MuonTrackBuildingConfig.py

Go to the documentation of this file.

# Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaConfiguration.AccumulatorCache import AccumulatorCache
from TrkConfig.TrkGlobalChi2FitterConfig import MCTBFitterCfg, MCTBSLFitterCfg
from MuonConfig.MuonRecToolsConfig import MuonTrackCleanerCfg, MuonSegmentMomentumFromFieldCfg, MuonSeededSegmentFinderCfg, MuonEDMPrinterToolCfg
from AthenaConfiguration.Enums import BeamType
from MuonConfig.MuonSegmentFindingConfig import MuonSegmentFittingToolCfg 
 
def MooTrackFitterCfg(flags, name = 'MooTrackFitter', prefix='', **kwargs):
    # Based on https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MooreTools.py#L179
    # (Tons of explicit configuration missing from there though)
    Muon__MooTrackFitter=CompFactory.Muon.MooTrackFitter
    MuonSegmentMomentum=CompFactory.MuonSegmentMomentum
    from MuonConfig.MuonRecToolsConfig import MuonPhiHitSelectorCfg, MuonTrackToSegmentToolCfg, MuonTrackSummaryHelperToolCfg, MuPatHitToolCfg
    
    result = ComponentAccumulator()
    mctb_fitter = result.getPrimaryAndMerge(MCTBFitterCfg(flags, name = prefix+'MCTBFitter'))
    kwargs.setdefault("Fitter", mctb_fitter)
        
    mu_pat_hit_tool = result.popToolsAndMerge(MuPatHitToolCfg(flags))
    result.addPublicTool(mu_pat_hit_tool)
    kwargs.setdefault("HitTool", mu_pat_hit_tool)
    
    from TrkConfig.TrkExSTEP_PropagatorConfig import AtlasSTEP_PropagatorCfg
    muon_prop =  result.popToolsAndMerge(AtlasSTEP_PropagatorCfg(flags, name='MuonPropagator'))
    
    kwargs.setdefault("Propagator",      muon_prop)
    kwargs.setdefault("SLFit" ,   not (flags.BField.barrelToroidOn and flags.BField.endcapToroidOn) )
    if flags.Muon.MuonTrigger:
        kwargs.setdefault("SLFit", False)
    kwargs.setdefault("ReducedChi2Cut",  flags.Muon.Chi2NDofCut)
    
    momentum_estimator=""
    if flags.Beam.Type is BeamType.Cosmics:
        momentum_estimator = MuonSegmentMomentum(DoCosmics = True)
    else:
        momentum_estimator=result.popToolsAndMerge(MuonSegmentMomentumFromFieldCfg(flags))
        
    result.addPublicTool(momentum_estimator)
    kwargs.setdefault("SegmentMomentum", momentum_estimator )
    
    kwargs.setdefault("MuonPrinterTool", result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags) ))
 
    track_to_segment_tool =  result.popToolsAndMerge(MuonTrackToSegmentToolCfg(flags))
    kwargs.setdefault("TrackToSegmentTool", track_to_segment_tool)    
   
    kwargs.setdefault("PhiHitSelector",  result.popToolsAndMerge(MuonPhiHitSelectorCfg(flags)))
    kwargs.setdefault("TrackCleaner",  result.popToolsAndMerge(MuonTrackCleanerCfg(flags)))
    kwargs.setdefault("SegmentInOverlapTool",  result.popToolsAndMerge(MuonSegmentInOverlapResolvingToolCfg(flags)))
 
    # Leaving "SegmentInOverlapTool" as default, which is what happens in the current configuration.
    
    track_summary_helper = result.popToolsAndMerge(MuonTrackSummaryHelperToolCfg(flags)) 
    kwargs.setdefault("TrackSummaryTool",  track_summary_helper)
    
    kwargs.setdefault("CleanPhiHits",              True)
    kwargs.setdefault("UsePreciseHits",            True)
    kwargs.setdefault("UsePrefit",                 False)
    kwargs.setdefault("SeedAtStartOfTrack",        False)
    
    fitter = Muon__MooTrackFitter(prefix + name, **kwargs)
    result.setPrivateTools(fitter)
    return result
 
