packages/trigger/TriggerAnalyzer.cc

0001 #include "TriggerAnalyzer.h"
0002
0003 #include "LL1Out.h"
0004 #include "TriggerRunInfo.h"
0005
0006 #include <ffarawobjects/Gl1Packet.h>
0007
0008 #include <phool/getClass.h>
0009
0010 #include <iostream>
0011
0012 int TriggerAnalyzer::decodeTriggers(PHCompositeNode* topNode)
0013 {
0014   triggerruninfo = findNode::getClass<TriggerRunInfo>(topNode, "TriggerRunInfo");
0015   if (!triggerruninfo)
0016   {
0017     std::cout << PHWHERE << " no triggerruninfo" << std::endl;
0018     return 1;
0019   }
0020
0021   if (m_useEmulator)
0022   {
0023     ll1out_photon = findNode::getClass<LL1Out>(topNode, "LL1OUT_PHOTON");
0024     if (!ll1out_photon)
0025     {
0026       std::cout << PHWHERE << " no trigger emulator" << std::endl;
0027       return 1;
0028     }
0029
0030     ll1out_jet = findNode::getClass<LL1Out>(topNode, "LL1OUT_JET");
0031     if (!ll1out_jet)
0032     {
0033       std::cout << PHWHERE << " no trigger emulator" << std::endl;
0034       return 1;
0035     }
0036
0037     fillTriggerVector();
0038
0039     return 0;
0040   }
0041
0042   gl1packet = findNode::getClass<Gl1Packet>(topNode, 14001);
0043   if (!gl1packet)
0044   {
0045     gl1packet = findNode::getClass<Gl1Packet>(topNode, "GL1Packet");
0046     if (!gl1packet)
0047     {
0048       gl1packet = findNode::getClass<Gl1Packet>(topNode, "GL1RAWHIT");  // Different term used in track production
0049       if (!gl1packet)
0050       {
0051     std::cout << PHWHERE << "no gl1 packet" << std::endl;
0052     return 1;
0053       }
0054     }
0055   }
0056
0057   gl1_scaledvec = gl1packet->lValue(0, "ScaledVector");
0058   gl1_livevec = gl1packet->lValue(0, "TriggerVector");
0059   gl1_bco = gl1packet->lValue(0, "BCO");
0060
0061   return 0;
0062 }
0063
0064 void TriggerAnalyzer::fillTriggerVector()
0065 {
0066   gl1_scaledvec = 0x000000000000;
0067   gl1_livevec = 0x000000000000;
0068   gl1_bco = 0x000000000000;
0069
0070   for (int i = 0; i < 4; i++)
0071   {
0072     if (ll1out_photon->passesThreshold(i + 1))
0073     {
0074       unsigned int bit = i + 28;
0075       gl1_scaledvec |= (0x1U << bit);
0076     }
0077   }
0078   for (int i = 0; i < 4; i++)
0079   {
0080     if (ll1out_jet->passesThreshold(i + 1))
0081     {
0082       unsigned int bit = i + 20;
0083       gl1_scaledvec |= (0x1U << bit);
0084     }
0085   }
0086   gl1_scaledvec &= 0x00000000ffffffff;
0087   return;
0088 }
0089
0090 bool TriggerAnalyzer::didTriggerFire(const std::string& triggername)
0091 {
0092   uint32_t bit = triggerruninfo->getTriggerBitByName(triggername);
0093   return (((gl1_scaledvec >> bit) & 0x1U) == 0x1U);
0094 }
0095
0096 bool TriggerAnalyzer::didTriggerFire(int triggerbit) const
0097 {
0098   uint32_t bit = (uint32_t) triggerbit;
0099   return (((gl1_scaledvec >> bit) & 0x1U) == 0x1U);
0100 }
0101
0102 int TriggerAnalyzer::getTriggerPrescale(const std::string& triggername)
0103 {
0104   return triggerruninfo->getPrescaleByName(triggername);
0105 }
0106
0107 int TriggerAnalyzer::getTriggerPrescale(int triggerbit)
0108 {
0109   return triggerruninfo->getPrescaleByBit(triggerbit);
0110 }
0111
0112 bool TriggerAnalyzer::checkRawTrigger(const std::string& triggername)
0113 {
0114   uint32_t bit = triggerruninfo->getTriggerBitByName(triggername);
0115   return (((gl1_livevec >> bit) & 0x1U) == 0x1U);
0116 }
0117
0118 bool TriggerAnalyzer::checkRawTrigger(int triggerbit) const
0119 {
0120   uint32_t bit = (uint32_t) triggerbit;
0121   return (((gl1_livevec >> bit) & 0x1U) == 0x1U);
0122 }
0123
0124 std::string TriggerAnalyzer::getTriggerName(int triggerbit)
0125 {
0126   return triggerruninfo->getTriggerName(triggerbit);
0127 }
0128
0129 uint64_t TriggerAnalyzer::getTriggerScalers(const std::string& triggername)
0130 {
0131   return triggerruninfo->getScalersByName(triggername);
0132 }
0133
0134 uint64_t TriggerAnalyzer::getTriggerScalers(int triggerbit)
0135 {
0136   return triggerruninfo->getScalersByBit(triggerbit);
0137 }
0138
0139 uint64_t TriggerAnalyzer::getTriggerLiveScalers(const std::string& triggername)
0140 {
0141   return triggerruninfo->getLiveScalersByName(triggername);
0142 }
0143
0144 uint64_t TriggerAnalyzer::getTriggerLiveScalers(int triggerbit)
0145 {
0146   return triggerruninfo->getLiveScalersByBit(triggerbit);
0147 }
0148
0149 uint64_t TriggerAnalyzer::getTriggerRawScalers(const std::string& triggername)
0150 {
0151   return triggerruninfo->getRawScalersByName(triggername);
0152 }
0153
0154 uint64_t TriggerAnalyzer::getTriggerRawScalers(int triggerbit)
0155 {
0156   return triggerruninfo->getRawScalersByBit(triggerbit);
0157 }
0158
0159 void TriggerAnalyzer::Print() const
0160 {
0161   for (int i = 0; i < 64; i++)
0162   {
0163     if (didTriggerFire(i))
0164     {
0165       std::cout << " Trigger " << i << " fired" << std::endl;
0166     }
0167   }
0168 }