CMS 3D CMS Logo
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 51 of file L1GetHistLimits.h.

Constructor & Destructor Documentation

◆ L1GetHistLimits()

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

Definition at line 35 of file L1GetHistLimits.cc.

35  : m_evSetup(evSetup) {
36  //
37 }

◆ ~L1GetHistLimits()

L1GetHistLimits::~L1GetHistLimits ( )
virtual

Definition at line 40 of file L1GetHistLimits.cc.

40  {
41  // empty
42 }

Member Function Documentation

◆ getHistLimits()

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

44  {
45  m_l1HistLimits.nrBins = 0;
46  m_l1HistLimits.lowerBinValue = 0;
47  m_l1HistLimits.upperBinValue = 0;
48  m_l1HistLimits.binThresholds.clear();
49 
50  // number of objects is independent of the object type
51  // and hardcoded in the actual version
52  if (quantity == "NrObjects") {
53  m_l1HistLimits.nrBins = 15;
54  m_l1HistLimits.lowerBinValue = -0.5;
55  m_l1HistLimits.upperBinValue = 14.5;
56 
57  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
58 
59  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
60  m_l1HistLimits.binThresholds[iBin] =
61  m_l1HistLimits.lowerBinValue +
62  iBin * (m_l1HistLimits.upperBinValue - m_l1HistLimits.lowerBinValue) / m_l1HistLimits.nrBins;
63  }
64 
65  // set last bin upper edge
66  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
67 
68  return;
69  }
70 
71  switch (l1GtObject) {
72  case Mu: {
73  if (quantity == "PT") {
74  edm::ESHandle<L1MuTriggerPtScale> muPtScale;
75  m_evSetup.get<L1MuTriggerPtScaleRcd>().get(muPtScale);
76 
77  m_l1HistLimits.nrBins = muPtScale->getPtScale()->getNBins();
78  m_l1HistLimits.lowerBinValue = muPtScale->getPtScale()->getScaleMin();
79  m_l1HistLimits.upperBinValue = muPtScale->getPtScale()->getScaleMax();
80 
81  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
82 
83  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
84  m_l1HistLimits.binThresholds[iBin] = muPtScale->getPtScale()->getValue(iBin);
85  }
86 
87  // last limit for muon is set too high (10^6) - resize the last bin
88 
89  float lastBinSize = m_l1HistLimits.upperBinValue - m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins - 1];
90 
91  // limit the size of the last bin to maximum 200 GeV
92  float maxLaxtBinsize = 200;
93  if (lastBinSize >= maxLaxtBinsize) {
94  m_l1HistLimits.upperBinValue = m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins - 1] +
95  2. * (m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins - 1] -
96  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins - 2]);
97  LogDebug("L1GetHistLimits") << "\n L1ExtraMuon: PT histogram"
98  << "\nm_l1HistLimits.upperBinValue truncated to = "
99  << m_l1HistLimits.upperBinValue << std::endl;
100  }
101 
102  // set last bin upper edge
103  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
104 
105  } else if (quantity == "eta" || quantity == "phi") {
106  edm::ESHandle<L1MuTriggerScales> muScales;
107  m_evSetup.get<L1MuTriggerScalesRcd>().get(muScales);
108 
109  if (quantity == "eta") {
110  // eta scale defined for positive values - need to be symmetrized
111  int histNrBinsHalf = muScales->getGMTEtaScale()->getNBins();
112  m_l1HistLimits.lowerBinValue = muScales->getGMTEtaScale()->getScaleMin();
113  m_l1HistLimits.upperBinValue = muScales->getGMTEtaScale()->getScaleMax();
114 
115  m_l1HistLimits.nrBins = 2 * histNrBinsHalf;
116  m_l1HistLimits.lowerBinValue = -m_l1HistLimits.upperBinValue;
117 
118  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
119 
120  int iBin = 0;
121  for (int j = histNrBinsHalf; j > 0; j--, iBin++) {
122  m_l1HistLimits.binThresholds[iBin] = (-1) * muScales->getGMTEtaScale()->getValue(j);
123  }
124  for (int j = 0; j <= histNrBinsHalf; j++, iBin++) {
125  m_l1HistLimits.binThresholds[iBin] = muScales->getGMTEtaScale()->getValue(j);
126  }
127 
128  // set last bin upper edge
129  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
130 
131  } else {
132  m_l1HistLimits.nrBins = muScales->getPhiScale()->getNBins();
133  m_l1HistLimits.lowerBinValue = rad2deg(muScales->getPhiScale()->getScaleMin());
134  m_l1HistLimits.upperBinValue = rad2deg(muScales->getPhiScale()->getScaleMax());
135 
136  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
137 
138  for (int iBin = 0; iBin <= m_l1HistLimits.nrBins; iBin++) {
139  m_l1HistLimits.binThresholds[iBin] = rad2deg(muScales->getPhiScale()->getValue(iBin));
140  }
141 
142  // set last bin upper edge
143  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
144  }
145  }
146 
147  } break;
148  case NoIsoEG:
149  case IsoEG: {
150  // common scales for NoIsoEG and IsoEG
151  if (quantity == "ET") {
152  edm::ESHandle<L1CaloEtScale> emScale;
153  m_evSetup.get<L1EmEtScaleRcd>().get(emScale);
154 
155  std::vector<double> emThresholds = emScale->getThresholds();
156  m_l1HistLimits.nrBins = emThresholds.size();
157  m_l1HistLimits.lowerBinValue = emThresholds.at(0);
158 
159  // FIXME high edge retrieval in the scale definition
160  // now, last bin has the same width like the last but one
161  m_l1HistLimits.upperBinValue =
162  emThresholds[m_l1HistLimits.nrBins - 1] +
163  (emThresholds[m_l1HistLimits.nrBins - 1] - emThresholds[m_l1HistLimits.nrBins - 2]);
164 
165  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
166 
167  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
168  m_l1HistLimits.binThresholds[iBin] = static_cast<float>(emThresholds[iBin]);
169  }
170 
171  // set last bin upper edge
172  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
173 
174  } else if (quantity == "eta" || quantity == "phi") {
175  edm::ESHandle<L1CaloGeometry> caloGeomESH;
176  m_evSetup.get<L1CaloGeometryRecord>().get(caloGeomESH);
177  const L1CaloGeometry* caloGeomScales = caloGeomESH.product();
178 
179  if (quantity == "eta") {
180  m_l1HistLimits.nrBins =
181  2 * (caloGeomScales->numberGctCentralEtaBinsPerHalf() + caloGeomScales->numberGctForwardEtaBinsPerHalf());
182  m_l1HistLimits.lowerBinValue = caloGeomScales->globalEtaBinLowEdge(0);
183  m_l1HistLimits.upperBinValue = caloGeomScales->globalEtaBinHighEdge(m_l1HistLimits.nrBins - 1);
184 
185  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
186 
187  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
188  m_l1HistLimits.binThresholds[iBin] = caloGeomScales->globalEtaBinLowEdge(iBin);
189  }
190 
191  // set last bin upper edge
192  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
193 
194  } else {
195  m_l1HistLimits.nrBins = caloGeomScales->numberGctEmJetPhiBins();
196  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
197 
198  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
199  m_l1HistLimits.binThresholds[iBin] = rad2deg(caloGeomScales->emJetPhiBinLowEdge(iBin));
200 
201  // treat correctly the 10 deg anti-clockwise rotation
202  if (rad2deg(caloGeomScales->emJetPhiBinHighEdge(iBin)) < m_l1HistLimits.binThresholds[iBin]) {
203  m_l1HistLimits.binThresholds[iBin] = m_l1HistLimits.binThresholds[iBin] - 360.;
204  }
205  }
206 
207  m_l1HistLimits.lowerBinValue = m_l1HistLimits.binThresholds[0];
208 
209  // last bin upper limit
210  m_l1HistLimits.upperBinValue = rad2deg(caloGeomScales->emJetPhiBinHighEdge(m_l1HistLimits.nrBins - 1));
211 
212  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
213  }
214  }
215 
216  } break;
217  case CenJet:
218  case ForJet:
219  case TauJet: {
220  // common scales for all jets
221  if (quantity == "ET") {
222  edm::ESHandle<L1CaloEtScale> jetScale;
223  m_evSetup.get<L1JetEtScaleRcd>().get(jetScale);
224 
225  std::vector<double> jetThresholds = jetScale->getThresholds();
226  m_l1HistLimits.nrBins = jetThresholds.size();
227  m_l1HistLimits.lowerBinValue = jetThresholds.at(0);
228 
229  // FIXME high edge retrieval in the scale definition
230  // now, last bin has the same width like the last but one
231  m_l1HistLimits.upperBinValue =
232  jetThresholds[m_l1HistLimits.nrBins - 1] +
233  (jetThresholds[m_l1HistLimits.nrBins - 1] - jetThresholds[m_l1HistLimits.nrBins - 2]);
234 
235  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
236 
237  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
238  m_l1HistLimits.binThresholds[iBin] = static_cast<float>(jetThresholds[iBin]);
239  }
240 
241  // set last bin upper edge
242  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
243 
244  } else if (quantity == "eta" || quantity == "phi") {
245  edm::ESHandle<L1CaloGeometry> caloGeomESH;
246  m_evSetup.get<L1CaloGeometryRecord>().get(caloGeomESH);
247  const L1CaloGeometry* caloGeomScales = caloGeomESH.product();
248 
249  if (quantity == "eta") {
250  m_l1HistLimits.nrBins =
251  2 * (caloGeomScales->numberGctCentralEtaBinsPerHalf() + caloGeomScales->numberGctForwardEtaBinsPerHalf());
252  m_l1HistLimits.lowerBinValue = caloGeomScales->globalEtaBinLowEdge(0);
253  m_l1HistLimits.upperBinValue = caloGeomScales->globalEtaBinHighEdge(m_l1HistLimits.nrBins - 1);
254 
255  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
256 
257  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
258  m_l1HistLimits.binThresholds[iBin] = caloGeomScales->globalEtaBinLowEdge(iBin);
259  }
260 
261  // set last bin upper edge
262  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
263 
264  } else {
265  m_l1HistLimits.nrBins = caloGeomScales->numberGctEmJetPhiBins();
266  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
267 
268  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
269  m_l1HistLimits.binThresholds[iBin] = rad2deg(caloGeomScales->emJetPhiBinLowEdge(iBin));
270 
271  // treat correctly the 10 deg anti-clockwise rotation
272  if (rad2deg(caloGeomScales->emJetPhiBinHighEdge(iBin)) < m_l1HistLimits.binThresholds[iBin]) {
273  m_l1HistLimits.binThresholds[iBin] = m_l1HistLimits.binThresholds[iBin] - 360.;
274  }
275  }
276 
277  m_l1HistLimits.lowerBinValue = m_l1HistLimits.binThresholds[0];
278 
279  // last bin upper limit
280  m_l1HistLimits.upperBinValue = rad2deg(caloGeomScales->emJetPhiBinHighEdge(m_l1HistLimits.nrBins - 1));
281 
282  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
283  }
284  }
285  } break;
286  case ETM: {
287  if (quantity == "ET") {
288  edm::ESHandle<L1CaloEtScale> etMissScale;
289  m_evSetup.get<L1JetEtScaleRcd>().get(etMissScale);
290 
291  const double etSumLSB = etMissScale->linearLsb();
292 
293  m_l1HistLimits.nrBins = L1GctEtMiss::kEtMissMaxValue;
294 
295  m_l1HistLimits.lowerBinValue = 0;
296  m_l1HistLimits.upperBinValue = (m_l1HistLimits.nrBins + 1) * etSumLSB;
297 
298  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
299 
300  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
301  m_l1HistLimits.binThresholds[iBin] = iBin * etSumLSB;
302  }
303 
304  // set last bin upper edge
305  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
306 
307  } else if (quantity == "eta" || quantity == "phi") {
308  edm::ESHandle<L1CaloGeometry> caloGeomESH;
309  m_evSetup.get<L1CaloGeometryRecord>().get(caloGeomESH);
310  const L1CaloGeometry* caloGeomScales = caloGeomESH.product();
311 
312  if (quantity == "eta") {
313  // do nothing, eta is not defined for ETM
314 
315  } else {
316  m_l1HistLimits.nrBins = caloGeomScales->numberGctEtSumPhiBins();
317  m_l1HistLimits.lowerBinValue = rad2deg(caloGeomScales->etSumPhiBinLowEdge(0));
318  m_l1HistLimits.upperBinValue = rad2deg(caloGeomScales->etSumPhiBinHighEdge(m_l1HistLimits.nrBins - 1));
319 
320  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
321 
322  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
323  m_l1HistLimits.binThresholds[iBin] = rad2deg(caloGeomScales->etSumPhiBinLowEdge(iBin));
324  }
325 
326  // last bin upper limit
327  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
328  }
329  }
330 
331  } break;
332  case ETT: {
333  if (quantity == "ET") {
334  edm::ESHandle<L1CaloEtScale> etMissScale;
335  m_evSetup.get<L1JetEtScaleRcd>().get(etMissScale);
336 
337  const double etSumLSB = etMissScale->linearLsb();
338 
339  m_l1HistLimits.nrBins = L1GctEtTotal::kEtTotalMaxValue;
340 
341  m_l1HistLimits.lowerBinValue = 0;
342  m_l1HistLimits.upperBinValue = (m_l1HistLimits.nrBins + 1) * etSumLSB;
343 
344  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
345 
346  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
347  m_l1HistLimits.binThresholds[iBin] = iBin * etSumLSB;
348  }
349 
350  // set last bin upper edge
351  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
352 
353  } else if (quantity == "eta" || quantity == "phi") {
354  // do nothing, eta and phi are not defined for ETT
355  }
356 
357  } break;
358  case HTT: {
359  if (quantity == "ET") {
360  edm::ESHandle<L1GctJetFinderParams> jetFinderParams;
361  m_evSetup.get<L1GctJetFinderParamsRcd>().get(jetFinderParams);
362  double htSumLSB = jetFinderParams->getHtLsbGeV();
363 
364  m_l1HistLimits.nrBins = L1GctEtHad::kEtHadMaxValue;
365 
366  m_l1HistLimits.lowerBinValue = 0;
367  m_l1HistLimits.upperBinValue = (m_l1HistLimits.nrBins + 1) * htSumLSB;
368 
369  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
370 
371  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
372  m_l1HistLimits.binThresholds[iBin] = iBin * htSumLSB;
373  }
374 
375  // set last bin upper edge
376  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
377 
378  } else if (quantity == "eta" || quantity == "phi") {
379  // do nothing, eta and phi are not defined for HTT
380  }
381  } break;
382  case HTM: {
383  if (quantity == "ET") {
384  edm::ESHandle<L1CaloEtScale> htMissScale;
385  m_evSetup.get<L1HtMissScaleRcd>().get(htMissScale);
386 
387  const std::vector<double>& htThresholds = htMissScale->getThresholds();
388  m_l1HistLimits.nrBins = htThresholds.size();
389  m_l1HistLimits.lowerBinValue = htThresholds[0];
390 
391  // FIXME high edge retrieval in the scale definition
392  // now, last bin has the same width like the last but one
393  m_l1HistLimits.upperBinValue =
394  htThresholds[m_l1HistLimits.nrBins - 1] +
395  (htThresholds[m_l1HistLimits.nrBins - 1] - htThresholds[m_l1HistLimits.nrBins - 2]);
396 
397  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
398 
399  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
400  m_l1HistLimits.binThresholds[iBin] = static_cast<float>(htThresholds[iBin]);
401  }
402 
403  // set last bin upper edge
404  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
405 
406  } else if (quantity == "eta" || quantity == "phi") {
407  edm::ESHandle<L1CaloGeometry> caloGeomESH;
408  m_evSetup.get<L1CaloGeometryRecord>().get(caloGeomESH);
409  const L1CaloGeometry* caloGeomScales = caloGeomESH.product();
410 
411  if (quantity == "eta") {
412  // do nothing, eta is not defined for HTM
413 
414  } else {
415  m_l1HistLimits.nrBins = caloGeomScales->numberGctHtSumPhiBins();
416  m_l1HistLimits.lowerBinValue = rad2deg(caloGeomScales->htSumPhiBinLowEdge(0));
417  m_l1HistLimits.upperBinValue = rad2deg(caloGeomScales->htSumPhiBinHighEdge(m_l1HistLimits.nrBins - 1));
418 
419  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
420 
421  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
422  m_l1HistLimits.binThresholds[iBin] = rad2deg(caloGeomScales->htSumPhiBinLowEdge(iBin));
423  }
424 
425  // last bin upper limit
426  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
427  }
428  }
429  } break;
430  case JetCounts: {
431  } break;
432  case HfBitCounts: {
433  // there are no scales for HfBitCounts, so one implements a fixed scale
434  // use same values as GCT for 3 bits
435  const unsigned int R3BINS = 8;
436  const float R3MIN = -0.5;
437  const float R3MAX = 7.5;
438 
439  m_l1HistLimits.nrBins = R3BINS;
440  m_l1HistLimits.lowerBinValue = R3MIN;
441  m_l1HistLimits.upperBinValue = R3MAX;
442 
443  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
444 
445  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
446  m_l1HistLimits.binThresholds[iBin] = R3MIN + iBin * (R3MAX - R3MIN) / R3BINS;
447  }
448 
449  // last bin upper limit
450  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
451 
452  } break;
453  case HfRingEtSums: {
454  if (quantity == "ET") {
455  edm::ESHandle<L1CaloEtScale> hfRingEtScale;
456  m_evSetup.get<L1HfRingEtScaleRcd>().get(hfRingEtScale);
457 
458  const std::vector<double>& hfRingEtThresholds = hfRingEtScale->getThresholds();
459  m_l1HistLimits.nrBins = hfRingEtThresholds.size();
460  m_l1HistLimits.lowerBinValue = hfRingEtThresholds[0];
461 
462  // FIXME high edge retrieval in the scale definition
463  // now, last bin has the same width like the last but one
464  m_l1HistLimits.upperBinValue =
465  hfRingEtThresholds[m_l1HistLimits.nrBins - 1] +
466  (hfRingEtThresholds[m_l1HistLimits.nrBins - 1] - hfRingEtThresholds[m_l1HistLimits.nrBins - 2]);
467 
468  m_l1HistLimits.binThresholds.resize(m_l1HistLimits.nrBins + 1);
469 
470  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
471  m_l1HistLimits.binThresholds[iBin] = static_cast<float>(hfRingEtThresholds[iBin]);
472  }
473 
474  // set last bin upper edge
475  m_l1HistLimits.binThresholds[m_l1HistLimits.nrBins] = m_l1HistLimits.upperBinValue;
476 
477  } else if (quantity == "eta" || quantity == "phi") {
478  // do nothing, eta and phi are not defined for HfRingEtSums
479  }
480  } break;
481  case TechTrig:
482  case Castor:
483  case BPTX:
484  default: {
485  // do nothing, for these cases ET/PT, eta and phi are not defined
486 
487  } break;
488  }
489 }