@AccumulatorCache
def MooTrackBuilderCfg(flags, name="MooTrackBuilderTemplate", prefix="", doSegmentPhiMatching=True, **kwargs):
    Muon__MooTrackBuilder=CompFactory.Muon.MooTrackBuilder
    from MuonConfig.MuonRIO_OnTrackCreatorToolConfig import MdtDriftCircleOnTrackCreatorCfg, TriggerChamberClusterOnTrackCreatorCfg
    from MuonConfig.MuonRecToolsConfig import MuonTrackToSegmentToolCfg, MuonTrackExtrapolationToolCfg
    from MagFieldServices.MagFieldServicesConfig import AtlasFieldCacheCondAlgCfg
    
    # Based on this: https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MooreTools.py#L221
    # ignoring all the name_prefix stuff for the moment, since I'm not sure it's necessary any more.
    result = ComponentAccumulator() 
    moo_track_fitter = result.popToolsAndMerge(MooTrackFitterCfg(flags, name='MooTrackFitter', prefix=prefix))
    kwargs.setdefault("Fitter", moo_track_fitter)
    
    # Now setup SL fitter (MooSLTrackFitter as defined here:
    # https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecExampleConfigDb.py#L203)
    mctbslfitter = result.popToolsAndMerge(MCTBSLFitterCfg(flags, name=prefix+'MCTBSLFitter'))
    
    # Just take the default configuration, as per https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecExampleConfigDb.py#L56
    from TrkConfig.TrkExSTEP_PropagatorConfig import AtlasSTEP_PropagatorCfg
    muon_prop = result.popToolsAndMerge(AtlasSTEP_PropagatorCfg(flags, name = 'MuonStraightLinePropagator'))
 
    moo_sl_track_fitter = result.popToolsAndMerge(MooTrackFitterCfg( flags, name="MooSLTrackFitter", prefix=prefix, Fitter = mctbslfitter, Propagator=muon_prop, ReducedChi2Cut=10.0,  SLFit=True))
    
    kwargs.setdefault("SLFitter", moo_sl_track_fitter)
    kwargs.setdefault("RecalibrateMDTHitsOnTrack", ( (not flags.Muon.doSegmentT0Fit) and flags.Beam.Type is BeamType.Collisions) )
    
    muon_seeded_segment_finder = result.popToolsAndMerge(MuonSeededSegmentFinderCfg(flags))
    kwargs.setdefault("SeededSegmentFinder", muon_seeded_segment_finder)
 
    mdt_dcot_creator = result.popToolsAndMerge(MdtDriftCircleOnTrackCreatorCfg(flags))
    kwargs.setdefault("MdtRotCreator", mdt_dcot_creator)
    
    muon_comp_cluster_creator =  result.popToolsAndMerge(TriggerChamberClusterOnTrackCreatorCfg(flags))
    kwargs.setdefault("CompetingClustersCreator", muon_comp_cluster_creator)    
    
    kwargs.setdefault("Propagator", muon_prop) 
    kwargs.setdefault("ChamberHoleRecoveryTool",  
                     result.popToolsAndMerge(MuonChamberHoleRecoveryToolCfg(flags))) 
 
    result.merge(AtlasFieldCacheCondAlgCfg(flags) )
    
    kwargs.setdefault("TrackToSegmentTool",  result.popToolsAndMerge(MuonTrackToSegmentToolCfg(flags)))        
    kwargs.setdefault("Printer", result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags)))
    kwargs.setdefault('Extrapolator', result.popToolsAndMerge( MuonTrackExtrapolationToolCfg(flags) ) )
 
    # FIXME - remove ErrorOptimisationTool from cxx?
    # declareProperty("ErrorOptimisationTool","" );Extrapolator
    kwargs.setdefault("CandidateTool",       result.popToolsAndMerge(MuPatCandidateToolCfg(flags)))
 
    kwargs.setdefault("CandidateMatchingTool", 
                      result.popToolsAndMerge(MooCandidateMatchingToolCfg(flags, name = 'MooCandidateMatchingTool', 
                      doSegmentPhiMatching=doSegmentPhiMatching, prefix=prefix)))
 
    from TrkConfig.TrkTrackSummaryToolConfig import MuonTrackSummaryToolCfg
    kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(MuonTrackSummaryToolCfg(flags)))
 
    if "PullCalculator" not in kwargs:
        from TrkConfig.TrkResidualPullCalculatorConfig import (
            ResidualPullCalculatorCfg)
        kwargs.setdefault("PullCalculator", result.popToolsAndMerge(
            ResidualPullCalculatorCfg(flags)))
 
    result.setPrivateTools(Muon__MooTrackBuilder(name, **kwargs))
    return result
 
