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

◆ 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 1140 of file jFEXSysSim.cxx.

1140 {
1141
1142 xAOD::jFexFwdElRoI* my_EDM = new xAOD::jFexFwdElRoI();
1143 jContainer->push_back( my_EDM );
1144
1145 my_EDM->initialize(jFexNum, fpgaNumber, tobWord ,istob , resolution, eta, phi);
1146
1147 ATH_MSG_DEBUG(" setting Forward Elec jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1148
1149 return StatusCode::SUCCESS;
1150 }
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 1152 of file jFEXSysSim.cxx.

1152 {
1153
1154 xAOD::jFexLRJetRoI* my_EDM = new xAOD::jFexLRJetRoI();
1155 jContainer->push_back( my_EDM );
1156
1157 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), istob, internalTob->getRes(), eta, phi);
1158
1159 ATH_MSG_DEBUG(" setting LRJet jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1160
1161 return StatusCode::SUCCESS;
1162 }
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 1176 of file jFEXSysSim.cxx.

1176 {
1177
1178 xAOD::jFexMETRoI* my_EDM = new xAOD::jFexMETRoI();
1179 jContainer->push_back( my_EDM );
1180
1181 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), internalTob->getRes());
1182
1183 ATH_MSG_DEBUG(" setting MET jFEX Number: " << +my_EDM->jFexNumber() << " Et_x: " << my_EDM->tobEx() << " Et_y: " << my_EDM->tobEy() << " sat: " << my_EDM->tobSat()<< " res: " << my_EDM->tobRes() );
1184
1185 return StatusCode::SUCCESS;
1186 }
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 1115 of file jFEXSysSim.cxx.

1115 {
1116
1117 xAOD::jFexSRJetRoI* my_EDM = new xAOD::jFexSRJetRoI();
1118 jContainer->push_back( my_EDM );
1119
1120 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), istob, internalTob->getRes(), eta, phi);
1121
1122 ATH_MSG_DEBUG(" setting SRJet jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1123
1124 return StatusCode::SUCCESS;
1125 }
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 1164 of file jFEXSysSim.cxx.

1164 {
1165
1166 xAOD::jFexSumETRoI* my_EDM = new xAOD::jFexSumETRoI();
1167 jContainer->push_back( my_EDM );
1168
1169 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), internalTob->getRes());
1170
1171 ATH_MSG_DEBUG(" setting SumET jFEX Number: " << +my_EDM->jFexNumber() << " Et_up: " << my_EDM->tobEt_upper() << " Et_down: " << my_EDM->tobEt_lower() << " sat_up: " << my_EDM->tobSat_upper()<< " sat_low: " << my_EDM->tobSat_lower());
1172
1173 return StatusCode::SUCCESS;
1174 }
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 1128 of file jFEXSysSim.cxx.

1128 {
1129
1130 xAOD::jFexTauRoI* my_EDM = new xAOD::jFexTauRoI();
1131 jContainer->push_back( my_EDM );
1132
1133 my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), istob, internalTob->getRes(), eta, phi);
1134
1135 ATH_MSG_DEBUG(" setting tau jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1136
1137 return StatusCode::SUCCESS;
1138 }
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.14.0