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 xAOD::MuonRoI * > &muonRoIs, DataVector< xAOD::L2StandAloneMuon > &outputTracks, xAOD::TrigCompositeContainer *outputMuonCal, TrigRoiDescriptorCollection &outputID, TrigRoiDescriptorCollection &outputMS, const bool dynamicDeltaRpc, const EventContext &ctx) const
 findMuonSignature(), includes reconstract algorithms 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
 findMuonSignatureIO(), includes reconstract algorithms for inside-out 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
 findMultiTrackSignature(), includes reconstract algorithms for multi-track mode More...
 
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, V, H > &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 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
 Called at the end of the algorithm processing to set the steering navigation properly. More...
 
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 xAOD::MuonRoI *roi, const TrigL2MuonSA::MdtHits &mdtHits, std::vector< TrigL2MuonSA::TrackPattern > &trackPatterns) const
 Update monitoring variables. More...
 
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, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &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 23 of file MuFastSteering.cxx.

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

Member Function Documentation

◆ cardinality()

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

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

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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, V, H > &  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, V, H > &  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, V, H > &  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, V, H > &  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 228 of file MuFastSteering.cxx.

229 {
230  if(!m_useRun3Config) {
231  ATH_MSG_ERROR("You are not supposed to run trigger on RUN2 layout anymore.");
232  return StatusCode::FAILURE;
233  }
234 
235  auto totalTimer = Monitored::Timer( "TIME_Total" );
236  auto monitorIt = Monitored::Group(m_monTool, totalTimer );
237 
238  // retrieve with ReadHandle
239  auto roiCollectionHandle = SG::makeHandle( m_roiCollectionKey, ctx );
240  const TrigRoiDescriptorCollection *roiCollection = roiCollectionHandle.cptr();
241  if (!roiCollectionHandle.isValid()){
242  ATH_MSG_ERROR("ReadHandle for TrigRoiDescriptorCollection key:" << m_roiCollectionKey.key() << " isn't Valid");
243  return StatusCode::FAILURE;
244  }
245 
246  auto recRoiCollectionHandle = SG::makeHandle( m_recRoiCollectionKey, ctx );
247  const xAOD::MuonRoIContainer *recRoiCollection = recRoiCollectionHandle.cptr();
248  if (!recRoiCollectionHandle.isValid()){
249  ATH_MSG_ERROR("ReadHandle for xAOD::MuonRoIContainer key:" << m_recRoiCollectionKey.key() << " isn't Valid");
250  return StatusCode::FAILURE;
251  }
252 
253  std::vector< const TrigRoiDescriptor* > internalRoI;
254  TrigRoiDescriptorCollection::const_iterator p_roids = roiCollection->begin();
255  TrigRoiDescriptorCollection::const_iterator p_roidsEn = roiCollection->end();
256 
257  for(; p_roids != p_roidsEn; ++p_roids ) {
258  internalRoI.push_back(*p_roids);
259  ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " eta = " << "(" << (*p_roids)->etaMinus() << ")" << (*p_roids)->eta() << "(" << (*p_roids)->etaPlus() << ")");
260  ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " phi = " << "(" << (*p_roids)->phiMinus() << ")" << (*p_roids)->phi() << "(" << (*p_roids)->phiPlus() << ")");
261  ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " zed = " << "(" << (*p_roids)->zedMinus() << ")" << (*p_roids)->zed() << "(" << (*p_roids)->zedPlus() << ")");
262  }
263  ATH_MSG_DEBUG("REGTEST: " << m_roiCollectionKey.key() << " size = " << internalRoI.size());
264 
265  // make RecMURoIs maching with MURoIs
266  std::vector< const xAOD::MuonRoI* > recRoIVector;
267  std::vector< const xAOD::MuonRoI* > surrRoIs;
268 
269  for (size_t size=0; size<roiCollection->size(); size++){
270  const xAOD::MuonRoI* recRoI = matchingRecRoI( roiCollection->at(size)->roiWord(), *recRoiCollection );
271  if( recRoI == nullptr ) continue;
272  recRoIVector.push_back(recRoI);
273  ATH_MSG_DEBUG("REGTEST: " << m_recRoiCollectionKey.key() << " eta/phi = " << (recRoI)->eta() << "/" << (recRoI)->phi());
274  ATH_MSG_DEBUG("REGTEST: " << m_recRoiCollectionKey.key() << " size = " << recRoIVector.size());
275  }
276 
277  bool dynamicDeltaRpc = false;
278  int nPassedBarrelSurrRoi = 0;
279  if(m_topoRoad ){
280  for( const auto recRoI: *recRoiCollection ){
281  if(std::find(recRoIVector.begin(), recRoIVector.end(), recRoI) != recRoIVector.end()) continue;
282 
283  bool surrounding = false;
284  for( const auto matchedRoI: recRoIVector ){
285  float deta = std::abs(recRoI->eta() - matchedRoI->eta());
286  float dphi = std::abs(recRoI->phi() - matchedRoI->phi());
287  if( dphi > M_PI )dphi = 2.*M_PI - dphi;
288  if( deta < m_dEtasurrRoI && dphi < m_dPhisurrRoI)
289  surrounding = true;
290  }
291 
292  if(surrounding)
293  surrRoIs.push_back(recRoI);
294  }
295 
296  ATH_MSG_DEBUG("surrRoI: " << " size = " << surrRoIs.size());
297  for( const auto recRoI: surrRoIs ){
298  ATH_MSG_DEBUG("surrRoI: " << " eta/phi = " << (recRoI)->eta() << "/" << (recRoI)->phi() );
299  if( std::abs((recRoI)->eta()) <= 1.05 && (recRoI)->getThrNumber() >= 1 )nPassedBarrelSurrRoi++;
300  }
301  ATH_MSG_DEBUG( "nPassedBarrelSurrRoi = " << nPassedBarrelSurrRoi);
302  //dynamicDeltaRpcMode
303  if( nPassedBarrelSurrRoi >= 1 )
304  dynamicDeltaRpc = true;
305  }
306 
307  // record data objects with WriteHandle
308  auto muFastContainer = SG::makeHandle(m_muFastContainerKey, ctx);
309  ATH_CHECK(muFastContainer.record(std::make_unique<xAOD::L2StandAloneMuonContainer>(), std::make_unique<xAOD::L2StandAloneMuonAuxContainer>()));
310 
311  xAOD::TrigCompositeContainer* muCompositeContainer{nullptr};
312  if (!m_muCompositeContainerKey.empty()){
313  SG::WriteHandle<xAOD::TrigCompositeContainer> wh_muCompositeCont(m_muCompositeContainerKey, ctx);
314  ATH_CHECK(wh_muCompositeCont.record(std::make_unique<xAOD::TrigCompositeContainer>(), std::make_unique<xAOD::TrigCompositeAuxContainer>()));
315  muCompositeContainer = wh_muCompositeCont.ptr();
316  }
317 
318  auto muIdContainer = SG::makeHandle(m_muIdContainerKey, ctx);
319  ATH_CHECK(muIdContainer.record(std::make_unique<TrigRoiDescriptorCollection>()));
320 
321  auto muMsContainer = SG::makeHandle(m_muMsContainerKey, ctx);
322  ATH_CHECK(muMsContainer.record(std::make_unique<TrigRoiDescriptorCollection>()));
323 
324 
325  // Inside-out L2Muon mode
326  if(m_insideOut) {
327  ATH_MSG_DEBUG("start inside-out mode...");
328 
329  auto muonCBColl = SG::makeHandle (m_outputCBmuonCollKey, ctx);
330  ATH_CHECK( muonCBColl.record (std::make_unique<xAOD::L2CombinedMuonContainer>(),
331  std::make_unique<xAOD::L2CombinedMuonAuxContainer>()) );
332 
333  auto trackHandle = SG::makeHandle( m_FTFtrackKey, ctx );
334  if (!trackHandle.isValid()){
335  ATH_MSG_ERROR("ReadHandle for TrackParticleContainer key:" << m_FTFtrackKey.key() << " isn't Valid");
336  return StatusCode::FAILURE;
337  }
338  const xAOD::TrackParticleContainer *tracks = trackHandle.cptr();
339 
340  ATH_CHECK(findMuonSignatureIO(*tracks, internalRoI, recRoIVector,
341  *muonCBColl, *muFastContainer, dynamicDeltaRpc, ctx ));
342 
343  if (msgLvl(MSG::DEBUG)) {
344  ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " size = " << muonCBColl->size());
345  for (const auto p_CBmuon : *muonCBColl){
346  ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " pt = " << (*p_CBmuon).pt() << " GeV");
347  ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " eta/phi = " << (*p_CBmuon).eta() << "/" << (*p_CBmuon).phi());
348  }
349  }
350  }
351  else if(m_multiTrack){ //multi-track SA mode
352  ATH_MSG_DEBUG("start multi-track SA mode...");
353  ATH_CHECK(findMultiTrackSignature(internalRoI, recRoIVector, *muFastContainer, dynamicDeltaRpc, ctx));
354  }
355  else {
356  ATH_CHECK(findMuonSignature(internalRoI, recRoIVector,
357  *muFastContainer, muCompositeContainer, *muIdContainer, *muMsContainer, dynamicDeltaRpc, ctx));
358  }
359 
360  if (msgLvl(MSG::DEBUG)) {
361  // DEBUG TEST: Recorded data objects
362  ATH_MSG_DEBUG("Recorded data objects");
363  ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " size = " << muFastContainer->size());
364 
365  for (auto p_muon : *muFastContainer) {
366  ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " pt = " << (*p_muon).pt() << " GeV");
367  ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " eta/phi = " << (*p_muon).eta() << "/" << (*p_muon).phi());
368  }
369 
370  ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muIdContainerKey.key() << " size = " << muIdContainer->size());
371  for (auto p_muonID : *muIdContainer) {
372  ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muIdContainerKey.key() << " eta/phi = " << (*p_muonID).eta() << "/" << (*p_muonID).phi());
373  }
374 
375  ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muMsContainerKey.key() << " size = " << muMsContainer->size());
376  for (auto p_muonMS : *muMsContainer) {
377  ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muMsContainerKey.key() << " eta/phi = " << (*p_muonMS).eta() << "/" << (*p_muonMS).phi());
378  }
379  }
380 
381  ATH_MSG_DEBUG("StatusCode MuFastSteering::execute() success");
382  return StatusCode::SUCCESS;
383 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

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

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

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

◆ filterPassed()

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

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

◆ findMultiTrackSignature()

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

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

Definition at line 1030 of file MuFastSteering.cxx.