def MuonSegmentInOverlapResolvingToolCfg(flags, name="MuonSegmentInOverlapResolvingTool", **kwargs):
    from MuonConfig.MuonRecToolsConfig import MuonEDMHelperSvcCfg
    from TrkConfig.TrkExRungeKuttaPropagatorConfig import RungeKuttaPropagatorCfg
    result = ComponentAccumulator()
    kwargs.setdefault("edmHelper", result.getPrimaryAndMerge(MuonEDMHelperSvcCfg(flags)) )
    kwargs.setdefault("Printer", result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags)) )
    kwargs.setdefault("AtlasRungeKuttaPropagator", result.popToolsAndMerge(
        RungeKuttaPropagatorCfg(flags)))
 
    if "ResidualPullCalculator" not in kwargs:
        from TrkConfig.TrkResidualPullCalculatorConfig import (
            ResidualPullCalculatorCfg)
        kwargs.setdefault("ResidualPullCalculator", result.popToolsAndMerge(
            ResidualPullCalculatorCfg(flags)))
    
    result.setPrivateTools(CompFactory.Muon.MuonSegmentInOverlapResolvingTool(name, **kwargs))
    return result
 
# Taken from https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MooreTools.py#L268
# Not bothering with MuonSegmentMatchingToolTight - just pass in TightSegmentMatching=True
def MuonSegmentMatchingToolCfg(flags, name="MuonSegmentMatchingTool", **kwargs):
    Muon__MuonSegmentMatchingTool=CompFactory.Muon.MuonSegmentMatchingTool
 
    kwargs.setdefault( "doThetaMatching", flags.Muon.useSegmentMatching)
    kwargs.setdefault( "doPhiMatching", False )
    if flags.Beam.Type is BeamType.Cosmics:
        kwargs.setdefault("OverlapMatchAveragePhiHitPullCut",  200.)
        kwargs.setdefault( "ToroidOn", False ) # Was "not jobproperties.BField.allToroidOn()" but do not have access to Field here.
 
    # There are two tools which this depends on which aren't properties and which weren't defined in old configuration
    # Ignore for now, but FIXME one day
 
    # m_pairMatchingTool("Muon::MuonSegmentPairMatchingTool/MuonSegmentPairMatchingTool"),
    # Also, residual pull calculator not yet configured. #FIXME
    
    result = MuonEDMPrinterToolCfg(flags)
    kwargs.setdefault("Printer", result.getPrimary() )
    kwargs.setdefault("MuonSegmentInOverlapResolvingTool", result.popToolsAndMerge(
        MuonSegmentInOverlapResolvingToolCfg(flags)))
    kwargs.setdefault("MuonSegmentPairMatchingTool", CompFactory.Muon.MuonSegmentPairMatchingTool('MuonSegmentPairMatchingTool'))
 
    matching = Muon__MuonSegmentMatchingTool(name, **kwargs)
    result.setPrivateTools(matching)
    return result
    
