Back to home page

sPhenix code displayed by LXR
 
 

    

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

0001 #include "LL1PacketGetter.h"
0002 #include "LL1Outv1.h"
0003 #include "TriggerPrimitiveContainerv1.h"
0004 #include "TriggerPrimitivev1.h"
0005 
0006 #include <fun4all/Fun4AllReturnCodes.h>
0007 #include <fun4all/SubsysReco.h>  // for SubsysReco
0008 
0009 #include <phool/PHCompositeNode.h>
0010 #include <phool/PHIODataNode.h>    // for PHIODataNode
0011 #include <phool/PHNode.h>          // for PHNode
0012 #include <phool/PHNodeIterator.h>  // for PHNodeIterator
0013 #include <phool/PHObject.h>        // for PHObject
0014 #include <phool/getClass.h>
0015 
0016 #include <Event/Event.h>
0017 #include <Event/packet.h>
0018 
0019 #include <cstdlib>
0020 #include <iostream>  // for operator<<, endl, basic...
0021 #include <vector>    // for vector
0022 
0023 //____________________________________________________________________________..
0024 LL1PacketGetter::LL1PacketGetter(const std::string &name, const std::string &trigger, const std::string &ll1)
0025   : SubsysReco(name)
0026   , m_trigger(trigger)
0027   , m_ll1(ll1)
0028   , m_nchannels(60)
0029 {
0030   m_packet_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::noneTId, TriggerDefs::DetectorId::noneDId)] = std::make_pair(0, 0);
0031   m_packet_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::jetTId, TriggerDefs::DetectorId::noneDId)] = std::make_pair(13002, 13002);
0032   m_packet_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::jetTId, TriggerDefs::DetectorId::hcalDId)] = std::make_pair(13002, 13002);
0033   m_packet_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::jetTId, TriggerDefs::DetectorId::hcalinDId)] = std::make_pair(13002, 13002);
0034   m_packet_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::jetTId, TriggerDefs::DetectorId::hcaloutDId)] = std::make_pair(13002, 13002);
0035   m_packet_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::jetTId, TriggerDefs::DetectorId::emcalDId)] = std::make_pair(13002, 13002);
0036   m_packet_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::photonTId, TriggerDefs::DetectorId::noneDId)] = std::make_pair(13002, 13002);
0037   m_packet_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::photonTId, TriggerDefs::DetectorId::emcalDId)] = std::make_pair(13002, 13002);
0038   m_packet_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::photonTId, TriggerDefs::DetectorId::hcalDId)] = std::make_pair(13002, 13002);
0039   m_packet_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::photonTId, TriggerDefs::DetectorId::hcalinDId)] = std::make_pair(13002, 13002);
0040   m_packet_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::photonTId, TriggerDefs::DetectorId::hcaloutDId)] = std::make_pair(13002, 13002);
0041   m_packet_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::noneTId, TriggerDefs::DetectorId::emcalDId)] = std::make_pair(13010, 13025);
0042   m_packet_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::mbdTId, TriggerDefs::DetectorId::mbdDId)] = std::make_pair(13002, 13002);
0043 
0044   m_prim_sum_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::noneTId, TriggerDefs::DetectorId::noneDId)] = std::make_pair(0, 0);
0045   m_prim_sum_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::jetTId, TriggerDefs::DetectorId::noneDId)] = std::make_pair(16, 24);
0046   m_prim_sum_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::jetTId, TriggerDefs::DetectorId::hcalDId)] = std::make_pair(16, 24);
0047   m_prim_sum_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::jetTId, TriggerDefs::DetectorId::hcalinDId)] = std::make_pair(16, 24);
0048   m_prim_sum_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::jetTId, TriggerDefs::DetectorId::hcaloutDId)] = std::make_pair(16, 24);
0049   m_prim_sum_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::jetTId, TriggerDefs::DetectorId::emcalDId)] = std::make_pair(16, 24);
0050   m_prim_sum_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::photonTId, TriggerDefs::DetectorId::noneDId)] = std::make_pair(16, 24);
0051   m_prim_sum_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::photonTId, TriggerDefs::DetectorId::emcalDId)] = std::make_pair(16, 24);
0052   m_prim_sum_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::photonTId, TriggerDefs::DetectorId::hcalDId)] = std::make_pair(16, 24);
0053   m_prim_sum_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::photonTId, TriggerDefs::DetectorId::hcalinDId)] = std::make_pair(16, 24);
0054   m_prim_sum_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::photonTId, TriggerDefs::DetectorId::hcaloutDId)] = std::make_pair(16, 24);
0055   m_prim_sum_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::noneTId, TriggerDefs::DetectorId::emcalDId)] = std::make_pair(24, 16);
0056   m_prim_sum_map[TriggerDefs::getTriggerKey(TriggerDefs::TriggerId::mbdTId, TriggerDefs::DetectorId::mbdDId)] = std::make_pair(4, 13);
0057 
0058   m_word_map[TriggerDefs::TriggerId::noneTId] = 0;
0059   m_word_map[TriggerDefs::TriggerId::jetTId] = 12 * 32;
0060   m_word_map[TriggerDefs::TriggerId::mbdTId] = 8;
0061   m_word_map[TriggerDefs::TriggerId::pairTId] = 0;
0062   m_word_map[TriggerDefs::TriggerId::photonTId] = 12 * 32;
0063 }
0064 
0065 //____________________________________________________________________________..
0066 int LL1PacketGetter::InitRun(PHCompositeNode *topNode)
0067 {
0068   m_triggerid = TriggerDefs::GetTriggerId(m_trigger);
0069   m_detectorid = TriggerDefs::GetDetectorId(m_ll1);
0070   m_triggerkey = TriggerDefs::getTriggerKey(m_triggerid, m_detectorid);
0071   m_primitiveid = TriggerDefs::GetPrimitiveId(m_ll1);
0072 
0073   if (m_trigger == "NONE")
0074   {
0075     m_triggerprimitive_nodename = "TRIGGERPRIMITIVES_RAW_" + m_ll1;
0076     m_triggerprimitive_ll1_nodename = "TRIGGERPRIMITIVES_RAW_" + m_ll1 + "_LL1";
0077     m_no_ll1out = true;
0078   }
0079   else
0080   {
0081     m_ll1_nodename = "LL1OUT_RAW_" + m_trigger;
0082     m_triggerprimitive_nodename = "TRIGGERPRIMITIVES_RAW_" + m_trigger;
0083   }
0084 
0085   m_packet_low = m_packet_map[m_triggerkey].first;
0086   m_packet_high = m_packet_map[m_triggerkey].second;
0087   m_nprimitives = m_prim_sum_map[m_triggerkey].first;
0088   m_nchannels_per_primitive = m_prim_sum_map[m_triggerkey].second;
0089   m_ntriggerwords = m_word_map[m_triggerid];
0090 
0091   m_nchannels = m_nchannels_per_primitive * m_nprimitives + m_ntriggerwords;
0092 
0093   if (CreateNodeTree(topNode))
0094   {
0095     return Fun4AllReturnCodes::ABORTRUN;
0096   }
0097 
0098   topNode->print();
0099   return Fun4AllReturnCodes::EVENT_OK;
0100 }
0101 
0102 //____________________________________________________________________________..
0103 int LL1PacketGetter::process_event(PHCompositeNode *topNode)
0104 {
0105   m_trigger_primitives = findNode::getClass<TriggerPrimitiveContainer>(topNode, m_triggerprimitive_nodename);
0106   if (!m_trigger_primitives)
0107   {
0108     std::cout << m_triggerprimitive_nodename << " not found - Fatal Error" << std::endl;
0109     exit(1);
0110   }
0111   if (!m_no_ll1out)
0112   {
0113     m_ll1out = findNode::getClass<LL1Out>(topNode, m_ll1_nodename);
0114     if (!m_ll1out)
0115     {
0116       std::cout << m_ll1_nodename << " not found - Fatal Error" << std::endl;
0117       exit(1);
0118     }
0119   }
0120   else
0121   {
0122     m_trigger_primitives_ll1 = findNode::getClass<TriggerPrimitiveContainer>(topNode, m_triggerprimitive_ll1_nodename);
0123     if (!m_trigger_primitives_ll1)
0124     {
0125       std::cout << m_triggerprimitive_ll1_nodename << " not found - Fatal Error" << std::endl;
0126       exit(1);
0127     }
0128   }
0129   TriggerDefs::TriggerSumKey sumkey = 0;
0130   TriggerDefs::TriggerPrimKey primkey;
0131 
0132   if (m_isdata)
0133   {
0134     Event *_event = findNode::getClass<Event>(topNode, "PRDF");
0135     if (_event == nullptr)
0136     {
0137       std::cout << "LL1UnpackPRDF::Process_Event - Event not found" << std::endl;
0138       return -1;
0139     }
0140     if (_event->getEvtType() >= 8)  /// special event where we do not read out the calorimeters
0141     {
0142       return Fun4AllReturnCodes::DISCARDEVENT;
0143     }
0144     unsigned int clk;
0145     unsigned int evt;
0146     int nsamples;
0147     // int monitor;
0148     for (int pid = m_packet_low; pid <= m_packet_high; pid++)
0149     {
0150       Packet *packet = _event->getPacket(pid);
0151 
0152       if (packet)
0153       {
0154         evt = packet->iValue(0, "EVTNR");
0155         clk = packet->iValue(0, "CLOCK");
0156         nsamples = packet->iValue(0, "SAMPLES");
0157         // monitor = packet->iValue(0, "MONITOR");
0158 
0159         if (!m_no_ll1out)
0160         {
0161           m_ll1out->set_event_number(evt);
0162           m_ll1out->set_clock_number(clk);
0163         }
0164 
0165         int nchannels = packet->iValue(0, "CHANNELS");
0166         int ntriggerwords = packet->iValue(0, "TRIGGERWORDS");
0167 
0168         if (nchannels > m_nchannels)  // packet is corrupted and reports too many channels
0169         {
0170           return Fun4AllReturnCodes::DISCARDEVENT;
0171         }
0172 
0173         TriggerDefs::PrimitiveId primid = TriggerDefs::GetPrimitiveId(m_trigger);
0174         if (primid == TriggerDefs::PrimitiveId::nonePId)
0175         {
0176           primid = TriggerDefs::GetPrimitiveId(m_ll1);
0177         }
0178 
0179         for (int iprim = 0; iprim < m_nprimitives; iprim++)
0180         {
0181           primkey = TriggerDefs::getTriggerPrimKey(TriggerDefs::GetTriggerId(m_trigger), TriggerDefs::GetDetectorId(m_ll1), primid, (m_nprimitives * (pid - m_packet_low)) + iprim);
0182 
0183           _trigger_primitive = m_trigger_primitives->get_primitive_at_key(primkey);
0184 
0185           for (int channel = 0; channel < m_nchannels_per_primitive; channel++)
0186           {
0187             sumkey = TriggerDefs::getTriggerSumKey(TriggerDefs::GetTriggerId(m_trigger), TriggerDefs::GetDetectorId(m_ll1), primid, (m_nprimitives * (pid - m_packet_low)) + iprim, channel);
0188 
0189             _sum = _trigger_primitive->get_sum_at_key(sumkey);
0190             for (int samp = 0; samp < nsamples; samp++)
0191             {
0192               if (pid == 13002)
0193               {
0194                 _sum->push_back(static_cast<unsigned int>(packet->iValue(samp, (iprim * 2) + (channel / 12) + (32 * (channel % 12)))));
0195               }
0196               else
0197               {
0198                 _sum->push_back(static_cast<unsigned int>(packet->iValue(samp, (iprim * m_nchannels_per_primitive) + channel)));
0199               }
0200             }
0201           }
0202         }
0203 
0204         if (!m_no_ll1out)
0205         {
0206           for (int channel = 0; channel < ntriggerwords; channel++)
0207           {
0208             std::vector<unsigned int> *sum = m_ll1out->get_word(((unsigned int) (channel % 32) & 0xffffU) + (((unsigned int) (channel / 32) & 0xffffU) << 16U));
0209 
0210             for (int samp = 0; samp < nsamples; samp++)
0211             {
0212               sum->push_back(static_cast<unsigned int>(packet->iValue(samp, (m_nprimitives * m_nchannels_per_primitive) + channel)));
0213             }
0214           }
0215         }
0216         else
0217         {
0218           TriggerDefs::TriggerId tid = TriggerDefs::TriggerId::jetTId;
0219           TriggerDefs::PrimitiveId prid = TriggerDefs::PrimitiveId::jetPId;
0220           TriggerDefs::DetectorId did = TriggerDefs::DetectorId::emcalDId;
0221 
0222           primkey = TriggerDefs::getTriggerPrimKey(tid, did, prid, pid - m_packet_low);
0223 
0224           _trigger_primitive = new TriggerPrimitivev1(primkey);
0225 
0226           for (int channel = 0; channel < 24; channel++)
0227           {
0228             sumkey = TriggerDefs::getTriggerSumKey(tid, did, prid, pid - m_packet_low, channel);
0229             _sum = new std::vector<unsigned int>();
0230             _sum->reserve(nsamples);
0231 
0232             for (int samp = 0; samp < nsamples; samp++)
0233             {
0234               _sum->push_back(static_cast<unsigned int>(packet->iValue(samp, (m_nprimitives * m_nchannels_per_primitive) + channel)));
0235             }
0236             _trigger_primitive->add_sum(sumkey, _sum);
0237           }
0238           m_trigger_primitives_ll1->add_primitive(primkey, _trigger_primitive);
0239         }
0240 
0241         delete packet;
0242       }
0243       // else // if the packet is missing treat constitutent channels as zero suppressed
0244       //   {
0245       //     for (int iprim = 0; iprim < m_nprimitives; iprim++)
0246       //    {
0247       //      if (m_detectorid == TriggerDefs::DetectorId::hcalDId)
0248       //        {
0249       //          primkey = TriggerDefs::getTriggerPrimKey(TriggerDefs::GetTriggerId(m_trigger), TriggerDefs::GetDetectorId((iprim < 12 ? "HCALOUT": "HCALIN")), TriggerDefs::GetPrimitiveId(m_ll1), m_nprimitives*(pid - m_packet_low) + iprim);
0250       //        }
0251       //      else
0252       //        {
0253       //          primkey = TriggerDefs::getTriggerPrimKey(TriggerDefs::GetTriggerId(m_trigger), TriggerDefs::GetDetectorId(m_ll1), TriggerDefs::GetPrimitiveId(m_ll1), m_nprimitives*(pid - m_packet_low) + iprim);
0254       //        }
0255 
0256       //      _trigger_primitive = new TriggerPrimitivev1(primkey);
0257 
0258       //      for (int channel = 0; channel < m_nchannels_per_primitive; channel++)
0259       //        {
0260       //          sumkey = TriggerDefs::getTriggerSumKey(TriggerDefs::GetTriggerId(m_trigger), TriggerDefs::GetDetectorId(m_ll1), TriggerDefs::GetPrimitiveId(m_ll1), m_nprimitives*(pid - m_packet_low) + iprim, channel);
0261       //          _sum = new std::vector<unsigned int>();
0262       //          _sum->reserve(nsamples);
0263       //          for (int samp = 0; samp < nsamples; samp++)
0264       //        {
0265       //          _sum->push_back(0); //static_cast<unsigned int>(packet->iValue(samp, iprim*m_nchannels_per_primitive+channel)));
0266       //        }
0267 
0268       //          _trigger_primitive->add_sum(sumkey, _sum);
0269       //        }
0270       //      m_trigger_primitives->add_primitive(primkey, _trigger_primitive);
0271       //    }
0272 
0273       //     for (int channel = 0; channel < m_ntriggerwords;channel++)
0274       //    {
0275       //      _sum = new std::vector<unsigned int>();
0276       //      _sum->reserve(nsamples);
0277       //      for (int samp = 0; samp < nsamples; samp++)
0278       //        {
0279       //          _sum->push_back(0);
0280       //        }
0281 
0282       //      m_ll1out->add_word(unsigned int)(channel), _sum);
0283 
0284       //    }
0285 
0286       //   }
0287     }
0288   }
0289 
0290   if (Verbosity())
0291   {
0292     if (m_no_ll1out)
0293     {
0294       std::cout << " PRIMITIVES LL1: " << std::endl;
0295       m_trigger_primitives_ll1->identify();
0296     }
0297     else
0298     {
0299       std::cout << " LL1 OUT: " << std::endl;
0300       m_ll1out->identify();
0301     }
0302   }
0303   if (Verbosity())
0304   {
0305     std::cout << "PRIMITIVES: " << std::endl;
0306     m_trigger_primitives->identify();
0307   }
0308 
0309   return Fun4AllReturnCodes::EVENT_OK;
0310 }
0311 
0312 int LL1PacketGetter::CreateNodeTree(PHCompositeNode *topNode)
0313 {
0314   PHNodeIterator nodeItr(topNode);
0315   // DST node
0316   PHCompositeNode *dst_node = dynamic_cast<PHCompositeNode *>(
0317       nodeItr.findFirst("PHCompositeNode", "DST"));
0318   if (!dst_node)
0319   {
0320     std::cout << "PHComposite node created: DST" << std::endl;
0321     dst_node = new PHCompositeNode("DST");
0322     topNode->addNode(dst_node);
0323   }
0324   // towers
0325   PHNodeIterator dstIter(dst_node);
0326 
0327   PHCompositeNode *ll1Node = dynamic_cast<PHCompositeNode *>(dstIter.findFirst("PHCompositeNode", "LL1"));
0328 
0329   if (!ll1Node)
0330   {
0331     ll1Node = new PHCompositeNode("LL1");
0332     dst_node->addNode(ll1Node);
0333   }
0334 
0335   if (!m_no_ll1out)
0336   {
0337     LL1Out *ll1out = findNode::getClass<LL1Out>(ll1Node, m_ll1_nodename);
0338     if (!ll1out)
0339     {
0340       ll1out = new LL1Outv1(m_trigger, m_ll1);
0341       PHIODataNode<PHObject> *LL1OutNode = new PHIODataNode<PHObject>(ll1out, m_ll1_nodename, "PHObject");
0342       ll1Node->addNode(LL1OutNode);
0343     }
0344   }
0345   else
0346   {
0347     TriggerPrimitiveContainer *primoutll1 = findNode::getClass<TriggerPrimitiveContainer>(ll1Node, m_triggerprimitive_ll1_nodename);
0348     if (!primoutll1)
0349     {
0350       primoutll1 = new TriggerPrimitiveContainerv1(m_triggerid, m_detectorid);
0351       PHIODataNode<PHObject> *LL1OutNode = new PHIODataNode<PHObject>(primoutll1, m_triggerprimitive_ll1_nodename, "PHObject");
0352       ll1Node->addNode(LL1OutNode);
0353     }
0354   }
0355   TriggerPrimitiveContainer *primout = findNode::getClass<TriggerPrimitiveContainer>(ll1Node, m_triggerprimitive_nodename);
0356   if (!primout)
0357   {
0358     primout = new TriggerPrimitiveContainerv1(m_triggerid, TriggerDefs::DetectorId::noneDId);
0359     PHIODataNode<PHObject> *LL1OutNode = new PHIODataNode<PHObject>(primout, m_triggerprimitive_nodename, "PHObject");
0360     ll1Node->addNode(LL1OutNode);
0361   }
0362 
0363   return Fun4AllReturnCodes::EVENT_OK;
0364 }
[ 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!