ATLAS Offline Software
Functions
python.MuonCombinedRecToolsConfig Namespace Reference

Functions

def InDetCandidateToolCfg (flags, name="InDetCandidateTool", **kwargs)
 
def MuonInDetForwardCandidateToolCfg (flags, name='InDetForwardCandidateTool', **kwargs)
 
def MuonCaloEnergyToolCfg (flags, name="MuonCaloEnergyTool", **kwargs)
 
def MuonMaterialProviderToolCfg (flags, name="MuonTrkMaterialProviderTool", **kwargs)
 
def MuonSegmentHitSummaryToolCfg (flags, name="MuonSegmentHitSummaryTool", **kwargs)
 
def MuonSegmentConverterToolCfg (flags, name="MuonSegmentConverterTool", **kwargs)
 
def MuonDressingToolCfg (flags, name="MuonDressingTool", **kwargs)
 
def MuonCreatorToolCfg (flags, name="MuonCreatorTool", **kwargs)
 
def ExtrapolateMuonToIPToolCfg (flags, name="ExtrapolateMuonToIPTool", **kwargs)
 
def MuonCandidateToolCfg (flags, name="MuonCandidateTool", **kwargs)
 
def MuonCombinedDebuggerToolCfg (flags, name="MuonCombinedDebuggerTool", **kwargs)
 
def MuonCombinedToolCfg (flags, name="MuonCombinedTool", **kwargs)
 
def MuonCombinedFitTagToolCfg (flags, name="MuonCombinedFitTagTool", **kwargs)
 
def EMEO_MuonCombinedFitTagToolCfg (flags, name="MuonCombinedFitTagTool_EMEO", **kwargs)
 
def EMEO_MuonCombinedToolCfg (flags, name="MuonCombinedTool_EMEO", **kwargs)
 
def MuonCombinedStacoTagToolCfg (flags, name="MuonCombinedStacoTagTool", **kwargs)
 
def MuidMaterialAllocatorCfg (flags, name='MuidMaterialAllocator', **kwargs)
 
def iPatFitterCfg (flags, name='iPatFitter', **kwargs)
 
def iPatSLFitterCfg (flags, name='iPatSLFitter', **kwargs)
 
def MuidTrackCleanerCfg (flags, name='MuidTrackCleaner', **kwargs)
 
def MuidCaloEnergyParam (flags, name='MuidCaloEnergyParam', **kwargs)
 
def MuidCaloEnergyMeasCfg (flags, name='MuidCaloEnergyMeas', **kwargs)
 
def MuidCaloEnergyToolParamCfg (flags, name='MuidCaloEnergyToolParam', **kwargs)
 
def MuidTrackIsolationCfg (flags, name='MuidTrackIsolation', **kwargs)
 
def MuidCaloEnergyToolCfg (flags, name='MuidCaloEnergyTool', **kwargs)
 
def MuidCaloTrackStateOnSurfaceCfg (flags, name='MuidCaloTrackStateOnSurface', **kwargs)
 
def MuidCaloTrackStateOnSurfaceParamCfg (flags, name='MuidCaloTrackStateOnSurfaceParam', **kwargs)
 
def MuidMaterialEffectsOnTrackProviderCfg (flags, name='MuidMaterialEffectsOnTrackProvider', **kwargs)
 
def MuidMaterialEffectsOnTrackProviderParamCfg (flags, name='MuidMaterialEffectsOnTrackProviderParam', **kwargs)
 
def MuonTrackQueryCfg (flags, name="MuonTrackQuery", **kwargs)
 
def EMEO_MuonSegmentRegionRecoveryToolCfg (flags, name="MuonSegmentRegionRecoveryTool_EMEO")
 
def EMEO_CombinedMuonTrackBuilderCfg (flags, name="MuonCombinedTrackBuilder_EMEO")
 
def MuidErrorOptimisationToolCfg (flags, name='MuidErrorOptimisationTool', **kwargs)
 
def MuonAlignmentUncertToolThetaCfg (flags, name="MuonAlignmentUncertToolTheta", **kwargs)
 
def MuonAlignmentUncertToolPhiCfg (flags, name="MuonAlignmentUncertToolPhi", **kwargs)
 
def CombinedMuonTrackBuilderCfg (flags, name='CombinedMuonTrackBuilder', **kwargs)
 
def CombinedMuonTrackBuilderFitCfg (flags, name='CombinedMuonTrackBuilderFit', **kwargs)
 
def EMEO_CombinedTrackBuilderFitCfg (flags, name="CombinedTrackBuilderFit_EMEO", **kwargs)
 
def MuonMatchQualityCfg (flags, name='MuonMatchQuality', **kwargs)
 
def MuidMuonRecoveryCfg (flags, name='MuidMuonRecovery', **kwargs)
 
def CombinedMuonTagTestToolCfg (flags, name='CombinedMuonTagTestTool', **kwargs)
 
def TrackDepositInCaloToolCfg (flags, name='TrackDepositInCaloTool', **kwargs)
 
def CaloMuonLikelihoodToolCfg (flags, name='CaloMuonLikelihoodTool', **kwargs)
 
def CaloMuonScoreToolCfg (flags, name='CaloMuonScoreTool', **kwargs)
 
def CaloMuonTagCfg (flags, name="CaloMuonTag", **kwargs)
 
def MuonCaloTagToolCfg (flags, name='MuonCaloTagTool', **kwargs)
 
def MuonLayerSegmentFinderToolCfg (flags, name="MuonLayerSegmentFinderTool", **kwargs)
 
def MuonLayerSegmentMatchingToolCfg (flags, name="MuonLayerSegmentMatchingTool", **kwargs)
 
def MuonInsideOutRecoToolCfg (flags, name="MuonInsideOutRecoTool", **kwargs)
 
def MuonCandidateTrackBuilderToolCfg (flags, name="MuonCandidateTrackBuilderTool", **kwargs)
 
def MuonSegmentSelectionToolCfg (flags, name="MuonSegmentSelectionTool", **kwargs)
 
def MuonLayerAmbiguitySolverToolCfg (flags, name="MuonLayerAmbiguitySolverTool", **kwargs)
 
def MdtDriftCircleOnTrackCreatorStauCfg (flags, name="MdtDriftCircleOnTrackCreatorStau", **kwargs)
 
def MuonStauRecoToolCfg (flags, name="MuonStauRecoTool", **kwargs)
 
def MuonSystemExtensionToolCfg (flags, **kwargs)
 
def MuTagMatchingToolCfg (flags, name='MuTagMatchingTool', **kwargs)
 
def MuTagAmbiguitySolverToolCfg (flags, name='MuTagAmbiguitySolverTool', **kwargs)
 
def MuonSegmentTagToolCfg (flags, name="MuonSegmentTagTool", **kwargs)
 

Function Documentation

◆ CaloMuonLikelihoodToolCfg()

def python.MuonCombinedRecToolsConfig.CaloMuonLikelihoodToolCfg (   flags,
  name = 'CaloMuonLikelihoodTool',
**  kwargs 
)

Definition at line 913 of file MuonCombinedRecToolsConfig.py.

913 def CaloMuonLikelihoodToolCfg(flags, name='CaloMuonLikelihoodTool', **kwargs):
914  from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg
915  result = ComponentAccumulator()
916  kwargs.setdefault("ParticleCaloExtensionTool",
917  result.popToolsAndMerge(ParticleCaloExtensionToolCfg(flags)))
918  tool = CompFactory.CaloMuonLikelihoodTool(name, **kwargs)
919  result.setPrivateTools(tool)
920  return result
921 
922 

◆ CaloMuonScoreToolCfg()

def python.MuonCombinedRecToolsConfig.CaloMuonScoreToolCfg (   flags,
  name = 'CaloMuonScoreTool',
**  kwargs 
)

Definition at line 923 of file MuonCombinedRecToolsConfig.py.

923 def CaloMuonScoreToolCfg(flags, name='CaloMuonScoreTool', **kwargs):
924  from TrackToCalo.TrackToCaloConfig import ParticleCaloCellAssociationToolCfg
925  result = ComponentAccumulator()
926  kwargs.setdefault("ParticleCaloCellAssociationTool",
927  result.popToolsAndMerge(ParticleCaloCellAssociationToolCfg(flags)))
928  tool = CompFactory.CaloMuonScoreTool(name, **kwargs)
929  result.setPrivateTools(tool)
930  return result
931 
932 

◆ CaloMuonTagCfg()

def python.MuonCombinedRecToolsConfig.CaloMuonTagCfg (   flags,
  name = "CaloMuonTag",
**  kwargs 
)

Definition at line 933 of file MuonCombinedRecToolsConfig.py.

933 def CaloMuonTagCfg(flags, name="CaloMuonTag", **kwargs):
934  result = ComponentAccumulator()
935  the_tool = CompFactory.CaloMuonTag(name, **kwargs)
936  result.setPrivateTools(the_tool)
937  return result
938 
939 

◆ CombinedMuonTagTestToolCfg()

def python.MuonCombinedRecToolsConfig.CombinedMuonTagTestToolCfg (   flags,
  name = 'CombinedMuonTagTestTool',
**  kwargs 
)

Definition at line 885 of file MuonCombinedRecToolsConfig.py.

885 def CombinedMuonTagTestToolCfg(flags, name='CombinedMuonTagTestTool', **kwargs):
886  result = AtlasExtrapolatorCfg(flags)
887  kwargs.setdefault("ExtrapolatorTool", result.popPrivateTools())
888  kwargs.setdefault("Chi2Cut", 50000.)
889  from TrackingGeometryCondAlg.AtlasTrackingGeometryCondAlgConfig import TrackingGeometryCondAlgCfg
890  result.merge(TrackingGeometryCondAlgCfg(flags))
891  kwargs.setdefault("TrackingGeometryReadKey", "AtlasTrackingGeometry")
892  tool = CompFactory.MuonCombined.MuonTrackTagTestTool(name, **kwargs)
893  result.setPrivateTools(tool)
894  return result
895 
896 # From MuonCaloTagTool.py
897 
898 

◆ CombinedMuonTrackBuilderCfg()

def python.MuonCombinedRecToolsConfig.CombinedMuonTrackBuilderCfg (   flags,
  name = 'CombinedMuonTrackBuilder',
**  kwargs 
)

Definition at line 696 of file MuonCombinedRecToolsConfig.py.

696 def CombinedMuonTrackBuilderCfg(flags, name='CombinedMuonTrackBuilder', **kwargs):
697  from AthenaCommon.SystemOfUnits import meter
698  from MuonConfig.MuonRIO_OnTrackCreatorToolConfig import CscClusterOnTrackCreatorCfg, MdtDriftCircleOnTrackCreatorCfg, MuonClusterOnTrackCreatorCfg
699  from TrkConfig.TrkTrackSummaryToolConfig import MuonCombinedTrackSummaryToolCfg
700 
701  result = ComponentAccumulator()
702 
703  from MuonConfig.MuonGeometryConfig import TrackingVolumesSvcCfg
704  kwargs.setdefault("TrackingVolumesSvc", result.getPrimaryAndMerge(TrackingVolumesSvcCfg(flags)))
705 
706  kwargs.setdefault("CaloEnergyParam", result.popToolsAndMerge(
707  MuidCaloEnergyToolParamCfg(flags)))
708  kwargs.setdefault("CaloTSOS", result.popToolsAndMerge(
709  MuidCaloTrackStateOnSurfaceCfg(flags)))
710  kwargs.setdefault("Cleaner", result.popToolsAndMerge(
711  MuidTrackCleanerCfg(flags)))
712  result.merge(MuonAlignmentUncertToolPhiCfg(flags))
713  kwargs.setdefault("AlignmentUncertToolPhi",
714  result.getPublicTool('MuonAlignmentUncertToolPhi'))
715  result.merge(MuonAlignmentUncertToolThetaCfg(flags))
716  kwargs.setdefault("AlignmentUncertToolTheta",
717  result.getPublicTool('MuonAlignmentUncertToolTheta'))
718 
719  if flags.Detector.GeometryCSC and not flags.Muon.MuonTrigger:
720  kwargs.setdefault("CscRotCreator", result.popToolsAndMerge(
721  CscClusterOnTrackCreatorCfg(flags)))
722  else:
723  kwargs.setdefault("CscRotCreator", "")
724 
725  kwargs.setdefault("Extrapolator", result.popToolsAndMerge(
726  AtlasExtrapolatorCfg(flags)))
727  kwargs.setdefault(
728  "Fitter", result.popToolsAndMerge(iPatFitterCfg(flags)))
729  kwargs.setdefault(
730  "SLFitter", result.popToolsAndMerge(iPatSLFitterCfg(flags)))
731  kwargs.setdefault("MaterialAllocator", result.popToolsAndMerge(
732  MuidMaterialAllocatorCfg(flags)))
733  kwargs.setdefault("MdtRotCreator", result.popToolsAndMerge(
734  MdtDriftCircleOnTrackCreatorCfg(flags)))
735  kwargs.setdefault("MuonRotCreator", result.popToolsAndMerge(
736  MuonClusterOnTrackCreatorCfg(flags)))
737 
738  # Tracking Geometry
739  from TrackingGeometryCondAlg.AtlasTrackingGeometryCondAlgConfig import (
740  TrackingGeometryCondAlgCfg)
741 
742  geom_cond_key = result.getPrimaryAndMerge(
743  TrackingGeometryCondAlgCfg(flags)).TrackingGeometryWriteKey
744  kwargs.setdefault("TrackingGeometryReadKey", geom_cond_key)
745 
746  kwargs.setdefault("CleanCombined", True)
747  kwargs.setdefault("CleanStandalone", True)
748  kwargs.setdefault("BadFitChi2", 2.5)
749  kwargs.setdefault("LargeMomentumError", 0.5)
750  kwargs.setdefault("LineMomentum", flags.Muon.straightLineFitMomentum)
751  kwargs.setdefault("LowMomentum", 10.*GeV)
752  kwargs.setdefault("MinEnergy", 0.3*GeV)
753  kwargs.setdefault("PerigeeAtSpectrometerEntrance", False)
754  kwargs.setdefault("ReallocateMaterial", False)
755  kwargs.setdefault("Vertex2DSigmaRPhi", 100.*mm)
756  kwargs.setdefault("Vertex3DSigmaRPhi", 6.*mm)
757  kwargs.setdefault("Vertex3DSigmaZ", 60.*mm)
758  kwargs.setdefault("UseCaloTG", True)
759 
760  kwargs.setdefault("CaloMaterialProvider", result.popToolsAndMerge(
761  MuonMaterialProviderToolCfg(flags)))
762  kwargs.setdefault("TrackQuery", result.popToolsAndMerge(
763  MuonTrackQueryCfg(flags)))
764 
765  if flags.Muon.SAMuonTrigger:
766  from TrkConfig.TrkTrackSummaryToolConfig import MuonTrackSummaryToolCfg
767  kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(
768  MuonTrackSummaryToolCfg(flags)))
769  else:
770  kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(
771  MuonCombinedTrackSummaryToolCfg(flags)))
772 
773  from TrkConfig.TrkExRungeKuttaPropagatorConfig import MuonCombinedPropagatorCfg, RungeKuttaPropagatorCfg
774  propagator = None
775  if flags.Muon.MuonTrigger:
776  propagator = result.popToolsAndMerge(RungeKuttaPropagatorCfg(flags))
777  else:
778  propagator = result.popToolsAndMerge(MuonCombinedPropagatorCfg(flags))
779  kwargs.setdefault("Propagator", propagator)
780  kwargs.setdefault("SLPropagator", propagator)
781  kwargs.setdefault("Printer", result.getPrimaryAndMerge(
782  MuonEDMPrinterToolCfg(flags)))
783 
784  if flags.Beam.Type is BeamType.Cosmics:
785  kwargs.setdefault("MdtRotCreator", "")
786  kwargs.setdefault("MuonRotCreator", "")
787  kwargs.setdefault("LowMomentum", 1.5*GeV)
788  kwargs.setdefault("ReallocateMaterial", False)
789  kwargs.setdefault("Vertex2DSigmaRPhi", 100.*mm)
790  kwargs.setdefault("Vertex3DSigmaRPhi", 100.*mm)
791  kwargs.setdefault("Vertex3DSigmaZ", 1.*meter)
792 
793  # configure tools for data reprocessing
794  if flags.Muon.enableErrorTuning and 'MuonErrorOptimizer' not in kwargs:
795  erroropt = result.popToolsAndMerge(MuidErrorOptimisationToolCfg(
796  flags, name="MuidErrorOptimisationTool", PrepareForFit=False, RecreateStartingParameters=False))
797  kwargs.setdefault("MuonErrorOptimizer", erroropt)
798  else:
799  kwargs.setdefault("MuonErrorOptimizer", "")
800 
801  if flags.Muon.MuonTrigger:
802  kwargs.setdefault("MuonHoleRecovery", "")
803  else:
804  if "MuonHoleRecovery" not in kwargs:
805  # Meeded to resolve circular dependency since MuonSegmentRegionRecoveryToolCfg calls CombinedMuonTrackBuilderCfg (i.e. this)!
806  muon_combined_track_summary = result.popToolsAndMerge(
807  MuonCombinedTrackSummaryToolCfg(flags))
808  acc = MuonSegmentRegionRecoveryToolCfg(
809  flags, name="MuidSegmentRegionRecoveryTool", TrackSummaryTool=muon_combined_track_summary)
810  kwargs.setdefault("MuonHoleRecovery", acc.popPrivateTools())
811  result.merge(acc)
812 
813  if flags.Muon.doSegmentT0Fit:
814  kwargs.setdefault("MdtRotCreator", "")
815  tool = CompFactory.Rec.CombinedMuonTrackBuilder(name, **kwargs)
816  result.setPrivateTools(tool)
817  return result
818 
819 

