CDBTTree.cc

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file CDBTTree.cc

#include "CDBTTree.h"

#include <phool/phool.h>

#include <TBranch.h>      // for TBranch
#include <TCollection.h>  // for TIter
#include <TDirectory.h>   // for TDirectoryAtomicAdapter, TDirectory, gDirec...
#include <TFile.h>
#include <TLeaf.h>      // for TLeaf
#include <TObjArray.h>  // for TObjArray
#include <TROOT.h>
#include <TSystem.h>
#include <TTree.h>

#include <climits>
#include <cmath>    // for NAN, isfinite
#include <cstdint>  // for uint64_t
#include <iostream>
#include <limits>   // for numeric_limits, numeric_limits<>::max_digits10
#include <set>      // for set
#include <utility>  // for pair, make_pair

CDBTTree::CDBTTree(const std::string &fname)
  : m_Filename(fname)
{
}

CDBTTree::~CDBTTree()
{
  m_FloatEntryMap.clear();
  m_SingleFloatEntryMap.clear();
}

void CDBTTree::SetFloatValue(int channel, const std::string &name, float value)
{
  if (name == "ID")
  {
    std::cout << "Sorry ID is reserved as fieldname, pick anything else" << std::endl;
    gSystem->Exit(1);
  }
  std::string fieldname = "F" + name;
  if (m_Locked[MultipleEntries])
  {
    std::cout << "Trying to add field " << name << " after another entry was committed" << std::endl;
    std::cout << "That does not work, restructure your code" << std::endl;
    gSystem->Exit(1);
  }
  m_FloatEntryMap[channel].insert(std::make_pair(fieldname, value));
}

void CDBTTree::SetDoubleValue(int channel, const std::string &name, double value)
{
  if (name == "ID")
  {
    std::cout << "Sorry ID is reserved as fieldname, pick anything else" << std::endl;
    gSystem->Exit(1);
  }
  std::string fieldname = "D" + name;
  if (m_Locked[MultipleEntries])
  {
    std::cout << "Trying to add field " << name << " after another entry was committed" << std::endl;
    std::cout << "That does not work, restructure your code" << std::endl;
    gSystem->Exit(1);
  }
  m_DoubleEntryMap[channel].insert(std::make_pair(fieldname, value));
}

void CDBTTree::SetIntValue(int channel, const std::string &name, int value)
{
  if (name == "ID")
  {
    std::cout << "Sorry ID is reserved as fieldname, pick anything else" << std::endl;
    gSystem->Exit(1);
  }
  std::string fieldname = "I" + name;
  if (m_Locked[MultipleEntries])
  {
    std::cout << "Trying to add field " << name << " after another entry was committed" << std::endl;
    std::cout << "That does not work, restructure your code" << std::endl;
    gSystem->Exit(1);
  }
  m_IntEntryMap[channel].insert(std::make_pair(fieldname, value));
}

void CDBTTree::SetUInt64Value(int channel, const std::string &name, uint64_t value)
{
  if (name == "ID")
  {
    std::cout << "Sorry ID is reserved as fieldname, pick anything else" << std::endl;
    gSystem->Exit(1);
  }
  std::string fieldname = "g" + name;
  if (m_Locked[MultipleEntries])
  {
    std::cout << "Trying to add field " << name << " after another entry was committed" << std::endl;
    std::cout << "That does not work, restructure your code" << std::endl;
    gSystem->Exit(1);
  }
  m_UInt64EntryMap[channel].insert(std::make_pair(fieldname, value));
}

void CDBTTree::Commit()
{
  m_Locked[MultipleEntries] = true;
}

