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

#include <MuFastSteering.h>

Inheritance diagram for MuFastSteering:
Collaboration diagram for MuFastSteering:

Public Types

enum  {
  ITIMER_DATA_PREPARATOR =0, ITIMER_PATTERN_FINDER, ITIMER_STATION_FITTER, ITIMER_TRACK_FITTER,
  ITIMER_TRACK_EXTRAPOLATOR, ITIMER_CALIBRATION_STREAMER, ITIMER_TOTAL_PROCESSING
}
 

Public Member Functions

 MuFastSteering (const std::string &name, ISvcLocator *svc)
 Constructor. More...
 
virtual StatusCode initialize () override
 
virtual StatusCode stop () override
 
virtual StatusCode execute (const EventContext &ctx) const override
 execute(), main code of the algorithm for AthenaMT More...
 
StatusCode findMuonSignature (const std::vector< const TrigRoiDescriptor * > &roi, const std::vector< const LVL1::RecMuonRoI * > &muonRoIs, DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputID, TrigRoiDescriptorCollection &outputMS, const bool dynamicDeltaRpc, const EventContext &ctx) const
 findMuonSignature(), includes reconstract algorithms More...
 
StatusCode findMuonSignature (const std::vector< const TrigRoiDescriptor * > &roi, const std::vector< const xAOD::MuonRoI * > &muonRoIs, DataVector< xAOD::L2StandAloneMuon > &outputTracks, xAOD::TrigCompositeContainer &outputMuonCal, TrigRoiDescriptorCollection &outputID, TrigRoiDescriptorCollection &outputMS, const bool dynamicDeltaRpc, const EventContext &ctx) const
 
StatusCode findMuonSignatureIO (const xAOD::TrackParticleContainer &idtracks, const std::vector< const TrigRoiDescriptor * > &roids, const std::vector< const LVL1::RecMuonRoI * > &muonRoIs, DataVector< xAOD::L2CombinedMuon > &outputCBs, DataVector< xAOD::L2StandAloneMuon > &outputSAs, const bool dynamicDeltaRpc, const EventContext &ctx) const
 findMuonSignatureIO(), includes reconstract algorithms for inside-out mode More...
 
StatusCode findMuonSignatureIO (const xAOD::TrackParticleContainer &idtracks, const std::vector< const TrigRoiDescriptor * > &roids, const std::vector< const xAOD::MuonRoI * > &muonRoIs, DataVector< xAOD::L2CombinedMuon > &outputCBs, DataVector< xAOD::L2StandAloneMuon > &outputSAs, const bool dynamicDeltaRpc, const EventContext &ctx) const
 
StatusCode findMultiTrackSignature (const std::vector< const TrigRoiDescriptor * > &roi, const std::vector< const LVL1::RecMuonRoI * > &muonRoIs, DataVector< xAOD::L2StandAloneMuon > &outputTracks, const bool dynamicDeltaRpc, const EventContext &ctx) const
 findMultiTrackSignature(), includes reconstract algorithms for multi-track mode More...
 
StatusCode findMultiTrackSignature (const std::vector< const TrigRoiDescriptor * > &roi, const std::vector< const xAOD::MuonRoI * > &muonRoIs, DataVector< xAOD::L2StandAloneMuon > &outputTracks, const bool dynamicDeltaRpc, const EventContext &ctx) const
 
int L2MuonAlgoMap (const std::string &name) const
 
virtual void handle (const Incident &incident) override
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
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 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

bool updateOutputObjects (const LVL1::RecMuonRoI *roi, const TrigRoiDescriptor *roids, const TrigL2MuonSA::MuonRoad &muonRoad, const TrigL2MuonSA::MdtRegion &mdtRegion, const TrigL2MuonSA::RpcHits &rpcHits, const TrigL2MuonSA::TgcHits &tgcHits, const TrigL2MuonSA::RpcFitResult &rpcFitResult, const TrigL2MuonSA::TgcFitResult &tgcFitResult, const TrigL2MuonSA::MdtHits &mdtHits, const TrigL2MuonSA::CscHits &cscHits, const TrigL2MuonSA::StgcHits &stgcHits, const TrigL2MuonSA::MmHits &mmHits, const std::vector< TrigL2MuonSA::TrackPattern > &trackPatterns, DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputID, TrigRoiDescriptorCollection &outputMS, const EventContext &ctx) const
 Called at the end of the algorithm processing to set the steering navigation properly. More...
 
bool updateOutputObjects (const xAOD::MuonRoI *roi, const TrigRoiDescriptor *roids, const TrigL2MuonSA::MuonRoad &muonRoad, const TrigL2MuonSA::MdtRegion &mdtRegion, const TrigL2MuonSA::RpcHits &rpcHits, const TrigL2MuonSA::TgcHits &tgcHits, const TrigL2MuonSA::RpcFitResult &rpcFitResult, const TrigL2MuonSA::TgcFitResult &tgcFitResult, const TrigL2MuonSA::MdtHits &mdtHits, const TrigL2MuonSA::CscHits &cscHits, const TrigL2MuonSA::StgcHits &stgcHits, const TrigL2MuonSA::MmHits &mmHits, const std::vector< TrigL2MuonSA::TrackPattern > &trackPatterns, DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputID, TrigRoiDescriptorCollection &outputMS, const EventContext &ctx) const
 
bool storeMuonSA (const LVL1::RecMuonRoI *roi, const TrigRoiDescriptor *roids, const TrigL2MuonSA::MuonRoad &muonRoad, const TrigL2MuonSA::MdtRegion &mdtRegion, const TrigL2MuonSA::RpcHits &rpcHits, const TrigL2MuonSA::TgcHits &tgcHits, const TrigL2MuonSA::RpcFitResult &rpcFitResult, const TrigL2MuonSA::TgcFitResult &tgcFitResult, const TrigL2MuonSA::MdtHits &mdtHits, const TrigL2MuonSA::CscHits &cscHits, const TrigL2MuonSA::StgcHits &stgcHits, const TrigL2MuonSA::MmHits &mmHits, const TrigL2MuonSA::TrackPattern &pattern, DataVector< xAOD::L2StandAloneMuon > &outputTracks, const EventContext &ctx) const
 
bool storeMuonSA (const xAOD::MuonRoI *roi, const TrigRoiDescriptor *roids, const TrigL2MuonSA::MuonRoad &muonRoad, const TrigL2MuonSA::MdtRegion &mdtRegion, const TrigL2MuonSA::RpcHits &rpcHits, const TrigL2MuonSA::TgcHits &tgcHits, const TrigL2MuonSA::RpcFitResult &rpcFitResult, const TrigL2MuonSA::TgcFitResult &tgcFitResult, const TrigL2MuonSA::MdtHits &mdtHits, const TrigL2MuonSA::CscHits &cscHits, const TrigL2MuonSA::StgcHits &stgcHits, const TrigL2MuonSA::MmHits &mmHits, const TrigL2MuonSA::TrackPattern &pattern, DataVector< xAOD::L2StandAloneMuon > &outputTracks, const EventContext &ctx) const
 
bool storeMSRoiDescriptor (const TrigRoiDescriptor *roids, const TrigL2MuonSA::TrackPattern &pattern, const DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputMS) const
 
bool storeIDRoiDescriptor (const TrigRoiDescriptor *roids, const TrigL2MuonSA::TrackPattern &pattern, const DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputID) const
 
StatusCode updateMonitor (const LVL1::RecMuonRoI *roi, const TrigL2MuonSA::MdtHits &mdtHits, std::vector< TrigL2MuonSA::TrackPattern > &trackPatterns) const
 Update monitoring variables. More...
 
StatusCode updateMonitor (const xAOD::MuonRoI *roi, const TrigL2MuonSA::MdtHits &mdtHits, std::vector< TrigL2MuonSA::TrackPattern > &trackPatterns) const
 
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...
 

Protected Attributes

ToolHandle< TrigL2MuonSA::MuFastDataPreparator > m_dataPreparator
 
ToolHandle< TrigL2MuonSA::MuFastPatternFinder > m_patternFinder
 
ToolHandle< TrigL2MuonSA::MuFastStationFitter > m_stationFitter
 
ToolHandle< TrigL2MuonSA::MuFastTrackFitter > m_trackFitter
 
ToolHandle< TrigL2MuonSA::MuFastTrackExtrapolator > m_trackExtrapolator
 
ToolHandle< TrigL2MuonSA::FtfRoadDefiner > m_ftfRoadDefiner
 
ToolHandle< ITrigMuonBackExtrapolator > m_backExtrapolatorTool
 Handle to MuonBackExtrapolator tool. More...
 
ToolHandle< TrigL2MuonSA::MuCalStreamerTool > m_calStreamer
 
TrigL2MuonSA::RecMuonRoIUtils m_recMuonRoIUtils
 
ToolHandle< TrigL2MuonSA::CscSegmentMaker > m_cscsegmaker
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

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

Private Attributes

ServiceHandle< IIncidentSvc > m_incidentSvc {this, "IncidentSvc", "IncidentSvc"}
 
ServiceHandle< Gaudi::Interfaces::IOptionsSvc > m_jobOptionsSvc {this, "JobOptionsSvc", "JobOptionsSvc", "Job options service to retrieve DataFlowConfig" }
 
Gaudi::Property< float > m_scaleRoadBarrelInner { this, "Scale_Road_BarrelInner", 1 }
 
Gaudi::Property< float > m_scaleRoadBarrelMiddle { this, "Scale_Road_BarrelMiddle", 1 }
 
Gaudi::Property< float > m_scaleRoadBarrelOuter { this, "Scale_Road_BarrelOuter", 1 }
 
Gaudi::Property< bool > m_use_mcLUT { this, "UseLUTForMC", true}
 
Gaudi::Property< bool > m_use_new_segmentfit { this, "USE_NEW_SEGMENTFIT", true}
 
Gaudi::Property< bool > m_use_rpc { this, "USE_RPC", true}
 
Gaudi::Property< bool > m_use_stgc { this, "USE_STGC", true}
 
Gaudi::Property< bool > m_use_mm { this, "USE_MM", true}
 
Gaudi::Property< bool > m_use_RoIBasedDataAccess_MDT { this, "USE_ROIBASEDACCESS_MDT", true}
 
Gaudi::Property< bool > m_use_RoIBasedDataAccess_RPC { this, "USE_ROIBASEDACCESS_RPC", true}
 
Gaudi::Property< bool > m_use_RoIBasedDataAccess_TGC { this, "USE_ROIBASEDACCESS_TGC", true}
 
Gaudi::Property< bool > m_use_RoIBasedDataAccess_CSC { this, "USE_ROIBASEDACCESS_CSC", true}
 
Gaudi::Property< bool > m_use_RoIBasedDataAccess_STGC { this, "USE_ROIBASEDACCESS_STGC", true}
 
Gaudi::Property< bool > m_use_RoIBasedDataAccess_MM { this, "USE_ROIBASEDACCESS_MM", true}
 
Gaudi::Property< bool > m_doCalStream { this, "DoCalibrationStream", true}
 
Gaudi::Property< bool > m_calDataScouting { this, "MuonCalDataScouting", false}
 
Gaudi::Property< bool > m_rpcErrToDebugStream { this, "RpcErrToDebugStream", false}
 
Gaudi::Property< bool > m_use_endcapInnerFromBarrel { this, "UseEndcapInnerFromBarrel", false}
 
Gaudi::Property< int > m_esd_rpc_size { this, "ESD_RPC_size", 100 }
 
Gaudi::Property< int > m_esd_tgc_size { this, "ESD_TGC_size", 50 }
 
Gaudi::Property< int > m_esd_mdt_size { this, "ESD_MDT_size", 100 }
 
Gaudi::Property< int > m_esd_csc_size { this, "ESD_CSC_size", 100 }
 
Gaudi::Property< int > m_esd_stgc_size { this, "ESD_STGC_size", 100 }
 
Gaudi::Property< int > m_esd_mm_size { this, "ESD_MM_size", 100 }
 
Gaudi::Property< double > m_rWidth_RPC_Failed { this, "R_WIDTH_RPC_FAILED", 400 }
 
Gaudi::Property< double > m_rWidth_TGC_Failed { this, "R_WIDTH_TGC_FAILED", 200 }
 
Gaudi::Property< double > m_winPt { this, "WinPt", 4.0 }
 
Gaudi::Property< bool > m_insideOut { this, "InsideOutMode", false, "" }
 
Gaudi::Property< bool > m_multiTrack { this, "multitrackMode", false, "" }
 
Gaudi::Property< bool > m_doEndcapForl2mt { this, "doEndcapForl2mt", false, "" }
 
Gaudi::Property< float > m_ftfminPt { this, "FTFminPt", 3500, "pT [MeV] threshold to FTF tracks for L2Muon Inside-out mode" }
 
Gaudi::Property< bool > m_topoRoad { this, "topoRoad", false, "create road in barrel not to highly overlap surrounding L1 RoIs" }
 
Gaudi::Property< float > m_dPhisurrRoI { this, "dPhisurrRoI", 99, "phi range to find surrounding L1 RoIs" }
 
Gaudi::Property< float > m_dEtasurrRoI { this, "dEtasurrRoI", 99, "eta range to find surrounding L1 RoIs" }
 
Gaudi::Property< bool > m_allowOksConfig { this, "AllowOksConfig", true}
 
Gaudi::Property< std::string > m_calBufferName { this, "MuonCalBufferName", "/tmp/testOutput"}
 
Gaudi::Property< int > m_calBufferSize { this, "MuonCalBufferSize", 1024*1024}
 
Gaudi::Property< bool > m_fill_FSIDRoI { this, "FILL_FSIDRoI", false, "Fill FS RoI for ID (will be used in cosmic run)"}
 
Gaudi::Property< bool > m_useRun3Config { this, "UseRun3Config", false, "use Run3 L1Muon EDM; xAOD::MuonRoI"}
 
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
 
SG::ReadHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey
 
SG::ReadHandleKey< DataVector< LVL1::RecMuonRoI > > m_run2recRoiCollectionKey
 
SG::ReadHandleKey< xAOD::MuonRoIContainer > m_recRoiCollectionKey
 
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_FTFtrackKey
 
SG::WriteHandleKey< xAOD::L2StandAloneMuonContainer > m_muFastContainerKey
 
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_muCompositeContainerKey
 
SG::WriteHandleKey< TrigRoiDescriptorCollection > m_muIdContainerKey
 
SG::WriteHandleKey< TrigRoiDescriptorCollection > m_muMsContainerKey
 
SG::WriteHandleKey< xAOD::L2CombinedMuonContainer > m_outputCBmuonCollKey
 
ToolHandle< GenericMonitoringTool > m_monTool { this, "MonTool", "", "Monitoring tool" }
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
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 44 of file MuFastSteering.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
Enumerator
ITIMER_DATA_PREPARATOR 
ITIMER_PATTERN_FINDER 
ITIMER_STATION_FITTER 
ITIMER_TRACK_FITTER 
ITIMER_TRACK_EXTRAPOLATOR 
ITIMER_CALIBRATION_STREAMER 
ITIMER_TOTAL_PROCESSING 

Definition at line 47 of file MuFastSteering.h.

47  {
48  ITIMER_DATA_PREPARATOR=0,
49  ITIMER_PATTERN_FINDER,
50  ITIMER_STATION_FITTER,
51  ITIMER_TRACK_FITTER,
52  ITIMER_TRACK_EXTRAPOLATOR,
53  ITIMER_CALIBRATION_STREAMER,
54  ITIMER_TOTAL_PROCESSING
55  };

Constructor & Destructor Documentation

◆ MuFastSteering()

MuFastSteering::MuFastSteering ( const std::string &  name,
ISvcLocator *  svc 
)

Constructor.

Definition at line 22 of file MuFastSteering.cxx.

23  : AthReentrantAlgorithm(name, svc),
24  m_recMuonRoIUtils()
25 {
26 }

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality
overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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 MuFastSteering::execute ( const EventContext &  ctx) const
overridevirtual

execute(), main code of the algorithm for AthenaMT

Definition at line 232 of file MuFastSteering.cxx.

233 {
234  auto totalTimer = Monitored::Timer( "TIME_Total" );
235  auto monitorIt = Monitored::Group(m_monTool, totalTimer );
236 
237  // retrieve with ReadHandle
238  auto roiCollectionHandle = SG::makeHandle( m_roiCollectionKey, ctx );
239  const TrigRoiDescriptorCollection *roiCollection = roiCollectionHandle.cptr();
240  if (!roiCollectionHandle.isValid()){
241  ATH_MSG_ERROR("ReadHandle for TrigRoiDescriptorCollection key:" << m_roiCollectionKey.key() << " isn't Valid");
242  return StatusCode::FAILURE;
243  }
244 
245  if(m_useRun3Config) {
246 
247  auto recRoiCollectionHandle = SG::makeHandle( m_recRoiCollectionKey, ctx );
248  const xAOD::MuonRoIContainer *recRoiCollection = recRoiCollectionHandle.cptr();
249  if (!recRoiCollectionHandle.isValid()){
250  ATH_MSG_ERROR("ReadHandle for xAOD::MuonRoIContainer key:" << m_recRoiCollectionKey.key() << " isn't Valid");
251  return StatusCode::FAILURE;
252  }
253 
254  std::vector< const TrigRoiDescriptor* > internalRoI;
255  TrigRoiDescriptorCollection::const_iterator p_roids = roiCollection->begin();
256  TrigRoiDescriptorCollection::const_iterator p_roidsEn = roiCollection->end();
257 
258  for(; p_roids != p_roidsEn; ++p_roids ) {
259  internalRoI.push_back(*p_roids);
260  ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " eta = " << "(" << (*p_roids)->etaMinus() << ")" << (*p_roids)->eta() << "(" << (*p_roids)->etaPlus() << ")");
261  ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " phi = " << "(" << (*p_roids)->phiMinus() << ")" << (*p_roids)->phi() << "(" << (*p_roids)->phiPlus() << ")");
262  ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " zed = " << "(" << (*p_roids)->zedMinus() << ")" << (*p_roids)->zed() << "(" << (*p_roids)->zedPlus() << ")");
263  }
264  ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " size = " << internalRoI.size());
265 
266  // make RecMURoIs maching with MURoIs
267  std::vector< const xAOD::MuonRoI* > recRoIVector;
268  std::vector< const xAOD::MuonRoI* > surrRoIs;
269 
270  for (size_t size=0; size<roiCollection->size(); size++){
271  const xAOD::MuonRoI* recRoI = matchingRecRoI( roiCollection->at(size)->roiWord(), *recRoiCollection );
272  if( recRoI == nullptr ) continue;
273  recRoIVector.push_back(recRoI);
274  ATH_MSG_DEBUG("REGTEST: " << m_recRoiCollectionKey.key() << " eta/phi = " << (recRoI)->eta() << "/" << (recRoI)->phi());
275  ATH_MSG_DEBUG("REGTEST: " << m_recRoiCollectionKey.key() << " size = " << recRoIVector.size());
276  }
277 
278  bool dynamicDeltaRpc = false;
279  int nPassedBarrelSurrRoi = 0;
280  if(m_topoRoad ){
281  for( const auto recRoI: *recRoiCollection ){
282  if(std::find(recRoIVector.begin(), recRoIVector.end(), recRoI) != recRoIVector.end()) continue;
283 
284  bool surrounding = false;
285  for( const auto matchedRoI: recRoIVector ){
286  float deta = std::abs(recRoI->eta() - matchedRoI->eta());
287  float dphi = std::abs(recRoI->phi() - matchedRoI->phi());
288  if( dphi > M_PI )dphi = 2.*M_PI - dphi;
289  if( deta < m_dEtasurrRoI && dphi < m_dPhisurrRoI)
290  surrounding = true;
291  }
292 
293  if(surrounding)
294  surrRoIs.push_back(recRoI);
295  }
296 
297  ATH_MSG_DEBUG("surrRoI: " << " size = " << surrRoIs.size());
298  for( const auto recRoI: surrRoIs ){
299  ATH_MSG_DEBUG("surrRoI: " << " eta/phi = " << (recRoI)->eta() << "/" << (recRoI)->phi() );
300  if( std::abs((recRoI)->eta()) <= 1.05 && (recRoI)->getThrNumber() >= 1 )nPassedBarrelSurrRoi++;
301  }
302  ATH_MSG_DEBUG( "nPassedBarrelSurrRoi = " << nPassedBarrelSurrRoi);
303  //dynamicDeltaRpcMode
304  if( nPassedBarrelSurrRoi >= 1 )
305  dynamicDeltaRpc = true;
306  }
307 
308  // record data objects with WriteHandle
309  auto muFastContainer = SG::makeHandle(m_muFastContainerKey, ctx);
310  ATH_CHECK(muFastContainer.record(std::make_unique<xAOD::L2StandAloneMuonContainer>(), std::make_unique<xAOD::L2StandAloneMuonAuxContainer>()));
311 
312  auto muCompositeContainer = SG::makeHandle(m_muCompositeContainerKey, ctx);
313  ATH_CHECK(muCompositeContainer.record(std::make_unique<xAOD::TrigCompositeContainer>(), std::make_unique<xAOD::TrigCompositeAuxContainer>()));
314 
315  auto muIdContainer = SG::makeHandle(m_muIdContainerKey, ctx);
316  ATH_CHECK(muIdContainer.record(std::make_unique<TrigRoiDescriptorCollection>()));
317 
318  auto muMsContainer = SG::makeHandle(m_muMsContainerKey, ctx);
319  ATH_CHECK(muMsContainer.record(std::make_unique<TrigRoiDescriptorCollection>()));
320 
321 
322  // Inside-out L2Muon mode
323  if(m_insideOut) {
324  ATH_MSG_DEBUG("start inside-out mode...");
325 
326  auto muonCBColl = SG::makeHandle (m_outputCBmuonCollKey, ctx);
327  ATH_CHECK( muonCBColl.record (std::make_unique<xAOD::L2CombinedMuonContainer>(),
328  std::make_unique<xAOD::L2CombinedMuonAuxContainer>()) );
329 
330  auto trackHandle = SG::makeHandle( m_FTFtrackKey, ctx );
331  if (!trackHandle.isValid()){
332  ATH_MSG_ERROR("ReadHandle for TrackParticleContainer key:" << m_FTFtrackKey.key() << " isn't Valid");
333  return StatusCode::FAILURE;
334  }
335  const xAOD::TrackParticleContainer *tracks = trackHandle.cptr();
336 
337  ATH_CHECK(findMuonSignatureIO(*tracks, internalRoI, recRoIVector,
338  *muonCBColl, *muFastContainer, dynamicDeltaRpc, ctx ));
339 
340  if (msgLvl(MSG::DEBUG)) {
341  ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " size = " << muonCBColl->size());
342  for (const auto p_CBmuon : *muonCBColl){
343  ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " pt = " << (*p_CBmuon).pt() << " GeV");
344  ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " eta/phi = " << (*p_CBmuon).eta() << "/" << (*p_CBmuon).phi());
345  }
346  }
347 
348  }
349  else if(m_multiTrack){ //multi-track SA mode
350  ATH_MSG_DEBUG("start multi-track SA mode...");
351  ATH_CHECK(findMultiTrackSignature(internalRoI, recRoIVector, *muFastContainer, dynamicDeltaRpc, ctx));
352  }
353  else {
354  // to StatusCode findMuonSignature()
355  ATH_CHECK(findMuonSignature(internalRoI, recRoIVector,
356  *muFastContainer, *muCompositeContainer, *muIdContainer, *muMsContainer, dynamicDeltaRpc, ctx));
357  }
358 
359  if (msgLvl(MSG::DEBUG)) {
360  // DEBUG TEST: Recorded data objects
361  ATH_MSG_DEBUG("Recorded data objects");
362  ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " size = " << muFastContainer->size());
363 
364  for (auto p_muon : *muFastContainer) {
365  ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " pt = " << (*p_muon).pt() << " GeV");
366  ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " eta/phi = " << (*p_muon).eta() << "/" << (*p_muon).phi());
367  }
368 
369  ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muIdContainerKey.key() << " size = " << muIdContainer->size());
370  for (auto p_muonID : *muIdContainer) {
371  ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muIdContainerKey.key() << " eta/phi = " << (*p_muonID).eta() << "/" << (*p_muonID).phi());
372  }
373 
374  ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muMsContainerKey.key() << " size = " << muMsContainer->size());
375  for (auto p_muonMS : *muMsContainer) {
376  ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muMsContainerKey.key() << " eta/phi = " << (*p_muonMS).eta() << "/" << (*p_muonMS).phi());
377  }
378  }
379 
380  }
381  else { // use Run2 L1Muon EDM
382 
383  auto recRoiCollectionHandle = SG::makeHandle( m_run2recRoiCollectionKey, ctx );
384  const DataVector<LVL1::RecMuonRoI> *recRoiCollection = recRoiCollectionHandle.cptr();
385  if (!recRoiCollectionHandle.isValid()){
386  ATH_MSG_ERROR("ReadHandle for DataVector<LVL1::RecMuonRoI> key:" << m_run2recRoiCollectionKey.key() << " isn't Valid");
387  return StatusCode::FAILURE;
388  }
389 
390  std::vector< const TrigRoiDescriptor* > internalRoI;
391  TrigRoiDescriptorCollection::const_iterator p_roids = roiCollection->begin();
392  TrigRoiDescriptorCollection::const_iterator p_roidsEn = roiCollection->end();
393 
394  for(; p_roids != p_roidsEn; ++p_roids ) {
395  internalRoI.push_back(*p_roids);
396  ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " eta = " << "(" << (*p_roids)->etaMinus() << ")" << (*p_roids)->eta() << "(" << (*p_roids)->etaPlus() << ")");
397  ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " phi = " << "(" << (*p_roids)->phiMinus() << ")" << (*p_roids)->phi() << "(" << (*p_roids)->phiPlus() << ")");
398  ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " zed = " << "(" << (*p_roids)->zedMinus() << ")" << (*p_roids)->zed() << "(" << (*p_roids)->zedPlus() << ")");
399  }
400  ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " size = " << internalRoI.size());
401 
402  // make RecMURoIs maching with MURoIs
403  std::vector< const LVL1::RecMuonRoI* > recRoIVector;
404  std::vector< const LVL1::RecMuonRoI* > surrRoIs;
405 
406  for (size_t size=0; size<roiCollection->size(); size++){
407  const LVL1::RecMuonRoI* recRoI = matchingRecRoI( roiCollection->at(size)->roiWord(), *recRoiCollection );
408  if( recRoI == nullptr ) continue;
409  recRoIVector.push_back(recRoI);
410  ATH_MSG_DEBUG("REGTEST: " << m_recRoiCollectionKey.key() << " eta/phi = " << (recRoI)->eta() << "/" << (recRoI)->phi());
411  ATH_MSG_DEBUG("REGTEST: " << m_recRoiCollectionKey.key() << " size = " << recRoIVector.size());
412  }
413 
414  bool dynamicDeltaRpc = false;
415  int nPassedBarrelSurrRoi = 0;
416  if(m_topoRoad ){
417  for( const auto recRoI: *recRoiCollection ){
418  if(std::find(recRoIVector.begin(), recRoIVector.end(), recRoI) != recRoIVector.end()) continue;
419 
420  bool surrounding = false;
421  for( const auto matchedRoI: recRoIVector ){
422  float deta = std::abs(recRoI->eta() - matchedRoI->eta());
423  float dphi = std::abs(recRoI->phi() - matchedRoI->phi());
424  if( dphi > M_PI )dphi = 2.*M_PI - dphi;
425  if( deta < m_dEtasurrRoI && dphi < m_dPhisurrRoI)
426  surrounding = true;
427  }
428 
429  if(surrounding)
430  surrRoIs.push_back(recRoI);
431  }
432 
433  ATH_MSG_DEBUG("surrRoI: " << " size = " << surrRoIs.size());
434  for( const auto recRoI: surrRoIs ){
435  ATH_MSG_DEBUG("surrRoI: " << " eta/phi = " << (recRoI)->eta() << "/" << (recRoI)->phi() );
436  if( std::abs((recRoI)->eta()) <= 1.05 && (recRoI)->getThresholdNumber() >= 1 )nPassedBarrelSurrRoi++;
437  }
438  ATH_MSG_DEBUG( "nPassedBarrelSurrRoi = " << nPassedBarrelSurrRoi);
439  //dynamicDeltaRpcMode
440  if( nPassedBarrelSurrRoi >= 1 )
441  dynamicDeltaRpc = true;
442  }
443 
444  // record data objects with WriteHandle
445  auto muFastContainer = SG::makeHandle(m_muFastContainerKey, ctx);
446  ATH_CHECK(muFastContainer.record(std::make_unique<xAOD::L2StandAloneMuonContainer>(), std::make_unique<xAOD::L2StandAloneMuonAuxContainer>()));
447 
448  auto muCompositeContainer = SG::makeHandle(m_muCompositeContainerKey, ctx);
449  ATH_CHECK(muCompositeContainer.record(std::make_unique<xAOD::TrigCompositeContainer>(), std::make_unique<xAOD::TrigCompositeAuxContainer>()));
450 
451  auto muIdContainer = SG::makeHandle(m_muIdContainerKey, ctx);
452  ATH_CHECK(muIdContainer.record(std::make_unique<TrigRoiDescriptorCollection>()));
453 
454  auto muMsContainer = SG::makeHandle(m_muMsContainerKey, ctx);
455  ATH_CHECK(muMsContainer.record(std::make_unique<TrigRoiDescriptorCollection>()));
456 
457 
458  // Inside-out L2Muon mode
459  if(m_insideOut) {
460  ATH_MSG_DEBUG("start inside-out mode...");
461 
462  auto muonCBColl = SG::makeHandle (m_outputCBmuonCollKey, ctx);
463  ATH_CHECK( muonCBColl.record (std::make_unique<xAOD::L2CombinedMuonContainer>(),
464  std::make_unique<xAOD::L2CombinedMuonAuxContainer>()) );
465 
466  auto trackHandle = SG::makeHandle( m_FTFtrackKey, ctx );
467  if (!trackHandle.isValid()){
468  ATH_MSG_ERROR("ReadHandle for TrackParticleContainer key:" << m_FTFtrackKey.key() << " isn't Valid");
469  return StatusCode::FAILURE;
470  }
471  const xAOD::TrackParticleContainer *tracks = trackHandle.cptr();
472 
473  ATH_CHECK(findMuonSignatureIO(*tracks, internalRoI, recRoIVector,
474  *muonCBColl, *muFastContainer, dynamicDeltaRpc, ctx ));
475 
476  if (msgLvl(MSG::DEBUG)) {
477  ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " size = " << muonCBColl->size());
478  for (const auto p_CBmuon : *muonCBColl){
479  ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " pt = " << (*p_CBmuon).pt() << " GeV");
480  ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " eta/phi = " << (*p_CBmuon).eta() << "/" << (*p_CBmuon).phi());
481  }
482  }
483 
484  }
485  else if(m_multiTrack){ //multi-track SA mode
486  ATH_MSG_DEBUG("start multi-track SA mode...");
487  ATH_CHECK(findMultiTrackSignature(internalRoI, recRoIVector, *muFastContainer, dynamicDeltaRpc, ctx));
488  }
489  else {
490  // to StatusCode findMuonSignature()
491  ATH_CHECK(findMuonSignature(internalRoI, recRoIVector,
492  *muFastContainer, *muIdContainer, *muMsContainer, dynamicDeltaRpc, ctx));
493  }
494 
495  if (msgLvl(MSG::DEBUG)) {
496  // DEBUG TEST: Recorded data objects
497  ATH_MSG_DEBUG("Recorded data objects");
498  ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " size = " << muFastContainer->size());
499 
500  for (auto p_muon : *muFastContainer) {
501  ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " pt = " << (*p_muon).pt() << " GeV");
502  ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " eta/phi = " << (*p_muon).eta() << "/" << (*p_muon).phi());
503  }
504 
505  ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muIdContainerKey.key() << " size = " << muIdContainer->size());
506  for (auto p_muonID : *muIdContainer) {
507  ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muIdContainerKey.key() << " eta/phi = " << (*p_muonID).eta() << "/" << (*p_muonID).phi());
508  }
509 
510  ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muMsContainerKey.key() << " size = " << muMsContainer->size());
511  for (auto p_muonMS : *muMsContainer) {
512  ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muMsContainerKey.key() << " eta/phi = " << (*p_muonMS).eta() << "/" << (*p_muonMS).phi());
513  }
514  }
515 
516  }
517 
518  ATH_MSG_DEBUG("StatusCode MuFastSteering::execute() success");
519  return StatusCode::SUCCESS;
520 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

