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

MuonCombinedReconstructionConfig.CombinedMuonOutputCfg ( flags)

Definition at line 489 of file MuonCombinedReconstructionConfig.py.

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

◆ CombinedMuonTrackTruthAlgsCfg()

MuonCombinedReconstructionConfig.CombinedMuonTrackTruthAlgsCfg ( flags)

Definition at line 450 of file MuonCombinedReconstructionConfig.py.

450def CombinedMuonTrackTruthAlgsCfg(flags):
451 result = ComponentAccumulator()
452 particle_cols, trk_cols = GetCombinedTrkContainers(flags)
453
454 from MuonConfig.MuonTruthAlgsConfig import MuonDetailedTrackTruthMakerCfg
455 result.merge(MuonDetailedTrackTruthMakerCfg(flags, name="MuonCombinedDetailedTrackTruthMaker",
456 TrackCollectionNames=trk_cols))
457
458 if(not flags.Muon.scheduleActsReco):
459 for i in range(len(trk_cols)):
460 from TrkConfig.TrkTruthAlgsConfig import TrackTruthSelectorCfg, TrackParticleTruthAlgCfg
461 result.merge(TrackTruthSelectorCfg(flags, tracks=trk_cols[i]))
462 result.merge(TrackParticleTruthAlgCfg(flags, tracks=trk_cols[i],
463 TrackParticleName=particle_cols[i]))
464
465 return result
466
467
if
if(pathvar)
Definition SealSharedLib.cxx:168

◆ CombinedMuonTruthAssociationAlgsCfg()

MuonCombinedReconstructionConfig.CombinedMuonTruthAssociationAlgsCfg ( flags)

Definition at line 468 of file MuonCombinedReconstructionConfig.py.

468def CombinedMuonTruthAssociationAlgsCfg(flags):
469 result = ComponentAccumulator()
470 trk_cols = GetCombinedTrkContainers(flags)[0]
471
472 from MuonConfig.MuonTruthAlgsConfig import MuonTruthAssociationAlgCfg
473 result.merge(MuonTruthAssociationAlgCfg(flags))
474
475 if flags.Tracking.doLargeD0:
476 result.merge(MuonTruthAssociationAlgCfg(flags, name="MuonTruthAssociationAlgLRT",
477 MuonContainerName="MuonsLRT",
478 RecoLinkName="recoMuonLinkLRT",
479 TrackContainers=trk_cols))
480
481 if flags.MuonCombined.doMuGirl and flags.MuonCombined.doMuGirlLowBeta:
482 result.merge(MuonTruthAssociationAlgCfg(flags, name="MuonTruthAssociationAlgStau",
483 MuonContainerName="Staus",
484 RecoLinkName="",
485 TrackContainers=trk_cols))
486
487 return result
488

◆ GetCombinedTrkContainers()

MuonCombinedReconstructionConfig.GetCombinedTrkContainers ( flags)

Definition at line 366 of file MuonCombinedReconstructionConfig.py.

366def GetCombinedTrkContainers(flags):
367 tp_coll = []
368 track_coll = []
369 tp_coll = ["ExtrapolatedMuonTrackParticles",
370 "CombinedMuonTrackParticles",
371 "MSOnlyExtrapolatedMuonTrackParticles"]
372 track_coll = ["ExtrapolatedMuonTracks",
373 "CombinedMuonTracks",
374 "MSOnlyExtrapolatedTracks"]
375 if flags.MuonCombined.doMuGirl and flags.MuonCombined.doMuGirlLowBeta:
376 tp_coll += ["CombinedStauTrackParticles",
377 "ExtrapolatedStauTrackParticles"]
378 track_coll += ["CombinedStauTracks",
379 "ExtrapolatedStauTracks"]
380 if flags.Tracking.doLargeD0:
381 tp_coll += ["CombinedMuonsLRTTrackParticles",
382 "ExtraPolatedMuonsLRTTrackParticles",
383 "MSOnlyExtraPolatedMuonsLRTTrackParticles"]
384 track_coll += ["CombinedMuonsLRTTracks",
385 "ExtraPolatedMuonsLRTTracks",
386 "MSOnlyExtraPolatedMuonsLRTTrackParticlesTracks"]
387 return tp_coll, track_coll
388
389

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

