database/PHParameter/PHParameterContainerInterface.cc

0001 #include "PHParameterContainerInterface.h"
0002 #include "PHParameters.h"
0003 #include "PHParametersContainer.h"
0004
0005 #include <phool/PHCompositeNode.h>
0006 #include <phool/PHDataNode.h>
0007
0008 #include <TSystem.h>
0009
0010 #include <cmath>
0011 #include <iostream>
0012 #include <sstream>
0013 #include <utility>
0014
0015 PHParameterContainerInterface::PHParameterContainerInterface(const std::string &name)
0016   : paramscontainer(new PHParametersContainer(name))
0017 {
0018   std::string pname(name);
0019   pname += "_default";
0020   defaultparams = new PHParameters(pname);
0021 }
0022
0023 PHParameterContainerInterface::~PHParameterContainerInterface()
0024 {
0025   delete paramscontainer;
0026   delete defaultparams;
0027   while (macroparams.begin() != macroparams.end())
0028   {
0029     delete macroparams.begin()->second;
0030     macroparams.erase(macroparams.begin());
0031   }
0032   return;
0033 }
0034
0035 void PHParameterContainerInterface::set_name(const std::string &name)
0036 {
0037   paramscontainer->set_name(name);
0038 }
0039
0040 void PHParameterContainerInterface::set_default_double_param(const std::string &name, const double dval)
0041 {
0042   if (defaultparams->exist_double_param(name))
0043   {
0044     std::cout << "trying to overwrite default double " << name << " "
0045               << defaultparams->get_double_param(name) << " with " << dval << std::endl;
0046     gSystem->Exit(1);
0047   }
0048   defaultparams->set_double_param(name, dval);
0049   return;
0050 }
0051
0052 void PHParameterContainerInterface::set_default_int_param(const std::string &name, const int ival)
0053 {
0054   if (defaultparams->exist_int_param(name))
0055   {
0056     std::cout << "trying to overwrite default double " << name << " "
0057               << defaultparams->get_int_param(name) << " with " << ival << std::endl;
0058     gSystem->Exit(1);
0059   }
0060   defaultparams->set_int_param(name, ival);
0061   return;
0062 }
0063
0064 void PHParameterContainerInterface::set_default_string_param(const std::string &name, const std::string &sval)
0065 {
0066   if (defaultparams->exist_string_param(name))
0067   {
0068     std::cout << "trying to overwrite default double " << name << " "
0069               << defaultparams->get_string_param(name) << " with " << sval << std::endl;
0070     gSystem->Exit(1);
0071   }
0072   defaultparams->set_string_param(name, sval);
0073   return;
0074 }
0075
0076 void PHParameterContainerInterface::set_double_param(const int detid, const std::string &name, const double dval)
0077 {
0078   if (!defaultparams->exist_double_param(name))
0079   {
0080     std::cout << "double parameter " << name << " not implemented" << std::endl;
0081     std::cout << "implemented double parameters are:" << std::endl;
0082     defaultparams->printdouble();
0083     gSystem->Exit(1);
0084     return;
0085   }
0086   std::map<int, PHParameters *>::iterator iter = macroparams.find(detid);
0087   PHParameters *params = nullptr;
0088   if (iter != macroparams.end())
0089   {
0090     params = iter->second;
0091   }
0092   else
0093   {
0094     std::ostringstream paramname;
0095     paramname << paramscontainer->Name() << "_" << detid;
0096     params = new PHParameters(paramname.str());
0097     macroparams[detid] = params;
0098   }
0099   params->set_double_param(name, dval);
0100 }
0101
0102 double
0103 PHParameterContainerInterface::get_double_param(const int detid, const std::string &name) const
0104 {
0105   const PHParameters *params = paramscontainer->GetParameters(detid);
0106   if (params)
0107   {
0108     return params->get_double_param(name);
0109   }
0110   std::cout << "no parameters for detid " << detid << " in "
0111             << paramscontainer->Name() << " found" << std::endl;
0112   return std::numeric_limits<double>::quiet_NaN();
0113 }
0114
0115 void PHParameterContainerInterface::set_int_param(const int detid, const std::string &name, const int ival)
0116 {
0117   if (!defaultparams->exist_int_param(name))
0118   {
0119     std::cout << "integer parameter " << name << " not implemented" << std::endl;
0120     std::cout << "implemented integer parameters are:" << std::endl;
0121     defaultparams->printint();
0122     gSystem->Exit(1);
0123     return;
0124   }
0125   std::map<int, PHParameters *>::iterator iter = macroparams.find(detid);
0126   PHParameters *params = nullptr;
0127   if (iter != macroparams.end())
0128   {
0129     params = iter->second;
0130   }
0131   else
0132   {
0133     std::ostringstream paramname;
0134     paramname << paramscontainer->Name() << "_" << detid;
0135     params = new PHParameters(paramname.str());
0136     paramscontainer->AddPHParameters(detid, params);
0137   }
0138   params->set_int_param(name, ival);
0139 }
0140
0141 int PHParameterContainerInterface::get_int_param(const int detid, const std::string &name) const
0142 {
0143   const PHParameters *params = paramscontainer->GetParameters(detid);
0144   if (params)
0145   {
0146     return params->get_int_param(name);
0147   }
0148   std::cout << "no parameters for detid " << detid << " in "
0149             << paramscontainer->Name() << " found" << std::endl;
0150   return (std::numeric_limits<int>::min());
0151 }
0152
0153 void PHParameterContainerInterface::set_string_param(const int detid, const std::string &name, const std::string &sval)
0154 {
0155   if (!defaultparams->exist_string_param(name))
0156   {
0157     std::cout << "string parameter " << name << " not implemented" << std::endl;
0158     std::cout << "implemented string parameters are:" << std::endl;
0159     defaultparams->printstring();
0160     gSystem->Exit(1);
0161     return;
0162   }
0163
0164   std::map<int, PHParameters *>::iterator iter = macroparams.find(detid);
0165   PHParameters *params = nullptr;
0166   if (iter != macroparams.end())
0167   {
0168     params = iter->second;
0169   }
0170   else
0171   {
0172     std::ostringstream paramname;
0173     paramname << paramscontainer->Name() << "_" << detid;
0174     params = new PHParameters(paramname.str());
0175     paramscontainer->AddPHParameters(detid, params);
0176   }
0177   params->set_string_param(name, sval);
0178 }
0179
0180 std::string
0181 PHParameterContainerInterface::get_string_param(const int detid, const std::string &name) const
0182 {
0183   const PHParameters *params = paramscontainer->GetParameters(detid);
0184   if (params)
0185   {
0186     return params->get_string_param(name);
0187   }
0188   std::cout << "no parameters for detid " << detid << " in "
0189             << paramscontainer->Name() << " found" << std::endl;
0190   return "";
0191 }
0192
0193 void PHParameterContainerInterface::UpdateParametersWithMacro()
0194 {
0195   std::map<int, PHParameters *>::const_iterator iter;
0196   for (iter = macroparams.begin(); iter != macroparams.end(); ++iter)
0197   {
0198     CreateInitialize(iter->first);
0199
0200     PHParameters *params = paramscontainer->GetParametersToModify(iter->first);
0201     std::pair<PHParameters::dIter, PHParameters::dIter> double_begin_end = iter->second->get_all_double_params();
0202     for (PHParameters::dIter diter = double_begin_end.first; diter != double_begin_end.second; ++diter)
0203     {
0204       params->set_double_param(diter->first, diter->second);
0205     }
0206
0207     std::pair<PHParameters::iIter, PHParameters::iIter> int_begin_end = iter->second->get_all_int_params();
0208     for (PHParameters::iIter iiter = int_begin_end.first; iiter != int_begin_end.second; ++iiter)
0209     {
0210       params->set_int_param(iiter->first, iiter->second);
0211     }
0212
0213     std::pair<PHParameters::strIter, PHParameters::strIter> string_begin_end = iter->second->get_all_string_params();
0214     for (PHParameters::strIter striter = string_begin_end.first; striter != string_begin_end.second; ++striter)
0215     {
0216       params->set_string_param(striter->first, striter->second);
0217     }
0218   }
0219   return;
0220 }
0221
0222 void PHParameterContainerInterface::SaveToNodeTree(PHCompositeNode *runNode, const std::string &nodename)
0223 {
0224   paramscontainer->SaveToNodeTree(runNode, nodename);
0225   return;
0226 }
0227
0228 void PHParameterContainerInterface::PutOnParNode(PHCompositeNode *parNode, const std::string &nodename)
0229 {
0230   parNode->addNode(new PHDataNode<PHParametersContainer>(paramscontainer, nodename));
0231 }
0232
0233 void PHParameterContainerInterface::InitializeParameters()
0234 {
0235   SetDefaultParameters();  // call method from specific subsystem
0236 }
0237
0238 void PHParameterContainerInterface::CreateInitialize(const int detid)
0239 {
0240   PHParameters *params = paramscontainer->GetParametersToModify(detid);
0241   if (!params)
0242   {
0243     std::ostringstream paramname;
0244     paramname << paramscontainer->Name() << "_" << detid;
0245     params = new PHParameters(*defaultparams, paramname.str());
0246     paramscontainer->AddPHParameters(detid, params);
0247   }
0248   return;
0249 }
0250
0251 int PHParameterContainerInterface::ExistDetid(const int detid) const
0252 {
0253   return paramscontainer->ExistDetid(detid);
0254 }