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)
 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)
 LRT_MuonCombinedAlgCfg (flags, name="MuonCombinedAlg_LRT", **kwargs)
 MuonCreatorAlgCfg (flags, name="MuonCreatorAlg", **kwargs)
 LRT_MuonCreatorAlgCfg (flags, name="MuonCreatorAlg_LRT", **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()

CombinedMuonOutputCfg ( flags)

Definition at line 519 of file MuonCombinedReconstructionConfig.py.

519def CombinedMuonOutputCfg(flags):
520 from OutputStreamAthenaPool.OutputStreamConfig import addToESD, addToAOD
521 result = ComponentAccumulator()
522
523 # FIXME! Fix for ATLASRECTS-5151. Remove when better solution found.
524 from TrkEventCnvTools.TrkEventCnvToolsConfig import (
525 TrkEventCnvSuperToolCfg)
526 result.merge(TrkEventCnvSuperToolCfg(flags))
527
528 # Avoid old-style import from from IsolationAlgs.IsoUpdatedTrackCones import iso_vars
529 # But shouldn't be here.
530 iso_vars = []
531 for track_pt in 500, 1000:
532 for cone_str in "", "LooseCone":
533 name = f"Nonprompt_All_MaxWeightTTVA{cone_str}_pt{track_pt}"
534 iso_vars += ["ptconeCorrBitset_"+name,
535 "ptconecoreTrackPtrCorrection_"+name]
536 for cone_size in 20, 30, 40:
537 for var_str in "", "var":
538 iso_vars.append(f"pt{var_str}cone{cone_size}_{name}")
539
540 aod_items = []
541 # Segments
542 aod_items += ["xAOD::MuonSegmentContainer#MuonSegments"]
543 aod_items += ["xAOD::MuonSegmentAuxContainer#MuonSegmentsAux."]
544 if flags.MuonCombined.writeUnAssocSegments:
545 aod_items += ["xAOD::MuonSegmentContainer#UnAssocMuonSegments"]
546 aod_items += ["xAOD::MuonSegmentAuxContainer#UnAssocMuonSegmentsAux."]
547 if flags.MuonCombined.doMuGirlLowBeta:
548 aod_items += ["xAOD::MuonSegmentContainer#StauSegments"]
549 aod_items += ["xAOD::MuonSegmentAuxContainer#StauSegmentsAux."]
550
551 particle_col, trk_col = GetCombinedTrkContainers(flags)
552 if flags.Detector.EnableCalo:
553 aod_items += ["xAOD::CaloClusterContainer#MuonClusterCollection"]
554 aod_items += ["xAOD::CaloClusterAuxContainer#MuonClusterCollectionAux."]
555 aod_items += ["CaloClusterCellLinkContainer#MuonClusterCollection_links"]
556 from CaloRec.CaloThinCellsByClusterAlgConfig import CaloThinCellsByClusterAlgCfg
557 result.merge(CaloThinCellsByClusterAlgCfg(flags, streamName="StreamAOD",
558 clusters="MuonClusterCollection",
559 samplings=["TileGap1", "TileGap2", "TileGap3", "TileBar0", "TileExt0", "HEC0"]))
560
561 # Adding the xAOD content by default
562 excludedAuxData = '-clusterAssociation'
563 aod_items += ["xAOD::TrackParticleContainer#"+col for col in particle_col]
564 aod_items += ["xAOD::TrackParticleAuxContainer#"+col +
565 "Aux." + excludedAuxData for col in particle_col]
566
567 if not flags.Muon.scheduleActsReco:
568 aod_items += ["xAOD::MuonContainer#Muons"]
569 aod_items += ["xAOD::MuonContainer#MuonsLRT"]
570 else:
571 aod_items += ["xAOD::MuonContainer#MuonsLegacy"]
572 aod_items += ["xAOD::MuonContainer#MuonsLRTLegacy"]
573
574
575 # FIXME! Next two lines are hack to remove derivation framework variables that are added by DRAW building and are supposed to be transient
576 wp_decors = ["DFCommonMuonsTight", "DFCommonGoodMuon", "DFCommonMuonsMedium",
577 "DFCommonMuonsLoose", "InnerDetectorPt", "MuonSpectrometerPt", "isMedium_DRAWZmumu"]
578 # Remove GlobalFELinks and related variables - these are links between FlowElement (FE) containers created in jet finding and muons.
579 # Since these transient FE containers are not in the ESD/AOD, we should not write out these links.
580 gpf_vars = ["chargedGlobalFELinks", "neutralGlobalFELinks",
581 "deltaR_muon_clus_GlobalFEalg", "muon_efrac_matched_GlobalFE"]
582
583 excludedMuonAuxData = ".-"+".-".join(iso_vars+wp_decors+gpf_vars)
584
585 aod_items += ["xAOD::MuonAuxContainer#MuonsAux" + excludedMuonAuxData]
586 aod_items += ["xAOD::MuonAuxContainer#MuonsLRTAux" + excludedMuonAuxData]
587
588 # stau
589 aod_items += ["xAOD::MuonContainer#Staus"]
590 aod_items += ["xAOD::MuonAuxContainer#StausAux" + excludedMuonAuxData]
591 aod_items += ["xAOD::SlowMuonContainer#SlowMuons"]
592 aod_items += ["xAOD::SlowMuonAuxContainer#SlowMuonsAux."]
593
594 # +++++ ESD +++++
595
596 # Tracks
597 esd_items = ["TrackCollection#"+col for col in trk_col]
598 esd_items += ["Trk::SegmentCollection#TrkMuonSegments"]
599 if flags.MuonCombined.writeUnAssocSegments:
600 esd_items += ["Trk::SegmentCollection#UnAssocMuonTrkSegments"]
601 # Truth
602 if flags.Input.isMC:
603 esd_items += ["DetailedTrackTruthCollection#ExtrapolatedMuonTracksTruth"]
604 esd_items += ["DetailedTrackTruthCollection#CombinedMuonTracksTruth"]
605 esd_items += ["DetailedTrackTruthCollection#ExtrapolatedMuonTrackParticlesTruth"]
606 esd_items += ["DetailedTrackTruthCollection#CombinedMuonTrackParticlesTruth"]
607
608 if flags.MuonCombined.doCosmicSplitTracks:
609 esd_items += ["TrackCollection#Combined_Tracks_split"]
610 esd_items += ["TrackCollection#Tracks_split"]
611 esd_items += ["Rec::TrackParticleContainer#TrackParticleCandidate_split"]
612
613 esd_items += aod_items
614
615 result.merge(addToESD(flags, esd_items))
616 result.merge(addToAOD(flags, aod_items))
617
618 # Leaving in for the moment, because we might still need this. Will remove once it's confirmed we don't
619 # if flags.Output.doWriteESD:
620 #
621 # if runOnESD:
622 # # Need to make it possible to write Object ... so rename read containers
623 # from AthenaCommon.Logging import log
624 # from SGComps.AddressRemappingConfig import AddressRemappingCfg
625 # rename_maps = list(map(lambda item:'%s->%s' % (item, 'old_'+item.split('#')[1]), esd_items))
626 # log.info('Since we are running on ESD, rename inputs as follows:'+str(rename_maps))
627 # cfg.merge( AddressRemappingCfg(rename_maps) )
628
629 return result
630
631

◆ CombinedMuonTrackTruthAlgsCfg()

CombinedMuonTrackTruthAlgsCfg ( flags)

Definition at line 478 of file MuonCombinedReconstructionConfig.py.

478def CombinedMuonTrackTruthAlgsCfg(flags):
479 result = ComponentAccumulator()
480 particle_cols, trk_cols = GetCombinedTrkContainers(flags)
481
482 from MuonConfig.MuonTruthAlgsConfig import MuonDetailedTrackTruthMakerCfg
483 result.merge(MuonDetailedTrackTruthMakerCfg(flags, name="MuonCombinedDetailedTrackTruthMaker",
484 TrackCollectionNames=trk_cols))
485
486 if not flags.Muon.usePhaseIIGeoSetup:
487 for i in range(len(trk_cols)):
488 from TrkConfig.TrkTruthAlgsConfig import TrackTruthSelectorCfg, TrackParticleTruthAlgCfg
489 result.merge(TrackTruthSelectorCfg(flags, tracks=trk_cols[i]))
490 result.merge(TrackParticleTruthAlgCfg(flags, tracks=trk_cols[i],
491 TrackParticleName=particle_cols[i]))
492
493 return result
494
495

◆ CombinedMuonTruthAssociationAlgsCfg()

CombinedMuonTruthAssociationAlgsCfg ( flags)

Definition at line 496 of file MuonCombinedReconstructionConfig.py.

496def CombinedMuonTruthAssociationAlgsCfg(flags):
497 result = ComponentAccumulator()
498 if flags.Muon.usePhaseIIGeoSetup:
499 return result
500 trk_cols = GetCombinedTrkContainers(flags)[0]
501
502 from MuonConfig.MuonTruthAlgsConfig import MuonTruthAssociationAlgCfg
503 result.merge(MuonTruthAssociationAlgCfg(flags))
504
505 if flags.Tracking.doLargeD0:
506 result.merge(MuonTruthAssociationAlgCfg(flags, name="MuonTruthAssociationAlgLRT",
507 MuonContainerName="MuonsLRT",
508 RecoLinkName="recoMuonLinkLRT",
509 TrackContainers=trk_cols))
510
511 if flags.MuonCombined.doMuGirl and flags.MuonCombined.doMuGirlLowBeta:
512 result.merge(MuonTruthAssociationAlgCfg(flags, name="MuonTruthAssociationAlgStau",
513 MuonContainerName="Staus",
514 RecoLinkName="",
515 TrackContainers=trk_cols))
516
517 return result
518

◆ GetCombinedTrkContainers()

GetCombinedTrkContainers ( flags)

Definition at line 394 of file MuonCombinedReconstructionConfig.py.

394def GetCombinedTrkContainers(flags):
395 tp_coll = []
396 track_coll = []
397 tp_coll = ["ExtrapolatedMuonTrackParticles",
398 "CombinedMuonTrackParticles",
399 "MSOnlyExtrapolatedMuonTrackParticles"]
400 track_coll = ["ExtrapolatedMuonTracks",
401 "CombinedMuonTracks",
402 "MSOnlyExtrapolatedTracks"]
403 if flags.MuonCombined.doMuGirl and flags.MuonCombined.doMuGirlLowBeta:
404 tp_coll += ["CombinedStauTrackParticles",
405 "ExtrapolatedStauTrackParticles"]
406 track_coll += ["CombinedStauTracks",
407 "ExtrapolatedStauTracks"]
408 if flags.Tracking.doLargeD0:
409 tp_coll += ["CombinedMuonsLRTTrackParticles",
410 "ExtraPolatedMuonsLRTTrackParticles",
411 "MSOnlyExtraPolatedMuonsLRTTrackParticles"]
412 track_coll += ["CombinedMuonsLRTTracks",
413 "ExtraPolatedMuonsLRTTracks",
414 "MSOnlyExtraPolatedMuonsLRTTrackParticlesTracks"]
415 return tp_coll, track_coll
416
417

◆ LRT_MuGirlAlgCfg()

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

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

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

Definition at line 252 of file MuonCombinedReconstructionConfig.py.

252def LRT_MuonCombinedAlgCfg(flags, name="MuonCombinedAlg_LRT", **kwargs):
253 kwargs.setdefault("InDetCandidateLocation", "TrackParticleCandidateLRT")
254 kwargs.setdefault("CombinedTagMaps", [
255 "muidcoTagMap_LRT", "stacoTagMap_LRT"])
256 kwargs.setdefault("MuidCombinedTracksLocation", "MuidCombinedTracks_LRT")
257 kwargs.setdefault("MuidMETracksLocation", "MuidMETracks_LRT")
258 return MuonCombinedAlgCfg(flags, name, **kwargs)
259
260

◆ LRT_MuonCombinedInDetCandidateAlgCfg()

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 kwargs.setdefault("WaitForTrackLink", not flags.Muon.MuonTrigger)
213
214 kwargs.setdefault("InDetForwardTrackSelector", result.popToolsAndMerge(
215 MuonCombinedInDetDetailedForwardTrackSelectorToolCfg(flags)))
216
217 if flags.Reco.EnableCaloExtension and not flags.Muon.MuonTrigger:
218 kwargs.setdefault("CaloExtensionLocation", [
219 "ParticleCaloExtension_LRT"])
220 cand_alg = MuonCombinedInDetCandidateAlgCfg(flags, name, **kwargs)
221 result.merge(cand_alg)
222 return result
223
224

◆ LRT_MuonCreatorAlgCfg()

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

Definition at line 297 of file MuonCombinedReconstructionConfig.py.

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

◆ LRT_MuonInDetToMuonSystemExtensionAlgCfg()

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

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

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

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

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

Definition at line 225 of file MuonCombinedReconstructionConfig.py.

225def MuonCombinedAlgCfg(flags, name="MuonCombinedAlg", **kwargs):
226 result = ComponentAccumulator()
227 tools = []
228 tagmaps = []
229 from MuonConfig.MuonRecToolsConfig import MuonEDMPrinterToolCfg
230 kwargs.setdefault("Printer", result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags)))
231 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonCombinedFitTagToolCfg, MuonCombinedStacoTagToolCfg
232
233 if flags.MuonCombined.doCombinedFit:
234 tools.append(result.popToolsAndMerge(MuonCombinedFitTagToolCfg(flags)))
235 tagmaps+=['muidcoTagMap']
236 if flags.MuonCombined.doStatisticalCombination and flags.Beam.Type is not BeamType.Cosmics:
237 tools.append(result.popToolsAndMerge(MuonCombinedStacoTagToolCfg(flags)))
238 tagmaps+=['stacoTagMap']
239
240 kwargs.setdefault("MuonCombinedTagTools", tools)
241 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonAlignmentUncertToolThetaCfg
242 kwargs.setdefault("AlignmentUncertTool", result.getPrimaryAndMerge(MuonAlignmentUncertToolThetaCfg(flags)))
243
244 kwargs.setdefault("DeltaEtaPreSelection", 0.2)
245 kwargs.setdefault("DeltaPhiPreSelection", 0.2)
246
247 kwargs.setdefault("CombinedTagMaps", tagmaps)
248 alg = CompFactory.MuonCombinedAlg(name, **kwargs)
249 result.addEventAlgo(alg, primary=True)
250 return result
251

