ATLAS Offline Software
Loading...
Searching...
No Matches
Functions | Variables
MuonCombinedReconstructionConfig Namespace Reference

Functions

 MuonCaloTagAlgCfg (flags, name="MuonCaloTagAlg", **kwargs)
 LRT_MuonCaloTagAlgCfg (flags, name="MuonCaloTagAlg_LRT", **kwargs)
 MuonSegmentTagAlgCfg (flags, name="MuonSegmentTagAlg", **kwargs)
 LRT_MuonSegmentTagAlgCfg (flags, name="MuonSegmentTagAlg_LRT", **kwargs)
 MuonInsideOutRecoAlgCfg (flags, name="MuonInsideOutRecoAlg", **kwargs)
 LRT_MuGirlAlgCfg (flags, name="MuGirlAlg_LRT", **kwargs)
 MuGirlStauAlgCfg (flags, name="MuGirlStauAlg", **kwargs)
 MuonCombinedMuonCandidateAlgCfg (flags, name="MuonCombinedMuonCandidateAlg", **kwargs)
 EMEO_MuonCombinedMuonCandidateAlgCfg (flags, name="MuonCombinedMuonCandidateAlg_EMEO")
 MuonCombinedInDetCandidateAlgCfg (flags, name="MuonCombinedInDetCandidateAlg", **kwargs)
 MuonInDetToMuonSystemExtensionAlgCfg (flags, name="MuonInDetToMuonSystemExtensionAlg", **kwargs)
 LRT_MuonInDetToMuonSystemExtensionAlgCfg (flags, name="MuonInDetToMuonSystemExtensionAlg_LRT", **kwargs)
 LRT_MuonCombinedInDetCandidateAlgCfg (flags, name="MuonCombinedInDetCandidateAlg_LRT", **kwargs)
 MuonCombinedAlgCfg (flags, name="MuonCombinedAlg", **kwargs)
 EMEO_MuonCombinedAlgCfg (flags, name="MuonCombinedAlg_EMEO", **kwargs)
 LRT_MuonCombinedAlgCfg (flags, name="MuonCombinedAlg_LRT", **kwargs)
 MuonCreatorAlgCfg (flags, name="MuonCreatorAlg", **kwargs)
 LRT_MuonCreatorAlgCfg (flags, name="MuonCreatorAlg_LRT", **kwargs)
 EMEO_MuonCreatorAlgCfg (flags, name="MuonCreatorAlg_EMEO", **kwargs)
 StauCreatorAlgCfg (flags, name="StauCreatorAlg", **kwargs)
 MuonSegContainerMergerAlgCfg (flags, name="MuonSegContainerMergerAlg", **kwargs)
 MuonInDetExtensionMergerAlgCfg (flags, name="MuonInDetExtensionMergerAlg", **kwargs)
 GetCombinedTrkContainers (flags)
 MuonTrkIDMSScatterDecorAlgCfg (flags, name="MuonCombIDMSScatterDecorAlg", **kwargs)
 MuonTrkAEOTDecorAlgCfg (flags, name="MuonCombAEOTDecorAlg", **kwargs)
 MuonPrecisionLayerDecorAlgCfg (flags, name="MuonPrecisionLayerDecorAlg", **kwargs)
 MuonDecorationAlgsCfg (flags)
 CombinedMuonTrackTruthAlgsCfg (flags)
 CombinedMuonTruthAssociationAlgsCfg (flags)
 CombinedMuonOutputCfg (flags)
 MuonCombinedReconstructionCfg (flags)

Variables

 flags = initConfigFlags()
 Files
 doMuGirlLowBeta
 cfg = SetupMuonStandaloneCA(flags)
 UseOnlyHitSectors
list rename_maps

Function Documentation

◆ CombinedMuonOutputCfg()

MuonCombinedReconstructionConfig.CombinedMuonOutputCfg ( flags)

Definition at line 560 of file MuonCombinedReconstructionConfig.py.

560def CombinedMuonOutputCfg(flags):
561 from OutputStreamAthenaPool.OutputStreamConfig import addToESD, addToAOD
562 result = ComponentAccumulator()
563
564 # FIXME! Fix for ATLASRECTS-5151. Remove when better solution found.
565 from TrkEventCnvTools.TrkEventCnvToolsConfig import (
566 TrkEventCnvSuperToolCfg)
567 result.merge(TrkEventCnvSuperToolCfg(flags))
568
569 # Avoid old-style import from from IsolationAlgs.IsoUpdatedTrackCones import iso_vars
570 # But shouldn't be here.
571 iso_vars = []
572 for track_pt in 500, 1000:
573 for cone_str in "", "LooseCone":
574 name = f"Nonprompt_All_MaxWeightTTVA{cone_str}_pt{track_pt}"
575 iso_vars += ["ptconeCorrBitset_"+name,
576 "ptconecoreTrackPtrCorrection_"+name]
577 for cone_size in 20, 30, 40:
578 for var_str in "", "var":
579 iso_vars.append(f"pt{var_str}cone{cone_size}_{name}")
580
581 aod_items = []
582 # Segments
583 aod_items += ["xAOD::MuonSegmentContainer#MuonSegments"]
584 aod_items += ["xAOD::MuonSegmentAuxContainer#MuonSegmentsAux."]
585 if flags.MuonCombined.writeUnAssocSegments:
586 aod_items += ["xAOD::MuonSegmentContainer#UnAssocMuonSegments"]
587 aod_items += ["xAOD::MuonSegmentAuxContainer#UnAssocMuonSegmentsAux."]
588 if flags.MuonCombined.doMuGirlLowBeta:
589 aod_items += ["xAOD::MuonSegmentContainer#StauSegments"]
590 aod_items += ["xAOD::MuonSegmentAuxContainer#StauSegmentsAux."]
591
592 particle_col, trk_col = GetCombinedTrkContainers(flags)
593 if flags.Detector.EnableCalo:
594 aod_items += ["xAOD::CaloClusterContainer#MuonClusterCollection"]
595 aod_items += ["xAOD::CaloClusterAuxContainer#MuonClusterCollectionAux."]
596 aod_items += ["CaloClusterCellLinkContainer#MuonClusterCollection_links"]
597 from CaloRec.CaloThinCellsByClusterAlgConfig import CaloThinCellsByClusterAlgCfg
598 result.merge(CaloThinCellsByClusterAlgCfg(flags, streamName="StreamAOD",
599 clusters="MuonClusterCollection",
600 samplings=["TileGap1", "TileGap2", "TileGap3", "TileBar0", "TileExt0", "HEC0"]))
601
602 # Adding the xAOD content by default
603 excludedAuxData = '-clusterAssociation'
604 aod_items += ["xAOD::TrackParticleContainer#"+col for col in particle_col]
605 aod_items += ["xAOD::TrackParticleAuxContainer#"+col +
606 "Aux." + excludedAuxData for col in particle_col]
607
608 aod_items += ["xAOD::MuonContainer#Muons"]
609 aod_items += ["xAOD::MuonContainer#MuonsLRT"]
610
611 # FIXME! Next two lines are hack to remove derivation framework variables that are added by DRAW building and are supposed to be transient
612 wp_decors = ["DFCommonMuonsTight", "DFCommonGoodMuon", "DFCommonMuonsMedium",
613 "DFCommonMuonsLoose", "InnerDetectorPt", "MuonSpectrometerPt", "isMedium_DRAWZmumu"]
614 # Remove GlobalFELinks and related variables - these are links between FlowElement (FE) containers created in jet finding and muons.
615 # Since these transient FE containers are not in the ESD/AOD, we should not write out these links.
616 gpf_vars = ["chargedGlobalFELinks", "neutralGlobalFELinks",
617 "deltaR_muon_clus_GlobalFEalg", "muon_efrac_matched_GlobalFE"]
618
619 excludedMuonAuxData = ".-"+".-".join(iso_vars+wp_decors+gpf_vars)
620
621 aod_items += ["xAOD::MuonAuxContainer#MuonsAux" + excludedMuonAuxData]
622 aod_items += ["xAOD::MuonAuxContainer#MuonsLRTAux" + excludedMuonAuxData]
623
624 # stau
625 aod_items += ["xAOD::MuonContainer#Staus"]
626 aod_items += ["xAOD::MuonAuxContainer#StausAux" + excludedMuonAuxData]
627 aod_items += ["xAOD::SlowMuonContainer#SlowMuons"]
628 aod_items += ["xAOD::SlowMuonAuxContainer#SlowMuonsAux."]
629
630 if flags.Muon.runCommissioningChain:
631 aod_items += ["xAOD::MuonContainer#EMEO_Muons"]
632 aod_items += ["xAOD::MuonAuxContainer#EMEO_MuonsAux" +
633 excludedMuonAuxData]
634 # +++++ ESD +++++
635
636 # Tracks
637 esd_items = ["TrackCollection#"+col for col in trk_col]
638 esd_items += ["Trk::SegmentCollection#TrkMuonSegments"]
639 if flags.MuonCombined.writeUnAssocSegments:
640 esd_items += ["Trk::SegmentCollection#UnAssocMuonTrkSegments"]
641 # Truth
642 if flags.Input.isMC:
643 esd_items += ["DetailedTrackTruthCollection#ExtrapolatedMuonTracksTruth"]
644 esd_items += ["DetailedTrackTruthCollection#CombinedMuonTracksTruth"]
645 esd_items += ["DetailedTrackTruthCollection#ExtrapolatedMuonTrackParticlesTruth"]
646 esd_items += ["DetailedTrackTruthCollection#CombinedMuonTrackParticlesTruth"]
647
648 if flags.MuonCombined.doCosmicSplitTracks:
649 esd_items += ["TrackCollection#Combined_Tracks_split"]
650 esd_items += ["TrackCollection#Tracks_split"]
651 esd_items += ["Rec::TrackParticleContainer#TrackParticleCandidate_split"]
652
653 esd_items += aod_items
654
655 result.merge(addToESD(flags, esd_items))
656 result.merge(addToAOD(flags, aod_items))
657
658 # Leaving in for the moment, because we might still need this. Will remove once it's confirmed we don't
659 # if flags.Output.doWriteESD:
660 #
661 # if runOnESD:
662 # # Need to make it possible to write Object ... so rename read containers
663 # from AthenaCommon.Logging import log
664 # from SGComps.AddressRemappingConfig import AddressRemappingCfg
665 # rename_maps = list(map(lambda item:'%s->%s' % (item, 'old_'+item.split('#')[1]), esd_items))
666 # log.info('Since we are running on ESD, rename inputs as follows:'+str(rename_maps))
667 # cfg.merge( AddressRemappingCfg(rename_maps) )
668
669 return result
670
671

