ATLAS Offline Software
Loading...
Searching...
No Matches
MuFastSteering Class Reference

#include <MuFastSteering.h>

Inheritance 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.
virtual StatusCode initialize () override
virtual StatusCode stop () override
virtual StatusCode execute (const EventContext &ctx) const override
 execute(), main code of the algorithm for AthenaMT
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
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
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
int L2MuonAlgoMap (const std::string &name) const
virtual void handle (const Incident &incident) override
virtual StatusCode sysInitialize () override
 Override sysInitialize.
virtual bool isClonable () const override
 Specify if the algorithm is clonable.
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
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.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () 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.
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.
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
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.

Protected Attributes

ToolHandle< TrigL2MuonSA::MuFastDataPreparatorm_dataPreparator
ToolHandle< TrigL2MuonSA::MuFastPatternFinderm_patternFinder
ToolHandle< TrigL2MuonSA::MuFastStationFitterm_stationFitter
ToolHandle< TrigL2MuonSA::MuFastTrackFitterm_trackFitter
ToolHandle< TrigL2MuonSA::MuFastTrackExtrapolatorm_trackExtrapolator
ToolHandle< TrigL2MuonSA::FtfRoadDefinerm_ftfRoadDefiner
ToolHandle< ITrigMuonBackExtrapolatorm_backExtrapolatorTool
 Handle to MuonBackExtrapolator tool.
ToolHandle< TrigL2MuonSA::MuCalStreamerToolm_calStreamer
TrigL2MuonSA::RecMuonRoIUtils m_recMuonRoIUtils
ToolHandle< TrigL2MuonSA::CscSegmentMakerm_cscsegmaker

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_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>

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::EventInfom_eventInfoKey
SG::ReadHandleKey< TrigRoiDescriptorCollectionm_roiCollectionKey
SG::ReadHandleKey< DataVector< LVL1::RecMuonRoI > > m_run2recRoiCollectionKey
SG::ReadHandleKey< xAOD::MuonRoIContainerm_recRoiCollectionKey
SG::ReadHandleKey< xAOD::TrackParticleContainerm_FTFtrackKey
SG::WriteHandleKey< xAOD::L2StandAloneMuonContainerm_muFastContainerKey
SG::WriteHandleKey< xAOD::TrigCompositeContainerm_muCompositeContainerKey
SG::WriteHandleKey< TrigRoiDescriptorCollectionm_muIdContainerKey
SG::WriteHandleKey< TrigRoiDescriptorCollectionm_muMsContainerKey
SG::WriteHandleKey< xAOD::L2CombinedMuonContainerm_outputCBmuonCollKey
ToolHandle< GenericMonitoringToolm_monTool { this, "MonTool", "", "Monitoring tool" }
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default)
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default)
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.

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),
26{
27}
TrigL2MuonSA::RecMuonRoIUtils m_recMuonRoIUtils

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const
overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

64{
65 return 0;
66}

◆ declareGaudiProperty()

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 {
160 hndl.value(),
161 hndl.documentation());
162
163 }
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)

◆ declareProperty()

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;
148 }
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>

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

◆ evtStore()

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.

◆ 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}
#define M_PI
Scalar eta() const
pseudorapidity method
Scalar phi() const
phi method
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_ERROR(x)
#define ATH_MSG_DEBUG(x)
const LVL1::RecMuonRoI * matchingRecRoI(uint32_t roiWord, const DataVector< LVL1::RecMuonRoI > &collection)
Athena::TPCnvVers::Current Athena::TPCnvVers::Old TrigRoiDescriptorCollection
bool msgLvl(const MSG::Level lvl) const
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:838
const T * at(size_type n) const
Access an element, as an rvalue.
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
size_type size() const noexcept
Returns the number of elements in the collection.
ToolHandle< GenericMonitoringTool > m_monTool
SG::WriteHandleKey< TrigRoiDescriptorCollection > m_muIdContainerKey
SG::ReadHandleKey< xAOD::MuonRoIContainer > m_recRoiCollectionKey
Gaudi::Property< float > m_dPhisurrRoI
SG::ReadHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_muCompositeContainerKey
SG::WriteHandleKey< xAOD::L2StandAloneMuonContainer > m_muFastContainerKey
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
Gaudi::Property< bool > m_insideOut
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
Gaudi::Property< bool > m_multiTrack
Gaudi::Property< float > m_dEtasurrRoI
SG::WriteHandleKey< TrigRoiDescriptorCollection > m_muMsContainerKey
Gaudi::Property< bool > m_topoRoad
SG::WriteHandleKey< xAOD::L2CombinedMuonContainer > m_outputCBmuonCollKey
Gaudi::Property< bool > m_useRun3Config
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_FTFtrackKey
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
virtual unsigned int roiWord() const override final
float eta() const
The pseudorapidity ( ) of the muon candidate.
float phi() const
The azimuthal angle ( ) of the muon candidate.
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
TrigCompositeContainer_v1 TrigCompositeContainer
Declare the latest version of the container.
MuonRoIContainer_v1 MuonRoIContainer
TrackParticleContainer_v1 TrackParticleContainer
Definition of the current "TrackParticle container version".
MuonRoI_v1 MuonRoI
Definition MuonRoI.h:15

