Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
LVL1::eFEXSysSim Class Reference

The eFEXSysSim class defines the structure of the eFEX system Its purpose is: More...

#include <eFEXSysSim.h>

Inheritance diagram for LVL1::eFEXSysSim:
Collaboration diagram for LVL1::eFEXSysSim:

Public Member Functions

 eFEXSysSim (const std::string &type, const std::string &name, const IInterface *parent)
 Constructors. More...
 
eFEXSysSim && operator= (const eFEXSysSim &)=delete
 Destructor. More...
 
virtual StatusCode initialize () override
 standard Athena-Algorithm method More...
 
virtual StatusCode execute (eFEXOutputCollection *inputOutputCollection) 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 StoreTauTOBs (std::map< int, std::vector< std::unique_ptr< eFEXtauTOB >> > &allTauTobObjects, SG::WriteHandleKey< xAOD::eFexTauRoIContainer > &eFexTauxTOBOutKey, SG::WriteHandleKey< xAOD::eFexTauRoIContainer > &eFexTauOutKey)
 
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...
 

Static Private Member Functions

template<class TOBObjectClass >
static bool TOBetSort (const TOBObjectClass &i, const TOBObjectClass &j, bool isTau)
 Internal data. More...
 

Private Attributes

ToolHandle< IeFEXSim > m_eFEXSimTool {this, "eFEXSimTool", "LVL1::eFEXSim", "Tool that creates the eFEX Simulation"}
 
ToolHandle< IeFEXFillEDM > m_eFEXFillEDMTool {this, "eFEXFillEDMTool", "LVL1::eFEXFillEDM", "Tool to fille eFEX EDMs"}
 
SG::ReadHandleKey< LVL1::eTowerContainer > m_eTowerContainerSGKey {this, "MyETowers", "eTowerContainer", "Input container for eTowers"}
 