References L1GetHistLimits::L1HistLimits::binThresholds, BPTX, Castor, CenJet, L1CaloGeometry::emJetPhiBinHighEdge(), L1CaloGeometry::emJetPhiBinLowEdge(), ETM, L1CaloGeometry::etSumPhiBinHighEdge(), L1CaloGeometry::etSumPhiBinLowEdge(), ETT, ForJet, edm::EventSetup::get(), get, L1MuTriggerScales::getGMTEtaScale(), L1GctJetFinderParams::getHtLsbGeV(), L1MuScale::getNBins(), L1MuTriggerScales::getPhiScale(), L1MuTriggerPtScale::getPtScale(), L1MuScale::getScaleMax(), L1MuScale::getScaleMin(), L1CaloEtScale::getThresholds(), L1MuScale::getValue(), L1CaloGeometry::globalEtaBinHighEdge(), L1CaloGeometry::globalEtaBinLowEdge(), HfBitCounts, HfRingEtSums, HTM, L1CaloGeometry::htSumPhiBinHighEdge(), L1CaloGeometry::htSumPhiBinLowEdge(), HTT, IsoEG, dqmiolumiharvest::j, JetCounts, wplusjetsAnalysis_cfi::jetScale, L1GctEtHad::kEtHadMaxValue, L1GctEtMiss::kEtMissMaxValue, L1GctEtTotal::kEtTotalMaxValue, L1CaloEtScale::linearLsb(), 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< T >::product(), MjjMonitor_cfi::quantity, R3BINS, R3MAX, R3MIN, rad2deg(), TauJet, TechTrig, and L1GetHistLimits::L1HistLimits::upperBinValue.

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

