ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
LVL1::jFEXSysSim Class Reference

The jFEXSysSim class defines the structure of the jFEX system Its purpose is: More...

#include <jFEXSysSim.h>

Inheritance diagram for LVL1::jFEXSysSim:

Public Member Functions

 jFEXSysSim (const std::string &type, const std::string &name, const IInterface *parent)
 Constructors.
jFEXSysSim && operator= (const jFEXSysSim &)=delete
 Destructor.
virtual StatusCode initialize () override
 standard Athena-Algorithm method
virtual StatusCode finalize () override
 standard Athena-Algorithm method
virtual StatusCode execute (jFEXOutputCollection *inputOutputCollection) override
virtual void init () const override
virtual void cleanup () override
virtual int calcTowerID (int eta, int phi, int mod) const override
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Static Public Member Functions

static const InterfaceID & interfaceID ()

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed.

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t

Private Member Functions

StatusCode fillSRJetEDM (const std::unique_ptr< jFEXTOB > &internalTob, char istob, float_t eta, float_t phi, SG::WriteHandle< xAOD::jFexSRJetRoIContainer > &jContainer) const
StatusCode fillLRJetEDM (const std::unique_ptr< jFEXTOB > &internalTob, char istob, float_t eta, float_t phi, SG::WriteHandle< xAOD::jFexLRJetRoIContainer > &jContainer) const
StatusCode fillTauEDM (const std::unique_ptr< jFEXTOB > &internalTob, char istob, float_t eta, float_t phi, SG::WriteHandle< xAOD::jFexTauRoIContainer > &jContainer) const
StatusCode fillFwdElEDM (uint8_t jFexNum, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi, SG::WriteHandle< xAOD::jFexFwdElRoIContainer > &jContainer) const
StatusCode fillSumEtEDM (const std::unique_ptr< jFEXTOB > &internalTob, SG::WriteHandle< xAOD::jFexSumETRoIContainer > &jContainer) const
StatusCode fillMetEDM (const std::unique_ptr< jFEXTOB > &internalTob, SG::WriteHandle< xAOD::jFexMETRoIContainer > &jContainer) const
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

std::vector< jFEXSim * > m_jFEXCollection
 Internal data.
