subsystems/gl1/GL1Mon.cc

0001 #include "GL1Mon.h"
0002
0003 #include <onlmon/OnlMon.h>  // for OnlMon
0004 #include <onlmon/OnlMonServer.h>
0005 #include <onlmon/triggerEnum.h>
0006
0007 #include <Event/Event.h>
0008 #include <Event/eventReceiverClient.h>
0009 #include <Event/packet.h>
0010
0011 #include <TH1.h>
0012
0013 #include <bitset>
0014 #include <iostream>
0015 #include <string>  // for allocator, string, char_traits
0016
0017 GL1Mon::GL1Mon(const std::string &name)
0018   : OnlMon(name)
0019 {
0020   // leave ctor fairly empty, its hard to debug if code crashes already
0021   // during a new GL1Mon()
0022   // triggernamemap[22] = "22";
0023   // triggernamemap[23] = "23";
0024   // triggernamemap[]
0025   // RareProbeTriggers
0026   for (const auto &miter : TriggerEnum::RareProbeTriggers)
0027   {
0028     // convert int to "int"
0029     triggernamemap[static_cast<int>(miter.first)] = std::to_string(static_cast<int>(miter.first));
0030   }
0031   return;
0032 }
0033
0034 GL1Mon::~GL1Mon()
0035 {
0036   delete erc;
0037   return;
0038 }
0039
0040 int GL1Mon::Init()
0041 {
0042   int ihist = 0;
0043   OnlMonServer *se = OnlMonServer::instance();
0044   gl1_stats = new TH1I("gl1_stats", "GL1 statistics", 1, -0.5, 0.5);
0045   se->registerHisto(this, gl1_stats);
0046   for (auto &iter : scaledtriggers)
0047   {
0048     std::string name = "gl1_scaledtrigger_" + std::to_string(ihist);
0049     std::string title = "scaled trigger bit " + std::to_string(ihist);
0050     iter = new TH1I(name.c_str(), title.c_str(), 130, -0.5, 129.5);
0051     se->registerHisto(this, iter);  // uses the TH1->GetName() as key
0052     ihist++;
0053   }
0054
0055   ihist = 0;
0056   for (auto &iter : livetriggers)
0057   {
0058     std::string name = "gl1_livetrigger_" + std::to_string(ihist);
0059     std::string title = "live trigger bit " + std::to_string(ihist);
0060     iter = new TH1I(name.c_str(), title.c_str(), 130, -0.5, 129.5);
0061     se->registerHisto(this, iter);  // uses the TH1->GetName() as key
0062     ihist++;
0063   }
0064
0065   ihist = 0;
0066   for (auto &iter : rawtriggers)
0067   {
0068     std::string name = "gl1_rawtrigger_" + std::to_string(ihist);
0069     std::string title = "raw trigger bit " + std::to_string(ihist);
0070     iter = new TH1I(name.c_str(), title.c_str(), 130, -0.5, 129.5);
0071     se->registerHisto(this, iter);  // uses the TH1->GetName() as key
0072     ihist++;
0073   }
0074   erc = new eventReceiverClient(eventReceiverClientHost);
0075   gl1_reject.resize(triggernamemap.size());
0076   ntriggers.resize(triggernamemap.size(), 0);
0077   triggernumber.resize(triggernamemap.size());
0078   triggername.resize(triggernamemap.size());
0079   int icnt = 0;
0080   for (const auto &miter : triggernamemap)
0081   {
0082     triggernumber[icnt] = miter.first;
0083     triggername[icnt] = miter.second;
0084     std::string hname = "gl1_reject_" + std::to_string(icnt);
0085     gl1_reject[icnt] = new TH1F(hname.c_str(), miter.second.c_str(), 1000, 0, 1000);
0086     se->registerHisto(this, gl1_reject[icnt]);
0087     icnt++;
0088   }
0089   TimeToLastEvent[0] = new TH1F("gl1_timetolastevent0", "Time to previous Event enlarged", 131, -0.5, 130.5);
0090   TimeToLastEvent[1] = new TH1F("gl1_timetolastevent1", "Time to previous Event", 2001, 1, 10001);
0091   TimeToLastEvent[2] = new TH1F("gl1_timetolastevent2", "Time to 2nd Event", 2001, 1, 10001);
0092   TimeToLastEvent[3] = new TH1F("gl1_timetolastevent3", "Time to 3rd Event", 2001, 1, 10001);
0093   TimeToLastEvent[4] = new TH1F("gl1_timetolastevent4", "Time to 4th Event", 2001, 1, 10001);
0094   for (auto iter : TimeToLastEvent)
0095   {
0096     se->registerHisto(this, iter);
0097   }
0098   for (int i = 1; i <= 5; i++)
0099   {
0100     eventticdeque.push_back(std::make_pair(-1*i,0));
0101   }
0102   return 0;
0103 }
0104
0105 int GL1Mon::BeginRun(const int /* runno */)
0106 {
0107   // if you need to read calibrations on a run by run basis
0108   // this is the place to do it
0109   if (erc->getStatus() != 0)
0110   {
0111     delete erc;
0112     erc = new eventReceiverClient(eventReceiverClientHost);
0113   }
0114   OnlMonServer *se = OnlMonServer::instance();
0115   se->UseGl1();
0116   lastupdate = se->CurrentTicks();
0117   starttime = lastupdate;
0118   return 0;
0119 }
0120
0121 int GL1Mon::process_event(Event *evt)
0122 {
0123   if (evt->getEvtType() == 1)
0124   {
0125     Packet *p = evt->getPacket(14001);
0126     if (p)
0127     {
0128       OnlMonServer *se = OnlMonServer::instance();
0129       int bunchnr = (p->lValue(0, "BunchNumber"));
0130       uint64_t trigscaled = static_cast<uint64_t>(p->lValue(0, "ScaledVector"));
0131       uint64_t triglive = static_cast<uint64_t>(p->lValue(0, "LiveVector"));
0132       uint64_t trigraw = static_cast<uint64_t>(p->lValue(0, "RawVector"));
0133       // triglive |= 0x1;
0134       // trigscaled |= 0x1;
0135       //  if ((triglive & trigscaled) != trigscaled) // this fails for the clock trigger
0136       //  {
0137       //    std::cout << "scaled trig vector: " << std::bitset<64>(trigscaled) << std::endl;
0138       //    std::cout << "live trig vector:   " << std::bitset<64>(triglive) << std::endl << std::endl;
0139       //  }
0140       //  std::cout << "scaled trig vector: " << std::bitset<64>(trigscaled) << std::endl;
0141       //  std::cout << "live trig vector:   " << std::bitset<64>(triglive) << std::endl << std::endl;
0142       //  std::cout << "raw trig vector: " << std::bitset<64>(trigraw) << std::endl;
0143       for (int itrig = 0; itrig < 64; itrig++)
0144       {
0145         uint64_t trigbit = 0x1UL << itrig;
0146         // fill with bunchnr+1, so the 0th bunch goes into the first channel (channel 0 is underflow)
0147         if ((trigscaled & trigbit) != 0)
0148         {
0149           scaledtriggers[itrig]->AddBinContent(bunchnr + 1);
0150         }
0151         if ((triglive & trigbit) != 0)
0152         {
0153           livetriggers[itrig]->AddBinContent(bunchnr + 1);
0154         }
0155         if ((trigraw & trigbit) != 0)
0156         {
0157           rawtriggers[itrig]->AddBinContent(bunchnr + 1);
0158         }
0159       }
0160       int eventnumber = evt->getEvtSequence();
0161       uint64_t bco = static_cast<uint64_t>(p->lValue(0, "BCO"));
0162       eventticdeque.push_back(std::make_pair(eventnumber,bco));
0163       std::pair<int, uint64_t> eventtic = eventticdeque.front();
0164       eventticdeque.pop_front();
0165       int event5th = eventtic.first;
0166       if (event5th > 0) // this will discard the first 5 events
0167       {
0168         for (int i =0; i < 5; i++)
0169         {
0170       if (eventticdeque[i].first == event5th+1+i)
0171       {
0172         TimeToLastEvent[i]->Fill(eventticdeque[i].second - eventtic.second);
0173       }
0174     }
0175       }
0176
0177       Event *gl1Event{nullptr};
0178       if (erc->getStatus() == 0)
0179       {
0180         gl1Event = erc->getEvent(eventnumber);
0181       }
0182       if (gl1Event)
0183       {
0184         se->IncrementGl1FoundCounter();
0185         if (gl1Event->getEvtSequence() != eventnumber)
0186         {
0187           std::cout << "event number mismatch, asked for " << eventnumber
0188                     << ", got " << gl1Event->getEvtSequence() << std::endl;
0189         }
0190         Packet *p_gl1 = gl1Event->getPacket(14001);
0191         if (p_gl1)
0192         {
0193           if (p_gl1->lValue(0, "BCO") != p->lValue(0, "BCO"))
0194           {
0195             std::cout << "BCO mismatch for event " << eventnumber
0196                       << std::endl;
0197           }
0198           if (p_gl1->iValue(0) != p->iValue(0))
0199           {
0200             std::cout << "Packet number mismatch for event " << eventnumber
0201                       << "erc: " << p_gl1->iValue(0) << " current event: "
0202                       << p->iValue(0) << std::endl;
0203             gl1_stats->AddBinContent(1);
0204           }
0205         }
0206         delete p_gl1;
0207       }
0208       delete gl1Event;
0209       // rejection factors
0210
0211       static constexpr time_t mintimediff{60};  //*60}; // every 5 minutes
0212       time_t ticks = se->CurrentTicks();
0213       if (ticks - lastupdate > mintimediff)
0214       {
0215         //      std::cout << "ticks: " << ticks << ", last: " << lastupdate << std::endl;
0216         int64_t current_mbtrigs = p->lValue(TriggerEnum::BitCodes::MBD_NS1_ZVRTX150, "TRIGGERRAW") - n_minbias;
0217
0218         for (size_t i = 0; i < triggernumber.size(); i++)
0219         {
0220           int64_t curscale = p->lValue(triggernumber[i], "TRIGGERRAW") - ntriggers[i];
0221           // std::cout << "mb trigs: " << current_mbtrigs << " " <<  triggername[i]
0222           //        << ": " << curscale << std::endl;
0223           float rejection = (current_mbtrigs * 1.) / (curscale * 1.);
0224           ntriggers[i] += curscale;
0225           if (std::isfinite(rejection))
0226           {
0227             int nEntries = gl1_reject[i]->GetEntries();
0228             gl1_reject[i]->SetBinContent(nEntries + 1, rejection);
0229             gl1_reject[i]->SetBinError(nEntries + 1, ticks - starttime);
0230           }
0231           // std::cout << "setting rejection to " << rejection << " for trigger " << triggername[i] << std::endl;
0232         }
0233         n_minbias += current_mbtrigs;
0234         lastupdate = ticks;
0235       }
0236       //    std::cout << "minbias count: " << p->lValue(12,"TRIGGERSCALED") << std::endl;
0237       // std::cout << "photon10: " << p->lValue(22,"TRIGGERSCALED") << std::endl;
0238       // std::cout << "photon12: " << p->lValue(23,"TRIGGERSCALED") << std::endl;
0239       // float rejection10 =
0240       delete p;
0241     }
0242   }
0243   return 0;
0244 }
0245
0246 int GL1Mon::Reset()
0247 {
0248   // reset our internal counters
0249   n_minbias = 0;
0250   std::fill(ntriggers.begin(), ntriggers.end(),0);
0251   return 0;
0252 }