◆ 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 ( ) const
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()) {
95 }
97}
An algorithm that can be simultaneously executed in multiple threads.

◆ 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 }
virtual bool filterPassed(const EventContext &ctx) const

◆ 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
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
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,
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();
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}
#define ATH_MSG_WARNING(x)
static Double_t sc
const float ZERO_LIMIT
Gaudi::Property< float > m_scaleRoadBarrelMiddle
Gaudi::Property< bool > m_use_new_segmentfit
ToolHandle< TrigL2MuonSA::MuFastTrackFitter > m_trackFitter
Gaudi::Property< float > m_scaleRoadBarrelInner
ToolHandle< TrigL2MuonSA::MuFastPatternFinder > m_patternFinder
ToolHandle< TrigL2MuonSA::MuFastDataPreparator > m_dataPreparator
ToolHandle< TrigL2MuonSA::CscSegmentMaker > m_cscsegmaker
Gaudi::Property< float > m_scaleRoadBarrelOuter
ToolHandle< TrigL2MuonSA::MuFastTrackExtrapolator > m_trackExtrapolator
ToolHandle< TrigL2MuonSA::MuFastStationFitter > m_stationFitter
StatusCode updateMonitor(const xAOD::MuonRoI *roi, const TrigL2MuonSA::MdtHits &mdtHits, std::vector< TrigL2MuonSA::TrackPattern > &trackPatterns) const
Update monitoring variables.
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
Gaudi::Property< double > m_winPt
Gaudi::Property< bool > m_doEndcapForl2mt
void setScales(double inner, double middle, double outer)
Definition MuonRoad.h:69
::StatusCode StatusCode
StatusCode definition for legacy code.
std::vector< StgcHitData > StgcHits
Definition StgcData.h:49
std::vector< MdtHitData > MdtHits
Definition MdtData.h:56
std::vector< MmHitData > MmHits
Definition MmData.h:47
std::vector< CscHitData > CscHits
Definition CscData.h:40
std::vector< RpcHitData > RpcHits
Definition RpcData.h:57
std::vector< TgcHitData > TgcHits
Definition TgcData.h:43
setTeId setLumiBlock setRoiId setRoiSubsystem setRoiNumber roiEta

◆ 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;
420
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
447
448 // Data preparation
449 sc = m_dataPreparator->prepareData(ctx,
450 *p_roi,
451 *p_roids,
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,
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();
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,
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
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}
static Double_t tc
value_type push_back(value_type pElem)
Add an element to the end of the collection.
ToolHandle< TrigL2MuonSA::MuCalStreamerTool > m_calStreamer
Gaudi::Property< bool > m_doCalStream
Gaudi::Property< bool > m_calDataScouting
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.
TrigComposite_v1 TrigComposite
Declare the latest version of the class.

◆ 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;
754
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
813
814 // Data preparation
815 sc = m_dataPreparator->prepareData(ctx,
816 p_roi,
817 *p_roids,
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,
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);
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);
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}
static const Attributes_t empty
Gaudi::Property< float > m_ftfminPt
ToolHandle< TrigL2MuonSA::FtfRoadDefiner > m_ftfRoadDefiner
void makePrivateStore()
Create a new (empty) private store for this object.
void setPt(float pt)
Set the transverse momentum ( ) of the muon.
void setStrategy(int value)
set algorithm strategy flag
void setErrorFlag(int value)
set algorithm error flag
void setIdTrackLink(const ElementLink< xAOD::TrackParticleContainer > &link)
set ID track used to make the CB muon
void setMuSATrackLink(const ElementLink< xAOD::L2StandAloneMuonContainer > &link)
set SA muon used to make the CB muon
void setPhi(float phi)
Set the azimuthal angle ( ) of the muon.
void setEta(float eta)
Set the pseudorapidity ( ) of the muon.
void setCharge(float value)
set seeding muon charge
L2CombinedMuon_v1 L2CombinedMuon
Define the latest version of the muon CB class.