◆ CombinedMuonTrackBuilderFitCfg()

def python.MuonCombinedRecToolsConfig.CombinedMuonTrackBuilderFitCfg (   flags,
  name = 'CombinedMuonTrackBuilderFit',
**  kwargs 
)

Definition at line 820 of file MuonCombinedRecToolsConfig.py.

820 def CombinedMuonTrackBuilderFitCfg(flags, name='CombinedMuonTrackBuilderFit', **kwargs):
821  # In the old configuration we had duplication between CombinedMuonTrackBuilder and CombinedMuonTrackBuilderFit
822  # Here we just call the Combined
823  from MuonConfig.MuonTrackBuildingConfig import MuonChamberHoleRecoveryToolCfg
824  result = ComponentAccumulator()
825  kwargs.setdefault("PerigeeAtSpectrometerEntrance", True)
826  kwargs.setdefault("UseCaloTG", False)
827  if flags.Muon.MuonTrigger:
828  kwargs.setdefault("MuonErrorOptimizer", "")
829  else:
830  kwargs.setdefault("MuonErrorOptimizer", result.popToolsAndMerge(
831  MuidErrorOptimisationToolCfg(flags, PrepareForFit=False, RecreateStartingParameters=False)))
832  kwargs.setdefault("MuonHoleRecovery", result.popToolsAndMerge(
833  MuonChamberHoleRecoveryToolCfg(flags)))
834 
835  tool = result.popToolsAndMerge(CombinedMuonTrackBuilderCfg(
836  flags, name, **kwargs)) # Need to reset this to be the primary tool
837  result.setPrivateTools(tool)
838  return result
839 
840 

◆ EMEO_CombinedMuonTrackBuilderCfg()

def python.MuonCombinedRecToolsConfig.EMEO_CombinedMuonTrackBuilderCfg (   flags,
  name = "MuonCombinedTrackBuilder_EMEO" 
)

Definition at line 641 of file MuonCombinedRecToolsConfig.py.

641 def EMEO_CombinedMuonTrackBuilderCfg(flags, name="MuonCombinedTrackBuilder_EMEO"):
642  result = ComponentAccumulator()
643  recovery_tool = result.popToolsAndMerge(
644  EMEO_MuonSegmentRegionRecoveryToolCfg(flags))
645  acc = CombinedMuonTrackBuilderCfg(flags, name,
646  MuonRotCreator="",
647  MuonHoleRecovery=recovery_tool)
648  # Need to reset this to be the primary tool
649  tool = result.popToolsAndMerge(acc)
650  result.setPrivateTools(tool)
651  return result
652 
653 

◆ EMEO_CombinedTrackBuilderFitCfg()

def python.MuonCombinedRecToolsConfig.EMEO_CombinedTrackBuilderFitCfg (   flags,
  name = "CombinedTrackBuilderFit_EMEO",
**  kwargs 
)

Definition at line 841 of file MuonCombinedRecToolsConfig.py.

841 def EMEO_CombinedTrackBuilderFitCfg(flags, name="CombinedTrackBuilderFit_EMEO", **kwargs):
842  result = ComponentAccumulator()
843  from MuonConfig.MuonTrackBuildingConfig import EMEO_MuonChamberHoleRecoveryToolCfg
844  if not flags.Muon.MuonTrigger:
845  trk_builder = result.popToolsAndMerge(
846  EMEO_MuonChamberHoleRecoveryToolCfg(flags))
847  kwargs.setdefault("MuonHoleRecovery", trk_builder)
848  else:
849  kwargs.setdefault("MuonHoleRecovery", "")
850  kwargs.setdefault("MuonRotCreator", "")
851  tool = result.popToolsAndMerge(CombinedMuonTrackBuilderFitCfg(
852  flags, name, **kwargs)) # Need to reset this to be the primary tool
853  result.setPrivateTools(tool)
854  return result
855 
856 

◆ EMEO_MuonCombinedFitTagToolCfg()

def python.MuonCombinedRecToolsConfig.EMEO_MuonCombinedFitTagToolCfg (   flags,
  name = "MuonCombinedFitTagTool_EMEO",
**  kwargs 
)

Definition at line 325 of file MuonCombinedRecToolsConfig.py.

325 def EMEO_MuonCombinedFitTagToolCfg(flags, name="MuonCombinedFitTagTool_EMEO", **kwargs):
326  result = ComponentAccumulator()
327  track_builder = result.popToolsAndMerge(
328  EMEO_CombinedMuonTrackBuilderCfg(flags))
329  fit_tag_tool = result.popToolsAndMerge(MuonCombinedFitTagToolCfg(flags, name=name,
330  TrackBuilder=track_builder,
331  **kwargs))
332  result.setPrivateTools(fit_tag_tool)
333  return result
334 
335 

◆ EMEO_MuonCombinedToolCfg()

def python.MuonCombinedRecToolsConfig.EMEO_MuonCombinedToolCfg (   flags,
  name = "MuonCombinedTool_EMEO",
**  kwargs 
)

Definition at line 336 of file MuonCombinedRecToolsConfig.py.

336 def EMEO_MuonCombinedToolCfg(flags, name="MuonCombinedTool_EMEO", **kwargs):
337  tools = []
338  result = ComponentAccumulator()
339  kwargs.setdefault("Printer", result.getPrimaryAndMerge(
340  MuonEDMPrinterToolCfg(flags)))
341 
342  if flags.MuonCombined.doCombinedFit:
343  tool = result.popToolsAndMerge(EMEO_MuonCombinedFitTagToolCfg(flags))
344  tools.append(tool)
345  if flags.MuonCombined.doStatisticalCombination:
346  tool = result.popToolsAndMerge(MuonCombinedStacoTagToolCfg(flags))
347  tools.append(tool)
348 
349  kwargs.setdefault("MuonCombinedTagTools", tools)
350  kwargs.setdefault("MuonCombinedDebuggerTool", result.popToolsAndMerge(
351  MuonCombinedDebuggerToolCfg(flags)))
352 
353  acc = MuonAlignmentUncertToolThetaCfg(flags)
354  result.merge(acc)
355  kwargs.setdefault("AlignmentUncertTool", result.getPublicTool(
356  'MuonAlignmentUncertToolTheta'))
357 
358  kwargs.setdefault("DeltaEtaPreSelection", 0.2)
359  kwargs.setdefault("DeltaPhiPreSelection", 0.2)
360  tool = CompFactory.MuonCombined.MuonCombinedTool(name, **kwargs)
361  result.setPrivateTools(tool)
362  return result
363 
364 

◆ EMEO_MuonSegmentRegionRecoveryToolCfg()

def python.MuonCombinedRecToolsConfig.EMEO_MuonSegmentRegionRecoveryToolCfg (   flags,
  name = "MuonSegmentRegionRecoveryTool_EMEO" 
)

Definition at line 618 of file MuonCombinedRecToolsConfig.py.

618 def EMEO_MuonSegmentRegionRecoveryToolCfg(flags, name="MuonSegmentRegionRecoveryTool_EMEO"):
619  result = ComponentAccumulator()
620  from MuonConfig.MuonTrackBuildingConfig import EMEO_MuonChamberHoleRecoveryToolCfg
621  chamber_recovery = result.popToolsAndMerge(
622  EMEO_MuonChamberHoleRecoveryToolCfg(flags))
623  trk_builder = result.popToolsAndMerge(
624  EMEO_CombinedTrackBuilderFitCfg(flags))
625  from TrkConfig.TrkTrackSummaryToolConfig import MuonCombinedTrackSummaryToolCfg
626  muon_combined_track_summary = result.popToolsAndMerge(
627  MuonCombinedTrackSummaryToolCfg(flags))
628  tool = result.popToolsAndMerge(MuonSegmentRegionRecoveryToolCfg(flags,
629  name=name,
630  ChamberHoleRecoveryTool=chamber_recovery,
631  Builder=trk_builder,
632  TrackSummaryTool=muon_combined_track_summary,
633  STGCRegionSelector="",
634  MMRegionSelector="",
635  RecoverMM=False,
636  RecoverSTGC=False))
637  result.setPrivateTools(tool)
638  return result
639 
640 

◆ ExtrapolateMuonToIPToolCfg()

def python.MuonCombinedRecToolsConfig.ExtrapolateMuonToIPToolCfg (   flags,
  name = "ExtrapolateMuonToIPTool",
**  kwargs 
)

Definition at line 200 of file MuonCombinedRecToolsConfig.py.

200 def ExtrapolateMuonToIPToolCfg(flags, name="ExtrapolateMuonToIPTool", **kwargs):
201  result = AtlasExtrapolatorCfg(flags)
202  kwargs.setdefault("Extrapolator", result.popPrivateTools())
203  from TrkConfig.AtlasExtrapolatorConfig import MuonExtrapolatorCfg
204  kwargs.setdefault("MuonExtrapolator", result.popToolsAndMerge(
205  MuonExtrapolatorCfg(flags)))
206 
207  if flags.Muon.MuonTrigger:
208  from TrkConfig.TrkTrackSummaryToolConfig import MuonTrackSummaryToolCfg
209  kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(
210  MuonTrackSummaryToolCfg(flags)))
211  else:
212  from TrkConfig.TrkTrackSummaryToolConfig import MuonCombinedTrackSummaryToolCfg
213  kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(
214  MuonCombinedTrackSummaryToolCfg(flags)))
215  kwargs.setdefault("Printer", result.getPrimaryAndMerge(
216  MuonEDMPrinterToolCfg(flags)))
217  result.setPrivateTools(CompFactory.ExtrapolateMuonToIPTool(name, **kwargs))
218  return result
219 
220 

◆ InDetCandidateToolCfg()

def python.MuonCombinedRecToolsConfig.InDetCandidateToolCfg (   flags,
  name = "InDetCandidateTool",
**  kwargs 
)

Definition at line 18 of file MuonCombinedRecToolsConfig.py.

18 def InDetCandidateToolCfg(flags, name="InDetCandidateTool", **kwargs):
19  from InDetConfig.InDetTrackSelectorToolConfig import MuonCombinedInDetDetailedTrackSelectorToolCfg
20  result = MuonCombinedInDetDetailedTrackSelectorToolCfg(flags)
21  kwargs.setdefault("TrackSelector", result.popPrivateTools())
22  result.setPrivateTools(
23  CompFactory.MuonCombined.InDetCandidateTool(name, **kwargs))
24  return result
25 
26 

◆ iPatFitterCfg()

def python.MuonCombinedRecToolsConfig.iPatFitterCfg (   flags,
  name = 'iPatFitter',
**  kwargs 
)

Definition at line 403 of file MuonCombinedRecToolsConfig.py.

403 def iPatFitterCfg(flags, name='iPatFitter', **kwargs):
404  from TrkConfig.SolenoidalIntersectorConfig import SolenoidalIntersectorCfg
405  from TrkConfig.TrkExSTEP_PropagatorConfig import AtlasSTEP_PropagatorCfg
406 
407  kwargs.setdefault("AggregateMaterial", True)
408  kwargs.setdefault("FullCombinedFit", True)
409  result = MuidMaterialAllocatorCfg(flags)
410  kwargs.setdefault("MaterialAllocator", result.popPrivateTools())
411  # RungeKuttaIntersector needs a AtlasFieldCacheCondObj, but it's impossible to get here without that being configured already so let's be lazy
412  # It does not otherwise require explicit configuration
413  kwargs.setdefault('SolenoidalIntersector', result.popToolsAndMerge(
414  SolenoidalIntersectorCfg(flags)))
415  kwargs.setdefault('Propagator', result.popToolsAndMerge(
416  AtlasSTEP_PropagatorCfg(flags)))
417  # StraightLineIntersector does not need explicit configuration
418  if flags.Muon.MuonTrigger:
419  kwargs.setdefault("MaxIterations", 15)
420  if flags.Muon.SAMuonTrigger:
421  from TrkConfig.TrkTrackSummaryToolConfig import MuonTrackSummaryToolCfg
422  kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(
423  MuonTrackSummaryToolCfg(flags)))
424  else:
425  from TrkConfig.TrkTrackSummaryToolConfig import MuonCombinedTrackSummaryToolCfg
426  kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(
427  MuonCombinedTrackSummaryToolCfg(flags)))
428  # This is only to match old-style config. Does nothing.
429  kwargs.setdefault("TrackingVolumesSvc", "TrackingVolumesSvc")
430 
431  tool = CompFactory.Trk.iPatFitter(name, **kwargs)
432  result.setPrivateTools(tool)
433  return result
434 
435 

