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 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
 Get filter decision:
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 Set filter decision:
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

◆ 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 auto muCompositeContainer = std::make_unique<xAOD::TrigCompositeContainer>();
312 auto muCompositeAuxContainer = std::make_unique<xAOD::TrigCompositeAuxContainer>();
313 muCompositeContainer->setStore(muCompositeAuxContainer.get());
314
315 auto muIdContainer = SG::makeHandle(m_muIdContainerKey, ctx);
316 ATH_CHECK(muIdContainer.record(std::make_unique<TrigRoiDescriptorCollection>()));
317
318 auto muMsContainer = SG::makeHandle(m_muMsContainerKey, ctx);
319 ATH_CHECK(muMsContainer.record(std::make_unique<TrigRoiDescriptorCollection>()));
320
321
322 // Inside-out L2Muon mode
323 if(m_insideOut) {
324 ATH_MSG_DEBUG("start inside-out mode...");
325
326 auto muonCBColl = SG::makeHandle (m_outputCBmuonCollKey, ctx);
327 ATH_CHECK( muonCBColl.record (std::make_unique<xAOD::L2CombinedMuonContainer>(),
328 std::make_unique<xAOD::L2CombinedMuonAuxContainer>()) );
329
330 auto trackHandle = SG::makeHandle( m_FTFtrackKey, ctx );
331 if (!trackHandle.isValid()){
332 ATH_MSG_ERROR("ReadHandle for TrackParticleContainer key:" << m_FTFtrackKey.key() << " isn't Valid");
333 return StatusCode::FAILURE;
334 }
335 const xAOD::TrackParticleContainer *tracks = trackHandle.cptr();
336
337 ATH_CHECK(findMuonSignatureIO(*tracks, internalRoI, recRoIVector,
338 *muonCBColl, *muFastContainer, dynamicDeltaRpc, ctx ));
339
340 if (msgLvl(MSG::DEBUG)) {
341 ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " size = " << muonCBColl->size());
342 for (const auto p_CBmuon : *muonCBColl){
343 ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " pt = " << (*p_CBmuon).pt() << " GeV");
344 ATH_MSG_DEBUG("REGTEST: xAOD::L2CombinedMuonContainer key:" << m_outputCBmuonCollKey.key() << " eta/phi = " << (*p_CBmuon).eta() << "/" << (*p_CBmuon).phi());
345 }
346 }
347 }
348 else if(m_multiTrack){ //multi-track SA mode
349 ATH_MSG_DEBUG("start multi-track SA mode...");
350 ATH_CHECK(findMultiTrackSignature(internalRoI, recRoIVector, *muFastContainer, dynamicDeltaRpc, ctx));
351 }
352 else {
353 ATH_CHECK(findMuonSignature(internalRoI, recRoIVector,
354 *muFastContainer, muCompositeContainer.get(), *muIdContainer, *muMsContainer, dynamicDeltaRpc, ctx));
355 }
356
357 if (!m_muCompositeContainerKey.empty()){
358 SG::WriteHandle<xAOD::TrigCompositeContainer> wh_muCompositeCont(m_muCompositeContainerKey, ctx);
359 ATH_CHECK(wh_muCompositeCont.record(std::move(muCompositeContainer), std::move(muCompositeAuxContainer)));
360 }
361
362 if (msgLvl(MSG::DEBUG)) {
363 // DEBUG TEST: Recorded data objects
364 ATH_MSG_DEBUG("Recorded data objects");
365 ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " size = " << muFastContainer->size());
366
367 for (auto p_muon : *muFastContainer) {
368 ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " pt = " << (*p_muon).pt() << " GeV");
369 ATH_MSG_DEBUG("REGTEST: xAOD::L2StandAloneMuonContainer key:" << m_muFastContainerKey.key() << " eta/phi = " << (*p_muon).eta() << "/" << (*p_muon).phi());
370 }
371
372 ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muIdContainerKey.key() << " size = " << muIdContainer->size());
373 for (auto p_muonID : *muIdContainer) {
374 ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muIdContainerKey.key() << " eta/phi = " << (*p_muonID).eta() << "/" << (*p_muonID).phi());
375 }
376
377 ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muMsContainerKey.key() << " size = " << muMsContainer->size());
378 for (auto p_muonMS : *muMsContainer) {
379 ATH_MSG_DEBUG("REGTEST: TrigRoiDescriptorCollection key:" << m_muMsContainerKey.key() << " eta/phi = " << (*p_muonMS).eta() << "/" << (*p_muonMS).phi());
380 }
381 }
382
383 ATH_MSG_DEBUG("StatusCode MuFastSteering::execute(const EventContext& ctx) success");
384 return StatusCode::SUCCESS;
385}
#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_DEBUG(x,...)
#define ATH_MSG_ERROR(x,...)
const LVL1::RecMuonRoI * matchingRecRoI(uint32_t roiWord, const DataVector< LVL1::RecMuonRoI > &collection)
size_t size() const
Number of registered mappings.
Athena::TPCnvVers::Current Athena::TPCnvVers::Old TrigRoiDescriptorCollection
bool msgLvl(const MSG::Level lvl) const
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:837
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())
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 & AthCommonAlgorithm< 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 89 of file AthCommonAlgorithm.cxx.

