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 (uint8_t jFexNum, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi, std::unique_ptr< xAOD::jFexSRJetRoIContainer > &jContainer) const
 
StatusCode fillLRJetEDM (uint8_t jFexNum, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi, std::unique_ptr< xAOD::jFexLRJetRoIContainer > &jContainer) const
 
StatusCode fillTauEDM (uint8_t jFexNum, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi, std::unique_ptr< 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, std::unique_ptr< xAOD::jFexFwdElRoIContainer > &jContainer) const
 
StatusCode fillSumEtEDM (uint8_t jFexNum, uint8_t fpgaNumber, uint32_t tobWord, int resolution, std::unique_ptr< xAOD::jFexSumETRoIContainer > &jContainer) const
 
StatusCode fillMetEDM (uint8_t jFexNum, uint8_t fpgaNumber, uint32_t tobWord, int resolution, std::unique_ptr< 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"}
 
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 55 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 113 of file jFEXSysSim.cxx.

113  {
114 
115  return ((64*eta) + phi + mod);
116  }

◆ cleanup()

void LVL1::jFEXSysSim::cleanup ( )
overridevirtual

Implements LVL1::IjFEXSysSim.

Definition at line 105 of file jFEXSysSim.cxx.

105  {
106 
107  m_jFEXCollection.clear();
108  m_jTowersColl.clear();
109 
110  }

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

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

◆ 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,
std::unique_ptr< xAOD::jFexFwdElRoIContainer > &  jContainer 
) const
private

Definition at line 1142 of file jFEXSysSim.cxx.

1142  {
1143 
1144  xAOD::jFexFwdElRoI* my_EDM = new xAOD::jFexFwdElRoI();
1145  jContainer->push_back( my_EDM );
1146 
1147  my_EDM->initialize(jFexNum, fpgaNumber, tobWord ,istob , resolution, eta, phi);
1148 
1149  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 );
1150 
1151  return StatusCode::SUCCESS;
1152  }

◆ fillLRJetEDM()

StatusCode LVL1::jFEXSysSim::fillLRJetEDM ( uint8_t  jFexNum,
uint8_t  fpgaNumber,
uint32_t  tobWord,
char  istob,
int  resolution,
float_t  eta,
float_t  phi,
std::unique_ptr< xAOD::jFexLRJetRoIContainer > &  jContainer 
) const
private

Definition at line 1154 of file jFEXSysSim.cxx.

1154  {
1155 
1156  xAOD::jFexLRJetRoI* my_EDM = new xAOD::jFexLRJetRoI();
1157  jContainer->push_back( my_EDM );
1158 
1159  my_EDM->initialize(jFexNum, fpgaNumber, tobWord ,istob , resolution, eta, phi);
1160 
1161  ATH_MSG_DEBUG(" setting LRJet jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1162 
1163  return StatusCode::SUCCESS;
1164  }

◆ fillMetEDM()

StatusCode LVL1::jFEXSysSim::fillMetEDM ( uint8_t  jFexNum,
uint8_t  fpgaNumber,
uint32_t  tobWord,
int  resolution,
std::unique_ptr< xAOD::jFexMETRoIContainer > &  jContainer 
) const
private

Definition at line 1178 of file jFEXSysSim.cxx.

1178  {
1179 
1180  xAOD::jFexMETRoI* my_EDM = new xAOD::jFexMETRoI();
1181  jContainer->push_back( my_EDM );
1182 
1183  my_EDM->initialize(jFexNum, fpgaNumber, tobWord, resolution);
1184 
1185  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() );
1186 
1187  return StatusCode::SUCCESS;
1188  }

◆ fillSRJetEDM()

StatusCode LVL1::jFEXSysSim::fillSRJetEDM ( uint8_t  jFexNum,
uint8_t  fpgaNumber,
uint32_t  tobWord,
char  istob,
int  resolution,
float_t  eta,
float_t  phi,
std::unique_ptr< xAOD::jFexSRJetRoIContainer > &  jContainer 
) const
private

Definition at line 1117 of file jFEXSysSim.cxx.