void CDBTTree::WriteMultipleCDBTTree()
{
  m_TTree[MultipleEntries] = new TTree(m_TTreeName[MultipleEntries].c_str(), m_TTreeName[MultipleEntries].c_str());
  std::set<int> id_set;
  std::map<std::string, float> floatmap;
  std::map<std::string, double> doublemap;
  std::map<std::string, int> intmap;
  std::map<std::string, uint64_t> uint64map;
  intmap.insert(std::make_pair("IID", std::numeric_limits<int>::min()));
  for (auto &f_entry : m_FloatEntryMap)
  {
    id_set.insert(f_entry.first);
    for (auto &f_val : f_entry.second)
    {
      floatmap.insert(std::make_pair(f_val.first, std::numeric_limits<float>::quiet_NaN()));
    }
  }
  for (auto &f_val : floatmap)
  {
    std::string fielddescriptor = f_val.first + "/F";
    m_TTree[MultipleEntries]->Branch(f_val.first.c_str(), &f_val.second, fielddescriptor.c_str());
  }

  for (auto &f_entry : m_DoubleEntryMap)
  {
    id_set.insert(f_entry.first);
    for (auto &f_val : f_entry.second)
    {
      doublemap.insert(std::make_pair(f_val.first, std::numeric_limits<double>::quiet_NaN()));
    }
  }
  for (auto &f_val : doublemap)
  {
    std::string fielddescriptor = f_val.first + "/D";
    m_TTree[MultipleEntries]->Branch(f_val.first.c_str(), &f_val.second, fielddescriptor.c_str());
  }

  for (auto &i_entry : m_IntEntryMap)
  {
    id_set.insert(i_entry.first);
    for (auto &i_val : i_entry.second)
    {
      intmap.insert(std::make_pair(i_val.first, std::numeric_limits<int>::min()));
    }
  }
  for (auto &i_val : intmap)
  {
    std::string fielddescriptor = i_val.first + "/I";
    m_TTree[MultipleEntries]->Branch(i_val.first.c_str(), &i_val.second, fielddescriptor.c_str());
  }

  for (auto &i_entry : m_UInt64EntryMap)
  {
    id_set.insert(i_entry.first);
    for (auto &i_val : i_entry.second)
    {
      uint64map.insert(std::make_pair(i_val.first, std::numeric_limits<uint64_t>::max()));
    }
  }
  for (auto &i_val : uint64map)
  {
    std::string fielddescriptor = i_val.first + "/g";
    m_TTree[MultipleEntries]->Branch(i_val.first.c_str(), &i_val.second, fielddescriptor.c_str());
  }
  // fill ttree
  for (auto ids : id_set)
  {
    intmap["IID"] = ids;
    auto fmapiter = m_FloatEntryMap.find(ids);
    if (fmapiter != m_FloatEntryMap.end())
    {
      for (auto &f_val : fmapiter->second)
      {
        floatmap[f_val.first] = f_val.second;
      }
    }
    auto dmapiter = m_DoubleEntryMap.find(ids);
    if (dmapiter != m_DoubleEntryMap.end())
    {
      for (auto &d_val : dmapiter->second)
      {
        doublemap[d_val.first] = d_val.second;
      }
    }
    auto imapiter = m_IntEntryMap.find(ids);
    if (imapiter != m_IntEntryMap.end())
    {
      for (auto &i_val : imapiter->second)
      {
        intmap[i_val.first] = i_val.second;
      }
    }
    auto uint64mapiter = m_UInt64EntryMap.find(ids);
    if (uint64mapiter != m_UInt64EntryMap.end())
    {
      for (auto &uint64_val : uint64mapiter->second)
      {
        uint64map[uint64_val.first] = uint64_val.second;
      }
    }
    m_TTree[MultipleEntries]->Fill();
    for (auto &f_val : floatmap)
    {
      f_val.second = std::numeric_limits<float>::quiet_NaN();
    }
    for (auto &f_val : doublemap)
    {
      f_val.second = std::numeric_limits<double>::quiet_NaN();
    }
    for (auto &i_val : intmap)
    {
      i_val.second = std::numeric_limits<int>::min();
    }
    for (auto &i_val : uint64map)
    {
      i_val.second = std::numeric_limits<uint64_t>::max();
    }
  }
  return;
}

