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

#include <L1GetHistLimits.h>

Classes

struct  L1HistLimits
 
struct  Tokens
 

Public Member Functions

 L1GetHistLimits (const Tokens &, 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...
 
const Tokens & m_tokens
 

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 Tokens &  tokens,
const edm::EventSetup &  evSetup 
)
explicit

Definition at line 47 of file L1GetHistLimits.cc.

48  : m_tokens(tokens), m_evSetup(evSetup) {
49  //
50 }
L1GetHistLimits::m_evSetup
const edm::EventSetup & m_evSetup
Definition: L1GetHistLimits.h:121
L1GetHistLimits::m_tokens
const Tokens & m_tokens
Definition: L1GetHistLimits.h:120
L1GetHistLimits::~L1GetHistLimits ( )
virtual

Definition at line 53 of file L1GetHistLimits.cc.

53  {
54  // empty
55 }

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

References L1GetHistLimits::L1HistLimits::binThresholds, BPTX, CenJet, L1CaloGeometry::emJetPhiBinHighEdge(), L1CaloGeometry::emJetPhiBinLowEdge(), ETM, L1CaloGeometry::etSumPhiBinHighEdge(), L1CaloGeometry::etSumPhiBinLowEdge(), ETT, ForJet, edm::EventSetup::getData(), 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, L1GctEtHad::kEtHadMaxValue, L1GctEtMiss::kEtMissMaxValue, L1GctEtTotal::kEtTotalMaxValue, L1CaloEtScale::linearLsb(), LogDebug, L1GetHistLimits::L1HistLimits::lowerBinValue, L1GetHistLimits::Tokens::m_caloGeomESHToken, L1GetHistLimits::Tokens::m_etScaleToken, m_evSetup, L1GetHistLimits::Tokens::m_hfRingEtScaleToken, L1GetHistLimits::Tokens::m_htMissScaleToken, L1GetHistLimits::Tokens::m_jetFinderParamsToken, L1GetHistLimits::Tokens::m_jetScaleToken, m_l1HistLimits, L1GetHistLimits::Tokens::m_muPTScaleToken, L1GetHistLimits::Tokens::m_muScalesToken, m_tokens, Mu, NoIsoEG, L1GetHistLimits::L1HistLimits::nrBins, L1CaloGeometry::numberGctCentralEtaBinsPerHalf(), L1CaloGeometry::numberGctEmJetPhiBins(), L1CaloGeometry::numberGctEtSumPhiBins(), L1CaloGeometry::numberGctForwardEtaBinsPerHalf(), L1CaloGeometry::numberGctHtSumPhiBins(), R3BINS, R3MAX, R3MIN, rad2deg(), TauJet, TechTrig, and L1GetHistLimits::L1HistLimits::upperBinValue.

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

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

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

616  {
617  getHistLimits(l1GtObject, quantity);
618  return m_l1HistLimits.binThresholds;
619 }
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:57
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:82
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 487 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().

488  {
489  getHistLimits(l1GtObject, quantity);
490 
491  if (edm::isDebugEnabled()) {
492  LogDebug("L1GetHistLimits") << "\n Histogram limits for L1GtObject " << l1GtObject << " and quantity " << quantity
493  << "\n Number of bins: " << m_l1HistLimits.nrBins
494  << "\n Lower limit of first bin: " << m_l1HistLimits.lowerBinValue
495  << "\n Upper limit of last bin: " << m_l1HistLimits.upperBinValue << std::endl;
496 
497  int binThreshSize = static_cast<int>(m_l1HistLimits.binThresholds.size());
498 
499  if (binThreshSize != (m_l1HistLimits.nrBins + 1)) {
500  LogTrace("L1GetHistLimits") << "\n Warning: inconsistent nrBins and binThresholds size"
501  << "\n Number of bins nrBins = " << m_l1HistLimits.nrBins
502  << "\n binThresholds size = " << binThreshSize
503  << "\n Please fix the L1GetLimits class.\n\n"
504  << std::endl;
505  }
506 
507  for (int iBin = 0; iBin < binThreshSize; ++iBin) {
508  LogTrace("L1GetHistLimits") << " Bin " << std::right << std::setw(5) << iBin << ": "
509  << m_l1HistLimits.binThresholds[iBin] << std::endl;
510  }
511  }
512 
513  return m_l1HistLimits;
514 }
edm::isDebugEnabled
bool isDebugEnabled()
Definition: MessageLogger.cc:12
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:57
L1GetHistLimits::m_l1HistLimits
L1HistLimits m_l1HistLimits
all limits for a histogram
Definition: L1GetHistLimits.h:124
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:234
L1GetHistLimits::L1HistLimits::binThresholds
std::vector< float > binThresholds
Definition: L1GetHistLimits.h:82
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:233
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 516 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.

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

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

605  {
606  getHistLimits(l1GtObject, quantity);
607  return m_l1HistLimits.lowerBinValue;
608 }
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:57
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 600 of file L1GetHistLimits.cc.

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

600  {
601  getHistLimits(l1GtObject, quantity);
602  return m_l1HistLimits.nrBins;
603 }
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:57
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 610 of file L1GetHistLimits.cc.

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

610  {
611  getHistLimits(l1GtObject, quantity);
612  return m_l1HistLimits.upperBinValue;
613 }
L1GetHistLimits::getHistLimits
void getHistLimits(const L1GtObject &l1GtObject, const std::string &quantity)
Definition: L1GetHistLimits.cc:57
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().

const Tokens& L1GetHistLimits::m_tokens
private

Definition at line 120 of file L1GetHistLimits.h.

Referenced by getHistLimits().

Generated for CMSSW Reference Manual by doxygen 1.8.5