SG::ReadCondHandleKey< jFEXDBCondData > m_DBToolKey {this, "DBToolKey", "jFEXDBParams", "DB tool key"}
ToolHandle< IjFEXSim > m_jFEXSimTool {this, "jFEXSimTool", "LVL1::jFEXSim", "Tool that creates the jFEX Simulation"}
SG::ReadHandleKey< LVL1::jTowerContainer > m_jTowerContainerSGKey {this, "MyETowers", "jTowerContainer", "Input container for jTowers"}
SG::ReadHandleKey< TrigConf::L1Menu > m_l1MenuKey {this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu","Name of the L1Menu object to read configuration from"}
SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer > m_TobOutKey_jJ {this,"Key_jFexSRJetOutputContainer","L1_jFexSRJetRoI","Output jFexEDM jets container"}
SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer > m_TobOutKey_jLJ {this,"Key_jFexLRJetOutputContainer","L1_jFexLRJetRoI","Output jFexEDM Ljets container"}
SG::WriteHandleKey< xAOD::jFexTauRoIContainer > m_TobOutKey_jTau {this,"Key_jFexTauOutputContainer" ,"L1_jFexTauRoI" ,"Output jFexEDM tau container"}
SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer > m_TobOutKey_jEM {this,"Key_jFexFwdElOutputContainer","L1_jFexFwdElRoI","Output jFexEDM fwdEl container"}
SG::WriteHandleKey< xAOD::jFexSumETRoIContainer > m_TobOutKey_jTE {this,"Key_jFexSumETOutputContainer","L1_jFexSumETRoI","Output jFexEDM SumET container"}
SG::WriteHandleKey< xAOD::jFexMETRoIContainer > m_TobOutKey_jXE {this,"Key_jFexMETOutputContainer" ,"L1_jFexMETRoI" ,"Output jFexEDM Met container"}
SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer > m_xTobOutKey_jJ {this,"Key_xTobOutKey_jJ" ,"L1_jFexSRJetxRoI","Output jFexEDM xTOBs jets container"}
SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer > m_xTobOutKey_jLJ {this,"Key_xTobOutKey_jLJ" ,"L1_jFexLRJetxRoI","Output jFexEDM xTOBs Ljets container"}
SG::WriteHandleKey< xAOD::jFexTauRoIContainer > m_xTobOutKey_jTau {this,"Key_xTobOutKey_jTau" ,"L1_jFexTauxRoI" ,"Output jFexEDM xTOBs tau container"}
SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer > m_xTobOutKey_jEM {this,"Key_xTobOutKey_jEM" ,"L1_jFexFwdElxRoI","Output jFexEDM xTOBs fwdEl container"}
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_TobDecorKey_jJ_seedET { this, "Key_tobDecor_jJ_seedET" , m_TobOutKey_jJ , "seedETMeV" , "jJet seed ET value in MeV" }
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_xTobDecorKey_jJ_seedET { this, "Key_xTobDecor_jJ_seedET" , m_xTobOutKey_jJ , "seedETMeV" , "jJet seed ET value in MeV" }
std::unordered_map< int, jTower > m_jTowersColl
std::unordered_map< uint8_t, std::vector< std::vector< std::vector< uint32_t > > > > m_allfwdElTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_alltauTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_allSmallRJetTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_allLargeRJetTobs
std::unordered_map< uint8_t, std::vector< std::unique_ptr< jFEXTOB > > > m_allsumEtTobs
std::unordered_map< uint8_t, std::vector< std::unique_ptr< jFEXTOB > > > m_allMetTobs
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

The jFEXSysSim class defines the structure of the jFEX system Its purpose is:

  • to follow the structure of the 24 jFEXes and their FPGAs in as much detail as necessary to simulate the output of the system It will need to interact with jTowers and produce the eTOBs

Definition at line 47 of file jFEXSysSim.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ jFEXSysSim()

LVL1::jFEXSysSim::jFEXSysSim ( const std::string & type,
const std::string & name,
const IInterface * parent )

Constructors.

Definition at line 36 of file jFEXSysSim.cxx.

36 :
37 AthAlgTool(type,name,parent)
38 {
39 declareInterface<IjFEXSysSim>(this);
40
41 }
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:

Member Function Documentation

◆ calcTowerID()

int LVL1::jFEXSysSim::calcTowerID ( int eta,
int phi,
int mod ) const
overridevirtual

Implements LVL1::IjFEXSysSim.

Definition at line 102 of file jFEXSysSim.cxx.

102 {
103
104 return ((64*eta) + phi + mod);
105 }
eta
Scalar eta() const
pseudorapidity method
Definition AmgMatrixBasePlugin.h:83
phi
Scalar phi() const
phi method
Definition AmgMatrixBasePlugin.h:67

◆ cleanup()

void LVL1::jFEXSysSim::cleanup ( )
overridevirtual

Implements LVL1::IjFEXSysSim.

Definition at line 94 of file jFEXSysSim.cxx.

94 {
95
96 m_jFEXCollection.clear();
97 m_jTowersColl.clear();
98
99 }
LVL1::jFEXSysSim::m_jTowersColl
std::unordered_map< int, jTower > m_jTowersColl
Definition jFEXSysSim.h:103
LVL1::jFEXSysSim::m_jFEXCollection
std::vector< jFEXSim * > m_jFEXCollection
Internal data.
Definition jFEXSysSim.h:74

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl,
const SG::VarHandleKeyType &  )
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158 {
159 return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160 hndl.value(),
161 hndl.documentation());
162
163 }
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
147 return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

◆ execute()

StatusCode LVL1::jFEXSysSim::execute ( jFEXOutputCollection * inputOutputCollection)
overridevirtual

Implements LVL1::IjFEXSysSim.

Definition at line 107 of file jFEXSysSim.cxx.

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

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ fillFwdElEDM()

StatusCode LVL1::jFEXSysSim::fillFwdElEDM ( uint8_t jFexNum,
uint8_t fpgaNumber,
uint32_t tobWord,
char istob,
int resolution,
float_t eta,
float_t phi,
SG::WriteHandle< xAOD::jFexFwdElRoIContainer > & jContainer ) const
private