◆ CombinedMuonTrackTruthAlgsCfg()

MuonCombinedReconstructionConfig.CombinedMuonTrackTruthAlgsCfg ( flags)

Definition at line 515 of file MuonCombinedReconstructionConfig.py.

515def CombinedMuonTrackTruthAlgsCfg(flags):
516 result = ComponentAccumulator()
517 particle_cols, trk_cols = GetCombinedTrkContainers(flags)
518
519 from MuonConfig.MuonTruthAlgsConfig import MuonDetailedTrackTruthMakerCfg
520 result.merge(MuonDetailedTrackTruthMakerCfg(flags, name="MuonCombinedDetailedTrackTruthMaker",
521 TrackCollectionNames=trk_cols))
522
523 if(not flags.Muon.scheduleActsReco):
524 for i in range(len(trk_cols)):
525 from TrkConfig.TrkTruthAlgsConfig import TrackTruthSelectorCfg, TrackParticleTruthAlgCfg
526 result.merge(TrackTruthSelectorCfg(flags, tracks=trk_cols[i]))
527 result.merge(TrackParticleTruthAlgCfg(flags, tracks=trk_cols[i],
528 TrackParticleName=particle_cols[i]))
529
530 return result
531
532
if
if(pathvar)
Definition SealSharedLib.cxx:167

◆ CombinedMuonTruthAssociationAlgsCfg()

MuonCombinedReconstructionConfig.CombinedMuonTruthAssociationAlgsCfg ( flags)

Definition at line 533 of file MuonCombinedReconstructionConfig.py.

533def CombinedMuonTruthAssociationAlgsCfg(flags):
534 result = ComponentAccumulator()
535 trk_cols = GetCombinedTrkContainers(flags)[0]
536
537 from MuonConfig.MuonTruthAlgsConfig import MuonTruthAssociationAlgCfg
538 result.merge(MuonTruthAssociationAlgCfg(flags))
539
540 if flags.Tracking.doLargeD0:
541 result.merge(MuonTruthAssociationAlgCfg(flags, name="MuonTruthAssociationAlgLRT",
542 MuonContainerName="MuonsLRT",
543 RecoLinkName="recoMuonLinkLRT",
544 TrackContainers=trk_cols))
545
546 if flags.Muon.runCommissioningChain:
547 result.merge(MuonTruthAssociationAlgCfg(flags, name="MuonTruthAssociationAlg_EMEO",
548 MuonContainerName="EMEO_Muons",
549 RecoLinkName="",
550 TrackContainers=trk_cols))
551
552 if flags.MuonCombined.doMuGirl and flags.MuonCombined.doMuGirlLowBeta:
553 result.merge(MuonTruthAssociationAlgCfg(flags, name="MuonTruthAssociationAlgStau",
554 MuonContainerName="Staus",
555 RecoLinkName="",
556 TrackContainers=trk_cols))
557
558 return result
559

◆ EMEO_MuonCombinedAlgCfg()

MuonCombinedReconstructionConfig.EMEO_MuonCombinedAlgCfg ( flags,
name = "MuonCombinedAlg_EMEO",
** kwargs )

Definition at line 243 of file MuonCombinedReconstructionConfig.py.

243def EMEO_MuonCombinedAlgCfg(flags, name="MuonCombinedAlg_EMEO", **kwargs):
244 from MuonCombinedConfig.MuonCombinedRecToolsConfig import EMEO_MuonCombinedToolCfg
245 result = ComponentAccumulator()
246 kwargs.setdefault("MuonCombinedTool", result.popToolsAndMerge(
247 EMEO_MuonCombinedToolCfg(flags)))
248 kwargs.setdefault("CombinedTagMaps", [
249 "muidcoTagMap_EMEO", "stacoTagMap_EMEO"])
250 kwargs.setdefault("MuidCombinedTracksLocation", "MuidCombinedTracks_EMEO")
251 kwargs.setdefault("MuidMETracksLocation", "MuidMETracks_EMEO")
252 kwargs.setdefault("MuonCandidateLocation", "MuonCandidates_EMEO")
253 alg = CompFactory.MuonCombinedAlg(name, **kwargs)
254 result.addEventAlgo(alg, primary=True)
255 return result
256
257

◆ EMEO_MuonCombinedMuonCandidateAlgCfg()

