def configIso(): from Configurables import ChargedProtoParticleMaker, DaVinci veloprotos = ChargedProtoParticleMaker("ProtoPMaker") veloprotos.Inputs = ["Rec/Track/Best"] veloprotos.Output = "Rec/ProtoP/myProtoPMaker/ProtoParticles" DaVinci().appendToMainSequence( [ veloprotos ]) from Configurables import ProtoParticleCALOFilter, CombinedParticleMaker,NoPIDsParticleMaker from CommonParticles.Utils import trackSelector, updateDoD algorithm = NoPIDsParticleMaker('StdNoPIDsVeloPions', Particle = 'pion', ) algorithm.Input = "Rec/ProtoP/myProtoPMaker/ProtoParticles" selector = trackSelector ( algorithm , trackTypes = ['Velo'] ) locations = updateDoD ( algorithm ) DaVinci().appendToMainSequence( [ algorithm ])
def muonTracksFORmuonAlignment(): # this still needs to be worked out from Configurables import Escher Escher().RecoSequence = [ "Hlt", "Decoding", "AlignTr", "Vertex", "RICH", "CALO", "MUON", "PROTO" ] # ???? Escher().MoniSequence = ["Tr", "OT"] # if the Escher hlt filter is not set, set it here if not hasattr(Escher(), "HltFilterCode") or not Escher().HltFilterCode: Escher( ).HltFilterCode = "HLT_PASS_RE( 'Hlt1DiMuonHighMass*Decision' )" # Hlt2-->Hlt1 requirement # revive only particles used for trigger print 'Hlt lines to be used: ' print ReviveHltTracks(['Hlt1DiMuonHighMassDecision']) # Now create the J/psi candidates from Configurables import CombineParticles, FilterDesktop from CommonParticles.StdAllLooseMuons import StdAllLooseMuons # requires IsMuon==1 from CommonParticles.StdLooseJpsi2MuMu import StdLooseJpsi2MuMu # requires (ADAMASS('J/psi')<100.*MeV)&(ADOCACHI2CUT(30,'')) && "(VFASPF(VCHI2) < 25.)" StdLooseJpsi2MuMu.DaughtersCuts = {"mu-": "( P> 6000*MeV)"} # momentum cut ## tighten the mass window for candidates used in alignment AlignJpsi2MuMu = FilterDesktop( "AlignJpsi2MuMu", Inputs=["Phys/StdLooseJpsi2MuMu"], Code="(ADMASS('J/psi(1S)') < 35.*MeV) & (VFASPF(VCHI2) < 10.)" ) # tighter requirements from Configurables import ChargedProtoParticleMaker, ChargedProtoParticleAddMuonInfo #####, ChargedProtoCombineDLLsAlg from Configurables import TrackParticleMonitor, GaudiSequencer recoJpsiSeq = GaudiSequencer("RecoJpsiSeq") recoJpsiSeq.Members = [ ChargedProtoParticleMaker('ChargedProtoPMaker'), ChargedProtoParticleAddMuonInfo('ChargedProtoPAddMuon'), ###ChargedProtoCombineDLLsAlg('ChargedProtoPCombDLLs'), StdAllLooseMuons, StdLooseJpsi2MuMu, TrackParticleMonitor( 'StdLooseJpsi2MuMuMonitor', InputLocation='/Event/Phys/StdLooseJpsi2MuMu/Particles', MinMass=3000, MaxMass=3190), AlignJpsi2MuMu, TrackParticleMonitor( 'AlignJpsi2MuMuMonitor', InputLocation='/Event/Phys/AlignJpsi2MuMu/Particles', MinMass=3000, MaxMass=3190), ] sel = ParticleSelection(Name='MufromJpsiMuMu', Location='/Event/Phys/AlignJpsi2MuMu/Particles', Algorithm=recoJpsiSeq) return sel
def selMuonPParts(name, trackingSeq): """ Make ProtoParticles out of VeloMuon tracks """ veloprotos = ChargedProtoParticleMaker(name + "ProtoPMaker") veloprotos.Inputs = ["Rec/VeloMuon/Tracks"] veloprotos.Output = "Rec/ProtoP/" + name + "ProtoPMaker/ProtoParticles" veloprotos.addTool(DelegatingTrackSelector, name="TrackSelector") tracktypes = ["Long"] veloprotos.TrackSelector.TrackTypes = tracktypes selector = veloprotos.TrackSelector for tsname in tracktypes: selector.addTool(TrackSelector, name=tsname) ts = getattr(selector, tsname) # Set Cuts ts.TrackTypes = [tsname] veloprotoseq = GaudiSequencer(name + "ProtoPSeq") veloprotoseq.Members += [veloprotos] return GSWrapper(name="WrappedVeloMuonProtoPSeqFor" + name, sequencer=veloprotoseq, output='Rec/ProtoP/' + name + 'ProtoPMaker/ProtoParticles', requiredSelections=[trackingSeq])
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 selMuonPParts(name, DataType, downstreamSeq): """ Make ProtoParticles out of Downstream tracks """ unpacker = UnpackTrack(name+"UnpackTrack") # do we need this or is it here for historical reason ? unpacker.InputName="pRec/Downstream/FittedTracks" unpacker.OutputName="Rec/Downstream/FittedTracks" idalg = MuonIDAlg(name+"IDalg") cm=ConfiguredMuonIDs.ConfiguredMuonIDs( DataType ) #data=DaVinci().getProp("DataType")) cm.configureMuonIDAlg(idalg) idalg.TrackLocation = "Rec/Downstream/FittedTracks" idalg.MuonIDLocation = "Rec/Muon/MuonPID/Downstream" idalg.MuonTrackLocation = "Rec/Track/MuonForDownstream" # I would call it FromDownstream …but just to be »Klugscheißer« downprotoseq = GaudiSequencer(name+"ProtoPSeq") downprotos = ChargedProtoParticleMaker(name+"ProtoPMaker") downprotos.Inputs = ["Rec/Downstream/FittedTracks"] downprotos.Output = "Rec/ProtoP/"+name+"ProtoPMaker/ProtoParticles" downprotos.addTool( DelegatingTrackSelector, name="TrackSelector" ) #tracktypes = [ "Long","Upstream","Downstream","Ttrack","Velo","VeloR" ] # only downstream needed … tracktypes = ["Downstream"] #if (trackcont == "Best") : # tracktypes = [ "Long" ] downprotos.TrackSelector.TrackTypes = tracktypes selector = downprotos.TrackSelector for tsname in tracktypes: selector.addTool(TrackSelector,name=tsname) ts = getattr(selector,tsname) # Set Cuts ts.TrackTypes = [tsname] # ts.MinNDoF = 1 ts.MaxChi2Cut = 10 addmuonpid = ChargedProtoParticleAddMuonInfo(name+"addmuoninfo") addmuonpid.InputMuonPIDLocation = "Rec/Muon/MuonPID/Downstream" addmuonpid.ProtoParticleLocation = "Rec/ProtoP/"+name+"ProtoPMaker/ProtoParticles" #addmuonpid.OutputLevel = 0 combinedll = ChargedProtoCombineDLLsAlg(name+"CombineDLL") combinedll.ProtoParticleLocation = "Rec/ProtoP/"+name+"ProtoPMaker/ProtoParticles" #combinedll.OutputLevel = 0 # DST post treatment #TrackToDST(name+"TrackToDST").TracksInContainer = "Rec/Downstream/Tracks" #downprotoseq.Members += [ TrackToDST(name+"TrackToDST"), downprotos, addmuonpid, combinedll ] downprotoseq.Members += [ downprotos, addmuonpid, combinedll ] # DataOnDemandSvc().AlgMap.update( { "/Event/Rec/Downstream/Tracks" : unpacker.getFullName(), "/Event/Rec/Muon/MuonPID/Downstream" : idalg.getFullName(), # "/Event/Rec/ProtoP/"+name+"ProtoPMaker" : downprotoseq.getFullName() } ) return GSWrapper(name="WrappedDownMuonProtoPSeqFor"+name, sequencer=downprotoseq, output='Rec/ProtoP/' + name +'ProtoPMaker/ProtoParticles', requiredSelections = [ downstreamSeq])
def MakeVeloProtos(self,prefilter): #### making the proto particles MakeVeloProtos = ChargedProtoParticleMaker('For%sVeloProtoMaker'%self.name()) MakeVeloProtos.Inputs = [self.VeloTrackInputLocaton] MakeVeloProtos.Output = self.VeloProtoOutputLocation MakeVeloProtos.addTool( DelegatingTrackSelector, name="TrackSelector" ) MakeVeloProtos.TrackSelector.TrackTypes = [ "Velo" ] #### the full sequence makeparts = GaudiSequencer('For%sMakeVeloProtosGS'%self.name()) 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 selMuonPParts(name, trackingSeq): """ Make ProtoParticles out of VeloMuon tracks """ unpacker = UnpackTrack(name+"UnpackTrack") unpacker.InputName="pRec/VeloMuon/Tracks" unpacker.OutputName="Rec/VeloMuon/Tracks" veloprotos = ChargedProtoParticleMaker(name+"ProtoPMaker") veloprotos.Inputs = ["Rec/VeloMuon/Tracks"] veloprotos.Output = "Rec/ProtoP/"+name+"ProtoPMaker/ProtoParticles" veloprotos.addTool( DelegatingTrackSelector, name="TrackSelector" ) tracktypes = [ "Long" ] #veloprotos.OutputLevel =0 #if (trackcont == "Best") : # tracktypes = [ "Long" ] veloprotos.TrackSelector.TrackTypes = tracktypes selector = veloprotos.TrackSelector for tsname in tracktypes: selector.addTool(TrackSelector,name=tsname) ts = getattr(selector,tsname) # Set Cuts ts.TrackTypes = [tsname] # DataOnDemandSvc().AlgMap.update( { "/Event/Rec/VeloMuon/Tracks" : unpacker.getFullName(), } ) veloprotoseq = GaudiSequencer(name+"ProtoPSeq") veloprotoseq.Members += [ veloprotos ] return GSWrapper(name="WrappedVeloMuonProtoPSeqFor" + name, sequencer=veloprotoseq, output='Rec/ProtoP/' + name +'ProtoPMaker/ProtoParticles', requiredSelections = [ trackingSeq])
#! /usr/bin/env python from Configurables import DaVinci import GaudiPython import os from PhysSelPython.Wrappers import DataOnDemand from Configurables import CombineParticles, ChargedProtoParticleMaker, NoPIDsParticleMaker from CommonParticles import StdAllNoPIDsPions, StdAllNoPIDsElectrons, StdNoPIDsUpElectrons from CommonParticles.Utils import * ######################## ## make VELO particles by hand # first make protoparticles (needed for VELO Tracks) myprotos = ChargedProtoParticleMaker("MyProtoParticles", Inputs = ["Rec/Track/Best"], Output = "Rec/ProtoP/MyProtoParticles") DaVinci().UserAlgorithms +=[myprotos] #now make the velo particles algorithm = NoPIDsParticleMaker ( 'StdNoPIDsVeloElectrons', DecayDescriptor = 'Electron' , Particle = 'electron', Input = myprotos.Output) # configure the track selector selector = trackSelector ( algorithm,trackTypes = [ "Velo" ] ) locations = updateDoD ( algorithm ) ######################## ## build all possible combinations of track types combs = {"LL":"( ANUM( ( TRTYPE == 3 ) & ( ABSID == 'e-' ) ) == 2 )",
hlt1_emu = getattr(relinfo_HLT1, "RelInfoHLT1Emulation") hlt1_emu.Variables = [] hlt1_emu.nltValue = 16. DaVinci().appendToMainSequence([relinfo_HLT1]) ############################################################################################## ##### PRODUCTION OF THE VELO PARTICLE INPUT CONTAINER FOR THE CHARGED ISOLATION TUPLE TOOL ############################################################################################# #To produce the Velo particles input container (the gain in performance from adding velo tracks is actually pretty negligible...) from Configurables import ChargedProtoParticleMaker name = "Lambdab2Lcmunu" veloprotos = ChargedProtoParticleMaker(name + "ProtoPMaker") veloprotos.Inputs = ["Rec/Track/Best"] veloprotos.Output = "Rec/ProtoP/myProtoPMaker/ProtoParticles" DaVinci().appendToMainSequence([veloprotos]) from Gaudi.Configuration import * from Configurables import ProtoParticleCALOFilter, CombinedParticleMaker, NoPIDsParticleMaker from CommonParticles.Utils import * algorithm = NoPIDsParticleMaker( 'StdNoPIDsVeloPions', Particle='pion', ) algorithm.Input = "Rec/ProtoP/myProtoPMaker/ProtoParticles" selector = trackSelector(algorithm, trackTypes=['Velo'])
def makeMyProtoP(trackcont): unpacker = UnpackTrack(trackcont + "UnpackTrack") unpacker.InputName = "pRec/Track/" + trackcont unpacker.OutputName = "Rec/Track/" + trackcont refitter = TrackSmeared(trackcont + "TrackSmeared") refitter.InputLocation = "Rec/Track/" + trackcont refitter.OutputLocation = "Refit" refitter.smear = 1 #refitter.makePlots = 1 #refitter.OutputLevel = 2 #idalg = MuonIDAlg("BestIDalg") #idalg.OutputLevel = 0 #cm=ConfiguredMuonIDs.ConfiguredMuonIDs(data=DaVinci().getProp("DataType")) #cm.configureMuonIDAlg(idalg) #idalg.TrackLocation = "Rec/Track/Refit" #idalg.MuonIDLocation = "Rec/Muon/MuonPID/Refit" downprotoseq = GaudiSequencer(trackcont + "ProtoPSeq") downprotos = ChargedProtoParticleMaker(trackcont + "ProtoPMaker") downprotos.InputTrackLocation = ["Rec/Track/Refit"] downprotos.OutputProtoParticleLocation = "Rec/ProtoP/" + trackcont + "ProtoPMaker" downprotos.addTool(DelegatingTrackSelector, name="TrackSelector") #downprotos.OutputLevel = 0 tracktypes = ["Long", "Upstream", "Downstream", "Ttrack", "Velo", "VeloR"] downprotos.TrackSelector.TrackTypes = tracktypes selector = downprotos.TrackSelector for tsname in tracktypes: selector.addTool(TrackSelector, name=tsname) ts = getattr(selector, tsname) # Set Cuts ts.TrackTypes = [tsname] #set up associators #addmuonpid = ChargedProtoParticleAddMuonInfo("Bestaddmuoninfo") #addmuonpid.InputMuonPIDLocation = "Rec/Muon/MuonPID/Refit" #addmuonpid.ProtoParticleLocation = "Rec/ProtoP/"+trackcont+"ProtoPMaker" #addmuonpid.OutputLevel = 0 addrichpid = ChargedProtoParticleAddRichInfo("Bestaddrichinfo") addrichpid.InputRichPIDLocation = "Rec/Rich/Refit" #addrichpid.InputRichPIDLocation = "Rec/Rich/"+trackcont addrichpid.ProtoParticleLocation = "Rec/ProtoP/" + trackcont + "ProtoPMaker" #addcalopid = ChargedProtoParticleAddCaloInfo("Bestaddcaloinfo") #addcalopid.InputRichCALOLocation = "Rec/Rich/Refit" #addcalopid.ProtoParticleLocation = "Rec/ProtoP/"+trackcont+"ProtoPMaker" combinedll = ChargedProtoCombineDLLsAlg("BestCombineDLL") combinedll.ProtoParticleLocation = "Rec/ProtoP/" + trackcont + "ProtoPMaker" assoctr = TrackAssociator(trackcont + "AssocTr") #assoctr.TracksInContainer = "Rec/Track/"+trackcont assoctr.TracksInContainer = "Rec/Track/Refit" assocpp = ChargedPP2MC(trackcont + "AssocPP") #assocpp.TrackLocations = [ "Rec/Track/"+trackcont ] assocpp.TrackLocations = ["Rec/Track/Refit"] assocpp.InputData = ["Rec/ProtoP/" + trackcont + "ProtoPMaker"] #assocpp.InputData = [ "Rec/ProtoP/Refit" ] assocpp.OutputTable = "Relations/Rec/ProtoP/" + trackcont + "ProtoPMaker" # DST post treatment TrackToDST(trackcont + "TrackToDST").TracksInContainer = "Rec/Track/" + trackcont #downprotoseq.Members += [ TrackToDST(trackcont+"TrackToDST"), assoctr, downprotos, assocpp,addrichpid,combinedll ] if not DaVinci().Simulation: downprotoseq.Members += [ TrackToDST(trackcont + "TrackToDST"), downprotos, addrichpid, combinedll ] DataOnDemandSvc().AlgMap.update({ "/Event/Rec/Track/" + trackcont: unpacker.getFullName(), "/Event/Rec/Track/Refit": refitter.getFullName(), "/Event/Rec/Rich/Refit": downprotoseq.getFullName(), "/Event/Rec/ProtoP/" + trackcont + "ProtoPMaker": downprotoseq.getFullName(), "/Event/Relations/Rec/ProtoP/" + trackcont + "ProtoPMaker": downprotoseq.getFullName() }) else: if (DaVinci().Simulation): downprotoseq.Members += [ TrackToDST(trackcont + "TrackToDST"), assoctr, downprotos, addrichpid, combinedll, assocpp ] DataOnDemandSvc().AlgMap.update({ "/Event/Rec/Track/" + trackcont: unpacker.getFullName(), "/Event/Rec/Track/Refit": refitter.getFullName(), "/Event/Rec/Rich/Refit": downprotoseq.getFullName(), "/Event/Rec/ProtoP/" + trackcont + "ProtoPMaker": downprotoseq.getFullName(), "/Event/Relations/Rec/ProtoP/" + trackcont + "ProtoPMaker": downprotoseq.getFullName() })
def makeMyProtoP(trackcont): unpacker = UnpackTrack(trackcont + "UnpackTrack") unpacker.InputName = "pRec/Track/" + trackcont unpacker.OutputName = "Rec/Track/" + trackcont smeartracks = TrackSmeared(trackcont + "TrackSmeared") smeartracks.InputLocation = "Rec/Track/" + trackcont outputLocation = "Smeared" smeartracks.OutputLocation = outputLocation smeartracks.smearCopied = True smeartracks.smear = 1 #smeartracks.makePlots = 1 #smeartracks.OutputLevel = 2 protoseq = GaudiSequencer(trackcont + "ProtoPSeq") protos = ChargedProtoParticleMaker(trackcont + "ProtoPMaker") protos.InputTrackLocation = ["Rec/Track/" + outputLocation] protos.OutputProtoParticleLocation = "Rec/ProtoP/" + trackcont + "ProtoPMaker" protos.addTool(DelegatingTrackSelector, name="TrackSelector") #protos.OutputLevel = 0 tracktypes = ["Long", "Upstream", "Downstream", "Ttrack", "Velo", "VeloR"] protos.TrackSelector.TrackTypes = tracktypes selector = protos.TrackSelector for tsname in tracktypes: selector.addTool(TrackSelector, name=tsname) ts = getattr(selector, tsname) # Set Cuts ts.TrackTypes = [tsname] # Add PID information idalg = MuonIDAlg("BestIDalg") #idalg.OutputLevel = 5 cm = ConfiguredMuonIDs.ConfiguredMuonIDs( data=DaVinci().getProp("DataType")) cm.configureMuonIDAlg(idalg) idalg.TrackLocation = "Rec/Track/" + outputLocation idalg.MuonIDLocation = "Rec/Muon/MuonPID/" + outputLocation from Configurables import ( ChargedProtoParticleAddRichInfo, ChargedProtoParticleAddMuonInfo, ChargedProtoParticleAddEcalInfo, ChargedProtoParticleAddBremInfo, ChargedProtoParticleAddHcalInfo, ChargedProtoParticleAddPrsInfo, ChargedProtoParticleAddSpdInfo, ChargedProtoParticleAddVeloInfo, ChargedProtoCombineDLLsAlg) addmuonpid = ChargedProtoParticleAddMuonInfo("Bestaddmuoninfo") addmuonpid.InputMuonPIDLocation = "Rec/Muon/MuonPID/" + outputLocation addmuonpid.ProtoParticleLocation = "Rec/ProtoP/" + trackcont + "ProtoPMaker" addrichpid = ChargedProtoParticleAddRichInfo("Bestaddrichinfo") addrichpid.ProtoParticleLocation = "Rec/ProtoP/" + trackcont + "ProtoPMaker" # The rich pid is added to the track in TrackSmeared, thus only kaon pion pid is consistent # the others are not implemented. The modes smearBest and smearProto don't have the problems #addcalopid = ChargedProtoParticleAddCaloInfo("Bestaddcaloinfo") #addcalopid.InputRichCALOLocation = "Rec/Rich/"+outputLocation #addcalopid.ProtoParticleLocation = "Rec/ProtoP/"+trackcont+"ProtoPMaker" #ecal = ChargedProtoParticleAddEcalInfo("ChargedProtoPAddEcal") #ecal.ProtoParticleLocation = "Rec/ProtoP/"+trackcont+"ProtoPMaker" #brem = ChargedProtoParticleAddBremInfo("ChargedProtoPAddBrem") #brem.ProtoParticleLocation = "Rec/ProtoP/"+trackcont+"ProtoPMaker" #hcal = ChargedProtoParticleAddHcalInfo("ChargedProtoPAddHcal") #hcal.ProtoParticleLocation = "Rec/ProtoP/"+trackcont+"ProtoPMaker" #prs = ChargedProtoParticleAddPrsInfo("ChargedProtoPAddPrs") #prs.ProtoParticleLocation = "Rec/ProtoP/"+trackcont+"ProtoPMaker" #spd = ChargedProtoParticleAddSpdInfo("ChargedProtoPAddSpd") #spd.ProtoParticleLocation = "Rec/ProtoP/"+trackcont+"ProtoPMaker" #velo = ChargedProtoParticleAddVeloInfo("ChargedProtoPAddVeloDEDX") #velo.ProtoParticleLocation = "Rec/ProtoP/"+trackcont+"ProtoPMaker" combinedll = ChargedProtoCombineDLLsAlg("BestCombineDLL") combinedll.ProtoParticleLocation = "Rec/ProtoP/" + trackcont + "ProtoPMaker" #set up associators assoctr = TrackAssociator(trackcont + "AssocTr") assoctr.TracksInContainer = "Rec/Track/" + outputLocation assocpp = ChargedPP2MC(trackcont + "AssocPP") assocpp.TrackLocations = ["Rec/Track/" + outputLocation] assocpp.InputData = ["Rec/ProtoP/" + trackcont + "ProtoPMaker"] assocpp.OutputTable = "Relations/Rec/ProtoP/" + trackcont + "ProtoPMaker" # DST post treatment TrackToDST(trackcont + "TrackToDST").TracksInContainer = "Rec/Track/" + trackcont if not DaVinci().Simulation: protoseq.Members += [TrackToDST(trackcont + "TrackToDST"), protos] protoseq.Members += [ ecal, brem, hcal, prs, spd, velo, addrichpid, addmuonpid, combinedll ] DataOnDemandSvc().AlgMap.update({ "/Event/Rec/Track/" + trackcont: unpacker.getFullName(), "/Event/Rec/Track/" + outputLocation: smeartracks.getFullName(), "/Event/Rec/Rich/" + outputLocation: protoseq.getFullName(), "/Event/Rec/Muon/MuonPID/" + outputLocation: idalg.getFullName(), "/Event/Rec/ProtoP/" + trackcont + "ProtoPMaker": protoseq.getFullName(), "/Event/Relations/Rec/ProtoP/" + trackcont + "ProtoPMaker": protoseq.getFullName() }) else: if (DaVinci().Simulation): protoseq.Members += [ TrackToDST(trackcont + "TrackToDST"), assoctr, protos ] #protoseq.Members += [ ecal,brem,hcal,prs,spd,velo,addrichpid,addmuonpid,combinedll,assocpp ] protoseq.Members += [ idalg, addmuonpid, addrichpid, combinedll, assocpp ] DataOnDemandSvc().AlgMap.update({ "/Event/Rec/Track/" + trackcont: unpacker.getFullName(), "/Event/Rec/Track/" + outputLocation: smeartracks.getFullName(), "/Event/Rec/Rich/" + outputLocation: protoseq.getFullName(), "/Event/Rec/Muon/MuonPID/" + outputLocation: idalg.getFullName(), "/Event/Rec/ProtoP/" + trackcont + "ProtoPMaker": protoseq.getFullName(), "/Event/Relations/Rec/ProtoP/" + trackcont + "ProtoPMaker": protoseq.getFullName() })
DaVinci().Lumi = not DaVinci().Simulation # Debug options DaVinci().EvtMax = -1 ################################### # Customize DaVinci main sequence # ################################### from Configurables import ChargedProtoParticleMaker from Configurables import NoPIDsParticleMaker from CommonParticles.Utils import trackSelector, updateDoD # Provide required information for VELO pions. ms_all_protos = ChargedProtoParticleMaker(name='MyProtoPMaker') ms_all_protos.Inputs = ['Rec/Track/Best'] ms_all_protos.Output = 'Rec/ProtoP/MyProtoPMaker/ProtoParticles' # NOTE: The name 'StdNoPIDsVeloPions' is hard-coded in the tuple tool, so the # name should not be changed. ms_velo_pions = NoPIDsParticleMaker('StdNoPIDsVeloPions', Particle='pion') ms_velo_pions.Input = ms_all_protos.Output trackSelector(ms_velo_pions, trackTypes=['Velo']) updateDoD(ms_velo_pions) DaVinci().appendToMainSequence([ms_all_protos, ms_velo_pions]) #######################
Options to run simple ChargedCombineParticleMaker configuraiton test. Different configuraiton parameter combinaitons should give cetrain Output, Input values. Author Juan Palacios [email protected] """ from Configurables import (ApplicationMgr, ChargedProtoParticleMaker, MessageSvc) #MessageSvc().Format = "% F%60W%S%7W%R%T %0W%M" # This should work fine # Inputs = [Rec/Track/Special0] # Output = Rec/ChargedPP/ProtoParticles0 cp0 = ChargedProtoParticleMaker('CPP0', Inputs=['Rec/Track/Special0'], Output='Rec/ChargedPP/ProtoParticles0', OutputLevel=1) ApplicationMgr().TopAlg += [cp0] # This should work fine # Inputs = [Rec/Track/Special1] # Output = Rec/ChargedPP/ProtoParticles1 cp1 = ChargedProtoParticleMaker('CPP1', Inputs=['Rec/Track/Special1'], Output='Rec/ChargedPP/ProtoParticles1', Context='HLT', OutputLevel=1) ApplicationMgr().TopAlg += [cp1]
def applyConf(self): if not self.isPropertySet("RecoSequencer") : raise RuntimeError("ERROR : PROTO Sequencer not set") seq = self.getProp("RecoSequencer") seq.Context = self.getProp("Context") # Charged Proto particles from Configurables import ( GaudiSequencer, ChargedProtoParticleMaker, ChargedProtoParticleAddRichInfo, ChargedProtoParticleAddMuonInfo, ChargedProtoParticleAddEcalInfo, ChargedProtoParticleAddBremInfo, ChargedProtoParticleAddHcalInfo, ChargedProtoParticleAddPrsInfo, ChargedProtoParticleAddSpdInfo, ChargedProtoParticleAddVeloInfo, ChargedProtoCombineDLLsAlg, DelegatingTrackSelector ) cseq = GaudiSequencer("ChargedProtoParticles") seq.Members += [cseq] # Make Charged ProtoParticles charged = ChargedProtoParticleMaker("ChargedProtoPMaker") charged.addTool( DelegatingTrackSelector, name="TrackSelector" ) tracktypes = self.getProp("TrackTypes") charged.TrackSelector.TrackTypes = tracktypes for type in tracktypes : self.setupTypeTrackSelector( type, charged.TrackSelector ) # Add PID information rich = ChargedProtoParticleAddRichInfo("ChargedProtoPAddRich") muon = ChargedProtoParticleAddMuonInfo("ChargedProtoPAddMuon") ecal = ChargedProtoParticleAddEcalInfo("ChargedProtoPAddEcal") brem = ChargedProtoParticleAddBremInfo("ChargedProtoPAddBrem") hcal = ChargedProtoParticleAddHcalInfo("ChargedProtoPAddHcal") velo = ChargedProtoParticleAddVeloInfo("ChargedProtoPAddVeloDEDX") # Fill the Combined DLL information in the charged protoparticles combine = ChargedProtoCombineDLLsAlg("ChargedProtoPCombDLLs") # Fill the sequence cseq.Members += [ charged,ecal,brem,hcal] if not self.getProp("NoSpdPrs") : prs = ChargedProtoParticleAddPrsInfo("ChargedProtoPAddPrs") spd = ChargedProtoParticleAddSpdInfo("ChargedProtoPAddSpd") cseq.Members += [prs,spd ] cseq.Members += [ velo, rich,muon,combine ] # Neutrals from Configurables import NeutralProtoPAlg nseq = GaudiSequencer("NeutralProtoParticles") seq.Members += [nseq] neutral = NeutralProtoPAlg("NeutralProtoPMaker") nseq.Members += [ neutral ] # Set output levels if self.isPropertySet("OutputLevel"): level = self.getProp("OutputLevel") charged.OutputLevel = level rich.OutputLevel = level muon.OutputLevel = level ecal.OutputLevel = level brem.OutputLevel = level hcal.OutputLevel = level if not self.getProp("NoSpdPrs") : prs.OutputLevel = level spd.OutputLevel = level velo.OutputLevel = level combine.OutputLevel = level neutral.OutputLevel = level # ANN PID if self.getProp("AddANNPIDInfo") : nnpidseq = GaudiSequencer("ANNGPIDSeq") cseq.Members += [nnpidseq] annconf = ChargedProtoANNPIDConf() self.setOtherProps(annconf,["DataType","OutputLevel","Context"]) annconf.RecoSequencer = nnpidseq
def __hlt2ProbeMuonProtos(self): """ Charged muon protoparticles Requires chargedProtos and muon ID """ from Configurables import (ChargedProtoParticleAddMuonInfo, ChargedProtoCombineDLLsAlg, MuonIDAlg, ChargedProtoParticleMaker, DelegatingTrackSelector) from MuonID import ConfiguredMuonIDs ProbeMuonProtosOutputLocation = _baseProtoPLocation( "Hlt2", HltDefaultFitSuffix + "/" + TrackEffNames[self.trackType()]) Hlt2ProbeMuonProtoMaker = ChargedProtoParticleMaker( self.__pidAlgosAndToolsPrefix() + 'ProbeProtoPAlg') if (self.trackType() == "MuonTT"): # create the protos bm_members = [self.__hlt2MuonTTTracking()] Hlt2ProbeMuonProtoMaker.Inputs = [ self.__hlt2MuonTTTracking().outputSelection() ] Hlt2ProbeMuonProtoMaker.addTool(DelegatingTrackSelector) Hlt2ProbeMuonProtoMaker.Output = ProbeMuonProtosOutputLocation Hlt2ProbeMuonProtoMaker.DelegatingTrackSelector.TrackTypes = [ "Long" ] bm_members += [Hlt2ProbeMuonProtoMaker] elif (self.trackType() == "VeloMuon"): #build protos out of tracks bm_members = [self.__hlt2VeloMuonTracking()] Hlt2ProbeMuonProtoMaker.Inputs = [ self.__hlt2VeloMuonTracking().outputSelection() ] Hlt2ProbeMuonProtoMaker.Output = ProbeMuonProtosOutputLocation Hlt2ProbeMuonProtoMaker.addTool(DelegatingTrackSelector, name='delTrackSel') Hlt2ProbeMuonProtoMaker.delTrackSel.TrackTypes = ['Long'] bm_members += [Hlt2ProbeMuonProtoMaker] elif (self.trackType() == "FullDownstream"): # add muon ID bm_members = [self.__hlt2FullDownstreamTracking()] idalgname = self.__pidAlgosAndToolsPrefix() + "IDalg" cm = ConfiguredMuonIDs.ConfiguredMuonIDs( data=self.getProp("DataType")) idalg = cm.configureMuonIDAlgLite(idalgname) idalg.TracksLocations = [ self.__hlt2FullDownstreamTracking().outputSelection() ] idalg.MuonIDLocation = Hlt2TrackRoot + HltDefaultFitSuffix + "/" + HltSharedPIDPrefix + "/" + HltMuonIDSuffix idalg.MuonTrackLocation = Hlt2TrackRoot + HltDefaultFitSuffix + "/" + HltSharedPIDPrefix + "/" + HltMuonTracksName # Configure moun ID tools explicitly, would be better if the ConfiguredMuonIDs class # provided a comprehensive method. All tools are public, but should configure # everywhere, where they are used to be safe. import Configurables for tool, fun in (("CommonMuonTool", "IsMuonTool"), ("DLLMuonTool", "DLLMuonTool"), ("MakeMuonTool", "MakeMuonTool")): tool = getattr(Configurables, tool)() getattr(cm, "configure" + fun)(tool) # make protos Hlt2ProbeMuonProtoMaker.Inputs = [ self.__hlt2FullDownstreamTracking().outputSelection() ] Hlt2ProbeMuonProtoMaker.Output = ProbeMuonProtosOutputLocation Hlt2ProbeMuonProtoMaker.addTool(DelegatingTrackSelector, name="TrackSelector") tracktypes = ["Downstream"] Hlt2ProbeMuonProtoMaker.TrackSelector.TrackTypes = tracktypes addmuonpid = ChargedProtoParticleAddMuonInfo("addmuonpid") addmuonpid.InputMuonPIDLocation = idalg.MuonIDLocation addmuonpid.ProtoParticleLocation = Hlt2ProbeMuonProtoMaker.Output combinedll = ChargedProtoCombineDLLsAlg("combineDLL") combinedll.ProtoParticleLocation = Hlt2ProbeMuonProtoMaker.Output bm_members += [ idalg, Hlt2ProbeMuonProtoMaker, addmuonpid, combinedll ] from HltLine.HltLine import bindMembers # Build the bindMembers bm_name = self.__pidAlgosAndToolsPrefix() + "ProbeMuonProtosSeq" bm_output = ProbeMuonProtosOutputLocation return bindMembers(bm_name, bm_members).setOutputSelection(bm_output)
def setupPF(self): ## List of algorithms to put in the sequencer ## set the algorithm alg = ParticleFlow4Jets(self.name) ## Definition of cuts to apply to input tracks for inputselection TrackCuts = {} print '###################################### ', self.TrackType if self.UseVelo and not "Velo" in self.TrackType: self.TrackType.append("Velo") for trtype in self.TrackType: if trtype == "Long": TrackCuts["Long"] = { "Chi2Cut": [0, self.Chi2MaxLong], "MinPtCut": self.PtMinLong, "CloneDistCut": [5000, 9e+99], "AcceptClones": self.AcceptClone } if trtype == "Downstream": TrackCuts["Downstream"] = { "Chi2Cut": [0, self.Chi2MaxDown], "MinPtCut": self.PtMinDown } if trtype == "Upstream": TrackCuts["Upstream"] = { "Chi2Cut": [0, self.Chi2MaxUp], "MinPtCut": self.PtMinUp } if trtype == "Velo": TrackCuts["Velo"] = {"Chi2Cut": [0, self.Chi2MaxVelo]} protos = ChargedProtoParticleMaker("VeloProtoPMaker") protos.Inputs = ["Rec/Track/Best"] protos.Output = "Rec/ProtoP/VeloProtoPMaker" protos.addTool(DelegatingTrackSelector, name="TrackSelector") protos.TrackSelector.TrackTypes = ["Velo"] self.setupTypeTrackSelector("Velo", protos.TrackSelector, TrackCuts["Velo"]) self.algorithms.append(protos) ## Neutral related cuts pLocations = [] alg.UseTTrackBanning = True alg.CandidateToBanLocation = self.CandidateToBanLocation alg.VerticesLocation = self.VerticesLocation alg.PFOutputLocation = self.PFOutputLocation alg.PFBannedOutputLocation = self.PFBannedOutputLocation alg.PFHiddenNeutralOutputLocation = self.PFHiddenNeutralOutputLocation alg.PFProtoParticlesOutputLocation = self.PFProtoParticlesOutputLocation alg.PFCaloHypoOutputLocation = self.PFCaloHypoOutputLocation for t in self.InputParticles: if t == 'Photons': pLocations.append('Phys/StdLooseAllPhotons/Particles') alg.MinPhotonID4Photon = self.MinPhotonID4Photon alg.MinPhotonID4PhotonTtrack = self.MinPhotonID4PhotonTtrack if t == 'NeutralHadrons': ## Set the HCAL uses alg.UseHCAL = self.UseHCAL self.setupHCAL() alg.MinHCALE = self.MinHCALE ## Match track and clusters alg.MaxMatchHCALLowEValue = self.MaxMatchHCALLowEValue alg.MaxMatchHCALHighEValue = self.MaxMatchHCALHighEValue alg.MaxMatchHCALTrSmallE = self.MaxMatchHCALTrSmallE alg.MaxMatchHCALTrMediumE = self.MaxMatchHCALTrMediumE alg.MaxMatchHCALTrLargeE = self.MaxMatchHCALTrLargeE alg.MaxMatchHCALTr_T = self.MaxMatchHCALTr_T if t == 'Charged': ## Track selector alg.TrackSelectorType = "DelegatingTrackSelector" alg.addTool(DelegatingTrackSelector, name="TrackSelector") tracktypes = TrackCuts.keys() alg.TrackSelector.TrackTypes = self.TrackType for type in tracktypes: self.setupTypeTrackSelector(type, alg.TrackSelector, TrackCuts) ## Track related cuts alg.MinInfMomentumCut = self.MinInfMomentumCut alg.MaxChi2NoTT = self.MaxChi2NoTT alg.UseTTHits = self.UseTTHits alg.MaxMatchECALTr = self.MaxMatchECALTr alg.MaxMatchECALTr_T = self.MaxMatchECALTr_T alg.UsePIDInfo = self.UsePIDInfo if t == 'Pi0s': pLocations.append('Phys/StdLooseResolvedPi0/Particles') pLocations.append('Phys/StdLooseMergedPi0/Particles') alg.MinPhotonIDMax4ResolvedPi0 = self.MinPhotonIDMax4ResolvedPi0 alg.MinPhotonIDMin4ResolvedPi0 = self.MinPhotonIDMin4ResolvedPi0 if t == 'V0s': pLocations.append('Phys/StdLooseKsDD/Particles') pLocations.append('Phys/StdLooseKsLL/Particles') pLocations.append('Phys/StdLooseLambdaDD/Particles') pLocations.append('Phys/StdLooseLambdaLL/Particles') if t == 'PFNeutrals': alg.NeutralRecovery = True alg.UsePIDInfo = True alg.CalibECAL_EovP = self.CalibECAL_EovP alg.CalibHCAL_EovP = self.CalibHCAL_EovP alg.NSigmaForCaloRecovery = self.NSigmaForCaloRecovery alg.ParticleLocations = pLocations #alg.OutputLevel = 0 self.algorithms.append(alg)
Hlt2FullDownParts.Input = fulldownProtos.outputSelection() Hlt2FullDownParts.Output = "Hlt2/Hlt2DownstreamMuons/Particles" ########################################################################## # # Velo particles # ########################################################################## from HltTracking.HltTrackNames import HltSharedTrackLoc, HltDefaultFitSuffix, _baseProtoPLocation, TrackName, Hlt2TrackEffRoot from HltLine.HltLine import bindMembers from Configurables import CombinedParticleMaker, ChargedProtoParticleMaker, BestPIDParticleMaker, NoPIDsParticleMaker from Configurables import DelegatingTrackSelector from HltTracking.HltSharedTracking import RevivedVelo, FittedVelo Hlt2VeloProtos = ChargedProtoParticleMaker('Hlt2VeloProtosForTrackEff') Hlt2VeloProtos.Inputs = [FittedVelo.outputSelection()] Hlt2VeloProtos.Output = _baseProtoPLocation( "Hlt2", Hlt2TrackEffRoot + "/" + TrackName["Velo"]) Hlt2VeloProtos.addTool(DelegatingTrackSelector, name='delTrackSelVelo') Hlt2VeloProtos.delTrackSelVelo.TrackTypes = ['Velo'] Hlt2VeloPionParts = NoPIDsParticleMaker("Hlt2VeloPionParts") Hlt2VeloPionParts.Particle = 'pion' Hlt2VeloPionParts.Input = Hlt2VeloProtos.Output Hlt2VeloPionParts.Output = Hlt2TrackEffRoot + "/Hlt2VeloPions/Particles" Hlt2VeloKaonParts = NoPIDsParticleMaker("Hlt2VeloKaonParts") Hlt2VeloKaonParts.Particle = 'kaon' Hlt2VeloKaonParts.Input = Hlt2VeloProtos.Output Hlt2VeloKaonParts.Output = Hlt2TrackEffRoot + "/Hlt2VeloKaons/Particles"
def defaultMinBiasD0Selection(): # this still needs to be worked out from Configurables import Escher Escher().RecoSequence = ["Decoding", "VELO", "Tr", "Vertex", "RICH"] Escher().MoniSequence = ["Tr", "OT"] # Tweak a little bit RICH MinimalRichSequence() # now create the D0->K-Pi+ candidates from Configurables import FilterDesktop from Configurables import ChargedProtoParticleMaker, ChargedProtoParticleAddRichInfo, ChargedProtoCombineDLLsAlg # take as much as possible from CommonParticles from CommonParticles.StdAllLooseKaons import StdAllLooseKaons from CommonParticles.StdAllLoosePions import StdAllLoosePions from CommonParticles.StdLooseKaons import StdLooseKaons from CommonParticles.StdLoosePions import StdLoosePions from CommonParticles.StdLooseD02HH import StdLooseD02KPi # remove cuts that require a PV StdLooseD02KPi.MotherCut = "((VFASPF(VCHI2)<10) & (ADMASS('D0')<100*MeV) & (MIPCHI2DV(PRIMARY)<100.0))" StdLooseKaons.Code = "((PT>800.*MeV) & (MIPCHI2DV(PRIMARY)>5.0))" StdLoosePions.Code = "((PT>800.*MeV) & (MIPCHI2DV(PRIMARY)>5.0))" # add tight PID cuts basically to ensure that we don't swap the # kaon and pion. AlignD02KPiWide = FilterDesktop("AlignD02KPiWide", Inputs = ["Phys/StdLooseD02KPi"], Code = "(ADMASS('D0') < 50.*MeV) & (VFASPF(VCHI2) < 9.)" \ # " & (MINTREE((ABSID=='D0'), VFASPF(VZ))-VFASPF(VZ) > 0.09*mm )" \ " & (MINTREE('K+'==ABSID, PIDK) > 0)" \ " & (MINTREE('pi+'==ABSID, PIDK) < 0)" ) # tighten the mass window for candidates used in alignment. AlignD02KPi = FilterDesktop("AlignD02KPi", Inputs=["Phys/AlignD02KPiWide"], Code="(ADMASS('D0') < 20.*MeV)") # create the sequence that we pass to the alignment from Configurables import TrackParticleMonitor, GaudiSequencer recoD0Seq = GaudiSequencer("RecoD0Seq", IgnoreFilterPassed=True) recoD0Seq.Members = [ ChargedProtoParticleMaker('ChargedProtoPMaker'), ChargedProtoParticleAddRichInfo('ChargedProtoPAddRich'), ChargedProtoCombineDLLsAlg('ChargedProtoPCombDLLs'), TrackParticleMonitor( 'StdLooseD02KPiMonitor', InputLocation='/Event/Phys/StdLooseD02KPi/Particles', MinMass=1810, MaxMass=1930), AlignD02KPiWide, TrackParticleMonitor( 'AlignD02KPiWideMonitor', InputLocation='/Event/Phys/AlignD02KPiWide/Particles', MinMass=1810, MaxMass=1930), AlignD02KPi, TrackParticleMonitor('AlignD02KPiMonitor', InputLocation='/Event/Phys/AlignD02KPi/Particles', MinMass=1810, MaxMass=1930) ] sel = ParticleSelection(Name='D02KPi', Location='/Event/Phys/AlignD02KPi/Particles', Algorithm=recoD0Seq) return sel
def defaultHLTJPsiSelection(lines=[]): # this still needs to be worked out from Configurables import Escher Escher().RecoSequence = [ "Hlt", "Decoding", "AlignTr", "Vertex", "RICH", "CALO", "MUON", "PROTO" ] Escher().MoniSequence = ["Tr", "OT"] # if the Escher hlt filter is not set, set it here if not hasattr(Escher(), "HltFilterCode") or not Escher().HltFilterCode: Escher().HltFilterCode = "HLT_PASS_RE( 'Hlt2.*JPsi.*Decision' )" # revive only particles used for trigger print 'Hlt lines to be used: ' print ReviveHltTracks(lines if len(lines) else [ 'Hlt2ExpressJPsiDecision', 'Hlt2DiMuonDetachedJPsiDecision', 'Hlt2DiMuonJPsiDecision', 'Hlt2DiMuonJPsiHighPTDecision' ]) # Now create the J/psi candidates from Configurables import CombineParticles, FilterDesktop from CommonParticles.StdAllLooseMuons import StdAllLooseMuons from CommonParticles.StdLooseJpsi2MuMu import StdLooseJpsi2MuMu StdLooseJpsi2MuMu.DaughtersCuts = { "mu-": "(PIDmu-PIDK>5.0) & (PIDmu-PIDe>8.0)" } ## tighten the mass window for candidates used in alignment AlignJpsi2MuMu = FilterDesktop( "AlignJpsi2MuMu", Inputs=["Phys/StdLooseJpsi2MuMu"], Code="(ADMASS('J/psi(1S)') < 35.*MeV) & (VFASPF(VCHI2) < 7.)" ) # Tight requirements on vchi2 - test 18/5/2012 from Configurables import ChargedProtoParticleMaker, ChargedProtoParticleAddMuonInfo, ChargedProtoCombineDLLsAlg from Configurables import TrackParticleMonitor, GaudiSequencer recoJpsiSeq = GaudiSequencer("RecoJpsiSeq") recoJpsiSeq.Members = [ ChargedProtoParticleMaker('ChargedProtoPMaker'), ChargedProtoParticleAddMuonInfo('ChargedProtoPAddMuon'), ChargedProtoCombineDLLsAlg('ChargedProtoPCombDLLs'), StdAllLooseMuons, # we could also get this from the DoD StdLooseJpsi2MuMu, # we could also get this from the DoD TrackParticleMonitor( 'StdLooseJpsi2MuMuMonitor', InputLocation='/Event/Phys/StdLooseJpsi2MuMu/Particles', MinMass=3000, MaxMass=3190), AlignJpsi2MuMu, TrackParticleMonitor( 'AlignJpsi2MuMuMonitor', InputLocation='/Event/Phys/AlignJpsi2MuMu/Particles', MinMass=3000, MaxMass=3190), ] sel = ParticleSelection(Name='Jpsi2MuMu', Location='/Event/Phys/AlignJpsi2MuMu/Particles', Algorithm=recoJpsiSeq) return sel
def defaultHLTDstarSelection(): # this still needs to be worked out from Configurables import Escher Escher().RecoSequence = ["Hlt", "Decoding", "AlignTr", "Vertex", "RICH"] Escher().MoniSequence = ["Tr", "OT"] # if the Escher hlt filter is not set, set it here if not hasattr(Escher(), "HltFilterCode") or not Escher().HltFilterCode: Escher( ).HltFilterCode = "HLT_PASS_RE( 'Hlt2ExpressDStar2D0PiDecision' )" # retrieve the trigger lines from the hlt filter code print 'Hlt lines to be used: ' print ReviveHltTracks() # Tweak a little bit RICH MinimalRichSequence() # now create the D0->K-Pi+ candidates from Configurables import FilterDesktop from Configurables import ChargedProtoParticleMaker, ChargedProtoParticleAddRichInfo, ChargedProtoCombineDLLsAlg # take as much as possible from CommonParticles from CommonParticles.StdAllLooseKaons import StdAllLooseKaons from CommonParticles.StdAllLoosePions import StdAllLoosePions from CommonParticles.StdLooseKaons import StdLooseKaons from CommonParticles.StdLoosePions import StdLoosePions from CommonParticles.StdLooseD02HH import StdLooseD02KPi from CommonParticles.StdLooseDstarWithD2HH import StdLooseDstarWithD02KPi # remove cuts that require a PV StdLooseD02KPi.MotherCut = "((VFASPF(VCHI2)<10) & (ADMASS('D0')<100*MeV))" StdLooseKaons.Code = "ALL" StdLoosePions.Code = "ALL" # add tight PID cuts basically toensure that we don't swap the # kaon and pion. AlignD02KPiWide = FilterDesktop( "AlignD02KPiWide", Inputs=["Phys/StdLooseD02KPi"], Code="(ADMASS('D0') < 50.*MeV) & (VFASPF(VCHI2) < 9.)") # tighten the mass window for candidates used in alignment. AlignD02KPi = FilterDesktop("AlignD02KPi", Inputs=["Phys/AlignD02KPiWide"], Code="(ADMASS('D0') < 20.*MeV)") # create the sequence that we pass to the alignment from Configurables import TrackParticleMonitor, GaudiSequencer recoDstarWithD0Seq = GaudiSequencer("RecoDstarWithD0Seq") recoDstarWithD0Seq.Members = [ ChargedProtoParticleMaker('ChargedProtoPMaker'), ChargedProtoParticleAddRichInfo('ChargedProtoPAddRich'), ChargedProtoCombineDLLsAlg('ChargedProtoPCombDLLs'), TrackParticleMonitor( 'StdLooseD02KPiMonitor', InputLocation='/Event/Phys/StdLooseD02KPi/Particles', MinMass=1810, MaxMass=1930), StdLooseDstarWithD02KPi, #apply Dstar cut AlignD02KPiWide, TrackParticleMonitor( 'AlignD02KPiWideMonitor', InputLocation='/Event/Phys/AlignD02KPiWide/Particles', MinMass=1810, MaxMass=1930), AlignD02KPi, TrackParticleMonitor('AlignD02KPiMonitor', InputLocation='/Event/Phys/AlignD02KPi/Particles', MinMass=1810, MaxMass=1930) ] sel = ParticleSelection(Name='DstarWithD02KPi', Location='/Event/Phys/AlignD02KPi/Particles', Algorithm=recoDstarWithD0Seq) return sel
################################### # Customize DaVinci main sequence # ################################### # These algorithms are executed before any of the selection algorithms. # # algorithms defined here will set up locations that will be available for all # selection algorithms. from Configurables import ChargedProtoParticleMaker from Configurables import NoPIDsParticleMaker from Configurables import TrackScaleState from Configurables import TrackSmearState from CommonParticles.Utils import trackSelector, updateDoD # Provide required information for VELO pions. ms_all_protos = ChargedProtoParticleMaker(name='MyProtoPMaker') ms_all_protos.Inputs = ['Rec/Track/Best'] ms_all_protos.Output = 'Rec/ProtoP/MyProtoPMaker/ProtoParticles' # This TES location will be accessible for all selection algorithms # VELO pions for Greg's isolation tool. # NOTE: The name 'StdNoPIDsVeloPions' is hard-coded in the tuple tool, so the # name should not be changed. ms_velo_pions = NoPIDsParticleMaker('StdNoPIDsVeloPions', Particle='pion') ms_velo_pions.Input = ms_all_protos.Output # NOTE: These two lines are needed to select particles in VELO only. # NOTE: DARK MAGIC. trackSelector(ms_velo_pions, trackTypes=['Velo']) updateDoD(ms_velo_pions) # According to the source code (available in 'Analysis/Phys/DaVinciTrackScaling/src/TrackScaleState.cpp'):
def setupPF(self): ## set the algorithm alg = ParticleFlow(self.name) if "Velo" in self.paramDef['TrackSelector'].keys( ) and not self.paramDef['UseVelo']: self.paramDef['UseVelo'] = True # set all params for prop, value in self.paramDef.items(): if prop != 'TrackSelector' and prop != 'TrackVelo' and prop != "scalingANDsmearing": setattr(alg, prop, value) else: self.__dict__[prop] = value if (self.name != "PF"): alg.PFOutputLocation = "Phys/" + self.name + "/Particles" ## List of algorithms to put in the sequencer if self.scalingANDsmearing: from Configurables import TrackScaleState as SCALER scaler = SCALER('PFStateScale') self.PFSeq.Members += [scaler] if self.MCCor: from Configurables import TrackSmearState as SMEAR smear = SMEAR('PFStateSmear') self.PFSeq.Members += [smear] ## Definition of cuts to apply to input tracks for inputselection TrackCuts = {} if self.paramDef['UseVelo'] and not "Velo" in self.TrackSelector.keys( ): self.TrackSelector["Velo"] = self.TrackVelo for trtype in self.TrackSelector.keys(): if trtype == "Long": TrackCuts[trtype] = { "Chi2Cut": [0, self.TrackSelector[trtype]['Chi2Max']], "MinPtCut": self.TrackSelector[trtype]['PtMin'], "MaxGhostProbCut": self.TrackSelector[trtype]['MaxGhostProb'] } if trtype == "Downstream": TrackCuts[trtype] = { "Chi2Cut": [0, self.TrackSelector[trtype]['Chi2Max']], "MinPtCut": self.TrackSelector[trtype]['PtMin'], "MaxGhostProbCut": self.TrackSelector[trtype]['MaxGhostProb'] } if trtype == "Upstream": TrackCuts[trtype] = { "Chi2Cut": [0, self.TrackSelector[trtype]['Chi2Max']], "MinPtCut": self.TrackSelector[trtype]['PtMin'] } if trtype == "Velo": TrackCuts[trtype] = { "Chi2Cut": [0, self.TrackSelector[trtype]['Chi2Max']] } protos = ChargedProtoParticleMaker("VeloProtoPMaker") protos.Inputs = ["Rec/Track/Best"] protos.Output = "Rec/ProtoP/VeloProtoPMaker" protos.addTool(DelegatingTrackSelector, name="TrackSelector") protos.TrackSelector.TrackTypes = ["Velo"] self.setupTypeTrackSelector("Velo", protos.TrackSelector, TrackCuts["Velo"]) self.PFSeq.Members += [protos] pLocations = [] pCompLocations = [] alg.MC_recovery = self.MCCor #re set default to false alg.UseHCAL = False alg.NeutralRecovery = False for t in self.InputParticles: if t == 'Photons': pLocations.append('Phys/StdLooseAllPhotons/Particles') elif t == 'NeutralHadrons': ## Set the HCAL uses alg.UseHCAL = True self.setupHCAL() elif t == 'Charged': ## Track selector alg.TrackSelectorType = "DelegatingTrackSelector" alg.addTool(DelegatingTrackSelector, name="TrackSelector") tracktypes = TrackCuts.keys() alg.TrackSelector.TrackTypes = self.TrackSelector.keys() for type in tracktypes: self.setupTypeTrackSelector(type, alg.TrackSelector, TrackCuts) elif t == 'Pi0s': pLocations.append('Phys/StdLooseResolvedPi0/Particles') pLocations.append('Phys/StdLooseMergedPi0/Particles') elif t == 'V0s': pCompLocations.append("Phys/StdKs2PiPiLL/Particles") pCompLocations.append("Phys/StdKs2PiPiDD/Particles") pCompLocations.append("Phys/StdLambda2PPiLL/Particles") pCompLocations.append("Phys/StdLambda2PPiDD/Particles") elif t == 'PFNeutrals': alg.NeutralRecovery = True else: print t, "are not supported!" exit(1) if len(self.paramDef['CompositeParticleLocations']) > 0.5: for t in self.paramDef['CompositeParticleLocations']: pCompLocations.append(t) alg.ParticleLocations = pLocations alg.CompositeParticleLocations = pCompLocations self.PFSeq.Members += [alg] self.algorithms.append(self.PFSeq)