psddl_hdf2psana/src/cspad.ddl.cpp

Go to the documentation of this file.

// *** Do not edit this file, it is auto-generated ***

#include "psddl_hdf2psana/cspad.ddl.h"
#include "hdf5pp/ArrayType.h"
#include "hdf5pp/CompoundType.h"
#include "hdf5pp/EnumType.h"
#include "hdf5pp/VlenType.h"
#include "hdf5pp/Utils.h"
#include "PSEvt/DataProxy.h"
#include "psddl_hdf2psana/Exceptions.h"
#include "psddl_hdf2psana/cspad.h"
namespace psddl_hdf2psana {
namespace CsPad {

hdf5pp::Type ns_CsPadDigitalPotsCfg_v0_dataset_data_stored_type()
{
  typedef ns_CsPadDigitalPotsCfg_v0::dataset_data DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  hsize_t _array_type_pots_shape[] = { 80 };
  hdf5pp::ArrayType _array_type_pots = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint8_t>::stored_type(), 1, _array_type_pots_shape);
  type.insert("pots", offsetof(DsType, pots), _array_type_pots);
  return type;
}

hdf5pp::Type ns_CsPadDigitalPotsCfg_v0::dataset_data::stored_type()
{
  static hdf5pp::Type type = ns_CsPadDigitalPotsCfg_v0_dataset_data_stored_type();
  return type;
}

hdf5pp::Type ns_CsPadDigitalPotsCfg_v0_dataset_data_native_type()
{
  typedef ns_CsPadDigitalPotsCfg_v0::dataset_data DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  hsize_t _array_type_pots_shape[] = { 80 };
  hdf5pp::ArrayType _array_type_pots = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint8_t>::native_type(), 1, _array_type_pots_shape);
  type.insert("pots", offsetof(DsType, pots), _array_type_pots);
  return type;
}

hdf5pp::Type ns_CsPadDigitalPotsCfg_v0::dataset_data::native_type()
{
  static hdf5pp::Type type = ns_CsPadDigitalPotsCfg_v0_dataset_data_native_type();
  return type;
}

ns_CsPadDigitalPotsCfg_v0::dataset_data::dataset_data()
{
}

ns_CsPadDigitalPotsCfg_v0::dataset_data::dataset_data(const Psana::CsPad::CsPadDigitalPotsCfg& psanaobj)
{
  {
    const __typeof__(psanaobj.pots())& arr = psanaobj.pots();
    std::copy(arr.begin(), arr.begin()+80, pots);
  }
}

ns_CsPadDigitalPotsCfg_v0::dataset_data::~dataset_data()
{
}
ndarray<const uint8_t, 1> CsPadDigitalPotsCfg_v0::pots() const {
  if (not m_ds_data) read_ds_data();
  boost::shared_ptr<uint8_t> ptr(m_ds_data, m_ds_data->pots);
  return make_ndarray(ptr, PotsPerQuad);
}
void CsPadDigitalPotsCfg_v0::read_ds_data() const {
  m_ds_data = hdf5pp::Utils::readGroup<CsPad::ns_CsPadDigitalPotsCfg_v0::dataset_data>(m_group, "data", m_idx);
}

void make_datasets_CsPadDigitalPotsCfg_v0(const Psana::CsPad::CsPadDigitalPotsCfg& obj, 
      hdf5pp::Group group, const ChunkPolicy& chunkPolicy, int deflate, bool shuffle)
{
  {
    hdf5pp::Type dstype = CsPad::ns_CsPadDigitalPotsCfg_v0::dataset_data::stored_type();
    hdf5pp::Utils::createDataset(group, "data", dstype, chunkPolicy.chunkSize(dstype), chunkPolicy.chunkCacheSize(dstype), deflate, shuffle);    
  }
}

void store_CsPadDigitalPotsCfg_v0(const Psana::CsPad::CsPadDigitalPotsCfg* obj, hdf5pp::Group group, long index, bool append)
{
  if (obj) {
    CsPad::ns_CsPadDigitalPotsCfg_v0::dataset_data ds_data(*obj);
    if (append) {
      hdf5pp::Utils::storeAt(group, "data", ds_data, index);
    } else {
      hdf5pp::Utils::storeScalar(group, "data", ds_data);
    }
  } else if (append) {
    hdf5pp::Utils::resizeDataset(group, "data", index < 0 ? index : index + 1);
  }
}


hdf5pp::Type ns_CsPadReadOnlyCfg_v0_dataset_data_stored_type()
{
  typedef ns_CsPadReadOnlyCfg_v0::dataset_data DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("shiftTest", offsetof(DsType, shiftTest), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("version", offsetof(DsType, version), hdf5pp::TypeTraits<uint32_t>::stored_type());
  return type;
}

hdf5pp::Type ns_CsPadReadOnlyCfg_v0::dataset_data::stored_type()
{
  static hdf5pp::Type type = ns_CsPadReadOnlyCfg_v0_dataset_data_stored_type();
  return type;
}

hdf5pp::Type ns_CsPadReadOnlyCfg_v0_dataset_data_native_type()
{
  typedef ns_CsPadReadOnlyCfg_v0::dataset_data DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("shiftTest", offsetof(DsType, shiftTest), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("version", offsetof(DsType, version), hdf5pp::TypeTraits<uint32_t>::native_type());
  return type;
}

hdf5pp::Type ns_CsPadReadOnlyCfg_v0::dataset_data::native_type()
{
  static hdf5pp::Type type = ns_CsPadReadOnlyCfg_v0_dataset_data_native_type();
  return type;
}

ns_CsPadReadOnlyCfg_v0::dataset_data::dataset_data()
{
}

ns_CsPadReadOnlyCfg_v0::dataset_data::dataset_data(const Psana::CsPad::CsPadReadOnlyCfg& psanaobj)
  : shiftTest(psanaobj.shiftTest())
  , version(psanaobj.version())
{
}

ns_CsPadReadOnlyCfg_v0::dataset_data::~dataset_data()
{
}

hdf5pp::Type ns_ProtectionSystemThreshold_v0_dataset_data_stored_type()
{
  typedef ns_ProtectionSystemThreshold_v0::dataset_data DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("adcThreshold", offsetof(DsType, adcThreshold), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("pixelCountThreshold", offsetof(DsType, pixelCountThreshold), hdf5pp::TypeTraits<uint32_t>::stored_type());
  return type;
}

hdf5pp::Type ns_ProtectionSystemThreshold_v0::dataset_data::stored_type()
{
  static hdf5pp::Type type = ns_ProtectionSystemThreshold_v0_dataset_data_stored_type();
  return type;
}

hdf5pp::Type ns_ProtectionSystemThreshold_v0_dataset_data_native_type()
{
  typedef ns_ProtectionSystemThreshold_v0::dataset_data DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("adcThreshold", offsetof(DsType, adcThreshold), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("pixelCountThreshold", offsetof(DsType, pixelCountThreshold), hdf5pp::TypeTraits<uint32_t>::native_type());
  return type;
}

hdf5pp::Type ns_ProtectionSystemThreshold_v0::dataset_data::native_type()
{
  static hdf5pp::Type type = ns_ProtectionSystemThreshold_v0_dataset_data_native_type();
  return type;
}

ns_ProtectionSystemThreshold_v0::dataset_data::dataset_data()
{
}

ns_ProtectionSystemThreshold_v0::dataset_data::dataset_data(const Psana::CsPad::ProtectionSystemThreshold& psanaobj)
  : adcThreshold(psanaobj.adcThreshold())
  , pixelCountThreshold(psanaobj.pixelCountThreshold())
{
}

ns_ProtectionSystemThreshold_v0::dataset_data::~dataset_data()
{
}

hdf5pp::Type ns_CsPadGainMapCfg_v0_dataset_data_stored_type()
{
  typedef ns_CsPadGainMapCfg_v0::dataset_data DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  hsize_t _array_type_gainMap_shape[] = { 185, 194 };
  hdf5pp::ArrayType _array_type_gainMap = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint16_t>::stored_type(), 2, _array_type_gainMap_shape);
  type.insert("gainMap", offsetof(DsType, gainMap), _array_type_gainMap);
  return type;
}

hdf5pp::Type ns_CsPadGainMapCfg_v0::dataset_data::stored_type()
{
  static hdf5pp::Type type = ns_CsPadGainMapCfg_v0_dataset_data_stored_type();
  return type;
}

hdf5pp::Type ns_CsPadGainMapCfg_v0_dataset_data_native_type()
{
  typedef ns_CsPadGainMapCfg_v0::dataset_data DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  hsize_t _array_type_gainMap_shape[] = { 185, 194 };
  hdf5pp::ArrayType _array_type_gainMap = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint16_t>::native_type(), 2, _array_type_gainMap_shape);
  type.insert("gainMap", offsetof(DsType, gainMap), _array_type_gainMap);
  return type;
}

hdf5pp::Type ns_CsPadGainMapCfg_v0::dataset_data::native_type()
{
  static hdf5pp::Type type = ns_CsPadGainMapCfg_v0_dataset_data_native_type();
  return type;
}

ns_CsPadGainMapCfg_v0::dataset_data::dataset_data()
{
}

ns_CsPadGainMapCfg_v0::dataset_data::dataset_data(const Psana::CsPad::CsPadGainMapCfg& psanaobj)
{
  {
    const __typeof__(psanaobj.gainMap())& arr = psanaobj.gainMap();
    std::copy(arr.begin(), arr.begin()+35890, gainMap[0]);
  }
}

ns_CsPadGainMapCfg_v0::dataset_data::~dataset_data()
{
}
ndarray<const uint16_t, 2> CsPadGainMapCfg_v0::gainMap() const {
  if (not m_ds_data) read_ds_data();
  boost::shared_ptr<uint16_t> ptr(m_ds_data, m_ds_data->gainMap[0]);
  return make_ndarray(ptr, ColumnsPerASIC,MaxRowsPerASIC);
}
void CsPadGainMapCfg_v0::read_ds_data() const {
  m_ds_data = hdf5pp::Utils::readGroup<CsPad::ns_CsPadGainMapCfg_v0::dataset_data>(m_group, "data", m_idx);
}

void make_datasets_CsPadGainMapCfg_v0(const Psana::CsPad::CsPadGainMapCfg& obj, 
      hdf5pp::Group group, const ChunkPolicy& chunkPolicy, int deflate, bool shuffle)
{
  {
    hdf5pp::Type dstype = CsPad::ns_CsPadGainMapCfg_v0::dataset_data::stored_type();
    hdf5pp::Utils::createDataset(group, "data", dstype, chunkPolicy.chunkSize(dstype), chunkPolicy.chunkCacheSize(dstype), deflate, shuffle);    
  }
}

void store_CsPadGainMapCfg_v0(const Psana::CsPad::CsPadGainMapCfg* obj, hdf5pp::Group group, long index, bool append)
{
  if (obj) {
    CsPad::ns_CsPadGainMapCfg_v0::dataset_data ds_data(*obj);
    if (append) {
      hdf5pp::Utils::storeAt(group, "data", ds_data, index);
    } else {
      hdf5pp::Utils::storeScalar(group, "data", ds_data);
    }
  } else if (append) {
    hdf5pp::Utils::resizeDataset(group, "data", index < 0 ? index : index + 1);
  }
}


hdf5pp::Type ns_ConfigV1QuadReg_v0_dataset_data_stored_type()
{
  typedef ns_ConfigV1QuadReg_v0::dataset_data DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("readClkSet", offsetof(DsType, readClkSet), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("readClkHold", offsetof(DsType, readClkHold), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("dataMode", offsetof(DsType, dataMode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("prstSel", offsetof(DsType, prstSel), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("acqDelay", offsetof(DsType, acqDelay), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("intTime", offsetof(DsType, intTime), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("digDelay", offsetof(DsType, digDelay), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("ampIdle", offsetof(DsType, ampIdle), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("injTotal", offsetof(DsType, injTotal), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("rowColShiftPer", offsetof(DsType, rowColShiftPer), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("readOnly", offsetof(DsType, readOnly), hdf5pp::TypeTraits<CsPad::ns_CsPadReadOnlyCfg_v0::dataset_data>::stored_type());
  type.insert("digitalPots", offsetof(DsType, digitalPots), hdf5pp::TypeTraits<CsPad::ns_CsPadDigitalPotsCfg_v0::dataset_data>::stored_type());
  type.insert("gainMap", offsetof(DsType, gainMap), hdf5pp::TypeTraits<CsPad::ns_CsPadGainMapCfg_v0::dataset_data>::stored_type());
  hsize_t _array_type_shiftSelect_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_shiftSelect = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint32_t>::stored_type(), 1, _array_type_shiftSelect_shape);
  type.insert("shiftSelect", offsetof(DsType, shiftSelect), _array_type_shiftSelect);
  hsize_t _array_type_edgeSelect_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_edgeSelect = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint32_t>::stored_type(), 1, _array_type_edgeSelect_shape);
  type.insert("edgeSelect", offsetof(DsType, edgeSelect), _array_type_edgeSelect);
  return type;
}

hdf5pp::Type ns_ConfigV1QuadReg_v0::dataset_data::stored_type()
{
  static hdf5pp::Type type = ns_ConfigV1QuadReg_v0_dataset_data_stored_type();
  return type;
}

hdf5pp::Type ns_ConfigV1QuadReg_v0_dataset_data_native_type()
{
  typedef ns_ConfigV1QuadReg_v0::dataset_data DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("readClkSet", offsetof(DsType, readClkSet), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("readClkHold", offsetof(DsType, readClkHold), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("dataMode", offsetof(DsType, dataMode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("prstSel", offsetof(DsType, prstSel), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("acqDelay", offsetof(DsType, acqDelay), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("intTime", offsetof(DsType, intTime), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("digDelay", offsetof(DsType, digDelay), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("ampIdle", offsetof(DsType, ampIdle), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("injTotal", offsetof(DsType, injTotal), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("rowColShiftPer", offsetof(DsType, rowColShiftPer), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("readOnly", offsetof(DsType, readOnly), hdf5pp::TypeTraits<CsPad::ns_CsPadReadOnlyCfg_v0::dataset_data>::native_type());
  type.insert("digitalPots", offsetof(DsType, digitalPots), hdf5pp::TypeTraits<CsPad::ns_CsPadDigitalPotsCfg_v0::dataset_data>::native_type());
  type.insert("gainMap", offsetof(DsType, gainMap), hdf5pp::TypeTraits<CsPad::ns_CsPadGainMapCfg_v0::dataset_data>::native_type());
  hsize_t _array_type_shiftSelect_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_shiftSelect = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint32_t>::native_type(), 1, _array_type_shiftSelect_shape);
  type.insert("shiftSelect", offsetof(DsType, shiftSelect), _array_type_shiftSelect);
  hsize_t _array_type_edgeSelect_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_edgeSelect = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint32_t>::native_type(), 1, _array_type_edgeSelect_shape);
  type.insert("edgeSelect", offsetof(DsType, edgeSelect), _array_type_edgeSelect);
  return type;
}

hdf5pp::Type ns_ConfigV1QuadReg_v0::dataset_data::native_type()
{
  static hdf5pp::Type type = ns_ConfigV1QuadReg_v0_dataset_data_native_type();
  return type;
}

ns_ConfigV1QuadReg_v0::dataset_data::dataset_data()
{
}

ns_ConfigV1QuadReg_v0::dataset_data::dataset_data(const Psana::CsPad::ConfigV1QuadReg& psanaobj)
  : readClkSet(psanaobj.readClkSet())
  , readClkHold(psanaobj.readClkHold())
  , dataMode(psanaobj.dataMode())
  , prstSel(psanaobj.prstSel())
  , acqDelay(psanaobj.acqDelay())
  , intTime(psanaobj.intTime())
  , digDelay(psanaobj.digDelay())
  , ampIdle(psanaobj.ampIdle())
  , injTotal(psanaobj.injTotal())
  , rowColShiftPer(psanaobj.rowColShiftPer())
  , readOnly(psanaobj.ro())
  , digitalPots(psanaobj.dp())
  , gainMap(psanaobj.gm())
{
  {
    const __typeof__(psanaobj.shiftSelect())& arr = psanaobj.shiftSelect();
    std::copy(arr.begin(), arr.begin()+4, shiftSelect);
  }
  {
    const __typeof__(psanaobj.edgeSelect())& arr = psanaobj.edgeSelect();
    std::copy(arr.begin(), arr.begin()+4, edgeSelect);
  }
}

ns_ConfigV1QuadReg_v0::dataset_data::~dataset_data()
{
}
ndarray<const uint32_t, 1> ConfigV1QuadReg_v0::shiftSelect() const {
  if (not m_ds_data) read_ds_data();
  boost::shared_ptr<uint32_t> ptr(m_ds_data, m_ds_data->shiftSelect);
  return make_ndarray(ptr, TwoByTwosPerQuad);
}
ndarray<const uint32_t, 1> ConfigV1QuadReg_v0::edgeSelect() const {
  if (not m_ds_data) read_ds_data();
  boost::shared_ptr<uint32_t> ptr(m_ds_data, m_ds_data->edgeSelect);
  return make_ndarray(ptr, TwoByTwosPerQuad);
}
uint32_t ConfigV1QuadReg_v0::readClkSet() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->readClkSet);
}
uint32_t ConfigV1QuadReg_v0::readClkHold() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->readClkHold);
}
uint32_t ConfigV1QuadReg_v0::dataMode() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->dataMode);
}
uint32_t ConfigV1QuadReg_v0::prstSel() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->prstSel);
}
uint32_t ConfigV1QuadReg_v0::acqDelay() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->acqDelay);
}
uint32_t ConfigV1QuadReg_v0::intTime() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->intTime);
}
uint32_t ConfigV1QuadReg_v0::digDelay() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->digDelay);
}
uint32_t ConfigV1QuadReg_v0::ampIdle() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->ampIdle);
}
uint32_t ConfigV1QuadReg_v0::injTotal() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->injTotal);
}
uint32_t ConfigV1QuadReg_v0::rowColShiftPer() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->rowColShiftPer);
}
const Psana::CsPad::CsPadReadOnlyCfg& ConfigV1QuadReg_v0::ro() const {
  if (not m_ds_data) read_ds_data();
  m_ds_storage_data_readOnly = Psana::CsPad::CsPadReadOnlyCfg(m_ds_data->readOnly);
  return m_ds_storage_data_readOnly;
}
const Psana::CsPad::CsPadDigitalPotsCfg& ConfigV1QuadReg_v0::dp() const {
  if (not m_ds_storage_data_digitalPots) {
    if (not m_ds_data) read_ds_data();
    boost::shared_ptr<CsPad::ns_CsPadDigitalPotsCfg_v0::dataset_data> tmp(m_ds_data, &m_ds_data->digitalPots);
    m_ds_storage_data_digitalPots = boost::make_shared<CsPad::CsPadDigitalPotsCfg_v0>(tmp);
  }
  return *m_ds_storage_data_digitalPots;
}
const Psana::CsPad::CsPadGainMapCfg& ConfigV1QuadReg_v0::gm() const {
  if (not m_ds_storage_data_gainMap) {
    if (not m_ds_data) read_ds_data();
    boost::shared_ptr<CsPad::ns_CsPadGainMapCfg_v0::dataset_data> tmp(m_ds_data, &m_ds_data->gainMap);
    m_ds_storage_data_gainMap = boost::make_shared<CsPad::CsPadGainMapCfg_v0>(tmp);
  }
  return *m_ds_storage_data_gainMap;
}
void ConfigV1QuadReg_v0::read_ds_data() const {
  m_ds_data = hdf5pp::Utils::readGroup<CsPad::ns_ConfigV1QuadReg_v0::dataset_data>(m_group, "data", m_idx);
}