◆ iPatSLFitterCfg()

def python.MuonCombinedRecToolsConfig.iPatSLFitterCfg (   flags,
  name = 'iPatSLFitter',
**  kwargs 
)

Definition at line 436 of file MuonCombinedRecToolsConfig.py.

436 def iPatSLFitterCfg(flags, name='iPatSLFitter', **kwargs):
437  kwargs.setdefault("LineFit", True)
438  kwargs.setdefault("LineMomentum", flags.Muon.straightLineFitMomentum)
439  return iPatFitterCfg(flags, name, **kwargs)
440 
441 # track cleaner configured to use the same fitter
442 
443 

◆ MdtDriftCircleOnTrackCreatorStauCfg()

def python.MuonCombinedRecToolsConfig.MdtDriftCircleOnTrackCreatorStauCfg (   flags,
  name = "MdtDriftCircleOnTrackCreatorStau",
**  kwargs 
)

Definition at line 1076 of file MuonCombinedRecToolsConfig.py.

1076 def MdtDriftCircleOnTrackCreatorStauCfg(flags, name="MdtDriftCircleOnTrackCreatorStau", **kwargs):
1077  from MuonConfig.MuonRIO_OnTrackCreatorToolConfig import MdtDriftCircleOnTrackCreatorCfg, MdtCalibWindowNumber, MdtCalibToolForRotsCfg
1078  result = ComponentAccumulator()
1079  kwargs.setdefault("TimingMode", 3)
1080  kwargs.setdefault("CalibrationTool", result.popToolsAndMerge(MdtCalibToolForRotsCfg(flags, TimeWindowSetting = MdtCalibWindowNumber('Collision_t0fit') )) )
1081  the_tool = result.popToolsAndMerge(MdtDriftCircleOnTrackCreatorCfg(flags, name, **kwargs))
1082  result.setPrivateTools(the_tool)
1083  return result
1084 
1085 

◆ MuidCaloEnergyMeasCfg()

def python.MuonCombinedRecToolsConfig.MuidCaloEnergyMeasCfg (   flags,
  name = 'MuidCaloEnergyMeas',
**  kwargs 
)

Definition at line 482 of file MuonCombinedRecToolsConfig.py.

482 def MuidCaloEnergyMeasCfg(flags, name='MuidCaloEnergyMeas', **kwargs):
483  result = ComponentAccumulator()
484  muidcaloenergyparam = MuidCaloEnergyParam(flags)
485  kwargs.setdefault("CaloParamTool", muidcaloenergyparam)
486  # FIXME! Need to setup the folders for CaloNoiseKey (which is why this needs a CA)
487  # Not sure how to do : if flags.haveRIO.Calo_on() but TBH, if the cells aren't there it will abort anyway
488  kwargs.setdefault("CellContainerLocation", "AllCalo")
489  kwargs.setdefault("NoiseThresInSigmas", 4.)
490  tool = CompFactory.Rec.MuidCaloEnergyMeas(name, **kwargs)
491  result.setPrivateTools(tool)
492  return result
493 
494 

◆ MuidCaloEnergyParam()

def python.MuonCombinedRecToolsConfig.MuidCaloEnergyParam (   flags,
  name = 'MuidCaloEnergyParam',
**  kwargs 
)

Definition at line 477 of file MuonCombinedRecToolsConfig.py.

477 def MuidCaloEnergyParam(flags, name='MuidCaloEnergyParam', **kwargs):
478  kwargs.setdefault("Cosmics", flags.Beam.Type is BeamType.Cosmics)
479  return CompFactory.Rec.MuidCaloEnergyParam(name, **kwargs)
480 
481 

◆ MuidCaloEnergyToolCfg()

def python.MuonCombinedRecToolsConfig.MuidCaloEnergyToolCfg (   flags,
  name = 'MuidCaloEnergyTool',
**  kwargs 
)

Definition at line 523 of file MuonCombinedRecToolsConfig.py.

523 def MuidCaloEnergyToolCfg(flags, name='MuidCaloEnergyTool', **kwargs):
524  result = MuidCaloEnergyMeasCfg(flags)
525  from LArGeoAlgsNV.LArGMConfig import LArGMCfg
526  result.merge(LArGMCfg(flags))
527  kwargs.setdefault("CaloMeasTool", result.popPrivateTools())
528  kwargs.setdefault("CaloParamTool", MuidCaloEnergyParam(flags))
529  kwargs.setdefault("MinFinalEnergy", 1.0*GeV)
530  kwargs.setdefault("MinMuonPt", 10.0*GeV)
531  kwargs.setdefault("MopParametrization", True)
532  if flags.Muon.MuonTrigger:
533  kwargs.setdefault("EnergyLossMeasurement", False)
534  kwargs.setdefault("TrackIsolation", False)
535  else:
536  kwargs.setdefault("EnergyLossMeasurement", True)
537  kwargs.setdefault("TrackIsolation", True)
538 
539  kwargs.setdefault("TrackIsolationTool", result.popToolsAndMerge(
540  MuidTrackIsolationCfg(flags)))
541  kwargs.setdefault("Cosmics", flags.Beam.Type is BeamType.Cosmics)
542  result.setPrivateTools(CompFactory.Rec.MuidCaloEnergyTool(name, **kwargs))
543  return result
544 
545 

◆ MuidCaloEnergyToolParamCfg()

def python.MuonCombinedRecToolsConfig.MuidCaloEnergyToolParamCfg (   flags,
  name = 'MuidCaloEnergyToolParam',
**  kwargs 
)

Definition at line 495 of file MuonCombinedRecToolsConfig.py.

495 def MuidCaloEnergyToolParamCfg(flags, name='MuidCaloEnergyToolParam', **kwargs):
496  # Some duplication with MuidCaloEnergyToolCfg but probably safer like this, since
497  # we don't want to set e.g. MinFinalEnergy here
498  result = MuidCaloEnergyMeasCfg(flags)
499  kwargs.setdefault("CaloMeasTool", result.popPrivateTools())
500  kwargs.setdefault("EnergyLossMeasurement", False)
501 
502  kwargs.setdefault("CaloParamTool", MuidCaloEnergyParam(flags))
503  if flags.Beam.Type is BeamType.Cosmics:
504  kwargs.setdefault("Cosmics", True)
505  kwargs.setdefault("TrackIsolationTool", result.popToolsAndMerge(
506  MuidTrackIsolationCfg(flags)))
507 
508  result.setPrivateTools(CompFactory.Rec.MuidCaloEnergyTool(name, **kwargs))
509  return result
510 
511 

◆ MuidCaloTrackStateOnSurfaceCfg()

def python.MuonCombinedRecToolsConfig.MuidCaloTrackStateOnSurfaceCfg (   flags,
  name = 'MuidCaloTrackStateOnSurface',
**  kwargs 
)

Definition at line 546 of file MuonCombinedRecToolsConfig.py.

546 def MuidCaloTrackStateOnSurfaceCfg(flags, name='MuidCaloTrackStateOnSurface', **kwargs):
547  result = ComponentAccumulator()
548  from TrkConfig.TrkExRungeKuttaPropagatorConfig import RungeKuttaPropagatorCfg
549  kwargs.setdefault("Propagator", result.popToolsAndMerge(
550  RungeKuttaPropagatorCfg(flags)))
551  kwargs.setdefault("MinRemainingEnergy", 0.2*GeV)
552  kwargs.setdefault("ParamPtCut", 3.0*GeV)
553  kwargs.setdefault("CaloEnergyDeposit", result.popToolsAndMerge(
554  MuidCaloEnergyToolCfg(flags)))
555  kwargs.setdefault("CaloEnergyParam", result.popToolsAndMerge(
556  MuidCaloEnergyToolParamCfg(flags)))
557  # I don't think CaloMaterialParam i.e. MuidCaloMaterialParam needs explicit configuration
558  # Ditto for IntersectorWrapper, since it just uses RKIntersector which doesn't
559  tool = CompFactory.Rec.MuidCaloTrackStateOnSurface(name, **kwargs)
560  result.setPrivateTools(tool)
561  return result
562 
563 

◆ MuidCaloTrackStateOnSurfaceParamCfg()

def python.MuonCombinedRecToolsConfig.MuidCaloTrackStateOnSurfaceParamCfg (   flags,
  name = 'MuidCaloTrackStateOnSurfaceParam',
**  kwargs 
)

Definition at line 564 of file MuonCombinedRecToolsConfig.py.

564 def MuidCaloTrackStateOnSurfaceParamCfg(flags, name='MuidCaloTrackStateOnSurfaceParam', **kwargs):
565  result = ComponentAccumulator()
566  from TrkConfig.TrkExRungeKuttaPropagatorConfig import RungeKuttaPropagatorCfg
567  kwargs.setdefault("Propagator", result.popToolsAndMerge(
568  RungeKuttaPropagatorCfg(flags)))
569  kwargs.setdefault("MinRemainingEnergy", 0.2*GeV)
570  kwargs.setdefault("ParamPtCut", 3.0*GeV)
571  kwargs.setdefault("CaloEnergyDeposit", MuidCaloEnergyParam(flags))
572  kwargs.setdefault("CaloEnergyParam", MuidCaloEnergyParam(flags))
573  tool = CompFactory.Rec.MuidCaloTrackStateOnSurface(name, **kwargs)
574  result.setPrivateTools(tool)
575  return result
576 
577 

◆ MuidErrorOptimisationToolCfg()

def python.MuonCombinedRecToolsConfig.MuidErrorOptimisationToolCfg (   flags,
  name = 'MuidErrorOptimisationTool',
**  kwargs 
)

Definition at line 654 of file MuonCombinedRecToolsConfig.py.

654 def MuidErrorOptimisationToolCfg(flags, name='MuidErrorOptimisationTool', **kwargs):
655  from MuonConfig.MuonRecToolsConfig import MuonTrackSummaryHelperToolCfg, MuonRefitToolCfg
656  result = ComponentAccumulator()
657  kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(
658  MuonTrackSummaryHelperToolCfg(flags)))
659  useAlignErrs = True
660  if flags.IOVDb.DatabaseInstance == 'COMP200' or \
661  'HLT' in flags.IOVDb.GlobalTag or flags.Common.isOnline or flags.Muon.MuonTrigger:
662  useAlignErrs = False
663  kwargs.setdefault("RefitTool", result.popToolsAndMerge(MuonRefitToolCfg(
664  flags, name="MuidRefitTool", AlignmentErrors=useAlignErrs,
665  Fitter=result.popToolsAndMerge(iPatFitterCfg(flags)))))
666  tool = CompFactory.Muon.MuonErrorOptimisationTool(name, **kwargs)
667  result.setPrivateTools(tool)
668  return result
669 
670 

◆ MuidMaterialAllocatorCfg()

def python.MuonCombinedRecToolsConfig.MuidMaterialAllocatorCfg (   flags,
  name = 'MuidMaterialAllocator',
**  kwargs 
)

Definition at line 382 of file MuonCombinedRecToolsConfig.py.

382 def MuidMaterialAllocatorCfg(flags, name='MuidMaterialAllocator', **kwargs):
383  from TrkConfig.TrkExSTEP_PropagatorConfig import AtlasSTEP_PropagatorCfg
384  kwargs.setdefault("AggregateMaterial", True)
385  kwargs.setdefault("AllowReordering", False)
386 
387  result = AtlasExtrapolatorCfg(flags)
388  kwargs.setdefault("Extrapolator", result.popPrivateTools())
389  # Intersector (a RungeKuttaIntersector) does not require explicit configuration
390  kwargs.setdefault("STEP_Propagator", result.popToolsAndMerge(
391  AtlasSTEP_PropagatorCfg(flags, name="AtlasSTEP_Propagator")))
392  from TrackingGeometryCondAlg.AtlasTrackingGeometryCondAlgConfig import TrackingGeometryCondAlgCfg
393  result.merge(TrackingGeometryCondAlgCfg(flags))
394  kwargs.setdefault("TrackingGeometryReadKey", "AtlasTrackingGeometry")
395 
396  tool = CompFactory.Trk.MaterialAllocator(name, **kwargs)
397  result.setPrivateTools(tool)
398  return result
399 
400 # and the fitter
401 
402 

◆ MuidMaterialEffectsOnTrackProviderCfg()

def python.MuonCombinedRecToolsConfig.MuidMaterialEffectsOnTrackProviderCfg (   flags,
  name = 'MuidMaterialEffectsOnTrackProvider',
**  kwargs 
)

Definition at line 578 of file MuonCombinedRecToolsConfig.py.

578 def MuidMaterialEffectsOnTrackProviderCfg(flags, name='MuidMaterialEffectsOnTrackProvider', **kwargs):
579  result = MuidCaloTrackStateOnSurfaceCfg(flags)
580  kwargs.setdefault("TSOSTool", result.popPrivateTools())
581  acc = MuidCaloTrackStateOnSurfaceParamCfg(flags)
582  kwargs.setdefault("TSOSToolParam", acc.popPrivateTools())
583  result.merge(acc)
584  kwargs.setdefault("Cosmics", flags.Beam.Type is BeamType.Cosmics)
585  tool = CompFactory.Rec.MuidMaterialEffectsOnTrackProvider(name, **kwargs)
586  result.setPrivateTools(tool)
587  return result
588 
589 

◆ MuidMaterialEffectsOnTrackProviderParamCfg()

def python.MuonCombinedRecToolsConfig.MuidMaterialEffectsOnTrackProviderParamCfg (   flags,
  name = 'MuidMaterialEffectsOnTrackProviderParam',
**  kwargs 
)

Definition at line 590 of file MuonCombinedRecToolsConfig.py.

590 def MuidMaterialEffectsOnTrackProviderParamCfg(flags, name='MuidMaterialEffectsOnTrackProviderParam', **kwargs):
591  result = MuidCaloTrackStateOnSurfaceParamCfg(flags)
592  muidtsosparam = result.popPrivateTools()
593  kwargs.setdefault("TSOSTool", muidtsosparam)
594  kwargs.setdefault("TSOSToolParam", muidtsosparam)
595  kwargs.setdefault("Cosmics", flags.Beam.Type is BeamType.Cosmics)
596  tool = CompFactory.Rec.MuidMaterialEffectsOnTrackProvider(name, **kwargs)
597  result.setPrivateTools(tool)
598  return result
599 
600 

◆ MuidMuonRecoveryCfg()

def python.MuonCombinedRecToolsConfig.MuidMuonRecoveryCfg (   flags,
  name = 'MuidMuonRecovery',
**  kwargs 
)

Definition at line 868 of file MuonCombinedRecToolsConfig.py.