227def LRT_MuonCombinedAlgCfg(flags, name="MuonCombinedAlg_LRT", **kwargs):
228 kwargs.setdefault("InDetCandidateLocation", "TrackParticleCandidateLRT")
229 kwargs.setdefault("CombinedTagMaps", [
230 "muidcoTagMap_LRT", "stacoTagMap_LRT"])
231 kwargs.setdefault("MuidCombinedTracksLocation", "MuidCombinedTracks_LRT")
232 kwargs.setdefault("MuidMETracksLocation", "MuidMETracks_LRT")
233 return MuonCombinedAlgCfg(flags, name, **kwargs)
234
235

◆ LRT_MuonCombinedInDetCandidateAlgCfg()

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

Definition at line 175 of file MuonCombinedReconstructionConfig.py.

175def LRT_MuonCombinedInDetCandidateAlgCfg(flags, name="MuonCombinedInDetCandidateAlg_LRT", **kwargs):
176 from InDetConfig.InDetTrackSelectorToolConfig import MuonCombinedInDetDetailedForwardTrackSelectorToolCfg, MuonCombinedInDetDetailedTrackSelectorTool_LRTCfg
177 result = ComponentAccumulator()
178
179 kwargs.setdefault("TrackSelector", result.popToolsAndMerge(
180 MuonCombinedInDetDetailedTrackSelectorTool_LRTCfg(flags)))
181
182 # Use the Standard Track particle container in cases where no separate containters will be
183 # saved for the LRT tracking
184 kwargs.setdefault("TrackParticleLocation", ["InDetLargeD0TrackParticles"])
185 kwargs.setdefault("InDetCandidateLocation", "TrackParticleCandidateLRT")
186 kwargs.setdefault("DoSiliconAssocForwardMuons", False)
187 kwargs.setdefault("WaitForTrackLink", not flags.Muon.MuonTrigger)
188
189 kwargs.setdefault("InDetForwardTrackSelector", result.popToolsAndMerge(
190 MuonCombinedInDetDetailedForwardTrackSelectorToolCfg(flags)))
191
192 if flags.Reco.EnableCaloExtension and not flags.Muon.MuonTrigger:
193 kwargs.setdefault("CaloExtensionLocation", [
194 "ParticleCaloExtension_LRT"])
195 cand_alg = MuonCombinedInDetCandidateAlgCfg(flags, name, **kwargs)
196 result.merge(cand_alg)
197 return result
198
199

◆ LRT_MuonCreatorAlgCfg()

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

Definition at line 269 of file MuonCombinedReconstructionConfig.py.

269def LRT_MuonCreatorAlgCfg(flags, name="MuonCreatorAlg_LRT", **kwargs):
270 result = ComponentAccumulator()
271 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonCreatorToolCfg
272 creatorTool = result.popToolsAndMerge(
273 MuonCreatorToolCfg(flags, "MuonCreatorTool_LRT", RequireIDTrack=True))
274 kwargs.setdefault("MuonCreatorTool", creatorTool)
275 # In cases we want to switch them off we should add the flags here
276 tag_maps = []
277 if flags.MuonCombined.doMuGirl:
278 tag_maps += ["MuGirlMap_LRT"]
279 if flags.MuonCombined.doStatisticalCombination:
280 tag_maps += ["stacoTagMap_LRT"]
281 if flags.MuonCombined.doCombinedFit:
282 tag_maps += ["muidcoTagMap_LRT"]
283 if flags.MuonCombined.doCaloTrkMuId:
284 tag_maps += ["caloTagMap_LRT"]
285 if flags.MuonCombined.doMuonSegmentTagger:
286 tag_maps += ["segmentTagMap_LRT"]
287 kwargs.setdefault("TagMaps", tag_maps)
288 kwargs.setdefault("MuonContainerLocation", "MuonsLRT")
289 kwargs.setdefault("ExtrapolatedLocation", "ExtraPolatedMuonsLRT")
290 kwargs.setdefault("MSOnlyExtrapolatedLocation",
291 "MSOnlyExtraPolatedMuonsLRT")
292 kwargs.setdefault("CombinedLocation", "CombinedMuonsLRT")
293 kwargs.setdefault("BuildSlowMuon", False)
294 kwargs.setdefault("MakeClusters", False)
295 kwargs.setdefault("ClusterContainerName", "")
296 result.merge(MuonCreatorAlgCfg(flags, name=name, **kwargs))
297 return result
298