◆ extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

90 {
91  // If we didn't find any symlinks to add, just return the collection
92  // from the base class. Otherwise, return the extended collection.
93  if (!m_extendedExtraObjects.empty()) {
94  return m_extendedExtraObjects;
95  }
96  return BaseAlg::extraOutputDeps();
97 }

◆ filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

96  {
97  return execState( ctx ).filterPassed();
98  }

◆ findMultiTrackSignature() [1/2]

StatusCode MuFastSteering::findMultiTrackSignature ( const std::vector< const TrigRoiDescriptor * > &  roi,
const std::vector< const LVL1::RecMuonRoI * > &  muonRoIs,
DataVector< xAOD::L2StandAloneMuon > &  outputTracks,
const bool  dynamicDeltaRpc,
const EventContext &  ctx 
) const

findMultiTrackSignature(), includes reconstract algorithms for multi-track mode

Definition at line 1776 of file MuFastSteering.cxx.

1781 {
1782  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMultiTrackSignature start");
1783  StatusCode sc = StatusCode::SUCCESS;
1784  const float ZERO_LIMIT = 1.e-5;
1785 
1786  // for RPC clustering and clusterRoad
1787  std::vector<TrigL2MuonSA::RpcFitResult> clusterFitResults;
1788  std::vector< TrigL2MuonSA::MuonRoad > clusterRoad;
1789  std::vector<TrigL2MuonSA::MdtHits> mdtHits_cluster_normal;
1790 
1791 
1792  auto prepTimer = Monitored::Timer( "TIME_Data_Preparator" );
1793  auto patternTimer = Monitored::Timer( "TIME_Pattern_Finder" );
1794  auto stationFitterTimer = Monitored::Timer( "TIME_Station_Fitter" );
1795  auto trackFitterTimer = Monitored::Timer( "TIME_Track_Fitter" );
1796  auto trackExtraTimer = Monitored::Timer( "TIME_Track_Extrapolator" );
1797  auto calibrationTimer = Monitored::Timer( "TIME_Calibration_Streamer" );
1798 
1799  auto monitorIt = Monitored::Group(m_monTool, prepTimer, patternTimer, stationFitterTimer,
1800  trackFitterTimer, trackExtraTimer, calibrationTimer );
1801 
1802  TrigL2MuonSA::RpcHits rpcHits;
1803  TrigL2MuonSA::TgcHits tgcHits;
1804  TrigL2MuonSA::MdtRegion mdtRegion;
1805  TrigL2MuonSA::MuonRoad muonRoad;
1806  TrigL2MuonSA::RpcFitResult rpcFitResult;
1807  TrigL2MuonSA::TgcFitResult tgcFitResult;
1808  TrigL2MuonSA::MdtHits mdtHits_normal;
1809  TrigL2MuonSA::MdtHits mdtHits_overlap;
1810  TrigL2MuonSA::CscHits cscHits;
1811  TrigL2MuonSA::StgcHits stgcHits;
1812  TrigL2MuonSA::MmHits mmHits;
1813 
1814  DataVector<const TrigRoiDescriptor>::const_iterator p_roids;
1815  DataVector<const LVL1::RecMuonRoI>::const_iterator p_roi;
1816 
1817  // muonRoIs = RecMURoIs, roids = MURoIs
1818  p_roids = roids.begin();
1819  for (p_roi=(muonRoIs).begin(); p_roi!=(muonRoIs).end(); ++p_roi) {
1820 
1821  prepTimer.start();
1822  std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
1823  rpcHits.clear();
1824  tgcHits.clear();
1825  mdtRegion.Clear();
1826  muonRoad.Clear();
1827  rpcFitResult.Clear();
1828  tgcFitResult.Clear();
1829  mdtHits_normal.clear();
1830  mdtHits_overlap.clear();
1831  cscHits.clear();
1832  stgcHits.clear();
1833  mmHits.clear();
1834 
1835  clusterFitResults.clear();
1836  clusterRoad.clear();
1837  mdtHits_cluster_normal.clear();
1838 
1839  if ( m_recMuonRoIUtils.isBarrel(*p_roi) ) { // Barrel
1840  ATH_MSG_DEBUG("Barrel");
1841 
1842  muonRoad.setScales(m_scaleRoadBarrelInner,
1843  m_scaleRoadBarrelMiddle,
1844  m_scaleRoadBarrelOuter);
1845 
1846  // Data preparation
1847  sc = m_dataPreparator->prepareData(*p_roi,
1848  *p_roids,
1849  clusterRoad,
1850  clusterFitResults,
1851  mdtHits_normal,
1852  mdtHits_overlap,
1853  mdtHits_cluster_normal,
1854  dynamicDeltaRpc);
1855 
1856  if (!sc.isSuccess()) {
1857  ATH_MSG_WARNING("Data preparation failed");
1858  continue;
1859  }
1860  ATH_MSG_DEBUG("clusterRoad size = " << clusterRoad.size());
1861 
1862  prepTimer.stop();
1863 
1864  for(unsigned int i_road = 0; i_road < clusterRoad.size(); i_road++){
1865  // Pattern finding
1866  std::vector<TrigL2MuonSA::TrackPattern> tmp_trkPats; tmp_trkPats.clear();
1867 
1868  patternTimer.start();
1869  sc = m_patternFinder->findPatterns(clusterRoad.at(i_road),
1870  mdtHits_cluster_normal.at(i_road),
1871  tmp_trkPats);
1872  if (!sc.isSuccess()) {
1873  ATH_MSG_WARNING("Pattern finder failed");
1874  continue;
1875  }
1876  patternTimer.stop();
1877 
1878  // Superpoint fit
1879  stationFitterTimer.start();
1880  sc = m_stationFitter->findSuperPoints(*p_roids,
1881  clusterRoad.at(i_road),
1882  clusterFitResults.at(i_road),
1883  tmp_trkPats);
1884  if (!sc.isSuccess()) {
1885  ATH_MSG_WARNING("Super point fitter failed");
1886  // Update output trigger element
1887  continue;
1888  }
1889  stationFitterTimer.stop();
1890 
1891  // Track fitting
1892  trackFitterTimer.start();
1893  sc = m_trackFitter->findTracks(*p_roids,
1894  clusterFitResults.at(i_road),
1895  tmp_trkPats);
1896 
1897  if (!sc.isSuccess()) {
1898  ATH_MSG_WARNING("Track fitter failed");
1899  continue;
1900  }
1901  trackFitterTimer.stop();
1902 
1903  // fix if eta is strange
1904  const float ETA_LIMIT = 2.8;
1905  const float DELTA_ETA_LIMIT = 1.0;
1906  for (TrigL2MuonSA::TrackPattern& track : tmp_trkPats) {
1907  float roiEta = (*p_roi)->eta();
1908  if (std::abs(track.pt) > ZERO_LIMIT
1909  && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
1910  track.etaMap = roiEta;
1911  }
1912  }
1913 
1914  // Track extrapolation for ID combined
1915  trackExtraTimer.start();
1916 
1917  sc = m_trackExtrapolator->extrapolateTrack(tmp_trkPats, m_winPt);
1918  ATH_MSG_DEBUG("test trackExtrapolator end");
1919 
1920  if (sc != StatusCode::SUCCESS) {
1921  ATH_MSG_WARNING("Track extrapolator failed");
1922  // Update output trigger element
1923  continue;
1924  }
1925  trackExtraTimer.stop();
1926 
1927  if(tmp_trkPats.size() > 0){
1928  ATH_MSG_DEBUG("temp pT calculated 2mu-in-1RoI alg = " << tmp_trkPats[0].pt << " GeV");
1929  if( (std::abs(tmp_trkPats[0].barrelSagitta) < ZERO_LIMIT &&
1930  std::abs(tmp_trkPats[0].barrelRadius) < ZERO_LIMIT) ||
1931  std::abs(tmp_trkPats[0].pt) < ZERO_LIMIT )
1932  continue;
1933  trackPatterns.push_back(tmp_trkPats[0]);
1934  }
1935 
1936  storeMuonSA(*p_roi, *p_roids, clusterRoad.at(i_road), mdtRegion, rpcHits, tgcHits,
1937  clusterFitResults.at(i_road), tgcFitResult, mdtHits_cluster_normal.at(i_road), cscHits,
1938  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1939 
1940  } // end the clusterRoad loop
1941  if(trackPatterns.empty()){
1942  ATH_MSG_DEBUG("multi-track SA falied to reconstruct muons");
1943  TrigL2MuonSA::TrackPattern trackPattern;
1944  trackPatterns.push_back(trackPattern);
1945  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1946  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
1947  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1948 
1949  continue;
1950  }
1951  } else { // Endcap
1952  ATH_MSG_DEBUG("Endcap");
1953  if(!m_doEndcapForl2mt){
1954  ATH_MSG_DEBUG("multi-track SA does nothings and skips for EndcapRoI");
1955  } else {
1956  prepTimer.start();
1957  // Data preparation
1958  sc = m_dataPreparator->prepareData(*p_roi,
1959  *p_roids,
1960  m_insideOut,
1961  tgcHits,
1962  muonRoad,
1963  mdtRegion,
1964  tgcFitResult,
1965  mdtHits_normal,
1966  mdtHits_overlap,
1967  cscHits,
1968  stgcHits,
1969  mmHits);
1970  if (!sc.isSuccess()) {
1971  ATH_MSG_WARNING("Data preparation failed");
1972  TrigL2MuonSA::TrackPattern trackPattern;
1973  trackPatterns.push_back(trackPattern);
1974  // Update output trigger element
1975  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1976  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
1977  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1978  continue;
1979  }
1980  prepTimer.stop();
1981 
1982  // Pattern finding
1983  patternTimer.start();
1984  sc = m_patternFinder->findPatterns(muonRoad,
1985  mdtHits_normal,
1986  stgcHits,
1987  mmHits,
1988  trackPatterns);
1989 
1990 
1991 
1992  if (!sc.isSuccess()) {
1993  ATH_MSG_WARNING("Pattern finder failed");
1994  // Update output trigger element
1995  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1996  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
1997  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1998  continue;
1999  }
2000  patternTimer.stop();
2001 
2002  // Superpoint fit
2003  stationFitterTimer.start();
2004  if(!m_use_new_segmentfit){
2005  sc = m_stationFitter->findSuperPointsSimple(*p_roids,
2006  muonRoad,
2007  tgcFitResult,
2008  trackPatterns,
2009  stgcHits,
2010  mmHits);
2011  }else{
2012  sc = m_stationFitter->findSuperPoints(*p_roids,
2013  muonRoad,
2014  tgcFitResult,
2015  trackPatterns,
2016  stgcHits,
2017  mmHits);
2018  }
2020  m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
2021 
2022  if (!sc.isSuccess()) {
2023  ATH_MSG_WARNING("Super point fitter failed");
2024  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2025  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
2026  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
2027  continue;
2028  }
2029 
2030  stationFitterTimer.stop();
2031 
2032  // Track fittingh
2033  trackFitterTimer.start();
2034  sc = m_trackFitter->findTracks(*p_roids,
2035  tgcFitResult,
2036  trackPatterns,
2037  muonRoad);
2038 
2039  if (!sc.isSuccess()) {
2040  ATH_MSG_WARNING("Track fitter failed");
2041  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2042  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
2043  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
2044  continue;
2045  }
2046  trackFitterTimer.stop();
2047 
2048  // fix if eta is strange
2049  const float ETA_LIMIT = 2.8;
2050  const float DELTA_ETA_LIMIT = 1.0;
2051  for (TrigL2MuonSA::TrackPattern& track : trackPatterns) {
2052  float roiEta = (*p_roi)->eta();
2053  if (std::abs(track.pt) > ZERO_LIMIT
2054  && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
2055  track.etaMap = roiEta;
2056  }
2057  }
2058 
2059  // Track extrapolation for ID combined
2060  trackExtraTimer.start();
2061 
2062  sc = m_trackExtrapolator->extrapolateTrack(trackPatterns, m_winPt);
2063 
2064  if (sc != StatusCode::SUCCESS) {
2065  ATH_MSG_WARNING("Track extrapolator failed");
2066  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2067  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
2068  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
2069  continue;
2070  }
2071  trackExtraTimer.stop();
2072 
2073  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2074  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
2075  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
2076  }
2077  }
2078  // Update monitoring variables
2079  sc = updateMonitor(*p_roi, mdtHits_normal, trackPatterns );
2080  if (sc != StatusCode::SUCCESS) {
2081  ATH_MSG_WARNING("Failed to update monitoring variables");
2082  }
2083 
2084  ++p_roids;
2085  if (p_roids==roids.end()) break;
2086  }
2087 
2088  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMultiTrackSignature success");
2089  return StatusCode::SUCCESS;
2090 }

◆ findMultiTrackSignature() [2/2]

StatusCode MuFastSteering::findMultiTrackSignature ( const std::vector< const TrigRoiDescriptor * > &  roi,
const std::vector< const xAOD::MuonRoI * > &  muonRoIs,
DataVector< xAOD::L2StandAloneMuon > &  outputTracks,
const bool  dynamicDeltaRpc,
const EventContext &  ctx 
) const

Definition at line 2096 of file MuFastSteering.cxx.

2101 {
2102  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMultiTrackSignature start");
2103  StatusCode sc = StatusCode::SUCCESS;
2104  const float ZERO_LIMIT = 1.e-5;
2105 
2106  // for RPC clustering and clusterRoad
2107  std::vector<TrigL2MuonSA::RpcFitResult> clusterFitResults;
2108  std::vector< TrigL2MuonSA::MuonRoad > clusterRoad;
2109  std::vector<TrigL2MuonSA::MdtHits> mdtHits_cluster_normal;
2110 
2111 
2112  auto prepTimer = Monitored::Timer( "TIME_Data_Preparator" );
2113  auto patternTimer = Monitored::Timer( "TIME_Pattern_Finder" );
2114  auto stationFitterTimer = Monitored::Timer( "TIME_Station_Fitter" );
2115  auto trackFitterTimer = Monitored::Timer( "TIME_Track_Fitter" );
2116  auto trackExtraTimer = Monitored::Timer( "TIME_Track_Extrapolator" );
2117  auto calibrationTimer = Monitored::Timer( "TIME_Calibration_Streamer" );
2118 
2119  auto monitorIt = Monitored::Group(m_monTool, prepTimer, patternTimer, stationFitterTimer,
2120  trackFitterTimer, trackExtraTimer, calibrationTimer );
2121 
2122  TrigL2MuonSA::RpcHits rpcHits;
2123  TrigL2MuonSA::TgcHits tgcHits;
2124  TrigL2MuonSA::MdtRegion mdtRegion;
2125  TrigL2MuonSA::MuonRoad muonRoad;
2126  TrigL2MuonSA::RpcFitResult rpcFitResult;
2127  TrigL2MuonSA::TgcFitResult tgcFitResult;
2128  TrigL2MuonSA::MdtHits mdtHits_normal;
2129  TrigL2MuonSA::MdtHits mdtHits_overlap;
2130  TrigL2MuonSA::CscHits cscHits;
2131  TrigL2MuonSA::StgcHits stgcHits;
2132  TrigL2MuonSA::MmHits mmHits;
2133 
2134  DataVector<const TrigRoiDescriptor>::const_iterator p_roids;
2135  DataVector<const xAOD::MuonRoI>::const_iterator p_roi;
2136 
2137  // muonRoIs = RecMURoIs, roids = MURoIs
2138  p_roids = roids.begin();
2139  for (p_roi=(muonRoIs).begin(); p_roi!=(muonRoIs).end(); ++p_roi) {
2140 
2141  prepTimer.start();
2142  std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
2143  rpcHits.clear();
2144  tgcHits.clear();
2145  mdtRegion.Clear();
2146  muonRoad.Clear();
2147  rpcFitResult.Clear();
2148  tgcFitResult.Clear();
2149  mdtHits_normal.clear();
2150  mdtHits_overlap.clear();
2151  cscHits.clear();
2152  stgcHits.clear();
2153  mmHits.clear();
2154 
2155  clusterFitResults.clear();
2156  clusterRoad.clear();
2157  mdtHits_cluster_normal.clear();
2158 
2159  if ( m_recMuonRoIUtils.isBarrel(*p_roi) ) { // Barrel
2160  ATH_MSG_DEBUG("Barrel");
2161 
2162  muonRoad.setScales(m_scaleRoadBarrelInner,
2163  m_scaleRoadBarrelMiddle,
2164  m_scaleRoadBarrelOuter);
2165 
2166  // Data preparation
2167  sc = m_dataPreparator->prepareData(*p_roi,
2168  *p_roids,
2169  clusterRoad,
2170  clusterFitResults,
2171  mdtHits_normal,
2172  mdtHits_overlap,
2173  mdtHits_cluster_normal,
2174  dynamicDeltaRpc);
2175 
2176  if (!sc.isSuccess()) {
2177  ATH_MSG_WARNING("Data preparation failed");
2178  continue;
2179  }
2180  ATH_MSG_DEBUG("clusterRoad size = " << clusterRoad.size());
2181 
2182  prepTimer.stop();
2183 
2184  for(unsigned int i_road = 0; i_road < clusterRoad.size(); i_road++){
2185  // Pattern finding
2186  std::vector<TrigL2MuonSA::TrackPattern> tmp_trkPats; tmp_trkPats.clear();
2187 
2188  patternTimer.start();
2189  sc = m_patternFinder->findPatterns(clusterRoad.at(i_road),
2190  mdtHits_cluster_normal.at(i_road),
2191  tmp_trkPats);
2192  if (!sc.isSuccess()) {
2193  ATH_MSG_WARNING("Pattern finder failed");
2194  continue;
2195  }
2196  patternTimer.stop();
2197 
2198  // Superpoint fit
2199  stationFitterTimer.start();
2200  sc = m_stationFitter->findSuperPoints(*p_roids,
2201  clusterRoad.at(i_road),
2202  clusterFitResults.at(i_road),
2203  tmp_trkPats);
2204  if (!sc.isSuccess()) {
2205  ATH_MSG_WARNING("Super point fitter failed");
2206  // Update output trigger element
2207  continue;
2208  }
2209  stationFitterTimer.stop();
2210 
2211  // Track fitting
2212  trackFitterTimer.start();
2213  sc = m_trackFitter->findTracks(*p_roids,
2214  clusterFitResults.at(i_road),
2215  tmp_trkPats);
2216 
2217  if (!sc.isSuccess()) {
2218  ATH_MSG_WARNING("Track fitter failed");
2219  continue;
2220  }
2221  trackFitterTimer.stop();
2222 
2223  // fix if eta is strange
2224  const float ETA_LIMIT = 2.8;
2225  const float DELTA_ETA_LIMIT = 1.0;
2226  for (TrigL2MuonSA::TrackPattern& track : tmp_trkPats) {
2227  float roiEta = (*p_roi)->eta();
2228  if (std::abs(track.pt) > ZERO_LIMIT
2229  && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
2230  track.etaMap = roiEta;
2231  }
2232  }
2233 
2234  // Track extrapolation for ID combined
2235  trackExtraTimer.start();
2236 
2237  sc = m_trackExtrapolator->extrapolateTrack(tmp_trkPats, m_winPt);
2238  ATH_MSG_DEBUG("test trackExtrapolator end");
2239 
2240  if (sc != StatusCode::SUCCESS) {
2241  ATH_MSG_WARNING("Track extrapolator failed");
2242  // Update output trigger element
2243  continue;
2244  }
2245  trackExtraTimer.stop();
2246 
2247  if(tmp_trkPats.size() > 0){
2248  ATH_MSG_DEBUG("temp pT calculated 2mu-in-1RoI alg = " << tmp_trkPats[0].pt << " GeV");
2249  if( (std::abs(tmp_trkPats[0].barrelSagitta) < ZERO_LIMIT &&
2250  std::abs(tmp_trkPats[0].barrelRadius) < ZERO_LIMIT) ||
2251  std::abs(tmp_trkPats[0].pt) < ZERO_LIMIT )
2252  continue;
2253  trackPatterns.push_back(tmp_trkPats[0]);
2254  }
2255 
2256  storeMuonSA(*p_roi, *p_roids, clusterRoad.at(i_road), mdtRegion, rpcHits, tgcHits,
2257  clusterFitResults.at(i_road), tgcFitResult, mdtHits_cluster_normal.at(i_road), cscHits,
2258  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
2259 
2260  } // end the clusterRoad loop
2261  if(trackPatterns.empty()){
2262  ATH_MSG_DEBUG("multi-track SA falied to reconstruct muons");
2263  TrigL2MuonSA::TrackPattern trackPattern;
2264  trackPatterns.push_back(trackPattern);
2265  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2266  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
2267  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
2268 
2269  continue;
2270  }
2271  } else { // Endcap
2272  ATH_MSG_DEBUG("Endcap");
2273  if(!m_doEndcapForl2mt){
2274  ATH_MSG_DEBUG("multi-track SA does nothings and skips for EndcapRoI");
2275  } else {
2276  prepTimer.start();
2277  // Data preparation
2278  sc = m_dataPreparator->prepareData(*p_roi,
2279  *p_roids,
2280  m_insideOut,
2281  tgcHits,
2282  muonRoad,
2283  mdtRegion,
2284  tgcFitResult,
2285  mdtHits_normal,
2286  mdtHits_overlap,
2287  cscHits,
2288  stgcHits,
2289  mmHits);
2290  if (!sc.isSuccess()) {
2291  ATH_MSG_WARNING("Data preparation failed");
2292  TrigL2MuonSA::TrackPattern trackPattern;
2293  trackPatterns.push_back(trackPattern);
2294  // Update output trigger element
2295  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2296  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
2297  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
2298  continue;
2299  }
2300  prepTimer.stop();
2301 
2302  // Pattern finding
2303  patternTimer.start();
2304  sc = m_patternFinder->findPatterns(muonRoad,
2305  mdtHits_normal,
2306  stgcHits,
2307  mmHits,
2308  trackPatterns);
2309 
2310 
2311 
2312  if (!sc.isSuccess()) {
2313  ATH_MSG_WARNING("Pattern finder failed");
2314  // Update output trigger element
2315  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2316  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
2317  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
2318  continue;
2319  }
2320  patternTimer.stop();
2321 
2322  // Superpoint fit
2323  stationFitterTimer.start();
2324  if(!m_use_new_segmentfit){
2325  sc = m_stationFitter->findSuperPointsSimple(*p_roids,
2326  muonRoad,
2327  tgcFitResult,
2328  trackPatterns,
2329  stgcHits,
2330  mmHits);
2331  }else{
2332  sc = m_stationFitter->findSuperPoints(*p_roids,
2333  muonRoad,
2334  tgcFitResult,
2335  trackPatterns,
2336  stgcHits,
2337  mmHits);
2338  }
2340  m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
2341 
2342  if (!sc.isSuccess()) {
2343  ATH_MSG_WARNING("Super point fitter failed");
2344  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2345  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
2346  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
2347  continue;
2348  }
2349 
2350  stationFitterTimer.stop();
2351 
2352  // Track fittingh
2353  trackFitterTimer.start();
2354  sc = m_trackFitter->findTracks(*p_roids,
2355  tgcFitResult,
2356  trackPatterns,
2357  muonRoad);
2358 
2359  if (!sc.isSuccess()) {
2360  ATH_MSG_WARNING("Track fitter failed");
2361  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2362  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
2363  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
2364  continue;
2365  }
2366  trackFitterTimer.stop();
2367 
2368  // fix if eta is strange
2369  const float ETA_LIMIT = 2.8;
2370  const float DELTA_ETA_LIMIT = 1.0;
2371  for (TrigL2MuonSA::TrackPattern& track : trackPatterns) {
2372  float roiEta = (*p_roi)->eta();
2373  if (std::abs(track.pt) > ZERO_LIMIT
2374  && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
2375  track.etaMap = roiEta;
2376  }
2377  }
2378 
2379  // Track extrapolation for ID combined
2380  trackExtraTimer.start();
2381 
2382  sc = m_trackExtrapolator->extrapolateTrack(trackPatterns, m_winPt);
2383 
2384  if (sc != StatusCode::SUCCESS) {
2385  ATH_MSG_WARNING("Track extrapolator failed");
2386  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2387  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
2388  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
2389  continue;
2390  }
2391  trackExtraTimer.stop();
2392 
2393  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2394  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
2395  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
2396  }
2397  }
2398  // Update monitoring variables
2399  sc = updateMonitor(*p_roi, mdtHits_normal, trackPatterns );
2400  if (sc != StatusCode::SUCCESS) {
2401  ATH_MSG_WARNING("Failed to update monitoring variables");
2402  }
2403 
2404  ++p_roids;
2405  if (p_roids==roids.end()) break;
2406  }
2407 
2408  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMultiTrackSignature success");
2409  return StatusCode::SUCCESS;
2410 }

◆ findMuonSignature() [1/2]

StatusCode MuFastSteering::findMuonSignature ( const std::vector< const TrigRoiDescriptor * > &  roi,
const std::vector< const LVL1::RecMuonRoI * > &  muonRoIs,
DataVector< xAOD::L2StandAloneMuon > &  outputTracks,
TrigRoiDescriptorCollection &  outputID,
TrigRoiDescriptorCollection &  outputMS,
const bool  dynamicDeltaRpc,
const EventContext &  ctx 
) const

findMuonSignature(), includes reconstract algorithms

this function can be called from both execute()

Definition at line 525 of file MuFastSteering.cxx.

532 {
533  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignature start");
534  StatusCode sc = StatusCode::SUCCESS;
535 
536  auto prepTimer = Monitored::Timer( "TIME_Data_Preparator" );
537  auto patternTimer = Monitored::Timer( "TIME_Pattern_Finder" );
538  auto stationFitterTimer = Monitored::Timer( "TIME_Station_Fitter" );
539  auto trackFitterTimer = Monitored::Timer( "TIME_Track_Fitter" );
540  auto trackExtraTimer = Monitored::Timer( "TIME_Track_Extrapolator" );
541  auto calibrationTimer = Monitored::Timer( "TIME_Calibration_Streamer" );
542 
543  auto monitorIt = Monitored::Group(m_monTool, prepTimer, patternTimer, stationFitterTimer,
544  trackFitterTimer, trackExtraTimer, calibrationTimer );
545 
546  TrigL2MuonSA::RpcHits rpcHits;
547  TrigL2MuonSA::TgcHits tgcHits;
548  TrigL2MuonSA::MdtRegion mdtRegion;
549  TrigL2MuonSA::MuonRoad muonRoad;
550  TrigL2MuonSA::RpcFitResult rpcFitResult;
551  TrigL2MuonSA::TgcFitResult tgcFitResult;
552  TrigL2MuonSA::MdtHits mdtHits_normal;
553  TrigL2MuonSA::MdtHits mdtHits_overlap;
554  TrigL2MuonSA::CscHits cscHits;
555  TrigL2MuonSA::StgcHits stgcHits;
556  TrigL2MuonSA::MmHits mmHits;
557 
558  DataVector<const TrigRoiDescriptor>::const_iterator p_roids;
559  DataVector<const LVL1::RecMuonRoI>::const_iterator p_roi;
560 
561  // muonRoIs = RecMURoIs, roids = MURoIs
562  p_roids = roids.begin();
563  for (p_roi=(muonRoIs).begin(); p_roi!=(muonRoIs).end(); ++p_roi) {
564 
565  prepTimer.start();
566  std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
567  rpcHits.clear();
568  tgcHits.clear();
569  mdtRegion.Clear();
570  muonRoad.Clear();
571  rpcFitResult.Clear();
572  tgcFitResult.Clear();
573  mdtHits_normal.clear();
574  mdtHits_overlap.clear();
575  cscHits.clear();
576  stgcHits.clear();
577  mmHits.clear();
578 
579  if ( m_recMuonRoIUtils.isBarrel(*p_roi) ) { // Barrel
580  ATH_MSG_DEBUG("Barrel");
581 
582  muonRoad.setScales(m_scaleRoadBarrelInner,
583  m_scaleRoadBarrelMiddle,
584  m_scaleRoadBarrelOuter);
585 
586  // Data preparation
587  sc = m_dataPreparator->prepareData(*p_roi,
588  *p_roids,
589  m_insideOut,
590  rpcHits,
591  muonRoad,
592  mdtRegion,
593  rpcFitResult,
594  mdtHits_normal,
595  mdtHits_overlap,
596  dynamicDeltaRpc);
597  if (!sc.isSuccess()) {
598  ATH_MSG_WARNING("Data preparation failed");
599  TrigL2MuonSA::TrackPattern trackPattern;
600  trackPatterns.push_back(trackPattern);
601  // Update output trigger element
602  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
603  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
604  stgcHits, mmHits,
605  trackPatterns, outputTracks, outputID, outputMS, ctx);
606  continue;
607  }
608  prepTimer.stop();
609 
610  // Pattern finding
611  patternTimer.start();
612  sc = m_patternFinder->findPatterns(muonRoad,
613  mdtHits_normal,
614  trackPatterns);
615  if (!sc.isSuccess()) {
616  ATH_MSG_WARNING("Pattern finder failed");
617  // Update output trigger element
618  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
619  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
620  stgcHits, mmHits,
621  trackPatterns, outputTracks, outputID, outputMS, ctx);
622  continue;
623  }
624  patternTimer.stop();
625 
626  // Superpoint fit
627  stationFitterTimer.start();
628  sc = m_stationFitter->findSuperPoints(*p_roids,
629  muonRoad,
630  rpcFitResult,
631  trackPatterns);
632  if (!sc.isSuccess()) {
633  ATH_MSG_WARNING("Super point fitter failed");
634  // Update output trigger element
635  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
636  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
637  stgcHits, mmHits,
638  trackPatterns, outputTracks, outputID, outputMS, ctx);
639  continue;
640  }
641  stationFitterTimer.stop();
642 
643  // Track fitting
644  trackFitterTimer.start();
645  sc = m_trackFitter->findTracks(*p_roids,
646  rpcFitResult,
647  trackPatterns);
648 
649  if (!sc.isSuccess()) {
650  ATH_MSG_WARNING("Track fitter failed");
651  // Update output trigger element
652  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
653  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
654  stgcHits, mmHits,
655  trackPatterns, outputTracks, outputID, outputMS, ctx);
656  continue;
657  }
658  trackFitterTimer.stop();
659 
660  } else { // Endcap
661  ATH_MSG_DEBUG("Endcap");
662 
663  prepTimer.start();
664  // Data preparation
665  sc = m_dataPreparator->prepareData(*p_roi,
666  *p_roids,
667  m_insideOut,
668  tgcHits,
669  muonRoad,
670  mdtRegion,
671  tgcFitResult,
672  mdtHits_normal,
673  mdtHits_overlap,
674  cscHits,
675  stgcHits,
676  mmHits);
677  if (!sc.isSuccess()) {
678  ATH_MSG_WARNING("Data preparation failed");
679  TrigL2MuonSA::TrackPattern trackPattern;
680  trackPatterns.push_back(trackPattern);
681  // Update output trigger element
682  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
683  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
684  stgcHits, mmHits,
685  trackPatterns, outputTracks, outputID, outputMS, ctx);
686  continue;
687  }
688  prepTimer.stop();
689 
690  // Pattern finding
691  patternTimer.start();
692  sc = m_patternFinder->findPatterns(muonRoad,
693  mdtHits_normal,
694  stgcHits,
695  mmHits,
696  trackPatterns);
697 
698 
699 
700  if (!sc.isSuccess()) {
701  ATH_MSG_WARNING("Pattern finder failed");
702  // Update output trigger element
703  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
704  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
705  stgcHits, mmHits,
706  trackPatterns, outputTracks, outputID, outputMS, ctx);
707  continue;
708  }
709  patternTimer.stop();
710 
711  // Superpoint fit
712  stationFitterTimer.start();
713  if(!m_use_new_segmentfit){
714  sc = m_stationFitter->findSuperPointsSimple(*p_roids,
715  muonRoad,
716  tgcFitResult,
717  trackPatterns,
718  stgcHits,
719  mmHits);
720  }else{
721  sc = m_stationFitter->findSuperPoints(*p_roids,
722  muonRoad,
723  tgcFitResult,
724  trackPatterns,
725  stgcHits,
726  mmHits);
727  }
729  m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
730 
731  if (!sc.isSuccess()) {
732  ATH_MSG_WARNING("Super point fitter failed");
733  // Update output trigger element
734  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
735  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
736  stgcHits, mmHits,
737  trackPatterns, outputTracks, outputID, outputMS, ctx);
738  continue;
739  }
740 
741  stationFitterTimer.stop();
742 
743  // Track fittingh
744  trackFitterTimer.start();
745  sc = m_trackFitter->findTracks(*p_roids,
746  tgcFitResult,
747  trackPatterns,
748  muonRoad);
749 
750  if (!sc.isSuccess()) {
751  ATH_MSG_WARNING("Track fitter failed");
752  // Update output trigger element
753  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
754  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
755  stgcHits, mmHits,
756  trackPatterns, outputTracks, outputID, outputMS, ctx);
757  continue;
758  }
759  trackFitterTimer.stop();
760  }
761 
762  // fix if eta is strange
763  const float ETA_LIMIT = 2.8;
764  const float DELTA_ETA_LIMIT = 1.0;
765  const float ZERO_LIMIT = 1.e-5;
766  for (TrigL2MuonSA::TrackPattern& track : trackPatterns) {
767  float roiEta = (*p_roi)->eta();
768  if (std::abs(track.pt) > ZERO_LIMIT
769  && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
770  track.etaMap = roiEta;
771  }
772  }
773 
774  // Track extrapolation for ID combined
775  trackExtraTimer.start();
776 
777  sc = m_trackExtrapolator->extrapolateTrack(trackPatterns, m_winPt);
778 
779  if (sc != StatusCode::SUCCESS) {
780  ATH_MSG_WARNING("Track extrapolator failed");
781  // Update output trigger element
782  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
783  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
784  stgcHits, mmHits,
785  trackPatterns, outputTracks, outputID, outputMS, ctx);
786  continue;
787  }
788  trackExtraTimer.stop();
789 
790  // Update monitoring variables
791  sc = updateMonitor(*p_roi, mdtHits_normal, trackPatterns );
792  if (sc != StatusCode::SUCCESS) {
793  ATH_MSG_WARNING("Failed to update monitoring variables");
794  // Update output trigger element
795  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
796  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
797  stgcHits, mmHits,
798  trackPatterns, outputTracks, outputID, outputMS, ctx);
799  continue;
800  }
801 
802  // Update output trigger element
803  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
804  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
805  stgcHits, mmHits,
806  trackPatterns, outputTracks, outputID, outputMS, ctx);
807 
808 
809  ++p_roids;
810  if (p_roids==roids.end()) break;
811  }
812 
813  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignature success");
814  return StatusCode::SUCCESS;
815 }