868 def MuidMuonRecoveryCfg(flags, name='MuidMuonRecovery', **kwargs):
869  result = AtlasExtrapolatorCfg(flags)
870  kwargs.setdefault("Extrapolator", result.popPrivateTools())
871  kwargs.setdefault("TrackBuilder", result.popToolsAndMerge(
872  CombinedMuonTrackBuilderCfg(flags)))
873 
874  if "ResidualPullCalculator" not in kwargs:
875  from TrkConfig.TrkResidualPullCalculatorConfig import (
876  ResidualPullCalculatorCfg)
877  kwargs.setdefault("ResidualPullCalculator", result.popToolsAndMerge(
878  ResidualPullCalculatorCfg(flags)))
879 
880  tool = CompFactory.Rec.MuidMuonRecovery(name, **kwargs)
881  result.setPrivateTools(tool)
882  return result
883 
884 

◆ MuidTrackCleanerCfg()

def python.MuonCombinedRecToolsConfig.MuidTrackCleanerCfg (   flags,
  name = 'MuidTrackCleaner',
**  kwargs 
)

Definition at line 444 of file MuonCombinedRecToolsConfig.py.

444 def MuidTrackCleanerCfg(flags, name='MuidTrackCleaner', **kwargs):
445  from MuonConfig.MuonRecToolsConfig import MuonTrackCleanerCfg
446  from TrkConfig.AtlasExtrapolatorConfig import AtlasExtrapolatorCfg
447  if flags.Beam.Type is BeamType.Cosmics:
448  kwargs.setdefault("PullCut", 5.0)
449  kwargs.setdefault("PullCutPhi", 10.0)
450  else:
451  kwargs.setdefault("PullCut", 4.0)
452  kwargs.setdefault("PullCutPhi", 4.0)
453  result = ComponentAccumulator()
454  if flags.Muon.MuonTrigger:
455  kwargs.setdefault("Iterate", False)
456  kwargs.setdefault("RecoverOutliers", False)
457  kwargs.setdefault("Fitter", result.popToolsAndMerge(
458  iPatFitterCfg(flags, 'iPatFitterClean', MaxIterations=4)))
459  else:
460  kwargs.setdefault(
461  "Fitter", result.popToolsAndMerge(iPatFitterCfg(flags)))
462  kwargs.setdefault(
463  "SLFitter", result.popToolsAndMerge(iPatSLFitterCfg(flags)))
464 
465  # For these following items, set back to default, because overridden in MuonTrackCleaner and we don't want overrides.
466  # ALL properties that are set in old-style are: PullCut, PullCutPhi, Iterate, RecoverOutliers, Fitter and iPatSLFitter
467  # However since there are defaults we still DO need to explicitly set, it's still probably easier to use MuonTrackCleanerCfg
468  kwargs.setdefault("MaxAvePullSumPerChamber", 3.5)
469  kwargs.setdefault("Chi2Cut", 100.0)
470  kwargs.setdefault("Extrapolator", result.getPrimaryAndMerge(
471  AtlasExtrapolatorCfg(flags)))
472  result.setPrivateTools(result.popToolsAndMerge(
473  MuonTrackCleanerCfg(flags, name, **kwargs)))
474  return result
475 
476 

◆ MuidTrackIsolationCfg()

def python.MuonCombinedRecToolsConfig.MuidTrackIsolationCfg (   flags,
  name = 'MuidTrackIsolation',
**  kwargs 
)

Definition at line 512 of file MuonCombinedRecToolsConfig.py.

512 def MuidTrackIsolationCfg(flags, name='MuidTrackIsolation', **kwargs):
513  from MagFieldServices.MagFieldServicesConfig import AtlasFieldCacheCondAlgCfg
514  kwargs.setdefault("InDetTracksLocation",
515  "CombinedInDetTracks" if flags.Detector.GeometryID else "CombinedITkTracks")
516  # RungeKuttaIntersector requires the magnetic field conditions
517  result = AtlasFieldCacheCondAlgCfg(flags)
518  tool = CompFactory.Rec.MuidTrackIsolation(name, **kwargs)
519  result.setPrivateTools(tool)
520  return result
521 
522 

◆ MuonAlignmentUncertToolPhiCfg()

def python.MuonCombinedRecToolsConfig.MuonAlignmentUncertToolPhiCfg (   flags,
  name = "MuonAlignmentUncertToolPhi",
**  kwargs 
)

Definition at line 683 of file MuonCombinedRecToolsConfig.py.

683 def MuonAlignmentUncertToolPhiCfg(flags, name="MuonAlignmentUncertToolPhi", **kwargs):
684  result = ComponentAccumulator()
685  kwargs.setdefault("HistoName", "PhiScattering")
686  from MuonConfig.MuonGeometryConfig import TrackingVolumesSvcCfg
687  kwargs.setdefault("TrackingVolumesSvc", result.getPrimaryAndMerge(TrackingVolumesSvcCfg(flags)))
688  kwargs.setdefault(
689  "InFile", "MuonCombinedBaseTools/AlignmentUncertainties/201029_initial/ID_MS_Uncertainties.root")
690  tool = CompFactory.Muon.MuonAlignmentUncertTool(name, **kwargs)
691  result.addPublicTool(tool)
692  return result
693 
694 
695 @AccumulatorCache

◆ MuonAlignmentUncertToolThetaCfg()

def python.MuonCombinedRecToolsConfig.MuonAlignmentUncertToolThetaCfg (   flags,
  name = "MuonAlignmentUncertToolTheta",
**  kwargs 
)

Definition at line 671 of file MuonCombinedRecToolsConfig.py.

671 def MuonAlignmentUncertToolThetaCfg(flags, name="MuonAlignmentUncertToolTheta", **kwargs):
672  result = ComponentAccumulator()
673  from MuonConfig.MuonGeometryConfig import TrackingVolumesSvcCfg
674  kwargs.setdefault("TrackingVolumesSvc", result.getPrimaryAndMerge(TrackingVolumesSvcCfg(flags)))
675  kwargs.setdefault("HistoName", "ThetaScattering")
676  kwargs.setdefault(
677  "InFile", "MuonCombinedBaseTools/AlignmentUncertainties/201029_initial/ID_MS_Uncertainties.root")
678  tool = CompFactory.Muon.MuonAlignmentUncertTool(name, **kwargs)
679  result.addPublicTool(tool)
680  return result
681 
682 

◆ MuonCaloEnergyToolCfg()

def python.MuonCombinedRecToolsConfig.MuonCaloEnergyToolCfg (   flags,
  name = "MuonCaloEnergyTool",
**  kwargs 
)

Definition at line 37 of file MuonCombinedRecToolsConfig.py.

37 def MuonCaloEnergyToolCfg(flags, name="MuonCaloEnergyTool", **kwargs):
38  from TrackToCalo.TrackToCaloConfig import ParticleCaloCellAssociationToolCfg, ParticleCaloExtensionToolCfg
39 
40  result = ParticleCaloExtensionToolCfg(
41  flags, name='MuonParticleCaloExtensionTool')
42  particle_calo_extension_tool = result.getPrimary()
43 
44  particle_calo_cell_association_tool = result.popToolsAndMerge(
45  ParticleCaloCellAssociationToolCfg(flags, name='MuonCaloCellAssociationTool', ParticleCaloExtensionTool=particle_calo_extension_tool))
46 
47  from TrkConfig.TrkParticleCreatorConfig import MuonCaloParticleCreatorCfg
48  track_particle_creator = result.popToolsAndMerge(
49  MuonCaloParticleCreatorCfg(flags))
50 
51  muonCaloEnergyTool = CompFactory.Rec.MuonCaloEnergyTool(name, ParticleCaloExtensionTool=particle_calo_extension_tool,
52  ParticleCaloCellAssociationTool=particle_calo_cell_association_tool,
53  TrackParticleCreator=track_particle_creator)
54  result.setPrivateTools(muonCaloEnergyTool)
55  return result
56 
57 

◆ MuonCaloTagToolCfg()

def python.MuonCombinedRecToolsConfig.MuonCaloTagToolCfg (   flags,
  name = 'MuonCaloTagTool',
**  kwargs 
)

Definition at line 940 of file MuonCombinedRecToolsConfig.py.

940 def MuonCaloTagToolCfg(flags, name='MuonCaloTagTool', **kwargs):
941  result = ComponentAccumulator()
942  kwargs.setdefault("CaloMuonTagLoose",
943  result.popToolsAndMerge(CaloMuonTagCfg(flags, name="CaloMuonTagLoose", TagMode="Loose")))
944  kwargs.setdefault("CaloMuonTagTight",
945  result.popToolsAndMerge(CaloMuonTagCfg(flags)))
946  kwargs.setdefault("CaloMuonLikelihoodTool",
947  result.popToolsAndMerge(CaloMuonLikelihoodToolCfg(flags)))
948  kwargs.setdefault("CaloMuonScoreTool",
949  result.popToolsAndMerge(CaloMuonScoreToolCfg(flags)))
950  kwargs.setdefault("TrackDepositInCaloTool",
951  result.popToolsAndMerge(TrackDepositInCaloToolCfg(flags)))
952  from InDetConfig.InDetTrackSelectorToolConfig import CaloTrkMuIdAlgTrackSelectorToolCfg
953  kwargs.setdefault("TrackSelectorTool",
954  result.popToolsAndMerge(CaloTrkMuIdAlgTrackSelectorToolCfg(flags)))
955  kwargs.setdefault("doCaloLR", False)
956  the_tool = CompFactory.MuonCombined.MuonCaloTagTool(name, **kwargs)
957  result.setPrivateTools(the_tool)
958  return result
959 
960 # Misc
961 
962 

◆ MuonCandidateToolCfg()

def python.MuonCombinedRecToolsConfig.MuonCandidateToolCfg (   flags,
  name = "MuonCandidateTool",
**  kwargs 
)

Definition at line 221 of file MuonCombinedRecToolsConfig.py.

221 def MuonCandidateToolCfg(flags, name="MuonCandidateTool", **kwargs):
222  from MuonConfig.MuonRecToolsConfig import MuonAmbiProcessorCfg
223  result = ComponentAccumulator()
224  muon_edm_printer = result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags))
225  kwargs.setdefault("Printer", muon_edm_printer)
226  if "TrackBuilder" not in kwargs:
227  kwargs.setdefault("TrackBuilder", result.popToolsAndMerge(
228  CombinedMuonTrackBuilderCfg(flags, name="CombinedMuonTrackBuilder")))
229  # Why was this dependent on cosmics? will now always create this
230  # if flags.Beam.Type is BeamType.Cosmics:
231  if flags.Muon.MuonTrigger and flags.Beam.Type is not BeamType.Cosmics:
232  # trigger definitely only uses the ExtrapolateToIPtool in cosmics mode
233  kwargs.setdefault("TrackExtrapolationTool", "")
234  else:
235  kwargs.setdefault("TrackExtrapolationTool", result.popToolsAndMerge(
236  ExtrapolateMuonToIPToolCfg(flags)))
237  kwargs.setdefault("SegmentContainer", "TrackMuonSegments")
238  kwargs.setdefault("AmbiguityProcessor", result.popToolsAndMerge(
239  MuonAmbiProcessorCfg(flags)))
240 
241  from TrkConfig.TrkTrackSummaryToolConfig import MuonTrackSummaryToolCfg
242  kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(
243  MuonTrackSummaryToolCfg(flags)))
244 
245  # MuonIDHelperSvc already configured
246 
247  if flags.Beam.Type is BeamType.Cosmics:
248  kwargs.setdefault("ExtrapolationStrategy", 1)
249 
250  track_segment_association_tool = CompFactory.MuonCombined.TrackSegmentAssociationTool(
251  MuonEDMPrinterTool=muon_edm_printer)
252  kwargs.setdefault("TrackSegmentAssociationTool",
253  track_segment_association_tool)
254  result.addPublicTool(track_segment_association_tool)
255 
256  tool = CompFactory.MuonCombined.MuonCandidateTool(name, **kwargs)
257  result.setPrivateTools(tool)
258  return result
259 
260 

◆ MuonCandidateTrackBuilderToolCfg()

def python.MuonCombinedRecToolsConfig.MuonCandidateTrackBuilderToolCfg (   flags,
  name = "MuonCandidateTrackBuilderTool",
**  kwargs 
)

Definition at line 1032 of file MuonCombinedRecToolsConfig.py.

1032 def MuonCandidateTrackBuilderToolCfg(flags, name="MuonCandidateTrackBuilderTool", **kwargs):
1033  result = CombinedMuonTrackBuilderCfg(flags)
1034  kwargs.setdefault("MuonTrackBuilder", result.popPrivateTools())
1035  muoncandidatetrackbuilder = CompFactory.Muon.MuonCandidateTrackBuilderTool(
1036  name, **kwargs)
1037  result.setPrivateTools(muoncandidatetrackbuilder)
1038  return result
1039 
1040 

◆ MuonCombinedDebuggerToolCfg()

def python.MuonCombinedRecToolsConfig.MuonCombinedDebuggerToolCfg (   flags,
  name = "MuonCombinedDebuggerTool",
**  kwargs 
)

Definition at line 261 of file MuonCombinedRecToolsConfig.py.

261 def MuonCombinedDebuggerToolCfg(flags, name="MuonCombinedDebuggerTool", **kwargs):
262  result = ComponentAccumulator()
263  match_quality = CompFactory.Rec.MuonMatchQuality(
264  TrackQuery=result.popToolsAndMerge(MuonTrackQueryCfg(flags)))
265  kwargs.setdefault("MuonMatchQuality", match_quality)
266  tool = CompFactory.MuonCombined.MuonCombinedDebuggerTool(name, **kwargs)
267  result.setPrivateTools(tool)
268  return result
269 
270 

◆ MuonCombinedFitTagToolCfg()

def python.MuonCombinedRecToolsConfig.MuonCombinedFitTagToolCfg (   flags,
  name = "MuonCombinedFitTagTool",
**  kwargs 
)

Definition at line 300 of file MuonCombinedRecToolsConfig.py.

300 def MuonCombinedFitTagToolCfg(flags, name="MuonCombinedFitTagTool", **kwargs):
301  if flags.Muon.MuonTrigger:
302  kwargs.setdefault("VertexContainer", "")
303 
304  result = ComponentAccumulator()
305  kwargs.setdefault("TrackBuilder", result.popToolsAndMerge(
306  CombinedMuonTrackBuilderCfg(flags)))
307 
308  kwargs.setdefault("Printer", result.getPrimaryAndMerge(
309  MuonEDMPrinterToolCfg(flags)))
310 
311  kwargs.setdefault("TrackQuery", result.popToolsAndMerge(
312  MuonTrackQueryCfg(flags)))
313  kwargs.setdefault("MatchQuality", result.popToolsAndMerge(
314  MuonMatchQualityCfg(flags)))
315 
316  from MuonConfig.MuonRecToolsConfig import MuonTrackScoringToolCfg
317  kwargs.setdefault("TrackScoringTool", result.popToolsAndMerge(
318  MuonTrackScoringToolCfg(flags)))
319 
320  tool = CompFactory.MuonCombined.MuonCombinedFitTagTool(name, **kwargs)
321  result.setPrivateTools(tool)
322  return result
323 
324 

◆ MuonCombinedStacoTagToolCfg()