◆ 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
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 }
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}
#define x
int sAddress() const
Get the station address of the muon.
float etaMS() const
Get the eta at muon spectrometer.
float phiMS() const
Get the phi at muon spectrometer.
virtual double pt() const
The transverse momentum ( ) of the particle.
ECRegions whichECRegion(const float eta, const float phi)

◆ 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}
#define ATH_MSG_INFO(x)
static const std::string & type()
Incident type.
Definition Incidents.h:49
int workerID() const
assigned worker ID from processing unit
Definition Incidents.h:40
Gaudi::Property< int > m_calBufferSize
Gaudi::Property< std::string > m_calBufferName

◆ 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
47
48 // BackExtrapolator services
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
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
76
77 // set data or MC flag
79
83 m_trackFitter -> setUseEIFromBarrel( m_use_endcapInnerFromBarrel );
84
85 // DataHandles for AthenaMT
86 ATH_CHECK(m_eventInfoKey.initialize());
87 ATH_CHECK(m_roiCollectionKey.initialize());
90 // for Inside-Out mode ---
93 // ----
94 ATH_CHECK(m_muFastContainerKey.initialize());
95 ATH_CHECK(m_muIdContainerKey.initialize());
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());
143 }
144
145
146 return StatusCode::SUCCESS;
147}
Gaudi::Property< bool > m_use_RoIBasedDataAccess_RPC
ServiceHandle< Gaudi::Interfaces::IOptionsSvc > m_jobOptionsSvc
Gaudi::Property< bool > m_use_RoIBasedDataAccess_TGC
Gaudi::Property< bool > m_use_mm
Gaudi::Property< bool > m_fill_FSIDRoI
Gaudi::Property< bool > m_use_RoIBasedDataAccess_MM
Gaudi::Property< double > m_rWidth_RPC_Failed
Gaudi::Property< bool > m_use_RoIBasedDataAccess_STGC
ServiceHandle< IIncidentSvc > m_incidentSvc
Gaudi::Property< bool > m_use_endcapInnerFromBarrel
Gaudi::Property< bool > m_use_RoIBasedDataAccess_CSC
ToolHandle< ITrigMuonBackExtrapolator > m_backExtrapolatorTool
Handle to MuonBackExtrapolator tool.
Gaudi::Property< bool > m_use_mcLUT
Gaudi::Property< bool > m_use_rpc
SG::ReadHandleKey< DataVector< LVL1::RecMuonRoI > > m_run2recRoiCollectionKey
Gaudi::Property< bool > m_use_stgc
Gaudi::Property< double > m_rWidth_TGC_Failed
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Gaudi::Property< bool > m_use_RoIBasedDataAccess_MDT

◆ 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()

◆ 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") {
1950 } else if (name == "MuFastSteering_900GeV") {
1952 } else {
1954 }
1955
1956 return algoId;
1957}

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ 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();
384 }
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)

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

◆ setFilterPassed()

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

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100 {
102 }
virtual void setFilterPassed(bool state, const EventContext &ctx) const

◆ 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}
#define ATH_MSG_VERBOSE(x)
Athena::TPCnvVers::Current TrigRoiDescriptor
float getRoiSizeForID(bool isEta, const xAOD::L2StandAloneMuon *muonSA) const
virtual double etaMinus() const override final
gets eta at zMinus
virtual double etaPlus() const override final
gets eta at zedPlus
virtual double phi() const override final
Methods to retrieve data members.
virtual double phiMinus() const override final
gets phiMinus
virtual double eta() const override final
virtual double phiPlus() const override final
gets phiPlus
virtual unsigned int roiId() const override final
these quantities probably don't need to be used any more
virtual unsigned int l1Id() const override final
T wrapToPi(T phi)
Wrap angle in radians to [-pi, pi].
Definition phihelper.h:24
L2StandAloneMuon_v2 L2StandAloneMuon
Define the latest version of the muon SA class.