void CDBTTree::SetSingleFloatValue(const std::string &name, float value)
{
  std::string fieldname = "F" + name;
  if (m_SingleFloatEntryMap.find(fieldname) == m_SingleFloatEntryMap.end())
  {
    if (m_Locked[SingleEntries])
    {
      std::cout << "Trying to add field " << name << " after another entry was committed" << std::endl;
      std::cout << "That does not work, restructure your code" << std::endl;
      gSystem->Exit(1);
    }
    m_SingleFloatEntryMap.insert(std::make_pair(fieldname, value));
    return;
  }
  m_SingleFloatEntryMap[fieldname] = value;
}

void CDBTTree::SetSingleDoubleValue(const std::string &name, double value)
{
  std::string fieldname = "D" + name;
  if (m_SingleDoubleEntryMap.find(fieldname) == m_SingleDoubleEntryMap.end())
  {
    if (m_Locked[SingleEntries])
    {
      std::cout << "Trying to add field " << name << " after another entry was committed" << std::endl;
      std::cout << "That does not work, restructure your code" << std::endl;
      gSystem->Exit(1);
    }
    m_SingleDoubleEntryMap.insert(std::make_pair(fieldname, value));
    return;
  }
  m_SingleDoubleEntryMap[fieldname] = value;
}

void CDBTTree::SetSingleIntValue(const std::string &name, int value)
{
  std::string fieldname = "I" + name;
  if (m_SingleIntEntryMap.find(fieldname) == m_SingleIntEntryMap.end())
  {
    if (m_Locked[SingleEntries])
    {
      std::cout << "Trying to add field " << name << " after another entry was committed" << std::endl;
      std::cout << "That does not work, restructure your code" << std::endl;
      gSystem->Exit(1);
    }
    m_SingleIntEntryMap.insert(std::make_pair(fieldname, value));
    return;
  }
  m_SingleIntEntryMap[fieldname] = value;
}

void CDBTTree::SetSingleUInt64Value(const std::string &name, uint64_t value)
{
  std::string fieldname = "g" + name;
  if (m_SingleUInt64EntryMap.find(fieldname) == m_SingleUInt64EntryMap.end())
  {
    if (m_Locked[SingleEntries])
    {
      std::cout << "Trying to add field " << name << " after another entry was committed" << std::endl;
      std::cout << "That does not work, restructure your code" << std::endl;
      gSystem->Exit(1);
    }
    m_SingleUInt64EntryMap.insert(std::make_pair(fieldname, value));
    return;
  }
  m_SingleUInt64EntryMap[fieldname] = value;
}

void CDBTTree::CommitSingle()
{
  m_Locked[SingleEntries] = true;
  return;
}

void CDBTTree::WriteSingleCDBTTree()
{
  m_TTree[SingleEntries] = new TTree(m_TTreeName[SingleEntries].c_str(), m_TTreeName[SingleEntries].c_str());
  for (auto &field : m_SingleFloatEntryMap)
  {
    std::string fielddescriptor = field.first + "/F";
    m_TTree[SingleEntries]->Branch(field.first.c_str(), &field.second, fielddescriptor.c_str());
  }
  for (auto &field : m_SingleDoubleEntryMap)
  {
    std::string fielddescriptor = field.first + "/D";
    m_TTree[SingleEntries]->Branch(field.first.c_str(), &field.second, fielddescriptor.c_str());
  }
  for (auto &field : m_SingleIntEntryMap)
  {
    std::string fielddescriptor = field.first + "/I";
    m_TTree[SingleEntries]->Branch(field.first.c_str(), &field.second, fielddescriptor.c_str());
  }
  for (auto &field : m_SingleUInt64EntryMap)
  {
    std::string fielddescriptor = field.first + "/g";
    m_TTree[SingleEntries]->Branch(field.first.c_str(), &field.second, fielddescriptor.c_str());
  }

  m_TTree[SingleEntries]->Fill();
  return;
}