def MooCandidateMatchingToolCfg(flags, name="MooCandidateMatchingTool", doSegmentPhiMatching=False, prefix="", **kwargs):
    Muon__MooCandidateMatchingTool=CompFactory.Muon.MooCandidateMatchingTool
    from TrkConfig.AtlasExtrapolatorConfig import AtlasExtrapolatorCfg
    
    result = ComponentAccumulator()
 
    # Won't explicitly configure MuonEDMHelperSvc
    kwargs.setdefault("MuonPrinterTool", result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags) ))
    kwargs.setdefault("Extrapolator", result.popToolsAndMerge(AtlasExtrapolatorCfg(flags)))
 
    acc = MuonSegmentMatchingToolCfg(flags, name=prefix+"MuonSegmentMatchingTool", doPhiMatching = doSegmentPhiMatching)
    muon_seg_matching = acc.getPrimary()
    result.merge(acc)
    kwargs.setdefault("SegmentMatchingTool",      muon_seg_matching)
 
    acc = MuonSegmentMatchingToolCfg(flags, name = prefix+"MuonSegmentMatchingToolTight", TightSegmentMatching=True, doPhiMatching = doSegmentPhiMatching)
    muon_seg_matching_tight = acc.getPrimary()
    result.merge(acc)
    kwargs.setdefault("SegmentMatchingToolTight", muon_seg_matching_tight)
        
    kwargs.setdefault("DoTrackSegmentMatching", flags.Muon.useTrackSegmentMatching)
    kwargs.setdefault("RequireSameSide", flags.Beam.Type is not BeamType.Collisions)
    if flags.Muon.useAlignmentCorrections:
        kwargs.setdefault("AlignmentErrorPosX",   5.0)
        kwargs.setdefault("AlignmentErrorPosY",   0.2)
        kwargs.setdefault("AlignmentErrorAngleX", 0.002)
        kwargs.setdefault("AlignmentErrorAngleY", 0.001)
 
    else: # no alignment corrections
        kwargs.setdefault("AlignmentErrorPosX",   10.0)
        kwargs.setdefault("AlignmentErrorPosY",   5.0)
        kwargs.setdefault("AlignmentErrorAngleX", 0.004)
        kwargs.setdefault("AlignmentErrorAngleY", 0.002)
 
    kwargs.setdefault("MuPatCandidateTool",  result.popToolsAndMerge(MuPatCandidateToolCfg(flags))) 
    
    moo_cand_matching_tool = Muon__MooCandidateMatchingTool(prefix+name,**kwargs)
    result.setPrivateTools(moo_cand_matching_tool)
    return result
 