◆ MuonCombinedInDetCandidateAlgCfg()

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 = ComponentAccumulator()
149 kwargs.setdefault("TrackSelector", result.popToolsAndMerge(MuonCombinedInDetDetailedTrackSelectorToolCfg(flags)))
150 kwargs.setdefault("WaitForTrackLink", not flags.Muon.MuonTrigger)
151
152 if flags.MuonCombined.doSiAssocForwardMuons and flags.Tracking.doForwardTracks:
153 kwargs.setdefault("DoSiliconAssocForwardMuons", True)
154 kwargs.setdefault("InDetForwardTrackSelector", result.popToolsAndMerge(
155 MuonCombinedInDetDetailedForwardTrackSelectorToolCfg(flags)))
156
157 kwargs.setdefault("MuonSystemExtensionTool", result.popToolsAndMerge(MuonSystemExtensionToolCfg(flags)))
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()

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

Definition at line 99 of file MuonCombinedReconstructionConfig.py.

99def MuonCombinedMuonCandidateAlgCfg(flags, name="MuonCombinedMuonCandidateAlg", **kwargs):
100 result = ComponentAccumulator()
101
102 from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
103 from MuonConfig.MuonRecToolsConfig import MuonAmbiProcessorCfg
104 from MuonConfig.MuonRecToolsConfig import MuonEDMPrinterToolCfg
105 from MuonCombinedConfig.MuonCombinedRecToolsConfig import CombinedMuonTrackBuilderCfg, ExtrapolateMuonToIPToolCfg
106 result.merge(CaloNoiseCondAlgCfg(flags, "totalNoise"))
107
108 kwargs.setdefault("Printer", result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags)))
109 if "TrackBuilder" not in kwargs:
110 kwargs.setdefault("TrackBuilder", result.popToolsAndMerge(
111 CombinedMuonTrackBuilderCfg(flags, name="CombinedMuonTrackBuilder")))
112 # Why was this dependent on cosmics? will now always create this
113 # if flags.Beam.Type is BeamType.Cosmics:
114 if flags.Muon.MuonTrigger and flags.Beam.Type is not BeamType.Cosmics:
115 # trigger definitely only uses the ExtrapolateToIPtool in cosmics mode
116 kwargs.setdefault("TrackExtrapolationTool", "")
117 else:
118 kwargs.setdefault("TrackExtrapolationTool", result.popToolsAndMerge(
119 ExtrapolateMuonToIPToolCfg(flags)))
120 kwargs.setdefault("SegmentContainer", "TrackMuonSegments")
121 kwargs.setdefault("AmbiguityProcessor", result.popToolsAndMerge(MuonAmbiProcessorCfg(flags)))
122
123 from TrkConfig.TrkTrackSummaryToolConfig import MuonTrackSummaryToolCfg
124 kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(MuonTrackSummaryToolCfg(flags)))
125
126 # MuonIDHelperSvc already configured
127
128 if flags.Beam.Type is BeamType.Cosmics:
129 kwargs.setdefault("ExtrapolationStrategy", 1)
130
131 track_segment_association_tool = CompFactory.MuonCombined.TrackSegmentAssociationTool(
132 MuonEDMPrinterTool=result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags)))
133
134 kwargs.setdefault("TrackSegmentAssociationTool", track_segment_association_tool)
135 result.addPublicTool(track_segment_association_tool)
136
137
138 if flags.Beam.Type is BeamType.Cosmics:
139 kwargs.setdefault("ExtrapolationStrategy", 1)
140
141 alg = CompFactory.MuonCombinedMuonCandidateAlg(name, **kwargs)
142 result.addEventAlgo(alg, primary=True)
143 return result
144

