ATLAS Offline Software
Functions | Variables
python.MuonCombinedReconstructionConfig Namespace Reference

Functions

def MuonCaloTagAlgCfg (flags, name="MuonCaloTagAlg", **kwargs)
 
def LRT_MuonCaloTagAlgCfg (flags, name="MuonCaloTagAlg_LRT", **kwargs)
 
def MuonSegmentTagAlgCfg (flags, name="MuonSegmentTagAlg", **kwargs)
 
def LRT_MuonSegmentTagAlgCfg (flags, name="MuonSegmentTagAlg_LRT", **kwargs)
 
def MuonInsideOutRecoAlgCfg (flags, name="MuonInsideOutRecoAlg", **kwargs)
 
def LRT_MuGirlAlgCfg (flags, name="MuGirlAlg_LRT", **kwargs)
 
def MuGirlStauAlgCfg (flags, name="MuGirlStauAlg", **kwargs)
 
def MuonCombinedMuonCandidateAlgCfg (flags, name="MuonCombinedMuonCandidateAlg", **kwargs)
 
def EMEO_MuonCombinedMuonCandidateAlgCfg (flags, name="MuonCombinedMuonCandidateAlg_EMEO")
 
def MuonCombinedInDetCandidateAlgCfg (flags, name="MuonCombinedInDetCandidateAlg", **kwargs)
 
def MuonInDetToMuonSystemExtensionAlgCfg (flags, name="MuonInDetToMuonSystemExtensionAlg", **kwargs)
 
def LRT_MuonInDetToMuonSystemExtensionAlgCfg (flags, name="MuonInDetToMuonSystemExtensionAlg_LRT", **kwargs)
 
def LRT_MuonCombinedInDetCandidateAlgCfg (flags, name="MuonCombinedInDetCandidateAlg_LRT", **kwargs)
 
def MuonCombinedAlgCfg (flags, name="MuonCombinedAlg", **kwargs)
 
def EMEO_MuonCombinedAlgCfg (flags, name="MuonCombinedAlg_EMEO", **kwargs)
 
def LRT_MuonCombinedAlgCfg (flags, name="MuonCombinedAlg_LRT", **kwargs)
 
def MuonCreatorAlgCfg (flags, name="MuonCreatorAlg", **kwargs)
 
def LRT_MuonCreatorAlgCfg (flags, name="MuonCreatorAlg_LRT", **kwargs)
 
def EMEO_MuonCreatorAlgCfg (flags, name="MuonCreatorAlg_EMEO", **kwargs)
 
def StauCreatorAlgCfg (flags, name="StauCreatorAlg", **kwargs)
 
def MuonSegContainerMergerAlgCfg (flags, name="MuonSegContainerMergerAlg", **kwargs)
 
def MuonInDetExtensionMergerAlgCfg (flags, name="MuonInDetExtensionMergerAlg", **kwargs)
 
def GetCombinedTrkContainers (flags)
 
def MuonTrkIDMSScatterDecorAlgCfg (flags, name="MuonCombIDMSScatterDecorAlg", **kwargs)
 
def MuonTrkAEOTDecorAlgCfg (flags, name="MuonCombAEOTDecorAlg", **kwargs)
 
def MuonPrecisionLayerDecorAlgCfg (flags, name="MuonPrecisionLayerDecorAlg", **kwargs)
 
def MuonDecorationAlgsCfg (flags)
 
def CombinedMuonTrackTruthAlgsCfg (flags)
 
def CombinedMuonTruthAssociationAlgsCfg (flags)
 
def CombinedMuonOutputCfg (flags)
 
def MuonCombinedReconstructionCfg (flags)
 

Variables

 flags = initConfigFlags()
 
 args = flags.fillFromArgs()
 
 Files
 
 GlobalTag
 
 useTGCPriorNextBC
 
 doMuGirlLowBeta
 
 cfg = SetupMuonStandaloneCA(args, flags)
 
def acc = MuonCombinedReconstructionCfg(flags)
 
 UseOnlyHitSectors
 
list rename_maps
 
 withDetails
 
 True
 
 summariseProps
 
 sc = cfg.run(20)
 

Function Documentation

◆ CombinedMuonOutputCfg()

def python.MuonCombinedReconstructionConfig.CombinedMuonOutputCfg (   flags)

Definition at line 562 of file MuonCombinedReconstructionConfig.py.

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

◆ CombinedMuonTrackTruthAlgsCfg()

