Back to home page

sPhenix code displayed by LXR
 
 

    

File indexing completed on 2025-08-05 08:17:47 

0001 #include "PHG4DetectorSubsystem.h"
0002 
0003 #include <phparameter/PHParameters.h>
0004 #include <phparameter/PHParametersContainer.h>
0005 #include <phparameter/PHParameterUtils.h>
0006 
0007 #include <pdbcalbase/PdbParameterMapContainer.h>
0008 
0009 #include <g4main/PHG4Subsystem.h>  // for PHG4Subsystem
0010 
0011 #include <phool/PHCompositeNode.h>
0012 #include <phool/PHDataNode.h>
0013 #include <phool/PHNode.h>  // for PHNode
0014 #include <phool/PHNodeIterator.h>
0015 #include <phool/getClass.h>
0016 #include <phool/phool.h>
0017 
0018 #include <cstdlib>  // for exit, NULL
0019 #include <iostream>
0020 #include <utility>  // for pair
0021 
0022 PHG4DetectorSubsystem::PHG4DetectorSubsystem(const std::string &name, const int lyr)
0023   : PHG4Subsystem(name)
0024   , params(new PHParameters(Name()))
0025   , layer(lyr)
0026 {
0027   // put the layer into the name so we get unique names
0028   // for multiple layers
0029   Name(name + "_" + std::to_string(lyr));
0030 }
0031 
0032 int PHG4DetectorSubsystem::Init(PHCompositeNode *topNode)
0033 {
0034   savetopNode = topNode;
0035   params->set_name(Name());
0036   int iret = InitSubsystem(topNode);
0037   return iret;
0038 }
0039 
0040 int PHG4DetectorSubsystem::InitRun(PHCompositeNode *topNode)
0041 {
0042   PHNodeIterator iter(topNode);
0043   PHCompositeNode *parNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "PAR"));
0044   PHCompositeNode *runNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "RUN"));
0045 
0046   std::string g4geonodename = "G4GEO_";
0047   std::string paramnodename = "G4GEOPARAM_";
0048   std::string calibdetname;
0049   int isSuperDetector = 0;
0050   if (superdetector != "NONE")
0051   {
0052     g4geonodename += SuperDetector();
0053     paramscontainer = findNode::getClass<PHParametersContainer>(parNode, g4geonodename);
0054     if (!paramscontainer)
0055     {
0056       PHNodeIterator parIter(parNode);
0057       PHCompositeNode *DetNode = dynamic_cast<PHCompositeNode *>(parIter.findFirst("PHCompositeNode", SuperDetector()));
0058       if (!DetNode)
0059       {
0060         DetNode = new PHCompositeNode(SuperDetector());
0061         parNode->addNode(DetNode);
0062       }
0063       paramscontainer = new PHParametersContainer(superdetector);
0064       DetNode->addNode(new PHDataNode<PHParametersContainer>(paramscontainer, g4geonodename));
0065     }
0066     paramscontainer->AddPHParameters(layer, params);
0067     paramnodename += superdetector;
0068     calibdetname = superdetector;
0069     isSuperDetector = 1;
0070   }
0071   else
0072   {
0073     g4geonodename += params->Name();
0074     parNode->addNode(new PHDataNode<PHParameters>(params, g4geonodename));
0075     paramnodename += params->Name();
0076     calibdetname = params->Name();
0077   }
0078 
0079   // ASSUMPTION: if we read from DB and/or file we don't want the stuff from
0080   // the node tree
0081   // We leave the defaults intact in case there is no entry for
0082   // those in the object read from the DB or file
0083   // Order: read first DB, then calib file if both are enabled
0084   if (ReadDB() || get_filetype() != PHG4DetectorSubsystem::none)
0085   {
0086     if (!m_Domain.empty())
0087     {
0088       ReadParamsFromCDB(m_Domain);
0089     }
0090     else
0091     {
0092       if (get_filetype() != PHG4DetectorSubsystem::none)
0093       {
0094         ReadParamsFromFile(calibdetname, get_filetype(), isSuperDetector);
0095       }
0096     }
0097   }
0098   else
0099   {
0100     PdbParameterMapContainer *nodeparams = findNode::getClass<PdbParameterMapContainer>(topNode, paramnodename);
0101     if (nodeparams)
0102     {
0103       params->FillFrom(nodeparams, layer);
0104     }
0105   }
0106   // parameters set in the macro always override whatever is read from
0107   // the node tree, DB or file
0108   UpdateParametersWithMacro();
0109   // save updated persistant copy on node tree
0110   PHCompositeNode *RunDetNode = runNode;
0111   if (superdetector != "NONE")
0112   {
0113     PHNodeIterator runIter(runNode);
0114     RunDetNode = dynamic_cast<PHCompositeNode *>(runIter.findFirst("PHCompositeNode", SuperDetector()));
0115     if (!RunDetNode)
0116     {
0117       RunDetNode = new PHCompositeNode(SuperDetector());
0118       runNode->addNode(RunDetNode);
0119     }
0120   }
0121   // put parameters on the node tree so the subsystem can read them from there (it does not have to)
0122   params->SaveToNodeTree(RunDetNode, paramnodename, layer);
0123   // define the materials for the detector
0124   // at this point all flags are known so materials set in the macro can
0125   // be implemented here
0126   DefineMaterials();
0127   int iret = InitRunSubsystem(topNode);
0128   // update parameters on node tree in case the subsystem has changed them
0129   // In the end the parameters on the node tree must reflect what was actually used
0130   params->UpdateNodeTree(RunDetNode, paramnodename, layer);
0131   if (Verbosity() > 0)
0132   {
0133     PdbParameterMapContainer *nodeparams = findNode::getClass<PdbParameterMapContainer>(topNode, paramnodename);
0134     std::cout << Name() << std::endl;
0135     nodeparams->print();
0136   }
0137   beginrunexecuted = 1;
0138   return iret;
0139 }
0140 
0141 void PHG4DetectorSubsystem::SuperDetector(const std::string &name)
0142 {
0143   superdetector = name;
0144   return;
0145 }
0146 
0147 void PHG4DetectorSubsystem::set_double_param(const std::string &name, const double dval)
0148 {
0149   if (default_double.find(name) == default_double.end())
0150   {
0151     std::cout << "double parameter " << name << " not implemented" << std::endl;
0152     std::cout << "implemented double parameters are:" << std::endl;
0153     for (std::map<const std::string, double>::const_iterator iter = default_double.begin(); iter != default_double.end(); ++iter)
0154     {
0155       std::cout << iter->first << std::endl;
0156     }
0157     return;
0158   }
0159   dparams[name] = dval;
0160 }
0161 
0162 double
0163 PHG4DetectorSubsystem::get_double_param(const std::string &name) const
0164 {
0165   return params->get_double_param(name);
0166 }
0167 
0168 void PHG4DetectorSubsystem::set_int_param(const std::string &name, const int ival)
0169 {
0170   if (default_int.find(name) == default_int.end())
0171   {
0172     std::cout << "integer parameter " << name << " not implemented" << std::endl;
0173     std::cout << "implemented integer parameters are:" << std::endl;
0174     for (std::map<const std::string, int>::const_iterator iter = default_int.begin(); iter != default_int.end(); ++iter)
0175     {
0176       std::cout << iter->first << std::endl;
0177     }
0178     return;
0179   }
0180   iparams[name] = ival;
0181 }
0182 
0183 int PHG4DetectorSubsystem::get_int_param(const std::string &name) const
0184 {
0185   return params->get_int_param(name);
0186 }
0187 
0188 void PHG4DetectorSubsystem::set_string_param(const std::string &name, const std::string &sval)
0189 {
0190   if (default_string.find(name) == default_string.end())
0191   {
0192     std::cout << "string parameter " << name << " not implemented" << std::endl;
0193     std::cout << "implemented string parameters are:" << std::endl;
0194     for (std::map<const std::string, std::string>::const_iterator iter = default_string.begin(); iter != default_string.end(); ++iter)
0195     {
0196       std::cout << iter->first << std::endl;
0197     }
0198     return;
0199   }
0200   cparams[name] = sval;
0201 }
0202 
0203 std::string
0204 PHG4DetectorSubsystem::get_string_param(const std::string &name) const
0205 {
0206   return params->get_string_param(name);
0207 }
0208 
0209 void PHG4DetectorSubsystem::UpdateParametersWithMacro()
0210 {
0211   for (std::map<const std::string, double>::const_iterator iter = dparams.begin(); iter != dparams.end(); ++iter)
0212   {
0213     params->set_double_param(iter->first, iter->second);
0214   }
0215   for (std::map<const std::string, int>::const_iterator iter = iparams.begin(); iter != iparams.end(); ++iter)
0216   {
0217     params->set_int_param(iter->first, iter->second);
0218   }
0219   for (std::map<const std::string, std::string>::const_iterator iter = cparams.begin(); iter != cparams.end(); ++iter)
0220   {
0221     params->set_string_param(iter->first, iter->second);
0222   }
0223   return;
0224 }
0225 
0226 void PHG4DetectorSubsystem::set_default_double_param(const std::string &name, const double dval)
0227 {
0228   if (default_double.find(name) == default_double.end())
0229   {
0230     default_double[name] = dval;
0231   }
0232   else
0233   {
0234     std::cout << "trying to overwrite default double " << name << " "
0235               << default_double[name] << " with " << dval << std::endl;
0236     exit(1);
0237   }
0238   return;
0239 }
0240 
0241 void PHG4DetectorSubsystem::set_default_int_param(const std::string &name, const int ival)
0242 {
0243   if (default_int.find(name) == default_int.end())
0244   {
0245     default_int[name] = ival;
0246   }
0247   else
0248   {
0249     std::cout << "trying to overwrite default int " << name << " "
0250               << default_int[name] << " with " << ival << std::endl;
0251     exit(1);
0252   }
0253   return;
0254 }
0255 
0256 void PHG4DetectorSubsystem::set_default_string_param(const std::string &name, const std::string &sval)
0257 {
0258   if (default_string.find(name) == default_string.end())
0259   {
0260     default_string[name] = sval;
0261   }
0262   else
0263   {
0264     std::cout << "trying to overwrite default string " << name << " "
0265               << default_string[name] << " with " << sval << std::endl;
0266     exit(1);
0267   }
0268   return;
0269 }
0270 
0271 void PHG4DetectorSubsystem::InitializeParameters()
0272 {
0273   set_default_int_param("absorberactive", 0);
0274   set_default_int_param("absorbertruth", 0);
0275   set_default_int_param("active", 0);
0276   set_default_int_param("blackhole", 0);
0277   set_default_int_param("supportactive", 0);
0278 
0279   SetDefaultParameters();  // call method from specific subsystem
0280   // now load those parameters to our params class
0281   for( const auto& [key, value]:default_double )
0282   {
0283     params->set_double_param(key,value);
0284   }
0285   for( const auto& [key, value]:default_int )
0286   {
0287     params->set_int_param(key,value);
0288   }
0289   for( const auto& [key, value]:default_string )
0290   {
0291     params->set_string_param(key,value);
0292   }
0293 }
0294 
0295 
0296 int PHG4DetectorSubsystem::SaveParamsToFile(const PHG4DetectorSubsystem::FILE_TYPE ftyp)
0297 {
0298   std::string extension;
0299   switch (ftyp)
0300   {
0301   case xml:
0302     extension = "xml";
0303     break;
0304   case root:
0305     extension = "root";
0306     break;
0307   default:
0308     std::cout << PHWHERE << "filetype " << ftyp << " not implemented" << std::endl;
0309     exit(1);
0310   }
0311   int iret = 0;
0312   if (paramscontainer)
0313   {
0314     iret = paramscontainer->WriteToFile(extension, calibfiledir);
0315   }
0316   else
0317   {
0318     iret = params->WriteToFile(extension, calibfiledir);
0319   }
0320   if (iret)
0321   {
0322     std::cout << "problem saving to " << extension << " file " << std::endl;
0323   }
0324   return iret;
0325 }
0326 
0327 int PHG4DetectorSubsystem::ReadParamsFromFile(const std::string &name, const PHG4DetectorSubsystem::FILE_TYPE ftyp, const int issuper)
0328 {
0329   std::string extension;
0330   switch (ftyp)
0331   {
0332   case xml:
0333     extension = "xml";
0334     break;
0335   case root:
0336     extension = "root";
0337     break;
0338   default:
0339     std::cout << PHWHERE << "filetype " << ftyp << " not implemented" << std::endl;
0340     exit(1);
0341   }
0342   int iret = params->ReadFromFile(name, extension, layer, issuper, calibfiledir);
0343   if (iret)
0344   {
0345     std::cout << "problem reading from " << extension << " file " << std::endl;
0346   }
0347   return iret;
0348 }
0349 
0350 void PHG4DetectorSubsystem::SetActive(const int i)
0351 {
0352   iparams["active"] = i;
0353 }
0354 
0355 void PHG4DetectorSubsystem::SetAbsorberActive(const int i)
0356 {
0357   iparams["absorberactive"] = i;
0358 }
0359 
0360 void PHG4DetectorSubsystem::SetSupportActive(const int i)
0361 {
0362   iparams["supportactive"] = i;
0363 }
0364 
0365 void PHG4DetectorSubsystem::BlackHole(const int i)
0366 {
0367   iparams["blackhole"] = i;
0368 }
0369 
0370 void PHG4DetectorSubsystem::SetAbsorberTruth(const int i)
0371 {
0372   iparams["absorbertruth"] = i;
0373 }
0374 
0375 int PHG4DetectorSubsystem::ReadParamsFromCDB(const std::string &domain)
0376 {
0377   if (params)
0378   {
0379     PHParameterUtils::FillPHParametersFromCDB(*params,domain);
0380   }
0381   return 0;
0382 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!