ATLAS Offline Software
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, 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 AthReentrantAlgorithm::cardinality ( ) const
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 55 of file AthReentrantAlgorithm.cxx.

56 {
57  return 0;
58 }

◆ 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, *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 & AthReentrantAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.cxx.

80 {
81  // If we didn't find any symlinks to add, just return the collection
82  // from the base class. Otherwise, return the extended collection.
83  if (!m_extendedExtraObjects.empty()) {
84  return m_extendedExtraObjects;
85  }
86  return Algorithm::extraOutputDeps();
87 }

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

135  {
136  return execState( ctx ).filterPassed();
137  }

◆ 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 1759 of file MuFastSteering.cxx.

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

◆ 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 2079 of file MuFastSteering.cxx.

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

◆ 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,
TrigRoiDescriptorCollection &  outputID,
TrigRoiDescriptorCollection &  outputMS,
const bool  dynamicDeltaRpc,
const EventContext &  ctx 
) const

Definition at line 820 of file MuFastSteering.cxx.

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

◆ 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 1138 of file MuFastSteering.cxx.

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

◆ 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 1450 of file MuFastSteering.cxx.

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

◆ getRoiSizeForID()

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

Definition at line 3480 of file MuFastSteering.cxx.

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

◆ 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 AthReentrantAlgorithm::isClonable ( ) const
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, InDet::SiSPGNNTrackMaker, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, ITkStripCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

45 {
46  // Reentrant algorithms are clonable.
47  return true;
48 }

◆ L2MuonAlgoMap()

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

Definition at line 3463 of file MuFastSteering.cxx.

3464 {
3465  int algoId = 0;
3466  if (name == "MuFastSteering_Muon") {
3467  algoId = xAOD::L2MuonParameters::L2MuonAlgoId::MUONID;
3468  } else if (name == "MuFastSteering_900GeV") {
3469  algoId = xAOD::L2MuonParameters::L2MuonAlgoId::GEV900ID;
3470  } else {
3471  algoId = xAOD::L2MuonParameters::L2MuonAlgoId::NULLID;
3472  }
3473 
3474  return algoId;
3475 }

◆ 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 AthReentrantAlgorithm::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

139  {
140  execState( ctx ).setFilterPassed( state );
141  }

◆ 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 3371 of file MuFastSteering.cxx.

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

◆ storeMSRoiDescriptor()

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

Definition at line 3325 of file MuFastSteering.cxx.

3329 {
3330  const float ZERO_LIMIT = 1.e-5;
3331 
3332  const xAOD::L2StandAloneMuon* muonSA = outputTracks[0];
3333 
3334  float mseta = pattern.etaMap;
3335  float msphi = pattern.phiMS;
3336 
3337  // store TrigRoiDescriptor
3338  if (std::abs(muonSA->pt()) < ZERO_LIMIT ) {
3339  mseta = roids->eta();
3340  msphi = roids->phi();
3341  }
3342 
3343  // set width of 0.1 so that ID tracking monitoring works
3344  const float phiHalfWidth = 0.1;
3345  const float etaHalfWidth = 0.1;
3346 
3347  TrigRoiDescriptor* MSroiDescriptor = new TrigRoiDescriptor(roids->roiWord(),
3348  roids->l1Id(),
3349  roids->roiId(),
3350  mseta,
3351  mseta - etaHalfWidth,
3352  mseta + etaHalfWidth,
3353  msphi,
3354  msphi - phiHalfWidth,
3355  msphi + phiHalfWidth);
3356 
3357  ATH_MSG_VERBOSE("...TrigRoiDescriptor for MS "
3358  << "mseta/msphi="
3359  << mseta << "/" << msphi);
3360 
3361  ATH_MSG_VERBOSE("will Record an RoiDescriptor for TrigMoore:"
3362  << " phi=" << MSroiDescriptor->phi()
3363  << ", eta=" << MSroiDescriptor->eta());
3364 
3365  outputMS.push_back(MSroiDescriptor);
3366 
3367  return true;
3368 }

◆ 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 2478 of file MuFastSteering.cxx.

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

