ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Private Member Functions | Private Attributes | List of all members
LVL1::jFEXSysSim Class Reference

The jFEXSysSim class defines the structure of the jFEX system Its purpose is: More...

#include <jFEXSysSim.h>

Inheritance diagram for LVL1::jFEXSysSim:

Public Member Functions

virtual StatusCode initialize () override
 standard Athena-Algorithm method
virtual StatusCode finalize () override
 standard Athena-Algorithm method
virtual StatusCode execute (const EventContext &ctx, jFEXOutputCollection *inputOutputCollection) override
virtual void init () const override
virtual void cleanup () override
virtual int calcTowerID (int eta, int phi, int mod) const override

Private Member Functions

StatusCode fillSRJetEDM (const std::unique_ptr< jFEXTOB > &internalTob, char istob, float_t eta, float_t phi, SG::WriteHandle< xAOD::jFexSRJetRoIContainer > &jContainer) const
StatusCode fillLRJetEDM (const std::unique_ptr< jFEXTOB > &internalTob, char istob, float_t eta, float_t phi, SG::WriteHandle< xAOD::jFexLRJetRoIContainer > &jContainer) const
StatusCode fillTauEDM (const std::unique_ptr< jFEXTOB > &internalTob, char istob, float_t eta, float_t phi, SG::WriteHandle< xAOD::jFexTauRoIContainer > &jContainer) const
StatusCode fillFwdElEDM (uint8_t jFexNum, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi, SG::WriteHandle< xAOD::jFexFwdElRoIContainer > &jContainer) const
StatusCode fillSumEtEDM (const std::unique_ptr< jFEXTOB > &internalTob, SG::WriteHandle< xAOD::jFexSumETRoIContainer > &jContainer) const
StatusCode fillMetEDM (const std::unique_ptr< jFEXTOB > &internalTob, SG::WriteHandle< xAOD::jFexMETRoIContainer > &jContainer) const

Private Attributes

std::vector< jFEXSim * > m_jFEXCollection
 Internal data.
