ATLAS Offline Software
eFEXegAlgo.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 //***************************************************************************
6 // eFEXegAlgo - description
7 // -------------------
8 // begin : 24 02 2020
9 // email : antonio.jacques.costa@cern.ch ulla.blumenschein@cern.ch tong.qiu@cern.ch
10 // ***************************************************************************/
11 #include <vector>
12 
13 #include "L1CaloFEXSim/eFEXegAlgo.h"
14 #include "L1CaloFEXSim/eFEXegTOB.h"
15 #include "L1CaloFEXSim/eTowerContainer.h"
16 #include "L1CaloFEXSim/eTower.h"
17 
18 
19 namespace LVL1 {
20 
21 static thread_local int s_corrections[3][25] = {
22  {0,0,0,0,0,0,0,0x8,0,0,0xb,0x4,0x8,0x9,0x34,0x7e,0x7b,0x6b,0,0,0,0,0,0,0xc},
23  {0xe,0x12,0x12,0x12,0x12,0x13,0x18,0x17,0x42,0x40,0x38,0x3d,0x3b,0x4e,0x2d,0xc,0x10,0x4,0x27,0x19,0x19,0x16,0x12,0x10,0xc},
24  {0xb,0x8,0x8,0x8,0x8,0x8,0x7,0x9,0x8,0x8,0x8,0x7,0x8,0x8,0x21,0x2,0x2,0x4,0x6,0x8,0x8,0x8,0x9,0x10,0x12}
25 };
26 bool thread_local eFEXegAlgo::s_dmCorrectionsLoaded = false;
27 
28 
29  // default constructor for persistency
30 eFEXegAlgo::eFEXegAlgo(const std::string& type, const std::string& name, const IInterface* parent):
31  AthAlgTool(type, name, parent)
32  {
33  declareInterface<IeFEXegAlgo>(this);
34  }
35 
37 eFEXegAlgo::~eFEXegAlgo()
38 {
39 }
40 
41 StatusCode eFEXegAlgo::initialize(){
42 
43  ATH_CHECK(m_eTowerContainerKey.initialize());
44  ATH_CHECK( m_dmCorrectionsKey.initialize(SG::AllowEmpty) );
45 
46  return StatusCode::SUCCESS;
47 }
48 
49 
50 StatusCode eFEXegAlgo::safetyTest() const {
51 
52  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
53  if(!eTowerContainer.isValid()){
54  ATH_MSG_FATAL("Could not retrieve container " << m_eTowerContainerKey.key() );
55  return StatusCode::FAILURE;
56  }
57 
58  return StatusCode::SUCCESS;
59 }
60 
61 void eFEXegAlgo::setup(int inputTable[3][3], int efex_id, int fpga_id, int central_eta) {
62 
63  std::copy(&inputTable[0][0], &inputTable[0][0] + 9, &m_eFEXegAlgoTowerID[0][0]);
64 
65  m_efexid = efex_id;
66  m_fpgaid = fpga_id;
67  m_central_eta = central_eta;
68 
69  setSeed();
70 
71 }
72 
73 void LVL1::eFEXegAlgo::getCoreEMTowerET(unsigned int & et) {
74 
75  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
76 
77  const LVL1::eTower * tmpTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[1][1]);
78  et = tmpTower->getLayerTotalET(0) + tmpTower->getLayerTotalET(1) + tmpTower->getLayerTotalET(2) + tmpTower->getLayerTotalET(3);
79 }
80 
81 void LVL1::eFEXegAlgo::getCoreHADTowerET(unsigned int & et) {
82 
83  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
84 
85  const LVL1::eTower * tmpTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[1][1]);
86  et = tmpTower->getLayerTotalET(4);
87 }
88 
89 void LVL1::eFEXegAlgo::getRealPhi(float & phi) {
90 
91  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
92  phi = eTowerContainer->findTower(m_eFEXegAlgoTowerID[1][1])->phi();
93 
94 }
95 
96 void LVL1::eFEXegAlgo::getRealEta(float & eta) {
97 
98  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
99 
100  eta = eTowerContainer->findTower(m_eFEXegAlgoTowerID[1][1])->eta() * eTowerContainer->findTower(m_eFEXegAlgoTowerID[1][1])->getPosNeg();
101 
102 }
103 
104 void eFEXegAlgo::getReta(std::vector<unsigned int> & retavec) {
105 
106  unsigned int coresum = 0; // 3x2 L2 sum : core
107  unsigned int totalsum = 0; // 7x3 L2 sum : total
108  unsigned int envsum = 0; // total - core : env
109 
110  retavec.clear(); // clear the output vector before starting
111 
112  // window limits
113  int iTotalStart = m_seedID-3;
114  int iTotalEnd = m_seedID+3;
115  int iCoreStart = m_seedID-1;
116  int iCoreEnd = m_seedID+1;
117  int phiStart = -999;
118  int phiEnd = -99;
119  if (m_seed_UnD) {
120  phiStart = 1;
121  phiEnd = 2;
122  } else {
123  phiStart = 0;
124  phiEnd = 1;
125  }
126 
127  // 3x2 and 7x3 L2 sum
128  for (int i=iTotalStart; i<=iTotalEnd; ++i) { // eta
129  for(int j=0; j<=2; ++j) { // phi
130  if (i>=iCoreStart && i <= iCoreEnd && j>=phiStart && j<=phiEnd) {
131  unsigned int tmp_et; getWindowET(2,j,i,tmp_et);
132  coresum += tmp_et;
133  }
134 
135  unsigned int tmptot_et; getWindowET(2,j,i,tmptot_et);
136  totalsum += tmptot_et;
137  }
138  }
139 
140  // get environment
141  envsum = totalsum - coresum;
142 
143  // Overflow handling
144  if (coresum > 0xffff) coresum = 0xffff;
145  if (envsum > 0xffff) envsum = 0xffff;
146 
147  // Return results
148  retavec.push_back(coresum);
149  retavec.push_back(envsum);
150 
151 }
152 
153 void eFEXegAlgo::getRhad(std::vector<unsigned int> & rhadvec) {
154 
155  unsigned int hadsum = 0; // 3x3 Towers Had
156  unsigned int emsum = 0; // (1x3 + 3x3 + 3x3 + 1x3) SCs EM
157 
158  rhadvec.clear(); // clear the output vector before starting
159 
160  int iCoreStart = m_seedID-1;
161  int iCoreEnd = m_seedID+1;
162 
163  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
164 
165  // 3x3 Towers Had ; 1x3 L0 + 1x3 L3 EM
166  for (int i=0; i<3; ++i) { // phi
167  for (int j=0; j<=2; ++j) { // eta
168  if (((m_efexid%3 == 0) && (m_fpgaid == 0) && (m_central_eta == 0) && (j == 0)) || ((m_efexid%3 == 2) && (m_fpgaid == 3) && (m_central_eta == 5) && (j == 2))) {
169  continue;
170  } else {
171  const eTower * tTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[i][j]);
172  hadsum += tTower->getLayerTotalET(4);
173  if (j==1) {
174  emsum += ( tTower->getLayerTotalET(0) + tTower->getLayerTotalET(3) );
175  }
176  }
177  }
178  }
179 
180  // 3x3 SCs L1 and L2 sum
181  for (int i=iCoreStart; i<=iCoreEnd; ++i) { // eta
182  for(int j=0; j<=2; ++j) { // phi
183  unsigned int tmp_et_a, tmp_et_b;
184  getWindowET(1,j,i,tmp_et_a);
185  getWindowET(2,j,i,tmp_et_b);
186  emsum += ( tmp_et_a + tmp_et_b );
187  }
188  }
189 
190  // Overflow handling
191  if (emsum > 0xffff) emsum = 0xffff;
192  if (hadsum > 0xffff) hadsum = 0xffff;
193 
194  // Return results
195  rhadvec.push_back(emsum);
196  rhadvec.push_back(hadsum);
197 
198 }
199 
200 void LVL1::eFEXegAlgo::getWstot(std::vector<unsigned int> & output){
201  unsigned int numer = 0;
202  unsigned int den = 0;
203 
204  output.clear(); // clear the output vector before starting
205 
206  int iStart = m_seedID - 2;
207  int iEnd = m_seedID + 2;
208 
209  for (int i = iStart; i <= iEnd; ++i) { // eta
210  int diff = i - m_seedID;
211  unsigned int weight = diff*diff;
212  for (int j = 0; j <= 2; ++j) { // phi
213  unsigned int eT;
214  getWindowET(1, j, i, eT);
215  // NB need to be careful as numer and den are defined such that wstot=numer/den,
216  // but in the firmware (and therefore this bitwise code) we actually
217  // check that den/numer < Threshold
218  numer += eT*weight;
219  den += eT;
220  }
221  }
222 
223  // Overflow handling
224  //if (den > 0xffff) den = 0xffff; - commented out so that denom can overflow, will then automatically pass all thresholds (see eFEXFPGA::SetIsoWP)
225  if (numer > 0xffff) numer = 0xffff;
226 
227  // Return results
228  output.push_back(den);
229  output.push_back(numer);
230 
231 }
232 
235 void LVL1::eFEXegAlgo::getClusterCells(std::vector<unsigned int> &cellETs) {
236 
237  int phiUpDownID = 0;
238  if (m_seed_UnD) phiUpDownID = 2;
239 
240  // Initialise results vector
241  cellETs.resize(16,0);
242  // Fill vector with 2 PS cells, 6 L1, 6 L2, 2 L3
243  // Presampler
244  getWindowET(0, 1, 0, cellETs[0]);
245  getWindowET(0, phiUpDownID, 0, cellETs[1]);
246  // central phi Layer 1
247  getWindowET(1, 1, m_seedID, cellETs[2]);
248  getWindowET(1, 1, m_seedID - 1, cellETs[3]);
249  getWindowET(1, 1, m_seedID + 1, cellETs[4]);
250  // top/bottom phi Layer 1
251  getWindowET(1, phiUpDownID, m_seedID, cellETs[5]);
252  getWindowET(1, phiUpDownID, m_seedID - 1, cellETs[6]);
253  getWindowET(1, phiUpDownID, m_seedID + 1, cellETs[7]);
254  // central phi Layer 2
255  getWindowET(2, 1, m_seedID, cellETs[8]);
256  getWindowET(2, 1, m_seedID - 1, cellETs[9]);
257  getWindowET(2, 1, m_seedID + 1, cellETs[10]);
258  // top/bottom phi Layer 2
259  getWindowET(2, phiUpDownID, m_seedID, cellETs[11]);
260  getWindowET(2, phiUpDownID, m_seedID - 1, cellETs[12]);
261  getWindowET(2, phiUpDownID, m_seedID + 1, cellETs[13]);
262  // Layer 3
263  getWindowET(3, 1, 0, cellETs[14]);
264  getWindowET(3, phiUpDownID, 0, cellETs[15]);
265 
266  return;
267 
268 }
269 
270 unsigned int LVL1::eFEXegAlgo::getET() {
271 
273  std::vector<unsigned int> clusterCells;
274  getClusterCells(clusterCells);
275 
277  unsigned int PS_ET = dmCorrection(clusterCells[0], 0)
278  + dmCorrection(clusterCells[1], 0);
279  unsigned int L1_ET = dmCorrection(clusterCells[2], 1)
280  + dmCorrection(clusterCells[3], 1)
281  + dmCorrection(clusterCells[4], 1)
282  + dmCorrection(clusterCells[5], 1)
283  + dmCorrection(clusterCells[6], 1)
284  + dmCorrection(clusterCells[7], 1);
285  unsigned int L2_ET = dmCorrection(clusterCells[8], 2)
286  + dmCorrection(clusterCells[9], 2)
287  + dmCorrection(clusterCells[10], 2)
288  + dmCorrection(clusterCells[11], 2)
289  + dmCorrection(clusterCells[12], 2)
290  + dmCorrection(clusterCells[13], 2);
291  unsigned int L3_ET = clusterCells[14] + clusterCells[15];
292 
294  unsigned int totET = PS_ET + L1_ET + L2_ET + L3_ET;
295 
296  // overflow handling
297  if (totET > 0xffff) totET = 0xffff;
298 
299  return totET;
300 
301 }
302 
303 unsigned int LVL1::eFEXegAlgo::dmCorrection (unsigned int ET, unsigned int layer) {
305  if ( !m_dmCorr || layer > 2 ) return ET;
306 
309  int efexEta = m_efexid%3;
310  int ieta = 0;
311  if (efexEta == 2) { // Rightmost eFEX
312  // m_central_eta has range 1-4 or 1-5
313  ieta = 8 + m_fpgaid*4 + m_central_eta - 1;
314  }
315  else if (efexEta == 1 && m_fpgaid > 1) { // central eFEX, eta > 0
316  // m_central_eta has range 1-4
317  ieta = (m_fpgaid-2)*4 + m_central_eta - 1;
318  }
319  else if (efexEta == 1) { // central eFEX, eta < 0
320  // m_central_eta had range 1-4
321  ieta = (1-m_fpgaid)*4 + (4-m_central_eta);
322  }
323  else { // Leftmost eFEX
324  // m_central_eta has range 0-4 or 1-4
325  ieta = 8 + 4*(3-m_fpgaid) + (4-m_central_eta);
326  }
327 
328  if (!s_dmCorrectionsLoaded) {
329  std::lock_guard<std::mutex> lk(m_dmCorrectionsMutex); // ensure only one thread tries to load corrections
330  if (!m_dmCorrectionsKey.empty()) {
331  // replace s_corrections values with values from database ... only try this once
332  SG::ReadCondHandle <CondAttrListCollection> dmCorrections{m_dmCorrectionsKey/*, ctx*/ };
333  if (dmCorrections.isValid()) {
334  if(dmCorrections->size()==0 && Gaudi::Hive::currentContext().eventID().time_stamp()>1672527600) { // not an error for data before 2023 (will include MC21 and MC23a)
335  ATH_MSG_ERROR("No dead material corrections found in conditions database for this event in folder " << m_dmCorrectionsKey.key());
336  throw std::runtime_error("No dead material corrections found in database for this event");
337  }
338  for (auto itr = dmCorrections->begin(); itr != dmCorrections->end(); ++itr) {
339  if (itr->first < 25 || itr->first >= 50) continue;
340  s_corrections[0][itr->first - 25] = itr->second["EmPS"].data<int>();
341  s_corrections[1][itr->first - 25] = itr->second["EmFR"].data<int>();
342  s_corrections[2][itr->first - 25] = itr->second["EmMD"].data<int>();
343  ATH_MSG_DEBUG("DM Correction for etaIdx=" << (itr->first - 25) << " : [" << s_corrections[0][itr->first - 25] << ","
344  << s_corrections[1][itr->first - 25] << "," << s_corrections[2][itr->first - 25] << "]" );
345  }
346  }
347  ATH_MSG_INFO("Loaded DM Corrections from database");
348  }
349  s_dmCorrectionsLoaded = true;
350  }
351 
353  unsigned int factor = s_corrections[layer][ieta];
354 
360  unsigned int correction = ET;
361  for (int bit = 6; bit >= 0; bit--) {
362  correction /= 2;
363  if (factor & (1<<bit))
364  ET += correction;
365  }
367  return ET;
368 }
369 
370 
371 std::unique_ptr<eFEXegTOB> LVL1::eFEXegAlgo::geteFEXegTOB() {
372 
373  std::unique_ptr<eFEXegTOB> out = std::make_unique<eFEXegTOB>();
374  out->setET(getET());
375 
376  std::vector<unsigned int> temvector;
377  getWstot(temvector);
378  // For wstot, num and den seem switched around, but this is because the 'numerator' and 'denominator'
379  // mean different things at different points in the processing chain
380  // When the threshold comparison is done in the SetIsoWP function, we actually check Den/Num
381  out->setWstotNum(temvector[1]);
382  out->setWstotDen(temvector[0]);
383  getRhad(temvector);
384  out->setRhadEM(temvector[0]);
385  out->setRhadHad(temvector[1]);
386  getReta(temvector);
387  out->setRetaCore(temvector[0]);
388  out->setRetaEnv(temvector[1]);
389  out->setSeedUnD(m_seed_UnD);
390  out->setSeed(m_seedID);
391  return out;
392 }
393 
394 void LVL1::eFEXegAlgo::getWindowET(int layer, int jPhi, int SCID, unsigned int & outET) {
395 
396  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
397 
398  if (SCID<0) { // left towers in eta
399  if ((m_efexid%3 == 0) && (m_fpgaid == 0) && (m_central_eta == 0)) {
400  outET = 0;
401  } else {
402  int etaID = 4+SCID;
403  const eTower * tmpTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[jPhi][0]);
404  if (layer==1 || layer==2) {
405  outET = tmpTower->getET(layer,etaID);
406  } else if (layer==0 || layer==3 || layer==4) {
407  outET = tmpTower->getLayerTotalET(layer);
408  }
409  }
410  } else if (SCID>=0 && SCID<4) { // central towers in eta
411  const eTower * tmpTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[jPhi][1]);
412  if (layer==1 || layer==2) {
413  outET = tmpTower->getET(layer,SCID);
414  } else if (layer==0 || layer==3 || layer==4) {
415  outET = tmpTower->getLayerTotalET(layer);
416  }
417  } else if (SCID>=4){ // right towers in eta
418  if ((m_efexid%3 == 2) && (m_fpgaid == 3) && (m_central_eta == 5)) {
419  outET = 0;
420  } else {
421  int etaID = SCID-4;
422  const eTower * tmpTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[jPhi][2]);
423  if (layer==1 || layer==2) {
424  outET = tmpTower->getET(layer,etaID);
425  } else if (layer==0 || layer==3 || layer==4) {
426  outET = tmpTower->getLayerTotalET(layer);
427  }
428  }
429  }
430 
431  // overflow handling
432  if (outET > 0xffff) outET = 0xffff;
433 
434 }
435 
436 
437 // Utility function to calculate and return jet discriminant sums for specified location
438 // Intended to allow xAOD TOBs to be decorated with this information
439 void eFEXegAlgo::getSums(unsigned int seed, bool UnD,
440  std::vector<unsigned int> & RetaSums,
441  std::vector<unsigned int> & RhadSums,
442  std::vector<unsigned int> & WstotSums)
443 {
444  // Set seed parameters to supplied values
445  m_seed_UnD = UnD;
446  m_seedID = seed;
447  m_hasSeed = true;
448 
449  // Now just call the 3 discriminant calculation methods
450  getReta(RetaSums);
451  getRhad(RhadSums);
452  getWstot(WstotSums);
453 
454 }
455 
456 
457 // Find seed and UnD flag
458 void eFEXegAlgo::setSeed() {
459 
460  m_hasSeed = false;
461  m_seed_UnD = false;
462  unsigned int tmpID = 999;
463  unsigned int maxET = 0;
464 
465  for (int i=0; i<4 ; ++i) {
466  int iSeedL = i-1;
467  int iSeedR = i+1;
468 
469  // eta ID of candidate seed
470  unsigned int cETUp;
471  getWindowET(2,2,i,cETUp);
472  unsigned int iSeedET;
473  getWindowET(2,1,i, iSeedET);
474  unsigned int cETDown;
475  getWindowET(2,0,i, cETDown);
476 
477  // left of candidate seed
478  unsigned int lETUp;
479  getWindowET(2,2,iSeedL,lETUp);
480  unsigned int lET;
481  getWindowET(2,1,iSeedL,lET);
482  unsigned int lETDown;
483  getWindowET(2,0,iSeedL,lETDown);
484 
485  // right of candidate seed
486  unsigned int rETUp;
487  getWindowET(2,2,iSeedR,rETUp);
488  unsigned int rET;
489  getWindowET(2,1,iSeedR,rET);
490  unsigned int rETDown;
491  getWindowET(2,0,iSeedR,rETDown);
492 
493  // greater or equal than for left and down cells, greater than for right and up ones
494  if (iSeedET>=lET && iSeedET>rET
495  && iSeedET>=lETUp && iSeedET>cETUp && iSeedET>rETUp
496  && iSeedET>=lETDown && iSeedET>=cETDown && iSeedET>rETDown) {
497  if (iSeedET>=maxET) { // if two maxima exist and have the same ET, keep the one to the right
498  maxET = iSeedET;
499  tmpID = i;
500  }
501  }
502  }
503 
504  if(tmpID!=999) {
505  m_seedID = tmpID;
506  m_hasSeed = true;
507  unsigned int tmp_et_up, tmp_et_down;
508  getWindowET(2,2,m_seedID,tmp_et_up);
509  getWindowET(2,0,m_seedID,tmp_et_down);
510  if (tmp_et_up >= tmp_et_down) {
511  m_seed_UnD = true; // go up if energy greater or equal to bottom
512  }
513  }
514 }
515 
516 } // namespace LVL1
LVL1::eFEXegAlgo::m_hasSeed
bool m_hasSeed
Definition: eFEXegAlgo.h:72
LVL1::eFEXegAlgo::dmCorrection
virtual unsigned int dmCorrection(unsigned int ET, unsigned int layer) override
Definition: eFEXegAlgo.cxx:303
et
Extra patterns decribing particle interation process.
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
LVL1::eFEXegAlgo::m_efexid
int m_efexid
Definition: eFEXegAlgo.h:69
eTowerContainer.h
LVL1::eFEXegAlgo::m_seed_UnD
bool m_seed_UnD
Definition: eFEXegAlgo.h:66
LVL1::eFEXegAlgo::getRhad
virtual void getRhad(std::vector< unsigned int > &) override
Definition: eFEXegAlgo.cxx:153
LVL1::eTower
The eTower class is an interface object for eFEX trigger algorithms The purposes are twofold:
Definition: eTower.h:38
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
LVL1::eFEXegAlgo::getRealEta
virtual void getRealEta(float &eta) override
Definition: eFEXegAlgo.cxx:96
LVL1::eFEXegAlgo::setup
virtual void setup(int inputTable[3][3], int efex_id, int fpga_id, int central_eta) override
Definition: eFEXegAlgo.cxx:61
LVL1::eFEXegAlgo::m_eTowerContainerKey
SG::ReadHandleKey< LVL1::eTowerContainer > m_eTowerContainerKey
Definition: eFEXegAlgo.h:78
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
LVL1::eFEXegAlgo::getRealPhi
virtual void getRealPhi(float &phi) override
Definition: eFEXegAlgo.cxx:89
LVL1::eFEXegAlgo::m_central_eta
int m_central_eta
Definition: eFEXegAlgo.h:71
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
LVL1::eTower::getPosNeg
int getPosNeg() const
Definition: eTower.h:121
mc.diff
diff
Definition: mc.SFGenPy8_MuMu_DD.py:14
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
LVL1::eFEXegAlgo::m_seedID
unsigned int m_seedID
Definition: eFEXegAlgo.h:67
LVL1::eFEXegAlgo::getReta
virtual void getReta(std::vector< unsigned int > &) override
Definition: eFEXegAlgo.cxx:104
LVL1
eFexTowerBuilder creates xAOD::eFexTowerContainer from supercells (LATOME) and triggerTowers (TREX) i...
Definition: ICMMCPHitsCnvTool.h:18
LVL1::eFEXegAlgo::geteFEXegTOB
virtual std::unique_ptr< eFEXegTOB > geteFEXegTOB() override
Definition: eFEXegAlgo.cxx:371
LVL1::eFEXegAlgo::getET
virtual unsigned int getET() override
Definition: eFEXegAlgo.cxx:270
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:189
tools.zlumi_mc_cf.correction
def correction(mu, runmode, campaign, run=None)
Definition: zlumi_mc_cf.py:4
LVL1::eFEXegAlgo::getCoreEMTowerET
virtual void getCoreEMTowerET(unsigned int &et) override
Definition: eFEXegAlgo.cxx:73
LVL1::eFEXegAlgo::eFEXegAlgo
eFEXegAlgo(const std::string &type, const std::string &name, const IInterface *parent)
Constructors.
Definition: eFEXegAlgo.cxx:30
LVL1::eFEXegAlgo::setSeed
void setSeed()
Definition: eFEXegAlgo.cxx:458
LVL1::eFEXegAlgo::getClusterCells
virtual void getClusterCells(std::vector< unsigned int > &cellETs) override
Return cell ET values used in cluster.
Definition: eFEXegAlgo.cxx:235
LVL1::eFEXegAlgo::getWindowET
virtual void getWindowET(int layer, int jPhi, int SCID, unsigned int &) override
Definition: eFEXegAlgo.cxx:394
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
IDTPM::eT
float eT(const U &p)
Accessor utility function for getting the value of Tranverse energy.
Definition: TrackParametersHelper.h:122
LVL1::eTower::phi
float phi() const
Definition: eTower.h:65
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
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
LVL1::eFEXegAlgo::getSums
virtual void getSums(unsigned int seed, bool UnD, std::vector< unsigned int > &RetaSums, std::vector< unsigned int > &RhadSums, std::vector< unsigned int > &WstotSums) override
Definition: eFEXegAlgo.cxx:439
eFEXegAlgo.h
test_pyathena.parent
parent
Definition: test_pyathena.py:15
LVL1::eFEXegAlgo::m_eFEXegAlgoTowerID
int m_eFEXegAlgoTowerID[3][3]
Definition: eFEXegAlgo.h:68
LVL1::eFEXegAlgo::getCoreHADTowerET
virtual void getCoreHADTowerET(unsigned int &et) override
Definition: eFEXegAlgo.cxx:81
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
LVL1::eFEXegAlgo::getWstot
virtual void getWstot(std::vector< unsigned int > &) override
Definition: eFEXegAlgo.cxx:200
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::eTower::getET
int getET(unsigned int layer, int cell=0) const
Get ET of a specified cell in MeV.
Definition: eTower.cxx:172
eFEXegTOB.h
LVL1::eTowerContainer
Definition: eTowerContainer.h:35
TrigConf::name
Definition: HLTChainList.h:35
LVL1::eTower::getLayerTotalET
int getLayerTotalET(unsigned int layer) const
Get total ET sum of all cells in a given layer in MeV.
Definition: eTower.cxx:249
merge.output
output
Definition: merge.py:17
LVL1::eFEXegAlgo::m_dmCorrectionsKey
SG::ReadCondHandleKey< CondAttrListCollection > m_dmCorrectionsKey
Definition: eFEXegAlgo.h:81
LVL1::eFEXegAlgo::safetyTest
virtual StatusCode safetyTest() const override
Definition: eFEXegAlgo.cxx:50
LVL1::eFEXegAlgo::~eFEXegAlgo
virtual ~eFEXegAlgo()
Destructor.
Definition: eFEXegAlgo.cxx:37
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LVL1::eFEXegAlgo::s_dmCorrectionsLoaded
static thread_local bool s_dmCorrectionsLoaded
Definition: eFEXegAlgo.h:83
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
LVL1::eFEXegAlgo::initialize
virtual StatusCode initialize() override
standard Athena-Algorithm method
Definition: eFEXegAlgo.cxx:41
LVL1::eTower::eta
float eta() const
Definition: eTower.h:64
calibdata.copy
bool copy
Definition: calibdata.py:27
AthAlgTool
Definition: AthAlgTool.h:26
LVL1::eTowerContainer::findTower
const LVL1::eTower * findTower(int towerID) const
fast find method given identifier.
Definition: eTowerContainer.cxx:29
LVL1::eFEXegAlgo::m_fpgaid
int m_fpgaid
Definition: eFEXegAlgo.h:70
eTower.h
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
Generated on Tue Dec 24 2024 21:09:40 for ATLAS Offline Software by   doxygen 1.8.18