packages/CaloReco/CaloTowerCalib.cc

0001 #include "CaloTowerCalib.h"
0002 #include "CaloTowerDefs.h"
0003
0004 #include <calobase/TowerInfo.h>  // for TowerInfo
0005 #include <calobase/TowerInfoContainer.h>
0006 #include <calobase/TowerInfoContainerv1.h>
0007 #include <calobase/TowerInfoContainerv2.h>
0008 #include <calobase/TowerInfov1.h>
0009 #include <calobase/TowerInfov2.h>
0010
0011 #include <cdbobjects/CDBTTree.h>  // for CDBTTree
0012
0013 #include <ffamodules/CDBInterface.h>
0014
0015 #include <ffaobjects/EventHeader.h>
0016
0017 #include <fun4all/Fun4AllReturnCodes.h>
0018 #include <fun4all/SubsysReco.h>  // for SubsysReco
0019
0020 #include <phool/PHCompositeNode.h>
0021 #include <phool/PHIODataNode.h>    // for PHIODataNode
0022 #include <phool/PHNode.h>          // for PHNode
0023 #include <phool/PHNodeIterator.h>  // for PHNodeIterator
0024 #include <phool/PHObject.h>        // for PHObject
0025 #include <phool/getClass.h>
0026 #include <phool/phool.h>
0027 #include <phool/recoConsts.h>
0028
0029 #include <TSystem.h>
0030
0031 #include <cstdlib>    // for exit
0032 #include <exception>  // for exception
0033 #include <iostream>   // for operator<<, basic_ostream
0034 #include <stdexcept>  // for runtime_error
0035
0036 //____________________________________________________________________________..
0037 CaloTowerCalib::CaloTowerCalib(const std::string &name)
0038   : SubsysReco(name)
0039   , m_dettype(CaloTowerDefs::HCALOUT)
0040   , m_detector("HCALOUT")
0041   , m_DETECTOR(TowerInfoContainer::HCAL)
0042 {
0043   if (Verbosity() > 0)
0044   {
0045     std::cout << "CaloTowerCalib::CaloTowerCalib(const std::string &name) Calling ctor" << std::endl;
0046   }
0047 }
0048
0049 //____________________________________________________________________________..
0050 CaloTowerCalib::~CaloTowerCalib()
0051 {
0052   delete cdbttree;
0053   delete cdbttree_time;
0054   delete cdbttree_ZScrosscalib;
0055   if (Verbosity() > 0)
0056   {
0057     std::cout << "CaloTowerCalib::~CaloTowerCalib() Calling dtor" << std::endl;
0058   }
0059 }
0060
0061 //____________________________________________________________________________..
0062 int CaloTowerCalib::InitRun(PHCompositeNode *topNode)
0063 {
0064   PHNodeIterator nodeIter(topNode);
0065
0066   if (m_dettype == CaloTowerDefs::CEMC)
0067   {
0068     m_detector = "CEMC";
0069     m_DETECTOR = TowerInfoContainer::EMCAL;
0070   }
0071   else if (m_dettype == CaloTowerDefs::HCALIN)
0072   {
0073     m_detector = "HCALIN";
0074     m_DETECTOR = TowerInfoContainer::HCAL;
0075   }
0076   else if (m_dettype == CaloTowerDefs::HCALOUT)
0077   {
0078     m_detector = "HCALOUT";
0079     m_DETECTOR = TowerInfoContainer::HCAL;
0080   }
0081   else if (m_dettype == CaloTowerDefs::ZDC)
0082   {
0083     m_detector = "ZDC";
0084     m_DETECTOR = TowerInfoContainer::ZDC;
0085   }
0086   else if (m_dettype == CaloTowerDefs::SEPD)
0087   {
0088     m_detector = "SEPD";
0089     m_DETECTOR = TowerInfoContainer::SEPD;
0090   }
0091
0092   ///////////////////////////////////////
0093   // energy calibration getting from CDB
0094   std::string default_time_independent_calib = m_detector+"_calib_ADC_to_ETower_default";
0095   if (!m_overrideCalibName)
0096   {
0097     m_calibName = m_detector+"_calib_ADC_to_ETower";
0098   }
0099   if (!m_overrideFieldName)
0100   {
0101     m_fieldname = m_detector+"_calib_ADC_to_ETower";
0102   }
0103
0104   if (m_giveDirectURL)
0105   {
0106     cdbttree = new CDBTTree(m_directURL);
0107   }
0108   else
0109   {
0110     std::string calibdir = CDBInterface::instance()->getUrl(m_calibName);
0111     if (!calibdir.empty())
0112     {
0113       cdbttree = new CDBTTree(calibdir);
0114     }
0115     else
0116     {
0117       calibdir = CDBInterface::instance()->getUrl(default_time_independent_calib);
0118
0119       if (calibdir.empty())
0120       {
0121         std::cout << "CaloTowerCalib::::InitRun No EMCal Calibration NOT even a default" << std::endl;
0122         exit(1);
0123       }
0124       cdbttree = new CDBTTree(calibdir);
0125       std::cout << "CaloTowerCalib::::InitRun No specific file for " << m_calibName << " found, using default calib " << default_time_independent_calib << std::endl;
0126     }
0127   }
0128
0129   //////////////////////////////////
0130   //time calibration getting the CDB
0131   m_calibName_time = m_detector + "_meanTime";
0132   m_fieldname_time = "time";
0133   std::string calibdir;
0134
0135   if (m_giveDirectURL_time)
0136   {
0137     calibdir = m_directURL_time;
0138     std::cout << "CaloTowerCalib::InitRun: Using setted url " << calibdir << std::endl;
0139     cdbttree_time = new CDBTTree(calibdir);
0140   }
0141   else
0142   {
0143     calibdir = CDBInterface::instance()->getUrl(m_calibName_time);
0144     if (!calibdir.empty())
0145     {
0146       cdbttree_time = new CDBTTree(calibdir);
0147       if (Verbosity() > 0)
0148       {
0149         std::cout << "CaloTowerCalib:InitRun Found " << m_calibName_time << " doing time calibration" << std::endl;
0150       }
0151     }
0152     else
0153     {
0154       m_dotimecalib = false;
0155       if (Verbosity() > 0)
0156       {
0157         std::cout << "CaloTowerCalib::InitRun no timing info, " << m_calibName_time << " not found, not doing time calibration" << std::endl;
0158       }
0159     }
0160   }
0161
0162   ////////////////////////////////////
0163   //Zero suppression cross calibration getting the CDB
0164   m_calibName_ZScrosscalib = m_detector + "_ZSCrossCalib";
0165   m_fieldname_ZScrosscalib = "ratio";
0166
0167   if (m_doZScrosscalib)
0168   {
0169     if (m_giveDirectURL_ZScrosscalib)
0170     {
0171       calibdir = m_directURL_ZScrosscalib;
0172       std::cout << "CaloTowerCalib::InitRun: Using setted url " << calibdir << std::endl;
0173       cdbttree_ZScrosscalib = new CDBTTree(calibdir);
0174     }
0175     else
0176     {
0177       calibdir = CDBInterface::instance()->getUrl(m_calibName_ZScrosscalib);
0178       if (!calibdir.empty())
0179       {
0180         cdbttree_ZScrosscalib = new CDBTTree(calibdir);
0181         if (Verbosity() > 0)
0182         {
0183           std::cout << "CaloTowerCalib:InitRun Found " << m_calibName_ZScrosscalib << " doing ZS cross calibration" << std::endl;
0184         }
0185       }
0186       else
0187       {
0188         m_doZScrosscalib = false;
0189         if (Verbosity() > 0)
0190         {
0191           std::cout << "CaloTowerCalib::InitRun no ZS cross calib info, " << m_calibName_ZScrosscalib << " not found, not doing ZS cross calibration" << std::endl;
0192         }
0193       }
0194     }
0195   }
0196
0197   PHNodeIterator iter(topNode);
0198
0199   // Looking for the DST node
0200   PHCompositeNode *dstNode;
0201   dstNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "DST"));
0202   if (!dstNode)
0203   {
0204     std::cout << Name() << "::" << m_detector << "::" << __PRETTY_FUNCTION__
0205               << "DST Node missing, doing nothing." << std::endl;
0206     exit(1);
0207   }
0208   try
0209   {
0210     CreateNodeTree(topNode);
0211   }
0212   catch (std::exception &e)
0213   {
0214     std::cout << e.what() << std::endl;
0215     return Fun4AllReturnCodes::ABORTRUN;
0216   }
0217   if (Verbosity() > 0)
0218   {
0219     topNode->print();
0220   }
0221   return Fun4AllReturnCodes::EVENT_OK;
0222 }
0223
0224 //____________________________________________________________________________..
0225 int CaloTowerCalib::process_event(PHCompositeNode *topNode)
0226 {
0227   TowerInfoContainer *_raw_towers = findNode::getClass<TowerInfoContainer>(topNode, RawTowerNodeName);
0228   TowerInfoContainer *_calib_towers = findNode::getClass<TowerInfoContainer>(topNode, CalibTowerNodeName);
0229   unsigned int ntowers = _raw_towers->size();
0230
0231   for (unsigned int channel = 0; channel < ntowers; channel++)
0232   {
0233     unsigned int key = _raw_towers->encode_key(channel);
0234     TowerInfo *caloinfo_raw = _raw_towers->get_tower_at_channel(channel);
0235     _calib_towers->get_tower_at_channel(channel)->copy_tower(caloinfo_raw);
0236     float raw_amplitude = caloinfo_raw->get_energy();
0237     float calibconst = cdbttree->GetFloatValue(key, m_fieldname);
0238     bool isZS = caloinfo_raw->get_isZS();
0239
0240     if (isZS && m_doZScrosscalib)
0241     {
0242       float crosscalibconst = cdbttree_ZScrosscalib->GetFloatValue(key, m_fieldname_ZScrosscalib);
0243       if (crosscalibconst == 0)
0244       {
0245         crosscalibconst = 1;
0246       }
0247       _calib_towers->get_tower_at_channel(channel)->set_energy(raw_amplitude * calibconst * crosscalibconst);
0248     }
0249     else
0250     {
0251       _calib_towers->get_tower_at_channel(channel)->set_energy(raw_amplitude * calibconst);
0252     }
0253
0254     if (calibconst == 0)
0255     {
0256       _calib_towers->get_tower_at_channel(channel)->set_isNoCalib(true);
0257     }
0258     if(m_dotimecalib)
0259     {
0260       //timing is not useful for ZS towers
0261       if(!isZS)
0262       {
0263       //I realized that there is no point to do timing calibration for the towerinfov1 object since the resolution is not enough...
0264       float raw_time = caloinfo_raw->get_time_float();
0265       float meantime = cdbttree_time->GetFloatValue(key, m_fieldname_time);
0266       _calib_towers->get_tower_at_channel(channel)->set_time_float(raw_time - meantime);
0267       }
0268     }
0269   }
0270   return Fun4AllReturnCodes::EVENT_OK;
0271 }
0272
0273 void CaloTowerCalib::CreateNodeTree(PHCompositeNode *topNode)
0274 {
0275   PHNodeIterator iter(topNode);
0276   PHCompositeNode *dstNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "DST"));
0277   if (!dstNode)
0278   {
0279     std::cerr << Name() << "::" << m_detector << "::" << __PRETTY_FUNCTION__
0280               << "DST Node missing, doing nothing." << std::endl;
0281     throw std::runtime_error("Failed to find DST node in RawTowerCalibration::CreateNodes");
0282   }
0283   // detector node
0284
0285   PHCompositeNode *DetNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", m_detector));
0286
0287   if (!DetNode)
0288   {
0289     DetNode = new PHCompositeNode(m_detector);
0290     dstNode->addNode(DetNode);
0291   }
0292
0293   // towers
0294   RawTowerNodeName = m_inputNodePrefix + m_detector;
0295   TowerInfoContainer *_raw_towers = findNode::getClass<TowerInfoContainer>(dstNode, RawTowerNodeName);
0296   if (!_raw_towers)
0297   {
0298     std::cout << Name() << "::" << m_detector << "::" << __PRETTY_FUNCTION__
0299               << " " << RawTowerNodeName << " Node missing, doing bail out!"
0300               << std::endl;
0301     throw std::runtime_error(
0302         "Failed to find " + RawTowerNodeName + " node in RawTowerCalibration::CreateNodes");
0303   }
0304
0305   CalibTowerNodeName = m_outputNodePrefix + m_detector;
0306   TowerInfoContainer *_calib_towers = findNode::getClass<TowerInfoContainer>(dstNode, CalibTowerNodeName);
0307   if (!_calib_towers)
0308   {
0309     _calib_towers = dynamic_cast<TowerInfoContainer *>(_raw_towers->CloneMe());
0310   }
0311   PHIODataNode<PHObject> *calibtowerNode = new PHIODataNode<PHObject>(_calib_towers, CalibTowerNodeName, "PHObject");
0312   DetNode->addNode(calibtowerNode);
0313   return;
0314 }