ATLAS Offline Software
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:
Collaboration diagram for LVL1::jFEXSysSim:

Public Member Functions

 jFEXSysSim (const std::string &type, const std::string &name, const IInterface *parent)
 Constructors. More...
 
jFEXSysSim && operator= (const jFEXSysSim &)=delete
 Destructor. More...
 
virtual StatusCode initialize () override
 standard Athena-Algorithm method More...
 
virtual StatusCode finalize () override
 standard Athena-Algorithm method More...
 
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. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) 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 More...
 
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. More...
 

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 > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

std::vector< jFEXSim * > m_jFEXCollection
 Internal data. More...
 
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) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

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

Definition at line 56 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 51 of file jFEXSysSim.cxx.

51  :
52  AthAlgTool(type,name,parent)
53  {
54  declareInterface<IjFEXSysSim>(this);
55 
56  }

Member Function Documentation

◆ calcTowerID()

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

Implements LVL1::IjFEXSysSim.

Definition at line 117 of file jFEXSysSim.cxx.

117  {
118 
119  return ((64*eta) + phi + mod);
120  }

◆ cleanup()

void LVL1::jFEXSysSim::cleanup ( )
overridevirtual

Implements LVL1::IjFEXSysSim.

Definition at line 109 of file jFEXSysSim.cxx.

109  {
110 
111  m_jFEXCollection.clear();
112  m_jTowersColl.clear();
113 
114  }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  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  }

◆ 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() [1/2]

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; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

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

Implements LVL1::IjFEXSysSim.

Definition at line 122 of file jFEXSysSim.cxx.

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

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

1153  {
1154 
1155  xAOD::jFexFwdElRoI* my_EDM = new xAOD::jFexFwdElRoI();
1156  jContainer->push_back( my_EDM );
1157 
1158  my_EDM->initialize(jFexNum, fpgaNumber, tobWord ,istob , resolution, eta, phi);
1159 
1160  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 );
1161 
1162  return StatusCode::SUCCESS;
1163  }

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

1165  {
1166 
1167  xAOD::jFexLRJetRoI* my_EDM = new xAOD::jFexLRJetRoI();
1168  jContainer->push_back( my_EDM );
1169 
1170  my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), istob, internalTob->getRes(), eta, phi);
1171 
1172  ATH_MSG_DEBUG(" setting LRJet jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1173 
1174  return StatusCode::SUCCESS;
1175  }

◆ fillMetEDM()

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

Definition at line 1189 of file jFEXSysSim.cxx.

1189  {
1190 
1191  xAOD::jFexMETRoI* my_EDM = new xAOD::jFexMETRoI();
1192  jContainer->push_back( my_EDM );
1193 
1194  my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), internalTob->getRes());
1195 
1196  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() );
1197 
1198  return StatusCode::SUCCESS;
1199  }

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

1128  {
1129 
1130  xAOD::jFexSRJetRoI* my_EDM = new xAOD::jFexSRJetRoI();
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 SRJet 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  }

◆ fillSumEtEDM()

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

Definition at line 1177 of file jFEXSysSim.cxx.

1177  {
1178 
1179  xAOD::jFexSumETRoI* my_EDM = new xAOD::jFexSumETRoI();
1180  jContainer->push_back( my_EDM );
1181 
1182  my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), internalTob->getRes());
1183 
1184  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());
1185 
1186  return StatusCode::SUCCESS;
1187  }

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

1141  {
1142 
1143  xAOD::jFexTauRoI* my_EDM = new xAOD::jFexTauRoI();
1144  jContainer->push_back( my_EDM );
1145 
1146  my_EDM->initialize(internalTob->getjFex(), internalTob->getFpga(), internalTob->getWord(), istob, internalTob->getRes(), eta, phi);
1147 
1148  ATH_MSG_DEBUG(" setting tau jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1149 
1150  return StatusCode::SUCCESS;
1151  }

◆ finalize()

StatusCode LVL1::jFEXSysSim::finalize ( )
overridevirtual

standard Athena-Algorithm method

Definition at line 99 of file jFEXSysSim.cxx.

100  {
101  return StatusCode::SUCCESS;
102  }

◆ init()

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

Implements LVL1::IjFEXSysSim.

Definition at line 105 of file jFEXSysSim.cxx.

105  {
106 
107  }

◆ initialize()

StatusCode LVL1::jFEXSysSim::initialize ( )
overridevirtual

standard Athena-Algorithm method

Destructor.

Definition at line 66 of file jFEXSysSim.cxx.

67  {
68 
69  ATH_CHECK(m_jTowerContainerSGKey.initialize());
70 
71  ATH_CHECK( m_DBToolKey.initialize() );
72  ATH_CHECK(m_jFEXSimTool.retrieve() );
73 
74  // TOBs Key
75  ATH_CHECK(m_TobOutKey_jJ.initialize());
76  ATH_CHECK(m_TobOutKey_jLJ.initialize());
77  ATH_CHECK(m_TobOutKey_jTau.initialize());
78  ATH_CHECK(m_TobOutKey_jEM.initialize());
79  ATH_CHECK(m_TobOutKey_jTE.initialize());
80  ATH_CHECK(m_TobOutKey_jXE.initialize());
81 
82  // xTOBs Key
83  ATH_CHECK(m_xTobOutKey_jJ.initialize());
84  ATH_CHECK(m_xTobOutKey_jLJ.initialize());
85  ATH_CHECK(m_xTobOutKey_jTau.initialize());
86  ATH_CHECK(m_xTobOutKey_jEM.initialize());
87 
88  // Decorations
89  ATH_CHECK(m_TobDecorKey_jJ_seedET.initialize());
90  ATH_CHECK(m_xTobDecorKey_jJ_seedET.initialize());
91 
92  ATH_CHECK(m_l1MenuKey.initialize());
93 
94  return StatusCode::SUCCESS;
95  }

◆ 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  }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ 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  }