◆ LRT_MuonInDetToMuonSystemExtensionAlgCfg()

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

Definition at line 166 of file MuonCombinedReconstructionConfig.py.

166def LRT_MuonInDetToMuonSystemExtensionAlgCfg(flags, name="MuonInDetToMuonSystemExtensionAlg_LRT", **kwargs):
167 kwargs.setdefault("WriteStauCandidates", "InDetCandidatesStausLRT")
168 kwargs.setdefault("WriteInDetCandidates",
169 "InDetCandidateLRT_SystemExtended")
170 kwargs.setdefault("InputInDetCandidates", "TrackParticleCandidateLRT")
171 kwargs.setdefault("CombinedTagMap", "muidcoTagMap_LRT")
172 return MuonInDetToMuonSystemExtensionAlgCfg(flags, name, **kwargs)
173
174

◆ LRT_MuonSegmentTagAlgCfg()

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

Definition at line 40 of file MuonCombinedReconstructionConfig.py.

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

◆ MuGirlStauAlgCfg()

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

Definition at line 79 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonCaloTagAlgCfg()

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

Definition at line 8 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonCombinedAlgCfg()

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

Definition at line 200 of file MuonCombinedReconstructionConfig.py.

200def MuonCombinedAlgCfg(flags, name="MuonCombinedAlg", **kwargs):
201 result = ComponentAccumulator()
202 tools = []
203 tagmaps = []
204 from MuonConfig.MuonRecToolsConfig import MuonEDMPrinterToolCfg
205 kwargs.setdefault("Printer", result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags)))
206 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonCombinedFitTagToolCfg, MuonCombinedStacoTagToolCfg
207
208 if flags.MuonCombined.doCombinedFit:
209 tools.append(result.popToolsAndMerge(MuonCombinedFitTagToolCfg(flags)))
210 tagmaps+=['muidcoTagMap']
211 if flags.MuonCombined.doStatisticalCombination and flags.Beam.Type is not BeamType.Cosmics:
212 tools.append(result.popToolsAndMerge(MuonCombinedStacoTagToolCfg(flags)))
213 tagmaps+=['stacoTagMap']
214
215 kwargs.setdefault("MuonCombinedTagTools", tools)
216 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonAlignmentUncertToolThetaCfg
217 kwargs.setdefault("AlignmentUncertTool", result.getPrimaryAndMerge(MuonAlignmentUncertToolThetaCfg(flags)))
218
219 kwargs.setdefault("DeltaEtaPreSelection", 0.2)
220 kwargs.setdefault("DeltaPhiPreSelection", 0.2)
221
222 kwargs.setdefault("CombinedTagMaps", tagmaps)
223 alg = CompFactory.MuonCombinedAlg(name, **kwargs)
224 result.addEventAlgo(alg, primary=True)
225 return result
226

◆ MuonCombinedInDetCandidateAlgCfg()

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

Definition at line 120 of file MuonCombinedReconstructionConfig.py.

120def MuonCombinedInDetCandidateAlgCfg(flags, name="MuonCombinedInDetCandidateAlg", **kwargs):
121 from InDetConfig.InDetTrackSelectorToolConfig import MuonCombinedInDetDetailedTrackSelectorToolCfg, MuonCombinedInDetDetailedForwardTrackSelectorToolCfg
122 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonSystemExtensionToolCfg
123 result = ComponentAccumulator()
124 kwargs.setdefault("TrackSelector", result.popToolsAndMerge(MuonCombinedInDetDetailedTrackSelectorToolCfg(flags)))
125 kwargs.setdefault("WaitForTrackLink", not flags.Muon.MuonTrigger)
126
127 if flags.MuonCombined.doSiAssocForwardMuons and flags.Tracking.doForwardTracks:
128 kwargs.setdefault("DoSiliconAssocForwardMuons", True)
129 kwargs.setdefault("InDetForwardTrackSelector", result.popToolsAndMerge(
130 MuonCombinedInDetDetailedForwardTrackSelectorToolCfg(flags)))
131
132 kwargs.setdefault("MuonSystemExtensionTool", result.popToolsAndMerge(MuonSystemExtensionToolCfg(flags)))
133
134 # Switch off the muon system extensions if we fit combined muons
135 # The MuonInDetToSystemExtensionAlg will perform the system extensions then
136 kwargs.setdefault("ExtendBulk", not flags.MuonCombined.doCombinedFit)
137
138 if flags.Reco.EnableCaloExtension and not flags.Muon.MuonTrigger:
139 kwargs.setdefault("CaloExtensionLocation", ["ParticleCaloExtension"])
140
141 alg = CompFactory.MuonCombinedInDetCandidateAlg(name, **kwargs)
142 result.addEventAlgo(alg, primary=True)
143 return result
144
145