Definition at line 1143 of file jFEXSysSim.cxx.

1143 {
1144
1145 xAOD::jFexFwdElRoI* my_EDM = new xAOD::jFexFwdElRoI();
1146 jContainer->push_back( my_EDM );
1147
1148 my_EDM->initialize(jFexNum, fpgaNumber, tobWord ,istob , resolution, eta, phi);
1149
1150 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 );
1151
1152 return StatusCode::SUCCESS;
1153 }
xAOD::jFexFwdElRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition jFexFwdElRoI_v1.cxx:151
xAOD::jFexFwdElRoI_v1::phi
float phi() const
xAOD::jFexFwdElRoI_v1::eta
float eta() const
xAOD::jFexFwdElRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi)
initialze the EDM
Definition jFexFwdElRoI_v1.cxx:30
xAOD::jFexFwdElRoI_v1::jFexNumber
uint8_t jFexNumber() const
Additional info (initialization).
xAOD::jFexFwdElRoI
jFexFwdElRoI_v1 jFexFwdElRoI
Define the latest version of the jFexFwdElJetRoI class.
Definition jFexFwdElRoI.h:13

◆ fillLRJetEDM()

StatusCode LVL1::jFEXSysSim::fillLRJetEDM ( const std::unique_ptr< jFEXTOB > & internalTob,
char istob,
float_t eta,
float_t phi,
SG::WriteHandle< xAOD::jFexLRJetRoIContainer > & jContainer ) const
private

Definition at line 1155 of file jFEXSysSim.cxx.

1155 {
1156
1157 xAOD::jFexLRJetRoI* my_EDM = new xAOD::jFexLRJetRoI();
1158 jContainer->push_back( my_EDM );
1159
1160 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), istob, internalTob->getRes(), eta, phi);
1161
1162 ATH_MSG_DEBUG(" setting LRJet jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1163
1164 return StatusCode::SUCCESS;
1165 }
xAOD::jFexLRJetRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition jFexLRJetRoI_v1.cxx:139
xAOD::jFexLRJetRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi)
In future initialze the EDM.
Definition jFexLRJetRoI_v1.cxx:40
xAOD::jFexLRJetRoI_v1::eta
float eta() const
xAOD::jFexLRJetRoI_v1::jFexNumber
uint8_t jFexNumber() const
xAOD::jFexLRJetRoI_v1::phi
float phi() const
xAOD::jFexLRJetRoI
jFexLRJetRoI_v1 jFexLRJetRoI
Define the latest version of the jFexLRJetRoI class.
Definition jFexLRJetRoI.h:13

◆ fillMetEDM()

StatusCode LVL1::jFEXSysSim::fillMetEDM ( const std::unique_ptr< jFEXTOB > & internalTob,
SG::WriteHandle< xAOD::jFexMETRoIContainer > & jContainer ) const
private

Definition at line 1179 of file jFEXSysSim.cxx.

1179 {
1180
1181 xAOD::jFexMETRoI* my_EDM = new xAOD::jFexMETRoI();
1182 jContainer->push_back( my_EDM );
1183
1184 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), internalTob->getRes());
1185
1186 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() );
1187
1188 return StatusCode::SUCCESS;
1189 }
xAOD::jFexMETRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, int resolution)
In future initialze the xTOB as well, word1.
Definition jFexMETRoI_v1.cxx:20
xAOD::jFexMETRoI_v1::tobEx
int tobEx() const
xAOD::jFexMETRoI_v1::jFexNumber
uint8_t jFexNumber() const
xAOD::jFexMETRoI_v1::tobRes
uint8_t tobRes() const
xAOD::jFexMETRoI_v1::tobEy
int tobEy() const
xAOD::jFexMETRoI_v1::tobSat
uint8_t tobSat() const
xAOD::jFexMETRoI
jFexMETRoI_v1 jFexMETRoI
Define the latest version of the jFexMETRoI class.
Definition jFexMETRoI.h:13

◆ fillSRJetEDM()

