From 5b7f59aeaf9e312fc8879d64a83b0481bc72d1eb Mon Sep 17 00:00:00 2001
From: Edward Moyse <edward.moyse@cern.ch>
Date: Wed, 4 Nov 2020 14:51:32 +0000
Subject: [PATCH] Attempt to clean up MuonCalibConfig I don't think that the
approach of modifying the class, rather than an instance, is a good idea. I
also worry that private tools are not being configured at all (specifically,
the MdtCalibrationTool and MdtCalibrationDbTool). Attempting to fix this.
This causes q431 changes, but this is probably expected.
---
.../MdtCalibSvc/MdtCalibrationDbTool.h | 3 +-
.../MdtCalibSvc/src/MdtCalibrationDbTool.cxx | 4 +
.../MuonCnvExample/python/MuonCalibConfig.py | 287 ++++++++++++++++--
.../python/MuonCalibrationConfig.py | 11 +-
.../python/MuonRIO_OnTrackCreatorConfig.py | 15 +-
.../MuonConfig/python/MuonRdoDecodeConfig.py | 8 +-
.../MuonConfig/python/MuonRecToolsConfig.py | 8 +-
.../python/MuonSegmentFindingConfig.py | 138 ++++-----
.../python/MuonTrackBuildingConfig.py | 20 +-
.../python/MdtDigitizationConfig.py | 6 +-
.../CMakeLists.txt | 1 -
.../MdtDriftCircleOnTrackCreator.h | 5 +-
.../share/MdtDriftCircleOnTrackCreator.py | 5 -
.../src/MdtDriftCircleOnTrackCreator.cxx | 4 +
.../python/MuonPrdProviderToolsConfig.py | 1 +
.../MuonRecExample/python/MuonRecTools.py | 5 +-
.../python/MuonCombinedRecToolsConfig.py | 92 ++++--
.../python/MuGirlTagTool.py | 3 +
.../TrigL2MuonSA/python/TrigL2MuonSAConfig.py | 12 +-
.../python/TrigL2MuonSAConfig_newJO.py | 4 +-
.../TrigMuonEF/python/TrigMuonEFConfig.py | 4 +-
.../python/HLTMenuConfig/Muon/MuonSetup.py | 5 +-
22 files changed, 453 insertions(+), 188 deletions(-)
delete mode 100644 MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/share/MdtDriftCircleOnTrackCreator.py
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationDbTool.h b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationDbTool.h
index b388cb86552c..f0fec1632a79 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationDbTool.h
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/MdtCalibSvc/MdtCalibrationDbTool.h
@@ -99,7 +99,8 @@ private:
SG::ReadCondHandleKey<MdtRtRelationCollection> m_readKeyRt{this,"MdtRtRelationCollection","MdtRtRelationCollection","MDT RT relations"};
SG::ReadCondHandleKey<MdtTubeCalibContainerCollection> m_readKeyTube{this,"MdtTubeCalibContainerCollection","MdtTubeCalibContainerCollection","MDT tube calib"};
SG::ReadCondHandleKey<MdtCorFuncSetCollection> m_readKeyCor{this,"MdtCorFuncSetCollection","MdtCorFuncSetCollection","MDT cor Funcs"};
-
+
+ Gaudi::Property<bool> m_wasConfigured {this,"WasConfigured",false,"This tool is too complicated to rely on defaults. Will fail if not configured."};
};
#endif // MDTCALIBSVC_MDTCALIBRATIONDBTOOL_H
diff --git a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationDbTool.cxx b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationDbTool.cxx
index c438cb0cdbaa..f16d455e4b36 100644
--- a/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationDbTool.cxx
+++ b/MuonSpectrometer/MuonCalib/MdtCalib/MdtCalibSvc/src/MdtCalibrationDbTool.cxx
@@ -55,6 +55,10 @@ StatusCode MdtCalibrationDbTool::initialize() {
ATH_CHECK(m_readKeyRt.initialize());
ATH_CHECK(m_readKeyTube.initialize());
ATH_CHECK(m_readKeyCor.initialize (m_createSlewingFunction || m_createWireSagFunction || m_create_b_field_function));
+
+ if (!m_wasConfigured){
+ ATH_MSG_WARNING( "This tool is too complicated to rely on defaults. Potential configuration issue." );
+ }
return StatusCode::SUCCESS;
} //end MdtCalibrationDbTool::initialize
diff --git a/MuonSpectrometer/MuonCnv/MuonCnvExample/python/MuonCalibConfig.py b/MuonSpectrometer/MuonCnv/MuonCnvExample/python/MuonCalibConfig.py
index 94608b056c31..084fcafe7551 100644
--- a/MuonSpectrometer/MuonCnv/MuonCnvExample/python/MuonCalibConfig.py
+++ b/MuonSpectrometer/MuonCnv/MuonCnvExample/python/MuonCalibConfig.py
@@ -162,48 +162,275 @@ def setupMdtCondDB():
condSequence += MdtCalibDbAlg("MdtCalibDbAlg")
if conddb.isOnline and not conddb.isMC:
- MdtCalibDbAlg.TubeFolder = "/MDT/T0"
- MdtCalibDbAlg.RtFolder = "/MDT/RT"
- MdtCalibDbAlg.ReadKeyTube = "/MDT/T0"
- MdtCalibDbAlg.ReadKeyRt = "/MDT/RT"
+ condSequence.MdtCalibDbAlg.TubeFolder = "/MDT/T0"
+ condSequence.MdtCalibDbAlg.RtFolder = "/MDT/RT"
+ condSequence.MdtCalibDbAlg.ReadKeyTube = "/MDT/T0"
+ condSequence.MdtCalibDbAlg.ReadKeyRt = "/MDT/RT"
else:
- MdtCalibDbAlg.TubeFolder = "/MDT/T0" + mdt_folder_name_appendix
- MdtCalibDbAlg.RtFolder = "/MDT/RT" + mdt_folder_name_appendix
- MdtCalibDbAlg.ReadKeyTube = "/MDT/T0" + mdt_folder_name_appendix
- MdtCalibDbAlg.ReadKeyRt = "/MDT/RT" + mdt_folder_name_appendix
- MdtCalibDbAlg.RT_InputFiles = ["Muon_RT_default.data"]
+ condSequence.MdtCalibDbAlg.TubeFolder = "/MDT/T0" + mdt_folder_name_appendix
+ condSequence.MdtCalibDbAlg.RtFolder = "/MDT/RT" + mdt_folder_name_appendix
+ condSequence.MdtCalibDbAlg.ReadKeyTube = "/MDT/T0" + mdt_folder_name_appendix
+ condSequence.MdtCalibDbAlg.ReadKeyRt = "/MDT/RT" + mdt_folder_name_appendix
+ condSequence.MdtCalibDbAlg.RT_InputFiles = ["Muon_RT_default.data"]
if globalflags.DataSource == 'data':
- MdtCalibDbAlg.defaultT0 = 40
+ condSequence.MdtCalibDbAlg.defaultT0 = 40
elif globalflags.DataSource == 'geant4':
- MdtCalibDbAlg.defaultT0 = 799
- MdtCalibDbAlg.UseMLRt = mdtCalibFlags.useMLRt()
- MdtCalibDbAlg.TimeSlewingCorrection = mdtCalibFlags.correctMdtRtForTimeSlewing()
- MdtCalibDbAlg.MeanCorrectionVsR = [ -5.45973, -4.57559, -3.71995, -3.45051, -3.4505, -3.4834, -3.59509, -3.74869, -3.92066, -4.10799, -4.35237, -4.61329, -4.84111, -5.14524 ]
- MdtCalibDbAlg.PropagationSpeedBeta = mdtCalibFlags.mdtPropagationSpeedBeta()
+ condSequence.MdtCalibDbAlg.defaultT0 = 799
+ condSequence.MdtCalibDbAlg.UseMLRt = mdtCalibFlags.useMLRt()
+ condSequence.MdtCalibDbAlg.TimeSlewingCorrection = mdtCalibFlags.correctMdtRtForTimeSlewing()
+ condSequence.MdtCalibDbAlg.MeanCorrectionVsR = [ -5.45973, -4.57559, -3.71995, -3.45051, -3.4505, -3.4834, -3.59509, -3.74869, -3.92066, -4.10799, -4.35237, -4.61329, -4.84111, -5.14524 ]
+ condSequence.MdtCalibDbAlg.PropagationSpeedBeta = mdtCalibFlags.mdtPropagationSpeedBeta()
# the same as MdtCalibrationDbTool
- MdtCalibDbAlg.CreateBFieldFunctions = mdtCalibFlags.correctMdtRtForBField()
- MdtCalibDbAlg.CreateWireSagFunctions = mdtCalibFlags.correctMdtRtWireSag()
- MdtCalibDbAlg.CreateSlewingFunctions = mdtCalibFlags.correctMdtRtForTimeSlewing()
+ condSequence.MdtCalibDbAlg.CreateBFieldFunctions = mdtCalibFlags.correctMdtRtForBField()
+ condSequence.MdtCalibDbAlg.CreateWireSagFunctions = mdtCalibFlags.correctMdtRtWireSag()
+ condSequence.MdtCalibDbAlg.CreateSlewingFunctions = mdtCalibFlags.correctMdtRtForTimeSlewing()
+def MdtCalibrationTool(name="MdtCalibrationTool", **kwargs):
from MdtCalibSvc.MdtCalibSvcConf import MdtCalibrationTool
- MdtCalibrationTool.DoSlewingCorrection = mdtCalibFlags.correctMdtRtForTimeSlewing()
+ kwargs.setdefault("DoSlewingCorrection", mdtCalibFlags.correctMdtRtForTimeSlewing())
+
# Hack to use DoTemperatureCorrection for applyRtScaling; but applyRtScaling should not be used anyway, since MLRT can be used
- MdtCalibrationTool.DoTemperatureCorrection = mdtCalibFlags.applyRtScaling()
- MdtCalibrationTool.DoWireSagCorrection = mdtCalibFlags.correctMdtRtWireSag()
+ kwargs.setdefault("DoTemperatureCorrection", mdtCalibFlags.applyRtScaling())
+ kwargs.setdefault("DoWireSagCorrection", mdtCalibFlags.correctMdtRtWireSag())
+
# for collisions cut away hits that are far outside of the MDT time window
if beamFlags.beamType() == 'collisions':
- MdtCalibrationTool.DoTofCorrection = True
- if globalflags.DataSource() == 'geant4':
- MdtCalibrationTool.TimeWindowSetting = mdtCalibWindowNumber('Collision_G4')
- elif globalflags.DataSource() == 'data':
- MdtCalibrationTool.TimeWindowSetting = mdtCalibWindowNumber('Collision_G4')
+ kwargs.setdefault("DoTofCorrection", True)
+
+ if globalflags.DataSource() == 'geant4' or globalflags.DataSource() == 'data':
+ kwargs.setdefault("TimeWindowSetting", mdtCalibWindowNumber('Collision_G4'))
else: # cosmics or single beam
- MdtCalibrationTool.DoTofCorrection = False
+ kwargs.setdefault("DoTofCorrection", False)
+
+ kwargs.setdefault("CalibrationDbTool", MdtCalibrationDbTool())
+ return MdtCalibrationTool(name, **kwargs)
+
+def MdtCalibrationDbTool(name="MdtCalibrationDbTool", **kwargs):
from MdtCalibSvc.MdtCalibSvcConf import MdtCalibrationDbTool
- MdtCalibrationDbTool.CreateBFieldFunctions = mdtCalibFlags.correctMdtRtForBField()
- MdtCalibrationDbTool.CreateWireSagFunctions = mdtCalibFlags.correctMdtRtWireSag()
- MdtCalibrationDbTool.CreateSlewingFunctions = mdtCalibFlags.correctMdtRtForTimeSlewing()
+ kwargs.setdefault("CreateBFieldFunctions", mdtCalibFlags.correctMdtRtForBField())
+ kwargs.setdefault("CreateWireSagFunctions", mdtCalibFlags.correctMdtRtWireSag())
+ kwargs.setdefault("CreateSlewingFunctions", mdtCalibFlags.correctMdtRtForTimeSlewing())
+ kwargs.setdefault("WasConfigured", True)
+
+ return MdtCalibrationDbTool(name, **kwargs)
+
+
+# return a list of dictionaires containing the calib config info (keys etc)
+def getCalibConfigs():
+ global muonRecFlags,rec
+ configs = []
+ if muonRecFlags.calibMuonStandalone and (muonRecFlags.doStandalone or rec.readESD):
+# try:
+ configs.append( muonRec.getConfig("MuonStandalone").getCalibConfig() )
+# except KeyError:
+# logMuon.warning("Could not get calibration config for MuonStandAlone - not adding MuonStandAlone info to calibration")
+# muonRecFlags.calibMuonStandalone = False
+ else:
+ muonRecFlags.calibMuonStandalone = False
+
+ return configs
+
+
+
+## Setup MuonSegmenToCalibSegment algorithm.
+# @param[in] segmentKeys list of segment keys to use or single segments key (string)
+def getMuonSegmentToCalibSegment():
+ global topSequence,muonRecFlags
+ try:
+ return topSequence.MuonSegmentToCalibSegment
+ except AttributeError:
+
+ from MuonCalibPatRec.MuonCalibPatRecConf import MuonCalib__MuonSegmentToCalibSegment
+ MuonSegmentToCalibSegment = MuonCalib__MuonSegmentToCalibSegment("MuonSegmentToCalibSegment")
+ # set consistent time-of-flight correction with MdtDriftCircleOnTrackCreator
+ mdtCreator = getPublicTool("MdtDriftCircleOnTrackCreator")
+ MuonSegmentToCalibSegment.DoTOF = getProperty(mdtCreator,"DoTofCorrection")
+ # when doing segment fits with floating t0's
+ MuonSegmentToCalibSegment.UpdateForT0Shift = type(MuonSegmentToCalibSegment.getDefaultProperty("UpdateForT0Shift")) (muonRecFlags.doSegmentT0Fit())
+ MuonSegmentToCalibSegment.UseCscSegments = False
+ MuonSegmentToCalibSegment.SegmentLocations = [ "MuonSegments" ]
+ MuonSegmentToCalibSegment.SegmentAuthors = [ 4,8 ]
+ MuonSegmentToCalibSegment.ReadSegments = True # rather than SegmentCombinations
+
+ from MuonCnvExample import MuonCalibConfig
+ MuonCalibConfig.setupMdtCondDB()
+
+ MuonSegmentToCalibSegment.CalibrationTool = MuonCalibConfig.MdtCalibrationTool()
+
+ # finally add it to topSequence
+ topSequence += MuonSegmentToCalibSegment
+
+ return topSequence.MuonSegmentToCalibSegment
+
+
+## Setup the basic MuonCalibAlg algorithm. Needs further configuration after this call
+# depending on the use-case.
+# @param[in] evenTag The event tag written to file
+def getMuonCalibAlg(eventTag):
+ global topSequence,beamFlags
+ try:
+ return topSequence.MuonCalibAlg
+ except AttributeError:
+ from MuonCalibAlgs.MuonCalibAlgsConf import MuonCalib__MuonCalibAlg
+ MuonCalibAlg = MuonCalib__MuonCalibAlg("MuonCalibAlg",
+ doMDTs = muonRecFlags.doMDTs(),
+ doCSCs = muonRecFlags.doCSCs(),
+ doRPCs = muonRecFlags.doRPCs(),
+ doTGCs = (muonRecFlags.doTGCs() and muonRecFlags.calibNtupleRawTGC()),
+ doTGCCoinData = (muonRecFlags.doTGCs() and muonRecFlags.calibNtupleRawTGC()),
+ doTruth = rec.doTruth(),
+ DoPrdSelect = muonRecFlags.doPrdSelect(), # optional cutting away of PRD hits to simulate dead channels
+ NtupleName = muonRecFlags.calibNtupleOutput(), # set the name of the output calibration ntuple
+ EventTag = eventTag )
+
+ if beamFlags.beamType == 'singlebeam' or beamFlags.beamType == 'cosmics':
+ MuonCalibAlg.addTriggerTag = False
+ else:
+ MuonCalibAlg.addTriggerTag = rec.doTrigger()
+ MuonCalibAlg.doTruth=rec.doTruth()
+ topSequence += MuonCalibAlg
+ return topSequence.MuonCalibAlg
+
+
+def setupMuonCalibNtuple():
+ global topSequence,muonRecFlags,beamFlags,ToolSvc,rec,DetFlags
+ if not rec.doMuon() or not DetFlags.Muon_on():
+ logMuon.warning("Not setting up requested Muon Calibration Ntuple because Muons are off")
+ return
+
+ logMuon.info("Setting up Muon Calibration Ntuple")
+ try:
+ configs = getCalibConfigs()
+ # MuonSegmentToCalibSegment is only needed if we want segments
+ if muonRecFlags.calibNtupleSegments and muonRecFlags.calibMuonStandalone:
+ MuonSegmentToCalibSegment = getMuonSegmentToCalibSegment()
+
+ # MuonCalibAlg is always needed
+ eventTag="UNKNOWN"
+ if (muonRecFlags.calibNtupleSegments or muonRecFlags.calibNtupleTracks) and muonRecFlags.calibMuonStandalone:
+ if len(configs) >= 1:
+ eventTag = configs[0]["eventTag"]
+ elif muonRecFlags.calibNtupleTrigger:
+ eventTag = "TRIG"
+ else:
+ eventTag = "HITS"
+
+ MuonCalibAlg = getMuonCalibAlg(eventTag)
+ # configure for writing ntuple
+ from MuonCalibTools.MuonCalibToolsConf import MuonCalib__PatternNtupleMaker
+ MuonCalibTool = MuonCalib__PatternNtupleMaker("MuonCalibPatternNtupleMaker")
+ MuonCalibTool.FillTruth = rec.doTruth()
+ MuonCalibTool.DoRawTGC = (muonRecFlags.doTGCs() and muonRecFlags.calibNtupleRawTGC())
+ ToolSvc += MuonCalibTool
+ MuonCalibAlg.MuonCalibTool = MuonCalibTool
+
+ # MuonCalibExtraTree only if we want to write tracks
+ if muonRecFlags.calibNtupleTracks:
+ MuonCalibTool.DelayFinish = True
+ from MuonCalibExtraTreeAlg.MuonCalibExtraTreeAlgConf import MuonCalib__MuonCalibExtraTreeAlg
+ MuonCalibExtraTreeAlg = MuonCalib__MuonCalibExtraTreeAlg("MuonCalibExtraTreeAlg",
+ NtupleName = "PatternNtupleMaker",
+ )
+ segmentOnTrackSelector=None
+ if hasattr(topSequence, "MuonSegmentToCalibSegment"):
+ from MuonCalibExtraTreeAlg.MuonCalibExtraTreeAlgConf import MuonCalib__SegmentOnTrackSelector
+ segmentOnTrackSelector=MuonCalib__SegmentOnTrackSelector()
+ segmentOnTrackSelector.PattternLocation = "PatternsForCalibration"
+ ToolSvc+=segmentOnTrackSelector
+ MuonCalibExtraTreeAlg.SegmentOnTrackSelector= segmentOnTrackSelector
+ if not rec.doMuonCombined():
+ tool_nr=0
+ from MuonCalibExtraTreeAlg.MuonCalibExtraTreeAlgConf import MuonCalib__ExtraTreeTrackFillerTool
+ resPullCalc=getPublicTool("ResidualPullCalculator")
+ for config in configs:
+ trackDumpTool = MuonCalib__ExtraTreeTrackFillerTool("ExtraTreeTrackFillerTool" + str(tool_nr))
+ trackDumpTool.TrackCollectionKey = config['tracksKey']
+ trackDumpTool.SegmentAuthors = [config['segmentAuthor']]
+ trackDumpTool.TrackAuthor = config['trackAuthor']
+ trackDumpTool.PullCalculator = resPullCalc
+ ToolSvc+=trackDumpTool
+ MuonCalibExtraTreeAlg.TrackFillerTools.append(trackDumpTool)
+ tool_nr+=1
+ # configure needed tools
+
+
+ # add to topSequence
+ topSequence += MuonCalibExtraTreeAlg
+
+
+ # MuonCalibExtraTreeTriggerAlg only if trigger is available
+ if muonRecFlags.calibNtupleTrigger: # and DetFlags.detdescr.LVL1_on() and DetFlags.haveRDO.LVL1_on():
+ # protect against running without AtlasTrigger project
+ doMuCTPI = True
+ if doMuCTPI:
+ try:
+ from TrigT1RPCRecRoiSvc import TrigT1RPCRecRoiConfig
+ from TrigT1TGCRecRoiSvc import TrigT1TGCRecRoiConfig
+ except ImportError:
+ logMuon.warning("MuonCalibExtraTreeTriggerAlg.doMuCTPI = False because AtlasTrigger is not available")
+ doMuCTPI = False
+
+ # delay writing of MuonCalibAlg
+ MuonCalibTool.DelayFinish = True
+ # also delay MuonCalibExtraTreeAlg if it is running
+ try:
+ topSequence.MuonCalibExtraTreeAlg.DelayFinish = True
+ except AttributeError:
+ pass
+
+ from MuonCalibExtraTreeAlg.MuonCalibExtraTreeAlgConf import MuonCalib__MuonCalibExtraTreeTriggerAlg
+ topSequence += MuonCalib__MuonCalibExtraTreeTriggerAlg( 'MuonCalibExtraTreeTriggerAlg',
+ doMuCTPI = doMuCTPI,
+ doLVL1Calo = rec.doTile() or rec.doLArg() or DetFlags.haveRDO.Calo_on(),
+ doMBTS = rec.doTile() or DetFlags.haveRDO.Tile_on() )
+
+
+ except:
+ from AthenaCommon.Resilience import treatException
+ treatException("Problem in MuonCalib - Muon Calibration Ntuple configuration probably incomplete")
+
+
+
+def setupMuonCalib():
+ global topSequence,ToolSvc
+ if not rec.doMuon() or not DetFlags.Muon_on():
+ logMuon.warning("Not setting up requested Muon Calibration because Muons are off")
+ return
+
+ logMuon.info("Setting up Muon Calibration")
+ try:
+ from MuonCnvExample.MuonCalibFlags import muonCalibFlags
+ muonCalibFlags.setDefaults()
+
+ configs = getCalibConfigs()
+ #
+ # MuonSegmentToCalibSegment
+ #
+ calibConfig = muonRec.allConfigs()[0].getCalibConfig() #muonRec.getConfig(muonCalibFlags.EventTag()).getCalibConfig()
+ MuonSegmentToCalibSegment = getMuonSegmentToCalibSegment()
+ #
+ # MuonCalibAlg
+ #
+ MuonCalibAlg = getMuonCalibAlg(muonCalibFlags.EventTag())
+
+ from MdtCalibTools.MdtCalibToolsConf import MuonCalib__MdtCalibTool
+ MuonCalibTool = MuonCalib__MdtCalibTool()
+ calibMode = muonCalibFlags.Mode()
+ if calibMode == 'regionNtuple':
+ from MdtCalibTools.MdtCalibToolsConf import MuonCalib__MdtCalibNtupleMakerTool
+ MdtCalibTool = MuonCalib__MdtCalibNtupleMakerTool()
+ else:
+ raise RuntimeError( "Unknown Muon Calibration Mode: %r" % calibMode )
+
+ ToolSvc += MdtCalibTool
+ MuonCalibTool.MdtCalibTool = MdtCalibTool
+
+ ToolSvc += MuonCalibTool
+ MuonCalibAlg.MuonCalibTool = MuonCalibTool
+ except:
+ from AthenaCommon.Resilience import treatException
+ treatException("Problem in MuonCalib - Muon Calibration configuration probably incomplete")
# return a list of dictionaires containing the calib config info (keys etc)
diff --git a/MuonSpectrometer/MuonConfig/python/MuonCalibrationConfig.py b/MuonSpectrometer/MuonConfig/python/MuonCalibrationConfig.py
index e54e9fe9ecda..20d1669aab84 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonCalibrationConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonCalibrationConfig.py
@@ -69,10 +69,10 @@ def _setupMdtCondDB(flags):
# end of function setupMdtCondDB()
def MdtCalibrationToolCfg(flags, **kwargs):
- result=MdtCalibrationDbToolCfg(flags, **kwargs)
- mdt_calibibration_db_tool = result.getPrimary()
+ result=MdtCalibrationDbToolCfg(flags)
+ mdt_calibration_db_tool = result.getPrimary()
- kwargs.setdefault("CalibrationDbTool", mdt_calibibration_db_tool)
+ kwargs.setdefault("CalibrationDbTool", mdt_calibration_db_tool)
kwargs.setdefault("DoSlewingCorrection", flags.Muon.Calib.correctMdtRtForTimeSlewing)
kwargs.setdefault("DoTemperatureCorrection", flags.Muon.Calib.applyRtScaling)
kwargs.setdefault("DoWireSagCorrection", flags.Muon.Calib.correctMdtRtWireSag)
@@ -80,7 +80,7 @@ def MdtCalibrationToolCfg(flags, **kwargs):
acc = MagneticFieldSvcCfg(flags)
result.merge(acc)
-
+
MdtCalibrationTool = CompFactory.MdtCalibrationTool
mdt_calibration_tool = MdtCalibrationTool(**kwargs)
result.setPrivateTools(mdt_calibration_tool)
@@ -93,7 +93,8 @@ def MdtCalibrationDbToolCfg(flags, **kwargs):
kwargs.setdefault("CreateBFieldFunctions", flags.Muon.Calib.correctMdtRtForBField)
kwargs.setdefault("CreateWireSagFunctions", flags.Muon.Calib.correctMdtRtWireSag)
kwargs.setdefault("CreateSlewingFunctions", flags.Muon.Calib.correctMdtRtForTimeSlewing)
-
+ kwargs.setdefault("WasConfigured", True)
+
MdtCalibrationDbTool = CompFactory.MdtCalibrationDbTool
mdt_calibration_db_tool = MdtCalibrationDbTool(**kwargs)
result.setPrivateTools(mdt_calibration_db_tool)
diff --git a/MuonSpectrometer/MuonConfig/python/MuonRIO_OnTrackCreatorConfig.py b/MuonSpectrometer/MuonConfig/python/MuonRIO_OnTrackCreatorConfig.py
index 94d30a541ef2..ba4b344dc0dc 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonRIO_OnTrackCreatorConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonRIO_OnTrackCreatorConfig.py
@@ -72,15 +72,8 @@ def MdtDriftCircleOnTrackCreatorCfg(flags,name="MdtDriftCircleOnTrackCreator", *
# acc = MdtCalibrationDbSvcCfg(flags)
# result.merge(acc)
- acc = MdtCalibrationDbToolCfg(flags)
- mdt_calibibration_db_tool = acc.getPrimary()
- result.merge(acc)
- kwargs.setdefault("CalibrationDbTool", mdt_calibibration_db_tool)
-
- acc = MdtCalibrationToolCfg(flags)
- mdt_calibibration_tool = acc.getPrimary()
- result.merge(acc)
- kwargs.setdefault("CalibrationTool", mdt_calibibration_tool)
+ kwargs.setdefault("CalibrationDbTool", result.popToolsAndMerge( MdtCalibrationDbToolCfg(flags)))
+ kwargs.setdefault("CalibrationTool", result.popToolsAndMerge( MdtCalibrationToolCfg(flags)) )
kwargs.setdefault("DoMagneticFieldCorrection", flags.Muon.Calib.correctMdtRtForBField)
kwargs.setdefault("DoWireSag", flags.Muon.useWireSagCorrections)
@@ -107,8 +100,8 @@ def MdtDriftCircleOnTrackCreatorCfg(flags,name="MdtDriftCircleOnTrackCreator", *
if flags.Muon.MuonTrigger:
kwargs.setdefault("doMDT", False)
-
- result.addPublicTool(Muon__MdtDriftCircleOnTrackCreator(name, **kwargs),primary=True)
+
+ result.addPublicTool(Muon__MdtDriftCircleOnTrackCreator(name, WasConfigured=True, **kwargs),primary=True)
return result
def MuonClusterOnTrackCreatorCfg(flags,name="MuonClusterOnTrackCreator", **kwargs):
diff --git a/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py b/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py
index b78e56be7379..fc3cacf94098 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py
@@ -121,6 +121,7 @@ def TgcRDODecodeCfg(flags, forTrigger=False):
def MdtRDODecodeCfg(flags, forTrigger=False):
acc = ComponentAccumulator()
+ from MuonConfig.MuonCalibrationConfig import MdtCalibrationToolCfg
# We need the MDT cabling to be setup
from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg
@@ -135,13 +136,14 @@ def MdtRDODecodeCfg(flags, forTrigger=False):
# Get the RDO -> PRD tool
Muon__MdtRdoToPrepDataToolMT=CompFactory.Muon.MdtRdoToPrepDataToolMT
- MdtRdoToMdtPrepDataTool = Muon__MdtRdoToPrepDataToolMT(name = "MdtRdoToMdtPrepDataTool")
-
+ calibTool = acc.popToolsAndMerge( MdtCalibrationToolCfg(flags))
+ MdtRdoToMdtPrepDataTool = Muon__MdtRdoToPrepDataToolMT(name = "MdtRdoToMdtPrepDataTool", CalibrationTool = calibTool)
+
# Get the RDO -> PRD alorithm
MdtRdoToMdtPrepData=CompFactory.MdtRdoToMdtPrepData
MdtRdoToMdtPrepData = MdtRdoToMdtPrepData(name = "MdtRdoToMdtPrepData",
DecodingTool = MdtRdoToMdtPrepDataTool,
- PrintPrepData = False )
+ PrintPrepData = False)
# add RegSelTool
from RegionSelector.RegSelToolConfig import regSelTool_MDT_Cfg
MdtRdoToMdtPrepData.RegSel_MDT = acc.popToolsAndMerge( regSelTool_MDT_Cfg( flags ) )
diff --git a/MuonSpectrometer/MuonConfig/python/MuonRecToolsConfig.py b/MuonSpectrometer/MuonConfig/python/MuonRecToolsConfig.py
index 11021421ac1b..e6931c765db9 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonRecToolsConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonRecToolsConfig.py
@@ -37,10 +37,11 @@ def MuonTrackToSegmentToolCfg(flags,name="MuonTrackToSegmentTool", **kwargs):
def MuonSeededSegmentFinderCfg(flags,name="MuonSeededSegmentFinder", **kwargs):
Muon__MuonSeededSegmentFinder=CompFactory.Muon.MuonSeededSegmentFinder
- from MuonConfig.MuonSegmentFindingConfig import DCMathSegmentMakerCfg, MdtMathSegmentFinder # FIXME - should really shift this to RecTools then.
+ from MuonConfig.MuonSegmentFindingConfig import DCMathSegmentMakerCfg, MdtMathSegmentFinderCfg # FIXME - should really shift this to RecTools then.
+ from MuonConfig.MuonRIO_OnTrackCreatorConfig import MdtDriftCircleOnTrackCreatorCfg
result = ComponentAccumulator()
- mdt_segment_finder = MdtMathSegmentFinder(flags, name="MCTBMdtMathSegmentFinder", UseChamberTheta = False, AssociationRoadWidth = 1.5)
+ mdt_segment_finder = result.popToolsAndMerge( MdtMathSegmentFinderCfg(flags, name="MCTBMdtMathSegmentFinder", UseChamberTheta = False, AssociationRoadWidth = 1.5) )
result.addPublicTool(mdt_segment_finder)
if "SegmentMaker" not in kwargs or "SegmentMakerNoHoles" not in kwargs:
@@ -62,6 +63,9 @@ def MuonSeededSegmentFinderCfg(flags,name="MuonSeededSegmentFinder", **kwargs):
kwargs.setdefault("MMPrepDataContainer","")
kwargs.setdefault("Printer", MuonEDMPrinterTool(flags) )
+ acc = MdtDriftCircleOnTrackCreatorCfg(flags)
+ kwargs.setdefault("MdtRotCreator", acc.getPrimary())
+ result.merge(acc)
kwargs.setdefault('TgcPrepDataContainer', 'TGC_MeasurementsAllBCs' if not flags.Muon.useTGCPriorNextBC and not flags.Muon.useTGCPriorNextBC else 'TGC_Measurements')
diff --git a/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py b/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py
index 01f3e5942990..65126bb8a945 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py
@@ -23,7 +23,7 @@ Muon__MuonSegmentSelectionTool=CompFactory.getComp("Muon::MuonSegmentSelectionTo
Muon__MuonClusterSegmentFinder=CompFactory.getComp("Muon::MuonClusterSegmentFinder")
#Local
-from MuonConfig.MuonCalibrationConfig import MdtCalibDbAlgCfg
+from MuonConfig.MuonCalibrationConfig import MdtCalibrationDbToolCfg
from MuonConfig.MuonRecToolsConfig import MCTBFitterCfg, MuonAmbiProcessorCfg, MuonStationIntersectSvcCfg, MuonTrackCleanerCfg, MuonTrackSummaryToolCfg, MuonEDMPrinterTool
from MuonConfig.MuonRIO_OnTrackCreatorConfig import MdtCalibWindowNumber
@@ -76,16 +76,17 @@ def AdjustableT0Tool(flags,**kwargs):
AdjT0__AdjustableT0Tool=CompFactory.getComp("AdjT0::AdjustableT0Tool")
return AdjT0__AdjustableT0Tool(**kwargs)
-def MdtMathSegmentFinder(flags,name="MdtMathSegmentFinder", **kwargs):
+def MdtMathSegmentFinderCfg(flags,name="MdtMathSegmentFinder", **kwargs):
# beamType = getattr(extraFlags,"beamType", beamFlags.beamType())
# doSegmentT0Fit = getattr(extraFlags,"doSegmentT0Fit",muonRecFlags.doSegmentT0Fit())
# enableCurvedSegmentFinding = getattr(extraFlags,"enableCurvedSegmentFinding", muonStandaloneFlags.enableCurvedSegmentFinding())
+ result = ComponentAccumulator()
if flags.Muon.doSegmentT0Fit:
kwargs.setdefault("AssociationRoadWidth", 3.)
kwargs.setdefault("MDTAssocationPullcut", 3.)
kwargs.setdefault("RecoverMdtOutliers", False)
- kwargs.setdefault("DCFitProvider", "MdtSegmentT0Fitter" )
+ kwargs.setdefault("DCFitProvider", result.popToolsAndMerge(MdtSegmentT0FitterCfg(flags) ) )
if flags.Beam.Type == 'singlebeam' or flags.Beam.Type == 'cosmics' or flags.Input.isMC is False:
kwargs.setdefault("AssociationRoadWidth", 2.)
@@ -94,8 +95,8 @@ def MdtMathSegmentFinder(flags,name="MdtMathSegmentFinder", **kwargs):
if flags.Muon.enableCurvedSegmentFinding:
kwargs.setdefault("DoCurvedSegmentFinder",True)
-
- return Muon__MdtMathSegmentFinder(name=name,**kwargs)
+ result.setPrivateTools(Muon__MdtMathSegmentFinder(name=name,**kwargs))
+ return result
def MuonSegmentFittingToolCfg(flags, **kwargs):
# declareProperty("SLPropagator", m_slPropagator);
@@ -131,8 +132,13 @@ def MuonSegmentFittingToolCfg(flags, **kwargs):
result.setPrivateTools(Muon__MuonSegmentFittingTool(**kwargs))
return result
+def MdtSegmentT0FitterCfg(flags, name="MdtSegmentT0Fitter", **kwargs):
+ result = MdtCalibrationDbToolCfg(flags) # Needed by MdtSegmentT0Fitter
+ kwargs.setdefault("CalibrationDbTool", result.popPrivateTools())
+ result.setPrivateTools(CompFactory.TrkDriftCircleMath.MdtSegmentT0Fitter(name, **kwargs))
+ return result
+
def DCMathSegmentMakerCfg(flags, **kwargs):
- TrkDriftCircleMath__MdtSegmentT0Fitter=CompFactory.TrkDriftCircleMath.MdtSegmentT0Fitter
from MuonConfig.MuonRIO_OnTrackCreatorConfig import MdtDriftCircleOnTrackCreatorCfg, MuonClusterOnTrackCreatorCfg, TriggerChamberClusterOnTrackCreatorCfg
from MuonConfig.MuonCondAlgConfig import MdtCondDbAlgCfg
@@ -160,12 +166,7 @@ def DCMathSegmentMakerCfg(flags, **kwargs):
kwargs.setdefault("AssumePointingPhi", beamType != 'cosmics')
kwargs.setdefault("OutputFittedT0", True)
- acc = MdtCalibDbAlgCfg(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)
+ kwargs.setdefault("DCFitProvider", result.popToolsAndMerge(MdtSegmentT0FitterCfg(flags)))
#kwargs.setdefault("CurvedErrorScaling", False)
kwargs.setdefault("UsePreciseError", True)
kwargs.setdefault("SinAngleCut", 0.4)
@@ -183,11 +184,10 @@ def DCMathSegmentMakerCfg(flags, **kwargs):
mdt_dcot_CA = MdtDriftCircleOnTrackCreatorCfg(flags, name="MdtDriftCircleOnTrackCreatorAdjustableT0", TimingMode=3, \
DoTofCorrection=True, TimeWindowSetting=MdtCalibWindowNumber('Collision_data'))
result.merge(mdt_dcot_CA)
- mdt_creator=acc.getPrimary()
- kwargs.setdefault("MdtCreatorT0", mdt_creator) # TODO - is this correct?
- mdt_math_segment_finder = MdtMathSegmentFinder(flags, doSegmentT0Fit=True)
+ kwargs.setdefault("MdtCreatorT0", mdt_dcot_CA.getPrimary()) # TODO - is this correct?
+ mdt_math_segment_finder = result.popToolsAndMerge(MdtMathSegmentFinderCfg(flags, doSegmentT0Fit=True))
else:
- mdt_math_segment_finder = MdtMathSegmentFinder(flags)
+ mdt_math_segment_finder = result.popToolsAndMerge(MdtMathSegmentFinderCfg(flags))
result.addPublicTool(mdt_math_segment_finder)
kwargs.setdefault("MdtSegmentFinder", mdt_math_segment_finder )
@@ -522,81 +522,52 @@ def MooSegmentFinderCfg(flags, name='MooSegmentFinder', **kwargs):
return result
def MuonClusterSegmentFinderToolCfg(flags, **kwargs):
- #m_slTrackFitter("Trk::GlobalChi2Fitter/MCTBSLFitter"),
- #m_ambiTool("Trk::SimpleAmbiguityProcessorTool/MuonAmbiProcessor"),
- #m_trackToSegmentTool("Muon::MuonTrackToSegmentTool/MuonTrackToSegmentTool"),
- #m_printer("Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"),
- #m_edmHelperSvc("Muon::MuonEDMHelperSvc/MuonEDMHelperSvc"),
- #m_trackCleaner("Muon::MuonTrackCleaner/MuonTrackCleaner") {
- #declareProperty("SLFitter", m_slTrackFitter);
- #declareProperty("SegmentAmbiguityTool",m_ambiTool);
- #declareProperty("TrackToSegmentTool", m_trackToSegmentTool);
- #declareProperty("TrackCleaner", m_trackCleaner);
+ from MuonConfig.MuonRecToolsConfig import MuonTrackToSegmentToolCfg
result=ComponentAccumulator()
+ # Won't explicitly configure MuonIdHelperSvc
+ # Won't explicitly configure MuonEDMHelperSvc
+ kwargs.setdefault('SegmentAmbiguityTool', result.popToolsAndMerge( MuonAmbiProcessorCfg(flags) ) )
+ kwargs.setdefault('SLFitter', result.popToolsAndMerge( MCTBFitterCfg(flags, name = "SLFitter", StraightLine=True) ) )
+ kwargs.setdefault("TrackToSegmentTool", result.popToolsAndMerge( MuonTrackToSegmentToolCfg(flags) ) )
+ kwargs.setdefault("Printer", MuonEDMPrinterTool(flags) )
+ kwargs.setdefault('TrackCleaner', result.popToolsAndMerge( MuonTrackCleanerCfg(flags) ) )
+ kwargs.setdefault('TrackSummaryTool', result.popToolsAndMerge( MuonTrackSummaryToolCfg(flags) ) )
- acc = MCTBFitterCfg(flags, name = "SLFitter", StraightLine=True)
- slfitter = acc.getPrimary()
- result.addPublicTool(slfitter)
- result.merge(acc)
- kwargs.setdefault("SLFitter", slfitter)
-
- acc = MuonTrackCleanerCfg(flags)
- cleaner = acc.getPrimary()
- result.addPublicTool(cleaner)
- kwargs.setdefault("TrackCleaner", cleaner)
- result.merge(acc)
-
- acc = MuonTrackSummaryToolCfg(flags)
- track_summary = acc.getPrimary( )
- result.addPublicTool(track_summary)
- kwargs.setdefault('TrackSummaryTool', track_summary)
- result.merge(acc)
-
- acc = MuonAmbiProcessorCfg(flags, name='MuonAmbiProcessor')
- ambi = acc.popPrivateTools()
- acc.addPublicTool(ambi)
- result.merge(acc)
- kwargs.setdefault("SegmentAmbiguityTool", ambi)
-
- # FIXME - remaining tools
result.setPrivateTools(Muon__MuonClusterSegmentFinderTool(**kwargs))
return result
-
-def MuonClusterSegmentFinderCfg(flags, **kwargs):
- #declareProperty("MuonClusterizationTool", m_clusterTool);
- #declareProperty("MuonEDMPrinterTool",m_printer );
- #declareProperty("MuonPRDSelectionTool", m_muonPRDSelectionTool );
- #declareProperty("MdtSegmentMaker",m_segmentMaker);
- #declareProperty("SLFitter", m_slTrackFitter);
- #declareProperty("TrackToSegmentTool", m_trackToSegmentTool);
- #declareProperty("AmbiguityProcessor",m_ambiguityProcessor);
- #declareProperty("TrackCleaner", m_trackCleaner);
- result=ComponentAccumulator()
- # FIXME - rest of the tools.
- acc = DCMathSegmentMakerCfg(flags,name="DCMathSegmentMaker")
- segment_maker = acc.getPrimary()
- acc.addPublicTool(segment_maker)
- kwargs.setdefault('MdtSegmentMaker', segment_maker)
+def MuonPRDSelectionToolCfg( flags, name="MuonPRDSelectionTool", **kwargs):
+ from MuonConfig.MuonRIO_OnTrackCreatorConfig import MuonClusterOnTrackCreatorCfg, MdtDriftCircleOnTrackCreatorCfg
+ # Won't explicitly configure MuonIdHelperSvc
+ result=MdtDriftCircleOnTrackCreatorCfg(flags)
+ kwargs.setdefault("MdtDriftCircleOnTrackCreator", result.getPrimary())
+ acc = MuonClusterOnTrackCreatorCfg(flags)
+ kwargs.setdefault("MuonClusterOnTrackCreator", acc.getPrimary() )
result.merge(acc)
+ # Won't explicitly configure MuonRecoValidationTool (but it would need configuration if used)
+ result.setPrivateTools(CompFactory.Muon.MuonPRDSelectionTool(**kwargs))
+ return result
- acc = MCTBFitterCfg(flags, name = "SLFitter", StraightLine=True)
- slfitter = acc.getPrimary()
- acc.addPublicTool(slfitter)
- result.merge(acc)
- kwargs.setdefault("SLFitter", slfitter)
-
- acc = MuonAmbiProcessorCfg(flags, name='NewMuonAmbiProcessor')
- ambi = acc.getPrimary()
- acc.addPublicTool(ambi)
- result.merge(acc)
- kwargs.setdefault("AmbiguityProcessor", ambi)
+def MuonClusterSegmentFinderCfg(flags, **kwargs):
+ from MuonConfig.MuonRecToolsConfig import MuonTrackToSegmentToolCfg
+ from MuonConfig.MuonRIO_OnTrackCreatorConfig import MuonClusterOnTrackCreatorCfg
- acc = MuonTrackCleanerCfg(flags)
- cleaner = acc.getPrimary()
- acc.addPublicTool(cleaner)
+ result=ComponentAccumulator()
+
+ # Won't explicitly configure MuonIdHelperSvc
+ kwargs.setdefault("MuonEDMPrinterTool", MuonEDMPrinterTool(flags) )
+ # Won't explicitly configure MuonLayerHashProviderTool
+ kwargs.setdefault("MuonPRDSelectionTool", result.popToolsAndMerge( MuonPRDSelectionToolCfg(flags) ) )
+ kwargs.setdefault('MdtSegmentMaker', result.popToolsAndMerge( DCMathSegmentMakerCfg(flags,name="DCMathSegmentMaker") ) )
+ # Won't explicitly configure MuonClusterizationTool
+ acc = MuonClusterOnTrackCreatorCfg(flags) # This only sets a public tool at the moment, so need to it like this. FIXME
+ kwargs.setdefault("MuonClusterOnTrackCreator", acc.getPrimary() )
result.merge(acc)
- kwargs.setdefault("TrackCleaner", cleaner)
+ kwargs.setdefault("TrackToSegmentTool", result.popToolsAndMerge( MuonTrackToSegmentToolCfg(flags) ) )
+ kwargs.setdefault('SLFitter', result.popToolsAndMerge( MCTBFitterCfg(flags, name = "SLFitter", StraightLine=True) ) )
+ kwargs.setdefault('AmbiguityProcessor', result.popToolsAndMerge( MuonAmbiProcessorCfg(flags) ) )
+ kwargs.setdefault('TrackCleaner', result.popToolsAndMerge( MuonTrackCleanerCfg(flags) ) )
+ # Won't explicitly configure MuonSegmentOverlapRemovalTool (though it possibly needs it)
result.addPublicTool(Muon__MuonClusterSegmentFinder(**kwargs),primary=True)
return result
@@ -738,8 +709,7 @@ if __name__=="__main__":
itemsToRecord = ["Trk::SegmentCollection#MuonSegments", "Trk::SegmentCollection#NCB_MuonSegments"]
SetupMuonStandaloneOutput(cfg, ConfigFlags, itemsToRecord)
-
-
+
# cfg.getService("StoreGateSvc").Dump = True
cfg.printConfig()
f=open("MuonSegmentFinding.pkl","wb")
diff --git a/MuonSpectrometer/MuonConfig/python/MuonTrackBuildingConfig.py b/MuonSpectrometer/MuonConfig/python/MuonTrackBuildingConfig.py
index 04fdddd8b1a2..db3bdc49f100 100644
--- a/MuonSpectrometer/MuonConfig/python/MuonTrackBuildingConfig.py
+++ b/MuonSpectrometer/MuonConfig/python/MuonTrackBuildingConfig.py
@@ -18,9 +18,7 @@ def MooTrackFitterCfg(flags, name = 'MooTrackFitter', **kwargs):
result.addPublicTool(mctb_fitter)
kwargs.setdefault("Fitter", mctb_fitter)
kwargs.setdefault("FitterPreFit", mctb_fitter)
-
- # FIXME MuPatHitTool currently isn't configured, but should be.
- MuPatHitToolCfg
+
acc = MuPatHitToolCfg(flags)
mu_pat_hit_tool = acc.getPrimary()
result.addPublicTool(mu_pat_hit_tool)
@@ -341,6 +339,8 @@ def MuPatCandidateToolCfg(flags, name="MuPatCandidateTool", **kwargs):
Muon__MuPatCandidateTool=CompFactory.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
+ from MuonConfig.MuonRecToolsConfig import MuPatHitToolCfg
+
result = MdtDriftCircleOnTrackCreatorCfg(flags)
mdt_dcot_creator = result.getPrimary()
kwargs.setdefault("MdtRotCreator", mdt_dcot_creator)
@@ -352,16 +352,28 @@ def MuPatCandidateToolCfg(flags, name="MuPatCandidateTool", **kwargs):
kwargs.setdefault("MuonPrinterTool", MuonEDMPrinterTool(flags) )
+ acc = MuPatHitToolCfg(flags)
+ mu_pat_hit_tool = acc.getPrimary()
+ result.merge(acc)
+ kwargs.setdefault("HitTool", mu_pat_hit_tool)
+
mu_pat_cand_tool = Muon__MuPatCandidateTool(name, **kwargs)
result.setPrivateTools(mu_pat_cand_tool)
return result
def MuonChamberHoleRecoveryToolCfg(flags, name="MuonChamberHoleRecoveryTool", **kwargs):
+ from MuonConfig.MuonRIO_OnTrackCreatorConfig import CscClusterOnTrackCreatorCfg,MdtDriftCircleOnTrackCreatorCfg
+
Muon__MuonChamberHoleRecoveryTool=CompFactory.Muon.MuonChamberHoleRecoveryTool
result=ComponentAccumulator()
+ # Not setting explicitly MuonStationIntersectSvc
+ acc = MdtDriftCircleOnTrackCreatorCfg(flags)
+ mdt_dcot_creator = acc.getPrimary()
+ kwargs.setdefault("MdtRotCreator", mdt_dcot_creator)
+ result.merge(acc)
+
kwargs.setdefault("AddMeasurements", not flags.Muon.doSegmentT0Fit )
if flags.Detector.GeometryCSC:
- from MuonConfig.MuonRIO_OnTrackCreatorConfig import CscClusterOnTrackCreatorCfg
extrakwargs={}
if flags.Muon.enableErrorTuning or not flags.Input.isMC:
extrakwargs["ErrorScalerBeta"] = 0.200
diff --git a/MuonSpectrometer/MuonDigitization/MDT_Digitization/python/MdtDigitizationConfig.py b/MuonSpectrometer/MuonDigitization/MDT_Digitization/python/MdtDigitizationConfig.py
index e82b1c285072..b8217bc24629 100644
--- a/MuonSpectrometer/MuonDigitization/MDT_Digitization/python/MdtDigitizationConfig.py
+++ b/MuonSpectrometer/MuonDigitization/MDT_Digitization/python/MdtDigitizationConfig.py
@@ -19,7 +19,9 @@ def MDT_LastXing():
return 150
def MdtDigitizationTool(name="MdtDigitizationTool",**kwargs):
- import MuonCondAlg.MdtCondDbAlgConfig # noqa: F401 (MT-safe conditions access)
+ import MuonCondAlg.MdtCondDbAlgConfig # noqa: F401 MT-safe conditions access
+ from MuonCnvExample import MuonCalibConfig
+
kwargs.setdefault("MaskedStations", [])
kwargs.setdefault("UseDeadChamberSvc", True)
kwargs.setdefault("DiscardEarlyHits", True)
@@ -50,6 +52,8 @@ def MdtDigitizationTool(name="MdtDigitizationTool",**kwargs):
kwargs.setdefault("OutputSDOName", overlayFlags.bkgPrefix() + "MDT_SDO")
else:
kwargs.setdefault("OutputSDOName", "MDT_SDO")
+
+ kwargs.setdefault("CalibrationDbTool", MuonCalibConfig.MdtCalibrationDbTool())
return CfgMgr.MdtDigitizationTool(name,**kwargs)
#return CfgMgr.MDT_PileUpTool(name,**kwargs)
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/CMakeLists.txt b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/CMakeLists.txt
index a6936e0f8d83..f2f9a3a07ab7 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/CMakeLists.txt
+++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/CMakeLists.txt
@@ -17,5 +17,4 @@ atlas_add_component( MdtDriftCircleOnTrackCreator
# Install files from the package:
atlas_install_headers( MdtDriftCircleOnTrackCreator )
-atlas_install_joboptions( share/*.py )
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator.h b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator.h
index 77f8091767c2..151382ed3b35 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator.h
+++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator.h
@@ -189,8 +189,8 @@ namespace Muon {
double muonErrorStrategy(const MuonDriftCircleErrorStrategy* myStrategy, double sigmaR, const Identifier& id) const;
ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
- ToolHandle<MdtCalibrationTool> m_mdtCalibrationTool{this,"CalibrationTool","MdtCalibrationTool"};
- ToolHandle<MdtCalibrationDbTool> m_mdtCalibrationDbTool{this,"CalibrationDbTool","MdtCalibrationDbTool"};
+ ToolHandle<MdtCalibrationTool> m_mdtCalibrationTool{this,"CalibrationTool","MdtCalibrationTool"};
+ ToolHandle<MdtCalibrationDbTool> m_mdtCalibrationDbTool{this,"CalibrationDbTool","MdtCalibrationDbTool"};
// Configuration variables
bool m_doMdt; //!< Process MDT ROTs
@@ -218,6 +218,7 @@ namespace Muon {
bool m_doIndividualChamberReweights; //!< Deweight individual chambers
bool m_isMC; //!< toggle between MC and data alignment errors (to be removed in rel. 21!)
bool m_looseErrors; //!< toggle between loose errors (initial before alignment) and tight after alignment
+ Gaudi::Property<bool> m_wasConfigured {this,"WasConfigured",false,"This tool is too complicated to rely on defaults. Will fail if not configured."};
const double m_inverseSpeedOfLight = 1 / Gaudi::Units::c_light; // need 1/299.792458, needed inside timeOfFlight()
};
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/share/MdtDriftCircleOnTrackCreator.py b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/share/MdtDriftCircleOnTrackCreator.py
deleted file mode 100644
index 1d5dfaa87b2b..000000000000
--- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/share/MdtDriftCircleOnTrackCreator.py
+++ /dev/null
@@ -1,5 +0,0 @@
-print "***** WARNING ******************************************************************"
-print " The file MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator.py"
-print " is currently obsolete."
-print "********************************************************************************"
-
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/MdtDriftCircleOnTrackCreator.cxx b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/MdtDriftCircleOnTrackCreator.cxx
index d7d7affb396f..832872863f90 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/MdtDriftCircleOnTrackCreator.cxx
+++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MdtDriftCircleOnTrackCreator/src/MdtDriftCircleOnTrackCreator.cxx
@@ -137,6 +137,10 @@ StatusCode Muon::MdtDriftCircleOnTrackCreator::initialize()
ATH_MSG_ERROR( "Time Correction Type too large! Aborting." );
return StatusCode::FAILURE;
}
+
+ if (!m_wasConfigured){
+ ATH_MSG_WARNING( "This tool is too complicated to rely on defaults. Potential configuration issue." );
+ }
return StatusCode::SUCCESS;
}
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonPrdProviderToolsConfig.py b/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonPrdProviderToolsConfig.py
index edd0358ebe33..dc084832971d 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonPrdProviderToolsConfig.py
+++ b/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonPrdProviderToolsConfig.py
@@ -36,6 +36,7 @@ def MdtPrepDataProviderTool(name="MdtPrepDataProviderTool", **kwargs):
if globalflags.DataSource.is_data():
kwargs.setdefault("UseTwin", True)
+ kwargs.setdefault("CalibrationTool", MuonCalibConfig.MdtCalibrationTool())
from MuonMDT_CnvTools.MuonMDT_CnvToolsConf import Muon__MdtRdoToPrepDataToolMT
return Muon__MdtRdoToPrepDataToolMT(name,**kwargs)
diff --git a/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecTools.py b/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecTools.py
index 49b060b6f886..dfadaae81f8a 100644
--- a/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecTools.py
+++ b/MuonSpectrometer/MuonReconstruction/MuonRecExample/python/MuonRecTools.py
@@ -78,6 +78,8 @@ def MdtDriftCircleOnTrackCreator(name="MdtDriftCircleOnTrackCreator",**kwargs):
kwargs.setdefault("DoMagneticFieldCorrection", mdtCalibFlags.correctMdtRtForBField())
kwargs.setdefault("DoWireSag", muonRecFlags.useWireSagCorrections())
kwargs.setdefault("DoSlewingCorrection", mdtCalibFlags.correctMdtRtForTimeSlewing())
+ kwargs.setdefault("CalibrationTool", MuonCalibConfig.MdtCalibrationTool())
+ kwargs.setdefault("CalibrationDbTool", MuonCalibConfig.MdtCalibrationDbTool())
if beamFlags.beamType() == 'cosmics' or beamFlags.beamType() == 'singlebeam' :
kwargs.setdefault("DoTofCorrection", False)
@@ -104,7 +106,7 @@ def MdtDriftCircleOnTrackCreator(name="MdtDriftCircleOnTrackCreator",**kwargs):
if TriggerFlags.MuonSlice.doTrigMuonConfig:
kwargs.setdefault("doMDT", True)
- return CfgMgr.Muon__MdtDriftCircleOnTrackCreator(name,**kwargs)
+ return CfgMgr.Muon__MdtDriftCircleOnTrackCreator(name, WasConfigured=True, **kwargs)
# end of factory function MdtDriftCircleOnTrackCreator
@@ -349,6 +351,7 @@ def MdtSegmentT0Fitter(name="MdtSegmentT0Fitter",**kwargs):
from MuonRecExample import MuonAlignConfig # noqa: F401
from MuonCnvExample import MuonCalibConfig # noqa: F401
MuonCalibConfig.setupMdtCondDB()
+ kwargs.setdefault("CalibrationDbTool", MuonCalibConfig.MdtCalibrationDbTool())
return CfgMgr.TrkDriftCircleMath__MdtSegmentT0Fitter(name,**kwargs)
def MdtMathSegmentFinder(name="MdtMathSegmentFinder",extraFlags=None,**kwargs):
diff --git a/Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py b/Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py
index 1b39bc031dfd..715ded49b3b0 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py
+++ b/Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py
@@ -211,14 +211,13 @@ def MuonMaterialProviderToolCfg(flags, name = "MuonMaterialProviderTool"):
def MuonCreatorToolCfg(flags, name="MuonCreatorTool", **kwargs):
from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg
- result = MuonMaterialProviderToolCfg(flags)
- kwargs.setdefault( "CaloMaterialProvider", result.getPrimary() )
- if flags.Muon.MuonTrigger:
- kwargs.setdefault('MakeTrackAtMSLink',True)
- kwargs.setdefault("FillTimingInformation",False)
- kwargs.setdefault("MuonSelectionTool", "")
- kwargs.setdefault("UseCaloCells", False)
- kwargs.setdefault("TrackSegmentAssociationTool", "")
+ result = ComponentAccumulator()
+ # Not explicitly setting up MuonIdHelperSvc, nor MuonEDMHelperSvc
+ kwargs.setdefault("Printer", MuonEDMPrinterTool(flags) )
+ # Not explicitly setting up MuonPrintingTool
+ acc = ParticleCaloExtensionToolCfg(flags,StartFromPerigee=True)
+ kwargs.setdefault("ParticleCaloExtensionTool", acc.getPrimary() )
+ result.merge(acc)
acc = MuonCombinedParticleCreatorCfg(flags)
kwargs.setdefault("TrackParticleCreator", acc.getPrimary() )
@@ -237,10 +236,29 @@ def MuonCreatorToolCfg(flags, name="MuonCreatorTool", **kwargs):
kwargs.setdefault("AmbiguityProcessor", acc.popPrivateTools())
result.merge(acc)
+ kwargs.setdefault("Propagator", CompFactory.Trk.RungeKuttaPropagator(name = 'AtlasRungeKuttaPropagator'))# FIXME - there should be a CA for this!
+ # Not explicitly setting up MuonDressingTool (but probably should FIXME)
+ # Not explicitly setting up MomentumBalanceTool nor ScatteringAngleTool
+ # Not explicitly setting up MuonSegmentConverterTool (but probably should FIXME)
+ # Not explicitly setting up MeanMDTdADCTool (but probably should FIXME)
+
+ kwargs.setdefault( "CaloMaterialProvider", result.popToolsAndMerge( MuonMaterialProviderToolCfg(flags) ) )
+
+ # Not explicitly setting up TrackSegmentAssociationTool
+
+ kwargs.setdefault("TrackQuery", result.popToolsAndMerge(MuonTrackQueryCfg(flags)) )
+
acc = MuonTrackSummaryToolCfg(flags)
kwargs.setdefault("TrackSummaryTool", acc.popPrivateTools())
result.merge(acc)
+ if flags.Muon.MuonTrigger:
+ kwargs.setdefault('MakeTrackAtMSLink',True)
+ kwargs.setdefault("FillTimingInformation",False)
+ kwargs.setdefault("MuonSelectionTool", "")
+ kwargs.setdefault("UseCaloCells", False)
+ kwargs.setdefault("TrackSegmentAssociationTool", "")
+
# This tool needs MuonScatteringAngleSignificanceTool... which in turn needs TrackingVolumeSvc.
# FIXME - probably this should be someplace central.
trackingVolSvc = CompFactory.Trk.TrackingVolumesSvc(name="TrackingVolumesSvc")
@@ -303,6 +321,14 @@ def MuonCandidateToolCfg(flags, name="MuonCandidateTool",**kwargs):
result.setPrivateTools(tool)
return result
+def MuonCombinedDebuggerToolCfg( flags, name="MuonCombinedDebuggerTool",**kwargs ):
+ result=ComponentAccumulator()
+ match_quality = CompFactory.Rec.MuonMatchQuality(TrackQuery = result.popToolsAndMerge( MuonTrackQueryCfg(flags) ) )
+ kwargs.setdefault("MuonMatchQuality",match_quality )
+ tool = CompFactory.MuonCombined.MuonCombinedDebuggerTool(name, **kwargs)
+ result.setPrivateTools(tool)
+ return result
+
def MuonCombinedToolCfg(flags, name="MuonCombinedTool",**kwargs):
tools = []
result=ComponentAccumulator()
@@ -320,6 +346,8 @@ def MuonCombinedToolCfg(flags, name="MuonCombinedTool",**kwargs):
result.merge(acc)
kwargs.setdefault("MuonCombinedTagTools", tools )
+ kwargs.setdefault("MuonCombinedDebuggerTool", result.popToolsAndMerge( MuonCombinedDebuggerToolCfg(flags) ) )
+
tool = CompFactory.MuonCombined.MuonCombinedTool(name,**kwargs)
result.setPrivateTools(tool)
return result
@@ -337,9 +365,7 @@ def MuonCombinedFitTagToolCfg(flags, name="MuonCombinedFitTagTool",**kwargs):
result.addPublicTool(tool)
kwargs.setdefault("TrackBuilder", tool )
- acc = MuonTrackQueryCfg(flags)
- kwargs.setdefault("TrackQuery", acc.popPrivateTools() )
- result.merge(acc)
+ kwargs.setdefault("TrackQuery", result.popToolsAndMerge(MuonTrackQueryCfg(flags)) )
acc = MuonMatchQualityCfg(flags)
kwargs.setdefault("MatchQuality", acc.popPrivateTools() )
@@ -412,6 +438,7 @@ def iPatSLFitterCfg(flags, name='iPatSLFitter', **kwargs):
# track cleaner configured to use the same fitter
def MuidTrackCleanerCfg(flags, name='MuidTrackCleaner', **kwargs ):
+ from MuonConfig.MuonRecToolsConfig import MuonTrackCleanerCfg
if flags.Beam.Type == 'cosmics':
kwargs.setdefault("PullCut" , 5.0)
kwargs.setdefault("PullCutPhi" , 10.0)
@@ -422,17 +449,7 @@ def MuidTrackCleanerCfg(flags, name='MuidTrackCleaner', **kwargs ):
if flags.Muon.MuonTrigger:
kwargs.setdefault("Iterate", False)
kwargs.setdefault("RecoverOutliers", False)
- result = iPatFitterCfg(flags)
- kwargs.setdefault("Fitter" , result.popPrivateTools() )
- acc= iPatSLFitterCfg(flags)
- kwargs.setdefault("SLFitter" , acc.popPrivateTools() )
- result.merge(acc)
-
- kwargs.setdefault("Printer", MuonEDMPrinterTool(flags) )
-
- tool = CompFactory.Muon.MuonTrackCleaner(name,**kwargs) #FIXME this is also in MuonConfig - check to see whether we can just use this.
- result.setPrivateTools(tool)
- return result
+ return MuonTrackCleanerCfg(flags, name, **kwargs)
def MuidCaloEnergyParam(flags, name='MuidCaloEnergyParam', **kwargs ):
kwargs.setdefault("Cosmics", flags.Beam.Type == 'cosmics' )
@@ -648,6 +665,8 @@ def CombinedMuonTrackBuilderCfg(flags, name='CombinedMuonTrackBuilder', **kwargs
kwargs.setdefault( "CaloMaterialProvider", acc.getPrimary() )
result.merge(acc)
+ kwargs.setdefault("TrackQuery", result.popToolsAndMerge(MuonTrackQueryCfg(flags)) )
+
if flags.Muon.SAMuonTrigger:
acc = MuonTrackSummaryToolCfg(flags)
kwargs.setdefault("TrackSummaryTool", acc.popPrivateTools())
@@ -724,6 +743,8 @@ def CombinedMuonTrackBuilderFitCfg(flags, name='CombinedMuonTrackBuilderFit', **
def MuonMatchQualityCfg(flags, name='MuonMatchQuality', **kwargs ):
result = CombinedMuonTagTestToolCfg(flags)
kwargs.setdefault("TagTool", result.popPrivateTools() )
+ kwargs.setdefault("TrackQuery", result.popToolsAndMerge(MuonTrackQueryCfg(flags)) )
+
tool = CompFactory.Rec.MuonMatchQuality(name,**kwargs)
result.setPrivateTools(tool)
return result
@@ -889,7 +910,7 @@ def MuonCaloTagToolCfg(flags, name='MuonCaloTagTool', **kwargs ):
# Misc
def MuonLayerSegmentFinderToolCfg(flags, name="MuonLayerSegmentFinderTool", **kwargs ):
- from MuonConfig.MuonSegmentFindingConfig import DCMathSegmentMakerCfg, MuonClusterSegmentFinderToolCfg
+ from MuonConfig.MuonSegmentFindingConfig import DCMathSegmentMakerCfg, MuonClusterSegmentFinderToolCfg, MuonPRDSelectionToolCfg
result = ComponentAccumulator()
csc2d=""
@@ -907,13 +928,15 @@ def MuonLayerSegmentFinderToolCfg(flags, name="MuonLayerSegmentFinderTool", **kw
kwargs.setdefault("Csc2DSegmentMaker", csc2d )
kwargs.setdefault("Csc4DSegmentMaker", csc4d )
+ kwargs.setdefault("MuonPRDSelectionTool", result.popToolsAndMerge( MuonPRDSelectionToolCfg(flags) ) )
+
acc = DCMathSegmentMakerCfg(flags, name = "DCMathSegmentMaker")
segmentmaker = acc.popPrivateTools()
kwargs.setdefault("SegmentMaker", segmentmaker )
result.addPublicTool(segmentmaker)
result.merge(acc)
- acc = MuonClusterSegmentFinderCfg(flags, name = "MuonClusterSegmentFinderEJWM")
+ acc = MuonClusterSegmentFinderCfg(flags, name = "MuonClusterSegmentFinder")
clustersegmentfinder = acc.getPrimary() #Already adds it as a public tool.
kwargs.setdefault("MuonClusterSegmentFinder", clustersegmentfinder )
result.merge(acc)
@@ -940,10 +963,16 @@ def MuonLayerSegmentMatchingToolCfg(flags, name="MuonLayerSegmentMatchingTool",
def MuonInsideOutRecoToolCfg(flags, name="MuonInsideOutRecoTool", **kwargs ):
# if TriggerFlags.MuonSlice.doTrigMuonConfig:
# kwargs.setdefault("VertexContainer", "")
- result = MuonLayerSegmentFinderToolCfg(flags, name= "MuonLayerSegmentFinderToolEJWM")
+ result = MuonLayerSegmentFinderToolCfg(flags, name= "MuonLayerSegmentFinderTool")
layersegmentfindertool = result.popPrivateTools()
kwargs.setdefault("MuonLayerSegmentFinderTool", layersegmentfindertool)
result.addPublicTool(layersegmentfindertool)
+
+ acc = MuonLayerSegmentMatchingToolCfg(flags)
+ muon_layer_segment_matching = acc.popPrivateTools()
+ kwargs.setdefault("MuonLayerSegmentMatchingTool", muon_layer_segment_matching)
+ acc.addPublicTool(muon_layer_segment_matching)
+ result.merge(acc)
acc = MuonLayerAmbiguitySolverToolCfg(flags)
muon_layer_ambiguity_solver = acc.popPrivateTools()
@@ -951,12 +980,6 @@ def MuonInsideOutRecoToolCfg(flags, name="MuonInsideOutRecoTool", **kwargs ):
acc.addPublicTool(muon_layer_ambiguity_solver)
result.merge(acc)
- acc = MuonLayerSegmentMatchingToolCfg(flags)
- muon_layer_segment_matching = acc.popPrivateTools()
- kwargs.setdefault("MuonLayerSegmentMatchingTool", muon_layer_segment_matching)
- acc.addPublicTool(muon_layer_segment_matching)
- result.merge(acc)
-
acc = MuonCandidateTrackBuilderToolCfg(flags)
muon_candidate_track_builder = acc.popPrivateTools()
kwargs.setdefault("MuonCandidateTrackBuilderTool", muon_candidate_track_builder)
@@ -976,6 +999,9 @@ def MuonInsideOutRecoToolCfg(flags, name="MuonInsideOutRecoTool", **kwargs ):
kwargs.setdefault("TrackAmbiguityProcessor", acc.getPrimary())
result.merge(acc)
+ from MuonConfig.MuonRecToolsConfig import MuonTrackSummaryToolCfg
+ kwargs.setdefault("TrackSummaryTool", acc.popToolsAndMerge( MuonTrackSummaryToolCfg(flags) ) )
+
tool = CompFactory.MuonCombined.MuonInsideOutRecoTool(name, **kwargs)
result.setPrivateTools(tool)
return result
@@ -1047,6 +1073,7 @@ def MuonStauRecoToolCfg(flags, name="MuonStauRecoTool", **kwargs ):
from MuonConfig.MuonSegmentFindingConfig import DCMathSegmentMakerCfg
from MuonConfig.MuonTrackBuildingConfig import MuonChamberHoleRecoveryToolCfg
from MuonConfig.MuonRecToolsConfig import MuonAmbiProcessorCfg, MuonSeededSegmentFinderCfg
+ from MuonConfig.MuonCalibrationConfig import MdtCalibrationDbToolCfg
kwargs.setdefault("ConsideredPDGs", [13,-13,1000015,-1000015])
kwargs.setdefault("DoTruth", flags.Input.isMC )
@@ -1092,4 +1119,7 @@ def MuonStauRecoToolCfg(flags, name="MuonStauRecoTool", **kwargs ):
result.merge(acc)
tool = CompFactory.MuonCombined.MuonStauRecoTool(name, **kwargs)
result.setPrivateTools(tool)
+
+ kwargs.setdefault("CalibrationDbTool", result.popToolsAndMerge( MdtCalibrationDbToolCfg(flags)))
+
return result
diff --git a/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuGirlTagTool.py b/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuGirlTagTool.py
index 967db99b0a3a..ff9f2002549c 100644
--- a/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuGirlTagTool.py
+++ b/Reconstruction/MuonIdentification/MuonCombinedRecExample/python/MuGirlTagTool.py
@@ -97,12 +97,15 @@ def MuonStauInsideOutRecoTool( name="MuonStauInsideOutRecoTool", **kwargs ):
return CfgMgr.MuonCombined__MuonInsideOutRecoTool(name,**kwargs )
def MuonStauRecoTool( name="MuonStauRecoTool", **kwargs ):
+ from MuonCnvExample.MuonCalibConfig import MdtCalibrationDbTool
+
kwargs.setdefault("ConsideredPDGs", [13,-13,1000015,-1000015])
kwargs.setdefault("DoTruth", rec.doTruth() )
kwargs.setdefault("DoSummary", muonCombinedRecFlags.printSummary() )
kwargs.setdefault("MuonSegmentMaker", getPublicTool("DCMathStauSegmentMaker") )
kwargs.setdefault("MuonInsideOutRecoTool", getPublicTool("MuonStauInsideOutRecoTool") )
kwargs.setdefault("TrackAmbiguityProcessor", getPublicTool("MuonAmbiProcessor") )
+ kwargs.setdefault("MdtCalibrationDbTool", MdtCalibrationDbTool())
return CfgMgr.MuonCombined__MuonStauRecoTool(name,**kwargs )
diff --git a/Trigger/TrigAlgorithms/TrigL2MuonSA/python/TrigL2MuonSAConfig.py b/Trigger/TrigAlgorithms/TrigL2MuonSA/python/TrigL2MuonSAConfig.py
index b7cd89d341ae..04fcae2901a4 100644
--- a/Trigger/TrigAlgorithms/TrigL2MuonSA/python/TrigL2MuonSAConfig.py
+++ b/Trigger/TrigAlgorithms/TrigL2MuonSA/python/TrigL2MuonSAConfig.py
@@ -41,7 +41,11 @@ if not MuonGeometryFlags.hasCSC():
#Need different PRD collection names to run offline and Run 2 trigger in same job
if not TriggerFlags.doMT():
from MuonMDT_CnvTools.MuonMDT_CnvToolsConf import Muon__MdtRdoToPrepDataTool
- MdtRdoToMdtPrepDataTool = Muon__MdtRdoToPrepDataTool(name = "TrigMdtRdoToPrepDataTool",OutputCollection="TrigMDT_DriftCircles")
+ from MuonCnvExample import MuonCalibConfig
+
+ MdtRdoToMdtPrepDataTool = Muon__MdtRdoToPrepDataTool(name = "TrigMdtRdoToPrepDataTool",
+ OutputCollection="TrigMDT_DriftCircles",
+ CalibrationTool=MuonCalibConfig.MdtCalibrationTool())
ToolSvc += MdtRdoToMdtPrepDataTool
theDataPreparator.MDTDataPreparator.MdtPrepDataProvider = MdtRdoToMdtPrepDataTool
theDataPreparator.MDTDataPreparator.MDTPrepDataContainer = MdtRdoToMdtPrepDataTool.OutputCollection
@@ -143,7 +147,8 @@ class TrigL2MuonSAMTConfig(MuonSA.MuFastSteering):
super( TrigL2MuonSAMTConfig, self ).__init__( name )
self.DataPreparator = theDataPreparator
- self.PatternFinder = MuonSA.TrigL2MuonSA__MuFastPatternFinder()
+ from MuonCnvExample.MuonCalibConfig import MdtCalibrationTool
+ self.PatternFinder = MuonSA.TrigL2MuonSA__MuFastPatternFinder(CalibrationTool=MdtCalibrationTool())
self.StationFitter = theStationFitter
self.TrackFitter = MuonSA.TrigL2MuonSA__MuFastTrackFitter()
self.TrackExtrapolator = MuonSA.TrigL2MuonSA__MuFastTrackExtrapolator()
@@ -231,7 +236,8 @@ class TrigL2MuonSAConfig(MuonSA.MuFastSteering):
super( TrigL2MuonSAConfig, self ).__init__( name )
self.DataPreparator = theDataPreparator
- self.PatternFinder = MuonSA.TrigL2MuonSA__MuFastPatternFinder()
+ from MuonCnvExample.MuonCalibConfig import MdtCalibrationTool
+ self.PatternFinder = MuonSA.TrigL2MuonSA__MuFastPatternFinder(CalibrationTool=MdtCalibrationTool())
self.StationFitter = theStationFitter
self.TrackFitter = MuonSA.TrigL2MuonSA__MuFastTrackFitter()
self.TrackExtrapolator = MuonSA.TrigL2MuonSA__MuFastTrackExtrapolator()
diff --git a/Trigger/TrigAlgorithms/TrigL2MuonSA/python/TrigL2MuonSAConfig_newJO.py b/Trigger/TrigAlgorithms/TrigL2MuonSA/python/TrigL2MuonSAConfig_newJO.py
index 624b7307acfc..8a610a1ecef4 100644
--- a/Trigger/TrigAlgorithms/TrigL2MuonSA/python/TrigL2MuonSAConfig_newJO.py
+++ b/Trigger/TrigAlgorithms/TrigL2MuonSA/python/TrigL2MuonSAConfig_newJO.py
@@ -115,6 +115,7 @@ def MmDataPreparatorCfg( flags, roisKey ):
# Based on TrigL2MuonSAMTConfig at TrigL2MuonSA/TrigL2MuonSAConfig.py
def muFastSteeringCfg( flags, roisKey, setup="" ):
+ from MuonConfig.MuonCalibrationConfig import MdtCalibrationToolCfg
acc = ComponentAccumulator()
@@ -171,9 +172,8 @@ def muFastSteeringCfg( flags, roisKey, setup="" ):
PtFromAlphaBeta.AvoidMisalignedCSCs = True
MuFastStationFitter = TrigL2MuonSA__MuFastStationFitter( PtFromAlphaBeta = PtFromAlphaBeta )
-
TrigL2MuonSA__MuFastPatternFinder,TrigL2MuonSA__MuFastTrackFitter,TrigL2MuonSA__MuFastTrackExtrapolator,TrigL2MuonSA__MuCalStreamerTool,TrigL2MuonSA__CscSegmentMaker=CompFactory.getComps("TrigL2MuonSA::MuFastPatternFinder","TrigL2MuonSA::MuFastTrackFitter","TrigL2MuonSA::MuFastTrackExtrapolator","TrigL2MuonSA::MuCalStreamerTool","TrigL2MuonSA::CscSegmentMaker")
- MuFastPatternFinder = TrigL2MuonSA__MuFastPatternFinder()
+ MuFastPatternFinder = TrigL2MuonSA__MuFastPatternFinder(CalibrationTool=acc.popToolsAndMerge( MdtCalibrationToolCfg(flags)))
MuFastTrackFitter = TrigL2MuonSA__MuFastTrackFitter()
MuFastTrackExtrapolator = TrigL2MuonSA__MuFastTrackExtrapolator()
MuCalStreamerTool = TrigL2MuonSA__MuCalStreamerTool()
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/python/TrigMuonEFConfig.py b/Trigger/TrigAlgorithms/TrigMuonEF/python/TrigMuonEFConfig.py
index 2db8347a2972..243f1cae90b7 100755
--- a/Trigger/TrigAlgorithms/TrigMuonEF/python/TrigMuonEFConfig.py
+++ b/Trigger/TrigAlgorithms/TrigMuonEF/python/TrigMuonEFConfig.py
@@ -538,7 +538,9 @@ class TrigMuonEFStandaloneTrackToolConfig (TrigMuonEFConf.TrigMuonEFStandaloneTr
from MuonCSC_CnvTools.MuonCSC_CnvToolsConf import Muon__CscRdoToCscPrepDataTool
from MuonTGC_CnvTools.MuonTGC_CnvToolsConf import Muon__TgcRdoToPrepDataTool
from MuonRPC_CnvTools.MuonRPC_CnvToolsConf import Muon__RpcRdoToPrepDataTool
- MdtRdoToMdtPrepDataTool = Muon__MdtRdoToPrepDataTool(name = "TrigEFMdtRdoToPrepDataTool")
+ from MuonCnvExample import MuonCalibConfig
+
+ MdtRdoToMdtPrepDataTool = Muon__MdtRdoToPrepDataTool(name = "TrigEFMdtRdoToPrepDataTool", CalibrationTool=MuonCalibConfig.MdtCalibrationTool())
CscRdoToCscPrepDataTool = Muon__CscRdoToCscPrepDataTool(name = "TrigEFCscRdoToPrepDataTool")
TgcRdoToTgcPrepDataTool = Muon__TgcRdoToPrepDataTool(name = "TrigEFTgcRdoToPrepDataTool")
RpcRdoToRpcPrepDataTool = Muon__RpcRdoToPrepDataTool(name = "TrigEFRpcRdoToPrepDataTool")
diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Muon/MuonSetup.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Muon/MuonSetup.py
index a4e2acacb564..0934aaaf8fdd 100644
--- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Muon/MuonSetup.py
+++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Muon/MuonSetup.py
@@ -198,8 +198,11 @@ def makeMuonPrepDataAlgs(RoIs="MURoIs", forFullScan=False):
ToolSvc += MuonMdtRawDataProviderTool
from MuonMDT_CnvTools.MuonMDT_CnvToolsConf import Muon__MdtRdoToPrepDataToolMT
+ from MuonCnvExample import MuonCalibConfig
+
MdtRdoToMdtPrepDataTool = Muon__MdtRdoToPrepDataToolMT(name = "MdtRdoToPrepDataTool",
- MdtPrdContainerCacheKey = MuonPrdCacheNames.MdtCache)
+ MdtPrdContainerCacheKey = MuonPrdCacheNames.MdtCache,
+ CalibrationTool=MuonCalibConfig.MdtCalibrationTool())
ToolSvc += MdtRdoToMdtPrepDataTool
--
GitLab