/** Closes the NeXus file opened with NDFileNexus::openFile */
asynStatus NDFileNexus::closeFile() {
asynStatus status = asynSuccess;
NXstatus nxstat;
static const char *functionName = "closeFile";
/*Print trace information if level is set correctly */
asynPrint(this->pasynUserSelf, ASYN_TRACE_FLOW,
"Entering %s:%s\n", driverName, functionName );
/* close the nexus file */
nxstat = NXclose(&nxFileHandle);
if (nxstat == NX_ERROR) {
asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
"Error %s:%s error closing file, status=%d\n", driverName, functionName, nxstat);
status = asynError;
}
this->imageNumber = 0;
/*Print trace information if level is set correctly */
asynPrint(this->pasynUserSelf, ASYN_TRACE_FLOW,
"Leaving %s:%s nxstat=%d\n", driverName, functionName, nxstat);
return status;
}
int main (int argc, char *argv[])
{
int i, j, k, n, NXrank, NXdims[32], NXtype, NXlen, entry_status, attr_status;
float r;
void *data_buffer;
unsigned char i1_array[4] = {1, 2, 3, 4};
short int i2_array[4] = {1000, 2000, 3000, 4000};
int i4_array[4] = {1000000, 2000000, 3000000, 4000000};
float r4_array[5][4] =
{{1., 2., 3., 4.}, {5., 6., 7., 8.}, {9., 10., 11., 12.}, {13., 14., 15., 16.}, {17., 18., 19., 20.}};
double r8_array[5][4] =
{{1., 2., 3., 4.}, {5., 6., 7., 8.}, {9., 10., 11., 12.}, {13., 14., 15., 16.}, {17., 18., 19., 20.}};
int array_dims[2] = {5, 4};
int unlimited_dims[1] = {NX_UNLIMITED};
int chunk_size[2]={5,4};
int slab_start[2], slab_size[2];
char name[64], char_class[64], char_buffer[128];
char group_name[64], class_name[64];
char c1_array[5][4] = {{'a', 'b', 'c' ,'d'}, {'e', 'f', 'g' ,'h'},
{'i', 'j', 'k', 'l'}, {'m', 'n', 'o', 'p'}, {'q', 'r', 's' , 't'}};
int unlimited_cdims[2] = {NX_UNLIMITED, 4};
NXhandle fileid, clone_fileid;
NXlink glink, dlink, blink;
int comp_array[100][20];
int dims[2];
int cdims[2];
int nx_creation_code;
char nxFile[80];
char filename[256];
int64_t grossezahl[4];
const char* ch_test_data = "NeXus ><}&{'\\&\" Data";
char path[512];
grossezahl[0] = 12;
grossezahl[2] = 23;
#if HAVE_LONG_LONG_INT
grossezahl[1] = (int64_t)555555555555LL;
grossezahl[3] = (int64_t)777777777777LL;
#else
grossezahl[1] = (int64_t)555555555555;
grossezahl[3] = (int64_t)777777777777;
#endif /* HAVE_LONG_LONG_INT */
if(strstr(argv[0],"napi_test-hdf5") != NULL){
nx_creation_code = NXACC_CREATE5;
strcpy(nxFile,"NXtest.h5");
}else if(strstr(argv[0],"napi_test-xml-table") != NULL){
nx_creation_code = NXACC_CREATEXML | NXACC_TABLE;
strcpy(nxFile,"NXtest-table.xml");
}else if(strstr(argv[0],"napi_test-xml") != NULL){
nx_creation_code = NXACC_CREATEXML;
strcpy(nxFile,"NXtest.xml");
} else {
nx_creation_code = NXACC_CREATE;
strcpy(nxFile,"NXtest.hdf");
}
/* create file */
if (NXopen (nxFile, nx_creation_code, &fileid) != NX_OK) return 1;
if (nx_creation_code == NXACC_CREATE5)
{
if (NXreopen (fileid, &clone_fileid) != NX_OK) return 1;
}
NXsetnumberformat(fileid,NX_FLOAT32,"%9.3f");
if (NXmakegroup (fileid, "entry", "NXentry") != NX_OK) return 1;
if (NXopengroup (fileid, "entry", "NXentry") != NX_OK) return 1;
if(NXputattr(fileid,"hugo","namenlos",strlen("namenlos"), NX_CHAR) != NX_OK) return 1;
if(NXputattr(fileid,"cucumber","passion",strlen("passion"), NX_CHAR) != NX_OK) return 1;
NXlen = strlen(ch_test_data);
if (NXmakedata (fileid, "ch_data", NX_CHAR, 1, &NXlen) != NX_OK) return 1;
if (NXopendata (fileid, "ch_data") != NX_OK) return 1;
if (NXputdata (fileid, ch_test_data) != NX_OK) return 1;
if (NXclosedata (fileid) != NX_OK) return 1;
if (NXmakedata (fileid, "c1_data", NX_CHAR, 2, array_dims) != NX_OK) return 1;
if (NXopendata (fileid, "c1_data") != NX_OK) return 1;
if (NXputdata (fileid, c1_array) != NX_OK) return 1;
if (NXclosedata (fileid) != NX_OK) return 1;
if (NXmakedata (fileid, "i1_data", NX_INT8, 1, &array_dims[1]) != NX_OK) return 1;
if (NXopendata (fileid, "i1_data") != NX_OK) return 1;
if (NXputdata (fileid, i1_array) != NX_OK) return 1;
if (NXclosedata (fileid) != NX_OK) return 1;
if (NXmakedata (fileid, "i2_data", NX_INT16, 1, &array_dims[1]) != NX_OK) return 1;
if (NXopendata (fileid, "i2_data") != NX_OK) return 1;
if (NXputdata (fileid, i2_array) != NX_OK) return 1;
if (NXclosedata (fileid) != NX_OK) return 1;
if (NXmakedata (fileid, "i4_data", NX_INT32, 1, &array_dims[1]) != NX_OK) return 1;
if (NXopendata (fileid, "i4_data") != NX_OK) return 1;
if (NXputdata (fileid, i4_array) != NX_OK) return 1;
if (NXclosedata (fileid) != NX_OK) return 1;
if (NXcompmakedata (fileid, "r4_data", NX_FLOAT32, 2, array_dims,NX_COMP_LZW,chunk_size) != NX_OK) return 1;
if (NXopendata (fileid, "r4_data") != NX_OK) return 1;
if (NXputdata (fileid, r4_array) != NX_OK) return 1;
if (NXclosedata (fileid) != NX_OK) return 1;
if (NXmakedata (fileid, "r8_data", NX_FLOAT64, 2, array_dims) != NX_OK) return 1;
if (NXopendata (fileid, "r8_data") != NX_OK) return 1;
slab_start[0] = 4; slab_start[1] = 0; slab_size[0] = 1; slab_size[1] = 4;
if (NXputslab (fileid, (double*)r8_array + 16, slab_start, slab_size) != NX_OK) return 1;
slab_start[0] = 0; slab_start[1] = 0; slab_size[0] = 4; slab_size[1] = 4;
if (NXputslab (fileid, r8_array, slab_start, slab_size) != NX_OK) return 1;
if (NXputattr (fileid, "ch_attribute", ch_test_data, strlen (ch_test_data), NX_CHAR) != NX_OK) return 1;
i = 42;
if (NXputattr (fileid, "i4_attribute", &i, 1, NX_INT32) != NX_OK) return 1;
r = 3.14159265;
if (NXputattr (fileid, "r4_attribute", &r, 1, NX_FLOAT32) != NX_OK) return 1;
if (NXgetdataID (fileid, &dlink) != NX_OK) return 1;
if (NXclosedata (fileid) != NX_OK) return 1;
dims[0] = 4;
if (nx_creation_code != NXACC_CREATE)
{
if (NXmakedata (fileid, "grosse_zahl", NX_INT64, 1,dims) == NX_OK) {
if (NXopendata (fileid, "grosse_zahl") != NX_OK) return 1;
if (NXputdata (fileid, grossezahl) != NX_OK) return 1;
if (NXclosedata (fileid) != NX_OK) return 1;
}
}
if (NXmakegroup (fileid, "data", "NXdata") != NX_OK) return 1;
if (NXopengroup (fileid, "data", "NXdata") != NX_OK) return 1;
if (NXmakelink (fileid, &dlink) != NX_OK) return 1;
dims[0] = 100;
dims[1] = 20;
for(i = 0; i < 100; i++)
{
for(j = 0; j < 20; j++)
{
comp_array[i][j] = i;
}
}
cdims[0] = 20;
cdims[1] = 20;
if (NXcompmakedata (fileid, "comp_data", NX_INT32, 2, dims, NX_COMP_LZW, cdims) != NX_OK) return 1;
if (NXopendata (fileid, "comp_data") != NX_OK) return 1;
if (NXputdata (fileid, comp_array) != NX_OK) return 1;
if (NXclosedata (fileid) != NX_OK) return 1;
if (NXflush (&fileid) != NX_OK) return 1;
if (NXmakedata (fileid, "flush_data", NX_INT32, 1, unlimited_dims) != NX_OK) return 1;
slab_size[0] = 1;
for (i = 0; i < 7; i++)
{
slab_start[0] = i;
if (NXopendata (fileid, "flush_data") != NX_OK) return 1;
if (NXputslab (fileid, &i, slab_start, slab_size) != NX_OK) return 1;
if (NXflush (&fileid) != NX_OK) return 1;
}
if (NXclosegroup (fileid) != NX_OK) return 1;
if (NXmakegroup (fileid, "sample", "NXsample") != NX_OK) return 1;
if (NXopengroup (fileid, "sample", "NXsample") != NX_OK) return 1;
NXlen = 12;
if (NXmakedata (fileid, "ch_data", NX_CHAR, 1, &NXlen) != NX_OK) return 1;
if (NXopendata (fileid, "ch_data") != NX_OK) return 1;
if (NXputdata (fileid, "NeXus sample") != NX_OK) return 1;
if (NXclosedata (fileid) != NX_OK) return 1;
if (NXgetgroupID (fileid, &glink) != NX_OK) return 1;
if (( nx_creation_code & NXACC_CREATEXML) == 0 ) {
if (NXmakedata (fileid, "cdata_unlimited", NX_CHAR, 2, unlimited_cdims) != NX_OK) return 1;
if (NXopendata (fileid, "cdata_unlimited") != NX_OK) return 1;
slab_size[0] = 1;
slab_size[1] = 4;
slab_start[1] = 0;
for (i = 0; i < 5; i++)
{
slab_start[0] = i;
if (NXputslab (fileid, &(c1_array[i][0]), slab_start, slab_size) != NX_OK) return 1;
}
if (NXclosedata (fileid) != NX_OK) return 1;
}
if (NXclosegroup (fileid) != NX_OK) return 1;
if (NXclosegroup (fileid) != NX_OK) return 1;
if (NXmakegroup (fileid, "link", "NXentry") != NX_OK) return 1;
if (NXopengroup (fileid, "link", "NXentry") != NX_OK) return 1;
if (NXmakelink (fileid, &glink) != NX_OK) return 1;
if (NXmakenamedlink (fileid,"renLinkGroup", &glink) != NX_OK) return 1;
if (NXmakenamedlink (fileid, "renLinkData", &dlink) != NX_OK) return 1;
if (NXclosegroup (fileid) != NX_OK) return 1;
if (NXclose (&fileid) != NX_OK) return 1;
if ( (argc >= 2) && !strcmp(argv[1], "-q") )
{
return 0; /* create only */
}
/*
read test
*/
if (NXopen (nxFile, NXACC_RDWR,&fileid) != NX_OK) return 1;
if(NXinquirefile(fileid,filename,256) != NX_OK){
return 1;
}
printf("NXinquirefile found: %s\n", relativePathOf(filename));
NXgetattrinfo (fileid, &i);
if (i > 0) {
printf ("Number of global attributes: %d\n", i);
}
do {
attr_status = NXgetnextattr (fileid, name, NXdims, &NXtype);
if (attr_status == NX_ERROR) return 1;
if (attr_status == NX_OK) {
switch (NXtype) {
case NX_CHAR:
NXlen = sizeof (char_buffer);
if (NXgetattr (fileid, name, char_buffer, &NXlen, &NXtype)
!= NX_OK) return 1;
if ( strcmp(name, "file_time") &&
strcmp(name, "HDF_version") &&
strcmp(name, "HDF5_Version") &&
strcmp(name, "XML_version") )
{
printf (" %s = %s\n", name, char_buffer);
}
break;
}
}
} while (attr_status == NX_OK);
if (NXopengroup (fileid, "entry", "NXentry") != NX_OK) return 1;
NXgetattrinfo(fileid,&i);
printf("Number of group attributes: %d\n", i);
if(NXgetpath(fileid,path,512) != NX_OK)return 1;
printf("NXentry path %s\n", path);
do {
attr_status = NXgetnextattr (fileid, name, NXdims, &NXtype);
if (attr_status == NX_ERROR) return 1;
if (attr_status == NX_OK) {
switch (NXtype) {
case NX_CHAR:
NXlen = sizeof (char_buffer);
if (NXgetattr (fileid, name, char_buffer, &NXlen, &NXtype)
!= NX_OK) return 1;
printf (" %s = %s\n", name, char_buffer);
}
}
} while (attr_status == NX_OK);
if (NXgetgroupinfo (fileid, &i, group_name, class_name) != NX_OK) return 1;
printf ("Group: %s(%s) contains %d items\n", group_name, class_name, i);
do {
entry_status = NXgetnextentry (fileid, name, char_class, &NXtype);
if (entry_status == NX_ERROR) return 1;
if (strcmp(char_class,"SDS") != 0) {
if (entry_status != NX_EOD) {
printf (" Subgroup: %s(%s)\n", name, char_class);
entry_status = NX_OK;
}
} else {
if (entry_status == NX_OK) {
if (NXopendata (fileid, name) != NX_OK) return 1;
if(NXgetpath(fileid,path,512) != NX_OK)return 1;
printf("Data path %s\n", path);
if (NXgetinfo (fileid, &NXrank, NXdims, &NXtype) != NX_OK) return 1;
printf (" %s(%d)", name, NXtype);
if (NXmalloc ((void **) &data_buffer, NXrank, NXdims, NXtype) != NX_OK) return 1;
n = 1;
for(k=0; k<NXrank; k++)
{
n *= NXdims[k];
}
if (NXtype == NX_CHAR) {
if (NXgetdata (fileid, data_buffer) != NX_OK) return 1;
print_data (" = ", data_buffer, NXtype, n);
} else if (NXtype != NX_FLOAT32 && NXtype != NX_FLOAT64) {
if (NXgetdata (fileid, data_buffer) != NX_OK) return 1;
print_data (" = ", data_buffer, NXtype, n);
} else {
slab_start[0] = 0;
slab_start[1] = 0;
slab_size[0] = 1;
slab_size[1] = 4;
if (NXgetslab (fileid, data_buffer, slab_start, slab_size) != NX_OK) return 1;
print_data ("\n ", data_buffer, NXtype, 4);
slab_start[0] = 1;
if (NXgetslab (fileid, data_buffer, slab_start, slab_size) != NX_OK) return 1;
print_data (" ", data_buffer, NXtype, 4);
slab_start[0] = 2;
if (NXgetslab (fileid, data_buffer, slab_start, slab_size) != NX_OK) return 1;
print_data (" ", data_buffer, NXtype, 4);
slab_start[0] = 3;
if (NXgetslab (fileid, data_buffer, slab_start, slab_size) != NX_OK) return 1;
print_data (" ", data_buffer, NXtype, 4);
slab_start[0] = 4;
if (NXgetslab (fileid, data_buffer, slab_start, slab_size) != NX_OK) return 1;
print_data (" ", data_buffer, NXtype, 4);
if (NXgetattrinfo (fileid, &i) != NX_OK) return 1;
if (i > 0) {
printf (" Number of attributes : %d\n", i);
}
do {
attr_status = NXgetnextattr (fileid, name, NXdims, &NXtype);
if (attr_status == NX_ERROR) return 1;
if (attr_status == NX_OK) {
switch (NXtype) {
case NX_INT32:
NXlen = 1;
if (NXgetattr (fileid, name, &i, &NXlen, &NXtype) != NX_OK) return 1;
printf (" %s : %d\n", name, i);
break;
case NX_FLOAT32:
NXlen = 1;
if (NXgetattr (fileid, name, &r, &NXlen, &NXtype) != NX_OK) return 1;
printf (" %s : %f\n", name, r);
break;
case NX_CHAR:
NXlen = sizeof (char_buffer);
if (NXgetattr (fileid, name, char_buffer, &NXlen, &NXtype) != NX_OK) return 1;
printf (" %s : %s\n", name, char_buffer);
break;
}
}
} while (attr_status == NX_OK);
}
if (NXclosedata (fileid) != NX_OK) return 1;
if (NXfree ((void **) &data_buffer) != NX_OK) return 1;
}
}
} while (entry_status == NX_OK);
if (NXclosegroup (fileid) != NX_OK) return 1;
/*
* check links
*/
if (NXopengroup (fileid, "entry", "NXentry") != NX_OK) return 1;
if (NXopengroup (fileid, "sample", "NXsample") != NX_OK) return 1;
if (NXgetgroupID (fileid, &glink) != NX_OK) return 1;
if (NXclosegroup (fileid) != NX_OK) return 1;
if (NXopengroup (fileid, "data", "NXdata") != NX_OK) return 1;
if (NXopendata (fileid, "r8_data") != NX_OK) return 1;
if (NXgetdataID (fileid, &dlink) != NX_OK) return 1;
if (NXclosedata (fileid) != NX_OK) return 1;
if (NXclosegroup (fileid) != NX_OK) return 1;
if (NXopendata (fileid, "r8_data") != NX_OK) return 1;
if (NXgetdataID (fileid, &blink) != NX_OK) return 1;
if (NXclosedata (fileid) != NX_OK) return 1;
if (NXsameID(fileid, &dlink, &blink) != NX_OK)
{
printf ("Link check FAILED (r8_data)\n");
printf ("original data\n");
NXIprintlink(fileid, &dlink);
printf ("linked data\n");
NXIprintlink(fileid, &blink);
return 1;
}
if (NXclosegroup (fileid) != NX_OK) return 1;
if (NXopengroup (fileid, "link", "NXentry") != NX_OK) return 1;
if (NXopengroup (fileid, "sample", "NXsample") != NX_OK) return 1;
if(NXgetpath(fileid,path,512) != NX_OK)return 1;
printf("Group path %s\n", path);
if (NXgetgroupID (fileid, &blink) != NX_OK) return 1;
if (NXsameID(fileid, &glink, &blink) != NX_OK)
{
printf ("Link check FAILED (sample)\n");
printf ("original group\n");
NXIprintlink(fileid, &glink);
printf ("linked group\n");
NXIprintlink(fileid, &blink);
return 1;
}
if (NXclosegroup (fileid) != NX_OK) return 1;
if (NXopengroup (fileid, "renLinkGroup", "NXsample") != NX_OK) return 1;
if (NXgetgroupID (fileid, &blink) != NX_OK) return 1;
if (NXsameID(fileid, &glink, &blink) != NX_OK)
{
printf ("Link check FAILED (renLinkGroup)\n");
printf ("original group\n");
NXIprintlink(fileid, &glink);
printf ("linked group\n");
NXIprintlink(fileid, &blink);
return 1;
}
if (NXclosegroup (fileid) != NX_OK) return 1;
if(NXopendata(fileid,"renLinkData") != NX_OK) return 1;
if(NXgetdataID(fileid,&blink) != NX_OK) return 1;
if (NXsameID(fileid, &dlink, &blink) != NX_OK)
{
printf ("Link check FAILED (renLinkData)\n");
printf ("original group\n");
NXIprintlink(fileid, &glink);
printf ("linked group\n");
NXIprintlink(fileid, &blink);
return 1;
}
if(NXclosedata(fileid) != NX_OK) return 1;
if (NXclosegroup (fileid) != NX_OK) return 1;
printf ("Link check OK\n");
/*
tests for NXopenpath
*/
if(NXopenpath(fileid,"/entry/data/comp_data") != NX_OK){
printf("Failure on NXopenpath\n");
return 0;
}
if(NXopenpath(fileid,"/entry/data/comp_data") != NX_OK){
printf("Failure on NXopenpath\n");
return 0;
}
if(NXopenpath(fileid,"../r8_data") != NX_OK){
printf("Failure on NXopenpath\n");
return 0;
}
if(NXopengrouppath(fileid,"/entry/data/comp_data") != NX_OK){
printf("Failure on NXopengrouppath\n");
return 0;
}
if(NXopenpath(fileid,"/entry/data/r8_data") != NX_OK){
printf("Failure on NXopenpath\n");
return 0;
}
printf("NXopenpath checks OK\n");
if (NXclose (&fileid) != NX_OK) return 1;
printf("before load path tests\n");
if(testLoadPath() != 0) return 1;
printf("before external link tests\n");
if(testExternal(argv[0]) != 0) {
return 1;
}
printf("all ok - done\n");
return 0;
}
/*---------------------------------------------------------------------*/
static int testExternal(char *progName){
char nxfile[255], ext[5], testFile[80], time[132], filename[256];
int create;
NXhandle hfil;
int dummylen = 1;
float dummyfloat = 1;
float temperature;
if(strstr(progName,"hdf4") != NULL){
strcpy(ext,"hdf");
create = NXACC_CREATE;
} else if(strstr(progName,"hdf5") != NULL){
strcpy(ext,"h5");
create = NXACC_CREATE5;
} else if(strstr(progName,"xml") != NULL){
strcpy(ext,"xml");
create = NXACC_CREATEXML;
} else {
printf("Failed to recognise napi_test program in testExternal\n");
return 1;
}
sprintf(testFile,"nxext.%s", ext);
/*
create the test file
*/
if(NXopen(testFile,create,&hfil) != NX_OK){
return 1;
}
/*if(NXmakegroup(hfil,"entry1","NXentry") != NX_OK){
return 1;
}*/
sprintf(nxfile,"nxfile://data/dmc01.%s#/entry1",ext);
if(NXlinkexternal(hfil,"entry1","NXentry",nxfile) != NX_OK){
return 1;
}
/*if(NXmakegroup(hfil,"entry2","NXentry") != NX_OK){
return 1;
}*/
sprintf(nxfile,"nxfile://data/dmc02.%s#/entry1",ext);
if(NXlinkexternal(hfil,"entry2","NXentry",nxfile) != NX_OK){
return 1;
}
if(NXmakegroup(hfil,"entry3","NXentry") != NX_OK){
return 1;
}
if(NXopengroup(hfil,"entry3","NXentry") != NX_OK){
return 1;
}
/* force create old style external link */
if (NXmakedata (hfil, "extlinkdata", NX_FLOAT32, 1, &dummylen) != NX_OK) return 1;
if (NXopendata (hfil, "extlinkdata") != NX_OK) return 1;
if (NXputdata (hfil, &dummyfloat) != NX_OK) return 1;
sprintf(nxfile,"nxfile://data/dmc01.%s#/entry1/sample/temperature_mean",ext);
if(NXputattr(hfil,"napimount",nxfile,strlen(nxfile), NX_CHAR) != NX_OK) return 1;
/* this would segfault because we are tricking the napi stack
if(NXclosedata(&hfil) != NX_OK){
return 1;
}
*/
if(NXopenpath(hfil,"/entry3") != NX_OK){
return 1;
}
/* create new style external link on hdf5 , equivalent to the above on other backends */
if (NXlinkexternaldataset(hfil, "extlinknative", nxfile) != NX_OK) return 1;
if(NXclose(&hfil) != NX_OK){
return 1;
}
/*
actually test linking
*/
if(NXopen(testFile,NXACC_RDWR,&hfil) != NX_OK){
return 1;
}
if(NXopenpath(hfil,"/entry1/start_time") != NX_OK){
return 1;
}
memset(time,0,132);
if(NXgetdata(hfil,time) != NX_OK){
return 1;
}
printf("First file time: %s\n", time);
if(NXinquirefile(hfil,filename,256) != NX_OK){
return 1;
}
printf("NXinquirefile found: %s\n", relativePathOf(filename));
if(NXopenpath(hfil,"/entry2/sample/sample_name") != NX_OK){
return 1;
}
memset(time,0,132);
if(NXgetdata(hfil,time) != NX_OK){
return 1;
}
printf("Second file sample: %s\n", time);
if(NXinquirefile(hfil,filename,256) != NX_OK){
return 1;
}
printf("NXinquirefile found: %s\n", relativePathOf(filename));
if(NXopenpath(hfil,"/entry2/start_time") != NX_OK){
return 1;
}
memset(time,0,132);
if(NXgetdata(hfil,time) != NX_OK){
return 1;
}
printf("Second file time: %s\n", time);
NXopenpath(hfil,"/");
if(NXisexternalgroup(hfil,"entry1","NXentry",filename,255) != NX_OK){
return 1;
} else {
printf("entry1 external URL = %s\n", filename);
}
printf("testing link to external data set\n");
if(NXopenpath(hfil,"/entry3") != NX_OK){
return 1;
}
if(NXisexternaldataset(hfil,"extlinkdata",filename,255) != NX_OK){
printf("extlinkdata should be external link\n");
return 1;
} else {
printf("extlinkdata external URL = %s\n", filename);
}
if (NXopendata (hfil, "extlinkdata") != NX_OK) return 1;
memset(&temperature,0,4);
if(NXgetdata(hfil,&temperature) != NX_OK){
return 1;
}
printf("value retrieved: %4.2f\n", temperature);
if(NXopenpath(hfil,"/entry3") != NX_OK){
return 1;
}
if(NXisexternaldataset(hfil,"extlinknative",filename,255) != NX_OK){
printf("extlinknative should be external link\n");
return 1;
} else {
printf("extlinknative external URL = %s\n", filename);
}
if (NXopendata (hfil, "extlinknative") != NX_OK) return 1;
memset(&temperature,0,4);
if(NXgetdata(hfil,&temperature) != NX_OK){
return 1;
}
printf("value retrieved: %4.2f\n", temperature);
NXclose(&hfil);
printf("External File Linking tested OK\n");
return 0;
}
/*------------------------------------------------------------------------*/
static pNEventArray loadAMOR(char *filename)
{
NXhandle handle;
int32_t dim[3];
int status, i, j, k, l, nCount, rank, type;
unsigned int size, offset;
int32_t *data = NULL;
float *tof = NULL;
int32_t iTof;
unsigned long nEvents;
pNEventArray evData = NULL;
unsigned int detID = -1;
status = NXopen(filename,NXACC_READ,&handle);
if(status != NX_OK) {
printf("Failed to open NeXus file %s\n", filename);
return NULL;
}
status = NXopenpath(handle,"/entry1/AMOR/area_detector/data");
if(status != NX_OK) {
printf("NeXus file %s in wrong format\n", filename);
return NULL;
}
NXgetinfo(handle,&rank,dim,&type);
for(i = 1, size = dim[0]; i < 3; i++) {
size *= dim[i];
}
data = malloc(size*sizeof(int32_t));
tof = malloc(dim[2]*sizeof(float));
if(data == NULL || tof == NULL ) {
printf("failed to allocate memory for NeXus data\n");
return NULL;
}
NXgetdata(handle,data);
status = NXopenpath(handle,"/entry1/AMOR/area_detector/time_binning");
if(status != NX_OK) {
printf("NeXus file %s in wrong format\n", filename);
return NULL;
}
NXgetdata(handle,tof);
NXclose(&handle);
nEvents = countNeutrons(data,size);
evData = createNEventArray(nEvents);
if(evData == NULL) {
return NULL;
}
printf("%s contains %ld neutrons\n",filename,nEvents);
nEvents = 0;
for(i = 0; i < dim[0]; i++) {
for(j = 0; j < dim[1]; j++) {
detID++;
offset = i*dim[1]*dim[2] + j*dim[2];
for(k = 0; k < dim[2]; k++) {
nCount = data[offset+k];
iTof = round(tof[k]/10.);
for(l = 0; l < nCount; l++) {
evData->detectorID[nEvents] = detID;
evData->timeStamp[nEvents] = iTof;
nEvents++;
}
}
}
}
return evData;
}
/** Execute the algorithm. Currently just calls SaveISISNexusProcessed but could
* call write other formats if support added
*
* @throw runtime_error Thrown if algorithm cannot execute
*/
void SaveISISNexus::exec() {
// Retrieve the filename from the properties
inputFilename = getPropertyValue("InputFileName");
m_isisRaw = new ISISRAW2;
rawFile = fopen(inputFilename.c_str(), "rb");
if (rawFile == nullptr) {
throw Exception::FileError("Cannot open file ", inputFilename);
}
m_isisRaw->ioRAW(rawFile, true);
nper = m_isisRaw->t_nper; // number of periods
nsp = m_isisRaw->t_nsp1; // number of spectra
ntc = m_isisRaw->t_ntc1; // number of time channels
nmon = m_isisRaw->i_mon; // number of monitors
ndet = m_isisRaw->i_det; // number of detectors
std::string outputFilename = getPropertyValue("OutputFileName");
NXstatus status;
float flt;
status = NXopen(outputFilename.c_str(), NXACC_CREATE5, &handle);
if (status != NX_OK) {
throw std::runtime_error("Cannot open file " + outputFilename +
" for writing.");
}
NXmakegroup(handle, "raw_data_1", "NXentry");
NXopengroup(handle, "raw_data_1", "NXentry");
write_isis_vms_compat();
saveString("beamline", " ");
flt = static_cast<float>(m_isisRaw->rpb.r_dur); // could be wrong
saveFloatOpen("collection_time", &flt, 1);
putAttr("units", "second");
close();
saveStringOpen("definition", "TOFRAW");
putAttr("version", "1.0");
putAttr("url",
"http://definition.nexusformat.org/instruments/TOFRAW/?version=1.0");
close();
saveStringOpen("definition_local", "ISISTOFRAW");
putAttr("version", "1.0");
putAttr("url",
"http://svn.isis.rl.ac.uk/instruments/ISISTOFRAW/?version=1.0");
close();
flt = static_cast<float>(m_isisRaw->rpb.r_dur);
saveFloatOpen("duration", &flt, 1);
putAttr("units", "second");
close();
start_time_str.assign(m_isisRaw->hdr.hd_date, m_isisRaw->hdr.hd_date + 12);
toISO8601(start_time_str);
start_time_str += 'T';
start_time_str +=
std::string(m_isisRaw->hdr.hd_time, m_isisRaw->hdr.hd_time + 8);
saveCharOpen("start_time", &start_time_str[0], 19);
putAttr("units", "ISO8601");
close();
std::string str;
str.assign(m_isisRaw->rpb.r_enddate, m_isisRaw->rpb.r_enddate + 12);
toISO8601(str);
str += 'T';
str += std::string(m_isisRaw->rpb.r_endtime, m_isisRaw->rpb.r_endtime + 8);
saveCharOpen("end_time", &str[0], 19);
putAttr("units", "ISO8601");
close();
saveChar("title", m_isisRaw->r_title, 80);
saveInt("good_frames", &m_isisRaw->rpb.r_goodfrm);
std::string experiment_identifier = std::to_string(m_isisRaw->rpb.r_prop);
saveChar("experiment_identifier", &experiment_identifier[0],
static_cast<int>(experiment_identifier.size()));
int tmp_int(0);
saveInt("measurement_first_run", &tmp_int);
saveString("measurement_id", " ");
saveString("measurement_label", " ");
saveString("measurement_subid", " ");
saveString("measurement_type", " ");
saveCharOpen("name", &m_isisRaw->i_inst, 8);
putAttr("short_name", m_isisRaw->hdr.inst_abrv, 3);
close();
logNotes();
saveString("program_name", "isisicp");
saveFloatOpen("proton_charge", &m_isisRaw->rpb.r_gd_prtn_chrg, 1);
putAttr("units", "uamp.hour");
close();
saveFloatOpen("proton_charge_raw", &m_isisRaw->rpb.r_tot_prtn_chrg, 1);
putAttr("units", "uamp.hour");
close();
saveInt("raw_frames", &m_isisRaw->rpb.r_rawfrm);
run_cycle();
saveInt("run_number", &m_isisRaw->r_number);
// script_name
// seci_config
instrument();
make_detector_1_link();
write_monitors();
user();
sample();
runlog();
selog();
NXclosegroup(handle); // raw_data_1
status = NXclose(&handle);
delete m_isisRaw;
}
int main(int argc, char *argv[])
{
char fileName[256], oldwd[256], *command, *dimensions, *stringPtr;
char prompt[512];
char *inputText;
NXname dataName;
int status;
#if HAVE_LIBREADLINE
rl_readline_name = "NXbrowse";
rl_attempted_completion_function = nxbrowse_complete;
#if READLINE_VERSION >= 0x500
rl_catch_signals = 0;
#else
#define rl_crlf() fprintf(rl_outstream, "\r\n");
#define rl_on_new_line() 1
#endif
using_history();
#else
#define rl_crlf()
#define rl_on_new_line()
#define add_history(a)
#endif
printf("NXBrowse %s Copyright (C) 2009-2014 NeXus Data Format\n",
NEXUS_VERSION);
#if HAVE_LIBREADLINE
printf
("Built with readline support - use <TAB> to complete commands and paths\n");
#endif /* HAVE_LIBREADLINE */
/* if there is a filename given on the command line use that,
else ask for a filename */
if (argc < 2) {
printf("Give name of NeXus file : ");
if (fgets(fileName, sizeof(fileName), stdin) == NULL) {
printf("Failed to open %s\n", fileName);
return NX_ERROR;
}
if ((stringPtr = strchr(fileName, '\n')) != NULL)
*stringPtr = '\0';
} else {
strcpy(fileName, argv[1]);
}
strcpy(nxFile, fileName);
/* Open input file and output global attributes */
if (NXopen(fileName, NXACC_READ, &the_fileId) != NX_OK) {
printf("NX_ERROR: Can't open %s\n", fileName);
return NX_ERROR;
}
PrintAttributes(the_fileId);
iByteAsChar = 0; /* Display remaining NX_INT8 and NX_UINT8 variables as integers by default */
/* Input commands until the EXIT command is given */
strcpy(oldwd, "/");
strcpy(path, "/");
do {
sprintf(prompt, "NX%s> ", path);
if (getenv("NO_READLINE") != NULL) {
inputText = my_readline(prompt);
} else {
inputText = readline(prompt);
}
if (inputText == NULL) {
inputText = strdup("EXIT");
}
if (*inputText) {
add_history(inputText);
}
command = strtok(inputText, " ");
/* Check if a command has been given */
if (command == NULL)
command = " ";
/* Convert it to upper case characters */
ConvertUpperCase(command);
if (StrEq(command, "PWD")) {
fprintf(rl_outstream, "%s\n", path);
}
if (StrEq(command, "TEST")) {
char a[256], b[256];
stringPtr = strtok(NULL, " ");
if (stringPtr != NULL) {
parsepath(stringPtr, a, b);
fprintf(rl_outstream," you entered >%s< - i think the full path is >%s< and the final component looks like this >%s<.\n", stringPtr, a, b);
} else {
fprintf(rl_outstream," you entered nothing\n");
}
}
/* Command is to print a directory of the current group */
if (StrEq(command, "DIR") || StrEq(command, "LS")) {
stringPtr = strtok(NULL, " ");
if (stringPtr != NULL) {
char a[256], b[256];
parsepath(stringPtr, a, b);
strcat(a, "/");
strcat(a, b);
NXopengrouppath(the_fileId, a);
NXBdir(the_fileId);
NXopengrouppath(the_fileId, path);
} else {
NXBdir(the_fileId);
}
}
/* Command is to open the specified group */
if (StrEq(command, "OPEN") || StrEq(command, "CD")) {
stringPtr = strtok(NULL, " ");
if (stringPtr != NULL) {
char a[256], b[256];
if (StrEq(stringPtr, "-")) {
stringPtr = oldwd;
}
parsepath(stringPtr, a, b);
strcat(a, "/");
strcat(a, b);
status = NXopengrouppath(the_fileId, a);
if (status == NX_OK) {
strcpy(oldwd, path);
strcpy(path, a);
} else {
fprintf(rl_outstream, "NX_ERROR: cannot change into %s\n", stringPtr);
NXopengrouppath(the_fileId, path); /* to be sure */
}
} else {
fprintf(rl_outstream, "NX_ERROR: Specify a group\n");
}
}
/* Command is to dump data values to a file */
if (StrEq(command, "DUMP")) {
stringPtr = strtok(NULL, " ");
if (stringPtr != NULL) {
strcpy(dataName, stringPtr);
stringPtr = strtok(NULL, " ");
if (stringPtr != NULL) {
strcpy(fileName, stringPtr);
status = NXBdump(the_fileId, dataName, fileName);
} else {
fprintf(rl_outstream, "NX_ERROR: Specify a dump file name \n");
}
} else {
fprintf(rl_outstream, "NX_ERROR: Specify a data item\n");
}
}
/* Command is to print the values of the data */
if (StrEq(command, "READ") || StrEq(command, "CAT")) {
stringPtr = strtok(NULL, " [");
if (stringPtr != NULL) {
strcpy(dataName, stringPtr);
dimensions = strtok(NULL, "[]");
status =
NXBread(the_fileId, dataName, dimensions);
} else {
fprintf(rl_outstream,
"NX_ERROR: Specify a data item\n");
}
}
/* Command is to close the current group */
if (StrEq(command, "CLOSE")) {
if (strlen(path) > 1) {
if (NXclosegroup(the_fileId) == NX_OK) {
/* Remove the group from the prompt string */
strcpy(oldwd, path);
stringPtr = strrchr(path, '/'); /* position of last group delimiter */
if (stringPtr != NULL)
*stringPtr = '\0'; /* terminate the string there */
}
} else {
fprintf(rl_outstream,
"NX_WARNING: Already at root level of file\n");
}
}
/* Command is to print help information */
if (StrEq(command, "HELP") || StrEq(command, "INFO")) {
printf("NXbrowse commands : DIR\n");
printf(" LS\n");
printf(" OPEN <groupName>\n");
printf(" CD <groupName>\n");
printf(" READ <dataName>\n");
printf(" READ <dataName>[<dimension indices...>]\n");
printf(" DUMP <dataName> <fileName> \n");
printf(" CLOSE\n");
printf(" BYTEASCHAR\n");
printf(" HELP\n");
printf(" EXIT\n");
printf("\n");
#if HAVE_LIBREADLINE
printf("Pressing <TAB> after a command or partial nexus object name will complete\n");
printf("possible names. For example:\n");
printf("\n");
printf(" cd ent<TAB KEY PRESSED> # all items starting with ent are listed\n");
printf("\n");
#endif
}
/* Command is to print byte as char information */
if (StrEq(command, "BYTEASCHAR")) {
if (iByteAsChar == 1)
iByteAsChar = 0;
else
iByteAsChar = 1;
}
/* Command is to exit the program */
if (StrEq(command, "EXIT") || StrEq(command, "QUIT")) {
/* for (i = groupLevel; i > 0; i--) NXclosegroup (the_fileId); */
NXclose(&the_fileId);
return NX_OK;
}
status = NX_OK;
free(inputText);
} while (status == NX_OK);
return NX_OK;
}
/** Get all the Nexus entry types for a file
*
* Try to open named Nexus file and return all entries plus the definition found for each.
* If definition not found, try and return "analysis" field (Muon V1 files)
* Closes file on exit.
*
* @param fileName :: file to open
* @param entryName :: vector that gets filled with strings with entry names
* @param definition :: vector that gets filled with the "definition" or "analysis" string.
* @return count of entries if OK, -1 failed to open file.
*/
int getNexusEntryTypes(const std::string& fileName, std::vector<std::string>& entryName,
std::vector<std::string>& definition )
{
//
//
NXhandle fileH;
NXaccess mode= NXACC_READ;
NXstatus stat=NXopen(fileName.c_str(), mode, &fileH);
if(stat==NX_ERROR) return(-1);
//
entryName.clear();
definition.clear();
char *nxname,*nxclass;
int nxdatatype;
nxname= new char[NX_MAXNAMELEN];
nxclass = new char[NX_MAXNAMELEN];
int rank,dims[2],type;
//
// Loop through all entries looking for the definition section in each (or analysis for MuonV1)
//
std::vector<std::string> entryList;
while( ( stat=NXgetnextentry(fileH,nxname,nxclass,&nxdatatype) ) == NX_OK )
{
std::string nxc(nxclass);
if(nxc.compare("NXentry")==0)
entryList.push_back(nxname);
}
// for each entry found, look for "analysis" or "definition" text data fields and return value plus entry name
for(size_t i=0;i<entryList.size();i++)
{
//
stat=NXopengroup(fileH,entryList[i].c_str(),"NXentry");
// loop through field names in this entry
while( ( stat=NXgetnextentry(fileH,nxname,nxclass,&nxdatatype) ) == NX_OK )
{
std::string nxc(nxclass),nxn(nxname);
// if a data field
if(nxc.compare("SDS")==0)
// if one of the two names we are looking for
if(nxn.compare("definition")==0 || nxn.compare("analysis")==0)
{
NXopendata(fileH,nxname);
stat=NXgetinfo(fileH,&rank,dims,&type);
if(stat==NX_ERROR)
continue;
char* value=new char[dims[0]+1];
stat=NXgetdata(fileH,value);
if(stat==NX_ERROR)
continue;
value[dims[0]]='\0';
// return e.g entryName "analysis"/definition "muonTD"
definition.push_back(value);
entryName.push_back(entryList[i]);
delete[] value;
NXclosegroup(fileH); // close data group, then entry
stat=NXclosegroup(fileH);
break;
}
}
}
stat=NXclose(&fileH);
delete[] nxname;
delete[] nxclass;
return(static_cast<int>(entryName.size()));
}
/** Performs the copying from the input to the output file,
* while modifying the data and time_of_flight fields.
*/
int SaveToSNSHistogramNexus::copy_file(const char *inFile, int nx_read_access,
const char *outFile,
int nx_write_access) {
int nx_is_definition = 0;
links_count = 0;
current_path[0] = '\0';
NXlink link;
/* Open NeXus input file and NeXus output file */
if (NXopen(inFile, nx_read_access, &inId) != NX_OK) {
printf("NX_ERROR: Can't open %s\n", inFile);
return NX_ERROR;
}
if (NXopen(outFile, nx_write_access, &outId) != NX_OK) {
printf("NX_ERROR: Can't open %s\n", outFile);
return NX_ERROR;
}
/* Output global attributes */
if (WriteAttributes(nx_is_definition) != NX_OK) {
return NX_ERROR;
}
/* Recursively cycle through the groups printing the contents */
if (WriteGroup(nx_is_definition) != NX_OK) {
return NX_ERROR;
}
/* close input */
if (NXclose(&inId) != NX_OK) {
return NX_ERROR;
}
// HDF5 only
{
/* now create any required links */
for (int i = 0; i < links_count; i++) {
if (NXopenpath(outId, links_to_make[i].to) != NX_OK)
return NX_ERROR;
if (NXgetdataID(outId, &link) == NX_OK ||
NXgetgroupID(outId, &link) == NX_OK) {
if (NXopenpath(outId, links_to_make[i].from) != NX_OK)
return NX_ERROR;
char *tstr = strrchr(links_to_make[i].to, '/');
if (!strcmp(links_to_make[i].name, tstr + 1)) {
if (NXmakelink(outId, &link) != NX_OK)
return NX_ERROR;
} else {
if (NXmakenamedlink(outId, links_to_make[i].name, &link) != NX_OK)
return NX_ERROR;
}
} else {
return NX_ERROR;
}
}
}
/* Close the input and output files */
if (NXclose(&outId) != NX_OK) {
return NX_ERROR;
}
return NX_OK;
}
/*-----------------------------------------------------------------------*/
void nx_close(void *hundle){
NXhandle handle;
handle = (NXhandle)hundle;
NXclose(&handle);
}
