ATLAS Offline Software
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 
31 namespace 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
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
xAOD::jFexTauRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexTauRoI_v1.h:23
LVL1::jFEXSysSim::m_TobOutKey_jJ
SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer > m_TobOutKey_jJ
Definition: jFEXSysSim.h:85
xAOD::jFexSRJetRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexSRJetRoI_v1.h:23
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::fillMetEDM
StatusCode fillMetEDM(const std::unique_ptr< jFEXTOB > &internalTob, SG::WriteHandle< xAOD::jFexMETRoIContainer > &jContainer) const
Definition: jFEXSysSim.cxx:1176
TrigConf::L1ThrExtraInfo::jEM
const L1ThrExtraInfo_jEM & jEM() const
Definition: L1ThrExtraInfo.cxx:128
xAOD::jFexTauRoI_v1::eta
float eta() const
xAOD::jFexTauRoI_v1::jFexNumber
uint8_t jFexNumber() const
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
LVL1::jTower::iEta
int iEta() const
Get coordinates of tower.
Definition: jTower.cxx:166
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:558
xAOD::jFexLRJetRoI_v1::eta
float eta() const
LVL1::FEXAlgoSpaceDefs::jFEX_thin_algoSpace_width
constexpr static int jFEX_thin_algoSpace_width
Definition: FEXAlgoSpaceDefs.h:28
xAOD::jFexLRJetRoI
jFexLRJetRoI_v1 jFexLRJetRoI
Define the latest version of the jFexLRJetRoI class
Definition: jFexLRJetRoI.h:13
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
SG::ReadHandle< LVL1::jTowerContainer >
jFEXSim.h
jFexSumETRoIAuxContainer.h
xAOD::jFexFwdElRoI_v1::eta
float eta() const
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_jFEXSimTool
ToolHandle< IjFEXSim > m_jFEXSimTool
Definition: jFEXSysSim.h:78
TrigConf::L1Menu::thrExtraInfo
const L1ThrExtraInfo & thrExtraInfo() const
Access to extra info for threshold types.
Definition: L1Menu.cxx:307
LVL1::jFEXSysSim::m_alltauTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_alltauTobs
Definition: jFEXSysSim.h:107
xAOD::jFexFwdElRoI_v1::jFexNumber
uint8_t jFexNumber() const
Additional info (initialization)
skel.it
it
Definition: skel.GENtoEVGEN.py:407
xAOD::jFexFwdElRoI_v1::phi
float phi() const
jFEXSysSim.h
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:210
xAOD::jFexLRJetRoI_v1::jFexNumber
uint8_t jFexNumber() const
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
LVL1::jTowerContainer::findTower
const LVL1::jTower * findTower(int towerID) const
fast find method given identifier.
Definition: jTowerContainer.cxx:29
xAOD::jFexLRJetRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition: jFexLRJetRoI_v1.cxx:139
jFexLRJetRoIAuxContainer.h
xAOD::jFexSRJetRoI_v1::eta
float eta() const
xAOD::jFexSRJetRoI_v1::phi
float phi() const
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_height
constexpr static int jFEX_algoSpace_height
Definition: FEXAlgoSpaceDefs.h:29
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
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::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
LVL1::jFEXSysSim::m_l1MenuKey
SG::ReadHandleKey< TrigConf::L1Menu > m_l1MenuKey
Definition: jFEXSysSim.h:82
Dedxcorrection::resolution
double resolution[nGasTypes][nParametersResolution]
Definition: TRT_ToT_Corrections.h:46
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
jFexTauRoIAuxContainer.h
LVL1::jFEXSysSim::m_xTobDecorKey_jJ_seedET
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_xTobDecorKey_jJ_seedET
Definition: jFEXSysSim.h:100
xAOD::jFexMETRoI_v1::jFexNumber
uint8_t jFexNumber() const
LVL1::jFEXSysSim::jFEXSysSim
jFEXSysSim(const std::string &type, const std::string &name, const IInterface *parent)
Constructors.
Definition: jFEXSysSim.cxx:36
xAOD::jFexMETRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexMETRoI_v1.h:22
LVL1::jFEXSysSim::m_TobOutKey_jEM
SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer > m_TobOutKey_jEM
Definition: jFEXSysSim.h:88
LVL1::jFEXSysSim::calcTowerID
virtual int calcTowerID(int eta, int phi, int mod) const override
Definition: jFEXSysSim.cxx:102
LVL1::jFEXSysSim::m_jTowersColl
std::unordered_map< int, jTower > m_jTowersColl
Definition: jFEXSysSim.h:103
xAOD::jFexMETRoI_v1::tobSat
uint8_t tobSat() 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
WriteHandle.h
Handle class for recording to StoreGate.
beamspotnt.cols
list cols
Definition: bin/beamspotnt.py:1113
LVL1::jFEXSysSim::m_jTowerContainerSGKey
SG::ReadHandleKey< LVL1::jTowerContainer > m_jTowerContainerSGKey
Definition: jFEXSysSim.h:80
LVL1::jFEXSysSim::execute
virtual StatusCode execute(jFEXOutputCollection *inputOutputCollection) override
Definition: jFEXSysSim.cxx:107
xAOD::jFexLRJetRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexLRJetRoI_v1.h:23
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
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
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
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
lumiFormat.i
int i
Definition: lumiFormat.py:85
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
xAOD::jFexMETRoI_v1::tobEy
int tobEy() const
LVL1::jFEXSysSim::m_xTobOutKey_jEM
SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer > m_xTobOutKey_jEM
Definition: jFEXSysSim.h:96
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::jFexMETRoI_v1::tobRes
uint8_t tobRes() const
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:100
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::FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width
constexpr static int jFEX_wide_algoSpace_width
Definition: FEXAlgoSpaceDefs.h:27
xAOD::jFexMETRoI_v1::tobEx
int tobEx() const
test_pyathena.parent
parent
Definition: test_pyathena.py:15
LVL1::jFEXSysSim::initialize
virtual StatusCode initialize() override
standard Athena-Algorithm method
Definition: jFEXSysSim.cxx:51
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::jFexSRJetRoI
jFexSRJetRoI_v1 jFexSRJetRoI
Define the latest version of the jFexSRJetRoI class
Definition: jFexSRJetRoI.h:14
LVL1::jTower::iPhi
int iPhi() const
Return global phi index.
Definition: jTower.cxx:171
xAOD::jFexTauRoI_v1::phi
float phi() const
LVL1::jFEXSysSim::m_allMetTobs
std::unordered_map< uint8_t, std::vector< std::unique_ptr< jFEXTOB > > > m_allMetTobs
Definition: jFEXSysSim.h:111
beamspotnt.rows
list rows
Definition: bin/beamspotnt.py:1111
LVL1::jFEXOutputCollection
Definition: jFEXOutputCollection.h:23
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
jFexMETRoIAuxContainer.h
FEXAlgoSpaceDefs.h
xAOD::jFexSumETRoI_v1::tobSat_lower
uint8_t tobSat_lower() const
DataVector::back
const T * back() const
Access the last element in the collection as an rvalue.
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
TrigConf::name
Definition: HLTChainList.h:35
LVL1::jFEXSysSim::m_xTobOutKey_jJ
SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer > m_xTobOutKey_jJ
Definition: jFEXSysSim.h:93
LVL1::jFEXSysSim::m_TobOutKey_jTE
SG::WriteHandleKey< xAOD::jFexSumETRoIContainer > m_TobOutKey_jTE
Definition: jFEXSysSim.h:89
jTowerContainer.h
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::m_xTobOutKey_jLJ
SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer > m_xTobOutKey_jLJ
Definition: jFEXSysSim.h:94
LVL1::jFEXSysSim::init
virtual void init() const override
Definition: jFEXSysSim.cxx:90
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
TrigConf::L1ThrExtraInfoBase::resolutionMeV
unsigned int resolutionMeV() const
Definition: L1ThresholdBase.h:101
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
xAOD::jFexSumETRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexSumETRoI_v1.h:22
LVL1::jFEXSysSim::fillSumEtEDM
StatusCode fillSumEtEDM(const std::unique_ptr< jFEXTOB > &internalTob, SG::WriteHandle< xAOD::jFexSumETRoIContainer > &jContainer) const
Definition: jFEXSysSim.cxx:1164
xAOD::jFexFwdElRoI
jFexFwdElRoI_v1 jFexFwdElRoI
Define the latest version of the jFexFwdElJetRoI class
Definition: jFexFwdElRoI.h:13
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
xAOD::jFexFwdElRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition: jFexFwdElRoI_v1.cxx:151
LVL1::jFEXSysSim::m_jFEXCollection
std::vector< jFEXSim * > m_jFEXCollection
Internal data.
Definition: jFEXSysSim.h:74
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::jFexSumETRoI_v1::jFexNumber
uint8_t jFexNumber() const
jFexFwdElRoIAuxContainer.h
xAOD::jFexSumETRoI_v1::tobEt_upper
uint16_t tobEt_upper() const
LVL1::jFEXSysSim::m_TobOutKey_jXE
SG::WriteHandleKey< xAOD::jFexMETRoIContainer > m_TobOutKey_jXE
Definition: jFEXSysSim.h:90
LVL1::jFEXSysSim::m_TobOutKey_jLJ
SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer > m_TobOutKey_jLJ
Definition: jFEXSysSim.h:86
LVL1::jFEXSysSim::cleanup
virtual void cleanup() override
Definition: jFEXSysSim.cxx:94
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
LVL1::jFEXSysSim::m_TobDecorKey_jJ_seedET
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_TobDecorKey_jJ_seedET
Definition: jFEXSysSim.h:99
LVL1::jFEXSysSim::m_allfwdElTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::vector< uint32_t > > > > m_allfwdElTobs
Definition: jFEXSysSim.h:105
xAOD::jFexLRJetRoI_v1::phi
float phi() const
xAOD::jFexMETRoI
jFexMETRoI_v1 jFexMETRoI
Define the latest version of the jFexMETRoI class
Definition: jFexMETRoI.h:13
DEBUG
#define DEBUG
Definition: page_access.h:11
LVL1::jFEXSysSim::finalize
virtual StatusCode finalize() override
standard Athena-Algorithm method
Definition: jFEXSysSim.cxx:84
LVL1::jFEXSysSim::m_DBToolKey
SG::ReadCondHandleKey< jFEXDBCondData > m_DBToolKey
Definition: jFEXSysSim.h:76
LVL1::jTower
The jTower class is an interface object for jFEX trigger algorithms The purposes are twofold:
Definition: jTower.h:36
xAOD::jFexTauRoI
jFexTauRoI_v1 jFexTauRoI
Define the latest version of the jFexSRJetRoI class
Definition: jFexTauRoI.h:13
xAOD::jFexSumETRoI
jFexSumETRoI_v1 jFexSumETRoI
Define the latest version of the jFexSumETJetRoI class
Definition: jFexSumETRoI.h:13
xAOD::jFexSRJetRoI_v1::jFexNumber
uint8_t jFexNumber() const
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
ReadHandle.h
Handle class for reading from StoreGate.
AthAlgTool
Definition: AthAlgTool.h:26
LVL1::jFEXSysSim::m_xTobOutKey_jTau
SG::WriteHandleKey< xAOD::jFexTauRoIContainer > m_xTobOutKey_jTau
Definition: jFEXSysSim.h:95
xAOD::jFexSumETRoI_v1::tobSat_upper
uint8_t tobSat_upper() const
LVL1::jFEXSysSim::m_allsumEtTobs
std::unordered_map< uint8_t, std::vector< std::unique_ptr< jFEXTOB > > > m_allsumEtTobs
Definition: jFEXSysSim.h:110
value_type
Definition: EDM_MasterSearch.h:11
xAOD::jFexSumETRoI_v1::tobEt_lower
uint16_t tobEt_lower() const
jTower.h
LVL1::jFEXSysSim::m_TobOutKey_jTau
SG::WriteHandleKey< xAOD::jFexTauRoIContainer > m_TobOutKey_jTau
Definition: jFEXSysSim.h:87
xAOD::jFexFwdElRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexFwdElRoI_v1.h:23
jFexSRJetRoIAuxContainer.h
xAOD::jFexSRJetRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition: jFexSRJetRoI_v1.cxx:138
Generated on Tue Sep 2 2025 21:14:18 for ATLAS Offline Software by   doxygen 1.8.18