PNeXus.cpp

Go to the documentation of this file.

/***************************************************************************
 
  PNeXus.cpp
 
  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.             *
 ***************************************************************************/

 
#include <iostream>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <cstring>
#include <cmath>
#include <chrono>
#include <ctime>
#include <iomanip>
 
#include "Minuit2/MnStrategy.h"
#include "Minuit2/MnMinimize.h"
#include "Minuit2/FunctionMinimum.h"
 
#include "PNeXus.h"
 
//=============================================================================
// nxs::checkHDFType - Determine HDF file format from magic bytes
//=============================================================================
nxs::HDFType nxs::checkHDFType(const std::string& filename) {
 
  std::ifstream file(filename, std::ios::binary);
  if (!file.is_open()) {
    std::cerr << "Error: Cannot open file '" << filename << "'" << std::endl;
    return nxs::HDFType::Unknown;
  }
 
  // Read first 8 bytes (enough for both signatures)
  unsigned char header[8];
  file.read(reinterpret_cast<char*>(header), 8);
 
  if (file.gcount() < 4) {
    std::cerr << "**Error**: File too small to be HDF4 or HDF5" << std::endl;
    return nxs::HDFType::Unknown;
  }
 
  // HDF5 signature: 0x89 'H' 'D' 'F' 0x0d 0x0a 0x1a 0x0a
  const unsigned char hdf5_sig[8] = {0x89, 0x48, 0x44, 0x46, 0x0d, 0x0a, 0x1a, 0x0a};
 
  // HDF4 signature: 0x0e 0x03 0x13 0x01
  const unsigned char hdf4_sig[4] = {0x0e, 0x03, 0x13, 0x01};
 
  // Check HDF5 first (needs 8 bytes)
  if (file.gcount() >= 8 && std::memcmp(header, hdf5_sig, 8) == 0) {
    return nxs::HDFType::HDF5;
  }
 
  // Check HDF4 (needs 4 bytes)
  if (std::memcmp(header, hdf4_sig, 4) == 0) {
    return nxs::HDFType::HDF4;
  }
 
  return nxs::HDFType::Unknown;
}
 
//=============================================================================
// nxs::getIso8601TimestampLocal - current time stamp in ISO8601 format
//=============================================================================
std::string nxs::getIso8601TimestampLocal() {
  auto now = std::chrono::system_clock::now();
  std::time_t now_c = std::chrono::system_clock::to_time_t(now);
  std::tm* local_tm = std::localtime(&now_c);
 
  // Get timezone offset
  char tz_offset[10];
  std::strftime(tz_offset, sizeof(tz_offset), "%z", local_tm);
 
  std::ostringstream oss;
  oss << std::put_time(local_tm, "%Y-%m-%dT%H:%M:%S");
 
  // Insert colon in timezone offset: +0100 → +01:00
  std::string tz_str(tz_offset);
  tz_str.insert(3, ":");
  oss << tz_str;
 
  return oss.str();
}
 
#ifdef HAVE_HDF4
namespace {
int32 Vgetname_portable(int32 vkey, char *vgname, size_t bufSize)
{
#ifdef HDF4_VGETNAME_HAS_BUFSIZE
  return Vgetname(vkey, vgname, &bufSize);
#else
  (void)bufSize;
  return Vgetname(vkey, vgname);
#endif
}
} // namespace
 
//=============================================================================
// nxH4::PNeXusDeadTime Constructor
//=============================================================================
nxH4::PNeXusDeadTime::PNeXusDeadTime(const nxH4::PNeXus *nxs, bool debug) : fDebug(debug)
{
  std::map<std::string, std::any> dataMap = nxs->GetDataMap();
 
  int idfVersion = nxs->GetIdfVersion();
  if ((idfVersion != 1) && (idfVersion != 2)) {
    std::stringstream err;
    err << "**ERROR** Found unsupported IDF version '" << idfVersion << "'";
    std::cout << err.str() << std::endl;
    fValid = false;
    return;
  }
 
  if (idfVersion == 1) {
    // not yet implemented
  } else { // idfVersion == 2
    // get counts
    if (dataMap.find("/raw_data_1/instrument/detector_1/counts") != dataMap.end()) {
      auto counts_data = std::any_cast<PNXdata<int>>(dataMap["/raw_data_1/instrument/detector_1/counts"]);
      const auto& counts = counts_data.GetData();
      fCounts = counts;
      auto dims = counts_data.GetDimensions();
      if (fDebug) {
        std::cout << " counts dimensions: " << dims[0] << " x "
                  << dims[1] << " x " << dims[2] << std::endl;
      }
      fDims = dims;
    } else {
      std::cout << "**ERROR** Couldn't find 'counts' dataset" << std::endl;
      fValid = false;
      return;
    }
 
    // get time_resolution
    if (dataMap.find("/raw_data_1/instrument/detector_1/time_resolution") != dataMap.end()) {
      auto time_res_data = std::any_cast<PNXdata<float>>(dataMap["/raw_data_1/instrument/detector_1/time_resolution"]);
      const auto& time_res = time_res_data.GetData();
      if (time_res.size() > 0) {
        fTimeResolution = time_res[0];
        if (fDebug) {
          std::cout << " time resolution: " << fTimeResolution << " ps" << std::endl;
        }
      }
    } else {
      std::cout << "**ERROR** Couldn't find 'time_resolution' dataset" << std::endl;
      fValid = false;
      return;
    }
 
    // get good_frames
    if (dataMap.find("/raw_data_1/good_frames") != dataMap.end()) {
      auto good_frames_data = std::any_cast<PNXdata<int>>(dataMap["/raw_data_1/good_frames"]);
      const auto& good_frames = good_frames_data.GetData();
      if (good_frames.size() > 0) {
        fGoodFrames = good_frames[0];
        if (fDebug) {
          std::cout << " good frames: " << fGoodFrames << std::endl;
        }
      }
    } else {
      std::cout << "**ERROR** Couldn't find 'good_frames' dataset" << std::endl;
      fValid = false;
      return;
    }
 
    // get t0_bin, first_good_bin, last_good_bin
    if (dataMap.find("/raw_data_1/instrument/detector_1/spectrum_index") != dataMap.end()) {
      auto spec_idx_data = std::any_cast<PNXdata<int>>(dataMap["/raw_data_1/instrument/detector_1/spectrum_index"]);
      if (spec_idx_data.HasAttribute("t0_bin")) {
        try {
          fT0Bin = std::any_cast<int>(spec_idx_data.GetAttribute("t0_bin"));
        } catch (...) {
          std::cout << "**WARNING** Couldn't read t0_bin attribute" << std::endl;
        }
      }
 
      if (spec_idx_data.HasAttribute("first_good_bin")) {
        try {
          fFgbBin = std::any_cast<int>(spec_idx_data.GetAttribute("first_good_bin"));
        } catch (...) {
          std::cout << "**WARNING** Couldn't read first_good_bin attribute" << std::endl;
        }
      }
 
      if (spec_idx_data.HasAttribute("last_good_bin")) {
        try {
          fLgbBin = std::any_cast<int>(spec_idx_data.GetAttribute("last_good_bin"));
        } catch (...) {
          std::cout << "**WARNING** Couldn't read last_good_bin attribute" << std::endl;
        }
      }
    }
 
    if (fDebug) {
      std::cout << " t0_bin: " << fT0Bin << ", first_good_bin: " << fFgbBin
                << ", last_good_bin: " << fLgbBin << std::endl;
    }
  }
 
  fValid = true;
}
 
//=============================================================================
// PNeXusDeadTime::operator()
//=============================================================================
double nxH4::PNeXusDeadTime::operator()(const std::vector<double> &par) const
{
  double chisq = 0.0;
  double tau = par[0]; // dead time in microseconds
 
  // Convert time resolution from ps to microseconds
  double dt = fTimeResolution * 1.0e-6; // ps -> us
 
  // Calculate chi-square for the specified spectrum
  int period = 0; // assuming single period
 
  for (unsigned int bin = fFgbBin; bin <= static_cast<unsigned int>(fLgbBin); bin++) {
    int idx = period * fDims[1] * fDims[2] + fIdx * fDims[2] + bin;
    double n_obs = static_cast<double>(fCounts[idx]);
 
    if (n_obs > 0) {
      // Dead time correction: n_true = n_obs / (1 - n_obs * tau / (good_frames * dt))
      double correction = 1.0 - (n_obs * tau) / (fGoodFrames * dt);
      if (correction > 0) {
        double n_expected = n_obs / correction;
        double diff = n_obs - n_expected;
        chisq += (diff * diff) / n_expected;
      }
    }
  }
 
  return chisq;
}
 
//=============================================================================
// PNeXusDeadTime::minimize
//=============================================================================
void nxH4::PNeXusDeadTime::Minimize(const int i)
{
  if (i < 0 || i >= static_cast<int>(fDims[1])) {
    std::cerr << "**ERROR** Invalid spectrum index: " << i << std::endl;
    return;
  }
 
  fIdx = static_cast<unsigned int>(i);
 
  ROOT::Minuit2::MnUserParameters upar;
  upar.Add("dead_time", 0.1, 0.01); // initial value, step size
  upar.SetLimits("dead_time", 0.0, 10.0); // limits in microseconds
 
  ROOT::Minuit2::MnMinimize minimize(*this, upar);
  ROOT::Minuit2::FunctionMinimum min = minimize();
 
  std::cout << "Spectrum " << i << ": ";
  if (min.IsValid()) {
    double dt = min.UserState().Value("dead_time");
    double dt_err = min.UserState().Error("dead_time");
    std::cout << "Dead time = " << dt << " +/- " << dt_err << " us" << std::endl;
  } else {
    std::cout << "Minimization failed" << std::endl;
  }
}
 
//=============================================================================
// PNeXus Default Constructor
//=============================================================================
nxH4::PNeXus::PNeXus() : fSdId(-1), fFileId(-1)
{
  uint32 major_v, minor_v, release;
  char string[256];
  Hgetlibversion(&major_v, &minor_v, &release, string);
  fHdf4LibVersion = string;
}
 
//=============================================================================
// PNeXus Constructor with filename
//=============================================================================
nxH4::PNeXus::PNeXus(const std::string fln, const bool printDebug)
  : fPrintDebug(printDebug), fFileName(fln), fSdId(-1), fFileId(-1)
{
  uint32 major_v, minor_v, release;
  char string[256];
  Hgetlibversion(&major_v, &minor_v, &release, string);
  fHdf4LibVersion = string;
 
  if (ReadNexusFile() != 0) {
    throw std::runtime_error("Failed to read NeXus file: " + fln);
  }
}
 
//=============================================================================
// PNeXus Destructor
//=============================================================================
nxH4::PNeXus::~PNeXus()
{
  if (fSdId != -1) {
    SDend(fSdId);
  }
  if (fFileId != -1) {
    Hclose(fFileId);
  }
}
 
//=============================================================================
// PNeXus::ReadNexusFile
//=============================================================================
int nxH4::PNeXus::ReadNexusFile()
{
  // Open the HDF4 file
  fSdId = SDstart(fFileName.c_str(), DFACC_READ);
  if (fSdId == FAIL) {
    std::cerr << "**ERROR** Failed to open HDF4 file: " << fFileName << std::endl;
    return 1;
  }
 
  fFileId = Hopen(fFileName.c_str(), DFACC_READ, 0);
  if (fFileId == FAIL) {
    std::cerr << "**ERROR** Failed to open HDF4 file (H interface): " << fFileName << std::endl;
    SDend(fSdId);
    fSdId = -1;
    return 1;
  }
 
  // Read file-level attributes
  int32 n_datasets, n_file_attrs;
  if (SDfileinfo(fSdId, &n_datasets, &n_file_attrs) == FAIL) {
    std::cerr << "**ERROR** Failed to get file info" << std::endl;
    return 1;
  }
 
  if (fPrintDebug) {
    std::cout << "Number of datasets: " << n_datasets << std::endl;
    std::cout << "Number of file attributes: " << n_file_attrs << std::endl;
  }
 
  // Read HDF4 version and NeXus version from attributes
  char attr_name[H4_MAX_NC_NAME];
  int32 attr_type, attr_count;
 
  for (int32 i = 0; i < n_file_attrs; i++) {
    if (SDattrinfo(fSdId, i, attr_name, &attr_type, &attr_count) == FAIL) {
      continue;
    }
 
    if (CaseInsensitiveEquals(attr_name, "HDF_version") ||
        CaseInsensitiveEquals(attr_name, "HDF4_version")) {
      std::vector<char> buffer(attr_count + 1, '\0');
      if (SDreadattr(fSdId, i, buffer.data()) != FAIL) {
        fHdf4Version = std::string(buffer.data());
      }
    } else if (CaseInsensitiveEquals(attr_name, "NeXus_version")) {
      std::vector<char> buffer(attr_count + 1, '\0');
      if (SDreadattr(fSdId, i, buffer.data()) != FAIL) {
        fNeXusVersion = std::string(buffer.data());
      }
    } else if (CaseInsensitiveEquals(attr_name, "file_name")) {
      std::vector<char> buffer(attr_count + 1, '\0');
      if (SDreadattr(fSdId, i, buffer.data()) != FAIL) {
        fFileNameNxs = std::string(buffer.data());
      }
    } else if (CaseInsensitiveEquals(attr_name, "file_time")) {
      std::vector<char> buffer(attr_count + 1, '\0');
      if (SDreadattr(fSdId, i, buffer.data()) != FAIL) {
        fFileTimeNxs = std::string(buffer.data());
      }
    }
  }
 
  // Determine IDF version
  // Try to find IDF_version dataset - check multiple possible locations
 
  // First try simple root-level name
  int32 idf_idx = SDnametoindex(fSdId, "IDF_version");
  if (idf_idx != FAIL) {
    int32 sds_id = SDselect(fSdId, idf_idx);
    if (sds_id != FAIL) {
      int32 rank, dim_sizes[H4_MAX_VAR_DIMS], data_type, n_attrs;
      char name[H4_MAX_NC_NAME];
      if (SDgetinfo(sds_id, name, &rank, dim_sizes, &data_type, &n_attrs) != FAIL) {
        if (data_type == DFNT_INT32) {
          int32 idf_val;
          int32 start[H4_MAX_VAR_DIMS] = {0};
          int32 edges[H4_MAX_VAR_DIMS] = {1};
          if (SDreaddata(sds_id, start, nullptr, edges, &idf_val) != FAIL) {
            fIdfVersion = idf_val;
          }
        }
      }
      SDendaccess(sds_id);
    }
  }
 
  // If not found, try /run/IDF_version (IDF version 1 location)
  if (fIdfVersion == -1) {
    try {
      int32 sds_ref = FindDatasetRefByPath("/run/IDF_version");
      if (sds_ref != -1) {
        int32 sds_idx = SDreftoindex(fSdId, sds_ref);
        if (sds_idx != FAIL) {
          int32 sds_id = SDselect(fSdId, sds_idx);
          if (sds_id != FAIL) {
            int32 rank, dim_sizes[H4_MAX_VAR_DIMS], data_type, n_attrs;
            char name[H4_MAX_NC_NAME];
            if (SDgetinfo(sds_id, name, &rank, dim_sizes, &data_type, &n_attrs) != FAIL) {
              if (data_type == DFNT_INT32) {
                int32 idf_val;
                int32 start[H4_MAX_VAR_DIMS] = {0};
                int32 edges[H4_MAX_VAR_DIMS] = {1};
                if (SDreaddata(sds_id, start, nullptr, edges, &idf_val) != FAIL) {
                  fIdfVersion = idf_val;
                }
              }
            }
            SDendaccess(sds_id);
          }
        }
      }
    } catch (...) {
      // Path not found, continue to next attempt
    }
  }
 
  // If still not found, try /raw_data_1/idf_version (IDF version 2 location)
  if (fIdfVersion == -1) {
    try {
      int32 sds_ref = FindDatasetRefByPath("/raw_data_1/idf_version");
      if (sds_ref != -1) {
        int32 sds_idx = SDreftoindex(fSdId, sds_ref);
        if (sds_idx != FAIL) {
          int32 sds_id = SDselect(fSdId, sds_idx);
          if (sds_id != FAIL) {
            int32 rank, dim_sizes[H4_MAX_VAR_DIMS], data_type, n_attrs;
            char name[H4_MAX_NC_NAME];
            if (SDgetinfo(sds_id, name, &rank, dim_sizes, &data_type, &n_attrs) != FAIL) {
              if (data_type == DFNT_INT32) {
                int32 idf_val;
                int32 start[H4_MAX_VAR_DIMS] = {0};
                int32 edges[H4_MAX_VAR_DIMS] = {1};
                if (SDreaddata(sds_id, start, nullptr, edges, &idf_val) != FAIL) {
                  fIdfVersion = idf_val;
                }
              }
            }
            SDendaccess(sds_id);
          }
        }
      }
    } catch (...) {
      // Path not found, will use default
    }
  }
 
  if (fIdfVersion == -1) {
    // Try alternate approach - check for raw_data_1 structure
    // If we find raw_data_1/detector_1, assume IDF v2
    // Otherwise assume IDF v1
    fIdfVersion = 2; // default to version 2
  }
 
  if (fPrintDebug) {
    std::cout << "HDF4 Version: " << fHdf4Version << std::endl;
    std::cout << "NeXus Version: " << fNeXusVersion << std::endl;
    std::cout << "IDF Version: " << fIdfVersion << std::endl;
  }
 
  // Read datasets based on IDF version
  if (fIdfVersion == 1) {
    HandleIdfV1(fSdId);
  } else if (fIdfVersion == 2) {
    HandleIdfV2(fSdId);
  } else {
    std::cerr << "**ERROR** Unsupported IDF version: " << fIdfVersion << std::endl;
    return 1;
  }
 
  return 0;
}
 
//=============================================================================
// nxH4::PNeXus::HandleIdfV1
//=============================================================================
void nxH4::PNeXus::HandleIdfV1(int32 sd_id)
{
  // IDF version 1 handling - not yet implemented
  if (fPrintDebug) {
    std::cout << "IDF version 1 handling ..." << std::endl;
  }
 
  std::vector<std::string> int_datasets = {
    "/run/IDF_version",
    "/run/number",
    "/run/switching_states",
    "/run/instrument/detector/number",
    "/run/instrument/beam/frames_good",
    "/run/histogram_data_1/counts",
    "/run/histogram_data_1/resolution",
    "/run/histogram_data_1/grouping"
  };
 
  std::vector<std::string> float_datasets = {
    "/run/sample/temperature",
    "/run/sample/magnetic_field",
    "/run/sample/magnetic_field_vector",
    "/run/instrument/detector/deadtimes",
    "/run/histogram_data_1/time_zero",
    "/run/histogram_data_1/raw_time",
    "/run/histogram_data_1/corrected_time",
    "/run/histogram_data_1/alpha"
  };
 
  std::vector<std::string> string_datasets = {
    "/run/program_name",
    "/run/title",
    "/run/notes",
    "/run/analysis",
    "/run/lab",
    "/run/beamline",
    "/run/start_time",
    "/run/stop_time",
    "/run/user/name",
    "/run/user/experiment_number",
    "/run/sample/name",
    "/run/sample/magnetic_field_state",
    "/run/sample/environment",
    "/run/instrument/name",
    "/run/instrument/collimator/type"
  };
 
  // Read integer datasets
  for (const auto& path : int_datasets) {
    try {
      ReadIntDataset(sd_id, path);
    } catch (const std::exception& e) {
      if (fPrintDebug) {
        std::cout << "Note: Could not read " << path << ": " << e.what() << std::endl;
      }
    }
  }
 
  // Read float datasets
  for (const auto& path : float_datasets) {
    try {
      ReadFloatDataset(sd_id, path);
    } catch (const std::exception& e) {
      if (fPrintDebug) {
        std::cout << "Note: Could not read " << path << ": " << e.what() << std::endl;
      }
    }
  }
 
  // Read string datasets
  for (const auto& path : string_datasets) {
    try {
      ReadStringDataset(sd_id, path);
    } catch (const std::exception& e) {
      if (fPrintDebug) {
        std::cout << "Note: Could not read " << path << ": " << e.what() << std::endl;
      }
    }
  }
}
 
//=============================================================================
// nxH4::PNeXus::HandleIdfV2
//=============================================================================
void nxH4::PNeXus::HandleIdfV2(int32 sd_id)
{
  // Read common datasets for IDF version 2
  // These are typical datasets found in muon NeXus files
 
  std::vector<std::string> int_datasets = {
    "/raw_data_1/instrument/detector_1/counts",
    "/raw_data_1/instrument/detector_1/spectrum_index",
    "/raw_data_1/good_frames",
    "/raw_data_1/instrument/detector_1/raw_time",
    "/raw_data_1/run_number"
  };
 
  std::vector<std::string> float_datasets = {
    "/raw_data_1/instrument/detector_1/resolution",
    "/raw_data_1/instrument/detector_1/time_zero"
  };
 
  std::vector<std::string> string_datasets = {
    "/raw_data_1/name",
    "/raw_data_1/title",
    "/raw_data_1/start_time",
    "/raw_data_1/end_time"
  };
 
  // Read integer datasets
  for (const auto& path : int_datasets) {
    try {
      ReadIntDataset(sd_id, path);
    } catch (const std::exception& e) {
      if (fPrintDebug) {
        std::cout << "Note: Could not read " << path << ": " << e.what() << std::endl;
      }
    }
  }
 
  // Read float datasets
  for (const auto& path : float_datasets) {
    try {
      ReadFloatDataset(sd_id, path);
    } catch (const std::exception& e) {
      if (fPrintDebug) {
        std::cout << "Note: Could not read " << path << ": " << e.what() << std::endl;
      }
    }
  }
 
  // Read string datasets
  for (const auto& path : string_datasets) {
    try {
      ReadStringDataset(sd_id, path);
    } catch (const std::exception& e) {
      if (fPrintDebug) {
        std::cout << "Note: Could not read " << path << ": " << e.what() << std::endl;
      }
    }
  }
}
 