◆ 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 2901 of file MuFastSteering.cxx.

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

◆ sysExecute()

StatusCode AthReentrantAlgorithm::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 67 of file AthReentrantAlgorithm.cxx.

68 {
69  return Gaudi::Algorithm::sysExecute (ctx);
70 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::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 96 of file AthReentrantAlgorithm.cxx.

96  {
97  StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>::sysInitialize();
98 
99  if (sc.isFailure()) {
100  return sc;
101  }
102 
103  ServiceHandle<ICondSvc> cs("CondSvc",name());
104  for (auto h : outputHandles()) {
105  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
106  // do this inside the loop so we don't create the CondSvc until needed
107  if ( cs.retrieve().isFailure() ) {
108  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
109  return StatusCode::SUCCESS;
110  }
111  if (cs->regHandle(this,*h).isFailure()) {
112  sc = StatusCode::FAILURE;
113  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
114  << " with CondSvc");
115  }
116  }
117  }
118  return sc;
119 }

◆ 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 3629 of file MuFastSteering.cxx.

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

◆ updateMonitor() [2/2]

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

Definition at line 3740 of file MuFastSteering.cxx.

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

◆ 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 2398 of file MuFastSteering.cxx.

2415 {
2416 
2417  if( trackPatterns.size() > 0 ) {
2418 
2419  const TrigL2MuonSA::TrackPattern& pattern = trackPatterns.back();
2420 
2421  // Update output trigger element
2422  storeMuonSA(roi, roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2423  rpcFitResult, tgcFitResult, mdtHits, cscHits,
2424  stgcHits, mmHits,
2425  pattern, outputTracks, ctx);
2426  storeMSRoiDescriptor(roids, pattern, outputTracks, outputMS);
2427  storeIDRoiDescriptor(roids, pattern, outputTracks, outputID);
2428 
2429  } else {
2430  ATH_MSG_DEBUG("Not update output objects because trackPatterns has no object");
2431  }
2432 
2433  return true;
2434 }

◆ 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 2439 of file MuFastSteering.cxx.

2456 {
2457 
2458  if( trackPatterns.size() > 0 ) {
2459 
2460  const TrigL2MuonSA::TrackPattern& pattern = trackPatterns.back();
2461 
2462  // Update output trigger element
2463  storeMuonSA(roi, roids, muonRoad, mdtRegion, rpcHits, tgcHits,
2464  rpcFitResult, tgcFitResult, mdtHits, cscHits,
2465  stgcHits, mmHits,
2466  pattern, outputTracks, ctx);
2467  storeMSRoiDescriptor(roids, pattern, outputTracks, outputMS);
2468  storeIDRoiDescriptor(roids, pattern, outputTracks, outputID);
2469 
2470  } else {
2471  ATH_MSG_DEBUG("Not update output objects because trackPatterns has no object");
2472  }
2473 
2474  return true;
2475 }

◆ 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 298 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 235 of file MuFastSteering.h.

◆ m_calBufferName

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

Definition at line 299 of file MuFastSteering.h.

◆ m_calBufferSize

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

Definition at line 300 of file MuFastSteering.h.

◆ m_calDataScouting

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

Definition at line 271 of file MuFastSteering.h.

◆ m_calStreamer

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

Definition at line 239 of file MuFastSteering.h.

◆ m_cscsegmaker

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

Definition at line 246 of file MuFastSteering.h.

◆ m_dataPreparator

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

Definition at line 221 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 294 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 270 of file MuFastSteering.h.

◆ m_doEndcapForl2mt

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

Definition at line 290 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 293 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 279 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 278 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 281 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 276 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 280 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 277 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 309 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 AthReentrantAlgorithm::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.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 303 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 291 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 231 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 323 of file MuFastSteering.h.

◆ m_incidentSvc

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

Definition at line 252 of file MuFastSteering.h.

◆ m_insideOut

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

Definition at line 288 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 253 of file MuFastSteering.h.

◆ m_monTool

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

Definition at line 347 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 331 of file MuFastSteering.h.

◆ m_muFastContainerKey