def __hlt2FullDownstreamTracking(self): """ Full Downstream track reconstruction and fitting for tracking efficiency lines """ from Configurables import PatSeeding from Configurables import PatSeedingTool from HltLine.HltLine import bindMembers from Configurables import TrackEventFitter, TrackMasterFitter DownstreamFit = TrackEventFitter('DownstreamFitter') DownstreamFit.TracksInContainer = Hlt2TrackLoc[ "Downstream"] #use unfitted Downstream tracks out of Hlt2Tracking DownstreamFit.TracksOutContainer = Hlt2TrackEffLoc[ "FullDownstream"] #our outputlocation DownstreamFit.addTool(TrackMasterFitter, name='Fitter') from TrackFitter.ConfiguredFitters import ConfiguredHltFitter, ConfiguredMasterFitter DownstreamFitter = getattr(DownstreamFit, 'Fitter') from Configurables import HltRecoConf ConfiguredMasterFitter(DownstreamFitter, SimplifiedGeometry=True, LiteClusters=True, MSRossiAndGreisen=HltRecoConf().getProp( "NewMSinFit")) #on par with Hlt track fits DownstreamFitter.OutputLevel = 5 # Build the bindMembers bm_name = self.getProp("Prefix") + "FullDownstreamTracking" bm_members = [DownstreamFit] bm_output = Hlt2TrackEffLoc["FullDownstream"] return bindMembers(bm_name, bm_members).setOutputSelection(bm_output)
def Hlt1GECStreamer(gec='Loose', accept=True): from Configurables import HltRecoConf gecs = { 'Tight': { 'MaxOTHits': HltRecoConf().getProp("Forward_MaxOTHits"), 'MaxITHits': 3000, 'MaxVeloHits': 3000, 'IsActivity': False }, 'Loose': { 'MaxOTHits': HltRecoConf().getProp("Forward_MaxOTHits"), 'MaxITHits': 3000, 'MaxVeloHits': 6000, 'IsActivity': False }, 'Activity': { 'MinOTHits': 100, 'MinITHits': 100, 'MinVeloHits': 100, 'IsActivity': True } } from Configurables import Hlt__GEC from HltLine.HltDecodeRaw import DecodeIT, DecodeVELO from HltLine.HltLine import bindMembers tool = Hlt__GEC("%sGECs" % gec, **gecs[gec]) code = "ACCEPT( '%s' )" % tool.getFullName() if not accept: code = '~' + code bm = bindMembers(None, [DecodeIT, DecodeVELO]) return "GEC%s%s = ( execute( %s ) & %s ) " % ({ True: 'Accept', False: 'Reject' }[accept], gec, [m.getFullName() for m in bm.members()], code)
def __hlt2ProbeTracking(self): """ Track reconstruction """ from HltLine.HltLine import bindMembers # # Set output location # hlt2TrackingOutput = Hlt2TrackLoc[self.trackType()] # Finally make the sequence trackRecoSequence = [] if (self.trackType() == "MuonTT"): trackRecoSequence = [self.__hlt2MuonTTTracking()] elif (self.trackType() == "VeloMuon"): trackRecoSequence = [self.__hlt2VeloMuonTracking()] elif (self.trackType() == "FullDownstream"): trackRecoSequence = [self.__hlt2FullDownstreamTracking()] # Build the bindMembers bm_name = self.__trackingAlgosAndToolsPrefix() + "TrackingSeq" bm_members = trackRecoSequence bm_output = hlt2TrackingOutput return bindMembers(bm_name, bm_members).setOutputSelection(bm_output)
def muonUnit(self): selection = 'Hlt1SharedMuons' props = self.getProps().copy() props.update({'selection': selection}) code = """ TrackCandidates >> tee ( monitor( TC_SIZE > 0, '# pass IsMuon', LoKi.Monitoring.ContextSvc ) ) >> FitTrack >> ( ( TrPT > %(PT)s * MeV ) & \ ( TrP > %(P)s * MeV ) ) >> IsMuon >> tee ( monitor( TC_SIZE > 0, '# pass Cuts', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE > 0, '# pass IsMuon', LoKi.Monitoring.ContextSvc ) ) >> TC_TOPROTOPARTICLES( '' ) >> TC_TOPARTICLES( 'mu+', '', ALL ) >> tee ( monitor( TC_SIZE > 0, '# pass ToMuons', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , 'nMuons', LoKi.Monitoring.ContextSvc ) ) >> SINK( '%(selection)s' ) >> ~TC_EMPTY """ % props from Configurables import LoKi__HltUnit as HltUnit from HltTracking.Hlt1Tracking import (TrackCandidates, IsMuon, FitTrack) muonUnit = HltUnit( 'Hlt1SharedMuonUnit', Preambulo=[TrackCandidates('SharedMuons'), IsMuon, FitTrack], Monitor=True, Code=code) from HltLine.HltLine import bindMembers bm = bindMembers(None, [muonUnit]).setOutputSelection(selection) return bm
def protoParticleUnit(self): selection = 'Hlt1ProtoParticles' props = self.getProps().copy() props.update({'selection': selection}) code = """ TrackCandidates >> FitTrack >> ( ( TrPT > %(PT)s * MeV ) & \ ( TrP > %(P)s * MeV ) ) >> tee ( monitor( TC_SIZE > 0, '# pass TrackFit', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , 'nFit' , LoKi.Monitoring.ContextSvc ) ) >> ( TrCHI2PDOF < %(TrackChi2DOF)s ) >> tee ( monitor( TC_SIZE > 0, '# pass TrackChi2', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , 'nChi2' , LoKi.Monitoring.ContextSvc ) ) >> TC_TOPROTOPARTICLES( '' ) >> SINK( '%(selection)s' ) >> ~TC_EMPTY """ % props from Configurables import LoKi__HltUnit as HltUnit from HltTracking.Hlt1Tracking import TrackCandidatesAlgos from HltTracking.Hlt1Tracking import (TrackCandidates, FitTrack) preambulo = [TrackCandidates('SharedParticles'), FitTrack] protoUnit = HltUnit( 'Hlt1ProtoParticleUnit', #OutputLevel = 1, Monitor=True, Preambulo=preambulo, Code=code) from HltLine.HltLine import bindMembers bm = bindMembers(None, [TrackCandidatesAlgos('SharedParticles'), protoUnit ]).setOutputSelection(selection) return bm
def __configure(self): recoSeq = GaudiSequencer("Hlt2JetRecoSequence", ModeOR = True, ShortCircuit = False) from HltTracking.Hlt2TrackingConfigurations import Hlt2BiKalmanFittedForwardTracking from HltTracking.Hlt2TrackingConfigurations import Hlt2BiKalmanFittedDownstreamTracking # Long charged proto particles longTracking = Hlt2BiKalmanFittedForwardTracking() longChargedProtos = longTracking.hlt2ChargedNoPIDsProtos() longSeq = GaudiSequencer("Hlt2JetLongRecoSequence", Members = longChargedProtos.members()) # Downstream charged proto particles downTracking = Hlt2BiKalmanFittedDownstreamTracking() downChargedProtos = downTracking.hlt2ChargedNoPIDsProtos() downSeq = GaudiSequencer("Hlt2JetDownRecoSequence", Members = downChargedProtos.members()) from Hlt2SharedParticles.TrackFittedBasicParticles import BiKalmanFittedPhotons as Photons from Hlt2SharedParticles.Pi0 import ResolvedPi0s from Hlt2SharedParticles.Pi0 import MergedPi0s from Hlt2SharedParticles.Ks import KsLLTF as KsLL from Hlt2SharedParticles.Ks import KsLLTF as KsDD from Hlt2SharedParticles.Lambda import LambdaLLTrackFitted as LambdaLL from Hlt2SharedParticles.Lambda import LambdaDDTrackFitted as LambdaDD self.__caloProcessor = longTracking.caloProcessor() ecalSeq = self.__caloProcessor.clusters() inputs = [ ['Particle', 'particle', self.__sharedParticleInput(Photons, "Photons")], ['Particle', 'particle', self.__sharedParticleInput(ResolvedPi0s, "ResolvedPi0s")], ['Particle', 'particle', self.__sharedParticleInput(MergedPi0s, "MergedPi0s")], ['Particle', 'particle', self.__sharedParticleInput(KsLL, "KsLL")], ['Particle', 'particle', self.__sharedParticleInput(KsDD, "KsDD")], ['Particle', 'particle', self.__sharedParticleInput(LambdaLL, "LambdaLL")], ['Particle', 'particle', self.__sharedParticleInput(LambdaDD, "LambdaDD")], ['ProtoParticle', 'best', (longSeq, longChargedProtos.outputSelection())], ['ProtoParticle', 'best', (downSeq, downChargedProtos.outputSelection())], ['CaloCluster', 'gamma', (None, self.__findCaloLocation(Photons.members(), CellularAutomatonAlg, "OutputData"))], ['CaloCluster', 'gamma', self.__hcalClusters()], ['IClusTrTable2D', 'ecal', (None, self.__findCaloLocation(Photons.members(), PhotonMatchAlg, "Output"))], ['IClusTrTable2D', 'hcal', self.__hcal2Track(longTracking, Photons)] ] pfInputs = [] for inputClass, inputType, (seq, loc) in inputs: if seq and seq not in recoSeq.Members: recoSeq.Members += [seq] pfInputs.append([inputClass, inputType, loc]) from Configurables import HltParticleFlow particleFlow = HltParticleFlow("HltParticleFlow", **self.getProp('ParticleFlowOptions')) particleFlow.Inputs = pfInputs particleFlow.Output = "Hlt2/ParticleFlow/Particles" from HltLine.HltLine import bindMembers self.__particleFlow = bindMembers("Hlt2Jet", [recoSeq, particleFlow])
def hltHighPTLowMultiplicity_Streamer( self, name, props): from Hlt1Lines.Hlt1GECs import Hlt1GECUnit from HltTracking.HltPVs import PV3D from Configurables import LoKi__HltUnit as HltUnit from HltLine.HltLine import bindMembers props['name'] = name algos = [] gec = props["GEC"] algos.append( Hlt1GECUnit( props["GEC"] ) ) algos.append( PV3D('Hlt1') ) LowMultUnit = HltUnit( "Hlt1%(name)sLowMultStreamer" % props, Preambulo = self.hltLowMultiplicity_Preambulo( 'CalibHighPTLowMultTrksU1' ), Code = """ TrackCandidates >> FitTrack >> tee ( monitor( TC_SIZE , 'nFit' , LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE < %(MaxTr)s , 'nTrksLT' , LoKi.Monitoring.ContextSvc ) ) >> (TC_SIZE < %(MaxTr)s) """ % props ) algos.append( LowMultUnit ) TrackSelUnit = HltUnit( "Hlt1%(name)sTrackSelStreamer" % props, Preambulo = self.hltLowMultiplicity_Preambulo( 'CalibHighPTLowMultTrksU2' ), Code = """ TrackCandidates >> FitTrack >> tee ( monitor( TC_SIZE > 0, '# pass TrackFit', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , 'nFit' , LoKi.Monitoring.ContextSvc ) ) >> ( ( TrPT > %(PT)s ) & ( TrP > %(P)s ) & ( TrCHI2PDOF < %(TrChi2)s ) ) >> tee ( monitor( TC_SIZE > 0, '# pass P/PT/TrackChi2', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , 'nP/PT/Chi2' , LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , 'nFit' , LoKi.Monitoring.ContextSvc ) ) >> SINK( 'Hlt1%(name)sDecision' ) >> (TC_SIZE > %(MinTr)s) """ % props ) algos.append( TrackSelUnit ) #return [ Hlt1GECUnit( props[ 'GEC' ] ), PV3D('Hlt1'), self.hltLowMultiplicity_Streamer( name, props)[0], hltHighPTLowMultiplicity_Unit ] return bindMembers( "Hlt1%(name)sAlgos" % props, algos ).setOutputSelection( "Hlt1%(name)sDecision" )
def kaonUnit(self): protoUnit = self.protoParticleUnit() selection = 'Hlt1SharedKaons' props = {'selection': selection, 'input': protoUnit.outputSelection()} code = """ SELECTION( '%(input)s' ) >> TC_TOPARTICLES( 'K+', '', ALL ) >> tee ( monitor( TC_SIZE > 0, '# pass ToKaons', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , 'nKaons', LoKi.Monitoring.ContextSvc ) ) >> SINK( '%(selection)s' ) >> ~TC_EMPTY """ % props from Configurables import LoKi__HltUnit as HltUnit kaonUnit = HltUnit('Hlt1SharedKaonUnit', Monitor=True, Code=code) from HltLine.HltLine import bindMembers bm = bindMembers(None, [protoUnit, kaonUnit]).setOutputSelection(selection) return bm
def __hlt2VeloMuonTracking(self): """ VeloMuon track reconstruction for Hlt2 """ #HltSharedTracking decides which Velo sequence is used from Configurables import Hlt2Conf, VeloMuonBuilder, StandaloneMuonRec, TrackMasterFitter from Configurables import MeasurementProviderT_MeasurementProviderTypes__VeloLiteR_, MeasurementProviderT_MeasurementProviderTypes__VeloLitePhi_ from HltLine.HltLine import bindMembers # Define output location VeloMuonTracksOutputLocation = Hlt2TrackEffLoc["VeloMuon"] # Get Muon standalone track Hlt2StandaloneMuon = StandaloneMuonRec("Hlt2StandaloneMuon") Hlt2StandaloneMuon.OutputMuonTracksName = Hlt2TrackEffLoc[ "StandaloneMuon"] #build VeloMuon track Hlt2VeloMuonBuild = VeloMuonBuilder('Hlt2VeloMuonBuild') Hlt2VeloMuonBuild.MuonLocation = Hlt2StandaloneMuon.OutputMuonTracksName Hlt2VeloMuonBuild.VeloLocation = HltSharedTrackLoc[ "Velo"] #Velo track location in Hlt Hlt2VeloMuonBuild.lhcbids = 4 Hlt2VeloMuonBuild.OutputLocation = VeloMuonTracksOutputLocation Hlt2VeloMuonBuild.addTool(TrackMasterFitter) from TrackFitter.ConfiguredFitters import ConfiguredHltFitter, ConfiguredMasterFitter from Configurables import HltRecoConf ConfiguredMasterFitter(Hlt2VeloMuonBuild.TrackMasterFitter, SimplifiedGeometry=True, LiteClusters=True, MSRossiAndGreisen=HltRecoConf().getProp( "NewMSinFit")) #on par with Hlt track fits Hlt2VeloMuonBuild.TrackMasterFitter.OutputLevel = 5 # Build the bindMembers bm_name = self.getProp("Prefix") + "VeloMuonTracking" bm_members = [Hlt2StandaloneMuon, Hlt2VeloMuonBuild] bm_output = VeloMuonTracksOutputLocation return bindMembers(bm_name, bm_members).setOutputSelection(bm_output)
__all__ = ('BiKalmanFittedMuons', 'BiKalmanFittedDownMuons', 'BiKalmanFittedNoPIDsMuons', 'BiKalmanFittedElectrons', 'BiKalmanFittedNoPIDsElectrons', 'BiKalmanFittedElectronsFromL0', 'BiKalmanFittedNoDLLCutElectronsFromL0', 'BiKalmanFittedDownElectrons', 'BiKalmanFittedNoPIDsDownElectrons', 'BiKalmanFittedKaons', 'BiKalmanFittedPions', 'BiKalmanFittedDownPions', 'BiKalmanFittedProtons', 'BiKalmanFittedDownProtons', 'BiKalmanFittedRichPions', 'BiKalmanFittedRichKaons', 'BiKalmanFittedRichProtons', 'BiKalmanFittedPhotons', 'BiKalmanFittedPionsWithMuonID', 'BiKalmanFittedKaonsWithMuonID', 'BiKalmanFittedPhotonsFromL0', 'BiKalmanFittedPhotonsFromL0Low') # BiKalmanFittedKaons = bindMembers( None, [BiKalmanFittedChargedRichHadronProtoMaker, Hlt2BiKalmanFittedKaons]) BiKalmanFittedPions = bindMembers( None, [BiKalmanFittedChargedRichHadronProtoMaker, Hlt2BiKalmanFittedPions]) BiKalmanFittedDownPions = bindMembers( None, [BiKalmanFittedChargedDownProtoMaker, Hlt2BiKalmanFittedDownPions]) BiKalmanFittedDownKaons = bindMembers( None, [BiKalmanFittedChargedDownProtoMaker, Hlt2BiKalmanFittedDownKaons]) BiKalmanFittedProtons = bindMembers( None, [BiKalmanFittedChargedRichHadronProtoMaker, Hlt2BiKalmanFittedProtons]) BiKalmanFittedDownProtons = bindMembers( None, [BiKalmanFittedChargedDownProtoMaker, Hlt2BiKalmanFittedDownProtons]) BiKalmanFittedMuons = bindMembers( None, [BiKalmanFittedMuonProtoMaker, Hlt2BiKalmanFittedMuons]) BiKalmanFittedDownMuons = bindMembers(
Hlt2ResolvedPi0sFromL0.MassWindow = 60.* MeV # was 30.* MeV Hlt2ResolvedPi0sFromL0.PhotonMaker.PtCut = 200.*MeV ########################################################################## # Make the pi0 # Hlt2MergedPi0sFromL0 = MergedPi0Maker("Hlt2MergedPi0sFromL0") Hlt2MergedPi0sFromL0.Output = 'Hlt2/Hlt2MergedPi0sFromL0/Particles' Hlt2MergedPi0sFromL0.DecayDescriptor = "Pi0" Hlt2MergedPi0sFromL0.Input = neutralProtosFromL0.outputSelection() Hlt2MergedPi0sFromL0.MassWindow = 60.* MeV ########################################################################## # Make both # SeqHlt2Pi0FromL0 = GaudiSequencer('SeqHlt2Pi0FromL0 ', ModeOR=True, ShortCircuit=False, Members = [ Hlt2MergedPi0sFromL0, Hlt2ResolvedPi0sFromL0]) # # define exported symbols -- these are for available # for use in Hlt2 by adding: # # from Hlt2SharedParticles.BasicParticles import Hlt2MergedPi0s # __all__ = ( 'MergedPi0s', 'ResolvedPi0s', 'AllPi0s', 'MergedPi0sFromL0', 'ResolvedPi0sFromL0', 'AllPi0sFromL0' ) MergedPi0s = bindMembers( None, [ neutralProtos, Hlt2MergedPi0s ] ).setOutputSelection(Hlt2MergedPi0s.Output) ResolvedPi0s = bindMembers( None, [ neutralProtos, Hlt2ResolvedPi0s ] ).setOutputSelection(Hlt2ResolvedPi0s.Output) AllPi0s = bindMembers( None, [ neutralProtos, SeqHlt2Pi0 ] ).setOutputSelection( [ Hlt2MergedPi0s.Output, Hlt2ResolvedPi0s.Output ] ) MergedPi0sFromL0 = bindMembers( None, [ neutralProtosFromL0, Hlt2MergedPi0sFromL0 ] ).setOutputSelection(Hlt2MergedPi0sFromL0.Output) ResolvedPi0sFromL0 = bindMembers( None, [ neutralProtosFromL0, Hlt2ResolvedPi0sFromL0 ] ).setOutputSelection(Hlt2ResolvedPi0sFromL0.Output) AllPi0sFromL0 = bindMembers( None, [ SeqHlt2Pi0FromL0 ] ).setOutputSelection([Hlt2MergedPi0sFromL0.Output, Hlt2ResolvedPi0sFromL0.Output])
Hlt2ResolvedEtas.addTool(PhotonMaker) Hlt2ResolvedEtas.PhotonMaker.Input = neutralProtos.outputSelection() Hlt2ResolvedEtas.MassWindow = 105. * MeV # Hlt2ResolvedEtas.PhotonMaker.PtCut = 200. * MeV ########################################################################## # Make the eta # #Hlt2ResolvedEtasFromL0 = ResolvedPi0Maker("Hlt2ResolvedEtasFromL0") #Hlt2ResolvedEtasFromL0.Input = neutralProtosFromL0.outputSelection() #Hlt2ResolvedEtasFromL0.DecayDescriptor = "Eta" #Hlt2ResolvedEtasFromL0.Output = 'Hlt2/Hlt2ResolvedEtasFromL0/Particles' #Hlt2ResolvedEtasFromL0.addTool(PhotonMaker) #Hlt2ResolvedEtasFromL0.PhotonMaker.Input = neutralProtosFromL0.outputSelection() #Hlt2ResolvedEtasFromL0.MassWindow = 105.* MeV # #Hlt2ResolvedEtasFromL0.PhotonMaker.PtCut = 200.*MeV ########################################################################## # # define exported symbols -- these are for available # for use in Hlt2 by adding: # # from Hlt2SharedParticles.BasicParticles import Hlt2ResolvedEtas # #__all__ = ( 'ResolvedEtas', 'ResolvedEtasFromL0' ) __all__ = ('ResolvedEtas') ResolvedEtas = bindMembers(None, [neutralProtos, Hlt2ResolvedEtas ]).setOutputSelection(Hlt2ResolvedEtas.Output) #ResolvedEtasFromL0 = bindMembers( None, [ neutralProtosFromL0, Hlt2ResolvedEtasFromL0 ] ).setOutputSelection(Hlt2ResolvedEtasFromL0.Output)
Hlt2Photons.PhotonMaker.Input = neutralProtos.outputSelection() Hlt2Photons.Inputs = [ ] # set explicitly, otherwise it goes for the default /Rec/Proto/Charged! Hlt2Photons.Input = 'PleaseIgnore' # set explicitly, otherwise it goes for the default /Rec/Proto/Charged! Hlt2Photons.Output = 'Hlt2/Hlt2Photons/Particles' Hlt2Photons.PhotonMaker.ConvertedPhotons = True Hlt2Photons.PhotonMaker.UnconvertedPhotons = True Hlt2Photons.PhotonMaker.PtCut = 200. * MeV Hlt2Photons.WriteP2PVRelations = False ########################################################################## # # # ########################################################################## # # define exported symbols -- these are for available # for use in Hlt2 by adding: # # from Hlt2SharedParticles.BasicParticles import Muons # __all__ = ('NoCutsPions', 'NoCutsKaons', 'NoCutsProtons', 'Muons', 'Electrons', 'Photons') NoCutsPions = bindMembers(None, [hadronProtos, Hlt2NoCutsPions]) NoCutsKaons = bindMembers(None, [hadronProtos, Hlt2NoCutsKaons]) NoCutsProtons = bindMembers(None, [hadronProtos, Hlt2NoCutsProtons]) Muons = bindMembers(None, [muonProtos, Hlt2Muons]) Electrons = bindMembers(None, [caloProtos, Hlt2Electrons]) Photons = bindMembers(None, [neutralProtos, Hlt2Photons])
## from Gaudi.Configuration import * from Configurables import CombineParticles from HltLine.HltLine import bindMembers, Hlt2Member from Hlt2SharedParticles.TrackFittedBasicParticles import BiKalmanFittedRichKaons __all__ = ( 'Phi2KK', 'UnbiasedPhi2KK' ) Hlt2SharedPhi2KK = Hlt2Member( CombineParticles , 'Phi2KK' , Inputs = [ BiKalmanFittedRichKaons ] , DecayDescriptor = "phi(1020) -> K+ K-" , DaughtersCuts = { "K+" : "ALL"} , CombinationCut = "(ADAMASS('phi(1020)')<50*MeV)" , MotherCut = "(VFASPF(VCHI2PDOF)<25)" ) Phi2KK = bindMembers( 'Shared', [ BiKalmanFittedRichKaons, Hlt2SharedPhi2KK ] ) ### # # Hlt2 Phi for Bs -> Phi Phi selection # # @author N.Styles [email protected] # @date 2008-10-09 # ## Hlt2SharedUnbiasedPhi2KK = Hlt2Member( CombineParticles , "UnbiasedPhi2KK" , Inputs = [ BiKalmanFittedRichKaons ] , DecayDescriptor = "phi(1020) -> K+ K-" , DaughtersCuts = { "K+" : "(PT > 500*MeV) & (PIDK>0.)" }
from HltTracking.HltPVs import PV3D __all__ = ('KsLLTF', 'KsDD') # The LL K shorts, track fitted Hlt2SharedKsLLTF = Hlt2Member( CombineParticles, "KsLLTF", DecayDescriptor="KS0 -> pi+ pi-", DaughtersCuts={"pi+": "(TRCHI2DOF<3.)& (MIPCHI2DV(PRIMARY)>36)"}, CombinationCut="(ADAMASS('KS0')<50*MeV) ", MotherCut= "(ADMASS('KS0')<35*MeV) & (VFASPF(VCHI2PDOF)<30) & (BPVLTIME() > 2.0*ps) ", Inputs=[BiKalmanFittedPions]) KsLLTF = bindMembers("SharedKsLLTF", [PV3D('Hlt2'), BiKalmanFittedPions, Hlt2SharedKsLLTF]) # Now the downstream K shorts, requires fitted tracks! Hlt2SharedKsDD = Hlt2Member( CombineParticles, "KsDD", DecayDescriptor="KS0 -> pi+ pi-", DaughtersCuts={"pi+": "(TRCHI2DOF<4) & (P>3000*MeV) & (PT > 175.*MeV)"}, CombinationCut="(ADAMASS('KS0')<80*MeV)", MotherCut= "(ADMASS('KS0')<64*MeV) & (VFASPF(VCHI2PDOF)<30) & (BPVVDZ > 400.0*mm)", Inputs=[BiKalmanFittedDownPions]) KsDD = bindMembers("SharedKsDD", [PV3D('Hlt2'), BiKalmanFittedDownPions, Hlt2SharedKsDD])
"VeloPions", Inputs=[Hlt2VeloPionParts.Output], Code="(ETA > 1.9) & (ETA < 4.9) & (MIPCHI2DV(PRIMARY) > 4)") # define exported symbols -- these are for available # for use in Hlt2 by adding: # # from Hlt2SharedParticles.TagAndProbeParticles import TagAndProbeMuons # __all__ = ('TagAndProbePions', 'TagAndProbeMuons', 'LongAssocMuons', 'TagMuonTTMuons', 'TagVeloMuons', 'TagDownstreamMuons', 'Hlt2ProbeVeloPions', 'Hlt2ProbeVeloKaons', 'Hlt2GoodProbeVeloPions', 'Hlt2GoodProbeVeloKaons') Hlt2ProbeVeloPions = bindMembers( None, [FittedVelo, Hlt2VeloProtos, Hlt2VeloPionParts]) Hlt2ProbeVeloKaons = bindMembers( None, [FittedVelo, Hlt2VeloProtos, Hlt2VeloKaonParts]) Hlt2GoodProbeVeloPions = bindMembers( 'Good', [FittedVelo, Hlt2VeloProtos, Hlt2ProbeVeloPions, Hlt2GoodVeloPions]) Hlt2GoodProbeVeloKaons = bindMembers( 'Good', [FittedVelo, Hlt2VeloProtos, Hlt2ProbeVeloKaons, Hlt2GoodVeloKaons]) TagAndProbePions = bindMembers(None, [caloProtos, Hlt2TagAndProbePions]) TagAndProbeMuons = bindMembers(None, [muonWithCaloProtos, Hlt2TagAndProbeMuons]) LongAssocMuons = bindMembers(None, [muonWithCaloProtos, Hlt2LongAssocParts]) ProbeMuonTTMuons = bindMembers(None, [muonTTProtos, Hlt2MuonTTParts]) ProbeVeloMuons = bindMembers(None, [velomuonProtos, Hlt2VeloMuonParts])
def PV3D(where): """ PV3D(where) -- where must either by Hlt1 or Hlt2 """ #from HltTrackNames import HltSharedRZVeloTracksName, HltSharedTracksPrefix, _baseTrackLocation from HltVertexNames import HltSharedVerticesPrefix from HltVertexNames import HltGlobalVertexLocation from Configurables import PatPV3D from Configurables import PVOfflineTool, LSAdaptPV3DFitter from Configurables import SimplifiedMaterialLocator, TrackMasterExtrapolator if where.upper() not in ['HLT1', 'HLT2']: raise KeyError('PV3D: where must be either HLT1 or HLT2') #TODO: Move these options to HltRecoConf output3DVertices = _vertexLocation(HltSharedVerticesPrefix, HltGlobalVertexLocation, PV3DSelection) recoPV3D = PatPV3D('HltPVsPV3D') recoPV3D.addTool(PVOfflineTool, "PVOfflineTool") recoPV3D.PVOfflineTool.PVSeedingName = "PVSeed3DTool" recoPV3D.PVOfflineTool.PVFitterName = "LSAdaptPV3DFitter" recoPV3D.PVOfflineTool.addTool(LSAdaptPV3DFitter, "LSAdaptPV3DFitter") offlineTool = recoPV3D.PVOfflineTool fitter = recoPV3D.PVOfflineTool.LSAdaptPV3DFitter # Set options from HltRecoConf from Configurables import HltRecoConf for opt, value in HltRecoConf().getProp("PVOptions").iteritems(): found = False for tool in (fitter, offlineTool): if opt in tool.getProperties(): tool.setProp(opt, value) found = True if not found: raise AttributeError("HltPVs.py: no tool has property %s" % opt) ## Simplified Material for TrackMasterExtrapolator recoPV3D.PVOfflineTool.LSAdaptPV3DFitter.addTool( TrackMasterExtrapolator, "TrackMasterExtrapolator") recoPV3D.PVOfflineTool.LSAdaptPV3DFitter.TrackMasterExtrapolator.addTool( SimplifiedMaterialLocator, name="MaterialLocator") ## Simplified Material for Recalculate. Not used, but let's not load from Configurables import PVOfflineRecalculate recoPV3D.PVOfflineTool.addTool(PVOfflineRecalculate, "PVOfflineRecalculate") recoPV3D.PVOfflineTool.PVOfflineRecalculate.addTool( TrackMasterExtrapolator, "TrackMasterExtrapolator") recoPV3D.PVOfflineTool.PVOfflineRecalculate.TrackMasterExtrapolator.addTool( SimplifiedMaterialLocator, name="MaterialLocator") if HltRecoConf().getProp("FitVelo"): recoPV3D.PVOfflineTool.LSAdaptPV3DFitter.UseFittedTracks = True #recoPV3D.PVOfflineTool.LSAdaptPV3DFitter.zVtxShift = 0.0 recoPV3D.OutputVerticesName = output3DVertices from HltSharedTracking import FittedVelo, RevivedVelo velo = FittedVelo if HltRecoConf().getProp("FitVelo") else RevivedVelo pv3dAlgos = ','.join( ["'%s'" % m.getFullName() for m in velo.members() + [recoPV3D]]) recoPV3D.PVOfflineTool.InputTracks = [velo.outputSelection()] from Configurables import LoKi__HltUnit as HltUnit ## Hlt vertex beamspot filter ##-- todo: can we integrate this in the main streamers directly, using 'tee' ? ## TODO: Make this a configurable. name = "HltPV3D" makePV3DSel = HltUnit(name, Preambulo=[ 'from LoKiPhys.decorators import *', 'from LoKiTrigger.decorators import *', 'from LoKiHlt.algorithms import *' ], Code=""" execute( %(algo)s ) * VSOURCE( '%(tesInput)s' ) >> VX_SINK( '%(hltFinal)s' ) >> ~VEMPTY """ % { 'algo': pv3dAlgos, 'tesInput': recoPV3D.OutputVerticesName, 'hltFinal': PV3DSelection }) pv3d = bindMembers(name + 'Sequence', [makePV3DSel]).setOutputSelection(PV3DSelection) pv3d.output = output3DVertices return pv3d
Hlt2SharedRhoPlus2PiPi0.VertexFitters.update({"": "ParticleAdder"}) Hlt2SharedRhoPlus2PiPi0.Output = 'Hlt2/Hlt2SharedRhoPlus2PiPi0/Particles' Hlt2SharedRhoPlus2PiPi0.Inputs = [GoodPions.outputSelection() ] + AllPi0s.outputSelection() Hlt2SharedRhoPlus2PiPi0.DecayDescriptor = "[rho(770)- -> pi- pi0]cc" Hlt2SharedRhoPlus2PiPi0.DaughtersCuts = { "pi+": "ALL", "pi0": "(PT>1000*MeV) & (P> 1500*MeV)" } #Note #The cut of 550 MeV around the K*(892)+ is NOT a typo, is motivated #by the requirements of the B2DVec HLT2 selection Hlt2SharedRhoPlus2PiPi0.CombinationCut = "(ADAMASS('K*(892)+')<550*MeV)" Hlt2SharedRhoPlus2PiPi0.MotherCut = "ALL" RhoPlus2PiPi0 = bindMembers(None, [GoodPions, AllPi0s, Hlt2SharedRhoPlus2PiPi0]) #-------------------------------------------------------------------- #rho(770) -> K pi0 is a clone of rho(770) -> pi pi0 Hlt2SharedRhoPlus2KPi0 = Hlt2SharedRhoPlus2PiPi0.clone( "Hlt2SharedRhoPlus2KPi0") Hlt2SharedRhoPlus2KPi0.DecayDescriptor = "[rho(770)- -> K- pi0]cc" Hlt2SharedRhoPlus2KPi0.Output = 'Hlt2/Hlt2SharedRhoPlus2KPi0/Particles' Hlt2SharedRhoPlus2KPi0.Inputs = [GoodKaons.outputSelection() ] + AllPi0s.outputSelection() Hlt2SharedRhoPlus2KPi0.DaughtersCuts.update({"K+": "ALL"}) Hlt2SharedRhoPlus2KPi0.DaughtersCuts.pop('pi+') # @todo How do I best get Merged and Resolved in here ? RhoPlus2KPi0 = bindMembers(None, [GoodKaons, AllPi0s, Hlt2SharedRhoPlus2KPi0])
from Gaudi.Configuration import * from Configurables import FilterDesktop, BremAdder, DiElectronMaker from Hlt2SharedParticles.TrackFittedBasicParticles import BiKalmanFittedElectrons, BiKalmanFittedPhotons from HltLine.HltLine import bindMembers, Hlt1Tool, Hlt2Member from HltTracking.HltPVs import PV3D Electrons = Hlt2Member( FilterDesktop, "Electrons", Inputs=[BiKalmanFittedElectrons], Code= "(MIPDV(PRIMARY) > 0.4 * mm) & (MIPCHI2DV(PRIMARY) > 5) & (TRGHOSTPROB < 0.15) & (PT > 80 * MeV)" ) SoftElectrons = bindMembers('Soft', [PV3D('Hlt2'), BiKalmanFittedElectrons, Electrons]) BA = Hlt1Tool(type=BremAdder, name='BremAdder', BremInput="Hlt2/Hlt2BiKalmanFittedPhotons/Particles") Hlt2SharedTrackFittedDetachedDiElectron = Hlt2Member( DiElectronMaker, "TrackFittedDetachedDiElectron", ElectronInputs=[SoftElectrons.outputSelection()], Particle='KS0', DecayDescriptor="KS0 -> e+ e-", ElectronPtMin=80, DiElectronPtMin=200, DiElectronMassMax=1000, tools=[BA])
from Gaudi.Configuration import * import Configurables from GaudiKernel.ConfigurableDb import cfgDb, loadConfigurableDb import sys, traceback ##### Setup Configurable for tracking... ##### from Configurables import Hlt2Tracking, GaudiSequencer import HltTracking.Hlt2TrackingConfigurations for att in dir(HltTracking.Hlt2TrackingConfigurations): if "Hlt2BiKalmanFitted" in att: iatt=getattr(HltTracking.Hlt2TrackingConfigurations,att)() for s in iatt.__slots__: if "Seq" in s: from HltLine.HltLine import bindMembers al=bindMembers(s+"dummy",[]).setOutputSelection('DummySelectionName') setattr(iatt,s,al) # #for s in Hlt2Tracking.__slots__: # if "Seq" in s: # setattr(Hlt2Tracking(),s,GaudiSequencer(s+"dummy")) ##### load all configurables of this package ##### loadConfigurableDb() for name,conf in cfgDb.iteritems(): if conf['package']=='Hlt2SharedParticles': if hasattr(Configurables,name): try:
########################################################################## # Prepare the Kaons -- pt cuts # Kaons = Hlt2Member(FilterDesktop, "Kaons", Inputs=[BiKalmanFittedKaons], Code="(PT > 300.*MeV) & (P>2*GeV) & (MIPCHI2DV(PRIMARY)>9)") ########################################################################## # Prepare the Pions -- pt cuts # Pions = Hlt2Member(FilterDesktop, "Pions", Inputs=[BiKalmanFittedPions], Code="(PT > 300.*MeV) & (P>2*GeV) & (MIPCHI2DV(PRIMARY)>9)") ########################################################################## GoodKaons = bindMembers('Good', [PV3D('Hlt2'), BiKalmanFittedKaons, Kaons]) GoodPions = bindMembers('Good', [PV3D('Hlt2'), BiKalmanFittedPions, Pions]) ################################################################################# # END OF OBSOLETE BLOCK ################################################################################# # NEW GOOD PARTICLES BLOK # DEFINE SOME GENERALLY SENSIBLE THRESHOLDS, EACH FOLLOWS THE PREVIOUS ################################################################################# ''' ParticlesToBuild = {"NoPIDsKaons" : {"Inputs" : [BiKalmanFittedKaons], "ValidPID" : []}, "NoPIDsPions" : {"Inputs" : [BiKalmanFittedPions], "ValidPID" : []}, "NoPIDsProtons" : {"Inputs" : [BiKalmanFittedProtons], "ValidPID" : []} "Kaons" : {"Inputs" : [BiKalmanFittedRichKaons], "ValidPID" : ["K"]}, "Pions" : {"Inputs" : [BiKalmanFittedRichPions], "ValidPID" : ["Pi"]}, "Protons" : {"Inputs" : [BiKalmanFittedRichProtons], "ValidPID" : ["p","pK"]}}
def __hlt2MuonTTTracking(self): """ MuonTT track reconstruction for Hlt2 """ from Configurables import Hlt2Conf from Configurables import MuonTTTrack, TrackMasterFitter, PatAddTTCoord, MuonCombRec, MuonHitDecode, TrackMasterExtrapolator from Configurables import MeasurementProviderT_MeasurementProviderTypes__TTLite_, StateThickMSCorrectionTool from HltLine.HltLine import bindMembers from Configurables import HltRecoConf from HltRecoConf import CommonForwardTrackingOptions, MuonTTOptions from HltTracking.HltPVs import PV3D # from Hlt1Lines.HltConfigurePR import ConfiguredPR pvreco = PV3D('Hlt2') Hlt2MuonTTTrack = MuonTTTrack("Hlt2MuonTTTrack") Hlt2MuonTTTrack.AddTTHits = True Hlt2MuonTTTrack.FillMuonStubInfo = False Hlt2MuonTTTrack.ToolName = "MuonCombRec" Hlt2MuonTTTrack.OutputLevel = 6 Hlt2MuonTTTrack.MC = False Hlt2MuonTTTrack.PVLocation = pvreco.output Hlt2MuonTTTrack.addTool(MuonCombRec) Hlt2MuonTTTrack.MuonCombRec.ClusterTool = "MuonFakeClustering" Hlt2MuonTTTrack.MuonCombRec.CloneKiller = False Hlt2MuonTTTrack.MuonCombRec.StrongCloneKiller = False Hlt2MuonTTTrack.MuonCombRec.SeedStation = MuonTTOptions["SeedStation"] Hlt2MuonTTTrack.MuonCombRec.DecodingTool = "MuonHitDecode" Hlt2MuonTTTrack.MuonCombRec.PadRecTool = "MuonPadRec" Hlt2MuonTTTrack.MuonCombRec.AssumePhysics = True Hlt2MuonTTTrack.MuonCombRec.MeasureTime = True Hlt2MuonTTTrack.MuonCombRec.addTool(MuonHitDecode("MuonHitDecode")) Hlt2MuonTTTrack.MuonCombRec.MuonHitDecode.SkipHWNumber = True Hlt2MuonTTTrack.addTool(PatAddTTCoord) Hlt2MuonTTTrack.PatAddTTCoord.YTolSlope = MuonTTOptions["YTolSlope"] Hlt2MuonTTTrack.PatAddTTCoord.XTol = MuonTTOptions["XTol"] Hlt2MuonTTTrack.PatAddTTCoord.XTolSlope = MuonTTOptions["XTolSlope"] Hlt2MuonTTTrack.PatAddTTCoord.MaxChi2Tol = MuonTTOptions["MaxChi2Tol"] Hlt2MuonTTTrack.PatAddTTCoord.MinAxProj = MuonTTOptions["MinAxProj"] Hlt2MuonTTTrack.PatAddTTCoord.MajAxProj = MuonTTOptions["MaxAxProj"] Hlt2MuonTTTrack.addTool(TrackMasterFitter) from TrackFitter.ConfiguredFitters import ConfiguredHltFitter, ConfiguredMasterFitter from Configurables import HltRecoConf, SimplifiedMaterialLocator ConfiguredMasterFitter(Hlt2MuonTTTrack.TrackMasterFitter, SimplifiedGeometry=True, LiteClusters=True, MSRossiAndGreisen=HltRecoConf().getProp( "NewMSinFit")) #on par with Hlt track fits Hlt2MuonTTTrack.TrackMasterFitter.OutputLevel = 5 Hlt2MuonTTTrack.addTool(TrackMasterExtrapolator) Hlt2MuonTTTrack.TrackMasterExtrapolator.MaterialLocator = "SimplifiedMaterialLocator" Hlt2MuonTTTrack.addTool(TrackMasterExtrapolator) Hlt2MuonTTTrack.TrackMasterExtrapolator.addTool( SimplifiedMaterialLocator, name="MaterialLocator") materialLocator = Hlt2MuonTTTrack.TrackMasterExtrapolator.MaterialLocator materialLocator.addTool(StateThickMSCorrectionTool, name="StateMSCorrectionTool") materialLocator.StateMSCorrectionTool.UseRossiAndGreisen = HltRecoConf( ).getProp("NewMSinFit") Hlt2MuonTTTrack.Output = Hlt2TrackEffLoc["MuonTT"] # Build the bindMembers bm_name = self.getProp("Prefix") + "MuonTTTracking" bm_members = [pvreco, Hlt2MuonTTTrack] bm_output = Hlt2MuonTTTrack.Output return bindMembers(bm_name, bm_members).setOutputSelection(bm_output)
outputLocation = OutputLocation) from Configurables import LoKi__Hybrid__TrackSelector as LoKiTrackSelector filterTracks.addTool(LoKiTrackSelector,name="LokiTracksSelector") filterTracks.Selector = LoKiTrackSelector(name="LokiTracksSelector") filterTracks.Selector.Code = "(~TrINVALID) & ( TrCHI2PDOF < %(TrChi2)s )" % {"TrChi2": HltRecoConf().getProp("GoodTrCHI2PDOF")} filterTracks.Selector.StatPrint = True return filterTracks ############################################################################################# # Define modules for the reconstruction sequence ############################################################################################# from HltLine.HltDecodeRaw import DecodeVELO, DecodeTRACK, DecodeTT, DecodeIT ### define exported symbols (i.e. these are externally visible, the rest is NOT) #This is the part which is shared between Hlt1 and Hlt2 MinimalVelo = bindMembers( None, [DecodeVELO, recoVelo( OutputTracksName=HltSharedTrackLoc["Velo"] ) ] ).setOutputSelection( HltSharedTrackLoc["Velo"] ) # We have to remove the decoder from the sequence if disabled otherwise the PV unit complains and does not run. veloAlgs = [DecodeTRACK, DecodeVELO, recoVelo( OutputTracksName=HltSharedTrackLoc["Velo"] )] if HltRecoConf().getProp('Hlt1TrackOption') == "Rerun": veloAlgs.remove(DecodeTRACK) RevivedVelo = bindMembers( None, veloAlgs ).setOutputSelection( HltSharedTrackLoc["Velo"] ) FittedVelo = bindMembers( None, RevivedVelo.members() + fittedVelo(RevivedVelo.outputSelection(), Hlt1TrackLoc["FittedVelo"])).setOutputSelection(Hlt1TrackLoc["FittedVelo"]) # TODO: put selection revive/redo here (ask Sebastian) # for now always redo: bm_members = DecodeVELO.members() + [recoVelo(), filterVelo ] bm_members += DecodeTT.members() + [recoVeloTT] bm_members += DecodeIT.members() + [recoForwardHPT] HltHPTTracking = bindMembers(None, bm_members).setOutputSelection( recoForwardHPT.OutputTracksName )
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)
"p+": "(TRCHI2DOF<4)& (MIPCHI2DV(PRIMARY)>36)" }, CombinationCut="(ADAMASS('Lambda0')<50*MeV)", MotherCut= "(ADMASS('Lambda0')<20*MeV) & (VFASPF(VCHI2PDOF)<30) & (BPVLTIME() > 2.0*ps) ", Inputs=[BiKalmanFittedPions, BiKalmanFittedProtons]) ################################################## # Standard Lambda: Fitted Downstream Tracks Hlt2SharedLambdaDDTrackFitted = Hlt2Member( CombineParticles, "LambdaDDTrackFitted", DecayDescriptor="[Lambda0 -> p+ pi-]cc", DaughtersCuts={ "pi+": "(TRCHI2DOF<4)& (P>3000*MeV) & (PT>175.*MeV)", "p+": "(TRCHI2DOF<4)& (P>3000*MeV) & (PT>175.*MeV)" }, CombinationCut="(ADAMASS('Lambda0')<80*MeV)", MotherCut= "(ADMASS('Lambda0')<64*MeV)& (VFASPF(VCHI2PDOF)<30)& (BPVVDZ > 400.0*mm)", Inputs=[BiKalmanFittedDownPions, BiKalmanFittedDownProtons]) LambdaLLTrackFitted = bindMembers("Shared", [ PV3D('Hlt2'), BiKalmanFittedPions, BiKalmanFittedProtons, Hlt2SharedLambdaLLTrackFitted ]) LambdaDDTrackFitted = bindMembers("Shared", [ PV3D('Hlt2'), BiKalmanFittedDownPions, BiKalmanFittedDownProtons, Hlt2SharedLambdaDDTrackFitted ])
from Gaudi.Configuration import * from Configurables import CombineParticles from Hlt2SharedParticles.TrackFittedBasicParticles import BiKalmanFittedElectrons, BiKalmanFittedElectronsFromL0 from HltLine.HltLine import bindMembers, Hlt2Member __all__ = ('TrackFittedDiElectron', 'TrackFittedDiElectronFromL0') Hlt2SharedTrackFittedDiElectron = Hlt2Member( CombineParticles, "TrackFittedDiElectron", Inputs=[BiKalmanFittedElectrons], DecayDescriptor="J/psi(1S) -> e+ e-", DaughtersCuts={"e+": "(PT>1000*MeV)"}, CombinationCut="AALL", MotherCut="(VFASPF(VCHI2PDOF)<25)") Hlt2SharedTrackFittedDiElectronFromL0 = Hlt2Member( CombineParticles, "TrackFittedDiElectronFromL0", Inputs=[BiKalmanFittedElectronsFromL0], DecayDescriptor="J/psi(1S) -> e+ e-", DaughtersCuts={"e+": "(PT>1000*MeV)"}, CombinationCut="AALL", MotherCut="(VFASPF(VCHI2PDOF)<25)") TrackFittedDiElectron = bindMembers( "Shared", [BiKalmanFittedElectrons, Hlt2SharedTrackFittedDiElectron]) TrackFittedDiElectronFromL0 = bindMembers( "SharedFromL0", [BiKalmanFittedElectronsFromL0, Hlt2SharedTrackFittedDiElectronFromL0])
### @file # # Standard rho(770)0 # ## from Gaudi.Configuration import * from Configurables import CombineParticles from HltLine.HltLine import bindMembers from Hlt2SharedParticles.GoodParticles import GoodPions __all__ = ('Rho0') Hlt2SharedRho0 = CombineParticles("Hlt2SharedRho0") Hlt2SharedRho0.Output = 'Hlt2/Hlt2SharedRho0/Particles' Hlt2SharedRho0.Inputs = [GoodPions.outputSelection()] Hlt2SharedRho0.DecayDescriptor = "[rho(770)0 -> pi+ pi-]cc" Hlt2SharedRho0.DaughtersCuts = {"pi+": "TRUE", "pi-": "TRUE"} Hlt2SharedRho0.CombinationCut = "(ADAMASS('rho(770)0')<100*MeV)" Hlt2SharedRho0.MotherCut = "(BPVVDZ>0) & (VFASPF(VCHI2PDOF)<9) & (BPVDIRA>0.95) & (BPVVDCHI2>25)" Rho0 = bindMembers(None, [GoodPions, Hlt2SharedRho0])
def vertexDisplVertex_streamer(self, properties): from Hlt1Lines.Hlt1GECs import Hlt1GECUnit from HltTracking.HltPVs import PV3D from Configurables import LoKi__HltUnit as HltUnit from HltLine.HltLine import bindMembers algos = [] gec = properties["GEC"] algos.append(Hlt1GECUnit(properties["GEC"])) algos.append(PV3D('Hlt1')) trackUnit = HltUnit( "Hlt1%(name)sTrackStreamer" % properties, Preambulo=self.vertexDisplVertex_trackPreambulo(properties), Code=""" VeloCandidates >> tee ( monitor( TC_SIZE>0, '# events pass Velo candidates', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , '# candidates pass Velo candidates', LoKi.Monitoring.ContextSvc ) ) >> ( ( TrNCONSECVELOSPACEPOINTS > %(VELO_NCSP)s ) & ( TrNVELOSPACEPOINTS > %(VELO_NSP)s ) ) >> tee ( monitor( TC_SIZE>0, '# events pass Velo spacepoints cuts', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , '# candidates pass Velo spacepoints cuts', LoKi.Monitoring.ContextSvc ) ) >> ( Tr_FASTDOCATOBEAMLINE(5.) > %(DOCABL)s ) >> tee ( monitor( TC_SIZE>0, '# events pass DOCABL cut', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , '# candidates pass DOCABL cut', LoKi.Monitoring.ContextSvc ) ) >> SINK( 'Hlt1%(name)sTracks' ) >> ~TC_EMPTY """ % properties) algos.append(trackUnit) if "TracksForVx" in properties: combinatoricsGECUnit = HltUnit("Hlt1%(name)sCombinatoricsCut" % properties, Code=""" SELECTION('Hlt1%(name)sTracks') >> monitor( TC_SIZE , Gaudi.Histo1DDef('# tracks for vertexing', 0., 100., 100 ), 'hNTracksForVertexing%(name)s' ) < %(TracksForVx)s """ % properties) algos.append(combinatoricsGECUnit) vertexUnit = HltUnit( "Hlt1%(name)sStreamer" % properties, Preambulo=self.vertexDisplVertex_vertexPreambulo(properties), Code=""" SELECTION ( 'Hlt1%(name)sTracks' ) >> MakeDisplVertices >> tee ( monitor( TC_SIZE>0, '# events pass displaced vertex making', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , '# candidates pass displaced vertex making', LoKi.Monitoring.ContextSvc ) ) >> ( VX_BEAMSPOTRHO(5.) > %(VX_RHO)s ) >> tee ( monitor( TC_SIZE>0, '# events pass RHO cut', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , '# candidates pass RHO cut', LoKi.Monitoring.ContextSvc ) ) >> LooseForward >> tee ( monitor( TC_SIZE>0, '# events pass forward', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , '# candidates pass forward', LoKi.Monitoring.ContextSvc ) ) >> HLT_TCASRVC_ANY( ( TrPT > %(Tr_PT)s ) & ( TrP > %(Tr_P)s), True ) >> tee ( monitor( TC_SIZE>0, '# events pass P, PT cut', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , '# candidates pass P, PT cut', LoKi.Monitoring.ContextSvc ) ) >> FitTracks >> tee ( monitor( TC_SIZE>0, '# events pass track fit', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , '# candidates pass track fit', LoKi.Monitoring.ContextSvc ) ) >> HLT_TCASRVC_ANY( ( TrCHI2PDOF < %(Tr_CHI2)s ), True ) >> tee ( monitor( TC_SIZE>0, '# events pass track CHI2 cut', LoKi.Monitoring.ContextSvc ) ) >> tee ( monitor( TC_SIZE , '# candidates pass track CHI2', LoKi.Monitoring.ContextSvc ) ) >> SINK( 'Hlt1%(name)sDecision' ) >> ~TC_EMPTY """ % properties) algos.append(vertexUnit) return bindMembers("Hlt1%(name)sAlgos" % properties, algos).setOutputSelection("Hlt1%(name)sDecision")
### @file # # Standard Track Fitted Di-muon # # @author P. Koppenburg [email protected] # @date 2008-07-15 # ## from Gaudi.Configuration import * from Hlt2SharedParticles.TrackFittedBasicParticles import BiKalmanFittedMuons from Configurables import CombineParticles, FilterDesktop from HltLine.HltLine import bindMembers, Hlt2Member __all__ = ('TrackFittedDiMuon') Hlt2SharedTrackFittedDiMuon = Hlt2Member( CombineParticles, "TrackFittedDiMuon", DecayDescriptor="J/psi(1S) -> mu+ mu-", CombinationCut="AALL", MotherCut="(VFASPF(VCHI2PDOF)<25)", Inputs=[BiKalmanFittedMuons], WriteP2PVRelations=False) TrackFittedDiMuon = bindMembers( "Shared", [BiKalmanFittedMuons, Hlt2SharedTrackFittedDiMuon])
from Hlt2SharedParticles.GoodParticles import GoodKaons, GoodPions from Hlt2SharedParticles.TrackFittedBasicParticles import BiKalmanFittedKaons, BiKalmanFittedPions from Hlt2SharedParticles.TrackFittedBasicParticles import BiKalmanFittedRichKaons from HltLine.HltLine import bindMembers, Hlt2Member __all__ = ( 'Kstar2KPi' , 'TightKstar2KPi' ) Hlt2SharedKstar2KPi = CombineParticles("Hlt2SharedKstar2KPi") Hlt2SharedKstar2KPi.Inputs = [ BiKalmanFittedKaons.outputSelection(), BiKalmanFittedPions.outputSelection() ] Hlt2SharedKstar2KPi.Output = 'Hlt2/Hlt2SharedKstar2KPi/Particles' Hlt2SharedKstar2KPi.DecayDescriptor = "[K*(892)0 -> K+ pi-]cc" Hlt2SharedKstar2KPi.DaughtersCuts = { "pi+" : "ALL", "K+" : "ALL" } Hlt2SharedKstar2KPi.CombinationCut = "(ADAMASS('K*(892)0')<300)" Hlt2SharedKstar2KPi.MotherCut = "(VFASPF(VCHI2PDOF)<25)" Kstar2KPi = bindMembers( None, [ BiKalmanFittedKaons, BiKalmanFittedPions, Hlt2SharedKstar2KPi ] ) # Tight K* with PID Hlt2SharedTightKstar2KPi = Hlt2Member( CombineParticles , "Hlt2SharedKstar2KPi" , Inputs = [ BiKalmanFittedRichKaons, BiKalmanFittedPions ] , DecayDescriptor = "[K*(892)0 -> K+ pi-]cc" , DaughtersCuts = { "pi+" : "(PT > 500*MeV)", "K+" : "(PT > 500*MeV) & (PIDK>0.)" } , CombinationCut = "(ADAMASS('K*(892)0')<100)" , MotherCut = "(VFASPF(VCHI2PDOF)<25)" ) TightKstar2KPi = bindMembers( 'Shared', [ BiKalmanFittedRichKaons, BiKalmanFittedPions, Hlt2SharedTightKstar2KPi ] )