/** * Save a vector of string in a dataset. * @param name :: Name of the data set * @param str_vec :: The vector to save * @param max_str_size :: The maximum string size * @return The line size */ int SaveISISNexus::saveStringVectorOpen(const char *name, const std::vector<std::string> &str_vec, int max_str_size) { if (str_vec.empty()) { saveStringOpen(name, " "); return 0; } int buff_size = max_str_size; if (buff_size <= 0) for (const auto &str : str_vec) { buff_size = std::max(buff_size, int(str.size())); } if (buff_size <= 0) buff_size = 1; auto buff = new char[buff_size]; int dim[2]; dim[0] = static_cast<int>(str_vec.size()); dim[1] = buff_size; NXmakedata(handle, name, NX_CHAR, 2, dim); NXopendata(handle, name); for (std::size_t i = 0; i < str_vec.size(); ++i) { int start[] = {static_cast<int>(i), 0}; int sizes[] = {1, buff_size}; const char *str = str_vec[i].c_str(); std::fill_n(buff, buff_size, ' '); int n = std::min(buff_size, int(str_vec[i].size())); std::copy(str, str + n, buff); NXputslab(handle, buff, start, sizes); } delete[] buff; return buff_size; }
/** * Write monitor_i gorup * @param i Index of a monitor */ void SaveISISNexus::monitor_i(int i) { int nper = m_isisRaw->t_nper; // number of periods int ntc = m_isisRaw->t_ntc1; // number of time channels int dim[] = {nper, 1, ntc}; int size[] = {1, 1, ntc}; std::ostringstream ostr; int mon_num = i + 1; ostr << "monitor_" << mon_num; NXmakegroup(handle, ostr.str().c_str(), "NXmonitor"); NXopengroup(handle, ostr.str().c_str(), "NXmonitor"); // int imon = m_isisRaw->mdet[i]; // spectrum number NXmakedata(handle, "data", NX_INT32, 3, dim); NXopendata(handle, "data"); for (int p = 0; p < nper; ++p) { int start[] = {p, 0, 0}; NXputslab(handle, getMonitorData(p, i), start, size); } putAttr("units", "counts"); putAttr("signal", 1); putAttr("axes", "period_index,spectrum_index,time_of_flight"); NXclosedata(handle); saveInt("monitor_number", &mon_num); NXmakelink(handle, &period_index_link); saveInt("spectrum_index", &m_isisRaw->mdet[i]); NXmakelink(handle, &time_of_flight_link); NXclosegroup(handle); }
int NDFileNexus::processStreamData(NDArray *pArray) { int fileWriteMode; int numCapture; int slabOffset[ND_ARRAY_MAX_DIMS]; int slabSize[ND_ARRAY_MAX_DIMS]; int rank; int ii; int addr = 0; //static const char *functionName = "processNode"; /* Must lock when accessing parameter library */ this->lock(); getIntegerParam(addr, NDFileWriteMode, &fileWriteMode); getIntegerParam(addr, NDFileNumCapture, &numCapture); this->unlock(); rank = pArray->ndims; for (ii=0; ii<rank; ii++) { switch(fileWriteMode) { case NDFileModeSingle: slabOffset[(rank-1) - ii] = 0; slabSize[(rank-1) -ii] = (int)pArray->dims[ii].size; break; case NDFileModeCapture: case NDFileModeStream: slabOffset[(rank) - ii] = 0; slabSize[(rank) -ii] = (int)pArray->dims[ii].size; break; } } //printf ("%s: dataPath %s\ndataName %s\nimageNumber %d\n", functionName, this->dataPath, this->dataName, this->imageNumber); if (this->imageNumber == 0) { NXopenpath( this->nxFileHandle, this->dataPath); NXopendata( this->nxFileHandle, this->dataName); } switch (fileWriteMode) { case NDFileModeSingle: NXputdata(this->nxFileHandle, pArray->pData); break; case NDFileModeCapture: case NDFileModeStream: rank = rank+1; slabOffset[0] = this->imageNumber; slabSize[0] = 1; NXputslab(this->nxFileHandle, pArray->pData, slabOffset, slabSize); break; } if (this-> imageNumber == (numCapture-1) ) { NXclosedata(this->nxFileHandle); NXclosegroup(this->nxFileHandle ); } this->imageNumber++; return 0; }
/*------------------------------------------------------------------------*/ int nx_putslab(void *handle, void *dataset, void *startDim){ int status; NXhandle hfil; pNXDS data; pNXDS start; int end[NX_MAXRANK], i; hfil = (NXhandle)handle; data = (pNXDS)dataset; start = (pNXDS)startDim; for(i = 0; i < data->rank;i++){ end[i] = data->dim[i]; } status = NXputslab(hfil,data->u.ptr,start->u.iPtr,end); if(status == NX_OK){ return 1; } else { return 0; } }
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; }
void SaveISISNexus::detector_1() { NXmakegroup(handle, "detector_1", "NXdata"); NXopengroup(handle, "detector_1", "NXdata"); for (int i = 0; i < nmon; ++i) { int si = int(std::distance( m_isisRaw->spec, std::find(m_isisRaw->spec, m_isisRaw->spec + nsp, m_isisRaw->mdet[i]))); monitor_index[si] = i; } // write counts int dim[3]; dim[0] = nper; dim[1] = nsp - nmon; dim[2] = ntc; NXmakedata(handle, "counts", NX_INT32, 3, dim); NXopendata(handle, "counts"); putAttr("units", "counts"); putAttr("signal", 1); putAttr("axes", "period_index,spectrum_index,time_of_flight"); int size[] = {1, 1, ntc}; int index = 0; for (int p = 0; p < nper; ++p) { int ispec = 0; m_isisRaw->skipData(rawFile, index++); for (int si = 0; si < nsp; ++si) { if (monitor_index.find(si) != monitor_index.end()) { m_isisRaw->readData(rawFile, index); monitorData.insert(monitorData.end(), m_isisRaw->dat1 + 1, m_isisRaw->dat1 + ntc + 1); } else { m_isisRaw->readData(rawFile, index); int start[] = {p, ispec, 0}; NXputslab(handle, m_isisRaw->dat1 + 1, start, size); ++ispec; } ++index; } } NXgetdataID(handle, &counts_link); NXclosedata(handle); NXmakelink(handle, &period_index_link); std::vector<int> spec_minus_monitors(nsp - nmon); std::generate(spec_minus_monitors.begin(), spec_minus_monitors.end(), getWithoutMonitors<int>(this, m_isisRaw->spec)); saveIntOpen("spectrum_index", &spec_minus_monitors[0], nsp - nmon); NXgetdataID(handle, &spectrum_index_link); close(); NXmakelink(handle, &time_of_flight_link); NXmakelink(handle, &time_of_flight_raw_link); std::vector<float> float_vec(ndet - nmon); std::generate(float_vec.begin(), float_vec.end(), getWithoutMonitors<float>(this, m_isisRaw->delt)); saveFloat("delt", &float_vec[0], ndet - nmon); saveFloat("source_detector_distance", &m_isisRaw->ivpb.i_sddist, 1); // using the same float_vec, size unchanged ndet-nmon std::generate(float_vec.begin(), float_vec.end(), getWithoutMonitors<float>(this, m_isisRaw->len2)); saveFloatOpen("distance", &float_vec[0], ndet - nmon); putAttr("units", "metre"); close(); // using the same float_vec, size unchanged ndet-nmon std::generate(float_vec.begin(), float_vec.end(), getWithoutMonitors<float>(this, m_isisRaw->tthe)); saveFloatOpen("polar_angle", &float_vec[0], ndet - nmon); putAttr("units", "degree"); close(); NXclosegroup(handle); }
/** Write out a MatrixWorkspace's data as a 2D matrix. * Use writeNexusProcessedDataEvent if writing an EventWorkspace. */ int NexusFileIO::writeNexusProcessedData2D( const API::MatrixWorkspace_const_sptr& localworkspace, const bool& uniformSpectra, const std::vector<int>& spec, const char * group_name, bool write2Ddata) const { NXstatus status; //write data entry status=NXmakegroup(fileID,group_name,"NXdata"); if(status==NX_ERROR) return(2); NXopengroup(fileID,group_name,"NXdata"); // write workspace data const size_t nHist=localworkspace->getNumberHistograms(); if(nHist<1) return(2); const size_t nSpectBins=localworkspace->readY(0).size(); const size_t nSpect=spec.size(); int dims_array[2] = { static_cast<int>(nSpect),static_cast<int>(nSpectBins) }; // Set the axis labels and values Mantid::API::Axis *xAxis=localworkspace->getAxis(0); Mantid::API::Axis *sAxis=localworkspace->getAxis(1); std::string xLabel,sLabel; if ( xAxis->isSpectra() ) xLabel = "spectraNumber"; else { if ( xAxis->unit() ) xLabel = xAxis->unit()->unitID(); else xLabel = "unknown"; } if ( sAxis->isSpectra() ) sLabel = "spectraNumber"; else { if ( sAxis->unit() ) sLabel = sAxis->unit()->unitID(); else sLabel = "unknown"; } // Get the values on the vertical axis std::vector<double> axis2; if (nSpect < nHist) for (size_t i=0;i<nSpect;i++) axis2.push_back((*sAxis)(spec[i])); else for (size_t i=0;i<sAxis->length();i++) axis2.push_back((*sAxis)(i)); int start[2]={0,0}; int asize[2]={1,dims_array[1]}; // -------------- Actually write the 2D data ---------------------------- if (write2Ddata) { std::string name="values"; NXcompmakedata(fileID, name.c_str(), NX_FLOAT64, 2, dims_array,m_nexuscompression,asize); NXopendata(fileID, name.c_str()); for(size_t i=0;i<nSpect;i++) { int s = spec[i]; NXputslab(fileID, reinterpret_cast<void*>(const_cast<double*>(&(localworkspace->readY(s)[0]))),start,asize); start[0]++; } if(m_progress != 0) m_progress->reportIncrement(1, "Writing data"); int signal=1; NXputattr (fileID, "signal", &signal, 1, NX_INT32); // More properties const std::string axesNames="axis2,axis1"; NXputattr (fileID, "axes", reinterpret_cast<void*>(const_cast<char*>(axesNames.c_str())), static_cast<int>(axesNames.size()), NX_CHAR); std::string yUnits=localworkspace->YUnit(); std::string yUnitLabel=localworkspace->YUnitLabel(); NXputattr (fileID, "units", reinterpret_cast<void*>(const_cast<char*>(yUnits.c_str())), static_cast<int>(yUnits.size()), NX_CHAR); NXputattr (fileID, "unit_label", reinterpret_cast<void*>(const_cast<char*>(yUnitLabel.c_str())), static_cast<int>(yUnitLabel.size()), NX_CHAR); NXclosedata(fileID); // error name="errors"; NXcompmakedata(fileID, name.c_str(), NX_FLOAT64, 2, dims_array,m_nexuscompression,asize); NXopendata(fileID, name.c_str()); start[0]=0; for(size_t i=0;i<nSpect;i++) { int s = spec[i]; NXputslab(fileID, reinterpret_cast<void*>(const_cast<double*>(&(localworkspace->readE(s)[0]))),start,asize); start[0]++; } if(m_progress != 0) m_progress->reportIncrement(1, "Writing data"); // Fractional area for RebinnedOutput if (localworkspace->id() == "RebinnedOutput") { RebinnedOutput_const_sptr rebin_workspace = boost::dynamic_pointer_cast<const RebinnedOutput>(localworkspace); name="frac_area"; NXcompmakedata(fileID, name.c_str(), NX_FLOAT64, 2, dims_array,m_nexuscompression,asize); NXopendata(fileID, name.c_str()); start[0]=0; for(size_t i=0;i<nSpect;i++) { int s = spec[i]; NXputslab(fileID, reinterpret_cast<void*>(const_cast<double*>(&(rebin_workspace->readF(s)[0]))), start, asize); start[0]++; } if(m_progress != 0) m_progress->reportIncrement(1, "Writing data"); } NXclosedata(fileID); } // write X data, as single array or all values if "ragged" if(uniformSpectra) { dims_array[0]=static_cast<int>(localworkspace->readX(0).size()); NXmakedata(fileID, "axis1", NX_FLOAT64, 1, dims_array); NXopendata(fileID, "axis1"); NXputdata(fileID, reinterpret_cast<void*>(const_cast<double*>(&(localworkspace->readX(0)[0])))); } else { dims_array[0]=static_cast<int>(nSpect); dims_array[1]=static_cast<int>(localworkspace->readX(0).size()); NXmakedata(fileID, "axis1", NX_FLOAT64, 2, dims_array); NXopendata(fileID, "axis1"); start[0]=0; asize[1]=dims_array[1]; for(size_t i=0;i<nSpect;i++) { NXputslab(fileID, reinterpret_cast<void*>(const_cast<double*>(&(localworkspace->readX(i)[0]))),start,asize); start[0]++; } } std::string dist=(localworkspace->isDistribution()) ? "1" : "0"; NXputattr(fileID, "distribution", reinterpret_cast<void*>(const_cast<char*>(dist.c_str())), 2, NX_CHAR); NXputattr (fileID, "units", reinterpret_cast<void*>(const_cast<char*>(xLabel.c_str())), static_cast<int>(xLabel.size()), NX_CHAR); auto label = boost::dynamic_pointer_cast<Mantid::Kernel::Units::Label>(xAxis->unit()); if(label) { NXputattr (fileID, "caption", reinterpret_cast<void*>(const_cast<char*>(label->caption().c_str())), static_cast<int>(label->caption().size()), NX_CHAR); auto unitLbl = label->label(); NXputattr (fileID, "label", reinterpret_cast<void*>(const_cast<char*>(unitLbl.ascii().c_str())), static_cast<int>(unitLbl.ascii().size()), NX_CHAR); } NXclosedata(fileID); if ( ! sAxis->isText() ) { // write axis2, maybe just spectra number dims_array[0]=static_cast<int>(axis2.size()); NXmakedata(fileID, "axis2", NX_FLOAT64, 1, dims_array); NXopendata(fileID, "axis2"); NXputdata(fileID, (void*)&(axis2[0])); NXputattr (fileID, "units", reinterpret_cast<void*>(const_cast<char*>(sLabel.c_str())), static_cast<int>(sLabel.size()), NX_CHAR); auto label = boost::dynamic_pointer_cast<Mantid::Kernel::Units::Label>(sAxis->unit()); if(label) { NXputattr (fileID, "caption", reinterpret_cast<void*>(const_cast<char*>(label->caption().c_str())), static_cast<int>(label->caption().size()), NX_CHAR); auto unitLbl = label->label(); NXputattr (fileID, "label", reinterpret_cast<void*>(const_cast<char*>(unitLbl.ascii().c_str())), static_cast<int>(unitLbl.ascii().size()), NX_CHAR); } NXclosedata(fileID); } else { std::string textAxis; for ( size_t i = 0; i < sAxis->length(); i ++ ) { std::string label = sAxis->label(i); textAxis += label + "\n"; } dims_array[0] = static_cast<int>(textAxis.size()); NXmakedata(fileID, "axis2", NX_CHAR, 2, dims_array); NXopendata(fileID, "axis2"); NXputdata(fileID, reinterpret_cast<void*>(const_cast<char*>(textAxis.c_str()))); NXputattr (fileID, "units", reinterpret_cast<void*>(const_cast<char*>("TextAxis")), 8, NX_CHAR); auto label = boost::dynamic_pointer_cast<Mantid::Kernel::Units::Label>(sAxis->unit()); if(label) { NXputattr (fileID, "caption", reinterpret_cast<void*>(const_cast<char*>(label->caption().c_str())), static_cast<int>(label->caption().size()), NX_CHAR); auto unitLbl = label->label(); NXputattr (fileID, "label", reinterpret_cast<void*>(const_cast<char*>(unitLbl.ascii().c_str())), static_cast<int>(unitLbl.ascii().size()), NX_CHAR); } NXclosedata(fileID); } writeNexusBinMasking(localworkspace); status=NXclosegroup(fileID); return((status==NX_ERROR)?3:0); }
/** Utility function to write out the * data or errors to a field in the group. * * @param det :: rectangular detector being written * @param x_pixel_slab :: size of a slab to write, in number of X pixels. *ignored if doBoth * @param field_name :: "data" field name * @param errors_field_name :: "errors" field name. * @param doErrors :: set true if you are writing the errors field this time. *field_name should be the "errors" field name * @param doBoth :: do both data and errors at once, no slabbing. * @param is_definition :: * @param bank :: name of the bank being written. * @return error code */ int SaveToSNSHistogramNexus::WriteOutDataOrErrors( Geometry::RectangularDetector_const_sptr det, int x_pixel_slab, const char *field_name, const char *errors_field_name, bool doErrors, bool doBoth, int is_definition, std::string bank) { int dataRank, dataDimensions[NX_MAXRANK]; int slabDimensions[NX_MAXRANK], slabStartIndices[NX_MAXRANK]; dataRank = 3; // Dimension 0 = the X pixels dataDimensions[0] = det->xpixels(); // Dimension 1 = the Y pixels dataDimensions[1] = det->ypixels(); // Dimension 2 = time of flight bins dataDimensions[2] = static_cast<int>(inputWorkspace->blocksize()); // ---- Determine slab size ----- // Number of pixels to collect in X before slabbing slabDimensions[0] = x_pixel_slab; slabDimensions[1] = dataDimensions[1]; slabDimensions[2] = dataDimensions[2]; if (doBoth) slabDimensions[0] = dataDimensions[0]; std::cout << "RectangularDetector " << det->getName() << " being copied. Dimensions : " << dataDimensions[0] << ", " << dataDimensions[1] << ", " << dataDimensions[2] << ".\n"; // ----- Open the data field ----------------------- if (m_compress) { if (NXcompmakedata(outId, field_name, NX_FLOAT32, dataRank, dataDimensions, NX_COMP_LZW, slabDimensions) != NX_OK) return NX_ERROR; } else { if (NXmakedata(outId, field_name, NX_FLOAT32, dataRank, dataDimensions) != NX_OK) return NX_ERROR; } if (NXopendata(outId, field_name) != NX_OK) return NX_ERROR; if (WriteAttributes(is_definition) != NX_OK) return NX_ERROR; if (!doErrors) { // Add an attribute called "errors" with value = the name of the data_errors // field. NXname attrName = "errors"; std::string attrBuffer = errors_field_name; if (NXputattr(outId, attrName, attrBuffer.c_str(), static_cast<int>(attrBuffer.size()), NX_CHAR) != NX_OK) return NX_ERROR; } // ---- Errors field ----- if (doBoth) { if (NXclosedata(outId) != NX_OK) return NX_ERROR; if (m_compress) { if (NXcompmakedata(outId, errors_field_name, NX_FLOAT32, dataRank, dataDimensions, NX_COMP_LZW, slabDimensions) != NX_OK) return NX_ERROR; } else { if (NXmakedata(outId, errors_field_name, NX_FLOAT32, dataRank, dataDimensions) != NX_OK) return NX_ERROR; } if (NXopendata(outId, errors_field_name) != NX_OK) return NX_ERROR; // NXlink * link = new NXlink; // link->linkType = 1; /* SDS data link */ // NXgetdataID(outId, link); // std::string targetPath = "/entry/" + bank + "/" + errors_field_name; // strcpy(link->targetPath, targetPath.c_str()); // if (NXmakelink(outId,link) != NX_OK) // g_log.debug() << "Error while making link to " << targetPath << // '\n'; if (WriteAttributes(is_definition) != NX_OK) return NX_ERROR; if (NXclosedata(outId) != NX_OK) return NX_ERROR; } double fillTime = 0; double saveTime = 0; // Make a buffer of floats will all the counts in that bank. auto data = new float[slabDimensions[0] * slabDimensions[1] * slabDimensions[2]]; // Only allocate an array for errors if it is needed float *errors = nullptr; if (doBoth) errors = new float[slabDimensions[0] * slabDimensions[1] * slabDimensions[2]]; for (int x = 0; x < det->xpixels(); x++) { // Which slab are we in? int slabnum = x / x_pixel_slab; // X index into the slabbed output array int slabx = x % x_pixel_slab; Timer tim1; int ypixels = static_cast<int>(det->ypixels()); PARALLEL_FOR1(inputWorkspace) for (int y = 0; y < ypixels; y++) { PARALLEL_START_INTERUPT_REGION // Get the workspace index for the detector ID at this spot size_t wi = 0; try { wi = map.find(det->getAtXY(x, y)->getID())->second; } catch (...) { std::cout << "Error finding " << bank << " x " << x << " y " << y << "\n"; } // Offset into array. size_t index = size_t(slabx) * size_t(dataDimensions[1]) * size_t(dataDimensions[2]) + size_t(y) * size_t(dataDimensions[2]); const MantidVec &Y = inputWorkspace->readY(wi); const MantidVec &E = inputWorkspace->readE(wi); for (size_t i = 0; i < Y.size(); ++i) { if (doErrors) { data[i + index] = static_cast<float>(E[i]); } else { data[i + index] = static_cast<float>(Y[i]); if (doBoth) { errors[i + index] = static_cast<float>(E[i]); } } } PARALLEL_END_INTERUPT_REGION } PARALLEL_CHECK_INTERUPT_REGION fillTime += tim1.elapsed(); // Is this the last pixel in the slab? if (!doBoth && (x % x_pixel_slab == x_pixel_slab - 1)) { Timer tim2; // std::cout << "starting slab " << x << "\n"; // This is where the slab is in the greater data array. slabStartIndices[0] = slabnum * x_pixel_slab; slabStartIndices[1] = 0; slabStartIndices[2] = 0; if (NXputslab(outId, data, slabStartIndices, slabDimensions) != NX_OK) return NX_ERROR; saveTime += tim2.elapsed(); std::ostringstream mess; mess << det->getName() << ", " << field_name << " slab " << slabnum << " of " << det->xpixels() / x_pixel_slab; this->prog->reportIncrement(x_pixel_slab * det->ypixels(), mess.str()); } } // X loop if (doBoth) { bool returnerror = false; Timer tim2; if (NXopendata(outId, field_name) != NX_OK) returnerror = true; else if (NXputdata(outId, data) != NX_OK) returnerror = true; else if (NXclosedata(outId) != NX_OK) returnerror = true; else { this->prog->reportIncrement(det->xpixels() * det->ypixels() * 1, det->getName() + " data"); if (NXopendata(outId, errors_field_name) != NX_OK) returnerror = true; else if (NXputdata(outId, errors) != NX_OK) returnerror = true; else if (NXclosedata(outId) != NX_OK) returnerror = true; else { this->prog->reportIncrement(det->xpixels() * det->ypixels() * 1, det->getName() + " errors"); saveTime += tim2.elapsed(); } } if (returnerror) { delete[] data; delete[] errors; return NX_ERROR; } } else { if (NXclosedata(outId) != NX_OK) { delete[] data; return NX_ERROR; } } std::cout << "Filling out " << det->getName() << " took " << fillTime << " sec.\n"; std::cout << "Saving " << det->getName() << " took " << saveTime << " sec.\n"; delete[] data; if (doBoth) delete[] errors; return NX_OK; }