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 ] )