◆ findMuonSignature() [2/2]

StatusCode MuFastSteering::findMuonSignature ( const std::vector< const TrigRoiDescriptor * > &  roi,
const std::vector< const xAOD::MuonRoI * > &  muonRoIs,
DataVector< xAOD::L2StandAloneMuon > &  outputTracks,
xAOD::TrigCompositeContainer &  outputMuonCal,
TrigRoiDescriptorCollection &  outputID,
TrigRoiDescriptorCollection &  outputMS,
const bool  dynamicDeltaRpc,
const EventContext &  ctx 
) const

Definition at line 820 of file MuFastSteering.cxx.

828 {
829  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignature start");
830  StatusCode sc = StatusCode::SUCCESS;
831 
832  auto prepTimer = Monitored::Timer( "TIME_Data_Preparator" );
833  auto patternTimer = Monitored::Timer( "TIME_Pattern_Finder" );
834  auto stationFitterTimer = Monitored::Timer( "TIME_Station_Fitter" );
835  auto trackFitterTimer = Monitored::Timer( "TIME_Track_Fitter" );
836  auto trackExtraTimer = Monitored::Timer( "TIME_Track_Extrapolator" );
837  auto calibrationTimer = Monitored::Timer( "TIME_Calibration_Streamer" );
838 
839  auto monitorIt = Monitored::Group(m_monTool, prepTimer, patternTimer, stationFitterTimer,
840  trackFitterTimer, trackExtraTimer, calibrationTimer );
841 
842  TrigL2MuonSA::RpcHits rpcHits;
843  TrigL2MuonSA::TgcHits tgcHits;
844  TrigL2MuonSA::MdtRegion mdtRegion;
845  TrigL2MuonSA::MuonRoad muonRoad;
846  TrigL2MuonSA::RpcFitResult rpcFitResult;
847  TrigL2MuonSA::TgcFitResult tgcFitResult;
848  TrigL2MuonSA::MdtHits mdtHits_normal;
849  TrigL2MuonSA::MdtHits mdtHits_overlap;
850  TrigL2MuonSA::CscHits cscHits;
851  TrigL2MuonSA::StgcHits stgcHits;
852  TrigL2MuonSA::MmHits mmHits;
853 
854  DataVector<const TrigRoiDescriptor>::const_iterator p_roids;
855  DataVector<const xAOD::MuonRoI>::const_iterator p_roi;
856 
857  // muonRoIs = RecMURoIs, roids = MURoIs
858  p_roids = roids.begin();
859  for (p_roi=(muonRoIs).begin(); p_roi!=(muonRoIs).end(); ++p_roi) {
860 
861  prepTimer.start();
862  std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
863  rpcHits.clear();
864  tgcHits.clear();
865  mdtRegion.Clear();
866  muonRoad.Clear();
867  rpcFitResult.Clear();
868  tgcFitResult.Clear();
869  mdtHits_normal.clear();
870  mdtHits_overlap.clear();
871  cscHits.clear();
872  stgcHits.clear();
873  mmHits.clear();
874 
875  if ( m_recMuonRoIUtils.isBarrel(*p_roi) ) { // Barrel
876  ATH_MSG_DEBUG("Barrel");
877 
878  muonRoad.setScales(m_scaleRoadBarrelInner,
879  m_scaleRoadBarrelMiddle,
880  m_scaleRoadBarrelOuter);
881 
882  // Data preparation
883  sc = m_dataPreparator->prepareData(*p_roi,
884  *p_roids,
885  m_insideOut,
886  rpcHits,
887  muonRoad,
888  mdtRegion,
889  rpcFitResult,
890  mdtHits_normal,
891  mdtHits_overlap,
892  dynamicDeltaRpc);
893  if (!sc.isSuccess()) {
894  ATH_MSG_WARNING("Data preparation failed");
895  TrigL2MuonSA::TrackPattern trackPattern;
896  trackPatterns.push_back(trackPattern);
897  // Update output trigger element
898  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
899  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
900  stgcHits, mmHits,
901  trackPatterns, outputTracks, outputID, outputMS, ctx);
902  continue;
903  }
904  prepTimer.stop();
905 
906  // Pattern finding
907  patternTimer.start();
908  sc = m_patternFinder->findPatterns(muonRoad,
909  mdtHits_normal,
910  trackPatterns);
911  if (!sc.isSuccess()) {
912  ATH_MSG_WARNING("Pattern finder failed");
913  // Update output trigger element
914  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
915  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
916  stgcHits, mmHits,
917  trackPatterns, outputTracks, outputID, outputMS, ctx);
918  continue;
919  }
920  patternTimer.stop();
921 
922  // Superpoint fit
923  stationFitterTimer.start();
924  sc = m_stationFitter->findSuperPoints(*p_roids,
925  muonRoad,
926  rpcFitResult,
927  trackPatterns);
928  if (!sc.isSuccess()) {
929  ATH_MSG_WARNING("Super point fitter failed");
930  // Update output trigger element
931  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
932  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
933  stgcHits, mmHits,
934  trackPatterns, outputTracks, outputID, outputMS, ctx);
935  continue;
936  }
937  stationFitterTimer.stop();
938 
939  // Track fitting
940  trackFitterTimer.start();
941  sc = m_trackFitter->findTracks(*p_roids,
942  rpcFitResult,
943  trackPatterns);
944 
945  if (!sc.isSuccess()) {
946  ATH_MSG_WARNING("Track fitter failed");
947  // Update output trigger element
948  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
949  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
950  stgcHits, mmHits,
951  trackPatterns, outputTracks, outputID, outputMS, ctx);
952  continue;
953  }
954  trackFitterTimer.stop();
955 
956  } else { // Endcap
957  ATH_MSG_DEBUG("Endcap");
958 
959  prepTimer.start();
960  // Data preparation
961  sc = m_dataPreparator->prepareData(*p_roi,
962  *p_roids,
963  m_insideOut,
964  tgcHits,
965  muonRoad,
966  mdtRegion,
967  tgcFitResult,
968  mdtHits_normal,
969  mdtHits_overlap,
970  cscHits,
971  stgcHits,
972  mmHits);
973  if (!sc.isSuccess()) {
974  ATH_MSG_WARNING("Data preparation failed");
975  TrigL2MuonSA::TrackPattern trackPattern;
976  trackPatterns.push_back(trackPattern);
977  // Update output trigger element
978  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
979  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
980  stgcHits, mmHits,
981  trackPatterns, outputTracks, outputID, outputMS, ctx);
982  continue;
983  }
984  prepTimer.stop();
985 
986  // Pattern finding
987  patternTimer.start();
988  sc = m_patternFinder->findPatterns(muonRoad,
989  mdtHits_normal,
990  stgcHits,
991  mmHits,
992  trackPatterns);
993 
994 
995 
996  if (!sc.isSuccess()) {
997  ATH_MSG_WARNING("Pattern finder failed");
998  // Update output trigger element
999  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1000  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
1001  stgcHits, mmHits,
1002  trackPatterns, outputTracks, outputID, outputMS, ctx);
1003  continue;
1004  }
1005  patternTimer.stop();
1006 
1007  // Superpoint fit
1008  stationFitterTimer.start();
1009  if(!m_use_new_segmentfit){
1010  sc = m_stationFitter->findSuperPointsSimple(*p_roids,
1011  muonRoad,
1012  tgcFitResult,
1013  trackPatterns,
1014  stgcHits,
1015  mmHits);
1016  }else{
1017  sc = m_stationFitter->findSuperPoints(*p_roids,
1018  muonRoad,
1019  tgcFitResult,
1020  trackPatterns,
1021  stgcHits,
1022  mmHits);
1023  }
1025  m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
1026 
1027  if (!sc.isSuccess()) {
1028  ATH_MSG_WARNING("Super point fitter failed");
1029  // Update output trigger element
1030  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1031  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
1032  stgcHits, mmHits,
1033  trackPatterns, outputTracks, outputID, outputMS, ctx);
1034  continue;
1035  }
1036 
1037  stationFitterTimer.stop();
1038 
1039  // Track fittingh
1040  trackFitterTimer.start();
1041  sc = m_trackFitter->findTracks(*p_roids,
1042  tgcFitResult,
1043  trackPatterns,
1044  muonRoad);
1045 
1046  if (!sc.isSuccess()) {
1047  ATH_MSG_WARNING("Track fitter failed");
1048  // Update output trigger element
1049  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1050  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
1051  stgcHits, mmHits,
1052  trackPatterns, outputTracks, outputID, outputMS, ctx);
1053  continue;
1054  }
1055  trackFitterTimer.stop();
1056  }
1057 
1058  // fix if eta is strange
1059  const float ETA_LIMIT = 2.8;
1060  const float DELTA_ETA_LIMIT = 1.0;
1061  const float ZERO_LIMIT = 1.e-5;
1062  for (TrigL2MuonSA::TrackPattern& track : trackPatterns) {
1063  float roiEta = (*p_roi)->eta();
1064  if (std::abs(track.pt) > ZERO_LIMIT
1065  && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
1066  track.etaMap = roiEta;
1067  }
1068  }
1069 
1070  // Track extrapolation for ID combined
1071  trackExtraTimer.start();
1072 
1073  sc = m_trackExtrapolator->extrapolateTrack(trackPatterns, m_winPt);
1074 
1075  if (sc != StatusCode::SUCCESS) {
1076  ATH_MSG_WARNING("Track extrapolator failed");
1077  // Update output trigger element
1078  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1079  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
1080  stgcHits, mmHits,
1081  trackPatterns, outputTracks, outputID, outputMS, ctx);
1082  continue;
1083  }
1084  trackExtraTimer.stop();
1085 
1086  // Update monitoring variables
1087  sc = updateMonitor(*p_roi, mdtHits_normal, trackPatterns );
1088  if (sc != StatusCode::SUCCESS) {
1089  ATH_MSG_WARNING("Failed to update monitoring variables");
1090  // Update output trigger element
1091  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1092  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
1093  stgcHits, mmHits,
1094  trackPatterns, outputTracks, outputID, outputMS, ctx);
1095  continue;
1096  }
1097 
1098  // Update output trigger element
1099  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1100  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
1101  stgcHits, mmHits,
1102  trackPatterns, outputTracks, outputID, outputMS, ctx);
1103 
1104 
1105  //-----------------------
1106  // call the calibration streamer
1107  //---------------------------
1108  if (m_doCalStream && trackPatterns.size()>0 ) {
1109  TrigL2MuonSA::TrackPattern tp = trackPatterns[0];
1110  std::vector<uint32_t> localBuffer; // init localBuffer parameter
1111  sc = m_calStreamer->createRoiFragment(*p_roi,tp,mdtHits_normal,
1112  rpcHits,
1113  tgcHits,
1114  localBuffer,
1115  m_calDataScouting,
1116  ctx);
1117  if (sc != StatusCode::SUCCESS ) {
1118  ATH_MSG_WARNING("Calibration streamer: create Roi Fragment failed");
1119  }
1120  // if it's a data scouting chain
1121  if ( m_calDataScouting ) {
1122 
1123  ATH_MSG_DEBUG("Retrieved the buffer, with size: " << localBuffer.size());
1124 
1125  // create the TrigCompositeContainer to store the calibration buffer
1126  // add the trigcomposite object to the container outputMuonCal
1127  xAOD::TrigComposite* tc = new xAOD::TrigComposite();
1128  outputMuonCal.push_back(tc);
1129 
1130  ATH_MSG_DEBUG("The size of the TrigCompositeContainer is: " << outputMuonCal.size() );
1131 
1132  // set the detail of the trigcomposite object
1133  tc->setDetail("MuonCalibrationStream", localBuffer );
1134 
1135  }
1136 
1137 
1138  }
1139 
1140 
1141 
1142  ++p_roids;
1143  if (p_roids==roids.end()) break;
1144  }
1145 
1146  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignature success");
1147  return StatusCode::SUCCESS;
1148 }

◆ findMuonSignatureIO() [1/2]

StatusCode MuFastSteering::findMuonSignatureIO ( const xAOD::TrackParticleContainer &  idtracks,
const std::vector< const TrigRoiDescriptor * > &  roids,
const std::vector< const LVL1::RecMuonRoI * > &  muonRoIs,
DataVector< xAOD::L2CombinedMuon > &  outputCBs,
DataVector< xAOD::L2StandAloneMuon > &  outputSAs,
const bool  dynamicDeltaRpc,
const EventContext &  ctx 
) const

findMuonSignatureIO(), includes reconstract algorithms for inside-out mode

Definition at line 1155 of file MuFastSteering.cxx.

1162 {
1163  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignatureIO start");
1164  StatusCode sc = StatusCode::SUCCESS;
1165  const float ZERO_LIMIT = 1.e-5;
1166 
1167  auto prepTimer = Monitored::Timer( "TIME_Data_Preparator" );
1168  auto patternTimer = Monitored::Timer( "TIME_Pattern_Finder" );
1169  auto stationFitterTimer = Monitored::Timer( "TIME_Station_Fitter" );
1170  auto trackFitterTimer = Monitored::Timer( "TIME_Track_Fitter" );
1171  auto trackExtraTimer = Monitored::Timer( "TIME_Track_Extrapolator" );
1172  auto calibrationTimer = Monitored::Timer( "TIME_Calibration_Streamer" );
1173 
1174  auto monitorIt = Monitored::Group(m_monTool, prepTimer, patternTimer, stationFitterTimer,
1175  trackFitterTimer, trackExtraTimer, calibrationTimer );
1176 
1177  TrigL2MuonSA::RpcHits rpcHits;
1178  TrigL2MuonSA::TgcHits tgcHits;
1179  TrigL2MuonSA::MdtRegion mdtRegion;
1180  TrigL2MuonSA::MuonRoad muonRoad;
1181  TrigL2MuonSA::RpcFitResult rpcFitResult;
1182  TrigL2MuonSA::TgcFitResult tgcFitResult;
1183  TrigL2MuonSA::MdtHits mdtHits_normal;
1184  TrigL2MuonSA::MdtHits mdtHits_overlap;
1185  TrigL2MuonSA::CscHits cscHits;
1186  TrigL2MuonSA::StgcHits stgcHits;
1187  TrigL2MuonSA::MmHits mmHits;
1188 
1189  DataVector<const TrigRoiDescriptor>::const_iterator p_roids;
1190 
1191  p_roids = roids.begin();
1192  for (const auto p_roi : muonRoIs) {
1193  ATH_MSG_DEBUG("roi eta/phi: " << (*p_roi).eta() << "/" << (*p_roi).phi());
1194 
1195  // idtracks loop
1196  if ( (idtracks).empty() ) ATH_MSG_DEBUG("IO TEST: xAOD::TrackParticleContainer has 0 tracks --> Can not use FTF tracks...");
1197  else ATH_MSG_DEBUG("IO TEST: xAOD::TrackParticleContainer has " << (idtracks).size() << " tracks --> Start inside-out mode!");
1198 
1199  std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
1200  int idtrack_idx = -1;
1201  for (auto idtrack : idtracks) {
1202 
1203  idtrack_idx++;
1204  ATH_MSG_DEBUG("IO TEST: FTF track key:" << m_FTFtrackKey.key() << " pt = " << idtrack->pt()/1000 << " GeV");
1205  ATH_MSG_DEBUG("IO TEST: FTF track key:" << m_FTFtrackKey.key() << " eta/phi = " << idtrack->eta() << "/" << idtrack->phi());
1206 
1207  if(idtrack->pt() < m_ftfminPt) {
1208  ATH_MSG_DEBUG("IO TEST: skip FTF track due to pT threshold: " << m_ftfminPt << " MeV");
1209  continue;
1210  }
1211 
1212  prepTimer.start();
1213  rpcHits.clear();
1214  tgcHits.clear();
1215  mdtRegion.Clear();
1216  muonRoad.Clear();
1217  rpcFitResult.Clear();
1218  tgcFitResult.Clear();
1219  mdtHits_normal.clear();
1220  mdtHits_overlap.clear();
1221  cscHits.clear();
1222  stgcHits.clear();
1223  mmHits.clear();
1224  trackPatterns.clear();
1225 
1226  sc = m_ftfRoadDefiner->defineRoad(idtrack, muonRoad);
1227  if (!sc.isSuccess()) {
1228  ATH_MSG_WARNING("FtfRoadDefiner failed");
1229  continue;
1230  } else {
1231  ATH_MSG_DEBUG("FtfRoadDefiner::defineRoad success");
1232  }
1233 
1234  if ( std::abs(idtrack->eta()) < 1.05 ){
1235  ATH_MSG_DEBUG("FTF track at IP is in Barrel: " << idtrack->eta());
1236  } else {
1237  ATH_MSG_DEBUG("FTF track at IP is in Endcap: " << idtrack->eta());
1238  }
1239 
1240  if ( m_recMuonRoIUtils.isBarrel(p_roi) ) { // Barrel Inside-out
1241  ATH_MSG_DEBUG("muonRoad.extFtfMiddleEta Barrel: " << muonRoad.extFtfMiddleEta);
1242 
1243  ATH_MSG_DEBUG("Barrel algorithm of IOmode starts");
1244 
1245  muonRoad.setScales(m_scaleRoadBarrelInner,
1246  m_scaleRoadBarrelMiddle,
1247  m_scaleRoadBarrelOuter);
1248 
1249  // Data preparation
1250  sc = m_dataPreparator->prepareData(p_roi,
1251  *p_roids,
1252  m_insideOut,
1253  rpcHits,
1254  muonRoad,
1255  mdtRegion,
1256  rpcFitResult,
1257  mdtHits_normal,
1258  mdtHits_overlap,
1259  dynamicDeltaRpc);
1260  if (!sc.isSuccess()) {
1261  ATH_MSG_WARNING("Data preparation failed");
1262  continue;
1263  } else {
1264  ATH_MSG_DEBUG("Data preparation success");
1265  }
1266  prepTimer.stop();
1267 
1268  // Pattern finding
1269  patternTimer.start();
1270  sc = m_patternFinder->findPatterns(muonRoad,
1271  mdtHits_normal,
1272  trackPatterns);
1273  if (!sc.isSuccess()) {
1274  ATH_MSG_WARNING("Pattern finder failed");
1275  continue;
1276  }
1277  patternTimer.stop();
1278 
1279  // Superpoint fit
1280  stationFitterTimer.start();
1281  sc = m_stationFitter->findSuperPoints(*p_roids,
1282  muonRoad,
1283  rpcFitResult,
1284  trackPatterns);
1285  if (!sc.isSuccess()) {
1286  ATH_MSG_WARNING("Super point fitter failed");
1287  continue;
1288  }
1289  stationFitterTimer.stop();
1290 
1291  // Track fitting
1292  trackFitterTimer.start();
1293  sc = m_trackFitter->findTracks(*p_roids,
1294  rpcFitResult,
1295  trackPatterns);
1296  if (!sc.isSuccess()) {
1297  ATH_MSG_WARNING("Track fitter failed");
1298  continue;
1299  }
1300  trackFitterTimer.stop();
1301 
1302  } else { // Endcap Inside-out
1303  ATH_MSG_DEBUG("muonRoad.extFtfMiddleEta Endcap: " << muonRoad.extFtfMiddleEta);
1304  ATH_MSG_DEBUG("Endcap algorithm of IOmode starts");
1305 
1306  prepTimer.start();
1307  // Data preparation
1308  sc = m_dataPreparator->prepareData(p_roi,
1309  *p_roids,
1310  m_insideOut,
1311  tgcHits,
1312  muonRoad,
1313  mdtRegion,
1314  tgcFitResult,
1315  mdtHits_normal,
1316  mdtHits_overlap,
1317  cscHits,
1318  stgcHits,
1319  mmHits);
1320  if (!sc.isSuccess()) {
1321  ATH_MSG_WARNING("Data preparation failed");
1322  continue;
1323  } else{
1324  ATH_MSG_DEBUG("Data preparation success");
1325  }
1326  prepTimer.stop();
1327 
1328  // Pattern finding
1329  patternTimer.start();
1330  sc = m_patternFinder->findPatterns(muonRoad,
1331  mdtHits_normal,
1332  stgcHits,
1333  mmHits,
1334  trackPatterns);
1335  if (!sc.isSuccess()) {
1336  ATH_MSG_WARNING("Pattern finder failed");
1337  continue;
1338  }
1339  patternTimer.stop();
1340 
1341  // Superpoint fit
1342  stationFitterTimer.start();
1343  sc = m_stationFitter->findSuperPointsSimple(*p_roids,
1344  muonRoad,
1345  tgcFitResult,
1346  trackPatterns,
1347  stgcHits,
1348  mmHits);
1350  m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
1351  if (!sc.isSuccess()) {
1352  ATH_MSG_WARNING("Super point fitter failed");
1353  continue;
1354  }
1355  stationFitterTimer.stop();
1356 
1357  // Track fittingh
1358  trackFitterTimer.start();
1359  sc = m_trackFitter->findTracks(*p_roids,
1360  tgcFitResult,
1361  trackPatterns,
1362  muonRoad);
1363  if (!sc.isSuccess()) {
1364  ATH_MSG_WARNING("Track fitter failed");
1365  continue;
1366  }
1367  trackFitterTimer.stop();
1368 
1369  }
1370 
1371  // fix if eta is strange
1372  TrigL2MuonSA::TrackPattern track = trackPatterns.back();
1373  const float ETA_LIMIT = 2.8;
1374  const float DELTA_ETA_LIMIT = 1.0;
1375  float roiEta = (*p_roi).eta();
1376  if (std::abs(track.pt) > ZERO_LIMIT
1377  && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
1378  trackPatterns.back().etaMap = roiEta;
1379  }
1380 
1381  // Update monitoring variables
1382  sc = updateMonitor(p_roi, mdtHits_normal, trackPatterns );
1383  if (sc != StatusCode::SUCCESS) {
1384  ATH_MSG_WARNING("Failed to update monitoring variables");
1385  }
1386 
1387  // Update output trigger element
1388  if ( std::abs(trackPatterns.back().pt) > ZERO_LIMIT ) {
1389  storeMuonSA(p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1390  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
1391  stgcHits, mmHits,
1392  trackPatterns.back(), outputSAs, ctx);
1393  xAOD::L2CombinedMuon* muonCB = new xAOD::L2CombinedMuon();
1394  muonCB->makePrivateStore();
1395  muonCB->setStrategy(0);
1396  muonCB->setErrorFlag(-9);
1397  muonCB->setPt(idtrack->pt());
1398  muonCB->setEta(idtrack->eta());
1399  muonCB->setPhi(idtrack->phi());
1400  muonCB->setCharge(idtrack->charge());
1401  ElementLink<xAOD::L2StandAloneMuonContainer> muonSAEL(outputSAs, outputSAs.size()-1);
1402  muonCB->setMuSATrackLink(muonSAEL);
1403  ElementLink<xAOD::TrackParticleContainer> idtrkEL(idtracks, idtrack_idx);
1404  muonCB->setIdTrackLink(idtrkEL);
1405  outputCBs.push_back(muonCB);
1406  }
1407 
1408  }
1409 
1410  if(outputSAs.size()==0) {
1411  ATH_MSG_DEBUG("outputSAs size = 0 -> push_back dummy");
1412  muonRoad.Clear();
1413  mdtRegion.Clear();
1414  rpcHits.clear();
1415  tgcHits.clear();
1416  rpcFitResult.Clear();
1417  tgcFitResult.Clear();
1418  mdtHits_normal.clear();
1419  cscHits.clear();
1420  stgcHits.clear();
1421  mmHits.clear();
1422  trackPatterns.clear();
1423  TrigL2MuonSA::TrackPattern trackPattern;
1424  storeMuonSA(p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1425  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
1426  stgcHits, mmHits,
1427  trackPattern, outputSAs, ctx);
1428  xAOD::L2CombinedMuon* muonCB = new xAOD::L2CombinedMuon();
1429  muonCB->makePrivateStore();
1430  muonCB->setStrategy(-9);
1431  muonCB->setErrorFlag(-9);
1432  muonCB->setPt(0);
1433  muonCB->setEta(99999.);
1434  muonCB->setPhi(99999.);
1435  ElementLink<xAOD::L2StandAloneMuonContainer> muonSAEL(outputSAs, outputSAs.size()-1);
1436  muonCB->setMuSATrackLink(muonSAEL);
1437  outputCBs.push_back(muonCB);
1438  }
1439 
1440 
1441  if (msgLvl(MSG::DEBUG)) {
1442  ATH_MSG_DEBUG("outputSAs size: " << outputSAs.size());
1443  ATH_MSG_DEBUG("idtracks size: " << idtracks.size());
1444  for (auto outputSA : outputSAs){
1445  ATH_MSG_DEBUG("outputSA pt/eta/phi: " << outputSA->pt() << "/" << outputSA->etaMS() << "/" << outputSA->phiMS());
1446  }
1447 
1448  ATH_MSG_DEBUG("outputCBs size: " << outputCBs.size());
1449  for (auto outputCB : outputCBs){
1450  ATH_MSG_DEBUG("outputCB pt/eta/phi: " << outputCB->pt() << "/" << outputCB->eta() << "/" << outputCB->phi());
1451  }
1452  }
1453 
1454  ++p_roids;
1455  if (p_roids==roids.end()) break;
1456  }
1457 
1458  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignatureIO success");
1459  return StatusCode::SUCCESS;
1460 }

◆ findMuonSignatureIO() [2/2]

StatusCode MuFastSteering::findMuonSignatureIO ( const xAOD::TrackParticleContainer &  idtracks,
const std::vector< const TrigRoiDescriptor * > &  roids,
const std::vector< const xAOD::MuonRoI * > &  muonRoIs,
DataVector< xAOD::L2CombinedMuon > &  outputCBs,
DataVector< xAOD::L2StandAloneMuon > &  outputSAs,
const bool  dynamicDeltaRpc,
const EventContext &  ctx 
) const

Definition at line 1467 of file MuFastSteering.cxx.