1035 {
1036  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMultiTrackSignature start");
1037  StatusCode sc = StatusCode::SUCCESS;
1038  const float ZERO_LIMIT = 1.e-5;
1039 
1040  // for RPC clustering and clusterRoad
1041  std::vector<TrigL2MuonSA::RpcFitResult> clusterFitResults;
1042  std::vector< TrigL2MuonSA::MuonRoad > clusterRoad;
1043  std::vector<TrigL2MuonSA::MdtHits> mdtHits_cluster_normal;
1044 
1045 
1046  auto prepTimer = Monitored::Timer( "TIME_Data_Preparator" );
1047  auto patternTimer = Monitored::Timer( "TIME_Pattern_Finder" );
1048  auto stationFitterTimer = Monitored::Timer( "TIME_Station_Fitter" );
1049  auto trackFitterTimer = Monitored::Timer( "TIME_Track_Fitter" );
1050  auto trackExtraTimer = Monitored::Timer( "TIME_Track_Extrapolator" );
1051  auto calibrationTimer = Monitored::Timer( "TIME_Calibration_Streamer" );
1052 
1053  auto monitorIt = Monitored::Group(m_monTool, prepTimer, patternTimer, stationFitterTimer,
1054  trackFitterTimer, trackExtraTimer, calibrationTimer );
1055 
1056  TrigL2MuonSA::RpcHits rpcHits;
1057  TrigL2MuonSA::TgcHits tgcHits;
1058  TrigL2MuonSA::MdtRegion mdtRegion;
1059  TrigL2MuonSA::MuonRoad muonRoad;
1060  TrigL2MuonSA::RpcFitResult rpcFitResult;
1061  TrigL2MuonSA::TgcFitResult tgcFitResult;
1062  TrigL2MuonSA::MdtHits mdtHits;
1063  TrigL2MuonSA::CscHits cscHits;
1064  TrigL2MuonSA::StgcHits stgcHits;
1065  TrigL2MuonSA::MmHits mmHits;
1066 
1067  DataVector<const TrigRoiDescriptor>::const_iterator p_roids;
1068  DataVector<const xAOD::MuonRoI>::const_iterator p_roi;
1069 
1070  // muonRoIs = RecMURoIs, roids = MURoIs
1071  p_roids = roids.begin();
1072  for (p_roi=(muonRoIs).begin(); p_roi!=(muonRoIs).end(); ++p_roi) {
1073 
1074  prepTimer.start();
1075  std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
1076  rpcHits.clear();
1077  tgcHits.clear();
1078  mdtRegion.Clear();
1079  muonRoad.Clear();
1080  rpcFitResult.Clear();
1081  tgcFitResult.Clear();
1082  mdtHits.clear();
1083  cscHits.clear();
1084  stgcHits.clear();
1085  mmHits.clear();
1086 
1087  clusterFitResults.clear();
1088  clusterRoad.clear();
1089  mdtHits_cluster_normal.clear();
1090 
1091  if ( m_recMuonRoIUtils.isBarrel(*p_roi) ) { // Barrel
1092  ATH_MSG_DEBUG("Barrel");
1093 
1094  muonRoad.setScales(m_scaleRoadBarrelInner,
1095  m_scaleRoadBarrelMiddle,
1096  m_scaleRoadBarrelOuter);
1097 
1098  // Data preparation
1099  sc = m_dataPreparator->prepareData(ctx,
1100  *p_roi,
1101  *p_roids,
1102  clusterRoad,
1103  clusterFitResults,
1104  mdtHits,
1105  mdtHits_cluster_normal,
1106  dynamicDeltaRpc);
1107 
1108  if (!sc.isSuccess()) {
1109  ATH_MSG_WARNING("Data preparation failed");
1110  continue;
1111  }
1112  ATH_MSG_DEBUG("clusterRoad size = " << clusterRoad.size());
1113 
1114  prepTimer.stop();
1115 
1116  for(unsigned int i_road = 0; i_road < clusterRoad.size(); i_road++){
1117  // Pattern finding
1118  std::vector<TrigL2MuonSA::TrackPattern> tmp_trkPats; tmp_trkPats.clear();
1119 
1120  patternTimer.start();
1121  sc = m_patternFinder->findPatterns(ctx,
1122  clusterRoad.at(i_road),
1123  mdtHits_cluster_normal.at(i_road),
1124  tmp_trkPats);
1125  if (!sc.isSuccess()) {
1126  ATH_MSG_WARNING("Pattern finder failed");
1127  continue;
1128  }
1129  patternTimer.stop();
1130 
1131  // Superpoint fit
1132  stationFitterTimer.start();
1133  sc = m_stationFitter->findSuperPoints(clusterRoad.at(i_road),
1134  clusterFitResults.at(i_road),
1135  tmp_trkPats);
1136  if (!sc.isSuccess()) {
1137  ATH_MSG_WARNING("Super point fitter failed");
1138  // Update output trigger element
1139  continue;
1140  }
1141  stationFitterTimer.stop();
1142 
1143  // Track fitting
1144  trackFitterTimer.start();
1145  sc = m_trackFitter->findTracks(*p_roids,
1146  clusterFitResults.at(i_road),
1147  tmp_trkPats);
1148 
1149  if (!sc.isSuccess()) {
1150  ATH_MSG_WARNING("Track fitter failed");
1151  continue;
1152  }
1153  trackFitterTimer.stop();
1154 
1155  // fix if eta is strange
1156  const float ETA_LIMIT = 2.8;
1157  const float DELTA_ETA_LIMIT = 1.0;
1158  for (TrigL2MuonSA::TrackPattern& track : tmp_trkPats) {
1159  float roiEta = (*p_roi)->eta();
1160  if (std::abs(track.pt) > ZERO_LIMIT
1161  && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
1162  track.etaMap = roiEta;
1163  }
1164  }
1165 
1166  // Track extrapolation for ID combined
1167  trackExtraTimer.start();
1168 
1169  sc = m_trackExtrapolator->extrapolateTrack(tmp_trkPats, m_winPt);
1170  ATH_MSG_DEBUG("test trackExtrapolator end");
1171 
1172  if (sc != StatusCode::SUCCESS) {
1173  ATH_MSG_WARNING("Track extrapolator failed");
1174  // Update output trigger element
1175  continue;
1176  }
1177  trackExtraTimer.stop();
1178 
1179  if(tmp_trkPats.size() > 0){
1180  ATH_MSG_DEBUG("temp pT calculated 2mu-in-1RoI alg = " << tmp_trkPats[0].pt << " GeV");
1181  if( (std::abs(tmp_trkPats[0].barrelSagitta) < ZERO_LIMIT &&
1182  std::abs(tmp_trkPats[0].barrelRadius) < ZERO_LIMIT) ||
1183  std::abs(tmp_trkPats[0].pt) < ZERO_LIMIT )
1184  continue;
1185  trackPatterns.push_back(tmp_trkPats[0]);
1186  }
1187 
1188  storeMuonSA(*p_roi, *p_roids, clusterRoad.at(i_road), mdtRegion, rpcHits, tgcHits,
1189  clusterFitResults.at(i_road), tgcFitResult, mdtHits_cluster_normal.at(i_road), cscHits,
1190  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1191 
1192  } // end the clusterRoad loop
1193  if(trackPatterns.empty()){
1194  ATH_MSG_DEBUG("multi-track SA falied to reconstruct muons");
1195  TrigL2MuonSA::TrackPattern trackPattern;
1196  trackPatterns.push_back(trackPattern);
1197  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1198  rpcFitResult, tgcFitResult, mdtHits, cscHits,
1199  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1200 
1201  continue;
1202  }
1203  } else { // Endcap
1204  ATH_MSG_DEBUG("Endcap");
1205  if(!m_doEndcapForl2mt){
1206  ATH_MSG_DEBUG("multi-track SA does nothings and skips for EndcapRoI");
1207  } else {
1208  prepTimer.start();
1209  // Data preparation
1210  sc = m_dataPreparator->prepareData(ctx,
1211  *p_roi,
1212  *p_roids,
1213  m_insideOut,
1214  tgcHits,
1215  muonRoad,
1216  mdtRegion,
1217  tgcFitResult,
1218  mdtHits,
1219  cscHits,
1220  stgcHits,
1221  mmHits);
1222  if (!sc.isSuccess()) {
1223  ATH_MSG_WARNING("Data preparation failed");
1224  TrigL2MuonSA::TrackPattern trackPattern;
1225  trackPatterns.push_back(trackPattern);
1226  // Update output trigger element
1227  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1228  rpcFitResult, tgcFitResult, mdtHits, cscHits,
1229  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1230  continue;
1231  }
1232  prepTimer.stop();
1233 
1234  // Pattern finding
1235  patternTimer.start();
1236  sc = m_patternFinder->findPatterns(ctx,
1237  muonRoad,
1238  mdtHits,
1239  stgcHits,
1240  mmHits,
1241  trackPatterns);
1242 
1243 
1244 
1245  if (!sc.isSuccess()) {
1246  ATH_MSG_WARNING("Pattern finder failed");
1247  // Update output trigger element
1248  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1249  rpcFitResult, tgcFitResult, mdtHits, cscHits,
1250  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1251  continue;
1252  }
1253  patternTimer.stop();
1254 
1255  // Superpoint fit
1256  stationFitterTimer.start();
1257  if(!m_use_new_segmentfit){
1258  sc = m_stationFitter->findSuperPointsSimple(*p_roids,
1259  muonRoad,
1260  tgcFitResult,
1261  trackPatterns,
1262  stgcHits,
1263  mmHits);
1264  }else{
1265  sc = m_stationFitter->findSuperPoints(*p_roids,
1266  muonRoad,
1267  tgcFitResult,
1268  trackPatterns,
1269  stgcHits,
1270  mmHits);
1271  }
1273  m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
1274 
1275  if (!sc.isSuccess()) {
1276  ATH_MSG_WARNING("Super point fitter failed");
1277  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1278  rpcFitResult, tgcFitResult, mdtHits, cscHits,
1279  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1280  continue;
1281  }
1282 
1283  stationFitterTimer.stop();
1284 
1285  // Track fittingh
1286  trackFitterTimer.start();
1287  sc = m_trackFitter->findTracks(*p_roids,
1288  tgcFitResult,
1289  trackPatterns,
1290  muonRoad);
1291 
1292  if (!sc.isSuccess()) {
1293  ATH_MSG_WARNING("Track fitter failed");
1294  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1295  rpcFitResult, tgcFitResult, mdtHits, cscHits,
1296  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1297  continue;
1298  }
1299  trackFitterTimer.stop();
1300 
1301  // fix if eta is strange
1302  const float ETA_LIMIT = 2.8;
1303  const float DELTA_ETA_LIMIT = 1.0;
1304  for (TrigL2MuonSA::TrackPattern& track : trackPatterns) {
1305  float roiEta = (*p_roi)->eta();
1306  if (std::abs(track.pt) > ZERO_LIMIT
1307  && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
1308  track.etaMap = roiEta;
1309  }
1310  }
1311 
1312  // Track extrapolation for ID combined
1313  trackExtraTimer.start();
1314 
1315  sc = m_trackExtrapolator->extrapolateTrack(trackPatterns, m_winPt);
1316 
1317  if (sc != StatusCode::SUCCESS) {
1318  ATH_MSG_WARNING("Track extrapolator failed");
1319  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1320  rpcFitResult, tgcFitResult, mdtHits, cscHits,
1321  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1322  continue;
1323  }
1324  trackExtraTimer.stop();
1325 
1326  storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1327  rpcFitResult, tgcFitResult, mdtHits, cscHits,
1328  stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1329  }
1330  }
1331  // Update monitoring variables
1332  sc = updateMonitor(*p_roi, mdtHits, trackPatterns );
1333  if (sc != StatusCode::SUCCESS) {
1334  ATH_MSG_WARNING("Failed to update monitoring variables");
1335  }
1336 
1337  ++p_roids;
1338  if (p_roids==roids.end()) break;
1339  }
1340 
1341  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMultiTrackSignature success");
1342  return StatusCode::SUCCESS;
1343 }

◆ findMuonSignature()

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

findMuonSignature(), includes reconstract algorithms

Definition at line 388 of file MuFastSteering.cxx.

396 {
397  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignature start");
398  StatusCode sc = StatusCode::SUCCESS;
399 
400  auto prepTimer = Monitored::Timer( "TIME_Data_Preparator" );
401  auto patternTimer = Monitored::Timer( "TIME_Pattern_Finder" );
402  auto stationFitterTimer = Monitored::Timer( "TIME_Station_Fitter" );
403  auto trackFitterTimer = Monitored::Timer( "TIME_Track_Fitter" );
404  auto trackExtraTimer = Monitored::Timer( "TIME_Track_Extrapolator" );
405  auto calibrationTimer = Monitored::Timer( "TIME_Calibration_Streamer" );
406 
407  auto monitorIt = Monitored::Group(m_monTool, prepTimer, patternTimer, stationFitterTimer,
408  trackFitterTimer, trackExtraTimer, calibrationTimer );
409 
410  TrigL2MuonSA::RpcHits rpcHits;
411  TrigL2MuonSA::TgcHits tgcHits;
412  TrigL2MuonSA::MdtRegion mdtRegion;
413  TrigL2MuonSA::MuonRoad muonRoad;
414  TrigL2MuonSA::RpcFitResult rpcFitResult;
415  TrigL2MuonSA::TgcFitResult tgcFitResult;
416  TrigL2MuonSA::MdtHits mdtHits;
417  TrigL2MuonSA::CscHits cscHits;
418  TrigL2MuonSA::StgcHits stgcHits;
419  TrigL2MuonSA::MmHits mmHits;
420 
421  DataVector<const TrigRoiDescriptor>::const_iterator p_roids;
422  DataVector<const xAOD::MuonRoI>::const_iterator p_roi;
423 
424  // muonRoIs = RecMURoIs, roids = MURoIs
425  p_roids = roids.begin();
426  for (p_roi=(muonRoIs).begin(); p_roi!=(muonRoIs).end(); ++p_roi) {
427 
428  prepTimer.start();
429  std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
430  rpcHits.clear();
431  tgcHits.clear();
432  mdtRegion.Clear();
433  muonRoad.Clear();
434  rpcFitResult.Clear();
435  tgcFitResult.Clear();
436  mdtHits.clear();
437  cscHits.clear();
438  stgcHits.clear();
439  mmHits.clear();
440 
441  if ( m_recMuonRoIUtils.isBarrel(*p_roi) ) { // Barrel
442  ATH_MSG_DEBUG("Barrel");
443 
444  muonRoad.setScales(m_scaleRoadBarrelInner,
445  m_scaleRoadBarrelMiddle,
446  m_scaleRoadBarrelOuter);
447 
448  // Data preparation
449  sc = m_dataPreparator->prepareData(ctx,
450  *p_roi,
451  *p_roids,
452  m_insideOut,
453  rpcHits,
454  muonRoad,
455  mdtRegion,
456  rpcFitResult,
457  mdtHits,
458  dynamicDeltaRpc);
459  if (!sc.isSuccess()) {
460  ATH_MSG_WARNING("Data preparation failed");
461  TrigL2MuonSA::TrackPattern trackPattern;
462  trackPatterns.push_back(std::move(trackPattern));
463  // Update output trigger element
464  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
465  rpcFitResult, tgcFitResult, mdtHits, cscHits,
466  stgcHits, mmHits,
467  trackPatterns, outputTracks, outputID, outputMS, ctx);
468  continue;
469  }
470  prepTimer.stop();
471 
472  // Pattern finding
473  patternTimer.start();
474  sc = m_patternFinder->findPatterns(ctx,
475  muonRoad,
476  mdtHits,
477  trackPatterns);
478  if (!sc.isSuccess()) {
479  ATH_MSG_WARNING("Pattern finder failed");
480  // Update output trigger element
481  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
482  rpcFitResult, tgcFitResult, mdtHits, cscHits,
483  stgcHits, mmHits,
484  trackPatterns, outputTracks, outputID, outputMS, ctx);
485  continue;
486  }
487  patternTimer.stop();
488 
489  // Superpoint fit
490  stationFitterTimer.start();
491  sc = m_stationFitter->findSuperPoints(muonRoad,
492  rpcFitResult,
493  trackPatterns);
494  if (!sc.isSuccess()) {
495  ATH_MSG_WARNING("Super point fitter failed");
496  // Update output trigger element
497  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
498  rpcFitResult, tgcFitResult, mdtHits, cscHits,
499  stgcHits, mmHits,
500  trackPatterns, outputTracks, outputID, outputMS, ctx);
501  continue;
502  }
503  stationFitterTimer.stop();
504 
505  // Track fitting
506  trackFitterTimer.start();
507  sc = m_trackFitter->findTracks(*p_roids,
508  rpcFitResult,
509  trackPatterns);
510 
511  if (!sc.isSuccess()) {
512  ATH_MSG_WARNING("Track fitter failed");
513  // Update output trigger element
514  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
515  rpcFitResult, tgcFitResult, mdtHits, cscHits,
516  stgcHits, mmHits,
517  trackPatterns, outputTracks, outputID, outputMS, ctx);
518  continue;
519  }
520  trackFitterTimer.stop();
521 
522  }
523  else { // Endcap
524  ATH_MSG_DEBUG("Endcap");
525 
526  prepTimer.start();
527  // Data preparation
528  sc = m_dataPreparator->prepareData(ctx,
529  *p_roi,
530  *p_roids,
531  m_insideOut,
532  tgcHits,
533  muonRoad,
534  mdtRegion,
535  tgcFitResult,
536  mdtHits,
537  cscHits,
538  stgcHits,
539  mmHits);
540  if (!sc.isSuccess()) {
541  ATH_MSG_WARNING("Data preparation failed");
542  TrigL2MuonSA::TrackPattern trackPattern;
543  trackPatterns.push_back(trackPattern);
544  // Update output trigger element
545  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
546  rpcFitResult, tgcFitResult, mdtHits, cscHits,
547  stgcHits, mmHits,
548  trackPatterns, outputTracks, outputID, outputMS, ctx);
549  continue;
550  }
551  prepTimer.stop();
552 
553  // Pattern finding
554  patternTimer.start();
555  sc = m_patternFinder->findPatterns(ctx,
556  muonRoad,
557  mdtHits,
558  stgcHits,
559  mmHits,
560  trackPatterns);
561 
562  if (!sc.isSuccess()) {
563  ATH_MSG_WARNING("Pattern finder failed");
564  // Update output trigger element
565  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
566  rpcFitResult, tgcFitResult, mdtHits, cscHits,
567  stgcHits, mmHits,
568  trackPatterns, outputTracks, outputID, outputMS, ctx);
569  continue;
570  }
571  patternTimer.stop();
572 
573  // Superpoint fit
574  stationFitterTimer.start();
575  if(!m_use_new_segmentfit){
576  sc = m_stationFitter->findSuperPointsSimple(*p_roids,
577  muonRoad,
578  tgcFitResult,
579  trackPatterns,
580  stgcHits,
581  mmHits);
582  }
583  else{
584  sc = m_stationFitter->findSuperPoints(*p_roids,
585  muonRoad,
586  tgcFitResult,
587  trackPatterns,
588  stgcHits,
589  mmHits);
590  }
592  m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
593 
594  if (!sc.isSuccess()) {
595  ATH_MSG_WARNING("Super point fitter failed");
596  // Update output trigger element
597  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
598  rpcFitResult, tgcFitResult, mdtHits, cscHits,
599  stgcHits, mmHits,
600  trackPatterns, outputTracks, outputID, outputMS, ctx);
601  continue;
602  }
603 
604  stationFitterTimer.stop();
605 
606  // Track fittingh
607  trackFitterTimer.start();
608  sc = m_trackFitter->findTracks(*p_roids,
609  tgcFitResult,
610  trackPatterns,
611  muonRoad);
612 
613  if (!sc.isSuccess()) {
614  ATH_MSG_WARNING("Track fitter failed");
615  // Update output trigger element
616  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
617  rpcFitResult, tgcFitResult, mdtHits, cscHits,
618  stgcHits, mmHits,
619  trackPatterns, outputTracks, outputID, outputMS, ctx);
620  continue;
621  }
622  trackFitterTimer.stop();
623  }
624 
625  // fix if eta is strange
626  const float ETA_LIMIT = 2.8;
627  const float DELTA_ETA_LIMIT = 1.0;
628  const float ZERO_LIMIT = 1.e-5;
629  for (TrigL2MuonSA::TrackPattern& track : trackPatterns) {
630  float roiEta = (*p_roi)->eta();
631  if ( std::abs(track.pt) > ZERO_LIMIT &&
632  ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
633  track.etaMap = roiEta;
634  }
635  }
636 
637  // Track extrapolation for ID combined
638  trackExtraTimer.start();
639 
640  sc = m_trackExtrapolator->extrapolateTrack(trackPatterns, m_winPt);
641 
642  if (sc != StatusCode::SUCCESS) {
643  ATH_MSG_WARNING("Track extrapolator failed");
644  // Update output trigger element
645  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
646  rpcFitResult, tgcFitResult, mdtHits, cscHits,
647  stgcHits, mmHits,
648  trackPatterns, outputTracks, outputID, outputMS, ctx);
649  continue;
650  }
651  trackExtraTimer.stop();
652 
653  // Update monitoring variables
654  sc = updateMonitor(*p_roi, mdtHits, trackPatterns );
655  if (sc != StatusCode::SUCCESS) {
656  ATH_MSG_WARNING("Failed to update monitoring variables");
657  // Update output trigger element
658  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
659  rpcFitResult, tgcFitResult, mdtHits, cscHits,
660  stgcHits, mmHits,
661  trackPatterns, outputTracks, outputID, outputMS, ctx);
662  continue;
663  }
664 
665  // Update output trigger element
666  updateOutputObjects(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
667  rpcFitResult, tgcFitResult, mdtHits, cscHits,
668  stgcHits, mmHits,
669  trackPatterns, outputTracks, outputID, outputMS, ctx);
670 
671 
672  //-----------------------
673  // call the calibration streamer
674  //---------------------------
675  if (m_doCalStream && trackPatterns.size()>0 ) {
676  TrigL2MuonSA::TrackPattern tp = trackPatterns[0];
677  std::vector<uint32_t> localBuffer; // init localBuffer parameter
678  sc = m_calStreamer->createRoiFragment(*p_roi,tp,mdtHits,
679  rpcHits,
680  tgcHits,
681  localBuffer,
682  m_calDataScouting,
683  ctx);
684  if (sc != StatusCode::SUCCESS ) {
685  ATH_MSG_WARNING("Calibration streamer: create Roi Fragment failed");
686  }
687  // if it's a data scouting chain
688  if ( m_calDataScouting ) {
689 
690  ATH_MSG_DEBUG("Retrieved the buffer, with size: " << localBuffer.size());
691 
692  // create the TrigCompositeContainer to store the calibration buffer
693  // add the trigcomposite object to the container outputMuonCal
694  xAOD::TrigComposite* tc = new xAOD::TrigComposite();
695  if (outputMuonCal){
696  outputMuonCal->push_back(tc);
697  ATH_MSG_DEBUG("The size of the TrigCompositeContainer is: " << outputMuonCal->size() );
698  }else{
699  ATH_MSG_ERROR("Trying to fill nullptr container.");
700  return StatusCode::FAILURE;
701  }
702 
703 
704  // set the detail of the trigcomposite object
705  tc->setDetail("muCalibDS", localBuffer );
706  }
707  }
708 
709  ++p_roids;
710  if (p_roids==roids.end()) break;
711  }
712 
713  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignature success");
714  return StatusCode::SUCCESS;
715 }

◆ findMuonSignatureIO()

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

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

Definition at line 722 of file MuFastSteering.cxx.