def MuonSegmentRegionRecoveryToolCfg(flags, name="MuonSegmentRegionRecoveryTool", **kwargs):
    from TrkConfig.AtlasExtrapolatorConfig import MuonExtrapolatorCfg
    from TrkConfig.TrkTrackSummaryToolConfig import MuonTrackSummaryToolCfg
    from MuonConfig.MuonCondAlgConfig import MuonStationIntersectCondAlgCfg
    from MuonCombinedConfig.MuonCombinedRecToolsConfig import CombinedMuonTrackBuilderFitCfg
    from MuonConfig.MuonRecToolsConfig import MuonHitSummaryToolCfg
 
    # Based on https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MooreTools.py#L426
    
    result = ComponentAccumulator()
    kwargs.setdefault("SeededSegmentFinder", 
                       result.popToolsAndMerge(MuonSeededSegmentFinderCfg(flags)))
    
    kwargs.setdefault("TrackSegmentMatchingTool", 
                      result.popToolsAndMerge(MooCandidateMatchingToolCfg(flags)))
    
    kwargs.setdefault("ChamberHoleRecoveryTool", 
                      result.popToolsAndMerge(MuonChamberHoleRecoveryToolCfg(flags)))
    
    kwargs.setdefault("Extrapolator", 
                      result.popToolsAndMerge(MuonExtrapolatorCfg(flags)))
    if 'OnlyEO' in kwargs:
        #MuonEORecoveryTool's CombinedMuonTrackBuilderFit apparently *should* have MuonHoleRecovery
        kwargs.setdefault("Builder",  result.popToolsAndMerge(
            CombinedMuonTrackBuilderFitCfg(flags)))
    else:
        kwargs.setdefault("Builder",  result.popToolsAndMerge(
            CombinedMuonTrackBuilderFitCfg(flags, MuonHoleRecovery= "")))
    
 
    kwargs.setdefault("Fitter", 
                      result.popToolsAndMerge(MCTBSLFitterCfg(flags, name='MCTBSLFitter')))
    kwargs.setdefault("HitSummaryTool",  result.popToolsAndMerge( MuonHitSummaryToolCfg(flags)))
    kwargs.setdefault("EDMPrinter", result.getPrimaryAndMerge(
        MuonEDMPrinterToolCfg(flags)))
    result.merge( MuonStationIntersectCondAlgCfg(flags))
    
    # Not bothering to handle IDHelper or EDMHelper. Default is okay.
    
    from RegionSelector.RegSelToolConfig import regSelTool_MDT_Cfg, regSelTool_RPC_Cfg, regSelTool_TGC_Cfg
    if flags.Detector.GeometryMDT:
        kwargs.setdefault("MDTRegionSelector", result.popToolsAndMerge(regSelTool_MDT_Cfg(flags)))
 
    if flags.Detector.GeometryTGC:
        kwargs.setdefault("TGCRegionSelector", result.popToolsAndMerge(regSelTool_TGC_Cfg(flags)))
 
    if flags.Detector.GeometryRPC:
        kwargs.setdefault("RPCRegionSelector", result.popToolsAndMerge(regSelTool_RPC_Cfg(flags)))
    
    if flags.Detector.GeometryCSC:
        from RegionSelector.RegSelToolConfig import regSelTool_CSC_Cfg
        kwargs.setdefault("CSCRegionSelector", result.popToolsAndMerge(regSelTool_CSC_Cfg(flags)))
 
    if flags.Detector.GeometrysTGC:
        from RegionSelector.RegSelToolConfig import regSelTool_STGC_Cfg
        kwargs.setdefault("STGCRegionSelector", result.popToolsAndMerge(regSelTool_STGC_Cfg(flags)))
   
    if flags.Detector.GeometryMM:
        from RegionSelector.RegSelToolConfig import regSelTool_MM_Cfg
        kwargs.setdefault("MMRegionSelector", result.popToolsAndMerge(regSelTool_MM_Cfg(flags)))
 
    kwargs.setdefault("TrackSummaryTool", result.popToolsAndMerge(MuonTrackSummaryToolCfg(flags)))
 
    segment_region_recovery_tool = CompFactory.Muon.MuonSegmentRegionRecoveryTool(name, **kwargs)
    result.setPrivateTools(segment_region_recovery_tool)
    return result
    
def MuPatCandidateToolCfg(flags, name="MuPatCandidateTool", **kwargs):
    # https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuPatTools.py#L32
    
    from MuonConfig.MuonRIO_OnTrackCreatorToolConfig import MdtDriftCircleOnTrackCreatorCfg, TriggerChamberClusterOnTrackCreatorCfg
    from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonSegmentSelectionToolCfg
    result = MdtDriftCircleOnTrackCreatorCfg(flags)
    kwargs.setdefault("MdtRotCreator", result.getPrimary())
 
    if flags.Detector.GeometryCSC:
        from MuonConfig.MuonRIO_OnTrackCreatorToolConfig import CscClusterOnTrackCreatorCfg
        kwargs.setdefault("CscRotCreator", result.popToolsAndMerge(CscClusterOnTrackCreatorCfg(flags)))
    else:
        kwargs.setdefault("CscRotCreator", "")
 
    kwargs.setdefault("CompetingClustersCreator", result.popToolsAndMerge(TriggerChamberClusterOnTrackCreatorCfg(flags)))
 
    kwargs.setdefault("MuonPrinterTool", result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags) ))
 
    from MuonConfig.MuonRecToolsConfig import MuPatHitToolCfg
    kwargs.setdefault("HitTool", result.getPrimaryAndMerge(MuPatHitToolCfg(flags)))
    kwargs.setdefault("SegmentSelector", result.popToolsAndMerge(MuonSegmentSelectionToolCfg(flags)))
 
    result.setPrivateTools(CompFactory.Muon.MuPatCandidateTool(name, **kwargs))
    return result
    