54{
55 // If we didn't find any symlinks to add, just return the collection
56 // from the base class. Otherwise, return the extended collection.
57 if (!m_extendedExtraObjects.empty()) {
59 }
61}
Common base class for algorithms.

◆ filterPassed()

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

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

93 {
94 return execState( ctx ).filterPassed();
95 }
virtual bool filterPassed(const EventContext &ctx) const
Get filter decision:

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

1037{
1038 ATH_MSG_DEBUG("StatusCode MuFastSteering::findMultiTrackSignature start");
1039 StatusCode sc = StatusCode::SUCCESS;
1040 const float ZERO_LIMIT = 1.e-5;
1041
1042 // for RPC clustering and clusterRoad
1043 std::vector<TrigL2MuonSA::RpcFitResult> clusterFitResults;
1044 std::vector< TrigL2MuonSA::MuonRoad > clusterRoad;
1045 std::vector<TrigL2MuonSA::MdtHits> mdtHits_cluster_normal;
1046
1047
1048 auto prepTimer = Monitored::Timer( "TIME_Data_Preparator" );
1049 auto patternTimer = Monitored::Timer( "TIME_Pattern_Finder" );
1050 auto stationFitterTimer = Monitored::Timer( "TIME_Station_Fitter" );
1051 auto trackFitterTimer = Monitored::Timer( "TIME_Track_Fitter" );
1052 auto trackExtraTimer = Monitored::Timer( "TIME_Track_Extrapolator" );
1053 auto calibrationTimer = Monitored::Timer( "TIME_Calibration_Streamer" );
1054
1055 auto monitorIt = Monitored::Group(m_monTool, prepTimer, patternTimer, stationFitterTimer,
1056 trackFitterTimer, trackExtraTimer, calibrationTimer );
1057
1058 TrigL2MuonSA::RpcHits rpcHits;
1059 TrigL2MuonSA::TgcHits tgcHits;
1060 TrigL2MuonSA::MdtRegion mdtRegion;
1061 TrigL2MuonSA::MuonRoad muonRoad;
1062 TrigL2MuonSA::RpcFitResult rpcFitResult;
1063 TrigL2MuonSA::TgcFitResult tgcFitResult;
1064 TrigL2MuonSA::MdtHits mdtHits;
1065 TrigL2MuonSA::CscHits cscHits;
1066 TrigL2MuonSA::StgcHits stgcHits;
1067 TrigL2MuonSA::MmHits mmHits;
1068
1071
1072 // muonRoIs = RecMURoIs, roids = MURoIs
1073 p_roids = roids.begin();
1074 for (p_roi=(muonRoIs).begin(); p_roi!=(muonRoIs).end(); ++p_roi) {
1075
1076 prepTimer.start();
1077 std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
1078 rpcHits.clear();
1079 tgcHits.clear();
1080 mdtRegion.Clear();
1081 muonRoad.Clear();
1082 rpcFitResult.Clear();
1083 tgcFitResult.Clear();
1084 mdtHits.clear();
1085 cscHits.clear();
1086 stgcHits.clear();
1087 mmHits.clear();
1088
1089 clusterFitResults.clear();
1090 clusterRoad.clear();
1091 mdtHits_cluster_normal.clear();
1092
1093 if ( m_recMuonRoIUtils.isBarrel(*p_roi) ) { // Barrel
1094 ATH_MSG_DEBUG("Barrel");
1095
1099
1100 // Data preparation
1101 sc = m_dataPreparator->prepareData(ctx,
1102 *p_roi,
1103 *p_roids,
1104 clusterRoad,
1105 clusterFitResults,
1106 mdtHits,
1107 mdtHits_cluster_normal,
1108 dynamicDeltaRpc);
1109
1110 if (!sc.isSuccess()) {
1111 ATH_MSG_WARNING("Data preparation failed");
1112 continue;
1113 }
1114 ATH_MSG_DEBUG("clusterRoad size = " << clusterRoad.size());
1115
1116 prepTimer.stop();
1117
1118 for(unsigned int i_road = 0; i_road < clusterRoad.size(); i_road++){
1119 // Pattern finding
1120 std::vector<TrigL2MuonSA::TrackPattern> tmp_trkPats; tmp_trkPats.clear();
1121
1122 patternTimer.start();
1123 sc = m_patternFinder->findPatterns(ctx,
1124 clusterRoad.at(i_road),
1125 mdtHits_cluster_normal.at(i_road),
1126 tmp_trkPats);
1127 if (!sc.isSuccess()) {
1128 ATH_MSG_WARNING("Pattern finder failed");
1129 continue;
1130 }
1131 patternTimer.stop();
1132
1133 // Superpoint fit
1134 stationFitterTimer.start();
1135 sc = m_stationFitter->findSuperPoints(clusterRoad.at(i_road),
1136 clusterFitResults.at(i_road),
1137 tmp_trkPats);
1138 if (!sc.isSuccess()) {
1139 ATH_MSG_WARNING("Super point fitter failed");
1140 // Update output trigger element
1141 continue;
1142 }
1143 stationFitterTimer.stop();
1144
1145 // Track fitting
1146 trackFitterTimer.start();
1147 sc = m_trackFitter->findTracks(*p_roids,
1148 clusterFitResults.at(i_road),
1149 tmp_trkPats);
1150
1151 if (!sc.isSuccess()) {
1152 ATH_MSG_WARNING("Track fitter failed");
1153 continue;
1154 }
1155 trackFitterTimer.stop();
1156
1157 // fix if eta is strange
1158 const float ETA_LIMIT = 2.8;
1159 const float DELTA_ETA_LIMIT = 1.0;
1160 for (TrigL2MuonSA::TrackPattern& track : tmp_trkPats) {
1161 float roiEta = (*p_roi)->eta();
1162 if (std::abs(track.pt) > ZERO_LIMIT
1163 && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
1164 track.etaMap = roiEta;
1165 }
1166 }
1167
1168 // Track extrapolation for ID combined
1169 trackExtraTimer.start();
1170
1171 sc = m_trackExtrapolator->extrapolateTrack(tmp_trkPats, m_winPt);
1172 ATH_MSG_DEBUG("test trackExtrapolator end");
1173
1174 if (sc != StatusCode::SUCCESS) {
1175 ATH_MSG_WARNING("Track extrapolator failed");
1176 // Update output trigger element
1177 continue;
1178 }
1179 trackExtraTimer.stop();
1180
1181 if(tmp_trkPats.size() > 0){
1182 ATH_MSG_DEBUG("temp pT calculated 2mu-in-1RoI alg = " << tmp_trkPats[0].pt << " GeV");
1183 if( (std::abs(tmp_trkPats[0].barrelSagitta) < ZERO_LIMIT &&
1184 std::abs(tmp_trkPats[0].barrelRadius) < ZERO_LIMIT) ||
1185 std::abs(tmp_trkPats[0].pt) < ZERO_LIMIT )
1186 continue;
1187 trackPatterns.push_back(tmp_trkPats[0]);
1188 }
1189
1190 storeMuonSA(*p_roi, *p_roids, clusterRoad.at(i_road), mdtRegion, rpcHits, tgcHits,
1191 clusterFitResults.at(i_road), tgcFitResult, mdtHits_cluster_normal.at(i_road), cscHits,
1192 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1193
1194 } // end the clusterRoad loop
1195 if(trackPatterns.empty()){
1196 ATH_MSG_DEBUG("multi-track SA falied to reconstruct muons");
1197 trackPatterns.emplace_back();
1198 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1199 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1200 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1201
1202 continue;
1203 }
1204 } else { // Endcap
1205 ATH_MSG_DEBUG("Endcap");
1206 if(!m_doEndcapForl2mt){
1207 ATH_MSG_DEBUG("multi-track SA does nothings and skips for EndcapRoI");
1208 } else {
1209 prepTimer.start();
1210 // Data preparation
1211 sc = m_dataPreparator->prepareData(ctx,
1212 *p_roi,
1213 *p_roids,
1215 tgcHits,
1216 muonRoad,
1217 mdtRegion,
1218 tgcFitResult,
1219 mdtHits,
1220 cscHits,
1221 stgcHits,
1222 mmHits);
1223 if (!sc.isSuccess()) {
1224 ATH_MSG_WARNING("Data preparation failed");
1225 trackPatterns.emplace_back();
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
static const double 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 390 of file MuFastSteering.cxx.

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

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

◆ 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 // initialize handle keys.
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()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const
inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

68 {
69 return true;
70 }

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

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

99 {
101 }
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Set filter decision:

◆ 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
constexpr T wrapToPi(T phi)
Wrap angle in radians to [-pi, pi].
Definition phihelper.h:31
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 ) = std::move(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 ) = std::move(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
SG::Accessor< T, ALLOC > Accessor
Definition AuxElement.h:573
@ 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 AthCommonAlgorithm< 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.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

41{
42 return BaseAlg::sysExecute (ctx);
43}

◆ sysInitialize()

StatusCode AthCommonAlgorithm< 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 AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

71 {
73
74 if (sc.isFailure()) {
75 return sc;
76 }
77
78 ServiceHandle<ICondSvc> cs("CondSvc",name());
79 for (auto h : outputHandles()) {
80 if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
81 // do this inside the loop so we don't create the CondSvc until needed
82 if ( cs.retrieve().isFailure() ) {
83 ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
85 }
86 if (cs->regHandle(this,*h).isFailure()) {
88 ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
89 << " with CondSvc");
90 }
91 }
92 }
93 return sc;
94}
virtual StatusCode sysInitialize() override
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 AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.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: