ATLAS Offline Software
Loading...
Searching...
No Matches
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
32namespace 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 || thr_eTAU.algoVersion() == 3) ? 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
eta
Scalar eta() const
pseudorapidity method
Definition AmgMatrixBasePlugin.h:83
phi
Scalar phi() const
phi method
Definition AmgMatrixBasePlugin.h:67
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition AthMsgStreamMacros.h:34
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
ReadHandle.h
Handle class for reading from StoreGate.
WriteHandle.h
Handle class for recording to StoreGate.
AthAlgTool::AthAlgTool
AthAlgTool(const std::string &type, const std::string &name, const IInterface *parent)
Constructor with parameters:
Definition AthAlgTool.cxx:16
LVL1::eFEXSysSim::m_eFEXSimTool
ToolHandle< eFEXSim > m_eFEXSimTool
Definition eFEXSysSim.h:94
LVL1::eFEXSysSim::m_eFexTauAltOutKey
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauAltOutKey
Definition eFEXSysSim.h:105
LVL1::eFEXSysSim::m_l1MenuKey
SG::ReadHandleKey< TrigConf::L1Menu > m_l1MenuKey
Definition eFEXSysSim.h:99
LVL1::eFEXSysSim::m_eFexOutKey
SG::WriteHandleKey< xAOD::eFexEMRoIContainer > m_eFexOutKey
Definition eFEXSysSim.h:101
LVL1::eFEXSysSim::m_eFEXFillEDMTool
ToolHandle< eFEXFillEDM > m_eFEXFillEDMTool
Definition eFEXSysSim.h:96
LVL1::eFEXSysSim::execute
virtual StatusCode execute(eFEXOutputCollection *inputOutputCollection)
Definition eFEXSysSim.cxx:79
LVL1::eFEXSysSim::m_eFEXFPGATowerIdProviderTool
ToolHandle< eFEXFPGATowerIdProvider > m_eFEXFPGATowerIdProviderTool
Definition eFEXSysSim.h:107
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
LVL1::eFEXSysSim::TOBetSort
static bool TOBetSort(const TOBObjectClass &i, const TOBObjectClass &j, bool isTau)
Internal data.
Definition eFEXSysSim.h:62
LVL1::eFEXSysSim::m_eFexEMxTOBOutKey
SG::WriteHandleKey< xAOD::eFexEMRoIContainer > m_eFexEMxTOBOutKey
Definition eFEXSysSim.h:102
LVL1::eFEXSysSim::m_eFexTauActivexTOBOutKey
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauActivexTOBOutKey
Definition eFEXSysSim.h:104
LVL1::eFEXSysSim::initialize
virtual StatusCode initialize()
standard Athena-Algorithm method
Definition eFEXSysSim.cxx:52
LVL1::eFEXSysSim::eFEXSysSim
eFEXSysSim(const std::string &type, const std::string &name, const IInterface *parent)
Constructors.
Definition eFEXSysSim.cxx:37
LVL1::eFEXSysSim::m_eFexTauActiveOutKey
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauActiveOutKey
Definition eFEXSysSim.h:103
LVL1::eFEXSysSim::calcTowerID
virtual int calcTowerID(int eta, int phi, int mod) const
Definition eFEXSysSim.cxx:74
LVL1::eFEXSysSim::m_eTowerContainerSGKey
SG::ReadHandleKey< LVL1::eTowerContainer > m_eTowerContainerSGKey
Definition eFEXSysSim.h:98
LVL1::eFEXSysSim::m_eFexTauAltxTOBOutKey
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauAltxTOBOutKey
Definition eFEXSysSim.h:106
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
SG::VarHandleBase::key
virtual const std::string & key() const override final
Return the StoreGate ID for the referenced object.
Definition AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx:64
SG::WriteHandleKey
Property holding a SG store/key/clid from which a WriteHandle is made.
Definition StoreGate/StoreGate/WriteHandleKey.h:40
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
xAOD::eFexTauRoI_v1::BDT
@ BDT
This object is generated by the BDT algorithm.
Definition eFexTauRoI_v1.h:48
xAOD::eFexTauRoI_v1::Heuristic
@ Heuristic
This object is generated by the heuristic algorithm.
Definition eFexTauRoI_v1.h:47
LVL1
eFexTowerBuilder creates xAOD::eFexTowerContainer from supercells (LATOME) and triggerTowers (TREX) i...
Definition ICMMCPHitsCnvTool.h:18
LVL1::matchTOBs
void matchTOBs(T &TOBs, T &xTOBs)
Definition eFEXTOBxTOBMatching.h:18
std::sort
void sort(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of sort for DataVector/List.
Definition DVL_algorithms.h:554
type
value_type
Definition EDM_MasterSearch.h:11
Generated on for ATLAS Offline Software by doxygen 1.14.0