def MuonChamberHoleRecoveryToolCfg(flags, name="MuonChamberHoleRecoveryTool", **kwargs):
    result=ComponentAccumulator()
    # Not setting explicitly MuonStationIntersectSvc
 
    from TrkConfig.AtlasExtrapolatorConfig import MuonExtrapolatorCfg
    kwargs.setdefault("Extrapolator", result.popToolsAndMerge(MuonExtrapolatorCfg(flags)))
 
    from MuonConfig.MuonGeometryConfig import TrackingVolumesSvcCfg
    kwargs.setdefault("TrackingVolumesSvc", result.getPrimaryAndMerge(TrackingVolumesSvcCfg(flags)))
 
    if not flags.Detector.GeometryMDT:
          kwargs.setdefault("MdtPrepDataContainer","")
    else:
        from MuonConfig.MuonRIO_OnTrackCreatorToolConfig import MdtDriftCircleOnTrackCreatorCfg, MuonClusterOnTrackCreatorCfg
        kwargs.setdefault("MdtRotCreator", result.getPrimaryAndMerge(MdtDriftCircleOnTrackCreatorCfg(flags)))
    
    if not flags.Detector.GeometryRPC:
        kwargs.setdefault("RpcPrepDataContainer","")
    if not flags.Detector.GeometryTGC:
          kwargs.setdefault("TgcPrepDataContainer","")
 
    kwargs.setdefault("AddMeasurements",  not flags.Muon.doSegmentT0Fit )
    
        
    if flags.Detector.GeometryCSC:
        from MuonConfig.MuonRIO_OnTrackCreatorToolConfig import CscClusterOnTrackCreatorCfg
        kwargs.setdefault("CscRotCreator", result.popToolsAndMerge(CscClusterOnTrackCreatorCfg(flags)))
    else:
        kwargs.setdefault("CscPrepDataContainer","")
    
    kwargs.setdefault("ClusterRotCreator", result.popToolsAndMerge(MuonClusterOnTrackCreatorCfg(flags)))
    
    if not flags.Detector.GeometrysTGC:
        kwargs.setdefault("sTgcPrepDataContainer","")
    
    if not flags.Detector.GeometryMM:
        kwargs.setdefault("MMPrepDataContainer","")
 
    kwargs.setdefault('TgcPrepDataContainer', 'TGC_MeasurementsAllBCs')    
    kwargs.setdefault("EDMPrinter", result.getPrimaryAndMerge(MuonEDMPrinterToolCfg(flags) ))
 
    if "PullCalculator" not in kwargs:
        from TrkConfig.TrkResidualPullCalculatorConfig import (
            ResidualPullCalculatorCfg)
        kwargs.setdefault("PullCalculator", result.popToolsAndMerge(
            ResidualPullCalculatorCfg(flags)))
    
    result.setPrivateTools(CompFactory.Muon.MuonChamberHoleRecoveryTool(name, **kwargs))
    return result
 
