def InDetMeasRecalibST(name='InDetMeasRecalibST', **kwargs): from TrkKalmanFitter.TrkKalmanFitterConf import Trk__MeasRecalibSteeringTool split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension', '') from InDetRecExample import TrackingCommon as TrackingCommon if 'BroadPixelClusterOnTrackTool' not in kwargs: kwargs = setDefaults( kwargs, BroadPixelClusterOnTrackTool=TrackingCommon. getInDetBroadPixelClusterOnTrackTool( nameSuffix=split_cluster_map_extension, SplitClusterMapExtension=split_cluster_map_extension)) if 'BroadSCT_ClusterOnTrackTool' not in kwargs: kwargs = setDefaults(kwargs, BroadSCT_ClusterOnTrackTool=TrackingCommon. getInDetBroadSCT_ClusterOnTrackTool()) if 'CommonRotCreator' not in kwargs: kwargs = setDefaults( kwargs, CommonRotCreator=TrackingCommon.getInDetRefitRotCreator( SplitClusterMapExtension=split_cluster_map_extension)) return Trk__MeasRecalibSteeringTool(name, **kwargs)
def GaussianSumFitter(name='GaussianSumFitter', **kwargs): split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension', '') from InDetRecExample import TrackingCommon as TrackingCommon if 'ToolForROTCreation' not in kwargs: kwargs = setDefaults( kwargs, ToolForROTCreation=TrackingCommon.getInDetRotCreator( nameSuffix=split_cluster_map_extension, SplitClusterMapExtension=split_cluster_map_extension)) if 'ToolForExtrapolation' not in kwargs: kwargs = setDefaults( kwargs, ToolForExtrapolation=TrackingCommon.getInDetGsfExtrapolator()) if 'MeasurementUpdatorType' not in kwargs: kwargs = setDefaults(kwargs, MeasurementUpdatorType=TrackingCommon. getInDetGsfMeasurementUpdator()) from TrkGaussianSumFilter.TrkGaussianSumFilterConf import Trk__GaussianSumFitter return Trk__GaussianSumFitter(name=name, **setDefaults(kwargs, ReintegrateOutliers=False, MakePerigee=True, RefitOnMeasurementBase=True, DoHitSorting=True))
def InDetGlobalChi2FitterLowPt(name='InDetGlobalChi2FitterLowPt', **kwargs): # @TODO TrackingGeometrySvc was not set but is set now # RotCreatorTool and BroadRotCreatorTool not set split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension', '') from InDetRecExample import TrackingCommon as TrackingCommon if 'RotCreatorTool' not in kwargs: kwargs = setDefaults( kwargs, RotCreatorTool=TrackingCommon.getInDetRotCreator( nameSuffix=split_cluster_map_extension, SplitClusterMapExtension=split_cluster_map_extension)) from InDetRecExample.InDetJobProperties import InDetFlags use_broad_cluster_any = InDetFlags.useBroadClusterErrors() and ( not InDetFlags.doDBMstandalone()) if 'BroadRotCreatorTool' not in kwargs and not InDetFlags.doRefit(): kwargs = setDefaults( kwargs, BroadRotCreatorTool=TrackingCommon.getInDetBroadRotCreator( nameSuffix=split_cluster_map_extension, SplitClusterMapExtension=split_cluster_map_extension)) return InDetGlobalChi2FitterBase( name, **setDefaults( kwargs, OutlierCut=5.0, Acceleration=False, # default RecalculateDerivatives=True, TrackChi2PerNDFCut=10))
def getInDetPhysValMonitoringToolTightPrimary(**kwargs): if 'TrackSelectionTool' not in kwargs: from InDetPhysValMonitoring.TrackSelectionTool import getInDetTrackSelectionToolTightPrimary kwargs = setDefaults(kwargs, TrackSelectionTool=toolFactory( getInDetTrackSelectionToolTightPrimary)) kwargs = setDefaults(kwargs, name='InDetPhysValMonitoringToolTightPrimary', SubFolder='TightPrimary/', useTrackSelection=True) return getInDetPhysValMonitoringTool(**kwargs)
def InDetGlobalChi2FitterBase(name='GlobalChi2FitterBase', **kwargs): from TrkDetDescrSvc.AtlasTrackingGeometrySvc import AtlasTrackingGeometrySvc from InDetRecExample.TrackingCommon import setDefaults from AthenaCommon.AppMgr import ToolSvc from InDetRecExample.InDetJobProperties import InDetFlags import InDetRecExample.TrackingCommon as TrackingCommon kwargs = setDefaults( kwargs, ExtrapolationTool=TrackingCommon.getInDetExtrapolator(), NavigatorTool=TrackingCommon.getInDetNavigator(), PropagatorTool=TrackingCommon.getInDetPropagator(), MultipleScatteringTool=TrackingCommon. getInDetMultipleScatteringUpdator(), MeasurementUpdateTool=ToolSvc.InDetUpdator, TrackingGeometrySvc=AtlasTrackingGeometrySvc, MaterialUpdateTool=TrackingCommon.getInDetMaterialEffectsUpdator(), StraightLine=not InDetFlags.solenoidOn(), OutlierCut=4, SignedDriftRadius=True, ReintegrateOutliers=True, RecalibrateSilicon=True, RecalibrateTRT=True, TRTTubeHitCut= 1.75, # use tighter hit classification, old: TrackingCommon.default_ScaleHitUncertainty MaxIterations=40, Acceleration=True, RecalculateDerivatives=InDetFlags.doMinBias() or InDetFlags.doCosmics() or InDetFlags.doBeamHalo(), TRTExtensionCuts=True, TrackChi2PerNDFCut=7) from TrkGlobalChi2Fitter.TrkGlobalChi2FitterConf import Trk__GlobalChi2Fitter return Trk__GlobalChi2Fitter(name, **kwargs)
def getInDetPhysValTruthDecoratorAlgStableParticles(**kwargs): ''' Create a decoration algorithm which decorates stable truth particles only with track parameters at the perigee see @ref getInDetPhysValTruthDecoratorAlg for details. ''' return getInDetPhysValTruthDecoratorAlg( **setDefaults(kwargs, TruthSelectionTool=getInDetTruthSelectionTool()))
def getInDetPhysValMonitoringToolGSF(**kwargs): kwargs = setDefaults(kwargs, name='InDetPhysValMonitoringToolGSF', SubFolder='GSF/', TrackParticleContainerName='GSFTrackParticles', useTrackSelection=True) return getInDetPhysValMonitoringTool(**kwargs)
def InDetGlobalChi2Fitter(name='InDetGlobalChi2Fitter', **kwargs): split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension', '') from InDetRecExample import TrackingCommon as TrackingCommon if 'RotCreatorTool' not in kwargs: kwargs = setDefaults( kwargs, RotCreatorTool=TrackingCommon.getInDetRotCreator( nameSuffix=split_cluster_map_extension, SplitClusterMapExtension=split_cluster_map_extension)) from InDetRecExample.InDetJobProperties import InDetFlags use_broad_cluster_any = InDetFlags.useBroadClusterErrors() and ( not InDetFlags.doDBMstandalone()) if 'BroadRotCreatorTool' not in kwargs and not InDetFlags.doRefit(): kwargs = setDefaults( kwargs, BroadRotCreatorTool=TrackingCommon.getInDetBroadRotCreator( nameSuffix=split_cluster_map_extension, SplitClusterMapExtension=split_cluster_map_extension)) if InDetFlags.doDBMstandalone(): kwargs = setDefaults(kwargs, StraightLine=True, OutlierCut=5, RecalibrateTRT=False, TRTExtensionCuts=False, TrackChi2PerNDFCut=20) if InDetFlags.doRefit() or use_broad_cluster_any is True: kwargs = setDefaults(kwargs, RecalibrateSilicon=False) if InDetFlags.doRefit(): kwargs = setDefaults(kwargs, BroadRotCreatorTool=None, ReintegrateOutliers=False, RecalibrateTRT=False) if InDetFlags.doRobustReco(): kwargs = setDefaults( kwargs, # BroadRotCreatorTool = None OutlierCut=10.0, TrackChi2PerNDFCut=20) if InDetFlags.doRobustReco() or InDetFlags.doCosmics(): kwargs = setDefaults(kwargs, MaxOutliers=99) if InDetFlags.doCosmics() or InDetFlags.doBeamHalo(): kwargs = setDefaults(kwargs, Acceleration=False) if InDetFlags.materialInteractions() and not InDetFlags.solenoidOn(): kwargs = setDefaults(kwargs, Momentum=1000. * Units.MeV) return InDetGlobalChi2FitterBase(name, **kwargs)
def createPublicTool(cfg_class, kwargs_in, **kwargs_default): kwargs = setDefaults(kwargs_in, **kwargs_default) name = kwargs.pop('name', cfg_class.__class__.__name__) from AthenaCommon.AppMgr import ToolSvc if hasattr(ToolSvc, name): return getattr(ToolSvc, name) a_tool = cfg_class(name=name, **kwargs) ToolSvc += a_tool return a_tool
def getInDetPhysValMonitoringToolDBM(**kwargs): from InDetRecExample.InDetKeys import InDetKeys kwargs = setDefaults(kwargs, name='InDetPhysValMonitoringToolDBM', SubFolder='DBM/', TrackParticleContainerName=InDetKeys.DBMTracks(), useTrackSelection=True) return getInDetPhysValMonitoringTool(**kwargs)
def DistributedKalmanFilter(name="DistributedKalmanFilter", **kwargs): split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension', '') from InDetRecExample.TrackingCommon import setDefaults if 'ExtrapolatorTool' not in kwargs: kwargs = setDefaults( kwargs, ExtrapolatorTool=TrackingCommon.getInDetExtrapolator()) from InDetRecExample import TrackingCommon as TrackingCommon if 'ROTcreator' not in kwargs: kwargs = setDefaults( kwargs, ROTcreator=TrackingCommon.getInDetRotCreator( nameSuffix=split_cluster_map_extension, SplitClusterMapExtension=split_cluster_map_extension)) # @TODO set sortingReferencePoint = ??? from TrkDistributedKalmanFilter.TrkDistributedKalmanFilterConf import Trk__DistributedKalmanFilter return Trk__DistributedKalmanFilter(name=name, **kwargs)
def InDetGlobalChi2FitterDBM(name='InDetGlobalChi2FitterDBM', **kwargs): split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension', '') if 'RotCreatorTool' not in kwargs: from InDetRecExample import TrackingCommon as TrackingCommon kwargs = setDefaults( kwargs, RotCreatorTool=TrackingCommon.getInDetRotCreatorDBM( SplitClusterMapExtension=split_cluster_map_extension)) return InDetGlobalChi2FitterBase( name, **setDefaults(kwargs, BroadRotCreatorTool=None, StraightLine=True, OutlierCut=5, RecalibrateTRT=False, RecalculateDerivatives=False, TRTExtensionCuts=False, TrackChi2PerNDFCut=20, Momentum=1000. * Units.MeV))
def getInDetxAODParticleCreatorTool(prd_to_track_map=None, suffix=""): from AthenaCommon.AppMgr import ToolSvc if hasattr(ToolSvc, 'InDetxAODParticleCreatorTool' + suffix): return getattr(ToolSvc, 'InDetxAODParticleCreatorTool') _perigee_expression = InDetFlags.perigeeExpression() # need to treat Vertex specifically because at the time of # the track particle creation the primary vertex does not yet exist. # The problem is solved by first creating track particles wrt. the beam line # and correcting the parameters after the vertex finding. if _perigee_expression == 'Vertex': _perigee_expression = 'BeamLine' from InDetRecExample import TrackingCommon as TrackingCommon from InDetRecExample.TrackingCommon import setDefaults if prd_to_track_map is None: track_summary_tool = TrackingCommon.getInDetTrackSummaryToolSharedHits( ) else: prop_args = setDefaults({}, nameSuffix=suffix) asso_tool = TrackingCommon.getConstPRD_AssociationTool( **setDefaults(prop_args, PRDtoTrackMap=prd_to_track_map)) helper_tool = TrackingCommon.getInDetSummaryHelperSharedHits( **setDefaults(prop_args, AssoTool=asso_tool)) track_summary_tool = TrackingCommon.getInDetTrackSummaryToolSharedHits( **setDefaults(prop_args, InDetSummaryHelperTool=helper_tool)) from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool InDetxAODParticleCreatorTool = Trk__TrackParticleCreatorTool( name="InDetxAODParticleCreatorTool" + suffix, Extrapolator=InDetExtrapolator, TrackSummaryTool=track_summary_tool, BadClusterID=InDetFlags.pixelClusterBadClusterID(), KeepParameters=True, KeepFirstParameters=InDetFlags.KeepFirstParameters(), PerigeeExpression=_perigee_expression) ToolSvc += InDetxAODParticleCreatorTool if InDetFlags.doPrintConfigurables(): printfunc(InDetxAODParticleCreatorTool) return InDetxAODParticleCreatorTool
def createExtendNameIfNotDefault(cfg_class, check_prop, def_val, kwargs_in, **kwargs_default): kwargs = setDefaults(kwargs_in, **kwargs_default) def_name = cfg_class.getType() if hasattr( cfg_class, 'getType') else cfg_class.__class__.__name__ the_name = kwargs.pop('name', def_name) if check_prop in kwargs and kwargs[check_prop] != def_val: if the_name == def_name: the_name += '_' the_name += kwargs[check_prop] elif check_prop not in kwargs: kwargs.setdefault(check_prop, def_val) return cfg_class(name=the_name, **kwargs)
def InDetGlobalChi2FitterTRT(name='InDetGlobalChi2FitterTRT', **kwargs): ''' Global Chi2 Fitter for TRT segments with different settings ''' split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension', '') if 'RotCreatorTool' not in kwargs: from InDetRecExample import TrackingCommon as TrackingCommon kwargs = setDefaults( kwargs, RotCreatorTool=TrackingCommon.getInDetRefitRotCreator( nameSuffix=split_cluster_map_extension, SplitClusterMapExtension=split_cluster_map_extension)) from InDetRecExample.InDetJobProperties import InDetFlags return InDetGlobalChi2FitterBase( name, **setDefaults( kwargs, MaterialUpdateTool='', # default TrackingGeometrySvc='', # default SignedDriftRadius=True, # default, RecalibrateSilicon=False, # default, RecalibrateTRT=False, # default, TRTTubeHitCut=2.5, # default, MaxIterations=10, Acceleration=False, # default, RecalculateDerivatives=False, TRTExtensionCuts=True, # default, TrackChi2PerNDFCut=999999, Momentum=1000. * Units.MeV if InDetFlags.materialInteractions() and not InDetFlags.solenoidOn() else 0, # default, OutlierCut=5, # default MaxOutliers=99 if InDetFlags.doRobustReco() or InDetFlags.doCosmics() else 10, # default, ReintegrateOutliers=False if InDetFlags.doRefit() else False # default ))
def InDetKalmanTrackFitterBase(name='InDetKalmanTrackFitterBase', **kwargs): from InDetRecExample import TrackingCommon as TrackingCommon from TrkKalmanFitter.TrkKalmanFitterConf import Trk__KalmanFitter from AthenaCommon.AppMgr import ToolSvc split_cluster_map_extension = kwargs.get('SplitClusterMapExtension', '') kwargs.setdefault('ExtrapolatorHandle', TrackingCommon.getInDetExtrapolator()) if 'RIO_OnTrackCreatorHandle' not in kwargs: from InDetRecExample import TrackingCommon as TrackingCommon kwargs = setDefaults( kwargs, RIO_OnTrackCreatorHandle=TrackingCommon.getInDetRefitRotCreator( SplitClusterMapExtension=split_cluster_map_extension)) kwargs.setdefault('MeasurementUpdatorHandle', ToolSvc.InDetUpdator) setTool('KalmanSmootherHandle', 'InDetBKS', kwargs) setTool('KalmanOutlierLogicHandle', 'InDetKOL', kwargs) kwargs.setdefault('DynamicNoiseAdjustorHandle', None) kwargs.setdefault('BrempointAnalyserHandle', None) kwargs.setdefault('AlignableSurfaceProviderHandle', None) if len(split_cluster_map_extension) > 0: if 'RecalibratorHandle' not in kwargs: the_tool_name = 'InDetMeasRecalibST' kwargs.setdefault( 'RecalibratorHandle', CfgGetter.getPublicToolClone( the_tool_name + split_cluster_map_extension, the_tool_name, SplitClusterMapExtension=split_cluster_map_extension)) else: setTool('RecalibratorHandle', 'InDetMeasRecalibST', kwargs) # setTool('InternalDAFHandle','KalmanInternalDAF',kwargs ) # from InDetRecExample.InDetJobProperties import InDetFlags # kwargs.setdefault('DoDNAForElectronsOnly', True if InDetFlags.doBremRecovery() and InDetFlags.trackFitterType() is 'KalmanFitter' else False) return Trk__KalmanFitter(name, **kwargs)
def getInDetPhysValMonitoringTool(**kwargs): kwargs = setDefaults(kwargs, useTrackSelection=False, EnableLumi=False) # create the HistogramDefinitionSvc # at the moment there can only be one HistogramDefinitionSvc from InDetPhysValMonitoring.HistogramDefinitionSvc import getHistogramDefinitionSvc #self.HistogramDefinitionSvc = serviceFactory(getHistogramDefinitionSvc) from InDetPhysValMonitoring.InDetPhysValJobProperties import isMC, InDetPhysValFlags if isMC(): from InDetPhysValMonitoring.InDetPhysValDecoration import getInDetRttTruthSelectionTool kwargs = setDefaults(kwargs, TruthParticleContainerName="TruthParticles") if 'TruthSelectionTool' not in kwargs: kwargs = setDefaults( kwargs, TruthSelectionTool=getInDetRttTruthSelectionTool()) if InDetPhysValFlags.doValidateTracksInJets(): jets_name = 'AntiKt4LCTopoJets' kwargs = setDefaults(kwargs, JetContainerName=jets_name, FillTrackInJetPlots=True) from InDetPhysValMonitoring.addTruthJets import addTruthJetsIfNotExising addTruthJetsIfNotExising(jets_name) if InDetPhysValFlags.doValidateTracksInBJets(): kwargs = setDefaults(kwargs, FillTrackInBJetPlots=True) else: kwargs = setDefaults(kwargs, JetContainerName='', FillTrackInJetPlots=False) #adding the VeretxTruthMatchingTool from InDetTruthVertexValidation.InDetTruthVertexValidationConf import InDetVertexTruthMatchTool kwargs = setDefaults( kwargs, useVertexTruthMatchTool=True, VertexTruthMatchTool=toolFactory(InDetVertexTruthMatchTool)) #Options for Truth Strategy : Requires full pile-up truth containers for some if InDetPhysValFlags.setTruthStrategy( ) == 'All' or InDetPhysValFlags.setTruthStrategy() == 'PileUp': from RecExConfig.AutoConfiguration import IsInInputFile if IsInInputFile('xAOD::TruthPileupEventContainer', 'TruthPileupEvents'): kwargs = setDefaults( kwargs, PileupSwitch=InDetPhysValFlags.setTruthStrategy()) else: print( 'WARNING Truth Strategy for InDetPhysValMonitoring set to %s but TruthPileupEvents are missing in the input; resetting to HardScatter only' % (InDetPhysValFlags.setTruthStrategy())) elif InDetPhysValFlags.setTruthStrategy() != 'HardScatter': print( 'WARNING Truth Strategy for for InDetPhysValMonitoring set to invalid option %s; valid flags are ["HardScatter", "All", "PileUp"]' % (InDetPhysValFlags.setTruthStrategy())) else: # disable truth monitoring for data kwargs = setDefaults( kwargs, TruthParticleContainerName='', TruthVertexContainerName='', TruthEvents='', TruthPileupEvents='', TruthSelectionTool='', # the jet container is actually meant to be a truth jet container JetContainerName='', FillTrackInJetPlots=False, FillTrackInBJetPlots=False) # Control the number of output histograms if InDetPhysValFlags.doPhysValOutput(): kwargs = setDefaults(kwargs, SkillLevel=100) elif InDetPhysValFlags.doExpertOutput(): kwargs = setDefaults(kwargs, SkillLevel=200) # hack to remove example physval monitor from RecExConfig.AutoConfiguration import IsInInputFile if not IsInInputFile('xAOD::JetContainer', 'AntiKt4EMTopoJets'): add_remover = True from RecExConfig.RecFlags import rec try: for elm in rec.UserExecs: if elm.find('removePhysValExample') > 0: add_remover = False break except: pass if add_remover: rec.UserExecs += [ 'from InDetPhysValMonitoring.InDetPhysValMonitoringTool import removePhysValExample;removePhysValExample();' ] return InDetPhysValMonitoring.InDetPhysValMonitoringConf.InDetPhysValMonitoringTool( **kwargs)
def create(cfg_class, kwargs_in, **kwargs_default): kwargs = setDefaults(kwargs_in, **kwargs_default) name = kwargs.pop('name', cfg_class.__class__.__name__) return cfg_class(name=name, **kwargs)
def getInDetTruthSelectionTool(**kwargs): return getInDetRttTruthSelectionTool(**setDefaults( kwargs, name='InDetTruthSelectionTool', maxProdVertRadius=-1)) # disable production radius cut
def getPhysValMonInDetHoleSearchTool(**kwargs): from InDetRecExample.TrackingCommon import getInDetHoleSearchTool kwargs = setDefaults(kwargs, name='PhysValMonInDetHoleSearchTool') return getInDetHoleSearchTool(**kwargs)
def getInDetTrackSelectionToolLoose(name="InDetTrackSelectionToolLoose", **kwargs): kwargs = setDefaults(kwargs, CutLevel="Loose") return InDet__InDetTrackSelectionTool(name, **kwargs)
def getInDetTrackSelectionToolTightPrimary( name="InDetTrackSelectionToolTightPrimary", **kwargs): kwargs = setDefaults(kwargs, CutLevel="TightPrimary") return InDet__InDetTrackSelectionTool(name, **kwargs)
def __init__(self, InputCollections=None, ResolvedTrackCollectionKey=None, SiSPSeededTrackCollectionKey=None, NewTrackingCuts=None, TrackCollectionKeys=[], TrackCollectionTruthKeys=[]): from InDetRecExample.InDetJobProperties import InDetFlags from InDetRecExample.InDetKeys import InDetKeys import InDetRecExample.TrackingCommon as TrackingCommon # # --- get ToolSvc and topSequence # from AthenaCommon.AppMgr import ToolSvc from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() # # --- decide if use the association tool # if (len(InputCollections) > 0) and ( NewTrackingCuts.mode() == "LowPt" or NewTrackingCuts.mode() == "VeryLowPt" or NewTrackingCuts.mode() == "LargeD0" or NewTrackingCuts.mode() == "R3LargeD0" or NewTrackingCuts.mode() == "LowPtLargeD0" or NewTrackingCuts.mode() == "BeamGas" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "Disappearing" or NewTrackingCuts.mode() == "VeryForwardSLHCTracks" or NewTrackingCuts.mode() == "SLHCConversionFinding"): usePrdAssociationTool = True else: usePrdAssociationTool = False # # --- get list of already associated hits (always do this, even if no other tracking ran before) # asso_tool = None if usePrdAssociationTool: prefix = 'InDet' suffix = NewTrackingCuts.extension() InDetPRD_Association = TrackingCommon.getInDetTrackPRD_Association( namePrefix=prefix, nameSuffix=suffix, TracksName=list(InputCollections)) # asso_tool = TrackingCommon.getConstPRD_AssociationTool(namePrefix = prefix, nameSuffix = suffix) topSequence += InDetPRD_Association if (InDetFlags.doPrintConfigurables()): printfunc(InDetPRD_Association) # ------------------------------------------------------------ # # ----------- SiSPSeededTrackFinder # # ------------------------------------------------------------ if InDetFlags.doSiSPSeededTrackFinder(): # # --- Space points seeds maker, use different ones for cosmics and collisions # if NewTrackingCuts.mode() == "DBM": from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_ATLxk as SiSpacePointsSeedMaker elif InDetFlags.doCosmics(): from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_Cosmic as SiSpacePointsSeedMaker elif InDetFlags.doHeavyIon(): from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_HeavyIon as SiSpacePointsSeedMaker elif NewTrackingCuts.mode() == "LowPt" or NewTrackingCuts.mode( ) == "VeryLowPt" or (NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()): from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_LowMomentum as SiSpacePointsSeedMaker elif NewTrackingCuts.mode() == "BeamGas": from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_BeamGas as SiSpacePointsSeedMaker elif NewTrackingCuts.mode() == "SLHC" or NewTrackingCuts.mode( ) == "ForwardSLHCTracks" or NewTrackingCuts.mode( ) == "VeryForwardSLHCTracks": from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_ITK as SiSpacePointsSeedMaker else: from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_ATLxk as SiSpacePointsSeedMaker InDetSiSpacePointsSeedMaker = SiSpacePointsSeedMaker( name="InDetSpSeedsMaker" + NewTrackingCuts.extension(), pTmin=NewTrackingCuts.minPT(), maxdImpact=NewTrackingCuts.maxPrimaryImpact(), maxZ=NewTrackingCuts.maxZImpact(), minZ=-NewTrackingCuts.maxZImpact(), usePixel=NewTrackingCuts.usePixel(), SpacePointsPixelName=InDetKeys.PixelSpacePoints(), # useSCT = NewTrackingCuts.useSCT(), useSCT=(NewTrackingCuts.useSCT() and NewTrackingCuts.useSCTSeeding()), SpacePointsSCTName=InDetKeys.SCT_SpacePoints(), # useOverlapSpCollection = NewTrackingCuts.useSCT(), useOverlapSpCollection=(NewTrackingCuts.useSCT() and NewTrackingCuts.useSCTSeeding()), SpacePointsOverlapName=InDetKeys.OverlapSpacePoints(), radMax=NewTrackingCuts.radMax(), RapidityCut=NewTrackingCuts.maxEta()) if NewTrackingCuts.mode() == "Offline" or InDetFlags.doHeavyIon( ) or NewTrackingCuts.mode() == "ForwardTracks": InDetSiSpacePointsSeedMaker.maxdImpactPPS = NewTrackingCuts.maxdImpactPPSSeeds( ) InDetSiSpacePointsSeedMaker.maxdImpactSSS = NewTrackingCuts.maxdImpactSSSSeeds( ) if not InDetFlags.doHeavyIon(): InDetSiSpacePointsSeedMaker.maxSeedsForSpacePointStrips = NewTrackingCuts.MaxSeedsPerSP_Strips( ) InDetSiSpacePointsSeedMaker.maxSeedsForSpacePointPixels = NewTrackingCuts.MaxSeedsPerSP_Pixels( ) InDetSiSpacePointsSeedMaker.alwaysKeepConfirmedStripSeeds = NewTrackingCuts.KeepAllConfirmedStripSeeds( ) InDetSiSpacePointsSeedMaker.alwaysKeepConfirmedPixelSeeds = NewTrackingCuts.KeepAllConfirmedPixelSeeds( ) if NewTrackingCuts.mode() == "R3LargeD0": InDetSiSpacePointsSeedMaker.optimisePhiBinning = False InDetSiSpacePointsSeedMaker.usePixel = False InDetSiSpacePointsSeedMaker.etaMax = NewTrackingCuts.maxEta() InDetSiSpacePointsSeedMaker.maxSeedsForSpacePointStrips = NewTrackingCuts.MaxSeedsPerSP_Strips( ) InDetSiSpacePointsSeedMaker.alwaysKeepConfirmedStripSeeds = NewTrackingCuts.KeepAllConfirmedStripSeeds( ) InDetSiSpacePointsSeedMaker.maxdRadius = 150 InDetSiSpacePointsSeedMaker.seedScoreBonusConfirmationSeed = -2000 #let's be generous if usePrdAssociationTool: # not all classes have that property !!! InDetSiSpacePointsSeedMaker.PRDtoTrackMap = prefix+'PRDtoTrackMap'+suffix \ if usePrdAssociationTool else '' if not InDetFlags.doCosmics(): InDetSiSpacePointsSeedMaker.maxRadius1 = 0.75 * NewTrackingCuts.radMax( ) InDetSiSpacePointsSeedMaker.maxRadius2 = NewTrackingCuts.radMax( ) InDetSiSpacePointsSeedMaker.maxRadius3 = NewTrackingCuts.radMax( ) if NewTrackingCuts.mode() == "LowPt" or NewTrackingCuts.mode( ) == "VeryLowPt" or (NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()): try: InDetSiSpacePointsSeedMaker.pTmax = NewTrackingCuts.maxPT() except: pass InDetSiSpacePointsSeedMaker.mindRadius = 4.0 if NewTrackingCuts.mode() == "SLHC" or NewTrackingCuts.mode( ) == "SLHCConversionFinding": InDetSiSpacePointsSeedMaker.minRadius1 = 0 InDetSiSpacePointsSeedMaker.minRadius2 = 0 InDetSiSpacePointsSeedMaker.minRadius3 = 0 InDetSiSpacePointsSeedMaker.maxRadius1 = 1000. * Units.mm InDetSiSpacePointsSeedMaker.maxRadius2 = 1000. * Units.mm InDetSiSpacePointsSeedMaker.maxRadius3 = 1000. * Units.mm if NewTrackingCuts.mode( ) == "ForwardTracks" or NewTrackingCuts.mode( ) == "ForwardSLHCTracks" or NewTrackingCuts.mode( ) == "VeryForwardSLHCTracks": InDetSiSpacePointsSeedMaker.checkEta = True InDetSiSpacePointsSeedMaker.etaMin = NewTrackingCuts.minEta() InDetSiSpacePointsSeedMaker.etaMax = NewTrackingCuts.maxEta() InDetSiSpacePointsSeedMaker.RapidityCut = NewTrackingCuts.maxEta( ) if NewTrackingCuts.mode() == "DBM": InDetSiSpacePointsSeedMaker.etaMin = NewTrackingCuts.minEta() InDetSiSpacePointsSeedMaker.etaMax = NewTrackingCuts.maxEta() InDetSiSpacePointsSeedMaker.useDBM = True #InDetSiSpacePointsSeedMaker.OutputLevel = VERBOSE ToolSvc += InDetSiSpacePointsSeedMaker if (InDetFlags.doPrintConfigurables()): printfunc(InDetSiSpacePointsSeedMaker) # # --- Z-coordinates primary vertices finder (only for collisions) # if InDetFlags.useZvertexTool() and NewTrackingCuts.mode() != "DBM": from SiZvertexTool_xk.SiZvertexTool_xkConf import InDet__SiZvertexMaker_xk InDetZvertexMaker = InDet__SiZvertexMaker_xk( name='InDetZvertexMaker' + NewTrackingCuts.extension(), Zmax=NewTrackingCuts.maxZImpact(), Zmin=-NewTrackingCuts.maxZImpact(), minRatio=0.17) # not default InDetZvertexMaker.SeedMakerTool = InDetSiSpacePointsSeedMaker if InDetFlags.doHeavyIon(): InDetZvertexMaker.HistSize = 2000 ###InDetZvertexMaker.minContent = 200 InDetZvertexMaker.minContent = 30 ToolSvc += InDetZvertexMaker if (InDetFlags.doPrintConfigurables()): printfunc(InDetZvertexMaker) else: InDetZvertexMaker = None # # --- SCT and Pixel detector elements road builder # from SiDetElementsRoadTool_xk.SiDetElementsRoadTool_xkConf import InDet__SiDetElementsRoadMaker_xk InDetSiDetElementsRoadMaker = InDet__SiDetElementsRoadMaker_xk( name='InDetSiRoadMaker' + NewTrackingCuts.extension(), PropagatorTool=InDetPatternPropagator, usePixel=NewTrackingCuts.usePixel(), PixManagerLocation=InDetKeys.PixelManager(), useSCT=NewTrackingCuts.useSCT(), SCTManagerLocation=InDetKeys.SCT_Manager(), RoadWidth=NewTrackingCuts.RoadWidth()) if (InDetFlags.doPrintConfigurables()): printfunc(InDetSiDetElementsRoadMaker) # Condition algorithm for InDet__SiDetElementsRoadMaker_xk if DetFlags.haveRIO.pixel_on(): # Condition algorithm for SiCombinatorialTrackFinder_xk from AthenaCommon.AlgSequence import AthSequencer condSeq = AthSequencer("AthCondSeq") if not hasattr(condSeq, "InDetSiDetElementBoundaryLinksPixelCondAlg"): from SiCombinatorialTrackFinderTool_xk.SiCombinatorialTrackFinderTool_xkConf import InDet__SiDetElementBoundaryLinksCondAlg_xk condSeq += InDet__SiDetElementBoundaryLinksCondAlg_xk( name="InDetSiDetElementBoundaryLinksPixelCondAlg", ReadKey="PixelDetectorElementCollection", WriteKey="PixelDetElementBoundaryLinks_xk", UsePixelDetectorManager=True) if NewTrackingCuts.useSCT(): from AthenaCommon.AlgSequence import AthSequencer condSeq = AthSequencer("AthCondSeq") if not hasattr(condSeq, "InDet__SiDetElementsRoadCondAlg_xk"): from SiDetElementsRoadTool_xk.SiDetElementsRoadTool_xkConf import InDet__SiDetElementsRoadCondAlg_xk condSeq += InDet__SiDetElementsRoadCondAlg_xk( name="InDet__SiDetElementsRoadCondAlg_xk") if not hasattr(condSeq, "InDetSiDetElementBoundaryLinksSCTCondAlg"): from SiCombinatorialTrackFinderTool_xk.SiCombinatorialTrackFinderTool_xkConf import InDet__SiDetElementBoundaryLinksCondAlg_xk condSeq += InDet__SiDetElementBoundaryLinksCondAlg_xk( name="InDetSiDetElementBoundaryLinksSCTCondAlg", ReadKey="SCT_DetectorElementCollection", WriteKey="SCT_DetElementBoundaryLinks_xk") # # --- Local track finding using sdCaloSeededSSSpace point seed # # @TODO ensure that PRD association map is used if usePrdAssociationTool is set is_dbm = InDetFlags.doDBMstandalone() or NewTrackingCuts.extension( ) == 'DBM' rot_creator_digital = TrackingCommon.getInDetRotCreatorDigital( ) if not is_dbm else TrackingCommon.getInDetRotCreatorDBM() from SiCombinatorialTrackFinderTool_xk.SiCombinatorialTrackFinderTool_xkConf import InDet__SiCombinatorialTrackFinder_xk track_finder = InDet__SiCombinatorialTrackFinder_xk( name='InDetSiComTrackFinder' + NewTrackingCuts.extension(), PropagatorTool=InDetPatternPropagator, UpdatorTool=InDetPatternUpdator, RIOonTrackTool=rot_creator_digital, usePixel=DetFlags.haveRIO.pixel_on(), useSCT=DetFlags.haveRIO.SCT_on() if not is_dbm else False, PixelClusterContainer=InDetKeys.PixelClusters(), SCT_ClusterContainer=InDetKeys.SCT_Clusters()) if is_dbm: track_finder.MagneticFieldMode = "NoField" track_finder.TrackQualityCut = 9.3 if (DetFlags.haveRIO.SCT_on()): track_finder.SctSummaryTool = InDetSCT_ConditionsSummaryTool else: track_finder.SctSummaryTool = None ToolSvc += track_finder useBremMode = NewTrackingCuts.mode( ) == "Offline" or NewTrackingCuts.mode( ) == "SLHC" or NewTrackingCuts.mode() == "DBM" from SiTrackMakerTool_xk.SiTrackMakerTool_xkConf import InDet__SiTrackMaker_xk as SiTrackMaker InDetSiTrackMaker = SiTrackMaker( name='InDetSiTrackMaker' + NewTrackingCuts.extension(), useSCT=NewTrackingCuts.useSCT(), usePixel=NewTrackingCuts.usePixel(), RoadTool=InDetSiDetElementsRoadMaker, CombinatorialTrackFinder=track_finder, pTmin=NewTrackingCuts.minPT(), pTminBrem=NewTrackingCuts.minPTBrem(), pTminSSS=InDetFlags.pT_SSScut(), nClustersMin=NewTrackingCuts.minClusters(), nHolesMax=NewTrackingCuts.nHolesMax(), nHolesGapMax=NewTrackingCuts.nHolesGapMax(), SeedsFilterLevel=NewTrackingCuts.seedFilterLevel(), Xi2max=NewTrackingCuts.Xi2max(), Xi2maxNoAdd=NewTrackingCuts.Xi2maxNoAdd(), nWeightedClustersMin=NewTrackingCuts.nWeightedClustersMin(), CosmicTrack=InDetFlags.doCosmics(), Xi2maxMultiTracks=NewTrackingCuts.Xi2max(), # was 3. useSSSseedsFilter=InDetFlags.doSSSfilter(), doMultiTracksProd=True, useBremModel=InDetFlags.doBremRecovery() and useBremMode, # only for NewTracking the brem is debugged !!! doCaloSeededBrem=InDetFlags.doCaloSeededBrem(), doHadCaloSeedSSS=InDetFlags.doHadCaloSeededSSS(), phiWidth=NewTrackingCuts.phiWidthBrem(), etaWidth=NewTrackingCuts.etaWidthBrem(), InputClusterContainerName=InDetKeys.CaloClusterROIContainer( ), # "InDetCaloClusterROIs" InputHadClusterContainerName=InDetKeys. HadCaloClusterROIContainer(), # "InDetCaloClusterROIs" UseAssociationTool=usePrdAssociationTool) if NewTrackingCuts.mode() == "SLHC" or NewTrackingCuts.mode( ) == "ForwardSLHCTracks" or NewTrackingCuts.mode( ) == "VeryForwardSLHCTracks": InDetSiTrackMaker.ITKGeometry = True if NewTrackingCuts.mode() == "DBM": InDetSiTrackMaker.MagneticFieldMode = "NoField" InDetSiTrackMaker.useBremModel = False InDetSiTrackMaker.doMultiTracksProd = False InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSPSeededFinder' InDetSiTrackMaker.pTminSSS = -1 InDetSiTrackMaker.CosmicTrack = False InDetSiTrackMaker.useSSSseedsFilter = False InDetSiTrackMaker.doCaloSeededBrem = False InDetSiTrackMaker.doHadCaloSeedSSS = False elif InDetFlags.doCosmics(): InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_Cosmic' elif InDetFlags.doHeavyIon(): InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_HeavyIon' elif NewTrackingCuts.mode() == "LowPt": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_LowMomentum' elif NewTrackingCuts.mode() == "VeryLowPt" or ( NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()): InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_VeryLowMomentum' elif NewTrackingCuts.mode() == "BeamGas": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_BeamGas' elif NewTrackingCuts.mode() == "ForwardTracks": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_ForwardTracks' elif NewTrackingCuts.mode() == "ForwardSLHCTracks": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_ForwardSLHCTracks' elif NewTrackingCuts.mode() == "VeryForwardSLHCTracks": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_VeryForwardSLHCTracks' elif NewTrackingCuts.mode() == "SLHCConversionFinding": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_SLHCConversionTracks' elif NewTrackingCuts.mode() == "LargeD0" or NewTrackingCuts.mode( ) == "R3LargeD0" or NewTrackingCuts.mode() == "LowPtLargeD0": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_LargeD0' else: InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSPSeededFinder' if InDetFlags.doStoreTrackSeeds(): from SeedToTrackConversionTool.SeedToTrackConversionToolConf import InDet__SeedToTrackConversionTool InDet_SeedToTrackConversion = InDet__SeedToTrackConversionTool( name="InDet_SeedToTrackConversion", OutputName=InDetKeys.SiSPSeedSegments() + NewTrackingCuts.extension()) InDetSiTrackMaker.SeedToTrackConversion = InDet_SeedToTrackConversion InDetSiTrackMaker.SeedSegmentsWrite = True #InDetSiTrackMaker.OutputLevel = VERBOSE ToolSvc += InDetSiTrackMaker if (InDetFlags.doPrintConfigurables()): printfunc(InDetSiTrackMaker) # # set output track collection name # self.__SiTrackCollection = SiSPSeededTrackCollectionKey # # --- Setup Track finder using space points seeds # from SiSPSeededTrackFinder.SiSPSeededTrackFinderConf import InDet__SiSPSeededTrackFinder if NewTrackingCuts.mode( ) == "ForwardSLHCTracks" or NewTrackingCuts.mode( ) == "ForwardTracks": InDetSiSPSeededTrackFinder = InDet__SiSPSeededTrackFinder(name = 'InDetSiSpTrackFinder'+NewTrackingCuts.extension(), TrackTool = InDetSiTrackMaker, PRDtoTrackMap = prefix+'PRDtoTrackMap'+suffix \ if usePrdAssociationTool else '', TrackSummaryTool = TrackingCommon.getInDetTrackSummaryToolNoHoleSearch(), TracksLocation = self.__SiTrackCollection, SeedsTool = InDetSiSpacePointsSeedMaker, useZvertexTool = InDetFlags.useZvertexTool(), ZvertexTool = InDetZvertexMaker, useNewStrategy = False, useMBTSTimeDiff = InDetFlags.useMBTSTimeDiff(), useZBoundFinding = False) if InDetFlags.doHeavyIon(): InDetSiSPSeededTrackFinder.FreeClustersCut = 2 #Heavy Ion optimization from Igor else: InDetSiSPSeededTrackFinder = InDet__SiSPSeededTrackFinder(name = 'InDetSiSpTrackFinder'+NewTrackingCuts.extension(), TrackTool = InDetSiTrackMaker, PRDtoTrackMap = prefix+'PRDtoTrackMap'+suffix \ if usePrdAssociationTool else '', TrackSummaryTool = TrackingCommon.getInDetTrackSummaryToolNoHoleSearch(), TracksLocation = self.__SiTrackCollection, SeedsTool = InDetSiSpacePointsSeedMaker, useZvertexTool = InDetFlags.useZvertexTool() and NewTrackingCuts.mode() != "DBM", ZvertexTool = InDetZvertexMaker, useNewStrategy = InDetFlags.useNewSiSPSeededTF() and NewTrackingCuts.mode() != "DBM", useMBTSTimeDiff = InDetFlags.useMBTSTimeDiff(), useZBoundFinding = NewTrackingCuts.doZBoundary() and NewTrackingCuts.mode() != "DBM") if InDetFlags.doHeavyIon(): InDetSiSPSeededTrackFinder.FreeClustersCut = 2 #Heavy Ion optimization from Igor #InDetSiSPSeededTrackFinder.OutputLevel =VERBOSE topSequence += InDetSiSPSeededTrackFinder if (InDetFlags.doPrintConfigurables()): printfunc(InDetSiSPSeededTrackFinder) if not InDetFlags.doSGDeletion(): if InDetFlags.doTruth(): # # set up the truth info for this container # include("InDetRecExample/ConfiguredInDetTrackTruth.py") InDetTracksTruth = ConfiguredInDetTrackTruth( self.__SiTrackCollection, self.__SiTrackCollection + "DetailedTruth", self.__SiTrackCollection + "TruthCollection") # # add final output for statistics # TrackCollectionKeys += [InDetTracksTruth.Tracks()] TrackCollectionTruthKeys += [ InDetTracksTruth.TracksTruth() ] else: TrackCollectionKeys += [self.__SiTrackCollection] # ------------------------------------------------------------ # # ---------- Ambiguity solving # # ------------------------------------------------------------ if InDetFlags.doAmbiSolving(): # # --- load InnerDetector TrackSelectionTool # prob1 = InDetFlags.pixelClusterSplitProb1() prob2 = InDetFlags.pixelClusterSplitProb2() nhitsToAllowSplitting = 9 from AtlasGeoModel.CommonGMJobProperties import CommonGeometryFlags if CommonGeometryFlags.Run() == 1: prob1 = InDetFlags.pixelClusterSplitProb1_run1() prob2 = InDetFlags.pixelClusterSplitProb2_run1() nhitsToAllowSplitting = 8 if InDetFlags.doTIDE_Ambi() and not ( NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "DBM"): from InDetAmbiTrackSelectionTool.InDetAmbiTrackSelectionToolConf import InDet__InDetDenseEnvAmbiTrackSelectionTool as AmbiTrackSelectionTool else: from InDetAmbiTrackSelectionTool.InDetAmbiTrackSelectionToolConf import InDet__InDetAmbiTrackSelectionTool as AmbiTrackSelectionTool InDetAmbiTrackSelectionTool = AmbiTrackSelectionTool( name='InDetAmbiTrackSelectionTool' + NewTrackingCuts.extension(), DriftCircleCutTool=InDetTRTDriftCircleCut, AssociationTool=TrackingCommon. getInDetPRDtoTrackMapToolGangedPixels(), minHits=NewTrackingCuts.minClusters(), minNotShared=NewTrackingCuts.minSiNotShared(), maxShared=NewTrackingCuts.maxShared(), minTRTHits=0, # used for Si only tracking !!! sharedProbCut=0.10, UseParameterization=False, Cosmics=InDetFlags.doCosmics(), doPixelSplitting=InDetFlags.doPixelClusterSplitting() and NewTrackingCuts.mode != "DBM") if InDetFlags.doTIDE_Ambi() and not ( NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "DBM"): InDetAmbiTrackSelectionTool.sharedProbCut = prob1 InDetAmbiTrackSelectionTool.sharedProbCut2 = prob2 InDetAmbiTrackSelectionTool.minSiHitsToAllowSplitting = nhitsToAllowSplitting InDetAmbiTrackSelectionTool.minUniqueSCTHits = 4 InDetAmbiTrackSelectionTool.minTrackChi2ForSharedHits = 3 InDetAmbiTrackSelectionTool.InputHadClusterContainerName = InDetKeys.HadCaloClusterROIContainer( ) + "Bjet" InDetAmbiTrackSelectionTool.doHadCaloSeed = InDetFlags.doCaloSeededAmbi( ) #Do special cuts in region of interest InDetAmbiTrackSelectionTool.minPtSplit = InDetFlags.pixelClusterSplitMinPt( ) #Only allow split clusters on track withe pt greater than this MeV InDetAmbiTrackSelectionTool.maxSharedModulesInROI = 3 #Maximum number of shared modules for tracks in ROI InDetAmbiTrackSelectionTool.minNotSharedInROI = 2 #Minimum number of unique modules for tracks in ROI InDetAmbiTrackSelectionTool.minSiHitsToAllowSplittingInROI = 7 #Minimum number of Si hits to allow splittings for tracks in ROI InDetAmbiTrackSelectionTool.phiWidth = 0.1 #Split cluster ROI size InDetAmbiTrackSelectionTool.etaWidth = 0.1 #Split cluster ROI size InDetAmbiTrackSelectionTool.InputEmClusterContainerName = InDetKeys.CaloClusterROIContainer( ) InDetAmbiTrackSelectionTool.doEmCaloSeed = False #Only split in cluster in region of interest InDetAmbiTrackSelectionTool.minPtConv = 10000 #Only allow split clusters on track withe pt greater than this MeV InDetAmbiTrackSelectionTool.phiWidthEM = 0.05 #Split cluster ROI size InDetAmbiTrackSelectionTool.etaWidthEM = 0.05 #Split cluster ROI size if NewTrackingCuts.mode() == "DBM": InDetAmbiTrackSelectionTool.Cosmics = False InDetAmbiTrackSelectionTool.UseParameterization = False InDetAmbiTrackSelectionTool.doPixelSplitting = False InDetAmbiTrackSelectionTool.maxShared = 1000 InDetAmbiTrackSelectionTool.maxTracksPerSharedPRD = 2 InDetAmbiTrackSelectionTool.minHits = 0 InDetAmbiTrackSelectionTool.minNotShared = 0 InDetAmbiTrackSelectionTool.minScoreShareTracks = 0.0 InDetAmbiTrackSelectionTool.minTRTHits = 0 InDetAmbiTrackSelectionTool.sharedProbCut = 0.1 # if NewTrackingCuts.mode() == "ForwardTracks": # InDetAmbiTrackSelectionTool.OutputLevel = VERBOSE ToolSvc += InDetAmbiTrackSelectionTool if (InDetFlags.doPrintConfigurables()): printfunc(InDetAmbiTrackSelectionTool) # # --- set up different Scoring Tool for collisions and cosmics # if InDetFlags.doCosmics() and NewTrackingCuts.mode() != "DBM": InDetAmbiScoringTool = TrackingCommon.getInDetCosmicsScoringTool( NewTrackingCuts) elif (NewTrackingCuts.mode() == "R3LargeD0" and InDetFlags.nnCutLargeD0Threshold > 0): # Set up NN config InDetAmbiScoringTool = TrackingCommon.getInDetNNScoringTool( NewTrackingCuts) else: InDetAmbiScoringTool = TrackingCommon.getInDetAmbiScoringTool( NewTrackingCuts) # # --- load Ambiguity Processor # useBremMode = NewTrackingCuts.mode( ) == "Offline" or NewTrackingCuts.mode() == "SLHC" if InDetFlags.doTIDE_Ambi() and not ( NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "DBM"): # DenseEnvironmentsAmbiguityProcessorTool from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__DenseEnvironmentsAmbiguityProcessorTool as ProcessorTool use_low_pt_fitter = True if NewTrackingCuts.mode( ) == "LowPt" or NewTrackingCuts.mode() == "VeryLowPt" or ( NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()) else False from AthenaCommon import CfgGetter from InDetRecExample.TrackingCommon import setDefaults if len(NewTrackingCuts.extension()) > 0: fitter_args = setDefaults( {}, SplitClusterMapExtension=NewTrackingCuts.extension()) fitter_list=[ CfgGetter.getPublicToolClone('InDetTrackFitter'+NewTrackingCuts.extension(), 'InDetTrackFitter',**fitter_args) if not use_low_pt_fitter \ else CfgGetter.getPublicToolClone('InDetTrackFitterLowPt'+NewTrackingCuts.extension(), 'InDetTrackFitterLowPt',**fitter_args)] else: fitter_list=[ CfgGetter.getPublicTool('InDetTrackFitter') if not use_low_pt_fitter \ else CfgGetter.getPublicTool('InDetTrackFitterLowPt')] if InDetFlags.doRefitInvalidCov(): from AthenaCommon import CfgGetter if len(NewTrackingCuts.extension()) > 0: fitter_args = setDefaults( {}, SplitClusterMapExtension=NewTrackingCuts.extension( )) fitter_list.append( CfgGetter.getPublicToolClone( 'KalmanFitter' + NewTrackingCuts.extension(), 'KalmanFitter', **fitter_args)) fitter_list.append( CfgGetter.getPublicToolClone( 'ReferenceKalmanFitter' + NewTrackingCuts.extension(), 'ReferenceKalmanFitter', **fitter_args)) else: fitter_list.append( CfgGetter.getPublicTool('KalmanFitter')) fitter_list.append( CfgGetter.getPublicTool('ReferenceKalmanFitter')) InDetAmbiguityProcessor = ProcessorTool( name='InDetAmbiguityProcessor' + NewTrackingCuts.extension(), Fitter=fitter_list, AssociationTool=TrackingCommon. getInDetPRDtoTrackMapToolGangedPixels(), AssociationMapName='PRDToTrackMap' + NewTrackingCuts.extension(), TrackSummaryTool=TrackingCommon.getInDetTrackSummaryTool(), ScoringTool=InDetAmbiScoringTool, SelectionTool=InDetAmbiTrackSelectionTool, SuppressHoleSearch=False, tryBremFit=InDetFlags.doBremRecovery() and useBremMode and NewTrackingCuts.mode() != "DBM", caloSeededBrem=InDetFlags.doCaloSeededBrem() and NewTrackingCuts.mode() != "DBM", pTminBrem=NewTrackingCuts.minPTBrem(), RefitPrds=True, doHadCaloSeed=InDetFlags.doCaloSeededRefit(), InputHadClusterContainerName=InDetKeys. HadCaloClusterROIContainer() + "Bjet") # DenseEnvironmentsAmbiguityScoreProcessorTool from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__DenseEnvironmentsAmbiguityScoreProcessorTool as ScoreProcessorTool InDetAmbiguityScoreProcessor = ScoreProcessorTool( name='InDetAmbiguityScoreProcessor' + NewTrackingCuts.extension(), ScoringTool=InDetAmbiScoringTool, SplitProbTool=NnPixelClusterSplitProbTool if InDetFlags.doPixelClusterSplitting() and 'NnPixelClusterSplitProbTool' in globals() else None, AssociationTool=TrackingCommon. getInDetPRDtoTrackMapToolGangedPixels(), AssociationToolNotGanged=TrackingCommon. getPRDtoTrackMapTool(), AssociationMapName='PRDToTrackMap' + NewTrackingCuts.extension(), SelectionTool=InDetAmbiTrackSelectionTool) # hasScoreProcessorTool = True else: from AthenaCommon import CfgGetter from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__SimpleAmbiguityProcessorTool as ProcessorTool InDetAmbiguityProcessor = ProcessorTool( name='InDetAmbiguityProcessor' + NewTrackingCuts.extension(), Fitter=CfgGetter.getPublicTool('InDetTrackFitter'), AssociationTool=TrackingCommon. getInDetPRDtoTrackMapToolGangedPixels(), TrackSummaryTool=TrackingCommon.getInDetTrackSummaryTool(), ScoringTool=InDetAmbiScoringTool, SelectionTool=InDetAmbiTrackSelectionTool, SuppressHoleSearch=False, tryBremFit=InDetFlags.doBremRecovery() and useBremMode and NewTrackingCuts.mode() != "DBM", caloSeededBrem=InDetFlags.doCaloSeededBrem() and NewTrackingCuts.mode() != "DBM", pTminBrem=NewTrackingCuts.minPTBrem(), RefitPrds=True) InDetAmbiguityScoreProcessor = None if InDetFlags.doTIDE_Ambi() and not ( NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "DBM") and 'NnPixelClusterSplitProbTool' in globals(): if InDetAmbiguityScoreProcessor is not None: InDetAmbiguityScoreProcessor.sharedProbCut = prob1 InDetAmbiguityScoreProcessor.sharedProbCut2 = prob2 if NewTrackingCuts.extension() == "": InDetAmbiguityScoreProcessor.SplitClusterMap_old = "" elif NewTrackingCuts.extension() == "Disappearing": InDetAmbiguityScoreProcessor.SplitClusterMap_old = InDetKeys.SplitClusterAmbiguityMap( ) InDetAmbiguityScoreProcessor.SplitClusterMap_new = InDetKeys.SplitClusterAmbiguityMap( ) + NewTrackingCuts.extension() if InDetFlags.doTIDE_RescalePixelCovariances(): InDetAmbiguityProcessor.applydRcorrection = True if NewTrackingCuts.mode() == "Pixel" or NewTrackingCuts.mode( ) == "DBM": InDetAmbiguityProcessor.SuppressHoleSearch = True if NewTrackingCuts.mode() == "LowPt" or NewTrackingCuts.mode( ) == "VeryLowPt" or (NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()): if InDetAmbiguityProcessor.getName().find('Dense'): pass else: from AthenaCommon import CfgGetter InDetAmbiguityProcessor.Fitter = CfgGetter.getPublicTool( 'InDetTrackFitterLowPt') if InDetFlags.materialInteractions(): InDetAmbiguityProcessor.MatEffects = InDetFlags.materialInteractionsType( ) else: InDetAmbiguityProcessor.MatEffects = 0 # if NewTrackingCuts.mode() == "ForwardTracks": # InDetAmbiguityProcessor.OutputLevel = VERBOSE ToolSvc += InDetAmbiguityProcessor if (InDetFlags.doPrintConfigurables()): printfunc(InDetAmbiguityProcessor) # add InDetAmbiguityScoreProcessor if InDetAmbiguityScoreProcessor is not None: ToolSvc += InDetAmbiguityScoreProcessor # # --- set input and output collection # InputTrackCollection = self.__SiTrackCollection self.__SiTrackCollection = ResolvedTrackCollectionKey # # --- configure Ambiguity (score) solver # from TrkAmbiguitySolver.TrkAmbiguitySolverConf import Trk__TrkAmbiguityScore # from RecExConfig.hideInput import hideInput # hideInput ('TrackCollection', self.__SiTrackCollection) InDetAmbiguityScore = Trk__TrkAmbiguityScore( name='InDetAmbiguityScore' + NewTrackingCuts.extension(), TrackInput=[InputTrackCollection], TrackOutput='ScoredMap' + 'InDetAmbiguityScore' + NewTrackingCuts.extension(), AmbiguityScoreProcessor=InDetAmbiguityScoreProcessor ) ## TODO: check the case when it is None object topSequence += InDetAmbiguityScore if (InDetFlags.doPrintConfigurables()): printfunc(InDetAmbiguityScore) # # --- configure Ambiguity solver # from TrkAmbiguitySolver.TrkAmbiguitySolverConf import Trk__TrkAmbiguitySolver from RecExConfig.hideInput import hideInput hideInput('TrackCollection', self.__SiTrackCollection) InDetAmbiguitySolver = Trk__TrkAmbiguitySolver( name='InDetAmbiguitySolver' + NewTrackingCuts.extension(), TrackInput='ScoredMap' + 'InDetAmbiguityScore' + NewTrackingCuts.extension(), TrackOutput=self.__SiTrackCollection, AmbiguityProcessor=InDetAmbiguityProcessor) topSequence += InDetAmbiguitySolver if (InDetFlags.doPrintConfigurables()): printfunc(InDetAmbiguitySolver) # # --- Delete Silicon Sp-Seeded tracks # from InDetRecExample.ConfiguredInDetSGDeletion import InDetSGDeletionAlg InDetSGDeletionAlg(key=SiSPSeededTrackCollectionKey) if ((NewTrackingCuts.mode() in ["Pixel", "SCT"]) or not InDetFlags.doSGDeletion()): if InDetFlags.doTruth(): # # set up the truth info for this container # include("InDetRecExample/ConfiguredInDetTrackTruth.py") InDetTracksTruth = ConfiguredInDetTrackTruth( self.__SiTrackCollection, self.__SiTrackCollection + "DetailedTruth", self.__SiTrackCollection + "TruthCollection") # # add final output for statistics # TrackCollectionKeys += [InDetTracksTruth.Tracks()] TrackCollectionTruthKeys += [ InDetTracksTruth.TracksTruth() ] else: TrackCollectionKeys += [self.__SiTrackCollection]