◆ l1HistBinThresholds()

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

620  {
621  getHistLimits(l1GtObject, quantity);
622  return m_l1HistLimits.binThresholds;
623 }

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

◆ l1HistLimits() [1/2]

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

492  {
493  getHistLimits(l1GtObject, quantity);
494 
495  if (edm::isDebugEnabled()) {
496  LogDebug("L1GetHistLimits") << "\n Histogram limits for L1GtObject " << l1GtObject << " and quantity " << quantity
497  << "\n Number of bins: " << m_l1HistLimits.nrBins
498  << "\n Lower limit of first bin: " << m_l1HistLimits.lowerBinValue
499  << "\n Upper limit of last bin: " << m_l1HistLimits.upperBinValue << std::endl;
500 
501  int binThreshSize = static_cast<int>(m_l1HistLimits.binThresholds.size());
502 
503  if (binThreshSize != (m_l1HistLimits.nrBins + 1)) {
504  LogTrace("L1GetHistLimits") << "\n Warning: inconsistent nrBins and binThresholds size"
505  << "\n Number of bins nrBins = " << m_l1HistLimits.nrBins
506  << "\n binThresholds size = " << binThreshSize
507  << "\n Please fix the L1GetLimits class.\n\n"
508  << std::endl;
509  }
510 
511  for (int iBin = 0; iBin < binThreshSize; ++iBin) {
512  LogTrace("L1GetHistLimits") << " Bin " << std::right << std::setw(5) << iBin << ": "
513  << m_l1HistLimits.binThresholds[iBin] << std::endl;
514  }
515  }
516 
517  return m_l1HistLimits;
518 }

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

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