1474 {
1475  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignatureIO start");
1476  StatusCode sc = StatusCode::SUCCESS;
1477  const float ZERO_LIMIT = 1.e-5;
1478 
1479  auto prepTimer = Monitored::Timer( "TIME_Data_Preparator" );
1480  auto patternTimer = Monitored::Timer( "TIME_Pattern_Finder" );
1481  auto stationFitterTimer = Monitored::Timer( "TIME_Station_Fitter" );
1482  auto trackFitterTimer = Monitored::Timer( "TIME_Track_Fitter" );
1483  auto trackExtraTimer = Monitored::Timer( "TIME_Track_Extrapolator" );
1484  auto calibrationTimer = Monitored::Timer( "TIME_Calibration_Streamer" );
1485 
1486  auto monitorIt = Monitored::Group(m_monTool, prepTimer, patternTimer, stationFitterTimer,
1487  trackFitterTimer, trackExtraTimer, calibrationTimer );
1488 
1489  TrigL2MuonSA::RpcHits rpcHits;
1490  TrigL2MuonSA::TgcHits tgcHits;
1491  TrigL2MuonSA::MdtRegion mdtRegion;
1492  TrigL2MuonSA::MuonRoad muonRoad;
1493  TrigL2MuonSA::RpcFitResult rpcFitResult;
1494  TrigL2MuonSA::TgcFitResult tgcFitResult;
1495  TrigL2MuonSA::MdtHits mdtHits_normal;
1496  TrigL2MuonSA::MdtHits mdtHits_overlap;
1497  TrigL2MuonSA::CscHits cscHits;
1498  TrigL2MuonSA::StgcHits stgcHits;
1499  TrigL2MuonSA::MmHits mmHits;
1500 
1501  DataVector<const TrigRoiDescriptor>::const_iterator p_roids;
1502 
1503  p_roids = roids.begin();
1504  for (const auto p_roi : muonRoIs) {
1505  ATH_MSG_DEBUG("roi eta/phi: " << (*p_roi).eta() << "/" << (*p_roi).phi());
1506 
1507  // idtracks loop
1508  if ( (idtracks).empty() ) ATH_MSG_DEBUG("IO TEST: xAOD::TrackParticleContainer has 0 tracks --> Can not use FTF tracks...");
1509  else ATH_MSG_DEBUG("IO TEST: xAOD::TrackParticleContainer has " << (idtracks).size() << " tracks --> Start inside-out mode!");
1510 
1511  std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
1512  int idtrack_idx = -1;
1513  for (auto idtrack : idtracks) {
1514 
1515  idtrack_idx++;
1516  ATH_MSG_DEBUG("IO TEST: FTF track key:" << m_FTFtrackKey.key() << " pt = " << idtrack->pt()/1000 << " GeV");
1517  ATH_MSG_DEBUG("IO TEST: FTF track key:" << m_FTFtrackKey.key() << " eta/phi = " << idtrack->eta() << "/" << idtrack->phi());
1518 
1519  if(idtrack->pt() < m_ftfminPt) {
1520  ATH_MSG_DEBUG("IO TEST: skip FTF track due to pT threshold: " << m_ftfminPt << " MeV");
1521  continue;
1522  }
1523 
1524  prepTimer.start();
1525  rpcHits.clear();
1526  tgcHits.clear();
1527  mdtRegion.Clear();
1528  muonRoad.Clear();
1529  rpcFitResult.Clear();
1530  tgcFitResult.Clear();
1531  mdtHits_normal.clear();
1532  mdtHits_overlap.clear();
1533  cscHits.clear();
1534  stgcHits.clear();
1535  mmHits.clear();
1536  trackPatterns.clear();
1537 
1538  sc = m_ftfRoadDefiner->defineRoad(idtrack, muonRoad);
1539  if (!sc.isSuccess()) {
1540  ATH_MSG_WARNING("FtfRoadDefiner failed");
1541  continue;
1542  } else {
1543  ATH_MSG_DEBUG("FtfRoadDefiner::defineRoad success");
1544  }
1545 
1546  if ( std::abs(idtrack->eta()) < 1.05 ){
1547  ATH_MSG_DEBUG("FTF track at IP is in Barrel: " << idtrack->eta());
1548  } else {
1549  ATH_MSG_DEBUG("FTF track at IP is in Endcap: " << idtrack->eta());
1550  }
1551 
1552  if ( m_recMuonRoIUtils.isBarrel(p_roi) ) { // Barrel Inside-out
1553  ATH_MSG_DEBUG("muonRoad.extFtfMiddleEta Barrel: " << muonRoad.extFtfMiddleEta);
1554 
1555  ATH_MSG_DEBUG("Barrel algorithm of IOmode starts");
1556 
1557  muonRoad.setScales(m_scaleRoadBarrelInner,
1558  m_scaleRoadBarrelMiddle,
1559  m_scaleRoadBarrelOuter);
1560 
1561  // Data preparation
1562  sc = m_dataPreparator->prepareData(p_roi,
1563  *p_roids,
1564  m_insideOut,
1565  rpcHits,
1566  muonRoad,
1567  mdtRegion,
1568  rpcFitResult,
1569  mdtHits_normal,
1570  mdtHits_overlap,
1571  dynamicDeltaRpc);
1572  if (!sc.isSuccess()) {
1573  ATH_MSG_WARNING("Data preparation failed");
1574  continue;
1575  } else {
1576  ATH_MSG_DEBUG("Data preparation success");
1577  }
1578  prepTimer.stop();
1579 
1580  // Pattern finding
1581  patternTimer.start();
1582  sc = m_patternFinder->findPatterns(muonRoad,
1583  mdtHits_normal,
1584  trackPatterns);
1585  if (!sc.isSuccess()) {
1586  ATH_MSG_WARNING("Pattern finder failed");
1587  continue;
1588  }
1589  patternTimer.stop();
1590 
1591  // Superpoint fit
1592  stationFitterTimer.start();
1593  sc = m_stationFitter->findSuperPoints(*p_roids,
1594  muonRoad,
1595  rpcFitResult,
1596  trackPatterns);
1597  if (!sc.isSuccess()) {
1598  ATH_MSG_WARNING("Super point fitter failed");
1599  continue;
1600  }
1601  stationFitterTimer.stop();
1602 
1603  // Track fitting
1604  trackFitterTimer.start();
1605  sc = m_trackFitter->findTracks(*p_roids,
1606  rpcFitResult,
1607  trackPatterns);
1608  if (!sc.isSuccess()) {
1609  ATH_MSG_WARNING("Track fitter failed");
1610  continue;
1611  }
1612  trackFitterTimer.stop();
1613 
1614  } else { // Endcap Inside-out
1615  ATH_MSG_DEBUG("muonRoad.extFtfMiddleEta Endcap: " << muonRoad.extFtfMiddleEta);
1616  ATH_MSG_DEBUG("Endcap algorithm of IOmode starts");
1617 
1618  prepTimer.start();
1619  // Data preparation
1620  sc = m_dataPreparator->prepareData(p_roi,
1621  *p_roids,
1622  m_insideOut,
1623  tgcHits,
1624  muonRoad,
1625  mdtRegion,
1626  tgcFitResult,
1627  mdtHits_normal,
1628  mdtHits_overlap,
1629  cscHits,
1630  stgcHits,
1631  mmHits);
1632  if (!sc.isSuccess()) {
1633  ATH_MSG_WARNING("Data preparation failed");
1634  continue;
1635  } else{
1636  ATH_MSG_DEBUG("Data preparation success");
1637  }
1638  prepTimer.stop();
1639 
1640  // Pattern finding
1641  patternTimer.start();
1642  sc = m_patternFinder->findPatterns(muonRoad,
1643  mdtHits_normal,
1644  stgcHits,
1645  mmHits,
1646  trackPatterns);
1647  if (!sc.isSuccess()) {
1648  ATH_MSG_WARNING("Pattern finder failed");
1649  continue;
1650  }
1651  patternTimer.stop();
1652 
1653  // Superpoint fit
1654  stationFitterTimer.start();
1655  sc = m_stationFitter->findSuperPointsSimple(*p_roids,
1656  muonRoad,
1657  tgcFitResult,
1658  trackPatterns,
1659  stgcHits,
1660  mmHits);
1662  m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
1663  if (!sc.isSuccess()) {
1664  ATH_MSG_WARNING("Super point fitter failed");
1665  continue;
1666  }
1667  stationFitterTimer.stop();
1668 
1669  // Track fittingh
1670  trackFitterTimer.start();
1671  sc = m_trackFitter->findTracks(*p_roids,
1672  tgcFitResult,
1673  trackPatterns,
1674  muonRoad);
1675  if (!sc.isSuccess()) {
1676  ATH_MSG_WARNING("Track fitter failed");
1677  continue;
1678  }
1679  trackFitterTimer.stop();
1680 
1681  }
1682 
1683  // fix if eta is strange
1684  TrigL2MuonSA::TrackPattern track = trackPatterns.back();
1685  const float ETA_LIMIT = 2.8;
1686  const float DELTA_ETA_LIMIT = 1.0;
1687  float roiEta = (*p_roi).eta();
1688  if (std::abs(track.pt) > ZERO_LIMIT
1689  && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
1690  trackPatterns.back().etaMap = roiEta;
1691  }
1692 
1693  // Update monitoring variables
1694  sc = updateMonitor(p_roi, mdtHits_normal, trackPatterns );
1695  if (sc != StatusCode::SUCCESS) {
1696  ATH_MSG_WARNING("Failed to update monitoring variables");
1697  }
1698 
1699  // Update output trigger element
1700  if ( std::abs(trackPatterns.back().pt) > ZERO_LIMIT ) {
1701  storeMuonSA(p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1702  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
1703  stgcHits, mmHits,
1704  trackPatterns.back(), outputSAs, ctx);
1705  xAOD::L2CombinedMuon* muonCB = new xAOD::L2CombinedMuon();
1706  muonCB->makePrivateStore();
1707  muonCB->setStrategy(0);
1708  muonCB->setErrorFlag(-9);
1709  muonCB->setPt(idtrack->pt());
1710  muonCB->setEta(idtrack->eta());
1711  muonCB->setPhi(idtrack->phi());
1712  muonCB->setCharge(idtrack->charge());
1713  ElementLink<xAOD::L2StandAloneMuonContainer> muonSAEL(outputSAs, outputSAs.size()-1);
1714  muonCB->setMuSATrackLink(muonSAEL);
1715  ElementLink<xAOD::TrackParticleContainer> idtrkEL(idtracks, idtrack_idx);
1716  muonCB->setIdTrackLink(idtrkEL);
1717  outputCBs.push_back(muonCB);
1718  }
1719 
1720  }
1721 
1722  if(outputSAs.size()==0) {
1723  ATH_MSG_DEBUG("outputSAs size = 0 -> push_back dummy");
1724  muonRoad.Clear();
1725  mdtRegion.Clear();
1726  rpcHits.clear();
1727  tgcHits.clear();
1728  rpcFitResult.Clear();
1729  tgcFitResult.Clear();
1730  mdtHits_normal.clear();
1731  cscHits.clear();
1732  stgcHits.clear();
1733  mmHits.clear();
1734  trackPatterns.clear();
1735  TrigL2MuonSA::TrackPattern trackPattern;
1736  storeMuonSA(p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1737  rpcFitResult, tgcFitResult, mdtHits_normal, cscHits,
1738  stgcHits, mmHits,
1739  trackPattern, outputSAs, ctx);
1740  xAOD::L2CombinedMuon* muonCB = new xAOD::L2CombinedMuon();
1741  muonCB->makePrivateStore();
1742  muonCB->setStrategy(-9);
1743  muonCB->setErrorFlag(-9);
1744  muonCB->setPt(0);
1745  muonCB->setEta(99999.);
1746  muonCB->setPhi(99999.);
1747  ElementLink<xAOD::L2StandAloneMuonContainer> muonSAEL(outputSAs, outputSAs.size()-1);
1748  muonCB->setMuSATrackLink(muonSAEL);
1749  outputCBs.push_back(muonCB);
1750  }
1751 
1752 
1753  ATH_MSG_DEBUG("outputSAs size: " << outputSAs.size());
1754  ATH_MSG_DEBUG("idtracks size: " << idtracks.size());
1755  for (auto outputSA : outputSAs){
1756  ATH_MSG_DEBUG("outputSA pt/eta/phi: " << outputSA->pt() << "/" << outputSA->etaMS() << "/" << outputSA->phiMS());
1757  }
1758 
1759  ATH_MSG_DEBUG("outputCBs size: " << outputCBs.size());
1760  for (auto outputCB : outputCBs){
1761  ATH_MSG_DEBUG("outputCB pt/eta/phi: " << outputCB->pt() << "/" << outputCB->eta() << "/" << outputCB->phi());
1762  }
1763 
1764  ++p_roids;
1765  if (p_roids==roids.end()) break;
1766  }
1767 
1768  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignatureIO success");
1769  return StatusCode::SUCCESS;
1770 }

◆ getRoiSizeForID()

float MuFastSteering::getRoiSizeForID ( bool  isEta,
const xAOD::L2StandAloneMuon *  muonSA 
) const
private

Definition at line 3497 of file MuFastSteering.cxx.

3498 {
3499  bool isBarrel = (muonSA->sAddress()==-1) ? true : false;
3500  float eta = muonSA->etaMS();
3501  float phi = muonSA->phiMS();
3502  float pt = muonSA->pt();
3503 
3504  //
3505  const int N_PARAMS = 2;
3506 
3507  //
3508  const float etaMinWin_brl = 0.10;
3509  const float etaMinWin_ec1 = 0.10;
3510  const float etaMinWin_ec2 = 0.10;
3511  const float etaMinWin_ec3 = 0.10;
3512  const float etaMinWin_ecA = 0.10;
3513  const float etaMinWin_ecB = 0.10;
3514 
3515  const float etaMaxWin_brl = 0.20;
3516  const float etaMaxWin_ec1 = 0.20;
3517  const float etaMaxWin_ec2 = 0.20;
3518  const float etaMaxWin_ec3 = 0.20;
3519  const float etaMaxWin_ecA = 0.20;
3520  const float etaMaxWin_ecB = 0.20;
3521 
3522  const float etaParams_brl[N_PARAMS] = { 0.038, 0.284};
3523  const float etaParams_ec1[N_PARAMS] = { 0.011, 0.519};
3524  const float etaParams_ec2[N_PARAMS] = { 0.023, 0.253};
3525  const float etaParams_ec3[N_PARAMS] = { 0.018, 0.519};
3526  const float etaParams_ecA[N_PARAMS] = { 0.010, 0.431};
3527  const float etaParams_ecB[N_PARAMS] = { 0.023, 0.236};
3528 
3529  //
3530  const float phiMinWin_brl = 0.125;
3531  const float phiMinWin_ec1 = 0.125;
3532  const float phiMinWin_ec2 = 0.125;
3533  const float phiMinWin_ec3 = 0.10;
3534  const float phiMinWin_ecA = 0.15;
3535  const float phiMinWin_ecB = 0.15;
3536 
3537  const float phiMaxWin_brl = 0.20;
3538  const float phiMaxWin_ec1 = 0.20;
3539  const float phiMaxWin_ec2 = 0.20;
3540  const float phiMaxWin_ec3 = 0.20;
3541  const float phiMaxWin_ecA = 0.25;
3542  const float phiMaxWin_ecB = 0.20;
3543 
3544  const float phiParams_brl[N_PARAMS] = { 0.000, 0.831};
3545  const float phiParams_ec1[N_PARAMS] = { 0.000, 0.885};
3546  const float phiParams_ec2[N_PARAMS] = { 0.015, 0.552};
3547  const float phiParams_ec3[N_PARAMS] = { 0.008, 0.576};
3548  const float phiParams_ecA[N_PARAMS] = { 0.000, 0.830};
3549  const float phiParams_ecB[N_PARAMS] = { 0.006, 1.331};
3550 
3551  //
3552  float minWin;
3553  float maxWin;
3554  float params[N_PARAMS];
3555  if( isBarrel ) {
3556  if( isEta ) {
3557  memcpy(params,etaParams_brl,sizeof(params));
3558  minWin = etaMinWin_brl;
3559  maxWin = etaMaxWin_brl;
3560  }
3561  else {
3562  memcpy(params,phiParams_brl,sizeof(params));
3563  minWin = phiMinWin_brl;
3564  maxWin = phiMaxWin_brl;
3565  }
3566  }
3567  else { // endcap
3568  xAOD::L2MuonParameters::ECRegions reg = xAOD::L2MuonParameters::whichECRegion(eta,phi);
3569  if( reg == xAOD::L2MuonParameters::ECRegions::WeakBFieldA ) {
3570 
3571  if( isEta ) {
3572  memcpy(params,etaParams_ecA,sizeof(params));
3573  minWin = etaMinWin_ecA;
3574  maxWin = etaMaxWin_ecA;
3575  }
3576  else {
3577  memcpy(params,phiParams_ecA,sizeof(params));
3578  minWin = phiMinWin_ecA;
3579  maxWin = phiMaxWin_ecA;
3580  }
3581  }
3582  else if( reg == xAOD::L2MuonParameters::ECRegions::WeakBFieldB ) {
3583  if( isEta ) {
3584  memcpy(params,etaParams_ecB,sizeof(params));
3585  minWin = etaMinWin_ecB;
3586  maxWin = etaMaxWin_ecB;
3587  }
3588  else {
3589  memcpy(params,phiParams_ecB,sizeof(params));
3590  minWin = phiMinWin_ecB;
3591  maxWin = phiMaxWin_ecB;
3592  }
3593  }
3594  else {
3595  if( std::abs(eta) < 1.5 ) {
3596  if( isEta ) {
3597  memcpy(params,etaParams_ec1,sizeof(params));
3598  minWin = etaMinWin_ec1;
3599  maxWin = etaMaxWin_ec1;
3600  }
3601  else {
3602  memcpy(params,phiParams_ec1,sizeof(params));
3603  minWin = phiMinWin_ec1;
3604  maxWin = phiMaxWin_ec1;
3605  }
3606  }
3607  else if( std::abs(eta) < 2.0 ) {
3608  if( isEta ) {
3609  memcpy(params,etaParams_ec2,sizeof(params));
3610  minWin = etaMinWin_ec2;
3611  maxWin = etaMaxWin_ec2;
3612  }
3613  else {
3614  memcpy(params,phiParams_ec2,sizeof(params));
3615  minWin = phiMinWin_ec2;
3616  maxWin = phiMaxWin_ec2;
3617  }
3618  }
3619  else {
3620  if( isEta ) {
3621  memcpy(params,etaParams_ec3,sizeof(params));
3622  minWin = etaMinWin_ec3;
3623  maxWin = etaMaxWin_ec3;
3624  }
3625  else {
3626  memcpy(params,phiParams_ec3,sizeof(params));
3627  minWin = phiMinWin_ec3;
3628  maxWin = phiMaxWin_ec3;
3629  }
3630  }
3631  }
3632  }
3633 
3634  //
3635  float x = params[0] + params[1] / pt;
3636  float retval = x;
3637  if( x < minWin ) retval = minWin;
3638  if( x > maxWin ) retval = maxWin;
3639 
3640  return retval;
3641 }

◆ handle()

void MuFastSteering::handle ( const Incident &  incident)
overridevirtual

Definition at line 168 of file MuFastSteering.cxx.

168  {
169 
170 
171  if (incident.type() == AthenaInterprocess::UpdateAfterFork::type() && m_doCalStream) {
172  ATH_MSG_DEBUG("+-----------------------------------+");
173  ATH_MSG_DEBUG("| handle for UpdateAfterFork called |");
174  ATH_MSG_DEBUG("+-----------------------------------+");
175  const AthenaInterprocess::UpdateAfterFork& updinc = dynamic_cast<const AthenaInterprocess::UpdateAfterFork&>(incident);
176 
177  ATH_MSG_DEBUG(" MuonCalBufferName = " << m_calBufferName);
178  ATH_MSG_DEBUG(" MuonCalBufferSize = " << m_calBufferSize);
179  ATH_MSG_DEBUG(" MuonCalBufferWId = " << updinc.workerID());
180  ATH_MSG_DEBUG("=================================================");
181 
182 
183  std::string worker_name=std::to_string(updinc.workerID());
184  //
185  // Create the calibration stream
186 
187  m_calStreamer->setInstanceName(worker_name);
188 
189  //open the stream
190  if ( m_calStreamer->openStream(m_calBufferSize).isSuccess() ) {
191  ATH_MSG_INFO("Opened the connection to the circular buffer " << m_calBufferName.value());
192  } else {
193  ATH_MSG_ERROR("Failed to open the connection to the circular buffer " << m_calBufferName.value());
194  }
195  }
196 }

◆ initialize()

StatusCode MuFastSteering::initialize ( )
overridevirtual

Definition at line 30 of file MuFastSteering.cxx.

