ATLAS Offline Software
eFEXSysSim.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 // eFEXSysSim - description
7 // -------------------
8 // begin : 12 07 2019
9 // email : jacob.julian.kempster@cern.ch alison.elliot@cern.ch
10 // ***************************************************************************/
11 
12 #include "eFEXSysSim.h"
13 #include "eFEXSim.h"
14 #include "L1CaloFEXSim/eTower.h"
15 #include "eFEXTOBxTOBMatching.h"
16 #include "L1CaloFEXSim/eTowerContainer.h"
17 
18 #include "StoreGate/WriteHandle.h"
19 #include "StoreGate/ReadHandle.h"
20 
21 #include "TrigConfData/L1Menu.h"
22 
23 #include "xAODTrigger/eFexEMRoI.h"
24 #include "xAODTrigger/eFexEMRoIContainer.h"
25 #include "xAODTrigger/eFexEMRoIAuxContainer.h"
26 
27 #include "xAODTrigger/eFexTauRoI.h"
28 #include "xAODTrigger/eFexTauRoIContainer.h"
29 #include "xAODTrigger/eFexTauRoIAuxContainer.h"
30 
31 
32 namespace LVL1 {
33 
34 
35  // default constructor for persistency
36 
37  eFEXSysSim::eFEXSysSim(const std::string& type,const std::string& name,const IInterface* parent):
38  AthAlgTool(type,name,parent)
39  {
40  declareInterface<eFEXSysSim>(this);
41 
42  }
43 
44 
46  //eFEXSysSim::~eFEXSysSim()
47  //{
48  //}
49 
50  //---------------- Initialisation -------------------------------------------------
51 
52  StatusCode eFEXSysSim::initialize()
53  {
54 
55  ATH_CHECK( m_eTowerContainerSGKey.initialize() );
56 
57  ATH_CHECK( m_eFEXSimTool.retrieve() );
58 
59  ATH_CHECK( m_eFexOutKey.initialize() );
60  ATH_CHECK( m_eFexEMxTOBOutKey.initialize() );
61 
62  ATH_CHECK( m_eFexTauActiveOutKey.initialize() );
63  ATH_CHECK( m_eFexTauActivexTOBOutKey.initialize() );
64  ATH_CHECK( m_eFexTauAltOutKey.initialize(SG::AllowEmpty) );
65  ATH_CHECK( m_eFexTauAltxTOBOutKey.initialize(SG::AllowEmpty) );
66 
67  ATH_CHECK( m_eFEXFPGATowerIdProviderTool.retrieve() );
68 
69  ATH_CHECK(m_l1MenuKey.initialize());
70 
71  return StatusCode::SUCCESS;
72  }
73 
74  int eFEXSysSim::calcTowerID(int eta, int phi, int mod) const {
75 
76  return ((64*eta) + phi + mod);
77  }
78 
79  StatusCode eFEXSysSim::execute(eFEXOutputCollection* inputOutputCollection) {
80 
81  SG::ReadHandle<LVL1::eTowerContainer> this_eTowerContainer(m_eTowerContainerSGKey/*,ctx*/);
82  if(!this_eTowerContainer.isValid()){
83  ATH_MSG_FATAL("Could not retrieve eTowerContainer " << m_eTowerContainerSGKey.key());
84  return StatusCode::FAILURE;
85  }
86 
87  // remove TOBs of the previous events from the map
88  std::map<int, std::vector<std::unique_ptr<eFEXegTOB>> > allEmTobObjects;
89  std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> > allTauHeuristicTobObjects;
90  std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> > allTauBDTTobObjects;
91 
92  // do mapping with preloaded csv file if it is available
93  if (m_eFEXFPGATowerIdProviderTool->ifhaveinputfile()) {
94  int tmp_eTowersIDs_subset_eFEX[10][18];
95  for (int i_efex{ 0 }; i_efex < 24; i_efex++) {
96  ATH_CHECK(m_eFEXFPGATowerIdProviderTool->getRankedTowerIDineFEX(i_efex, tmp_eTowersIDs_subset_eFEX));
97  m_eFEXSimTool->init(i_efex);
98  ATH_CHECK(m_eFEXSimTool->NewExecute(tmp_eTowersIDs_subset_eFEX, inputOutputCollection));
99  // Get TOBs from this eFEX
100  allEmTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXegTOB>> >::value_type(i_efex, m_eFEXSimTool->getEmTOBs() ));
101  allTauHeuristicTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(i_efex, m_eFEXSimTool->getTauHeuristicTOBs() ));
102  allTauBDTTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(i_efex, m_eFEXSimTool->getTauBDTTOBs() ));
103  m_eFEXSimTool->reset();
104  }
105  } else {
106  // We need to split the towers into 3 blocks in eta and 8 blocks in phi.
107 
108  // boundaries in eta: -2.5, -0.8, 0.8, 2.5
109  // REAL boundaries in eta (overlaps must occur for sliding window algorithms!): -2.5, -0.7, -0.9, 0.9, 0.7, 2.5
110  // Written explicitly:
111  // -2.5 -> -0.7
112  // -0.9 -> 0.9
113  // 0.7 -> 2.5
114 
115  // boundaries in phi: 0.2, 1.0, 1.8, 2.6, 3.4, 4.2, 5.0, 5.8
116  // Written explicitly with REAL boundaries in phi (overlaps must occur for sliding window algorithms!)
117  // 0.1 -> 1.1
118  // 0.9 -> 1.9
119  // 1.7 -> 2.7
120  // 2.5 -> 3.5
121  // 3.3 -> 4.3
122  // 4.1 -> 5.1
123  // 4.9 -> 5.9
124  // 5.7 -> 0.3
125 
126  // C-SIDE NEGATIVE EFEXs
127  // DO THE LEFT-MOST (NEGATIVE ETA) EFEXs FIRST
128  int fexcounter = 0;
129  // Example values for eFEX 0
130  //id_modifier + phi + (64 * eta)
131  int emecEta = 24; int emecPhi = 1; int emecMod = 500000;
132  int initialEMEC = calcTowerID(emecEta,emecPhi,emecMod); //501537;
133  int transEta = 14; int transPhi = 1; int transMod = 300000;
134  int initialTRANS = calcTowerID(transEta,transPhi,transMod); //300897;
135  int embEta = 13; int embPhi = 1; int embMod = 100000;
136  int initialEMB = calcTowerID(embEta,embPhi,embMod); //100833;
137  int eFEXa = 0;
138 
139  for (int thisEFEX=eFEXa; thisEFEX<=21; thisEFEX+=3){
140 
141  if(fexcounter > 0){ initialEMEC += 8; initialTRANS += 8; initialEMB += 8; } // TODO // SOMEHOW REMOVE HARD-CODING?
142 
143  // decide which subset of towers (and therefore supercells) should go to the eFEX
144  std::map<int,eTower> tmp_eTowersColl_subset;
145 
146  // let's try doing this with an array initially just containing tower IDs.
147  int tmp_eTowersIDs_subset [10][18];
148 
149  int rows = sizeof tmp_eTowersIDs_subset / sizeof tmp_eTowersIDs_subset[0];
150  int cols = sizeof tmp_eTowersIDs_subset[0] / sizeof tmp_eTowersIDs_subset[0][0];
151 
152  // set the EMEC part
153  for(int thisCol=0; thisCol<10; thisCol++){
154  for(int thisRow=0; thisRow<rows; thisRow++){
155 
156  int towerid = initialEMEC - (thisCol * 64) + thisRow;
157 
158  if( (thisEFEX == 21) && (thisRow >= 7)){ towerid -= 64; };
159 
160  tmp_eTowersIDs_subset[thisRow][thisCol] = towerid;
161  tmp_eTowersColl_subset.insert( std::map<int, eTower>::value_type(towerid, *(this_eTowerContainer->findTower(towerid))));
162 
163  }
164  }
165 
166  // set the TRANS part
167  for(int thisRow = 0; thisRow < rows; thisRow++){
168 
169  int towerid = initialTRANS + thisRow;
170 
171  if( (thisEFEX == 21) && (thisRow >= 7)){ towerid -= 64; };
172 
173  tmp_eTowersIDs_subset[thisRow][10] = towerid;
174  tmp_eTowersColl_subset.insert( std::map<int, eTower>::value_type(towerid, *(this_eTowerContainer->findTower(towerid))));
175 
176  }
177 
178  // set the EMB part
179  for(int thisCol = 11; thisCol < cols; thisCol++){
180  for(int thisRow=0; thisRow<rows; thisRow++){
181 
182  int towerid = initialEMB - ( (thisCol-11) * 64) + thisRow;
183 
184  if( (thisEFEX == 21) && (thisRow >= 7)){ towerid -= 64; };
185 
186  tmp_eTowersIDs_subset[thisRow][thisCol] = towerid;
187  tmp_eTowersColl_subset.insert( std::map<int, eTower>::value_type(towerid, *(this_eTowerContainer->findTower(towerid))));
188 
189  }
190  }
191 
192 
193  if(false){
194  ATH_MSG_DEBUG("CONTENTS OF eFEX " << thisEFEX << " :");
195  for (int thisRow=rows-1; thisRow>=0; thisRow--){
196  for (int thisCol=0; thisCol<cols; thisCol++){
197  int tmptowerid = tmp_eTowersIDs_subset[thisRow][thisCol];
198  const float tmptowereta = this_eTowerContainer->findTower(tmptowerid)->eta();
199  const float tmptowerphi = this_eTowerContainer->findTower(tmptowerid)->phi();
200  if(thisCol != cols-1){ ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowerphi << "][" << tmptowereta << "]) "); }
201  else { ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) |"); }
202  }
203  }
204  }
205 
206 
207  m_eFEXSimTool->init(thisEFEX);
208  ATH_CHECK(m_eFEXSimTool->NewExecute(tmp_eTowersIDs_subset, inputOutputCollection));
209  allEmTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXegTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getEmTOBs() ) ));
210  allTauHeuristicTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getTauHeuristicTOBs() ) ));
211  allTauBDTTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getTauBDTTOBs() ) ));
212  m_eFEXSimTool->reset();
213 
214  fexcounter++;
215  }
216 
217  // CENTRAL EFEXs
218  // DO THE CENTRAL EFEXs SECOND
219  fexcounter = 0;
220  int embnegEta = 8; int embnegPhi = 1; int embnegMod = 100000;
221  int initialEMB_neg = calcTowerID(embnegEta,embnegPhi,embnegMod); //100513;
222  int embposEta = 0; int embposPhi = 1; int embposMod = 200000;
223  int initialEMB_pos = calcTowerID(embposEta,embposPhi,embposMod); //200001;
224  int eFEXb = 1;
225 
226  for (int thisEFEX=eFEXb; thisEFEX<=22; thisEFEX+=3){
227 
228  if(fexcounter > 0){ initialEMB_neg += 8; initialEMB_pos += 8; }
229 
230  // decide which subset of towers (and therefore supercells) should go to the eFEX
231  std::map<int,eTower> tmp_eTowersColl_subset;
232 
233  // doing this with an array initially just containing tower IDs.
234  int tmp_eTowersIDs_subset [10][18];
235 
236  int rows = sizeof tmp_eTowersIDs_subset / sizeof tmp_eTowersIDs_subset[0];
237  int cols = sizeof tmp_eTowersIDs_subset[0] / sizeof tmp_eTowersIDs_subset[0][0];
238 
239  // set the EMB part
240  for(int thisCol = 0; thisCol < cols; thisCol++){
241  for(int thisRow=0; thisRow<rows; thisRow++){
242  int towerid = -1;
243 
244  int tmp_initEMB = initialEMB_neg;
245 
246  if(thisCol < 9){
247  towerid = tmp_initEMB - ( (thisCol) * 64) + thisRow;
248  }
249  else{
250  tmp_initEMB = initialEMB_pos;
251  towerid = tmp_initEMB + ( (thisCol-9) * 64) + thisRow;
252  }
253 
254  if( (thisEFEX == 22) && (thisRow >= 7)){ towerid -= 64; };
255 
256  tmp_eTowersIDs_subset[thisRow][thisCol] = towerid;
257 
258  tmp_eTowersColl_subset.insert( std::map<int, eTower>::value_type(towerid, *(this_eTowerContainer->findTower(towerid))));
259  }
260  }
261 
262 
263  if(false){
264  ATH_MSG_DEBUG("CONTENTS OF eFEX " << thisEFEX << " :");
265  for (int thisRow=rows-1; thisRow>=0; thisRow--){
266  for (int thisCol=0; thisCol<cols; thisCol++){
267  int tmptowerid = tmp_eTowersIDs_subset[thisRow][thisCol];
268  const float tmptowereta = this_eTowerContainer->findTower(tmptowerid)->eta();
269  const float tmptowerphi = this_eTowerContainer->findTower(tmptowerid)->phi();
270  if(thisCol != cols-1){ ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) "); }
271  else { ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) |"); }
272  }
273  }
274  }
275 
276  //tool use instead
277  m_eFEXSimTool->init(thisEFEX);
278  ATH_CHECK(m_eFEXSimTool->NewExecute(tmp_eTowersIDs_subset, inputOutputCollection));
279  allEmTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXegTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getEmTOBs() ) ));
280  allTauHeuristicTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getTauHeuristicTOBs() ) ));
281  allTauBDTTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getTauBDTTOBs() ) ));
282  m_eFEXSimTool->reset();
283 
284  fexcounter++;
285  }
286 
287  // POSITIVE EFEXs
288  // LET'S DO THE RIGHT-MOST (POSTITIVE ETA) EFEXs THIRD
289  fexcounter = 0;
290  // Example values for eFEX 0
291  emecEta = 15; emecPhi = 1; emecMod = 600000;
292  initialEMEC = calcTowerID(emecEta,emecPhi,emecMod); //600961;
293  transEta = 14; transPhi = 1; transMod = 400000;
294  initialTRANS = calcTowerID(transEta,transPhi,transMod); //400897;
295  embEta = 7; embPhi = 1; embMod = 200000;
296  initialEMB = calcTowerID(embEta,embPhi,embMod); //200449;
297  int eFEXc = 2;
298 
299  for (int thisEFEX=eFEXc; thisEFEX<=23; thisEFEX+=3){
300 
301  if(fexcounter > 0){ initialEMEC += 8; initialTRANS += 8; initialEMB += 8; }
302 
303  // decide which subset of towers (and therefore supercells) should go to the eFEX
304  std::map<int,eTower> tmp_eTowersColl_subset;
305 
306  // doing this with an array initially just containing tower IDs.
307  int tmp_eTowersIDs_subset [10][18];
308 
309  int rows = sizeof tmp_eTowersIDs_subset / sizeof tmp_eTowersIDs_subset[0];
310  int cols = sizeof tmp_eTowersIDs_subset[0] / sizeof tmp_eTowersIDs_subset[0][0];
311 
312  // set the EMB part
313  for(int thisCol = 0; thisCol < 7; thisCol++){
314  for(int thisRow=0; thisRow<rows; thisRow++){
315  int towerid = initialEMB + ( (thisCol) * 64) + thisRow;
316 
317  if( (thisEFEX == 23) && (thisRow >= 7)){ towerid -= 64; };
318 
319  tmp_eTowersIDs_subset[thisRow][thisCol] = towerid;
320  tmp_eTowersColl_subset.insert( std::map<int, eTower>::value_type(towerid, *(this_eTowerContainer->findTower(towerid))));
321  }
322  }
323  // set the TRANS part
324  for(int thisRow = 0; thisRow < rows; thisRow++){
325  int towerid = initialTRANS + thisRow;
326 
327  if( (thisEFEX == 23) && (thisRow >= 7)){ towerid -= 64; };
328 
329  tmp_eTowersIDs_subset[thisRow][7] = towerid;
330  tmp_eTowersColl_subset.insert( std::map<int, eTower>::value_type(towerid, *(this_eTowerContainer->findTower(towerid))));
331  }
332  // set the EMEC part
333  for(int thisCol=8; thisCol<cols; thisCol++){
334  for(int thisRow=0; thisRow<rows; thisRow++){
335  int towerid = initialEMEC + ( (thisCol-8) * 64) + thisRow;
336 
337  if( (thisEFEX == 23) && (thisRow >= 7)){ towerid -= 64; };
338 
339  tmp_eTowersIDs_subset[thisRow][thisCol] = towerid;
340  tmp_eTowersColl_subset.insert( std::map<int, eTower>::value_type(towerid, *(this_eTowerContainer->findTower(towerid))));
341  }
342  }
343 
344  // Debug printout
345  if(false){
346  ATH_MSG_DEBUG("CONTENTS OF eFEX " << thisEFEX << " :");
347  for (int thisRow=rows-1; thisRow>=0; thisRow--){
348  for (int thisCol=0; thisCol<cols; thisCol++){
349  int tmptowerid = tmp_eTowersIDs_subset[thisRow][thisCol];
350  const float tmptowereta = this_eTowerContainer->findTower(tmptowerid)->eta();
351  const float tmptowerphi = this_eTowerContainer->findTower(tmptowerid)->phi();
352  if(thisCol != cols-1){ ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) "); }
353  else { ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) |"); }
354  }
355  }
356  }
357 
358  //tool use instead
359  m_eFEXSimTool->init(thisEFEX);
360  ATH_CHECK(m_eFEXSimTool->NewExecute(tmp_eTowersIDs_subset, inputOutputCollection));
361  allEmTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXegTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getEmTOBs() ) ));
362  allTauHeuristicTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getTauHeuristicTOBs() ) ));
363  allTauBDTTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getTauBDTTOBs() ) ));
364  m_eFEXSimTool->reset();
365 
366  fexcounter++;
367  }
368 
369  }//close the non-csv loop over eFEXes
370 
371  // EM TOBs and xTOBs
372 
373  // TOB Containers
374  auto eContainer = std::make_unique<xAOD::eFexEMRoIContainer> ();
375  auto eAuxContainer = std::make_unique<xAOD::eFexEMRoIAuxContainer> ();
376  eContainer->setStore(eAuxContainer.get());
377 
378  // xTOB Containers
379  auto xeContainer = std::make_unique<xAOD::eFexEMRoIContainer> ();
380  auto xeAuxContainer = std::make_unique<xAOD::eFexEMRoIAuxContainer> ();
381  xeContainer->setStore(xeAuxContainer.get());
382 
383  // iterate over all Em Tobs and fill xTOB EDM with them
384  for( auto const& [efex, tobObjects] : allEmTobObjects ){
385  for(auto &tobObject : tobObjects){
386  m_eFEXFillEDMTool->fillEmEDM(xeContainer, efex, tobObject, true);
387  }
388  }
389 
390  // Form list of TOBs, sorted and truncated from each eFEX
391  // Vector to store sorted TOBs from all eFEXes
392  // Note that this step means moving TOBs from the all objects vector, which is why we do it last
393  std::vector<std::unique_ptr<eFEXegTOB>> emTOBs;
394  // Loop through eFEXes and sort TOBs from each
395  auto iter = allEmTobObjects.begin();
396  while (iter != allEmTobObjects.end()) {
397  std::vector<std::unique_ptr<eFEXegTOB>> tobsSort = std::move(iter->second);
398  // sort tobs by their et (last 12 bits of the 32 bit tob word)
399  std::sort (tobsSort.begin(), tobsSort.end(), std::bind(TOBetSort<std::unique_ptr<eFEXegTOB>>, std::placeholders::_1, std::placeholders::_2, false));
400  // Truncate at 6 TOBs per eFEX
401  if (tobsSort.size() > 6) tobsSort.resize(6);
402  // Append to system TOB list
403  for (unsigned int t = 0; t < tobsSort.size(); ++t) emTOBs.push_back(std::move(tobsSort[t]));
404  // Next eFEX
405  ++iter;
406  }
407 
408  // iterate over sorted eFEX EM TOBs and fill TOB EDM with them
409  for(auto &tobObject : emTOBs){
410  int efex = tobObject->geteFEXID();
411  m_eFEXFillEDMTool->fillEmEDM(eContainer, efex, tobObject);
412  }
413 
414  // Match xTOBs to TOBs and set isTOB flags if matched
415  matchTOBs(eContainer, xeContainer);
416 
417  // Record EDMs in StoreGate
418  SG::WriteHandle<xAOD::eFexEMRoIContainer> outputeFexEMxTOBHandle(m_eFexEMxTOBOutKey/*, ctx*/);
419  ATH_MSG_DEBUG(" write: " << outputeFexEMxTOBHandle.key() << " = " << "..." );
420  ATH_CHECK(outputeFexEMxTOBHandle.record(std::move(xeContainer),std::move(xeAuxContainer)));
421 
422  SG::WriteHandle<xAOD::eFexEMRoIContainer> outputeFexHandle(m_eFexOutKey/*, ctx*/);
423  ATH_MSG_DEBUG(" write: " << outputeFexHandle.key() << " = " << "..." );
424  ATH_CHECK(outputeFexHandle.record(std::move(eContainer),std::move(eAuxContainer)));
425 
426  SG::ReadHandle<TrigConf::L1Menu> l1Menu (m_l1MenuKey/*, ctx*/);
427  ATH_CHECK(l1Menu.isValid());
428 
429  auto & thr_eTAU = l1Menu->thrExtraInfo().eTAU();
430  int activeAlgo = thr_eTAU.algoVersion() == 0 ? xAOD::eFexTauRoI_v1::Heuristic : xAOD::eFexTauRoI_v1::BDT;
431  bool omitAltTauContainer = m_eFexTauAltxTOBOutKey.empty() || m_eFexTauAltOutKey.empty();
432 
433  // Repeat for Tau TOBs and xTOBs
434  if (activeAlgo == xAOD::eFexTauRoI_v1::Heuristic) {
435  ATH_CHECK(StoreTauTOBs(allTauHeuristicTobObjects, m_eFexTauActivexTOBOutKey, m_eFexTauActiveOutKey));
436  if (!omitAltTauContainer) {
437  ATH_CHECK(StoreTauTOBs(allTauBDTTobObjects, m_eFexTauAltxTOBOutKey, m_eFexTauAltOutKey));
438  }
439  } else if (activeAlgo == xAOD::eFexTauRoI_v1::BDT) {
440  ATH_CHECK(StoreTauTOBs(allTauBDTTobObjects, m_eFexTauActivexTOBOutKey, m_eFexTauActiveOutKey));
441  if (!omitAltTauContainer) {
442  ATH_CHECK(StoreTauTOBs(allTauHeuristicTobObjects, m_eFexTauAltxTOBOutKey, m_eFexTauAltOutKey));
443  }
444  }
445 
446  //Send TOBs to bytestream?
447  // ToDo
448  // To implement
449  // {--Implement--}
450 
451  return StatusCode::SUCCESS;
452 
453  }
454 
455  StatusCode eFEXSysSim::StoreTauTOBs(std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >& allTauTobObjects,
456  SG::WriteHandleKey< xAOD::eFexTauRoIContainer >& eFexTauxTOBOutKey,
457  SG::WriteHandleKey< xAOD::eFexTauRoIContainer >& eFexTauOutKey)
458  {
459  std::unique_ptr< xAOD::eFexTauRoIContainer > tauContainer;
460  std::unique_ptr< xAOD::eFexTauRoIAuxContainer > tauAuxContainer;
461  std::unique_ptr< xAOD::eFexTauRoIContainer > xtauContainer;
462  std::unique_ptr< xAOD::eFexTauRoIAuxContainer > xtauAuxContainer;
463 
464  tauContainer = std::make_unique<xAOD::eFexTauRoIContainer> ();
465  tauAuxContainer = std::make_unique<xAOD::eFexTauRoIAuxContainer> ();
466  tauContainer->setStore(tauAuxContainer.get());
467 
468  xtauContainer = std::make_unique<xAOD::eFexTauRoIContainer> ();
469  xtauAuxContainer = std::make_unique<xAOD::eFexTauRoIAuxContainer> ();
470  xtauContainer->setStore(xtauAuxContainer.get());
471 
472  // iterate over all tau TOBs and fill xTOB EDM with them
473  for( auto const& [efex, tobObjects] : allTauTobObjects ){
474  for( auto &tobObject: tobObjects ){
475  m_eFEXFillEDMTool->fillTauEDM(xtauContainer, efex, tobObject, true);
476  }
477  }
478 
479  // Form list of TOBs, sorted and truncated from each eFEX
480  // Vector to store sorted TOBs from all eFEXes
481  // Note that this step means moving TOBs from the all objects vector, which is why we do it last
482  std::vector<std::unique_ptr<eFEXtauTOB>> tauTOBs;
483  // Loop through eFEXes and sort TOBs from each
484  auto iterTau = allTauTobObjects.begin();
485  while (iterTau != allTauTobObjects.end()) {
486  std::vector<std::unique_ptr<eFEXtauTOB>> tobsSort = std::move(iterTau->second);
487  // sort tobs by their et (last 12 bits of the 32 bit tob word)
488  std::sort (tobsSort.begin(), tobsSort.end(), std::bind(TOBetSort<std::unique_ptr<eFEXtauTOB>>, std::placeholders::_1, std::placeholders::_2, true));
489  // Truncate at 6 TOBs per eFEX
490  if (tobsSort.size() > 6) tobsSort.resize(6);
491  // Append to system TOB list
492  for (unsigned int t = 0; t < tobsSort.size(); ++t) tauTOBs.push_back(std::move(tobsSort[t]));
493  // Next eFEX
494  ++iterTau;
495  }
496 
497  // iterate over sorted eFEX Tau TOBs and fill TOB EDM with them
498  for(auto &tobObject : tauTOBs){
499  int efex = tobObject->geteFEXID();
500  m_eFEXFillEDMTool->fillTauEDM(tauContainer, efex, tobObject);
501  }
502 
503  // Match xTOBs and TOBs and set isTOB flags if matched
504  matchTOBs(tauContainer, xtauContainer);
505 
506  // Record containers in StoreGate
507  SG::WriteHandle<xAOD::eFexTauRoIContainer> outputeFexTauxTOBHandle(eFexTauxTOBOutKey/*, ctx*/);
508  ATH_MSG_DEBUG(" write: " << outputeFexTauxTOBHandle.key() << " = " << "..." );
509  ATH_CHECK(outputeFexTauxTOBHandle.record(std::move(xtauContainer), std::move(xtauAuxContainer)));
510 
511  SG::WriteHandle<xAOD::eFexTauRoIContainer> outputeFexTauHandle(eFexTauOutKey/*, ctx*/);
512  ATH_MSG_DEBUG(" write: " << outputeFexTauHandle.key() << " = " << "..." );
513  ATH_CHECK(outputeFexTauHandle.record(std::move(tauContainer), std::move(tauAuxContainer)));
514 
515  return StatusCode::SUCCESS;
516 
517  }
518 } // end of namespace bracket
LVL1::eFEXSysSim::m_eFexTauActiveOutKey
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauActiveOutKey
Definition: eFEXSysSim.h:103
LVL1::eFEXSysSim::m_eFEXFPGATowerIdProviderTool
ToolHandle< eFEXFPGATowerIdProvider > m_eFEXFPGATowerIdProviderTool
Definition: eFEXSysSim.h:107
createLinkingScheme.iter
iter
Definition: createLinkingScheme.py:62
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
eTowerContainer.h
xAOD::eFexTauRoI_v1::BDT
@ BDT
This object is generated by the BDT algorithm.
Definition: eFexTauRoI_v1.h:48
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
LVL1::eFEXSysSim::m_eFexTauActivexTOBOutKey
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauActivexTOBOutKey
Definition: eFEXSysSim.h:104
LVL1::eFEXSysSim::calcTowerID
virtual int calcTowerID(int eta, int phi, int mod) const
Definition: eFEXSysSim.cxx:74
LVL1::eFEXSysSim::StoreTauTOBs
StatusCode StoreTauTOBs(std::map< int, std::vector< std::unique_ptr< eFEXtauTOB >> > &allTauTobObjects, SG::WriteHandleKey< xAOD::eFexTauRoIContainer > &eFexTauxTOBOutKey, SG::WriteHandleKey< xAOD::eFexTauRoIContainer > &eFexTauOutKey)
Definition: eFEXSysSim.cxx:455
eFEXSim.h
LVL1::eFEXSysSim::execute
virtual StatusCode execute(eFEXOutputCollection *inputOutputCollection)
Definition: eFEXSysSim.cxx:79
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
LVL1::eFEXSysSim::m_eFEXSimTool
ToolHandle< eFEXSim > m_eFEXSimTool
Definition: eFEXSysSim.h:94
TrigConf::L1ThrExtraInfo::eTAU
const L1ThrExtraInfo_eTAU & eTAU() const
Definition: L1ThrExtraInfo.cxx:133
eFEXTOBxTOBMatching.h
eFexEMRoIAuxContainer.h
TrigConf::L1Menu::thrExtraInfo
const L1ThrExtraInfo & thrExtraInfo() const
Access to extra info for threshold types.
Definition: L1Menu.cxx:307
eFexTauRoIContainer.h
LVL1::eFEXSysSim::m_eTowerContainerSGKey
SG::ReadHandleKey< LVL1::eTowerContainer > m_eTowerContainerSGKey
Definition: eFEXSysSim.h:98
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
LVL1::matchTOBs
void matchTOBs(T &TOBs, T &xTOBs)
Definition: eFEXTOBxTOBMatching.h:18
LVL1
eFexTowerBuilder creates xAOD::eFexTowerContainer from supercells (LATOME) and triggerTowers (TREX) i...
Definition: ICMMCPHitsCnvTool.h:18
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
LVL1::eFEXSysSim::initialize
virtual StatusCode initialize()
standard Athena-Algorithm method
Definition: eFEXSysSim.cxx:52
WriteHandle.h
Handle class for recording to StoreGate.
beamspotnt.cols
list cols
Definition: bin/beamspotnt.py:1113
LVL1::eFEXSysSim::m_eFexTauAltxTOBOutKey
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauAltxTOBOutKey
Definition: eFEXSysSim.h:106
SG::WriteHandleKey
Property holding a SG store/key/clid from which a WriteHandle is made.
Definition: StoreGate/StoreGate/WriteHandleKey.h:40
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
LVL1::eTower::phi
float phi() const
Definition: eTower.h:65
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LVL1::eFEXSysSim::m_eFexEMxTOBOutKey
SG::WriteHandleKey< xAOD::eFexEMRoIContainer > m_eFexEMxTOBOutKey
Definition: eFEXSysSim.h:102
test_pyathena.parent
parent
Definition: test_pyathena.py:15
LVL1::eFEXSysSim::eFEXSysSim
eFEXSysSim(const std::string &type, const std::string &name, const IInterface *parent)
Constructors.
Definition: eFEXSysSim.cxx:37
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::eFexTauRoI_v1::Heuristic
@ Heuristic
This object is generated by the heuristic algorithm.
Definition: eFexTauRoI_v1.h:47
beamspotnt.rows
list rows
Definition: bin/beamspotnt.py:1111
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
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
LVL1::eFEXSysSim::m_l1MenuKey
SG::ReadHandleKey< TrigConf::L1Menu > m_l1MenuKey
Definition: eFEXSysSim.h:99
TrigConf::name
Definition: HLTChainList.h:35
LVL1::eFEXSysSim::m_eFexOutKey
SG::WriteHandleKey< xAOD::eFexEMRoIContainer > m_eFexOutKey
Definition: eFEXSysSim.h:101
TrigConf::L1ThrExtraInfo_eTAU::algoVersion
unsigned int algoVersion() const
Definition: L1ThrExtraInfo.h:285
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
eFexTauRoI.h
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
LVL1::eFEXSysSim::m_eFexTauAltOutKey
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauAltOutKey
Definition: eFEXSysSim.h:105
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
eFexTauRoIAuxContainer.h
LVL1::eFEXSysSim::m_eFEXFillEDMTool
ToolHandle< eFEXFillEDM > m_eFEXFillEDMTool
Definition: eFEXSysSim.h:96
eFexEMRoI.h
LVL1::eTower::eta
float eta() const
Definition: eTower.h:64
ReadHandle.h
Handle class for reading from StoreGate.
AthAlgTool
Definition: AthAlgTool.h:26
L1Menu.h
LVL1::eFEXSysSim::TOBetSort
static bool TOBetSort(const TOBObjectClass &i, const TOBObjectClass &j, bool isTau)
Internal data.
Definition: eFEXSysSim.h:62
LVL1::eTowerContainer::findTower
const LVL1::eTower * findTower(int towerID) const
fast find method given identifier.
Definition: eTowerContainer.cxx:29
LVL1::eFEXOutputCollection
Definition: eFEXOutputCollection.h:23
eTower.h
value_type
Definition: EDM_MasterSearch.h:11
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:27
eFexEMRoIContainer.h
eFEXSysSim.h
Generated on Mon Nov 3 2025 21:09:18 for ATLAS Offline Software by   doxygen 1.8.18