◆ 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) {
1432 } else {
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
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
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 static const SG::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 static const SG::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}
Scalar theta() const
theta method
const double width
unsigned bcTag(unsigned bcBitMap)
#define z
int L2MuonAlgoMap(const std::string &name) const
Gaudi::Property< int > m_esd_mm_size
Gaudi::Property< int > m_esd_rpc_size
Gaudi::Property< int > m_esd_csc_size
Gaudi::Property< int > m_esd_tgc_size
Gaudi::Property< int > m_esd_mdt_size
Gaudi::Property< int > m_esd_stgc_size
double zMin[N_STATION][N_SECTOR]
Definition MdtRegion.h:37
double rMin[N_STATION][N_SECTOR]
Definition MdtRegion.h:39
double zMax[N_STATION][N_SECTOR]
Definition MdtRegion.h:38
double etaMax[N_STATION][N_SECTOR]
Definition MdtRegion.h:42
double etaMin[N_STATION][N_SECTOR]
Definition MdtRegion.h:41
int chamberType[N_STATION][N_SECTOR][2]
Definition MdtRegion.h:45
double rMax[N_STATION][N_SECTOR]
Definition MdtRegion.h:40
double aw[N_STATION][N_SECTOR]
Definition MuonRoad.h:83
double bw[N_STATION][N_SECTOR]
Definition MuonRoad.h:84
void setRegionR(int station, int sector, float min, float max)
R range.
void setEta(float eta)
Set the pseudorapidity ( ) of the muon.
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.
void setBeta(float value)
Set beta.
void setRpcFitInn(float phi, float slope, float offset)
Set the results of RPC fit.
void setPhi(float phi)
Set the azimuthal angle ( ) of the muon.
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.
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.
void setBarrelSagitta(float value)
Set the fitted sagitta of the muon in the barrel.
void setDeltaPt(float value)
Set error of pT.
void setEtaMS(float value)
Set the eta at muon spectrometer.
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.
void setTgcInn(float eta, float phi, float r, float z)
Set the results of TGC fit.
void setMmClustersCapacity(const int value)
Set size of storage for MM clusters.
void setDeltaEta(float value)
Set error of eta.
void setRoiSystem(uint32_t value)
void setRoad(int station, int sector, float aw, float bw)
Road.
void setTgcHit(float eta, float phi, float r, float z, float width, int stationNum, bool isStrip, int bcTag, bool inRoad)
Set TGC hits.
void setRoiNumber(uint32_t value)
void setDeltaPhi(float value)
Set error of phi.
void setPtEndcapRadius(float value)
void setTgcMid2(float eta, float phi, float r, float z)
void setStgcClustersCapacity(const int value)
Set size of storage for sTGC clusters.
void setTrackPosition(float r, float z, float eta, float phi)
Set position of muon track.
void setRMS(float value)
Set the R at muon spectrometer.
void setPtCSC(float value)
void setLumiBlock(uint32_t value)
void setRoiThreshold(uint32_t value)
void setTgcMidF(float rhoChi2, long rhoN, float phiChi2, long phiN)
void setPhiMap(float value)
Set phi used to refer pT LUT.
void setIsTgcFailure(int value)
Set flag to record if TGC is properly read.
void setRoiSubsystem(uint32_t value)
void setRpcHitsCapacity(int value)
Size of storage to be reserved.
void setRoiSector(uint32_t value)
void setRpcFitOut(float phi, float slope, float offset)
void setLvl1Id(uint32_t value)
void setChamberType2(int station, int sector, int chamberType)
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.
void setEtaBin(int value)
Set eta bin of pT LUT.
void setEtaMap(float value)
Set eta used to refer pT LUT.
void setMuonDetMask(uint32_t value)
void setDirPhiMS(float value)
Set tan phi at muon spectrometer.
void setPtEndcapBeta(float value)
void setCscHitsCapacity(int value)
Set size of storage for CSC hits.
void setRegionZ(int station, int sector, float min, float max)
Z range.
void setEndcapRadius(float value)
Set the fitted radius of the muon in the endcap.
void setEndcapBeta(float value)
Set the fitted value in the endcap.
void setChamberType1(int station, int sector, int chamberType)
Set the muon road information.
void setSAddress(int value)
Set the station address of the muon.
void setRpcFitMid(float phi, float slope, float offset)
void setPhiMS(float value)
Set the phi at muon spectrometer.
void setEndcapAlpha(float value)
Set the fitted value in the endcap.
void setRoIWord(uint32_t value)
Set the RoI ID of the seeding LVL1 muon.
void setRoiId(uint32_t value)
void setTgcHitsCapacity(int value)
Set size of storage for TGC hits.
void setRoiEta(float value)
void setTgcMid1(float eta, float phi, float r, float z)
void setRegionEta(int station, int sector, float min, float max)
Eta range.
void setIsRpcFailure(int value)
Set flag to record if RPC is properly read.
void setPt(float pt)
Set the transverse momentum ( ) of the muon.
void setRoiPhi(float value)
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.
void setMdtHitsCapacity(int value)
Set size of storage for MDT hits.
void setDirZMS(float value)
Set dRdZ at muon spectrometer.
void setAlgoId(int value)
void setPhiBin(int value)
Set phi bin of pT LUT.
void setZMS(float value)
Set the Z at muon spectrometer.
void setBarrelRadius(float value)
Set the fitted radius of the muon in the barrel.
void setPtEndcapAlpha(float value)
void setTgcPt(float value)
void setTgcInnF(float rhoStd, long rhoN, float phiStd, long phiN)
Hemisphere getHemisphere() const
Returns the hemisphere that detected the muon candidate.
RoISource getSource() const
Returns the system that detected the muon candidate.
uint32_t roiWord() const
The "raw" RoI word describing the muon candidate.
int getThrNumber() const
Get the logic number of the highest threshold this RoI passed.
int getSectorID() const
Get the sector ID number.
int getRoI() const
Get the "RoI number" (position inside the sector)
int r
Definition globals.cxx:22
@ BarrelInner
Inner station in the barrel spectrometer.
@ EndcapOuter
Outer station in the endcap spectrometer.
@ BarrelMiddle
Middle station in the barrel spectrometer.
@ EndcapMiddle
Middle station in the endcap spectrometer.
@ BEE
BEE measurement point.
@ EndcapExtra
Extra station in the endcap spectrometer.
@ BarrelOuter
Outer station in the barrel spectrometer.
@ BME
BME measurement point.
@ EndcapInner
Inner station in the endcap spectrometer.
setEventNumber uint32_t