//=============================================================================
// nxH4::PNeXus::ReadIntDataset
//=============================================================================
void nxH4::PNeXus::ReadIntDataset(int32 sd_id, const std::string& path)
{
  // Extract dataset name from path
  std::vector<std::string> components = SplitPath(path);
  if (components.empty()) {
    throw std::runtime_error("Invalid path: " + path);
  }
  std::string dataset_name = components.back();
 
  // Use VGroup navigation to find the correct dataset reference
  int32 sds_ref = -1;
  if (components.size() > 1) {
    // Try to resolve via VGroup hierarchy
    sds_ref = FindDatasetRefByPath(path);
  }
 
  int32 sds_idx = -1;
  if (sds_ref != -1) {
    // Find SDS index from reference
    sds_idx = SDreftoindex(sd_id, sds_ref);
  }
 
  // Fallback to name-based search if VGroup navigation failed
  if (sds_idx == FAIL || sds_idx == -1) {
    sds_idx = FindDatasetIndex(sd_id, dataset_name);
  }
 
  int32 sds_id = SDselect(sd_id, sds_idx);
  if (sds_id == FAIL) {
    throw std::runtime_error("Failed to select dataset: " + dataset_name);
  }
 
  // Get dataset info
  int32 rank, dim_sizes[H4_MAX_VAR_DIMS], data_type, n_attrs;
  char name[H4_MAX_NC_NAME];
  if (SDgetinfo(sds_id, name, &rank, dim_sizes, &data_type, &n_attrs) == FAIL) {
    SDendaccess(sds_id);
    throw std::runtime_error("Failed to get dataset info: " + dataset_name);
  }
 
  // Calculate total number of elements
  int32 n_elements = 1;
  std::vector<uint32_t> dimensions;
  for (int32 i = 0; i < rank; i++) {
    n_elements *= dim_sizes[i];
    dimensions.push_back(static_cast<uint32_t>(dim_sizes[i]));
  }
 
  // Read data
  std::vector<int32> data(n_elements);
  int32 start[H4_MAX_VAR_DIMS] = {0};
  if (SDreaddata(sds_id, start, nullptr, dim_sizes, data.data()) == FAIL) {
    SDendaccess(sds_id);
    throw std::runtime_error("Failed to read dataset: " + dataset_name);
  }
 
  // Convert to int vector
  std::vector<int> int_data(data.begin(), data.end());
 
  // Create PNXdata object
  PNXdata<int> pnx_data(H4DataType::kINT32);
  pnx_data.SetData(int_data);
  pnx_data.SetDimensions(dimensions);
 
  // Read attributes
  ReadDatasetAttributes(sds_id, pnx_data);
 
  // Store in data map
  fDataMap[path] = pnx_data;
 
  SDendaccess(sds_id);
}
 
//=============================================================================
// nxH4::PNeXus::ReadFloatDataset
//=============================================================================
void nxH4::PNeXus::ReadFloatDataset(int32 sd_id, const std::string& path)
{
  // Extract dataset name from path
  std::vector<std::string> components = SplitPath(path);
  if (components.empty()) {
    throw std::runtime_error("Invalid path: " + path);
  }
  std::string dataset_name = components.back();
 
  // Use VGroup navigation to find the correct dataset reference
  int32 sds_ref = -1;
  if (components.size() > 1) {
    // Try to resolve via VGroup hierarchy
    sds_ref = FindDatasetRefByPath(path);
  }
 
  int32 sds_idx = -1;
  if (sds_ref != -1) {
    // Find SDS index from reference
    sds_idx = SDreftoindex(sd_id, sds_ref);
  }
 
  // Fallback to name-based search if VGroup navigation failed
  if (sds_idx == FAIL || sds_idx == -1) {
    sds_idx = FindDatasetIndex(sd_id, dataset_name);
  }
 
  int32 sds_id = SDselect(sd_id, sds_idx);
  if (sds_id == FAIL) {
    throw std::runtime_error("Failed to select dataset: " + dataset_name);
  }
 
  // Get dataset info
  int32 rank, dim_sizes[H4_MAX_VAR_DIMS], data_type, n_attrs;
  char name[H4_MAX_NC_NAME];
  if (SDgetinfo(sds_id, name, &rank, dim_sizes, &data_type, &n_attrs) == FAIL) {
    SDendaccess(sds_id);
    throw std::runtime_error("Failed to get dataset info: " + dataset_name);
  }
 
  // Calculate total number of elements
  int32 n_elements = 1;
  std::vector<uint32_t> dimensions;
  for (int32 i = 0; i < rank; i++) {
    n_elements *= dim_sizes[i];
    dimensions.push_back(static_cast<uint32_t>(dim_sizes[i]));
  }
 
  // Read data
  std::vector<float32> data(n_elements);
  int32 start[H4_MAX_VAR_DIMS] = {0};
  if (SDreaddata(sds_id, start, nullptr, dim_sizes, data.data()) == FAIL) {
    SDendaccess(sds_id);
    throw std::runtime_error("Failed to read dataset: " + dataset_name);
  }
 
  // Convert to float vector
  std::vector<float> float_data(data.begin(), data.end());
 
  // Create PNXdata object
  PNXdata<float> pnx_data(H4DataType::kFLOAT32);
  pnx_data.SetData(float_data);
  pnx_data.SetDimensions(dimensions);
 
  // Read attributes
  ReadDatasetAttributes(sds_id, pnx_data);
 
  // Store in data map
  fDataMap[path] = pnx_data;
 
  SDendaccess(sds_id);
}
 
//=============================================================================
// nxH4::PNeXus::ReadStringDataset
//=============================================================================
void nxH4::PNeXus::ReadStringDataset(int32 sd_id, const std::string& path)
{
  // Extract dataset name from path
  std::vector<std::string> components = SplitPath(path);
  if (components.empty()) {
    throw std::runtime_error("Invalid path: " + path);
  }
  std::string dataset_name = components.back();
 
  // Use VGroup navigation to find the correct dataset reference
  int32 sds_ref = -1;
  if (components.size() > 1) {
    // Try to resolve via VGroup hierarchy
    sds_ref = FindDatasetRefByPath(path);
  }
 
  int32 sds_idx = -1;
  if (sds_ref != -1) {
    // Find SDS index from reference
    sds_idx = SDreftoindex(sd_id, sds_ref);
  }
 
  // Fallback to name-based search if VGroup navigation failed
  if (sds_idx == FAIL || sds_idx == -1) {
    sds_idx = FindDatasetIndex(sd_id, dataset_name);
  }
 
  int32 sds_id = SDselect(sd_id, sds_idx);
  if (sds_id == FAIL) {
    throw std::runtime_error("Failed to select dataset: " + dataset_name);
  }
 
  // Get dataset info
  int32 rank, dim_sizes[H4_MAX_VAR_DIMS], data_type, n_attrs;
  char name[H4_MAX_NC_NAME];
  if (SDgetinfo(sds_id, name, &rank, dim_sizes, &data_type, &n_attrs) == FAIL) {
    SDendaccess(sds_id);
    throw std::runtime_error("Failed to get dataset info: " + dataset_name);
  }
 
  // Calculate total size for string
  int32 n_elements = 1;
  std::vector<uint32_t> dimensions;
  for (int32 i = 0; i < rank; i++) {
    n_elements *= dim_sizes[i];
    dimensions.push_back(static_cast<uint32_t>(dim_sizes[i]));
  }
 
  // Read data as char array
  std::vector<char> data(n_elements + 1, '\0');
  int32 start[H4_MAX_VAR_DIMS] = {0};
  if (SDreaddata(sds_id, start, nullptr, dim_sizes, data.data()) == FAIL) {
    SDendaccess(sds_id);
    throw std::runtime_error("Failed to read dataset: " + dataset_name);
  }
 
  // Create string
  std::vector<std::string> string_data;
  string_data.push_back(std::string(data.data()));
 
  // Create PNXdata object
  PNXdata<std::string> pnx_data(H4DataType::kCHAR8);
  pnx_data.SetData(string_data);
  pnx_data.SetDimensions(dimensions);
 
  // Read attributes
  ReadDatasetAttributes(sds_id, pnx_data);
 
  // Store in data map
  fDataMap[path] = pnx_data;
 
  SDendaccess(sds_id);
}
 
//=============================================================================
// nxH4::PNeXus::ReadDatasetAttributes (template specializations)
//=============================================================================
template <typename T>
void nxH4::PNeXus::ReadDatasetAttributes(int32 sds_id, PNXdata<T>& data)
{
  int32 rank, dim_sizes[H4_MAX_VAR_DIMS], data_type, n_attrs;
  char name[H4_MAX_NC_NAME];
 
  if (SDgetinfo(sds_id, name, &rank, dim_sizes, &data_type, &n_attrs) == FAIL) {
    return;
  }
 
  for (int32 i = 0; i < n_attrs; i++) {
    char attr_name[H4_MAX_NC_NAME];
    int32 attr_type, attr_count;
 
    if (SDattrinfo(sds_id, i, attr_name, &attr_type, &attr_count) == FAIL) {
      continue;
    }
 
    // Read attribute based on type - store as primitives like h5nexus
    if (attr_type == DFNT_INT32) {
      if (attr_count == 1) {
        // Single value - store as int directly
        int32 value;
        if (SDreadattr(sds_id, i, &value) != FAIL) {
          data.AddAttribute(attr_name, static_cast<int>(value));
        }
      } else {
        // Multiple values - store as vector
        std::vector<int32> attr_data(attr_count);
        if (SDreadattr(sds_id, i, attr_data.data()) != FAIL) {
          std::vector<int> int_data(attr_data.begin(), attr_data.end());
          data.AddAttribute(attr_name, int_data);
        }
      }
    } else if (attr_type == DFNT_FLOAT32) {
      if (attr_count == 1) {
        // Single value - store as float directly
        float32 value;
        if (SDreadattr(sds_id, i, &value) != FAIL) {
          data.AddAttribute(attr_name, static_cast<float>(value));
        }
      } else {
        // Multiple values - store as vector
        std::vector<float32> attr_data(attr_count);
        if (SDreadattr(sds_id, i, attr_data.data()) != FAIL) {
          std::vector<float> float_data(attr_data.begin(), attr_data.end());
          data.AddAttribute(attr_name, float_data);
        }
      }
    } else if (attr_type == DFNT_CHAR8 || attr_type == DFNT_UCHAR8) {
      // String attributes - always store as string
      std::vector<char> attr_data(attr_count + 1, '\0');
      if (SDreadattr(sds_id, i, attr_data.data()) != FAIL) {
        data.AddAttribute(attr_name, std::string(attr_data.data()));
      }
    }
  }
}
 