SG::ReadHandleKey< TrigConf::L1Menu > m_l1MenuKey {this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu","Name of the L1Menu object to read configuration from"}
 
SG::WriteHandleKey< xAOD::eFexEMRoIContainer > m_eFexOutKey {this,"Key_eFexEMOutputContainer","L1_eEMRoI","Output eFexEM TOB container"}
 
SG::WriteHandleKey< xAOD::eFexEMRoIContainer > m_eFexEMxTOBOutKey {this,"Key_eFexEMxTOBOutputContainer","L1_eEMxRoI","Output eFexEM xTOB container"}
 
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauActiveOutKey {this,"Key_eFexTauOutputContainer","L1_eTauRoI","Output eFexTau active (BDT/heuristic) algorithm TOB container"}
 
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauActivexTOBOutKey {this,"Key_eFexTauxTOBOutputContainer","L1_eTauxRoI","Output eFexTau active (BDT/heuristic) algorithm xTOB container"}
 
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauAltOutKey {this,"Key_eFexAltTauOutputContainer","","Output eFexTau alternative (BDT/heuristic) algorithm TOB container"}
 
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauAltxTOBOutKey {this,"Key_eFexAltTauxTOBOutputContainer","","Output eFexTau alternative (BDT/heuristic) algorithm xTOB container"}
 
ToolHandle< IeFEXFPGATowerIdProvider > m_eFEXFPGATowerIdProviderTool {this, "eFEXFPGATowerIdProviderTool", "LVL1::eFEXFPGATowerIdProvider", "Tool that provides tower-FPGA mapping"}
 
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 eFEXSysSim class defines the structure of the eFEX system Its purpose is:

Definition at line 42 of file eFEXSysSim.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

◆ eFEXSysSim()

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

Constructors.

Definition at line 37 of file eFEXSysSim.cxx.

37  :
38  AthAlgTool(type,name,parent)
39  {
40  declareInterface<IeFEXSysSim>(this);
41 
42  }

Member Function Documentation

◆ calcTowerID()

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

Implements LVL1::IeFEXSysSim.

Definition at line 74 of file eFEXSysSim.cxx.

74  {
75 
76  return ((64*eta) + phi + mod);
77  }

◆ 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::eFEXSysSim::execute ( eFEXOutputCollection *  inputOutputCollection)
overridevirtual

Implements LVL1::IeFEXSysSim.

Definition at line 79 of file eFEXSysSim.cxx.

79  {
80 
81  SG::ReadHandle<LVL1::eTowerContainer> this_eTowerContainer(m_eTowerContainerSGKey/*,ctx*/);
82  if(!this_eTowerContainer.isValid()){
83  ATH_MSG_FATAL("Could not retrieve eTowerContainer " << m_eTowerContainerSGKey.key());
84  return StatusCode::FAILURE;
85  }
86 
87  // remove TOBs of the previous events from the map
88  std::map<int, std::vector<std::unique_ptr<eFEXegTOB>> > allEmTobObjects;
89  std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> > allTauHeuristicTobObjects;
90  std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> > allTauBDTTobObjects;
91 
92  // do mapping with preloaded csv file if it is available
93  if (m_eFEXFPGATowerIdProviderTool->ifhaveinputfile()) {
94  int tmp_eTowersIDs_subset_eFEX[10][18];
95  for (int i_efex{ 0 }; i_efex < 24; i_efex++) {
96  ATH_CHECK(m_eFEXFPGATowerIdProviderTool->getRankedTowerIDineFEX(i_efex, tmp_eTowersIDs_subset_eFEX));
97  m_eFEXSimTool->init(i_efex);
98  ATH_CHECK(m_eFEXSimTool->NewExecute(tmp_eTowersIDs_subset_eFEX, inputOutputCollection));
99  // Get TOBs from this eFEX
100  allEmTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXegTOB>> >::value_type(i_efex, m_eFEXSimTool->getEmTOBs() ));
101  allTauHeuristicTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(i_efex, m_eFEXSimTool->getTauHeuristicTOBs() ));
102  allTauBDTTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(i_efex, m_eFEXSimTool->getTauBDTTOBs() ));
103  m_eFEXSimTool->reset();
104  }
105  } else {
106  // We need to split the towers into 3 blocks in eta and 8 blocks in phi.
107 
108  // boundaries in eta: -2.5, -0.8, 0.8, 2.5
109  // REAL boundaries in eta (overlaps must occur for sliding window algorithms!): -2.5, -0.7, -0.9, 0.9, 0.7, 2.5
110  // Written explicitly:
111  // -2.5 -> -0.7
112  // -0.9 -> 0.9
113  // 0.7 -> 2.5
114 
115  // boundaries in phi: 0.2, 1.0, 1.8, 2.6, 3.4, 4.2, 5.0, 5.8
116  // Written explicitly with REAL boundaries in phi (overlaps must occur for sliding window algorithms!)
117  // 0.1 -> 1.1
118  // 0.9 -> 1.9
119  // 1.7 -> 2.7
120  // 2.5 -> 3.5
121  // 3.3 -> 4.3
122  // 4.1 -> 5.1
123  // 4.9 -> 5.9
124  // 5.7 -> 0.3
125 
126  // C-SIDE NEGATIVE EFEXs
127  // DO THE LEFT-MOST (NEGATIVE ETA) EFEXs FIRST
128  int fexcounter = 0;
129  // Example values for eFEX 0
130  //id_modifier + phi + (64 * eta)
131  int emecEta = 24; int emecPhi = 1; int emecMod = 500000;
132  int initialEMEC = calcTowerID(emecEta,emecPhi,emecMod); //501537;
133  int transEta = 14; int transPhi = 1; int transMod = 300000;
134  int initialTRANS = calcTowerID(transEta,transPhi,transMod); //300897;
135  int embEta = 13; int embPhi = 1; int embMod = 100000;
136  int initialEMB = calcTowerID(embEta,embPhi,embMod); //100833;
137  int eFEXa = 0;
138 
139  for (int thisEFEX=eFEXa; thisEFEX<=21; thisEFEX+=3){
140 
141  if(fexcounter > 0){ initialEMEC += 8; initialTRANS += 8; initialEMB += 8; } // TODO // SOMEHOW REMOVE HARD-CODING?
142 
143  // decide which subset of towers (and therefore supercells) should go to the eFEX
144  std::map<int,eTower> tmp_eTowersColl_subset;
145 
146  // let's try doing this with an array initially just containing tower IDs.
147  int tmp_eTowersIDs_subset [10][18];
148 
149  int rows = sizeof tmp_eTowersIDs_subset / sizeof tmp_eTowersIDs_subset[0];
150  int cols = sizeof tmp_eTowersIDs_subset[0] / sizeof tmp_eTowersIDs_subset[0][0];
151 
152  // set the EMEC part
153  for(int thisCol=0; thisCol<10; thisCol++){
154  for(int thisRow=0; thisRow<rows; thisRow++){
155 
156  int towerid = initialEMEC - (thisCol * 64) + thisRow;
157 
158  if( (thisEFEX == 21) && (thisRow >= 7)){ towerid -= 64; };
159 
160  tmp_eTowersIDs_subset[thisRow][thisCol] = towerid;
161  tmp_eTowersColl_subset.insert( std::map<int, eTower>::value_type(towerid, *(this_eTowerContainer->findTower(towerid))));
162 
163  }
164  }
165 
166  // set the TRANS part
167  for(int thisRow = 0; thisRow < rows; thisRow++){
168 
169  int towerid = initialTRANS + thisRow;
170 
171  if( (thisEFEX == 21) && (thisRow >= 7)){ towerid -= 64; };
172 
173  tmp_eTowersIDs_subset[thisRow][10] = towerid;
174  tmp_eTowersColl_subset.insert( std::map<int, eTower>::value_type(towerid, *(this_eTowerContainer->findTower(towerid))));
175 
176  }
177 
178  // set the EMB part
179  for(int thisCol = 11; thisCol < cols; thisCol++){
180  for(int thisRow=0; thisRow<rows; thisRow++){
181 
182  int towerid = initialEMB - ( (thisCol-11) * 64) + thisRow;
183 
184  if( (thisEFEX == 21) && (thisRow >= 7)){ towerid -= 64; };
185 
186  tmp_eTowersIDs_subset[thisRow][thisCol] = towerid;
187  tmp_eTowersColl_subset.insert( std::map<int, eTower>::value_type(towerid, *(this_eTowerContainer->findTower(towerid))));
188 
189  }
190  }
191 
192 
193  if(false){
194  ATH_MSG_DEBUG("CONTENTS OF eFEX " << thisEFEX << " :");
195  for (int thisRow=rows-1; thisRow>=0; thisRow--){
196  for (int thisCol=0; thisCol<cols; thisCol++){
197  int tmptowerid = tmp_eTowersIDs_subset[thisRow][thisCol];
198  const float tmptowereta = this_eTowerContainer->findTower(tmptowerid)->eta();
199  const float tmptowerphi = this_eTowerContainer->findTower(tmptowerid)->phi();
200  if(thisCol != cols-1){ ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowerphi << "][" << tmptowereta << "]) "); }
201  else { ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) |"); }
202  }
203  }
204  }
205 
206 
207  m_eFEXSimTool->init(thisEFEX);
208  ATH_CHECK(m_eFEXSimTool->NewExecute(tmp_eTowersIDs_subset, inputOutputCollection));
209  allEmTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXegTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getEmTOBs() ) ));
210  allTauHeuristicTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getTauHeuristicTOBs() ) ));
211  allTauBDTTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getTauBDTTOBs() ) ));
212  m_eFEXSimTool->reset();
213 
214  fexcounter++;
215  }
216 
217  // CENTRAL EFEXs
218  // DO THE CENTRAL EFEXs SECOND
219  fexcounter = 0;
220  int embnegEta = 8; int embnegPhi = 1; int embnegMod = 100000;
221  int initialEMB_neg = calcTowerID(embnegEta,embnegPhi,embnegMod); //100513;
222  int embposEta = 0; int embposPhi = 1; int embposMod = 200000;
223  int initialEMB_pos = calcTowerID(embposEta,embposPhi,embposMod); //200001;
224  int eFEXb = 1;
225 
226  for (int thisEFEX=eFEXb; thisEFEX<=22; thisEFEX+=3){
227 
228  if(fexcounter > 0){ initialEMB_neg += 8; initialEMB_pos += 8; }
229 
230  // decide which subset of towers (and therefore supercells) should go to the eFEX
231  std::map<int,eTower> tmp_eTowersColl_subset;
232 
233  // doing this with an array initially just containing tower IDs.
234  int tmp_eTowersIDs_subset [10][18];
235 
236  int rows = sizeof tmp_eTowersIDs_subset / sizeof tmp_eTowersIDs_subset[0];
237  int cols = sizeof tmp_eTowersIDs_subset[0] / sizeof tmp_eTowersIDs_subset[0][0];
238 
239  // set the EMB part
240  for(int thisCol = 0; thisCol < cols; thisCol++){
241  for(int thisRow=0; thisRow<rows; thisRow++){
242  int towerid = -1;
243 
244  int tmp_initEMB = initialEMB_neg;
245 
246  if(thisCol < 9){
247  towerid = tmp_initEMB - ( (thisCol) * 64) + thisRow;
248  }
249  else{
250  tmp_initEMB = initialEMB_pos;
251  towerid = tmp_initEMB + ( (thisCol-9) * 64) + thisRow;
252  }
253 
254  if( (thisEFEX == 22) && (thisRow >= 7)){ towerid -= 64; };
255 
256  tmp_eTowersIDs_subset[thisRow][thisCol] = towerid;
257 
258  tmp_eTowersColl_subset.insert( std::map<int, eTower>::value_type(towerid, *(this_eTowerContainer->findTower(towerid))));
259  }
260  }
261 
262 
263  if(false){
264  ATH_MSG_DEBUG("CONTENTS OF eFEX " << thisEFEX << " :");
265  for (int thisRow=rows-1; thisRow>=0; thisRow--){
266  for (int thisCol=0; thisCol<cols; thisCol++){
267  int tmptowerid = tmp_eTowersIDs_subset[thisRow][thisCol];
268  const float tmptowereta = this_eTowerContainer->findTower(tmptowerid)->eta();
269  const float tmptowerphi = this_eTowerContainer->findTower(tmptowerid)->phi();
270  if(thisCol != cols-1){ ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) "); }
271  else { ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) |"); }
272  }
273  }
274  }
275 
276  //tool use instead
277  m_eFEXSimTool->init(thisEFEX);
278  ATH_CHECK(m_eFEXSimTool->NewExecute(tmp_eTowersIDs_subset, inputOutputCollection));
279  allEmTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXegTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getEmTOBs() ) ));
280  allTauHeuristicTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getTauHeuristicTOBs() ) ));
281  allTauBDTTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getTauBDTTOBs() ) ));
282  m_eFEXSimTool->reset();
283 
284  fexcounter++;
285  }
286 
287  // POSITIVE EFEXs
288  // LET'S DO THE RIGHT-MOST (POSTITIVE ETA) EFEXs THIRD
289  fexcounter = 0;
290  // Example values for eFEX 0
291  emecEta = 15; emecPhi = 1; emecMod = 600000;
292  initialEMEC = calcTowerID(emecEta,emecPhi,emecMod); //600961;
293  transEta = 14; transPhi = 1; transMod = 400000;
294  initialTRANS = calcTowerID(transEta,transPhi,transMod); //400897;
295  embEta = 7; embPhi = 1; embMod = 200000;
296  initialEMB = calcTowerID(embEta,embPhi,embMod); //200449;
297  int eFEXc = 2;
298 
299  for (int thisEFEX=eFEXc; thisEFEX<=23; thisEFEX+=3){
300 
301  if(fexcounter > 0){ initialEMEC += 8; initialTRANS += 8; initialEMB += 8; }
302 
303  // decide which subset of towers (and therefore supercells) should go to the eFEX
304  std::map<int,eTower> tmp_eTowersColl_subset;
305 
306  // doing this with an array initially just containing tower IDs.
307  int tmp_eTowersIDs_subset [10][18];
308 
309  int rows = sizeof tmp_eTowersIDs_subset / sizeof tmp_eTowersIDs_subset[0];
310  int cols = sizeof tmp_eTowersIDs_subset[0] / sizeof tmp_eTowersIDs_subset[0][0];
311 
312  // set the EMB part
313  for(int thisCol = 0; thisCol < 7; thisCol++){
314  for(int thisRow=0; thisRow<rows; thisRow++){
315  int towerid = initialEMB + ( (thisCol) * 64) + thisRow;
316 
317  if( (thisEFEX == 23) && (thisRow >= 7)){ towerid -= 64; };
318 
319  tmp_eTowersIDs_subset[thisRow][thisCol] = towerid;
320  tmp_eTowersColl_subset.insert( std::map<int, eTower>::value_type(towerid, *(this_eTowerContainer->findTower(towerid))));
321  }
322  }
323  // set the TRANS part
324  for(int thisRow = 0; thisRow < rows; thisRow++){
325  int towerid = initialTRANS + thisRow;
326 
327  if( (thisEFEX == 23) && (thisRow >= 7)){ towerid -= 64; };
328 
329  tmp_eTowersIDs_subset[thisRow][7] = towerid;
330  tmp_eTowersColl_subset.insert( std::map<int, eTower>::value_type(towerid, *(this_eTowerContainer->findTower(towerid))));
331  }
332  // set the EMEC part
333  for(int thisCol=8; thisCol<cols; thisCol++){
334  for(int thisRow=0; thisRow<rows; thisRow++){
335  int towerid = initialEMEC + ( (thisCol-8) * 64) + thisRow;
336 
337  if( (thisEFEX == 23) && (thisRow >= 7)){ towerid -= 64; };
338 
339  tmp_eTowersIDs_subset[thisRow][thisCol] = towerid;
340  tmp_eTowersColl_subset.insert( std::map<int, eTower>::value_type(towerid, *(this_eTowerContainer->findTower(towerid))));
341  }
342  }
343 
344  // Debug printout
345  if(false){
346  ATH_MSG_DEBUG("CONTENTS OF eFEX " << thisEFEX << " :");
347  for (int thisRow=rows-1; thisRow>=0; thisRow--){
348  for (int thisCol=0; thisCol<cols; thisCol++){
349  int tmptowerid = tmp_eTowersIDs_subset[thisRow][thisCol];
350  const float tmptowereta = this_eTowerContainer->findTower(tmptowerid)->eta();
351  const float tmptowerphi = this_eTowerContainer->findTower(tmptowerid)->phi();
352  if(thisCol != cols-1){ ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) "); }
353  else { ATH_MSG_DEBUG("| " << tmptowerid << "([" << tmptowereta << "][" << tmptowerphi << "]) |"); }
354  }
355  }
356  }
357 
358  //tool use instead
359  m_eFEXSimTool->init(thisEFEX);
360  ATH_CHECK(m_eFEXSimTool->NewExecute(tmp_eTowersIDs_subset, inputOutputCollection));
361  allEmTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXegTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getEmTOBs() ) ));
362  allTauHeuristicTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getTauHeuristicTOBs() ) ));
363  allTauBDTTobObjects.insert( std::map<int, std::vector<std::unique_ptr<eFEXtauTOB>> >::value_type(thisEFEX, (m_eFEXSimTool->getTauBDTTOBs() ) ));
364  m_eFEXSimTool->reset();
365 
366  fexcounter++;
367  }
368 
369  }//close the non-csv loop over eFEXes
370 
371  // EM TOBs and xTOBs
372 
373  // TOB Containers
374  auto eContainer = std::make_unique<xAOD::eFexEMRoIContainer> ();
375  auto eAuxContainer = std::make_unique<xAOD::eFexEMRoIAuxContainer> ();
376  eContainer->setStore(eAuxContainer.get());
377 
378  // xTOB Containers
379  auto xeContainer = std::make_unique<xAOD::eFexEMRoIContainer> ();
380  auto xeAuxContainer = std::make_unique<xAOD::eFexEMRoIAuxContainer> ();
381  xeContainer->setStore(xeAuxContainer.get());
382 
383  // iterate over all Em Tobs and fill xTOB EDM with them
384  for( auto const& [efex, tobObjects] : allEmTobObjects ){
385  for(auto &tobObject : tobObjects){
386  m_eFEXFillEDMTool->fillEmEDM(xeContainer, efex, tobObject, true);
387  }
388  }
389 
390  // Form list of TOBs, sorted and truncated from each eFEX
391  // Vector to store sorted TOBs from all eFEXes
392  // Note that this step means moving TOBs from the all objects vector, which is why we do it last
393  std::vector<std::unique_ptr<eFEXegTOB>> emTOBs;
394  // Loop through eFEXes and sort TOBs from each
395  auto iter = allEmTobObjects.begin();
396  while (iter != allEmTobObjects.end()) {
397  std::vector<std::unique_ptr<eFEXegTOB>> tobsSort = std::move(iter->second);
398  // sort tobs by their et (last 12 bits of the 32 bit tob word)
399  std::sort (tobsSort.begin(), tobsSort.end(), std::bind(TOBetSort<std::unique_ptr<eFEXegTOB>>, std::placeholders::_1, std::placeholders::_2, false));
400  // Truncate at 6 TOBs per eFEX
401  if (tobsSort.size() > 6) tobsSort.resize(6);
402  // Append to system TOB list
403  for (unsigned int t = 0; t < tobsSort.size(); ++t) emTOBs.push_back(std::move(tobsSort[t]));
404  // Next eFEX
405  ++iter;
406  }
407 
408  // iterate over sorted eFEX EM TOBs and fill TOB EDM with them
409  for(auto &tobObject : emTOBs){
410  int efex = tobObject->geteFEXID();
411  m_eFEXFillEDMTool->fillEmEDM(eContainer, efex, tobObject);
412  }
413 
414  // Match xTOBs to TOBs and set isTOB flags if matched
415  matchTOBs(eContainer, xeContainer);
416 
417  // Record EDMs in StoreGate
418  SG::WriteHandle<xAOD::eFexEMRoIContainer> outputeFexEMxTOBHandle(m_eFexEMxTOBOutKey/*, ctx*/);
419  ATH_MSG_DEBUG(" write: " << outputeFexEMxTOBHandle.key() << " = " << "..." );
420  ATH_CHECK(outputeFexEMxTOBHandle.record(std::move(xeContainer),std::move(xeAuxContainer)));
421 
422  SG::WriteHandle<xAOD::eFexEMRoIContainer> outputeFexHandle(m_eFexOutKey/*, ctx*/);
423  ATH_MSG_DEBUG(" write: " << outputeFexHandle.key() << " = " << "..." );
424  ATH_CHECK(outputeFexHandle.record(std::move(eContainer),std::move(eAuxContainer)));
425 
426  SG::ReadHandle<TrigConf::L1Menu> l1Menu (m_l1MenuKey/*, ctx*/);
427  ATH_CHECK(l1Menu.isValid());
428 
429  auto & thr_eTAU = l1Menu->thrExtraInfo().eTAU();
430  int activeAlgo = thr_eTAU.algoVersion() == 0 ? xAOD::eFexTauRoI_v1::Heuristic : xAOD::eFexTauRoI_v1::BDT;
431  bool omitAltTauContainer = m_eFexTauAltxTOBOutKey.empty() || m_eFexTauAltOutKey.empty();
432 
433  // Repeat for Tau TOBs and xTOBs
434  if (activeAlgo == xAOD::eFexTauRoI_v1::Heuristic) {
435  ATH_CHECK(StoreTauTOBs(allTauHeuristicTobObjects, m_eFexTauActivexTOBOutKey, m_eFexTauActiveOutKey));
436  if (!omitAltTauContainer) {
437  ATH_CHECK(StoreTauTOBs(allTauBDTTobObjects, m_eFexTauAltxTOBOutKey, m_eFexTauAltOutKey));
438  }
439  } else if (activeAlgo == xAOD::eFexTauRoI_v1::BDT) {
440  ATH_CHECK(StoreTauTOBs(allTauBDTTobObjects, m_eFexTauActivexTOBOutKey, m_eFexTauActiveOutKey));
441  if (!omitAltTauContainer) {
442  ATH_CHECK(StoreTauTOBs(allTauHeuristicTobObjects, m_eFexTauAltxTOBOutKey, m_eFexTauAltOutKey));
443  }
444  }
445 
446  //Send TOBs to bytestream?
447  // ToDo
448  // To implement
449  // {--Implement--}
450 
451  return StatusCode::SUCCESS;
452 
453  }

◆ 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

◆ initialize()

StatusCode LVL1::eFEXSysSim::initialize ( )
overridevirtual

standard Athena-Algorithm method

Destructor.

Definition at line 52 of file eFEXSysSim.cxx.

53  {
54 
55  ATH_CHECK( m_eTowerContainerSGKey.initialize() );
56 
57  ATH_CHECK( m_eFEXSimTool.retrieve() );
58 
59  ATH_CHECK( m_eFexOutKey.initialize() );
60  ATH_CHECK( m_eFexEMxTOBOutKey.initialize() );
61 
62  ATH_CHECK( m_eFexTauActiveOutKey.initialize() );
63  ATH_CHECK( m_eFexTauActivexTOBOutKey.initialize() );
64  ATH_CHECK( m_eFexTauAltOutKey.initialize(SG::AllowEmpty) );
65  ATH_CHECK( m_eFexTauAltxTOBOutKey.initialize(SG::AllowEmpty) );
66 
67  ATH_CHECK( m_eFEXFPGATowerIdProviderTool.retrieve() );
68 
69  ATH_CHECK(m_l1MenuKey.initialize());
70 
71  return StatusCode::SUCCESS;
72  }

◆ 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::IeFEXSysSim::interfaceID ( )
inlinestaticinherited

Definition at line 39 of file IeFEXSysSim.h.

40  {
41  return IID_IeFEXSysSim;
42  }

◆ 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=()

eFEXSysSim&& LVL1::eFEXSysSim::operator= ( const eFEXSysSim &  )
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  }

◆ StoreTauTOBs()

StatusCode LVL1::eFEXSysSim::StoreTauTOBs ( std::map< int, std::vector< std::unique_ptr< eFEXtauTOB >> > &  allTauTobObjects,
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > &  eFexTauxTOBOutKey,
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > &  eFexTauOutKey 
)
private

Definition at line 455 of file eFEXSysSim.cxx.

458  {
459  std::unique_ptr< xAOD::eFexTauRoIContainer > tauContainer;
460  std::unique_ptr< xAOD::eFexTauRoIAuxContainer > tauAuxContainer;
461  std::unique_ptr< xAOD::eFexTauRoIContainer > xtauContainer;
462  std::unique_ptr< xAOD::eFexTauRoIAuxContainer > xtauAuxContainer;
463 
464  tauContainer = std::make_unique<xAOD::eFexTauRoIContainer> ();
465  tauAuxContainer = std::make_unique<xAOD::eFexTauRoIAuxContainer> ();
466  tauContainer->setStore(tauAuxContainer.get());
467 
468  xtauContainer = std::make_unique<xAOD::eFexTauRoIContainer> ();
469  xtauAuxContainer = std::make_unique<xAOD::eFexTauRoIAuxContainer> ();
470  xtauContainer->setStore(xtauAuxContainer.get());
471 
472  // iterate over all tau TOBs and fill xTOB EDM with them
473  for( auto const& [efex, tobObjects] : allTauTobObjects ){
474  for( auto &tobObject: tobObjects ){
475  m_eFEXFillEDMTool->fillTauEDM(xtauContainer, efex, tobObject, true);
476  }
477  }
478 
479  // Form list of TOBs, sorted and truncated from each eFEX
480  // Vector to store sorted TOBs from all eFEXes
481  // Note that this step means moving TOBs from the all objects vector, which is why we do it last
482  std::vector<std::unique_ptr<eFEXtauTOB>> tauTOBs;
483  // Loop through eFEXes and sort TOBs from each
484  auto iterTau = allTauTobObjects.begin();
485  while (iterTau != allTauTobObjects.end()) {
486  std::vector<std::unique_ptr<eFEXtauTOB>> tobsSort = std::move(iterTau->second);
487  // sort tobs by their et (last 12 bits of the 32 bit tob word)
488  std::sort (tobsSort.begin(), tobsSort.end(), std::bind(TOBetSort<std::unique_ptr<eFEXtauTOB>>, std::placeholders::_1, std::placeholders::_2, true));
489  // Truncate at 6 TOBs per eFEX
490  if (tobsSort.size() > 6) tobsSort.resize(6);
491  // Append to system TOB list
492  for (unsigned int t = 0; t < tobsSort.size(); ++t) tauTOBs.push_back(std::move(tobsSort[t]));
493  // Next eFEX
494  ++iterTau;
495  }
496 
497  // iterate over sorted eFEX Tau TOBs and fill TOB EDM with them
498  for(auto &tobObject : tauTOBs){
499  int efex = tobObject->geteFEXID();
500  m_eFEXFillEDMTool->fillTauEDM(tauContainer, efex, tobObject);
501  }
502 
503  // Match xTOBs and TOBs and set isTOB flags if matched
504  matchTOBs(tauContainer, xtauContainer);
505 
506  // Record containers in StoreGate
507  SG::WriteHandle<xAOD::eFexTauRoIContainer> outputeFexTauxTOBHandle(eFexTauxTOBOutKey/*, ctx*/);
508  ATH_MSG_DEBUG(" write: " << outputeFexTauxTOBHandle.key() << " = " << "..." );
509  ATH_CHECK(outputeFexTauxTOBHandle.record(std::move(xtauContainer), std::move(xtauAuxContainer)));
510 
511  SG::WriteHandle<xAOD::eFexTauRoIContainer> outputeFexTauHandle(eFexTauOutKey/*, ctx*/);
512  ATH_MSG_DEBUG(" write: " << outputeFexTauHandle.key() << " = " << "..." );
513  ATH_CHECK(outputeFexTauHandle.record(std::move(tauContainer), std::move(tauAuxContainer)));
514 
515  return StatusCode::SUCCESS;
516 
517  }

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

◆ TOBetSort()

template<class TOBObjectClass >
static bool LVL1::eFEXSysSim::TOBetSort ( const TOBObjectClass &  i,
const TOBObjectClass &  j,
bool  isTau 
)
inlinestaticprivate

Internal data.

Definition at line 62 of file eFEXSysSim.h.

62  {
63  auto et_i = (i->getTobword() >> 0 ) & 0xfff;
64  auto et_j = (j->getTobword() >> 0 ) & 0xfff;
65  if(et_i > et_j) return true;
66  if(et_i==et_j) {
67  // resolve ties with procNumber (2,1,3,0 for em, 2,1,0,3 for tau), then phi, then eta
68  auto procOrder = (isTau) ? std::map<unsigned int,unsigned int>{{2,3},{1,2},{0,1},{3,0}} :
69  std::map<unsigned int,unsigned int>{{2,3},{1,2},{3,1},{0,0}};
70  auto proc_i = procOrder.at((i->getTobword()) >> 30);
71  auto proc_j = procOrder.at((j->getTobword()) >> 30);
72  if(proc_i > proc_j) return true;
73  if (proc_i == proc_j) {
74  auto phi_i = (i->getTobword()) & 0x07000000;
75  auto phi_j = (j->getTobword()) & 0x07000000;
76  if(phi_i > phi_j) return true;
77  if(phi_i == phi_j) {
78  auto eta_i = (i->getTobword()) & 0x38000000;
79  auto eta_j = (j->getTobword()) & 0x38000000;
80  if(eta_i > eta_j) return true;
81  }
82 
83  }
84  }
85  return false;
86  }

