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