StatusCode LVL1::jFEXSysSim::fillSRJetEDM ( const std::unique_ptr< jFEXTOB > & internalTob,
char istob,
float_t eta,
float_t phi,
SG::WriteHandle< xAOD::jFexSRJetRoIContainer > & jContainer ) const
private

Definition at line 1118 of file jFEXSysSim.cxx.

1118 {
1119
1120 xAOD::jFexSRJetRoI* my_EDM = new xAOD::jFexSRJetRoI();
1121 jContainer->push_back( my_EDM );
1122
1123 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), istob, internalTob->getRes(), eta, phi);
1124
1125 ATH_MSG_DEBUG(" setting SRJet jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1126
1127 return StatusCode::SUCCESS;
1128 }
xAOD::jFexSRJetRoI_v1::phi
float phi() const
xAOD::jFexSRJetRoI_v1::jFexNumber
uint8_t jFexNumber() const
xAOD::jFexSRJetRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi)
In future initialze the EDM.
Definition jFexSRJetRoI_v1.cxx:38
xAOD::jFexSRJetRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition jFexSRJetRoI_v1.cxx:138
xAOD::jFexSRJetRoI_v1::eta
float eta() const
xAOD::jFexSRJetRoI
jFexSRJetRoI_v1 jFexSRJetRoI
Define the latest version of the jFexSRJetRoI class.
Definition jFexSRJetRoI.h:14

◆ fillSumEtEDM()

StatusCode LVL1::jFEXSysSim::fillSumEtEDM ( const std::unique_ptr< jFEXTOB > & internalTob,
SG::WriteHandle< xAOD::jFexSumETRoIContainer > & jContainer ) const
private

Definition at line 1167 of file jFEXSysSim.cxx.

1167 {
1168
1169 xAOD::jFexSumETRoI* my_EDM = new xAOD::jFexSumETRoI();
1170 jContainer->push_back( my_EDM );
1171
1172 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), internalTob->getRes());
1173
1174 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());
1175
1176 return StatusCode::SUCCESS;
1177 }
xAOD::jFexSumETRoI_v1::tobSat_upper
uint8_t tobSat_upper() const
xAOD::jFexSumETRoI_v1::tobSat_lower
uint8_t tobSat_lower() const
xAOD::jFexSumETRoI_v1::tobEt_lower
uint16_t tobEt_lower() const
xAOD::jFexSumETRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, int resolution)
In future initialze the xTOB as well, word1.
Definition jFexSumETRoI_v1.cxx:20
xAOD::jFexSumETRoI_v1::tobEt_upper
uint16_t tobEt_upper() const
xAOD::jFexSumETRoI_v1::jFexNumber
uint8_t jFexNumber() const
xAOD::jFexSumETRoI
jFexSumETRoI_v1 jFexSumETRoI
Define the latest version of the jFexSumETJetRoI class.
Definition jFexSumETRoI.h:13

◆ fillTauEDM()

StatusCode LVL1::jFEXSysSim::fillTauEDM ( const std::unique_ptr< jFEXTOB > & internalTob,
char istob,
float_t eta,
float_t phi,
SG::WriteHandle< xAOD::jFexTauRoIContainer > & jContainer ) const
private

Definition at line 1131 of file jFEXSysSim.cxx.

1131 {
1132
1133 xAOD::jFexTauRoI* my_EDM = new xAOD::jFexTauRoI();
1134 jContainer->push_back( my_EDM );
1135
1136 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), istob, internalTob->getRes(), eta, phi);
1137
1138 ATH_MSG_DEBUG(" setting tau jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1139
1140 return StatusCode::SUCCESS;
1141 }
xAOD::jFexTauRoI_v1::phi
float phi() const
xAOD::jFexTauRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi)
In future initialze the EDM.
Definition jFexTauRoI_v1.cxx:21
xAOD::jFexTauRoI_v1::eta
float eta() const
xAOD::jFexTauRoI_v1::jFexNumber
uint8_t jFexNumber() const
xAOD::jFexTauRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition jFexTauRoI_v1.cxx:114
xAOD::jFexTauRoI
jFexTauRoI_v1 jFexTauRoI
Define the latest version of the jFexSRJetRoI class.
Definition jFexTauRoI.h:13

◆ finalize()

