CMS 3D CMS Logo
L1GetHistLimits.cc
Go to the documentation of this file.
1 
15 // this class header
16 #include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GetHistLimits.h"
17 
18 // system include files
19 #include <iostream>
20 #include <iomanip>
21 #include <string>
22 
23 // user include files
24 #include "L1Trigger/GlobalTriggerAnalyzer/interface/L1PhiConversion.h"
25 #include "DataFormats/Math/interface/normalizedPhi.h"
26 
27 
28 #include "DataFormats/L1GlobalCaloTrigger/interface/L1GctEtMiss.h"
29 #include "DataFormats/L1GlobalCaloTrigger/interface/L1GctEtTotal.h"
30 #include "DataFormats/L1GlobalCaloTrigger/interface/L1GctEtHad.h"
31 
32 #include "FWCore/Framework/interface/ESHandle.h"
33 #include "FWCore/MessageLogger/interface/MessageLogger.h"
34 
35 // constructor
36 L1GetHistLimits::L1GetHistLimits(const edm::EventSetup& evSetup) :
37  m_evSetup(evSetup) {
38 
39  //
40 
41 }
42 
43 // destructor
44 L1GetHistLimits::~L1GetHistLimits() {
45 
46  // empty
47 
48 }
49 
50 void L1GetHistLimits::getHistLimits(const L1GtObject& l1GtObject,
51  const std::string& quantity) {
52 
53  m_l1HistLimits.nrBins = 0;
54  m_l1HistLimits.lowerBinValue = 0;
55  m_l1HistLimits.upperBinValue = 0;
56  m_l1HistLimits.binThresholds.clear();
57 
58 
59  // number of objects is independent of the object type
60  // and hardcoded in the actual version
61  if (quantity == "NrObjects") {
62 
63  m_l1HistLimits.nrBins = 15;
64  m_l1HistLimits.lowerBinValue = -0.5;
65  m_l1HistLimits.upperBinValue = 14.5;
66 
67  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
68 
69  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
70  m_l1HistLimits.binThresholds[iBin] = m_l1HistLimits.lowerBinValue
71  + iBin * (m_l1HistLimits.upperBinValue
72  - m_l1HistLimits.lowerBinValue)
73  / m_l1HistLimits.nrBins;
74 
75  }
76 
77  // set last bin upper edge
78  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
79  = m_l1HistLimits.upperBinValue;
80 
81  return;
82 
83  }
84 
85  switch (l1GtObject) {
86  case Mu: {
87 
88  if (quantity == "PT") {
89 
90  edm::ESHandle<L1MuTriggerPtScale> muPtScale;
91  m_evSetup.get<L1MuTriggerPtScaleRcd>().get(muPtScale);
92 
93  m_l1HistLimits.nrBins = muPtScale->getPtScale()->getNBins();
94  m_l1HistLimits.lowerBinValue
95  = muPtScale->getPtScale()->getScaleMin();
96  m_l1HistLimits.upperBinValue
97  = muPtScale->getPtScale()->getScaleMax();
98 
99  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
100 
101  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
102  m_l1HistLimits.binThresholds[iBin]
103  = muPtScale->getPtScale()->getValue(iBin);
104 
105  }
106 
107  // last limit for muon is set too high (10^6) - resize the last bin
108 
109  float lastBinSize = m_l1HistLimits.upperBinValue
110  - m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins - 1];
111 
112  // limit the size of the last bin to maximum 200 GeV
113  float maxLaxtBinsize = 200;
114  if (lastBinSize >= maxLaxtBinsize) {
115  m_l1HistLimits.upperBinValue
116  = m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins - 1]
117  + 2.* (m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins - 1]
118  - m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins - 2]);
119  LogDebug("L1GetHistLimits")
120  << "\n L1ExtraMuon: PT histogram"
121  << "\nm_l1HistLimits.upperBinValue truncated to = "
122  << m_l1HistLimits.upperBinValue << std::endl;
123  }
124 
125  // set last bin upper edge
126  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
127  = m_l1HistLimits.upperBinValue;
128 
129  } else if (quantity == "eta" || quantity == "phi") {
130  edm::ESHandle<L1MuTriggerScales> muScales;
131  m_evSetup.get<L1MuTriggerScalesRcd>().get(muScales);
132 
133  if (quantity == "eta") {
134  // eta scale defined for positive values - need to be symmetrized
135  int histNrBinsHalf = muScales->getGMTEtaScale()->getNBins();
136  m_l1HistLimits.lowerBinValue
137  = muScales->getGMTEtaScale()->getScaleMin();
138  m_l1HistLimits.upperBinValue
139  = muScales->getGMTEtaScale()->getScaleMax();
140 
141  m_l1HistLimits.nrBins = 2 * histNrBinsHalf;
142  m_l1HistLimits.lowerBinValue
143  = -m_l1HistLimits.upperBinValue;
144 
145  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
146 
147  int iBin = 0;
148  for (int j = histNrBinsHalf; j > 0; j--, iBin++) {
149  m_l1HistLimits.binThresholds[iBin] = (-1)
150  * muScales->getGMTEtaScale()->getValue(j);
151  }
152  for (int j = 0; j <= histNrBinsHalf; j++, iBin++) {
153  m_l1HistLimits.binThresholds[iBin]
154  = muScales->getGMTEtaScale()->getValue(j);
155  }
156 
157  // set last bin upper edge
158  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
159  = m_l1HistLimits.upperBinValue;
160 
161  } else {
162  m_l1HistLimits.nrBins = muScales->getPhiScale()->getNBins();
163  m_l1HistLimits.lowerBinValue = rad2deg(
164  muScales->getPhiScale()->getScaleMin());
165  m_l1HistLimits.upperBinValue = rad2deg(
166  muScales->getPhiScale()->getScaleMax());
167 
168  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins
169  + 1);
170 
171  for (int iBin = 0; iBin <= m_l1HistLimits.nrBins; iBin++) {
172  m_l1HistLimits.binThresholds[iBin] = rad2deg(
173  muScales->getPhiScale()->getValue(iBin));
174  }
175 
176  // set last bin upper edge
177  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
178  = m_l1HistLimits.upperBinValue;
179 
180  }
181 
182  }
183 
184  }
185  break;
186  case NoIsoEG:
187  case IsoEG: {
188  // common scales for NoIsoEG and IsoEG
189  if (quantity == "ET") {
190  edm::ESHandle<L1CaloEtScale> emScale;
191  m_evSetup.get<L1EmEtScaleRcd>().get(emScale);
192 
193  std::vector<double> emThresholds = emScale->getThresholds();
194  m_l1HistLimits.nrBins = emThresholds.size();
195  m_l1HistLimits.lowerBinValue = emThresholds.at(0);
196 
197  // FIXME high edge retrieval in the scale definition
198  // now, last bin has the same width like the last but one
199  m_l1HistLimits.upperBinValue
200  = emThresholds[m_l1HistLimits.nrBins - 1]
201  + (emThresholds[m_l1HistLimits.nrBins - 1]
202  - emThresholds[m_l1HistLimits.nrBins - 2]);
203 
204  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
205 
206  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
207  m_l1HistLimits.binThresholds[iBin]
208  = static_cast<float>(emThresholds[iBin]);
209 
210  }
211 
212  // set last bin upper edge
213  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
214  = m_l1HistLimits.upperBinValue;
215 
216  } else if (quantity == "eta" || quantity == "phi") {
217  edm::ESHandle<L1CaloGeometry> caloGeomESH;
218  m_evSetup.get<L1CaloGeometryRecord>().get(caloGeomESH);
219  const L1CaloGeometry* caloGeomScales = caloGeomESH.product();
220 
221  if (quantity == "eta") {
222  m_l1HistLimits.nrBins
223  = 2 * (caloGeomScales->numberGctCentralEtaBinsPerHalf()
224  + caloGeomScales->numberGctForwardEtaBinsPerHalf());
225  m_l1HistLimits.lowerBinValue
226  = caloGeomScales->globalEtaBinLowEdge(0);
227  m_l1HistLimits.upperBinValue
228  = caloGeomScales->globalEtaBinHighEdge(
229  m_l1HistLimits.nrBins - 1);
230 
231  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
232 
233  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
234  m_l1HistLimits.binThresholds[iBin]
235  = caloGeomScales->globalEtaBinLowEdge(iBin);
236  }
237 
238  // set last bin upper edge
239  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
240  = m_l1HistLimits.upperBinValue;
241 
242 
243 
244  } else {
245 
246  m_l1HistLimits.nrBins
247  = caloGeomScales->numberGctEmJetPhiBins();
248  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins
249  + 1);
250 
251  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
252 
253  m_l1HistLimits.binThresholds[iBin] = rad2deg(
254  caloGeomScales->emJetPhiBinLowEdge(iBin));
255 
256  // treat correctly the 10 deg anti-clockwise rotation
257  if (rad2deg(caloGeomScales->emJetPhiBinHighEdge(iBin))
258  < m_l1HistLimits.binThresholds[iBin]) {
259  m_l1HistLimits.binThresholds[iBin]
260  = m_l1HistLimits.binThresholds[iBin] - 360.;
261  }
262 
263  }
264 
265  m_l1HistLimits.lowerBinValue
266  = m_l1HistLimits.binThresholds[0];
267 
268  // last bin upper limit
269  m_l1HistLimits.upperBinValue = rad2deg(
270  caloGeomScales->emJetPhiBinHighEdge(
271  m_l1HistLimits.nrBins - 1));
272 
273  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
274  = m_l1HistLimits.upperBinValue;
275 
276  }
277 
278  }
279 
280  }
281  break;
282  case CenJet:
283  case ForJet:
284  case TauJet: {
285  // common scales for all jets
286  if (quantity == "ET") {
287  edm::ESHandle<L1CaloEtScale> jetScale;
288  m_evSetup.get<L1JetEtScaleRcd>().get(jetScale);
289 
290  std::vector<double> jetThresholds = jetScale->getThresholds();
291  m_l1HistLimits.nrBins = jetThresholds.size();
292  m_l1HistLimits.lowerBinValue = jetThresholds.at(0);
293 
294  // FIXME high edge retrieval in the scale definition
295  // now, last bin has the same width like the last but one
296  m_l1HistLimits.upperBinValue
297  = jetThresholds[m_l1HistLimits.nrBins - 1]
298  + (jetThresholds[m_l1HistLimits.nrBins - 1]
299  - jetThresholds[m_l1HistLimits.nrBins - 2]);
300 
301  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
302 
303  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
304  m_l1HistLimits.binThresholds[iBin]
305  = static_cast<float>(jetThresholds[iBin]);
306 
307  }
308 
309  // set last bin upper edge
310  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
311  = m_l1HistLimits.upperBinValue;
312 
313  } else if (quantity == "eta" || quantity == "phi") {
314  edm::ESHandle<L1CaloGeometry> caloGeomESH;
315  m_evSetup.get<L1CaloGeometryRecord>().get(caloGeomESH);
316  const L1CaloGeometry* caloGeomScales = caloGeomESH.product();
317 
318  if (quantity == "eta") {
319  m_l1HistLimits.nrBins
320  = 2 * (caloGeomScales->numberGctCentralEtaBinsPerHalf()
321  + caloGeomScales->numberGctForwardEtaBinsPerHalf());
322  m_l1HistLimits.lowerBinValue
323  = caloGeomScales->globalEtaBinLowEdge(0);
324  m_l1HistLimits.upperBinValue
325  = caloGeomScales->globalEtaBinHighEdge(
326  m_l1HistLimits.nrBins - 1);
327 
328  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
329 
330  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
331  m_l1HistLimits.binThresholds[iBin]
332  = caloGeomScales->globalEtaBinLowEdge(iBin);
333  }
334 
335  // set last bin upper edge
336  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
337  = m_l1HistLimits.upperBinValue;
338 
339  } else {
340 
341  m_l1HistLimits.nrBins
342  = caloGeomScales->numberGctEmJetPhiBins();
343  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins
344  + 1);
345 
346  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
347 
348  m_l1HistLimits.binThresholds[iBin] = rad2deg(
349  caloGeomScales->emJetPhiBinLowEdge(iBin));
350 
351  // treat correctly the 10 deg anti-clockwise rotation
352  if (rad2deg(caloGeomScales->emJetPhiBinHighEdge(iBin))
353  < m_l1HistLimits.binThresholds[iBin]) {
354  m_l1HistLimits.binThresholds[iBin]
355  = m_l1HistLimits.binThresholds[iBin] - 360.;
356  }
357 
358  }
359 
360  m_l1HistLimits.lowerBinValue
361  = m_l1HistLimits.binThresholds[0];
362 
363  // last bin upper limit
364  m_l1HistLimits.upperBinValue = rad2deg(
365  caloGeomScales->emJetPhiBinHighEdge(
366  m_l1HistLimits.nrBins - 1));
367 
368  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
369  = m_l1HistLimits.upperBinValue;
370 
371  }
372 
373  }
374  }
375  break;
376  case ETM: {
377  if (quantity == "ET") {
378 
379  edm::ESHandle<L1CaloEtScale> etMissScale;
380  m_evSetup.get<L1JetEtScaleRcd>().get(etMissScale);
381 
382  const double etSumLSB = etMissScale->linearLsb() ;
383 
384  m_l1HistLimits.nrBins = L1GctEtMiss::kEtMissMaxValue;
385 
386  m_l1HistLimits.lowerBinValue = 0;
387  m_l1HistLimits.upperBinValue = (m_l1HistLimits.nrBins + 1)
388  * etSumLSB;
389 
390  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
391 
392  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
393  m_l1HistLimits.binThresholds[iBin] = iBin * etSumLSB;
394 
395  }
396 
397  // set last bin upper edge
398  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
399  = m_l1HistLimits.upperBinValue;
400 
401  } else if (quantity == "eta" || quantity == "phi") {
402  edm::ESHandle<L1CaloGeometry> caloGeomESH;
403  m_evSetup.get<L1CaloGeometryRecord>().get(caloGeomESH);
404  const L1CaloGeometry* caloGeomScales = caloGeomESH.product();
405 
406  if (quantity == "eta") {
407 
408  // do nothing, eta is not defined for ETM
409 
410  } else {
411  m_l1HistLimits.nrBins
412  = caloGeomScales->numberGctEtSumPhiBins();
413  m_l1HistLimits.lowerBinValue = rad2deg(
414  caloGeomScales->etSumPhiBinLowEdge(0));
415  m_l1HistLimits.upperBinValue = rad2deg(
416  caloGeomScales->etSumPhiBinHighEdge(
417  m_l1HistLimits.nrBins - 1));
418 
419  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins
420  + 1);
421 
422  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
423  m_l1HistLimits.binThresholds[iBin] = rad2deg(
424  caloGeomScales->etSumPhiBinLowEdge(iBin));
425 
426  }
427 
428  // last bin upper limit
429  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
430  = m_l1HistLimits.upperBinValue;
431 
432  }
433 
434  }
435 
436  }
437  break;
438  case ETT: {
439  if (quantity == "ET") {
440 
441  edm::ESHandle<L1CaloEtScale> etMissScale;
442  m_evSetup.get<L1JetEtScaleRcd>().get(etMissScale);
443 
444  const double etSumLSB = etMissScale->linearLsb() ;
445 
446  m_l1HistLimits.nrBins = L1GctEtTotal::kEtTotalMaxValue;
447 
448  m_l1HistLimits.lowerBinValue = 0;
449  m_l1HistLimits.upperBinValue = (m_l1HistLimits.nrBins + 1)
450  * etSumLSB;
451 
452  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
453 
454  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
455  m_l1HistLimits.binThresholds[iBin] = iBin * etSumLSB;
456 
457  }
458 
459  // set last bin upper edge
460  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
461  = m_l1HistLimits.upperBinValue;
462 
463  } else if (quantity == "eta" || quantity == "phi") {
464 
465  // do nothing, eta and phi are not defined for ETT
466 
467  }
468 
469  }
470  break;
471  case HTT: {
472  if (quantity == "ET") {
473 
474  edm::ESHandle< L1GctJetFinderParams > jetFinderParams ;
475  m_evSetup.get< L1GctJetFinderParamsRcd >().get( jetFinderParams ) ;
476  double htSumLSB = jetFinderParams->getHtLsbGeV();
477 
478  m_l1HistLimits.nrBins = L1GctEtHad::kEtHadMaxValue;
479 
480  m_l1HistLimits.lowerBinValue = 0;
481  m_l1HistLimits.upperBinValue = (m_l1HistLimits.nrBins + 1)
482  * htSumLSB;
483 
484  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
485 
486  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
487  m_l1HistLimits.binThresholds[iBin] = iBin * htSumLSB;
488 
489  }
490 
491  // set last bin upper edge
492  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
493  = m_l1HistLimits.upperBinValue;
494 
495  } else if (quantity == "eta" || quantity == "phi") {
496 
497  // do nothing, eta and phi are not defined for HTT
498 
499  }
500  }
501  break;
502  case HTM: {
503  if (quantity == "ET") {
504  edm::ESHandle<L1CaloEtScale> htMissScale;
505  m_evSetup.get<L1HtMissScaleRcd>().get(htMissScale);
506 
507  const std::vector<double>& htThresholds =
508  htMissScale->getThresholds();
509  m_l1HistLimits.nrBins = htThresholds.size();
510  m_l1HistLimits.lowerBinValue = htThresholds[0];
511 
512  // FIXME high edge retrieval in the scale definition
513  // now, last bin has the same width like the last but one
514  m_l1HistLimits.upperBinValue
515  = htThresholds[m_l1HistLimits.nrBins - 1]
516  + (htThresholds[m_l1HistLimits.nrBins - 1]
517  - htThresholds[m_l1HistLimits.nrBins - 2]);
518 
519  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
520 
521  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
522  m_l1HistLimits.binThresholds[iBin]
523  = static_cast<float>(htThresholds[iBin]);
524 
525  }
526 
527  // set last bin upper edge
528  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
529  = m_l1HistLimits.upperBinValue;
530 
531  } else if (quantity == "eta" || quantity == "phi") {
532  edm::ESHandle<L1CaloGeometry> caloGeomESH;
533  m_evSetup.get<L1CaloGeometryRecord>().get(caloGeomESH);
534  const L1CaloGeometry* caloGeomScales = caloGeomESH.product();
535 
536  if (quantity == "eta") {
537 
538  // do nothing, eta is not defined for HTM
539 
540  } else {
541  m_l1HistLimits.nrBins
542  = caloGeomScales->numberGctHtSumPhiBins();
543  m_l1HistLimits.lowerBinValue = rad2deg(
544  caloGeomScales->htSumPhiBinLowEdge(0));
545  m_l1HistLimits.upperBinValue = rad2deg(
546  caloGeomScales->htSumPhiBinHighEdge(
547  m_l1HistLimits.nrBins - 1));
548 
549  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins
550  + 1);
551 
552  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
553  m_l1HistLimits.binThresholds[iBin] = rad2deg(
554  caloGeomScales->htSumPhiBinLowEdge(iBin));
555 
556  }
557 
558  // last bin upper limit
559  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
560  = m_l1HistLimits.upperBinValue;
561 
562  }
563 
564  }
565  }
566  break;
567  case JetCounts: {
568 
569  }
570  break;
571  case HfBitCounts: {
572  // there are no scales for HfBitCounts, so one implements a fixed scale
573  // use same values as GCT for 3 bits
574  const unsigned int R3BINS = 8;
575  const float R3MIN = -0.5;
576  const float R3MAX = 7.5;
577 
578  m_l1HistLimits.nrBins
579  = R3BINS;
580  m_l1HistLimits.lowerBinValue
581  = R3MIN;
582  m_l1HistLimits.upperBinValue
583  = R3MAX;
584 
585  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins
586  + 1);
587 
588  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
589  m_l1HistLimits.binThresholds[iBin]
590  = R3MIN + iBin*(R3MAX - R3MIN)/R3BINS;
591 
592  }
593 
594  // last bin upper limit
595  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
596  = m_l1HistLimits.upperBinValue;
597 
598 
599 
600  }
601  break;
602  case HfRingEtSums: {
603  if (quantity == "ET") {
604  edm::ESHandle<L1CaloEtScale> hfRingEtScale;
605  m_evSetup.get<L1HfRingEtScaleRcd>().get(hfRingEtScale);
606 
607  const std::vector<double>& hfRingEtThresholds =
608  hfRingEtScale->getThresholds();
609  m_l1HistLimits.nrBins = hfRingEtThresholds.size();
610  m_l1HistLimits.lowerBinValue = hfRingEtThresholds[0];
611 
612  // FIXME high edge retrieval in the scale definition
613  // now, last bin has the same width like the last but one
614  m_l1HistLimits.upperBinValue
615  = hfRingEtThresholds[m_l1HistLimits.nrBins - 1]
616  + (hfRingEtThresholds[m_l1HistLimits.nrBins - 1]
617  - hfRingEtThresholds[m_l1HistLimits.nrBins - 2]);
618 
619  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
620 
621  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
622  m_l1HistLimits.binThresholds[iBin]
623  = static_cast<float>(hfRingEtThresholds[iBin]);
624 
625  }
626 
627  // set last bin upper edge
628  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins]
629  = m_l1HistLimits.upperBinValue;
630 
631  } else if (quantity == "eta" || quantity == "phi") {
632 
633  // do nothing, eta and phi are not defined for HfRingEtSums
634  }
635  }
636  break;
637  case TechTrig:
638  case Castor:
639  case BPTX:
640  default: {
641 
642  // do nothing, for these cases ET/PT, eta and phi are not defined
643 
644  }
645  break;
646  }
647 
648 }
649 
650 const L1GetHistLimits::L1HistLimits& L1GetHistLimits::l1HistLimits(
651  const L1GtObject& l1GtObject, const std::string& quantity) {
652 
653  getHistLimits(l1GtObject, quantity);
654 
655  if (edm::isDebugEnabled()) {
656  LogDebug("L1GetHistLimits") << "\n Histogram limits for L1GtObject "
657  << l1GtObject << " and quantity " << quantity
658  << "\n Number of bins: " << m_l1HistLimits.nrBins
659  << "\n Lower limit of first bin: "
660  << m_l1HistLimits.lowerBinValue
661  << "\n Upper limit of last bin: "
662  << m_l1HistLimits.upperBinValue << std::endl;
663 
664  int binThreshSize = static_cast<int>(m_l1HistLimits.binThresholds.size());
665 
666  if (binThreshSize != (m_l1HistLimits.nrBins + 1)) {
667 
668  LogTrace("L1GetHistLimits")
669  << "\n Warning: inconsistent nrBins and binThresholds size"
670  << "\n Number of bins nrBins = " << m_l1HistLimits.nrBins
671  << "\n binThresholds size = " << binThreshSize
672  << "\n Please fix the L1GetLimits class.\n\n" << std::endl;
673 
674  }
675 
676  for (int iBin = 0; iBin < binThreshSize; ++iBin) {
677  LogTrace("L1GetHistLimits") << " Bin " << std::right
678  << std::setw(5) << iBin << ": "
679  << m_l1HistLimits.binThresholds[iBin] << std::endl;
680 
681  }
682  }
683 
684  return m_l1HistLimits;
685 
686 }
687 
688 
689 const L1GetHistLimits::L1HistLimits& L1GetHistLimits::l1HistLimits(
690  const L1GtObject& l1GtObject, const std::string& quantity,
691  const double histMinValue, const double histMaxValue) {
692 
693  getHistLimits(l1GtObject, quantity);
694 
695  bool foundLowerBinValue = false;
696  bool foundUpperBinValue = false;
697 
698  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
699  if (m_l1HistLimits.binThresholds[iBin] <= histMinValue) {
700  m_l1HistLimits.lowerBinValue = m_l1HistLimits.binThresholds[iBin];
701  foundLowerBinValue = true;
702  break;
703  }
704  }
705 
706  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
707  if (m_l1HistLimits.binThresholds[iBin] > histMaxValue) {
708  m_l1HistLimits.upperBinValue = m_l1HistLimits.binThresholds[iBin];
709  foundUpperBinValue = true;
710  break;
711  }
712  }
713 
714  if (foundLowerBinValue && foundUpperBinValue) {
715 
716  int countBins = -1;
717  std::vector<float> binThresh;
718  binThresh.reserve(m_l1HistLimits.binThresholds.size());
719 
720  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
721  if ((m_l1HistLimits.binThresholds[iBin] >= histMinValue)
722  && m_l1HistLimits.binThresholds[iBin] < histMaxValue) {
723  m_l1HistLimits.upperBinValue
724  = m_l1HistLimits.binThresholds[iBin];
725 
726  countBins++;
727  binThresh.push_back(m_l1HistLimits.binThresholds[iBin]);
728 
729  }
730  }
731 
732  m_l1HistLimits.nrBins = countBins;
733  m_l1HistLimits.binThresholds.clear();
734  m_l1HistLimits.binThresholds = binThresh;
735 
736  // FIXME last bin untested.
737 
738  } else {
739  m_l1HistLimits.nrBins = 0;
740  m_l1HistLimits.lowerBinValue = 0;
741  m_l1HistLimits.upperBinValue = 0;
742  m_l1HistLimits.binThresholds.clear();
743 
744  LogDebug("L1GetHistLimits") << "\n Histogram limits for L1GtObject"
745  << l1GtObject << " and quantity " << quantity
746  << " within the required range [" << histMinValue << ", "
747  << histMaxValue << "] not found."
748  << "\n The range is not included in the original histogram range."
749  << std::endl;
750 
751  return m_l1HistLimits;
752 
753  }
754 
755  if (edm::isDebugEnabled()) {
756  LogDebug("L1GetHistLimits") << "\n Histogram limits for L1GtObject"
757  << l1GtObject << " and quantity " << quantity
758  << "\n Number of bins: " << m_l1HistLimits.nrBins
759  << "\n Lower limit of first bin: "
760  << m_l1HistLimits.lowerBinValue
761  << "\n Upper limit of last bin: "
762  << m_l1HistLimits.upperBinValue << std::endl;
763 
764  int binThreshSize = static_cast<int>(m_l1HistLimits.binThresholds.size());
765 
766  if (binThreshSize != (m_l1HistLimits.nrBins + 1)) {
767 
768  LogTrace("L1GetHistLimits")
769  << "\n Warning: inconsistent nrBins and binThresholds size"
770  << "\n Number of bins nrBins = " << m_l1HistLimits.nrBins
771  << "\n binThresholds size = " << binThreshSize
772  << "\n Please fix the L1GetLimits class.\n\n" << std::endl;
773 
774  }
775 
776  for (int iBin = 0; iBin < binThreshSize; ++iBin) {
777  LogTrace("L1GetHistLimits") << " Bin " << std::right
778  << std::setw(5) << iBin << ": "
779  << m_l1HistLimits.binThresholds[iBin] << std::endl;
780 
781  }
782  }
783 
784 
785  return m_l1HistLimits;
786 
787 }
788 
789 
790 const int L1GetHistLimits::l1HistNrBins(const L1GtObject& l1GtObject,
791  const std::string& quantity) {
792 
793  getHistLimits(l1GtObject, quantity);
794  return m_l1HistLimits.nrBins;
795 
796 }
797 
798 const double L1GetHistLimits::l1HistLowerBinValue(const L1GtObject& l1GtObject,
799  const std::string& quantity) {
800 
801  getHistLimits(l1GtObject, quantity);
802  return m_l1HistLimits.lowerBinValue;
803 
804 }
805 
806 const double L1GetHistLimits::l1HistUpperBinValue(const L1GtObject& l1GtObject,
807  const std::string& quantity) {
808 
809  getHistLimits(l1GtObject, quantity);
810  return m_l1HistLimits.upperBinValue;
811 
812 }
813 
814 const std::vector<float>& L1GetHistLimits::l1HistBinThresholds(
815  const L1GtObject& l1GtObject, const std::string& quantity) {
816 
817  getHistLimits(l1GtObject, quantity);
818  return m_l1HistLimits.binThresholds;
819 
820 }
LogDebug
#define LogDebug(id)
Definition: PFTrackAlgoTools.cc:503
L1CaloGeometry::globalEtaBinLowEdge
double globalEtaBinLowEdge(unsigned int globalEtaIndex) const
Definition: L1CaloGeometry.cc:156
edm::isDebugEnabled
bool isDebugEnabled()
Definition: MessageLogger.cc:71
L1CaloGeometry::numberGctForwardEtaBinsPerHalf
unsigned int numberGctForwardEtaBinsPerHalf() const
Definition: L1CaloGeometry.h:118
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:50
L1GetHistLimits::m_evSetup
const edm::EventSetup & m_evSetup
Definition: L1GetHistLimits.h:119
HTM
Definition: L1GtObject.h:39
L1GetHistLimits::m_l1HistLimits
L1HistLimits m_l1HistLimits
all limits for a histogram
Definition: L1GetHistLimits.h:122
L1CaloGeometry::numberGctHtSumPhiBins
unsigned int numberGctHtSumPhiBins() const
Definition: L1CaloGeometry.cc:505
L1MuTriggerPtScale::getPtScale
const L1MuScale * getPtScale() const
get the Pt scale
Definition: L1MuTriggerPtScale.h:71
L1CaloGeometry::htSumPhiBinLowEdge
double htSumPhiBinLowEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:331
L1GetHistLimits::l1HistUpperBinValue
const double l1HistUpperBinValue(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:806
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
ETM
Definition: L1GtObject.h:36
L1CaloGeometry::numberGctEtSumPhiBins
unsigned int numberGctEtSumPhiBins() const
Definition: L1CaloGeometry.h:113
L1GetHistLimits::l1HistBinThresholds
const std::vector< float > & l1HistBinThresholds(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:814
wplusjetsAnalysis_cfi.jetScale
jetScale
Definition: wplusjetsAnalysis_cfi.py:88
L1CaloGeometry::numberGctEmJetPhiBins
unsigned int numberGctEmJetPhiBins() const
Definition: L1CaloGeometry.h:111
L1GetHistLimits::l1HistNrBins
const int l1HistNrBins(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:790
L1CaloGeometry::numberGctCentralEtaBinsPerHalf
unsigned int numberGctCentralEtaBinsPerHalf() const
Definition: L1CaloGeometry.h:116
L1GctJetFinderParams::getHtLsbGeV
double getHtLsbGeV() const
Definition: L1GctJetFinderParams.h:38
L1CaloEtScale::linearLsb
double linearLsb() const
get LSB of linear input scale
Definition: L1CaloEtScale.h:53
L1GetHistLimits::~L1GetHistLimits
virtual ~L1GetHistLimits()
Definition: L1GetHistLimits.cc:44
HTT
Definition: L1GtObject.h:38
L1CaloEtScale::getThresholds
const std::vector< double > & getThresholds() const
get thresholds
Definition: L1CaloEtScale.h:65
R3BINS
const unsigned int R3BINS
Definition: L1TGCT.cc:44
L1MuTriggerScales::getPhiScale
const L1MuScale * getPhiScale() const
get the phi scale
Definition: L1MuTriggerScales.h:201
L1MuScale::getScaleMin
virtual float getScaleMin() const =0
get the lower edge of the first bin
L1MuScale::getNBins
virtual unsigned getNBins() const =0
get number of bins
LogTrace
#define LogTrace(id)
Definition: PFTrackAlgoTools.cc:504
L1GetHistLimits::L1HistLimits::binThresholds
std::vector< float > binThresholds
Definition: L1GetHistLimits.h:71
rad2deg
const double rad2deg(const double &)
convert phi from rad (-pi, pi] to deg (0, 360)
Definition: L1PhiConversion.cc:17
Mu
Definition: L1GtObject.h:30
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
L1CaloGeometry::globalEtaBinHighEdge
double globalEtaBinHighEdge(unsigned int globalEtaIndex) const
Definition: L1CaloGeometry.cc:176
L1CaloGeometry::etSumPhiBinLowEdge
double etSumPhiBinLowEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:302
tauVariables_cff.quantity
quantity
Definition: tauVariables_cff.py:10
ETT
Definition: L1GtObject.h:37
L1MuTriggerScales::getGMTEtaScale
const L1MuScale * getGMTEtaScale() const
get the GMT eta scale
Definition: L1MuTriggerScales.h:194
L1CaloGeometry::emJetPhiBinLowEdge
double emJetPhiBinLowEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:281
L1CaloGeometry::htSumPhiBinHighEdge
double htSumPhiBinHighEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:346
L1GetHistLimits::L1GetHistLimits
L1GetHistLimits(const edm::EventSetup &evSetup)
Definition: L1GetHistLimits.cc:36
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
R3MAX
const float R3MAX
Definition: L1TGCT.cc:46
L1MuScale::getScaleMax
virtual float getScaleMax() const =0
get the upper edge of the last bin
L1GetHistLimits::l1HistLowerBinValue
const double l1HistLowerBinValue(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:798
L1MuScale::getValue
virtual float getValue(unsigned i) const =0
get value of the underlying vector for bin i
L1CaloGeometry::emJetPhiBinHighEdge
double emJetPhiBinHighEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:288
L1CaloGeometry::etSumPhiBinHighEdge
double etSumPhiBinHighEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:309
R3MIN
const float R3MIN
Definition: L1TGCT.cc:45
L1GetHistLimits::l1HistLimits
const L1HistLimits & l1HistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:650
Generated for CMSSW Reference Manual by doxygen 1.8.11