LMU/musrfit
5
0
Fork 0
Code Issues 5 Pull Requests Actions Packages Projects Releases 4 Activity
Files
4519a0b76e9d1cfda431543a341ecdf70f724e04
musrfit/src/external/nexus/PNeXus.cpp

5594 lines
200 KiB
C++
Raw Blame History

/***************************************************************************
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. *
***************************************************************************/
/**
* @file PNeXus.cpp
* @brief Implementation of the PNeXus class - NeXus HDF4/HDF5 file reader and writer
*
* This file contains the implementation of the PNeXus class for reading and
* writing ISIS muon NeXus HDF5 files. It provides case-insensitive path
* lookup functionality using the HDF4 C / HDF5 C++ API.
*
* The implementation includes:
*
* **Read Functionality:**
* - String utilities for case-insensitive comparison
* - Path parsing for HDF4 / HDF5 hierarchical paths
* - Recursive path traversal with case-insensitive matching
* - Attribute, group, and dataset lookup functions
* - Support for IDF version 1 and 2
*
* **Write Functionality:**
* - Group hierarchy creation
* - Dataset writing for int, float, and string types
* - Attribute preservation
* - Multi-dimensional array support
* - Type-safe operations using PNXdata template class
*
* **Error Handling:**
* - Comprehensive error handling with descriptive exceptions
* - Validation of data consistency
* - HDF4 error propagation / HDF5 exception propagation
*
* @author Andreas Suter
* @date 2007-2026
* @copyright GNU General Public License v2
* @version 1.0
*
* @see nxH4::PNeXus
* @see nxH4::PNXdata
* @see nxH5::PNeXus
* @see nxH5::PNXdata
*/
#include <iostream>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <cstring>
#include <cmath>
#include "Minuit2/MnStrategy.h"
#include "Minuit2/MnMinimize.h"
#include "Minuit2/FunctionMinimum.h"
#include "PNeXus.h"
//=============================================================================
// nxs::checkHDFType - Determine HDF file format from magic bytes
//=============================================================================
/**
* @brief Determine the HDF format type of a file by reading its header
*
* Opens the file in binary mode and reads the first 8 bytes to compare
* against known HDF4 and HDF5 magic byte signatures. This allows automatic
* format detection before attempting to open the file with the appropriate
* library.
*
* @param filename Path to the file to check
* @return nxs::HDFType indicating the format (HDF4, HDF5, or Unknown)
*/
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;
}
#ifdef HAVE_HDF4
//=============================================================================
// 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)
{
}
//=============================================================================
// PNeXus Constructor with filename
//=============================================================================
nxH4::PNeXus::PNeXus(const std::string fln, const bool printDebug)
: fPrintDebug(printDebug), fFileName(fln), fSdId(-1), fFileId(-1)
{
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::INT32);
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::FLOAT32);
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::CHAR8);
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<int32_t>(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<int32_t>(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<int32_t>(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<int32_t>>(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
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 attributes
WriteFileAttributes(sd_id);
// Write datasets based on IDF version
if (idfVersion == 2) {
WriteIdfV2(sd_id);
} else {
std::cerr << "**ERROR** Unsupported IDF version for writing: " << idfVersion << std::endl;
SDend(sd_id);
return 1;
}
SDend(sd_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::WriteIdfV2
//=============================================================================
void nxH4::PNeXus::WriteIdfV2(int32 sd_id)
{
// Write all datasets from data map
for (const auto& [path, data_any] : fDataMap) {
// Try to write as int dataset
try {
auto data = std::any_cast<PNXdata<int>>(data_any);
WriteIntDataset(sd_id, path, data);
continue;
} catch (...) {}
// Try to write as float dataset
try {
auto data = std::any_cast<PNXdata<float>>(data_any);
WriteFloatDataset(sd_id, path, data);
continue;
} catch (...) {}
// Try to write as string dataset
try {
auto data = std::any_cast<PNXdata<std::string>>(data_any);
WriteStringDataset(sd_id, path, data);
continue;
} catch (...) {}
}
}
//=============================================================================
// nxH4::PNeXus::WriteIntDataset
//=============================================================================
void 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);
SDendaccess(sds_id);
}
//=============================================================================
// nxH4::PNeXus::WriteFloatDataset
//=============================================================================
void 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);
SDendaccess(sds_id);
}
//=============================================================================
// nxH4::PNeXus::WriteStringDataset
//=============================================================================
void 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;
}
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);
SDendaccess(sds_id);
}
//=============================================================================
// 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 (...) {}
}
}
//=============================================================================
// Group attribute methods - manage attributes associated with HDF4 groups
//=============================================================================
/**
* @brief Add or update an attribute for a group
*
* Stores an attribute value in the internal group attributes map. These
* attributes will be written when WriteNexusFile() is called. The root
* group "/" can be used for file-level attributes.
*
* @param groupPath HDF4 path of the group (e.g., "/raw_data_1")
* @param attrName Attribute name
* @param attrValue Attribute value (stored as std::any)
* @return true if attribute was added successfully
*/
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(vg_id, 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(child_vg_id, 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;
}
/**
* @brief Convert HDF4 numeric type constant to H4DataType enum
*
* Maps HDF4 DFNT_* type constants to the library's H4DataType enum for
* type-safe handling of dataset types.
*
* @param hdf4_type HDF4 numeric type constant (e.g., DFNT_INT32)
* @return Corresponding H4DataType enum value
*
* @note Unknown types default to H4DataType::INT32
*/
nxH4::H4DataType nxH4::PNeXus::convertHdf4Type(int32 hdf4_type)
{
switch (hdf4_type) {
case DFNT_INT32: return H4DataType::INT32;
case DFNT_FLOAT32: return H4DataType::FLOAT32;
case DFNT_FLOAT64: return H4DataType::FLOAT64;
case DFNT_CHAR8: return H4DataType::CHAR8;
case DFNT_UINT32: return H4DataType::UINT32;
case DFNT_INT16: return H4DataType::INT16;
case DFNT_UINT16: return H4DataType::UINT16;
case DFNT_INT8: return H4DataType::INT8;
case DFNT_UINT8: return H4DataType::UINT8;
default: return H4DataType::INT32;
}
}
/**
* @brief Convert H4DataType enum to HDF4 numeric type constant
*
* Maps the library's H4DataType enum to HDF4 DFNT_* type constants
* for writing datasets to HDF4 files.
*
* @param dataType H4DataType enum value
* @return Corresponding HDF4 numeric type constant (e.g., DFNT_INT32)
*
* @note Unknown types default to DFNT_INT32
*/
int32 nxH4::PNeXus::convertToHdf4Type(H4DataType dataType)
{
switch (dataType) {
case H4DataType::INT32: return DFNT_INT32;
case H4DataType::FLOAT32: return DFNT_FLOAT32;
case H4DataType::FLOAT64: return DFNT_FLOAT64;
case H4DataType::CHAR8: return DFNT_CHAR8;
case H4DataType::UINT32: return DFNT_UINT32;
case H4DataType::INT16: return DFNT_INT16;
case H4DataType::UINT16: return DFNT_UINT16;
case H4DataType::INT8: return DFNT_INT8;
case H4DataType::UINT8: 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<int32_t>(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<int32_t>(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<int32_t>(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()
//=============================================================================
/**
* @brief Calculate the negative log-likelihood for dead time correction
*
* This function implements the objective function for ROOT Minuit2 minimization.
* It calculates the negative log-likelihood comparing observed counts to
* the expected count rate model with dead time correction.
*
* **Model:**
* The expected count rate includes:
* - Exponential muon decay: N(t) = N0 * exp(-t/tau_mu) + N_bkg
* - Dead time correction: N_corrected = N(t) / (1 + N(t) * dtc)
*
* **Parameters:**
* - par[0] (dtc): Dead time correction parameter
* - par[1] (N0): Initial count rate amplitude
* - par[2] (N_bkg): Background count rate
*
* @param par Vector of parameters [dtc, N0, N_bkg]
* @return Negative log-likelihood value to be minimized
*
* @note Uses the muon lifetime tau_mu = 2.1969811 microseconds
*/
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()
//=============================================================================
/**
* @brief Minimize dead time for a specific detector spectrum
*
* Performs ROOT Minuit2 minimization to find the optimal dead time parameter
* and count rate model parameters for the specified spectrum index. Uses
* MnMinimize with strategy 2 (high precision) and stores the result.
*
* **Minimization Parameters:**
* - dtc: Dead time correction (initial: 0.01, step: 0.01)
* - N0: Initial count rate (initial: estimated from data)
* - N_bkg: Background rate (initial: 0.1)
*
* @param i Spectrum index to minimize (0-based, must be < dims[1])
*
* @note Results are stored in fDeadTimeEstimated[i] and optionally printed
* to stdout if debug mode is enabled
*
* @see GetDeadTimeEstimated() to retrieve results after minimization
*/
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; ///< Minuit2 function minimum result
// 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
//=============================================================================
/**
* Compares two strings character-by-character using case-insensitive matching.
* The function first checks if the lengths match, then converts each character
* to lowercase using std::tolower before comparison.
*
* @param a First string to compare
* @param b Second string to compare
* @return true if strings are equal (ignoring case), false otherwise
*
* @note Uses static_cast to unsigned char for std::tolower to avoid undefined
* behavior with negative char values
*
* @example
* @code
* caseInsensitiveEquals("NeXus", "nexus") // returns true
* caseInsensitiveEquals("IDF_VERSION", "idf_version") // returns true
* @endcode
*/
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
//=============================================================================
/**
* Splits an HDF5 path string into individual components using '/' as delimiter.
* The function preserves the information about absolute vs relative paths by
* keeping an empty first component for absolute paths.
*
* @param path HDF5 path string to split
* @return Vector of path components
*
* @note Empty components are filtered out except for the first component
* which indicates an absolute path when empty
*
* @example
* @code
* splitPath("/raw_data_1/IDF_version") // returns ["", "raw_data_1", "IDF_version"]
* splitPath("detector_1/counts") // returns ["detector_1", "counts"]
* splitPath("/") // returns [""]
* @endcode
*/
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
//=============================================================================
/**
* Searches for an attribute by name using case-insensitive matching.
* Lists all attributes on the given HDF5 object and compares each name
* case-insensitively against the requested name.
*
* @param obj HDF5 File object to search for attributes
* @param requestedName Attribute name to find (any case)
* @return The correctly-cased attribute name as it exists in the file
* @throws H5::AttributeIException if no matching attribute is found
*
* @note Useful for handling NeXus files where attribute names may vary in case
* (e.g., "NeXus_version" vs "nexus_version")
*
* @example
* @code
* std::string actualName = findAttributeName(file, "nexus_VERSION");
* // actualName might be "NeXus_version" if that's how it's stored
* @endcode
*/
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)
//=============================================================================
/**
* Finds an HDF5 group path using case-insensitive matching, starting from
* the file root. Traverses the group hierarchy by splitting the path into
* components and matching each component case-insensitively.
*
* @param parent HDF5 File object (file root)
* @param requestedPath Group path to find (any case, absolute or relative)
* @return The correctly-cased group path as it exists in the file
* @throws H5::GroupIException if group not found or path component is not a group
*
* @note Each path component is verified to be a Group using getObjectType()
*
* @example
* @code
* std::string path = findGroupPath(file, "/RAW_DATA_1/detector_1");
* // path might be "/raw_data_1/detector_1" if that's the actual casing
* @endcode
*/
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)
//=============================================================================
/**
* Finds an HDF5 dataset path using case-insensitive matching, starting from
* the file root. Traverses the group hierarchy and verifies that the final
* path component is actually a dataset.
*
* @param parent HDF5 File object (file root)
* @param requestedPath Dataset path to find (any case, absolute or relative)
* @return The correctly-cased dataset path as it exists in the file
* @throws H5::DataSetIException if dataset not found, path invalid, or
* final component is not a dataset
*
* @note Intermediate path components must be groups, and the final component
* must be a dataset, otherwise an exception is thrown
*
* @example
* @code
* std::string path = findDatasetPath(file, "/RAW_DATA_1/idf_VERSION");
* // path might be "/raw_data_1/IDF_version" if that's the actual casing
* std::int data = H5Easy::load<int>(file, path);
* @endcode
*/
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()
{
// empty
}
//=============================================================================
// nxH5::PNeXus Constructor
//=============================================================================
/**
* Constructs a PNeXus object and immediately reads the specified NeXus file.
* The constructor initializes the filename member and calls ReadNexusFile()
* to open and parse the HDF5 file.
*
* @param fln Path to the NeXus HDF5 file to read
* @throws H5::FileIException if the file cannot be opened
* @throws H5::AttributeIException if required attributes are missing
* @throws H5::DataSetIException if required datasets are missing
*
* @note The file is read immediately upon construction. If reading fails,
* an exception is thrown and the object is not fully constructed.
*
* @example
* @code
* try {
* PNeXus nexus("data/emu00139040.nxs");
* std::cout << "Opened: " << nexus.GetFileName() << std::endl;
* } catch (const H5::Exception& e) {
* std::cerr << "Failed to open file: " << e.getDetailMsg() << std::endl;
* }
* @endcode
*/
nxH5::PNeXus::PNeXus(const std::string fln, const bool printDebug) : fFileName(fln), fPrintDebug(printDebug)
{
ReadNexusFile();
}
//=============================================================================
// Read NeXus File
//=============================================================================
/**
* Reads and parses the NeXus HDF5 file. Opens the file in read-only mode,
* loads the NeXus version attribute, and reads the IDF version dataset.
* Uses case-insensitive path lookup to handle varying path casings.
*
* @return 0 on success, 1 on error
* @throws H5::FileIException if file cannot be opened
* @throws H5::AttributeIException if NeXus_version attribute is missing
* @throws H5::DataSetIException if IDF_version dataset is missing
*
* @note This method is called automatically by the constructor. It performs
* case-insensitive lookups for both attributes and datasets to handle
* NeXus files with varying naming conventions.
*
* @internal
* Current implementation reads:
* - Attribute: NeXus_version (from root "/")
* - Dataset: /raw_data_1/IDF_version
*
* Both paths use case-insensitive lookup, so variations like
* "/RAW_DATA_1/idf_VERSION" will work correctly.
*/
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/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()
{
int32_t 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<int32_t>(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<int32_t>(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<int32_t>(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<int32_t>>(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/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
//=============================================================================
/**
* Reads an integer dataset from the HDF5 file and stores it in the data map.
* Handles multi-dimensional datasets by flattening them into a vector.
*
* @param file HDF5 file object
* @param path Path to the dataset
* @throws H5::Exception if reading fails
*/
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
//=============================================================================
/**
* Reads a float dataset from the HDF5 file and stores it in the data map.
* Handles multi-dimensional datasets by flattening them into a vector.
*
* @param file HDF5 file object
* @param path Path to the dataset
* @throws H5::Exception if reading fails
*/
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
//=============================================================================
/**
* Reads a string dataset from the HDF5 file and stores it in the data map.
*
* @param file HDF5 file object
* @param path Path to the dataset
* @throws H5::Exception if reading fails
*/
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)
//=============================================================================
/**
* Reads all attributes from an HDF5 dataset and adds them to a PNXdata object.
* Attributes can be integers, floats, or strings.
*
* @tparam T The data type of the PNXdata object
* @param dataset HDF5 dataset object
* @param data PNXdata object to add attributes to
*/
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) {
int32_t value;
attr.read(H5::PredType::NATIVE_INT32, &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
//=============================================================================
/**
* Create nested group hierarchy for a given path. Groups are created recursively
* if they don't exist. If a group already exists, it is opened and returned.
*
* @param file HDF5 file object
* @param path Full path (e.g., "/raw_data_1/detector_1")
* @return H5::Group handle to the deepest created/opened group
* @throws H5::GroupIException if group creation fails
*/
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
//=============================================================================
/**
* Writes all attributes from a PNXdata object to an HDF5 dataset.
* Supports int32_t, float, and string attribute types.
*
* @tparam T The data type of the PNXdata object
* @param dataset HDF5 dataset object to write attributes to
* @param data PNXdata object containing attributes
*/
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 int32_t
if (auto* intVal = std::any_cast<int32_t>(&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();
}
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
//=============================================================================
/**
* Writes an integer dataset to the HDF5 file with all its attributes.
* The parent group hierarchy is created automatically if it doesn't exist.
*
* @param file HDF5 file object
* @param path Dataset path (groups created automatically)
* @param data PNXdata object containing data, dimensions, and attributes
* @throws H5::Exception if writing fails
*/
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
//=============================================================================
/**
* Writes a float dataset to the HDF5 file with all its attributes.
* The parent group hierarchy is created automatically if it doesn't exist.
*
* @param file HDF5 file object
* @param path Dataset path (groups created automatically)
* @param data PNXdata object containing data, dimensions, and attributes
* @throws H5::Exception if writing fails
*/
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
//=============================================================================
/**
* Writes a string dataset to the HDF5 file with all its attributes.
* The parent group hierarchy is created automatically if it doesn't exist.
* Handles both scalar strings and arrays of strings.
*
* @param file HDF5 file object
* @param path Dataset path (groups created automatically)
* @param data PNXdata object containing data, dimensions, and attributes
* @throws H5::Exception if writing fails
*/
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
//=============================================================================
/**
* Writes attributes to an HDF5 group object. Supports int32_t, float, and
* string attribute types.
*
* @param group HDF5 group object to write attributes to
* @param attributes Map of attribute names to values (stored as std::any)
*/
void nxH5::PNeXus::WriteGroupAttributes(H5::Group& group, const std::map<std::string, std::any>& attributes)
{
for (const auto& [attrName, attrValue] : attributes) {
try {
// Try int32_t
if (auto* intVal = std::any_cast<int32_t>(&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();
}
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
//=============================================================================
/**
* Writes root-level file attributes such as NeXus_version, HDF5_version,
* file_name, and file_time to the HDF5 file.
*
* @param file HDF5 file object
* @throws H5::Exception if writing fails
*/
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 int32_t
if (auto* intVal = std::any_cast<int32_t>(&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;
}
}
//=============================================================================
// Write IDF version 2 structure
//=============================================================================
/**
* Writes all datasets from the data map to the HDF5 file following the
* IDF version 2 structure. Iterates through fDataMap and writes each
* dataset based on its type.
*
* @param file HDF5 file object
* @throws H5::Exception if writing fails
*/
void nxH5::PNeXus::WriteIdfV2(H5::H5File& file)
{
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<int32_t> - convert to int
try {
auto int32Data = std::any_cast<PNXdata<int32_t>>(anyData);
// Convert PNXdata<int32_t> to PNXdata<int>
PNXdata<int> intData(int32Data.GetDataType());
intData.SetDimensions(int32Data.GetDimensions());
std::vector<int> convertedData;
for (auto val : int32Data.GetData()) {
convertedData.push_back(static_cast<int>(val));
}
intData.SetData(convertedData);
// Copy attributes
for (const auto& [name, value] : int32Data.GetAttributes()) {
intData.AddAttribute(name, value);
}
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;
}
}
}
//=============================================================================
// Group attribute management methods
//=============================================================================
/**
* Add or update an attribute for a group.
*
* @param groupPath HDF5 path of the group (e.g., "/raw_data_1")
* @param attrName Attribute name
* @param attrValue Attribute value (stored as std::any)
* @return true if attribute was added successfully
*/
bool nxH5::PNeXus::AddGroupAttribute(const std::string& groupPath, const std::string& attrName,
const std::any& attrValue)
{
fGroupAttributes[groupPath][attrName] = attrValue;
return true;
}
/**
* Remove an attribute from a group.
*
* @param groupPath HDF5 path of the group
* @param attrName Attribute name to remove
* @return true if attribute was removed, false if group or attribute not found
*/
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;
}
/**
* Check if a group has a specific attribute.
*
* @param groupPath HDF5 path of the group
* @param attrName Attribute name to check
* @return true if attribute exists, false otherwise
*/
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();
}
/**
* Get an attribute value from a group.
*
* @param groupPath HDF5 path of the group
* @param attrName Attribute name
* @return The attribute value as std::any
* @throws std::out_of_range if group or attribute doesn't exist
*/
std::any nxH5::PNeXus::GetGroupAttribute(const std::string& groupPath, const std::string& attrName) const
{
return fGroupAttributes.at(groupPath).at(attrName);
}
/**
* Get all attributes for a group.
*
* @param groupPath HDF5 path of the group
* @return Map of attribute names to values
*/
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;
}
/**
* Clear all attributes from a group.
*
* @param groupPath HDF5 path of the group
* @return true if group was found and attributes cleared, false otherwise
*/
bool nxH5::PNeXus::ClearGroupAttributes(const std::string& groupPath)
{
auto it = fGroupAttributes.find(groupPath);
if (it == fGroupAttributes.end()) {
return false;
}
fGroupAttributes.erase(it);
return true;
}
/**
* Add or update an attribute at the root level "/".
* This is a convenience method that calls AddGroupAttribute("/", attrName, attrValue).
*
* @param attrName Attribute name
* @param attrValue Attribute value (stored as std::any)
* @return true if attribute was added successfully
*/
bool nxH5::PNeXus::AddRootAttribute(const std::string& attrName, const std::any& attrValue)
{
return AddGroupAttribute("/", attrName, attrValue);
}
//=============================================================================
// Write NeXus file (main entry point)
//=============================================================================
/**
* Writes the data map contents to a new NeXus HDF5 file.
* This is the main public API for writing NeXus files.
*
* @param filename Path to the output NeXus HDF5 file
* @param idfVersion IDF version to write (default: 2)
* @return 0 on success, 1 on error
* @throws H5::FileIException if file cannot be created
* @throws H5::GroupIException if group creation fails
* @throws H5::DataSetIException if dataset writing fails
*/
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) {
std::cerr << "Error: IDF version 1 writing not yet implemented"
<< std::endl;
file.close();
return 1;
} else if (idfVersion == 2) {
WriteIdfV2(file);
} 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>&);
Reference in New Issue View Git Blame Copy Permalink