StatusCode LVL1::jFEXSysSim::finalize ( )
overridevirtual

standard Athena-Algorithm method

Definition at line 84 of file jFEXSysSim.cxx.

85 {
86 return StatusCode::SUCCESS;
87 }

◆ init()

void LVL1::jFEXSysSim::init ( ) const
overridevirtual

Implements LVL1::IjFEXSysSim.

Definition at line 90 of file jFEXSysSim.cxx.

90 {
91
92 }

◆ initialize()

StatusCode LVL1::jFEXSysSim::initialize ( )
overridevirtual

standard Athena-Algorithm method

Destructor.

Definition at line 51 of file jFEXSysSim.cxx.

52 {
53
54 ATH_CHECK(m_jTowerContainerSGKey.initialize());
55
56 ATH_CHECK( m_DBToolKey.initialize() );
57 ATH_CHECK(m_jFEXSimTool.retrieve() );
58
59 // TOBs Key
60 ATH_CHECK(m_TobOutKey_jJ.initialize());
61 ATH_CHECK(m_TobOutKey_jLJ.initialize());
62 ATH_CHECK(m_TobOutKey_jTau.initialize());
63 ATH_CHECK(m_TobOutKey_jEM.initialize());
64 ATH_CHECK(m_TobOutKey_jTE.initialize());
65 ATH_CHECK(m_TobOutKey_jXE.initialize());
66
67 // xTOBs Key
68 ATH_CHECK(m_xTobOutKey_jJ.initialize());
69 ATH_CHECK(m_xTobOutKey_jLJ.initialize());
70 ATH_CHECK(m_xTobOutKey_jTau.initialize());
71 ATH_CHECK(m_xTobOutKey_jEM.initialize());
72
73 // Decorations
74 ATH_CHECK(m_TobDecorKey_jJ_seedET.initialize());
75 ATH_CHECK(m_xTobDecorKey_jJ_seedET.initialize());
76
77 ATH_CHECK(m_l1MenuKey.initialize());
78
79 return StatusCode::SUCCESS;
80 }

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

const InterfaceID & LVL1::IjFEXSysSim::interfaceID ( )
inlinestaticinherited

Definition at line 58 of file IjFEXSysSim.h.

59 {
60 return IID_IjFEXSysSim;
61 }
LVL1::IID_IjFEXSysSim
static const InterfaceID IID_IjFEXSysSim("LVL1::IjFEXSysSim", 1, 0)

◆ msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24 {
25 return this->msgStream();
26 }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

◆ operator=()

jFEXSysSim && LVL1::jFEXSysSim::operator= ( const jFEXSysSim & )
delete

Destructor.

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381 {
382 h.renounce();
383 PBASE::renounce (h);
384 }
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition AthCommonDataStore.h:380

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364 {
365 handlesArray.renounce();
366 }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308 {
309 // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310 // << " size: " << m_vhka.size() << endmsg;
311 for (auto &a : m_vhka) {
312 std::vector<SG::VarHandleKey*> keys = a->keys();
313 for (auto k : keys) {
314 k->setOwner(this);
315 }
316 }
317 }
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition AthCommonDataStore.h:398

Member Data Documentation

◆ m_allfwdElTobs

std::unordered_map<uint8_t, std::vector<std::vector<std::vector<uint32_t> > > > LVL1::jFEXSysSim::m_allfwdElTobs
private

Definition at line 105 of file jFEXSysSim.h.

◆ m_allLargeRJetTobs

std::unordered_map<uint8_t, std::vector<std::vector<std::unique_ptr<jFEXTOB> > > > LVL1::jFEXSysSim::m_allLargeRJetTobs
private

Definition at line 109 of file jFEXSysSim.h.

◆ m_allMetTobs

std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB> > > LVL1::jFEXSysSim::m_allMetTobs
private

Definition at line 111 of file jFEXSysSim.h.

◆ m_allSmallRJetTobs

std::unordered_map<uint8_t, std::vector<std::vector<std::unique_ptr<jFEXTOB> > > > LVL1::jFEXSysSim::m_allSmallRJetTobs
private

Definition at line 108 of file jFEXSysSim.h.

◆ m_allsumEtTobs

