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