ATLAS Offline Software
LumiCalculator.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "LumiCalc/LumiCalculator.h"
6 
7 // GoodRunsLists
8 #include "GoodRunsLists/TGoodRunsList.h"
9 #include "GoodRunsLists/TGoodRunsListWriter.h"
10 
11 //
12 #include "LumiCalc/CoolQuery.h"
13 #include "LumiCalc/LumiBlockRangeContainerConverter.h"
14 
15 // ROOT
16 #include "TH1F.h"
17 #include "TTree.h"
18 #include "TFile.h"
19 #include "TString.h"
20 #include "TObjString.h"
21 #include "TROOT.h"
22 
23 // stl includes
24 #include <memory>
25 #include <iomanip>
26 #include <iostream>
27 #include <set>
28 #include <regex.h>
29 #include <stdexcept>
30 
31 LumiCalculator::LumiCalculator()
32  : m_LumiTree (nullptr)
33  , m_recordTTree (false)
34  , m_State (true)
35 
36  , m_trigger ("COOLONL_TRIGGER/")
37  , m_lumioff ("COOLOFL_TRIGGER/")
38  , m_lumionl ("COOLONL_TRIGGER/")
39  , m_lumitag ("OflLumi-8TeV-002")// for offline: OflLumi_CosmicFake, OflLumi_TopMix
40  , m_lumimethod ("")// offline channels: ATLAS_PREFERRED, OflLumi_Fake0, OflLumi_Fake:, TopMixLumi
41  , m_laroff ("COOLOFL_LAR/")
42  , m_bsonl ("COOLONL_INDET/")
43  , m_bstag ("IndetBeamposOnl-HLT-UPD1-001-00")
44 
45  , m_parlvl1menufolder ("/TRIGGER/LVL1/Menu")
46  , m_parhltmenufolder ("/TRIGGER/HLT/Menu")// ChainCounter is here for COOLONL_TRIGGER/COMP20
47  , m_parhltprescalesfolder ("/TRIGGER/HLT/Prescales")// ChainCounter is here for COOLONL_TRIGGER/COMP20
48  , m_parlumilvl1folder ("/TRIGGER/LUMI/LVL1COUNTERS")
49  , m_parlumihltfolder ("/TRIGGER/LUMI/HLTCOUNTERS")
50  , m_parlvl1prescalesfolder ("/TRIGGER/LVL1/Prescales")
51  , m_parlvl1lblbfolder ("/TRIGGER/LUMI/LBLB")// for time information
52  , m_parlareventvetofolder ("/LAR/BadChannelsOfl/EventVeto") // For LAr event veto
53  , m_paronlbeamspotfolder ("/Indet/Onl/Beampos") // For invalid online beamspot
54 
55  , m_logger( "LumiCalculator" )
56  , m_lbcollname ("LumiBlocks")
57  , m_uselivetrigger (false)
58  , m_verbose (false)
59  , m_lbstarttime(0.)
60  , m_lbendtime(0.)
61 
62  , m_totalDelL(0.)
63  , m_totalL(0.)
64  , m_totalLRun(0.)
65  , m_totaltime(0.)
66  , m_instLumi(0.)
67  , m_AvEvtsPerBX(0.)
68  , m_delLumi(0.)
69  , m_intLumi(0.)
70  , m_deltaT(0.)
71  , m_TotaldeltaT(0.)
72  , m_livefrac(0.)
73  , m_livetime(0.)
74  , m_l1acc(0)
75  , m_livetime_l1acc(0)
76  , m_l1accof(false)
77  , m_l2acc(0)
78  , m_l3acc(0)
79  , m_totall1acc(0)
80  , m_livtrig_totall1acc(0)
81  , m_totall1befpresc(0)
82  , m_totall2acc(0)
83  , m_totall3acc(0)
84  , m_l1prescale(0.)
85  , m_l2prescale(0.)
86  , m_l3prescale(0.)
87  , m_afterprescale(0)
88  , m_livetime_beforeprescale(0)
89  , m_livetime_afterprescale(0)
90  , m_afterprescaleof(false)
91  , m_beforeprescale(0)
92  , m_beforeprescaleof(false)
93  , m_runnbr(0)
94  , m_lbstart(0)
95  , m_lbstop(0)
96  , m_lbstart_prev(0)
97  , m_lbstop_prev(0)
98  , m_runnbr_prev(0)
99  , m_totalgoodblock(0)
100  , m_totalbadblock(0)
101  , m_clumiblocknbr(0)
102  , m_clumiblocknbrend(0)
103  , m_triglevel(0)
104  , m_totalPrescaleWLiveTime(0.)
105  , m_t_totalPrescaleWLiveTime(0.)
106  , m_totalPrescale(0.)
107  , m_t_totalPrescale(0.)
108  , m_lumiWOPrescale(0.)
109  , m_t_lumiWOPrescale(0.)
110  , m_lumiLAr(0.)
111  , m_t_lumiLAr(0.)
112  , m_t_totalDelL(0.)
113  , m_t_totalL(0.)
114  , m_t_totalLRun(0.)
115  , m_t_totaltime(0.)
116  , m_t_deltaT(0.)
117  , m_t_l1acc(0)
118  , m_t_l2acc(0)
119  , m_t_l3acc(0)
120  , m_t_totalgoodblock(0)
121  , m_t_totalbadblock(0)
122  , m_t_totall1befpresc(0)
123  , m_lartime(0.)
124  , m_larfrac(0.)
125  , m_bsvalid(0.)
126  , m_effxsec(1.)
127  , m_l1rate(0.)
128  , m_l2rate(0.)
129  , m_l3rate(0.)
130  , m_l1ratediveffxsec(0.)
131  , m_total_l1ratediveffxsec(0.)
132  , m_total_l1ratediveffxsecRun(0.)
133  , m_l1ratediveffxsec_recorded(0.)
134  , m_total_l1ratediveffxsec_recorded(0.)
135  , m_total_l1ratediveffxsecRun_recorded(0.)
136  , m_mintrigrate(5./120.)
137  , m_collsgrl(0)
138  , m_ntrigplb(0)
139  , m_trigrateplb(0)
140  , m_lumiplb(0)
141  , m_lumitrigrateplb(0)
142  , m_intlumi(0)
143  , m_intlumitrigrate(0)
144  , m_lumitrigrateplb_recorded(0)
145  , m_intlumitrigrate_recorded(0)
146  , m_intlumiruns(0)
147  , m_intlumitrigrateruns(0)
148  , m_intlumitrigrateruns_recorded(0)
149  , m_avgintperbx(0)
150  , m_makePlots(false)
151  , m_makecollList(false)
152  , m_Lumiid(0)
153  , m_L3id(0)
154  , m_L2id(0)
155  , m_L1id(0)
156  , m_LiveL1id(0)
157  , m_L1Valid(false)
158  , m_L2Valid(false)
159  , m_L3Valid(false)
160  , m_LiveValid(false)
161  , m_onlinelumi(false)
162  , m_uselar(false)
163  , m_usebs(false)
164  , m_minrun(0)
165  , m_maxrun(0)
166 {
167 
168  // by default we use the "offline data" database name
169  m_lumi_database = m_lumioff + m_data_db;
170  m_trig_database = m_trigger + m_data_db;
171  m_lar_database = m_laroff + m_data_db;
172  m_bs_database = m_bsonl + m_data_db;
173 
174  m_lumichannel = 0;
175 
176 }
177 
178 
179 LumiCalculator::~LumiCalculator(){
180 
181  // delete collisions grl
182  if (m_collsgrl!=0) { delete m_collsgrl; m_collsgrl=0; }
183 
184  std::vector<TH1F*>::iterator itr;
185  for (itr=m_ntrigplbVec.begin(); itr!=m_ntrigplbVec.end(); ++itr) { delete *itr; }
186  for (itr=m_trigrateplbVec.begin(); itr!=m_trigrateplbVec.end(); ++itr) { delete *itr; }
187  for (itr=m_lumiplbVec.begin(); itr!=m_lumiplbVec.end(); ++itr) { delete *itr; }
188  for (itr=m_lumitrigrateplbVec.begin(); itr!=m_lumitrigrateplbVec.end(); ++itr) { delete *itr; }
189  for (itr=m_intlumiVec.begin(); itr!=m_intlumiVec.end(); ++itr) { delete *itr; }
190  for (itr=m_intlumitrigrateVec.begin(); itr!=m_intlumitrigrateVec.end(); ++itr) { delete *itr; }
191  for (itr=m_lumitrigrateplb_recordedVec.begin(); itr!=m_lumitrigrateplb_recordedVec.end(); ++itr) { delete *itr; }
192  for (itr=m_intlumitrigrate_recordedVec.begin(); itr!=m_intlumitrigrate_recordedVec.end(); ++itr) { delete *itr; }
193 
194  m_ntrigplbVec.clear();
195  m_trigrateplbVec.clear();
196  m_lumiplbVec.clear();
197  m_lumitrigrateplbVec.clear();
198  m_intlumiVec.clear();
199  m_intlumitrigrateVec.clear();
200  m_lumitrigrateplb_recordedVec.clear();
201  m_intlumitrigrate_recordedVec.clear();
202 
203  if (m_intlumiruns!=0) { delete m_intlumiruns; m_intlumiruns=0; }
204  if (m_intlumitrigrateruns!=0) { delete m_intlumitrigrateruns; m_intlumitrigrateruns=0; }
205  if (m_intlumitrigrateruns_recorded!=0) { delete m_intlumitrigrateruns_recorded; m_intlumitrigrateruns_recorded=0; }
206  if (m_avgintperbx != 0) { delete m_avgintperbx; m_avgintperbx = 0; }
207 
208 }
209 
210 void LumiCalculator::setTree(TTree * tree){
211  // Register branches
212  m_LumiTree = tree;
213  if(m_LumiTree != 0){
214 
215  m_LumiTree->Branch("LBStartTime/D", &m_lbstarttime);
216  m_LumiTree->Branch("LBEndTime/D", &m_lbendtime);
217  m_LumiTree->Branch("Trigger", &m_triggerchain);
218  m_LumiTree->Branch("LBCollection", &m_lbcollname);
219  m_LumiTree->Branch("RunNbr", &m_runnbr);
220  m_LumiTree->Branch("IOVRStart", &m_lbstart);
221  m_LumiTree->Branch("IOVREnd", &m_lbstop);
222  m_LumiTree->Branch("LBStart", &m_clumiblocknbr);
223  m_LumiTree->Branch("Inst_m_Lumi", &m_instLumi);
224  m_LumiTree->Branch("LiveTime", &m_livetime);
225  m_LumiTree->Branch("L1Presc", &m_l1prescale);
226  m_LumiTree->Branch("L2Presc", &m_l2prescale);
227  m_LumiTree->Branch("L3Presc", &m_l3prescale);
228  m_LumiTree->Branch("L1Count", &m_l1acc);
229  m_LumiTree->Branch("L1CountOverFlow", &m_l1accof);
230  m_LumiTree->Branch("L2Count", &m_l2acc);
231  m_LumiTree->Branch("L3Count", &m_l3acc);
232  m_LumiTree->Branch("L1AfterPrescale", &m_afterprescale);
233  m_LumiTree->Branch("L1AfterPrescaleOverFlow", &m_afterprescaleof);
234  m_LumiTree->Branch("L1BeforePrescale", &m_beforeprescale);
235  m_LumiTree->Branch("L1BeforePrescaleOverFlow", &m_beforeprescaleof);
236  m_LumiTree->Branch("Livefrac", &m_livefrac);
237  m_LumiTree->Branch("LArfrac", &m_larfrac);
238  m_LumiTree->Branch("DeltaT", &m_deltaT);
239  m_LumiTree->Branch("L1Rate", &m_l1rate);
240  m_LumiTree->Branch("IntLumi",&m_intLumi);
241  m_LumiTree->Branch("L1Ratediveffxsec",&m_l1ratediveffxsec);
242  m_LumiTree->Branch("TotalLumi",&m_totalL);
243  m_LumiTree->Branch("Total_L1Ratediveffxsec",&m_total_l1ratediveffxsec);
244  m_LumiTree->Branch("TotalLumiRun",&m_totalLRun);
245  m_LumiTree->Branch("Total_L1RatediveffxsecRun",&m_total_l1ratediveffxsecRun);
246  m_LumiTree->Branch("L1RatediveffxsecRecorded",&m_l1ratediveffxsec_recorded);
247  m_LumiTree->Branch("Total_L1RatediveffxsecRecorded",&m_total_l1ratediveffxsec_recorded);
248  m_LumiTree->Branch("Total_L1RatediveffxsecRunRecorded",&m_total_l1ratediveffxsecRun_recorded);
249  m_LumiTree->Branch("AvergeInteractionPerXing",&m_AvEvtsPerBX);
250  m_LumiTree->Branch("BSValid", &m_bsvalid);
251  }
252 
253 }
254 
255 
256 void LumiCalculator::SetCollName(const std::string& lbcollname){
257  m_lbcollname = lbcollname;
258 }
259 
260 
261 void LumiCalculator::Verbose(bool verbose){
262  m_verbose = verbose;
263 }
264 
265 void LumiCalculator::UseMC(bool mc){
266 
267  // Print warning
268  if (mc)
269  m_logger << Root::kWARNING << "Monte Carlo mode no longer supported!" << Root::GEndl;
270 
271 }
272 
273 void LumiCalculator::UseOnlineLumi(bool online){
274 
275  m_onlinelumi = online;
276 
277 }
278 
279 void LumiCalculator::UseLumiTag(const std::string& tag){
280  m_lumitag = tag;
281 }
282 
283 void LumiCalculator::UseLumiMethod(const std::string& method){
284  m_lumimethod = method;
285 }
286 
287 void LumiCalculator::UseLumiChannel(int chan){
288  m_lumichannel = chan;
289  m_lumimethod = "";
290 }
291 
292 
293 void LumiCalculator::UseLiveTrigger(bool live, std::string& livetrigger){
294  m_uselivetrigger = live;
295  m_livetrigger = livetrigger;
296 }
297 
298 void LumiCalculator::UseLArNoiseDB(bool lar, const std::string& lartag) {
299  m_uselar = lar;
300  m_lartag = lartag;
301 }
302 
303 void LumiCalculator::UseBeamspot(bool bs, const std::string& bstag) {
304  m_usebs = bs;
305  m_bstag = bstag;
306 }
307 
308 TTree * LumiCalculator::getTree(){
309  if(m_LumiTree != 0)return m_LumiTree;
310  return 0;
311 }
312 
313 //______________________________________________________________________________
314 void LumiCalculator::IntegrateLumi ATLAS_NOT_THREAD_SAFE (const xAOD::LumiBlockRangeContainer * iovc, const std::string& triggerchain){
315 
316 
317  CoolQuery * cq_lumi = NULL;
318  CoolQuery * cq_trigger = NULL;
319  CoolQuery* cq_lar = NULL;
320  CoolQuery* cq_bs = NULL;
321 
322  // Peek at first run in iovc to check if we want Run1 or Run2 data
323  xAOD::LumiBlockRangeContainer::const_iterator it = iovc->begin();
324  // const IOVRange * iovr = (*it);
325  const IOVRange* iovr = new IOVRange(IOVTime((*it)->startRunNumber(),(*it)->startLumiBlockNumber()),
326  IOVTime((*it)->stopRunNumber(),(*it)->stopLumiBlockNumber()));
327 
328  bool isrun2 = false;
329  std::string onlfolder;
330  std::string oflfolder;
331  if (iovr->start().run() > 222222) {
332  isrun2 = true;
333  m_data_db="CONDBR2";
334  onlfolder = "/TRIGGER/LUMI/OnlPrefLumi";
335  oflfolder = "/TRIGGER/OFLLUMI/OflPrefLumi";
336  } else {
337  isrun2 = false;
338  m_data_db="COMP200";
339  onlfolder = "/TRIGGER/LUMI/LBLESTONL";
340  oflfolder = "/TRIGGER/OFLLUMI/LBLESTOFL";
341  }
342 
343  // define all connection strings
344 
345  // check for online DB
346  if(m_onlinelumi){
347  m_lumi_database = m_lumionl + m_data_db;
348  m_parlumiestfolder = std::move(onlfolder);
349  } else {
350  m_lumi_database = m_lumioff + m_data_db;
351  m_parlumiestfolder = std::move(oflfolder);
352  }
353 
354  m_trig_database = m_trigger + m_data_db;
355  m_lar_database = m_laroff + m_data_db;
356  m_bs_database = m_bsonl + m_data_db;
357 
358 
359  m_logger << Root::kINFO << "Luminosity database: " << m_lumi_database << Root::GEndl;
360  m_logger << Root::kINFO << "Trigger database: " << m_trig_database << Root::GEndl;
361 
362  cq_lumi = new CoolQuery(m_lumi_database, triggerchain);
363  if (!cq_lumi->openDbConn()) {
364  delete cq_lumi;
365  return;
366  }
367 
368  cq_trigger = new CoolQuery(m_trig_database, triggerchain);
369  if (!cq_trigger->openDbConn()) {
370  delete cq_trigger;
371  return;
372  }
373 
374  if (m_uselar) {
375  m_logger << Root::kINFO << "LAr database: " << m_lar_database << Root::GEndl;
376 
377  cq_lar = new CoolQuery(m_lar_database, triggerchain);
378  if (!cq_lar->openDbConn()) {
379  delete cq_lar;
380  return;
381  }
382  }
383 
384  if (m_usebs) {
385  m_logger << Root::kINFO << "Onl beamspot database: " << m_bs_database << Root::GEndl;
386 
387  cq_bs = new CoolQuery(m_bs_database, triggerchain);
388  if (!cq_bs->openDbConn()) {
389  delete cq_bs;
390  return;
391  }
392  }
393 
394  // initialize
395  m_lbstarttime = 0.;
396  m_lbendtime = 0.;
397  m_totalDelL = 0.;
398  m_totalL = 0.;
399  m_totalLRun = 0.;
400  m_totaltime = 0.;
401  m_instLumi = 0.;
402  m_delLumi = 0.;
403  m_intLumi = 0.;
404  m_deltaT = 0.;
405 
406  m_totalPrescaleWLiveTime = 0.;
407  m_totalPrescale = 0.;
408  m_lumiWOPrescale = 0.;
409  m_lumiLAr = 0.;
410  m_TotaldeltaT = 0.;
411  m_livefrac = 0.;
412  m_livetime = 0.;
413  m_lartime = 0.;
414  m_larfrac = 0.;
415  m_bsvalid = 0.;
416  m_livetime_l1acc = 0;
417  m_l1acc = 0;
418  m_l2acc = 0;
419  m_l3acc = 0;
420  m_totall1acc = 0;
421  m_livtrig_totall1acc = 0;
422  m_totall2acc = 0;
423  m_totall3acc = 0;
424  m_l1prescale = 1.;
425  m_l2prescale = 1.;
426  m_l3prescale = 1.;
427  m_livetime_beforeprescale = 0;
428  m_livetime_afterprescale = 0;
429  m_afterprescale = 0;
430  m_beforeprescale = 0;
431  m_totall1befpresc = 0;
432  m_runnbr = 0;
433  m_lbstart = 0;
434  m_lbstop = 0;
435  m_lbstart_prev = 0;
436  m_lbstop_prev = 0;
437  m_totalgoodblock = 0;
438  m_totalbadblock = 0;
439  m_clumiblocknbr = 0;
440  m_clumiblocknbrend =0;
441  m_triglevel = 0;
442  m_lbcollectionname = "LumiBlocks";
443  m_triggerchain = triggerchain;
444  m_l1rate = 0.;
445  m_l2rate = 0.;
446  m_l3rate = 0.;
447  m_l1ratediveffxsec = 0.;
448  m_total_l1ratediveffxsec = 0.;
449  m_total_l1ratediveffxsecRun = 0.;
450  m_l1ratediveffxsec_recorded = 0.;
451  m_total_l1ratediveffxsec_recorded = 0.;
452  m_total_l1ratediveffxsecRun_recorded = 0.;
453  m_runnbr_prev = 0;
454 
455  // Set to extreme values, to be updated below
456  m_minrun = 99999999;
457  m_maxrun = 0;
458 
459  bool firstL1Missing = true;
460  bool firstHLTMissing = true;
461 
462  std::set<cool::ValidityKey> lbrunset;
463  lbrunset.clear();
464 
465  // collisions xml file settings
466  if (m_collsgrl!=0) { delete m_collsgrl; m_collsgrl=0; }
467  if (m_makecollList) {
468  m_collsgrl = new Root::TGoodRunsList();
469  m_collsgrl->SetVersion("30"); // lumicalc signature
470  m_collsgrl->AddMetaData("Query","Generated by LumiCalculator");
471  }
472 
473  // Figure out trigger level
474  m_triglevel = cq_lumi->getTriggerLevel(triggerchain);
475  if (m_triglevel == 0){
476  // Check if on purpose, otherwise, give a warning
477  if (triggerchain == "None") {
478  m_logger << Root::kINFO << "No trigger specified!" << Root::GEndl;
479  } else {
480  m_logger << Root::kWARNING << "Invalid trigger: [" << triggerchain << "] - will proceed with no trigger defined!" << Root::GEndl;
481  }
482  }
483 
484  // Look for b-jet triggers
485  regex_t regex;
486  int reti = regcomp(&regex, "_[[:digit:]]?b[[:digit:]]+_", REG_EXTENDED);
487  if (reti) m_logger << Root::kWARNING << "Could not compile regex!" << Root::GEndl;
488 
489  reti = regexec(&regex, triggerchain.c_str(), 0, NULL, 0);
490  if ( !reti && !m_usebs) {
491  m_logger << Root::kWARNING << "Trigger: [" << triggerchain << "] appears to be a b-jet trigger, but online beamspot validity not included in livefraction!" << Root::GEndl;
492  m_logger << Root::kWARNING << "Probably need to specify --beamspot to get accurate luminosity!" << Root::GEndl;
493  }
494  regfree(&regex);
495 
496  // get lumi channel id (this never changes)
497  if (m_lumimethod != "") {
498  m_Lumiid = cq_lumi->getLumiChannelId(m_lumimethod, m_parlumiestfolder);
499  } else {
500  m_Lumiid = m_lumichannel;
501  }
502 
503 
504  // do main LumiBlock loop
505  //==============================
506 
507  IOVData<cool::Int32> L1preObj;
508  IOVData<cool::Int32> L1preOther;
509  IOVData<cool::Float> L2preObj;
510  IOVData<cool::Float> L3preObj;
511  IOVData<cool::UInt32> LArObj;
512  IOVData<cool::Int32> BSObj;
513 
514  std::map<cool::ValidityKey, CoolQuery::LumiFolderData> LumiDataMap;
515 
516  // UTC nanoseconds since 1970
517  std::map<cool::ValidityKey, cool::UInt63> L1starttime_map;
518  std::map<cool::ValidityKey, cool::UInt63> L1endtime_map;
519 
520  // Livetime maps
521  std::map<cool::ValidityKey, CoolQuery::L1CountFolderData> Livetime_map;
522  std::map<cool::ValidityKey, CoolQuery::L1CountFolderData> L1accept_map;
523 
524  for(xAOD::LumiBlockRangeContainer::const_iterator it = iovc->begin(); it != iovc->end(); ++it){
525  const auto iovr = std::make_unique<IOVRange>(IOVTime((*it)->startRunNumber(),(*it)->startLumiBlockNumber()),
526  IOVTime((*it)->stopRunNumber(),(*it)->stopLumiBlockNumber()));
527 
528  // Bookkeeping temporary results
529  m_t_totalDelL = 0.;
530  m_t_totalL = 0.;
531  m_t_totalLRun = 0.;
532  m_t_totaltime = 0.;
533  m_t_deltaT = 0.;
534  m_t_l1acc = 0;
535  m_t_l2acc = 0;
536  m_t_l3acc = 0;
537  m_t_totalgoodblock = 0;
538  m_t_totalbadblock = 0;
539  m_t_totall1befpresc = 0;
540  m_t_totalPrescaleWLiveTime = 0.;
541  m_t_totalPrescale = 0.;
542  m_t_lumiWOPrescale = 0. ;
543  m_t_lumiLAr = 0.;
544 
545  m_runnbr = iovr->start().run();
546  m_lbstart = iovr->start().event();
547  m_lbstop = iovr->stop().event();
548 
549  // Look for duplicate run/LB
550  if(m_lbstart_prev == m_lbstart && m_lbstop_prev == m_lbstop && m_runnbr_prev == m_runnbr){
551  m_logger << Root::kWARNING << "Skipping multiply stored IOVRange: [" << m_lbstart << "-" << m_lbstop << "]" << Root::GEndl;
552  continue;
553  }
554 
555  // new run, reset its lumi and reload the trigger channels
556  if ( m_runnbr!=m_runnbr_prev ) {
557 
558  if (m_runnbr < m_minrun) m_minrun = m_runnbr;
559  if (m_runnbr > m_maxrun) m_maxrun = m_runnbr;
560 
561  m_totalLRun=0.;
562  m_total_l1ratediveffxsecRun=0.;
563  m_total_l1ratediveffxsecRun_recorded=0.;
564 
565  // Set IOV range for full run
566  cq_trigger->setIOVForRun (m_runnbr);
567  cq_lumi->setIOVForRun(m_runnbr);
568 
569  // get trigger channel ids
570  m_L1Valid = false;
571  m_L2Valid = false;
572  m_L3Valid = false;
573  m_LiveValid = false;
574  m_triggerlowerchains.clear();
575  // These are used to resolve L1 ORs like [L1_MU20,L1_MU21]
576  m_L1triggerchains.clear();
577  m_L1idList.clear();
578 
579  std::string lowerch = "";
580 
581  // This is really inefficient...
582  if(m_triglevel == 3){
583  m_L3id = cq_trigger->getHLTChannelId(triggerchain, m_parhltmenufolder);
584  m_L3Valid = cq_trigger->channelIdValid();
585 
586  lowerch = cq_trigger->getHLTLowerChainName(triggerchain, m_parhltmenufolder);
587  m_triggerlowerchains.push_back(lowerch);
588  //
589  m_L2id = cq_trigger->getHLTChannelId(lowerch, m_parhltmenufolder);
590  if (m_L2id == UINT_MAX) { //nonsense value for getHLTChannelId
591  throw std::runtime_error("LumiCalculator::IntegrateLumi : getHLTChannelId returned invalid value.");
592  }
593  m_L2Valid = cq_trigger->channelIdValid();
594 
595  lowerch = cq_trigger->getHLTLowerChainName(lowerch, m_parhltmenufolder);
596  m_triggerlowerchains.push_back(lowerch);
597  //
598  m_L1id = cq_trigger->getL1ChannelId(lowerch, m_parlvl1menufolder );
599  m_L1Valid = cq_trigger->channelIdValid();
600 
601  }else if(m_triglevel == 2){ // Run2 or starting at L2 in Run1
602  lowerch = cq_trigger->getHLTLowerChainName(triggerchain, m_parhltmenufolder);
603  m_triggerlowerchains.push_back(lowerch);
604  m_L2id = cq_trigger->getHLTChannelId(triggerchain, m_parhltmenufolder);
605  m_L2Valid = cq_trigger->channelIdValid();
606 
607  ParseL1Trigger(lowerch, cq_trigger);
608 
609  }else if(m_triglevel == 1){
610 
611  ParseL1Trigger(triggerchain, cq_trigger);
612  }
613 
614  if (firstL1Missing && (!m_L1Valid && m_triglevel > 0)) {
615  firstL1Missing = false;
616  cq_trigger->printL1Triggers(m_parlvl1menufolder);
617  }
618 
619  if (firstHLTMissing && ((!m_L2Valid && m_triglevel > 1) || (!m_L3Valid && m_triglevel > 2)) ) {
620  firstHLTMissing = false;
621  cq_trigger->printHLTTriggers(m_parhltmenufolder);
622  }
623 
624  // Should we check here for btag trigger and onl beamspot?
625 
626  // Do we use dedicated livetime trigger?
627  if(m_uselivetrigger){
628  m_LiveL1id = cq_trigger->getL1ChannelId(m_livetrigger, m_parlvl1menufolder);
629  m_LiveValid = cq_trigger->channelIdValid();
630  }else{
631  // then fall back to the original trigger
632  m_LiveL1id = m_L1id;
633  m_LiveValid = m_L1Valid;
634  }
635 
636  if (!m_LiveValid) {
637  if (m_uselivetrigger)
638  m_logger << Root::kWARNING << "Runnumber: [" << m_runnbr << "] can't find livefraction trigger [" << m_livetrigger << "]! Livefraction won't be calculated!" << Root::GEndl;
639  else
640  m_logger << Root::kWARNING << "Runnumber: [" << m_runnbr << "] can't find trigger [" << triggerchain << "]! Livefraction won't be calculated!" << Root::GEndl;
641  }
642 
643  // Also load all deadtime counters here
644 
645  // Need to fix this for non-MC. HLT counters now available, but not used here...
646 
647  //-------------------------
648  // Load livetime information
649  Livetime_map.clear();
650  L1accept_map.clear();
651 
652  if (m_LiveValid)
653  Livetime_map = cq_trigger->getL1CountFolderData(m_parlumilvl1folder, m_LiveL1id);
654 
655 
656  if (m_L1Valid && m_triglevel >= 1)
657  L1accept_map = cq_trigger->getL1CountFolderData(m_parlumilvl1folder, m_L1id);
658 
659  // UTC nanoseconds since 1970
660  L1starttime_map.clear();
661  L1endtime_map.clear();
662  L1starttime_map = cq_trigger->getObjMapFromFolderAtChan<cool::UInt63>("StartTime", m_parlvl1lblbfolder, 0);
663  L1endtime_map = cq_trigger->getObjMapFromFolderAtChan<cool::UInt63>("EndTime", m_parlvl1lblbfolder, 0);
664 
665  //---------------------------
666  // Load LAr defects
667  LArObj.clear();
668 
669  if (m_uselar) {
670  cool::ValidityKey runstarttime = L1starttime_map.begin()->second;
671  cool::ValidityKey runendtime = L1endtime_map.rbegin()->second;
672 
673  cq_lar->setIOV(runstarttime, runendtime);
674  LArObj = cq_lar->getIOVData<cool::UInt32>("EventVeto", m_parlareventvetofolder, 0, m_lartag);
675  }
676 
677  //---------------------------
678  // Load Onl beamspot
679  BSObj.clear();
680 
681  if (m_usebs) {
682  cq_bs->setIOVForRun(m_runnbr);
683  BSObj = cq_bs->getIOVData<cool::Int32>("status", m_paronlbeamspotfolder, 0, m_bstag);
684  }
685 
686 
687  //-----------------------------
688  // Load luminosity for this run
689  LumiDataMap.clear();
690  LumiDataMap = cq_lumi->getLumiFolderData(m_parlumiestfolder, m_lumitag, m_Lumiid);
691 
692 
693  } // End of new run stuff
694 
695  m_lbstart_prev = m_lbstart;
696  m_lbstop_prev = m_lbstop;
697  m_runnbr_prev = m_runnbr;
698 
699  // Update DB for this specific IOV range
700  cq_trigger->setIOV(iovr->start().re_time(), iovr->stop().re_time());
701 
702  // Print this here (will be output for each contiguous LB range in XML file)
703  m_logger << Root::kINFO << std::left << "-----------------------------------" << Root::GEndl;
704  m_logger << Root::kINFO << "Beginning calculation for ";
705  if (m_triglevel > 0) {
706  m_logger << Root::kINFO << "Trigger " << m_triggerchain;
707  if(m_triggerlowerchains.size() > 0){
708  m_logger << Root::kINFO << "[";
709  for(std::vector<std::string>::iterator sit = m_triggerlowerchains.begin(); sit != m_triggerlowerchains.end(); ++sit){
710  m_logger << Root::kINFO << "==>" << *sit;
711  }
712  m_logger << Root::kINFO << "], ";
713  }
714  }
715  m_logger << Root::kINFO << "Run " << m_runnbr << " LB [" << m_lbstart << "-" << m_lbstop << "]" << Root::GEndl;
716  m_logger << Root::kINFO << std::left << "-----------------------------------" << Root::GEndl;
717 
718  //----------------------------
719  // Load prescales for this IOV
720  L1preObj.clear();
721  L2preObj.clear();
722  L3preObj.clear();
723  L1preOther.clear(); // Used for mutliple L1 triggers
724 
725  if(m_L1Valid) {
726  // Normal case
727  if (m_L1idList.size() <= 1) {
728  L1preObj = cq_trigger->getIOVData<cool::Int32>("Lvl1Prescale", m_parlvl1prescalesfolder, m_L1id);
729 
730  // Multiple L1 items defined
731  } else {
732 
733  m_logger << Root::kINFO << "Resolving multiple L1 prescales:" << Root::GEndl;
734 
735  // Load first one
736  L1preObj = cq_trigger->getIOVData<cool::Int32>("Lvl1Prescale", m_parlvl1prescalesfolder, m_L1idList[0]);
737 
738  // Dump prescales
739  std::list< std::pair<IOVRange, cool::Int32> >::iterator it;
740 
741  m_logger << Root::kINFO << std::setw(10) << std::left << m_L1triggerchains[0];
742  for(it = L1preObj.data.begin(); it != L1preObj.data.end(); ++it) {
743  m_logger << Root::kINFO << std::setw(1) << std::left << "[" << it->first.start().event() << "," << it->first.stop().event()-1 << "]:" ;
744 
745  if (it->second < 0)
746  m_logger << it->second << ", ";
747  else
748  m_logger << (0xFFFFFF / float(0x1000000 - it->second)) << ", ";
749  }
750  m_logger << Root::kINFO << Root::GEndl;
751 
752  // Now loop over the remaining and replace
753  for (unsigned int iid=1; iid < m_L1idList.size(); iid++) {
754  L1preOther = cq_trigger->getIOVData<cool::Int32>("Lvl1Prescale", m_parlvl1prescalesfolder, m_L1idList[iid]);
755 
756  // Dump prescales
757  m_logger << Root::kINFO << std::setw(10) << std::left << m_L1triggerchains[iid];
758  for(it = L1preOther.data.begin(); it != L1preOther.data.end(); ++it) {
759  m_logger << Root::kINFO << std::setw(1) << std::left << "[" << it->first.start().event() << "," << it->first.stop().event()-1 << "]:" ;
760 
761  if (it->second < 0)
762  m_logger << it->second << ", ";
763  else
764  m_logger << (0xFFFFFF / float(0x1000000 - it->second)) << ", ";
765  }
766  m_logger << Root::kINFO << Root::GEndl;
767 
768  // Iterate through both lists and keep lowest non-negative prescale
769  std::list< std::pair<IOVRange, cool::Int32> >::iterator it1;
770  std::list< std::pair<IOVRange, cool::Int32> >::iterator it2;
771  for(it1 = L1preObj.data.begin(), it2 = L1preOther.data.begin(); it1 != L1preObj.data.end(); ++it1, ++it2) {
772 
773  // -1 is disabled, otherwise this is the event count to prescale
774  if ((it2->second > 0) && (it1->second > it2->second)) {
775  // Check if they are both prescaled (this is bad)
776  if ((it1->second > 1) && (it2->second > 1)) {
777  m_logger << Root::kWARNING << "L1 Prescales combined with both triggers prescaled for Run " << m_runnbr << "!" << Root::GEndl;
778  }
779  it1->second = it2->second;// See if this works...
780  }
781  }
782  }
783 
784  // OK done, lets check the result
785  // Dump prescales
786  m_logger << Root::kINFO << std::setw(10) << std::left << "L1 Pre:";
787  for(it = L1preObj.data.begin(); it != L1preObj.data.end(); ++it) {
788  m_logger << Root::kINFO << std::setw(1) << std::left << "[" << it->first.start().event() << "," << it->first.stop().event()-1 << "]:" ;
789 
790  if (it->second < 0)
791  m_logger << it->second << ", ";
792  else
793  m_logger << (0xFFFFFF / float(0x1000000 - it->second)) << ", ";
794  }
795  m_logger << Root::kINFO << Root::GEndl;
796 
797  }
798 
799  }
800 
801  if(m_L2Valid) {
802  if (isrun2) {
803  L2preObj = cq_trigger->getIOVData<cool::Float>("Prescale", m_parhltprescalesfolder, 20000 + m_L2id);
804  }
805  else {
806  L2preObj = cq_trigger->getIOVData<cool::Float>("Prescale", m_parhltprescalesfolder, 2*m_L2id);
807  }
808  }
809 
810  if(m_L3Valid) {
811  L3preObj = cq_trigger->getIOVData<cool::Float>("Prescale", m_parhltprescalesfolder, 2*m_L3id+1);
812  }
813 
814  // Reload the time map to get the ATLAS range
815  L1starttime_map.clear();
816  L1endtime_map.clear();
817  L1starttime_map = cq_trigger->getObjMapFromFolderAtChan<cool::UInt63>("StartTime", m_parlvl1lblbfolder, 0);
818  L1endtime_map = cq_trigger->getObjMapFromFolderAtChan<cool::UInt63>("EndTime", m_parlvl1lblbfolder, 0);
819 
820  // Restrict lb range if necessary based on actual ATLAS run/lb values
821  if (L1starttime_map.begin()->first > iovr->start().re_time() || L1starttime_map.rbegin()->first < iovr->stop().re_time()) {
822  m_lbstart = (L1starttime_map.begin()->first & 0xFFFFFFFF);
823  m_lbstop = (L1starttime_map.rbegin()->first & 0xFFFFFFFF);
824  m_logger << Root::kINFO << "Restricting to valid ATLAS lumi block range [" << m_lbstart << "-" << m_lbstop << "]" << Root::GEndl;
825  }
826 
827 
828  //
829  // Dont assume that all lumi blocks in this range are present in the lumi DB.
830  // Loop over all lumi blocks specifically and flag any missing lumi entries as bad lumi blocks.
831  //
832 
833  // Counters to check for missing LB ranges
834  int firstMissing = -1;
835  int lastMissing = -1;
836 
837  for (cool::ValidityKey currentVK = L1starttime_map.begin()->first; currentVK <= L1starttime_map.rbegin()->first; currentVK++) {
838 
839  // Current IOVTime
840  IOVTime curIOV;
841  curIOV.setRETime(currentVK);
842 
843  m_clumiblocknbr = curIOV.event();
844  m_clumiblocknbrend = curIOV.event()+1;
845 
846  // Check here for duplicate lumi blocks by explicitly keeping track of every run/lb seen
847  if (lbrunset.count(curIOV.re_time()) != 0) {
848  m_logger << Root::kWARNING << "Skipping duplicate [run,lumiblock]: " << curIOV << " !" << Root::GEndl;
849  continue;
850  } else {
851  lbrunset.insert(curIOV.re_time());
852  }
853 
854  // Not really good, just all seen
855  m_totalgoodblock += 1;
856  m_t_totalgoodblock += 1;
857 
858  // Find luminosity record
859  std::map<cool::ValidityKey, CoolQuery::LumiFolderData>::iterator itOL = LumiDataMap.find(currentVK);
860 
861  // Check if we didn't find anything
862  if (itOL == LumiDataMap.end()) {
863 
864  m_t_totalbadblock++;
865  m_totalbadblock++;
866 
867  if (firstMissing < 0) {
868  // Is this the first missing one? If so, make a note of it and go on
869  firstMissing = curIOV.event();
870  lastMissing = firstMissing;
871  } else if (int(curIOV.event()) == (lastMissing+1)) {
872  // Is this a contiguous missing lumi block?
873  lastMissing = curIOV.event();
874  } else {
875  // Not contiguous, print previous
876  if (firstMissing == lastMissing) {
877  m_logger << Root::kWARNING << "Luminosity info not found for Run " << m_runnbr << " LB " << firstMissing << " !" << Root::GEndl;
878  } else {
879  m_logger << Root::kWARNING << "Luminosity info not found for Run " << m_runnbr << " LB [" << firstMissing << "-" << lastMissing << "] !" << Root::GEndl;
880  }
881  firstMissing = curIOV.event();
882  lastMissing = firstMissing;
883  }
884 
885  // If last time through loop, print this also
886  if (currentVK == L1starttime_map.rbegin()->first) {
887  if (firstMissing == lastMissing) {
888  m_logger << Root::kWARNING << "Luminosity info not found for Run " << m_runnbr << " LB " << firstMissing << " !" << Root::GEndl;
889  } else {
890  m_logger << Root::kWARNING << "Luminosity info not found for Run " << m_runnbr << " LB [" << firstMissing << "-" << lastMissing << "] !" << Root::GEndl;
891  }
892  firstMissing = -1;
893  lastMissing = -1;
894  }
895 
896  // Skip rest of this LB
897  continue;
898 
899  } else {
900 
901  // Check if we had previous missing block
902  if (firstMissing >= 0) {
903  if (firstMissing == lastMissing) {
904  m_logger << Root::kWARNING << "Luminosity info not found for Run " << m_runnbr << " LB " << firstMissing << " !" << Root::GEndl;
905  } else {
906  m_logger << Root::kWARNING << "Luminosity info not found for Run " << m_runnbr << " LB [" << firstMissing << "-" << lastMissing << "] !" << Root::GEndl;
907  }
908 
909  firstMissing = -1;
910  lastMissing = -1;
911  }
912 
913  }
914 
915 
916  // given in units of ub^{-1} = 10^{30} cm^{-2}
917  m_instLumi = (itOL->second).LBAvInstLumi;
918  m_AvEvtsPerBX = (itOL->second).LBAvEvtsPerBX;
919  m_Valid = (itOL->second).Valid;
920 
921 
922  // Clear values in case trigger isn't defined
923  m_l1acc = 0.;
924  m_beforeprescale = 0.;
925  m_afterprescale = 0.;
926  m_l2acc = 0.;
927  m_l3acc = 0.;
928 
929  // Store dummy prescale values at start
930  m_l1prescale = -1.;
931  m_l2prescale = -1.;
932  m_l3prescale = -1.;
933 
934  // Some trigger is defined. Get prescales and values here
935  if(m_L1Valid && m_triglevel > 0) {
936 
937  // Get L1 prescale
938  if (isrun2) {
939  if (L1preObj.getValue(curIOV) < 0)
940  m_l1prescale = L1preObj.getValue(curIOV);
941  else
942  m_l1prescale = 0xFFFFFF / float(0x1000000 - L1preObj.getValue(curIOV));
943  }
944  else {
945  m_l1prescale = L1preObj.getValue(curIOV);
946  }
947 
948  if (m_triglevel >=2) {
949  if(m_L2Valid) {
950 
951  // Get L2 prescale
952  m_l2prescale = L2preObj.getValue(curIOV);
953 
954  }
955  // Else, prescale stays at -1.
956 
957  } else {
958  // Force L2 'passthrough'
959  m_l2prescale = 1.;
960  }
961 
962  if(m_triglevel == 3){
963  if (m_L3Valid) {
964 
965  // Get L3 prescale
966  m_l3prescale = L3preObj.getValue(curIOV);
967 
968  }
969  // Else, L3 prescale stays at -1.
970  } else {
971  // Force L3 'passthrough'
972  m_l3prescale = 1.;
973  }
974  }
975 
976  //-------------------------------
977  // Calculate livetime from a dedicated not rare trigger if user requested
978  CoolQuery::L1CountFolderData l1count = Livetime_map.find(currentVK)->second;
979 
980  m_livetime_beforeprescale = l1count.BeforePrescale;
981  m_livetime_afterprescale = l1count.AfterPrescale;
982  m_livetime_l1acc = l1count.L1Accept;
983  if(m_livetime_afterprescale > 0.){
984  m_livefrac = m_livetime_l1acc/(float)m_livetime_afterprescale;
985  }else{
986  m_livefrac = 0.0;
987  }
988 
989  // Hack for bad SFO in particular run
990  if (m_runnbr == 286367) {
991  m_livefrac *= 5./6.;
992  }
993 
994  if (m_runnbr == 281385) {
995  if (m_clumiblocknbr <= 196) {
996  m_livefrac *= 4./6.;
997  } else if (m_clumiblocknbr <= 374) {
998  m_livefrac *= 5./6.;
999  }
1000  }
1001 
1002  // Check for low statistics in afterprescale counts
1003  if(m_livetime_beforeprescale > 0 && m_livetime_afterprescale <= 0 ){
1004  std::string ttrig = "";
1005  ttrig = triggerchain;
1006  if(m_uselivetrigger)ttrig = m_livetrigger;
1007  m_logger << Root::kWARNING << "L1 counts after prescale (before veto) are 0.0 for trigger " << std::move(ttrig) << "! Livefraction set to zero!" << Root::GEndl;
1008  m_logger << Root::kWARNING << "Try using a high rate L1 trigger for livetime calculation: --livetrigger=<high rate L1 trigger> " << Root::GEndl;
1009  m_logger << Root::kINFO << m_runnbr << "[" << m_clumiblocknbr << "]: L1Acc: " << m_l1acc << ", AfterPrescale: " << m_afterprescale << ", L1Presc: " << m_l1prescale << Root::GEndl;
1010  }
1011 
1012  //------------------------
1013  // Calculate LAr veto time
1014  auto itStartTime = L1starttime_map.find(currentVK);
1015  auto itEndTime = L1endtime_map.find(currentVK);
1016  if (itStartTime == L1starttime_map.end() or itEndTime == L1endtime_map.end()){
1017  throw std::runtime_error("LumiCalculator::IntegrateLumi Start or End times not found in map.");
1018  }
1019  cool::ValidityKey lbstarttime = L1starttime_map.find(currentVK)->second;
1020  cool::ValidityKey lbendtime = L1endtime_map.find(currentVK)->second;
1021 
1022  m_lartime = 0.; // Time to exclude in seconds
1023  if (m_uselar) {
1024 
1025  IOVTime lbstart, lbend;
1026  lbstart.setRETime(lbstarttime);
1027  lbend.setRETime(lbendtime);
1028  IOVRange range(lbstart, lbend);
1029 
1030  std::list<std::pair<IOVRange, cool::UInt32> > larlist;
1031  larlist = LArObj.getOverlap(range);
1032 
1033  for (std::list<std::pair<IOVRange, cool::UInt32> >::iterator it = larlist.begin(); it != larlist.end(); ++it) {
1034  if (it->second == 0) continue;
1035  float dtime = (it->first.stop().re_time() - it->first.start().re_time())/1.E9;
1036  m_lartime += dtime;
1037  if (m_verbose == true) {
1038  m_logger << Root::kINFO << "Found LAr veto from " << it->first.start().re_time() << " to " << it->first.stop().re_time() << " = " << dtime << " seconds" << Root::GEndl;
1039  }
1040  }
1041  }
1042 
1043  //------------------------
1044  // Check for online BS
1045  m_bsvalid = 1.;
1046  if (m_usebs) {
1047 
1048  // Read beamspot validity
1049  bool valid = true;
1050  int status = BSObj.getValue(curIOV);
1051  //m_logger << Root::kINFO << "Found online beamspot status = " << status << Root::GEndl;
1052 
1053  if (status != 7) valid = false;
1054 
1055  if (!valid) {
1056  m_bsvalid = 0.0;
1057  m_livefrac = 0.0;
1058  if(m_verbose == true){
1059  m_logger << Root::kINFO << m_runnbr << "[" << m_clumiblocknbr << "]: Online beamspot invalid with Lumi=" << m_instLumi << " 10^30 cm-2 s-1" << Root::GEndl;
1060  }
1061  }
1062  }
1063 
1064  //-------------------------------
1065 
1066  l1count = L1accept_map.find(currentVK)->second;
1067  m_beforeprescale = l1count.BeforePrescale;
1068  m_beforeprescaleof = false;
1069  m_afterprescale = l1count.AfterPrescale;
1070  m_afterprescaleof = false;
1071  m_l1acc = l1count.L1Accept;
1072  m_l1accof = false;
1073 
1074  m_deltaT = (lbendtime-lbstarttime)/1.E9;
1075  m_lbstarttime = lbstarttime/1.E9;
1076  m_lbendtime = lbendtime/1.E9;
1077 
1078  if (m_deltaT > 0.) m_larfrac = 1.-m_lartime/m_deltaT;
1079 
1080  // For online lumi database case one needs to make some changes:
1081  if(m_onlinelumi == true){
1082  // In Valid UInt32 type value some information is encoded:
1083  // see: https://twiki.cern.ch/twiki/bin/view/Atlas/CoolOnlineData#Folder_TRIGGER_LUMI_LBLESTONL
1084  cool::UInt32 tempValid = (m_Valid & 1023);
1085 
1086  if(tempValid == 10){
1087  // in this bits, Value 301 and 302 means MBTS and LUCID lumi for which some care is needed
1088  if((m_Valid >> 22) == 301
1089  || (m_Valid >> 22) == 302
1090  || (m_Valid >> 22) == 101
1091  || (m_Valid >> 22) == 102
1092  || (m_Valid >> 22) == 103
1093  || (m_Valid >> 22) == 104
1094  ){
1095  m_Valid = 0;
1096  }else{
1097  m_Valid = tempValid;
1098  }
1099  }else{
1100  m_Valid = tempValid;
1101  }
1102 
1103  } else {
1104 
1105  // For offline, we also need to strip out the preferred channel value from the validity word
1106  m_Valid &= 0xFFFF;
1107  }
1108 
1109  // Dump out debugging information
1110  if(m_verbose == true){
1111  m_logger << Root::kINFO << m_runnbr << "[" << m_clumiblocknbr << "]: L1Acc: " << m_l1acc;
1112  if(m_uselivetrigger) m_logger << ", Livetime trigger L1Acc: " << m_livetime_l1acc;
1113  m_logger << ", InstLumi: " << m_instLumi << ", deltaT: " << m_deltaT << ", AvEvtsPerBX: " << m_AvEvtsPerBX << ", BeforePrescale: " << m_beforeprescale << ", AfterPrescale: " << m_afterprescale;
1114  if (m_uselivetrigger) m_logger << ", Livetime trigger BeforePrescale: " << m_livetime_beforeprescale << " Livetime trigger AfterPrescale: " << m_livetime_afterprescale;
1115  if (isrun2) {
1116  m_logger << ", Livefrac: " << m_livefrac << ", L1Presc: " << m_l1prescale << ", HLTPresc: " << m_l2prescale << ", Valid: " << m_Valid;
1117  } else {
1118  m_logger << ", Livefrac: " << m_livefrac << ", L1Presc: " << m_l1prescale << ", L2Presc: " << m_l2prescale << ", L3Presc: " << m_l3prescale << ", Valid: " << m_Valid;
1119  }
1120  if (m_uselar) m_logger << ", LAr ready fraction: " << m_larfrac;
1121  m_logger << Root::GEndl;
1122  }
1123 
1124  // Check if we have valid luminosity
1125  // Just need to check lowest digit. 10 -> BCID blind, 100 -> mu not valid
1126  if(m_Valid%10 != 0){
1127 
1128  // Invalid luminosity entry, call it bad
1129  m_instLumi = 0.0;
1130  m_totalbadblock += 1;
1131  m_t_totalbadblock += 1;
1132  m_logger << Root::kWARNING << "Skipping lumiblock " << m_runnbr << "[" << m_clumiblocknbr << "] with invalid inst. lumi. (valid=" << m_Valid << ")!" << Root::GEndl;
1133 
1134  } else if ((m_triglevel > 0) && (m_l1prescale < 0. || m_l2prescale < 0. || m_l3prescale < 0.)) {
1135 
1136  // Disabled trigger, call bad but still record delivered luminosity
1137  m_totalbadblock += 1;
1138  m_t_totalbadblock += 1;
1139  m_logger << Root::kWARNING << "Lumiblock " << m_runnbr << "[" << m_clumiblocknbr << "] has a disabled or incorrectly specified trigger.! " << Root::GEndl;
1140 
1141  }
1142 
1143  //========================================================//
1144  // L U M I N O S I T Y C A L C U L A T I O N H E R E //
1145  //========================================================//
1146  // The actual calculation of integrated luminosity and
1147  // accumulation of some variables
1148  m_totalDelL += (m_deltaT*m_instLumi); // delivered lumi
1149  m_t_totalDelL += (m_deltaT*m_instLumi); // delivered lumi
1150  m_t_deltaT += m_deltaT;
1151 
1152  // Count up everything
1153  m_totall1acc += m_l1acc;
1154  m_livtrig_totall1acc += m_livetime_l1acc;
1155  m_t_l1acc += m_l1acc;
1156  m_totall1befpresc += m_beforeprescale;
1157  m_t_totall1befpresc += m_beforeprescale;
1158  m_totall2acc += m_l2acc;
1159  m_t_l2acc += m_l2acc;
1160  m_totall3acc += m_l3acc;
1161  m_t_l3acc += m_l3acc;
1162  m_livetime = m_livefrac*m_deltaT;
1163  m_totaltime += m_livetime;
1164  m_t_totaltime += m_livetime;
1165 
1166  double totalPrescale = m_l1prescale * m_l2prescale * m_l3prescale;
1167 
1168  // Check for disabled triggers
1169  if (m_l1prescale < 0. ) totalPrescale = 0.;
1170  if (m_l2prescale < 0. ) totalPrescale = 0.;
1171  if (m_l3prescale < 0. ) totalPrescale = 0.;
1172 
1173  // Check also for no trigger
1174  if (m_triglevel == 0) totalPrescale = 1.;
1175 
1176  m_intLumi = 0.;
1177 
1178  m_lumiWOPrescale += m_livetime*m_instLumi ;
1179  m_t_lumiWOPrescale += m_livetime*m_instLumi ;
1180 
1181  m_lumiLAr += m_livetime*m_larfrac*m_instLumi;
1182  m_t_lumiLAr += m_livetime*m_larfrac*m_instLumi;
1183 
1184  if (totalPrescale > 0.) {
1185  m_totalPrescaleWLiveTime += m_livetime/totalPrescale;
1186  m_t_totalPrescaleWLiveTime += m_livetime/totalPrescale;
1187  m_totalPrescale += 1./totalPrescale;
1188  m_t_totalPrescale += 1./totalPrescale;
1189  m_intLumi = m_larfrac * m_livetime * m_instLumi/totalPrescale; // <<<--- T H E F O R M U L A
1190  }
1191 
1192 
1193  m_totalL += m_intLumi;
1194  m_t_totalL += m_intLumi;
1195  m_totalLRun += m_intLumi;
1196 
1197 
1198  // MB: trigger rates, note that livefrac drops out of ratio
1199  m_l1rate = ( m_livetime>0 ? m_l1acc / m_livetime : 0. );
1200  m_l2rate = ( m_livetime>0 ? m_l2acc / m_livetime : 0. );
1201  m_l3rate = ( m_livetime>0 ? m_l3acc / m_livetime : 0. );
1202 
1203  // MB: delivered lumi
1204  m_l1ratediveffxsec = (float)m_afterprescale/( m_deltaT*m_effxsec );
1205  m_total_l1ratediveffxsec += (float)m_afterprescale / m_effxsec ;
1206  m_total_l1ratediveffxsecRun += (float)m_afterprescale / m_effxsec ;
1207 
1208  // MB: recorded lumi
1209  m_l1ratediveffxsec_recorded = (float)m_l1acc /( m_deltaT*m_effxsec );
1210  m_total_l1ratediveffxsec_recorded += (float)m_l1acc / m_effxsec ;
1211  m_total_l1ratediveffxsecRun_recorded += (float)m_l1acc / m_effxsec ;
1212 
1213  if (m_collsgrl!=0) {
1214  if ( m_l1rate>=m_mintrigrate )
1215  m_collsgrl->AddRunLumiBlock(m_runnbr,m_clumiblocknbr);
1216  }
1217 
1218  if (m_verbose) {
1219  if (m_effxsec!=1.0)
1220  m_logger << Root::kINFO << "L1rate a/ prescale: " << m_afterprescale << ", Delivered LumiFromL1rate (/ub): " << m_l1ratediveffxsec << ", Delivered TotalLumiFromL1rate (/ub): " << m_total_l1ratediveffxsec
1221  << Root::GEndl;
1222  }
1223 
1224  if(m_LumiTree != 0)m_LumiTree->Fill();
1225  } // End of loop over lumi blocks
1226 
1227  // Print IOV summary
1228  m_logger << Root::kINFO<< std::setw(10) << std::left << ">== Trigger : " << triggerchain << Root::GEndl;
1229  m_logger << Root::kINFO<< std::setw(10) << std::right << "Run" << std::setw(10) << std::right << "L1-Acc" << std::setw(10) << std::right << "L2-Acc" << std::setw(10) << std::right << "L3-Acc" << std::setw(10) << std::right << "LiveTime" << std::setw(18) << std::right << "IntL rec.(ub^-1)" << std::setw(18) << std::right << "IntL del.(ub^-1)" << Root::GEndl;
1230  m_logger << Root::kINFO<< std::setw(10) << std::right << m_runnbr << std::setw(10) << std::right << m_t_l1acc << std::setw(10) << std::right << m_t_l2acc << std::setw(10) << std::right << m_t_l3acc << std::setw(10) << std::right << m_t_totaltime << std::setw(18) << std::right << m_t_totalL << std::setw(18) << std::right << m_t_totalDelL << Root::GEndl;
1231  // m_logger << Root::kINFO << std::setw(10) << std::right << "BeforePrescale" << std::setw(10) << std::right << m_totall1befpresc << std::setw(10) << std::right << "" << std::setw(10) << std::right << "" << std::setw(10) << std::right << "" << std::setw(10) << std::right << "" << std::setw(10) << std::right << "" << std::setw(10) << m_TotaldeltaT << std::setw(14) << std::right << m_totalL << Root::GEndl;
1232 
1233  m_logger << Root::kINFO<< std::setw(10) << std::left << "L1/2/3 accept: " << std::setw(10) << std::left << m_t_l1acc << std::setw(10) << std::left << m_t_l2acc << std::setw(10) << std::left << m_t_l3acc << Root::GEndl;
1234  m_logger << Root::kINFO << std::setw(10) << std::left << "L1BeforePresc: " << std::setw(10) << std::left << m_t_totall1befpresc << Root::GEndl;
1235  m_logger << Root::kINFO << std::setw(10) << std::left << "Livetime : " << m_t_totaltime << Root::GEndl;
1236  m_logger << Root::kINFO << std::setw(10) << std::left << "Prescale Weighted Livetime: " << m_t_totalPrescaleWLiveTime << Root::GEndl;
1237  m_logger << Root::kINFO<< std::setw(10) << std::left << "Good LBs : " << m_t_totalgoodblock - m_t_totalbadblock << Root::GEndl;
1238  m_logger << Root::kINFO<< std::setw(10) << std::left << "Bad LBs : " << m_t_totalbadblock << Root::GEndl;
1239 
1240  if ( m_effxsec==1.0 ) {
1241  m_logger << Root::kINFO << std::setw(10) << std::left << "IntL delivered (ub^-1) : " << m_t_totalDelL << Root::GEndl;
1242  m_logger << Root::kINFO << std::setw(10) << std::left << "IntL after livefraction (ub^-1): " << m_t_lumiWOPrescale << Root::GEndl;
1243  if (m_uselar)
1244  m_logger << Root::kINFO << std::setw(10) << std::left << "IntL after LAr fraction (ub^-1): " << m_t_lumiLAr << Root::GEndl;
1245  m_logger << Root::kINFO << std::setw(10) << std::left << "IntL recorded after prescale (ub^-1) : " << m_t_totalL << Root::GEndl;
1246  } else {
1247  m_logger << Root::kINFO << std::setw(10) << std::left << "IntL delived (ub^-1) : " << m_total_l1ratediveffxsec << Root::GEndl;
1248  m_logger << Root::kINFO << std::setw(10) << std::left << "IntL recorded (ub^-1) : " << m_total_l1ratediveffxsec_recorded << Root::GEndl;
1249  }
1250 
1251  // Print prescales as range of actual lumi blocks these apply to
1252  if(m_triglevel >= 1){
1253  // Print L1 Prescale values:
1254  m_logger << Root::kINFO << std::setw(10) << std::left << "L1 Prescales: ";
1255 
1256  std::list< std::pair<IOVRange, cool::Int32> >::iterator it;
1257  for(it = L1preObj.data.begin(); it != L1preObj.data.end(); ++it) {
1258  m_logger << Root::kINFO << std::setw(1) << std::left << "[" << it->first.start().event() << "," << it->first.stop().event()-1 << "]:" ;
1259  if (isrun2) {
1260  if (it->second < 0)
1261  m_logger << it->second << ", ";
1262  else
1263  m_logger << (0xFFFFFF / float(0x1000000 - it->second)) << ", ";
1264  } else {
1265  m_logger << it->second << ", ";
1266  }
1267  }
1268  m_logger << Root::kINFO << Root::GEndl;
1269  }
1270 
1271  if(m_triglevel >= 2){
1272  // Print L2 Prescale values:
1273  if (isrun2) {
1274  m_logger << Root::kINFO << std::setw(10) << std::left << "HLT Prescales: ";
1275  }
1276  else {
1277  m_logger << Root::kINFO << std::setw(10) << std::left << "L2 Prescales: ";
1278  }
1279 
1280  std::list< std::pair<IOVRange, cool::Float> >::iterator it;
1281  for(it = L2preObj.data.begin(); it != L2preObj.data.end(); ++it) {
1282  m_logger << Root::kINFO << std::setw(1) << std::left << "[" << it->first.start().event() << "," << it->first.stop().event()-1 << "]:" << it->second << ", ";
1283  }
1284  m_logger << Root::kINFO << Root::GEndl;
1285  }
1286 
1287  if(m_triglevel == 3){
1288  // Print L3 Prescale values:
1289  m_logger << Root::kINFO << std::setw(10) << std::left << "L3 Prescales: ";
1290 
1291  std::list< std::pair<IOVRange, cool::Float> >::iterator it;
1292  for(it = L3preObj.data.begin(); it != L3preObj.data.end(); ++it) {
1293  m_logger << Root::kINFO << std::setw(1) << std::left << "[" << it->first.start().event() << "," << it->first.stop().event()-1 << "]:" << it->second << ", ";
1294  }
1295  m_logger << Root::kINFO << Root::GEndl;
1296  }
1297 
1298  } // end lb collection loop
1299 
1300 
1301  // ------------------------------------------------------------------------------------------------
1302  // MB : Print total only at end of LB loop:
1303  m_logger << Root::kINFO << std::left << "-----------------------------------" << Root::GEndl;
1304  m_logger << Root::kINFO << std::left << " LumiCalculator summary" << Root::GEndl;
1305  m_logger << Root::kINFO << std::left << "-----------------------------------" << Root::GEndl;
1306  m_logger << Root::kINFO<< std::setw(10) << std::right << "Total" << std::setw(10) << std::right << "L1-Acc" << std::setw(10) << std::right << "L2-Acc" << std::setw(10) << std::right << "L3-Acc" <<
1307  std::setw(10) << std::right << "LiveTime" << std::setw(18) << std::right << "IntL rec.(ub^-1)" << std::setw(18) << std::right << "IntL del.(ub^-1)" << Root::GEndl;
1308  m_logger << Root::kINFO<< std::setw(10) << std::right << "" << std::setw(10) << std::right << m_totall1acc << std::setw(10) << std::right << m_totall2acc << std::setw(10) << std::right
1309  << m_totall3acc << std::setw(10) << std::right << m_totaltime << std::setw(18) << std::right << m_totalL << std::setw(18) << std::right << m_totalDelL << Root::GEndl;
1310  m_logger << Root::kINFO<< std::setw(10) << std::left << "Total L1/2/3 accept: " << std::setw(10) << std::left << m_totall1acc << std::setw(10) << std::left << m_totall2acc << std::setw(10)
1311  << std::left << m_totall3acc << Root::GEndl;
1312  if(m_uselivetrigger)m_logger << Root::kINFO<< std::setw(10) << std::left << "Total L1 livetime trigger accept: " << std::setw(10) << std::left << m_livtrig_totall1acc << Root::GEndl;
1313 
1314  m_logger << Root::kINFO << std::setw(10) << std::left << "First Run: " << std::setw(10) << std::left << m_minrun << Root::GEndl;
1315  m_logger << Root::kINFO << std::setw(10) << std::left << "Last Run: " << std::setw(10) << std::left << m_maxrun << Root::GEndl;
1316  m_logger << Root::kINFO << std::setw(10) << std::left << "Total L1BeforePresc: " << std::setw(10) << std::left << m_totall1befpresc << Root::GEndl;
1317  m_logger << Root::kINFO<< std::setw(10) << std::left << "Total Livetime : " << m_totaltime << Root::GEndl;
1318  m_logger << Root::kINFO << std::setw(10) << std::left << "Total prescale weighted Livetime: " << m_totalPrescaleWLiveTime << Root::GEndl;
1319  m_logger << Root::kINFO<< std::setw(10) << std::left << "Total Good LBs : " << m_totalgoodblock - m_totalbadblock << Root::GEndl;
1320  m_logger << Root::kINFO<< std::setw(10) << std::left << "Total Bad LBs : " << m_totalbadblock << Root::GEndl;
1321  m_logger << Root::kINFO << std::setw(10) << std::left << "Total IntL delivered (ub^-1) : " << m_totalDelL << Root::GEndl;
1322  m_logger << Root::kINFO << std::setw(10) << std::left << "Total IntL after livefraction (ub^-1): " << m_lumiWOPrescale << Root::GEndl;
1323  if (m_uselar)
1324  m_logger << Root::kINFO << std::setw(10) << std::left << "Total IntL after LAr fraction (ub^-1): " << m_lumiLAr << Root::GEndl;
1325  m_logger << Root::kINFO << std::setw(10) << std::left << "Total IntL recorded (ub^-1) : " << m_totalL << Root::GEndl;
1326 
1327  // ------------------------------------------------------------------------------------------------
1328 
1329  if(m_makecollList == true){
1330  // store collisions xml file on demand
1331  if (m_collsgrl!=0) {
1332  TString collisionsxml = "collisions_" + m_collsgrl->GetSuggestedName() + ".xml";
1333  Root::TGoodRunsListWriter writer;
1334  writer.SetGoodRunsList( *m_collsgrl );
1335  writer.SetFilename( collisionsxml.Data() );
1336  writer.WriteXMLFile();
1337  // can now delete grl
1338  delete m_collsgrl; m_collsgrl=0;
1339  }
1340  }
1341 
1342 
1343  // Creating monitoring plots on demand
1344  if(m_makePlots == true) { this->MakePlots(triggerchain); }
1345 
1346  delete cq_trigger;
1347  delete cq_lumi;
1348  delete cq_lar;
1349  delete cq_bs;
1350 }
1351 
1352 // Deal with composite L1 trigger
1353 void
1354 LumiCalculator::ParseL1Trigger(const std::string& lowerch, CoolQuery * cq_trigger) {
1355 
1356  //
1357  // Check if we have multiple entries
1358  size_t last = 0;
1359  size_t next = 0;
1360  cool::ChannelId id;
1361  bool valid;
1362 
1363  m_L1id = 0;
1364  m_L1Valid = false;
1365 
1366  if (lowerch.find(',', last) == std::string::npos) {
1367  // Normal case
1368  m_L1id = cq_trigger->getL1ChannelId(lowerch, m_parlvl1menufolder);
1369  m_L1Valid = cq_trigger->channelIdValid();
1370 
1371  } else {
1372  m_logger << Root::kINFO << "L1 item is composite: " << lowerch << Root::GEndl;
1373  do {
1374  next = lowerch.find(',', last);
1375  // Check if these are valid before using them
1376  id = cq_trigger->getL1ChannelId(lowerch.substr(last, next-last), m_parlvl1menufolder);
1377  valid = cq_trigger->channelIdValid();
1378  if (valid) {
1379  m_L1triggerchains.push_back(lowerch.substr(last, next-last));
1380  m_L1idList.push_back(m_L1id);
1381  m_L1id = id;
1382  m_L1Valid = true;
1383  } else {
1384  m_logger << Root::kINFO << lowerch.substr(last, next-last) << " Invalid" << Root::GEndl;
1385  }
1386 
1387  last = next + 1;
1388  } while (next != std::string::npos);
1389 
1390 
1391  }
1392 }
1393 
1394 // ---------------------------------------------------------------------------------
1395 // Utility to print lumicalc summary results
1396 void
1397 LumiCalculator::printSummary(std::ostream& os) {
1398 
1399  os << std::left << "-----------------------------------" << std::endl;
1400  os << std::left << " LumiCalculator summary" << std::endl;
1401  os << std::left << "-----------------------------------" << std::endl;
1402  os << std::setw(10) << std::left << "Trigger: " << std::setw(10) << std::left << m_triggerchain << std::endl;
1403  os << std::setw(10) << std::left << "First Run: " << std::setw(10) << std::left << m_minrun << std::endl;
1404  os << std::setw(10) << std::left << "Last Run: " << std::setw(10) << std::left << m_maxrun << std::endl;
1405  os << std::setw(10) << std::left << "Total L1BeforePresc: " << std::setw(10) << std::left << m_totall1befpresc << std::endl;
1406  os << std::setw(10) << std::left << "Total Livetime : " << m_totaltime << std::endl;
1407  os << std::setw(10) << std::left << "Total prescale weighted Livetime: " << m_totalPrescaleWLiveTime << std::endl;
1408  os << std::setw(10) << std::left << "Total Good LBs : " << m_totalgoodblock - m_totalbadblock << std::endl;
1409  os << std::setw(10) << std::left << "Total Bad LBs : " << m_totalbadblock << std::endl;
1410  os << std::setw(10) << std::left << "Total IntL delivered (ub^-1) : " << m_totalDelL << std::endl;
1411  os << std::setw(10) << std::left << "Total IntL after livefraction (ub^-1): " << m_lumiWOPrescale << std::endl;
1412  if (m_uselar)
1413  os << std::setw(10) << std::left << "Total IntL after LAr fraction (ub^-1): " << m_lumiLAr << std::endl;
1414  os << std::setw(10) << std::left << "Total IntL recorded (ub^-1) : " << m_totalL << std::endl;
1415 
1416 }
1417 
1418 void
1419 LumiCalculator::DoHistogramAdmin(const uint32_t& runnbr, const TString& trigName, const float& effxsec)
1420 {
1421  // rebin the histograms once number of LBs is known
1422  int maxlb = 5000;
1423 
1424  m_ntrigplbVec.push_back( new TH1F(Form("run%d_ntrigplb",runnbr), Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
1425  m_trigrateplbVec.push_back( new TH1F(Form("run%d_trigrateplb",runnbr), Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
1426  m_lumiplbVec.push_back( new TH1F(Form("run%d_peaklumiplb",runnbr), Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
1427  m_lumitrigrateplbVec.push_back( new TH1F(Form("run%d_peaklumitrigrateplb",runnbr), Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
1428  m_intlumiVec.push_back( new TH1F(Form("run%d_intlumi",runnbr), Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
1429  m_intlumitrigrateVec.push_back( new TH1F(Form("run%d_intlumitrigrate",runnbr), Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
1430  m_lumitrigrateplb_recordedVec.push_back( new TH1F(Form("run%d_peakrecordedlumitrigrateplb",runnbr), Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
1431  m_intlumitrigrate_recordedVec.push_back( new TH1F(Form("run%d_intrecordedlumitrigrate",runnbr), Form("Run %d",runnbr) , maxlb, 0., float(maxlb)) );
1432 
1433  m_ntrigplb = *(m_ntrigplbVec.rbegin());
1434  m_trigrateplb = *(m_trigrateplbVec.rbegin());
1435  m_lumiplb = *(m_lumiplbVec.rbegin());
1436  m_lumitrigrateplb = *(m_lumitrigrateplbVec.rbegin());
1437  m_intlumi = *(m_intlumiVec.rbegin());
1438  m_intlumitrigrate = *(m_intlumitrigrateVec.rbegin());
1439  m_lumitrigrateplb_recorded = *(m_lumitrigrateplb_recordedVec.rbegin());
1440  m_intlumitrigrate_recorded = *(m_intlumitrigrate_recordedVec.rbegin());
1441 
1442  this->SetHistogramStyle(m_ntrigplb, Form("Run = %d",runnbr), "Luminosity block number", Form("# %s triggers / LB",trigName.Data()));
1443  this->SetHistogramStyle(m_trigrateplb, Form("Run = %d",runnbr), "Luminosity block number", Form("%s trigger rate / LB",trigName.Data()));
1444  this->SetHistogramStyle(m_lumiplb, Form("Run = %d",runnbr), "Luminosity block number", "Delivered luminosity (#mub^{-1}/s)");
1445  this->SetHistogramStyle(m_lumitrigrateplb, Form("Efficiency * x-sec = %.1f #mub, Run = %d",effxsec,runnbr), "Luminosity block number", Form("%s luminosity (#mub^{-1}/s)",trigName.Data()));
1446  this->SetHistogramStyle(m_intlumi, Form("Run = %d",runnbr), "Luminosity block number", "Integrated delivered luminosity (#mub^{-1})");
1447  this->SetHistogramStyle(m_intlumitrigrate, Form("Efficiency * x-sec = %.1f #mub, Run = %d",effxsec,runnbr), "Luminosity block number", Form("%s Integrated luminosity (#mub^{-1})",trigName.Data()));
1448  this->SetHistogramStyle(m_lumitrigrateplb_recorded, Form("Efficiency * x-sec = %.1f #mub, Run = %d",effxsec,runnbr), "Luminosity block number", Form("%s Recorded luminosity (#mub^{-1}/s)",trigName.Data()));
1449  this->SetHistogramStyle(m_intlumitrigrate_recorded, Form("Efficiency * x-sec = %.1f #mub, Run = %d",effxsec,runnbr), "Luminosity block number", Form("%s Integrated recorded luminosity (#mub^{-1})",trigName.Data()));
1450 }
1451 
1452 
1453 void
1454 LumiCalculator::RebinHistograms(const int& nbins, const double& start, const double& end)
1455 {
1456  m_ntrigplb->SetBins(nbins,start,end);
1457  m_trigrateplb->SetBins(nbins,start,end);
1458  m_lumiplb->SetBins(nbins,start,end);
1459  m_lumitrigrateplb->SetBins(nbins,start,end);
1460  m_intlumi->SetBins(nbins,start,end);
1461  m_intlumitrigrate->SetBins(nbins,start,end);
1462  m_lumitrigrateplb_recorded->SetBins(nbins,start,end);
1463  m_intlumitrigrate_recorded->SetBins(nbins,start,end);
1464 }
1465 
1466 
1467 void
1468 LumiCalculator::SetHistogramStyle(TH1F* hist, const char* title, const char* xaxis, const char* yaxis)
1469 {
1470  hist->SetFillColor(33); // light grey, blueish
1471  if (title!=0) hist->SetTitle(title);
1472  if (xaxis!=0) hist->GetXaxis()->SetTitle(xaxis);
1473  if (yaxis!=0) hist->GetYaxis()->SetTitle(yaxis);
1474 
1475  hist->GetXaxis()->SetLabelFont(52);
1476  hist->GetXaxis()->SetLabelSize(0.04);
1477  hist->GetXaxis()->SetTitleSize(0.05);
1478  hist->GetXaxis()->SetTitleOffset(1.28);
1479  hist->GetXaxis()->SetTitleFont(42);
1480 
1481  hist->GetYaxis()->SetLabelFont(52);
1482  hist->GetYaxis()->SetLabelSize(0.04);
1483  hist->GetYaxis()->SetTitleSize(0.05);
1484  hist->GetYaxis()->SetTitleOffset(1.25);
1485  hist->GetYaxis()->SetTitleFont(42);
1486 
1487  hist->SetStats(false);
1488 
1489  hist->SetLineWidth(2);
1490 }
1491 
1492 void
1493 LumiCalculator::MakePlots(const std::string& triggerchain)
1494 {
1495  if(m_LumiTree != 0){
1496  // rebin and fill histograms:
1497  m_LumiTree->SetBranchAddress("LBStart", &m_clumiblocknbr);
1498  m_LumiTree->SetBranchAddress("L1AfterPrescale", &m_afterprescale);
1499  m_LumiTree->SetBranchAddress("L1Rate", &m_l1rate);
1500  m_LumiTree->SetBranchAddress("IntLumi",&m_intLumi);
1501  m_LumiTree->SetBranchAddress("L1Ratediveffxsec",&m_l1ratediveffxsec);
1502  m_LumiTree->SetBranchAddress("TotalLumi",&m_totalL);
1503  m_LumiTree->SetBranchAddress("Total_L1Ratediveffxsec",&m_total_l1ratediveffxsec);
1504  m_LumiTree->SetBranchAddress("TotalLumiRun",&m_totalLRun);
1505  m_LumiTree->SetBranchAddress("Total_L1RatediveffxsecRun",&m_total_l1ratediveffxsecRun);
1506  m_LumiTree->SetBranchAddress("RunNbr", &m_runnbr);
1507  m_LumiTree->SetBranchAddress("L1RatediveffxsecRecorded",&m_l1ratediveffxsec_recorded);
1508  m_LumiTree->SetBranchAddress("Total_L1RatediveffxsecRecorded",&m_total_l1ratediveffxsec_recorded);
1509  m_LumiTree->SetBranchAddress("Total_L1RatediveffxsecRunRecorded",&m_total_l1ratediveffxsecRun_recorded);
1510  m_LumiTree->SetBranchAddress("AvergeInteractionPerXing",&m_AvEvtsPerBX);
1511 
1512  // get first and last run number
1513  m_LumiTree->GetEntry(0);
1514  int runnbrstart = m_runnbr;
1515  m_LumiTree->GetEntry(m_LumiTree->GetEntries()-1);
1516  int runnbrend = m_runnbr;
1517 
1518  // makeup of integrated lumi histograms
1519  m_intlumiruns = new TH1F("intlumiruns","Luminosity",1,0.,1.);
1520  m_intlumitrigrateruns = new TH1F("intlumitrigrateruns","Delivered luminosity",1,0.,1.);
1521  m_intlumitrigrateruns_recorded = new TH1F("intlumitrigrateruns_recorded","Recorded luminosity",1,0.,1.);
1522  m_intlumiruns->SetBins(runnbrend-runnbrstart+10,float(runnbrstart),float(runnbrend+10));
1523  m_intlumitrigrateruns->SetBins(runnbrend-runnbrstart+10,float(runnbrstart),float(runnbrend+10));
1524  m_intlumitrigrateruns_recorded->SetBins(runnbrend-runnbrstart+10,float(runnbrstart),float(runnbrend+10));
1525 
1526  // Lumi-weighted average interactions per crossing
1527  m_avgintperbx = new TH1F("avgintperbx", "Avg Int/BX", 1000, 0., 100.);
1528  m_avgintperbx->SetTitle("Lumi-weighted Interactions per BX");
1529  this->SetHistogramStyle(m_avgintperbx, "Lumi-weighted Average Interactions per BX", "Average Interactions per BX", "Recorded Luminosity (mb-1)");
1530 
1531  // loop over the lumi tree
1532  m_runnbr_prev = 0;
1533  int nlbs(0);
1534  float totalL(0.), total_l1ratediveffxsec(0.), total_l1ratediveffxsec_recorded(0.), totalLRun(0.), total_l1ratediveffxsecRun(0.), total_l1ratediveffxsecRun_recorded(0.);
1535  for(int i=0; i < m_LumiTree->GetEntries(); i++){
1536  m_LumiTree->GetEntry(i);
1537 
1538  // do histogram admin first
1539  if ( m_runnbr!=m_runnbr_prev ) {
1540  // first rebin prev histograms
1541  if (m_runnbr_prev>0) {
1542  m_intlumi->SetTitle(Form("Delivered luminosity = %.1f /#mu b, Run = %d",totalLRun,m_runnbr_prev));
1543  m_intlumitrigrate->SetTitle(Form("Delivered luminosity = %.1f /#mu b, Efficiency * x-sec = %.1f #mu b, Run = %d",total_l1ratediveffxsecRun,m_effxsec,m_runnbr_prev));
1544  m_intlumitrigrate_recorded->SetTitle(Form("Recorded luminosity = %.1f /#mu b, Efficiency * x-sec = %.1f #mu b, Run = %d",total_l1ratediveffxsecRun_recorded,m_effxsec,m_runnbr_prev));
1545  this->RebinHistograms(nlbs+10,0,double(nlbs+10));
1546  }
1547  // create new histograms
1548  this->DoHistogramAdmin(m_runnbr,triggerchain,m_effxsec);
1549  // fill cullumative luminosity
1550  if (m_runnbr_prev>0) {
1551  for (uint32_t j=m_runnbr_prev; j<m_runnbr; ++j) {
1552  m_intlumiruns->Fill(j,totalL);
1553  m_intlumitrigrateruns->Fill(j,total_l1ratediveffxsec);
1554  m_intlumitrigrateruns_recorded->Fill(j,total_l1ratediveffxsec_recorded);
1555  }
1556  }
1557  m_runnbr_prev = m_runnbr ;
1558  }
1559  totalL = m_totalL;
1560  totalLRun = m_totalLRun;
1561  total_l1ratediveffxsec = m_total_l1ratediveffxsec;
1562  total_l1ratediveffxsecRun = m_total_l1ratediveffxsecRun;
1563  total_l1ratediveffxsec_recorded = m_total_l1ratediveffxsec_recorded;
1564  total_l1ratediveffxsecRun_recorded = m_total_l1ratediveffxsecRun_recorded;
1565  nlbs = m_clumiblocknbr;
1566 
1567  m_ntrigplb->Fill(m_clumiblocknbr,(float)m_afterprescale);
1568  m_trigrateplb->Fill(m_clumiblocknbr,m_l1rate);
1569  m_lumiplb->Fill(m_clumiblocknbr,m_instLumi);
1570  m_lumitrigrateplb->Fill(m_clumiblocknbr,m_l1ratediveffxsec);
1571  m_intlumi->Fill(m_clumiblocknbr,m_totalLRun);
1572  m_intlumitrigrate->Fill(m_clumiblocknbr,m_total_l1ratediveffxsecRun);
1573  m_lumitrigrateplb_recorded->Fill(m_clumiblocknbr,m_l1ratediveffxsec_recorded);
1574  m_intlumitrigrate_recorded->Fill(m_clumiblocknbr,m_total_l1ratediveffxsecRun_recorded);
1575  m_avgintperbx->Fill(m_AvEvtsPerBX, m_intLumi); // Lumi-weighted mu
1576 
1577  } // end tree loop
1578  m_intlumiruns->Fill(runnbrend,totalL);
1579  m_intlumitrigrateruns->Fill(runnbrend,total_l1ratediveffxsec);
1580  m_intlumitrigrateruns_recorded->Fill(runnbrend,total_l1ratediveffxsec_recorded);
1581 
1582  // finish histograms make-up
1583  m_intlumiruns->SetMinimum(0.);
1584  m_intlumitrigrateruns->SetMinimum(0.);
1585  this->RebinHistograms(nlbs+10,0,double(nlbs+10));
1586  this->SetHistogramStyle(m_intlumiruns, Form("Delivered luminosity = %.1f /ub",totalL), "Run number", "Luminosity (#mu b^{-1})");
1587  this->SetHistogramStyle(m_intlumitrigrateruns, Form("Delivered luminosity = %.1f /#mu b, Recorded luminosity = %.1f /#mu b", //, Efficiency * x-sec = %.1f mb",
1588  total_l1ratediveffxsec,total_l1ratediveffxsec_recorded/*,m_effxsec*/), "Run number", Form("%s Luminosity (#mu b^{-1})",triggerchain.c_str()));
1589  this->SetHistogramStyle(m_intlumitrigrateruns_recorded, Form("Delivered luminosity = %.1f /#mub, Recorded luminosity = %.1f /#mub", //, Efficiency * x-sec = %.1f #mub",
1590  total_l1ratediveffxsec,total_l1ratediveffxsec_recorded/*,m_effxsec*/), "Run number", Form("%s Luminosity (#mu b^{-1})",triggerchain.c_str()));
1591 
1592  std::vector<TH1F*>::iterator itr;
1593 
1594  // and store the histograms
1595  TString histFileName = TString("ilumicalc_histograms_") + TString(triggerchain) + ( runnbrstart==runnbrend ? Form("_%d_",runnbrstart) : Form("_%d-%d_",runnbrstart,runnbrend)) + TString(m_lumitag) + TString(".root");
1596  TFile *ff = new TFile(histFileName.Data(),"recreate");
1597  m_avgintperbx->Write();
1598  if (m_effxsec==1.0) {
1599  m_intlumiruns->Write();
1600  for (itr=m_lumiplbVec.begin(); itr!=m_lumiplbVec.end(); ++itr) { (*itr)->Write(); }
1601  for (itr=m_intlumiVec.begin(); itr!=m_intlumiVec.end(); ++itr) { (*itr)->Write(); }
1602  }
1603  for (itr=m_ntrigplbVec.begin(); itr!=m_ntrigplbVec.end(); ++itr) { (*itr)->Write(); }
1604  for (itr=m_trigrateplbVec.begin(); itr!=m_trigrateplbVec.end(); ++itr) { (*itr)->Write(); }
1605  if (m_effxsec!=1.0) { // results only make sense when proper xsec is provided externally
1606  m_intlumitrigrateruns->Write();
1607  m_intlumitrigrateruns_recorded->Write();
1608  for (itr=m_lumitrigrateplbVec.begin(); itr!=m_lumitrigrateplbVec.end(); ++itr) { (*itr)->Write(); }
1609  for (itr=m_intlumitrigrateVec.begin(); itr!=m_intlumitrigrateVec.end(); ++itr) { (*itr)->Write(); }
1610  for (itr=m_lumitrigrateplb_recordedVec.begin(); itr!=m_lumitrigrateplb_recordedVec.end(); ++itr) { (*itr)->Write(); }
1611  for (itr=m_intlumitrigrate_recordedVec.begin(); itr!=m_intlumitrigrate_recordedVec.end(); ++itr) { (*itr)->Write(); }
1612  }
1613  m_LumiTree->Write();
1614 
1615  // And write out the lumi tag information
1616  TObjString lumiTag(m_lumitag.c_str());
1617  lumiTag.Write("lumiTag");
1618 
1619  TObjString larTag(m_lartag.c_str());
1620  larTag.Write("larTag");
1621 
1622 
1623  ff->Close();
1624  delete ff;
1625  m_logger << Root::kINFO << "Histograms stored as : " << histFileName << Root::GEndl;
1626 
1627  }else{
1628  m_logger << Root::kWARNING << "LumiTree pointer does not exist! : " << Root::GEndl;
1629  }
1630 
1631 
1632 }
1633 
1634 
RunTileTBRec.method
method
Definition: RunTileTBRec.py:73
LumiCalculator::m_deltaT
float m_deltaT
Definition: LumiCalculator.h:128
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
LumiCalculator::m_afterprescaleof
bool m_afterprescaleof
Definition: LumiCalculator.h:148
LumiCalculator::m_l2acc
unsigned int m_l2acc
Definition: LumiCalculator.h:135
TGoodRunsList.h
LumiCalculator::m_lumiLAr
float m_lumiLAr
Definition: LumiCalculator.h:168
LumiCalculator::m_ntrigplbVec
std::vector< TH1F * > m_ntrigplbVec
Definition: LumiCalculator.h:220
LumiCalculator::m_livetrigger
std::string m_livetrigger
Definition: LumiCalculator.h:82
Root::kWARNING
@ kWARNING
Definition: TMsgLogger.h:51
LumiCalculator::m_totalbadblock
unsigned int m_totalbadblock
Definition: LumiCalculator.h:158
LumiCalculator::m_lumimethod
std::string m_lumimethod
Definition: LumiCalculator.h:87
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
LumiCalculator::UseLumiChannel
void UseLumiChannel(int chan)
Definition: LumiCalculator.cxx:287
LumiCalculator::m_totalgoodblock
unsigned int m_totalgoodblock
Definition: LumiCalculator.h:157
LumiCalculator::m_intlumi
TH1F * m_intlumi
Definition: LumiCalculator.h:209
LumiCalculator::m_lbstarttime
double m_lbstarttime
Definition: LumiCalculator.h:116
LumiCalculator::printSummary
void printSummary(std::ostream &os)
Definition: LumiCalculator.cxx:1397
IOVRange
Validity Range object. Holds two IOVTimes (start and stop)
Definition: IOVRange.h:30
python.output.AtlRunQueryRoot.MakePlots
def MakePlots(tree, datapath)
Definition: AtlRunQueryRoot.py:111
LumiCalculator::SetHistogramStyle
void SetHistogramStyle(TH1F *hist, const char *title=0, const char *xaxis=0, const char *yaxis=0)
Definition: LumiCalculator.cxx:1468
IOVTime::event
uint32_t event() const noexcept
Definition: IOVTime.h:106
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
IOVData
Definition: CoolQuery.h:54
LumiCalculator::m_usebs
bool m_usebs
Definition: LumiCalculator.h:245
LumiCalculator::m_intlumitrigrate
TH1F * m_intlumitrigrate
Definition: LumiCalculator.h:210
CoolQuery::getLumiFolderData
std::map< cool::ValidityKey, LumiFolderData > getLumiFolderData(const std::string &folder_name, const std::string &tag, const cool::ChannelId &id)
Definition: CoolQuery.cxx:290
LumiCalculator::RebinHistograms
void RebinHistograms(const int &nbins, const double &start, const double &end)
Definition: LumiCalculator.cxx:1454
LumiCalculator::m_lumichannel
int m_lumichannel
Definition: LumiCalculator.h:92
plotmaker.hist
hist
Definition: plotmaker.py:148
LumiCalculator::m_bsonl
std::string m_bsonl
Definition: LumiCalculator.h:90
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:13
tree
TChain * tree
Definition: tile_monitor.h:30
IOVRange::start
const IOVTime & start() const
Definition: IOVRange.h:38
CoolQuery::getHLTLowerChainName
std::string getHLTLowerChainName(const std::string &trigger, const std::string &folder_name)
Definition: CoolQuery.cxx:256
CoolQuery::setIOVForRun
void setIOVForRun(unsigned int runnum)
Definition: CoolQuery.cxx:101
skel.it
it
Definition: skel.GENtoEVGEN.py:407
IOVTime::re_time
uint64_t re_time() const noexcept
Definition: IOVTime.h:107
CoolQuery::L1CountFolderData::AfterPrescale
cool::UInt63 AfterPrescale
Definition: CoolQuery.h:312
LumiCalculator::m_afterprescale
ULong64_t m_afterprescale
Definition: LumiCalculator.h:145
LumiCalculator::m_lumitrigrateplbVec
std::vector< TH1F * > m_lumitrigrateplbVec
Definition: LumiCalculator.h:223
LumiCalculator::m_trigger
std::string m_trigger
Definition: LumiCalculator.h:81
CoolQuery::L1CountFolderData::BeforePrescale
cool::UInt63 BeforePrescale
Definition: CoolQuery.h:311
ATLAS_NOT_THREAD_SAFE
void LumiCalculator::IntegrateLumi ATLAS_NOT_THREAD_SAFE(const xAOD::LumiBlockRangeContainer *iovc, const std::string &triggerchain)
Definition: LumiCalculator.cxx:314
LumiCalculator::m_lumitrigrateplb
TH1F * m_lumitrigrateplb
Definition: LumiCalculator.h:208
LumiCalculator::m_lumiplbVec
std::vector< TH1F * > m_lumiplbVec
Definition: LumiCalculator.h:222
LumiCalculator::m_L1id
cool::ChannelId m_L1id
Definition: LumiCalculator.h:235
LumiCalculator::m_parlvl1menufolder
std::string m_parlvl1menufolder
Definition: LumiCalculator.h:97
LumiCalculator::m_avgintperbx
TH1F * m_avgintperbx
Definition: LumiCalculator.h:218
LumiCalculator.h
LumiCalculator::m_l3prescale
float m_l3prescale
Definition: LumiCalculator.h:144
LumiCalculator::SetCollName
void SetCollName(const std::string &lbcollname)
Definition: LumiCalculator.cxx:256
LumiCalculator::m_totalLRun
float m_totalLRun
Definition: LumiCalculator.h:121
LumiCalculator::UseLumiMethod
void UseLumiMethod(const std::string &method)
Definition: LumiCalculator.cxx:283
GEndl
#define GEndl
Definition: TMsgLogger.h:152
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
LumiCalculator::m_intlumiVec
std::vector< TH1F * > m_intlumiVec
Definition: LumiCalculator.h:224
LumiCalculator::m_trigrateplb
TH1F * m_trigrateplb
Definition: LumiCalculator.h:206
PrepareReferenceFile.regex
regex
Definition: PrepareReferenceFile.py:43
LumiCalculator::m_AvEvtsPerBX
float m_AvEvtsPerBX
Definition: LumiCalculator.h:124
CoolQuery::getL1CountFolderData
std::map< cool::ValidityKey, L1CountFolderData > getL1CountFolderData(const std::string &folder_name, const cool::ChannelId &id)
Definition: CoolQuery.cxx:324
IOVRange::stop
const IOVTime & stop() const
Definition: IOVRange.h:39
LumiCalculator::m_livefrac
float m_livefrac
Definition: LumiCalculator.h:130
LumiCalculator::m_bstag
std::string m_bstag
Definition: LumiCalculator.h:91
LumiCalculator::m_lumi_database
std::string m_lumi_database
Definition: LumiCalculator.h:76
LumiCalculator::m_lartag
std::string m_lartag
Definition: LumiCalculator.h:89
LumiCalculator::m_laroff
std::string m_laroff
Definition: LumiCalculator.h:88
IOVTime
Basic time unit for IOVSvc. Hold time as a combination of run and event numbers.
Definition: IOVTime.h:33
calibdata.valid
list valid
Definition: calibdata.py:44
LumiCalculator::ParseL1Trigger
void ParseL1Trigger(const std::string &lowerch, CoolQuery *cq_trigger)
Definition: LumiCalculator.cxx:1354
TileSynchronizeBch.online
online
Definition: TileSynchronizeBch.py:88
mc
Definition: mc.Py8EG_A2MSTW2008LO_minbias_inelastic.py:1
LumiCalculator::m_lbstop
uint32_t m_lbstop
Definition: LumiCalculator.h:153
CoolQuery::getLumiChannelId
cool::ChannelId getLumiChannelId(const std::string &lumimethod, const std::string &folder_name)
Definition: CoolQuery.cxx:170
LumiCalculator::m_data_db
std::string m_data_db
Definition: LumiCalculator.h:85
fillPileUpNoiseLumi.next
next
Definition: fillPileUpNoiseLumi.py:52
CoolQuery::L1CountFolderData::L1Accept
cool::UInt63 L1Accept
Definition: CoolQuery.h:313
CoolQuery
Definition: CoolQuery.h:217
lumiFormat.i
int i
Definition: lumiFormat.py:85
D3PDSizeSummary.ff
ff
Definition: D3PDSizeSummary.py:305
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
LumiCalculator::m_clumiblocknbr
uint32_t m_clumiblocknbr
Definition: LumiCalculator.h:159
LumiCalculator::m_l1ratediveffxsec_recorded
float m_l1ratediveffxsec_recorded
Definition: LumiCalculator.h:198
Root::kINFO
@ kINFO
Definition: TMsgLogger.h:50
LumiCalculator::m_lbstart
uint32_t m_lbstart
Definition: LumiCalculator.h:152
LumiCalculator::m_onlinelumi
bool m_onlinelumi
Definition: LumiCalculator.h:243
LumiCalculator::m_verbose
bool m_verbose
Definition: LumiCalculator.h:110
LumiCalculator::m_intlumitrigrateruns
TH1F * m_intlumitrigrateruns
Definition: LumiCalculator.h:215
IOVData::clear
void clear()
Definition: CoolQuery.h:65
LumiCalculator::m_totalL
float m_totalL
Definition: LumiCalculator.h:120
covarianceTool.title
title
Definition: covarianceTool.py:542
Root::TGoodRunsListWriter
Definition: TGoodRunsListWriter.h:38
LumiCalculator::m_maxrun
unsigned int m_maxrun
Definition: LumiCalculator.h:248
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:194
LumiCalculator::m_collsgrl
Root::TGoodRunsList * m_collsgrl
Definition: LumiCalculator.h:203
LumiCalculator::m_l1ratediveffxsec
float m_l1ratediveffxsec
Definition: LumiCalculator.h:195
LumiCalculator::m_effxsec
float m_effxsec
Definition: LumiCalculator.h:191
beamspotman.bstag
string bstag
Definition: beamspotman.py:854
LumiCalculator::m_bs_database
std::string m_bs_database
Definition: LumiCalculator.h:79
CoolQuery::getObjMapFromFolderAtChan
std::map< cool::ValidityKey, T > getObjMapFromFolderAtChan(const std::string &obj_name, const std::string &folder_name, const cool::ChannelId &id)
Definition: CoolQuery.h:375
LumiCalculator::m_beforeprescaleof
bool m_beforeprescaleof
Definition: LumiCalculator.h:150
LumiCalculator::m_intlumitrigrate_recordedVec
std::vector< TH1F * > m_intlumitrigrate_recordedVec
Definition: LumiCalculator.h:227
IOVTime::setRETime
void setRETime(uint64_t time) noexcept
Definition: IOVTime.cxx:84
LumiCalculator::m_runnbr_prev
uint32_t m_runnbr_prev
Definition: LumiCalculator.h:156
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
LumiCalculator::m_lumiplb
TH1F * m_lumiplb
Definition: LumiCalculator.h:207
LumiCalculator::m_total_l1ratediveffxsecRun
float m_total_l1ratediveffxsecRun
Definition: LumiCalculator.h:197
CoolQuery::printHLTTriggers
void printHLTTriggers(const std::string &folder_name)
Definition: CoolQuery.cxx:235
CoolQuery::getIOVData
IOVData< T > getIOVData(const std::string &name, const std::string &folder_name, const cool::ChannelId &id, const std::string &tag="")
Definition: CoolQuery.h:421
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
LumiCalculator::m_lumioff
std::string m_lumioff
Definition: LumiCalculator.h:83
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
LumiCalculator::m_logger
Root::TMsgLogger m_logger
Definition: LumiCalculator.h:107
CoolQuery::getHLTChannelId
cool::ChannelId getHLTChannelId(const std::string &trigger, const std::string &folder_name)
Definition: CoolQuery.cxx:191
LumiCalculator::m_totalDelL
float m_totalDelL
Definition: LumiCalculator.h:119
LumiCalculator::m_L1idList
std::vector< cool::ChannelId > m_L1idList
Definition: LumiCalculator.h:188
CoolQuery::channelIdValid
bool channelIdValid()
Definition: CoolQuery.cxx:250
LumiCalculator::UseLArNoiseDB
void UseLArNoiseDB(bool lar, const std::string &lardb)
Definition: LumiCalculator.cxx:298
LumiCalculator::m_livetime
float m_livetime
Definition: LumiCalculator.h:131
LumiBlockRangeContainerConverter.h
LumiCalculator::m_intlumitrigrateruns_recorded
TH1F * m_intlumitrigrateruns_recorded
Definition: LumiCalculator.h:216
LumiCalculator::m_ntrigplb
TH1F * m_ntrigplb
Definition: LumiCalculator.h:205
LumiCalculator::m_totall1befpresc
unsigned int m_totall1befpresc
Definition: LumiCalculator.h:139
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
CoolQuery::setIOV
void setIOV(const cool::ValidityKey start, const cool::ValidityKey stop)
Definition: CoolQuery.cxx:96
LumiCalculator::m_l1acc
unsigned int m_l1acc
Definition: LumiCalculator.h:132
LumiCalculator::m_lumitrigrateplb_recordedVec
std::vector< TH1F * > m_lumitrigrateplb_recordedVec
Definition: LumiCalculator.h:226
LumiCalculator::m_L1Valid
bool m_L1Valid
Definition: LumiCalculator.h:238
LumiCalculator::m_uselivetrigger
bool m_uselivetrigger
Definition: LumiCalculator.h:109
IOVTime::run
uint32_t run() const noexcept
Definition: IOVTime.h:105
Root::TGoodRunsList
Definition: TGoodRunsList.h:31
LumiCalculator::Verbose
void Verbose(bool verbose=true)
Definition: LumiCalculator.cxx:261
LumiCalculator::m_intLumi
float m_intLumi
Definition: LumiCalculator.h:127
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
LumiCalculator::m_L1triggerchains
std::vector< std::string > m_L1triggerchains
Definition: LumiCalculator.h:187
CoolQuery::printL1Triggers
void printL1Triggers(const std::string &folder_name)
Definition: CoolQuery.cxx:221
LumiCalculator::m_l1rate
float m_l1rate
Definition: LumiCalculator.h:192
LumiCalculator::m_total_l1ratediveffxsecRun_recorded
float m_total_l1ratediveffxsecRun_recorded
Definition: LumiCalculator.h:200
LumiCalculator::m_l3acc
unsigned int m_l3acc
Definition: LumiCalculator.h:136
LumiCalculator::UseOnlineLumi
void UseOnlineLumi(bool online)
Definition: LumiCalculator.cxx:273
LumiCalculator::m_lbcollname
std::string m_lbcollname
Definition: LumiCalculator.h:108
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
LumiCalculator::UseMC
void UseMC(bool mc=true)
Definition: LumiCalculator.cxx:265
python.DataFormatRates.lumiTag
lumiTag
Definition: DataFormatRates.py:56
IOVData::data
std::list< std::pair< IOVRange, T > > data
Definition: CoolQuery.h:81
LumiCalculator::m_intlumiruns
TH1F * m_intlumiruns
Definition: LumiCalculator.h:214
LumiCalculator::m_trigrateplbVec
std::vector< TH1F * > m_trigrateplbVec
Definition: LumiCalculator.h:221
CoolQuery::openDbConn
bool openDbConn()
Definition: CoolQuery.cxx:30
LumiCalculator::m_triggerchain
std::string m_triggerchain
Definition: LumiCalculator.h:185
LumiCalculator::m_intlumitrigrateVec
std::vector< TH1F * > m_intlumitrigrateVec
Definition: LumiCalculator.h:225
LumiCalculator::m_runnbr
uint32_t m_runnbr
Definition: LumiCalculator.h:151
LumiCalculator::m_l1prescale
float m_l1prescale
Definition: LumiCalculator.h:142
LumiCalculator::m_lumitag
std::string m_lumitag
Definition: LumiCalculator.h:86
python.TriggerHandler.verbose
verbose
Definition: TriggerHandler.py:296
LumiCalculator::m_totaltime
float m_totaltime
Definition: LumiCalculator.h:122
LumiCalculator::m_larfrac
float m_larfrac
Definition: LumiCalculator.h:182
LumiCalculator::m_LumiTree
TTree * m_LumiTree
Definition: LumiCalculator.h:69
LumiCalculator::m_l2prescale
float m_l2prescale
Definition: LumiCalculator.h:143
LumiCalculator::DoHistogramAdmin
void DoHistogramAdmin(const uint32_t &runnbr, const TString &trigName, const float &effxsec)
Definition: LumiCalculator.cxx:1419
IOVData::getValue
T getValue(IOVTime time)
Definition: CoolQuery.h:99
IOVData::getOverlap
std::list< std::pair< IOVRange, T > > getOverlap(const IOVRange &range)
Definition: CoolQuery.h:173
LumiCalculator::m_lumitrigrateplb_recorded
TH1F * m_lumitrigrateplb_recorded
Definition: LumiCalculator.h:211
LumiCalculator::m_total_l1ratediveffxsec
float m_total_l1ratediveffxsec
Definition: LumiCalculator.h:196
merge.status
status
Definition: merge.py:16
LumiCalculator::m_instLumi
float m_instLumi
Definition: LumiCalculator.h:123
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
CoolQuery::L1CountFolderData
Definition: CoolQuery.h:310
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:23
CoolQuery.h
LumiCalculator::m_lar_database
std::string m_lar_database
Definition: LumiCalculator.h:78
LumiCalculator::UseLiveTrigger
void UseLiveTrigger(bool live, std::string &livetrigger)
Definition: LumiCalculator.cxx:293
LumiCalculator::m_bsvalid
float m_bsvalid
Definition: LumiCalculator.h:183
LumiCalculator::m_beforeprescale
ULong64_t m_beforeprescale
Definition: LumiCalculator.h:149
LumiCalculator::MakePlots
void MakePlots(bool plots)
Definition: LumiCalculator.h:47
LumiCalculator::m_total_l1ratediveffxsec_recorded
float m_total_l1ratediveffxsec_recorded
Definition: LumiCalculator.h:199
LumiCalculator::UseBeamspot
void UseBeamspot(bool bs, const std::string &bstag)
Definition: LumiCalculator.cxx:303
example.writer
writer
show summary of content
Definition: example.py:36
LumiCalculator::m_lumiWOPrescale
float m_lumiWOPrescale
Definition: LumiCalculator.h:166
LumiCalculator::m_lbendtime
double m_lbendtime
Definition: LumiCalculator.h:117
LumiCalculator::m_intlumitrigrate_recorded
TH1F * m_intlumitrigrate_recorded
Definition: LumiCalculator.h:212
LumiCalculator::m_uselar
bool m_uselar
Definition: LumiCalculator.h:244
LumiCalculator::m_totalPrescaleWLiveTime
float m_totalPrescaleWLiveTime
Definition: LumiCalculator.h:162
TGoodRunsListWriter.h
LumiCalculator::m_trig_database
std::string m_trig_database
Definition: LumiCalculator.h:77
LumiCalculator::m_l1accof
bool m_l1accof
Definition: LumiCalculator.h:134
LumiCalculator::LumiCalculator
LumiCalculator()
Definition: LumiCalculator.cxx:31
LumiCalculator::~LumiCalculator
~LumiCalculator()
Definition: LumiCalculator.cxx:179
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
CoolQuery::getTriggerLevel
unsigned int getTriggerLevel(const std::string &triggername)
Definition: CoolQuery.cxx:79
LumiCalculator::m_minrun
unsigned int m_minrun
Definition: LumiCalculator.h:247
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
LumiCalculator::getTree
TTree * getTree()
Definition: LumiCalculator.cxx:308
LumiCalculator::UseLumiTag
void UseLumiTag(const std::string &tag)
Definition: LumiCalculator.cxx:279
LumiCalculator::setTree
void setTree(TTree *tree=0)
Definition: LumiCalculator.cxx:210
CoolQuery::getL1ChannelId
cool::ChannelId getL1ChannelId(const std::string &trigger, const std::string &folder_name)
Definition: CoolQuery.cxx:139
Generated on Mon Sep 29 2025 21:14:14 for ATLAS Offline Software by   doxygen 1.8.18