void make_datasets_ConfigV1QuadReg_v0(const Psana::CsPad::ConfigV1QuadReg& obj, 
      hdf5pp::Group group, const ChunkPolicy& chunkPolicy, int deflate, bool shuffle)
{
  {
    hdf5pp::Type dstype = CsPad::ns_ConfigV1QuadReg_v0::dataset_data::stored_type();
    hdf5pp::Utils::createDataset(group, "data", dstype, chunkPolicy.chunkSize(dstype), chunkPolicy.chunkCacheSize(dstype), deflate, shuffle);    
  }
}

void store_ConfigV1QuadReg_v0(const Psana::CsPad::ConfigV1QuadReg* obj, hdf5pp::Group group, long index, bool append)
{
  if (obj) {
    CsPad::ns_ConfigV1QuadReg_v0::dataset_data ds_data(*obj);
    if (append) {
      hdf5pp::Utils::storeAt(group, "data", ds_data, index);
    } else {
      hdf5pp::Utils::storeScalar(group, "data", ds_data);
    }
  } else if (append) {
    hdf5pp::Utils::resizeDataset(group, "data", index < 0 ? index : index + 1);
  }
}


hdf5pp::Type ns_ConfigV2QuadReg_v0_dataset_data_stored_type()
{
  typedef ns_ConfigV2QuadReg_v0::dataset_data DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("readClkSet", offsetof(DsType, readClkSet), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("readClkHold", offsetof(DsType, readClkHold), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("dataMode", offsetof(DsType, dataMode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("prstSel", offsetof(DsType, prstSel), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("acqDelay", offsetof(DsType, acqDelay), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("intTime", offsetof(DsType, intTime), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("digDelay", offsetof(DsType, digDelay), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("ampIdle", offsetof(DsType, ampIdle), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("injTotal", offsetof(DsType, injTotal), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("rowColShiftPer", offsetof(DsType, rowColShiftPer), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("ampReset", offsetof(DsType, ampReset), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("digCount", offsetof(DsType, digCount), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("digPeriod", offsetof(DsType, digPeriod), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("readOnly", offsetof(DsType, readOnly), hdf5pp::TypeTraits<CsPad::ns_CsPadReadOnlyCfg_v0::dataset_data>::stored_type());
  type.insert("digitalPots", offsetof(DsType, digitalPots), hdf5pp::TypeTraits<CsPad::ns_CsPadDigitalPotsCfg_v0::dataset_data>::stored_type());
  type.insert("gainMap", offsetof(DsType, gainMap), hdf5pp::TypeTraits<CsPad::ns_CsPadGainMapCfg_v0::dataset_data>::stored_type());
  hsize_t _array_type_shiftSelect_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_shiftSelect = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint32_t>::stored_type(), 1, _array_type_shiftSelect_shape);
  type.insert("shiftSelect", offsetof(DsType, shiftSelect), _array_type_shiftSelect);
  hsize_t _array_type_edgeSelect_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_edgeSelect = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint32_t>::stored_type(), 1, _array_type_edgeSelect_shape);
  type.insert("edgeSelect", offsetof(DsType, edgeSelect), _array_type_edgeSelect);
  return type;
}

hdf5pp::Type ns_ConfigV2QuadReg_v0::dataset_data::stored_type()
{
  static hdf5pp::Type type = ns_ConfigV2QuadReg_v0_dataset_data_stored_type();
  return type;
}

hdf5pp::Type ns_ConfigV2QuadReg_v0_dataset_data_native_type()
{
  typedef ns_ConfigV2QuadReg_v0::dataset_data DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("readClkSet", offsetof(DsType, readClkSet), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("readClkHold", offsetof(DsType, readClkHold), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("dataMode", offsetof(DsType, dataMode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("prstSel", offsetof(DsType, prstSel), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("acqDelay", offsetof(DsType, acqDelay), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("intTime", offsetof(DsType, intTime), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("digDelay", offsetof(DsType, digDelay), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("ampIdle", offsetof(DsType, ampIdle), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("injTotal", offsetof(DsType, injTotal), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("rowColShiftPer", offsetof(DsType, rowColShiftPer), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("ampReset", offsetof(DsType, ampReset), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("digCount", offsetof(DsType, digCount), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("digPeriod", offsetof(DsType, digPeriod), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("readOnly", offsetof(DsType, readOnly), hdf5pp::TypeTraits<CsPad::ns_CsPadReadOnlyCfg_v0::dataset_data>::native_type());
  type.insert("digitalPots", offsetof(DsType, digitalPots), hdf5pp::TypeTraits<CsPad::ns_CsPadDigitalPotsCfg_v0::dataset_data>::native_type());
  type.insert("gainMap", offsetof(DsType, gainMap), hdf5pp::TypeTraits<CsPad::ns_CsPadGainMapCfg_v0::dataset_data>::native_type());
  hsize_t _array_type_shiftSelect_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_shiftSelect = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint32_t>::native_type(), 1, _array_type_shiftSelect_shape);
  type.insert("shiftSelect", offsetof(DsType, shiftSelect), _array_type_shiftSelect);
  hsize_t _array_type_edgeSelect_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_edgeSelect = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint32_t>::native_type(), 1, _array_type_edgeSelect_shape);
  type.insert("edgeSelect", offsetof(DsType, edgeSelect), _array_type_edgeSelect);
  return type;
}

hdf5pp::Type ns_ConfigV2QuadReg_v0::dataset_data::native_type()
{
  static hdf5pp::Type type = ns_ConfigV2QuadReg_v0_dataset_data_native_type();
  return type;
}

ns_ConfigV2QuadReg_v0::dataset_data::dataset_data()
{
}

ns_ConfigV2QuadReg_v0::dataset_data::dataset_data(const Psana::CsPad::ConfigV2QuadReg& psanaobj)
  : readClkSet(psanaobj.readClkSet())
  , readClkHold(psanaobj.readClkHold())
  , dataMode(psanaobj.dataMode())
  , prstSel(psanaobj.prstSel())
  , acqDelay(psanaobj.acqDelay())
  , intTime(psanaobj.intTime())
  , digDelay(psanaobj.digDelay())
  , ampIdle(psanaobj.ampIdle())
  , injTotal(psanaobj.injTotal())
  , rowColShiftPer(psanaobj.rowColShiftPer())
  , ampReset(psanaobj.ampReset())
  , digCount(psanaobj.digCount())
  , digPeriod(psanaobj.digPeriod())
  , readOnly(psanaobj.ro())
  , digitalPots(psanaobj.dp())
  , gainMap(psanaobj.gm())
{
  {
    const __typeof__(psanaobj.shiftSelect())& arr = psanaobj.shiftSelect();
    std::copy(arr.begin(), arr.begin()+4, shiftSelect);
  }
  {
    const __typeof__(psanaobj.edgeSelect())& arr = psanaobj.edgeSelect();
    std::copy(arr.begin(), arr.begin()+4, edgeSelect);
  }
}

ns_ConfigV2QuadReg_v0::dataset_data::~dataset_data()
{
}
ndarray<const uint32_t, 1> ConfigV2QuadReg_v0::shiftSelect() const {
  if (not m_ds_data) read_ds_data();
  boost::shared_ptr<uint32_t> ptr(m_ds_data, m_ds_data->shiftSelect);
  return make_ndarray(ptr, TwoByTwosPerQuad);
}
ndarray<const uint32_t, 1> ConfigV2QuadReg_v0::edgeSelect() const {
  if (not m_ds_data) read_ds_data();
  boost::shared_ptr<uint32_t> ptr(m_ds_data, m_ds_data->edgeSelect);
  return make_ndarray(ptr, TwoByTwosPerQuad);
}
uint32_t ConfigV2QuadReg_v0::readClkSet() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->readClkSet);
}
uint32_t ConfigV2QuadReg_v0::readClkHold() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->readClkHold);
}
uint32_t ConfigV2QuadReg_v0::dataMode() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->dataMode);
}
uint32_t ConfigV2QuadReg_v0::prstSel() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->prstSel);
}
uint32_t ConfigV2QuadReg_v0::acqDelay() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->acqDelay);
}
uint32_t ConfigV2QuadReg_v0::intTime() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->intTime);
}
uint32_t ConfigV2QuadReg_v0::digDelay() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->digDelay);
}
uint32_t ConfigV2QuadReg_v0::ampIdle() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->ampIdle);
}
uint32_t ConfigV2QuadReg_v0::injTotal() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->injTotal);
}
uint32_t ConfigV2QuadReg_v0::rowColShiftPer() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->rowColShiftPer);
}
uint32_t ConfigV2QuadReg_v0::ampReset() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->ampReset);
}
uint32_t ConfigV2QuadReg_v0::digCount() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->digCount);
}
uint32_t ConfigV2QuadReg_v0::digPeriod() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->digPeriod);
}
const Psana::CsPad::CsPadReadOnlyCfg& ConfigV2QuadReg_v0::ro() const {
  if (not m_ds_data) read_ds_data();
  m_ds_storage_data_readOnly = Psana::CsPad::CsPadReadOnlyCfg(m_ds_data->readOnly);
  return m_ds_storage_data_readOnly;
}
const Psana::CsPad::CsPadDigitalPotsCfg& ConfigV2QuadReg_v0::dp() const {
  if (not m_ds_storage_data_digitalPots) {
    if (not m_ds_data) read_ds_data();
    boost::shared_ptr<CsPad::ns_CsPadDigitalPotsCfg_v0::dataset_data> tmp(m_ds_data, &m_ds_data->digitalPots);
    m_ds_storage_data_digitalPots = boost::make_shared<CsPad::CsPadDigitalPotsCfg_v0>(tmp);
  }
  return *m_ds_storage_data_digitalPots;
}
const Psana::CsPad::CsPadGainMapCfg& ConfigV2QuadReg_v0::gm() const {
  if (not m_ds_storage_data_gainMap) {
    if (not m_ds_data) read_ds_data();
    boost::shared_ptr<CsPad::ns_CsPadGainMapCfg_v0::dataset_data> tmp(m_ds_data, &m_ds_data->gainMap);
    m_ds_storage_data_gainMap = boost::make_shared<CsPad::CsPadGainMapCfg_v0>(tmp);
  }
  return *m_ds_storage_data_gainMap;
}
void ConfigV2QuadReg_v0::read_ds_data() const {
  m_ds_data = hdf5pp::Utils::readGroup<CsPad::ns_ConfigV2QuadReg_v0::dataset_data>(m_group, "data", m_idx);
}

