test
CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
L1TBPTX.cc
Go to the documentation of this file.
1 #include "DQM/L1TMonitor/interface/L1TBPTX.h"
2 
3 #include "DQMServices/Core/interface/DQMStore.h"
4 
5 #include "DataFormats/Scalers/interface/LumiScalers.h"
6 #include "DataFormats/Scalers/interface/Level1TriggerRates.h"
7 
8 #include "DataFormats/Common/interface/ConditionsInEdm.h" // Parameters associated to Run, LS and Event
9 
10 #include "CondFormats/L1TObjects/interface/L1GtTriggerMenuFwd.h"
11 #include "CondFormats/L1TObjects/interface/L1GtTriggerMenu.h"
12 #include "CondFormats/L1TObjects/interface/L1GtPrescaleFactors.h"
13 #include "CondFormats/DataRecord/interface/L1GtTriggerMenuRcd.h"
14 #include "CondFormats/DataRecord/interface/L1GtPrescaleFactorsAlgoTrigRcd.h"
15 #include "CondFormats/DataRecord/interface/L1GtPrescaleFactorsTechTrigRcd.h"
16 #include "CondFormats/L1TObjects/interface/L1GtMuonTemplate.h"
17 
18 // Luminosity Information
19 //#include "DataFormats/Luminosity/interface/LumiDetails.h"
20 //#include "DataFormats/Luminosity/interface/LumiSummary.h"
21 
22 // L1TMonitor includes
23 #include "DQM/L1TMonitor/interface/L1TMenuHelper.h"
24 
25 #include "TList.h"
26 
27 using namespace edm;
28 using namespace std;
29 
30 //-------------------------------------------------------------------------------------
31 //-------------------------------------------------------------------------------------
32 L1TBPTX::L1TBPTX(const ParameterSet & pset){
33 
34  m_parameters = pset;
35 
36  // Mapping parameter input variables
37  m_scalersSource = consumes<Level1TriggerScalersCollection>(pset.getParameter <InputTag>("inputTagScalersResults"));
38  m_l1GtDataDaqInputTag = consumes<L1GlobalTriggerReadoutRecord>(pset.getParameter <InputTag>("inputTagL1GtDataDaq"));
39  m_l1GtEvmSource = consumes<L1GlobalTriggerEvmReadoutRecord>(pset.getParameter <InputTag>("inputTagtEvmSource"));
40  m_verbose = pset.getUntrackedParameter<bool> ("verbose",false);
41 // m_refPrescaleSet = pset.getParameter <int> ("refPrescaleSet");
42 
43  m_monitorBits = pset.getParameter< vector<ParameterSet> >("MonitorBits");
44 
45  for(unsigned i=0; i<m_monitorBits.size(); i++){
46 
47  // Algorithms
48  if(m_monitorBits[i].getParameter<bool>("bitType")){
49 
50  int bit = m_monitorBits[i].getParameter<int>("bitNumber");
51  int offset = m_monitorBits[i].getParameter<int>("bitOffset");
52  m_selAlgoBit.push_back( pair<int,int>(bit,offset) );
53  }
54  // Tech
55  else{
56  int bit = m_monitorBits[i].getParameter<int>("bitNumber");
57  int offset = m_monitorBits[i].getParameter<int>("bitOffset");
58  m_selTechBit.push_back( pair<int,int>(bit,offset) );
59  }
60  }
61 
62  m_monitorRates = pset.getParameter< vector<ParameterSet> >("MonitorRates");
63 
64 }
65 
66 //-------------------------------------------------------------------------------------
67 //-------------------------------------------------------------------------------------
68 L1TBPTX::~L1TBPTX(){}
69 
70 //-------------------------------------------------------------------------------------
72 //-------------------------------------------------------------------------------------
73 void L1TBPTX::bookHistograms(DQMStore::IBooker &ibooker, const edm::Run& iRun, const edm::EventSetup& iSetup){
74 
75  if (m_verbose){cout << "[L1TBPTX] Called beginRun." << endl;}
76 
77  ibooker.setCurrentFolder("L1T/L1TBPTX");
78 
79  // Initializing variables
80  int maxNbins = 2501;
81 
82  // Reseting run dependent variables
83  m_lhcFill = 0;
84  m_currentLS = 0;
85 
86  // Getting Trigger menu from GT
87  ESHandle<L1GtTriggerMenu> menuRcd;
88  iSetup.get<L1GtTriggerMenuRcd>().get(menuRcd);
89  const L1GtTriggerMenu* menu = menuRcd.product();
90 
91  // Filling Alias-Bit Map
92  for (CItAlgo algo = menu->gtAlgorithmAliasMap().begin(); algo!=menu->gtAlgorithmAliasMap().end(); ++algo){
93  m_algoBit_Alias[(algo->second).algoBitNumber()] = (algo->second).algoAlias();
94  }
95 
96  for (CItAlgo algo = menu->gtTechnicalTriggerMap().begin(); algo!=menu->gtTechnicalTriggerMap().end(); ++algo){
97  m_techBit_Alias[(algo->second).algoBitNumber()] = (algo->second).algoName();
98  }
99 
100  // Initializing DQM Monitor Elements
101  ibooker.setCurrentFolder("L1T/L1TBPTX");
102  m_ErrorMonitor = ibooker.book1D("ErrorMonitor","ErrorMonitor",7,0,7);
103  m_ErrorMonitor->setBinLabel(UNKNOWN ,"UNKNOWN");
104  m_ErrorMonitor->setBinLabel(WARNING_DB_CONN_FAILED ,"WARNING_DB_CONN_FAILED"); // Errors from L1TOMDSHelper
105  m_ErrorMonitor->setBinLabel(WARNING_DB_QUERY_FAILED ,"WARNING_DB_QUERY_FAILED"); // Errors from L1TOMDSHelper
106  m_ErrorMonitor->setBinLabel(WARNING_DB_INCORRECT_NBUNCHES,"WARNING_DB_INCORRECT_NBUNCHES"); // Errors from L1TOMDSHelper
107  m_ErrorMonitor->setBinLabel(ERROR_UNABLE_RETRIVE_PRODUCT ,"ERROR_UNABLE_RETRIVE_PRODUCT");
108  m_ErrorMonitor->setBinLabel(ERROR_TRIGGERALIAS_NOTVALID ,"ERROR_TRIGGERALIAS_NOTVALID");
109  m_ErrorMonitor->setBinLabel(ERROR_LSBLOCK_NOTVALID ,"ERROR_LSBLOCK_NOTVALID");
110 
111  for(unsigned i=0; i<m_monitorBits.size(); i++){
112 
113  bool isAlgo = m_monitorBits[i].getParameter<bool> ("bitType");
114  TString testName = m_monitorBits[i].getParameter<string>("testName");
115  int bit = m_monitorBits[i].getParameter<int> ("bitNumber");
116 
117  TString meTitle = "";
118  ibooker.setCurrentFolder("L1T/L1TBPTX/Efficiency/");
119  if(isAlgo){
120  meTitle="Algo ";meTitle+=bit; meTitle+=" - "; meTitle+=m_algoBit_Alias[bit]; meTitle+=" Efficiency";
121  m_meAlgoEfficiency[bit] = ibooker.book1D(testName,meTitle,maxNbins,-0.5,double(maxNbins)-0.5);
122  m_meAlgoEfficiency[bit]->setAxisTitle("Lumi Section" ,1);
123  }
124  else{
125  meTitle="Tech "; meTitle+=bit; meTitle+=" - "; meTitle+=m_techBit_Alias[bit]; meTitle+=" Efficiency";
126  m_meTechEfficiency[bit] = ibooker.book1D(testName,meTitle,maxNbins,-0.5,double(maxNbins)-0.5);
127  m_meTechEfficiency[bit]->setAxisTitle("Lumi Section" ,1);
128  }
129 
130  meTitle = "";
131  ibooker.setCurrentFolder("L1T/L1TBPTX/MissFire/");
132  if(isAlgo){
133  meTitle="Algo "; meTitle+=bit; meTitle+=" - "; meTitle+=m_algoBit_Alias[bit]; meTitle+="(1 - Miss Fire Rate)";
134  m_meAlgoMissFire[bit] = ibooker.book1D(testName,meTitle,maxNbins,-0.5,double(maxNbins)-0.5);
135  m_meAlgoMissFire[bit]->setAxisTitle("Lumi Section" ,1);
136  m_meAlgoMissFire[bit]->setAxisTitle("1 - Miss Fire Rate",2);
137  }
138  else{
139  meTitle="Tech "; meTitle+=bit; meTitle+=" - "; meTitle+=m_techBit_Alias[bit]; meTitle+="(1 - Miss Fire Rate)";
140  m_meTechMissFire[bit] = ibooker.book1D(testName,meTitle,maxNbins,-0.5,double(maxNbins)-0.5);
141  m_meTechMissFire[bit]->setAxisTitle("Lumi Section" ,1);
142  m_meTechMissFire[bit]->setAxisTitle("1 - Miss Fire Rate",2);
143  }
144  }
145 
146  for(unsigned i=0; i<m_monitorRates.size(); i++){
147 
148  TString testName = m_monitorRates[i].getParameter<string>("testName");
149  bool isAlgo = m_monitorRates[i].getParameter<bool> ("bitType");
150  int bit = m_monitorRates[i].getParameter<int> ("bitNumber");
151 
152  pair<bool,int> refME = pair<bool,int>(isAlgo,bit);
153 
154  TString meTitle = "";
155  ibooker.setCurrentFolder("L1T/L1TBPTX/Rate/");
156  if(isAlgo){
157  meTitle="Algo "+bit; meTitle+=" - "; meTitle+=m_algoBit_Alias[bit]; meTitle+=" Rate";
158  m_meRate[refME] = ibooker.book1D(testName,meTitle,maxNbins,-0.5,double(maxNbins)-0.5);
159  m_meRate[refME]->setAxisTitle("Lumi Section" ,1);
160  m_meRate[refME]->setAxisTitle("Rate (unprescaled) [Hz]",2);
161  }
162  else{
163  meTitle="Tech "+bit; meTitle+=" - "; meTitle+=m_techBit_Alias[bit]; meTitle+=" Rate";
164  m_meRate[refME] = ibooker.book1D(testName,meTitle,maxNbins,-0.5,double(maxNbins)-0.5);
165  m_meRate[refME]->setAxisTitle("Lumi Section" ,1);
166  m_meRate[refME]->setAxisTitle("Rate (unprescaled) [Hz]",2);
167  }
168  }
169 
170 
171 
172  //_____________________________________________________________________
173  // Getting the prescale columns definition for this run
174  ESHandle<L1GtPrescaleFactors> l1GtPfAlgo;
175  ESHandle<L1GtPrescaleFactors> l1GtPfTech;
176 
177  iSetup.get<L1GtPrescaleFactorsAlgoTrigRcd>().get(l1GtPfAlgo);
178  iSetup.get<L1GtPrescaleFactorsTechTrigRcd>().get(l1GtPfTech);
179 
180  if(l1GtPfAlgo.isValid()){
181  const L1GtPrescaleFactors* m_l1GtPfAlgo = l1GtPfAlgo.product();
182  m_prescaleFactorsAlgoTrig = &(m_l1GtPfAlgo->gtPrescaleFactors());
183  }else{
184  //TODO: Some error handling
185  }
186 
187  if(l1GtPfAlgo.isValid()){
188  const L1GtPrescaleFactors* m_l1GtPfTech = l1GtPfTech.product();
189  m_prescaleFactorsTechTrig = &(m_l1GtPfTech->gtPrescaleFactors());
190  }else{
191  //TODO: Some error handling
192  }
193 
194 }
195 
196 void L1TBPTX::dqmBeginRun(const edm::Run&, const edm::EventSetup&){
197  //empty
198 }
199 
200 //_____________________________________________________________________
201 // Function: beginLuminosityBlock
202 //_____________________________________________________________________
203 void L1TBPTX::beginLuminosityBlock(LuminosityBlock const& lumiBlock, EventSetup const& c) {
204 
205  if (m_verbose){cout << "[L1TBPTX] Called beginLuminosityBlock." << endl;}
206 
207  // Updating current LS number
208  m_currentLS = lumiBlock.id().luminosityBlock();
209 
210  // A LS will be valid if BeamMode==STABLE for all events monitored
211  m_currentLSValid = true;
212 
213  for(unsigned i=0; i<m_monitorBits.size(); i++){
214 
215  TString triggerName = "";
216  if(m_monitorBits[i].getParameter<bool>("bitType")){
217  triggerName = "algo_"+m_monitorBits[i].getParameter<int>("bitNumber");
218  }else{
219  triggerName = "tech_"+m_monitorBits[i].getParameter<int>("bitNumber");
220  }
221 
222  m_effNumerator [triggerName] = 0;
223  m_effDenominator [triggerName] = 0;
224  m_missFireNumerator [triggerName] = 0;
225  m_missFireDenominator[triggerName] = 0;
226 
227  }
228 
229 }
230 
231 //_____________________________________________________________________
232 // Function: endLuminosityBlock
233 // * Fills LS by LS ration of trigger out of sync
234 //_____________________________________________________________________
235 void L1TBPTX::endLuminosityBlock(LuminosityBlock const& lumiBlock, EventSetup const& c) {
236 
237  //______________________________________________________________________________
238  // Monitoring efficiencies
239  //______________________________________________________________________________
240  if(m_verbose){cout << "[L1TBPTX] Called endLuminosityBlock." << endl;}
241 
242  // If this LS is valid (i.e. all events recorded with stable beams)
243  if(m_currentLSValid && m_beamConfig.isValid()){
244 
245  for(unsigned i=0; i<m_monitorBits.size(); i++){
246 
247  bool isAlgo = m_monitorBits[i].getParameter<bool> ("bitType");
248  TString testName = m_monitorBits[i].getParameter<string>("testName");
249  int bit = m_monitorBits[i].getParameter<int> ("bitNumber");
250 
251  TString triggerName;
252  if(isAlgo){triggerName = "algo_"+bit;}
253  else {triggerName = "tech_"+bit;}
254 
255  double valEff;
256  double valMiss;
257  if(m_effDenominator[triggerName]!=0) {valEff = (double)m_effNumerator[triggerName]/m_effDenominator[triggerName];}
258  else {valEff = 0;}
259  if(m_missFireDenominator[triggerName]!=0){valMiss = (double)m_missFireNumerator[triggerName]/m_missFireDenominator[triggerName];}
260  else {valMiss = 0;}
261 
262  if(isAlgo){
263  int bin = m_meAlgoEfficiency[bit]->getTH1()->FindBin(m_currentLS);
264  m_meAlgoEfficiency[bit]->setBinContent(bin,valEff);
265  m_meAlgoMissFire[bit] ->setBinContent(bin,1-valMiss);
266  }
267  else{
268  int bin = m_meTechEfficiency[bit]->getTH1()->FindBin(m_currentLS);
269  m_meTechEfficiency[bit]->setBinContent(bin,valEff);
270  m_meTechMissFire[bit] ->setBinContent(bin,1-valMiss);
271  }
272  }
273  }
274 
275  //______________________________________________________________________________
276  // Monitoring rates
277  //______________________________________________________________________________
278  // We are only interested in monitoring lumisections where the the LHC state is
279  // RAMP, FLATTOP, SQUEEZE, ADJUST or STABLE since the bunch configuration and
280  // therefore the BPTX rate will not change.
281 
282  if(m_currentLSValid){
283 
284  const vector<int>& currentPFAlgo = (*m_prescaleFactorsAlgoTrig).at(m_currentPrescalesIndex);
285  const vector<int>& currentPFTech = (*m_prescaleFactorsTechTrig).at(m_currentPrescalesIndex);
286 
287  for(unsigned i=0; i<m_monitorRates.size(); i++){
288 
289  bool isAlgo = m_monitorRates[i].getParameter<bool> ("bitType");
290  int bit = m_monitorRates[i].getParameter<int> ("bitNumber");
291 
292  pair<bool,int> refME = pair<bool,int>(isAlgo,bit);
293 
294  if(isAlgo){
295  int bin = m_meRate[refME]->getTH1()->FindBin(m_currentGTLS);
296  int trigPS = currentPFAlgo[bit];
297  double trigRate = (double) trigPS*m_l1Rate[refME];
298  m_meRate[refME]->setBinContent(bin,trigRate);
299 
300  }else{
301  int bin = m_meRate[refME]->getTH1()->FindBin(m_currentGTLS);
302  int trigPS = currentPFTech[bit];
303  double trigRate = (double) trigPS*m_l1Rate[refME];
304  m_meRate[refME]->setBinContent(bin,trigRate);
305  }
306  }
307  }
308 }
309 
310 
311 //_____________________________________________________________________
312 void L1TBPTX::analyze(const Event & iEvent, const EventSetup & eventSetup){
313 
314  if(m_verbose){cout << "[L1TBPTX] Called analyze." << endl;}
315 
316  // We only start analyzing if current LS is still valid
317  if(m_currentLSValid){
318 
319  if(m_verbose){cout << "[L1TBPTX] -> m_currentLSValid=" << m_currentLSValid << endl;}
320 
321  // Retriving information from GT
322  edm::Handle<L1GlobalTriggerEvmReadoutRecord> gtEvmReadoutRecord;
323  iEvent.getByToken(m_l1GtEvmSource, gtEvmReadoutRecord);
324 
325  // Determining beam mode and fill number
326  if(gtEvmReadoutRecord.isValid()){
327 
328  const L1GtfeExtWord& gtfeEvmWord = gtEvmReadoutRecord->gtfeWord();
329  unsigned int lhcBeamMode = gtfeEvmWord.beamMode(); // Updating beam mode
330 
331  if(m_verbose){cout << "[L1TBPTX] Beam mode: "<< lhcBeamMode << endl;}
332 
333  if(lhcBeamMode==RAMP || lhcBeamMode==FLATTOP || lhcBeamMode==SQUEEZE || lhcBeamMode==ADJUST || lhcBeamMode==STABLE){
334 
335  if(m_lhcFill==0){
336 
337  if(m_verbose){cout << "[L1TBPTX] No valid bunch structure yet retrived. Attemptting to retrive..." << endl;}
338 
339  m_lhcFill = gtfeEvmWord.lhcFillNumber(); // Getting LHC Fill Number from GT
340 
341  getBeamConfOMDS(); // Getting Beam Configuration from OMDS
342 
343  // We are between RAMP and STABLE so there should be some colliding bunches
344  // in the machine. If 0 colliding bunched are found might be due to a delay
345  // of the update of the database. So we declare this LS as invalid and try
346  // again on the next one.
347  if(m_beamConfig.nCollidingBunches<=0){
348  m_lhcFill=0;
349  m_currentLSValid=false;
350  }
351  }
352  }
353  else{m_currentLSValid=false;}
354 
355  }else{
356  int eCount = m_ErrorMonitor->getTH1()->GetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT);
357  eCount++;
358  m_ErrorMonitor->getTH1()->SetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT,eCount);
359  }
360  }
361 
362  //______________________________________________________________________________
363  // If current LS is valid and Beam Configuration is Valid we analyse this event
364  //______________________________________________________________________________
365  if(m_currentLSValid && m_beamConfig.isValid()){
366 
367  if(m_verbose){cout << "Current event in valid LS and beam config" << endl;}
368 
369  // Getting Final Decision Logic (FDL) Data from GT
370  edm::Handle<L1GlobalTriggerReadoutRecord> gtReadoutRecordData;
371  iEvent.getByToken(m_l1GtDataDaqInputTag, gtReadoutRecordData);
372 
373  if(gtReadoutRecordData.isValid()){
374 
375  const vector<L1GtFdlWord>& gtFdlVectorData = gtReadoutRecordData->gtFdlVector();
376 
377  // Getting the index for the fdl data for this event
378  int eventFDL=0;
379  for(unsigned int i=0; i<gtFdlVectorData.size(); i++){
380  if(gtFdlVectorData[i].bxInEvent()==0){eventFDL=i; break;}
381  }
382 
383  m_currentPrescalesIndex = gtFdlVectorData[eventFDL].gtPrescaleFactorIndexAlgo();
384 
385  for(unsigned i=0; i<m_monitorBits.size(); i++){
386 
387  TString triggerName = "";
388  bool isAlgo = m_monitorBits[i].getParameter<bool>("bitType");
389  int bit = m_monitorBits[i].getParameter<int> ("bitNumber");
390  int offset = m_monitorBits[i].getParameter<int> ("bitOffset");
391 
392  if(isAlgo){triggerName = "algo_"+bit;}
393  else {triggerName = "tech_"+bit;}
394 
395  int evBxStart = -2;
396  int evBxEnd = 2;
397 
398  if(offset<0){evBxStart+=-1*offset;}
399  if(offset>0){evBxEnd +=-1*offset;}
400 
401  for(unsigned a=0; a<gtFdlVectorData.size(); a++){
402 
403  int testBx = gtFdlVectorData[a].localBxNr()-offset;
404  bool lhcBxFilled = m_beamConfig.beam1[testBx] && m_beamConfig.beam2[testBx];
405  bool algoFired = false;
406 
407  if(isAlgo){
408  if(gtFdlVectorData[a].gtDecisionWord()[bit]){algoFired=true;}
409 
410  }
411  else{
412  if(gtFdlVectorData[a].gtTechnicalTriggerWord()[bit]){algoFired=true;}
413  }
414 
415  if(lhcBxFilled) {m_effDenominator[triggerName]++;}
416  if(lhcBxFilled && algoFired){m_effNumerator [triggerName]++;}
417 
418  if(algoFired) {m_missFireNumerator[triggerName]++;}
419  if(algoFired && !lhcBxFilled){m_missFireNumerator[triggerName]++;}
420 
421  }
422  }
423  }
424  }
425 
426  //______________________________________________________________________________
427  // Rate calculation
428  //______________________________________________________________________________
429  edm::Handle<Level1TriggerScalersCollection> triggerScalers;
430  iEvent.getByToken(m_scalersSource,triggerScalers);
431 
432  if(triggerScalers.isValid()){
433 
434  Level1TriggerScalersCollection::const_iterator itL1TScalers = triggerScalers->begin();
435  Level1TriggerRates trigRates(*itL1TScalers,iEvent.id().run());
436 
437  m_currentGTLS= (*itL1TScalers).lumiSegmentNr();
438 
439  for(unsigned i=0; i<m_monitorRates.size(); i++){
440 
441  bool isAlgo = m_monitorRates[i].getParameter<bool>("bitType");
442  int bit = m_monitorRates[i].getParameter<int> ("bitNumber");
443 
444  pair<bool,int> refTrig = pair<bool,int>(isAlgo,bit);
445 
446  if(isAlgo){m_l1Rate[refTrig] = trigRates.gtAlgoCountsRate()[bit];}
447  else {m_l1Rate[refTrig] = trigRates.gtTechCountsRate()[bit];}
448  }
449  }
450 }
451 
452 //_____________________________________________________________________
453 // Method: getBunchStructureOMDS
454 // Description: Attempt to retrive Beam Configuration from OMDS and if
455 // we find error handle it
456 //_____________________________________________________________________
457 void L1TBPTX::getBeamConfOMDS(){
458 
459  if(m_verbose){cout << "[L1TBPTX] Called getBeamConfOMDS()" << endl;}
460 
461  //Getting connection paremeters
462  string oracleDB = m_parameters.getParameter<string>("oracleDB");
463  string pathCondDB = m_parameters.getParameter<string>("pathCondDB");
464 
465  // Connecting to OMDS
466  L1TOMDSHelper myOMDSHelper = L1TOMDSHelper();
467  int conError;
468  myOMDSHelper.connect(oracleDB,pathCondDB,conError);
469 
470  if(conError == L1TOMDSHelper::NO_ERROR){
471 
472  if(m_verbose){cout << "[L1TBPTX] Connected to DB with no error." << endl;}
473 
474  int errorRetrive;
475  m_beamConfig = myOMDSHelper.getBeamConfiguration(m_lhcFill,errorRetrive);
476 
477  if(errorRetrive == L1TOMDSHelper::NO_ERROR){
478  if(m_verbose){
479  cout << "[L1TBPTX] Retriving LHC Bunch Structure: NO_ERROR" << endl;
480  cout << "[L1TSync] -> LHC Bunch Structure valid=" << m_beamConfig.m_valid << " nBunches=" << m_beamConfig.nCollidingBunches << endl;
481  }
482  }
483  else if(errorRetrive == L1TOMDSHelper::WARNING_DB_QUERY_FAILED){
484  if(m_verbose){cout << "[L1TBPTX] Retriving LHC Bunch Structure: WARNING_DB_QUERY_FAILED" << endl;}
485 
486  int eCount = m_ErrorMonitor->getTH1()->GetBinContent(WARNING_DB_QUERY_FAILED);
487  eCount++;
488  m_ErrorMonitor->getTH1()->SetBinContent(WARNING_DB_QUERY_FAILED,eCount);
489  }
490  else if(errorRetrive == L1TOMDSHelper::WARNING_DB_INCORRECT_NBUNCHES){
491  if(m_verbose){cout << "[L1TBPTX] Retriving LHC Bunch Structure: WARNING_DB_INCORRECT_NBUNCHES" << endl;}
492 
493  int eCount = m_ErrorMonitor->getTH1()->GetBinContent(WARNING_DB_INCORRECT_NBUNCHES);
494  eCount++;
495  m_ErrorMonitor->getTH1()->SetBinContent(WARNING_DB_INCORRECT_NBUNCHES,eCount);
496  }
497  else{
498  if(m_verbose){cout << "[L1TBPTX] Retriving LHC Bunch Structure: UNKNOWN" << endl;}
499  int eCount = m_ErrorMonitor->getTH1()->GetBinContent(UNKNOWN);
500  eCount++;
501  m_ErrorMonitor->getTH1()->SetBinContent(UNKNOWN,eCount);
502  }
503 
504  }
505  else if(conError == L1TOMDSHelper::WARNING_DB_CONN_FAILED){
506  if(m_verbose){cout << "[L1TBPTX] Connection to DB: WARNING_DB_CONN_FAILED" << endl;}
507  int eCount = m_ErrorMonitor->getTH1()->GetBinContent(WARNING_DB_CONN_FAILED);
508  eCount++;
509  m_ErrorMonitor->getTH1()->SetBinContent(WARNING_DB_CONN_FAILED,eCount);
510  }
511  else{
512  if(m_verbose){cout << "[L1TBPTX] Connection to DB: UNKNOWN" << endl;}
513  int eCount = m_ErrorMonitor->getTH1()->GetBinContent(UNKNOWN);
514  eCount++;
515  m_ErrorMonitor->getTH1()->SetBinContent(UNKNOWN,eCount);
516  }
517 }
518 
519 //_____________________________________________________________________
520 // Method: doFractionInSync
521 // Description: Produce plot with the fraction of in sync trigger for
522 // LS blocks with enough statistics.
523 // Variable: iForce - Forces closing of all blocks and calculation of
524 // the respective fractions
525 // Variable: iBad - (Only works with iForce=true) Forces the current
526 // all current blocks to be marked as bad
527 //_____________________________________________________________________
528 void L1TBPTX::doFractionInSync(bool iForce,bool iBad){
529 
530 }
531 
532 
533 //_____________________________________________________________________
534 // Method: certifyLSBlock
535 // Description: Fill the trigger certification plot by blocks
536 // Variable: iTrigger - Which trigger to certify
537 // Variable: iInitLs - Blocks initial LS
538 // Variable: iEndLs - Blocks end LS
539 // Variable: iValue - Value to be used to fill
540 //_____________________________________________________________________
541 void L1TBPTX::certifyLSBlock(string iTrigger, int iInitLs, int iEndLs ,float iValue){
542 
543 }
edm::EventID::run
RunNumber_t run() const
Definition: EventID.h:39
edm::LuminosityBlockBase::id
LuminosityBlockID id() const
Definition: LuminosityBlockBase.h:48
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
L1TBPTX::analyze
void analyze(const edm::Event &e, const edm::EventSetup &c)
Definition: L1TBPTX.cc:312
i
int i
Definition: DBlmapReader.cc:9
L1TBPTX::doFractionInSync
void doFractionInSync(bool iForce=false, bool iBad=false)
Definition: L1TBPTX.cc:528
L1TBPTX::endLuminosityBlock
virtual void endLuminosityBlock(edm::LuminosityBlock const &lumiBlock, edm::EventSetup const &c)
Definition: L1TBPTX.cc:235
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:462
L1TBPTX::beginLuminosityBlock
virtual void beginLuminosityBlock(edm::LuminosityBlock const &lumiBlock, edm::EventSetup const &c)
Definition: L1TBPTX.cc:203
pat::UNKNOWN
0: Unidentified isolated particle
Definition: ParticleCode.h:19
TrackValidation_cff.pset
tuple pset
Definition: TrackValidation_cff.py:374
MonitorElement::setBinLabel
void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:920
ecalcalib_dqm_sourceclient-live_cfg.algo
tuple algo
Definition: ecalcalib_dqm_sourceclient-live_cfg.py:65
L1TBPTX::L1TBPTX
L1TBPTX(const edm::ParameterSet &ps)
Definition: L1TBPTX.cc:32
CItAlgo
AlgorithmMap::const_iterator CItAlgo
iterators through map containing the algorithms
Definition: L1GtTriggerMenuFwd.h:38
Level1TriggerRates::gtAlgoCountsRate
std::vector< double > gtAlgoCountsRate() const
Definition: Level1TriggerRates.h:127
L1TBPTX::dqmBeginRun
virtual void dqmBeginRun(const edm::Run &, const edm::EventSetup &)
Definition: L1TBPTX.cc:196
L1TBPTX::~L1TBPTX
virtual ~L1TBPTX()
Definition: L1TBPTX.cc:68
iEvent
int iEvent
Definition: GenABIO.cc:230
L1TBPTX::bookHistograms
virtual void bookHistograms(DQMStore::IBooker &ibooker, const edm::Run &, const edm::EventSetup &) override
BeginRun.
Definition: L1TBPTX.cc:73
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:75
L1TBPTX::certifyLSBlock
void certifyLSBlock(std::string iTrigger, int iInitLs, int iEndLs, float iValue)
Definition: L1TBPTX.cc:541
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:276
L1GtPrescaleFactors::gtPrescaleFactors
const std::vector< std::vector< int > > & gtPrescaleFactors() const
get the prescale factors by reference
Definition: L1GtPrescaleFactors.h:49
L1GtfeExtWord::lhcFillNumber
const cms_uint32_t lhcFillNumber() const
Definition: L1GtfeExtWord.cc:227
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:56
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
edm::LuminosityBlockID::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: LuminosityBlockID.h:42
hltrates_dqm_sourceclient-live_cfg.offset
tuple offset
Definition: hltrates_dqm_sourceclient-live_cfg.py:81
edm::EventBase::id
edm::EventID id() const
Definition: EventBase.h:59
a
double a
Definition: hdecay.h:121
relval_steps.menu
list menu
Definition: relval_steps.py:990
L1TBPTX::getBeamConfOMDS
void getBeamConfOMDS()
Definition: L1TBPTX.cc:457
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:145
L1GtTriggerMenu::gtTechnicalTriggerMap
const AlgorithmMap & gtTechnicalTriggerMap() const
get / set the technical trigger map
Definition: L1GtTriggerMenu.h:255
L1GtTriggerMenu::gtAlgorithmAliasMap
const AlgorithmMap & gtAlgorithmAliasMap() const
get / set the algorithm map (by alias)
Definition: L1GtTriggerMenu.h:248
edm::ESHandleBase::isValid
bool isValid() const
Definition: ESHandle.h:47
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:947
L1GtfeExtWord::beamMode
const cms_uint16_t beamMode() const
Definition: L1GtfeExtWord.cc:252
edm::Run
Definition: Run.h:43
Generated for CMSSW Reference Manual by doxygen 1.8.5