Skimmers/CaloPacket/CaloPacketSkimmer.cc

0001 #include "CaloPacketSkimmer.h"
0002
0003 #include <qautils/QAHistManagerDef.h>
0004
0005 #include <ffarawobjects/CaloPacket.h>
0006 #include <ffarawobjects/CaloPacketContainer.h>
0007
0008 #include <fun4all/Fun4AllHistoManager.h>
0009 #include <fun4all/Fun4AllReturnCodes.h>
0010
0011 #include <phool/getClass.h>
0012 #include <phool/phool.h>
0013
0014 #include <Event/Event.h>
0015 #include <Event/EventTypes.h>
0016 #include <Event/packet.h>
0017
0018 #include <TH1.h>
0019
0020 #include <cassert>
0021 #include <iostream>  // for operator<<, basic_ostream
0022 #include <map>       // for operator!=, _Rb_tree_iterator
0023 #include <utility>   // for pair
0024 #include <variant>
0025
0026 static const std::map<CaloTowerDefs::DetectorSystem, std::string> nodemap{
0027     {CaloTowerDefs::CEMC, "CEMCPackets"},
0028     {CaloTowerDefs::HCALIN, "HCALPackets"},
0029     {CaloTowerDefs::HCALOUT, "HCALPackets"},
0030     {CaloTowerDefs::ZDC, "ZDCPackets"},
0031     {CaloTowerDefs::SEPD, "SEPDPackets"},
0032     {CaloTowerDefs::MBD, "MBDPackets"}};
0033
0034 //____________________________________________________________________________..
0035 CaloPacketSkimmer::CaloPacketSkimmer(const std::string &name)
0036   : SubsysReco(name)
0037 {
0038 }
0039
0040 int CaloPacketSkimmer::InitRun(PHCompositeNode * /*topNode*/)
0041 {
0042   // Initialize the detector systems to be used
0043   if (Verbosity() > 0)
0044   {
0045     std::cout << "CaloPacketSkimmer::InitRun - Initializing with detectors: ";
0046     for (const auto &det : m_CaloDetectors)
0047     {
0048       std::cout << getDetectorName(det) << " ";
0049     }
0050     std::cout << std::endl;
0051   }
0052
0053   auto *hm = QAHistManagerDef::getHistoManager();
0054   assert(hm);
0055
0056   h_aborted_events = new TH1D("h_caloskimmer_aborted_events", "Aborted Events", 1, 0, 1);
0057   h_aborted_events->SetDirectory(nullptr);
0058   hm->registerHisto(h_aborted_events);
0059
0060   h_kept_events = new TH1D("h_caloskimmer_kept_events", "Kept Events", 1, 0, 1);
0061   h_kept_events->SetDirectory(nullptr);
0062   hm->registerHisto(h_kept_events);
0063
0064   h_missing_packets = new TH1D("h_caloskimmer_missing_packets", "Missing Packets", 6000, 6000, 12000);
0065   h_missing_packets->SetDirectory(nullptr);
0066   hm->registerHisto(h_missing_packets);
0067
0068   h_empty_packets = new TH1D("h_caloskimmer_empty_packets", "Empty Packets", 6000, 6000, 12000);
0069   h_empty_packets->SetDirectory(nullptr);
0070   hm->registerHisto(h_empty_packets);
0071
0072   return Fun4AllReturnCodes::EVENT_OK;
0073 }
0074
0075 //____________________________________________________________________________..
0076 int CaloPacketSkimmer::process_event(PHCompositeNode *topNode)
0077 {
0078   bool bad_event = false;
0079   // loop over detectors and return DISCARDEVENT if any detector fails
0080   for (const auto &det : m_CaloDetectors)
0081   {
0082     if (Verbosity() > 1)
0083     {
0084       std::cout << "CaloPacketSkimmer::process_event - Processing detector: " << getDetectorName(det) << std::endl;
0085     }
0086     int ret = processDetector(topNode, det);
0087     if (ret != Fun4AllReturnCodes::EVENT_OK)
0088     {
0089       if (Verbosity() > 1)
0090       {
0091         std::cout << "CaloPacketSkimmer::process_event - Detector " << getDetectorName(det) << " failed" << std::endl;
0092       }
0093       bad_event = true;
0094     }
0095   }
0096
0097   h_kept_events->Fill(1);  // Increment histogram for kept events
0098   if (bad_event)
0099   {
0100     h_aborted_events->Fill(1);  // Increment histogram for aborted events
0101     return Fun4AllReturnCodes::DISCARDEVENT;
0102   }
0103   return Fun4AllReturnCodes::EVENT_OK;
0104 }
0105
0106 //____________________________________________________________________________..
0107 int CaloPacketSkimmer::processDetector(PHCompositeNode *topNode, CaloTowerDefs::DetectorSystem dettype)
0108 {
0109   // Process the detector data and filter packets based on the accepted IDs
0110   auto packetRange = getPacketRange(dettype);
0111   int startID = packetRange.first;
0112   int endID = packetRange.second;
0113
0114   if (Verbosity() > 4)
0115   {
0116     std::cout << "Processing " << getDetectorName(dettype) << " from ID " << startID << " to " << endID << std::endl;
0117   }
0118   std::variant<CaloPacketContainer *, Event *> event;
0119   if (m_UseOfflinePacketFlag)
0120   {
0121     CaloPacketContainer *cont = findNode::getClass<CaloPacketContainer>(topNode, nodemap.find(dettype)->second);
0122     if (!cont)
0123     {
0124       for (int pid = startID; pid <= endID; pid++)
0125       {
0126         if (findNode::getClass<CaloPacket>(topNode, pid))
0127         {
0128           m_PacketNodesFlag = true;
0129           break;
0130         }
0131       }
0132       if (!m_PacketNodesFlag)
0133       {
0134         if (Verbosity() > 0)
0135         {
0136           std::cout << "CaloPacketSkimmer: unable to find node " << nodemap.find(dettype)->second << "  skiping event" << std::endl;
0137         }
0138         return Fun4AllReturnCodes::EVENT_OK;
0139       }
0140     }
0141     event = cont;
0142   }
0143   else
0144   {
0145     Event *_event = findNode::getClass<Event>(topNode, "PRDF");
0146     if (_event == nullptr)
0147     {
0148       if (Verbosity() > 0)
0149       {
0150         std::cout << PHWHERE << " Event node not found, skipping event" << std::endl;
0151       }
0152       return Fun4AllReturnCodes::ABORTEVENT;
0153     }
0154     if (_event->getEvtType() != DATAEVENT)
0155     {
0156       return Fun4AllReturnCodes::ABORTEVENT;
0157     }
0158     event = _event;
0159   }
0160   // since the function call on Packet and CaloPacket is the same, maybe we can use lambda? ... yes, we can!
0161   auto process_packet = [&](auto *packet, int pid)
0162   {
0163     if (packet)
0164     {
0165       int nchannels = packet->iValue(0, "CHANNELS");
0166       if (nchannels == 0)
0167       {
0168         if (Verbosity() > 1)
0169         {
0170           std::cout << "CaloPacketSkimmer: No channels in packet " << pid << " for detector " << getDetectorName(dettype) << std::endl;
0171         }
0172         h_empty_packets->Fill(pid);
0173         return Fun4AllReturnCodes::DISCARDEVENT;
0174       }
0175     }
0176     else
0177     {
0178       if (Verbosity() > 1)
0179       {
0180         std::cout << "CaloPacketSkimmer: Packet " << pid << " not found for detector " << getDetectorName(dettype) << std::endl;
0181       }
0182       h_missing_packets->Fill(pid);
0183       return Fun4AllReturnCodes::DISCARDEVENT;
0184     }
0185     return Fun4AllReturnCodes::EVENT_OK;
0186   };
0187   // loop over packets
0188   bool bad_event = false;
0189   for (int pid = startID; pid <= endID; pid++)
0190   {
0191     if (!m_PacketNodesFlag)
0192     {
0193       if (auto *cont = std::get_if<CaloPacketContainer *>(&event))
0194       {
0195         if (!*cont)
0196         {
0197           std::cout << PHWHERE << " CaloPacketContainer not found: " << nodemap.find(dettype)->second << std::endl;
0198           return Fun4AllReturnCodes::DISCARDEVENT;
0199         }
0200         CaloPacket *packet = (*cont)->getPacketbyId(pid);
0201         if (process_packet(packet, pid) == Fun4AllReturnCodes::DISCARDEVENT)
0202         {
0203           bad_event = true;
0204         }
0205       }
0206       else if (auto *_event = std::get_if<Event *>(&event))
0207       {
0208         Packet *packet = (*_event)->getPacket(pid);
0209         if (process_packet(packet, pid) == Fun4AllReturnCodes::DISCARDEVENT)
0210         {
0211           bad_event = true;
0212         }
0213         delete packet;
0214       }
0215     }
0216     else
0217     {
0218       CaloPacket *calopacket = findNode::getClass<CaloPacket>(topNode, pid);
0219       if (process_packet(calopacket, pid) == Fun4AllReturnCodes::DISCARDEVENT)
0220       {
0221         bad_event = true;
0222       }
0223     }
0224   }
0225
0226   if (bad_event)
0227   {
0228     return Fun4AllReturnCodes::DISCARDEVENT;
0229   }
0230
0231   return Fun4AllReturnCodes::EVENT_OK;
0232 }
0233
0234 int CaloPacketSkimmer::EndRun(const int /*runnumber*/)
0235 {
0236   std::cout << "CaloPacketSkimmer::EndRun - Analyzed events: " << h_kept_events->GetEntries() << std::endl;
0237   std::cout << "CaloPacketSkimmer::EndRun - Discarded events: " << h_aborted_events->GetEntries() << std::endl;
0238   // loop over and print the missing and empty packets
0239   for (int pid = 6000; pid <= 12000; pid++)
0240   {
0241     int bin = h_missing_packets->FindBin(pid);
0242     if (h_missing_packets->GetBinContent(bin) > 0)
0243     {
0244       std::cout << "CaloPacketSkimmer::EndRun - Missing packet: " << pid << " occurences: " << h_missing_packets->GetBinContent(bin) << std::endl;
0245     }
0246     if (h_empty_packets->GetBinContent(bin) > 0)
0247     {
0248       std::cout << "CaloPacketSkimmer::EndRun - Empty packet: " << pid << " occurences: " << h_empty_packets->GetBinContent(bin) << std::endl;
0249     }
0250   }
0251   return Fun4AllReturnCodes::EVENT_OK;
0252 }