PRunDataHandler.h

Go to the documentation of this file.

/***************************************************************************
 
  PRunDataHandler.h
 
  Author: Andreas Suter
  e-mail: andreas.suter@psi.ch
 
***************************************************************************/
 
/***************************************************************************
 *   Copyright (C) 2007-2026 by Andreas Suter                              *
 *   andreas.suter@psi.ch                                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#ifndef _PRUNDATAHANDLER_H_
#define _PRUNDATAHANDLER_H_
 
#include <any>
#include <iostream>
#include <string>
 
#include <TString.h>
 
#include "PMusr.h"
#include "PMsrHandler.h"
 
//-------------------------------------------------------------
#define A2M_UNDEFINED     0
#define A2M_ROOT          1
#define A2M_MUSR_ROOT     2
#define A2M_MUSR_ROOT_DIR 3
#define A2M_PSIBIN        4
#define A2M_PSIMDU        5
#define A2M_MUD           6
#define A2M_NEXUS         7
#define A2M_WKM           8
#define A2M_ASCII         9
 
//-------------------------------------------------------------
class PRunDataHandler
{
  public:
    PRunDataHandler();

    PRunDataHandler(TString fileName, const TString fileFormat);

    PRunDataHandler(TString fileName, const TString fileFormat, const PStringVector dataPath);

    PRunDataHandler(TString fileName, const TString fileFormat, const TString dataPath, PRawRunData &runData);

    PRunDataHandler(PAny2ManyInfo *any2ManyInfo);

    PRunDataHandler(PAny2ManyInfo *any2ManyInfo, const PStringVector dataPath);

    PRunDataHandler(PMsrHandler *msrInfo);

    PRunDataHandler(PMsrHandler *msrInfo, const PStringVector dataPath);

    virtual ~PRunDataHandler();

    virtual void ReadData();

    virtual void ConvertData();

    virtual Bool_t WriteData(TString fileName="");

    virtual Bool_t IsAllDataAvailable() const { return fAllDataAvailable; }

    virtual PRawRunData* GetRunData(const TString &runName);

    virtual PRawRunData* GetRunData(const UInt_t idx=0);

    virtual Int_t GetNoOfRunData() {return fData.size(); }

    virtual Bool_t SetRunData(PRawRunData *data, UInt_t idx=0);
 
  private:
    PMsrHandler   *fMsrInfo; 
    PAny2ManyInfo *fAny2ManyInfo; 
    PStringVector fDataPath; 
 
    Bool_t fAllDataAvailable; 
    TString fFileFormat;      
    TString fRunName;         
    TString fRunPathName;     
    PRawRunDataList fData;    
 
    virtual void Init(const Int_t tag=0);
    virtual Bool_t ReadFilesMsr();
    virtual Bool_t ReadWriteFilesList();
    virtual Bool_t FileAlreadyRead(TString runName);
    virtual void TestFileName(TString &runName, const TString &ext);
    virtual Bool_t FileExistsCheck(PMsrRunBlock &runInfo, const UInt_t idx);
    virtual Bool_t FileExistsCheck(const Bool_t fileName, const Int_t idx);
    virtual Bool_t FileExistsCheck(const TString fileName);
    virtual Bool_t ReadRootFile();
    template <typename T> Bool_t ReadNexusFileIdf1(T& nxs_file);
    template <typename T> Bool_t ReadNexusFileIdf2(T& nxs_file);
    virtual Bool_t ReadNexusFile();
    virtual Bool_t ReadWkmFile();
    virtual Bool_t ReadPsiBinFile();
    virtual Bool_t ReadMudFile();
    virtual Bool_t ReadMduAsciiFile();
    virtual Bool_t ReadAsciiFile();
    virtual Bool_t ReadDBFile();
    virtual Bool_t ReadDatFile();
 
    virtual Bool_t WriteMusrRootFile(Int_t tag=A2M_MUSR_ROOT_DIR, TString fln="");
    virtual Bool_t WriteRootFile(TString fln="");
    virtual Bool_t WriteNexusFile(TString format, TString fln="");
    virtual Bool_t WriteWkmFile(TString fln="");
    virtual Bool_t WritePsiBinFile(TString fln="");
    virtual Bool_t WriteMudFile(TString fln="");
    virtual Bool_t WriteAsciiFile(TString fln="");
 
    virtual Bool_t StripWhitespace(TString &str);
    virtual Bool_t IsWhitespace(const Char_t *str);
    virtual Double_t ToDouble(TString &str, Bool_t &ok);
    virtual Int_t ToInt(TString &str, Bool_t &ok);
    virtual Int_t GetDataTagIndex(TString &str, const PStringVector* fLabels);
 
    virtual TString GenerateOutputFileName(const TString fileName, const TString extension, Bool_t &ok);
    virtual TString GetFileName(const TString extension, Bool_t &ok);
    virtual TString FileNameFromTemplate(TString &fileNameTemplate, Int_t run, TString &year, Bool_t &ok);
    virtual bool DateToISO8601(std::string inDate, std::string &iso8601Date);
    virtual void SplitTimeDate(TString timeDate, TString &time, TString &date, Bool_t &ok);
    virtual TString GetMonth(Int_t month);
    virtual TString GetYear(Int_t month);
};
 
//--------------------------------------------------------------------------
// ReadNexusFileIdf1 (private)
//--------------------------------------------------------------------------
template <typename T>
Bool_t PRunDataHandler::ReadNexusFileIdf1(T& nxs_file)
{
  PRawRunData    runData;
  PRawRunDataSet dataSet;
  TString str;
  std::string sstr;
  Int_t ival;
  Double_t dval, factor;
  bool ok;
 
  // get header information
 
  // get/set laboratory
  sstr = "n/a";
  if (nxs_file->HasDataset("/run/lab"))
    sstr = nxs_file->template GetDataset<std::string>("/run/lab").GetData()[0];
  runData.SetLaboratory(sstr);
 
  // get/set beamline
  sstr = "n/a";
  if (nxs_file->HasDataset("/run/beamline"))
    sstr = nxs_file->template GetDataset<std::string>("/run/beamline").GetData()[0];
  runData.SetBeamline(sstr);
 
  // get/set instrument
  sstr = "n/a";
  if (nxs_file->HasDataset("/run/instrument/name"))
    sstr = nxs_file->template GetDataset<std::string>("/run/instrument/name").GetData()[0];
  runData.SetInstrument(sstr);
 
  // get/set run title
  str = "n/a";
  if (nxs_file->HasDataset("/run/title"))
    sstr = nxs_file->template GetDataset<std::string>("/run/title").GetData()[0];
  runData.SetRunTitle(sstr);
 
  // get/set run number
  ival = -1;
  if (nxs_file->HasDataset("/run/number"))
    ival = nxs_file->template GetDataset<int>("/run/number").GetData()[0];
  runData.SetRunNumber(ival);
 
  // get/set temperature
  dval = PMUSR_UNDEFINED;
  sstr = "n/a";
  if (nxs_file->HasDataset("/run/sample/temperature")) {
    auto tmp_ds = nxs_file->template GetDataset<float>("/run/sample/temperature");
    dval = tmp_ds.GetData()[0];
    if (tmp_ds.HasAttribute("units")) {
      try {
        sstr = std::any_cast<std::string>(tmp_ds.GetAttribute("units"));
      } catch (const std::bad_any_cast&) {
        std::cerr << std::endl << "**WARNING** ReadNexusFileIdf1: temperature 'units' attribute has unexpected type." << std::endl;
      }
    }
    if (sstr == "Celcius")
      dval += 273.16;
  }
  runData.SetTemperature(0, dval, 0.0);
 
  // get/set field
  dval = PMUSR_UNDEFINED;
  sstr = "n/a";
  factor = 1.0;
  if (nxs_file->HasDataset("/run/sample/magnetic_field")) {
    auto mag_ds = nxs_file->template GetDataset<float>("/run/sample/magnetic_field");
    dval = mag_ds.GetData()[0];
    if (mag_ds.HasAttribute("units")) {
      try {
        sstr = std::any_cast<std::string>(mag_ds.GetAttribute("units"));
      } catch (const std::bad_any_cast&) {
        std::cerr << std::endl << "**WARNING** ReadNexusFileIdf1: magnetic_field 'units' attribute has unexpected type." << std::endl;
      }
    }
    if (sstr == "Tesla")
      factor = 1.0e4;
  }
  runData.SetField(dval*factor);
 
  // 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
  sstr = "n/a";
  if (nxs_file->HasDataset("/run/notes"))
    sstr = nxs_file->template GetDataset<std::string>("/run/notes").GetData()[0];
  runData.SetSetup(sstr);
 
  // get/set sample
  sstr = "n/a";
  if (nxs_file->HasDataset("/run/sample/name"))
    sstr = nxs_file->template GetDataset<std::string>("/run/sample/name").GetData()[0];
  runData.SetSample(sstr);
 
  // get/set orientation
  runData.SetOrientation("??");
 
  // get/set time resolution (ns)
  dval = PMUSR_UNDEFINED;
  sstr = "n/a";
  factor = 1.0;
  if (nxs_file->HasDataset("/run/histogram_data_1/resolution")) {
    auto res_ds = nxs_file->template GetDataset<int>("/run/histogram_data_1/resolution");
    dval = res_ds.GetData()[0];
    if (res_ds.HasAttribute("units")) {
      try {
        sstr = std::any_cast<std::string>(res_ds.GetAttribute("units"));
      } catch (const std::bad_any_cast&) {
        std::cerr << std::endl << "**WARNING** ReadNexusFileIdf1: resolution 'units' attribute has unexpected type." << std::endl;
      }
    }
    if ((sstr == "picoseconds") || (sstr == "pico.seconds"))
      factor = 1.0e-3; // ps -> ns
  }
  runData.SetTimeResolution(dval*factor);
 
  // get/set start/stop time
  sstr = "n/a";
  TString date{"n/a"}, time{"n/a"};
  if (nxs_file->HasDataset("/run/start_time"))
    sstr = nxs_file->template GetDataset<std::string>("/run/start_time").GetData()[0];
  str = sstr;
  SplitTimeDate(str, time, date, ok);
  if (ok) {
    runData.SetStartTime(time);
    runData.SetStartDate(date);
  }
 
  sstr = "n/a";
  date = "n/a";
  time = "n/a";
  if (nxs_file->HasDataset("/run/stop_time"))
    sstr = nxs_file->template GetDataset<std::string>("/run/stop_time").GetData()[0];
  str = sstr;
  SplitTimeDate(str, time, date, ok);
  if (ok) {
    runData.SetStopTime(time);
    runData.SetStopDate(date);
  }
 
  // get/set deadtime relevant parameters
  if (nxs_file->HasDataset("/run/instrument/detector/deadtimes")) {
    std::vector<float> dt;
    dt = nxs_file->template GetDataset<float>("/run/instrument/detector/deadtimes").GetData();
    runData.SetDeadTimeParam(dt);
  }
  if (nxs_file->HasDataset("/run/instrument/beam/frames_good")) {
    ival = nxs_file->template GetDataset<int>("/run/instrument/beam/frames_good").GetData()[0];
    runData.SetNumberOfGoodFrames(ival);
  }
 
  // data with its metadata
  if (nxs_file->HasDataset("/run/histogram_data_1/counts")) {
    int t0_bin{-1}, fgb{-1}, lgb{-1}, noOfHistos{-1}, histoLength{-1};
    auto count_ds = nxs_file->template GetDataset<int>("/run/histogram_data_1/counts");
    auto count = count_ds.GetData();
    // get all necessary attributes
    auto castIntAttr = [](const std::any& val, const std::string& name) -> int {
      try {
        return std::any_cast<int>(val);
      } catch (const std::bad_any_cast&) {
        try {
          // Attribute may be stored as vector<int> when HDF4 attr_count > 1
          return std::any_cast<std::vector<int>>(val)[0];
        } catch (const std::bad_any_cast&) {
          std::cerr << std::endl << "**WARNING** ReadNexusFileIdf1: counts attribute '" << name
                    << "' has unexpected type; defaulting to -1." << std::endl;
          return -1;
        }
      }
    };
    if (count_ds.HasAttribute("t0_bin"))
      t0_bin = castIntAttr(count_ds.GetAttribute("t0_bin"), "t0_bin");
    if (count_ds.HasAttribute("first_good_bin"))
      fgb = castIntAttr(count_ds.GetAttribute("first_good_bin"), "first_good_bin");
    if (count_ds.HasAttribute("last_good_bin"))
      lgb = castIntAttr(count_ds.GetAttribute("last_good_bin"), "last_good_bin");
    if (count_ds.HasAttribute("number"))
      noOfHistos = castIntAttr(count_ds.GetAttribute("number"), "number");
    if (count_ds.HasAttribute("length"))
      histoLength = castIntAttr(count_ds.GetAttribute("length"), "length");
    if (static_cast<int>(count.size()) != noOfHistos*histoLength) {
      std::cerr << std::endl << "**ERROR** PNeXus data size error! count.size()=" << count.size() << ", #histos=" << noOfHistos << ", length=" << histoLength << "." << std::endl;
      return false;
    }
    // fill dataSet
    PDoubleVector data;
    for (int i=0; i<noOfHistos; i++) {
      dataSet.Clear();
      dataSet.SetHistoNo(i+1); // i.e. histo numbers start with 1
      dataSet.SetTimeZeroBin(t0_bin);
      dataSet.SetFirstGoodBin(fgb);
      dataSet.SetLastGoodBin(lgb);
      for (int j=0; j<histoLength; j++)
        data.push_back(count[i*histoLength+j]);
      dataSet.SetData(data);
      runData.SetDataSet(dataSet);
      data.clear();
    }
 
    // keep run name from the msr-file
    runData.SetRunName(fRunName);
 
    // keep the information
    fData.push_back(runData);
  } else { // no data found
    std::cerr << std::endl << "**ERROR** PNeXus couldn't obtain data: '/run/histogram_data_1/counts' is missing." << std::endl;
    return false;
  }
 
  return true;
}
 
//--------------------------------------------------------------------------
// ReadNexusFileIdf2 (private)
//--------------------------------------------------------------------------
template <typename T>
Bool_t PRunDataHandler::ReadNexusFileIdf2(T& nxs_file)
{
  PRawRunData    runData;
  PRawRunDataSet dataSet;
  TString str;
  std::string sstr;
  Int_t ival;
  Double_t dval, factor;
  bool ok;
 
  // get header information
 
  // get/set laboratory
  sstr = "n/a";
  if (nxs_file->HasDataset("/raw_data_1/instrument/source/name"))
    sstr = nxs_file->template GetDataset<std::string>("/raw_data_1/instrument/source/name").GetData()[0];
  runData.SetLaboratory(sstr);
 
  // get/set beamline
  sstr = "n/a";
  if (nxs_file->HasDataset("/raw_data_1/instrument/name"))
    sstr = nxs_file->template GetDataset<std::string>("/raw_data_1/instrument/name").GetData()[0];
  runData.SetBeamline(sstr);
  runData.SetBeamline(sstr);
 
  // get/set muon source
  sstr = "n/a";
  if (nxs_file->HasDataset("/raw_data_1/instrument/source/type"))
    sstr = nxs_file->template GetDataset<std::string>("/raw_data_1/instrument/source/type").GetData()[0];
  runData.SetMuonSource(sstr);
 
  // get/set muon species
  sstr = "n/a";
  if (nxs_file->HasDataset("/raw_data_1/instrument/source/probe"))
    sstr = nxs_file->template GetDataset<std::string>("/raw_data_1/instrument/source/probe").GetData()[0];
  runData.SetMuonSpecies(sstr);
 
  // get/set run title
  sstr = "n/a";
  if (nxs_file->HasDataset("/raw_data_1/title"))
    sstr = nxs_file->template GetDataset<std::string>("/raw_data_1/title").GetData()[0];
  runData.SetRunTitle(sstr);
 
  // get/set run number
  ival = -1;
  if (nxs_file->HasDataset("/raw_data_1/run_number"))
    ival = nxs_file->template GetDataset<int>("/raw_data_1/run_number").GetData()[0];
  runData.SetRunNumber(ival);
 
  // get/set temperature
  dval = PMUSR_UNDEFINED;
  sstr = "n/a";
  if (nxs_file->HasDataset("/raw_data_1/sample/temperature")) {
    auto tmp_ds = nxs_file->template GetDataset<float>("/raw_data_1/sample/temperature");
    dval = tmp_ds.GetData()[0];
    if (tmp_ds.HasAttribute("units"))
      sstr = std::any_cast<std::string>(tmp_ds.GetAttribute("units"));
    if (sstr == "Celcius")
      dval += 273.16;
  }
  runData.SetTemperature(0, dval, 0.0);
 
  // get/set field
  dval = PMUSR_UNDEFINED;
  sstr = "n/a";
  factor = 1.0;
  if (nxs_file->HasDataset("/raw_data_1/sample/magnetic_field")) {
    auto mag_ds = nxs_file->template GetDataset<float>("/raw_data_1/sample/magnetic_field");
    dval = mag_ds.GetData()[0];
    if (mag_ds.HasAttribute("units"))
      sstr = std::any_cast<std::string>(mag_ds.GetAttribute("units"));
    if (sstr == "Tesla")
      factor = 1.0e4;
  }
  runData.SetField(dval*factor);
 
  // get/set implantation energy
  runData.SetEnergy(PMUSR_UNDEFINED);
 
  // 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
  sstr  = "n/a";
  runData.SetSetup(str);
 
  // get/set sample
  sstr = "n/a";
  if (nxs_file->HasDataset("/raw_data_1/sample/name"))
    sstr = nxs_file->template GetDataset<std::string>("/raw_data_1/sample/name").GetData()[0];
  runData.SetSample(sstr);
 
  // get/set orientation
  runData.SetOrientation("n/a");
 
  // get/set time resolution (ns)
  dval = PMUSR_UNDEFINED;
  sstr = "n/a";
  factor = 1.0;
  if (nxs_file->HasDataset("/raw_data_1/instrument/detector_1/resolution")) {
    auto res_ds = nxs_file->template GetDataset<int>("/raw_data_1/instrument/detector_1/resolution");
    dval = res_ds.GetData()[0];
    if (res_ds.HasAttribute("units"))
      sstr = std::any_cast<std::string>(res_ds.GetAttribute("units"));
    if ((sstr == "picoseconds") || (sstr == "pico.seconds"))
      factor = 1.0e-3; // ps -> ns
  }
  runData.SetTimeResolution(dval*factor);
 
  // get/set start/stop time
  sstr = "n/a";
  TString date{"n/a"}, time{"n/a"};
  if (nxs_file->HasDataset("/raw_data_1/start_time"))
    sstr = nxs_file->template GetDataset<std::string>("/raw_data_1/start_time").GetData()[0];
  str = sstr;
  SplitTimeDate(str, time, date, ok);
  if (ok) {
    runData.SetStartTime(time);
    runData.SetStartDate(date);
  }
 
  sstr = "n/a";
  date = "n/a";
  time = "n/a";
  if (nxs_file->HasDataset("/raw_data_1/end_time"))
    sstr = nxs_file->template GetDataset<std::string>("/raw_data_1/end_time").GetData()[0];
  str = sstr;
  SplitTimeDate(str, time, date, ok);
  if (ok) {
    runData.SetStopTime(time);
    runData.SetStopDate(date);
  }
 
  // get/set deadtime relevant parameters
  if (nxs_file->HasDataset("/raw_data_1/instrument/detector_1/dead_time")) {
    std::vector<float> dt;
    dt = nxs_file->template GetDataset<float>("/raw_data_1/instrument/detector_1/dead_time").GetData();
    runData.SetDeadTimeParam(dt);
  }
  if (nxs_file->HasDataset("/raw_data_1/good_frames")) {
    ival = nxs_file->template GetDataset<int>("/raw_data_1/good_frames").GetData()[0];
    runData.SetNumberOfGoodFrames(ival);
  }
 
  // data with its metadata
  if (nxs_file->HasDataset("/raw_data_1/instrument/detector_1/counts")) {
    int t0_bin{-1}, fgb{-1}, lgb{-1}, noOfPeriods{-1}, noOfHistos{-1}, histoLength{-1};
    auto count_ds = nxs_file->template GetDataset<int>("/raw_data_1/instrument/detector_1/counts");
    auto count = count_ds.GetData();
    auto dims = count_ds.GetDimensions();
    if (dims.size() < 3) {
      std::cerr << std::endl << "**ERROR** PNeXus data dimension error! dims.size()=" << dims.size() << ", expecting == 3." << std::endl;
      return false;
    }
    noOfPeriods = dims[0];
    noOfHistos = dims[1];
    histoLength = dims[2];
    // needed to properly address period related information like the dead time parameters
    runData.SetNoOfHistosPerPeriod(noOfHistos);
    // get all necessary attributes
    if (count_ds.HasAttribute("t0_bin"))
      t0_bin = std::any_cast<int>(count_ds.GetAttribute("t0_bin"));
    if (count_ds.HasAttribute("first_good_bin"))
      fgb = std::any_cast<int>(count_ds.GetAttribute("first_good_bin"));
    if (count_ds.HasAttribute("last_good_bin"))
      lgb = std::any_cast<int>(count_ds.GetAttribute("last_good_bin"));
    if (static_cast<int>(count.size()) != noOfPeriods*noOfHistos*histoLength) {
      std::cerr << std::endl << "**ERROR** PNeXus data size error! count.size()=" << count.size() << ", #periods=" << noOfPeriods << ", #histos=" << noOfHistos << ", length=" << histoLength << "." << std::endl;
      return false;
    }
 
    // fill dataSet
    PDoubleVector data;
    for (int i=0; i<noOfPeriods; i++) {
      for (int j=0; j<noOfHistos; j++) {
        dataSet.Clear();
        dataSet.SetHistoNo(i*PERIOD_HISTO_OFFSET+j+1); // i.e. histo numbers start with 1
        dataSet.SetTimeZeroBin(t0_bin);
        dataSet.SetFirstGoodBin(fgb);
        dataSet.SetLastGoodBin(lgb);
        for (int k=0; k<histoLength; k++)
          data.push_back(count[i*noOfHistos*histoLength+j*histoLength+k]);
        dataSet.SetData(data);
        runData.SetDataSet(dataSet);
        data.clear();
      }
    }
 
    // keep run name from the msr-file
    runData.SetRunName(fRunName);
 
    // keep the information
    fData.push_back(runData);
  }
 
  return true;
}
 
#endif //  _PRUNDATAHANDLER_H_