SG::ReadCondHandleKey< jFEXDBCondData > m_DBToolKey {this, "DBToolKey", "jFEXDBParams", "DB tool key"}
ToolHandle< IjFEXSim > m_jFEXSimTool {this, "jFEXSimTool", "LVL1::jFEXSim", "Tool that creates the jFEX Simulation"}
SG::ReadHandleKey< LVL1::jTowerContainer > m_jTowerContainerSGKey {this, "MyETowers", "jTowerContainer", "Input container for jTowers"}
SG::ReadHandleKey< TrigConf::L1Menu > m_l1MenuKey {this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu","Name of the L1Menu object to read configuration from"}
SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer > m_TobOutKey_jJ {this,"Key_jFexSRJetOutputContainer","L1_jFexSRJetRoI","Output jFexEDM jets container"}
SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer > m_TobOutKey_jLJ {this,"Key_jFexLRJetOutputContainer","L1_jFexLRJetRoI","Output jFexEDM Ljets container"}
SG::WriteHandleKey< xAOD::jFexTauRoIContainer > m_TobOutKey_jTau {this,"Key_jFexTauOutputContainer" ,"L1_jFexTauRoI" ,"Output jFexEDM tau container"}
SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer > m_TobOutKey_jEM {this,"Key_jFexFwdElOutputContainer","L1_jFexFwdElRoI","Output jFexEDM fwdEl container"}
SG::WriteHandleKey< xAOD::jFexSumETRoIContainer > m_TobOutKey_jTE {this,"Key_jFexSumETOutputContainer","L1_jFexSumETRoI","Output jFexEDM SumET container"}
SG::WriteHandleKey< xAOD::jFexMETRoIContainer > m_TobOutKey_jXE {this,"Key_jFexMETOutputContainer" ,"L1_jFexMETRoI" ,"Output jFexEDM Met container"}
SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer > m_xTobOutKey_jJ {this,"Key_xTobOutKey_jJ" ,"L1_jFexSRJetxRoI","Output jFexEDM xTOBs jets container"}
SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer > m_xTobOutKey_jLJ {this,"Key_xTobOutKey_jLJ" ,"L1_jFexLRJetxRoI","Output jFexEDM xTOBs Ljets container"}
SG::WriteHandleKey< xAOD::jFexTauRoIContainer > m_xTobOutKey_jTau {this,"Key_xTobOutKey_jTau" ,"L1_jFexTauxRoI" ,"Output jFexEDM xTOBs tau container"}
SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer > m_xTobOutKey_jEM {this,"Key_xTobOutKey_jEM" ,"L1_jFexFwdElxRoI","Output jFexEDM xTOBs fwdEl container"}
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_TobDecorKey_jJ_seedET { this, "Key_tobDecor_jJ_seedET" , m_TobOutKey_jJ , "seedETMeV" , "jJet seed ET value in MeV" }
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_xTobDecorKey_jJ_seedET { this, "Key_xTobDecor_jJ_seedET" , m_xTobOutKey_jJ , "seedETMeV" , "jJet seed ET value in MeV" }
std::unordered_map< int, jTower > m_jTowersColl
std::unordered_map< uint8_t, std::vector< std::vector< std::vector< uint32_t > > > > m_allfwdElTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_alltauTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_allSmallRJetTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_allLargeRJetTobs
std::unordered_map< uint8_t, std::vector< std::unique_ptr< jFEXTOB > > > m_allsumEtTobs
std::unordered_map< uint8_t, std::vector< std::unique_ptr< jFEXTOB > > > m_allMetTobs

Detailed Description

The jFEXSysSim class defines the structure of the jFEX system Its purpose is:

  • to follow the structure of the 24 jFEXes and their FPGAs in as much detail as necessary to simulate the output of the system It will need to interact with jTowers and produce the eTOBs

Definition at line 47 of file jFEXSysSim.h.

Member Function Documentation

◆ calcTowerID()

int LVL1::jFEXSysSim::calcTowerID ( int eta,
int phi,
int mod ) const
overridevirtual

Definition at line 87 of file jFEXSysSim.cxx.

87 {
88
89 return ((64*eta) + phi + mod);
90 }
eta
Scalar eta() const
pseudorapidity method
Definition AmgMatrixBasePlugin.h:83
phi
Scalar phi() const
phi method
Definition AmgMatrixBasePlugin.h:67

◆ cleanup()

void LVL1::jFEXSysSim::cleanup ( )
overridevirtual

Definition at line 79 of file jFEXSysSim.cxx.

79 {
80
81 m_jFEXCollection.clear();
82 m_jTowersColl.clear();
83
84 }
LVL1::jFEXSysSim::m_jTowersColl
std::unordered_map< int, jTower > m_jTowersColl
Definition jFEXSysSim.h:99
LVL1::jFEXSysSim::m_jFEXCollection
std::vector< jFEXSim * > m_jFEXCollection
Internal data.
Definition jFEXSysSim.h:70

◆ execute()

StatusCode LVL1::jFEXSysSim::execute ( const EventContext & ctx,
jFEXOutputCollection * inputOutputCollection )
overridevirtual

Definition at line 92 of file jFEXSysSim.cxx.

92 {
93
94 SG::ReadHandle<LVL1::jTowerContainer> this_jTowerContainer(m_jTowerContainerSGKey, ctx);
95 if(!this_jTowerContainer.isValid()){
96 ATH_MSG_ERROR("Could not retrieve jTowerContainer " << m_jTowerContainerSGKey.key());
97 return StatusCode::FAILURE;
98 }
99
100 m_allSmallRJetTobs.clear();
101 m_allLargeRJetTobs.clear();
102 m_alltauTobs.clear();
103 m_allfwdElTobs.clear();
104 m_allMetTobs.clear();
105 m_allsumEtTobs.clear();
106 // We need to split the towers into 6 blocks in eta and 4 blocks in phi.
107
108 // boundaries in eta: -2.5, -1.6, -0.8, 0.0, 0.8, 1.6, 2.5
109 // Written explicitly:
110 // -2.5 -> -0.8 (in reality this will be -4.9 to -0.8 , but we're ignoring the forward region for the time being...) [core is -4.9 to -1.6]
111 // -2.4 -> -0.0 [core is -1.6 to -0.8]
112 // -1.6 -> 0.8 [core is -0.8 to -0.0]
113 // -0.8 -> 1.6 [core is [0.0 to 0.8]
114 // 0.0 -> 2.4 [core is 0.8 to 1.6]
115 // 0.8 -> 2.5 (in reality this will be 0.8 to 4.9 , but we're ignoring the forward region for the time being...) [core is 1.6 to 4.9]
116
117 //----------------------------------------------WRONG! THE FPGAs SPLIT IN PHI, NOT THE FEXs------------------------------------------------
118 // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
119 // boundaries in phi: 0.0, 1.6, 3.2, 4.8, 6.4
120 // Written explicitly:
121 // 5.6 -> 2.4 [core is 0.0 to 1.6]
122 // 0.8 -> 4.0 [core is 1.6 to 3.2]
123 // 2.4 -> 5.6 [core is 3.2 to 4.8]
124 // 4.0 -> 0.8 [core is 4.8 to 6.4]
125 // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
126 //----------------------------------------------WRONG! THE FPGAs SPLIT IN PHI, NOT THE FEXs------------------------------------------------
127
128 //--------------------------------------------------------------------------------------------------------------------------------------------------------------------
129 // C-SIDE NEGATIVE JFEX
130 // LEFT-MOST
131 // -4.9 to -0.8 [core is -4.9 to -1.6]
132 // DO THE LEFT-MOST (NEGATIVE ETA) JFEX FIRST
133 //id_modifier + phi + (64 * eta)
134 int fcal2Eta = 3; int fcal2Phi = 0; int fcal2Mod = 1100000;
135 int initialFCAL2 = calcTowerID(fcal2Eta,fcal2Phi,fcal2Mod); //1100192
136 int fcal1Eta = 7; int fcal1Phi = 0; int fcal1Mod = 900000;
137 int initialFCAL1 = calcTowerID(fcal1Eta,fcal1Phi,fcal1Mod); //900448
138 int fcal0Eta = 11; int fcal0Phi = 0; int fcal0Mod = 700000;
139 int initialFCAL0 = calcTowerID(fcal0Eta,fcal0Phi,fcal0Mod); //700704
140 int emecEta = 28; int emecPhi = 0; int emecMod = 500000;
141 int initialEMEC = calcTowerID(emecEta,emecPhi,emecMod); //501792
142 int transEta = 14; int transPhi = 0; int transMod = 300000;
143 int initialTRANS = calcTowerID(transEta,transPhi,transMod); //300896;
144 int embEta = 13; int embPhi = 0; int embMod = 100000;
145 int initialEMB = calcTowerID(embEta,embPhi,embMod); //100832
146
147 SG::ReadCondHandle<jFEXDBCondData> myDBTool = SG::ReadCondHandle<jFEXDBCondData>( m_DBToolKey, ctx );
148 if (!myDBTool.isValid()){
149 ATH_MSG_ERROR("Not able to read " << m_DBToolKey );
150 return StatusCode::FAILURE;
151 }
152
153 unsigned int evtTimeStamp = ctx.eventID().time_stamp();
154
155 uint8_t thisJFEX = 0;
156 // jFEX 0
157 thisJFEX = 0;
158
159 // let's work fully out to in (sort of)
160 // Let's go with FCAL2 first
161 // decide which subset of towers (and therefore supercells) should go to the jFEX
162 std::unordered_map<int,jTower> tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL;
163 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL.reserve(1600);
164
165 // let's try doing this with an array initially just containing tower IDs.
166 //coverity[STACK_USE]
167 int tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL [2*FEXAlgoSpaceDefs::jFEX_algoSpace_height][FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width];
168
169 // zero the matrix out
170 for (int i = 0; i<2*FEXAlgoSpaceDefs::jFEX_algoSpace_height; i++){
171 for (int j = 0; j<FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width; j++){
172 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL[i][j] = 0;
173 }
174 }
175
176 int rows = sizeof tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL / sizeof tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL[0];
177 int cols = sizeof tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL[0] / sizeof tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL[0][0];
178
179 // set the FCAL2 part
180 for(int thisCol=0; thisCol<4; thisCol++){
181 for(int thisRow=0; thisRow<rows/4; thisRow++){
182
183 int towerid = initialFCAL2 - (thisCol * 64) + thisRow;
184
185 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL[thisRow][thisCol] = towerid;
186 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
187
188 }
189 }
190 //---
191 // Let's go with FCAL1
192 // set the FCAL1 part
193 for(int thisCol=4; thisCol<12; thisCol++){
194 for(int thisRow=0; thisRow<rows/4; thisRow++){
195
196 int towerid = initialFCAL1 - ((thisCol-4) * 64) + thisRow;
197
198 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL[thisRow][thisCol] = towerid;
199 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
200
201 }
202 }
203 //---
204 // Let's go with FCAL0
205 // set the FCAL0 part
206 for(int thisCol=12; thisCol<24; thisCol++){
207 for(int thisRow=0; thisRow<rows/4; thisRow++){
208
209 int towerid = initialFCAL0 - ((thisCol-12) * 64) + thisRow;
210
211 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL[thisRow][thisCol] = towerid;
212 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
213
214 }
215 }
216 //---
217 // decide which subset of towers (and therefore supercells) should go to the jFEX
218 // set the next EMEC part
219 for(int thisCol=24; thisCol<28; thisCol++){
220 for(int thisRow=0; thisRow<rows/2; thisRow++){
221
222 int towerid = initialEMEC - ((thisCol-24) * 64) + thisRow;
223
224 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL[thisRow][thisCol] = towerid;
225 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
226
227 }
228 }
229 // set the EMEC part
230 for(int thisCol=28; thisCol<38; thisCol++){
231 for(int thisRow=0; thisRow<rows; thisRow++){
232
233 int towerid = initialEMEC - ((thisCol-24) * 64) + thisRow; //note special case -24 rather than -28, this *is* deliberate
234
235 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL[thisRow][thisCol] = towerid;
236 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
237
238 }
239 }
240 // set the TRANS part
241 for(int thisRow = 0; thisRow < rows; thisRow++){
242
243 int towerid = initialTRANS + thisRow;
244
245 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL[thisRow][38] = towerid;
246 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
247
248 }
249 // set the EMB part
250 for(int thisCol = 39; thisCol < 45; thisCol++){
251 for(int thisRow=0; thisRow<rows; thisRow++){
252
253 int towerid = initialEMB - ( (thisCol-39) * 64) + thisRow;
254
255 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL[thisRow][thisCol] = towerid;
256 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
257
258 }
259 }
260
261 if (msgLvl(MSG::DEBUG)) {
262 ATH_MSG_DEBUG("CONTENTS OF jFEX " << thisJFEX << " :");
263 for (int thisRow=rows-1; thisRow>=0; thisRow--) {
264 for (int thisCol=0; thisCol<cols; thisCol++) {
265 int tmptowerid = tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL[thisRow][thisCol];
266 if(tmptowerid == 0 ) continue;
267 const LVL1::jTower* tmptower = this_jTowerContainer->findTower(tmptowerid);
268 const float tmptowereta = tmptower->iEta();
269 const float tmptowerphi = tmptower->iPhi();
270 if(thisCol != cols-1) {
271 ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowerphi << "][" << tmptowereta << "]) ");
272 }
273 else {
274 ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) |");
275 }
276 }
277 }
278 }
279 m_jFEXSimTool->init(thisJFEX);
280 ATH_CHECK(m_jFEXSimTool->ExecuteForwardASide(tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL, inputOutputCollection, { evtTimeStamp, myDBTool->get_jJCalibParams(thisJFEX) } ));
281
282 m_allSmallRJetTobs.insert(std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getSmallRJetTOBs() ) ));
283 m_allLargeRJetTobs.insert(std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getLargeRJetTOBs() ) ));
284 m_alltauTobs.insert( std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getTauTOBs() ) ));
285 m_allfwdElTobs.insert( std::unordered_map<uint8_t, std::vector<std::vector<std::vector<uint32_t>>> >::value_type(thisJFEX,(m_jFEXSimTool->getFwdElTOBs() ) ));
286
287 m_allsumEtTobs.insert(std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB>> >::value_type(thisJFEX,(m_jFEXSimTool->getSumEtTOBs() ) ));
288 m_allMetTobs.insert(std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB>> >::value_type(thisJFEX,(m_jFEXSimTool->getMetTOBs() ) ));
289 m_jFEXSimTool->reset();
290
291 //--------------------------------------------------------------------------------------------------------------------------------------------------------------------
292
293 //--------------------------------------------------------------------------------------------------------------------------------------------------------------------
294 // C-SIDE NEGATIVE JFEX
295 // INNER-LEFT
296 // -2.4 -> -0.0 [core is -1.6 to -0.8]
297 // DO THE INNER-LEFT (NEGATIVE ETA) JFEX SECOND
298 //id_modifier + phi + (64 * eta)
299 emecEta = 23; emecPhi = 0; emecMod = 500000;
300 initialEMEC = calcTowerID(emecEta,emecPhi,emecMod); //500472;
301 transEta = 14; transPhi = 0; transMod = 300000;
302 initialTRANS = calcTowerID(transEta,transPhi,transMod); //300896;
303 embEta = 13; embPhi = 0; embMod = 100000;
304 initialEMB = calcTowerID(embEta,embPhi,embMod); //100832
305
306 // jFEX 1
307 thisJFEX = 1;
308
309 // decide which subset of towers (and therefore supercells) should go to the jFEX
310 std::unordered_map<int,jTower> tmp_jTowersColl_subset_1;
311
312 // let's try doing this with an array initially just containing tower IDs.
313 int tmp_jTowersIDs_subset_1 [2*FEXAlgoSpaceDefs::jFEX_algoSpace_height][FEXAlgoSpaceDefs::jFEX_thin_algoSpace_width];
314
315 // zero the matrix out
316 for (int i = 0; i<2*FEXAlgoSpaceDefs::jFEX_algoSpace_height; i++){
317 for (int j = 0; j<FEXAlgoSpaceDefs::jFEX_thin_algoSpace_width; j++){
318 tmp_jTowersIDs_subset_1[i][j] = 0;
319 }
320 }
321
322 rows = sizeof tmp_jTowersIDs_subset_1 / sizeof tmp_jTowersIDs_subset_1[0];
323 cols = sizeof tmp_jTowersIDs_subset_1[0] / sizeof tmp_jTowersIDs_subset_1[0][0];
324
325 // set the EMEC part
326 for(int thisCol = 0; thisCol < 9; thisCol++){
327 for(int thisRow=0; thisRow<rows; thisRow++){
328
329 int towerid = initialEMEC - (thisCol * 64) + thisRow;
330
331 tmp_jTowersIDs_subset_1[thisRow][thisCol] = towerid;
332 tmp_jTowersColl_subset_1.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
333
334 }
335 }
336
337 // set the TRANS part
338 for(int thisRow = 0; thisRow < rows; thisRow++) {
339
340 int towerid = initialTRANS + thisRow;
341
342 tmp_jTowersIDs_subset_1[thisRow][9] = towerid;
343 tmp_jTowersColl_subset_1.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
344
345 }
346
347 // set the EMB part
348 for(int thisCol = 10; thisCol < cols; thisCol++) {
349 for(int thisRow=0; thisRow<rows; thisRow++) {
350
351 int towerid = initialEMB - ( (thisCol-10) * 64) + thisRow ;
352
353 tmp_jTowersIDs_subset_1[thisRow][thisCol] = towerid;
354 tmp_jTowersColl_subset_1.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
355
356 }
357 }
358
359 if (msgLvl(MSG::DEBUG)) {
360 ATH_MSG_DEBUG("CONTENTS OF jFEX " << thisJFEX << " :");
361 for (int thisRow=rows-1; thisRow>=0; thisRow--) {
362 for (int thisCol=0; thisCol<cols; thisCol++) {
363 int tmptowerid = tmp_jTowersIDs_subset_1[thisRow][thisCol];
364 if(tmptowerid == 0) continue;
365 const LVL1::jTower* tmptower = this_jTowerContainer->findTower(tmptowerid);
366 const float tmptowereta = tmptower->iEta();
367 const float tmptowerphi = tmptower->iPhi();
368 if(thisCol != cols-1) {
369 ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowerphi << "][" << tmptowereta << "]) ");
370 }
371 else {
372 ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) |");
373 }
374 }
375 }
376 }
377 m_jFEXSimTool->init(thisJFEX);
378 ATH_CHECK(m_jFEXSimTool->ExecuteBarrel(tmp_jTowersIDs_subset_1, inputOutputCollection, { evtTimeStamp, myDBTool->get_jJCalibParams(thisJFEX) } ));
379
380 m_allSmallRJetTobs.insert(std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getSmallRJetTOBs() ) ));
381 m_allLargeRJetTobs.insert(std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getLargeRJetTOBs() ) ));
382 m_alltauTobs.insert( std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getTauTOBs() ) ));
383
384 m_allsumEtTobs.insert(std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB>> >::value_type(thisJFEX,(m_jFEXSimTool->getSumEtTOBs() ) ));
385 m_allMetTobs.insert(std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB>> >::value_type(thisJFEX,(m_jFEXSimTool->getMetTOBs() ) ));
386 m_jFEXSimTool->reset();
387
388 //--------------------------------------------------------------------------------------------------------------------------------------------------------------------
389
390 //--------------------------------------------------------------------------------------------------------------------------------------------------------------------
391 // C-SIDE NEGATIVE JFEXs
392 // CENTRAL-LEFT
393 // -1.6 -> 0.8 [core is -0.8 to -0.0]
394 // DO THE CENTRAL-LEFT JFEXs (NEGATIVE ETA) THIRD
395 //id_modifier + phi + (64 * eta)
396 emecEta = 15; emecPhi = 0; emecMod = 500000;
397 initialEMEC = calcTowerID(emecEta,emecPhi,emecMod); //500960;
398 transEta = 14; transPhi = 0; transMod = 300000;
399 initialTRANS = calcTowerID(transEta,transPhi,transMod); //300896;
400 embEta = 13; embPhi = 0; embMod = 100000;
401 initialEMB = calcTowerID(embEta,embPhi,embMod); //100832
402
403 // jFEX 2
404 thisJFEX = 2;
405
406 // decide which subset of towers (and therefore supercells) should go to the jFEX
407 std::unordered_map<int,jTower> tmp_jTowersColl_subset_2;
408
409 // doing this with an array initially just containing tower IDs.
410 int tmp_jTowersIDs_subset_2 [2*FEXAlgoSpaceDefs::jFEX_algoSpace_height][FEXAlgoSpaceDefs::jFEX_thin_algoSpace_width];
411
412 // zero the matrix out
413 for (int i = 0; i<2*FEXAlgoSpaceDefs::jFEX_algoSpace_height; i++) {
414 for (int j = 0; j<FEXAlgoSpaceDefs::jFEX_thin_algoSpace_width; j++) {
415 tmp_jTowersIDs_subset_2[i][j] = 0;
416 }
417 }
418
419
420 rows = sizeof tmp_jTowersIDs_subset_2 / sizeof tmp_jTowersIDs_subset_2[0];
421 cols = sizeof tmp_jTowersIDs_subset_2[0] / sizeof tmp_jTowersIDs_subset_2[0][0];
422
423 // set the EMEC part
424 for(int thisRow=0; thisRow<rows; thisRow++) {
425
426 int towerid = initialEMEC /*- (thisCol * 64)*/ + thisRow;
427
428 tmp_jTowersIDs_subset_2[thisRow][0] = towerid;
429 tmp_jTowersColl_subset_2.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
430
431 }
432
433 // set the TRANS part
434 for(int thisRow = 0; thisRow < rows; thisRow++) {
435
436 int towerid = initialTRANS + thisRow;
437
438 tmp_jTowersIDs_subset_2[thisRow][1] = towerid;
439 tmp_jTowersColl_subset_2.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
440
441 }
442
443 // set the negative EMB part
444 for(int thisCol = 2; thisCol < cols-8; thisCol++) {
445 for(int thisRow=0; thisRow<rows; thisRow++) {
446 int towerid = -1;
447
448 int tmp_initEMB = initialEMB;
449
450 towerid = tmp_initEMB - ( (thisCol-2) * 64) + thisRow;
451 tmp_jTowersIDs_subset_2[thisRow][thisCol] = towerid;
452
453 tmp_jTowersColl_subset_2.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
454
455 }
456 }
457
458 embEta = 0; embPhi = 0; embMod = 200000;
459 initialEMB = calcTowerID(embEta,embPhi,embMod); //200000
460
461 // set the positive EMB part
462 for(int thisCol = 16; thisCol < cols; thisCol++) {
463 for(int thisRow=0; thisRow<rows; thisRow++) {
464 int towerid = -1;
465
466 int tmp_initEMB = initialEMB;
467
468 towerid = tmp_initEMB + ( (thisCol-16) * 64) + thisRow;
469 tmp_jTowersIDs_subset_2[thisRow][thisCol] = towerid;
470
471 tmp_jTowersColl_subset_2.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
472
473 }
474 }
475
476 if (msgLvl(MSG::DEBUG)) {
477 ATH_MSG_DEBUG("CONTENTS OF jFEX " << thisJFEX << " :");
478 for (int thisRow=rows-1; thisRow>=0; thisRow--) {
479 for (int thisCol=0; thisCol<cols; thisCol++) {
480 int tmptowerid = tmp_jTowersIDs_subset_2[thisRow][thisCol];
481 if(tmptowerid == 0) continue;
482 const LVL1::jTower* tmptower = this_jTowerContainer->findTower(tmptowerid);
483 const float tmptowereta = tmptower->iEta();
484 const float tmptowerphi = tmptower->iPhi();
485 if(thisCol != cols-1) {
486 ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) ");
487 }
488 else {
489 ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) |");
490 }
491 }
492 }
493 }
494
495 //tool use instead
496 m_jFEXSimTool->init(thisJFEX);
497 ATH_CHECK(m_jFEXSimTool->ExecuteBarrel(tmp_jTowersIDs_subset_2, inputOutputCollection, { evtTimeStamp, myDBTool->get_jJCalibParams(thisJFEX) } ));
498
499 m_allSmallRJetTobs.insert(std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getSmallRJetTOBs() ) ));
500 m_allLargeRJetTobs.insert(std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getLargeRJetTOBs() ) ));
501 m_alltauTobs.insert( std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getTauTOBs() ) ));
502
503 m_allsumEtTobs.insert(std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB>> >::value_type(thisJFEX,(m_jFEXSimTool->getSumEtTOBs() ) ));
504 m_allMetTobs.insert(std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB>> >::value_type(thisJFEX,(m_jFEXSimTool->getMetTOBs() ) ));
505 m_jFEXSimTool->reset();
506
507 //--------------------------------------------------------------------------------------------------------------------------------------------------------------------
508
509 //--------------------------------------------------------------------------------------------------------------------------------------------------------------------
510 // A-SIDE POSITIVE JFEXs
511 // CENTRAL-RIGHT JFEXs
512 // -0.8 -> 1.6 [core is [0.0 to 0.8]
513 // DO THE CENTRAL-RIGHT JFEXs (POSITIVE ETA) FOURTH
514 //id_modifier + phi + (64 * eta)
515 emecEta = 15; emecPhi = 0; emecMod = 600000;
516 initialEMEC = calcTowerID(emecEta,emecPhi,emecMod); //600960;
517 transEta = 14; transPhi = 0; transMod = 400000;
518 initialTRANS = calcTowerID(transEta,transPhi,transMod); //400896;
519 embEta = 7; embPhi = 0; embMod = 100000;
520 initialEMB = calcTowerID(embEta,embPhi,embMod); //100448
521
522 // jFEX 3
523 thisJFEX = 3;
524
525 // decide which subset of towers (and therefore supercells) should go to the jFEX
526 std::unordered_map<int,jTower> tmp_jTowersColl_subset_3;
527
528 // doing this with an array initially just containing tower IDs.
529 int tmp_jTowersIDs_subset_3 [2*FEXAlgoSpaceDefs::jFEX_algoSpace_height][FEXAlgoSpaceDefs::jFEX_thin_algoSpace_width];
530
531 // zero the matrix out
532 for (int i = 0; i<2*FEXAlgoSpaceDefs::jFEX_algoSpace_height; i++){
533 for (int j = 0; j<FEXAlgoSpaceDefs::jFEX_thin_algoSpace_width; j++){
534 tmp_jTowersIDs_subset_3[i][j] = 0;
535 }
536 }
537
538
539 rows = sizeof tmp_jTowersIDs_subset_3 / sizeof tmp_jTowersIDs_subset_3[0];
540 cols = sizeof tmp_jTowersIDs_subset_3[0] / sizeof tmp_jTowersIDs_subset_3[0][0];
541
542 // set the negative EMB part
543 for(int thisCol = 0; thisCol < 8; thisCol++){
544 for(int thisRow=0; thisRow<rows; thisRow++){
545 int towerid = -1;
546
547 int tmp_initEMB = initialEMB;
548
549 towerid = tmp_initEMB - ( (thisCol) * 64) + thisRow;
550
551 tmp_jTowersIDs_subset_3[thisRow][thisCol] = towerid;
552
553 tmp_jTowersColl_subset_3.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
554
555 }
556 }
557
558 embEta = 0; embPhi = 0; embMod = 200000;
559 initialEMB = calcTowerID(embEta,embPhi,embMod); //200000
560 // set the positive EMB part
561 for(int thisCol = 8; thisCol < 22; thisCol++){
562 for(int thisRow=0; thisRow<rows; thisRow++){
563 int towerid = -1;
564
565 int tmp_initEMB = initialEMB;
566
567 towerid = tmp_initEMB + ( (thisCol-8) * 64) + thisRow;
568
569 tmp_jTowersIDs_subset_3[thisRow][thisCol] = towerid;
570
571 tmp_jTowersColl_subset_3.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
572
573 }
574 }
575
576 // set the TRANS part
577 for(int thisRow = 0; thisRow < rows; thisRow++){
578 int towerid = initialTRANS + thisRow;
579
580 tmp_jTowersIDs_subset_3[thisRow][22] = towerid;
581 tmp_jTowersColl_subset_3.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
582
583 }
584
585 // set the EMEC part
586 for(int thisRow=0; thisRow<rows; thisRow++){
587 int towerid = initialEMEC + /*( (thisCol-8) * 64)*/ + thisRow;
588
589 tmp_jTowersIDs_subset_3[thisRow][23] = towerid;
590 tmp_jTowersColl_subset_3.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
591
592 }
593
594 if (msgLvl(MSG::DEBUG)) {
595 ATH_MSG_DEBUG("CONTENTS OF jFEX " << thisJFEX << " :");
596 for (int thisRow=rows-1; thisRow>=0; thisRow--) {
597 for (int thisCol=0; thisCol<cols; thisCol++) {
598 int tmptowerid = tmp_jTowersIDs_subset_3[thisRow][thisCol];
599 if(tmptowerid == 0) continue;
600 const LVL1::jTower* tmptower = this_jTowerContainer->findTower(tmptowerid);
601 const float tmptowereta = tmptower->iEta();
602 const float tmptowerphi = tmptower->iPhi();
603 if(thisCol != cols-1) {
604 ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) ");
605 }
606 else {
607 ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) |");
608 }
609 }
610 }
611 }
612
613 //tool use instead
614 m_jFEXSimTool->init(thisJFEX);
615 ATH_CHECK(m_jFEXSimTool->ExecuteBarrel(tmp_jTowersIDs_subset_3, inputOutputCollection, { evtTimeStamp, myDBTool->get_jJCalibParams(thisJFEX) } ));
616
617 m_allSmallRJetTobs.insert(std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getSmallRJetTOBs() ) ));
618 m_allLargeRJetTobs.insert(std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getLargeRJetTOBs() ) ));
619 m_alltauTobs.insert( std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getTauTOBs() ) ));
620
621 m_allsumEtTobs.insert(std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB>> >::value_type(thisJFEX,(m_jFEXSimTool->getSumEtTOBs() ) ));
622 m_allMetTobs.insert(std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB>> >::value_type(thisJFEX,(m_jFEXSimTool->getMetTOBs() ) ));
623 m_jFEXSimTool->reset();
624
625 //--------------------------------------------------------------------------------------------------------------------------------------------------------------------
626
627 //--------------------------------------------------------------------------------------------------------------------------------------------------------------------
628 // A-SIDE POSITIVE JFEXs
629 // INNER-RIGHT JFEXs
630 // 0.0 -> 2.4 [core is 0.8 to 1.6]
631 // DO THE INNER-RIGHT JFEXs (POSITIVE ETA) FIFTH
632 emecEta = 15; emecPhi = 0; emecMod = 600000;
633 initialEMEC = calcTowerID(emecEta,emecPhi,emecMod); //600960;
634 transEta = 14; transPhi = 0; transMod = 400000;
635 initialTRANS = calcTowerID(transEta,transPhi,transMod); //400896;
636 embEta = 0; embPhi = 0; embMod = 200000;
637 initialEMB = calcTowerID(embEta,embPhi,embMod); //200000;
638
639 // jFEX 4
640 thisJFEX = 4;
641
642 // decide which subset of towers (and therefore supercells) should go to the jFEX
643 std::unordered_map<int,jTower> tmp_jTowersColl_subset_4;
644
645 // doing this with an array initially just containing tower IDs.
646 int tmp_jTowersIDs_subset_4 [2*FEXAlgoSpaceDefs::jFEX_algoSpace_height][FEXAlgoSpaceDefs::jFEX_thin_algoSpace_width];
647
648 // zero the matrix out
649 for (int i = 0; i<2*FEXAlgoSpaceDefs::jFEX_algoSpace_height; i++){
650 for (int j = 0; j<FEXAlgoSpaceDefs::jFEX_thin_algoSpace_width; j++){
651 tmp_jTowersIDs_subset_4[i][j] = 0;
652 }
653 }
654
655 rows = sizeof tmp_jTowersIDs_subset_4 / sizeof tmp_jTowersIDs_subset_4[0];
656 cols = sizeof tmp_jTowersIDs_subset_4[0] / sizeof tmp_jTowersIDs_subset_4[0][0];
657
658 // set the EMB part
659 for(int thisCol = 0; thisCol < 14; thisCol++){
660 for(int thisRow=0; thisRow<rows; thisRow++){
661 int towerid = initialEMB + ( (thisCol) * 64) + thisRow;
662
663 tmp_jTowersIDs_subset_4[thisRow][thisCol] = towerid;
664 tmp_jTowersColl_subset_4.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
665
666 }
667 }
668 // set the TRANS part
669 for(int thisRow = 0; thisRow < rows; thisRow++){
670 int towerid = initialTRANS + thisRow;
671
672 tmp_jTowersIDs_subset_4[thisRow][14] = towerid;
673 tmp_jTowersColl_subset_4.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
674
675 }
676 // set the EMEC part
677 for(int thisCol = 15; thisCol < cols; thisCol++){
678 for(int thisRow=0; thisRow<rows; thisRow++){
679 int towerid = initialEMEC + ( (thisCol-15) * 64) + thisRow;
680
681 tmp_jTowersIDs_subset_4[thisRow][thisCol] = towerid;
682 tmp_jTowersColl_subset_4.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
683
684 }
685 }
686
687 if (msgLvl(MSG::DEBUG)) {
688 ATH_MSG_DEBUG("CONTENTS OF jFEX " << thisJFEX << " :");
689 for (int thisRow=rows-1; thisRow>=0; thisRow--) {
690 for (int thisCol=0; thisCol<cols; thisCol++) {
691 int tmptowerid = tmp_jTowersIDs_subset_4[thisRow][thisCol];
692 if(tmptowerid == 0) continue;
693 const LVL1::jTower* tmptower = this_jTowerContainer->findTower(tmptowerid);
694 const float tmptowereta = tmptower->iEta();
695 const float tmptowerphi = tmptower->iPhi();
696 if(thisCol != cols-1) {
697 ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) ");
698 }
699 else {
700 ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) |");
701 }
702 }
703 }
704 }
705
706 //tool use instead
707 m_jFEXSimTool->init(thisJFEX);
708 ATH_CHECK(m_jFEXSimTool->ExecuteBarrel(tmp_jTowersIDs_subset_4, inputOutputCollection, { evtTimeStamp, myDBTool->get_jJCalibParams(thisJFEX) } ));
709
710 m_allSmallRJetTobs.insert(std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getSmallRJetTOBs() ) ));
711 m_allLargeRJetTobs.insert(std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getLargeRJetTOBs() ) ));
712 m_alltauTobs.insert( std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getTauTOBs() ) ));
713
714 m_allsumEtTobs.insert(std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB>> >::value_type(thisJFEX,(m_jFEXSimTool->getSumEtTOBs() ) ));
715 m_allMetTobs.insert(std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB>> >::value_type(thisJFEX,(m_jFEXSimTool->getMetTOBs() ) ));
716 m_jFEXSimTool->reset();
717 //--------------------------------------------------------------------------------------------------------------------------------------------------------------------
718
719 //--------------------------------------------------------------------------------------------------------------------------------------------------------------------
720 // A-SIDE POSITIVE JFEXs
721 // RIGHT-MOST
722 // 0.8 -> 2.5 (in reality this will be 0.8 to 4.9 , but we're ignoring the forward region for the time being...) [core is 1.6 to 4.9]
723 // DO THE RIGHT-MOST (POSITIVE ETA) JFEXs SIXTH
724 //id_modifier + phi + (64 * eta)
725 fcal2Eta = 0; fcal2Phi = 0; fcal2Mod = 1200000;
726 initialFCAL2 = calcTowerID(fcal2Eta,fcal2Phi,fcal2Mod); //1200000
727 fcal1Eta = 0; fcal1Phi = 0; fcal1Mod = 1000000;
728 initialFCAL1 = calcTowerID(fcal1Eta,fcal1Phi,fcal1Mod); //1000000
729 fcal0Eta = 0; fcal0Phi = 0; fcal0Mod = 800000;
730 initialFCAL0 = calcTowerID(fcal0Eta,fcal0Phi,fcal0Mod); //800000
731 emecEta = 15; emecPhi = 0; emecMod = 600000;
732 initialEMEC = calcTowerID(emecEta,emecPhi,emecMod); //600960;
733 transEta = 14; transPhi = 0; transMod = 400000;
734 initialTRANS = calcTowerID(transEta,transPhi,transMod); //400896;
735 embEta = 8; embPhi = 0; embMod = 200000;
736 initialEMB = calcTowerID(embEta,embPhi,embMod); //200512;
737
738 // jFEX 5
739 thisJFEX = 5;
740
741 // decide which subset of towers (and therefore supercells) should go to the jFEX
742 std::unordered_map<int,jTower> tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL_2;
743
744 // let's try doing this with an array initially just containing tower IDs.
745 //uses 11520 bytes of stack space
746 //coverity[STACK_USE]
747 int tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2 [2*FEXAlgoSpaceDefs::jFEX_algoSpace_height][FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width];
748
749 // zero the matrix out
750 for (int i = 0; i<2*FEXAlgoSpaceDefs::jFEX_algoSpace_height; i++){
751 for (int j = 0; j<FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width; j++){
752 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2[i][j] = 0;
753 }
754 }
755
756 rows = sizeof tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2 / sizeof tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2[0];
757 cols = sizeof tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2[0] / sizeof tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2[0][0];
758
759 // set the EMB part
760 for(int thisCol = 0; thisCol < 6; thisCol++){
761 for(int thisRow=0; thisRow<rows; thisRow++){
762 int towerid = initialEMB + ( (thisCol) * 64) + thisRow;
763
764 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2[thisRow][thisCol] = towerid;
765 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL_2.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
766
767 }
768 }
769
770 // set the TRANS part
771 for(int thisRow = 0; thisRow < rows; thisRow++){
772 int towerid = initialTRANS + thisRow;
773
774 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2[thisRow][6] = towerid;
775 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL_2.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
776
777 }
778
779 // set the EMEC part
780 for(int thisCol=7; thisCol<17; thisCol++){
781 for(int thisRow=0; thisRow<rows; thisRow++){
782
783 int towerid = initialEMEC + ((thisCol-7) * 64) + thisRow;
784
785 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2[thisRow][thisCol] = towerid;
786 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL_2.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
787
788 }
789 }
790
791 // set the next EMEC part
792 for(int thisCol=17; thisCol<21; thisCol++){
793 for(int thisRow=0; thisRow<rows/2; thisRow++){
794
795 int towerid = initialEMEC + ((thisCol-7) * 64) + thisRow; //note special case -7 rather than -17, this *is* deliberate
796
797 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2[thisRow][thisCol] = towerid;
798 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL_2.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
799
800 }
801 }
802
803 //-----
804 // Let's go with FCAL0
805 // set the FCAL0 part
806 for(int thisCol=21; thisCol<33; thisCol++){
807 for(int thisRow=0; thisRow<rows/4; thisRow++){
808
809 int towerid = initialFCAL0 + ((thisCol-21) * 64) + thisRow;
810
811 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2[thisRow][thisCol] = towerid;
812 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL_2.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
813
814 }
815 }
816
817 //---
818 // Let's go with FCAL1
819 // set the FCAL1 part
820 for(int thisCol=33; thisCol<41; thisCol++){
821 for(int thisRow=0; thisRow<rows/4; thisRow++){
822
823 int towerid = initialFCAL1 + ((thisCol-33) * 64) + thisRow;
824
825 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2[thisRow][thisCol] = towerid;
826 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL_2.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
827
828 }
829 }
830
831 //---
832 // Let's go with FCAL2
833 // set the FCAL2 part
834 for(int thisCol=41; thisCol<45; thisCol++){
835 for(int thisRow=0; thisRow<rows/4; thisRow++){
836
837 int towerid = initialFCAL2 + ((thisCol-41) * 64) + thisRow;
838
839 tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2[thisRow][thisCol] = towerid;
840 tmp_jTowersColl_subset_ENDCAP_AND_EMB_AND_FCAL_2.insert( std::unordered_map<int, jTower>::value_type(towerid, *(this_jTowerContainer->findTower(towerid))));
841
842 }
843 }
844 //---
845
846 if (msgLvl(MSG::DEBUG)) {
847 ATH_MSG_DEBUG("CONTENTS OF jFEX " << thisJFEX << " :");
848 for (int thisRow=rows-1; thisRow>=0; thisRow--) {
849 for (int thisCol=0; thisCol<cols; thisCol++) {
850 int tmptowerid = tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2[thisRow][thisCol];
851 if(tmptowerid == 0) continue;
852 const LVL1::jTower* tmptower = this_jTowerContainer->findTower(tmptowerid);
853 const float tmptowereta = tmptower->iEta();
854 const float tmptowerphi = tmptower->iPhi();
855 if(thisCol != cols-1) {
856 ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowerphi << "][" << tmptowereta << "]) ");
857 }
858 else {
859 ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) |");
860 }
861 }
862 }
863 }
864
865 m_jFEXSimTool->init(thisJFEX);
866 ATH_CHECK(m_jFEXSimTool->ExecuteForwardCSide(tmp_jTowersIDs_subset_ENDCAP_AND_EMB_AND_FCAL_2, inputOutputCollection, { evtTimeStamp, myDBTool->get_jJCalibParams(thisJFEX) } ));
867
868 m_allSmallRJetTobs.insert(std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getSmallRJetTOBs() ) ));
869 m_allLargeRJetTobs.insert(std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getLargeRJetTOBs() ) ));
870 m_alltauTobs.insert( std::unordered_map<uint8_t, std::vector< std::vector<std::unique_ptr<jFEXTOB>> > >::value_type(thisJFEX,(m_jFEXSimTool->getTauTOBs() ) ));
871 m_allfwdElTobs.insert( std::unordered_map<uint8_t, std::vector<std::vector<std::vector<uint32_t>>> >::value_type(thisJFEX,(m_jFEXSimTool->getFwdElTOBs() ) ));
872
873 m_allsumEtTobs.insert(std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB>> >::value_type(thisJFEX,(m_jFEXSimTool->getSumEtTOBs() ) ));
874 m_allMetTobs.insert(std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB>> >::value_type(thisJFEX,(m_jFEXSimTool->getMetTOBs() ) ));
875 m_jFEXSimTool->reset();
876
877
878 //-----------------------------------------------------FILLING EDMs--------------------------------------------------------------------------------
879
880 //Reading the Trigger menu to send the jFEX Resolution to the EDMs
881
882 SG::ReadHandle<TrigConf::L1Menu> l1Menu (m_l1MenuKey, ctx);
883
884 const int jFwdElResolution = l1Menu->thrExtraInfo().jEM().resolutionMeV();
885
886 //---SRJet EDM
887 auto tobContainer_jJ = std::make_unique<xAOD::jFexSRJetRoIContainer> ();
888 std::unique_ptr< xAOD::jFexSRJetRoIAuxContainer > tobAuxContainer_jJ = std::make_unique<xAOD::jFexSRJetRoIAuxContainer> ();
889 tobContainer_jJ->setStore(tobAuxContainer_jJ.get());
890
891 SG::WriteDecorHandle<xAOD::jFexSRJetRoIContainer, int > tobDec_jJ_seedET (m_TobDecorKey_jJ_seedET, ctx);
892
893 auto xtobContainer_jJ = std::make_unique<xAOD::jFexSRJetRoIContainer> ();
894 std::unique_ptr< xAOD::jFexSRJetRoIAuxContainer > xtobAuxContainer_jJ = std::make_unique<xAOD::jFexSRJetRoIAuxContainer> ();
895 xtobContainer_jJ->setStore(xtobAuxContainer_jJ.get());
896
897 SG::WriteDecorHandle<xAOD::jFexSRJetRoIContainer, int > xtobDec_jJ_seedET (m_xTobDecorKey_jJ_seedET, ctx);
898
899
900 SG::WriteHandle<xAOD::jFexSRJetRoIContainer> output_Tob_jJ(m_TobOutKey_jJ, ctx);
901 ATH_MSG_DEBUG(" write: " << output_Tob_jJ.key() << " = " << "..." );
902 ATH_CHECK(output_Tob_jJ.record(std::move(tobContainer_jJ),std::move(tobAuxContainer_jJ)));
903
904 SG::WriteHandle<xAOD::jFexSRJetRoIContainer> output_xTob_jJ(m_xTobOutKey_jJ, ctx);
905 ATH_MSG_DEBUG(" write: " << output_xTob_jJ.key() << " = " << "..." );
906 ATH_CHECK(output_xTob_jJ.record(std::move(xtobContainer_jJ),std::move(xtobAuxContainer_jJ)));
907
908 // iterate over all SRJEt Tobs and fill EDM with them m_allSmallRJetTobs
909 for( auto const& [jfex, fpga] : m_allSmallRJetTobs ) {
910 for(auto const & tobs: fpga) {
911 for(size_t it = 0; it<tobs.size();it++) {
912 float_t eta = -99;
913 float_t phi = -99;
914 char istob = 0;
915 if(tobs.at(it)->getWord() != 0) {
916 eta = (this_jTowerContainer->findTower( tobs.at(it)->getTTID() ))->centreEta();
917 phi = (this_jTowerContainer->findTower( tobs.at(it)->getTTID() ))->centrephi_toPI();
918 }
919
920 // Just sending 7 SRjets to L1Topo and HLT chain
921 if(it<7){
922 istob = 1;
923 ATH_CHECK(fillSRJetEDM(tobs.at(it), istob, eta, phi, output_Tob_jJ));
924 tobDec_jJ_seedET( *(output_Tob_jJ->back()) ) = tobs.at(it)->getSeedEt();
925 }
926 ATH_CHECK(fillSRJetEDM(tobs.at(it), istob, eta, phi, output_xTob_jJ));
927 xtobDec_jJ_seedET( *(output_xTob_jJ->back()) ) = tobs.at(it)->getSeedEt();
928 }
929 }
930 }
931
932 //---LRJet EDM
933 auto tobContainer_jLJ = std::make_unique<xAOD::jFexLRJetRoIContainer> ();
934 std::unique_ptr< xAOD::jFexLRJetRoIAuxContainer > tobAuxContainer_jLJ = std::make_unique<xAOD::jFexLRJetRoIAuxContainer> ();
935 tobContainer_jLJ->setStore(tobAuxContainer_jLJ.get());
936
937 auto xtobContainer_jLJ = std::make_unique<xAOD::jFexLRJetRoIContainer> ();
938 std::unique_ptr< xAOD::jFexLRJetRoIAuxContainer > xtobAuxContainer_jLJ = std::make_unique<xAOD::jFexLRJetRoIAuxContainer> ();
939 xtobContainer_jLJ->setStore(xtobAuxContainer_jLJ.get());
940
941
942 SG::WriteHandle<xAOD::jFexLRJetRoIContainer_v1> output_Tob_jLJ(m_TobOutKey_jLJ, ctx);
943 ATH_MSG_DEBUG(" write: " << output_Tob_jLJ.key() << " = " << "..." );
944 ATH_CHECK(output_Tob_jLJ.record(std::move(tobContainer_jLJ),std::move(tobAuxContainer_jLJ)));
945
946 SG::WriteHandle<xAOD::jFexLRJetRoIContainer_v1> output_xTob_jLJ(m_xTobOutKey_jLJ, ctx);
947 ATH_MSG_DEBUG(" write: " << output_xTob_jLJ.key() << " = " << "..." );
948 ATH_CHECK(output_xTob_jLJ.record(std::move(xtobContainer_jLJ),std::move(xtobAuxContainer_jLJ)));
949
950 m_allLargeRJetTobs.clear(); // Aug2025: no longer filling the jLJ container, but will still produce the container to avoid EDM changes
951
952 // iterate over all LRJEt Tobs and fill EDM with them
953 for(auto const& [jfex, fpga] : m_allLargeRJetTobs ) {
954 for(auto const& tobs: fpga) {
955 for(size_t it = 0; it<tobs.size();it++) {
956 float_t eta = -99;
957 float_t phi = -99;
958 char istob = 0;
959 if(tobs.at(it)->getWord() != 0) {
960 eta = (this_jTowerContainer->findTower( tobs.at(it)->getTTID() ))->centreEta();
961 phi = (this_jTowerContainer->findTower( tobs.at(it)->getTTID() ))->centrephi_toPI();
962 }
963
964 // Just sending 1 LRjets to L1Topo and HLT chain
965 if(it<1){
966 istob=1;
967 ATH_CHECK(fillLRJetEDM(tobs.at(it), istob, eta, phi, output_Tob_jLJ));
968 }
969 ATH_CHECK(fillLRJetEDM(tobs.at(it), istob, eta, phi, output_xTob_jLJ));
970 }
971 }
972 }
973 //---Tau EDM
974 auto tobContainer_jTau = std::make_unique<xAOD::jFexTauRoIContainer> ();
975 std::unique_ptr< xAOD::jFexTauRoIAuxContainer > tobAuxContainer_jTau = std::make_unique<xAOD::jFexTauRoIAuxContainer> ();
976 tobContainer_jTau->setStore(tobAuxContainer_jTau.get());
977
978 auto xtobContainer_jTau = std::make_unique<xAOD::jFexTauRoIContainer> ();
979 std::unique_ptr< xAOD::jFexTauRoIAuxContainer > xtobAuxContainer_jTau = std::make_unique<xAOD::jFexTauRoIAuxContainer> ();
980 xtobContainer_jTau->setStore(xtobAuxContainer_jTau.get());
981
982 SG::WriteHandle<xAOD::jFexTauRoIContainer_v1> output_Tob_jTau(m_TobOutKey_jTau, ctx);
983 ATH_MSG_DEBUG(" write: " << output_Tob_jTau.key() << " = " << "..." );
984 ATH_CHECK(output_Tob_jTau.record(std::move(tobContainer_jTau),std::move(tobAuxContainer_jTau)));
985
986 SG::WriteHandle<xAOD::jFexTauRoIContainer_v1> output_xTob_jTau(m_xTobOutKey_jTau, ctx);
987 ATH_MSG_DEBUG(" write: " << output_xTob_jTau.key() << " = " << "..." );
988 ATH_CHECK(output_xTob_jTau.record(std::move(xtobContainer_jTau),std::move(xtobAuxContainer_jTau)));
989
990 //iterate over all Tau Tobs and fill EDM with
991 for( auto const& [jfex, fpga] : m_alltauTobs ) {
992 for(auto const& tobs : fpga){
993 for(size_t it = 0; it<tobs.size();it++) {
994 float_t eta = -99;
995 float_t phi = -99;
996 char istob = 0;
997 if(tobs.at(it)->getWord() != 0){
998 eta = (this_jTowerContainer->findTower( tobs.at(it)->getTTID() ))->centreEta();
999 phi = (this_jTowerContainer->findTower( tobs.at(it)->getTTID() ))->centrephi_toPI();
1000 }
1001
1002 // Just sending 6 Taus to L1Topo and HLT chain
1003 if(it<6){
1004 istob=1;
1005 ATH_CHECK(fillTauEDM(tobs.at(it), istob, eta, phi, output_Tob_jTau));
1006 }
1007 ATH_CHECK(fillTauEDM(tobs.at(it), istob, eta, phi, output_xTob_jTau));
1008 }
1009 }
1010
1011 }
1012
1013 //---Forward Elec EDM
1014 auto tobContainer_jEM = std::make_unique<xAOD::jFexFwdElRoIContainer> ();
1015 std::unique_ptr< xAOD::jFexFwdElRoIAuxContainer > tobAuxContainer_jEM = std::make_unique<xAOD::jFexFwdElRoIAuxContainer> ();
1016 tobContainer_jEM->setStore(tobAuxContainer_jEM.get());
1017
1018 auto xtobContainer_jEM = std::make_unique<xAOD::jFexFwdElRoIContainer> ();
1019 std::unique_ptr< xAOD::jFexFwdElRoIAuxContainer > xtobAuxContainer_jEM = std::make_unique<xAOD::jFexFwdElRoIAuxContainer> ();
1020 xtobContainer_jEM->setStore(xtobAuxContainer_jEM.get());
1021
1022 SG::WriteHandle<xAOD::jFexFwdElRoIContainer_v1> output_Tob_jEM(m_TobOutKey_jEM, ctx);
1023 ATH_MSG_DEBUG(" write: " << output_Tob_jEM.key() << " = " << "..." );
1024 ATH_CHECK(output_Tob_jEM.record(std::move(tobContainer_jEM),std::move(tobAuxContainer_jEM)));
1025
1026 SG::WriteHandle<xAOD::jFexFwdElRoIContainer_v1> output_xTob_jEM(m_xTobOutKey_jEM, ctx);
1027 ATH_MSG_DEBUG(" write: " << output_xTob_jEM.key() << " = " << "..." );
1028 ATH_CHECK(output_xTob_jEM.record(std::move(xtobContainer_jEM),std::move(xtobAuxContainer_jEM)));
1029
1030 //iterate over all Forward Elec Tobs and fill EDM
1031 for( auto const& [jfex, MODULE_tobs] : m_allfwdElTobs ) {
1032 const int fpga_map[4]={0,1,3,2}; // No FPGA info available in FWD EL TOB
1033 uint8_t fpgaNum =0;
1034 for(auto &FPGA_tob : MODULE_tobs) {
1035 if (fpgaNum>3) {
1036 ATH_MSG_ERROR("FPGA larger than 4 in Forward electron EDM!");
1037 continue;
1038 }
1039 for(size_t it = 0; it<FPGA_tob.size();it++) {
1040 float_t eta = -99;
1041 float_t phi = -99;
1042 char istob = 0;
1043 if(FPGA_tob.at(it).at(1) != 0) {
1044 eta = (this_jTowerContainer->findTower(FPGA_tob.at(it).at(1)))->centreEta();
1045 phi = (this_jTowerContainer->findTower(FPGA_tob.at(it).at(1)))->centrephi_toPI();
1046 }
1047
1048 if(it<5){
1049 istob=1;
1050 ATH_CHECK(fillFwdElEDM(jfex,fpga_map[fpgaNum], FPGA_tob.at(it).at(0),istob, jFwdElResolution, eta, phi, output_Tob_jEM));
1051 }
1052 ATH_CHECK(fillFwdElEDM(jfex,fpga_map[fpgaNum], FPGA_tob.at(it).at(0),istob, jFwdElResolution, eta, phi, output_xTob_jEM));
1053 }
1054 fpgaNum++;
1055 }
1056
1057 }
1058
1059 //---SumET EDM
1060 auto tobContainer_jTE = std::make_unique<xAOD::jFexSumETRoIContainer> ();
1061 std::unique_ptr< xAOD::jFexSumETRoIAuxContainer > tobAuxContainer_jTE = std::make_unique<xAOD::jFexSumETRoIAuxContainer> ();
1062 tobContainer_jTE->setStore(tobAuxContainer_jTE.get());
1063
1064 SG::WriteHandle<xAOD::jFexSumETRoIContainer_v1> output_Tob_jTE(m_TobOutKey_jTE, ctx);
1065 ATH_MSG_DEBUG(" write: " << output_Tob_jTE.key() << " = " << "..." );
1066 ATH_CHECK(output_Tob_jTE.record(std::move(tobContainer_jTE),std::move(tobAuxContainer_jTE)));
1067
1068 for( auto const& [jfex, tobs] : m_allsumEtTobs ) {
1069
1070 for(auto const& t : tobs) {
1071 ATH_CHECK(fillSumEtEDM(t, output_Tob_jTE));
1072 }
1073 }
1074
1075 //---MET EDM
1076 auto tobContainer_jXE = std::make_unique<xAOD::jFexMETRoIContainer> ();
1077 std::unique_ptr< xAOD::jFexMETRoIAuxContainer > tobAuxContainer_jXE = std::make_unique<xAOD::jFexMETRoIAuxContainer> ();
1078 tobContainer_jXE->setStore(tobAuxContainer_jXE.get());
1079
1080 SG::WriteHandle<xAOD::jFexMETRoIContainer_v1> output_Tob_jXE(m_TobOutKey_jXE, ctx);
1081 ATH_MSG_DEBUG(" write: " << output_Tob_jXE.key() << " = " << "..." );
1082 ATH_CHECK(output_Tob_jXE.record(std::move(tobContainer_jXE),std::move(tobAuxContainer_jXE)));
1083
1084 for( auto const& [jfex, tobs] : m_allMetTobs ) {
1085
1086 for(auto const& t : tobs) {
1087 ATH_CHECK(fillMetEDM(t, output_Tob_jXE));
1088 }
1089 }
1090
1091
1092
1093 //Send TOBs to bytestream?
1094 // ToDo
1095 // To implement
1096 // {--Implement--}
1097
1098 return StatusCode::SUCCESS;
1099
1100 }
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
LVL1::FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width
static constexpr int jFEX_wide_algoSpace_width
Definition FEXAlgoSpaceDefs.h:27
LVL1::FEXAlgoSpaceDefs::jFEX_thin_algoSpace_width
static constexpr int jFEX_thin_algoSpace_width
Definition FEXAlgoSpaceDefs.h:28
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_height
static constexpr int jFEX_algoSpace_height
Definition FEXAlgoSpaceDefs.h:29
LVL1::jFEXSysSim::m_allLargeRJetTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_allLargeRJetTobs
Definition jFEXSysSim.h:105
LVL1::jFEXSysSim::m_xTobOutKey_jLJ
SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer > m_xTobOutKey_jLJ
Definition jFEXSysSim.h:90
LVL1::jFEXSysSim::fillFwdElEDM
StatusCode fillFwdElEDM(uint8_t jFexNum, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi, SG::WriteHandle< xAOD::jFexFwdElRoIContainer > &jContainer) const
Definition jFEXSysSim.cxx:1128
LVL1::jFEXSysSim::m_alltauTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_alltauTobs
Definition jFEXSysSim.h:103
LVL1::jFEXSysSim::m_TobOutKey_jXE
SG::WriteHandleKey< xAOD::jFexMETRoIContainer > m_TobOutKey_jXE
Definition jFEXSysSim.h:86
LVL1::jFEXSysSim::m_xTobOutKey_jEM
SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer > m_xTobOutKey_jEM
Definition jFEXSysSim.h:92
LVL1::jFEXSysSim::m_jTowerContainerSGKey
SG::ReadHandleKey< LVL1::jTowerContainer > m_jTowerContainerSGKey
Definition jFEXSysSim.h:76
LVL1::jFEXSysSim::m_l1MenuKey
SG::ReadHandleKey< TrigConf::L1Menu > m_l1MenuKey
Definition jFEXSysSim.h:78
LVL1::jFEXSysSim::m_jFEXSimTool
ToolHandle< IjFEXSim > m_jFEXSimTool
Definition jFEXSysSim.h:74
LVL1::jFEXSysSim::m_allSmallRJetTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_allSmallRJetTobs
Definition jFEXSysSim.h:104
LVL1::jFEXSysSim::m_TobOutKey_jTau
SG::WriteHandleKey< xAOD::jFexTauRoIContainer > m_TobOutKey_jTau
Definition jFEXSysSim.h:83
LVL1::jFEXSysSim::fillTauEDM
StatusCode fillTauEDM(const std::unique_ptr< jFEXTOB > &internalTob, char istob, float_t eta, float_t phi, SG::WriteHandle< xAOD::jFexTauRoIContainer > &jContainer) const
Definition jFEXSysSim.cxx:1116
LVL1::jFEXSysSim::fillMetEDM
StatusCode fillMetEDM(const std::unique_ptr< jFEXTOB > &internalTob, SG::WriteHandle< xAOD::jFexMETRoIContainer > &jContainer) const
Definition jFEXSysSim.cxx:1164
LVL1::jFEXSysSim::m_xTobOutKey_jJ
SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer > m_xTobOutKey_jJ
Definition jFEXSysSim.h:89
LVL1::jFEXSysSim::m_TobDecorKey_jJ_seedET
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_TobDecorKey_jJ_seedET
Definition jFEXSysSim.h:95
LVL1::jFEXSysSim::m_allMetTobs
std::unordered_map< uint8_t, std::vector< std::unique_ptr< jFEXTOB > > > m_allMetTobs
Definition jFEXSysSim.h:107
LVL1::jFEXSysSim::fillLRJetEDM
StatusCode fillLRJetEDM(const std::unique_ptr< jFEXTOB > &internalTob, char istob, float_t eta, float_t phi, SG::WriteHandle< xAOD::jFexLRJetRoIContainer > &jContainer) const
Definition jFEXSysSim.cxx:1140
LVL1::jFEXSysSim::m_xTobDecorKey_jJ_seedET
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_xTobDecorKey_jJ_seedET
Definition jFEXSysSim.h:96
LVL1::jFEXSysSim::calcTowerID
virtual int calcTowerID(int eta, int phi, int mod) const override
Definition jFEXSysSim.cxx:87
LVL1::jFEXSysSim::m_TobOutKey_jLJ
SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer > m_TobOutKey_jLJ
Definition jFEXSysSim.h:82
LVL1::jFEXSysSim::m_TobOutKey_jJ
SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer > m_TobOutKey_jJ
Definition jFEXSysSim.h:81
LVL1::jFEXSysSim::m_TobOutKey_jEM
SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer > m_TobOutKey_jEM
Definition jFEXSysSim.h:84
LVL1::jFEXSysSim::m_allsumEtTobs
std::unordered_map< uint8_t, std::vector< std::unique_ptr< jFEXTOB > > > m_allsumEtTobs
Definition jFEXSysSim.h:106
LVL1::jFEXSysSim::fillSRJetEDM
StatusCode fillSRJetEDM(const std::unique_ptr< jFEXTOB > &internalTob, char istob, float_t eta, float_t phi, SG::WriteHandle< xAOD::jFexSRJetRoIContainer > &jContainer) const
Definition jFEXSysSim.cxx:1103
LVL1::jFEXSysSim::m_xTobOutKey_jTau
SG::WriteHandleKey< xAOD::jFexTauRoIContainer > m_xTobOutKey_jTau
Definition jFEXSysSim.h:91
LVL1::jFEXSysSim::m_DBToolKey
SG::ReadCondHandleKey< jFEXDBCondData > m_DBToolKey
Definition jFEXSysSim.h:72
LVL1::jFEXSysSim::m_allfwdElTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::vector< uint32_t > > > > m_allfwdElTobs
Definition jFEXSysSim.h:101
LVL1::jFEXSysSim::fillSumEtEDM
StatusCode fillSumEtEDM(const std::unique_ptr< jFEXTOB > &internalTob, SG::WriteHandle< xAOD::jFexSumETRoIContainer > &jContainer) const
Definition jFEXSysSim.cxx:1152
LVL1::jFEXSysSim::m_TobOutKey_jTE
SG::WriteHandleKey< xAOD::jFexSumETRoIContainer > m_TobOutKey_jTE
Definition jFEXSysSim.h:85
LVL1::jTower::iEta
int iEta() const
Get coordinates of tower.
Definition jTower.cxx:167
LVL1::jTower::iPhi
int iPhi() const
Return global phi index.
Definition jTower.cxx:172
TauHitVars::j
float j(const xAOD::IParticle &, const xAOD::TrackMeasurementValidation &hit, const Eigen::Matrix3d &jab_inv)
Definition ConstituentLoaderTauHit.cxx:102