◆ 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 HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

107 {
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()) {
124 ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
125 << " with CondSvc");
126 }
127 }
128 }
129 return sc;
130}
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override

◆ 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 auto track_eta = Monitored::Collection("TrackEta", t_eta);
2134 auto track_phi = Monitored::Collection("TrackPhi", t_phi);
2135 auto failed_eta = Monitored::Collection("FailedRoIEta", f_eta);
2136 auto failed_phi = Monitored::Collection("FailedRoIPhi", f_phi);
2137 auto res_inner = Monitored::Collection("ResInner", r_inner);
2138 auto res_middle = Monitored::Collection("ResMiddle", r_middle);
2139 auto res_outer = Monitored::Collection("ResOuter", r_outer);
2140 auto fit_residuals = Monitored::Collection("FitResiduals", f_residuals);
2141
2142 auto monitorIt = Monitored::Group(m_monTool, inner_mdt_hits, middle_mdt_hits, outer_mdt_hits,
2143 invalid_rpc_roi_number,
2144 efficiency, sag_inverse, address, absolute_pt, sagitta, track_pt,
2145 track_eta, track_phi, failed_eta, failed_phi,
2146 res_inner, res_middle, res_outer, fit_residuals );
2147
2148 const float ZERO_LIMIT = 1e-5;
2149
2150 if( !trackPatterns.empty() ) {
2151
2152 efficiency = 1;
2153
2154 const TrigL2MuonSA::TrackPattern& pattern = trackPatterns[0];
2155 float norm = 10.;
2156
2157 float count_inner = 0;
2158 float count_middle = 0;
2159 float count_outer = 0;
2160
2161 for (const TrigL2MuonSA::MdtHitData& mdtHit : mdtHits) {
2162
2163 if (std::abs(mdtHit.DriftSpace) < ZERO_LIMIT) continue;
2164
2165 char st = mdtHit.cType[1];
2166
2167 if (st=='I') {
2168 count_inner++;
2169 r_inner.push_back(mdtHit.Residual/norm);
2170 if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
2171 }
2172
2173 if (st=='M') {
2174 count_middle++;
2175 r_middle.push_back(mdtHit.Residual/norm);
2176 if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
2177 }
2178
2179 if (st=='O') {
2180 count_outer++;
2181 r_outer.push_back(mdtHit.Residual/norm);
2182 if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
2183 }
2184 }
2185
2186 inner_mdt_hits = count_inner;
2187 middle_mdt_hits = count_middle;
2188 outer_mdt_hits = count_outer;
2189
2190 track_pt = (std::abs(pattern.pt ) > ZERO_LIMIT)? pattern.charge*pattern.pt: 9999.;
2191 absolute_pt = std::abs(track_pt);
2192
2193 if ( std::abs(pattern.etaMap) > ZERO_LIMIT || std::abs(pattern.phiMS) > ZERO_LIMIT ) {
2194 t_eta.push_back(pattern.etaMap);
2195 t_phi.push_back(pattern.phiMS);
2196 }
2197 if ( std::abs(pattern.pt ) < ZERO_LIMIT){
2198 f_eta.push_back(roi->eta());
2199 f_phi.push_back(roi->phi());
2200 }
2201
2202 sagitta = (std::abs(pattern.barrelSagitta) > ZERO_LIMIT)? pattern.barrelSagitta: 9999.;
2203 sag_inverse = (std::abs(pattern.barrelSagitta) > ZERO_LIMIT)? 1./pattern.barrelSagitta: 9999.;
2204 address = pattern.s_address;
2205 }
2206
2207 return StatusCode::SUCCESS;
2208}
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="")
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.

