HDF5Record.h

Go to the documentation of this file.

// This file was auto-generated by gen_hdf5record.py.
// DO NOT EDIT IT DIRECTLY.
// For documentation of the fields see the regular StandardRecord.h

#pragma once

#include "StandardRecord/StandardRecord.h"

#include "hep_hpc/hdf5/File.hpp"
#include "hep_hpc/hdf5/Ntuple.hpp"
#include "hep_hpc/hdf5/PropertyList.hpp"
#include "hep_hpc/hdf5/make_column.hpp"

namespace hdf5
{

inline std::string Join(const std::string& a, const std::string& b)
{
  if(a.empty()) return b;
  return a+"."+b;
}

#include <iostream>

typedef std::initializer_list<hep_hpc::hdf5::PropertyList> plist_init;

/// Helper for make_cols() - specialized for regular fields
template<class T> hep_hpc::hdf5::Column<T>
make_col(const size_t& chunkSize,
         const size_t& elementsPerChunk,
         const bool& shuffleInts,
         const size_t& compressionLevel,
         const std::string& name,
         std::enable_if_t<!std::is_array<T>::value, void*> dummy = 0)
{
  // for now, support chunking by number of elements in chunk 
  // and chunking by chunk size in MB. This should be temporary
  size_t chunking;
  if(elementsPerChunk == 0) {
      chunking = chunkSize * chunkSize / sizeof(T);
  }
  else if(chunkSize == 0) {
      chunking = elementsPerChunk;
  }

  // if integral type, use shuffle compression
  if constexpr(std::is_integral_v<T>)
      if(shuffleInts) 
          return hep_hpc::hdf5::make_scalar_column<T>(name, 
                                                      chunking,
                                                      {hep_hpc::hdf5::PropertyList{H5P_DATASET_CREATE}
                                                       (&H5Pset_shuffle)
                                                       (&H5Pset_deflate, compressionLevel)});
      else
          return hep_hpc::hdf5::make_scalar_column<T>(name, 
                                                      chunking, 
                                                      {hep_hpc::hdf5::PropertyList{H5P_DATASET_CREATE}
                                                       (&H5Pset_deflate, compressionLevel)});
  else
      return hep_hpc::hdf5::make_scalar_column<T>(name, 
                                                  chunking, 
                                                  {hep_hpc::hdf5::PropertyList{H5P_DATASET_CREATE}
                                                   (&H5Pset_deflate, compressionLevel)});
}

/// Helper for make_cols() - specialized for arrays
template<class T> hep_hpc::hdf5::Column<std::remove_extent_t<T>>
make_col(const size_t& chunkSize,
         const size_t& elementsPerChunk,
         const bool& shuffleInts,
         const size_t& compressionLevel,
         const std::string& name,
         std::enable_if_t<std::is_array<T>::value, void*> dummy = 0)
{
  // for now, support chunking by number of elements in chunk 
  // and chunking by chunk size in KB. This should be temporary
  size_t chunking;
  if(elementsPerChunk == 0) {
      chunking = std::max(1024 * chunkSize / sizeof(T), (size_t) 1);
  }
  else if(chunkSize == 0) {
      chunking = elementsPerChunk;
  }

  // if integral type, use shuffle compression
  if constexpr(std::is_integral_v<std::remove_extent_t<T>>)
      if(shuffleInts)
          return hep_hpc::hdf5::make_column<std::remove_extent_t<T>>(name, 
                                                                     std::extent<T>::value,
                                                                     chunking,
                                                                     {hep_hpc::hdf5::PropertyList{H5P_DATASET_CREATE}
                                                                      (&H5Pset_shuffle)
                                                                      (&H5Pset_deflate, compressionLevel)});
       else
          return hep_hpc::hdf5::make_column<std::remove_extent_t<T>>(name, 
                                                                     std::extent<T>::value, 
                                                                     chunking, 
                                                                     {hep_hpc::hdf5::PropertyList{H5P_DATASET_CREATE}
                                                                      (&H5Pset_deflate, compressionLevel)});
  else
      return hep_hpc::hdf5::make_column<std::remove_extent_t<T>>(name, 
                                                                 std::extent<T>::value, 
                                                                 chunking, 
                                                                 {hep_hpc::hdf5::PropertyList{H5P_DATASET_CREATE}
                                                                  (&H5Pset_deflate, compressionLevel)});
}

/// Return a tuple of hdf5 columns, with the given names and types
template<class... Types, class... Names> static auto
make_cols(const size_t& chunkSize,
          const size_t& elementsPerChunk,
          const bool& shuffleInts,
          const size_t& compressionLevel,
          Names... names)
{
  static_assert(sizeof...(Names) == sizeof...(Types),
                "Must specify same number of column types and column names");
  return std::make_tuple(make_col<Types>(chunkSize, elementsPerChunk, shuffleInts, compressionLevel, names)...);
}

/// Wrap a basic datatype up as if it's a class with a single member
template<class W, class... Tidx> class Wrapped
{
public:
    template<class... Cols> Wrapped(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols)
    : vals(f, name, make_cols<Tidx..., W>(chunkSize, elementsPerChunk, shuffleInts, compressionLevel, cols..., "value"))
  {
  }

  void Fill(Tidx... idxs, W x) {vals.insert(idxs..., x);}

  hep_hpc::hdf5::Ntuple<Tidx..., W> vals;
};

/// HDF5 encoding of \ref SRTrainingData
template<class... Tidx> class HDF5TrainingData
{
public:
  template<class... Cols> HDF5TrainingData(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRTrainingData& sr);

  // parent, interaction, finalstate, finalstateprong, particles, nuenergy, lepenergy, vtxx, vtxy, vtxz
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, float, float, double, double, double> vals;
};

/// HDF5 encoding of \ref SRSliceMap
template<class... Tidx> class HDF5SliceMap
{
public:
  template<class... Cols> HDF5SliceMap(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRSliceMap& sr);

  // slicemap
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned char> vals;
};

/// HDF5 encoding of \ref SRPixelObjMap
template<class... Tidx> class HDF5PixelObjMap
{
public:
  template<class... Cols> HDF5PixelObjMap(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRPixelObjMap& sr);

  // nplanes, ncells, nchan, firstplane, lastplane, firstcellx, lastcellx, firstcelly, lastcelly, hitfracx, hitfracy, cvnmap, cvnlabmap, cvnobjmap
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, float, float, unsigned char, unsigned char, unsigned char> vals;
};

/// HDF5 encoding of \ref SRCVNFeatures
template<class... Tidx> class HDF5CVNFeatures
{
public:
  template<class... Cols> HDF5CVNFeatures(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRCVNFeatures& sr);

  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> output;
  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> components;
  // noutput, ncomponents
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned int, unsigned int> vals;
};

/// HDF5 encoding of \ref SRMRCCParent
template<class... Tidx> class HDF5MRCCParent
{
public:
  template<class... Cols> HDF5MRCCParent(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRMRCCParent& sr);

  // slcidx, eff, pur, nhit, contplanes, ncellsfromedge, firstplane, lastplane, remid, cvnm, muonstart.x, muonstart.y, muonstart.z, muonstop.x, muonstop.y, muonstop.z, muonyattrans, muonfwdcell, muonbkcell, numuE, muE, hadEinmucat
  hep_hpc::hdf5::Ntuple<Tidx..., int, float, float, int, int, int, int, int, float, float, float, float, float, float, float, float, float, int, int, float, float, float> vals;
};

/// HDF5 encoding of \ref SRNDSandbox
template<class... Tidx> class HDF5NDSandbox
{
public:
  template<class... Cols> HDF5NDSandbox(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRNDSandbox& sr);

  // cvnFSNDccPi, cvnFSNDccPiNoutput
  hep_hpc::hdf5::Ntuple<Tidx..., float, unsigned int> vals;
};

/// HDF5 encoding of \ref SRNumuSandbox
template<class... Tidx> class HDF5NumuSandbox
{
public:
  template<class... Cols> HDF5NumuSandbox(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRNumuSandbox& sr);

  // pimudecay, nprotons, nmutrks, nhadHits, nhadCellsFromEdge, offTrkFra, actVtx, avedEdxtrk1, avedEdxtrk2, avedEdxtrk1Last4Cells, avedEdxtrk2Last4Cells, avedEdxtrk1Last6Cells, avedEdxtrk2Last6Cells, avedEdxtrk1Last8Cells, avedEdxtrk2Last8Cells, scattAngtrk1, scattAngtrk2, vtxE20, vtxE40, vtxE60
  hep_hpc::hdf5::Ntuple<Tidx..., int, int, int, int, int, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRJMShower
template<class... Tidx> class HDF5JMShower
{
public:
  template<class... Cols> HDF5JMShower(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRJMShower& sr);

  // nhit, nhitx, nhity, nplane, maxplanecont, maxplanegap, calE, start.x, start.y, start.z, dir.x, dir.y, dir.z, len, view, width, nplanex, nplaney, gap, stop.x, stop.y, stop.z, shwE, vtxE
  hep_hpc::hdf5::Ntuple<Tidx..., short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, float, float, float, float, float, float, float, float, unsigned short, float, short unsigned int, short unsigned int, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRJMEid
template<class... Tidx> class HDF5JMEid
{
public:
  template<class... Cols> HDF5JMEid(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRJMEid& sr);

  // ann, annE, annEL, annEPi0, annEPi0EL, annNoCos, annENoCos, ismuon, dedx0, dedx1, dedx2, dedx3, dedx4, dedx5, eglll, egllt, emulll, emullt, epi0lll, epi0llt, eplll, epllt, enlll, enllt, epilll, epillt, vtxgev, pi0mass, shwEFrac, gap, costheta, elll, ellt, eellll, eelllt, mulll, mullt
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, float, int, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRNusSandbox
template<class... Tidx> class HDF5NusSandbox
{
public:
  template<class... Cols> HDF5NusSandbox(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRNusSandbox& sr);

  // sumtx, sumty, ewsumtx, ewsumty, cossumtx, cossumty, cosewsumtx, cosewsumty, angsumtx, angsumty, angewsumtx, angewsumty
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRGlobalTruth
template<class... Tidx> class HDF5GlobalTruth
{
public:
  template<class... Cols> HDF5GlobalTruth(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRGlobalTruth& sr);

  // nnu
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned int> vals;
};

/// HDF5 encoding of \ref SRGeant4Weights
template<class... Tidx> class HDF5Geant4Weights
{
public:
  template<class... Cols> HDF5Geant4Weights(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRGeant4Weights& sr);

  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> piplus_univ;
  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> piminus_univ;
  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> proton_univ;
  // piplus_cv, piminus_cv, proton_cv, npiplus_univ, npiminus_univ, nproton_univ
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, unsigned int, unsigned int, unsigned int> vals;
};

/// HDF5 encoding of \ref SRFluxWeights
template<class... Tidx> class HDF5FluxWeights
{
public:
  template<class... Cols> HDF5FluxWeights(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRFluxWeights& sr);

  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> vuniv;
  // cv, nvuniv
  hep_hpc::hdf5::Ntuple<Tidx..., float, unsigned int> vals;
};

/// HDF5 encoding of \ref SRGenieWeights
template<class... Tidx> class HDF5GenieWeights
{
public:
  template<class... Cols> HDF5GenieWeights(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRGenieWeights& sr);

  // minus2sigma, minus1sigma, plus1sigma, plus2sigma
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRNuGenParticle
template<class... Tidx> class HDF5NuGenParticle
{
public:
  template<class... Cols> HDF5NuGenParticle(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRNuGenParticle& sr);

  std::unique_ptr<Wrapped<unsigned int, Tidx..., unsigned int>> primList;
  // pdg, status, p.E, p.px, p.py, p.pz
  hep_hpc::hdf5::Ntuple<Tidx..., short int, int, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRTrueParticle
template<class... Tidx> class HDF5TrueParticle
{
public:
  template<class... Cols> HDF5TrueParticle(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRTrueParticle& sr);

  std::unique_ptr<Wrapped<int, Tidx..., unsigned int>> daughterlist;
  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> daughterEnergies;
  // pdg, visE, visEinslc, daughterVisE, daughterVisEinslc, visEBirks, visEinslcBirks, daughterVisEBirks, daughterVisEinslcBirks, enteringE, totEscE, time, p.E, p.px, p.py, p.pz, trkID, prefsiID, elasticProtonSumVisE, inelasticProtonSumVisE, inelasticPhotonSumVisE, elasticProtonSumVisEinslc, inelasticProtonSumVisEinslc, inelasticPhotonSumVisEinslc, elasticProtonMaxVisE, inelasticProtonMaxVisE, inelasticPhotonMaxVisE, elasticProtonMaxVisEinslc, inelasticProtonMaxVisEinslc, inelasticPhotonMaxVisEinslc, maxInelasticProtonTrueE, maxInelasticPhotonTrueE, maxElasticProtonTrueE
  hep_hpc::hdf5::Ntuple<Tidx..., int, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, int, int, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRBeam
template<class... Tidx> class HDF5Beam
{
public:
  template<class... Cols> HDF5Beam(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRBeam& sr);

  // tv.x, tv.y, tv.z, tp.x, tp.y, tp.z, runjob, potnum, tptype, nimpwt, ndecay, v.x, v.y, v.z, pdp.x, pdp.y, pdp.z, ppdxdz, ppdydz, pppz, ppenergy, ppmedium, ptype, ppv.x, ppv.y, ppv.z, muparp.x, muparp.y, muparp.z, mupare, necm, tgen, tgptype, dk2gen, gen2vtx, dk2vtx
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, float, int, int, float, int, float, float, float, float, float, float, float, float, float, float, int, int, float, float, float, float, float, float, float, float, int, int, float, float, float> vals;
};

/// HDF5 encoding of \ref SRTrueMichelE
template<class... Tidx> class HDF5TrueMichelE
{
public:
  template<class... Cols> HDF5TrueMichelE(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRTrueMichelE& sr);

  // E, visE, time, mustop.E, mustop.px, mustop.py, mustop.pz, p.E, p.px, p.py, p.pz
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRNuonEResult
template<class... Tidx> class HDF5NuonEResult
{
public:
  template<class... Cols> HDF5NuonEResult(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRNuonEResult& sr);

  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> output;
  // rawgevslice, nuoneid, pi0id, nueccid, otherid, epi0nuoneid, epi0pi0id, noutput
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, float, unsigned int> vals;
};

/// HDF5 encoding of \ref SRSliceLID
template<class... Tidx> class HDF5SliceLID
{
public:
  template<class... Cols> HDF5SliceLID(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRSliceLID& sr);

  // ncid, numuid, nueid, nutauid, cosmicid
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRXnue
template<class... Tidx> class HDF5Xnue
{
public:
  template<class... Cols> HDF5Xnue(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRXnue& sr);

  // p1energy, p1Fmip, p2Fmip, emaxfrac6p, efrac10p, efracp2, efracp3, efracp4, efrac2sig, bdt
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, float, float, float, double> vals;
};

/// HDF5 encoding of \ref SRVeto
template<class... Tidx> class HDF5Veto
{
public:
  template<class... Cols> HDF5Veto(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRVeto& sr);

  // ncell, fwddist, bakdist, ratio, diry, angle, anglevar, anglevarold, passthru, passthruold, passangle, passanglefirstana, passnumicut, keep, keepnue
  hep_hpc::hdf5::Ntuple<Tidx..., int, float, float, float, float, float, float, float, unsigned short, unsigned short, unsigned short, unsigned short, unsigned short, unsigned short, unsigned short> vals;
};

/// HDF5 encoding of \ref SRContain
template<class... Tidx> class HDF5Contain
{
public:
  template<class... Cols> HDF5Contain(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRContain& sr);

  // numucontain, numucontainSA, missE, nplanestofront, nplanestoback, vtxdist, enddist, cosfwddist, cosfwdcell, cosfwdcellnd, cosfwdair, cosfwdsteel, cosbakdist, cosbakcell, cosbakcellnd, cosbakair, cosbaksteel, kalfwddist, kalfwdcell, kalfwdcellnd, kalfwdair, kalfwdsteel, kalbakdist, kalbakcell, kalbakcellnd, kalbakair, kalbaksteel, cosyposattrans, kalyposattrans, xmin2, ymin2, zmin2, xmax2, ymax2, zmax2, xmint, ymint, zmint, xmaxt, ymaxt, zmaxt
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned short, unsigned short, float, int, int, float, float, float, int, int, float, float, float, int, int, float, float, float, int, int, float, float, float, int, int, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRNCPi0BkgRej
template<class... Tidx> class HDF5NCPi0BkgRej
{
public:
  template<class... Cols> HDF5NCPi0BkgRej(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRNCPi0BkgRej& sr);

  // ncpidbdtg, ncpidbdtglt
  hep_hpc::hdf5::Ntuple<Tidx..., double, double> vals;
};

/// HDF5 encoding of \ref SRNCCosRej
template<class... Tidx> class HDF5NCCosRej
{
public:
  template<class... Cols> HDF5NCCosRej(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRNCCosRej& sr);

  // pngptp, cospidbdt, cospidbdtg
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float> vals;
};

/// HDF5 encoding of \ref SRNueCosRej
template<class... Tidx> class HDF5NueCosRej
{
public:
  template<class... Cols> HDF5NueCosRej(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRNueCosRej& sr);

  // hitsperplane, pngptp, partptp, photptp, photpxp, photpyp, starttop, startbottom, startfront, startback, startwest, starteast, stoptop, stopbottom, stopfront, stopback, stopwest, stopeast, distallpngtop, distallpngbottom, distallpngfront, distallpngback, distallpngwest, distallpngeast, cospidcontain, cospidcontainxy, cospidlight, cospidperibdt, cospidcorebdt, cosdang, vtxdoca, prongmaxx, prongmaxy, prongmaxz, prongminx, prongminy, prongminz, sparsenessasymm, hitsperplaneasymm, sparsenessasymmslice, hitsperplaneasymmslice, musliceidxbydist, muanglediffbydist, mutimediffbydist, muclosestapproachbydist, musliceidxbytime, muanglediffbytime, mutimediffbytime, muclosestapproachbytime
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, int, float, float, float, int, float, float, float> vals;
};

/// HDF5 encoding of \ref SRCosRej
template<class... Tidx> class HDF5CosRej
{
public:
  template<class... Cols> HDF5CosRej(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRCosRej& sr);

  // mindist, mincell, anglekal, anglecos, nkal3d, costhetatrue, kalthetatrue, pdgbest, numucontpid2020, numucontpid2019, numuunconttunedpid, scatt, fscattmax, fscattsum, fscattext, fscattsig, eratio, hadE, kfitspeed, cfitspeed, kdirscore, cdirscore, kscorediff, cscorediff, kalslope, kalchisq, kalchidiff, cosslope, coschisq, coschidiff
  hep_hpc::hdf5::Ntuple<Tidx..., float, int, float, float, int, float, float, int, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRRvp
template<class... Tidx> class HDF5Rvp
{
public:
  template<class... Cols> HDF5Rvp(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRRvp& sr);

  // pid, ncell, recoE, longtr, longtrfrac, mipfrac, miphits, epl20frac, efrac2plwin, efrac6plwin, efrac2sigrd, prongs3D, prongEbal3D, prongs2D, prongEbal2D, eiso3sig, rvp12
  hep_hpc::hdf5::Ntuple<Tidx..., float, int, float, float, float, float, float, float, float, float, float, int, float, int, float, float, float> vals;
};

/// HDF5 encoding of \ref SRPresel
template<class... Tidx> class HDF5Presel
{
public:
  template<class... Cols> HDF5Presel(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRPresel& sr);

  // passpre
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned short> vals;
};

/// HDF5 encoding of \ref SRLem
template<class... Tidx> class HDF5Lem
{
public:
  template<class... Cols> HDF5Lem(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRLem& sr);

  // pid, pidfit, pidexp, pidexpfit, meany, meanyfit, meanyexp, meanysig, meanysigexp, meanqfrac, meanqfracfit, meanqfracexp, meanqfracsig, meanqfracsigexp, meanqfracbkg, meanqfracbkgexp, energydiff, energydiffexp, enrichfrac, enrichfracexp, fannid, fannidenrich, chisig, chibkg, chisigexp, chibkgexp, avginvE, avgexpE, avgsigE, tmvabdtg, tmvabdt, tmvabdtd, tmvabdtmf, tmvamlp, dectree
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRELid
template<class... Tidx> class HDF5ELid
{
public:
  template<class... Cols> HDF5ELid(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRELid& sr);

  // ann, rnn, anne, annepi0, annecos
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRQepid
template<class... Tidx> class HDF5Qepid
{
public:
  template<class... Cols> HDF5Qepid(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRQepid& sr);

  // pdg, mode, ntrk, pid, offE, ediff, ediffz, dedx
  hep_hpc::hdf5::Ntuple<Tidx..., int, int, int, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRBpfId
template<class... Tidx> class HDF5BpfId
{
public:
  template<class... Cols> HDF5BpfId(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRBpfId& sr);

  // bestVtxIdx, bestPngIdx, bestBpfIdx, pdg, pid, chi2T, dEdXLL, hitRatio, momentum.x, momentum.y, momentum.z, energy, len
  hep_hpc::hdf5::Ntuple<Tidx..., int, int, int, int, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRMuonID
template<class... Tidx> class HDF5MuonID
{
public:
  template<class... Cols> HDF5MuonID(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRMuonID& sr);

  // pid
  hep_hpc::hdf5::Ntuple<Tidx..., float> vals;
};

/// HDF5 encoding of \ref SRRemid
template<class... Tidx> class HDF5Remid
{
public:
  template<class... Cols> HDF5Remid(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRRemid& sr);

  // pid, scatllh, dedxllh, len, measfrac, cont
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, int> vals;
};

/// HDF5 encoding of \ref SRMuId
template<class... Tidx> class HDF5MuId
{
public:
  template<class... Cols> HDF5MuId(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRMuId& sr);

  // pdg, pid, scatllh, dedxllh, len, measfrac, cont
  hep_hpc::hdf5::Ntuple<Tidx..., int, float, float, float, float, float, int> vals;
};

/// HDF5 encoding of \ref SREnergy
template<class... Tidx> class HDF5Energy
{
public:
  template<class... Cols> HDF5Energy(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SREnergy& sr);

  // E
  hep_hpc::hdf5::Ntuple<Tidx..., float> vals;
};

/// HDF5 encoding of \ref SRBPFEnergy
template<class... Tidx> class HDF5BPFEnergy
{
public:
  template<class... Cols> HDF5BPFEnergy(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRBPFEnergy& sr);

  // E1, Eres1, E2, Eres2, E3, Eres3, EventID, PMuon, DirZMuon, N3DProngs, EFuzzyK3D, ERemain, SumPE
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRTrueNumuEnergy
template<class... Tidx> class HDF5TrueNumuEnergy
{
public:
  template<class... Cols> HDF5TrueNumuEnergy(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRTrueNumuEnergy& sr);

  // truemuonE, truemuoncatcherE, truegoodmuon
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, unsigned short> vals;
};

/// HDF5 encoding of \ref SRHadClust
template<class... Tidx> class HDF5HadClust
{
public:
  template<class... Cols> HDF5HadClust(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRHadClust& sr);

  // nhit, ncalhit, nmiphit, ncontplanes, firstplane, lastplane, firstcell, lastcell, ncellsfromedge, calE, boxmin.x, boxmin.y, boxmin.z, boxmax.x, boxmax.y, boxmax.z, meanpos.x, meanpos.y, meanpos.z
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRVertexDT
template<class... Tidx> class HDF5VertexDT
{
public:
  template<class... Cols> HDF5VertexDT(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRVertexDT& sr);

  // time, vtx.x, vtx.y, vtx.z
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRVertex
template<class... Tidx> class HDF5Vertex
{
public:
  template<class... Cols> HDF5Vertex(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRVertex& sr);

  // time, vtx.x, vtx.y, vtx.z
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRProngXSec
template<class... Tidx> class HDF5ProngXSec
{
public:
  template<class... Cols> HDF5ProngXSec(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRProngXSec& sr);

  // ccpi0bpi, ccpi0phll, ccpi0ismu
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, unsigned short> vals;
};

/// HDF5 encoding of \ref SRRegCVNResult
template<class... Tidx> class HDF5RegCVNResult
{
public:
  template<class... Cols> HDF5RegCVNResult(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRRegCVNResult& sr);

  // prongE
  hep_hpc::hdf5::Ntuple<Tidx..., float> vals;
};

/// HDF5 encoding of \ref SRCVNResult
template<class... Tidx> class HDF5CVNResult
{
public:
  template<class... Cols> HDF5CVNResult(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRCVNResult& sr);

  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> output;
  // numuid, nueid, nutauid, ncid, cosmicid, maxval, argmax, noutput
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, unsigned int, unsigned int> vals;
};

/// HDF5 encoding of \ref SRSLid
template<class... Tidx> class HDF5SLid
{
public:
  template<class... Cols> HDF5SLid(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRSLid& sr);

  // ann, anne, annepi0, annecos, ismuon, eglll, egllt, emulll, emullt, epi0lll, epi0llt, eplll, epllt, enlll, enllt, epilll, epillt, vtxgev, pi0mass, shwEFrac, gap, costheta, invglll, elll, ellt, mulll, mullt, dedx0, dedx1, dedx2, dedx3, dedx4, dedx5, dedxp0c0, dedxp0c1, dedxp1c0, dedxp1c1, dedxp2c0, dedxp2c1, dedxp3c0, dedxp3c1, dedxp4c0, dedxp4c1, dedxp5c0, dedxp5c1
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, int, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRSLidEnergy
template<class... Tidx> class HDF5SLidEnergy
{
public:
  template<class... Cols> HDF5SLidEnergy(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRSLidEnergy& sr);

  // E, depE, shwE, hadE
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRSPid
template<class... Tidx> class HDF5SPid
{
public:
  template<class... Cols> HDF5SPid(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRSPid& sr);

  // annepi0, annepi0el, elll, ellt, glll, gllt, mulll, mullt, pi0lll, pi0llt, plll, pllt, nlll, nllt, pilll, pillt, dedx0, dedx1, dedx2, dedx3, dedx4, dedx5
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRProngTrainingData
template<class... Tidx> class HDF5ProngTrainingData
{
public:
  template<class... Cols> HDF5ProngTrainingData(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRProngTrainingData& sr);

  // label3d, labelx, labely, isprimary, purity3d, purityx, purityy, rece, ncellx, ncelly, vertx, verty, vertz, plength, pangle, pgap
  hep_hpc::hdf5::Ntuple<Tidx..., int, int, int, unsigned short, double, double, double, double, unsigned int, unsigned int, double, double, double, double, double, double> vals;
};

/// HDF5 encoding of \ref SRPixelMap
template<class... Tidx> class HDF5PixelMap
{
public:
  template<class... Cols> HDF5PixelMap(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRPixelMap& sr);

  // nplanes, ncells, nchan, firstplane, lastplane, firstcellx, lastcellx, firstcelly, lastcelly, hitfracx, hitfracy, cvnmap
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, float, float, unsigned char> vals;
};

/// HDF5 encoding of \ref SRCVNParticleResult
template<class... Tidx> class HDF5CVNParticleResult
{
public:
  template<class... Cols> HDF5CVNParticleResult(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRCVNParticleResult& sr);

  // muonid, electronid, protonid, neutronid, pionid, pizeroid, photonid, otherid, emid, hadronid, maxval, pdgmax
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, float, float, float, float, float, unsigned int> vals;
};

/// HDF5 encoding of \ref SRCVNNeutronDaughterResult
template<class... Tidx> class HDF5CVNNeutronDaughterResult
{
public:
  template<class... Cols> HDF5CVNNeutronDaughterResult(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRCVNNeutronDaughterResult& sr);

  // protonid, photonid, otherid
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float> vals;
};

/// HDF5 encoding of \ref SRParticleTruth
template<class... Tidx> class HDF5ParticleTruth
{
public:
  template<class... Cols> HDF5ParticleTruth(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRParticleTruth& sr);

  std::unique_ptr<Wrapped<int, Tidx..., unsigned int>> motherlist;
  std::unique_ptr<Wrapped<int, Tidx..., unsigned int>> daughterlist;
  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> daughterVisEnergies;
  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> primNeutronE;
  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> primNeutronProcessE;
  // pdg, motherpdg, eff, pur, p.E, p.px, p.py, p.pz, motherp.E, motherp.px, motherp.py, motherp.pz, trkID, start.x, start.y, start.z, visE, visEinslc, daughterVisE, daughterVisEinslc, visEBirks, visEinslcBirks, daughterVisEBirks, daughterVisEinslcBirks, processMax, processParticleE
  hep_hpc::hdf5::Ntuple<Tidx..., int, int, float, float, float, float, float, float, float, float, float, float, int, float, float, float, float, float, float, float, float, float, float, float, unsigned short, float> vals;
};

/// HDF5 encoding of \ref SRSlice
template<class... Tidx> class HDF5Slice
{
public:
  template<class... Cols> HDF5Slice(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRSlice& sr);

  // nhit, ncalhit, nmiphit, ncontplanes, firstplane, lastplane, firstcell, lastcell, ncellsfromedge, nnonnoise, nnoisehit, fracnoiseE, fracnoisePE, calE, starttime, endtime, meantime, tsd, closestslicetime, closestslicenhit, closestslicecalE, boxmin.x, boxmin.y, boxmin.z, boxmax.x, boxmax.y, boxmax.z, meanpos.x, meanpos.y, meanpos.z, closestsliceminfromtop, closestsliceminfrombottom, closestsliceminfromfront, closestsliceminfromback, closestsliceminfromeast, closestsliceminfromwest, closestslicemindist
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, float, float, float, float, float, float, float, float, unsigned int, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRCosmicCVN
template<class... Tidx> class HDF5CosmicCVN
{
public:
  template<class... Cols> HDF5CosmicCVN(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRCosmicCVN& sr);

  // nHits, timeWinMin, timeWinMax, numuVal, nueVal, nutauVal, ncVal, cosmicVal, passSel
  hep_hpc::hdf5::Ntuple<Tidx..., int, float, float, float, float, float, float, float, unsigned short> vals;
};

/// HDF5 encoding of \ref SRHeader
template<class... Tidx> class HDF5Header
{
public:
  template<class... Cols> HDF5Header(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRHeader& sr);

  // batch, ismc, det, blind, filt, dibfirst, diblast, dibmask, maskstatus, year, month, day, doy, hour, minute, second, unixtime, subevtstarttime, subevtendtime, subevtmeantime, nbadchan, ntotchan, gain, finetiming
  hep_hpc::hdf5::Ntuple<Tidx..., int, unsigned short, unsigned short, unsigned short, unsigned short, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, float, float, float, float, unsigned int, unsigned int, short unsigned int, unsigned short> vals;
};

/// HDF5 encoding of \ref SRTrainingBranch
template<class... Tidx> class HDF5TrainingBranch
{
public:
  template<class... Cols> HDF5TrainingBranch(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRTrainingBranch& sr);

  std::unique_ptr<HDF5CVNFeatures<Tidx...>> cvnfeatures;
  std::unique_ptr<HDF5PixelObjMap<Tidx..., unsigned int>> cvnmaps;
  std::unique_ptr<HDF5SliceMap<Tidx..., unsigned int>> slicemaps;
  std::unique_ptr<HDF5TrainingData<Tidx..., unsigned int>> trainingdata;
  // cvnmapsfilled
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned short> vals;
};

/// HDF5 encoding of \ref SRParentBranch
template<class... Tidx> class HDF5ParentBranch
{
public:
  template<class... Cols> HDF5ParentBranch(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRParentBranch& sr);

  std::unique_ptr<HDF5MRCCParent<Tidx...>> mrccpar;
};

/// HDF5 encoding of \ref SRNueSandbox
template<class... Tidx> class HDF5NueSandbox
{
public:
  template<class... Cols> HDF5NueSandbox(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRNueSandbox& sr);

  std::unique_ptr<HDF5JMShower<Tidx..., unsigned int>> jm;
  std::unique_ptr<HDF5JMEid<Tidx...>> jmid;
  // infid, slicemeanx, slicemeany, slicemeanz, npi0, npip, npim, pi0E, pipE, pimE, phot0E, phot1E, opencos, conv0, conv1, mincellcosmic, mincellwallcosmic, anglecosmic, nplanesfilled, nxplanes, nyplanes, ncellrow, ncellsum, mincellavg, mincellkalman, nmiphits, mipmin.x, mipmin.y, mipmin.z, ecfNu, mipmax.x, mipmax.y, mipmax.z, evtncell, evtsumcostheta, evtsump, evtsumpt, evtsump0, evtsumpt0, evtetot, evtminx, evtminy, evtminz, evtmaxx, evtmaxy, evtmaxz, evtgaptns, evtncelltoedge, sh1energy, sh1exclenergy, sh1totalL, sh1start.x, sh1start.y, sh1start.z, sh1stop.x, sh1stop.y, sh1stop.z, sh1dir.x, sh1dir.y, sh1dir.z, sh1vtxdoca, sh1gap, sh1nplane, sh1xnplane, sh1ynplane, sh1ncell, sh1xncell, sh1yncell, sh1pid, sh1ncelltoedge, sh1sh2dang, sh2energy, sh2exclenergy, sh2totalL, sh2start.x, sh2start.y, sh2start.z, sh2stop.x, sh2stop.y, sh2stop.z, sh2dir.x, sh2dir.y, sh2dir.z, sh2vtxdoca, sh2gap, sh2nplane, sh2xnplane, sh2ynplane, sh2ncell, sh2xncell, sh2yncell, sh2pid, sh2ncelltoedge, elll, sh1d2edge, eedge2cell, eedge5cell, eedge10cell, njm, vtx.x, vtx.y, vtx.z, time, E, depE, shwE, fracangchanges, fracangchangesloose, fracmodalhits, fracnoncontig, fracnoncontigloose, maxgap, maxhitsx, maxhitsy, dedxpng1, dedxpng2
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned short, float, float, float, int, int, int, float, float, float, float, float, float, float, float, float, float, float, int, unsigned int, unsigned int, int, int, float, float, int, float, float, float, float, float, float, float, unsigned int, float, float, float, float, float, float, float, float, float, float, float, float, float, int, float, float, float, float, float, float, float, float, float, float, float, float, float, float, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, int, int, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, int, int, float, float, float, float, float, size_t, float, float, float, float, float, float, float, float, float, float, float, float, int, int, int, float, float> vals;
};

/// HDF5 encoding of \ref SRMCReweight
template<class... Tidx> class HDF5MCReweight
{
public:
  template<class... Cols> HDF5MCReweight(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRMCReweight& sr);

  std::unique_ptr<HDF5GenieWeights<Tidx..., unsigned int>> genie;
  std::unique_ptr<HDF5FluxWeights<Tidx...>> ppfx;
  std::unique_ptr<HDF5Geant4Weights<Tidx...>> geant4;
};

/// HDF5 encoding of \ref SRCosmic
template<class... Tidx> class HDF5Cosmic
{
public:
  template<class... Cols> HDF5Cosmic(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRCosmic& sr);

  std::unique_ptr<HDF5TrueMichelE<Tidx..., unsigned int>> michel;
  // pdg, E, visE, visEinslc, eff, pur, nhitslc, nhittot, time, p.E, p.px, p.py, p.pz, penter.E, penter.px, penter.py, penter.pz, vtx.x, vtx.y, vtx.z, azimuth, zenith, enter.x, enter.y, enter.z, exit.x, exit.y, exit.z, stop.x, stop.y, stop.z
  hep_hpc::hdf5::Ntuple<Tidx..., short int, float, float, float, float, float, unsigned int, unsigned int, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRTruth
template<class... Tidx> class HDF5Truth
{
public:
  template<class... Cols> HDF5Truth(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRTruth& sr);

  std::unique_ptr<HDF5TrueMichelE<Tidx..., unsigned int>> michel;
  // pdg, E, visE, visEinslc, eff, pur, nhitslc, nhittot, time, p.E, p.px, p.py, p.pz, vtx.x, vtx.y, vtx.z
  hep_hpc::hdf5::Ntuple<Tidx..., short int, float, float, float, float, float, unsigned int, unsigned int, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRIDBranch
template<class... Tidx> class HDF5IDBranch
{
public:
  template<class... Cols> HDF5IDBranch(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRIDBranch& sr);

  std::unique_ptr<HDF5Remid<Tidx...>> remid;
  std::unique_ptr<HDF5MuonID<Tidx...>> muonid;
  std::unique_ptr<HDF5BpfId<Tidx...>> bpfid;
  std::unique_ptr<HDF5ELid<Tidx...>> lid;
  std::unique_ptr<HDF5Lem<Tidx...>> lem;
  std::unique_ptr<HDF5Presel<Tidx...>> nuepre;
  std::unique_ptr<HDF5Presel<Tidx...>> rockpre;
  std::unique_ptr<HDF5Rvp<Tidx...>> rvp;
  std::unique_ptr<HDF5CosRej<Tidx...>> cosrej;
  std::unique_ptr<HDF5NueCosRej<Tidx...>> nuecosrej;
  std::unique_ptr<HDF5NCCosRej<Tidx...>> nccosrej;
  std::unique_ptr<HDF5NCPi0BkgRej<Tidx...>> ncpi0bkgrej;
  std::unique_ptr<HDF5Contain<Tidx...>> contain;
  std::unique_ptr<HDF5Veto<Tidx...>> veto;
  std::unique_ptr<HDF5CVNResult<Tidx...>> cvn;
  std::unique_ptr<HDF5CVNResult<Tidx...>> cvnloosepreselptp;
  std::unique_ptr<HDF5CVNResult<Tidx...>> cvnoldpresel;
  std::unique_ptr<HDF5CVNResult<Tidx...>> cvnnocosmics;
  std::unique_ptr<HDF5Xnue<Tidx...>> xnuepid;
  std::unique_ptr<HDF5SliceLID<Tidx...>> slicelid;
  std::unique_ptr<HDF5NuonEResult<Tidx...>> nuone;
  std::unique_ptr<HDF5CVNResult<Tidx...>> cvnloosepreselptp_opphorn;
  std::unique_ptr<HDF5CVNResult<Tidx...>> cvnoldpresel_opphorn;
  std::unique_ptr<HDF5CVNResult<Tidx...>> cvnnocosmics_opphorn;
  std::unique_ptr<HDF5SliceLID<Tidx...>> slicelid_opphorn;
  std::unique_ptr<HDF5NuonEResult<Tidx...>> nuone_opphorn;
  // wsid
  hep_hpc::hdf5::Ntuple<Tidx..., double> vals;
};

/// HDF5 encoding of \ref SRNumuEnergy
template<class... Tidx> class HDF5NumuEnergy
{
public:
  template<class... Cols> HDF5NumuEnergy(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRNumuEnergy& sr);

  std::unique_ptr<HDF5HadClust<Tidx...>> hadclust;
  std::unique_ptr<HDF5TrueNumuEnergy<Tidx...>> mc;
  std::unique_ptr<HDF5BPFEnergy<Tidx...>> bpfenergy;
  // E, calccE, trkqeE, trknonqeE, trkccE, shiftedtrkccE, angleE, angleerror, recomuonE, ucrecomuonE1trk, ucrecomuonE, recotrkcchadE, hadcalE, hadtrkE, ndtrklenact, ndtrklencat, ndtrkcalactE, ndtrkcaltranE, ndtrkcalcatE, ndhadcalactE, ndhadcaltranE, ndhadcalcatE, ndhadtrkactE, ndhadtrktranE, ndhadtrkcatE, ndtrktranx, ndtrktrany, lstmmuon, lstmnu, lstmmuon_opphorn, lstmnu_opphorn, regcvnhadE, regcvnhadE_opphorn
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRNueEnergy
template<class... Tidx> class HDF5NueEnergy
{
public:
  template<class... Cols> HDF5NueEnergy(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRNueEnergy& sr);

  std::unique_ptr<HDF5SLidEnergy<Tidx...>> lid;
  // rawgevshw, rawgevhad, rawgevslice, regcvnEvtE, regcvnEvtE_opphorn
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRSlcME
template<class... Tidx> class HDF5SlcME
{
public:
  template<class... Cols> HDF5SlcME(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRSlcME& sr);

  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truth;
  // mid, nhitx, nhity, calE, deltat, adc, disttoslc, meanpos.x, meanpos.y, meanpos.z
  hep_hpc::hdf5::Ntuple<Tidx..., float, short unsigned int, short unsigned int, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRShower
template<class... Tidx> class HDF5Shower
{
public:
  template<class... Cols> HDF5Shower(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRShower& sr);

  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truth;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthXView;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthYView;
  // nhit, nhitx, nhity, nplane, maxplanecont, maxplanegap, calE, start.x, start.y, start.z, dir.x, dir.y, dir.z, len, view, width, nplanex, nplaney, gap, stop.x, stop.y, stop.z
  hep_hpc::hdf5::Ntuple<Tidx..., short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, float, float, float, float, float, float, float, float, unsigned short, float, short unsigned int, short unsigned int, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRTrkME
template<class... Tidx> class HDF5TrkME
{
public:
  template<class... Cols> HDF5TrkME(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRTrkME& sr);

  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truth;
  // mid, nhitx, nhity, calE, deltat, adc, disttotrack, meanpos.x, meanpos.y, meanpos.z
  hep_hpc::hdf5::Ntuple<Tidx..., float, short unsigned int, short unsigned int, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRProng
template<class... Tidx> class HDF5Prong
{
public:
  template<class... Cols> HDF5Prong(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRProng& sr);

  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truth;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthXView;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthYView;
  std::unique_ptr<HDF5CVNNeutronDaughterResult<Tidx...>> cvnneutron;
  std::unique_ptr<HDF5CVNParticleResult<Tidx...>> cvnpart;
  std::unique_ptr<HDF5CVNParticleResult<Tidx...>> cvnpart_opphorn;
  std::unique_ptr<HDF5CVNParticleResult<Tidx...>> spprongcvnpart5label;
  std::unique_ptr<HDF5CVNParticleResult<Tidx...>> spprongcvnpartnumuccemid;
  std::unique_ptr<HDF5PixelMap<Tidx..., unsigned int>> cvnmaps;
  std::unique_ptr<HDF5ProngTrainingData<Tidx..., unsigned int>> prongtrainingdata;
  // nhit, nhitx, nhity, nplane, maxplanecont, maxplanegap, calE, weightedCalE, start.x, start.y, start.z, dir.x, dir.y, dir.z, pngminx, pngmaxx, pngminy, pngmaxy, len, view, meantime, maxtime, mintime, meantimeRes
  hep_hpc::hdf5::Ntuple<Tidx..., short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, float, float, float, float, float, float, float, float, float, float, float, float, float, unsigned short, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRSpill
template<class... Tidx> class HDF5Spill
{
public:
  template<class... Cols> HDF5Spill(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRSpill& sr);

  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> intx;
  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> inty;
  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> bposx;
  std::unique_ptr<Wrapped<float, Tidx..., unsigned int>> bposy;
  std::unique_ptr<HDF5CosmicCVN<Tidx..., unsigned int>> cosmiccvn;
  // det, ismc, isgoodspill, spilltimesec, spilltimensec, gpsspilltimesec, gpsspilltimensec, deltaspilltimensec, spillpot, livetime, hornI, isFHC, is0HC, isRHC, posx, posy, widthx, widthy, dibfirst, diblast, dibmask, maskstatus, nmissingdcms, fracdcm3hits, nouttimehits, nnoisyapds, nmissingdcmslg, nbaddcmslg, dcmedgematchfrac, nmicroslices, ndcms, eventincomplete, ndiblocks, emptydatablock, nmicroblocks, nemptymicroslice, ndroppedmicroblocks, ndatablockmissingdata, nmicroslicedatanotpresent, nnanoslices, nanoslicedatanotpresent, nanoslicenolinkstatus, nanoslicebufferempty, nanoslicebufferfull, nanoslicecommerror, nanoslicepacketerror, nanosliceoverflowerror, nanosliceadcerror, trigger, ncosmiccvn
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned short, unsigned short, unsigned short, long unsigned int, long unsigned int, long unsigned int, long unsigned int, long long int, float, float, float, unsigned short, unsigned short, unsigned short, float, float, float, float, short unsigned int, short unsigned int, short unsigned int, short unsigned int, unsigned int, float, unsigned int, unsigned int, unsigned int, unsigned int, float, unsigned int, int, unsigned short, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, unsigned char, short int> vals;
};

/// HDF5 encoding of \ref SRSandbox
template<class... Tidx> class HDF5Sandbox
{
public:
  template<class... Cols> HDF5Sandbox(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRSandbox& sr);

  std::unique_ptr<HDF5NueSandbox<Tidx...>> nue;
  std::unique_ptr<HDF5NumuSandbox<Tidx...>> numu;
  std::unique_ptr<HDF5NusSandbox<Tidx...>> nus;
  std::unique_ptr<HDF5NDSandbox<Tidx...>> nd;
};

/// HDF5 encoding of \ref SRNeutrino
template<class... Tidx> class HDF5Neutrino
{
public:
  template<class... Cols> HDF5Neutrino(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRNeutrino& sr);

  std::unique_ptr<HDF5TrueMichelE<Tidx..., unsigned int>> michel;
  std::unique_ptr<HDF5TrueParticle<Tidx..., unsigned int>> prim;
  std::unique_ptr<HDF5NuGenParticle<Tidx..., unsigned int>> prefsi;
  std::unique_ptr<Wrapped<unsigned int, Tidx..., unsigned int>> genVersion;
  std::unique_ptr<HDF5MCReweight<Tidx...>> rwgt;
  std::unique_ptr<HDF5Beam<Tidx...>> beam;
  // pdg, E, visE, visEinslc, visENeutron, visEinslcNeutron, visEBirks, visEinslcBirks, visENeutronBirks, visEinslcNeutronBirks, L, isvtxcont, eff, pur, nhitslc, nhittot, time, p.E, p.px, p.py, p.pz, vtx.x, vtx.y, vtx.z, pdgorig, hitnuc, hitnucp.E, hitnucp.px, hitnucp.py, hitnucp.pz, woscdumb, mode, iscc, inttype, npiplus, npiminus, npizero, nproton, nneutron, ischarm, isseaquark, resnum, xsec, tgtZ, tgtA, q2, x, y, W2, genweight, generator, isFHC, is0HC, isRHC, det
  hep_hpc::hdf5::Ntuple<Tidx..., short int, float, float, float, float, float, float, float, float, float, float, unsigned short, float, float, unsigned int, unsigned int, float, float, float, float, float, float, float, float, short int, int, float, float, float, float, float, int, unsigned short, int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned short, unsigned short, int, float, int, int, float, float, float, float, float, unsigned short, unsigned short, unsigned short, unsigned short, unsigned short> vals;
};

/// HDF5 encoding of \ref SREnergyBranch
template<class... Tidx> class HDF5EnergyBranch
{
public:
  template<class... Cols> HDF5EnergyBranch(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SREnergyBranch& sr);

  std::unique_ptr<HDF5NueEnergy<Tidx...>> nue;
  std::unique_ptr<HDF5NumuEnergy<Tidx...>> numu;
};

/// HDF5 encoding of \ref SRMichelE
template<class... Tidx> class HDF5MichelE
{
public:
  template<class... Cols> HDF5MichelE(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRMichelE& sr);

  std::unique_ptr<HDF5TrkME<Tidx..., unsigned int>> trkkalman;
  std::unique_ptr<HDF5TrkME<Tidx..., unsigned int>> trkdiscrete;
  std::unique_ptr<HDF5TrkME<Tidx..., unsigned int>> trkcosmic;
  std::unique_ptr<HDF5TrkME<Tidx..., unsigned int>> trkbpf;
  std::unique_ptr<HDF5SlcME<Tidx..., unsigned int>> slc;
  // nkalman, ndiscrete, ncosmic, nbpf, nslc
  hep_hpc::hdf5::Ntuple<Tidx..., size_t, size_t, size_t, size_t, size_t> vals;
};

/// HDF5 encoding of \ref SRShowerBranch
template<class... Tidx> class HDF5ShowerBranch
{
public:
  template<class... Cols> HDF5ShowerBranch(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRShowerBranch& sr);

  std::unique_ptr<HDF5Shower<Tidx..., unsigned int>> shwlid;
  // nshwlid
  hep_hpc::hdf5::Ntuple<Tidx..., size_t> vals;
};

/// HDF5 encoding of \ref SRShowerLID
template<class... Tidx> class HDF5ShowerLID
{
public:
  template<class... Cols> HDF5ShowerLID(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRShowerLID& sr);

  std::unique_ptr<HDF5SLidEnergy<Tidx...>> lidE;
  std::unique_ptr<HDF5SLid<Tidx...>> lid;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truth;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthXView;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthYView;
  // shwE, vtxE, nhit, nhitx, nhity, nplane, maxplanecont, maxplanegap, calE, start.x, start.y, start.z, dir.x, dir.y, dir.z, len, view, width, nplanex, nplaney, gap, stop.x, stop.y, stop.z
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, float, float, float, float, float, float, float, float, unsigned short, float, short unsigned int, short unsigned int, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRTruthBranch
template<class... Tidx> class HDF5TruthBranch
{
public:
  template<class... Cols> HDF5TruthBranch(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRTruthBranch& sr);

  std::unique_ptr<HDF5Neutrino<Tidx..., unsigned int>> nu;
  std::unique_ptr<HDF5Cosmic<Tidx..., unsigned int>> cosmic;
  std::unique_ptr<HDF5Neutrino<Tidx..., unsigned int>> allnus;
  std::unique_ptr<HDF5Cosmic<Tidx..., unsigned int>> allcosmics;
  std::unique_ptr<HDF5GlobalTruth<Tidx...>> global;
  // faveidxeff, faveidxenergy, faveidxpur, faveidxeffpur, faveidxeffthenpur, nnu, ncosmic, nallnus, nallcosmics
  hep_hpc::hdf5::Ntuple<Tidx..., short int, short int, short int, short int, short int, short int, short int, short int, short int> vals;
};

/// HDF5 encoding of \ref SRMRProperties
template<class... Tidx> class HDF5MRProperties
{
public:
  template<class... Cols> HDF5MRProperties(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRMRProperties& sr);

  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truth;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthXView;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthYView;
  std::unique_ptr<HDF5ShowerLID<Tidx...>> lid;
  std::unique_ptr<HDF5CVNResult<Tidx...>> cvnloosepreselptp;
  std::unique_ptr<HDF5CVNResult<Tidx...>> cvnoldpresel;
  std::unique_ptr<HDF5CVNResult<Tidx...>> cvnnocosmics;
  // nhit, nhitx, nhity, nplane, maxplanecont, maxplanegap, calE, view, nplanex, nplaney, minplane, maxplane, gap, isDiF, isShwDiF
  hep_hpc::hdf5::Ntuple<Tidx..., short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, float, unsigned short, short unsigned int, short unsigned int, short unsigned int, short unsigned int, float, unsigned short, unsigned short> vals;
};

/// HDF5 encoding of \ref SRTrack
template<class... Tidx> class HDF5Track
{
public:
  template<class... Cols> HDF5Track(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRTrack& sr);

  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truth;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthXView;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthYView;
  std::unique_ptr<HDF5TrkME<Tidx..., unsigned int>> me;
  std::unique_ptr<HDF5MRProperties<Tidx..., unsigned int>> mrdif;
  std::unique_ptr<HDF5MRProperties<Tidx..., unsigned int>> mrbrem;
  // nhit, nhitx, nhity, nplane, maxplanecont, maxplanegap, nplanegap, calE, start.x, start.y, start.z, dir.x, dir.y, dir.z, pngminx, pngmaxx, pngminy, pngmaxy, len, view, lenE, overlapE, stop.x, stop.y, stop.z, stopdir.x, stopdir.y, stopdir.z, trkfwdcell, trkfwdcellnd, trkbakcell, trkbakcellnd, leninact, lenincat, trkyposattrans, vtxdist, enddist, trkfwddist, trkfwdair, trkfwdsteel, trkbakdist, trkbakair, trkbaksteel, avedEdxlast10cm, avedEdxlast20cm, avedEdxlast30cm, avedEdxlast40cm, meantime, maxtime, mintime, meantimeRes
  hep_hpc::hdf5::Ntuple<Tidx..., short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, float, float, float, float, float, float, float, float, float, float, float, float, unsigned short, float, float, float, float, float, float, float, float, int, int, int, int, double, double, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRBpfTrack
template<class... Tidx> class HDF5BpfTrack
{
public:
  template<class... Cols> HDF5BpfTrack(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRBpfTrack& sr);

  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truth;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthXView;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthYView;
  std::unique_ptr<HDF5TrkME<Tidx..., unsigned int>> me;
  std::unique_ptr<HDF5MRProperties<Tidx..., unsigned int>> mrdif;
  std::unique_ptr<HDF5MRProperties<Tidx..., unsigned int>> mrbrem;
  // IsValid, pdg, pid, chi2T, chi2Hit, chi2Scat, dEdXLL, hitRatio, momentum.x, momentum.y, momentum.z, energy, scatt15, scatt30, dedx15, dedx30, activity15, activity30, activity45, prox15, prox30, mvapiE, nhit, nhitx, nhity, nplane, maxplanecont, maxplanegap, nplanegap, calE, start.x, start.y, start.z, dir.x, dir.y, dir.z, pngminx, pngmaxx, pngminy, pngmaxy, len, view, lenE, overlapE, stop.x, stop.y, stop.z, stopdir.x, stopdir.y, stopdir.z, trkfwdcell, trkfwdcellnd, trkbakcell, trkbakcellnd, leninact, lenincat, trkyposattrans, vtxdist, enddist, trkfwddist, trkfwdair, trkfwdsteel, trkbakdist, trkbakair, trkbaksteel, avedEdxlast10cm, avedEdxlast20cm, avedEdxlast30cm, avedEdxlast40cm, meantime, maxtime, mintime, meantimeRes
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned short, int, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, float, float, float, float, float, float, float, float, float, float, float, float, unsigned short, float, float, float, float, float, float, float, float, int, int, int, int, double, double, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRTrackBase
template<class... Tidx> class HDF5TrackBase
{
public:
  template<class... Cols> HDF5TrackBase(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRTrackBase& sr);

  std::unique_ptr<HDF5Track<Tidx..., unsigned int>> tracks;
  // ntracks
  hep_hpc::hdf5::Ntuple<Tidx..., size_t> vals;
};

/// HDF5 encoding of \ref SRKalmanTrack
template<class... Tidx> class HDF5KalmanTrack
{
public:
  template<class... Cols> HDF5KalmanTrack(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRKalmanTrack& sr);

  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truth;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthXView;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthYView;
  std::unique_ptr<HDF5TrkME<Tidx..., unsigned int>> me;
  std::unique_ptr<HDF5MRProperties<Tidx..., unsigned int>> mrdif;
  std::unique_ptr<HDF5MRProperties<Tidx..., unsigned int>> mrbrem;
  // remavededx, rempid, muonid, scatllh, dedxllh, measfrac, remcont, scatt15, scatt30, dedx15, dedx30, activity15, activity30, activity45, prox15, prox30, mvapiE, nhit, nhitx, nhity, nplane, maxplanecont, maxplanegap, nplanegap, calE, start.x, start.y, start.z, dir.x, dir.y, dir.z, pngminx, pngmaxx, pngminy, pngmaxy, len, view, lenE, overlapE, stop.x, stop.y, stop.z, stopdir.x, stopdir.y, stopdir.z, trkfwdcell, trkfwdcellnd, trkbakcell, trkbakcellnd, leninact, lenincat, trkyposattrans, vtxdist, enddist, trkfwddist, trkfwdair, trkfwdsteel, trkbakdist, trkbakair, trkbaksteel, avedEdxlast10cm, avedEdxlast20cm, avedEdxlast30cm, avedEdxlast40cm, meantime, maxtime, mintime, meantimeRes
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, int, float, float, float, float, float, float, float, float, float, float, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, float, float, float, float, float, float, float, float, float, float, float, float, unsigned short, float, float, float, float, float, float, float, float, int, int, int, int, double, double, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRBpf
template<class... Tidx> class HDF5Bpf
{
public:
  template<class... Cols> HDF5Bpf(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRBpf& sr);

  std::unique_ptr<HDF5BpfTrack<Tidx...>> muon;
  std::unique_ptr<HDF5BpfTrack<Tidx...>> pion;
  std::unique_ptr<HDF5BpfTrack<Tidx...>> proton;
};

/// HDF5 encoding of \ref SRKalman
template<class... Tidx> class HDF5Kalman
{
public:
  template<class... Cols> HDF5Kalman(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRKalman& sr);

  std::unique_ptr<HDF5KalmanTrack<Tidx..., unsigned int>> tracks;
  std::unique_ptr<HDF5Track<Tidx..., unsigned int>> tracks2d;
  // ntracks, ntracks2d, idxremid, idxmuonid, idxlongest
  hep_hpc::hdf5::Ntuple<Tidx..., size_t, size_t, unsigned int, unsigned int, unsigned int> vals;
};

/// HDF5 encoding of \ref SRFuzzyKProng
template<class... Tidx> class HDF5FuzzyKProng
{
public:
  template<class... Cols> HDF5FuzzyKProng(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRFuzzyKProng& sr);

  std::unique_ptr<HDF5ShowerLID<Tidx...>> shwlid;
  std::unique_ptr<HDF5Bpf<Tidx...>> bpf;
  std::unique_ptr<HDF5RegCVNResult<Tidx...>> regcvn;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truth;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthXView;
  std::unique_ptr<HDF5ParticleTruth<Tidx...>> truthYView;
  std::unique_ptr<HDF5CVNNeutronDaughterResult<Tidx...>> cvnneutron;
  std::unique_ptr<HDF5CVNParticleResult<Tidx...>> cvnpart;
  std::unique_ptr<HDF5CVNParticleResult<Tidx...>> cvnpart_opphorn;
  std::unique_ptr<HDF5CVNParticleResult<Tidx...>> spprongcvnpart5label;
  std::unique_ptr<HDF5CVNParticleResult<Tidx...>> spprongcvnpartnumuccemid;
  std::unique_ptr<HDF5PixelMap<Tidx..., unsigned int>> cvnmaps;
  std::unique_ptr<HDF5ProngTrainingData<Tidx..., unsigned int>> prongtrainingdata;
  // dedx15, dedx30, activity15, activity30, activity45, prox15, prox30, mvapiE, nhit, nhitx, nhity, nplane, maxplanecont, maxplanegap, calE, weightedCalE, start.x, start.y, start.z, dir.x, dir.y, dir.z, pngminx, pngmaxx, pngminy, pngmaxy, len, view, meantime, maxtime, mintime, meantimeRes
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, float, float, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, short unsigned int, float, float, float, float, float, float, float, float, float, float, float, float, float, unsigned short, float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRTrackBranch
template<class... Tidx> class HDF5TrackBranch
{
public:
  template<class... Cols> HDF5TrackBranch(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRTrackBranch& sr);

  std::unique_ptr<HDF5Kalman<Tidx...>> kalman;
  std::unique_ptr<HDF5TrackBase<Tidx...>> discrete;
  std::unique_ptr<HDF5TrackBase<Tidx...>> cosmic;
  std::unique_ptr<HDF5TrackBase<Tidx...>> window;
};

/// HDF5 encoding of \ref SRFuzzyK
template<class... Tidx> class HDF5FuzzyK
{
public:
  template<class... Cols> HDF5FuzzyK(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRFuzzyK& sr);

  std::unique_ptr<HDF5FuzzyKProng<Tidx..., unsigned int>> png;
  std::unique_ptr<HDF5Prong<Tidx..., unsigned int>> png2d;
  // longestidx, nshwlid, npng, npng2d, ntot, orphCalE
  hep_hpc::hdf5::Ntuple<Tidx..., unsigned int, unsigned int, size_t, size_t, size_t, float> vals;
};

/// HDF5 encoding of \ref SRHoughVertex
template<class... Tidx> class HDF5HoughVertex
{
public:
  template<class... Cols> HDF5HoughVertex(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRHoughVertex& sr);

  std::unique_ptr<HDF5FuzzyK<Tidx...>> fuzzyk;
  // time, vtx.x, vtx.y, vtx.z
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float> vals;
};

/// HDF5 encoding of \ref SRElastic
template<class... Tidx> class HDF5Elastic
{
public:
  template<class... Cols> HDF5Elastic(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRElastic& sr);

  std::unique_ptr<HDF5FuzzyK<Tidx...>> fuzzyk;
  // time, slicevertexenergyvolume10, slicevertexenergyvolume20, slicevertexenergyvolume30, slicevertexenergyvolume40, prong3dvertexenergyvolume10, prong3dvertexenergyvolume20, prong3dvertexenergyvolume30, prong3dvertexenergyvolume40, prong2dvertexenergyvolume10, prong2dvertexenergyvolume20, prong2dvertexenergyvolume30, prong2dvertexenergyvolume40, vtx.x, vtx.y, vtx.z, IsValid
  hep_hpc::hdf5::Ntuple<Tidx..., float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, unsigned short> vals;
};

/// HDF5 encoding of \ref SRVertexBranch
template<class... Tidx> class HDF5VertexBranch
{
public:
  template<class... Cols> HDF5VertexBranch(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::SRVertexBranch& sr);

  std::unique_ptr<HDF5Elastic<Tidx...>> elastic;
  std::unique_ptr<HDF5HoughVertex<Tidx..., unsigned int>> hough;
  std::unique_ptr<HDF5VertexDT<Tidx..., unsigned int>> vdt;
  // nhough, nvdt
  hep_hpc::hdf5::Ntuple<Tidx..., size_t, size_t> vals;
};

/// HDF5 encoding of \ref StandardRecord
template<class... Tidx> class HDF5Record
{
public:
  template<class... Cols> HDF5Record(hid_t f, const std::string& name, const size_t& chunkSize, const size_t& elementsPerChunk, const bool& shuffleInts, const size_t& compressionLevel, Cols... cols);

  void Fill(Tidx... idxs, const caf::StandardRecord& sr);

  std::unique_ptr<HDF5Header<Tidx...>> hdr;
  std::unique_ptr<HDF5Spill<Tidx...>> spill;
  std::unique_ptr<HDF5Slice<Tidx...>> slc;
  std::unique_ptr<HDF5TrackBranch<Tidx...>> trk;
  std::unique_ptr<HDF5VertexBranch<Tidx...>> vtx;
  std::unique_ptr<HDF5MichelE<Tidx...>> me;
  std::unique_ptr<HDF5EnergyBranch<Tidx...>> energy;
  std::unique_ptr<HDF5IDBranch<Tidx...>> sel;
  std::unique_ptr<HDF5TruthBranch<Tidx...>> mc;
  std::unique_ptr<HDF5ParentBranch<Tidx...>> parent;
  std::unique_ptr<HDF5TrainingBranch<Tidx...>> training;
};

} // end namespace