def python.MuonCombinedReconstructionConfig.CombinedMuonTrackTruthAlgsCfg (   flags)

Definition at line 518 of file MuonCombinedReconstructionConfig.py.

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

◆ CombinedMuonTruthAssociationAlgsCfg()

def python.MuonCombinedReconstructionConfig.CombinedMuonTruthAssociationAlgsCfg (   flags)

Definition at line 535 of file MuonCombinedReconstructionConfig.py.

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

◆ EMEO_MuonCombinedAlgCfg()

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

Definition at line 246 of file MuonCombinedReconstructionConfig.py.

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

◆ EMEO_MuonCombinedMuonCandidateAlgCfg()

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

Definition at line 124 of file MuonCombinedReconstructionConfig.py.

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

◆ EMEO_MuonCreatorAlgCfg()

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

Definition at line 334 of file MuonCombinedReconstructionConfig.py.

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

◆ GetCombinedTrkContainers()

def python.MuonCombinedReconstructionConfig.GetCombinedTrkContainers (   flags)

Definition at line 427 of file MuonCombinedReconstructionConfig.py.

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

◆ LRT_MuGirlAlgCfg()

def python.MuonCombinedReconstructionConfig.LRT_MuGirlAlgCfg (   flags,
  name = "MuGirlAlg_LRT",
**  kwargs 
)

Definition at line 68 of file MuonCombinedReconstructionConfig.py.

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

def python.MuonCombinedReconstructionConfig.LRT_MuonCaloTagAlgCfg (   flags,
  name = "MuonCaloTagAlg_LRT",
**  kwargs 
)

Definition at line 22 of file MuonCombinedReconstructionConfig.py.

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

def python.MuonCombinedReconstructionConfig.LRT_MuonCombinedAlgCfg (   flags,
  name = "MuonCombinedAlg_LRT",
**  kwargs 
)

Definition at line 261 of file MuonCombinedReconstructionConfig.py.

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

◆ LRT_MuonCombinedInDetCandidateAlgCfg()

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

Definition at line 203 of file MuonCombinedReconstructionConfig.py.

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

◆ LRT_MuonCreatorAlgCfg()

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

Definition at line 303 of file MuonCombinedReconstructionConfig.py.

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

◆ LRT_MuonInDetToMuonSystemExtensionAlgCfg()

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

Definition at line 194 of file MuonCombinedReconstructionConfig.py.

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

◆ LRT_MuonSegmentTagAlgCfg()

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

Definition at line 40 of file MuonCombinedReconstructionConfig.py.

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

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

Definition at line 79 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonCaloTagAlgCfg()

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

Definition at line 8 of file MuonCombinedReconstructionConfig.py.

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

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

Definition at line 227 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonCombinedInDetCandidateAlgCfg()

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

Definition at line 148 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonCombinedMuonCandidateAlgCfg()

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

Definition at line 102 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonCombinedReconstructionCfg()

def python.MuonCombinedReconstructionConfig.MuonCombinedReconstructionCfg (   flags)

Definition at line 674 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonCreatorAlgCfg()

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

Definition at line 270 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonDecorationAlgsCfg()

def python.MuonCombinedReconstructionConfig.MuonDecorationAlgsCfg (   flags)

Definition at line 479 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonInDetExtensionMergerAlgCfg()

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

Definition at line 414 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonInDetToMuonSystemExtensionAlgCfg()

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

Definition at line 174 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonInsideOutRecoAlgCfg()

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

Definition at line 47 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonPrecisionLayerDecorAlgCfg()

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

Definition at line 472 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonSegContainerMergerAlgCfg()

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

Definition at line 374 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonSegmentTagAlgCfg()

def python.MuonCombinedReconstructionConfig.MuonSegmentTagAlgCfg (   flags,
  name = "MuonSegmentTagAlg",
**  kwargs 
)

Definition at line 28 of file MuonCombinedReconstructionConfig.py.

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

def python.MuonCombinedReconstructionConfig.MuonTrkAEOTDecorAlgCfg (   flags,
  name = "MuonCombAEOTDecorAlg",
**  kwargs 
)

Definition at line 465 of file MuonCombinedReconstructionConfig.py.

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

◆ MuonTrkIDMSScatterDecorAlgCfg()

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

Definition at line 458 of file MuonCombinedReconstructionConfig.py.

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

◆ StauCreatorAlgCfg()

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