MuonCombinedReconstructionConfig.EMEO_MuonCombinedMuonCandidateAlgCfg ( flags,
name = "MuonCombinedMuonCandidateAlg_EMEO" )

Definition at line 121 of file MuonCombinedReconstructionConfig.py.

121def EMEO_MuonCombinedMuonCandidateAlgCfg(flags, name="MuonCombinedMuonCandidateAlg_EMEO"):
122 result = ComponentAccumulator()
123
124 from MuonCombinedConfig.MuonCombinedRecToolsConfig import EMEO_CombinedMuonTrackBuilderCfg
125 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonCandidateToolCfg
126
127 track_builder = result.popToolsAndMerge(
128 EMEO_CombinedMuonTrackBuilderCfg(flags))
129 acc = MuonCandidateToolCfg(flags,
130 name="MuonCandidateTool_EMEO",
131 TrackBuilder=track_builder,
132 Commissioning=True)
133
134 candidate_tool = result.popToolsAndMerge(acc)
135 alg = CompFactory.MuonCombinedMuonCandidateAlg(name,
136 MuonCandidateTool=candidate_tool,
137 MuonSpectrometerTrackParticleLocation="EMEO_MuonSpectrometerTrackParticles",
138 MuonCandidateLocation="MuonCandidates_EMEO",
139 MSOnlyExtrapolatedTrackLocation="EMEO_MSOnlyExtrapolatedTracks")
140 result.addEventAlgo(alg, primary=True)
141
142 return result
143
144

◆ EMEO_MuonCreatorAlgCfg()

MuonCombinedReconstructionConfig.EMEO_MuonCreatorAlgCfg ( flags,
name = "MuonCreatorAlg_EMEO",
** kwargs )

Definition at line 331 of file MuonCombinedReconstructionConfig.py.

331def EMEO_MuonCreatorAlgCfg(flags, name="MuonCreatorAlg_EMEO", **kwargs):
332 muon_maps = ["MuonCandidates_EMEO"]
333 combined_maps = []
334 if flags.MuonCombined.doStatisticalCombination:
335 combined_maps += ["stacoTagMap_EMEO"]
336 if flags.MuonCombined.doCombinedFit:
337 combined_maps += ["muidcoTagMap_EMEO"]
338 kwargs.setdefault("TagMaps", combined_maps)
339 kwargs.setdefault("MuonCandidateLocation", muon_maps)
340 kwargs.setdefault("MuonContainerLocation", "EMEO_Muons")
341 kwargs.setdefault("ExtrapolatedLocation", "EMEO_ExtrapolatedMuon")
342 kwargs.setdefault("MSOnlyExtrapolatedLocation",
343 "EMEO_MSOnlyExtrapolatedMuon")
344 kwargs.setdefault("CombinedLocation", "EMEO_CombinedMuon")
345 kwargs.setdefault("BuildSlowMuon", False)
346 kwargs.setdefault("MakeClusters", False)
347 kwargs.setdefault("ClusterContainerName", "")
348 return MuonCreatorAlgCfg(flags, name=name, **kwargs)
349
350

◆ GetCombinedTrkContainers()

MuonCombinedReconstructionConfig.GetCombinedTrkContainers ( flags)

Definition at line 424 of file MuonCombinedReconstructionConfig.py.

424def GetCombinedTrkContainers(flags):
425 tp_coll = []
426 track_coll = []
427 tp_coll = ["ExtrapolatedMuonTrackParticles",
428 "CombinedMuonTrackParticles",
429 "MSOnlyExtrapolatedMuonTrackParticles"]
430 track_coll = ["ExtrapolatedMuonTracks",
431 "CombinedMuonTracks",
432 "MSOnlyExtrapolatedTracks"]
433 if flags.Muon.runCommissioningChain:
434 tp_coll += ["EMEO_ExtrapolatedMuonTrackParticles",
435 "EMEO_CombinedMuonTrackParticles",
436 "EMEO_MSOnlyExtrapolatedMuonTrackParticles"]
437 track_coll += ["EMEO_ExtrapolatedMuonTracks",
438 "EMEO_CombinedMuonTracks",
439 "EMEO_MSOnlyExtrapolatedTracks"]
440 if flags.MuonCombined.doMuGirl and flags.MuonCombined.doMuGirlLowBeta:
441 tp_coll += ["CombinedStauTrackParticles",
442 "ExtrapolatedStauTrackParticles"]
443 track_coll += ["CombinedStauTracks",
444 "ExtrapolatedStauTracks"]
445 if flags.Tracking.doLargeD0:
446 tp_coll += ["CombinedMuonsLRTTrackParticles",
447 "ExtraPolatedMuonsLRTTrackParticles",
448 "MSOnlyExtraPolatedMuonsLRTTrackParticles"]
449 track_coll += ["CombinedMuonsLRTTracks",
450 "ExtraPolatedMuonsLRTTracks",
451 "MSOnlyExtraPolatedMuonsLRTTrackParticlesTracks"]
452 return tp_coll, track_coll
453
454

◆ LRT_MuGirlAlgCfg()

MuonCombinedReconstructionConfig.LRT_MuGirlAlgCfg ( flags,
name = "MuGirlAlg_LRT",
** kwargs )

Definition at line 68 of file MuonCombinedReconstructionConfig.py.

68def LRT_MuGirlAlgCfg(flags, name="MuGirlAlg_LRT", **kwargs):
69 kwargs.setdefault("TagMap", "MuGirlMap_LRT")
70 kwargs.setdefault("METrackCollection", "MuGirlMETracks_LRT")
71 kwargs.setdefault("SegmentCollection", "MuGirlSegments_LRT")
72 kwargs.setdefault("CombinedTrackCollection",
73 "MuGirlCombinedMuonContainerLRT")
74 kwargs.setdefault("InDetCandidateLocation", "TrackParticleCandidateLRT"
75 if not flags.MuonCombined.doCombinedFit else "InDetCandidateLRT_SystemExtended")
76 return MuonInsideOutRecoAlgCfg(flags, name, **kwargs)
77
78

◆ LRT_MuonCaloTagAlgCfg()

MuonCombinedReconstructionConfig.LRT_MuonCaloTagAlgCfg ( flags,
name = "MuonCaloTagAlg_LRT",
** kwargs )

Definition at line 22 of file MuonCombinedReconstructionConfig.py.

22def LRT_MuonCaloTagAlgCfg(flags, name="MuonCaloTagAlg_LRT", **kwargs):
23 kwargs.setdefault("TagMap", "caloTagMap_LRT")
24 kwargs.setdefault("InDetCandidateLocation", "TrackParticleCandidateLRT")
25 return MuonCaloTagAlgCfg(flags, name, **kwargs)
26
27

◆ LRT_MuonCombinedAlgCfg()

MuonCombinedReconstructionConfig.LRT_MuonCombinedAlgCfg ( flags,
name = "MuonCombinedAlg_LRT",
** kwargs )

Definition at line 258 of file MuonCombinedReconstructionConfig.py.

258def LRT_MuonCombinedAlgCfg(flags, name="MuonCombinedAlg_LRT", **kwargs):
259 kwargs.setdefault("InDetCandidateLocation", "TrackParticleCandidateLRT")
260 kwargs.setdefault("CombinedTagMaps", [
261 "muidcoTagMap_LRT", "stacoTagMap_LRT"])
262 kwargs.setdefault("MuidCombinedTracksLocation", "MuidCombinedTracks_LRT")
263 kwargs.setdefault("MuidMETracksLocation", "MuidMETracks_LRT")
264 return MuonCombinedAlgCfg(flags, name, **kwargs)
265
266