◆ MuonCombinedReconstructionCfg()

MuonCombinedReconstructionCfg ( flags)

Definition at line 632 of file MuonCombinedReconstructionConfig.py.

632def MuonCombinedReconstructionCfg(flags):
633 from MuonConfig.MuonGeometryConfig import MuonIdHelperSvcCfg
634
635 # Many components need these services, so setup once here.
636 result = MuonIdHelperSvcCfg(flags)
637
638 from CaloRec.CaloTopoClusterConfig import CaloTopoClusterCfg
639 result.merge(CaloTopoClusterCfg(flags))
640 from TrackToCalo.CaloExtensionBuilderAlgCfg import CaloExtensionBuilderCfg
641 result.merge(CaloExtensionBuilderCfg(flags))
642
643 from TrackingGeometryCondAlg.AtlasTrackingGeometryCondAlgConfig import TrackingGeometryCondAlgCfg
644 result.merge(TrackingGeometryCondAlgCfg(flags))
645 from MuonConfig.MuonRecToolsConfig import MuonEDMHelperSvcCfg
646 result.merge(MuonEDMHelperSvcCfg(flags))
647
648 # Set up to read Tracks.
649 from TrkConfig.TrackCollectionReadConfig import TrackCollectionReadCfg
650 result.merge(TrackCollectionReadCfg(flags, 'Tracks'))
651
652 # We do not need to schedule the Inner detector selector algs if none
653 # of the combined algs executed
654 if flags.MuonCombined.doMuGirl or \
655 flags.MuonCombined.doStatisticalCombination or \
656 flags.MuonCombined.doCaloTrkMuId or \
657 flags.MuonCombined.doCombinedFit or \
658 flags.MuonCombined.doMuonSegmentTagger:
659
660 result.merge(MuonCombinedInDetCandidateAlgCfg(flags))
661 if flags.Tracking.doLargeD0:
662 result.merge(LRT_MuonCombinedInDetCandidateAlgCfg(flags))
663
664 result.merge(MuonCombinedMuonCandidateAlgCfg(flags))
665
666 if flags.MuonCombined.doStatisticalCombination or flags.MuonCombined.doCombinedFit:
667 result.merge(MuonCombinedAlgCfg(flags))
668 if flags.Tracking.doLargeD0:
669 result.merge(LRT_MuonCombinedAlgCfg(flags))
670
671 # Perform system extensions on ID tracks where MuidCo did not succeed
672 if flags.MuonCombined.doCombinedFit:
673 result.merge(MuonInDetToMuonSystemExtensionAlgCfg(flags))
674 if flags.Tracking.doLargeD0:
675 result.merge(LRT_MuonInDetToMuonSystemExtensionAlgCfg(flags))
676 if flags.MuonCombined.doMuGirl:
677 # Use only ID tracks rejected by MuidCo
678 result.merge(MuonInsideOutRecoAlgCfg(flags, name="MuonInsideOutRecoAlg",
679 InDetCandidateLocation="InDetCandidates"
680 if not flags.MuonCombined.doCombinedFit else "InDetCandidatesSystemExtened"))
681 if flags.MuonCombined.doMuGirlLowBeta:
682 if flags.Tracking.doLargeD0:
683 result.merge(MuonInDetExtensionMergerAlgCfg(flags))
684 # Use the InDetCandidateStaus as InDetCandidates as they've also the extensions
685 # from the MuidCo tracks
686 result.merge(MuGirlStauAlgCfg(flags))
687 if flags.Tracking.doLargeD0:
688 result.merge(LRT_MuGirlAlgCfg(flags))
689
690 if flags.MuonCombined.doCaloTrkMuId:
691 result.merge(MuonCaloTagAlgCfg(flags))
692 if flags.Tracking.doLargeD0:
693 result.merge(LRT_MuonCaloTagAlgCfg(flags))
694
695 if flags.MuonCombined.doMuonSegmentTagger:
696 result.merge(MuonSegmentTagAlgCfg(flags))
697 if flags.Tracking.doLargeD0:
698 result.merge(LRT_MuonSegmentTagAlgCfg(flags))
699
700 result.merge(MuonSegContainerMergerAlgCfg(flags))
701 from MuonConfig.MuonSegmentFindingConfig import MuonSegmentCnvAlgCfg
702 result.merge(MuonSegmentCnvAlgCfg(flags, "MuonSegmentCnvAlg",
703 SegmentContainerName="TrkMuonSegments",
704 xAODContainerName="MuonSegments"))
705 if flags.MuonCombined.writeUnAssocSegments:
706 result.merge(MuonSegmentCnvAlgCfg(flags, "UnAssocMuonSegmentCnvAlg",
707 SegmentContainerName="UnAssocMuonTrkSegments",
708 xAODContainerName="UnAssocMuonSegments"))
709 if flags.MuonCombined.doMuGirlLowBeta:
710 result.merge(MuonSegmentCnvAlgCfg(flags, "MuonStauSegmentCnvAlg",
711 SegmentContainerName="TrkStauSegments",
712 xAODContainerName="StauSegments"))
713 # runs over outputs and create xAODMuon collection
714 result.merge(MuonCreatorAlgCfg(flags))
715 if flags.Tracking.doLargeD0:
716 result.merge(LRT_MuonCreatorAlgCfg(flags))
717
718 if flags.MuonCombined.doMuGirlLowBeta:
719 # Has to be at end if not using sequencer. If we drop this requirement, can be moved above
720 result.merge(StauCreatorAlgCfg(flags))
721
722 # FIXME
723 # I see errors related to unconfigured public tools. This is a quick fix, but should really move to where it is called.
724 from MuonConfig.MuonRecToolsConfig import MuonTrackScoringToolCfg
725 result.addPublicTool(result.popToolsAndMerge(
726 MuonTrackScoringToolCfg(flags)))
727 from TrkConfig.TrkTrackSummaryToolConfig import MuonCombinedTrackSummaryToolCfg
728 result.addPublicTool(result.popToolsAndMerge(
729 MuonCombinedTrackSummaryToolCfg(flags)))
730
731 # post processing
732 from AthenaConfiguration.Enums import Format
733 if flags.Input.isMC and flags.Input.Format != Format.BS:
734 result.merge(CombinedMuonTrackTruthAlgsCfg(flags))
735 result.merge(CombinedMuonTruthAssociationAlgsCfg(flags))
736 if not flags.Muon.usePhaseIIGeoSetup and \
737 "MuonSegments" not in flags.Input.Collections:
738 # Segment truth association decorations, but only if they are not already there (e.g. when running on ESDs)
739 from MuonConfig.MuonTruthAlgsConfig import MuonSegmentTruthAssociationAlgCfg
740 result.merge(MuonSegmentTruthAssociationAlgCfg(flags))
741
742 result.addEventAlgo(CompFactory.ClusterMatching.CaloClusterMatchLinkAlg(
743 "MuonTCLinks", ClustersToDecorate="MuonClusterCollection"))
744 result.merge(MuonDecorationAlgsCfg(flags))
745 # Setup output
746 result.merge(CombinedMuonOutputCfg(flags))
747
748 return result
749
750