◆ MuonCombinedMuonCandidateAlgCfg()

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

Definition at line 99 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonCombinedReconstructionCfg()

MuonCombinedReconstructionConfig.MuonCombinedReconstructionCfg ( flags)

Definition at line 597 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonCreatorAlgCfg()

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

Definition at line 236 of file MuonCombinedReconstructionConfig.py.

236def MuonCreatorAlgCfg(flags, name="MuonCreatorAlg", **kwargs):
237 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonCreatorToolCfg
238 result = MuonCreatorToolCfg(flags, name="MuonCreatorTool")
239 kwargs.setdefault("MuonCreatorTool", result.popPrivateTools())
240
241 # if muGirl is off, remove "muGirlTagMap" from "TagMaps"
242 # but don't set this default in case the StauCreatorAlg is created (see below)
243 tag_maps = []
244 if flags.MuonCombined.doMuGirl:
245 tag_maps += ["muGirlTagMap"]
246 if flags.MuonCombined.doStatisticalCombination:
247 tag_maps += ["stacoTagMap"]
248 if flags.MuonCombined.doCombinedFit:
249 tag_maps += ["muidcoTagMap"]
250 if flags.MuonCombined.doCaloTrkMuId:
251 tag_maps += ["caloTagMap"]
252 if flags.MuonCombined.doMuonSegmentTagger:
253 tag_maps += ["segmentTagMap"]
254 kwargs.setdefault("TagMaps", tag_maps)
255 if flags.Muon.MuonTrigger:
256 kwargs.setdefault("MakeClusters", False)
257 kwargs.setdefault("ClusterContainerName", "")
258 kwargs.setdefault("SegmentContainerName", "")
259 kwargs.setdefault("TagToSegmentKey", "")
260 if flags.Muon.SAMuonTrigger:
261 kwargs.setdefault("CreateSAmuons", True)
262 kwargs.setdefault("TagMaps", [])
263
264 alg = CompFactory.MuonCreatorAlg(name, **kwargs)
265 result.addEventAlgo(alg, primary=True)
266 return result
267
268

◆ MuonDecorationAlgsCfg()

MuonCombinedReconstructionConfig.MuonDecorationAlgsCfg ( flags)

Definition at line 411 of file MuonCombinedReconstructionConfig.py.

411def MuonDecorationAlgsCfg(flags):
412 result = ComponentAccumulator()
413 trk_cols = ["ExtrapolatedMuonTrackParticles",
414 "CombinedMuonTrackParticles",
415 "MSOnlyExtrapolatedMuonTrackParticles"]
416 stau_coll = ["CombinedStauTrackParticles",
417 "ExtrapolatedStauTrackParticles"] if flags.MuonCombined.doMuGirl and flags.MuonCombined.doMuGirlLowBeta else []
418 track_coll_lrt = ["CombinedMuonsLRTTrackParticles",
419 "ExtraPolatedMuonsLRTTrackParticles",
420 "MSOnlyExtraPolatedMuonsLRTTrackParticles"] if flags.Tracking.doLargeD0 else []
421
422 # Decorate the muon tracks
423 for coll in trk_cols + stau_coll + track_coll_lrt:
424 result.merge(MuonTrkIDMSScatterDecorAlgCfg(flags, "MuonCombIDMSScatterDecorAlg"+coll,
425 TrackContainer=coll))
426
427 result.merge(MuonTrkAEOTDecorAlgCfg(flags, "MuonCombAEOTDecorAlg"+coll,
428 TrackContainer=coll))
429 # Proceed with the precision layer decoration
430 prec_trk_cols = ["ExtrapolatedMuonTrackParticles",
431 "CombinedMuonTrackParticles",
432 "MSOnlyExtrapolatedMuonTrackParticles"]
433 result.merge(MuonPrecisionLayerDecorAlgCfg(flags, "MuonCombPrecisionLayerDecorAlg",
434 MuonContainer="Muons",
435 TrackContainer=prec_trk_cols))
436 if flags.MuonCombined.doMuGirl and flags.MuonCombined.doMuGirlLowBeta:
437
438 result.merge(MuonPrecisionLayerDecorAlgCfg(flags, "MuonCombStauPrecisionLayerDecorAlg",
439 MuonContainer="Staus",
440 TrackContainer=stau_coll))
441 if flags.Tracking.doLargeD0:
442
443 result.merge(MuonPrecisionLayerDecorAlgCfg(flags, "MuonCombLRTPrecisionLayerDecorAlg",
444 MuonContainer="MuonsLRT",
445 TrackContainer=track_coll_lrt))
446
447 return result
448
449

