database/PHParameter/PHParametersContainer.cc

0001 #include "PHParametersContainer.h"
0002 #include "PHParameters.h"
0003
0004 #include <pdbcalbase/PdbBankID.h>
0005 #include <pdbcalbase/PdbCalBank.h>
0006 #include <pdbcalbase/PdbParameterMap.h>
0007 #include <pdbcalbase/PdbParameterMapContainer.h>
0008
0009 #include <phool/PHCompositeNode.h>
0010 #include <phool/PHIODataNode.h>
0011 #include <phool/PHTimeStamp.h>
0012 #include <phool/getClass.h>
0013 #include <phool/phool.h>
0014
0015 #include <TBufferXML.h>
0016 #include <TFile.h>
0017 #include <TSystem.h>
0018
0019 // stacktrace gives a shadow warning
0020 #pragma GCC diagnostic push
0021 #pragma GCC diagnostic ignored "-Wshadow"
0022 #include <boost/stacktrace.hpp>
0023 #pragma GCC diagnostic pop
0024
0025 #include <unistd.h>
0026 #include <algorithm>
0027 #include <cctype>
0028 #include <cstdlib>
0029 #include <ctime>
0030 #include <iostream>
0031 #include <sstream>
0032
0033 PHParametersContainer::PHParametersContainer(const std::string &name)
0034   : superdetectorname(name)
0035 {
0036 }
0037
0038 PHParametersContainer::~PHParametersContainer()
0039 {
0040   while (parametermap.begin() != parametermap.end())
0041   {
0042     delete parametermap.begin()->second;
0043     parametermap.erase(parametermap.begin());
0044   }
0045 }
0046
0047 void PHParametersContainer::FillFrom(const PdbParameterMapContainer *saveparamcontainer)
0048 {
0049   // this fill only existing detids - no new ones are created (if the PdbParameterMapContainer contains
0050   // entries from another detector)
0051   PdbParameterMapContainer::parConstRange begin_end = saveparamcontainer->get_ParameterMaps();
0052   for (PdbParameterMapContainer::parIter iter = begin_end.first; iter != begin_end.second; ++iter)
0053   {
0054     Iterator pariter = parametermap.find(iter->first);
0055     if (pariter != parametermap.end())
0056     {
0057       PHParameters *params = pariter->second;
0058       params->FillFrom(iter->second);
0059     }
0060   }
0061   return;
0062 }
0063
0064 void PHParametersContainer::CreateAndFillFrom(const PdbParameterMapContainer *saveparamcontainer, const std::string &name)
0065 {
0066   PdbParameterMapContainer::parConstRange begin_end = saveparamcontainer->get_ParameterMaps();
0067   for (PdbParameterMapContainer::parIter iter = begin_end.first; iter != begin_end.second; ++iter)
0068   {
0069     Iterator pariter = parametermap.find(iter->first);
0070     if (pariter != parametermap.end())
0071     {
0072       PHParameters *params = pariter->second;
0073       params->FillFrom(iter->second);
0074     }
0075     else
0076     {
0077       PHParameters *params = new PHParameters(name);
0078       params->FillFrom(iter->second);
0079       AddPHParameters(iter->first, params);
0080     }
0081   }
0082   return;
0083 }
0084
0085 void PHParametersContainer::AddPHParameters(const int detid, PHParameters *params)
0086 {
0087   if (parametermap.find(detid) != parametermap.end())
0088   {
0089     std::cout << PHWHERE << " detector id " << detid << " already exists for "
0090               << (parametermap.find(detid))->second->Name() << std::endl;
0091     gSystem->Exit(1);
0092   }
0093   parametermap[detid] = params;
0094 }
0095
0096 const PHParameters *
0097 PHParametersContainer::GetParameters(const int detid) const
0098 {
0099   std::map<int, PHParameters *>::const_iterator iter = parametermap.find(detid);
0100   if (iter == parametermap.end())
0101   {
0102     std::cout << "could not find parameters for detector id " << detid
0103               << std::endl;
0104     std::cout << "Here is the stacktrace: " << std::endl;
0105     std::cout << boost::stacktrace::stacktrace();
0106     std::cout << std::endl
0107               << "DO NOT PANIC - this is not a segfault" << std::endl;
0108     std::cout << "Check the stacktrace for the guilty party (typically #2)" << std::endl;
0109     gSystem->Exit(1);
0110     exit(1);
0111   }
0112   return iter->second;
0113 }
0114
0115 PHParameters *
0116 PHParametersContainer::GetParametersToModify(const int detid)
0117 {
0118   std::map<int, PHParameters *>::iterator iter = parametermap.find(detid);
0119   if (iter == parametermap.end())
0120   {
0121     return nullptr;
0122   }
0123   return iter->second;
0124 }
0125
0126 int PHParametersContainer::WriteToFile(const std::string &extension, const std::string &dir)
0127 {
0128   std::ostringstream fullpath;
0129   std::ostringstream fnamestream;
0130   PdbBankID bankID(0);  // lets start at zero
0131   PHTimeStamp TStart(0);
0132   PHTimeStamp TStop(0xffffffff);
0133   fullpath << dir;
0134   // add / if directory lacks ending /
0135   if (*(dir.rbegin()) != '/')
0136   {
0137     fullpath << "/";
0138   }
0139   fnamestream << superdetectorname << "_geoparams"
0140               << "-" << bankID.getInternalValue()
0141               << "-" << TStart.getTics() << "-" << TStop.getTics() << "-" << time(nullptr)
0142               << "." << extension;
0143   std::string fname = fnamestream.str();
0144   std::transform(fname.begin(), fname.end(), fname.begin(), ::tolower);
0145   fullpath << fname;
0146
0147   std::cout << "PHParameters::WriteToFile - save to " << fullpath.str() << std::endl;
0148
0149   PdbParameterMapContainer *myparm = new PdbParameterMapContainer();
0150   CopyToPdbParameterMapContainer(myparm);
0151   TFile *f = TFile::Open(fullpath.str().c_str(), "recreate");
0152   // force xml file writing to use extended precision shown experimentally
0153   // to not modify input parameters (.15e)
0154   std::string floatformat = TBufferXML::GetFloatFormat();
0155   TBufferXML::SetFloatFormat("%.15e");
0156   myparm->Write();
0157   delete f;
0158   // restore previous xml float format
0159   TBufferXML::SetFloatFormat(floatformat.c_str());
0160   std::cout << "sleeping 1 second to prevent duplicate inserttimes" << std::endl;
0161   sleep(1);
0162   return 0;
0163 }
0164
0165 void PHParametersContainer::CopyToPdbParameterMapContainer(PdbParameterMapContainer *myparmap)
0166 {
0167   std::map<int, PHParameters *>::const_iterator iter;
0168   for (iter = parametermap.begin(); iter != parametermap.end(); ++iter)
0169   {
0170     PdbParameterMap *myparm = new PdbParameterMap();
0171     iter->second->CopyToPdbParameterMap(myparm);
0172     myparmap->AddPdbParameterMap(iter->first, myparm);
0173   }
0174   return;
0175 }
0176
0177 void PHParametersContainer::UpdatePdbParameterMapContainer(PdbParameterMapContainer *myparmap)
0178 {
0179   std::map<int, PHParameters *>::const_iterator iter;
0180   for (iter = parametermap.begin(); iter != parametermap.end(); ++iter)
0181   {
0182     PdbParameterMap *nodeparams = myparmap->GetParametersToModify(iter->first);
0183     iter->second->CopyToPdbParameterMap(nodeparams);
0184   }
0185   return;
0186 }
0187
0188 void PHParametersContainer::Print(Option_t * /*option*/) const
0189 {
0190   std::cout << "Name: " << Name() << std::endl;
0191   std::map<int, PHParameters *>::const_iterator iter;
0192   for (iter = parametermap.begin(); iter != parametermap.end(); ++iter)
0193   {
0194     std::cout << "parameter detid: " << iter->first << std::endl;
0195     iter->second->Print();
0196   }
0197   return;
0198 }
0199
0200 void PHParametersContainer::SaveToNodeTree(PHCompositeNode *topNode, const std::string &nodename)
0201 {
0202   PdbParameterMapContainer *myparmap = findNode::getClass<PdbParameterMapContainer>(topNode, nodename);
0203   if (!myparmap)
0204   {
0205     myparmap = new PdbParameterMapContainer();
0206     PHIODataNode<PdbParameterMapContainer> *newnode =
0207         new PHIODataNode<PdbParameterMapContainer>(myparmap, nodename);
0208     topNode->addNode(newnode);
0209   }
0210   else
0211   {
0212     myparmap->Reset();
0213   }
0214   CopyToPdbParameterMapContainer(myparmap);
0215   return;
0216 }
0217
0218 void PHParametersContainer::UpdateNodeTree(PHCompositeNode *topNode, const std::string &nodename)
0219 {
0220   PdbParameterMapContainer *myparmap = findNode::getClass<PdbParameterMapContainer>(topNode, nodename);
0221   if (!myparmap)
0222   {
0223     std::cout << PHWHERE << " could not find PdbParameterMapContainer " << nodename
0224               << " which must exist" << std::endl;
0225     gSystem->Exit(1);
0226   }
0227   UpdatePdbParameterMapContainer(myparmap);
0228   return;
0229 }
0230
0231 int PHParametersContainer::ExistDetid(const int detid) const
0232 {
0233   if (parametermap.find(detid) != parametermap.end())
0234   {
0235     return 1;
0236   }
0237   return 0;
0238 }