ATLAS Offline Software
Loading...
Searching...
No Matches
Classes | Functions | Variables
python.HLT.Muon.MuonRecoSequences Namespace Reference

Classes

class  muonNames

Functions

 isCosmic (flags)
 isLRT (name)
 getIDTracks (flags, name='', muonIDreuse=False, precision=False, suffix='')
 MuDataPrepViewDataVerifierCfg (flags)
 muonDecodeCfg (flags, RoIs)
 muFastVDVCfg (flags, RoIs, postFix, InsideOutMode, extraLoads)
 muFastRecoSequenceCfg (flags, RoIs, doFullScanID=False, InsideOutMode=False, extraLoads=None, l2mtmode=False, calib=False, useNewFast=False)
 muonIDtrackVDVCfg (flags, name, RoIs, extraLoads=None, extraLoadsForl2mtmode=None)
 muonIDFastTrackingSequenceCfg (flags, RoIs, name, extraLoads=None, extraLoadsForl2mtmode=None, doLRT=False, trackingMode="FTF")
 muonIDCosmicTrackingSequenceCfg (flags, RoIs, name, extraLoads=None, extraLoadsForl2mtmode=None)
 muCombVDVCfg (flags, postFix)
 muCombRecoSequenceCfg (flags, RoIs, name, l2mtmode=False, l2CBname="")
 EFMuSADataPrepViewDataVerifierCfg (flags, RoIs, suffix="")
 muEFSARecoSequenceCfg (flags, RoIs, suffix="", useBucketFilter=False)
 VDVEFMuCBCfg (flags, RoIs, name, suffix)
 VDVPrecMuTrkCfg (flags, name, suffix)
 VDVidReuseITkCfg (flags, suffix)
 muEFCBRecoSequenceCfg (flags, RoIs, name, suffix)
 VDVMuInsideOutCfg (flags, name, candidatesName, suffix)
 muEFInsideOutRecoSequenceCfg (flags, RoIs, name, suffix)
 VDVMuIsoCfg (flags, name, RoIs)
 efmuisoRecoSequenceCfg (flags, RoIs, Muons, doMSiso=False)
 VDVLateMuCfg (flags)
 efLateMuRoISequenceCfg (flags)

Variables

 log = logging.getLogger(__name__)
 CBTPname = recordable("HLT_CBCombinedMuon_RoITrackParticles")
 CBTPnameFS = recordable("HLT_CBCombinedMuon_FSTrackParticles")
 CBTPnameLRT = recordable("HLT_CBCombinedMuon_LRTTrackParticles")
 ExtrpTPname = recordable("HLT_MSExtrapolatedMuons_RoITrackParticles")
 ExtrpTPnameFS = recordable("HLT_MSExtrapolatedMuons_FSTrackParticles")
 MSextrpTPname = recordable("HLT_MSOnlyExtrapolatedMuons_FSTrackParticles")
 muNames = muonNames().getNames('RoI')
 muNamesFS = muonNames().getNames('FS')
 muNamesLRT = muonNames().getNames('LRT')

Function Documentation

◆ efLateMuRoISequenceCfg()

python.HLT.Muon.MuonRecoSequences.efLateMuRoISequenceCfg ( flags)

Definition at line 763 of file MuonRecoSequences.py.

763def efLateMuRoISequenceCfg(flags):
764
765 acc = VDVLateMuCfg(flags)
766
767 from TrigmuRoI.TrigmuRoIConfig import TrigmuRoIConfig
768 sequenceOut = "LateMuRoIs"
769 acc.merge(TrigmuRoIConfig(flags, "TrigmuRoI", outputRoIs=sequenceOut))
770
771 return acc, sequenceOut

◆ efmuisoRecoSequenceCfg()

python.HLT.Muon.MuonRecoSequences.efmuisoRecoSequenceCfg ( flags,
RoIs,
Muons,
doMSiso = False )

Definition at line 727 of file MuonRecoSequences.py.

727def efmuisoRecoSequenceCfg( flags, RoIs, Muons, doMSiso=False ):
728
729 name = ""
730 if doMSiso:
731 name = "MS"
732 acc = VDVMuIsoCfg(flags, name, RoIs)
733
734 acc.merge(muonIDFastTrackingSequenceCfg(flags, RoIs, "muonIso"+name ))
735
736 from TrigInDetConfig.TrigInDetConfig import trigInDetPrecisionTrackingCfg
737 muIsoFlags = getFlagsForActiveConfig(flags, "muonIso"+name, log)
738 acc.merge(trigInDetPrecisionTrackingCfg(muIsoFlags, rois= RoIs, signatureName="muonIso"+name, in_view=False))
739 trackParticles = muIsoFlags.Tracking.ActiveConfig.tracks_IDTrig
740
741 # Isolation alg
742 from TrigMuonEF.TrigMuonEFConfig import TrigMuonEFTrackIsolationAlgCfg
743 acc.merge(TrigMuonEFTrackIsolationAlgCfg(flags,name="TrigEFMuIso"+name, requireCombinedMuon = not doMSiso,
744 MuonEFContainer = Muons,IdTrackParticles = trackParticles, MuonContName = muNames.EFIsoMuonName+name,
745 ptcone02Name = muNames.EFIsoMuonName+name + ".ptcone02",
746 ptcone03Name = muNames.EFIsoMuonName+name + ".ptcone03"))
747
748 return acc
749

◆ EFMuSADataPrepViewDataVerifierCfg()

python.HLT.Muon.MuonRecoSequences.EFMuSADataPrepViewDataVerifierCfg ( flags,
RoIs,
suffix = "" )

Definition at line 335 of file MuonRecoSequences.py.

