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
 useTGCPriorNextBC
 doMuGirlLowBeta
 cfg = SetupMuonStandaloneCA(flags)
 UseOnlyHitSectors
list rename_maps

Function Documentation

◆ CombinedMuonOutputCfg()

MuonCombinedReconstructionConfig.CombinedMuonOutputCfg ( flags)

Definition at line 563 of file MuonCombinedReconstructionConfig.py.

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

◆ CombinedMuonTrackTruthAlgsCfg()

MuonCombinedReconstructionConfig.CombinedMuonTrackTruthAlgsCfg ( flags)

Definition at line 518 of file MuonCombinedReconstructionConfig.py.

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

◆ CombinedMuonTruthAssociationAlgsCfg()

MuonCombinedReconstructionConfig.CombinedMuonTruthAssociationAlgsCfg ( flags)

Definition at line 536 of file MuonCombinedReconstructionConfig.py.

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

◆ EMEO_MuonCombinedAlgCfg()

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

Definition at line 246 of file MuonCombinedReconstructionConfig.py.

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

◆ EMEO_MuonCombinedMuonCandidateAlgCfg()

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

Definition at line 124 of file MuonCombinedReconstructionConfig.py.

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

◆ EMEO_MuonCreatorAlgCfg()

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

Definition at line 334 of file MuonCombinedReconstructionConfig.py.

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

◆ GetCombinedTrkContainers()

MuonCombinedReconstructionConfig.GetCombinedTrkContainers ( flags)

Definition at line 427 of file MuonCombinedReconstructionConfig.py.

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

◆ 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 261 of file MuonCombinedReconstructionConfig.py.

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

◆ LRT_MuonCombinedInDetCandidateAlgCfg()

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

Definition at line 203 of file MuonCombinedReconstructionConfig.py.

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

◆ LRT_MuonCreatorAlgCfg()

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

Definition at line 303 of file MuonCombinedReconstructionConfig.py.

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

◆ LRT_MuonInDetToMuonSystemExtensionAlgCfg()

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

Definition at line 194 of file MuonCombinedReconstructionConfig.py.

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

◆ 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",
89 # 'TGC_MeasurementsAllBCs' if not flags.Muon.useTGCPriorNextBC else 'TGC_Measurements')
90 # This is probably wrong, but matches old-config. #FIXME
91 kwargs.setdefault("TGCPrepDataLocation", 'TGC_Measurements')
92 kwargs.setdefault("CombinedTrackCollection", "MuGirlStauCombinedTracks")
93 kwargs.setdefault("METrackCollection", "")
94 kwargs.setdefault("SegmentCollection", "TrkStauSegments")
95 kwargs.setdefault("InDetCandidateLocation",
96 "InDetCandidates" if not flags.MuonCombined.doCombinedFit else "InDetCandidatesStaus")
97 alg = CompFactory.MuonCombinedInDetExtensionAlg(name, **kwargs)
98 result.addEventAlgo(alg, primary=True)
99 return result
100
101

◆ 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 227 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonCombinedInDetCandidateAlgCfg()

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

Definition at line 148 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonCombinedMuonCandidateAlgCfg()

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

Definition at line 102 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonCombinedReconstructionCfg()

MuonCombinedReconstructionConfig.MuonCombinedReconstructionCfg ( flags)

Definition at line 675 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonCreatorAlgCfg()

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

Definition at line 270 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonDecorationAlgsCfg()

MuonCombinedReconstructionConfig.MuonDecorationAlgsCfg ( flags)

Definition at line 479 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonInDetExtensionMergerAlgCfg()

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

Definition at line 414 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonInDetToMuonSystemExtensionAlgCfg()

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

Definition at line 174 of file MuonCombinedReconstructionConfig.py.

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

◆ 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' if not flags.Muon.useTGCPriorNextBC else 'TGC_Measurements')
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 472 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonSegContainerMergerAlgCfg()

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

Definition at line 374 of file MuonCombinedReconstructionConfig.py.

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

◆ 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 465 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonTrkIDMSScatterDecorAlgCfg()

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

Definition at line 458 of file MuonCombinedReconstructionConfig.py.

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

◆ StauCreatorAlgCfg()

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

Definition at line 354 of file MuonCombinedReconstructionConfig.py.

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

Variable Documentation

◆ cfg

MuonCombinedReconstructionConfig.cfg = SetupMuonStandaloneCA(flags)

Definition at line 822 of file MuonCombinedReconstructionConfig.py.

◆ doMuGirlLowBeta

MuonCombinedReconstructionConfig.doMuGirlLowBeta

Definition at line 814 of file MuonCombinedReconstructionConfig.py.

◆ Files

MuonCombinedReconstructionConfig.Files

Definition at line 807 of file MuonCombinedReconstructionConfig.py.

◆ flags

MuonCombinedReconstructionConfig.flags = initConfigFlags()

Definition at line 806 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 850 of file MuonCombinedReconstructionConfig.py.

◆ UseOnlyHitSectors

MuonCombinedReconstructionConfig.UseOnlyHitSectors

Definition at line 832 of file MuonCombinedReconstructionConfig.py.

◆ useTGCPriorNextBC

MuonCombinedReconstructionConfig.useTGCPriorNextBC

Definition at line 812 of file MuonCombinedReconstructionConfig.py.

Generated on for ATLAS Offline Software by doxygen 1.14.0