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

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

◆ 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.usePhaseIIGeoSetup:
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

◆ CombinedMuonTruthAssociationAlgsCfg()

CombinedMuonTruthAssociationAlgsCfg ( flags)

Definition at line 493 of file MuonCombinedReconstructionConfig.py.

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

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

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

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

◆ doMuGirlLowBeta

MuonCombinedReconstructionConfig.doMuGirlLowBeta

Definition at line 756 of file MuonCombinedReconstructionConfig.py.

◆ Files

MuonCombinedReconstructionConfig.Files

Definition at line 750 of file MuonCombinedReconstructionConfig.py.

◆ flags

MuonCombinedReconstructionConfig.flags = initConfigFlags()

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

◆ UseOnlyHitSectors

MuonCombinedReconstructionConfig.UseOnlyHitSectors

Definition at line 774 of file MuonCombinedReconstructionConfig.py.

Generated on for ATLAS Offline Software by doxygen 1.17.0