//=============================================================================
// nxH4::PNeXus::Dump
//=============================================================================
void nxH4::PNeXus::Dump()
{
  int first_good_bin{0};
 
  if (fIdfVersion == 1) {
    std::cout << std::endl;
    std::cout << "========================================" << std::endl;
    std::cout << "NeXus File Dump" << std::endl;
    std::cout << "========================================" << std::endl;
    std::cout << "Filename: " << fFileName << std::endl;
    std::cout << "HDF4 Version: " << fHdf4Version << std::endl;
    std::cout << "NeXus Version: " << fNeXusVersion << std::endl;
    std::cout << "IDF Version: " << fIdfVersion << std::endl;
    std::cout << "----------------------------------------" << std::endl;
 
    std::cout << std::endl << "++++";
    std::cout << std::endl << "run";
    std::cout << std::endl << "----";
    std::cout << std::endl << " IDF_version: " << fIdfVersion;
    if (fDataMap.find("/run/program_name") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/program_name"]);
        std::cout << std::endl << " program_name : " << str_data.GetData()[0];
 
        // Check for attributes
        if (str_data.HasAttribute("version")) {
          try {
            auto version = std::any_cast<std::string>(str_data.GetAttribute("version"));
            std::cout << "   version : " << version;
          } catch (const std::bad_any_cast& e) {
            std::cerr << std::endl << "**ERROR**: Failed to cast version attribute" << std::endl;
          }
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast program_name data" << std::endl;
      }
    } else {
      std::cout << std::endl << " program_name : n/a";
    }
 
    if (fDataMap.find("/run/number") != fDataMap.end()) {
      try {
        auto number = std::any_cast<PNXdata<int>>(fDataMap["/run/number"]);
        std::cout << std::endl << " number : " << number.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast number data" << std::endl;
      }
    } else {
      std::cout << std::endl << " number : n/a";
    }
 
    if (fDataMap.find("/run/title") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/title"]);
        std::cout << std::endl << " title : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast title data" << std::endl;
      }
    } else {
      std::cout << std::endl << " title : n/a";
    }
 
    if (fDataMap.find("/run/notes") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/notes"]);
        std::cout << std::endl << " notes : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast notes data" << std::endl;
      }
    } else {
      std::cout << std::endl << " notes : n/a";
    }
 
    if (fDataMap.find("/run/analysis") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/analysis"]);
        std::cout << std::endl << " analysis : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast analysis data" << std::endl;
      }
    } else {
      std::cout << std::endl << " analysis : n/a";
    }
 
    if (fDataMap.find("/run/lab") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/lab"]);
        std::cout << std::endl << " lab : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast lab data" << std::endl;
      }
    } else {
      std::cout << std::endl << " lab : n/a";
    }
 
    if (fDataMap.find("/run/beamline") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/beamline"]);
        std::cout << std::endl << " beamline : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast beamline data" << std::endl;
      }
    } else {
      std::cout << std::endl << " beamline : n/a";
    }
 
    if (fDataMap.find("/run/start_time") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/start_time"]);
        std::cout << std::endl << " start_time : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast start_time data" << std::endl;
      }
    } else {
      std::cout << std::endl << " start_time : n/a";
    }
 
    if (fDataMap.find("/run/stop_time") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/stop_time"]);
        std::cout << std::endl << " stop_time  : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast stop_time data" << std::endl;
      }
    } else {
      std::cout << std::endl << " stop_time  : n/a";
    }
 
    if (fDataMap.find("/run/switching_state") != fDataMap.end()) {
      try {
        auto int_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/switching_state"]);
        std::cout << std::endl << " switching_state : " << int_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast switching_state data" << std::endl;
      }
    } else {
      std::cout << std::endl << " switching_state : n/a";
    }
 
    std::cout << std::endl << "----";
    std::cout << std::endl << " user";
    std::cout << std::endl << "----";
    if (fDataMap.find("/run/user/name") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/user/name"]);
        std::cout << std::endl << "  name : '" << str_data.GetData()[0] << "'";
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast name data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  name : n/a";
    }
 
    if (fDataMap.find("/run/user/experiment_number") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/user/experiment_number"]);
        std::cout << std::endl << "  experiment_number : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast experiment_number data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  experiment_number : n/a";
    }
 
    std::cout << std::endl << "----";
    std::cout << std::endl << " sample";
    std::cout << std::endl << "----";
    if (fDataMap.find("/run/sample/name") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/sample/name"]);
        std::cout << std::endl << "  name : '" << str_data.GetData()[0] << "'";
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast name data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  name : n/a";
    }
 
    if (fDataMap.find("/run/sample/temperature") != fDataMap.end()) {
      try {
        auto float_data = std::any_cast<PNXdata<float>>(fDataMap["/run/sample/temperature"]);
        std::cout << std::endl << "  temperature : " << float_data.GetData()[0];
 
        // Check for attributes
        if (float_data.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(float_data.GetAttribute("units"));
            std::cout << "   units : " << units;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast units attribute" << std::endl;
          }
        } else {
          std::cout << "   units : n/a";
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast temperature data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  temperature : n/a";
    }
 
    if (fDataMap.find("/run/sample/magnetic_field") != fDataMap.end()) {
      try {
        auto float_data = std::any_cast<PNXdata<float>>(fDataMap["/run/sample/magnetic_field"]);
        std::cout << std::endl << "  magnetic_field : " << float_data.GetData()[0];
 
        // Check for attributes
        if (float_data.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(float_data.GetAttribute("units"));
            std::cout << "   units : " << units;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast units attribute" << std::endl;
          }
        } else {
          std::cout << "   units : n/a";
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast magnetic_field data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  magnetic_field : n/a";
    }
 
    if (fDataMap.find("/run/sample/magnetic_field_vector") != fDataMap.end()) {
      try {
        auto float_data = std::any_cast<PNXdata<float>>(fDataMap["/run/sample/magnetic_field_vector"]);
        std::cout << std::endl << "  magnetic_field_vector : " << float_data.GetData()[0];
 
        // Check for attributes
        if (float_data.HasAttribute("coordinate_system")) {
          try {
            auto coordinate_system = std::any_cast<std::string>(float_data.GetAttribute("coordinate_system"));
            std::cout << std::endl << "   coordinate_system : " << coordinate_system << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast coordinate_system attribute" << std::endl;
          }
        } else {
          std::cout << std::endl << "   coordinate_system : n/a" << std::endl;
        }
 
        if (float_data.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(float_data.GetAttribute("units"));
            std::cout << "   units : " << units << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast units attribute" << std::endl;
          }
        } else {
          std::cout << "   units : n/a" << std::endl;
        }
 
        if (float_data.HasAttribute("available")) {
          try {
            auto available = std::any_cast<int>(float_data.GetAttribute("available"));
            std::cout << "   available : " << available;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast available attribute" << std::endl;
          }
        } else {
          std::cout << "   available : n/a";
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast magnetic_field_vector data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  magnetic_field_vector : n/a";
    }
 
    if (fDataMap.find("/run/sample/environment") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/sample/environment"]);
        std::cout << std::endl << "  environment : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast environment data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  environment : n/a";
    }
 
    std::cout << std::endl << "----";
    std::cout << std::endl << " instrument";
    std::cout << std::endl << "----";
    if (fDataMap.find("/run/instrument/name") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/instrument/name"]);
        std::cout << std::endl << "  name : '" << str_data.GetData()[0] << "'";
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast name data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  name : n/a";
    }
 
    std::cout << std::endl << "----";
    std::cout << std::endl << "  detector";
    std::cout << std::endl << "----";
    if (fDataMap.find("/run/instrument/detector/number") != fDataMap.end()) {
      try {
        auto int_data = std::any_cast<PNXdata<int>>(fDataMap["/run/instrument/detector/number"]);
        std::cout << std::endl << "   number : " << int_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast number data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   number : n/a";
    }
 
    if (fDataMap.find("/run/instrument/detector/deadtimes") != fDataMap.end()) {
      try {
        auto float_data = std::any_cast<PNXdata<float>>(fDataMap["/run/instrument/detector/deadtimes"]);
        auto data = float_data.GetData();
        unsigned int end{15};
        if (data.size() < end)
          end = data.size();
        std::cout << std::endl << "   deadtimes: ";
        for (unsigned int i=0; i<end; i++)
          std::cout << data[i] << ", ";
        std::cout << "...";
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast deadtimes data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   deadtimes: n/a";
    }
 
    std::cout << std::endl << "----";
    std::cout << std::endl << "  beam";
    std::cout << std::endl << "----";
    if (fDataMap.find("/run/instrument/beam/frames_good") != fDataMap.end()) {
      try {
        auto fg = std::any_cast<PNXdata<int>>(fDataMap["/run/instrument/beam/frames_good"]);
        std::cout << std::endl << "   good_frames : " << fg.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast good_frames data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   good_frames : n/a";
    }
 
    std::cout << std::endl << "----";
    std::cout << std::endl << "  collimator";
    std::cout << std::endl << "----";
    if (fDataMap.find("/run/instrument/collimator/type") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/instrument/collimator/type"]);
        std::cout << std::endl << "   type : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast type data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   type : n/a";
    }
 
    std::cout << std::endl << "----";
    std::cout << std::endl << " histogram_data_1";
    std::cout << std::endl << "----";
    std::cout << std::endl << "  counts:";
    std::cout << std::endl;
    try {
      auto counts_data = std::any_cast<PNXdata<int>>(fDataMap["/run/histogram_data_1/counts"]);
 
      // Check for attributes
      if (counts_data.HasAttribute("units")) {
        try {
          auto units = std::any_cast<std::string>(counts_data.GetAttribute("units"));
          std::cout << "   units : " << units << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "**ERROR**: Failed to cast units attribute" << std::endl;
        }
      } else {
        std::cout << "   units : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("signal")) {
        try {
          auto signal = std::any_cast<int>(counts_data.GetAttribute("signal"));
          std::cout << "   signal : " << signal << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "**ERROR**: Failed to cast signal attribute" << std::endl;
        }
      } else {
        std::cout << "   signal : n/a" << std::endl;
      }
 
      int noOfHistos{0};
      if (counts_data.HasAttribute("number")) {
        try {
          noOfHistos = std::any_cast<int>(counts_data.GetAttribute("number"));
          std::cout << "   number : " << noOfHistos << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "**ERROR**: Failed to cast number attribute" << std::endl;
        }
      } else {
        std::cout << "   number : n/a" << std::endl;
      }
 
      int histoLength{0};
      if (counts_data.HasAttribute("length")) {
        try {
          histoLength = std::any_cast<int>(counts_data.GetAttribute("length"));
          std::cout << "   length : " << histoLength << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "**ERROR**: Failed to cast length attribute" << std::endl;
        }
      } else {
        std::cout << "   length : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("t0_bin")) {
        try {
          auto t0_bin = std::any_cast<int>(counts_data.GetAttribute("t0_bin"));
          std::cout << "   t0_bin : " << t0_bin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "**ERROR**: Failed to cast t0_bin attribute" << std::endl;
        }
      } else {
        std::cout << "   t0_bin : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("first_good_bin")) {
        try {
          first_good_bin = std::any_cast<int>(counts_data.GetAttribute("first_good_bin"));
          std::cout << "   first_good_bin : " << first_good_bin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "**ERROR**: Failed to cast first_good_bin attribute" << std::endl;
        }
      } else {
        std::cout << "   first_good_bin : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("last_good_bin")) {
        try {
          auto last_good_bin = std::any_cast<int>(counts_data.GetAttribute("last_good_bin"));
          std::cout << "   last_good_bin : " << last_good_bin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "**ERROR**: Failed to cast last_good_bin attribute" << std::endl;
        }
      } else {
        std::cout << "   last_good_bin : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("offset")) {
        try {
          auto offset = std::any_cast<float>(counts_data.GetAttribute("offset"));
          std::cout << "   offset : " << offset << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "**ERROR**: Failed to cast offset attribute" << std::endl;
        }
      } else {
        std::cout << "   offset : n/a" << std::endl;
      }
 
      // dump the first couple of counts of each detector
      const auto& data = counts_data.GetData();
      std::cout << std::endl << "  first couple of counts of each detector:";
      for (unsigned int i=0; i<noOfHistos; i++) {
        if (i<9)
          std::cout << std::endl << "   " << i+1 << ": ";
        else
          std::cout << std::endl << "  " << i+1 << ": ";
        for (unsigned int j=0; j<first_good_bin+5; j++)
          std::cout << data[i*histoLength+j] << ", ";
        std::cout << "...";
      }
    } catch (const std::bad_any_cast& e) {
      std::cerr << "**ERROR**: Failed to cast counts data" << std::endl;
    }
 
    if (fDataMap.find("/run/histogram_data_1/resolution") != fDataMap.end()) {
      try {
        auto int_data = std::any_cast<PNXdata<int>>(fDataMap["/run/histogram_data_1/resolution"]);
        std::cout << std::endl << "   resolution : " << int_data.GetData()[0];
 
        if (int_data.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(int_data.GetAttribute("units"));
            std::cout << "   units : " << units;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast units attribute" << std::endl;
          }
        } else {
          std::cout << std::endl << "   units : n/a";
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast resolution data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   resolution : n/a";
    }
 
    if (fDataMap.find("/run/histogram_data_1/time_zero") != fDataMap.end()) {
      try {
        auto float_data = std::any_cast<PNXdata<float>>(fDataMap["/run/histogram_data_1/time_zero"]);
        std::cout << std::endl << "   time_zero : " << float_data.GetData()[0];
 
        if (float_data.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(float_data.GetAttribute("units"));
            std::cout << std::endl << "    units : " << units;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast units attribute" << std::endl;
          }
        } else {
          std::cout << std::endl << "    units : n/a";
        }
 
        if (float_data.HasAttribute("available")) {
          try {
            auto available = std::any_cast<int>(float_data.GetAttribute("available"));
            std::cout << std::endl << "    available : " << available;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast available attribute";
          }
        } else {
          std::cout << std::endl << "    available : n/a";
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast time_zero data" << std::endl;
      }
    } else {
      std::cout << std::endl << "    time_zero : n/a";
    }
 
    if (fDataMap.find("/run/histogram_data_1/raw_time") != fDataMap.end()) {
      try {
        auto float_data = std::any_cast<PNXdata<float>>(fDataMap["/run/histogram_data_1/raw_time"]);
        std::cout << std::endl << "   raw_time : " << float_data.GetData()[0];
        if (float_data.HasAttribute("axis")) {
          try {
            auto axis = std::any_cast<int>(float_data.GetAttribute("axis"));
            std::cout << std::endl << "    axis : " << axis;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast axis attribute" << std::endl;
          }
        } else {
          std::cout << std::endl << "    axis : n/a";
        }
 
        if (float_data.HasAttribute("primary")) {
          try {
            auto primary = std::any_cast<int>(float_data.GetAttribute("primary"));
            std::cout << std::endl << "    primary : " << primary;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast primary attribute" << std::endl;
          }
        } else {
          std::cout << std::endl << "    primary : n/a";
        }
 
        if (float_data.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(float_data.GetAttribute("units"));
            std::cout << std::endl << "    units : " << units;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast units attribute" << std::endl;
          }
        } else {
          std::cout << std::endl << "    units : n/a";
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast raw_time data" << std::endl;
      }
    } else {
      std::cout << std::endl << "    raw_time : n/a";
    }
 
    if (fDataMap.find("/run/histogram_data_1/corrected_time") != fDataMap.end()) {
      try {
        auto float_data = std::any_cast<PNXdata<float>>(fDataMap["/run/histogram_data_1/corrected_time"]);
        std::cout << std::endl << "   corrected_time : " << float_data.GetData()[0];
        if (float_data.HasAttribute("axis")) {
          try {
            auto axis = std::any_cast<int>(float_data.GetAttribute("axis"));
            std::cout << std::endl << "   axis : " << axis;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast axis attribute" << std::endl;
          }
        } else {
          std::cout << std::endl << "    axis : n/a";
        }
 
        if (float_data.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(float_data.GetAttribute("units"));
            std::cout << std::endl << "    units : " << units;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast units attribute" << std::endl;
          }
        } else {
          std::cout << std::endl << "    units : n/a";
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast raw_time data" << std::endl;
      }
    } else {
      std::cout << std::endl << "    corrected_time : n/a";
    }
 
    if (fDataMap.find("/run/histogram_data_1/grouping") != fDataMap.end()) {
      try {
        auto int_data = std::any_cast<PNXdata<int>>(fDataMap["/run/histogram_data_1/grouping"]);
        auto data = int_data.GetData();
        unsigned int end{15};
        if (data.size() < end)
          end = data.size();
        std::cout << std::endl << "   grouping : ";
        for (unsigned int i=0; i<end; i++)
          std::cout << data[i] << ", ";
        std::cout << "...";
        if (int_data.HasAttribute("available")) {
          try {
            auto available = std::any_cast<int>(int_data.GetAttribute("available"));
            std::cout << std::endl << "    available : " << available;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast available attribute" << std::endl;
          }
        } else {
          std::cout << std::endl << "    available : n/a";
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast grouping data" << std::endl;
      }
    } else {
      std::cout << std::endl << "    grouping : n/a";
    }
 
    if (fDataMap.find("/run/histogram_data_1/alpha") != fDataMap.end()) {
      try {
        auto float_data = std::any_cast<PNXdata<float>>(fDataMap["/run/histogram_data_1/alpha"]);
        auto data = float_data.GetData();
        unsigned int end{15};
        if (data.size() < end)
          end = data.size();
        std::cout << std::endl << "   alpha : ";
        for (unsigned int i=0; i<end; i++)
          std::cout << data[i] << ", ";
        std::cout << "...";
        if (float_data.HasAttribute("available")) {
          try {
            auto available = std::any_cast<int>(float_data.GetAttribute("available"));
            std::cout << std::endl << "    available : " << available;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "**ERROR**: Failed to cast available attribute" << std::endl;
          }
        } else {
          std::cout << std::endl << "    alpha : n/a";
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "**ERROR**: Failed to cast alpha data" << std::endl;
      }
    } else {
      std::cout << std::endl << "    available : n/a";
    }
 
    std::cout << std::endl;
    std::cout << "========================================" << std::endl;
    std::cout << std::endl;
  } else { // IDF Version 2
    std::cout << std::endl;
    std::cout << std::endl << "hdf5-NeXus file content of file:' " << fFileName << "'";
    std::cout << std::endl << "****";
    std::cout << std::endl << "Top Level Attributes:";
    std::cout << std::endl << " HDF4 Version : " << fHdf4Version;
    std::cout << std::endl << " NeXus Version: " << fNeXusVersion;
    std::cout << std::endl << " file_name    : " << fFileNameNxs;
    std::cout << std::endl << " file_time    : " << fFileTimeNxs;
    std::cout << std::endl << "++++";
    std::cout << std::endl << "raw_data_1";
    std::cout << std::endl << "----";
    std::cout << std::endl << " IDF_version: " << fIdfVersion;
    if (fDataMap.find("/raw_data_1/beamline") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/beamline"]);
        std::cout << std::endl << " beamline   : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast beamline data" << std::endl;
      }
    } else {
      std::cout << std::endl << " beamline   : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/definition") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/definition"]);
        std::cout << std::endl << " definition : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast definition data" << std::endl;
      }
    } else {
      std::cout << std::endl << " definition   : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/run_number") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<int>>(fDataMap["/raw_data_1/run_number"]);
        std::cout << std::endl << " run_number : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast run_number data" << std::endl;
      }
    } else {
      std::cout << std::endl << " run_number   : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/title") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/title"]);
        std::cout << std::endl << " title      : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast title data" << std::endl;
      }
    } else {
      std::cout << std::endl << " title      : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/start_time") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/start_time"]);
        std::cout << std::endl << " start_time : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast start_time data" << std::endl;
      }
    } else {
      std::cout << std::endl << " start_time : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/end_time") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/end_time"]);
        std::cout << std::endl << " end_time   : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast end_time data" << std::endl;
      }
    } else {
      std::cout << std::endl << " end_time   : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/good_frames") != fDataMap.end()) {
      try {
        auto good_frames = std::any_cast<PNXdata<int>>(fDataMap["/raw_data_1/good_frames"]);
        std::cout << std::endl << " good_frames: " << good_frames.GetData()[0];
      } catch(const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast good_frames data" << std::endl;
      }
    } else {
      std::cout << std::endl << " good_frames: n/a";
    }
 
    if (fDataMap.find("/raw_data_1/experiment_identifier") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/experiment_identifier"]);
        std::cout << std::endl << " experiment_identifier: " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast experiment_identifier data" << std::endl;
      }
    } else {
      std::cout << std::endl << " experiment_identifier: n/a";
    }
 
    std::cout << std::endl << "----";
    std::cout << std::endl << " instrument";
    if (fDataMap.find("/raw_data_1/instrument/name") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/instrument/name"]);
        std::cout << std::endl << "  name      : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast instrument/name data" << std::endl;
      }
    } else {
      std::cout << std::endl << " name      : n/a";
    }
 
    std::cout << std::endl << "----";
    std::cout << std::endl << "  source";
    if (fDataMap.find("/raw_data_1/instrument/source/name") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/instrument/source/name"]);
        std::cout << std::endl << "   name     : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast instrument/source/name data" << std::endl;
      }
    } else {
      std::cout << std::endl << " name     : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/instrument/source/type") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/instrument/source/type"]);
        std::cout << std::endl << "   type     : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast instrument/source/type data" << std::endl;
      }
    } else {
      std::cout << std::endl << " type     : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/instrument/source/probe") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/instrument/source/probe"]);
        std::cout << std::endl << "   probe    : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast instrument/source/probe data" << std::endl;
      }
    } else {
      std::cout << std::endl << " probe    : n/a";
    }
 
    std::cout << std::endl << "----";
    std::cout << std::endl << " detector_1";
    std::cout << std::endl << "  counts:";
    std::cout << std::endl;
    try {
      auto counts_data = std::any_cast<PNXdata<int>>(fDataMap["/raw_data_1/instrument/detector_1/counts"]);
      auto dims = counts_data.GetDimensions();
      std::cout << "   counts dimensions: " << dims[0] << " x "
                << dims[1] << " x " << dims[2] << std::endl;
      std::cout << "   total elements: " << counts_data.GetNumElements() << std::endl;
 
      // Check for attributes
      if (counts_data.HasAttribute("signal")) {
        try {
          auto signal = std::any_cast<int>(counts_data.GetAttribute("signal"));
          std::cout << "   signal : " << signal << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast signal attribute" << std::endl;
        }
      } else {
        std::cout << std::endl << " signal : n/a";
      }
 
      if (counts_data.HasAttribute("axes")) {
        try {
          auto axes = std::any_cast<std::string>(counts_data.GetAttribute("axes"));
          std::cout << "   axes : " << axes << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast axes attribute" << std::endl;
        }
      } else {
        std::cout << std::endl << " axes : n/a";
      }
 
      if (counts_data.HasAttribute("long_name")) {
        try {
          auto long_name = std::any_cast<std::string>(counts_data.GetAttribute("long_name"));
          std::cout << "   long_name : " << long_name << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast long_name attribute" << std::endl;
        }
      } else {
        std::cout << std::endl << " long_name : n/a";
      }
 
      if (counts_data.HasAttribute("t0_bin")) {
        try {
          auto t0_bin = std::any_cast<int>(counts_data.GetAttribute("t0_bin"));
          std::cout << "   t0_bin : " << t0_bin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast t0_bin attribute" << std::endl;
        }
      } else {
        std::cout << std::endl << " t0_bin : n/a";
      }
 
      if (counts_data.HasAttribute("first_good_bin")) {
        try {
          first_good_bin = std::any_cast<int>(counts_data.GetAttribute("first_good_bin"));
          std::cout << "   first_good_bin : " << first_good_bin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast first_good_bin attribute" << std::endl;
        }
      } else {
        std::cout << std::endl << " first_good_bin : n/a";
      }
 
      if (counts_data.HasAttribute("last_good_bin")) {
        try {
          auto last_good_bin = std::any_cast<int>(counts_data.GetAttribute("last_good_bin"));
          std::cout << "   last_good_bin  : " << last_good_bin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast last_good_bin attribute" << std::endl;
        }
      } else {
        std::cout << std::endl << " last_good_bin : n/a";
      }
 
      if (fDataMap.find("/raw_data_1/instrument/detector_1/resolution") != fDataMap.end()) {
        try {
          auto ivalData = std::any_cast<PNXdata<int>>(fDataMap["/raw_data_1/instrument/detector_1/resolution"]);
          std::cout << "   resolution     : " << ivalData.GetData()[0];
          if (ivalData.HasAttribute("units")) {
            try {
              auto units = std::any_cast<std::string>(ivalData.GetAttribute("units"));
              std::cout << " " << units << std::endl;
            } catch (const std::bad_any_cast& e) {
              std::cerr << "Error: Failed to cast units attribute" << std::endl;
            }
          } else {
            std::cout << std::endl << " unit : n/a" << std::endl;
          }
 
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast resolution attribute" << std::endl;
        }
      } else {
        std::cout << std::endl << " resolution : n/a";
      }
 
      // dump the first couple of counts of each detector
      const auto& data = counts_data.GetData();
      std::cout << std::endl << "  first couple of counts of each detector:";
      for (unsigned int i=0; i<dims[1]; i++) {
        if (i<9)
          std::cout << std::endl << "   " << i+1 << ": ";
        else
          std::cout << std::endl << "  " << i+1 << ": ";
        for (unsigned int j=0; j<first_good_bin+5; j++)
          std::cout << data[i*dims[2]+j] << ", ";
        std::cout << "...";
      }
    } catch (const std::bad_any_cast& e) {
      std::cerr << "Error: Failed to cast counts data" << std::endl;
    }
 
    std::cout << std::endl;
    std::cout << std::endl << "  raw_time:";
    std::cout << std::endl;
    try {
      auto raw_time = std::any_cast<PNXdata<float>>(fDataMap["/raw_data_1/instrument/detector_1/raw_time"]);
      const auto& data = raw_time.GetData();
 
      // Check for attributes
      if (raw_time.HasAttribute("units")) {
        try {
          auto units = std::any_cast<std::string>(raw_time.GetAttribute("units"));
          std::cout << "   units : " << units << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast units attribute" << std::endl;
        }
      } else {
        std::cout << std::endl << " units : n/a" << std::endl;
      }
 
      // dump the first couple of raw_times
      std::cout << "   ";
      for (unsigned int i=0; i<first_good_bin+5; i++)
        std::cout << data[i] << ", ";
      std::cout << "...";
    } catch (const std::bad_any_cast& e) {
      std::cerr << "Error: Failed to cast raw_time data" << std::endl;
    }
 
 
    std::cout << std::endl;
    std::cout << std::endl << "  spectrum_index:";
    std::cout << std::endl;
    try {
      auto spectrum_index = std::any_cast<PNXdata<int>>(fDataMap["/raw_data_1/instrument/detector_1/spectrum_index"]);
      const auto& data = spectrum_index.GetData();
 
      // dump the first couple of raw_times
      std::cout << "   ";
      for (unsigned int i=0; i<first_good_bin+5; i++)
        std::cout << data[i] << ", ";
      std::cout << "...";
    } catch (const std::bad_any_cast& e) {
      std::cerr << "Error: Failed to cast spectrum_index data" << std::endl;
    }
 
    std::cout << std::endl;
    std::cout << std::endl << "  dead_time:";
    std::cout << std::endl;
    try {
      auto dead_time = std::any_cast<PNXdata<float>>(fDataMap["/raw_data_1/instrument/detector_1/dead_time"]);
      const auto& data = dead_time.GetData();
 
      // dump the first couple of raw_times
      std::cout << "   ";
      for (unsigned int i=0; i<first_good_bin+5; i++)
        std::cout << data[i] << ", ";
      std::cout << "...";
    } catch (const std::bad_any_cast& e) {
      std::cerr << "Error: Failed to cast spectrum_index data" << std::endl;
    }
 
    std::cout << std::endl;
  }
}
 
//=============================================================================
// nxH4::PNeXus::WriteNexusFile
//=============================================================================
int nxH4::PNeXus::WriteNexusFile(const std::string& filename, int idfVersion)
{
  // Create new HDF4 file using SD interface (for datasets)
  int32 sd_id = SDstart(filename.c_str(), DFACC_CREATE);
  if (sd_id == FAIL) {
    std::cerr << "**ERROR** Failed to create HDF4 file: " << filename << std::endl;
    return 1;
  }
 
  // Write file-level attributes (NeXus_version, HDF4_version, etc.)
  WriteFileAttributes(sd_id);
 
  if ((idfVersion != 1) && (idfVersion != 2)) {
    std::cerr << "**ERROR** Unsupported IDF version for writing: " << idfVersion << std::endl;
    SDend(sd_id);
    return 1;
  }
 
  // Write all SDS datasets and collect their references keyed by path
  std::map<std::string, int32> sdsRefMap;
 
  for (const auto& [path, data_any] : fDataMap) {
    int32 sds_ref = -1;
 
    // Try to write as int dataset
    try {
      auto data = std::any_cast<PNXdata<int>>(data_any);
      sds_ref = WriteIntDataset(sd_id, path, data);
    } catch (...) {}
 
    if (sds_ref == -1) {
      // Try to write as float dataset
      try {
        auto data = std::any_cast<PNXdata<float>>(data_any);
        sds_ref = WriteFloatDataset(sd_id, path, data);
      } catch (...) {}
    }
 
    if (sds_ref == -1) {
      // Try to write as string dataset
      try {
        auto data = std::any_cast<PNXdata<std::string>>(data_any);
        sds_ref = WriteStringDataset(sd_id, path, data);
      } catch (...) {}
    }
 
    if (sds_ref != -1) {
      sdsRefMap[path] = sds_ref;
    }
  }
 
  // Close SD interface before building Vgroup hierarchy
  SDend(sd_id);
 
  // Now open the file with Hopen/Vstart to build the Vgroup hierarchy
  int32 file_id = Hopen(filename.c_str(), DFACC_WRITE, 0);
  if (file_id == FAIL) {
    std::cerr << "**ERROR** Failed to reopen HDF4 file for Vgroup creation: " << filename << std::endl;
    return 1;
  }
 
  if (Vstart(file_id) == FAIL) {
    std::cerr << "**ERROR** Failed to initialize Vgroup interface" << std::endl;
    Hclose(file_id);
    return 1;
  }
 
  // Build Vgroup hierarchy and link SDS datasets into the correct groups
  std::map<std::string, int32> vgroupCache; // path -> vgroup ref
 
  for (const auto& [path, sds_ref] : sdsRefMap) {
    // Extract parent path
    size_t lastSlash = path.find_last_of('/');
    if (lastSlash == std::string::npos || lastSlash == 0) {
      // Dataset is at root level, no Vgroup needed
      continue;
    }
    std::string parentPath = path.substr(0, lastSlash);
 
    // Create the Vgroup hierarchy for the parent path
    int32 parent_vg_ref = CreateVGroupHierarchy(file_id, parentPath, vgroupCache);
    if (parent_vg_ref == -1) {
      std::cerr << "**ERROR** Failed to create Vgroup hierarchy for: " << parentPath << std::endl;
      continue;
    }
 
    // Attach to parent Vgroup and add the SDS dataset
    int32 parent_vg_id = Vattach(file_id, parent_vg_ref, "w");
    if (parent_vg_id != FAIL) {
      Vaddtagref(parent_vg_id, DFTAG_NDG, sds_ref);
      Vdetach(parent_vg_id);
    }
  }
 
  // Detach all cached Vgroups (they were left attached for reuse)
  // No — Vgroups were detached after creation in CreateVGroupHierarchy.
  // We only re-attach briefly above to add tag/refs.
 
  Vend(file_id);
  Hclose(file_id);
 
  return 0;
}
 
