PNeXus.h

Go to the documentation of this file.

/***************************************************************************
 
  PNeXus.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 _PNEXUS_H_
#define _PNEXUS_H_
 
#include <string>
#include <vector>
#include <map>
#include <cctype>
#include <algorithm>
#include <any>
#include <cstdint>
 
#include "Minuit2/FCNBase.h"
 
#ifdef HAVE_HDF4
#include <mfhdf.h>
#include <hdf.h>
#endif // HAVE_HDF4
 
#include <H5Cpp.h>

namespace nxs {

enum class HDFType {
  HDF4,    
  HDF5,    
  Unknown  
};

HDFType checkHDFType(const std::string& filename);

std::string getIso8601TimestampLocal();
 
} // end namespace nxs
 
#ifdef HAVE_HDF4
namespace nxH4 {
 
class PNeXus;

class PNeXusDeadTime : public ROOT::Minuit2::FCNBase
{
public:
  PNeXusDeadTime(const PNeXus *nxs, bool debug=false);

  bool IsValid() { return fValid; }

  double Up() const { return fUp; }

  double operator()(const std::vector<double> &par) const;

  void Minimize(const int i);

  const std::vector<uint32_t>& GetDimensions() const { return fDims; }
 
private:
  bool fDebug{false};                        
  bool fValid;                                
  int fGoodFrames{-1};                        
  float fTimeResolution{0.0};                 
  std::vector<uint32_t>fDims = {0, 0, 0};    
  int fT0Bin{-1};                             
  int fFgbBin{-1};                            
  int fLgbBin{-1};                            
  std::vector<float> fDeadTime;               
  std::vector<int> fCounts;                   
  double fUp{0.5};                            
  unsigned int fIdx{0};                       
};
 

enum class H4DataType {
  kINT32,      
  kFLOAT32,    
  kFLOAT64,    
  kCHAR8,      
  kUINT32,     
  kINT16,      
  kUINT16,     
  kINT8,       
  kUINT8       
};

template <typename T> class PNXdata {
public:
  PNXdata() : fDataType(H4DataType::kINT32) {}

  PNXdata(const H4DataType& dataType) : fDataType(dataType) {}

  H4DataType GetDataType() const { return fDataType; }

  void SetDataType(const H4DataType& dataType) { fDataType = dataType; }

  const std::vector<T>& GetData() const { return fData; }

  std::vector<T>& GetData() { return fData; }

  void SetData(const std::vector<T>& data) { fData = data; }

  const std::vector<uint32_t>& GetDimensions() const { return fDimensions; }

  void SetDimensions(const std::vector<uint32_t>& dims) { fDimensions = dims; }

  size_t GetRank() const { return fDimensions.size(); }

  size_t GetNumElements() const {
    if (fDimensions.empty()) return 0;
    size_t total = 1;
    for (auto dim : fDimensions) {
        total *= dim;
      }
    return total;
  }

  void AddAttribute(const std::string& name, const std::any& value) {
    fAttributes[name] = value;
  }

  std::any GetAttribute(const std::string& name) const {
    return fAttributes.at(name);
  }

  bool HasAttribute(const std::string& name) const {
    return fAttributes.find(name) != fAttributes.end();
  }

  const std::map<std::string, std::any>& GetAttributes() const {
    return fAttributes;
  }

  std::map<std::string, std::any>& GetAttributes() {
    return fAttributes;
  }
 
private:
  H4DataType fDataType;                  
  std::vector<T> fData;                  
  std::vector<uint32_t> fDimensions;     
  std::map<std::string, std::any> fAttributes; 
};

class PNeXus {
public:
  PNeXus();

  PNeXus(const std::string fln, const bool printDebug=false);

  ~PNeXus();

  std::string GetFileName() const { return fFileName; }

  std::string GetHdf4LibVersion() const { return fHdf4LibVersion; }

  std::string GetHdf4Version() const { return fHdf4Version; }

  std::string GetNeXusVersion() const { return fNeXusVersion; }

  int GetIdfVersion() const { return fIdfVersion; }

  int ReadNexusFile();

  const std::map<std::string, std::any>& GetDataMap() const { return fDataMap; }

  std::map<std::string, std::any>& GetDataMap() { return fDataMap; }

  bool HasDataset(const std::string& path) const { return fDataMap.find(path) != fDataMap.end(); }

  template <typename T>
  void SetDataset(const std::string& path, const PNXdata<T>& data) {
    fDataMap[path] = data;
  }

  template <typename T>
  PNXdata<T> GetDataset(const std::string& path) const {
    return std::any_cast<PNXdata<T>>(fDataMap.at(path));
  }

  template <typename T>
  PNXdata<T>& GetDatasetRef(const std::string& path) {
    return std::any_cast<PNXdata<T>&>(fDataMap.at(path));
  }

  bool RemoveDataset(const std::string& path) {
    auto it = fDataMap.find(path);
    if (it != fDataMap.end()) {
        fDataMap.erase(it);
        return true;
      }
    return false;
  }

  void ClearDataMap() { fDataMap.clear(); }

  size_t GetNumDatasets() const { return fDataMap.size(); }

  template <typename T>
  bool UpdateDatasetData(const std::string& path, const std::vector<T>& newData) {
    if (!HasDataset(path)) return false;
    try {
        auto& dataset = std::any_cast<PNXdata<T>&>(fDataMap.at(path));
        dataset.SetData(newData);
        return true;
      } catch (const std::bad_any_cast&) {
        return false;
      }
  }

  template <typename T>
  bool UpdateDatasetDimensions(const std::string& path, const std::vector<uint32_t>& newDimensions) {
    if (!HasDataset(path)) return false;
    try {
        auto& dataset = std::any_cast<PNXdata<T>&>(fDataMap.at(path));
        dataset.SetDimensions(newDimensions);
        return true;
      } catch (const std::bad_any_cast&) {
        return false;
      }
  }

  template <typename T>
  bool AddDatasetAttribute(const std::string& path, const std::string& attrName,
                       const std::any& attrValue) {
    if (!HasDataset(path)) return false;
    try {
        auto& dataset = std::any_cast<PNXdata<T>&>(fDataMap.at(path));
        dataset.AddAttribute(attrName, attrValue);
        return true;
      } catch (const std::bad_any_cast&) {
        return false;
      }
  }

  template <typename T>
  bool RemoveDatasetAttribute(const std::string& path, const std::string& attrName) {
    if (!HasDataset(path)) return false;
    try {
        auto& dataset = std::any_cast<PNXdata<T>&>(fDataMap.at(path));
        auto& attrs = dataset.GetAttributes();
        auto it = attrs.find(attrName);
        if (it != attrs.end()) {
            attrs.erase(it);
            return true;
          }
        return false;
      } catch (const std::bad_any_cast&) {
        return false;
      }
  }

  template <typename T>
  bool AddDataset(const std::string& path, const std::vector<T>& data,
              const std::vector<uint32_t>& dimensions,
              const H4DataType& dataType = H4DataType::kINT32) {
    if (HasDataset(path)) return false;
    PNXdata<T> dataset(dataType);
    dataset.SetData(data);
    dataset.SetDimensions(dimensions);
    fDataMap[path] = dataset;
    return true;
  }

  template <typename T>
  bool ModifyDataset(const std::string& path, const std::vector<T>& newData,
                 const std::vector<uint32_t>& newDimensions) {
    if (!HasDataset(path)) return false;
    try {
        auto& dataset = std::any_cast<PNXdata<T>&>(fDataMap.at(path));
        dataset.SetData(newData);
        dataset.SetDimensions(newDimensions);
        return true;
      } catch (const std::bad_any_cast&) {
        return false;
      }
  }

  void Dump();

  int WriteNexusFile(const std::string& filename, int idfVersion = 2);

  bool AddGroupAttribute(const std::string& groupPath, const std::string& attrName,
                          const std::any& attrValue);

  bool RemoveGroupAttribute(const std::string& groupPath, const std::string& attrName);

  bool HasGroupAttribute(const std::string& groupPath, const std::string& attrName) const;

  std::any GetGroupAttribute(const std::string& groupPath, const std::string& attrName) const;

  const std::map<std::string, std::any>& GetGroupAttributes(const std::string& groupPath) const;

  bool ClearGroupAttributes(const std::string& groupPath);

  bool AddRootAttribute(const std::string& attrName, const std::any& attrValue);
 
private:
  bool fPrintDebug{false};  
  std::string fFileName{""}; 
  int fIdfVersion{-1}; 
  std::string fHdf4LibVersion{""}; 
  std::string fHdf4Version{""}; 
  std::string fNeXusVersion{""}; 
  std::string fFileNameNxs{""};
  std::string fFileTimeNxs{""};
  std::string fCreatorNxs{""};
  std::string fUserV1{""};
  int32 fSdId{-1};  
  int32 fFileId{-1}; 
  std::map<std::string, std::any> fDataMap; 
  std::map<std::string, std::map<std::string, std::any>> fGroupAttributes; 

  void HandleIdfV1(int32 sd_id);

  void HandleIdfV2(int32 sd_id);
 
  // ========================================================================
  // Write methods for HDF4 file creation
  // ========================================================================

  template <typename T>
  void WriteDatasetAttributes(int32 sds_id, const PNXdata<T>& data);

  void WriteVGroupAttributes(int32 vgroup_id,
                              const std::map<std::string, std::any>& attributes);

  int32 CreateVGroupHierarchy(int32 file_id, const std::string& path,
                               std::map<std::string, int32>& vgroupCache);

  int32 WriteIntDataset(int32 sd_id, const std::string& path,
                         const PNXdata<int>& data);

  int32 WriteFloatDataset(int32 sd_id, const std::string& path,
                           const PNXdata<float>& data);

  int32 WriteStringDataset(int32 sd_id, const std::string& path,
                            const PNXdata<std::string>& data);

  void WriteFileAttributes(int32 sd_id);
 
  // ========================================================================
  // Case-insensitive lookup helper methods
  // ========================================================================

  static bool CaseInsensitiveEquals(const std::string& a, const std::string& b);

  static std::vector<std::string> SplitPath(const std::string& path);

  std::string FindAttributeName(int32 sd_id, const std::string& requestedName);

  int32 FindDatasetIndex(int32 sd_id, const std::string& requestedName);

  int32 FindDatasetRefByPath(const std::string& path);
 
  // ========================================================================
  // Dataset reading helper methods
  // ========================================================================

  void ReadIntDataset(int32 sd_id, const std::string& path);

  void ReadFloatDataset(int32 sd_id, const std::string& path);

  void ReadStringDataset(int32 sd_id, const std::string& path);

  template <typename T>
  void ReadDatasetAttributes(int32 sds_id, PNXdata<T>& data);

  static H4DataType convertHdf4Type(int32 hdf4_type);

  static int32 convertToHdf4Type(H4DataType dataType);
};
 
} // end namespace nxH4
#endif // HAVE_HDF4

namespace nxH5 {
 
class PNeXus;

class PNeXusDeadTime : public ROOT::Minuit2::FCNBase
{
public:
  PNeXusDeadTime(const PNeXus *nxs, bool debug=false);

  bool IsValid() { return fValid; }

  double Up() const { return fUp; }

  double operator()(const std::vector<double> &par) const;

  void Minimize(const int i);

  const std::vector<hsize_t>& GetDimensions() const { return fDims; }

  std::vector<float> GetDeadTimeEstimated() { return fDeadTimeEstimated; }
 
private:
  bool fDebug{false};                        
  bool fValid;                                
  int fGoodFrames{-1};                        
  float fTimeResolution{0.0};                 
  std::vector<hsize_t>fDims = {0, 0, 0};     
  int fT0Bin{-1};                             
  int fFgbBin{-1};                            
  int fLgbBin{-1};                            
  std::vector<float> fDeadTime;               
  std::vector<float> fDeadTimeEstimated;      
  std::vector<int> fCounts;                   
  double fUp{0.5};                            
  unsigned int fIdx{0};                       
};
 

template <typename T> class PNXdata {
public:
  PNXdata() : fDataType(H5::PredType::NATIVE_INT) {}

  PNXdata(const H5::DataType& dataType) : fDataType(dataType) {}

  H5::DataType GetDataType() const { return fDataType; }

  void SetDataType(const H5::DataType& dataType) { fDataType = dataType; }

  const std::vector<T>& GetData() const { return fData; }

  std::vector<T>& GetData() { return fData; }

  void SetData(const std::vector<T>& data) { fData = data; }

  const std::vector<hsize_t>& GetDimensions() const { return fDimensions; }

  void SetDimensions(const std::vector<hsize_t>& dims) { fDimensions = dims; }

  size_t GetRank() const { return fDimensions.size(); }

  size_t GetNumElements() const {
    if (fDimensions.empty()) return 0;
    size_t total = 1;
    for (auto dim : fDimensions) {
      total *= dim;
    }
    return total;
  }

  void AddAttribute(const std::string& name, const std::any& value) {
    fAttributes[name] = value;
  }

  std::any GetAttribute(const std::string& name) const {
    return fAttributes.at(name);
  }

  bool HasAttribute(const std::string& name) const {
    return fAttributes.find(name) != fAttributes.end();
  }

  const std::map<std::string, std::any>& GetAttributes() const {
    return fAttributes;
  }

  std::map<std::string, std::any>& GetAttributes() {
    return fAttributes;
  }
 
private:
  H5::DataType fDataType;                
  std::vector<T> fData;                  
  std::vector<hsize_t> fDimensions;      
  std::map<std::string, std::any> fAttributes; 
};

class PNeXus {
public:
  PNeXus();

  PNeXus(const std::string fln, const bool printDebug=false);

  std::string GetFileName() const { return fFileName; }

  std::string GetHdf5LibVersion() const { return fHdf5LibVersion; }

  std::string GetHdf5Version() const { return fHdf5Version; }

  std::string GetNeXusVersion() const { return fNeXusVersion; }

  int GetIdfVersion() const { return fIdfVersion; }

  int ReadNexusFile();

  const std::map<std::string, std::any>& GetDataMap() const { return fDataMap; }

  std::map<std::string, std::any>& GetDataMap() { return fDataMap; }

  bool HasDataset(const std::string& path) const { return fDataMap.find(path) != fDataMap.end(); }

  template <typename T>
  void SetDataset(const std::string& path, const PNXdata<T>& data) {
    fDataMap[path] = data;
  }

  template <typename T>
  PNXdata<T> GetDataset(const std::string& path) const {
    return std::any_cast<PNXdata<T>>(fDataMap.at(path));
  }

  template <typename T>
  PNXdata<T>& GetDatasetRef(const std::string& path) {
    return std::any_cast<PNXdata<T>&>(fDataMap.at(path));
  }

  bool RemoveDataset(const std::string& path) {
    auto it = fDataMap.find(path);
    if (it != fDataMap.end()) {
      fDataMap.erase(it);
      return true;
    }
    return false;
  }

  void ClearDataMap() { fDataMap.clear(); }

  size_t GetNumDatasets() const { return fDataMap.size(); }

  template <typename T>
  bool UpdateDatasetData(const std::string& path, const std::vector<T>& newData) {
    if (!HasDataset(path)) return false;
    try {
      auto& dataset = std::any_cast<PNXdata<T>&>(fDataMap.at(path));
      dataset.SetData(newData);
      return true;
    } catch (const std::bad_any_cast&) {
      return false;
    }
  }

  template <typename T>
  bool UpdateDatasetDimensions(const std::string& path, const std::vector<hsize_t>& newDimensions) {
    if (!HasDataset(path)) return false;
    try {
      auto& dataset = std::any_cast<PNXdata<T>&>(fDataMap.at(path));
      dataset.SetDimensions(newDimensions);
      return true;
    } catch (const std::bad_any_cast&) {
      return false;
    }
  }

  template <typename T>
  bool AddDatasetAttribute(const std::string& path, const std::string& attrName,
                           const std::any& attrValue) {
    if (!HasDataset(path)) return false;
    try {
      auto& dataset = std::any_cast<PNXdata<T>&>(fDataMap.at(path));
      dataset.AddAttribute(attrName, attrValue);
      return true;
    } catch (const std::bad_any_cast&) {
      return false;
    }
  }

  template <typename T>
  bool RemoveDatasetAttribute(const std::string& path, const std::string& attrName) {
    if (!HasDataset(path)) return false;
    try {
      auto& dataset = std::any_cast<PNXdata<T>&>(fDataMap.at(path));
      auto& attrs = dataset.GetAttributes();
      auto it = attrs.find(attrName);
      if (it != attrs.end()) {
        attrs.erase(it);
        return true;
      }
      return false;
    } catch (const std::bad_any_cast&) {
      return false;
    }
  }

  template <typename T>
  bool AddDataset(const std::string& path, const std::vector<T>& data,
                  const std::vector<hsize_t>& dimensions,
                  const H5::DataType& dataType = H5::PredType::NATIVE_INT) {
    if (HasDataset(path)) return false;
    PNXdata<T> dataset(dataType);
    dataset.SetData(data);
    dataset.SetDimensions(dimensions);
    fDataMap[path] = dataset;
    return true;
  }

  template <typename T>
  bool ModifyDataset(const std::string& path, const std::vector<T>& newData,
                     const std::vector<hsize_t>& newDimensions) {
    if (!HasDataset(path)) return false;
    try {
      auto& dataset = std::any_cast<PNXdata<T>&>(fDataMap.at(path));
      dataset.SetData(newData);
      dataset.SetDimensions(newDimensions);
      return true;
    } catch (const std::bad_any_cast&) {
      return false;
    }
  }

  void Dump();

  int WriteNexusFile(const std::string& filename, int idfVersion = 2);

  bool AddGroupAttribute(const std::string& groupPath, const std::string& attrName,
                         const std::any& attrValue);

  bool RemoveGroupAttribute(const std::string& groupPath, const std::string& attrName);

  bool HasGroupAttribute(const std::string& groupPath, const std::string& attrName) const;

  std::any GetGroupAttribute(const std::string& groupPath, const std::string& attrName) const;

  const std::map<std::string, std::any>& GetGroupAttributes(const std::string& groupPath) const;

  bool ClearGroupAttributes(const std::string& groupPath);

  bool AddRootAttribute(const std::string& attrName, const std::any& attrValue);
 
private:
  bool fPrintDebug{false};  
  std::string fFileName{""}; 
  int fIdfVersion{-1}; 
  std::string fHdf5LibVersion{"n/a"}; 
  std::string fHdf5Version{""}; 
  std::string fNeXusVersion{""}; 
  std::string fFileNameNxs{""};
  std::string fFileTimeNxs{""};
  std::string fCreatorNxs{""};
  std::string fUserV1{""};
  std::map<std::string, std::any> fDataMap; 
  std::map<std::string, std::map<std::string, std::any>> fGroupAttributes; 

  void HandleIdfV1(H5::H5File &file);

  void HandleIdfV2(H5::H5File &file);
 
  // ========================================================================
  // Write methods for HDF5 file creation
  // ========================================================================

  H5::Group CreateGroupHierarchy(H5::H5File& file, const std::string& path);

  template <typename T>
  void WriteDatasetAttributes(H5::DataSet& dataset, const PNXdata<T>& data);

  void WriteGroupAttributes(H5::Group& group, const std::map<std::string, std::any>& attributes);

  void WriteIntDataset(H5::H5File& file, const std::string& path,
                       const PNXdata<int>& data);

  void WriteFloatDataset(H5::H5File& file, const std::string& path,
                         const PNXdata<float>& data);

  void WriteStringDataset(H5::H5File& file, const std::string& path,
                          const PNXdata<std::string>& data);

  void WriteFileAttributes(H5::H5File& file);
 
  // ========================================================================
  // Case-insensitive lookup helper methods
  // ========================================================================

  static bool CaseInsensitiveEquals(const std::string& a, const std::string& b);

  static std::vector<std::string> SplitPath(const std::string& path);

  std::string FindAttributeName(H5::H5File& obj, const std::string& requestedName);

  std::string FindGroupPath(H5::H5File& parent, const std::string& requestedPath);

  std::string FindGroupPath(H5::Group& parent, const std::string& requestedPath);

  std::string FindDatasetPath(H5::H5File& parent, const std::string& requestedPath);

  std::string FindDatasetPath(H5::Group& parent, const std::string& requestedPath);
 
  // ========================================================================
  // Dataset reading helper methods
  // ========================================================================

  void ReadIntDataset(H5::H5File& file, const std::string& path);

  void ReadFloatDataset(H5::H5File& file, const std::string& path);

  void ReadStringDataset(H5::H5File& file, const std::string& path);

  template <typename T>
  void ReadDatasetAttributes(H5::DataSet& dataset, PNXdata<T>& data);
};
 
} // end namespace nxH5
 
#endif // _PNEXUS_H_