◆ LRT_MuonCombinedInDetCandidateAlgCfg()

MuonCombinedReconstructionConfig.LRT_MuonCombinedInDetCandidateAlgCfg ( flags,
name = "MuonCombinedInDetCandidateAlg_LRT",
** kwargs )

Definition at line 200 of file MuonCombinedReconstructionConfig.py.

200def LRT_MuonCombinedInDetCandidateAlgCfg(flags, name="MuonCombinedInDetCandidateAlg_LRT", **kwargs):
201 from InDetConfig.InDetTrackSelectorToolConfig import MuonCombinedInDetDetailedForwardTrackSelectorToolCfg, MuonCombinedInDetDetailedTrackSelectorTool_LRTCfg
202 result = ComponentAccumulator()
203
204 kwargs.setdefault("TrackSelector", result.popToolsAndMerge(
205 MuonCombinedInDetDetailedTrackSelectorTool_LRTCfg(flags)))
206
207 # Use the Standard Track particle container in cases where no separate containters will be
208 # saved for the LRT tracking
209 kwargs.setdefault("TrackParticleLocation", ["InDetLargeD0TrackParticles"])
210 kwargs.setdefault("InDetCandidateLocation", "TrackParticleCandidateLRT")
211 kwargs.setdefault("DoSiliconAssocForwardMuons", False)
212
213 kwargs.setdefault("InDetForwardTrackSelector", result.popToolsAndMerge(
214 MuonCombinedInDetDetailedForwardTrackSelectorToolCfg(flags)))
215
216 if flags.Reco.EnableCaloExtension and not flags.Muon.MuonTrigger:
217 kwargs.setdefault("CaloExtensionLocation", [
218 "ParticleCaloExtension_LRT"])
219 cand_alg = MuonCombinedInDetCandidateAlgCfg(flags, name, **kwargs)
220 result.merge(cand_alg)
221 return result
222
223

◆ LRT_MuonCreatorAlgCfg()

MuonCombinedReconstructionConfig.LRT_MuonCreatorAlgCfg ( flags,
name = "MuonCreatorAlg_LRT",
** kwargs )

Definition at line 300 of file MuonCombinedReconstructionConfig.py.

300def LRT_MuonCreatorAlgCfg(flags, name="MuonCreatorAlg_LRT", **kwargs):
301 result = ComponentAccumulator()
302 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonCreatorToolCfg
303 creatorTool = result.popToolsAndMerge(
304 MuonCreatorToolCfg(flags, "MuonCreatorTool_LRT", RequireIDTrack=True))
305 kwargs.setdefault("MuonCreatorTool", creatorTool)
306 # In cases we want to switch them off we should add the flags here
307 tag_maps = []
308 if flags.MuonCombined.doMuGirl:
309 tag_maps += ["MuGirlMap_LRT"]
310 if flags.MuonCombined.doStatisticalCombination:
311 tag_maps += ["stacoTagMap_LRT"]
312 if flags.MuonCombined.doCombinedFit:
313 tag_maps += ["muidcoTagMap_LRT"]
314 if flags.MuonCombined.doCaloTrkMuId:
315 tag_maps += ["caloTagMap_LRT"]
316 if flags.MuonCombined.doMuonSegmentTagger:
317 tag_maps += ["segmentTagMap_LRT"]
318 kwargs.setdefault("TagMaps", tag_maps)
319 kwargs.setdefault("MuonContainerLocation", "MuonsLRT")
320 kwargs.setdefault("ExtrapolatedLocation", "ExtraPolatedMuonsLRT")
321 kwargs.setdefault("MSOnlyExtrapolatedLocation",
322 "MSOnlyExtraPolatedMuonsLRT")
323 kwargs.setdefault("CombinedLocation", "CombinedMuonsLRT")
324 kwargs.setdefault("BuildSlowMuon", False)
325 kwargs.setdefault("MakeClusters", False)
326 kwargs.setdefault("ClusterContainerName", "")
327 result.merge(MuonCreatorAlgCfg(flags, name=name, **kwargs))
328 return result
329
330

◆ LRT_MuonInDetToMuonSystemExtensionAlgCfg()

MuonCombinedReconstructionConfig.LRT_MuonInDetToMuonSystemExtensionAlgCfg ( flags,
name = "MuonInDetToMuonSystemExtensionAlg_LRT",
** kwargs )

Definition at line 191 of file MuonCombinedReconstructionConfig.py.

191def LRT_MuonInDetToMuonSystemExtensionAlgCfg(flags, name="MuonInDetToMuonSystemExtensionAlg_LRT", **kwargs):
192 kwargs.setdefault("WriteStauCandidates", "InDetCandidatesStausLRT")
193 kwargs.setdefault("WriteInDetCandidates",
194 "InDetCandidateLRT_SystemExtended")
195 kwargs.setdefault("InputInDetCandidates", "TrackParticleCandidateLRT")
196 kwargs.setdefault("CombinedTagMap", "muidcoTagMap_LRT")
197 return MuonInDetToMuonSystemExtensionAlgCfg(flags, name, **kwargs)
198
199

◆ LRT_MuonSegmentTagAlgCfg()

MuonCombinedReconstructionConfig.LRT_MuonSegmentTagAlgCfg ( flags,
name = "MuonSegmentTagAlg_LRT",
** kwargs )

Definition at line 40 of file MuonCombinedReconstructionConfig.py.

40def LRT_MuonSegmentTagAlgCfg(flags, name="MuonSegmentTagAlg_LRT", **kwargs):
41 kwargs.setdefault("TagMap", "segmentTagMap_LRT")
42 kwargs.setdefault("InDetCandidateLocation", "TrackParticleCandidateLRT"
43 if not flags.MuonCombined.doCombinedFit else "InDetCandidateLRT_SystemExtended")
44 return MuonSegmentTagAlgCfg(flags, name, **kwargs)
45
46

◆ MuGirlStauAlgCfg()

MuonCombinedReconstructionConfig.MuGirlStauAlgCfg ( flags,
name = "MuGirlStauAlg",
** kwargs )

Definition at line 79 of file MuonCombinedReconstructionConfig.py.

79def MuGirlStauAlgCfg(flags, name="MuGirlStauAlg", **kwargs):
80 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonStauRecoToolCfg
81 result = ComponentAccumulator()
82 kwargs.setdefault("MuonCombinedInDetExtensionTool",
83 result.popToolsAndMerge(MuonStauRecoToolCfg(flags)))
84 kwargs.setdefault("TagMap", "stauTagMap")
85 kwargs.setdefault("HasCSC", flags.Detector.GeometryCSC)
86 kwargs.setdefault("HasSTgc", False)
87 kwargs.setdefault("HasMM", False)
88 kwargs.setdefault("TGCPrepDataLocation", 'TGC_MeasurementsAllBCs')
89 kwargs.setdefault("CombinedTrackCollection", "MuGirlStauCombinedTracks")
90 kwargs.setdefault("METrackCollection", "")
91 kwargs.setdefault("SegmentCollection", "TrkStauSegments")
92 kwargs.setdefault("InDetCandidateLocation",
93 "InDetCandidates" if not flags.MuonCombined.doCombinedFit else "InDetCandidatesStaus")
94 alg = CompFactory.MuonCombinedInDetExtensionAlg(name, **kwargs)
95 result.addEventAlgo(alg, primary=True)
96 return result
97
98

◆ MuonCaloTagAlgCfg()

MuonCombinedReconstructionConfig.MuonCaloTagAlgCfg ( flags,
name = "MuonCaloTagAlg",
** kwargs )