31 {
32  // Locate DataPreparator
33  ATH_CHECK(m_dataPreparator.retrieve());
34 
35  // Locate PatternFinder
36  ATH_CHECK(m_patternFinder.retrieve());
37 
38  // Locate StationFitter
39  ATH_CHECK(m_stationFitter.retrieve());
40 
41  // Locate TrackFitter
42  ATH_CHECK(m_trackFitter.retrieve());
43 
44  // Locate TrackExtrapolator
45  ATH_CHECK(m_trackExtrapolator.retrieve());
46 
47  // BackExtrapolator services
48  ATH_CHECK(m_backExtrapolatorTool.retrieve());
49 
50  // CscSegmentMaker
51  ATH_CHECK(m_cscsegmaker.retrieve());
52 
53  // FtfRoadDefiner
54  ATH_CHECK(m_ftfRoadDefiner.retrieve());
55 
56  // Set service tools
57  m_trackExtrapolator->setExtrapolatorTool(&m_backExtrapolatorTool);
58  m_dataPreparator->setExtrapolatorTool(&m_backExtrapolatorTool);
59 
60  // set road width in case TGC/RPC readout failure
61  m_dataPreparator->setRoadWidthForFailure(m_rWidth_RPC_Failed, m_rWidth_TGC_Failed);
62 
63  m_dataPreparator->setRpcGeometry(m_use_rpc);
64 
65  // set the flag whether to use NSW or not
66  m_dataPreparator->setStgcGeometry(m_use_stgc);
67  m_dataPreparator->setMmGeometry(m_use_mm);
68 
69  m_dataPreparator->setRoIBasedDataAccess(m_use_RoIBasedDataAccess_MDT,
70  m_use_RoIBasedDataAccess_RPC,
71  m_use_RoIBasedDataAccess_TGC,
72  m_use_RoIBasedDataAccess_CSC,
73  m_use_RoIBasedDataAccess_STGC,
74  m_use_RoIBasedDataAccess_MM);
75 
76  // set data or MC flag
77  ATH_CHECK(m_dataPreparator->setMCFlag(m_use_mcLUT));
78 
80  ATH_CHECK(m_stationFitter->setMCFlag(m_use_mcLUT));
81  ATH_CHECK(m_trackFitter->setMCFlag(m_use_mcLUT));
82  m_trackFitter -> setUseEIFromBarrel( m_use_endcapInnerFromBarrel );
83 
84  // DataHandles for AthenaMT
85  ATH_CHECK(m_eventInfoKey.initialize());
86  ATH_CHECK(m_roiCollectionKey.initialize());
87  ATH_CHECK(m_run2recRoiCollectionKey.initialize(!m_useRun3Config));
88  ATH_CHECK(m_recRoiCollectionKey.initialize(m_useRun3Config));
89  // for Inside-Out mode ---
90  ATH_CHECK(m_FTFtrackKey.initialize(m_insideOut));
91  ATH_CHECK(m_outputCBmuonCollKey.initialize(m_insideOut));
92  // ----
93  ATH_CHECK(m_muFastContainerKey.initialize());
94  ATH_CHECK(m_muCompositeContainerKey.initialize());
95  ATH_CHECK(m_muIdContainerKey.initialize());
96 
97  ATH_CHECK(m_muMsContainerKey.initialize());
98  if (not m_monTool.name().empty()) {
99  ATH_CHECK(m_monTool.retrieve());
100  }
101  ATH_MSG_DEBUG( "topoRoad = " << m_topoRoad);
102 
103  if (m_fill_FSIDRoI) {
104  ATH_MSG_INFO("will fill " << m_muIdContainerKey.key() << " in Full Scan mode. Please check if it's correct.");
105  }
106 
107  ATH_MSG_DEBUG("InsideOutMode: " << m_insideOut);
108  ATH_MSG_DEBUG("Multi-TrackMode: " << m_multiTrack << "/ run for endcap RoI -> " << m_doEndcapForl2mt);
109 
110  //
111  // Initialize the calibration streamer
112  //
113 
114  if (m_doCalStream) {
115  ATH_CHECK(m_jobOptionsSvc.retrieve());
116 
117  if (m_jobOptionsSvc->has("MuonHltCalibrationConfig.MuonCalBufferName")) {
118  if (m_calBufferName.fromString(m_jobOptionsSvc->get("MuonHltCalibrationConfig.MuonCalBufferName","")).isSuccess()) {
119  ATH_MSG_DEBUG("Set property " << m_calBufferName << " from MuonHltCalibrationConfig.MuonCalBufferName");
120  }
121  } else {
122  ATH_MSG_DEBUG("Could not parse MuonHltCalibrationConfig.MuonCalBufferName from JobOptionsSvc");
123  }
124  if (m_jobOptionsSvc->has("MuonHltCalibrationConfig.MuonCalBufferSize")) {
125  if (m_calBufferSize.fromString(m_jobOptionsSvc->get("MuonHltCalibrationConfig.MuonCalBufferSize","")).isSuccess()) {
126  ATH_MSG_DEBUG("Set property " << m_calBufferSize << " from MuonHltCalibrationConfig.MuonCalBufferSize");
127  }
128  }
129  else {
130  ATH_MSG_DEBUG("Could not parse MuonHltCalibrationConfig.MuonCalBufferSize from JobOptionsSvc");
131  }
132 
133  // retrieve the calibration streamer
134  ATH_CHECK(m_calStreamer.retrieve());
135  // set properties
136  m_calStreamer->setBufferName(m_calBufferName);
137  ATH_MSG_DEBUG("Initialized the Muon Calibration Streamer. Buffer name: " << m_calBufferName
138  << ", buffer size: " << m_calBufferSize
139  << " doDataScouting: " << m_calDataScouting);
140 
141 
142  ATH_CHECK(m_incidentSvc.retrieve());
143  m_incidentSvc->addListener(this, AthenaInterprocess::UpdateAfterFork::type());
144  }
145 
146 
147  return StatusCode::SUCCESS;
148 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

◆ isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

52 {
53  // Reentrant algorithms are clonable.
54  return true;
55 }

◆ L2MuonAlgoMap()

int MuFastSteering::L2MuonAlgoMap ( const std::string &  name) const

Definition at line 3480 of file MuFastSteering.cxx.

3481 {
3482  int algoId = 0;
3483  if (name == "MuFastSteering_Muon") {
3484  algoId = xAOD::L2MuonParameters::L2MuonAlgoId::MUONID;
3485  } else if (name == "MuFastSteering_900GeV") {
3486  algoId = xAOD::L2MuonParameters::L2MuonAlgoId::GEV900ID;
3487  } else {
3488  algoId = xAOD::L2MuonParameters::L2MuonAlgoId::NULLID;
3489  }
3490 
3491  return algoId;
3492 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::Algorithm >::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< Gaudi::Algorithm >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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  }

◆ setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100  {
101  execState( ctx ).setFilterPassed( state );
102  }

◆ stop()

StatusCode MuFastSteering::stop ( )
overridevirtual

Definition at line 150 of file MuFastSteering.cxx.

151 {
152  // close the calibration stream
153  if ( m_doCalStream ) {
154  if (m_calStreamer->isStreamOpen()){
155  StatusCode sc = m_calStreamer->closeStream();
156  if ( sc != StatusCode::SUCCESS ) {
157  ATH_MSG_ERROR("Failed to close the calibration stream");}
158  else {
159  ATH_MSG_INFO("Calibration stream closed");
160  }
161  }
162  }
163  return StatusCode::SUCCESS;
164 }

◆ storeIDRoiDescriptor()

bool MuFastSteering::storeIDRoiDescriptor ( const TrigRoiDescriptor *  roids,
const TrigL2MuonSA::TrackPattern &  pattern,
const DataVector< xAOD::L2StandAloneMuon > &  outputTracks,
TrigRoiDescriptorCollection &  outputID 
) const
protected

Definition at line 3388 of file MuFastSteering.cxx.

3392 {
3393 
3394  if (m_fill_FSIDRoI) { // this mode will be used in cosmic run, if ID expert want to run full scan FTF.
3395  TrigRoiDescriptor* IDroiDescriptor = new TrigRoiDescriptor(true);
3396  outputID.push_back(IDroiDescriptor);
3397  return true;
3398  }
3399 
3400  const float ZERO_LIMIT = 1.e-5;
3401 
3402  const double scalePhiWidthForFailure = 2;
3403  const double scaleRoIforZeroPt = 2;
3404 
3405  const xAOD::L2StandAloneMuon* muonSA = outputTracks[0];
3406 
3407  // store TrigRoiDescriptor
3408  if (std::abs(muonSA->pt()) > ZERO_LIMIT ) {
3409 
3410  // patch for the ID RoI descriptor
3411  float phiHalfWidth = 0.1;
3412  float etaHalfWidth = 0.1;
3413 
3414  // 2010 runs
3415  // if ( std::abs(pattern.etaVtx)>1 && std::abs(pattern.etaVtx)<1.5 ) {
3416  // phiHalfWidth = 0.25;
3417  // etaHalfWidth = 0.4;
3418  // } else {
3419  // phiHalfWidth = 0.1;
3420  // etaHalfWidth = 0.15;
3421  // }
3422 
3423  // 2011a tuning
3424  phiHalfWidth = getRoiSizeForID(false,muonSA);
3425  etaHalfWidth = getRoiSizeForID(true, muonSA);
3426 
3427  if (pattern.isTgcFailure || pattern.isRpcFailure)
3428  phiHalfWidth *= scalePhiWidthForFailure;
3429 
3430  TrigRoiDescriptor* IDroiDescriptor = new TrigRoiDescriptor(roids->roiWord(),
3431  roids->l1Id(),
3432  roids->roiId(),
3433  pattern.etaVtx,
3434  pattern.etaVtx - etaHalfWidth,
3435  pattern.etaVtx + etaHalfWidth,
3436  pattern.phiVtx,
3437  pattern.phiVtx - phiHalfWidth,
3438  pattern.phiVtx + phiHalfWidth);
3439 
3440  ATH_MSG_VERBOSE("...TrigRoiDescriptor for ID "
3441  << "pattern.etaVtx/pattern.phiVtx="
3442  << pattern.etaVtx << "/" << pattern.phiVtx);
3443 
3444  ATH_MSG_VERBOSE("will Record an RoiDescriptor for Inner Detector:"
3445  << " phi=" << IDroiDescriptor->phi()
3446  << ", eta=" << IDroiDescriptor->eta());
3447 
3448  outputID.push_back(IDroiDescriptor);
3449 
3450  } else { // pt = 0.
3451 
3452  TrigRoiDescriptor* IDroiDescriptor = new TrigRoiDescriptor(roids->roiWord(),
3453  roids->l1Id(),
3454  roids->roiId(),
3455  roids->eta(),
3456  roids->eta() - (roids->eta() - roids->etaMinus()) * scaleRoIforZeroPt,
3457  roids->eta() + (roids->etaPlus() - roids->eta()) * scaleRoIforZeroPt,
3458  roids->phi(),
3459  CxxUtils::wrapToPi(roids->phi() - CxxUtils::wrapToPi(roids->phiPlus() - roids->phiMinus())/2. * scaleRoIforZeroPt),
3460  CxxUtils::wrapToPi(roids->phi() + CxxUtils::wrapToPi(roids->phiPlus() - roids->phiMinus())/2. * scaleRoIforZeroPt));
3461 
3462  ATH_MSG_VERBOSE("will Record an RoiDescriptor for Inner Detector in case with zero pT:"
3463  << " phi=" << IDroiDescriptor->phi()
3464  << ", phi min=" << IDroiDescriptor->phiMinus()
3465  << ", phi max=" << IDroiDescriptor->phiPlus()
3466  << ", eta=" << IDroiDescriptor->eta()
3467  << ", eta min=" << IDroiDescriptor->etaMinus()
3468  << ", eta max=" << IDroiDescriptor->etaPlus());
3469 
3470  outputID.push_back(IDroiDescriptor);
3471  }
3472 
3473  return true;
3474 }

◆ storeMSRoiDescriptor()

bool MuFastSteering::storeMSRoiDescriptor ( const TrigRoiDescriptor *  roids,
const TrigL2MuonSA::TrackPattern &  pattern,
const DataVector< xAOD::L2StandAloneMuon > &  outputTracks,
TrigRoiDescriptorCollection &  outputMS 
) const
protected

Definition at line 3342 of file MuFastSteering.cxx.

3346 {
3347  const float ZERO_LIMIT = 1.e-5;
3348 
3349  const xAOD::L2StandAloneMuon* muonSA = outputTracks[0];
3350 
3351  float mseta = pattern.etaMap;
3352  float msphi = pattern.phiMS;
3353 
3354  // store TrigRoiDescriptor
3355  if (std::abs(muonSA->pt()) < ZERO_LIMIT ) {
3356  mseta = roids->eta();
3357  msphi = roids->phi();
3358  }
3359 
3360  // set width of 0.1 so that ID tracking monitoring works
3361  const float phiHalfWidth = 0.1;
3362  const float etaHalfWidth = 0.1;
3363 
3364  TrigRoiDescriptor* MSroiDescriptor = new TrigRoiDescriptor(roids->roiWord(),
3365  roids->l1Id(),
3366  roids->roiId(),
3367  mseta,
3368  mseta - etaHalfWidth,
3369  mseta + etaHalfWidth,
3370  msphi,
3371  msphi - phiHalfWidth,
3372  msphi + phiHalfWidth);
3373 
3374  ATH_MSG_VERBOSE("...TrigRoiDescriptor for MS "
3375  << "mseta/msphi="
3376  << mseta << "/" << msphi);
3377 
3378  ATH_MSG_VERBOSE("will Record an RoiDescriptor for TrigMoore:"
3379  << " phi=" << MSroiDescriptor->phi()
3380  << ", eta=" << MSroiDescriptor->eta());
3381 
3382  outputMS.push_back(MSroiDescriptor);
3383 
3384  return true;
3385 }

◆ storeMuonSA() [1/2]

bool MuFastSteering::storeMuonSA ( const LVL1::RecMuonRoI *  roi,
const TrigRoiDescriptor *  roids,
const TrigL2MuonSA::MuonRoad &  muonRoad,
const TrigL2MuonSA::MdtRegion &  mdtRegion,
const TrigL2MuonSA::RpcHits &  rpcHits,
const TrigL2MuonSA::TgcHits &  tgcHits,
const TrigL2MuonSA::RpcFitResult &  rpcFitResult,
const TrigL2MuonSA::TgcFitResult &  tgcFitResult,
const TrigL2MuonSA::MdtHits &  mdtHits,
const TrigL2MuonSA::CscHits &  cscHits,
const TrigL2MuonSA::StgcHits &  stgcHits,
const TrigL2MuonSA::MmHits &  mmHits,
const TrigL2MuonSA::TrackPattern &  pattern,
DataVector< xAOD::L2StandAloneMuon > &  outputTracks,
const EventContext &  ctx 
) const
protected

Set L2 muon algorithm ID

Set input TE ID

Set level-1 ID

Set lumi block

Set muon detector mask

Set RoI ID

Set RoI system ID

Set RoI subsystem ID

Set RoI sector ID

Set RoI number

Set RoI threshold number

Set RoI eta

Set RoIp phi

Set RoI word

Set size of storages to be reserved

Definition at line 2495 of file MuFastSteering.cxx.

2510 {
2511  const float ZERO_LIMIT = 1.e-5;
2512 
2513  const int currentRoIId = roids->roiId();
2514 
2515  const EventIDBase& eventID = ctx.eventID();
2516  auto eventInfo = SG::makeHandle(m_eventInfoKey, ctx);
2517  if (!eventInfo.isValid()) {
2518  ATH_MSG_ERROR("Failed to retrieve xAOD::EventInfo object");
2519  return false;
2520  }
2521 
2522  int inner = 0;
2523  int middle = 1;
2524  int outer = 2;
2525  int ee = 6;
2526  int csc = 7;
2527  int barrelinner = 0;
2528  int endcapinner = 3;
2529  int bee = 8;
2530  int bme = 9;
2531  // int bmg = 10;
2532 
2533  // define inner, middle, outer
2534  if (pattern.s_address==-1) {
2535  inner = xAOD::L2MuonParameters::Chamber::EndcapInner;
2536  middle = xAOD::L2MuonParameters::Chamber::EndcapMiddle;
2537  outer = xAOD::L2MuonParameters::Chamber::EndcapOuter;
2538  ee = xAOD::L2MuonParameters::Chamber::EndcapExtra;
2539  barrelinner = xAOD::L2MuonParameters::Chamber::BarrelInner;
2540  bee = xAOD::L2MuonParameters::Chamber::BEE;
2541  } else {
2542  inner = xAOD::L2MuonParameters::Chamber::BarrelInner;
2543  middle = xAOD::L2MuonParameters::Chamber::BarrelMiddle;
2544  outer = xAOD::L2MuonParameters::Chamber::BarrelOuter;
2545  bme = xAOD::L2MuonParameters::Chamber::BME;
2546  endcapinner = xAOD::L2MuonParameters::Chamber::EndcapInner;
2547  }
2548 
2549  ATH_MSG_DEBUG("### Hit patterns at the Muon Spectrometer ###");
2550  ATH_MSG_DEBUG("pattern#0: # of hits at inner =" << pattern.mdtSegments[inner].size());
2551  ATH_MSG_DEBUG("pattern#0: # of hits at middle =" << pattern.mdtSegments[middle].size());
2552  ATH_MSG_DEBUG("pattern#0: # of hits at outer =" << pattern.mdtSegments[outer].size());
2553  if (pattern.s_address==-1){
2554  ATH_MSG_DEBUG("pattern#0: # of hits at ee =" << pattern.mdtSegments[ee].size());
2555  ATH_MSG_DEBUG("pattern#0: # of hits at endcap barrel inner =" << pattern.mdtSegments[barrelinner].size());
2556  ATH_MSG_DEBUG("pattern#0: # of hits at BEE =" << pattern.mdtSegments[bee].size());
2557  } else {
2558  ATH_MSG_DEBUG("pattern#0: # of hits at BME =" << pattern.mdtSegments[bme].size());
2559  ATH_MSG_DEBUG("pattern#0: # of hits at barrel endcap inner =" << pattern.mdtSegments[endcapinner].size());
2560  }
2561  ATH_MSG_DEBUG("### ************************************* ###");
2562  ATH_MSG_DEBUG("Estimated muon pt = " << pattern.pt << " GeV");
2563 
2564  // ---------
2565  // store xAOD
2566 
2567  xAOD::L2StandAloneMuon* muonSA = new xAOD::L2StandAloneMuon();
2568  muonSA->makePrivateStore();
2569 
2570  // add pT
2571  muonSA->setPt(pattern.pt*pattern.charge);
2572  muonSA->setPtEndcapAlpha(pattern.ptEndcapAlpha*pattern.charge);
2573  muonSA->setPtEndcapBeta(pattern.ptEndcapBeta*pattern.charge);
2574  muonSA->setPtEndcapRadius(pattern.ptEndcapRadius*pattern.charge);
2575  muonSA->setPtCSC(pattern.ptCSC*pattern.charge);
2576 
2577  muonSA->setEta(pattern.etaVtx);
2578  muonSA->setPhi(pattern.phiVtx);
2579  muonSA->setDeltaPt(pattern.deltaPt);
2580  muonSA->setDeltaEta(pattern.deltaEtaVtx);
2581  muonSA->setDeltaPhi(pattern.deltaPhiVtx);
2582 
2583  // add s_address
2584  muonSA->setSAddress(pattern.s_address);
2585 
2586  // add positions at MS
2587  muonSA->setEtaMS(pattern.etaMap);
2588  muonSA->setPhiMS(pattern.phiMS);
2589  muonSA->setDirPhiMS(pattern.phiMSDir);
2590  muonSA->setRMS(pattern.superPoints[inner].R);
2591  muonSA->setZMS(pattern.superPoints[inner].Z);
2592  muonSA->setDirZMS(pattern.superPoints[inner].Alin);
2593 
2594  // add pt variables
2595  // Endcap
2596  muonSA->setEndcapAlpha(pattern.endcapAlpha);
2597  muonSA->setEndcapBeta(pattern.endcapBeta);
2598  muonSA->setEndcapRadius(pattern.endcapRadius3P);
2599  // Barrel
2600  muonSA->setBarrelRadius(pattern.barrelRadius);
2601  muonSA->setBarrelSagitta(pattern.barrelSagitta);
2602 
2603  // store eta and phi used as argument to pT LUT
2604  muonSA->setEtaMap(pattern.etaMap);
2605  muonSA->setPhiMap(pattern.phiMap);
2606  muonSA->setEtaBin(pattern.etaBin);
2607  muonSA->setPhiBin(pattern.phiBin);
2608 
2609  // store TGC/RPC readout failure flags
2610  muonSA->setIsTgcFailure((int)pattern.isTgcFailure);
2611  muonSA->setIsRpcFailure((int)pattern.isRpcFailure);
2612 
2613  // add superpoints
2614  muonSA->setSuperPoint(inner, pattern.superPoints[inner].R, pattern.superPoints[inner].Z,
2615  pattern.superPoints[inner].Alin, pattern.superPoints[inner].Blin, pattern.superPoints[inner].Chi2);
2616  muonSA->setSuperPoint(middle, pattern.superPoints[middle].R, pattern.superPoints[middle].Z,
2617  pattern.superPoints[middle].Alin, pattern.superPoints[middle].Blin, pattern.superPoints[middle].Chi2);
2618  muonSA->setSuperPoint(outer, pattern.superPoints[outer].R, pattern.superPoints[outer].Z,
2619  pattern.superPoints[outer].Alin, pattern.superPoints[outer].Blin, pattern.superPoints[outer].Chi2);
2620  if (pattern.s_address==-1){
2621  muonSA->setSuperPoint(ee, pattern.superPoints[ee].R, pattern.superPoints[ee].Z,
2622  pattern.superPoints[ee].Alin, pattern.superPoints[ee].Blin, pattern.superPoints[ee].Chi2);
2623  muonSA->setSuperPoint(barrelinner, pattern.superPoints[barrelinner].R, pattern.superPoints[barrelinner].Z,
2624  pattern.superPoints[barrelinner].Alin, pattern.superPoints[barrelinner].Blin, pattern.superPoints[barrelinner].Chi2);
2625  muonSA->setSuperPoint(csc, pattern.superPoints[csc].R, pattern.superPoints[csc].Z,
2626  pattern.superPoints[csc].Alin, pattern.superPoints[csc].Blin, pattern.superPoints[csc].Chi2);
2627  } else {
2628  muonSA->setSuperPoint(endcapinner, pattern.superPoints[endcapinner].R, pattern.superPoints[endcapinner].Z,
2629  pattern.superPoints[endcapinner].Alin, pattern.superPoints[endcapinner].Blin, pattern.superPoints[endcapinner].Chi2);
2630  }
2631 
2633  // Below are detailed information
2634 
2635  uint32_t muondetmask = 0;
2636 
2638  muonSA->setAlgoId( L2MuonAlgoMap(name()) );
2640  //muonSA->setTeId( inputTE->getId() ); // move to hltExecute()
2642  muonSA->setLvl1Id( eventInfo->extendedLevel1ID() );
2644  muonSA->setLumiBlock( eventID.lumi_block() );
2646  muonSA->setMuonDetMask( muondetmask );
2648  muonSA->setRoiId( currentRoIId );
2650  muonSA->setRoiSystem( roi->sysID() );
2652  muonSA->setRoiSubsystem( roi->subsysID() );
2654  muonSA->setRoiSector( roi->sectorID() );
2656  muonSA->setRoiNumber( roi->getRoINumber() );
2658  muonSA->setRoiThreshold( roi->getThresholdNumber() );
2660  muonSA->setRoiEta( roi->eta() );
2662  muonSA->setRoiPhi( roi->phi() );
2664  muonSA->setRoIWord( roi->roiWord() );
2665 
2667  muonSA->setRpcHitsCapacity( m_esd_rpc_size );
2668  muonSA->setTgcHitsCapacity( m_esd_tgc_size );
2669  muonSA->setMdtHitsCapacity( m_esd_mdt_size );
2670  muonSA->setCscHitsCapacity( m_esd_csc_size );
2671  muonSA->setStgcClustersCapacity( m_esd_stgc_size );
2672  muonSA->setMmClustersCapacity( m_esd_mm_size );
2673 
2674  // MDT hits
2675  std::vector<std::string> mdtId;
2676  for (const TrigL2MuonSA::MdtHitData& mdtHit : mdtHits) {
2677  if ( mdtHit.isOutlier==0 || mdtHit.isOutlier==1 ) {
2678  muonSA->setMdtHit(mdtHit.OnlineId, mdtHit.isOutlier, mdtHit.Chamber,
2679  mdtHit.R, mdtHit.Z, mdtHit.cPhi0, mdtHit.Residual,
2680  mdtHit.DriftTime, mdtHit.DriftSpace, mdtHit.DriftSigma);
2681  mdtId.push_back(mdtHit.Id.getString());
2682  }
2683  }
2684  SG::AuxElement::Accessor< std::vector<std::string> > accessor_mdthitid( "mdtHitId" );
2685  accessor_mdthitid( *muonSA ) = mdtId;
2686 
2687  //CSC hits
2688  std::vector<float> cscResol;
2689  for (const TrigL2MuonSA::CscHitData& cscHit : cscHits) {
2690  if ( 1/*cscHit.MeasuresPhi==0*/ ){
2691  if ( cscHit.isOutlier==0 || cscHit.isOutlier==1 ) {
2692  muonSA->setCscHit(cscHit.isOutlier, cscHit.Chamber, cscHit.StationName,
2693  cscHit.StationEta, cscHit.StationPhi,
2694  cscHit.ChamberLayer, cscHit.WireLayer, cscHit.MeasuresPhi, cscHit.Strip,
2695  cscHit.eta, cscHit.phi, cscHit.r, cscHit.z,
2696  cscHit.charge, cscHit.time, cscHit.Residual);
2697  cscResol.push_back(cscHit.resolution);
2698  ATH_MSG_VERBOSE("CSC Hits stored in xAOD: "
2699  << "OL=" << cscHit.isOutlier << ","
2700  << "Ch=" << cscHit.Chamber << ","
2701  << "StationName=" << cscHit.StationName << ","
2702  << "StationEta=" << cscHit.StationEta << ","
2703  << "StationPhi=" << cscHit.StationPhi << ","
2704  << "ChamberLayer=" << cscHit.ChamberLayer << ","
2705  << "WireLayer=" << cscHit.WireLayer << ","
2706  << "MeasuresPhi=" << cscHit.MeasuresPhi << ","
2707  << "Strip=" << cscHit.Strip << ","
2708  << "eta=" << cscHit.eta << ","
2709  << "phi=" << cscHit.phi << ","
2710  << "r=" << cscHit.r << ","
2711  << "z=" << cscHit.z << ","
2712  << "charge=" << cscHit.charge << ","
2713  << "Rs=" << cscHit.Residual << ","
2714  << "t=" << cscHit.time);
2715  }
2716  }
2717  }
2718  SG::AuxElement::Accessor< std::vector<float> > accessor_cschitresol( "cscHitResolution" );
2719  accessor_cschitresol( *muonSA ) = cscResol;
2720 
2721  // RPC hits
2722  float sumbeta[8]={0};
2723  float nhit_layer[8]={0};
2724  for (const TrigL2MuonSA::RpcHitData& rpcHit : rpcHits) {
2725  muonSA->setRpcHit(rpcHit.layer, rpcHit.measuresPhi,
2726  rpcHit.x, rpcHit.y, rpcHit.z,
2727  rpcHit.time, rpcHit.distToEtaReadout, rpcHit.distToPhiReadout,
2728  rpcHit.stationName);
2729  ATH_MSG_VERBOSE("RPC hits stored in xAOD: "
2730  << "stationName=" << rpcHit.stationName << ","
2731  << "layer=" << rpcHit.layer << ","
2732  << "measuresPhi=" << rpcHit.measuresPhi << ","
2733  << "x=" << rpcHit.x << ","
2734  << "y=" << rpcHit.y << ","
2735  << "y=" << rpcHit.z);
2736 
2737  float dRMS = std::sqrt( std::abs(pattern.etaMap-rpcHit.eta)*std::abs(pattern.etaMap-rpcHit.eta) + std::acos(std::cos(pattern.phiMS-rpcHit.phi))*std::acos(std::cos(pattern.phiMS-rpcHit.phi)) );
2738  if(dRMS>0.05) continue;
2739  float muToF = rpcHit.l/1000/(CLHEP::c_light/1000);
2740  float Tprop = rpcHit.distToPhiReadout/1000*4.8;
2741  float beta = rpcHit.l/1000/(muToF+rpcHit.time-Tprop+3.125/2)/(CLHEP::c_light/1000);
2742  sumbeta[rpcHit.layer]=sumbeta[rpcHit.layer]+beta;
2743  nhit_layer[rpcHit.layer]=nhit_layer[rpcHit.layer]+1;
2744  }
2745 
2746  std::vector<float> Avebeta_layer;
2747  for(int i_layer=0;i_layer<8;i_layer++){
2748  if(nhit_layer[i_layer]!=0)Avebeta_layer.push_back( sumbeta[i_layer]/nhit_layer[i_layer] );
2749  }
2750  if(Avebeta_layer.size()>0) muonSA->setBeta( std::accumulate(Avebeta_layer.begin(),Avebeta_layer.end(),0.0)/Avebeta_layer.size() );
2751  else muonSA->setBeta( 9999 );
2752  Avebeta_layer.clear();
2753 
2754  // TGC hits
2755  for (const TrigL2MuonSA::TgcHitData& tgcHit : tgcHits) {
2756  muonSA->setTgcHit(tgcHit.eta, tgcHit.phi, tgcHit.r, tgcHit.z,
2757  tgcHit.width, tgcHit.sta, tgcHit.isStrip,
2758  tgcHit.bcTag, tgcHit.inRoad);
2759  ATH_MSG_VERBOSE("TGC hits stored in xAOD: "
2760  << "eta=" << tgcHit.eta << ","
2761  << "phi=" << tgcHit.phi << ","
2762  << "r=" << tgcHit.r << ","
2763  << "z=" << tgcHit.z << ","
2764  << "width=" << tgcHit.width << ","
2765  << "stationNum=" << tgcHit.sta << ","
2766  << "isStrip=" << tgcHit.isStrip << ","
2767  << "bcTag=" << tgcHit.bcTag << ","
2768  << "inRoad=" << tgcHit.inRoad);
2769  }
2770 
2771 
2772  // sTGC clusters
2773  for(unsigned int i_hit=0; i_hit<stgcHits.size(); i_hit++) {
2774  if ( stgcHits[i_hit].isOutlier==0 || stgcHits[i_hit].isOutlier==1 ) {
2775 
2776 
2777  muonSA->setStgcCluster(stgcHits[i_hit].layerNumber, stgcHits[i_hit].isOutlier, stgcHits[i_hit].channelType,
2778  stgcHits[i_hit].eta, stgcHits[i_hit].phi, stgcHits[i_hit].r, stgcHits[i_hit].z,
2779  stgcHits[i_hit].ResidualR, stgcHits[i_hit].ResidualPhi,
2780  stgcHits[i_hit].stationEta, stgcHits[i_hit].stationPhi, stgcHits[i_hit].stationName);
2781 
2782  ATH_MSG_VERBOSE("sTGC hits stored in xAOD: "
2783  << "eta=" << stgcHits[i_hit].eta << ","
2784  << "phi=" << stgcHits[i_hit].phi << ","
2785  << "r=" << stgcHits[i_hit].r << ","
2786  << "z=" << stgcHits[i_hit].z << ","
2787  << "z=" << stgcHits[i_hit].ResidualR << ","
2788  << "z=" << stgcHits[i_hit].ResidualPhi);
2789  }
2790  }
2791 
2792  // MM clusters
2793  for(unsigned int i_hit=0; i_hit<mmHits.size(); i_hit++) {
2794  if ( mmHits[i_hit].isOutlier==0 || mmHits[i_hit].isOutlier==1 ) {
2795 
2796 
2797  muonSA->setMmCluster(mmHits[i_hit].layerNumber, mmHits[i_hit].isOutlier,
2798  mmHits[i_hit].eta, mmHits[i_hit].phi, mmHits[i_hit].r, mmHits[i_hit].z,
2799  mmHits[i_hit].ResidualR, mmHits[i_hit].ResidualPhi,
2800  mmHits[i_hit].stationEta, mmHits[i_hit].stationPhi, mmHits[i_hit].stationName);
2801 
2802  ATH_MSG_VERBOSE("mm hits stored in xAOD: "
2803  << "eta=" << tgcHits[i_hit].eta << ","
2804  << "phi=" << tgcHits[i_hit].phi << ","
2805  << "r=" << tgcHits[i_hit].r << ","
2806  << "z=" << tgcHits[i_hit].z << ","
2807  << "width=" << tgcHits[i_hit].width << ","
2808  << "stationNum=" << tgcHits[i_hit].sta << ","
2809  << "isStrip=" << tgcHits[i_hit].isStrip << ","
2810  << "bcTag=" << tgcHits[i_hit].bcTag << ","
2811  << "inRoad=" << tgcHits[i_hit].inRoad);
2812  }
2813  }
2814 
2815 
2816 
2817 
2818  // Muon road
2819  for (int i_station=0; i_station<8; i_station++) {
2820  for (int i_sector=0; i_sector<2; i_sector++) {
2821  muonSA->setRoad(i_station, i_sector, muonRoad.aw[i_station][i_sector], muonRoad.bw[i_station][i_sector]);
2822  muonSA->setRegionZ(i_station, i_sector, mdtRegion.zMin[i_station][i_sector], mdtRegion.zMax[i_station][i_sector]);
2823  muonSA->setRegionR(i_station, i_sector, mdtRegion.rMin[i_station][i_sector], mdtRegion.rMax[i_station][i_sector]);
2824  muonSA->setRegionEta(i_station, i_sector, mdtRegion.etaMin[i_station][i_sector], mdtRegion.etaMax[i_station][i_sector]);
2825  muonSA->setChamberType1(i_station, i_sector, mdtRegion.chamberType[i_station][i_sector][0]);
2826  muonSA->setChamberType2(i_station, i_sector, mdtRegion.chamberType[i_station][i_sector][1]);
2827  }
2828  }
2829 
2830  if ( muonRoad.isEndcap ) {
2831  // TGC fit results
2832  if (tgcFitResult.isSuccess ) {
2833  muonSA->setTgcPt(tgcFitResult.tgcPT);
2834 
2835  muonSA->setTgcInn(tgcFitResult.tgcInn[0], tgcFitResult.tgcInn[1],
2836  tgcFitResult.tgcInn[2], tgcFitResult.tgcInn[3]);
2837  muonSA->setTgcInnF(tgcFitResult.tgcInnRhoStd, tgcFitResult.tgcInnRhoNin,
2838  tgcFitResult.tgcInnPhiStd, tgcFitResult.tgcInnPhiNin);
2839 
2840  muonSA->setTgcMid1(tgcFitResult.tgcMid1[0], tgcFitResult.tgcMid1[1],
2841  tgcFitResult.tgcMid1[2], tgcFitResult.tgcMid1[3]);
2842  muonSA->setTgcMid2(tgcFitResult.tgcMid2[0], tgcFitResult.tgcMid2[1],
2843  tgcFitResult.tgcMid2[2], tgcFitResult.tgcMid2[3]);
2844  muonSA->setTgcMidF(tgcFitResult.tgcMidRhoChi2, tgcFitResult.tgcMidRhoNin,
2845  tgcFitResult.tgcMidPhiChi2, tgcFitResult.tgcMidPhiNin);
2846  }
2847  } else {
2848  // RPC fit results
2849  if (rpcFitResult.isSuccess ) {
2850  // Fill middle fit results for the moment
2851 
2852  muonSA->setRpcFitInn(rpcFitResult.phi_inner, rpcFitResult.slope_inner, rpcFitResult.offset_inner);
2853  muonSA->setRpcFitMid(rpcFitResult.phi_middle, rpcFitResult.slope_middle, rpcFitResult.offset_middle);
2854  muonSA->setRpcFitOut(rpcFitResult.phi_outer, rpcFitResult.slope_outer, rpcFitResult.offset_outer);
2855  }
2856  }
2857 
2858  // Store track positions if set of (R, Z, eta, phi) are all available
2859  if (pattern.s_address==-1) { // endcap
2860 
2861  // Inner
2862  if ( std::abs(pattern.superPoints[inner].R) > ZERO_LIMIT && std::abs(pattern.superPoints[inner].Z) > ZERO_LIMIT ) { // if R and Z exist
2863  if ( tgcFitResult.isSuccess && std::abs(tgcFitResult.tgcInn[3]) > ZERO_LIMIT ) { // if phi exist
2864  float theta = std::atan(pattern.superPoints[inner].R/std::abs(pattern.superPoints[inner].Z));
2865  float eta = (std::tan(theta/2.)!=0.)? -std::log(std::tan(theta/2.))*pattern.superPoints[inner].Z/std::abs(pattern.superPoints[inner].Z): 0.;
2866  muonSA->setTrackPosition( pattern.superPoints[inner].R, pattern.superPoints[inner].Z, eta, tgcFitResult.tgcInn[1] );
2867  }
2868  }
2869 
2870  // Middle
2871  if ( std::abs(pattern.superPoints[middle].R) > ZERO_LIMIT && std::abs(pattern.superPoints[middle].Z) > ZERO_LIMIT ) { // if R and Z exist
2872  float phi = 0;
2873  if (tgcFitResult.isSuccess && ( std::abs(tgcFitResult.tgcMid1[3]) > ZERO_LIMIT || std::abs(tgcFitResult.tgcMid2[3]) > ZERO_LIMIT )) { // if phi exist
2874  double phi1 = tgcFitResult.tgcMid1[1];
2875  double phi2 = tgcFitResult.tgcMid2[1];
2876  if ( tgcFitResult.tgcMid1[3]==0. || tgcFitResult.tgcMid2[3]==0. ) {
2877  if ( std::abs(tgcFitResult.tgcMid1[3]) > ZERO_LIMIT ) phi = phi1;
2878  if ( std::abs(tgcFitResult.tgcMid2[3]) > ZERO_LIMIT ) phi = phi2;
2879  } else if( phi1*phi2 < 0 && std::abs(phi1)>(M_PI/2.) ) {
2880  double tmp1 = (phi1>0)? phi1 - M_PI : phi1 + M_PI;
2881  double tmp2 = (phi2>0)? phi2 - M_PI : phi2 + M_PI;
2882  double tmp = (tmp1+tmp2)/2.;
2883  phi = (tmp>0.)? tmp - M_PI : tmp + M_PI;
2884  } else {
2885  phi = (phi2+phi1)/2.;
2886  }
2887  } else {
2888  phi = roi->phi();
2889  }
2890  float theta = std::atan(pattern.superPoints[middle].R/std::abs(pattern.superPoints[middle].Z));
2891  float eta = (std::tan(theta/2.)!=0.)? -std::log(std::tan(theta/2.))*pattern.superPoints[middle].Z/std::abs(pattern.superPoints[middle].Z): 0.;
2892  muonSA->setTrackPosition( pattern.superPoints[middle].R, pattern.superPoints[middle].Z, eta, phi );
2893  }
2894 
2895  } else { // barrel
2896 
2897  // Middle
2898  if ( std::abs(pattern.superPoints[middle].R) > ZERO_LIMIT && std::abs(pattern.superPoints[middle].Z) > ZERO_LIMIT ) { // if R and Z exist
2899  float phi = 0;
2900  if (rpcFitResult.isSuccess) {
2901  phi = rpcFitResult.phi;
2902  } else {
2903  phi = roi->phi();
2904  }
2905  float theta = std::atan(pattern.superPoints[middle].R/std::abs(pattern.superPoints[middle].Z));
2906  float eta = (std::tan(theta/2.)!=0.)? -std::log(std::tan(theta/2.))*pattern.superPoints[middle].Z/std::abs(pattern.superPoints[middle].Z): 0.;
2907  muonSA->setTrackPosition( pattern.superPoints[middle].R, pattern.superPoints[middle].Z, eta, phi );
2908  }
2909 
2910  // Not stored outer position for the moment as the phi is not available
2911 
2912  }
2913  outputTracks.push_back(muonSA);
2914 
2915  return true;
2916 }

◆ storeMuonSA() [2/2]

bool MuFastSteering::storeMuonSA ( const xAOD::MuonRoI *  roi,
const TrigRoiDescriptor *  roids,
const TrigL2MuonSA::MuonRoad &  muonRoad,
const TrigL2MuonSA::MdtRegion &  mdtRegion,
const TrigL2MuonSA::RpcHits &  rpcHits,
const TrigL2MuonSA::TgcHits &  tgcHits,
const TrigL2MuonSA::RpcFitResult &  rpcFitResult,
const TrigL2MuonSA::TgcFitResult &  tgcFitResult,
const TrigL2MuonSA::MdtHits &  mdtHits,
const TrigL2MuonSA::CscHits &  cscHits,
const TrigL2MuonSA::StgcHits &  stgcHits,
const TrigL2MuonSA::MmHits &  mmHits,
const TrigL2MuonSA::TrackPattern &  pattern,
DataVector< xAOD::L2StandAloneMuon > &  outputTracks,
const EventContext &  ctx 
) const
protected

Set L2 muon algorithm ID

Set input TE ID

Set level-1 ID

Set lumi block

Set muon detector mask

Set RoI ID

Set RoI system ID (or system ID; Barrel=0, Endcap=1, Forward=2)

Set RoI subsystem ID (0=-z,1=+z)

Set RoI sector ID

Set RoI number

Set RoI threshold number

Set RoI eta

Set RoIp phi

Set RoI word

Set size of storages to be reserved

Definition at line 2918 of file MuFastSteering.cxx.

2933 {
2934  const float ZERO_LIMIT = 1.e-5;
2935 
2936  const int currentRoIId = roids->roiId();
2937 
2938  const EventIDBase& eventID = ctx.eventID();
2939  auto eventInfo = SG::makeHandle(m_eventInfoKey, ctx);
2940  if (!eventInfo.isValid()) {
2941  ATH_MSG_ERROR("Failed to retrieve xAOD::EventInfo object");
2942  return false;
2943  }
2944 
2945  int inner = 0;
2946  int middle = 1;
2947  int outer = 2;
2948  int ee = 6;
2949  int csc = 7;
2950  int barrelinner = 0;
2951  int endcapinner = 3;
2952  int bee = 8;
2953  int bme = 9;
2954  // int bmg = 10;
2955 
2956  // define inner, middle, outer
2957  if (pattern.s_address==-1) {
2958  inner = xAOD::L2MuonParameters::Chamber::EndcapInner;
2959  middle = xAOD::L2MuonParameters::Chamber::EndcapMiddle;
2960  outer = xAOD::L2MuonParameters::Chamber::EndcapOuter;
2961  ee = xAOD::L2MuonParameters::Chamber::EndcapExtra;
2962  barrelinner = xAOD::L2MuonParameters::Chamber::BarrelInner;
2963  bee = xAOD::L2MuonParameters::Chamber::BEE;
2964  } else {
2965  inner = xAOD::L2MuonParameters::Chamber::BarrelInner;
2966  middle = xAOD::L2MuonParameters::Chamber::BarrelMiddle;
2967  outer = xAOD::L2MuonParameters::Chamber::BarrelOuter;
2968  bme = xAOD::L2MuonParameters::Chamber::BME;
2969  endcapinner = xAOD::L2MuonParameters::Chamber::EndcapInner;
2970  }
2971 
2972  ATH_MSG_DEBUG("### Hit patterns at the Muon Spectrometer ###");
2973  ATH_MSG_DEBUG("pattern#0: # of hits at inner =" << pattern.mdtSegments[inner].size());
2974  ATH_MSG_DEBUG("pattern#0: # of hits at middle =" << pattern.mdtSegments[middle].size());
2975  ATH_MSG_DEBUG("pattern#0: # of hits at outer =" << pattern.mdtSegments[outer].size());
2976  if (pattern.s_address==-1){
2977  ATH_MSG_DEBUG("pattern#0: # of hits at ee =" << pattern.mdtSegments[ee].size());
2978  ATH_MSG_DEBUG("pattern#0: # of hits at endcap barrel inner =" << pattern.mdtSegments[barrelinner].size());
2979  ATH_MSG_DEBUG("pattern#0: # of hits at BEE =" << pattern.mdtSegments[bee].size());
2980  } else {
2981  ATH_MSG_DEBUG("pattern#0: # of hits at BME =" << pattern.mdtSegments[bme].size());
2982  ATH_MSG_DEBUG("pattern#0: # of hits at barrel endcap inner =" << pattern.mdtSegments[endcapinner].size());
2983  }
2984  ATH_MSG_DEBUG("### ************************************* ###");
2985  ATH_MSG_DEBUG("Estimated muon pt = " << pattern.pt << " GeV");
2986 
2987  // ---------
2988  // store xAOD
2989 
2990  xAOD::L2StandAloneMuon* muonSA = new xAOD::L2StandAloneMuon();
2991  muonSA->makePrivateStore();
2992 
2993  // add pT
2994  muonSA->setPt(pattern.pt*pattern.charge);
2995  muonSA->setPtEndcapAlpha(pattern.ptEndcapAlpha*pattern.charge);
2996  muonSA->setPtEndcapBeta(pattern.ptEndcapBeta*pattern.charge);
2997  muonSA->setPtEndcapRadius(pattern.ptEndcapRadius*pattern.charge);
2998  muonSA->setPtCSC(pattern.ptCSC*pattern.charge);
2999 
3000  muonSA->setEta(pattern.etaVtx);
3001  muonSA->setPhi(pattern.phiVtx);
3002  muonSA->setDeltaPt(pattern.deltaPt);
3003  muonSA->setDeltaEta(pattern.deltaEtaVtx);
3004  muonSA->setDeltaPhi(pattern.deltaPhiVtx);
3005 
3006  // add s_address
3007  muonSA->setSAddress(pattern.s_address);
3008 
3009  // add positions at MS
3010  muonSA->setEtaMS(pattern.etaMap);
3011  muonSA->setPhiMS(pattern.phiMS);
3012  muonSA->setDirPhiMS(pattern.phiMSDir);
3013  muonSA->setRMS(pattern.superPoints[inner].R);
3014  muonSA->setZMS(pattern.superPoints[inner].Z);
3015  muonSA->setDirZMS(pattern.superPoints[inner].Alin);
3016 
3017  // add pt variables
3018  // Endcap
3019  muonSA->setEndcapAlpha(pattern.endcapAlpha);
3020  muonSA->setEndcapBeta(pattern.endcapBeta);
3021  muonSA->setEndcapRadius(pattern.endcapRadius3P);
3022  // Barrel
3023  muonSA->setBarrelRadius(pattern.barrelRadius);
3024  muonSA->setBarrelSagitta(pattern.barrelSagitta);
3025 
3026  // store eta and phi used as argument to pT LUT
3027  muonSA->setEtaMap(pattern.etaMap);
3028  muonSA->setPhiMap(pattern.phiMap);
3029  muonSA->setEtaBin(pattern.etaBin);
3030  muonSA->setPhiBin(pattern.phiBin);
3031 
3032  // store TGC/RPC readout failure flags
3033  muonSA->setIsTgcFailure((int)pattern.isTgcFailure);
3034  muonSA->setIsRpcFailure((int)pattern.isRpcFailure);
3035 
3036  // add superpoints
3037  muonSA->setSuperPoint(inner, pattern.superPoints[inner].R, pattern.superPoints[inner].Z,
3038  pattern.superPoints[inner].Alin, pattern.superPoints[inner].Blin, pattern.superPoints[inner].Chi2);
3039  muonSA->setSuperPoint(middle, pattern.superPoints[middle].R, pattern.superPoints[middle].Z,
3040  pattern.superPoints[middle].Alin, pattern.superPoints[middle].Blin, pattern.superPoints[middle].Chi2);
3041  muonSA->setSuperPoint(outer, pattern.superPoints[outer].R, pattern.superPoints[outer].Z,
3042  pattern.superPoints[outer].Alin, pattern.superPoints[outer].Blin, pattern.superPoints[outer].Chi2);
3043  if (pattern.s_address==-1){
3044  muonSA->setSuperPoint(ee, pattern.superPoints[ee].R, pattern.superPoints[ee].Z,
3045  pattern.superPoints[ee].Alin, pattern.superPoints[ee].Blin, pattern.superPoints[ee].Chi2);
3046  muonSA->setSuperPoint(barrelinner, pattern.superPoints[barrelinner].R, pattern.superPoints[barrelinner].Z,
3047  pattern.superPoints[barrelinner].Alin, pattern.superPoints[barrelinner].Blin, pattern.superPoints[barrelinner].Chi2);
3048  muonSA->setSuperPoint(csc, pattern.superPoints[csc].R, pattern.superPoints[csc].Z,
3049  pattern.superPoints[csc].Alin, pattern.superPoints[csc].Blin, pattern.superPoints[csc].Chi2);
3050  } else {
3051  muonSA->setSuperPoint(endcapinner, pattern.superPoints[endcapinner].R, pattern.superPoints[endcapinner].Z,
3052  pattern.superPoints[endcapinner].Alin, pattern.superPoints[endcapinner].Blin, pattern.superPoints[endcapinner].Chi2);
3053  }
3054 
3056  // Below are detailed information
3057 
3058  uint32_t muondetmask = 0;
3059 
3061  muonSA->setAlgoId( L2MuonAlgoMap(name()) );
3063  //muonSA->setTeId( inputTE->getId() ); // move to hltExecute()
3065  muonSA->setLvl1Id( eventInfo->extendedLevel1ID() );
3067  muonSA->setLumiBlock( eventID.lumi_block() );
3069  muonSA->setMuonDetMask( muondetmask );
3071  muonSA->setRoiId( currentRoIId );
3073  muonSA->setRoiSystem( roi->getSource() );
3075  muonSA->setRoiSubsystem( 1 - roi->getHemisphere() );
3077  muonSA->setRoiSector( roi->getSectorID() );
3079  muonSA->setRoiNumber( roi->getRoI() );
3081  muonSA->setRoiThreshold( roi->getThrNumber() );
3083  muonSA->setRoiEta( roi->eta() );
3085  muonSA->setRoiPhi( roi->phi() );
3087  muonSA->setRoIWord( roi->roiWord() );
3088 
3090  muonSA->setRpcHitsCapacity( m_esd_rpc_size );
3091  muonSA->setTgcHitsCapacity( m_esd_tgc_size );
3092  muonSA->setMdtHitsCapacity( m_esd_mdt_size );
3093  muonSA->setCscHitsCapacity( m_esd_csc_size );
3094  muonSA->setStgcClustersCapacity( m_esd_stgc_size );
3095  muonSA->setMmClustersCapacity( m_esd_mm_size );
3096 
3097  // MDT hits
3098  std::vector<std::string> mdtId;
3099  for (const TrigL2MuonSA::MdtHitData& mdtHit : mdtHits) {
3100  if ( mdtHit.isOutlier==0 || mdtHit.isOutlier==1 ) {
3101  muonSA->setMdtHit(mdtHit.OnlineId, mdtHit.isOutlier, mdtHit.Chamber,
3102  mdtHit.R, mdtHit.Z, mdtHit.cPhi0, mdtHit.Residual,
3103  mdtHit.DriftTime, mdtHit.DriftSpace, mdtHit.DriftSigma);
3104  mdtId.push_back(mdtHit.Id.getString());
3105  }
3106  }
3107  SG::AuxElement::Accessor< std::vector<std::string> > accessor_mdthitid( "mdtHitId" );
3108  accessor_mdthitid( *muonSA ) = mdtId;
3109 
3110  //CSC hits
3111  std::vector<float> cscResol;
3112  for (const TrigL2MuonSA::CscHitData& cscHit : cscHits) {
3113  if ( 1/*cscHit.MeasuresPhi==0*/ ){
3114  if ( cscHit.isOutlier==0 || cscHit.isOutlier==1 ) {
3115  muonSA->setCscHit(cscHit.isOutlier, cscHit.Chamber, cscHit.StationName,
3116  cscHit.StationEta, cscHit.StationPhi,
3117  cscHit.ChamberLayer, cscHit.WireLayer, cscHit.MeasuresPhi, cscHit.Strip,
3118  cscHit.eta, cscHit.phi, cscHit.r, cscHit.z,
3119  cscHit.charge, cscHit.time, cscHit.Residual);
3120  cscResol.push_back(cscHit.resolution);
3121  ATH_MSG_VERBOSE("CSC Hits stored in xAOD: "
3122  << "OL=" << cscHit.isOutlier << ","
3123  << "Ch=" << cscHit.Chamber << ","
3124  << "StationName=" << cscHit.StationName << ","
3125  << "StationEta=" << cscHit.StationEta << ","
3126  << "StationPhi=" << cscHit.StationPhi << ","
3127  << "ChamberLayer=" << cscHit.ChamberLayer << ","
3128  << "WireLayer=" << cscHit.WireLayer << ","
3129  << "MeasuresPhi=" << cscHit.MeasuresPhi << ","
3130  << "Strip=" << cscHit.Strip << ","
3131  << "eta=" << cscHit.eta << ","
3132  << "phi=" << cscHit.phi << ","
3133  << "r=" << cscHit.r << ","
3134  << "z=" << cscHit.z << ","
3135  << "charge=" << cscHit.charge << ","
3136  << "Rs=" << cscHit.Residual << ","
3137  << "t=" << cscHit.time);
3138  }
3139  }
3140  }
3141  SG::AuxElement::Accessor< std::vector<float> > accessor_cschitresol( "cscHitResolution" );
3142  accessor_cschitresol( *muonSA ) = cscResol;
3143 
3144  // RPC hits
3145  float sumbeta[8]={0};
3146  float nhit_layer[8]={0};
3147  for (const TrigL2MuonSA::RpcHitData& rpcHit : rpcHits) {
3148  muonSA->setRpcHit(rpcHit.layer, rpcHit.measuresPhi,
3149  rpcHit.x, rpcHit.y, rpcHit.z,
3150  rpcHit.time, rpcHit.distToEtaReadout, rpcHit.distToPhiReadout,
3151  rpcHit.stationName);
3152  ATH_MSG_VERBOSE("RPC hits stored in xAOD: "
3153  << "stationName=" << rpcHit.stationName << ","
3154  << "layer=" << rpcHit.layer << ","
3155  << "measuresPhi=" << rpcHit.measuresPhi << ","
3156  << "x=" << rpcHit.x << ","
3157  << "y=" << rpcHit.y << ","
3158  << "y=" << rpcHit.z);
3159 
3160  float dRMS = std::sqrt( std::abs(pattern.etaMap-rpcHit.eta)*std::abs(pattern.etaMap-rpcHit.eta) + std::acos(std::cos(pattern.phiMS-rpcHit.phi))*std::acos(std::cos(pattern.phiMS-rpcHit.phi)) );
3161  if(dRMS>0.05) continue;
3162  float muToF = rpcHit.l/1000/(CLHEP::c_light/1000);
3163  float Tprop = rpcHit.distToPhiReadout/1000*4.8;
3164  float beta = rpcHit.l/1000/(muToF+rpcHit.time-Tprop+3.125/2)/(CLHEP::c_light/1000);
3165  sumbeta[rpcHit.layer]=sumbeta[rpcHit.layer]+beta;
3166  nhit_layer[rpcHit.layer]=nhit_layer[rpcHit.layer]+1;
3167  }
3168 
3169  std::vector<float> Avebeta_layer;
3170  for(int i_layer=0;i_layer<8;i_layer++){
3171  if(nhit_layer[i_layer]!=0)Avebeta_layer.push_back( sumbeta[i_layer]/nhit_layer[i_layer] );
3172  }
3173  if(Avebeta_layer.size()>0) muonSA->setBeta( std::accumulate(Avebeta_layer.begin(),Avebeta_layer.end(),0.0)/Avebeta_layer.size() );
3174  else muonSA->setBeta( 9999 );
3175  Avebeta_layer.clear();
3176 
3177  // TGC hits
3178  for (const TrigL2MuonSA::TgcHitData& tgcHit : tgcHits) {
3179  muonSA->setTgcHit(tgcHit.eta, tgcHit.phi, tgcHit.r, tgcHit.z,
3180  tgcHit.width, tgcHit.sta, tgcHit.isStrip,
3181  tgcHit.bcTag, tgcHit.inRoad);
3182  ATH_MSG_VERBOSE("TGC hits stored in xAOD: "
3183  << "eta=" << tgcHit.eta << ","
3184  << "phi=" << tgcHit.phi << ","
3185  << "r=" << tgcHit.r << ","
3186  << "z=" << tgcHit.z << ","
3187  << "width=" << tgcHit.width << ","
3188  << "stationNum=" << tgcHit.sta << ","
3189  << "isStrip=" << tgcHit.isStrip << ","
3190  << "bcTag=" << tgcHit.bcTag << ","
3191  << "inRoad=" << tgcHit.inRoad);
3192  }
3193 
3194 
3195  // sTGC clusters
3196  for(unsigned int i_hit=0; i_hit<stgcHits.size(); i_hit++) {
3197  if ( stgcHits[i_hit].isOutlier==0 || stgcHits[i_hit].isOutlier==1 ) {
3198 
3199 
3200  muonSA->setStgcCluster(stgcHits[i_hit].layerNumber, stgcHits[i_hit].isOutlier, stgcHits[i_hit].channelType,
3201  stgcHits[i_hit].eta, stgcHits[i_hit].phi, stgcHits[i_hit].r, stgcHits[i_hit].z,
3202  stgcHits[i_hit].ResidualR, stgcHits[i_hit].ResidualPhi,
3203  stgcHits[i_hit].stationEta, stgcHits[i_hit].stationPhi, stgcHits[i_hit].stationName);
3204 
3205  ATH_MSG_VERBOSE("sTGC hits stored in xAOD: "
3206  << "eta=" << stgcHits[i_hit].eta << ","
3207  << "phi=" << stgcHits[i_hit].phi << ","
3208  << "r=" << stgcHits[i_hit].r << ","
3209  << "z=" << stgcHits[i_hit].z << ","
3210  << "z=" << stgcHits[i_hit].ResidualR << ","
3211  << "z=" << stgcHits[i_hit].ResidualPhi);
3212  }
3213  }
3214 
3215  // MM clusters
3216  for(unsigned int i_hit=0; i_hit<mmHits.size(); i_hit++) {
3217  if ( mmHits[i_hit].isOutlier==0 || mmHits[i_hit].isOutlier==1 ) {
3218 
3219 
3220  muonSA->setMmCluster(mmHits[i_hit].layerNumber, mmHits[i_hit].isOutlier,
3221  mmHits[i_hit].eta, mmHits[i_hit].phi, mmHits[i_hit].r, mmHits[i_hit].z,
3222  mmHits[i_hit].ResidualR, mmHits[i_hit].ResidualPhi,
3223  mmHits[i_hit].stationEta, mmHits[i_hit].stationPhi, mmHits[i_hit].stationName);
3224 
3225  ATH_MSG_VERBOSE("mm hits stored in xAOD: "
3226  << "eta=" << tgcHits[i_hit].eta << ","
3227  << "phi=" << tgcHits[i_hit].phi << ","
3228  << "r=" << tgcHits[i_hit].r << ","
3229  << "z=" << tgcHits[i_hit].z << ","
3230  << "width=" << tgcHits[i_hit].width << ","
3231  << "stationNum=" << tgcHits[i_hit].sta << ","
3232  << "isStrip=" << tgcHits[i_hit].isStrip << ","
3233  << "bcTag=" << tgcHits[i_hit].bcTag << ","
3234  << "inRoad=" << tgcHits[i_hit].inRoad);
3235  }
3236  }
3237 
3238 
3239 
3240 
3241  // Muon road
3242  for (int i_station=0; i_station<8; i_station++) {
3243  for (int i_sector=0; i_sector<2; i_sector++) {
3244  muonSA->setRoad(i_station, i_sector, muonRoad.aw[i_station][i_sector], muonRoad.bw[i_station][i_sector]);
3245  muonSA->setRegionZ(i_station, i_sector, mdtRegion.zMin[i_station][i_sector], mdtRegion.zMax[i_station][i_sector]);
3246  muonSA->setRegionR(i_station, i_sector, mdtRegion.rMin[i_station][i_sector], mdtRegion.rMax[i_station][i_sector]);
3247  muonSA->setRegionEta(i_station, i_sector, mdtRegion.etaMin[i_station][i_sector], mdtRegion.etaMax[i_station][i_sector]);
3248  muonSA->setChamberType1(i_station, i_sector, mdtRegion.chamberType[i_station][i_sector][0]);
3249  muonSA->setChamberType2(i_station, i_sector, mdtRegion.chamberType[i_station][i_sector][1]);
3250  }
3251  }
3252 
3253  if ( muonRoad.isEndcap ) {
3254  // TGC fit results
3255  if (tgcFitResult.isSuccess ) {
3256  muonSA->setTgcPt(tgcFitResult.tgcPT);
3257 
3258  muonSA->setTgcInn(tgcFitResult.tgcInn[0], tgcFitResult.tgcInn[1],
3259  tgcFitResult.tgcInn[2], tgcFitResult.tgcInn[3]);
3260  muonSA->setTgcInnF(tgcFitResult.tgcInnRhoStd, tgcFitResult.tgcInnRhoNin,
3261  tgcFitResult.tgcInnPhiStd, tgcFitResult.tgcInnPhiNin);
3262 
3263  muonSA->setTgcMid1(tgcFitResult.tgcMid1[0], tgcFitResult.tgcMid1[1],
3264  tgcFitResult.tgcMid1[2], tgcFitResult.tgcMid1[3]);
3265  muonSA->setTgcMid2(tgcFitResult.tgcMid2[0], tgcFitResult.tgcMid2[1],
3266  tgcFitResult.tgcMid2[2], tgcFitResult.tgcMid2[3]);
3267  muonSA->setTgcMidF(tgcFitResult.tgcMidRhoChi2, tgcFitResult.tgcMidRhoNin,
3268  tgcFitResult.tgcMidPhiChi2, tgcFitResult.tgcMidPhiNin);
3269  }
3270  } else {
3271  // RPC fit results
3272  if (rpcFitResult.isSuccess ) {
3273  // Fill middle fit results for the moment
3274 
3275  muonSA->setRpcFitInn(rpcFitResult.phi_inner, rpcFitResult.slope_inner, rpcFitResult.offset_inner);
3276  muonSA->setRpcFitMid(rpcFitResult.phi_middle, rpcFitResult.slope_middle, rpcFitResult.offset_middle);
3277  muonSA->setRpcFitOut(rpcFitResult.phi_outer, rpcFitResult.slope_outer, rpcFitResult.offset_outer);
3278  }
3279  }
3280 
3281  // Store track positions if set of (R, Z, eta, phi) are all available
3282  if (pattern.s_address==-1) { // endcap
3283 
3284  // Inner
3285  if ( std::abs(pattern.superPoints[inner].R) > ZERO_LIMIT && std::abs(pattern.superPoints[inner].Z) > ZERO_LIMIT ) { // if R and Z exist
3286  if ( tgcFitResult.isSuccess && std::abs(tgcFitResult.tgcInn[3]) > ZERO_LIMIT ) { // if phi exist
3287  float theta = std::atan(pattern.superPoints[inner].R/std::abs(pattern.superPoints[inner].Z));
3288  float eta = (std::tan(theta/2.)!=0.)? -std::log(std::tan(theta/2.))*pattern.superPoints[inner].Z/std::abs(pattern.superPoints[inner].Z): 0.;
3289  muonSA->setTrackPosition( pattern.superPoints[inner].R, pattern.superPoints[inner].Z, eta, tgcFitResult.tgcInn[1] );
3290  }
3291  }
3292 
3293  // Middle
3294  if ( std::abs(pattern.superPoints[middle].R) > ZERO_LIMIT && std::abs(pattern.superPoints[middle].Z) > ZERO_LIMIT ) { // if R and Z exist
3295  float phi = 0;
3296  if (tgcFitResult.isSuccess && ( std::abs(tgcFitResult.tgcMid1[3]) > ZERO_LIMIT || std::abs(tgcFitResult.tgcMid2[3]) > ZERO_LIMIT )) { // if phi exist
3297  double phi1 = tgcFitResult.tgcMid1[1];
3298  double phi2 = tgcFitResult.tgcMid2[1];
3299  if ( tgcFitResult.tgcMid1[3]==0. || tgcFitResult.tgcMid2[3]==0. ) {
3300  if ( std::abs(tgcFitResult.tgcMid1[3]) > ZERO_LIMIT ) phi = phi1;
3301  if ( std::abs(tgcFitResult.tgcMid2[3]) > ZERO_LIMIT ) phi = phi2;
3302  } else if( phi1*phi2 < 0 && std::abs(phi1)>(M_PI/2.) ) {
3303  double tmp1 = (phi1>0)? phi1 - M_PI : phi1 + M_PI;
3304  double tmp2 = (phi2>0)? phi2 - M_PI : phi2 + M_PI;
3305  double tmp = (tmp1+tmp2)/2.;
3306  phi = (tmp>0.)? tmp - M_PI : tmp + M_PI;
3307  } else {
3308  phi = (phi2+phi1)/2.;
3309  }
3310  } else {
3311  phi = roi->phi();
3312  }
3313  float theta = std::atan(pattern.superPoints[middle].R/std::abs(pattern.superPoints[middle].Z));
3314  float eta = (std::tan(theta/2.)!=0.)? -std::log(std::tan(theta/2.))*pattern.superPoints[middle].Z/std::abs(pattern.superPoints[middle].Z): 0.;
3315  muonSA->setTrackPosition( pattern.superPoints[middle].R, pattern.superPoints[middle].Z, eta, phi );
3316  }
3317 
3318  } else { // barrel
3319 
3320  // Middle
3321  if ( std::abs(pattern.superPoints[middle].R) > ZERO_LIMIT && std::abs(pattern.superPoints[middle].Z) > ZERO_LIMIT ) { // if R and Z exist
3322  float phi = 0;
3323  if (rpcFitResult.isSuccess) {
3324  phi = rpcFitResult.phi;
3325  } else {
3326  phi = roi->phi();
3327  }
3328  float theta = std::atan(pattern.superPoints[middle].R/std::abs(pattern.superPoints[middle].Z));
3329  float eta = (std::tan(theta/2.)!=0.)? -std::log(std::tan(theta/2.))*pattern.superPoints[middle].Z/std::abs(pattern.superPoints[middle].Z): 0.;
3330  muonSA->setTrackPosition( pattern.superPoints[middle].R, pattern.superPoints[middle].Z, eta, phi );
3331  }
3332 
3333  // Not stored outer position for the moment as the phi is not available
3334 
3335  }
3336  outputTracks.push_back(muonSA);
3337 
3338  return true;
3339 }

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

77 {
78  return BaseAlg::sysExecute (ctx);
79 }

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

107  {
108  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
109 
110  if (sc.isFailure()) {
111  return sc;
112  }
113 
114  ServiceHandle<ICondSvc> cs("CondSvc",name());
115  for (auto h : outputHandles()) {
116  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
117  // do this inside the loop so we don't create the CondSvc until needed
118  if ( cs.retrieve().isFailure() ) {
119  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
120  return StatusCode::SUCCESS;
121  }
122  if (cs->regHandle(this,*h).isFailure()) {
123  sc = StatusCode::FAILURE;
124  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
125  << " with CondSvc");
126  }
127  }
128  }
129  return sc;
130 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

