def MuonTrackCleaner(name, extraFlags=None, **kwargs):
kwargs.setdefault("Chi2Cut", muonStandaloneFlags.Chi2NDofCut())
kwargs.setdefault("MaxAvePullSumPerChamber", 6)
kwargs.setdefault("Fitter", getPrivateTool('MCTBFitterMaterialFromTrack'))
kwargs.setdefault("SLFitter",
getPrivateTool('MCTBSLFitterMaterialFromTrack'))
kwargs.setdefault("MdtRotCreator",
getPrivateTool('MdtDriftCircleOnTrackCreator'))
# kwargs.setdefault("CompRotCreator", getPrivateTool('TriggerChamberClusterOnTrackCreator')) Not in DB
return CfgMgr.Muon__MuonTrackCleaner(name, **kwargs)
def MuonSegmentFittingTool(name='MuonSegmentFittingTool',
extraFlags=None,
**kwargs):
prop = getPublicTool('AtlasRungeKuttaPropagator')
kwargs.setdefault("SLPropagator",
getPrivateToolClone('SLPropagator', prop))
# Think I need to do it this way because AtlasRungeKuttaPropagator isn't known to ConfigurableFactory.
# If I directly call getPrivateTool('AtlasRungeKuttaPropagator') then it fails with:
# ConfigurationError: Private Tool <Trk::RungeKuttaPropagator/ToolSvc.AtlasRungeKuttaPropagator at 0x7f5811db3158> not found
kwargs.setdefault("SLFitter", getPrivateTool('MCTBSLFitter'))
kwargs.setdefault("CurvedFitter", getPrivateTool('MCTBFitter'))
kwargs.setdefault("TrackCleaner", getPrivateTool('MuonTrackCleaner'))
return CfgMgr.Muon__MuonSegmentFittingTool(name, **kwargs)
def MuonCaloTagTool(name='MuonCaloTagTool', **kwargs):
from CaloTrkMuIdTools.CaloTrkMuIdToolsConf import CaloMuonTag as ConfiguredCaloMuonTag
CaloMuonTagLoose = ConfiguredCaloMuonTag(name="CaloMuonTagLoose")
CaloMuonTagLoose.TagMode = "Loose"
CaloMuonTagTight = ConfiguredCaloMuonTag(name="CaloMuonTag")
kwargs.setdefault("CaloMuonTagLoose", CaloMuonTagLoose)
kwargs.setdefault("CaloMuonTagTight", CaloMuonTagTight)
kwargs.setdefault("CaloMuonLikelihoodTool",
getPrivateTool("CaloMuonLikelihoodTool"))
kwargs.setdefault("CaloMuonScoreTool", getPrivateTool("CaloMuonScoreTool"))
kwargs.setdefault("TrackDepositInCaloTool",
getPublicTool("TrackDepositInCaloTool"))
kwargs.setdefault("TrackSelectorTool",
getPublicTool("CaloTrkMuIdAlgTrackSelectorTool"))
kwargs.setdefault("doCaloLR", True)
return CfgMgr.MuonCombined__MuonCaloTagTool(name, **kwargs)
def QratCscClusterFitter(name="QratCscClusterFitter",
extraFlags=None,
**kwargs):
qratcor_css_eta = [
0.000000, 0.000000, 0.000000, 0.000000, 0.0699381, 0.178291, 0.271303,
0.345611, 0.400738, 0.452451, 0.493772, 0.526792, 0.553845, 0.580111,
0.603337, 0.624749, 0.646065, 0.663924, 0.681897, 0.701345, 0.716067,
0.730324, 0.743168, 0.760598, 0.773341, 0.786406, 0.798358, 0.811339,
0.820949, 0.832676, 0.843917, 0.85412, 0.863914, 0.873229, 0.88251,
0.892856, 0.903296, 0.910067, 0.917892, 0.928028, 0.93461, 0.943679,
0.951617, 0.958326, 0.964428, 0.97341, 0.978204, 0.987075, 0.994789,
1.000000
]
qratcor_csl_eta = [
0.000000, 0.000000, 0.000000, 0.000000, 0.0290177, 0.0834867, 0.188683,
0.269967, 0.334887, 0.393036, 0.440317, 0.481884, 0.51725, 0.545107,
0.56959, 0.592327, 0.614087, 0.635344, 0.655252, 0.672766, 0.690929,
0.707293, 0.722742, 0.738323, 0.753562, 0.76749, 0.780983, 0.79354,
0.806521, 0.818085, 0.829987, 0.841443, 0.853723, 0.863393, 0.87431,
0.883139, 0.892962, 0.902803, 0.911276, 0.921417, 0.929387, 0.938106,
0.947072, 0.954406, 0.961692, 0.97055, 0.978517, 0.985133, 0.992257,
1.000000
]
kwargs.setdefault("qratcor_csl_eta", qratcor_csl_eta)
kwargs.setdefault("qratcor_css_eta", qratcor_css_eta)
kwargs.setdefault("CscAlignmentTool", getPrivateTool("CscAlignmentTool"))
return CfgMgr.QratCscClusterFitter(name, **kwargs)
def CscClusterOnTrackCreator(name="CscClusterOnTrackCreator", **kwargs):
kwargs.setdefault("CscStripFitter", getPrivateTool("CalibCscStripFitter"))
kwargs.setdefault("CscClusterFitter",
getPrivateTool("QratCscClusterFitter"))
kwargs.setdefault("CscClusterUtilTool",
getPrivateTool("CscClusterUtilTool"))
if False: # enable CscClusterOnTrack error scaling :
from InDetRecExample.TrackingCommon import getRIO_OnTrackErrorScalingCondAlg, createAndAddCondAlg
createAndAddCondAlg(getMuonRIO_OnTrackErrorScalingCondAlg,
'RIO_OnTrackErrorScalingCondAlg')
kwargs.setdefault("CSCErrorScalingKey", "/MUON/TrkErrorScalingCSC")
if globalflags.DataSource(
) == 'data': # collisions real data or simulated first data
# scale CSC and hit errors
kwargs.setdefault("ErrorScalerBeta", 0.070)
return CfgMgr.Muon__CscClusterOnTrackCreator(name, **kwargs)
def DCMathSegmentMaker(name='DCMathSegmentMaker', extraFlags=None, **kwargs):
beamType = getattr(extraFlags, "beamType", beamFlags.beamType())
doSegmentT0Fit = getattr(extraFlags, "doSegmentT0Fit",
muonRecFlags.doSegmentT0Fit())
updateSegmentSecondCoordinate = getattr(
extraFlags, "updateSegmentSecondCoordinate",
muonStandaloneFlags.updateSegmentSecondCoordinate())
enableCurvedSegmentFinding = getattr(
extraFlags, "enableCurvedSegmentFinding",
muonStandaloneFlags.enableCurvedSegmentFinding())
kwargs.setdefault("RefitSegment", True)
kwargs.setdefault("AssumePointingPhi", beamType != 'cosmics')
kwargs.setdefault("OutputFittedT0", True)
kwargs.setdefault("DCFitProvider", "MdtSegmentT0Fitter")
#kwargs.setdefault("CurvedErrorScaling", False)
kwargs.setdefault("UsePreciseError", True)
kwargs.setdefault("SinAngleCut", 0.4)
#MDT conditions information not available online
if (athenaCommonFlags.isOnline):
kwargs.setdefault("MdtCondKey", "")
# MuonCompetingClustersCreator apparently just takes default
kwargs.setdefault("MuonClusterCreator",
getPrivateTool("MuonClusterOnTrackCreator"))
if (beamType == 'singlebeam' or beamType == 'cosmics'):
kwargs.setdefault("SinAngleCut", 0.9)
kwargs.setdefault("AddUnassociatedPhiHits", True)
kwargs.setdefault("RecoverBadRpcCabling", True)
kwargs.setdefault("CurvedErrorScaling", False)
elif globalflags.DataSource(
) == 'data': # collisions real data or simulation first data
kwargs.setdefault("AddUnassociatedPhiHits", True)
kwargs.setdefault("RecoverBadRpcCabling", True)
if doSegmentT0Fit:
kwargs.setdefault(
"MdtCreatorT0",
getPrivateTool("MdtDriftCircleOnTrackCreatorAdjustableT0"))
kwargs.setdefault("MdtSegmentFinder",
getPrivateTool("MdtMathT0FitSegmentFinder"))
else:
kwargs.setdefault("MdtSegmentFinder",
getPrivateTool("MdtMathSegmentFinder"))
kwargs.setdefault("SegmentFitter",
getPrivateTool("MuonSegmentFittingTool"))
kwargs.setdefault("SegmentSelector",
getPrivateTool("MuonSegmentSelectionTool"))
if updateSegmentSecondCoordinate:
kwargs.setdefault("UpdatePhiUsingPhiHits", True)
if enableCurvedSegmentFinding:
kwargs.setdefault("CurvedErrorScaling", False)
kwargs.setdefault("PreciseErrorScale", 1)
kwargs.setdefault("UsePreciseError", True)
return CfgMgr.Muon__DCMathSegmentMaker(name, **kwargs)
from AthenaCommon.CfgGetter import getPrivateTool
ckvptool = getPrivateTool("CrabKissingVertexPositioner")
# all lengths are in mm
ckvptool.BunchShape = "GAUSS" # GAUSS or FLAT
ckvptool.BunchLength = 81.
ckvptool.Epsilon = 2.5e-3 # normalized emittance
ckvptool.BetaStar = 150. #
ckvptool.AlfaParallel = 3.3e-3 # kissing angle
ckvptool.AlfaX = 10.3e-3 #rad, crabbing angle
ckvptool.ThetaX = 0. #rad, half crossing angle
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
job.BeamEffectsAlg.GenEventManipulators["GenEventVertexPositioner"].VertexShifters=[ckvptool]
#############################################################
#
# postOptions.ScoringVolume.py : calls ScoringVolumeKiller
# while running a G4 simulation of the ATLAS detector.
# The ScoringVolumeKiller will kill all particles leaving
# the scoring volumes surrounding the muon stations.
#
# Dennis Wright (SLAC)
# 25 May 2010
#############################################################
from AthenaCommon.CfgGetter import getPrivateTool, getService
getService('DetectorGeometrySvc').RegionCreators += [
getPrivateTool('MuonPhysicsRegionTool')
]
#FIXME need to add this to the list of RegionCreators, but
#currently initializing the DetectorGeometrySvc too early causes
#problems with the GeoModelSvc configuration.
csc_evtSelectionTriggers = [ "L1_MU10", "L1_MU15", "EF_mu20_muCombTag_NoEF", "EF_mu15", "EF_mu15_mu10_EFFS", "EF_2mu10", "EF_2mu10_loose" ]
## retrieve TDT (this should be done already?)
if(DQMonFlags.useTrigger() and hasattr(ToolSvc, DQMonFlags.nameTrigDecTool())):
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
ToolSvc += Trig__TrigDecisionTool( "TrigDecisionTool" )
ToolSvc.TrigDecisionTool.OutputLevel=ERROR
ToolSvc.TrigDecisionTool.Navigation.OutputLevel = ERROR
from CscRawDataMonitoring.CscRawDataMonitoringConf import CscClusterValAlg
cscClusterESDValAlg = CscClusterValAlg( name = 'cscClusterESDValAlg',
CSCClusterPath = 'Muon/MuonRawDataMonitoring/CSC/Clusters',
CSCClusterKey = 'CSC_Clusters',
CSCPrepRawDataKey = 'CSC_Measurements',
CSCQmaxCutADC = 0,
CSCCalibTool = getPrivateTool("CscCalibTool"),
CSCStripFitter = getPrivateTool("CalibCscStripFitter"),
#CSCTrigDecisionTool = ToolSvc.TrigDecisionTool,
CSCDoEventSelection = False,
CSCEventSelTriggers = csc_evtSelectionTriggers
)
#ToolSvc += cscClusterESDValAlg
cscesdRawMonMan.AthenaMonTools += [cscClusterESDValAlg]
topSequence += cscesdRawMonMan
#print cscesdRawMonMan
############################################################################################################
#---------------------------------------------------------------
# CSC Segment Monitoring
def getPileUpEventLoopMgr(name="PileUpEventLoopMgr", **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
#configure random generator
digitizationFlags.rndmSeedList.addSeed("PileUpCollXingStream", 123, 345)
# SubDet By SubDet (default) or Xing By Xing Pile-up?
kwargs.setdefault('XingByXing', digitizationFlags.doXingByXingPileUp())
# Bunch Structure
if digitizationFlags.BeamIntensityPattern.statusOn:
if digitizationFlags.SignalPatternForSteppingCache.statusOn:
# Simulate Bunch Structure with events sliding backwards on a conveyor belt
kwargs.setdefault('BeamInt', getService("StepArrayBM"))
elif digitizationFlags.FixedT0BunchCrossing.statusOn:
# Simulate Bunch Structure using a fixed point for the central bunch crossing
kwargs.setdefault('BeamInt', getService("FixedArrayBM"))
else:
# Simulate Bunch Structure and allow the central bunch crossing to vary
kwargs.setdefault('BeamInt', getService("ArrayBM"))
#define inputs
kwargs.setdefault('OrigSelector', "EventSelector")
BackgroundCaches = []
if 'SplitCacheForMinbias' in digitizationFlags.experimentalDigi(
) and digitizationFlags.doLowPtMinBias(
) and digitizationFlags.doHighPtMinBias():
BackgroundCaches += [getPrivateTool("MinBiasCache", checkType=True)]
else:
if digitizationFlags.doLowPtMinBias():
BackgroundCaches += [
getPrivateTool("LowPtMinBiasCache", checkType=True)
]
if digitizationFlags.doHighPtMinBias():
BackgroundCaches += [
getPrivateTool("HighPtMinBiasCache", checkType=True)
]
if digitizationFlags.doCavern():
BackgroundCaches += [getPrivateTool("CavernCache", checkType=True)]
if digitizationFlags.doBeamGas():
BackgroundCaches += [getPrivateTool("BeamGasCache", checkType=True)]
if digitizationFlags.doBeamHalo():
BackgroundCaches += [getPrivateTool("BeamHaloCache", checkType=True)]
kwargs.setdefault('bkgCaches', BackgroundCaches)
#define output stream
kwargs.setdefault('OutStreamType', "AthenaOutputStream")
#xing frequency in ns
kwargs.setdefault('XingFrequency', digitizationFlags.bunchSpacing())
#define time range to be studied. t0 at t' ,0, xing' ,0
kwargs.setdefault('firstXing', digitizationFlags.initialBunchCrossing())
kwargs.setdefault('lastXing', digitizationFlags.finalBunchCrossing())
from AthenaCommon.AppMgr import ServiceMgr
if digitizationFlags.RunAndLumiOverrideList.statusOn:
if not (digitizationFlags.RunAndLumiOverrideList.is_locked()):
raise RuntimeError(
'You cannot configure the PileUpEventLoopMgr with an unlocked JobProperty.'
)
kwargs.setdefault(
'MaxMinBiasCollPerXing',
digitizationFlags.RunAndLumiOverrideList.getMaxNevtsPerXing())
lumiProfileSvc = getService("LumiProfileSvc")
kwargs.setdefault('BeamLuminosity', lumiProfileSvc)
ServiceMgr += lumiProfileSvc
else:
kwargs.setdefault('MaxMinBiasCollPerXing',
digitizationFlags.numberOfCollisions())
noProfileSvc = getService("NoProfileSvc")
kwargs.setdefault('BeamLuminosity', noProfileSvc)
ServiceMgr += noProfileSvc
return CfgMgr.PileUpEventLoopMgr(name, **kwargs)
# This job option should be added via the postInclude
# command line argument. I.e. before theApp.initialize()
# is called.
#
#########################################################
from AthenaCommon.AlgSequence import AlgSequence, AthSequencer
topSequence = AlgSequence()
from AthenaCommon.DetFlags import DetFlags
if DetFlags.pileup.any_on():
index = 0
for alg in topSequence:
index += 1 #count position
if 'PileUpToolsAlg' in alg.name():
from AthenaCommon.CfgGetter import getPrivateTool
alg.PileUpTools += [getPrivateTool("MergeHijingParsTool")]
break
if 'MergeMcEventCollection' == alg.name():
from MCTruthSimAlgs.MCTruthSimAlgsConf import MergeHijingPars
mergeHijingPars = MergeHijingPars()
topSequence.insert(index, mergeHijingPars)
break
else:
try:
from TruthIO.TruthIOConf import PrintHijingPars
except:
from TruthExamples.TruthExamplesConf import PrintHijingPars
topSequence += PrintHijingPars()
## configure Athena for POOL persistency
streamAlgs = ['StreamHITS', 'StreamRDO', 'StreamESD', 'StreamAOD']
def CscClusterUtilTool(name="CscClusterUtilTool", extraFlags=None, **kwargs):
kwargs.setdefault("strip_fitter", getPrivateTool("CalibCscStripFitter"))
kwargs.setdefault("precision_fitter",
getPrivateTool("QratCscClusterFitter"))
return CfgMgr.CscClusterUtilTool(name, **kwargs)
def __init__(self, forceUseDB=False, forceUseGeoModel=False):
if forceUseDB and forceUseGeoModel:
from AthenaCommon import Logging
msg = Logging.logging.getLogger("SCTLorentzAngleToolSetup")
msg.error(
"Setting is wrong: both forceUseDB and forceUseGeoModel cannot be True at the same time"
)
return
# Set up SCT_DCSConditiosnTool if necessary
if not forceUseGeoModel:
from SCT_ConditionsTools.SCT_DCSConditionsToolSetup import SCT_DCSConditionsToolSetup
sct_DCSConditionsToolSetup = SCT_DCSConditionsToolSetup()
# For HLT and online monitoring
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
if athenaCommonFlags.isOnline():
sct_DCSConditionsToolSetup.setReadAllDBFolders(False)
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == "data":
sct_DCSConditionsToolSetup.setDbInstance("SCT")
dcs_folder = "/SCT/HLT/DCS"
sct_DCSConditionsToolSetup.setStateFolder(dcs_folder +
"/CHANSTAT")
sct_DCSConditionsToolSetup.setHVFolder(dcs_folder + "/HV")
sct_DCSConditionsToolSetup.setTempFolder(dcs_folder +
"/MODTEMP")
sct_DCSConditionsToolSetup.setup()
# Set up SCT_SiliconConditionsTool
from SCT_ConditionsTools.SCT_SiliconConditionsToolSetup import SCT_SiliconConditionsToolSetup
sct_SiliconConditionsToolSetup = SCT_SiliconConditionsToolSetup()
if forceUseGeoModel:
sct_SiliconConditionsToolSetup.setUseDB(False)
sct_SiliconConditionsToolSetup.setForceUseGeoModel(True)
else:
sct_SiliconConditionsToolSetup.setDcsTool(
sct_DCSConditionsToolSetup.getTool())
sct_SiliconConditionsToolSetup.setup()
sctSiliconConditionsTool = sct_SiliconConditionsToolSetup.getTool()
self.sctSiliconConditionsTool = sctSiliconConditionsTool
self.SCT_SiliconConditionsTool = sctSiliconConditionsTool
# Set up SCTSiLorentzAngleCondAlg
from AthenaCommon.AlgSequence import AthSequencer
condSeq = AthSequencer("AthCondSeq")
if not hasattr(condSeq, "SCTSiLorentzAngleCondAlg"):
from SiLorentzAngleTool.SiLorentzAngleToolConf import SCTSiLorentzAngleCondAlg
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
condSeq += SCTSiLorentzAngleCondAlg(
name="SCTSiLorentzAngleCondAlg",
SiConditionsTool=sctSiliconConditionsTool,
UseMagFieldCache=True,
UseMagFieldDcs=(not athenaCommonFlags.isOnline()),
UseGeoModel=forceUseGeoModel)
sctSiLorentzAngleCondAlg = condSeq.SCTSiLorentzAngleCondAlg
if forceUseDB:
sctSiLorentzAngleCondAlg.useSctDefaults = False
# Set up SCTLorentzAngleTool
from AthenaCommon.CfgGetter import getPrivateTool
sctLorentzAngleTool = getPrivateTool("SCTLorentzAngleTool")
# Pass the silicon conditions tool to the Lorentz angle tool
# Also make sure UseMagFieldTool is True as AtlasGeoModel sets this to False
# if loaded first.
sctLorentzAngleTool.UseMagFieldCache = True
self.SCTLorentzAngleTool = sctLorentzAngleTool
getPrivateToolClone('SLPropagator', prop))
# Think I need to do it this way because AtlasRungeKuttaPropagator isn't known to ConfigurableFactory.
# If I directly call getPrivateTool('AtlasRungeKuttaPropagator') then it fails with:
# ConfigurationError: Private Tool <Trk::RungeKuttaPropagator/ToolSvc.AtlasRungeKuttaPropagator at 0x7f5811db3158> not found
kwargs.setdefault("SLFitter", getPrivateTool('MCTBSLFitter'))
kwargs.setdefault("CurvedFitter", getPrivateTool('MCTBFitter'))
kwargs.setdefault("TrackCleaner", getPrivateTool('MuonTrackCleaner'))
return CfgMgr.Muon__MuonSegmentFittingTool(name, **kwargs)
if DetFlags.detdescr.Muon_on() and rec.doMuon():
# until all clients explicitly get their tools and services, load some explicitly
getPublicTool("ResidualPullCalculator")
getPublicTool("MuonHoughPatternTool")
getPublicTool("MuonCombinePatternTool")
getPublicTool("MuonPhiHitSelector")
getPublicTool("MuonEDMPrinterTool")
getPublicTool("MuonSegmentMomentum")
getPublicTool("MuonClusterOnTrackCreator")
if MuonGeometryFlags.hasCSC():
getPrivateTool("CscClusterOnTrackCreator")
getPrivateTool("CscBroadClusterOnTrackCreator")
getPublicTool("MdtDriftCircleOnTrackCreator")
getPublicTool("MdtTubeHitOnTrackCreator")
#getService("SomeService")
else: # not (DetFlags.Muon_on() and rec.doMuon())
logMuon.warning(
"Muon reconstruction tools only loaded on-demand because Muons")
def CombinedMuonTrackBuilder( name='CombinedMuonTrackBuilder', **kwargs ):
from AthenaCommon.AppMgr import ToolSvc
kwargs.setdefault("CaloEnergyParam" , getPublicTool("MuidCaloEnergyToolParam") )
kwargs.setdefault("CaloTSOS" , getPublicTool("MuidCaloTrackStateOnSurface") )
kwargs.setdefault("MaterialAllocator" , getPublicTool("MuidMaterialAllocator") )
kwargs.setdefault("MdtRotCreator" , getPublicTool("MdtDriftCircleOnTrackCreator") )
kwargs.setdefault("CleanCombined" , True )
kwargs.setdefault("CleanStandalone" , True )
kwargs.setdefault("BadFitChi2" , 2.5 )
kwargs.setdefault("LargeMomentumError" , 0.5 )
kwargs.setdefault("LineMomentum" , muonStandaloneFlags.straightLineFitMomentum() )
kwargs.setdefault("LowMomentum" , 10.*GeV )
kwargs.setdefault("MinEnergy" , 0.3*GeV )
kwargs.setdefault("PerigeeAtSpectrometerEntrance" , False )
kwargs.setdefault("ReallocateMaterial" , False )
kwargs.setdefault("Vertex2DSigmaRPhi" , 100.*mm )
kwargs.setdefault("Vertex3DSigmaRPhi" , 6.*mm )
kwargs.setdefault("Vertex3DSigmaZ" , 60.*mm)
kwargs.setdefault("UseCaloTG" , True ) #
kwargs.setdefault("CaloMaterialProvider" , getPublicTool("MuonMaterialProviderTool"))
kwargs.setdefault("TrackQuery" , getPrivateTool("MuonTrackQuery") )
if TriggerFlags.MuonSlice.doTrigMuonConfig:
kwargs.setdefault("MuonHoleRecovery" , "" )
trigTrackSummary = getPublicToolClone("TrigMuonTrackSummary", "MuonTrackSummaryTool")
if DetFlags.detdescr.ID_on():
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackSummaryHelperTool
trigTrackSummary.InDetSummaryHelperTool = InDetTrigTrackSummaryHelperTool
trigTrackSummary.doHolesInDet = True
kwargs.setdefault("TrackSummaryTool" , trigTrackSummary )
kwargs.setdefault("Propagator" , ToolSvc.AtlasRungeKuttaPropagator)
kwargs.setdefault("SLPropagator" , ToolSvc.AtlasRungeKuttaPropagator)
#The trigger uses the iPatFitter in different sequences that do and do not include ID tracking
#so using the same track summary tool as is used here to get it correct
trackSummary = kwargs["TrackSummaryTool"]
suffix = "MS"
if "Trig" in trackSummary.name():
suffix = "CB"
kwargs.setdefault("Fitter" , getPublicToolClone("TrigiPatFitter_"+suffix, "iPatFitter", TrackSummaryTool=trackSummary) )
kwargs.setdefault("SLFitter" , getPublicToolClone("TrigiPatSLFitter_"+suffix, "iPatSLFitter", TrackSummaryTool=trackSummary) )
kwargs.setdefault("MuonErrorOptimizer", "")
kwargs.setdefault("CscRotCreator" , "" )
kwargs.setdefault("Cleaner" , getPrivateToolClone("TrigMuidTrackCleaner_"+suffix, "MuidTrackCleaner", Fitter=kwargs["Fitter"]) )
else:
import MuonCombinedRecExample.CombinedMuonTrackSummary
kwargs.setdefault("MuonHoleRecovery" , getPublicTool("MuidSegmentRegionRecoveryTool") )
kwargs.setdefault("TrackSummaryTool" , ToolSvc.CombinedMuonTrackSummary )
kwargs.setdefault("Propagator" , getPublicTool("MuonCombinedPropagator") )
kwargs.setdefault("SLPropagator" , getPublicTool("MuonCombinedPropagator") )
kwargs.setdefault("Fitter" , getPublicTool("iPatFitter") )
kwargs.setdefault("SLFitter" , getPublicTool("iPatSLFitter") )
kwargs.setdefault("CscRotCreator" , (getPublicTool("CscClusterOnTrackCreator") if MuonGeometryFlags.hasCSC() else "") )
kwargs.setdefault("Cleaner" , getPrivateTool("MuidTrackCleaner") )
if beamFlags.beamType() == 'cosmics':
kwargs.setdefault("MdtRotCreator" , "" )
kwargs.setdefault("LowMomentum" , 1.5*GeV )
kwargs.setdefault("ReallocateMaterial", False )
kwargs.setdefault("Vertex2DSigmaRPhi" , 100.*mm )
kwargs.setdefault("Vertex3DSigmaRPhi" , 100.*mm )
kwargs.setdefault("Vertex3DSigmaZ" , 1.*meter )
# configure tools for data reprocessing
if muonRecFlags.enableErrorTuning():
# use alignment effects on track for all algorithms
useAlignErrs = True
if conddb.dbdata == 'COMP200' or conddb.dbmc == 'COMP200' or 'HLT' in globalflags.ConditionsTag() or conddb.isOnline or TriggerFlags.MuonSlice.doTrigMuonConfig:
useAlignErrs = False
kwargs.setdefault("MuonErrorOptimizer", getPublicToolClone("MuidErrorOptimisationTool",
"MuonErrorOptimisationTool",
PrepareForFit = False,
RecreateStartingParameters = False,
RefitTool = getPublicToolClone("MuidRefitTool", "MuonRefitTool", AlignmentErrors = useAlignErrs, Fitter = getPublicTool("iPatFitter"))
))
if muonRecFlags.doSegmentT0Fit():
kwargs.setdefault("MdtRotCreator" , "" )
getPublicTool("MuonCaloParticleCreator")
return CfgMgr.Rec__CombinedMuonTrackBuilder(name,**kwargs)
#--------------------------------------------------------------
# Load CondAlg, Tool and TestAlg
#--------------------------------------------------------------
from AthenaCommon.AlgSequence import AthSequencer
condSeq = AthSequencer("AthCondSeq")
condAlgName = "SCT_CablingCondAlgFromCoraCool"
if not hasattr(condSeq, condAlgName):
from AthenaCommon.CfgGetter import getAlgorithm
SCT_CablingCondAlgFromCoraCool = getAlgorithm(condAlgName)
condSeq += SCT_CablingCondAlgFromCoraCool
from AthenaCommon.CfgGetter import getPrivateTool
SCT_CablingTool = getPrivateTool("SCT_CablingTool")
SCT_CablingTool.DataSource = "COOLVECTOR"
SCT_CablingTool.OutputLevel = INFO
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
from SCT_Cabling.SCT_CablingConf import SCT_TestCablingAlg
topSequence += SCT_TestCablingAlg(
SCT_CablingTool=SCT_CablingTool,
OutputLevel=INFO,
POSIXtime=ServiceMgr.EventSelector.InitialTimeStamp)
if numThreads >= 2:
from SCT_ConditionsAlgorithms.SCTCondAlgCardinality import sctCondAlgCardinality
DetFlags.Print()
include("Digitization/Digitization.py")
#--------------------------------------------------------------
#test the IPileUpTool call back mechanism
#--------------------------------------------------------------
#this only works in XingByXing mode
if digitizationFlags.doXingByXingPileUp():
job = AlgSequence()
puAlg = job.StandardPileUpToolsAlg
#puAlg = job.StandardInTimeOnlyTruthPileUpToolsAlg
puAlg.OutputLevel = DEBUG
from AthenaCommon.CfgGetter import getPrivateTool
puAlg.PileUpTools += [
getPrivateTool("TestPileUpTool", tryDefaultConfigurable=True)
]
puAlg.PileUpTools["TestPileUpTool"].OutputLevel = DEBUG
#xing times in ns
puAlg.PileUpTools["TestPileUpTool"].FirstXing = -300
puAlg.PileUpTools["TestPileUpTool"].LastXing = +300
#--------------------------------------------------------------
# Set output level threshold (2=DEBUG, 3=INFO, 4=WARNING, 5=ERROR, 6=FATAL )
#--------------------------------------------------------------
from AthenaCommon.AppMgr import ServiceMgr
ServiceMgr.MessageSvc.OutputLevel = INFO
ServiceMgr.MessageSvc.setVerbose += ["PileUpStream"]
pupElm = ServiceMgr.PileUpEventLoopMgr
pupElm.OutputLevel = VERBOSE
def CalibCscStripFitter(name="CalibCscStripFitter", extraFlags=None, **kwargs):
kwargs.setdefault("cscCalibTool", getPrivateTool("CscCalibTool"))
return CfgMgr.CalibCscStripFitter(name, **kwargs)