◆ fillFwdElEDM()

StatusCode LVL1::jFEXSysSim::fillFwdElEDM ( uint8_t jFexNum,
uint8_t fpgaNumber,
uint32_t tobWord,
char istob,
int resolution,
float_t eta,
float_t phi,
SG::WriteHandle< xAOD::jFexFwdElRoIContainer > & jContainer ) const
private

Definition at line 1128 of file jFEXSysSim.cxx.

1128 {
1129
1130 xAOD::jFexFwdElRoI* my_EDM = new xAOD::jFexFwdElRoI();
1131 jContainer->push_back( my_EDM );
1132
1133 my_EDM->initialize(jFexNum, fpgaNumber, tobWord ,istob , resolution, eta, phi);
1134
1135 ATH_MSG_DEBUG(" setting Forward Elec jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1136
1137 return StatusCode::SUCCESS;
1138 }
xAOD::jFexFwdElRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition jFexFwdElRoI_v1.cxx:151
xAOD::jFexFwdElRoI_v1::phi
float phi() const
xAOD::jFexFwdElRoI_v1::eta
float eta() const
xAOD::jFexFwdElRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi)
initialze the EDM
Definition jFexFwdElRoI_v1.cxx:30
xAOD::jFexFwdElRoI_v1::jFexNumber
uint8_t jFexNumber() const
Additional info (initialization).
xAOD::jFexFwdElRoI
jFexFwdElRoI_v1 jFexFwdElRoI
Define the latest version of the jFexFwdElJetRoI class.
Definition jFexFwdElRoI.h:13

