LMU/musrfit
5
0
Fork 0
Code Issues 6 Pull Requests Actions Packages Projects Releases 4 Activity

added minimal NeXus IDF 2 support.

Browse Source
This commit is contained in:
nemu
2011-08-23 17:22:29 +00:00
parent b67a19d406
commit 03b9fe1e71
12 changed files with 5355 additions and 1845 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
src/any2many.cpp
View File

@ -64,9 +64,10 @@ void any2many_syntax()
cout << endl << " etc., or a sequence of runs <runStart>-<runEnd>, e.g. 111-222";
cout << endl << " -c <convert-options> : <inFormat> <outFormat>";
cout << endl << " <inFormat> : input data file format. Supported formats are:";
cout << endl << " PSI-BIN, ROOT (LEM), MUD, NeXus, PSI-MDU, WKM";
cout << endl << " PSI-BIN, ROOT (LEM), MUD, NeXus1, NeXus2, PSI-MDU, WKM";
cout << endl << " <outFormat> : ouput data file format. Supported formats are:";
cout << endl << " PSI-BIN, ROOT (LEM), MUD, NeXus-HDF4, NeXus-HDF5, NeXus-XML, WKM, ASCII";
cout << endl << " PSI-BIN, ROOT (LEM), MUD, NeXus1-HDF4, NeXus1-HDF5, NeXus1-XML,";
cout << endl << " NeXus2-HDF4, NeXus2-HDF5, NeXus2-XML, WKM, ASCII";
cout << endl << " -p <output-path> : where <output-path> is the output path for the";
cout << endl << " converted files. If nothing is given, the current directory";
cout << endl << " will be used, unless the option '-s' is used.";
@ -149,9 +150,12 @@ int main(int argc, char *argv[])
outputFormat.push_back("psi-bin");
outputFormat.push_back("root");
outputFormat.push_back("mud");
outputFormat.push_back("nexus-hdf4");
outputFormat.push_back("nexus-hdf5");
outputFormat.push_back("nexus-xml");
outputFormat.push_back("nexus1-hdf4");
outputFormat.push_back("nexus1-hdf5");
outputFormat.push_back("nexus1-xml");
outputFormat.push_back("nexus2-hdf4");
outputFormat.push_back("nexus2-hdf5");
outputFormat.push_back("nexus2-xml");
outputFormat.push_back("wkm");
outputFormat.push_back("ascii");
@ -159,6 +163,7 @@ int main(int argc, char *argv[])
info.useStandardOutput = false;
info.rebin = 1;
info.compressionTag = 0; // no compression as default
info.idf = 0; // undefined
// call any2many without arguments
if (argc == 1) {
@ -404,6 +409,12 @@ int main(int argc, char *argv[])
show_syntax = true;
}
// check if the output format is nexus
if (info.outFormat.Contains("nexus1", TString::kIgnoreCase))
info.idf = 1;
if (info.outFormat.Contains("nexus2", TString::kIgnoreCase))
info.idf = 2;
if (show_syntax) {
info.runList.clear();
any2many_syntax();

573
src/classes/PRunDataHandler.cpp
View File

@ -1346,7 +1346,9 @@ Bool_t PRunDataHandler::ReadNexusFile()
PDoubleVector histoData;
PRawRunData runData;
TString str;
string sstr;
Double_t dval;
bool ok;
PNeXus *nxs_file = new PNeXus(fRunPathName.Data());
if (!nxs_file->IsValid()) {
@ -1355,81 +1357,265 @@ Bool_t PRunDataHandler::ReadNexusFile()
return false;
}
// get header information
// get/set run title
str = TString(nxs_file->GetRunTitle());
runData.SetRunTitle(str);
// get/set run number
runData.SetRunNumber(nxs_file->GetRunNumber());
// get/set temperature
runData.SetTemperature(0, nxs_file->GetSampleTemperature(), 0.0);
// get/set field
dval = nxs_file->GetMagneticField();
str = TString(nxs_file->GetMagneticFieldUnits());
// since field has to be given in Gauss, check the units
Double_t factor=1.0;
if (!str.CompareTo("gauss", TString::kIgnoreCase))
factor=1.0;
else if (!str.CompareTo("tesla", TString::kIgnoreCase))
factor=1.0e4;
else
factor=1.0;
runData.SetField(factor*dval);
// get/set implantation energy
runData.SetEnergy(PMUSR_UNDEFINED);
// get/set moderator HV
runData.SetTransport(PMUSR_UNDEFINED);
// get/set RA HV's (LEM specific)
for (UInt_t i=0; i<4; i++)
runData.SetRingAnode(i, PMUSR_UNDEFINED);
// get/set setup
runData.SetSetup(nxs_file->GetRunNotes());
// get/set sample
runData.SetSample(nxs_file->GetSampleName());
// get/set orientation
runData.SetOrientation("??");
// get/set time resolution (ns)
runData.SetTimeResolution(nxs_file->GetTimeResolution());
// get/set start/stop time
runData.SetStartTime(nxs_file->GetStartTime());
runData.SetStartDate(nxs_file->GetStartDate());
runData.SetStopTime(nxs_file->GetStopTime());
runData.SetStopDate(nxs_file->GetStopDate());
// get t0, firstGoodBin, lastGoodBin, data
UInt_t t0=nxs_file->GetT0();
PIntPair goodDataBin;
goodDataBin.first = nxs_file->GetFirstGoodBin();
goodDataBin.second = nxs_file->GetLastGoodBin();
PDoubleVector data;
for (Int_t i=0; i<nxs_file->GetNoHistos(); i++) {
runData.AppendT0(t0);
runData.AppendGoodDataBin(goodDataBin);
data.clear();
for (UInt_t j=0; j<nxs_file->GetHisto(i)->size(); j++) {
data.push_back((Double_t)nxs_file->GetHisto(i)->at(j));
if (nxs_file->GetIdfVersion() == 1) {
if (!nxs_file->IsValid()) {
cout << endl << "**ERROR** invalid NeXus IDF 2 version file found." << endl;
return false;
}
runData.AppendDataBin(data);
// get header information
// get/set run title
str = TString(nxs_file->GetEntryIdf1()->GetTitle());
runData.SetRunTitle(str);
// get/set run number
runData.SetRunNumber(nxs_file->GetEntryIdf1()->GetRunNumber());
// get/set temperature
dval = nxs_file->GetEntryIdf1()->GetSample()->GetPhysPropValue("temperature", ok);
if (ok)
runData.SetTemperature(0, dval, 0.0);
// get/set field
dval = nxs_file->GetEntryIdf1()->GetSample()->GetPhysPropValue("magnetic_field", ok);
nxs_file->GetEntryIdf1()->GetSample()->GetPhysPropUnit("magnetic_field", sstr, ok);
str = sstr;
// since field has to be given in Gauss, check the units
Double_t factor=1.0;
if (!str.CompareTo("gauss", TString::kIgnoreCase))
factor=1.0;
else if (!str.CompareTo("tesla", TString::kIgnoreCase))
factor=1.0e4;
else
factor=1.0;
runData.SetField(factor*dval);
// get/set implantation energy
runData.SetEnergy(PMUSR_UNDEFINED);
// get/set moderator HV
runData.SetTransport(PMUSR_UNDEFINED);
// get/set RA HV's (LEM specific)
for (UInt_t i=0; i<4; i++)
runData.SetRingAnode(i, PMUSR_UNDEFINED);
// get/set setup
runData.SetSetup(nxs_file->GetEntryIdf1()->GetNotes());
// get/set sample
runData.SetSample(nxs_file->GetEntryIdf1()->GetSample()->GetName());
// get/set orientation
runData.SetOrientation("??");
// get/set time resolution (ns)
runData.SetTimeResolution(nxs_file->GetEntryIdf1()->GetData()->GetTimeResolution("ns"));
// get/set start/stop time
sstr = nxs_file->GetEntryIdf1()->GetStartTime();
str = sstr;
TString date, time;
SplitTimeDate(str, time, date, ok);
if (ok) {
runData.SetStartTime(time);
runData.SetStartDate(date);
}
sstr = nxs_file->GetEntryIdf1()->GetStopTime();
str = sstr;
SplitTimeDate(str, time, date, ok);
if (ok) {
runData.SetStopTime(time);
runData.SetStopDate(date);
}
// get/set t0, firstGoodBin, lastGoodBin
vector<unsigned int> *t0 = nxs_file->GetEntryIdf1()->GetData()->GetT0s();
vector<unsigned int> *fgb = nxs_file->GetEntryIdf1()->GetData()->GetFirstGoodBins();
vector<unsigned int> *lgb = nxs_file->GetEntryIdf1()->GetData()->GetLastGoodBins();
PIntPair goodDataBin;
for (UInt_t i=0; i<nxs_file->GetEntryIdf1()->GetData()->GetNoOfHistos(); i++) {
if (i<t0->size()) {
runData.AppendT0(t0->at(i));
} else {
runData.AppendT0(t0->at(0));
}
if (i<fgb->size()) {
goodDataBin.first = fgb->at(i);
goodDataBin.second = lgb->at(i);
} else {
goodDataBin.first = fgb->at(0);
goodDataBin.second = lgb->at(0);
}
runData.AppendGoodDataBin(goodDataBin);
}
// get/set data
vector<unsigned int> *pdata;
PDoubleVector data;
for (UInt_t i=0; i<nxs_file->GetEntryIdf1()->GetData()->GetNoOfHistos(); i++) {
pdata = nxs_file->GetEntryIdf1()->GetData()->GetHisto(i);
for (UInt_t j=0; j<pdata->size(); j++)
data.push_back(pdata->at(j));
runData.AppendDataBin(data);
data.clear();
}
// keep run name from the msr-file
runData.SetRunName(fRunName);
// keep the information
fData.push_back(runData);
} else if (nxs_file->GetIdfVersion() == 2) {
if (!nxs_file->IsValid()) {
cout << endl << "**ERROR** invalid NeXus IDF 2 version file found." << endl;
return false;
}
// get header information
// get/set run title
str = TString(nxs_file->GetEntryIdf2()->GetTitle());
runData.SetRunTitle(str);
// get/set run number
runData.SetRunNumber(nxs_file->GetEntryIdf2()->GetRunNumber());
// get/set temperature
dval = nxs_file->GetEntryIdf2()->GetSample()->GetPhysPropValue("temperature", ok);
if (ok)
runData.SetTemperature(0, dval, 0.0);
// get/set field
dval = nxs_file->GetEntryIdf2()->GetSample()->GetPhysPropValue("magnetic_field", ok);
nxs_file->GetEntryIdf2()->GetSample()->GetPhysPropUnit("magnetic_field", sstr, ok);
str = sstr;
// since field has to be given in Gauss, check the units
Double_t factor=1.0;
if (!str.CompareTo("gauss", TString::kIgnoreCase))
factor=1.0;
else if (!str.CompareTo("tesla", TString::kIgnoreCase))
factor=1.0e4;
else
factor=1.0;
runData.SetField(factor*dval);
// get/set implantation energy
runData.SetEnergy(PMUSR_UNDEFINED);
// get/set moderator HV
runData.SetTransport(PMUSR_UNDEFINED);
// get/set RA HV's (LEM specific)
for (UInt_t i=0; i<4; i++)
runData.SetRingAnode(i, PMUSR_UNDEFINED);
// get/set setup take NXsample/temperature_1_env and NXsample/magnetic_field_1_env
sstr = nxs_file->GetEntryIdf2()->GetSample()->GetEnvironmentTemp() + string("/");
sstr += nxs_file->GetEntryIdf2()->GetSample()->GetEnvironmentField();
str = sstr;
runData.SetSetup(str);
// get/set sample
runData.SetSample(nxs_file->GetEntryIdf2()->GetSample()->GetName());
// get/set orientation
runData.SetOrientation("??");
// get/set time resolution (ns)
runData.SetTimeResolution(nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetTimeResolution("ns"));
// get/set start/stop time
sstr = nxs_file->GetEntryIdf2()->GetStartTime();
str = sstr;
TString date, time;
SplitTimeDate(str, time, date, ok);
if (ok) {
runData.SetStartTime(time);
runData.SetStartDate(date);
}
sstr = nxs_file->GetEntryIdf2()->GetStopTime();
str = sstr;
SplitTimeDate(str, time, date, ok);
if (ok) {
runData.SetStopTime(time);
runData.SetStopDate(date);
}
// get/set t0, firstGoodBin, lastGoodBin
int *t0 = nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetT0s();
int *fgb = nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetFirstGoodBins();
int *lgb = nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetLastGoodBins();
PIntPair goodDataBin;
if (nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetT0Tag() == 2) { // t0, fgb, lgb: [][]
for (int i=0; i<nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfPeriods(); i++) {
for (int j=0; j<nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfSpectra(); j++) {
if (fgb && lgb) {
goodDataBin.first = *(fgb+i*nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfSpectra()+j);
goodDataBin.second = *(lgb+i*nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfSpectra()+j);
}
runData.AppendT0(*(t0+i*nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfSpectra()+j));
if (fgb && lgb) {
runData.AppendGoodDataBin(goodDataBin);
}
}
}
} else { // t0, fgb, lgb: single numbers
if (fgb && lgb) {
goodDataBin.first = *fgb;
goodDataBin.second = *lgb;
}
for (int i=0; i<nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfPeriods(); i++) {
for (int j=0; j<nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfSpectra(); j++) {
runData.AppendT0(*t0);
if (fgb && lgb)
runData.AppendGoodDataBin(goodDataBin);
}
}
}
// get/set data
PDoubleVector data;
int *histos = nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetHistos();
if (nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfPeriods() > 0) { // counts[][][]
for (int i=0; i<nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfPeriods(); i++) {
for (int j=0; j<nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfSpectra(); j++) {
for (int k=0; k<nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfBins(); k++) {
data.push_back(*(histos+i*nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfSpectra()+j*nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfBins()+k));
}
runData.AppendDataBin(data);
data.clear();
}
}
} else {
if (nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfSpectra() > 0) { // counts[][]
for (int i=0; i<nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfSpectra(); i++) {
for (int j=0; j<nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfBins(); j++) {
data.push_back(*(histos+i*nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfBins()+j));
}
runData.AppendDataBin(data);
data.clear();
}
} else { // counts[]
for (int i=0; i<nxs_file->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfBins(); i++) {
data.push_back(*(histos+i));
}
runData.AppendDataBin(data);
data.clear();
}
}
// keep run name from the msr-file
runData.SetRunName(fRunName);
// keep the information
fData.push_back(runData);
} else {
cout << endl << ">> PRunDataHandler::ReadNexusFile(): IDF version " << nxs_file->GetIdfVersion() << ", not implemented." << endl;
}
data.clear();
// keep run name from the msr-file
runData.SetRunName(fRunName);
// keep the information
fData.push_back(runData);
// clean up
if (nxs_file) {
@ -3405,8 +3591,11 @@ Bool_t PRunDataHandler::WriteRootFile(TString fln)
* \param fln file name. If empty, the routine will try to construct one
*/
Bool_t PRunDataHandler::WriteNexusFile(TString fln)
{
{
#ifdef PNEXUS_ENABLED
int *t0=0, *fgb=0, *lgb=0, *histo=0;
// generate output file name
if (fln.Length() == 0) {
Bool_t ok = false;
@ -3429,65 +3618,151 @@ Bool_t PRunDataHandler::WriteNexusFile(TString fln)
return false;
}
// fill necessary data structures
nxs->SetFileName(fln.Data());
nxs->SetIDFVersion(1);
nxs->SetProgramName("any2many");
nxs->SetProgramVersion("$Id$");
nxs->SetRunNumber(fData[0].GetRunNumber());
nxs->SetRunTitle(fData[0].GetRunTitle()->Data());
nxs->SetRunNotes("n/a");
nxs->SetAnalysisTag("n/a");
nxs->SetLab("PSI");
nxs->SetBeamline("n/a");
nxs->SetStartDate(fData[0].GetStartDate()->Data());
nxs->SetStartTime(fData[0].GetStartTime()->Data());
nxs->SetStopDate(fData[0].GetStopDate()->Data());
nxs->SetStopTime(fData[0].GetStopTime()->Data());
nxs->SetSwitchingState(0);
nxs->SetUser("n/a");
nxs->SetExperimentNumber("n/a");
nxs->SetSampleName(fData[0].GetSample()->Data());
nxs->SetSampleTemperature(fData[0].GetTemperature(0));
nxs->SetSampleTemperatureUints("Kelvin");
nxs->SetMagneticField(fData[0].GetField());
nxs->SetMagneticFieldUnits("Gauss");
nxs->SetSampleEnvironment("n/a");
nxs->SetSampleShape("n/a");
nxs->SetMagneticFieldVectorAvailable(0);
nxs->SetExperimentName("n/a");
nxs->SetNoDetectors(fData[0].GetNoOfHistos());
nxs->SetCollimatorType("n/a");
nxs->SetTimeResolution(fData[0].GetTimeResolution());
if (fData[0].GetT0(0) == -1)
nxs->SetT0(0);
else
nxs->SetT0(fData[0].GetT0(0)); // this needs to be changed in the long term, since for continous sources each detector has its one t0!!
if (fData[0].GetGoodDataBin(0).first == -1) {
nxs->SetFirstGoodBin(0);
nxs->SetLastGoodBin(0);
} else {
nxs->SetFirstGoodBin(fData[0].GetGoodDataBin(0).first);
nxs->SetLastGoodBin(fData[0].GetGoodDataBin(0).second);
}
// feed real histogram data
PUIntVector data;
for (UInt_t i=0; i<fData[0].GetNoOfHistos(); i++) {
for (UInt_t j=0; j<fData[0].GetDataBin(i)->size(); j++) {
data.push_back((UInt_t)fData[0].GetDataBin(i)->at(j));
// set IDF version
nxs->SetIdfVersion(fAny2ManyInfo->idf);
if (fAny2ManyInfo->idf == 1) {
// fill necessary data structures
nxs->SetFileName(fln.Data());
// set file creating time
time_t now;
struct tm *tm;
time(&now);
tm = localtime(&now);
string str("");
char cstr[128];
sprintf(cstr, "%04d-%02d-%02d %02d:%02d:%02d", 1900+tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_hour, tm->tm_sec);
str = string(cstr);
nxs->SetFileTime(str);
nxs->GetEntryIdf1()->SetProgramName("any2many");
nxs->GetEntryIdf1()->SetProgramVersion("$Id$");
nxs->GetEntryIdf1()->SetRunNumber(fData[0].GetRunNumber());
nxs->GetEntryIdf1()->SetTitle(fData[0].GetRunTitle()->Data());
nxs->GetEntryIdf1()->SetNotes("n/a");
nxs->GetEntryIdf1()->SetAnalysis("n/a");
nxs->GetEntryIdf1()->SetLaboratory("PSI");
nxs->GetEntryIdf1()->SetBeamline("n/a");
str = string(fData[0].GetStartDate()->Data()) + string(" ") + string(fData[0].GetStartTime()->Data());
nxs->GetEntryIdf1()->SetStartTime(str);
str = string(fData[0].GetStopDate()->Data()) + string(" ") + string(fData[0].GetStopTime()->Data());
nxs->GetEntryIdf1()->SetStopTime(str);
nxs->GetEntryIdf1()->SetSwitchingState(0);
nxs->GetEntryIdf1()->GetUser()->SetName("n/a");
nxs->GetEntryIdf1()->GetUser()->SetExperimentNumber("n/a");
nxs->GetEntryIdf1()->GetSample()->SetName(fData[0].GetSample()->Data());
nxs->GetEntryIdf1()->GetSample()->SetPhysProp("temperature", fData[0].GetTemperature(0), "Kelvin");
nxs->GetEntryIdf1()->GetSample()->SetPhysProp("magnetic_field", fData[0].GetField(), "Gauss");
nxs->GetEntryIdf1()->GetSample()->SetEnvironment("n/a");
nxs->GetEntryIdf1()->GetSample()->SetShape("n/a");
nxs->GetEntryIdf1()->GetSample()->SetMagneticFieldVectorAvailable(0);
nxs->GetEntryIdf1()->GetInstrument()->SetName("n/a");
nxs->GetEntryIdf1()->GetInstrument()->GetDetector()->SetNumber(fData[0].GetNoOfHistos());
nxs->GetEntryIdf1()->GetInstrument()->GetCollimator()->SetType("n/a");
nxs->GetEntryIdf1()->GetData()->SetTimeResolution(fData[0].GetTimeResolution(), "ns");
if (fData[0].GetT0(0) == -1)
nxs->GetEntryIdf1()->GetData()->SetT0(0);
else
nxs->GetEntryIdf1()->GetData()->SetT0(fData[0].GetT0(0)); // this needs to be changed in the long term, since for continous sources each detector has its one t0!!
if (fData[0].GetGoodDataBin(0).first == -1) {
nxs->GetEntryIdf1()->GetData()->SetFirstGoodBin(0);
nxs->GetEntryIdf1()->GetData()->SetLastGoodBin(0);
} else {
nxs->GetEntryIdf1()->GetData()->SetFirstGoodBin(fData[0].GetGoodDataBin(0).first);
nxs->GetEntryIdf1()->GetData()->SetLastGoodBin(fData[0].GetGoodDataBin(0).second);
}
nxs->SetHisto(i, data);
data.clear();
// feed real histogram data
PUIntVector data;
for (UInt_t i=0; i<fData[0].GetNoOfHistos(); i++) {
for (UInt_t j=0; j<fData[0].GetDataBin(i)->size(); j++) {
data.push_back((UInt_t)fData[0].GetDataBin(i)->at(j));
}
nxs->GetEntryIdf1()->GetData()->SetHisto(data, i);
data.clear();
}
} else if (fAny2ManyInfo->idf == 2) {
// fill necessary data structures
nxs->SetFileName(fln.Data());
// set file creating time
time_t now;
struct tm *tm;
time(&now);
tm = localtime(&now);
string str("");
char cstr[128];
sprintf(cstr, "%04d-%02d-%02d %02d:%02d:%02d", 1900+tm->tm_year, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_hour, tm->tm_sec);
str = string(cstr);
nxs->SetFileTime(str);
nxs->SetCreator("PSI - any2many");
nxs->GetEntryIdf2()->SetDefinition("pulsedTD");
nxs->GetEntryIdf2()->SetRunNumber(fData[0].GetRunNumber());
nxs->GetEntryIdf2()->SetTitle(fData[0].GetRunTitle()->Data());
str = string(fData[0].GetStartDate()->Data()) + string(" ") + string(fData[0].GetStartTime()->Data());
nxs->GetEntryIdf2()->SetStartTime(str);
str = string(fData[0].GetStopDate()->Data()) + string(" ") + string(fData[0].GetStopTime()->Data());
nxs->GetEntryIdf2()->SetStopTime(str);
nxs->GetEntryIdf2()->SetExperimentIdentifier("n/a");
nxs->GetEntryIdf2()->GetUser()->SetName("n/a");
nxs->GetEntryIdf2()->GetSample()->SetName(fData[0].GetSample()->Data());
nxs->GetEntryIdf2()->GetSample()->SetDescription("n/a");
nxs->GetEntryIdf2()->GetSample()->SetPhysProp("temperature_1", fData[0].GetTemperature(0), "Kelvin");
nxs->GetEntryIdf2()->GetSample()->SetPhysProp("magnetic_field_1", fData[0].GetField(), "Gauss");
nxs->GetEntryIdf2()->GetSample()->SetEnvironmentTemp("n/a");
nxs->GetEntryIdf2()->GetSample()->SetEnvironmentField("n/a");
// here would be the information for NXinstrument. Currently there are not enough information to feed this
nxs->GetEntryIdf2()->GetInstrument()->GetDetector()->SetDescription("n/a");
nxs->GetEntryIdf2()->GetInstrument()->GetDetector()->SetNoOfPeriods(1); // currently red/green is not distinguished
nxs->GetEntryIdf2()->GetInstrument()->GetDetector()->SetNoOfSpectra(fData[0].GetNoOfHistos());
nxs->GetEntryIdf2()->GetInstrument()->GetDetector()->SetNoOfBins(fData[0].GetDataBin(0)->size());
nxs->GetEntryIdf2()->GetInstrument()->GetDetector()->SetTimeResolution(fData[0].GetTimeResolution(), "ns");
histo = new int[fData[0].GetNoOfHistos()*fData[0].GetDataBin(0)->size()];
for (int i=0; i<nxs->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfSpectra(); i++) {
for (unsigned int j=0; j<fData[0].GetDataBin(0)->size(); j++) {
*(histo+i*fData[0].GetDataBin(0)->size()+j) = (int) fData[0].GetDataBin(i)->at(j);
}
}
nxs->GetEntryIdf2()->GetInstrument()->GetDetector()->SetHisto(histo);
for (int i=0; i<nxs->GetEntryIdf2()->GetInstrument()->GetDetector()->GetNoOfSpectra(); i++)
nxs->GetEntryIdf2()->GetInstrument()->GetDetector()->SetSpectrumIndex(i+1);
nxs->GetEntryIdf2()->GetInstrument()->GetDetector()->SetT0Tag(2);
int *t0 = new int[fData[0].GetT0Size()];
for (unsigned int i=0; i<fData[0].GetNoOfHistos(); i++) {
if (i<fData[0].GetT0Size())
*(t0+i) = fData[0].GetT0(i);
else
*(t0+i) = fData[0].GetT0(0);
}
nxs->GetEntryIdf2()->GetInstrument()->GetDetector()->SetT0(t0);
// first_good_bin - still missing
// last_good_bin - still missing
} else {
// clean up
if (nxs != 0) {
delete nxs;
nxs = 0;
}
return false;
}
// filter out the proper file type, i.e. HDF4, HDF5, or XML
char fileType[32];
memset(fileType, '\0', 32);
if (!fAny2ManyInfo->outFormat.CompareTo("nexus-hdf4", TString::kIgnoreCase))
if (!fAny2ManyInfo->outFormat.CompareTo("nexus1-hdf4", TString::kIgnoreCase) || !fAny2ManyInfo->outFormat.CompareTo("nexus2-hdf4", TString::kIgnoreCase))
strncpy(fileType, "hdf4", sizeof(fileType));
else if (!fAny2ManyInfo->outFormat.CompareTo("nexus-hdf5", TString::kIgnoreCase))
else if (!fAny2ManyInfo->outFormat.CompareTo("nexus1-hdf5", TString::kIgnoreCase) || !fAny2ManyInfo->outFormat.CompareTo("nexus2-hdf5", TString::kIgnoreCase))
strncpy(fileType, "hdf5", sizeof(fileType));
else if (!fAny2ManyInfo->outFormat.CompareTo("nexus-xml", TString::kIgnoreCase))
else if (!fAny2ManyInfo->outFormat.CompareTo("nexus1-xml", TString::kIgnoreCase) || !fAny2ManyInfo->outFormat.CompareTo("nexus2-xml", TString::kIgnoreCase))
strncpy(fileType, "xml", sizeof(fileType));
else {
cerr << endl << ">> PRunDataHandler::WriteNexusFile(): **ERROR** undefined output NeXus format " << fAny2ManyInfo->outFormat.Data() << " found.";
@ -3500,9 +3775,25 @@ Bool_t PRunDataHandler::WriteNexusFile(TString fln)
}
// write file
nxs->WriteFile(fln, fileType);
nxs->WriteFile(fln, fileType, fAny2ManyInfo->idf);
// clean up
if (t0) {
delete [] t0;
t0 = 0;
}
if (fgb) {
delete [] fgb;
fgb = 0;
}
if (lgb) {
delete [] lgb;
lgb = 0;
}
if (histo) {
delete [] histo;
histo = 0;
}
if (nxs != 0) {
delete nxs;
nxs = 0;
@ -3510,6 +3801,7 @@ Bool_t PRunDataHandler::WriteNexusFile(TString fln)
#else
cout << endl << ">> PRunDataHandler::WriteNexusFile(): Sorry, not enabled at configuration level, i.e. --enable-NeXus when executing configure" << endl << endl;
#endif
return true;
}
@ -4567,3 +4859,32 @@ TString PRunDataHandler::GetMonth(Int_t month)
return mm;
}
//--------------------------------------------------------------------------
// SplitTimeData (private)
//--------------------------------------------------------------------------
/**
* <p>splits an ISO 8601 timeDate into seperate time and data. The flag ok
* shows if it was successfull.
*
* \param timeData ISO 8601 timeData
* \param time part of timeData
* \param date part of timeData
* \param ok flag showing if the splitting was successfull
*/
void PRunDataHandler::SplitTimeDate(TString timeData, TString &time, TString &date, Bool_t &ok)
{
struct tm tm;
memset(&tm, 0, sizeof(tm));
strptime(timeData.Data(), "%Y-%m-%d %H:%M:S", &tm);
if (tm.tm_year == 0)
strptime(timeData.Data(), "%Y-%m-%dT%H:%M:S", &tm);
if (tm.tm_year == 0) {
ok = false;
return;
}
time = TString::Format("%02d:%02d:%02d", tm.tm_hour, tm.tm_min, tm.tm_sec);
date = TString::Format("%04d-%02d-%02d", tm.tm_year+1900, tm.tm_mon, tm.tm_mday);
}

2
src/external/nexus/Makefile.am vendored
View File

@ -5,7 +5,7 @@ h_sources = \
PNeXus.h
cpp_sources = \
PNeXus.cpp
PNeXus.cpp
include_HEADERS = $(h_sources)

5708
src/external/nexus/PNeXus.cpp vendored
View File

File diff suppressed because it is too large Load Diff

773
src/external/nexus/PNeXus.h vendored
View File

@ -32,7 +32,6 @@
#ifndef _PNEXUS_H_
#define _PNEXUS_H_
#include <iostream>
#include <string>
#include <vector>
using namespace std;
@ -43,271 +42,581 @@ using namespace std;
#define VGNAMELENMAX 64
#endif /* VGNAMELENMAX */
#define PNEXUS_FILE_OPEN_ERROR 0
#define PNEXUS_GROUP_OPEN_ERROR 1
#define PNEXUS_OPEN_DATA_ERROR 2
#define PNEXUS_GET_DATA_ERROR 3
#define PNEXUS_GET_ATTR_ERROR 4
#define PNEXUS_CLOSE_DATA_ERROR 5
#define PNEXUS_GET_META_INFO_ERROR 6
#define PNEXUS_WRONG_META_INFO 7
#define PNEXUS_WRONG_DATE_FORMAT 8
#define PNEXUS_WRONG_TIME_FORMAT 9
#define PNEXUS_INIT_GROUPDIR_ERROR 10
#define PNEXUS_GET_GROUP_INFO_ERROR 11
#define PNEXUS_GET_NEXT_ENTRY_ERROR 12
#define PNEXUS_HISTO_ERROR 13
#define PNEXUS_SET_ATTR_ERROR 14
#define PNEXUS_CREATE_GROUP_ERROR 15
#define PNEXUS_MAKE_DATA_ERROR 16
#define PNEXUS_PUT_DATA_ERROR 17
#define PNEXUS_PUT_ATTR_ERROR 18
#define PNEXUS_NO_ERROR 0
#define PNEXUS_NXENTRY_NOT_FOUND 1
#define PNEXUS_FILE_OPEN_ERROR 2
#define PNEXUS_GROUP_OPEN_ERROR 3
#define PNEXUS_OPEN_DATA_ERROR 4
#define PNEXUS_GET_DATA_ERROR 5
#define PNEXUS_GET_ATTR_ERROR 6
#define PNEXUS_CLOSE_DATA_ERROR 7
#define PNEXUS_GET_META_INFO_ERROR 8
#define PNEXUS_WRONG_META_INFO 9
#define PNEXUS_WRONG_DATE_FORMAT 10
#define PNEXUS_WRONG_TIME_FORMAT 11
#define PNEXUS_INIT_GROUPDIR_ERROR 12
#define PNEXUS_GET_GROUP_INFO_ERROR 13
#define PNEXUS_GET_NEXT_ENTRY_ERROR 14
#define PNEXUS_HISTO_ERROR 15
#define PNEXUS_SET_ATTR_ERROR 16
#define PNEXUS_CREATE_GROUP_ERROR 17
#define PNEXUS_MAKE_DATA_ERROR 18
#define PNEXUS_PUT_DATA_ERROR 19
#define PNEXUS_PUT_ATTR_ERROR 20
#define PNEXUS_IDF_NOT_IMPLEMENTED 21
#define PNEXUS_VAILD_READ_IDF1_FILE 22
#define PNEXUS_VAILD_READ_IDF2_FILE 23
#define PNEXUS_OBJECT_INVOK_ERROR 24
#define PNEXUS_TIME_FORMAT_ERROR 25
#define PNEXUS_DATA_ERROR 26
#define PNEXUS_NXUSER_NOT_FOUND 27
#define PNEXUS_LINKING_ERROR 28
//-----------------------------------------------------------------------------
/**
*
*/
typedef struct {
string fUserName;
string fExperimentNumber;
} PNeXusUser;
class PNeXusProp {
public:
PNeXusProp();
virtual ~PNeXusProp() {}
//-----------------------------------------------------------------------------
/**
*
*/
typedef struct {
string fName;
double fTemperature;
string fTemperatureUnit;
double fMagneticField;
string fMagneticFieldUnit;
string fShape;
string fMagneticFieldState; ///< ZF, TF, LF
int fMagneticFieldVectorAvailable;
vector<double> fMagneticFieldVector;
string fMagneticFieldVectorUnits;
string fMagneticFieldVectorCoordinateSystem;
string fEnvironment;
} PNeXusSample;
virtual string GetName() { return fName; }
virtual double GetValue() { return fValue; }
virtual string GetUnit() { return fUnit; }
//-----------------------------------------------------------------------------
/**
* <p> currently only put in the requiered ones.
*/
typedef struct {
int number;
} PNeXusDetector;
virtual void SetName(string name) { fName = name; }
virtual void SetValue(double val) { fValue = val; }
virtual void SetUnit(string unit) { fUnit = unit; }
//-----------------------------------------------------------------------------
/**
* <p> currently only put in the requiered ones.
*/
typedef struct {
string type;
} PNeXusCollimator;
private:
string fName;
double fValue;
string fUnit;
};
//-----------------------------------------------------------------------------
/**
* <p> currently only put in the requiered ones.
*/
typedef struct {
double total_counts;
string total_counts_units;
} PNeXusBeam;
class PNeXusBeam1 {
public:
PNeXusBeam1() { fTotalCounts = 0; fUnits = "n/a"; }
virtual ~PNeXusBeam1() {}
//-----------------------------------------------------------------------------
/**
*
*/
typedef struct {
string name;
PNeXusDetector detector;
PNeXusCollimator collimator;
PNeXusBeam beam;
} PNeXusInstrument;
virtual bool IsValid(bool strict);
//-----------------------------------------------------------------------------
/**
*
*/
typedef struct {
unsigned int fGroupFirst;
unsigned int fGroupSecond;
double fAlphaVal;
} PNeXusAlpha;
virtual double GetTotalCounts() { return fTotalCounts; }
virtual string GetUnits() { return fUnits; }
//-----------------------------------------------------------------------------
/**
*
*/
typedef struct {
double fTimeResolution; ///< time resolution in (ns)
unsigned int fNumberOfHistos;
vector<unsigned int> fT0;
vector<unsigned int> fFirstGoodBin;
vector<unsigned int> fLastGoodBin;
vector<string> fHistoName;
vector< vector<unsigned int> > fHisto;
vector<unsigned int> fGrouping;
vector<PNeXusAlpha> fAlpha;
} PNeXusData;
virtual void SetTotalCounts(double counts) { fTotalCounts = counts; }
virtual void SetUnits(string units) { fUnits = units; }
private:
double fTotalCounts; ///< total number of counts
string fUnits; ///< 'units' in which total counts is given, e.g. 'Mev'
};
class PNeXusCollimator1 {
public:
PNeXusCollimator1() { fType = "n/a"; }
virtual ~PNeXusCollimator1() {}
virtual bool IsValid(bool strict) { return true; } // currently only a dummy
virtual string GetType() { return fType; }
virtual void SetType(string type) { fType = type; }
private:
string fType;
};
class PNeXusDetector1 {
public:
PNeXusDetector1() { fNumber = 0; }
virtual ~PNeXusDetector1() {}
virtual bool IsValid(bool strict);
virtual int GetNumber() { return fNumber; }
virtual void SetNumber(int number) { fNumber = number; }
private:
int fNumber;
};
class PNeXusInstrument1 {
public:
PNeXusInstrument1() { fName = "n/a"; }
virtual ~PNeXusInstrument1() {}
virtual bool IsValid(bool strict);
virtual string GetName() { return fName; }
virtual PNeXusDetector1* GetDetector() { return &fDetector; }
virtual PNeXusCollimator1* GetCollimator() { return &fCollimator; }
virtual PNeXusBeam1* GetBeam() { return &fBeam; }
virtual void SetName(string name) { fName = name; }
virtual void SetDetector(PNeXusDetector1 &detector) { fDetector = detector; }
virtual void SetCollimator(PNeXusCollimator1 &collimator) { fCollimator = collimator; }
virtual void SetBeam(PNeXusBeam1 &beam) { fBeam = beam; }
private:
string fName; ///< instrument name
PNeXusDetector1 fDetector;
PNeXusCollimator1 fCollimator;
PNeXusBeam1 fBeam;
};
class PNeXusSample1 {
public:
PNeXusSample1();
virtual ~PNeXusSample1();
virtual bool IsValid(bool strict);
virtual string GetName() { return fName; }
virtual string GetShape() { return fShape; }
virtual string GetMagneticFieldState() { return fMagneticFieldState; }
virtual string GetEnvironment() { return fEnvironment; }
virtual double GetPhysPropValue(string name, bool &ok);
virtual void GetPhysPropUnit(string name, string &unit, bool &ok);
virtual int IsMagneticFieldVectorAvailable() { return fMagneticFieldVectorAvailable; }
virtual vector<double> GetMagneticFieldVector() { return fMagneticFieldVector; }
virtual string GetMagneticFieldVectorUnits() { return fMagneticFieldVectorUnits; }
virtual string GetMagneticFieldVectorCoordinateSystem() { return fMagneticFieldVectorCoordinateSystem; }
virtual void SetName(string name) { fName = name; }
virtual void SetShape(string shape) { fShape = shape; }
virtual void SetMagneticFieldState(string magFieldState) { fMagneticFieldState = magFieldState; }
virtual void SetEnvironment(string env) { fEnvironment = env; }
virtual void SetPhysProp(string name, double value, string unit, int idx=-1);
virtual void SetMagneticFieldVectorAvailable(int avail) { fMagneticFieldVectorAvailable = avail; }
virtual void SetMagneticFieldVector(vector<double> &magVec) { fMagneticFieldVector = magVec; }
virtual void SetMagneticFieldVectorCoordinateSystem(string coord) { fMagneticFieldVectorCoordinateSystem = coord; }
virtual void SetMagneticFieldUnits(string units) { fMagneticFieldVectorUnits = units; }
private:
string fName; ///< sample name
string fShape; ///< sample orientation
string fMagneticFieldState; ///< magnetic field state, e.g. TF, ZF, ...
string fEnvironment; ///< sample environment, e.g. CCR, Konti-1, ...
vector<PNeXusProp> fPhysProp; ///< collects the temperature, magnetic field
int fMagneticFieldVectorAvailable; ///< flag '0' magnetic field vector not available, '1' magnetic field vector available
vector<double> fMagneticFieldVector; ///< magnetic field vector
string fMagneticFieldVectorUnits; ///< units in which the magnetic field vector is given
string fMagneticFieldVectorCoordinateSystem; ///< coordinate system, e.g. 'cartesian'
};
class PNeXusUser1 {
public:
PNeXusUser1();
virtual ~PNeXusUser1() {}
virtual bool IsValid(bool strict) { return true; } // currently only a dummy
virtual string GetName() { return fName; }
virtual string GetExperimentNumber() { return fExperimentNumber; }
virtual void SetName(string name) { fName = name; }
virtual void SetExperimentNumber(string expNum) { fExperimentNumber = expNum; }
private:
string fName; ///< user name
string fExperimentNumber; ///< experiment number, RB number at ISIS
};
class PNeXusAlpha1 {
public:
PNeXusAlpha1();
virtual ~PNeXusAlpha1() {}
virtual unsigned int GetGroupFirst() { return fGroupFirst; }
virtual unsigned int GetGroupSecond() { return fGroupSecond; }
virtual double GetAlpha() { return fAlphaVal; }
virtual void SetGroupFirst(unsigned int val) { fGroupFirst = val; }
virtual void SetGroupSecond(unsigned int val) { fGroupSecond = val; }
virtual void SetAlpha(double val) { fAlphaVal = val; }
private:
unsigned int fGroupFirst;
unsigned int fGroupSecond;
double fAlphaVal;
};
class PNeXusData1 {
public:
PNeXusData1() { fTimeResolution = 0.0; }
virtual ~PNeXusData1();
virtual bool IsValid(bool strict);
virtual double GetTimeResolution(string units);
virtual vector<unsigned int> *GetT0s() { return &fT0; }
virtual int GetT0(unsigned int idx);
virtual vector<unsigned int> *GetFirstGoodBins() { return &fFirstGoodBin; }
virtual int GetFirstGoodBin(unsigned int idx);
virtual vector<unsigned int> *GetLastGoodBins() { return &fLastGoodBin; }
virtual int GetLastGoodBin(unsigned int idx);
virtual vector<string> *GetHistoNames() { return &fHistoName; }
virtual void GetHistoName(unsigned int idx, string &name, bool &ok);
virtual unsigned int GetNoOfHistos() { return fHisto.size(); }
virtual vector<unsigned int> *GetHisto(unsigned int histoNo);
virtual vector<int> *GetGrouping() { return &fGrouping; }
virtual vector<PNeXusAlpha1> *GetAlpha() { return &fAlpha; }
virtual void SetTimeResolution(double val, string units);
virtual void SetT0(unsigned int t0, int idx=-1);
virtual void SetFirstGoodBin(unsigned int fgb, int idx=-1);
virtual void SetLastGoodBin(unsigned int lgb, int idx=-1);
virtual void FlushHistos();
virtual void SetHisto(vector<unsigned int> &data, int histoNo=-1);
virtual void FlushGrouping() { fGrouping.clear(); }
virtual void SetGrouping(vector<int> &grouping) { fGrouping = grouping; }
virtual void FlushAlpha() { fAlpha.clear(); }
virtual void SetAlpha(vector<PNeXusAlpha1> &alpha) { fAlpha = alpha; }
private:
double fTimeResolution; ///< time resolution in (ps)
vector<unsigned int> fT0;
vector<unsigned int> fFirstGoodBin;
vector<unsigned int> fLastGoodBin;
vector<string> fHistoName;
vector< vector<unsigned int> > fHisto;
vector<int> fGrouping;
vector<PNeXusAlpha1> fAlpha;
};
class PNeXusEntry1 {
public:
PNeXusEntry1();
virtual ~PNeXusEntry1() {}
virtual bool IsValid(bool strict);
virtual string GetProgramName() { return fProgramName; }
virtual string GetProgramVersion() { return fProgramVersion; }
virtual int GetRunNumber() { return fRunNumber; }
virtual string GetTitle() { return fTitle; }
virtual string GetNotes() { return fNotes; }
virtual string GetAnalysis() { return fAnalysis; }
virtual string GetLaboratory() { return fLaboratory; }
virtual string GetBeamline() { return fBeamline; }
virtual string GetStartTime() { return fStartTime; }
virtual string GetStopTime() { return fStopTime; }
virtual int GetSwitchingState() { return fSwitchingState; }
virtual PNeXusUser1* GetUser() { return &fUser; }
virtual PNeXusSample1* GetSample() { return &fSample; }
virtual PNeXusInstrument1* GetInstrument() { return &fInstrument; }
virtual PNeXusData1* GetData() { return &fData; }
virtual void SetProgramName(string name) { fProgramName = name; }
virtual void SetProgramVersion(string version) { fProgramVersion = version; }
virtual void SetRunNumber(int number) { fRunNumber = number; }
virtual void SetTitle(string title) { fTitle = title; }
virtual void SetNotes(string notes) { fNotes = notes; }
virtual void SetAnalysis(string analysis) { fAnalysis = analysis; }
virtual void SetLaboratory(string lab) { fLaboratory = lab; }
virtual void SetBeamline(string beamline) { fBeamline = beamline; }
virtual int SetStartTime(string time);
virtual int SetStopTime(string time);
virtual int SetSwitchingState(int state);
virtual void SetUser(PNeXusUser1 &user) { fUser = user; }
virtual void SetSample(PNeXusSample1 &sample) { fSample = sample; }
virtual void SetInstrument(PNeXusInstrument1 &instrument) { fInstrument = instrument; }
virtual void SetData(PNeXusData1 &data) { fData = data; }
private:
string fProgramName; ///< name of the creating program
string fProgramVersion; ///< version of the creating program
int fRunNumber; ///< run number
string fTitle; ///< string containing the run title
string fNotes; ///< comments
string fAnalysis; ///< type of muon experiment "muonTD", "ALC", ...
string fLaboratory; ///< name of the laboratory where the data are taken, e.g. PSI, triumf, ISIS, J-Parc
string fBeamline; ///< name of the beamline used for the experiment, e.g. muE4
string fStartTime; ///< start date/time of the run
string fStopTime; ///< stop date/time of the run
int fSwitchingState; ///< '1' normal data collection, '2' Red/Green mode
PNeXusUser1 fUser; ///< NXuser info IDF Version 1
PNeXusSample1 fSample; ///< NXsample info IDF Version 1
PNeXusInstrument1 fInstrument; ///< NXinstrument info IDF Version 1
PNeXusData1 fData; ///< NXdata info IDF Version 1
};
class PNeXusSource2 {
public:
PNeXusSource2();
virtual ~PNeXusSource2() {}
virtual bool IsValid(bool strict);
virtual string GetName() { return fName; }
virtual string GetType() { return fType; }
virtual string GetProbe() { return fProbe; }
virtual void SetName(string name) { fName = name; }
virtual void SetType(string type) { fType = type; }
virtual void SetProbe(string probe) { fProbe = probe; }
private:
string fName; ///< facility name
string fType; ///< continous muon source, pulsed muon source, low energy muon source, ...
string fProbe; ///< positive muon, negative muon
};
class PNeXusBeamline2 {
public:
PNeXusBeamline2() { fName = "n/a"; }
virtual ~PNeXusBeamline2() {}
virtual bool IsValid(bool strict);
virtual string GetName() { return fName; }
virtual void SetName(string name) { fName = name; }
private:
string fName;
};
class PNeXusDetector2 {
public:
PNeXusDetector2();
virtual ~PNeXusDetector2();
virtual bool IsValid(bool strict);
virtual string GetDescription() { return fDescription; }
virtual double GetTimeResolution(string units);
virtual bool IsT0Present() { return (fT0 == 0) ? false : true; }
virtual int GetT0Tag() { return fT0Tag; }
virtual int GetT0(int idxp=-1, int idxs=-1);
virtual int* GetT0s() { return fT0; }
virtual bool IsFirstGoodBinPresent() { return (fFirstGoodBin == 0) ? false : true; }
virtual int GetFirstGoodBin(int idxp=-1, int idxs=-1);
virtual int* GetFirstGoodBins() { return fFirstGoodBin; }
virtual bool IsLastGoodBinPresent() { return (fFirstGoodBin == 0) ? false : true; }
virtual int GetLastGoodBin(int idxp=-1, int idxs=-1);
virtual int* GetLastGoodBins() { return fLastGoodBin; }
virtual int GetNoOfPeriods() { return fNoOfPeriods; }
virtual int GetNoOfSpectra() { return fNoOfSpectra; }
virtual int GetNoOfBins() { return fNoOfBins; }
virtual int GetHistoValue(int idx_p, int idx_s, int idx_b);
virtual int* GetHistos() { return fHisto; }
virtual unsigned int GetSpectrumIndexSize() { return fSpectrumIndex.size(); }
virtual vector<int> *GetSpectrumIndex() { return &fSpectrumIndex; }
virtual int GetSpectrumIndex(unsigned int idx);
virtual void SetDescription(string description) { fDescription = description; }
virtual void SetTimeResolution(double val, string units);
virtual void SetT0Tag(int tag) { fT0Tag = tag; }
virtual void SetT0(int *t0) { fT0 = t0; }
virtual void SetFirstGoodBin(int *fgb) { fFirstGoodBin = fgb; }
virtual void SetLastGoodBin(int *lgb) { fLastGoodBin = lgb; }
virtual void SetNoOfPeriods(int val) { fNoOfPeriods = val; }
virtual void SetNoOfSpectra(int val) { fNoOfSpectra = val; }
virtual void SetNoOfBins(int val) { fNoOfBins = val; }
virtual void SetHisto(int *histo) { fHisto = histo; }
virtual void SetSpectrumIndex(vector<int> spectIdx) { fSpectrumIndex = spectIdx; }
virtual void SetSpectrumIndex(int spectIdx, int idx=-1);
private:
string fDescription; ///< description of the detector
double fTimeResolution; ///< keeps the time resolution in (ps)
vector<int> fSpectrumIndex; ///< list of global spectra
int fNoOfPeriods; ///< number of periods or -1 if not defined
int fNoOfSpectra; ///< number of spectra or -1 if not defined
int fNoOfBins; ///< number of bins of a spectrum or -1 if not defined
int fT0Tag; ///< tag for t0, fgb, lgb structure. -1==not present, 1==NX_INT, 2=NX_INT[np][ns]
int *fT0;
int *fFirstGoodBin;
int *fLastGoodBin;
int *fHisto;
};
class PNeXusInstrument2 {
public:
PNeXusInstrument2() { fName = "n/a"; }
virtual ~PNeXusInstrument2() {}
virtual bool IsValid(bool strict);
virtual string GetName() { return fName; }
virtual PNeXusSource2* GetSource() { return &fSource; }
virtual PNeXusBeamline2* GetBeamline() { return &fBeamline; }
virtual PNeXusDetector2* GetDetector() { return &fDetector; }
virtual void SetName(string name) { fName = name; }
virtual void SetSource(PNeXusSource2 &source) { fSource = source; }
virtual void SetBeamline(PNeXusBeamline2 &beamline) { fBeamline = beamline; }
virtual void SetDetector(PNeXusDetector2 &detector) { fDetector = detector; }
private:
string fName; ///< name of the instrument
PNeXusSource2 fSource; ///< details of the muon source used
PNeXusBeamline2 fBeamline; ///< beamline description
PNeXusDetector2 fDetector; ///< details of the detectors which also includes the data!!
};
class PNeXusSample2 {
public:
PNeXusSample2();
virtual ~PNeXusSample2();
virtual bool IsValid(bool strict);
virtual string GetName() { return fName; }
virtual string GetDescription() { return fDescription; }
virtual string GetMagneticFieldState() { return fMagneticFieldState; }
virtual string GetEnvironmentTemp() { return fEnvironmentTemp; }
virtual string GetEnvironmentField() { return fEnvironmentField; }
virtual double GetPhysPropValue(string name, bool &ok);
virtual void GetPhysPropUnit(string name, string &unit, bool &ok);
virtual void SetName(string name) { fName = name; }
virtual void SetDescription(string description) { fDescription = description; }
virtual void SetMagneticFieldState(string magFieldState) { fMagneticFieldState = magFieldState; }
virtual void SetEnvironmentTemp(string env) { fEnvironmentTemp = env; }
virtual void SetEnvironmentField(string env) { fEnvironmentField = env; }
virtual void SetPhysProp(string name, double value, string unit, int idx=-1);
private:
string fName; ///< sample name
string fDescription; ///< sample description
string fMagneticFieldState; ///< magnetic field state, e.g. TF, ZF, ...
string fEnvironmentTemp; ///< sample environment related to temperature, e.g. CCR, Konti-1, ...
string fEnvironmentField; ///< sample environment related to field, e.g. WEW-Bruker
vector<PNeXusProp> fPhysProp; ///< collects the temperature, magnetic field
};
class PNeXusUser2 {
public:
PNeXusUser2() { fName = "n/a"; }
virtual ~PNeXusUser2() {}
virtual bool IsValid(bool strict) { return true; } // currently only a dummy
virtual string GetName() { return fName; }
virtual void SetName(string name) { fName = name; }
private:
string fName; ///< user name
};
class PNeXusEntry2 {
public:
PNeXusEntry2();
virtual ~PNeXusEntry2() {}
virtual bool IsValid(bool strict);
virtual string GetDefinition() { return fDefinition; }
virtual string GetProgramName() { return fProgramName; }
virtual string GetProgramVersion() { return fProgramVersion; }
virtual int GetRunNumber() { return fRunNumber; }
virtual string GetTitle() { return fTitle; }
virtual string GetStartTime() { return fStartTime; }
virtual string GetStopTime() { return fStopTime; }
virtual string GetExperimentIdentifier() { return fExperimentIdentifier; }
virtual PNeXusUser2* GetUser() { return &fUser; }
virtual PNeXusSample2* GetSample() { return &fSample; }
virtual PNeXusInstrument2* GetInstrument() { return &fInstrument; }
virtual void SetDefinition(string def) { fDefinition = def; }
virtual void SetProgramName(string name) { fProgramName = name; }
virtual void SetProgramVersion(string version) { fProgramVersion = version; }
virtual void SetRunNumber(int number) { fRunNumber = number; }
virtual void SetTitle(string title) { fTitle = title; }
virtual int SetStartTime(string time);
virtual int SetStopTime(string time);
virtual void SetExperimentIdentifier(string expId) { fExperimentIdentifier = expId; }
virtual void SetUser(PNeXusUser2 &user) { fUser = user; }
virtual void SetSample(PNeXusSample2 &sample) { fSample = sample; }
virtual void SetInstrument(PNeXusInstrument2 &instrument) { fInstrument = instrument; }
private:
string fDefinition; ///< the template (DTD name) on which the entry was based, e.g. 'pulsedTD'
string fProgramName; ///< name of the creating program
string fProgramVersion; ///< version of the creating program
int fRunNumber; ///< run number
string fTitle; ///< string containing the run title
string fStartTime; ///< start date/time of the run
string fStopTime; ///< stop date/time of the run
string fExperimentIdentifier; ///< experiment number, (for ISIS, the RB number)
PNeXusUser2 fUser; ///< NXuser info IDF Version 2
PNeXusSample2 fSample; ///< NXsample info IDF Version 2
PNeXusInstrument2 fInstrument; ///< NXinstrument inf IDF Version 2
};
//-----------------------------------------------------------------------------
/**
*
*/
class PNeXus {
public:
PNeXus();
PNeXus(const char* fileName);
virtual ~PNeXus();
virtual bool IsValid() { return fIsValid; }
virtual int GetIdfVersion() { return fIdfVersion; }
virtual string GetFileName() { return fFileName; }
virtual string GetFileTime() { return fFileTime; }
virtual void SetIdfVersion(unsigned int idf);
virtual void SetFileName(string name) { fFileName = name; }
virtual void SetFileTime(string time) { fFileTime = time; }
virtual PNeXusEntry1* GetEntryIdf1() { return fNxEntry1; }
virtual PNeXusEntry2* GetEntryIdf2() { return fNxEntry2; }
virtual bool IsValid(bool strict=false);
virtual int GetErrorCode() { return fErrorCode; }
virtual string GetErrorMsg() { return fErrorMsg; }
virtual vector<unsigned int>* GetGroupedHisto(unsigned int idx);
virtual int ReadFile(const char *fileName);
virtual int WriteFile(const char *fileName, const char *fileType="hdf4");
virtual int WriteFile(const char *fileName, const char *fileType="hdf4", const unsigned int idf=2);
virtual void SetCreator(string str) { fCreator = str; }
virtual void Dump();
virtual int GetErrorCode() { return fErrorCode; }
virtual string GetErrorMsg() { return fErrorMsg; }
virtual string GetFileName() { return fFileName; }
virtual int GetIDFVersion() { return fIDFVersion; }
virtual string GetProgramName() { return fProgramName; }
virtual string GetProgramVersion() { return fProgramVersion; }
virtual int GetRunNumber() { return fRunNumber; }
virtual string GetRunTitle() { return fRunTitle; }
virtual string GetRunNotes() { return fNotes; }
virtual string GetAnalysisTag() { return fAnalysisTag; }
virtual string GetLab() { return fLab; }
virtual string GetBeamline() { return fBeamLine; }
virtual string GetStartDate() { return fStartDate; }
virtual string GetStartTime() { return fStartTime; }
virtual string GetStopDate() { return fStopDate; }
virtual string GetStopTime() { return fStopTime; }
virtual int GetSwitchingState() { return fSwitchingState; }
virtual string GetUser() { return fUser.fUserName; }
virtual string GetExperimentNumber() { return fUser.fExperimentNumber; }
virtual string GetSampleName() { return fSample.fName; }
virtual double GetSampleTemperature() { return fSample.fTemperature; }
virtual string GetSampleTemperartureUnits() { return fSample.fTemperatureUnit; }
virtual double GetMagneticField() { return fSample.fMagneticField; }
virtual string GetMagneticFieldUnits() { return fSample.fMagneticFieldUnit; }
virtual string GetMagneticFieldState() { return fSample.fMagneticFieldState; }
virtual int IsMagneticFieldVectorAvailable() { return fSample.fMagneticFieldVectorAvailable; }
virtual vector<double>& GetMagneticFieldVector() { return fSample.fMagneticFieldVector; }
virtual string GetMagneticFieldVectorCoordSystem() { return fSample.fMagneticFieldVectorCoordinateSystem; }
virtual string GetMagneticFieldVectorUnits() { return fSample.fMagneticFieldVectorUnits; }
virtual string GetSampleEnvironment() { return fSample.fEnvironment; }
virtual string GetSampleShape() { return fSample.fShape; }
virtual string GetExperimentName() { return fInstrument.name; }
virtual int GetNoDetectors() { return fInstrument.detector.number; }
virtual string GetCollimatorType() { return fInstrument.collimator.type; }
virtual double GetTotalNoEvents() { return fInstrument.beam.total_counts; }
virtual string GetTotalNoEventsUnits() { return fInstrument.beam.total_counts_units; }
virtual double GetTimeResolution() { return fData.fTimeResolution; }
virtual int GetNoHistos() { return fData.fNumberOfHistos; }
virtual int IsAlphaAvailable() { return fData.fAlpha.size(); }
virtual vector<PNeXusAlpha> *GetAlpha() { if (fData.fAlpha.size()) return &fData.fAlpha; else return 0; }
virtual unsigned int GetT0() { if (fData.fT0.size()) return fData.fT0[0]; else return 0; }
virtual unsigned int GetFirstGoodBin() { if (fData.fFirstGoodBin.size()) return fData.fFirstGoodBin[0]; else return 0; }
virtual unsigned int GetLastGoodBin() { if (fData.fLastGoodBin.size()) return fData.fLastGoodBin[0]; else return 0; }
virtual vector<unsigned int> *GetHisto(unsigned int histoNo) { if (fData.fHisto.size() > histoNo) return &fData.fHisto[histoNo]; else return 0;}
virtual vector<unsigned int> *GetGroupedHisto(unsigned int histoNo) { if (fGroupedData.size() > histoNo) return &fGroupedData[histoNo]; else return 0; }
virtual void SetFileName(const char* fileName) { fFileName = fileName; }
virtual void SetFileName(string fileName) { fFileName = fileName; }
virtual void SetIDFVersion(int idfVersion) { fIDFVersion = idfVersion; }
virtual void SetProgramName(const char* progName) { fProgramName = progName; }
virtual void SetProgramName(string progName) { fProgramName = progName; }
virtual void SetProgramVersion(const char* progVersion) { fProgramVersion = progVersion; }
virtual void SetProgramVersion(string progVersion) { fProgramVersion = progVersion; }
virtual void SetRunNumber(int runNumber) { fRunNumber = runNumber; }
virtual void SetRunTitle(const char* runTitle) { fRunTitle = runTitle; }
virtual void SetRunTitle(string runTitle) { fRunTitle = runTitle; }
virtual void SetRunNotes(const char* notes) { fNotes = notes; }
virtual void SetRunNotes(string notes) { fNotes = notes; }
virtual void SetAnalysisTag(const char* analysisTag) { fAnalysisTag = analysisTag; }
virtual void SetAnalysisTag(string analysisTag) { fAnalysisTag = analysisTag; }
virtual void SetLab(const char *lab) { fLab = lab; }
virtual void SetLab(string lab) { fLab = lab; }
virtual void SetBeamline(const char *beamline) { fBeamLine = beamline; }
virtual void SetBeamline(string beamline) { fBeamLine = beamline; }
virtual bool SetStartDate(const char *date);
virtual bool SetStartDate(string date);
virtual bool SetStartTime(const char *time);
virtual bool SetStartTime(string time);
virtual bool SetStopDate(const char *date);
virtual bool SetStopDate(string date);
virtual bool SetStopTime(const char *time);
virtual bool SetStopTime(string time);
virtual void SetSwitchingState(int state) { fSwitchingState=state; }
virtual void SetUser(string user) { fUser.fUserName = user; }
virtual void SetExperimentNumber(string number) { fUser.fExperimentNumber = number; }
virtual void SetSampleName(string name) { fSample.fName = name; }
virtual void SetSampleTemperature(double temp) { fSample.fTemperature = temp; }
virtual void SetSampleTemperatureUints(string units) { fSample.fTemperatureUnit = units; }
virtual void SetMagneticField(double field) { fSample.fMagneticField = field; }
virtual void SetMagneticFieldUnits(string units) { fSample.fMagneticFieldUnit = units; }
virtual void SetMagneticFieldState(string state) { fSample.fMagneticFieldState = state; }
virtual void SetSampleEnvironment(string env) { fSample.fEnvironment = env; }
virtual void SetSampleShape(string shape) { fSample.fShape = shape; }
virtual void SetMagneticFieldVectorAvailable(int available) { fSample.fMagneticFieldVectorAvailable = available; }
virtual void SetMagneticFieldVector(vector<double>& vec) {fSample.fMagneticFieldVectorAvailable = 1; fSample.fMagneticFieldVector = vec;}
virtual void SetMagneticFieldVectorCoordSystem(string coord) { fSample.fMagneticFieldVectorCoordinateSystem = coord; }
virtual void SetMagneticFieldVectorUnits(string units) { fSample.fMagneticFieldVectorUnits = units; }
virtual void SetExperimentName(string name) { fInstrument.name = name; }
virtual void SetNoDetectors(unsigned int no) { fInstrument.detector.number = no; }
virtual void SetCollimatorType(string type) { fInstrument.collimator.type = type; }
virtual void SetTimeResolution(double timeResolution) { fData.fTimeResolution = timeResolution; } // given in ns
virtual void SetT0(unsigned int t0, unsigned int idx=0);
virtual void SetFirstGoodBin(unsigned int fgb, unsigned int idx=0);
virtual void SetLastGoodBin(unsigned int lgb, unsigned int idx=0);
virtual void SetHisto(unsigned int histoNo, vector<unsigned int> &data);
private:
bool fIsValid;
string fFileName; ///< read/write file name
NXhandle fFileHandle; ///< nexus file handle
bool fValid;
int fErrorCode;
string fErrorMsg;
string fErrorMsg; ///< stores the current error message
int fErrorCode; ///< indicates the current error code
string fNeXusVersion; ///< version of the NeXus API used in writing the file
string fFileFormatVersion; ///< version of the HDF, HDF5, or XML library used to create the file (IDF 2 only)
int fIDFVersion;
string fProgramName;
string fProgramVersion;
unsigned int fIdfVersion; ///< version of the instrument definition
string fFileName; ///< file name of the original NeXus file to assist identification if the external name has been changed
string fFileTime; ///< date and time of file creating (IDF 2 only)
NXhandle fFileHandle;
int fRunNumber;
string fRunTitle;
string fNotes;
string fAnalysisTag; ///< type of muon experiment
string fLab;
string fBeamLine;
string fStartDate;
string fStartTime;
string fStopDate;
string fStopTime;
int fSwitchingState; ///< red/green mode
string fCreator; ///< facility of program where the file originated
PNeXusUser fUser;
PNeXusSample fSample;
PNeXusInstrument fInstrument;
PNeXusData fData;
vector< vector<unsigned int> > fGroupedData;
PNeXusEntry1 *fNxEntry1; ///< NXentry for IDF 1
PNeXusEntry2 *fNxEntry2; ///< NXentry for IDF 2
vector< vector<unsigned int> > fGroupedHisto;
virtual void Init();
virtual void CleanUp();
virtual bool ErrorHandler(NXstatus status, int errCode, const string &errMsg);
virtual NXstatus GetStringData(string &str);
virtual NXstatus GetStringAttr(string attr, string &str);
virtual int GetDataSize(int type);
virtual NXstatus GetDoubleVectorData(vector<double> &data);
virtual NXstatus GetIntVectorData(vector<int> &data);
virtual int ReadFileIdf1();
virtual int ReadFileIdf2();
virtual int WriteFileIdf1(const char* fileName, const NXaccess access);
virtual int WriteFileIdf2(const char* fileName, const NXaccess access);
virtual NXstatus GroupHistoData();
virtual string TransformDate(string date, bool &ok);
virtual int GetMonth(const string month);
virtual bool IsValidIdf1(bool strict);
virtual bool IsValidIdf2(bool strict);
virtual bool SearchInGroup(string str, string tag, NXname &nxname, NXname &nxclass, int &dataType);
};
#endif // _PNEXUS_H_

1
src/include/PMusr.h
View File

@ -609,6 +609,7 @@ typedef struct {
UInt_t rebin; ///< holds the number of bins to be packed
UInt_t compressionTag; ///< 0=no compression, 1=gzip compression, 2=bzip2 compression
TString compressFileName; ///< holds the name of the outputfile name in case of compression is used
UInt_t idf; ///< IDF version for NeXus files.
} PAny2ManyInfo;
#endif // _PMUSR_H_

1
src/include/PRunDataHandler.h
View File

@ -96,6 +96,7 @@ class PRunDataHandler
virtual TString GetFileName(const TString extension, Bool_t &ok);
virtual TString FileNameFromTemplate(TString &fileNameTemplate, Int_t run, TString &year, Bool_t &ok);
virtual TString GetMonth(Int_t month);
virtual void SplitTimeDate(TString timeDate, TString &time, TString &date, Bool_t &ok);
};
#endif // _PRUNDATAHANDLER_H_

2
src/tests/nexus/Makefile
View File

@ -11,7 +11,7 @@ LD = g++
LDFLAGS = -g
LIBS = -L /usr/local/lib -lNeXus
LIBS += -L /opt/hdf5/lib -lhdf5
LIBS += -L /usr/lib -lhdf5
EXEC = nexus_read_test

44
src/tests/nexus/nexus_read_test.cpp
View File

@ -30,6 +30,7 @@
***************************************************************************/
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
@ -37,8 +38,6 @@
#include <vector>
using namespace std;
#include "napi.h"
#include "PNeXus.h"
//---------------------------------------------------------------------------------------
@ -46,12 +45,13 @@ using namespace std;
void nexus_read_test_syntax()
{
cout << endl << ">>---------------------------------------------------------------------------------------";
cout << endl << ">> usage: nexus_read_test <nexus-in-filename> <nexus-out-filename> <nexus-write-format>";
cout << endl << ">> usage: nexus_read_test <nexus-in-filename> [<nexus-out-filename> <nexus-write-format> <idf>]";
cout << endl << ">> This will try to read a nexus-files <nexus-in-filename> and send the relevant";
cout << endl << ">> information to the standard output.";
cout << endl << ">> At the same time the read file is written back to <nexus-out-filename>, where";
cout << endl << ">> the extension will be added based on the <nexus-write-format>.";
cout << endl << ">> <nexus-write-format>: hdf4, hdf5, xml";
cout << endl << ">> <idf>: 1 | 2";
cout << endl << ">>---------------------------------------------------------------------------------------";
cout << endl << endl;
}
@ -60,29 +60,39 @@ void nexus_read_test_syntax()
int main(int argc, char *argv[])
{
if (argc != 4) {
if ((argc != 5) && (argc !=2)) {
nexus_read_test_syntax();
return -1;
}
PNeXus *nxs_file = new PNeXus(argv[1]);
if (nxs_file->IsValid()) {
if (nxs_file->IsValid(true)) {
nxs_file->Dump();
char filename[128];
if (strstr(argv[3], "hdf") || strstr(argv[3], "xml")) {
snprintf(filename, sizeof(filename), "%s.%s", argv[2], argv[3]);
} else {
cerr << endl << "**ERROR** unkown nexus write format found" << endl;
nexus_read_test_syntax();
return -1;
}
if (argc == 5) {
long int idf = strtol(argv[4], (char **)NULL, 10);
if ((idf != 1) && (idf != 2)) {
if (nxs_file)
delete nxs_file;
nexus_read_test_syntax();
return -1;
}
if (nxs_file->WriteFile(filename, argv[3]) != NX_OK) {
cerr << endl << nxs_file->GetErrorMsg() << " (" << nxs_file->GetErrorCode() << ")" << endl << endl;
} else {
cout << endl << "file " << filename << " written successfully." << endl << endl;
char filename[128];
if (strstr(argv[3], "hdf") || strstr(argv[3], "xml")) {
snprintf(filename, sizeof(filename), "%s.%s", argv[2], argv[3]);
} else {
cerr << endl << "**ERROR** unkown nexus write format found" << endl;
nexus_read_test_syntax();
return -1;
}
if (nxs_file->WriteFile(filename, argv[3], (unsigned int)idf) != NX_OK) {
cerr << endl << nxs_file->GetErrorMsg() << " (" << nxs_file->GetErrorCode() << ")" << endl << endl;
} else {
cout << endl << "file " << filename << " written successfully." << endl << endl;
}
}
}