def ConfiguredPatSeeding(name
, OutputTracksName
, VetoTrackLocations = None):
if name == None:
log.fatal( '##################################################################################')
log.fatal( '## FATAL You did not specify the name of the PatSeeding instance.' )
log.fatal( '## FATAL I will now die, you need to make Hlt2Tracking aware of the name! ')
log.fatal( '##################################################################################')
from Configurables import PatSeeding
from Configurables import PatSeedingTool
recoSeeding = PatSeeding(name, OutputTracksName = OutputTracksName )
recoSeeding.addTool(PatSeedingTool, name="PatSeedingTool")
# New tool
if VetoTrackLocations != None and len(VetoTrackLocations) != 0:
from Configurables import TrackUsedLHCbID
recoSeeding.PatSeedingTool.UsedLHCbIDToolName = "TrackUsedLHCbID"
recoSeeding.PatSeedingTool.addTool( TrackUsedLHCbID, name="TrackUsedLHCbID" )
recoSeeding.PatSeedingTool.TrackUsedLHCbID.inputContainers = VetoTrackLocations
from Configurables import HltRecoConf
from HltRecoConf import OnlineSeedingToolOptions, OfflineSeedingToolOptions
if HltRecoConf().getProp("OfflineSeeding"):
recoSeeding.PatSeedingTool.NDblOTHitsInXSearch = OfflineSeedingToolOptions ["NDblOTHitsInXSearch"]
recoSeeding.PatSeedingTool.MinMomentum = OfflineSeedingToolOptions["MinMomentum"]
else:
recoSeeding.PatSeedingTool.NDblOTHitsInXSearch = OnlineSeedingToolOptions ["NDblOTHitsInXSearch"]
recoSeeding.PatSeedingTool.MinMomentum = OnlineSeedingToolOptions["MinMomentum"]
from Configurables import HltRecoConf
from HltTracking.HltRecoConf import CommonForwardOptions
recoSeeding.PatSeedingTool.MaxOTHits = HltRecoConf().getProp("Forward_MaxOTHits")
recoSeeding.PatSeedingTool.MaxITHits = CommonForwardOptions["MaxITHits"]
return recoSeeding
def Hlt1GECStreamer(gec='Loose', accept=True):
from Configurables import HltRecoConf
gecs = {
'Tight': {
'MaxOTHits': HltRecoConf().getProp("Forward_MaxOTHits"),
'MaxITHits': 3000,
'MaxVeloHits': 3000,
'IsActivity': False
},
'Loose': {
'MaxOTHits': HltRecoConf().getProp("Forward_MaxOTHits"),
'MaxITHits': 3000,
'MaxVeloHits': 6000,
'IsActivity': False
},
'Activity': {
'MinOTHits': 100,
'MinITHits': 100,
'MinVeloHits': 100,
'IsActivity': True
}
}
from Configurables import Hlt__GEC
from HltLine.HltDecodeRaw import DecodeIT, DecodeVELO
from HltLine.HltLine import bindMembers
tool = Hlt__GEC("%sGECs" % gec, **gecs[gec])
code = "ACCEPT( '%s' )" % tool.getFullName()
if not accept: code = '~' + code
bm = bindMembers(None, [DecodeIT, DecodeVELO])
return "GEC%s%s = ( execute( %s ) & %s ) " % ({
True: 'Accept',
False: 'Reject'
}[accept], gec, [m.getFullName() for m in bm.members()], code)
def recoVelo(OutputTracksName=HltSharedTrackLoc["Velo"]):
recoVelo = FastVeloTracking( 'FastVeloHlt', OutputTracksName = OutputTracksName)
recoVelo.StatPrint = True
extendVelo = HltRecoConf().getProp("BeamGasMode")
if extendVelo:
recoVelo.ZVertexMin = HltRecoConf().getProp("VeloTrackingZMin")
recoVelo.ZVertexMax = HltRecoConf().getProp("VeloTrackingZMax")
recoVelo.VetoObjects = [ OutputTracksName ]
return recoVelo
def ConfigureFitter( fitter ):
from TrackFitter.ConfiguredFitters import ConfiguredHltFitter, ConfiguredMasterFitter
# configure the fitter
if not HltRecoConf().getProp("MoreOfflineLikeFit"):
ConfiguredHltFitter( fitter )
fitter.NumberFitIterations = HltRecoConf().getProp("FitIterationsInHltFit")
else:
ConfiguredMasterFitter( fitter , SimplifiedGeometry = True, LiteClusters = True, MSRossiAndGreisen = HltRecoConf().getProp("NewMSinFit"))
# Ignore Muon hits
fitter.MeasProvider.IgnoreMuon = True
return fitter
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 ConfiguredHltInitFitter( parent ):
from Configurables import ( TrackEventFitter, TrackMasterFitter, TrackInitFit, TrackStateInitTool )
if not HltRecoConf().getProp("InitFits"):
parent.addTool( TrackMasterFitter, name="Fitter")
fitter = parent.Fitter
else:
parent.addTool( TrackInitFit, name = "Fitter")
parent.Fitter.Init = "TrackStateInitTool/StateInit"
parent.Fitter.addTool(TrackStateInitTool, name="StateInit")
parent.Fitter.StateInit.VeloFitterName = "FastVeloFitLHCbIDs"
parent.Fitter.StateInit.UseFastMomentumEstimate = True
parent.Fitter.StateInit.addTool(TrackMasterExtrapolator, "Extrapolator")
parent.Fitter.StateInit.Extrapolator.MaterialLocator = "SimplifiedMaterialLocator"
parent.Fitter.Fit = "TrackMasterFitter/Fitter"
parent.Fitter.addTool(TrackMasterFitter, name="Fitter")
fitter = parent.Fitter.Fitter
ConfigureFitter( fitter )
return fitter
def ConfiguredForwardComplement(name
, InputTracksName #= HltSharedTrackLoc["Velo"]
, OutputTracksName #= Hlt2TrackLoc["ForwardComp"]
, VetoSeedLocations #= [ HltSharedTrackLoc["ForwardHPT"] ]
, MinMomentum #= HltRecoConf().getProp("Forward_LPT_MinP")
, MinPt #= HltRecoConf().getProp("Forward_LPT_MinPt")
):
if name == None:
log.fatal( '##################################################################################')
log.fatal( '## FATAL You did not specify the name of the PatForward instance.' )
log.fatal( '## FATAL I will now die, you need to make Hlt2Tracking aware of the name! ')
log.fatal( '##################################################################################')
forward = PatForward( name
, InputTracksName = InputTracksName
, OutputTracksName = OutputTracksName
)
#Sascha Stahl: We should get rid of GECs in the pattern reco, do it centrally
from HltRecoConf import CommonForwardOptions
from Configurables import HltRecoConf
forward.maxOTHits = HltRecoConf().getProp("Forward_MaxOTHits")
forward.maxITHits = CommonForwardOptions["MaxITHits"]
forward.MaxNVelo = CommonForwardOptions["MaxNVelo"]
from HltRecoConf import CommonForwardTrackingOptions, ComplementForwardToolOptions
opts = CommonForwardTrackingOptions.copy()
opts.update(ComplementForwardToolOptions)
opts.update({"MinMomentum" : MinMomentum
,"MinPt" : MinPt })
forward.addTool(PatForwardTool(**opts), name='PatForwardTool')
from Configurables import TrackUsedLHCbID
if VetoSeedLocations != None and len(VetoSeedLocations) != 0:
forward.PatForwardTool.addTool(TrackUsedLHCbID, name='TrackUsedLHCbID')
forward.PatForwardTool.UsedLHCbIDToolName="TrackUsedLHCbID"
forward.PatForwardTool.TrackUsedLHCbID.inputContainers= VetoSeedLocations
forward.PatForwardTool.VeloVetoTracksNames = VetoSeedLocations
# make them a bit more verbose
forward.StatPrint = True
forward.PatForwardTool.StatPrint = True
return forward
def __hlt2VeloMuonTracking(self):
"""
VeloMuon track reconstruction for Hlt2
"""
#HltSharedTracking decides which Velo sequence is used
from Configurables import Hlt2Conf, VeloMuonBuilder, StandaloneMuonRec, TrackMasterFitter
from Configurables import MeasurementProviderT_MeasurementProviderTypes__VeloLiteR_, MeasurementProviderT_MeasurementProviderTypes__VeloLitePhi_
from HltLine.HltLine import bindMembers
# Define output location
VeloMuonTracksOutputLocation = Hlt2TrackEffLoc["VeloMuon"]
# Get Muon standalone track
Hlt2StandaloneMuon = StandaloneMuonRec("Hlt2StandaloneMuon")
Hlt2StandaloneMuon.OutputMuonTracksName = Hlt2TrackEffLoc[
"StandaloneMuon"]
#build VeloMuon track
Hlt2VeloMuonBuild = VeloMuonBuilder('Hlt2VeloMuonBuild')
Hlt2VeloMuonBuild.MuonLocation = Hlt2StandaloneMuon.OutputMuonTracksName
Hlt2VeloMuonBuild.VeloLocation = HltSharedTrackLoc[
"Velo"] #Velo track location in Hlt
Hlt2VeloMuonBuild.lhcbids = 4
Hlt2VeloMuonBuild.OutputLocation = VeloMuonTracksOutputLocation
Hlt2VeloMuonBuild.addTool(TrackMasterFitter)
from TrackFitter.ConfiguredFitters import ConfiguredHltFitter, ConfiguredMasterFitter
from Configurables import HltRecoConf
ConfiguredMasterFitter(Hlt2VeloMuonBuild.TrackMasterFitter,
SimplifiedGeometry=True,
LiteClusters=True,
MSRossiAndGreisen=HltRecoConf().getProp(
"NewMSinFit")) #on par with Hlt track fits
Hlt2VeloMuonBuild.TrackMasterFitter.OutputLevel = 5
# Build the bindMembers
bm_name = self.getProp("Prefix") + "VeloMuonTracking"
bm_members = [Hlt2StandaloneMuon, Hlt2VeloMuonBuild]
bm_output = VeloMuonTracksOutputLocation
return bindMembers(bm_name, bm_members).setOutputSelection(bm_output)
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 PV3D(where):
""" PV3D(where) -- where must either by Hlt1 or Hlt2 """
#from HltTrackNames import HltSharedRZVeloTracksName, HltSharedTracksPrefix, _baseTrackLocation
from HltVertexNames import HltSharedVerticesPrefix
from HltVertexNames import HltGlobalVertexLocation
from Configurables import PatPV3D
from Configurables import PVOfflineTool, LSAdaptPV3DFitter
from Configurables import SimplifiedMaterialLocator, TrackMasterExtrapolator
if where.upper() not in ['HLT1', 'HLT2']:
raise KeyError('PV3D: where must be either HLT1 or HLT2')
#TODO: Move these options to HltRecoConf
output3DVertices = _vertexLocation(HltSharedVerticesPrefix,
HltGlobalVertexLocation, PV3DSelection)
recoPV3D = PatPV3D('HltPVsPV3D')
recoPV3D.addTool(PVOfflineTool, "PVOfflineTool")
recoPV3D.PVOfflineTool.PVSeedingName = "PVSeed3DTool"
recoPV3D.PVOfflineTool.PVFitterName = "LSAdaptPV3DFitter"
recoPV3D.PVOfflineTool.addTool(LSAdaptPV3DFitter, "LSAdaptPV3DFitter")
offlineTool = recoPV3D.PVOfflineTool
fitter = recoPV3D.PVOfflineTool.LSAdaptPV3DFitter
# Set options from HltRecoConf
from Configurables import HltRecoConf
for opt, value in HltRecoConf().getProp("PVOptions").iteritems():
found = False
for tool in (fitter, offlineTool):
if opt in tool.getProperties():
tool.setProp(opt, value)
found = True
if not found:
raise AttributeError("HltPVs.py: no tool has property %s" % opt)
## Simplified Material for TrackMasterExtrapolator
recoPV3D.PVOfflineTool.LSAdaptPV3DFitter.addTool(
TrackMasterExtrapolator, "TrackMasterExtrapolator")
recoPV3D.PVOfflineTool.LSAdaptPV3DFitter.TrackMasterExtrapolator.addTool(
SimplifiedMaterialLocator, name="MaterialLocator")
## Simplified Material for Recalculate. Not used, but let's not load
from Configurables import PVOfflineRecalculate
recoPV3D.PVOfflineTool.addTool(PVOfflineRecalculate,
"PVOfflineRecalculate")
recoPV3D.PVOfflineTool.PVOfflineRecalculate.addTool(
TrackMasterExtrapolator, "TrackMasterExtrapolator")
recoPV3D.PVOfflineTool.PVOfflineRecalculate.TrackMasterExtrapolator.addTool(
SimplifiedMaterialLocator, name="MaterialLocator")
if HltRecoConf().getProp("FitVelo"):
recoPV3D.PVOfflineTool.LSAdaptPV3DFitter.UseFittedTracks = True
#recoPV3D.PVOfflineTool.LSAdaptPV3DFitter.zVtxShift = 0.0
recoPV3D.OutputVerticesName = output3DVertices
from HltSharedTracking import FittedVelo, RevivedVelo
velo = FittedVelo if HltRecoConf().getProp("FitVelo") else RevivedVelo
pv3dAlgos = ','.join(
["'%s'" % m.getFullName() for m in velo.members() + [recoPV3D]])
recoPV3D.PVOfflineTool.InputTracks = [velo.outputSelection()]
from Configurables import LoKi__HltUnit as HltUnit
## Hlt vertex beamspot filter
##-- todo: can we integrate this in the main streamers directly, using 'tee' ?
## TODO: Make this a configurable.
name = "HltPV3D"
makePV3DSel = HltUnit(name,
Preambulo=[
'from LoKiPhys.decorators import *',
'from LoKiTrigger.decorators import *',
'from LoKiHlt.algorithms import *'
],
Code="""
execute( %(algo)s ) * VSOURCE( '%(tesInput)s' )
>> VX_SINK( '%(hltFinal)s' )
>> ~VEMPTY
""" % {
'algo': pv3dAlgos,
'tesInput': recoPV3D.OutputVerticesName,
'hltFinal': PV3DSelection
})
pv3d = bindMembers(name + 'Sequence',
[makePV3DSel]).setOutputSelection(PV3DSelection)
pv3d.output = output3DVertices
return pv3d
def ConfiguredGoodTrackFilter (name,
InputLocation,
OutputLocation = None):
if name == None:
log.fatal( '##################################################################################')
log.fatal( '## FATAL You did not specify the name of the Filter instance.' )
log.fatal( '## FATAL I will now die, you need to make Hlt2Tracking aware of the name! ')
log.fatal( '##################################################################################')
if OutputLocation == None: OutputLocation = InputLocation + "Filtered"
from Configurables import TrackListRefiner
filterTracks = TrackListRefiner( name,
inputLocation = InputLocation,
outputLocation = OutputLocation)
from Configurables import LoKi__Hybrid__TrackSelector as LoKiTrackSelector
filterTracks.addTool(LoKiTrackSelector,name="LokiTracksSelector")
filterTracks.Selector = LoKiTrackSelector(name="LokiTracksSelector")
filterTracks.Selector.Code = "(~TrINVALID) & ( TrCHI2PDOF < %(TrChi2)s )" % {"TrChi2": HltRecoConf().getProp("GoodTrCHI2PDOF")}
filterTracks.Selector.StatPrint = True
return filterTracks
from Configurables import HltRecoConf
## Simplified Material for public MasterExtrapolator and TrackStateProvider
ToolSvc().addTool(TrackMasterExtrapolator, "TrackMasterExtrapolator")
ToolSvc().TrackMasterExtrapolator.addTool(SimplifiedMaterialLocator, name="MaterialLocator")
ToolSvc().TrackMasterExtrapolator.MaterialLocator.addTool( StateThickMSCorrectionTool, name= "StateMSCorrectionTool" )
ToolSvc().addTool(TrackStateProvider, "TrackStateProvider")
ToolSvc().TrackStateProvider.addTool(TrackMasterExtrapolator,name="Extrapolator")
ToolSvc().TrackStateProvider.Extrapolator.addTool(SimplifiedMaterialLocator, name="MaterialLocator")
ToolSvc().TrackStateProvider.Extrapolator.MaterialLocator.addTool( StateThickMSCorrectionTool, name= "StateMSCorrectionTool" )
ToolSvc().TrackStateProvider.addTool(TrackInterpolator,"Interpolator")
ToolSvc().TrackStateProvider.Interpolator.addTool(TrackMasterExtrapolator,name="Extrapolator")
ToolSvc().TrackStateProvider.addTool(TrackInterpolator,"Interpolator")
ToolSvc().TrackStateProvider.Interpolator.Extrapolator.addTool(SimplifiedMaterialLocator, name="MaterialLocator")
ToolSvc().TrackStateProvider.Interpolator.Extrapolator.MaterialLocator.addTool( StateThickMSCorrectionTool, name= "StateMSCorrectionTool")
if HltRecoConf().getProp("NewMSinFit"):
ToolSvc().TrackMasterExtrapolator.MaterialLocator.StateMSCorrectionTool.UseRossiAndGreisen = True
ToolSvc().TrackStateProvider.Extrapolator.MaterialLocator.StateMSCorrectionTool.UseRossiAndGreisen = True
ToolSvc().TrackStateProvider.Interpolator.Extrapolator.MaterialLocator.StateMSCorrectionTool.UseRossiAndGreisen = True
if HltRecoConf().getProp("CacheStatesInStateProvider"):
ToolSvc().TrackStateProvider.CacheStatesOnDemand = True
else:
ToolSvc().TrackStateProvider.CacheStatesOnDemand = False
#### Velo Tracking
# the full Velo reconstruction
def recoVelo(OutputTracksName=HltSharedTrackLoc["Velo"]):
recoVelo = FastVeloTracking( 'FastVeloHlt', OutputTracksName = OutputTracksName)
recoVelo.StatPrint = True
extendVelo = HltRecoConf().getProp("BeamGasMode")
def __hlt2MuonTTTracking(self):
"""
MuonTT track reconstruction for Hlt2
"""
from Configurables import Hlt2Conf
from Configurables import MuonTTTrack, TrackMasterFitter, PatAddTTCoord, MuonCombRec, MuonHitDecode, TrackMasterExtrapolator
from Configurables import MeasurementProviderT_MeasurementProviderTypes__TTLite_, StateThickMSCorrectionTool
from HltLine.HltLine import bindMembers
from Configurables import HltRecoConf
from HltRecoConf import CommonForwardTrackingOptions, MuonTTOptions
from HltTracking.HltPVs import PV3D
# from Hlt1Lines.HltConfigurePR import ConfiguredPR
pvreco = PV3D('Hlt2')
Hlt2MuonTTTrack = MuonTTTrack("Hlt2MuonTTTrack")
Hlt2MuonTTTrack.AddTTHits = True
Hlt2MuonTTTrack.FillMuonStubInfo = False
Hlt2MuonTTTrack.ToolName = "MuonCombRec"
Hlt2MuonTTTrack.OutputLevel = 6
Hlt2MuonTTTrack.MC = False
Hlt2MuonTTTrack.PVLocation = pvreco.output
Hlt2MuonTTTrack.addTool(MuonCombRec)
Hlt2MuonTTTrack.MuonCombRec.ClusterTool = "MuonFakeClustering"
Hlt2MuonTTTrack.MuonCombRec.CloneKiller = False
Hlt2MuonTTTrack.MuonCombRec.StrongCloneKiller = False
Hlt2MuonTTTrack.MuonCombRec.SeedStation = MuonTTOptions["SeedStation"]
Hlt2MuonTTTrack.MuonCombRec.DecodingTool = "MuonHitDecode"
Hlt2MuonTTTrack.MuonCombRec.PadRecTool = "MuonPadRec"
Hlt2MuonTTTrack.MuonCombRec.AssumePhysics = True
Hlt2MuonTTTrack.MuonCombRec.MeasureTime = True
Hlt2MuonTTTrack.MuonCombRec.addTool(MuonHitDecode("MuonHitDecode"))
Hlt2MuonTTTrack.MuonCombRec.MuonHitDecode.SkipHWNumber = True
Hlt2MuonTTTrack.addTool(PatAddTTCoord)
Hlt2MuonTTTrack.PatAddTTCoord.YTolSlope = MuonTTOptions["YTolSlope"]
Hlt2MuonTTTrack.PatAddTTCoord.XTol = MuonTTOptions["XTol"]
Hlt2MuonTTTrack.PatAddTTCoord.XTolSlope = MuonTTOptions["XTolSlope"]
Hlt2MuonTTTrack.PatAddTTCoord.MaxChi2Tol = MuonTTOptions["MaxChi2Tol"]
Hlt2MuonTTTrack.PatAddTTCoord.MinAxProj = MuonTTOptions["MinAxProj"]
Hlt2MuonTTTrack.PatAddTTCoord.MajAxProj = MuonTTOptions["MaxAxProj"]
Hlt2MuonTTTrack.addTool(TrackMasterFitter)
from TrackFitter.ConfiguredFitters import ConfiguredHltFitter, ConfiguredMasterFitter
from Configurables import HltRecoConf, SimplifiedMaterialLocator
ConfiguredMasterFitter(Hlt2MuonTTTrack.TrackMasterFitter,
SimplifiedGeometry=True,
LiteClusters=True,
MSRossiAndGreisen=HltRecoConf().getProp(
"NewMSinFit")) #on par with Hlt track fits
Hlt2MuonTTTrack.TrackMasterFitter.OutputLevel = 5
Hlt2MuonTTTrack.addTool(TrackMasterExtrapolator)
Hlt2MuonTTTrack.TrackMasterExtrapolator.MaterialLocator = "SimplifiedMaterialLocator"
Hlt2MuonTTTrack.addTool(TrackMasterExtrapolator)
Hlt2MuonTTTrack.TrackMasterExtrapolator.addTool(
SimplifiedMaterialLocator, name="MaterialLocator")
materialLocator = Hlt2MuonTTTrack.TrackMasterExtrapolator.MaterialLocator
materialLocator.addTool(StateThickMSCorrectionTool,
name="StateMSCorrectionTool")
materialLocator.StateMSCorrectionTool.UseRossiAndGreisen = HltRecoConf(
).getProp("NewMSinFit")
Hlt2MuonTTTrack.Output = Hlt2TrackEffLoc["MuonTT"]
# Build the bindMembers
bm_name = self.getProp("Prefix") + "MuonTTTracking"
bm_members = [pvreco, Hlt2MuonTTTrack]
bm_output = Hlt2MuonTTTrack.Output
return bindMembers(bm_name, bm_members).setOutputSelection(bm_output)