Definition at line 354 of file MuonCombinedReconstructionConfig.py.

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

Variable Documentation

◆ acc

def python.MuonCombinedReconstructionConfig.acc = MuonCombinedReconstructionCfg(flags)

Definition at line 828 of file MuonCombinedReconstructionConfig.py.

◆ args

python.MuonCombinedReconstructionConfig.args = flags.fillFromArgs()

Definition at line 804 of file MuonCombinedReconstructionConfig.py.

◆ cfg

python.MuonCombinedReconstructionConfig.cfg = SetupMuonStandaloneCA(args, flags)

Definition at line 821 of file MuonCombinedReconstructionConfig.py.

◆ doMuGirlLowBeta

python.MuonCombinedReconstructionConfig.doMuGirlLowBeta

Definition at line 816 of file MuonCombinedReconstructionConfig.py.

◆ Files

python.MuonCombinedReconstructionConfig.Files

Definition at line 808 of file MuonCombinedReconstructionConfig.py.

◆ flags

python.MuonCombinedReconstructionConfig.flags = initConfigFlags()

Definition at line 803 of file MuonCombinedReconstructionConfig.py.

◆ GlobalTag

python.MuonCombinedReconstructionConfig.GlobalTag

Definition at line 812 of file MuonCombinedReconstructionConfig.py.

◆ rename_maps

list python.MuonCombinedReconstructionConfig.rename_maps
Initial value:
1 = ['%s#%s->%s' % ("xAOD::MuonContainer", "Muons", "old_Muons"),
2  '%s#%s->%s' % ("xAOD::MuonAuxContainer",
3  "MuonsAux.", "old_MuonsAux."),
4  '%s#%s->%s' % ("xAOD::MuonContainer",
5  "Muons.rpcHitIdentifier", "old_Muons.rpcHitIdentifier"),
6  '%s#%s->%s' % ("xAOD::TruthParticleContainer",
7  "MuonTruthParticles.recoMuonLink", "MuonTruthParticles.old_recoMuonLink")
8  ]

Definition at line 850 of file MuonCombinedReconstructionConfig.py.

◆ sc

python.MuonCombinedReconstructionConfig.sc = cfg.run(20)

Definition at line 869 of file MuonCombinedReconstructionConfig.py.

◆ summariseProps

python.MuonCombinedReconstructionConfig.summariseProps

Definition at line 863 of file MuonCombinedReconstructionConfig.py.

◆ True

python.MuonCombinedReconstructionConfig.True

Definition at line 863 of file MuonCombinedReconstructionConfig.py.

◆ UseOnlyHitSectors

python.MuonCombinedReconstructionConfig.UseOnlyHitSectors

Definition at line 833 of file MuonCombinedReconstructionConfig.py.

◆ useTGCPriorNextBC

python.MuonCombinedReconstructionConfig.useTGCPriorNextBC

Definition at line 814 of file MuonCombinedReconstructionConfig.py.

◆ withDetails

python.MuonCombinedReconstructionConfig.withDetails

Definition at line 863 of file MuonCombinedReconstructionConfig.py.