◆ l1HistLimits() [2/2]

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

523  {
524  getHistLimits(l1GtObject, quantity);
525 
526  bool foundLowerBinValue = false;
527  bool foundUpperBinValue = false;
528 
529  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
530  if (m_l1HistLimits.binThresholds[iBin] <= histMinValue) {
531  m_l1HistLimits.lowerBinValue = m_l1HistLimits.binThresholds[iBin];
532  foundLowerBinValue = true;
533  break;
534  }
535  }
536 
537  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
538  if (m_l1HistLimits.binThresholds[iBin] > histMaxValue) {
539  m_l1HistLimits.upperBinValue = m_l1HistLimits.binThresholds[iBin];
540  foundUpperBinValue = true;
541  break;
542  }
543  }
544 
545  if (foundLowerBinValue && foundUpperBinValue) {
546  int countBins = -1;
547  std::vector<float> binThresh;
548  binThresh.reserve(m_l1HistLimits.binThresholds.size());
549 
550  for (int iBin = 0; iBin < m_l1HistLimits.nrBins; ++iBin) {
551  if ((m_l1HistLimits.binThresholds[iBin] >= histMinValue) && m_l1HistLimits.binThresholds[iBin] < histMaxValue) {
552  m_l1HistLimits.upperBinValue = m_l1HistLimits.binThresholds[iBin];
553 
554  countBins++;
555  binThresh.push_back(m_l1HistLimits.binThresholds[iBin]);
556  }
557  }
558 
559  m_l1HistLimits.nrBins = countBins;
560  m_l1HistLimits.binThresholds.clear();
561  m_l1HistLimits.binThresholds = binThresh;
562 
563  // FIXME last bin untested.
564 
565  } else {
566  m_l1HistLimits.nrBins = 0;
567  m_l1HistLimits.lowerBinValue = 0;
568  m_l1HistLimits.upperBinValue = 0;
569  m_l1HistLimits.binThresholds.clear();
570 
571  LogDebug("L1GetHistLimits") << "\n Histogram limits for L1GtObject" << l1GtObject << " and quantity " << quantity
572  << " within the required range [" << histMinValue << ", " << histMaxValue
573  << "] not found."
574  << "\n The range is not included in the original histogram range." << std::endl;
575 
576  return m_l1HistLimits;
577  }
578 
579  if (edm::isDebugEnabled()) {
580  LogDebug("L1GetHistLimits") << "\n Histogram limits for L1GtObject" << l1GtObject << " and quantity " << quantity
581  << "\n Number of bins: " << m_l1HistLimits.nrBins
582  << "\n Lower limit of first bin: " << m_l1HistLimits.lowerBinValue
583  << "\n Upper limit of last bin: " << m_l1HistLimits.upperBinValue << std::endl;
584 
585  int binThreshSize = static_cast<int>(m_l1HistLimits.binThresholds.size());
586 
587  if (binThreshSize != (m_l1HistLimits.nrBins + 1)) {
588  LogTrace("L1GetHistLimits") << "\n Warning: inconsistent nrBins and binThresholds size"
589  << "\n Number of bins nrBins = " << m_l1HistLimits.nrBins
590  << "\n binThresholds size = " << binThreshSize
591  << "\n Please fix the L1GetLimits class.\n\n"
592  << std::endl;
593  }
594 
595  for (int iBin = 0; iBin < binThreshSize; ++iBin) {
596  LogTrace("L1GetHistLimits") << " Bin " << std::right << std::setw(5) << iBin << ": "
597  << m_l1HistLimits.binThresholds[iBin] << std::endl;
598  }
599  }
600 
601  return m_l1HistLimits;
602 }

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

