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

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

◆ CombinedMuonTrackTruthAlgsCfg()

CombinedMuonTrackTruthAlgsCfg ( flags)

Definition at line 475 of file MuonCombinedReconstructionConfig.py.

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

◆ CombinedMuonTruthAssociationAlgsCfg()

CombinedMuonTruthAssociationAlgsCfg ( flags)

Definition at line 493 of file MuonCombinedReconstructionConfig.py.

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

◆ GetCombinedTrkContainers()

GetCombinedTrkContainers ( flags)

Definition at line 391 of file MuonCombinedReconstructionConfig.py.

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

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

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

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

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

◆ 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 alg = CompFactory.MuonCreatorAlg(name, **kwargs)
290 result.addEventAlgo(alg, primary=True)
291 return result
292
293

◆ MuonDecorationAlgsCfg()

MuonDecorationAlgsCfg ( flags)

Definition at line 436 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonInDetExtensionMergerAlgCfg()

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

Definition at line 378 of file MuonCombinedReconstructionConfig.py.

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

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

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

◆ MuonSegContainerMergerAlgCfg()

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

Definition at line 344 of file MuonCombinedReconstructionConfig.py.

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

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

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

◆ MuonTrkIDMSScatterDecorAlgCfg()

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

Definition at line 415 of file MuonCombinedReconstructionConfig.py.

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

◆ StauCreatorAlgCfg()

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

Definition at line 324 of file MuonCombinedReconstructionConfig.py.

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

Variable Documentation

◆ cfg

MuonCombinedReconstructionConfig.cfg = SetupMuonStandaloneCA(flags)

Definition at line 762 of file MuonCombinedReconstructionConfig.py.

◆ doMuGirlLowBeta

MuonCombinedReconstructionConfig.doMuGirlLowBeta

Definition at line 754 of file MuonCombinedReconstructionConfig.py.

◆ Files

MuonCombinedReconstructionConfig.Files

Definition at line 748 of file MuonCombinedReconstructionConfig.py.

◆ flags

MuonCombinedReconstructionConfig.flags = initConfigFlags()

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

◆ UseOnlyHitSectors

MuonCombinedReconstructionConfig.UseOnlyHitSectors

Definition at line 772 of file MuonCombinedReconstructionConfig.py.

Generated on for ATLAS Offline Software by doxygen 1.17.0