void CDBTTree::Print()
{
  if (!m_FloatEntryMap.empty())
  {
    std::cout << "Number of float entries: " << m_FloatEntryMap.size() << std::endl;
    for (auto &field : m_FloatEntryMap)
    {
      std::cout << "ID: " << field.first << std::endl;
      for (auto &calibs : field.second)
      {
        std::string tmpstring = calibs.first;
        tmpstring.erase(0, 1);
        std::cout << "name " << tmpstring << " value: " << calibs.second << std::endl;
      }
    }
    std::cout << "--------------------------------------------------" << std::endl
              << std::endl;
  }
  if (!m_DoubleEntryMap.empty())
  {
    std::cout << "Number of double entries: " << m_DoubleEntryMap.size() << std::endl;
    for (auto &field : m_DoubleEntryMap)
    {
      std::cout << "ID: " << field.first << std::endl;
      for (auto &calibs : field.second)
      {
        std::string tmpstring = calibs.first;
        tmpstring.erase(0, 1);
        std::cout << "name " << tmpstring << " value: " << calibs.second << std::endl;
      }
    }
    std::cout << "--------------------------------------------------" << std::endl
              << std::endl;
  }
  if (!m_IntEntryMap.empty())
  {
    std::cout << "Number of int entries: " << m_IntEntryMap.size() << std::endl;
    for (auto &field : m_IntEntryMap)
    {
      std::cout << "ID: " << field.first << std::endl;
      for (auto &calibs : field.second)
      {
        std::string tmpstring = calibs.first;
        tmpstring.erase(0, 1);
        std::cout << "name " << tmpstring << " value: " << calibs.second << std::endl;
      }
    }
  }
  if (!m_UInt64EntryMap.empty())
  {
    std::cout << "Number of uint64 entries: " << m_UInt64EntryMap.size() << std::endl;
    for (auto &field : m_UInt64EntryMap)
    {
      std::cout << "ID: " << field.first << std::endl;
      for (auto &calibs : field.second)
      {
        std::string tmpstring = calibs.first;
        tmpstring.erase(0, 1);
        std::cout << "name " << tmpstring << " value: " << calibs.second << std::endl;
      }
    }
  }

  if (!m_SingleFloatEntryMap.empty())
  {
    std::cout << "Number of single float fields: " << m_SingleFloatEntryMap.size() << std::endl;
    for (auto &field : m_SingleFloatEntryMap)
    {
      std::string tmpstring = field.first;
      tmpstring.erase(0, 1);
      std::cout << tmpstring << " value " << field.second << std::endl;
    }
  }
  if (!m_SingleDoubleEntryMap.empty())
  {
    std::cout << "Number of single double fields: " << m_SingleDoubleEntryMap.size() << std::endl;
    // some acrobatics to restore the old state of cout after changing the precision for double printout
    std::ios oldState(nullptr);
    oldState.copyfmt(std::cout);
    std::cout.precision(std::numeric_limits<double>::max_digits10);
    for (auto &field : m_SingleDoubleEntryMap)
    {
      std::string tmpstring = field.first;
      tmpstring.erase(0, 1);
      std::cout << tmpstring << " value " << field.second << std::endl;
    }
    std::cout.copyfmt(oldState);
  }
  if (!m_SingleIntEntryMap.empty())
  {
    std::cout << "Number of single int fields: " << m_SingleIntEntryMap.size() << std::endl;
    for (auto &field : m_SingleIntEntryMap)
    {
      std::string tmpstring = field.first;
      tmpstring.erase(0, 1);
      std::cout << tmpstring << " value " << field.second << std::endl;
    }
  }
  if (!m_SingleUInt64EntryMap.empty())
  {
    std::cout << "Number of single uint64 fields: " << m_SingleUInt64EntryMap.size() << std::endl;
    for (auto &field : m_SingleUInt64EntryMap)
    {
      std::string tmpstring = field.first;
      tmpstring.erase(0, 1);
      std::cout << tmpstring << " value " << field.second << std::endl;
    }
  }
}

