def getFatrasParticleDecayHelper(name="ISF_FatrasParticleDecayHelper", **kwargs):
from G4AtlasApps.SimFlags import simFlags
if not simFlags.RandomSeedList.checkForExistingSeed( "FatrasG4" ):
simFlags.RandomSeedList.addSeed( "FatrasG4" , 23491234, 23470291 )
kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() )
kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName())
kwargs.setdefault("G4RandomStreamName" , "FatrasG4") # TODO: read stream name "FatrasG4" from Fatras jobProperties
kwargs.setdefault("ParticleBroker" , getService('ISF_ParticleBrokerSvc'))
kwargs.setdefault("ParticleTruthSvc", simFlags.TruthStrategy.TruthServiceName())
kwargs.setdefault("PDGToG4ParticleConverter", getPublicTool('ISF_FatrasPdgG4Particle'))
# the validation output
kwargs.setdefault("ValidationMode" , ISF_Flags.ValidationMode())
kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool'))
#kwargs.setdefault("G4RunManagerHelper" , getPublicTool('ISF_G4RunManagerHelper'))
from ISF_FatrasToolsG4.ISF_FatrasToolsG4Conf import iFatras__G4ParticleDecayHelper
return iFatras__G4ParticleDecayHelper(name, **kwargs )
def MuonCaloParticleCreator(name="MuonCaloParticleCreator", **kwargs):
import MuonCombinedRecExample.CombinedMuonTrackSummary
kwargs.setdefault("Extrapolator", getPublicTool("AtlasExtrapolator"))
kwargs.setdefault("TrackSummaryTool", ToolSvc.CombinedMuonTrackSummary
) #getPublicTool("CombinedMuonTrackSummary") )
kwargs.setdefault("KeepAllPerigee", True)
kwargs.setdefault("PerigeeExpression", "Origin")
return CfgMgr.Trk__TrackParticleCreatorTool(name, **kwargs)
def getFatrasStaticPropagator(name="ISF_FatrasStaticPropagator", **kwargs):
kwargs.setdefault("Propagator", getPublicTool('ISF_FatrasPropagator'))
# configure output formatting
kwargs.setdefault("OutputPrefix", '[SP] - ')
kwargs.setdefault("OutputPostfix", ' - ')
kwargs.setdefault("OutputLevel", ISF_FatrasFlags.OutputLevelGeneral())
from TrkExEngine.TrkExEngineConf import Trk__PropagationEngine as StaticPropagator
return StaticPropagator(name, **kwargs)
def MCTBSLFitterMaterialFromTrack(name="MCTBSLFitterMaterialFromTrack",
**kwargs):
kwargs["GetMaterialFromTrack"] = True
kwargs.setdefault("ExtrapolationTool",
"Trk::Extrapolator/MuonStraightLineExtrapolator")
#kwargs.setdefault("PropagatorTool", "Trk::STEP_Propagator/MuonStraightLinePropagator") #will switch to this once it's ready
kwargs["PropagatorTool"] = getPublicTool("MuonRK_Propagator")
return MCTBSLFitter(name, **kwargs)
def MuonCombinedInDetCandidateAlg(name="MuonCombinedInDetCandidateAlg",
**kwargs):
from InDetRecExample.InDetJobProperties import InDetFlags
kwargs.setdefault(
"TrackSelector",
getPublicTool("MuonCombinedInDetDetailedTrackSelectorTool"))
if muonCombinedRecFlags.doSiAssocForwardMuons(
) and InDetFlags.doForwardTracks():
kwargs.setdefault("DoSiliconAssocForwardMuons", True)
kwargs.setdefault(
"InDetForwardTrackSelector",
getPublicTool("MuonCombinedInDetDetailedForwardTrackSelectorTool"))
kwargs.setdefault("MuonSystemExtensionTool",
getPublicTool("MuonSystemExtensionTool"))
return CfgMgr.MuonCombinedInDetCandidateAlg(name, **kwargs)
def TrigMuSuperEF_MuonCaloTagTool(name='OnlineMuonCaloTagTool', **kwargs):
#from AthenaCommon.AppMgr import ToolSvc
#import TrigMuSuperEF.CombinedMuonTrackSummary_Trig
kwargs.setdefault("CaloMuonTagLoose", getPublicTool("CaloMuonTagLoose"))
kwargs.setdefault("CaloMuonTagTight", getPublicTool("CaloMuonTag"))
kwargs.setdefault("CaloMuonLikelihoodTool",
getPublicTool("CaloMuonLikelihoodTool"))
kwargs.setdefault("TrackDepositInCaloTool",
getPublicTool("TrigMuSuperEF_TrackDepositInCaloTool"))
kwargs.setdefault("TrackSelectorTool",
getPublicTool("TrigMuSuperEF_CaloTrkSelectorTool"))
kwargs.setdefault("TrackIsolationTool", None)
kwargs.setdefault("DebugMode", False)
kwargs.setdefault("doTrkSelection", True)
kwargs.setdefault("doCaloLR", False)
kwargs.setdefault("doOldExtrapolation", True)
kwargs.setdefault("ShowTruth", False)
return CfgMgr.MuonCombined__MuonCaloTagTool(name, **kwargs)
def MuonChi2TrackFitter(name='MuonChi2TrackFitter',**kwargs):
from TrkGlobalChi2Fitter.TrkGlobalChi2FitterConf import Trk__GlobalChi2Fitter
kwargs.setdefault("ExtrapolationTool" , "MuonExtrapolator")
kwargs.setdefault("RotCreatorTool" , "MuonRotCreator")
kwargs.setdefault("MeasurementUpdateTool", "MuonMeasUpdator")
kwargs.setdefault("StraightLine" , False)
kwargs.setdefault("OutlierCut" , 3.0)
kwargs.setdefault("GetMaterialFromTrack" , False)
kwargs.setdefault("RejectLargeNScat" , True)
# take propagator and navigator from the extrapolator
Extrapolator = getPublicTool(kwargs["ExtrapolationTool"])
kwargs["ExtrapolationTool"] = Extrapolator
kwargs["PropagatorTool"] = getPublicTool(Extrapolator.Propagators[0].getName())
kwargs["NavigatorTool"] = getPublicTool(Extrapolator.Navigator.getName())
return Trk__GlobalChi2Fitter(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 ExtrapolateMuonToIPTool(name="ExtrapolateMuonToIPTool", **kwargs):
if TriggerFlags.MuonSlice.doTrigMuonConfig:
kwargs.setdefault("TrackSummaryTool",
getPublicTool("MuonTrackSummaryTool"))
else:
import MuonCombinedRecExample.CombinedMuonTrackSummary
from AthenaCommon.AppMgr import ToolSvc
kwargs.setdefault("TrackSummaryTool", ToolSvc.CombinedMuonTrackSummary)
return CfgMgr.ExtrapolateMuonToIPTool(name, **kwargs)
def StauCreatorAlg( name="StauCreatorAlg", **kwargs ):
kwargs.setdefault("MuonCreatorTool",getPublicTool("StauCreatorTool"))
kwargs.setdefault("MuonContainerLocation","Staus")
kwargs.setdefault("CombinedLocation","CombinedStau")
kwargs.setdefault("ExtrapolatedLocation","ExtrapolatedStau")
kwargs.setdefault("MSOnlyExtrapolatedLocation","MSOnlyExtrapolatedStau")
kwargs.setdefault("MuonCandidateLocation","")
kwargs.setdefault("SegmentContainerName","StauSegments")
kwargs.setdefault("BuildSlowMuon",1)
return MuonCreatorAlg(name,**kwargs)
def getCaloEntryTrkExtrapolator(name="ISF_CaloEntryTrkExtrapolator", **kwargs):
kwargs.setdefault('TrackingVolumeName', 'InDet::Containers::EntryVolume')
kwargs.setdefault('TrackingGeometrySvc',
getService('AtlasTrackingGeometrySvc'))
atlasExtrapolator = getPublicTool('AtlasExtrapolator')
atlasExtrapolator.ApplyMaterialEffects = False
kwargs.setdefault('Extrapolator', atlasExtrapolator)
from ISF_TrackingTools.ISF_TrackingToolsConf import ISF__TrkExtrapolator
return ISF__TrkExtrapolator(name, **kwargs)
def MuonInsideOutRecoAlg(name="MuonInsideOutRecoAlg", **kwargs):
tools = [getPublicTool("MuonInsideOutRecoTool")]
from MuonLayerSegmentMakerTools.MuonLayerSegmentMakerToolsConf import Muon__MuonLayerSegmentFinderTool
from AthenaCommon.AppMgr import ToolSvc
MuonLayerSegmentFinderTool = Muon__MuonLayerSegmentFinderTool(
"MuonLayerSegmentFinderTool",
Csc2DSegmentMaker=(getPublicTool("Csc2dSegmentMaker")
if MuonGeometryFlags.hasCSC() else ""),
Csc4DSegmentMaker=(getPublicTool("Csc4dSegmentMaker")
if MuonGeometryFlags.hasCSC() else ""))
ToolSvc += MuonLayerSegmentFinderTool
tools[0].MuonLayerSegmentFinderTool = MuonLayerSegmentFinderTool
kwargs.setdefault("MuonCombinedInDetExtensionTools", tools)
kwargs.setdefault("usePRDs", True)
kwargs.setdefault("HasCSC", MuonGeometryFlags.hasCSC())
kwargs.setdefault("HasSTgc", MuonGeometryFlags.hasSTGC())
kwargs.setdefault("HasMM", MuonGeometryFlags.hasMM())
kwargs.setdefault("TagMap", "muGirlTagMap")
return CfgMgr.MuonCombinedInDetExtensionAlg(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 CaloMuonScoreTool(name='CaloMuonScoreTool', **kwargs):
from TrackToCalo.TrackToCaloConf import Rec__ParticleCaloCellAssociationTool
caloCellAssociationTool = Rec__ParticleCaloCellAssociationTool(
ParticleCaloExtensionTool=getPublicTool(
"MuonParticleCaloExtensionTool"))
kwargs.setdefault("ParticleCaloCellAssociationTool",
caloCellAssociationTool)
kwargs.setdefault("CaloMuonScoreONNXRuntimeSvc",
getService("CaloMuonScoreONNXRuntimeSvc"))
return CfgMgr.CaloMuonScoreTool(name, **kwargs)
def getParametricSimServiceID(name="ISF_ParametricSimSvc", **kwargs):
kwargs.setdefault("Identifier", "ParametricSim")
kwargs.setdefault("OutputLevel", ISF_ParSimFlags.OutputLevelGeneral())
kwargs.setdefault("ParticleSmearers",
[getPublicTool('ISF_TrackParticleSmearer')])
kwargs.setdefault("TrackingGeometrySvc",
getService("AtlasTrackingGeometrySvc"))
from ISF_ParSimServices.ISF_ParSimServicesConf import iParSim__ParametricSimSvc
return iParSim__ParametricSimSvc(name, **kwargs)
def MuonCreatorTool(name="MuonCreatorTool", **kwargs):
getPublicTool("MuonMomentumBalanceSignificanceTool")
getPublicTool("MuonScatteringAngleSignificanceTool")
getPublicTool("MuonCaloParticleCreator")
kwargs.setdefault("TrackParticleCreator",
getPublicTool("MuonCombinedParticleCreator"))
# kwargs.setdefault("CaloNoiseTool", getPublicTool("CaloNoiseToolDefault") )
return CfgMgr.MuonCombined__MuonCreatorTool(name, **kwargs)
def getFastHitConvAlgFastCaloSimSvc(name="ISF_FastHitConvAlgFastCaloSimSvc",**kwargs):
kwargs.setdefault("CaloCellMakerTools_release", [
#getPublicTool('ISF_AddNoiseCellBuilderTool'),
getPublicTool('ISF_CaloCellContainerFinalizerTool')
] )
# setup FastCaloSim hit converter and add it to the alg sequence:
# -> creates HITS from reco cells
from AthenaCommon.AlgSequence import AlgSequence
topSequence=AlgSequence()
topSequence+=getAlgorithm('ISF_FastHitConvAlg')
return getNativeFastCaloSimSvc(name,**kwargs)
def MuGirlStauAlg(name="MuGirlStauAlg", **kwargs):
tools = [getPublicTool("MuonStauRecoTool")]
kwargs.setdefault("MuonCombinedInDetExtensionTools", tools)
kwargs.setdefault("TagMap", "stauTagMap")
kwargs.setdefault("HasCSC", MuonGeometryFlags.hasCSC())
kwargs.setdefault("HasSTgc", MuonGeometryFlags.hasSTGC())
kwargs.setdefault("HasMM", MuonGeometryFlags.hasMM())
kwargs.setdefault("CombinedTrackCollection", "MuGirlStauCombinedTracks")
kwargs.setdefault("METrackCollection", "")
kwargs.setdefault("SegmentCollection", "MuGirlStauSegments")
return CfgMgr.MuonCombinedInDetExtensionAlg(name, **kwargs)
def MuidCaloEnergyTool( name='MuidCaloEnergyTool', **kwargs ):
kwargs.setdefault("CaloMeasTool", getPublicTool("MuidCaloEnergyMeas") )
kwargs.setdefault("CaloParamTool", getPublicTool("MuidCaloEnergyParam") )
if DetFlags.haveRIO.Calo_on():
kwargs.setdefault("EnergyLossMeasurement", True )
kwargs.setdefault("MinFinalEnergy", 1.0*GeV )
kwargs.setdefault("MinMuonPt", 10.0*GeV )
kwargs.setdefault("MopParametrization", True )
else:
kwargs.setdefault("EnergyLossMeasurement", False )
if DetFlags.haveRIO.ID_on():
kwargs.setdefault("TrackIsolation", True )
else:
kwargs.setdefault("TrackIsolation", False )
if beamFlags.beamType() == 'cosmics':
kwargs.setdefault("Cosmics", True )
return CfgMgr.Rec__MuidCaloEnergyTool(name,**kwargs)
def getFatrasProcessSamplingTool(name="ISF_FatrasProcessSamplingTool", **kwargs):
# random number service
from G4AtlasApps.SimFlags import simFlags
kwargs.setdefault( "RandomNumberService", simFlags.RandomSvc())
# truth record
kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName())
# decays
kwargs.setdefault("ParticleDecayHelper" , getPublicTool('ISF_FatrasParticleDecayHelper'))
# photon conversion
kwargs.setdefault("PhotonConversionTool" , getPublicTool('ISF_FatrasConversionCreator'))
# hadronic interactions
kwargs.setdefault("HadronicInteraction" , True)
#kwargs.setdefault("HadronicInteractionProcessor", getPublicTool('ISF_FatrasParametricHadIntProcessor'))
kwargs.setdefault("HadronicInteractionProcessor", getPublicTool('ISF_FatrasG4HadIntProcessor'))
# the validation output
kwargs.setdefault("ValidationMode" , ISF_Flags.ValidationMode())
kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool'))
from ISF_FatrasTools.ISF_FatrasToolsConf import iFatras__ProcessSamplingTool
return iFatras__ProcessSamplingTool(name, **kwargs)
def MuonChamberHoleRecoveryTool(name="MuonChamberHoleRecoveryTool",extraFlags=None,**kwargs):
doSegmentT0Fit = getattr(extraFlags,"doSegmentT0Fit", muonRecFlags.doSegmentT0Fit())
kwargs.setdefault("Extrapolator", "MuonExtrapolator")
if doSegmentT0Fit:
kwargs.setdefault("AddMeasurements", False)
if muonRecFlags.doCSCs:
if muonRecFlags.enableErrorTuning() or globalflags.DataSource() == 'data':
kwargs.setdefault("CscRotCreator","CscBroadClusterOnTrackCreator")
else:
kwargs.setdefault("CscRotCreator","CscClusterOnTrackCreator")
else: # no CSCs
# switch off whatever is set
kwargs["CscRotCreator"] = None
# add in missing C++ dependency. TODO: fix in C++
getPublicTool("ResidualPullCalculator")
return CfgMgr.Muon__MuonChamberHoleRecoveryTool(name,**kwargs)
def getFatrasG4HadIntProcessor(name="ISF_FatrasG4HadIntProcessor", **kwargs):
from G4AtlasApps.SimFlags import simFlags
kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() )
kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName())
kwargs.setdefault("ParticleBroker" , ISF_Flags.ParticleBroker())
kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName())
kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool'))
kwargs.setdefault('ValidationMode' , ISF_Flags.ValidationMode())
kwargs.setdefault("MomentumCut" , FatrasTuningFlags.MomCutOffSec())
from ISF_FatrasToolsG4.ISF_FatrasToolsG4Conf import iFatras__G4HadIntProcessor
return iFatras__G4HadIntProcessor(name, **kwargs )
def MuonCombinedAlg(name="MuonCombinedAlg", **kwargs):
kwargs.setdefault("MuonCombinedTool", getPublicTool("MuonCombinedTool"))
tagmaps = []
# CombinedTagMaps must be in a 1-1 correspondence
# with MuonCombinedTagTools.
for h in kwargs['MuonCombinedTool'].MuonCombinedTagTools:
if h.getFullName().find('FitTagTool') >= 0:
tagmaps.append('muidcoTagMap')
elif h.getFullName().find('StacoTagTool') >= 0:
tagmaps.append('stacoTagMap')
kwargs.setdefault("CombinedTagMaps", tagmaps)
return CfgMgr.MuonCombinedAlg(name, **kwargs)
def getFatrasMaterialEffectsEngine(name="ISF_FatrasMaterialEffectsEngine", **kwargs):
from G4AtlasApps.SimFlags import simFlags
kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() )
kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName())
kwargs.setdefault("ParticleBroker" , ISF_Flags.ParticleBroker())
kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName())
kwargs.setdefault("ProcessSamplingTool" , getPublicTool('ISF_FatrasProcessSamplingTool'))
kwargs.setdefault("ParticleDecayHelper" , getPublicTool('ISF_FatrasParticleDecayHelper'))
# energy loss
kwargs.setdefault("EnergyLoss" , True)
kwargs.setdefault("EnergyLossSampler" , getPublicTool('ISF_FatrasEnergyLossUpdator'))
kwargs.setdefault("UseElectronSampler" , True)
kwargs.setdefault("ElectronEnergyLossSampler" , getPublicTool('ISF_FatrasEnergyLossSamplerBetheHeitler'))
kwargs.setdefault("CreateBremPhotons" , True)
# multiple scattering
kwargs.setdefault("MultipleScattering" , True)
kwargs.setdefault("MultipleScatteringSampler" , getPublicTool('ISF_FatrasMultipleScatteringSamplerHighland'))
# the properties given throuth the JobProperties interface
kwargs.setdefault("MomentumCut" , FatrasTuningFlags.MomCutOffSec())
kwargs.setdefault("MinimumBremPhotonMomentum" , FatrasTuningFlags.MomCutOffSec())
# MCTruth Process Code
kwargs.setdefault("BremProcessCode" , 3) # TODO: to be taken from central definition
# the validation output
kwargs.setdefault("ValidationMode" , ISF_Flags.ValidationMode())
kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool'))
kwargs.setdefault("OutputPrefix", '[McME] - ')
kwargs.setdefault("OutputPostfix", ' - ')
kwargs.setdefault("OutputLevel", ISF_FatrasFlags.OutputLevelGeneral())
from ISF_FatrasTools.ISF_FatrasToolsConf import iFatras__McMaterialEffectsEngine
return iFatras__McMaterialEffectsEngine(name, **kwargs )
def MuonCreatorAlg(name="MuonCreatorAlg", **kwargs):
kwargs.setdefault("MuonCreatorTool", getPublicTool("MuonCreatorTool"))
recordMuonCreatorAlgObjs(kwargs)
# if muGirl is off, remove "muGirlTagMap" from "TagMaps"
# but don't set this default in case the StauCreatorAlg is created (see below)
if not muonCombinedRecFlags.doMuGirl() and not name == "StauCreatorAlg":
kwargs.setdefault(
"TagMaps",
["muidcoTagMap", "stacoTagMap", "caloTagMap", "segmentTagMap"])
if TriggerFlags.MuonSlice.doTrigMuonConfig:
kwargs.setdefault("MakeClusters", False)
kwargs.setdefault("ClusterContainerName", "")
return CfgMgr.MuonCreatorAlg(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 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 MuonEDMHelperTool(name='MuonEDMHelperTool',**kwargs):
# configure some tools that are used but are not declared as properties (they should be!)
getPublicTool("MuonIdHelperTool")
getPublicTool("MuonExtrapolator")
getPublicTool("AtlasExtrapolator")
from MuonRecHelperTools.MuonRecHelperToolsConf import Muon__MuonEDMHelperTool
return Muon__MuonEDMHelperTool(name,**kwargs)
def getFatrasConversionCreator(name="ISF_FatrasConversionCreator", **kwargs):
# Fatras Hadronic Interaction Processor
# hadronic interaction creator
from G4AtlasApps.SimFlags import simFlags
kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() )
kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName())
kwargs.setdefault("ParticleBroker" , ISF_Flags.ParticleBroker())
kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName())
kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool'))
kwargs.setdefault("PhysicsProcessCode" , 14) # TODO: to be taken from central definition
kwargs.setdefault('ValidationMode' , ISF_Flags.ValidationMode())
from ISF_FatrasTools.ISF_FatrasToolsConf import iFatras__PhotonConversionTool
return iFatras__PhotonConversionTool(name, **kwargs )
def CaloTrkMuIdAlgTrackSelectorTool(name='CaloTrkMuIdAlgTrackSelectorTool',
**kwargs):
from AthenaCommon.AppMgr import ToolSvc
kwargs.setdefault("pTMin", 5000.)
kwargs.setdefault("IPd0Max", 7.)
kwargs.setdefault("IPz0Max", 130) # 130 (tuned on Z)
kwargs.setdefault("nHitBLayer", 0)
kwargs.setdefault("nHitPix", 1)
kwargs.setdefault("nHitSct", 5)
kwargs.setdefault("nHitSi", 7)
kwargs.setdefault("nHitTrt", 0)
kwargs.setdefault("TrackSummaryTool", ToolSvc.CombinedMuonTrackSummary)
kwargs.setdefault("Extrapolator", getPublicTool("AtlasExtrapolator"))
return CfgMgr.InDet__InDetDetailedTrackSelectorTool(name, **kwargs)
include("RecExCond/AllDet_detDescr.py")
# Fetch the AthAlgSeq, i.e., one of the existing master sequences where one should attach all algorithms
algSeq = CfgMgr.AthSequencer("AthAlgSeq")
alg = CfgMgr.BaseAnalysis("SegmentAnalysis", OutputLevel=INFO);
ServiceMgr.MessageSvc.defaultLimit = 9999999
algSeq += alg
import time
svcMgr += CfgMgr.THistSvc()
svcMgr.THistSvc.Output += ["ANOTHERSTREAM DATAFILE='ntuple.%s.Run%s.root' OPT='RECREATE'" % (time.strftime('%Y-%m-%d-%Hh%Mm%Ss'),
muonrawhits_run,
)]
from LumiBlockComps.LuminosityToolDefault import LuminosityToolDefault
theLumiTool = LuminosityToolDefault()
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += theLumiTool
from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter
cfg = TriggerConfigGetter('ReadPool')
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
tdt = Trig__TrigDecisionTool("TrigDecisionTool")
ToolSvc += tdt
from AthenaCommon.CfgGetter import getPublicTool,getPublicToolClone
CalibCscStripFitter = getPublicTool("CalibCscStripFitter")
ToolSvc += CalibCscStripFitter
# functionality : Muon combined reconstruction
#
pdr.flag_domain('muoncomb')
if rec.doMuonCombined() and DetFlags.Muon_on() and DetFlags.ID_on():
try:
include ("MuonCombinedRecExample/MuonCombinedRec_config.py")
except Exception:
treatException("Could not set up combined muon reconstruction. Switched off !")
rec.doMuonCombined = False
#
# functionality : add cells crossed by high pt ID tracks
#
if rec.doESD() and recAlgs.doTrackParticleCellAssociation():
from AthenaCommon.CfgGetter import getPublicTool
getPublicTool("MuonCombinedInDetDetailedTrackSelectorTool")
topSequence += CfgMgr.TrackParticleCellAssociationAlg("TrackParticleCellAssociationAlg")
#
# functionality : energy flow
#
pdr.flag_domain('eflow')
if recAlgs.doEFlow() and ( rec.readESD() or ( DetFlags.haveRIO.ID_on() and DetFlags.haveRIO.Calo_allOn() ) ) :
try:
include( "eflowRec/eflowRec_jobOptions.py" )
except Exception:
treatException("Could not set up EFlow. Switched off !")
recAlgs.doEFlow=False
else:
recAlgs.doEFlow=False