1117  {
1118 
1119  xAOD::jFexSRJetRoI* my_EDM = new xAOD::jFexSRJetRoI();
1120  jContainer->push_back( my_EDM );
1121 
1122  my_EDM->initialize(jFexNum, fpgaNumber, tobWord ,istob , resolution, eta, phi);
1123 
1124  ATH_MSG_DEBUG(" setting SRJet jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1125 
1126  return StatusCode::SUCCESS;
1127  }

◆ fillSumEtEDM()

StatusCode LVL1::jFEXSysSim::fillSumEtEDM ( uint8_t  jFexNum,
uint8_t  fpgaNumber,
uint32_t  tobWord,
int  resolution,
std::unique_ptr< xAOD::jFexSumETRoIContainer > &  jContainer 
) const
private

Definition at line 1166 of file jFEXSysSim.cxx.

1166  {
1167 
1168  xAOD::jFexSumETRoI* my_EDM = new xAOD::jFexSumETRoI();
1169  jContainer->push_back( my_EDM );
1170 
1171  my_EDM->initialize(jFexNum, fpgaNumber, tobWord, resolution);
1172 
1173  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());
1174 
1175  return StatusCode::SUCCESS;
1176  }

◆ fillTauEDM()

StatusCode LVL1::jFEXSysSim::fillTauEDM ( uint8_t  jFexNum,
uint8_t  fpgaNumber,
uint32_t  tobWord,
char  istob,
int  resolution,
float_t  eta,
float_t  phi,
std::unique_ptr< xAOD::jFexTauRoIContainer > &  jContainer 
) const
private

Definition at line 1130 of file jFEXSysSim.cxx.

1130  {
1131 
1132  xAOD::jFexTauRoI* my_EDM = new xAOD::jFexTauRoI();
1133  jContainer->push_back( my_EDM );
1134 
1135  my_EDM->initialize(jFexNum, fpgaNumber, tobWord ,istob , resolution, eta, phi);
1136 
1137  ATH_MSG_DEBUG(" setting tau jFEX Number: " << +my_EDM->jFexNumber() << " et: " << my_EDM->et() << " eta: " << my_EDM->eta() <<" / "<< eta << " phi: " << my_EDM->phi()<<" / "<< phi );
1138 
1139  return StatusCode::SUCCESS;
1140  }

◆ finalize()

StatusCode LVL1::jFEXSysSim::finalize ( )
overridevirtual

standard Athena-Algorithm method

Definition at line 95 of file jFEXSysSim.cxx.

96  {
97  return StatusCode::SUCCESS;
98  }

◆ init()

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

Implements LVL1::IjFEXSysSim.

Definition at line 101 of file jFEXSysSim.cxx.

101  {
102 
103  }

◆ 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  ATH_CHECK(m_l1MenuKey.initialize());
89 
90  return StatusCode::SUCCESS;
91  }

◆ 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 108 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 112 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 114 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 111 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 113 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 110 of file jFEXSysSim.h.

◆ m_DBToolKey

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

Definition at line 84 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 82 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 86 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 88 of file jFEXSysSim.h.

◆ m_jTowersColl

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

Definition at line 106 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 90 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 96 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 93 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 94 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 95 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 97 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 98 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_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 104 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 101 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 102 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 103 of file jFEXSysSim.h.

