def __init__(self, name="ExtrapolTrackToCaloToolBaseUNSET", depth="ETTCTunset", straightLine=False): ExtrapolTrackToCaloTool.__init__(self, name) # call base class constructor from AthenaCommon.Logging import logging mlog = logging.getLogger(name + '(Base)::__init__ ') mlog.info("entering") if name == "ExtrapolTrackToCaloToolBaseUNSET": mlog.info("name should be explicitly set") return if depth == "ETTCTunset": mlog.info("default depth value. OK only if copy") # depth=self._depth # raise RuntimeError,"depth should be explicitly set" return # should instantioate CaloDetDescMger # should instantiate calo ID helper # should instantiate TBCaloCoordinate tool from CaloTrackingGeometry.CaloSurfaceBuilderBase import CaloSurfaceBuilderFactory theCaloSurfaceBuilder = CaloSurfaceBuilderFactory(depth) # public tool from AthenaCommon.AppMgr import ToolSvc ToolSvc += theCaloSurfaceBuilder self.CaloSurfaceBuilder = theCaloSurfaceBuilder from TrkExTools.AtlasExtrapolator import AtlasExtrapolator from AthenaCommon.AppMgr import ToolSvc if not straightLine: theExtrapolator = AtlasExtrapolator() else: theExtrapolator = AtlasExtrapolator( "ATLASExtrapolatorStraightLine") from TrkExSlPropagator.TrkExSlPropagatorConf import Trk__StraightLinePropagator as Propagator SlPropagator = Propagator(name='TTC_SlPropagator') ToolSvc += SlPropagator theExtrapolator.Propagators = [SlPropagator] # need to add to ToolSvc before putting in ToolHandle ToolSvc += theExtrapolator self.Extrapolator = theExtrapolator
def _get_estimator (args, hookargs): from AthenaCommon.AppMgr import ToolSvc if hasattr(ToolSvc, 'AtlasExtrapolator'): AtlasExtrapolator = ToolSvc.AtlasExtrapolator else: from TrkExTools.AtlasExtrapolator import AtlasExtrapolator AtlasExtrapolator = AtlasExtrapolator() ToolSvc += AtlasExtrapolator if hasattr(ToolSvc, 'TrackD3PDLinTrkFactory'): TrackD3PDLinTrkFactory = ToolSvc.TrackD3PDLinTrkFactory else: from TrkVertexFitterUtils.TrkVertexFitterUtilsConf import Trk__FullLinearizedTrackFactory TrackD3PDLinTrkFactory = Trk__FullLinearizedTrackFactory( name = "TrackD3PDFullLinearizedTrackFactory", Extrapolator = AtlasExtrapolator) ToolSvc += TrackD3PDLinTrkFactory if hasattr(ToolSvc, 'TrackD3PDTrackToVertexIPEstimator'): TrackD3PDTrackToVertexIPEstimator = ToolSvc.TrackD3PDTrackToVertexIPEstimator else: from TrkVertexFitterUtils.TrkVertexFitterUtilsConf import Trk__TrackToVertexIPEstimator TrackD3PDTrackToVertexIPEstimator = Trk__TrackToVertexIPEstimator( name="TrackD3PDTrackToVertexIPEstimator", Extrapolator=AtlasExtrapolator, LinearizedTrackFactory=TrackD3PDLinTrkFactory) ToolSvc += TrackD3PDTrackToVertexIPEstimator args['TrackToVertexIPEstimator'] = TrackD3PDTrackToVertexIPEstimator return
def trackIsolationTool_trkelstyle(): from AthenaCommon.AppMgr import ToolSvc IsolBuildTestBLayerTool = None if DetFlags.haveRIO.pixel_on(): from TrkExTools.AtlasExtrapolator import AtlasExtrapolator TrackIsolationExtrapolator = AtlasExtrapolator() ToolSvc += TrackIsolationExtrapolator from InDetTestBLayer.InDetTestBLayerConf import \ InDet__InDetTestBLayerTool IsolBuildTestBLayerTool = InDet__InDetTestBLayerTool \ (name= "IsolBuildTestBLayerTool", PixelSummarySvc = ServiceMgr.PixelConditionsSummarySvc, Extrapolator = TrackIsolationExtrapolator) ToolSvc += IsolBuildTestBLayerTool return trackIsolationTool(name='TrackIsolationTool_trkelstyle', pTMin=0.4 * MeV, IPd0Max=1.5 * mm, IPz0Max=1.0 * mm, nHitBLayer=1, nHitSi=9, nHolesPixel=0, nSharedBLayer=999, nSharedPix=999, nSharedSct=999, nSharedSi=999, d0MaxPreselection=9999, InDetTestBLayerTool=IsolBuildTestBLayerTool)
def getAtlasExtrapolator(): _name = sPrefix + 'theAtlasExtrapolator' from AthenaCommon.AppMgr import ToolSvc if _name in cached_instances: return cached_instances[_name] #Configure the extrapolator from TrkExTools.AtlasExtrapolator import AtlasExtrapolator theAtlasExtrapolator=AtlasExtrapolator(name = _name) theAtlasExtrapolator.DoCaloDynamic = False # this turns off dynamic ToolSvc += theAtlasExtrapolator cached_instances[_name] = theAtlasExtrapolator return theAtlasExtrapolator
def __init__(self, suffix, buildconfigs=[], refconfigs=[], doTracks=False, doSum=False, doRegions=False, doCells=False, doTriggerMET=True, duplicateWarning=True, doOriginCorrClus=False): print(prefix, 'Creating MET config \'' + suffix + '\'') self.suffix = suffix self.doSum = doSum self.doTracks = doTracks self.doRegions = doRegions self.doCells = doCells, self.doOriginCorrClus = doOriginCorrClus self.doTriggerMET = doTriggerMET self.duplicateWarning = duplicateWarning # self.builders = {} self.buildlist = [] # need an ordered list # self.refiners = {} self.reflist = [] # need an ordered list # self.regions = {} self.reglist = [] # need an ordered list if doRegions: self.setupRegions(buildconfigs) # self.trkseltool = CfgMgr.InDet__InDetTrackSelectionTool( "IDTrkSel_MET", CutLevel="TightPrimary", maxZ0SinTheta=3, maxD0=2, minPt=500) self.trkvxtool = CfgMgr.CP__TrackVertexAssociationTool( "TrackVertexAssociationTool_MET", WorkingPoint="Nominal") self.trkisotool = CfgMgr.xAOD__TrackIsolationTool( "TrackIsolationTool_MET") self.trkisotool.TrackSelectionTool = self.trkseltool # As configured above from TrackToCalo.TrackToCaloConf import Trk__ParticleCaloExtensionTool, Rec__ParticleCaloCellAssociationTool from TrkExTools.AtlasExtrapolator import AtlasExtrapolator CaloExtensionTool = Trk__ParticleCaloExtensionTool( Extrapolator=AtlasExtrapolator()) CaloCellAssocTool = Rec__ParticleCaloCellAssociationTool( ParticleCaloExtensionTool=CaloExtensionTool) self.caloisotool = CfgMgr.xAOD__CaloIsolationTool( "CaloIsolationTool_MET", saveOnlyRequestedCorrections=True, addCaloExtensionDecoration=False, ParticleCaloExtensionTool=CaloExtensionTool, ParticleCaloCellAssociationTool=CaloCellAssocTool) self.setupBuilders(buildconfigs) self.setupRefiners(refconfigs)
def toolJetFitterExtrapolator(name, useBTagFlagsDefaults=True, **options): """Sets up a JetFitterExtrapolator tool and returns it. input: name: The name of the tool (should be unique). useBTagFlagsDefaults : Whether to use BTaggingFlags defaults for options that are not specified. **options: Python dictionary with options for the tool. output: The actual tool, which can then by added to ToolSvc via ToolSvc += output.""" from TrkExTools.AtlasExtrapolator import AtlasExtrapolator return AtlasExtrapolator(**options)
def __init__(self, name = 'AtlasVKalVxInJetFinder' ): from __main__ import ToolSvc mlog = logging.getLogger( 'AtlasVKalVxInJetFinder::__init__ ' ) mlog.info("entering") #----------------- ATLAS magnetic field from AthenaCommon.AppMgr import ServiceMgr from MagFieldServices.MagFieldServicesConf import MagField__AtlasFieldSvc ServiceMgr += MagField__AtlasFieldSvc("myAtlasFieldSvc"); #----------------- ATLAS extrapolator from TrkExTools.AtlasExtrapolator import AtlasExtrapolator SVAtlasExtrapolator=AtlasExtrapolator() ToolSvc+=SVAtlasExtrapolator #-------------------------- from TrkTrackSummaryTool.AtlasTrackSummaryTool import AtlasTrackSummaryTool SVAtlasTrackSummaryTool = AtlasTrackSummaryTool() ToolSvc += SVAtlasTrackSummaryTool #------------------------- # TrackParticle creator # from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool SVParticleCreatorTool = Trk__TrackParticleCreatorTool(name="SVParticleCreatorTool", TrackSummaryTool=SVAtlasTrackSummaryTool, UseTrackSummaryTool=False ) ToolSvc += SVParticleCreatorTool #---------------------- # VKalVrt vertex fitter # from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter SVertexFitterTool = Trk__TrkVKalVrtFitter(name="SVertexFitterTool", Extrapolator=SVAtlasExtrapolator, AtlasMagFieldSvc = "myAtlasFieldSvc" ) ToolSvc += SVertexFitterTool #---------------------- # Secondary vertex finder itself # from TrkVertexFitterUtils.TrkVertexFitterUtilsConf import Trk__FullLinearizedTrackFactory SVLinearizedTrackFactory = Trk__FullLinearizedTrackFactory(name="SVLinearizedTrackFactory",Extrapolator = SVAtlasExtrapolator) ToolSvc += SVLinearizedTrackFactory from TrkVertexFitterUtils.TrkVertexFitterUtilsConf import Trk__TrackToVertexIPEstimator SVTrackToVertexIPEstimator = Trk__TrackToVertexIPEstimator(name="SVTrackToVertexIPEstimator", Extrapolator = SVAtlasExtrapolator, LinearizedTrackFactory=SVLinearizedTrackFactory) ToolSvc += SVTrackToVertexIPEstimator InDet__InDetVKalVxInJetTool.__init__( self, name = name, VertexFitterTool = SVertexFitterTool, TrackParticleCreator = SVParticleCreatorTool, TrackSummaryTool = SVAtlasTrackSummaryTool, TrackToVertexTool = SVTrackToVertexIPEstimator )
def TrackDepositInCaloTool(name='TrackDepositInCaloTool', **kwargs): from TrkExTools.AtlasExtrapolator import AtlasExtrapolator from TrackToCalo.TrackToCaloConf import Rec__ParticleCaloCellAssociationTool caloCellAssociationTool = Rec__ParticleCaloCellAssociationTool( ParticleCaloExtensionTool=getPublicTool( "MuonParticleCaloExtensionTool")) kwargs.setdefault("ExtrapolatorHandle", AtlasExtrapolator()) kwargs.setdefault("ParticleCaloExtensionTool", getPublicTool("MuonParticleCaloExtensionTool")) kwargs.setdefault("ParticleCaloCellAssociationTool", caloCellAssociationTool) return CfgMgr.TrackDepositInCaloTool(name, **kwargs)
def ConfigurationComboHypo(self, trigSequenceName='Dimu', trigLevel='L2', trackCollection='', muonCollection=''): trigLevelDict = {'L2': 0, 'EF': 1} try: value = trigLevelDict[trigLevel] log.debug('TrigMultiTrkComboHypo.trigLevel = %s ', value) except KeyError: log.error( 'TrigMultiTrkComboHypo.trigLevel should be L2 or EF, but %s provided.', trigLevel) from TrkExTools.AtlasExtrapolator import AtlasExtrapolator from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter VertexFitter = Trk__TrkVKalVrtFitter(name='TrigBphysFitter_' + trigSequenceName + trigLevel, FirstMeasuredPoint=False, MakeExtendedVertex=False, Extrapolator=AtlasExtrapolator()) from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__VertexPointEstimator VertexPointEstimator = InDet__VertexPointEstimator( name='VertexPointEstimator_' + trigSequenceName + trigLevel, MinDeltaR=[-10000., -10000., -10000.], MaxDeltaR=[10000., 10000., 10000.], MaxPhi=[10000., 10000., 10000.], MaxChi2OfVtxEstimation=2000.) tool = TrigMultiTrkComboHypo( name=trigSequenceName + trigLevel + 'ComboHypo', trigLevel=trigLevel, nTracks=2, massRanges=[(100., 20000.)], TrackCollectionKey=trackCollection, MuonCollectionKey=muonCollection, VertexFitter=VertexFitter, VertexPointEstimator=VertexPointEstimator, CheckMultiplicityMap=False, MonTool=TrigMultiTrkComboHypoMonitoring( 'TrigMultiTrkComboHypoMonitoring_' + trigSequenceName + trigLevel)) if trigLevel == 'EF': tool.TrigBphysCollectionKey = 'HLT_' + trigSequenceName + trigLevel return tool
def toolAtlasExtrapolator(name, useBTagFlagsDefaults = True, **options): """Sets up a AtlasExtrapolator tool and returns it. input: name: The name of the tool (should be unique). useBTagFlagsDefaults : Whether to use BTaggingFlags defaults for options that are not specified. (this function does not have any though, just here for consistency). **options: Python dictionary with options for the tool. output: The actual tool, which can then be added to ToolSvc via ToolSvc += output.""" if useBTagFlagsDefaults: defaults = {} for option in defaults: options.setdefault(option, defaults[option]) options['name'] = name from TrkExTools.AtlasExtrapolator import AtlasExtrapolator return AtlasExtrapolator(**options)
def TMEF_MuonCreatorTool(name="TMEF_MuonCreatorTool", **kwargs): from TrkExTools.AtlasExtrapolator import AtlasExtrapolator from TrackToCalo.TrackToCaloConf import Trk__ParticleCaloExtensionTool pcExtensionTool = Trk__ParticleCaloExtensionTool( Extrapolator=AtlasExtrapolator()) kwargs.setdefault("ParticleCaloExtensionTool", pcExtensionTool) kwargs.setdefault('TrackParticleCreator', 'TMEF_TrkToTrackParticleConvTool') kwargs.setdefault("AmbiguityProcessor", CfgGetter.getPublicTool('TrigMuonAmbiProcessor')) kwargs.setdefault('MakeTrackAtMSLink', True) kwargs.setdefault("CaloMaterialProvider", "TMEF_TrkMaterialProviderTool") kwargs.setdefault("FillTimingInformation", False) kwargs.setdefault("MuonSelectionTool", "") kwargs.setdefault("TrackQuery", "TMEF_MuonTrackQuery") kwargs.setdefault("TrackSummaryTool", "TMEF_TrackSummaryTool") return CfgMgr.MuonCombined__MuonCreatorTool(name, **kwargs)
def setup(self): mlog = logging.getLogger( 'eflowSetupParticleCreator::setup' ) try: from AthenaCommon.AppMgr import ToolSvc except: mlog.error("could not import ToolSvc") print traceback.format_exc() return False try: from TrkExTools.AtlasExtrapolator import AtlasExtrapolator eflowExtrapolator = AtlasExtrapolator(name = "eflowExtrapolator") except: mlog.error("could not import AtlasExtrapolator from TrkExTools.AtlasExtrapolator") print traceback.format_exc() return False ToolSvc+=eflowExtrapolator try: from TrkTrackSummaryTool.AtlasTrackSummaryTool import AtlasTrackSummaryTool eflowTrackSummaryTool = AtlasTrackSummaryTool(name = "eflowTrackSummaryTool") except: mlog.error("could not import AtlasTrackSummaryTool from TrkTrackSummaryTool.AtlasTrackSummaryTool") print traceback.format_exc() return False ToolSvc+=eflowTrackSummaryTool try: from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool eflowParticleCreatorTool = Trk__TrackParticleCreatorTool(name = "eflowParticleCreatorTool",Extrapolator = eflowExtrapolator, TrackSummaryTool = eflowTrackSummaryTool) except: mlog.error("could not import Trk__TrackParticleCreatorTool from TrkParticleCreator.TrkParticleCreatorConf") print traceback.format_exc() return False ToolSvc += eflowParticleCreatorTool return eflowParticleCreatorTool
#ServiceMgr.EventSelector.InputCollections += ["castor:/castor/cern.ch/grid/atlas/datafiles/egamma/DC3.007040.singlepart_gamma_Et20/digit/120031/ideal0_mc12.007040.singlepart_gamma_Et20.digit.RDO.v12003108_tid005022._00002.pool.root"] # --- black hole event #ServiceMgr.EventSelector.InputCollections = ["castor:/castor/cern.ch/user/j/jgoncalo/valid12003108/misal1_mc12.006640.CharybdisJimmy.digit.RDO.v12003108_tid006066._00038.pool.root.4"] # --- event with low lumi pile up (4.6 min bias, 2*10^33), should be ATLAS-CSC-01-02-00 #ServiceMgr.EventSelector.InputCollections = ["castor:/castor/cern.ch/user/k/kgrybel/pileup/CSC/005850.pyt_WH120_munubb/digits/misal1_csc11.005850.WH120bb_pythia.digit.RDOS.v12003103_lumi02._00001.pool.root"] if doReadBS: # input used for FDR2b (run 8): low lumi (2.3 min bias, 10^33)/pile-up/shifted vertex run 8 # this file needs (as set by default): DetDescrVersion = "ATLAS-CSC-02-00-00" globalflags.ConditionsTag="OFLCOND-FDR-02-01-00", jobproperties.Beam.numberOfCollisions = 2.3 ServiceMgr.ByteStreamInputSvc.FullFileName = [ "/tmp/jahreda/data11_7TeV.00191628.physics_ZeroBias.merge.RAW/data11_7TeV.00191628.physics_ZeroBias.merge.RAW._lb0216._SFO-ALL._0001.1"] # if you create the input BS file yourself with InDetWriteBS jobO the output will be this file # and you have to set the detdescr and cond tag to what you used ... #ServiceMgr.ByteStreamInputSvc.FullFileName = [ "daq.csc13.0000000.Single.Stream.LB0000.Athena._0001.data" ] from TrkExTools.AtlasExtrapolator import AtlasExtrapolator theAtlasExtrapolator = AtlasExtrapolator() ToolSvc += theAtlasExtrapolator from TRT_TrackHoleSearch.TRT_TrackHoleSearchConf import TRTTrackHoleSearchTool theTRTTrackHoleSearchTool = TRTTrackHoleSearchTool( OutputLevel = WARNING, extrapolator = theAtlasExtrapolator, conditions_svc = InDetTRTConditionsSummaryService, # defined in InDetRec_all.py use_conditions_svc = True, do_dump_bad_straw_log = False, begin_at_first_trt_hit = False, # if not, extrapolate from last Si hit end_at_last_trt_hit = False, # if not, continue hole search to the edge of the TRT max_trailing_holes = 1, # only used if end_at_last_trt_hit=False locR_cut = -1, # 1.4*mm # negative means no cut locR_sigma_cut = -1)
# ------------------------ # SET UP FITTER # ------------------------ # User's analysis requirements here: # ---------------------------------- from TrkExTools.AtlasExtrapolator import AtlasExtrapolator InDetExtrapolator = AtlasExtrapolator(name="AtlasExtrapolator") ToolSvc += InDetExtrapolator print InDetExtrapolator from TrkV0Fitter.TrkV0FitterConf import Trk__TrkV0VertexFitter TrkV0Fitter = Trk__TrkV0VertexFitter(name="TrkV0FitterName", MaxIterations=10, Use_deltaR=False, Extrapolator=InDetExtrapolator) ToolSvc += TrkV0Fitter print TrkV0Fitter from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter TrkVKalVrtFitter = Trk__TrkVKalVrtFitter(name="VKalVrtFitter", Extrapolator=InDetExtrapolator, FirstMeasuredPoint=False, MakeExtendedVertex=True) ToolSvc += TrkVKalVrtFitter print TrkVKalVrtFitter from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__VertexPointEstimator VtxPointEstimator = InDet__VertexPointEstimator( name="VtxPointEstimator",
#from AthenaCommon.AlgSequence import AlgSequence #topSequence = AlgSequence() topSequence.InDetPriVxFinder.TracksName = "AdjustedTrackParticleCandidate" topSequence.InDetPriVxFinder.VxCandidatesOutputName = "AdjustedVxPrimaryCandidate" ToolSvc.NewJetFitterVxFinder.VxPrimaryContainer = "AdjustedVxPrimaryCandidate" ToolSvc.NewJetFitterVxFinderFlip.VxPrimaryContainer = "AdjustedVxPrimaryCandidate" JetTagD3PDFlags.PrimaryVertexSGKey = "AdjustedVxPrimaryCandidate" JetTagD3PDFlags.TruthTrackParticleSGKey = "AdjustedTrackParticleTruthCandidate" JetTagD3PDFlags.TrackParticleSGKey = "AdjustedTrackParticleCandidate" from AthenaCommon.AppMgr import ToolSvc from TrkExTools.AtlasExtrapolator import AtlasExtrapolator if hasattr(ToolSvc, "AtlasExtrapolator"): JetTagD3PDAdjustTracks.Extrapolator = ToolSvc.AtlasExtrapolator else: myextrap = AtlasExtrapolator() ToolSvc += myextrap JetTagD3PDAdjustTracks.Extrapolator = myextrap
def trackIsolationTool(name, doTrackIsolation=False, doSumConversionTracks=True, trackParticleCollection='TrackParticleCandidate', conversionContainer='ConversionCandidate', calorimeterCellContainer=None, onlyEM=False, coreDeltaR=0.05, trackToVertexTool=None, trackSummaryTool=None, extrapolator=None, trackSelector=None, pTMin=1000 * MeV, IPd0Max=10.0 * mm, IPz0Max=10.0 * mm, z0Max=10.0 * mm, useTrackSummaryInfo=True, nHitBLayer=0, nHitPix=0, nHitBLayerPlusPix=0, nHitSct=0, nHitSi=4, nHitTrt=0, useTrackQualityInfo=False, **kw): from AthenaCommon.AppMgr import ToolSvc if calorimeterCellContainer == None: calorimeterCellContainer = \ 'AODCellContainer' if rec.readAOD() else 'AllCalo' if trackToVertexTool == None: from TrackToVertex.TrackToVertexConf import Reco__TrackToVertex trackToVertexTool = Reco__TrackToVertex() ToolSvc += trackToVertexTool if trackSummaryTool == None: from TrkTrackSummaryTool.AtlasTrackSummaryTool import AtlasTrackSummaryTool trackSummaryTool = AtlasTrackSummaryTool() ToolSvc += trackSummaryTool if extrapolator == None: from TrkExTools.AtlasExtrapolator import AtlasExtrapolator extrapolator = AtlasExtrapolator() ToolSvc += extrapolator if trackSelector == None: selname = name + 'TrackSelector' from AthenaCommon.BeamFlags import jobproperties if (jobproperties.Beam.beamType() == 'cosmics' or jobproperties.Beam.beamType() == 'singlebeam'): trackSelector = InDet__InDetDetailedTrackSelectorTool( name=selname, pTMin=0 * MeV, IPd0Max=9999 * mm, IPz0Max=9999 * mm, z0Max=9999 * mm, useTrackSummaryInfo=False, useTrackQualityInfo=False, TrackSummaryTool=trackSummaryTool, Extrapolator=extrapolator) else: trackSelector = InDet__InDetDetailedTrackSelectorTool( name=selname, pTMin=pTMin, IPd0Max=IPd0Max, IPz0Max=IPz0Max, z0Max=z0Max, useTrackSummaryInfo=useTrackSummaryInfo, nHitBLayer=nHitBLayer, nHitPix=nHitPix, nHitBLayerPlusPix=nHitBLayerPlusPix, nHitSct=nHitSct, nHitSi=nHitSi, nHitTrt=nHitTrt, useTrackQualityInfo=useTrackQualityInfo, TrackSummaryTool=trackSummaryTool, Extrapolator=extrapolator, **kw) ToolSvc += trackSelector tool = TrackIsolationTool(name, DoTrackIsolation=doTrackIsolation, DoSumConversionTracks=doSumConversionTracks, TrackParticleCollection=trackParticleCollection, ConversionContainer=conversionContainer, CaloCellContainer=calorimeterCellContainer, OnlyEM=onlyEM, CoreDeltaR=coreDeltaR, ExtrapolTrackToCaloTool=ToolSvc.TrackInCaloTools, TrackToVertex=trackToVertexTool, TrackSelector=trackSelector) ToolSvc += tool return tool
#------------------------------------------------------------------------------ # Magnetic field tool #------------------------------------------------------------------------------ from TrkMagFieldTools.TrkMagFieldToolsConf import Trk__MagneticFieldTool InDetMagField = Trk__MagneticFieldTool('InDetMagField') ToolSvc += InDetMagField print InDetMagField #------------------------------------------------------------------------------ # Set up extrapolator #------------------------------------------------------------------------------ from TrkExTools.AtlasExtrapolator import AtlasExtrapolator InDetExtrapolator = AtlasExtrapolator() ToolSvc += InDetExtrapolator print InDetExtrapolator #------------------------------------------------------------------------------ # Vertex point estimator #------------------------------------------------------------------------------ from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__VertexPointEstimator VtxPointEstimator = InDet__VertexPointEstimator(name = 'VtxPointEstimator', MinDeltaR = [ -10000., -10000., -10000. ], MaxDeltaR = [ 10000., 10000., 10000. ], MaxPhi = [ 10000., 10000., 10000. ], MaxChi2OfVtxEstimation = 2000.) ToolSvc += VtxPointEstimator
def getPhotonConversionTool(): if jobproperties.tauRecFlags.useVertexBasedConvFinder(): from AthenaCommon.AppMgr import ToolSvc name = "_PhotonConversionVertex" ## from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator as MaterialEffectsUpdator AtlasMaterialEffectsUpdator = MaterialEffectsUpdator( name='AtlasMaterialEffectsUpdator') ToolSvc += AtlasMaterialEffectsUpdator #default material effects updator NoElossMaterialEffectsUpdator = MaterialEffectsUpdator( name='NoElossMaterialEffectsUpdator') NoElossMaterialEffectsUpdator.EnergyLoss = False ToolSvc += NoElossMaterialEffectsUpdator # setup MaterialEffectsUpdator arrays MyUpdators = [] MyUpdators += [AtlasMaterialEffectsUpdator] # for ID MyUpdators += [NoElossMaterialEffectsUpdator] # for Calo # MyUpdators += [NoElossMaterialEffectsUpdator] # for muon MySubUpdators = [] MySubUpdators += [AtlasMaterialEffectsUpdator.name()] # for ID MySubUpdators += [NoElossMaterialEffectsUpdator.name()] # for Calo MySubUpdators += [NoElossMaterialEffectsUpdator.name()] # for muon #Configure the extrapolator from TrkExTools.AtlasExtrapolator import AtlasExtrapolator theAtlasExtrapolator = AtlasExtrapolator(name='theAtlasExtrapolator' + name) theAtlasExtrapolator.DoCaloDynamic = False # this turns off dynamic theAtlasExtrapolator.MaterialEffectsUpdators = MyUpdators theAtlasExtrapolator.SubMEUpdators = MySubUpdators ToolSvc += theAtlasExtrapolator # from TrkMagFieldTools.TrkMagFieldToolsConf import Trk__MagneticFieldTool # InDetMagField = Trk__MagneticFieldTool('InDetMagField'+name) # ToolSvc += InDetMagField ### Ly S swith bellow off Oct 7 # from AthenaCommon.AppMgr import ServiceMgr # from MagFieldServices.MagFieldServicesConf import MagField__AtlasFieldSvc # ServiceMgr += MagField__AtlasFieldSvc("myAtlasFieldSvc") # # Setup track summary tool # from InDetAssociationTools.InDetAssociationToolsConf import InDet__InDetPRD_AssociationToolGangedPixels tauInDetPrdAssociationTool = InDet__InDetPRD_AssociationToolGangedPixels( name="tauInDetPrdAssociationTool", PixelClusterAmbiguitiesMapName='PixelClusterAmbiguitiesMap') ToolSvc += tauInDetPrdAssociationTool from InDetRecExample.InDetJobProperties import InDetFlags from InDetTrackHoleSearch.InDetTrackHoleSearchConf import InDet__InDetTrackHoleSearchTool tauInDetHoleSearchTool = InDet__InDetTrackHoleSearchTool( name="tauInDetHoleSearchTool", Extrapolator=theAtlasExtrapolator, checkBadSCTChip=InDetFlags.checkDeadElementsOnTrack()) ToolSvc += tauInDetHoleSearchTool from AthenaCommon.DetFlags import DetFlags from InDetTrackSummaryHelperTool.InDetTrackSummaryHelperToolConf import InDet__InDetTrackSummaryHelperTool tauInDetTrackSummaryHelperTool = InDet__InDetTrackSummaryHelperTool( name="tauInDetTrackSummaryHelper", AssoTool=tauInDetPrdAssociationTool, DoSharedHits=False, HoleSearch=tauInDetHoleSearchTool, usePixel=DetFlags.haveRIO.pixel_on(), useSCT=DetFlags.haveRIO.SCT_on(), useTRT=DetFlags.haveRIO.TRT_on()) ToolSvc += tauInDetTrackSummaryHelperTool # from TrkTrackSummaryTool.AtlasTrackSummaryTool import AtlasTrackSummaryTool # MyInDetTrackSummaryTool = AtlasTrackSummaryTool( # InDetSummaryHelperTool = tauInDetTrackSummaryHelperTool, # doSharedHits = False ) from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool MyInDetTrackSummaryTool = Trk__TrackSummaryTool( name="MyInDetTrackSummaryTool", InDetSummaryHelperTool=tauInDetTrackSummaryHelperTool, doSharedHits=False, InDetHoleSearchTool=tauInDetHoleSearchTool) ToolSvc += MyInDetTrackSummaryTool from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter InDetConversionVxFitterTool = Trk__TrkVKalVrtFitter( name="InDetConversionVxFitter" + name, Extrapolator=theAtlasExtrapolator, # Extrapolator = "Trk::Extrapolator/AtlasExtrapolator", IterationNumber=30, MakeExtendedVertex=True, FirstMeasuredPoint=False, # MagFieldSvc = InDetMagField, ## MagFieldSvc="Trk::MagneticFieldTool/InDetMagField", # AtlasMagFieldSvc="myAtlasFieldSvc", Robustness=6, usePhiCnst=True, useThetaCnst=True, FirstMeasuredPointLimit=True, InputParticleMasses=[0.511, 0.511], VertexForConstraint=[0., 0., 0.], CovVrtForConstraint=[ 0.015 * 0.015, 0., 0.015 * 0.015, 0., 0., 10000. * 10000. ]) ToolSvc += InDetConversionVxFitterTool print InDetConversionVxFitterTool # Distance of minimum approach utility # from TrkVertexSeedFinderUtils.TrkVertexSeedFinderUtilsConf import Trk__SeedNewtonTrkDistanceFinder InDetConversionTrkDistanceFinder = Trk__SeedNewtonTrkDistanceFinder( name='InDetConversionTrkDistanceFinder' + name) ToolSvc += InDetConversionTrkDistanceFinder print InDetConversionTrkDistanceFinder # Straight line propagator needed to clean-up single track conversions # # from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as Propagator # Helper Tool # from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__ConversionFinderUtils InDetConversionHelper = InDet__ConversionFinderUtils( name="InDetConversionFinderUtils" + name) ToolSvc += InDetConversionHelper print InDetConversionHelper # Track selector tool # from InDetTrackSelectorTool.InDetTrackSelectorToolConf import InDet__InDetConversionTrackSelectorTool InDetConversionTrackSelector = InDet__InDetConversionTrackSelectorTool( name="InDetConversionTrackSelector" + name, TrackSummaryTool=MyInDetTrackSummaryTool, Extrapolator=theAtlasExtrapolator, maxSiD0=10000., #50.0, maxTrtD0=10000., #100., maxSiZ0=10000., #350.0, maxTrtZ0=10000., #1400., minPt=300, #InDetNewTrackingCuts.minSecondaryPt() RatioCut1=0.0, #0.5, RatioCut2=0.05, RatioCut3=0.05, RatioTRT=0.05, IsConversion=True, significanceD0_Si=-1., RatioV0=-1.) ToolSvc += InDetConversionTrackSelector print InDetConversionTrackSelector # Track pairs selector # ## There are many tunings on Oct 5 from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__TrackPairsSelector InDetConversionTrackPairsSelector = InDet__TrackPairsSelector( name="InDetConversionTrackPairsSelector" + name, ConversionFinderHelperTool=InDetConversionHelper, DistanceTool=InDetConversionTrkDistanceFinder, # MaxEta = [0.12,10000.,10000.], #[0.5,1.0,0.5]) MaxEta=[0.15, 0.3, 0.5], #[0.5,1.0,0.5]) # MaxDistBetweenTracks = [6.6,10000.,10000.], #[6.,80.,30.] MaxDistBetweenTracks=[7.5, 15., 30.], #[6.,80.,30.] MaxInitDistance=[10000., 10000., 10000.], MinTrackAngle=0.) ToolSvc += InDetConversionTrackPairsSelector print InDetConversionTrackPairsSelector # Vertex point estimator # from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__VertexPointEstimator InDetConversionVtxPointEstimator = InDet__VertexPointEstimator( name="InDetConversionVtxPointEstimator" + name, MaxTrkXYDiffAtVtx=[10000., 10000., 10000.], MaxTrkZDiffAtVtx=[10000., 10000., 10000.], MaxTrkXYValue=[10000., 10000., 10000.], MinArcLength=[-10000., -10000., -10000.], MaxArcLength=[10000., 10000., 10000.], MinDeltaR=[-5., -25., -50.], # MaxDeltaR = [10000.,10000.,10000.], MaxDeltaR=[5., 10., 10.], # MaxHl = [10000.,10000.,10000.], # MaxPhi = [0.034, 10000., 10000.] #[0.05, 0.1, 0.1] # MaxPhi = [ 10000., 10000., 10000.] MaxPhi=[0.05, 0.1, 0.2]) ToolSvc += InDetConversionVtxPointEstimator print InDetConversionVtxPointEstimator # Conversion post selector # from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__ConversionPostSelector InDetConversionPostSelector = InDet__ConversionPostSelector( name="InDetConversionPostSelector" + name, # MaxChi2Vtx = [10000.,10000.,10000.], #[40.,100.,80.], MaxChi2Vtx=[500., 700., 900.], #[40.,100.,80.], # MaxInvariantMass = [45.,25000.,25000.], #[60.,60.,30.], MaxInvariantMass=[350., 400., 500.], #[60.,60.,30.], MinFitMomentum=[0., 0., 0.], #[2000.,2000.,2000.], MinRadius=[21, 20., 15.], #[30.,35.,250.], # MinRadius = [ -10000.0, -10000.0, -10000.0 ], #[30.,35.,250.], MinPt=0., # MaxdR = 10000., #-250., ## equivalent to InDetConversionFinderTools.MaxDistVtxHit MaxdR=-10000., #-250., # MaxPhiVtxTrk = 0.046 #0.2 MaxPhiVtxTrk=0.05) ToolSvc += InDetConversionPostSelector print InDetConversionPostSelector # Single track conversion tool # from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__SingleTrackConversionTool InDetSingleTrackConversion = InDet__SingleTrackConversionTool( name="InDetSingleTrackConversionTool" + name, ConversionFinderHelperTool=InDetConversionHelper, TrackSummaryTool=MyInDetTrackSummaryTool, Extrapolator=theAtlasExtrapolator, MaxBLayerHits=0, MinInitialHitRadius=70., MinInitialHitRadius_noBlay=90., MinRatioOfHLhits=0.95) ToolSvc += InDetSingleTrackConversion print InDetSingleTrackConversion ## Oct 5, following egamma from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__InDetConversionFinderTools MyInDetConversionFinderTools = InDet__InDetConversionFinderTools( name="InDetConversionFinderTools" + name, VertexFitterTool=InDetConversionVxFitterTool, TrackSelectorTool=InDetConversionTrackSelector, TrackPairsSelector=InDetConversionTrackPairsSelector, ConversionFinderHelperTool=InDetConversionHelper, VertexPointEstimator=InDetConversionVtxPointEstimator, PostSelector=InDetConversionPostSelector, SingleTrackConversionTool=InDetSingleTrackConversion, Extrapolator=theAtlasExtrapolator, TrackParticleCollection="InDetTrackParticles", # MinDistVtxHit = -10000., MinDistVtxHit=-350., MaxDistVtxHit=230., MinFlightAngle=0.0, MinInitVtxR=0.0, RemoveTrtTracks=False, IsConversion=True) ToolSvc += MyInDetConversionFinderTools print MyInDetConversionFinderTools from tauRecTools.tauRecToolsConf import PhotonConversionVertex photonConv = PhotonConversionVertex( name="PhotonConversionVertex", TauRecContainer="TauJets", TrackParticleContainer="InDetTrackParticles", OutputConversionVertexContainerName="ConversionsVertex_Container", MaxTauJetDr=0.5, ConversionFinderTool=MyInDetConversionFinderTools) return photonConv else: from tauRecTools.tauRecToolsConf import PhotonConversionPID photonConv = PhotonConversionPID( ConversionCandidatesName="ConversionCandidate", ConversionOutputName="ConversionsPID_Container", ElectronProbability=0.9) return photonConv
include.block ( "MuonSegmentTaggerTools/MuonSegmentTaggerTools_jobOptions.py" ) #----------------------------------------------------------------- from TrkExTools.AtlasExtrapolator import AtlasExtrapolator MuTagExtrapolator = AtlasExtrapolator() from TrackToSegmentTools.TrackToSegmentToolsConf import TrackToSegmentTool ConfiguredForAllStationsTrackToSegmentTool = TrackToSegmentTool( name = "ConfiguredForAllStationsTrackToSegmentTool" , IExtrapolator = MuTagExtrapolator , addMultipleScattering = 0 , ReverseIDTrack = 0 ) ToolSvc += ConfiguredForAllStationsTrackToSegmentTool #print ConfiguredForAllStationsTrackToSegmentTool #-------------------------------------------------------------------------------------------------------------------------- from TrkTrackSummaryTool.AtlasTrackSummaryTool import AtlasTrackSummaryTool TrkTrackSummaryToolFORMuTagIMOInDetDetailedTrackSelectorTool = AtlasTrackSummaryTool() ToolSvc += TrkTrackSummaryToolFORMuTagIMOInDetDetailedTrackSelectorTool from InDetTrackSelectorTool.InDetTrackSelectorToolConf import InDet__InDetDetailedTrackSelectorTool from AthenaCommon.GlobalFlags import globalflags from RecExConfig.RecFlags import rec MuTagIMOInDetDetailedTrackSelectorTool = InDet__InDetDetailedTrackSelectorTool( name = "MuTagIMOInDetDetailedTrackSelectorTool", pTMin = 2000*MeV, IPd0Max = 50.0*mm, IPz0Max = 9999.0*mm, z0Max = 9999.0*mm, useTrackSummaryInfo = False, nHitBLayer = 0,
def __init__(self,name = 'AtlasTrackSummaryTool'): from AthenaCommon.AppMgr import ToolSvc # # Setup Atlas Extrapolator # from TrkExTools.AtlasExtrapolator import AtlasExtrapolator AtlasExtrapolator = AtlasExtrapolator() ToolSvc += AtlasExtrapolator # # Setup Association Tool # from InDetAssociationTools.InDetAssociationToolsConf import InDet__InDetPRD_AssociationToolGangedPixels AtlasPrdAssociationTool = InDet__InDetPRD_AssociationToolGangedPixels( name = "AtlasPrdAssociationTool", PixelClusterAmbiguitiesMapName = "PixelClusterAmbiguitiesMap" ) ToolSvc += AtlasPrdAssociationTool #print AtlasPrdAssociationTool # # Setup Boundary Check Tool # from InDetBoundaryCheckTool.InDetBoundaryCheckToolConf import InDet__InDetBoundaryCheckTool AtlasBoundaryCheckTool = InDet__InDetBoundaryCheckTool( name="AtlasBoundaryCheckTool", UsePixel = DetFlags.haveRIO.pixel_on(), UseSCT = DetFlags.haveRIO.SCT_on() ) ToolSvc += AtlasBoundaryCheckTool # # Loading Configurable HoleSearchTool # from InDetTrackHoleSearch.InDetTrackHoleSearchConf import InDet__InDetTrackHoleSearchTool AtlasHoleSearchTool = InDet__InDetTrackHoleSearchTool(name = "AtlasHoleSearchTool", Extrapolator = AtlasExtrapolator, BoundaryCheckTool=AtlasBoundaryCheckTool ) ToolSvc += AtlasHoleSearchTool #print AtlasHoleSearchTool # # Configrable version of loading the AtlasTrackSummaryHelperTool # from InDetTrackSummaryHelperTool.InDetTrackSummaryHelperToolConf import InDet__InDetTrackSummaryHelperTool if DetFlags.haveRIO.TRT_on(): AtlasTrackSummaryHelperTool = InDet__InDetTrackSummaryHelperTool( name = "AtlasTrackSummaryHelperTool", HoleSearch = AtlasHoleSearchTool, AssoTool = AtlasPrdAssociationTool, DoSharedHits = False ) else: AtlasTrackSummaryHelperTool = InDet__InDetTrackSummaryHelperTool( name = "AtlasTrackSummaryHelperTool", HoleSearch = AtlasHoleSearchTool, AssoTool = AtlasPrdAssociationTool, DoSharedHits = False, TRTStrawSummarySvc = "" ) ToolSvc += AtlasTrackSummaryHelperTool #print AtlasTrackSummaryHelperTool # # Configurable version of TrkTrackSummaryTool # from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool AtlasTrackSummaryTool = Trk__TrackSummaryTool( ) # call the base class constructor Trk__TrackSummaryTool.__init__(self, name = name, InDetSummaryHelperTool = AtlasTrackSummaryHelperTool, doHolesOnTrack = True, doSharedHits = AtlasTrackSummaryHelperTool.DoSharedHits )
include("LArConditionsCommon/LArIdMap_MC_jobOptions.py") #Extrapolator: if vp1Extrapolator and (vp1ID or vp1Muon): # Force tool initializations needed by the extrapolator from VP1TrkAuxAlgs.VP1TrkAuxAlgsConf import VP1TrkInitializer VP1TrkInitializer = VP1TrkInitializer() VP1TrkInitializer.ForceExtrapolatorTools = True topSequence += VP1TrkInitializer if not vp1Fatras and vp1Mc: include('TrkDetDescrSvc/AtlasTrackingGeometrySvc.py') from TrkExTools.AtlasExtrapolator import AtlasExtrapolator VP1ExtraPolatorName = 'VP1Extrapolator' VP1Extrapolator = AtlasExtrapolator(name=VP1ExtraPolatorName) # Previous config from SetupFitters.py # from TrkExTools.TrkExToolsConf import Trk__Extrapolator as Extrapolator # VP1Extrapolator = Extrapolator(name='VP1Extrapolator', # Navigator = VP1Navigator, # MaterialEffectsUpdators = [ VP1MaterialUpdator ], # Propagators = [ VP1Propagator ] ) ToolSvc += VP1Extrapolator print VP1Extrapolator #We should append to variable instead: os.putenv("VP1_JOBCFG_EXTRA_VP1_EXTRAPOLATORS", "Trk::Extrapolator/" + VP1ExtraPolatorName) from TrkExEngine.AtlasExtrapolationEngine import AtlasExtrapolationEngine
from RecExConfig.Configured import Configured from InDetRecExample.InDetKeys import InDetKeys from AthenaCommon.DetFlags import DetFlags import AthenaCommon.CfgMgr as CfgMgr mlog = logging.getLogger ('MCTruthCalssifierBase.py::configure:') mlog.info('entering') from AthenaCommon.AppMgr import ToolSvc # Configure the extrapolator from TrkExTools.AtlasExtrapolator import AtlasExtrapolator theAtlasExtrapolator=AtlasExtrapolator(name = 'egammaExtrapolator') theAtlasExtrapolator.DoCaloDynamic = False # this turns off dynamic calculation of eloss in calorimeters # all left to MaterialEffects/EnergyLossUpdators from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator as MaterialEffectsUpdator AtlasMaterialEffectsUpdator = MaterialEffectsUpdator(name = 'AtlasMaterialEffectsUpdator') ToolSvc += AtlasMaterialEffectsUpdator #default material effects updator NoElossMaterialEffectsUpdator = MaterialEffectsUpdator(name = 'NoElossMaterialEffectsUpdator') NoElossMaterialEffectsUpdator.EnergyLoss = False ToolSvc += NoElossMaterialEffectsUpdator # setup MaterialEffectsUpdator arrays MyUpdators = [] # MyUpdators += [AtlasMaterialEffectsUpdator] # for ID MyUpdators += [NoElossMaterialEffectsUpdator] # for ID MyUpdators += [NoElossMaterialEffectsUpdator] # for Calo
Mode='indet') ToolSvc += egRotCreator # load error scaling from IOVDbSvc.CondDB import conddb if not conddb.folderRequested('Indet/TrkErrorScaling'): conddb.addFolderSplitOnline('INDET', '/Indet/Onl/TrkErrorScaling', '/Indet/TrkErrorScaling') ##################End of e/gamma Rot Creator ################### # # # Extrapolator to be used for tracking inside egamma i.e GSF , conversions # Set up AtlasExtrapolator if not hasattr(ToolSvc, 'AtlasExtrapolator'): from TrkExTools.AtlasExtrapolator import AtlasExtrapolator ToolSvc += AtlasExtrapolator() from AthenaCommon.AppMgr import ServiceMgr as svcMgr AtlasTrackingGeometrySvc = svcMgr.AtlasTrackingGeometrySvc # get propagator from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as Propagator # egTrkPropagator = Propagator(name='egTrkPropagator') egTrkPropagator.AccuracyParameter = 0.0001 ToolSvc += egTrkPropagator # from TrkExSTEP_Propagator.TrkExSTEP_PropagatorConf import Trk__STEP_Propagator as StepPropagator egTrkStepPropagator = StepPropagator(name='egTrkStepPropagator') ToolSvc += egTrkStepPropagator
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
topSequence += AthenaMonManager("HLTMonManager") HLTMonManager = topSequence.HLTMonManager from TrigIDtrkMonitoring.TrigIDtrkMonitoringConfig import TrigIDtrkMonitoringTool montool = TrigIDtrkMonitoringTool() HLTMonManager.AthenaMonTools += montool ###### Run Zee part if calo is present ############# if rec.doCalo: ########################################################################################################## # Configure the extrapolator ########################################################################################################## from TrkExTools.AtlasExtrapolator import AtlasExtrapolator theAtlasExtrapolator = AtlasExtrapolator(name='egammaExtrapolator') theAtlasExtrapolator.DoCaloDynamic = False # this turns off dynamic calculation of eloss in calorimeters # all left to MaterialEffects/EnergyLossUpdators from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator as MaterialEffectsUpdator AtlasMaterialEffectsUpdator = MaterialEffectsUpdator( name='AtlasMaterialEffectsUpdator') ToolSvc += AtlasMaterialEffectsUpdator #default material effects updator NoElossMaterialEffectsUpdator = MaterialEffectsUpdator( name='NoElossMaterialEffectsUpdator') NoElossMaterialEffectsUpdator.EnergyLoss = False ToolSvc += NoElossMaterialEffectsUpdator # setup MaterialEffectsUpdator arrays MyUpdators = [] # MyUpdators += [AtlasMaterialEffectsUpdator] # for ID
def __init__(self,name = 'UserExtrapolator'): # call the base class constructor AtlasExtrapolator.__init__(self,name) self.thisIndex = -1
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration from TrigEgammaHypo.TrigEgammaHypoConf import TrigEgammaFastElectronFexMT from AthenaCommon.SystemOfUnits import GeV, mm from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringTool from TrackToCalo.TrackToCaloConf import Trk__ParticleCaloExtensionTool from TrkExTools.AtlasExtrapolator import AtlasExtrapolator ParticleCaloExtensionTool= Trk__ParticleCaloExtensionTool(Extrapolator = AtlasExtrapolator()) # --------------------------------------------------------------- # class for common setups (like monitoring) class EgammaFastElectronFexBase(TrigEgammaFastElectronFexMT): __slots__ = [] def __init__(self, name): super(EgammaFastElectronFexBase,self).__init__(name) # Tracking cuts self.TrackPt = 1.0 * GeV self.TrackPtHighEt = 2.0 * GeV self.ClusEt = 20.0 * GeV self.CaloTrackdEtaNoExtrap = 0.5 self.CaloTrackdEtaNoExtrapHighEt = 0.1 # Calo-Tracking matching cuts self.CaloTrackdETA = 0.5 self.CaloTrackdPHI = 0.5 self.CaloTrackdEoverPLow = 0.0 self.CaloTrackdEoverPHigh = 999.0 self.ParticleCaloExtensionTool = ParticleCaloExtensionTool
MessageSvc.defaultLimit = 100000 MessageSvc.Format = "% F%37W%S%7W%R%T %0W%M" ################################################################ # load the AtlasExtrapolator # the Detector flags to be imported from TrkDetDescrSvc.TrkDetDescrJobProperties import TrkDetFlags TrkDetFlags.TRT_BuildStrawLayers = False # True # to test complex geometry # validate also the collection of material layers MaterialCollectionValidation = False # create the extrapolator from TrkExTools.AtlasExtrapolator import AtlasExtrapolator MyExtrapolator = AtlasExtrapolator(name='TestExtrapolator') MyExtrapolator.NavigationStatisticsOutput = True MyExtrapolator.OutputLevel = INFO MyExtrapolator.StopWithNavigationBreak = True MyExtrapolator.DoCaloDynamic = True MyExtrapolator.MaterialEffectsOnTrackValidation = True MyExtrapolator.RequireMaterialDestinationHit = MaterialCollectionValidation MyExtrapolator.setEnergyLoss(False) from TrkExTools.TrkExToolsConf import Trk__Navigator MyNavigator = Trk__Navigator(name='TestNavigator') MyNavigator.OutputLevel = INFO ToolSvc += MyNavigator MyExtrapolator.Navigator = MyNavigator ToolSvc += MyExtrapolator
#Avoid multiple includes include.block("TruthJiveXML/TruthJiveXML_DataTypes.py") if not "AtlasExtrapolator" in dir(): from TrkExTools.AtlasExtrapolator import AtlasExtrapolator AtlasExtrapolator = AtlasExtrapolator('AtlasExtrapolator') ToolSvc += AtlasExtrapolator # Include the base options if the user didn't already do that if not "theEventData2XML" in dir(): include("JiveXML/JiveXML_jobOptionBase.py") if not "JiveXML::TruthTrackRetriever/TruthTrackRetriever" in theEventData2XML.DataTypes: theEventData2XML.DataTypes += [ "JiveXML::TruthTrackRetriever/TruthTrackRetriever" ] theEventData2XML.DataTypes += [ "JiveXML::TruthMuonTrackRetriever/TruthMuonTrackRetriever" ] # Configuration of the data retrievers can be done as follows: from TruthJiveXML.TruthJiveXMLConf import JiveXML__TruthTrackRetriever theTruthTrackRetriever = JiveXML__TruthTrackRetriever( name="TruthTrackRetriever") #theTruthTrackRetriever.StoreGateKey = "TruthEvent" ToolSvc += theTruthTrackRetriever
#ctct = ClusterTimeCutTool("JetConstit_Timecut") #ToolSvc += ctct PFSequence = JetConstituentModSequence( "JetConstitSeq_LCOriginAndTime", InputContainer="CaloCalTopoClusters", OutputContainer="TimedCaloCalTopoClusters", InputType="CaloCluster", Modifiers=[ccco], SaveAsShallow=False) ToolSvc += PFSequence #Configure the extrapolator from TrkExTools.AtlasExtrapolator import AtlasExtrapolator theAtlasExtrapolator = AtlasExtrapolator("AtlasExtrapolator") ToolSvc += theAtlasExtrapolator from TrackCaloClusterRecTools.TrackCaloClusterRecToolsConf import ParticleToCaloExtrapolationTool ParticleToCaloExtrapolationTool = ParticleToCaloExtrapolationTool( name="ParticleToCaloExtrapolationTool", Extrapolator=theAtlasExtrapolator, ParticleType="pion") #ParticleToCaloExtrapolationTool.OutputLevel = DEBUG ToolSvc += ParticleToCaloExtrapolationTool print ParticleToCaloExtrapolationTool from ParticlesInConeTools.ParticlesInConeToolsConf import xAOD__CaloClustersInConeTool CaloClustersInCone = xAOD__CaloClustersInConeTool( name="CaloClustersInCone", CaloClusterLocation="TimedCaloCalTopoClusters")
### Setup extrapolator ### if (doMEOTP): ### Configure Material Effects On Track Provider (usually this is not done) ### include( 'CaloMaterialEffectsOnTrackProvider/CaloMaterialEffectsOnTrackProvider.py' ) from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator CaloTrkMuId_MaterialUpdator = Trk__MaterialEffectsUpdator() ToolSvc += CaloTrkMuId_MaterialUpdator from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator CaloTrkMuId_Propagator = Trk__RungeKuttaPropagator() ToolSvc += CaloTrkMuId_Propagator from TrkExTools.AtlasExtrapolator import AtlasExtrapolator CaloTrkMuIdTools_Extrapolator = AtlasExtrapolator( name='CaloTrkMuIdTools_Extrapolator') CaloTrkMuIdTools_Extrapolator.DoCaloDynamic = True CaloTrkMuIdTools_Extrapolator.Propagators = [CaloTrkMuIdTools_Propagator] CaloTrkMuIdTools_Extrapolator.MaterialEffectsUpdator = CaloTrkMuIdTools_MaterialUpdator else: ### Use the public AtlasExtrapolator ### from TrkExTools.AtlasExtrapolator import AtlasExtrapolator CaloTrkMuIdTools_Extrapolator = AtlasExtrapolator() ToolSvc += CaloTrkMuIdTools_Extrapolator #print CaloTrkMuIdTools_Extrapolator ### Configure TrackEnergyInCaloTool ### from CaloTrkMuIdTools.CaloTrkMuIdToolsConf import TrackEnergyInCaloTool as ConfiguredTrackEnergyInCaloTool TrackEnergyInCaloTool = ConfiguredTrackEnergyInCaloTool(