◆ 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ 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  }

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 115 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 119 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 121 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 118 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 120 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 117 of file jFEXSysSim.h.

◆ m_DBToolKey

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

Definition at line 85 of file jFEXSysSim.h.

◆ 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 83 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 87 of file jFEXSysSim.h.

◆ m_jTowerContainerSGKey

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

Definition at line 89 of file jFEXSysSim.h.

◆ m_jTowersColl

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

Definition at line 113 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 91 of file jFEXSysSim.h.

◆ 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 108 of file jFEXSysSim.h.

◆ 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 97 of file jFEXSysSim.h.

◆ 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 94 of file jFEXSysSim.h.

◆ 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 95 of file jFEXSysSim.h.

◆ 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 96 of file jFEXSysSim.h.

◆ 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 98 of file jFEXSysSim.h.

◆ 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 99 of file jFEXSysSim.h.

◆ 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 109 of file jFEXSysSim.h.

◆ 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 105 of file jFEXSysSim.h.

◆ 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 102 of file jFEXSysSim.h.

◆ 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 103 of file jFEXSysSim.h.

◆ 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 104 of file jFEXSysSim.h.

The documentation for this class was generated from the following files:
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:1165
xAOD::jFexTauRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexTauRoI_v1.h:23
test_pyathena.eta
eta
Definition: test_pyathena.py:10
LVL1::jFEXSysSim::m_TobOutKey_jJ
SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer > m_TobOutKey_jJ
Definition: jFEXSysSim.h:94
xAOD::jFexSRJetRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexSRJetRoI_v1.h:23
LVL1::jFEXSysSim::m_allLargeRJetTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_allLargeRJetTobs
Definition: jFEXSysSim.h:119
LVL1::jFEXSysSim::fillMetEDM
StatusCode fillMetEDM(const std::unique_ptr< jFEXTOB > &internalTob, SG::WriteHandle< xAOD::jFexMETRoIContainer > &jContainer) const
Definition: jFEXSysSim.cxx:1189
xAOD::jFexTauRoI_v1::eta
float eta() const
xAOD::jFexTauRoI_v1::jFexNumber
uint8_t jFexNumber() const
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
LVL1::jTower::iEta
int iEta() const
Get coordinates of tower.
Definition: jTower.cxx:169
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
xAOD::jFexLRJetRoI_v1::eta
float eta() const
LVL1::FEXAlgoSpaceDefs::jFEX_thin_algoSpace_width
constexpr static int jFEX_thin_algoSpace_width
Definition: FEXAlgoSpaceDefs.h:26
xAOD::jFexLRJetRoI
jFexLRJetRoI_v1 jFexLRJetRoI
Define the latest version of the jFexLRJetRoI class
Definition: jFexLRJetRoI.h:13
SG::ReadHandle< LVL1::jTowerContainer >
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
xAOD::jFexFwdElRoI_v1::eta
float eta() const
LVL1::jFEXSysSim::m_allSmallRJetTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_allSmallRJetTobs
Definition: jFEXSysSim.h:118
LVL1::jFEXSysSim::m_jFEXSimTool
ToolHandle< IjFEXSim > m_jFEXSimTool
Definition: jFEXSysSim.h:87
LVL1::jFEXSysSim::m_alltauTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_alltauTobs
Definition: jFEXSysSim.h:117
xAOD::jFexFwdElRoI_v1::jFexNumber
uint8_t jFexNumber() const
Additional info (initialization)
skel.it
it
Definition: skel.GENtoEVGEN.py:396
xAOD::jFexFwdElRoI_v1::phi
float phi() const
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:206
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
xAOD::jFexLRJetRoI_v1::jFexNumber
uint8_t jFexNumber() const
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
xAOD::jFexLRJetRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition: jFexLRJetRoI_v1.cxx:139
xAOD::jFexSRJetRoI_v1::eta
float eta() const
xAOD::jFexSRJetRoI_v1::phi
float phi() const
LVL1::FEXAlgoSpaceDefs::jFEX_algoSpace_height
constexpr static int jFEX_algoSpace_height
Definition: FEXAlgoSpaceDefs.h:27
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
xAOD::jFexMETRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, int resolution)
In future initialze the xTOB as well, word1.
Definition: jFexMETRoI_v1.cxx:20
xAOD::jFexTauRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition: jFexTauRoI_v1.cxx:114
LVL1::jFEXSysSim::m_l1MenuKey
SG::ReadHandleKey< TrigConf::L1Menu > m_l1MenuKey
Definition: jFEXSysSim.h:91
Dedxcorrection::resolution
double resolution[nGasTypes][nParametersResolution]
Definition: TRT_ToT_Corrections.h:46
LVL1::jFEXSysSim::m_xTobDecorKey_jJ_seedET
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_xTobDecorKey_jJ_seedET
Definition: jFEXSysSim.h:109
xAOD::jFexMETRoI_v1::jFexNumber
uint8_t jFexNumber() const
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
xAOD::jFexMETRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexMETRoI_v1.h:22
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
xAOD::phi
setEt phi
Definition: TrigEMCluster_v1.cxx:29
LVL1::jFEXSysSim::m_TobOutKey_jEM
SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer > m_TobOutKey_jEM
Definition: jFEXSysSim.h:97
LVL1::jFEXSysSim::calcTowerID
virtual int calcTowerID(int eta, int phi, int mod) const override
Definition: jFEXSysSim.cxx:117
LVL1::jFEXSysSim::m_jTowersColl
std::unordered_map< int, jTower > m_jTowersColl
Definition: jFEXSysSim.h:113
xAOD::jFexMETRoI_v1::tobSat
uint8_t tobSat() 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
beamspotnt.cols
list cols
Definition: bin/beamspotnt.py:1114
LVL1::jFEXSysSim::m_jTowerContainerSGKey
SG::ReadHandleKey< LVL1::jTowerContainer > m_jTowerContainerSGKey
Definition: jFEXSysSim.h:89
xAOD::jFexLRJetRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexLRJetRoI_v1.h:23
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::jFexSumETRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, int resolution)
In future initialze the xTOB as well, word1.
Definition: jFexSumETRoI_v1.cxx:20
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
xAOD::jFexLRJetRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi)
In future initialze the EDM.
Definition: jFexLRJetRoI_v1.cxx:40
lumiFormat.i
int i
Definition: lumiFormat.py:85
xAOD::jFexMETRoI_v1::tobEy
int tobEy() const
LVL1::jFEXSysSim::m_xTobOutKey_jEM
SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer > m_xTobOutKey_jEM
Definition: jFEXSysSim.h:105
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::jFexMETRoI_v1::tobRes
uint8_t tobRes() const
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:100
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:1128
LVL1::FEXAlgoSpaceDefs::jFEX_wide_algoSpace_width
constexpr static int jFEX_wide_algoSpace_width
Definition: FEXAlgoSpaceDefs.h:25
xAOD::jFexMETRoI_v1::tobEx
int tobEx() const
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::jFexSRJetRoI
jFexSRJetRoI_v1 jFexSRJetRoI
Define the latest version of the jFexSRJetRoI class
Definition: jFexSRJetRoI.h:14
LVL1::jTower::iPhi
int iPhi() const
Return global phi index.
Definition: jTower.cxx:174
xAOD::jFexTauRoI_v1::phi
float phi() const
LVL1::jFEXSysSim::m_allMetTobs
std::unordered_map< uint8_t, std::vector< std::unique_ptr< jFEXTOB > > > m_allMetTobs
Definition: jFEXSysSim.h:121
beamspotnt.rows
list rows
Definition: bin/beamspotnt.py:1112
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
xAOD::jFexSumETRoI_v1::tobSat_lower
uint8_t tobSat_lower() const
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
LVL1::jFEXSysSim::m_xTobOutKey_jJ
SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer > m_xTobOutKey_jJ
Definition: jFEXSysSim.h:102
LVL1::jFEXSysSim::m_TobOutKey_jTE
SG::WriteHandleKey< xAOD::jFexSumETRoIContainer > m_TobOutKey_jTE
Definition: jFEXSysSim.h:98
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
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:1141
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
LVL1::jFEXSysSim::m_xTobOutKey_jLJ
SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer > m_xTobOutKey_jLJ
Definition: jFEXSysSim.h:103
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
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
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
xAOD::jFexSumETRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexSumETRoI_v1.h:22
LVL1::jFEXSysSim::fillSumEtEDM
StatusCode fillSumEtEDM(const std::unique_ptr< jFEXTOB > &internalTob, SG::WriteHandle< xAOD::jFexSumETRoIContainer > &jContainer) const
Definition: jFEXSysSim.cxx:1177
xAOD::jFexFwdElRoI
jFexFwdElRoI_v1 jFexFwdElRoI
Define the latest version of the jFexFwdElJetRoI class
Definition: jFexFwdElRoI.h:13
xAOD::jFexFwdElRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition: jFexFwdElRoI_v1.cxx:151
LVL1::jFEXSysSim::m_jFEXCollection
std::vector< jFEXSim * > m_jFEXCollection
Internal data.
Definition: jFEXSysSim.h:83
xAOD::jFexSRJetRoI_v1::initialize
void initialize(uint8_t jFexNumber, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi)
In future initialze the EDM.
Definition: jFexSRJetRoI_v1.cxx:38
xAOD::jFexSumETRoI_v1::jFexNumber
uint8_t jFexNumber() const
xAOD::jFexSumETRoI_v1::tobEt_upper
uint16_t tobEt_upper() const
LVL1::jFEXSysSim::m_TobOutKey_jXE
SG::WriteHandleKey< xAOD::jFexMETRoIContainer > m_TobOutKey_jXE
Definition: jFEXSysSim.h:99
LVL1::jFEXSysSim::m_TobOutKey_jLJ
SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer > m_TobOutKey_jLJ
Definition: jFEXSysSim.h:95
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
a
TList * a
Definition: liststreamerinfos.cxx:10
h
LVL1::jFEXSysSim::m_TobDecorKey_jJ_seedET
SG::WriteDecorHandleKey< xAOD::jFexSRJetRoIContainer > m_TobDecorKey_jJ_seedET
Definition: jFEXSysSim.h:108
LVL1::jFEXSysSim::m_allfwdElTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::vector< uint32_t > > > > m_allfwdElTobs
Definition: jFEXSysSim.h:115
xAOD::jFexLRJetRoI_v1::phi
float phi() const
xAOD::jFexMETRoI
jFexMETRoI_v1 jFexMETRoI
Define the latest version of the jFexMETRoI class
Definition: jFexMETRoI.h:13
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
DEBUG
#define DEBUG
Definition: page_access.h:11
LVL1::jFEXSysSim::m_DBToolKey
SG::ReadCondHandleKey< jFEXDBCondData > m_DBToolKey
Definition: jFEXSysSim.h:85
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
LVL1::jTower
The jTower class is an interface object for jFEX trigger algorithms The purposes are twofold:
Definition: jTower.h:40
xAOD::jFexTauRoI
jFexTauRoI_v1 jFexTauRoI
Define the latest version of the jFexSRJetRoI class
Definition: jFexTauRoI.h:13
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
xAOD::jFexSumETRoI
jFexSumETRoI_v1 jFexSumETRoI
Define the latest version of the jFexSumETJetRoI class
Definition: jFexSumETRoI.h:13
xAOD::jFexSRJetRoI_v1::jFexNumber
uint8_t jFexNumber() const
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:1153
LVL1::jFEXSysSim::m_xTobOutKey_jTau
SG::WriteHandleKey< xAOD::jFexTauRoIContainer > m_xTobOutKey_jTau
Definition: jFEXSysSim.h:104
xAOD::jFexSumETRoI_v1::tobSat_upper
uint8_t tobSat_upper() const
LVL1::jFEXSysSim::m_allsumEtTobs
std::unordered_map< uint8_t, std::vector< std::unique_ptr< jFEXTOB > > > m_allsumEtTobs
Definition: jFEXSysSim.h:120
value_type
Definition: EDM_MasterSearch.h:11
xAOD::jFexSumETRoI_v1::tobEt_lower
uint16_t tobEt_lower() const
LVL1::jFEXSysSim::m_TobOutKey_jTau
SG::WriteHandleKey< xAOD::jFexTauRoIContainer > m_TobOutKey_jTau
Definition: jFEXSysSim.h:96
xAOD::jFexFwdElRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexFwdElRoI_v1.h:23
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
fitman.k
k
Definition: fitman.py:528
xAOD::jFexSRJetRoI_v1::et
unsigned int et() const
Methods that require combining results or applying scales.
Definition: jFexSRJetRoI_v1.cxx:138
Generated on Sun Dec 22 2024 22:02:16 for ATLAS Offline Software by   doxygen 1.8.18