//=============================================================================
// nxH4::PNeXus::WriteFileAttributes
//=============================================================================
void nxH4::PNeXus::WriteFileAttributes(int32 sd_id)
{
  // Write HDF4 version
  if (!fHdf4Version.empty()) {
    SDsetattr(sd_id, "HDF4_version", DFNT_CHAR8,
              fHdf4Version.length(), fHdf4Version.c_str());
  }
 
  // Write NeXus version
  if (!fNeXusVersion.empty()) {
    SDsetattr(sd_id, "NeXus_version", DFNT_CHAR8,
              fNeXusVersion.length(), fNeXusVersion.c_str());
  }
 
  // Write file name
  if (!fFileNameNxs.empty()) {
    SDsetattr(sd_id, "file_name", DFNT_CHAR8,
              fFileNameNxs.length(), fFileNameNxs.c_str());
  }
 
  // Write file time
  if (!fFileTimeNxs.empty()) {
    SDsetattr(sd_id, "file_time", DFNT_CHAR8,
              fFileTimeNxs.length(), fFileTimeNxs.c_str());
  }
 
  // Write root level attributes from fGroupAttributes
  if (fGroupAttributes.find("/") != fGroupAttributes.end()) {
    const auto& attrs = fGroupAttributes.at("/");
    for (const auto& [attr_name, attr_value] : attrs) {
      // Handle different attribute types
      try {
        auto str_attr = std::any_cast<std::string>(attr_value);
        SDsetattr(sd_id, attr_name.c_str(), DFNT_CHAR8,
                  str_attr.length(), str_attr.c_str());
      } catch (...) {
        // Try other types if needed
      }
    }
  }
}
 
//=============================================================================
// nxH4::PNeXus::WriteIntDataset
//=============================================================================
int32 nxH4::PNeXus::WriteIntDataset(int32 sd_id, const std::string& path,
                             const PNXdata<int>& data)
{
  // Extract dataset name from path
  std::vector<std::string> components = SplitPath(path);
  if (components.empty()) {
    throw std::runtime_error("Invalid path: " + path);
  }
  std::string dataset_name = components.back();
 
  const auto& dims = data.GetDimensions();
  int32 rank = static_cast<int32>(dims.size());
  std::vector<int32> dim_sizes(rank);
  for (int32 i = 0; i < rank; i++) {
    dim_sizes[i] = static_cast<int32>(dims[i]);
  }
 
  // Create dataset
  int32 sds_id = SDcreate(sd_id, dataset_name.c_str(), DFNT_INT32, rank, dim_sizes.data());
  if (sds_id == FAIL) {
    throw std::runtime_error("Failed to create dataset: " + dataset_name);
  }
 
  // Convert data to int32
  const auto& int_data = data.GetData();
  std::vector<int32> data32(int_data.begin(), int_data.end());
 
  // Write data
  int32 start[H4_MAX_VAR_DIMS] = {0};
  if (SDwritedata(sds_id, start, nullptr, dim_sizes.data(), data32.data()) == FAIL) {
    SDendaccess(sds_id);
    throw std::runtime_error("Failed to write dataset: " + dataset_name);
  }
 
  // Write attributes
  WriteDatasetAttributes(sds_id, data);
 
  // Get the SDS reference for Vgroup linking
  int32 sds_ref = SDidtoref(sds_id);
 
  SDendaccess(sds_id);
 
  return sds_ref;
}
 
//=============================================================================
// nxH4::PNeXus::WriteFloatDataset
//=============================================================================
int32 nxH4::PNeXus::WriteFloatDataset(int32 sd_id, const std::string& path,
                               const PNXdata<float>& data)
{
  // Extract dataset name from path
  std::vector<std::string> components = SplitPath(path);
  if (components.empty()) {
    throw std::runtime_error("Invalid path: " + path);
  }
  std::string dataset_name = components.back();
 
  const auto& dims = data.GetDimensions();
  int32 rank = static_cast<int32>(dims.size());
  std::vector<int32> dim_sizes(rank);
  for (int32 i = 0; i < rank; i++) {
    dim_sizes[i] = static_cast<int32>(dims[i]);
  }
 
  // Create dataset
  int32 sds_id = SDcreate(sd_id, dataset_name.c_str(), DFNT_FLOAT32, rank, dim_sizes.data());
  if (sds_id == FAIL) {
    throw std::runtime_error("Failed to create dataset: " + dataset_name);
  }
 
  // Convert data to float32
  const auto& float_data = data.GetData();
  std::vector<float32> data32(float_data.begin(), float_data.end());
 
  // Write data
  int32 start[H4_MAX_VAR_DIMS] = {0};
  if (SDwritedata(sds_id, start, nullptr, dim_sizes.data(), data32.data()) == FAIL) {
    SDendaccess(sds_id);
    throw std::runtime_error("Failed to write dataset: " + dataset_name);
  }
 
  // Write attributes
  WriteDatasetAttributes(sds_id, data);
 
  // Get the SDS reference for Vgroup linking
  int32 sds_ref = SDidtoref(sds_id);
 
  SDendaccess(sds_id);
 
  return sds_ref;
}
 
//=============================================================================
// nxH4::PNeXus::WriteStringDataset
//=============================================================================
int32 nxH4::PNeXus::WriteStringDataset(int32 sd_id, const std::string& path,
                                const PNXdata<std::string>& data)
{
  // Extract dataset name from path
  std::vector<std::string> components = SplitPath(path);
  if (components.empty()) {
    throw std::runtime_error("Invalid path: " + path);
  }
  std::string dataset_name = components.back();
 
  const auto& string_data = data.GetData();
  if (string_data.empty()) {
    return -1;
  }
 
  std::string str = string_data[0];
  int32 dims[1] = {static_cast<int32>(str.length())};
 
  // Create dataset
  int32 sds_id = SDcreate(sd_id, dataset_name.c_str(), DFNT_CHAR8, 1, dims);
  if (sds_id == FAIL) {
    throw std::runtime_error("Failed to create dataset: " + dataset_name);
  }
 
  // Write data - HDF4 requires non-const pointer
  std::vector<char> str_buffer(str.begin(), str.end());
  int32 start[1] = {0};
  if (SDwritedata(sds_id, start, nullptr, dims, str_buffer.data()) == FAIL) {
    SDendaccess(sds_id);
    throw std::runtime_error("Failed to write dataset: " + dataset_name);
  }
 
  // Write attributes
  WriteDatasetAttributes(sds_id, data);
 
  // Get the SDS reference for Vgroup linking
  int32 sds_ref = SDidtoref(sds_id);
 
  SDendaccess(sds_id);
 
  return sds_ref;
}
 
//=============================================================================
// nxH4::PNeXus::WriteDatasetAttributes (template specializations)
//=============================================================================
template <typename T>
void nxH4::PNeXus::WriteDatasetAttributes(int32 sds_id, const PNXdata<T>& data)
{
  const auto& attributes = data.GetAttributes();
 
  for (const auto& [attr_name, attr_value] : attributes) {
    // Try different attribute types - primitives first (like h5nexus)
 
    // Try scalar int
    try {
      int32 value = std::any_cast<int>(attr_value);
      SDsetattr(sds_id, attr_name.c_str(), DFNT_INT32, 1, &value);
      continue;
    } catch (...) {}
 
    // Try scalar float
    try {
      float32 value = std::any_cast<float>(attr_value);
      SDsetattr(sds_id, attr_name.c_str(), DFNT_FLOAT32, 1, &value);
      continue;
    } catch (...) {}
 
    // Try string
    try {
      std::string str = std::any_cast<std::string>(attr_value);
      SDsetattr(sds_id, attr_name.c_str(), DFNT_CHAR8, str.length(), str.c_str());
      continue;
    } catch (...) {}
 
    // Try vector<int> for multi-element attributes
    try {
      std::vector<int> int_vec = std::any_cast<std::vector<int>>(attr_value);
      std::vector<int32> data32(int_vec.begin(), int_vec.end());
      SDsetattr(sds_id, attr_name.c_str(), DFNT_INT32, data32.size(), data32.data());
      continue;
    } catch (...) {}
 
    // Try vector<float> for multi-element attributes
    try {
      std::vector<float> float_vec = std::any_cast<std::vector<float>>(attr_value);
      std::vector<float32> data32(float_vec.begin(), float_vec.end());
      SDsetattr(sds_id, attr_name.c_str(), DFNT_FLOAT32, data32.size(), data32.data());
      continue;
    } catch (...) {}
  }
}
 
//=============================================================================
// nxH4::PNeXus::WriteVGroupAttributes
//=============================================================================
void nxH4::PNeXus::WriteVGroupAttributes(int32 vgroup_id,
                                          const std::map<std::string, std::any>& attributes)
{
  for (const auto& [attr_name, attr_value] : attributes) {
    // Try string
    try {
      std::string str = std::any_cast<std::string>(attr_value);
      Vsetattr(vgroup_id, attr_name.c_str(), DFNT_CHAR8,
               static_cast<int32>(str.length()), str.c_str());
      continue;
    } catch (...) {}
 
    // Try scalar int
    try {
      int32 value = std::any_cast<int>(attr_value);
      Vsetattr(vgroup_id, attr_name.c_str(), DFNT_INT32, 1, &value);
      continue;
    } catch (...) {}
 
    // Try scalar float
    try {
      float32 value = std::any_cast<float>(attr_value);
      Vsetattr(vgroup_id, attr_name.c_str(), DFNT_FLOAT32, 1, &value);
      continue;
    } catch (...) {}
 
    // Try vector<int>
    try {
      std::vector<int> int_vec = std::any_cast<std::vector<int>>(attr_value);
      std::vector<int32> data32(int_vec.begin(), int_vec.end());
      Vsetattr(vgroup_id, attr_name.c_str(), DFNT_INT32,
               static_cast<int32>(data32.size()), data32.data());
      continue;
    } catch (...) {}
 
    // Try vector<float>
    try {
      std::vector<float> float_vec = std::any_cast<std::vector<float>>(attr_value);
      std::vector<float32> data32(float_vec.begin(), float_vec.end());
      Vsetattr(vgroup_id, attr_name.c_str(), DFNT_FLOAT32,
               static_cast<int32>(data32.size()), data32.data());
      continue;
    } catch (...) {}
  }
}
 
//=============================================================================
// nxH4::PNeXus::CreateVGroupHierarchy
//=============================================================================
int32 nxH4::PNeXus::CreateVGroupHierarchy(int32 file_id, const std::string& path,
                                           std::map<std::string, int32>& vgroupCache)
{
  std::vector<std::string> components = SplitPath(path);
  if (components.empty()) {
    return -1;
  }
 
  std::string currentPath;
  int32 parent_vg_ref = -1;
 
  for (const auto& component : components) {
    if (component.empty()) continue;
 
    currentPath += "/" + component;
 
    // Check if this Vgroup was already created
    auto it = vgroupCache.find(currentPath);
    if (it != vgroupCache.end()) {
      parent_vg_ref = it->second;
      continue;
    }
 
    // Create a new Vgroup
    int32 vg_id = Vattach(file_id, -1, "w");
    if (vg_id == FAIL) {
      std::cerr << "**ERROR** Failed to create Vgroup for: " << currentPath << std::endl;
      return -1;
    }
 
    Vsetname(vg_id, component.c_str());
 
    // Write group attributes if any exist for this path
    auto attrIt = fGroupAttributes.find(currentPath);
    if (attrIt != fGroupAttributes.end()) {
      // Check for NX_class attribute and set it as Vgroup class
      auto classIt = attrIt->second.find("NX_class");
      if (classIt != attrIt->second.end()) {
        try {
          std::string nxClass = std::any_cast<std::string>(classIt->second);
          Vsetclass(vg_id, nxClass.c_str());
        } catch (...) {}
      }
      WriteVGroupAttributes(vg_id, attrIt->second);
    }
 
    // Get the reference of the newly created Vgroup
    int32 vg_ref = VQueryref(vg_id);
 
    // If there is a parent Vgroup, add this one as a child
    if (parent_vg_ref != -1) {
      int32 parent_vg_id = Vattach(file_id, parent_vg_ref, "w");
      if (parent_vg_id != FAIL) {
        Vinsert(parent_vg_id, vg_id);
        Vdetach(parent_vg_id);
      }
    }
 
    Vdetach(vg_id);
 
    // Cache the reference for this path
    vgroupCache[currentPath] = vg_ref;
    parent_vg_ref = vg_ref;
  }
 
  return parent_vg_ref;
}
 
//=============================================================================
// Group attribute methods - manage attributes associated with HDF4 groups
//=============================================================================

bool nxH4::PNeXus::AddGroupAttribute(const std::string& groupPath,
                           const std::string& attrName,
                           const std::any& attrValue)
{
  fGroupAttributes[groupPath][attrName] = attrValue;
  return true;
}
 
bool nxH4::PNeXus::RemoveGroupAttribute(const std::string& groupPath,
                                  const std::string& attrName)
{
  auto it = fGroupAttributes.find(groupPath);
  if (it != fGroupAttributes.end()) {
    auto attr_it = it->second.find(attrName);
    if (attr_it != it->second.end()) {
      it->second.erase(attr_it);
      return true;
    }
  }
  return false;
}
 
bool nxH4::PNeXus::HasGroupAttribute(const std::string& groupPath,
                               const std::string& attrName) const
{
  auto it = fGroupAttributes.find(groupPath);
  if (it != fGroupAttributes.end()) {
    return it->second.find(attrName) != it->second.end();
  }
  return false;
}
 
std::any nxH4::PNeXus::GetGroupAttribute(const std::string& groupPath,
                           const std::string& attrName) const
{
  return fGroupAttributes.at(groupPath).at(attrName);
}
 
const std::map<std::string, std::any>& nxH4::PNeXus::GetGroupAttributes(
    const std::string& groupPath) const
{
  static std::map<std::string, std::any> empty_map;
  auto it = fGroupAttributes.find(groupPath);
  if (it != fGroupAttributes.end()) {
    return it->second;
  }
  return empty_map;
}
 
bool nxH4::PNeXus::ClearGroupAttributes(const std::string& groupPath)
{
  auto it = fGroupAttributes.find(groupPath);
  if (it != fGroupAttributes.end()) {
    it->second.clear();
    return true;
    }
  return false;
}
 
bool nxH4::PNeXus::AddRootAttribute(const std::string& attrName, const std::any& attrValue)
{
  return AddGroupAttribute("/", attrName, attrValue);
}
 
//=============================================================================
// Helper methods
//=============================================================================
bool nxH4::PNeXus::CaseInsensitiveEquals(const std::string& a, const std::string& b)
{
  if (a.length() != b.length()) {
    return false;
  }
  return std::equal(a.begin(), a.end(), b.begin(),
                    [](char a, char b) {
                      return std::tolower(static_cast<unsigned char>(a)) ==
                             std::tolower(static_cast<unsigned char>(b));
                    });
}
 
std::vector<std::string> nxH4::PNeXus::SplitPath(const std::string& path)
{
  std::vector<std::string> components;
  std::string current;
 
  for (char c : path) {
    if (c == '/') {
      if (!current.empty()) {
        components.push_back(current);
        current.clear();
      }
    } else {
      current += c;
    }
  }
 
  if (!current.empty()) {
    components.push_back(current);
  }
 
  return components;
}
 
std::string nxH4::PNeXus::FindAttributeName(int32 sd_id, const std::string& requestedName)
{
  int32 n_datasets, n_attrs;
  if (SDfileinfo(sd_id, &n_datasets, &n_attrs) == FAIL) {
    throw std::runtime_error("Failed to get file info");
  }
 
  char attr_name[H4_MAX_NC_NAME];
  int32 attr_type, attr_count;
 
  for (int32 i = 0; i < n_attrs; i++) {
    if (SDattrinfo(sd_id, i, attr_name, &attr_type, &attr_count) != FAIL) {
      if (CaseInsensitiveEquals(attr_name, requestedName)) {
        return std::string(attr_name);
      }
    }
  }
 
  throw std::runtime_error("Attribute not found: " + requestedName);
}
 
int32 nxH4::PNeXus::FindDatasetIndex(int32 sd_id, const std::string& requestedName)
{
  // First try exact match
  int32 idx = SDnametoindex(sd_id, requestedName.c_str());
  if (idx != FAIL) {
    return idx;
  }
 
  // Try case-insensitive search
  int32 n_datasets, n_attrs;
  if (SDfileinfo(sd_id, &n_datasets, &n_attrs) == FAIL) {
    throw std::runtime_error("Failed to get file info");
  }
 
  for (int32 i = 0; i < n_datasets; i++) {
    int32 sds_id = SDselect(sd_id, i);
    if (sds_id != FAIL) {
      char name[H4_MAX_NC_NAME];
      int32 rank, dim_sizes[H4_MAX_VAR_DIMS], data_type, n_ds_attrs;
      if (SDgetinfo(sds_id, name, &rank, dim_sizes, &data_type, &n_ds_attrs) != FAIL) {
        if (CaseInsensitiveEquals(name, requestedName)) {
          SDendaccess(sds_id);
          return i;
        }
      }
      SDendaccess(sds_id);
    }
  }
 
  throw std::runtime_error("Dataset not found: " + requestedName);
}
 
int32 nxH4::PNeXus::FindDatasetRefByPath(const std::string& path)
{
  // Navigate VGroup hierarchy to find the dataset reference
  // Path format: /group1/group2/.../dataset_name
 
  std::vector<std::string> components = SplitPath(path);
  if (components.empty()) {
    return -1;
  }
 
  // Open file with V interface
  if (Vstart(fFileId) == FAIL) {
    return -1;
  }
 
  int32 result_ref = -1;
  int32 current_vg_ref = -1;
 
  // Find root VGroup (first component after /)
  // For IDF version 1, root is typically "run"
  if (components.size() >= 1) {
    // Get all lone vgroups
    int32 n_vgroups = Vlone(fFileId, nullptr, 0);
    if (n_vgroups > 0) {
      std::vector<int32> vgroup_refs(n_vgroups);
      Vlone(fFileId, vgroup_refs.data(), n_vgroups);
 
      // Find the root VGroup
      for (int32 i = 0; i < n_vgroups; i++) {
        int32 vg_id = Vattach(fFileId, vgroup_refs[i], "r");
        if (vg_id != FAIL) {
          char vg_name[VGNAMELENMAX];
          if (Vgetname_portable(vg_id, vg_name, sizeof(vg_name)) != FAIL) {
            if (CaseInsensitiveEquals(vg_name, components[0])) {
              current_vg_ref = vgroup_refs[i];
              Vdetach(vg_id);
              break;
            }
          }
          Vdetach(vg_id);
        }
      }
    }
  }
 
  // Navigate through intermediate VGroups
  for (size_t comp_idx = 1; comp_idx < components.size() - 1; comp_idx++) {
    if (current_vg_ref == -1) break;
 
    int32 vg_id = Vattach(fFileId, current_vg_ref, "r");
    if (vg_id == FAIL) {
      current_vg_ref = -1;
      break;
    }
 
    int32 n_entries = Vntagrefs(vg_id);
    bool found = false;
 
    for (int32 i = 0; i < n_entries; i++) {
      int32 tag, ref;
      if (Vgettagref(vg_id, i, &tag, &ref) != FAIL) {
        // Check if it's a VGroup
        if (tag == DFTAG_VG) {
          int32 child_vg_id = Vattach(fFileId, ref, "r");
          if (child_vg_id != FAIL) {
            char child_name[VGNAMELENMAX];
            if (Vgetname_portable(child_vg_id, child_name, sizeof(child_name)) != FAIL) {
              if (CaseInsensitiveEquals(child_name, components[comp_idx])) {
                current_vg_ref = ref;
                found = true;
                Vdetach(child_vg_id);
                break;
              }
            }
            Vdetach(child_vg_id);
          }
        }
      }
    }
 
    Vdetach(vg_id);
 
    if (!found) {
      current_vg_ref = -1;
      break;
    }
  }
 
  // Find the dataset in the final VGroup
  if (current_vg_ref != -1 && components.size() >= 1) {
    int32 vg_id = Vattach(fFileId, current_vg_ref, "r");
    if (vg_id != FAIL) {
      int32 n_entries = Vntagrefs(vg_id);
      std::string target_name = components.back();
 
      for (int32 i = 0; i < n_entries; i++) {
        int32 tag, ref;
        if (Vgettagref(vg_id, i, &tag, &ref) != FAIL) {
          // Check if it's a Numeric Data (SDS)
          if (tag == DFTAG_NDG) {
            // Try to get the name by converting ref to index
            int32 sds_idx = SDreftoindex(fSdId, ref);
            if (sds_idx != FAIL) {
              int32 sds_id = SDselect(fSdId, sds_idx);
              if (sds_id != FAIL) {
                char ds_name[H4_MAX_NC_NAME];
                int32 rank, dim_sizes[H4_MAX_VAR_DIMS], data_type, n_attrs;
                if (SDgetinfo(sds_id, ds_name, &rank, dim_sizes, &data_type, &n_attrs) != FAIL) {
                  if (CaseInsensitiveEquals(ds_name, target_name)) {
                    result_ref = ref;
                    SDendaccess(sds_id);
                    break;
                  }
                }
                SDendaccess(sds_id);
              }
            }
          }
        }
      }
 
      Vdetach(vg_id);
    }
  }
 
  Vend(fFileId);
  return result_ref;
}

nxH4::H4DataType nxH4::PNeXus::convertHdf4Type(int32 hdf4_type)
{
  switch (hdf4_type) {
  case DFNT_INT32:   return H4DataType::kINT32;
  case DFNT_FLOAT32: return H4DataType::kFLOAT32;
  case DFNT_FLOAT64: return H4DataType::kFLOAT64;
  case DFNT_CHAR8:   return H4DataType::kCHAR8;
  case DFNT_UINT32:  return H4DataType::kUINT32;
  case DFNT_INT16:   return H4DataType::kINT16;
  case DFNT_UINT16:  return H4DataType::kUINT16;
  case DFNT_INT8:    return H4DataType::kINT8;
  case DFNT_UINT8:   return H4DataType::kUINT8;
  default:           return H4DataType::kINT32;
  }
}

