ATLAS Offline Software
Loading...
Searching...
No Matches
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
20namespace LVL1
21{
22
24
25L1EnergyCMXTools::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
38
42
44
45StatusCode 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
59
60StatusCode L1EnergyCMXTools::finalize()
61{
62 return StatusCode::SUCCESS;
63}
64
68
70
71void 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
114
115void 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
154
155void 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
175void 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}
217void 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
258
259void 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
303
304void 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
321
322void 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
361
362void 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
432
433void 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
474
475void 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
527
528void 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
621void 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
737
738void 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
805
806void 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
942void 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
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
data
char data[hepevt_bytes_allocation_ATLAS]
Definition HepEvt.cxx:11
et
float et(const xAOD::jFexSRJetRoI *j)
Definition L1MonitorAdaptors.h:17
AthAlgTool::AthAlgTool
AthAlgTool(const std::string &type, const std::string &name, const IInterface *parent)
Constructor with parameters:
Definition AthAlgTool.cxx:16
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition AthCommonMsg.h:30
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition AthCommonMsg.h:24
DataVector
Derived DataVector<T>.
Definition DataVector.h:795
DataVector< xAOD::JetElement_v2 >::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:838
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
LVL1::CrateEnergy
CrateEnergy class declaration Simulates behaviour of the Crate-CMM System CMM logic is done in Energy...
Definition CrateEnergy.h:29
LVL1::DataError
Error data.
Definition DataError.h:27
LVL1::DataError::error
int error() const
Return the full error word.
Definition DataError.h:78
LVL1::DataError::set
void set(ErrorBit bit, int value=1)
Set an error bit or data.
Definition DataError.cxx:28
LVL1::DataError::get
int get(ErrorBit bit) const
Return an error bit or data.
Definition DataError.cxx:48
LVL1::L1EnergyCMXTools::EnergyVector
std::vector< uint16_t > EnergyVector
Definition L1EnergyCMXTools.h:83
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
LVL1::L1EnergyCMXTools::findRestrictedEta
void findRestrictedEta(uint32_t &maskXE, uint32_t &maskTE) const
form partial CMXEtSums (crate) from module CMXEtSums
Definition L1EnergyCMXTools.cxx:175
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
LVL1::L1EnergyCMXTools::~L1EnergyCMXTools
virtual ~L1EnergyCMXTools()
default destructor
Definition L1EnergyCMXTools.cxx:39
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
LVL1::L1EnergyCMXTools::ErrorVector
std::vector< uint32_t > ErrorVector
Definition L1EnergyCMXTools.h:84
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
LVL1::L1EnergyCMXTools::m_jeTool
ToolHandle< LVL1::IL1JetElementTools > m_jeTool
Tool for JetElement map.
Definition L1EnergyCMXTools.h:120
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::m_etTool
ToolHandle< LVL1::IL1EtTools > m_etTool
Tool for energy sums.
Definition L1EnergyCMXTools.h:122
LVL1::L1EnergyCMXTools::MultiSliceSystemEnergy
std::vector< SystemEnergy * > MultiSliceSystemEnergy
Definition L1EnergyCMXTools.h:87
LVL1::L1EnergyCMXTools::dumpCrateEnergies
void dumpCrateEnergies(const std::string &msg, const MultiSliceCrateEnergy &crates) const
Definition L1EnergyCMXTools.cxx:942
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
LVL1::L1EnergyCMXTools::initialize
virtual StatusCode initialize()
standard Athena-Algorithm method
Definition L1EnergyCMXTools.cxx:45
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
LVL1::L1EnergyCMXTools::L1EnergyCMXTools
L1EnergyCMXTools(const std::string &type, const std::string &name, const IInterface *parent)
Constructor.
Definition L1EnergyCMXTools.cxx:25
LVL1::L1EnergyCMXTools::m_L1MenuKey
SG::ReadHandleKey< TrigConf::L1Menu > m_L1MenuKey
Definition L1EnergyCMXTools.h:118
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
LVL1::L1EnergyCMXTools::MultiSliceModuleEnergy
std::vector< DataVector< ModuleEnergy > * > MultiSliceModuleEnergy
Definition L1EnergyCMXTools.h:85
LVL1::L1EnergyCMXTools::finalize
virtual StatusCode finalize()
standard Athena-Algorithm method
Definition L1EnergyCMXTools.cxx:60
LVL1::L1EnergyCMXTools::formCMXEtSums
virtual void formCMXEtSums(const xAOD::JEMEtSumsContainer *jemEtSumsVec, xAOD::CMXEtSumsContainer *cmxEtSumsVec) const
form complete CMXEtSums from JEMEtSums
Definition L1EnergyCMXTools.cxx:115
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::L1EnergyCMXTools::MultiSliceCrateEnergy
std::vector< DataVector< CrateEnergy > * > MultiSliceCrateEnergy
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
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::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
LVL1::ModuleEnergy
This is an internal class, used in the Energy trigger.
Definition ModuleEnergy.h:40
LVL1::SystemEnergy
SystemEnergy class declaration Simulates behaviour of the Crate-CMM System CMM logic is done in Energ...
Definition SystemEnergy.h:30
SG::AuxElement::makePrivateStore
void makePrivateStore()
Create a new (empty) private store for this object.
Definition AuxElement.cxx:192
TrigConf::L1DataDef::typeAsString
static std::string & typeAsString(TriggerType tt)
Definition L1DataDef.h:53
TrigConf::L1Threshold_Calo
Definition L1ThresholdBase.h:188
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::crate
uint8_t crate() const
get crate
xAOD::CMXEtSums_v1::initialize
virtual void initialize(const uint8_t crate, const uint8_t source)
initialize
Definition CMXEtSums_v1.cxx:59
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
xAOD::CMXEtSums_v1::eyErrorVec
const std::vector< uint32_t > & eyErrorVec() const
get eyErrorVec
xAOD::CMXEtSums_v1::Sources
Sources
Definition CMXEtSums_v1.h:30
xAOD::CMXEtSums_v1::REMOTE_STANDARD
@ REMOTE_STANDARD
Definition CMXEtSums_v1.h:30
xAOD::CMXEtSums_v1::TOTAL_RESTRICTED
@ TOTAL_RESTRICTED
Definition CMXEtSums_v1.h:32
xAOD::CMXEtSums_v1::TOTAL_STANDARD
@ TOTAL_STANDARD
Definition CMXEtSums_v1.h:32
xAOD::CMXEtSums_v1::REMOTE_RESTRICTED
@ REMOTE_RESTRICTED
Definition CMXEtSums_v1.h:30
xAOD::CMXEtSums_v1::LOCAL_RESTRICTED
@ LOCAL_RESTRICTED
Definition CMXEtSums_v1.h:31
xAOD::CMXEtSums_v1::LOCAL_STANDARD
@ LOCAL_STANDARD
Definition CMXEtSums_v1.h:31
xAOD::CMXEtSums_v1::sourceComponent
uint8_t sourceComponent() const
get source
xAOD::CMXEtSums_v1::peak
uint8_t peak() const
get peak
xAOD::CMXEtSums_v1::exErrorVec
const std::vector< uint32_t > & exErrorVec() const
get exErrorVec
xAOD::CMXEtSums_v1::exVec
const std::vector< uint16_t > & exVec() const
get exVec
xAOD::CMXEtSums_v1::eyVec
const std::vector< uint16_t > & eyVec() const
get eyVec
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
xAOD::CMXEtSums_v1::etVec
const std::vector< uint16_t > & etVec() const
get etVec
xAOD::CMXEtSums_v1::etErrorVec
const std::vector< uint32_t > & etErrorVec() const
get etErrorVec
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
xAOD::JEMEtSums_v2::initialize
virtual void initialize(const uint8_t crate, const uint8_t module)
initialize
Definition JEMEtSums_v2.cxx:24
xAOD::JEMEtSums_v2::module
uint8_t module() const
get module
xAOD::JEMEtSums_v2::eyVec
const std::vector< uint16_t > & eyVec() const
get eyVec - ey for all time slices
xAOD::JEMEtSums_v2::setExVec
void setExVec(const std::vector< uint16_t > &)
set exVec - ex for all time slices
xAOD::JEMEtSums_v2::setEyVec
void setEyVec(const std::vector< uint16_t > &)
set eyVec - ey for all time slices
xAOD::JEMEtSums_v2::crate
uint8_t crate() const
get crate number
xAOD::JEMEtSums_v2::setEtVec
void setEtVec(const std::vector< uint16_t > &)
set etVec - et for all time slices
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...
xAOD::JEMEtSums_v2::peak
uint8_t peak() const
get peak
xAOD::JEMEtSums_v2::exVec
const std::vector< uint16_t > & exVec() const
get exVec - ex for all time slices
LVL1
eFexTowerBuilder creates xAOD::eFexTowerContainer from supercells (LATOME) and triggerTowers (TREX) i...
Definition ICMMCPHitsCnvTool.h:18
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition ReadCondHandle.h:270
xAOD::JetElementContainer
JetElementContainer_v2 JetElementContainer
Define the latest version of the JetElement container.
Definition JetElementContainer.h:15
xAOD::CMXEtSumsContainer
CMXEtSumsContainer_v1 CMXEtSumsContainer
Define the latest version of the CMXEtSums class.
Definition CMXEtSumsContainer.h:18
xAOD::JEMEtSums
JEMEtSums_v2 JEMEtSums
Define the latest version of the JEMEtSums class.
Definition Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JEMEtSums.h:16
xAOD::CMXEtSums
CMXEtSums_v1 CMXEtSums
Define the latest version of the CMXEtSums class.
Definition Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/CMXEtSums.h:20
xAOD::JetElementMap_t
std::map< int, const JetElement * > JetElementMap_t
Definition Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JetElement.h:18
xAOD::JEMEtSumsContainer
JEMEtSumsContainer_v2 JEMEtSumsContainer
Define the latest version of the JEMEtSums container.
Definition JEMEtSumsContainer.h:15
type
et
Extra patterns decribing particle interation process.
Generated on for ATLAS Offline Software by doxygen 1.14.0