◆ fillLRJetEDM()

StatusCode LVL1::jFEXSysSim::fillLRJetEDM ( const std::unique_ptr< jFEXTOB > & internalTob,
char istob,
float_t eta,
float_t phi,
SG::WriteHandle< xAOD::jFexLRJetRoIContainer > & jContainer ) const
private

Definition at line 1140 of file jFEXSysSim.cxx.

1140 {
1141
1142 xAOD::jFexLRJetRoI* my_EDM = new xAOD::jFexLRJetRoI();
1143 jContainer->push_back( my_EDM );
1144
1145 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), istob, internalTob->getRes(), eta, phi);
1146
1147 ATH_MSG_DEBUG(" setting LRJet jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1148
1149 return StatusCode::SUCCESS;
1150 }
xAOD::jFexLRJetRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition jFexLRJetRoI_v1.cxx:139
xAOD::jFexLRJetRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi)
In future initialze the EDM.
Definition jFexLRJetRoI_v1.cxx:40
xAOD::jFexLRJetRoI_v1::eta
float eta() const
xAOD::jFexLRJetRoI_v1::jFexNumber
uint8_t jFexNumber() const
xAOD::jFexLRJetRoI_v1::phi
float phi() const
xAOD::jFexLRJetRoI
jFexLRJetRoI_v1 jFexLRJetRoI
Define the latest version of the jFexLRJetRoI class.
Definition jFexLRJetRoI.h:13