Definition at line 8 of file MuonCombinedReconstructionConfig.py.

8def MuonCaloTagAlgCfg(flags, name="MuonCaloTagAlg", **kwargs):
9 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonCaloTagToolCfg
10 result = ComponentAccumulator()
11 kwargs.setdefault("MuonCombinedInDetExtensionTool",
12 result.popToolsAndMerge(MuonCaloTagToolCfg(flags)))
13 kwargs.setdefault("TagMap", "caloTagMap")
14 kwargs.setdefault("CombinedTrackCollection", "")
15 kwargs.setdefault("METrackCollection", "")
16 kwargs.setdefault("usePRDs", False)
17 alg = CompFactory.MuonCombinedInDetExtensionAlg(name, **kwargs)
18 result.addEventAlgo(alg, primary=True)
19 return result
20
21

◆ MuonCombinedAlgCfg()

MuonCombinedReconstructionConfig.MuonCombinedAlgCfg ( flags,
name = "MuonCombinedAlg",
** kwargs )

Definition at line 224 of file MuonCombinedReconstructionConfig.py.

224def MuonCombinedAlgCfg(flags, name="MuonCombinedAlg", **kwargs):
225 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonCombinedToolCfg
226 result = ComponentAccumulator()
227 kwargs.setdefault("MuonCombinedTool", result.popToolsAndMerge(
228 MuonCombinedToolCfg(flags)))
229 tagmaps = []
230 # CombinedTagMaps must be in a 1-1 correspondence
231 # with MuonCombinedTagTools.
232 for h in kwargs['MuonCombinedTool'].MuonCombinedTagTools:
233 if str(h).find('FitTagTool') >= 0:
234 tagmaps.append('muidcoTagMap')
235 elif str(h).find('StacoTagTool') >= 0:
236 tagmaps.append('stacoTagMap')
237 kwargs.setdefault("CombinedTagMaps", tagmaps)
238 alg = CompFactory.MuonCombinedAlg(name, **kwargs)
239 result.addEventAlgo(alg, primary=True)
240 return result
241
242
find
std::string find(const std::string &s)
return a remapped string
Definition hcg.cxx:140

◆ MuonCombinedInDetCandidateAlgCfg()

MuonCombinedReconstructionConfig.MuonCombinedInDetCandidateAlgCfg ( flags,
name = "MuonCombinedInDetCandidateAlg",
** kwargs )

Definition at line 145 of file MuonCombinedReconstructionConfig.py.

145def MuonCombinedInDetCandidateAlgCfg(flags, name="MuonCombinedInDetCandidateAlg", **kwargs):
146 from InDetConfig.InDetTrackSelectorToolConfig import MuonCombinedInDetDetailedTrackSelectorToolCfg, MuonCombinedInDetDetailedForwardTrackSelectorToolCfg
147 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonSystemExtensionToolCfg
148 result = MuonCombinedInDetDetailedTrackSelectorToolCfg(flags)
149 kwargs.setdefault("TrackSelector", result.popPrivateTools())
150 if flags.MuonCombined.doSiAssocForwardMuons and flags.Tracking.doForwardTracks:
151 kwargs.setdefault("DoSiliconAssocForwardMuons", True)
152 kwargs.setdefault("InDetForwardTrackSelector", result.popToolsAndMerge(
153 MuonCombinedInDetDetailedForwardTrackSelectorToolCfg(flags)))
154
155 muon_ext_tool = result.popToolsAndMerge(
156 MuonSystemExtensionToolCfg(flags))
157 kwargs.setdefault("MuonSystemExtensionTool", muon_ext_tool)
158
159 # Switch off the muon system extensions if we fit combined muons
160 # The MuonInDetToSystemExtensionAlg will perform the system extensions then
161 kwargs.setdefault("ExtendBulk", not flags.MuonCombined.doCombinedFit)
162
163 if flags.Reco.EnableCaloExtension and not flags.Muon.MuonTrigger:
164 kwargs.setdefault("CaloExtensionLocation", ["ParticleCaloExtension"])
165
166 alg = CompFactory.MuonCombinedInDetCandidateAlg(name, **kwargs)
167 result.addEventAlgo(alg, primary=True)
168 return result
169
170

◆ MuonCombinedMuonCandidateAlgCfg()

MuonCombinedReconstructionConfig.MuonCombinedMuonCandidateAlgCfg ( flags,
name = "MuonCombinedMuonCandidateAlg",
** kwargs )

Definition at line 99 of file MuonCombinedReconstructionConfig.py.

99def MuonCombinedMuonCandidateAlgCfg(flags, name="MuonCombinedMuonCandidateAlg", **kwargs):
100 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonCandidateToolCfg
101
102 result = ComponentAccumulator()
103
104 # EJWM - not completely sure where this comes from. Perhaps should be retrieved by a sub-tool?
105 from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
106 result.merge(CaloNoiseCondAlgCfg(flags, "totalNoise"))
107
108 tool_kwargs = {}
109 if flags.Beam.Type is BeamType.Cosmics:
110 tool_kwargs.setdefault("ExtrapolationStrategy", 1)
111
112 acc = MuonCandidateToolCfg(flags, **tool_kwargs)
113 kwargs.setdefault("MuonCandidateTool", acc.popPrivateTools())
114 result.merge(acc)
115
116 alg = CompFactory.MuonCombinedMuonCandidateAlg(name, **kwargs)
117 result.addEventAlgo(alg, primary=True)
118 return result
119
120

◆ MuonCombinedReconstructionCfg()

MuonCombinedReconstructionConfig.MuonCombinedReconstructionCfg ( flags)

Definition at line 672 of file MuonCombinedReconstructionConfig.py.