The documentation for this class was generated from the following files:
xAOD::jFexTauRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexTauRoI_v1.h:22
LVL1::jFEXSysSim::m_TobOutKey_jJ
SG::WriteHandleKey< xAOD::jFexSRJetRoIContainer > m_TobOutKey_jJ
Definition: jFEXSysSim.h:93
xAOD::jFexSRJetRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexSRJetRoI_v1.h:22
LVL1::jFEXSysSim::fillFwdElEDM
StatusCode fillFwdElEDM(uint8_t jFexNum, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi, std::unique_ptr< xAOD::jFexFwdElRoIContainer > &jContainer) const
Definition: jFEXSysSim.cxx:1142
LVL1::jFEXSysSim::m_allLargeRJetTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_allLargeRJetTobs
Definition: jFEXSysSim.h:112
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
xAOD::jFexTauRoI_v1::eta
float eta() const
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
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:575
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
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
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:111
LVL1::jFEXSysSim::fillSRJetEDM
StatusCode fillSRJetEDM(uint8_t jFexNum, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi, std::unique_ptr< xAOD::jFexSRJetRoIContainer > &jContainer) const
Definition: jFEXSysSim.cxx:1117
LVL1::jFEXSysSim::m_jFEXSimTool
ToolHandle< IjFEXSim > m_jFEXSimTool
Definition: jFEXSysSim.h:86
LVL1::jFEXSysSim::m_alltauTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::unique_ptr< jFEXTOB > > > > m_alltauTobs
Definition: jFEXSysSim.h:110
xAOD::jFexFwdElRoI_v1::jFexNumber
uint8_t jFexNumber() const
Additional info (initialization)
skel.it
it
Definition: skel.GENtoEVGEN.py:423
xAOD::jFexFwdElRoI_v1::phi
float phi() const
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:205
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:90
Dedxcorrection::resolution
double resolution[nGasTypes][nParametersResolution]
Definition: TRT_ToT_Corrections.h:46
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
LVL1::jFEXSysSim::m_TobOutKey_jEM
SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer > m_TobOutKey_jEM
Definition: jFEXSysSim.h:96
LVL1::jFEXSysSim::calcTowerID
virtual int calcTowerID(int eta, int phi, int mod) const override
Definition: jFEXSysSim.cxx:113
LVL1::jFEXSysSim::m_jTowersColl
std::unordered_map< int, jTower > m_jTowersColl
Definition: jFEXSysSim.h:106
xAOD::jFexMETRoI_v1::tobSat
uint8_t tobSat() const
LVL1::jFEXSysSim::fillLRJetEDM
StatusCode fillLRJetEDM(uint8_t jFexNum, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi, std::unique_ptr< xAOD::jFexLRJetRoIContainer > &jContainer) const
Definition: jFEXSysSim.cxx:1154
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:88
xAOD::jFexLRJetRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexLRJetRoI_v1.h:22
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:92
xAOD::jFexMETRoI_v1::tobEy
int tobEy() const
LVL1::jFEXSysSim::m_xTobOutKey_jEM
SG::WriteHandleKey< xAOD::jFexFwdElRoIContainer > m_xTobOutKey_jEM
Definition: jFEXSysSim.h:104
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::jFexMETRoI_v1::tobRes
uint8_t tobRes() const
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:114
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
LVL1::jFEXSysSim::fillSumEtEDM
StatusCode fillSumEtEDM(uint8_t jFexNum, uint8_t fpgaNumber, uint32_t tobWord, int resolution, std::unique_ptr< xAOD::jFexSumETRoIContainer > &jContainer) const
Definition: jFEXSysSim.cxx:1166
LVL1::jFEXSysSim::fillTauEDM
StatusCode fillTauEDM(uint8_t jFexNum, uint8_t fpgaNumber, uint32_t tobWord, char istob, int resolution, float_t eta, float_t phi, std::unique_ptr< xAOD::jFexTauRoIContainer > &jContainer) const
Definition: jFEXSysSim.cxx:1130
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:101
LVL1::jFEXSysSim::m_TobOutKey_jTE
SG::WriteHandleKey< xAOD::jFexSumETRoIContainer > m_TobOutKey_jTE
Definition: jFEXSysSim.h:97
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
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:102
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:192
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
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:82
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:98
LVL1::jFEXSysSim::m_TobOutKey_jLJ
SG::WriteHandleKey< xAOD::jFexLRJetRoIContainer > m_TobOutKey_jLJ
Definition: jFEXSysSim.h:94
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
a
TList * a
Definition: liststreamerinfos.cxx:10
h
LVL1::jFEXSysSim::m_allfwdElTobs
std::unordered_map< uint8_t, std::vector< std::vector< std::vector< uint32_t > > > > m_allfwdElTobs
Definition: jFEXSysSim.h:108
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:84
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
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
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
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::m_xTobOutKey_jTau
SG::WriteHandleKey< xAOD::jFexTauRoIContainer > m_xTobOutKey_jTau
Definition: jFEXSysSim.h:103
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:113
LVL1::jFEXSysSim::fillMetEDM
StatusCode fillMetEDM(uint8_t jFexNum, uint8_t fpgaNumber, uint32_t tobWord, int resolution, std::unique_ptr< xAOD::jFexMETRoIContainer > &jContainer) const
Definition: jFEXSysSim.cxx:1178
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:95
xAOD::jFexFwdElRoI_v1
Class describing properties of a LVL1 jFEX global Trigger Object (TOB) in the xAOD format.
Definition: jFexFwdElRoI_v1.h:22
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 Fri Jun 28 2024 22:20:32 for ATLAS Offline Software by   doxygen 1.8.18