◆ fillMetEDM()

StatusCode LVL1::jFEXSysSim::fillMetEDM ( const std::unique_ptr< jFEXTOB > & internalTob,
SG::WriteHandle< xAOD::jFexMETRoIContainer > & jContainer ) const
private

Definition at line 1164 of file jFEXSysSim.cxx.

1164 {
1165
1166 xAOD::jFexMETRoI* my_EDM = new xAOD::jFexMETRoI();
1167 jContainer->push_back( my_EDM );
1168
1169 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), internalTob->getRes());
1170
1171 ATH_MSG_DEBUG(" setting MET jFEX Number: " << +my_EDM->jFexNumber() << " Et_x: " << my_EDM->tobEx() << " Et_y: " << my_EDM->tobEy() << " sat: " << my_EDM->tobSat()<< " res: " << my_EDM->tobRes() );
1172
1173 return StatusCode::SUCCESS;
1174 }
xAOD::jFexMETRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, int resolution)
In future initialze the xTOB as well, word1.
Definition jFexMETRoI_v1.cxx:20
xAOD::jFexMETRoI_v1::tobEx
int tobEx() const
xAOD::jFexMETRoI_v1::jFexNumber
uint8_t jFexNumber() const
xAOD::jFexMETRoI_v1::tobRes
uint8_t tobRes() const
xAOD::jFexMETRoI_v1::tobEy
int tobEy() const
xAOD::jFexMETRoI_v1::tobSat
uint8_t tobSat() const
xAOD::jFexMETRoI
jFexMETRoI_v1 jFexMETRoI
Define the latest version of the jFexMETRoI class.
Definition jFexMETRoI.h:13

