ATLAS Offline Software
Functions
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 MuonCombinedRecToolsConfig.CaloMuonLikelihoodToolCfg (   flags,
  name = 'CaloMuonLikelihoodTool',
**  kwargs 
)

Definition at line 917 of file MuonCombinedRecToolsConfig.py.

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

◆ CaloMuonScoreToolCfg()

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

Definition at line 927 of file MuonCombinedRecToolsConfig.py.

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

◆ CaloMuonTagCfg()

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

Definition at line 937 of file MuonCombinedRecToolsConfig.py.

937 def CaloMuonTagCfg(flags, name="CaloMuonTag", **kwargs):
938  result = ComponentAccumulator()
939  the_tool = CompFactory.CaloMuonTag(name, **kwargs)
940  result.setPrivateTools(the_tool)
941  return result
942 
943 

◆ CombinedMuonTagTestToolCfg()

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

Definition at line 889 of file MuonCombinedRecToolsConfig.py.

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

◆ CombinedMuonTrackBuilderCfg()

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

Definition at line 700 of file MuonCombinedRecToolsConfig.py.

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

◆ CombinedMuonTrackBuilderFitCfg()

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

Definition at line 824 of file MuonCombinedRecToolsConfig.py.

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

◆ EMEO_CombinedMuonTrackBuilderCfg()

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

Definition at line 645 of file MuonCombinedRecToolsConfig.py.

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

◆ EMEO_CombinedTrackBuilderFitCfg()

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

Definition at line 845 of file MuonCombinedRecToolsConfig.py.

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

◆ EMEO_MuonCombinedFitTagToolCfg()

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

Definition at line 331 of file MuonCombinedRecToolsConfig.py.

331 def EMEO_MuonCombinedFitTagToolCfg(flags, name="MuonCombinedFitTagTool_EMEO", **kwargs):
332  result = ComponentAccumulator()
333  track_builder = result.popToolsAndMerge(
334  EMEO_CombinedMuonTrackBuilderCfg(flags))
335  fit_tag_tool = result.popToolsAndMerge(MuonCombinedFitTagToolCfg(flags, name=name,
336  TrackBuilder=track_builder,
337  **kwargs))
338  result.setPrivateTools(fit_tag_tool)
339  return result
340 
341 

◆ EMEO_MuonCombinedToolCfg()

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

Definition at line 342 of file MuonCombinedRecToolsConfig.py.

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

◆ EMEO_MuonSegmentRegionRecoveryToolCfg()

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

Definition at line 622 of file MuonCombinedRecToolsConfig.py.

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

◆ ExtrapolateMuonToIPToolCfg()

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

Definition at line 201 of file MuonCombinedRecToolsConfig.py.

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

◆ InDetCandidateToolCfg()

def 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 MuonCombinedRecToolsConfig.iPatFitterCfg (   flags,
  name = 'iPatFitter',
**  kwargs 
)

Definition at line 409 of file MuonCombinedRecToolsConfig.py.

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

◆ iPatSLFitterCfg()

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

Definition at line 440 of file MuonCombinedRecToolsConfig.py.

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

◆ MdtDriftCircleOnTrackCreatorStauCfg()

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

Definition at line 1080 of file MuonCombinedRecToolsConfig.py.

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

◆ MuidCaloEnergyMeasCfg()

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

Definition at line 486 of file MuonCombinedRecToolsConfig.py.

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

◆ MuidCaloEnergyParam()

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

Definition at line 481 of file MuonCombinedRecToolsConfig.py.

481 def MuidCaloEnergyParam(flags, name='MuidCaloEnergyParam', **kwargs):
482  kwargs.setdefault("Cosmics", flags.Beam.Type is BeamType.Cosmics)
483  return CompFactory.Rec.MuidCaloEnergyParam(name, **kwargs)
484 
485 

◆ MuidCaloEnergyToolCfg()

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

Definition at line 527 of file MuonCombinedRecToolsConfig.py.

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

◆ MuidCaloEnergyToolParamCfg()

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

Definition at line 499 of file MuonCombinedRecToolsConfig.py.

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

◆ MuidCaloTrackStateOnSurfaceCfg()

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

Definition at line 550 of file MuonCombinedRecToolsConfig.py.

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

◆ MuidCaloTrackStateOnSurfaceParamCfg()

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

Definition at line 568 of file MuonCombinedRecToolsConfig.py.

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

◆ MuidErrorOptimisationToolCfg()

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

Definition at line 658 of file MuonCombinedRecToolsConfig.py.

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

◆ MuidMaterialAllocatorCfg()

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