void make_datasets_ConfigV2QuadReg_v0(const Psana::CsPad::ConfigV2QuadReg& obj, 
      hdf5pp::Group group, const ChunkPolicy& chunkPolicy, int deflate, bool shuffle)
{
  {
    hdf5pp::Type dstype = CsPad::ns_ConfigV2QuadReg_v0::dataset_data::stored_type();
    hdf5pp::Utils::createDataset(group, "data", dstype, chunkPolicy.chunkSize(dstype), chunkPolicy.chunkCacheSize(dstype), deflate, shuffle);    
  }
}

void store_ConfigV2QuadReg_v0(const Psana::CsPad::ConfigV2QuadReg* obj, hdf5pp::Group group, long index, bool append)
{
  if (obj) {
    CsPad::ns_ConfigV2QuadReg_v0::dataset_data ds_data(*obj);
    if (append) {
      hdf5pp::Utils::storeAt(group, "data", ds_data, index);
    } else {
      hdf5pp::Utils::storeScalar(group, "data", ds_data);
    }
  } else if (append) {
    hdf5pp::Utils::resizeDataset(group, "data", index < 0 ? index : index + 1);
  }
}


hdf5pp::Type ns_ConfigV3QuadReg_v0_dataset_data_stored_type()
{
  typedef ns_ConfigV3QuadReg_v0::dataset_data DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("readClkSet", offsetof(DsType, readClkSet), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("readClkHold", offsetof(DsType, readClkHold), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("dataMode", offsetof(DsType, dataMode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("prstSel", offsetof(DsType, prstSel), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("acqDelay", offsetof(DsType, acqDelay), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("intTime", offsetof(DsType, intTime), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("digDelay", offsetof(DsType, digDelay), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("ampIdle", offsetof(DsType, ampIdle), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("injTotal", offsetof(DsType, injTotal), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("rowColShiftPer", offsetof(DsType, rowColShiftPer), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("ampReset", offsetof(DsType, ampReset), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("digCount", offsetof(DsType, digCount), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("digPeriod", offsetof(DsType, digPeriod), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("biasTuning", offsetof(DsType, biasTuning), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("pdpmndnmBalance", offsetof(DsType, pdpmndnmBalance), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("readOnly", offsetof(DsType, readOnly), hdf5pp::TypeTraits<CsPad::ns_CsPadReadOnlyCfg_v0::dataset_data>::stored_type());
  type.insert("digitalPots", offsetof(DsType, digitalPots), hdf5pp::TypeTraits<CsPad::ns_CsPadDigitalPotsCfg_v0::dataset_data>::stored_type());
  type.insert("gainMap", offsetof(DsType, gainMap), hdf5pp::TypeTraits<CsPad::ns_CsPadGainMapCfg_v0::dataset_data>::stored_type());
  hsize_t _array_type_shiftSelect_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_shiftSelect = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint32_t>::stored_type(), 1, _array_type_shiftSelect_shape);
  type.insert("shiftSelect", offsetof(DsType, shiftSelect), _array_type_shiftSelect);
  hsize_t _array_type_edgeSelect_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_edgeSelect = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint32_t>::stored_type(), 1, _array_type_edgeSelect_shape);
  type.insert("edgeSelect", offsetof(DsType, edgeSelect), _array_type_edgeSelect);
  return type;
}

hdf5pp::Type ns_ConfigV3QuadReg_v0::dataset_data::stored_type()
{
  static hdf5pp::Type type = ns_ConfigV3QuadReg_v0_dataset_data_stored_type();
  return type;
}

hdf5pp::Type ns_ConfigV3QuadReg_v0_dataset_data_native_type()
{
  typedef ns_ConfigV3QuadReg_v0::dataset_data DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("readClkSet", offsetof(DsType, readClkSet), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("readClkHold", offsetof(DsType, readClkHold), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("dataMode", offsetof(DsType, dataMode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("prstSel", offsetof(DsType, prstSel), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("acqDelay", offsetof(DsType, acqDelay), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("intTime", offsetof(DsType, intTime), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("digDelay", offsetof(DsType, digDelay), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("ampIdle", offsetof(DsType, ampIdle), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("injTotal", offsetof(DsType, injTotal), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("rowColShiftPer", offsetof(DsType, rowColShiftPer), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("ampReset", offsetof(DsType, ampReset), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("digCount", offsetof(DsType, digCount), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("digPeriod", offsetof(DsType, digPeriod), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("biasTuning", offsetof(DsType, biasTuning), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("pdpmndnmBalance", offsetof(DsType, pdpmndnmBalance), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("readOnly", offsetof(DsType, readOnly), hdf5pp::TypeTraits<CsPad::ns_CsPadReadOnlyCfg_v0::dataset_data>::native_type());
  type.insert("digitalPots", offsetof(DsType, digitalPots), hdf5pp::TypeTraits<CsPad::ns_CsPadDigitalPotsCfg_v0::dataset_data>::native_type());
  type.insert("gainMap", offsetof(DsType, gainMap), hdf5pp::TypeTraits<CsPad::ns_CsPadGainMapCfg_v0::dataset_data>::native_type());
  hsize_t _array_type_shiftSelect_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_shiftSelect = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint32_t>::native_type(), 1, _array_type_shiftSelect_shape);
  type.insert("shiftSelect", offsetof(DsType, shiftSelect), _array_type_shiftSelect);
  hsize_t _array_type_edgeSelect_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_edgeSelect = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint32_t>::native_type(), 1, _array_type_edgeSelect_shape);
  type.insert("edgeSelect", offsetof(DsType, edgeSelect), _array_type_edgeSelect);
  return type;
}

hdf5pp::Type ns_ConfigV3QuadReg_v0::dataset_data::native_type()
{
  static hdf5pp::Type type = ns_ConfigV3QuadReg_v0_dataset_data_native_type();
  return type;
}

ns_ConfigV3QuadReg_v0::dataset_data::dataset_data()
{
}

ns_ConfigV3QuadReg_v0::dataset_data::dataset_data(const Psana::CsPad::ConfigV3QuadReg& psanaobj)
  : readClkSet(psanaobj.readClkSet())
  , readClkHold(psanaobj.readClkHold())
  , dataMode(psanaobj.dataMode())
  , prstSel(psanaobj.prstSel())
  , acqDelay(psanaobj.acqDelay())
  , intTime(psanaobj.intTime())
  , digDelay(psanaobj.digDelay())
  , ampIdle(psanaobj.ampIdle())
  , injTotal(psanaobj.injTotal())
  , rowColShiftPer(psanaobj.rowColShiftPer())
  , ampReset(psanaobj.ampReset())
  , digCount(psanaobj.digCount())
  , digPeriod(psanaobj.digPeriod())
  , biasTuning(psanaobj.biasTuning())
  , pdpmndnmBalance(psanaobj.pdpmndnmBalance())
  , readOnly(psanaobj.ro())
  , digitalPots(psanaobj.dp())
  , gainMap(psanaobj.gm())
{
  {
    const __typeof__(psanaobj.shiftSelect())& arr = psanaobj.shiftSelect();
    std::copy(arr.begin(), arr.begin()+4, shiftSelect);
  }
  {
    const __typeof__(psanaobj.edgeSelect())& arr = psanaobj.edgeSelect();
    std::copy(arr.begin(), arr.begin()+4, edgeSelect);
  }
}

ns_ConfigV3QuadReg_v0::dataset_data::~dataset_data()
{
}
ndarray<const uint32_t, 1> ConfigV3QuadReg_v0::shiftSelect() const {
  if (not m_ds_data) read_ds_data();
  boost::shared_ptr<uint32_t> ptr(m_ds_data, m_ds_data->shiftSelect);
  return make_ndarray(ptr, TwoByTwosPerQuad);
}
ndarray<const uint32_t, 1> ConfigV3QuadReg_v0::edgeSelect() const {
  if (not m_ds_data) read_ds_data();
  boost::shared_ptr<uint32_t> ptr(m_ds_data, m_ds_data->edgeSelect);
  return make_ndarray(ptr, TwoByTwosPerQuad);
}
uint32_t ConfigV3QuadReg_v0::readClkSet() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->readClkSet);
}
uint32_t ConfigV3QuadReg_v0::readClkHold() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->readClkHold);
}
uint32_t ConfigV3QuadReg_v0::dataMode() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->dataMode);
}
uint32_t ConfigV3QuadReg_v0::prstSel() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->prstSel);
}
uint32_t ConfigV3QuadReg_v0::acqDelay() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->acqDelay);
}
uint32_t ConfigV3QuadReg_v0::intTime() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->intTime);
}
uint32_t ConfigV3QuadReg_v0::digDelay() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->digDelay);
}
uint32_t ConfigV3QuadReg_v0::ampIdle() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->ampIdle);
}
uint32_t ConfigV3QuadReg_v0::injTotal() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->injTotal);
}
uint32_t ConfigV3QuadReg_v0::rowColShiftPer() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->rowColShiftPer);
}
uint32_t ConfigV3QuadReg_v0::ampReset() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->ampReset);
}
uint32_t ConfigV3QuadReg_v0::digCount() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->digCount);
}
uint32_t ConfigV3QuadReg_v0::digPeriod() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->digPeriod);
}
uint32_t ConfigV3QuadReg_v0::biasTuning() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->biasTuning);
}
uint32_t ConfigV3QuadReg_v0::pdpmndnmBalance() const {
  if (not m_ds_data) read_ds_data();
  return uint32_t(m_ds_data->pdpmndnmBalance);
}
const Psana::CsPad::CsPadReadOnlyCfg& ConfigV3QuadReg_v0::ro() const {
  if (not m_ds_data) read_ds_data();
  m_ds_storage_data_readOnly = Psana::CsPad::CsPadReadOnlyCfg(m_ds_data->readOnly);
  return m_ds_storage_data_readOnly;
}
const Psana::CsPad::CsPadDigitalPotsCfg& ConfigV3QuadReg_v0::dp() const {
  if (not m_ds_storage_data_digitalPots) {
    if (not m_ds_data) read_ds_data();
    boost::shared_ptr<CsPad::ns_CsPadDigitalPotsCfg_v0::dataset_data> tmp(m_ds_data, &m_ds_data->digitalPots);
    m_ds_storage_data_digitalPots = boost::make_shared<CsPad::CsPadDigitalPotsCfg_v0>(tmp);
  }
  return *m_ds_storage_data_digitalPots;
}
const Psana::CsPad::CsPadGainMapCfg& ConfigV3QuadReg_v0::gm() const {
  if (not m_ds_storage_data_gainMap) {
    if (not m_ds_data) read_ds_data();
    boost::shared_ptr<CsPad::ns_CsPadGainMapCfg_v0::dataset_data> tmp(m_ds_data, &m_ds_data->gainMap);
    m_ds_storage_data_gainMap = boost::make_shared<CsPad::CsPadGainMapCfg_v0>(tmp);
  }
  return *m_ds_storage_data_gainMap;
}
void ConfigV3QuadReg_v0::read_ds_data() const {
  m_ds_data = hdf5pp::Utils::readGroup<CsPad::ns_ConfigV3QuadReg_v0::dataset_data>(m_group, "data", m_idx);
}

void make_datasets_ConfigV3QuadReg_v0(const Psana::CsPad::ConfigV3QuadReg& obj, 
      hdf5pp::Group group, const ChunkPolicy& chunkPolicy, int deflate, bool shuffle)
{
  {
    hdf5pp::Type dstype = CsPad::ns_ConfigV3QuadReg_v0::dataset_data::stored_type();
    hdf5pp::Utils::createDataset(group, "data", dstype, chunkPolicy.chunkSize(dstype), chunkPolicy.chunkCacheSize(dstype), deflate, shuffle);    
  }
}

void store_ConfigV3QuadReg_v0(const Psana::CsPad::ConfigV3QuadReg* obj, hdf5pp::Group group, long index, bool append)
{
  if (obj) {
    CsPad::ns_ConfigV3QuadReg_v0::dataset_data ds_data(*obj);
    if (append) {
      hdf5pp::Utils::storeAt(group, "data", ds_data, index);
    } else {
      hdf5pp::Utils::storeScalar(group, "data", ds_data);
    }
  } else if (append) {
    hdf5pp::Utils::resizeDataset(group, "data", index < 0 ? index : index + 1);
  }
}


