framework/fun4allraw/SingleGl1TriggerInput.cc

0001 #include "SingleGl1TriggerInput.h"
0002
0003 #include "Fun4AllPrdfInputTriggerManager.h"
0004 #include "InputManagerType.h"
0005
0006 #include <ffarawobjects/Gl1Packetv3.h>
0007
0008 #include <phool/PHCompositeNode.h>
0009 #include <phool/PHIODataNode.h>    // for PHIODataNode
0010 #include <phool/PHNode.h>          // for PHNode
0011 #include <phool/PHNodeIterator.h>  // for PHNodeIterator
0012 #include <phool/PHObject.h>        // for PHObject
0013 #include <phool/getClass.h>
0014 #include <phool/phool.h>
0015
0016 #include <Event/Event.h>
0017 #include <Event/EventTypes.h>
0018 #include <Event/Eventiterator.h>
0019 #include <Event/packet.h>  // for Packet
0020
0021 #include <cstdint>   // for uint64_t
0022 #include <iostream>  // for operator<<, basic_ostream<...
0023 #include <iterator>  // for reverse_iterator
0024 #include <limits>    // for numeric_limits
0025 #include <memory>
0026 #include <set>
0027 #include <utility>  // for pair
0028
0029 SingleGl1TriggerInput::SingleGl1TriggerInput(const std::string &name)
0030   : SingleTriggerInput(name)
0031 {
0032   SubsystemEnum(InputManagerType::GL1);
0033 }
0034
0035 SingleGl1TriggerInput::~SingleGl1TriggerInput()
0036 {
0037   CleanupUsedPackets(std::numeric_limits<int>::max());
0038   // some events are already in the m_EventStack but they haven't been put
0039   // into the m_PacketMap
0040   while (m_EventStack.begin() != m_EventStack.end())
0041   {
0042     m_EventStack.erase(m_EventStack.begin());
0043   }
0044 }
0045
0046 void SingleGl1TriggerInput::FillPool(const unsigned int keep)
0047 {
0048   if (AllDone())  // no more files and all events read
0049   {
0050     return;
0051   }
0052   while (GetEventiterator() == nullptr)  // at startup this is a null pointer
0053   {
0054     if (!OpenNextFile())
0055     {
0056       AllDone(1);
0057       return;
0058     }
0059   }
0060   while (GetSomeMoreEvents(keep))
0061   {
0062     std::unique_ptr<Event> evt(GetEventiterator()->getNextEvent());
0063     while (!evt)
0064     {
0065       fileclose();
0066       if (!OpenNextFile())
0067       {
0068         AllDone(1);
0069         return;
0070       }
0071       evt.reset(GetEventiterator()->getNextEvent());
0072     }
0073     if (Verbosity() > 2)
0074     {
0075       std::cout << PHWHERE << "Fetching next Event" << evt->getEvtSequence() << std::endl;
0076     }
0077     RunNumber(evt->getRunNumber());
0078     if (GetVerbosity() > 1)
0079     {
0080       evt->identify();
0081     }
0082     if (evt->getEvtType() != DATAEVENT)
0083     {
0084       m_NumSpecialEvents++;
0085       continue;
0086     }
0087     int EventSequence = evt->getEvtSequence();
0088     if (EventSequence < SkipToEvent())
0089     {
0090       continue;
0091     }
0092     if (EventSequence > LastEvent())
0093     {
0094       std::cout << Name() << ": Last event " << LastEvent() << std::endl;
0095       AllDone(1);
0096       return;
0097     }
0098     Packet *packet = evt->getPacket(14001);
0099     if (!packet)
0100     {
0101       std::cout << PHWHERE << "Packet 14001 is null ptr" << std::endl;
0102       evt->identify();
0103       continue;
0104     }
0105     if (Verbosity() > 1)
0106     {
0107       packet->identify();
0108     }
0109
0110     // by default use previous bco clock for gtm bco
0111     Gl1Packet *newhit = new Gl1Packetv3();
0112     uint64_t gtm_bco = packet->lValue(0, "BCO");
0113     unsigned int packetnumber = packet->iValue(0);
0114     unsigned int gl1pktdiff = packetnumber - EventSequence;
0115     if (m_Gl1PacketNumberEventNumberDiff == 0)  // startup
0116     {
0117       m_Gl1PacketNumberEventNumberDiff = gl1pktdiff;
0118     }
0119     else
0120     {
0121       if (m_Gl1PacketNumberEventNumberDiff != gl1pktdiff)
0122       {
0123         if (TriggerInputManager())
0124         {
0125           TriggerInputManager()->AddGl1DroppedEvent(EventSequence);
0126         }
0127
0128         static int icnt = 0;
0129         if (icnt < 1000)
0130         {
0131           std::cout << Name() << ": Found dropped Event at event " << EventSequence
0132                     << " with Packet Number: " << packetnumber << std::endl;
0133           icnt++;
0134         }
0135         m_Gl1PacketNumberEventNumberDiff = gl1pktdiff;
0136       }
0137     }
0138
0139     newhit->setBCO(packet->lValue(0, "BCO"));
0140     newhit->setHitFormat(packet->getHitFormat());
0141     newhit->setIdentifier(packet->getIdentifier());
0142     newhit->setEvtSequence(EventSequence);
0143     newhit->setPacketNumber(packetnumber);
0144
0145     newhit->setBunchNumber(packet->lValue(0, "BunchNumber"));
0146     newhit->setTriggerInput(packet->lValue(0, "TriggerInput"));
0147     newhit->setLiveVector(packet->lValue(0, "LiveVector"));
0148     newhit->setScaledVector(packet->lValue(0, "ScaledVector"));
0149     newhit->setGTMBusyVector(packet->lValue(0, "GTMBusyVector"));
0150     newhit->setGTMAllBusyVector(packet->lValue(0, "GTMAllBusyVector"));
0151     for (int i = 0; i < 64; i++)
0152     {
0153       for (int j = 0; j < 3; j++)
0154       {
0155         newhit->setScaler(i, j, packet->lValue(i, j));
0156       }
0157     }
0158     for (int i = 0; i < 12; i++)
0159     {
0160       newhit->setGl1pScaler(i, 0, packet->lValue(i, "GL1PRAW"));
0161       newhit->setGl1pScaler(i, 1, packet->lValue(i, "GL1PLIVE"));
0162       newhit->setGl1pScaler(i, 2, packet->lValue(i, "GL1PSCALED"));
0163     }
0164     if (Verbosity() > 2)
0165     {
0166       std::cout << PHWHERE << " Packet: " << packet->getIdentifier()
0167                 << " evtno: " << EventSequence
0168                 << ", bco: 0x" << std::hex << gtm_bco << std::dec
0169                 << ", bunch no: " << packet->lValue(0, "BunchNumber")
0170                 << std::endl;
0171       std::cout << PHWHERE << " RB Packet: " << newhit->getIdentifier()
0172                 << " evtno: " << newhit->getEvtSequence()
0173                 << ", bco: 0x" << std::hex << newhit->getBCO() << std::dec
0174                 << ", bunch no: " << +newhit->getBunchNumber()
0175                 << std::endl;
0176     }
0177     if (TriggerInputManager())
0178     {
0179       TriggerInputManager()->AddGl1Packet(EventSequence, newhit);
0180     }
0181     m_PacketMap[EventSequence].push_back(newhit);
0182     m_EventStack.insert(EventSequence);
0183     if (ddump_enabled())
0184     {
0185       ddumppacket(packet);
0186     }
0187
0188     delete packet;
0189   }
0190 }
0191
0192 void SingleGl1TriggerInput::Print(const std::string &what) const
0193 {
0194   if (what == "ALL" || what == "STORAGE")
0195   {
0196     for (const auto &bcliter : m_PacketMap)
0197     {
0198       std::cout << PHWHERE << "Event: " << bcliter.first << std::endl;
0199     }
0200   }
0201   if (what == "ALL" || what == "STACK")
0202   {
0203     for (auto iter : m_EventStack)
0204     {
0205       std::cout << PHWHERE << "stacked event: " << iter << std::endl;
0206     }
0207   }
0208 }
0209
0210 void SingleGl1TriggerInput::CleanupUsedPackets(const int eventno)
0211 {
0212   std::vector<int> toclearevents;
0213   for (const auto &iter : m_PacketMap)
0214   {
0215     if (iter.first <= eventno)
0216     {
0217       for (auto pktiter : iter.second)
0218       {
0219         delete pktiter;
0220       }
0221       toclearevents.push_back(iter.first);
0222     }
0223     else
0224     {
0225       break;
0226     }
0227   }
0228
0229   for (auto iter : toclearevents)
0230   {
0231     m_EventStack.erase(iter);
0232     m_PacketMap.erase(iter);
0233   }
0234 }
0235
0236 void SingleGl1TriggerInput::ClearCurrentEvent()
0237 {
0238   // called interactively, to get rid of the current event
0239   int currentevent = *m_EventStack.begin();
0240   //  std::cout << PHWHERE << "clearing bclk 0x" << std::hex << currentbclk << std::dec << std::endl;
0241   CleanupUsedPackets(currentevent);
0242   return;
0243 }
0244
0245 void SingleGl1TriggerInput::CreateDSTNode(PHCompositeNode *topNode)
0246 {
0247   PHNodeIterator iter(topNode);
0248   PHCompositeNode *dstNode = dynamic_cast<PHCompositeNode *>(iter.findFirst("PHCompositeNode", "DST"));
0249   if (!dstNode)
0250   {
0251     dstNode = new PHCompositeNode("DST");
0252     topNode->addNode(dstNode);
0253   }
0254   PHNodeIterator iterDst(dstNode);
0255   PHCompositeNode *detNode = dynamic_cast<PHCompositeNode *>(iterDst.findFirst("PHCompositeNode", "GL1"));
0256   if (!detNode)
0257   {
0258     detNode = new PHCompositeNode("GL1");
0259     dstNode->addNode(detNode);
0260   }
0261   OfflinePacket *gl1hitcont = findNode::getClass<OfflinePacket>(detNode, "GL1Packet");
0262   if (!gl1hitcont)
0263   {
0264     gl1hitcont = new Gl1Packetv3();
0265     PHIODataNode<PHObject> *newNode = new PHIODataNode<PHObject>(gl1hitcont, "GL1Packet", "PHObject");
0266     detNode->addNode(newNode);
0267   }
0268 }