int32 nxH4::PNeXus::convertToHdf4Type(H4DataType dataType)
{
  switch (dataType) {
  case H4DataType::kINT32:   return DFNT_INT32;
  case H4DataType::kFLOAT32: return DFNT_FLOAT32;
  case H4DataType::kFLOAT64: return DFNT_FLOAT64;
  case H4DataType::kCHAR8:   return DFNT_CHAR8;
  case H4DataType::kUINT32:  return DFNT_UINT32;
  case H4DataType::kINT16:   return DFNT_INT16;
  case H4DataType::kUINT16:  return DFNT_UINT16;
  case H4DataType::kINT8:    return DFNT_INT8;
  case H4DataType::kUINT8:   return DFNT_UINT8;
  default:                  return DFNT_INT32;
  }
}
#endif // HAVE_HDF4
 
// ** HDF5 ********************************************************************
 
//=============================================================================
// nxH5::PNeXusDeadTime Constructor
//=============================================================================
nxH5::PNeXusDeadTime::PNeXusDeadTime(const PNeXus *nxs, bool debug) : fDebug(debug)
{
  std::map<std::string, std::any> dataMap = nxs->GetDataMap();
 
  int idfVersion = nxs->GetIdfVersion();
  if ((idfVersion != 1) && (idfVersion != 2)) {
    std::stringstream err;
    err << "**ERROR** Found unsupported IDF version '" << idfVersion << "'";
    std::cout << err.str() << std::endl;
    fValid = false;
    return;
  }
 
  if (idfVersion == 1) {
    // not yet implemented
  } else { // idfVersion == 2
    // get counts
    if (dataMap.find("/raw_data_1/instrument/detector_1/counts") != dataMap.end()) {
      auto counts_data = std::any_cast<PNXdata<int>>(dataMap["/raw_data_1/instrument/detector_1/counts"]);
      const auto& counts = counts_data.GetData();
      fCounts = counts;
      auto dims = counts_data.GetDimensions();
      if (fDebug) {
        std::cout << " counts dimensions: " << dims[0] << " x "
                  << dims[1] << " x " << dims[2] << std::endl;
      }
      fDims = dims;
 
             // get t0
      if (counts_data.HasAttribute("t0_bin")) {
        try {
          auto t0_bin = std::any_cast<int>(counts_data.GetAttribute("t0_bin"));
          fT0Bin = t0_bin;
          if (fDebug)
            std::cout << " fT0Bin: " << fT0Bin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast t0_bin attribute" << std::endl;
        }
      }
      // get fgb
      if (counts_data.HasAttribute("first_good_bin")) {
        try {
          auto first_good_bin = std::any_cast<int>(counts_data.GetAttribute("first_good_bin"));
          fFgbBin = first_good_bin;
          if (fDebug)
            std::cout << " fFgbBin: " << fFgbBin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast first_good_bin attribute" << std::endl;
        }
      }
      // get lgb
      if (counts_data.HasAttribute("last_good_bin")) {
        try {
          auto last_good_bin = std::any_cast<int>(counts_data.GetAttribute("last_good_bin"));
          fLgbBin = last_good_bin;
          if (fDebug)
            std::cout << " fLgbBin: " << fLgbBin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast last_good_bin attribute" << std::endl;
        }
      }
    }
 
    // get dead time parameters
    if (dataMap.find("/raw_data_1/instrument/detector_1/dead_time") != dataMap.end()) {
      auto dead_time = std::any_cast<PNXdata<float>>(dataMap["/raw_data_1/instrument/detector_1/dead_time"]);
      const auto& dt_data = dead_time.GetData();
      fDeadTime = dt_data;
    }
    fDeadTimeEstimated.resize(fDeadTime.size());
 
    // get good_frames
    if (dataMap.find("/raw_data_1/good_frames") != dataMap.end()) {
      auto intData = std::any_cast<PNXdata<int>>(dataMap["/raw_data_1/good_frames"]);
      const auto& ival = intData.GetData();
      fGoodFrames = ival[0];
      if (fDebug)
        std::cout << " good_frames: " << fGoodFrames << std::endl;
    }
    // get resolution with units
    if (dataMap.find("/raw_data_1/instrument/detector_1/resolution") != dataMap.end()) {
      auto int_data = std::any_cast<PNXdata<int>>(dataMap["/raw_data_1/instrument/detector_1/resolution"]);
      const auto& ival = int_data.GetData();
      float scale{1.0};
      if (int_data.HasAttribute("units")) {
        try {
          auto units = std::any_cast<std::string>(int_data.GetAttribute("units"));
          if (units == "picoseconds")
            scale = 1.0e-6;
          else if (units == "nanoseconds")
            scale = 1.0e-3;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast units attribute" << std::endl;
        }
      }
      fTimeResolution = ival[0] * scale;
      if (fDebug)
        std::cout << " time_resolution: " << fTimeResolution << " (us)" << std::endl;
    }
  }
}
 
//=============================================================================
// nxH5::PNeXusDeadTime::operator()
//=============================================================================
double nxH5::PNeXusDeadTime::operator()(const std::vector<double> &par) const
{
  // par[0]: dtc, par[1]: N0, par[2]: N_bkg
 
  double nt=0, nd=0, ll=0;
  const double tau_mu=2.1969811;
  for (unsigned int i=fFgbBin; i<fLgbBin; i++) {
    nt = par[1]*exp(-(((double)i-(double)fT0Bin+0.5)*fTimeResolution)/tau_mu)+par[2]; // theory
    if (nt <= 0) nt=1.0e-6;
    nt = nt/(1.0+nt*par[0]); // dead time corrected
    if (nt <= 1.0e-12) nt=1.0e-12;
    nd = (double)fCounts[i+fIdx*fDims[2]]; // data
    ll += nt - nd/(fGoodFrames*fTimeResolution) * log(nt);
  }
 
  return ll;
}
 
//=============================================================================
// nxH5::PNeXusDeadTime::Minimize()
//=============================================================================
void nxH5::PNeXusDeadTime::Minimize(const int i)
{
  fIdx = i;
 
  double n0 = 1.07*(double)fCounts[fFgbBin+fIdx*fDims[2]];
  ROOT::Minuit2::MnUserParameters params;
  params.Add("dtc", 0.01, 0.01);
  params.Add("N0", n0/fDims[2], 1.0);
  params.Add("N_bkg", 0.1/fDims[2], 0.1);
 
         // create minimizer object
  ROOT::Minuit2::MnMinimize minimize(*this, params, ROOT::Minuit2::MnStrategy{2});
 
         // minimize
         // maxfcn is MINUIT2 Default maxfcn
  unsigned int maxfcn = std::numeric_limits<unsigned int>::max();
  double tolerance = 0.1;
  ROOT::Minuit2::FunctionMinimum min = minimize(maxfcn, tolerance);
 
  std::unique_ptr<ROOT::Minuit2::FunctionMinimum> fcnMin; 
 
         // keep FunctionMinimum object
  fcnMin.reset(new ROOT::Minuit2::FunctionMinimum(min));
 
         // keep user parameters
  if (fcnMin)
    params = fcnMin->UserParameters();
 
  fDeadTimeEstimated[i] = params.Value(0);
 
  if (fDebug)
    std::cout << "debug> " << i << ": dtc fitted=" << params.Value(0) << ", dtc from file=" << fDeadTime[i] << std::endl;
}
 
//=============================================================================
// Case-insensitive string comparison helper
//=============================================================================
bool nxH5::PNeXus::CaseInsensitiveEquals(const std::string& a, const std::string& b)
{
  if (a.length() != b.length()) {
    return false;
  }
 
  for (size_t i = 0; i < a.length(); ++i) {
    if (std::tolower(static_cast<unsigned char>(a[i])) !=
        std::tolower(static_cast<unsigned char>(b[i]))) {
      return false;
    }
  }
 
  return true;
}
 
//=============================================================================
// Split HDF5 path into components
//=============================================================================
std::vector<std::string> nxH5::PNeXus::SplitPath(const std::string& path)
{
  std::vector<std::string> components;
  std::string component;
  std::istringstream stream(path);
 
  while (std::getline(stream, component, '/')) {
    // Keep empty first component to indicate absolute path
    if (!component.empty() || components.empty()) {
      components.push_back(component);
    }
  }
 
  return components;
}
 
//=============================================================================
// Find attribute with case-insensitive name matching
//=============================================================================
std::string nxH5::PNeXus::FindAttributeName(H5::H5File& obj, const std::string& requestedName)
{
  int numAttrs = obj.getNumAttrs();
 
  for (int i = 0; i < numAttrs; i++) {
    H5::Attribute attr = obj.openAttribute(i);
    std::string attrName = attr.getName();
    attr.close();
 
    if (CaseInsensitiveEquals(attrName, requestedName)) {
      return attrName;
    }
  }
 
         // Not found - throw exception
  std::ostringstream msg;
  msg << "Could not find attribute matching case-insensitive name: '" << requestedName << "'";
  throw H5::AttributeIException("FindAttributeName", msg.str());
}
 
//=============================================================================
// Find group path with case-insensitive matching (File overload)
//=============================================================================
std::string nxH5::PNeXus::FindGroupPath(H5::H5File& parent, const std::string& requestedPath)
{
  std::vector<std::string> components = SplitPath(requestedPath);
 
         // Handle empty path
  if (components.empty()) {
    return "/";
  }
 
         // Check if absolute path
  bool isAbsolute = (components[0].empty());
  std::string currentPath = isAbsolute ? "" : "";
 
         // Start from index 1 if absolute path (skip empty component)
  size_t startIdx = isAbsolute ? 1 : 0;
 
         // Traverse path components
  for (size_t i = startIdx; i < components.size(); ++i) {
    const std::string& requestedComponent = components[i];
 
           // Build the parent path for querying
    std::string parentPath = (currentPath.empty() || currentPath == "") ? "/" : currentPath;
    H5::Group currentGroup = (parentPath == "/") ? parent.openGroup("/") : parent.openGroup(parentPath);
 
           // List object names using iteration
    hsize_t numObjs = currentGroup.getNumObjs();
    std::vector<std::string> objectNames;
    for (hsize_t j = 0; j < numObjs; j++) {
      objectNames.push_back(currentGroup.getObjnameByIdx(j));
    }
 
           // Find case-insensitive match
    std::string matchedName;
    bool found = false;
 
    for (const auto& objName : objectNames) {
      if (CaseInsensitiveEquals(objName, requestedComponent)) {
        matchedName = objName;
        found = true;
        break;
      }
    }
 
    if (!found) {
      std::ostringstream msg;
      msg << "Could not find group component matching case-insensitive path: '"
          << requestedPath << "' (failed at component: '" << requestedComponent << "')";
      throw H5::GroupIException("FindGroupPath", msg.str());
    }
 
           // Build current path
    currentPath += "/" + matchedName;
 
           // Verify it's a group
    H5O_type_t objType = currentGroup.childObjType(matchedName);
    if (objType != H5O_TYPE_GROUP) {
      std::ostringstream msg;
      msg << "Path component '" << matchedName << "' in '" << requestedPath
          << "' is not a group";
      throw H5::GroupIException("FindGroupPath", msg.str());
    }
  }
 
  return currentPath;
}
 
//-----------------------------------------------------------------------------
// Find group path with case-insensitive matching (Group overload)
//-----------------------------------------------------------------------------
std::string nxH5::PNeXus::FindGroupPath(H5::Group& parent, const std::string& requestedPath)
{
  std::vector<std::string> components = SplitPath(requestedPath);
 
         // Handle empty path
  if (components.empty()) {
    return "/";
  }
 
         // Check if absolute path
  bool isAbsolute = (components[0].empty());
  std::string currentPath = isAbsolute ? "" : "";
  H5::Group currentGroup = parent;
 
         // Start from index 1 if absolute path (skip empty component)
  size_t startIdx = isAbsolute ? 1 : 0;
 
         // Traverse path components
  for (size_t i = startIdx; i < components.size(); ++i) {
    const std::string& requestedComponent = components[i];
 
           // List object names using iteration
    hsize_t numObjs = currentGroup.getNumObjs();
    std::vector<std::string> objectNames;
    for (hsize_t j = 0; j < numObjs; j++) {
      objectNames.push_back(currentGroup.getObjnameByIdx(j));
    }
 
           // Find case-insensitive match
    std::string matchedName;
    bool found = false;
 
    for (const auto& objName : objectNames) {
      if (CaseInsensitiveEquals(objName, requestedComponent)) {
        matchedName = objName;
        found = true;
        break;
      }
    }
 
    if (!found) {
      std::ostringstream msg;
      msg << "Could not find group component matching case-insensitive path: '"
          << requestedPath << "' (failed at component: '" << requestedComponent << "')";
      throw H5::GroupIException("FindGroupPath", msg.str());
    }
 
           // Build current path
    currentPath += "/" + matchedName;
 
           // Verify it's a group (unless it's the last component, which is checked by caller)
    H5O_type_t objType = currentGroup.childObjType(matchedName);
    if (objType != H5O_TYPE_GROUP) {
      std::ostringstream msg;
      msg << "Path component '" << matchedName << "' in '" << requestedPath
          << "' is not a group";
      throw H5::GroupIException("FindGroupPath", msg.str());
    }
 
           // Open the group for next iteration
    if (i < components.size() - 1) {
      currentGroup = currentGroup.openGroup(matchedName);
    }
  }
 
  return currentPath;
}
 
//=============================================================================
// Find dataset path with case-insensitive matching (File overload)
//=============================================================================
std::string nxH5::PNeXus::FindDatasetPath(H5::H5File& parent, const std::string& requestedPath)
{
  std::vector<std::string> components = SplitPath(requestedPath);
 
         // Handle empty path
  if (components.empty()) {
    throw H5::DataSetIException("FindDatasetPath", "Empty dataset path provided");
  }
 
         // Check if absolute path
  bool isAbsolute = (components[0].empty());
  std::string currentPath = isAbsolute ? "" : "";
 
         // Start from index 1 if absolute path (skip empty component)
  size_t startIdx = isAbsolute ? 1 : 0;
 
         // Traverse path components
  for (size_t i = startIdx; i < components.size(); ++i) {
    const std::string& requestedComponent = components[i];
 
           // Build the parent path for querying
    std::string parentPath = (currentPath.empty() || currentPath == "") ? "/" : currentPath;
    H5::Group currentGroup = (parentPath == "/") ? parent.openGroup("/") : parent.openGroup(parentPath);
 
           // List object names using iteration
    hsize_t numObjs = currentGroup.getNumObjs();
    std::vector<std::string> objectNames;
    for (hsize_t j = 0; j < numObjs; j++) {
      objectNames.push_back(currentGroup.getObjnameByIdx(j));
    }
 
           // Find case-insensitive match
    std::string matchedName;
    bool found = false;
 
    for (const auto& objName : objectNames) {
      if (CaseInsensitiveEquals(objName, requestedComponent)) {
        matchedName = objName;
        found = true;
        break;
      }
    }
 
    if (!found) {
      std::ostringstream msg;
      msg << "Could not find dataset matching case-insensitive path: '"
          << requestedPath << "' (failed at component: '" << requestedComponent << "')";
      throw H5::DataSetIException("FindDatasetPath", msg.str());
    }
 
           // Build current path
    currentPath += "/" + matchedName;
 
           // Check if this is the last component (should be a dataset)
    if (i == components.size() - 1) {
      H5O_type_t objType = currentGroup.childObjType(matchedName);
      if (objType != H5O_TYPE_DATASET) {
        std::ostringstream msg;
        msg << "Path '" << requestedPath << "' resolves to '" << currentPath
            << "' which is not a dataset";
        throw H5::DataSetIException("FindDatasetPath", msg.str());
      }
    } else {
      // Intermediate component - should be a group
      H5O_type_t objType = currentGroup.childObjType(matchedName);
      if (objType != H5O_TYPE_GROUP) {
        std::ostringstream msg;
        msg << "Path component '" << matchedName << "' in '" << requestedPath
            << "' is not a group";
        throw H5::DataSetIException("FindDatasetPath", msg.str());
      }
    }
  }
 
  return currentPath;
}
 
//-----------------------------------------------------------------------------
// Find dataset path with case-insensitive matching (Group overload)
//-----------------------------------------------------------------------------
std::string nxH5::PNeXus::FindDatasetPath(H5::Group& parent, const std::string& requestedPath)
{
  std::vector<std::string> components = SplitPath(requestedPath);
 
         // Handle empty path
  if (components.empty()) {
    throw H5::DataSetIException("FindDatasetPath", "Empty dataset path provided");
  }
 
         // Check if absolute path
  bool isAbsolute = (components[0].empty());
  std::string currentPath = isAbsolute ? "" : "";
  H5::Group currentGroup = parent;
 
         // Start from index 1 if absolute path (skip empty component)
  size_t startIdx = isAbsolute ? 1 : 0;
 
         // Traverse path components
  for (size_t i = startIdx; i < components.size(); ++i) {
    const std::string& requestedComponent = components[i];
 
           // List object names using iteration
    hsize_t numObjs = currentGroup.getNumObjs();
    std::vector<std::string> objectNames;
    for (hsize_t j = 0; j < numObjs; j++) {
      objectNames.push_back(currentGroup.getObjnameByIdx(j));
    }
 
           // Find case-insensitive match
    std::string matchedName;
    bool found = false;
 
    for (const auto& objName : objectNames) {
      if (CaseInsensitiveEquals(objName, requestedComponent)) {
        matchedName = objName;
        found = true;
        break;
      }
    }
 
    if (!found) {
      std::ostringstream msg;
      msg << "Could not find dataset matching case-insensitive path: '"
          << requestedPath << "' (failed at component: '" << requestedComponent << "')";
      throw H5::DataSetIException("FindDatasetPath", msg.str());
    }
 
           // Build current path
    currentPath += "/" + matchedName;
 
           // Check if this is the last component (should be a dataset)
    if (i == components.size() - 1) {
      H5O_type_t objType = currentGroup.childObjType(matchedName);
      if (objType != H5O_TYPE_DATASET) {
        std::ostringstream msg;
        msg << "Path '" << requestedPath << "' resolves to '" << currentPath
            << "' which is not a dataset";
        throw H5::DataSetIException("FindDatasetPath", msg.str());
      }
    } else {
      // Intermediate component - should be a group
      H5O_type_t objType = currentGroup.childObjType(matchedName);
      if (objType != H5O_TYPE_GROUP) {
        std::ostringstream msg;
        msg << "Path component '" << matchedName << "' in '" << requestedPath
            << "' is not a group";
        throw H5::DataSetIException("FindDatasetPath", msg.str());
      }
      // Open the group for next iteration
      currentGroup = currentGroup.openGroup(matchedName);
    }
  }
 
  return currentPath;
}
 
//=============================================================================
// nxH5::PNeXus Constructor
//=============================================================================
nxH5::PNeXus::PNeXus()
{
  unsigned majnum, minnum, relnum;
  herr_t status;
  std::stringstream ss;
 
  status = H5get_libversion(&majnum, &minnum, &relnum);
  if (status >= 0) {
    ss << majnum << "." << minnum << "." << relnum;
  }
  fHdf5LibVersion = ss.str();
}
 
//=============================================================================
// nxH5::PNeXus Constructor
//=============================================================================
nxH5::PNeXus::PNeXus(const  std::string fln, const bool printDebug) : fFileName(fln), fPrintDebug(printDebug)
{
  unsigned majnum, minnum, relnum;
  herr_t status;
  std::stringstream ss;
 
  status = H5get_libversion(&majnum, &minnum, &relnum);
  if (status >= 0) {
    ss << majnum << "." << minnum << "." << relnum;
  }
  fHdf5LibVersion = ss.str();
 
  ReadNexusFile();
}
 
 
//=============================================================================
// Read NeXus File
//=============================================================================
int nxH5::PNeXus::ReadNexusFile()
{
  try {
    // Open the HDF5/NeXus file
    H5::H5File file(fFileName, H5F_ACC_RDONLY);
 
           // Turn off the auto-printing when failure occurs so that we can
           // handle the errors appropriately
    H5::Exception::dontPrint();
 
           // Load NeXus version attribute (with case-insensitive lookup)
    std::string version;
    try {
      std::string versionNeXusAttr = FindAttributeName(file, "NeXus_version");
      H5::Attribute attr = file.openAttribute(versionNeXusAttr);
      H5::DataType dtype = attr.getDataType();
      attr.read(dtype, version);
      attr.close();
      fNeXusVersion = version;
      if (fPrintDebug)
        std::cout << "debug> NeXus version=" << fNeXusVersion << std::endl;
    } catch (const H5::AttributeIException& err) {
      std::cerr << "Error: Failed to read NeXus_version attribute: " << err.getDetailMsg() << std::endl;
      return 1;
    }
 
           // Load IDF version from dataset (with case-insensitive lookup)
    int idf_vers{-1};
    try {
      std::string idfPath = FindDatasetPath(file, "/run/IDF_version");
      H5::DataSet dataset = file.openDataSet(idfPath);
      dataset.read(&idf_vers, H5::PredType::NATIVE_INT);
      dataset.close();
      fIdfVersion = idf_vers;
    } catch (const H5::DataSetIException& err) {
      if (fPrintDebug)
        std::cout << "Info: not IDF version 1, will check for IDF version 2" << std::endl;
    }
 
    if (fIdfVersion == -1) {
      try {
        std::string idfPath = FindDatasetPath(file, "/raw_data_1/IDF_version");
        H5::DataSet dataset = file.openDataSet(idfPath);
        dataset.read(&idf_vers, H5::PredType::NATIVE_INT);
        dataset.close();
        fIdfVersion = idf_vers;
      } catch (const H5::DataSetIException& err) {
        std::cerr << "Error: Failed to read IDF_version dataset: " << err.getDetailMsg() << std::endl;
        return 1;
      }
 
      try {
        std::string versionHdf5Attr = FindAttributeName(file, "HDF5_version");
        H5::Attribute attr = file.openAttribute(versionHdf5Attr);
        H5::DataType dtype = attr.getDataType();
        attr.read(dtype, version);
        attr.close();
        fHdf5Version = version;
        if (fPrintDebug)
          std::cout << "debug> HDF5 version=" << fHdf5Version << std::endl;
      } catch (const H5::AttributeIException& err) {
        std::cerr << "Error: Failed to read HDF5_version attribute: " << err.getDetailMsg() << std::endl;
        return 1;
      }
    }
 
    if (fPrintDebug)
      std::cout << "debug> IDF_version=" << fIdfVersion << std::endl;
 
    if (fIdfVersion == 1) {
      try {
        HandleIdfV1(file);
      } catch (...) {
 
      }
    } else { // fIdfVersion == 2
      try {
        HandleIdfV2(file);
      } catch (...) {
 
      }
    }
 
    return 0;
 
  } catch (const H5::FileIException& err) {
    std::cerr << "Error: Failed to open file '" << fFileName << "': " << err.getDetailMsg() << std::endl;
    return 1;
  } catch (const H5::Exception& err) {
    std::cerr << "Error: HDF5 exception occurred: " << err.getDetailMsg() << std::endl;
    return 1;
  } catch (const std::exception& err) {
    std::cerr << "Error: Unexpected exception: " << err.what() << std::endl;
    return 1;
  }
}
 