335def EFMuSADataPrepViewDataVerifierCfg(flags, RoIs, suffix=""):
336 result=ComponentAccumulator()
337 dataObjects=[( 'xAOD::EventInfo' , 'StoreGateSvc+EventInfo' ),
338 ( 'TrigRoiDescriptorCollection' , 'StoreGateSvc+%s' % RoIs )]
339
340 if flags.Muon.usePhaseIIGeoSetup:
341 dataObjects += [( 'ActsGeometryContext' , 'StoreGateSvc+ActsAlignment' )]
342
343 if flags.Muon.setupTruthAlgorithms:
344 dataObjects += [( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+MDT_SDO' ),
345 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+MM_SDO' ),
346 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+RPC_SDO' ),
347 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+TGC_SDO' ),
348 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+sTGC_SDO' ),
349 ( 'McEventCollection' , 'StoreGateSvc+TruthEvent' ),
350 # Truth muons containers and decorations
351 ( 'xAOD::TruthParticleContainer' , 'StoreGateSvc+MuonTruthParticles' ),
352 ( 'xAOD::TruthParticleContainer' , 'StoreGateSvc+MuonTruthParticles.truthClassification' ),
353 ( 'xAOD::TruthParticleContainer' , 'StoreGateSvc+MuonTruthParticles.truthOrigin' ),
354 ( 'xAOD::TruthParticleContainer' , 'StoreGateSvc+MuonTruthParticles.truthParticleLink' ),
355 ( 'xAOD::TruthParticleContainer' , 'StoreGateSvc+MuonTruthParticles.truthType' ),
356 # Truth segments and SDO-to-segment links
357 ( 'xAOD::MuonSegmentContainer' , 'StoreGateSvc+MuonTruthSegments' ),
358 ( 'xAOD::MuonSegmentContainer' , 'StoreGateSvc+MuonTruthSegments.charge' ),
359 ( 'xAOD::MuonSegmentContainer' , 'StoreGateSvc+MuonTruthSegments.localSegPars' ),
360 ( 'xAOD::MuonSegmentContainer' , 'StoreGateSvc+MuonTruthSegments.pt' ),
361 ( 'xAOD::MuonSegmentContainer' , 'StoreGateSvc+MuonTruthSegments.simHitLinks' ),
362 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+MDT_SDO.truthSegmentLink' ),
363 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+MM_SDO.truthSegmentLink' ),
364 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+RPC_SDO.truthSegmentLink' ),
365 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+TGC_SDO.truthSegmentLink' ),
366 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+sTGC_SDO.truthSegmentLink' ),
367 # Truth segment to truth particle links
368 ( 'xAOD::MuonSegmentContainer' , 'StoreGateSvc+MuonTruthSegments.truthParticleLink' ),
369 ( 'xAOD::TruthParticleContainer' , 'StoreGateSvc+MuonTruthParticles.truthSegmentLinks' )]
370
371 alg = CompFactory.AthViews.ViewDataVerifier( name = f"VDVMuEFSA_{suffix}",
372 DataObjects = dataObjects)
373 result.addEventAlgo(alg)
374 return result
375
376

◆ getIDTracks()

python.HLT.Muon.MuonRecoSequences.getIDTracks ( flags,
name = '',
muonIDreuse = False,
precision = False,
suffix = '' )

Definition at line 70 of file MuonRecoSequences.py.

70def getIDTracks(flags, name='', muonIDreuse=False, precision=False, suffix=''):
71
72 if muonIDreuse or suffix != '':
73 if isLRT(name):
74 return 'HLT_IDTrack_MuonComb_FTF_LRT'
75 elif isCosmic(flags):
76 return 'HLT_IDTrack_MuonComb_FTF'
77 else:
78 return 'HLT_IDTrack_MuonComb_FTF'+suffix
79
80 else:
81 if precision:
82 return flags.Tracking.ActiveConfig.tracks_IDTrig
83 else:
84 if isLRT(name):
85 return flags.Trigger.InDetTracking.muonLRT.tracks_FTF
86 elif isCosmic(flags):
87 return flags.Trigger.InDetTracking.cosmics.tracks_IDTrig
88 else:
89 return flags.Trigger.InDetTracking.muon.tracks_FTF
90
91

◆ isCosmic()

python.HLT.Muon.MuonRecoSequences.isCosmic ( flags)

Definition at line 62 of file MuonRecoSequences.py.

62def isCosmic(flags):
63 #FIXME: this might not be ideal criteria to determine if this is cosmic chain but used to work in Run2 and will do for now, ATR-22758
64 return (flags.Beam.Type == BeamType.Cosmics)
65

◆ isLRT()

python.HLT.Muon.MuonRecoSequences.isLRT ( name)

Definition at line 66 of file MuonRecoSequences.py.

66def isLRT(name):
67 return "LRT" in name
68
69#Returns relevant track collection name

◆ muCombRecoSequenceCfg()

python.HLT.Muon.MuonRecoSequences.muCombRecoSequenceCfg ( flags,
RoIs,
name,
l2mtmode = False,
l2CBname = "" )

Definition at line 319 of file MuonRecoSequences.py.

319def muCombRecoSequenceCfg( flags, RoIs, name, l2mtmode=False, l2CBname="" ):
320
321 acc = ComponentAccumulator()
322 postFix = ""
323 if l2mtmode:
324 postFix = "l2mtmode"
325
326 acc.merge(muCombVDVCfg(flags, postFix))
327 from TrigmuComb.TrigmuCombConfig import muCombCfg
328 l2trackname = getIDTracks(flags) if l2mtmode else getIDTracks(flags, name)
329 acc.merge(muCombCfg(flags, f'{postFix}_{name}', useBackExtrp=True,
330 L2StandAloneMuonContainerName = muNames.L2SAName+postFix,
331 L2CombinedMuonContainerName = l2CBname, TrackParticleContainerName = l2trackname ))
332
333 return acc
334

◆ muCombVDVCfg()

python.HLT.Muon.MuonRecoSequences.muCombVDVCfg ( flags,
postFix )

Definition at line 311 of file MuonRecoSequences.py.

311def muCombVDVCfg( flags, postFix):
312 result=ComponentAccumulator()
313 dataObjects=[('xAOD::L2StandAloneMuonContainer','StoreGateSvc+%s' % muNames.L2SAName+postFix)]
314 ViewVerify = CompFactory.AthViews.ViewDataVerifier("muCombAlgVDV"+postFix, DataObjects = dataObjects)
315 result.addEventAlgo(ViewVerify)
316 return result
317
318

◆ MuDataPrepViewDataVerifierCfg()

python.HLT.Muon.MuonRecoSequences.MuDataPrepViewDataVerifierCfg ( flags)

Definition at line 92 of file MuonRecoSequences.py.

92def MuDataPrepViewDataVerifierCfg(flags):
93 result = ComponentAccumulator()
94
95 # Cache
96 dataObjects=[( 'RpcPrepDataCollection_Cache' , 'StoreGateSvc+RpcPrdCache' ),
97 ( 'TgcRdo_Cache' , 'StoreGateSvc+TgcRdoCache' ),
98 ( 'MdtCsm_Cache' , 'StoreGateSvc+MdtCsmRdoCache' ),
99 ( 'RpcPad_Cache' , 'StoreGateSvc+RpcRdoCache' ),
100 ( 'RpcCoinDataCollection_Cache' , 'StoreGateSvc+RpcCoinCache' ),
101 ( 'TgcPrepDataCollection_Cache' , 'StoreGateSvc+' + MuonPrdCacheNames.TgcCache + 'AllBCs' ),
102 ( 'TgcCoinDataCollection_Cache' , 'StoreGateSvc+' + MuonPrdCacheNames.TgcCoinCache + 'PriorBC' ),
103 ( 'TgcCoinDataCollection_Cache' , 'StoreGateSvc+' + MuonPrdCacheNames.TgcCoinCache + 'NextBC' ),
104 ( 'TgcCoinDataCollection_Cache' , 'StoreGateSvc+' + MuonPrdCacheNames.TgcCoinCache + 'NextNextBC' ),
105 ( 'TgcCoinDataCollection_Cache' , 'StoreGateSvc+' + MuonPrdCacheNames.TgcCoinCache )
106 ]
107
108 if flags.Detector.GeometrysTGC:
109 dataObjects += [( 'sTgcPrepDataCollection_Cache' , 'StoreGateSvc+' + MuonPrdCacheNames.sTgcCache)]
110 if flags.Input.isMC:
111 dataObjects += [( 'Muon::STGC_RawDataContainer' , 'StoreGateSvc+sTGCRDO' )]
112
113 if flags.Detector.GeometryMM:
114 dataObjects += [( 'MMPrepDataCollection_Cache' , 'StoreGateSvc+' + MuonPrdCacheNames.MmCache)]
115 if flags.Input.isMC:
116 dataObjects += [( 'Muon::MM_RawDataContainer' , 'StoreGateSvc+MMRDO' )]
117
118 if flags.Detector.GeometryCSC:
119 dataObjects+=[( 'CscRawDataCollection_Cache' , 'StoreGateSvc+CscRdoCache' )]
120 if flags.Input.isMC:
121 dataObjects += [( 'CscRawDataContainer' , 'StoreGateSvc+CSCRDO' ),
122 ( 'CscRawDataCollection_Cache' , 'StoreGateSvc+CscRdoCache' )]
123
124 if flags.Input.isMC:
125 dataObjects += [( 'MdtCsmContainer' , 'StoreGateSvc+MDTCSM' ),
126 *( [( 'RpcPadContainer' , 'StoreGateSvc+RPCPAD' )] if "RPCPAD" in flags.Input.Collections else [] ),
127 *( [( 'xAOD::NRPCRDOContainer' , 'StoreGateSvc+NRPCRDO' )] if flags.Muon.enableNRPC else [] ),
128 ('TgcRdoContainer' , 'StoreGateSvc+TGCRDO' )]
129
130 if flags.Muon.usePhaseIIGeoSetup:
131 dataObjects += [('ActsTrk::GeometryContext' , 'StoreGateSvc+ActsAlignment' )]
132
133 alg = CompFactory.AthViews.ViewDataVerifier( name = "VDVMuDataPrep",
134 DataObjects = dataObjects)
135 result.addEventAlgo(alg)
136 return result
137
138

◆ muEFCBRecoSequenceCfg()

python.HLT.Muon.MuonRecoSequences.muEFCBRecoSequenceCfg ( flags,
RoIs,
name,
suffix )

Definition at line 555 of file MuonRecoSequences.py.

555def muEFCBRecoSequenceCfg( flags, RoIs, name, suffix ):
556
557
558 from MuonCombinedAlgs.MuonCombinedAlgsMonitoring import MuonCreatorAlgMonitoring
559 from MuonCombinedConfig.MuonCombinedReconstructionConfig import MuonCreatorAlgCfg, MuonCombinedAlgCfg, MuonCombinedInDetCandidateAlgCfg
560 acc = ComponentAccumulator()
561
562 acc.merge(VDVEFMuCBCfg(flags, RoIs, name, suffix))
563
564 if "FS" in name:
565 #Need to run tracking for full scan chains
566 from TrigInDetConfig.TrigInDetConfig import trigInDetFastTrackingCfg
567 acc.merge(trigInDetFastTrackingCfg( flags, roisKey=RoIs, signatureName="muonFS" ))
568
569 else:
570 acc.merge(VDVPrecMuTrkCfg(flags, name, suffix))
571
572
573 #Precision Tracking
574 from TrigInDetConfig.TrigInDetConfig import trigInDetPrecisionTrackingCfg
575 #When run in a different view than FTF some data dependencies needs to be loaded through verifier
576 #Pass verifier as an argument and it will automatically append necessary DataObjects
577 #@NOTE: Don't provide any verifier if loaded in the same view as FTF
578 if isCosmic(flags) and 'LRT' not in name:
579 trackParticles=getIDTracks(flags, name, muonIDreuse=flags.Muon.enableTrigIDtrackReuse)
580 elif 'LRT' in name:
581 muLrtFlags = getFlagsForActiveConfig(flags, "muonLRT", log)
582 acc.merge(trigInDetPrecisionTrackingCfg(muLrtFlags, rois= RoIs, signatureName="muonLRT"))
583 trackParticles = getIDTracks(muLrtFlags, name, precision=True)
584 elif 'FS' in name:
585 muFsFlags = getFlagsForActiveConfig(flags, "muonFS", log)
586 acc.merge(trigInDetPrecisionTrackingCfg(muFsFlags, rois= RoIs, signatureName="muonFS", in_view=False))
587 trackParticles = getIDTracks(muFsFlags, precision=True)
588 else:
589 muFlags = getFlagsForActiveConfig(flags, "muon", log)
590 if not flags.Muon.enableTrigIDtrackReuse and suffix == '':
591 acc.merge(trigInDetPrecisionTrackingCfg(muFlags, rois= RoIs, signatureName="muon"))
592 trackParticles=getIDTracks(muFlags, name, muonIDreuse=flags.Muon.enableTrigIDtrackReuse, precision=True, suffix=suffix)
593
594 if flags.Muon.enableTrigIDtrackReuse or suffix != '':
595 if 'LRT' not in name or 'FS' not in name:
596 if flags.GeoModel.Run > LHCPeriod.Run3:
597 acc.merge(VDVidReuseITkCfg(flags, suffix))
598 if suffix != 'idReuse':
599 MuonL2CBInputContainer = muNames.L2CBName+suffix
600 else:
601 MuonL2CBInputContainer = muNames.L2CBName
602 from TrigMuonEF.TrigMuonEFConfig import GetL2CBmuonInDetTracksAlgCfg
603 acc.merge(GetL2CBmuonInDetTracksAlgCfg(flags, name="GetL2CBInDetTracks"+suffix,
604 MuonL2CBContainerLocation=MuonL2CBInputContainer,
605 IDtrackOutputLocation="HLT_IDTrack_MuonComb_FTF"+suffix))
606
607 #Make InDetCandidates
608 acc.merge(MuonCombinedInDetCandidateAlgCfg(flags, name="TrigMuonCombinedInDetCandidateAlg_"+name+suffix,TrackParticleLocation = [trackParticles], InDetCandidateLocation="InDetCandidates_"+name+suffix))
609
610
611 #MS ID combination
612 candidatesName = "MuonCandidates"
613 if 'FS' in name:
614 candidatesName = "MuonCandidates_FS"
615
616 acc.merge(MuonCombinedAlgCfg(flags,name="TrigMuonCombinedAlg_"+name+suffix, MuonCandidateLocation=candidatesName, InDetCandidateLocation="InDetCandidates_"+name+suffix))
617
618 cbMuonName = muNames.EFCBOutInName
619 if 'FS' in name:
620 cbMuonName = muNamesFS.EFCBOutInName
621 elif 'LRT' in name:
622 cbMuonName = muNamesLRT.EFCBName
623
624
625 acc.merge(MuonCreatorAlgCfg(flags, name="TrigMuonCreatorAlgCB_"+name+suffix, MuonCandidateLocation=[candidatesName], TagMaps=["muidcoTagMap"], InDetCandidateLocation="InDetCandidates_"+name+suffix,
626 MuonContainerLocation = cbMuonName+suffix, ExtrapolatedLocation = "CBExtrapolatedMuons"+suffix,
627 MSOnlyExtrapolatedLocation = "CBMSonlyExtrapolatedMuons"+suffix, CombinedLocation = "HLT_CBCombinedMuon_"+name+suffix,
628 MonTool = MuonCreatorAlgMonitoring(flags, "MuonCreatorAlgCB_"+name+suffix)))
629
630
631
632 return acc
633
634

◆ muEFInsideOutRecoSequenceCfg()

python.HLT.Muon.MuonRecoSequences.muEFInsideOutRecoSequenceCfg ( flags,
RoIs,
name,
suffix )

Definition at line 654 of file MuonRecoSequences.py.

654def muEFInsideOutRecoSequenceCfg(flags, RoIs, name, suffix ):
655
656 from MuonConfig.MuonSegmentFindingConfig import MuonSegmentFinderAlgCfg, MuonLayerHoughAlgCfg
657 from MuonCombinedAlgs.MuonCombinedAlgsMonitoring import MuonCreatorAlgMonitoring
658 from MuonCombinedConfig.MuonCombinedReconstructionConfig import MuonCreatorAlgCfg, MuGirlStauAlgCfg, StauCreatorAlgCfg, MuonInDetToMuonSystemExtensionAlgCfg, MuonInsideOutRecoAlgCfg, MuonCombinedInDetCandidateAlgCfg
659 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonInsideOutRecoToolCfg
660
661 acc = ComponentAccumulator()
662
663 candidatesName = "MuonCandidates"
664 if 'FS' in name:
665 candidatesName = "MuonCandidates_FS"
666
667 if "Late" in name:
668
669 #Need to run hough transform at start of late muon chain
670 acc.merge(MuonLayerHoughAlgCfg(flags, "TrigMuonLayerHoughAlg_"+name,MuonPatternCombinationCollection="MuonLayerHoughCombis_"+name,
671 Key_MuonLayerHoughToolHoughDataPerSectorVec="HoughDataPerSectorVec_"+name))
672
673 acc.merge(MuonSegmentFinderAlgCfg(flags, "TrigMuonSegmentMaker_"+name,MuonLayerHoughCombisKey="MuonLayerHoughCombis_"+name))
674
675
676 # need to run precisions tracking for late muons, since we don't run it anywhere else
677 from TrigInDetConfig.TrigInDetConfig import trigInDetPrecisionTrackingCfg
678 muLateFlags = getFlagsForActiveConfig(flags, "muonLate", log)
679 acc.merge(trigInDetPrecisionTrackingCfg(muLateFlags, rois= RoIs, signatureName="muonLate", in_view=False))
680 trackParticles = muLateFlags.Tracking.ActiveConfig.tracks_IDTrig
681
682 #Make InDetCandidates
683 acc.merge(MuonCombinedInDetCandidateAlgCfg(flags, name="TrigMuonCombinedInDetCandidateAlg_"+name,TrackParticleLocation=[trackParticles],ForwardParticleLocation=trackParticles,InDetCandidateLocation="InDetCandidates_"+name,ExtendBulk=True))
684
685 else:
686 # for non-latemu chains, the decoding/hough transform is run in an earlier step
687 #Need PRD containers for inside-out reco
688 acc.merge(VDVMuInsideOutCfg(flags, name, candidatesName, suffix))
689
690 #Inside-out reconstruction
691
692 cbMuonName = muNames.EFCBInOutName+suffix
693 if 'Late' in name:
694 cbMuonName = recordable(cbMuonName+"_Late")
695 acc.merge(MuGirlStauAlgCfg(flags, name="TrigMuonLateInsideOutRecoAlg_"+name,InDetCandidateLocation="InDetCandidates_"+name))
696 acc.merge(StauCreatorAlgCfg(flags, name="TrigLateMuonCreatorAlg_"+name, TagMaps=["stauTagMap"], SegmentContainerName="", InDetCandidateLocation="InDetCandidates_"+name,
697 MuonContainerLocation=cbMuonName, MonTool=MuonCreatorAlgMonitoring(flags, "LateMuonCreatorAlg_"+name)))
698 else:
699 acc.merge(MuonInDetToMuonSystemExtensionAlgCfg(flags, name="TrigInDetMuonExtensionAlg_"+name+suffix, InputInDetCandidates="InDetCandidates_"+name+suffix,
700 WriteInDetCandidates="InDetCandidatesSystemExtended_"+name+suffix))
701 if 'RoI' in name:
702 ioTool = MuonInsideOutRecoToolCfg(flags, MuonLayerSegmentFinderTool="", InputSegments="TrackMuonSegments")
703 else:
704 ioTool = MuonInsideOutRecoToolCfg(flags)
705 InsideOutRecoTool = acc.popToolsAndMerge(ioTool)
706
707 acc.merge(MuonInsideOutRecoAlgCfg(flags, name="TrigMuonInsideOutRecoAlg_"+name+suffix,InDetCandidateLocation="InDetCandidatesSystemExtended_"+name+suffix, MuonCombinedInDetExtensionTool=InsideOutRecoTool))
708
709 acc.merge(MuonCreatorAlgCfg(flags, name="TrigMuonCreatorAlgInsideOut_"+name+suffix, MuonCandidateLocation=[candidatesName], TagMaps=["muGirlTagMap"],InDetCandidateLocation="InDetCandidates_"+name+suffix,
710 MuonContainerLocation = cbMuonName, ExtrapolatedLocation = "InsideOutCBExtrapolatedMuons"+suffix,
711 MSOnlyExtrapolatedLocation = "InsideOutCBMSOnlyExtrapolatedMuons"+suffix, CombinedLocation = "InsideOutCBCombinedMuon"+suffix, MonTool = MuonCreatorAlgMonitoring(flags, "MuonCreatorAlgInsideOut_"+name+suffix)))
712
713 return acc
714
715

◆ muEFSARecoSequenceCfg()

python.HLT.Muon.MuonRecoSequences.muEFSARecoSequenceCfg ( flags,
RoIs,
suffix = "",
useBucketFilter = False )

Definition at line 377 of file MuonRecoSequences.py.

377def muEFSARecoSequenceCfg( flags, RoIs, suffix="", useBucketFilter=False):
378
379 acc = ComponentAccumulator()
380
381 acc.merge(EFMuSADataPrepViewDataVerifierCfg(flags, RoIs=RoIs, suffix=suffix))
382
383 msMuonName = muNames.EFSAName
384 if 'FS' in suffix:
385 msMuonName = muNamesFS.EFSAName
386
387 if flags.Muon.usePhaseIIGeoSetup and flags.Muon.scheduleActsReco:
388
389 # Schedule reco-to-truth object association
390 if flags.Muon.setupTruthAlgorithms:
391 from MuonObjectMarker.ObjectMarkerConfig import TruthMeasMarkerAlgCfg
392 acc.merge(TruthMeasMarkerAlgCfg(flags, name = f"TruthMeasMarkerAlg{suffix}"))
393 from MuonTruthAlgsR4.MuonTruthAlgsConfig import TruthHitAssociationCfg, RecoSegmentTruthAssocCfg, MuonToTruthAssocAlgCfg
394 acc.merge(TruthHitAssociationCfg(flags, useSDO=True, suffix=suffix))
395 acc.merge(RecoSegmentTruthAssocCfg(flags, name=f"MuonSegmentsFromR4TruthMatching{suffix}",
396 SegmentKey="MuonSegmentsFromR4"))
397 acc.merge(MuonToTruthAssocAlgCfg(flags, name=f'MuonToTruthMatchingAlg{suffix}'))
398
399 # ML bucket filter
400 if useBucketFilter:
401 from MuonInference.InferenceConfig import GraphBucketFilterToolCfg, GraphInferenceAlgCfg
402 bucketTool = acc.popToolsAndMerge(GraphBucketFilterToolCfg(flags, name=f"GraphBucketFilterTool{suffix}",
403 WriteSpacePointKey=f"FilteredMlBuckets{suffix}"))
404 acc.merge(GraphInferenceAlgCfg(flags, name = f"GraphInferenceAlg{suffix}",
405 InferenceTools=[bucketTool]))
406
407 # Pattern recognition & segment fitting
408 from MuonPatternRecognitionAlgs.MuonPatternRecognitionConfig import MuonEtaHoughTransformAlgCfg, MuonNSWSegmentFinderAlgCfg, MuonPhiHoughTransformAlgCfg, MuonSegmentFittingAlgCfg
409 segmentContainers = []
410 if flags.Detector.GeometrysTGC or flags.Detector.GeometryMM:
411 segmentContainers+=["MuonNswSegments"]
412 acc.merge(MuonEtaHoughTransformAlgCfg(flags, name=f"MuonNswEtaHoughTransformAlg{suffix}",
413 EtaHoughMaxContainer = "MuonHoughNswMaxima",
414 SpacePointContainer = "NswSpacePoints"))
415 acc.merge(MuonNSWSegmentFinderAlgCfg(flags, name=f"MuonNswSegmentFinderAlg{suffix}",
416 MuonNswSegmentWriteKey = segmentContainers[-1],
417 MuonNswSegmentSeedWriteKey = "MuonNswSegmentSeeds",
418 CombinatorialReadKey = "MuonHoughNswMaxima"))
419
420 if flags.Detector.GeometryMDT or flags.Detector.GeometryRPC or flags.Detector.GeometryTGC:
421 if flags.Muon.enableMLBucketFilter:
422 acc.merge(MuonEtaHoughTransformAlgCfg(flags, name = f"MuonEtaHoughTransformAlg{suffix}",
423 SpacePointContainer = "FilteredMlBuckets"))
424 else:
425 acc.merge(MuonEtaHoughTransformAlgCfg(flags, name = f"MuonEtaHoughTransformAlg{suffix}"))
426
427 acc.merge(MuonPhiHoughTransformAlgCfg(flags, name = f"MuonPhiHoughTransformAlg{suffix}"))
428
429 segmentContainers+=["R4MuonSegments"]
430 acc.merge(MuonSegmentFittingAlgCfg(flags, name = f"MuonSegmentFittingAlg{suffix}",
431 OutSegmentContainer=segmentContainers[-1]))
432
433 from MuonSegmentCnv.MuonSegmentCnvConfig import xAODSegmentCnvAlgCfg
434 acc.merge(xAODSegmentCnvAlgCfg(flags, name = f"MuonR4xAODSegmentCnvAlg{suffix}",
435 InSegmentKeys = segmentContainers))
436
437 from MuonSegmentCnv.MuonSegmentCnvConfig import MuonR4SegmentCnvAlgCfg
438 acc.merge(MuonR4SegmentCnvAlgCfg(flags, name=f"MuonR4SegmentCnvAlg{suffix}",
439 ReadSegments = segmentContainers,
440 WriteKey="TrackMuonSegments"))
441
442 # Track building
443 from MuonTrackFindingAlgs.TrackFindingConfig import MSTrackFinderAlgCfg, StandaloneTrackPartCnvCfg, MuidSaTagMakerAlgCfg, MuonCreatorAlgCfg
444 acc.merge(MSTrackFinderAlgCfg(flags, name=f"MSTrackFinderAlg{suffix}"))
445 trackContainer = f"HLT_MSMuons_{suffix}"
446 acc.merge(StandaloneTrackPartCnvCfg(flags, name=f"MuonMsTrackParticleCnvR4{suffix}",
447 TrackParticlesOutKey = trackContainer))
448 acc.merge(MuidSaTagMakerAlgCfg(flags, name=f"MuidSaTagMakerAlg{suffix}",
449 MsTracks = trackContainer))
450 acc.merge(MuonCreatorAlgCfg(flags, name = f"MuonActsCreatorAlg{suffix}",
451 TagKeys = ["MuonTagsSA"],
452 MuonKey = msMuonName))
453
454 else:
455 from MuonConfig.MuonSegmentFindingConfig import MuonSegmentFinderAlgCfg, MuonLayerHoughAlgCfg
456 acc.merge(MuonLayerHoughAlgCfg(flags, f"TrigMuonLayerHoughAlg{suffix}"))
457 acc.merge(MuonSegmentFinderAlgCfg(flags, f"TrigMuonSegmentMaker{suffix}"))
458
459 from MuonSegmentTrackMaker.MuonTrackMakerAlgsMonitoring import MuPatTrackBuilderMonitoring
460 from MuonConfig.MuonTrackBuildingConfig import MuPatTrackBuilderCfg
461 from xAODTrackingCnv.xAODTrackingCnvConfig import MuonStandaloneTrackParticleCnvAlgCfg
462 acc.merge(MuPatTrackBuilderCfg(flags, name=f"TrigMuPatTrackBuilder{suffix}",
463 MuonSegmentCollection = "TrackMuonSegments",
464 MonTool = MuPatTrackBuilderMonitoring(flags, f"MuPatTrackBuilderMonitoringSA{suffix}")))
465
466 acc.merge(MuonStandaloneTrackParticleCnvAlgCfg(flags, name = f"TrigMuonStandaloneTrackParticleCnvAlg{suffix}"))
467 from MuonCombinedConfig.MuonCombinedReconstructionConfig import MuonCombinedMuonCandidateAlgCfg, MuonCreatorAlgCfg
468 from MuonCombinedAlgs.MuonCombinedAlgsMonitoring import MuonCreatorAlgMonitoring
469 acc.merge(MuonCombinedMuonCandidateAlgCfg(flags, name=f"TrigMuonCandidateAlg{suffix}"))
470 acc.merge(MuonCreatorAlgCfg(flags, name=f"TrigMuonCreatorAlg_{suffix}",
471 CreateSAmuons=True,
472 TagMaps=[],
473 MuonContainerLocation=msMuonName,
474 ExtrapolatedLocation = f"HLT_MSExtrapolatedMuons_{suffix}",
475 MSOnlyExtrapolatedLocation = f"HLT_MSOnlyExtrapolatedMuons_{suffix}",
476 MonTool = MuonCreatorAlgMonitoring(flags, f"MuonCreatorAlgSA_{suffix}")))
477
478 sequenceOut = msMuonName
479
480 return acc, sequenceOut
481
482
483

◆ muFastRecoSequenceCfg()

python.HLT.Muon.MuonRecoSequences.muFastRecoSequenceCfg ( flags,
RoIs,
doFullScanID = False,
InsideOutMode = False,
extraLoads = None,
l2mtmode = False,
calib = False,
useNewFast = False )

Definition at line 238 of file MuonRecoSequences.py.

238def muFastRecoSequenceCfg( flags, RoIs, doFullScanID = False, InsideOutMode=False, extraLoads=None, l2mtmode=False, calib=False, useNewFast=False ):
239
240 acc = ComponentAccumulator()
241 postFix = ""
242 if InsideOutMode:
243 postFix = "IOmode"
244 elif l2mtmode:
245 postFix = "l2mtmode"
246 elif calib:
247 postFix = "Calib"
248
249 acc.merge(muFastVDVCfg(flags, RoIs, postFix, InsideOutMode, extraLoads))
250
251 if useNewFast:
252 from MuonFastRecoAlgs.MuonFastReconstructionConfig import MuonFastReconstructionAlgCfg
253 acc.merge(MuonFastReconstructionAlgCfg(flags, name=f"MuonFastReconstructionAlg_{RoIs}",
254 OutMuons=muNames.L2SANamePhII))
255 else:
256
257 from TrigL2MuonSA.TrigL2MuonSAConfig import l2MuFastAlgCfg
258 acc.merge(l2MuFastAlgCfg(flags,
259 roisKey = RoIs,
260 setup = postFix,
261 FILL_FSIDRoI = doFullScanID,
262 MuonL2SAInfo = muNames.L2SAName+postFix,
263 L2IOCB = muNames.L2CBName+postFix,
264 forID = muNames.L2forIDName+postFix,
265 forMS = "forMS"+postFix,
266 TrackParticlesContainerName = getIDTracks(flags)))
267
268
269 return acc
270

◆ muFastVDVCfg()

python.HLT.Muon.MuonRecoSequences.muFastVDVCfg ( flags,
RoIs,
postFix,
InsideOutMode,
extraLoads )

Definition at line 202 of file MuonRecoSequences.py.

202def muFastVDVCfg(flags, RoIs, postFix, InsideOutMode, extraLoads):
203 result=ComponentAccumulator()
204 # In insideout mode, need to inherit muon decoding objects for TGC, RPC, MDT, CSC
205 dataObjects=[]
206 if InsideOutMode:
207 dataObjects = [('Muon::TgcPrepDataContainer','StoreGateSvc+TGC_MeasurementsAllBCs'),
208 ('TgcRdoContainer' , 'StoreGateSvc+TGCRDO'),
209 ('Muon::RpcPrepDataContainer','StoreGateSvc+RPC_Measurements'),
210 ('Muon::MdtPrepDataContainer','StoreGateSvc+MDT_DriftCircles'),
211 *( [( 'RpcPadContainer' , 'StoreGateSvc+RPCPAD' )] if "RPCPAD" in flags.Input.Collections else [] )]
212 if flags.Detector.GeometryCSC:
213 dataObjects += [('Muon::CscPrepDataContainer','StoreGateSvc+CSC_Clusters')]
214 if flags.Detector.GeometrysTGC:
215 dataObjects += [('Muon::sTgcPrepDataContainer','StoreGateSvc+STGC_Measurements')]
216 if flags.Detector.GeometryMM:
217 dataObjects += [('Muon::MMPrepDataContainer','StoreGateSvc+MM_Measurements')]
218
219 if flags.Muon.usePhaseIIGeoSetup:
220 dataObjects += [('ActsTrk::GeometryContext' , 'StoreGateSvc+ActsAlignment' )]
221
222 else:
223 dataObjects += [( 'TrigRoiDescriptorCollection' , 'StoreGateSvc+%s' % RoIs )]
224 dataObjects += [( 'xAOD::EventInfo' , 'StoreGateSvc+EventInfo' )]
225 if flags.Trigger.enableL1MuonPhase1:
226 dataObjects += [( 'xAOD::MuonRoIContainer' , 'StoreGateSvc+LVL1MuonRoIs' )]
227 else:
228 dataObjects += [( 'DataVector< LVL1::RecMuonRoI >' , 'StoreGateSvc+HLT_RecMURoIs' )]
229
230 #For L2 multi-track SA mode
231 if extraLoads:
232 dataObjects += extraLoads
233 ViewVerify = CompFactory.AthViews.ViewDataVerifier("muFastRecoVDV"+postFix, DataObjects = dataObjects)
234
235 result.addEventAlgo(ViewVerify)
236 return result
237

◆ muonDecodeCfg()

python.HLT.Muon.MuonRecoSequences.muonDecodeCfg ( flags,
RoIs )

Definition at line 139 of file MuonRecoSequences.py.

139def muonDecodeCfg(flags, RoIs):
140 acc = ComponentAccumulator()
141
142 doSeededDecoding =True
143 if 'FSRoI' in RoIs:
144 doSeededDecoding = False
145 acc.merge(MuDataPrepViewDataVerifierCfg(flags))
146
147 # Get RPC BS decoder
148 if not flags.Input.isMC:
149 rpcAcc = RpcBytestreamDecodeCfg( flags, name = "RpcRawDataProvider_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
150 acc.merge( rpcAcc )
151 if flags.Muon.enableNRPC:
152 acc.merge(NrpcBytestreamDecodeCfg( flags, name="NRpcRawDataProvider_"+RoIs ))
153 # Get RPC RDO convertor
154 rpcAcc = RpcRDODecodeCfg( flags, name= "RpcRdoToRpcPrepData_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
155 acc.merge( rpcAcc )
156 # Get TGC BS decoder
157 if not flags.Input.isMC:
158 tgcAcc = TgcBytestreamDecodeCfg( flags, name="TgcRawDataProvider_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
159 acc.merge( tgcAcc )
160 # Get TGC RDO convertor
161 tgcAcc = TgcRDODecodeCfg( flags, name="TgcRdoToTgcPrepData_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
162 acc.merge( tgcAcc )
163 # Get MDT BS decoder
164 if not flags.Input.isMC:
165 mdtAcc = MdtBytestreamDecodeCfg( flags, name="MdtRawDataProvider_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
166 acc.merge( mdtAcc )
167 # Get MDT RDO convertor
168 mdtAcc = MdtRDODecodeCfg( flags, name="MdtRdoToMdtPrepData_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
169 acc.merge( mdtAcc )
170 # Get CSC BS decoder
171 if flags.Detector.GeometryCSC:
172 if not flags.Input.isMC:
173 cscAcc = CscBytestreamDecodeCfg( flags, name="CscRawDataProvider_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
174 acc.merge( cscAcc )
175 # Get CSC RDO convertor
176 cscAcc = CscRDODecodeCfg( flags, name="CscRdoToCscPrepData_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
177 acc.merge( cscAcc )
178 # Get CSC cluster builder
179 cscAcc = CscClusterBuildCfg( flags, name="CscThresholdClusterBuilder_"+RoIs )
180 acc.merge( cscAcc )
181 #sTGC and MM BS decoder
182 if flags.Detector.GeometrysTGC and flags.Detector.GeometryMM:
183 if not flags.Input.isMC:
184 stgcAcc = sTgcBytestreamDecodeCfg(flags, name="sTgcRawDataProvider_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding)
185 acc.merge( stgcAcc )
186 mmAcc = MmBytestreamDecodeCfg(flags, name="MMRawDataProvider_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding)
187 acc.merge( mmAcc )
188 #sTGC and MM RDO converter
189 stgcAcc = StgcRDODecodeCfg( flags, name="StgcRdoToStgcPrepData_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
190 acc.merge( stgcAcc )
191
192 mmAcc = MMRDODecodeCfg( flags, name="MMRdoToMMPrepData_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding)
193 acc.merge( mmAcc )
194
195 # SpacePoint formation
196 if flags.Muon.usePhaseIIGeoSetup and flags.Muon.scheduleActsReco:
197 from MuonSpacePointFormation.SpacePointFormationConfig import MuonSpacePointFormationCfg
198 acc.merge( MuonSpacePointFormationCfg( flags, suffix =f'_{RoIs}' ) )
199
200 return acc
201

◆ muonIDCosmicTrackingSequenceCfg()

python.HLT.Muon.MuonRecoSequences.muonIDCosmicTrackingSequenceCfg ( flags,
RoIs,
name,
extraLoads = None,
extraLoadsForl2mtmode = None )

Definition at line 293 of file MuonRecoSequences.py.

293def muonIDCosmicTrackingSequenceCfg( flags, RoIs, name, extraLoads=None, extraLoadsForl2mtmode=None ):
294
295 acc = ComponentAccumulator()
296
297 acc.merge(muonIDtrackVDVCfg(flags, 'cosmics', RoIs, extraLoads, extraLoadsForl2mtmode))
298
299 flagsWithTrk = getFlagsForActiveConfig(flags, "cosmics", log)
300
301 from TrigInDetConfig.InnerTrackingTrigSequence import InnerTrackingTrigSequence
302 seq = InnerTrackingTrigSequence.create(flagsWithTrk,
303 flagsWithTrk.Tracking.ActiveConfig.input_name,
304 rois = RoIs,
305 inView = "muCombVDVcosmics")
306 acc.merge(seq.sequence("Offline"))
307
308
309 return acc
310

◆ muonIDFastTrackingSequenceCfg()

python.HLT.Muon.MuonRecoSequences.muonIDFastTrackingSequenceCfg ( flags,
RoIs,
name,
extraLoads = None,
extraLoadsForl2mtmode = None,
doLRT = False,
trackingMode = "FTF" )

Definition at line 283 of file MuonRecoSequences.py.

283def muonIDFastTrackingSequenceCfg( flags, RoIs, name, extraLoads=None, extraLoadsForl2mtmode=None, doLRT=False, trackingMode="FTF" ):
284
285 acc = ComponentAccumulator()
286 from TrigInDetConfig.TrigInDetConfig import trigInDetFastTrackingCfg
287 acc.merge(trigInDetFastTrackingCfg( flags, roisKey=RoIs, signatureName=name, patternMode=trackingMode ))
288
289 acc.merge(muonIDtrackVDVCfg(flags, name, RoIs, extraLoads, extraLoadsForl2mtmode))
290
291 return acc
292

◆ muonIDtrackVDVCfg()

python.HLT.Muon.MuonRecoSequences.muonIDtrackVDVCfg ( flags,
name,
RoIs,
extraLoads = None,
extraLoadsForl2mtmode = None )

Definition at line 271 of file MuonRecoSequences.py.

271def muonIDtrackVDVCfg( flags, name, RoIs, extraLoads=None, extraLoadsForl2mtmode=None ):
272 result=ComponentAccumulator()
273 dataObjects=[( 'TrigRoiDescriptorCollection' , 'StoreGateSvc+%s' % RoIs )]
274 if extraLoads:
275 dataObjects += extraLoads
276 if extraLoadsForl2mtmode:
277 dataObjects += extraLoadsForl2mtmode
278 ViewVerify = CompFactory.AthViews.ViewDataVerifier("muCombVDV"+name, DataObjects = dataObjects)
279
280 result.addEventAlgo(ViewVerify)
281 return result
282

◆ VDVEFMuCBCfg()

python.HLT.Muon.MuonRecoSequences.VDVEFMuCBCfg ( flags,
RoIs,
name,
suffix )

Definition at line 484 of file MuonRecoSequences.py.

484def VDVEFMuCBCfg(flags, RoIs, name, suffix):
485 acc = ComponentAccumulator()
486 dataObjects = [( 'Muon::MdtPrepDataContainer' , 'StoreGateSvc+MDT_DriftCircles' ),
487 ( 'Muon::TgcPrepDataContainer' , 'StoreGateSvc+TGC_MeasurementsAllBCs' ),
488 ( 'Muon::RpcPrepDataContainer' , 'StoreGateSvc+RPC_Measurements' ),
489 ( 'TrigRoiDescriptorCollection' , 'StoreGateSvc+%s' % RoIs ),
490 ( 'xAOD::EventInfo' , 'StoreGateSvc+EventInfo' ),
491 ]
492 if "FS" in name:
493 dataObjects +=[( 'MuonCandidateCollection' , 'StoreGateSvc+MuonCandidates_FS' )]
494 else:
495 dataObjects +=[( 'MuonCandidateCollection' , 'StoreGateSvc+MuonCandidates')]
496
497 if flags.Detector.GeometryCSC:
498 dataObjects += [( 'Muon::CscStripPrepDataContainer' , 'StoreGateSvc+CSC_Measurements' )]
499 if flags.Detector.GeometrysTGC and flags.Detector.GeometryMM:
500 dataObjects += [( 'Muon::MMPrepDataContainer' , 'StoreGateSvc+MM_Measurements'),
501 ( 'Muon::sTgcPrepDataContainer' , 'StoreGateSvc+STGC_Measurements') ]
502 if flags.Muon.usePhaseIIGeoSetup:
503 dataObjects += [( 'MuonR4::SpacePointContainer' , 'StoreGateSvc+MuonSpacePoints' )]
504 if flags.Detector.GeometrysTGC or flags.Detector.GeometryMM:
505 dataObjects += [( 'MuonR4::SpacePointContainer' , 'StoreGateSvc+NswSpacePoints' )]
506
507 alg = CompFactory.AthViews.ViewDataVerifier( name = "VDVMuEFCB_"+name+suffix,
508 DataObjects = dataObjects)
509 acc.addEventAlgo(alg)
510 return acc
511
512
513

◆ VDVidReuseITkCfg()

python.HLT.Muon.MuonRecoSequences.VDVidReuseITkCfg ( flags,
suffix )

Definition at line 540 of file MuonRecoSequences.py.

540def VDVidReuseITkCfg(flags, suffix):
541 acc = ComponentAccumulator()
542
543 vdvName = "VDVidReuseITk"
544 dataObjects = []
545
546 from TrigInDetConfig.TrigInDetConfig import InDetExtraDataObjectsFromDataPrep
547 InDetExtraDataObjectsFromDataPrep(flags, dataObjects)
548
549 alg = CompFactory.AthViews.ViewDataVerifier( name = vdvName+suffix,
550 DataObjects = dataObjects)
551 acc.addEventAlgo(alg)
552 return acc
553
554

◆ VDVLateMuCfg()

python.HLT.Muon.MuonRecoSequences.VDVLateMuCfg ( flags)

Definition at line 750 of file MuonRecoSequences.py.

750def VDVLateMuCfg(flags):
751 acc = ComponentAccumulator()
752 dataObjects = [( 'xAOD::MuonRoIContainer', 'StoreGateSvc+LVL1MuonRoIsBCm2' ),
753 ( 'xAOD::MuonRoIContainer', 'StoreGateSvc+LVL1MuonRoIsBCm1' ),
754 ( 'xAOD::MuonRoIContainer', 'StoreGateSvc+LVL1MuonRoIsBCp1' ),
755 ( 'xAOD::MuonRoIContainer', 'StoreGateSvc+LVL1MuonRoIsBCp2' )]
756
757 alg = CompFactory.AthViews.ViewDataVerifier( name = "efLateMuRoIVDV",
758 DataObjects = dataObjects)
759 acc.addEventAlgo(alg)
760 return acc
761
762

◆ VDVMuInsideOutCfg()

python.HLT.Muon.MuonRecoSequences.VDVMuInsideOutCfg ( flags,
name,
candidatesName,
suffix )

Definition at line 635 of file MuonRecoSequences.py.

635def VDVMuInsideOutCfg(flags, name, candidatesName, suffix):
636 acc = ComponentAccumulator()
637 dataObjects = [( 'Muon::RpcPrepDataContainer' , 'StoreGateSvc+RPC_Measurements' ),
638 ( 'Muon::TgcPrepDataContainer' , 'StoreGateSvc+TGC_MeasurementsAllBCs' ),
639 ( 'MuonCandidateCollection' , 'StoreGateSvc+'+candidatesName ),
640 ('Trk::SegmentCollection' , 'StoreGateSvc+TrackMuonSegments')]
641 if not isCosmic(flags): dataObjects += [( 'Muon::HoughDataPerSectorVec' , 'StoreGateSvc+HoughDataPerSectorVec')]
642 if flags.Detector.GeometryCSC:
643 dataObjects += [( 'Muon::CscPrepDataContainer' , 'StoreGateSvc+CSC_Clusters' )]
644 if flags.Detector.GeometrysTGC and flags.Detector.GeometryMM:
645 dataObjects += [( 'Muon::MMPrepDataContainer' , 'StoreGateSvc+MM_Measurements'),
646 ( 'Muon::sTgcPrepDataContainer' , 'StoreGateSvc+STGC_Measurements') ]
647
648 alg = CompFactory.AthViews.ViewDataVerifier( name = "VDVMuInsideOut_"+name+suffix,
649 DataObjects = dataObjects)
650 acc.addEventAlgo(alg)
651 return acc
652
653

◆ VDVMuIsoCfg()

python.HLT.Muon.MuonRecoSequences.VDVMuIsoCfg ( flags,
name,
RoIs )

Definition at line 716 of file MuonRecoSequences.py.

716def VDVMuIsoCfg(flags, name, RoIs):
717 acc = ComponentAccumulator()
718 dataObjects = [( 'TrigRoiDescriptorCollection' , 'StoreGateSvc+'+RoIs ),
719 ( 'xAOD::MuonContainer' , 'StoreGateSvc+IsoViewMuons'+name )]
720
721 alg = CompFactory.AthViews.ViewDataVerifier( name = "efMuIsoVDV"+name,
722 DataObjects = dataObjects)
723 acc.addEventAlgo(alg)
724 return acc
725
726

◆ VDVPrecMuTrkCfg()

python.HLT.Muon.MuonRecoSequences.VDVPrecMuTrkCfg ( flags,
name,
suffix )

Definition at line 514 of file MuonRecoSequences.py.

514def VDVPrecMuTrkCfg(flags, name, suffix):
515 acc = ComponentAccumulator()
516
517 vdvName = "VDVMuTrkLRT" if "LRT" in name else "VDVMuTrk"
518 trkname = "LRT" if "LRT" in name else ''
519 dataObjects = [( 'xAOD::IParticleContainer' , 'StoreGateSvc+'+ getIDTracks(flags, trkname) )]
520
521 if not flags.Muon.enableTrigIDtrackReuse and suffix == '':
522 dataObjects += [( 'xAOD::TrackParticleContainer' , 'StoreGateSvc+'+getIDTracks(flags, trkname, muonIDreuse=flags.Muon.enableTrigIDtrackReuse) )]
523 else:
524 if suffix != 'idReuse':
525 MuonL2CBContainer = muNames.L2CBName+suffix
526 else:
527 MuonL2CBContainer = muNames.L2CBName
528 dataObjects += [( 'xAOD::L2CombinedMuonContainer', 'StoreGateSvc+'+MuonL2CBContainer)]
529
530 if not flags.Input.isMC:
531 dataObjects += [( 'IDCInDetBSErrContainer' , 'StoreGateSvc+PixelByteStreamErrs' ),
532 ( 'IDCInDetBSErrContainer' , 'StoreGateSvc+SCT_ByteStreamErrs' )]
533
534 alg = CompFactory.AthViews.ViewDataVerifier( name = vdvName+suffix,
535 DataObjects = dataObjects)
536 acc.addEventAlgo(alg)
537 return acc
538
539

Variable Documentation

◆ CBTPname

python.HLT.Muon.MuonRecoSequences.CBTPname = recordable("HLT_CBCombinedMuon_RoITrackParticles")

Definition at line 17 of file MuonRecoSequences.py.

◆ CBTPnameFS

python.HLT.Muon.MuonRecoSequences.CBTPnameFS = recordable("HLT_CBCombinedMuon_FSTrackParticles")

Definition at line 18 of file MuonRecoSequences.py.

◆ CBTPnameLRT

python.HLT.Muon.MuonRecoSequences.CBTPnameLRT = recordable("HLT_CBCombinedMuon_LRTTrackParticles")

Definition at line 19 of file MuonRecoSequences.py.

◆ ExtrpTPname

python.HLT.Muon.MuonRecoSequences.ExtrpTPname = recordable("HLT_MSExtrapolatedMuons_RoITrackParticles")

Definition at line 20 of file MuonRecoSequences.py.

◆ ExtrpTPnameFS

python.HLT.Muon.MuonRecoSequences.ExtrpTPnameFS = recordable("HLT_MSExtrapolatedMuons_FSTrackParticles")

Definition at line 21 of file MuonRecoSequences.py.

◆ log

python.HLT.Muon.MuonRecoSequences.log = logging.getLogger(__name__)

Definition at line 6 of file MuonRecoSequences.py.

◆ MSextrpTPname

python.HLT.Muon.MuonRecoSequences.MSextrpTPname = recordable("HLT_MSOnlyExtrapolatedMuons_FSTrackParticles")

Definition at line 22 of file MuonRecoSequences.py.

◆ muNames

python.HLT.Muon.MuonRecoSequences.muNames = muonNames().getNames('RoI')

Definition at line 58 of file MuonRecoSequences.py.

◆ muNamesFS

python.HLT.Muon.MuonRecoSequences.muNamesFS = muonNames().getNames('FS')

Definition at line 59 of file MuonRecoSequences.py.

◆ muNamesLRT

python.HLT.Muon.MuonRecoSequences.muNamesLRT = muonNames().getNames('LRT')

Definition at line 60 of file MuonRecoSequences.py.

Generated on for ATLAS Offline Software by doxygen 1.16.1