◆ 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_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_eFexEMxTOBOutKey

SG::WriteHandleKey< xAOD::eFexEMRoIContainer > LVL1::eFEXSysSim::m_eFexEMxTOBOutKey {this,"Key_eFexEMxTOBOutputContainer","L1_eEMxRoI","Output eFexEM xTOB container"}
private

Definition at line 102 of file eFEXSysSim.h.

◆ m_eFEXFillEDMTool

ToolHandle<IeFEXFillEDM> LVL1::eFEXSysSim::m_eFEXFillEDMTool {this, "eFEXFillEDMTool", "LVL1::eFEXFillEDM", "Tool to fille eFEX EDMs"}
private

Definition at line 96 of file eFEXSysSim.h.

◆ m_eFEXFPGATowerIdProviderTool

ToolHandle<IeFEXFPGATowerIdProvider> LVL1::eFEXSysSim::m_eFEXFPGATowerIdProviderTool {this, "eFEXFPGATowerIdProviderTool", "LVL1::eFEXFPGATowerIdProvider", "Tool that provides tower-FPGA mapping"}
private

Definition at line 107 of file eFEXSysSim.h.

◆ m_eFexOutKey

SG::WriteHandleKey< xAOD::eFexEMRoIContainer > LVL1::eFEXSysSim::m_eFexOutKey {this,"Key_eFexEMOutputContainer","L1_eEMRoI","Output eFexEM TOB container"}
private