def python.MuonCombinedRecToolsConfig.MuonCombinedStacoTagToolCfg (   flags,
  name = "MuonCombinedStacoTagTool",
**  kwargs 
)

Definition at line 365 of file MuonCombinedRecToolsConfig.py.

365 def MuonCombinedStacoTagToolCfg(flags, name="MuonCombinedStacoTagTool", **kwargs):
366 
367  result = ComponentAccumulator()
368  kwargs.setdefault("Printer", result.getPrimaryAndMerge(
369  MuonEDMPrinterToolCfg(flags)))
370  kwargs.setdefault("TagTool", result.popToolsAndMerge(
371  CombinedMuonTagTestToolCfg(flags)))
372  kwargs.setdefault("Extrapolator", result.popToolsAndMerge(
373  AtlasExtrapolatorCfg(flags)))
374 
375  tool = CompFactory.MuonCombined.MuonCombinedStacoTagTool(name, **kwargs)
376  result.setPrivateTools(tool)
377  return result
378 
379 # From Combined fit tools.py
380 
381 

◆ MuonCombinedToolCfg()

def python.MuonCombinedRecToolsConfig.MuonCombinedToolCfg (   flags,
  name = "MuonCombinedTool",
**  kwargs 
)

Definition at line 271 of file MuonCombinedRecToolsConfig.py.

271 def MuonCombinedToolCfg(flags, name="MuonCombinedTool", **kwargs):
272  tools = []
273  result = ComponentAccumulator()
274  kwargs.setdefault("Printer", result.getPrimaryAndMerge(
275  MuonEDMPrinterToolCfg(flags)))
276 
277  if flags.MuonCombined.doCombinedFit:
278  tool = result.popToolsAndMerge(MuonCombinedFitTagToolCfg(flags))
279  tools.append(tool)
280  if flags.MuonCombined.doStatisticalCombination and flags.Beam.Type is not BeamType.Cosmics:
281  tool = result.popToolsAndMerge(MuonCombinedStacoTagToolCfg(flags))
282  tools.append(tool)
283 
284  kwargs.setdefault("MuonCombinedTagTools", tools)
285  kwargs.setdefault("MuonCombinedDebuggerTool", result.popToolsAndMerge(
286  MuonCombinedDebuggerToolCfg(flags)))
287 
288  acc = MuonAlignmentUncertToolThetaCfg(flags)
289  result.merge(acc)
290  kwargs.setdefault("AlignmentUncertTool", result.getPublicTool(
291  'MuonAlignmentUncertToolTheta'))
292 
293  kwargs.setdefault("DeltaEtaPreSelection", 0.2)
294  kwargs.setdefault("DeltaPhiPreSelection", 0.2)
295  tool = CompFactory.MuonCombined.MuonCombinedTool(name, **kwargs)
296  result.setPrivateTools(tool)
297  return result
298 
299 

◆ MuonCreatorToolCfg()

def python.MuonCombinedRecToolsConfig.MuonCreatorToolCfg (   flags,
  name = "MuonCreatorTool",
**  kwargs 
)

Definition at line 138 of file MuonCombinedRecToolsConfig.py.

138 def MuonCreatorToolCfg(flags, name="MuonCreatorTool", **kwargs):
139  from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg
140  result = ComponentAccumulator()
141  # Not explicitly setting up MuonIdHelperSvc, nor MuonEDMHelperSvc (configured in top level reco Cfg)
142  muon_edm_printer = result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags))
143  kwargs.setdefault("Printer", muon_edm_printer)
144 
145  kwargs.setdefault("MuonPrinter", CompFactory.Rec.MuonPrintingTool(name='MuonPrintingTool',
146  MuonStationPrinter=muon_edm_printer))
147 
148  kwargs.setdefault("ParticleCaloExtensionTool",
149  result.popToolsAndMerge(ParticleCaloExtensionToolCfg(flags,
150  name='MuonParticleCaloExtensionTool',
151  StartFromPerigee=True)))
152 
153  from TrkConfig.TrkParticleCreatorConfig import MuonCombinedParticleCreatorCfg
154  kwargs.setdefault("TrackParticleCreator", result.popToolsAndMerge(
155  MuonCombinedParticleCreatorCfg(flags)))
156 
157  from MuonConfig.MuonRecToolsConfig import MuonAmbiProcessorCfg
158  kwargs.setdefault("AmbiguityProcessor", result.popToolsAndMerge(
159  MuonAmbiProcessorCfg(flags)))
160 
161  from TrkConfig.TrkExRungeKuttaPropagatorConfig import RungeKuttaPropagatorCfg
162  kwargs.setdefault("Propagator", result.popToolsAndMerge(
163  RungeKuttaPropagatorCfg(flags)))
164  kwargs.setdefault("MuonDressingTool", result.popToolsAndMerge(
165  MuonDressingToolCfg(flags)))
166  # Not explicitly setting up MomentumBalanceTool nor ScatteringAngleTool
167  # Not explicitly setting up MeanMDTdADCTool (but probably should FIXME)
168 
169  kwargs.setdefault("CaloMaterialProvider", result.popToolsAndMerge(
170  MuonMaterialProviderToolCfg(flags)))
171 
172  kwargs.setdefault("TrackQuery", result.popToolsAndMerge(
173  MuonTrackQueryCfg(flags)))
174  # runCommissioningChain
175  if flags.Muon.SAMuonTrigger:
176  from TrkConfig.TrkTrackSummaryToolConfig import MuonTrackSummaryToolCfg
177  kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(
178  MuonTrackSummaryToolCfg(flags)))
179  else:
180  from TrkConfig.TrkTrackSummaryToolConfig import MuonCombinedTrackSummaryToolCfg
181  kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(
182  MuonCombinedTrackSummaryToolCfg(flags)))
183 
184  if flags.Muon.MuonTrigger:
185  kwargs.setdefault("MuonSelectionTool", "")
186  kwargs.setdefault("UseCaloCells", False)
187  kwargs.setdefault("CopyUInt8SummaryKeys", [])
188  else:
189  from MuonSelectorTools.MuonSelectorToolsConfig import MuonSelectionToolCfg
190  kwargs.setdefault("MuonSelectionTool", result.popToolsAndMerge(
191  MuonSelectionToolCfg(flags, name='MuonRecoSelTool')))
192  kwargs.setdefault("RequireMSOEforSA", flags.Beam.Type is BeamType.Collisions)
193  kwargs.setdefault("RequireCaloForSA", flags.Beam.Type is BeamType.Collisions)
194 
195  tool = CompFactory.MuonCombined.MuonCreatorTool(name, **kwargs)
196  result.setPrivateTools(tool)
197  return result
198 
199 

◆ MuonDressingToolCfg()

def python.MuonCombinedRecToolsConfig.MuonDressingToolCfg (   flags,
  name = "MuonDressingTool",
**  kwargs 
)

Definition at line 128 of file MuonCombinedRecToolsConfig.py.

128 def MuonDressingToolCfg(flags, name="MuonDressingTool", **kwargs):
129  from MuonConfig.MuonRecToolsConfig import MuonHitSummaryToolCfg
130  result = MuonHitSummaryToolCfg(flags)
131  kwargs.setdefault("MuonHitSummaryTool", result.popPrivateTools())
132  # HitTimingTool does not need specific configuration
133  tool = CompFactory.MuonCombined.MuonDressingTool(name, **kwargs)
134  result.setPrivateTools(tool)
135  return result
136 
137 

◆ MuonInDetForwardCandidateToolCfg()

def python.MuonCombinedRecToolsConfig.MuonInDetForwardCandidateToolCfg (   flags,
  name = 'InDetForwardCandidateTool',
**  kwargs 
)

Definition at line 27 of file MuonCombinedRecToolsConfig.py.

27 def MuonInDetForwardCandidateToolCfg(flags, name='InDetForwardCandidateTool', **kwargs):
28  from InDetConfig.InDetTrackSelectorToolConfig import MuonCombinedInDetDetailedForwardTrackSelectorToolCfg
29  result = MuonCombinedInDetDetailedForwardTrackSelectorToolCfg(flags)
30  kwargs.setdefault("TrackSelector", result.popPrivateTools())
31  kwargs.setdefault("FlagCandidatesAsSiAssociated", True)
32  result.setPrivateTools(result.popToolsAndMerge(
33  InDetCandidateToolCfg(flags, name, **kwargs)))
34  return result # FIXME - is this and the above, actually used?
35 
36 

◆ MuonInsideOutRecoToolCfg()

def python.MuonCombinedRecToolsConfig.MuonInsideOutRecoToolCfg (   flags,
  name = "MuonInsideOutRecoTool",
**  kwargs 
)

Definition at line 1004 of file MuonCombinedRecToolsConfig.py.

1004 def MuonInsideOutRecoToolCfg(flags, name="MuonInsideOutRecoTool", **kwargs):
1005  from MuonConfig.MuonRecToolsConfig import MuonAmbiProcessorCfg
1006  if flags.Muon.MuonTrigger:
1007  kwargs.setdefault("VertexContainer", "")
1008  result = ComponentAccumulator()
1009  kwargs.setdefault("MuonEDMPrinterTool", result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags)))
1010  layersegmentfindertool = result.popToolsAndMerge(
1011  MuonLayerSegmentFinderToolCfg(flags, name="MuonLayerSegmentFinderTool"))
1012  kwargs.setdefault("MuonLayerSegmentFinderTool", layersegmentfindertool)
1013  kwargs.setdefault("MuonLayerSegmentMatchingTool", result.popToolsAndMerge(
1014  MuonLayerSegmentMatchingToolCfg(flags)))
1015  kwargs.setdefault("MuonLayerAmbiguitySolverTool", result.popToolsAndMerge(
1016  MuonLayerAmbiguitySolverToolCfg(flags)))
1017  kwargs.setdefault("MuonCandidateTrackBuilderTool", result.popToolsAndMerge(
1018  MuonCandidateTrackBuilderToolCfg(flags)))
1019  from TrkConfig.TrkTrackSummaryToolConfig import MuonCombinedTrackSummaryToolCfg
1020  kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(
1021  MuonCombinedTrackSummaryToolCfg(flags)))
1022  kwargs.setdefault("MuonTrackBuilder", result.popToolsAndMerge(
1023  CombinedMuonTrackBuilderCfg(flags)))
1024  kwargs.setdefault("TrackAmbiguityProcessor",
1025  result.popToolsAndMerge(MuonAmbiProcessorCfg(flags)))
1026 
1027  tool = CompFactory.MuonCombined.MuonInsideOutRecoTool(name, **kwargs)
1028  result.setPrivateTools(tool)
1029  return result
1030 
1031 

◆ MuonLayerAmbiguitySolverToolCfg()

def python.MuonCombinedRecToolsConfig.MuonLayerAmbiguitySolverToolCfg (   flags,
  name = "MuonLayerAmbiguitySolverTool",
**  kwargs 
)

Definition at line 1059 of file MuonCombinedRecToolsConfig.py.

1059 def MuonLayerAmbiguitySolverToolCfg(flags, name="MuonLayerAmbiguitySolverTool", **kwargs):
1060  from MuonConfig.MuonTrackBuildingConfig import MuonSegmentMatchingToolCfg, MooTrackBuilderCfg
1061  result = MuonSegmentSelectionToolCfg(flags)
1062  kwargs.setdefault("MuonSegmentSelectionTool", result.popPrivateTools())
1063  kwargs.setdefault("MuonSegmentMatchingTool", result.popToolsAndMerge(
1064  MuonSegmentMatchingToolCfg(flags, name='MuonSegmentMatchingToolTight', TightSegmentMatching=True)))
1065 
1066  kwargs.setdefault("MuonSegmentTrackBuilder",
1067  result.popToolsAndMerge(MooTrackBuilderCfg(flags, name='MooMuonTrackBuilder', prefix='MuSt_')))
1068  kwargs.setdefault("MuonEDMPrinterTool", result.getPrimaryAndMerge(
1069  MuonEDMPrinterToolCfg(flags)))
1070 
1071  result.setPrivateTools(
1072  CompFactory.Muon.MuonLayerAmbiguitySolverTool(name, **kwargs))
1073  return result
1074 
1075 

◆ MuonLayerSegmentFinderToolCfg()

def python.MuonCombinedRecToolsConfig.MuonLayerSegmentFinderToolCfg (   flags,
  name = "MuonLayerSegmentFinderTool",
**  kwargs 
)

Definition at line 963 of file MuonCombinedRecToolsConfig.py.

963 def MuonLayerSegmentFinderToolCfg(flags, name="MuonLayerSegmentFinderTool", **kwargs):
964  from MuonConfig.MuonSegmentFindingConfig import DCMathSegmentMakerCfg, MuonNSWSegmentFinderToolCfg, MuonPRDSelectionToolCfg
965  result = ComponentAccumulator()
966 
967  from MuonConfig.MuonSegmentFindingConfig import Csc2dSegmentMakerCfg, Csc4dSegmentMakerCfg
968  kwargs.setdefault("Csc2DSegmentMaker", result.popToolsAndMerge(
969  Csc2dSegmentMakerCfg(flags)) if flags.Detector.GeometryCSC else "")
970  kwargs.setdefault("Csc4DSegmentMaker", result.popToolsAndMerge(
971  Csc4dSegmentMakerCfg(flags)) if flags.Detector.GeometryCSC else "")
972 
973  kwargs.setdefault("MuonPRDSelectionTool", result.popToolsAndMerge(
974  MuonPRDSelectionToolCfg(flags)))
975  kwargs.setdefault("SegmentMaker", result.popToolsAndMerge(
976  DCMathSegmentMakerCfg(flags, name="DCMathSegmentMaker")))
977  kwargs.setdefault("NSWMuonClusterSegmentFinderTool",
978  result.popToolsAndMerge(MuonNSWSegmentFinderToolCfg(flags, name="MuonNSWSegmentFinderTool")))
979 
980 
981  from AthenaConfiguration.Enums import LHCPeriod
982  if flags.GeoModel.Run < LHCPeriod.Run3 or flags.Muon.MuonTrigger:
983  kwargs.setdefault("InSegmentContainer", "")
984  kwargs.setdefault("MuonLayerSegmentMatchingTool", "")
985  else:
986  kwargs.setdefault("MuonLayerSegmentMatchingTool", result.popToolsAndMerge(
987  MuonLayerSegmentMatchingToolCfg(flags)))
988  tool = CompFactory.Muon.MuonLayerSegmentFinderTool(name, **kwargs)
989  result.setPrivateTools(tool)
990  return result
991 
992 

◆ MuonLayerSegmentMatchingToolCfg()

def python.MuonCombinedRecToolsConfig.MuonLayerSegmentMatchingToolCfg (   flags,
  name = "MuonLayerSegmentMatchingTool",
**  kwargs 
)

Definition at line 993 of file MuonCombinedRecToolsConfig.py.