672def MuonCombinedReconstructionCfg(flags):
673 from MuonConfig.MuonGeometryConfig import MuonIdHelperSvcCfg
674
675 # Many components need these services, so setup once here.
676 result = MuonIdHelperSvcCfg(flags)
677
678 from CaloRec.CaloTopoClusterConfig import CaloTopoClusterCfg
679 result.merge(CaloTopoClusterCfg(flags))
680 from TrackToCalo.CaloExtensionBuilderAlgCfg import CaloExtensionBuilderCfg
681 result.merge(CaloExtensionBuilderCfg(flags))
682
683 from TrackingGeometryCondAlg.AtlasTrackingGeometryCondAlgConfig import TrackingGeometryCondAlgCfg
684 result.merge(TrackingGeometryCondAlgCfg(flags))
685 from MuonConfig.MuonRecToolsConfig import MuonEDMHelperSvcCfg
686 result.merge(MuonEDMHelperSvcCfg(flags))
687
688 # Set up to read Tracks.
689 from TrkConfig.TrackCollectionReadConfig import TrackCollectionReadCfg
690 result.merge(TrackCollectionReadCfg(flags, 'Tracks'))
691
692 # We do not need to schedule the Inner detector selector algs if none
693 # of the combined algs executed
694 if flags.MuonCombined.doMuGirl or \
695 flags.MuonCombined.doStatisticalCombination or \
696 flags.MuonCombined.doCaloTrkMuId or \
697 flags.MuonCombined.doCombinedFit or \
698 flags.MuonCombined.doMuonSegmentTagger:
699
700 result.merge(MuonCombinedInDetCandidateAlgCfg(flags))
701 if flags.Tracking.doLargeD0:
702 result.merge(LRT_MuonCombinedInDetCandidateAlgCfg(flags))
703
704 result.merge(MuonCombinedMuonCandidateAlgCfg(flags))
705
706 if flags.MuonCombined.doStatisticalCombination or flags.MuonCombined.doCombinedFit:
707 result.merge(MuonCombinedAlgCfg(flags))
708 if flags.Tracking.doLargeD0:
709 result.merge(LRT_MuonCombinedAlgCfg(flags))
710
711 # Perform system extensions on ID tracks where MuidCo did not succeed
712 if flags.MuonCombined.doCombinedFit:
713 result.merge(MuonInDetToMuonSystemExtensionAlgCfg(flags))
714 if flags.Tracking.doLargeD0:
715 result.merge(LRT_MuonInDetToMuonSystemExtensionAlgCfg(flags))
716 if flags.MuonCombined.doMuGirl:
717 # Use only ID tracks rejected by MuidCo
718 result.merge(MuonInsideOutRecoAlgCfg(flags, name="MuonInsideOutRecoAlg",
719 InDetCandidateLocation="InDetCandidates"
720 if not flags.MuonCombined.doCombinedFit else "InDetCandidatesSystemExtened"))
721 if flags.MuonCombined.doMuGirlLowBeta:
722 if flags.Tracking.doLargeD0:
723 result.merge(MuonInDetExtensionMergerAlgCfg(flags))
724 # Use the InDetCandidateStaus as InDetCandidates as they've also the extensions
725 # from the MuidCo tracks
726 result.merge(MuGirlStauAlgCfg(flags))
727 if flags.Tracking.doLargeD0:
728 result.merge(LRT_MuGirlAlgCfg(flags))
729
730 if flags.MuonCombined.doCaloTrkMuId:
731 result.merge(MuonCaloTagAlgCfg(flags))
732 if flags.Tracking.doLargeD0:
733 result.merge(LRT_MuonCaloTagAlgCfg(flags))
734
735 if flags.MuonCombined.doMuonSegmentTagger:
736 result.merge(MuonSegmentTagAlgCfg(flags))
737 if flags.Tracking.doLargeD0:
738 result.merge(LRT_MuonSegmentTagAlgCfg(flags))
739
740 if flags.Muon.runCommissioningChain:
741 result.merge(EMEO_MuonCombinedMuonCandidateAlgCfg(flags))
742 result.merge(EMEO_MuonCombinedAlgCfg(flags))
743
744 result.merge(MuonSegContainerMergerAlgCfg(flags))
745 from MuonConfig.MuonSegmentFindingConfig import MuonSegmentCnvAlgCfg
746 result.merge(MuonSegmentCnvAlgCfg(flags, "MuonSegmentCnvAlg",
747 SegmentContainerName="TrkMuonSegments",
748 xAODContainerName="MuonSegments"))
749 if flags.MuonCombined.writeUnAssocSegments:
750 result.merge(MuonSegmentCnvAlgCfg(flags, "UnAssocMuonSegmentCnvAlg",
751 SegmentContainerName="UnAssocMuonTrkSegments",
752 xAODContainerName="UnAssocMuonSegments"))
753 if flags.MuonCombined.doMuGirlLowBeta:
754 result.merge(MuonSegmentCnvAlgCfg(flags, "MuonStauSegmentCnvAlg",
755 SegmentContainerName="TrkStauSegments",
756 xAODContainerName="StauSegments"))
757 if flags.Muon.runCommissioningChain:
758 result.merge(EMEO_MuonCreatorAlgCfg(flags))
759 # runs over outputs and create xAODMuon collection
760 result.merge(MuonCreatorAlgCfg(flags))
761 if flags.Tracking.doLargeD0:
762 result.merge(LRT_MuonCreatorAlgCfg(flags))
763
764 if flags.MuonCombined.doMuGirlLowBeta:
765 # Has to be at end if not using sequencer. If we drop this requirement, can be moved above
766 result.merge(StauCreatorAlgCfg(flags))
767
768 # FIXME
769 # I see errors related to unconfigured public tools. This is a quick fix, but should really move to where it is called.
770 from MuonConfig.MuonRecToolsConfig import MuonTrackScoringToolCfg
771 result.addPublicTool(result.popToolsAndMerge(
772 MuonTrackScoringToolCfg(flags)))
773 from TrkConfig.TrkTrackSummaryToolConfig import MuonCombinedTrackSummaryToolCfg
774 result.addPublicTool(result.popToolsAndMerge(
775 MuonCombinedTrackSummaryToolCfg(flags)))
776
777 # post processing
778 from AthenaConfiguration.Enums import Format
779 if flags.Input.isMC and flags.Input.Format != Format.BS:
780 result.merge(CombinedMuonTrackTruthAlgsCfg(flags))
781 result.merge(CombinedMuonTruthAssociationAlgsCfg(flags))
782 if not flags.Muon.usePhaseIIGeoSetup and \
783 "MuonSegments" not in flags.Input.Collections:
784 # Segment truth association decorations, but only if they are not already there (e.g. when running on ESDs)
785 from MuonConfig.MuonTruthAlgsConfig import MuonSegmentTruthAssociationAlgCfg
786 result.merge(MuonSegmentTruthAssociationAlgCfg(flags))
787
788 result.addEventAlgo(CompFactory.ClusterMatching.CaloClusterMatchLinkAlg(
789 "MuonTCLinks", ClustersToDecorate="MuonClusterCollection"))
790 result.merge(MuonDecorationAlgsCfg(flags))
791 # Setup output
792 result.merge(CombinedMuonOutputCfg(flags))
793
794 return result
795
796

◆ MuonCreatorAlgCfg()

MuonCombinedReconstructionConfig.MuonCreatorAlgCfg ( flags,
name = "MuonCreatorAlg",
** kwargs )

Definition at line 267 of file MuonCombinedReconstructionConfig.py.

267def MuonCreatorAlgCfg(flags, name="MuonCreatorAlg", **kwargs):
268 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonCreatorToolCfg
269 result = MuonCreatorToolCfg(flags, name="MuonCreatorTool")
270 kwargs.setdefault("MuonCreatorTool", result.popPrivateTools())
271
272 # if muGirl is off, remove "muGirlTagMap" from "TagMaps"
273 # but don't set this default in case the StauCreatorAlg is created (see below)
274 tag_maps = []
275 if flags.MuonCombined.doMuGirl:
276 tag_maps += ["muGirlTagMap"]
277 if flags.MuonCombined.doStatisticalCombination:
278 tag_maps += ["stacoTagMap"]
279 if flags.MuonCombined.doCombinedFit:
280 tag_maps += ["muidcoTagMap"]
281 if flags.MuonCombined.doCaloTrkMuId:
282 tag_maps += ["caloTagMap"]
283 if flags.MuonCombined.doMuonSegmentTagger:
284 tag_maps += ["segmentTagMap"]
285 kwargs.setdefault("TagMaps", tag_maps)
286 if flags.Muon.MuonTrigger:
287 kwargs.setdefault("MakeClusters", False)
288 kwargs.setdefault("ClusterContainerName", "")
289 kwargs.setdefault("SegmentContainerName", "")
290 kwargs.setdefault("TagToSegmentKey", "")
291 if flags.Muon.SAMuonTrigger:
292 kwargs.setdefault("CreateSAmuons", True)
293 kwargs.setdefault("TagMaps", [])
294
295 alg = CompFactory.MuonCreatorAlg(name, **kwargs)
296 result.addEventAlgo(alg, primary=True)
297 return result
298
299

◆ MuonDecorationAlgsCfg()

MuonCombinedReconstructionConfig.MuonDecorationAlgsCfg ( flags)