void CDBTTree::WriteCDBTTree()
{
  bool empty_single = m_SingleFloatEntryMap.empty() && m_SingleDoubleEntryMap.empty() &&
                      m_SingleIntEntryMap.empty() && m_SingleUInt64EntryMap.empty();
  if (!empty_single && !m_Locked[SingleEntries])
  {
    std::cout << "You need to call CDBTTree::CommitSingle() before writing" << std::endl;
    return;
  }
  bool empty_multiple = m_FloatEntryMap.empty() && m_DoubleEntryMap.empty() &&
                        m_IntEntryMap.empty() && m_UInt64EntryMap.empty();
  if (!empty_multiple && !m_Locked[MultipleEntries])
  {
    std::cout << "You need to call CDBTTree::Commit() before writing" << std::endl;
    return;
  }
  if (empty_single && empty_multiple)
  {
    std::cout << "no values to be saved" << std::endl;
    return;
  }

  std::string currdir = gDirectory->GetPath();

  TFile *f = TFile::Open(m_Filename.c_str(), "RECREATE");
  if (!empty_single)
  {
    WriteSingleCDBTTree();
    m_TTree[SingleEntries]->Write();
  }
  if (!empty_multiple)
  {
    WriteMultipleCDBTTree();
    m_TTree[MultipleEntries]->Write();
  }
  f->Close();

  gROOT->cd(currdir.c_str());  // restore previous directory
}

