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(