def MuonTrackSteeringCfg(flags, name="MuonTrackSteering", **kwargs):
    Muon__MuonTrackSteering=CompFactory.Muon.MuonTrackSteering
    # This is based on https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonStandalone.py#L35
    result=ComponentAccumulator()
    
    # This was originally defined here: https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonStandaloneFlags.py#L137
    MoorelikeStrategy=[
         "BarrelCombined[CombineSegInStation,DoRefinement,DoAmbiSolving,CutSeedsOnTracks]:BML,BMS;BOL,BOS;BIL,BIS",
         "EndcapCombined[CombineSegInStation,DoRefinement,DoAmbiSolving,CutSeedsOnTracks]:EML,EMS;EOL,EOS;EIL,EIS;CSL,CSS;EEL,EES;BEE",
         "BarrelEndcap[CombineSegInStation,DoRefinement,DoAmbiSolving,CutSeedsOnTracks,BarrelEndcapFilter]:EML,EMS;EEL,EES;BML,BMS;EIL,EIS;BIL,BIS;BOL,BOS"]
    
    kwargs.setdefault("StrategyList", MoorelikeStrategy) 
    
    # Set properties which were set in MuonStandalone.py, and which aren't default (fix this later, because we don't want to break existing configuration)
    # extraFlags are ignored (don't believe they're necessary)
    
    result = MCTBSLFitterCfg(flags)
    mctbslfitter = result.getPrimary()
    
    acc = MuonSegmentRegionRecoveryToolCfg(flags, name='MuonEORecoveryTool', OnlyEO = True, Fitter=mctbslfitter, UseFitterOutlierLogic=False)
    muon_eo_recovery_tool = acc.getPrimary()
    result.merge(acc) 
    
    kwargs.setdefault("HoleRecoveryTool",       muon_eo_recovery_tool)
    kwargs.setdefault("SegSeedQCut", 2 if flags.Beam.Type != BeamType.Cosmics else 1)
    kwargs.setdefault("Seg2ndQCut", 1)
   
    if "TrackBuilderTool" not in kwargs:
        # Old config had: kwargs["TrackBuilderTool"] = getPublicToolClone("MooMuonTrackBuilder", "MooTrackBuilderTemplate",
        #                                                extraFlags=extraFlags)
        # For some strange reason, MooTrackBuilderTemplate was just a MooTrackBuilder i.e. they had:
        # addTool( "MuonRecExample.MooreTools.MooTrackBuilder", "MooTrackBuilderTemplate") but passing in extraFlags
        # I have simplified this. Also, in the old configuration there was the possiblity to set optimiseMomentumResolutionUsingChi2 to true in extraflags (which were passed to TrackBuilderTool but not TrackRefinementTool) - however I don't think this was used, and have removed it.
        # However some other things were set in extraFlags here: https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonStandalone.py#L39
        # So I might well have made a mistake. TODO check
        kwargs["TrackBuilderTool"] = result.popToolsAndMerge( MooTrackBuilderCfg(flags, name='MooMuonTrackBuilder', prefix="MuSt_"))
        
    if "TrackRefinementTool" not in kwargs:
        kwargs["TrackRefinementTool"] = result.popToolsAndMerge( MooTrackBuilderCfg(flags, name='MooTrackBuilderTemplate', doSegmentPhiMatching=False))
    
    acc=MuPatCandidateToolCfg(flags)
    cand_tool = acc.getPrimary()
    result.merge(acc)
    kwargs.setdefault("MuPatCandidateTool",       cand_tool) 
 
    from MuonConfig.MuonRecToolsConfig import MuonAmbiProcessorCfg
    acc  = MuonAmbiProcessorCfg(flags, name='MuonAmbiProcessor')
    ambi = acc.getPrimary()
    result.merge(acc)
    kwargs.setdefault("AmbiguityTool",       ambi) 
    
    kwargs.setdefault("MooBuilderTool",       result.popToolsAndMerge( MooTrackBuilderCfg(flags, name='MooMuonTrackBuilder', prefix="MuSt_"))) 
    
    kwargs.setdefault("CandidateMatchingTool", 
                      result.popToolsAndMerge(MooCandidateMatchingToolCfg(flags, doSegmentPhiMatching=True)))
    
    kwargs.setdefault("MuonSegmentFittingTool",       
                       result.popToolsAndMerge(MuonSegmentFittingToolCfg(flags))) 
    kwargs.setdefault("MuonTrackSelector", 
                       result.popToolsAndMerge(MuonTrackSelectorCfg(flags)))
   
    kwargs.setdefault("HoleRecoveryTool",       
                      result.popToolsAndMerge(MuonChamberHoleRecoveryToolCfg(flags))) 
    
    from TrkConfig.TrkTrackSummaryToolConfig import MuonTrackSummaryToolCfg
    kwargs.setdefault("TrackSummaryTool",  result.popToolsAndMerge(MuonTrackSummaryToolCfg(flags)))
    kwargs.setdefault("DoSummary", flags.Muon.printSummary)
 
 
    track_maker_steering = Muon__MuonTrackSteering(name,**kwargs)
    result.setPrivateTools(track_maker_steering)
    return result
 