◆ MuonInDetExtensionMergerAlgCfg()

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

Definition at line 353 of file MuonCombinedReconstructionConfig.py.

353def MuonInDetExtensionMergerAlgCfg(flags, name="MuonInDetExtensionMergerAlg", **kwargs):
354 result = ComponentAccumulator()
355 kwargs.setdefault(
356 "ToMerge", ["InDetCandidatesStausPrompt", "InDetCandidatesStausLRT"])
357 kwargs.setdefault("ToWrite", "InDetCandidatesStaus")
358 the_alg = CompFactory.MuonInDetExtensionMergerAlg(name, **kwargs)
359 result.addEventAlgo(the_alg, primary=True)
360 return result
361
362# Returns a pair vectors containing th names of the
363# track particle collections associated with combined muon tracks
364
365

◆ MuonInDetToMuonSystemExtensionAlgCfg()

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

Definition at line 146 of file MuonCombinedReconstructionConfig.py.

146def MuonInDetToMuonSystemExtensionAlgCfg(flags, name="MuonInDetToMuonSystemExtensionAlg", **kwargs):
147 result = ComponentAccumulator()
148 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonSystemExtensionToolCfg
149 muon_ext_tool = result.popToolsAndMerge(
150 MuonSystemExtensionToolCfg(flags))
151 kwargs.setdefault("MuonSystemExtensionTool", muon_ext_tool)
152 kwargs.setdefault("noNSWforSeeding", True)
153 kwargs.setdefault("WriteStauCandidates", "InDetCandidatesStausPrompt"
154 if flags.Tracking.doLargeD0 else "InDetCandidatesStaus")
155
156 if not flags.Muon.MuonTrigger:
157 from MuonConfig.MuonSegmentFindingConfig import MuonLayerHoughAlgCfg
158 result.merge(MuonLayerHoughAlgCfg(flags))
159 kwargs.setdefault("UseOnlyHitSectors",
160 not flags.Muon.MuonTrigger and flags.Beam.Type is BeamType.Collisions)
161 alg = CompFactory.MuonInDetToMuonSystemExtensionAlg(name, **kwargs)
162 result.addEventAlgo(alg, primary=True)
163 return result
164
165

◆ MuonInsideOutRecoAlgCfg()

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

Definition at line 47 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonPrecisionLayerDecorAlgCfg()

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

Definition at line 404 of file MuonCombinedReconstructionConfig.py.

404def MuonPrecisionLayerDecorAlgCfg(flags, name="MuonPrecisionLayerDecorAlg", **kwargs):
405 result = ComponentAccumulator()
406 the_alg = CompFactory.MuonPrecisionLayerDecorAlg(name=name, **kwargs)
407 result.addEventAlgo(the_alg)
408 return result
409
410

◆ MuonSegContainerMergerAlgCfg()

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

Definition at line 319 of file MuonCombinedReconstructionConfig.py.