◆ l1HistLowerBinValue()

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

609  {
610  getHistLimits(l1GtObject, quantity);
611  return m_l1HistLimits.lowerBinValue;
612 }

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

◆ l1HistNrBins()

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

604  {
605  getHistLimits(l1GtObject, quantity);
606  return m_l1HistLimits.nrBins;
607 }

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

◆ l1HistUpperBinValue()

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

614  {
615  getHistLimits(l1GtObject, quantity);
616  return m_l1HistLimits.upperBinValue;
617 }

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

Member Data Documentation

◆ m_evSetup

const edm::EventSetup& L1GetHistLimits::m_evSetup
private

Definition at line 106 of file L1GetHistLimits.h.

Referenced by getHistLimits().

◆ m_l1HistLimits

L1HistLimits L1GetHistLimits::m_l1HistLimits
private

all limits for a histogram

Definition at line 109 of file L1GetHistLimits.h.

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

edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
L1CaloGeometry::emJetPhiBinHighEdge
double emJetPhiBinHighEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:232
L1GetHistLimits::m_l1HistLimits
L1HistLimits m_l1HistLimits
all limits for a histogram
Definition: L1GetHistLimits.h:109
HTM
Definition: L1GtObject.h:38
L1MuScale::getNBins
virtual unsigned getNBins() const =0
get number of bins
L1CaloGeometry::etSumPhiBinHighEdge
double etSumPhiBinHighEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:244
L1CaloGeometry::htSumPhiBinHighEdge
double htSumPhiBinHighEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:264
L1MuTriggerScales::getGMTEtaScale
const L1MuScale * getGMTEtaScale() const
get the GMT eta scale
Definition: L1MuTriggerScales.h:169
R3MAX
const float R3MAX
Definition: L1TGCT.cc:46
ETM
Definition: L1GtObject.h:35
Castor
Definition: L1GtObject.h:43
R3MIN
const float R3MIN
Definition: L1TGCT.cc:45
L1CaloGeometry::numberGctCentralEtaBinsPerHalf
unsigned int numberGctCentralEtaBinsPerHalf() const
Definition: L1CaloGeometry.h:103
rad2deg
const double rad2deg(const double &)
convert phi from rad (-pi, pi] to deg (0, 360)
Definition: L1PhiConversion.cc:17
L1GetHistLimits::L1HistLimits::nrBins
int nrBins
Definition: L1GetHistLimits.h:65
L1MuScale::getValue
virtual float getValue(unsigned i) const =0
get value of the underlying vector for bin i
L1GetHistLimits::m_evSetup
const edm::EventSetup & m_evSetup
Definition: L1GetHistLimits.h:106
L1CaloGeometry::etSumPhiBinLowEdge
double etSumPhiBinLowEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:240
NoIsoEG
Definition: L1GtObject.h:30
L1GetHistLimits::L1HistLimits::lowerBinValue
double lowerBinValue
Definition: L1GetHistLimits.h:66
L1GctJetFinderParams::getHtLsbGeV
double getHtLsbGeV() const
Definition: L1GctJetFinderParams.h:36
IsoEG
Definition: L1GtObject.h:31
L1HfRingEtScaleRcd
Definition: L1HfRingEtScaleRcd.h:30
L1GctEtMiss::kEtMissMaxValue
Definition: L1GctEtMiss.h:24
L1CaloGeometry::numberGctEmJetPhiBins
unsigned int numberGctEmJetPhiBins() const
Definition: L1CaloGeometry.h:100
L1MuTriggerScales::getPhiScale
const L1MuScale * getPhiScale() const
get the phi scale
Definition: L1MuTriggerScales.h:175
L1CaloGeometry::globalEtaBinLowEdge
double globalEtaBinLowEdge(unsigned int globalEtaIndex) const
Definition: L1CaloGeometry.cc:141
edm::EventSetup::get
T get() const
Definition: EventSetup.h:80
L1CaloGeometry::numberGctEtSumPhiBins
unsigned int numberGctEtSumPhiBins() const
Definition: L1CaloGeometry.h:101
HTT
Definition: L1GtObject.h:37
L1GctEtHad::kEtHadMaxValue
Definition: L1GctEtHad.h:22
HfBitCounts
Definition: L1GtObject.h:40
HfRingEtSums
Definition: L1GtObject.h:41
L1JetEtScaleRcd
Definition: L1JetEtScaleRcd.h:30
edm::ESHandle
Definition: DTSurvey.h:22
L1GctJetFinderParamsRcd
Definition: L1GctJetFinderParamsRcd.h:31
CenJet
Definition: L1GtObject.h:32
L1CaloEtScale::linearLsb
double linearLsb() const
get LSB of linear input scale
Definition: L1CaloEtScale.h:54
L1GctEtTotal::kEtTotalMaxValue
Definition: L1GctEtTotal.h:22
L1GetHistLimits::L1HistLimits::upperBinValue
double upperBinValue
Definition: L1GetHistLimits.h:67
L1MuScale::getScaleMin
virtual float getScaleMin() const =0
get the lower edge of the first bin
L1CaloGeometryRecord
Definition: L1CaloGeometryRecord.h:30
TechTrig
Definition: L1GtObject.h:42
R3BINS
const unsigned int R3BINS
Definition: L1TGCT.cc:44
MjjMonitor_cfi.quantity
quantity
Definition: MjjMonitor_cfi.py:10
TauJet
Definition: L1GtObject.h:34
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:223
L1CaloGeometry
Definition: L1CaloGeometry.h:33
L1MuTriggerPtScale::getPtScale
const L1MuScale * getPtScale() const
get the Pt scale
Definition: L1MuTriggerPtScale.h:59
L1CaloGeometry::globalEtaBinHighEdge
double globalEtaBinHighEdge(unsigned int globalEtaIndex) const
Definition: L1CaloGeometry.cc:154
ETT
Definition: L1GtObject.h:36
L1MuTriggerPtScaleRcd
Definition: L1MuTriggerPtScaleRcd.h:12
get
#define get
L1MuTriggerScalesRcd
Definition: L1MuTriggerScalesRcd.h:12
L1CaloEtScale::getThresholds
const std::vector< double > & getThresholds() const
get thresholds
Definition: L1CaloEtScale.h:66
L1CaloGeometry::emJetPhiBinLowEdge
double emJetPhiBinLowEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:228
Mu
Definition: L1GtObject.h:29
L1HtMissScaleRcd
Definition: L1HtMissScaleRcd.h:30
L1EmEtScaleRcd
Definition: L1EmEtScaleRcd.h:30
L1CaloGeometry::htSumPhiBinLowEdge
double htSumPhiBinLowEdge(unsigned int phiIndex) const
Definition: L1CaloGeometry.cc:256
L1CaloGeometry::numberGctForwardEtaBinsPerHalf
unsigned int numberGctForwardEtaBinsPerHalf() const
Definition: L1CaloGeometry.h:104
ForJet
Definition: L1GtObject.h:33
JetCounts
Definition: L1GtObject.h:39
wplusjetsAnalysis_cfi.jetScale
jetScale
Definition: wplusjetsAnalysis_cfi.py:88
L1CaloGeometry::numberGctHtSumPhiBins
unsigned int numberGctHtSumPhiBins() const
Definition: L1CaloGeometry.cc:369
edm::isDebugEnabled
bool isDebugEnabled()
Definition: MessageLogger.cc:12
BPTX
Definition: L1GtObject.h:44
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:224
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
L1MuScale::getScaleMax
virtual float getScaleMax() const =0
get the upper edge of the last bin
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:44
L1GetHistLimits::L1HistLimits::binThresholds
std::vector< float > binThresholds
Definition: L1GetHistLimits.h:68
Generated for CMSSW Reference Manual by doxygen 1.8.16