void CDBTTree::LoadCalibrations()
{
  std::string currdir = gDirectory->GetPath();

  TFile *f = TFile::Open(m_Filename.c_str());
  f->GetObject(m_TTreeName[SingleEntries].c_str(), m_TTree[SingleEntries]);
  f->GetObject(m_TTreeName[MultipleEntries].c_str(), m_TTree[MultipleEntries]);
  if (m_TTree[SingleEntries] != nullptr)
  {
    TObjArray *branches = m_TTree[SingleEntries]->GetListOfBranches();
    TIter iter(branches);
    while (TBranch *thisbranch = static_cast<TBranch *>(iter.Next()))
    {
      // this convoluted expression returns the data type of a split branch
      std::string DataType = thisbranch->GetLeaf(thisbranch->GetName())->GetTypeName();
      if (DataType == "Float_t")
      {
        auto itermap = m_SingleFloatEntryMap.insert(std::make_pair(thisbranch->GetName(), std::numeric_limits<float>::quiet_NaN()));
        m_TTree[SingleEntries]->SetBranchAddress(thisbranch->GetName(), &(itermap.first)->second);
      }
      else if (DataType == "Double_t")
      {
        auto itermap = m_SingleDoubleEntryMap.insert(std::make_pair(thisbranch->GetName(), std::numeric_limits<double>::quiet_NaN()));
        m_TTree[SingleEntries]->SetBranchAddress(thisbranch->GetName(), &(itermap.first)->second);
      }
      else if (DataType == "Int_t")
      {
        auto itermap = m_SingleIntEntryMap.insert(std::make_pair(thisbranch->GetName(), -99999));
        m_TTree[SingleEntries]->SetBranchAddress(thisbranch->GetName(), &(itermap.first)->second);
      }
      else if (DataType == "ULong_t")
      {
        auto itermap = m_SingleUInt64EntryMap.insert(std::make_pair(thisbranch->GetName(), std::numeric_limits<uint64_t>::max()));
        m_TTree[SingleEntries]->SetBranchAddress(thisbranch->GetName(), &(itermap.first)->second);
      }
      else
      {
        std::cout << __PRETTY_FUNCTION__ << " data type " << DataType
                  << " in " << m_TTree[SingleEntries]->GetName()
                  << " from " << f->GetName()
                  << " not implemented" << std::endl;
        gSystem->Exit(1);
      }
    }
    m_TTree[SingleEntries]->GetEntry(0);
  }
  if (m_TTree[MultipleEntries] != nullptr)
  {
    TObjArray *branches = m_TTree[MultipleEntries]->GetListOfBranches();
    TIter iter(branches);
    std::map<std::string, float> floatvalmap;
    std::map<std::string, double> doublevalmap;
    std::map<std::string, int> intvalmap;
    std::map<std::string, uint64_t> uint64valmap;
    while (TBranch *thisbranch = static_cast<TBranch *>(iter.Next()))
    {
      // this convoluted expression returns the data type of a split branch
      std::string DataType = thisbranch->GetLeaf(thisbranch->GetName())->GetTypeName();
      if (DataType == "Float_t")
      {
        auto itermap = floatvalmap.insert(std::make_pair(thisbranch->GetName(), std::numeric_limits<float>::quiet_NaN()));
        m_TTree[MultipleEntries]->SetBranchAddress(thisbranch->GetName(), &(itermap.first)->second);
      }
      if (DataType == "Double_t")
      {
        auto itermap = doublevalmap.insert(std::make_pair(thisbranch->GetName(), std::numeric_limits<double>::quiet_NaN()));
        m_TTree[MultipleEntries]->SetBranchAddress(thisbranch->GetName(), &(itermap.first)->second);
      }
      if (DataType == "Int_t")
      {
        auto itermap = intvalmap.insert(std::make_pair(thisbranch->GetName(), std::numeric_limits<int>::min()));
        m_TTree[MultipleEntries]->SetBranchAddress(thisbranch->GetName(), &(itermap.first)->second);
      }
      if (DataType == "ULong_t")
      {
        auto itermap = uint64valmap.insert(std::make_pair(thisbranch->GetName(), std::numeric_limits<uint64_t>::max()));
        m_TTree[MultipleEntries]->SetBranchAddress(thisbranch->GetName(), &(itermap.first)->second);
      }
    }
    for (auto entry = 0; entry < m_TTree[MultipleEntries]->GetEntries(); ++entry)
    {
      for (auto &field : floatvalmap)
      {
        field.second = std::numeric_limits<float>::quiet_NaN();
      }
      for (auto &field : doublevalmap)
      {
        field.second = std::numeric_limits<double>::quiet_NaN();
      }
      for (auto &field : intvalmap)
      {
        field.second = std::numeric_limits<int>::min();
      }
      for (auto &field : uint64valmap)
      {
        field.second = std::numeric_limits<uint64_t>::max();
      }
      m_TTree[MultipleEntries]->GetEntry(entry);
      int ID = intvalmap.find("IID")->second;
      std::map<std::string, float> tmp_floatvalmap;
      for (auto &field : floatvalmap)
      {
        if (std::isfinite(field.second))
        {
          tmp_floatvalmap.insert(std::make_pair(field.first, field.second));
        }
      }
      if (!tmp_floatvalmap.empty())
      {
        m_FloatEntryMap.insert(std::make_pair(ID, tmp_floatvalmap));
      }

      std::map<std::string, double> tmp_doublevalmap;
      for (auto &field : doublevalmap)
      {
        if (std::isfinite(field.second))
        {
          tmp_doublevalmap.insert(std::make_pair(field.first, field.second));
        }
      }
      if (!tmp_doublevalmap.empty())
      {
        m_DoubleEntryMap.insert(std::make_pair(ID, tmp_doublevalmap));
      }

      std::map<std::string, int> tmp_intvalmap;
      for (auto &field : intvalmap)
      {
        if (field.second != std::numeric_limits<int>::min() && field.first != "IID")
        {
          tmp_intvalmap.insert(std::make_pair(field.first, field.second));
        }
      }
      if (!tmp_intvalmap.empty())
      {
        m_IntEntryMap.insert(std::make_pair(ID, tmp_intvalmap));
      }

      std::map<std::string, uint64_t> tmp_uint64valmap;
      for (auto &field : uint64valmap)
      {
        if (field.second != std::numeric_limits<uint64_t>::max())
        {
          tmp_uint64valmap.insert(std::make_pair(field.first, field.second));
        }
      }
      if (!tmp_uint64valmap.empty())
      {
        m_UInt64EntryMap.insert(std::make_pair(ID, tmp_uint64valmap));
      }
    }
  }
  for (auto ttree : m_TTree)
  {
    delete ttree;
    ttree = nullptr;
  }
  f->Close();
  gROOT->cd(currdir.c_str());  // restore previous directory
}