def MuonTrackSelectorCfg(flags, name = "MuonTrackSelectorTool", **kwargs):
    from MuonConfig.MuonRecToolsConfig import MuonTrackSummaryHelperToolCfg
 
    result = ComponentAccumulator()
    if flags.Beam.Type in [BeamType.Cosmics, BeamType.SingleBeam] or not flags.Input.isMC:
        kwargs.setdefault("UseRPCHoles", False) 
        kwargs.setdefault("UseTGCHoles", False) 
        kwargs.setdefault("MaxMdtHolesOnTwoStationTrack", 10) 
        kwargs.setdefault("MaxMdtHolesOnTrack", 30) 
        kwargs.setdefault("HolesToHitsRatioCutPerStation", 2) 
        kwargs.setdefault("CountMDTOutlierAsHoles", False) 
    else:
        kwargs.setdefault("MaxMdtHolesOnTwoStationTrack", 4) 
        kwargs.setdefault("MaxMdtHolesOnTrack", 5) 
        kwargs.setdefault("CountMDTOutlierAsHoles", True)
        
    kwargs.setdefault("TrackSummaryHelperTool",  result.popToolsAndMerge(MuonTrackSummaryHelperToolCfg(flags)))
 
    theTool = CompFactory.Muon.MuonTrackSelectorTool(name, **kwargs)
    result.setPrivateTools(theTool)
    return result
 
 
def MuPatTrackBuilderCfg(flags, name = "MuPatTrackBuilder", **kwargs):
    result=ComponentAccumulator()
    acc = MuonTrackSteeringCfg(flags)
    track_steering = acc.getPrimary()
    result.merge(acc)
    
    kwargs.setdefault("TrackSteering", track_steering)
    kwargs.setdefault("MuonSegmentCollection", "TrackMuonSegments")
    kwargs.setdefault("SpectrometerTrackOutputLocation", "MuonSpectrometerTracks")
 
    track_builder = CompFactory.MuPatTrackBuilder(name=name,  **kwargs)
    result.addEventAlgo( track_builder, primary=True )
   
    return result
def MuonTrackBuildingCfg(flags, name = "MuPatTrackBuilder", **kwargs):    
    # This is based on https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonStandalone.py#L162
    result=ComponentAccumulator()
    
    #Arguably this should be somewhere deeper - not quite sure where yet though. FIXME
    from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg 
    result.merge( MuonGeoModelCfg(flags) )
    from MuonConfig.MuonRecToolsConfig import MuonEDMHelperSvcCfg
    result.merge(MuonEDMHelperSvcCfg(flags))
    
    # release 21 ESDs contain a Trk::SegmentCollection named 'MuonSegments' instead of 'TrackMuonSegments', the following 2 lines account for that
    from MuonConfig.MuonSegmentNameFixConfig import MuonSegmentNameFixCfg
    result.merge(MuonSegmentNameFixCfg(flags))    
    result.merge(MuPatTrackBuilderCfg(flags))
    
    return result
    
 
if __name__=="__main__":
    # To run this, do e.g. 
    # python -m MuonConfig.MuonTrackBuildingConfig --run --threads=
    from MuonConfig.MuonConfigUtils import SetupMuonStandaloneConfigFlags, SetupMuonStandaloneOutput, SetupMuonStandaloneCA
    
    flags = SetupMuonStandaloneConfigFlags()
    cfg = SetupMuonStandaloneCA(flags)
 
    # Run the actual test.
    cfg.merge(MuonTrackBuildingCfg(flags))
 
            
    # This is a temporary fix - it should go someplace central as it replaces the functionality of addInputRename from here:
    # https://gitlab.cern.ch/atlas/athena/blob/master/Control/SGComps/python/AddressRemappingSvc.py
    AddressRemappingSvc, ProxyProviderSvc=CompFactory.getComps("AddressRemappingSvc","ProxyProviderSvc",)
    pps = ProxyProviderSvc()
    ars=AddressRemappingSvc()
    pps.ProviderNames += [ 'AddressRemappingSvc' ]
    ars.TypeKeyRenameMaps += [ '%s#%s->%s' % ("TrackCollection", "MuonSpectrometerTracks", "MuonSpectrometerTracks_old") ]
    
    cfg.addService(pps)
    cfg.addService(ars)
 
    itemsToRecord = ["TrackCollection#MuonSpectrometerTracks"] 
    SetupMuonStandaloneOutput(cfg, flags, itemsToRecord)
    
    cfg.printConfig(withDetails = True)
              
    f=open("MuonTrackBuilding.pkl","wb")
    cfg.store(f)
    f.close()
    
    from MuonConfig.MuonConfigUtils import executeTest
    executeTest(cfg)