◆ fillSRJetEDM()

StatusCode LVL1::jFEXSysSim::fillSRJetEDM ( const std::unique_ptr< jFEXTOB > & internalTob,
char istob,
float_t eta,
float_t phi,
SG::WriteHandle< xAOD::jFexSRJetRoIContainer > & jContainer ) const
private

Definition at line 1103 of file jFEXSysSim.cxx.

1103 {
1104
1105 xAOD::jFexSRJetRoI* my_EDM = new xAOD::jFexSRJetRoI();
1106 jContainer->push_back( my_EDM );
1107
1108 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), istob, internalTob->getRes(), eta, phi);
1109
1110 ATH_MSG_DEBUG(" setting SRJet jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1111
1112 return StatusCode::SUCCESS;
1113 }
xAOD::jFexSRJetRoI_v1::phi
float phi() const
xAOD::jFexSRJetRoI_v1::jFexNumber
uint8_t jFexNumber() const
xAOD::jFexSRJetRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi)
In future initialze the EDM.
Definition jFexSRJetRoI_v1.cxx:38
xAOD::jFexSRJetRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition jFexSRJetRoI_v1.cxx:138
xAOD::jFexSRJetRoI_v1::eta
float eta() const
xAOD::jFexSRJetRoI
jFexSRJetRoI_v1 jFexSRJetRoI
Define the latest version of the jFexSRJetRoI class.
Definition jFexSRJetRoI.h:14