float CDBTTree::GetSingleFloatValue(const std::string &name, int verbose)
{
  if (m_SingleFloatEntryMap.empty())
  {
    LoadCalibrations();
  }
  std::string fieldname = "F" + name;
  auto singleiter = m_SingleFloatEntryMap.find(fieldname);
  if (singleiter == m_SingleFloatEntryMap.end())
  {
    if (verbose > 0)
    {
      std::cout << "Could not find " << name << " in single float calibrations" << std::endl;
      std::cout << "Existing values:" << std::endl;
      for (auto &eiter : m_SingleFloatEntryMap)
      {
        std::string tmpstring = eiter.first;
        tmpstring.erase(0, 1);
        std::cout << "name : " << tmpstring << ", value " << eiter.second
                  << std::endl;
      }
    }
    return std::numeric_limits<float>::quiet_NaN();
  }
  return singleiter->second;
}

float CDBTTree::GetFloatValue(int channel, const std::string &name, int verbose)
{
  if (m_FloatEntryMap.empty())
  {
    LoadCalibrations();
  }
  auto channelmapiter = m_FloatEntryMap.find(channel);
  if (channelmapiter == m_FloatEntryMap.end())
  {
    if (verbose > 0)
    {
      std::cout << PHWHERE << " Could not find channel " << channel
                << " for " << name << " in float calibrations" << std::endl;
    }
    return std::numeric_limits<float>::quiet_NaN();
  }
  std::string fieldname = "F" + name;
  auto calibiter = channelmapiter->second.find(fieldname);
  if (calibiter == channelmapiter->second.end())
  {
    if (verbose > 0)
    {
      std::cout << "Could not find " << name << " among float calibrations of channel " << channel << std::endl;
    }
    return std::numeric_limits<float>::quiet_NaN();
  }
  return calibiter->second;
}

double CDBTTree::GetSingleDoubleValue(const std::string &name, int verbose)
{
  if (m_SingleDoubleEntryMap.empty())
  {
    LoadCalibrations();
  }
  std::string fieldname = "D" + name;
  auto singleiter = m_SingleDoubleEntryMap.find(fieldname);
  if (singleiter == m_SingleDoubleEntryMap.end())
  {
    if (verbose > 0)
    {
      std::cout << "Could not find " << name << " in single double calibrations" << std::endl;
      std::cout << "Existing values:" << std::endl;
      for (auto &eiter : m_SingleDoubleEntryMap)
      {
        std::string tmpstring = eiter.first;
        tmpstring.erase(0, 1);
        std::cout << "name : " << tmpstring << ", value " << eiter.second
                  << std::endl;
      }
    }
    return std::numeric_limits<double>::quiet_NaN();
  }
  return singleiter->second;
}

double CDBTTree::GetDoubleValue(int channel, const std::string &name, int verbose)
{
  if (m_DoubleEntryMap.empty())
  {
    LoadCalibrations();
  }
  auto channelmapiter = m_DoubleEntryMap.find(channel);
  if (channelmapiter == m_DoubleEntryMap.end())
  {
    if (verbose > 0)
    {
      std::cout << PHWHERE << " Could not find channel " << channel
                << " for " << name << " in double calibrations" << std::endl;
    }
    return std::numeric_limits<double>::quiet_NaN();
  }
  std::string fieldname = "D" + name;
  auto calibiter = channelmapiter->second.find(fieldname);
  if (calibiter == channelmapiter->second.end())
  {
    if (verbose > 0)
    {
      std::cout << "Could not find " << name << " among double calibrations for channel " << channel << std::endl;
    }
    return std::numeric_limits<double>::quiet_NaN();
  }
  return calibiter->second;
}