729 {
730  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignatureIO start");
731  StatusCode sc = StatusCode::SUCCESS;
732  const float ZERO_LIMIT = 1.e-5;
733 
734  auto prepTimer = Monitored::Timer( "TIME_Data_Preparator" );
735  auto patternTimer = Monitored::Timer( "TIME_Pattern_Finder" );
736  auto stationFitterTimer = Monitored::Timer( "TIME_Station_Fitter" );
737  auto trackFitterTimer = Monitored::Timer( "TIME_Track_Fitter" );
738  auto trackExtraTimer = Monitored::Timer( "TIME_Track_Extrapolator" );
739  auto calibrationTimer = Monitored::Timer( "TIME_Calibration_Streamer" );
740 
741  auto monitorIt = Monitored::Group(m_monTool, prepTimer, patternTimer, stationFitterTimer,
742  trackFitterTimer, trackExtraTimer, calibrationTimer );
743 
744  TrigL2MuonSA::RpcHits rpcHits;
745  TrigL2MuonSA::TgcHits tgcHits;
746  TrigL2MuonSA::MdtRegion mdtRegion;
747  TrigL2MuonSA::MuonRoad muonRoad;
748  TrigL2MuonSA::RpcFitResult rpcFitResult;
749  TrigL2MuonSA::TgcFitResult tgcFitResult;
750  TrigL2MuonSA::MdtHits mdtHits;
751  TrigL2MuonSA::CscHits cscHits;
752  TrigL2MuonSA::StgcHits stgcHits;
753  TrigL2MuonSA::MmHits mmHits;
754 
755  DataVector<const TrigRoiDescriptor>::const_iterator p_roids;
756 
757  p_roids = roids.begin();
758  for (const auto p_roi : muonRoIs) {
759  ATH_MSG_DEBUG("roi eta/phi: " << (*p_roi).eta() << "/" << (*p_roi).phi());
760 
761  // idtracks loop
762  if ( (idtracks).empty() ) ATH_MSG_DEBUG("IO TEST: xAOD::TrackParticleContainer has 0 tracks --> Can not use FTF tracks...");
763  else ATH_MSG_DEBUG("IO TEST: xAOD::TrackParticleContainer has " << (idtracks).size() << " tracks --> Start inside-out mode!");
764 
765  std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
766  int idtrack_idx = -1;
767  for (auto idtrack : idtracks) {
768 
769  idtrack_idx++;
770  ATH_MSG_DEBUG("IO TEST: FTF track key:" << m_FTFtrackKey.key() << " pt = " << idtrack->pt()/1000 << " GeV");
771  ATH_MSG_DEBUG("IO TEST: FTF track key:" << m_FTFtrackKey.key() << " eta/phi = " << idtrack->eta() << "/" << idtrack->phi());
772 
773  if(idtrack->pt() < m_ftfminPt) {
774  ATH_MSG_DEBUG("IO TEST: skip FTF track due to pT threshold: " << m_ftfminPt << " MeV");
775  continue;
776  }
777 
778  prepTimer.start();
779  rpcHits.clear();
780  tgcHits.clear();
781  mdtRegion.Clear();
782  muonRoad.Clear();
783  rpcFitResult.Clear();
784  tgcFitResult.Clear();
785  mdtHits.clear();
786  cscHits.clear();
787  stgcHits.clear();
788  mmHits.clear();
789  trackPatterns.clear();
790 
791  sc = m_ftfRoadDefiner->defineRoad(ctx, idtrack, muonRoad);
792  if (!sc.isSuccess()) {
793  ATH_MSG_WARNING("FtfRoadDefiner failed");
794  continue;
795  } else {
796  ATH_MSG_DEBUG("FtfRoadDefiner::defineRoad success");
797  }
798 
799  if ( std::abs(idtrack->eta()) < 1.05 ){
800  ATH_MSG_DEBUG("FTF track at IP is in Barrel: " << idtrack->eta());
801  } else {
802  ATH_MSG_DEBUG("FTF track at IP is in Endcap: " << idtrack->eta());
803  }
804 
805  if ( m_recMuonRoIUtils.isBarrel(p_roi) ) { // Barrel Inside-out
806  ATH_MSG_DEBUG("muonRoad.extFtfMiddleEta Barrel: " << muonRoad.extFtfMiddleEta);
807 
808  ATH_MSG_DEBUG("Barrel algorithm of IOmode starts");
809 
810  muonRoad.setScales(m_scaleRoadBarrelInner,
811  m_scaleRoadBarrelMiddle,
812  m_scaleRoadBarrelOuter);
813 
814  // Data preparation
815  sc = m_dataPreparator->prepareData(ctx,
816  p_roi,
817  *p_roids,
818  m_insideOut,
819  rpcHits,
820  muonRoad,
821  mdtRegion,
822  rpcFitResult,
823  mdtHits,
824  dynamicDeltaRpc);
825  if (!sc.isSuccess()) {
826  ATH_MSG_WARNING("Data preparation failed");
827  continue;
828  } else {
829  ATH_MSG_DEBUG("Data preparation success");
830  }
831  prepTimer.stop();
832 
833  // Pattern finding
834  patternTimer.start();
835  sc = m_patternFinder->findPatterns(ctx,
836  muonRoad,
837  mdtHits,
838  trackPatterns);
839  if (!sc.isSuccess()) {
840  ATH_MSG_WARNING("Pattern finder failed");
841  continue;
842  }
843  patternTimer.stop();
844 
845  // Superpoint fit
846  stationFitterTimer.start();
847  sc = m_stationFitter->findSuperPoints(muonRoad,
848  rpcFitResult,
849  trackPatterns);
850  if (!sc.isSuccess()) {
851  ATH_MSG_WARNING("Super point fitter failed");
852  continue;
853  }
854  stationFitterTimer.stop();
855 
856  // Track fitting
857  trackFitterTimer.start();
858  sc = m_trackFitter->findTracks(*p_roids,
859  rpcFitResult,
860  trackPatterns);
861  if (!sc.isSuccess()) {
862  ATH_MSG_WARNING("Track fitter failed");
863  continue;
864  }
865  trackFitterTimer.stop();
866 
867  } else { // Endcap Inside-out
868  ATH_MSG_DEBUG("muonRoad.extFtfMiddleEta Endcap: " << muonRoad.extFtfMiddleEta);
869  ATH_MSG_DEBUG("Endcap algorithm of IOmode starts");
870 
871  prepTimer.start();
872  // Data preparation
873  sc = m_dataPreparator->prepareData(ctx,
874  p_roi,
875  *p_roids,
876  m_insideOut,
877  tgcHits,
878  muonRoad,
879  mdtRegion,
880  tgcFitResult,
881  mdtHits,
882  cscHits,
883  stgcHits,
884  mmHits);
885  if (!sc.isSuccess()) {
886  ATH_MSG_WARNING("Data preparation failed");
887  continue;
888  } else{
889  ATH_MSG_DEBUG("Data preparation success");
890  }
891  prepTimer.stop();
892 
893  // Pattern finding
894  patternTimer.start();
895  sc = m_patternFinder->findPatterns(ctx,
896  muonRoad,
897  mdtHits,
898  stgcHits,
899  mmHits,
900  trackPatterns);
901  if (!sc.isSuccess()) {
902  ATH_MSG_WARNING("Pattern finder failed");
903  continue;
904  }
905  patternTimer.stop();
906 
907  // Superpoint fit
908  stationFitterTimer.start();
909  sc = m_stationFitter->findSuperPointsSimple(*p_roids,
910  muonRoad,
911  tgcFitResult,
912  trackPatterns,
913  stgcHits,
914  mmHits);
916  m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
917  if (!sc.isSuccess()) {
918  ATH_MSG_WARNING("Super point fitter failed");
919  continue;
920  }
921  stationFitterTimer.stop();
922 
923  // Track fittingh
924  trackFitterTimer.start();
925  sc = m_trackFitter->findTracks(*p_roids,
926  tgcFitResult,
927  trackPatterns,
928  muonRoad);
929  if (!sc.isSuccess()) {
930  ATH_MSG_WARNING("Track fitter failed");
931  continue;
932  }
933  trackFitterTimer.stop();
934 
935  }
936 
937  // fix if eta is strange
938  TrigL2MuonSA::TrackPattern track = trackPatterns.back();
939  const float ETA_LIMIT = 2.8;
940  const float DELTA_ETA_LIMIT = 1.0;
941  float roiEta = (*p_roi).eta();
942  if (std::abs(track.pt) > ZERO_LIMIT
943  && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
944  trackPatterns.back().etaMap = roiEta;
945  }
946 
947  // Update monitoring variables
948  sc = updateMonitor(p_roi, mdtHits, trackPatterns );
949  if (sc != StatusCode::SUCCESS) {
950  ATH_MSG_WARNING("Failed to update monitoring variables");
951  }
952 
953  // Update output trigger element
954  if ( std::abs(trackPatterns.back().pt) > ZERO_LIMIT ) {
955  storeMuonSA(p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
956  rpcFitResult, tgcFitResult, mdtHits, cscHits,
957  stgcHits, mmHits,
958  trackPatterns.back(), outputSAs, ctx);
959  xAOD::L2CombinedMuon* muonCB = new xAOD::L2CombinedMuon();
960  muonCB->makePrivateStore();
961  muonCB->setStrategy(0);
962  muonCB->setErrorFlag(-9);
963  muonCB->setPt(idtrack->pt());
964  muonCB->setEta(idtrack->eta());
965  muonCB->setPhi(idtrack->phi());
966  muonCB->setCharge(idtrack->charge());
967  ElementLink<xAOD::L2StandAloneMuonContainer> muonSAEL(outputSAs, outputSAs.size()-1);
968  muonCB->setMuSATrackLink(muonSAEL);
969  ElementLink<xAOD::TrackParticleContainer> idtrkEL(idtracks, idtrack_idx);
970  muonCB->setIdTrackLink(idtrkEL);
971  outputCBs.push_back(muonCB);
972  }
973 
974  }
975 
976  if(outputSAs.size()==0) {
977  ATH_MSG_DEBUG("outputSAs size = 0 -> push_back dummy");
978  muonRoad.Clear();
979  mdtRegion.Clear();
980  rpcHits.clear();
981  tgcHits.clear();
982  rpcFitResult.Clear();
983  tgcFitResult.Clear();
984  mdtHits.clear();
985  cscHits.clear();
986  stgcHits.clear();
987  mmHits.clear();
988  trackPatterns.clear();
989  TrigL2MuonSA::TrackPattern trackPattern;
990  storeMuonSA(p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
991  rpcFitResult, tgcFitResult, mdtHits, cscHits,
992  stgcHits, mmHits,
993  trackPattern, outputSAs, ctx);
994  xAOD::L2CombinedMuon* muonCB = new xAOD::L2CombinedMuon();
995  muonCB->makePrivateStore();
996  muonCB->setStrategy(-9);
997  muonCB->setErrorFlag(-9);
998  muonCB->setPt(0);
999  muonCB->setEta(99999.);
1000  muonCB->setPhi(99999.);
1001  ElementLink<xAOD::L2StandAloneMuonContainer> muonSAEL(outputSAs, outputSAs.size()-1);
1002  muonCB->setMuSATrackLink(muonSAEL);
1003  outputCBs.push_back(muonCB);
1004  }
1005 
1006 
1007  ATH_MSG_DEBUG("outputSAs size: " << outputSAs.size());
1008  ATH_MSG_DEBUG("idtracks size: " << idtracks.size());
1009  for (auto outputSA : outputSAs){
1010  ATH_MSG_DEBUG("outputSA pt/eta/phi: " << outputSA->pt() << "/" << outputSA->etaMS() << "/" << outputSA->phiMS());
1011  }
1012 
1013  ATH_MSG_DEBUG("outputCBs size: " << outputCBs.size());
1014  for (auto outputCB : outputCBs){
1015  ATH_MSG_DEBUG("outputCB pt/eta/phi: " << outputCB->pt() << "/" << outputCB->eta() << "/" << outputCB->phi());
1016  }
1017 
1018  ++p_roids;
1019  if (p_roids==roids.end()) break;
1020  }
1021 
1022  ATH_MSG_DEBUG("StatusCode MuFastSteering::findMuonSignatureIO success");
1023  return StatusCode::SUCCESS;
1024 }

◆ getRoiSizeForID()

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

Definition at line 1962 of file MuFastSteering.cxx.

1963 {
1964  bool isBarrel = (muonSA->sAddress()==-1) ? true : false;
1965  float eta = muonSA->etaMS();
1966  float phi = muonSA->phiMS();
1967  float pt = muonSA->pt();
1968 
1969  //
1970  const int N_PARAMS = 2;
1971 
1972  //
1973  const float etaMinWin_brl = 0.10;
1974  const float etaMinWin_ec1 = 0.10;
1975  const float etaMinWin_ec2 = 0.10;
1976  const float etaMinWin_ec3 = 0.10;
1977  const float etaMinWin_ecA = 0.10;
1978  const float etaMinWin_ecB = 0.10;
1979 
1980  const float etaMaxWin_brl = 0.20;
1981  const float etaMaxWin_ec1 = 0.20;
1982  const float etaMaxWin_ec2 = 0.20;
1983  const float etaMaxWin_ec3 = 0.20;
1984  const float etaMaxWin_ecA = 0.20;
1985  const float etaMaxWin_ecB = 0.20;
1986 
1987  const float etaParams_brl[N_PARAMS] = { 0.038, 0.284};
1988  const float etaParams_ec1[N_PARAMS] = { 0.011, 0.519};
1989  const float etaParams_ec2[N_PARAMS] = { 0.023, 0.253};
1990  const float etaParams_ec3[N_PARAMS] = { 0.018, 0.519};
1991  const float etaParams_ecA[N_PARAMS] = { 0.010, 0.431};
1992  const float etaParams_ecB[N_PARAMS] = { 0.023, 0.236};
1993 
1994  //
1995  const float phiMinWin_brl = 0.125;
1996  const float phiMinWin_ec1 = 0.125;
1997  const float phiMinWin_ec2 = 0.125;
1998  const float phiMinWin_ec3 = 0.10;
1999  const float phiMinWin_ecA = 0.15;
2000  const float phiMinWin_ecB = 0.15;
2001 
2002  const float phiMaxWin_brl = 0.20;
2003  const float phiMaxWin_ec1 = 0.20;
2004  const float phiMaxWin_ec2 = 0.20;
2005  const float phiMaxWin_ec3 = 0.20;
2006  const float phiMaxWin_ecA = 0.25;
2007  const float phiMaxWin_ecB = 0.20;
2008 
2009  const float phiParams_brl[N_PARAMS] = { 0.000, 0.831};
2010  const float phiParams_ec1[N_PARAMS] = { 0.000, 0.885};
2011  const float phiParams_ec2[N_PARAMS] = { 0.015, 0.552};
2012  const float phiParams_ec3[N_PARAMS] = { 0.008, 0.576};
2013  const float phiParams_ecA[N_PARAMS] = { 0.000, 0.830};
2014  const float phiParams_ecB[N_PARAMS] = { 0.006, 1.331};
2015 
2016  //
2017  float minWin;
2018  float maxWin;
2019  float params[N_PARAMS];
2020  if( isBarrel ) {
2021  if( isEta ) {
2022  memcpy(params,etaParams_brl,sizeof(params));
2023  minWin = etaMinWin_brl;
2024  maxWin = etaMaxWin_brl;
2025  }
2026  else {
2027  memcpy(params,phiParams_brl,sizeof(params));
2028  minWin = phiMinWin_brl;
2029  maxWin = phiMaxWin_brl;
2030  }
2031  }
2032  else { // endcap
2033  xAOD::L2MuonParameters::ECRegions reg = xAOD::L2MuonParameters::whichECRegion(eta,phi);
2034  if( reg == xAOD::L2MuonParameters::ECRegions::WeakBFieldA ) {
2035 
2036  if( isEta ) {
2037  memcpy(params,etaParams_ecA,sizeof(params));
2038  minWin = etaMinWin_ecA;
2039  maxWin = etaMaxWin_ecA;
2040  }
2041  else {
2042  memcpy(params,phiParams_ecA,sizeof(params));
2043  minWin = phiMinWin_ecA;
2044  maxWin = phiMaxWin_ecA;
2045  }
2046  }
2047  else if( reg == xAOD::L2MuonParameters::ECRegions::WeakBFieldB ) {
2048  if( isEta ) {
2049  memcpy(params,etaParams_ecB,sizeof(params));
2050  minWin = etaMinWin_ecB;
2051  maxWin = etaMaxWin_ecB;
2052  }
2053  else {
2054  memcpy(params,phiParams_ecB,sizeof(params));
2055  minWin = phiMinWin_ecB;
2056  maxWin = phiMaxWin_ecB;
2057  }
2058  }
2059  else {
2060  if( std::abs(eta) < 1.5 ) {
2061  if( isEta ) {
2062  memcpy(params,etaParams_ec1,sizeof(params));
2063  minWin = etaMinWin_ec1;
2064  maxWin = etaMaxWin_ec1;
2065  }
2066  else {
2067  memcpy(params,phiParams_ec1,sizeof(params));
2068  minWin = phiMinWin_ec1;
2069  maxWin = phiMaxWin_ec1;
2070  }
2071  }
2072  else if( std::abs(eta) < 2.0 ) {
2073  if( isEta ) {
2074  memcpy(params,etaParams_ec2,sizeof(params));
2075  minWin = etaMinWin_ec2;
2076  maxWin = etaMaxWin_ec2;
2077  }
2078  else {
2079  memcpy(params,phiParams_ec2,sizeof(params));
2080  minWin = phiMinWin_ec2;
2081  maxWin = phiMaxWin_ec2;
2082  }
2083  }
2084  else {
2085  if( isEta ) {
2086  memcpy(params,etaParams_ec3,sizeof(params));
2087  minWin = etaMinWin_ec3;
2088  maxWin = etaMaxWin_ec3;
2089  }
2090  else {
2091  memcpy(params,phiParams_ec3,sizeof(params));
2092  minWin = phiMinWin_ec3;
2093  maxWin = phiMaxWin_ec3;
2094  }
2095  }
2096  }
2097  }
2098 
2099  //
2100  float x = params[0] + params[1] / pt;
2101  float retval = x;
2102  if( x < minWin ) retval = minWin;
2103  if( x > maxWin ) retval = maxWin;
2104 
2105  return retval;
2106 }