◆ 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}
bool storeIDRoiDescriptor(const TrigRoiDescriptor *roids, const TrigL2MuonSA::TrackPattern &pattern, const DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputID) const
bool storeMSRoiDescriptor(const TrigRoiDescriptor *roids, const TrigL2MuonSA::TrackPattern &pattern, const DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputMS) const

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

239{ this, "AllowOksConfig", true};

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

176 {
177 this, "BackExtrapolator", "TrigMuonBackExtrapolator", "public tool for back extrapolating the muon tracks to the IV" };

◆ m_calBufferName

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

Definition at line 240 of file MuFastSteering.h.

240{ this, "MuonCalBufferName", "/tmp/testOutput"};

◆ m_calBufferSize

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

Definition at line 241 of file MuFastSteering.h.

241{ this, "MuonCalBufferSize", 1024*1024};

◆ m_calDataScouting

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

Definition at line 212 of file MuFastSteering.h.

212{ this, "MuonCalDataScouting", false};

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

180 {
181 this, "CalibrationStreamer", "TrigL2MuonSA::MuCalStreamerTool", "calibration stream" };

◆ m_cscsegmaker

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

Definition at line 187 of file MuFastSteering.h.

187 {
188 this, "CscSegmentMaker", "TrigL2MuonSA::CscSegmentMaker", "" };

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

162 {
163 this, "DataPreparator", "TrigL2MuonSA::MuFastDataPreparator", "data preparator" };

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

235{ this, "dEtasurrRoI", 99, "eta range to find surrounding L1 RoIs" };

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

211{ this, "DoCalibrationStream", true};

◆ m_doEndcapForl2mt

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

Definition at line 231 of file MuFastSteering.h.

231{ this, "doEndcapForl2mt", false, "" };

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

234{ this, "dPhisurrRoI", 99, "phi range to find surrounding L1 RoIs" };

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

220{ this, "ESD_CSC_size", 100 };

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

219{ this, "ESD_MDT_size", 100 };

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

222{ this, "ESD_MM_size", 100 };

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

217{ this, "ESD_RPC_size", 100 };

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

221{ this, "ESD_STGC_size", 100 };

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

218{ this, "ESD_TGC_size", 50 };

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

250 {
251 this, "EventInfo", "EventInfo", "Name of the xAOD::EventInfo object"};

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

244{ this, "FILL_FSIDRoI", false, "Fill FS RoI for ID (will be used in cosmic run)"};

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

232{ this, "FTFminPt", 3500, "pT [MeV] threshold to FTF tracks for L2Muon Inside-out mode" };

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

172 {
173 this, "FtfRoadDefiner", "TrigL2MuonSA::FtfRoadDefiner", "ftf road definer" };

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

264 {
265 this, "TrackParticlesContainerName", "HLT_xAODTracks_Muon", "Name of the input data on xAOD::TrackParticleContainer produced by FTF for Inside-Out mode"};

◆ m_incidentSvc

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

Definition at line 193 of file MuFastSteering.h.

193{this, "IncidentSvc", "IncidentSvc"};

