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     LoadCalib(topNode);
0212   }
0213   catch (std::exception &e)
0214   {
0215     std::cout << e.what() << std::endl;
0216     return Fun4AllReturnCodes::ABORTRUN;
0217   }
0218   if (Verbosity() > 0)
0219   {
0220     topNode->print();
0221   }
0222   return Fun4AllReturnCodes::EVENT_OK;
0223 }
0224
0225 void CaloTowerCalib::LoadCalib(PHCompositeNode *topNode)
0226 {
0227   TowerInfoContainer *_raw_towers = findNode::getClass<TowerInfoContainer>(topNode, RawTowerNodeName);
0228   unsigned int ntowers = _raw_towers->size();
0229   m_cdbInfo_vec.resize(ntowers);
0230
0231   for (unsigned int channel = 0; channel < ntowers; channel++)
0232   {
0233     unsigned int key = _raw_towers->encode_key(channel);
0234
0235     m_cdbInfo_vec[channel].calibconst = cdbttree->GetFloatValue(key, m_fieldname);
0236
0237     if (m_doZScrosscalib)
0238     {
0239       m_cdbInfo_vec[channel].crosscalibconst = cdbttree_ZScrosscalib->GetFloatValue(key, m_fieldname_ZScrosscalib);
0240     }
0241
0242     if(m_dotimecalib)
0243     {
0244       m_cdbInfo_vec[channel].meantime = cdbttree_time->GetFloatValue(key, m_fieldname_time);
0245     }
0246   }
0247 }
0248
0249 //____________________________________________________________________________..
0250 int CaloTowerCalib::process_event(PHCompositeNode *topNode)
0251 {
0252   TowerInfoContainer *_raw_towers = findNode::getClass<TowerInfoContainer>(topNode, RawTowerNodeName);
0253   TowerInfoContainer *_calib_towers = findNode::getClass<TowerInfoContainer>(topNode, CalibTowerNodeName);
0254   unsigned int ntowers = _raw_towers->size();
0255
0256   for (unsigned int channel = 0; channel < ntowers; channel++)
0257   {
0258     TowerInfo *caloinfo_raw = _raw_towers->get_tower_at_channel(channel);
0259     _calib_towers->get_tower_at_channel(channel)->copy_tower(caloinfo_raw);
0260     float raw_amplitude = caloinfo_raw->get_energy();
0261     float calibconst = m_cdbInfo_vec[channel].calibconst;
0262     bool isZS = caloinfo_raw->get_isZS();
0263
0264     if (isZS && m_doZScrosscalib)
0265     {
0266       float crosscalibconst = m_cdbInfo_vec[channel].crosscalibconst;
0267       if (crosscalibconst == 0)
0268       {
0269         crosscalibconst = 1;
0270       }
0271       _calib_towers->get_tower_at_channel(channel)->set_energy(raw_amplitude * calibconst * crosscalibconst);
0272     }
0273     else
0274     {
0275       _calib_towers->get_tower_at_channel(channel)->set_energy(raw_amplitude * calibconst);
0276     }
0277
0278     if (calibconst == 0)
0279     {
0280       _calib_towers->get_tower_at_channel(channel)->set_isNoCalib(true);
0281     }
0282     if(m_dotimecalib)
0283     {
0284       //timing is not useful for ZS towers
0285       if(!isZS)
0286       {
0287       //I realized that there is no point to do timing calibration for the towerinfov1 object since the resolution is not enough...
0288       float raw_time = caloinfo_raw->get_time();
0289       float meantime = m_cdbInfo_vec[channel].meantime;
0290       _calib_towers->get_tower_at_channel(channel)->set_time(raw_time - meantime);
0291       }
0292     }
0293   }
0294   return Fun4AllReturnCodes::EVENT_OK;
0295 }
0296
0297 void CaloTowerCalib::CreateNodeTree(PHCompositeNode *topNode)
0298 {
0299   PHNodeIterator iter(topNode);
0300   PHCompositeNode *dstNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "DST"));
0301   if (!dstNode)
0302   {
0303     std::cerr << Name() << "::" << m_detector << "::" << __PRETTY_FUNCTION__
0304               << "DST Node missing, doing nothing." << std::endl;
0305     throw std::runtime_error("Failed to find DST node in RawTowerCalibration::CreateNodes");
0306   }
0307   // detector node
0308
0309   PHCompositeNode *DetNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", m_detector));
0310
0311   if (!DetNode)
0312   {
0313     DetNode = new PHCompositeNode(m_detector);
0314     dstNode->addNode(DetNode);
0315   }
0316
0317   // towers
0318   RawTowerNodeName = m_inputNodePrefix + m_detector;
0319   TowerInfoContainer *_raw_towers = findNode::getClass<TowerInfoContainer>(dstNode, RawTowerNodeName);
0320   if (!_raw_towers)
0321   {
0322     std::cout << Name() << "::" << m_detector << "::" << __PRETTY_FUNCTION__
0323               << " " << RawTowerNodeName << " Node missing, doing bail out!"
0324               << std::endl;
0325     throw std::runtime_error(
0326         "Failed to find " + RawTowerNodeName + " node in RawTowerCalibration::CreateNodes");
0327   }
0328
0329   CalibTowerNodeName = m_outputNodePrefix + m_detector;
0330   TowerInfoContainer *_calib_towers = findNode::getClass<TowerInfoContainer>(dstNode, CalibTowerNodeName);
0331   if (!_calib_towers)
0332   {
0333     _calib_towers = dynamic_cast<TowerInfoContainer *>(_raw_towers->CloneMe());
0334   }
0335   PHIODataNode<PHObject> *calibtowerNode = new PHIODataNode<PHObject>(_calib_towers, CalibTowerNodeName, "PHObject");
0336   DetNode->addNode(calibtowerNode);
0337   return;
0338 }