319def MuonSegContainerMergerAlgCfg(flags, name="MuonSegContainerMergerAlg", **kwargs):
320 result = ComponentAccumulator()
321 kwargs.setdefault("saveUnusedSegments",
322 flags.MuonCombined.writeUnAssocSegments)
323 tag_maps = []
324 if flags.MuonCombined.doMuGirl:
325 tag_maps += ["muGirlTagMap"]
326 if flags.MuonCombined.doStatisticalCombination:
327 tag_maps += ["stacoTagMap"]
328 if flags.MuonCombined.doCombinedFit:
329 tag_maps += ["muidcoTagMap"]
330 if flags.MuonCombined.doMuonSegmentTagger:
331 tag_maps += ["segmentTagMap"]
332 muon_maps = ["MuonCandidates"]
333 if flags.Tracking.doLargeD0:
334 if flags.MuonCombined.doMuGirl:
335 tag_maps += ["MuGirlMap_LRT"]
336 if flags.MuonCombined.doStatisticalCombination:
337 tag_maps += ["stacoTagMap_LRT"]
338 if flags.MuonCombined.doCombinedFit:
339 tag_maps += ["muidcoTagMap_LRT"]
340 if flags.MuonCombined.doMuonSegmentTagger:
341 tag_maps += ["segmentTagMap_LRT"]
342 kwargs.setdefault("MuonCandidateMaps", muon_maps)
343 kwargs.setdefault("TagMaps", tag_maps)
344 from MuonConfig.MuonRecToolsConfig import MuonAmbiProcessorCfg
345 kwargs.setdefault("AmbiguityProcessor", result.popToolsAndMerge(
346 MuonAmbiProcessorCfg(flags)))
347
348 the_alg = CompFactory.MuonSegContainerMergerAlg(name, **kwargs)
349 result.addEventAlgo(the_alg)
350 return result
351
352

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

397def MuonTrkAEOTDecorAlgCfg(flags, name="MuonCombAEOTDecorAlg", **kwargs):
398 result = ComponentAccumulator()
399 the_alg = CompFactory.MuonTrkAEOTDecorationAlg(name=name, **kwargs)
400 result.addEventAlgo(the_alg)
401 return result
402
403

◆ MuonTrkIDMSScatterDecorAlgCfg()

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

Definition at line 390 of file MuonCombinedReconstructionConfig.py.

390def MuonTrkIDMSScatterDecorAlgCfg(flags, name="MuonCombIDMSScatterDecorAlg", **kwargs):
391 result = ComponentAccumulator()
392 the_alg = CompFactory.MuonTrkIDMSScatterDecorAlg(name=name, **kwargs)
393 result.addEventAlgo(the_alg)
394 return result
395
396

◆ StauCreatorAlgCfg()

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

Definition at line 299 of file MuonCombinedReconstructionConfig.py.

299def StauCreatorAlgCfg(flags, name="StauCreatorAlg", **kwargs):
300 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonCreatorToolCfg
301 result = MuonCreatorToolCfg(
302 flags, BuildStauContainer=True, name='StauCreatorTool')
303 kwargs.setdefault("MuonCreatorTool", result.popPrivateTools())
304 kwargs.setdefault("MuonContainerLocation", "Staus")
305 kwargs.setdefault("CombinedLocation", "CombinedStau")
306 kwargs.setdefault("ExtrapolatedLocation", "ExtrapolatedStau")
307 kwargs.setdefault("MSOnlyExtrapolatedLocation", "MSOnlyExtrapolatedStau")
308 kwargs.setdefault("MuonCandidateLocation", [])
309 kwargs.setdefault("SegmentContainerName", "StauSegments")
310 kwargs.setdefault("TagToSegmentKey", "")
311 kwargs.setdefault("BuildSlowMuon", 1)
312 kwargs.setdefault("ClusterContainerName", "SlowMuonClusterCollection")
313 kwargs.setdefault("TagMaps", ["stauTagMap"])
314 acc = MuonCreatorAlgCfg(flags, name, **kwargs)
315 result.merge(acc)
316 return result # don't have the right algorithm being primary here, but should be okay?
317
318

Variable Documentation

◆ cfg

MuonCombinedReconstructionConfig.cfg = SetupMuonStandaloneCA(flags)

Definition at line 737 of file MuonCombinedReconstructionConfig.py.

◆ doMuGirlLowBeta

MuonCombinedReconstructionConfig.doMuGirlLowBeta

Definition at line 729 of file MuonCombinedReconstructionConfig.py.

◆ Files

MuonCombinedReconstructionConfig.Files

Definition at line 723 of file MuonCombinedReconstructionConfig.py.

◆ flags

MuonCombinedReconstructionConfig.flags = initConfigFlags()

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

◆ UseOnlyHitSectors

MuonCombinedReconstructionConfig.UseOnlyHitSectors

Definition at line 747 of file MuonCombinedReconstructionConfig.py.

Generated on for ATLAS Offline Software by doxygen 1.16.1