◆ MuonCreatorAlgCfg()

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

Definition at line 261 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonDecorationAlgsCfg()

MuonDecorationAlgsCfg ( flags)

Definition at line 439 of file MuonCombinedReconstructionConfig.py.

439def MuonDecorationAlgsCfg(flags):
440 result = ComponentAccumulator()
441 trk_cols = ["ExtrapolatedMuonTrackParticles",
442 "CombinedMuonTrackParticles",
443 "MSOnlyExtrapolatedMuonTrackParticles"]
444 stau_coll = ["CombinedStauTrackParticles",
445 "ExtrapolatedStauTrackParticles"] if flags.MuonCombined.doMuGirl and flags.MuonCombined.doMuGirlLowBeta else []
446 track_coll_lrt = ["CombinedMuonsLRTTrackParticles",
447 "ExtraPolatedMuonsLRTTrackParticles",
448 "MSOnlyExtraPolatedMuonsLRTTrackParticles"] if flags.Tracking.doLargeD0 else []
449
450 # Decorate the muon tracks
451 for coll in trk_cols + stau_coll + track_coll_lrt:
452 result.merge(MuonTrkIDMSScatterDecorAlgCfg(flags, "MuonCombIDMSScatterDecorAlg"+coll,
453 TrackContainer=coll))
454
455 result.merge(MuonTrkAEOTDecorAlgCfg(flags, "MuonCombAEOTDecorAlg"+coll,
456 TrackContainer=coll))
457 # Proceed with the precision layer decoration
458 prec_trk_cols = ["ExtrapolatedMuonTrackParticles",
459 "CombinedMuonTrackParticles",
460 "MSOnlyExtrapolatedMuonTrackParticles"]
461 result.merge(MuonPrecisionLayerDecorAlgCfg(flags, "MuonCombPrecisionLayerDecorAlg",
462 MuonContainer="Muons" if not flags.Muon.scheduleActsReco else "MuonsLegacy",
463 TrackContainer=prec_trk_cols))
464 if flags.MuonCombined.doMuGirl and flags.MuonCombined.doMuGirlLowBeta:
465
466 result.merge(MuonPrecisionLayerDecorAlgCfg(flags, "MuonCombStauPrecisionLayerDecorAlg",
467 MuonContainer="Staus",
468 TrackContainer=stau_coll))
469 if flags.Tracking.doLargeD0:
470
471 result.merge(MuonPrecisionLayerDecorAlgCfg(flags, "MuonCombLRTPrecisionLayerDecorAlg",
472 MuonContainer="MuonsLRT",
473 TrackContainer=track_coll_lrt))
474
475 return result
476
477