◆ handle()

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

Definition at line 167 of file MuFastSteering.cxx.

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

◆ initialize()

StatusCode MuFastSteering::initialize ( )
overridevirtual

Definition at line 31 of file MuFastSteering.cxx.

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

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isClonable()

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

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

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

◆ L2MuonAlgoMap()

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

Definition at line 1945 of file MuFastSteering.cxx.

1946 {
1947  int algoId = 0;
1948  if (name == "MuFastSteering_Muon") {
1949  algoId = xAOD::L2MuonParameters::L2MuonAlgoId::MUONID;
1950  } else if (name == "MuFastSteering_900GeV") {
1951  algoId = xAOD::L2MuonParameters::L2MuonAlgoId::GEV900ID;
1952  } else {
1953  algoId = xAOD::L2MuonParameters::L2MuonAlgoId::NULLID;
1954  }
1955 
1956  return algoId;
1957 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ setFilterPassed()

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

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

◆ stop()

StatusCode MuFastSteering::stop ( )
overridevirtual

Definition at line 149 of file MuFastSteering.cxx.

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

◆ storeIDRoiDescriptor()

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

Definition at line 1853 of file MuFastSteering.cxx.

1857 {
1858 
1859  if (m_fill_FSIDRoI) { // this mode will be used in cosmic run, if ID expert want to run full scan FTF.
1860  TrigRoiDescriptor* IDroiDescriptor = new TrigRoiDescriptor(true);
1861  outputID.push_back(IDroiDescriptor);
1862  return true;
1863  }
1864 
1865  const float ZERO_LIMIT = 1.e-5;
1866 
1867  const double scalePhiWidthForFailure = 2;
1868  const double scaleRoIforZeroPt = 2;
1869 
1870  const xAOD::L2StandAloneMuon* muonSA = outputTracks[0];
1871 
1872  // store TrigRoiDescriptor
1873  if (std::abs(muonSA->pt()) > ZERO_LIMIT ) {
1874 
1875  // patch for the ID RoI descriptor
1876  float phiHalfWidth = 0.1;
1877  float etaHalfWidth = 0.1;
1878 
1879  // 2010 runs
1880  // if ( std::abs(pattern.etaVtx)>1 && std::abs(pattern.etaVtx)<1.5 ) {
1881  // phiHalfWidth = 0.25;
1882  // etaHalfWidth = 0.4;
1883  // } else {
1884  // phiHalfWidth = 0.1;
1885  // etaHalfWidth = 0.15;
1886  // }
1887 
1888  // 2011a tuning
1889  phiHalfWidth = getRoiSizeForID(false,muonSA);
1890  etaHalfWidth = getRoiSizeForID(true, muonSA);
1891 
1892  if (pattern.isTgcFailure || pattern.isRpcFailure)
1893  phiHalfWidth *= scalePhiWidthForFailure;
1894 
1895  TrigRoiDescriptor* IDroiDescriptor = new TrigRoiDescriptor(roids->roiWord(),
1896  roids->l1Id(),
1897  roids->roiId(),
1898  pattern.etaVtx,
1899  pattern.etaVtx - etaHalfWidth,
1900  pattern.etaVtx + etaHalfWidth,
1901  pattern.phiVtx,
1902  pattern.phiVtx - phiHalfWidth,
1903  pattern.phiVtx + phiHalfWidth);
1904 
1905  ATH_MSG_VERBOSE("...TrigRoiDescriptor for ID "
1906  << "pattern.etaVtx/pattern.phiVtx="
1907  << pattern.etaVtx << "/" << pattern.phiVtx);
1908 
1909  ATH_MSG_VERBOSE("will Record an RoiDescriptor for Inner Detector:"
1910  << " phi=" << IDroiDescriptor->phi()
1911  << ", eta=" << IDroiDescriptor->eta());
1912 
1913  outputID.push_back(IDroiDescriptor);
1914 
1915  } else { // pt = 0.
1916 
1917  TrigRoiDescriptor* IDroiDescriptor = new TrigRoiDescriptor(roids->roiWord(),
1918  roids->l1Id(),
1919  roids->roiId(),
1920  roids->eta(),
1921  roids->eta() - (roids->eta() - roids->etaMinus()) * scaleRoIforZeroPt,
1922  roids->eta() + (roids->etaPlus() - roids->eta()) * scaleRoIforZeroPt,
1923  roids->phi(),
1924  CxxUtils::wrapToPi(roids->phi() - CxxUtils::wrapToPi(roids->phiPlus() - roids->phiMinus())/2. * scaleRoIforZeroPt),
1925  CxxUtils::wrapToPi(roids->phi() + CxxUtils::wrapToPi(roids->phiPlus() - roids->phiMinus())/2. * scaleRoIforZeroPt));
1926 
1927  ATH_MSG_VERBOSE("will Record an RoiDescriptor for Inner Detector in case with zero pT:"
1928  << " phi=" << IDroiDescriptor->phi()
1929  << ", phi min=" << IDroiDescriptor->phiMinus()
1930  << ", phi max=" << IDroiDescriptor->phiPlus()
1931  << ", eta=" << IDroiDescriptor->eta()
1932  << ", eta min=" << IDroiDescriptor->etaMinus()
1933  << ", eta max=" << IDroiDescriptor->etaPlus());
1934 
1935  outputID.push_back(IDroiDescriptor);
1936  }
1937 
1938  return true;
1939 }

◆ storeMSRoiDescriptor()

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

Definition at line 1807 of file MuFastSteering.cxx.

1811 {
1812  const float ZERO_LIMIT = 1.e-5;
1813 
1814  const xAOD::L2StandAloneMuon* muonSA = outputTracks[0];
1815 
1816  float mseta = pattern.etaMap;
1817  float msphi = pattern.phiMS;
1818 
1819  // store TrigRoiDescriptor
1820  if (std::abs(muonSA->pt()) < ZERO_LIMIT ) {
1821  mseta = roids->eta();
1822  msphi = roids->phi();
1823  }
1824 
1825  // set width of 0.1 so that ID tracking monitoring works
1826  const float phiHalfWidth = 0.1;
1827  const float etaHalfWidth = 0.1;
1828 
1829  TrigRoiDescriptor* MSroiDescriptor = new TrigRoiDescriptor(roids->roiWord(),
1830  roids->l1Id(),
1831  roids->roiId(),
1832  mseta,
1833  mseta - etaHalfWidth,
1834  mseta + etaHalfWidth,
1835  msphi,
1836  msphi - phiHalfWidth,
1837  msphi + phiHalfWidth);
1838 
1839  ATH_MSG_VERBOSE("...TrigRoiDescriptor for MS "
1840  << "mseta/msphi="
1841  << mseta << "/" << msphi);
1842 
1843  ATH_MSG_VERBOSE("will Record an RoiDescriptor for TrigMoore:"
1844  << " phi=" << MSroiDescriptor->phi()
1845  << ", eta=" << MSroiDescriptor->eta());
1846 
1847  outputMS.push_back(MSroiDescriptor);
1848 
1849  return true;
1850 }

◆ storeMuonSA()

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

1401 {
1402  const float ZERO_LIMIT = 1.e-5;
1403 
1404  const int currentRoIId = roids->roiId();
1405 
1406  const EventIDBase& eventID = ctx.eventID();
1407  auto eventInfo = SG::makeHandle(m_eventInfoKey, ctx);
1408  if (!eventInfo.isValid()) {
1409  ATH_MSG_ERROR("Failed to retrieve xAOD::EventInfo object");
1410  return false;
1411  }
1412 
1413  int inner = 0;
1414  int middle = 1;
1415  int outer = 2;
1416  int ee = 6;
1417  int csc = 7;
1418  int barrelinner = 0;
1419  int endcapinner = 3;
1420  int bee = 8;
1421  int bme = 9;
1422  // int bmg = 10;
1423 
1424  // define inner, middle, outer
1425  if (pattern.s_address==-1) {
1426  inner = xAOD::L2MuonParameters::Chamber::EndcapInner;
1427  middle = xAOD::L2MuonParameters::Chamber::EndcapMiddle;
1428  outer = xAOD::L2MuonParameters::Chamber::EndcapOuter;
1429  ee = xAOD::L2MuonParameters::Chamber::EndcapExtra;
1430  barrelinner = xAOD::L2MuonParameters::Chamber::BarrelInner;
1431  bee = xAOD::L2MuonParameters::Chamber::BEE;
1432  } else {
1433  inner = xAOD::L2MuonParameters::Chamber::BarrelInner;
1434  middle = xAOD::L2MuonParameters::Chamber::BarrelMiddle;
1435  outer = xAOD::L2MuonParameters::Chamber::BarrelOuter;
1436  bme = xAOD::L2MuonParameters::Chamber::BME;
1437  endcapinner = xAOD::L2MuonParameters::Chamber::EndcapInner;
1438  }
1439 
1440  ATH_MSG_DEBUG("### Hit patterns at the Muon Spectrometer ###");
1441  ATH_MSG_DEBUG("pattern#0: # of hits at inner =" << pattern.mdtSegments[inner].size());
1442  ATH_MSG_DEBUG("pattern#0: # of hits at middle =" << pattern.mdtSegments[middle].size());
1443  ATH_MSG_DEBUG("pattern#0: # of hits at outer =" << pattern.mdtSegments[outer].size());
1444  if (pattern.s_address==-1){
1445  ATH_MSG_DEBUG("pattern#0: # of hits at ee =" << pattern.mdtSegments[ee].size());
1446  ATH_MSG_DEBUG("pattern#0: # of hits at endcap barrel inner =" << pattern.mdtSegments[barrelinner].size());
1447  ATH_MSG_DEBUG("pattern#0: # of hits at BEE =" << pattern.mdtSegments[bee].size());
1448  } else {
1449  ATH_MSG_DEBUG("pattern#0: # of hits at BME =" << pattern.mdtSegments[bme].size());
1450  ATH_MSG_DEBUG("pattern#0: # of hits at barrel endcap inner =" << pattern.mdtSegments[endcapinner].size());
1451  }
1452  ATH_MSG_DEBUG("### ************************************* ###");
1453  ATH_MSG_DEBUG("Estimated muon pt = " << pattern.pt << " GeV");
1454 
1455  // ---------
1456  // store xAOD
1457 
1458  xAOD::L2StandAloneMuon* muonSA = new xAOD::L2StandAloneMuon();
1459  muonSA->makePrivateStore();
1460 
1461  // add pT
1462  muonSA->setPt(pattern.pt*pattern.charge);
1463  muonSA->setPtEndcapAlpha(pattern.ptEndcapAlpha*pattern.charge);
1464  muonSA->setPtEndcapBeta(pattern.ptEndcapBeta*pattern.charge);
1465  muonSA->setPtEndcapRadius(pattern.ptEndcapRadius*pattern.charge);
1466  muonSA->setPtCSC(pattern.ptCSC*pattern.charge);
1467 
1468  muonSA->setEta(pattern.etaVtx);
1469  muonSA->setPhi(pattern.phiVtx);
1470  muonSA->setDeltaPt(pattern.deltaPt);
1471  muonSA->setDeltaEta(pattern.deltaEtaVtx);
1472  muonSA->setDeltaPhi(pattern.deltaPhiVtx);
1473 
1474  // add s_address
1475  muonSA->setSAddress(pattern.s_address);
1476 
1477  // add positions at MS
1478  muonSA->setEtaMS(pattern.etaMap);
1479  muonSA->setPhiMS(pattern.phiMS);
1480  muonSA->setDirPhiMS(pattern.phiMSDir);
1481  muonSA->setRMS(pattern.superPoints[inner].R);
1482  muonSA->setZMS(pattern.superPoints[inner].Z);
1483  muonSA->setDirZMS(pattern.superPoints[inner].Alin);
1484 
1485  // add pt variables
1486  // Endcap
1487  muonSA->setEndcapAlpha(pattern.endcapAlpha);
1488  muonSA->setEndcapBeta(pattern.endcapBeta);
1489  muonSA->setEndcapRadius(pattern.endcapRadius3P);
1490  // Barrel
1491  muonSA->setBarrelRadius(pattern.barrelRadius);
1492  muonSA->setBarrelSagitta(pattern.barrelSagitta);
1493 
1494  // store eta and phi used as argument to pT LUT
1495  muonSA->setEtaMap(pattern.etaMap);
1496  muonSA->setPhiMap(pattern.phiMap);
1497  muonSA->setEtaBin(pattern.etaBin);
1498  muonSA->setPhiBin(pattern.phiBin);
1499 
1500  // store TGC/RPC readout failure flags
1501  muonSA->setIsTgcFailure((int)pattern.isTgcFailure);
1502  muonSA->setIsRpcFailure((int)pattern.isRpcFailure);
1503 
1504  // add superpoints
1505  muonSA->setSuperPoint(inner, pattern.superPoints[inner].R, pattern.superPoints[inner].Z,
1506  pattern.superPoints[inner].Alin, pattern.superPoints[inner].Blin, pattern.superPoints[inner].Chi2);
1507  muonSA->setSuperPoint(middle, pattern.superPoints[middle].R, pattern.superPoints[middle].Z,
1508  pattern.superPoints[middle].Alin, pattern.superPoints[middle].Blin, pattern.superPoints[middle].Chi2);
1509  muonSA->setSuperPoint(outer, pattern.superPoints[outer].R, pattern.superPoints[outer].Z,
1510  pattern.superPoints[outer].Alin, pattern.superPoints[outer].Blin, pattern.superPoints[outer].Chi2);
1511  if (pattern.s_address==-1){
1512  muonSA->setSuperPoint(ee, pattern.superPoints[ee].R, pattern.superPoints[ee].Z,
1513  pattern.superPoints[ee].Alin, pattern.superPoints[ee].Blin, pattern.superPoints[ee].Chi2);
1514  muonSA->setSuperPoint(barrelinner, pattern.superPoints[barrelinner].R, pattern.superPoints[barrelinner].Z,
1515  pattern.superPoints[barrelinner].Alin, pattern.superPoints[barrelinner].Blin, pattern.superPoints[barrelinner].Chi2);
1516  muonSA->setSuperPoint(csc, pattern.superPoints[csc].R, pattern.superPoints[csc].Z,
1517  pattern.superPoints[csc].Alin, pattern.superPoints[csc].Blin, pattern.superPoints[csc].Chi2);
1518  } else {
1519  muonSA->setSuperPoint(endcapinner, pattern.superPoints[endcapinner].R, pattern.superPoints[endcapinner].Z,
1520  pattern.superPoints[endcapinner].Alin, pattern.superPoints[endcapinner].Blin, pattern.superPoints[endcapinner].Chi2);
1521  }
1522 
1524  // Below are detailed information
1525 
1526  uint32_t muondetmask = 0;
1527 
1529  muonSA->setAlgoId( L2MuonAlgoMap(name()) );
1531  //muonSA->setTeId( inputTE->getId() ); // move to hltExecute()
1533  muonSA->setLvl1Id( eventInfo->extendedLevel1ID() );
1535  muonSA->setLumiBlock( eventID.lumi_block() );
1537  muonSA->setMuonDetMask( muondetmask );
1539  muonSA->setRoiId( currentRoIId );
1541  muonSA->setRoiSystem( roi->getSource() );
1543  muonSA->setRoiSubsystem( 1 - roi->getHemisphere() );
1545  muonSA->setRoiSector( roi->getSectorID() );
1547  muonSA->setRoiNumber( roi->getRoI() );
1549  muonSA->setRoiThreshold( roi->getThrNumber() );
1551  muonSA->setRoiEta( roi->eta() );
1553  muonSA->setRoiPhi( roi->phi() );
1555  muonSA->setRoIWord( roi->roiWord() );
1556 
1558  muonSA->setRpcHitsCapacity( m_esd_rpc_size );
1559  muonSA->setTgcHitsCapacity( m_esd_tgc_size );
1560  muonSA->setMdtHitsCapacity( m_esd_mdt_size );
1561  muonSA->setCscHitsCapacity( m_esd_csc_size );
1562  muonSA->setStgcClustersCapacity( m_esd_stgc_size );
1563  muonSA->setMmClustersCapacity( m_esd_mm_size );
1564 
1565  // MDT hits
1566  std::vector<std::string> mdtId;
1567  for (const TrigL2MuonSA::MdtHitData& mdtHit : mdtHits) {
1568  if ( mdtHit.isOutlier==0 || mdtHit.isOutlier==1 ) {
1569  muonSA->setMdtHit(mdtHit.OnlineId, mdtHit.isOutlier, mdtHit.Chamber,
1570  mdtHit.R, mdtHit.Z, mdtHit.cPhi0, mdtHit.Residual,
1571  mdtHit.DriftTime, mdtHit.DriftSpace, mdtHit.DriftSigma);
1572  mdtId.push_back(mdtHit.Id.getString());
1573  }
1574  }
1575  SG::AuxElement::Accessor< std::vector<std::string> > accessor_mdthitid( "mdtHitId" );
1576  accessor_mdthitid( *muonSA ) = mdtId;
1577 
1578  //CSC hits
1579  std::vector<float> cscResol;
1580  for (const TrigL2MuonSA::CscHitData& cscHit : cscHits) {
1581  if ( 1/*cscHit.MeasuresPhi==0*/ ){
1582  if ( cscHit.isOutlier==0 || cscHit.isOutlier==1 ) {
1583  muonSA->setCscHit(cscHit.isOutlier, cscHit.Chamber, cscHit.StationName,
1584  cscHit.StationEta, cscHit.StationPhi,
1585  cscHit.ChamberLayer, cscHit.WireLayer, cscHit.MeasuresPhi, cscHit.Strip,
1586  cscHit.eta, cscHit.phi, cscHit.r, cscHit.z,
1587  cscHit.charge, cscHit.time, cscHit.Residual);
1588  cscResol.push_back(cscHit.resolution);
1589  ATH_MSG_VERBOSE("CSC Hits stored in xAOD: "
1590  << "OL=" << cscHit.isOutlier << ","
1591  << "Ch=" << cscHit.Chamber << ","
1592  << "StationName=" << cscHit.StationName << ","
1593  << "StationEta=" << cscHit.StationEta << ","
1594  << "StationPhi=" << cscHit.StationPhi << ","
1595  << "ChamberLayer=" << cscHit.ChamberLayer << ","
1596  << "WireLayer=" << cscHit.WireLayer << ","
1597  << "MeasuresPhi=" << cscHit.MeasuresPhi << ","
1598  << "Strip=" << cscHit.Strip << ","
1599  << "eta=" << cscHit.eta << ","
1600  << "phi=" << cscHit.phi << ","
1601  << "r=" << cscHit.r << ","
1602  << "z=" << cscHit.z << ","
1603  << "charge=" << cscHit.charge << ","
1604  << "Rs=" << cscHit.Residual << ","
1605  << "t=" << cscHit.time);
1606  }
1607  }
1608  }
1609  SG::AuxElement::Accessor< std::vector<float> > accessor_cschitresol( "cscHitResolution" );
1610  accessor_cschitresol( *muonSA ) = cscResol;
1611 
1612  // RPC hits
1613  float sumbeta[8]={0};
1614  float nhit_layer[8]={0};
1615  for (const TrigL2MuonSA::RpcHitData& rpcHit : rpcHits) {
1616  muonSA->setRpcHit(rpcHit.layer, rpcHit.measuresPhi,
1617  rpcHit.x, rpcHit.y, rpcHit.z,
1618  rpcHit.time, rpcHit.distToEtaReadout, rpcHit.distToPhiReadout,
1619  rpcHit.stationName);
1620  ATH_MSG_VERBOSE("RPC hits stored in xAOD: "
1621  << "stationName=" << rpcHit.stationName << ","
1622  << "layer=" << rpcHit.layer << ","
1623  << "measuresPhi=" << rpcHit.measuresPhi << ","
1624  << "x=" << rpcHit.x << ","
1625  << "y=" << rpcHit.y << ","
1626  << "y=" << rpcHit.z);
1627 
1628  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)) );
1629  if(dRMS>0.05) continue;
1630  float muToF = rpcHit.l/1000/(CLHEP::c_light/1000);
1631  float Tprop = rpcHit.distToPhiReadout/1000*4.8;
1632  float beta = rpcHit.l/1000/(muToF+rpcHit.time-Tprop+3.125/2)/(CLHEP::c_light/1000);
1633  sumbeta[rpcHit.layer]=sumbeta[rpcHit.layer]+beta;
1634  nhit_layer[rpcHit.layer]=nhit_layer[rpcHit.layer]+1;
1635  }
1636 
1637  std::vector<float> Avebeta_layer;
1638  for(int i_layer=0;i_layer<8;i_layer++){
1639  if(nhit_layer[i_layer]!=0)Avebeta_layer.push_back( sumbeta[i_layer]/nhit_layer[i_layer] );
1640  }
1641  if(Avebeta_layer.size()>0) muonSA->setBeta( std::accumulate(Avebeta_layer.begin(),Avebeta_layer.end(),0.0)/Avebeta_layer.size() );
1642  else muonSA->setBeta( 9999 );
1643  Avebeta_layer.clear();
1644 
1645  // TGC hits
1646  for (const TrigL2MuonSA::TgcHitData& tgcHit : tgcHits) {
1647  muonSA->setTgcHit(tgcHit.eta, tgcHit.phi, tgcHit.r, tgcHit.z,
1648  tgcHit.width, tgcHit.sta, tgcHit.isStrip,
1649  tgcHit.bcTag, tgcHit.inRoad);
1650  ATH_MSG_VERBOSE("TGC hits stored in xAOD: "
1651  << "eta=" << tgcHit.eta << ","
1652  << "phi=" << tgcHit.phi << ","
1653  << "r=" << tgcHit.r << ","
1654  << "z=" << tgcHit.z << ","
1655  << "width=" << tgcHit.width << ","
1656  << "stationNum=" << tgcHit.sta << ","
1657  << "isStrip=" << tgcHit.isStrip << ","
1658  << "bcTag=" << tgcHit.bcTag << ","
1659  << "inRoad=" << tgcHit.inRoad);
1660  }
1661 
1662 
1663  // sTGC clusters
1664  for(unsigned int i_hit=0; i_hit<stgcHits.size(); i_hit++) {
1665  if ( stgcHits[i_hit].isOutlier==0 || stgcHits[i_hit].isOutlier==1 ) {
1666 
1667 
1668  muonSA->setStgcCluster(stgcHits[i_hit].layerNumber, stgcHits[i_hit].isOutlier, stgcHits[i_hit].channelType,
1669  stgcHits[i_hit].eta, stgcHits[i_hit].phi, stgcHits[i_hit].r, stgcHits[i_hit].z,
1670  stgcHits[i_hit].ResidualR, stgcHits[i_hit].ResidualPhi,
1671  stgcHits[i_hit].stationEta, stgcHits[i_hit].stationPhi, stgcHits[i_hit].stationName);
1672 
1673  ATH_MSG_VERBOSE("sTGC hits stored in xAOD: "
1674  << "eta=" << stgcHits[i_hit].eta << ","
1675  << "phi=" << stgcHits[i_hit].phi << ","
1676  << "r=" << stgcHits[i_hit].r << ","
1677  << "z=" << stgcHits[i_hit].z << ","
1678  << "z=" << stgcHits[i_hit].ResidualR << ","
1679  << "z=" << stgcHits[i_hit].ResidualPhi);
1680  }
1681  }
1682 
1683  // MM clusters
1684  for(unsigned int i_hit=0; i_hit<mmHits.size(); i_hit++) {
1685  if ( mmHits[i_hit].isOutlier==0 || mmHits[i_hit].isOutlier==1 ) {
1686 
1687 
1688  muonSA->setMmCluster(mmHits[i_hit].layerNumber, mmHits[i_hit].isOutlier,
1689  mmHits[i_hit].eta, mmHits[i_hit].phi, mmHits[i_hit].r, mmHits[i_hit].z,
1690  mmHits[i_hit].ResidualR, mmHits[i_hit].ResidualPhi,
1691  mmHits[i_hit].stationEta, mmHits[i_hit].stationPhi, mmHits[i_hit].stationName);
1692 
1693  ATH_MSG_VERBOSE("mm hits stored in xAOD: "
1694  << "eta=" << tgcHits[i_hit].eta << ","
1695  << "phi=" << tgcHits[i_hit].phi << ","
1696  << "r=" << tgcHits[i_hit].r << ","
1697  << "z=" << tgcHits[i_hit].z << ","
1698  << "width=" << tgcHits[i_hit].width << ","
1699  << "stationNum=" << tgcHits[i_hit].sta << ","
1700  << "isStrip=" << tgcHits[i_hit].isStrip << ","
1701  << "bcTag=" << tgcHits[i_hit].bcTag << ","
1702  << "inRoad=" << tgcHits[i_hit].inRoad);
1703  }
1704  }
1705 
1706  // Muon road
1707  for (int i_station=0; i_station<8; i_station++) {
1708  for (int i_sector=0; i_sector<2; i_sector++) {
1709  muonSA->setRoad(i_station, i_sector, muonRoad.aw[i_station][i_sector], muonRoad.bw[i_station][i_sector]);
1710  muonSA->setRegionZ(i_station, i_sector, mdtRegion.zMin[i_station][i_sector], mdtRegion.zMax[i_station][i_sector]);
1711  muonSA->setRegionR(i_station, i_sector, mdtRegion.rMin[i_station][i_sector], mdtRegion.rMax[i_station][i_sector]);
1712  muonSA->setRegionEta(i_station, i_sector, mdtRegion.etaMin[i_station][i_sector], mdtRegion.etaMax[i_station][i_sector]);
1713  muonSA->setChamberType1(i_station, i_sector, mdtRegion.chamberType[i_station][i_sector][0]);
1714  muonSA->setChamberType2(i_station, i_sector, mdtRegion.chamberType[i_station][i_sector][1]);
1715  }
1716  }
1717 
1718  if ( muonRoad.isEndcap ) {
1719  // TGC fit results
1720  if (tgcFitResult.isSuccess ) {
1721  muonSA->setTgcPt(tgcFitResult.tgcPT);
1722 
1723  muonSA->setTgcInn(tgcFitResult.tgcInn[0], tgcFitResult.tgcInn[1],
1724  tgcFitResult.tgcInn[2], tgcFitResult.tgcInn[3]);
1725  muonSA->setTgcInnF(tgcFitResult.tgcInnRhoStd, tgcFitResult.tgcInnRhoNin,
1726  tgcFitResult.tgcInnPhiStd, tgcFitResult.tgcInnPhiNin);
1727 
1728  muonSA->setTgcMid1(tgcFitResult.tgcMid1[0], tgcFitResult.tgcMid1[1],
1729  tgcFitResult.tgcMid1[2], tgcFitResult.tgcMid1[3]);
1730  muonSA->setTgcMid2(tgcFitResult.tgcMid2[0], tgcFitResult.tgcMid2[1],
1731  tgcFitResult.tgcMid2[2], tgcFitResult.tgcMid2[3]);
1732  muonSA->setTgcMidF(tgcFitResult.tgcMidRhoChi2, tgcFitResult.tgcMidRhoNin,
1733  tgcFitResult.tgcMidPhiChi2, tgcFitResult.tgcMidPhiNin);
1734  }
1735  } else {
1736  // RPC fit results
1737  if (rpcFitResult.isSuccess ) {
1738  // Fill middle fit results for the moment
1739 
1740  muonSA->setRpcFitInn(rpcFitResult.phi_inner, rpcFitResult.slope_inner, rpcFitResult.offset_inner);
1741  muonSA->setRpcFitMid(rpcFitResult.phi_middle, rpcFitResult.slope_middle, rpcFitResult.offset_middle);
1742  muonSA->setRpcFitOut(rpcFitResult.phi_outer, rpcFitResult.slope_outer, rpcFitResult.offset_outer);
1743  }
1744  }
1745 
1746  // Store track positions if set of (R, Z, eta, phi) are all available
1747  if (pattern.s_address==-1) { // endcap
1748 
1749  // Inner
1750  if ( std::abs(pattern.superPoints[inner].R) > ZERO_LIMIT && std::abs(pattern.superPoints[inner].Z) > ZERO_LIMIT ) { // if R and Z exist
1751  if ( tgcFitResult.isSuccess && std::abs(tgcFitResult.tgcInn[3]) > ZERO_LIMIT ) { // if phi exist
1752  float theta = std::atan(pattern.superPoints[inner].R/std::abs(pattern.superPoints[inner].Z));
1753  float eta = (std::tan(theta/2.)!=0.)? -std::log(std::tan(theta/2.))*pattern.superPoints[inner].Z/std::abs(pattern.superPoints[inner].Z): 0.;
1754  muonSA->setTrackPosition( pattern.superPoints[inner].R, pattern.superPoints[inner].Z, eta, tgcFitResult.tgcInn[1] );
1755  }
1756  }
1757 
1758  // Middle
1759  if ( std::abs(pattern.superPoints[middle].R) > ZERO_LIMIT && std::abs(pattern.superPoints[middle].Z) > ZERO_LIMIT ) { // if R and Z exist
1760  float phi = 0;
1761  if (tgcFitResult.isSuccess && ( std::abs(tgcFitResult.tgcMid1[3]) > ZERO_LIMIT || std::abs(tgcFitResult.tgcMid2[3]) > ZERO_LIMIT )) { // if phi exist
1762  double phi1 = tgcFitResult.tgcMid1[1];
1763  double phi2 = tgcFitResult.tgcMid2[1];
1764  if ( tgcFitResult.tgcMid1[3]==0. || tgcFitResult.tgcMid2[3]==0. ) {
1765  if ( std::abs(tgcFitResult.tgcMid1[3]) > ZERO_LIMIT ) phi = phi1;
1766  if ( std::abs(tgcFitResult.tgcMid2[3]) > ZERO_LIMIT ) phi = phi2;
1767  } else if( phi1*phi2 < 0 && std::abs(phi1)>(M_PI/2.) ) {
1768  double tmp1 = (phi1>0)? phi1 - M_PI : phi1 + M_PI;
1769  double tmp2 = (phi2>0)? phi2 - M_PI : phi2 + M_PI;
1770  double tmp = (tmp1+tmp2)/2.;
1771  phi = (tmp>0.)? tmp - M_PI : tmp + M_PI;
1772  } else {
1773  phi = (phi2+phi1)/2.;
1774  }
1775  } else {
1776  phi = roi->phi();
1777  }
1778  float theta = std::atan(pattern.superPoints[middle].R/std::abs(pattern.superPoints[middle].Z));
1779  float eta = (std::tan(theta/2.)!=0.)? -std::log(std::tan(theta/2.))*pattern.superPoints[middle].Z/std::abs(pattern.superPoints[middle].Z): 0.;
1780  muonSA->setTrackPosition( pattern.superPoints[middle].R, pattern.superPoints[middle].Z, eta, phi );
1781  }
1782 
1783  } else { // barrel
1784 
1785  // Middle
1786  if ( std::abs(pattern.superPoints[middle].R) > ZERO_LIMIT && std::abs(pattern.superPoints[middle].Z) > ZERO_LIMIT ) { // if R and Z exist
1787  float phi = 0;
1788  if (rpcFitResult.isSuccess) {
1789  phi = rpcFitResult.phi;
1790  } else {
1791  phi = roi->phi();
1792  }
1793  float theta = std::atan(pattern.superPoints[middle].R/std::abs(pattern.superPoints[middle].Z));
1794  float eta = (std::tan(theta/2.)!=0.)? -std::log(std::tan(theta/2.))*pattern.superPoints[middle].Z/std::abs(pattern.superPoints[middle].Z): 0.;
1795  muonSA->setTrackPosition( pattern.superPoints[middle].R, pattern.superPoints[middle].Z, eta, phi );
1796  }
1797 
1798  // Not stored outer position for the moment as the phi is not available
1799 
1800  }
1801  outputTracks.push_back(muonSA);
1802 
1803  return true;
1804 }

