diff --git a/MuonSpectrometer/MuonConfig/python/MuonBytestreamDecodeConfig.py b/MuonSpectrometer/MuonConfig/python/MuonBytestreamDecodeConfig.py
index 28e9d8dc1a1337ba8c8f556e25f08c703debb3df..c8f42f6c464c50da1612802117ac47b161e6bb58 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonBytestreamDecodeConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonBytestreamDecodeConfig.py
@@ -1,6 +1,5 @@
-#
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-#
+
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaCommon.Constants import DEBUG
diff --git a/MuonSpectrometer/MuonConfig/python/MuonConfigFlags.py b/MuonSpectrometer/MuonConfig/python/MuonConfigFlags.py
index 99d6610de9e7be92e70b849c60f15ec125f04d4f..c38ad35fe384705f35dc8e41b861d80b162fc864 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonConfigFlags.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonConfigFlags.py
@@ -63,6 +63,7 @@ def createMuonConfigFlags():
mcf.addFlag("Muon.useTGCPriorNextBC",False) # Use TGC measurements from Prior and Next Bunch Crossings. These measurements are available in the real data since somewhere in 2008.
mcf.addFlag("Muon.useAlignmentCorrections",False) # Apply alignment corrections to MuonGeoModel. The corrections are read from a COOL database
mcf.addFlag("Muon.useWireSagCorrections",False) # tApply wire sag corrections.
+ # doNSWNewThirdChain redundant - check e.g. Detector.GeometryCSC
# makePRDs - surely this is top level and redundant with makeRIO?
@@ -73,7 +74,6 @@ def createMuonConfigFlags():
mcf.addFlag("Muon.strategy", []) # CutSeedsOnTracks, CombineSegInStation, DynamicSeeding, PreferOutsideIn, AllowOneSharedHit, DoRefinement, DoAmbiSolving
mcf.addFlag("Muon.trackBuilder", "Moore") # Allowed: 'Moore','TruthTracking','None'
mcf.addFlag("Muon.refinementTool", "Moore") # Allowed: Moore TODO surely we can drop this if there is only one option?
- mcf.addFlag("Muon.optimiseMomentumResolutionUsingChi2", False)
mcf.addFlag("Muon.patternsOnly", False) # TODO probably can be dropped? Just disable later steps.
mcf.addFlag("Muon.createTrackParticles", True ) # TODO do we ever turn this off?
mcf.addFlag("Muon.straightLineFitMomentum", 2000.0 )
diff --git a/MuonSpectrometer/MuonConfig/python/MuonRIO_OnTrackCreatorConfig.py b/MuonSpectrometer/MuonConfig/python/MuonRIO_OnTrackCreatorConfig.py
index 3bdf2d38e8c7f3d7b7e61c1492ba960a4317fc02..18a7b5157da427d6cadebd82bb5574a162ced945 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonRIO_OnTrackCreatorConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonRIO_OnTrackCreatorConfig.py
@@ -6,6 +6,17 @@ from MuonCnvExample.MuonCnvUtils import mdtCalibWindowNumber # TODO should maybe
from MdtDriftCircleOnTrackCreator.MdtDriftCircleOnTrackCreatorConf import Muon__MdtDriftCircleOnTrackCreator
from MuonClusterOnTrackCreator.MuonClusterOnTrackCreatorConf import Muon__CscClusterOnTrackCreator, Muon__MuonClusterOnTrackCreator
from TrkRIO_OnTrackCreator.TrkRIO_OnTrackCreatorConf import Trk__RIO_OnTrackCreator
+from MuonCompetingClustersOnTrackCreator.MuonCompetingClustersOnTrackCreatorConf import Muon__TriggerChamberClusterOnTrackCreator
+
+def TriggerChamberClusterOnTrackCreatorCfg(flags, **kwargs):
+ result=ComponentAccumulator()
+ acc = MuonClusterOnTrackCreatorCfg(flags)
+ muon_cluster_creator=acc.getPrimary()
+ result.merge(acc)
+ kwargs.setdefault("ClusterCreator", muon_cluster_creator)
+ result.setPrivateTools(Muon__TriggerChamberClusterOnTrackCreator(**kwargs))
+ return result
+
def CscClusterOnTrackCreatorCfg(flags,**kwargs):
from MuonConfig.MuonSegmentFindingConfig import QratCscClusterFitterCfg
diff --git a/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py b/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py
index 8433f2d2b018f4f763288c309a7b69559ea5a93c..25cfd6739e90c821aa1efc4994b9816cabf6d5cb 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py
@@ -1,6 +1,5 @@
-#
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-#
+
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaCommon.Constants import VERBOSE, DEBUG
diff --git a/MuonSpectrometer/MuonConfig/python/MuonRecToolsConfig.py b/MuonSpectrometer/MuonConfig/python/MuonRecToolsConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..af02ce1b63acafdaf4e3b91598d5e5bf0cf57f2d
--- /dev/null
+++ b/MuonSpectrometer/MuonConfig/python/MuonRecToolsConfig.py
@@ -0,0 +1,354 @@
+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+
+# Configuration of tools shared between Segment Finding and Track Building
+
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+
+# Tracking
+from TrkDetDescrSvc.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg
+
+def MuonSeededSegmentFinderCfg(flags,name="MuonSeededSegmentFinder", **kwargs):
+ from MuonTrackFinderTools.MuonTrackFinderToolsConf import Muon__MuonSeededSegmentFinder
+ from MuonSegmentFindingConfig import DCMathSegmentMakerCfg, MdtMathSegmentFinder # FIXME - should really shift this to RecTools then.
+ result = ComponentAccumulator()
+
+ mdt_segment_finder = MdtMathSegmentFinder(flags, name="MCTBMdtMathSegmentFinder", UseChamberTheta = False, AssociationRoadWidth = 1.5)
+ result.addPublicTool(mdt_segment_finder)
+
+ if "SegmentMaker" not in kwargs or "SegmentMakerNoHoles" not in kwargs:
+ seg_maker=""
+ acc={}
+ if flags.Beam.Type == 'collisions':
+ acc = DCMathSegmentMakerCfg( flags, MdtSegmentFinder = mdt_segment_finder, SinAngleCut = 0.04, DoGeometry = True)
+ else: # cosmics or singlebeam
+ acc = DCMathSegmentMakerCfg( flags, MdtSegmentFinder = mdt_segment_finder, SinAngleCut = 0.1, DoGeometry = False, AddUnassociatedPhiHits= True )
+ seg_maker = acc.getPrimary()
+ result.merge(acc)
+ result.addPublicTool(seg_maker)
+ kwargs.setdefault("SegmentMaker", seg_maker)
+ kwargs.setdefault("SegmentMakerNoHoles", seg_maker) #FIXME. Just remove one.
+ if not flags.Detector.GeometryCSC:
+ kwargs.setdefault("CscPrepDataContainer","")
+ else:
+ kwargs.setdefault("sTgcPrepDataContainer","")
+ kwargs.setdefault("MMPrepDataContainer","")
+
+ muon_seeded_segment_finder = Muon__MuonSeededSegmentFinder(name, **kwargs)
+ result.setPrivateTools(muon_seeded_segment_finder)
+ return result
+
+
+def MuonSegmentMomentumFromFieldCfg(flags, name="MuonSegmentMomentumFromField", **kwargs):
+ from MuonSegmentMomentum.MuonSegmentMomentumConf import MuonSegmentMomentumFromField
+ from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
+
+ result = ComponentAccumulator()
+ acc = MagneticFieldSvcCfg(flags)
+ magfieldsvc = acc.getPrimary()
+ result.merge(acc)
+ kwargs.setdefault("MagFieldSvc", magfieldsvc)
+
+ navigator_ca = MuonNavigatorCfg(flags)
+ navigator = navigator_ca.popPrivateTools()
+ result.addPublicTool(navigator)
+ result.merge(navigator_ca)
+ kwargs.setdefault("NavigatorTool", navigator)
+
+ acc = MuonSTEP_PropagatorCfg(flags)
+ muon_prop = acc.getPrimary()
+ result.merge(acc)
+ result.addPublicTool(muon_prop)
+ kwargs.setdefault("PropagatorTool", muon_prop)
+
+ muon_seg_mom_from_field = MuonSegmentMomentumFromField(name=name, **kwargs)
+ result.setPrivateTools(muon_seg_mom_from_field)
+ return result
+
+def MuonTrackSummaryHelperToolCfg(flags, name="MuonTrackSummaryHelperTool", **kwargs):
+ # m_muonTgTool("MuonHolesOnTrack"),
+ # m_idHelperTool("Muon::MuonIdHelperTool/MuonIdHelperTool"),
+ # m_edmHelperTool("Muon::MuonEDMHelperSvc/MuonEDMHelperSvc"),
+ # m_extrapolator("Trk::Extrapolator/AtlasExtrapolator"),
+ # m_slExtrapolator("Trk::Extrapolator/MuonStraightLineExtrapolator"),
+
+ result = ComponentAccumulator()
+ acc = TrackingGeometrySvcCfg(flags)
+
+ result.merge(acc)
+ kwargs.setdefault("TrackingGeometryName", 'AtlasTrackingGeometry') # FIXME - get this from somewhere?
+
+ acc = MuonExtrapolatorCfg(flags)
+ extrap = acc.getPrimary()
+ acc.addPublicTool(extrap)
+ result.merge(acc)
+ kwargs.setdefault("Extrapolator", extrap)
+
+ from MuonTGRecTools.MuonTGRecToolsConf import Muon__MuonHolesOnTrackTool
+ holetool = Muon__MuonHolesOnTrackTool (ExtrapolatorName = extrap,
+ TrackingGeometryName = 'MuonStandaloneTrackingGeometry')
+
+ kwargs.setdefault("DoHolesOnTrack", False)
+ kwargs.setdefault("CalculateCloseHits", True)
+ kwargs.setdefault("HoleOnTrackTool", holetool)
+
+ from MuonTrackSummaryHelperTool.MuonTrackSummaryHelperToolConf import Muon__MuonTrackSummaryHelperTool
+ result.setPrivateTools(Muon__MuonTrackSummaryHelperTool(name=name,**kwargs))
+ return result
+
+def MuonTrackSummaryToolCfg(flags, name="MuonTrackSummaryTool", **kwargs):
+ from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool
+
+ result = ComponentAccumulator()
+ acc = MuonTrackSummaryHelperToolCfg(flags)
+ track_summary_helper = acc.getPrimary()
+ acc.addPublicTool(track_summary_helper)
+ result.merge(acc)
+ kwargs.setdefault("MuonSummaryHelperTool", track_summary_helper )
+ kwargs.setdefault("doSharedHits", False )
+ kwargs.setdefault("AddDetailedMuonSummary", True )
+ result.setPrivateTools(Trk__TrackSummaryTool(name=name,**kwargs))
+ return result
+
+def MuonTrackScoringToolCfg(flags, name="MuonTrackScoringTool", **kwargs):
+ from MuonTrackFinderTools.MuonTrackFinderToolsConf import Muon__MuonTrackScoringTool
+
+ # m_trkSummaryTool("Trk::TrackSummaryTool"),
+ # m_printer("Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"),
+ result = ComponentAccumulator()
+ acc = MuonTrackSummaryToolCfg(flags)
+ track_summary = acc.getPrimary( )
+ acc.addPublicTool(track_summary)
+ result.merge(acc)
+ kwargs.setdefault('SumHelpTool', track_summary)
+ result.setPrivateTools(Muon__MuonTrackScoringTool(name=name,**kwargs))
+ return result
+
+def MuonAmbiProcessorCfg(flags, name="MuonAmbiProcessor", **kwargs):
+ from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__TrackSelectionProcessorTool
+ from MuonAmbiTrackSelectionTool.MuonAmbiTrackSelectionToolConf import Muon__MuonAmbiTrackSelectionTool
+
+ #m_scoringTool("Trk::TrackScoringTool/TrackScoringTool"),
+ #m_selectionTool("InDet::InDetAmbiTrackSelectionTool/InDetAmbiTrackSelectionTool")
+ result = ComponentAccumulator()
+ kwargs.setdefault('DropDouble', False)
+ acc = MuonTrackScoringToolCfg( flags )
+ scoring_tool = acc.getPrimary()
+ acc.addPublicTool(scoring_tool)
+ result.merge(acc)
+ kwargs.setdefault('ScoringTool', scoring_tool )
+ muon_ami_selection_tool = Muon__MuonAmbiTrackSelectionTool()
+ result.addPublicTool(muon_ami_selection_tool)
+ kwargs.setdefault('SelectionTool', muon_ami_selection_tool)
+ result.setPrivateTools(Trk__TrackSelectionProcessorTool(name=name,**kwargs))
+ return result
+
+def MuonTrackCleanerCfg(flags, **kwargs):
+ from MuonTrackFinderTools.MuonTrackFinderToolsConf import Muon__MuonTrackCleaner
+ from MuonConfig.MuonRIO_OnTrackCreatorConfig import MdtDriftCircleOnTrackCreatorCfg, TriggerChamberClusterOnTrackCreatorCfg
+ # declareProperty("IdHelper",m_idHelper);
+ # declareProperty("Helper",m_edmHelperSvc);
+ # declareProperty("Printer",m_printer);
+ # declareProperty("MdtRotCreator", m_mdtRotCreator );
+ # declareProperty("CompRotCreator", m_compRotCreator );
+ # declareProperty("PullCalculator", m_pullCalculator );
+ # declareProperty("Extrapolator", m_extrapolator );
+ # declareProperty("MagFieldSvc", m_magFieldSvc );
+ # declareProperty("MeasurementUpdator", m_measurementUpdator );
+ result=ComponentAccumulator()
+
+ acc = MdtDriftCircleOnTrackCreatorCfg(flags)
+ mdt_creator=acc.getPrimary()
+ result.merge(acc)
+ kwargs.setdefault("MdtRotCreator", mdt_creator)
+
+ acc = TriggerChamberClusterOnTrackCreatorCfg(flags)
+ muon_cluster_creator=acc.getPrimary()
+ result.merge(acc)
+ kwargs.setdefault("CompRotCreator", muon_cluster_creator)
+
+ # For PullCalculator, just let it get default for moment. FIXME
+
+ extrapolator_CA = MuonExtrapolatorCfg(flags)
+ extrapolator = extrapolator_CA.getPrimary()
+ acc.addPublicTool( extrapolator ) # TODO remove
+ result.merge( extrapolator_CA )
+ kwargs.setdefault("Extrapolator", extrapolator)
+
+ acc = MCTBFitterCfg(flags, name = "SLFitter", StraightLine=True)
+ slfitter = acc.getPrimary()
+ acc.addPublicTool(slfitter)
+ result.merge(acc)
+ kwargs.setdefault("SLFitter", slfitter)
+
+ acc = MCTBFitterCfg(flags, name = "CurvedFitter")
+ fitter = acc.getPrimary()
+
+ acc.addPublicTool(fitter)
+ result.merge(acc)
+ kwargs.setdefault("Fitter", fitter)
+
+ # kwargs.setdefault("MagFieldSvc", mag_field_svc) Default for moment
+
+ # FIXME - do remaining tools
+
+ result.setPrivateTools(Muon__MuonTrackCleaner(**kwargs))
+
+ return result
+
+def MuonStationIntersectSvcCfg(flags, name='MuonStationIntersectSvc',**kwargs):
+ from MuonStationIntersectSvc.MuonStationIntersectSvcConf import MuonStationIntersectSvc
+ from MuonConfig.MuonCondSvcConfig import MDTCondSummarySvcCfg
+ # Has dependency on MDTCondSummarySvc and IdHelperTool (which we ignore for now)
+ result = ComponentAccumulator()
+ acc = MDTCondSummarySvcCfg(flags)
+ mdt_cond_summary_svc = acc.getPrimary()
+ result.merge(acc)
+ kwargs.setdefault("MDTCondSummarySvc", mdt_cond_summary_svc)
+ muon_station_intersect_svc = MuonStationIntersectSvc(name=name, **kwargs)
+ result.addService(muon_station_intersect_svc, primary=True)
+ return result
+
+# default muon navigator
+def MuonNavigatorCfg(flags, name="MuonNavigator", **kwargs):
+ from TrkExTools.TrkExToolsConf import Trk__Navigator
+
+ result = ComponentAccumulator()
+
+ acc = TrackingGeometrySvcCfg(flags)
+ result.merge(acc)
+ kwargs.setdefault("TrackingGeometrySvc", acc.getPrimary() )
+
+ navigator = Trk__Navigator(name=name, **kwargs)
+ result.setPrivateTools(navigator)
+ return result
+
+def MuonExtrapolatorCfg(flags,name = "MuonExtrapolator", **kwargs):
+ from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator, Trk__EnergyLossUpdator, Trk__MultipleScatteringUpdator
+
+ from TrkExTools.TrkExToolsConf import Trk__Extrapolator
+ result = ComponentAccumulator()
+
+ energy_loss_updator = Trk__EnergyLossUpdator() # Not really sure these should be tools...
+ result.addPublicTool(energy_loss_updator) # TODO remove
+
+ # This one has a dependency on RndNumberService
+ mult_scat_updator = Trk__MultipleScatteringUpdator()
+ result.addPublicTool(mult_scat_updator) # TODO remove
+
+ material_effects_updator = Trk__MaterialEffectsUpdator( EnergyLossUpdator=energy_loss_updator, MultipleScatteringUpdator=mult_scat_updator)
+ result.addPublicTool(material_effects_updator)
+ kwargs.setdefault("MaterialEffectsUpdators", [material_effects_updator])
+
+ navigator_ca = MuonNavigatorCfg(flags)
+ navigator = navigator_ca.popPrivateTools()
+ result.addPublicTool(navigator)
+ result.merge(navigator_ca)
+ kwargs.setdefault("Navigator", navigator)
+
+ acc = MuonSTEP_PropagatorCfg(flags, Tolerance = 0.00001, MaterialEffects=True, IncludeBgradients=True)
+ muon_prop = acc.getPrimary()
+ result.merge(acc)
+
+ result.addPublicTool(muon_prop)
+
+ kwargs.setdefault("Propagators", [muon_prop])
+ kwargs.setdefault("ResolveMuonStation", True)
+ kwargs.setdefault("Tolerance", 0.0011) # must be > 1um to avoid missing MTG intersections
+ extrap = Trk__Extrapolator(name=name, **kwargs)
+ result.setPrivateTools(extrap)
+ return result
+
+def MuonChi2TrackFitterCfg(flags, name='MuonChi2TrackFitter', **kwargs):
+ from TrkMeasurementUpdator.TrkMeasurementUpdatorConf import Trk__KalmanUpdator
+ from TrkGlobalChi2Fitter.TrkGlobalChi2FitterConf import Trk__GlobalChi2Fitter
+ import MuonConfig.MuonRIO_OnTrackCreatorConfig # Trying to avoid circular dependencies here
+
+ result = ComponentAccumulator()
+
+ extrapolator_CA = MuonExtrapolatorCfg(flags)
+ extrapolator= extrapolator_CA.getPrimary()
+
+ result.addPublicTool(extrapolator) # TODO remove
+ result.merge(extrapolator_CA)
+
+ acc = MuonConfig.MuonRIO_OnTrackCreatorConfig.MuonRotCreatorCfg(flags)
+ rotcreator=acc.getPrimary()
+ result.merge(acc)
+
+ measurement_updater = Trk__KalmanUpdator()
+ result.addPublicTool(measurement_updater) #FIXME
+
+ kwargs.setdefault("ExtrapolationTool" , extrapolator)
+ kwargs.setdefault("RotCreatorTool" , rotcreator)
+ kwargs.setdefault("MeasurementUpdateTool", measurement_updater)
+ kwargs.setdefault("StraightLine" , False)
+ kwargs.setdefault("OutlierCut" , 3.0)
+ kwargs.setdefault("GetMaterialFromTrack" , False)
+ kwargs.setdefault("RejectLargeNScat" , True)
+
+ # take propagator and navigator from the extrapolator
+ extrapolator_CA = MuonExtrapolatorCfg(flags)
+ result.addPublicTool(extrapolator_CA.getPrimary()) # TODO remove
+ result.merge(extrapolator_CA)
+
+ kwargs["ExtrapolationTool"] = extrapolator
+ kwargs["PropagatorTool"] = extrapolator.Propagators[0]
+ kwargs["NavigatorTool"] = extrapolator.Navigator
+
+ fitter = Trk__GlobalChi2Fitter(name=name, **kwargs)
+ result.setPrivateTools(fitter)
+ # print fitter
+ return result
+
+def MuonSTEP_PropagatorCfg(flags, name='MuonSTEP_Propagator', **kwargs):
+ # Really there should be a central configuration for the STEP propagator. FIXME
+ # In the old ConfigDb this was named MuonStraightLinePropagator (!)
+ from TrkExSTEP_Propagator.TrkExSTEP_PropagatorConf import Trk__STEP_Propagator
+ from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
+ result = ComponentAccumulator()
+
+ acc = MagneticFieldSvcCfg(flags)
+ magfieldsvc = acc.getPrimary()
+ result.merge(acc)
+
+ kwargs.setdefault("Tolerance", 0.00001 )
+ kwargs.setdefault("MaterialEffects", True )
+ kwargs.setdefault("IncludeBgradients", True )
+ kwargs.setdefault("MagFieldSvc", magfieldsvc )
+
+ propagator = Trk__STEP_Propagator(name=name, **kwargs)
+ result.setPrivateTools(propagator)
+ return result
+
+def MCTBExtrapolatorCfg(flags, name='MCTBExtrapolator',**kwargs):
+ result = ComponentAccumulator()
+
+ acc = MuonSTEP_PropagatorCfg(flags)
+ prop = acc.getPrimary()
+ result.addPublicTool(prop)
+ result.merge(acc)
+ kwargs.setdefault("Propagators", [ prop ])
+ kwargs.setdefault("ResolveMuonStation", False)
+ acc = MuonExtrapolatorCfg(flags, name=name, **kwargs)
+ result.setPrivateTools(acc.getPrimary())
+ result.merge(acc)
+
+ return result
+
+def MCTBFitterCfg(flags, name='MCTBFitter', **kwargs):
+ # didn't bother with MCTBSLFitter, since this seems redundant. Just set "StraightLine" = True since the kwargs are passed on to MuonChi2TrackFitterCfg
+ result = ComponentAccumulator()
+
+ acc = MCTBExtrapolatorCfg(flags)
+ mctbExtrapolator = acc.getPrimary()
+ result.merge(acc)
+
+ kwargs.setdefault("ExtrapolationTool", mctbExtrapolator)
+ kwargs.setdefault("GetMaterialFromTrack", True)
+ kwargs.setdefault("Momentum", flags.Muon.straightLineFitMomentum)
+ acc = MuonChi2TrackFitterCfg(flags, name=name, **kwargs)
+ mctbfitter = acc.getPrimary()
+ result.merge(acc)
+ # print mctbfitter
+ result.setPrivateTools(mctbfitter)
+ return result
\ No newline at end of file
diff --git a/MuonSpectrometer/MuonConfig/python/MuonReconstructionConfig.py b/MuonSpectrometer/MuonConfig/python/MuonReconstructionConfig.py
index 16478b8ba6ee7b7911c48235ab74ecf7d6d553a7..cb12b377e5fe51168460966e6feca3e21bec47aa 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonReconstructionConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonReconstructionConfig.py
@@ -5,6 +5,7 @@ from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
# Local
from MuonConfig.MuonSegmentFindingConfig import MuonSegmentFindingCfg
+from MuonConfig.MuonTrackBuildingConfig import MuonTrackBuildingCfg
def MuonReconstructionCfg(flags):
@@ -12,6 +13,7 @@ def MuonReconstructionCfg(flags):
# https://gitlab.cern.ch/atlas/athena/blob/master/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonStandalone.py
result=ComponentAccumulator()
result.merge( MuonSegmentFindingCfg(flags) )
+ result.merge( MuonTrackBuildingCfg(flags) )
return result
if __name__=="__main__":
diff --git a/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py b/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py
index f293155352d18680591e6888b55d9a92d32e6889..1bc90666a963f5665c2193c4defbef85e2421c25 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py
@@ -12,221 +12,21 @@
# When porting it I have tried to remove anything redundant, and I have tried to simplify the number of configuration techniques
# used, so for example I'm no longer using CfgGetter, and am minimising the use of CfgMgr,
-# There is now quite a lot in here not solely needed for SegmentFinding, so probably need to spit into another fragment.
# Core
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
-# Tracking
-from TrkMeasurementUpdator.TrkMeasurementUpdatorConf import Trk__KalmanUpdator
-from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator, Trk__EnergyLossUpdator, Trk__MultipleScatteringUpdator, Trk__Navigator
-from TrkDetDescrSvc.AtlasTrackingGeometrySvcConfig import TrackingGeometrySvcCfg
-from TrkExSTEP_Propagator.TrkExSTEP_PropagatorConf import Trk__STEP_Propagator
-from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__TrackSelectionProcessorTool
-from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool
-
# Muon
-from CscSegmentMakers.CscSegmentMakersConf import Csc2dSegmentMaker, Csc4dSegmentMaker
+# from CscSegmentMakers.CscSegmentMakersConf import Csc2dSegmentMaker, Csc4dSegmentMaker
from DCMathSegmentMaker.DCMathSegmentMakerConf import Muon__DCMathSegmentMaker, Muon__MdtMathSegmentFinder, Muon__MuonSegmentFittingTool, Muon__MuonClusterSegmentFinderTool
-from MuonTrackFinderTools.MuonTrackFinderToolsConf import Muon__MuonTrackCleaner, Muon__MuonTrackScoringTool
-from MuonCompetingClustersOnTrackCreator.MuonCompetingClustersOnTrackCreatorConf import Muon__TriggerChamberClusterOnTrackCreator
-from MuonStationIntersectSvc.MuonStationIntersectSvcConf import MuonStationIntersectSvc
from MuonSegmentSelectionTools.MuonSegmentSelectionToolsConf import Muon__MuonSegmentSelectionTool
-from MdtSegmentT0Fitter.MdtSegmentT0FitterConf import TrkDriftCircleMath__MdtSegmentT0Fitter
from MuonClusterSegmentMakerTools.MuonClusterSegmentMakerToolsConf import Muon__MuonClusterSegmentFinder
-from MuonAmbiTrackSelectionTool.MuonAmbiTrackSelectionToolConf import Muon__MuonAmbiTrackSelectionTool
from MuonCnvExample.MuonCnvUtils import mdtCalibWindowNumber # TODO - should maybe move this somewhere else?
#Local
import MuonConfig.MuonRIO_OnTrackCreatorConfig # Trying to avoid circular dependencies here
-from MuonConfig.MuonCondSvcConfig import MDTCondSummarySvcCfg
+# from MuonConfig.MuonCondSvcConfig import MDTCondSummarySvcCfg
from MuonConfig.MuonCalibConfig import MdtCalibrationDbSvcCfg
-
-def MuonTrackSummaryHelperToolCfg(flags, **kwargs):
- # m_muonTgTool("MuonHolesOnTrack"),
- # m_idHelperTool("Muon::MuonIdHelperTool/MuonIdHelperTool"),
- # m_edmHelperTool("Muon::MuonEDMHelperSvc/MuonEDMHelperSvc"),
- # m_extrapolator("Trk::Extrapolator/AtlasExtrapolator"),
- # m_slExtrapolator("Trk::Extrapolator/MuonStraightLineExtrapolator"),
-
- result = ComponentAccumulator()
- acc = TrackingGeometrySvcCfg(flags)
-
- result.merge(acc)
- kwargs.setdefault("TrackingGeometryName", 'AtlasTrackingGeometry') # FIXME - get this from somewhere?
-
- acc = MuonExtrapolatorCfg(flags)
- extrap = acc.getPrimary()
- acc.addPublicTool(extrap)
- result.merge(acc)
- kwargs.setdefault("Extrapolator", extrap)
-
- from MuonTGRecTools.MuonTGRecToolsConf import Muon__MuonHolesOnTrackTool
- holetool = Muon__MuonHolesOnTrackTool (ExtrapolatorName = extrap,
- TrackingGeometryName = 'MuonStandaloneTrackingGeometry')
-
- kwargs.setdefault("DoHolesOnTrack", False)
- kwargs.setdefault("CalculateCloseHits", True)
- kwargs.setdefault("HoleOnTrackTool", holetool)
-
- from MuonTrackSummaryHelperTool.MuonTrackSummaryHelperToolConf import Muon__MuonTrackSummaryHelperTool
- result.setPrivateTools(Muon__MuonTrackSummaryHelperTool(**kwargs))
- return result
-
-def MuonTrackSummaryToolCfg(flags, **kwargs):
- result = ComponentAccumulator()
- acc = MuonTrackSummaryHelperToolCfg(flags)
- track_summary_helper = acc.getPrimary()
- acc.addPublicTool(track_summary_helper)
- result.merge(acc)
- kwargs.setdefault("MuonSummaryHelperTool", track_summary_helper )
- kwargs.setdefault("doSharedHits", False )
- kwargs.setdefault("AddDetailedMuonSummary", True )
- result.setPrivateTools(Trk__TrackSummaryTool(**kwargs))
- return result
-
-def MuonTrackScoringToolCfg(flags, **kwargs):
- # m_trkSummaryTool("Trk::TrackSummaryTool"),
- # m_printer("Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"),
- result = ComponentAccumulator()
- acc = MuonTrackSummaryToolCfg(flags)
- track_summary = acc.getPrimary( )
- acc.addPublicTool(track_summary)
- result.merge(acc)
- kwargs.setdefault('SumHelpTool', track_summary)
- result.setPrivateTools(Muon__MuonTrackScoringTool(**kwargs))
- return result
-
-def MuonAmbiProcessorCfg(flags, **kwargs):
- #m_scoringTool("Trk::TrackScoringTool/TrackScoringTool"),
- #m_selectionTool("InDet::InDetAmbiTrackSelectionTool/InDetAmbiTrackSelectionTool")
- result = ComponentAccumulator()
- kwargs.setdefault('DropDouble', False)
- acc = MuonTrackScoringToolCfg( flags )
- scoring_tool = acc.getPrimary()
- acc.addPublicTool(scoring_tool)
- result.merge(acc)
- kwargs.setdefault('ScoringTool', scoring_tool )
- muon_ami_selection_tool = Muon__MuonAmbiTrackSelectionTool()
- result.addPublicTool(muon_ami_selection_tool)
- kwargs.setdefault('SelectionTool', muon_ami_selection_tool)
- result.setPrivateTools(Trk__TrackSelectionProcessorTool(**kwargs))
- return result
-
-# This probably doesn't belong here.
-def MuonStationIntersectSvcCfg(flags, **kwargs):
- # Has dependency on MDTCondSummarySvc and IdHelperTool (which we ignore for now)
- result = ComponentAccumulator()
- acc = MDTCondSummarySvcCfg(flags)
- mdt_cond_summary_svc = acc.getPrimary()
- result.merge(acc)
- kwargs.setdefault("MDTCondSummarySvc", mdt_cond_summary_svc)
- muon_station_intersect_svc = MuonStationIntersectSvc(**kwargs)
- result.addService(muon_station_intersect_svc, primary=True)
- return result
-
-# default muon navigator
-def MuonNavigatorCfg(flags, **kwargs):
- result = ComponentAccumulator()
-
- acc = TrackingGeometrySvcCfg(flags)
- result.merge(acc)
- kwargs.setdefault("TrackingGeometrySvc", acc.getPrimary() )
-
- navigator = Trk__Navigator(**kwargs)
- result.setPrivateTools(navigator)
- return result
-
-def MuonExtrapolatorCfg(flags,**kwargs):
- from TrkExTools.TrkExToolsConf import Trk__Extrapolator
- result = ComponentAccumulator()
-
- energy_loss_updator = Trk__EnergyLossUpdator() # Not really sure these should be tools...
- result.addPublicTool(energy_loss_updator) # TODO remove
-
- # This one has a dependency on RndNumberService
- mult_scat_updator = Trk__MultipleScatteringUpdator()
- result.addPublicTool(mult_scat_updator) # TODO remove
-
- material_effects_updator = Trk__MaterialEffectsUpdator( EnergyLossUpdator=energy_loss_updator, MultipleScatteringUpdator=mult_scat_updator)
- result.addPublicTool(material_effects_updator)
- kwargs.setdefault("MaterialEffectsUpdators", [material_effects_updator])
-
- navigator_ca = MuonNavigatorCfg(flags)
- navigator = navigator_ca.popPrivateTools()
- result.addPublicTool(navigator)
- result.merge(navigator_ca)
- kwargs.setdefault("Navigator", navigator)
-
- muon_prop = Trk__STEP_Propagator(Tolerance = 0.00001, MaterialEffects=True, IncludeBgradients=True)
- result.addPublicTool(muon_prop)
-
- kwargs.setdefault("Propagators", [muon_prop])
- kwargs.setdefault("ResolveMuonStation", True)
- kwargs.setdefault("Tolerance", 0.0011) # must be > 1um to avoid missing MTG intersections
- extrap = Trk__Extrapolator(**kwargs)
- result.setPrivateTools(extrap)
- return result
-
-def MuonChi2TrackFitterCfg(flags,**kwargs):
- result = ComponentAccumulator()
- from TrkGlobalChi2Fitter.TrkGlobalChi2FitterConf import Trk__GlobalChi2Fitter
-
- extrapolator_CA = MuonExtrapolatorCfg(flags)
- extrapolator= extrapolator_CA.getPrimary()
-
- result.addPublicTool(extrapolator) # TODO remove
- result.merge(extrapolator_CA)
-
- acc = MuonConfig.MuonRIO_OnTrackCreatorConfig.MuonRotCreatorCfg(flags)
- rotcreator=acc.getPrimary()
- result.merge(acc)
-
- measurement_updater = Trk__KalmanUpdator()
- result.addPublicTool(measurement_updater) #FIXME
-
- kwargs.setdefault("ExtrapolationTool" , extrapolator)
- kwargs.setdefault("RotCreatorTool" , rotcreator)
- kwargs.setdefault("MeasurementUpdateTool", measurement_updater)
- kwargs.setdefault("StraightLine" , False)
- kwargs.setdefault("OutlierCut" , 3.0)
- kwargs.setdefault("GetMaterialFromTrack" , False)
- kwargs.setdefault("RejectLargeNScat" , True)
-
- # take propagator and navigator from the extrapolator
- extrapolator_CA = MuonExtrapolatorCfg(flags)
- result.addPublicTool(extrapolator_CA.getPrimary()) # TODO remove
- result.merge(extrapolator_CA)
-
- kwargs["ExtrapolationTool"] = extrapolator
- kwargs["PropagatorTool"] = extrapolator.Propagators[0]
- kwargs["NavigatorTool"] = extrapolator.Navigator
-
- fitter = Trk__GlobalChi2Fitter(**kwargs)
- result.setPrivateTools(fitter)
- # print fitter
- return result
-
-
-def MCTBExtrapolatorCfg(flags, name='MCTBExtrapolator',**kwargs):
- result = ComponentAccumulator()
- kwargs.setdefault("Propagators", ["MCTBPropagator"]) # FIXME!
- kwargs.setdefault("ResolveMuonStation", False)
- extrap = MuonExtrapolatorCfg(flags, **kwargs)
- result.setPrivateTools(extrap)
- return result
-
-def MCTBFitterCfg(flags, **kwargs):
- # didn't bother with MCTBSLFitter, since this seems redundant. Just set "StraightLine" = True
- result = ComponentAccumulator()
- kwargs.setdefault("ExtrapolationTool", "MCTBExtrapolator")
- kwargs.setdefault("GetMaterialFromTrack", True)
- kwargs.setdefault("Momentum", flags.Muon.straightLineFitMomentum)
- acc = MuonChi2TrackFitterCfg(flags, **kwargs)
- mctbfitter = acc.getPrimary()
- result.merge(acc)
- # print mctbfitter
- result.setPrivateTools(mctbfitter)
- return result
+from MuonConfig.MuonRecToolsConfig import MCTBFitterCfg, MuonAmbiProcessorCfg, MuonStationIntersectSvcCfg, MuonTrackCleanerCfg
def MuonHoughPatternFinderTool(flags, **kwargs):
# Taken from https://gitlab.cern.ch/atlas/athena/blob/master/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecTools.py#L173 from MuonHoughPatternTools/MuonHoughPatternToolsConf import Muon__MuonHoughPatternFinderTool
@@ -276,7 +76,7 @@ def AdjustableT0Tool(flags,**kwargs):
from MdtDriftCircleOnTrackCreator.MdtDriftCircleOnTrackCreatorConf import AdjT0__AdjustableT0Tool
return AdjT0__AdjustableT0Tool(**kwargs)
-def MdtMathSegmentFinder(flags,**kwargs):
+def MdtMathSegmentFinder(flags,name="MdtMathSegmentFinder", **kwargs):
# beamType = getattr(extraFlags,"beamType", beamFlags.beamType())
# doSegmentT0Fit = getattr(extraFlags,"doSegmentT0Fit",muonRecFlags.doSegmentT0Fit())
# enableCurvedSegmentFinding = getattr(extraFlags,"enableCurvedSegmentFinding", muonStandaloneFlags.enableCurvedSegmentFinding())
@@ -295,67 +95,7 @@ def MdtMathSegmentFinder(flags,**kwargs):
if flags.Muon.enableCurvedSegmentFinding:
kwargs.setdefault("DoCurvedSegmentFinder",True)
- return Muon__MdtMathSegmentFinder(**kwargs)
-
-def TriggerChamberClusterOnTrackCreatorCfg(flags, **kwargs):
- result=ComponentAccumulator()
- acc = MuonConfig.MuonRIO_OnTrackCreatorConfig.MuonClusterOnTrackCreatorCfg(flags)
- muon_cluster_creator=acc.getPrimary()
- result.merge(acc)
- kwargs.setdefault("ClusterCreator", muon_cluster_creator)
- result.setPrivateTools(Muon__TriggerChamberClusterOnTrackCreator(**kwargs))
- return result
-
-def MuonTrackCleanerCfg(flags, **kwargs):
- # declareProperty("IdHelper",m_idHelper);
- # declareProperty("Helper",m_edmHelperSvc);
- # declareProperty("Printer",m_printer);
- # declareProperty("MdtRotCreator", m_mdtRotCreator );
- # declareProperty("CompRotCreator", m_compRotCreator );
- # declareProperty("PullCalculator", m_pullCalculator );
- # declareProperty("Extrapolator", m_extrapolator );
- # declareProperty("MagFieldSvc", m_magFieldSvc );
- # declareProperty("MeasurementUpdator", m_measurementUpdator );
- result=ComponentAccumulator()
-
- acc = MuonConfig.MuonRIO_OnTrackCreatorConfig.MdtDriftCircleOnTrackCreatorCfg(flags)
- mdt_creator=acc.getPrimary()
- result.merge(acc)
- kwargs.setdefault("MdtRotCreator", mdt_creator)
-
- acc = TriggerChamberClusterOnTrackCreatorCfg(flags)
- muon_cluster_creator=acc.getPrimary()
- result.merge(acc)
- kwargs.setdefault("CompRotCreator", muon_cluster_creator)
-
- # For PullCalculator, just let it get default for moment. FIXME
-
- extrapolator_CA = MuonExtrapolatorCfg(flags)
- extrapolator = extrapolator_CA.getPrimary()
- acc.addPublicTool( extrapolator ) # TODO remove
- result.merge( extrapolator_CA )
- kwargs.setdefault("Extrapolator", extrapolator)
-
- acc = MCTBFitterCfg(flags, name = "SLFitter", StraightLine=True)
- slfitter = acc.getPrimary()
- acc.addPublicTool(slfitter)
- result.merge(acc)
- kwargs.setdefault("SLFitter", slfitter)
-
- acc = MCTBFitterCfg(flags, name = "CurvedFitter")
- fitter = acc.getPrimary()
-
- acc.addPublicTool(fitter)
- result.merge(acc)
- kwargs.setdefault("Fitter", fitter)
-
- # kwargs.setdefault("MagFieldSvc", mag_field_svc) Default for moment
-
- # FIXME - do remaining tools
-
- result.setPrivateTools(Muon__MuonTrackCleaner(**kwargs))
-
- return result
+ return Muon__MdtMathSegmentFinder(name=name,**kwargs)
def MuonSegmentFittingToolCfg(flags, **kwargs):
# declareProperty("SLPropagator", m_slPropagator);
@@ -393,6 +133,7 @@ def MuonSegmentFittingToolCfg(flags, **kwargs):
return result
def DCMathSegmentMakerCfg(flags, **kwargs):
+ from MdtSegmentT0Fitter.MdtSegmentT0FitterConf import TrkDriftCircleMath__MdtSegmentT0Fitter
# This in general is a pretty problematic piece of code. It seems to have a lot of potential issues, because it has loads of mutables / subtools etc
# https://gitlab.cern.ch/atlas/athena/blob/master/MuonSpectrometer/MuonReconstruction/MuonSegmentMakers/MuonSegmentMakerTools/DCMathSegmentMaker/src/DCMathSegmentMaker.h
# ToolHandle<IMdtDriftCircleOnTrackCreator> m_mdtCreator; //<! mdt rio ontrack creator
@@ -420,6 +161,7 @@ def DCMathSegmentMakerCfg(flags, **kwargs):
acc = MdtCalibrationDbSvcCfg(flags) # Needed by MdtSegmentT0Fitter
result.merge(acc)
+
mdt_segment_t0_fitter = TrkDriftCircleMath__MdtSegmentT0Fitter()
result.addPublicTool(mdt_segment_t0_fitter)
kwargs.setdefault("DCFitProvider", mdt_segment_t0_fitter)
@@ -471,13 +213,18 @@ def DCMathSegmentMakerCfg(flags, **kwargs):
acc=MuonConfig.MuonRIO_OnTrackCreatorConfig.MuonClusterOnTrackCreatorCfg(flags)
muon_cluster_creator=acc.getPrimary()
+ result.addPublicTool(muon_cluster_creator)
# FIXME - declare property for muon_cluster_creator is missing from the tool.
+ result.merge(acc)
+
+ acc = MuonConfig.MuonRIO_OnTrackCreatorConfig.TriggerChamberClusterOnTrackCreatorCfg(flags)
+ muon_comp_cluster_creator = acc.getPrimary()
+ result.addPublicTool(muon_comp_cluster_creator)
+ result.merge(acc)
- muon_comp_cluster_creator = Muon__TriggerChamberClusterOnTrackCreator(ClusterCreator=muon_cluster_creator)
- acc.addPublicTool(muon_comp_cluster_creator)
kwargs.setdefault("MuonCompetingClustersCreator", muon_comp_cluster_creator)
- acc = MuonSegmentFittingToolCfg(flags, name="NewMuonSegmentFittingTool")
+ acc = MuonSegmentFittingToolCfg(flags, name="MuonSegmentFittingTool")
segment_fitter=acc.getPrimary()
result.addPublicTool(segment_fitter)
@@ -661,6 +408,7 @@ def CscSegmentUtilToolCfg(flags, **kwargs):
return result
def Csc2dSegmentMakerCfg(flags, **kwargs):
+ from CscSegmentMakers.CscSegmentMakersConf import Csc2dSegmentMaker
result=ComponentAccumulator()
acc = CscSegmentUtilToolCfg(flags)
csc_segment_util_tool = acc.getPrimary()
@@ -673,6 +421,8 @@ def Csc2dSegmentMakerCfg(flags, **kwargs):
return result
def Csc4dSegmentMakerCfg(flags, **kwargs):
+ from CscSegmentMakers.CscSegmentMakersConf import Csc4dSegmentMaker
+
result=ComponentAccumulator()
acc= CscSegmentUtilToolCfg(flags)
csc_segment_util_tool = acc.getPrimary()
@@ -818,7 +568,7 @@ def MuonClusterSegmentFinderCfg(flags, **kwargs):
result.addPublicTool(Muon__MuonClusterSegmentFinder(**kwargs),primary=True)
return result
-def MuonSegmentFindingCfg(flags, **kwargs):
+def MuonSegmentFindingCfg(flags, name = "MuonSegmentMaker", **kwargs):
# This is based on https://gitlab.cern.ch/atlas/athena/blob/master/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonStandalone.py#L113
from MooSegmentCombinationFinder.MooSegmentCombinationFinderConf import MooSegmentFinderAlg
result=ComponentAccumulator()
@@ -841,7 +591,7 @@ def MuonSegmentFindingCfg(flags, **kwargs):
if not flags.Muon.useTGCPriorNextBC and not flags.Muon.useTGCPriorNextBC:
tgc_meas_key = 'TGC_MeasurementsAllBCs'
- moo_segment_finder_alg = MooSegmentFinderAlg( "MuonSegmentMaker",
+ moo_segment_finder_alg = MooSegmentFinderAlg( name,
SegmentFinder = segment_finder_tool,
MuonClusterSegmentFinderTool=muon_cluster_segment_finder,
MuonSegmentOutputLocation = segment_location,
diff --git a/MuonSpectrometer/MuonConfig/python/MuonTrackBuildingConfig.py b/MuonSpectrometer/MuonConfig/python/MuonTrackBuildingConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4007ad3674eafa8cd04c01c98848aba8038f293
--- /dev/null
+++ b/MuonSpectrometer/MuonConfig/python/MuonTrackBuildingConfig.py
@@ -0,0 +1,355 @@
+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from MuonRecToolsConfig import MCTBFitterCfg, MuonSTEP_PropagatorCfg, MuonTrackCleanerCfg, MuonSegmentMomentumFromFieldCfg, MuonSeededSegmentFinderCfg
+from MuonConfig.MuonSegmentFindingConfig import MuonSegmentFittingToolCfg
+
+def MooTrackFitterCfg(flags, name = 'MooTrackFitter', **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)
+ from MuonTrackSteeringTools.MuonTrackSteeringToolsConf import Muon__MooTrackFitter
+ from MuonSegmentMomentum.MuonSegmentMomentumConf import MuonSegmentMomentum
+
+ result = MCTBFitterCfg(flags)
+ mctb_fitter = result.getPrimary()
+ result.addPublicTool(mctb_fitter)
+ kwargs.setdefault("Fitter", mctb_fitter)
+
+ acc = MuonSTEP_PropagatorCfg(flags)
+ muon_prop = acc.getPrimary()
+ result.addPublicTool(muon_prop)
+ result.merge(acc)
+
+ kwargs.setdefault("Propagator", muon_prop)
+ # kwargs.setdefault("SLFit" , ) # Was "not jobproperties.BField.allToroidOn()" but do not have access to Field here.
+ kwargs.setdefault("ReducedChi2Cut", flags.Muon.Chi2NDofCut)
+
+ momentum_estimator=""
+ if flags.Beam.Type == 'cosmics':
+ momentum_estimator = MuonSegmentMomentum(DoCosmics = True)
+ else:
+ acc = MuonSegmentMomentumFromFieldCfg(flags)
+ momentum_estimator=acc.getPrimary()
+ result.merge(acc)
+
+ result.addPublicTool(momentum_estimator)
+ kwargs.setdefault("SegmentMomentum", momentum_estimator )
+
+ kwargs.setdefault("CleanPhiHits", True)
+ kwargs.setdefault("UsePreciseHits", True)
+ kwargs.setdefault("UsePrefit", False)
+ kwargs.setdefault("SeedAtStartOfTrack", False)
+
+ acc = MuonTrackCleanerCfg(flags)
+ track_cleaner = acc.getPrimary()
+ result.merge(acc)
+ result.addPublicTool(track_cleaner)
+ kwargs.setdefault("TrackCleaner", track_cleaner)
+
+ fitter = Muon__MooTrackFitter(name, **kwargs)
+ result.setPrivateTools(fitter)
+ return result
+
+def MooTrackBuilderCfg(flags, name="MooTrackBuilderTemplate", **kwargs):
+ from MuonTrackSteeringTools.MuonTrackSteeringToolsConf import Muon__MooTrackBuilder
+ from TrkExSTEP_Propagator.TrkExSTEP_PropagatorConf import Trk__STEP_Propagator
+
+ # 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=MooTrackFitterCfg(flags)
+ moo_track_fitter = result.getPrimary()
+ result.addPublicTool(moo_track_fitter)
+ 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)
+ acc = MCTBFitterCfg(flags, name='MCTBSLFitter', StraightLine=True)
+ mctbslfitter = acc.getPrimary()
+ result.addPublicTool(mctbslfitter)
+
+ result.merge(acc)
+
+ # 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
+ # FIXME - this should be updated once there is a proper CA implementation for the STEP_Propagator
+ prop = Trk__STEP_Propagator(name = 'MuonStraightLinePropagator')
+ result.addPublicTool(prop)
+
+ # TODO - check why Fitter and FitterPreFit are identical
+ acc = MooTrackFitterCfg( flags, name="MooSLTrackFitter", Fitter = mctbslfitter, FitterPreFit=mctbslfitter, Propagator=prop, ReducedChi2Cut=10.0, SLFit=True)
+ moo_sl_track_fitter = acc.getPrimary()
+ result.addPublicTool(moo_sl_track_fitter)
+ result.merge(acc)
+
+ kwargs.setdefault("SLFitter", moo_sl_track_fitter)
+ kwargs.setdefault("RecalibrateMDTHitsOnTrack", ( (not flags.Muon.doSegmentT0Fit) and flags.Beam.Type == 'collisions') )
+
+
+ acc = MuonSeededSegmentFinderCfg(flags)
+ muon_seeded_segment_finder = acc.getPrimary()
+ result.addPublicTool(muon_seeded_segment_finder)
+ result.merge(acc)
+ kwargs.setdefault("SeededSegmentFinder", muon_seeded_segment_finder)
+
+ builder = Muon__MooTrackBuilder(name, **kwargs)
+ result.setPrivateTools(builder)
+ 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):
+ from MuonSegmentMatchingTools.MuonSegmentMatchingToolsConf import Muon__MuonSegmentMatchingTool
+ from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg
+
+ kwargs.setdefault( "doThetaMatching", flags.Muon.useSegmentMatching)
+ kwargs.setdefault( "doPhiMatching", False )
+ if flags.Beam.Type == 'cosmics':
+ kwargs.setdefault("OverlapMatchAveragePhiHitPullCut", 200.)
+
+ # 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_overlapResolvingTool("Muon::MuonSegmentInOverlapResolvingTool/MuonSegmentInOverlapResolvingTool"),
+ # m_pairMatchingTool("Muon::MuonSegmentPairMatchingTool/MuonSegmentPairMatchingTool"),
+ # Also, residual pull calculator not yet configured. #FIXME
+
+ result = MagneticFieldSvcCfg(flags)
+ magfieldsvc = result.getPrimary()
+
+ kwargs.setdefault( "MagFieldSvc", magfieldsvc )
+
+ matching = Muon__MuonSegmentMatchingTool(name, **kwargs)
+ result.setPrivateTools(matching)
+ return result
+
+def MooCandidateMatchingToolCfg(flags, name="MooCandidateMatchingTool", doSegmentPhiMatching=True, **kwargs):
+ from MuonTrackSteeringTools.MuonTrackSteeringToolsConf import Muon__MooCandidateMatchingTool
+ result = ComponentAccumulator()
+ if doSegmentPhiMatching is not None:
+ acc = MuonSegmentMatchingToolCfg(flags, doPhiMatching = doSegmentPhiMatching)
+ muon_seg_matching = acc.getPrimary()
+ result.addPublicTool(muon_seg_matching)
+ result.merge(acc)
+ kwargs.setdefault("SegmentMatchingTool", muon_seg_matching)
+
+ acc = MuonSegmentMatchingToolCfg(flags, name = "MuonSegmentMatchingToolTight", TightSegmentMatching=True, doPhiMatching = doSegmentPhiMatching)
+ muon_seg_matching_tight = acc.getPrimary()
+ result.addPublicTool(muon_seg_matching_tight)
+ result.merge(acc)
+ kwargs.setdefault("SegmentMatchingToolTight", muon_seg_matching_tight)
+
+ kwargs.setdefault("DoTrackSegmentMatching", flags.Muon.useTrackSegmentMatching)
+ kwargs.setdefault("RequireSameSide", flags.Beam.Type != '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)
+
+ moo_cand_matching_tool = Muon__MooCandidateMatchingTool(name,**kwargs)
+ result.setPrivateTools(moo_cand_matching_tool)
+ return result
+
+def MuonSegmentRegionRecoveryToolCfg(flags, name="MuonSegmentRegionRecoveryTool", **kwargs):
+ from MuonTrackFinderTools.MuonTrackFinderToolsConf import Muon__MuonSegmentRegionRecoveryTool
+ # Based on https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MooreTools.py#L426
+ result = MCTBFitterCfg(flags)
+ mctbfitter = result.getPrimary()
+ result.addPublicTool(mctbfitter)
+ kwargs.setdefault("Fitter", mctbfitter)
+
+ acc = MooCandidateMatchingToolCfg(flags)
+ track_segment_matching_tool=acc.getPrimary()
+ result.addPublicTool(track_segment_matching_tool)
+ result.merge(acc)
+ kwargs.setdefault("TrackSegmentMatchingTool", track_segment_matching_tool)
+
+ segment_region_recovery_tool = Muon__MuonSegmentRegionRecoveryTool(name, **kwargs)
+ result.setPrivateTools(segment_region_recovery_tool)
+ return result
+
+def MuPatCandidateToolCfg(flags, name="MuPatCandidateTool", **kwargs):
+ from MuonTrackSteeringTools.MuonTrackSteeringToolsConf import Muon__MuPatCandidateTool
+ # https://gitlab.cern.ch/atlas/athena/blob/release/22.0.3/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuPatTools.py#L32
+
+ from MuonConfig.MuonRIO_OnTrackCreatorConfig import CscClusterOnTrackCreatorCfg,MdtDriftCircleOnTrackCreatorCfg
+ result = MdtDriftCircleOnTrackCreatorCfg(flags)
+ mdt_dcot_creator = result.getPrimary()
+ kwargs.setdefault("MdtRotCreator", mdt_dcot_creator)
+
+ acc = CscClusterOnTrackCreatorCfg(flags)
+ csc_cluster_creator = acc.getPrimary()
+ result.merge(acc)
+ kwargs.setdefault("CscRotCreator", csc_cluster_creator)
+
+ kwargs.setdefault("SegmentExtender", "") #FIXME If this is always empty, can it be removed?
+
+ mu_pat_cand_tool = Muon__MuPatCandidateTool(name, **kwargs)
+ result.setPrivateTools(mu_pat_cand_tool)
+ return result
+
+def MuonTrackSteeringCfg(flags, name="MuonTrackSteering", **kwargs):
+ from MuonTrackSteeringTools.MuonTrackSteeringToolsConf import 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 = MCTBFitterCfg(flags, name='MCTBSLFitter', StraightLine=True)
+ mctbslfitter = result.getPrimary()
+ result.addPublicTool(mctbslfitter)
+
+ acc = MuonSegmentRegionRecoveryToolCfg(flags, name='MuonEORecoveryTool', OnlyEO = True, Fitter=mctbslfitter, UseFitterOutlierLogic=False)
+ muon_eo_recovery_tool = acc.getPrimary()
+ result.addPublicTool(muon_eo_recovery_tool)
+ result.merge(acc)
+
+ kwargs.setdefault("HoleRecoveryTool", muon_eo_recovery_tool)
+ kwargs.setdefault("SegSeedQCut", 2)
+ kwargs.setdefault("Seg2ndQCut", 1)
+
+ kwargs.setdefault("OutputSingleStationTracks", True) # default is False
+
+ 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")
+ # 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
+ acc = MooTrackBuilderCfg(flags)
+ builder = acc.getPrimary()
+ kwargs["TrackBuilderTool"] = builder
+ result.merge(acc)
+
+ if "TrackRefinementTool" not in kwargs:
+ kwargs["TrackRefinementTool"] = builder
+ # FIXME. Need to see if TrackRefinementTool is actually used & possibly remove.
+
+ # --- Now let's setup tools which were ignored in the old configuration. Just want to get this working for the moment. Will clean it up later.
+
+ acc=MuPatCandidateToolCfg(flags)
+ cand_tool = acc.getPrimary()
+ result.merge(acc)
+ result.addPublicTool(cand_tool)
+ kwargs.setdefault("MuPatCandidateTool", cand_tool)
+
+ from MuonConfig.MuonRecToolsConfig import MuonAmbiProcessorCfg
+ acc = MuonAmbiProcessorCfg(flags, name='MuonAmbiProcessor')
+ ambi = acc.getPrimary()
+ result.merge(acc)
+ result.addPublicTool(ambi)
+ kwargs.setdefault("AmbiguityTool", ambi)
+
+ kwargs.setdefault("MooBuilderTool", builder)
+ kwargs.setdefault("TrackRefinementTool", builder)
+
+ acc = MooCandidateMatchingToolCfg(flags)
+ cand_matching_tool = acc.getPrimary()
+ kwargs["CandidateMatchingTool"] = cand_matching_tool
+ result.merge(acc)
+
+ acc = MuonSegmentFittingToolCfg(flags)
+ seg_fitting_tool = acc.getPrimary()
+ result.merge(acc)
+
+ kwargs.setdefault("MuonSegmentFittingTool", seg_fitting_tool)
+ kwargs.setdefault("MuonTrackSelector", MuonTrackSelector(flags))
+
+ track_maker_steering = Muon__MuonTrackSteering(name,**kwargs)
+ result.setPrivateTools(track_maker_steering)
+ return result
+
+def MuonTrackSelector(flags, name = "MuonTrackSelectorTool", **kwargs):
+ from MuonTrackFinderTools.MuonTrackFinderToolsConf import Muon__MuonTrackSelectorTool
+ # In MooreTools this is:
+ # if beamFlags.beamType() == 'cosmics' or beamFlags.beamType() == 'singlebeam' or globalflags.DataSource() == 'data' :
+ # Hopefully this is good enough
+ if flags.Beam.Type == 'cosmics' 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)
+
+ return Muon__MuonTrackSelectorTool(name, **kwargs)
+
+def MuonTrackBuildingCfg(flags):
+ from MuonSegmentTrackMaker.MuonSegmentTrackMakerConf import MuPatTrackBuilder
+ # 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) )
+
+ acc = MuonTrackSteeringCfg(flags)
+ track_steering = acc.getPrimary()
+ result.merge(acc)
+ result.addPublicTool(track_steering)
+
+ track_builder = MuPatTrackBuilder("MuPatTrackBuilder", TrackSteering = track_steering )
+ result.addEventAlgo( track_builder )
+ return result
+
+
+if __name__=="__main__":
+ # To run this, do e.g.
+ # python ../athena/MuonSpectrometer/MuonConfig/python/MuonTrackBuildingConfig.py
+ from AthenaCommon.Configurable import Configurable
+ Configurable.configurableRun3Behavior=1
+
+ from AthenaCommon.Logging import log
+ from AthenaConfiguration.AllConfigFlags import ConfigFlags
+
+ ConfigFlags.Concurrency.NumThreads = 1
+
+ ConfigFlags.Detector.GeometryMDT = True
+ ConfigFlags.Detector.GeometryTGC = True
+ ConfigFlags.Detector.GeometryCSC = True
+ ConfigFlags.Detector.GeometryRPC = True
+
+ from AthenaConfiguration.TestDefaults import defaultTestFiles
+ ConfigFlags.Input.Files = defaultTestFiles.ESD
+ # from AthenaCommon.Constants import DEBUG
+ #log.setLevel(DEBUG)
+ log.debug('About to set up Muon Track Building.')
+
+ ConfigFlags.Input.isMC = True
+ # ConfigFlags.Muon.doCSCs = False
+ ConfigFlags.lock()
+
+ cfg=ComponentAccumulator()
+
+ # This is a temporary fix! Should be private!
+ from MuonRecHelperTools.MuonRecHelperToolsConf import Muon__MuonEDMHelperSvc
+ muon_edm_helper_svc = Muon__MuonEDMHelperSvc("MuonEDMHelperSvc")
+ cfg.addService( muon_edm_helper_svc )
+
+ from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
+ cfg.merge(PoolReadCfg(ConfigFlags))
+
+ cfg.merge(MuonTrackBuildingCfg(ConfigFlags))
+
+ f=open("MuonTrackBuilding.pkl","w")
+ cfg.store(f)
+ f.close()