◆ MuonInDetExtensionMergerAlgCfg()

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

Definition at line 381 of file MuonCombinedReconstructionConfig.py.

381def MuonInDetExtensionMergerAlgCfg(flags, name="MuonInDetExtensionMergerAlg", **kwargs):
382 result = ComponentAccumulator()
383 kwargs.setdefault(
384 "ToMerge", ["InDetCandidatesStausPrompt", "InDetCandidatesStausLRT"])
385 kwargs.setdefault("ToWrite", "InDetCandidatesStaus")
386 the_alg = CompFactory.MuonInDetExtensionMergerAlg(name, **kwargs)
387 result.addEventAlgo(the_alg, primary=True)
388 return result
389
390# Returns a pair vectors containing th names of the
391# track particle collections associated with combined muon tracks
392
393

◆ MuonInDetToMuonSystemExtensionAlgCfg()

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

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

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

Definition at line 432 of file MuonCombinedReconstructionConfig.py.

432def MuonPrecisionLayerDecorAlgCfg(flags, name="MuonPrecisionLayerDecorAlg", **kwargs):
433 result = ComponentAccumulator()
434 the_alg = CompFactory.MuonPrecisionLayerDecorAlg(name=name, **kwargs)
435 result.addEventAlgo(the_alg)
436 return result
437
438

