TriggerClusterMaker/src/TriggerClusterMaker.cc

0001 // ----------------------------------------------------------------------------
0002 /*! \file    TriggerClusterMaker.cc'
0003  *  \authors Derek Anderson
0004  *  \date    05.15.2024
0005  *
0006  *  A Fun4All module to construct trigger clusters,
0007  *  jet patches stored in RawCluster objects, for
0008  *  downstream analysis
0009  */
0010 // ----------------------------------------------------------------------------
0011
0012 #define TRIGGERCLUSTERMAKER_CC
0013
0014 // c++ utiilites
0015 #include <algorithm>
0016 #include <cassert>
0017 #include <iostream>
0018 // calo base
0019 #include <calobase/RawClusterv1.h>
0020 #include <calobase/TowerInfo.h>
0021 #include <calobase/TowerInfoContainer.h>
0022 // trigger libraries
0023 #include <calotrigger/LL1Out.h>
0024 #include <calotrigger/LL1Outv1.h>
0025 #include <calotrigger/TriggerPrimitiveContainer.h>
0026 #include <calotrigger/TriggerPrimitiveContainerv1.h>
0027 // f4a libraries
0028 #include <fun4all/Fun4AllReturnCodes.h>
0029 // phool libraries
0030 #include <phool/getClass.h>
0031 #include <phool/phool.h>
0032 #include <phool/PHCompositeNode.h>
0033 #include <phool/PHIODataNode.h>
0034 #include <phool/PHNode.h>
0035 #include <phool/PHNodeIterator.h>
0036 #include <phool/PHObject.h>
0037
0038 // module definition
0039 #include "TriggerClusterMaker.h"
0040
0041
0042
0043 // ctor/dtor ==================================================================
0044
0045 // ----------------------------------------------------------------------------
0046 //! Module constructor
0047 // ----------------------------------------------------------------------------
0048 TriggerClusterMaker::TriggerClusterMaker(const std::string &name) : SubsysReco(name) {
0049
0050   // print debug message
0051   if (m_config.debug && (Verbosity() > 0)) {
0052     std::cout << "TriggerClusterMaker::TriggerClusterMaker(const std::string &name) Calling ctor" << std::endl;
0053   }
0054
0055   // set tower nodes to null
0056   std::fill(m_inTowerNodes.begin(), m_inTowerNodes.end(), nullptr);
0057
0058   // make sure vectors are clear
0059   m_inLL1Nodes.clear();
0060   m_inPrimNodes.clear();
0061
0062 }  // end ctor
0063
0064
0065
0066 // ----------------------------------------------------------------------------
0067 //! Module destructor
0068 // ----------------------------------------------------------------------------
0069 TriggerClusterMaker::~TriggerClusterMaker() {
0070
0071   // print debug message
0072   if (m_config.debug && (Verbosity() > 0)) {
0073     std::cout << "TriggerClusterMaker::~TriggerClusterMaker() Calling dtor" << std::endl;
0074   }
0075
0076   /* nothing to do */
0077
0078 }  // end dtor
0079
0080
0081
0082 // fun4all methods ============================================================
0083
0084 // ----------------------------------------------------------------------------
0085 //! Initialize module
0086 // ----------------------------------------------------------------------------
0087 int TriggerClusterMaker::Init(PHCompositeNode* topNode) {
0088
0089   if (m_config.debug) {
0090     std::cout << "TriggerClusterMaker::Init(PHCompositeNode *topNode) Initializing" << std::endl;
0091   }
0092
0093   // initialize outputs
0094   InitOutNode(topNode);
0095   return Fun4AllReturnCodes::EVENT_OK;
0096
0097 }  // end 'Init(PHCompositeNode*)'
0098
0099
0100
0101 // ----------------------------------------------------------------------------
0102 //! Grab inputs and build trigger clusters
0103 // ----------------------------------------------------------------------------
0104 int TriggerClusterMaker::process_event(PHCompositeNode* topNode) {
0105
0106   if (m_config.debug) {
0107     std::cout << "TriggerClusterMaker::process_event(PHCompositeNode *topNode) Processing Event" << std::endl;
0108   }
0109
0110   // grab input nodes
0111   GrabTowerNodes(topNode);
0112   GrabTriggerNodes(topNode);
0113
0114   // loop over LL1 nodes
0115   for (auto inLL1Node : m_inLL1Nodes) {
0116     ProcessLL1s(inLL1Node);
0117   }  // end LL1 node loop
0118
0119   // loop over trigger primitive nodes
0120   for (auto inPrimNode : m_inPrimNodes) {
0121     ProcessPrimitives(inPrimNode);
0122   }  // end trigger primitive node loop
0123
0124   // end event
0125   return Fun4AllReturnCodes::EVENT_OK;
0126
0127 }  // end 'process_event(PHCompositeNode*)'
0128
0129
0130
0131 // ----------------------------------------------------------------------------
0132 //! Run final calculations
0133 // ----------------------------------------------------------------------------
0134 int TriggerClusterMaker::End(PHCompositeNode *topNode) {
0135
0136   if (m_config.debug) {
0137     std::cout << "TriggerClusterMaker::End(PHCompositeNode *topNode) This is the End..." << std::endl;
0138   }
0139
0140   /* nothing to do */
0141
0142   return Fun4AllReturnCodes::EVENT_OK;
0143
0144 }  // end 'End(PHCompositeNode*)'
0145
0146
0147
0148 // private methods ============================================================
0149
0150 // ----------------------------------------------------------------------------
0151 //! Create output node on node tree
0152 // ----------------------------------------------------------------------------
0153 void TriggerClusterMaker::InitOutNode(PHCompositeNode* topNode) {
0154
0155   // print debug message
0156   if (m_config.debug && (Verbosity() > 0)) {
0157     std::cout << "TriggerClusterMaker::InitOutNode(PHCompositeNode*) Creating output node" << std::endl;
0158   }
0159
0160   // find dst node
0161   //   - if missing, abort
0162   PHNodeIterator   itNode(topNode);
0163   PHCompositeNode* dstNode = static_cast<PHCompositeNode*>(itNode.findFirst("PHCompositeNode", "DST"));
0164   if (!dstNode) {
0165     std::cerr << PHWHERE << ": PANIC! DST node missing! Aborting!" << std::endl;
0166     assert(dstNode);
0167   }
0168
0169   // find or add LL1 node
0170   PHNodeIterator   itTrg(dstNode);
0171   PHCompositeNode* trgNode = static_cast<PHCompositeNode*>(itNode.findFirst("PHCompositeNode", "LL1"));
0172   if (!trgNode) {
0173     PHCompositeNode* trgNodeToAdd = new PHCompositeNode("LL1");
0174     dstNode -> addNode(trgNodeToAdd);
0175     trgNode =  trgNodeToAdd;
0176   }
0177
0178   // create container for clusters
0179   m_outClustNode = new RawClusterContainer();
0180
0181   // and add node to tree
0182   PHIODataNode<PHObject>* clustNode = new PHIODataNode<PHObject>(m_outClustNode, m_config.outNodeName, "PHObject");
0183   if (!clustNode) {
0184     std::cerr << PHWHERE << ": PANIC! Couldn't create cluster node! Aborting!" << std::endl;
0185     assert(clustNode);
0186   } else {
0187     trgNode -> addNode(clustNode);
0188   }
0189   return;
0190
0191 }  // end 'InitOutNode(PHCompositeNode*)'
0192
0193
0194
0195 // ----------------------------------------------------------------------------
0196 //! Grab input tower nodes
0197 // ----------------------------------------------------------------------------
0198 void TriggerClusterMaker::GrabTowerNodes(PHCompositeNode* topNode) {
0199
0200   // print debug message
0201   if (m_config.debug && (Verbosity() > 0)) {
0202     std::cout << "TriggerClusterMaker::GrabTowerNodes(PHCompositeNode*) Grabbing input tower nodes" << std::endl;
0203   }
0204
0205   // get emcal tower info node
0206   m_inTowerNodes[TriggerClusterMakerDefs::Cal::EM] = findNode::getClass<TowerInfoContainer>(topNode, m_config.inEMCalTowerNode);
0207   if (!m_inTowerNodes[TriggerClusterMakerDefs::Cal::EM]) {
0208     std::cerr << PHWHERE << ": PANIC! Couldn't grab EMCal towers from node '" << m_config.inEMCalTowerNode << "'!" << std::endl;
0209     assert(m_inTowerNodes[TriggerClusterMakerDefs::Cal::EM]);
0210   }
0211
0212   // get inner hcal tower info node
0213   m_inTowerNodes[TriggerClusterMakerDefs::Cal::IH] = findNode::getClass<TowerInfoContainer>(topNode, m_config.inIHCalTowerNode);
0214   if (!m_inTowerNodes[TriggerClusterMakerDefs::Cal::EM]) {
0215     std::cerr << PHWHERE << ": PANIC! Couldn't grab IHCal towers from node '" << m_config.inIHCalTowerNode << "'!" << std::endl;
0216     assert(m_inTowerNodes[TriggerClusterMakerDefs::Cal::IH]);
0217   }
0218
0219   // get outer hcal tower info node
0220   m_inTowerNodes[TriggerClusterMakerDefs::Cal::OH] = findNode::getClass<TowerInfoContainer>(topNode, m_config.inOHCalTowerNode);
0221   if (!m_inTowerNodes[TriggerClusterMakerDefs::Cal::EM]) {
0222     std::cerr << PHWHERE << ": PANIC! Couldn't grab OHCal towers from node '" << m_config.inOHCalTowerNode << "'!" << std::endl;
0223     assert(m_inTowerNodes[TriggerClusterMakerDefs::Cal::OH]);
0224   }
0225   return;
0226
0227 }  // end 'GrabTowerNodes(PHCompositeNode*)'
0228
0229
0230
0231 // ----------------------------------------------------------------------------
0232 //! Grab input trigger nodes
0233 // ----------------------------------------------------------------------------
0234 void TriggerClusterMaker::GrabTriggerNodes(PHCompositeNode* topNode) {
0235
0236   // print debug message
0237   if (m_config.debug && (Verbosity() > 0)) {
0238     std::cout << "TriggerClusterMaker::GrabTriggerNodes(PHCompositeNode*) Grabbing input trigger nodes" << std::endl;
0239   }
0240
0241   // get LL1 nodes
0242   for (const std::string& inLL1Node : m_config.inLL1Nodes) {
0243     m_inLL1Nodes.push_back(
0244       findNode::getClass<LL1Out>(topNode, inLL1Node)
0245     );
0246     if (!m_inLL1Nodes.back()) {
0247       std::cerr << PHWHERE << ": PANIC! Couldn't grab LL1Out node '" << inLL1Node << "'!" << std::endl;
0248       assert(m_inLL1Nodes.back());
0249     }
0250   }
0251
0252   // get trigger primitive nodes
0253   for (const std::string& inPrimNode : m_config.inPrimNodes) {
0254     m_inPrimNodes.push_back(
0255       findNode::getClass<TriggerPrimitiveContainer>(topNode, inPrimNode)
0256     );
0257     if (!m_inPrimNodes.back()) {
0258       std::cerr << PHWHERE << ": PANIC! Couldn't grab TriggerPrimitive node '" << inPrimNode << "'!" << std::endl;
0259       assert(m_inPrimNodes.back());
0260     }
0261   }
0262   return;
0263
0264 }  // end 'GrabTriggerNodes(PHCompositeNode*)'
0265
0266
0267
0268 // ----------------------------------------------------------------------------
0269 //! Process a node of LL1s
0270 // ----------------------------------------------------------------------------
0271 void TriggerClusterMaker::ProcessLL1s(LL1Out* lloNode) {
0272
0273   // loop over trigger words
0274   LL1Outv1::Range lloWordRange = lloNode -> getTriggerWords();
0275   for (
0276     LL1Outv1::Iter itTrgWord = lloWordRange.first;
0277     itTrgWord != lloWordRange.second;
0278     ++itTrgWord
0279   ) {
0280
0281     // FIXME figure out how to get trigger
0282     //   - primitives from LL1Out
0283     //auto word = (*itTrgWord).second;
0284     //MakeCluster(word);
0285
0286   }  // end trigger word loop
0287   return;
0288
0289 }  // end 'ProcessLL1s(LL1Out*)'
0290
0291
0292
0293 // ----------------------------------------------------------------------------
0294 //! Process a node of trigger primitives
0295 // ----------------------------------------------------------------------------
0296 void TriggerClusterMaker::ProcessPrimitives(TriggerPrimitiveContainer* primNode) {
0297
0298     // loop over primitives
0299   TriggerPrimitiveContainerv1::Range trgPrimStoreRange = primNode -> getTriggerPrimitives();
0300   for (
0301     TriggerPrimitiveContainerv1::Iter itTrgPrim = trgPrimStoreRange.first;
0302     itTrgPrim != trgPrimStoreRange.second;
0303     ++itTrgPrim
0304   ) {
0305
0306     // grab trigger primitve and decompose into clusters
0307     TriggerPrimitive* primitive = (*itTrgPrim).second;
0308     if (!primitive) continue;
0309
0310     // create new cluster and add primitive to it
0311     RawClusterv1* cluster = new RawClusterv1();
0312     AddPrimitiveToCluster(primitive, cluster);
0313
0314     // put cluster in output node
0315     m_outClustNode -> AddCluster(cluster);
0316
0317   }  // end trigger primitive loop
0318   return;
0319
0320 }  // end 'ProcessPrimitives(TriggerPrimitiveContainer*)'
0321
0322
0323
0324 // ----------------------------------------------------------------------------
0325 //! Add primitive to a given cluster
0326 // ----------------------------------------------------------------------------
0327 void TriggerClusterMaker::AddPrimitiveToCluster(TriggerPrimitive* primitive, RawClusterv1* cluster) {
0328
0329   // print debug message
0330   if (m_config.debug && (Verbosity() > 1)) {
0331     std::cout << "TriggerClusterMaker::MakeClustersFromPrimitive(TriggerPrimitive*) Making clusters from TriggerPrimitive object" << std::endl;
0332   }
0333
0334   // loop over sums
0335   TriggerPrimitivev1::Range trgPrimSumRange = primitive -> getSums();
0336   for (
0337     TriggerPrimitive::Iter itPrimSum = trgPrimSumRange.first;
0338     itPrimSum != trgPrimSumRange.second;
0339     ++itPrimSum
0340   ) {
0341
0342     // loop over summands
0343     auto sum = (*itPrimSum).second;
0344     for (
0345       auto itSum = sum -> begin();
0346       itSum != sum -> end();
0347       ++itSum
0348     ) {
0349
0350       // get sum key and detector ID
0351       auto sumKey = (*itPrimSum).first;
0352       auto detID  = TriggerDefs::getDetectorId_from_TriggerSumKey(sumKey);
0353       std::cout << "    CHECK-1 sum key = " << sumKey << ", detector ID = " << detID << std::endl;
0354
0355       // get eta, phi bin of sum
0356       const uint32_t iEtaStart = TriggerClusterMakerDefs::GetBin(
0357         (*itPrimSum).first,
0358          TriggerClusterMakerDefs::Axis::Eta,
0359          TriggerClusterMakerDefs::Type::Prim
0360       );
0361       const uint32_t iPhiStart = TriggerClusterMakerDefs::GetBin(
0362         (*itPrimSum).first,
0363          TriggerClusterMakerDefs::Axis::Phi,
0364          TriggerClusterMakerDefs::Type::Prim
0365       );
0366
0367       // then iterate through towers in sum
0368       /* TODO */
0369
0370       // grab tower key
0371       const uint32_t towKey = TriggerClusterMakerDefs::GetKeyFromEtaPhiIndex(iEtaStart, iPhiStart, detID);
0372
0373       // and finally grab tower
0374       TowerInfo* tower = GetTowerFromKey(towKey, detID);
0375       if (!tower) continue;
0376       std::cout << "    CHECK0 (eta, phi) = (" << iEtaStart << ", " << iPhiStart << ")\n"
0377                 << "           key = " << towKey << ", tower = " << tower
0378                 << std::endl;
0379
0380       // and add to custer
0381       cluster -> addTower(towKey, tower -> get_energy());
0382
0383     }  // end tower loop
0384
0385   }  // end primitive sum loop
0386   return;
0387
0388 }  // end 'MakeClustersFromPrimitive(TriggerPrimitive*, RawClusterv1*)'
0389
0390
0391
0392 // ----------------------------------------------------------------------------
0393 //! Grab tower from an input node based on key
0394 // ----------------------------------------------------------------------------
0395 TowerInfo* TriggerClusterMaker::GetTowerFromKey(const uint32_t key, const uint32_t det) {
0396
0397   // print debug message
0398   if (m_config.debug && (Verbosity() > 2)) {
0399     std::cout << "TriggerClusterMaker::GetTowerFromKey(uint32_t) Grabbing tower based on key..." << std::endl;
0400   }
0401
0402   TowerInfo* tower;
0403   switch (det) {
0404
0405     // get emcal tower index
0406     case TriggerDefs::DetectorId::emcalDId:
0407       tower = m_inTowerNodes[TriggerClusterMakerDefs::Cal::EM] -> get_tower_at_key(key);
0408       break;
0409
0410     // get inner hcal tower index
0411     case TriggerDefs::DetectorId::hcalinDId:
0412       tower = m_inTowerNodes[TriggerClusterMakerDefs::Cal::IH] -> get_tower_at_key(key);
0413       break;
0414
0415     case TriggerDefs::DetectorId::hcaloutDId:
0416       tower = m_inTowerNodes[TriggerClusterMakerDefs::Cal::OH] -> get_tower_at_key(key);
0417       break;
0418
0419     // otherwise return null
0420     default:
0421       tower = nullptr;
0422       break;
0423   }
0424   return tower;
0425
0426 }  // end 'GetTowerFromKey(uint32_t, uint32_t)'
0427
0428 // end ------------------------------------------------------------------------