def ConfiguredEventFitter(Name,
TracksInContainer,
FieldOff=None,
SimplifiedGeometry=None,
NoDriftTimes=None,
KalmanSmoother=None,
LiteClusters=False,
ApplyMaterialCorrections=None,
StateAtBeamLine=True,
MaxNumberOutliers=2,
MSRossiAndGreisen=False):
# make sure the name is unique
if allConfigurables.get(Name):
raise ValueError, 'ConfiguredEventFitter: instance with name ' + Name + ' already exists'
# create the event fitter
eventfitter = TrackEventFitter(Name)
eventfitter.TracksInContainer = TracksInContainer
# this addTool should not be necessary but unfortunately there is a problem with the toolhandle configuration
eventfitter.addTool(TrackMasterFitter, name="Fitter")
# configure the fitter
ConfiguredMasterFitter(eventfitter.Fitter,
FieldOff=FieldOff,
SimplifiedGeometry=SimplifiedGeometry,
NoDriftTimes=NoDriftTimes,
KalmanSmoother=KalmanSmoother,
LiteClusters=LiteClusters,
ApplyMaterialCorrections=ApplyMaterialCorrections,
StateAtBeamLine=StateAtBeamLine,
MaxNumberOutliers=MaxNumberOutliers,
MSRossiAndGreisen=MSRossiAndGreisen)
return eventfitter
def ConfiguredForwardStraightLineEventFitter(Name, TracksInContainer):
eventfitter = TrackEventFitter(Name)
eventfitter.TracksInContainer = TracksInContainer
fittername = Name + ".Fitter"
eventfitter.addTool(ConfiguredForwardStraightLineFitter(Name=fittername),
name="Fitter")
return eventfitter
def ConfiguredForwardEventFitter(Name,
TracksInContainer,
ForceUseDriftTime=True):
eventfitter = TrackEventFitter(Name)
eventfitter.TracksInContainer = TracksInContainer
fittername = Name + ".Fitter"
eventfitter.addTool(ConfiguredForwardFitter(
Name=fittername, ForceUseDriftTime=ForceUseDriftTime),
name="Fitter")
return eventfitter
def ConfiguredHltEventFitter( name,
TracksInContainer,
TracksOutContainer = None):
# create the event fitter
from Configurables import ( TrackEventFitter, TrackMasterFitter, TrackInitFit, TrackStateInitTool )
eventfitter = TrackEventFitter(name)
eventfitter.TracksInContainer = TracksInContainer
if TracksOutContainer != None:
eventfitter.TracksOutContainer = TracksOutContainer
ConfiguredHltInitFitter(eventfitter)
return eventfitter
def TweakFitter(eventfittername):
from Configurables import TrackEventFitter
eventfitter = TrackEventFitter(eventfittername)
eventfitter.Fitter.MaxNumberOutliers = 2
eventfitter.Fitter.MaxDeltaChiSqConverged = 0.01
eventfitter.Fitter.NumberFitIterations = 10
eventfitter.Fitter.Chi2Outliers = 25
def __hlt2FullDownstreamTracking(self):
"""
Full Downstream track reconstruction and fitting for tracking efficiency lines
"""
from Configurables import PatSeeding
from Configurables import PatSeedingTool
from HltLine.HltLine import bindMembers
from Configurables import TrackEventFitter, TrackMasterFitter
DownstreamFit = TrackEventFitter('DownstreamFitter')
DownstreamFit.TracksInContainer = Hlt2TrackLoc[
"Downstream"] #use unfitted Downstream tracks out of Hlt2Tracking
DownstreamFit.TracksOutContainer = Hlt2TrackEffLoc[
"FullDownstream"] #our outputlocation
DownstreamFit.addTool(TrackMasterFitter, name='Fitter')
from TrackFitter.ConfiguredFitters import ConfiguredHltFitter, ConfiguredMasterFitter
DownstreamFitter = getattr(DownstreamFit, 'Fitter')
from Configurables import HltRecoConf
ConfiguredMasterFitter(DownstreamFitter,
SimplifiedGeometry=True,
LiteClusters=True,
MSRossiAndGreisen=HltRecoConf().getProp(
"NewMSinFit")) #on par with Hlt track fits
DownstreamFitter.OutputLevel = 5
# Build the bindMembers
bm_name = self.getProp("Prefix") + "FullDownstreamTracking"
bm_members = [DownstreamFit]
bm_output = Hlt2TrackEffLoc["FullDownstream"]
return bindMembers(bm_name, bm_members).setOutputSelection(bm_output)
def doMyAlignChanges():
from Configurables import TESCheck
TESCheck().Stop = False
TESCheck().Enable = False
TweakFitter('FitDownstream')
TweakFitter('FitMatch')
TweakFitter('FitSeed')
TweakFitter('RefitSeed')
TweakFitter('FitForward')
TweakFitter('FitVelo')
TweakFitter('FitVeloTT')
TweakFitter('TrackRefitter')
TrackEventFitter('TrackRefitter').Fitter.UpdateTransport = True
# add a filter on Velo tracks
from Configurables import TrackListFilter
GaudiSequencer("RecoVELOSeq").Members += [TrackListFilter("VeloFilter",
inputLocation = "Rec/Track/Velo")]
from Configurables import Tf__Tsa__Seed, Tf__Tsa__SeedAddHits
tsaSeed = Tf__Tsa__Seed("TsaSeed")
tsaSeed.addTool(Tf__Tsa__SeedAddHits(), name="SeedAddHits")
# tolerance if inside box mm
tsaSeed.SeedAddHits.tol = 3
# tolerance window make bigger mmm
tsaSeed.SeedAddHits.dCut = 2.5
# chi-sq cut
tsaSeed.SeedAddHits.outlierCutParabola = 5;
from Configurables import TrackHitMapMonitor
GaudiSequencer("MoniTrSeq").Members.append( TrackHitMapMonitor() )
from Configurables import STOfflinePosition
itClusterPosition = STOfflinePosition('ToolSvc.ITClusterPosition')
itClusterPosition.ErrorVec = [0.28, 0.22, 0.35, 0.35]
itClusterPosition.APE = 0.1
def fittedVelo(inputTracks, outputTracks, name='VeloOnlyFitterAlg'):
from Configurables import TrackEventFitter, TrackInitFit
from Configurables import TrackStateInitTool, TrackMasterFitter
if HltRecoConf().getProp("FastFitVelo"):
# For now use the save option where Velo tracks are copied and the original ones are not changed
from Configurables import TrackStateInitAlg, TrackStateInitTool,FastVeloFitLHCbIDs
from Configurables import TrackContainerCopy
copy = TrackContainerCopy(name+"CopyVelo")
copy.inputLocations = [ inputTracks ]
copy.outputLocation = outputTracks
init = TrackStateInitAlg(name)
init.TrackLocation = copy.outputLocation
init.addTool(TrackStateInitTool, name="StateInitTool")
init.StateInitTool.VeloFitterName = "FastVeloFitLHCbIDs"
init.StateInitTool.addTool(TrackMasterExtrapolator, "Extrapolator")
init.StateInitTool.Extrapolator.addTool(SimplifiedMaterialLocator,
name = "MaterialLocator")
init.StateInitTool.addTool(FastVeloFitLHCbIDs,name="FastVeloFitLHCbIDs")
init.StateInitTool.FastVeloFitLHCbIDs.UseKalmanFit = True
return [copy,init]
else:
fa = TrackEventFitter(name)
fa.TracksInContainer = inputTracks
fa.TracksOutContainer = outputTracks
fa.Fitter = "TrackInitFit/Fit"
fa.addTool(TrackInitFit, "Fit")
fa.Fit.Init = "TrackStateInitTool/VeloOnlyStateInit"
fa.Fit.addTool(TrackStateInitTool, "VeloOnlyStateInit")
fa.Fit.VeloOnlyStateInit.VeloFitterName = "FastVeloFitLHCbIDs"
fa.Fit.VeloOnlyStateInit.addTool(TrackMasterExtrapolator, "Extrapolator")
fa.Fit.VeloOnlyStateInit.Extrapolator.addTool(SimplifiedMaterialLocator,
name = "MaterialLocator")
fa.Fit.Fit = "TrackMasterFitter/Fit"
fa.Fit.addTool(TrackMasterFitter, name = "Fit")
from TrackFitter.ConfiguredFitters import ConfiguredForwardFitter
fitter = ConfiguredForwardFitter(fa.Fit.Fit)
return [ fa ]
def trackingPreFilter(name, prefilter):
VeloMuonBuilder1 = VeloMuonBuilder("VeloMuonBuilder")
VeloMuonBuilder1.OutputLevel = 6
VeloMuonBuilder1.MuonLocation = "Hlt1/Track/MuonSeg"
VeloMuonBuilder1.VeloLocation = "Rec/Track/FittedVelo"
VeloMuonBuilder1.lhcbids = 4
VeloMuonBuilder1.OutputLocation = "Rec/VeloMuon/Tracks"
preve = TrackPrepareVelo("preve")
preve.inputLocation = "Rec/Track/Velo"
preve.outputLocation = "Rec/Track/UnfittedPreparedVelo"
preve.bestLocation = ""
vefit = TrackEventFitter('vefit')
vefit.TracksInContainer = "Rec/Track/UnfittedPreparedVelo"
vefit.TracksOutContainer = "Rec/Track/FittedVelo"
vefit.addTool(TrackMasterFitter, name = 'Fitter')
ConfiguredFastFitter( getattr(vefit,'Fitter'))
#define a TrackCloneFinder
#low = TrackCloneFinder("TrackCloneFinder/low")
#low.MatchingFraction = 0.6
Tf__PatVeloSpaceTracking("PatVeloSpaceTracking").addTool( Tf__PatVeloSpaceTool(), name="PatVeloSpaceTool" )
Tf__PatVeloSpaceTracking("PatVeloSpaceTracking").PatVeloSpaceTool.MarkClustersUsed = True;
#Tf__PatVeloSpaceTracking("PatVeloSpaceTracking").OutputLevel = 0;
# algos = [tisTosPreFilterHlt1Jpsi, tisTosPreFilterHlt2Jpsi, Tf__PatVeloRTracking(), Tf__PatVeloSpaceTracking(),Tf__PatVeloGeneralTracking(), preve,vefit, StandaloneMuonRec(), VeloMuonBuilder1]
#
alg = GaudiSequencer("VeloMuonTrackingFor"+name,
#Members = [Jpsi_already_there,
# jpsidotracking],
Members = [ DecodeVeloRawBuffer(name+"VeloDecoding"),
Tf__PatVeloRTracking(name+"VeloR"), Tf__PatVeloSpaceTracking(name+"VeloSpace"),
Tf__PatVeloGeneralTracking(name+"VeloGen"), preve,vefit,
StandaloneMuonRec(name+"MuonStandalone"), VeloMuonBuilder1])
return GSWrapper(name="WrappedVeloMuonTracking",
sequencer=alg,
output='Rec/VeloMuon/Tracks',
requiredSelections = [ prefilter])
#L0Conf().EnsureKnownTCK=False
from Configurables import TrajOTProjector
Projector = TrajOTProjector("OTProjector", UseDrift=True)
from TrackFitter.ConfiguredFitters import *
Fitter = ConfiguredMasterFitter("TrackMonFitter")
Fitter.Projector.OT = Projector
Fitter.MaxNumberOutliers = 0
#OT t0 calibration
from Configurables import (GaudiSequencer, TrackHitAdder, TrackEventFitter,
OTModuleClbrMon, TrackMon)
GaudiSequencer("MoniOTSeq").Members = [
TrackHitAdder(TrackLocation="Rec/Track/Best"),
TrackEventFitter(TracksInContainer="Rec/Track/Best", Fitter=Fitter),
OTModuleClbrMon(
TrackType=
3, # Long tracks
MinP=3.2, # GeV
MaxTrackChi2=100,
MaxTrackUbChi2=2,
ReadXMLs=False,
TrackLocation="Rec/Track/Best",
Fitter=Fitter,
Projector=Projector)
]
NTupleSvc().Output = ["FILE1 DATAFILE='clbr.root' TYP='ROOT' OPT='NEW'"]
HistogramPersistencySvc().OutputFile = "clbr_hists.root"
def ConfiguredHltEventFitter(Name, TracksInContainer):
eventfitter = TrackEventFitter(Name)
eventfitter.TracksInContainer = TracksInContainer
fittername = Name + ".Fitter"
eventfitter.addTool(ConfiguredHltFitter(Name=fittername), name="Fitter")
return eventfitter
def doMyAlignChanges():
from Configurables import TESCheck
TESCheck().Stop = False
TESCheck().Enable = False
TweakFitter('FitDownstream')
TweakFitter('FitMatch')
TweakFitter('FitSeed')
TweakFitter('RefitSeed')
TweakFitter('FitForward')
TweakFitter('FitVelo')
TweakFitter('FitVeloTT')
TweakFitter('FitBest')
TweakFitter('TrackRefitter')
TrackEventFitter('TrackRefitter').Fitter.UpdateTransport = True
ApplicationMgr().ExtSvc += ["DataOnDemandSvc", "ANNDispatchSvc"]
# insert a filter get only dimuons
from Configurables import LoKi__HDRFilter as HDRFilter
hltfilter = HDRFilter(
'HLT2JPsi',
Code="HLT_PASS_RE( 'Hlt2.*Muon.*JPsi.*Decision' )"
#Code = "HLT_PASS_RE( '.*Decision' )"
#Code = "HLT_PASS_RE('Hlt2.*Decision')"
#Code ="HLT_PASS('Hlt2ExpressHLT1PhysicsDecision')"
)
hltfilter.Preambulo += ["from LoKiCore.functions import *"]
from Configurables import HltDecReportsDecoder
DataOnDemandSvc().AlgMap["Hlt/DecReports"] = HltDecReportsDecoder(
OutputLevel=4)
GaudiSequencer('EscherSequencer').Members.insert(1, hltfilter)
#from Configurables import DecReportDumper
#GaudiSequencer('EscherSequencer').Members.insert(2,DecReportDumper())
#from Configurables import LoKi__VoidFilter as LokiFilter
#stripfilter = LokiFilter ( 'JPsiMuMuFilter' ,
# Code = "0 < CONTAINS ( '/Event/Dimuon/Phys/FullDSTDiMuonJpsi2MuMuLine/Particles' )"
# #,Preambulo = [ "from LoKiTrigger.decorators import *" ]
# )
#GaudiSequencer('EscherSequencer').Members.insert(2,stripfilter)
# add a filter on Velo tracks
from Configurables import TrackListFilter
GaudiSequencer("RecoVELOSeq").Members += [
TrackListFilter("VeloFilter", inputLocation="Rec/Track/Velo")
]
from Configurables import TrackMultiplicityFilter
GaudiSequencer("RecoDecodingSeq").Members += [
TrackMultiplicityFilter("MultFilter", MaxNumITHits=600)
]
from Configurables import TrackDiMuonMonitor
TrackDiMuonMonitor().MaxTwoProngVertexChi2 = 4
from Configurables import TrackHitMapMonitor
GaudiSequencer("MoniTrSeq").Members.append(TrackHitMapMonitor())
#from Configurables import STOfflinePosition
#itClusterPosition = STOfflinePosition('ToolSvc.ITClusterPosition')
#itClusterPosition.ErrorVec = [0.28, 0.22, 0.35, 0.35]
#itClusterPosition.APE = 0.1
from Configurables import ST__STClusterMonitor
ST__STClusterMonitor('ITClusterMonitor').HitMaps = True
def RecoTrackingHLT1(exclude=[],
simplifiedGeometryFit=True,
liteClustersFit=True):
'''Function that defines the pattern recognition algorithms for the HLT1 sequence of the Run 2 offline tracking'''
## Start TransportSvc, needed by track fit
ApplicationMgr().ExtSvc.append("TransportSvc")
## --------------------------------------------------------------------
## Pattern Recognition and Fitting
## --------------------------------------------------------------------
# Which algs to run ?
trackAlgs = TrackSys().getProp("TrackPatRecAlgorithms")
# Which data type is it?
dataType = TrackSys().getProp("DataType")
# Decode the RAW banks
ExcludedLayers = TrackSys().getProp("ExcludedLayers")
DecodeTracking(trackAlgs, ExcludedLayers)
from Configurables import STOfflinePosition
IT = STOfflinePosition('ITClusterPosition')
IT.DetType = "IT"
TT = STOfflinePosition('TTClusterPosition')
TT.DetType = "TT"
from STTools import STOfflineConf
STOfflineConf.DefaultConf().configureTools()
## Make sure the default extrapolator and interpolator use simplified material
from Configurables import TrackMasterExtrapolator, TrackInterpolator, SimplifiedMaterialLocator, DetailedMaterialLocator
if TrackSys().simplifiedGeometry() and ('SimpleGeom' not in exclude):
TrackMasterExtrapolator().MaterialLocator = 'SimplifiedMaterialLocator'
TrackInterpolator().addTool(TrackMasterExtrapolator(
MaterialLocator='SimplifiedMaterialLocator'),
name='Extrapolator')
### This configures public tools to use the new multiple scattering description without the log term
from Configurables import StateThickMSCorrectionTool
me = TrackMasterExtrapolator()
me.addTool(DetailedMaterialLocator(), name="MaterialLocator")
me.MaterialLocator.addTool(StateThickMSCorrectionTool,
name="StateMSCorrectionTool")
me.MaterialLocator.StateMSCorrectionTool.UseRossiAndGreisen = True
ti = TrackInterpolator()
ti.addTool(me)
from Configurables import TrackStateProvider
tsp = TrackStateProvider()
tsp.addTool(TrackInterpolator, name="Interpolator")
tsp.addTool(TrackMasterExtrapolator, name="Extrapolator")
tsp.Interpolator.addTool(TrackMasterExtrapolator, name='Extrapolator')
if simplifiedGeometryFit or (TrackSys().simplifiedGeometry() and
('SimpleGeom' not in exclude)):
tsp.Extrapolator.addTool(SimplifiedMaterialLocator,
name="MaterialLocator")
tsp.Interpolator.Extrapolator.addTool(SimplifiedMaterialLocator,
name="MaterialLocator")
else:
tsp.Extrapolator.addTool(DetailedMaterialLocator,
name="MaterialLocator")
tsp.Interpolator.Extrapolator.addTool(DetailedMaterialLocator,
name="MaterialLocator")
tsp.Extrapolator.MaterialLocator.addTool(StateThickMSCorrectionTool,
name="StateMSCorrectionTool")
tsp.Extrapolator.MaterialLocator.StateMSCorrectionTool.UseRossiAndGreisen = True
tsp.Interpolator.Extrapolator.MaterialLocator.addTool(
StateThickMSCorrectionTool, name="StateMSCorrectionTool")
tsp.Interpolator.Extrapolator.MaterialLocator.StateMSCorrectionTool.UseRossiAndGreisen = True
###
## Velo tracking
## Why is Velo not in the tracking sequence?
if "FastVelo" in trackAlgs:
from Configurables import FastVeloTracking
GaudiSequencer("RecoVELOSeq").Members += [
FastVeloTracking("FastVeloTracking")
]
if TrackSys().timing():
FastVeloTracking().TimingMeasurement = True
## Tracking sequence
from Configurables import ProcessPhase
track = ProcessPhase("TrackHLT1")
GaudiSequencer("RecoTrHLT1Seq").Members += [track]
from Configurables import MagneticFieldSvc
if TrackSys().fieldOff():
MagneticFieldSvc().ForcedSignedCurrentScaling = 0.
if "noDrifttimes" in TrackSys().getProp("ExpertTracking"):
from Configurables import (Tf__OTHitCreator)
Tf__OTHitCreator("OTHitCreator").NoDriftTimes = True
# Get the fitters
from TrackFitter.ConfiguredFitters import ConfiguredFit, ConfiguredFitSeed, ConfiguredMasterFitter
# Clone killer
tracklists = []
# Is this standard sequence?
stdSeq = "fastSequence" not in TrackSys().getProp("ExpertTracking")
## Velo-TT pattern
if "VeloTT" in trackAlgs:
track.DetectorList += ["VeloTTPat"]
from Configurables import PatVeloTTHybrid
GaudiSequencer("TrackHLT1VeloTTPatSeq").Members += [
PatVeloTTHybrid("PatVeloTTHybrid")
]
from PatVeloTT import PatVeloTTAlgConf
PatVeloTTAlgConf.PatVeloTTConf().configureAlgRun2HLT1()
if TrackSys().timing():
PatVeloTTHybrid("PatVeloTTHybrid").TimingMeasurement = True
tracklists += ["Rec/Track/VeloTT"]
## Forward pattern
if "ForwardHLT1" in trackAlgs:
if "VeloTT" not in trackAlgs:
raise RuntimeError("Cannot run HLT1 forward without VeloTT")
track.DetectorList += ["ForwardPatHLT1"]
from Configurables import PatForward, PatForwardTool
GaudiSequencer("TrackHLT1ForwardPatHLT1Seq").Members += [
PatForward("PatForwardHLT1")
]
# should be replaced by more 'global' tracking configuration
from PatAlgorithms import PatAlgConf
PatAlgConf.ForwardConf().configureAlgRun2HLT1()
if TrackSys().timing():
PatForward("PatForwardHLT1").TimingMeasurement = True
tracklists += ["Rec/Track/ForwardHLT1"]
## Fitting all HLT1 tracks
track.DetectorList += ["FitHLT1"]
from Configurables import TrackEventFitter, TrackInitFit, TrackStateInitTool, TrackStateInitAlg, TrackMasterExtrapolator, TrackMasterFitter
from Configurables import SimplifiedMaterialLocator, DetailedMaterialLocator
from Configurables import TrackContainerCopy
######
### Fitter for Velo tracks
######
if "FastVelo" in trackAlgs:
if "VeloForwardKalmanHLT1" in TrackSys().getProp("ExpertTracking"):
# This is the option for the 2015 early measurements
veloFitter = TrackEventFitter('VeloOnlyFitterAlg')
veloFitter.TracksInContainer = "Rec/Track/Velo"
veloFitter.TracksOutContainer = "Rec/Track/FittedHLT1VeloTracks"
veloFitter.Fitter = "TrackInitFit/Fit"
veloFitter.addTool(TrackInitFit, "Fit")
veloFitter.Fit.Init = "TrackStateInitTool/VeloOnlyStateInit"
veloFitter.Fit.addTool(TrackStateInitTool, "VeloOnlyStateInit")
veloFitter.Fit.VeloOnlyStateInit.VeloFitterName = "FastVeloFitLHCbIDs"
veloFitter.Fit.VeloOnlyStateInit.addTool(TrackMasterExtrapolator,
"Extrapolator")
if (simplifiedGeometryFit):
veloFitter.Fit.VeloOnlyStateInit.Extrapolator.addTool(
SimplifiedMaterialLocator, name="MaterialLocator")
else:
veloFitter.Fit.VeloOnlyStateInit.Extrapolator.addTool(
DetailedMaterialLocator, name="MaterialLocator")
veloFitter.Fit.Fit = "TrackMasterFitter/Fit"
veloFitter.Fit.addTool(TrackMasterFitter, name="Fit")
from TrackFitter.ConfiguredFitters import ConfiguredForwardFitter
ConfiguredForwardFitter(veloFitter.Fit.Fit,
LiteClusters=liteClustersFit)
GaudiSequencer("TrackHLT1FitHLT1Seq").Members += [veloFitter]
else:
# and this is the option for after the early measurements
# copy tracks from pat reco output container to a new one
copyVeloTracks = TrackContainerCopy("CopyVeloTracks")
copyVeloTracks.inputLocations = ["Rec/Track/Velo"]
copyVeloTracks.outputLocation = "Rec/Track/FittedHLT1VeloTracks"
from FastVelo import FastVeloAlgConf
stateInit = TrackStateInitAlg('VeloOnlyInitAlg')
FastVeloAlgConf.FastVeloKalmanConf().configureFastKalmanFit(
init=stateInit)
GaudiSequencer("TrackHLT1FitHLT1Seq").Members += [
copyVeloTracks, stateInit
]
######
### Fitter for Forward tracks
### Need to be careful: This is all a little fragile, so if you plan to change something, check that everything configures the way you expect
### The Extrapolator for the StateInitTool does not use material corrections, so don't need to explicitely add the StateThickMSCorrectionTool
######
if "ForwardHLT1" in trackAlgs:
fwdFitter = TrackEventFitter('ForwardHLT1FitterAlg')
fwdFitter.TracksInContainer = "Rec/Track/ForwardHLT1"
fwdFitter.TracksOutContainer = "Rec/Track/FittedHLT1ForwardTracks"
# Keep only good tracks, this cut should be aligned with the one in the TrackBestTrackCreator
fwdFitter.MaxChi2DoF = 4.0
fwdFitter.Fitter = "TrackInitFit/Fit"
fwdFitter.addTool(TrackInitFit, "Fit")
fwdFitter.Fit.Init = "TrackStateInitTool/FwdStateInit"
fwdFitter.Fit.addTool(TrackStateInitTool, "FwdStateInit")
fwdFitter.Fit.FwdStateInit.addTool(TrackMasterExtrapolator,
"Extrapolator")
fwdFitter.Fit.FwdStateInit.UseFastMomentumEstimate = True
fwdFitter.Fit.FwdStateInit.VeloFitterName = "FastVeloFitLHCbIDs"
if (simplifiedGeometryFit):
fwdFitter.Fit.FwdStateInit.Extrapolator.addTool(
SimplifiedMaterialLocator, name="MaterialLocator")
else:
fwdFitter.Fit.FwdStateInit.Extrapolator.addTool(
DetailedMaterialLocator, name="MaterialLocator")
fwdFitter.Fit.Fit = "TrackMasterFitter/Fit"
fwdFitter.Fit.addTool(TrackMasterFitter, name="Fit")
from TrackFitter.ConfiguredFitters import ConfiguredMasterFitter
ConfiguredMasterFitter(fwdFitter.Fit.Fit,
SimplifiedGeometry=simplifiedGeometryFit,
LiteClusters=liteClustersFit,
MSRossiAndGreisen=True)
GaudiSequencer("TrackHLT1FitHLT1Seq").Members += [fwdFitter]
def RecoTracking(exclude=[]):
'''What used to be in the options file, moved here'''
## Start TransportSvc, needed by track fit
ApplicationMgr().ExtSvc.append("TransportSvc")
## --------------------------------------------------------------------
## Pattern Recognition and Fitting
## --------------------------------------------------------------------
# Which algs to run ?
trackAlgs = TrackSys().getProp("TrackPatRecAlgorithms")
# Which data type is it?
dataType = TrackSys().getProp("DataType")
# Decode the RAW banks
DecodeTracking(trackAlgs)
from Configurables import STOfflinePosition
IT = STOfflinePosition('ITClusterPosition')
IT.DetType = "IT"
TT = STOfflinePosition('TTClusterPosition')
TT.DetType = "TT"
from STTools import STOfflineConf
STOfflineConf.DefaultConf().configureTools()
#importOptions( "$STTOOLSROOT/options/Brunel.opts" )
## Velo tracking
if "FastVelo" in trackAlgs:
from Configurables import FastVeloTracking
GaudiSequencer("RecoVELOSeq").Members += [FastVeloTracking()]
if TrackSys().timing():
FastVeloTracking().TimingMeasurement = True
if "Velo" in trackAlgs:
from Configurables import Tf__PatVeloGeneralTracking
if TrackSys().veloOpen():
if TrackSys().beamGas():
from Configurables import Tf__PatVeloGeneric
GaudiSequencer("RecoVELOSeq").Members += [
Tf__PatVeloGeneric("PatVeloGeneric"),
Tf__PatVeloGeneralTracking("PatVeloGeneralTracking")
]
else:
from Configurables import Tf__PatVeloTrackTool
GaudiSequencer("RecoVELOSeq").Members += [
Tf__PatVeloGeneralTracking("PatVeloGeneralTracking")
]
Tf__PatVeloGeneralTracking(
"PatVeloGeneralTracking").PointErrorMin = 2 * mm
Tf__PatVeloGeneralTracking("PatVeloGeneralTracking").addTool(
Tf__PatVeloTrackTool("PatVeloTrackTool"))
Tf__PatVeloTrackTool("PatVeloTrackTool").highChargeFract = 0.5
if TrackSys().timing():
Tf__PatVeloGeneralTracking(
"PatVeloGeneralTracking").TimingMeasurement = True
else:
from Configurables import (Tf__PatVeloRTracking,
Tf__PatVeloSpaceTool,
Tf__PatVeloSpaceTracking)
GaudiSequencer("RecoVELOSeq").Members += [
Tf__PatVeloRTracking("PatVeloRTracking"),
Tf__PatVeloSpaceTracking("PatVeloSpaceTracking"),
Tf__PatVeloGeneralTracking("PatVeloGeneralTracking")
]
Tf__PatVeloSpaceTracking("PatVeloSpaceTracking").addTool(
Tf__PatVeloSpaceTool(), name="PatVeloSpaceTool")
Tf__PatVeloSpaceTracking("PatVeloSpaceTracking"
).PatVeloSpaceTool.MarkClustersUsed = True
if TrackSys().timing():
Tf__PatVeloSpaceTracking(
"PatVeloSpaceTracking").TimingMeasurement = True
Tf__PatVeloRTracking(
"PatVeloRTracking").TimingMeasurement = True
Tf__PatVeloGeneralTracking(
"PatVeloGeneralTracking").TimingMeasurement = True
## Make sure the default extrapolator and interpolator use simplified material
if TrackSys().simplifiedGeometry() and ('SimpleGeom' not in exclude):
from Configurables import TrackMasterExtrapolator, TrackInterpolator
TrackMasterExtrapolator().MaterialLocator = 'SimplifiedMaterialLocator'
TrackInterpolator().addTool(TrackMasterExtrapolator(
MaterialLocator='SimplifiedMaterialLocator'),
name='Extrapolator')
## Tracking sequence
from Configurables import ProcessPhase
track = ProcessPhase("Track")
GaudiSequencer("RecoTrSeq").Members += [track]
from Configurables import MagneticFieldSvc
if TrackSys().fieldOff():
MagneticFieldSvc().ForcedSignedCurrentScaling = 0.
if "noDrifttimes" in TrackSys().getProp("ExpertTracking"):
from Configurables import (Tf__OTHitCreator)
Tf__OTHitCreator("OTHitCreator").NoDriftTimes = True
# Get the fitters
from TrackFitter.ConfiguredFitters import ConfiguredFit, ConfiguredFitSeed, ConfiguredMasterFitter
# Clone killer
tracklists = []
# Is this standard sequence?
stdSeq = "fastSequence" not in TrackSys().getProp("ExpertTracking")
# TrackMatching not supported anymore, raise error
if "Match" in trackAlgs:
raise RuntimeError(
"TrackMatching not supported anymore. If you think this is wrong, report to [email protected]"
)
## Forward pattern
if "Forward" in trackAlgs:
track.DetectorList += ["ForwardPat"]
from Configurables import PatForward
GaudiSequencer("TrackForwardPatSeq").Members += [
PatForward("PatForward")
]
from PatAlgorithms import PatAlgConf
PatAlgConf.ForwardConf().configureAlg()
if TrackSys().timing():
PatForward("PatForward").TimingMeasurement = True
tracklists += ["Rec/Track/Forward"]
## Seed pattern
if "TsaSeed" in trackAlgs and "PatSeed" in trackAlgs:
raise RuntimeError("Cannot run both Tsa and Pat Seeding at once")
if "TsaSeed" in trackAlgs:
track.DetectorList += ["SeedPat"]
from Configurables import Tf__Tsa__Seed, Tf__Tsa__SeedTrackCnv
GaudiSequencer("TrackSeedPatSeq").Members += [
Tf__Tsa__Seed("TsaSeed"),
Tf__Tsa__SeedTrackCnv("TsaSeedTrackCnv")
]
from TsaAlgorithms import TsaAlgConf
TsaAlgConf.TsaSeedConf().configureAlg()
if TrackSys().timing():
Tf__Tsa__Seed("TsaSeed").TimingMeasurement = True
if "PatSeed" in trackAlgs:
track.DetectorList += ["SeedPat"]
from Configurables import PatSeeding
GaudiSequencer("TrackSeedPatSeq").Members += [PatSeeding("PatSeeding")]
from PatAlgorithms import PatAlgConf
PatAlgConf.SeedingConf().configureAlg()
if TrackSys().timing():
PatSeeding("PatSeeding").TimingMeasurement = True
if TrackSys().cosmics():
from PatAlgorithms import PatAlgConf
PatAlgConf.CosmicConf().configureAlg()
if "TsaSeed" in trackAlgs or "PatSeed" in trackAlgs:
tracklists += ["Rec/Track/Seed"]
# TrackMatching not supported anymore, comment for the moment in case anything breaks
#if "Match" in trackAlgs :
# Fit now
#track.DetectorList += [ "SeedFit" ]
## Seed fit initialization
#from Configurables import TrackStateInitAlg, TrackStateInitTool
#initSeedFit = TrackStateInitAlg("InitSeedFit",
# TrackLocation = "Rec/Track/Seed")
#GaudiSequencer("TrackSeedFitSeq").Members += [initSeedFit]
#if "FastVelo" in trackAlgs :
# initSeedFit.StateInitTool.VeloFitterName = "FastVeloFitLHCbIDs"
# Use small ErrorQoP fitter, needed for Match
#GaudiSequencer("TrackSeedFitSeq").Members += [ConfiguredFitSeed()]
# TrackMatching not supported anymore, comment for the moment in case anything breaks
## Match
#if "Match" in trackAlgs and "PatMatch" in trackAlgs :
# raise RuntimeError("Cannot run both TrackMatching and PatMatch at once")
#if "Match" in trackAlgs :
# track.DetectorList += [ "MatchPat" ]
# from Configurables import TrackMatchVeloSeed
# GaudiSequencer("TrackMatchPatSeq").Members += [ TrackMatchVeloSeed("TrackMatch") ]
# from TrackMatching import TrackMatchConf
# TrackMatchConf.MatchingConf().configureAlg()
# TrackMatchVeloSeed("TrackMatch").LikCut = -99999.
# if TrackSys().timing() :
# TrackMatchVeloSeed("TrackMatch").TimingMeasurement = True;
if "PatMatch" in trackAlgs:
track.DetectorList += ["MatchPat"]
from Configurables import PatMatch
GaudiSequencer("TrackMatchPatSeq").Members += [PatMatch("PatMatch")]
if "Match" in trackAlgs or "PatMatch" in trackAlgs:
tracklists += ["Rec/Track/Match"]
## Downstream
if "Downstream" in trackAlgs:
track.DetectorList += ["DownstreamPat"]
from Configurables import PatDownstream
GaudiSequencer("TrackDownstreamPatSeq").Members += [PatDownstream()]
tracklists += ["Rec/Track/Downstream"]
from PatAlgorithms import PatAlgConf
#PatAlgConf.DownstreamConf().configureAlg()
if TrackSys().timing():
PatDownstream("PatDownstream").TimingMeasurement = True
## Velo-TT pattern
if "VeloTT" in trackAlgs:
track.DetectorList += ["VeloTTPat"]
# from 2015 on, 'VeloTTHybrid' is used (as in the HLT)
# on python configuration is used
if dataType is "2015":
from Configurables import PatVeloTTHybrid
GaudiSequencer("TrackVeloTTPatSeq").Members += [
PatVeloTTHybrid("PatVeloTTHybrid")
]
if TrackSys().timing():
PatVeloTTHybrid("PatVeloTTHybrid").TimingMeasurement = True
# for everything older, the old 'PatVeloTT' is run
else:
from Configurables import PatVeloTT
GaudiSequencer("TrackVeloTTPatSeq").Members += [
PatVeloTT("PatVeloTT")
]
from PatVeloTT.PatVeloTTAlgConf import PatVeloTTConf
PatVeloTTConf().configureAlg()
if TrackSys().timing():
PatVeloTT("PatVeloTT").TimingMeasurement = True
tracklists += ["Rec/Track/VeloTT"]
### Clean clone and fit
track.DetectorList += ["Fit"]
if TrackSys().getProp("OldCloneKiller"):
from Configurables import TrackEventCloneKiller, TrackStateInitAlg, TrackContainerCopy
cloneKiller = TrackEventCloneKiller()
cloneKiller.TracksInContainers = tracklists
cloneKiller.TracksOutContainer = "Rec/Track/AllBest"
GaudiSequencer("TrackFitSeq").Members += [cloneKiller]
stateInitAlg = TrackStateInitAlg("InitBestFit")
stateInitAlg.TrackLocation = "Rec/Track/AllBest"
if "FastVelo" in trackAlgs:
stateInitAlg.StateInitTool.VeloFitterName = "FastVeloFitLHCbIDs"
GaudiSequencer("TrackFitSeq").Members += [stateInitAlg]
GaudiSequencer("TrackFitSeq").Members += [
ConfiguredFit("FitBest", "Rec/Track/AllBest")
]
copyBest = TrackContainerCopy("CopyBest")
copyBest.inputLocations = ["Rec/Track/AllBest"]
GaudiSequencer("TrackFitSeq").Members += [copyBest]
## Velo fitting
if "Velo" in trackAlgs or "FastVelo" in trackAlgs:
## Prepare the velo tracks for the fit
track.DetectorList += ["VeloFit"]
from Configurables import TrackPrepareVelo
GaudiSequencer("TrackVeloFitSeq").Members += [TrackPrepareVelo()]
## Fit the velo tracks
GaudiSequencer("TrackVeloFitSeq").Members += [
ConfiguredFit("FitVelo", "Rec/Track/PreparedVelo")
]
## copy the velo tracks to the "best" container
copyVelo = TrackContainerCopy("CopyVelo")
copyVelo.inputLocations = ["Rec/Track/PreparedVelo"]
GaudiSequencer("TrackVeloFitSeq").Members += [copyVelo]
else:
# complete the list of track lists
if "Velo" in trackAlgs or "FastVelo" in trackAlgs:
tracklists += ["Rec/Track/Velo"]
# create the best track creator
from Configurables import TrackBestTrackCreator
bestTrackCreator = TrackBestTrackCreator(TracksInContainers=tracklists)
# configure its fitter and stateinittool
ConfiguredMasterFitter(bestTrackCreator.Fitter)
if "FastVelo" in trackAlgs:
bestTrackCreator.StateInitTool.VeloFitterName = "FastVeloFitLHCbIDs"
# add to the sequence
GaudiSequencer("TrackFitSeq").Members.append(bestTrackCreator)
### Change dEdx correction for simulated data
if TrackSys().getProp("Simulation"):
from Configurables import StateDetailedBetheBlochEnergyCorrectionTool, DetailedMaterialLocator
if TrackSys().getProp("OldCloneKiller"):
from Configurables import TrackEventFitter, TrackMasterFitter
fitBest = TrackEventFitter("FitBest")
fitBest.Fitter.MaterialLocator.addTool(
StateDetailedBetheBlochEnergyCorrectionTool("GeneralDedxTool"))
fitBest.Fitter.MaterialLocator.GeneralDedxTool.EnergyLossFactor = 0.76
else:
from Configurables import TrackBestTrackCreator
fitter = TrackBestTrackCreator().Fitter
fitter.MaterialLocator.addTool(
StateDetailedBetheBlochEnergyCorrectionTool("GeneralDedxTool"))
fitter.MaterialLocator.GeneralDedxTool.EnergyLossFactor = 0.76
## Extra track information sequence
extraInfos = TrackSys().getProp("TrackExtraInfoAlgorithms")
if len(extraInfos) > 0:
track.DetectorList += ["AddExtraInfo"]
## Clone finding and flagging
if "CloneFlagging" in extraInfos:
from Configurables import TrackBuildCloneTable, TrackCloneCleaner
trackClones = GaudiSequencer("TrackClonesSeq")
GaudiSequencer("TrackAddExtraInfoSeq").Members += [trackClones]
if TrackSys().timing():
trackClones.MeasureTime = True
cloneTable = TrackBuildCloneTable("FindTrackClones")
cloneTable.maxDz = 500 * mm
cloneTable.zStates = [0 * mm, 990 * mm, 9450 * mm]
cloneTable.klCut = 5e3
cloneCleaner = TrackCloneCleaner("FlagTrackClones")
cloneCleaner.CloneCut = 5e3
trackClones.Members += [cloneTable, cloneCleaner]
## Add expected hit information
#if "ExpectedHits" in extraInfos :
# GaudiSequencer("TrackAddExtraInfoSeq").Members += [ TrackComputeExpectedHits() ]
## Add the likelihood information
if "TrackLikelihood" in extraInfos and ('TrackLikelihood'
not in exclude):
from Configurables import TrackAddLikelihood, TrackLikelihood
trackAddLikelihood = TrackAddLikelihood()
trackAddLikelihood.addTool(TrackLikelihood,
name="TrackMatching_likTool")
trackAddLikelihood.TrackMatching_likTool.otEff = 0.9
GaudiSequencer("TrackAddExtraInfoSeq").Members += [
trackAddLikelihood
]
## ghost probability using a Neural Net
if "GhostProbability" in extraInfos:
from Configurables import TrackAddNNGhostId, TrackNNGhostId
nn = TrackAddNNGhostId()
GaudiSequencer("TrackAddExtraInfoSeq").Members += [nn]
track.DetectorList += ["EraseExtraInformation"]
from Configurables import TrackEraseExtraInfo
GaudiSequencer("TrackEraseExtraInformationSeq").Members += [
TrackEraseExtraInfo()
]
## Muon alignment tracks
if "MuonAlign" in trackAlgs:
from Configurables import TrackEventFitter, AlignMuonRec
track.DetectorList += ["MuonRec"]
GaudiSequencer("TrackMuonRecSeq").Members += [
AlignMuonRec("AlignMuonRec"),
TrackEventFitter("MuonTrackFitter")
]
importOptions("$TRACKSYSROOT/options/AlignMuonRec.opts")
if TrackSys().fieldOff():
AlignMuonRec("AlignMuonRec").BField = False
importOptions("$STDOPTS/DstContentMuonAlign.opts")
def RecoTrackingHLT2(exclude=[],
simplifiedGeometryFit=True,
liteClustersFit=True):
'''Function that defines the pattern recognition algorithms for the HLT2 sequence of the Run 2 offline tracking'''
## Tracking sequence
from Configurables import ProcessPhase
track = ProcessPhase("TrackHLT2")
GaudiSequencer("RecoTrHLT2Seq").Members += [track]
tracklists = []
# Which algs to run ?
trackAlgs = TrackSys().getProp("TrackPatRecAlgorithms")
# Which data type is it?
dataType = TrackSys().getProp("DataType")
## Forward pattern
if "ForwardHLT2" in trackAlgs:
track.DetectorList += ["ForwardPatHLT2"]
# Need to filter out the Velo tracks of the fitted HLT1 tracks
#from Configurables import TrackListRefiner, TrackSelector
#refiner = TrackListRefiner("FilterForwardHLT1Tracks")
#refiner.inputLocation = "Rec/Track/FittedHLT1Tracks"
#refiner.outputLocation = "Rec/Track/FittedHLT1ForwardTracks"
#refiner.Selector = "TrackSelector"
#refiner.addTool(TrackSelector("TrackSelector"))
#refiner.TrackSelector.TrackTypes = [ "Long" ]
#GaudiSequencer("TrackHLT2ForwardPatHLT2Seq").Members += [ refiner ]
from Configurables import PatForward
GaudiSequencer("TrackHLT2ForwardPatHLT2Seq").Members += [
PatForward("PatForwardHLT2")
]
from PatAlgorithms import PatAlgConf
PatAlgConf.ForwardConf().configureAlgRun2HLT2()
if TrackSys().timing():
PatForward("PatForwardHLT2").TimingMeasurement = True
#tracklists += ["Rec/Track/ForwardHLT2"]
#merge forward from HLT1 and HLT2
from Configurables import TrackContainerCopy
merger = TrackContainerCopy("MergeForwardHLT1HLT2")
merger.inputLocations = [
"Rec/Track/FittedHLT1ForwardTracks", "Rec/Track/ForwardHLT2"
]
merger.outputLocation = "Rec/Track/Forward"
merger.copyFailures = True
GaudiSequencer("TrackHLT2ForwardPatHLT2Seq").Members += [merger]
tracklists += ["Rec/Track/Forward"]
## Seed pattern
if "PatSeed" in trackAlgs:
track.DetectorList += ["SeedPat"]
from Configurables import PatSeeding
GaudiSequencer("TrackHLT2SeedPatSeq").Members += [
PatSeeding("PatSeeding")
]
# should be replaced by more 'global' tracking configuration
from PatAlgorithms import PatAlgConf
PatAlgConf.SeedingConf().configureAlg()
if TrackSys().timing():
PatSeeding("PatSeeding").TimingMeasurement = True
if TrackSys().cosmics():
from PatAlgorithms import PatAlgConf
PatAlgConf.CosmicConf().configureAlg()
tracklists += ["Rec/Track/Seed"]
## Matching
if "PatMatch" in trackAlgs:
track.DetectorList += ["MatchPat"]
from Configurables import PatMatch
GaudiSequencer("TrackHLT2MatchPatSeq").Members += [
PatMatch("PatMatch")
]
# timing?
# global conf?
tracklists += ["Rec/Track/Match"]
## avoid running both downstream algos
if "Downstream" in trackAlgs and "PatLongLivedTracking" in trackAlgs:
raise RuntimeError(
"Cannot run both PatDownstream and PatLongLivedTracking at once")
## Downstream
if "Downstream" in trackAlgs:
track.DetectorList += ["DownstreamPat"]
from Configurables import PatDownstream
GaudiSequencer("TrackHLT2DownstreamPatSeq").Members += [
PatDownstream("PatDownstream")
]
from PatAlgorithms import PatAlgConf
# global conf?
#PatAlgConf.DownstreamConf().configureAlg()
if TrackSys().timing():
PatDownstream("PatDownstream").TimingMeasurement = True
tracklists += ["Rec/Track/Downstream"]
## PatLongLivedTracking (aka improved Downstream)
if "PatLongLivedTracking" in trackAlgs:
track.DetectorList += ["DownstreamPat"]
from Configurables import PatLongLivedTracking
GaudiSequencer("TrackHLT2DownstreamPatSeq").Members += [
PatLongLivedTracking("PatLongLivedTracking")
]
if TrackSys().timing():
PatLongLivedTracking(
"PatLongLivedTracking").TimingMeasurement = True
tracklists += ["Rec/Track/Downstream"]
fit = ProcessPhase("FitHLT2")
GaudiSequencer("RecoTrHLT2Seq").Members += [fit]
### Clean clone and fit
fit.DetectorList += ["Best"]
# complete the list of track lists
if "FastVelo" in trackAlgs:
tracklists += ["Rec/Track/Velo"]
if "VeloTT" in trackAlgs:
tracklists += ["Rec/Track/VeloTT"]
# create the best track creator
# note the comment for the HLT1 forward fitter about configurations
from TrackFitter.ConfiguredFitters import ConfiguredMasterFitter
from Configurables import TrackBestTrackCreator, TrackMasterFitter, TrackStateInitTool
# add and cut on the GP in the TrackBestTrackCreator
# the variable is needed later
addGhostProbTBTC = True
bestTrackCreator = TrackBestTrackCreator(TracksInContainers=tracklists)
bestTrackCreator.MaxChi2DoF = 4.0
bestTrackCreator.addTool(TrackMasterFitter, name="Fitter")
bestTrackCreator.DoNotRefit = True
bestTrackCreator.addTool(TrackStateInitTool, name="StateInitTool")
bestTrackCreator.StateInitTool.UseFastMomentumEstimate = True
# cut on ghost prob
bestTrackCreator.AddGhostProb = addGhostProbTBTC
bestTrackCreator.GhostIdTool = "Run2GhostId"
bestTrackCreator.MaxGhostProb = 0.4
# configure its fitter and stateinittool
ConfiguredMasterFitter(getattr(bestTrackCreator, "Fitter"),
SimplifiedGeometry=simplifiedGeometryFit,
LiteClusters=liteClustersFit,
MSRossiAndGreisen=True)
if "FastVelo" in trackAlgs:
bestTrackCreator.StateInitTool.VeloFitterName = "FastVeloFitLHCbIDs"
# add to the sequence
GaudiSequencer("FitHLT2BestSeq").Members += [bestTrackCreator]
### Change dEdx correction for simulated data
#if TrackSys().getProp("Simulation"):
# from Configurables import StateDetailedBetheBlochEnergyCorrectionTool,DetailedMaterialLocator
# from Configurables import TrackBestTrackCreator
# fitter = TrackBestTrackCreator().Fitter
# fitter.MaterialLocator.addTool(StateDetailedBetheBlochEnergyCorrectionTool("GeneralDedxTool"))
# fitter.MaterialLocator.GeneralDedxTool.EnergyLossFactor = 0.76
# Make V0
# needs to be done after fitting, but before the extra infos
from Configurables import TrackV0Finder
V0 = ProcessPhase("RecV0")
GaudiSequencer("RecoTrHLT2Seq").Members += [V0]
V0.DetectorList += ["MakeV0"]
### Clean clone and fit
trackV0Finder = TrackV0Finder("TrackV0Finder")
GaudiSequencer("RecV0MakeV0Seq").Members += [trackV0Finder]
#########################################################
##########################################################
addExtraInfo = ProcessPhase("AddExtraInfo")
GaudiSequencer("RecoTrHLT2Seq").Members += [addExtraInfo]
## Extra track information sequence
extraInfos = TrackSys().getProp("TrackExtraInfoAlgorithms")
if len(extraInfos) > 0:
## Clone finding and flagging
if "CloneFlagging" in extraInfos:
addExtraInfo.DetectorList += ["Clones"]
from Configurables import TrackBuildCloneTable, TrackCloneCleaner
#trackClones = GaudiSequencer("TrackClonesSeq")
if TrackSys().timing():
trackClones.MeasureTime = True
cloneTable = TrackBuildCloneTable("FindTrackClones")
cloneTable.maxDz = 500 * mm
cloneTable.zStates = [0 * mm, 990 * mm, 9450 * mm]
cloneTable.klCut = 5e3
cloneCleaner = TrackCloneCleaner("FlagTrackClones")
cloneCleaner.CloneCut = 5e3
#trackClones.Members += [ cloneTable, cloneCleaner ]
GaudiSequencer("AddExtraInfoClonesSeq").Members += [
cloneTable, cloneCleaner
]
## Add the likelihood information
if "TrackLikelihood" in extraInfos and ('TrackLikelihood'
not in exclude):
addExtraInfo.DetectorList += ["TrackLikelihood"]
from Configurables import TrackAddLikelihood, TrackLikelihood
trackAddLikelihood = TrackAddLikelihood()
trackAddLikelihood.addTool(TrackLikelihood,
name="TrackMatching_likTool")
trackAddLikelihood.TrackMatching_likTool.otEff = 0.9
GaudiSequencer("AddExtraInfoTrackLikelihoodSeq").Members += [
trackAddLikelihood
]
## ghost probability using a Neural Net
if "GhostProbability" in extraInfos and addGhostProbTBTC is False:
addExtraInfo.DetectorList += ["GhostProb"]
from Configurables import TrackAddNNGhostId
nn = TrackAddNNGhostId("TrackAddNNGhostdId")
nn.GhostIdTool = "Run2GhostId" # to be decided
GaudiSequencer("AddExtraInfoGhostProbSeq").Members += [nn]
# this is very misleading (naming wise), but it will erase extra info that is put on the track by some algorithms
# (not of the ones beforehand).
addExtraInfo.DetectorList += ["EraseExtraInfo"]
from Configurables import TrackEraseExtraInfo
# erase extra info on Best tracks and on fitted Velo tracks (i.e. on everything that is saved on a DST)
eraseExtraInfoBest = TrackEraseExtraInfo("TrackEraseExtraInfoBest")
eraseExtraInfoFittedVelo = TrackEraseExtraInfo(
"TrackEraseExtraInfoFittedVelo")
eraseExtraInfoFittedVelo.InputLocation = "Rec/Track/FittedHLT1VeloTracks"
GaudiSequencer("AddExtraInfoEraseExtraInfoSeq").Members += [
eraseExtraInfoBest, eraseExtraInfoFittedVelo
]
## Muon alignment tracks
## is this still needed? Looks rather old
if "MuonAlign" in trackAlgs:
from Configurables import TrackEventFitter, AlignMuonRec
track.DetectorList += ["MuonRec"]
GaudiSequencer("TrackMuonRecSeq").Members += [
AlignMuonRec("AlignMuonRec"),
TrackEventFitter("MuonTrackFitter")
]
importOptions("$TRACKSYSROOT/options/AlignMuonRec.opts")
if TrackSys().fieldOff():
AlignMuonRec("AlignMuonRec").BField = False
importOptions("$STDOPTS/DstContentMuonAlign.opts")
def doMyAlignChanges():
from Configurables import TESCheck
TESCheck().Stop = False
TESCheck().Enable = False
TweakFitter('FitDownstream')
TweakFitter('FitMatch')
TweakFitter('FitSeed')
TweakFitter('RefitSeed')
TweakFitter('FitForward')
TweakFitter('FitVelo')
TweakFitter('FitVeloTT')
TweakFitter('FitBest')
TweakFitter('TrackRefitter')
TrackEventFitter('TrackRefitter').Fitter.UpdateTransport = True
# add a filter on Velo tracks
from Configurables import TrackListFilter
GaudiSequencer("RecoVELOSeq").Members += [
TrackListFilter("VeloFilter", inputLocation="Rec/Track/Velo")
]
from Configurables import TrackMultiplicityFilter
GaudiSequencer("RecoDecodingSeq").Members += [
TrackMultiplicityFilter("MultFilter", MaxNumITHits=200)
]
from Configurables import PatSeeding, PatSeedingTool
ps = PatSeeding('PatSeeding')
ps.PatSeedingTool.CurveTol = 10
ps.PatSeedingTool.TolCollectIT = 5
ps.PatSeedingTool.QualityWeights = [0, -0.2]
ps.PatSeedingTool.MaxRangeIT = 100
ps.PatSeedingTool.MaxChi2HitIT = 60
ps.PatSeedingTool.MinXPlanes = 4
ps.PatSeedingTool.MinTotalPlanes = 8
ps.PatSeedingTool.MaxMisses = 2
ps.PatSeedingTool.MaxHoles = 2
ps.PatSeedingTool.MaxTrackChi2 = 30
ps.PatSeedingTool.MaxFinalChi2 = 40
ps.PatSeedingTool.MaxFinalTrackChi2 = 30
from Configurables import PatForward, PatForwardTool
pf = PatForward('PatForward')
pf.PatForwardTool.MinXPlanes = 4
pf.PatForwardTool.MinPlanes = 7
pf.PatForwardTool.MaxSpreadX = 2
pf.PatForwardTool.MinHits = 8
from Configurables import Tf__Tsa__Seed, Tf__Tsa__SeedAddHits
tsaSeed = Tf__Tsa__Seed("TsaSeed")
tsaSeed.addTool(Tf__Tsa__SeedAddHits(), name="SeedAddHits")
# tolerance if inside box mm
tsaSeed.SeedAddHits.tol = 3
# tolerance window make bigger mmm
tsaSeed.SeedAddHits.dCut = 2.5
# chi-sq cut
tsaSeed.SeedAddHits.outlierCutParabola = 5
from Configurables import TrackHitMapMonitor
GaudiSequencer("MoniTrSeq").Members.append(TrackHitMapMonitor())
from Configurables import STOfflinePosition
itClusterPosition = STOfflinePosition('ToolSvc.ITClusterPosition')
itClusterPosition.ErrorVec = [0.28, 0.22, 0.35, 0.35]
itClusterPosition.APE = 0.1
from Configurables import ST__STClusterMonitor
ST__STClusterMonitor('ITClusterMonitor').HitMaps = True
from Gaudi.Configuration import *
from Brunel.Configuration import *
from PRConfig import TestFileDB
TestFileDB.test_file_db[
"Brunel-SIM08-MinBias-Beam6500GeV-md100-nu4.8.xdst"].run()
from Configurables import ApplicationMgr, NTupleSvc, GaudiSequencer
from Configurables import (IdealTracksCreator, TrackStateInitAlg,
TrackBestTrackCreator, PrTrackAssociator,
Velo__VeloTrackMonitorNT, VeloClusterPosition,
TrackEventFitter)
from TrackFitter.ConfiguredFitters import ConfiguredFit
importOptions("$ASSOCIATORSROOT/options/MCParticleToMCHit.py")
# set the event fitter to use ideal tracks (no outlier rejections)
TrackEventFitter('FitVelo').Fitter.MaxNumberOutliers = 0
TrackEventFitter('TrackRefitter').Fitter.MaxNumberOutliers = 0
TrackEventFitter().TracksInContainer = 'MC/Track/Ideal'
# set the Velo and tracking monitor sequences to reconstruct ideal tracks
GaudiSequencer("MoniVELOSeq").Members = [
TrackStateInitAlg("InitIdealFit", TrackLocation="MC/Track/Ideal"),
ConfiguredFit("IdealFit", "MC/Track/Ideal"),
Velo__VeloTrackMonitorNT()
]
GaudiSequencer("RecoTrSeq").Members += [
IdealTracksCreator('IdealTracksCreator',
TrueStatesAtMCHits=True,
TrackTypes=[3])
]
TrackBestTrackCreator().TracksInContainers = ['MC/Track/Ideal']
def doMyAlignChanges():
from Configurables import TrackEventFitter, VeloTrackSelector
from TrackFitter.ConfiguredFitters import ConfiguredStraightLineFitter
TweakFitter(TrackEventFitter('FitMatch'))
TweakFitter(TrackEventFitter('FitForward'))
TweakFitter(TrackEventFitter('FitSeed'))
TweakFitter(TrackEventFitter('FitVelo'))
TweakFitter(TrackEventFitter('FitVeloTT'))
TweakFitter(TrackEventFitter('RefitSeed'))
TweakFitter(TrackEventFitter('TrackRefitter'))
# add a filter on Velo tracks
from Configurables import TrackListFilter
GaudiSequencer("RecoVELOSeq").Members += [
TrackListFilter("VeloFilter", inputLocation="Rec/Track/Velo")
]
GaudiSequencer("RecoVELOSeq").Members += [
TrackContainerCopy('VeloOnlyContainerCopy',
inputLocation="Rec/Track/Velo",
outputLocation="Rec/Track/VeloOnly",
copyFailures=True,
Selector=None),
ConfiguredStraightLineFitter('VeloOnlyFitter',
TracksInContainer="Rec/Track/VeloOnly")
]
veloOnlyRefiner = TrackListRefiner(
"VeloOnlySelector",
inputLocation="Rec/Track/VeloOnly",
outputLocation="Rec/Track/SelectedVeloOnly",
Selector=TrackSelector())
veloOnlyRefiner.Selector.MaxChi2Cut = 5
#veloOnlyRefiner.OutputLevel = 1
GaudiSequencer("RecoVELOSeq").Members.append(veloOnlyRefiner)
GaudiSequencer("RecoVELOSeq").Members += [
TrackListRefiner('VeloASideSelector',
inputLocation="Rec/Track/SelectedVeloOnly",
outputLocation="Rec/Track/VeloASide",
Selector=VeloTrackSelector()),
TrackCaloMatchMonitor("VeloAEcalMatchMonitor",
TrackLocation='Rec/Track/VeloASide',
CaloSystem='Ecal',
RequireTHits=False)
]
TrackListRefiner('VeloASideSelector').Selector.MinHitsASide = 6
GaudiSequencer("RecoVELOSeq").Members += [
TrackListRefiner('VeloCSideSelector',
inputLocation="Rec/Track/SelectedVeloOnly",
outputLocation="Rec/Track/VeloCSide",
Selector=VeloTrackSelector()),
TrackCaloMatchMonitor("VeloCEcalMatchMonitor",
TrackLocation='Rec/Track/VeloCSide',
CaloSystem='Ecal',
RequireTHits=False)
]
TrackListRefiner('VeloCSideSelector').Selector.MinHitsCSide = 6
from Configurables import AlRobustAlignAlg
GaudiSequencer("AlignMonitorSeq").Members += [
AlRobustAlignAlg('VeloARobustAlign',
TrackLocation="Rec/Track/VeloASide"),
AlRobustAlignAlg('VeloCRobustAlign',
TrackLocation="Rec/Track/VeloCSide")
]
GaudiSequencer("AlignPostMonitorSeq").Members += [
AlRobustAlignAlg('VeloARobustAlignPost',
TrackLocation="Rec/Track/VeloASide"),
AlRobustAlignAlg('VeloCRobustAlignPost',
TrackLocation="Rec/Track/VeloCSide")
]
from Configurables import Tf__Tsa__Seed, Tf__Tsa__SeedAddHits
tsaSeed = Tf__Tsa__Seed("TsaSeed")
tsaSeed.addTool(Tf__Tsa__SeedAddHits(), name="SeedAddHits")
# tolerance if inside box mm
tsaSeed.SeedAddHits.tol = 5
# tolerance window make bigger mmm
tsaSeed.SeedAddHits.dCut = 2
# chi-sq cut
tsaSeed.SeedAddHits.outlierCutParabola = 5
from Configurables import STOfflinePosition
itClusterPosition = STOfflinePosition('ToolSvc.ITClusterPosition')
itClusterPosition.ErrorVec = [0.28, 0.22, 0.35, 0.35]
itClusterPosition.APE = 0.1
from Configurables import TrackFieldOffMatchMonitor
seedRefiner = TrackListRefiner("SeedSelector",
inputLocation="Rec/Track/Seed",
outputLocation="Rec/Track/SelectedSeed",
Selector=TrackSelector())
seedRefiner.Selector.MaxChi2Cut = 5
GaudiSequencer('MoniTrSeq').Members += [
seedRefiner,
TrackFieldOffMatchMonitor(
VeloTrackLocation='Rec/Track/SelectedVeloOnly',
SeedTrackLocation='Rec/Track/SelectedSeed')
]
from Configurables import TrackMatchVeloSeed
TrackMatchVeloSeed("TrackMatch").Chi2MatchingCut = 500
TAlignment().WriteCondSubDetList = ['Velo', 'TT', 'IT', 'OT']
#TAlignment().EigenValueThreshold = 100
#TAlignment().MinEigenModeChisquare = 100
TAlignment().MinNumberOfHits = 1
# still set up a track selection
from Configurables import (GaudiSequencer, TrackListRefiner, TrackListMerger,
TrackSelector, TrackMonitor, ITTrackSelector,
TrackHitAdder)
from TrackFitter.ConfiguredFitters import *
GaudiSequencer("TrackAddExtraInfoSeq").Members += [
TrackHitAdder("TrackHitAdder", TrackLocation="Rec/Track/Best"),
ConfiguredEventFitter("TrackRefitter", TracksInContainer="Rec/Track/Best")
]
TrackEventFitter("TrackRefitter").Fitter.UpdateTransport = True
trackFilterSeq = GaudiSequencer("TrackFilterSeq")
alignSelectorA = TrackListRefiner("AlignSelectorA",
inputLocation="Rec/Track/Best",
outputLocation="Rec/Track/AlignTracksA",
Selector=TrackSelector())
alignSelectorA.Selector.MaxChi2Cut = 10
alignSelectorA.Selector.MaxChi2PerDoFMatch = 10
alignSelectorA.Selector.MaxChi2PerDoFVelo = 5
alignSelectorA.Selector.MaxChi2PerDoFDownstream = 5
alignSelectorA.Selector.MinPCut = 10000
alignSelectorA.Selector.TrackTypes = ["Long", "Downstream"]
#this one selects specifically overlap tracks. we only take T-tracks with overlaps
alignSelectorB = TrackListRefiner("AlignSelectorB",