ATLAS Offline Software
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"}
 
ToolHandle< IeFEXFPGA > m_eFEXFPGATool {this, "eFEXFPGATool", "LVL1::eFEXFPGA", "Tool that simulates the FPGA hardware"}
 
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 76 of file eFEXSysSim.cxx.

76  {
77 
78  return ((64*eta) + phi + mod);
79  }

◆ 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 81 of file eFEXSysSim.cxx.

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

◆ 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_eFEXFPGATool.retrieve() );
70 
71  ATH_CHECK(m_l1MenuKey.initialize());
72 
73  return StatusCode::SUCCESS;
74  }

◆ 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 457 of file eFEXSysSim.cxx.

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

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

ToolHandle<IeFEXFPGA> LVL1::eFEXSysSim::m_eFEXFPGATool {this, "eFEXFPGATool", "LVL1::eFEXFPGA", "Tool that simulates the FPGA hardware"}
private

Definition at line 108 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:457
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
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
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
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:76
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:157
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:221
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
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
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
LVL1::eFEXSysSim::m_eFEXFPGATool
ToolHandle< IeFEXFPGA > m_eFEXFPGATool
Definition: eFEXSysSim.h:108
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
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 Thu Nov 7 2024 22:17:13 for ATLAS Offline Software by   doxygen 1.8.18