std::unordered_map<uint8_t, std::vector<std::unique_ptr<jFEXTOB> > > LVL1::jFEXSysSim::m_allsumEtTobs
private

Definition at line 110 of file jFEXSysSim.h.

◆ m_alltauTobs

std::unordered_map<uint8_t, std::vector<std::vector<std::unique_ptr<jFEXTOB> > > > LVL1::jFEXSysSim::m_alltauTobs
private

Definition at line 107 of file jFEXSysSim.h.

◆ m_DBToolKey

SG::ReadCondHandleKey<jFEXDBCondData> LVL1::jFEXSysSim::m_DBToolKey {this, "DBToolKey", "jFEXDBParams", "DB tool key"}
private

Definition at line 76 of file jFEXSysSim.h.

76{this, "DBToolKey", "jFEXDBParams", "DB tool key"};

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

◆ m_jFEXCollection

std::vector<jFEXSim*> LVL1::jFEXSysSim::m_jFEXCollection
private

Internal data.

Definition at line 74 of file jFEXSysSim.h.

◆ m_jFEXSimTool

ToolHandle<IjFEXSim> LVL1::jFEXSysSim::m_jFEXSimTool {this, "jFEXSimTool", "LVL1::jFEXSim", "Tool that creates the jFEX Simulation"}
private

Definition at line 78 of file jFEXSysSim.h.

78{this, "jFEXSimTool", "LVL1::jFEXSim", "Tool that creates the jFEX Simulation"};

◆ m_jTowerContainerSGKey

SG::ReadHandleKey<LVL1::jTowerContainer> LVL1::jFEXSysSim::m_jTowerContainerSGKey {this, "MyETowers", "jTowerContainer", "Input container for jTowers"}
private

Definition at line 80 of file jFEXSysSim.h.

80{this, "MyETowers", "jTowerContainer", "Input container for jTowers"};

◆ m_jTowersColl

std::unordered_map<int,jTower> LVL1::jFEXSysSim::m_jTowersColl
private

Definition at line 103 of file jFEXSysSim.h.

◆ m_l1MenuKey