◆ fillSumEtEDM()

StatusCode LVL1::jFEXSysSim::fillSumEtEDM ( const std::unique_ptr< jFEXTOB > & internalTob,
SG::WriteHandle< xAOD::jFexSumETRoIContainer > & jContainer ) const
private

Definition at line 1152 of file jFEXSysSim.cxx.

1152 {
1153
1154 xAOD::jFexSumETRoI* my_EDM = new xAOD::jFexSumETRoI();
1155 jContainer->push_back( my_EDM );
1156
1157 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), internalTob->getRes());
1158
1159 ATH_MSG_DEBUG(" setting SumET jFEX Number: " << +my_EDM->jFexNumber() << " Et_up: " << my_EDM->tobEt_upper() << " Et_down: " << my_EDM->tobEt_lower() << " sat_up: " << my_EDM->tobSat_upper()<< " sat_low: " << my_EDM->tobSat_lower());
1160
1161 return StatusCode::SUCCESS;
1162 }
xAOD::jFexSumETRoI_v1::tobSat_upper
uint8_t tobSat_upper() const
xAOD::jFexSumETRoI_v1::tobSat_lower
uint8_t tobSat_lower() const
xAOD::jFexSumETRoI_v1::tobEt_lower
uint16_t tobEt_lower() const
xAOD::jFexSumETRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, int resolution)
In future initialze the xTOB as well, word1.
Definition jFexSumETRoI_v1.cxx:20
xAOD::jFexSumETRoI_v1::tobEt_upper
uint16_t tobEt_upper() const
xAOD::jFexSumETRoI_v1::jFexNumber
uint8_t jFexNumber() const
xAOD::jFexSumETRoI
jFexSumETRoI_v1 jFexSumETRoI
Define the latest version of the jFexSumETJetRoI class.
Definition jFexSumETRoI.h:13

◆ fillTauEDM()

StatusCode LVL1::jFEXSysSim::fillTauEDM ( const std::unique_ptr< jFEXTOB > & internalTob,
char istob,
float_t eta,
float_t phi,
SG::WriteHandle< xAOD::jFexTauRoIContainer > & jContainer ) const
private

Definition at line 1116 of file jFEXSysSim.cxx.

1116 {
1117
1118 xAOD::jFexTauRoI* my_EDM = new xAOD::jFexTauRoI();
1119 jContainer->push_back( my_EDM );
1120
1121 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), istob, internalTob->getRes(), eta, phi);
1122
1123 ATH_MSG_DEBUG(" setting tau jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1124
1125 return StatusCode::SUCCESS;
1126 }
xAOD::jFexTauRoI_v1::phi
float phi() const
xAOD::jFexTauRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi)
In future initialze the EDM.
Definition jFexTauRoI_v1.cxx:21
xAOD::jFexTauRoI_v1::eta
float eta() const
xAOD::jFexTauRoI_v1::jFexNumber
uint8_t jFexNumber() const
xAOD::jFexTauRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition jFexTauRoI_v1.cxx:114
xAOD::jFexTauRoI
jFexTauRoI_v1 jFexTauRoI
Define the latest version of the jFexSRJetRoI class.
Definition jFexTauRoI.h:13

◆ finalize()

StatusCode LVL1::jFEXSysSim::finalize ( )
overridevirtual

standard Athena-Algorithm method

Definition at line 69 of file jFEXSysSim.cxx.

70 {
71 return StatusCode::SUCCESS;
72 }

◆ init()