◆ updateMonitor() [1/2]

StatusCode MuFastSteering::updateMonitor ( const LVL1::RecMuonRoI *  roi,
const TrigL2MuonSA::MdtHits &  mdtHits,
std::vector< TrigL2MuonSA::TrackPattern > &  trackPatterns 
) const
protected

Update monitoring variables.

Definition at line 3646 of file MuFastSteering.cxx.

3649 {
3650  // initialize monitored variable
3651  auto inner_mdt_hits = Monitored::Scalar("InnMdtHits", -1);
3652  auto middle_mdt_hits = Monitored::Scalar("MidMdtHits", -1);
3653  auto outer_mdt_hits = Monitored::Scalar("OutMdtHits", -1);
3654  auto invalid_rpc_roi_number = Monitored::Scalar("InvalidRpcRoINumber", -1);
3655 
3656  auto efficiency = Monitored::Scalar("Efficiency", 0);
3657  auto sag_inverse = Monitored::Scalar("SagInv", 9999.);
3658  auto address = Monitored::Scalar("Address", 9999.);
3659  auto absolute_pt = Monitored::Scalar("AbsPt", 9999.);
3660  auto sagitta = Monitored::Scalar("Sagitta", 9999.);
3661  auto track_pt = Monitored::Scalar("TrackPt", 9999.);
3662 
3663  std::vector<float> t_eta, t_phi;
3664  std::vector<float> f_eta, f_phi;
3665  std::vector<float> r_inner, r_middle, r_outer;
3666  std::vector<float> f_residuals;
3667 
3668  t_eta.clear();
3669  t_phi.clear();
3670  f_eta.clear();
3671  f_phi.clear();
3672  r_inner.clear();
3673  r_middle.clear();
3674  r_outer.clear();
3675  f_residuals.clear();
3676 
3677  auto track_eta = Monitored::Collection("TrackEta", t_eta);
3678  auto track_phi = Monitored::Collection("TrackPhi", t_phi);
3679  auto failed_eta = Monitored::Collection("FailedRoIEta", f_eta);
3680  auto failed_phi = Monitored::Collection("FailedRoIPhi", f_phi);
3681  auto res_inner = Monitored::Collection("ResInner", r_inner);
3682  auto res_middle = Monitored::Collection("ResMiddle", r_middle);
3683  auto res_outer = Monitored::Collection("ResOuter", r_outer);
3684  auto fit_residuals = Monitored::Collection("FitResiduals", f_residuals);
3685 
3686  auto monitorIt = Monitored::Group(m_monTool, inner_mdt_hits, middle_mdt_hits, outer_mdt_hits,
3687  invalid_rpc_roi_number,
3688  efficiency, sag_inverse, address, absolute_pt, sagitta, track_pt,
3689  track_eta, track_phi, failed_eta, failed_phi,
3690  res_inner, res_middle, res_outer, fit_residuals );
3691 
3692  const float ZERO_LIMIT = 1e-5;
3693 
3694  if( trackPatterns.size() > 0 ) {
3695 
3696  efficiency = 1;
3697 
3698  const TrigL2MuonSA::TrackPattern& pattern = trackPatterns[0];
3699  float norm = 10.;
3700 
3701  float count_inner = 0;
3702  float count_middle = 0;
3703  float count_outer = 0;
3704 
3705  for (const TrigL2MuonSA::MdtHitData& mdtHit : mdtHits) {
3706 
3707  if (std::abs(mdtHit.DriftSpace) < ZERO_LIMIT) continue;
3708 
3709  char st = mdtHit.cType[1];
3710 
3711  if (st=='I') {
3712  count_inner++;
3713  r_inner.push_back(mdtHit.Residual/norm);
3714  if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
3715  }
3716 
3717  if (st=='M') {
3718  count_middle++;
3719  r_middle.push_back(mdtHit.Residual/norm);
3720  if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
3721  }
3722 
3723  if (st=='O') {
3724  count_outer++;
3725  r_outer.push_back(mdtHit.Residual/norm);
3726  if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
3727  }
3728  }
3729 
3730  inner_mdt_hits = count_inner;
3731  middle_mdt_hits = count_middle;
3732  outer_mdt_hits = count_outer;
3733 
3734  track_pt = (std::abs(pattern.pt ) > ZERO_LIMIT)? pattern.charge*pattern.pt: 9999.;
3735  absolute_pt = std::abs(track_pt);
3736 
3737  if ( std::abs(pattern.etaMap) > ZERO_LIMIT || std::abs(pattern.phiMS) > ZERO_LIMIT ) {
3738  t_eta.push_back(pattern.etaMap);
3739  t_phi.push_back(pattern.phiMS);
3740  }
3741  if ( std::abs(pattern.pt ) < ZERO_LIMIT){
3742  f_eta.push_back(roi->eta());
3743  f_phi.push_back(roi->phi());
3744  }
3745 
3746  sagitta = (std::abs(pattern.barrelSagitta) > ZERO_LIMIT)? pattern.barrelSagitta: 9999.;
3747  sag_inverse = (std::abs(pattern.barrelSagitta) > ZERO_LIMIT)? 1./pattern.barrelSagitta: 9999.;
3748  address = pattern.s_address;
3749  }
3750 
3751  return StatusCode::SUCCESS;
3752 }

◆ updateMonitor() [2/2]

StatusCode MuFastSteering::updateMonitor ( const xAOD::MuonRoI *  roi,
const TrigL2MuonSA::MdtHits &  mdtHits,
std::vector< TrigL2MuonSA::TrackPattern > &  trackPatterns 
) const
protected

Definition at line 3757 of file MuFastSteering.cxx.

3760 {
3761  // initialize monitored variable
3762  auto inner_mdt_hits = Monitored::Scalar("InnMdtHits", -1);
3763  auto middle_mdt_hits = Monitored::Scalar("MidMdtHits", -1);
3764  auto outer_mdt_hits = Monitored::Scalar("OutMdtHits", -1);
3765  auto invalid_rpc_roi_number = Monitored::Scalar("InvalidRpcRoINumber", -1);
3766 
3767  auto efficiency = Monitored::Scalar("Efficiency", 0);
3768  auto sag_inverse = Monitored::Scalar("SagInv", 9999.);
3769  auto address = Monitored::Scalar("Address", 9999.);
3770  auto absolute_pt = Monitored::Scalar("AbsPt", 9999.);
3771  auto sagitta = Monitored::Scalar("Sagitta", 9999.);
3772  auto track_pt = Monitored::Scalar("TrackPt", 9999.);
3773 
3774  std::vector<float> t_eta, t_phi;
3775  std::vector<float> f_eta, f_phi;
3776  std::vector<float> r_inner, r_middle, r_outer;
3777  std::vector<float> f_residuals;
3778 
3779  t_eta.clear();
3780  t_phi.clear();
3781  f_eta.clear();
3782  f_phi.clear();
3783  r_inner.clear();
3784  r_middle.clear();
3785  r_outer.clear();
3786  f_residuals.clear();
3787 
3788  auto track_eta = Monitored::Collection("TrackEta", t_eta);
3789  auto track_phi = Monitored::Collection("TrackPhi", t_phi);
3790  auto failed_eta = Monitored::Collection("FailedRoIEta", f_eta);
3791  auto failed_phi = Monitored::Collection("FailedRoIPhi", f_phi);
3792  auto res_inner = Monitored::Collection("ResInner", r_inner);
3793  auto res_middle = Monitored::Collection("ResMiddle", r_middle);
3794  auto res_outer = Monitored::Collection("ResOuter", r_outer);
3795  auto fit_residuals = Monitored::Collection("FitResiduals", f_residuals);
3796 
3797  auto monitorIt = Monitored::Group(m_monTool, inner_mdt_hits, middle_mdt_hits, outer_mdt_hits,
3798  invalid_rpc_roi_number,
3799  efficiency, sag_inverse, address, absolute_pt, sagitta, track_pt,
3800  track_eta, track_phi, failed_eta, failed_phi,
3801  res_inner, res_middle, res_outer, fit_residuals );
3802 
3803  const float ZERO_LIMIT = 1e-5;
3804 
3805  if( trackPatterns.size() > 0 ) {
3806 
3807  efficiency = 1;
3808 
3809  const TrigL2MuonSA::TrackPattern& pattern = trackPatterns[0];
3810  float norm = 10.;
3811 
3812  float count_inner = 0;
3813  float count_middle = 0;
3814  float count_outer = 0;
3815 
3816  for (const TrigL2MuonSA::MdtHitData& mdtHit : mdtHits) {
3817 
3818  if (std::abs(mdtHit.DriftSpace) < ZERO_LIMIT) continue;
3819 
3820  char st = mdtHit.cType[1];
3821 
3822  if (st=='I') {
3823  count_inner++;
3824  r_inner.push_back(mdtHit.Residual/norm);
3825  if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
3826  }
3827 
3828  if (st=='M') {
3829  count_middle++;
3830  r_middle.push_back(mdtHit.Residual/norm);
3831  if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
3832  }
3833 
3834  if (st=='O') {
3835  count_outer++;
3836  r_outer.push_back(mdtHit.Residual/norm);
3837  if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
3838  }
3839  }
3840 
3841  inner_mdt_hits = count_inner;
3842  middle_mdt_hits = count_middle;
3843  outer_mdt_hits = count_outer;
3844 
3845  track_pt = (std::abs(pattern.pt ) > ZERO_LIMIT)? pattern.charge*pattern.pt: 9999.;
3846  absolute_pt = std::abs(track_pt);
3847 
3848  if ( std::abs(pattern.etaMap) > ZERO_LIMIT || std::abs(pattern.phiMS) > ZERO_LIMIT ) {
3849  t_eta.push_back(pattern.etaMap);
3850  t_phi.push_back(pattern.phiMS);
3851  }
3852  if ( std::abs(pattern.pt ) < ZERO_LIMIT){
3853  f_eta.push_back(roi->eta());
3854  f_phi.push_back(roi->phi());
3855  }
3856 
3857  sagitta = (std::abs(pattern.barrelSagitta) > ZERO_LIMIT)? pattern.barrelSagitta: 9999.;
3858  sag_inverse = (std::abs(pattern.barrelSagitta) > ZERO_LIMIT)? 1./pattern.barrelSagitta: 9999.;
3859  address = pattern.s_address;
3860  }
3861 
3862  return StatusCode::SUCCESS;
3863 }

◆ updateOutputObjects() [1/2]

bool MuFastSteering::updateOutputObjects ( const LVL1::RecMuonRoI *  roi,
const TrigRoiDescriptor *  roids,
const TrigL2MuonSA::MuonRoad &  muonRoad,
const TrigL2MuonSA::MdtRegion &  mdtRegion,
const TrigL2MuonSA::RpcHits &  rpcHits,
const TrigL2MuonSA::TgcHits &  tgcHits,
const TrigL2MuonSA::RpcFitResult &  rpcFitResult,
const TrigL2MuonSA::TgcFitResult &  tgcFitResult,
const TrigL2MuonSA::MdtHits &  mdtHits,
const TrigL2MuonSA::CscHits &  cscHits,
const TrigL2MuonSA::StgcHits &  stgcHits,
const TrigL2MuonSA::MmHits &  mmHits,
const std::vector< TrigL2MuonSA::TrackPattern > &  trackPatterns,
DataVector< xAOD::L2StandAloneMuon > &  outputTracks,
TrigRoiDescriptorCollection &  outputID,
TrigRoiDescriptorCollection &  outputMS,
const EventContext &  ctx 
) const
protected

Called at the end of the algorithm processing to set the steering navigation properly.

Definition at line 2415 of file MuFastSteering.cxx.