Definition at line 388 of file MuonCombinedRecToolsConfig.py.

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

◆ MuidMaterialEffectsOnTrackProviderCfg()

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

Definition at line 582 of file MuonCombinedRecToolsConfig.py.

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

◆ MuidMaterialEffectsOnTrackProviderParamCfg()

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

Definition at line 594 of file MuonCombinedRecToolsConfig.py.

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

◆ MuidMuonRecoveryCfg()

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

Definition at line 872 of file MuonCombinedRecToolsConfig.py.

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

◆ MuidTrackCleanerCfg()

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

Definition at line 448 of file MuonCombinedRecToolsConfig.py.

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

◆ MuidTrackIsolationCfg()

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

Definition at line 516 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonAlignmentUncertToolPhiCfg()

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

Definition at line 687 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonAlignmentUncertToolThetaCfg()

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

Definition at line 675 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonCaloEnergyToolCfg()

def 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 MuonCombinedRecToolsConfig.MuonCaloTagToolCfg (   flags,
  name = 'MuonCaloTagTool',
**  kwargs 
)

Definition at line 944 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonCandidateToolCfg()

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

Definition at line 222 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonCandidateTrackBuilderToolCfg()

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

Definition at line 1036 of file MuonCombinedRecToolsConfig.py.

1036 def MuonCandidateTrackBuilderToolCfg(flags, name="MuonCandidateTrackBuilderTool", **kwargs):
1037  result = CombinedMuonTrackBuilderCfg(flags)
1038  kwargs.setdefault("MuonTrackBuilder", result.popPrivateTools())
1039  muoncandidatetrackbuilder = CompFactory.Muon.MuonCandidateTrackBuilderTool(
1040  name, **kwargs)
1041  result.setPrivateTools(muoncandidatetrackbuilder)
1042  return result
1043 
1044 

◆ MuonCombinedDebuggerToolCfg()

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

Definition at line 262 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonCombinedFitTagToolCfg()

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

Definition at line 301 of file MuonCombinedRecToolsConfig.py.

301 def MuonCombinedFitTagToolCfg(flags, name="MuonCombinedFitTagTool", **kwargs):
302  if flags.Muon.MuonTrigger:
303  kwargs.setdefault("VertexContainer", "")
304 
305  result = ComponentAccumulator()
306  kwargs.setdefault("TrackBuilder", result.popToolsAndMerge(
307  CombinedMuonTrackBuilderCfg(flags)))
308 
309  kwargs.setdefault("Printer", result.getPrimaryAndMerge(
310  MuonEDMPrinterToolCfg(flags)))
311 
312  kwargs.setdefault("TrackQuery", result.popToolsAndMerge(
313  MuonTrackQueryCfg(flags)))
314  kwargs.setdefault("MatchQuality", result.popToolsAndMerge(
315  MuonMatchQualityCfg(flags)))
316 
317  from MuonConfig.MuonRecToolsConfig import MuonTrackScoringToolCfg
318  kwargs.setdefault("TrackScoringTool", result.popToolsAndMerge(
319  MuonTrackScoringToolCfg(flags)))
320 
321 
322  #When both solenoid and toriod are off (e.g. cosmic runs) this cut is likely to kill the combined muon -> loosen up for cosmics
323  if flags.Beam.Type is BeamType.Cosmics and (not flags.BField.endcapToroidOn and not flags.BField.solenoidOn):
324  kwargs.setdefault("MomentumBalanceCut", 1e6)
325 
326  tool = CompFactory.MuonCombined.MuonCombinedFitTagTool(name, **kwargs)
327  result.setPrivateTools(tool)
328  return result
329 
330 

◆ MuonCombinedStacoTagToolCfg()

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

Definition at line 371 of file MuonCombinedRecToolsConfig.py.

371 def MuonCombinedStacoTagToolCfg(flags, name="MuonCombinedStacoTagTool", **kwargs):
372 
373  result = ComponentAccumulator()
374  kwargs.setdefault("Printer", result.getPrimaryAndMerge(
375  MuonEDMPrinterToolCfg(flags)))
376  kwargs.setdefault("TagTool", result.popToolsAndMerge(
377  CombinedMuonTagTestToolCfg(flags)))
378  kwargs.setdefault("Extrapolator", result.popToolsAndMerge(
379  AtlasExtrapolatorCfg(flags)))
380 
381  tool = CompFactory.MuonCombined.MuonCombinedStacoTagTool(name, **kwargs)
382  result.setPrivateTools(tool)
383  return result
384 
385 # From Combined fit tools.py
386 
387 