SG::ReadHandleKey<TrigConf::L1Menu> LVL1::jFEXSysSim::m_l1MenuKey {this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu","Name of the L1Menu object to read configuration from"}
private

Definition at line 82 of file jFEXSysSim.h.

82{this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu","Name of the L1Menu object to read configuration from"};

◆ m_TobDecorKey_jJ_seedET

SG::WriteDecorHandleKey<xAOD::jFexSRJetRoIContainer> LVL1::jFEXSysSim::m_TobDecorKey_jJ_seedET { this, "Key_tobDecor_jJ_seedET" , m_TobOutKey_jJ , "seedETMeV" , "jJet seed ET value in MeV" }
private

Definition at line 99 of file jFEXSysSim.h.

99{ this, "Key_tobDecor_jJ_seedET" , m_TobOutKey_jJ , "seedETMeV" , "jJet seed ET value in MeV" };

◆ m_TobOutKey_jEM

SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer> LVL1::jFEXSysSim::m_TobOutKey_jEM {this,"Key_jFexFwdElOutputContainer","L1_jFexFwdElRoI","Output jFexEDM fwdEl container"}
private

Definition at line 88 of file jFEXSysSim.h.

88{this,"Key_jFexFwdElOutputContainer","L1_jFexFwdElRoI","Output jFexEDM fwdEl container"};

◆ m_TobOutKey_jJ

SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer> LVL1::jFEXSysSim::m_TobOutKey_jJ {this,"Key_jFexSRJetOutputContainer","L1_jFexSRJetRoI","Output jFexEDM jets container"}
private

Definition at line 85 of file jFEXSysSim.h.

85{this,"Key_jFexSRJetOutputContainer","L1_jFexSRJetRoI","Output jFexEDM jets container"};

◆ m_TobOutKey_jLJ

SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer> LVL1::jFEXSysSim::m_TobOutKey_jLJ {this,"Key_jFexLRJetOutputContainer","L1_jFexLRJetRoI","Output jFexEDM Ljets container"}
private

Definition at line 86 of file jFEXSysSim.h.

86{this,"Key_jFexLRJetOutputContainer","L1_jFexLRJetRoI","Output jFexEDM Ljets container"};

◆ m_TobOutKey_jTau

SG::WriteHandleKey< xAOD::jFexTauRoIContainer> LVL1::jFEXSysSim::m_TobOutKey_jTau {this,"Key_jFexTauOutputContainer" ,"L1_jFexTauRoI" ,"Output jFexEDM tau container"}
private

Definition at line 87 of file jFEXSysSim.h.

87{this,"Key_jFexTauOutputContainer" ,"L1_jFexTauRoI" ,"Output jFexEDM tau container"};

◆ m_TobOutKey_jTE

SG::WriteHandleKey< xAOD::jFexSumETRoIContainer> LVL1::jFEXSysSim::m_TobOutKey_jTE {this,"Key_jFexSumETOutputContainer","L1_jFexSumETRoI","Output jFexEDM SumET container"}
private

Definition at line 89 of file jFEXSysSim.h.

89{this,"Key_jFexSumETOutputContainer","L1_jFexSumETRoI","Output jFexEDM SumET container"};

◆ m_TobOutKey_jXE

SG::WriteHandleKey< xAOD::jFexMETRoIContainer> LVL1::jFEXSysSim::m_TobOutKey_jXE {this,"Key_jFexMETOutputContainer" ,"L1_jFexMETRoI" ,"Output jFexEDM Met container"}
private

Definition at line 90 of file jFEXSysSim.h.

90{this,"Key_jFexMETOutputContainer" ,"L1_jFexMETRoI" ,"Output jFexEDM Met container"};

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_xTobDecorKey_jJ_seedET

SG::WriteDecorHandleKey<xAOD::jFexSRJetRoIContainer> LVL1::jFEXSysSim::m_xTobDecorKey_jJ_seedET { this, "Key_xTobDecor_jJ_seedET" , m_xTobOutKey_jJ , "seedETMeV" , "jJet seed ET value in MeV" }
private

Definition at line 100 of file jFEXSysSim.h.

100{ this, "Key_xTobDecor_jJ_seedET" , m_xTobOutKey_jJ , "seedETMeV" , "jJet seed ET value in MeV" };

◆ m_xTobOutKey_jEM

SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer> LVL1::jFEXSysSim::m_xTobOutKey_jEM {this,"Key_xTobOutKey_jEM" ,"L1_jFexFwdElxRoI","Output jFexEDM xTOBs fwdEl container"}
private

Definition at line 96 of file jFEXSysSim.h.

96{this,"Key_xTobOutKey_jEM" ,"L1_jFexFwdElxRoI","Output jFexEDM xTOBs fwdEl container"};

◆ m_xTobOutKey_jJ

SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer> LVL1::jFEXSysSim::m_xTobOutKey_jJ {this,"Key_xTobOutKey_jJ" ,"L1_jFexSRJetxRoI","Output jFexEDM xTOBs jets container"}
private

Definition at line 93 of file jFEXSysSim.h.

93{this,"Key_xTobOutKey_jJ" ,"L1_jFexSRJetxRoI","Output jFexEDM xTOBs jets container"};

◆ m_xTobOutKey_jLJ

SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer> LVL1::jFEXSysSim::m_xTobOutKey_jLJ {this,"Key_xTobOutKey_jLJ" ,"L1_jFexLRJetxRoI","Output jFexEDM xTOBs Ljets container"}
private

Definition at line 94 of file jFEXSysSim.h.

94{this,"Key_xTobOutKey_jLJ" ,"L1_jFexLRJetxRoI","Output jFexEDM xTOBs Ljets container"};

◆ m_xTobOutKey_jTau

SG::WriteHandleKey< xAOD::jFexTauRoIContainer> LVL1::jFEXSysSim::m_xTobOutKey_jTau {this,"Key_xTobOutKey_jTau" ,"L1_jFexTauxRoI" ,"Output jFexEDM xTOBs tau container"}
private

Definition at line 95 of file jFEXSysSim.h.

95{this,"Key_xTobOutKey_jTau" ,"L1_jFexTauxRoI" ,"Output jFexEDM xTOBs tau container"};
The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.16.1