CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Classes | Public Member Functions | Private Member Functions | Private Attributes
L1GetHistLimits Class Reference

#include <L1GetHistLimits.h>

Classes

struct  L1HistLimits
 

Public Member Functions

 L1GetHistLimits (const edm::EventSetup &evSetup)
 
const std::vector< float > & l1HistBinThresholds (const L1GtObject &l1GtObject, const std::string &quantity)
 
const L1HistLimits & l1HistLimits (const L1GtObject &l1GtObject, const std::string &quantity)
 
const L1HistLimits & l1HistLimits (const L1GtObject &l1GtObject, const std::string &quantity, const double histMinValue, const double histMaxValue)
 
const double l1HistLowerBinValue (const L1GtObject &l1GtObject, const std::string &quantity)
 
const int l1HistNrBins (const L1GtObject &l1GtObject, const std::string &quantity)
 
const double l1HistUpperBinValue (const L1GtObject &l1GtObject, const std::string &quantity)
 
virtual ~L1GetHistLimits ()
 

Private Member Functions

void getHistLimits (const L1GtObject &l1GtObject, const std::string &quantity)
 

Private Attributes

const edm::EventSetup & m_evSetup
 
L1HistLimits m_l1HistLimits
 all limits for a histogram More...
 

Detailed Description

Description: use L1 scales to define histogram limits for L1 trigger objects.

Implementation: <TODO: enter implementation details>

Author
: Vasile Mihai Ghete - HEPHY Vienna

$Date$ $Revision$

Definition at line 54 of file L1GetHistLimits.h.

Constructor & Destructor Documentation

L1GetHistLimits::L1GetHistLimits ( const edm::EventSetup &  evSetup)
explicit

Definition at line 38 of file L1GetHistLimits.cc.

38  :
39  m_evSetup(evSetup) {
40 
41  //
42 
43 }
L1GetHistLimits::m_evSetup
const edm::EventSetup & m_evSetup
Definition: L1GetHistLimits.h:121
L1GetHistLimits::~L1GetHistLimits ( )
virtual

Definition at line 46 of file L1GetHistLimits.cc.

46  {
47 
48  // empty
49 
50 }

Member Function Documentation

void L1GetHistLimits::getHistLimits ( const L1GtObject &  l1GtObject,
const std::string &  quantity 
)
private

for a L1 trigger object and a given quantity, compute the number of bins, the lower limit of the first bin, the upper limit of the last bin and the vector of bin thresholds

Definition at line 52 of file L1GetHistLimits.cc.

References L1GetHistLimits::L1HistLimits::binThresholds, BPTX, Castor, CenJet, L1CaloGeometry::emJetPhiBinHighEdge(), L1CaloGeometry::emJetPhiBinLowEdge(), ETM, L1CaloGeometry::etSumPhiBinHighEdge(), L1CaloGeometry::etSumPhiBinLowEdge(), ETT, ForJet, edm::EventSetup::get(), L1CaloGeometry::globalEtaBinHighEdge(), L1CaloGeometry::globalEtaBinLowEdge(), HfBitCounts, HfRingEtSums, HTM, L1CaloGeometry::htSumPhiBinHighEdge(), L1CaloGeometry::htSumPhiBinLowEdge(), HTT, IsoEG, j, JetCounts, L1GctEtHad::kEtHadMaxValue, L1GctEtMiss::kEtMissMaxValue, L1GctEtTotal::kEtTotalMaxValue, LogDebug, L1GetHistLimits::L1HistLimits::lowerBinValue, m_evSetup, m_l1HistLimits, Mu, NoIsoEG, L1GetHistLimits::L1HistLimits::nrBins, L1CaloGeometry::numberGctCentralEtaBinsPerHalf(), L1CaloGeometry::numberGctEmJetPhiBins(), L1CaloGeometry::numberGctEtSumPhiBins(), L1CaloGeometry::numberGctForwardEtaBinsPerHalf(), L1CaloGeometry::numberGctHtSumPhiBins(), edm::ESHandle< class >::product(), R3BINS, R3MAX, R3MIN, rad2deg(), TauJet, TechTrig, and L1GetHistLimits::L1HistLimits::upperBinValue.