Definition at line 101 of file eFEXSysSim.h.

◆ m_eFEXSimTool

ToolHandle<IeFEXSim> LVL1::eFEXSysSim::m_eFEXSimTool {this, "eFEXSimTool", "LVL1::eFEXSim", "Tool that creates the eFEX Simulation"}
private

Definition at line 94 of file eFEXSysSim.h.

◆ m_eFexTauActiveOutKey

SG::WriteHandleKey< xAOD::eFexTauRoIContainer > LVL1::eFEXSysSim::m_eFexTauActiveOutKey {this,"Key_eFexTauOutputContainer","L1_eTauRoI","Output eFexTau active (BDT/heuristic) algorithm TOB container"}
private

Definition at line 103 of file eFEXSysSim.h.

◆ m_eFexTauActivexTOBOutKey

SG::WriteHandleKey< xAOD::eFexTauRoIContainer > LVL1::eFEXSysSim::m_eFexTauActivexTOBOutKey {this,"Key_eFexTauxTOBOutputContainer","L1_eTauxRoI","Output eFexTau active (BDT/heuristic) algorithm xTOB container"}
private

Definition at line 104 of file eFEXSysSim.h.

◆ m_eFexTauAltOutKey

SG::WriteHandleKey< xAOD::eFexTauRoIContainer > LVL1::eFEXSysSim::m_eFexTauAltOutKey {this,"Key_eFexAltTauOutputContainer","","Output eFexTau alternative (BDT/heuristic) algorithm TOB container"}
private

