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 _modify_velo_seq(self, sequence): ''' Modify RecoVertexSeq sequence. ''' from Configurables import FastVeloTracking myFastVelo = FastVeloTracking("MyFastVelo") myFastVelo.ZVertexMin = -2000 myFastVelo.ZVertexMax = 2000 sequence.Members = [myFastVelo]
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 = ConfiguredFit("vefit", "Rec/Track/UnfittedPreparedVelo") vefit.TracksOutContainer = "Rec/Track/FittedVelo" vefit.addTool(TrackMasterFitter, name='Fitter') ConfiguredFastFitter(getattr(vefit, 'Fitter')) alg = GaudiSequencer( "VeloMuonTrackingFor" + name, Members=[ DecodeVeloRawBuffer(name + "VeloDecoding", DecodeToVeloLiteClusters=True, DecodeToVeloClusters=True), FastVeloTracking(name + "FastVelo", OutputTracksName="Rec/Track/Velo"), preve, vefit, StandaloneMuonRec(name + "MuonStandalone"), VeloMuonBuilder1 ]) return GSWrapper(name="WrappedVeloMuonTracking", sequencer=alg, output='Rec/VeloMuon/Tracks', requiredSelections=prefilter)
def trackingPreFilter(name, prefilter): VeloMuonBuilder1 = VeloMuonBuilder("VeloMuonBuilder") VeloMuonBuilder1.OutputLevel = 6 VeloMuonBuilder1.MuonLocation = "Hlt1/Track/MuonSeg" VeloMuonBuilder1.VeloLocation = "Rec/Track/UnFittedVelo" VeloMuonBuilder1.lhcbids = 4 VeloMuonBuilder1.OutputLocation = "Rec/VeloMuon/Tracks" preve = TrackPrepareVelo("preve") preve.inputLocation = "Rec/Track/Velo" preve.outputLocation = "Rec/Track/UnFittedVelo" preve.bestLocation = "" #TODO: apparently FastVelo is now (april 2012) run with fixes in the production which don't neccessarily apply to the stripping... alg = GaudiSequencer( "VeloMuonTrackingFor" + name, Members=[ DecodeVeloRawBuffer(name + "VeloDecoding", DecodeToVeloLiteClusters=True, DecodeToVeloClusters=True), FastVeloTracking(name + "FastVelo", OutputTracksName="Rec/Track/Velo"), preve, StandaloneMuonRec(name + "MuonStandalone"), VeloMuonBuilder1 ]) return GSWrapper(name="WrappedVeloMuonTracking", sequencer=alg, output='Rec/VeloMuon/Tracks', requiredSelections=prefilter)
def trackingPreFilter(name, prefilter): VeloMuonBuilder1 = VeloMuonBuilder("VeloMuonBuilder") VeloMuonBuilder1.OutputLevel = 6 VeloMuonBuilder1.MuonLocation = "Hlt1/Track/MuonSeg" VeloMuonBuilder1.VeloLocation = "Rec/Track/UnFittedVelo" VeloMuonBuilder1.lhcbids = 4 VeloMuonBuilder1.OutputLocation = "Rec/VeloMuon/Tracks" preve = TrackPrepareVelo("preve") preve.inputLocation = "Rec/Track/Velo" preve.outputLocation = "Rec/Track/UnFittedVelo" preve.bestLocation = "" alg = GaudiSequencer( "VeloMuonTrackingFor" + name, Members=[ DecodeVeloRawBuffer(name + "VeloDecoding", DecodeToVeloLiteClusters=True, DecodeToVeloClusters=True), FastVeloTracking(name + "FastVelo", OutputTracksName="Rec/Track/Velo"), preve, StandaloneMuonRec(name + "MuonStandalone"), VeloMuonBuilder1 ]) return GSWrapper(name="WrappedVeloMuonTracking", sequencer=alg, output='Rec/VeloMuon/Tracks', requiredSelections=prefilter)
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 algorithm(self): from Configurables import GaudiSequencer, HltTrackConverter, TrackContainerCopy, Escher from TAlignment.Utils import configuredFitAndHitAdderSequence seq = GaudiSequencer(self.name() + "Seq") # configure algorithm to revive HLT tracks. it seems that the # Hlt2Global decision is the most useful, because it has TT # hits on the tracks. adding Hlt1Global does rather # little. (if you do, make sure to put it after Hlt2Global, # since the clone rejection takes the first track.) hltTrackConvAll = HltTrackConverter( "HltTrackConvAll", TrackDestination='Rec/Track/NoPIDBest') hltTrackConvAll.HltLinesToUse += ['Hlt2Global', 'Hlt1Global'] if Escher().DataType in ['2015']: hltTrackConvAll.SelReportsLocation = 'Hlt1/SelReports' seq.Members += [hltTrackConvAll] # configure algorithm to run Velo standalone reconstruction if self._runVelo: # run FastVeloTracks and copy all tracks to NoPIDBest. We # need to deal with clones at some point. from Configurables import FastVeloTracking seq.Members += [ FastVeloTracking(), TrackContainerCopy('CopyVeloTracks', inputLocations=['Rec/Track/Velo'], outputLocation='Rec/Track/NoPIDBest') ] tracksel = FavouriteTrackCocktail(Name='NoPIDForAlignment', InputLocation='Rec/Track/NoPIDBest', Fitted=False) seq.Members += [ tracksel.algorithm(), TrackContainerCopy('NoPIDForAlignmentCopy', inputLocations=[tracksel.location()], outputLocation=tracksel.location() + 'Owned'), configuredFitAndHitAdderSequence( 'NoPIDFit', InputLocation=tracksel.location() + 'Owned', OutputLocation=self.location()) ] return seq
def __lumi_track_and_vertex_seq__(self): ''' returns a list of private lumi Velo tracking and vertexing algorithms ''' ### create the tracking alg from HltLine.HltDecodeRaw import DecodeVELO algsDecodeVelo = [i for i in DecodeVELO.members()] from Configurables import FastVeloTracking algTr = FastVeloTracking('FastVeloLumiHlt', OutputTracksName=self.containerNameLumiTracks, HitManagerName='FastVeloLumiHltHitManager') ### create the vertexing alg from Configurables import PatPV3D, PVOfflineTool, LSAdaptPV3DFitter algPV = PatPV3D('PV3DLumiHlt') algPV.addTool(PVOfflineTool, "PVOfflineTool") algPV.PVOfflineTool.addTool(LSAdaptPV3DFitter, "LSAdaptPV3DFitter") algPV.PVOfflineTool.PVFitterName = "LSAdaptPV3DFitter" algPV.PVOfflineTool.LSAdaptPV3DFitter.TrackErrorScaleFactor = 2. algPV.PVOfflineTool.InputTracks = [algTr.OutputTracksName] algPV.OutputVerticesName = self.containerNameLumiVertex #return a list with the 2 algorithms return algsDecodeVelo + [algTr, algPV]
def _create_tracking_algos(self): '''Create the common velo tracking instance.''' tracking_conf = self.getProp("TrackingConf") tracking_output = self.getProp("TrackContName") algs = [] if tracking_conf == 'FastVelo': from Configurables import FastVeloTracking algTr = FastVeloTracking('FastVeloTrackingBeamGas') algTr.HitManagerName = self.getProp("FastVeloBGHitManagerName") algTr.OutputTracksName = tracking_output algTr.ZVertexMin = self.getProp("TrackingZMin") algTr.ZVertexMax = self.getProp("TrackingZMax") algs.append(algTr) elif tracking_conf == 'PatVelo': from Configurables import Tf__PatVeloRTracking, Tf__PatVeloSpaceTracking, Tf__PatVeloSpaceTool, Tf__PatVeloGeneralTracking patVeloR = Tf__PatVeloRTracking('PatVeloBeamGas_RTracking') patVeloR.OutputTracksName = self.getProp('RZTrackContName') patVeloR.ZVertexMin = self.getProp("TrackingZMin") patVeloR.ZVertexMax = self.getProp("TrackingZMax") patVeloSpace = Tf__PatVeloSpaceTracking( 'PatVeloBeamGas_SpaceTracking') patVeloSpace.InputTracksName = patVeloR.OutputTracksName patVeloSpace.OutputTracksName = tracking_output patVeloSpace.addTool(Tf__PatVeloSpaceTool(), name="PatVeloSpaceTool") patVeloSpace.PatVeloSpaceTool.MarkClustersUsed = True patVeloGeneral = Tf__PatVeloGeneralTracking( 'PatVeloBeamGas_GeneralTracking') patVeloGeneral.OutputTracksLocation = tracking_output patVeloGeneral.PointErrorMin = 2 algs.extend([patVeloR, patVeloSpace, patVeloGeneral]) else: raise ValueError( "Unknown TrackingConf ({})!".format(tracking_conf)) return algs
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]
# 'x' : [0.75, 0.6, 0.49, 0.65], # 'y' : [0.483, 0.589, 0.738, 0.813]} ## Recombine RawEvent # from Configurables import RawEventFormatConf, RawEventJuggler, RecombineRawEvent # juggleSeq = GaudiSequencer("JuggleSeq") # RawEventJuggler().Input = 2.0 # RawEventJuggler().Output = 0.0 # RawEventJuggler().Sequencer = juggleSeq ## Configure Reco co = createODIN() mr = MuonRec() decodeVelo = DecodeVeloRawBuffer( "createVeloLiteClusters" ) recoVelo = FastVeloTracking( 'FastVeloHlt', OutputTracksName = "Hlt/Track/Velo" ) recoVelo.HLT1Only = False decodeIT = RawBankToSTLiteClusterAlg("createITLiteClusters") decodeIT.DetType = "IT" ## Configure L0 emulation by hand # from Configurables import L0DUFromRawAlg, L0DUFromRawTool # l0du = L0DUFromRawAlg("L0DUFromRaw") # l0du.addTool(L0DUFromRawTool,name = "L0DUFromRawTool") # l0du = getattr( l0du, 'L0DUFromRawTool' ) # l0du.StatusOnTES = False seq.Members = [ co, decodeVelo, recoVelo, decodeIT, mr ] from Configurables import CombinedParticleMaker from Configurables import ProtoParticleMUONFilter from Configurables import TrackSelector
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")