◆ MuonSegContainerMergerAlgCfg()

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

Definition at line 347 of file MuonCombinedReconstructionConfig.py.

347def MuonSegContainerMergerAlgCfg(flags, name="MuonSegContainerMergerAlg", **kwargs):
348 result = ComponentAccumulator()
349 kwargs.setdefault("saveUnusedSegments",
350 flags.MuonCombined.writeUnAssocSegments)
351 tag_maps = []
352 if flags.MuonCombined.doMuGirl:
353 tag_maps += ["muGirlTagMap"]
354 if flags.MuonCombined.doStatisticalCombination:
355 tag_maps += ["stacoTagMap"]
356 if flags.MuonCombined.doCombinedFit:
357 tag_maps += ["muidcoTagMap"]
358 if flags.MuonCombined.doMuonSegmentTagger:
359 tag_maps += ["segmentTagMap"]
360 muon_maps = ["MuonCandidates"]
361 if flags.Tracking.doLargeD0:
362 if flags.MuonCombined.doMuGirl:
363 tag_maps += ["MuGirlMap_LRT"]
364 if flags.MuonCombined.doStatisticalCombination:
365 tag_maps += ["stacoTagMap_LRT"]
366 if flags.MuonCombined.doCombinedFit:
367 tag_maps += ["muidcoTagMap_LRT"]
368 if flags.MuonCombined.doMuonSegmentTagger:
369 tag_maps += ["segmentTagMap_LRT"]
370 kwargs.setdefault("MuonCandidateMaps", muon_maps)
371 kwargs.setdefault("TagMaps", tag_maps)
372 from MuonConfig.MuonRecToolsConfig import MuonAmbiProcessorCfg
373 kwargs.setdefault("AmbiguityProcessor", result.popToolsAndMerge(
374 MuonAmbiProcessorCfg(flags)))
375
376 the_alg = CompFactory.MuonSegContainerMergerAlg(name, **kwargs)
377 result.addEventAlgo(the_alg)
378 return result
379
380