Definition at line 105 of file eFEXSysSim.h.

◆ m_eFexTauAltxTOBOutKey

SG::WriteHandleKey< xAOD::eFexTauRoIContainer > LVL1::eFEXSysSim::m_eFexTauAltxTOBOutKey {this,"Key_eFexAltTauxTOBOutputContainer","","Output eFexTau alternative (BDT/heuristic) algorithm xTOB container"}
private

Definition at line 106 of file eFEXSysSim.h.

◆ m_eTowerContainerSGKey

SG::ReadHandleKey<LVL1::eTowerContainer> LVL1::eFEXSysSim::m_eTowerContainerSGKey {this, "MyETowers", "eTowerContainer", "Input container for eTowers"}
private

Definition at line 98 of file eFEXSysSim.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_l1MenuKey

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

Definition at line 99 of file eFEXSysSim.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.

The documentation for this class was generated from the following files:
LVL1::eFEXSysSim::m_eFexTauActiveOutKey
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauActiveOutKey
Definition: eFEXSysSim.h:103
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
xAOD::eFexTauRoI_v1::BDT
@ BDT
This object is generated by the BDT algorithm.
Definition: eFexTauRoI_v1.h:48
LVL1::eFEXSysSim::m_eFexTauActivexTOBOutKey
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauActivexTOBOutKey
Definition: eFEXSysSim.h:104
LVL1::eFEXSysSim::StoreTauTOBs
StatusCode StoreTauTOBs(std::map< int, std::vector< std::unique_ptr< eFEXtauTOB >> > &allTauTobObjects, SG::WriteHandleKey< xAOD::eFexTauRoIContainer > &eFexTauxTOBOutKey, SG::WriteHandleKey< xAOD::eFexTauRoIContainer > &eFexTauOutKey)
Definition: eFEXSysSim.cxx:455
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
LVL1::eFEXSysSim::m_eFEXSimTool
ToolHandle< IeFEXSim > m_eFEXSimTool
Definition: eFEXSysSim.h:94
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
LVL1::eFEXSysSim::m_eTowerContainerSGKey
SG::ReadHandleKey< LVL1::eTowerContainer > m_eTowerContainerSGKey
Definition: eFEXSysSim.h:98
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
LVL1::matchTOBs
void matchTOBs(T &TOBs, T &xTOBs)
Definition: eFEXTOBxTOBMatching.h:18
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
beamspotnt.cols
list cols
Definition: bin/beamspotnt.py:1114
LVL1::eFEXSysSim::m_eFexTauAltxTOBOutKey
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauAltxTOBOutKey
Definition: eFEXSysSim.h:106
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
maskDeadModules.mod
mod
Definition: maskDeadModules.py:36
lumiFormat.i
int i
Definition: lumiFormat.py:85
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LVL1::eFEXSysSim::m_eFexEMxTOBOutKey
SG::WriteHandleKey< xAOD::eFexEMRoIContainer > m_eFexEMxTOBOutKey
Definition: eFEXSysSim.h:102
test_pyathena.parent
parent
Definition: test_pyathena.py:15
LVL1::eFEXSysSim::calcTowerID
virtual int calcTowerID(int eta, int phi, int mod) const override
Definition: eFEXSysSim.cxx:74
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::eFexTauRoI_v1::Heuristic
@ Heuristic
This object is generated by the heuristic algorithm.
Definition: eFexTauRoI_v1.h:47
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
LVL1::eFEXSysSim::m_eFEXFPGATowerIdProviderTool
ToolHandle< IeFEXFPGATowerIdProvider > m_eFEXFPGATowerIdProviderTool
Definition: eFEXSysSim.h:107
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
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
LVL1::eFEXSysSim::m_l1MenuKey
SG::ReadHandleKey< TrigConf::L1Menu > m_l1MenuKey
Definition: eFEXSysSim.h:99
isTau
bool isTau(const T &p)
Definition: AtlasPID.h:197
LVL1::eFEXSysSim::m_eFexOutKey
SG::WriteHandleKey< xAOD::eFexEMRoIContainer > m_eFexOutKey
Definition: eFEXSysSim.h:101
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
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
a
TList * a
Definition: liststreamerinfos.cxx:10
h
LVL1::eFEXSysSim::m_eFexTauAltOutKey
SG::WriteHandleKey< xAOD::eFexTauRoIContainer > m_eFexTauAltOutKey
Definition: eFEXSysSim.h:105
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
LVL1::eFEXSysSim::TOBetSort
static bool TOBetSort(const TOBObjectClass &i, const TOBObjectClass &j, bool isTau)
Internal data.
Definition: eFEXSysSim.h:62
value_type
Definition: EDM_MasterSearch.h:11
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
LVL1::eFEXSysSim::m_eFEXFillEDMTool
ToolHandle< IeFEXFillEDM > m_eFEXFillEDMTool
Definition: eFEXSysSim.h:96
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
Generated on Mon Apr 14 2025 21:57:58 for ATLAS Offline Software by   doxygen 1.8.18