def MakeVeloTracks(self,prefilter):
if self.__confdict__["DoVeloDecoding"]:
from DAQSys.Decoders import DecoderDB
from DAQSys.DecoderClass import decodersForBank
decs=[]
vdec=DecoderDB["DecodeVeloRawBuffer/createBothVeloClusters"]
vdec.Active=True
DecoderDB["DecodeVeloRawBuffer/createVeloClusters"].Active=False
DecoderDB["DecodeVeloRawBuffer/createVeloLiteClusters"].Active=False
decs=decs+[vdec]
VeloDecoding = GaudiSequencer("RecoDecodingSeq")
VeloDecoding.Members += [d.setup() for d in decs ]
MyFastVeloTracking = FastVeloTracking("For%sFastVelo"%self.name,OutputTracksName=self.VeloTrackOutputLocation)
MyFastVeloTracking.OnlyForward = True
MyFastVeloTracking.ResetUsedFlags = True
### prepare for fitting
preve = TrackStateInitAlg("For%sInitSeedFit"%self.name,TrackLocation = self.VeloTrackOutputLocation)
preve.StateInitTool.VeloFitterName = "FastVeloFitLHCbIDs"
copyVelo = TrackContainerCopy( "For%sCopyVelo"%self.name )
copyVelo.inputLocations = [self.VeloTrackOutputLocation]
copyVelo.outputLocation = self.FittedVeloTrackOutputLocation
### fitting
if self.__confdict__["VeloFitter"] == "ForwardStraightLine":
MyVeloFit = ConfiguredForwardStraightLineEventFitter(Name="For%sVeloRefitterAlg"%self.name,
TracksInContainer=self.FittedVeloTrackOutputLocation)
elif self.__confdict__["VeloFitter"] == "SimplifiedGeometry":
MyVeloFit = ConfiguredEventFitter(Name="For%sVeloRefitterAlg"%self.name,
TracksInContainer=self.FittedVeloTrackOutputLocation,
SimplifiedGeometry = True)
else:
MyVeloFit = ConfiguredEventFitter(Name="For%sVeloRefitterAlg"%self.name,
TracksInContainer=self.FittedVeloTrackOutputLocation)
#### making the proto particles
MakeVeloProtos = ChargedProtoParticleMaker('For%sVeloProtoMaker'%self.name)
MakeVeloProtos.Inputs=[self.FittedVeloTrackOutputLocation]
MakeVeloProtos.Output = self.VeloProtoOutputLocation
MakeVeloProtos.addTool( DelegatingTrackSelector, name="TrackSelector" )
MakeVeloProtos.TrackSelector.TrackTypes = [ "Velo" ]
#### the full sequence
makeparts = GaudiSequencer('For%sMakeVeloTracksGS'%self.name)
if self.__confdict__["DoVeloDecoding"]:
makeparts.Members += [ VeloDecoding ]
makeparts.Members += [ MyFastVeloTracking ]
makeparts.Members += [ preve ]
makeparts.Members += [ copyVelo ]
makeparts.Members += [ MyVeloFit ]
makeparts.Members += [ MakeVeloProtos ]
#### some python magic to maek this appear like a "Selection"
return GSWrapper(name="For%sWrappedVeloTrackingFor"%self.name,
sequencer=makeparts,
output=self.VeloProtoOutputLocation,
requiredSelections = prefilter)
def applyConf(self):
MSRossiAndGreisen = False
# For Run 2, we want the new multiple scattering
if (self.getProp("DataType") in self.Run2DataTypes):
MSRossiAndGreisen = True
muonTrackFit = ConfiguredEventFitter(
'MuonTrackFitter',
'Rec/Track/Muon',
MSRossiAndGreisen=MSRossiAndGreisen)
muonTrackFit.Fitter.addTool(TrackKalmanFilter, 'NodeFitter')
muonTrackFit.Fitter.addTool(MeasurementProvider, name='MeasProvider')
muonTrackFit.Fitter.MeasProvider.IgnoreVelo = True
muonTrackFit.Fitter.MeasProvider.IgnoreTT = True
muonTrackFit.Fitter.MeasProvider.IgnoreIT = True
muonTrackFit.Fitter.MeasProvider.IgnoreOT = True
muonTrackFit.Fitter.MeasProvider.IgnoreMuon = False
muonTrackFit.Fitter.MeasProvider.MuonProvider.clusterize = True #=======
#muonTrackFit.Fitter.MeasProvider.MuonProvider.OutputLevel = DEBUG #=======
muonTrackFit.Fitter.ErrorX = 1000
muonTrackFit.Fitter.ErrorY = 1000
muonTrackFit.Fitter.ErrorTx = 0.7
muonTrackFit.Fitter.ErrorTy = 0.7
muonTrackFit.Fitter.NumberFitIterations = 4
muonTrackFit.Fitter.MaxNumberOutliers = 0 #2
muonTrackFit.OutputLevel = self.getProp("OutputLevel")
muonMoniSeq = self.getProp("Sequencer")
monalig = MuonTrackAligMonitor("MuonTrackAligMonitor",
HistoTopDir="Muon/",
HistoLevel=self.getProp("Histograms"))
monalig.OutputLevel = self.getProp("OutputLevel")
#monalig.IsLongTrackState = True
monalig.LongToMuonMatch = True
monalig.pCut = 6 # =========
monalig.chi2nCut = 3
monalig.chi2matchCut = 10
monalig.IsCosmics = False
# For Run 2, we want the new multiple scattering
if (self.getProp("DataType") in self.Run2DataTypes):
from Configurables import TrackMasterExtrapolator, DetailedMaterialLocator, StateThickMSCorrectionTool
monalig.addTool(TrackMasterExtrapolator, name="Extrapolator")
monalig.Extrapolator.addTool(DetailedMaterialLocator,
name="MaterialLocator")
monalig.Extrapolator.MaterialLocator.addTool(
StateThickMSCorrectionTool, "StateMSCorrectionTool")
monalig.Extrapolator.MaterialLocator.StateMSCorrectionTool.UseRossiAndGreisen = True
muonMoniSeq.Members += [muonTrackFit, monalig]
def algorithm(self):
Name = self._name
inputTrackLocation = self._inputLocation
from Configurables import GaudiSequencer, HltTrackConverter, TrackContainerCopy, Escher
from Configurables import TrackContainerCopy, TrackSelector
trackRefitSeq = GaudiSequencer(
self.name() + "Seq") # GaudiSequencer("TrackRefitSeq")
# create a track list for tracks with velo hits
velotrackselector = TrackContainerCopy(
"GoodLongRefittedVeloTracks",
inputLocations=["Rec/Track/Best"],
outputLocation="Rec/Track/GoodLongRefittedVeloTracks",
Selector=TrackSelector())
velotrackselector.Selector.MinNVeloRHits = 7
velotrackselector.Selector.MinNVeloPhiHits = 6
# refit the tracks in that list
from TrackFitter.ConfiguredFitters import *
velotrackrefitter = ConfiguredEventFitter(
Name="TracksWithVeloHitsFitter",
TracksInContainer="Rec/Track/GoodLongRefittedVeloTracks",
FieldOff=True)
velotrackrefitter.Fitter.MeasProvider.IgnoreIT = True
velotrackrefitter.Fitter.MeasProvider.IgnoreOT = True
velotrackrefitter.Fitter.MeasProvider.IgnoreTT = True
velotrackrefitter.Fitter.MeasProvider.IgnoreMuon = True
velotrackrefitter.Fitter.MakeNodes = True
velotrackrefitter.Fitter.MakeMeasurements = True
trackRefitSeq.Members += [velotrackselector, velotrackrefitter]
return trackRefitSeq
def configuredFitAndHitAdderSequence(Name, InputLocation, OutputLocation):
from TrackFitter.ConfiguredFitters import ConfiguredEventFitter
from Configurables import (TrackHitAdder, TrackContainerCopy,
TrackSelector, GaudiSequencer,
TrackStateInitAlg)
# create the sequence
if isinstance(Name, GaudiSequencer):
seq = Sequence
Name = seq.name()
Name.replace('Sequence', '')
Name.replace('Seq', '')
else:
seq = GaudiSequencer(Name + 'Seq')
# I am lazy: use the DOD to get the decoded clusters
#importOption( "$STDOPTS/DecodeRawEvent.py" )
# now setup the fitters
seq.Members += [
TrackStateInitAlg(Name + 'FitInit', TrackLocation=InputLocation),
ConfiguredEventFitter(Name + 'FitBeforeHitAdder',
TracksInContainer=InputLocation),
TrackHitAdder(Name + 'HitAdder', TrackLocation=InputLocation),
ConfiguredEventFitter(Name + 'FitAfterHitAdder',
TracksInContainer=InputLocation)
]
tracksel = TrackContainerCopy(Name + 'CopyAndSelect',
inputLocations=[InputLocation],
outputLocation=OutputLocation,
Selector=TrackSelector())
# also apply a selection
tracksel.Selector.MaxChi2Cut = 5
tracksel.Selector.MaxChi2PerDoFMatch = 5
tracksel.Selector.MaxChi2PerDoFVelo = 5
tracksel.Selector.MaxChi2PerDoFDownstream = 5
seq.Members.append(tracksel)
return seq
matching.TTracksLocation = 'Rec/Track/Best' # Best container + chisquare < 5
matching.MuonTracksLocation = 'Rec/Track/SelectedMuon' # MuonNNet
matching.TracksOutputLocation = 'Rec/Track/Best/TMuon'
matching.addTool(TrackMasterExtrapolator, name='Extrapolator')
matching.Extrapolator.ApplyMultScattCorr = True
matching.Extrapolator.ApplyEnergyLossCorr = False
matching.Extrapolator.ApplyElectronEnergyLossCorr = False
matching.addTool(TrackChi2Calculator, name='Chi2Calculator')
matching.MatchChi2Cut = 10.0 #
matching.WriteNtuple = OTMuon_ntuple
# Fit TMuon tracks
#tmuonfit = ConfiguredFastEventFitter( 'TMuonFit', TracksInContainer = 'Rec/Track/Best/TMuon') # contains Best+Muon
tmuonfit = ConfiguredEventFitter(
'TMuonFit',
TracksInContainer='Rec/Track/Best/TMuon') # contains Best+Muon
tmuonfit.OutputLevel = outputlevel
tmuonfit.Fitter.MakeNodes = True
tmuonfit.Fitter.MakeMeasurements = True
tmuonfit.Fitter.addTool(TrackKalmanFilter, 'NodeFitter')
tmuonfit.Fitter.ErrorX = 1000
tmuonfit.Fitter.ErrorY = 10000
tmuonfit.Fitter.NumberFitIterations = 5
tmuonfit.Fitter.MaxDeltaChiSqConverged = 0.1
tmuonfit.Fitter.MaxNumberOutliers = 0
tmuonfit.Fitter.addTool(MeasurementProvider(), name='MeasProvider')
tmuonfit.Fitter.MeasProvider.MuonProvider.clusterize = True
tmuonfit.Fitter.MeasProvider.MuonProvider.OutputLevel = outputlevel
tmuonfit.Fitter.MeasProvider.IgnoreMuon = False
def algorithm(self):
from Configurables import TrackSys
TrackSys().GlobalCuts = {
'Velo': 4000,
'OT': 8000
} #### to remove busy events
Name = self._name
inputTrackLocation = self._inputLocation
from Configurables import GaudiSequencer, HltTrackConverter, TrackContainerCopy, Escher
from TAlignment.Utils import configuredFitAndHitAdderSequence
seq = GaudiSequencer(self.name() + "Seq")
## Here starts Stefania's code ========================
from Configurables import MuonNNetRec, MuonPadRec, MuonClusterRec
muonTrackTool = MuonNNetRec(
name="MuonNNetRec",
AssumeCosmics=False,
PhysicsTiming=False,
AssumePhysics=
True, ## assume that tracks come from IP (only forward)
AddXTalk=True,
XtalkRadius=1.5,
SkipStation=0,
#DecodingTool = "MuonMonHitDecode", # default is "MuonHitDecode"
ClusterTool="MuonClusterRec" # default is "MuonFakeClustering"
#OutputLevel = 2
)
clusterTool = MuonClusterRec(name="MuonClusterRec",
OutputLevel=5,
MaxPadsPerStation=500) #default 1500
padRecTool = MuonPadRec(name="PadRecTool", OutputLevel=5)
from Configurables import MakeMuonTracks
copy = MakeMuonTracks(name='MakeMuonTracks',
OutputLevel=5,
SkipBigClusters=True)
copy.addTool(muonTrackTool, name='MuonRecTool')
# ------------------------------------------------------------------
seq.Members += [copy] # Copy MuonTracks to LHCb tracks
# ------------------------------------------------------------------
from TrackFitter.ConfiguredFitters import ConfiguredForwardStraightLineEventFitter #, ConfiguredStraightLineFitter
from Configurables import MeasurementProvider, TrackKalmanFilter
muonTrackFit = ConfiguredForwardStraightLineEventFitter(
"MuonTrackFit", TracksInContainer="Rec/Track/Muon")
#muonTrackFit = ConfiguredStraightLineFitter( 'MuonTrackFit' , TracksInContainer = 'Rec/Track/Muon' )
muonTrackFit.Fitter.OutputLevel = 5
muonTrackFit.Fitter.addTool(TrackKalmanFilter, 'NodeFitter')
muonTrackFit.Fitter.addTool(MeasurementProvider, name='MeasProvider')
muonTrackFit.Fitter.MeasProvider.MuonProvider.clusterize = True #default False
muonTrackFit.Fitter.MeasProvider.MuonProvider.OutputLevel = 5
muonTrackFit.Fitter.ErrorX = 1000
muonTrackFit.Fitter.ErrorY = 10000
muonTrackFit.Fitter.MaxNumberOutliers = 0
# ------------------------------------------------------------------
seq.Members += [muonTrackFit]
# ------------------------------------------------------------------
from Configurables import TAlignment, GetElementsToBeAligned
from Configurables import TrackFilterAlg
trackFilterAlg = TrackFilterAlg(
name="FilterTracks",
OutputLevel=5,
TracksInputContainer="Rec/Track/Muon", # MuonTrackRec
TracksOutputContainer="Rec/Track/SelectedMuon", # Filtered tracks
MuonFilter=True, ###------------------------------ MUONTRACKSELECTOR
MuonPcut=6000., ## 6 GeV
MuonChisquareCut=5,
inCaloAcceptance=True,
noOverlap=False,
#TheRegion = 10
minHitStation=3) # >3
####???????
trackFilterAlg.addTool(GetElementsToBeAligned(
OutputLevel=5, Elements=TAlignment().ElementsToAlign),
name="GetElementsToBeAligned")
# ------------------------------------------------------------------
seq.Members += [trackFilterAlg]
# ------------------------------------------------------------------
from Configurables import TrackMuonMatching, TrackMasterExtrapolator, TrackChi2Calculator
#, TrajOTCosmicsProjector, TrajOTProjector, TrackProjectorSelector
matching = TrackMuonMatching(
name="TrackMuonMatching",
AllCombinations=False, # default true
MatchAtFirstMuonHit=True, # default false
FullDetail=True, #????
OutputLevel=5,
TTracksLocation=inputTrackLocation, # Best container + chisquare < 5
MuonTracksLocation='Rec/Track/SelectedMuon', # MuonNNet
TracksOutputLocation='Rec/Track/Best/TMuon',
MatchChi2Cut=20.0,
WriteNtuple=False)
matching.addTool(TrackMasterExtrapolator, name='Extrapolator')
matching.Extrapolator.ApplyMultScattCorr = True
matching.Extrapolator.ApplyEnergyLossCorr = False
matching.Extrapolator.ApplyElectronEnergyLossCorr = False
matching.addTool(TrackChi2Calculator, name='Chi2Calculator')
# ------------------------------------------------------------------
seq.Members += [matching] # Track-Muon Matching
# ------------------------------------------------------------------
from TrackFitter.ConfiguredFitters import ConfiguredEventFitter
#tmuonfit = ConfiguredFastEventFitter( 'TMuonFit', TracksInContainer = 'Rec/Track/Best/TMuon') # contains Best+Muon
tmuonfit = ConfiguredEventFitter(
"TMuonFit",
TracksInContainer='Rec/Track/Best/TMuon') # contains Best+Muon
tmuonfit.Fitter.MakeNodes = True
tmuonfit.Fitter.MakeMeasurements = True
tmuonfit.Fitter.addTool(TrackKalmanFilter, 'NodeFitter')
tmuonfit.Fitter.ErrorX = 1000
tmuonfit.Fitter.ErrorY = 10000
tmuonfit.Fitter.NumberFitIterations = 5
tmuonfit.Fitter.MaxDeltaChiSqConverged = 0.1
tmuonfit.Fitter.MaxNumberOutliers = 0
tmuonfit.Fitter.addTool(MeasurementProvider(), name='MeasProvider')
tmuonfit.Fitter.MeasProvider.MuonProvider.clusterize = True
#tmuonfit.Fitter.MeasProvider.MuonProvider.OutputLevel = 2
tmuonfit.Fitter.MeasProvider.IgnoreMuon = False
# ------------------------------------------------------------------
seq.Members += [tmuonfit] # Fit TMuon tracks
# ------------------------------------------------------------------
from Configurables import TrackSelector, TrackContainerCopy
tmuonselectoralg = TrackContainerCopy(
name="TmuonSelection",
inputLocations=['Rec/Track/Best/TMuon'],
outputLocation=self.location())
tmuonselectoralg.addTool(TrackSelector, name="Selector")
tmuonselectoralg.Selector.MaxChi2Cut = 10
#tmuonselectoralg.Selector.OutputLevel = 2
# ------------------------------------------------------------------
seq.Members += [tmuonselectoralg] # selects good TMuon tracks
# ------------------------------------------------------------------
return seq