int CDBTTree::GetSingleIntValue(const std::string &name, int verbose)
{
  if (m_SingleIntEntryMap.empty())
  {
    LoadCalibrations();
  }
  std::string fieldname = "I" + name;
  auto singleiter = m_SingleIntEntryMap.find(fieldname);
  if (singleiter == m_SingleIntEntryMap.end())
  {
    if (verbose > 0)
    {
      std::cout << "Could not find " << name << " in single int calibrations" << std::endl;
      std::cout << "Existing values:" << std::endl;
      for (auto &eiter : m_SingleIntEntryMap)
      {
        std::string tmpstring = eiter.first;
        tmpstring.erase(0, 1);
        std::cout << "name : " << tmpstring << ", value " << eiter.second
                  << std::endl;
      }
    }
    return std::numeric_limits<int>::min();
  }
  return singleiter->second;
}

int CDBTTree::GetIntValue(int channel, const std::string &name, int verbose)
{
  if (m_IntEntryMap.empty())
  {
    LoadCalibrations();
  }
  auto channelmapiter = m_IntEntryMap.find(channel);
  if (channelmapiter == m_IntEntryMap.end())
  {
    if (verbose > 0)
    {
      std::cout << PHWHERE << " Could not find channel " << channel
                << " for " << name << " in int calibrations" << std::endl;
    }
    return std::numeric_limits<int>::min();
  }
  std::string fieldname = "I" + name;
  auto calibiter = channelmapiter->second.find(fieldname);
  if (calibiter == channelmapiter->second.end())
  {
    if (verbose > 0)
    {
      std::cout << "Could not find " << name << " among int calibrations for channel " << channel << std::endl;
    }
    return std::numeric_limits<int>::min();
  }
  return calibiter->second;
}

uint64_t CDBTTree::GetSingleUInt64Value(const std::string &name, int verbose)
{
  if (m_SingleUInt64EntryMap.empty())
  {
    LoadCalibrations();
  }
  std::string fieldname = "g" + name;
  auto singleiter = m_SingleUInt64EntryMap.find(fieldname);
  if (singleiter == m_SingleUInt64EntryMap.end())
  {
    if (verbose > 0)
    {
      std::cout << "Could not find " << name << " in single uint64 calibrations" << std::endl;
      std::cout << "Existing values:" << std::endl;
      for (auto &eiter : m_SingleUInt64EntryMap)
      {
        std::string tmpstring = eiter.first;
        tmpstring.erase(0, 1);
        std::cout << "name : " << tmpstring << ", value " << eiter.second
                  << std::endl;
      }
    }
    return std::numeric_limits<uint64_t>::max();
  }
  return singleiter->second;
}

uint64_t CDBTTree::GetUInt64Value(int channel, const std::string &name, int verbose)
{
  if (m_UInt64EntryMap.empty())
  {
    LoadCalibrations();
  }
  auto channelmapiter = m_UInt64EntryMap.find(channel);
  if (channelmapiter == m_UInt64EntryMap.end())
  {
    if (verbose > 0)
    {
      std::cout << "Could not find channel " << channel << " in unint64 calibrations" << std::endl;
    }
    return std::numeric_limits<uint64_t>::max();
  }
  std::string fieldname = "g" + name;
  auto calibiter = channelmapiter->second.find(fieldname);
  if (calibiter == channelmapiter->second.end())
  {
    if (verbose > 0)
    {
      std::cout << PHWHERE << " Could not find channel " << channel
                << " for " << name << " in uint64_t calibrations" << std::endl;
    }
    return std::numeric_limits<uint64_t>::max();
  }
  return calibiter->second;
}