Back to home page

sPhenix code displayed by LXR
 
 

    

File indexing completed on 2025-08-06 08:18:51 

0001 #include "HcalRawTowerBuilder.h"
0002 
0003 #include <calobase/RawTower.h>  // for RawTower
0004 #include <calobase/RawTowerContainer.h>
0005 #include <calobase/RawTowerDefs.h>           // for convert_name_...
0006 #include <calobase/RawTowerGeom.h>           // for RawTowerGeom
0007 #include <calobase/RawTowerGeomContainer.h>  // for RawTowerGeomC...
0008 #include <calobase/RawTowerGeomContainer_Cylinderv1.h>
0009 #include <calobase/RawTowerGeomv1.h>
0010 #include <calobase/RawTowerv1.h>
0011 #include <calobase/TowerInfo.h>
0012 #include <calobase/TowerInfoContainer.h>
0013 #include <calobase/TowerInfoContainerv1.h>
0014 
0015 #include <g4detectors/PHG4Cell.h>
0016 #include <g4detectors/PHG4CellContainer.h>
0017 #include <g4detectors/PHG4CellDefs.h>
0018 #include <g4detectors/PHG4HcalDefs.h>
0019 
0020 #include <phparameter/PHParameterInterface.h>  // for PHParameterIn...
0021 #include <phparameter/PHParameters.h>
0022 
0023 #include <g4main/PHG4Utils.h>
0024 
0025 #include <fun4all/Fun4AllReturnCodes.h>
0026 #include <fun4all/Fun4AllServer.h>
0027 #include <fun4all/SubsysReco.h>  // for SubsysReco
0028 
0029 #include <pdbcalbase/PdbParameterMapContainer.h>
0030 
0031 #include <phool/PHCompositeNode.h>
0032 #include <phool/PHIODataNode.h>
0033 #include <phool/PHNode.h>  // for PHNode
0034 #include <phool/PHNodeIterator.h>
0035 #include <phool/PHObject.h>  // for PHObject
0036 #include <phool/getClass.h>
0037 #include <phool/phool.h>  // for PHWHERE
0038 
0039 #include <TSystem.h>
0040 
0041 #include <cmath>    // for fabs, NAN, cos
0042 #include <cstdlib>  // for exit
0043 #include <filesystem>
0044 #include <fstream>
0045 #include <iostream>
0046 #include <map>
0047 #include <memory>  // for allocator_tra...
0048 #include <stdexcept>
0049 #include <utility>  // for make_pair, pair
0050 
0051 HcalRawTowerBuilder::HcalRawTowerBuilder(const std::string &name)
0052   : SubsysReco(name)
0053   , PHParameterInterface(name)
0054 {
0055   InitializeParameters();
0056 }
0057 
0058 int HcalRawTowerBuilder::InitRun(PHCompositeNode *topNode)
0059 {
0060   if (m_InputDetector.empty() || m_OutputDetector.empty())
0061   {
0062     std::cout << PHWHERE
0063               << " Detector name not set, use HcalRawTowerBuilder::Detector(string) to set, exiting"
0064               << std::endl;
0065     gSystem->Exit(1);
0066     exit(1);
0067   }
0068   PHNodeIterator iter(topNode);
0069 
0070   // Looking for the DST node
0071   PHCompositeNode *dstNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "DST"));
0072   if (!dstNode)
0073   {
0074     std::cout << PHWHERE << "DST Node missing, exiting" << std::endl;
0075     gSystem->Exit(1);
0076     exit(1);
0077   }
0078   PHCompositeNode *runNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "RUN"));
0079   std::string paramnodename = "TOWERPARAM_" + m_OutputDetector;
0080   try
0081   {
0082     CreateNodes(topNode);
0083   }
0084 
0085   catch (std::exception &e)
0086   {
0087     std::cout << e.what() << std::endl;
0088     gSystem->Exit(1);
0089     exit(1);
0090   }
0091   // order first default,
0092   // then parameter from g4detector on node tree
0093   ReadParamsFromNodeTree(topNode);
0094   // then macro setting
0095   UpdateParametersWithMacro();
0096   PHNodeIterator runIter(runNode);
0097   PHCompositeNode *RunDetNode = dynamic_cast<PHCompositeNode *>(runIter.findFirst("PHCompositeNode", m_OutputDetector));
0098   if (!RunDetNode)
0099   {
0100     RunDetNode = new PHCompositeNode(m_OutputDetector);
0101     runNode->addNode(RunDetNode);
0102   }
0103   SaveToNodeTree(RunDetNode, paramnodename);
0104   PHCompositeNode *parNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "PAR"));
0105   std::string geonodename = "TOWERGEO_" + m_OutputDetector;
0106 
0107   PHNodeIterator parIter(parNode);
0108   PHCompositeNode *ParDetNode = dynamic_cast<PHCompositeNode *>(parIter.findFirst("PHCompositeNode", m_OutputDetector));
0109   if (!ParDetNode)
0110   {
0111     ParDetNode = new PHCompositeNode(m_OutputDetector);
0112     parNode->addNode(ParDetNode);
0113   }
0114   PutOnParNode(ParDetNode, geonodename);
0115   m_TowerEnergySrc = get_int_param("tower_energy_source");
0116   m_Emin = get_double_param("emin");
0117   m_NcellToTower = get_int_param("n_scinti_plates_per_tower");
0118   if (!m_TowerDecalFactors.empty())
0119   {
0120     SetTowerDecalFactors();
0121   }
0122   if (Verbosity() >= 1)
0123   {
0124     std::cout << "HcalRawTowerBuilder::InitRun :";
0125     if (m_TowerEnergySrc == kEnergyDeposition)
0126     {
0127       std::cout << "save Geant4 energy deposition in towers" << std::endl;
0128     }
0129     else if (m_TowerEnergySrc == kLightYield)
0130     {
0131       std::cout << "save light yield in towers" << std::endl;
0132     }
0133     else if (m_TowerEnergySrc == kIonizationEnergy)
0134     {
0135       std::cout << "save ionization energy in towers" << std::endl;
0136     }
0137     else if (m_TowerEnergySrc == kRawLightYield)
0138     {
0139       std::cout << "save raw (pre-Mephi map) light yield in towers" << std::endl;
0140     }
0141     else
0142     {
0143       std::cout << "unknown energy source" << std::endl;
0144     }
0145   }
0146   m_TowerGeomNodeName = "TOWERGEOM_" + m_OutputDetector;
0147   m_RawTowerGeom = findNode::getClass<RawTowerGeomContainer>(topNode, m_TowerGeomNodeName);
0148   if (!m_RawTowerGeom)
0149   {
0150     m_RawTowerGeom = new RawTowerGeomContainer_Cylinderv1(RawTowerDefs::convert_name_to_caloid(m_InputDetector));
0151     PHIODataNode<PHObject> *newNode = new PHIODataNode<PHObject>(m_RawTowerGeom, m_TowerGeomNodeName, "PHObject");
0152     RunDetNode->addNode(newNode);
0153   }
0154   double innerrad = get_double_param(PHG4HcalDefs::innerrad);
0155   double thickness = get_double_param(PHG4HcalDefs::outerrad) - innerrad;
0156   m_RawTowerGeom->set_radius(innerrad);
0157   m_RawTowerGeom->set_thickness(thickness);
0158   m_RawTowerGeom->set_phibins(get_int_param(PHG4HcalDefs::n_towers));
0159   m_RawTowerGeom->set_etabins(get_int_param("etabins"));
0160   double geom_ref_radius = innerrad + thickness / 2.;
0161   double phistart = get_double_param("phistart");
0162   if (!std::isfinite(phistart))
0163   {
0164     std::cout << PHWHERE << " phistart is not finite: " << phistart
0165               << ", exiting now (this will crash anyway)" << std::endl;
0166     gSystem->Exit(1);
0167   }
0168   for (int i = 0; i < get_int_param(PHG4HcalDefs::n_towers); i++)
0169   {
0170     double phiend = phistart + 2. * M_PI / get_int_param(PHG4HcalDefs::n_towers);
0171     std::pair<double, double> range = std::make_pair(phiend, phistart);
0172     phistart = phiend;
0173     int tempi = i + 1;
0174     if (tempi >= get_int_param(PHG4HcalDefs::n_towers))
0175     {
0176       tempi -= get_int_param(PHG4HcalDefs::n_towers);
0177     }
0178     m_RawTowerGeom->set_phibounds(tempi, range);
0179   }
0180   // double etalowbound = -1.1;
0181   double etalowbound = -get_double_param("scinti_eta_coverage_neg");
0182   for (int i = 0; i < get_int_param("etabins"); i++)
0183   {
0184     // double etahibound = etalowbound + 2.2 / get_int_param("etabins");
0185     double etahibound = etalowbound +
0186                         (get_double_param("scinti_eta_coverage_neg") + get_double_param("scinti_eta_coverage_pos")) / get_int_param("etabins");
0187     std::pair<double, double> range = std::make_pair(etalowbound, etahibound);
0188     m_RawTowerGeom->set_etabounds(i, range);
0189     etalowbound = etahibound;
0190   }
0191   for (int iphi = 0; iphi < m_RawTowerGeom->get_phibins(); iphi++)
0192   {
0193     for (int ieta = 0; ieta < m_RawTowerGeom->get_etabins(); ieta++)
0194     {
0195       const RawTowerDefs::keytype key = RawTowerDefs::encode_towerid(RawTowerDefs::convert_name_to_caloid(m_InputDetector), ieta, iphi);
0196 
0197       const double x(geom_ref_radius * cos(m_RawTowerGeom->get_phicenter(iphi)));
0198       const double y(geom_ref_radius * sin(m_RawTowerGeom->get_phicenter(iphi)));
0199       const double z(geom_ref_radius / tan(PHG4Utils::get_theta(m_RawTowerGeom->get_etacenter(ieta))));
0200 
0201       RawTowerGeom *tg = m_RawTowerGeom->get_tower_geometry(key);
0202       if (tg)
0203       {
0204         if (Verbosity() > 0)
0205         {
0206           std::cout << "HcalRawTowerBuilder::InitRun - Tower geometry " << key << " already exists" << std::endl;
0207         }
0208 
0209         if (fabs(tg->get_center_x() - x) > 1e-4)
0210         {
0211           std::cout << "HcalRawTowerBuilder::InitRun - Fatal Error - duplicated Tower geometry " << key << " with existing x = " << tg->get_center_x() << " and expected x = " << x
0212                     << std::endl;
0213 
0214           return Fun4AllReturnCodes::ABORTRUN;
0215         }
0216         if (fabs(tg->get_center_y() - y) > 1e-4)
0217         {
0218           std::cout << "HcalRawTowerBuilder::InitRun - Fatal Error - duplicated Tower geometry " << key << " with existing y = " << tg->get_center_y() << " and expected y = " << y
0219                     << std::endl;
0220           return Fun4AllReturnCodes::ABORTRUN;
0221         }
0222         if (fabs(tg->get_center_z() - z) > 1e-4)
0223         {
0224           std::cout << "HcalRawTowerBuilder::InitRun - Fatal Error - duplicated Tower geometry " << key << " with existing z= " << tg->get_center_z() << " and expected z = " << z
0225                     << std::endl;
0226           return Fun4AllReturnCodes::ABORTRUN;
0227         }
0228       }
0229       else
0230       {
0231         if (Verbosity() > 0)
0232         {
0233           std::cout << "HcalRawTowerBuilder::InitRun - building tower geometry " << key << "" << std::endl;
0234         }
0235 
0236         tg = new RawTowerGeomv1(key);
0237 
0238         tg->set_center_x(x);
0239         tg->set_center_y(y);
0240         tg->set_center_z(z);
0241         m_RawTowerGeom->add_tower_geometry(tg);
0242       }
0243     }
0244   }
0245   if (Verbosity() > 0)
0246   {
0247     m_RawTowerGeom->identify();
0248   }
0249 
0250   int m = m_DecalArray[0].size();
0251   int n = m_DecalArray.size();
0252 
0253   for (int i = 0; i < n; i++)
0254   {
0255     for (int j = 0; j < m; j++)
0256     {
0257       m_DecalArray[i][j] = 1.;
0258     }
0259   }
0260 
0261   if (!m_DeCalibrationFileName.empty())
0262   {
0263     if (std::filesystem::exists(m_DeCalibrationFileName))
0264     {
0265       std::ifstream decalibrate_tower;
0266       decalibrate_tower.open(m_DeCalibrationFileName, std::ifstream::in);
0267       if (decalibrate_tower.is_open())
0268       {
0269         while (!decalibrate_tower.eof())
0270         {
0271           int etabin = -1;
0272           int phibin = -1;
0273           for (int i = 0; i < n; i++)
0274           {
0275             for (int j = 0; j < m; j++)
0276             {
0277               decalibrate_tower >> etabin >> phibin >> m_DecalArray[i][j];
0278               if (!std::isfinite(m_DecalArray[i][j]))
0279               {
0280                 std::cout << "Calibration constant at etabin " << etabin
0281                           << ", phibin " << phibin << " in " << m_DeCalibrationFileName
0282                           << " is not finite: " << m_DecalArray[i][j] << std::endl;
0283                 gSystem->Exit(1);
0284                 exit(1);
0285               }
0286             }
0287           }
0288         }
0289         decalibrate_tower.close();
0290       }
0291     }
0292   }
0293 
0294   return Fun4AllReturnCodes::EVENT_OK;
0295 }
0296 
0297 int HcalRawTowerBuilder::process_event(PHCompositeNode *topNode)
0298 {
0299   /* decalibration occurs if user supplies a non empty decalMap.txt
0300     file, otherwise code will proceed with no de-calibration (as is)
0301 */
0302 
0303   double cell_weight = 0.0;
0304   if (Verbosity() > 3)
0305   {
0306     std::cout << PHWHERE << "Process event entered" << std::endl;
0307   }
0308 
0309   // load get TowerInfoContainer node from node tree:
0310   TowerInfoContainer *m_TowerInfoContainer = findNode::getClass<TowerInfoContainer>(topNode, m_TowerInfoNodeName);
0311   if (!m_TowerInfoContainer && m_UseTowerInfo > 0)
0312   {
0313     std::cout << PHWHERE << "TowerInfoContainer Node missing, doing nothing." << std::endl;
0314     exit(1);
0315   }
0316 
0317   // get cells
0318   std::string cellnodename = "G4CELL_" + m_InputDetector;
0319   PHG4CellContainer *slats = findNode::getClass<PHG4CellContainer>(topNode, cellnodename);
0320   if (!slats)
0321   {
0322     std::cout << PHWHERE << " Node " << cellnodename
0323               << " missing, quitting" << std::endl;
0324     gSystem->Exit(1);
0325     exit(1);
0326   }
0327 
0328   // loop over all slats in an event
0329   PHG4CellContainer::ConstIterator cell_iter;
0330   PHG4CellContainer::ConstRange cell_range = slats->getCells();
0331   for (cell_iter = cell_range.first; cell_iter != cell_range.second;
0332        ++cell_iter)
0333   {
0334     PHG4Cell *cell = cell_iter->second;
0335 
0336     short twrrow = get_tower_row(PHG4CellDefs::ScintillatorSlatBinning::get_row(cell->get_cellid()));
0337 
0338     if (m_TowerEnergySrc == kEnergyDeposition)
0339     {
0340       cell_weight = cell->get_edep();
0341     }
0342     else if (m_TowerEnergySrc == kLightYield)
0343     {
0344       cell_weight = cell->get_light_yield();
0345     }
0346     else if (m_TowerEnergySrc == kIonizationEnergy)
0347     {
0348       cell_weight = cell->get_eion();
0349     }
0350     else if (m_TowerEnergySrc == kRawLightYield)
0351     {
0352       cell_weight = cell->get_raw_light_yield();
0353     }
0354     else
0355     {
0356       std::cout << Name() << ": unknown tower energy source "
0357                 << m_TowerEnergySrc << std::endl;
0358       gSystem->Exit(1);
0359       exit(1);
0360     }
0361 
0362     cell_weight *= m_DecalArray.at(PHG4CellDefs::ScintillatorSlatBinning::get_column(cell->get_cellid())).at(PHG4CellDefs::ScintillatorSlatBinning::get_row(cell->get_cellid()));
0363 
0364     if (m_UseTowerInfo != 1)
0365     {
0366       RawTower *tower = m_Towers->getTower(PHG4CellDefs::ScintillatorSlatBinning::get_column(cell->get_cellid()), twrrow);
0367       if (!tower)
0368       {
0369         tower = new RawTowerv1();
0370         tower->set_energy(0.0);
0371         m_Towers->AddTower(PHG4CellDefs::ScintillatorSlatBinning::get_column(cell->get_cellid()), twrrow, tower);
0372       }
0373 
0374       tower->add_ecell(cell->get_cellid(), cell_weight);
0375 
0376       PHG4Cell::ShowerEdepConstRange range = cell->get_g4showers();
0377       for (PHG4Cell::ShowerEdepConstIterator shower_iter = range.first;
0378            shower_iter != range.second;
0379            ++shower_iter)
0380       {
0381         tower->add_eshower(shower_iter->first, shower_iter->second);
0382       }
0383       tower->set_energy(tower->get_energy() + cell_weight);
0384     }
0385 
0386     if (m_UseTowerInfo > 0)
0387     {
0388       TowerInfo *towerinfo;
0389       unsigned int etabin = PHG4CellDefs::ScintillatorSlatBinning::get_column(cell->get_cellid());
0390       unsigned int phibin = twrrow;
0391 
0392       unsigned int towerkey = (etabin << 16U) + phibin;
0393 
0394       towerinfo = m_TowerInfoContainer->get_tower_at_key(towerkey);
0395       if (!towerinfo)
0396       {
0397         std::cout << __PRETTY_FUNCTION__ << ": missing towerkey = " << towerkey << " in m_TowerInfoContainer!";
0398         exit(1);
0399       }
0400       else
0401       {
0402         towerinfo->set_energy(towerinfo->get_energy() + cell_weight);
0403       }
0404     }
0405   }
0406 
0407   double towerE = 0;
0408   if (m_ChkEnergyConservationFlag)
0409   {
0410     double cellE = slats->getTotalEdep();
0411     towerE = m_Towers->getTotalEdep();
0412     if (fabs(cellE - towerE) / cellE > 1e-5)
0413     {
0414       std::cout << "towerE: " << towerE << ", cellE: " << cellE << ", delta: "
0415                 << cellE - towerE << std::endl;
0416     }
0417   }
0418 
0419   if (Verbosity())
0420   {
0421     towerE = m_Towers->getTotalEdep();
0422   }
0423 
0424   m_Towers->compress(m_Emin);
0425   if (Verbosity())
0426   {
0427     std::cout << "Energy lost by dropping towers with less than " << m_Emin
0428               << " energy, lost energy: " << towerE - m_Towers->getTotalEdep()
0429               << std::endl;
0430     m_Towers->identify();
0431     RawTowerContainer::ConstRange begin_end = m_Towers->getTowers();
0432     RawTowerContainer::ConstIterator iter;
0433     for (iter = begin_end.first; iter != begin_end.second; ++iter)
0434     {
0435       iter->second->identify();
0436     }
0437   }
0438 
0439   return Fun4AllReturnCodes::EVENT_OK;
0440 }
0441 
0442 void HcalRawTowerBuilder::CreateNodes(PHCompositeNode *topNode)
0443 {
0444   PHNodeIterator iter(topNode);
0445   PHCompositeNode *runNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "RUN"));
0446   if (!runNode)
0447   {
0448     std::cout << PHWHERE << "Run Node missing, exiting." << std::endl;
0449     gSystem->Exit(1);
0450     exit(1);
0451   }
0452   PHCompositeNode *dstNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "DST"));
0453   if (!dstNode)
0454   {
0455     std::cout << PHWHERE << "DST Node missing, exiting." << std::endl;
0456     gSystem->Exit(1);
0457     exit(1);
0458   }
0459 
0460   PHNodeIterator dstiter(dstNode);
0461   PHCompositeNode *DetNode = dynamic_cast<PHCompositeNode *>(dstiter.findFirst("PHCompositeNode", m_OutputDetector));
0462   if (!DetNode)
0463   {
0464     DetNode = new PHCompositeNode(m_OutputDetector);
0465     dstNode->addNode(DetNode);
0466   }
0467 
0468   if (m_UseTowerInfo != 1)
0469   {
0470     // Create the tower nodes on the tree
0471     if (m_SimTowerNodePrefix.empty())
0472     {
0473       // no prefix, consistent with older convension
0474       m_TowerNodeName = "TOWER_" + m_OutputDetector;
0475     }
0476     else
0477     {
0478       m_TowerNodeName = "TOWER_" + m_SimTowerNodePrefix + "_" + m_OutputDetector;
0479     }
0480     m_Towers = findNode::getClass<RawTowerContainer>(DetNode, m_TowerNodeName);
0481     if (!m_Towers)
0482     {
0483       m_Towers = new RawTowerContainer(RawTowerDefs::convert_name_to_caloid(m_InputDetector));
0484 
0485       PHIODataNode<PHObject> *towerNode = new PHIODataNode<PHObject>(m_Towers, m_TowerNodeName, "PHObject");
0486       DetNode->addNode(towerNode);
0487     }
0488   }
0489 
0490   if (m_UseTowerInfo > 0)
0491   {
0492     if (m_SimTowerNodePrefix.empty())
0493     {
0494       // no prefix, consistent with older convension
0495       m_TowerInfoNodeName = "TOWERINFO_" + m_OutputDetector;
0496     }
0497     else
0498     {
0499       m_TowerInfoNodeName = "TOWERINFO_" + m_SimTowerNodePrefix + "_" + m_OutputDetector;
0500     }
0501 
0502     TowerInfoContainer *m_TowerInfoContainer = findNode::getClass<TowerInfoContainer>(DetNode, m_TowerInfoNodeName);
0503 
0504     RawTowerDefs::CalorimeterId caloid = RawTowerDefs::convert_name_to_caloid(m_InputDetector);
0505     if (m_TowerInfoContainer == nullptr)
0506     {
0507       TowerInfoContainer::DETECTOR detec;
0508       if (caloid == RawTowerDefs::CalorimeterId::CEMC)
0509       {
0510         detec = TowerInfoContainer::DETECTOR::EMCAL;
0511       }
0512       else if (caloid == RawTowerDefs::CalorimeterId::HCALIN || caloid == RawTowerDefs::CalorimeterId::HCALOUT)
0513       {
0514         detec = TowerInfoContainer::DETECTOR::HCAL;
0515       }
0516       else
0517       {
0518         std::cout << PHWHERE << "Detector not implemented into the TowerInfoContainer object, defaulting to HCal implementation." << std::endl;
0519         detec = TowerInfoContainer::DETECTOR::HCAL;
0520       }
0521       m_TowerInfoContainer = new TowerInfoContainerv1(detec);
0522       PHIODataNode<PHObject> *TowerInfoNode = new PHIODataNode<PHObject>(m_TowerInfoContainer, m_TowerInfoNodeName, "PHObject");
0523       DetNode->addNode(TowerInfoNode);
0524     }
0525   }
0526 
0527   return;
0528 }
0529 
0530 short HcalRawTowerBuilder::get_tower_row(const short cellrow) const
0531 {
0532   short twrrow = cellrow / m_NcellToTower;
0533   return twrrow;
0534 }
0535 
0536 void HcalRawTowerBuilder::SetDefaultParameters()
0537 {
0538   set_default_int_param(PHG4HcalDefs::scipertwr, 5);
0539   set_default_int_param("tower_energy_source", kLightYield);
0540   set_default_int_param(PHG4HcalDefs::n_towers, 64);
0541   set_default_int_param("etabins", 24);
0542 
0543   set_default_double_param("emin", 1.e-6);
0544   set_default_double_param(PHG4HcalDefs::outerrad, std::numeric_limits<double>::quiet_NaN());
0545   set_default_double_param(PHG4HcalDefs::innerrad, std::numeric_limits<double>::quiet_NaN());
0546 
0547   set_default_double_param("scinti_eta_coverage_neg", 1.1);
0548   set_default_double_param("scinti_eta_coverage_pos", 1.1);
0549   set_default_double_param("phistart", std::numeric_limits<double>::quiet_NaN());
0550 }
0551 
0552 void HcalRawTowerBuilder::ReadParamsFromNodeTree(PHCompositeNode *topNode)
0553 {
0554   PHParameters *pars = new PHParameters("temp");
0555   // we need the number of scintillator plates per tower
0556   std::string geonodename = "G4GEOPARAM_" + m_InputDetector;
0557   PdbParameterMapContainer *saveparams = findNode::getClass<PdbParameterMapContainer>(topNode, geonodename);
0558   if (!saveparams)
0559   {
0560     std::cout << "could not find " << geonodename << std::endl;
0561     Fun4AllServer *se = Fun4AllServer::instance();
0562     se->Print("NODETREE");
0563     return;
0564   }
0565   pars->FillFrom(saveparams, 0);
0566   set_int_param(PHG4HcalDefs::scipertwr, pars->get_int_param(PHG4HcalDefs::scipertwr));
0567   set_int_param(PHG4HcalDefs::n_towers, pars->get_int_param(PHG4HcalDefs::n_towers));
0568   set_double_param(PHG4HcalDefs::innerrad, pars->get_double_param(PHG4HcalDefs::innerrad));
0569   set_double_param(PHG4HcalDefs::outerrad, pars->get_double_param(PHG4HcalDefs::outerrad));
0570 
0571   int nTiles = 2 * pars->get_int_param(PHG4HcalDefs::n_scinti_tiles);
0572   int nPhislices = pars->get_int_param(PHG4HcalDefs::scipertwr) * pars->get_int_param(PHG4HcalDefs::n_towers);
0573   if (nTiles <= 0)
0574   {
0575     nTiles = pars->get_int_param(PHG4HcalDefs::n_scinti_tiles_pos) + pars->get_int_param(PHG4HcalDefs::n_scinti_tiles_neg);
0576     set_double_param("scinti_eta_coverage_neg", pars->get_double_param("scinti_eta_coverage_neg"));
0577     set_double_param("scinti_eta_coverage_pos", pars->get_double_param("scinti_eta_coverage_pos"));
0578   }
0579   set_int_param("etabins", nTiles);
0580   m_DecalArray.resize(nTiles, std::vector<double>(nPhislices));
0581 
0582   delete pars;
0583   return;
0584 }
0585 
0586 void HcalRawTowerBuilder::set_cell_decal_factor(const int etabin, const int phibin, const double d)
0587 {
0588   m_DecalArray.at(etabin).at(phibin) = d;
0589 }
0590 
0591 void HcalRawTowerBuilder::SetTowerDecalFactors()
0592 {
0593   for (auto &m_TowerDecalFactor : m_TowerDecalFactors)
0594   {
0595     set_tower_decal_factor_real(m_TowerDecalFactor.first.first, m_TowerDecalFactor.first.second, m_TowerDecalFactor.second);
0596   }
0597 }
0598 
0599 void HcalRawTowerBuilder::set_tower_decal_factor(const int etabin, const int phibin, const double d)
0600 {
0601   // since we do not have the number of scintillators per tower at this point
0602   // the decal values are cached in m_TowerDecalFactors to be set during the InitRun
0603   std::pair<int, int> etaphi = std::make_pair(etabin, phibin);
0604   m_TowerDecalFactors[etaphi] = d;
0605 }
0606 
0607 void HcalRawTowerBuilder::set_tower_decal_factor_real(const int etabin, const int phibin, const double d)
0608 {
0609   for (int i = 0; i < m_NcellToTower; i++)
0610   {
0611     int istart = phibin * m_NcellToTower + i;
0612     m_DecalArray.at(etabin).at(istart) = d;
0613   }
0614 }
0615 
0616 void HcalRawTowerBuilder::Print(const std::string & /*what*/) const
0617 {
0618   std::cout << Name() << std::endl;
0619   PHParameterInterface::Print();
0620 }
[ 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!