2432 {
2433 
2434  if( trackPatterns.size() > 0 ) {
2435 
2436  const TrigL2MuonSA::TrackPattern& pattern = trackPatterns.back();
2437 
2438  // Update output trigger element
2439  storeMuonSA(roi, roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2440  rpcFitResult, tgcFitResult, mdtHits, cscHits,
2441  stgcHits, mmHits,
2442  pattern, outputTracks, ctx);
2443  storeMSRoiDescriptor(roids, pattern, outputTracks, outputMS);
2444  storeIDRoiDescriptor(roids, pattern, outputTracks, outputID);
2445 
2446  } else {
2447  ATH_MSG_DEBUG("Not update output objects because trackPatterns has no object");
2448  }
2449 
2450  return true;
2451 }

◆ updateOutputObjects() [2/2]

bool MuFastSteering::updateOutputObjects ( const xAOD::MuonRoI *  roi,
const TrigRoiDescriptor *  roids,
const TrigL2MuonSA::MuonRoad &  muonRoad,
const TrigL2MuonSA::MdtRegion &  mdtRegion,
const TrigL2MuonSA::RpcHits &  rpcHits,
const TrigL2MuonSA::TgcHits &  tgcHits,
const TrigL2MuonSA::RpcFitResult &  rpcFitResult,
const TrigL2MuonSA::TgcFitResult &  tgcFitResult,
const TrigL2MuonSA::MdtHits &  mdtHits,
const TrigL2MuonSA::CscHits &  cscHits,
const TrigL2MuonSA::StgcHits &  stgcHits,
const TrigL2MuonSA::MmHits &  mmHits,
const std::vector< TrigL2MuonSA::TrackPattern > &  trackPatterns,
DataVector< xAOD::L2StandAloneMuon > &  outputTracks,
TrigRoiDescriptorCollection &  outputID,
TrigRoiDescriptorCollection &  outputMS,
const EventContext &  ctx 
) const
protected

Definition at line 2456 of file MuFastSteering.cxx.

2473 {
2474 
2475  if( trackPatterns.size() > 0 ) {
2476 
2477  const TrigL2MuonSA::TrackPattern& pattern = trackPatterns.back();
2478 
2479  // Update output trigger element
2480  storeMuonSA(roi, roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2481  rpcFitResult, tgcFitResult, mdtHits, cscHits,
2482  stgcHits, mmHits,
2483  pattern, outputTracks, ctx);
2484  storeMSRoiDescriptor(roids, pattern, outputTracks, outputMS);
2485  storeIDRoiDescriptor(roids, pattern, outputTracks, outputID);
2486 
2487  } else {
2488  ATH_MSG_DEBUG("Not update output objects because trackPatterns has no object");
2489  }
2490 
2491  return true;
2492 }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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_allowOksConfig

Gaudi::Property< bool > MuFastSteering::m_allowOksConfig { this, "AllowOksConfig", true}
private

Definition at line 299 of file MuFastSteering.h.

◆ m_backExtrapolatorTool

ToolHandle<ITrigMuonBackExtrapolator> MuFastSteering::m_backExtrapolatorTool
protected
Initial value:
{
this, "BackExtrapolator", "TrigMuonBackExtrapolator", "public tool for back extrapolating the muon tracks to the IV" }

Handle to MuonBackExtrapolator tool.

Definition at line 236 of file MuFastSteering.h.

◆ m_calBufferName

Gaudi::Property< std::string > MuFastSteering::m_calBufferName { this, "MuonCalBufferName", "/tmp/testOutput"}
private

Definition at line 300 of file MuFastSteering.h.

◆ m_calBufferSize

Gaudi::Property< int > MuFastSteering::m_calBufferSize { this, "MuonCalBufferSize", 1024*1024}
private

Definition at line 301 of file MuFastSteering.h.

◆ m_calDataScouting

Gaudi::Property< bool > MuFastSteering::m_calDataScouting { this, "MuonCalDataScouting", false}
private

Definition at line 272 of file MuFastSteering.h.

◆ m_calStreamer

ToolHandle<TrigL2MuonSA::MuCalStreamerTool> MuFastSteering::m_calStreamer
protected
Initial value:
{
this, "CalibrationStreamer", "TrigL2MuonSA::MuCalStreamerTool", "calibration stream" }

Definition at line 240 of file MuFastSteering.h.

◆ m_cscsegmaker

ToolHandle<TrigL2MuonSA::CscSegmentMaker> MuFastSteering::m_cscsegmaker
protected
Initial value:
{
this, "CscSegmentMaker", "TrigL2MuonSA::CscSegmentMaker", "" }

Definition at line 247 of file MuFastSteering.h.

◆ m_dataPreparator

ToolHandle<TrigL2MuonSA::MuFastDataPreparator> MuFastSteering::m_dataPreparator
protected
Initial value:
{
this, "DataPreparator", "TrigL2MuonSA::MuFastDataPreparator", "data preparator" }

Definition at line 222 of file MuFastSteering.h.

◆ m_dEtasurrRoI

Gaudi::Property< float > MuFastSteering::m_dEtasurrRoI { this, "dEtasurrRoI", 99, "eta range to find surrounding L1 RoIs" }
private

Definition at line 295 of file MuFastSteering.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doCalStream

Gaudi::Property< bool > MuFastSteering::m_doCalStream { this, "DoCalibrationStream", true}
private

Definition at line 271 of file MuFastSteering.h.

◆ m_doEndcapForl2mt

Gaudi::Property< bool > MuFastSteering::m_doEndcapForl2mt { this, "doEndcapForl2mt", false, "" }
private

Definition at line 291 of file MuFastSteering.h.

◆ m_dPhisurrRoI

Gaudi::Property< float > MuFastSteering::m_dPhisurrRoI { this, "dPhisurrRoI", 99, "phi range to find surrounding L1 RoIs" }
private

Definition at line 294 of file MuFastSteering.h.

◆ m_esd_csc_size

Gaudi::Property< int > MuFastSteering::m_esd_csc_size { this, "ESD_CSC_size", 100 }
private

Definition at line 280 of file MuFastSteering.h.

◆ m_esd_mdt_size

Gaudi::Property< int > MuFastSteering::m_esd_mdt_size { this, "ESD_MDT_size", 100 }
private

Definition at line 279 of file MuFastSteering.h.

◆ m_esd_mm_size

Gaudi::Property< int > MuFastSteering::m_esd_mm_size { this, "ESD_MM_size", 100 }
private

Definition at line 282 of file MuFastSteering.h.

◆ m_esd_rpc_size

Gaudi::Property< int > MuFastSteering::m_esd_rpc_size { this, "ESD_RPC_size", 100 }
private

Definition at line 277 of file MuFastSteering.h.

◆ m_esd_stgc_size

Gaudi::Property< int > MuFastSteering::m_esd_stgc_size { this, "ESD_STGC_size", 100 }
private

Definition at line 281 of file MuFastSteering.h.

◆ m_esd_tgc_size

Gaudi::Property< int > MuFastSteering::m_esd_tgc_size { this, "ESD_TGC_size", 50 }
private

Definition at line 278 of file MuFastSteering.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> MuFastSteering::m_eventInfoKey
private
Initial value:
{
this, "EventInfo", "EventInfo", "Name of the xAOD::EventInfo object"}

Definition at line 310 of file MuFastSteering.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_fill_FSIDRoI

Gaudi::Property< bool > MuFastSteering::m_fill_FSIDRoI { this, "FILL_FSIDRoI", false, "Fill FS RoI for ID (will be used in cosmic run)"}
private

Definition at line 304 of file MuFastSteering.h.

◆ m_ftfminPt

Gaudi::Property< float > MuFastSteering::m_ftfminPt { this, "FTFminPt", 3500, "pT [MeV] threshold to FTF tracks for L2Muon Inside-out mode" }
private

Definition at line 292 of file MuFastSteering.h.

◆ m_ftfRoadDefiner

ToolHandle<TrigL2MuonSA::FtfRoadDefiner> MuFastSteering::m_ftfRoadDefiner
protected
Initial value:
{
this, "FtfRoadDefiner", "TrigL2MuonSA::FtfRoadDefiner", "ftf road definer" }

Definition at line 232 of file MuFastSteering.h.

◆ m_FTFtrackKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> MuFastSteering::m_FTFtrackKey
private
Initial value:
{
this, "TrackParticlesContainerName", "HLT_xAODTracks_Muon", "Name of the input data on xAOD::TrackParticleContainer produced by FTF for Inside-Out mode"}

Definition at line 324 of file MuFastSteering.h.

◆ m_incidentSvc

ServiceHandle< IIncidentSvc > MuFastSteering::m_incidentSvc {this, "IncidentSvc", "IncidentSvc"}
private

Definition at line 253 of file MuFastSteering.h.

◆ m_insideOut

Gaudi::Property< bool > MuFastSteering::m_insideOut { this, "InsideOutMode", false, "" }
private

Definition at line 289 of file MuFastSteering.h.

◆ m_jobOptionsSvc

ServiceHandle<Gaudi::Interfaces::IOptionsSvc> MuFastSteering::m_jobOptionsSvc {this, "JobOptionsSvc", "JobOptionsSvc", "Job options service to retrieve DataFlowConfig" }
private

Definition at line 254 of file MuFastSteering.h.

◆ m_monTool

ToolHandle< GenericMonitoringTool > MuFastSteering::m_monTool { this, "MonTool", "", "Monitoring tool" }
private

Definition at line 348 of file MuFastSteering.h.

◆ m_muCompositeContainerKey

SG::WriteHandleKey<xAOD::TrigCompositeContainer> MuFastSteering::m_muCompositeContainerKey
private
Initial value:
{
this, "MuonCalibrationStream", "MuonCalibrationStream", "Name of the decisions object attached by MuFastSteering"}

Definition at line 332 of file MuFastSteering.h.

◆ m_muFastContainerKey

SG::WriteHandleKey<xAOD::L2StandAloneMuonContainer> MuFastSteering::m_muFastContainerKey
private
Initial value:
{
this, "MuonL2SAInfo", "MuonL2SAInfo", "Name of the output data on xAOD::L2StandAloneMuonContainer"}

Definition at line 328 of file MuFastSteering.h.

◆ m_muIdContainerKey

SG::WriteHandleKey<TrigRoiDescriptorCollection> MuFastSteering::m_muIdContainerKey
private
Initial value:
{
this, "forID", "forID", "Name of the output data for Inner Detector"}

Definition at line 336 of file MuFastSteering.h.

◆ m_multiTrack

Gaudi::Property< bool > MuFastSteering::m_multiTrack { this, "multitrackMode", false, "" }
private

Definition at line 290 of file MuFastSteering.h.

◆ m_muMsContainerKey

SG::WriteHandleKey<TrigRoiDescriptorCollection> MuFastSteering::m_muMsContainerKey
private
Initial value:
{
this, "forMS", "forMS", "Name of the output data for MS"}

Definition at line 340 of file MuFastSteering.h.

◆ m_outputCBmuonCollKey

SG::WriteHandleKey<xAOD::L2CombinedMuonContainer> MuFastSteering::m_outputCBmuonCollKey
private
Initial value:
{
this, "L2IOCB", "MuonL2CBInfo", "output CB Muon container name"}

Definition at line 344 of file MuFastSteering.h.

◆ m_patternFinder

ToolHandle<TrigL2MuonSA::MuFastPatternFinder> MuFastSteering::m_patternFinder
protected
Initial value:
{
this, "PatternFinder", "TrigL2MuonSA::MuFastPatternFinder", "pattern finder" }

Definition at line 224 of file MuFastSteering.h.

◆ m_recMuonRoIUtils

TrigL2MuonSA::RecMuonRoIUtils MuFastSteering::m_recMuonRoIUtils
protected

Definition at line 244 of file MuFastSteering.h.

◆ m_recRoiCollectionKey

SG::ReadHandleKey<xAOD::MuonRoIContainer> MuFastSteering::m_recRoiCollectionKey
private
Initial value:
{
this, "RecMuonRoI", "LVL1MuonRoIs", "Name of the input data on xAOD::MuonRoI"}

Definition at line 320 of file MuFastSteering.h.

◆ m_roiCollectionKey

SG::ReadHandleKey<TrigRoiDescriptorCollection> MuFastSteering::m_roiCollectionKey
private
Initial value:
{
this, "MuRoIs", "HLT_MURoIs", "Name of the input data from HLTSeeding"}

Definition at line 314 of file MuFastSteering.h.

◆ m_rpcErrToDebugStream

Gaudi::Property< bool > MuFastSteering::m_rpcErrToDebugStream { this, "RpcErrToDebugStream", false}
private

Definition at line 273 of file MuFastSteering.h.

◆ m_run2recRoiCollectionKey

SG::ReadHandleKey<DataVector<LVL1::RecMuonRoI> > MuFastSteering::m_run2recRoiCollectionKey
private
Initial value:
{
this, "Run2RecMuonRoI", "HLT_RecMURoIs", "Name of the input data on LVL1::RecMuonRoI produced by HLTSeeding"}

Definition at line 318 of file MuFastSteering.h.

◆ m_rWidth_RPC_Failed

Gaudi::Property< double > MuFastSteering::m_rWidth_RPC_Failed { this, "R_WIDTH_RPC_FAILED", 400 }
private

Definition at line 284 of file MuFastSteering.h.

◆ m_rWidth_TGC_Failed

Gaudi::Property< double > MuFastSteering::m_rWidth_TGC_Failed { this, "R_WIDTH_TGC_FAILED", 200 }
private

Definition at line 285 of file MuFastSteering.h.

◆ m_scaleRoadBarrelInner

Gaudi::Property< float > MuFastSteering::m_scaleRoadBarrelInner { this, "Scale_Road_BarrelInner", 1 }
private

Definition at line 256 of file MuFastSteering.h.

◆ m_scaleRoadBarrelMiddle

Gaudi::Property< float > MuFastSteering::m_scaleRoadBarrelMiddle { this, "Scale_Road_BarrelMiddle", 1 }
private

Definition at line 257 of file MuFastSteering.h.

◆ m_scaleRoadBarrelOuter

Gaudi::Property< float > MuFastSteering::m_scaleRoadBarrelOuter { this, "Scale_Road_BarrelOuter", 1 }
private

Definition at line 258 of file MuFastSteering.h.

◆ m_stationFitter

ToolHandle<TrigL2MuonSA::MuFastStationFitter> MuFastSteering::m_stationFitter
protected
Initial value:
{
this, "StationFitter", "TrigL2MuonSA::MuFastStationFitter", "station fitter" }

Definition at line 226 of file MuFastSteering.h.

◆ m_topoRoad

Gaudi::Property< bool > MuFastSteering::m_topoRoad { this, "topoRoad", false, "create road in barrel not to highly overlap surrounding L1 RoIs" }
private

Definition at line 293 of file MuFastSteering.h.

◆ m_trackExtrapolator

ToolHandle<TrigL2MuonSA::MuFastTrackExtrapolator> MuFastSteering::m_trackExtrapolator
protected
Initial value:
{
this, "TrackExtrapolator", "TrigL2MuonSA::MuFastTrackExtrapolator", "track extrapolator" }

Definition at line 230 of file MuFastSteering.h.

◆ m_trackFitter

ToolHandle<TrigL2MuonSA::MuFastTrackFitter> MuFastSteering::m_trackFitter
protected
Initial value:
{
this, "TrackFitter", "TrigL2MuonSA::MuFastTrackFitter", "track fitter" }

Definition at line 228 of file MuFastSteering.h.

◆ m_use_endcapInnerFromBarrel

Gaudi::Property< bool > MuFastSteering::m_use_endcapInnerFromBarrel { this, "UseEndcapInnerFromBarrel", false}
private

Definition at line 274 of file MuFastSteering.h.

◆ m_use_mcLUT

Gaudi::Property< bool > MuFastSteering::m_use_mcLUT { this, "UseLUTForMC", true}
private

Definition at line 260 of file MuFastSteering.h.

◆ m_use_mm

Gaudi::Property< bool > MuFastSteering::m_use_mm { this, "USE_MM", true}
private

Definition at line 264 of file MuFastSteering.h.

◆ m_use_new_segmentfit

Gaudi::Property< bool > MuFastSteering::m_use_new_segmentfit { this, "USE_NEW_SEGMENTFIT", true}
private

Definition at line 261 of file MuFastSteering.h.

◆ m_use_RoIBasedDataAccess_CSC

Gaudi::Property< bool > MuFastSteering::m_use_RoIBasedDataAccess_CSC { this, "USE_ROIBASEDACCESS_CSC", true}
private

Definition at line 268 of file MuFastSteering.h.

◆ m_use_RoIBasedDataAccess_MDT

Gaudi::Property< bool > MuFastSteering::m_use_RoIBasedDataAccess_MDT { this, "USE_ROIBASEDACCESS_MDT", true}
private

Definition at line 265 of file MuFastSteering.h.

◆ m_use_RoIBasedDataAccess_MM

Gaudi::Property< bool > MuFastSteering::m_use_RoIBasedDataAccess_MM { this, "USE_ROIBASEDACCESS_MM", true}
private

Definition at line 270 of file MuFastSteering.h.

◆ m_use_RoIBasedDataAccess_RPC

Gaudi::Property< bool > MuFastSteering::m_use_RoIBasedDataAccess_RPC { this, "USE_ROIBASEDACCESS_RPC", true}
private

Definition at line 266 of file MuFastSteering.h.

◆ m_use_RoIBasedDataAccess_STGC

Gaudi::Property< bool > MuFastSteering::m_use_RoIBasedDataAccess_STGC { this, "USE_ROIBASEDACCESS_STGC", true}
private

Definition at line 269 of file MuFastSteering.h.

◆ m_use_RoIBasedDataAccess_TGC

Gaudi::Property< bool > MuFastSteering::m_use_RoIBasedDataAccess_TGC { this, "USE_ROIBASEDACCESS_TGC", true}
private

Definition at line 267 of file MuFastSteering.h.

◆ m_use_rpc

Gaudi::Property< bool > MuFastSteering::m_use_rpc { this, "USE_RPC", true}
private

Definition at line 262 of file MuFastSteering.h.

◆ m_use_stgc

Gaudi::Property< bool > MuFastSteering::m_use_stgc { this, "USE_STGC", true}
private

Definition at line 263 of file MuFastSteering.h.

◆ m_useRun3Config

Gaudi::Property< bool > MuFastSteering::m_useRun3Config { this, "UseRun3Config", false, "use Run3 L1Muon EDM; xAOD::MuonRoI"}
private

Definition at line 306 of file MuFastSteering.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_winPt

Gaudi::Property< double > MuFastSteering::m_winPt { this, "WinPt", 4.0 }
private

Definition at line 287 of file MuFastSteering.h.