993 def MuonLayerSegmentMatchingToolCfg(flags, name="MuonLayerSegmentMatchingTool", **kwargs):
994  result = AtlasExtrapolatorCfg(flags)
995  kwargs.setdefault("Extrapolator", result.popPrivateTools())
996  MuTagTool = result.getPrimaryAndMerge(MuTagMatchingToolCfg(flags))
997  kwargs.setdefault("MatchTool", MuTagTool)
998 
999  tool = CompFactory.Muon.MuonLayerSegmentMatchingTool(name, **kwargs)
1000  result.setPrivateTools(tool)
1001  return result
1002 
1003 

◆ MuonMatchQualityCfg()

def python.MuonCombinedRecToolsConfig.MuonMatchQualityCfg (   flags,
  name = 'MuonMatchQuality',
**  kwargs 
)

Definition at line 857 of file MuonCombinedRecToolsConfig.py.

857 def MuonMatchQualityCfg(flags, name='MuonMatchQuality', **kwargs):
858  result = CombinedMuonTagTestToolCfg(flags)
859  kwargs.setdefault("TagTool", result.popPrivateTools())
860  kwargs.setdefault("TrackQuery", result.popToolsAndMerge(
861  MuonTrackQueryCfg(flags)))
862 
863  tool = CompFactory.Rec.MuonMatchQuality(name, **kwargs)
864  result.setPrivateTools(tool)
865  return result
866 
867 

◆ MuonMaterialProviderToolCfg()

def python.MuonCombinedRecToolsConfig.MuonMaterialProviderToolCfg (   flags,
  name = "MuonTrkMaterialProviderTool",
**  kwargs 
)

Definition at line 58 of file MuonCombinedRecToolsConfig.py.

58 def MuonMaterialProviderToolCfg(flags, name="MuonTrkMaterialProviderTool", **kwargs):
59  from TrackingGeometryCondAlg.AtlasTrackingGeometryCondAlgConfig import TrackingGeometryCondAlgCfg
60  from TrkConfig.AtlasExtrapolatorToolsConfig import AtlasMultipleScatteringUpdatorCfg
61 
62  result = AtlasExtrapolatorCfg(flags)
63  atlas_extrapolator = result.popPrivateTools()
64  kwargs.setdefault("Extrapolator", atlas_extrapolator)
65  result.addPublicTool(atlas_extrapolator)
66  kwargs.setdefault("MuonCaloEnergyTool", result.popToolsAndMerge(
67  MuonCaloEnergyToolCfg(flags, name="MuonCaloEnergyTool")))
68 
69  # MuonCaloEnergyTool is actually a private tool
70  calo_meas_tool = result.popToolsAndMerge(MuidCaloEnergyMeasCfg(flags))
71  kwargs.setdefault("CaloMeasTool", calo_meas_tool)
72  result.addPublicTool(calo_meas_tool)
73 
74  calo_param_tool = MuidCaloEnergyParam(flags)
75  kwargs.setdefault("CaloParamTool", calo_param_tool)
76  result.addPublicTool(calo_param_tool)
77 
78  multiple_scattering_tool = result.popToolsAndMerge(
79  AtlasMultipleScatteringUpdatorCfg(flags))
80  kwargs.setdefault("MultipleScatteringTool", multiple_scattering_tool)
81  result.addPublicTool(multiple_scattering_tool)
82 
83  useCaloEnergyMeas = True
84  if flags.Muon.MuonTrigger:
85  useCaloEnergyMeas = False
86  kwargs.setdefault("UseCaloEnergyMeasurement", useCaloEnergyMeas)
87  acc = TrackingGeometryCondAlgCfg(flags)
88  kwargs.setdefault("TrackingGeometryReadKey",
89  acc.getPrimary().TrackingGeometryWriteKey)
90  result.merge(acc)
91 
92  energy_loss_updator = result.popToolsAndMerge(
93  AtlasEnergyLossUpdatorCfg(flags))
94  kwargs.setdefault("EnergyLossUpdator",
95  energy_loss_updator) # PublicToolHandle
96  result.addPublicTool(energy_loss_updator)
97 
98  track_isolation_tool = result.popToolsAndMerge(
99  MuidTrackIsolationCfg(flags))
100  kwargs.setdefault("TrackIsolationTool", track_isolation_tool)
101  result.addPublicTool(track_isolation_tool)
102 
103  tool = CompFactory.Trk.TrkMaterialProviderTool(name=name, **kwargs)
104  result.setPrivateTools(tool)
105  return result
106 
107 

◆ MuonSegmentConverterToolCfg()

def python.MuonCombinedRecToolsConfig.MuonSegmentConverterToolCfg (   flags,
  name = "MuonSegmentConverterTool",
**  kwargs 
)

Definition at line 119 of file MuonCombinedRecToolsConfig.py.

119 def MuonSegmentConverterToolCfg(flags, name="MuonSegmentConverterTool", **kwargs):
120  result = MuonSegmentHitSummaryToolCfg(flags)
121  kwargs.setdefault("MuonSegmentHitSummaryTool", result.popPrivateTools())
122  # HitTimingTool does not need specific configuration
123  tool = CompFactory.Muon.MuonSegmentConverterTool(name, **kwargs)
124  result.setPrivateTools(tool)
125  return result
126 
127 

◆ MuonSegmentHitSummaryToolCfg()

def python.MuonCombinedRecToolsConfig.MuonSegmentHitSummaryToolCfg (   flags,
  name = "MuonSegmentHitSummaryTool",
**  kwargs 
)

Definition at line 108 of file MuonCombinedRecToolsConfig.py.

108 def MuonSegmentHitSummaryToolCfg(flags, name="MuonSegmentHitSummaryTool", **kwargs):
109  from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
110  result = ComponentAccumulator()
111  kwargs.setdefault("Printer", result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags)))
112  result.merge(MuonGeoModelCfg(flags))
113  kwargs.setdefault("DetectorManagerKey", "MuonDetectorManager")
114  tool = CompFactory.Muon.MuonSegmentHitSummaryTool(name, **kwargs)
115  result.setPrivateTools(tool)
116  return result
117 
118 

◆ MuonSegmentSelectionToolCfg()

def python.MuonCombinedRecToolsConfig.MuonSegmentSelectionToolCfg (   flags,
  name = "MuonSegmentSelectionTool",
**  kwargs 
)

Definition at line 1041 of file MuonCombinedRecToolsConfig.py.

1041 def MuonSegmentSelectionToolCfg(flags, name="MuonSegmentSelectionTool", **kwargs):
1042  if flags.Input.isMC is False:
1043  kwargs.setdefault("GoodADCFractionCut", 0.5)
1044  kwargs.setdefault("MinADCPerSegmentCut", 100)
1045  result = ComponentAccumulator()
1046  kwargs.setdefault("Printer", result.getPrimaryAndMerge(
1047  MuonEDMPrinterToolCfg(flags)))
1048  muon_segment_hit_summary_tool = result.popToolsAndMerge(
1049  MuonSegmentHitSummaryToolCfg(flags))
1050  kwargs.setdefault("MuonSegmentHitSummaryTool",
1051  muon_segment_hit_summary_tool)
1052  result.addPublicTool(muon_segment_hit_summary_tool)
1053 
1054  result.setPrivateTools(
1055  CompFactory.Muon.MuonSegmentSelectionTool(name, **kwargs))
1056  return result
1057 
1058 

◆ MuonSegmentTagToolCfg()

def python.MuonCombinedRecToolsConfig.MuonSegmentTagToolCfg (   flags,
  name = "MuonSegmentTagTool",
**  kwargs 
)

Definition at line 1239 of file MuonCombinedRecToolsConfig.py.

1239 def MuonSegmentTagToolCfg(flags, name="MuonSegmentTagTool", **kwargs):
1240  result = ComponentAccumulator()
1241  mu_tag_matching = result.getPrimaryAndMerge(MuTagMatchingToolCfg(flags))
1242  kwargs.setdefault("MuTagMatchingTool", mu_tag_matching)
1243 
1244  kwargs.setdefault("Printer", result.getPrimaryAndMerge(
1245  MuonEDMPrinterToolCfg(flags)))
1246  kwargs.setdefault("MuTagAmbiguitySolverTool", result.getPrimaryAndMerge(
1247  MuTagAmbiguitySolverToolCfg(flags)))
1248  kwargs.setdefault("MuonSegmentSelectionTool", result.getPrimaryAndMerge(
1249  MuonSegmentSelectionToolCfg(flags)))
1250  kwargs.setdefault("MuonSegmentHitSummaryTool", result.getPrimaryAndMerge(
1251  MuonSegmentHitSummaryToolCfg(flags)))
1252 
1253  result.setPrivateTools(
1254  CompFactory.MuonCombined.MuonSegmentTagTool(name, **kwargs))
1255  return result

◆ MuonStauRecoToolCfg()

def python.MuonCombinedRecToolsConfig.MuonStauRecoToolCfg (   flags,
  name = "MuonStauRecoTool",
**  kwargs 
)

Definition at line 1086 of file MuonCombinedRecToolsConfig.py.

1086 def MuonStauRecoToolCfg(flags, name="MuonStauRecoTool", **kwargs):
1087  # In the old configuration this was split over several functions. But since these Stau tools are only used here,
1088  # trying a new approach. We can always refactorise later if necessary.
1089  from MuonConfig.MuonSegmentFindingConfig import DCMathSegmentMakerCfg, MuonPRDSelectionToolCfg
1090  from MuonConfig.MuonTrackBuildingConfig import MuonChamberHoleRecoveryToolCfg
1091  from MuonConfig.MuonRecToolsConfig import MuonAmbiProcessorCfg, MuonSeededSegmentFinderCfg
1092  from MuonConfig.MuonRIO_OnTrackCreatorToolConfig import MdtDriftCircleOnTrackCreatorCfg
1093  from MuonConfig.MuonSegmentFindingConfig import MuonLayerHoughAlgCfg
1094  kwargs.setdefault("DoSummary", flags.Muon.printSummary)
1095  kwargs.setdefault("ConsideredPDGs", [13, -13, 1000015, -1000015])
1096  kwargs.setdefault("DoTruth", flags.Input.isMC)
1097 
1098  result = ComponentAccumulator()
1099  result.merge(MuonLayerHoughAlgCfg(flags))
1100  # Not setting up MuonIdHelperSvc nor MuonEDMHelperSvc
1101  kwargs.setdefault("MuonEDMPrinterTool", result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags)))
1102  kwargs.setdefault("MuonPRDSelectionTool", result.popToolsAndMerge(MuonPRDSelectionToolCfg(flags)))
1103 
1104  # This is going to be used in a few tools below
1105  staurotcreator = result.popToolsAndMerge(MdtDriftCircleOnTrackCreatorStauCfg(flags))
1106  kwargs.setdefault("MuonPRDSelectionToolStau",
1107  result.popToolsAndMerge(MuonPRDSelectionToolCfg(flags,
1108  "MuonPRDSelectionToolStau",
1109  MdtDriftCircleOnTrackCreator=staurotcreator)))
1110 
1111  segmentmaker = result.popToolsAndMerge(DCMathSegmentMakerCfg(
1112  flags, name="DCMathStauSegmentMaker", MdtCreator=staurotcreator))
1113  # segmentmaker also used by MuonSeededSegmentFinder below
1114  kwargs.setdefault("MuonSegmentMaker", segmentmaker)
1115  kwargs.setdefault("MuonSegmentMakerT0Fit", result.popToolsAndMerge(DCMathSegmentMakerCfg(
1116  flags, name="DCMathT0FitSegmentMaker", doSegmentT0Fit=True)))
1117  # ^ doSegmentT0Fit overrides several defaults, including MdtCreatorT0 and MdtSegmentFinder
1118 
1119  kwargs.setdefault("MuonLayerSegmentMatchingTool", result.popToolsAndMerge(
1120  MuonLayerSegmentMatchingToolCfg(flags)))
1121 
1122  # Not configuring MuonRecoValidationTool as it is off by default, but it would need configuring if used
1123  kwargs.setdefault("TrackAmbiguityProcessor",
1124  result.popToolsAndMerge(MuonAmbiProcessorCfg(flags)))
1125  # I don't believe MuonHitTimingTool needs configuration.
1126  kwargs.setdefault("MuonPRDSelectionTool", result.popToolsAndMerge(
1127  MuonPRDSelectionToolCfg(flags)))
1128  kwargs.setdefault("MuonPRDSelectionToolStau", result.popToolsAndMerge(
1129  MuonPRDSelectionToolCfg(flags, MdtDriftCircleOnTrackCreator=staurotcreator)))
1130  kwargs.setdefault("MdtDriftCircleOnTrackCreator", result.popToolsAndMerge(
1131  MdtDriftCircleOnTrackCreatorCfg(flags)))
1132  kwargs.setdefault("MdtDriftCircleOnTrackCreatorStau", staurotcreator)
1133  # Now setup MuonInsideOutRecoTool property of MuonStauRecoTool. Long chain here! Could split for clarity. Another option would be to have a Stau flag on
1134  # shared tool functions.
1135  chamberholerecoverytool = result.popToolsAndMerge(MuonChamberHoleRecoveryToolCfg(flags,
1136  sTgcPrepDataContainer="",
1137  MMPrepDataContainer=""))
1138  seededsegmentfinder = result.popToolsAndMerge(MuonSeededSegmentFinderCfg(flags, name="MuonStauSeededSegmentFinder", MdtRotCreator=staurotcreator,
1139  SegmentMaker=segmentmaker, SegmentMakerNoHoles=segmentmaker))
1140  fitter = result.popToolsAndMerge(CombinedMuonTrackBuilderFitCfg(
1141  flags, name="CombinedStauTrackBuilderFit", MdtRotCreator=staurotcreator))
1142  from TrkConfig.TrkTrackSummaryToolConfig import MuonCombinedTrackSummaryToolCfg
1143  muon_combined_track_summary = result.popToolsAndMerge(
1144  MuonCombinedTrackSummaryToolCfg(flags))
1145  muidsegmentregionrecovery = result.popToolsAndMerge(MuonSegmentRegionRecoveryToolCfg(flags, name="MuonStauSegmentRegionRecoveryTool", SeededSegmentFinder=seededsegmentfinder,
1146  RecoverMM=False, RecoverSTGC=False, MMRegionSelector="", STGCRegionSelector="",
1147  ChamberHoleRecoveryTool=chamberholerecoverytool, Fitter=fitter, TrackSummaryTool=muon_combined_track_summary))
1148  trackbuilder = result.popToolsAndMerge(CombinedMuonTrackBuilderCfg(
1149  flags, name="CombinedStauTrackBuilder", MdtRotCreator=staurotcreator, MuonHoleRecovery=muidsegmentregionrecovery))
1150  muoncandidatetrackbuilder = CompFactory.Muon.MuonCandidateTrackBuilderTool(
1151  name="MuonStauCandidateTrackBuilderTool", MuonTrackBuilder=trackbuilder)
1152  kwargs.setdefault("MuonInsideOutRecoTool", result.popToolsAndMerge(
1153  MuonInsideOutRecoToolCfg(flags, name='MuonStauInsideOutRecoTool', MuonCandidateTrackBuilderTool=muoncandidatetrackbuilder)))
1154  # Rest
1155 
1156  tool = CompFactory.MuonCombined.MuonStauRecoTool(name, **kwargs)
1157  result.setPrivateTools(tool)
1158  return result
1159 
1160 

