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

Definition at line 52 of file L1GetHistLimits.h.

Constructor & Destructor Documentation

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

Definition at line 36 of file L1GetHistLimits.cc.

36  :
37  m_evSetup(evSetup) {
38 
39  //
40 
41 }
L1GetHistLimits::m_evSetup
const edm::EventSetup & m_evSetup
Definition: L1GetHistLimits.h:119
L1GetHistLimits::~L1GetHistLimits ( )
virtual

Definition at line 44 of file L1GetHistLimits.cc.

44  {
45 
46  // empty
47 
48 }

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 50 of file L1GetHistLimits.cc.

References L1GetHistLimits::L1HistLimits::binThresholds, BPTX, 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().

51  {
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 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
L1CaloGeometry::globalEtaBinLowEdge
double globalEtaBinLowEdge(unsigned int globalEtaIndex) const
Definition: L1CaloGeometry.cc:156
L1CaloGeometry::numberGctForwardEtaBinsPerHalf
unsigned int numberGctForwardEtaBinsPerHalf() const
Definition: L1CaloGeometry.h:118
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
L1CaloGeometry::htSumPhiBinLowEdge
double htSumPhiBinLowEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:331
ETM
Definition: L1GtObject.h:36
L1CaloGeometry::numberGctEtSumPhiBins
unsigned int numberGctEtSumPhiBins() const
Definition: L1CaloGeometry.h:113
L1CaloGeometry::numberGctEmJetPhiBins
unsigned int numberGctEmJetPhiBins() const
Definition: L1CaloGeometry.h:111
L1CaloGeometry::numberGctCentralEtaBinsPerHalf
unsigned int numberGctCentralEtaBinsPerHalf() const
Definition: L1CaloGeometry.h:116
HTT
Definition: L1GtObject.h:38
R3BINS
const unsigned int R3BINS
Definition: L1TGCT.cc:44
j
int j
Definition: DBlmapReader.cc:9
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
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:37
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:46
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
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 814 of file L1GetHistLimits.cc.

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

815  {
816 
817  getHistLimits(l1GtObject, quantity);
818  return m_l1HistLimits.binThresholds;
819 
820 }
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:50
L1GetHistLimits::m_l1HistLimits
L1HistLimits m_l1HistLimits
all limits for a histogram
Definition: L1GetHistLimits.h:122
L1GetHistLimits::L1HistLimits::binThresholds
std::vector< float > binThresholds
Definition: L1GetHistLimits.h:71
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 650 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().

651  {
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 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
edm::isDebugEnabled
bool isDebugEnabled()
Definition: MessageLogger.cc:71
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:50
L1GetHistLimits::m_l1HistLimits
L1HistLimits m_l1HistLimits
all limits for a histogram
Definition: L1GetHistLimits.h:122
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
L1GetHistLimits::L1HistLimits::binThresholds
std::vector< float > binThresholds
Definition: L1GetHistLimits.h:71
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 689 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.

691  {
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 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
edm::isDebugEnabled
bool isDebugEnabled()
Definition: MessageLogger.cc:71
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:50
L1GetHistLimits::m_l1HistLimits
L1HistLimits m_l1HistLimits
all limits for a histogram
Definition: L1GetHistLimits.h:122
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
L1GetHistLimits::L1HistLimits::binThresholds
std::vector< float > binThresholds
Definition: L1GetHistLimits.h:71
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 798 of file L1GetHistLimits.cc.

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

799  {
800 
801  getHistLimits(l1GtObject, quantity);
802  return m_l1HistLimits.lowerBinValue;
803 
804 }
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:50
L1GetHistLimits::m_l1HistLimits
L1HistLimits m_l1HistLimits
all limits for a histogram
Definition: L1GetHistLimits.h:122
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 790 of file L1GetHistLimits.cc.

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

791  {
792 
793  getHistLimits(l1GtObject, quantity);
794  return m_l1HistLimits.nrBins;
795 
796 }
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:50
L1GetHistLimits::m_l1HistLimits
L1HistLimits m_l1HistLimits
all limits for a histogram
Definition: L1GetHistLimits.h:122
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 806 of file L1GetHistLimits.cc.

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

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

Member Data Documentation

const edm::EventSetup& L1GetHistLimits::m_evSetup
private

Definition at line 119 of file L1GetHistLimits.h.

Referenced by getHistLimits().

L1HistLimits L1GetHistLimits::m_l1HistLimits
private

all limits for a histogram

Definition at line 122 of file L1GetHistLimits.h.

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

Generated for CMSSW Reference Manual by doxygen 1.8.5