ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
TrigL2MuonSA::MuFastDataPreparator Class Reference

#include <MuFastDataPreparator.h>

Inheritance diagram for TrigL2MuonSA::MuFastDataPreparator:
Collaboration diagram for TrigL2MuonSA::MuFastDataPreparator:

Public Member Functions

 MuFastDataPreparator (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual StatusCode initialize () override
 
StatusCode prepareData (const LVL1::RecMuonRoI *p_roi, const TrigRoiDescriptor *p_roids, const bool insideOut, TrigL2MuonSA::RpcHits &rpcHits, TrigL2MuonSA::MuonRoad &muonRoad, TrigL2MuonSA::MdtRegion &mdtRegion, TrigL2MuonSA::RpcFitResult &rpcFitResult, TrigL2MuonSA::MdtHits &mdtHits_normal, TrigL2MuonSA::MdtHits &mdtHits_overlap, const bool dynamicDeltaRpc) const
 
StatusCode prepareData (const xAOD::MuonRoI *p_roi, const TrigRoiDescriptor *p_roids, const bool insideOut, TrigL2MuonSA::RpcHits &rpcHits, TrigL2MuonSA::MuonRoad &muonRoad, TrigL2MuonSA::MdtRegion &mdtRegion, TrigL2MuonSA::RpcFitResult &rpcFitResult, TrigL2MuonSA::MdtHits &mdtHits_normal, TrigL2MuonSA::MdtHits &mdtHits_overlap, const bool dynamicDeltaRpc) const
 
StatusCode prepareData (const LVL1::RecMuonRoI *p_roi, const TrigRoiDescriptor *p_roids, const bool insideOut, TrigL2MuonSA::TgcHits &tgcHits, TrigL2MuonSA::MuonRoad &muonRoad, TrigL2MuonSA::MdtRegion &mdtRegion, TrigL2MuonSA::TgcFitResult &tgcFitResult, TrigL2MuonSA::MdtHits &mdtHits_normal, TrigL2MuonSA::MdtHits &mdtHits_overlap, TrigL2MuonSA::CscHits &cscHits, TrigL2MuonSA::StgcHits &stgcHits, TrigL2MuonSA::MmHits &mmHits) const
 
StatusCode prepareData (const xAOD::MuonRoI *p_roi, const TrigRoiDescriptor *p_roids, const bool insideOut, TrigL2MuonSA::TgcHits &tgcHits, TrigL2MuonSA::MuonRoad &muonRoad, TrigL2MuonSA::MdtRegion &mdtRegion, TrigL2MuonSA::TgcFitResult &tgcFitResult, TrigL2MuonSA::MdtHits &mdtHits_normal, TrigL2MuonSA::MdtHits &mdtHits_overlap, TrigL2MuonSA::CscHits &cscHits, TrigL2MuonSA::StgcHits &stgcHits, TrigL2MuonSA::MmHits &mmHits) const
 
StatusCode prepareData (const LVL1::RecMuonRoI *p_roi, const TrigRoiDescriptor *p_roids, std::vector< TrigL2MuonSA::MuonRoad > &clusterRoad, std::vector< TrigL2MuonSA::RpcFitResult > &clusterFitResults, TrigL2MuonSA::MdtHits &mdtHits_normal, TrigL2MuonSA::MdtHits &mdtHits_overlap, std::vector< TrigL2MuonSA::MdtHits > &mdtHits_cluster_normal, const bool dynamicDeltaRpc) const
 
StatusCode prepareData (const xAOD::MuonRoI *p_roi, const TrigRoiDescriptor *p_roids, std::vector< TrigL2MuonSA::MuonRoad > &clusterRoad, std::vector< TrigL2MuonSA::RpcFitResult > &clusterFitResults, TrigL2MuonSA::MdtHits &mdtHits_normal, TrigL2MuonSA::MdtHits &mdtHits_overlap, std::vector< TrigL2MuonSA::MdtHits > &mdtHits_cluster_normal, const bool dynamicDeltaRpc) const
 
void setOptions (const TrigL2MuonSA::MuFastDataPreparatorOptions &options)
 
void setRoadWidthForFailure (double rWidth_RPC_Failed, double rWidth_TGC_Failed)
 
StatusCode setGeometry (bool use_new_geometry)
 
void setRpcGeometry (bool use_rpc)
 
void setStgcGeometry (bool use_stgc)
 
void setMmGeometry (bool use_mm)
 
StatusCode setMCFlag (const BooleanProperty &use_mcLUT)
 
void setRoIBasedDataAccess (bool use_RoIBasedDataAccess_MDT, bool use_RoIBasedDataAccess_RPC, bool use_RoIBasedDataAccess_TGC, bool use_RoIBasedDataAccess_CSC, bool use_RoIBasedDataAccess_STGC, bool use_RoIBasedDataAccess_MM)
 
void setExtrapolatorTool (ToolHandle< ITrigMuonBackExtrapolator > *backExtrapolator)
 
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
 

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

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

Private Attributes

TrigL2MuonSA::MuFastDataPreparatorOptions m_options
 
ToolHandle< LVL1::ITrigT1MuonRecRoiTool > m_recRPCRoiTool {this, "TrigT1RPCRecRoiTool", "LVL1::TrigT1RPCRecRoiTool/TrigT1RPCRecRoiTool"}
 
ToolHandle< RpcDataPreparator > m_rpcDataPreparator {this, "RPCDataPreparator", "TrigL2MuonSA::RpcDataPreparator"}
 
ToolHandle< TgcDataPreparator > m_tgcDataPreparator {this, "TGCDataPreparator", "TrigL2MuonSA::TgcDataPreparator"}
 
ToolHandle< MdtDataPreparator > m_mdtDataPreparator {this, "MDTDataPreparator", "TrigL2MuonSA::MdtDataPreparator"}
 
ToolHandle< CscDataPreparator > m_cscDataPreparator {this, "CSCDataPreparator", "TrigL2MuonSA::CscDataPreparator"}
 
ToolHandle< StgcDataPreparator > m_stgcDataPreparator {this,"STGCDataPreparator","TrigL2MuonSA::StgcDataPreparator"}
 
ToolHandle< MmDataPreparator > m_mmDataPreparator {this, "MMDataPreparator", "TrigL2MuonSA::MmDataPreparator"}
 
ToolHandle< RpcRoadDefiner > m_rpcRoadDefiner {this, "RpcRoadDefiner", "TrigL2MuonSA::RpcRoadDefiner"}
 
ToolHandle< TgcRoadDefiner > m_tgcRoadDefiner {this, "TgcRoadDefiner", "TrigL2MuonSA::TgcRoadDefiner"}
 
ToolHandle< RpcPatFinder > m_rpcPatFinder {"TrigL2MuonSA::RpcPatFinder"}
 
ToolHandle< ClusterRoadDefiner > m_clusterRoadDefiner {this, "ClusterRoadDefiner", "TrigL2MuonSA::ClusterRoadDefiner"}
 
ToolHandle< ClusterPatFinder > m_clusterPatFinder {this, "ClusterPatFinder", "TrigL2MuonSA::ClusterPatFinder"}
 
ToolHandle< ITrigMuonBackExtrapolator > * m_backExtrapolatorTool {nullptr}
 
bool m_use_rpc {false}
 
bool m_use_stgc {false}
 
bool m_use_mm {false}
 
bool m_use_mcLUT {false}
 
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

Definition at line 41 of file MuFastDataPreparator.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

◆ MuFastDataPreparator()

TrigL2MuonSA::MuFastDataPreparator::MuFastDataPreparator ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 11 of file MuFastDataPreparator.cxx.

13  :
14  AthAlgTool(type,name,parent)
15 {
16 }

Member Function Documentation

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

◆ 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 TrigL2MuonSA::MuFastDataPreparator::initialize ( )
overridevirtual

Definition at line 22 of file MuFastDataPreparator.cxx.

23 {
24  ATH_CHECK(m_recRPCRoiTool.retrieve());
25 
26  if (m_use_rpc) {
27  ATH_CHECK(m_rpcDataPreparator.retrieve());
28  ATH_MSG_DEBUG("Retrieved service " << m_rpcDataPreparator);
29  }
30 
31  ATH_CHECK(m_tgcDataPreparator.retrieve());
32  ATH_MSG_DEBUG("Retrieved service " << m_tgcDataPreparator);
33 
34  ATH_CHECK(m_mdtDataPreparator.retrieve());
35  ATH_MSG_DEBUG("Retrieved service " << m_mdtDataPreparator);
36 
37  ATH_CHECK(m_cscDataPreparator.retrieve(DisableTool{m_cscDataPreparator.empty()}));
38  ATH_MSG_DEBUG("Retrieved service " << m_cscDataPreparator);
39 
40  if (m_use_stgc) {
41  ATH_CHECK(m_stgcDataPreparator.retrieve(DisableTool{m_stgcDataPreparator.empty()}));
42  ATH_MSG_DEBUG("Retrieved service " << m_stgcDataPreparator);
43  }
44 
45  if (m_use_mm) {
46  ATH_CHECK(m_mmDataPreparator.retrieve(DisableTool{m_mmDataPreparator.empty()}));
47  ATH_MSG_DEBUG("Retrieved service " << m_mmDataPreparator);
48  }
49 
50  ATH_CHECK(m_rpcRoadDefiner.retrieve());
51  ATH_MSG_DEBUG("Retrieved service " << m_rpcRoadDefiner);
52 
53  ATH_CHECK(m_tgcRoadDefiner.retrieve());
54  ATH_MSG_DEBUG("Retrieved service " << m_tgcRoadDefiner);
55 
56  ATH_CHECK(m_rpcPatFinder.retrieve());
57  ATH_MSG_DEBUG("Retrieved service " << m_rpcPatFinder);
58 
59  ATH_CHECK(m_clusterRoadDefiner.retrieve());
60  ATH_MSG_DEBUG("Retrieved service " << m_clusterRoadDefiner);
61 
62  ATH_CHECK(m_clusterPatFinder.retrieve());
63  ATH_MSG_DEBUG("Retrieved service " << m_clusterPatFinder);
64 
65  return StatusCode::SUCCESS;
66 }

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

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

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

◆ prepareData() [1/6]

StatusCode TrigL2MuonSA::MuFastDataPreparator::prepareData ( const LVL1::RecMuonRoI *  p_roi,
const TrigRoiDescriptor *  p_roids,
const bool  insideOut,
TrigL2MuonSA::RpcHits &  rpcHits,
TrigL2MuonSA::MuonRoad &  muonRoad,
TrigL2MuonSA::MdtRegion &  mdtRegion,
TrigL2MuonSA::RpcFitResult &  rpcFitResult,
TrigL2MuonSA::MdtHits &  mdtHits_normal,
TrigL2MuonSA::MdtHits &  mdtHits_overlap,
const bool  dynamicDeltaRpc 
) const

Definition at line 157 of file MuFastDataPreparator.cxx.

167 {
168 
169  ATH_MSG_DEBUG("RoI eta/phi=" << p_roi->eta() << "/" << p_roi->phi());
170 
171  StatusCode sc = StatusCode::SUCCESS;
172 
173  //Storing rpc hits by each layers and eta/phi strip for creating road
174  //RpcLayerHits class is defined in RpcPatFinder.h
175  TrigL2MuonSA::RpcLayerHits rpcLayerHits;
176  rpcLayerHits.clear();
177 
178  if(m_use_rpc && !insideOut) {
179 
180  sc = m_rpcDataPreparator->prepareData(p_roids,
181  rpcHits,
182  rpcLayerHits,
183  &m_rpcPatFinder,
184  dynamicDeltaRpc);
185 
186  if (!sc.isSuccess()) {
187  ATH_MSG_DEBUG("Error in RPC data prepapration. Continue using RoI");
188  }
189  } else {
190  ATH_MSG_DEBUG("Skip RpcDataPreparator");
191  }
192 
193  LVL1::TrigT1MuonRecRoiData data;
194  sc = m_recRPCRoiTool->roiData(p_roi->roiWord(),data);
195  if (!sc.isSuccess()){
196  ATH_MSG_WARNING("Error in roiWord decode");
197  return sc;
198  }
199  double roiEtaMinLow = 0.;
200  double roiEtaMaxLow = 0.;
201  double roiEtaMinHigh = 0.;
202  double roiEtaMaxHigh = 0.;
203  if(!m_recRPCRoiTool->etaDimLow(data, roiEtaMinLow, roiEtaMaxLow)) {
204  roiEtaMinLow = p_roids->eta();
205  roiEtaMaxLow = p_roids->eta();
206  }
207  if(!m_recRPCRoiTool->etaDimHigh(data, roiEtaMinHigh, roiEtaMaxHigh)) {
208  roiEtaMinHigh = p_roids->eta();
209  roiEtaMaxHigh = p_roids->eta();
210  }
211 
212  ATH_MSG_DEBUG("nr of RPC hits=" << rpcHits.size());
213 
214  sc = m_rpcRoadDefiner->defineRoad(p_roi,
215  insideOut,
216  muonRoad,
217  rpcHits,
218  rpcLayerHits,
219  &m_rpcPatFinder,
220  rpcFitResult,
221  roiEtaMinLow,
222  roiEtaMaxLow,
223  roiEtaMinHigh,
224  roiEtaMaxHigh);
225  if (!sc.isSuccess()) {
226  ATH_MSG_WARNING("Error in road definition.");
227  return sc;
228  }
229 
230  sc = m_mdtDataPreparator->prepareData(p_roids,
231  rpcFitResult,
232  muonRoad,
233  mdtRegion,
234  mdtHits_normal);
235 
236 
237  if (!sc.isSuccess()) {
238  ATH_MSG_WARNING("Error in MDT data preparation.");
239  return sc;
240  }
241  ATH_MSG_DEBUG("nr of MDT (normal) hits=" << mdtHits_normal.size());
242  ATH_MSG_DEBUG("nr of MDT (overlap) hits=" << mdtHits_overlap.size());
243 
244  return StatusCode::SUCCESS;
245 }

◆ prepareData() [2/6]

StatusCode TrigL2MuonSA::MuFastDataPreparator::prepareData ( const LVL1::RecMuonRoI *  p_roi,
const TrigRoiDescriptor *  p_roids,
const bool  insideOut,
TrigL2MuonSA::TgcHits &  tgcHits,
TrigL2MuonSA::MuonRoad &  muonRoad,
TrigL2MuonSA::MdtRegion &  mdtRegion,
TrigL2MuonSA::TgcFitResult &  tgcFitResult,
TrigL2MuonSA::MdtHits &  mdtHits_normal,
TrigL2MuonSA::MdtHits &  mdtHits_overlap,
TrigL2MuonSA::CscHits &  cscHits,
TrigL2MuonSA::StgcHits &  stgcHits,
TrigL2MuonSA::MmHits &  mmHits 
) const

Definition at line 599 of file MuFastDataPreparator.cxx.

611 {
612  StatusCode sc = StatusCode::SUCCESS;
613  ATH_MSG_DEBUG("RoI eta/phi=" << p_roi->eta() << "/" << p_roi->phi());
614 
615  if(!insideOut) {
616  sc = m_tgcDataPreparator->prepareData(p_roi,
617  tgcHits);
618  } else {
619  ATH_MSG_DEBUG("Skip TgcDataPreparator");
620  }
621 
622  if (!sc.isSuccess()) {
623  ATH_MSG_DEBUG("Error in TGC data preparation. Continue using RoI");
624  }
625  ATH_MSG_DEBUG("nr of TGC hits=" << tgcHits.size());
626 
627  sc = m_tgcRoadDefiner->defineRoad(p_roids,
628  insideOut,
629  tgcHits,
630  muonRoad,
631  tgcFitResult);
632  if (!sc.isSuccess()) {
633  ATH_MSG_WARNING("Error in road definition.");
634  return sc;
635  }
636 
637  sc = m_mdtDataPreparator->prepareData(p_roids,
638  tgcFitResult,
639  muonRoad,
640  mdtRegion,
641  mdtHits_normal);
642 
643  if (!sc.isSuccess()) {
644  ATH_MSG_WARNING("Error in MDT data preparation.");
645  return sc;
646  }
647  ATH_MSG_DEBUG("nr of MDT (normal) hits=" << mdtHits_normal.size());
648  ATH_MSG_DEBUG("nr of MDT (overlap) hits=" << mdtHits_overlap.size());
649 
650  if(!m_cscDataPreparator.empty()) {
651  sc = m_cscDataPreparator->prepareData(muonRoad,
652  cscHits);
653  if (!sc.isSuccess()) {
654  ATH_MSG_WARNING("Error in CSC data preparation.");
655  return sc;
656  }
657  ATH_MSG_DEBUG("nr of CSC hits=" << cscHits.size());
658  }
659 
660  if(m_use_stgc && !m_stgcDataPreparator.empty()){
661  sc = m_stgcDataPreparator->prepareData(p_roids,
662  stgcHits);
663  if (!sc.isSuccess()) {
664  ATH_MSG_WARNING("Error in sTGC data preparation.");
665  return sc;
666  }
667  ATH_MSG_DEBUG("nr of sTGC hits=" << stgcHits.size());
668  }
669 
670  if(m_use_mm && !m_mmDataPreparator.empty()){
671  sc = m_mmDataPreparator->prepareData(p_roids,
672  mmHits);
673  if (!sc.isSuccess()) {
674  ATH_MSG_WARNING("Error in MM data preparation.");
675  return sc;
676  }
677  ATH_MSG_DEBUG("nr of MM hits=" << mmHits.size());
678  }
679 
680  return StatusCode::SUCCESS;
681 }

◆ prepareData() [3/6]

StatusCode TrigL2MuonSA::MuFastDataPreparator::prepareData ( const LVL1::RecMuonRoI *  p_roi,
const TrigRoiDescriptor *  p_roids,
std::vector< TrigL2MuonSA::MuonRoad > &  clusterRoad,
std::vector< TrigL2MuonSA::RpcFitResult > &  clusterFitResults,
TrigL2MuonSA::MdtHits &  mdtHits_normal,
TrigL2MuonSA::MdtHits &  mdtHits_overlap,
std::vector< TrigL2MuonSA::MdtHits > &  mdtHits_cluster_normal,
const bool  dynamicDeltaRpc 
) const

Definition at line 345 of file MuFastDataPreparator.cxx.

353 {
354 
355  ATH_MSG_DEBUG("RoI eta/phi=" << p_roi->eta() << "/" << p_roi->phi());
356  //RpcLayerClusters class is defined in ClusterPatFinder.h
357  TrigL2MuonSA::RpcLayerClusters rpcLayerClusters;
358  rpcLayerClusters.clear();
359 
360  // for MdtDataPreparator's input
361  TrigL2MuonSA::MdtRegion mdtRegion;
362  mdtRegion.Clear();
363 
364  StatusCode sc = StatusCode::SUCCESS;
365 
366  if(!m_use_rpc){
367 
368  } else {
369 
370  sc = m_rpcDataPreparator->prepareData(p_roids,
371  rpcLayerClusters,
372  &m_clusterPatFinder,
373  dynamicDeltaRpc);
374 
375  if (!sc.isSuccess()) {
376  ATH_MSG_DEBUG("Error in RPC data prepapration and clustering. Continue using RoI");
377  return sc;
378  }
379  }
380 
381  LVL1::TrigT1MuonRecRoiData data;
382  sc = m_recRPCRoiTool->roiData(p_roi->roiWord(),data);
383  if (!sc.isSuccess()){
384  ATH_MSG_WARNING("Error in roiWord decode");
385  return sc;
386  }
387  double roiEtaMinLow = 0.;
388  double roiEtaMaxLow = 0.;
389  double roiEtaMinHigh = 0.;
390  double roiEtaMaxHigh = 0.;
391  if(!m_recRPCRoiTool->etaDimLow(data, roiEtaMinLow, roiEtaMaxLow)) {
392  roiEtaMinLow = p_roids->eta();
393  roiEtaMaxLow = p_roids->eta();
394  }
395  if(!m_recRPCRoiTool->etaDimHigh(data, roiEtaMinHigh, roiEtaMaxHigh)) {
396  roiEtaMinHigh = p_roids->eta();
397  roiEtaMaxHigh = p_roids->eta();
398  }
399 
400  sc = m_clusterRoadDefiner->defineRoad(p_roi,
401  clusterRoad,
402  rpcLayerClusters,
403  &m_clusterPatFinder,
404  clusterFitResults,
405  roiEtaMinLow,
406  roiEtaMaxLow,
407  roiEtaMinHigh,
408  roiEtaMaxHigh);
409  if (!sc.isSuccess()) {
410  ATH_MSG_WARNING("Error in clusterRoad definition.");
411  return sc;
412 
413  }
414  if(!clusterRoad.empty()){
415  sc = m_mdtDataPreparator->prepareData(p_roids,
416  clusterFitResults.back(),
417  clusterRoad.back(),
418  mdtRegion,
419  mdtHits_normal);
420 
421  if (!sc.isSuccess()) {
422  ATH_MSG_WARNING("Error in MDT data preparation.");
423  return sc;
424  }
425 
426  ATH_MSG_DEBUG("nr of MDT (normal) hits=" << mdtHits_normal.size());
427  ATH_MSG_DEBUG("nr of MDT (overlap) hits=" << mdtHits_overlap.size());
428 
429  for(unsigned int i_road = 0; i_road < clusterRoad.size(); i_road++){
430  TrigL2MuonSA::MdtHits mdt_normal;
431  for(unsigned int i_hit = 0; i_hit < mdtHits_normal.size(); i_hit++){
432  unsigned int chamber = mdtHits_normal[i_hit].Chamber;
433 
434  if (chamber >= xAOD::L2MuonParameters::MaxChamber) continue;
435  double Z = mdtHits_normal[i_hit].Z;
436  double R = mdtHits_normal[i_hit].R;
437  double residual = 999999;
438  unsigned int clusterRoadID = 9999;
439  for(unsigned int j_road = 0; j_road < clusterRoad.size(); j_road++){
440  double aw = clusterRoad.at(j_road).aw[chamber][0];
441  double bw = clusterRoad.at(j_road).bw[chamber][0];
442  double tmp_residual;
443  const double ZERO_LIMIT = 1e-4;
444  if( std::abs(aw) < ZERO_LIMIT ){
445  tmp_residual = R-bw;
446  } else {
447  double ia = 1/aw;
448  double iaq = ia*ia;
449  double dz = Z - (R-bw)*ia;
450  tmp_residual = dz/std::sqrt(1.+iaq);
451  }
452  if(std::abs(residual) > std::abs(tmp_residual)){
453  residual = tmp_residual;
454  clusterRoadID = j_road;
455  }
456  }
457  if(clusterRoadID == i_road){
458  mdt_normal.push_back(mdtHits_normal[i_hit]);
459  }
460  }
461  mdtHits_cluster_normal.push_back(mdt_normal);
462  }
463  }
464 
465  return StatusCode::SUCCESS;
466 }

◆ prepareData() [4/6]

StatusCode TrigL2MuonSA::MuFastDataPreparator::prepareData ( const xAOD::MuonRoI *  p_roi,
const TrigRoiDescriptor *  p_roids,
const bool  insideOut,
TrigL2MuonSA::RpcHits &  rpcHits,
TrigL2MuonSA::MuonRoad &  muonRoad,
TrigL2MuonSA::MdtRegion &  mdtRegion,
TrigL2MuonSA::RpcFitResult &  rpcFitResult,
TrigL2MuonSA::MdtHits &  mdtHits_normal,
TrigL2MuonSA::MdtHits &  mdtHits_overlap,
const bool  dynamicDeltaRpc 
) const

Definition at line 250 of file MuFastDataPreparator.cxx.

260 {
261 
262  ATH_MSG_DEBUG("RoI eta/phi=" << p_roi->eta() << "/" << p_roi->phi());
263 
264  StatusCode sc = StatusCode::SUCCESS;
265 
266  //Storing rpc hits by each layers and eta/phi strip for creating road
267  //RpcLayerHits class is defined in RpcPatFinder.h
268  TrigL2MuonSA::RpcLayerHits rpcLayerHits;
269  rpcLayerHits.clear();
270 
271  if(m_use_rpc && !insideOut) {
272 
273  sc = m_rpcDataPreparator->prepareData(p_roids,
274  rpcHits,
275  rpcLayerHits,
276  &m_rpcPatFinder,
277  dynamicDeltaRpc);
278 
279  if (!sc.isSuccess()) {
280  ATH_MSG_DEBUG("Error in RPC data prepapration. Continue using RoI");
281  }
282  } else {
283  ATH_MSG_DEBUG("Skip RpcDataPreparator");
284  }
285 
286  LVL1::TrigT1MuonRecRoiData data;
287  sc = m_recRPCRoiTool->roiData(p_roi->roiWord(),data);
288  if (!sc.isSuccess()){
289  ATH_MSG_WARNING("Error in roiWord decode");
290  return sc;
291  }
292  double roiEtaMinLow = 0.;
293  double roiEtaMaxLow = 0.;
294  double roiEtaMinHigh = 0.;
295  double roiEtaMaxHigh = 0.;
296  if(!m_recRPCRoiTool->etaDimLow(data, roiEtaMinLow, roiEtaMaxLow)) {
297  roiEtaMinLow = p_roids->eta();
298  roiEtaMaxLow = p_roids->eta();
299  }
300  if(!m_recRPCRoiTool->etaDimHigh(data, roiEtaMinHigh, roiEtaMaxHigh)) {
301  roiEtaMinHigh = p_roids->eta();
302  roiEtaMaxHigh = p_roids->eta();
303  }
304 
305  ATH_MSG_DEBUG("nr of RPC hits=" << rpcHits.size());
306 
307  sc = m_rpcRoadDefiner->defineRoad(p_roi,
308  insideOut,
309  muonRoad,
310  rpcHits,
311  rpcLayerHits,
312  &m_rpcPatFinder,
313  rpcFitResult,
314  roiEtaMinLow,
315  roiEtaMaxLow,
316  roiEtaMinHigh,
317  roiEtaMaxHigh);
318  if (!sc.isSuccess()) {
319  ATH_MSG_WARNING("Error in road definition.");
320  return sc;
321  }
322 
323  sc = m_mdtDataPreparator->prepareData(p_roids,
324  rpcFitResult,
325  muonRoad,
326  mdtRegion,
327  mdtHits_normal);
328 
329 
330  if (!sc.isSuccess()) {
331  ATH_MSG_WARNING("Error in MDT data preparation.");
332  return sc;
333  }
334  ATH_MSG_DEBUG("nr of MDT (normal) hits=" << mdtHits_normal.size());
335  ATH_MSG_DEBUG("nr of MDT (overlap) hits=" << mdtHits_overlap.size());
336 
337  return StatusCode::SUCCESS;
338 }

◆ prepareData() [5/6]

StatusCode TrigL2MuonSA::MuFastDataPreparator::prepareData ( const xAOD::MuonRoI *  p_roi,
const TrigRoiDescriptor *  p_roids,
const bool  insideOut,
TrigL2MuonSA::TgcHits &  tgcHits,
TrigL2MuonSA::MuonRoad &  muonRoad,
TrigL2MuonSA::MdtRegion &  mdtRegion,
TrigL2MuonSA::TgcFitResult &  tgcFitResult,
TrigL2MuonSA::MdtHits &  mdtHits_normal,
TrigL2MuonSA::MdtHits &  mdtHits_overlap,
TrigL2MuonSA::CscHits &  cscHits,
TrigL2MuonSA::StgcHits &  stgcHits,
TrigL2MuonSA::MmHits &  mmHits 
) const

Definition at line 686 of file MuFastDataPreparator.cxx.

698 {
699  StatusCode sc = StatusCode::SUCCESS;
700  ATH_MSG_DEBUG("RoI eta/phi=" << p_roi->eta() << "/" << p_roi->phi());
701 
702  if(!insideOut) {
703  sc = m_tgcDataPreparator->prepareData(p_roi,
704  tgcHits);
705  } else {
706  ATH_MSG_DEBUG("Skip TgcDataPreparator");
707  }
708 
709  if (!sc.isSuccess()) {
710  ATH_MSG_DEBUG("Error in TGC data preparation. Continue using RoI");
711  }
712  ATH_MSG_DEBUG("nr of TGC hits=" << tgcHits.size());
713 
714  sc = m_tgcRoadDefiner->defineRoad(p_roids,
715  insideOut,
716  tgcHits,
717  muonRoad,
718  tgcFitResult);
719  if (!sc.isSuccess()) {
720  ATH_MSG_WARNING("Error in road definition.");
721  return sc;
722  }
723 
724  sc = m_mdtDataPreparator->prepareData(p_roids,
725  tgcFitResult,
726  muonRoad,
727  mdtRegion,
728  mdtHits_normal);
729 
730  if (!sc.isSuccess()) {
731  ATH_MSG_WARNING("Error in MDT data preparation.");
732  return sc;
733  }
734  ATH_MSG_DEBUG("nr of MDT (normal) hits=" << mdtHits_normal.size());
735  ATH_MSG_DEBUG("nr of MDT (overlap) hits=" << mdtHits_overlap.size());
736 
737  if(!m_cscDataPreparator.empty()) {
738  sc = m_cscDataPreparator->prepareData(muonRoad,
739  cscHits);
740  if (!sc.isSuccess()) {
741  ATH_MSG_WARNING("Error in CSC data preparation.");
742  return sc;
743  }
744  ATH_MSG_DEBUG("nr of CSC hits=" << cscHits.size());
745  }
746 
747  if(m_use_stgc && !m_stgcDataPreparator.empty()){
748  sc = m_stgcDataPreparator->prepareData(p_roids,
749  stgcHits);
750  if (!sc.isSuccess()) {
751  ATH_MSG_WARNING("Error in sTGC data preparation.");
752  return sc;
753  }
754  ATH_MSG_DEBUG("nr of sTGC hits=" << stgcHits.size());
755  }
756 
757  if(m_use_mm && !m_mmDataPreparator.empty()){
758  sc = m_mmDataPreparator->prepareData(p_roids,
759  mmHits);
760  if (!sc.isSuccess()) {
761  ATH_MSG_WARNING("Error in MM data preparation.");
762  return sc;
763  }
764  ATH_MSG_DEBUG("nr of MM hits=" << mmHits.size());
765  }
766 
767  return StatusCode::SUCCESS;
768 }

◆ prepareData() [6/6]

StatusCode TrigL2MuonSA::MuFastDataPreparator::prepareData ( const xAOD::MuonRoI *  p_roi,
const TrigRoiDescriptor *  p_roids,
std::vector< TrigL2MuonSA::MuonRoad > &  clusterRoad,
std::vector< TrigL2MuonSA::RpcFitResult > &  clusterFitResults,
TrigL2MuonSA::MdtHits &  mdtHits_normal,
TrigL2MuonSA::MdtHits &  mdtHits_overlap,
std::vector< TrigL2MuonSA::MdtHits > &  mdtHits_cluster_normal,
const bool  dynamicDeltaRpc 
) const

Definition at line 473 of file MuFastDataPreparator.cxx.

481 {
482 
483  ATH_MSG_DEBUG("RoI eta/phi=" << p_roi->eta() << "/" << p_roi->phi());
484  //RpcLayerClusters class is defined in ClusterPatFinder.h
485  TrigL2MuonSA::RpcLayerClusters rpcLayerClusters;
486  rpcLayerClusters.clear();
487 
488  // for MdtDataPreparator's input
489  TrigL2MuonSA::MdtRegion mdtRegion;
490  mdtRegion.Clear();
491 
492  StatusCode sc = StatusCode::SUCCESS;
493 
494  if(!m_use_rpc){
495 
496  } else {
497 
498  sc = m_rpcDataPreparator->prepareData(p_roids,
499  rpcLayerClusters,
500  &m_clusterPatFinder,
501  dynamicDeltaRpc);
502 
503  if (!sc.isSuccess()) {
504  ATH_MSG_DEBUG("Error in RPC data prepapration and clustering. Continue using RoI");
505  return sc;
506  }
507  }
508 
509  LVL1::TrigT1MuonRecRoiData data;
510  sc = m_recRPCRoiTool->roiData(p_roi->roiWord(),data);
511  if (!sc.isSuccess()){
512  ATH_MSG_WARNING("Error in roiWord decode");
513  return sc;
514  }
515  double roiEtaMinLow = 0.;
516  double roiEtaMaxLow = 0.;
517  double roiEtaMinHigh = 0.;
518  double roiEtaMaxHigh = 0.;
519  if(!m_recRPCRoiTool->etaDimLow(data, roiEtaMinLow, roiEtaMaxLow)) {
520  roiEtaMinLow = p_roids->eta();
521  roiEtaMaxLow = p_roids->eta();
522  }
523  if(!m_recRPCRoiTool->etaDimHigh(data, roiEtaMinHigh, roiEtaMaxHigh)) {
524  roiEtaMinHigh = p_roids->eta();
525  roiEtaMaxHigh = p_roids->eta();
526  }
527 
528  sc = m_clusterRoadDefiner->defineRoad(p_roi,
529  clusterRoad,
530  rpcLayerClusters,
531  &m_clusterPatFinder,
532  clusterFitResults,
533  roiEtaMinLow,
534  roiEtaMaxLow,
535  roiEtaMinHigh,
536  roiEtaMaxHigh);
537  if (!sc.isSuccess()) {
538  ATH_MSG_WARNING("Error in clusterRoad definition.");
539  return sc;
540 
541  }
542  if(!clusterRoad.empty()){
543  sc = m_mdtDataPreparator->prepareData(p_roids,
544  clusterFitResults.back(),
545  clusterRoad.back(),
546  mdtRegion,
547  mdtHits_normal);
548 
549  if (!sc.isSuccess()) {
550  ATH_MSG_WARNING("Error in MDT data preparation.");
551  return sc;
552  }
553 
554  ATH_MSG_DEBUG("nr of MDT (normal) hits=" << mdtHits_normal.size());
555  ATH_MSG_DEBUG("nr of MDT (overlap) hits=" << mdtHits_overlap.size());
556 
557  for(unsigned int i_road = 0; i_road < clusterRoad.size(); i_road++){
558  TrigL2MuonSA::MdtHits mdt_normal;
559  for(unsigned int i_hit = 0; i_hit < mdtHits_normal.size(); i_hit++){
560  unsigned int chamber = mdtHits_normal[i_hit].Chamber;
561 
562  if (chamber >= xAOD::L2MuonParameters::MaxChamber) continue;
563  double Z = mdtHits_normal[i_hit].Z;
564  double R = mdtHits_normal[i_hit].R;
565  double residual = 999999;
566  unsigned int clusterRoadID = 9999;
567  for(unsigned int j_road = 0; j_road < clusterRoad.size(); j_road++){
568  double aw = clusterRoad.at(j_road).aw[chamber][0];
569  double bw = clusterRoad.at(j_road).bw[chamber][0];
570  double tmp_residual;
571  const double ZERO_LIMIT = 1e-4;
572  if( std::abs(aw) < ZERO_LIMIT ){
573  tmp_residual = R-bw;
574  } else {
575  double ia = 1/aw;
576  double iaq = ia*ia;
577  double dz = Z - (R-bw)*ia;
578  tmp_residual = dz/std::sqrt(1.+iaq);
579  }
580  if(std::abs(residual) > std::abs(tmp_residual)){
581  residual = tmp_residual;
582  clusterRoadID = j_road;
583  }
584  }
585  if(clusterRoadID == i_road){
586  mdt_normal.push_back(mdtHits_normal[i_hit]);
587  }
588  }
589  mdtHits_cluster_normal.push_back(mdt_normal);
590  }
591  }
592 
593  return StatusCode::SUCCESS;
594 }

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

◆ setExtrapolatorTool()

void TrigL2MuonSA::MuFastDataPreparator::setExtrapolatorTool ( ToolHandle< ITrigMuonBackExtrapolator > *  backExtrapolator)

Definition at line 147 of file MuFastDataPreparator.cxx.

148 {
149  m_backExtrapolatorTool = backExtrapolator;
150  m_tgcRoadDefiner->setExtrapolatorTool(m_backExtrapolatorTool);
151  return;
152 }

◆ setGeometry()

StatusCode TrigL2MuonSA::MuFastDataPreparator::setGeometry ( bool  use_new_geometry)

◆ setMCFlag()

StatusCode TrigL2MuonSA::MuFastDataPreparator::setMCFlag ( const BooleanProperty &  use_mcLUT)

Definition at line 81 of file MuFastDataPreparator.cxx.

82 {
83  m_use_mcLUT = use_mcLUT;
84 
85  if (m_use_mcLUT) {
86  const ServiceHandle<TrigL2MuonSA::PtEndcapLUTSvc> ptEndcapLUTSvc("PtEndcapLUTSvc_MC", name());
87  if ( ptEndcapLUTSvc.retrieve().isFailure() ) {
88  ATH_MSG_DEBUG("Could not retrieve PtEndcapLUTSvc_MC");
89  return StatusCode::FAILURE;
90  }
91  m_tgcRoadDefiner->setPtLUT(&*ptEndcapLUTSvc);
92  } else {
93  const ServiceHandle<TrigL2MuonSA::PtEndcapLUTSvc> ptEndcapLUTSvc("PtEndcapLUTSvc", name());
94  if ( ptEndcapLUTSvc.retrieve().isFailure() ) {
95  ATH_MSG_DEBUG("Could not retrieve PtEndcapLUTSvc");
96  return StatusCode::FAILURE;
97  }
98  m_tgcRoadDefiner->setPtLUT(&*ptEndcapLUTSvc);
99  }
100 
101  return StatusCode::SUCCESS;
102 }

◆ setMmGeometry()

void TrigL2MuonSA::MuFastDataPreparator::setMmGeometry ( bool  use_mm)
inline

Definition at line 127 of file MuFastDataPreparator.h.

127 { m_use_mm = use_mm; };

◆ setOptions()

void TrigL2MuonSA::MuFastDataPreparator::setOptions ( const TrigL2MuonSA::MuFastDataPreparatorOptions &  options)

Definition at line 71 of file MuFastDataPreparator.cxx.

72 {
73  m_options = options;
74  m_tgcDataPreparator->setOptions(options.tgcOptions());
75  return;
76 }

◆ setRoadWidthForFailure()

void TrigL2MuonSA::MuFastDataPreparator::setRoadWidthForFailure ( double  rWidth_RPC_Failed,
double  rWidth_TGC_Failed 
)

Definition at line 107 of file MuFastDataPreparator.cxx.

109 {
110  m_rpcRoadDefiner->setRoadWidthForFailure(rWidth_RPC_Failed);
111  m_tgcRoadDefiner->setRoadWidthForFailure(rWidth_TGC_Failed);
112  return;
113 }

◆ setRoIBasedDataAccess()

void TrigL2MuonSA::MuFastDataPreparator::setRoIBasedDataAccess ( bool  use_RoIBasedDataAccess_MDT,
bool  use_RoIBasedDataAccess_RPC,
bool  use_RoIBasedDataAccess_TGC,
bool  use_RoIBasedDataAccess_CSC,
bool  use_RoIBasedDataAccess_STGC,
bool  use_RoIBasedDataAccess_MM 
)

Definition at line 128 of file MuFastDataPreparator.cxx.

134 {
135  m_mdtDataPreparator ->setRoIBasedDataAccess(use_RoIBasedDataAccess_MDT);
136  m_rpcDataPreparator ->setRoIBasedDataAccess(use_RoIBasedDataAccess_RPC);
137  m_tgcDataPreparator ->setRoIBasedDataAccess(use_RoIBasedDataAccess_TGC);
138  if(!m_cscDataPreparator.empty()) m_cscDataPreparator->setRoIBasedDataAccess(use_RoIBasedDataAccess_CSC);
139  if(!m_stgcDataPreparator.empty()) m_stgcDataPreparator->setRoIBasedDataAccess(use_RoIBasedDataAccess_STGC);
140  if(!m_mmDataPreparator.empty()) m_mmDataPreparator->setRoIBasedDataAccess(use_RoIBasedDataAccess_MM);
141  return;
142 }

◆ setRpcGeometry()

void TrigL2MuonSA::MuFastDataPreparator::setRpcGeometry ( bool  use_rpc)

Definition at line 118 of file MuFastDataPreparator.cxx.

119 {
120  m_rpcRoadDefiner->setRpcGeometry(use_rpc);
121 
122  m_use_rpc = use_rpc;
123  return;
124 }

◆ setStgcGeometry()

void TrigL2MuonSA::MuFastDataPreparator::setStgcGeometry ( bool  use_stgc)
inline

Definition at line 126 of file MuFastDataPreparator.h.

126 { m_use_stgc = use_stgc; };

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_backExtrapolatorTool

ToolHandle<ITrigMuonBackExtrapolator>* TrigL2MuonSA::MuFastDataPreparator::m_backExtrapolatorTool {nullptr}
private

Definition at line 159 of file MuFastDataPreparator.h.

◆ m_clusterPatFinder

ToolHandle<ClusterPatFinder> TrigL2MuonSA::MuFastDataPreparator::m_clusterPatFinder {this, "ClusterPatFinder", "TrigL2MuonSA::ClusterPatFinder"}
private

Definition at line 156 of file MuFastDataPreparator.h.

◆ m_clusterRoadDefiner

ToolHandle<ClusterRoadDefiner> TrigL2MuonSA::MuFastDataPreparator::m_clusterRoadDefiner {this, "ClusterRoadDefiner", "TrigL2MuonSA::ClusterRoadDefiner"}
private

Definition at line 155 of file MuFastDataPreparator.h.

◆ m_cscDataPreparator

ToolHandle<CscDataPreparator> TrigL2MuonSA::MuFastDataPreparator::m_cscDataPreparator {this, "CSCDataPreparator", "TrigL2MuonSA::CscDataPreparator"}
private

Definition at line 146 of file MuFastDataPreparator.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_mdtDataPreparator

ToolHandle<MdtDataPreparator> TrigL2MuonSA::MuFastDataPreparator::m_mdtDataPreparator {this, "MDTDataPreparator", "TrigL2MuonSA::MdtDataPreparator"}
private

Definition at line 145 of file MuFastDataPreparator.h.

◆ m_mmDataPreparator

ToolHandle<MmDataPreparator> TrigL2MuonSA::MuFastDataPreparator::m_mmDataPreparator {this, "MMDataPreparator", "TrigL2MuonSA::MmDataPreparator"}
private

Definition at line 148 of file MuFastDataPreparator.h.

◆ m_options

TrigL2MuonSA::MuFastDataPreparatorOptions TrigL2MuonSA::MuFastDataPreparator::m_options
private

Definition at line 140 of file MuFastDataPreparator.h.

◆ m_recRPCRoiTool

ToolHandle<LVL1::ITrigT1MuonRecRoiTool> TrigL2MuonSA::MuFastDataPreparator::m_recRPCRoiTool {this, "TrigT1RPCRecRoiTool", "LVL1::TrigT1RPCRecRoiTool/TrigT1RPCRecRoiTool"}
private

Definition at line 142 of file MuFastDataPreparator.h.

◆ m_rpcDataPreparator

ToolHandle<RpcDataPreparator> TrigL2MuonSA::MuFastDataPreparator::m_rpcDataPreparator {this, "RPCDataPreparator", "TrigL2MuonSA::RpcDataPreparator"}
private

Definition at line 143 of file MuFastDataPreparator.h.

◆ m_rpcPatFinder

ToolHandle<RpcPatFinder> TrigL2MuonSA::MuFastDataPreparator::m_rpcPatFinder {"TrigL2MuonSA::RpcPatFinder"}
private

Definition at line 152 of file MuFastDataPreparator.h.

◆ m_rpcRoadDefiner

ToolHandle<RpcRoadDefiner> TrigL2MuonSA::MuFastDataPreparator::m_rpcRoadDefiner {this, "RpcRoadDefiner", "TrigL2MuonSA::RpcRoadDefiner"}
private

Definition at line 150 of file MuFastDataPreparator.h.

◆ m_stgcDataPreparator

ToolHandle<StgcDataPreparator> TrigL2MuonSA::MuFastDataPreparator::m_stgcDataPreparator {this,"STGCDataPreparator","TrigL2MuonSA::StgcDataPreparator"}
private

Definition at line 147 of file MuFastDataPreparator.h.

◆ m_tgcDataPreparator

ToolHandle<TgcDataPreparator> TrigL2MuonSA::MuFastDataPreparator::m_tgcDataPreparator {this, "TGCDataPreparator", "TrigL2MuonSA::TgcDataPreparator"}
private

Definition at line 144 of file MuFastDataPreparator.h.

◆ m_tgcRoadDefiner

ToolHandle<TgcRoadDefiner> TrigL2MuonSA::MuFastDataPreparator::m_tgcRoadDefiner {this, "TgcRoadDefiner", "TrigL2MuonSA::TgcRoadDefiner"}
private

Definition at line 151 of file MuFastDataPreparator.h.

◆ m_use_mcLUT

bool TrigL2MuonSA::MuFastDataPreparator::m_use_mcLUT {false}
private

Definition at line 164 of file MuFastDataPreparator.h.

◆ m_use_mm

bool TrigL2MuonSA::MuFastDataPreparator::m_use_mm {false}
private

Definition at line 163 of file MuFastDataPreparator.h.

◆ m_use_rpc

bool TrigL2MuonSA::MuFastDataPreparator::m_use_rpc {false}
private

Definition at line 161 of file MuFastDataPreparator.h.

◆ m_use_stgc

bool TrigL2MuonSA::MuFastDataPreparator::m_use_stgc {false}
private

Definition at line 162 of file MuFastDataPreparator.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:
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
LVL1::TrigT1MuonRecRoiData
Definition: TrigT1MuonRecRoiData.h:10
TrigL2MuonSA::MuFastDataPreparator::m_backExtrapolatorTool
ToolHandle< ITrigMuonBackExtrapolator > * m_backExtrapolatorTool
Definition: MuFastDataPreparator.h:159
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
TrigL2MuonSA::MuFastDataPreparator::m_clusterPatFinder
ToolHandle< ClusterPatFinder > m_clusterPatFinder
Definition: MuFastDataPreparator.h:156
TrigL2MuonSA::RpcLayerClusters::clear
void clear()
Definition: ClusterPatFinder.h:63
TrigL2MuonSA::MuFastDataPreparator::m_recRPCRoiTool
ToolHandle< LVL1::ITrigT1MuonRecRoiTool > m_recRPCRoiTool
Definition: MuFastDataPreparator.h:142
ClusterSeg::residual
@ residual
Definition: ClusterNtuple.h:20
calibdata.chamber
chamber
Definition: calibdata.py:32
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Monitored::Z
@ Z
Definition: HistogramFillerUtils.h:24
TrigL2MuonSA::MuFastDataPreparator::m_mdtDataPreparator
ToolHandle< MdtDataPreparator > m_mdtDataPreparator
Definition: MuFastDataPreparator.h:145
TrigL2MuonSA::MdtHits
std::vector< MdtHitData > MdtHits
Definition: MdtData.h:57
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
xAOD::MuonRoI_v1::eta
float eta() const
The pseudorapidity ( ) of the muon candidate.
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
TrigL2MuonSA::MuFastDataPreparator::m_use_mcLUT
bool m_use_mcLUT
Definition: MuFastDataPreparator.h:164
TrigL2MuonSA::MdtRegion::Clear
void Clear()
Definition: MdtRegion.h:18
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
LVL1::RecMuonRoI::eta
virtual double eta() const
returns eta coord of ROI
Definition: RecMuonRoI.h:117
TrigL2MuonSA::MdtRegion
Definition: MdtRegion.h:14
LVL1::RecMuonRoI::roiWord
virtual unsigned int roiWord() const
returns roi word
Definition: RecMuonRoI.h:102
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
TrigL2MuonSA::MuFastDataPreparator::m_rpcRoadDefiner
ToolHandle< RpcRoadDefiner > m_rpcRoadDefiner
Definition: MuFastDataPreparator.h:150
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TrigL2MuonSA::MuFastDataPreparator::m_options
TrigL2MuonSA::MuFastDataPreparatorOptions m_options
Definition: MuFastDataPreparator.h:140
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
TrigL2MuonSA::MuFastDataPreparator::m_mmDataPreparator
ToolHandle< MmDataPreparator > m_mmDataPreparator
Definition: MuFastDataPreparator.h:148
xAOD::L2MuonParameters::MaxChamber
@ MaxChamber
Number of measurement point definitions.
Definition: TrigMuonDefs.h:27
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
test_pyathena.parent
parent
Definition: test_pyathena.py:15
TrigL2MuonSA::RpcLayerClusters
Definition: ClusterPatFinder.h:58
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TrigL2MuonSA::MuFastDataPreparator::m_rpcPatFinder
ToolHandle< RpcPatFinder > m_rpcPatFinder
Definition: MuFastDataPreparator.h:152
python.AtlRunQueryLib.options
options
Definition: AtlRunQueryLib.py:379
AnalysisUtils::Delta::R
double R(const INavigable4Momentum *p1, const double v_eta, const double v_phi)
Definition: AnalysisMisc.h:49
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
TrigL2MuonSA::MuFastDataPreparator::m_use_rpc
bool m_use_rpc
Definition: MuFastDataPreparator.h:161
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
ZERO_LIMIT
const float ZERO_LIMIT
Definition: VP1TriggerHandleL2.cxx:37
TrigL2MuonSA::RpcLayerHits::clear
void clear()
Definition: RpcPatFinder.h:25
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
TrigL2MuonSA::MuFastDataPreparator::m_rpcDataPreparator
ToolHandle< RpcDataPreparator > m_rpcDataPreparator
Definition: MuFastDataPreparator.h:143
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
LVL1::RecMuonRoI::phi
virtual double phi() const
returns phi coord of ROI
Definition: RecMuonRoI.h:114
TrigL2MuonSA::MuFastDataPreparator::m_stgcDataPreparator
ToolHandle< StgcDataPreparator > m_stgcDataPreparator
Definition: MuFastDataPreparator.h:147
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
TrigL2MuonSA::RpcLayerHits
Definition: RpcPatFinder.h:20
TrigL2MuonSA::MuFastDataPreparator::m_use_stgc
bool m_use_stgc
Definition: MuFastDataPreparator.h:162
TrigL2MuonSA::MuFastDataPreparator::m_cscDataPreparator
ToolHandle< CscDataPreparator > m_cscDataPreparator
Definition: MuFastDataPreparator.h:146
TrigL2MuonSA::MuFastDataPreparator::m_clusterRoadDefiner
ToolHandle< ClusterRoadDefiner > m_clusterRoadDefiner
Definition: MuFastDataPreparator.h:155
TrigL2MuonSA::MuFastDataPreparator::m_tgcRoadDefiner
ToolHandle< TgcRoadDefiner > m_tgcRoadDefiner
Definition: MuFastDataPreparator.h:151
a
TList * a
Definition: liststreamerinfos.cxx:10
h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
RoiDescriptor::eta
virtual double eta() const override final
Definition: RoiDescriptor.h:101
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
TrigL2MuonSA::MuFastDataPreparator::m_tgcDataPreparator
ToolHandle< TgcDataPreparator > m_tgcDataPreparator
Definition: MuFastDataPreparator.h:144
TrigL2MuonSA::MuFastDataPreparator::m_use_mm
bool m_use_mm
Definition: MuFastDataPreparator.h:163
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
xAOD::MuonRoI_v1::roiWord
uint32_t roiWord() const
The "raw" RoI word describing the muon candidate.
fitman.k
k
Definition: fitman.py:528
ServiceHandle
Definition: ClusterMakerTool.h:37
xAOD::MuonRoI_v1::phi
float phi() const
The azimuthal angle ( ) of the muon candidate.
Generated on Mon Dec 23 2024 22:10:01 for ATLAS Offline Software by   doxygen 1.8.18