HighQ2MuonsOnDemand = DataOnDemand(Location = "/Event/Dimuon/Phys/B2XMuMuIncl_InclDiMuHighQ2Line/Particles")
bothstripping = MergedSelection("Selection_mergeddaughters",
RequiredSelections = [LowQ2MuonsOnDemand,HighQ2MuonsOnDemand])
_filterDimuons = FilterDesktop(Code="ABSID==511") # Dimuons from B0--> mu mu stripping selection
_selDimuons= Selection( "_selDimuons", Algorithm = _filterDimuons, RequiredSelections = [bothstripping] )
from Configurables import SubstitutePID
subalg = SubstitutePID("_B2Jpsi_SubPID", Code="(DECTREE('B0 -> mu+ mu-'))",
Substitutions={'B0 -> mu+ mu-' : 'J/psi(1S)'}, MaxChi2PerDoF=-666)
subsel = Selection("subsel",Algorithm = subalg, RequiredSelections = [_selDimuons])
# Try and make B->J/psi K
_B = CombineParticles()
_B.DaughtersCuts = { "K+" : "(PT>500*MeV)&(MIPCHI2DV(PRIMARY) > 9)" }
_B.MotherCut = "(DMASS('B+')<5000*MeV) & (VFASPF(VCHI2)/VFASPF(VDOF)<5.0) & (BPVDIRA > 0.999)" #need to check these cuts
_B.DecayDescriptors = [ "[B+ -> J/psi(1S) K+]cc" ]
_BdecaySelection = Selection( "TurboB", Algorithm = _B, RequiredSelections = [subsel,kaons] )
SeqB = SelectionSequence('SeqB', TopSelection = _BdecaySelection)
# Here we just put the output candidates in an Tuple
tupleB = DecayTreeTuple("bae-muon-data")
tupleB.Inputs = [SeqB.outputLocation()]
tupleB.Decay = "[B+ -> ^K+ ^(J/psi(1S) -> ^mu+ ^mu-)]CC"
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self.__confdict__ = config
self.GECs = {
"Code":
"( recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %(GEC_nLongTrk)s )"
% config,
"Preambulo": ["from LoKiTracks.decorators import *"]
}
#== selection of standard particles
self.Kaon1Cuts = "(TRCHI2DOF < 3) & (TRGHOSTPROB < 0.5) & (PT > %(K1PT)s *MeV) &"\
"(MIPCHI2DV(PRIMARY) < %(K1MinIPChi2)s) & "\
"(PIDK-PIDpi > %(K1PIDK)s) & (PIDK-PIDp > 0) & (PIDK-PIDmu > 0)" %config
self.Kaon1CutsLoose = "(TRCHI2DOF < 3) & (TRGHOSTPROB < 0.5) & (PT > %(K1PTLoose)s *MeV) &"\
"(MIPCHI2DV(PRIMARY) < %(K1MinIPChi2)s) & "\
"(PIDK-PIDpi > %(K1PIDK)s) & (PIDK-PIDp > 0) & (PIDK-PIDmu > 0)" %config
self.Kaon2Cuts = "(TRCHI2DOF < 3) & (TRGHOSTPROB < 0.5) & "\
"(P > %(K2P)s *MeV) & (PT > %(K2PT)s *MeV) & "\
"(MIPCHI2DV(PRIMARY) > %(K2MinIPChi2)s) & "\
"(PIDK-PIDpi > %(K2PIDK)s) & (PIDK-PIDp > 0) & (PIDK-PIDmu > 0)" %config
self.MuonCuts = "(TRCHI2DOF < 3) & (TRGHOSTPROB < 0.5) & "\
"(P > %(MuP)s *MeV) & (PT > %(MuPT)s *MeV) & "\
"(MIPCHI2DV(PRIMARY) > %(MuMinIPChi2)s) & "\
"(PIDmu-PIDK > 0) & (PIDmu-PIDp > 0) & (PIDmu-PIDpi > %(MuPIDmu)s)" %config
self.JpsiCuts = "(PFUNA(ADAMASS('J/psi(1S)')) < %(JpsiMassWindow)s * MeV)" % config
self.SelKaon1 = Selection("K1_for" + name,
Algorithm=FilterDesktop(Code=self.Kaon1Cuts),
RequiredSelections=[StdAllLooseKaons])
self.SelKaon1Loose = Selection(
"K1Loose_for" + name,
Algorithm=FilterDesktop(Code=self.Kaon1CutsLoose),
RequiredSelections=[StdAllLooseKaons])
self.SelKaon2 = Selection("K2_for" + name,
Algorithm=FilterDesktop(Code=self.Kaon2Cuts),
RequiredSelections=[StdLooseKaons])
self.SelMuon = Selection("Mu_for" + name,
Algorithm=FilterDesktop(Code=self.MuonCuts),
RequiredSelections=[StdLooseMuons])
self.SelJpsi = Selection(
"Jpsi_for" + name,
Algorithm=FilterDesktop(Code=self.JpsiCuts),
RequiredSelections=[StdMassConstrainedJpsi2MuMu])
# B -> K Mu X, both opposite & same signed K mu can be signals
self.Bu2KMu = CombineParticles(
DecayDescriptors=["[B+ -> K+ mu-]cc", "[B+ -> K+ mu+]cc"])
self.Bu2KMu.CombinationCut = "(AM > %(KMuMassMin)s*MeV) & (AM < %(KMuMassMax)s*MeV)" % config
self.Bu2KMu.MotherCut = "(VFASPF(VCHI2/VDOF) < %(KMuVChi2Dof)s) & (BPVDIRA > 0.99) & "\
"(BPVVDCHI2 > %(KMuFdChi2)s)" % config
self.Bu2KMu.ReFitPVs = True
self.SelBu2KMu = Selection(
"Bu2KMu_for" + name,
Algorithm=self.Bu2KMu,
RequiredSelections=[self.SelKaon2, self.SelMuon])
# B -> K J/psi
self.Bu2KJpsi = CombineParticles(
DecayDescriptors=["[B+ -> J/psi(1S) K+]cc"])
self.Bu2KJpsi.CombinationCut = "(AM > %(KJpsiMassMin)s*MeV) & (AM < %(KJpsiMassMax)s*MeV)" % config
self.Bu2KJpsi.MotherCut = "(VFASPF(VCHI2/VDOF) < %(KJpsiVChi2Dof)s) & (BPVDIRA > 0.99) & "\
"(BPVVDCHI2 > %(KJpsiFdChi2)s)" % config
self.Bu2KJpsi.ReFitPVs = True
self.SelBu2KJpsi = Selection(
"Bu2KJpsi_for" + name,
Algorithm=self.Bu2KJpsi,
RequiredSelections=[self.SelKaon2, self.SelJpsi])
# B_s2*0 -> (B -> K Mu X) K, signal KK have opposite signed charge.
self.Bs2KKMu = CombineParticles(DecayDescriptor="[B*_s20 -> B+ K-]cc")
self.Bs2KKMu.CombinationCut = "(AM-AM1 < %(DMKKMu)s*MeV) & "\
"(abs(ACHILD(BPV(VZ),1)-ACHILD(BPV(VZ),2))<%(DZBPV)s*mm)" % config
self.Bs2KKMu.MotherCut = "(PT > %(Bs2PT)s*MeV)" % config
self.Bs2KKMu.ReFitPVs = False
self.SelBs2KKMu = Selection(
"Bs2KKMu_for" + name,
Algorithm=self.Bs2KKMu,
RequiredSelections=[self.SelBu2KMu, self.SelKaon1])
# B_s2*0 -> (B -> K Mu X) K, same signed KK for back ground
self.Bs2KKMuWS = CombineParticles(
DecayDescriptor="[B*_s20 -> B+ K+]cc")
self.Bs2KKMuWS.CombinationCut = self.Bs2KKMu.CombinationCut
self.Bs2KKMuWS.MotherCut = self.Bs2KKMu.MotherCut
self.Bs2KKMuWS.ReFitPVs = self.Bs2KKMu.ReFitPVs
self.SelBs2KKMuWS = Selection(
"Bs2KKMuWS_for" + name,
Algorithm=self.Bs2KKMuWS,
RequiredSelections=[self.SelBu2KMu, self.SelKaon1])
# B_s2*0 -> (B -> K Jpsi) K, signal KK have opposite signed charge.
self.Bs2KKJpsi = CombineParticles(
DecayDescriptor="[B*_s20 -> B+ K-]cc")
self.Bs2KKJpsi.CombinationCut = "(AM-AM1 < %(DMKKJpsi)s*MeV) & "\
"(abs(ACHILD(BPV(VZ),1)-ACHILD(BPV(VZ),2))<%(DZBPV)s*mm)" % config
self.Bs2KKJpsi.MotherCut = "(PT > %(Bs2PT)s*MeV)" % config
self.Bs2KKJpsi.ReFitPVs = False
self.SelBs2KKJpsi = Selection(
"Bs2KKJpsi_for" + name,
Algorithm=self.Bs2KKJpsi,
RequiredSelections=[self.SelBu2KJpsi, self.SelKaon1Loose])
# B_s2*0 -> (B -> K Jpsi) K, same signed KK for back ground
self.Bs2KKJpsiWS = CombineParticles(
DecayDescriptor="[B*_s20 -> B+ K+]cc")
self.Bs2KKJpsiWS.CombinationCut = self.Bs2KKJpsi.CombinationCut
self.Bs2KKJpsiWS.MotherCut = self.Bs2KKJpsi.MotherCut
self.Bs2KKJpsiWS.ReFitPVs = self.Bs2KKJpsi.ReFitPVs
self.SelBs2KKJpsiWS = Selection(
"Bs2KKJpsiWS_for" + name,
Algorithm=self.Bs2KKJpsiWS,
RequiredSelections=[self.SelBu2KJpsi, self.SelKaon1Loose])
# register stripping lines
self.Bs2st2KKMuLine = StrippingLine(
"Bs2st2KKMuLine",
prescale=config['Bs2st2KKMuPrescale'],
FILTER=self.GECs,
RelatedInfoTools=config['RelatedInfoTools'],
selection=self.SelBs2KKMu
#, MDSTFlag = True
)
self.Bs2st2KKMuWSLine = StrippingLine(
"Bs2st2KKMuWSLine",
prescale=config['Bs2st2KKMuWSPrescale'],
FILTER=self.GECs,
RelatedInfoTools=self.Bs2st2KKMuLine.RelatedInfoTools,
selection=self.SelBs2KKMuWS
#, MDSTFlag = True
)
self.Bs2st2KKJpsiLine = StrippingLine(
"Bs2st2KKJpsiLine",
prescale=config['Bs2st2KKMuPrescale'],
FILTER=self.GECs,
selection=self.SelBs2KKJpsi
#, MDSTFlag = True
)
self.Bs2st2KKJpsiWSLine = StrippingLine(
"Bs2st2KKJpsiWSLine",
prescale=config['Bs2st2KKJpsiWSPrescale'],
FILTER=self.GECs,
selection=self.SelBs2KKJpsiWS
#, MDSTFlag = True
)
# register stripping lines
self.registerLine(self.Bs2st2KKMuLine)
self.registerLine(self.Bs2st2KKMuWSLine)
self.registerLine(self.Bs2st2KKJpsiLine)
self.registerLine(self.Bs2st2KKJpsiWSLine)
HighQ2MuonsOnDemand = DataOnDemand(Location = "Phys/B2XMuMuInclusive_InclDiMuHighQ2Line/Particles")
bothstripping = MergedSelection("Selection_mergeddaughters",
RequiredSelections = [LowQ2MuonsOnDemand,HighQ2MuonsOnDemand])
_filterDimuons = FilterDesktop(Code="ABSID==511") # Dimuons from B0--> mu mu stripping selection
_selDimuons= Selection( "_selDimuons", Algorithm = _filterDimuons, RequiredSelections = [bothstripping] )
from Configurables import SubstitutePID
subalg = SubstitutePID("_B2Jpsi_SubPID", Code="(DECTREE('B0 -> mu+ mu-'))",
Substitutions={'B0 -> mu+ mu-' : 'J/psi(1S)'}, MaxChi2PerDoF=-666)
subsel = Selection("subsel",Algorithm = subalg, RequiredSelections = [_selDimuons])
# Try and make B->J/psi K
_B = CombineParticles()
_B.DaughtersCuts = { "K+" : "PT>500*MeV" }
_B.MotherCut = "(DMASS('B+')<5000*MeV) & (VFASPF(VCHI2)<25.0)" #need to check these cuts
_B.DecayDescriptors = [ "[B+ -> J/psi(1S) K+]cc" ]
_BdecaySelection = Selection( "TurboB", Algorithm = _B, RequiredSelections = [subsel,kaons] )
SeqB = SelectionSequence('SeqB', TopSelection = _BdecaySelection)
tupleB = DecayTreeTuple("bar-muon-tuple")
tupleB.Inputs = [SeqB.outputLocation()]
tupleB.Decay = "[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC"
def makeKS2LL(self, name, config):
# define all the cuts
#1st daughters cuts
_piPCut1 = "(P>%s*MeV)" % config['pi_L_Pmin']
_piMIPCut1 = "(MIPDV(PRIMARY)<%s*mm)" % config['pi_L_MIPDV']
_pipCuts = _piPCut1 + '&' + _piMIPCut1
_piPCut2 = "(P>%s*MeV)" % config['pi_L_Pmin']
_piMIPCut2 = "(MIPDV(PRIMARY)<%s*mm)" % config['pi_L_MIPDV']
_pimCuts = _piPCut2 + '&' + _piMIPCut2
# before vretex fit cuts
_massCut2 = "(ADAMASS('KS0')<%s*MeV)" % config['KS_LL_MassWindowP']
_docacut = "(ACUTDOCA(%s*mm,''))" % config['KS_LL_DOCA']
_CombinationCuts = _massCut2 + '&' + _docacut
# after vertex fit cuts
_massCut = "(ADMASS('KS0')<%s*MeV)" % config['KS_LL_MassWindow']
_vtxCut = "(VFASPF(VCHI2)<%s)" % config['KS_LL_VtxChi2']
_combMIP = "( sqrt( CHILD( MIPCHI2DV(PRIMARY) , 1 ) * CHILD( MIPCHI2DV(PRIMARY) , 1 ) + CHILD( MIPCHI2DV(PRIMARY) , 2 ) * CHILD( MIPCHI2DV(PRIMARY ) , 2 ) )>%s )" % config[
'KS_LL_CombMPI']
_docachi2cut = "(DOCA(1,2)/(sqrt( DOCACHI2(1,2) ))<%s*mm)" % config[
'KS_LL_DOCA_ERR']
_nuCut = "(log( CHILD( MIPDV(PRIMARY) , 1 )* CHILD( MIPDV(PRIMARY) , 2 )/ MIPDV( PRIMARY) ) > %s )" % config[
'KS_LL_nu']
_ptCut = "((CHILD ( PT , 1 )+CHILD ( PT , 2 ))>%s*MeV)" % config[
'KS_LL_pT']
_fdCut = "(BPVVDCHI2>%s)" % config['KS_LL_FDChi2']
# _trkChi2Cut1 = "(CHILDCUT((TRCHI2DOF<%s),1))" % config['Trk_Chi2']
# _trkChi2Cut2 = "(CHILDCUT((TRCHI2DOF<%s),2))" % config['Trk_Chi2']
_MotherCuts = _massCut + '&' + _vtxCut + '&' + _combMIP + '&' + _docachi2cut + '&' + _nuCut + '&' + _ptCut + '&' + _fdCut
########## EndCuts definition
print 'KS pipCuts: ', _pipCuts
print 'KS pimCuts: ', _pimCuts
print 'KS CombinationCuts: ', _CombinationCuts
print 'KS MotherCuts: ', _MotherCuts
# make the Ks from StdAllNoPIDsPions
_Ks = CombineParticles(DecayDescriptor="KS0 -> pi+ pi-",
DaughtersCuts={
"pi+": _pipCuts,
"pi-": _pimCuts
},
CombinationCut=_CombinationCuts,
MotherCut=_MotherCuts)
# Ks2PiPi.DaughtersCuts = { "pi+" : "(P>2*GeV) & (MIPDV(PRIMARY)<20.*mm)",
# "pi-" : "(P>2*GeV) & (MIPDV(PRIMARY)<20.*mm)" }
# get the KS's to filter
# _stdKSLL = DataOnDemand( Location = "Phys/StdLooseKsLL/Particles" )
# make the filter
# _filterKSLL = FilterDesktop( Code = _allCuts )
# make and store the Selection object
self.selKS2LL = Selection("selKS2LL_" + name,
Algorithm=_Ks,
RequiredSelections=[self.pions])
def __init__(self, name, config):
LineBuilder.__init__(self, name, config)
self.__confdict__ = config
#### muon selection
Muon_cuts = "(PT > %(MuonPT)s) & (P> %(MuonP)s)"\
"& (TRCHI2DOF < %(MuonChi2)s)"\
"& (TRGHOSTPROB < %(MuonGhostProbMax)s)"\
"& (MIPCHI2DV(PRIMARY)> %(MuonIPChi2)s)" % config
self.muons = Selection("Muons_for_" + name,
Algorithm=FilterDesktop(Code=Muon_cuts),
RequiredSelections=[StdNoPIDsMuons])
#### additional track selection
Track_cuts = "(PT > %(TrackPT)s) & (P> %(TrackP)s)"\
"& (TRCHI2DOF < %(TrackChi2)s)"\
"& (TRGHOSTPROB < %(TrackGhostProbMax)s)"\
"& (MIPCHI2DV(PRIMARY)> %(TrackIPChi2)s)" % config
self.tracks = Selection("Tracks_for_" + name,
Algorithm=FilterDesktop(Code=Track_cuts),
RequiredSelections=[StdNoPIDsKaons])
#### J/psi->mumu selection
self.JPsi_to_mumu = CombineParticles(DecayDescriptor = "J/psi(1S) -> mu+ mu-",
CombinationCut = "(ADAMASS('J/psi(1S)')<%(PsiMasswinPreFit)s) & (ADOCACHI2CUT(%(PsiDocaChi2Max)s,''))" %config,
MotherCut = "(INTREE( (ABSID=='mu+') & ISMUON ) )"\
"& (VFASPF(VCHI2/VDOF)< %(PsiVChi2NdofMax)s)"\
"& (ADMASS('J/psi(1S)')< %(PsiMasswin)s)"
" & (SUMTREE( PT, ISBASIC )>%(PsiPT)s)"\
"& (BPVVDCHI2 > %(PsiFDChi2Min)s) & (BPVDIRA>%(PsiDIRAMin)s)" %config
)
self.Sel_JPsi_to_mumu = Selection("JPsi_to_mumu_for_" + name,
Algorithm=self.JPsi_to_mumu,
RequiredSelections=[self.muons])
#### B -> J/psi + >=1 track selection
self.B_to_JPsi_track = CombineParticles(DecayDescriptor = "[B+ -> J/psi(1S) K+]cc",
CombinationCut = "(AM > %(BCombMassMin)s) & (AM < %(BCombMassMax)s) & (ADOCACHI2CUT(%(BDocaChi2Max)s,''))" %config,
MotherCut = "(VFASPF(VCHI2/VDOF)< %(BVChi2NdofMax)s)"\
" & (SUMTREE( PT, ISBASIC )>%(BPTMin)s) & (BPVVDCHI2 > %(BFDChi2Min)s) & (BPVDIRA>%(BDIRAMin)s)" %config
)
self.Sel_B_to_JPsi_track = Selection(
"B_to_JPsi_track_For" + name,
Algorithm=self.B_to_JPsi_track,
RequiredSelections=[self.Sel_JPsi_to_mumu, self.tracks])
#### GECs
GECs = {
"Code":
"( recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %(nLongTrackMax)s )"
% config,
"Preambulo": ["from LoKiTracks.decorators import *"]
}
#### register the line
self.registerLine(
StrippingLine("SemiIncJpsi2mumu" + name + "Line",
prescale=config["PrescaleSemiIncJpsi2mumu"],
FILTER=GECs,
selection=self.Sel_B_to_JPsi_track))
def makeD2KS0KDD(
name,
# KS0 selection
KS0DDSel
# Bach kaons selection
,
BachKaonsSel
# Cuts to be used
# D meson cuts
# Combo cuts
,
DMesonComboLowMass,
DMesonComboHighMass,
DMesonComboDOCA,
DMesonAPT,
DMesonADOCAChi2
# Mother cuts
,
DMesonMotherLowMass,
DMesonMotherHighMass,
DMesonMotherVertexChi2,
DMesonMotherMIPChi2,
DMesonMotherPT,
KS0ZDiff,
DMesonFlightDistChi2,
D_BPVLTIME_MIN,
UseTOS,
TisTosSpecs):
"""
Create and return a D(s) -> KS0 K Selection object.
Arguments:
name : name of the Selection.
ks0llSel : KS0DD -> pi+pi- Selection object.
All rest : Cuts used - self-explanatory naming
"""
# Define the combination, mother and daughter cuts
# _combCuts = "(APT > %(DMesonAPT)s) & (ACUTDOCACHI2(%(DMesonADOCAChi2)s,'')) & in_range(%(DMesonComboLowMass)s, AM, %(DMesonComboHighMass)s)" % locals()
_combCuts = "(APT > %(DMesonAPT)s) & (ACUTDOCACHI2(%(DMesonADOCAChi2)s,'')) & in_range(%(DMesonComboLowMass)s, AM, %(DMesonComboHighMass)s)" % locals(
)
_motherCuts = ("(PT > %(DMesonMotherPT)s) & (VFASPF(VCHI2PDOF) < %(DMesonMotherVertexChi2)s) &"\
" in_range(%(DMesonMotherLowMass)s, MM, %(DMesonMotherHighMass)s) &"\
" ((CHILD( VFASPF(VZ) , 'KS0' == ID ) - VFASPF(VZ)) > %(KS0ZDiff)s) &"\
" (MIPCHI2DV(PRIMARY) < %(DMesonMotherMIPChi2)s) &"\
" (BPVLTIME() > %(D_BPVLTIME_MIN)s) & (BPVVDCHI2 > %(DMesonFlightDistChi2)s)") % locals()
# Define the combine particles
_Dmeson = CombineParticles(DecayDescriptor="[D+ -> KS0 K+]cc",
CombinationCut=_combCuts,
MotherCut=_motherCuts)
sel = Selection(name,
Algorithm=_Dmeson,
RequiredSelections=[KS0DDSel, BachKaonsSel])
if not UseTOS:
return sel
else:
return Selection(name + "_TOS",
Algorithm=TisTosParticleTagger(
name + "TOSTagger", TisTosSpecs=TisTosSpecs),
RequiredSelections=[sel])
def makeD02hhmumu(
moduleName
,combMassWin
,massWin
,maxDOCA
,pt
,dauPt
,dauMom
,vtxChi2DOF
,FDChi2
,IPChi2
,dauMaxIPChi2
,dauIPChi2
,DIRA
,trackChi2DOF
,applyKaonPIDK
,kaonPIDK
,applyPionPIDK
,pionPIDK
,applyGhostProbCut
,ghostProbCut
):
"""Creates a D0->hhmumu Selection object, merging D0->Kpimumu CF
, D0->Kpimumu DCS, D0->KKmumu and D0->pipimumu, with cuts for physics analysis.
Uses StandardParticle objects 'StdAllLooseKaons', 'StdAllLoosePions'
and 'StdAllLooseMuons'
Arguments:
- moduleName : name of Selection
- combMassWin : mass window cut on combination (MeV/c^2)
- massWin : mass window cut (MeV/c^2)
- maxDOCA : maximum DOCA of D0 daughters (mm)
- pt : minimum transverse momentum of D0 (MeV/c)
- dauPt : minimum transverse momentum of D0 daughters (MeV/c)
- dauMom : minimum momentum of D0 daughters (MeV/c)
- vtxChi2DOF : maximum vertex chi2 / d.o.f.
- FDChi2 : minimum vertex chi2
- IPChi2 : maximum IP chi2
- dauMaxIPChi2 :require at leat one D0 daughter with IP chi2 greather than this value
- dauIPChi2 : minimum IP chi2 of D0 daughters
- DIRA : cosine of angle sustended by momentum and flight direction vectors of D0
- trackChi2DOF : maximum track chi2 / d.o.f. of D0 daughters (unitless)
- applyKaonPIDK : boolean for whether we apply a kaon PIDK cut
- kaonPIDK : DLL(K-pi) cut applied to kaon
- applyPionPIDK : boolean for whether we apply a pion PIDK cut
- pionPIDK : DLL(K-pi) cut applied to pions
"""
_prefitCuts = "(ADAMASS('D0')<%(combMassWin)s) & (APT>%(pt)s) & " \
"(AMAXDOCA('')<%(maxDOCA)s) & " \
"(AHASCHILD(((ABSID=='K+') | (ABSID=='pi+') | (ABSID=='mu+') ) & " \
"(MIPCHI2DV(PRIMARY)>%(dauMaxIPChi2)s)))" %locals()
_motherCuts = "(VFASPF(VCHI2/VDOF)<%(vtxChi2DOF)s) & " \
"(BPVVDCHI2>%(FDChi2)s) & (BPVIPCHI2()<%(IPChi2)s) & " \
"(BPVDIRA>%(DIRA)s) & (ADMASS('D0')<%(massWin)s) & " \
"(PT>%(pt)s)" %locals()
_kaonCuts = "(TRCHI2DOF<%(trackChi2DOF)s)" \
" &(PT>%(dauPt)s)&(P>%(dauMom)s)" \
" & (MIPCHI2DV(PRIMARY)>%(dauIPChi2)s)" \
%locals()
_pionCuts = copy(_kaonCuts)
_muonCuts = copy(_kaonCuts)
if applyKaonPIDK:
_kaonCutsOLD = copy(_kaonCuts)
_kaonCuts="(PIDK>%(kaonPIDK)s) & (HASRICH) & " %locals()
_kaonCuts+=_kaonCutsOLD
if applyPionPIDK:
_pionCutsOLD = copy(_pionCuts)
_pionCuts="(PIDK<%(pionPIDK)s) & (HASRICH) & " %locals()
_pionCuts+=_pionCutsOLD
if applyGhostProbCut:
_ghostCut = "( TRGHOSTPROB < %(ghostProbCut)s )" %locals()
_kaonCutsOLD = copy(_kaonCuts)
_pionCutsOLD = copy(_pionCuts)
_kaonCuts = _kaonCutsOLD + " & " + _ghostCut
_pionCuts = _pionCutsOLD + " & " + _ghostCut
from StandardParticles import StdAllNoPIDsPions, StdAllNoPIDsKaons
from StandardParticles import StdAllLoosePions, StdAllLooseKaons, StdAllLooseMuons
_kaons = StdAllLooseKaons
_pions = StdAllLoosePions
_muons = StdAllLooseMuons
_d02kpi = CombineParticles (DecayDescriptor = "[D0 -> K- pi+ mu+ mu-]cc"
,CombinationCut = _prefitCuts
,MotherCut = _motherCuts
,DaughtersCuts = { "K+" : _kaonCuts
,"pi+" : _pionCuts
,"mu+" : _muonCuts}
)
_selD02KPi = Selection('D02KPiFor'+moduleName
,Algorithm=_d02kpi
,RequiredSelections=[_muons,_kaons,_pions])
_conjPID = ConjugateNeutralPID()
_selD02KPiConj = Selection('D02KPiConjFor'+moduleName
,Algorithm=_conjPID
,RequiredSelections=[_selD02KPi])
_d02kk = copy(_d02kpi)
_d02kk.DecayDescriptor="D0 -> K+ K- mu+ mu-"
_selD02KK = Selection('D02KKFor'+moduleName
,Algorithm=_d02kk
,RequiredSelections=[_muons,_kaons])
_selD02KKConj = Selection('D02KKConjFor'+moduleName
,Algorithm=_conjPID
,RequiredSelections=[_selD02KK])
_d02pipi = copy(_d02kpi)
_d02pipi.DecayDescriptor="D0 -> pi+ pi- mu+ mu-"
_d02pipi.DaughtersCuts={ "K+" : _kaonCuts
,"pi+" : _pionCuts
,"mu+" : _muonCuts}
_selD02PiPi = Selection('D02PiPiFor'+moduleName
,Algorithm=_d02pipi
,RequiredSelections=[_muons,_pions])
_selD02PiPiConj = Selection('D02PiPiConjFor'+moduleName
,Algorithm=_conjPID
,RequiredSelections=[_selD02PiPi])
_d0Sel = MergedSelection('D02hhmumuFor'+moduleName
,RequiredSelections=[_selD02KPi
,_selD02KPiConj
,_selD02KK
,_selD02KKConj
,_selD02PiPi
,_selD02PiPiConj]
)
return _d0Sel
def __init__( self, name, config ):
LineBuilder.__init__( self, name, config )
#######################################################################
### ###
### VELO BASED VERTEXING SEQUENCE ###
### ###
#######################################################################
bestTracks = AutomaticData("Rec/Track/Best")
withVeloTracksForVertexing = bestTracks
if self.configurationParameter("VeloGEC")["Apply"]:
from GaudiConfUtils.ConfigurableGenerators import VeloEventShapeCutsS20p3
veloGEC = VeloEventShapeCutsS20p3()
self.validatedSetProps( "VeloGEC", DisplVerticesConf.veloGECCuts, veloGEC )
withVeloTracksForVertexing = PassThroughSelection( "%sVeloGEC" % self.name()
, RequiredSelection = withVeloTracksForVertexing
, Algorithm = veloGEC
)
if self.configurationParameter("FilterVelo")["Apply"]:
from GaudiConfUtils.ConfigurableGenerators import SelectVeloTracksNotFromPVS20p3
veloWithIP = SelectVeloTracksNotFromPVS20p3()
self.validatedSetProps( "FilterVelo", DisplVerticesConf.veloWithIPCuts, veloWithIP )
withVeloTracksForVertexing = Selection( "%sVeloFilteredTracks" % self.name()
, RequiredSelections = [ withVeloTracksForVertexing ]
, Algorithm = veloWithIP
)
# Displaced Vertex reconstruction with best tracks (dominated by those with a Velo segment)
from Configurables import PatPV3D, PVOfflineTool, PVSeed3DTool, LSAdaptPV3DFitter, LSAdaptPVFitter
withVeloVertexAlg = PatPV3D( "%sWithVeloVertexAlg" % self.name() )
withVeloVertexFinder = addPrivateToolAndGet(withVeloVertexAlg, PVOfflineTool)
withVeloVertexFinder.PVsChi2Separation = 0
withVeloVertexFinder.PVsChi2SeparationLowMult = 0
withVeloSeeder = addPrivateToolAndGet(withVeloVertexFinder, PVSeed3DTool )
withVeloVertexFinder.PVSeedingName = withVeloSeeder.getTitleName()
withVeloSeeder.MinCloseTracks = 3
withVeloFitter = addPrivateToolAndGet(withVeloVertexFinder, LSAdaptPV3DFitter)
withVeloVertexFinder.PVFitterName = withVeloFitter.getTitleName()
withVeloFitter.MinTracks = 4
withVeloVertexing = SelectionPatPV3DWrapper( "%sWithVeloVertexing" % self.name()
, withVeloVertexAlg
, RequiredSelections = [ withVeloTracksForVertexing ]
)
# Make Particles out of the RecVertices
from GaudiConfUtils.ConfigurableGenerators import LLParticlesFromRecVertices
rv2pWithVelo = LLParticlesFromRecVertices(
VerticesFromVeloOnly = False
, RequireUpstreamPV = False
, WriteP2PVRelations = False
, ForceP2PVBuild = False
, VeloProtoParticlesLocation = "Phys/%s/VeloProtoP" % self.name()
)
self.validatedSetProps( "RV2PWithVelo", DisplVerticesConf.recoCuts + DisplVerticesConf.singleCuts, rv2pWithVelo )
withVeloCandidates = Selection( "%sWithVeloCandidates" % self.name()
, RequiredSelections = [ withVeloVertexing ]
, Algorithm = rv2pWithVelo
, InputDataSetter = "RecVertexLocations"
)
#######################################################################
### ###
### DOWNSTREAM VERTEXING SEQUENCE ###
### ###
#######################################################################
from GaudiConfUtils.ConfigurableGenerators import CopyDownstreamTracks
downTracks = Selection( "%sDownstreamTracks" % self.name()
, RequiredSelections = [ bestTracks ]
, Algorithm = CopyDownstreamTracks()
)
# Displaced Vertex reconstruction from downstream tracks
downVertexAlg = PatPV3D( "%sDownVertexAlg" % self.name() )
downVertexFinder = addPrivateToolAndGet( downVertexAlg, PVOfflineTool )
downVertexFinder.RequireVelo = False
downVertexFinder.PVsChi2Separation = 0
downVertexFinder.PVsChi2SeparationLowMult = 0
downSeeder = addPrivateToolAndGet( downVertexFinder, PVSeed3DTool )
downVertexFinder.PVSeedingName = downSeeder.getTitleName()
downSeeder.TrackPairMaxDistance = 2.0*units.mm
downSeeder.zMaxSpread = 20.0*units.mm
downSeeder.MinCloseTracks = 4
downFitter = addPrivateToolAndGet( downVertexFinder, LSAdaptPVFitter )
downVertexFinder.PVFitterName = downFitter.getTitleName()
downFitter.MinTracks = 4
downFitter.maxChi2 = 400.0
downFitter.maxDeltaZ = 0.0005 *units.mm
downFitter.maxDeltaChi2NDoF = 0.002
downFitter.acceptTrack = 0.000000001
downFitter.trackMaxChi2 = 9
downFitter.trackMaxChi2Remove = 64
downVertexing = SelectionPatPV3DWrapper( "%sDownVertexing" % self.name()
, downVertexAlg
, RequiredSelections = [ downTracks ]
)
# Make Particles out of the RecVertices
rv2pDown = LLParticlesFromRecVertices(
VerticesFromVeloOnly = False
, RequireUpstreamPV = False
, WriteP2PVRelations = False
, ForceP2PVBuild = False
#, OutputLevel = VERBOSE
)
self.validatedSetProps( "RV2PDown", DisplVerticesConf.recoCuts + DisplVerticesConf.singleCuts, rv2pDown )
downCandidates = Selection( "%sDownCandidates" % self.name()
, RequiredSelections = [ downVertexing ]
, Algorithm = rv2pDown
, InputDataSetter = "RecVertexLocations"
)
#######################################################################
### ###
### HLT JET SEQUENCE ###
### ###
#######################################################################
# timing is already fine, so one algo with loose JetID is sufficient
# Hlt prefilter and vertex candidates from Hlt2
from Configurables import HltVertexConverterS20p3
revivedHlt2Candidates = "Phys/%sHlt2Cand/Particles" % self.name()
hltCandReviver = GaudiSequenceroid(ModeOR = True, ShortCircuit = False,
Members = [ GaudiSequencer( "%sHlt2CandFilterTCK%s-%s" % (self.name(), tckBegin, tckEnd),
Members = ( LoKi_Filters(HLT2_Code="in_range( {begin}, HLT_TCK % 0x40000000 , {end} ) & ( {decisions} )".format(begin=tckBegin, end=tckEnd, decisions=" | ".join("HLT_PASS('%s')" % ln for ln in hltLines))).filters("%sHlt2DecisionFilterTCK%s-%s" % (self.name(), tckBegin, tckEnd))
+ [ HltVertexConverterS20p3("%sHltConverter%s-%s" % (self.name(), tckBegin, tckEnd), HltSelReports="Hlt2/SelReports", HltLines=hltLines, Recursive=True, Output=revivedHlt2Candidates, WriteP2PVRelations=False, ForceP2PVBuild=False) ] ) )
for (tckBegin, tckEnd), hltLines in self.configurationParameter("HLT")["SignalLines"]
]
)
hltCandSelection = EventSelection( "%sHltCandidates" % self.name()
, Algorithm = hltCandReviver
)
hltVeloGEC = VeloEventShapeCutsS20p3()
self.validatedSetProps( "VeloGEC", DisplVerticesConf.veloGECCuts, hltVeloGEC )
hltVeloGEC.HistoProduce = False
hltVeloGECSel = EventSelection( "%sHltVeloGEC" % self.name(), Algorithm=hltVeloGEC )
hlt2CandAndGECSelection = Selection( "".join(( self.name(), "Hlt2CandVertices" ))
, RequiredSelections = [ hltCandSelection, AutomaticData(revivedHlt2Candidates), hltVeloGECSel ]
, Algorithm = FilterDesktop(
Code = "( ABSID == '{pid}' )".format(pid=LLPLHCbName)
, WriteP2PVRelations = False
, ForceP2PVBuild = False
)
)
#######################################################################
### ###
### LINE DEFINITIONS ###
### ###
#######################################################################
# one line for every configuratoin key of the format
# "Single.*Selection"
# "JetSingle.*Selection"
# "JetHltSingle.*Selection"
# "Double.*Selection"
# ".*HLTPS"
# "HltEff.*Selection"
##============================== Single ===================================##
singleLineNames = [ p.split("Single")[1].split("Selection")[0]
for p in self.configKeys()
if p.startswith("Single")
and p.endswith("Selection")
]
for lAcroName in singleLineNames:
lShortName = "Single%s" % lAcroName # SingleMedium
lSelName = "%sSelection" % lShortName # SingleMediumSelection
lLineName = "%s%s" % (self.name(), lShortName) # DisplVerticesSingleMedium
# Choose between Velo-based and downstream vertexing input
candidates = withVeloCandidates
code = None
if "Down" in lAcroName:
candidates = downCandidates
code = self.getLLPSelection( self.validatedGetProps(lSelName, DisplVerticesConf.singleCuts + DisplVerticesConf.downCuts) )
else:
code = self.getLLPSelection( self.validatedGetProps(lSelName, DisplVerticesConf.singleCuts) )
lineFilter = FilterDesktop(
DecayDescriptor = LLPLHCbName
, Preambulo = DisplVerticesConf.llpSelectionPreambulo
, Code = code
, WriteP2PVRelations = False
, ForceP2PVBuild = False
#, OutputLevel = VERBOSE
)
lineSel = Selection( "".join(( self.name(), lSelName ))
, RequiredSelections = [ candidates ]
, Algorithm = lineFilter
)
line = StrippingLine(lLineName
, prescale = self.validatedGetProps(lSelName, ["PreScale"])["PreScale"]
, selection = lineSel
, RequiredRawEvents = [ "Calo" ]
, RelatedInfoTools = [ { "Type" : "AddVeloEventShapeS21", "TopSelection" : lineSel, "Location" : "P2VES" } ]
)
if lShortName in self.configurationParameter("HLT"):
line.HLT2 = self.configurationParameter("HLT")[lShortName]
self.registerLine(line)
##========================= Single with jets ==============================##
jetSingleLineNames = [ p.split("JetSingle")[1].split("Selection")[0]
for p in self.configKeys()
if p.startswith("JetSingle")
and p.endswith("Selection")
]
for lAcroName in jetSingleLineNames:
lShortName = "JetSingle%s" % lAcroName # JetSingleMedium
lSelName = "%sSelection" % lShortName # JetSingleMediumSelection
lLineName = "%s%s" % (self.name(), lShortName) # DisplVerticesJetSingleMedium
# Choose between Velo-based and downstream vertexing input
vertexCandidates = withVeloCandidates
code = self.getLLPSelection( self.validatedGetProps(lSelName, DisplVerticesConf.singleCuts) )
vertexFilter = FilterDesktop(
DecayDescriptor = LLPLHCbName
, Preambulo = DisplVerticesConf.llpSelectionPreambulo
, Code = code
, WriteP2PVRelations = False
, ForceP2PVBuild = False
#, OutputLevel = VERBOSE
)
goodVertices = Selection( "".join(( self.name(), lSelName, "Vertices" ))
, RequiredSelections = [ vertexCandidates ]
, Algorithm = vertexFilter
)
jetProps = self.validatedGetProps(lSelName, DisplVerticesConf.jetCuts)
vertWithJets = Selection( "".join(( self.name(), lSelName, "Jets" ))
, RequiredSelections = [ goodVertices ]
, Algorithm = self.makeJetCandidateAlg("".join((self.name(), lSelName, "JetAlg"))
, MinNumJets = jetProps["MinNumJets"]
, ConeSize = jetProps["ConeSize"]
, JetIDCut = jetProps["JetIDCut"]
, MinDOCABL = jetProps["MinDOCABL"]
)
)
jetCode = self.getLLPJetSelection(jetProps)
jetCandFilter = FilterDesktop(
DecayDescriptor = LLPLHCbName
, Preambulo = self.jetSelectionPreambulo
, Code = jetCode
, WriteP2PVRelations = False
, ForceP2PVBuild = False
)
lineSel = Selection( "".join(( self.name(), lSelName ))
, RequiredSelections = [ vertWithJets ]
, Algorithm = jetCandFilter
)
line = StrippingLine(lLineName
, prescale = self.validatedGetProps(lSelName, ["PreScale"])["PreScale"]
, selection = lineSel
, RequiredRawEvents = [ "Calo" ]
, RelatedInfoTools = [ { "Type" : "AddVeloEventShapeS21", "TopSelection" : lineSel, "Location" : "P2VES" } ]
)
if lShortName in self.configurationParameter("HLT"):
line.HLT2 = self.configurationParameter("HLT")[lShortName]
self.registerLine(line)
##============= Single with jets based on Hlt candidate ==================##
jetHltSingleLineNames = [ p.split("JetHltSingle")[1].split("Selection")[0]
for p in self.configKeys()
if p.startswith("JetHltSingle")
and p.endswith("Selection")
]
for lAcroName in jetHltSingleLineNames:
lShortName = "JetHltSingle%s" % lAcroName # JetHltSingleMedium
lSelName = "%sSelection" % lShortName # JetHltSingleMediumSelection
lLineName = "%s%s" % (self.name(), lShortName) # DisplVerticesJetHltSingleMedium
jetProps = self.validatedGetProps(lSelName, DisplVerticesConf.jetCuts)
vertWithJets = Selection( "".join(( self.name(), lSelName, "HltJets" ))
, RequiredSelections = [ hlt2CandAndGECSelection ]
, Algorithm = self.makeJetCandidateAlg("".join((self.name(), lSelName, "HltJetAlg"))
, MinNumJets = jetProps["MinNumJets"]
, ConeSize = jetProps["ConeSize"]
, JetIDCut = jetProps["JetIDCut"]
, MinDOCABL = jetProps["MinDOCABL"]
)
)
jetCode = self.getLLPJetSelection(jetProps)
jetCandFilter = FilterDesktop(
DecayDescriptor = LLPLHCbName
, Preambulo = self.jetSelectionPreambulo
, Code = jetCode
, WriteP2PVRelations = False
, ForceP2PVBuild = False
)
lineSel = Selection( "".join(( self.name(), lSelName ))
, RequiredSelections = [ vertWithJets ]
, Algorithm = jetCandFilter
)
line = StrippingLine(lLineName
, prescale = self.validatedGetProps(lSelName, ["PreScale"])["PreScale"]
, selection = lineSel
, RequiredRawEvents = [ "Calo" ]
, RelatedInfoTools = [ { "Type" : "AddVeloEventShapeS21", "TopSelection" : lineSel, "Location" : "P2VES" } ]
)
if lShortName in self.configurationParameter("HLT"):
line.HLT2 = self.configurationParameter("HLT")[lShortName]
self.registerLine(line)
##============================== Double ===================================##
doubleLineNames = [ p.split("Double")[1].split("Selection")[0]
for p in self.configKeys()
if p.startswith("Double")
and p.endswith("Selection")
]
for lAcroName in doubleLineNames:
lShortName = "Double%s" % lAcroName
lSelName = "%sSelection" % lShortName
lLineName = "%s%s" % (self.name(), lShortName)
combinationCut, motherCut = self.getResonanceSelection( self.validatedGetProps(lSelName, DisplVerticesConf.doubleResonanceCuts) )
lineFilter = CombineParticles(
DecayDescriptor = "H_10 -> %s %s" % (LLPLHCbName, LLPLHCbName)
, Preambulo = DisplVerticesConf.llpSelectionPreambulo
, DaughtersCuts = { LLPLHCbName : self.getLLPSelection( self.validatedGetProps(lSelName, DisplVerticesConf.singleCuts) ) }
, CombinationCut = combinationCut
, MotherCut = motherCut
, WriteP2PVRelations = False
, ForceP2PVBuild = False
#, OutputLevel = VERBOSE
)
lineSel = Selection( "".join(( self.name(), lSelName ))
, RequiredSelections = [ withVeloCandidates ]
, Algorithm = lineFilter
)
line = StrippingLine(lLineName
, prescale = self.validatedGetProps(lSelName, ["PreScale"])["PreScale"]
, selection = lineSel
, RequiredRawEvents = [ "Calo" ]
, RelatedInfoTools = [ { "Type" : "AddVeloEventShapeS21", "TopSelection" : lineSel, "Location" : "P2VES" } ]
)
if lShortName in self.configurationParameter("HLT"):
line.HLT2 = self.configurationParameter("HLT")[lShortName]
self.registerLine(line)
##============================== HLT PS ===================================##
hltPSLineNames = [ p.split("HLTPS")[0]
for p in self.configKeys()
if p.endswith("HLTPS")
]
for lAcroName in hltPSLineNames:
lShortName = "%sHLTPS" % lAcroName
lLineName = "%s%s" % (self.name(), lShortName) # DisplVerticesSingleMedium
orFilters = []
for (tckBegin, tckEnd), hltFilter in self.validatedGetProps("HLT", [lShortName])[lShortName]:
filters = LoKi_Filters(HLT2_Code="in_range( {begin}, HLT_TCK % 0x40000000, {end} ) & ( {decisions} )".format(begin=tckBegin, end=tckEnd, decisions=hltFilter)).filters("%sHlt2FilterTCK%s-%s" % (lLineName, tckBegin, tckEnd))
assert len(filters) == 1
orFilters.append(filters[0])
assert len(orFilters) == len(self.validatedGetProps("HLT", [lShortName])[lShortName])
hltSelection = EventSelection( "%sHltFilter" % lLineName
, Algorithm = GaudiSequenceroid(ModeOR = True, ShortCircuit = False, Members=orFilters)
)
line = StrippingLine(lLineName
, prescale = self.validatedGetProps(lShortName, ["PreScale"])["PreScale"]
, selection = hltSelection
, RequiredRawEvents = ["Muon","Calo","Rich","Velo","Tracker"]
)
self.registerLine(line)
##============================== OTHER ===================================##
hltEffLineNames = [ p.split("HltEff")[1].split("Selection")[0]
for p in self.configKeys()
if p.startswith("HltEff")
and p.endswith("Selection")
]
for lShortName in hltEffLineNames:
lSelName = "HltEff%sSelection" % lShortName
lLineName = "%s%s" % (self.name(), lShortName)
# HltEff lines are single, Velo-vertexing based lines
lineFilter = FilterDesktop(
DecayDescriptor = LLPLHCbName
, Preambulo = DisplVerticesConf.llpSelectionPreambulo
, Code = self.getLLPSelection( self.validatedGetProps(lSelName, DisplVerticesConf.singleCuts) )
, WriteP2PVRelations = False
, ForceP2PVBuild = False
#, OutputLevel = VERBOSE
)
lineSel = Selection( "".join(( self.name(), lSelName ))
, RequiredSelections = [ withVeloCandidates ]
, Algorithm = lineFilter
)
line = StrippingLine(lLineName
, prescale = self.validatedGetProps(lSelName, ["PreScale"])["PreScale"]
# these lines MUST have an HLT filter
, HLT2 = self.configurationParameter("HLT")[lShortName]
, selection = lineSel
, RequiredRawEvents = ["Muon","Calo","Rich","Velo","Tracker"]
, RelatedInfoTools = [ { "Type" : "AddVeloEventShapeS21", "TopSelection" : lineSel, "Location" : "P2VES" } ]
)
self.registerLine(line)
def makeLambdac2PKPi(name,
inputSel,
Daug_All_PT_MIN,
Daug_2of3_PT_MIN,
Daug_1of3_PT_MIN,
Daug_All_BPVIPCHI2_MIN,
Daug_2of3_BPVIPCHI2_MIN,
Daug_1of3_BPVIPCHI2_MIN,
Proton_PIDpPIDpi_MIN,
Proton_PIDpPIDK_MIN,
K_PIDK_MIN,
Pi_PIDK_MAX,
Comb_ADAMASS_WIN,
Comb_ADOCAMAX_MAX,
Lambdac_VCHI2VDOF_MAX,
Lambdac_acosBPVDIRA_MAX,
Lambdac_PVDispCut,
decDescriptors=["[Lambda_c+ -> p+ K- pi+]cc"]): # {
## Construct a preambulo to simplify some calculations.
lclPreambulo = [
"from math import cos",
"bpvdirathresh = cos(%(Lambdac_acosBPVDIRA_MAX)s)" % locals(),
"pidFiducialPMin = 3.0 * GeV", "pidFiducialPMax = 100.0 * GeV"
]
daugCuts = "(PT > %(Daug_All_PT_MIN)s)" \
"& (BPVIPCHI2() > %(Daug_All_BPVIPCHI2_MIN)s)" % locals()
pidFiducialCuts = "(HASRICH)" \
"& (in_range(pidFiducialPMin, P, pidFiducialPMax))" \
"& (in_range(2.0, ETA, 5.0))"
pCuts = pidFiducialCuts + "& ((PIDp-PIDpi) > %(Proton_PIDpPIDpi_MIN)s)" \
"& ((PIDp-PIDK) > %(Proton_PIDpPIDK_MIN)s)" % locals()
kCuts = pidFiducialCuts + "& ((PIDK-PIDpi) > %(K_PIDK_MIN)s)" % locals()
piCuts = pidFiducialCuts + "& ((PIDK-PIDpi) < %(Pi_PIDK_MAX)s)" % locals()
combCuts = "(ADAMASS('Lambda_c+') < %(Comb_ADAMASS_WIN)s)" \
"& (AMAXCHILD(PT) > %(Daug_1of3_PT_MIN)s)" \
"& (AMAXCHILD(BPVIPCHI2()) > %(Daug_1of3_BPVIPCHI2_MIN)s)" \
"& (ANUM(PT > %(Daug_2of3_PT_MIN)s) >= 2)" \
"& (ANUM(BPVIPCHI2() > %(Daug_2of3_BPVIPCHI2_MIN)s) >= 2)" \
"& (ADOCAMAX('') < %(Comb_ADOCAMAX_MAX)s)" % locals()
lambdacCuts = "(VFASPF(VCHI2/VDOF) < %(Lambdac_VCHI2VDOF_MAX)s)" \
"& (%(Lambdac_PVDispCut)s)" \
"& (BPVDIRA > bpvdirathresh)" % locals()
_Lambdac = CombineParticles(DecayDescriptors=decDescriptors,
Preambulo=lclPreambulo,
DaughtersCuts={
"pi+": daugCuts + '&' + piCuts,
"K+": daugCuts + '&' + kCuts,
"p+": daugCuts + '&' + pCuts
},
CombinationCut=combCuts,
MotherCut=lambdacCuts)
return Selection(name, Algorithm=_Lambdac, RequiredSelections=inputSel)
def __init__( self, name, config ):
LineBuilder.__init__( self, name, config )
#######################################################################
### ###
### VELO BASED VERTEXING SEQUENCE ###
### ###
#######################################################################
bestTracks = AutomaticData("Rec/Track/Best")
withVeloTracksForVertexing = bestTracks
if self.configurationParameter("FilterVelo")["Apply"]:
from GaudiConfUtils.ConfigurableGenerators import SelectVeloTracksNotFromPV
veloWithIP = SelectVeloTracksNotFromPV()
self.validatedSetProps( "FilterVelo", DisplVerticesLinesConf.veloWithIPCuts, veloWithIP )
withVeloTracksForVertexing = Selection( "%sVeloFilteredTracks" % self.name()
, RequiredSelections = [ bestTracks ]
, Algorithm = veloWithIP
)
# Displaced Vertex reconstruction with best tracks (dominated by those with a Velo segment)
from Configurables import PatPV3D, PVOfflineTool, PVSeed3DTool, LSAdaptPV3DFitter, LSAdaptPVFitter
withVeloVertexFinder = PVOfflineTool( "%sWithVeloVertexFinder" % self.name()
, PVsChi2Separation = 0
, PVsChi2SeparationLowMult = 0
, PVSeedingName = "PVSeed3DTool"
, PVFitterName = "LSAdaptPV3DFitter"
)
withVeloVertexFinder.addTool(PVSeed3DTool)
withVeloVertexFinder.PVSeed3DTool.MinCloseTracks = 3
withVeloVertexFinder.addTool(LSAdaptPV3DFitter)
withVeloVertexFinder.LSAdaptPV3DFitter.maxIP2PV = 2.0*units.mm
withVeloVertexFinder.LSAdaptPV3DFitter.MinTracks = 4
withVeloVertexAlg = PatPV3D( "%sWithVeloVertexAlg" )
withVeloVertexAlg.addTool( withVeloVertexFinder, name="PVOfflineTool" )
withVeloVertexing = SelectionPatPV3DWrapper( "%sWithVeloVertexing" % self.name()
, withVeloVertexAlg
, RequiredSelections = [ withVeloTracksForVertexing ]
)
# Make Particles out of the RecVertices
from GaudiConfUtils.ConfigurableGenerators import LLParticlesFromRecVertices
rv2pWithVelo = LLParticlesFromRecVertices(
VerticesFromVeloOnly = False
, WriteP2PVRelations = False
, ForceP2PVBuild = False
, VeloProtoParticlesLocation = "Phys/%s/VeloProtoP" % self.name()
)
self.validatedSetProps( "RV2PWithVelo", DisplVerticesLinesConf.recoCuts + DisplVerticesLinesConf.singleCuts, rv2pWithVelo )
withVeloCandidates = Selection( "%sWithVeloCandidates" % self.name()
, RequiredSelections = [ withVeloVertexing ]
, Algorithm = rv2pWithVelo
, InputDataSetter = "RecVertexLocations"
)
#######################################################################
### ###
### DOWNSTREAM VERTEXING SEQUENCE ###
### ###
#######################################################################
from GaudiConfUtils.ConfigurableGenerators import CopyDownstreamTracks
downTracks = Selection( "%sDownstreamTracks" % self.name()
, RequiredSelections = [ bestTracks ]
, Algorithm = CopyDownstreamTracks()
)
# Displaced Vertex reconstruction from downstream tracks
downVertexFinder = PVOfflineTool( "%sDownVertexFinder" % self.name()
, RequireVelo = False
, PVsChi2Separation = 0
, PVsChi2SeparationLowMult = 0
, PVSeedingName = "PVSeed3DTool"
, PVFitterName = "LSAdaptPVFitter"
)
downVertexFinder.addTool(PVSeed3DTool)
downVertexFinder.PVSeed3DTool.TrackPairMaxDistance = 2.0*units.mm
downVertexFinder.PVSeed3DTool.zMaxSpread = 20.0*units.mm
downVertexFinder.PVSeed3DTool.MinCloseTracks = 4
downVertexFinder.addTool(LSAdaptPVFitter)
downVertexFinder.LSAdaptPVFitter.MinTracks = 4
downVertexFinder.LSAdaptPVFitter.maxChi2 = 400.0
downVertexFinder.LSAdaptPVFitter.maxDeltaZ = 0.0005 *units.mm
downVertexFinder.LSAdaptPVFitter.maxDeltaChi2NDoF = 0.002
downVertexFinder.LSAdaptPVFitter.acceptTrack = 0.000000001
downVertexFinder.LSAdaptPVFitter.trackMaxChi2 = 9
downVertexFinder.LSAdaptPVFitter.trackMaxChi2Remove = 64
downVertexAlg = PatPV3D( "%sDownVertexAlg" % self.name() )
downVertexAlg.addTool(downVertexFinder, name="PVOfflineTool")
downVertexing = SelectionPatPV3DWrapper( "%sDownVertexing" % self.name()
, downVertexAlg
, RequiredSelections = [ downTracks ]
)
# Make Particles out of the RecVertices
rv2pDown = LLParticlesFromRecVertices(
VerticesFromVeloOnly = False
, WriteP2PVRelations = False
, ForceP2PVBuild = False
#, OutputLevel = VERBOSE
)
self.validatedSetProps( "RV2PDown", DisplVerticesLinesConf.recoCuts + DisplVerticesLinesConf.singleCuts, rv2pDown )
downCandidates = Selection( "%sDownCandidates" % self.name()
, RequiredSelections = [ downVertexing ]
, Algorithm = rv2pDown
, InputDataSetter = "RecVertexLocations"
)
#######################################################################
### ###
### LINE DEFINITIONS ###
### ###
#######################################################################
##============================== Single ===================================##
singleLineNames = [ p.split("Single")[1].split("Selection")[0]
for p in self.configKeys()
if p.startswith("Single")
and p.endswith("Selection")
]
for lAcroName in singleLineNames:
lShortName = "Single%s" % lAcroName # SingleMedium
lSelName = "%sSelection" % lShortName # SingleMediumSelection
lLineName = "%s%s" % (self.name(), lShortName) # DisplVerticesSingleMedium
# Choose between Velo-based and downstream vertexing input
candidates = withVeloCandidates
code = None
if "Down" in lAcroName:
candidates = downCandidates
code = self.getLLPSelection( self.validatedGetProps(lSelName, DisplVerticesLinesConf.singleCuts + DisplVerticesLinesConf.downCuts) )
else:
code = self.getLLPSelection( self.validatedGetProps(lSelName, DisplVerticesLinesConf.singleCuts) )
lineFilter = FilterDesktop(
DecayDescriptor = LLPLHCbName
, Preambulo = DisplVerticesLinesConf.llpSelectionPreambulo
, Code = code
, WriteP2PVRelations = False
, ForceP2PVBuild = False
#, OutputLevel = VERBOSE
)
lineSel = Selection( "".join(( self.name(), lSelName ))
, RequiredSelections = [ candidates ]
, Algorithm = lineFilter
)
line = StrippingLine(lLineName
, prescale = self.validatedGetProps(lSelName, ["PreScale"])["PreScale"]
, selection = lineSel
## , FILTER = { "Preambulo" : [ "nVeloTracks = RECSUMMARY(13, 0)"
## , "nVeloClusters = RECSUMMARY(30, -1)"
## , "from LoKiCore.functions import *" ]
## , "Code" : "monitor( 1.*nVeloTracks/nVeloClusters , Gaudi.Histo1DDef('Number of Velo Tracks / Clusters', 0., 1., 100) , 'NumVeloTracksPerCluster' ) < 0.2" }
)
if lShortName in self.configurationParameter("HLT"):
line.HLT = self.configurationParameter("HLT")[lShortName]
self.registerLine(line)
##============================== Double ===================================##
doubleLineNames = [ p.split("Double")[1].split("Selection")[0]
for p in self.configKeys()
if p.startswith("Double")
and p.endswith("Selection")
]
for lAcroName in doubleLineNames:
lShortName = "Double%s" % lAcroName
lSelName = "%sSelection" % lShortName
lLineName = "%s%s" % (self.name(), lShortName)
combinationCut, motherCut = self.getResonanceSelection( self.validatedGetProps(lSelName, DisplVerticesLinesConf.doubleResonanceCuts) )
lineFilter = CombineParticles(
DecayDescriptor = "H_10 -> %s %s" % (LLPLHCbName, LLPLHCbName)
, Preambulo = DisplVerticesLinesConf.llpSelectionPreambulo
, DaughtersCuts = { LLPLHCbName : self.getLLPSelection( self.validatedGetProps(lSelName, DisplVerticesLinesConf.singleCuts) ) }
, CombinationCut = combinationCut
, MotherCut = motherCut
, WriteP2PVRelations = False
, ForceP2PVBuild = False
#, OutputLevel = VERBOSE
)
lineSel = Selection( "".join(( self.name(), lSelName ))
, RequiredSelections = [ withVeloCandidates ]
, Algorithm = lineFilter
)
line = StrippingLine(lLineName
, prescale = self.validatedGetProps(lSelName, ["PreScale"])["PreScale"]
, selection = lineSel
)
if lShortName in self.configurationParameter("HLT"):
line.HLT = self.configurationParameter("HLT")[lShortName]
self.registerLine(line)
##============================== HLT PS ===================================##
hltPSLineNames = [ p.split("HLTPS")[0]
for p in self.configKeys()
if p.endswith("HLTPS")
]
for lAcroName in hltPSLineNames:
lShortName = "%sHLTPS" % lAcroName
lLineName = "%s%s" % (self.name(), lShortName) # DisplVerticesSingleMedium
hltSelAlg = GaudiSequenceroid(ModeOR = True, ShortCircuit = False,
Members = [ GaudiSequencer( "%sHltFilterTCK%s-%s" % (lLineName, tckBegin, tckEnd),
Members = [ ODINFilter("%sODINFilterTCK%s-%s" % (lLineName, tckBegin, tckEnd), Code="( ODIN_TCK >= %s ) & ( ODIN_TCK <= %s )" % (tckBegin, tckEnd))
, HltFilter("%sHltDecisionFilterTCK%s-%s" % (lLineName, tckBegin, tckEnd), Code=hltFilter) ])
for (tckBegin, tckEnd), hltFilter in self.validatedGetProps("HLT", [lShortName])[lShortName]
]
)
hltSelection = EventSelection( "%sHltFilter" % lLineName
, Algorithm = hltSelAlg
)
line = StrippingLine(lLineName
, prescale = self.validatedGetProps(lShortName, ["PreScale"])["PreScale"]
, selection = hltSelection
)
self.registerLine(line)
##============================== OTHER ===================================##
hltEffLineNames = [ p.split("HltEff")[1].split("Selection")[0]
for p in self.configKeys()
if p.startswith("HltEff")
and p.endswith("Selection")
]
for lShortName in hltEffLineNames:
lSelName = "HltEff%sSelection" % lShortName
lLineName = "%s%s" % (self.name(), lShortName)
# HltEff lines are single, Velo-vertexing based lines
lineFilter = FilterDesktop(
DecayDescriptor = LLPLHCbName
, Preambulo = DisplVerticesLinesConf.llpSelectionPreambulo
, Code = self.getLLPSelection( self.validatedGetProps(lSelName, DisplVerticesLinesConf.singleCuts) )
, WriteP2PVRelations = False
, ForceP2PVBuild = False
#, OutputLevel = VERBOSE
)
lineSel = Selection( "".join(( self.name(), lSelName ))
, RequiredSelections = [ withVeloCandidates ]
, Algorithm = lineFilter
)
line = StrippingLine(lLineName
, prescale = self.validatedGetProps(lSelName, ["PreScale"])["PreScale"]
# these lines MUST have an HLT filter
, HLT = self.configurationParameter("HLT")[lShortName]
, selection = lineSel
)
self.registerLine(line)
def makeb2DMuXNEW(module_name,
name,
BDecays,
DDecays,
CONFIG,
CHARM_DAUGHTERS,
MUON):
DEFAULT_GECs = { "Code":"( recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %(GEC_nLongTrk)s )" %CONFIG,
"Preambulo": ["from LoKiTracks.decorators import *"]}
DEFAULT_HLT = CONFIG["HLT_FILTER"]
CHARM_DaugCuts = {}
CHARM_ComboCuts = CONFIG["CharmComboCuts"]
CHARM_MotherCuts = CONFIG["CharmMotherCuts"]
if "CharmDaugCuts" in CONFIG.keys():
CHARM_DaugCuts = CONFIG["CharmDaugCuts"]
if "CharmExtraComboCuts" in CONFIG.keys():
CHARM_ComboCuts += CONFIG["CharmExtraComboCuts"]
if "CharmExtraMotherCuts" in CONFIG.keys():
CHARM_MotherCuts += CONFIG["CharmExtraMotherCuts"]
CHARM = Selection("CharmSelFor"+name+module_name,
Algorithm=CombineParticles(DecayDescriptors = DDecays,
DaughtersCuts = CHARM_DaugCuts,
CombinationCut = CHARM_ComboCuts,
MotherCut = CHARM_MotherCuts),
RequiredSelections = CHARM_DAUGHTERS)
USED_CHARM = CHARM
if "D*" in BDecays:
DST = makeDstar("CharmSelDstFor"+name+module_name,CHARM,CONFIG)
USED_CHARM = DST
B_combinationCut = "(AM > %(BMassMin)s*GeV) & (AM < %(BMassMax)s*GeV) & (ADOCACHI2CUT( %(B_DocaChi2Max)s, ''))" %CONFIG
B_motherCut = " (MM>%(BMassMin)s*GeV) & (MM<%(BMassMax)s*GeV) & (VFASPF(VCHI2/VDOF)< %(BVCHI2DOF)s) & (BPVDIRA> %(B_DIRA)s) " \
"& (MINTREE(((ABSID=='D+') | (ABSID=='D0') | (ABSID=='Lambda_c+')) , VFASPF(VZ))-VFASPF(VZ) > %(B_D_DZ)s *mm ) " %CONFIG
if "ExtraComboCuts" in CONFIG.keys():
B_combinationCut += CONFIG["ExtraComboCuts"]
if "ExtraMotherCuts" in CONFIG.keys():
B_motherCut += CONFIG["ExtraMotherCuts"]
B_DaugCuts = {}
if "ExtraMuonCuts" in CONFIG.keys():
B_DaugCuts = {"mu+":CONFIG["ExtraMuonCuts"]}
if "ExtraElectronCuts" in CONFIG.keys():
B_DaugCuts = {"e+":CONFIG["ExtraElectronCuts"]}
_B = CombineParticles(DecayDescriptors = BDecays,
DaughtersCuts = B_DaugCuts,
CombinationCut = B_combinationCut,
MotherCut = B_motherCut)
BSel = Selection ("BSelFor"+name+module_name,
Algorithm = _B,
RequiredSelections = [MUON,USED_CHARM])
### invert the order for the fakes line
### to be more efficient
if "fakes" in name:
BSel.RequiredSelections = [USED_CHARM,MUON]
BSelTOS = TOSFilter( "BSelFor"+name+module_name+"TOS"
,BSel
,CONFIG["TTSpecs"])
debug = False
if debug:
print [name,DEFAULT_HLT,CHARM_DaugCuts,Charm_ComboCuts,CHARM_MotherCuts,B_DaugCuts,B_combinationCut,B_motherCut]
_prescale = 1.0
if name in CONFIG["prescales"].keys():
_prescale = CONFIG["prescales"][name]
return StrippingLine(name + module_name + 'Line',
HLT = DEFAULT_HLT,
FILTER=DEFAULT_GECs,
prescale = _prescale,
selection = BSelTOS)
def makeResonanceMuMuTrackEff(name, resonanceName, decayDescriptor, plusCharge,
minusCharge, mode, massWin, vertexChi2,
resonancePT, muonTTPT, longPT, longMuonPID,
longMuonMinIP, longMuonTrackCHI2):
"""
Create and return a Resonance -> mu mu Selection object, with one track a long track
and the other a MuonTT track.
Arguments:
name : name of the selection
resonanceName : name of the resonance
decayDescriptor : decayDescriptor of the decay
plusCharge : algorithm for selection positvely charged tracks
minusCharge : algorithm for selection negatively charged tracks
mode : Tag(-)-and-Probe(+) (1) or Tag(+)-and-Probe(-) (2)
massWin : mass window around J/psi mass
VertexChi2 : vertex chi2 / ndof of mu mu vertex
resonancePT : Pt of the resonance particle (f.ex. J/psi)
muonTTPT : Pt of MuonTT-track muon
longPT : Pt of Long-track muon
longMuonPID : CombDLL(mu-pi) of long-track muon
NOT IMPLEMENTED YET:
longMuonMinIPCHI2 : MinIPCHI2 of long-track muon
longMuonTrackCHI2 : Track-Chi2 of long-track muon
"""
massWinCombCut = 2 * massWin
Combine = CombineParticles()
MuonTTResonance = Combine.configurable(name + "MuonTTResonance")
MuonTTResonance.DecayDescriptor = decayDescriptor
MuonTTResonance.OutputLevel = 4
if (mode == 1):
MuonTTResonance.DaughtersCuts = {
"mu+": "PT > %(muonTTPT)s" % locals(),
"mu-": "(PT > %(longPT)s) & (PIDmu > %(longMuonPID)s)" % locals()
}
MuonTTResonance.CombinationCut = "ADAMASS('%(resonanceName)s') < %(massWinCombCut)s" % locals(
)
MuonTTResonance.MotherCut = "(ADMASS('%(resonanceName)s') < %(massWin)s) & (VFASPF(VCHI2/VDOF) < %(vertexChi2)s)" % locals(
)
return Selection(name,
Algorithm=MuonTTResonance,
RequiredSelections=[minusCharge, plusCharge])
if (mode == 2):
MuonTTResonance.DaughtersCuts = {
"mu-": "PT > %(muonTTPT)s" % locals(),
"mu+": "(PT > %(longPT)s) & (PIDmu > %(longMuonPID)s)" % locals()
}
MuonTTResonance.CombinationCut = "ADAMASS('%(resonanceName)s') < %(massWinCombCut)s" % locals(
)
MuonTTResonance.MotherCut = "(ADMASS('%(resonanceName)s') < %(massWin)s) & (VFASPF(VCHI2/VDOF) < %(vertexChi2)s)" % locals(
)
return Selection(name,
Algorithm=MuonTTResonance,
RequiredSelections=[plusCharge, minusCharge])
def DiCharm ( self ) :
"""
Di-Charm selection
"""
sel = self._selection ( 'DiCharm_Selection' )
if sel : return sel
## prepare Di-charm
cmb = CombineParticles (
## the decays to be reconstructed
DecayDescriptors = [
#
# charm-anti-charm
#
" psi(3770) -> D0 D~0 " ,
" [ psi(3770) -> D0 D*(2010)- ]cc " ,
" [ psi(3770) -> D0 D- ]cc " ,
" [ psi(3770) -> D0 D_s- ]cc " ,
" [ psi(3770) -> D0 Lambda_c~- ]cc " ,
#
" psi(3770) -> D*(2010)+ D*(2010)- " ,
" [ psi(3770) -> D*(2010)+ D- ]cc " ,
" [ psi(3770) -> D*(2010)+ D_s- ]cc " ,
" [ psi(3770) -> D*(2010)+ Lambda_c~- ]cc " ,
#
" psi(3770) -> D+ D- " ,
" [ psi(3770) -> D+ D_s- ]cc " ,
" [ psi(3770) -> D+ Lambda_c~- ]cc " ,
#
" psi(3770) -> D_s+ D_s- " ,
" [ psi(3770) -> D_s+ Lambda_c~- ]cc " ,
#
" psi(3770) -> Lambda_c+ Lambda_c~- " ,
#
# double charm
#
" [ psi(3770) -> D0 D0 ]cc" ,
" [ psi(3770) -> D0 D*(2010)+ ]cc " ,
" [ psi(3770) -> D0 D+ ]cc " ,
" [ psi(3770) -> D0 D_s+ ]cc " ,
" [ psi(3770) -> D0 Lambda_c+ ]cc " ,
#
" [ psi(3770) -> D*(2010)+ D*(2010)+ ]cc " ,
" [ psi(3770) -> D*(2010)+ D+ ]cc " ,
" [ psi(3770) -> D*(2010)+ D_s+ ]cc " ,
" [ psi(3770) -> D*(2010)+ Lambda_c+ ]cc " ,
#
" [ psi(3770) -> D+ D+ ]cc " ,
" [ psi(3770) -> D+ D_s+ ]cc " ,
" [ psi(3770) -> D+ Lambda_c+ ]cc " ,
#
" [ psi(3770) -> D_s+ D_s+ ]cc " ,
" [ psi(3770) -> D_s+ Lambda_c+ ]cc " ,
#
" [ psi(3770) -> Lambda_c+ Lambda_c+ ]cc "
] ,
## combination cut : accept all
CombinationCut = " AALL " ,
## mother cut : accept all
MotherCut = " ALL "
)
sel = Selection (
##
'SelDiCharmFor' + self.name() ,
##
Algorithm = cmb ,
##
RequiredSelections = [ self.PromptCharm () ]
)
return self._add_selection ( 'DiCharm_Selection' , sel )
def makeEE(
name,
#
Both_PT,
Both_P,
Both_TRCHI2DOF,
Both_MIPCHI2,
#
Tag_PT,
Tag_P,
Tag_PIDe,
Tag_MIPCHI2,
#
Probe_PT,
Probe_P,
Probe_MIPCHI2,
#
eeCombMinMass,
eeCombMaxMass,
eeVCHI2PDOF,
eeMinMass,
eeMaxMass,
#
eeFDCHI2,
eeVZ):
_StdNoPIDsDownElectrons = DataOnDemand(
Location='Phys/StdNoPIDsDownElectrons/Particles')
InAccCuts = "(0.5<PPINFO(LHCb.ProtoParticle.InAccEcal,-1))"
BothCuts = "(PT> %(Both_PT)s *MeV)"\
" & (TRCHI2DOF < %(Both_TRCHI2DOF)s)"\
" & (MINTREE('e+'==ABSID,MIPCHI2DV(PRIMARY))> %(Both_MIPCHI2)s )" % locals()
EEComCut = "(in_range(%(eeCombMinMass)s *MeV, AM, %(eeCombMaxMass)s *MeV))" % locals(
)
EEMomCut = "(VFASPF(VCHI2)< %(eeVCHI2PDOF)s)"\
" & (in_range(%(eeMinMass)s *MeV, MM, %(eeMaxMass)s *MeV))"\
" & (BPVVDCHI2>%(eeFDCHI2)s)"\
" & (VFASPF(VZ)>%(eeVZ)s *mm)" % locals()
Tag1Cuts = "(CHILDCUT((PT>%(Tag_PT)s*MeV),1)) & (CHILDCUT((PIDe>%(Tag_PIDe)s),1)) & (CHILDCUT((P>%(Tag_P)s*MeV),1))"\
" & (CHILDCUT((MIPCHI2DV(PRIMARY)> %(Tag_MIPCHI2)s),1))" % locals()
Tag2Cuts = "(CHILDCUT((PT>%(Tag_PT)s*MeV),2)) & (CHILDCUT((PIDe>%(Tag_PIDe)s),2)) & (CHILDCUT((P>%(Tag_P)s*MeV),2))"\
" & (CHILDCUT((MIPCHI2DV(PRIMARY)> %(Tag_MIPCHI2)s),2))" % locals()
Probe1Cuts = "(CHILDCUT((PT>%(Probe_PT)s*MeV),1)) & (CHILDCUT((P>%(Probe_P)s*MeV),1))"\
" & (CHILDCUT((MIPCHI2DV(PRIMARY)> %(Probe_MIPCHI2)s),1))" % locals()
Probe2Cuts = "(CHILDCUT((PT>%(Probe_PT)s*MeV),2)) & (CHILDCUT((P>%(Probe_P)s*MeV),2))"\
" & (CHILDCUT((MIPCHI2DV(PRIMARY)> %(Probe_MIPCHI2)s),2))" % locals()
Tag1Probe2Cuts = Tag1Cuts + " & " + Probe2Cuts
Tag2Probe1Cuts = Tag2Cuts + " & " + Probe1Cuts
_EE = CombineParticles(DecayDescriptor="J/psi(1S) -> e+ e-",
DaughtersCuts={"e+": InAccCuts + "&" + BothCuts},
CombinationCut=EEComCut,
MotherCut=EEMomCut + " & ( ( " + Tag1Probe2Cuts +
" ) | (" + Tag2Probe1Cuts + " ) ) ")
return Selection(name,
Algorithm=_EE,
RequiredSelections=[_StdNoPIDsDownElectrons])
def _Bs2PhiPhi_X_Line( self, name, config, wide ) :
Phi2KK_DC = "(TRGHOSTPROB < 0.5) & (PT>%(KaonPT)s*MeV)&(MIPCHI2DV(PRIMARY)>%(KaonIPCHI2)s)" % config
Phi2KK_CC = "(AM<(%(PhiMassMax)s+30)*MeV)" % config
#Phi2KK_CC = "(AM<(%(PhiMassMax)s+30)*MeV)&(ADOCACHI2CUT(40, ''))" % config
Phi2KK_MassCut = ""
if wide == False :
Phi2KK_MassCut = "&(ADMASS('phi(1020)')<%(PhiMassWindow)s*MeV)" % config
else :
Phi2KK_MassCut = "&(MM<%(PhiMassMax)s*MeV)" % config
Phi2KK_MC = "(VFASPF(VCHI2/VDOF)<%(PhiVertexCHI2pDOF)s)" % config + Phi2KK_MassCut
Bs2PhiPhi_DC = "(PT>%(PhiPT)s*MeV)" % config
Bs2PhiPhi_CC = "(ADAMASS('B_s0')<((%(BsMassWindow)s+30)*MeV))&(ACHILD(PT,1)*ACHILD(PT,2)>%(PhiPTsq)s*GeV*GeV)" % config
Bs2PhiPhi_MC = "(BPVDIRA > 0.999) & (VFASPF(VCHI2/VDOF)<%(BsVertexCHI2pDOF)s)&(ADMASS('B_s0')<%(BsMassWindow)s*MeV)" % config
ps = 1.0
if wide == True :
ps = config['WidePrescale']
#print "Cuts for "+name+"Line"
#print Phi2KK_DC
#print Phi2KK_CC
#print Phi2KK_MC
#print Bs2PhiPhi_DC
#print Bs2PhiPhi_CC
#print Bs2PhiPhi_MC
#print "Prescale: ", ps
#_stdLooseKaons = DataOnDemand(Location = "Phys/StdLooseKaons/Particles")
_Bs2PhiPhiLooseDetachedPhi2KK = CombineParticles(
DecayDescriptor = "phi(1020) -> K+ K-"
, DaughtersCuts = {"K+": Phi2KK_DC}
, CombinationCut = Phi2KK_CC
, MotherCut = Phi2KK_MC
)
_Bs2PhiPhi = CombineParticles(
DecayDescriptor = "B_s0 -> phi(1020) phi(1020)"
, DaughtersCuts = {"phi(1020)" : Bs2PhiPhi_DC}
, CombinationCut = Bs2PhiPhi_CC
, MotherCut = Bs2PhiPhi_MC
)
Bs2PhiPhiLooseDetachedPhi2KK = Selection(
name+ "_LoosePhi2KK",
Algorithm = _Bs2PhiPhiLooseDetachedPhi2KK,
RequiredSelections = [MyLooseKaons])
Bs2PhiPhi = Selection(
name,
Algorithm = _Bs2PhiPhi,
RequiredSelections = [Bs2PhiPhiLooseDetachedPhi2KK])
if wide == True:
return StrippingLine(name+"Line"
, prescale = ps
, postscale = 1
, selection = Bs2PhiPhi
, EnableFlavourTagging = True,
RelatedInfoTools = [
{ "Type" : "RelInfoConeVariables",
"ConeAngle" : 0.8,
"Variables" : ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'],
'RecursionLevel' : 2,
"Locations" : {'Phys/StdAllLooseANNKaons' : ['P2ConeVar08_1','P2ConeVar08_2','P2ConeVar08_3','P2ConeVar08_4'] } },
{ "Type" : "RelInfoConeVariables",
"ConeAngle" : 1.0,
"Variables" : ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'],
'RecursionLevel' : 2,
"Locations" : {'Phys/StdAllLooseANNKaons' : ['P2ConeVar10_1','P2ConeVar10_2','P2ConeVar10_3','P2ConeVar10_4'] } },
{ "Type" : "RelInfoConeVariables",
"ConeAngle" : 1.3,
"Variables" : ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'],
'RecursionLevel' : 2,
"Locations" : {'Phys/StdAllLooseANNKaons' : ['P2ConeVar13_1','P2ConeVar13_2','P2ConeVar13_3','P2ConeVar13_4'] } },
{ "Type" : "RelInfoConeVariables",
"ConeAngle" : 1.7,
"Variables" : ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'],
'RecursionLevel' : 2,
"Locations" : {'Phys/StdAllLooseANNKaons' : ['P2ConeVar17_1','P2ConeVar17_2','P2ConeVar17_3','P2ConeVar17_4'] } },
{ "Type" : "RelInfoVertexIsolation", "Location" : "VertexIsoInfo" } ]
)
else:
return StrippingLine(name+"Line"
, prescale = ps
, postscale = 1
, selection = Bs2PhiPhi
, EnableFlavourTagging = True
, RequiredRawEvents = ['Trigger', 'Muon', 'Calo', 'Rich', 'Velo', 'Tracker'])
def psi_Kst ( self ) :
"""
This is just a control line to study
the reconstruction efficiency for pi0 and gamma
see LHCb-INT-2012-001
"""
sel = self._selection ( 'PsiK*+_Selection')
if sel : return sel
alg = CombineParticles (
##
DecayDescriptors = [
"[B+ -> J/psi(1S) K+ pi0 ]cc" ,
] ,
##
DaughtersCuts = {
'J/psi(1S)' : " M < 3.3 * GeV " , ## keep only J/psi
## 'pi0' : """
## ( abs ( LV01 ) < 0.9 ) &
## ( MINTREE ( 'gamma' == ID , PT ) > 250 * MeV )
## """ ,
} ,
##
Preambulo = self['Preambulo'] ,
##
CombinationCut = """
in_range ( 4.95 * GeV , AM , 5.75 * GeV ) &
in_range ( 750 * MeV , AM23 , 1050 * MeV ) &
( APT23 > 1.5 * GeV )
""" ,
##
MotherCut = """
in_range ( 5.0 * GeV , M , 5.7 * GeV ) &
( chi2vx < 16 ) &
( ctau_9 > %s )
""" % self['CTAU_Kst'] ,
##
ParticleCombiners = {'' : "LoKi::VertexFitter" }
)
#
sel_ = Selection (
"SelPrePsiK*+For" + self.name () ,
Algorithm = alg ,
RequiredSelections = [ self.psi () ,
self.kaons () ,
self.pi0s () ]
)
tag = Pi0Veto__Tagger2g (
MassWindow = 25 * MeV ,
MassChi2 = -1 ,
ExtraInfoIndex = 25020 ## unique !
)
sel = Selection (
"SelPsiK*+For" + self.name () ,
Algorithm = tag ,
RequiredSelections = [ sel_ ]
)
return self._add_selection( 'PsiK*+_Selection' , sel )