Definition at line 476 of file MuonCombinedReconstructionConfig.py.

476def MuonDecorationAlgsCfg(flags):
477 result = ComponentAccumulator()
478 trk_cols = ["ExtrapolatedMuonTrackParticles",
479 "CombinedMuonTrackParticles",
480 "MSOnlyExtrapolatedMuonTrackParticles"]
481 stau_coll = ["CombinedStauTrackParticles",
482 "ExtrapolatedStauTrackParticles"] if flags.MuonCombined.doMuGirl and flags.MuonCombined.doMuGirlLowBeta else []
483 track_coll_lrt = ["CombinedMuonsLRTTrackParticles",
484 "ExtraPolatedMuonsLRTTrackParticles",
485 "MSOnlyExtraPolatedMuonsLRTTrackParticles"] if flags.Tracking.doLargeD0 else []
486
487 # Decorate the muon tracks
488 for coll in trk_cols + stau_coll + track_coll_lrt:
489 result.merge(MuonTrkIDMSScatterDecorAlgCfg(flags, "MuonCombIDMSScatterDecorAlg"+coll,
490 TrackContainer=coll))
491
492 result.merge(MuonTrkAEOTDecorAlgCfg(flags, "MuonCombAEOTDecorAlg"+coll,
493 TrackContainer=coll))
494 # Proceed with the precision layer decoration
495 prec_trk_cols = ["ExtrapolatedMuonTrackParticles",
496 "CombinedMuonTrackParticles",
497 "MSOnlyExtrapolatedMuonTrackParticles"]
498 result.merge(MuonPrecisionLayerDecorAlgCfg(flags, "MuonCombPrecisionLayerDecorAlg",
499 MuonContainer="Muons",
500 TrackContainer=prec_trk_cols))
501 if flags.MuonCombined.doMuGirl and flags.MuonCombined.doMuGirlLowBeta:
502
503 result.merge(MuonPrecisionLayerDecorAlgCfg(flags, "MuonCombStauPrecisionLayerDecorAlg",
504 MuonContainer="Staus",
505 TrackContainer=stau_coll))
506 if flags.Tracking.doLargeD0:
507
508 result.merge(MuonPrecisionLayerDecorAlgCfg(flags, "MuonCombLRTPrecisionLayerDecorAlg",
509 MuonContainer="MuonsLRT",
510 TrackContainer=track_coll_lrt))
511
512 return result
513
514

◆ MuonInDetExtensionMergerAlgCfg()

MuonCombinedReconstructionConfig.MuonInDetExtensionMergerAlgCfg ( flags,
name = "MuonInDetExtensionMergerAlg",
** kwargs )

Definition at line 411 of file MuonCombinedReconstructionConfig.py.

411def MuonInDetExtensionMergerAlgCfg(flags, name="MuonInDetExtensionMergerAlg", **kwargs):
412 result = ComponentAccumulator()
413 kwargs.setdefault(
414 "ToMerge", ["InDetCandidatesStausPrompt", "InDetCandidatesStausLRT"])
415 kwargs.setdefault("ToWrite", "InDetCandidatesStaus")
416 the_alg = CompFactory.MuonInDetExtensionMergerAlg(name, **kwargs)
417 result.addEventAlgo(the_alg, primary=True)
418 return result
419
420# Returns a pair vectors containing th names of the
421# track particle collections associated with combined muon tracks
422
423

◆ MuonInDetToMuonSystemExtensionAlgCfg()

MuonCombinedReconstructionConfig.MuonInDetToMuonSystemExtensionAlgCfg ( flags,
name = "MuonInDetToMuonSystemExtensionAlg",
** kwargs )

Definition at line 171 of file MuonCombinedReconstructionConfig.py.

171def MuonInDetToMuonSystemExtensionAlgCfg(flags, name="MuonInDetToMuonSystemExtensionAlg", **kwargs):
172 result = ComponentAccumulator()
173 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonSystemExtensionToolCfg
174 muon_ext_tool = result.popToolsAndMerge(
175 MuonSystemExtensionToolCfg(flags))
176 kwargs.setdefault("MuonSystemExtensionTool", muon_ext_tool)
177 kwargs.setdefault("noNSWforSeeding", True)
178 kwargs.setdefault("WriteStauCandidates", "InDetCandidatesStausPrompt"
179 if flags.Tracking.doLargeD0 else "InDetCandidatesStaus")
180
181 if not flags.Muon.MuonTrigger:
182 from MuonConfig.MuonSegmentFindingConfig import MuonLayerHoughAlgCfg
183 result.merge(MuonLayerHoughAlgCfg(flags))
184 kwargs.setdefault("UseOnlyHitSectors",
185 not flags.Muon.MuonTrigger and flags.Beam.Type is BeamType.Collisions)
186 alg = CompFactory.MuonInDetToMuonSystemExtensionAlg(name, **kwargs)
187 result.addEventAlgo(alg, primary=True)
188 return result
189
190

◆ MuonInsideOutRecoAlgCfg()

MuonCombinedReconstructionConfig.MuonInsideOutRecoAlgCfg ( flags,
name = "MuonInsideOutRecoAlg",
** kwargs )

Definition at line 47 of file MuonCombinedReconstructionConfig.py.

47def MuonInsideOutRecoAlgCfg(flags, name="MuonInsideOutRecoAlg", **kwargs):
48 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonInsideOutRecoToolCfg
49 result = ComponentAccumulator()
50 kwargs.setdefault("MuonCombinedInDetExtensionTool",
51 result.popToolsAndMerge(MuonInsideOutRecoToolCfg(flags)))
52 kwargs.setdefault("usePRDs", True)
53 kwargs.setdefault("HasCSC", flags.Detector.GeometryCSC)
54 kwargs.setdefault("HasSTgc", flags.Detector.GeometrysTGC)
55 kwargs.setdefault("HasMM", flags.Detector.GeometryMM)
56 kwargs.setdefault("TagMap", "muGirlTagMap")
57 kwargs.setdefault("SegmentCollection", "MuGirlSegments")
58 kwargs.setdefault("TGCPrepDataLocation",
59 'TGC_MeasurementsAllBCs')
60 kwargs.setdefault("InDetCandidateLocation",
61 "InDetCandidates" if not flags.MuonCombined.doCombinedFit else "InDetCandidatesSystemExtened")
62
63 alg = CompFactory.MuonCombinedInDetExtensionAlg(name, **kwargs)
64 result.addEventAlgo(alg, primary=True)
65 return result
66
67

◆ MuonPrecisionLayerDecorAlgCfg()

MuonCombinedReconstructionConfig.MuonPrecisionLayerDecorAlgCfg ( flags,
name = "MuonPrecisionLayerDecorAlg",
** kwargs )

Definition at line 469 of file MuonCombinedReconstructionConfig.py.

469def MuonPrecisionLayerDecorAlgCfg(flags, name="MuonPrecisionLayerDecorAlg", **kwargs):
470 result = ComponentAccumulator()
471 the_alg = CompFactory.MuonPrecisionLayerDecorAlg(name=name, **kwargs)
472 result.addEventAlgo(the_alg)
473 return result
474
475

◆ MuonSegContainerMergerAlgCfg()

MuonCombinedReconstructionConfig.MuonSegContainerMergerAlgCfg ( flags,
name = "MuonSegContainerMergerAlg",
** kwargs )

Definition at line 371 of file MuonCombinedReconstructionConfig.py.

