Back to home page

sPhenix code displayed by LXR
 
 

    

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

0001 #include "RawTowerDigitizer.h"
0002 
0003 #include <calobase/RawTower.h>  // for RawTower
0004 #include <calobase/RawTowerContainer.h>
0005 #include <calobase/RawTowerDeadMap.h>
0006 #include <calobase/RawTowerDefs.h>  // for keytype
0007 #include <calobase/RawTowerGeom.h>
0008 #include <calobase/RawTowerGeomContainer.h>
0009 #include <calobase/RawTowerv2.h>
0010 
0011 #include <calobase/TowerInfo.h>
0012 #include <calobase/TowerInfoContainer.h>
0013 #include <calobase/TowerInfoContainerv1.h>
0014 #include <calobase/TowerInfov1.h>
0015 
0016 #include <phparameter/PHParameters.h>
0017 
0018 #include <cdbobjects/CDBTTree.h>
0019 
0020 #include <ffamodules/CDBInterface.h>
0021 
0022 #include <fun4all/Fun4AllBase.h>  // for Fun4AllBase::VERBOSITY_MORE
0023 #include <fun4all/Fun4AllReturnCodes.h>
0024 #include <fun4all/SubsysReco.h>  // for SubsysReco
0025 
0026 #include <phool/PHCompositeNode.h>
0027 #include <phool/PHIODataNode.h>
0028 #include <phool/PHNode.h>  // for PHNode
0029 #include <phool/PHNodeIterator.h>
0030 #include <phool/PHObject.h>  // for PHObject
0031 #include <phool/PHRandomSeed.h>
0032 #include <phool/getClass.h>
0033 #include <phool/phool.h>  // for PHWHERE
0034 
0035 #include <TSystem.h>
0036 
0037 #include <gsl/gsl_cdf.h>
0038 #include <gsl/gsl_randist.h>
0039 #include <gsl/gsl_rng.h>
0040 
0041 #include <cmath>
0042 #include <cstdlib>    // for exit
0043 #include <exception>  // for exception
0044 #include <iostream>
0045 #include <map>
0046 #include <stdexcept>
0047 #include <string>
0048 #include <utility>  // for pair
0049 
0050 RawTowerDigitizer::RawTowerDigitizer(const std::string &name)
0051   : SubsysReco(name)
0052   , _tower_params(name)
0053 {
0054   m_RandomGenerator = gsl_rng_alloc(gsl_rng_mt19937);
0055   m_Seed = PHRandomSeed();  // fixed seed handled in PHRandomSeed()
0056   // std::cout << Name() << " Random Seed: " << m_Seed << std::endl;
0057   gsl_rng_set(m_RandomGenerator, m_Seed);
0058 }
0059 
0060 RawTowerDigitizer::~RawTowerDigitizer()
0061 {
0062   gsl_rng_free(m_RandomGenerator);
0063   delete m_CDBTTree;
0064 }
0065 
0066 void RawTowerDigitizer::set_seed(const unsigned int iseed)
0067 {
0068   m_Seed = iseed;
0069   gsl_rng_set(m_RandomGenerator, m_Seed);
0070 }
0071 
0072 int RawTowerDigitizer::InitRun(PHCompositeNode *topNode)
0073 {
0074   PHNodeIterator iter(topNode);
0075 
0076   // Looking for the DST node
0077   PHCompositeNode *dstNode;
0078   dstNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "DST"));
0079   if (!dstNode)
0080   {
0081     std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0082               << "DST Node missing, doing nothing." << std::endl;
0083     exit(1);
0084   }
0085 
0086   try
0087   {
0088     CreateNodes(topNode);
0089   }
0090   catch (std::exception &e)
0091   {
0092     std::cout << e.what() << std::endl;
0093     return Fun4AllReturnCodes::ABORTRUN;
0094   }
0095 
0096   if (m_DoDecal)
0097   {
0098     if (m_Detector.c_str()[0] == 'H')
0099     {
0100       std::string url = CDBInterface::instance()->getUrl("HCALGAINSCORR");
0101       if (url.empty())
0102       {
0103         std::cout << PHWHERE << " Could not get Hcal Calibration for domain HCALGAINSCORR" << std::endl;
0104         gSystem->Exit(1);
0105         exit(1);
0106       }
0107 
0108       m_CDBTTree = new CDBTTree(url);
0109     }
0110     else if (m_Detector.c_str()[0] == 'C')
0111     {
0112       std::string url = CDBInterface::instance()->getUrl("CEMCGAINSCORR");
0113       if (url.empty())
0114       {
0115         std::cout << PHWHERE << " Could not get Cemc Calibration for domain CEMCGAINSCORR" << std::endl;
0116         gSystem->Exit(1);
0117         exit(1);
0118       }
0119 
0120       m_CDBTTree = new CDBTTree(url);
0121     }
0122     else
0123     {
0124       std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0125                 << "Calo Decal requested but Detector Name not HCALOUT/IN or CEMC"
0126                 << std::endl;
0127       gSystem->Exit(1);
0128     }
0129     // warnings for bad file names handled inside Open
0130   }
0131 
0132   return Fun4AllReturnCodes::EVENT_OK;
0133 }
0134 
0135 int RawTowerDigitizer::process_event(PHCompositeNode * /**topNode*/)
0136 {
0137   if (Verbosity())
0138   {
0139     std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0140               << "Process event entered. "
0141               << "Digitalization method: ";
0142 
0143     if (m_DigiAlgorithm == kNo_digitization)
0144     {
0145       std::cout << "directly pass the energy of sim tower to digitalized tower";
0146     }
0147     else if (m_DigiAlgorithm == kSimple_photon_digitization)
0148     {
0149       std::cout << "simple digitization with photon statistics, ADC conversion and pedstal";
0150     }
0151     std::cout << std::endl;
0152   }
0153   // loop over all possible towers, even empty ones. The digitization can add towers containing
0154   // pedestals
0155   RawTowerGeomContainer::ConstRange all_towers = m_RawTowerGeom->get_tower_geometries();
0156 
0157   double deadChanEnergy = 0;
0158 
0159   for (RawTowerGeomContainer::ConstIterator it = all_towers.first;
0160        it != all_towers.second; ++it)
0161   {
0162     const RawTowerDefs::keytype key = it->second->get_id();
0163     RawTowerDefs::CalorimeterId caloid = RawTowerDefs::decode_caloid(key);
0164     const int eta = it->second->get_bineta();
0165     const int phi = it->second->get_binphi();
0166 
0167     if (caloid == RawTowerDefs::LFHCAL)
0168     {
0169       const int l = it->second->get_binl();
0170       if (m_ZeroSuppressionFile == true)
0171       {
0172         const std::string zsName = "ZS_ADC_eta" + std::to_string(eta) + "_phi" + std::to_string(phi) + "_l" + std::to_string(l);
0173         m_ZeroSuppressionADC =
0174             _tower_params.get_double_param(zsName);
0175       }
0176 
0177       if (m_pedestalFile == true)
0178       {
0179         const std::string pedCentralName = "PedCentral_ADC_eta" + std::to_string(eta) + "_phi" + std::to_string(phi) + "_l" + std::to_string(l);
0180         m_PedstalCentralADC =
0181             _tower_params.get_double_param(pedCentralName);
0182         const std::string pedWidthName = "PedWidth_ADC_eta" + std::to_string(eta) + "_phi" + std::to_string(phi) + "_l" + std::to_string(l);
0183         m_PedstalWidthADC =
0184             _tower_params.get_double_param(pedWidthName);
0185       }
0186     }
0187     else
0188     {
0189       if (m_ZeroSuppressionFile == true)
0190       {
0191         const std::string zsName = "ZS_ADC_eta" + std::to_string(eta) + "_phi" + std::to_string(phi);
0192         m_ZeroSuppressionADC = _tower_params.get_double_param(zsName);
0193       }
0194 
0195       if (m_pedestalFile == true)
0196       {
0197         const std::string pedCentralName = "PedCentral_ADC_eta" + std::to_string(eta) + "_phi" + std::to_string(phi);
0198         m_PedstalCentralADC = _tower_params.get_double_param(pedCentralName);
0199         const std::string pedWidthName = "PedWidth_ADC_eta" + std::to_string(eta) + "_phi" + std::to_string(phi);
0200         m_PedstalWidthADC = _tower_params.get_double_param(pedWidthName);
0201       }
0202     }
0203 
0204     if (m_TowerType >= 0)
0205     {
0206       // Skip towers that don't match the type we are supposed to digitize
0207       if (m_TowerType != it->second->get_tower_type())
0208       {
0209         continue;
0210       }
0211     }
0212 
0213     RawTower *digi_tower = nullptr;
0214     TowerInfo *digi_towerinfo = nullptr;
0215 
0216     if (m_UseTowerInfo != 1)
0217     {
0218       RawTower *sim_tower = m_SimTowers->getTower(key);
0219       if (m_DeadMap)
0220       {
0221         if (m_DeadMap->isDeadTower(key))
0222         {
0223           if (sim_tower)
0224           {
0225             deadChanEnergy += sim_tower->get_energy();
0226           }
0227 
0228           sim_tower = nullptr;
0229 
0230           if (Verbosity() >= VERBOSITY_MORE)
0231           {
0232             std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0233                       << " apply dead tower " << key << std::endl;
0234           }
0235         }
0236       }
0237       if (m_DigiAlgorithm == kNo_digitization)
0238       {
0239         // for no digitization just copy existing towers
0240         if (sim_tower)
0241         {
0242           digi_tower = new RawTowerv2(*sim_tower);
0243         }
0244       }
0245       else if (m_DigiAlgorithm == kSimple_photon_digitization)
0246       {
0247         // for photon digitization towers can be created if sim_tower is null pointer
0248         digi_tower = simple_photon_digitization(sim_tower);
0249       }
0250       else if (m_DigiAlgorithm == kSiPM_photon_digitization)
0251       {
0252         // for photon digitization towers can be created if sim_tower is null pointer
0253         digi_tower = sipm_photon_digitization(sim_tower);
0254       }
0255       else
0256       {
0257         std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0258                   << " invalid digitization algorithm #" << m_DigiAlgorithm
0259                   << std::endl;
0260 
0261         return Fun4AllReturnCodes::ABORTRUN;
0262       }
0263 
0264       if (digi_tower)
0265       {
0266         if (m_DoDecal && m_Decal)
0267         {
0268           unsigned int etaphikey = phi;
0269           etaphikey = (etaphikey << 16U) + eta;
0270           float decal_fctr = m_CDBTTree->GetFloatValue(etaphikey, "etaphi");
0271 
0272           if (m_DecalInverse)
0273           {
0274             decal_fctr = 1.0 / decal_fctr;
0275           }
0276           float e_dec = digi_tower->get_energy();
0277           digi_tower->set_energy(e_dec * decal_fctr);
0278         }
0279         m_RawTowers->AddTower(key, digi_tower);
0280         if (Verbosity() >= VERBOSITY_MORE)
0281         {
0282           std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0283                     << " output tower:"
0284                     << std::endl;
0285           digi_tower->identify();
0286         }
0287       }
0288     }
0289 
0290     if (m_UseTowerInfo > 0)
0291     {
0292       unsigned int towerkey = ((unsigned int) (eta) << 16U) + phi;
0293       // unsigned int towerindex = m_SimTowerInfos->decode_key(towerkey);
0294       TowerInfo *sim_tower = m_SimTowerInfos->get_tower_at_key(towerkey);
0295       if (m_DeadMap)
0296       {
0297         if (m_DeadMap->isDeadTower(key))
0298         {
0299           if (sim_tower)
0300           {
0301             deadChanEnergy += sim_tower->get_energy();
0302           }
0303           sim_tower = nullptr;
0304           if (Verbosity() >= VERBOSITY_MORE)
0305           {
0306             std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0307                       << " apply dead tower " << key << std::endl;
0308           }
0309         }
0310       }
0311       if (m_DigiAlgorithm == kNo_digitization)
0312       {
0313         // for no digitization just copy existing towers
0314         if (sim_tower)
0315         {
0316           digi_towerinfo = new TowerInfov1(*sim_tower);
0317         }
0318       }
0319       else if (m_DigiAlgorithm == kSimple_photon_digitization)
0320       {
0321         // for photon digitization towers can be created if sim_tower is null pointer
0322         digi_towerinfo = simple_photon_digitization(sim_tower);
0323       }
0324       else if (m_DigiAlgorithm == kSiPM_photon_digitization)
0325       {
0326         // for photon digitization towers can be created if sim_tower is null pointer
0327         digi_towerinfo = sipm_photon_digitization(sim_tower);
0328       }
0329       else
0330       {
0331         std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0332                   << " invalid digitization algorithm #" << m_DigiAlgorithm
0333                   << std::endl;
0334 
0335         return Fun4AllReturnCodes::ABORTRUN;
0336       }
0337 
0338       if (digi_towerinfo)
0339       {
0340         if (m_DoDecal && m_Decal)
0341         {
0342           unsigned int etaphikey = phi;
0343           etaphikey = (etaphikey << 16U) + eta;
0344           float decal_fctr = m_CDBTTree->GetFloatValue(etaphikey, "etaphi");
0345           if (m_DecalInverse)
0346           {
0347             decal_fctr = 1.0 / decal_fctr;
0348           }
0349           float e_dec = digi_towerinfo->get_energy();
0350           digi_towerinfo->set_energy(e_dec * decal_fctr);
0351         }
0352         TowerInfo *digitized_towerinfo = m_RawTowerInfos->get_tower_at_key(towerkey);
0353         if (m_UseTowerInfo == 2)  // if reconstructing both RawTowers and towerinfo objects force them to be the same
0354         {
0355           if (digi_tower)
0356           {
0357             digitized_towerinfo->set_energy(digi_tower->get_energy());
0358           }
0359           else
0360           {
0361             digitized_towerinfo->set_energy(0);
0362           }
0363         }
0364         else
0365         {
0366           digitized_towerinfo->set_energy(digi_towerinfo->get_energy());
0367         }
0368       }
0369       delete digi_towerinfo;
0370     }
0371   }
0372 
0373   if (Verbosity())
0374   {
0375     if (m_UseTowerInfo != 1)
0376     {
0377       std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0378                 << "input sum energy = " << m_SimTowers->getTotalEdep() << " GeV"
0379                 << ", dead channel masked energy = " << deadChanEnergy << " GeV"
0380                 << ", output sum digitalized value = " << m_RawTowers->getTotalEdep() << " ADC"
0381                 << std::endl;
0382     }
0383   }
0384   return Fun4AllReturnCodes::EVENT_OK;
0385 }
0386 
0387 RawTower *
0388 RawTowerDigitizer::simple_photon_digitization(RawTower *sim_tower)
0389 {
0390   RawTower *digi_tower = nullptr;
0391 
0392   double energy = 0.;
0393   if (sim_tower)
0394   {
0395     energy = sim_tower->get_energy();
0396   }
0397   const double photon_count_mean = energy * m_PhotonElecYieldVisibleGeV;
0398   const int photon_count = gsl_ran_poisson(m_RandomGenerator, photon_count_mean);
0399 
0400   const int signal_ADC = floor(photon_count / m_PhotonElecADC);
0401   const double pedestal = m_PedstalCentralADC + ((m_PedstalWidthADC > 0) ? gsl_ran_gaussian(m_RandomGenerator, m_PedstalWidthADC) : 0);
0402 
0403   const int sum_ADC = signal_ADC + (int) pedestal;
0404 
0405   double sum_ADC_d = (double) sum_ADC;
0406 
0407   // temporary fix to remove digitization
0408   // for decalibration tests
0409   // to be replaced permanently for all cases
0410   // with sim of pulse extraction/fitting
0411   if (m_DoDecal)
0412   {
0413     double signal_ADC_d = 1. * photon_count;
0414     signal_ADC_d /= m_PhotonElecADC;
0415 
0416     sum_ADC_d = signal_ADC_d + pedestal;
0417   }
0418 
0419   if (sum_ADC > m_ZeroSuppressionADC)
0420   {
0421     // create new digitalizaed tower
0422     if (sim_tower)
0423     {
0424       digi_tower = new RawTowerv2(*sim_tower);
0425     }
0426     else
0427     {
0428       digi_tower = new RawTowerv2();
0429     }
0430     digi_tower->set_energy(sum_ADC_d);
0431   }
0432 
0433   if (Verbosity() >= 2)
0434   {
0435     std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0436               << std::endl;
0437 
0438     std::cout << "input: ";
0439     if (sim_tower)
0440     {
0441       sim_tower->identify();
0442     }
0443     else
0444     {
0445       std::cout << "None" << std::endl;
0446     }
0447     std::cout << "output based on "
0448               << "sum_ADC = " << sum_ADC << ", zero_sup = "
0449               << m_ZeroSuppressionADC << " : ";
0450     if (digi_tower)
0451     {
0452       digi_tower->identify();
0453     }
0454     else
0455     {
0456       std::cout << "None" << std::endl;
0457     }
0458   }
0459   return digi_tower;
0460 }
0461 
0462 TowerInfo *
0463 RawTowerDigitizer::simple_photon_digitization(TowerInfo *sim_tower)
0464 {
0465   TowerInfo *digi_tower = nullptr;
0466   if (sim_tower)
0467   {
0468     digi_tower = new TowerInfov1(*sim_tower);
0469   }
0470   else
0471   {
0472     digi_tower = new TowerInfov1();
0473   }
0474   double energy = 0.;
0475   if (sim_tower)
0476   {
0477     energy = sim_tower->get_energy();
0478   }
0479   const double photon_count_mean = energy * m_PhotonElecYieldVisibleGeV;
0480   const int photon_count = gsl_ran_poisson(m_RandomGenerator, photon_count_mean);
0481 
0482   const int signal_ADC = floor(photon_count / m_PhotonElecADC);
0483   const double pedestal = m_PedstalCentralADC + ((m_PedstalWidthADC > 0) ? gsl_ran_gaussian(m_RandomGenerator, m_PedstalWidthADC) : 0);
0484 
0485   const int sum_ADC = signal_ADC + (int) pedestal;
0486 
0487   double sum_ADC_d = (double) sum_ADC;
0488 
0489   // temporary fix to remove digitization
0490   // for decalibration tests
0491   // to be replaced permanently for all cases
0492   // with sim of pulse extraction/fitting
0493   if (m_DoDecal)
0494   {
0495     double signal_ADC_d = 1. * photon_count;
0496     signal_ADC_d /= m_PhotonElecADC;
0497 
0498     sum_ADC_d = signal_ADC_d + pedestal;
0499   }
0500 
0501   if (sum_ADC > m_ZeroSuppressionADC)
0502   {
0503     digi_tower->set_energy(sum_ADC_d);
0504   }
0505 
0506   if (Verbosity() >= 2)
0507   {
0508     std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0509               << std::endl;
0510 
0511     std::cout << "input: ";
0512     if (sim_tower)
0513     {
0514       sim_tower->identify();
0515     }
0516     else
0517     {
0518       std::cout << "None" << std::endl;
0519     }
0520     std::cout << "output based on "
0521               << "sum_ADC = " << sum_ADC << ", zero_sup = "
0522               << m_ZeroSuppressionADC << " : ";
0523     if (digi_tower)
0524     {
0525       digi_tower->identify();
0526     }
0527     else
0528     {
0529       std::cout << "None" << std::endl;
0530     }
0531   }
0532   return digi_tower;
0533 }
0534 
0535 RawTower *
0536 RawTowerDigitizer::sipm_photon_digitization(RawTower *sim_tower)
0537 {
0538   RawTower *digi_tower = nullptr;
0539 
0540   double energy = 0;
0541   if (sim_tower)
0542   {
0543     energy = sim_tower->get_energy();
0544   }
0545 
0546   int signal_ADC = 0;
0547 
0548   if (energy > 0)
0549   {
0550     const double photon_count_mean = energy * m_PhotonElecYieldVisibleGeV;
0551     const double poission_param_per_pixel = photon_count_mean / m_SiPMEffectivePixel;
0552     const double prob_activated_per_pixel = gsl_cdf_poisson_Q(0, poission_param_per_pixel);
0553     const double active_pixel = gsl_ran_binomial(m_RandomGenerator, prob_activated_per_pixel, m_SiPMEffectivePixel);
0554     signal_ADC = floor(active_pixel / m_PhotonElecADC);
0555   }
0556 
0557   const double pedstal = m_PedstalCentralADC + ((m_PedstalWidthADC > 0) ? gsl_ran_gaussian(m_RandomGenerator, m_PedstalWidthADC) : 0);
0558   const int sum_ADC = signal_ADC + (int) pedstal;
0559 
0560   if (sum_ADC > m_ZeroSuppressionADC)
0561   {
0562     // create new digitalizaed tower
0563     if (sim_tower)
0564     {
0565       digi_tower = new RawTowerv2(*sim_tower);
0566     }
0567     else
0568     {
0569       digi_tower = new RawTowerv2();
0570     }
0571     digi_tower->set_energy((double) sum_ADC);
0572   }
0573 
0574   if (Verbosity() >= 2)
0575   {
0576     std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0577               << std::endl;
0578 
0579     std::cout << "input: ";
0580     if (sim_tower)
0581     {
0582       sim_tower->identify();
0583     }
0584     else
0585     {
0586       std::cout << "None" << std::endl;
0587     }
0588     std::cout << "output based on "
0589               << "sum_ADC = " << sum_ADC << ", zero_sup = "
0590               << m_ZeroSuppressionADC << " : ";
0591     if (digi_tower)
0592     {
0593       digi_tower->identify();
0594     }
0595     else
0596     {
0597       std::cout << "None" << std::endl;
0598     }
0599   }
0600 
0601   return digi_tower;
0602 }
0603 
0604 TowerInfo *
0605 RawTowerDigitizer::sipm_photon_digitization(TowerInfo *sim_tower)
0606 {
0607   TowerInfo *digi_tower = nullptr;
0608 
0609   double energy = 0;
0610   if (sim_tower)
0611   {
0612     energy = sim_tower->get_energy();
0613   }
0614 
0615   int signal_ADC = 0;
0616 
0617   if (energy > 0)
0618   {
0619     const double photon_count_mean = energy * m_PhotonElecYieldVisibleGeV;
0620     const double poission_param_per_pixel = photon_count_mean / m_SiPMEffectivePixel;
0621     const double prob_activated_per_pixel = gsl_cdf_poisson_Q(0, poission_param_per_pixel);
0622     const double active_pixel = gsl_ran_binomial(m_RandomGenerator, prob_activated_per_pixel, m_SiPMEffectivePixel);
0623     signal_ADC = floor(active_pixel / m_PhotonElecADC);
0624   }
0625 
0626   const double pedstal = m_PedstalCentralADC + ((m_PedstalWidthADC > 0) ? gsl_ran_gaussian(m_RandomGenerator, m_PedstalWidthADC) : 0);
0627   const int sum_ADC = signal_ADC + (int) pedstal;
0628 
0629   if (sum_ADC > m_ZeroSuppressionADC)
0630   {
0631     // create new digitalizaed tower
0632     if (sim_tower)
0633     {
0634       digi_tower = new TowerInfov1(*sim_tower);
0635     }
0636     else
0637     {
0638       digi_tower = new TowerInfov1();
0639     }
0640     digi_tower->set_energy((double) sum_ADC);
0641   }
0642 
0643   if (Verbosity() >= 2)
0644   {
0645     std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0646               << std::endl;
0647 
0648     std::cout << "input: ";
0649     if (sim_tower)
0650     {
0651       sim_tower->identify();
0652     }
0653     else
0654     {
0655       std::cout << "None" << std::endl;
0656     }
0657     std::cout << "output based on "
0658               << "sum_ADC = " << sum_ADC << ", zero_sup = "
0659               << m_ZeroSuppressionADC << " : ";
0660     if (digi_tower)
0661     {
0662       digi_tower->identify();
0663     }
0664     else
0665     {
0666       std::cout << "None" << std::endl;
0667     }
0668   }
0669   return digi_tower;
0670 }
0671 
0672 void RawTowerDigitizer::CreateNodes(PHCompositeNode *topNode)
0673 {
0674   PHNodeIterator iter(topNode);
0675   PHCompositeNode *runNode = static_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "RUN"));
0676   if (!runNode)
0677   {
0678     std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0679               << "Run Node missing, doing nothing." << std::endl;
0680     throw std::runtime_error("Failed to find Run node in RawTowerDigitizer::CreateNodes");
0681   }
0682 
0683   std::string TowerGeomNodeName = "TOWERGEOM_" + m_Detector;
0684   m_RawTowerGeom = findNode::getClass<RawTowerGeomContainer>(topNode, TowerGeomNodeName);
0685   if (!m_RawTowerGeom)
0686   {
0687     std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0688               << " " << TowerGeomNodeName << " Node missing, doing bail out!"
0689               << std::endl;
0690     throw std::runtime_error("Failed to find " + TowerGeomNodeName + " node in RawTowerDigitizer::CreateNodes");
0691   }
0692 
0693   if (Verbosity() >= 1)
0694   {
0695     m_RawTowerGeom->identify();
0696   }
0697 
0698   const std::string deadMapName = "DEADMAP_" + m_Detector;
0699   m_DeadMap = findNode::getClass<RawTowerDeadMap>(topNode, deadMapName);
0700   if (m_DeadMap)
0701   {
0702     std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0703               << " use dead map: ";
0704     m_DeadMap->identify();
0705   }
0706 
0707   PHCompositeNode *dstNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "DST"));
0708   if (!dstNode)
0709   {
0710     std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0711               << "DST Node missing, doing nothing." << std::endl;
0712     throw std::runtime_error("Failed to find DST node in RawTowerDigitizer::CreateNodes");
0713   }
0714 
0715   if (m_UseTowerInfo != 1)
0716   {
0717     std::string SimTowerNodeName = "TOWER_" + m_SimTowerNodePrefix + "_" + m_Detector;
0718     m_SimTowers = findNode::getClass<RawTowerContainer>(dstNode, SimTowerNodeName);
0719     if (!m_SimTowers)
0720     {
0721       std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0722                 << " " << SimTowerNodeName << " Node missing, doing bail out!"
0723                 << std::endl;
0724       throw std::runtime_error("Failed to find " + SimTowerNodeName + " node in RawTowerDigitizer::CreateNodes");
0725     }
0726   }
0727   if (m_UseTowerInfo > 0)
0728   {
0729     std::string SimTowerInfoNodeName = "TOWERINFO_" + m_SimTowerNodePrefix + "_" + m_Detector;
0730     m_SimTowerInfos = findNode::getClass<TowerInfoContainer>(dstNode, SimTowerInfoNodeName);
0731     if (!m_SimTowerInfos)
0732     {
0733       std::cout << Name() << "::" << m_Detector << "::" << __PRETTY_FUNCTION__
0734                 << " " << SimTowerInfoNodeName << " Node missing, doing bail out!"
0735                 << std::endl;
0736       throw std::runtime_error("Failed to find " + SimTowerInfoNodeName + " node in RawTowerDigitizer::CreateNodes");
0737     }
0738   }
0739 
0740   // Create the tower nodes on the tree
0741   PHNodeIterator dstiter(dstNode);
0742   PHCompositeNode *DetNode = dynamic_cast<PHCompositeNode *>(dstiter.findFirst("PHCompositeNode", m_Detector));
0743   if (!DetNode)
0744   {
0745     DetNode = new PHCompositeNode(m_Detector);
0746     dstNode->addNode(DetNode);
0747   }
0748 
0749   // Be careful as a previous digitizer may have been registered for this detector
0750 
0751   if (m_UseTowerInfo != 1)
0752   {
0753     std::string RawTowerNodeName = "TOWER_" + m_RawTowerNodePrefix + "_" + m_Detector;
0754     m_RawTowers = findNode::getClass<RawTowerContainer>(DetNode, RawTowerNodeName);
0755     if (!m_RawTowers)
0756     {
0757       m_RawTowers = new RawTowerContainer(m_SimTowers->getCalorimeterID());
0758       PHIODataNode<PHObject> *towerNode = new PHIODataNode<PHObject>(m_RawTowers,
0759                                                                      RawTowerNodeName, "PHObject");
0760       DetNode->addNode(towerNode);
0761     }
0762   }
0763   if (m_UseTowerInfo > 0)
0764   {
0765     std::string TowerInfoNodeName = "TOWERINFO_" + m_RawTowerNodePrefix + "_" + m_Detector;
0766     m_RawTowerInfos = findNode::getClass<TowerInfoContainer>(DetNode, TowerInfoNodeName);
0767     if (m_RawTowerInfos == nullptr)
0768     {
0769       TowerInfoContainer::DETECTOR detec;
0770       if (m_Detector == "CEMC")
0771       {
0772         detec = TowerInfoContainer::DETECTOR::EMCAL;
0773       }
0774       else if (m_Detector == "HCALIN" || m_Detector == "HCALOUT")
0775       {
0776         detec = TowerInfoContainer::DETECTOR::HCAL;
0777       }
0778       else
0779       {
0780         std::cout << PHWHERE << "Detector not implemented into the TowerInfoContainer object, defaulting to HCal implementation." << std::endl;
0781         detec = TowerInfoContainer::DETECTOR::HCAL;
0782       }
0783       m_RawTowerInfos = new TowerInfoContainerv1(detec);
0784       PHIODataNode<PHObject> *towerinfoNode = new PHIODataNode<PHObject>(m_RawTowerInfos, TowerInfoNodeName, "PHObject");
0785       DetNode->addNode(towerinfoNode);
0786     }
0787   }
0788 
0789   return;
0790 }
[ 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!