◆ sysExecute()

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

Execute an algorithm.

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

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

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

◆ sysInitialize()

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

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

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

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

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

◆ updateMonitor()

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

Update monitoring variables.

Definition at line 2111 of file MuFastSteering.cxx.

2114 {
2115  // initialize monitored variable
2116  auto inner_mdt_hits = Monitored::Scalar("InnMdtHits", -1);
2117  auto middle_mdt_hits = Monitored::Scalar("MidMdtHits", -1);
2118  auto outer_mdt_hits = Monitored::Scalar("OutMdtHits", -1);
2119  auto invalid_rpc_roi_number = Monitored::Scalar("InvalidRpcRoINumber", -1);
2120 
2121  auto efficiency = Monitored::Scalar("Efficiency", 0);
2122  auto sag_inverse = Monitored::Scalar("SagInv", 9999.);
2123  auto address = Monitored::Scalar("Address", 9999.);
2124  auto absolute_pt = Monitored::Scalar("AbsPt", 9999.);
2125  auto sagitta = Monitored::Scalar("Sagitta", 9999.);
2126  auto track_pt = Monitored::Scalar("TrackPt", 9999.);
2127 
2128  std::vector<float> t_eta, t_phi;
2129  std::vector<float> f_eta, f_phi;
2130  std::vector<float> r_inner, r_middle, r_outer;
2131  std::vector<float> f_residuals;
2132 
2133  t_eta.clear();
2134  t_phi.clear();
2135  f_eta.clear();
2136  f_phi.clear();
2137  r_inner.clear();
2138  r_middle.clear();
2139  r_outer.clear();
2140  f_residuals.clear();
2141 
2142  auto track_eta = Monitored::Collection("TrackEta", t_eta);
2143  auto track_phi = Monitored::Collection("TrackPhi", t_phi);
2144  auto failed_eta = Monitored::Collection("FailedRoIEta", f_eta);
2145  auto failed_phi = Monitored::Collection("FailedRoIPhi", f_phi);
2146  auto res_inner = Monitored::Collection("ResInner", r_inner);
2147  auto res_middle = Monitored::Collection("ResMiddle", r_middle);
2148  auto res_outer = Monitored::Collection("ResOuter", r_outer);
2149  auto fit_residuals = Monitored::Collection("FitResiduals", f_residuals);
2150 
2151  auto monitorIt = Monitored::Group(m_monTool, inner_mdt_hits, middle_mdt_hits, outer_mdt_hits,
2152  invalid_rpc_roi_number,
2153  efficiency, sag_inverse, address, absolute_pt, sagitta, track_pt,
2154  track_eta, track_phi, failed_eta, failed_phi,
2155  res_inner, res_middle, res_outer, fit_residuals );
2156 
2157  const float ZERO_LIMIT = 1e-5;
2158 
2159  if( trackPatterns.size() > 0 ) {
2160 
2161  efficiency = 1;
2162 
2163  const TrigL2MuonSA::TrackPattern& pattern = trackPatterns[0];
2164  float norm = 10.;
2165 
2166  float count_inner = 0;
2167  float count_middle = 0;
2168  float count_outer = 0;
2169 
2170  for (const TrigL2MuonSA::MdtHitData& mdtHit : mdtHits) {
2171 
2172  if (std::abs(mdtHit.DriftSpace) < ZERO_LIMIT) continue;
2173 
2174  char st = mdtHit.cType[1];
2175 
2176  if (st=='I') {
2177  count_inner++;
2178  r_inner.push_back(mdtHit.Residual/norm);
2179  if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
2180  }
2181 
2182  if (st=='M') {
2183  count_middle++;
2184  r_middle.push_back(mdtHit.Residual/norm);
2185  if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
2186  }
2187 
2188  if (st=='O') {
2189  count_outer++;
2190  r_outer.push_back(mdtHit.Residual/norm);
2191  if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
2192  }
2193  }
2194 
2195  inner_mdt_hits = count_inner;
2196  middle_mdt_hits = count_middle;
2197  outer_mdt_hits = count_outer;
2198 
2199  track_pt = (std::abs(pattern.pt ) > ZERO_LIMIT)? pattern.charge*pattern.pt: 9999.;
2200  absolute_pt = std::abs(track_pt);
2201 
2202  if ( std::abs(pattern.etaMap) > ZERO_LIMIT || std::abs(pattern.phiMS) > ZERO_LIMIT ) {
2203  t_eta.push_back(pattern.etaMap);
2204  t_phi.push_back(pattern.phiMS);
2205  }
2206  if ( std::abs(pattern.pt ) < ZERO_LIMIT){
2207  f_eta.push_back(roi->eta());
2208  f_phi.push_back(roi->phi());
2209  }
2210 
2211  sagitta = (std::abs(pattern.barrelSagitta) > ZERO_LIMIT)? pattern.barrelSagitta: 9999.;
2212  sag_inverse = (std::abs(pattern.barrelSagitta) > ZERO_LIMIT)? 1./pattern.barrelSagitta: 9999.;
2213  address = pattern.s_address;
2214  }
2215 
2216  return StatusCode::SUCCESS;
2217 }