//=============================================================================
// Handle NeXus IDF version 1 file
//=============================================================================
void nxH5::PNeXus::HandleIdfV1(H5::H5File &file)
{
  if (fPrintDebug)
    std::cout << "debug> in HandleIdfV1 ..." << std::endl;
 
  std::string attrStr{""}, attrStrName{""};
  // get file_name attribute
  try {
    attrStrName = FindAttributeName(file, "user");
    H5::Attribute attr = file.openAttribute(attrStrName);
    H5::DataType dtype = attr.getDataType();
    attr.read(dtype, attrStr);
    attr.close();
    fUserV1 = attrStr;
    if (fPrintDebug)
      std::cout << "debug> user =" << fUserV1 << std::endl;
  } catch (const H5::AttributeIException& err) {
    std::cerr << "Error: Failed to read user attribute: " << err.getDetailMsg() << std::endl;
  }
 
         // Read the mandatory key datasets and store them in the data map
  try {
    ReadStringDataset(file, "/run/program_name");
    ReadIntDataset(file, "/run/number");
    ReadStringDataset(file, "/run/title");
    ReadStringDataset(file, "/run/notes");
    ReadStringDataset(file, "/run/analysis");
    ReadStringDataset(file, "/run/lab");
    ReadStringDataset(file, "/run/beamline");
    ReadStringDataset(file, "/run/start_time");
    ReadStringDataset(file, "/run/stop_time");
    ReadIntDataset(file, "/run/switching_states");
    ReadStringDataset(file, "/run/user/name");
    ReadStringDataset(file, "/run/user/experiment_number");
    ReadStringDataset(file, "/run/sample/name");
    ReadFloatDataset(file, "/run/sample/temperature");
    ReadFloatDataset(file, "/run/sample/magnetic_field");
    ReadStringDataset(file, "/run/sample/magnetic_field_state");
    ReadFloatDataset(file, "/run/sample/magnetic_field_vector");
    ReadStringDataset(file, "/run/sample/environment");
    ReadStringDataset(file, "/run/instrument/name");
    ReadIntDataset(file, "/run/instrument/detector/number");
    ReadFloatDataset(file, "/run/instrument/detector/deadtimes");
    ReadStringDataset(file, "/run/instrument/collimator/type");
    ReadStringDataset(file, "/run/instrument/beam/beamline");
    ReadIntDataset(file, "/run/instrument/beam/frames_good");
    ReadIntDataset(file, "/run/histogram_data_1/counts");
    ReadIntDataset(file, "/run/histogram_data_1/resolution");
    ReadIntDataset(file, "/run/histogram_data_1/time_zero");
    ReadFloatDataset(file, "/run/histogram_data_1/raw_time");
    ReadFloatDataset(file, "/run/histogram_data_1/corrected_time");
    ReadIntDataset(file, "/run/histogram_data_1/grouping");
    ReadFloatDataset(file, "/run/histogram_data_1/alpha");
  } catch (const H5::Exception& err) {
    std::cerr << "Error in HandleIdfV1: " << err.getDetailMsg() << std::endl;
    throw;
  }
}
 
//=============================================================================
// Handle NeXus IDF version 2 file
//=============================================================================
void nxH5::PNeXus::HandleIdfV2(H5::H5File &file)
{
  if (fPrintDebug)
    std::cout << "debug> in HandleIdfV2 ..." << std::endl;
 
  std::string attrStr{""}, attrStrName{""};
  // get file_name attribute
  try {
    attrStrName = FindAttributeName(file, "file_name");
    H5::Attribute attr = file.openAttribute(attrStrName);
    H5::DataType dtype = attr.getDataType();
    attr.read(dtype, attrStr);
    attr.close();
    fFileNameNxs = attrStr;
    if (fPrintDebug)
      std::cout << "debug> NXS file_name =" << fFileNameNxs << std::endl;
  } catch (const H5::AttributeIException& err) {
    std::cerr << "Error: Failed to read file_name attribute: " << err.getDetailMsg() << std::endl;
  }
 
         // get file_time attribute
  attrStr="";
  try {
    attrStrName = FindAttributeName(file, "file_time");
    H5::Attribute attr = file.openAttribute(attrStrName);
    H5::DataType dtype = attr.getDataType();
    attr.read(dtype, attrStr);
    attr.close();
    fFileTimeNxs = attrStr;
    if (fPrintDebug)
      std::cout << "debug> NXS file_time =" << fFileNameNxs << std::endl;
  } catch (const H5::AttributeIException& err) {
    std::cerr << "Error: Failed to read file_time attribute: " << err.getDetailMsg() << std::endl;
  }
 
         // Read the mandatory key datasets and store them in the data map
  try {
    ReadIntDataset(file, "/raw_data_1/IDF_version");
    ReadStringDataset(file, "/raw_data_1/beamline");
    ReadStringDataset(file, "/raw_data_1/definition");
    ReadIntDataset(file, "/raw_data_1/good_frames");
    ReadIntDataset(file, "/raw_data_1/run_number");
    ReadStringDataset(file, "/raw_data_1/title");
    ReadStringDataset(file, "/raw_data_1/start_time");
    ReadStringDataset(file, "/raw_data_1/end_time");
    ReadStringDataset(file, "/raw_data_1/experiment_identifier");
    ReadStringDataset(file, "/raw_data_1/instrument/name");
    ReadStringDataset(file, "/raw_data_1/instrument/source/name");
    ReadStringDataset(file, "/raw_data_1/instrument/source/type");
    ReadStringDataset(file, "/raw_data_1/instrument/source/probe");
    ReadIntDataset(file, "/raw_data_1/instrument/detector_1/resolution");
    ReadIntDataset(file, "/raw_data_1/instrument/detector_1/counts");
    ReadFloatDataset(file, "/raw_data_1/instrument/detector_1/raw_time");
    ReadIntDataset(file, "/raw_data_1/instrument/detector_1/spectrum_index");
    ReadFloatDataset(file, "/raw_data_1/instrument/detector_1/dead_time");
    ReadStringDataset(file, "/raw_data_1/sample/name");
    ReadFloatDataset(file, "/raw_data_1/sample/temperature");
    ReadFloatDataset(file, "/raw_data_1/sample/magnetic_field");
    ReadStringDataset(file, "/raw_data_1/sample/shape");
  } catch (const H5::Exception& err) {
    std::cerr << "Error in HandleIdfV2: " << err.getDetailMsg() << std::endl;
    throw;
  }
}
 
//=============================================================================
// Dump hdf5-NeXus file content which was read
//=============================================================================
void nxH5::PNeXus::Dump()
{
  int first_good_bin{0};
 
  if (fIdfVersion == 1) {
    std::cout << std::endl;
    std::cout << std::endl << "hdf5-NeXus file content of file:' " << fFileName << "'";      std::cout << std::endl << "****";
    std::cout << std::endl << "****";
    std::cout << std::endl << "Top Level Attributes:";
    std::cout << std::endl << " NeXus Version: " << fNeXusVersion;
    std::cout << std::endl << " user: " << fUserV1;
    std::cout << std::endl << "++++";
    std::cout << std::endl << "run";
    std::cout << std::endl << "----";
    std::cout << std::endl << " IDF_version: " << fIdfVersion;
    if (fDataMap.find("/run/program_name") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/program_name"]);
        std::cout << std::endl << " program_name : " << str_data.GetData()[0];
 
               // Check for attributes
        if (str_data.HasAttribute("version")) {
          try {
            auto version = std::any_cast<std::string>(str_data.GetAttribute("version"));
            std::cout << "   version : " << version << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast version attribute" << std::endl;
          }
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast program_name data" << std::endl;
      }
    } else {
      std::cout << std::endl << " program_name : n/a";
    }
 
    if (fDataMap.find("/run/number") != fDataMap.end()) {
      try {
        auto number = std::any_cast<PNXdata<int>>(fDataMap["/run/number"]);
        std::cout << std::endl << " number : " << number.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast number data" << std::endl;
      }
    } else {
      std::cout << std::endl << " number : n/a";
    }
 
    if (fDataMap.find("/run/title") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/title"]);
        std::cout << std::endl << " title : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast title data" << std::endl;
      }
    } else {
      std::cout << std::endl << " title : n/a";
    }
 
    if (fDataMap.find("/run/notes") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/notes"]);
        std::cout << std::endl << " notes : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast notes data" << std::endl;
      }
    } else {
      std::cout << std::endl << " notes : n/a";
    }
 
    if (fDataMap.find("/run/analysis") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/analysis"]);
        std::cout << std::endl << " analysis : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast analysis data" << std::endl;
      }
    } else {
      std::cout << std::endl << " analysis : n/a";
    }
 
    if (fDataMap.find("/run/lab") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/lab"]);
        std::cout << std::endl << " lab : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast lab data" << std::endl;
      }
    } else {
      std::cout << std::endl << " lab : n/a";
    }
 
    if (fDataMap.find("/run/beamline") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/beamline"]);
        std::cout << std::endl << " beamline : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast beamline data" << std::endl;
      }
    } else {
      std::cout << std::endl << " beamline : n/a";
    }
 
    if (fDataMap.find("/run/start_time") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/start_time"]);
        std::cout << std::endl << " start_time : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast start_time data" << std::endl;
      }
    } else {
      std::cout << std::endl << " start_time : n/a";
    }
 
    if (fDataMap.find("/run/end_time") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/end_time"]);
        std::cout << std::endl << " end_time : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast end_time data" << std::endl;
      }
    } else {
      std::cout << std::endl << " end_time : n/a";
    }
 
    if (fDataMap.find("/run/switching_state") != fDataMap.end()) {
      try {
        auto int_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/switching_state"]);
        std::cout << std::endl << " switching_state : " << int_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast switching_state data" << std::endl;
      }
    } else {
      std::cout << std::endl << " switching_state : n/a";
    }
 
    std::cout << std::endl << " user";
    std::cout << std::endl << "----";
    if (fDataMap.find("/run/usr/name") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/user/name"]);
        std::cout << std::endl << "  name : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast name data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  name : n/a";
    }
 
    if (fDataMap.find("/run/usr/experiment_number") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/user/experiment_number"]);
        std::cout << std::endl << "  experiment_number : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast experiment_number data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  experiment_number : n/a";
    }
 
    std::cout << std::endl << " sample";
    std::cout << std::endl << "----";
    if (fDataMap.find("/run/sample/name") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/sample/name"]);
        std::cout << std::endl << "  name : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast name data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  name : n/a";
    }
 
    if (fDataMap.find("/run/sample/temperature") != fDataMap.end()) {
      try {
        auto float_data = std::any_cast<PNXdata<float>>(fDataMap["/run/sample/temperature"]);
        std::cout << std::endl << "  temperature : " << float_data.GetData()[0];
 
        // Check for attributes
        if (float_data.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(float_data.GetAttribute("units"));
            std::cout << "   units : " << units << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast units attribute" << std::endl;
          }
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast temperature data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  temperature : n/a";
    }
 
    if (fDataMap.find("/run/sample/magnetic_field") != fDataMap.end()) {
      try {
        auto float_data = std::any_cast<PNXdata<float>>(fDataMap["/run/sample/magnetic_field"]);
        std::cout << std::endl << "  magnetic_field : " << float_data.GetData()[0];
 
               // Check for attributes
        if (float_data.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(float_data.GetAttribute("units"));
            std::cout << "   units : " << units << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast units attribute" << std::endl;
          }
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast magnetic_field data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  magnetic_field : n/a";
    }
 
    if (fDataMap.find("/run/sample/magnetic_field_vector") != fDataMap.end()) {
      try {
        auto float_data = std::any_cast<PNXdata<float>>(fDataMap["/run/sample/magnetic_field_vector"]);
        std::cout << std::endl << "  magnetic_field_vector : " << float_data.GetData()[0];
 
               // Check for attributes
        if (float_data.HasAttribute("coordinate_system")) {
          try {
            auto coordinate_system = std::any_cast<std::string>(float_data.GetAttribute("coordinate_system"));
            std::cout << "   coordinate_system : " << coordinate_system << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast coordinate_system attribute" << std::endl;
          }
        }
        if (float_data.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(float_data.GetAttribute("units"));
            std::cout << "   units : " << units << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast units attribute" << std::endl;
          }
        }
        if (float_data.HasAttribute("available")) {
          try {
            auto available = std::any_cast<int>(float_data.GetAttribute("available"));
            std::cout << "   available : " << available << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast available attribute" << std::endl;
          }
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast magnetic_field_vector data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  magnetic_field_vector : n/a";
    }
 
    if (fDataMap.find("/run/sample/environment") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/sample/environment"]);
        std::cout << std::endl << "  environment : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast environment data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  environment : n/a";
    }
 
    std::cout << std::endl << " instrument";
    std::cout << std::endl << "----";
    if (fDataMap.find("/run/instrument/name") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/instrument/name"]);
        std::cout << std::endl << "  name : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast name data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  name : n/a";
    }
 
    std::cout << std::endl << "  detector";
    std::cout << std::endl << "----";
    if (fDataMap.find("/run/instrument/detector/number") != fDataMap.end()) {
      try {
        auto int_data = std::any_cast<PNXdata<int>>(fDataMap["/run/instrument/detector/number"]);
        std::cout << std::endl << "   number : " << int_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast number data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   number : n/a";
    }
 
    if (fDataMap.find("/run/instrument/detector/deadtimes") != fDataMap.end()) {
      try {
        const auto& dead_times = std::any_cast<PNXdata<float>>("/run/instrument/detector/deadtimes").GetData();
        std::cout << std::endl << "   deadtimes: ";
        for (unsigned int i=0; i<10; i++)
          std::cout << dead_times[i] << ", ";
        std::cout << "...";
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast dead time data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   deadtimes: n/a";
    }
 
    std::cout << std::endl << "  collimator";
    std::cout << std::endl << "----";
    if (fDataMap.find("/run/instrument/collimator/type") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/instrument/collimator/type"]);
        std::cout << std::endl << "   type : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast type data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   type : n/a";
    }
 
    std::cout << std::endl << "  beam";
    std::cout << std::endl << "----";
    if (fDataMap.find("/run/instrument/beam/beamline") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/instrument/beam/beamline"]);
        std::cout << std::endl << "   beamline : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast beamline data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   beamline : n/a";
    }
 
    if (fDataMap.find("/run/instrument/beam/frames_good") != fDataMap.end()) {
      try {
        auto str_data = std::any_cast<PNXdata<std::string>>(fDataMap["/run/instrument/beam/frames_good"]);
        std::cout << std::endl << "   frames_good : " << str_data.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast frames_good data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   frames_good : n/a";
    }
 
    std::cout << std::endl << " histogram_data_1";
    std::cout << std::endl << "----";
    std::cout << std::endl << "  counts:";
    std::cout << std::endl;
    try {
      auto counts_data = std::any_cast<PNXdata<int>>(fDataMap["/run/histogram_data_1/counts"]);
 
             // Check for attributes
      if (counts_data.HasAttribute("units")) {
        try {
          auto units = std::any_cast<std::string>(counts_data.GetAttribute("units"));
          std::cout << "   units : " << units << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast units attribute" << std::endl;
        }
      } else {
        std::cout << "   units : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("signal")) {
        try {
          auto signal = std::any_cast<int>(counts_data.GetAttribute("signal"));
          std::cout << "   signal : " << signal << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast signal attribute" << std::endl;
        }
      } else {
        std::cout << "   signal : n/a" << std::endl;
      }
 
      int noOfHistos{0};
      if (counts_data.HasAttribute("number")) {
        try {
          noOfHistos = std::any_cast<int>(counts_data.GetAttribute("number"));
          std::cout << "   number : " << noOfHistos << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast number attribute" << std::endl;
        }
      } else {
        std::cout << "   number : n/a" << std::endl;
      }
 
      int histoLength{0};
      if (counts_data.HasAttribute("length")) {
        try {
          histoLength = std::any_cast<int>(counts_data.GetAttribute("length"));
          std::cout << "   length : " << noOfHistos << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast length attribute" << std::endl;
        }
      } else {
        std::cout << "   length : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("t0_bin")) {
        try {
          auto t0_bin = std::any_cast<int>(counts_data.GetAttribute("t0_bin"));
          std::cout << "   t0_bin : " << t0_bin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast t0_bin attribute" << std::endl;
        }
      } else {
        std::cout << "   t0_bin : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("first_good_bin")) {
        try {
          first_good_bin = std::any_cast<int>(counts_data.GetAttribute("first_good_bin"));
          std::cout << "   first_good_bin : " << first_good_bin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast first_good_bin attribute" << std::endl;
        }
      } else {
        std::cout << "   first_good_bin : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("last_good_bin")) {
        try {
          auto last_good_bin = std::any_cast<int>(counts_data.GetAttribute("last_good_bin"));
          std::cout << "   last_good_bin : " << last_good_bin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast last_good_bin attribute" << std::endl;
        }
      } else {
        std::cout << "   last_good_bin : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("offset")) {
        try {
          auto offset = std::any_cast<float>(counts_data.GetAttribute("offset"));
          std::cout << "   offset : " << offset << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast offset attribute" << std::endl;
        }
      } else {
        std::cout << "   offset : n/a" << std::endl;
      }
 
      // dump the first couple of counts of each detector
      const auto& data = counts_data.GetData();
      std::cout << std::endl << "  first couple of counts of each detector:";
      for (unsigned int i=0; i<noOfHistos; i++) {
        if (i<9)
          std::cout << std::endl << "   " << i+1 << ": ";
        else
          std::cout << std::endl << "  " << i+1 << ": ";
        for (unsigned int j=0; j<first_good_bin+5; j++)
          std::cout << data[i*histoLength+j] << ", ";
        std::cout << "...";
      }
    } catch (const std::bad_any_cast& e) {
      std::cerr << "Error: Failed to cast counts data" << std::endl;
    }
 
    if (fDataMap.find("/run/histogram_data_1/resolution") != fDataMap.end()) {
      try {
        auto int_data = std::any_cast<PNXdata<int>>(fDataMap["/run/histogram_data_1/resolution"]);
        std::cout << std::endl << "   resolution : " << int_data.GetData()[0];
 
        if (int_data.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(int_data.GetAttribute("units"));
            std::cout << "   units : " << units << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast units attribute" << std::endl;
          }
        } else {
          std::cout << "   units : n/a" << std::endl;
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast resolution data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   resolution : n/a";
    }
 
    if (fDataMap.find("/run/histogram_data_1/time_zero") != fDataMap.end()) {
      try {
        auto int_data = std::any_cast<PNXdata<int>>(fDataMap["/run/histogram_data_1/time_zero"]);
        std::cout << std::endl << "   time_zero : " << int_data.GetData()[0];
 
        if (int_data.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(int_data.GetAttribute("units"));
            std::cout << "   units : " << units << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast units attribute" << std::endl;
          }
        } else {
          std::cout << "   units : n/a" << std::endl;
        }
 
        if (int_data.HasAttribute("available")) {
          try {
            auto available = std::any_cast<int>(int_data.GetAttribute("available"));
            std::cout << "   available : " << available << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast available attribute" << std::endl;
          }
        } else {
          std::cout << "   available : n/a" << std::endl;
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast time_zero data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   time_zero : n/a";
    }
 
    if (fDataMap.find("/run/histogram_data_1/raw_time") != fDataMap.end()) {
      try {
        auto float_data = std::any_cast<PNXdata<float>>(fDataMap["/run/histogram_data_1/raw_time"]);
        std::cout << std::endl << "   raw_time : " << float_data.GetData()[0];
        if (float_data.HasAttribute("axis")) {
          try {
            auto axis = std::any_cast<int>(float_data.GetAttribute("axis"));
            std::cout << "   axis : " << axis << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast axis attribute" << std::endl;
          }
        } else {
          std::cout << "   axis : n/a" << std::endl;
        }
 
        if (float_data.HasAttribute("primary")) {
          try {
            auto primary = std::any_cast<int>(float_data.GetAttribute("primary"));
            std::cout << "   primary : " << primary << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast primary attribute" << std::endl;
          }
        } else {
          std::cout << "   primary : n/a" << std::endl;
        }
 
        if (float_data.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(float_data.GetAttribute("units"));
            std::cout << "   units : " << units << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast units attribute" << std::endl;
          }
        } else {
          std::cout << "   units : n/a" << std::endl;
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast raw_time data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   raw_time : n/a";
    }
 
    if (fDataMap.find("/run/histogram_data_1/corrected_time") != fDataMap.end()) {
      try {
        auto float_data = std::any_cast<PNXdata<float>>(fDataMap["/run/histogram_data_1/corrected_time"]);
        std::cout << std::endl << "   corrected_time : " << float_data.GetData()[0];
        if (float_data.HasAttribute("axis")) {
          try {
            auto axis = std::any_cast<int>(float_data.GetAttribute("axis"));
            std::cout << "   axis : " << axis << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast axis attribute" << std::endl;
          }
        } else {
          std::cout << "   axis : n/a" << std::endl;
        }
 
        if (float_data.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(float_data.GetAttribute("units"));
            std::cout << "   units : " << units << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast units attribute" << std::endl;
          }
        } else {
          std::cout << "   units : n/a" << std::endl;
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast raw_time data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   corrected_time : n/a";
    }
 
    if (fDataMap.find("/run/histogram_data_1/grouping") != fDataMap.end()) {
      try {
        auto int_data = std::any_cast<PNXdata<int>>(fDataMap["/run/histogram_data_1/grouping"]);
        std::cout << std::endl << "   grouping : " << int_data.GetData()[0];
        if (int_data.HasAttribute("available")) {
          try {
            auto available = std::any_cast<int>(int_data.GetAttribute("available"));
            std::cout << "   available : " << available << std::endl;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast available attribute" << std::endl;
          }
        } else {
          std::cout << std::endl << "   available : n/a";
        }
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast grouping data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   grouping : n/a";
    }
 
    std::cout << std::endl;
  } else { // IDF Version 2
    std::cout << std::endl;
    std::cout << std::endl << "hdf5-NeXus file content of file:' " << fFileName << "'";
    std::cout << std::endl << "****";
    std::cout << std::endl << "Top Level Attributes:";
    std::cout << std::endl << " HDF5 Version : " << fHdf5Version;
    std::cout << std::endl << " NeXus Version: " << fNeXusVersion;
    std::cout << std::endl << " file_name    : " << fFileNameNxs;
    std::cout << std::endl << " file_time    : " << fFileTimeNxs;
    std::cout << std::endl << "++++";
    std::cout << std::endl << "raw_data_1";
    std::cout << std::endl << "----";
    std::cout << std::endl << " IDF_version: " << fIdfVersion;
    if (fDataMap.find("/raw_data_1/beamline") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/beamline"]);
        std::cout << std::endl << " beamline   : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast beamline data" << std::endl;
      }
    } else {
      std::cout << std::endl << " beamline   : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/definition") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/definition"]);
        std::cout << std::endl << " definition : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast definition data" << std::endl;
      }
    } else {
      std::cout << std::endl << " definition : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/run_number") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<int>>(fDataMap["/raw_data_1/run_number"]);
        std::cout << std::endl << " run_number : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast run_number data" << std::endl;
      }
    } else {
      std::cout << std::endl << " run_number : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/title") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/title"]);
        std::cout << std::endl << " title      : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast title data" << std::endl;
      }
    } else {
      std::cout << std::endl << " title      : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/start_time") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/start_time"]);
        std::cout << std::endl << " start_time : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast start_time data" << std::endl;
      }
    } else {
      std::cout << std::endl << " start_time : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/end_time") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/end_time"]);
        std::cout << std::endl << " end_time   : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast end_time data" << std::endl;
      }
    } else {
      std::cout << std::endl << " end_time   : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/good_frames") != fDataMap.end()) {
      try {
        auto good_frames = std::any_cast<PNXdata<int>>(fDataMap["/raw_data_1/good_frames"]);
        std::cout << std::endl << " good_frames: " << good_frames.GetData()[0];
      } catch(const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast good_frames data" << std::endl;
      }
    } else {
      std::cout << std::endl << " good_frames: n/a";
    }
 
    if (fDataMap.find("/raw_data_1/experiment_identifier") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/experiment_identifier"]);
        std::cout << std::endl << " experiment_identifier: " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast experiment_identifier data" << std::endl;
      }
    } else {
      std::cout << std::endl << " experiment_identifier: n/a";
    }
 
    std::cout << std::endl << "----";
    std::cout << std::endl << " instrument";
    if (fDataMap.find("/raw_data_1/instrument/name") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/instrument/name"]);
        std::cout << std::endl << "  name      : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast instrument/name data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  name      : n/a";
    }
 
    std::cout << std::endl << "----";
    std::cout << std::endl << "  source";
    if (fDataMap.find("/raw_data_1/instrument/source/name") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/instrument/source/name"]);
        std::cout << std::endl << "   name     : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast instrument/source/name data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   name     : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/instrument/source/type") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/instrument/source/type"]);
        std::cout << std::endl << "   type     : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast instrument/source/type data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   type     : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/instrument/source/probe") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/instrument/source/probe"]);
        std::cout << std::endl << "   probe    : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast instrument/source/probe data" << std::endl;
      }
    } else {
      std::cout << std::endl << "   probe    : n/a";
    }
 
    std::cout << std::endl << "----";
    std::cout << std::endl << " sample";
    if (fDataMap.find("/raw_data_1/sample/name") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/sample/name"]);
        std::cout << std::endl << "  name      : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast sample/name data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  name      : n/a";
    }
 
    if (fDataMap.find("/raw_data_1/sample/temperature") != fDataMap.end()) {
      try {
        auto temp_ds = std::any_cast<PNXdata<float>>(fDataMap["/raw_data_1/sample/temperature"]);
        float temp = temp_ds.GetData()[0];
        if (temp_ds.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(temp_ds.GetAttribute("units"));
            if (units == "Celsius")
              temp += 273.16;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast units attribute" << std::endl;
          }
        }
        std::cout << std::endl << "  temperature: " << temp << " K";
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast sample/temperature data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  temperature: n/a";
    }
 
    if (fDataMap.find("/raw_data_1/sample/magnetic_field") != fDataMap.end()) {
      try {
        auto mag_field_ds = std::any_cast<PNXdata<float>>(fDataMap["/raw_data_1/sample/magnetic_field"]);
        float mag_field = mag_field_ds.GetData()[0];
        if (mag_field_ds.HasAttribute("units")) {
          try {
            auto units = std::any_cast<std::string>(mag_field_ds.GetAttribute("units"));
            if (units == "Tesla")
              mag_field *= 1e4;
          } catch (const std::bad_any_cast& e) {
            std::cerr << "Error: Failed to cast units attribute" << std::endl;
          }
        }
        std::cout << std::endl << "  mag. field: " << mag_field << " G";
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast sample/magnetic_field data" << std::endl;
      }
    } else {
        std::cout << std::endl << "  temperature: n/a";
    }
 
    if (fDataMap.find("/raw_data_1/sample/shape") != fDataMap.end()) {
      try {
        auto str = std::any_cast<PNXdata<std::string>>(fDataMap["/raw_data_1/sample/shape"]);
        std::cout << std::endl << "  shape     : " << str.GetData()[0];
      } catch (const std::bad_any_cast& e) {
        std::cerr << std::endl << "Error: Failed to cast sample/shape data" << std::endl;
      }
    } else {
      std::cout << std::endl << "  shape     : n/a";
    }
 
    std::cout << std::endl << "----";
    std::cout << std::endl << " detector_1";
    std::cout << std::endl << "  counts:";
    std::cout << std::endl;
    try {
      auto counts_data = std::any_cast<PNXdata<int>>(fDataMap["/raw_data_1/instrument/detector_1/counts"]);
      auto dims = counts_data.GetDimensions();
      std::cout << "   counts dimensions: " << dims[0] << " x "
                << dims[1] << " x " << dims[2] << std::endl;
      std::cout << "   total elements: " << counts_data.GetNumElements() << std::endl;
 
             // Check for attributes
      if (counts_data.HasAttribute("signal")) {
        try {
          auto signal = std::any_cast<int>(counts_data.GetAttribute("signal"));
          std::cout << "   signal : " << signal << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast signal attribute" << std::endl;
        }
      } else {
        std::cout << "   signal : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("axes")) {
        try {
          auto axes = std::any_cast<std::string>(counts_data.GetAttribute("axes"));
          std::cout << "   axes : " << axes << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast axes attribute" << std::endl;
        }
      } else {
        std::cout << "   axes : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("long_name")) {
        try {
          auto long_name = std::any_cast<std::string>(counts_data.GetAttribute("long_name"));
          std::cout << "   long_name : " << long_name << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast long_name attribute" << std::endl;
        }
      } else {
        std::cout << "   long_name : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("t0_bin")) {
        try {
          auto t0_bin = std::any_cast<int>(counts_data.GetAttribute("t0_bin"));
          std::cout << "   t0_bin : " << t0_bin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast t0_bin attribute" << std::endl;
        }
      } else {
        std::cout << "   t0_bin : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("first_good_bin")) {
        try {
          first_good_bin = std::any_cast<int>(counts_data.GetAttribute("first_good_bin"));
          std::cout << "   first_good_bin : " << first_good_bin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast first_good_bin attribute" << std::endl;
        }
      } else {
        std::cout << "   first_good_bin : n/a" << std::endl;
      }
 
      if (counts_data.HasAttribute("last_good_bin")) {
        try {
          auto last_good_bin = std::any_cast<int>(counts_data.GetAttribute("last_good_bin"));
          std::cout << "   last_good_bin  : " << last_good_bin << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast last_good_bin attribute" << std::endl;
        }
      } else {
        std::cout << "   last_good_bin  : n/a" << std::endl;
      }
 
      if (fDataMap.find("/raw_data_1/instrument/detector_1/resolution") != fDataMap.end()) {
        try {
          auto ivalData = std::any_cast<PNXdata<int>>(fDataMap["/raw_data_1/instrument/detector_1/resolution"]);
          std::cout << "   resolution     : " << ivalData.GetData()[0];
          if (ivalData.HasAttribute("units")) {
            try {
              auto units = std::any_cast<std::string>(ivalData.GetAttribute("units"));
              std::cout << " " << units << std::endl;
            } catch (const std::bad_any_cast& e) {
              std::cerr << "Error: Failed to cast units attribute" << std::endl;
            }
          }
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast resolution attribute" << std::endl;
        }
      } else {
        std::cout << "   resolution     : n/a";
      }
 
      // dump the first couple of counts of each detector
      const auto& data = counts_data.GetData();
      std::cout << std::endl << "  first couple of counts of each detector:";
      for (unsigned int i=0; i<dims[1]; i++) {
        if (i<9)
          std::cout << std::endl << "   " << i+1 << ": ";
        else
          std::cout << std::endl << "  " << i+1 << ": ";
        for (unsigned int j=0; j<first_good_bin+5; j++)
          std::cout << data[i*dims[2]+j] << ", ";
        std::cout << "...";
      }
    } catch (const std::bad_any_cast& e) {
      std::cerr << "Error: Failed to cast counts data" << std::endl;
    }
 
    std::cout << std::endl;
    std::cout << std::endl << "  raw_time:";
    std::cout << std::endl;
    try {
      auto raw_time = std::any_cast<PNXdata<float>>(fDataMap["/raw_data_1/instrument/detector_1/raw_time"]);
      const auto& data = raw_time.GetData();
 
      // Check for attributes
      if (raw_time.HasAttribute("units")) {
        try {
          auto units = std::any_cast<std::string>(raw_time.GetAttribute("units"));
          std::cout << "   units : " << units << std::endl;
        } catch (const std::bad_any_cast& e) {
          std::cerr << "Error: Failed to cast units attribute" << std::endl;
        }
      } else {
        std::cout << "   units : n/a" << std::endl;
      }
 
      // dump the first couple of raw_times
      std::cout << "   ";
      for (unsigned int i=0; i<first_good_bin+5; i++)
        std::cout << data[i] << ", ";
      std::cout << "...";
    } catch (const std::bad_any_cast& e) {
      std::cerr << "Error: Failed to cast raw_time data" << std::endl;
    }
 
    std::cout << std::endl;
    std::cout << std::endl << "  spectrum_index:";
    std::cout << std::endl;
    try {
      auto spectrum_index = std::any_cast<PNXdata<int>>(fDataMap["/raw_data_1/instrument/detector_1/spectrum_index"]);
      const auto& data = spectrum_index.GetData();
 
             // dump the first couple of raw_times
      std::cout << "   ";
      for (unsigned int i=0; i<first_good_bin+5; i++)
        std::cout << data[i] << ", ";
      std::cout << "...";
    } catch (const std::bad_any_cast& e) {
      std::cerr << "Error: Failed to cast spectrum_index data" << std::endl;
    }
 
    std::cout << std::endl;
    std::cout << std::endl << "  dead_time:";
    std::cout << std::endl;
    try {
      auto dead_time = std::any_cast<PNXdata<float>>(fDataMap["/raw_data_1/instrument/detector_1/dead_time"]);
      const auto& data = dead_time.GetData();
 
      // dump the first couple of raw_times
      std::cout << "   ";
      for (unsigned int i=0; i<first_good_bin+5; i++)
        std::cout << data[i] << ", ";
      std::cout << "...";
    } catch (const std::bad_any_cast& e) {
      std::cerr << "Error: Failed to cast spectrum_index data" << std::endl;
    }
 
    std::cout << std::endl;
  }
}
 