◆ MuonSegmentTagAlgCfg()

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

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

Definition at line 425 of file MuonCombinedReconstructionConfig.py.

425def MuonTrkAEOTDecorAlgCfg(flags, name="MuonCombAEOTDecorAlg", **kwargs):
426 result = ComponentAccumulator()
427 the_alg = CompFactory.MuonTrkAEOTDecorationAlg(name=name, **kwargs)
428 result.addEventAlgo(the_alg)
429 return result
430
431

◆ MuonTrkIDMSScatterDecorAlgCfg()

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

Definition at line 418 of file MuonCombinedReconstructionConfig.py.

418def MuonTrkIDMSScatterDecorAlgCfg(flags, name="MuonCombIDMSScatterDecorAlg", **kwargs):
419 result = ComponentAccumulator()
420 the_alg = CompFactory.MuonTrkIDMSScatterDecorAlg(name=name, **kwargs)
421 result.addEventAlgo(the_alg)
422 return result
423
424

◆ StauCreatorAlgCfg()

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

Definition at line 327 of file MuonCombinedReconstructionConfig.py.

327def StauCreatorAlgCfg(flags, name="StauCreatorAlg", **kwargs):
328 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonCreatorToolCfg
329 result = MuonCreatorToolCfg(
330 flags, BuildStauContainer=True, name='StauCreatorTool')
331 kwargs.setdefault("MuonCreatorTool", result.popPrivateTools())
332 kwargs.setdefault("MuonContainerLocation", "Staus")
333 kwargs.setdefault("CombinedLocation", "CombinedStau")
334 kwargs.setdefault("ExtrapolatedLocation", "ExtrapolatedStau")
335 kwargs.setdefault("MSOnlyExtrapolatedLocation", "MSOnlyExtrapolatedStau")
336 kwargs.setdefault("MuonCandidateLocation", [])
337 kwargs.setdefault("SegmentContainerName", "StauSegments")
338 kwargs.setdefault("TagToSegmentKey", "")
339 kwargs.setdefault("BuildSlowMuon", 1)
340 kwargs.setdefault("ClusterContainerName", "SlowMuonClusterCollection")
341 kwargs.setdefault("TagMaps", ["stauTagMap"])
342 acc = MuonCreatorAlgCfg(flags, name, **kwargs)
343 result.merge(acc)
344 return result # don't have the right algorithm being primary here, but should be okay?
345
346

Variable Documentation

◆ cfg

MuonCombinedReconstructionConfig.cfg = SetupMuonStandaloneCA(flags)

Definition at line 772 of file MuonCombinedReconstructionConfig.py.

◆ doMuGirlLowBeta

MuonCombinedReconstructionConfig.doMuGirlLowBeta

Definition at line 764 of file MuonCombinedReconstructionConfig.py.

◆ Files

MuonCombinedReconstructionConfig.Files

Definition at line 758 of file MuonCombinedReconstructionConfig.py.

◆ flags

MuonCombinedReconstructionConfig.flags = initConfigFlags()

Definition at line 757 of file MuonCombinedReconstructionConfig.py.

◆ rename_maps

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

Definition at line 800 of file MuonCombinedReconstructionConfig.py.

◆ UseOnlyHitSectors

MuonCombinedReconstructionConfig.UseOnlyHitSectors

Definition at line 782 of file MuonCombinedReconstructionConfig.py.

Generated on for ATLAS Offline Software by doxygen 1.17.0