◆ updateOutputObjects()

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

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

Definition at line 1348 of file MuFastSteering.cxx.

1365 {
1366 
1367  if( trackPatterns.size() > 0 ) {
1368 
1369  const TrigL2MuonSA::TrackPattern& pattern = trackPatterns.back();
1370 
1371  // Update output trigger element
1372  storeMuonSA(roi, roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1373  rpcFitResult, tgcFitResult, mdtHits, cscHits,
1374  stgcHits, mmHits,
1375  pattern, outputTracks, ctx);
1376  storeMSRoiDescriptor(roids, pattern, outputTracks, outputMS);
1377  storeIDRoiDescriptor(roids, pattern, outputTracks, outputID);
1378 
1379  } else {
1380  ATH_MSG_DEBUG("Not update output objects because trackPatterns has no object");
1381  }
1382 
1383  return true;
1384 }

◆ 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 239 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 176 of file MuFastSteering.h.

◆ m_calBufferName

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

Definition at line 240 of file MuFastSteering.h.

◆ m_calBufferSize

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

Definition at line 241 of file MuFastSteering.h.

◆ m_calDataScouting

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

Definition at line 212 of file MuFastSteering.h.

◆ m_calStreamer

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

Definition at line 180 of file MuFastSteering.h.

◆ m_cscsegmaker

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

Definition at line 187 of file MuFastSteering.h.

◆ m_dataPreparator

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

Definition at line 162 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 235 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 211 of file MuFastSteering.h.

◆ m_doEndcapForl2mt

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

Definition at line 231 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 234 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 220 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 219 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 222 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 217 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 221 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 218 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 250 of file MuFastSteering.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

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

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_fill_FSIDRoI

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

Definition at line 244 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 232 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 172 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 264 of file MuFastSteering.h.

◆ m_incidentSvc

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

Definition at line 193 of file MuFastSteering.h.

◆ m_insideOut

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

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

◆ m_monTool

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

Definition at line 288 of file MuFastSteering.h.

◆ m_muCompositeContainerKey

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

Definition at line 272 of file MuFastSteering.h.

◆ m_muFastContainerKey

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

Definition at line 268 of file MuFastSteering.h.

◆ m_muIdContainerKey

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

Definition at line 276 of file MuFastSteering.h.

◆ m_multiTrack

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

Definition at line 230 of file MuFastSteering.h.

◆ m_muMsContainerKey

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

Definition at line 280 of file MuFastSteering.h.

◆ m_outputCBmuonCollKey

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

Definition at line 284 of file MuFastSteering.h.

◆ m_patternFinder

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

Definition at line 164 of file MuFastSteering.h.

◆ m_recMuonRoIUtils

TrigL2MuonSA::RecMuonRoIUtils MuFastSteering::m_recMuonRoIUtils
protected

Definition at line 184 of file MuFastSteering.h.

◆ m_recRoiCollectionKey

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

Definition at line 260 of file MuFastSteering.h.

◆ m_roiCollectionKey

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

Definition at line 254 of file MuFastSteering.h.

◆ m_rpcErrToDebugStream

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

Definition at line 213 of file MuFastSteering.h.

◆ m_run2recRoiCollectionKey

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

Definition at line 258 of file MuFastSteering.h.

◆ m_rWidth_RPC_Failed

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

Definition at line 224 of file MuFastSteering.h.

◆ m_rWidth_TGC_Failed

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

Definition at line 225 of file MuFastSteering.h.

◆ m_scaleRoadBarrelInner

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

Definition at line 196 of file MuFastSteering.h.

◆ m_scaleRoadBarrelMiddle

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

Definition at line 197 of file MuFastSteering.h.

◆ m_scaleRoadBarrelOuter

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

Definition at line 198 of file MuFastSteering.h.

◆ m_stationFitter

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

Definition at line 166 of file MuFastSteering.h.

◆ m_topoRoad

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

Definition at line 233 of file MuFastSteering.h.

◆ m_trackExtrapolator

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

Definition at line 170 of file MuFastSteering.h.

◆ m_trackFitter

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

Definition at line 168 of file MuFastSteering.h.

◆ m_use_endcapInnerFromBarrel

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

Definition at line 214 of file MuFastSteering.h.

◆ m_use_mcLUT

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

Definition at line 200 of file MuFastSteering.h.

◆ m_use_mm

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

Definition at line 204 of file MuFastSteering.h.

◆ m_use_new_segmentfit

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

Definition at line 201 of file MuFastSteering.h.

◆ m_use_RoIBasedDataAccess_CSC

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

Definition at line 208 of file MuFastSteering.h.

◆ m_use_RoIBasedDataAccess_MDT

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

Definition at line 205 of file MuFastSteering.h.

◆ m_use_RoIBasedDataAccess_MM

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

Definition at line 210 of file MuFastSteering.h.

◆ m_use_RoIBasedDataAccess_RPC

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

Definition at line 206 of file MuFastSteering.h.

◆ m_use_RoIBasedDataAccess_STGC

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

Definition at line 209 of file MuFastSteering.h.

◆ m_use_RoIBasedDataAccess_TGC

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

Definition at line 207 of file MuFastSteering.h.

◆ m_use_rpc

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

Definition at line 202 of file MuFastSteering.h.

◆ m_use_stgc

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

Definition at line 203 of file MuFastSteering.h.

◆ m_useRun3Config

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

Definition at line 246 of file MuFastSteering.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_winPt

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

Definition at line 227 of file MuFastSteering.h.