void LVL1::jFEXSysSim::init ( ) const
overridevirtual

Definition at line 75 of file jFEXSysSim.cxx.

75 {
76
77 }

◆ initialize()

StatusCode LVL1::jFEXSysSim::initialize ( )
overridevirtual

standard Athena-Algorithm method

Definition at line 36 of file jFEXSysSim.cxx.

37 {
38
39 ATH_CHECK(m_jTowerContainerSGKey.initialize());
40
41 ATH_CHECK( m_DBToolKey.initialize() );
42 ATH_CHECK(m_jFEXSimTool.retrieve() );
43
44 // TOBs Key
45 ATH_CHECK(m_TobOutKey_jJ.initialize());
46 ATH_CHECK(m_TobOutKey_jLJ.initialize());
47 ATH_CHECK(m_TobOutKey_jTau.initialize());
48 ATH_CHECK(m_TobOutKey_jEM.initialize());
49 ATH_CHECK(m_TobOutKey_jTE.initialize());
50 ATH_CHECK(m_TobOutKey_jXE.initialize());
51
52 // xTOBs Key
53 ATH_CHECK(m_xTobOutKey_jJ.initialize());
54 ATH_CHECK(m_xTobOutKey_jLJ.initialize());
55 ATH_CHECK(m_xTobOutKey_jTau.initialize());
56 ATH_CHECK(m_xTobOutKey_jEM.initialize());
57
58 // Decorations
59 ATH_CHECK(m_TobDecorKey_jJ_seedET.initialize());
60 ATH_CHECK(m_xTobDecorKey_jJ_seedET.initialize());
61
62 ATH_CHECK(m_l1MenuKey.initialize());
63
64 return StatusCode::SUCCESS;
65 }

Member Data Documentation

◆ m_allfwdElTobs

std::unordered_map<uint8_t, std::vector<std::vector<std::vector<uint32_t> > > > LVL1::jFEXSysSim::m_allfwdElTobs
private

Definition at line 101 of file jFEXSysSim.h.

◆ m_allLargeRJetTobs

std::unordered_map<uint8_t, std::vector<std::vector<std::unique_ptr<jFEXTOB> > > > LVL1::jFEXSysSim::m_allLargeRJetTobs
private

Definition at line 105 of file jFEXSysSim.h.

◆ m_allMetTobs

std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB> > > LVL1::jFEXSysSim::m_allMetTobs
private

Definition at line 107 of file jFEXSysSim.h.

◆ m_allSmallRJetTobs

std::unordered_map<uint8_t, std::vector<std::vector<std::unique_ptr<jFEXTOB> > > > LVL1::jFEXSysSim::m_allSmallRJetTobs
private

Definition at line 104 of file jFEXSysSim.h.

◆ m_allsumEtTobs

std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB> > > LVL1::jFEXSysSim::m_allsumEtTobs
private

Definition at line 106 of file jFEXSysSim.h.

◆ m_alltauTobs

std::unordered_map<uint8_t, std::vector<std::vector<std::unique_ptr<jFEXTOB> > > > LVL1::jFEXSysSim::m_alltauTobs
private

Definition at line 103 of file jFEXSysSim.h.

◆ m_DBToolKey

SG::ReadCondHandleKey<jFEXDBCondData> LVL1::jFEXSysSim::m_DBToolKey {this, "DBToolKey", "jFEXDBParams", "DB tool key"}
private

Definition at line 72 of file jFEXSysSim.h.

72{this, "DBToolKey", "jFEXDBParams", "DB tool key"};

◆ m_jFEXCollection

std::vector<jFEXSim*> LVL1::jFEXSysSim::m_jFEXCollection
private

Internal data.

Definition at line 70 of file jFEXSysSim.h.

◆ m_jFEXSimTool

ToolHandle<IjFEXSim> LVL1::jFEXSysSim::m_jFEXSimTool {this, "jFEXSimTool", "LVL1::jFEXSim", "Tool that creates the jFEX Simulation"}
private

Definition at line 74 of file jFEXSysSim.h.

74{this, "jFEXSimTool", "LVL1::jFEXSim", "Tool that creates the jFEX Simulation"};

◆ m_jTowerContainerSGKey

SG::ReadHandleKey<LVL1::jTowerContainer> LVL1::jFEXSysSim::m_jTowerContainerSGKey {this, "MyETowers", "jTowerContainer", "Input container for jTowers"}
private

Definition at line 76 of file jFEXSysSim.h.

76{this, "MyETowers", "jTowerContainer", "Input container for jTowers"};

◆ m_jTowersColl

std::unordered_map<int,jTower> LVL1::jFEXSysSim::m_jTowersColl
private

Definition at line 99 of file jFEXSysSim.h.

◆ m_l1MenuKey

SG::ReadHandleKey<TrigConf::L1Menu> LVL1::jFEXSysSim::m_l1MenuKey {this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu","Name of the L1Menu object to read configuration from"}
private

Definition at line 78 of file jFEXSysSim.h.

78{this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu","Name of the L1Menu object to read configuration from"};

◆ m_TobDecorKey_jJ_seedET

SG::WriteDecorHandleKey<xAOD::jFexSRJetRoIContainer> LVL1::jFEXSysSim::m_TobDecorKey_jJ_seedET { this, "Key_tobDecor_jJ_seedET" , m_TobOutKey_jJ , "seedETMeV" , "jJet seed ET value in MeV" }
private

Definition at line 95 of file jFEXSysSim.h.

95{ this, "Key_tobDecor_jJ_seedET" , m_TobOutKey_jJ , "seedETMeV" , "jJet seed ET value in MeV" };

◆ m_TobOutKey_jEM

SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer> LVL1::jFEXSysSim::m_TobOutKey_jEM {this,"Key_jFexFwdElOutputContainer","L1_jFexFwdElRoI","Output jFexEDM fwdEl container"}
private

Definition at line 84 of file jFEXSysSim.h.

84{this,"Key_jFexFwdElOutputContainer","L1_jFexFwdElRoI","Output jFexEDM fwdEl container"};

◆ m_TobOutKey_jJ

SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer> LVL1::jFEXSysSim::m_TobOutKey_jJ {this,"Key_jFexSRJetOutputContainer","L1_jFexSRJetRoI","Output jFexEDM jets container"}
private

Definition at line 81 of file jFEXSysSim.h.

81{this,"Key_jFexSRJetOutputContainer","L1_jFexSRJetRoI","Output jFexEDM jets container"};

◆ m_TobOutKey_jLJ

SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer> LVL1::jFEXSysSim::m_TobOutKey_jLJ {this,"Key_jFexLRJetOutputContainer","L1_jFexLRJetRoI","Output jFexEDM Ljets container"}
private

Definition at line 82 of file jFEXSysSim.h.

82{this,"Key_jFexLRJetOutputContainer","L1_jFexLRJetRoI","Output jFexEDM Ljets container"};

◆ m_TobOutKey_jTau

SG::WriteHandleKey< xAOD::jFexTauRoIContainer> LVL1::jFEXSysSim::m_TobOutKey_jTau {this,"Key_jFexTauOutputContainer" ,"L1_jFexTauRoI" ,"Output jFexEDM tau container"}
private

Definition at line 83 of file jFEXSysSim.h.

83{this,"Key_jFexTauOutputContainer" ,"L1_jFexTauRoI" ,"Output jFexEDM tau container"};

◆ m_TobOutKey_jTE

SG::WriteHandleKey< xAOD::jFexSumETRoIContainer> LVL1::jFEXSysSim::m_TobOutKey_jTE {this,"Key_jFexSumETOutputContainer","L1_jFexSumETRoI","Output jFexEDM SumET container"}
private

Definition at line 85 of file jFEXSysSim.h.

85{this,"Key_jFexSumETOutputContainer","L1_jFexSumETRoI","Output jFexEDM SumET container"};

◆ m_TobOutKey_jXE

SG::WriteHandleKey< xAOD::jFexMETRoIContainer> LVL1::jFEXSysSim::m_TobOutKey_jXE {this,"Key_jFexMETOutputContainer" ,"L1_jFexMETRoI" ,"Output jFexEDM Met container"}
private

Definition at line 86 of file jFEXSysSim.h.

86{this,"Key_jFexMETOutputContainer" ,"L1_jFexMETRoI" ,"Output jFexEDM Met container"};

◆ m_xTobDecorKey_jJ_seedET

SG::WriteDecorHandleKey<xAOD::jFexSRJetRoIContainer> LVL1::jFEXSysSim::m_xTobDecorKey_jJ_seedET { this, "Key_xTobDecor_jJ_seedET" , m_xTobOutKey_jJ , "seedETMeV" , "jJet seed ET value in MeV" }
private

Definition at line 96 of file jFEXSysSim.h.

96{ this, "Key_xTobDecor_jJ_seedET" , m_xTobOutKey_jJ , "seedETMeV" , "jJet seed ET value in MeV" };

◆ m_xTobOutKey_jEM

SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer> LVL1::jFEXSysSim::m_xTobOutKey_jEM {this,"Key_xTobOutKey_jEM" ,"L1_jFexFwdElxRoI","Output jFexEDM xTOBs fwdEl container"}
private

Definition at line 92 of file jFEXSysSim.h.

92{this,"Key_xTobOutKey_jEM" ,"L1_jFexFwdElxRoI","Output jFexEDM xTOBs fwdEl container"};

◆ m_xTobOutKey_jJ

SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer> LVL1::jFEXSysSim::m_xTobOutKey_jJ {this,"Key_xTobOutKey_jJ" ,"L1_jFexSRJetxRoI","Output jFexEDM xTOBs jets container"}
private

Definition at line 89 of file jFEXSysSim.h.

89{this,"Key_xTobOutKey_jJ" ,"L1_jFexSRJetxRoI","Output jFexEDM xTOBs jets container"};

◆ m_xTobOutKey_jLJ

SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer> LVL1::jFEXSysSim::m_xTobOutKey_jLJ {this,"Key_xTobOutKey_jLJ" ,"L1_jFexLRJetxRoI","Output jFexEDM xTOBs Ljets container"}
private

Definition at line 90 of file jFEXSysSim.h.

90{this,"Key_xTobOutKey_jLJ" ,"L1_jFexLRJetxRoI","Output jFexEDM xTOBs Ljets container"};

◆ m_xTobOutKey_jTau

SG::WriteHandleKey< xAOD::jFexTauRoIContainer> LVL1::jFEXSysSim::m_xTobOutKey_jTau {this,"Key_xTobOutKey_jTau" ,"L1_jFexTauxRoI" ,"Output jFexEDM xTOBs tau container"}
private

Definition at line 91 of file jFEXSysSim.h.

91{this,"Key_xTobOutKey_jTau" ,"L1_jFexTauxRoI" ,"Output jFexEDM xTOBs tau container"};
The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.16.1