371def MuonSegContainerMergerAlgCfg(flags, name="MuonSegContainerMergerAlg", **kwargs):
372 result = ComponentAccumulator()
373 kwargs.setdefault("saveUnusedSegments",
374 flags.MuonCombined.writeUnAssocSegments)
375 tag_maps = []
376 if flags.MuonCombined.doMuGirl:
377 tag_maps += ["muGirlTagMap"]
378 if flags.MuonCombined.doStatisticalCombination:
379 tag_maps += ["stacoTagMap"]
380 if flags.MuonCombined.doCombinedFit:
381 tag_maps += ["muidcoTagMap"]
382 if flags.MuonCombined.doMuonSegmentTagger:
383 tag_maps += ["segmentTagMap"]
384 muon_maps = ["MuonCandidates"]
385 if flags.Muon.runCommissioningChain:
386 if flags.MuonCombined.doStatisticalCombination:
387 tag_maps += ["stacoTagMap_EMEO"]
388 if flags.MuonCombined.doCombinedFit:
389 tag_maps += ["muidcoTagMap_EMEO"]
390 muon_maps += ["MuonCandidates_EMEO"]
391 if flags.Tracking.doLargeD0:
392 if flags.MuonCombined.doMuGirl:
393 tag_maps += ["MuGirlMap_LRT"]
394 if flags.MuonCombined.doStatisticalCombination:
395 tag_maps += ["stacoTagMap_LRT"]
396 if flags.MuonCombined.doCombinedFit:
397 tag_maps += ["muidcoTagMap_LRT"]
398 if flags.MuonCombined.doMuonSegmentTagger:
399 tag_maps += ["segmentTagMap_LRT"]
400 kwargs.setdefault("MuonCandidateMaps", muon_maps)
401 kwargs.setdefault("TagMaps", tag_maps)
402 from MuonConfig.MuonRecToolsConfig import MuonAmbiProcessorCfg
403 kwargs.setdefault("AmbiguityProcessor", result.popToolsAndMerge(
404 MuonAmbiProcessorCfg(flags)))
405
406 the_alg = CompFactory.MuonSegContainerMergerAlg(name, **kwargs)
407 result.addEventAlgo(the_alg)
408 return result
409
410

◆ MuonSegmentTagAlgCfg()

MuonCombinedReconstructionConfig.MuonSegmentTagAlgCfg ( flags,
name = "MuonSegmentTagAlg",
** kwargs )

Definition at line 28 of file MuonCombinedReconstructionConfig.py.

28def MuonSegmentTagAlgCfg(flags, name="MuonSegmentTagAlg", **kwargs):
29 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonSegmentTagToolCfg
30 result = MuonSegmentTagToolCfg(flags)
31 muon_segment_tag_tool = result.popPrivateTools()
32 kwargs.setdefault("MuonSegmentTagTool", muon_segment_tag_tool)
33 kwargs.setdefault("InDetCandidateLocation",
34 "InDetCandidates" if not flags.MuonCombined.doCombinedFit else "InDetCandidatesSystemExtened")
35 alg = CompFactory.MuonSegmentTagAlg(name, **kwargs)
36 result.addEventAlgo(alg, primary=True)
37 return result
38
39

◆ MuonTrkAEOTDecorAlgCfg()

MuonCombinedReconstructionConfig.MuonTrkAEOTDecorAlgCfg ( flags,
name = "MuonCombAEOTDecorAlg",
** kwargs )

Definition at line 462 of file MuonCombinedReconstructionConfig.py.

462def MuonTrkAEOTDecorAlgCfg(flags, name="MuonCombAEOTDecorAlg", **kwargs):
463 result = ComponentAccumulator()
464 the_alg = CompFactory.MuonTrkAEOTDecorationAlg(name=name, **kwargs)
465 result.addEventAlgo(the_alg)
466 return result
467
468

◆ MuonTrkIDMSScatterDecorAlgCfg()

MuonCombinedReconstructionConfig.MuonTrkIDMSScatterDecorAlgCfg ( flags,
name = "MuonCombIDMSScatterDecorAlg",
** kwargs )

Definition at line 455 of file MuonCombinedReconstructionConfig.py.

455def MuonTrkIDMSScatterDecorAlgCfg(flags, name="MuonCombIDMSScatterDecorAlg", **kwargs):
456 result = ComponentAccumulator()
457 the_alg = CompFactory.MuonTrkIDMSScatterDecorAlg(name=name, **kwargs)
458 result.addEventAlgo(the_alg)
459 return result
460
461

◆ StauCreatorAlgCfg()

MuonCombinedReconstructionConfig.StauCreatorAlgCfg ( flags,
name = "StauCreatorAlg",
** kwargs )

Definition at line 351 of file MuonCombinedReconstructionConfig.py.

351def StauCreatorAlgCfg(flags, name="StauCreatorAlg", **kwargs):
352 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonCreatorToolCfg
353 result = MuonCreatorToolCfg(
354 flags, BuildStauContainer=True, name='StauCreatorTool')
355 kwargs.setdefault("MuonCreatorTool", result.popPrivateTools())
356 kwargs.setdefault("MuonContainerLocation", "Staus")
357 kwargs.setdefault("CombinedLocation", "CombinedStau")
358 kwargs.setdefault("ExtrapolatedLocation", "ExtrapolatedStau")
359 kwargs.setdefault("MSOnlyExtrapolatedLocation", "MSOnlyExtrapolatedStau")
360 kwargs.setdefault("MuonCandidateLocation", [])
361 kwargs.setdefault("SegmentContainerName", "StauSegments")
362 kwargs.setdefault("TagToSegmentKey", "")
363 kwargs.setdefault("BuildSlowMuon", 1)
364 kwargs.setdefault("ClusterContainerName", "SlowMuonClusterCollection")
365 kwargs.setdefault("TagMaps", ["stauTagMap"])
366 acc = MuonCreatorAlgCfg(flags, name, **kwargs)
367 result.merge(acc)
368 return result # don't have the right algorithm being primary here, but should be okay?
369
370

Variable Documentation

◆ cfg

MuonCombinedReconstructionConfig.cfg = SetupMuonStandaloneCA(flags)

Definition at line 818 of file MuonCombinedReconstructionConfig.py.

◆ doMuGirlLowBeta

MuonCombinedReconstructionConfig.doMuGirlLowBeta

Definition at line 810 of file MuonCombinedReconstructionConfig.py.

◆ Files

MuonCombinedReconstructionConfig.Files

Definition at line 804 of file MuonCombinedReconstructionConfig.py.

◆ flags

MuonCombinedReconstructionConfig.flags = initConfigFlags()

Definition at line 803 of file MuonCombinedReconstructionConfig.py.

◆ rename_maps

list MuonCombinedReconstructionConfig.rename_maps
Initial value:
1= ['%s#%s->%s' % ("xAOD::MuonContainer", "Muons", "old_Muons"),
2 '%s#%s->%s' % ("xAOD::MuonAuxContainer",
3 "MuonsAux.", "old_MuonsAux."),
4 '%s#%s->%s' % ("xAOD::MuonContainer",
5 "Muons.rpcHitIdentifier", "old_Muons.rpcHitIdentifier"),
6 '%s#%s->%s' % ("xAOD::TruthParticleContainer",
7 "MuonTruthParticles.recoMuonLink", "MuonTruthParticles.old_recoMuonLink")
8 ]

Definition at line 846 of file MuonCombinedReconstructionConfig.py.

◆ UseOnlyHitSectors

MuonCombinedReconstructionConfig.UseOnlyHitSectors

Definition at line 828 of file MuonCombinedReconstructionConfig.py.

Generated on for ATLAS Offline Software by doxygen 1.16.1