The documentation for this class was generated from the following files:
MuFastSteering::m_use_mm
Gaudi::Property< bool > m_use_mm
Definition: MuFastSteering.h:204
xAOD::L2MuonParameters::ECRegions
ECRegions
Definition: TrigMuonDefs.h:36
MuFastSteering::m_use_RoIBasedDataAccess_CSC
Gaudi::Property< bool > m_use_RoIBasedDataAccess_CSC
Definition: MuFastSteering.h:208
MuFastSteering::m_jobOptionsSvc
ServiceHandle< Gaudi::Interfaces::IOptionsSvc > m_jobOptionsSvc
Definition: MuFastSteering.h:194
mergePhysValFiles.pattern
pattern
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:25
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
xAOD::L2StandAloneMuon_v2::setDeltaEta
void setDeltaEta(float value)
Set error of eta.
beamspotman.r
def r
Definition: beamspotman.py:672
MuFastSteering::m_cscsegmaker
ToolHandle< TrigL2MuonSA::CscSegmentMaker > m_cscsegmaker
Definition: MuFastSteering.h:187
MuFastSteering::storeMuonSA
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
Definition: MuFastSteering.cxx:1386
Muon::nsw::STGTPSegments::moduleIDBits::stationPhi
constexpr uint8_t stationPhi
station Phi 1 to 8
Definition: NSWSTGTPDecodeBitmaps.h:161
xAOD::L2StandAloneMuon_v2::setMmClustersCapacity
void setMmClustersCapacity(const int value)
Set size of storage for MM clusters.
Definition: L2StandAloneMuon_v2.cxx:1296
xAOD::L2CombinedMuon_v1::setStrategy
void setStrategy(int value)
set algorithm strategy flag
TrigL2MuonSA::CscHitData
Definition: CscData.h:14
PlotCalibFromCool.norm
norm
Definition: PlotCalibFromCool.py:100
MuFastSteering::storeIDRoiDescriptor
bool storeIDRoiDescriptor(const TrigRoiDescriptor *roids, const TrigL2MuonSA::TrackPattern &pattern, const DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputID) const
Definition: MuFastSteering.cxx:1853
MuFastSteering::m_dataPreparator
ToolHandle< TrigL2MuonSA::MuFastDataPreparator > m_dataPreparator
Definition: MuFastSteering.h:162
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TrigL2MuonSA::TgcFitResult::tgcMidRhoNin
int tgcMidRhoNin
Definition: TgcFitResult.h:48
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
xAOD::L2StandAloneMuon_v2::setTgcMidF
void setTgcMidF(float rhoChi2, long rhoN, float phiChi2, long phiN)
Definition: L2StandAloneMuon_v2.cxx:1019
TrigL2MuonSA::MuonRoad::setScales
void setScales(double inner, double middle, double outer)
Definition: MuonRoad.h:69
DeMoUpdate.tmp2
string tmp2
Definition: DeMoUpdate.py:1168
TrigL2MuonSA::TgcFitResult::tgcMidPhiNin
int tgcMidPhiNin
Definition: TgcFitResult.h:51
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
xAOD::L2StandAloneMuon_v2::setEtaBin
void setEtaBin(int value)
Set eta bin of pT LUT.
xAOD::L2StandAloneMuon_v2::setEndcapAlpha
void setEndcapAlpha(float value)
Set the fitted value in the endcap.
xAOD::L2StandAloneMuon_v2::etaMS
float etaMS() const
Get the eta at muon spectrometer.
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:138
xAOD::L2StandAloneMuon_v2::setEtaMap
void setEtaMap(float value)
Set eta used to refer pT LUT.
TrigL2MuonSA::RpcFitResult::phi
double phi
Definition: RpcFitResult.h:44
TrigL2MuonSA::RpcHits
std::vector< RpcHitData > RpcHits
Definition: RpcData.h:57
xAOD::L2StandAloneMuon_v2::setRegionEta
void setRegionEta(int station, int sector, float min, float max)
Eta range.
Definition: L2StandAloneMuon_v2.cxx:884
xAOD::TrigComposite
TrigComposite_v1 TrigComposite
Declare the latest version of the class.
Definition: Event/xAOD/xAODTrigger/xAODTrigger/TrigComposite.h:16
MuFastSteering::m_dEtasurrRoI
Gaudi::Property< float > m_dEtasurrRoI
Definition: MuFastSteering.h:235
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
MuFastSteering::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: MuFastSteering.h:250
xAOD::L2CombinedMuon_v1::setPhi
void setPhi(float phi)
Set the azimuthal angle ( ) of the muon.
Definition: L2CombinedMuon_v1.cxx:90
MuFastSteering::m_trackExtrapolator
ToolHandle< TrigL2MuonSA::MuFastTrackExtrapolator > m_trackExtrapolator
Definition: MuFastSteering.h:170
dumpTgcDigiDeadChambers.stationName
dictionary stationName
Definition: dumpTgcDigiDeadChambers.py:30
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
xAOD::L2MuonParameters::NULLID
@ NULLID
Definition: TrigMuonDefs.h:34
TrigL2MuonSA::RpcFitResult::phi_inner
double phi_inner
Definition: RpcFitResult.h:47
xAOD::L2StandAloneMuon_v2::setPhiBin
void setPhiBin(int value)
Set phi bin of pT LUT.
TrigL2MuonSA::RpcFitResult
Definition: RpcFitResult.h:14
xAOD::L2StandAloneMuon_v2
Class describing standalone muons reconstructed in the LVL2 trigger.
Definition: L2StandAloneMuon_v2.h:36
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
MuFastSteering::ITIMER_STATION_FITTER
@ ITIMER_STATION_FITTER
Definition: MuFastSteering.h:50
TrigInDetValidation_menu_test.tc
tc
Definition: TrigInDetValidation_menu_test.py:8
xAOD::L2StandAloneMuon_v2::setAlgoId
void setAlgoId(int value)
python.getProblemFolderFromLogs.st
string st
Definition: getProblemFolderFromLogs.py:45
MuFastSteering::m_trackFitter
ToolHandle< TrigL2MuonSA::MuFastTrackFitter > m_trackFitter
Definition: MuFastSteering.h:168
TrigL2MuonSA::RpcFitResult::offset_middle
double offset_middle
Definition: RpcFitResult.h:53
MuFastSteering::m_calStreamer
ToolHandle< TrigL2MuonSA::MuCalStreamerTool > m_calStreamer
Definition: MuFastSteering.h:180
MuFastSteering::m_outputCBmuonCollKey
SG::WriteHandleKey< xAOD::L2CombinedMuonContainer > m_outputCBmuonCollKey
Definition: MuFastSteering.h:284
MuFastSteering::m_calBufferName
Gaudi::Property< std::string > m_calBufferName
Definition: MuFastSteering.h:240
TrigL2MuonSA::RpcFitResult::Clear
void Clear()
Definition: RpcFitResult.h:19
MuFastSteering::m_recMuonRoIUtils
TrigL2MuonSA::RecMuonRoIUtils m_recMuonRoIUtils
Definition: MuFastSteering.h:184
runITkAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runITkAlign.py:62
AthenaInterprocess::UpdateAfterFork
Definition: Incidents.h:22
CxxUtils::wrapToPi
T wrapToPi(T phi)
Wrap angle in radians to [-pi, pi].
Definition: phihelper.h:24
xAOD::L2StandAloneMuon_v2::setIsRpcFailure
void setIsRpcFailure(int value)
Set flag to record if RPC is properly read.
xAOD::L2MuonParameters::BEE
@ BEE
BEE measurement point.
Definition: TrigMuonDefs.h:24
xAOD::L2MuonParameters::EndcapExtra
@ EndcapExtra
Extra station in the endcap spectrometer.
Definition: TrigMuonDefs.h:22
TrigL2MuonSA::TgcFitResult
Definition: TgcFitResult.h:11
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
xAOD::L2StandAloneMuon_v2::setRoiSubsystem
void setRoiSubsystem(uint32_t value)
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition: AthCommonDataStore.h:380
MuFastSteering::m_backExtrapolatorTool
ToolHandle< ITrigMuonBackExtrapolator > m_backExtrapolatorTool
Handle to MuonBackExtrapolator tool.
Definition: MuFastSteering.h:176
MuFastSteering::m_patternFinder
ToolHandle< TrigL2MuonSA::MuFastPatternFinder > m_patternFinder
Definition: MuFastSteering.h:164
TrigL2MuonSA::MdtHits
std::vector< MdtHitData > MdtHits
Definition: MdtData.h:56
TrigL2MuonSA::TgcHits
std::vector< TgcHitData > TgcHits
Definition: TgcData.h:43
MuFastSteering::storeMSRoiDescriptor
bool storeMSRoiDescriptor(const TrigRoiDescriptor *roids, const TrigL2MuonSA::TrackPattern &pattern, const DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputMS) const
Definition: MuFastSteering.cxx:1807
TrigL2MuonSA::MdtHitData
Definition: MdtData.h:18
TrigL2MuonSA::MuonRoad::bw
double bw[N_STATION][N_SECTOR]
Definition: MuonRoad.h:84
xAOD::L2StandAloneMuon_v2::setTgcInn
void setTgcInn(float eta, float phi, float r, float z)
Set the results of TGC fit.
Definition: L2StandAloneMuon_v2.cxx:959
MuFastSteering::m_topoRoad
Gaudi::Property< bool > m_topoRoad
Definition: MuFastSteering.h:233
test_pyathena.pt
pt
Definition: test_pyathena.py:11
MuFastSteering::findMuonSignature
StatusCode findMuonSignature(const std::vector< const TrigRoiDescriptor * > &roi, const std::vector< const xAOD::MuonRoI * > &muonRoIs, DataVector< xAOD::L2StandAloneMuon > &outputTracks, xAOD::TrigCompositeContainer *outputMuonCal, TrigRoiDescriptorCollection &outputID, TrigRoiDescriptorCollection &outputMS, const bool dynamicDeltaRpc, const EventContext &ctx) const
findMuonSignature(), includes reconstract algorithms
Definition: MuFastSteering.cxx:388
ReadBchFromCrest.begin
begin
Definition: ReadBchFromCrest.py:80
xAOD::L2StandAloneMuon_v2::setMdtHit
void setMdtHit(uint32_t onlineId, int isOutier, int chamber, float r, float z, float phi, float residual, float time, float space, float sigma)
Set the properties of each MDT tube.
Definition: L2StandAloneMuon_v2.cxx:1493
xAOD::L2StandAloneMuon_v2::setPt
void setPt(float pt)
Set the transverse momentum ( ) of the muon.
xAOD::L2MuonParameters::BME
@ BME
BME measurement point.
Definition: TrigMuonDefs.h:25
M_PI
#define M_PI
Definition: ActiveFraction.h:11
TrigRoiDescriptor::roiWord
virtual unsigned int roiWord() const override final
Definition: TrigRoiDescriptor.h:135
MuFastSteering::m_scaleRoadBarrelInner
Gaudi::Property< float > m_scaleRoadBarrelInner
Definition: MuFastSteering.h:196
TrigL2MuonSA::MuonRoad::isEndcap
bool isEndcap
Definition: MuonRoad.h:74
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
xAOD::L2MuonParameters::BarrelInner
@ BarrelInner
Inner station in the barrel spectrometer.
Definition: TrigMuonDefs.h:16
xAOD::MuonRoI_v1::eta
float eta() const
The pseudorapidity ( ) of the muon candidate.
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
MuFastSteering::m_incidentSvc
ServiceHandle< IIncidentSvc > m_incidentSvc
Definition: MuFastSteering.h:193
ParticleTest.tp
tp
Definition: ParticleTest.py:25
MuFastSteering::m_doEndcapForl2mt
Gaudi::Property< bool > m_doEndcapForl2mt
Definition: MuFastSteering.h:231
xAOD::L2StandAloneMuon_v2::setRoiSector
void setRoiSector(uint32_t value)
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
MuFastSteering::m_stationFitter
ToolHandle< TrigL2MuonSA::MuFastStationFitter > m_stationFitter
Definition: MuFastSteering.h:166
TrigL2MuonSA::RpcFitResult::offset_inner
double offset_inner
Definition: RpcFitResult.h:49
xAOD::L2StandAloneMuon_v2::setDeltaPhi
void setDeltaPhi(float value)
Set error of phi.
xAOD::L2StandAloneMuon_v2::setSuperPoint
void setSuperPoint(int chamber, float r, float z, float slope, float intercept=0., float chi2=0.)
Set the properties of one particular super point measurement.
Definition: L2StandAloneMuon_v2.cxx:221
xAOD::L2StandAloneMuon_v2::setPhiMS
void setPhiMS(float value)
Set the phi at muon spectrometer.
TrigL2MuonSA::MdtRegion::Clear
void Clear()
Definition: MdtRegion.h:19
xAOD::L2StandAloneMuon_v2::setEtaMS
void setEtaMS(float value)
Set the eta at muon spectrometer.
xAOD::L2StandAloneMuon_v2::setRpcFitInn
void setRpcFitInn(float phi, float slope, float offset)
Set the results of RPC fit.
Definition: L2StandAloneMuon_v2.cxx:1051
TrigRoiDescriptor
nope - should be used for standalone also, perhaps need to protect the class def bits #ifndef XAOD_AN...
Definition: TrigRoiDescriptor.h:56
xAOD::L2StandAloneMuon_v2::phiMS
float phiMS() const
Get the phi at muon spectrometer.
xAOD::roiEta
setTeId setLumiBlock setRoiId setRoiSubsystem setRoiNumber roiEta
Definition: L2StandAloneMuon_v2.cxx:344
MuFastSteering::m_muMsContainerKey
SG::WriteHandleKey< TrigRoiDescriptorCollection > m_muMsContainerKey
Definition: MuFastSteering.h:280
xAOD::barrelRadius
setSAddress setEtaMS setDirPhiMS setDirZMS barrelRadius
Definition: L2StandAloneMuon_v1.cxx:129
xAOD::L2CombinedMuon_v1::setCharge
void setCharge(float value)
set seeding muon charge
MuFastSteering::m_esd_csc_size
Gaudi::Property< int > m_esd_csc_size
Definition: MuFastSteering.h:220
MuFastSteering::findMuonSignatureIO
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
findMuonSignatureIO(), includes reconstract algorithms for inside-out mode
Definition: MuFastSteering.cxx:722
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
MuFastSteering::m_FTFtrackKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_FTFtrackKey
Definition: MuFastSteering.h:264
xAOD::MuonRoI_v1::getHemisphere
Hemisphere getHemisphere() const
Returns the hemisphere that detected the muon candidate.
Definition: MuonRoI_v1.cxx:220
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
MuonR4::to_string
std::string to_string(const SectorProjector proj)
Definition: MsTrackSeeder.cxx:66
MuFastSteering::m_use_rpc
Gaudi::Property< bool > m_use_rpc
Definition: MuFastSteering.h:202
TrigL2MuonSA::RpcFitResult::offset_outer
double offset_outer
Definition: RpcFitResult.h:57
AthenaInterprocess::UpdateAfterFork::workerID
int workerID() const
assigned worker ID from processing unit
Definition: Incidents.h:40
TrigL2MuonSA::CscHits
std::vector< CscHitData > CscHits
Definition: CscData.h:40
x
#define x
xAOD::L2StandAloneMuon_v2::setRMS
void setRMS(float value)
Set the R at muon spectrometer.
xAOD::L2MuonParameters::MUONID
@ MUONID
Definition: TrigMuonDefs.h:31
TrigL2MuonSA::MuonRoad::aw
double aw[N_STATION][N_SECTOR]
Definition: MuonRoad.h:83
TrigL2MuonSA::MdtRegion
Definition: MdtRegion.h:15
xAOD::L2CombinedMuon_v1::setEta
void setEta(float eta)
Set the pseudorapidity ( ) of the muon.
Definition: L2CombinedMuon_v1.cxx:83
MuFastSteering::getRoiSizeForID
float getRoiSizeForID(bool isEta, const xAOD::L2StandAloneMuon *muonSA) const
Definition: MuFastSteering.cxx:1962
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
xAOD::L2StandAloneMuon_v2::setTgcHitsCapacity
void setTgcHitsCapacity(int value)
Set size of storage for TGC hits.
Definition: L2StandAloneMuon_v2.cxx:1205
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:74
xAOD::L2StandAloneMuon_v2::setTgcInnF
void setTgcInnF(float rhoStd, long rhoN, float phiStd, long phiN)
Definition: L2StandAloneMuon_v2.cxx:974
MuFastSteering::m_fill_FSIDRoI
Gaudi::Property< bool > m_fill_FSIDRoI
Definition: MuFastSteering.h:244
xAOD::L2CombinedMuon_v1
Class describing combined muon reconstructed in the LVL2 trigger.
Definition: L2CombinedMuon_v1.h:41
MuFastSteering::m_doCalStream
Gaudi::Property< bool > m_doCalStream
Definition: MuFastSteering.h:211
TrigL2MuonSA::TrackPattern
Definition: TrackData.h:16
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
xAOD::L2StandAloneMuon_v2::setPtEndcapBeta
void setPtEndcapBeta(float value)
LArCellBinning_test.retval
def retval
Definition: LArCellBinning_test.py:112
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
MuFastSteering::m_use_RoIBasedDataAccess_RPC
Gaudi::Property< bool > m_use_RoIBasedDataAccess_RPC
Definition: MuFastSteering.h:206
xAOD::L2StandAloneMuon_v2::setBeta
void setBeta(float value)
Set beta.
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
MuFastSteering::m_calDataScouting
Gaudi::Property< bool > m_calDataScouting
Definition: MuFastSteering.h:212
MuFastSteering::m_recRoiCollectionKey
SG::ReadHandleKey< xAOD::MuonRoIContainer > m_recRoiCollectionKey
Definition: MuFastSteering.h:260
MuFastSteering::ITIMER_CALIBRATION_STREAMER
@ ITIMER_CALIBRATION_STREAMER
Definition: MuFastSteering.h:53
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
xAOD::L2StandAloneMuon_v2::setEta
void setEta(float eta)
Set the pseudorapidity ( ) of the muon.
Definition: L2StandAloneMuon_v2.cxx:83
efficiency
void efficiency(std::vector< double > &bins, std::vector< double > &values, const std::vector< std::string > &files, const std::string &histname, const std::string &tplotname, const std::string &label="")
Definition: dependence.cxx:128
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
MuFastSteering::updateMonitor
StatusCode updateMonitor(const xAOD::MuonRoI *roi, const TrigL2MuonSA::MdtHits &mdtHits, std::vector< TrigL2MuonSA::TrackPattern > &trackPatterns) const
Update monitoring variables.
Definition: MuFastSteering.cxx:2111
AthCommonDataStore
Definition: AthCommonDataStore.h:52
MuFastSteering::ITIMER_DATA_PREPARATOR
@ ITIMER_DATA_PREPARATOR
Definition: MuFastSteering.h:48
MuFastSteering::m_useRun3Config
Gaudi::Property< bool > m_useRun3Config
Definition: MuFastSteering.h:246
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::L2StandAloneMuon_v2::setRoad
void setRoad(int station, int sector, float aw, float bw)
Road.
Definition: L2StandAloneMuon_v2.cxx:752
TrigL2MuonSA::TgcFitResult::tgcMid2
float tgcMid2[4]
Definition: TgcFitResult.h:46
TrigL2MuonSA::MdtRegion::rMax
double rMax[N_STATION][N_SECTOR]
Definition: MdtRegion.h:40
TrigL2MuonSA::TgcFitResult::isSuccess
bool isSuccess
Definition: TgcFitResult.h:39
TrigL2MuonSA::RpcFitResult::slope_inner
double slope_inner
Definition: RpcFitResult.h:48
MuFastSteering::m_use_stgc
Gaudi::Property< bool > m_use_stgc
Definition: MuFastSteering.h:203
MuFastSteering::m_multiTrack
Gaudi::Property< bool > m_multiTrack
Definition: MuFastSteering.h:230
xAOD::L2StandAloneMuon_v2::setPhi
void setPhi(float phi)
Set the azimuthal angle ( ) of the muon.
Definition: L2StandAloneMuon_v2.cxx:90
xAOD::L2StandAloneMuon_v2::setBarrelSagitta
void setBarrelSagitta(float value)
Set the fitted sagitta of the muon in the barrel.
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
xAOD::L2StandAloneMuon_v2::sAddress
int sAddress() const
Get the station address of the muon.
MuFastSteering::m_scaleRoadBarrelMiddle
Gaudi::Property< float > m_scaleRoadBarrelMiddle
Definition: MuFastSteering.h:197
xAOD::L2StandAloneMuon_v2::setMmCluster
void setMmCluster(const unsigned int layer, const int isOutlier, const float eta, const float phi, const float r, const float z, const float residualR, const float residualPhi, const int stationEta, const int stationPhi, const int stationName)
Set MM hits.
Definition: L2StandAloneMuon_v2.cxx:1737
MuFastSteering::m_use_new_segmentfit
Gaudi::Property< bool > m_use_new_segmentfit
Definition: MuFastSteering.h:201
xAOD::L2StandAloneMuon_v2::setSAddress
void setSAddress(int value)
Set the station address of the muon.
TrigL2MuonSA::MuonRoad
Definition: MuonRoad.h:20
z
#define z
MuFastSteering::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: MuFastSteering.h:288
xAOD::L2StandAloneMuon_v2::setRoiSystem
void setRoiSystem(uint32_t value)
MuFastSteering::m_ftfminPt
Gaudi::Property< float > m_ftfminPt
Definition: MuFastSteering.h:232
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
TrigL2MuonSA::TgcFitResult::Clear
void Clear()
Definition: TgcFitResult.h:16
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
TrigL2MuonSA::TgcFitResult::tgcInnRhoNin
int tgcInnRhoNin
Definition: TgcFitResult.h:57
xAOD::L2StandAloneMuon_v2::setRoiId
void setRoiId(uint32_t value)
xAOD::L2StandAloneMuon_v2::setChamberType2
void setChamberType2(int station, int sector, int chamberType)
Definition: L2StandAloneMuon_v2.cxx:724
xAOD::L2StandAloneMuon_v2::setPtEndcapAlpha
void setPtEndcapAlpha(float value)
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
TrigL2MuonSA::RecMuonRoIUtils::isBarrel
bool isBarrel(const LVL1::RecMuonRoI *p_roi) const
Definition: RecMuonRoIUtils.h:19
TrigL2MuonSA::RpcFitResult::slope_middle
double slope_middle
Definition: RpcFitResult.h:52
xAOD::MuonRoI_v1
Class describing a LVL1 muon region of interest.
Definition: MuonRoI_v1.h:29
WeakBFieldA
@ WeakBFieldA
Definition: MuFastSteering.h:42
xAOD::MuonRoI_v1::getSource
RoISource getSource() const
Returns the system that detected the muon candidate.
Definition: MuonRoI_v1.cxx:202
MuFastSteering::findMultiTrackSignature
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
findMultiTrackSignature(), includes reconstract algorithms for multi-track mode
Definition: MuFastSteering.cxx:1030
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TrigRoiDescriptor::l1Id
virtual unsigned int l1Id() const override final
Definition: TrigRoiDescriptor.h:134
MuFastSteering::m_roiCollectionKey
SG::ReadHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey
Definition: MuFastSteering.h:254
TrigL2MuonSA::TgcFitResult::tgcMid1
float tgcMid1[4]
Definition: TgcFitResult.h:45
TrigL2MuonSA::TgcHitData
Definition: TgcData.h:14
TrigL2MuonSA::RpcFitResult::phi_middle
double phi_middle
Definition: RpcFitResult.h:51
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
MuFastSteering::m_use_endcapInnerFromBarrel
Gaudi::Property< bool > m_use_endcapInnerFromBarrel
Definition: MuFastSteering.h:214
Handler::svc
AthROOTErrorHandlerSvc * svc
Definition: AthROOTErrorHandlerSvc.cxx:10
MuFastSteering::m_muIdContainerKey
SG::WriteHandleKey< TrigRoiDescriptorCollection > m_muIdContainerKey
Definition: MuFastSteering.h:276
MuFastSteering::L2MuonAlgoMap
int L2MuonAlgoMap(const std::string &name) const
Definition: MuFastSteering.cxx:1945
TrigL2MuonSA::MdtRegion::etaMin
double etaMin[N_STATION][N_SECTOR]
Definition: MdtRegion.h:41
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:49
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
xAOD::MuonRoI_v1::getRoI
int getRoI() const
Get the "RoI number" (position inside the sector)
Definition: MuonRoI_v1.cxx:89
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
TrigL2MuonSA::TgcFitResult::tgcInnRhoStd
float tgcInnRhoStd
Definition: TgcFitResult.h:56
xAOD::L2StandAloneMuon_v2::setCscHit
void setCscHit(int isOutlier, int chamber, uint32_t stationName, int stationEta, int stationPhi, int chamberLayer, int wireLayer, int measuresPhi, int strip, float eta, float phi, float r, float z, int charge, float time, float residual)
Set the properties of each CSC tube.
Definition: L2StandAloneMuon_v2.cxx:1651
TrigL2MuonSA::RpcHitData
Definition: RpcData.h:14
xAOD::L2StandAloneMuon_v2::setRegionZ
void setRegionZ(int station, int sector, float min, float max)
Z range.
Definition: L2StandAloneMuon_v2.cxx:796
xAOD::L2StandAloneMuon_v2::setRpcFitOut
void setRpcFitOut(float phi, float slope, float offset)
Definition: L2StandAloneMuon_v2.cxx:1077
xAOD::L2StandAloneMuon_v2::setMuonDetMask
void setMuonDetMask(uint32_t value)
ZERO_LIMIT
const float ZERO_LIMIT
Definition: VP1TriggerHandleL2.cxx:37
TrigL2MuonSA::RpcFitResult::phi_outer
double phi_outer
Definition: RpcFitResult.h:55
xAOD::L2StandAloneMuon_v2::setChamberType1
void setChamberType1(int station, int sector, int chamberType)
Set the muon road information.
Definition: L2StandAloneMuon_v2.cxx:697
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
MuFastSteering::m_esd_rpc_size
Gaudi::Property< int > m_esd_rpc_size
Definition: MuFastSteering.h:217
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
xAOD::L2StandAloneMuon_v2::setStgcCluster
void setStgcCluster(const unsigned int layer, const int isOutlier, const int type, const float eta, const float phi, const float r, const float z, const float residualR, const float residualPhi, const int stationEta, const int stationPhi, const int stationName)
Set sTGC hits.
Definition: L2StandAloneMuon_v2.cxx:1698
xAOD::L2MuonParameters::GEV900ID
@ GEV900ID
Definition: TrigMuonDefs.h:31
MuFastSteering::m_insideOut
Gaudi::Property< bool > m_insideOut
Definition: MuFastSteering.h:229
TrigL2MuonSA::TgcFitResult::tgcMidRhoChi2
float tgcMidRhoChi2
Definition: TgcFitResult.h:47
xAOD::L2StandAloneMuon_v2::setIsTgcFailure
void setIsTgcFailure(int value)
Set flag to record if TGC is properly read.
xAOD::L2MuonParameters::EndcapMiddle
@ EndcapMiddle
Middle station in the endcap spectrometer.
Definition: TrigMuonDefs.h:20
dumpTgcDigiThreshold.isStrip
list isStrip
Definition: dumpTgcDigiThreshold.py:33
MuFastSteering::m_use_RoIBasedDataAccess_MM
Gaudi::Property< bool > m_use_RoIBasedDataAccess_MM
Definition: MuFastSteering.h:210
xAOD::L2StandAloneMuon_v2::setEndcapBeta
void setEndcapBeta(float value)
Set the fitted value in the endcap.
xAOD::L2CombinedMuon_v1::setIdTrackLink
void setIdTrackLink(const ElementLink< xAOD::TrackParticleContainer > &link)
set ID track used to make the CB muon
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
MuFastSteering::m_esd_tgc_size
Gaudi::Property< int > m_esd_tgc_size
Definition: MuFastSteering.h:218
xAOD::L2StandAloneMuon_v2::setDirPhiMS
void setDirPhiMS(float value)
Set tan phi at muon spectrometer.
xAOD::L2StandAloneMuon_v2::setRpcHitsCapacity
void setRpcHitsCapacity(int value)
Size of storage to be reserved.
Definition: L2StandAloneMuon_v2.cxx:1184
xAOD::L2StandAloneMuon_v2::setBarrelRadius
void setBarrelRadius(float value)
Set the fitted radius of the muon in the barrel.
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::AuxElement::makePrivateStore
void makePrivateStore()
Create a new (empty) private store for this object.
Definition: AuxElement.cxx:192
xAOD::L2StandAloneMuon_v2::setRpcHit
void setRpcHit(uint32_t layer, uint32_t measuresPhi, float x, float y, float z, float time, float distEta, float distPhi, const std::string &stationName)
Set RPC hits.
Definition: L2StandAloneMuon_v2.cxx:1341
python.PhysicalConstants.c_light
float c_light
Definition: PhysicalConstants.py:73
xAOD::L2StandAloneMuon_v2::setMdtHitsCapacity
void setMdtHitsCapacity(int value)
Set size of storage for MDT hits.
Definition: L2StandAloneMuon_v2.cxx:1226
MuFastSteering::m_ftfRoadDefiner
ToolHandle< TrigL2MuonSA::FtfRoadDefiner > m_ftfRoadDefiner
Definition: MuFastSteering.h:172
xAOD::L2CombinedMuon
L2CombinedMuon_v1 L2CombinedMuon
Define the latest version of the muon CB class.
Definition: L2CombinedMuon.h:15
TrigL2MuonSA::TgcFitResult::tgcInn
float tgcInn[4]
Definition: TgcFitResult.h:55
MuFastSteering::ITIMER_TRACK_FITTER
@ ITIMER_TRACK_FITTER
Definition: MuFastSteering.h:51
RTTAlgmain.address
address
Definition: RTTAlgmain.py:55
MuFastSteering::m_scaleRoadBarrelOuter
Gaudi::Property< float > m_scaleRoadBarrelOuter
Definition: MuFastSteering.h:198
AthenaInterprocess::UpdateAfterFork::type
static const std::string & type()
Incident type.
Definition: Incidents.h:49
MuFastSteering::m_rWidth_TGC_Failed
Gaudi::Property< double > m_rWidth_TGC_Failed
Definition: MuFastSteering.h:225
xAOD::L2CombinedMuon_v1::setMuSATrackLink
void setMuSATrackLink(const ElementLink< xAOD::L2StandAloneMuonContainer > &link)
set SA muon used to make the CB muon
MuFastSteering::m_winPt
Gaudi::Property< double > m_winPt
Definition: MuFastSteering.h:227
TrigRoiDescriptor::roiId
virtual unsigned int roiId() const override final
these quantities probably don't need to be used any more
Definition: TrigRoiDescriptor.h:133
TrigL2MuonSA::MdtRegion::zMin
double zMin[N_STATION][N_SECTOR]
Definition: MdtRegion.h:34
xAOD::L2CombinedMuon_v1::setPt
void setPt(float pt)
Set the transverse momentum ( ) of the muon.
xAOD::L2StandAloneMuon_v2::setRoiEta
void setRoiEta(float value)
MuFastSteering::m_dPhisurrRoI
Gaudi::Property< float > m_dPhisurrRoI
Definition: MuFastSteering.h:234
xAOD::L2StandAloneMuon_v2::setZMS
void setZMS(float value)
Set the Z at muon spectrometer.
xAOD::L2StandAloneMuon_v2::setRoiThreshold
void setRoiThreshold(uint32_t value)
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
TrigL2MuonSA::MdtRegion::zMax
double zMax[N_STATION][N_SECTOR]
Definition: MdtRegion.h:38
MuFastSteering::updateOutputObjects
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
Called at the end of the algorithm processing to set the steering navigation properly.
Definition: MuFastSteering.cxx:1348
xAOD::L2StandAloneMuon_v2::setRpcFitMid
void setRpcFitMid(float phi, float slope, float offset)
Definition: L2StandAloneMuon_v2.cxx:1064
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
TrigL2MuonSA::RpcFitResult::isSuccess
bool isSuccess
Definition: RpcFitResult.h:38
matchingRecRoI
const LVL1::RecMuonRoI * matchingRecRoI(uint32_t roiWord, const DataVector< LVL1::RecMuonRoI > &collection)
Definition: MuFastSteering.cxx:200
RoiDescriptor::etaPlus
virtual double etaPlus() const override final
gets eta at zedPlus
Definition: RoiDescriptor.h:115
TrigL2MuonSA::TgcFitResult::tgcPT
float tgcPT
Definition: TgcFitResult.h:63
MuFastSteering::ITIMER_TRACK_EXTRAPOLATOR
@ ITIMER_TRACK_EXTRAPOLATOR
Definition: MuFastSteering.h:52
xAOD::L2StandAloneMuon_v2::setTgcPt
void setTgcPt(float value)
a
TList * a
Definition: liststreamerinfos.cxx:10
TrigL2MuonSA::MmHits
std::vector< MmHitData > MmHits
Definition: MmData.h:47
columnar::empty
bool empty() const noexcept
Definition: ObjectRange.h:167
h
Base_Fragment.width
width
Definition: Sherpa_i/share/common/Base_Fragment.py:59
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
RoiDescriptor::phi
virtual double phi() const override final
Methods to retrieve data members.
Definition: RoiDescriptor.h:100
TrigL2MuonSA::MdtRegion::rMin
double rMin[N_STATION][N_SECTOR]
Definition: MdtRegion.h:39
xAOD::L2MuonParameters::EndcapInner
@ EndcapInner
Inner station in the endcap spectrometer.
Definition: TrigMuonDefs.h:19
TrigRoiDescriptorCollection
Definition: TrigRoiDescriptorCollection.h:21
xAOD::L2MuonParameters::BarrelOuter
@ BarrelOuter
Outer station in the barrel spectrometer.
Definition: TrigMuonDefs.h:18
TrigL2MuonSA::StgcHits
std::vector< StgcHitData > StgcHits
Definition: StgcData.h:49
xAOD::L2StandAloneMuon_v2::setRegionR
void setRegionR(int station, int sector, float min, float max)
R range.
Definition: L2StandAloneMuon_v2.cxx:840
DEBUG
#define DEBUG
Definition: page_access.h:11
bcTag
unsigned bcTag(unsigned bcBitMap)
Definition: TgcByteStreamData.h:359
MuFastSteering::m_use_mcLUT
Gaudi::Property< bool > m_use_mcLUT
Definition: MuFastSteering.h:200
MuFastSteering::m_muFastContainerKey
SG::WriteHandleKey< xAOD::L2StandAloneMuonContainer > m_muFastContainerKey
Definition: MuFastSteering.h:268
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
xAOD::L2StandAloneMuon_v2::setRoiNumber
void setRoiNumber(uint32_t value)
MuFastSteering::m_run2recRoiCollectionKey
SG::ReadHandleKey< DataVector< LVL1::RecMuonRoI > > m_run2recRoiCollectionKey
Definition: MuFastSteering.h:258
python.LArCondContChannels.isBarrel
isBarrel
Definition: LArCondContChannels.py:659
xAOD::L2StandAloneMuon_v2::setLvl1Id
void setLvl1Id(uint32_t value)
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
RoiDescriptor::eta
virtual double eta() const override final
Definition: RoiDescriptor.h:101
xAOD::L2StandAloneMuon_v2::setPtCSC
void setPtCSC(float value)
xAOD::L2StandAloneMuon_v2::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
WeakBFieldB
@ WeakBFieldB
Definition: MuFastSteering.h:42
TrigL2MuonSA::RpcFitResult::slope_outer
double slope_outer
Definition: RpcFitResult.h:56
MuFastSteering::ITIMER_PATTERN_FINDER
@ ITIMER_PATTERN_FINDER
Definition: MuFastSteering.h:49
TrigRoiDescriptor
Athena::TPCnvVers::Current TrigRoiDescriptor
Definition: TrigSteeringEventTPCnv.cxx:68
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
xAOD::L2StandAloneMuon_v2::setRoIWord
void setRoIWord(uint32_t value)
Set the RoI ID of the seeding LVL1 muon.
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
MuFastSteering::m_rWidth_RPC_Failed
Gaudi::Property< double > m_rWidth_RPC_Failed
Definition: MuFastSteering.h:224
TrigL2MuonSA::MuonRoad::extFtfMiddleEta
double extFtfMiddleEta
Definition: MuonRoad.h:92
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
MuFastSteering::m_calBufferSize
Gaudi::Property< int > m_calBufferSize
Definition: MuFastSteering.h:241
xAOD::MuonRoI_v1::getSectorID
int getSectorID() const
Get the sector ID number.
Definition: MuonRoI_v1.cxx:133
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
MuFastSteering::m_use_RoIBasedDataAccess_MDT
Gaudi::Property< bool > m_use_RoIBasedDataAccess_MDT
Definition: MuFastSteering.h:205
PowhegControl_ttFCNC_NLO.params
params
Definition: PowhegControl_ttFCNC_NLO.py:226
TrigL2MuonSA::MdtRegion::etaMax
double etaMax[N_STATION][N_SECTOR]
Definition: MdtRegion.h:42
RoiDescriptor::phiPlus
virtual double phiPlus() const override final
gets phiPlus
Definition: RoiDescriptor.h:118
Muon::nsw::STGTPSegments::moduleIDBits::stationEta
constexpr uint8_t stationEta
1 to 3
Definition: NSWSTGTPDecodeBitmaps.h:159
xAOD::L2StandAloneMuon_v2::setTgcHit
void setTgcHit(float eta, float phi, float r, float z, float width, int stationNum, bool isStrip, int bcTag, bool inRoad)
Set TGC hits.
Definition: L2StandAloneMuon_v2.cxx:1376
xAOD::L2StandAloneMuon_v2::setCscHitsCapacity
void setCscHitsCapacity(int value)
Set size of storage for CSC hits.
Definition: L2StandAloneMuon_v2.cxx:1247
xAOD::L2StandAloneMuon
L2StandAloneMuon_v2 L2StandAloneMuon
Define the latest version of the muon SA class.
Definition: L2StandAloneMuon.h:17
TrigL2MuonSA::TgcFitResult::tgcInnPhiNin
int tgcInnPhiNin
Definition: TgcFitResult.h:60
RoiDescriptor::etaMinus
virtual double etaMinus() const override final
gets eta at zMinus
Definition: RoiDescriptor.h:116
xAOD::L2StandAloneMuon_v2::setStgcClustersCapacity
void setStgcClustersCapacity(const int value)
Set size of storage for sTGC clusters.
Definition: L2StandAloneMuon_v2.cxx:1275
TrigL2MuonSA::TgcFitResult::tgcMidPhiChi2
float tgcMidPhiChi2
Definition: TgcFitResult.h:50
MuonParameters::beta
@ beta
Definition: MuonParamDefs.h:144
xAOD::L2StandAloneMuon_v2::setPtEndcapRadius
void setPtEndcapRadius(float value)
xAOD::L2StandAloneMuon_v2::setDirZMS
void setDirZMS(float value)
Set dRdZ at muon spectrometer.
TrigL2MuonSA::MuonRoad::Clear
void Clear()
Definition: MuonRoad.h:25
xAOD::MuonRoI_v1::getThrNumber
int getThrNumber() const
Get the logic number of the highest threshold this RoI passed.
Definition: MuonRoI_v1.cxx:76
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
xAOD::L2CombinedMuon_v1::setErrorFlag
void setErrorFlag(int value)
set algorithm error flag
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:27
xAOD::L2StandAloneMuon_v2::setPhiMap
void setPhiMap(float value)
Set phi used to refer pT LUT.
xAOD::L2StandAloneMuon_v2::setEndcapRadius
void setEndcapRadius(float value)
Set the fitted radius of the muon in the endcap.
MuFastSteering::m_esd_mdt_size
Gaudi::Property< int > m_esd_mdt_size
Definition: MuFastSteering.h:219
RoiDescriptor::phiMinus
virtual double phiMinus() const override final
gets phiMinus
Definition: RoiDescriptor.h:119
xAOD::L2StandAloneMuon_v2::setDeltaPt
void setDeltaPt(float value)
Set error of pT.
MuFastSteering::m_esd_mm_size
Gaudi::Property< int > m_esd_mm_size
Definition: MuFastSteering.h:222
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
xAOD::L2MuonParameters::BarrelMiddle
@ BarrelMiddle
Middle station in the barrel spectrometer.
Definition: TrigMuonDefs.h:17
MuFastSteering::ITIMER_TOTAL_PROCESSING
@ ITIMER_TOTAL_PROCESSING
Definition: MuFastSteering.h:54
xAOD::L2StandAloneMuon_v2::setLumiBlock
void setLumiBlock(uint32_t value)
Monitored::Timer
A monitored timer.
Definition: MonitoredTimer.h:32
xAOD::L2MuonParameters::EndcapOuter
@ EndcapOuter
Outer station in the endcap spectrometer.
Definition: TrigMuonDefs.h:21
TrigL2MuonSA::TgcFitResult::tgcInnPhiStd
float tgcInnPhiStd
Definition: TgcFitResult.h:59
MuFastSteering::m_esd_stgc_size
Gaudi::Property< int > m_esd_stgc_size
Definition: MuFastSteering.h:221
xAOD::MuonRoI_v1::roiWord
uint32_t roiWord() const
The "raw" RoI word describing the muon candidate.
MuFastSteering::m_use_RoIBasedDataAccess_TGC
Gaudi::Property< bool > m_use_RoIBasedDataAccess_TGC
Definition: MuFastSteering.h:207
xAOD::L2StandAloneMuon_v2::setTgcMid2
void setTgcMid2(float eta, float phi, float r, float z)
Definition: L2StandAloneMuon_v2.cxx:1004
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
xAOD::L2StandAloneMuon_v2::setTgcMid1
void setTgcMid1(float eta, float phi, float r, float z)
Definition: L2StandAloneMuon_v2.cxx:989
xAOD::L2StandAloneMuon_v2::setTrackPosition
void setTrackPosition(float r, float z, float eta, float phi)
Set position of muon track.
Definition: L2StandAloneMuon_v2.cxx:302
fitman.k
k
Definition: fitman.py:528
TrigL2MuonSA::MdtRegion::chamberType
int chamberType[N_STATION][N_SECTOR][2]
Definition: MdtRegion.h:45
xAOD::L2StandAloneMuon_v2::setRoiPhi
void setRoiPhi(float value)
MuFastSteering::m_muCompositeContainerKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_muCompositeContainerKey
Definition: MuFastSteering.h:272
xAOD::L2MuonParameters::whichECRegion
ECRegions whichECRegion(const float eta, const float phi)
Definition: TrigMuonDefs.cxx:16
ServiceHandle< ICondSvc >
xAOD::MuonRoI_v1::phi
float phi() const
The azimuthal angle ( ) of the muon candidate.
MuFastSteering::m_use_RoIBasedDataAccess_STGC
Gaudi::Property< bool > m_use_RoIBasedDataAccess_STGC
Definition: MuFastSteering.h:209
Generated on Tue Dec 2 2025 21:40:45 for ATLAS Offline Software by   doxygen 1.8.18