python.MuonCombinedReconstructionConfig.MuonCreatorAlgCfg
def MuonCreatorAlgCfg(flags, name="MuonCreatorAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:270
python.MuonRecToolsConfig.MuonAmbiProcessorCfg
def MuonAmbiProcessorCfg(flags, name="MuonAmbiProcessor", **kwargs)
Definition: MuonRecToolsConfig.py:144
python.TrkTruthAlgsConfig.TrackTruthSelectorCfg
def TrackTruthSelectorCfg(flags, name="Selector", tracks="", **kwargs)
Definition: TrkTruthAlgsConfig.py:28
python.TrkTruthAlgsConfig.TrackParticleTruthAlgCfg
def TrackParticleTruthAlgCfg(flags, name="TruthAlg", tracks="", **kwargs)
Definition: TrkTruthAlgsConfig.py:35
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
python.InDetTrackSelectorToolConfig.MuonCombinedInDetDetailedTrackSelectorToolCfg
def MuonCombinedInDetDetailedTrackSelectorToolCfg(flags, name="MuonCombinedInDetDetailedTrackSelectorTool", **kwargs)
Definition: InDetTrackSelectorToolConfig.py:125
python.MuonRecToolsConfig.MuonTrackScoringToolCfg
def MuonTrackScoringToolCfg(flags, name="MuonTrackScoringTool", **kwargs)
Definition: MuonRecToolsConfig.py:132
python.MuonCombinedReconstructionConfig.MuonSegContainerMergerAlgCfg
def MuonSegContainerMergerAlgCfg(flags, name="MuonSegContainerMergerAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:374
python.CaloThinCellsByClusterAlgConfig.CaloThinCellsByClusterAlgCfg
def CaloThinCellsByClusterAlgCfg(flags, streamName, clusters, samplings=[], cells='AllCalo')
Definition: CaloThinCellsByClusterAlgConfig.py:11
python.MuonCombinedReconstructionConfig.CombinedMuonTrackTruthAlgsCfg
def CombinedMuonTrackTruthAlgsCfg(flags)
Definition: MuonCombinedReconstructionConfig.py:518
AtlasTrackingGeometryCondAlgConfig.TrackingGeometryCondAlgCfg
def TrackingGeometryCondAlgCfg(flags, name='AtlasTrackingGeometryCondAlg', doMaterialValidation=False, **kwargs)
Definition: AtlasTrackingGeometryCondAlgConfig.py:131
python.MuonCombinedReconstructionConfig.MuonInDetToMuonSystemExtensionAlgCfg
def MuonInDetToMuonSystemExtensionAlgCfg(flags, name="MuonInDetToMuonSystemExtensionAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:174
python.MuonCombinedRecToolsConfig.MuonCreatorToolCfg
def MuonCreatorToolCfg(flags, name="MuonCreatorTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:138
python.MuonCombinedRecToolsConfig.MuonCandidateToolCfg
def MuonCandidateToolCfg(flags, name="MuonCandidateTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:221
python.MuonCombinedReconstructionConfig.MuonCombinedMuonCandidateAlgCfg
def MuonCombinedMuonCandidateAlgCfg(flags, name="MuonCombinedMuonCandidateAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:102
python.MuonCombinedReconstructionConfig.LRT_MuGirlAlgCfg
def LRT_MuGirlAlgCfg(flags, name="MuGirlAlg_LRT", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:68
python.MuonCombinedReconstructionConfig.CombinedMuonTruthAssociationAlgsCfg
def CombinedMuonTruthAssociationAlgsCfg(flags)
Definition: MuonCombinedReconstructionConfig.py:535
python.MuonCombinedReconstructionConfig.MuGirlStauAlgCfg
def MuGirlStauAlgCfg(flags, name="MuGirlStauAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:79
python.MuonCombinedReconstructionConfig.MuonSegmentTagAlgCfg
def MuonSegmentTagAlgCfg(flags, name="MuonSegmentTagAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:28
python.MuonCombinedReconstructionConfig.CombinedMuonOutputCfg
def CombinedMuonOutputCfg(flags)
Definition: MuonCombinedReconstructionConfig.py:562
python.MuonCombinedReconstructionConfig.MuonCombinedInDetCandidateAlgCfg
def MuonCombinedInDetCandidateAlgCfg(flags, name="MuonCombinedInDetCandidateAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:148
python.TrkTrackSummaryToolConfig.MuonCombinedTrackSummaryToolCfg
def MuonCombinedTrackSummaryToolCfg(flags, name="CombinedMuonTrackSummary", **kwargs)
Definition: TrkTrackSummaryToolConfig.py:153
python.MuonTruthAlgsConfig.MuonDetailedTrackTruthMakerCfg
def MuonDetailedTrackTruthMakerCfg(flags, name="MuonDetailedTrackTruthMaker", **kwargs)
Definition: MuonConfig/python/MuonTruthAlgsConfig.py:6
python.MuonCombinedReconstructionConfig.MuonCaloTagAlgCfg
def MuonCaloTagAlgCfg(flags, name="MuonCaloTagAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:8
CaloExtensionBuilderAlgCfg.CaloExtensionBuilderCfg
def CaloExtensionBuilderCfg(flags)
Definition: CaloExtensionBuilderAlgCfg.py:35
python.TrkEventCnvToolsConfig.TrkEventCnvSuperToolCfg
def TrkEventCnvSuperToolCfg(flags, name='EventCnvSuperTool', **kwargs)
Definition: TrkEventCnvToolsConfig.py:51
python.MuonGeometryConfig.MuonIdHelperSvcCfg
def MuonIdHelperSvcCfg(flags)
Definition: MuonGeometryConfig.py:15
python.MuonCombinedReconstructionConfig.MuonDecorationAlgsCfg
def MuonDecorationAlgsCfg(flags)
Definition: MuonCombinedReconstructionConfig.py:479
python.MuonTruthAlgsConfig.MuonSegmentTruthAssociationAlgCfg
def MuonSegmentTruthAssociationAlgCfg(flags, name="MuonSegmentTruthAssociationAlg", **kwargs)
Definition: MuonConfig/python/MuonTruthAlgsConfig.py:56
python.MuonCombinedRecToolsConfig.MuonCombinedToolCfg
def MuonCombinedToolCfg(flags, name="MuonCombinedTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:271
python.MuonCombinedRecToolsConfig.MuonStauRecoToolCfg
def MuonStauRecoToolCfg(flags, name="MuonStauRecoTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1086
python.CaloNoiseCondAlgConfig.CaloNoiseCondAlgCfg
def CaloNoiseCondAlgCfg(flags, noisetype="totalNoise")
Definition: CaloNoiseCondAlgConfig.py:11
python.MuonCombinedReconstructionConfig.EMEO_MuonCombinedMuonCandidateAlgCfg
def EMEO_MuonCombinedMuonCandidateAlgCfg(flags, name="MuonCombinedMuonCandidateAlg_EMEO")
Definition: MuonCombinedReconstructionConfig.py:124
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:195
python.MuonCombinedReconstructionConfig.MuonPrecisionLayerDecorAlgCfg
def MuonPrecisionLayerDecorAlgCfg(flags, name="MuonPrecisionLayerDecorAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:472
python.MuonCombinedReconstructionConfig.LRT_MuonCombinedInDetCandidateAlgCfg
def LRT_MuonCombinedInDetCandidateAlgCfg(flags, name="MuonCombinedInDetCandidateAlg_LRT", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:203
python.MuonCombinedReconstructionConfig.MuonInsideOutRecoAlgCfg
def MuonInsideOutRecoAlgCfg(flags, name="MuonInsideOutRecoAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:47
python.MuonCombinedRecToolsConfig.MuonSegmentTagToolCfg
def MuonSegmentTagToolCfg(flags, name="MuonSegmentTagTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1239
python.MuonSegmentFindingConfig.MuonLayerHoughAlgCfg
def MuonLayerHoughAlgCfg(flags, name="MuonLayerHoughAlg", **kwargs)
Definition: MuonSegmentFindingConfig.py:402
python.MuonSegmentFindingConfig.MuonSegmentCnvAlgCfg
def MuonSegmentCnvAlgCfg(flags, name="MuonSegmentCnvAlg", **kwargs)
Definition: MuonSegmentFindingConfig.py:567
python.MuonCombinedReconstructionConfig.LRT_MuonCaloTagAlgCfg
def LRT_MuonCaloTagAlgCfg(flags, name="MuonCaloTagAlg_LRT", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:22
python.MuonCombinedRecToolsConfig.EMEO_MuonCombinedToolCfg
def EMEO_MuonCombinedToolCfg(flags, name="MuonCombinedTool_EMEO", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:336
python.MuonCombinedReconstructionConfig.EMEO_MuonCombinedAlgCfg
def EMEO_MuonCombinedAlgCfg(flags, name="MuonCombinedAlg_EMEO", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:246
python.MuonCombinedReconstructionConfig.EMEO_MuonCreatorAlgCfg
def EMEO_MuonCreatorAlgCfg(flags, name="MuonCreatorAlg_EMEO", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:334
python.MuonCombinedReconstructionConfig.MuonTrkIDMSScatterDecorAlgCfg
def MuonTrkIDMSScatterDecorAlgCfg(flags, name="MuonCombIDMSScatterDecorAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:458
python.OutputStreamConfig.addToESD
def addToESD(flags, itemOrList, **kwargs)
Definition: OutputStreamConfig.py:127
TCS::join
std::string join(const std::vector< std::string > &v, const char c=',')
Definition: Trigger/TrigT1/L1Topo/L1TopoCommon/Root/StringUtils.cxx:10
python.MuonCombinedReconstructionConfig.StauCreatorAlgCfg
def StauCreatorAlgCfg(flags, name="StauCreatorAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:354
python.MuonCombinedReconstructionConfig.LRT_MuonInDetToMuonSystemExtensionAlgCfg
def LRT_MuonInDetToMuonSystemExtensionAlgCfg(flags, name="MuonInDetToMuonSystemExtensionAlg_LRT", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:194
python.CaloTopoClusterConfig.CaloTopoClusterCfg
def CaloTopoClusterCfg(flags, cellsname="AllCalo", clustersname=None, clustersnapname="CaloTopoClusters")
Definition: CaloTopoClusterConfig.py:318
python.MuonRecToolsConfig.MuonEDMHelperSvcCfg
def MuonEDMHelperSvcCfg(flags, name="MuonEDMHelperSvc", **kwargs)
Definition: MuonRecToolsConfig.py:31
python.InDetTrackSelectorToolConfig.MuonCombinedInDetDetailedForwardTrackSelectorToolCfg
def MuonCombinedInDetDetailedForwardTrackSelectorToolCfg(flags, name='MuonCombinedInDetDetailedForwardTrackSelectorTool', **kwargs)
Definition: InDetTrackSelectorToolConfig.py:172
python.MuonCombinedReconstructionConfig.LRT_MuonSegmentTagAlgCfg
def LRT_MuonSegmentTagAlgCfg(flags, name="MuonSegmentTagAlg_LRT", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:40
python.MuonCombinedReconstructionConfig.LRT_MuonCreatorAlgCfg
def LRT_MuonCreatorAlgCfg(flags, name="MuonCreatorAlg_LRT", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:303
python.MuonCombinedRecToolsConfig.MuonCaloTagToolCfg
def MuonCaloTagToolCfg(flags, name='MuonCaloTagTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:940
python.MuonCombinedReconstructionConfig.MuonInDetExtensionMergerAlgCfg
def MuonInDetExtensionMergerAlgCfg(flags, name="MuonInDetExtensionMergerAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:414
python.MuonCombinedRecToolsConfig.MuonInsideOutRecoToolCfg
def MuonInsideOutRecoToolCfg(flags, name="MuonInsideOutRecoTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1004
python.MuonCombinedRecToolsConfig.EMEO_CombinedMuonTrackBuilderCfg
def EMEO_CombinedMuonTrackBuilderCfg(flags, name="MuonCombinedTrackBuilder_EMEO")
Definition: MuonCombinedRecToolsConfig.py:641
python.MuonCombinedReconstructionConfig.LRT_MuonCombinedAlgCfg
def LRT_MuonCombinedAlgCfg(flags, name="MuonCombinedAlg_LRT", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:261
python.OutputStreamConfig.addToAOD
def addToAOD(flags, itemOrList, **kwargs)
Definition: OutputStreamConfig.py:142
python.MuonCombinedReconstructionConfig.GetCombinedTrkContainers
def GetCombinedTrkContainers(flags)
Definition: MuonCombinedReconstructionConfig.py:427
str
Definition: BTagTrackIpAccessor.cxx:11
python.MuonCombinedReconstructionConfig.MuonTrkAEOTDecorAlgCfg
def MuonTrkAEOTDecorAlgCfg(flags, name="MuonCombAEOTDecorAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:465
python.MuonCombinedRecToolsConfig.MuonSystemExtensionToolCfg
def MuonSystemExtensionToolCfg(flags, **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1161
python.InDetTrackSelectorToolConfig.MuonCombinedInDetDetailedTrackSelectorTool_LRTCfg
def MuonCombinedInDetDetailedTrackSelectorTool_LRTCfg(flags, name='MuonCombinedInDetDetailedTrackSelectorTool_LRT', **kwargs)
Definition: InDetTrackSelectorToolConfig.py:158
python.TrackCollectionReadConfig.TrackCollectionReadCfg
def TrackCollectionReadCfg(flags, key)
Definition: TrackCollectionReadConfig.py:28
python.MuonCombinedReconstructionConfig.MuonCombinedAlgCfg
def MuonCombinedAlgCfg(flags, name="MuonCombinedAlg", **kwargs)
Definition: MuonCombinedReconstructionConfig.py:227
python.MuonCombinedReconstructionConfig.MuonCombinedReconstructionCfg
def MuonCombinedReconstructionCfg(flags)
Definition: MuonCombinedReconstructionConfig.py:674
python.MuonTruthAlgsConfig.MuonTruthAssociationAlgCfg
def MuonTruthAssociationAlgCfg(flags, name="MuonTruthAssociationAlg", **kwargs)
Definition: MuonConfig/python/MuonTruthAlgsConfig.py:51
Generated on Sun Dec 22 2024 22:06:42 for ATLAS Offline Software by   doxygen 1.8.18