ATLAS Offline Software
jTowerBuilder.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 
6 #include "CaloEvent/CaloCellContainer.h"
7 #include "CaloIdentifier/CaloIdManager.h"
8 #include "CaloIdentifier/CaloCell_SuperCell_ID.h"
9 #include "L1CaloFEXSim/FEXAlgoSpaceDefs.h"
10 
11 #include "xAODTrigL1Calo/TriggerTowerContainer.h"
12 
13 #include "L1CaloFEXSim/jTower.h"
14 #include "L1CaloFEXSim/jTowerBuilder.h"
15 
16 #include "L1CaloFEXSim/jTowerContainer.h"
17 
18 // TOWER IS A COLLECTION OF SUPER CELLS
19 // IT SHOULD HAVE A UNIQUE ID
20 // IT SHOULD BE ABLE TO RETURN LIST OF SUPER CELLS BELONGING TO IT
21 
22 // THIS IS A CLASS DESIGNED TO BUILD AN JTOWER USING THE JTOWER CLASS AND THEN PRINT THE RELEVANT INFORMATION TO THE SCREEN USING FUNCTION CALLS FROM THE JTOWER CLASS
23 
24 namespace LVL1 {
25 
26 jTowerBuilder::jTowerBuilder(const std::string& type,const std::string& name,const IInterface* parent): AthAlgTool(type,name,parent) {
27  declareInterface<IjTowerBuilder>(this);
28 }
29 
30 StatusCode jTowerBuilder::initialize()
31 {
32  ATH_CHECK( m_BDToolKey.initialize() );
33 
34  return StatusCode::SUCCESS;
35 }
36 
37 
38 
39 void jTowerBuilder::init(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const {
40 
41  execute(jTowerContainerRaw);
42 
43  jTowerContainerRaw->clearContainerMap();
44  jTowerContainerRaw->fillContainerMap();
45 
46 }
47 
48 
49 void jTowerBuilder::reset() const {
50 
51 }
52 
53 
54 void jTowerBuilder::execute(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const {
55  BuildAllTowers(jTowerContainerRaw);
56 }
57 
58  // TOWER IDs FOR CLARITY
59  // Left Barrel IETower = 100000 + X
60  // Right Barrel IETower = 200000 + X
61  // Left Transition ID Tower = 300000 + X;
62  // Right Transition ID Tower = 400000 + X;
63  // Left Endcap ID Tower = 500000 + X
64  // Right Endcap ID Tower = 600000 + X
65  // Left Hadronic Endcap ID Tower = 11100000 + X --> These are just Layer 5 of Endcap Towers. They will never be generated as standalone jTowers.
66  // Right Haronic Endcap ID Tower = 22200000 + X --> These are just Layer 5 of Endcap Towers. They will never be generated as standalone jTowers.
67 
68 void jTowerBuilder::BuildEMBjTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const {
69  // Regions 0 only. Region 1 is 'transition region'.
70  for (int ieta = 0; ieta < 14; ++ieta) { // loop over 14 eta steps (ignoring last step as it is transition region)
71  float centre_eta = (0.1*ieta) + (0.05) ;
72  for (int iphi = 0; iphi < 64; ++iphi) { // loop over 64 phi steps
73  int key_eta = ieta;
74  float centre_phi = (m_TT_Size_phi*iphi) + (m_TT_Size_phi/2);
75  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 100000, -1, -1*centre_eta, centre_phi);
76  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 200000, 1, centre_eta, centre_phi);
77  }
78  }
79 
80 }
81 
82 void jTowerBuilder::BuildTRANSjTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const {
83  int TRANS_MODIFIER = 14;
84  int tmpVal = TRANS_MODIFIER;
85 
86  for (int ieta = tmpVal; ieta < tmpVal + 1; ieta++) { // loop over eta steps
87  float centre_eta = (0.1*ieta) + (0.05);
88  for (int iphi = 0; iphi < 64; ++iphi) { // loop over 64 phi steps
89  int key_eta = ieta;
90  float centre_phi = (m_TT_Size_phi*iphi) + (m_TT_Size_phi/2);
91  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 300000, -1,-1*centre_eta, centre_phi);
92  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 400000, 1, centre_eta, centre_phi);
93  }
94  }
95 
96 }
97 
98 void jTowerBuilder::BuildEMEjTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const {
99  // Region 1
100  int EME_MODIFIER = 15;
101  int tmpVal = EME_MODIFIER;
102 
103  for (int ieta = tmpVal; ieta < tmpVal + 3; ++ieta) { // loop over eta steps
104  float centre_eta =(0.1*ieta) + (0.05) ;
105  for (int iphi = 0; iphi < 64; ++iphi) { // loop over 64 phi steps
106  int key_eta = ieta;
107  float centre_phi = (m_TT_Size_phi*iphi) + (m_TT_Size_phi/2);
108  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 500000, -1, -1*centre_eta, centre_phi);
109  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 600000, 1, centre_eta, centre_phi);
110  }
111  EME_MODIFIER++;
112  }
113 
114  // Region 2
115  tmpVal = EME_MODIFIER;
116  for (int ieta = tmpVal; ieta < tmpVal + 2; ++ieta) { // loop over eta steps
117  float centre_eta = (0.1*ieta) + (0.05);
118  for (int iphi = 0; iphi < 64; ++iphi) { // loop over 64 phi steps
119  int key_eta = ieta;
120  float centre_phi = (m_TT_Size_phi*iphi) + (m_TT_Size_phi/2);
121  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 500000, -1,-1*centre_eta, centre_phi);
122  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 600000, 1, centre_eta, centre_phi);
123  }
124  EME_MODIFIER++;
125  }
126 
127  // Region 3
128  tmpVal = EME_MODIFIER;
129  for (int ieta = tmpVal; ieta < tmpVal + 4; ++ieta) { // loop over eta steps
130  float centre_eta= (0.1*ieta) + (0.05) ;
131  for (int iphi = 0; iphi < 64; ++iphi) { // loop over 64 phi steps
132  int key_eta = ieta;
133  float centre_phi = (m_TT_Size_phi*iphi) + (m_TT_Size_phi/2);
134  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 500000, -1,-1*centre_eta, centre_phi);
135  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 600000, 1, centre_eta, centre_phi);
136  }
137  EME_MODIFIER++;
138  }
139 
140  // Region 4
141  tmpVal = EME_MODIFIER;
142  for (int ieta = tmpVal; ieta < tmpVal + 1; ++ieta) { // loop over eta steps
143  float centre_eta = (0.1*ieta) + (0.05);
144  for (int iphi = 0; iphi < 64; ++iphi) { // loop over 64 phi steps
145  int key_eta = ieta;
146  //float centre_phi =(TT_Size*iphi) + (0.5*TT_Size) ;
147  float centre_phi = (m_TT_Size_phi*iphi) + (m_TT_Size_phi/2);
148  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 500000, -1, -1*centre_eta, centre_phi);
149  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 600000, 1, centre_eta, centre_phi);
150  }
151  EME_MODIFIER++;
152  }
153 
154 
155 }
156 
157  // EMIE = Electromagnetic Inner ECAL - i.e. the forward ECAL region at high eta
158 void jTowerBuilder::BuildEMIEjTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const {
159  int EMIE_MODIFIER = 25;
160  int tmpVal = EMIE_MODIFIER;
161  int cellCountEta = 0;
162 
163  for (int ieta = tmpVal; ieta < tmpVal + 3; ++ieta) { // loop over eta steps (there are 3 here, 2.5-2.7, 2.7-2.9, 2.9-3.1)
164  cellCountEta++;
165  float centre_eta =(0.1*ieta) + (0.1*cellCountEta) ;
166  for (int iphi = 0; iphi < 32; ++iphi) { // loop over 32 phi steps
167  int key_eta = ieta;
168  float centre_phi = (2*m_TT_Size_phi*iphi) + m_TT_Size_phi;
169  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, /*7*/500000, -1, -1*centre_eta, centre_phi);
170  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, /*8*/600000, 1, centre_eta, centre_phi);
171  }
172  EMIE_MODIFIER++;
173  }
174 
175  tmpVal = EMIE_MODIFIER;
176  for (int ieta = tmpVal; ieta < tmpVal + 1; ++ieta) { // loop over eta steps (there are 1 here, 3.1-3.2)
177  float centre_eta = (0.1*ieta + 0.3) + (0.05);
178  for (int iphi = 0; iphi < 32; ++iphi) { // loop over 32 phi steps
179  int key_eta = ieta;
180  float centre_phi = (2*m_TT_Size_phi*iphi) + m_TT_Size_phi;
181  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, /*7*/500000, -1, -1*centre_eta, centre_phi);
182  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, /*8*/600000, 1, centre_eta, centre_phi);
183  }
184  EMIE_MODIFIER++;
185  }
186 
187 }
188 
189 void jTowerBuilder::BuildFCALjTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const {
190  int FCAL_MODIFIER = 29; // there's 0.1 overlap with EMIE here in eta, but in counting we pretend it's the next one along.
191  int tmpVal = FCAL_MODIFIER;
192 
193  //These jTowers split between all of the layers as well (FCAL0,1,2) but we treat them as though they are a single flat layer of 24 supercells and also pretend that they do not overlap - when they definitely do...
194  //This means that from a tower numbering perspective we start with FCAL0 and work upwards (in numbers?), but real ordering in eta is different and this has to be built into the jTower internal properties
195  //Right now we are unfortunately using hard-coded eta and phi positions to do this, but maybe these should be drawn from a database someday
196 
197  // THIS REGION DEFINES 1 jTOWER PER SUPERCELL! AS SUCH THE jTOWER AND SUPERCELL POSITIONS IN ETA-PHI SPACE WILL MATCH EXACTY
198  // (That's good right? Supposed to make life easier?)
199 
200  // 21/01/21 IN THE MC:
201  // FCAL 0 Region [NOT SPECIFIED IN MC] has 12 supercells in 3.2 < eta < 4.88, and 16 supercells in phi. Supercells are 0.14 x 0.4. posneg +-2
202  // FCAL 1 Region [NOT SPECIFIED IN MC] has 8 supercells in 3.2 < eta < 4.48, and 16 supercells in phi. Supercells are 0.16 x 0.4. posneg +-2
203  // FCAL 2 Region [NOT SPECIFIED IN MC] has 4 supercells in 3.2 < eta < 4.48, and 16 supercells in phi. Supercells are 0.32 x 0.4. posneg +-2
204 
205  //FCAL0
206  float eta_width = 1.4;
207  int cellCountEta = 0;
208  int FCAL0_INITIAL = FCAL_MODIFIER;
209  std::vector<int> TT_etapos{31,33,34,36,37,39,40,42,43,45,46,48}; // Eta position of each supercell, need to be change for the real coords. Future MR
210  for (int ieta = tmpVal; ieta < tmpVal + 12; ++ieta) { // loop over eta steps (there are 12 here in varying positions for FCAL0)
211  int key_eta = ieta - FCAL0_INITIAL;
212  float centre_eta = (TT_etapos[cellCountEta]+eta_width/2)/10.0;
213  cellCountEta++;
214 
215  for (int iphi = 0; iphi < 16; ++iphi) { // loop over 16 phi steps
216  float centre_phi = (2*m_TT_Size_phi_FCAL*iphi) + m_TT_Size_phi_FCAL;
217  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 700000, -1, -1*centre_eta, centre_phi, 0);
218  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 800000, 1, centre_eta, centre_phi, 0);
219  }
220  FCAL_MODIFIER++;
221  }
222 
223  //FCAL1
224  eta_width = 1.6;
225  cellCountEta = 0;
226  tmpVal = FCAL_MODIFIER;
227  TT_etapos = {31,33,35,37,39,41,43,44};// Eta position of each supercell, need to be change for the real coords. Future MR
228  int FCAL1_INITIAL = FCAL_MODIFIER;
229  for (int ieta = tmpVal; ieta < tmpVal + 8; ++ieta) { // loop over eta steps (there are 8 here in varying positions for FCAL1)
230  int key_eta = ieta - FCAL1_INITIAL;
231  float centre_eta = (TT_etapos[cellCountEta]+eta_width/2)/10.0;
232  cellCountEta++;
233  for (int iphi = 0; iphi < 16; ++iphi) { // loop over 16 phi steps
234  float centre_phi = (2*m_TT_Size_phi_FCAL*iphi) + m_TT_Size_phi_FCAL;
235  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 900000, -1, -1*centre_eta, centre_phi, 1);
236  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 1000000, 1, centre_eta, centre_phi, 1);
237  }
238  FCAL_MODIFIER++;
239  }
240 
241 
242  //FCAL2
243  eta_width = 3.2;
244  cellCountEta = 0;
245  tmpVal = FCAL_MODIFIER;
246  TT_etapos = {31,34,37,41};// Eta position of each supercell, need to be change for the real coords. Future MR
247  int FCAL2_INITIAL = FCAL_MODIFIER;
248  for (int ieta = tmpVal; ieta < tmpVal + 4; ++ieta) { // loop over eta steps (there are 4 here in varying positions for FCAL2)
249  int key_eta = ieta - FCAL2_INITIAL;
250  float centre_eta = (TT_etapos[cellCountEta]+eta_width/2)/10.0;
251  cellCountEta++;
252  for (int iphi = 0; iphi < 16; ++iphi) { // loop over 16 phi steps
253  float centre_phi = (2*m_TT_Size_phi_FCAL*iphi) + m_TT_Size_phi_FCAL;
254  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 1100000, -1, -1*centre_eta, centre_phi, 2);
255  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 1200000, 1, centre_eta, centre_phi, 2);
256  }
257  FCAL_MODIFIER++;
258  }
259 
260 
261 }
262 
263 
264 
265  void jTowerBuilder::BuildHECjTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const {
266  // Region 0
267  int HEC_MODIFIER = 29;
268  int tmpVal = HEC_MODIFIER;
269  for (int ieta = tmpVal; ieta < tmpVal + 10; ++ieta){ // loop over eta steps
270  for (int iphi = 0; iphi < 64; ++iphi){ // loop over 64 phi steps
271  int key_eta = ieta;
272  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 11100000, -1, ieta, iphi);
273  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 22200000, 1, ieta, iphi);
274  }
275  HEC_MODIFIER++;
276  }
277 
278  // Region 1
279  tmpVal = HEC_MODIFIER;
280  for (int ieta = tmpVal; ieta < tmpVal + 4; ++ieta){ // loop over eta steps
281  for (int iphi = 0; iphi < 32; ++iphi){ // loop over 64 phi steps
282  int key_eta = ieta;
283  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 11100000, -1, ieta, iphi);
284  BuildSingleTower(jTowerContainerRaw, ieta, iphi, key_eta, 22200000, 1, ieta, iphi);
285  }
286  HEC_MODIFIER++;
287  }
288 
289 }
290 //=================================================================================================================================================================
291 
292 void jTowerBuilder::BuildSingleTower(std::unique_ptr<jTowerContainer> & jTowerContainerRaw,float eta, float phi, int key_eta, float keybase, int posneg, float centre_eta, float centre_phi, int fcal_layer) const {
293  int towerID = keybase + phi + (64 * key_eta);
294  jTowerContainerRaw->push_back(eta, phi, towerID, posneg, centre_eta, centre_phi, fcal_layer);
295 
296 }
297 
298 
299 
300 StatusCode jTowerBuilder::AssignPileupAndNoiseValues(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const{
301 
302  SG::ReadCondHandle<jFEXDBCondData> myDBTool = SG::ReadCondHandle<jFEXDBCondData>( m_BDToolKey/*, ctx*/ );
303  if (!myDBTool.isValid()){
304  ATH_MSG_ERROR("Not able to read " << m_BDToolKey );
305  return StatusCode::FAILURE;
306  }
307 
308  for(LVL1::jTower* jtower : *jTowerContainerRaw) {
309 
310  auto [CutJetEM, CutJetHad, CutMetEM, CutMetHad] = myDBTool->get_NoiseCuts( jtower->OnlineID() );
311  auto [PileUpWeightEM, PileUpWeightHad, InverseWeightEM, InverseWeightHad] = myDBTool->get_PileUpValues( jtower->OnlineID() );
312 
313  //Simulation used MeV not counts, those
314  int LSBscale_EM = 25; // cf LATOME
315  int LSBscale_HAD = 25; // cf LATOME
316 
317  //TREX uses another conversion factor
318  if(std::abs(jtower->centreEta()) < 1.5){
319  LSBscale_HAD = 500;// cf TREX
320  }
321 
322  //Since the COOL DB for FCAL individual towers are sharing the same OnlideID ( to save space)
323  //but in reality they are different towers. we need to set the parameters to 0
324  if(jtower->OfflineID() >= FEXAlgoSpaceDefs::jFEX_FCAL2_start){
325  PileUpWeightEM = 0;
326  InverseWeightEM = 0;
327  }
328  else if(jtower->OfflineID() >= FEXAlgoSpaceDefs::jFEX_FCAL1_start){
329  PileUpWeightHad = 0;
330  InverseWeightHad = 0;
331  }
332 
333  jtower->setTTowerArea(PileUpWeightEM,0);
334  jtower->setTTowerArea(PileUpWeightHad,1);
335 
336  jtower->setTTowerAreaInv(InverseWeightEM,0);
337  jtower->setTTowerAreaInv(InverseWeightHad,1);
338 
339  jtower->setNoiseForMet(CutMetEM*LSBscale_EM,0);
340  jtower->setNoiseForMet(CutMetHad*LSBscale_HAD,1);
341 
342  jtower->setNoiseForJet(CutJetEM*LSBscale_EM,0);
343  jtower->setNoiseForJet(CutJetHad*LSBscale_HAD,1);
344 
345  }
346  return StatusCode::SUCCESS;
347 }
348 
349 
350 void jTowerBuilder::BuildAllTowers(std::unique_ptr<jTowerContainer> & jTowerContainerRaw) const {
351  BuildEMBjTowers(jTowerContainerRaw);
352  BuildTRANSjTowers(jTowerContainerRaw);
353  BuildEMEjTowers(jTowerContainerRaw);
354  BuildEMIEjTowers(jTowerContainerRaw);
355  BuildFCALjTowers(jTowerContainerRaw);
356 }
357 
358 } // end of LVL1 namespace
359 
LVL1::jTowerBuilder::m_BDToolKey
SG::ReadCondHandleKey< jFEXDBCondData > m_BDToolKey
Definition: jTowerBuilder.h:57
LVL1::jTowerBuilder::m_TT_Size_phi
static constexpr float m_TT_Size_phi
Definition: jTowerBuilder.h:54
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
LVL1::jTowerBuilder::BuildHECjTowers
void BuildHECjTowers(std::unique_ptr< jTowerContainer > &jTowerContainerRaw) const
Definition: jTowerBuilder.cxx:265
TriggerTowerContainer.h
LVL1::jTowerBuilder::BuildTRANSjTowers
void BuildTRANSjTowers(std::unique_ptr< jTowerContainer > &jTowerContainerRaw) const
Definition: jTowerBuilder.cxx:82
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:206
LVL1
eFexTowerBuilder creates xAOD::eFexTowerContainer from supercells (LATOME) and triggerTowers (TREX) i...
Definition: ICMMCPHitsCnvTool.h:18
jTowerBuilder.h
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
LVL1::FEXAlgoSpaceDefs::jFEX_FCAL1_start
constexpr static int jFEX_FCAL1_start
Definition: FEXAlgoSpaceDefs.h:32
test_pyathena.parent
parent
Definition: test_pyathena.py:15
LVL1::jTowerBuilder::BuildEMIEjTowers
void BuildEMIEjTowers(std::unique_ptr< jTowerContainer > &jTowerContainerRaw) const
Definition: jTowerBuilder.cxx:158
CaloCell_SuperCell_ID.h
Helper class for offline supercell identifiers.
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
FEXAlgoSpaceDefs.h
LVL1::jTowerBuilder::init
virtual void init(std::unique_ptr< jTowerContainer > &jTowerContainerRaw) const override
Definition: jTowerBuilder.cxx:39
LVL1::jTowerBuilder::BuildEMBjTowers
void BuildEMBjTowers(std::unique_ptr< jTowerContainer > &jTowerContainerRaw) const
Definition: jTowerBuilder.cxx:68
TrigConf::name
Definition: HLTChainList.h:35
jTowerContainer.h
LVL1::jTowerBuilder::BuildEMEjTowers
void BuildEMEjTowers(std::unique_ptr< jTowerContainer > &jTowerContainerRaw) const
Definition: jTowerBuilder.cxx:98
LVL1::jTowerBuilder::initialize
virtual StatusCode initialize() override
Definition: jTowerBuilder.cxx:30
CaloCellContainer.h
LVL1::jTowerBuilder::m_TT_Size_phi_FCAL
static constexpr float m_TT_Size_phi_FCAL
Definition: jTowerBuilder.h:55
LVL1::jTowerBuilder::jTowerBuilder
jTowerBuilder(const std::string &type, const std::string &name, const IInterface *parent)
Definition: jTowerBuilder.cxx:26
LVL1::jTowerBuilder::AssignPileupAndNoiseValues
virtual StatusCode AssignPileupAndNoiseValues(std::unique_ptr< jTowerContainer > &jTowerContainerRaw) const override
Definition: jTowerBuilder.cxx:300
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
LVL1::jTowerBuilder::BuildSingleTower
void BuildSingleTower(std::unique_ptr< jTowerContainer > &jTowerContainerRaw, float eta, float phi, int key_eta, float keybase, int posneg, float centre_eta=0.0, float centre_phi=0.0, int fcal_layer=-1) const
Definition: jTowerBuilder.cxx:292
LVL1::FEXAlgoSpaceDefs::jFEX_FCAL2_start
constexpr static int jFEX_FCAL2_start
Definition: FEXAlgoSpaceDefs.h:33
LVL1::jTower
The jTower class is an interface object for jFEX trigger algorithms The purposes are twofold:
Definition: jTower.h:40
CaloIdManager.h
AthAlgTool
Definition: AthAlgTool.h:26
LVL1::jTowerBuilder::reset
virtual void reset() const override
Definition: jTowerBuilder.cxx:49
LVL1::jTowerBuilder::execute
virtual void execute(std::unique_ptr< jTowerContainer > &jTowerContainerRaw) const override
Definition: jTowerBuilder.cxx:54
jTower.h
LVL1::jTowerBuilder::BuildFCALjTowers
void BuildFCALjTowers(std::unique_ptr< jTowerContainer > &jTowerContainerRaw) const
Definition: jTowerBuilder.cxx:189
LVL1::jTowerBuilder::BuildAllTowers
void BuildAllTowers(std::unique_ptr< jTowerContainer > &jTowerContainerRaw) const
Definition: jTowerBuilder.cxx:350
Generated on Mon Dec 23 2024 21:12:54 for ATLAS Offline Software by   doxygen 1.8.18