Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
L1EnergyCMXTools.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include <map>
6 #include <utility>
7 
8 #include "GaudiKernel/MsgStream.h"
9 #include "TrigT1CaloEvent/CMXEtSums.h"
10 #include "TrigT1CaloEvent/JEMEtSums.h"
11 #include "xAODTrigL1Calo/JetElement.h"
12 #include "TrigT1CaloUtils/ModuleEnergy.h"
13 #include "TrigT1CaloUtils/CrateEnergy.h"
14 #include "TrigT1CaloUtils/SystemEnergy.h"
15 #include "TrigT1CaloUtils/DataError.h"
16 #include "L1EnergyCMXTools.h"
17 #include "TrigConfL1Data/TriggerThreshold.h"
18 #include "TrigConfL1Data/L1DataDef.h"
19 
20 namespace LVL1
21 {
22 
25 L1EnergyCMXTools::L1EnergyCMXTools(const std::string &type,
26  const std::string &name,
27  const IInterface *parent)
28  : AthAlgTool(type, name, parent),
29  m_jeTool("LVL1::L1JetElementTools/L1JetElementTools"),
30  m_etTool("LVL1::L1EtTools/L1EtTools")
31 {
32  declareInterface<IL1EnergyCMXTools>(this);
33  declareProperty("JetElementTool", m_jeTool);
34  declareProperty("EtTool", m_etTool);
35 }
36 
39 L1EnergyCMXTools::~L1EnergyCMXTools()
40 {
41 }
42 
45 StatusCode L1EnergyCMXTools::initialize()
46 {
47  m_debug = msgLvl(MSG::DEBUG);
48  ATH_CHECK( m_L1MenuKey.initialize() );
49 
50  // Retrieve jet element tool
51 
52  ATH_CHECK(m_jeTool.retrieve());
53  ATH_CHECK(m_etTool.retrieve());
54 
55  return StatusCode::SUCCESS;
56 }
57 
60 StatusCode L1EnergyCMXTools::finalize()
61 {
62  return StatusCode::SUCCESS;
63 }
64 
71 void L1EnergyCMXTools::formJEMEtSums(
72  const xAOD::JetElementContainer *jetElementVec,
73  xAOD::JEMEtSumsContainer *jemEtSumsVec) const
74 {
75  // Find number of slices
76  int peak = 0;
77  unsigned int nslices = 1;
78  xAOD::JetElementContainer::const_iterator iter = jetElementVec->begin();
79  xAOD::JetElementContainer::const_iterator iterE = jetElementVec->end();
80  for (; iter != iterE; ++iter)
81  {
82  if ((*iter)->emJetElementETVec().size() > nslices)
83  {
84  nslices = (*iter)->emJetElementETVec().size();
85  peak = (*iter)->peak();
86  break;
87  }
88  if ((*iter)->hadJetElementETVec().size() > nslices)
89  {
90  nslices = (*iter)->hadJetElementETVec().size();
91  peak = (*iter)->peak();
92  break;
93  }
94  }
95  // Process each slice
96  xAOD::JetElementMap_t jeMap;
97  m_jeTool->mapJetElements(jetElementVec, &jeMap);
98  MultiSliceModuleEnergy modulesVec;
99  for (unsigned int slice = 0; slice < nslices; ++slice)
100  {
101  DataVector<ModuleEnergy> *modules = new DataVector<ModuleEnergy>;
102  modulesVec.push_back(modules);
103  m_etTool->moduleSums(&jeMap, modules, slice);
104  }
105  // Convert to JEMEtSums
106  moduleEnergyToEtSums(modulesVec, jemEtSumsVec, peak);
107  MultiSliceModuleEnergy::iterator miter = modulesVec.begin();
108  MultiSliceModuleEnergy::iterator miterE = modulesVec.end();
109  for (; miter != miterE; ++miter)
110  delete *miter;
111 }
112 
115 void L1EnergyCMXTools::formCMXEtSums(const xAOD::JEMEtSumsContainer *jemEtSumsVec,
116  xAOD::CMXEtSumsContainer *cmxEtSumsVec) const
117 {
118  formCMXEtSumsModule(jemEtSumsVec, cmxEtSumsVec);
119  // Convert to internal containers
120  int peak = 0;
121  MultiSliceModuleEnergy modulesVec;
122  MultiSliceCrateEnergy cratesVec;
123  MultiSliceSystemEnergy systemVec;
124  etSumsToModuleEnergy(cmxEtSumsVec, modulesVec, peak);
125  // Process each slice
126  MultiSliceModuleEnergy::iterator iter = modulesVec.begin();
127  MultiSliceModuleEnergy::iterator iterE = modulesVec.end();
128 
129  auto l1Menu = SG::makeHandle( m_L1MenuKey );
130  for (; iter != iterE; ++iter)
131  {
132  DataVector<ModuleEnergy> *modules = *iter;
133  DataVector<CrateEnergy> *crates = new DataVector<CrateEnergy>;
134  cratesVec.push_back(crates);
135  m_etTool->crateSums(modules, crates);
136  systemVec.push_back(new SystemEnergy(crates, &(*l1Menu)));
137  delete modules;
138  }
139  // Convert back to CMXEtSums
140  crateEnergyToEtSums(cratesVec, cmxEtSumsVec, peak);
141  MultiSliceCrateEnergy::iterator citer = cratesVec.begin();
142  MultiSliceCrateEnergy::iterator citerE = cratesVec.end();
143  for (; citer != citerE; ++citer)
144  delete *citer;
145  systemEnergyToEtSums(systemVec, cmxEtSumsVec, peak);
146  etMapsToEtSums(systemVec, cmxEtSumsVec, peak);
147  MultiSliceSystemEnergy::iterator siter = systemVec.begin();
148  MultiSliceSystemEnergy::iterator siterE = systemVec.end();
149  for (; siter != siterE; ++siter)
150  delete *siter;
151 }
152 
155 void L1EnergyCMXTools::formCMXEtSumsModule(
156  const xAOD::JEMEtSumsContainer *jemEtSumsVec,
157  xAOD::CMXEtSumsContainer *cmxEtSumsMod) const
158 {
159  xAOD::JEMEtSumsContainer::const_iterator pos = jemEtSumsVec->begin();
160  xAOD::JEMEtSumsContainer::const_iterator pose = jemEtSumsVec->end();
161  for (; pos != pose; ++pos)
162  {
163  const xAOD::JEMEtSums *sums = *pos;
164  ErrorVector err(sums->etVec().size());
165  auto item = new xAOD::CMXEtSums;
166  item->makePrivateStore();
167  item->initialize(sums->crate(), sums->module(),
168  sums->etVec(), sums->exVec(), sums->eyVec(),
169  err, err, err, sums->peak());
170  cmxEtSumsMod->push_back(item);
171  }
172 }
173 
175 void L1EnergyCMXTools::findRestrictedEta(uint32_t &maskXE, uint32_t &maskTE) const
176 {
177  using TrigConf::L1DataDef;
178  const float moduleEta[8] = {-4.,-2.,-1.2,-0.4,0.4,1.2,2.,4.};
179  maskXE = 0;
180  maskTE = 0;
181  bool maskXESet = false;
182  bool maskTESet = false;
183 
184  auto l1Menu = SG::makeHandle( m_L1MenuKey );
185  std::vector<std::shared_ptr<TrigConf::L1Threshold>> allThresholds = l1Menu->thresholds();
186  for ( const auto& thresh : allThresholds ) {
187  if ( ( thresh->type() == L1DataDef::typeAsString(L1DataDef::XE) ||
188  thresh->type() == L1DataDef::typeAsString(L1DataDef::TE) ) && thresh->mapping() > 7 ) {
189  auto thresh_Calo = static_cast<TrigConf::L1Threshold_Calo*>(thresh.get());
190  auto tvcs = thresh_Calo->thrValuesCounts();
191  // Make sure only set masks from the first valid threshold in the range (for each type)
192  if (maskXE > 0) maskXESet = true;
193  if (maskTE > 0) maskTESet = true;
194  if (tvcs.size() == 0) {
195  tvcs.addRangeValue(thresh_Calo->thrValueCounts(),-49, 49, 1, true);
196  }
197  for (const auto& tVC : tvcs) {
198  // Bits are set false by default, so ignore thresholds that are just doing that
199  if (tVC.value() >= 0x7fff) continue;
200  // Set bits true if module centre between etaMin and etaMax
201  if ( thresh->type() == L1DataDef::typeAsString(L1DataDef::XE) && !maskXESet ) {
202  for (unsigned int bin = 0; bin < 8; ++bin) {
203  if (moduleEta[bin] > tVC.etaMin()*0.1 && moduleEta[bin] < tVC.etaMax()*0.1)
204  maskXE |= (1<<bin);
205  }
206  }
207  else if ( thresh->type() == L1DataDef::typeAsString(L1DataDef::TE) && !maskTESet ) {
208  for (unsigned int bin = 0; bin < 8; ++bin) {
209  if (moduleEta[bin] > tVC.etaMin()*0.1 && moduleEta[bin] < tVC.etaMax()*0.1)
210  maskTE |= (1<<bin);
211  }
212  }
213  } // loop over TTV
214  } // Is this XE or TE threshold?
215  }
216 }
217 void L1EnergyCMXTools::formCMXEtSumsCrate(
218  const xAOD::CMXEtSumsContainer *cmxEtSumsMod,
219  xAOD::CMXEtSumsContainer *cmxEtSumsCrate) const
220 {
221  uint32_t maskXE, maskTE;
222  findRestrictedEta(maskXE, maskTE);
223  ATH_MSG_DEBUG("Restricted eta masks: XE=" << MSG::hex << maskXE << ", TE=" << maskTE << MSG::dec);
224  // Convert to internal containers
225  int peak = 0;
226  MultiSliceModuleEnergy modulesVec;
227  MultiSliceCrateEnergy cratesVecFull;
228  MultiSliceCrateEnergy cratesVecRestricted;
229  etSumsToModuleEnergy(cmxEtSumsMod, modulesVec, peak);
230  // Process each slice
231  for (auto iter : modulesVec)
232  {
233  DataVector<ModuleEnergy> *modules = iter;
234  DataVector<CrateEnergy> *cratesFull = new DataVector<CrateEnergy>;
235  DataVector<CrateEnergy> *cratesRestricted = new DataVector<CrateEnergy>;
236  cratesVecFull.push_back(cratesFull);
237  cratesVecRestricted.push_back(cratesRestricted);
238  m_etTool->crateSums(modules, cratesFull);
239  m_etTool->crateSums(modules, cratesRestricted, maskXE, maskTE, true);
240  delete modules;
241  }
242 
243  // Convert back to CMXEtSums
244  crateEnergyToEtSums(cratesVecFull, cratesVecRestricted, cmxEtSumsCrate, peak);
245  // crateEnergyToEtSums(cratesVecRestricted, cmxEtSumsCrate, peak);
246 
247  for (auto crate : cratesVecFull)
248  {
249  delete crate;
250  }
251  for (auto crate : cratesVecRestricted)
252  {
253  delete crate;
254  }
255 }
256 
259 void L1EnergyCMXTools::formCMXEtSumsSystem(
260  const xAOD::CMXEtSumsContainer *cmxEtSumsCrate,
261  xAOD::CMXEtSumsContainer *cmxEtSumsSys) const
262 {
263  // Convert to internal containers
264  int peak = 0;
265  MultiSliceCrateEnergy cratesVecFull;
266  MultiSliceCrateEnergy cratesVecRestricted;
267 
268  MultiSliceSystemEnergy systemVecFull;
269  MultiSliceSystemEnergy systemVecRestricted;
270  auto l1Menu = SG::makeHandle( m_L1MenuKey );
271  etSumsToCrateEnergy(cmxEtSumsCrate, cratesVecFull, cratesVecRestricted, peak);
272  for (int i = 0; i < 2; i++)
273  {
274  MultiSliceCrateEnergy *cratesVec = i == 0? &cratesVecFull: &cratesVecRestricted;
275  MultiSliceSystemEnergy *systemVec = i == 0? &systemVecFull: &systemVecRestricted;
276  // Process each slice
277  MultiSliceCrateEnergy::iterator iter = (*cratesVec).begin();
278  MultiSliceCrateEnergy::iterator iterE = (*cratesVec).end();
279  for (; iter != iterE; ++iter)
280  {
281  DataVector<CrateEnergy> *crates = *iter;
282  //systemVec.push_back(new SystemEnergy(m_etTool->systemSums(crates)));
283  systemVec->push_back(new SystemEnergy(crates, &(*l1Menu)));
284  delete crates;
285  }
286  }
287  // Convert back to CMXEtSums
288  systemEnergyToEtSums(systemVecFull, cmxEtSumsSys, peak, xAOD::CMXEtSums::TOTAL_STANDARD);
289  systemEnergyToEtSums(systemVecRestricted, cmxEtSumsSys, peak, xAOD::CMXEtSums::TOTAL_RESTRICTED);
290 
291  for (int i = 0; i < 2; i++)
292  {
293  MultiSliceSystemEnergy *systemVec = i == 0? &systemVecFull: &systemVecRestricted;
294  MultiSliceSystemEnergy::iterator siter = (*systemVec).begin();
295  MultiSliceSystemEnergy::iterator siterE = (*systemVec).end();
296  for (; siter != siterE; ++siter)
297  delete *siter;
298  }
299 }
300 
304 void L1EnergyCMXTools::formCMXEtSumsEtMaps(
305  const xAOD::CMXEtSumsContainer *cmxEtSumsSys,
306  xAOD::CMXEtSumsContainer *cmxEtSumsMap) const
307 {
308  // Convert to internal objects
309  int peak = 0;
310  MultiSliceSystemEnergy systemVec;
311  etSumsToSystemEnergy(cmxEtSumsSys, systemVec, peak);
312  // Convert back to CMXEtSums
313  etMapsToEtSums(systemVec, cmxEtSumsMap, peak);
314  MultiSliceSystemEnergy::iterator iter = systemVec.begin();
315  MultiSliceSystemEnergy::iterator iterE = systemVec.end();
316  for (; iter != iterE; ++iter)
317  delete *iter;
318 }
319 
322 void L1EnergyCMXTools::etSumsToModuleEnergy(
323  const xAOD::CMXEtSumsContainer *etSums,
324  MultiSliceModuleEnergy &modulesVec, int &peak) const
325 {
326  peak = 0;
327  unsigned int nslices = 0;
328  xAOD::CMXEtSumsContainer::const_iterator pos = etSums->begin();
329  xAOD::CMXEtSumsContainer::const_iterator pose = etSums->end();
330  for (; pos != pose; ++pos)
331  {
332  const xAOD::CMXEtSums *sums = *pos;
333  int source = sums->sourceComponent();
334  if (source > 15)
335  continue;
336  int crate = sums->crate();
337  if (sums->peak() > peak)
338  peak = sums->peak();
339  const EnergyVector &ex(sums->exVec());
340  const EnergyVector &ey(sums->eyVec());
341  const EnergyVector &et(sums->etVec());
342  unsigned int slices = et.size();
343  if (slices > nslices)
344  {
345  for (unsigned int i = nslices; i < slices; ++i)
346  {
347  modulesVec.push_back(new DataVector<ModuleEnergy>);
348  }
349  nslices = slices;
350  }
351  for (unsigned int sl = 0; sl < slices; ++sl)
352  {
353  DataVector<ModuleEnergy> *modules = modulesVec[sl];
354  modules->push_back(new ModuleEnergy(crate, source,
355  et[sl], ex[sl], ey[sl]));
356  }
357  }
358 }
359 
362 void L1EnergyCMXTools::etSumsToCrateEnergy(const xAOD::CMXEtSumsContainer *etSums,
363  MultiSliceCrateEnergy &crateVecFull,
364  MultiSliceCrateEnergy &crateVecRestricted, int &peak) const
365 {
366  peak = 0;
367  unsigned int nslicesFull = 0;
368  unsigned int nslicesRestricted = 0;
369  xAOD::CMXEtSumsContainer::const_iterator pos = etSums->begin();
370  xAOD::CMXEtSumsContainer::const_iterator pose = etSums->end();
371 
372  MultiSliceCrateEnergy *crateVec = nullptr;
373  unsigned int *nslices = nullptr;
374  bool restricted = false;
375  for (; pos != pose; ++pos)
376  {
377  const xAOD::CMXEtSums *sums = *pos;
378  int crate = sums->crate();
379  if (crate != 1)
380  continue;
381  int source = sums->sourceComponent();
382  if (source != xAOD::CMXEtSums::LOCAL_STANDARD && source != xAOD::CMXEtSums::LOCAL_RESTRICTED
383  && source != xAOD::CMXEtSums::REMOTE_STANDARD && source != xAOD::CMXEtSums::REMOTE_RESTRICTED)
384  continue;
385  if (source == xAOD::CMXEtSums::REMOTE_STANDARD || source == xAOD::CMXEtSums::REMOTE_RESTRICTED)
386  crate = 0; // SASHA: check
387  if (source == xAOD::CMXEtSums::LOCAL_RESTRICTED || source == xAOD::CMXEtSums::REMOTE_RESTRICTED){
388  crateVec = &crateVecRestricted;
389  nslices = &nslicesRestricted;
390  restricted = true;
391  }else{
392  crateVec = &crateVecFull;
393  nslices = &nslicesFull;
394  restricted = false;
395  }
396  if (sums->peak() > peak)
397  peak = sums->peak();
398  const EnergyVector &ex(sums->exVec());
399  const EnergyVector &ey(sums->eyVec());
400  const EnergyVector &et(sums->etVec());
401  const ErrorVector &exErrVec(sums->exErrorVec());
402  const ErrorVector &eyErrVec(sums->eyErrorVec());
403  const ErrorVector &etErrVec(sums->etErrorVec());
404  unsigned int slices = et.size();
405 
406  if (slices > *nslices)
407  {
408  for (unsigned int i = *nslices; i < slices; ++i)
409  {
410  crateVec->push_back(new DataVector<CrateEnergy>);
411  }
412  *nslices = slices;
413  }
414  for (unsigned int sl = 0; sl < slices; ++sl)
415  {
416  DataVector<CrateEnergy> *crates = (*crateVec)[sl];
417  DataError exErr(exErrVec[sl]);
418  DataError eyErr(eyErrVec[sl]);
419  DataError etErr(etErrVec[sl]);
420  crates->push_back(new CrateEnergy(crate, et[sl], ex[sl], ey[sl],
421  etErr.get(DataError::Overflow),
422  exErr.get(DataError::Overflow),
423  eyErr.get(DataError::Overflow), restricted));
424  }
425  }
426 
427  dumpCrateEnergies("Crates from full region (for total)", crateVecFull);
428  dumpCrateEnergies("Crates from restricted region (for total)", crateVecRestricted);
429 }
430 
433 void L1EnergyCMXTools::etSumsToSystemEnergy(
434  const xAOD::CMXEtSumsContainer *etSums,
435  MultiSliceSystemEnergy &systemVec, int &peak) const
436 {
437  peak = 0;
438  xAOD::CMXEtSumsContainer::const_iterator pos = etSums->begin();
439  xAOD::CMXEtSumsContainer::const_iterator pose = etSums->end();
440  for (; pos != pose; ++pos)
441  {
442  const xAOD::CMXEtSums *sums = *pos;
443  int source = sums->sourceComponent();
444  if (source != xAOD::CMXEtSums::TOTAL_STANDARD && source != xAOD::CMXEtSums::TOTAL_RESTRICTED)
445  continue;
446  if (sums->peak() > peak)
447  peak = sums->peak();
448  const EnergyVector &ex(sums->exVec());
449  const EnergyVector &ey(sums->eyVec());
450  const EnergyVector &et(sums->etVec());
451  const ErrorVector &exErrVec(sums->exErrorVec());
452  const ErrorVector &eyErrVec(sums->eyErrorVec());
453  const ErrorVector &etErrVec(sums->etErrorVec());
454  unsigned int slices = et.size();
455  auto l1Menu = SG::makeHandle( m_L1MenuKey );
456  for (unsigned int sl = 0; sl < slices; ++sl)
457  {
458  DataError exErr(exErrVec[sl]);
459  DataError eyErr(eyErrVec[sl]);
460  DataError etErr(etErrVec[sl]);
461  auto systemEnergy = new SystemEnergy(et[sl], ex[sl], ey[sl],
462  etErr.get(DataError::Overflow),
463  exErr.get(DataError::Overflow),
464  eyErr.get(DataError::Overflow),
465  source == xAOD::CMXEtSums::TOTAL_RESTRICTED,
466  &(*l1Menu));
467  // bool srestricted = (systemEnergy->roiWord0() >> 26) & 1;
468  systemVec.push_back(systemEnergy);
469  }
470  }
471 }
472 
475 void L1EnergyCMXTools::moduleEnergyToEtSums(
476  const MultiSliceModuleEnergy &modulesVec,
477  xAOD::JEMEtSumsContainer *jemEtSumsVec, int peak) const
478 {
479  std::map<int, xAOD::JEMEtSums *> etMap;
480  unsigned int nslices = modulesVec.size();
481  std::vector<uint16_t> dummy(nslices);
482  for (unsigned int slice = 0; slice < nslices; ++slice)
483  {
484  const DataVector<ModuleEnergy> *modules = modulesVec[slice];
485  DataVector<ModuleEnergy>::const_iterator pos = modules->begin();
486  DataVector<ModuleEnergy>::const_iterator pose = modules->end();
487  for (; pos != pose; ++pos)
488  {
489  const ModuleEnergy *energy = *pos;
490  //unsigned int ex = energy->exCompressed();
491  //unsigned int ey = energy->eyCompressed();
492  //unsigned int et = energy->etCompressed();
493  unsigned int ex = energy->ex();
494  unsigned int ey = energy->ey();
495  unsigned int et = energy->et();
496  if (ex == 0 && ey == 0 && et == 0)
497  continue;
498  int crate = energy->crate();
499  int module = energy->module();
500  xAOD::JEMEtSums *sums = 0;
501  int key = crate * 100 + module;
502  std::map<int, xAOD::JEMEtSums *>::iterator iter = etMap.find(key);
503  if (iter == etMap.end())
504  {
505  sums = new xAOD::JEMEtSums;
506  sums->makePrivateStore();
507  sums->initialize(crate, module, dummy, dummy, dummy, peak);
508  etMap.insert(std::make_pair(key, sums));
509  jemEtSumsVec->push_back(sums);
510  }
511  else
512  sums = iter->second;
513  std::vector<uint16_t> exVec(sums->exVec());
514  std::vector<uint16_t> eyVec(sums->eyVec());
515  std::vector<uint16_t> etVec(sums->etVec());
516  exVec[slice] = ex;
517  eyVec[slice] = ey;
518  etVec[slice] = et;
519  sums->setExVec(exVec);
520  sums->setEyVec(eyVec);
521  sums->setEtVec(etVec);
522  }
523  }
524 }
525 
528 void L1EnergyCMXTools::crateEnergyToEtSums(
529  const MultiSliceCrateEnergy &cratesVec,
530  xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
531 {
532  std::map<int, xAOD::CMXEtSums *> etMap;
533  unsigned int nslices = cratesVec.size();
534  std::vector<uint16_t> dummy(nslices);
535  std::vector<uint32_t> error(nslices);
536  for (unsigned int slice = 0; slice < nslices; ++slice)
537  {
538  const DataVector<CrateEnergy> *crates = cratesVec[slice];
539  DataVector<CrateEnergy>::const_iterator pos = crates->begin();
540  DataVector<CrateEnergy>::const_iterator pose = crates->end();
541  for (; pos != pose; ++pos)
542  {
543  const CrateEnergy *energy = *pos;
544  unsigned int ex = energy->exTC();
545  unsigned int ey = energy->eyTC();
546  unsigned int et = energy->et();
547  int exOverflow = energy->exOverflow();
548  int eyOverflow = energy->eyOverflow();
549  int etOverflow = energy->etOverflow();
550  if (ex == 0 && ey == 0 && et == 0 &&
551  exOverflow == 0 && eyOverflow == 0 && etOverflow == 0)
552  continue;
553  int crate = energy->crate();
554  xAOD::CMXEtSums *sums = 0;
555  int source = xAOD::CMXEtSums::LOCAL_STANDARD;
556  for (int i = 0; i < 2; ++i)
557  {
558  for (int j = 0; j < 2; ++j)
559  {
560  int key = crate * 100 + source;
561  std::map<int, xAOD::CMXEtSums *>::iterator iter = etMap.find(key);
562  if (iter == etMap.end())
563  {
564  sums = new xAOD::CMXEtSums;
565  sums->makePrivateStore();
566  sums->initialize(crate, source, dummy, dummy, dummy,
567  error, error, error, peak);
568  etMap.insert(std::make_pair(key, sums));
569  cmxEtSumsVec->push_back(sums);
570  }
571  else
572  sums = iter->second;
573  std::vector<uint16_t> exVec(sums->exVec());
574  std::vector<uint16_t> eyVec(sums->eyVec());
575  std::vector<uint16_t> etVec(sums->etVec());
576  std::vector<uint32_t> exErr(sums->exErrorVec());
577  std::vector<uint32_t> eyErr(sums->eyErrorVec());
578  std::vector<uint32_t> etErr(sums->etErrorVec());
579  exVec[slice] = ex;
580  eyVec[slice] = ey;
581  etVec[slice] = et;
582  if (exOverflow)
583  {
584  DataError dEx(exErr[slice]);
585  dEx.set(DataError::Overflow);
586  exErr[slice] = dEx.error();
587  }
588  if (eyOverflow)
589  {
590  DataError dEy(eyErr[slice]);
591  dEy.set(DataError::Overflow);
592  eyErr[slice] = dEy.error();
593  }
594  if (etOverflow)
595  {
596  DataError dEt(etErr[slice]);
597  dEt.set(DataError::Overflow);
598  etErr[slice] = dEt.error();
599  }
600  sums->addEx(exVec, exErr);
601  sums->addEy(eyVec, eyErr);
602  sums->addEt(etVec, etErr);
603  if (source == xAOD::CMXEtSums::LOCAL_STANDARD)
604  {
605  source = xAOD::CMXEtSums::LOCAL_RESTRICTED;
606  }
607  else
608  {
609  source = xAOD::CMXEtSums::REMOTE_RESTRICTED;
610  }
611  }
612  if (crate == 1)
613  break;
614  crate = 1;
615  source = xAOD::CMXEtSums::REMOTE_STANDARD;
616  }
617  }
618  }
619 }
620 
621 void L1EnergyCMXTools::crateEnergyToEtSums(
622  const MultiSliceCrateEnergy &cratesVecFull, const MultiSliceCrateEnergy &cratesVecRestricted,
623  xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
624 {
625  std::map<int, xAOD::CMXEtSums *> etMap;
626  unsigned int nslices = cratesVecFull.size();
627  std::vector<uint16_t> dummy(nslices);
628  std::vector<uint32_t> error(nslices);
629 
630  dumpCrateEnergies("Crates from full region", cratesVecFull);
631  dumpCrateEnergies("Crates from restricted region", cratesVecRestricted);
632 
633 
634  for (unsigned int slice = 0; slice < nslices; ++slice)
635  {
636  for (unsigned int i = 0; i < 2; i++)
637  {
638  const auto *crates = (i == 0 ? cratesVecFull[slice] : cratesVecRestricted[slice]);
639  int origSource = i == 0 ? xAOD::CMXEtSums::LOCAL_STANDARD : xAOD::CMXEtSums::LOCAL_RESTRICTED;
640 
641  for (auto pos : *crates)
642  {
643  int source = origSource;
644  const CrateEnergy *energy = pos;
645  unsigned int ex = energy->exTC();
646  unsigned int ey = energy->eyTC();
647  unsigned int et = energy->et();
648  int exOverflow = energy->exOverflow();
649  int eyOverflow = energy->eyOverflow();
650  int etOverflow = energy->etOverflow();
651  if (ex == 0 && ey == 0 && et == 0 &&
652  exOverflow == 0 && eyOverflow == 0 && etOverflow == 0)
653  continue;
654  int crate = energy->crate();
655  xAOD::CMXEtSums *sums = 0;
656 
657  while (true)
658  {
659  int key = crate * 100 + source;
660  std::map<int, xAOD::CMXEtSums *>::iterator iter = etMap.find(key);
661  if (iter == etMap.end())
662  {
663  sums = new xAOD::CMXEtSums;
664  sums->makePrivateStore();
665  sums->initialize(crate, source, dummy, dummy, dummy,
666  error, error, error, peak);
667  etMap.insert(std::make_pair(key, sums));
668  cmxEtSumsVec->push_back(sums);
669  }
670  else
671  sums = iter->second;
672  std::vector<uint16_t> exVec(sums->exVec());
673  std::vector<uint16_t> eyVec(sums->eyVec());
674  std::vector<uint16_t> etVec(sums->etVec());
675  std::vector<uint32_t> exErr(sums->exErrorVec());
676  std::vector<uint32_t> eyErr(sums->eyErrorVec());
677  std::vector<uint32_t> etErr(sums->etErrorVec());
678  exVec[slice] = ex;
679  eyVec[slice] = ey;
680  etVec[slice] = et;
681  if (exOverflow)
682  {
683  DataError dEx(exErr[slice]);
684  dEx.set(DataError::Overflow);
685  exErr[slice] = dEx.error();
686  }
687  if (eyOverflow)
688  {
689  DataError dEy(eyErr[slice]);
690  dEy.set(DataError::Overflow);
691  eyErr[slice] = dEy.error();
692  }
693  if (etOverflow)
694  {
695  DataError dEt(etErr[slice]);
696  dEt.set(DataError::Overflow);
697  etErr[slice] = dEt.error();
698  }
699  sums->addEx(exVec, exErr);
700  sums->addEy(eyVec, eyErr);
701  sums->addEt(etVec, etErr);
702  if (source == xAOD::CMXEtSums::LOCAL_STANDARD)
703  {
704  if (crate == 1)
705  {
706  break;
707  }
708  else
709  {
710  crate = 1;
711  source = xAOD::CMXEtSums::REMOTE_STANDARD;
712  }
713  }
714  else if (source == xAOD::CMXEtSums::LOCAL_RESTRICTED)
715  {
716  if (crate == 1)
717  {
718  break;
719  }
720  else
721  {
722  crate = 1;
723  source = xAOD::CMXEtSums::REMOTE_RESTRICTED;
724  }
725  }
726  else
727  {
728  break;
729  }
730  }
731  } // crates
732  } //for i
733  }
734 }
735 
738 void L1EnergyCMXTools::systemEnergyToEtSums(
739  const MultiSliceSystemEnergy &systemVec,
740  xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak, xAOD::CMXEtSums_v1::Sources source) const
741 {
742  xAOD::CMXEtSums *sums = nullptr;
743 
744  unsigned int nslices = systemVec.size();
745  std::vector<uint16_t> data(nslices);
746  std::vector<uint32_t> error(nslices);
747  for (unsigned int slice = 0; slice < nslices; ++slice)
748  {
749  SystemEnergy *energy = systemVec[slice];
750  unsigned int ex = energy->exTC();
751  unsigned int ey = energy->eyTC();
752  unsigned int et = energy->et();
753  int exOverflow = energy->exOverflow();
754  int eyOverflow = energy->eyOverflow();
755  int etOverflow = energy->etOverflow();
756 
757  // don't trust to exOverflow for restricted
758  if (ex == 0 && ey == 0 && et == 0 &&
759  exOverflow == 0 && eyOverflow == 0 && etOverflow == 0)
760  continue;
761  if (!sums)
762  {
763  sums = new xAOD::CMXEtSums;
764  sums->makePrivateStore();
765  sums->initialize(1, source, data, data, data,
766  error, error, error, peak);
767  cmxEtSumsVec->push_back(sums);
768  }
769  std::vector<uint16_t> exVec(sums->exVec());
770  std::vector<uint16_t> eyVec(sums->eyVec());
771  std::vector<uint16_t> etVec(sums->etVec());
772  std::vector<uint32_t> exErr(sums->exErrorVec());
773  std::vector<uint32_t> eyErr(sums->eyErrorVec());
774  std::vector<uint32_t> etErr(sums->etErrorVec());
775  exVec[slice] = ex;
776  eyVec[slice] = ey;
777  etVec[slice] = et;
778 
779  if (exOverflow)
780  {
781  DataError dEx(exErr[slice]);
782  dEx.set(DataError::Overflow);
783  exErr[slice] = dEx.error();
784  }
785 
786  if (eyOverflow)
787  {
788  DataError dEy(eyErr[slice]);
789  dEy.set(DataError::Overflow);
790  eyErr[slice] = dEy.error();
791  }
792  if (etOverflow)
793  {
794  DataError dEt(etErr[slice]);
795  dEt.set(DataError::Overflow);
796  etErr[slice] = dEt.error();
797  }
798  sums->addEx(exVec, exErr);
799  sums->addEy(eyVec, eyErr);
800  sums->addEt(etVec, etErr);
801  }
802 }
803 
806 void L1EnergyCMXTools::etMapsToEtSums(
807  const MultiSliceSystemEnergy &systemVec,
808  xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
809 {
810 
811  xAOD::CMXEtSums **sumEt = 0;
812  xAOD::CMXEtSums **missEt = 0;
813  xAOD::CMXEtSums **missEtSig = 0;
814 
815  xAOD::CMXEtSums *sumEtFull = 0;
816  xAOD::CMXEtSums *missEtFull = 0;
817  xAOD::CMXEtSums *missEtSigFull = 0;
818 
819  xAOD::CMXEtSums *sumEtRestricted = 0;
820  xAOD::CMXEtSums *missEtRestricted = 0;
821  xAOD::CMXEtSums *missEtSigRestricted = 0;
822 
823  int nslicesFull = 0;
824  int nslicesRestricted = 0;
825 
826  std::map<int, bool> isRestrictedMap;
827 
828 
829  for (unsigned int i = 0; i < systemVec.size(); ++i)
830  {
831  bool isRestricted = (systemVec[i]->roiWord0() >> 26) & 1;
832  isRestrictedMap[i] = isRestricted;
833  if (isRestricted) {
834  nslicesRestricted++;
835  }else{
836  nslicesFull++;
837  }
838  // ATH_MSG_DEBUG("isRestriced=" << isRestricted << " slice=" << (isRestricted? nslicesRestricted: nslicesFull)
839  // << " et=" << systemVec[i]->et() << " etSumHits=" << systemVec[i]->etSumHits());
840  }
841 
842  std::vector<uint16_t> dataFull(nslicesFull);
843  std::vector<uint32_t> errorFull(nslicesFull);
844 
845  std::vector<uint16_t> dataRestricted(nslicesRestricted);
846  std::vector<uint32_t> errorRestricted(nslicesRestricted);
847 
848  int iSliceFull = 0;
849  int iSliceRestricted = 0;
850  int *iSlice = 0;
851 
852  for (unsigned int i = 0; i < systemVec.size(); ++i)
853  {
854  SystemEnergy *energy = systemVec[i];
855  bool restricted = isRestrictedMap[i];
856 
857  std::vector<uint16_t>* data;
858  std::vector<uint32_t>* error;
859  if (restricted)
860  {
861  sumEt = &sumEtRestricted;
862  missEt = &missEtRestricted;
863  missEtSig = &missEtSigRestricted;
864  iSlice = &iSliceRestricted;
865  data = &dataRestricted;
866  error = &errorRestricted;
867  }
868  else
869  {
870  sumEt = &sumEtFull;
871  missEt = &missEtFull;
872  missEtSig = &missEtSigFull;
873  iSlice = &iSliceFull;
874  data = &dataFull;
875  error = &errorFull;
876  }
877 
878  unsigned int slice = *iSlice;
879 
880 
881  unsigned int etSumHits = energy->etSumHits();
882  if (etSumHits)
883  {
884  if (!*sumEt)
885  {
886  *sumEt = new xAOD::CMXEtSums;
887  (*sumEt)->makePrivateStore();
888  (*sumEt)->initialize(1, restricted
889  ? CMXEtSums::SUM_ET_RESTRICTED
890  : CMXEtSums::SUM_ET_STANDARD,
891  *data, *data, *data, *error, *error, *error, peak);
892  cmxEtSumsVec->push_back(*sumEt);
893  }
894  std::vector<uint16_t> etVec((*sumEt)->etVec());
895  etVec[slice] = etSumHits;
896 
897  (*sumEt)->addEx(etVec, *error);
898  (*sumEt)->addEy(etVec, *error);
899  (*sumEt)->addEt(etVec, *error);
900 
901  // ATH_MSG_DEBUG("slice=" << slice << " restricted=" << restricted << " etVec=" << (*sumEt)->etVec() << " etSumHits=" << etSumHits);
902  }
903  unsigned int etMissHits = energy->etMissHits();
904  if (etMissHits)
905  {
906  if (!*missEt)
907  {
908  *missEt = new xAOD::CMXEtSums;
909  (*missEt)->makePrivateStore();
910  (*missEt)->initialize(1, restricted
911  ? CMXEtSums::MISSING_ET_RESTRICTED
912  : CMXEtSums::MISSING_ET_STANDARD,
913  *data, *data, *data, *error, *error, *error, peak);
914  cmxEtSumsVec->push_back(*missEt);
915  }
916  std::vector<uint16_t> etVec((*missEt)->etVec());
917  etVec[slice] = etMissHits;
918  (*missEt)->addEx(etVec, *error);
919  (*missEt)->addEy(etVec, *error);
920  (*missEt)->addEt(etVec, *error);
921  }
922  unsigned int etMissSigHits = energy->metSigHits();
923  if (etMissSigHits)
924  {
925  if (!*missEtSig)
926  {
927  *missEtSig = new xAOD::CMXEtSums;
928  (*missEtSig)->makePrivateStore();
929  (*missEtSig)->initialize(1, CMXEtSums::MISSING_ET_SIG_STANDARD, *data, *data, *data, *error, *error, *error, peak);
930  cmxEtSumsVec->push_back(*missEtSig);
931  }
932  std::vector<uint16_t> etVec((*missEtSig)->etVec());
933  etVec[slice] = etMissSigHits;
934  (*missEtSig)->addEx(etVec, *error);
935  (*missEtSig)->addEy(etVec, *error);
936  (*missEtSig)->addEt(etVec, *error);
937  }
938  (*iSlice)++;
939  }
940 }
941 
942 void L1EnergyCMXTools::dumpCrateEnergies(
943  const std::string &msg, const MultiSliceCrateEnergy &crates) const {
944  if (!m_debug) return;
945 
946  ATH_MSG_DEBUG(msg);
947  for (const auto& p : crates) {
948  for (const LVL1::CrateEnergy* c : *p) {
949  ATH_MSG_DEBUG(" CrateEnergy: crate " << c->crate() << " results ");
950  ATH_MSG_DEBUG(" Et " << c->et() << " overflow " << c->etOverflow());
951  ATH_MSG_DEBUG(" Ex " << c->ex() << " overflow " << c->exOverflow());
952  ATH_MSG_DEBUG(" Ey " << c->ey() << " overflow "<< c->eyOverflow());
953  }
954  ATH_MSG_DEBUG("");
955  }
956 }
957 
958 } // end of namespace
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
TrigConf::L1Threshold_Calo::thrValuesCounts
virtual ValueWithEtaDependence< unsigned int > thrValuesCounts() const
access to the list of ThresholdValues in energy units
Definition: L1ThresholdBase.cxx:317
xAOD::CMXEtSums_v1::LOCAL_RESTRICTED
@ LOCAL_RESTRICTED
Definition: CMXEtSums_v1.h:31
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
et
Extra patterns decribing particle interation process.
xAOD::CMXEtSums_v1::addEy
void addEy(const std::vector< uint16_t > &eyVec, const std::vector< uint32_t > &eyErrorVec)
add Ey
Definition: CMXEtSums_v1.cxx:103
JEMEtSums.h
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
module_driven_slicing.nslices
nslices
Definition: module_driven_slicing.py:575
xAOD::JEMEtSums_v2::setExVec
void setExVec(const std::vector< uint16_t > &)
set exVec - ex for all time slices
xAOD::CMXEtSums_v1::exVec
const std::vector< uint16_t > & exVec() const
get exVec
xAOD::JEMEtSums
JEMEtSums_v2 JEMEtSums
Define the latest version of the JEMEtSums class.
Definition: Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JEMEtSums.h:16
LVL1::DataError
Error data.
Definition: DataError.h:27
xAOD::JEMEtSums_v2::initialize
virtual void initialize(const uint8_t crate, const uint8_t module)
initialize
Definition: JEMEtSums_v2.cxx:24
LVL1::L1EnergyCMXTools::MultiSliceCrateEnergy
std::vector< DataVector< CrateEnergy > * > MultiSliceCrateEnergy
Definition: L1EnergyCMXTools.h:89
xAOD::et
et
Definition: TrigEMCluster_v1.cxx:25
physval_make_web_display.thresh
thresh
Definition: physval_make_web_display.py:36
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
LVL1::L1EnergyCMXTools::L1EnergyCMXTools
L1EnergyCMXTools(const std::string &type, const std::string &name, const IInterface *parent)
Constructor.
Definition: L1EnergyCMXTools.cxx:25
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
LVL1::CrateEnergy
CrateEnergy class declaration Simulates behaviour of the Crate-CMM System CMM logic is done in Energy...
Definition: CrateEnergy.h:34
LVL1::L1EnergyCMXTools::MultiSliceModuleEnergy
std::vector< DataVector< ModuleEnergy > * > MultiSliceModuleEnergy
Definition: L1EnergyCMXTools.h:88
ModuleEnergy.h
xAOD::CMXEtSums_v1::TOTAL_RESTRICTED
@ TOTAL_RESTRICTED
Definition: CMXEtSums_v1.h:32
xAOD::JEMEtSums_v2::exVec
const std::vector< uint16_t > & exVec() const
get exVec - ex for all time slices
bin
Definition: BinsDiffFromStripMedian.h:43
LVL1::CMXEtSums::SUM_ET_RESTRICTED
@ SUM_ET_RESTRICTED
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXEtSums.h:32
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
xAOD::CMXEtSums_v1::etVec
const std::vector< uint16_t > & etVec() const
get etVec
xAOD::JEMEtSums_v2::peak
uint8_t peak() const
get peak
xAOD::JEMEtSums_v2::crate
uint8_t crate() const
get crate number
LVL1::L1EnergyCMXTools::formCMXEtSumsEtMaps
virtual void formCMXEtSumsEtMaps(const xAOD::CMXEtSumsContainer *cmxEtSumsSys, xAOD::CMXEtSumsContainer *cmxEtSumsMap) const
form partial CMXEtSums (sumEt/missingEt maps) from system CMXEtSums
Definition: L1EnergyCMXTools.cxx:304
CMXEtSums.h
LVL1
eFexTowerBuilder creates xAOD::eFexTowerContainer from supercells (LATOME) and triggerTowers (TREX) i...
Definition: ICMMCPHitsCnvTool.h:18
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
xAOD::CMXEtSums_v1::peak
uint8_t peak() const
get peak
LVL1::L1EnergyCMXTools::etSumsToSystemEnergy
void etSumsToSystemEnergy(const xAOD::CMXEtSumsContainer *etSums, MultiSliceSystemEnergy &systemVec, int &peak) const
Convert CMXEtSums container to internal SystemEnergy objects.
Definition: L1EnergyCMXTools.cxx:433
xAOD::CMXEtSums_v1::REMOTE_STANDARD
@ REMOTE_STANDARD
Definition: CMXEtSums_v1.h:30
CrateEnergy.h
LVL1::L1EnergyCMXTools::m_jeTool
ToolHandle< LVL1::IL1JetElementTools > m_jeTool
Tool for JetElement map.
Definition: L1EnergyCMXTools.h:123
xAOD::JEMEtSums_v2::eyVec
const std::vector< uint16_t > & eyVec() const
get eyVec - ey for all time slices
LVL1::L1EnergyCMXTools::formCMXEtSumsModule
virtual void formCMXEtSumsModule(const xAOD::JEMEtSumsContainer *jemEtSumsVec, xAOD::CMXEtSumsContainer *cmxEtSumsMod) const
form partial CMXEtSums (module) from JEMEtSums
Definition: L1EnergyCMXTools.cxx:155
TrigConf::L1DataDef::XE
@ XE
Definition: L1DataDef.h:22
LVL1::L1EnergyCMXTools::crateEnergyToEtSums
void crateEnergyToEtSums(const MultiSliceCrateEnergy &cratesVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
Convert internal CrateEnergy containers to CMXEtSums container.
Definition: L1EnergyCMXTools.cxx:528
TrigConf::L1Threshold_Calo
Definition: L1ThresholdBase.h:188
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
xAOD::JEMEtSums_v2::setEtVec
void setEtVec(const std::vector< uint16_t > &)
set etVec - et for all time slices
python.PyAthena.module
module
Definition: PyAthena.py:131
LVL1::L1EnergyCMXTools::m_debug
bool m_debug
Debug flag.
Definition: L1EnergyCMXTools.h:127
LVL1::L1EnergyCMXTools::EnergyVector
std::vector< uint16_t > EnergyVector
Definition: L1EnergyCMXTools.h:86
LVL1::L1EnergyCMXTools::formJEMEtSums
virtual void formJEMEtSums(const xAOD::JetElementContainer *jetElementVec, xAOD::JEMEtSumsContainer *jemEtSumsVec) const
form JEMEtSums from JetElements
Definition: L1EnergyCMXTools.cxx:71
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
TrigConf::L1DataDef
Definition: L1DataDef.h:16
xAOD::JetElementMap_t
std::map< int, const JetElement * > JetElementMap_t
Definition: Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JetElement.h:18
LVL1::L1EnergyCMXTools::ErrorVector
std::vector< uint32_t > ErrorVector
Definition: L1EnergyCMXTools.h:87
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
LVL1::DataError::Overflow
@ Overflow
Definition: DataError.h:31
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:182
perfmonmt-refit.slice
slice
Definition: perfmonmt-refit.py:52
xAOD::CMXEtSums_v1
Description of CMXEtSums_v1.
Definition: CMXEtSums_v1.h:28
lumiFormat.i
int i
Definition: lumiFormat.py:85
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LVL1::DataError::set
void set(ErrorBit bit, int value=1)
Set an error bit or data.
Definition: DataError.cxx:28
xAOD::JEMEtSums_v2
Description of JEMEtSums_v2.
Definition: JEMEtSums_v2.h:26
xAOD::CMXEtSums_v1::crate
uint8_t crate() const
get crate
LVL1::L1EnergyCMXTools::m_etTool
ToolHandle< LVL1::IL1EtTools > m_etTool
Tool for energy sums.
Definition: L1EnergyCMXTools.h:125
xAOD::CMXEtSums_v1::addEt
void addEt(const std::vector< uint16_t > &etVec, const std::vector< uint32_t > &etErrorVec)
add data to existing object add Et
Definition: CMXEtSums_v1.cxx:89
LVL1::CMXEtSums::SUM_ET_STANDARD
@ SUM_ET_STANDARD
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXEtSums.h:32
xAOD::CMXEtSums_v1::TOTAL_STANDARD
@ TOTAL_STANDARD
Definition: CMXEtSums_v1.h:32
LVL1::ModuleEnergy
This is an internal class, used in the Energy trigger.
Definition: ModuleEnergy.h:45
test_pyathena.parent
parent
Definition: test_pyathena.py:15
LVL1::L1EnergyCMXTools::findRestrictedEta
void findRestrictedEta(uint32_t &maskXE, uint32_t &maskTE) const
form partial CMXEtSums (crate) from module CMXEtSums
Definition: L1EnergyCMXTools.cxx:175
JetElement.h
python.xAODType.dummy
dummy
Definition: xAODType.py:4
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
LVL1::L1EnergyCMXTools::formCMXEtSumsSystem
virtual void formCMXEtSumsSystem(const xAOD::CMXEtSumsContainer *cmxEtSumsCrate, xAOD::CMXEtSumsContainer *cmxEtSumsSys) const
form partial CMXEtSums (system) from crate CMXEtSums
Definition: L1EnergyCMXTools.cxx:259
L1EnergyCMXTools.h
TriggerThreshold.h
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
LVL1::L1EnergyCMXTools::etSumsToCrateEnergy
void etSumsToCrateEnergy(const xAOD::CMXEtSumsContainer *etSums, MultiSliceCrateEnergy &crateVecFull, MultiSliceCrateEnergy &crateVecRestricted, int &peak) const
Convert CMXEtSums container to internal CrateEnergy containers.
Definition: L1EnergyCMXTools.cxx:362
xAOD::JEMEtSums_v2::etVec
const std::vector< uint16_t > & etVec() const
Please note that in the context of JEMEtSums, et is total energy, not transverse energy For transvers...
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
xAOD::CMXEtSums_v1::eyErrorVec
const std::vector< uint32_t > & eyErrorVec() const
get eyErrorVec
DataError.h
xAOD::CMXEtSums_v1::Sources
Sources
Definition: CMXEtSums_v1.h:30
TrigConf::name
Definition: HLTChainList.h:35
LVL1::L1EnergyCMXTools::formCMXEtSumsCrate
virtual void formCMXEtSumsCrate(const xAOD::CMXEtSumsContainer *cmxEtSumsMod, xAOD::CMXEtSumsContainer *cmxEtSumsCrate) const
form partial CMXEtSums (crate) from module CMXEtSums
Definition: L1EnergyCMXTools.cxx:217
LVL1::DataError::error
int error() const
Return the full error word.
Definition: DataError.h:78
xAOD::CMXEtSums_v1::REMOTE_RESTRICTED
@ REMOTE_RESTRICTED
Definition: CMXEtSums_v1.h:30
TrigConf::L1DataDef::TE
@ TE
Definition: L1DataDef.h:22
xAOD::CMXEtSums
CMXEtSums_v1 CMXEtSums
Define the latest version of the CMXEtSums class.
Definition: Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/CMXEtSums.h:20
TrigConf::L1DataDef::typeAsString
static std::string & typeAsString(TriggerType tt)
Definition: L1DataDef.h:53
LVL1::CMXEtSums::MISSING_ET_SIG_STANDARD
@ MISSING_ET_SIG_STANDARD
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXEtSums.h:34
LVL1::L1EnergyCMXTools::~L1EnergyCMXTools
virtual ~L1EnergyCMXTools()
default destructor
Definition: L1EnergyCMXTools.cxx:39
plotBeamSpotVxVal.bin
int bin
Definition: plotBeamSpotVxVal.py:83
LVL1::L1EnergyCMXTools::m_L1MenuKey
SG::ReadHandleKey< TrigConf::L1Menu > m_L1MenuKey
Definition: L1EnergyCMXTools.h:121
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::AuxElement::makePrivateStore
void makePrivateStore()
Create a new (empty) private store for this object.
Definition: AuxElement.cxx:192
item
Definition: ItemListSvc.h:43
LVL1::L1EnergyCMXTools::systemEnergyToEtSums
void systemEnergyToEtSums(const MultiSliceSystemEnergy &systemVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak, xAOD::CMXEtSums_v1::Sources source=xAOD::CMXEtSums::TOTAL_STANDARD) const
Convert internal SystemEnergy objects to CMXEtSums object.
Definition: L1EnergyCMXTools.cxx:738
LVL1::L1EnergyCMXTools::dumpCrateEnergies
void dumpCrateEnergies(const std::string &msg, const MultiSliceCrateEnergy &crates) const
Definition: L1EnergyCMXTools.cxx:942
xAOD::CMXEtSums_v1::addEx
void addEx(const std::vector< uint16_t > &exVec, const std::vector< uint32_t > &exErrorVec)
add Ex
Definition: CMXEtSums_v1.cxx:96
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
L1DataDef.h
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
LVL1::L1EnergyCMXTools::formCMXEtSums
virtual void formCMXEtSums(const xAOD::JEMEtSumsContainer *jemEtSumsVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec) const
form complete CMXEtSums from JEMEtSums
Definition: L1EnergyCMXTools.cxx:115
TrigConf::ValueWithEtaDependence::addRangeValue
void addRangeValue(const T &value, int etaMin, int etaMax, unsigned int priority, bool symmetric=true)
DEBUG
#define DEBUG
Definition: page_access.h:11
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
LVL1::L1EnergyCMXTools::finalize
virtual StatusCode finalize()
standard Athena-Algorithm method
Definition: L1EnergyCMXTools.cxx:60
LVL1::CMXEtSums::MISSING_ET_RESTRICTED
@ MISSING_ET_RESTRICTED
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXEtSums.h:33
copySelective.source
string source
Definition: copySelective.py:32
LVL1::SystemEnergy
SystemEnergy class declaration Simulates behaviour of the Crate-CMM System CMM logic is done in Energ...
Definition: SystemEnergy.h:35
xAOD::CMXEtSums_v1::LOCAL_STANDARD
@ LOCAL_STANDARD
Definition: CMXEtSums_v1.h:31
xAOD::CMXEtSums_v1::etErrorVec
const std::vector< uint32_t > & etErrorVec() const
get etErrorVec
xAOD::JEMEtSums_v2::module
uint8_t module() const
get module
xAOD::CMXEtSums_v1::sourceComponent
uint8_t sourceComponent() const
get source
AthAlgTool
Definition: AthAlgTool.h:26
LVL1::DataError::get
int get(ErrorBit bit) const
Return an error bit or data.
Definition: DataError.cxx:48
LVL1::L1EnergyCMXTools::etMapsToEtSums
void etMapsToEtSums(const MultiSliceSystemEnergy &systemVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
Convert maps from internal SystemEnergy objects to CMXEtSums objects.
Definition: L1EnergyCMXTools.cxx:806
SystemEnergy.h
get_generator_info.error
error
Definition: get_generator_info.py:40
LVL1::L1EnergyCMXTools::MultiSliceSystemEnergy
std::vector< SystemEnergy * > MultiSliceSystemEnergy
Definition: L1EnergyCMXTools.h:90
error
Definition: IImpactPoint3dEstimator.h:70
xAOD::CMXEtSums_v1::initialize
virtual void initialize(const uint8_t crate, const uint8_t source)
initialize
Definition: CMXEtSums_v1.cxx:59
LVL1::L1EnergyCMXTools::initialize
virtual StatusCode initialize()
standard Athena-Algorithm method
Definition: L1EnergyCMXTools.cxx:45
python.compressB64.c
def c
Definition: compressB64.py:93
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
LVL1::CMXEtSums::MISSING_ET_STANDARD
@ MISSING_ET_STANDARD
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXEtSums.h:33
xAOD::JEMEtSums_v2::setEyVec
void setEyVec(const std::vector< uint16_t > &)
set eyVec - ey for all time slices
keylayer_zslicemap.slices
slices
Definition: keylayer_zslicemap.py:112
LVL1::L1EnergyCMXTools::moduleEnergyToEtSums
void moduleEnergyToEtSums(const MultiSliceModuleEnergy &modulesVec, xAOD::JEMEtSumsContainer *jemEtSumsVec, int peak) const
Convert internal ModuleEnergy containers to JEMEtSums container.
Definition: L1EnergyCMXTools.cxx:475
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
LVL1::L1EnergyCMXTools::etSumsToModuleEnergy
void etSumsToModuleEnergy(const xAOD::CMXEtSumsContainer *etSums, MultiSliceModuleEnergy &modulesVec, int &peak) const
Convert CMXEtSums container to internal ModuleEnergy containers.
Definition: L1EnergyCMXTools.cxx:322
xAOD::CMXEtSums_v1::exErrorVec
const std::vector< uint32_t > & exErrorVec() const
get exErrorVec
xAOD::CMXEtSums_v1::eyVec
const std::vector< uint16_t > & eyVec() const
get eyVec
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Mon Apr 21 2025 21:13:28 for ATLAS Offline Software by   doxygen 1.8.18