Referenced by l1HistBinThresholds(), l1HistLimits(), l1HistLowerBinValue(), l1HistNrBins(), and l1HistUpperBinValue().

53  {
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 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:510
L1CaloGeometry::globalEtaBinLowEdge
double globalEtaBinLowEdge(unsigned int globalEtaIndex) const
Definition: L1CaloGeometry.cc:156
L1CaloGeometry::numberGctForwardEtaBinsPerHalf
unsigned int numberGctForwardEtaBinsPerHalf() const
Definition: L1CaloGeometry.h:116
L1GetHistLimits::m_evSetup
const edm::EventSetup & m_evSetup
Definition: L1GetHistLimits.h:121
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
L1CaloGeometry::numberGctEtSumPhiBins
unsigned int numberGctEtSumPhiBins() const
Definition: L1CaloGeometry.h:111
L1CaloGeometry::numberGctEmJetPhiBins
unsigned int numberGctEmJetPhiBins() const
Definition: L1CaloGeometry.h:109
L1CaloGeometry::numberGctCentralEtaBinsPerHalf
unsigned int numberGctCentralEtaBinsPerHalf() const
Definition: L1CaloGeometry.h:114
R3BINS
const unsigned int R3BINS
Definition: L1TGCT.cc:216
j
int j
Definition: DBlmapReader.cc:9
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
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
L1CaloGeometry::emJetPhiBinLowEdge
double emJetPhiBinLowEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:281
L1CaloGeometry::htSumPhiBinHighEdge
double htSumPhiBinHighEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:346
R3MAX
const float R3MAX
Definition: L1TGCT.cc:218
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:217
const std::vector< float > & L1GetHistLimits::l1HistBinThresholds ( const L1GtObject &  l1GtObject,
const std::string &  quantity 
)

for a L1 trigger object and a given quantity, return the vector of bin thresholds

Definition at line 816 of file L1GetHistLimits.cc.

References L1GetHistLimits::L1HistLimits::binThresholds, getHistLimits(), and m_l1HistLimits.

817  {
818 
819  getHistLimits(l1GtObject, quantity);
820  return m_l1HistLimits.binThresholds;
821 
822 }
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:52
L1GetHistLimits::m_l1HistLimits
L1HistLimits m_l1HistLimits
all limits for a histogram
Definition: L1GetHistLimits.h:124
L1GetHistLimits::L1HistLimits::binThresholds
std::vector< float > binThresholds
Definition: L1GetHistLimits.h:73
const L1GetHistLimits::L1HistLimits & L1GetHistLimits::l1HistLimits ( const L1GtObject &  l1GtObject,
const std::string &  quantity 
)

for a L1 trigger object and a given quantity, return all limits for a histogram

Definition at line 652 of file L1GetHistLimits.cc.

References L1GetHistLimits::L1HistLimits::binThresholds, getHistLimits(), edm::isDebugEnabled(), LogDebug, LogTrace, L1GetHistLimits::L1HistLimits::lowerBinValue, m_l1HistLimits, L1GetHistLimits::L1HistLimits::nrBins, and L1GetHistLimits::L1HistLimits::upperBinValue.

Referenced by L1ExtraDQM::L1ExtraMonElement< CollectionType >::bookHistograms().

653  {
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 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:510
edm::isDebugEnabled
bool isDebugEnabled()
Definition: MessageLogger.cc:68
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:52
L1GetHistLimits::m_l1HistLimits
L1HistLimits m_l1HistLimits
all limits for a histogram
Definition: L1GetHistLimits.h:124
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:511
L1GetHistLimits::L1HistLimits::binThresholds
std::vector< float > binThresholds
Definition: L1GetHistLimits.h:73
const L1GetHistLimits::L1HistLimits & L1GetHistLimits::l1HistLimits ( const L1GtObject &  l1GtObject,
const std::string &  quantity,
const double  histMinValue,
const double  histMaxValue 
)

for a L1 trigger object and a given quantity, return the real limits for a histogram given an arbitrary range

Definition at line 691 of file L1GetHistLimits.cc.

References L1GetHistLimits::L1HistLimits::binThresholds, getHistLimits(), edm::isDebugEnabled(), LogDebug, LogTrace, L1GetHistLimits::L1HistLimits::lowerBinValue, m_l1HistLimits, L1GetHistLimits::L1HistLimits::nrBins, and L1GetHistLimits::L1HistLimits::upperBinValue.

693  {
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 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:510
edm::isDebugEnabled
bool isDebugEnabled()
Definition: MessageLogger.cc:68
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:52
L1GetHistLimits::m_l1HistLimits
L1HistLimits m_l1HistLimits
all limits for a histogram
Definition: L1GetHistLimits.h:124
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:511
L1GetHistLimits::L1HistLimits::binThresholds
std::vector< float > binThresholds
Definition: L1GetHistLimits.h:73
const double L1GetHistLimits::l1HistLowerBinValue ( const L1GtObject &  l1GtObject,
const std::string &  quantity 
)

for a L1 trigger object and a given quantity, return the lower limit of the first bin in the histogram

Definition at line 800 of file L1GetHistLimits.cc.

References getHistLimits(), L1GetHistLimits::L1HistLimits::lowerBinValue, and m_l1HistLimits.

801  {
802 
803  getHistLimits(l1GtObject, quantity);
804  return m_l1HistLimits.lowerBinValue;
805 
806 }
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:52
L1GetHistLimits::m_l1HistLimits
L1HistLimits m_l1HistLimits
all limits for a histogram
Definition: L1GetHistLimits.h:124
const int L1GetHistLimits::l1HistNrBins ( const L1GtObject &  l1GtObject,
const std::string &  quantity 
)

for a L1 trigger object and a given quantity, return the numbers of bins for a given histogram

Definition at line 792 of file L1GetHistLimits.cc.

References getHistLimits(), m_l1HistLimits, and L1GetHistLimits::L1HistLimits::nrBins.

793  {
794 
795  getHistLimits(l1GtObject, quantity);
796  return m_l1HistLimits.nrBins;
797 
798 }
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:52
L1GetHistLimits::m_l1HistLimits
L1HistLimits m_l1HistLimits
all limits for a histogram
Definition: L1GetHistLimits.h:124
const double L1GetHistLimits::l1HistUpperBinValue ( const L1GtObject &  l1GtObject,
const std::string &  quantity 
)

for a L1 trigger object and a given quantity, return the upper limit of the last bin in the histogram

Definition at line 808 of file L1GetHistLimits.cc.

References getHistLimits(), m_l1HistLimits, and L1GetHistLimits::L1HistLimits::upperBinValue.

809  {
810 
811  getHistLimits(l1GtObject, quantity);
812  return m_l1HistLimits.upperBinValue;
813 
814 }
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:52
L1GetHistLimits::m_l1HistLimits
L1HistLimits m_l1HistLimits
all limits for a histogram
Definition: L1GetHistLimits.h:124

Member Data Documentation

const edm::EventSetup& L1GetHistLimits::m_evSetup
private

Definition at line 121 of file L1GetHistLimits.h.

Referenced by getHistLimits().

L1HistLimits L1GetHistLimits::m_l1HistLimits
private

all limits for a histogram

Definition at line 124 of file L1GetHistLimits.h.

Referenced by getHistLimits(), l1HistBinThresholds(), l1HistLimits(), l1HistLowerBinValue(), l1HistNrBins(), and l1HistUpperBinValue().

Generated for CMSSW Reference Manual by doxygen 1.8.5