//=============================================================================
// Read integer dataset and store in data map
//=============================================================================
void nxH5::PNeXus::ReadIntDataset(H5::H5File& file, const std::string& path)
{
  try {
    // Find the actual path (case-insensitive)
    std::string actualPath = FindDatasetPath(file, path);
 
           // Open the dataset
    H5::DataSet dataset = file.openDataSet(actualPath);
    H5::DataType datatype = dataset.getDataType();
    H5::DataSpace dataspace = dataset.getSpace();
 
           // Get dimensions
    int rank = dataspace.getSimpleExtentNdims();
    std::vector<hsize_t> dims(rank);
    dataspace.getSimpleExtentDims(dims.data(), nullptr);
 
           // Calculate total number of elements
    hsize_t numElements = 1;
    for (int i = 0; i < rank; i++) {
      numElements *= dims[i];
    }
 
           // Create PNXdata object
    PNXdata<int> data(datatype);
    data.SetDimensions(dims);
 
           // Read data
    std::vector<int> buffer(numElements);
    dataset.read(buffer.data(), H5::PredType::NATIVE_INT);
    data.SetData(buffer);
 
           // Read attributes
    ReadDatasetAttributes(dataset, data);
 
           // Store in map
    fDataMap[actualPath] = data;
 
    dataset.close();
 
    if (fPrintDebug) {
      std::cout << "debug> Read integer dataset: " << actualPath
                << " (dims: ";
      for (size_t i = 0; i < dims.size(); i++) {
        std::cout << dims[i];
        if (i < dims.size() - 1) std::cout << " x ";
      }
      std::cout << ")" << std::endl;
    }
  } catch (const H5::Exception& err) {
    std::cerr << "Error reading integer dataset " << path << ": "
              << err.getDetailMsg() << std::endl;
    throw;
  }
}
 
//=============================================================================
// Read float dataset and store in data map
//=============================================================================
void nxH5::PNeXus::ReadFloatDataset(H5::H5File& file, const std::string& path)
{
  try {
    // Find the actual path (case-insensitive)
    std::string actualPath = FindDatasetPath(file, path);
 
           // Open the dataset
    H5::DataSet dataset = file.openDataSet(actualPath);
    H5::DataType datatype = dataset.getDataType();
    H5::DataSpace dataspace = dataset.getSpace();
 
           // Get dimensions
    int rank = dataspace.getSimpleExtentNdims();
    std::vector<hsize_t> dims(rank);
    dataspace.getSimpleExtentDims(dims.data(), nullptr);
 
           // Calculate total number of elements
    hsize_t numElements = 1;
    for (int i = 0; i < rank; i++) {
      numElements *= dims[i];
    }
 
           // Create PNXdata object
    PNXdata<float> data(datatype);
    data.SetDimensions(dims);
 
           // Read data
    std::vector<float> buffer(numElements);
    dataset.read(buffer.data(), H5::PredType::NATIVE_FLOAT);
    data.SetData(buffer);
 
           // Read attributes
    ReadDatasetAttributes(dataset, data);
 
           // Store in map
    fDataMap[actualPath] = data;
 
    dataset.close();
 
    if (fPrintDebug) {
      std::cout << "debug> Read float dataset: " << actualPath
                << " (dims: ";
      for (size_t i = 0; i < dims.size(); i++) {
        std::cout << dims[i];
        if (i < dims.size() - 1) std::cout << " x ";
      }
      std::cout << ")" << std::endl;
    }
  } catch (const H5::Exception& err) {
    std::cerr << "Error reading float dataset " << path << ": "
              << err.getDetailMsg() << std::endl;
    throw;
  }
}
 
//=============================================================================
// Read string dataset and store in data map
//=============================================================================
void nxH5::PNeXus::ReadStringDataset(H5::H5File& file, const std::string& path)
{
  try {
    // Find the actual path (case-insensitive)
    std::string actualPath = FindDatasetPath(file, path);
 
           // Open the dataset
    H5::DataSet dataset = file.openDataSet(actualPath);
    H5::DataType datatype = dataset.getDataType();
    H5::DataSpace dataspace = dataset.getSpace();
 
           // Get dimensions
    int rank = dataspace.getSimpleExtentNdims();
    std::vector<hsize_t> dims(rank);
    dataspace.getSimpleExtentDims(dims.data(), nullptr);
 
           // Calculate total number of elements
    hsize_t numElements = 1;
    for (int i = 0; i < rank; i++) {
      numElements *= dims[i];
    }
 
           // Create PNXdata object
    PNXdata<std::string> data(datatype);
    data.SetDimensions(dims);
 
           // Read data
    std::vector<std::string> buffer(numElements);
    if (numElements == 1) {
      // Single string
      std::string value;
      dataset.read(value, datatype);
      buffer[0] = value;
    } else {
      // Multiple strings (if needed)
      for (hsize_t i = 0; i < numElements; i++) {
        dataset.read(buffer[i], datatype);
      }
    }
    data.SetData(buffer);
 
           // Read attributes
    ReadDatasetAttributes(dataset, data);
 
           // Store in map
    fDataMap[actualPath] = data;
 
    dataset.close();
 
    if (fPrintDebug) {
      std::cout << "debug> Read string dataset: " << actualPath << std::endl;
    }
  } catch (const H5::Exception& err) {
    std::cerr << "Error reading string dataset " << path << ": "
              << err.getDetailMsg() << std::endl;
    throw;
  }
}
 
//=============================================================================
// Read dataset attributes (template implementation)
//=============================================================================
template <typename T>
void nxH5::PNeXus::ReadDatasetAttributes(H5::DataSet& dataset, PNXdata<T>& data)
{
  int numAttrs = dataset.getNumAttrs();
 
  for (int i = 0; i < numAttrs; i++) {
    H5::Attribute attr = dataset.openAttribute(i);
    std::string attrName = attr.getName();
    H5::DataType attrType = attr.getDataType();
    H5T_class_t typeClass = attrType.getClass();
 
    try {
      if (typeClass == H5T_INTEGER) {
        int value;
        attr.read(H5::PredType::NATIVE_INT, &value);
        data.AddAttribute(attrName, value);
      } else if (typeClass == H5T_FLOAT) {
        float value;
        attr.read(H5::PredType::NATIVE_FLOAT, &value);
        data.AddAttribute(attrName, value);
      } else if (typeClass == H5T_STRING) {
        std::string value;
        attr.read(attrType, value);
        data.AddAttribute(attrName, value);
      }
    } catch (const H5::Exception& err) {
      if (fPrintDebug) {
        std::cerr << "Warning: Could not read attribute " << attrName
                  << ": " << err.getDetailMsg() << std::endl;
      }
    }
 
    attr.close();
  }
}
 
// Explicit template instantiations
template void nxH5::PNeXus::ReadDatasetAttributes(H5::DataSet&, PNXdata<int>&);
template void nxH5::PNeXus::ReadDatasetAttributes(H5::DataSet&, PNXdata<float>&);
template void nxH5::PNeXus::ReadDatasetAttributes(H5::DataSet&, PNXdata<std::string>&);
 
//=============================================================================
// WRITE METHODS
//=============================================================================
 
//=============================================================================
// Create group hierarchy for a given path
//=============================================================================
H5::Group nxH5::PNeXus::CreateGroupHierarchy(H5::H5File& file, const std::string& path)
{
  std::vector<std::string> components = SplitPath(path);
  std::string currentPath = "";
  H5::Group currentGroup;
 
  for (const auto& component : components) {
    if (component.empty()) continue; // Skip empty (root indicator)
 
    currentPath += "/" + component;
 
           // Check if group exists
    bool exists = false;
    try {
      H5::Group testGroup = file.openGroup(currentPath);
      testGroup.close();
      exists = true;
    } catch (const H5::Exception&) {
      exists = false;
    }
 
           // Create if doesn't exist
    if (!exists) {
      if (fPrintDebug) {
        std::cout << "debug> Creating group: " << currentPath << std::endl;
      }
      currentGroup = file.createGroup(currentPath);
 
             // Write group attributes if any exist for this path
      auto attrIt = fGroupAttributes.find(currentPath);
      if (attrIt != fGroupAttributes.end()) {
        if (fPrintDebug) {
          std::cout << "debug> Writing " << attrIt->second.size()
          << " attributes to group: " << currentPath << std::endl;
        }
        WriteGroupAttributes(currentGroup, attrIt->second);
      }
 
      currentGroup.close();
 
      if (fPrintDebug) {
        std::cout << "debug> Created group: " << currentPath << std::endl;
      }
    }
  }
 
         // Return an invalid group handle (we just needed to create the hierarchy)
  return currentGroup;
}
 