◆ MuonSystemExtensionToolCfg()

def python.MuonCombinedRecToolsConfig.MuonSystemExtensionToolCfg (   flags,
**  kwargs 
)

Definition at line 1161 of file MuonCombinedRecToolsConfig.py.

1161 def MuonSystemExtensionToolCfg(flags, **kwargs):
1162  result = ComponentAccumulator()
1163 
1164  from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg
1165  from MuonConfig.MuonRecToolsConfig import MuonEDMPrinterToolCfg
1166 
1167  kwargs.setdefault("Extrapolator", result.popToolsAndMerge(AtlasExtrapolatorCfg(flags)))
1168  kwargs.setdefault("Printer", result.addPublicTool(result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags))) )
1169  kwargs.setdefault("ParticleCaloExtensionTool",
1170  result.popToolsAndMerge(ParticleCaloExtensionToolCfg(flags,
1171  name='MuonParticleCaloExtensionTool')))
1172 
1173 
1174  muon_ext_tool = CompFactory.Muon.MuonSystemExtensionTool("MuonSystemExtensionTool", **kwargs)
1175  result.setPrivateTools(muon_ext_tool)
1176  return result
1177 
1178 

◆ MuonTrackQueryCfg()

def python.MuonCombinedRecToolsConfig.MuonTrackQueryCfg (   flags,
  name = "MuonTrackQuery",
**  kwargs 
)

Definition at line 601 of file MuonCombinedRecToolsConfig.py.

601 def MuonTrackQueryCfg(flags, name="MuonTrackQuery", **kwargs):
602  from MuonConfig.MuonRIO_OnTrackCreatorToolConfig import MdtDriftCircleOnTrackCreatorCfg
603  result = MdtDriftCircleOnTrackCreatorCfg(flags)
604  kwargs.setdefault("MdtRotCreator", result.popPrivateTools())
605  from TrackingGeometryCondAlg.AtlasTrackingGeometryCondAlgConfig import TrackingGeometryCondAlgCfg
606  result.merge(TrackingGeometryCondAlgCfg(flags))
607  kwargs.setdefault("TrackingGeometryReadKey", "AtlasTrackingGeometry")
608 
609  acc = iPatFitterCfg(flags)
610  kwargs.setdefault("Fitter", acc.popPrivateTools())
611  result.merge(acc)
612 
613  tool = CompFactory.Rec.MuonTrackQuery(name, **kwargs)
614  result.setPrivateTools(tool)
615  return result
616 
617 

◆ MuTagAmbiguitySolverToolCfg()

def python.MuonCombinedRecToolsConfig.MuTagAmbiguitySolverToolCfg (   flags,
  name = 'MuTagAmbiguitySolverTool',
**  kwargs 
)

Definition at line 1223 of file MuonCombinedRecToolsConfig.py.

1223 def MuTagAmbiguitySolverToolCfg(flags, name='MuTagAmbiguitySolverTool', **kwargs):
1224  from MuonConfig.MuonTrackBuildingConfig import MuonSegmentMatchingToolCfg
1225  #TODO: defaults in cxx
1226  kwargs.setdefault("RejectOuterEndcap", True)
1227  kwargs.setdefault("RejectMatchPhi", True)
1228  result = ComponentAccumulator()
1229  kwargs.setdefault("Printer", result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags)))
1230  kwargs.setdefault("MuonSegmentMatchingTool", result.popToolsAndMerge(
1231  MuonSegmentMatchingToolCfg(flags, name='MuonSegmentMatchingTool', doPhiMatching=False)))
1232  # EJWM. Not sure where doPhiMatching is set to False in old, but this is what I see in configuration diffs
1233 
1234  tool = CompFactory.MuTagAmbiguitySolverTool(name, **kwargs)
1235  result.addPublicTool(tool, primary=True)
1236  return result
1237 
1238 

◆ MuTagMatchingToolCfg()

def python.MuonCombinedRecToolsConfig.MuTagMatchingToolCfg (   flags,
  name = 'MuTagMatchingTool',
**  kwargs 
)

Definition at line 1179 of file MuonCombinedRecToolsConfig.py.

1179 def MuTagMatchingToolCfg(flags, name='MuTagMatchingTool', **kwargs):
1180  from TrkConfig.AtlasExtrapolatorConfig import AtlasExtrapolatorCfg
1181  from TrkConfig.TrkExRungeKuttaPropagatorConfig import RungeKuttaPropagatorCfg
1182 
1183  #TODO: defaults in cxx
1184  kwargs.setdefault("AssumeLocalErrors", True)
1185  kwargs.setdefault("PhiCut", 30.)
1186  kwargs.setdefault("GlobalPhiCut", 1.)
1187  kwargs.setdefault("ThetaCut", 5.)
1188  kwargs.setdefault("GlobalThetaCut", 0.5)
1189  kwargs.setdefault("ThetaAngleCut", 5.)
1190  kwargs.setdefault("DoDistanceCut", True)
1191  kwargs.setdefault("CombinedPullCut", 3.0)
1192 
1193  result = AtlasExtrapolatorCfg(flags)
1194  kwargs.setdefault("IExtrapolator", result.popPrivateTools())
1195  kwargs.setdefault("Propagator", result.popToolsAndMerge(
1196  RungeKuttaPropagatorCfg(flags)))
1197  kwargs.setdefault("Printer", result.getPrimaryAndMerge(
1198  MuonEDMPrinterToolCfg(flags)))
1199  kwargs.setdefault("MuonSegmentHitSummary", result.popToolsAndMerge(
1200  MuonSegmentHitSummaryToolCfg(flags)))
1201  kwargs.setdefault("MuonSegmentSelection", result.popToolsAndMerge(
1202  MuonSegmentSelectionToolCfg(flags)))
1203 
1204  if "ResidualPullCalculator" not in kwargs:
1205  from TrkConfig.TrkResidualPullCalculatorConfig import (
1206  ResidualPullCalculatorCfg)
1207  kwargs.setdefault("ResidualPullCalculator", result.popToolsAndMerge(
1208  ResidualPullCalculatorCfg(flags)))
1209 
1210  from TrackingGeometryCondAlg.AtlasTrackingGeometryCondAlgConfig import (
1211  TrackingGeometryCondAlgCfg)
1212  acc = TrackingGeometryCondAlgCfg(flags)
1213  geom_cond_key = acc.getPrimary().TrackingGeometryWriteKey
1214  result.merge(acc)
1215  kwargs.setdefault("TrackingGeometryReadKey", geom_cond_key)
1216 
1217  tool = CompFactory.MuTagMatchingTool(name, **kwargs)
1218 
1219  result.addPublicTool(tool, primary=True)
1220  return result
1221 
1222 

◆ TrackDepositInCaloToolCfg()

def python.MuonCombinedRecToolsConfig.TrackDepositInCaloToolCfg (   flags,
  name = 'TrackDepositInCaloTool',
**  kwargs 
)

Definition at line 899 of file MuonCombinedRecToolsConfig.py.

