framework/fun4allraw/SingleTriggerInput.cc

0001 #include "SingleTriggerInput.h"
0002
0003 #include <frog/FROG.h>
0004
0005 #include <ffarawobjects/CaloPacket.h>
0006 #include <phool/phool.h>
0007
0008 #include <Event/Eventiterator.h>
0009 #include <Event/fileEventiterator.h>
0010 #include <Event/packet.h>
0011
0012 #include <TSystem.h>
0013
0014 #include <cstdint>   // for uint64_t
0015 #include <iostream>  // for operator<<, basic_ostream, endl
0016 #include <set>
0017 #include <utility>  // for pair
0018 #include <vector>
0019
0020 SingleTriggerInput::SingleTriggerInput(const std::string &name)
0021   : Fun4AllBase(name)
0022 {
0023 }
0024
0025 SingleTriggerInput::~SingleTriggerInput()
0026 {
0027   for (auto &openfiles : m_PacketDumpFile)
0028   {
0029     openfiles.second->close();
0030     delete openfiles.second;
0031   }
0032   m_PacketDumpFile.clear();
0033   delete m_EventIterator;
0034 }
0035
0036 int SingleTriggerInput::fileopen(const std::string &filenam)
0037 {
0038   std::cout << PHWHERE << "trying to open " << filenam << std::endl;
0039   if (IsOpen())
0040   {
0041     std::cout << "Closing currently open file "
0042               << FileName()
0043               << " and opening " << filenam << std::endl;
0044     fileclose();
0045   }
0046   FileName(filenam);
0047   FROG frog;
0048   std::string fname = frog.location(FileName());
0049   if (Verbosity() > 0)
0050   {
0051     std::cout << Name() << ": opening file " << FileName() << std::endl;
0052   }
0053   int status = 0;
0054   m_EventIterator = new fileEventiterator(fname.c_str(), status);
0055   m_EventsThisFile = 0;
0056   if (status)
0057   {
0058     delete m_EventIterator;
0059     m_EventIterator = nullptr;
0060     std::cout << PHWHERE << Name() << ": could not open file " << fname << std::endl;
0061     return -1;
0062   }
0063   IsOpen(1);
0064   AddToFileOpened(fname);  // add file to the list of files which were opened
0065   return 0;
0066 }
0067
0068 int SingleTriggerInput::fileclose()
0069 {
0070   if (!IsOpen())
0071   {
0072     std::cout << Name() << ": fileclose: No Input file open" << std::endl;
0073     return -1;
0074   }
0075   delete m_EventIterator;
0076   m_EventIterator = nullptr;
0077   IsOpen(0);
0078   // if we have a file list, move next entry to top of the list
0079   // or repeat the same entry again
0080   UpdateFileList();
0081   return 0;
0082 }
0083
0084 void SingleTriggerInput::Print(const std::string &what) const
0085 {
0086   if (what == "ALL" || what == "FEE")
0087   {
0088     for (const auto &bcliter : m_BeamClockFEE)
0089     {
0090       std::cout << "Beam clock 0x" << std::hex << bcliter.first << std::dec << std::endl;
0091       for (auto feeiter : bcliter.second)
0092       {
0093         std::cout << "FEM: " << feeiter << std::endl;
0094       }
0095     }
0096   }
0097   if (what == "ALL" || what == "FEEBCLK")
0098   {
0099     for (auto bcliter : m_FEEBclkMap)
0100     {
0101       std::cout << "FEE" << bcliter.first << " bclk: 0x"
0102                 << std::hex << bcliter.second << std::dec << std::endl;
0103     }
0104   }
0105   if (what == "ALL" || what == "STACK")
0106   {
0107     for (auto iter : m_BclkStack)
0108     {
0109       std::cout << "stacked bclk: 0x" << std::hex << iter << std::dec << std::endl;
0110     }
0111   }
0112 }
0113
0114 bool SingleTriggerInput::CheckPoolDepth(const uint64_t bclk)
0115 {
0116   // if (m_FEEBclkMap.size() < 10)
0117   // {
0118   //   std::cout << "not all FEEs in map: " << m_FEEBclkMap.size() << std::endl;
0119   //   return true;
0120   // }
0121   for (auto iter : m_FEEBclkMap)
0122   {
0123     if (Verbosity() > 2)
0124     {
0125       std::cout << "my bclk 0x" << std::hex << iter.second
0126                 << " req: 0x" << bclk << std::dec << std::endl;
0127     }
0128     if (iter.second < bclk)
0129     {
0130       if (Verbosity() > 1)
0131       {
0132         std::cout << "FEE " << iter.first << " beamclock 0x" << std::hex << iter.second
0133                   << " smaller than req bclk: 0x" << bclk << std::dec << std::endl;
0134       }
0135       return true;
0136     }
0137   }
0138   return false;
0139 }
0140
0141 void SingleTriggerInput::ClearCurrentEvent()
0142 {
0143   // called interactively, to get rid of the current event
0144   uint64_t currentbclk = *m_BclkStack.begin();
0145   std::cout << "clearing bclk 0x" << std::hex << currentbclk << std::dec << std::endl;
0146   CleanupUsedPackets(currentbclk);
0147   m_BclkStack.erase(currentbclk);
0148   m_BeamClockFEE.erase(currentbclk);
0149   return;
0150 }
0151
0152 void SingleTriggerInput::ddumppacket(Packet *pkt)
0153 {
0154   int packetid = pkt->getIdentifier();
0155   if (m_PacketDumpFile.find(packetid) == m_PacketDumpFile.end())
0156   {
0157     std::string fname = "packet_" + std::to_string(packetid) + ".ddump";
0158     std::ofstream *dumpfile = new std::ofstream(fname);
0159     // dumpfile.open(fname);
0160     m_PacketDumpFile.insert(std::make_pair(packetid, dumpfile));
0161     m_PacketDumpCounter.insert(std::make_pair(packetid, m_ddump_flag));
0162   }
0163   if (m_PacketDumpCounter[packetid] != 0)
0164   {
0165     pkt->dump(*m_PacketDumpFile[packetid]);
0166     m_PacketDumpCounter[packetid]--;
0167   }
0168   return;
0169 }
0170
0171 int SingleTriggerInput::EventNumberOffset(const int packetid)
0172 {
0173   // initialize to zero, if map entry exists it will not overwrite it
0174   // just return false in retcode.second
0175   auto retcode = m_EventNumberOffset.insert(std::make_pair(packetid, m_DefaultEventNumberOffset));
0176   if (Verbosity() > 2)
0177   {
0178     if (retcode.second)
0179     {
0180       std::cout << PHWHERE << " Inserted " << m_DefaultEventNumberOffset << " as event offset for packet "
0181                 << packetid << std::endl;
0182     }
0183   }
0184   return m_EventNumberOffset[packetid];
0185 }
0186
0187 void SingleTriggerInput::AdjustEventNumberOffset(const int packetid, const int offset)
0188 {
0189   if (m_EventNumberOffset.find(packetid) == m_EventNumberOffset.end())
0190   {
0191     return;
0192   }
0193   m_EventNumberOffset[packetid] += offset;
0194 }
0195
0196 int SingleTriggerInput::AdjustPacketMap(int pktid, int evtoffset)
0197 {
0198   if (Verbosity() > 1)
0199   {
0200     std::cout << PHWHERE << " adjusting local " << Name()
0201               << " packet map for packet " << pktid
0202               << " with offset " << evtoffset << std::endl;
0203   }
0204   std::vector<int> eventnumbers;
0205   for (auto packetmapiter = m_PacketMap.rbegin(); packetmapiter != m_PacketMap.rend(); ++packetmapiter)
0206   {
0207     eventnumbers.push_back(packetmapiter->first);
0208   }
0209
0210   for (auto evtnumiter : eventnumbers)
0211   {
0212     int lastevent = evtnumiter;
0213     int newevent = lastevent + evtoffset;
0214     //    for (auto pktiter : m_PacketMap[lastevent])
0215     for (std::vector<OfflinePacket *>::iterator pktiter = m_PacketMap[lastevent].begin(); pktiter != m_PacketMap[lastevent].end(); ++pktiter)
0216     {
0217       if ((*pktiter)->getIdentifier() == pktid)
0218       {
0219         if (Verbosity() > 1)
0220         {
0221           std::cout << PHWHERE << " need to move packet " << (*pktiter)->getIdentifier() << std::endl;
0222         }
0223         //      trivial variables give no speed benefit from using std::move
0224         //  m_PacketMap[newevent].push_back(std::move(*pktiter));
0225         m_PacketMap[newevent].push_back(*pktiter);
0226         m_PacketMap[lastevent].erase(pktiter);
0227         break;
0228       }
0229     }
0230   }
0231   return 0;
0232 }
0233
0234 int SingleTriggerInput::AdjustEventOffset(int evtoffset)
0235 {
0236   if (Verbosity() > 1)
0237   {
0238     std::cout << PHWHERE << " adjusting local " << Name()
0239               << " all packets with offset " << evtoffset << std::endl;
0240   }
0241   std::vector<int> eventnumbers;
0242   // needs separate cases so we don't overwrite existing entries
0243   if (evtoffset < 0)  // for negative offsets start at the beginning and move down (into empty space)
0244   {
0245     for (auto &packetmapiter : m_PacketMap)
0246     {
0247       eventnumbers.push_back(packetmapiter.first);
0248     }
0249   }
0250   else  // for positive offsets start at the end and move up (into empty space)
0251   {
0252     for (auto &packetmapiter : m_PacketMap)
0253     {
0254       eventnumbers.push_back(packetmapiter.first);
0255     }
0256   }
0257
0258   for (auto evtnumiter : eventnumbers)
0259   {
0260     int lastevent = evtnumiter;
0261     int newevent = lastevent + evtoffset;
0262     //    for (auto pktiter : m_PacketMap[lastevent])
0263     for (std::vector<OfflinePacket *>::iterator pktiter = m_PacketMap[lastevent].begin(); pktiter != m_PacketMap[lastevent].end(); ++pktiter)
0264     {
0265       //      if ((*pktiter)->getIdentifier() == pktid)
0266       {
0267         if (Verbosity() > 1)
0268         {
0269           std::cout << PHWHERE << " need to move packet " << (*pktiter)->getIdentifier() << std::endl;
0270         }
0271         //      trivial variables give no speed benefit from using std::move
0272         //  m_PacketMap[newevent].push_back(std::move(*pktiter));
0273         m_PacketMap[newevent].push_back(*pktiter);
0274         m_PacketMap[lastevent].erase(pktiter);
0275         break;
0276       }
0277     }
0278   }
0279   for (auto evtnumiter : m_EventNumberOffset)
0280   {
0281     evtnumiter.second += evtoffset;
0282   }
0283   return 0;
0284 }
0285
0286 bool SingleTriggerInput::GetSomeMoreEvents(const unsigned int keep)
0287 {
0288   if (AllDone())
0289   {
0290     return false;
0291   }
0292   if (m_PacketMap.empty())
0293   {
0294     return true;
0295   }
0296   if (Verbosity() > 21)
0297   {
0298     std::cout << PHWHERE << Name() << ": first event: " << m_PacketMap.begin()->first
0299               << " last event: " << m_PacketMap.rbegin()->first << " size: " << m_PacketMap.size()
0300               << ", keep: " << keep
0301               << std::endl;
0302   }
0303   // how many events should be stored upstream (keep) plus number of events kept locally
0304   if (m_PacketMap.size() < std::max(2U, keep + m_LocalPoolDepth))  // at least 2 events in pool
0305   {
0306     return true;
0307   }
0308   return false;
0309 }
0310
0311 int SingleTriggerInput::SetFEMEventRefPacketId(const int pktid)
0312 {
0313   if (m_FEMEventRefPacketId > 0)
0314   {
0315     return m_FEMEventRefPacketId;
0316   }
0317 // from https://indico.bnl.gov/event/24287/contributions/94631/attachments/56257/96280/Software_20240730.pdf
0318 // /* 6067 copying to 6068 6071 6072 6075 6076 6079 6080 */ seb00
0319 // /* 6083 copying to 6084 6087 6088 6091 6092 6095 6096 */ seb01
0320 // /* 6115 copying to 6116 6119 6120 6123 6124 6127 6128 */ seb02
0321 // /* 6099 copying to 6100 6103 6104 6107 6108 6111 6112 */ seb03
0322 // /* 6035 copying to 6036 6039 6040 6043 6044 6047 6048 */ seb04
0323 // /* 6051 copying to 6052 6055 6056 6059 6060 6063 6064 */ seb05
0324 // /* 6019 copying to 6020 6023 6024 6027 6028 6031 6032 */ seb06
0325 // /* 6003 copying to 6004 6007 6008 6011 6012 6015 6016 */ seb07
0326 // /* 6065 copying to 6066 6069 6070 6073 6074 6077 6078 */ seb08
0327 // /* 6081 copying to 6082 6085 6086 6089 6090 6093 6094 */ seb09
0328 // /* 6121 copying to 6122 6125 6126 6113 6114 6117 6118 */ seb10
0329 // /* 6105 copying to 6106 6109 6110 6097 6098 6101 6102 */ seb11
0330 // /* 6033 copying to 6034 6037 6038 6041 6042 6045 6046 */ seb12
0331 // /* 6049 copying to 6050 6053 6054 6057 6058 6061 6062 */ seb13
0332 // /* 6025 copying to 6026 6029 6030 6017 6018 6021 6022 */ seb14
0333 // /* 6009 copying to 6010 6013 6014 6001 6002 6005 6006 */ seb15
0334 // /* 8001 copying to 8002 8007 8008 7001 7002 7007 7008  */ seb16
0335 // /* 8003 copying to 8004 8005 8006 7003 7004 7005 7006 */ seb17
0336 // /* 9003 copying to 9002 9001 9006 9005 9004 */ seb20 -- sepd only
0337   static std::map<int, int> refpacketmap = {
0338     {6067, 6067}, {6068, 6067}, {6071, 6067}, {6072, 6067}, {6075, 6067}, {6076, 6067}, {6079, 6067}, {6080, 6067},
0339     {6083, 6083}, {6084, 6083}, {6087, 6083}, {6088, 6083}, {6091, 6083}, {6092, 6083}, {6095, 6083}, {6096, 6083},
0340     {6115, 6115}, {6116, 6115}, {6119, 6115}, {6120, 6115}, {6123, 6115}, {6124, 6115}, {6127, 6115}, {6128, 6115},
0341     {6099, 6099}, {6100, 6099}, {6103, 6099}, {6104, 6099}, {6107, 6099}, {6108, 6099}, {6111, 6099}, {6112, 6099},
0342     {6035, 6035}, {6036, 6035}, {6039, 6035}, {6040, 6035}, {6043, 6035}, {6044, 6035}, {6047, 6035}, {6048, 6035},
0343     {6051, 6051}, {6052, 6051}, {6055, 6051}, {6056, 6051}, {6059, 6051}, {6060, 6051}, {6063, 6051}, {6064, 6051},
0344     {6019, 6019}, {6020, 6019}, {6023, 6019}, {6024, 6019}, {6027, 6019}, {6028, 6019}, {6031, 6019}, {6032, 6019},
0345     {6003, 6003}, {6004, 6003}, {6007, 6003}, {6008, 6003}, {6011, 6003}, {6012, 6003}, {6015, 6003}, {6016, 6003},
0346     {6065, 6065}, {6066, 6065}, {6069, 6065}, {6070, 6065}, {6073, 6065}, {6074, 6065}, {6077, 6065}, {6078, 6065},
0347     {6081, 6081}, {6082, 6081}, {6085, 6081}, {6086, 6081}, {6089, 6081}, {6090, 6081}, {6093, 6081}, {6094, 6081},
0348     {6121, 6121}, {6122, 6121}, {6125, 6121}, {6126, 6121}, {6113, 6121}, {6114, 6121}, {6117, 6121}, {6118, 6121},
0349     {6105, 6105}, {6106, 6105}, {6109, 6105}, {6110, 6105}, {6097, 6105}, {6098, 6105}, {6101, 6105}, {6102, 6105},
0350     {6033, 6033}, {6034, 6033}, {6037, 6033}, {6038, 6033}, {6041, 6033}, {6042, 6033}, {6045, 6033}, {6046, 6033},
0351     {6049, 6049}, {6050, 6049}, {6053, 6049}, {6054, 6049}, {6054, 6049}, {6058, 6049}, {6061, 6049}, {6062, 6049},
0352     {6025, 6025}, {6026, 6025}, {6029, 6025}, {6030, 6025}, {6017, 6025}, {6018, 6025}, {6021, 6025}, {6022, 6025},
0353     {6009, 6009}, {6010, 6009}, {6013, 6009}, {6014, 6009}, {6001, 6009}, {6002, 6009}, {6005, 6009}, {6006, 6009},
0354     {8001, 8001}, {8002, 8001}, {8007, 8001}, {8008, 8001}, {7001, 8001}, {7002, 8001}, {7007, 8001}, {7008, 8001},
0355     {8003, 8003}, {8004, 8003}, {8005, 8003}, {7003, 8003}, {7004, 8003}, {7005, 8003}, {7006, 8003},
0356     {9003, 9003}, {9002, 9003}, {9001, 9003}, {9006, 9003}, {9004, 9003}
0357 };
0358   auto refpacket_pair = refpacketmap.find(pktid);
0359   if (refpacket_pair != refpacketmap.end())
0360   {
0361     m_FEMEventRefPacketId = refpacket_pair->second;
0362     return m_FEMEventRefPacketId;
0363   }
0364   std::cout << PHWHERE << " could not find " << pktid << " in refpacket map" << std::endl;
0365   gSystem->Exit(1);
0366   exit(1);
0367 }