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