hdf5pp::Type ns_ConfigV1_v0_dataset_config_stored_type()
{
  typedef ns_ConfigV1_v0::dataset_config DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("concentratorVersion", offsetof(DsType, concentratorVersion), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("runDelay", offsetof(DsType, runDelay), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("eventCode", offsetof(DsType, eventCode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("inactiveRunMode", offsetof(DsType, inactiveRunMode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("activeRunMode", offsetof(DsType, activeRunMode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("testDataIndex", offsetof(DsType, testDataIndex), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("payloadPerQuad", offsetof(DsType, payloadPerQuad), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("badAsicMask0", offsetof(DsType, badAsicMask0), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("badAsicMask1", offsetof(DsType, badAsicMask1), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("asicMask", offsetof(DsType, asicMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("quadMask", offsetof(DsType, quadMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  hsize_t _array_type_quads_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_quads = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ConfigV1QuadReg_v0::dataset_data>::stored_type(), 1, _array_type_quads_shape);
  type.insert("quads", offsetof(DsType, quads), _array_type_quads);
  return type;
}

hdf5pp::Type ns_ConfigV1_v0::dataset_config::stored_type()
{
  static hdf5pp::Type type = ns_ConfigV1_v0_dataset_config_stored_type();
  return type;
}

hdf5pp::Type ns_ConfigV1_v0_dataset_config_native_type()
{
  typedef ns_ConfigV1_v0::dataset_config DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("concentratorVersion", offsetof(DsType, concentratorVersion), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("runDelay", offsetof(DsType, runDelay), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("eventCode", offsetof(DsType, eventCode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("inactiveRunMode", offsetof(DsType, inactiveRunMode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("activeRunMode", offsetof(DsType, activeRunMode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("testDataIndex", offsetof(DsType, testDataIndex), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("payloadPerQuad", offsetof(DsType, payloadPerQuad), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("badAsicMask0", offsetof(DsType, badAsicMask0), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("badAsicMask1", offsetof(DsType, badAsicMask1), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("asicMask", offsetof(DsType, asicMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("quadMask", offsetof(DsType, quadMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  hsize_t _array_type_quads_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_quads = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ConfigV1QuadReg_v0::dataset_data>::native_type(), 1, _array_type_quads_shape);
  type.insert("quads", offsetof(DsType, quads), _array_type_quads);
  return type;
}

hdf5pp::Type ns_ConfigV1_v0::dataset_config::native_type()
{
  static hdf5pp::Type type = ns_ConfigV1_v0_dataset_config_native_type();
  return type;
}

ns_ConfigV1_v0::dataset_config::dataset_config()
{
}

ns_ConfigV1_v0::dataset_config::dataset_config(const Psana::CsPad::ConfigV1& psanaobj)
  : concentratorVersion(psanaobj.concentratorVersion())
  , runDelay(psanaobj.runDelay())
  , eventCode(psanaobj.eventCode())
  , inactiveRunMode(psanaobj.inactiveRunMode())
  , activeRunMode(psanaobj.activeRunMode())
  , testDataIndex(psanaobj.tdi())
  , payloadPerQuad(psanaobj.payloadSize())
  , badAsicMask0(psanaobj.badAsicMask0())
  , badAsicMask1(psanaobj.badAsicMask1())
  , asicMask(psanaobj.asicMask())
  , quadMask(psanaobj.quadMask())
{
  for (size_t i = 0, len = 4; i != len; ++ i) {
    quads[i] = CsPad::ns_ConfigV1QuadReg_v0::dataset_data(psanaobj.quads(i));
  }
}

ns_ConfigV1_v0::dataset_config::~dataset_config()
{
}
uint32_t ConfigV1_v0::concentratorVersion() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->concentratorVersion);
}
uint32_t ConfigV1_v0::runDelay() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->runDelay);
}
uint32_t ConfigV1_v0::eventCode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->eventCode);
}
uint32_t ConfigV1_v0::inactiveRunMode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->inactiveRunMode);
}
uint32_t ConfigV1_v0::activeRunMode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->activeRunMode);
}
uint32_t ConfigV1_v0::tdi() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->testDataIndex);
}
uint32_t ConfigV1_v0::payloadSize() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->payloadPerQuad);
}
uint32_t ConfigV1_v0::badAsicMask0() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->badAsicMask0);
}
uint32_t ConfigV1_v0::badAsicMask1() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->badAsicMask1);
}
uint32_t ConfigV1_v0::asicMask() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->asicMask);
}
uint32_t ConfigV1_v0::quadMask() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->quadMask);
}
const Psana::CsPad::ConfigV1QuadReg& ConfigV1_v0::quads(uint32_t i0) const {
  if (not m_ds_config) read_ds_config();
  if (m_ds_storage_config_quads.empty()) {
    unsigned shape[] = {MaxQuadsPerSensor};
    ndarray<ConfigV1QuadReg_v0, 1> tmparr(shape);
    for (int i = 0; i != 4; ++ i) {
      boost::shared_ptr<CsPad::ns_ConfigV1QuadReg_v0::dataset_data> ptr(m_ds_config, &m_ds_config->quads[i]);
      tmparr.begin()[i] = ConfigV1QuadReg_v0(ptr);
    }
    m_ds_storage_config_quads = tmparr;
  }
  return m_ds_storage_config_quads[i0];
}
uint32_t
ConfigV1_v0::numAsicsRead() const{ 
return (this->asicMask() & 0xf)==1 ? 4 : 16; 
}
uint32_t
ConfigV1_v0::numQuads() const{ 
return __builtin_popcount(this->quadMask()); 
}
uint32_t
ConfigV1_v0::numSect() const{ 
return this->numAsicsRead()/2; 
}
std::vector<int>
ConfigV1_v0::quads_shape() const{ 
  int shape[] = { MaxQuadsPerSensor };
  return std::vector<int>(shape, shape+1); 
}
void ConfigV1_v0::read_ds_config() const {
  m_ds_config = hdf5pp::Utils::readGroup<CsPad::ns_ConfigV1_v0::dataset_config>(m_group, "config", m_idx);
}

void make_datasets_ConfigV1_v0(const Psana::CsPad::ConfigV1& obj, 
      hdf5pp::Group group, const ChunkPolicy& chunkPolicy, int deflate, bool shuffle)
{
  {
    hdf5pp::Type dstype = CsPad::ns_ConfigV1_v0::dataset_config::stored_type();
    hdf5pp::Utils::createDataset(group, "config", dstype, chunkPolicy.chunkSize(dstype), chunkPolicy.chunkCacheSize(dstype), deflate, shuffle);    
  }
}

void store_ConfigV1_v0(const Psana::CsPad::ConfigV1* obj, hdf5pp::Group group, long index, bool append)
{
  if (obj) {
    CsPad::ns_ConfigV1_v0::dataset_config ds_data(*obj);
    if (append) {
      hdf5pp::Utils::storeAt(group, "config", ds_data, index);
    } else {
      hdf5pp::Utils::storeScalar(group, "config", ds_data);
    }
  } else if (append) {
    hdf5pp::Utils::resizeDataset(group, "config", index < 0 ? index : index + 1);
  }
}

boost::shared_ptr<PSEvt::Proxy<Psana::CsPad::ConfigV1> > make_ConfigV1(int version, hdf5pp::Group group, hsize_t idx) {
  switch (version) {
  case 0:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::ConfigV1> >(boost::make_shared<ConfigV1_v0>(group, idx));
  default:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::ConfigV1> >(boost::shared_ptr<Psana::CsPad::ConfigV1>());
  }
}

void make_datasets(const Psana::CsPad::ConfigV1& obj, hdf5pp::Group group, const ChunkPolicy& chunkPolicy,
                   int deflate, bool shuffle, int version)
{
  if (version < 0) version = 0;
  group.createAttr<uint32_t>("_schemaVersion").store(version);
  switch (version) {
  case 0:
    make_datasets_ConfigV1_v0(obj, group, chunkPolicy, deflate, shuffle);
    break;
  default:
    throw ExceptionSchemaVersion(ERR_LOC, "CsPad.ConfigV1", version);
  }
}

void store_ConfigV1(const Psana::CsPad::ConfigV1* obj, hdf5pp::Group group, long index, int version, bool append)
{
  if (version < 0) version = 0;
  if (not append) group.createAttr<uint32_t>("_schemaVersion").store(version);
  switch (version) {
  case 0:
    store_ConfigV1_v0(obj, group, index, append);
    break;
  default:
    throw ExceptionSchemaVersion(ERR_LOC, "CsPad.ConfigV1", version);
  }
}

void store(const Psana::CsPad::ConfigV1& obj, hdf5pp::Group group, int version) 
{
  store_ConfigV1(&obj, group, 0, version, false);
}

void store_at(const Psana::CsPad::ConfigV1* obj, hdf5pp::Group group, long index, int version)
{
  store_ConfigV1(obj, group, index, version, true);
}


hdf5pp::Type ns_ConfigV2_v0_dataset_config_stored_type()
{
  typedef ns_ConfigV2_v0::dataset_config DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("concentratorVersion", offsetof(DsType, concentratorVersion), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("runDelay", offsetof(DsType, runDelay), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("eventCode", offsetof(DsType, eventCode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("inactiveRunMode", offsetof(DsType, inactiveRunMode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("activeRunMode", offsetof(DsType, activeRunMode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("testDataIndex", offsetof(DsType, testDataIndex), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("payloadPerQuad", offsetof(DsType, payloadPerQuad), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("badAsicMask0", offsetof(DsType, badAsicMask0), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("badAsicMask1", offsetof(DsType, badAsicMask1), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("asicMask", offsetof(DsType, asicMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("quadMask", offsetof(DsType, quadMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("roiMask", offsetof(DsType, roiMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  hsize_t _array_type_quads_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_quads = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ConfigV1QuadReg_v0::dataset_data>::stored_type(), 1, _array_type_quads_shape);
  type.insert("quads", offsetof(DsType, quads), _array_type_quads);
  hsize_t _array_type_sections_shape[] = { 4, 8 };
  hdf5pp::ArrayType _array_type_sections = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<int8_t>::stored_type(), 2, _array_type_sections_shape);
  type.insert("sections", offsetof(DsType, sections), _array_type_sections);
  return type;
}

hdf5pp::Type ns_ConfigV2_v0::dataset_config::stored_type()
{
  static hdf5pp::Type type = ns_ConfigV2_v0_dataset_config_stored_type();
  return type;
}

hdf5pp::Type ns_ConfigV2_v0_dataset_config_native_type()
{
  typedef ns_ConfigV2_v0::dataset_config DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("concentratorVersion", offsetof(DsType, concentratorVersion), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("runDelay", offsetof(DsType, runDelay), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("eventCode", offsetof(DsType, eventCode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("inactiveRunMode", offsetof(DsType, inactiveRunMode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("activeRunMode", offsetof(DsType, activeRunMode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("testDataIndex", offsetof(DsType, testDataIndex), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("payloadPerQuad", offsetof(DsType, payloadPerQuad), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("badAsicMask0", offsetof(DsType, badAsicMask0), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("badAsicMask1", offsetof(DsType, badAsicMask1), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("asicMask", offsetof(DsType, asicMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("quadMask", offsetof(DsType, quadMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("roiMask", offsetof(DsType, roiMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  hsize_t _array_type_quads_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_quads = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ConfigV1QuadReg_v0::dataset_data>::native_type(), 1, _array_type_quads_shape);
  type.insert("quads", offsetof(DsType, quads), _array_type_quads);
  hsize_t _array_type_sections_shape[] = { 4, 8 };
  hdf5pp::ArrayType _array_type_sections = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<int8_t>::native_type(), 2, _array_type_sections_shape);
  type.insert("sections", offsetof(DsType, sections), _array_type_sections);
  return type;
}

hdf5pp::Type ns_ConfigV2_v0::dataset_config::native_type()
{
  static hdf5pp::Type type = ns_ConfigV2_v0_dataset_config_native_type();
  return type;
}

ns_ConfigV2_v0::dataset_config::dataset_config()
{
}

ns_ConfigV2_v0::dataset_config::dataset_config(const Psana::CsPad::ConfigV2& psanaobj)
  : concentratorVersion(psanaobj.concentratorVersion())
  , runDelay(psanaobj.runDelay())
  , eventCode(psanaobj.eventCode())
  , inactiveRunMode(psanaobj.inactiveRunMode())
  , activeRunMode(psanaobj.activeRunMode())
  , testDataIndex(psanaobj.tdi())
  , payloadPerQuad(psanaobj.payloadSize())
  , badAsicMask0(psanaobj.badAsicMask0())
  , badAsicMask1(psanaobj.badAsicMask1())
  , asicMask(psanaobj.asicMask())
  , quadMask(psanaobj.quadMask())
  , roiMask(psanaobj.roiMasks())
{
  for (size_t i = 0, len = 4; i != len; ++ i) {
    quads[i] = CsPad::ns_ConfigV1QuadReg_v0::dataset_data(psanaobj.quads(i));
  }
  init_attr_sections();
}

ns_ConfigV2_v0::dataset_config::~dataset_config()
{
}
uint32_t ConfigV2_v0::concentratorVersion() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->concentratorVersion);
}
uint32_t ConfigV2_v0::runDelay() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->runDelay);
}
uint32_t ConfigV2_v0::eventCode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->eventCode);
}
uint32_t ConfigV2_v0::inactiveRunMode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->inactiveRunMode);
}
uint32_t ConfigV2_v0::activeRunMode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->activeRunMode);
}
uint32_t ConfigV2_v0::tdi() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->testDataIndex);
}
uint32_t ConfigV2_v0::payloadSize() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->payloadPerQuad);
}
uint32_t ConfigV2_v0::badAsicMask0() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->badAsicMask0);
}
uint32_t ConfigV2_v0::badAsicMask1() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->badAsicMask1);
}
uint32_t ConfigV2_v0::asicMask() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->asicMask);
}
uint32_t ConfigV2_v0::quadMask() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->quadMask);
}
uint32_t ConfigV2_v0::roiMasks() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->roiMask);
}
const Psana::CsPad::ConfigV1QuadReg& ConfigV2_v0::quads(uint32_t i0) const {
  if (not m_ds_config) read_ds_config();
  if (m_ds_storage_config_quads.empty()) {
    unsigned shape[] = {MaxQuadsPerSensor};
    ndarray<ConfigV1QuadReg_v0, 1> tmparr(shape);
    for (int i = 0; i != 4; ++ i) {
      boost::shared_ptr<CsPad::ns_ConfigV1QuadReg_v0::dataset_data> ptr(m_ds_config, &m_ds_config->quads[i]);
      tmparr.begin()[i] = ConfigV1QuadReg_v0(ptr);
    }
    m_ds_storage_config_quads = tmparr;
  }
  return m_ds_storage_config_quads[i0];
}
uint32_t
ConfigV2_v0::numAsicsRead() const{ 
return (this->asicMask() & 0xf)==1 ? 4 : 16; 
}
uint32_t
ConfigV2_v0::roiMask(uint32_t iq) const{ 
return (this->roiMasks() >> (8*iq)) & 0xff; 
}
uint32_t
ConfigV2_v0::numAsicsStored(uint32_t iq) const{ 
return __builtin_popcount(this->roiMask(iq))*2; 
}
uint32_t
ConfigV2_v0::numQuads() const{ 
return __builtin_popcount(this->quadMask()); 
}
uint32_t
ConfigV2_v0::numSect() const{ 
return __builtin_popcount(this->roiMasks()); 
}
std::vector<int>
ConfigV2_v0::quads_shape() const{ 
  int shape[] = { MaxQuadsPerSensor };
  return std::vector<int>(shape, shape+1); 
}
void ConfigV2_v0::read_ds_config() const {
  m_ds_config = hdf5pp::Utils::readGroup<CsPad::ns_ConfigV2_v0::dataset_config>(m_group, "config", m_idx);
}

void make_datasets_ConfigV2_v0(const Psana::CsPad::ConfigV2& obj, 
      hdf5pp::Group group, const ChunkPolicy& chunkPolicy, int deflate, bool shuffle)
{
  {
    hdf5pp::Type dstype = CsPad::ns_ConfigV2_v0::dataset_config::stored_type();
    hdf5pp::Utils::createDataset(group, "config", dstype, chunkPolicy.chunkSize(dstype), chunkPolicy.chunkCacheSize(dstype), deflate, shuffle);    
  }
}

void store_ConfigV2_v0(const Psana::CsPad::ConfigV2* obj, hdf5pp::Group group, long index, bool append)
{
  if (obj) {
    CsPad::ns_ConfigV2_v0::dataset_config ds_data(*obj);
    if (append) {
      hdf5pp::Utils::storeAt(group, "config", ds_data, index);
    } else {
      hdf5pp::Utils::storeScalar(group, "config", ds_data);
    }
  } else if (append) {
    hdf5pp::Utils::resizeDataset(group, "config", index < 0 ? index : index + 1);
  }
}

boost::shared_ptr<PSEvt::Proxy<Psana::CsPad::ConfigV2> > make_ConfigV2(int version, hdf5pp::Group group, hsize_t idx) {
  switch (version) {
  case 0:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::ConfigV2> >(boost::make_shared<ConfigV2_v0>(group, idx));
  default:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::ConfigV2> >(boost::shared_ptr<Psana::CsPad::ConfigV2>());
  }
}

void make_datasets(const Psana::CsPad::ConfigV2& obj, hdf5pp::Group group, const ChunkPolicy& chunkPolicy,
                   int deflate, bool shuffle, int version)
{
  if (version < 0) version = 0;
  group.createAttr<uint32_t>("_schemaVersion").store(version);
  switch (version) {
  case 0:
    make_datasets_ConfigV2_v0(obj, group, chunkPolicy, deflate, shuffle);
    break;
  default:
    throw ExceptionSchemaVersion(ERR_LOC, "CsPad.ConfigV2", version);
  }
}

void store_ConfigV2(const Psana::CsPad::ConfigV2* obj, hdf5pp::Group group, long index, int version, bool append)
{
  if (version < 0) version = 0;
  if (not append) group.createAttr<uint32_t>("_schemaVersion").store(version);
  switch (version) {
  case 0:
    store_ConfigV2_v0(obj, group, index, append);
    break;
  default:
    throw ExceptionSchemaVersion(ERR_LOC, "CsPad.ConfigV2", version);
  }
}

void store(const Psana::CsPad::ConfigV2& obj, hdf5pp::Group group, int version) 
{
  store_ConfigV2(&obj, group, 0, version, false);
}

void store_at(const Psana::CsPad::ConfigV2* obj, hdf5pp::Group group, long index, int version)
{
  store_ConfigV2(obj, group, index, version, true);
}


hdf5pp::Type ns_ConfigV3_v0_dataset_config_stored_type()
{
  typedef ns_ConfigV3_v0::dataset_config DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("concentratorVersion", offsetof(DsType, concentratorVersion), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("runDelay", offsetof(DsType, runDelay), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("eventCode", offsetof(DsType, eventCode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("protectionEnable", offsetof(DsType, protectionEnable), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("inactiveRunMode", offsetof(DsType, inactiveRunMode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("activeRunMode", offsetof(DsType, activeRunMode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("testDataIndex", offsetof(DsType, testDataIndex), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("payloadPerQuad", offsetof(DsType, payloadPerQuad), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("badAsicMask0", offsetof(DsType, badAsicMask0), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("badAsicMask1", offsetof(DsType, badAsicMask1), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("asicMask", offsetof(DsType, asicMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("quadMask", offsetof(DsType, quadMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("roiMask", offsetof(DsType, roiMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  hsize_t _array_type_protectionThresholds_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_protectionThresholds = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ProtectionSystemThreshold_v0::dataset_data>::stored_type(), 1, _array_type_protectionThresholds_shape);
  type.insert("protectionThresholds", offsetof(DsType, protectionThresholds), _array_type_protectionThresholds);
  hsize_t _array_type_quads_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_quads = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ConfigV1QuadReg_v0::dataset_data>::stored_type(), 1, _array_type_quads_shape);
  type.insert("quads", offsetof(DsType, quads), _array_type_quads);
  hsize_t _array_type_sections_shape[] = { 4, 8 };
  hdf5pp::ArrayType _array_type_sections = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<int8_t>::stored_type(), 2, _array_type_sections_shape);
  type.insert("sections", offsetof(DsType, sections), _array_type_sections);
  return type;
}

hdf5pp::Type ns_ConfigV3_v0::dataset_config::stored_type()
{
  static hdf5pp::Type type = ns_ConfigV3_v0_dataset_config_stored_type();
  return type;
}

hdf5pp::Type ns_ConfigV3_v0_dataset_config_native_type()
{
  typedef ns_ConfigV3_v0::dataset_config DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("concentratorVersion", offsetof(DsType, concentratorVersion), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("runDelay", offsetof(DsType, runDelay), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("eventCode", offsetof(DsType, eventCode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("protectionEnable", offsetof(DsType, protectionEnable), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("inactiveRunMode", offsetof(DsType, inactiveRunMode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("activeRunMode", offsetof(DsType, activeRunMode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("testDataIndex", offsetof(DsType, testDataIndex), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("payloadPerQuad", offsetof(DsType, payloadPerQuad), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("badAsicMask0", offsetof(DsType, badAsicMask0), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("badAsicMask1", offsetof(DsType, badAsicMask1), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("asicMask", offsetof(DsType, asicMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("quadMask", offsetof(DsType, quadMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("roiMask", offsetof(DsType, roiMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  hsize_t _array_type_protectionThresholds_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_protectionThresholds = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ProtectionSystemThreshold_v0::dataset_data>::native_type(), 1, _array_type_protectionThresholds_shape);
  type.insert("protectionThresholds", offsetof(DsType, protectionThresholds), _array_type_protectionThresholds);
  hsize_t _array_type_quads_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_quads = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ConfigV1QuadReg_v0::dataset_data>::native_type(), 1, _array_type_quads_shape);
  type.insert("quads", offsetof(DsType, quads), _array_type_quads);
  hsize_t _array_type_sections_shape[] = { 4, 8 };
  hdf5pp::ArrayType _array_type_sections = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<int8_t>::native_type(), 2, _array_type_sections_shape);
  type.insert("sections", offsetof(DsType, sections), _array_type_sections);
  return type;
}

hdf5pp::Type ns_ConfigV3_v0::dataset_config::native_type()
{
  static hdf5pp::Type type = ns_ConfigV3_v0_dataset_config_native_type();
  return type;
}

ns_ConfigV3_v0::dataset_config::dataset_config()
{
}

ns_ConfigV3_v0::dataset_config::dataset_config(const Psana::CsPad::ConfigV3& psanaobj)
  : concentratorVersion(psanaobj.concentratorVersion())
  , runDelay(psanaobj.runDelay())
  , eventCode(psanaobj.eventCode())
  , protectionEnable(psanaobj.protectionEnable())
  , inactiveRunMode(psanaobj.inactiveRunMode())
  , activeRunMode(psanaobj.activeRunMode())
  , testDataIndex(psanaobj.tdi())
  , payloadPerQuad(psanaobj.payloadSize())
  , badAsicMask0(psanaobj.badAsicMask0())
  , badAsicMask1(psanaobj.badAsicMask1())
  , asicMask(psanaobj.asicMask())
  , quadMask(psanaobj.quadMask())
  , roiMask(psanaobj.roiMasks())
{
  {
    const __typeof__(psanaobj.protectionThresholds())& arr = psanaobj.protectionThresholds();
    std::copy(arr.begin(), arr.begin()+4, protectionThresholds);
  }
  for (size_t i = 0, len = 4; i != len; ++ i) {
    quads[i] = CsPad::ns_ConfigV1QuadReg_v0::dataset_data(psanaobj.quads(i));
  }
  init_attr_sections();
}

ns_ConfigV3_v0::dataset_config::~dataset_config()
{
}
uint32_t ConfigV3_v0::concentratorVersion() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->concentratorVersion);
}
uint32_t ConfigV3_v0::runDelay() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->runDelay);
}
uint32_t ConfigV3_v0::eventCode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->eventCode);
}
ndarray<const Psana::CsPad::ProtectionSystemThreshold, 1> ConfigV3_v0::protectionThresholds() const {
  if (not m_ds_config) read_ds_config();
  if (m_ds_storage_config_protectionThresholds.empty()) {
    unsigned shape[] = {MaxQuadsPerSensor};
    ndarray<Psana::CsPad::ProtectionSystemThreshold, 1> tmparr(shape);
    unsigned size = tmparr.size();
    ndarray<Psana::CsPad::ProtectionSystemThreshold, 1>::iterator it = tmparr.begin();
    for (unsigned i = 0; i != size; ++ i, ++ it) {
      *it = Psana::CsPad::ProtectionSystemThreshold(m_ds_config->protectionThresholds[i]);
    }
    m_ds_storage_config_protectionThresholds = tmparr;
  }
  return m_ds_storage_config_protectionThresholds;
}
uint32_t ConfigV3_v0::protectionEnable() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->protectionEnable);
}
uint32_t ConfigV3_v0::inactiveRunMode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->inactiveRunMode);
}
uint32_t ConfigV3_v0::activeRunMode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->activeRunMode);
}
uint32_t ConfigV3_v0::tdi() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->testDataIndex);
}
uint32_t ConfigV3_v0::payloadSize() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->payloadPerQuad);
}
uint32_t ConfigV3_v0::badAsicMask0() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->badAsicMask0);
}
uint32_t ConfigV3_v0::badAsicMask1() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->badAsicMask1);
}
uint32_t ConfigV3_v0::asicMask() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->asicMask);
}
uint32_t ConfigV3_v0::quadMask() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->quadMask);
}
uint32_t ConfigV3_v0::roiMasks() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->roiMask);
}
const Psana::CsPad::ConfigV1QuadReg& ConfigV3_v0::quads(uint32_t i0) const {
  if (not m_ds_config) read_ds_config();
  if (m_ds_storage_config_quads.empty()) {
    unsigned shape[] = {MaxQuadsPerSensor};
    ndarray<ConfigV1QuadReg_v0, 1> tmparr(shape);
    for (int i = 0; i != 4; ++ i) {
      boost::shared_ptr<CsPad::ns_ConfigV1QuadReg_v0::dataset_data> ptr(m_ds_config, &m_ds_config->quads[i]);
      tmparr.begin()[i] = ConfigV1QuadReg_v0(ptr);
    }
    m_ds_storage_config_quads = tmparr;
  }
  return m_ds_storage_config_quads[i0];
}
uint32_t
ConfigV3_v0::numAsicsRead() const{ 
return (this->asicMask() & 0xf)==1 ? 4 : 16; 
}
uint32_t
ConfigV3_v0::roiMask(uint32_t iq) const{ 
return (this->roiMasks() >> (8*iq)) & 0xff; 
}
uint32_t
ConfigV3_v0::numAsicsStored(uint32_t iq) const{ 
return __builtin_popcount(this->roiMask(iq))*2; 
}
uint32_t
ConfigV3_v0::numQuads() const{ 
return __builtin_popcount(this->quadMask()); 
}
uint32_t
ConfigV3_v0::numSect() const{ 
return __builtin_popcount(this->roiMasks()); 
}
std::vector<int>
ConfigV3_v0::quads_shape() const{ 
  int shape[] = { MaxQuadsPerSensor };
  return std::vector<int>(shape, shape+1); 
}
void ConfigV3_v0::read_ds_config() const {
  m_ds_config = hdf5pp::Utils::readGroup<CsPad::ns_ConfigV3_v0::dataset_config>(m_group, "config", m_idx);
}

void make_datasets_ConfigV3_v0(const Psana::CsPad::ConfigV3& obj, 
      hdf5pp::Group group, const ChunkPolicy& chunkPolicy, int deflate, bool shuffle)
{
  {
    hdf5pp::Type dstype = CsPad::ns_ConfigV3_v0::dataset_config::stored_type();
    hdf5pp::Utils::createDataset(group, "config", dstype, chunkPolicy.chunkSize(dstype), chunkPolicy.chunkCacheSize(dstype), deflate, shuffle);    
  }
}

void store_ConfigV3_v0(const Psana::CsPad::ConfigV3* obj, hdf5pp::Group group, long index, bool append)
{
  if (obj) {
    CsPad::ns_ConfigV3_v0::dataset_config ds_data(*obj);
    if (append) {
      hdf5pp::Utils::storeAt(group, "config", ds_data, index);
    } else {
      hdf5pp::Utils::storeScalar(group, "config", ds_data);
    }
  } else if (append) {
    hdf5pp::Utils::resizeDataset(group, "config", index < 0 ? index : index + 1);
  }
}

boost::shared_ptr<PSEvt::Proxy<Psana::CsPad::ConfigV3> > make_ConfigV3(int version, hdf5pp::Group group, hsize_t idx) {
  switch (version) {
  case 0:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::ConfigV3> >(boost::make_shared<ConfigV3_v0>(group, idx));
  default:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::ConfigV3> >(boost::shared_ptr<Psana::CsPad::ConfigV3>());
  }
}

void make_datasets(const Psana::CsPad::ConfigV3& obj, hdf5pp::Group group, const ChunkPolicy& chunkPolicy,
                   int deflate, bool shuffle, int version)
{
  if (version < 0) version = 0;
  group.createAttr<uint32_t>("_schemaVersion").store(version);
  switch (version) {
  case 0:
    make_datasets_ConfigV3_v0(obj, group, chunkPolicy, deflate, shuffle);
    break;
  default:
    throw ExceptionSchemaVersion(ERR_LOC, "CsPad.ConfigV3", version);
  }
}

void store_ConfigV3(const Psana::CsPad::ConfigV3* obj, hdf5pp::Group group, long index, int version, bool append)
{
  if (version < 0) version = 0;
  if (not append) group.createAttr<uint32_t>("_schemaVersion").store(version);
  switch (version) {
  case 0:
    store_ConfigV3_v0(obj, group, index, append);
    break;
  default:
    throw ExceptionSchemaVersion(ERR_LOC, "CsPad.ConfigV3", version);
  }
}

void store(const Psana::CsPad::ConfigV3& obj, hdf5pp::Group group, int version) 
{
  store_ConfigV3(&obj, group, 0, version, false);
}

void store_at(const Psana::CsPad::ConfigV3* obj, hdf5pp::Group group, long index, int version)
{
  store_ConfigV3(obj, group, index, version, true);
}


hdf5pp::Type ns_ConfigV4_v0_dataset_config_stored_type()
{
  typedef ns_ConfigV4_v0::dataset_config DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("concentratorVersion", offsetof(DsType, concentratorVersion), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("runDelay", offsetof(DsType, runDelay), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("eventCode", offsetof(DsType, eventCode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("protectionEnable", offsetof(DsType, protectionEnable), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("inactiveRunMode", offsetof(DsType, inactiveRunMode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("activeRunMode", offsetof(DsType, activeRunMode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("testDataIndex", offsetof(DsType, testDataIndex), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("payloadPerQuad", offsetof(DsType, payloadPerQuad), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("badAsicMask0", offsetof(DsType, badAsicMask0), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("badAsicMask1", offsetof(DsType, badAsicMask1), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("asicMask", offsetof(DsType, asicMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("quadMask", offsetof(DsType, quadMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("roiMask", offsetof(DsType, roiMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  hsize_t _array_type_protectionThresholds_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_protectionThresholds = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ProtectionSystemThreshold_v0::dataset_data>::stored_type(), 1, _array_type_protectionThresholds_shape);
  type.insert("protectionThresholds", offsetof(DsType, protectionThresholds), _array_type_protectionThresholds);
  hsize_t _array_type_quads_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_quads = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ConfigV2QuadReg_v0::dataset_data>::stored_type(), 1, _array_type_quads_shape);
  type.insert("quads", offsetof(DsType, quads), _array_type_quads);
  hsize_t _array_type_sections_shape[] = { 4, 8 };
  hdf5pp::ArrayType _array_type_sections = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<int8_t>::stored_type(), 2, _array_type_sections_shape);
  type.insert("sections", offsetof(DsType, sections), _array_type_sections);
  return type;
}

hdf5pp::Type ns_ConfigV4_v0::dataset_config::stored_type()
{
  static hdf5pp::Type type = ns_ConfigV4_v0_dataset_config_stored_type();
  return type;
}

hdf5pp::Type ns_ConfigV4_v0_dataset_config_native_type()
{
  typedef ns_ConfigV4_v0::dataset_config DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("concentratorVersion", offsetof(DsType, concentratorVersion), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("runDelay", offsetof(DsType, runDelay), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("eventCode", offsetof(DsType, eventCode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("protectionEnable", offsetof(DsType, protectionEnable), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("inactiveRunMode", offsetof(DsType, inactiveRunMode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("activeRunMode", offsetof(DsType, activeRunMode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("testDataIndex", offsetof(DsType, testDataIndex), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("payloadPerQuad", offsetof(DsType, payloadPerQuad), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("badAsicMask0", offsetof(DsType, badAsicMask0), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("badAsicMask1", offsetof(DsType, badAsicMask1), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("asicMask", offsetof(DsType, asicMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("quadMask", offsetof(DsType, quadMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("roiMask", offsetof(DsType, roiMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  hsize_t _array_type_protectionThresholds_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_protectionThresholds = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ProtectionSystemThreshold_v0::dataset_data>::native_type(), 1, _array_type_protectionThresholds_shape);
  type.insert("protectionThresholds", offsetof(DsType, protectionThresholds), _array_type_protectionThresholds);
  hsize_t _array_type_quads_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_quads = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ConfigV2QuadReg_v0::dataset_data>::native_type(), 1, _array_type_quads_shape);
  type.insert("quads", offsetof(DsType, quads), _array_type_quads);
  hsize_t _array_type_sections_shape[] = { 4, 8 };
  hdf5pp::ArrayType _array_type_sections = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<int8_t>::native_type(), 2, _array_type_sections_shape);
  type.insert("sections", offsetof(DsType, sections), _array_type_sections);
  return type;
}

hdf5pp::Type ns_ConfigV4_v0::dataset_config::native_type()
{
  static hdf5pp::Type type = ns_ConfigV4_v0_dataset_config_native_type();
  return type;
}

ns_ConfigV4_v0::dataset_config::dataset_config()
{
}

ns_ConfigV4_v0::dataset_config::dataset_config(const Psana::CsPad::ConfigV4& psanaobj)
  : concentratorVersion(psanaobj.concentratorVersion())
  , runDelay(psanaobj.runDelay())
  , eventCode(psanaobj.eventCode())
  , protectionEnable(psanaobj.protectionEnable())
  , inactiveRunMode(psanaobj.inactiveRunMode())
  , activeRunMode(psanaobj.activeRunMode())
  , testDataIndex(psanaobj.tdi())
  , payloadPerQuad(psanaobj.payloadSize())
  , badAsicMask0(psanaobj.badAsicMask0())
  , badAsicMask1(psanaobj.badAsicMask1())
  , asicMask(psanaobj.asicMask())
  , quadMask(psanaobj.quadMask())
  , roiMask(psanaobj.roiMasks())
{
  {
    const __typeof__(psanaobj.protectionThresholds())& arr = psanaobj.protectionThresholds();
    std::copy(arr.begin(), arr.begin()+4, protectionThresholds);
  }
  for (size_t i = 0, len = 4; i != len; ++ i) {
    quads[i] = CsPad::ns_ConfigV2QuadReg_v0::dataset_data(psanaobj.quads(i));
  }
  init_attr_sections();
}

ns_ConfigV4_v0::dataset_config::~dataset_config()
{
}
uint32_t ConfigV4_v0::concentratorVersion() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->concentratorVersion);
}
uint32_t ConfigV4_v0::runDelay() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->runDelay);
}
uint32_t ConfigV4_v0::eventCode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->eventCode);
}
ndarray<const Psana::CsPad::ProtectionSystemThreshold, 1> ConfigV4_v0::protectionThresholds() const {
  if (not m_ds_config) read_ds_config();
  if (m_ds_storage_config_protectionThresholds.empty()) {
    unsigned shape[] = {MaxQuadsPerSensor};
    ndarray<Psana::CsPad::ProtectionSystemThreshold, 1> tmparr(shape);
    unsigned size = tmparr.size();
    ndarray<Psana::CsPad::ProtectionSystemThreshold, 1>::iterator it = tmparr.begin();
    for (unsigned i = 0; i != size; ++ i, ++ it) {
      *it = Psana::CsPad::ProtectionSystemThreshold(m_ds_config->protectionThresholds[i]);
    }
    m_ds_storage_config_protectionThresholds = tmparr;
  }
  return m_ds_storage_config_protectionThresholds;
}
uint32_t ConfigV4_v0::protectionEnable() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->protectionEnable);
}
uint32_t ConfigV4_v0::inactiveRunMode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->inactiveRunMode);
}
uint32_t ConfigV4_v0::activeRunMode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->activeRunMode);
}
uint32_t ConfigV4_v0::tdi() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->testDataIndex);
}
uint32_t ConfigV4_v0::payloadSize() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->payloadPerQuad);
}
uint32_t ConfigV4_v0::badAsicMask0() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->badAsicMask0);
}
uint32_t ConfigV4_v0::badAsicMask1() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->badAsicMask1);
}
uint32_t ConfigV4_v0::asicMask() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->asicMask);
}
uint32_t ConfigV4_v0::quadMask() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->quadMask);
}
uint32_t ConfigV4_v0::roiMasks() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->roiMask);
}
const Psana::CsPad::ConfigV2QuadReg& ConfigV4_v0::quads(uint32_t i0) const {
  if (not m_ds_config) read_ds_config();
  if (m_ds_storage_config_quads.empty()) {
    unsigned shape[] = {MaxQuadsPerSensor};
    ndarray<ConfigV2QuadReg_v0, 1> tmparr(shape);
    for (int i = 0; i != 4; ++ i) {
      boost::shared_ptr<CsPad::ns_ConfigV2QuadReg_v0::dataset_data> ptr(m_ds_config, &m_ds_config->quads[i]);
      tmparr.begin()[i] = ConfigV2QuadReg_v0(ptr);
    }
    m_ds_storage_config_quads = tmparr;
  }
  return m_ds_storage_config_quads[i0];
}
uint32_t
ConfigV4_v0::numAsicsRead() const{ 
return (this->asicMask() & 0xf)==1 ? 4 : 16; 
}
uint32_t
ConfigV4_v0::roiMask(uint32_t iq) const{ 
return (this->roiMasks() >> (8*iq)) & 0xff; 
}
uint32_t
ConfigV4_v0::numAsicsStored(uint32_t iq) const{ 
return __builtin_popcount(this->roiMask(iq))*2; 
}
uint32_t
ConfigV4_v0::numQuads() const{ 
return __builtin_popcount(this->quadMask()); 
}
uint32_t
ConfigV4_v0::numSect() const{ 
return __builtin_popcount(this->roiMasks()); 
}
std::vector<int>
ConfigV4_v0::quads_shape() const{ 
  int shape[] = { MaxQuadsPerSensor };
  return std::vector<int>(shape, shape+1); 
}
void ConfigV4_v0::read_ds_config() const {
  m_ds_config = hdf5pp::Utils::readGroup<CsPad::ns_ConfigV4_v0::dataset_config>(m_group, "config", m_idx);
}

void make_datasets_ConfigV4_v0(const Psana::CsPad::ConfigV4& obj, 
      hdf5pp::Group group, const ChunkPolicy& chunkPolicy, int deflate, bool shuffle)
{
  {
    hdf5pp::Type dstype = CsPad::ns_ConfigV4_v0::dataset_config::stored_type();
    hdf5pp::Utils::createDataset(group, "config", dstype, chunkPolicy.chunkSize(dstype), chunkPolicy.chunkCacheSize(dstype), deflate, shuffle);    
  }
}

void store_ConfigV4_v0(const Psana::CsPad::ConfigV4* obj, hdf5pp::Group group, long index, bool append)
{
  if (obj) {
    CsPad::ns_ConfigV4_v0::dataset_config ds_data(*obj);
    if (append) {
      hdf5pp::Utils::storeAt(group, "config", ds_data, index);
    } else {
      hdf5pp::Utils::storeScalar(group, "config", ds_data);
    }
  } else if (append) {
    hdf5pp::Utils::resizeDataset(group, "config", index < 0 ? index : index + 1);
  }
}

boost::shared_ptr<PSEvt::Proxy<Psana::CsPad::ConfigV4> > make_ConfigV4(int version, hdf5pp::Group group, hsize_t idx) {
  switch (version) {
  case 0:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::ConfigV4> >(boost::make_shared<ConfigV4_v0>(group, idx));
  default:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::ConfigV4> >(boost::shared_ptr<Psana::CsPad::ConfigV4>());
  }
}

void make_datasets(const Psana::CsPad::ConfigV4& obj, hdf5pp::Group group, const ChunkPolicy& chunkPolicy,
                   int deflate, bool shuffle, int version)
{
  if (version < 0) version = 0;
  group.createAttr<uint32_t>("_schemaVersion").store(version);
  switch (version) {
  case 0:
    make_datasets_ConfigV4_v0(obj, group, chunkPolicy, deflate, shuffle);
    break;
  default:
    throw ExceptionSchemaVersion(ERR_LOC, "CsPad.ConfigV4", version);
  }
}

void store_ConfigV4(const Psana::CsPad::ConfigV4* obj, hdf5pp::Group group, long index, int version, bool append)
{
  if (version < 0) version = 0;
  if (not append) group.createAttr<uint32_t>("_schemaVersion").store(version);
  switch (version) {
  case 0:
    store_ConfigV4_v0(obj, group, index, append);
    break;
  default:
    throw ExceptionSchemaVersion(ERR_LOC, "CsPad.ConfigV4", version);
  }
}

void store(const Psana::CsPad::ConfigV4& obj, hdf5pp::Group group, int version) 
{
  store_ConfigV4(&obj, group, 0, version, false);
}

void store_at(const Psana::CsPad::ConfigV4* obj, hdf5pp::Group group, long index, int version)
{
  store_ConfigV4(obj, group, index, version, true);
}


hdf5pp::Type ns_ConfigV5_v0_dataset_config_stored_type()
{
  typedef ns_ConfigV5_v0::dataset_config DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("concentratorVersion", offsetof(DsType, concentratorVersion), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("runDelay", offsetof(DsType, runDelay), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("eventCode", offsetof(DsType, eventCode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("protectionEnable", offsetof(DsType, protectionEnable), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("inactiveRunMode", offsetof(DsType, inactiveRunMode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("activeRunMode", offsetof(DsType, activeRunMode), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("internalTriggerDelay", offsetof(DsType, internalTriggerDelay), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("testDataIndex", offsetof(DsType, testDataIndex), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("payloadPerQuad", offsetof(DsType, payloadPerQuad), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("badAsicMask0", offsetof(DsType, badAsicMask0), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("badAsicMask1", offsetof(DsType, badAsicMask1), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("asicMask", offsetof(DsType, asicMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("quadMask", offsetof(DsType, quadMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("roiMask", offsetof(DsType, roiMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  hsize_t _array_type_protectionThresholds_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_protectionThresholds = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ProtectionSystemThreshold_v0::dataset_data>::stored_type(), 1, _array_type_protectionThresholds_shape);
  type.insert("protectionThresholds", offsetof(DsType, protectionThresholds), _array_type_protectionThresholds);
  hsize_t _array_type_quads_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_quads = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ConfigV3QuadReg_v0::dataset_data>::stored_type(), 1, _array_type_quads_shape);
  type.insert("quads", offsetof(DsType, quads), _array_type_quads);
  hsize_t _array_type_sections_shape[] = { 4, 8 };
  hdf5pp::ArrayType _array_type_sections = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<int8_t>::stored_type(), 2, _array_type_sections_shape);
  type.insert("sections", offsetof(DsType, sections), _array_type_sections);
  return type;
}

hdf5pp::Type ns_ConfigV5_v0::dataset_config::stored_type()
{
  static hdf5pp::Type type = ns_ConfigV5_v0_dataset_config_stored_type();
  return type;
}

hdf5pp::Type ns_ConfigV5_v0_dataset_config_native_type()
{
  typedef ns_ConfigV5_v0::dataset_config DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("concentratorVersion", offsetof(DsType, concentratorVersion), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("runDelay", offsetof(DsType, runDelay), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("eventCode", offsetof(DsType, eventCode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("protectionEnable", offsetof(DsType, protectionEnable), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("inactiveRunMode", offsetof(DsType, inactiveRunMode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("activeRunMode", offsetof(DsType, activeRunMode), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("internalTriggerDelay", offsetof(DsType, internalTriggerDelay), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("testDataIndex", offsetof(DsType, testDataIndex), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("payloadPerQuad", offsetof(DsType, payloadPerQuad), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("badAsicMask0", offsetof(DsType, badAsicMask0), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("badAsicMask1", offsetof(DsType, badAsicMask1), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("asicMask", offsetof(DsType, asicMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("quadMask", offsetof(DsType, quadMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("roiMask", offsetof(DsType, roiMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  hsize_t _array_type_protectionThresholds_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_protectionThresholds = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ProtectionSystemThreshold_v0::dataset_data>::native_type(), 1, _array_type_protectionThresholds_shape);
  type.insert("protectionThresholds", offsetof(DsType, protectionThresholds), _array_type_protectionThresholds);
  hsize_t _array_type_quads_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_quads = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<CsPad::ns_ConfigV3QuadReg_v0::dataset_data>::native_type(), 1, _array_type_quads_shape);
  type.insert("quads", offsetof(DsType, quads), _array_type_quads);
  hsize_t _array_type_sections_shape[] = { 4, 8 };
  hdf5pp::ArrayType _array_type_sections = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<int8_t>::native_type(), 2, _array_type_sections_shape);
  type.insert("sections", offsetof(DsType, sections), _array_type_sections);
  return type;
}

hdf5pp::Type ns_ConfigV5_v0::dataset_config::native_type()
{
  static hdf5pp::Type type = ns_ConfigV5_v0_dataset_config_native_type();
  return type;
}

ns_ConfigV5_v0::dataset_config::dataset_config()
{
}

ns_ConfigV5_v0::dataset_config::dataset_config(const Psana::CsPad::ConfigV5& psanaobj)
  : concentratorVersion(psanaobj.concentratorVersion())
  , runDelay(psanaobj.runDelay())
  , eventCode(psanaobj.eventCode())
  , protectionEnable(psanaobj.protectionEnable())
  , inactiveRunMode(psanaobj.inactiveRunMode())
  , activeRunMode(psanaobj.activeRunMode())
  , internalTriggerDelay(psanaobj.internalTriggerDelay())
  , testDataIndex(psanaobj.tdi())
  , payloadPerQuad(psanaobj.payloadSize())
  , badAsicMask0(psanaobj.badAsicMask0())
  , badAsicMask1(psanaobj.badAsicMask1())
  , asicMask(psanaobj.asicMask())
  , quadMask(psanaobj.quadMask())
  , roiMask(psanaobj.roiMasks())
{
  {
    const __typeof__(psanaobj.protectionThresholds())& arr = psanaobj.protectionThresholds();
    std::copy(arr.begin(), arr.begin()+4, protectionThresholds);
  }
  for (size_t i = 0, len = 4; i != len; ++ i) {
    quads[i] = CsPad::ns_ConfigV3QuadReg_v0::dataset_data(psanaobj.quads(i));
  }
  init_attr_sections();
}

ns_ConfigV5_v0::dataset_config::~dataset_config()
{
}
uint32_t ConfigV5_v0::concentratorVersion() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->concentratorVersion);
}
uint32_t ConfigV5_v0::runDelay() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->runDelay);
}
uint32_t ConfigV5_v0::eventCode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->eventCode);
}
ndarray<const Psana::CsPad::ProtectionSystemThreshold, 1> ConfigV5_v0::protectionThresholds() const {
  if (not m_ds_config) read_ds_config();
  if (m_ds_storage_config_protectionThresholds.empty()) {
    unsigned shape[] = {MaxQuadsPerSensor};
    ndarray<Psana::CsPad::ProtectionSystemThreshold, 1> tmparr(shape);
    unsigned size = tmparr.size();
    ndarray<Psana::CsPad::ProtectionSystemThreshold, 1>::iterator it = tmparr.begin();
    for (unsigned i = 0; i != size; ++ i, ++ it) {
      *it = Psana::CsPad::ProtectionSystemThreshold(m_ds_config->protectionThresholds[i]);
    }
    m_ds_storage_config_protectionThresholds = tmparr;
  }
  return m_ds_storage_config_protectionThresholds;
}
uint32_t ConfigV5_v0::protectionEnable() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->protectionEnable);
}
uint32_t ConfigV5_v0::inactiveRunMode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->inactiveRunMode);
}
uint32_t ConfigV5_v0::activeRunMode() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->activeRunMode);
}
uint32_t ConfigV5_v0::internalTriggerDelay() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->internalTriggerDelay);
}
uint32_t ConfigV5_v0::tdi() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->testDataIndex);
}
uint32_t ConfigV5_v0::payloadSize() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->payloadPerQuad);
}
uint32_t ConfigV5_v0::badAsicMask0() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->badAsicMask0);
}
uint32_t ConfigV5_v0::badAsicMask1() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->badAsicMask1);
}
uint32_t ConfigV5_v0::asicMask() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->asicMask);
}
uint32_t ConfigV5_v0::quadMask() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->quadMask);
}
uint32_t ConfigV5_v0::roiMasks() const {
  if (not m_ds_config) read_ds_config();
  return uint32_t(m_ds_config->roiMask);
}
const Psana::CsPad::ConfigV3QuadReg& ConfigV5_v0::quads(uint32_t i0) const {
  if (not m_ds_config) read_ds_config();
  if (m_ds_storage_config_quads.empty()) {
    unsigned shape[] = {MaxQuadsPerSensor};
    ndarray<ConfigV3QuadReg_v0, 1> tmparr(shape);
    for (int i = 0; i != 4; ++ i) {
      boost::shared_ptr<CsPad::ns_ConfigV3QuadReg_v0::dataset_data> ptr(m_ds_config, &m_ds_config->quads[i]);
      tmparr.begin()[i] = ConfigV3QuadReg_v0(ptr);
    }
    m_ds_storage_config_quads = tmparr;
  }
  return m_ds_storage_config_quads[i0];
}
uint32_t
ConfigV5_v0::numAsicsRead() const{ 
return (this->asicMask() & 0xf)==1 ? 4 : 16; 
}
uint32_t
ConfigV5_v0::roiMask(uint32_t iq) const{ 
return (this->roiMasks() >> (8*iq)) & 0xff; 
}
uint32_t
ConfigV5_v0::numAsicsStored(uint32_t iq) const{ 
return __builtin_popcount(this->roiMask(iq))*2; 
}
uint32_t
ConfigV5_v0::numQuads() const{ 
return __builtin_popcount(this->quadMask()); 
}
uint32_t
ConfigV5_v0::numSect() const{ 
return __builtin_popcount(this->roiMasks()); 
}
std::vector<int>
ConfigV5_v0::quads_shape() const{ 
  int shape[] = { MaxQuadsPerSensor };
  return std::vector<int>(shape, shape+1); 
}
void ConfigV5_v0::read_ds_config() const {
  m_ds_config = hdf5pp::Utils::readGroup<CsPad::ns_ConfigV5_v0::dataset_config>(m_group, "config", m_idx);
}

void make_datasets_ConfigV5_v0(const Psana::CsPad::ConfigV5& obj, 
      hdf5pp::Group group, const ChunkPolicy& chunkPolicy, int deflate, bool shuffle)
{
  {
    hdf5pp::Type dstype = CsPad::ns_ConfigV5_v0::dataset_config::stored_type();
    hdf5pp::Utils::createDataset(group, "config", dstype, chunkPolicy.chunkSize(dstype), chunkPolicy.chunkCacheSize(dstype), deflate, shuffle);    
  }
}

void store_ConfigV5_v0(const Psana::CsPad::ConfigV5* obj, hdf5pp::Group group, long index, bool append)
{
  if (obj) {
    CsPad::ns_ConfigV5_v0::dataset_config ds_data(*obj);
    if (append) {
      hdf5pp::Utils::storeAt(group, "config", ds_data, index);
    } else {
      hdf5pp::Utils::storeScalar(group, "config", ds_data);
    }
  } else if (append) {
    hdf5pp::Utils::resizeDataset(group, "config", index < 0 ? index : index + 1);
  }
}

boost::shared_ptr<PSEvt::Proxy<Psana::CsPad::ConfigV5> > make_ConfigV5(int version, hdf5pp::Group group, hsize_t idx) {
  switch (version) {
  case 0:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::ConfigV5> >(boost::make_shared<ConfigV5_v0>(group, idx));
  default:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::ConfigV5> >(boost::shared_ptr<Psana::CsPad::ConfigV5>());
  }
}

void make_datasets(const Psana::CsPad::ConfigV5& obj, hdf5pp::Group group, const ChunkPolicy& chunkPolicy,
                   int deflate, bool shuffle, int version)
{
  if (version < 0) version = 0;
  group.createAttr<uint32_t>("_schemaVersion").store(version);
  switch (version) {
  case 0:
    make_datasets_ConfigV5_v0(obj, group, chunkPolicy, deflate, shuffle);
    break;
  default:
    throw ExceptionSchemaVersion(ERR_LOC, "CsPad.ConfigV5", version);
  }
}

void store_ConfigV5(const Psana::CsPad::ConfigV5* obj, hdf5pp::Group group, long index, int version, bool append)
{
  if (version < 0) version = 0;
  if (not append) group.createAttr<uint32_t>("_schemaVersion").store(version);
  switch (version) {
  case 0:
    store_ConfigV5_v0(obj, group, index, append);
    break;
  default:
    throw ExceptionSchemaVersion(ERR_LOC, "CsPad.ConfigV5", version);
  }
}

void store(const Psana::CsPad::ConfigV5& obj, hdf5pp::Group group, int version) 
{
  store_ConfigV5(&obj, group, 0, version, false);
}

void store_at(const Psana::CsPad::ConfigV5* obj, hdf5pp::Group group, long index, int version)
{
  store_ConfigV5(obj, group, index, version, true);
}


hdf5pp::Type ns_ElementV1_v0_dataset_element_stored_type()
{
  typedef ns_ElementV1_v0::dataset_element DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("virtual_channel", offsetof(DsType, virtual_channel), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("lane", offsetof(DsType, lane), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("tid", offsetof(DsType, tid), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("acq_count", offsetof(DsType, acq_count), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("op_code", offsetof(DsType, op_code), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("quad", offsetof(DsType, quad), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("seq_count", offsetof(DsType, seq_count), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("ticks", offsetof(DsType, ticks), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("fiducials", offsetof(DsType, fiducials), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("frame_type", offsetof(DsType, frame_type), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("sectionMask", offsetof(DsType, sectionMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  hsize_t _array_type_sb_temp_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_sb_temp = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint16_t>::stored_type(), 1, _array_type_sb_temp_shape);
  type.insert("sb_temp", offsetof(DsType, sb_temp), _array_type_sb_temp);
  return type;
}

hdf5pp::Type ns_ElementV1_v0::dataset_element::stored_type()
{
  static hdf5pp::Type type = ns_ElementV1_v0_dataset_element_stored_type();
  return type;
}

hdf5pp::Type ns_ElementV1_v0_dataset_element_native_type()
{
  typedef ns_ElementV1_v0::dataset_element DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("virtual_channel", offsetof(DsType, virtual_channel), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("lane", offsetof(DsType, lane), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("tid", offsetof(DsType, tid), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("acq_count", offsetof(DsType, acq_count), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("op_code", offsetof(DsType, op_code), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("quad", offsetof(DsType, quad), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("seq_count", offsetof(DsType, seq_count), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("ticks", offsetof(DsType, ticks), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("fiducials", offsetof(DsType, fiducials), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("frame_type", offsetof(DsType, frame_type), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("sectionMask", offsetof(DsType, sectionMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  hsize_t _array_type_sb_temp_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_sb_temp = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint16_t>::native_type(), 1, _array_type_sb_temp_shape);
  type.insert("sb_temp", offsetof(DsType, sb_temp), _array_type_sb_temp);
  return type;
}

hdf5pp::Type ns_ElementV1_v0::dataset_element::native_type()
{
  static hdf5pp::Type type = ns_ElementV1_v0_dataset_element_native_type();
  return type;
}

ns_ElementV1_v0::dataset_element::dataset_element()
{
}

ns_ElementV1_v0::dataset_element::dataset_element(const Psana::CsPad::ElementV1& psanaobj)
  : virtual_channel(psanaobj.virtual_channel())
  , lane(psanaobj.lane())
  , tid(psanaobj.tid())
  , acq_count(psanaobj.acq_count())
  , op_code(psanaobj.op_code())
  , quad(psanaobj.quad())
  , seq_count(psanaobj.seq_count())
  , ticks(psanaobj.ticks())
  , fiducials(psanaobj.fiducials())
  , frame_type(psanaobj.frame_type())
  , sectionMask(psanaobj.sectionMask())
{
  {
    const __typeof__(psanaobj.sb_temp())& arr = psanaobj.sb_temp();
    std::copy(arr.begin(), arr.begin()+4, sb_temp);
  }
}

ns_ElementV1_v0::dataset_element::~dataset_element()
{
}
template <typename Config>
uint32_t ElementV1_v0<Config>::virtual_channel() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->virtual_channel);
}
template <typename Config>
uint32_t ElementV1_v0<Config>::lane() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->lane);
}
template <typename Config>
uint32_t ElementV1_v0<Config>::tid() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->tid);
}
template <typename Config>
uint32_t ElementV1_v0<Config>::acq_count() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->acq_count);
}
template <typename Config>
uint32_t ElementV1_v0<Config>::op_code() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->op_code);
}
template <typename Config>
uint32_t ElementV1_v0<Config>::quad() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->quad);
}
template <typename Config>
uint32_t ElementV1_v0<Config>::seq_count() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->seq_count);
}
template <typename Config>
uint32_t ElementV1_v0<Config>::ticks() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->ticks);
}
template <typename Config>
uint32_t ElementV1_v0<Config>::fiducials() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->fiducials);
}
template <typename Config>
ndarray<const uint16_t, 1> ElementV1_v0<Config>::sb_temp() const {
  if (not m_ds_element) read_ds_element();
  boost::shared_ptr<uint16_t> ptr(m_ds_element, m_ds_element->sb_temp);
  return make_ndarray(ptr, Nsbtemp);
}
template <typename Config>
uint32_t ElementV1_v0<Config>::frame_type() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->frame_type);
}
template <typename Config>
ndarray<const int16_t, 3> ElementV1_v0<Config>::data() const {
  if (m_ds_data.empty()) read_ds_data();
  return m_ds_data;
}
template <typename Config>
uint32_t ElementV1_v0<Config>::sectionMask() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->sectionMask);
}
template <typename Config>
float
ElementV1_v0<Config>::common_mode(uint32_t section) const{ 
return 0; 
}
template <typename Config>
void ElementV1_v0<Config>::read_ds_element() const {
  m_ds_element = hdf5pp::Utils::readGroup<CsPad::ns_ElementV1_v0::dataset_element>(m_group, "element", m_idx);
}
template <typename Config>
void ElementV1_v0<Config>::read_ds_data() const {
  m_ds_data = hdf5pp::Utils::readNdarray<int16_t, 3>(m_group, "data", m_idx);
}
template class ElementV1_v0<Psana::CsPad::ConfigV1>;
template class ElementV1_v0<Psana::CsPad::ConfigV2>;
template class ElementV1_v0<Psana::CsPad::ConfigV3>;
template class ElementV1_v0<Psana::CsPad::ConfigV4>;
template class ElementV1_v0<Psana::CsPad::ConfigV5>;

void make_datasets_ElementV1_v0(const Psana::CsPad::ElementV1& obj, 
      hdf5pp::Group group, const ChunkPolicy& chunkPolicy, int deflate, bool shuffle)
{
  {
    hdf5pp::Type dstype = CsPad::ns_ElementV1_v0::dataset_element::stored_type();
    hdf5pp::Utils::createDataset(group, "element", dstype, chunkPolicy.chunkSize(dstype), chunkPolicy.chunkCacheSize(dstype), deflate, shuffle);    
  }
  {
    typedef __typeof__(obj.data()) PsanaArray;
    const PsanaArray& psana_array = obj.data();
    hsize_t dims[3];
    std::copy(psana_array.shape(), psana_array.shape()+3, dims);
    hdf5pp::Type dstype = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<int16_t>::stored_type(), 3, dims);
    hdf5pp::Utils::createDataset(group, "data", dstype, chunkPolicy.chunkSize(dstype), chunkPolicy.chunkCacheSize(dstype), deflate, shuffle);    
  }
}

void store_ElementV1_v0(const Psana::CsPad::ElementV1* obj, hdf5pp::Group group, long index, bool append)
{
  if (obj) {
    CsPad::ns_ElementV1_v0::dataset_element ds_data(*obj);
    if (append) {
      hdf5pp::Utils::storeAt(group, "element", ds_data, index);
    } else {
      hdf5pp::Utils::storeScalar(group, "element", ds_data);
    }
  } else if (append) {
    hdf5pp::Utils::resizeDataset(group, "element", index < 0 ? index : index + 1);
  }
  if (append) {
    if (obj) {
      hdf5pp::Utils::storeNDArrayAt(group, "data", obj->data(), index);
    } else {
      hdf5pp::Utils::resizeDataset(group, "data", index < 0 ? index : index + 1);
    }
  } else {
    hdf5pp::Utils::storeNDArray(group, "data", obj->data());
  }

}

boost::shared_ptr<PSEvt::Proxy<Psana::CsPad::DataV1> > make_DataV1(int version, hdf5pp::Group group, hsize_t idx, const boost::shared_ptr<Psana::CsPad::ConfigV1>& cfg) {
  switch (version) {
  case 0:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV1> >(boost::make_shared<DataV1_v0<Psana::CsPad::ConfigV1> >(group, idx, cfg));
  default:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV1> >(boost::shared_ptr<Psana::CsPad::DataV1>());
  }
}
boost::shared_ptr<PSEvt::Proxy<Psana::CsPad::DataV1> > make_DataV1(int version, hdf5pp::Group group, hsize_t idx, const boost::shared_ptr<Psana::CsPad::ConfigV2>& cfg) {
  switch (version) {
  case 0:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV1> >(boost::make_shared<DataV1_v0<Psana::CsPad::ConfigV2> >(group, idx, cfg));
  default:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV1> >(boost::shared_ptr<Psana::CsPad::DataV1>());
  }
}
boost::shared_ptr<PSEvt::Proxy<Psana::CsPad::DataV1> > make_DataV1(int version, hdf5pp::Group group, hsize_t idx, const boost::shared_ptr<Psana::CsPad::ConfigV3>& cfg) {
  switch (version) {
  case 0:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV1> >(boost::make_shared<DataV1_v0<Psana::CsPad::ConfigV3> >(group, idx, cfg));
  default:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV1> >(boost::shared_ptr<Psana::CsPad::DataV1>());
  }
}
boost::shared_ptr<PSEvt::Proxy<Psana::CsPad::DataV1> > make_DataV1(int version, hdf5pp::Group group, hsize_t idx, const boost::shared_ptr<Psana::CsPad::ConfigV4>& cfg) {
  switch (version) {
  case 0:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV1> >(boost::make_shared<DataV1_v0<Psana::CsPad::ConfigV4> >(group, idx, cfg));
  default:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV1> >(boost::shared_ptr<Psana::CsPad::DataV1>());
  }
}
boost::shared_ptr<PSEvt::Proxy<Psana::CsPad::DataV1> > make_DataV1(int version, hdf5pp::Group group, hsize_t idx, const boost::shared_ptr<Psana::CsPad::ConfigV5>& cfg) {
  switch (version) {
  case 0:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV1> >(boost::make_shared<DataV1_v0<Psana::CsPad::ConfigV5> >(group, idx, cfg));
  default:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV1> >(boost::shared_ptr<Psana::CsPad::DataV1>());
  }
}

void make_datasets(const Psana::CsPad::DataV1& obj, hdf5pp::Group group, const ChunkPolicy& chunkPolicy,
                   int deflate, bool shuffle, int version)
{
  if (version < 0) version = 0;
  group.createAttr<uint32_t>("_schemaVersion").store(version);
  switch (version) {
  case 0:
    make_datasets_DataV1_v0(obj, group, chunkPolicy, deflate, shuffle);
    break;
  default:
    throw ExceptionSchemaVersion(ERR_LOC, "CsPad.DataV1", version);
  }
}

void store_DataV1(const Psana::CsPad::DataV1* obj, hdf5pp::Group group, long index, int version, bool append)
{
  if (version < 0) version = 0;
  if (not append) group.createAttr<uint32_t>("_schemaVersion").store(version);
  switch (version) {
  case 0:
    store_DataV1_v0(obj, group, index, append);
    break;
  default:
    throw ExceptionSchemaVersion(ERR_LOC, "CsPad.DataV1", version);
  }
}

void store(const Psana::CsPad::DataV1& obj, hdf5pp::Group group, int version) 
{
  store_DataV1(&obj, group, 0, version, false);
}

void store_at(const Psana::CsPad::DataV1* obj, hdf5pp::Group group, long index, int version)
{
  store_DataV1(obj, group, index, version, true);
}


hdf5pp::Type ns_ElementV2_v0_dataset_element_stored_type()
{
  typedef ns_ElementV2_v0::dataset_element DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("virtual_channel", offsetof(DsType, virtual_channel), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("lane", offsetof(DsType, lane), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("tid", offsetof(DsType, tid), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("acq_count", offsetof(DsType, acq_count), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("op_code", offsetof(DsType, op_code), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("quad", offsetof(DsType, quad), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("seq_count", offsetof(DsType, seq_count), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("ticks", offsetof(DsType, ticks), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("fiducials", offsetof(DsType, fiducials), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("frame_type", offsetof(DsType, frame_type), hdf5pp::TypeTraits<uint32_t>::stored_type());
  type.insert("sectionMask", offsetof(DsType, sectionMask), hdf5pp::TypeTraits<uint32_t>::stored_type());
  hsize_t _array_type_sb_temp_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_sb_temp = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint16_t>::stored_type(), 1, _array_type_sb_temp_shape);
  type.insert("sb_temp", offsetof(DsType, sb_temp), _array_type_sb_temp);
  return type;
}

hdf5pp::Type ns_ElementV2_v0::dataset_element::stored_type()
{
  static hdf5pp::Type type = ns_ElementV2_v0_dataset_element_stored_type();
  return type;
}

hdf5pp::Type ns_ElementV2_v0_dataset_element_native_type()
{
  typedef ns_ElementV2_v0::dataset_element DsType;
  hdf5pp::CompoundType type = hdf5pp::CompoundType::compoundType<DsType>();
  type.insert("virtual_channel", offsetof(DsType, virtual_channel), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("lane", offsetof(DsType, lane), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("tid", offsetof(DsType, tid), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("acq_count", offsetof(DsType, acq_count), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("op_code", offsetof(DsType, op_code), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("quad", offsetof(DsType, quad), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("seq_count", offsetof(DsType, seq_count), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("ticks", offsetof(DsType, ticks), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("fiducials", offsetof(DsType, fiducials), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("frame_type", offsetof(DsType, frame_type), hdf5pp::TypeTraits<uint32_t>::native_type());
  type.insert("sectionMask", offsetof(DsType, sectionMask), hdf5pp::TypeTraits<uint32_t>::native_type());
  hsize_t _array_type_sb_temp_shape[] = { 4 };
  hdf5pp::ArrayType _array_type_sb_temp = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<uint16_t>::native_type(), 1, _array_type_sb_temp_shape);
  type.insert("sb_temp", offsetof(DsType, sb_temp), _array_type_sb_temp);
  return type;
}

hdf5pp::Type ns_ElementV2_v0::dataset_element::native_type()
{
  static hdf5pp::Type type = ns_ElementV2_v0_dataset_element_native_type();
  return type;
}

ns_ElementV2_v0::dataset_element::dataset_element()
{
}

ns_ElementV2_v0::dataset_element::dataset_element(const Psana::CsPad::ElementV2& psanaobj)
  : virtual_channel(psanaobj.virtual_channel())
  , lane(psanaobj.lane())
  , tid(psanaobj.tid())
  , acq_count(psanaobj.acq_count())
  , op_code(psanaobj.op_code())
  , quad(psanaobj.quad())
  , seq_count(psanaobj.seq_count())
  , ticks(psanaobj.ticks())
  , fiducials(psanaobj.fiducials())
  , frame_type(psanaobj.frame_type())
  , sectionMask(psanaobj.sectionMask())
{
  {
    const __typeof__(psanaobj.sb_temp())& arr = psanaobj.sb_temp();
    std::copy(arr.begin(), arr.begin()+4, sb_temp);
  }
}

ns_ElementV2_v0::dataset_element::~dataset_element()
{
}
template <typename Config>
uint32_t ElementV2_v0<Config>::virtual_channel() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->virtual_channel);
}
template <typename Config>
uint32_t ElementV2_v0<Config>::lane() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->lane);
}
template <typename Config>
uint32_t ElementV2_v0<Config>::tid() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->tid);
}
template <typename Config>
uint32_t ElementV2_v0<Config>::acq_count() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->acq_count);
}
template <typename Config>
uint32_t ElementV2_v0<Config>::op_code() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->op_code);
}
template <typename Config>
uint32_t ElementV2_v0<Config>::quad() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->quad);
}
template <typename Config>
uint32_t ElementV2_v0<Config>::seq_count() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->seq_count);
}
template <typename Config>
uint32_t ElementV2_v0<Config>::ticks() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->ticks);
}
template <typename Config>
uint32_t ElementV2_v0<Config>::fiducials() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->fiducials);
}
template <typename Config>
ndarray<const uint16_t, 1> ElementV2_v0<Config>::sb_temp() const {
  if (not m_ds_element) read_ds_element();
  boost::shared_ptr<uint16_t> ptr(m_ds_element, m_ds_element->sb_temp);
  return make_ndarray(ptr, Nsbtemp);
}
template <typename Config>
uint32_t ElementV2_v0<Config>::frame_type() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->frame_type);
}
template <typename Config>
ndarray<const int16_t, 3> ElementV2_v0<Config>::data() const {
  if (m_ds_data.empty()) read_ds_data();
  return m_ds_data;
}
template <typename Config>
uint32_t ElementV2_v0<Config>::sectionMask() const {
  if (not m_ds_element) read_ds_element();
  return uint32_t(m_ds_element->sectionMask);
}
template <typename Config>
float
ElementV2_v0<Config>::common_mode(uint32_t section) const{ 
return 0; 
}
template <typename Config>
void ElementV2_v0<Config>::read_ds_element() const {
  m_ds_element = hdf5pp::Utils::readGroup<CsPad::ns_ElementV2_v0::dataset_element>(m_group, "element", m_idx);
}
template <typename Config>
void ElementV2_v0<Config>::read_ds_data() const {
  m_ds_data = hdf5pp::Utils::readNdarray<int16_t, 3>(m_group, "data", m_idx);
}
template class ElementV2_v0<Psana::CsPad::ConfigV2>;
template class ElementV2_v0<Psana::CsPad::ConfigV3>;
template class ElementV2_v0<Psana::CsPad::ConfigV4>;
template class ElementV2_v0<Psana::CsPad::ConfigV5>;

void make_datasets_ElementV2_v0(const Psana::CsPad::ElementV2& obj, 
      hdf5pp::Group group, const ChunkPolicy& chunkPolicy, int deflate, bool shuffle)
{
  {
    hdf5pp::Type dstype = CsPad::ns_ElementV2_v0::dataset_element::stored_type();
    hdf5pp::Utils::createDataset(group, "element", dstype, chunkPolicy.chunkSize(dstype), chunkPolicy.chunkCacheSize(dstype), deflate, shuffle);    
  }
  {
    typedef __typeof__(obj.data()) PsanaArray;
    const PsanaArray& psana_array = obj.data();
    hsize_t dims[3];
    std::copy(psana_array.shape(), psana_array.shape()+3, dims);
    hdf5pp::Type dstype = hdf5pp::ArrayType::arrayType(hdf5pp::TypeTraits<int16_t>::stored_type(), 3, dims);
    hdf5pp::Utils::createDataset(group, "data", dstype, chunkPolicy.chunkSize(dstype), chunkPolicy.chunkCacheSize(dstype), deflate, shuffle);    
  }
}

void store_ElementV2_v0(const Psana::CsPad::ElementV2* obj, hdf5pp::Group group, long index, bool append)
{
  if (obj) {
    CsPad::ns_ElementV2_v0::dataset_element ds_data(*obj);
    if (append) {
      hdf5pp::Utils::storeAt(group, "element", ds_data, index);
    } else {
      hdf5pp::Utils::storeScalar(group, "element", ds_data);
    }
  } else if (append) {
    hdf5pp::Utils::resizeDataset(group, "element", index < 0 ? index : index + 1);
  }
  if (append) {
    if (obj) {
      hdf5pp::Utils::storeNDArrayAt(group, "data", obj->data(), index);
    } else {
      hdf5pp::Utils::resizeDataset(group, "data", index < 0 ? index : index + 1);
    }
  } else {
    hdf5pp::Utils::storeNDArray(group, "data", obj->data());
  }

}

boost::shared_ptr<PSEvt::Proxy<Psana::CsPad::DataV2> > make_DataV2(int version, hdf5pp::Group group, hsize_t idx, const boost::shared_ptr<Psana::CsPad::ConfigV2>& cfg) {
  switch (version) {
  case 0:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV2> >(boost::make_shared<DataV2_v0<Psana::CsPad::ConfigV2> >(group, idx, cfg));
  default:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV2> >(boost::shared_ptr<Psana::CsPad::DataV2>());
  }
}
boost::shared_ptr<PSEvt::Proxy<Psana::CsPad::DataV2> > make_DataV2(int version, hdf5pp::Group group, hsize_t idx, const boost::shared_ptr<Psana::CsPad::ConfigV3>& cfg) {
  switch (version) {
  case 0:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV2> >(boost::make_shared<DataV2_v0<Psana::CsPad::ConfigV3> >(group, idx, cfg));
  default:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV2> >(boost::shared_ptr<Psana::CsPad::DataV2>());
  }
}
boost::shared_ptr<PSEvt::Proxy<Psana::CsPad::DataV2> > make_DataV2(int version, hdf5pp::Group group, hsize_t idx, const boost::shared_ptr<Psana::CsPad::ConfigV4>& cfg) {
  switch (version) {
  case 0:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV2> >(boost::make_shared<DataV2_v0<Psana::CsPad::ConfigV4> >(group, idx, cfg));
  default:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV2> >(boost::shared_ptr<Psana::CsPad::DataV2>());
  }
}
boost::shared_ptr<PSEvt::Proxy<Psana::CsPad::DataV2> > make_DataV2(int version, hdf5pp::Group group, hsize_t idx, const boost::shared_ptr<Psana::CsPad::ConfigV5>& cfg) {
  switch (version) {
  case 0:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV2> >(boost::make_shared<DataV2_v0<Psana::CsPad::ConfigV5> >(group, idx, cfg));
  default:
    return boost::make_shared<PSEvt::DataProxy<Psana::CsPad::DataV2> >(boost::shared_ptr<Psana::CsPad::DataV2>());
  }
}

void make_datasets(const Psana::CsPad::DataV2& obj, hdf5pp::Group group, const ChunkPolicy& chunkPolicy,
                   int deflate, bool shuffle, int version)
{
  if (version < 0) version = 0;
  group.createAttr<uint32_t>("_schemaVersion").store(version);
  switch (version) {
  case 0:
    make_datasets_DataV2_v0(obj, group, chunkPolicy, deflate, shuffle);
    break;
  default:
    throw ExceptionSchemaVersion(ERR_LOC, "CsPad.DataV2", version);
  }
}

void store_DataV2(const Psana::CsPad::DataV2* obj, hdf5pp::Group group, long index, int version, bool append)
{
  if (version < 0) version = 0;
  if (not append) group.createAttr<uint32_t>("_schemaVersion").store(version);
  switch (version) {
  case 0:
    store_DataV2_v0(obj, group, index, append);
    break;
  default:
    throw ExceptionSchemaVersion(ERR_LOC, "CsPad.DataV2", version);
  }
}

void store(const Psana::CsPad::DataV2& obj, hdf5pp::Group group, int version) 
{
  store_DataV2(&obj, group, 0, version, false);
}

void store_at(const Psana::CsPad::DataV2* obj, hdf5pp::Group group, long index, int version)
{
  store_DataV2(obj, group, index, version, true);
}

} // namespace CsPad
} // namespace psddl_hdf2psana

---