def MuonPatternSegmentMaker(name="MuonPatternSegmentMaker",
extraFlags=None,
**kwargs):
if extraFlags is None: extraFlags = ExtraFlags()
beamType = extraFlags.setFlagDefault(beamFlags.beamType)
doSegmentT0Fit = extraFlags.setFlagDefault(muonRecFlags.doSegmentT0Fit)
if "MdtCreator" not in kwargs:
# on data configure a MdtDriftCircleOnTrackCreator for the segment finding with reduced errors
# when using the t0 refit enlarge the time window
if globalflags.DataSource() == 'data' and beamFlags.beamType(
) == 'collisions':
if doSegmentT0Fit:
mdtCreator = getPublicToolClone(
"MdtDriftCircleOnTrackCreatorSegmentFinding",
"MdtDriftCircleOnTrackCreator",
CreateTubeHit=False,
TimeWindowSetting=mdtCalibWindowNumber('Collision_t0fit'))
else:
mdtCreator = getPublicToolClone(
"MdtDriftCircleOnTrackCreatorSegmentFinding",
"MdtDriftCircleOnTrackCreator",
CreateTubeHit=False,
TimeWindowSetting=mdtCalibWindowNumber('Collision_data'))
kwargs["MdtCreator"] = mdtCreator
if beamType == 'cosmics':
kwargs.setdefault("AngleCutPhi", 1e9)
kwargs.setdefault("DropDistance", 100000000.)
return CfgMgr.Muon__MuonPatternSegmentMaker(name, **kwargs)
def MuonSeededSegmentFinder(name="MuonSeededSegmentFinder", **kwargs):
if "SegmentMaker" not in kwargs or "SegmentMakerNoHoles" not in kwargs:
if beamFlags.beamType() == 'collisions':
segMaker = getPublicToolClone(
"MCTBDCMathSegmentMaker",
"DCMathSegmentMaker",
MdtSegmentFinder="MCTBMdtMathSegmentFinder",
SinAngleCut=0.04,
DoGeometry=True)
else: # cosmics or singlebeam
segMaker = getPublicToolClone(
"MCTBDCMathSegmentMaker",
"DCMathSegmentMaker",
MdtSegmentFinder="MCTBMdtMathSegmentFinder",
SinAngleCut=0.1,
DoGeometry=False,
AddUnassociatedPhiHits=True)
kwargs.setdefault("SegmentMaker", segMaker)
kwargs.setdefault("SegmentMakerNoHoles", segMaker)
if not MuonGeometryFlags.hasCSC():
kwargs.setdefault("CscPrepDataContainer", "")
if not MuonGeometryFlags.hasSTGC():
kwargs.setdefault("sTgcPrepDataContainer", "")
if not MuonGeometryFlags.hasMM():
kwargs.setdefault("MMPrepDataContainer", "")
return CfgMgr.Muon__MuonSeededSegmentFinder(name, **kwargs)
def CombinedMuonTrackBuilder( name='CombinedMuonTrackBuilder', **kwargs ):
import MuonCombinedRecExample.CombinedMuonTrackSummary
from AthenaCommon.AppMgr import ToolSvc
kwargs.setdefault("CaloEnergyParam" , getPublicTool("MuidCaloEnergyToolParam") )
kwargs.setdefault("CaloTSOS" , getPublicTool("MuidCaloTrackStateOnSurface") )
kwargs.setdefault("CscRotCreator" , getPublicTool("CscClusterOnTrackCreator") )
kwargs.setdefault("Fitter" , getPublicTool("iPatFitter") )
kwargs.setdefault("SLFitter" , getPublicTool("iPatSLFitter") )
kwargs.setdefault("MaterialAllocator" , getPublicTool("MuidMaterialAllocator") )
kwargs.setdefault("MdtRotCreator" , getPublicTool("MdtDriftCircleOnTrackCreator") )
kwargs.setdefault("MuonHoleRecovery" , getPublicTool("MuidSegmentRegionRecoveryTool") )
kwargs.setdefault("Propagator" , getPublicTool("MuonCombinedPropagator") )
kwargs.setdefault("SLPropagator" , getPublicTool("MuonCombinedPropagator") )
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("TrackSummaryTool" , ToolSvc.CombinedMuonTrackSummary )
kwargs.setdefault("UseCaloTG" , True ) #
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 :
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)
def MooTrackBuilder(name="MooTrackBuilderTemplate", extraFlags=None, **kwargs):
namePrefix = getattr(extraFlags, "namePrefix", "")
namePostfix = getattr(extraFlags, "namePostfix", "")
optimiseMomentumResolutionUsingChi2 = getattr(
extraFlags, "optimiseMomentumResolutionUsingChi2", False)
kwargs.setdefault("Fitter", "MooTrackFitter")
kwargs.setdefault("SLFitter", "MooSLTrackFitter")
kwargs.setdefault(
"RecalibrateMDTHitsOnTrack",
((not muonRecFlags.doSegmentT0Fit())
and muonStandaloneFlags.reconstructionMode() == 'collisions'))
# hardcode some properties before passing on to base class constructors
if optimiseMomentumResolutionUsingChi2:
if "ErrorOptimisationTool" not in kwargs:
if namePrefix or namePostfix:
tool = getPublicToolClone(
namePrefix + "MuonErrorOptimisationTool" + namePostfix,
"MuonErrorOptimisationTool",
extraFlags=extraFlags)
else:
tool = getPublicTool("MuonErrorOptimisationTool")
kwargs["ErrorOptimisationTool"] = tool
builder = CfgMgr.Muon__MooTrackBuilder(name, **kwargs)
# make clones of some tools if namePrefix (e.g. for TrigMuonEF) or namePostfix (e.g. for FinalFit) is given
if namePrefix or namePostfix:
oldFitterName = getProperty(builder, "Fitter").getName()
newFitterName = namePrefix + oldFitterName + namePostfix
builder.Fitter = getPublicToolClone(newFitterName,
oldFitterName,
extraFlags=extraFlags)
oldFitterName = getProperty(builder, "SLFitter").getName()
newFitterName = namePrefix + oldFitterName + namePostfix
builder.SLFitter = getPublicToolClone(newFitterName,
oldFitterName,
extraFlags=extraFlags)
oldMatchingToolName = getProperty(builder,
"CandidateMatchingTool").getName()
newMatchingToolName = namePrefix + oldMatchingToolName + namePostfix
builder.CandidateMatchingTool = getPublicToolClone(
newMatchingToolName, oldMatchingToolName, extraFlags=extraFlags)
import MuonCombinedRecExample.CombinedMuonTrackSummary
from AthenaCommon.AppMgr import ToolSvc
kwargs.setdefault("TrackSummaryTool", ToolSvc.CombinedMuonTrackSummary)
return builder
def MuonTrackSteering(name="MuonTrackSteering", extraFlags=None, **kwargs):
if extraFlags is None:
extraFlags = ExtraFlags()
extraFlags.setFlagDefault("namePrefix", "MuSt_")
extraFlags.setFlagDefault("doSegmentPhiMatching", True)
extraFlags.setFlagDefault(muonStandaloneFlags.optimiseMomentumResolutionUsingChi2) # take name & value from JobProperty
extraFlags.setFlagDefault(muonStandaloneFlags.strategy)
extraFlags.setFlagDefault(muonStandaloneFlags.trackBuilder)
extraFlags.setFlagDefault(muonStandaloneFlags.printSummary)
extraFlags.setFlagDefault(muonStandaloneFlags.refinementTool)
if extraFlags.strategy:
kwargs.setdefault("StrategyList", extraFlags.strategy)
else:
kwargs.setdefault("StrategyList", MoorelikeStrategy)
kwargs.setdefault("DoSummary", extraFlags.printSummary)
kwargs.setdefault("OutputSingleStationTracks", True)
kwargs.setdefault("HoleRecoveryTool", "MuonEORecoveryTool")
if "TrackBuilderTool" not in kwargs:
extraFlags.setFlagDefault('UseTrackingHistory',True)
kwargs["TrackBuilderTool"] = getPublicToolClone("MooMuonTrackBuilder", "MooTrackBuilderTemplate",
extraFlags=extraFlags)
if "TrackRefinementTool" not in kwargs:
kwargs["TrackRefinementTool"] = getPublicTool("MooTrackBuilderTemplate")
kwargs.setdefault("SegSeedQCut", 2)
kwargs.setdefault("Seg2ndQCut", 1)
return CfgMgr.Muon__MuonTrackSteering(name,**kwargs)
def getKernel_G4HiggsLeptonsConeOnly(name="ISF_Kernel_G4HiggsLeptonsConeOnly", **kwargs):
from AthenaCommon.CfgGetter import getPublicToolClone
kwargs.setdefault("BeamPipeSimulationSelectors" , [ 'ISF_SubDetStickyGeant4SimSelector',
getPublicToolClone('ISF_HiggsLeptonsConeGeant4SelectorBeamPipe','ISF_HiggsLeptonsConeGeant4Selector') ,
'ISF_DefaultParticleKillerSelector' ] )
kwargs.setdefault("IDSimulationSelectors" , [ 'ISF_SubDetStickyGeant4SimSelector',
getPublicToolClone('ISF_HiggsLeptonsConeGeant4SelectorID','ISF_HiggsLeptonsConeGeant4Selector') ,
'ISF_DefaultParticleKillerSelector' ] )
kwargs.setdefault("CaloSimulationSelectors" , [ 'ISF_SubDetStickyGeant4SimSelector',
getPublicToolClone('ISF_HiggsLeptonsConeGeant4SelectorCalo','ISF_HiggsLeptonsConeGeant4Selector') ,
'ISF_DefaultParticleKillerSelector' ] )
kwargs.setdefault("MSSimulationSelectors" , [ 'ISF_SubDetStickyGeant4SimSelector',
getPublicToolClone('ISF_HiggsLeptonsConeGeant4SelectorMS','ISF_HiggsLeptonsConeGeant4Selector') ,
'ISF_DefaultParticleKillerSelector' ] )
kwargs.setdefault("CavernSimulationSelectors" , [ 'ISF_DefaultParticleKillerSelector' ] )
return getKernel_GenericSimulator(name, **kwargs)
def MooCandidateMatchingTool(name, extraFlags=None, **kwargs):
namePrefix = getattr(extraFlags, "namePrefix", "")
namePostfix = getattr(extraFlags, "namePostfix", "")
doSegmentPhiMatching = getattr(extraFlags, "doSegmentPhiMatching", None)
useTrackSegmentMatching = getattr(
extraFlags, "useTrackSegmentMatching",
muonStandaloneFlags.useTrackSegmentMatching())
# segment-segment matching
if doSegmentPhiMatching is not None:
if not (namePrefix or namePostfix):
raise RuntimeError(
"extraFlags ERROR: namePrefix or namePostfix is required if doSegmentPhiMatching is set"
)
if "SegmentMatchingTool" not in kwargs:
kwargs["SegmentMatchingTool"] = getPublicToolClone(
namePrefix + "MuonSegmentMatchingTool" + namePostfix,
"MuonSegmentMatchingTool",
doPhiMatching=doSegmentPhiMatching)
if "SegmentMatchingToolTight" not in kwargs:
kwargs["SegmentMatchingToolTight"] = getPublicToolClone(
namePrefix + "MuonSegmentMatchingToolTight" + namePostfix,
"MuonSegmentMatchingToolTight",
doPhiMatching=doSegmentPhiMatching)
# track-segment matching
kwargs.setdefault("DoTrackSegmentMatching", useTrackSegmentMatching)
kwargs.setdefault("RequireSameSide",
muonStandaloneFlags.reconstructionMode() != "collisions")
if muonRecFlags.useAlignmentCorrections():
kwargs.setdefault("AlignmentErrorPosX", 5.0)
kwargs.setdefault("AlignmentErrorPosY", 0.2)
kwargs.setdefault("AlignmentErrorAngleX", 0.002)
kwargs.setdefault("AlignmentErrorAngleY", 0.001)
else: # no alignment corrections
kwargs.setdefault("AlignmentErrorPosX", 10.0)
kwargs.setdefault("AlignmentErrorPosY", 5.0)
kwargs.setdefault("AlignmentErrorAngleX", 0.004)
kwargs.setdefault("AlignmentErrorAngleY", 0.002)
kwargs.setdefault("MuPatCandidateTool",
getPublicTool("MuPatCandidateTool"))
return CfgMgr.Muon__MooCandidateMatchingTool(name, **kwargs)
def OutwardsCombinedMuonTrackBuilder( name = 'OutwardsCombinedMuonTrackBuilder', **kwargs ):
import MuonCombinedRecExample.CombinedMuonTrackSummary
from AthenaCommon.AppMgr import ToolSvc
kwargs.setdefault("Cleaner", getPublicTool("OutwardsTrackCleaner") )
kwargs.setdefault("Fitter", getPublicTool("MuonCombinedTrackFitter") )
kwargs.setdefault("TrackSummaryTool" , ToolSvc.CombinedMuonTrackSummary )
kwargs.setdefault("MuonHoleRecovery" , getPublicTool("OutwardsSegmentRegionRecoveryTool") )
kwargs.setdefault("AllowCleanerVeto" , False)
if muonRecFlags.enableErrorTuning():
kwargs.setdefault("MuonErrorOptimizer", getPublicToolClone("OutwardsErrorOptimisationTool", "MuidErrorOptimisationTool",
PrepareForFit=False,RecreateStartingParameters=False,
RefitTool = getPublicToolClone("OutwardsRefitTool",
"MuonRefitTool",
AlignmentErrors = False,
Fitter = getPublicTool("MuonCombinedTrackFitter"))))
return CfgMgr.Rec__OutwardsCombinedMuonTrackBuilder(name,**kwargs)
def MuonInDetForwardCandidateTool(name='MuonInDetForwardCandidateTool',
**kwargs):
#import pdb ; pdb.set_trace()
idCandTool = getPublicToolClone(
"InDetForwardCandidateTool",
"InDetCandidateTool",
TrackSelector=getPublicTool(
"MuonCombinedInDetDetailedForwardTrackSelectorTool"))
idCandTool.FlagCandidatesAsSiAssociated = True
return idCandTool
def MuonCandidateTool(name="MuonCandidateTool", **kwargs):
if beamFlags.beamType() == 'cosmics':
kwargs.setdefault("ExtrapolationStrategy", 1)
kwargs.setdefault("TrackExtrapolationTool",
getPublicTool("ExtrapolateMuonToIPTool"))
if TriggerFlags.MuonSlice.doTrigMuonConfig:
trigTrackBuilder = getPublicToolClone(
"TrigCombinedMuonTrackBuilder",
"CombinedMuonTrackBuilder",
TrackSummaryTool=getPublicTool("MuonTrackSummaryTool"))
kwargs.setdefault("TrackBuilder", trigTrackBuilder)
return CfgMgr.MuonCombined__MuonCandidateTool(name, **kwargs)
def MuonErrorOptimisationTool(name,extraFlags=None,**kwargs):
namePrefix =getattr(extraFlags,"namePrefix","")
namePostfix=getattr(extraFlags,"namePostfix","")
cloneArgs = {}
fitter=getattr(extraFlags,"Fitter",None)
if fitter is not None:
cloneArgs["Fitter"] = fitter
if "RefitTool" not in kwargs:
if namePrefix or namePostfix:
cloneName = namePrefix+"MuonRefitTool"+namePostfix
kwargs["RefitTool"] = getPublicToolClone(cloneName, "MuonRefitTool", **cloneArgs)
return CfgMgr.Muon__MuonErrorOptimisationTool(name,**kwargs)
def MooTrackFitter(name="MooTrackFitter", extraFlags=None, **kwargs):
namePrefix =getattr(extraFlags,"namePrefix","")
namePostfix=getattr(extraFlags,"namePostfix","")
kwargs.setdefault("Fitter", "MCTBFitter")
kwargs.setdefault("Propagator", "MuonPropagator")
kwargs.setdefault("SLFit" , not jobproperties.BField.allToroidOn())
kwargs.setdefault("ReducedChi2Cut", muonStandaloneFlags.Chi2NDofCut())
kwargs.setdefault("FitEtaStrips", True)
kwargs.setdefault("SegmentMomentum", "MuonSegmentMomentumFromField")
kwargs.setdefault("CleanPhiHits", True)
kwargs.setdefault("UsePreciseHits", True)
kwargs.setdefault("UsePrefit", False)
kwargs.setdefault("SeedAtStartOfTrack", False)
if muonStandaloneFlags.reconstructionMode() == 'cosmics':
kwargs.setdefault("SeedWithAvePhi", True)
kwargs.setdefault("SeedWithSegmentTheta", False)
kwargs.setdefault("Cosmics", True)
kwargs.setdefault("PreCleaningReducedChi2Cut", 5000)
kwargs.setdefault("SegmentMomentum", "MuonSegmentMomentum")
# make instance
fitter = CfgMgr.Muon__MooTrackFitter(name,**kwargs)
# make some clones if needed
if namePrefix or namePostfix:
oldFitterName = getProperty(fitter,"Fitter").getName()
newFitterName = namePrefix + oldFitterName + namePostfix
fitter.Fitter = getPublicToolClone(newFitterName,oldFitterName)
oldFitterName = getProperty(fitter,"FitterPreFit").getName()
newFitterName = namePrefix + oldFitterName + namePostfix
fitter.FitterPreFit = getPublicToolClone(newFitterName,oldFitterName)
return fitter
def MooSegmentFinderNCBAlg( name="MuonSegmentMaker_NCB",**kwargs ):
kwargs.setdefault("SegmentFinder",getPublicToolClone("MooSegmentFinder_NCB","MuonSegmentFinder",
DoSummary=False,
Csc2dSegmentMaker = (getPublicToolClone("Csc2dSegmentMaker_NCB","Csc2dSegmentMaker",
segmentTool = getPublicToolClone("CscSegmentUtilTool_NCB",
"CscSegmentUtilTool",
TightenChi2 = False,
IPconstraint=False)) if MuonGeometryFlags.hasCSC() else ""),
Csc4dSegmentMaker = (getPublicToolClone("Csc4dSegmentMaker_NCB","Csc4dSegmentMaker",
segmentTool = getPublicTool("CscSegmentUtilTool_NCB")) if MuonGeometryFlags.hasCSC() else ""),
DoMdtSegments=False,DoSegmentCombinations=False,DoSegmentCombinationCleaning=False))
kwargs.setdefault("MuonPatternCombinationLocation", "NCB_MuonHoughPatternCombinations")
kwargs.setdefault("MuonSegmentOutputLocation", "NCB_MuonSegments")
kwargs.setdefault("MuonSegmentOutputLocation", "NCB_MuonSegments")
kwargs.setdefault("UseCSC", muonRecFlags.doCSCs())
kwargs.setdefault("UseMDT", False)
kwargs.setdefault("UseRPC", False)
kwargs.setdefault("UseTGC", False)
kwargs.setdefault("UseTGCPriorBC", False)
kwargs.setdefault("UseTGCNextBC", False)
kwargs.setdefault("doTGCClust", False)
kwargs.setdefault("doRPCClust", False)
return CfgMgr.MooSegmentFinderAlg(name,**kwargs)
def MuonCombinedFitTagTool(name="MuonCombinedFitTagTool", **kwargs):
from AthenaCommon.AppMgr import ToolSvc
if TriggerFlags.MuonSlice.doTrigMuonConfig:
from TrkExRungeKuttaIntersector.TrkExRungeKuttaIntersectorConf import Trk__IntersectorWrapper as Propagator
TrigMuonPropagator = Propagator(name='TrigMuonPropagator')
ToolSvc += TrigMuonPropagator
kwargs.setdefault(
"TrackBuilder",
getPublicToolClone("TrigMuonTrackBuilder",
"CombinedMuonTrackBuilder",
Propagator=TrigMuonPropagator))
kwargs.setdefault("VertexContainer", "")
else:
kwargs.setdefault("TrackBuilder",
getPublicTool("CombinedMuonTrackBuilder"))
kwargs.setdefault("TrackQuery", getPublicTool("MuonTrackQuery"))
kwargs.setdefault("MatchQuality", getPublicTool("MuonMatchQuality"))
return CfgMgr.MuonCombined__MuonCombinedFitTagTool(name, **kwargs)
def MooSegmentFinderAlg( name="MuonSegmentMaker",**kwargs ):
kwargs.setdefault("SegmentFinder", getPublicToolClone("MuonSegmentFinder","MooSegmentFinder",
DoSummary=muonStandaloneFlags.printSummary()))
kwargs.setdefault("MuonClusterSegmentFinderTool",getPublicTool("MuonClusterSegmentFinder"))
kwargs.setdefault("MuonSegmentOutputLocation", "MuonSegments")
kwargs.setdefault("UseCSC", muonRecFlags.doCSCs())
kwargs.setdefault("UseMDT", muonRecFlags.doMDTs())
kwargs.setdefault("UseRPC", muonRecFlags.doRPCs())
kwargs.setdefault("UseTGC", muonRecFlags.doTGCs())
if TriggerFlags.MuonSlice.doTrigMuonConfig:
kwargs.setdefault("UseTGCPriorBC", False)
kwargs.setdefault("UseTGCNextBC", False)
else:
kwargs.setdefault("UseTGCPriorBC", muonRecFlags.doTGCs() and muonRecFlags.useTGCPriorNextBC())
kwargs.setdefault("UseTGCNextBC", muonRecFlags.doTGCs() and muonRecFlags.useTGCPriorNextBC())
kwargs.setdefault("doTGCClust", muonRecFlags.doTGCClusterSegmentFinding())
kwargs.setdefault("doRPCClust", muonRecFlags.doRPCClusterSegmentFinding())
return CfgMgr.MooSegmentFinderAlg(name,**kwargs)
def TrigMuSuperEF_FSSA(name="TrigMuSuperEF_FSSA", **kwargs):
kwargs.setdefault("StandaloneOnly", True)
kwargs.setdefault("UseL2Info", False)
kwargs.setdefault("ExtrapolatedTrackParticleContName",
"MuonEFInfo_ExtrapTrackParticles_FullScan")
kwargs.setdefault("MSonlyTrackParticleContName",
"MuonEFInfo_MSonlyTrackParticles_FullScan")
kwargs.setdefault("CBTrackParticleContName",
"MuonEFInfo_CombTrackParticles_FullScan")
kwargs.setdefault("MuonContName", "MuonEFInfo_FullScan")
#Turn off seeded decoding for full scan reconstruction
from AthenaCommon.CfgGetter import getPublicToolClone
kwargs.setdefault(
"TMEF_standaloneTrackTool",
getPublicToolClone("TrigMuonEFStandaloneTrackToolFullScan",
"TrigMuonEFStandaloneTrackTool",
useMdtSeededDecoding=False,
useRpcSeededDecoding=False,
useTgcSeededDecoding=False,
useCscSeededDecoding=False))
return TrigMuSuperEF_FSCB(name, **kwargs)
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)
def configure(self,keys=None):
super(MuonStandalone,self).configure(keys)
if not self.isEnabled(): return
from AthenaCommon.BeamFlags import jobproperties
beamFlags = jobproperties.Beam
SegmentLocation = "MuonSegments"
if muonStandaloneFlags.segmentOrigin == 'TruthTracking':
SegmentLocation = "ThirdChainSegments"
# do the following in case of (at least one) NSW
if (MuonGeometryFlags.hasSTGC() and MuonGeometryFlags.hasMM()):
getPublicTool("MuonLayerHoughTool")
self.addAlg( CfgMgr.MuonLayerHoughAlg( "MuonLayerHoughAlg",
PrintSummary = muonStandaloneFlags.printSummary(),
CscPrepDataContainer = ("CSC_Clusters" if MuonGeometryFlags.hasCSC() else ""),
sTgcPrepDataContainer = ("STGC_Measurements" if MuonGeometryFlags.hasSTGC() else ""),
MMPrepDataContainer = ("MM_Measurements" if MuonGeometryFlags.hasMM() else "") ) )
if not muonStandaloneFlags.patternsOnly():
SegmentFinder = getPublicTool("MuonClusterSegmentFinderTool")
Cleaner = getPublicToolClone("MuonTrackCleaner_seg","MuonTrackCleaner")
Cleaner.Extrapolator = getPublicTool("MuonStraightLineExtrapolator")
Cleaner.Fitter = getPublicTool("MCTBSLFitterMaterialFromTrack")
Cleaner.PullCut = 3
Cleaner.PullCutPhi = 3
Cleaner.UseSLFit = True
SegmentFinder.TrackCleaner = Cleaner
# for test purposes allow parallel running of truth segment finding and new segment finder
MuonSegmentFinderAlg = CfgMgr.MuonSegmentFinderAlg( "MuonSegmentMaker",SegmentCollectionName=SegmentLocation,
MuonPatternCalibration = getPublicTool("MuonPatternCalibration"),
MuonPatternSegmentMaker = getPublicTool("MuonPatternSegmentMaker"),
MuonTruthSummaryTool = None,
PrintSummary = muonStandaloneFlags.printSummary() )
# we check whether the layout contains any CSC chamber and if yes, we check that the user also wants to use the CSCs in reconstruction
if MuonGeometryFlags.hasCSC() and muonRecFlags.doCSCs():
getPublicTool("CscSegmentUtilTool")
getPublicTool("Csc2dSegmentMaker")
getPublicTool("Csc4dSegmentMaker")
else:
MuonSegmentFinderAlg.Csc2dSegmentMaker = ""
MuonSegmentFinderAlg.Csc4dSegmentMaker = ""
self.addAlg( MuonSegmentFinderAlg )
else:
getPublicTool("MuonLayerHoughTool")
self.addAlg(MooSegmentFinderAlg("MuonSegmentMaker"))
self.addAlg(MooSegmentFinderNCBAlg("MuonSegmentMaker_NCB"))
if (not cfgKeyStore.isInInput ('xAOD::MuonSegmentContainer', 'MuonSegments_NCB')):
self.addAlg( CfgMgr.xAODMaker__MuonSegmentCnvAlg("MuonSegmentCnvAlg_NCB",SegmentContainerName="NCB_MuonSegments",xAODContainerName="NCB_MuonSegments") )
if (not cfgKeyStore.isInInput ('xAOD::MuonSegmentContainer', 'MuonSegments')):
self.addAlg( CfgMgr.xAODMaker__MuonSegmentCnvAlg("MuonSegmentCnvAlg") )
if muonStandaloneFlags.doSegmentsOnly():
return
# Tracks builder
#
# add the algorithm (which uses the MuonTrackSteering)
#
TrackBuilder = CfgMgr.MuPatTrackBuilder("MuPatTrackBuilder", TrackSteering = getPublicTool("MuonTrackSteering") )
self.addAlg( TrackBuilder )
self.registerOutputKey("MuonSpectrometerTracks", self.MuPatTrackBuilder, "SpectrometerTrackOutputLocation")
self.registerInputKey ("MuonSegments", self.MuPatTrackBuilder, "MuonSegmentCollection" )
if muonStandaloneFlags.createTrackParticles():
xAODTrackParticleCnvAlg = MuonStandaloneTrackParticleCnvAlg("MuonStandaloneTrackParticleCnvAlg")
self.addAlg( xAODTrackParticleCnvAlg )
def __init__(self, name="TrigMuSuperEF", **kwargs):
kwargs.setdefault("doInsideOut", True)
kwargs.setdefault("doOutsideIn", True)
kwargs.setdefault("insideOutFirst", False)
kwargs.setdefault("fullScan", False)
kwargs.setdefault("StandaloneOnly", False)
kwargs.setdefault("CombinerOnly", False)
kwargs.setdefault("CaloTagOnly", False)
kwargs.setdefault("TMEF_standaloneTrackTool",
"TrigMuonEFStandaloneTrackTool")
kwargs.setdefault("MuonCombinedTool", "TMEF_MuonCombinedTool")
kwargs.setdefault("TrkToTrackParticleConvTool",
"TMEF_TrkToTrackParticleConvTool")
kwargs.setdefault("MuonCreatorTool", "TMEF_MuonCreatorTool")
kwargs.setdefault("deltaEtaRoI", 0.2)
kwargs.setdefault("deltaPhiRoI", 0.2)
kwargs.setdefault("UseL2Info", False)
kwargs.setdefault("DoCache", True)
from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
from TrackToCalo.TrackToCaloConf import Trk__ParticleCaloExtensionTool
from MuonTGRecTools.MuonTGRecToolsConf import Muon__MuonSystemExtensionTool
pcExtensionTool = Trk__ParticleCaloExtensionTool(
Extrapolator=AtlasExtrapolator())
muonExtTool = Muon__MuonSystemExtensionTool(
Extrapolator=AtlasExtrapolator(),
ParticleCaloExtensionTool=pcExtensionTool)
kwargs.setdefault("MuonSystemExtensionTool", muonExtTool)
doTrigMuonEF = kwargs["doOutsideIn"]
doTrigMuGirl = kwargs["doInsideOut"]
doStandaloneOnly = kwargs["StandaloneOnly"]
combinerOnly = kwargs["CombinerOnly"]
# turn on seeded data decoding by default
TriggerFlags.MuonSlice.doEFRoIDrivenAccess = True
# make instance
super(TrigMuSuperEFConfig, self).__init__(name, **kwargs)
# setup monitoring depending on configuration
monTools = []
# top level histograms use Combined Muons
if not doStandaloneOnly:
monTools.append(TrigMuSuperEFMonitoring())
monTools.append(TrigMuSuperEFValidationMonitoring())
# only add TrigMuonEF monitoring if it is run
if doTrigMuonEF:
if not combinerOnly:
monTools.append(TrigMuonEFStandaloneToolMonitoring())
monTools.append(TrigMuonEFStandaloneToolValidationMonitoring())
if not doStandaloneOnly:
monTools.append(TrigMuonEFCombinerToolMonitoring())
monTools.append(TrigMuonEFCombinerToolValidationMonitoring())
from AthenaCommon.CfgGetter import getPublicTool, getPublicToolClone
self.StauCreatorTool = getPublicToolClone("TMEF_StauCreatorTool",
"TMEF_MuonCreatorTool",
BuildStauContainer=True)
# only add TrigMuGirl monitoring if it is run
if doTrigMuGirl:
self.MuGirlTool = getPublicTool("TMEF_MuonInsideOutRecoTool")
if self.UseL2Info:
self.TMEF_standaloneTrackTool.useL2Hits = True
else:
self.TMEF_standaloneTrackTool.useL2Hits = False
# always add timing monitoring
timetool = TrigTimeHistToolConfig("Time")
timetool.NumberOfHistBins = 100
timetool.TimerHistLimits = [0, 1000]
monTools.append(timetool)
self.AthenaMonTools = monTools
def __init__(self, name="TrigMuSuperEF", **kwargs):
kwargs.setdefault("doInsideOut", True)
kwargs.setdefault("doOutsideIn", True)
kwargs.setdefault("insideOutFirst", False)
kwargs.setdefault("fullScan", False)
kwargs.setdefault("StandaloneOnly", False)
kwargs.setdefault("CombinerOnly", False)
kwargs.setdefault("CaloTagOnly", False)
kwargs.setdefault("TMEF_standaloneTrackTool",
"TrigMuonEFStandaloneTrackTool")
kwargs.setdefault("MuonCombinedTool", "TMEF_MuonCombinedTool")
kwargs.setdefault("TrkToTrackParticleConvTool",
"TMEF_TrkToTrackParticleConvTool")
kwargs.setdefault("MuonCreatorTool", "TMEF_MuonCreatorTool")
kwargs.setdefault("deltaEtaRoI", 0.2)
kwargs.setdefault("deltaPhiRoI", 0.2)
kwargs.setdefault("UseL2Info", False)
kwargs.setdefault("DoCache", True)
doTrigMuonEF = kwargs["doOutsideIn"]
doTrigMuGirl = kwargs["doInsideOut"]
doStandaloneOnly = kwargs["StandaloneOnly"]
doFullScan = kwargs["fullScan"]
doCaloTagOnly = kwargs["CaloTagOnly"]
combinerOnly = kwargs["CombinerOnly"]
doCosmics = jobproperties.Beam.beamType == 'cosmics'
# turn on seeded data decoding by default
TriggerFlags.MuonSlice.doEFRoIDrivenAccess = True
# make instance
super(TrigMuSuperEFConfig, self).__init__(name, **kwargs)
# setup monitoring depending on configuration
monTools = []
# top level histograms use Combined Muons
if not doStandaloneOnly:
monTools.append(TrigMuSuperEFMonitoring())
monTools.append(TrigMuSuperEFValidationMonitoring())
# only add TrigMuonEF monitoring if it is run
if doTrigMuonEF:
if not combinerOnly:
monTools.append(TrigMuonEFStandaloneToolMonitoring())
monTools.append(TrigMuonEFStandaloneToolValidationMonitoring())
if not doStandaloneOnly:
monTools.append(TrigMuonEFCombinerToolMonitoring())
monTools.append(TrigMuonEFCombinerToolValidationMonitoring())
from AthenaCommon.CfgGetter import getPublicTool, getPublicToolClone
self.StauCreatorTool = getPublicToolClone("TMEF_StauCreatorTool",
"TMEF_MuonCreatorTool",
BuildStauContainer=True)
# only add TrigMuGirl monitoring if it is run
# if doTrigMuGirl:
kwargs.setdefault("MuGirlTool",
getPublicTool("TMEF_MuonInsideOutRecoTool"))
#from TrigMuGirl.TrigMuGirlMonitoring import TrigMuGirlToolMonitoring
#montool = TrigMuGirlToolMonitoring()
#print montool
#monTools.append( montool )
# turn off PrepRawData decoders in MuGirl
if doTrigMuGirl:
from MuGirlCandidate.MuGirlCandidateConf import MuGirlNS__CandidateTool
MuGirlNS__CandidateTool.doDecoding = False
if self.UseL2Info:
self.TMEF_standaloneTrackTool.useL2Hits = True
else:
self.TMEF_standaloneTrackTool.useL2Hits = False
# always add timing monitoring
timetool = TrigTimeHistToolConfig("Time")
timetool.NumberOfHistBins = 100
timetool.TimerHistLimits = [0, 1000]
monTools.append(timetool)
self.AthenaMonTools = monTools
def configure(self,keys=None):
super(MuonStandalone,self).configure(keys)
if not self.isEnabled(): return
print " configuring MuonStandalone: flags ", muonStandaloneFlags
from AthenaCommon.BeamFlags import jobproperties
beamFlags = jobproperties.Beam
SegmentLocation = "MuonSegments"
if muonStandaloneFlags.segmentOrigin == 'TruthTracking':
SegmentLocation = "ThirdChainSegments"
if muonRecFlags.doNSWNewThirdChain():
getPublicTool("MuonLayerHoughTool")
self.addAlg( CfgMgr.MuonLayerHoughAlg( "MuonLayerHoughAlg", PrintSummary = muonStandaloneFlags.printSummary() ) )
if not muonStandaloneFlags.patternsOnly():
SegmentFinder = getPublicTool("MuonClusterSegmentFinderTool")
Cleaner = getPublicToolClone("MuonTrackCleaner_seg","MuonTrackCleaner")
Cleaner.PullCut = 3
Cleaner.PullCutPhi = 3
SegmentFinder.TrackCleaner = Cleaner
# for test purposes allow parallel running of truth segment finding and new segment finder
MuonSegmentFinderAlg = CfgMgr.MuonSegmentFinderAlg( "MuonSegmentMaker",SegmentCollectionName=SegmentLocation,
MuonPatternCalibration = getPublicTool("MuonPatternCalibration"),
MuonPatternSegmentMaker = getPublicTool("MuonPatternSegmentMaker"),
MuonTruthSummaryTool = None,
PrintSummary = muonStandaloneFlags.printSummary() )
if( muonRecFlags.doCSCs() ):
getPublicTool("CscSegmentUtilTool")
getPublicTool("Csc2dSegmentMaker")
getPublicTool("Csc4dSegmentMaker")
else:
MuonSegmentFinderAlg.Csc2dSegmentMaker = None
MuonSegmentFinderAlg.Csc4dSegmentMaker = None
self.addAlg( MuonSegmentFinderAlg )
else:
getPublicTool("MuonLayerHoughTool")
self.addAlg( CfgMgr.MooSegmentFinderAlg( "MuonSegmentMaker",
SegmentFinder = getPublicToolClone("MuonSegmentFinder","MooSegmentFinder",
DoSummary=muonStandaloneFlags.printSummary()),
MuonSegmentOutputLocation = SegmentLocation,
UseCSC = muonRecFlags.doCSCs(),
UseMDT = muonRecFlags.doMDTs(),
UseRPC = muonRecFlags.doRPCs(),
UseTGC = muonRecFlags.doTGCs(),
UseTGCPriorBC = muonRecFlags.doTGCs() and muonRecFlags.useTGCPriorNextBC(),
UseTGCNextBC = muonRecFlags.doTGCs() and muonRecFlags.useTGCPriorNextBC(),
doTGCClust = muonRecFlags.doTGCClusterSegmentFinding(),
doRPCClust = muonRecFlags.doRPCClusterSegmentFinding() ))
self.addAlg( CfgMgr.MooSegmentFinderAlg( "MuonSegmentMaker_NCB",
SegmentFinder = getPublicToolClone("MooSegmentFinder_NCB","MuonSegmentFinder",
DoSummary=False,
Csc2dSegmentMaker = getPublicToolClone("Csc2dSegmentMaker_NCB","Csc2dSegmentMaker",
segmentTool = getPublicToolClone("CscSegmentUtilTool_NCB",
"CscSegmentUtilTool",
TightenChi2 = False,
IPconstraint=False)),
Csc4dSegmentMaker = getPublicToolClone("Csc4dSegmentMaker_NCB","Csc4dSegmentMaker",
segmentTool = getPublicTool("CscSegmentUtilTool_NCB")),
DoMdtSegments=False,DoSegmentCombinations=False,DoSegmentCombinationCleaning=False),
MuonPatternCombinationLocation = "NCB_MuonHoughPatternCombinations",
MuonSegmentOutputLocation = "NCB_MuonSegments",
MuonSegmentCombinationOutputLocation = "NCB_MooreSegmentCombinations",
UseCSC = muonRecFlags.doCSCs(),
UseMDT = False,
UseRPC = False,
UseTGC = False,
UseTGCPriorBC = False,
UseTGCNextBC = False,
doTGCClust = False,
doRPCClust = False) )
self.addAlg( CfgMgr.xAODMaker__MuonSegmentCnvAlg("MuonSegmentCnvAlg") )
self.addAlg( CfgMgr.xAODMaker__MuonSegmentCnvAlg("MuonSegmentCnvAlg_NCB",SegmentContainerName="NCB_MuonSegments",xAODContainerName="NCB_MuonSegments") )
if muonStandaloneFlags.doSegmentsOnly():
return
# Tracks builder
#
# add the algorithm (which uses the MuonTrackSteering)
#
TrackBuilder = CfgMgr.MuPatTrackBuilder("MuPatTrackBuilder", TrackSteering = getPublicTool("MuonTrackSteering") )
self.addAlg( TrackBuilder )
self.registerOutputKey("MuonSpectrometerTracks", self.MuPatTrackBuilder, "SpectrometerTrackOutputLocation")
self.registerInputKey ("MuonSegments", self.MuPatTrackBuilder, "MuonSegmentCollection" )
if muonStandaloneFlags.createTrackParticles() and DetFlags.ID_on():
from xAODTrackingCnv.xAODTrackingCnvConf import xAODMaker__TrackParticleCnvAlg
xAODTrackParticleCnvAlg = xAODMaker__TrackParticleCnvAlg( name = "MuonStandaloneTrackParticleCnvAlg",
TrackParticleCreator = getPublicTool("MuonParticleCreatorTool"),
TrackContainerName = "MuonSpectrometerTracks",
xAODTrackParticlesFromTracksContainerName = "MuonSpectrometerTrackParticles",
ConvertTrackParticles = False,
ConvertTracks = True )
self.addAlg( xAODTrackParticleCnvAlg )