//=============================================================================
// Write dataset attributes from PNXdata object
//=============================================================================
template <typename T>
void nxH5::PNeXus::WriteDatasetAttributes(H5::DataSet& dataset, const PNXdata<T>& data)
{
  const auto& attributes = data.GetAttributes();
 
  for (const auto& [attrName, attrValue] : attributes) {
    try {
      // Try int
      if (auto* intVal = std::any_cast<int>(&attrValue)) {
        H5::DataSpace attrSpace(H5S_SCALAR);
        H5::Attribute attr = dataset.createAttribute(
          attrName, H5::PredType::NATIVE_INT32, attrSpace
          );
        attr.write(H5::PredType::NATIVE_INT32, intVal);
        attr.close();
        attrSpace.close();
      }
      // Try float
      else if (auto* floatVal = std::any_cast<float>(&attrValue)) {
        H5::DataSpace attrSpace(H5S_SCALAR);
        H5::Attribute attr = dataset.createAttribute(
          attrName, H5::PredType::NATIVE_FLOAT, attrSpace
          );
        attr.write(H5::PredType::NATIVE_FLOAT, floatVal);
        attr.close();
        attrSpace.close();
      }
      // Try string
      else if (auto* strVal = std::any_cast<std::string>(&attrValue)) {
        H5::StrType strType(H5::PredType::C_S1, H5T_VARIABLE);
        H5::DataSpace attrSpace(H5S_SCALAR);
        H5::Attribute attr = dataset.createAttribute(
          attrName, strType, attrSpace
          );
        attr.write(strType, *strVal);
        attr.close();
        attrSpace.close();
      }
      // Try vector<int> for multi-element attributes
      else if (auto* intVec = std::any_cast<std::vector<int>>(&attrValue)) {
        hsize_t dims[1] = {intVec->size()};
        H5::DataSpace attrSpace(1, dims);
        H5::Attribute attr = dataset.createAttribute(
          attrName, H5::PredType::NATIVE_INT32, attrSpace
          );
        attr.write(H5::PredType::NATIVE_INT32, intVec->data());
        attr.close();
        attrSpace.close();
      }
      // Try vector<float> for multi-element attributes
      else if (auto* floatVec = std::any_cast<std::vector<float>>(&attrValue)) {
        hsize_t dims[1] = {floatVec->size()};
        H5::DataSpace attrSpace(1, dims);
        H5::Attribute attr = dataset.createAttribute(
          attrName, H5::PredType::NATIVE_FLOAT, attrSpace
          );
        attr.write(H5::PredType::NATIVE_FLOAT, floatVec->data());
        attr.close();
        attrSpace.close();
      }
      else {
        if (fPrintDebug) {
          std::cerr << "Warning: Unsupported attribute type for "
                    << attrName << std::endl;
        }
      }
 
    } catch (const H5::Exception& err) {
      if (fPrintDebug) {
        std::cerr << "Warning: Could not write attribute " << attrName
                  << ": " << err.getDetailMsg() << std::endl;
      }
    }
  }
}
 
//=============================================================================
// Write integer dataset with attributes
//=============================================================================
void nxH5::PNeXus::WriteIntDataset(H5::H5File& file, const std::string& path,
                             const PNXdata<int>& data)
{
  try {
    // Extract parent path and dataset name
    size_t lastSlash = path.find_last_of('/');
    std::string parentPath = (lastSlash == 0) ? "/" : path.substr(0, lastSlash);
    std::string datasetName = path.substr(lastSlash + 1);
 
           // Create parent group hierarchy
    if (!parentPath.empty() && parentPath != "/") {
      CreateGroupHierarchy(file, parentPath);
    }
 
           // Get dimensions and data
    const auto& dims = data.GetDimensions();
    const auto& buffer = data.GetData();
 
           // Validate data consistency
    if (buffer.size() != data.GetNumElements()) {
      throw std::runtime_error("Data size mismatch with dimensions");
    }
 
           // Create dataspace
    H5::DataSpace dataspace(dims.size(), dims.data());
 
           // Create dataset
    H5::DataSet dataset = file.createDataSet(
      path,
      H5::PredType::NATIVE_INT,
      dataspace
      );
 
           // Write data
    dataset.write(buffer.data(), H5::PredType::NATIVE_INT);
 
           // Write attributes
    WriteDatasetAttributes(dataset, data);
 
           // Close resources
    dataset.close();
    dataspace.close();
 
    if (fPrintDebug) {
      std::cout << "debug> Wrote integer dataset: " << path
                << " (dims: ";
      for (size_t i = 0; i < dims.size(); i++) {
        std::cout << dims[i];
        if (i < dims.size() - 1) std::cout << " x ";
      }
      std::cout << ")" << std::endl;
    }
 
  } catch (const H5::Exception& err) {
    std::cerr << "Error writing integer dataset " << path << ": "
              << err.getDetailMsg() << std::endl;
    throw;
  }
}
 
//=============================================================================
// Write float dataset with attributes
//=============================================================================
void nxH5::PNeXus::WriteFloatDataset(H5::H5File& file, const std::string& path,
                               const PNXdata<float>& data)
{
  try {
    // Extract parent path and dataset name
    size_t lastSlash = path.find_last_of('/');
    std::string parentPath = (lastSlash == 0) ? "/" : path.substr(0, lastSlash);
    std::string datasetName = path.substr(lastSlash + 1);
 
           // Create parent group hierarchy
    if (!parentPath.empty() && parentPath != "/") {
      CreateGroupHierarchy(file, parentPath);
    }
 
           // Get dimensions and data
    const auto& dims = data.GetDimensions();
    const auto& buffer = data.GetData();
 
           // Validate data consistency
    if (buffer.size() != data.GetNumElements()) {
      throw std::runtime_error("Data size mismatch with dimensions");
    }
 
           // Create dataspace
    H5::DataSpace dataspace(dims.size(), dims.data());
 
           // Create dataset
    H5::DataSet dataset = file.createDataSet(
      path,
      H5::PredType::NATIVE_FLOAT,
      dataspace
      );
 
           // Write data
    dataset.write(buffer.data(), H5::PredType::NATIVE_FLOAT);
 
           // Write attributes
    WriteDatasetAttributes(dataset, data);
 
           // Close resources
    dataset.close();
    dataspace.close();
 
    if (fPrintDebug) {
      std::cout << "debug> Wrote float dataset: " << path
                << " (dims: ";
      for (size_t i = 0; i < dims.size(); i++) {
        std::cout << dims[i];
        if (i < dims.size() - 1) std::cout << " x ";
      }
      std::cout << ")" << std::endl;
    }
 
  } catch (const H5::Exception& err) {
    std::cerr << "Error writing float dataset " << path << ": "
              << err.getDetailMsg() << std::endl;
    throw;
  }
}
 
//=============================================================================
// Write string dataset with attributes
//=============================================================================
void nxH5::PNeXus::WriteStringDataset(H5::H5File& file, const std::string& path,
                                const PNXdata<std::string>& data)
{
  try {
    // Extract parent path and dataset name
    size_t lastSlash = path.find_last_of('/');
    std::string parentPath = (lastSlash == 0) ? "/" : path.substr(0, lastSlash);
    std::string datasetName = path.substr(lastSlash + 1);
 
           // Create parent group hierarchy
    if (!parentPath.empty() && parentPath != "/") {
      CreateGroupHierarchy(file, parentPath);
    }
 
           // Get data
    const auto& buffer = data.GetData();
    const auto& dims = data.GetDimensions();
 
    /* //as35
        // Handle single string vs array of strings
        if (buffer.size() == 1 && dims.size() == 1 && dims[0] == 1) {
          // Single string - use variable-length string type
          H5::StrType strType(H5::PredType::C_S1, H5T_VARIABLE);
          H5::DataSpace dataspace(H5S_SCALAR);
 
       H5::DataSet dataset = file.createDataSet(path, strType, dataspace);
       dataset.write(buffer[0], strType);
 
        WriteDatasetAttributes(dataset, data);
        dataset.close();
        dataspace.close();
 
     } else {
 */ //as35
    // Array of strings
    H5::StrType strType(H5::PredType::C_S1, H5T_VARIABLE);
    H5::DataSpace dataspace(dims.size(), dims.data());
 
    H5::DataSet dataset = file.createDataSet(path, strType, dataspace);
 
           // For arrays, need to create array of C strings
    std::vector<const char*> cStrings;
    for (const auto& str : buffer) {
      cStrings.push_back(str.c_str());
    }
    dataset.write(cStrings.data(), strType);
 
    WriteDatasetAttributes(dataset, data);
    dataset.close();
    dataspace.close();
    /* //as35
        }
    */ //as35
 
    if (fPrintDebug) {
      std::cout << "debug> Wrote string dataset: " << path << std::endl;
    }
 
  } catch (const H5::Exception& err) {
    std::cerr << "Error writing string dataset " << path << ": "
              << err.getDetailMsg() << std::endl;
    throw;
  }
}
 
//=============================================================================
// Write group attributes
//=============================================================================
void nxH5::PNeXus::WriteGroupAttributes(H5::Group& group, const std::map<std::string, std::any>& attributes)
{
  for (const auto& [attrName, attrValue] : attributes) {
    try {
      // Try int
      if (auto* intVal = std::any_cast<int>(&attrValue)) {
        H5::DataSpace attrSpace(H5S_SCALAR);
        H5::Attribute attr = group.createAttribute(
          attrName, H5::PredType::NATIVE_INT32, attrSpace
          );
        attr.write(H5::PredType::NATIVE_INT32, intVal);
        attr.close();
        attrSpace.close();
      }
      // Try float
      else if (auto* floatVal = std::any_cast<float>(&attrValue)) {
        H5::DataSpace attrSpace(H5S_SCALAR);
        H5::Attribute attr = group.createAttribute(
          attrName, H5::PredType::NATIVE_FLOAT, attrSpace
          );
        attr.write(H5::PredType::NATIVE_FLOAT, floatVal);
        attr.close();
        attrSpace.close();
      }
      // Try string
      else if (auto* strVal = std::any_cast<std::string>(&attrValue)) {
        H5::StrType strType(H5::PredType::C_S1, H5T_VARIABLE);
        H5::DataSpace attrSpace(H5S_SCALAR);
        H5::Attribute attr = group.createAttribute(
          attrName, strType, attrSpace
          );
        attr.write(strType, *strVal);
        attr.close();
        attrSpace.close();
      }
      // Try vector<int> for multi-element attributes
      else if (auto* intVec = std::any_cast<std::vector<int>>(&attrValue)) {
        hsize_t dims[1] = {intVec->size()};
        H5::DataSpace attrSpace(1, dims);
        H5::Attribute attr = group.createAttribute(
          attrName, H5::PredType::NATIVE_INT32, attrSpace
          );
        attr.write(H5::PredType::NATIVE_INT32, intVec->data());
        attr.close();
        attrSpace.close();
      }
      // Try vector<float> for multi-element attributes
      else if (auto* floatVec = std::any_cast<std::vector<float>>(&attrValue)) {
        hsize_t dims[1] = {floatVec->size()};
        H5::DataSpace attrSpace(1, dims);
        H5::Attribute attr = group.createAttribute(
          attrName, H5::PredType::NATIVE_FLOAT, attrSpace
          );
        attr.write(H5::PredType::NATIVE_FLOAT, floatVec->data());
        attr.close();
        attrSpace.close();
      }
      else {
        if (fPrintDebug) {
          std::cerr << "Warning: Unsupported attribute type for "
                    << attrName << std::endl;
        }
      }
 
    } catch (const H5::Exception& err) {
      if (fPrintDebug) {
        std::cerr << "Warning: Failed to write group attribute "
                  << attrName << ": " << err.getDetailMsg() << std::endl;
      }
    }
  }
}
 
//=============================================================================
// Write root-level file attributes
//=============================================================================
void nxH5::PNeXus::WriteFileAttributes(H5::H5File& file)
{
  try {
    H5::StrType strType(H5::PredType::C_S1, H5T_VARIABLE);
    H5::DataSpace attrSpace(H5S_SCALAR);
 
           // Check if custom root-level attributes exist
    auto rootAttrIt = fGroupAttributes.find("/");
    bool hasCustomAttrs = (rootAttrIt != fGroupAttributes.end());
 
           // NeXus_version attribute
    if (!fNeXusVersion.empty() &&
        (!hasCustomAttrs || rootAttrIt->second.find("NeXus_version") == rootAttrIt->second.end())) {
      H5::Attribute attr = file.createAttribute(
        "NeXus_version", strType, attrSpace
        );
      attr.write(strType, fNeXusVersion);
      attr.close();
    }
 
           // HDF5_version attribute
    if (!fHdf5Version.empty() &&
        (!hasCustomAttrs || rootAttrIt->second.find("HDF5_version") == rootAttrIt->second.end())) {
      H5::Attribute attr = file.createAttribute(
        "HDF5_version", strType, attrSpace
        );
      attr.write(strType, fHdf5Version);
      attr.close();
    }
 
           // file_name attribute
    if (!fFileNameNxs.empty() &&
        (!hasCustomAttrs || rootAttrIt->second.find("file_name") == rootAttrIt->second.end())) {
      H5::Attribute attr = file.createAttribute(
        "file_name", strType, attrSpace
        );
      attr.write(strType, fFileNameNxs);
      attr.close();
    }
 
           // file_time attribute
    if (!fFileTimeNxs.empty() &&
        (!hasCustomAttrs || rootAttrIt->second.find("file_time") == rootAttrIt->second.end())) {
      H5::Attribute attr = file.createAttribute(
        "file_time", strType, attrSpace
        );
      attr.write(strType, fFileTimeNxs);
      attr.close();
    }
 
    attrSpace.close();
 
           // Write any custom root-level attributes from fGroupAttributes["/"]
    if (hasCustomAttrs) {
      if (fPrintDebug) {
        std::cout << "debug> Writing " << rootAttrIt->second.size()
        << " custom attributes to root level" << std::endl;
      }
 
      for (const auto& [attrName, attrValue] : rootAttrIt->second) {
        try {
          // Try int
          if (auto* intVal = std::any_cast<int>(&attrValue)) {
            H5::DataSpace scalarSpace(H5S_SCALAR);
            H5::Attribute attr = file.createAttribute(
              attrName, H5::PredType::NATIVE_INT32, scalarSpace
              );
            attr.write(H5::PredType::NATIVE_INT32, intVal);
            attr.close();
            scalarSpace.close();
          }
          // Try float
          else if (auto* floatVal = std::any_cast<float>(&attrValue)) {
            H5::DataSpace scalarSpace(H5S_SCALAR);
            H5::Attribute attr = file.createAttribute(
              attrName, H5::PredType::NATIVE_FLOAT, scalarSpace
              );
            attr.write(H5::PredType::NATIVE_FLOAT, floatVal);
            attr.close();
            scalarSpace.close();
          }
          // Try string
          else if (auto* strVal = std::any_cast<std::string>(&attrValue)) {
            H5::StrType varStrType(H5::PredType::C_S1, H5T_VARIABLE);
            H5::DataSpace scalarSpace(H5S_SCALAR);
            H5::Attribute attr = file.createAttribute(
              attrName, varStrType, scalarSpace
              );
            attr.write(varStrType, *strVal);
            attr.close();
            scalarSpace.close();
          }
          else {
            if (fPrintDebug) {
              std::cerr << "Warning: Unsupported attribute type for root-level "
                        << attrName << std::endl;
            }
          }
        } catch (const H5::Exception& err) {
          if (fPrintDebug) {
            std::cerr << "Warning: Failed to write root-level attribute "
                      << attrName << ": " << err.getDetailMsg() << std::endl;
          }
        }
      }
    }
 
  } catch (const H5::Exception& err) {
    std::cerr << "Error writing file attributes: "
              << err.getDetailMsg() << std::endl;
    throw;
  }
}
 
//=============================================================================
// Group attribute management methods
//=============================================================================

bool nxH5::PNeXus::AddGroupAttribute(const std::string& groupPath, const std::string& attrName,
                               const std::any& attrValue)
{
  fGroupAttributes[groupPath][attrName] = attrValue;
  return true;
}

bool nxH5::PNeXus::RemoveGroupAttribute(const std::string& groupPath, const std::string& attrName)
{
  auto groupIt = fGroupAttributes.find(groupPath);
  if (groupIt == fGroupAttributes.end()) {
    return false;
  }
 
  auto attrIt = groupIt->second.find(attrName);
  if (attrIt == groupIt->second.end()) {
    return false;
  }
 
  groupIt->second.erase(attrIt);
 
         // Clean up empty group entry
  if (groupIt->second.empty()) {
    fGroupAttributes.erase(groupIt);
  }
 
  return true;
}

bool nxH5::PNeXus::HasGroupAttribute(const std::string& groupPath, const std::string& attrName) const
{
  auto groupIt = fGroupAttributes.find(groupPath);
  if (groupIt == fGroupAttributes.end()) {
    return false;
  }
 
  return groupIt->second.find(attrName) != groupIt->second.end();
}

std::any nxH5::PNeXus::GetGroupAttribute(const std::string& groupPath, const std::string& attrName) const
{
  return fGroupAttributes.at(groupPath).at(attrName);
}

const std::map<std::string, std::any>& nxH5::PNeXus::GetGroupAttributes(const std::string& groupPath) const
{
  static const std::map<std::string, std::any> emptyMap;
  auto it = fGroupAttributes.find(groupPath);
  if (it == fGroupAttributes.end()) {
    return emptyMap;
  }
  return it->second;
}

bool nxH5::PNeXus::ClearGroupAttributes(const std::string& groupPath)
{
  auto it = fGroupAttributes.find(groupPath);
  if (it == fGroupAttributes.end()) {
    return false;
  }
 
  fGroupAttributes.erase(it);
  return true;
}

bool nxH5::PNeXus::AddRootAttribute(const std::string& attrName, const std::any& attrValue)
{
  return AddGroupAttribute("/", attrName, attrValue);
}
 
//=============================================================================
// Write NeXus file (main entry point)
//=============================================================================
int nxH5::PNeXus::WriteNexusFile(const std::string& filename, int idfVersion)
{
  try {
    if (fPrintDebug) {
      std::cout << std::endl;
      std::cout << "debug> Creating NeXus file: " << filename << std::endl;
    }
 
    // Validate that we have data to write
    if (fDataMap.empty()) {
      std::cerr << "Error: No data to write (data map is empty)" << std::endl;
      return 1;
    }
 
    // Create new HDF5 file (truncate if exists)
    H5::H5File file(filename, H5F_ACC_TRUNC);
 
    // Turn off auto-printing for exceptions
    H5::Exception::dontPrint();
 
    // Write root-level file attributes
    WriteFileAttributes(file);
 
    // Write structure based on IDF version
    if ((idfVersion == 1) || (idfVersion == 2)) {
      if (fPrintDebug) {
        std::cout << "debug> Writing IDF v2 structure..." << std::endl;
      }
 
             // Iterate through all datasets in fDataMap
      for (const auto& [path, anyData] : fDataMap) {
        try {
          // Try PNXdata<int>
          try {
            auto intData = std::any_cast<PNXdata<int>>(anyData);
            WriteIntDataset(file, path, intData);
            continue;
          } catch (const std::bad_any_cast&) {}
 
                 // Try PNXdata<float>
          try {
            auto floatData = std::any_cast<PNXdata<float>>(anyData);
            WriteFloatDataset(file, path, floatData);
            continue;
          } catch (const std::bad_any_cast&) {}
 
                 // Try PNXdata<std::string>
          try {
            auto strData = std::any_cast<PNXdata<std::string>>(anyData);
            WriteStringDataset(file, path, strData);
            continue;
          } catch (const std::bad_any_cast&) {}
 
                 // Unknown type
          if (fPrintDebug) {
            std::cerr << "Warning: Unknown data type for path " << path
                      << std::endl;
          }
 
        } catch (const H5::Exception& err) {
          std::cerr << "Error writing dataset " << path << ": "
                    << err.getDetailMsg() << std::endl;
          throw;
        }
      }
    } else {
      std::cerr << "Error: Unsupported IDF version " << idfVersion
                << std::endl;
      file.close();
      return 1;
    }
 
    // Close file
    file.close();
 
    if (fPrintDebug) {
      std::cout << "debug> Successfully wrote NeXus file: " << filename
                << std::endl;
    }
 
    return 0;
 
  } catch (const H5::FileIException& err) {
    std::cerr << "Error: Failed to create file '" << filename << "': "
              << err.getDetailMsg() << std::endl;
    return 1;
  } catch (const H5::Exception& err) {
    std::cerr << "Error: HDF5 exception occurred: "
              << err.getDetailMsg() << std::endl;
    return 1;
  } catch (const std::exception& err) {
    std::cerr << "Error: Unexpected exception: " << err.what() << std::endl;
    return 1;
  }
}
 
// Explicit template instantiations for write methods
template void nxH5::PNeXus::WriteDatasetAttributes(H5::DataSet&, const PNXdata<int>&);
template void nxH5::PNeXus::WriteDatasetAttributes(H5::DataSet&, const PNXdata<float>&);
template void nxH5::PNeXus::WriteDatasetAttributes(H5::DataSet&, const PNXdata<std::string>&);