◆ MuonCombinedToolCfg()

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

Definition at line 272 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonCreatorToolCfg()

def 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  kwargs.setdefault("AddMDTExtrasMuGirlLowBeta", flags.MuonCombined.addMDTExtrasMuGirlLowBeta)
167  # Not explicitly setting up MomentumBalanceTool nor ScatteringAngleTool
168  # Not explicitly setting up MeanMDTdADCTool (but probably should FIXME)
169 
170  kwargs.setdefault("CaloMaterialProvider", result.popToolsAndMerge(
171  MuonMaterialProviderToolCfg(flags)))
172 
173  kwargs.setdefault("TrackQuery", result.popToolsAndMerge(
174  MuonTrackQueryCfg(flags)))
175  # runCommissioningChain
176  if flags.Muon.SAMuonTrigger:
177  from TrkConfig.TrkTrackSummaryToolConfig import MuonTrackSummaryToolCfg
178  kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(
179  MuonTrackSummaryToolCfg(flags)))
180  else:
181  from TrkConfig.TrkTrackSummaryToolConfig import MuonCombinedTrackSummaryToolCfg
182  kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(
183  MuonCombinedTrackSummaryToolCfg(flags)))
184 
185  if flags.Muon.MuonTrigger:
186  kwargs.setdefault("MuonSelectionTool", "")
187  kwargs.setdefault("UseCaloCells", False)
188  kwargs.setdefault("CopyUInt8SummaryKeys", [])
189  else:
190  from MuonSelectorTools.MuonSelectorToolsConfig import MuonSelectionToolCfg
191  kwargs.setdefault("MuonSelectionTool", result.popToolsAndMerge(
192  MuonSelectionToolCfg(flags, name='MuonRecoSelTool')))
193  kwargs.setdefault("RequireMSOEforSA", flags.Beam.Type is BeamType.Collisions)
194  kwargs.setdefault("RequireCaloForSA", flags.Beam.Type is BeamType.Collisions)
195 
196  tool = CompFactory.MuonCombined.MuonCreatorTool(name, **kwargs)
197  result.setPrivateTools(tool)
198  return result
199 
200 

◆ MuonDressingToolCfg()

def 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 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 MuonCombinedRecToolsConfig.MuonInsideOutRecoToolCfg (   flags,
  name = "MuonInsideOutRecoTool",
**  kwargs 
)

Definition at line 1008 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonLayerAmbiguitySolverToolCfg()

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

Definition at line 1063 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonLayerSegmentFinderToolCfg()

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

Definition at line 967 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonLayerSegmentMatchingToolCfg()

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

Definition at line 997 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonMatchQualityCfg()

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

Definition at line 861 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonMaterialProviderToolCfg()

def 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 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 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 MuonCombinedRecToolsConfig.MuonSegmentSelectionToolCfg (   flags,
  name = "MuonSegmentSelectionTool",
**  kwargs 
)

Definition at line 1045 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonSegmentTagToolCfg()

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

Definition at line 1244 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonStauRecoToolCfg()

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

Definition at line 1090 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonSystemExtensionToolCfg()

def MuonCombinedRecToolsConfig.MuonSystemExtensionToolCfg (   flags,
**  kwargs 
)

Definition at line 1166 of file MuonCombinedRecToolsConfig.py.

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

◆ MuonTrackQueryCfg()

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

Definition at line 605 of file MuonCombinedRecToolsConfig.py.

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

◆ MuTagAmbiguitySolverToolCfg()

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

Definition at line 1228 of file MuonCombinedRecToolsConfig.py.

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

◆ MuTagMatchingToolCfg()

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

Definition at line 1184 of file MuonCombinedRecToolsConfig.py.

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

◆ TrackDepositInCaloToolCfg()

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

Definition at line 903 of file MuonCombinedRecToolsConfig.py.