The documentation for this class was generated from the following files:
MuFastSteering::m_use_mm
Gaudi::Property< bool > m_use_mm
Definition: MuFastSteering.h:264
xAOD::L2MuonParameters::ECRegions
ECRegions
Definition: TrigMuonDefs.h:36
MuFastSteering::m_use_RoIBasedDataAccess_CSC
Gaudi::Property< bool > m_use_RoIBasedDataAccess_CSC
Definition: MuFastSteering.h:268
MuFastSteering::m_jobOptionsSvc
ServiceHandle< Gaudi::Interfaces::IOptionsSvc > m_jobOptionsSvc
Definition: MuFastSteering.h:254
mergePhysValFiles.pattern
pattern
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:26
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
xAOD::L2StandAloneMuon_v2::setDeltaEta
void setDeltaEta(float value)
Set error of eta.
beamspotman.r
def r
Definition: beamspotman.py:676
MuFastSteering::m_cscsegmaker
ToolHandle< TrigL2MuonSA::CscSegmentMaker > m_cscsegmaker
Definition: MuFastSteering.h:247
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:161
MuFastSteering::updateMonitor
StatusCode updateMonitor(const LVL1::RecMuonRoI *roi, const TrigL2MuonSA::MdtHits &mdtHits, std::vector< TrigL2MuonSA::TrackPattern > &trackPatterns) const
Update monitoring variables.
Definition: MuFastSteering.cxx:3646
xAOD::L2StandAloneMuon_v2::setMmClustersCapacity
void setMmClustersCapacity(const int value)
Set size of storage for MM clusters.
Definition: L2StandAloneMuon_v2.cxx:1295
xAOD::L2CombinedMuon_v1::setStrategy
void setStrategy(int value)
set algorithm strategy flag
TrigL2MuonSA::CscHitData
Definition: CscData.h:14
PlotCalibFromCool.norm
norm
Definition: PlotCalibFromCool.py:100
MuFastSteering::storeIDRoiDescriptor
bool storeIDRoiDescriptor(const TrigRoiDescriptor *roids, const TrigL2MuonSA::TrackPattern &pattern, const DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputID) const
Definition: MuFastSteering.cxx:3388
MuFastSteering::m_dataPreparator
ToolHandle< TrigL2MuonSA::MuFastDataPreparator > m_dataPreparator
Definition: MuFastSteering.h:222
MuFastSteering::ITIMER_TRACK_EXTRAPOLATOR
@ ITIMER_TRACK_EXTRAPOLATOR
Definition: MuFastSteering.h:52
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TrigL2MuonSA::TgcFitResult::tgcMidRhoNin
int tgcMidRhoNin
Definition: TgcFitResult.h:48
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
xAOD::L2StandAloneMuon_v2::setTgcMidF
void setTgcMidF(float rhoChi2, long rhoN, float phiChi2, long phiN)
Definition: L2StandAloneMuon_v2.cxx:1018
LVL1::RecMuonRoI::subsysID
unsigned int subsysID() const
returns sub-system ID ROI (0=-z,1=+z)
Definition: RecMuonRoI.h:108
TrigL2MuonSA::MuonRoad::setScales
void setScales(double inner, double middle, double outer)
Definition: MuonRoad.h:67
DeMoUpdate.tmp2
string tmp2
Definition: DeMoUpdate.py:1168
TrigL2MuonSA::TgcFitResult::tgcMidPhiNin
int tgcMidPhiNin
Definition: TgcFitResult.h:51
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
xAOD::L2StandAloneMuon_v2::setEtaBin
void setEtaBin(int value)
Set eta bin of pT LUT.
xAOD::L2StandAloneMuon_v2::setEndcapAlpha
void setEndcapAlpha(float value)
Set the fitted value in the endcap.
xAOD::L2StandAloneMuon_v2::etaMS
float etaMS() const
Get the eta at muon spectrometer.
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
xAOD::L2StandAloneMuon_v2::setEtaMap
void setEtaMap(float value)
Set eta used to refer pT LUT.
TrigL2MuonSA::RpcFitResult::phi
double phi
Definition: RpcFitResult.h:44
TrigL2MuonSA::RpcHits
std::vector< RpcHitData > RpcHits
Definition: RpcData.h:57
xAOD::L2StandAloneMuon_v2::setRegionEta
void setRegionEta(int station, int sector, float min, float max)
Eta range.
Definition: L2StandAloneMuon_v2.cxx:883
xAOD::TrigComposite
TrigComposite_v1 TrigComposite
Declare the latest version of the class.
Definition: Event/xAOD/xAODTrigger/xAODTrigger/TrigComposite.h:16
MuFastSteering::ITIMER_DATA_PREPARATOR
@ ITIMER_DATA_PREPARATOR
Definition: MuFastSteering.h:48
MuFastSteering::m_dEtasurrRoI
Gaudi::Property< float > m_dEtasurrRoI
Definition: MuFastSteering.h:295
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
MuFastSteering::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: MuFastSteering.h:310
xAOD::L2CombinedMuon_v1::setPhi
void setPhi(float phi)
Set the azimuthal angle ( ) of the muon.
Definition: L2CombinedMuon_v1.cxx:89
MuFastSteering::m_trackExtrapolator
ToolHandle< TrigL2MuonSA::MuFastTrackExtrapolator > m_trackExtrapolator
Definition: MuFastSteering.h:230
dumpTgcDigiDeadChambers.stationName
dictionary stationName
Definition: dumpTgcDigiDeadChambers.py:30
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
xAOD::L2MuonParameters::NULLID
@ NULLID
Definition: TrigMuonDefs.h:34
TrigL2MuonSA::RpcFitResult::phi_inner
double phi_inner
Definition: RpcFitResult.h:47
xAOD::L2StandAloneMuon_v2::setPhiBin
void setPhiBin(int value)
Set phi bin of pT LUT.
TrigL2MuonSA::RpcFitResult
Definition: RpcFitResult.h:14
xAOD::L2StandAloneMuon_v2
Class describing standalone muons reconstructed in the LVL2 trigger.
Definition: L2StandAloneMuon_v2.h:36
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
TrigInDetValidation_menu_test.tc
tc
Definition: TrigInDetValidation_menu_test.py:8
xAOD::L2StandAloneMuon_v2::setAlgoId
void setAlgoId(int value)
MuFastSteering::m_trackFitter
ToolHandle< TrigL2MuonSA::MuFastTrackFitter > m_trackFitter
Definition: MuFastSteering.h:228
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TrigL2MuonSA::RpcFitResult::offset_middle
double offset_middle
Definition: RpcFitResult.h:53
MuFastSteering::m_calStreamer
ToolHandle< TrigL2MuonSA::MuCalStreamerTool > m_calStreamer
Definition: MuFastSteering.h:240
MuFastSteering::m_outputCBmuonCollKey
SG::WriteHandleKey< xAOD::L2CombinedMuonContainer > m_outputCBmuonCollKey
Definition: MuFastSteering.h:344
MuFastSteering::m_calBufferName
Gaudi::Property< std::string > m_calBufferName
Definition: MuFastSteering.h:300
TrigL2MuonSA::RpcFitResult::Clear
void Clear()
Definition: RpcFitResult.h:19
MuFastSteering::m_recMuonRoIUtils
TrigL2MuonSA::RecMuonRoIUtils m_recMuonRoIUtils
Definition: MuFastSteering.h:244
AthenaInterprocess::UpdateAfterFork
Definition: Incidents.h:22
CxxUtils::wrapToPi
T wrapToPi(T phi)
Wrap angle in radians to [-pi, pi].
Definition: phihelper.h:24
xAOD::L2StandAloneMuon_v2::setIsRpcFailure
void setIsRpcFailure(int value)
Set flag to record if RPC is properly read.
xAOD::L2MuonParameters::BEE
@ BEE
BEE measurement point.
Definition: TrigMuonDefs.h:24
xAOD::L2MuonParameters::EndcapExtra
@ EndcapExtra
Extra station in the endcap spectrometer.
Definition: TrigMuonDefs.h:22
TrigL2MuonSA::TgcFitResult
Definition: TgcFitResult.h:11
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
xAOD::L2StandAloneMuon_v2::setRoiSubsystem
void setRoiSubsystem(uint32_t value)
AthCommonDataStore::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 > renounce(T &h)
Definition: AthCommonDataStore.h:380
TrigL2MuonSA::MdtRegion::rMin
double rMin[11][2]
Definition: MdtRegion.h:38
MuFastSteering::m_backExtrapolatorTool
ToolHandle< ITrigMuonBackExtrapolator > m_backExtrapolatorTool
Handle to MuonBackExtrapolator tool.
Definition: MuFastSteering.h:236
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
MuFastSteering::m_patternFinder
ToolHandle< TrigL2MuonSA::MuFastPatternFinder > m_patternFinder
Definition: MuFastSteering.h:224
TrigL2MuonSA::MdtHits
std::vector< MdtHitData > MdtHits
Definition: MdtData.h:57
TrigL2MuonSA::TgcHits
std::vector< TgcHitData > TgcHits
Definition: TgcData.h:43
MuFastSteering::storeMSRoiDescriptor
bool storeMSRoiDescriptor(const TrigRoiDescriptor *roids, const TrigL2MuonSA::TrackPattern &pattern, const DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputMS) const
Definition: MuFastSteering.cxx:3342
TrigL2MuonSA::MdtHitData
Definition: MdtData.h:18
TrigL2MuonSA::MdtRegion::zMin
double zMin[11][2]
Definition: MdtRegion.h:33
TrigL2MuonSA::MuonRoad::bw
double bw[N_STATION][N_SECTOR]
Definition: MuonRoad.h:82
xAOD::L2StandAloneMuon_v2::setTgcInn
void setTgcInn(float eta, float phi, float r, float z)
Set the results of TGC fit.
Definition: L2StandAloneMuon_v2.cxx:958
MuFastSteering::m_topoRoad
Gaudi::Property< bool > m_topoRoad
Definition: MuFastSteering.h:293
test_pyathena.pt
pt
Definition: test_pyathena.py:11
xAOD::L2StandAloneMuon_v2::setMdtHit
void setMdtHit(uint32_t onlineId, int isOutier, int chamber, float r, float z, float phi, float residual, float time, float space, float sigma)
Set the properties of each MDT tube.
Definition: L2StandAloneMuon_v2.cxx:1492
xAOD::L2StandAloneMuon_v2::setPt
void setPt(float pt)
Set the transverse momentum ( ) of the muon.
xAOD::L2MuonParameters::BME
@ BME
BME measurement point.
Definition: TrigMuonDefs.h:25
M_PI
#define M_PI
Definition: ActiveFraction.h:11
TrigRoiDescriptor::roiWord
virtual unsigned int roiWord() const override final
Definition: TrigRoiDescriptor.h:135
MuFastSteering::m_scaleRoadBarrelInner
Gaudi::Property< float > m_scaleRoadBarrelInner
Definition: MuFastSteering.h:256
TrigL2MuonSA::MuonRoad::isEndcap
bool isEndcap
Definition: MuonRoad.h:72
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
xAOD::L2MuonParameters::BarrelInner
@ BarrelInner
Inner station in the barrel spectrometer.
Definition: TrigMuonDefs.h:16
xAOD::MuonRoI_v1::eta
float eta() const
The pseudorapidity ( ) of the muon candidate.
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
MuFastSteering::m_incidentSvc
ServiceHandle< IIncidentSvc > m_incidentSvc
Definition: MuFastSteering.h:253
ParticleTest.tp
tp
Definition: ParticleTest.py:25
TrigL2MuonSA::MdtRegion::zMax
double zMax[11][2]
Definition: MdtRegion.h:37
MuFastSteering::m_doEndcapForl2mt
Gaudi::Property< bool > m_doEndcapForl2mt
Definition: MuFastSteering.h:291
xAOD::L2StandAloneMuon_v2::setRoiSector
void setRoiSector(uint32_t value)
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
MuFastSteering::m_stationFitter
ToolHandle< TrigL2MuonSA::MuFastStationFitter > m_stationFitter
Definition: MuFastSteering.h:226
TrigL2MuonSA::RpcFitResult::offset_inner
double offset_inner
Definition: RpcFitResult.h:49
xAOD::L2StandAloneMuon_v2::setDeltaPhi
void setDeltaPhi(float value)
Set error of phi.
xAOD::L2StandAloneMuon_v2::setSuperPoint
void setSuperPoint(int chamber, float r, float z, float slope, float intercept=0., float chi2=0.)
Set the properties of one particular super point measurement.
Definition: L2StandAloneMuon_v2.cxx:220
xAOD::L2StandAloneMuon_v2::setPhiMS
void setPhiMS(float value)
Set the phi at muon spectrometer.
TrigL2MuonSA::MdtRegion::Clear
void Clear()
Definition: MdtRegion.h:18
xAOD::L2StandAloneMuon_v2::setEtaMS
void setEtaMS(float value)
Set the eta at muon spectrometer.
xAOD::L2StandAloneMuon_v2::setRpcFitInn
void setRpcFitInn(float phi, float slope, float offset)
Set the results of RPC fit.
Definition: L2StandAloneMuon_v2.cxx:1050
TrigRoiDescriptor
nope - should be used for standalone also, perhaps need to protect the class def bits #ifndef XAOD_AN...
Definition: TrigRoiDescriptor.h:56
xAOD::L2StandAloneMuon_v2::phiMS
float phiMS() const
Get the phi at muon spectrometer.
xAOD::roiEta
setTeId setLumiBlock setRoiId setRoiSubsystem setRoiNumber roiEta
Definition: L2StandAloneMuon_v2.cxx:343
MuFastSteering::m_muMsContainerKey
SG::WriteHandleKey< TrigRoiDescriptorCollection > m_muMsContainerKey
Definition: MuFastSteering.h:340
xAOD::barrelRadius
setSAddress setEtaMS setDirPhiMS setDirZMS barrelRadius
Definition: L2StandAloneMuon_v1.cxx:128
xAOD::L2CombinedMuon_v1::setCharge
void setCharge(float value)
set seeding muon charge
MuFastSteering::m_esd_csc_size
Gaudi::Property< int > m_esd_csc_size
Definition: MuFastSteering.h:280
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
MuFastSteering::m_FTFtrackKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_FTFtrackKey
Definition: MuFastSteering.h:324
MuFastSteering::ITIMER_TRACK_FITTER
@ ITIMER_TRACK_FITTER
Definition: MuFastSteering.h:51
xAOD::MuonRoI_v1::getHemisphere
Hemisphere getHemisphere() const
Returns the hemisphere that detected the muon candidate.
Definition: MuonRoI_v1.cxx:220
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
MuFastSteering::m_use_rpc
Gaudi::Property< bool > m_use_rpc
Definition: MuFastSteering.h:262
TrigL2MuonSA::RpcFitResult::offset_outer
double offset_outer
Definition: RpcFitResult.h:57
LVL1::RecMuonRoI::eta
virtual double eta() const
returns eta coord of ROI
Definition: RecMuonRoI.h:117
AthenaInterprocess::UpdateAfterFork::workerID
int workerID() const
assigned worker ID from processing unit
Definition: Incidents.h:40
TrigL2MuonSA::CscHits
std::vector< CscHitData > CscHits
Definition: CscData.h:40
x
#define x
xAOD::L2StandAloneMuon_v2::setRMS
void setRMS(float value)
Set the R at muon spectrometer.
TrigL2MuonSA::MdtRegion::chamberType
int chamberType[11][2][2]
Definition: MdtRegion.h:44
xAOD::L2MuonParameters::MUONID
@ MUONID
Definition: TrigMuonDefs.h:31
LVL1::RecMuonRoI::getThresholdNumber
unsigned int getThresholdNumber() const
returns the Threshold Number (1 to 6) associated with this RecRoI
Definition: RecMuonRoI.h:120
TrigL2MuonSA::MuonRoad::aw
double aw[N_STATION][N_SECTOR]
Definition: MuonRoad.h:81
TrigL2MuonSA::MdtRegion
Definition: MdtRegion.h:14
LVL1::RecMuonRoI::roiWord
virtual unsigned int roiWord() const
returns roi word
Definition: RecMuonRoI.h:102
xAOD::L2CombinedMuon_v1::setEta
void setEta(float eta)
Set the pseudorapidity ( ) of the muon.
Definition: L2CombinedMuon_v1.cxx:82
MuFastSteering::getRoiSizeForID
float getRoiSizeForID(bool isEta, const xAOD::L2StandAloneMuon *muonSA) const
Definition: MuFastSteering.cxx:3497
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
MuFastSteering::ITIMER_PATTERN_FINDER
@ ITIMER_PATTERN_FINDER
Definition: MuFastSteering.h:49
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
xAOD::L2StandAloneMuon_v2::setTgcHitsCapacity
void setTgcHitsCapacity(int value)
Set size of storage for TGC hits.
Definition: L2StandAloneMuon_v2.cxx:1204
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:74
xAOD::L2StandAloneMuon_v2::setTgcInnF
void setTgcInnF(float rhoStd, long rhoN, float phiStd, long phiN)
Definition: L2StandAloneMuon_v2.cxx:973
MuFastSteering::m_fill_FSIDRoI
Gaudi::Property< bool > m_fill_FSIDRoI
Definition: MuFastSteering.h:304
MuFastSteering::ITIMER_CALIBRATION_STREAMER
@ ITIMER_CALIBRATION_STREAMER
Definition: MuFastSteering.h:53
xAOD::L2CombinedMuon_v1
Class describing combined muon reconstructed in the LVL2 trigger.
Definition: L2CombinedMuon_v1.h:41
MuFastSteering::m_doCalStream
Gaudi::Property< bool > m_doCalStream
Definition: MuFastSteering.h:271
TrigL2MuonSA::TrackPattern
Definition: TrackData.h:16
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
xAOD::L2StandAloneMuon_v2::setPtEndcapBeta
void setPtEndcapBeta(float value)
LArCellBinning_test.retval
def retval
Definition: LArCellBinning_test.py:112
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
MuFastSteering::m_use_RoIBasedDataAccess_RPC
Gaudi::Property< bool > m_use_RoIBasedDataAccess_RPC
Definition: MuFastSteering.h:266
xAOD::L2StandAloneMuon_v2::setBeta
void setBeta(float value)
Set beta.
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
MuFastSteering::m_calDataScouting
Gaudi::Property< bool > m_calDataScouting
Definition: MuFastSteering.h:272
MuFastSteering::m_recRoiCollectionKey
SG::ReadHandleKey< xAOD::MuonRoIContainer > m_recRoiCollectionKey
Definition: MuFastSteering.h:320
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
xAOD::L2StandAloneMuon_v2::setEta
void setEta(float eta)
Set the pseudorapidity ( ) of the muon.
Definition: L2StandAloneMuon_v2.cxx:82
efficiency
void efficiency(std::vector< double > &bins, std::vector< double > &values, const std::vector< std::string > &files, const std::string &histname, const std::string &tplotname, const std::string &label="")
Definition: dependence.cxx:128
MuFastSteering::ITIMER_TOTAL_PROCESSING
@ ITIMER_TOTAL_PROCESSING
Definition: MuFastSteering.h:54
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
MuFastSteering::m_useRun3Config
Gaudi::Property< bool > m_useRun3Config
Definition: MuFastSteering.h:306
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::L2StandAloneMuon_v2::setRoad
void setRoad(int station, int sector, float aw, float bw)
Road.
Definition: L2StandAloneMuon_v2.cxx:751
TrigL2MuonSA::TgcFitResult::tgcMid2
float tgcMid2[4]
Definition: TgcFitResult.h:46
LVL1::RecMuonRoI
This class defines the reconstructed Muon ROI.
Definition: RecMuonRoI.h:60
TrigL2MuonSA::TgcFitResult::isSuccess
bool isSuccess
Definition: TgcFitResult.h:39
TrigL2MuonSA::RpcFitResult::slope_inner
double slope_inner
Definition: RpcFitResult.h:48
MuFastSteering::m_use_stgc
Gaudi::Property< bool > m_use_stgc
Definition: MuFastSteering.h:263
MuFastSteering::m_multiTrack
Gaudi::Property< bool > m_multiTrack
Definition: MuFastSteering.h:290
xAOD::L2StandAloneMuon_v2::setPhi
void setPhi(float phi)
Set the azimuthal angle ( ) of the muon.
Definition: L2StandAloneMuon_v2.cxx:89
xAOD::L2StandAloneMuon_v2::setBarrelSagitta
void setBarrelSagitta(float value)
Set the fitted sagitta of the muon in the barrel.
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
xAOD::L2StandAloneMuon_v2::sAddress
int sAddress() const
Get the station address of the muon.
MuFastSteering::m_scaleRoadBarrelMiddle
Gaudi::Property< float > m_scaleRoadBarrelMiddle
Definition: MuFastSteering.h:257
xAOD::L2StandAloneMuon_v2::setMmCluster
void setMmCluster(const unsigned int layer, const int isOutlier, const float eta, const float phi, const float r, const float z, const float residualR, const float residualPhi, const int stationEta, const int stationPhi, const int stationName)
Set MM hits.
Definition: L2StandAloneMuon_v2.cxx:1736
MuFastSteering::m_use_new_segmentfit
Gaudi::Property< bool > m_use_new_segmentfit
Definition: MuFastSteering.h:261
xAOD::L2StandAloneMuon_v2::setSAddress
void setSAddress(int value)
Set the station address of the muon.
TrigL2MuonSA::MuonRoad
Definition: MuonRoad.h:20
z
#define z
MuFastSteering::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: MuFastSteering.h:348
xAOD::L2StandAloneMuon_v2::setRoiSystem
void setRoiSystem(uint32_t value)
MuFastSteering::m_ftfminPt
Gaudi::Property< float > m_ftfminPt
Definition: MuFastSteering.h:292
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
TrigL2MuonSA::TgcFitResult::Clear
void Clear()
Definition: TgcFitResult.h:16
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TrigL2MuonSA::TgcFitResult::tgcInnRhoNin
int tgcInnRhoNin
Definition: TgcFitResult.h:57
xAOD::L2StandAloneMuon_v2::setRoiId
void setRoiId(uint32_t value)
xAOD::L2StandAloneMuon_v2::setChamberType2
void setChamberType2(int station, int sector, int chamberType)
Definition: L2StandAloneMuon_v2.cxx:723
xAOD::L2StandAloneMuon_v2::setPtEndcapAlpha
void setPtEndcapAlpha(float value)
MuFastSteering::storeMuonSA
bool storeMuonSA(const LVL1::RecMuonRoI *roi, const TrigRoiDescriptor *roids, const TrigL2MuonSA::MuonRoad &muonRoad, const TrigL2MuonSA::MdtRegion &mdtRegion, const TrigL2MuonSA::RpcHits &rpcHits, const TrigL2MuonSA::TgcHits &tgcHits, const TrigL2MuonSA::RpcFitResult &rpcFitResult, const TrigL2MuonSA::TgcFitResult &tgcFitResult, const TrigL2MuonSA::MdtHits &mdtHits, const TrigL2MuonSA::CscHits &cscHits, const TrigL2MuonSA::StgcHits &stgcHits, const TrigL2MuonSA::MmHits &mmHits, const TrigL2MuonSA::TrackPattern &pattern, DataVector< xAOD::L2StandAloneMuon > &outputTracks, const EventContext &ctx) const
Definition: MuFastSteering.cxx:2495
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
TrigL2MuonSA::RecMuonRoIUtils::isBarrel
bool isBarrel(const LVL1::RecMuonRoI *p_roi) const
Definition: RecMuonRoIUtils.h:19
MuFastSteering::findMultiTrackSignature
StatusCode findMultiTrackSignature(const std::vector< const TrigRoiDescriptor * > &roi, const std::vector< const LVL1::RecMuonRoI * > &muonRoIs, DataVector< xAOD::L2StandAloneMuon > &outputTracks, const bool dynamicDeltaRpc, const EventContext &ctx) const
findMultiTrackSignature(), includes reconstract algorithms for multi-track mode
Definition: MuFastSteering.cxx:1776
TrigL2MuonSA::RpcFitResult::slope_middle
double slope_middle
Definition: RpcFitResult.h:52
xAOD::MuonRoI_v1
Class describing a LVL1 muon region of interest.
Definition: MuonRoI_v1.h:29
WeakBFieldA
@ WeakBFieldA
Definition: MuFastSteering.h:42
xAOD::MuonRoI_v1::getSource
RoISource getSource() const
Returns the system that detected the muon candidate.
Definition: MuonRoI_v1.cxx:202
MuFastSteering::findMuonSignature
StatusCode findMuonSignature(const std::vector< const TrigRoiDescriptor * > &roi, const std::vector< const LVL1::RecMuonRoI * > &muonRoIs, DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputID, TrigRoiDescriptorCollection &outputMS, const bool dynamicDeltaRpc, const EventContext &ctx) const
findMuonSignature(), includes reconstract algorithms
Definition: MuFastSteering.cxx:525
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TrigRoiDescriptor::l1Id
virtual unsigned int l1Id() const override final
Definition: TrigRoiDescriptor.h:134
LVL1::RecMuonRoI::sectorID
unsigned int sectorID() const
returns sector ID ROI
Definition: RecMuonRoI.h:111
MuFastSteering::m_roiCollectionKey
SG::ReadHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey
Definition: MuFastSteering.h:314
TrigL2MuonSA::TgcFitResult::tgcMid1
float tgcMid1[4]
Definition: TgcFitResult.h:45
TrigL2MuonSA::TgcHitData
Definition: TgcData.h:14
TrigL2MuonSA::RpcFitResult::phi_middle
double phi_middle
Definition: RpcFitResult.h:51
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
MuFastSteering::m_use_endcapInnerFromBarrel
Gaudi::Property< bool > m_use_endcapInnerFromBarrel
Definition: MuFastSteering.h:274
Handler::svc
AthROOTErrorHandlerSvc * svc
Definition: AthROOTErrorHandlerSvc.cxx:10
MuFastSteering::m_muIdContainerKey
SG::WriteHandleKey< TrigRoiDescriptorCollection > m_muIdContainerKey
Definition: MuFastSteering.h:336
MuFastSteering::L2MuonAlgoMap
int L2MuonAlgoMap(const std::string &name) const
Definition: MuFastSteering.cxx:3480
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:52
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
MuFastSteering::updateOutputObjects
bool updateOutputObjects(const LVL1::RecMuonRoI *roi, const TrigRoiDescriptor *roids, const TrigL2MuonSA::MuonRoad &muonRoad, const TrigL2MuonSA::MdtRegion &mdtRegion, const TrigL2MuonSA::RpcHits &rpcHits, const TrigL2MuonSA::TgcHits &tgcHits, const TrigL2MuonSA::RpcFitResult &rpcFitResult, const TrigL2MuonSA::TgcFitResult &tgcFitResult, const TrigL2MuonSA::MdtHits &mdtHits, const TrigL2MuonSA::CscHits &cscHits, const TrigL2MuonSA::StgcHits &stgcHits, const TrigL2MuonSA::MmHits &mmHits, const std::vector< TrigL2MuonSA::TrackPattern > &trackPatterns, DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputID, TrigRoiDescriptorCollection &outputMS, const EventContext &ctx) const
Called at the end of the algorithm processing to set the steering navigation properly.
Definition: MuFastSteering.cxx:2415
xAOD::MuonRoI_v1::getRoI
int getRoI() const
Get the "RoI number" (position inside the sector)
Definition: MuonRoI_v1.cxx:89
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
TrigL2MuonSA::TgcFitResult::tgcInnRhoStd
float tgcInnRhoStd
Definition: TgcFitResult.h:56
xAOD::L2StandAloneMuon_v2::setCscHit
void setCscHit(int isOutlier, int chamber, uint32_t stationName, int stationEta, int stationPhi, int chamberLayer, int wireLayer, int measuresPhi, int strip, float eta, float phi, float r, float z, int charge, float time, float residual)
Set the properties of each CSC tube.
Definition: L2StandAloneMuon_v2.cxx:1650
TrigL2MuonSA::RpcHitData
Definition: RpcData.h:14
xAOD::L2StandAloneMuon_v2::setRegionZ
void setRegionZ(int station, int sector, float min, float max)
Z range.
Definition: L2StandAloneMuon_v2.cxx:795
xAOD::L2StandAloneMuon_v2::setRpcFitOut
void setRpcFitOut(float phi, float slope, float offset)
Definition: L2StandAloneMuon_v2.cxx:1076
xAOD::L2StandAloneMuon_v2::setMuonDetMask
void setMuonDetMask(uint32_t value)
TrigL2MuonSA::MdtRegion::etaMin
double etaMin[11][2]
Definition: MdtRegion.h:40
ZERO_LIMIT
const float ZERO_LIMIT
Definition: VP1TriggerHandleL2.cxx:37
TrigL2MuonSA::RpcFitResult::phi_outer
double phi_outer
Definition: RpcFitResult.h:55
xAOD::L2StandAloneMuon_v2::setChamberType1
void setChamberType1(int station, int sector, int chamberType)
Set the muon road information.
Definition: L2StandAloneMuon_v2.cxx:696
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
MuFastSteering::m_esd_rpc_size
Gaudi::Property< int > m_esd_rpc_size
Definition: MuFastSteering.h:277
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
xAOD::L2StandAloneMuon_v2::setStgcCluster
void setStgcCluster(const unsigned int layer, const int isOutlier, const int type, const float eta, const float phi, const float r, const float z, const float residualR, const float residualPhi, const int stationEta, const int stationPhi, const int stationName)
Set sTGC hits.
Definition: L2StandAloneMuon_v2.cxx:1697
xAOD::L2MuonParameters::GEV900ID
@ GEV900ID
Definition: TrigMuonDefs.h:31
LVL1::RecMuonRoI::phi
virtual double phi() const
returns phi coord of ROI
Definition: RecMuonRoI.h:114
MuFastSteering::m_insideOut
Gaudi::Property< bool > m_insideOut
Definition: MuFastSteering.h:289
TrigL2MuonSA::TgcFitResult::tgcMidRhoChi2
float tgcMidRhoChi2
Definition: TgcFitResult.h:47
xAOD::L2StandAloneMuon_v2::setIsTgcFailure
void setIsTgcFailure(int value)
Set flag to record if TGC is properly read.
xAOD::L2MuonParameters::EndcapMiddle
@ EndcapMiddle
Middle station in the endcap spectrometer.
Definition: TrigMuonDefs.h:20
dumpTgcDigiThreshold.isStrip
list isStrip
Definition: dumpTgcDigiThreshold.py:33
MuFastSteering::m_use_RoIBasedDataAccess_MM
Gaudi::Property< bool > m_use_RoIBasedDataAccess_MM
Definition: MuFastSteering.h:270
xAOD::L2StandAloneMuon_v2::setEndcapBeta
void setEndcapBeta(float value)
Set the fitted value in the endcap.
xAOD::L2CombinedMuon_v1::setIdTrackLink
void setIdTrackLink(const ElementLink< xAOD::TrackParticleContainer > &link)
set ID track used to make the CB muon
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
LVL1::RecMuonRoI::sysID
unsigned int sysID() const
returns system ID ROI (Barrel=0, Endcap=1, Forward=2)
Definition: RecMuonRoI.h:105
MuFastSteering::m_esd_tgc_size
Gaudi::Property< int > m_esd_tgc_size
Definition: MuFastSteering.h:278
xAOD::L2StandAloneMuon_v2::setDirPhiMS
void setDirPhiMS(float value)
Set tan phi at muon spectrometer.
xAOD::L2StandAloneMuon_v2::setRpcHitsCapacity
void setRpcHitsCapacity(int value)
Size of storage to be reserved.
Definition: L2StandAloneMuon_v2.cxx:1183
xAOD::L2StandAloneMuon_v2::setBarrelRadius
void setBarrelRadius(float value)
Set the fitted radius of the muon in the barrel.
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::AuxElement::makePrivateStore
void makePrivateStore()
Create a new (empty) private store for this object.
Definition: AuxElement.cxx:192
xAOD::L2StandAloneMuon_v2::setRpcHit
void setRpcHit(uint32_t layer, uint32_t measuresPhi, float x, float y, float z, float time, float distEta, float distPhi, const std::string &stationName)
Set RPC hits.
Definition: L2StandAloneMuon_v2.cxx:1340
python.PhysicalConstants.c_light
float c_light
Definition: PhysicalConstants.py:63
xAOD::L2StandAloneMuon_v2::setMdtHitsCapacity
void setMdtHitsCapacity(int value)
Set size of storage for MDT hits.
Definition: L2StandAloneMuon_v2.cxx:1225
MuFastSteering::m_ftfRoadDefiner
ToolHandle< TrigL2MuonSA::FtfRoadDefiner > m_ftfRoadDefiner
Definition: MuFastSteering.h:232
xAOD::L2CombinedMuon
L2CombinedMuon_v1 L2CombinedMuon
Define the latest version of the muon CB class.
Definition: L2CombinedMuon.h:15
TrigL2MuonSA::TgcFitResult::tgcInn
float tgcInn[4]
Definition: TgcFitResult.h:55
RTTAlgmain.address
address
Definition: RTTAlgmain.py:55
MuFastSteering::m_scaleRoadBarrelOuter
Gaudi::Property< float > m_scaleRoadBarrelOuter
Definition: MuFastSteering.h:258
AthenaInterprocess::UpdateAfterFork::type
static const std::string & type()
Incident type.
Definition: Incidents.h:49
MuFastSteering::m_rWidth_TGC_Failed
Gaudi::Property< double > m_rWidth_TGC_Failed
Definition: MuFastSteering.h:285
xAOD::L2CombinedMuon_v1::setMuSATrackLink
void setMuSATrackLink(const ElementLink< xAOD::L2StandAloneMuonContainer > &link)
set SA muon used to make the CB muon
MuFastSteering::m_winPt
Gaudi::Property< double > m_winPt
Definition: MuFastSteering.h:287
TrigRoiDescriptor::roiId
virtual unsigned int roiId() const override final
these quantities probably don't need to be used any more
Definition: TrigRoiDescriptor.h:133
columnar::ContainerId::eventInfo
@ eventInfo
xAOD::L2CombinedMuon_v1::setPt
void setPt(float pt)
Set the transverse momentum ( ) of the muon.
xAOD::L2StandAloneMuon_v2::setRoiEta
void setRoiEta(float value)
MuFastSteering::m_dPhisurrRoI
Gaudi::Property< float > m_dPhisurrRoI
Definition: MuFastSteering.h:294
xAOD::L2StandAloneMuon_v2::setZMS
void setZMS(float value)
Set the Z at muon spectrometer.
xAOD::L2StandAloneMuon_v2::setRoiThreshold
void setRoiThreshold(uint32_t value)
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
xAOD::L2StandAloneMuon_v2::setRpcFitMid
void setRpcFitMid(float phi, float slope, float offset)
Definition: L2StandAloneMuon_v2.cxx:1063
TrigL2MuonSA::RpcFitResult::isSuccess
bool isSuccess
Definition: RpcFitResult.h:38
matchingRecRoI
const LVL1::RecMuonRoI * matchingRecRoI(uint32_t roiWord, const DataVector< LVL1::RecMuonRoI > &collection)
Definition: MuFastSteering.cxx:204
MuFastSteering::ITIMER_STATION_FITTER
@ ITIMER_STATION_FITTER
Definition: MuFastSteering.h:50
RoiDescriptor::etaPlus
virtual double etaPlus() const override final
gets eta at zedPlus
Definition: RoiDescriptor.h:115
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:63
TrigL2MuonSA::TgcFitResult::tgcPT
float tgcPT
Definition: TgcFitResult.h:63
xAOD::L2StandAloneMuon_v2::setTgcPt
void setTgcPt(float value)
a
TList * a
Definition: liststreamerinfos.cxx:10
TrigL2MuonSA::MmHits
std::vector< MmHitData > MmHits
Definition: MmData.h:47
columnar::empty
bool empty() const noexcept
Definition: ObjectRange.h:129
h
Base_Fragment.width
width
Definition: Sherpa_i/share/common/Base_Fragment.py:59
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
RoiDescriptor::phi
virtual double phi() const override final
Methods to retrieve data members.
Definition: RoiDescriptor.h:100
xAOD::L2MuonParameters::EndcapInner
@ EndcapInner
Inner station in the endcap spectrometer.
Definition: TrigMuonDefs.h:19
TrigRoiDescriptorCollection
Definition: TrigRoiDescriptorCollection.h:21
xAOD::L2MuonParameters::BarrelOuter
@ BarrelOuter
Outer station in the barrel spectrometer.
Definition: TrigMuonDefs.h:18
TrigL2MuonSA::StgcHits
std::vector< StgcHitData > StgcHits
Definition: StgcData.h:49
xAOD::L2StandAloneMuon_v2::setRegionR
void setRegionR(int station, int sector, float min, float max)
R range.
Definition: L2StandAloneMuon_v2.cxx:839
DEBUG
#define DEBUG
Definition: page_access.h:11
bcTag
unsigned bcTag(unsigned bcBitMap)
Definition: TgcByteStreamData.h:359
MuFastSteering::m_use_mcLUT
Gaudi::Property< bool > m_use_mcLUT
Definition: MuFastSteering.h:260
MuFastSteering::m_muFastContainerKey
SG::WriteHandleKey< xAOD::L2StandAloneMuonContainer > m_muFastContainerKey
Definition: MuFastSteering.h:328
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
xAOD::L2StandAloneMuon_v2::setRoiNumber
void setRoiNumber(uint32_t value)
MuFastSteering::m_run2recRoiCollectionKey
SG::ReadHandleKey< DataVector< LVL1::RecMuonRoI > > m_run2recRoiCollectionKey
Definition: MuFastSteering.h:318
python.LArCondContChannels.isBarrel
isBarrel
Definition: LArCondContChannels.py:659
xAOD::L2StandAloneMuon_v2::setLvl1Id
void setLvl1Id(uint32_t value)
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
MuFastSteering::findMuonSignatureIO
StatusCode findMuonSignatureIO(const xAOD::TrackParticleContainer &idtracks, const std::vector< const TrigRoiDescriptor * > &roids, const std::vector< const LVL1::RecMuonRoI * > &muonRoIs, DataVector< xAOD::L2CombinedMuon > &outputCBs, DataVector< xAOD::L2StandAloneMuon > &outputSAs, const bool dynamicDeltaRpc, const EventContext &ctx) const
findMuonSignatureIO(), includes reconstract algorithms for inside-out mode
Definition: MuFastSteering.cxx:1155
RoiDescriptor::eta
virtual double eta() const override final
Definition: RoiDescriptor.h:101
xAOD::L2StandAloneMuon_v2::setPtCSC
void setPtCSC(float value)
xAOD::L2StandAloneMuon_v2::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
LVL1::RecMuonRoI::getRoINumber
unsigned int getRoINumber() const
return RoI number in hardware numbering scheme
Definition: RecMuonRoI.h:126
WeakBFieldB
@ WeakBFieldB
Definition: MuFastSteering.h:42
TrigL2MuonSA::RpcFitResult::slope_outer
double slope_outer
Definition: RpcFitResult.h:56
TrigRoiDescriptor
Athena::TPCnvVers::Current TrigRoiDescriptor
Definition: TrigSteeringEventTPCnv.cxx:68
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
xAOD::L2StandAloneMuon_v2::setRoIWord
void setRoIWord(uint32_t value)
Set the RoI ID of the seeding LVL1 muon.
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
MuFastSteering::m_rWidth_RPC_Failed
Gaudi::Property< double > m_rWidth_RPC_Failed
Definition: MuFastSteering.h:284
TrigL2MuonSA::MuonRoad::extFtfMiddleEta
double extFtfMiddleEta
Definition: MuonRoad.h:90
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
MuFastSteering::m_calBufferSize
Gaudi::Property< int > m_calBufferSize
Definition: MuFastSteering.h:301
xAOD::MuonRoI_v1::getSectorID
int getSectorID() const
Get the sector ID number.
Definition: MuonRoI_v1.cxx:133
TrigL2MuonSA::MdtRegion::etaMax
double etaMax[11][2]
Definition: MdtRegion.h:41
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
MuFastSteering::m_use_RoIBasedDataAccess_MDT
Gaudi::Property< bool > m_use_RoIBasedDataAccess_MDT
Definition: MuFastSteering.h:265
PowhegControl_ttFCNC_NLO.params
params
Definition: PowhegControl_ttFCNC_NLO.py:226
RoiDescriptor::phiPlus
virtual double phiPlus() const override final
gets phiPlus
Definition: RoiDescriptor.h:118
Muon::nsw::STGTPSegments::moduleIDBits::stationEta
constexpr uint8_t stationEta
1 to 3
Definition: NSWSTGTPDecodeBitmaps.h:159
xAOD::L2StandAloneMuon_v2::setTgcHit
void setTgcHit(float eta, float phi, float r, float z, float width, int stationNum, bool isStrip, int bcTag, bool inRoad)
Set TGC hits.
Definition: L2StandAloneMuon_v2.cxx:1375
xAOD::L2StandAloneMuon_v2::setCscHitsCapacity
void setCscHitsCapacity(int value)
Set size of storage for CSC hits.
Definition: L2StandAloneMuon_v2.cxx:1246
xAOD::L2StandAloneMuon
L2StandAloneMuon_v2 L2StandAloneMuon
Define the latest version of the muon SA class.
Definition: L2StandAloneMuon.h:17
TrigL2MuonSA::TgcFitResult::tgcInnPhiNin
int tgcInnPhiNin
Definition: TgcFitResult.h:60
RoiDescriptor::etaMinus
virtual double etaMinus() const override final
gets eta at zMinus
Definition: RoiDescriptor.h:116
xAOD::L2StandAloneMuon_v2::setStgcClustersCapacity
void setStgcClustersCapacity(const int value)
Set size of storage for sTGC clusters.
Definition: L2StandAloneMuon_v2.cxx:1274
TrigL2MuonSA::TgcFitResult::tgcMidPhiChi2
float tgcMidPhiChi2
Definition: TgcFitResult.h:50
MuonParameters::beta
@ beta
Definition: MuonParamDefs.h:144
xAOD::L2StandAloneMuon_v2::setPtEndcapRadius
void setPtEndcapRadius(float value)
xAOD::L2StandAloneMuon_v2::setDirZMS
void setDirZMS(float value)
Set dRdZ at muon spectrometer.
TrigL2MuonSA::MuonRoad::Clear
void Clear()
Definition: MuonRoad.h:25
xAOD::MuonRoI_v1::getThrNumber
int getThrNumber() const
Get the logic number of the highest threshold this RoI passed.
Definition: MuonRoI_v1.cxx:76
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
xAOD::L2CombinedMuon_v1::setErrorFlag
void setErrorFlag(int value)
set algorithm error flag
xAOD::L2StandAloneMuon_v2::setPhiMap
void setPhiMap(float value)
Set phi used to refer pT LUT.
xAOD::L2StandAloneMuon_v2::setEndcapRadius
void setEndcapRadius(float value)
Set the fitted radius of the muon in the endcap.
MuFastSteering::m_esd_mdt_size
Gaudi::Property< int > m_esd_mdt_size
Definition: MuFastSteering.h:279
RoiDescriptor::phiMinus
virtual double phiMinus() const override final
gets phiMinus
Definition: RoiDescriptor.h:119
xAOD::L2StandAloneMuon_v2::setDeltaPt
void setDeltaPt(float value)
Set error of pT.
MuFastSteering::m_esd_mm_size
Gaudi::Property< int > m_esd_mm_size
Definition: MuFastSteering.h:282
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
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::L2MuonParameters::BarrelMiddle
@ BarrelMiddle
Middle station in the barrel spectrometer.
Definition: TrigMuonDefs.h:17
xAOD::L2StandAloneMuon_v2::setLumiBlock
void setLumiBlock(uint32_t value)
Monitored::Timer
A monitored timer.
Definition: MonitoredTimer.h:32
xAOD::L2MuonParameters::EndcapOuter
@ EndcapOuter
Outer station in the endcap spectrometer.
Definition: TrigMuonDefs.h:21
TrigL2MuonSA::TgcFitResult::tgcInnPhiStd
float tgcInnPhiStd
Definition: TgcFitResult.h:59
TrigL2MuonSA::MdtRegion::rMax
double rMax[11][2]
Definition: MdtRegion.h:39
MuFastSteering::m_esd_stgc_size
Gaudi::Property< int > m_esd_stgc_size
Definition: MuFastSteering.h:281
xAOD::MuonRoI_v1::roiWord
uint32_t roiWord() const
The "raw" RoI word describing the muon candidate.
MuFastSteering::m_use_RoIBasedDataAccess_TGC
Gaudi::Property< bool > m_use_RoIBasedDataAccess_TGC
Definition: MuFastSteering.h:267
xAOD::L2StandAloneMuon_v2::setTgcMid2
void setTgcMid2(float eta, float phi, float r, float z)
Definition: L2StandAloneMuon_v2.cxx:1003
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
xAOD::L2StandAloneMuon_v2::setTgcMid1
void setTgcMid1(float eta, float phi, float r, float z)
Definition: L2StandAloneMuon_v2.cxx:988
xAOD::L2StandAloneMuon_v2::setTrackPosition
void setTrackPosition(float r, float z, float eta, float phi)
Set position of muon track.
Definition: L2StandAloneMuon_v2.cxx:301
fitman.k
k
Definition: fitman.py:528
xAOD::L2StandAloneMuon_v2::setRoiPhi
void setRoiPhi(float value)
MuFastSteering::m_muCompositeContainerKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_muCompositeContainerKey
Definition: MuFastSteering.h:332
xAOD::L2MuonParameters::whichECRegion
ECRegions whichECRegion(const float eta, const float phi)
Definition: TrigMuonDefs.cxx:16
ServiceHandle< ICondSvc >
xAOD::MuonRoI_v1::phi
float phi() const
The azimuthal angle ( ) of the muon candidate.
MuFastSteering::m_use_RoIBasedDataAccess_STGC
Gaudi::Property< bool > m_use_RoIBasedDataAccess_STGC
Definition: MuFastSteering.h:269
Generated on Thu Apr 17 2025 21:37:27 for ATLAS Offline Software by   doxygen 1.8.18