◆ m_insideOut

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

Definition at line 229 of file MuFastSteering.h.

229{ this, "InsideOutMode", false, "" };

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

194{this, "JobOptionsSvc", "JobOptionsSvc", "Job options service to retrieve DataFlowConfig" };

◆ m_monTool

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

Definition at line 288 of file MuFastSteering.h.

288{ this, "MonTool", "", "Monitoring tool" };

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

272 {
273 this, "MuonCalibrationStream", "", "Name of the decisions object attached by MuFastSteering"};

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

268 {
269 this, "MuonL2SAInfo", "MuonL2SAInfo", "Name of the output data on xAOD::L2StandAloneMuonContainer"};

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

276 {
277 this, "forID", "forID", "Name of the output data for Inner Detector"};

◆ m_multiTrack

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

Definition at line 230 of file MuFastSteering.h.

230{ this, "multitrackMode", false, "" };

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

280 {
281 this, "forMS", "forMS", "Name of the output data for MS"};

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

284 {
285 this, "L2IOCB", "MuonL2CBInfo", "output CB Muon container name"};

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

164 {
165 this, "PatternFinder", "TrigL2MuonSA::MuFastPatternFinder", "pattern finder" };

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

260 {
261 this, "RecMuonRoI", "LVL1MuonRoIs", "Name of the input data on xAOD::MuonRoI"};

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

254 {
255 this, "MuRoIs", "HLT_MURoIs", "Name of the input data from HLTSeeding"};

◆ m_rpcErrToDebugStream

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

Definition at line 213 of file MuFastSteering.h.

213{ this, "RpcErrToDebugStream", false};

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

258 {
259 this, "Run2RecMuonRoI", "HLT_RecMURoIs", "Name of the input data on LVL1::RecMuonRoI produced by HLTSeeding"};

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

224{ this, "R_WIDTH_RPC_FAILED", 400 };

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

225{ this, "R_WIDTH_TGC_FAILED", 200 };

◆ m_scaleRoadBarrelInner

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

Definition at line 196 of file MuFastSteering.h.

196{ this, "Scale_Road_BarrelInner", 1 };

◆ m_scaleRoadBarrelMiddle

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

Definition at line 197 of file MuFastSteering.h.

197{ this, "Scale_Road_BarrelMiddle", 1 };

◆ m_scaleRoadBarrelOuter

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

Definition at line 198 of file MuFastSteering.h.

198{ this, "Scale_Road_BarrelOuter", 1 };

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

166 {
167 this, "StationFitter", "TrigL2MuonSA::MuFastStationFitter", "station fitter" };

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

233{ this, "topoRoad", false, "create road in barrel not to highly overlap surrounding L1 RoIs" };

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

170 {
171 this, "TrackExtrapolator", "TrigL2MuonSA::MuFastTrackExtrapolator", "track extrapolator" };

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

168 {
169 this, "TrackFitter", "TrigL2MuonSA::MuFastTrackFitter", "track fitter" };

◆ m_use_endcapInnerFromBarrel

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

Definition at line 214 of file MuFastSteering.h.

214{ this, "UseEndcapInnerFromBarrel", false};

◆ m_use_mcLUT

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

Definition at line 200 of file MuFastSteering.h.

200{ this, "UseLUTForMC", true};

◆ m_use_mm

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

Definition at line 204 of file MuFastSteering.h.

204{ this, "USE_MM", true};

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

201{ this, "USE_NEW_SEGMENTFIT", true};

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

208{ this, "USE_ROIBASEDACCESS_CSC", true};

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

205{ this, "USE_ROIBASEDACCESS_MDT", true};

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

210{ this, "USE_ROIBASEDACCESS_MM", true};

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

206{ this, "USE_ROIBASEDACCESS_RPC", true};

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

209{ this, "USE_ROIBASEDACCESS_STGC", true};

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

207{ this, "USE_ROIBASEDACCESS_TGC", true};

◆ m_use_rpc

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

Definition at line 202 of file MuFastSteering.h.

202{ this, "USE_RPC", true};

◆ m_use_stgc

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

Definition at line 203 of file MuFastSteering.h.

203{ this, "USE_STGC", true};

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

246{ this, "UseRun3Config", false, "use Run3 L1Muon EDM; xAOD::MuonRoI"};

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

227{ this, "WinPt", 4.0 };

The documentation for this class was generated from the following files: