Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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  if(m_algoVersion==0) {
166  // 3x3 Towers Had ; 1x3 L0 + 1x3 L3 EM
167  for (int i=0; i<3; ++i) { // phi
168  for (int j=0; j<=2; ++j) { // eta
169  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))) {
170  continue;
171  } else {
172  const eTower * tTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[i][j]);
173  hadsum += tTower->getLayerTotalET(4);
174  if (j==1) {
175  emsum += ( tTower->getLayerTotalET(0) + tTower->getLayerTotalET(3) );
176  }
177  }
178  }
179  }
180 
181  // 3x3 SCs L1 and L2 sum
182  for (int i=iCoreStart; i<=iCoreEnd; ++i) { // eta
183  for(int j=0; j<=2; ++j) { // phi
184  unsigned int tmp_et_a, tmp_et_b;
185  getWindowET(1,j,i,tmp_et_a);
186  getWindowET(2,j,i,tmp_et_b);
187  emsum += ( tmp_et_a + tmp_et_b );
188  }
189  }
190  } else {
191 
192  // see slide 4 of https://indico.cern.ch/event/1513502/contributions/6389265/attachments/3019474/5326755/Rate%20Reduction%20Methods%20Overview.pdf
193  // Update 29-Apr-2025: removing 4 corners of EM3 from sum
194 
195  // EM cluster depends on UnD flag
196  int phi2 = (m_seed_UnD > 0 ? 2 : 0);
197 
198  // 3x3 Towers Had + EM3 (excluding corners in EM3); 1x2 L0
199  for (int i = 0; i < 3; ++i) { // phi
200  for (int j = 0; j <= 2; ++j) { // eta
201  if (((m_efexid % 3 == 0) && (m_fpgaid == 0) && (m_central_eta == 0) && (j == 0)) ||
202  ((m_efexid % 3 == 2) && (m_fpgaid == 3) && (m_central_eta == 5) && (j == 2))) {
203  continue;
204  } else {
205  const eTower *tTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[i][j]);
206  hadsum += tTower->getLayerTotalET(4) + (((i==0&&j==0)||(i==2&&j==2)||(i==0&&j==2)||(i==2&&j==0)) ? 0 : tTower->getLayerTotalET(3));
207  // For PS add central tower + UnD phi neighbour
208  if (j == 1 && (i == 1 || i == phi2)) {
209  emsum += (tTower->getLayerTotalET(0));
210  }
211  }
212  }
213  }
214 
215  // 3x2 SCs L1 and L2 sum, so phi range depends on UnD flag
216  int phiStart = 0;
217  int phiEnd = 1;
218  if (m_seed_UnD > 0) {
219  phiStart = 1;
220  phiEnd = 2;
221  }
222  for (int i = iCoreStart; i <= iCoreEnd; ++i) { // eta
223  for (int j = phiStart; j <= phiEnd; ++j) { // phi
224  unsigned int tmp_et_a, tmp_et_b;
225  getWindowET(1, j, i, tmp_et_a);
226  getWindowET(2, j, i, tmp_et_b);
227  emsum += (tmp_et_a + tmp_et_b);
228  }
229  }
230  }
231  // Overflow handling
232  if (emsum > 0xffff) emsum = 0xffff;
233  if (hadsum > 0xffff) hadsum = 0xffff;
234 
235  // Return results
236  rhadvec.push_back(emsum);
237  rhadvec.push_back(hadsum);
238 
239  }
240 
241  void LVL1::eFEXegAlgo::getWstot(std::vector<unsigned int> & output){
242  unsigned int numer = 0;
243  unsigned int den = 0;
244 
245  output.clear(); // clear the output vector before starting
246 
247  int iStart = m_seedID - 2;
248  int iEnd = m_seedID + 2;
249 
250  for (int i = iStart; i <= iEnd; ++i) { // eta
251  int diff = i - m_seedID;
252  unsigned int weight = diff*diff;
253  for (int j = 0; j <= 2; ++j) { // phi
254  unsigned int eT;
255  getWindowET(1, j, i, eT);
256  // NB need to be careful as numer and den are defined such that wstot=numer/den,
257  // but in the firmware (and therefore this bitwise code) we actually
258  // check that den/numer < Threshold
259  numer += eT*weight;
260  den += eT;
261  }
262  }
263 
264  // Overflow handling
265  //if (den > 0xffff) den = 0xffff; - commented out so that denom can overflow, will then automatically pass all thresholds (see eFEXFPGA::SetIsoWP)
266  if (numer > 0xffff) numer = 0xffff;
267 
268  // Return results
269  output.push_back(den);
270  output.push_back(numer);
271 
272  }
273 
276  void LVL1::eFEXegAlgo::getClusterCells(std::vector<unsigned int> &cellETs) {
277 
278  int phiUpDownID = 0;
279  if (m_seed_UnD) phiUpDownID = 2;
280 
281  // Initialise results vector
282  cellETs.resize(16,0);
283  // Fill vector with 2 PS cells, 6 L1, 6 L2, 2 L3
284  // Presampler
285  getWindowET(0, 1, 0, cellETs[0]);
286  getWindowET(0, phiUpDownID, 0, cellETs[1]);
287  // central phi Layer 1
288  getWindowET(1, 1, m_seedID, cellETs[2]);
289  getWindowET(1, 1, m_seedID - 1, cellETs[3]);
290  getWindowET(1, 1, m_seedID + 1, cellETs[4]);
291  // top/bottom phi Layer 1
292  getWindowET(1, phiUpDownID, m_seedID, cellETs[5]);
293  getWindowET(1, phiUpDownID, m_seedID - 1, cellETs[6]);
294  getWindowET(1, phiUpDownID, m_seedID + 1, cellETs[7]);
295  // central phi Layer 2
296  getWindowET(2, 1, m_seedID, cellETs[8]);
297  getWindowET(2, 1, m_seedID - 1, cellETs[9]);
298  getWindowET(2, 1, m_seedID + 1, cellETs[10]);
299  // top/bottom phi Layer 2
300  getWindowET(2, phiUpDownID, m_seedID, cellETs[11]);
301  getWindowET(2, phiUpDownID, m_seedID - 1, cellETs[12]);
302  getWindowET(2, phiUpDownID, m_seedID + 1, cellETs[13]);
303  // Layer 3
304  getWindowET(3, 1, 0, cellETs[14]);
305  getWindowET(3, phiUpDownID, 0, cellETs[15]);
306 
307  return;
308 
309  }
310 
311  unsigned int LVL1::eFEXegAlgo::getET() {
312 
314  std::vector<unsigned int> clusterCells;
315  getClusterCells(clusterCells);
316 
317 
319  unsigned int PS_ET = 0;
320 
321  if(m_algoVersion==0) {
322  PS_ET = dmCorrection(clusterCells[0], 0)
323  + dmCorrection(clusterCells[1], 0);
324  } else {
325  // 2025 algoVersion only uses 1 PS scell, except at most extreme eta values
326  PS_ET = dmCorrection(clusterCells[0], 0);
327  if ( ((m_efexid%3) == 0 && m_fpgaid == 0) || ((m_efexid%3) == 2 && m_fpgaid == 3)) {
328  PS_ET += dmCorrection(clusterCells[1], 0);
329  }
330  }
331  unsigned int L1_ET = dmCorrection(clusterCells[2], 1)
332  + dmCorrection(clusterCells[3], 1)
333  + dmCorrection(clusterCells[4], 1)
334  + dmCorrection(clusterCells[5], 1)
335  + dmCorrection(clusterCells[6], 1)
336  + dmCorrection(clusterCells[7], 1);
337  unsigned int L2_ET = dmCorrection(clusterCells[8], 2)
338  + dmCorrection(clusterCells[9], 2)
339  + dmCorrection(clusterCells[10], 2)
340  + dmCorrection(clusterCells[11], 2)
341  + dmCorrection(clusterCells[12], 2)
342  + dmCorrection(clusterCells[13], 2);
343  unsigned int L3_ET = clusterCells[14] + clusterCells[15];
344 
346  unsigned int totET = PS_ET + L1_ET + L2_ET + L3_ET;
347 
348  // overflow handling
349  if (totET > 0xffff) totET = 0xffff;
350 
351  return totET;
352 
353  }
354 
355  unsigned int LVL1::eFEXegAlgo::dmCorrection (unsigned int ET, unsigned int layer) {
357  if ( !m_dmCorr || layer > 2 ) return ET;
358 
361  int efexEta = m_efexid%3;
362  int ieta = 0;
363  if (efexEta == 2) { // Rightmost eFEX
364  // m_central_eta has range 1-4 or 1-5
365  ieta = 8 + m_fpgaid*4 + m_central_eta - 1;
366  }
367  else if (efexEta == 1 && m_fpgaid > 1) { // central eFEX, eta > 0
368  // m_central_eta has range 1-4
369  ieta = (m_fpgaid-2)*4 + m_central_eta - 1;
370  }
371  else if (efexEta == 1) { // central eFEX, eta < 0
372  // m_central_eta had range 1-4
373  ieta = (1-m_fpgaid)*4 + (4-m_central_eta);
374  }
375  else { // Leftmost eFEX
376  // m_central_eta has range 0-4 or 1-4
377  ieta = 8 + 4*(3-m_fpgaid) + (4-m_central_eta);
378  }
379 
380  if (!s_dmCorrectionsLoaded) {
381  std::lock_guard<std::mutex> lk(m_dmCorrectionsMutex); // ensure only one thread tries to load corrections
382  if (!m_dmCorrectionsKey.empty()) {
383  // replace s_corrections values with values from database ... only try this once
384  SG::ReadCondHandle <CondAttrListCollection> dmCorrections{m_dmCorrectionsKey/*, ctx*/ };
385  if (dmCorrections.isValid()) {
386  if(dmCorrections->size()==0 && Gaudi::Hive::currentContext().eventID().time_stamp()>1672527600) { // not an error for data before 2023 (will include MC21 and MC23a)
387  ATH_MSG_ERROR("No dead material corrections found in conditions database for this event in folder " << m_dmCorrectionsKey.key());
388  throw std::runtime_error("No dead material corrections found in database for this event");
389  }
390  for (auto itr = dmCorrections->begin(); itr != dmCorrections->end(); ++itr) {
391  if (itr->first < 25 || itr->first >= 50) continue;
392  s_corrections[0][itr->first - 25] = itr->second["EmPS"].data<int>();
393  s_corrections[1][itr->first - 25] = itr->second["EmFR"].data<int>();
394  s_corrections[2][itr->first - 25] = itr->second["EmMD"].data<int>();
395  ATH_MSG_DEBUG("DM Correction for etaIdx=" << (itr->first - 25) << " : [" << s_corrections[0][itr->first - 25] << ","
396  << s_corrections[1][itr->first - 25] << "," << s_corrections[2][itr->first - 25] << "]" );
397  }
398  }
399  ATH_MSG_INFO("Loaded DM Corrections from database");
400  }
401  s_dmCorrectionsLoaded = true;
402  }
403 
405  unsigned int factor = s_corrections[layer][ieta];
406 
412  unsigned int correction = ET;
413  for (int bit = 6; bit >= 0; bit--) {
414  correction /= 2;
415  if (factor & (1<<bit))
416  ET += correction;
417  }
419  return ET;
420  }
421 
422 
423  std::unique_ptr<eFEXegTOB> LVL1::eFEXegAlgo::geteFEXegTOB() {
424 
425  std::unique_ptr<eFEXegTOB> out = std::make_unique<eFEXegTOB>();
426  out->setET(getET());
427 
428  std::vector<unsigned int> temvector;
429  getWstot(temvector);
430  // For wstot, num and den seem switched around, but this is because the 'numerator' and 'denominator'
431  // mean different things at different points in the processing chain
432  // When the threshold comparison is done in the SetIsoWP function, we actually check Den/Num
433  out->setWstotNum(temvector[1]);
434  out->setWstotDen(temvector[0]);
435  getRhad(temvector);
436  out->setRhadEM(temvector[0]);
437  out->setRhadHad(temvector[1]);
438  getReta(temvector);
439  out->setRetaCore(temvector[0]);
440  out->setRetaEnv(temvector[1]);
441  out->setSeedUnD(m_seed_UnD);
442  out->setSeed(m_seedID);
443  return out;
444  }
445 
446  void LVL1::eFEXegAlgo::getWindowET(int layer, int jPhi, int SCID, unsigned int & outET) {
447 
448  SG::ReadHandle<eTowerContainer> eTowerContainer(m_eTowerContainerKey/*,ctx*/);
449 
450  if (SCID<0) { // left towers in eta
451  if ((m_efexid%3 == 0) && (m_fpgaid == 0) && (m_central_eta == 0)) {
452  outET = 0;
453  } else {
454  int etaID = 4+SCID;
455  const eTower * tmpTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[jPhi][0]);
456  if (layer==1 || layer==2) {
457  outET = tmpTower->getET(layer,etaID);
458  } else if (layer==0 || layer==3 || layer==4) {
459  outET = tmpTower->getLayerTotalET(layer);
460  }
461  }
462  } else if (SCID>=0 && SCID<4) { // central towers in eta
463  const eTower * tmpTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[jPhi][1]);
464  if (layer==1 || layer==2) {
465  outET = tmpTower->getET(layer,SCID);
466  } else if (layer==0 || layer==3 || layer==4) {
467  outET = tmpTower->getLayerTotalET(layer);
468  }
469  } else if (SCID>=4){ // right towers in eta
470  if ((m_efexid%3 == 2) && (m_fpgaid == 3) && (m_central_eta == 5)) {
471  outET = 0;
472  } else {
473  int etaID = SCID-4;
474  const eTower * tmpTower = eTowerContainer->findTower(m_eFEXegAlgoTowerID[jPhi][2]);
475  if (layer==1 || layer==2) {
476  outET = tmpTower->getET(layer,etaID);
477  } else if (layer==0 || layer==3 || layer==4) {
478  outET = tmpTower->getLayerTotalET(layer);
479  }
480  }
481  }
482 
483  // overflow handling
484  if (outET > 0xffff) outET = 0xffff;
485 
486  }
487 
488 
489 // Utility function to calculate and return jet discriminant sums for specified location
490 // Intended to allow xAOD TOBs to be decorated with this information
491  void eFEXegAlgo::getSums(unsigned int seed, bool UnD,
492  std::vector<unsigned int> & RetaSums,
493  std::vector<unsigned int> & RhadSums,
494  std::vector<unsigned int> & WstotSums)
495  {
496  // Set seed parameters to supplied values
497  m_seed_UnD = UnD;
498  m_seedID = seed;
499  m_hasSeed = true;
500 
501  // Now just call the 3 discriminant calculation methods
502  getReta(RetaSums);
503  getRhad(RhadSums);
504  getWstot(WstotSums);
505 
506  }
507 
508 
509 // Find seed and UnD flag
510  void eFEXegAlgo::setSeed() {
511 
512  m_hasSeed = false;
513  m_seed_UnD = false;
514  unsigned int tmpID = 999;
515  unsigned int maxET = 0;
516 
517  for (int i=0; i<4 ; ++i) {
518  int iSeedL = i-1;
519  int iSeedR = i+1;
520 
521  // eta ID of candidate seed
522  unsigned int cETUp;
523  getWindowET(2,2,i,cETUp);
524  unsigned int iSeedET;
525  getWindowET(2,1,i, iSeedET);
526  unsigned int cETDown;
527  getWindowET(2,0,i, cETDown);
528 
529  // left of candidate seed
530  unsigned int lETUp;
531  getWindowET(2,2,iSeedL,lETUp);
532  unsigned int lET;
533  getWindowET(2,1,iSeedL,lET);
534  unsigned int lETDown;
535  getWindowET(2,0,iSeedL,lETDown);
536 
537  // right of candidate seed
538  unsigned int rETUp;
539  getWindowET(2,2,iSeedR,rETUp);
540  unsigned int rET;
541  getWindowET(2,1,iSeedR,rET);
542  unsigned int rETDown;
543  getWindowET(2,0,iSeedR,rETDown);
544 
545  // greater or equal than for left and down cells, greater than for right and up ones
546  if (iSeedET>=lET && iSeedET>rET
547  && iSeedET>=lETUp && iSeedET>cETUp && iSeedET>rETUp
548  && iSeedET>=lETDown && iSeedET>=cETDown && iSeedET>rETDown) {
549  if (iSeedET>=maxET) { // if two maxima exist and have the same ET, keep the one to the right
550  maxET = iSeedET;
551  tmpID = i;
552  }
553  }
554  }
555 
556  if(tmpID!=999) {
557  m_seedID = tmpID;
558  m_hasSeed = true;
559  unsigned int tmp_et_up, tmp_et_down;
560  getWindowET(2,2,m_seedID,tmp_et_up);
561  getWindowET(2,0,m_seedID,tmp_et_down);
562  if (tmp_et_up >= tmp_et_down) {
563  m_seed_UnD = true; // go up if energy greater or equal to bottom
564  }
565  }
566  }
567 
568 } // 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:355
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:79
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
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:423
LVL1::eFEXegAlgo::m_algoVersion
Gaudi::Property< int > m_algoVersion
Definition: eFEXegAlgo.h:76
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
LVL1::eFEXegAlgo::getET
virtual unsigned int getET() override
Definition: eFEXegAlgo.cxx:311
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:510
LVL1::eFEXegAlgo::getClusterCells
virtual void getClusterCells(std::vector< unsigned int > &cellETs) override
Return cell ET values used in cluster.
Definition: eFEXegAlgo.cxx:276
LVL1::eFEXegAlgo::getWindowET
virtual void getWindowET(int layer, int jPhi, int SCID, unsigned int &) override
Definition: eFEXegAlgo.cxx:446
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:491
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:241
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
LVL1::eFEXegAlgo::m_dmCorrectionsKey
SG::ReadCondHandleKey< CondAttrListCollection > m_dmCorrectionsKey
Definition: eFEXegAlgo.h:82
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:84
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 Mon May 5 2025 21:09:06 for ATLAS Offline Software by   doxygen 1.8.18