903 def TrackDepositInCaloToolCfg(flags, name='TrackDepositInCaloTool', **kwargs):
904  from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg, ParticleCaloCellAssociationToolCfg
905  result = ComponentAccumulator()
906  kwargs.setdefault("ParticleCaloExtensionTool",
907  result.popToolsAndMerge(ParticleCaloExtensionToolCfg(flags)))
908  kwargs.setdefault("ExtrapolatorHandle", result.popToolsAndMerge(
909  AtlasExtrapolatorCfg(flags)))
910  kwargs.setdefault("ParticleCaloCellAssociationTool",
911  result.popToolsAndMerge(ParticleCaloCellAssociationToolCfg(flags, name="Rec::ParticleCaloCellAssociationTool")))
912  tool = CompFactory.TrackDepositInCaloTool(name, **kwargs)
913  result.setPrivateTools(tool)
914  return result
915 
916 
MuonCombinedRecToolsConfig.MuonMatchQualityCfg
def MuonMatchQualityCfg(flags, name='MuonMatchQuality', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:861
MuonRIO_OnTrackCreatorToolConfig.MdtCalibToolForRotsCfg
def MdtCalibToolForRotsCfg(flags, name="MdtCalibrationTool", **kwargs)
Definition: MuonRIO_OnTrackCreatorToolConfig.py:62
MuonGeometryConfig.TrackingVolumesSvcCfg
def TrackingVolumesSvcCfg(flags, name="TrackingVolumesSvc", **kwargs)
Definition: MuonGeometryConfig.py:10
SystemOfUnits
MuonCombinedRecToolsConfig.MuonInsideOutRecoToolCfg
def MuonInsideOutRecoToolCfg(flags, name="MuonInsideOutRecoTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1008
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
python.AtlasExtrapolatorToolsConfig.AtlasEnergyLossUpdatorCfg
def AtlasEnergyLossUpdatorCfg(flags, name='AtlasEnergyLossUpdator', **kwargs)
Definition: AtlasExtrapolatorToolsConfig.py:12
MuidCaloEnergyParam
MuonCombinedRecToolsConfig.MuonInDetForwardCandidateToolCfg
def MuonInDetForwardCandidateToolCfg(flags, name='InDetForwardCandidateTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:27
MuonCombinedRecToolsConfig.EMEO_MuonSegmentRegionRecoveryToolCfg
def EMEO_MuonSegmentRegionRecoveryToolCfg(flags, name="MuonSegmentRegionRecoveryTool_EMEO")
Definition: MuonCombinedRecToolsConfig.py:622
MuonCombinedRecToolsConfig.MuonAlignmentUncertToolPhiCfg
def MuonAlignmentUncertToolPhiCfg(flags, name="MuonAlignmentUncertToolPhi", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:687
MuonCombinedRecToolsConfig.ExtrapolateMuonToIPToolCfg
def ExtrapolateMuonToIPToolCfg(flags, name="ExtrapolateMuonToIPTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:201
MuonCombinedRecToolsConfig.MuonCandidateToolCfg
def MuonCandidateToolCfg(flags, name="MuonCandidateTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:222
python.InDetTrackSelectorToolConfig.MuonCombinedInDetDetailedTrackSelectorToolCfg
def MuonCombinedInDetDetailedTrackSelectorToolCfg(flags, name="MuonCombinedInDetDetailedTrackSelectorTool", **kwargs)
Definition: InDetTrackSelectorToolConfig.py:125
MuonCombinedRecToolsConfig.MuonLayerAmbiguitySolverToolCfg
def MuonLayerAmbiguitySolverToolCfg(flags, name="MuonLayerAmbiguitySolverTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1063
MuonCombinedRecToolsConfig.CombinedMuonTagTestToolCfg
def CombinedMuonTagTestToolCfg(flags, name='CombinedMuonTagTestTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:889
AtlasTrackingGeometryCondAlgConfig.TrackingGeometryCondAlgCfg
def TrackingGeometryCondAlgCfg(flags, name='AtlasTrackingGeometryCondAlg', doMaterialValidation=False, **kwargs)
Definition: AtlasTrackingGeometryCondAlgConfig.py:131
MuonCombinedRecToolsConfig.MuonCombinedToolCfg
def MuonCombinedToolCfg(flags, name="MuonCombinedTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:272
MuonSegmentFindingConfig.Csc2dSegmentMakerCfg
def Csc2dSegmentMakerCfg(flags, name="Csc2dSegmentMaker", **kwargs)
Definition: MuonSegmentFindingConfig.py:317
MuonCombinedRecToolsConfig.EMEO_MuonCombinedToolCfg
def EMEO_MuonCombinedToolCfg(flags, name="MuonCombinedTool_EMEO", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:342
MuonTrackBuildingConfig.MuonSegmentMatchingToolCfg
def MuonSegmentMatchingToolCfg(flags, name="MuonSegmentMatchingTool", **kwargs)
Definition: MuonTrackBuildingConfig.py:152
python.TrkTrackSummaryToolConfig.MuonTrackSummaryToolCfg
def MuonTrackSummaryToolCfg(flags, name="MuonTrackSummaryTool", **kwargs)
Definition: TrkTrackSummaryToolConfig.py:143
MuonCombinedRecToolsConfig.MuidMaterialEffectsOnTrackProviderParamCfg
def MuidMaterialEffectsOnTrackProviderParamCfg(flags, name='MuidMaterialEffectsOnTrackProviderParam', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:594
MuonCombinedRecToolsConfig.iPatFitterCfg
def iPatFitterCfg(flags, name='iPatFitter', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:409
MuonCombinedRecToolsConfig.CombinedMuonTrackBuilderCfg
def CombinedMuonTrackBuilderCfg(flags, name='CombinedMuonTrackBuilder', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:700
MuonCombinedRecToolsConfig.MuonStauRecoToolCfg
def MuonStauRecoToolCfg(flags, name="MuonStauRecoTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1090
MuonCombinedRecToolsConfig.MuidTrackIsolationCfg
def MuidTrackIsolationCfg(flags, name='MuidTrackIsolation', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:516
MuonCombinedRecToolsConfig.iPatSLFitterCfg
def iPatSLFitterCfg(flags, name='iPatSLFitter', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:440
MuonRecToolsConfig.MuonTrackScoringToolCfg
def MuonTrackScoringToolCfg(flags, name="MuonTrackScoringTool", **kwargs)
Definition: MuonRecToolsConfig.py:132
MuonCombinedRecToolsConfig.MuonCaloTagToolCfg
def MuonCaloTagToolCfg(flags, name='MuonCaloTagTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:944
MuonCombinedRecToolsConfig.MuidCaloTrackStateOnSurfaceCfg
def MuidCaloTrackStateOnSurfaceCfg(flags, name='MuidCaloTrackStateOnSurface', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:550
python.TrkTrackSummaryToolConfig.MuonCombinedTrackSummaryToolCfg
def MuonCombinedTrackSummaryToolCfg(flags, name="CombinedMuonTrackSummary", **kwargs)
Definition: TrkTrackSummaryToolConfig.py:153
MuonCombinedRecToolsConfig.MuidCaloTrackStateOnSurfaceParamCfg
def MuidCaloTrackStateOnSurfaceParamCfg(flags, name='MuidCaloTrackStateOnSurfaceParam', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:568
python.AtlasExtrapolatorToolsConfig.AtlasMultipleScatteringUpdatorCfg
def AtlasMultipleScatteringUpdatorCfg(flags, name="AtlasMultipleScatteringUpdator", **kwargs)
Definition: AtlasExtrapolatorToolsConfig.py:119
MuonCombinedRecToolsConfig.MuidMaterialEffectsOnTrackProviderCfg
def MuidMaterialEffectsOnTrackProviderCfg(flags, name='MuidMaterialEffectsOnTrackProvider', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:582
MuonCombinedRecToolsConfig.MuonLayerSegmentFinderToolCfg
def MuonLayerSegmentFinderToolCfg(flags, name="MuonLayerSegmentFinderTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:967
MuonCombinedRecToolsConfig.MuonSegmentConverterToolCfg
def MuonSegmentConverterToolCfg(flags, name="MuonSegmentConverterTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:119
MuonRIO_OnTrackCreatorToolConfig.CscClusterOnTrackCreatorCfg
def CscClusterOnTrackCreatorCfg(flags, name="CscClusterOnTrackCreator", **kwargs)
Definition: MuonRIO_OnTrackCreatorToolConfig.py:34
MuonCombinedRecToolsConfig.CaloMuonTagCfg
def CaloMuonTagCfg(flags, name="CaloMuonTag", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:937
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
MuonCombinedRecToolsConfig.InDetCandidateToolCfg
def InDetCandidateToolCfg(flags, name="InDetCandidateTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:18
TrackToCaloConfig.ParticleCaloCellAssociationToolCfg
def ParticleCaloCellAssociationToolCfg(flags, name='ParticleCaloCellAssociationTool', **kwargs)
Definition: TrackToCaloConfig.py:72
MuonCombinedRecToolsConfig.MuonCombinedDebuggerToolCfg
def MuonCombinedDebuggerToolCfg(flags, name="MuonCombinedDebuggerTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:262
MuonCombinedRecToolsConfig.MuidMuonRecoveryCfg
def MuidMuonRecoveryCfg(flags, name='MuidMuonRecovery', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:872
MuonCombinedRecToolsConfig.MuonTrackQueryCfg
def MuonTrackQueryCfg(flags, name="MuonTrackQuery", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:605
MuonCombinedRecToolsConfig.MuonLayerSegmentMatchingToolCfg
def MuonLayerSegmentMatchingToolCfg(flags, name="MuonLayerSegmentMatchingTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:997
MuonRecToolsConfig.MuonHitSummaryToolCfg
def MuonHitSummaryToolCfg(flags, name="MuonHitSummaryTool", **kwargs)
Definition: MuonRecToolsConfig.py:54
MuonCombinedRecToolsConfig.CombinedMuonTrackBuilderFitCfg
def CombinedMuonTrackBuilderFitCfg(flags, name='CombinedMuonTrackBuilderFit', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:824
python.TrkParticleCreatorConfig.MuonCaloParticleCreatorCfg
def MuonCaloParticleCreatorCfg(flags, name="MuonCaloParticleCreator", **kwargs)
Definition: TrkParticleCreatorConfig.py:388
MuonGeometryConfig.MuonGeoModelCfg
def MuonGeoModelCfg(flags)
Definition: MuonGeometryConfig.py:28
MuonCombinedRecToolsConfig.TrackDepositInCaloToolCfg
def TrackDepositInCaloToolCfg(flags, name='TrackDepositInCaloTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:903
python.TrkExSTEP_PropagatorConfig.AtlasSTEP_PropagatorCfg
def AtlasSTEP_PropagatorCfg(flags, name='AtlasSTEP_Propagator', **kwargs)
Definition: TrkExSTEP_PropagatorConfig.py:16
MuonCombinedRecToolsConfig.MuonCreatorToolCfg
def MuonCreatorToolCfg(flags, name="MuonCreatorTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:138
MuonCombinedRecToolsConfig.MuTagAmbiguitySolverToolCfg
def MuTagAmbiguitySolverToolCfg(flags, name='MuTagAmbiguitySolverTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1228
MuonCombinedRecToolsConfig.MuonSystemExtensionToolCfg
def MuonSystemExtensionToolCfg(flags, **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1166
MuonCombinedRecToolsConfig.MuonSegmentSelectionToolCfg
def MuonSegmentSelectionToolCfg(flags, name="MuonSegmentSelectionTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1045
MuonRecToolsConfig.MuonTrackCleanerCfg
def MuonTrackCleanerCfg(flags, name="MuonTrackCleaner", seg=False, **kwargs)
Definition: MuonRecToolsConfig.py:159
MuonSegmentFindingConfig.MuonLayerHoughAlgCfg
def MuonLayerHoughAlgCfg(flags, name="MuonLayerHoughAlg", **kwargs)
Definition: MuonSegmentFindingConfig.py:382
MuonCombinedRecToolsConfig.MuidMaterialAllocatorCfg
def MuidMaterialAllocatorCfg(flags, name='MuidMaterialAllocator', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:388
MuonCombinedRecToolsConfig.MuidErrorOptimisationToolCfg
def MuidErrorOptimisationToolCfg(flags, name='MuidErrorOptimisationTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:658
MuonCombinedRecToolsConfig.MuidCaloEnergyToolCfg
def MuidCaloEnergyToolCfg(flags, name='MuidCaloEnergyTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:527
python.InDetTrackSelectorToolConfig.CaloTrkMuIdAlgTrackSelectorToolCfg
def CaloTrkMuIdAlgTrackSelectorToolCfg(flags, name='CaloTrkMuIdAlgTrackSelectorTool', **kwargs)
Definition: InDetTrackSelectorToolConfig.py:176
MuonRecToolsConfig.MuonRefitToolCfg
def MuonRefitToolCfg(flags, name="MuonRefitTool", **kwargs)
Definition: MuonRecToolsConfig.py:279
python.TrkExRungeKuttaPropagatorConfig.MuonCombinedPropagatorCfg
def MuonCombinedPropagatorCfg(flags, name='MuonCombinedPropagator', **kwargs)
Definition: TrkExRungeKuttaPropagatorConfig.py:31
LArGMConfig.LArGMCfg
def LArGMCfg(flags)
Definition: LArGMConfig.py:8
MuonRecToolsConfig.MuonAmbiProcessorCfg
def MuonAmbiProcessorCfg(flags, name="MuonAmbiProcessor", **kwargs)
Definition: MuonRecToolsConfig.py:144
MuonCombinedRecToolsConfig.MuidCaloEnergyMeasCfg
def MuidCaloEnergyMeasCfg(flags, name='MuidCaloEnergyMeas', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:486
MuonCombinedRecToolsConfig.EMEO_CombinedTrackBuilderFitCfg
def EMEO_CombinedTrackBuilderFitCfg(flags, name="CombinedTrackBuilderFit_EMEO", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:845
MuonCombinedRecToolsConfig.CaloMuonScoreToolCfg
def CaloMuonScoreToolCfg(flags, name='CaloMuonScoreTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:927
python.AtlasExtrapolatorConfig.MuonExtrapolatorCfg
def MuonExtrapolatorCfg(flags, name="MuonExtrapolator", **kwargs)
Definition: AtlasExtrapolatorConfig.py:379
MuonRecToolsConfig.MuonTrackSummaryHelperToolCfg
def MuonTrackSummaryHelperToolCfg(flags, name="MuonTrackSummaryHelperTool", **kwargs)
Definition: MuonRecToolsConfig.py:123
python.MuonSelectorToolsConfig.MuonSelectionToolCfg
def MuonSelectionToolCfg(flags, name="MuonSelectionTool", **kwargs)
Definition: MuonSelectorToolsConfig.py:13
python.InDetTrackSelectorToolConfig.MuonCombinedInDetDetailedForwardTrackSelectorToolCfg
def MuonCombinedInDetDetailedForwardTrackSelectorToolCfg(flags, name='MuonCombinedInDetDetailedForwardTrackSelectorTool', **kwargs)
Definition: InDetTrackSelectorToolConfig.py:172
MuonTrackBuildingConfig.EMEO_MuonChamberHoleRecoveryToolCfg
def EMEO_MuonChamberHoleRecoveryToolCfg(flags, name="MuonChamberRecovery_EMEO")
Definition: MuonTrackBuildingConfig.py:359
MuonCombinedRecToolsConfig.MdtDriftCircleOnTrackCreatorStauCfg
def MdtDriftCircleOnTrackCreatorStauCfg(flags, name="MdtDriftCircleOnTrackCreatorStau", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1080
MuonCombinedRecToolsConfig.MuonDressingToolCfg
def MuonDressingToolCfg(flags, name="MuonDressingTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:128
python.TrkParticleCreatorConfig.MuonCombinedParticleCreatorCfg
def MuonCombinedParticleCreatorCfg(flags, name="MuonCombinedParticleCreator", **kwargs)
Definition: TrkParticleCreatorConfig.py:328
MuonCombinedRecToolsConfig.EMEO_CombinedMuonTrackBuilderCfg
def EMEO_CombinedMuonTrackBuilderCfg(flags, name="MuonCombinedTrackBuilder_EMEO")
Definition: MuonCombinedRecToolsConfig.py:645
MuonSegmentFindingConfig.Csc4dSegmentMakerCfg
def Csc4dSegmentMakerCfg(flags, name="Csc4dSegmentMaker", **kwargs)
Definition: MuonSegmentFindingConfig.py:335
MuonCombinedRecToolsConfig.MuTagMatchingToolCfg
def MuTagMatchingToolCfg(flags, name='MuTagMatchingTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1184
MuonRIO_OnTrackCreatorToolConfig.MuonClusterOnTrackCreatorCfg
def MuonClusterOnTrackCreatorCfg(flags, name="MuonClusterOnTrackCreator", **kwargs)
Definition: MuonRIO_OnTrackCreatorToolConfig.py:96
MuonRIO_OnTrackCreatorToolConfig.MdtCalibWindowNumber
def MdtCalibWindowNumber(name)
Definition: MuonRIO_OnTrackCreatorToolConfig.py:19
MuonCombinedRecToolsConfig.MuonMaterialProviderToolCfg
def MuonMaterialProviderToolCfg(flags, name="MuonTrkMaterialProviderTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:58
MuonCombinedRecToolsConfig.MuidCaloEnergyParam
def MuidCaloEnergyParam(flags, name='MuidCaloEnergyParam', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:481
MuonCombinedRecToolsConfig.CaloMuonLikelihoodToolCfg
def CaloMuonLikelihoodToolCfg(flags, name='CaloMuonLikelihoodTool', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:917
MuonSegmentFindingConfig.DCMathSegmentMakerCfg
def DCMathSegmentMakerCfg(flags, name='DCMathSegmentMaker', doSegmentT0Fit=False, **kwargs)
Definition: MuonSegmentFindingConfig.py:94
MuonCombinedRecToolsConfig.MuonSegmentHitSummaryToolCfg
def MuonSegmentHitSummaryToolCfg(flags, name="MuonSegmentHitSummaryTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:108
MuonTrackBuildingConfig.MuonChamberHoleRecoveryToolCfg
def MuonChamberHoleRecoveryToolCfg(flags, name="MuonChamberHoleRecoveryTool", **kwargs)
Definition: MuonTrackBuildingConfig.py:309
MuonCombinedRecToolsConfig.MuonCombinedStacoTagToolCfg
def MuonCombinedStacoTagToolCfg(flags, name="MuonCombinedStacoTagTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:371
MuonRIO_OnTrackCreatorToolConfig.MdtDriftCircleOnTrackCreatorCfg
def MdtDriftCircleOnTrackCreatorCfg(flags, name="MdtDriftCircleOnTrackCreator", **kwargs)
Definition: MuonRIO_OnTrackCreatorToolConfig.py:73
MuonCombinedRecToolsConfig.MuidTrackCleanerCfg
def MuidTrackCleanerCfg(flags, name='MuidTrackCleaner', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:448
MuonCombinedRecToolsConfig.MuonCandidateTrackBuilderToolCfg
def MuonCandidateTrackBuilderToolCfg(flags, name="MuonCandidateTrackBuilderTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1036
MuonTrackBuildingConfig.MooTrackBuilderCfg
def MooTrackBuilderCfg(flags, name="MooTrackBuilderTemplate", prefix="", doSegmentPhiMatching=True, **kwargs)
Definition: MuonTrackBuildingConfig.py:68
MuonSegmentFindingConfig.MuonPRDSelectionToolCfg
def MuonPRDSelectionToolCfg(flags, name="MuonPRDSelectionTool", **kwargs)
Definition: MuonSegmentFindingConfig.py:364
MuonSegmentFindingConfig.MuonNSWSegmentFinderToolCfg
def MuonNSWSegmentFinderToolCfg(flags, name='MuonNSWSegmentFinderTool', **kwargs)
Definition: MuonSegmentFindingConfig.py:342
python.MagFieldServicesConfig.AtlasFieldCacheCondAlgCfg
def AtlasFieldCacheCondAlgCfg(flags, **kwargs)
Definition: MagFieldServicesConfig.py:8
MuonCombinedRecToolsConfig.MuonAlignmentUncertToolThetaCfg
def MuonAlignmentUncertToolThetaCfg(flags, name="MuonAlignmentUncertToolTheta", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:675
python.TrkResidualPullCalculatorConfig.ResidualPullCalculatorCfg
def ResidualPullCalculatorCfg(flags, name='ResidualPullCalculator', **kwargs)
Definition: TrkResidualPullCalculatorConfig.py:6
MuonRecToolsConfig.MuonSeededSegmentFinderCfg
def MuonSeededSegmentFinderCfg(flags, name="MuonSeededSegmentFinder", **kwargs)
Definition: MuonRecToolsConfig.py:64
MuonCombinedRecToolsConfig.EMEO_MuonCombinedFitTagToolCfg
def EMEO_MuonCombinedFitTagToolCfg(flags, name="MuonCombinedFitTagTool_EMEO", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:331
python.SolenoidalIntersectorConfig.SolenoidalIntersectorCfg
def SolenoidalIntersectorCfg(flags, name='SolenoidalIntersector', **kwargs)
Definition: SolenoidalIntersectorConfig.py:7
MuonCombinedRecToolsConfig.MuidCaloEnergyToolParamCfg
def MuidCaloEnergyToolParamCfg(flags, name='MuidCaloEnergyToolParam', **kwargs)
Definition: MuonCombinedRecToolsConfig.py:499
MuonCombinedRecToolsConfig.MuonSegmentTagToolCfg
def MuonSegmentTagToolCfg(flags, name="MuonSegmentTagTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:1244
MuonRecToolsConfig.MuonEDMPrinterToolCfg
def MuonEDMPrinterToolCfg(flags, name="MuonEDMPrinterTool", **kwargs)
Definition: MuonRecToolsConfig.py:10
MuonTrackBuildingConfig.MuonSegmentRegionRecoveryToolCfg
def MuonSegmentRegionRecoveryToolCfg(flags, name="MuonSegmentRegionRecoveryTool", **kwargs)
Definition: MuonTrackBuildingConfig.py:217
MuonCombinedRecToolsConfig.MuonCaloEnergyToolCfg
def MuonCaloEnergyToolCfg(flags, name="MuonCaloEnergyTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:37
MuonCombinedRecToolsConfig.MuonCombinedFitTagToolCfg
def MuonCombinedFitTagToolCfg(flags, name="MuonCombinedFitTagTool", **kwargs)
Definition: MuonCombinedRecToolsConfig.py:301
TrackToCaloConfig.ParticleCaloExtensionToolCfg
def ParticleCaloExtensionToolCfg(flags, name='ParticleCaloExtensionTool', **kwargs)
Definition: TrackToCaloConfig.py:10
Generated on Thu Sep 4 2025 22:10:40 for ATLAS Offline Software by   doxygen 1.8.18