ATLAS Offline Software
L1EnergyCMXTools.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2021 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  const float moduleEta[8] = {-4.,-2.,-1.2,-0.4,0.4,1.2,2.,4.};
178  maskXE = 0;
179  maskTE = 0;
180  bool maskXESet = false;
181  bool maskTESet = false;
182 
183  auto l1Menu = SG::makeHandle( m_L1MenuKey );
184  TrigConf::L1DataDef def;
185  std::vector<std::shared_ptr<TrigConf::L1Threshold>> allThresholds = l1Menu->thresholds();
186  for ( const auto& thresh : allThresholds ) {
187  if ( ( thresh->type() == def.xeType() || thresh->type() == def.teType()) && thresh->mapping() > 7 ) {
188  std::shared_ptr<TrigConf::L1Threshold_Calo> thresh_Calo = std::static_pointer_cast<TrigConf::L1Threshold_Calo>(thresh);
189  auto tvcs = thresh_Calo->thrValuesCounts();
190  // Make sure only set masks from the first valid threshold in the range (for each type)
191  if (maskXE > 0) maskXESet = true;
192  if (maskTE > 0) maskTESet = true;
193  if (tvcs.size() == 0) {
194  tvcs.addRangeValue(thresh_Calo->thrValueCounts(),-49, 49, 1, true);
195  }
196  for (const auto& tVC : tvcs) {
197  // Bits are set false by default, so ignore thresholds that are just doing that
198  if (tVC.value() >= 0x7fff) continue;
199  // Set bits true if module centre between etaMin and etaMax
200  if ( thresh->type() == def.xeType() && !maskXESet ) {
201  for (unsigned int bin = 0; bin < 8; ++bin) {
202  if (moduleEta[bin] > tVC.etaMin()*0.1 && moduleEta[bin] < tVC.etaMax()*0.1)
203  maskXE |= (1<<bin);
204  }
205  }
206  else if ( thresh->type() == def.teType() && !maskTESet ) {
207  for (unsigned int bin = 0; bin < 8; ++bin) {
208  if (moduleEta[bin] > tVC.etaMin()*0.1 && moduleEta[bin] < tVC.etaMax()*0.1)
209  maskTE |= (1<<bin);
210  }
211  }
212  } // loop over TTV
213  } // Is this XE or TE threshold?
214  }
215 }
216 void L1EnergyCMXTools::formCMXEtSumsCrate(
217  const xAOD::CMXEtSumsContainer *cmxEtSumsMod,
218  xAOD::CMXEtSumsContainer *cmxEtSumsCrate) const
219 {
220  uint32_t maskXE, maskTE;
221  findRestrictedEta(maskXE, maskTE);
222  ATH_MSG_DEBUG("Restricted eta masks: XE=" << MSG::hex << maskXE << ", TE=" << maskTE << MSG::dec);
223  // Convert to internal containers
224  int peak = 0;
225  MultiSliceModuleEnergy modulesVec;
226  MultiSliceCrateEnergy cratesVecFull;
227  MultiSliceCrateEnergy cratesVecRestricted;
228  etSumsToModuleEnergy(cmxEtSumsMod, modulesVec, peak);
229  // Process each slice
230  for (auto iter : modulesVec)
231  {
232  DataVector<ModuleEnergy> *modules = iter;
233  DataVector<CrateEnergy> *cratesFull = new DataVector<CrateEnergy>;
234  DataVector<CrateEnergy> *cratesRestricted = new DataVector<CrateEnergy>;
235  cratesVecFull.push_back(cratesFull);
236  cratesVecRestricted.push_back(cratesRestricted);
237  m_etTool->crateSums(modules, cratesFull);
238  m_etTool->crateSums(modules, cratesRestricted, maskXE, maskTE, true);
239  delete modules;
240  }
241 
242  // Convert back to CMXEtSums
243  crateEnergyToEtSums(cratesVecFull, cratesVecRestricted, cmxEtSumsCrate, peak);
244  // crateEnergyToEtSums(cratesVecRestricted, cmxEtSumsCrate, peak);
245 
246  for (auto crate : cratesVecFull)
247  {
248  delete crate;
249  }
250  for (auto crate : cratesVecRestricted)
251  {
252  delete crate;
253  }
254 }
255 
258 void L1EnergyCMXTools::formCMXEtSumsSystem(
259  const xAOD::CMXEtSumsContainer *cmxEtSumsCrate,
260  xAOD::CMXEtSumsContainer *cmxEtSumsSys) const
261 {
262  // Convert to internal containers
263  int peak = 0;
264  MultiSliceCrateEnergy cratesVecFull;
265  MultiSliceCrateEnergy cratesVecRestricted;
266 
267  MultiSliceSystemEnergy systemVecFull;
268  MultiSliceSystemEnergy systemVecRestricted;
269  auto l1Menu = SG::makeHandle( m_L1MenuKey );
270  etSumsToCrateEnergy(cmxEtSumsCrate, cratesVecFull, cratesVecRestricted, peak);
271  for (int i = 0; i < 2; i++)
272  {
273  MultiSliceCrateEnergy *cratesVec = i == 0? &cratesVecFull: &cratesVecRestricted;
274  MultiSliceSystemEnergy *systemVec = i == 0? &systemVecFull: &systemVecRestricted;
275  // Process each slice
276  MultiSliceCrateEnergy::iterator iter = (*cratesVec).begin();
277  MultiSliceCrateEnergy::iterator iterE = (*cratesVec).end();
278  for (; iter != iterE; ++iter)
279  {
280  DataVector<CrateEnergy> *crates = *iter;
281  //systemVec.push_back(new SystemEnergy(m_etTool->systemSums(crates)));
282  systemVec->push_back(new SystemEnergy(crates, &(*l1Menu)));
283  delete crates;
284  }
285  }
286  // Convert back to CMXEtSums
287  systemEnergyToEtSums(systemVecFull, cmxEtSumsSys, peak, xAOD::CMXEtSums::TOTAL_STANDARD);
288  systemEnergyToEtSums(systemVecRestricted, cmxEtSumsSys, peak, xAOD::CMXEtSums::TOTAL_RESTRICTED);
289 
290  for (int i = 0; i < 2; i++)
291  {
292  MultiSliceSystemEnergy *systemVec = i == 0? &systemVecFull: &systemVecRestricted;
293  MultiSliceSystemEnergy::iterator siter = (*systemVec).begin();
294  MultiSliceSystemEnergy::iterator siterE = (*systemVec).end();
295  for (; siter != siterE; ++siter)
296  delete *siter;
297  }
298 }
299 
303 void L1EnergyCMXTools::formCMXEtSumsEtMaps(
304  const xAOD::CMXEtSumsContainer *cmxEtSumsSys,
305  xAOD::CMXEtSumsContainer *cmxEtSumsMap) const
306 {
307  // Convert to internal objects
308  int peak = 0;
309  MultiSliceSystemEnergy systemVec;
310  etSumsToSystemEnergy(cmxEtSumsSys, systemVec, peak);
311  // Convert back to CMXEtSums
312  etMapsToEtSums(systemVec, cmxEtSumsMap, peak);
313  MultiSliceSystemEnergy::iterator iter = systemVec.begin();
314  MultiSliceSystemEnergy::iterator iterE = systemVec.end();
315  for (; iter != iterE; ++iter)
316  delete *iter;
317 }
318 
321 void L1EnergyCMXTools::etSumsToModuleEnergy(
322  const xAOD::CMXEtSumsContainer *etSums,
323  MultiSliceModuleEnergy &modulesVec, int &peak) const
324 {
325  peak = 0;
326  unsigned int nslices = 0;
327  xAOD::CMXEtSumsContainer::const_iterator pos = etSums->begin();
328  xAOD::CMXEtSumsContainer::const_iterator pose = etSums->end();
329  for (; pos != pose; ++pos)
330  {
331  const xAOD::CMXEtSums *sums = *pos;
332  int source = sums->sourceComponent();
333  if (source > 15)
334  continue;
335  int crate = sums->crate();
336  if (sums->peak() > peak)
337  peak = sums->peak();
338  const EnergyVector &ex(sums->exVec());
339  const EnergyVector &ey(sums->eyVec());
340  const EnergyVector &et(sums->etVec());
341  unsigned int slices = et.size();
342  if (slices > nslices)
343  {
344  for (unsigned int i = nslices; i < slices; ++i)
345  {
346  modulesVec.push_back(new DataVector<ModuleEnergy>);
347  }
348  nslices = slices;
349  }
350  for (unsigned int sl = 0; sl < slices; ++sl)
351  {
352  DataVector<ModuleEnergy> *modules = modulesVec[sl];
353  modules->push_back(new ModuleEnergy(crate, source,
354  et[sl], ex[sl], ey[sl]));
355  }
356  }
357 }
358 
361 void L1EnergyCMXTools::etSumsToCrateEnergy(const xAOD::CMXEtSumsContainer *etSums,
362  MultiSliceCrateEnergy &crateVecFull,
363  MultiSliceCrateEnergy &crateVecRestricted, int &peak) const
364 {
365  peak = 0;
366  unsigned int nslicesFull = 0;
367  unsigned int nslicesRestricted = 0;
368  xAOD::CMXEtSumsContainer::const_iterator pos = etSums->begin();
369  xAOD::CMXEtSumsContainer::const_iterator pose = etSums->end();
370 
371  MultiSliceCrateEnergy *crateVec = nullptr;
372  unsigned int *nslices = nullptr;
373  bool restricted = false;
374  for (; pos != pose; ++pos)
375  {
376  const xAOD::CMXEtSums *sums = *pos;
377  int crate = sums->crate();
378  if (crate != 1)
379  continue;
380  int source = sums->sourceComponent();
381  if (source != xAOD::CMXEtSums::LOCAL_STANDARD && source != xAOD::CMXEtSums::LOCAL_RESTRICTED
382  && source != xAOD::CMXEtSums::REMOTE_STANDARD && source != xAOD::CMXEtSums::REMOTE_RESTRICTED)
383  continue;
384  if (source == xAOD::CMXEtSums::REMOTE_STANDARD || source == xAOD::CMXEtSums::REMOTE_RESTRICTED)
385  crate = 0; // SASHA: check
386  if (source == xAOD::CMXEtSums::LOCAL_RESTRICTED || source == xAOD::CMXEtSums::REMOTE_RESTRICTED){
387  crateVec = &crateVecRestricted;
388  nslices = &nslicesRestricted;
389  restricted = true;
390  }else{
391  crateVec = &crateVecFull;
392  nslices = &nslicesFull;
393  restricted = false;
394  }
395  if (sums->peak() > peak)
396  peak = sums->peak();
397  const EnergyVector &ex(sums->exVec());
398  const EnergyVector &ey(sums->eyVec());
399  const EnergyVector &et(sums->etVec());
400  const ErrorVector &exErrVec(sums->exErrorVec());
401  const ErrorVector &eyErrVec(sums->eyErrorVec());
402  const ErrorVector &etErrVec(sums->etErrorVec());
403  unsigned int slices = et.size();
404 
405  if (slices > *nslices)
406  {
407  for (unsigned int i = *nslices; i < slices; ++i)
408  {
409  crateVec->push_back(new DataVector<CrateEnergy>);
410  }
411  *nslices = slices;
412  }
413  for (unsigned int sl = 0; sl < slices; ++sl)
414  {
415  DataVector<CrateEnergy> *crates = (*crateVec)[sl];
416  DataError exErr(exErrVec[sl]);
417  DataError eyErr(eyErrVec[sl]);
418  DataError etErr(etErrVec[sl]);
419  crates->push_back(new CrateEnergy(crate, et[sl], ex[sl], ey[sl],
420  etErr.get(DataError::Overflow),
421  exErr.get(DataError::Overflow),
422  eyErr.get(DataError::Overflow), restricted));
423  }
424  }
425 
426  dumpCrateEnergies("Crates from full region (for total)", crateVecFull);
427  dumpCrateEnergies("Crates from restricted region (for total)", crateVecRestricted);
428 }
429 
432 void L1EnergyCMXTools::etSumsToSystemEnergy(
433  const xAOD::CMXEtSumsContainer *etSums,
434  MultiSliceSystemEnergy &systemVec, int &peak) const
435 {
436  peak = 0;
437  xAOD::CMXEtSumsContainer::const_iterator pos = etSums->begin();
438  xAOD::CMXEtSumsContainer::const_iterator pose = etSums->end();
439  for (; pos != pose; ++pos)
440  {
441  const xAOD::CMXEtSums *sums = *pos;
442  int source = sums->sourceComponent();
443  if (source != xAOD::CMXEtSums::TOTAL_STANDARD && source != xAOD::CMXEtSums::TOTAL_RESTRICTED)
444  continue;
445  if (sums->peak() > peak)
446  peak = sums->peak();
447  const EnergyVector &ex(sums->exVec());
448  const EnergyVector &ey(sums->eyVec());
449  const EnergyVector &et(sums->etVec());
450  const ErrorVector &exErrVec(sums->exErrorVec());
451  const ErrorVector &eyErrVec(sums->eyErrorVec());
452  const ErrorVector &etErrVec(sums->etErrorVec());
453  unsigned int slices = et.size();
454  auto l1Menu = SG::makeHandle( m_L1MenuKey );
455  for (unsigned int sl = 0; sl < slices; ++sl)
456  {
457  DataError exErr(exErrVec[sl]);
458  DataError eyErr(eyErrVec[sl]);
459  DataError etErr(etErrVec[sl]);
460  auto systemEnergy = new SystemEnergy(et[sl], ex[sl], ey[sl],
461  etErr.get(DataError::Overflow),
462  exErr.get(DataError::Overflow),
463  eyErr.get(DataError::Overflow),
464  source == xAOD::CMXEtSums::TOTAL_RESTRICTED,
465  &(*l1Menu));
466  // bool srestricted = (systemEnergy->roiWord0() >> 26) & 1;
467  systemVec.push_back(systemEnergy);
468  }
469  }
470 }
471 
474 void L1EnergyCMXTools::moduleEnergyToEtSums(
475  const MultiSliceModuleEnergy &modulesVec,
476  xAOD::JEMEtSumsContainer *jemEtSumsVec, int peak) const
477 {
478  std::map<int, xAOD::JEMEtSums *> etMap;
479  unsigned int nslices = modulesVec.size();
480  std::vector<uint16_t> dummy(nslices);
481  for (unsigned int slice = 0; slice < nslices; ++slice)
482  {
483  const DataVector<ModuleEnergy> *modules = modulesVec[slice];
484  DataVector<ModuleEnergy>::const_iterator pos = modules->begin();
485  DataVector<ModuleEnergy>::const_iterator pose = modules->end();
486  for (; pos != pose; ++pos)
487  {
488  const ModuleEnergy *energy = *pos;
489  //unsigned int ex = energy->exCompressed();
490  //unsigned int ey = energy->eyCompressed();
491  //unsigned int et = energy->etCompressed();
492  unsigned int ex = energy->ex();
493  unsigned int ey = energy->ey();
494  unsigned int et = energy->et();
495  if (ex == 0 && ey == 0 && et == 0)
496  continue;
497  int crate = energy->crate();
498  int module = energy->module();
499  xAOD::JEMEtSums *sums = 0;
500  int key = crate * 100 + module;
501  std::map<int, xAOD::JEMEtSums *>::iterator iter = etMap.find(key);
502  if (iter == etMap.end())
503  {
504  sums = new xAOD::JEMEtSums;
505  sums->makePrivateStore();
506  sums->initialize(crate, module, dummy, dummy, dummy, peak);
507  etMap.insert(std::make_pair(key, sums));
508  jemEtSumsVec->push_back(sums);
509  }
510  else
511  sums = iter->second;
512  std::vector<uint16_t> exVec(sums->exVec());
513  std::vector<uint16_t> eyVec(sums->eyVec());
514  std::vector<uint16_t> etVec(sums->etVec());
515  exVec[slice] = ex;
516  eyVec[slice] = ey;
517  etVec[slice] = et;
518  sums->setExVec(exVec);
519  sums->setEyVec(eyVec);
520  sums->setEtVec(etVec);
521  }
522  }
523 }
524 
527 void L1EnergyCMXTools::crateEnergyToEtSums(
528  const MultiSliceCrateEnergy &cratesVec,
529  xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
530 {
531  std::map<int, xAOD::CMXEtSums *> etMap;
532  unsigned int nslices = cratesVec.size();
533  std::vector<uint16_t> dummy(nslices);
534  std::vector<uint32_t> error(nslices);
535  for (unsigned int slice = 0; slice < nslices; ++slice)
536  {
537  const DataVector<CrateEnergy> *crates = cratesVec[slice];
538  DataVector<CrateEnergy>::const_iterator pos = crates->begin();
539  DataVector<CrateEnergy>::const_iterator pose = crates->end();
540  for (; pos != pose; ++pos)
541  {
542  const CrateEnergy *energy = *pos;
543  unsigned int ex = energy->exTC();
544  unsigned int ey = energy->eyTC();
545  unsigned int et = energy->et();
546  int exOverflow = energy->exOverflow();
547  int eyOverflow = energy->eyOverflow();
548  int etOverflow = energy->etOverflow();
549  if (ex == 0 && ey == 0 && et == 0 &&
550  exOverflow == 0 && eyOverflow == 0 && etOverflow == 0)
551  continue;
552  int crate = energy->crate();
553  xAOD::CMXEtSums *sums = 0;
554  int source = xAOD::CMXEtSums::LOCAL_STANDARD;
555  for (int i = 0; i < 2; ++i)
556  {
557  for (int j = 0; j < 2; ++j)
558  {
559  int key = crate * 100 + source;
560  std::map<int, xAOD::CMXEtSums *>::iterator iter = etMap.find(key);
561  if (iter == etMap.end())
562  {
563  sums = new xAOD::CMXEtSums;
564  sums->makePrivateStore();
565  sums->initialize(crate, source, dummy, dummy, dummy,
566  error, error, error, peak);
567  etMap.insert(std::make_pair(key, sums));
568  cmxEtSumsVec->push_back(sums);
569  }
570  else
571  sums = iter->second;
572  std::vector<uint16_t> exVec(sums->exVec());
573  std::vector<uint16_t> eyVec(sums->eyVec());
574  std::vector<uint16_t> etVec(sums->etVec());
575  std::vector<uint32_t> exErr(sums->exErrorVec());
576  std::vector<uint32_t> eyErr(sums->eyErrorVec());
577  std::vector<uint32_t> etErr(sums->etErrorVec());
578  exVec[slice] = ex;
579  eyVec[slice] = ey;
580  etVec[slice] = et;
581  if (exOverflow)
582  {
583  DataError dEx(exErr[slice]);
584  dEx.set(DataError::Overflow);
585  exErr[slice] = dEx.error();
586  }
587  if (eyOverflow)
588  {
589  DataError dEy(eyErr[slice]);
590  dEy.set(DataError::Overflow);
591  eyErr[slice] = dEy.error();
592  }
593  if (etOverflow)
594  {
595  DataError dEt(etErr[slice]);
596  dEt.set(DataError::Overflow);
597  etErr[slice] = dEt.error();
598  }
599  sums->addEx(exVec, exErr);
600  sums->addEy(eyVec, eyErr);
601  sums->addEt(etVec, etErr);
602  if (source == xAOD::CMXEtSums::LOCAL_STANDARD)
603  {
604  source = xAOD::CMXEtSums::LOCAL_RESTRICTED;
605  }
606  else
607  {
608  source = xAOD::CMXEtSums::REMOTE_RESTRICTED;
609  }
610  }
611  if (crate == 1)
612  break;
613  crate = 1;
614  source = xAOD::CMXEtSums::REMOTE_STANDARD;
615  }
616  }
617  }
618 }
619 
620 void L1EnergyCMXTools::crateEnergyToEtSums(
621  const MultiSliceCrateEnergy &cratesVecFull, const MultiSliceCrateEnergy &cratesVecRestricted,
622  xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
623 {
624  std::map<int, xAOD::CMXEtSums *> etMap;
625  unsigned int nslices = cratesVecFull.size();
626  std::vector<uint16_t> dummy(nslices);
627  std::vector<uint32_t> error(nslices);
628 
629  dumpCrateEnergies("Crates from full region", cratesVecFull);
630  dumpCrateEnergies("Crates from restricted region", cratesVecRestricted);
631 
632 
633  for (unsigned int slice = 0; slice < nslices; ++slice)
634  {
635  for (unsigned int i = 0; i < 2; i++)
636  {
637  const auto *crates = (i == 0 ? cratesVecFull[slice] : cratesVecRestricted[slice]);
638  int origSource = i == 0 ? xAOD::CMXEtSums::LOCAL_STANDARD : xAOD::CMXEtSums::LOCAL_RESTRICTED;
639 
640  for (auto pos : *crates)
641  {
642  int source = origSource;
643  const CrateEnergy *energy = pos;
644  unsigned int ex = energy->exTC();
645  unsigned int ey = energy->eyTC();
646  unsigned int et = energy->et();
647  int exOverflow = energy->exOverflow();
648  int eyOverflow = energy->eyOverflow();
649  int etOverflow = energy->etOverflow();
650  if (ex == 0 && ey == 0 && et == 0 &&
651  exOverflow == 0 && eyOverflow == 0 && etOverflow == 0)
652  continue;
653  int crate = energy->crate();
654  xAOD::CMXEtSums *sums = 0;
655 
656  while (true)
657  {
658  int key = crate * 100 + source;
659  std::map<int, xAOD::CMXEtSums *>::iterator iter = etMap.find(key);
660  if (iter == etMap.end())
661  {
662  sums = new xAOD::CMXEtSums;
663  sums->makePrivateStore();
664  sums->initialize(crate, source, dummy, dummy, dummy,
665  error, error, error, peak);
666  etMap.insert(std::make_pair(key, sums));
667  cmxEtSumsVec->push_back(sums);
668  }
669  else
670  sums = iter->second;
671  std::vector<uint16_t> exVec(sums->exVec());
672  std::vector<uint16_t> eyVec(sums->eyVec());
673  std::vector<uint16_t> etVec(sums->etVec());
674  std::vector<uint32_t> exErr(sums->exErrorVec());
675  std::vector<uint32_t> eyErr(sums->eyErrorVec());
676  std::vector<uint32_t> etErr(sums->etErrorVec());
677  exVec[slice] = ex;
678  eyVec[slice] = ey;
679  etVec[slice] = et;
680  if (exOverflow)
681  {
682  DataError dEx(exErr[slice]);
683  dEx.set(DataError::Overflow);
684  exErr[slice] = dEx.error();
685  }
686  if (eyOverflow)
687  {
688  DataError dEy(eyErr[slice]);
689  dEy.set(DataError::Overflow);
690  eyErr[slice] = dEy.error();
691  }
692  if (etOverflow)
693  {
694  DataError dEt(etErr[slice]);
695  dEt.set(DataError::Overflow);
696  etErr[slice] = dEt.error();
697  }
698  sums->addEx(exVec, exErr);
699  sums->addEy(eyVec, eyErr);
700  sums->addEt(etVec, etErr);
701  if (source == xAOD::CMXEtSums::LOCAL_STANDARD)
702  {
703  if (crate == 1)
704  {
705  break;
706  }
707  else
708  {
709  crate = 1;
710  source = xAOD::CMXEtSums::REMOTE_STANDARD;
711  }
712  }
713  else if (source == xAOD::CMXEtSums::LOCAL_RESTRICTED)
714  {
715  if (crate == 1)
716  {
717  break;
718  }
719  else
720  {
721  crate = 1;
722  source = xAOD::CMXEtSums::REMOTE_RESTRICTED;
723  }
724  }
725  else
726  {
727  break;
728  }
729  }
730  } // crates
731  } //for i
732  }
733 }
734 
737 void L1EnergyCMXTools::systemEnergyToEtSums(
738  const MultiSliceSystemEnergy &systemVec,
739  xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak, xAOD::CMXEtSums_v1::Sources source) const
740 {
741  xAOD::CMXEtSums *sums = nullptr;
742 
743  unsigned int nslices = systemVec.size();
744  std::vector<uint16_t> data(nslices);
745  std::vector<uint32_t> error(nslices);
746  for (unsigned int slice = 0; slice < nslices; ++slice)
747  {
748  SystemEnergy *energy = systemVec[slice];
749  unsigned int ex = energy->exTC();
750  unsigned int ey = energy->eyTC();
751  unsigned int et = energy->et();
752  int exOverflow = energy->exOverflow();
753  int eyOverflow = energy->eyOverflow();
754  int etOverflow = energy->etOverflow();
755 
756  // don't trust to exOverflow for restricted
757  if (ex == 0 && ey == 0 && et == 0 &&
758  exOverflow == 0 && eyOverflow == 0 && etOverflow == 0)
759  continue;
760  if (!sums)
761  {
762  sums = new xAOD::CMXEtSums;
763  sums->makePrivateStore();
764  sums->initialize(1, source, data, data, data,
765  error, error, error, peak);
766  cmxEtSumsVec->push_back(sums);
767  }
768  std::vector<uint16_t> exVec(sums->exVec());
769  std::vector<uint16_t> eyVec(sums->eyVec());
770  std::vector<uint16_t> etVec(sums->etVec());
771  std::vector<uint32_t> exErr(sums->exErrorVec());
772  std::vector<uint32_t> eyErr(sums->eyErrorVec());
773  std::vector<uint32_t> etErr(sums->etErrorVec());
774  exVec[slice] = ex;
775  eyVec[slice] = ey;
776  etVec[slice] = et;
777 
778  if (exOverflow)
779  {
780  DataError dEx(exErr[slice]);
781  dEx.set(DataError::Overflow);
782  exErr[slice] = dEx.error();
783  }
784 
785  if (eyOverflow)
786  {
787  DataError dEy(eyErr[slice]);
788  dEy.set(DataError::Overflow);
789  eyErr[slice] = dEy.error();
790  }
791  if (etOverflow)
792  {
793  DataError dEt(etErr[slice]);
794  dEt.set(DataError::Overflow);
795  etErr[slice] = dEt.error();
796  }
797  sums->addEx(exVec, exErr);
798  sums->addEy(eyVec, eyErr);
799  sums->addEt(etVec, etErr);
800  }
801 }
802 
805 void L1EnergyCMXTools::etMapsToEtSums(
806  const MultiSliceSystemEnergy &systemVec,
807  xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
808 {
809 
810  xAOD::CMXEtSums **sumEt = 0;
811  xAOD::CMXEtSums **missEt = 0;
812  xAOD::CMXEtSums **missEtSig = 0;
813 
814  xAOD::CMXEtSums *sumEtFull = 0;
815  xAOD::CMXEtSums *missEtFull = 0;
816  xAOD::CMXEtSums *missEtSigFull = 0;
817 
818  xAOD::CMXEtSums *sumEtRestricted = 0;
819  xAOD::CMXEtSums *missEtRestricted = 0;
820  xAOD::CMXEtSums *missEtSigRestricted = 0;
821 
822  int nslicesFull = 0;
823  int nslicesRestricted = 0;
824 
825  std::map<int, bool> isRestrictedMap;
826 
827 
828  for (unsigned int i = 0; i < systemVec.size(); ++i)
829  {
830  bool isRestricted = (systemVec[i]->roiWord0() >> 26) & 1;
831  isRestrictedMap[i] = isRestricted;
832  if (isRestricted) {
833  nslicesRestricted++;
834  }else{
835  nslicesFull++;
836  }
837  // ATH_MSG_DEBUG("isRestriced=" << isRestricted << " slice=" << (isRestricted? nslicesRestricted: nslicesFull)
838  // << " et=" << systemVec[i]->et() << " etSumHits=" << systemVec[i]->etSumHits());
839  }
840 
841  std::vector<uint16_t> dataFull(nslicesFull);
842  std::vector<uint32_t> errorFull(nslicesFull);
843 
844  std::vector<uint16_t> dataRestricted(nslicesRestricted);
845  std::vector<uint32_t> errorRestricted(nslicesRestricted);
846 
847  int iSliceFull = 0;
848  int iSliceRestricted = 0;
849  int *iSlice = 0;
850 
851  for (unsigned int i = 0; i < systemVec.size(); ++i)
852  {
853  SystemEnergy *energy = systemVec[i];
854  bool restricted = isRestrictedMap[i];
855 
856  std::vector<uint16_t>* data;
857  std::vector<uint32_t>* error;
858  if (restricted)
859  {
860  sumEt = &sumEtRestricted;
861  missEt = &missEtRestricted;
862  missEtSig = &missEtSigRestricted;
863  iSlice = &iSliceRestricted;
864  data = &dataRestricted;
865  error = &errorRestricted;
866  }
867  else
868  {
869  sumEt = &sumEtFull;
870  missEt = &missEtFull;
871  missEtSig = &missEtSigFull;
872  iSlice = &iSliceFull;
873  data = &dataFull;
874  error = &errorFull;
875  }
876 
877  unsigned int slice = *iSlice;
878 
879 
880  unsigned int etSumHits = energy->etSumHits();
881  if (etSumHits)
882  {
883  if (!*sumEt)
884  {
885  *sumEt = new xAOD::CMXEtSums;
886  (*sumEt)->makePrivateStore();
887  (*sumEt)->initialize(1, restricted
888  ? CMXEtSums::SUM_ET_RESTRICTED
889  : CMXEtSums::SUM_ET_STANDARD,
890  *data, *data, *data, *error, *error, *error, peak);
891  cmxEtSumsVec->push_back(*sumEt);
892  }
893  std::vector<uint16_t> etVec((*sumEt)->etVec());
894  etVec[slice] = etSumHits;
895 
896  (*sumEt)->addEx(etVec, *error);
897  (*sumEt)->addEy(etVec, *error);
898  (*sumEt)->addEt(etVec, *error);
899 
900  // ATH_MSG_DEBUG("slice=" << slice << " restricted=" << restricted << " etVec=" << (*sumEt)->etVec() << " etSumHits=" << etSumHits);
901  }
902  unsigned int etMissHits = energy->etMissHits();
903  if (etMissHits)
904  {
905  if (!*missEt)
906  {
907  *missEt = new xAOD::CMXEtSums;
908  (*missEt)->makePrivateStore();
909  (*missEt)->initialize(1, restricted
910  ? CMXEtSums::MISSING_ET_RESTRICTED
911  : CMXEtSums::MISSING_ET_STANDARD,
912  *data, *data, *data, *error, *error, *error, peak);
913  cmxEtSumsVec->push_back(*missEt);
914  }
915  std::vector<uint16_t> etVec((*missEt)->etVec());
916  etVec[slice] = etMissHits;
917  (*missEt)->addEx(etVec, *error);
918  (*missEt)->addEy(etVec, *error);
919  (*missEt)->addEt(etVec, *error);
920  }
921  unsigned int etMissSigHits = energy->metSigHits();
922  if (etMissSigHits)
923  {
924  if (!*missEtSig)
925  {
926  *missEtSig = new xAOD::CMXEtSums;
927  (*missEtSig)->makePrivateStore();
928  (*missEtSig)->initialize(1, CMXEtSums::MISSING_ET_SIG_STANDARD, *data, *data, *data, *error, *error, *error, peak);
929  cmxEtSumsVec->push_back(*missEtSig);
930  }
931  std::vector<uint16_t> etVec((*missEtSig)->etVec());
932  etVec[slice] = etMissSigHits;
933  (*missEtSig)->addEx(etVec, *error);
934  (*missEtSig)->addEy(etVec, *error);
935  (*missEtSig)->addEt(etVec, *error);
936  }
937  (*iSlice)++;
938  }
939 }
940 
941 void L1EnergyCMXTools::dumpCrateEnergies(
942  const std::string &msg, const MultiSliceCrateEnergy &crates) const {
943  if (!m_debug) return;
944 
945  ATH_MSG_DEBUG(msg);
946  for (const auto& p : crates) {
947  for (const LVL1::CrateEnergy* c : *p) {
948  ATH_MSG_DEBUG(" CrateEnergy: crate " << c->crate() << " results ");
949  ATH_MSG_DEBUG(" Et " << c->et() << " overflow " << c->etOverflow());
950  ATH_MSG_DEBUG(" Ex " << c->ex() << " overflow " << c->exOverflow());
951  ATH_MSG_DEBUG(" Ey " << c->ey() << " overflow "<< c->eyOverflow());
952  }
953  ATH_MSG_DEBUG("");
954  }
955 }
956 
957 } // 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:15
LVL1::DataError
Error data.
Definition: DataError.h:27
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
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:35
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:33
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:303
CMXEtSums.h
LVL1
eFexTowerBuilder creates xAOD::eFexTowerContainer from supercells (LATOME) and triggerTowers (TREX) i...
Definition: ICMMCPHitsCnvTool.h:18
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:432
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
LVL1::L1EnergyCMXTools::crateEnergyToEtSums
void crateEnergyToEtSums(const MultiSliceCrateEnergy &cratesVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec, int peak) const
Convert internal CrateEnergy containers to CMXEtSums container.
Definition: L1EnergyCMXTools.cxx:527
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:269
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:134
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
TrigConf::L1Threshold_Calo::thrValueCounts
virtual unsigned int thrValueCounts(int eta=0) const
Definition: L1ThresholdBase.cxx:278
TrigConf::L1DataDef
Definition: L1DataDef.h:27
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:193
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:92
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:33
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:258
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:361
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:581
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:216
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
xAOD::CMXEtSums
CMXEtSums_v1 CMXEtSums
Define the latest version of the CMXEtSums class.
Definition: Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/CMXEtSums.h:20
LVL1::CMXEtSums::MISSING_ET_SIG_STANDARD
@ MISSING_ET_SIG_STANDARD
Definition: Trigger/TrigT1/TrigT1CaloEvent/TrigT1CaloEvent/CMXEtSums.h:35
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:172
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:737
LVL1::L1EnergyCMXTools::dumpCrateEnergies
void dumpCrateEnergies(const std::string &msg, const MultiSliceCrateEnergy &crates) const
Definition: L1EnergyCMXTools.cxx:941
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)
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
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:34
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:805
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:34
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:474
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:321
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 Sun Jun 30 2024 21:19:41 for ATLAS Offline Software by   doxygen 1.8.18