899 def TrackDepositInCaloToolCfg(flags, name='TrackDepositInCaloTool', **kwargs):
900  from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg, ParticleCaloCellAssociationToolCfg
901  result = ComponentAccumulator()
902  kwargs.setdefault("ParticleCaloExtensionTool",
903  result.popToolsAndMerge(ParticleCaloExtensionToolCfg(flags)))
904  kwargs.setdefault("ExtrapolatorHandle", result.popToolsAndMerge(
905  AtlasExtrapolatorCfg(flags)))
906  kwargs.setdefault("ParticleCaloCellAssociationTool",
907  result.popToolsAndMerge(ParticleCaloCellAssociationToolCfg(flags, name="Rec::ParticleCaloCellAssociationTool")))
908  tool = CompFactory.TrackDepositInCaloTool(name, **kwargs)
909  result.setPrivateTools(tool)
910  return result
911 
912 
python.MuonRecToolsConfig.MuonAmbiProcessorCfg
def MuonAmbiProcessorCfg(flags, name="MuonAmbiProcessor", **kwargs)
Definition: MuonRecToolsConfig.py:144
python.MuonCombinedRecToolsConfig.MuidTrackCleanerCfg
def MuidTrackCleanerCfg(flags, name='MuidTrackCleaner', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:444
python.MuonCombinedRecToolsConfig.CombinedMuonTagTestToolCfg
def CombinedMuonTagTestToolCfg(flags, name='CombinedMuonTagTestTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:885
SystemOfUnits
python.MuonRecToolsConfig.MuonTrackSummaryHelperToolCfg
def MuonTrackSummaryHelperToolCfg(flags, name="MuonTrackSummaryHelperTool", **kwargs)
Definition: MuonRecToolsConfig.py:123
python.MuonTrackBuildingConfig.MooTrackBuilderCfg
def MooTrackBuilderCfg(flags, name="MooTrackBuilderTemplate", prefix="", doSegmentPhiMatching=True, **kwargs)
Definition: MuonTrackBuildingConfig.py:68
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
python.AtlasExtrapolatorToolsConfig.AtlasEnergyLossUpdatorCfg
def AtlasEnergyLossUpdatorCfg(flags, name='AtlasEnergyLossUpdator', **kwargs)
Definition: AtlasExtrapolatorToolsConfig.py:12
MuidCaloEnergyParam
python.MuonCombinedRecToolsConfig.ExtrapolateMuonToIPToolCfg
def ExtrapolateMuonToIPToolCfg(flags, name="ExtrapolateMuonToIPTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:200
python.MuonRecToolsConfig.MuonSeededSegmentFinderCfg
def MuonSeededSegmentFinderCfg(flags, name="MuonSeededSegmentFinder", **kwargs)
Definition: MuonRecToolsConfig.py:64
python.MuonCombinedRecToolsConfig.MuonTrackQueryCfg
def MuonTrackQueryCfg(flags, name="MuonTrackQuery", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:601
python.MuonCombinedRecToolsConfig.MuonAlignmentUncertToolPhiCfg
def MuonAlignmentUncertToolPhiCfg(flags, name="MuonAlignmentUncertToolPhi", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:683
python.MuonCombinedRecToolsConfig.MuonDressingToolCfg
def MuonDressingToolCfg(flags, name="MuonDressingTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:128
python.InDetTrackSelectorToolConfig.MuonCombinedInDetDetailedTrackSelectorToolCfg
def MuonCombinedInDetDetailedTrackSelectorToolCfg(flags, name="MuonCombinedInDetDetailedTrackSelectorTool", **kwargs)
Definition: InDetTrackSelectorToolConfig.py:125
python.MuonCombinedRecToolsConfig.MuidCaloEnergyToolParamCfg
def MuidCaloEnergyToolParamCfg(flags, name='MuidCaloEnergyToolParam', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:495
python.MuonCombinedRecToolsConfig.MuonLayerSegmentMatchingToolCfg
def MuonLayerSegmentMatchingToolCfg(flags, name="MuonLayerSegmentMatchingTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:993
python.MuonRIO_OnTrackCreatorToolConfig.MdtCalibWindowNumber
def MdtCalibWindowNumber(name)
Definition: MuonRIO_OnTrackCreatorToolConfig.py:19
python.MuonRecToolsConfig.MuonTrackScoringToolCfg
def MuonTrackScoringToolCfg(flags, name="MuonTrackScoringTool", **kwargs)
Definition: MuonRecToolsConfig.py:132
python.MuonCombinedRecToolsConfig.EMEO_MuonCombinedFitTagToolCfg
def EMEO_MuonCombinedFitTagToolCfg(flags, name="MuonCombinedFitTagTool_EMEO", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:325
python.MuonCombinedRecToolsConfig.MuonMaterialProviderToolCfg
def MuonMaterialProviderToolCfg(flags, name="MuonTrkMaterialProviderTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:58
AtlasTrackingGeometryCondAlgConfig.TrackingGeometryCondAlgCfg
def TrackingGeometryCondAlgCfg(flags, name='AtlasTrackingGeometryCondAlg', doMaterialValidation=False, **kwargs)
Definition: AtlasTrackingGeometryCondAlgConfig.py:131
python.MuonCombinedRecToolsConfig.MuonCreatorToolCfg
def MuonCreatorToolCfg(flags, name="MuonCreatorTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:138
python.MuonCombinedRecToolsConfig.iPatFitterCfg
def iPatFitterCfg(flags, name='iPatFitter', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:403
python.MuonCombinedRecToolsConfig.MuonCandidateToolCfg
def MuonCandidateToolCfg(flags, name="MuonCandidateTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:221
python.MuonRecToolsConfig.MuonEDMPrinterToolCfg
def MuonEDMPrinterToolCfg(flags, name="MuonEDMPrinterTool", **kwargs)
Definition: MuonRecToolsConfig.py:10
python.TrkTrackSummaryToolConfig.MuonTrackSummaryToolCfg
def MuonTrackSummaryToolCfg(flags, name="MuonTrackSummaryTool", **kwargs)
Definition: TrkTrackSummaryToolConfig.py:143
python.MuonCombinedRecToolsConfig.MuidCaloEnergyToolCfg
def MuidCaloEnergyToolCfg(flags, name='MuidCaloEnergyTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:523
python.MuonSegmentFindingConfig.MuonNSWSegmentFinderToolCfg
def MuonNSWSegmentFinderToolCfg(flags, name='MuonNSWSegmentFinderTool', **kwargs)
Definition: MuonSegmentFindingConfig.py:362
python.MuonCombinedRecToolsConfig.MuonCombinedFitTagToolCfg
def MuonCombinedFitTagToolCfg(flags, name="MuonCombinedFitTagTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:300
python.MuonCombinedRecToolsConfig.MuonInDetForwardCandidateToolCfg
def MuonInDetForwardCandidateToolCfg(flags, name='InDetForwardCandidateTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:27
python.MuonCombinedRecToolsConfig.MuidCaloTrackStateOnSurfaceCfg
def MuidCaloTrackStateOnSurfaceCfg(flags, name='MuidCaloTrackStateOnSurface', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:546
python.MuonRecToolsConfig.MuonRefitToolCfg
def MuonRefitToolCfg(flags, name="MuonRefitTool", **kwargs)
Definition: MuonRecToolsConfig.py:279
python.TrkTrackSummaryToolConfig.MuonCombinedTrackSummaryToolCfg
def MuonCombinedTrackSummaryToolCfg(flags, name="CombinedMuonTrackSummary", **kwargs)
Definition: TrkTrackSummaryToolConfig.py:153
python.AtlasExtrapolatorToolsConfig.AtlasMultipleScatteringUpdatorCfg
def AtlasMultipleScatteringUpdatorCfg(flags, name="AtlasMultipleScatteringUpdator", **kwargs)
Definition: AtlasExtrapolatorToolsConfig.py:115
python.MuonCombinedRecToolsConfig.MuidMaterialAllocatorCfg
def MuidMaterialAllocatorCfg(flags, name='MuidMaterialAllocator', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:382
python.MuonCombinedRecToolsConfig.EMEO_CombinedTrackBuilderFitCfg
def EMEO_CombinedTrackBuilderFitCfg(flags, name="CombinedTrackBuilderFit_EMEO", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:841
python.MuonCombinedRecToolsConfig.InDetCandidateToolCfg
def InDetCandidateToolCfg(flags, name="InDetCandidateTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:18
python.MuonCombinedRecToolsConfig.MuonMatchQualityCfg
def MuonMatchQualityCfg(flags, name='MuonMatchQuality', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:857
python.AtlasExtrapolatorConfig.AtlasExtrapolatorCfg
def AtlasExtrapolatorCfg(flags, name='AtlasExtrapolator')
Definition: AtlasExtrapolatorConfig.py:63
python.TrkExRungeKuttaPropagatorConfig.RungeKuttaPropagatorCfg
def RungeKuttaPropagatorCfg(flags, name='AtlasRungeKuttaPropagator', **kwargs)
Definition: TrkExRungeKuttaPropagatorConfig.py:9
TrackToCaloConfig.ParticleCaloCellAssociationToolCfg
def ParticleCaloCellAssociationToolCfg(flags, name='ParticleCaloCellAssociationTool', **kwargs)
Definition: TrackToCaloConfig.py:72
python.MuonCombinedRecToolsConfig.MuidErrorOptimisationToolCfg
def MuidErrorOptimisationToolCfg(flags, name='MuidErrorOptimisationTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:654
python.MuonTrackBuildingConfig.MuonChamberHoleRecoveryToolCfg
def MuonChamberHoleRecoveryToolCfg(flags, name="MuonChamberHoleRecoveryTool", **kwargs)
Definition: MuonTrackBuildingConfig.py:309
python.MuonCombinedRecToolsConfig.CaloMuonTagCfg
def CaloMuonTagCfg(flags, name="CaloMuonTag", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:933
python.MuonCombinedRecToolsConfig.CombinedMuonTrackBuilderCfg
def CombinedMuonTrackBuilderCfg(flags, name='CombinedMuonTrackBuilder', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:696
python.MuonCombinedRecToolsConfig.CombinedMuonTrackBuilderFitCfg
def CombinedMuonTrackBuilderFitCfg(flags, name='CombinedMuonTrackBuilderFit', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:820
python.MuonGeometryConfig.TrackingVolumesSvcCfg
def TrackingVolumesSvcCfg(flags, name="TrackingVolumesSvc", **kwargs)
Definition: MuonGeometryConfig.py:10
python.MuonCombinedRecToolsConfig.MuTagAmbiguitySolverToolCfg
def MuTagAmbiguitySolverToolCfg(flags, name='MuTagAmbiguitySolverTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1223
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.TrkParticleCreatorConfig.MuonCaloParticleCreatorCfg
def MuonCaloParticleCreatorCfg(flags, name="MuonCaloParticleCreator", **kwargs)
Definition: TrkParticleCreatorConfig.py:376
python.MuonCombinedRecToolsConfig.MuonCaloEnergyToolCfg
def MuonCaloEnergyToolCfg(flags, name="MuonCaloEnergyTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:37
python.TrkExSTEP_PropagatorConfig.AtlasSTEP_PropagatorCfg
def AtlasSTEP_PropagatorCfg(flags, name='AtlasSTEP_Propagator', **kwargs)
Definition: TrkExSTEP_PropagatorConfig.py:16
python.MuonRIO_OnTrackCreatorToolConfig.CscClusterOnTrackCreatorCfg
def CscClusterOnTrackCreatorCfg(flags, name="CscClusterOnTrackCreator", **kwargs)
Definition: MuonRIO_OnTrackCreatorToolConfig.py:34
python.MuonCombinedRecToolsConfig.MuidTrackIsolationCfg
def MuidTrackIsolationCfg(flags, name='MuidTrackIsolation', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:512
python.MuonCombinedRecToolsConfig.MuidCaloEnergyParam
def MuidCaloEnergyParam(flags, name='MuidCaloEnergyParam', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:477
python.MuonCombinedRecToolsConfig.MuonAlignmentUncertToolThetaCfg
def MuonAlignmentUncertToolThetaCfg(flags, name="MuonAlignmentUncertToolTheta", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:671
python.MuonTrackBuildingConfig.EMEO_MuonChamberHoleRecoveryToolCfg
def EMEO_MuonChamberHoleRecoveryToolCfg(flags, name="MuonChamberRecovery_EMEO")
Definition: MuonTrackBuildingConfig.py:359
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.InDetTrackSelectorToolConfig.CaloTrkMuIdAlgTrackSelectorToolCfg
def CaloTrkMuIdAlgTrackSelectorToolCfg(flags, name='CaloTrkMuIdAlgTrackSelectorTool', **kwargs)
Definition: InDetTrackSelectorToolConfig.py:176
python.MuonCombinedRecToolsConfig.MuonSegmentSelectionToolCfg
def MuonSegmentSelectionToolCfg(flags, name="MuonSegmentSelectionTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1041
python.MuonCombinedRecToolsConfig.MuidMuonRecoveryCfg
def MuidMuonRecoveryCfg(flags, name='MuidMuonRecovery', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:868
python.MuonCombinedRecToolsConfig.MdtDriftCircleOnTrackCreatorStauCfg
def MdtDriftCircleOnTrackCreatorStauCfg(flags, name="MdtDriftCircleOnTrackCreatorStau", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1076
python.TrkExRungeKuttaPropagatorConfig.MuonCombinedPropagatorCfg
def MuonCombinedPropagatorCfg(flags, name='MuonCombinedPropagator', **kwargs)
Definition: TrkExRungeKuttaPropagatorConfig.py:31
python.MuonCombinedRecToolsConfig.MuonCandidateTrackBuilderToolCfg
def MuonCandidateTrackBuilderToolCfg(flags, name="MuonCandidateTrackBuilderTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1032
python.MuonCombinedRecToolsConfig.EMEO_MuonCombinedToolCfg
def EMEO_MuonCombinedToolCfg(flags, name="MuonCombinedTool_EMEO", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:336
LArGMConfig.LArGMCfg
def LArGMCfg(flags)
Definition: LArGMConfig.py:8
python.MuonCombinedRecToolsConfig.CaloMuonLikelihoodToolCfg
def CaloMuonLikelihoodToolCfg(flags, name='CaloMuonLikelihoodTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:913
python.MuonCombinedRecToolsConfig.MuonCombinedDebuggerToolCfg
def MuonCombinedDebuggerToolCfg(flags, name="MuonCombinedDebuggerTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:261
python.MuonCombinedRecToolsConfig.MuonSegmentHitSummaryToolCfg
def MuonSegmentHitSummaryToolCfg(flags, name="MuonSegmentHitSummaryTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:108
python.AtlasExtrapolatorConfig.MuonExtrapolatorCfg
def MuonExtrapolatorCfg(flags, name="MuonExtrapolator", **kwargs)
Definition: AtlasExtrapolatorConfig.py:376
python.MuonSelectorToolsConfig.MuonSelectionToolCfg
def MuonSelectionToolCfg(flags, name="MuonSelectionTool", **kwargs)
Standard configuration of the MuonSelectionTool used in reconstruction & validation jobs The snippet ...
Definition: MuonSelectorToolsConfig.py:16
python.InDetTrackSelectorToolConfig.MuonCombinedInDetDetailedForwardTrackSelectorToolCfg
def MuonCombinedInDetDetailedForwardTrackSelectorToolCfg(flags, name='MuonCombinedInDetDetailedForwardTrackSelectorTool', **kwargs)
Definition: InDetTrackSelectorToolConfig.py:172
python.MuonCombinedRecToolsConfig.MuidCaloEnergyMeasCfg
def MuidCaloEnergyMeasCfg(flags, name='MuidCaloEnergyMeas', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:482
python.MuonCombinedRecToolsConfig.MuTagMatchingToolCfg
def MuTagMatchingToolCfg(flags, name='MuTagMatchingTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1179
python.MuonCombinedRecToolsConfig.MuidMaterialEffectsOnTrackProviderCfg
def MuidMaterialEffectsOnTrackProviderCfg(flags, name='MuidMaterialEffectsOnTrackProvider', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:578
python.TrkParticleCreatorConfig.MuonCombinedParticleCreatorCfg
def MuonCombinedParticleCreatorCfg(flags, name="MuonCombinedParticleCreator", **kwargs)
Definition: TrkParticleCreatorConfig.py:315
python.MuonCombinedRecToolsConfig.MuonCaloTagToolCfg
def MuonCaloTagToolCfg(flags, name='MuonCaloTagTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:940
python.MuonRecToolsConfig.MuonTrackCleanerCfg
def MuonTrackCleanerCfg(flags, name="MuonTrackCleaner", seg=False, **kwargs)
Definition: MuonRecToolsConfig.py:159
python.MuonRIO_OnTrackCreatorToolConfig.MuonClusterOnTrackCreatorCfg
def MuonClusterOnTrackCreatorCfg(flags, name="MuonClusterOnTrackCreator", **kwargs)
Definition: MuonRIO_OnTrackCreatorToolConfig.py:96
python.MuonRIO_OnTrackCreatorToolConfig.MdtDriftCircleOnTrackCreatorCfg
def MdtDriftCircleOnTrackCreatorCfg(flags, name="MdtDriftCircleOnTrackCreator", **kwargs)
Definition: MuonRIO_OnTrackCreatorToolConfig.py:73
python.MuonGeometryConfig.MuonGeoModelCfg
def MuonGeoModelCfg(flags)
Definition: MuonGeometryConfig.py:28
python.MuonCombinedRecToolsConfig.MuonInsideOutRecoToolCfg
def MuonInsideOutRecoToolCfg(flags, name="MuonInsideOutRecoTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1004
python.MuonCombinedRecToolsConfig.iPatSLFitterCfg
def iPatSLFitterCfg(flags, name='iPatSLFitter', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:436
python.MuonCombinedRecToolsConfig.EMEO_MuonSegmentRegionRecoveryToolCfg
def EMEO_MuonSegmentRegionRecoveryToolCfg(flags, name="MuonSegmentRegionRecoveryTool_EMEO")
Definition: MuonCombinedRecToolsConfig.py:618
python.MuonCombinedRecToolsConfig.EMEO_CombinedMuonTrackBuilderCfg
def EMEO_CombinedMuonTrackBuilderCfg(flags, name="MuonCombinedTrackBuilder_EMEO")
Definition: MuonCombinedRecToolsConfig.py:641
python.MuonCombinedRecToolsConfig.TrackDepositInCaloToolCfg
def TrackDepositInCaloToolCfg(flags, name='TrackDepositInCaloTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:899
python.MuonCombinedRecToolsConfig.MuidCaloTrackStateOnSurfaceParamCfg
def MuidCaloTrackStateOnSurfaceParamCfg(flags, name='MuidCaloTrackStateOnSurfaceParam', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:564
python.MuonCombinedRecToolsConfig.MuonLayerSegmentFinderToolCfg
def MuonLayerSegmentFinderToolCfg(flags, name="MuonLayerSegmentFinderTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:963
python.MuonSegmentFindingConfig.Csc4dSegmentMakerCfg
def Csc4dSegmentMakerCfg(flags, name="Csc4dSegmentMaker", **kwargs)
Definition: MuonSegmentFindingConfig.py:355
python.MuonCombinedRecToolsConfig.CaloMuonScoreToolCfg
def CaloMuonScoreToolCfg(flags, name='CaloMuonScoreTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:923
python.MuonCombinedRecToolsConfig.MuidMaterialEffectsOnTrackProviderParamCfg
def MuidMaterialEffectsOnTrackProviderParamCfg(flags, name='MuidMaterialEffectsOnTrackProviderParam', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:590
python.MuonRIO_OnTrackCreatorToolConfig.MdtCalibToolForRotsCfg
def MdtCalibToolForRotsCfg(flags, name="MdtCalibrationTool", **kwargs)
Definition: MuonRIO_OnTrackCreatorToolConfig.py:62
python.MuonCombinedRecToolsConfig.MuonSystemExtensionToolCfg
def MuonSystemExtensionToolCfg(flags, **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1161
python.MagFieldServicesConfig.AtlasFieldCacheCondAlgCfg
def AtlasFieldCacheCondAlgCfg(flags, **kwargs)
Definition: MagFieldServicesConfig.py:8
python.TrkResidualPullCalculatorConfig.ResidualPullCalculatorCfg
def ResidualPullCalculatorCfg(flags, name='ResidualPullCalculator', **kwargs)
Definition: TrkResidualPullCalculatorConfig.py:6
python.MuonTrackBuildingConfig.MuonSegmentRegionRecoveryToolCfg
def MuonSegmentRegionRecoveryToolCfg(flags, name="MuonSegmentRegionRecoveryTool", **kwargs)
Definition: MuonTrackBuildingConfig.py:217
python.SolenoidalIntersectorConfig.SolenoidalIntersectorCfg
def SolenoidalIntersectorCfg(flags, name='SolenoidalIntersector', **kwargs)
Definition: SolenoidalIntersectorConfig.py:7
python.MuonRecToolsConfig.MuonHitSummaryToolCfg
def MuonHitSummaryToolCfg(flags, name="MuonHitSummaryTool", **kwargs)
Definition: MuonRecToolsConfig.py:54
python.MuonSegmentFindingConfig.DCMathSegmentMakerCfg
def DCMathSegmentMakerCfg(flags, name='DCMathSegmentMaker', doSegmentT0Fit=False, **kwargs)
Definition: MuonSegmentFindingConfig.py:114
python.MuonSegmentFindingConfig.Csc2dSegmentMakerCfg
def Csc2dSegmentMakerCfg(flags, name="Csc2dSegmentMaker", **kwargs)
Definition: MuonSegmentFindingConfig.py:337
python.MuonCombinedRecToolsConfig.MuonSegmentConverterToolCfg
def MuonSegmentConverterToolCfg(flags, name="MuonSegmentConverterTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:119
python.MuonTrackBuildingConfig.MuonSegmentMatchingToolCfg
def MuonSegmentMatchingToolCfg(flags, name="MuonSegmentMatchingTool", **kwargs)
Definition: MuonTrackBuildingConfig.py:152
python.MuonSegmentFindingConfig.MuonPRDSelectionToolCfg
def MuonPRDSelectionToolCfg(flags, name="MuonPRDSelectionTool", **kwargs)
Definition: MuonSegmentFindingConfig.py:384
python.MuonCombinedRecToolsConfig.MuonCombinedStacoTagToolCfg
def MuonCombinedStacoTagToolCfg(flags, name="MuonCombinedStacoTagTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:365
python.MuonCombinedRecToolsConfig.MuonLayerAmbiguitySolverToolCfg
def MuonLayerAmbiguitySolverToolCfg(flags, name="MuonLayerAmbiguitySolverTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1059
TrackToCaloConfig.ParticleCaloExtensionToolCfg
def ParticleCaloExtensionToolCfg(flags, name='ParticleCaloExtensionTool', **kwargs)
Definition: TrackToCaloConfig.py:10
Generated on Sun Dec 22 2024 22:06:42 for ATLAS Offline Software by   doxygen 1.8.18