def makeD2MuMuMuMu(name, inputSel):
"""
D --> 4 mu selection
"""
from Configurables import OfflineVertexFitter
D2MuMuMuMu = CombineParticles("Combine" + name)
D2MuMuMuMu.DecayDescriptor = "D0 -> mu+ mu- mu+ mu-"
D2MuMuMuMu.addTool(OfflineVertexFitter)
D2MuMuMuMu.ParticleCombiners.update({"": "OfflineVertexFitter"})
D2MuMuMuMu.DaughtersCuts = { "mu+" : "(TRCHI2DOF < 3.0 ) "\
" & (MIPCHI2DV(PRIMARY)> 4.)"\
" & (TRGHOSTPROB<0.3) "\
" & (P> 3000.*MeV)"}
D2MuMuMuMu.CombinationCut = "(ADAMASS('D0')<300*MeV) "\
"& (AMAXDOCA('')<0.2*mm) "
D2MuMuMuMu.MotherCut = "(VFASPF(VCHI2/VDOF)<12.) "\
"& (BPVVDZ > 0.) " \
"& (MIPCHI2DV(PRIMARY) < 25. )"
return Selection(name, Algorithm=D2MuMuMuMu, RequiredSelections=inputSel)
def makeBu(name):
"""
detached Bu-->JPsiK selection. Selection is aligned to the Bs2MuMu
selection.
Please contact Johannes Albrecht if you think of prescaling this line!
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
SelDJPsi = makeDetachedJPsi(name)
PreselBu2JPsiKCommon = CombineParticles("PreselBu2JPsiKCommon")
PreselBu2JPsiKCommon.DecayDescriptor = " [B+ -> J/psi(1S) K+]cc "
PreselBu2JPsiKCommon.addTool(OfflineVertexFitter())
PreselBu2JPsiKCommon.VertexFitters.update({"": "OfflineVertexFitter"})
PreselBu2JPsiKCommon.OfflineVertexFitter.useResonanceVertex = False
PreselBu2JPsiKCommon.ReFitPVs = True
PreselBu2JPsiKCommon.DaughtersCuts = {
"K+":
"(ISLONG) & (TRCHI2DOF < 5 ) &(MIPCHI2DV(PRIMARY)>25)& (PT>250*MeV) "
}
PreselBu2JPsiKCommon.CombinationCut = "(ADAMASS('B+') < 500*MeV)"
PreselBu2JPsiKCommon.MotherCut = "(BPVIPCHI2()< 25)& (VFASPF(VCHI2)<45) "
_kaons = DataOnDemand(Location='Phys/StdNoPIDsKaons/Particles')
return Selection("SelBu2JPsiK",
Algorithm=PreselBu2JPsiKCommon,
RequiredSelections=[SelDJPsi, _kaons])
def makeTau2pmm(name):
"""
Please contact Jon Harrison if you think of prescaling this line!
Arguments:
name : name of the Selection.
"""
Tau2PMuMu = CombineParticles("Comine" + name)
Tau2PMuMu.DecayDescriptors = [
" [ tau+ -> p+ mu+ mu- ]cc", " [ tau+ -> p~- mu+ mu+ ]cc",
" [ Lambda_c+ -> p+ mu+ mu- ]cc", " [ Lambda_c+ -> p~- mu+ mu+ ]cc"
]
Tau2PMuMu.DaughtersCuts = { "mu+" : " ( PT > 300 * MeV ) & ( TRCHI2DOF < 3 ) & ( BPVIPCHI2 () > 9 ) "\
"& ( PIDmu > -5 ) & ( (PIDmu - PIDK) > 0 ) & ( TRGHOSTPROB < 0.3 )",
"p+" : " ( PT > 300 * MeV ) & ( TRCHI2DOF < 3 ) & ( BPVIPCHI2 () > 9 ) "\
"& (PIDp>10) & ( TRGHOSTPROB < 0.3 )"}
Tau2PMuMu.CombinationCut = "( (ADAMASS('tau+')<150*MeV) | (ADAMASS('Lambda_c+')<150*MeV) )"
Tau2PMuMu.MotherCut = """
( VFASPF(VCHI2) < 15 ) &
( (BPVLTIME () * c_light) > 100 * micrometer ) &
( BPVIPCHI2() < 225 )
"""
_stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles")
_stdLooseProtons = DataOnDemand(Location="Phys/StdLooseProtons/Particles")
return Selection(name,
Algorithm=Tau2PMuMu,
RequiredSelections=[_stdLooseMuons, _stdLooseProtons])
def makeNoMuID(name, mupt=0, kspt=0):
"""
default K0s2mumu selection object
starts from Phys/StdNoPIDsMuons
Please contact Diego Martinez Santos if you think of prescaling this line!
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
K0s2MuMuNoMuID = CombineParticles("Comine" + name)
K0s2MuMuNoMuID.DecayDescriptor = "KS0 -> pi+ pi-"
# Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:
K0s2MuMuNoMuID.addTool(OfflineVertexFitter)
K0s2MuMuNoMuID.ParticleCombiners.update({"": "OfflineVertexFitter"})
K0s2MuMuNoMuID.OfflineVertexFitter.useResonanceVertex = False
K0s2MuMuNoMuID.ReFitPVs = True
K0s2MuMuNoMuID.DaughtersCuts = {
"pi+":
"(MIPCHI2DV(PRIMARY)> 100.)&(TRCHI2DOF < 5 ) & (PT >" + str(mupt) +
" * MeV )"
}
K0s2MuMuNoMuID.CombinationCut = "(ADAMASS('KS0')<100*MeV)"\
"& (AMAXDOCA('')<0.3*mm)"
K0s2MuMuNoMuID.MotherCut = "((BPVDIRA>0) & ((BPVVDSIGN*M/P) > 0.1*89.53*2.9979e-01) & (MIPDV(PRIMARY)<0.4*mm) & (M>400) & (M<600) & (PT > " + str(
kspt) + " * MeV))"
_stdNoPIDsPions = DataOnDemand(Location="Phys/StdNoPIDsPions/Particles")
return Selection(name,
Algorithm=K0s2MuMuNoMuID,
RequiredSelections=[_stdNoPIDsPions])
def makeJetGroup(self, name, config):
JetGroup = CombineParticles("Combine" + name)
JetGroup.DecayDescriptor = "H_10 -> CELLjet CELLjet"
JetGroup.ParticleCombiners = {"": "LoKi::VertexFitter"}
JetGroup.addTool(LoKi__VertexFitter, name="LoKi::VertexFitter")
vfitter = getattr(JetGroup, "LoKi::VertexFitter")
vfitter.Jets = ""
JetGroup.DaughtersCuts = {
"CELLjet": " (PT > %(min_jet_pT)s ) " % config
}
JetGroup.CombinationCut = "AALLSAMEBPV "
JetGroup.MotherCut = "ALL"
## TOS_HLT2 on-demand
hlt = config['TOS_HLT2']
if hlt:
JetGroup.MotherCut += '& (TOS("%s", "Hlt2TriggerTisTos"))' % hlt
requiredSelections = [DataOnDemand(Location="Phys/StdJets/Particles")]
return Selection("Sel" + name,
Algorithm=JetGroup,
RequiredSelections=requiredSelections)
def makeBs2D0KS0(name,BIPCHI2,BVCHI2,BPVDLS,BsCombMassMin,BsCombMassMax,BsMassMin,BsMassMax,D0MassMin,D0MassMax,DTF_CHI2NDOF):
"""
Create and return a Bs -> D0 KS selection
"""
SelStdLooseKsDD = DataOnDemand(Location = 'Phys/StdLooseKsDD/Particles')
SelStdLooseKsLL = DataOnDemand(Location = 'Phys/StdLooseKsLL/Particles')
SelStdLooseKs = MergedSelection("KSFor"+name, RequiredSelections = [ SelStdLooseKsDD, SelStdLooseKsLL ] )
SelStdLooseD0 = DataOnDemand(Location = 'Phys/StdLooseD02KPi/Particles')
_motherCuts = "(VFASPF(VCHI2/VDOF) < %(BVCHI2)s)" \
"& (BPVDLS > %(BPVDLS)s)" \
"& (M > %(BsMassMin)s*MeV)" \
"& (M < %(BsMassMax)s*MeV)" \
"& (BPVIPCHI2() < %(BIPCHI2)s)" \
"& (DTF_CHI2NDOF(True) < %(DTF_CHI2NDOF)s)" % locals()
_combinationCut = "(AM > %(BsCombMassMin)s*MeV)" \
"& (AM < %(BsCombMassMax)s*MeV)" % locals()
_daughterCut = "(M > %(D0MassMin)s*MeV)" \
"& (M < %(D0MassMax)s*MeV)" \
"& (MAXTREE(ABSID=='K+',PIDK) > 0)" % locals()
_Bs = CombineParticles('_'+name)
_Bs.DecayDescriptor = "B0 -> D0 KS0"
_Bs.CombinationCut = _combinationCut
_Bs.MotherCut = _motherCuts
_Bs.DaughtersCuts = {"D0" : _daughterCut}
return Selection ( name,
Algorithm = _Bs,
RequiredSelections = [SelStdLooseD0,SelStdLooseKs])
def makeB2pMu(name):
"""
Please contact Johannes Albrecht if you think of prescaling this line!
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
Bs2pMu = CombineParticles("Combine" + name)
Bs2pMu.DecayDescriptor = "[B_s0 -> p+ mu-]cc"
#Bs2pMu.addTool( OfflineVertexFitter )
#Bs2pMu.VertexFitters.update( { "" : "OfflineVertexFitter"} )
#Bs2pMu.OfflineVertexFitter.useResonanceVertex = False
#Bs2pMu.ReFitPVs = True
Bs2pMu.DaughtersCuts = {
"mu+": "(MIPCHI2DV(PRIMARY)> 25.)&(TRCHI2DOF < 4 )",
"p+": "(MIPCHI2DV(PRIMARY)> 25.)&(TRCHI2DOF < 4 )"
}
Bs2pMu.CombinationCut = "(ADAMASS('B_s0')<600*MeV)"\
"& (AMAXDOCA('')<0.3*mm)"
Bs2pMu.MotherCut = "(VFASPF(VCHI2/VDOF)<9) "\
"& (ADMASS('B_s0') < 600*MeV )"\
"& (BPVDIRA > 0) "\
"& (BPVVDCHI2> 225)"\
"& (BPVIPCHI2()< 25) "
_stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles")
_stdLooseProtons = DataOnDemand(Location="Phys/StdLooseProtons/Particles")
return Selection(name,
Algorithm=Bs2pMu,
RequiredSelections=[_stdLooseMuons, _stdLooseProtons])
def makeDetachedJPsiLoose(name):
"""
loose detached JPsi selection to monitor selection,
systematics from cuts, etc.
prescaled
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
DetachedJPsiLoose = CombineParticles("Combine" + name)
DetachedJPsiLoose.DecayDescriptor = "J/psi(1S) -> mu+ mu-"
# Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:
DetachedJPsiLoose.addTool(OfflineVertexFitter())
DetachedJPsiLoose.VertexFitters.update({"": "OfflineVertexFitter"})
DetachedJPsiLoose.OfflineVertexFitter.useResonanceVertex = False
DetachedJPsiLoose.ReFitPVs = True
DetachedJPsiLoose.DaughtersCuts = { "mu+" : "(TRCHI2DOF < 10 ) "\
"& (MIPCHI2DV(PRIMARY)> 9.)"}
DetachedJPsiLoose.CombinationCut = "(ADAMASS('J/psi(1S)')<120*MeV) "\
"& (AMAXDOCA('')<0.5*mm)"
DetachedJPsiLoose.MotherCut = "(VFASPF(VCHI2)<25) "\
"& (ADMASS('J/psi(1S)') < 120*MeV )"\
"& (BPVDIRA > 0) "\
"& (BPVVDCHI2>100)"
_stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles")
return Selection(name,
Algorithm=DetachedJPsiLoose,
RequiredSelections=[_stdLooseMuons])
def makePromptJPsi(name):
"""
Prompt variant of the detached JPsi selection for
B--> JPsi X calibration and normalization channels.
Selection is aligned to the Bs2MuMu selection.
heavily prescaled
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
PromptJPsi = CombineParticles("Combine" + name)
PromptJPsi.DecayDescriptor = "J/psi(1S) -> mu+ mu-"
# Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:
PromptJPsi.addTool(OfflineVertexFitter())
PromptJPsi.VertexFitters.update({"": "OfflineVertexFitter"})
PromptJPsi.OfflineVertexFitter.useResonanceVertex = False
PromptJPsi.ReFitPVs = True
PromptJPsi.DaughtersCuts = {"mu+": "(TRCHI2DOF < 4 ) "}
PromptJPsi.CombinationCut = "(ADAMASS('J/psi(1S)')<100*MeV) "\
"& (AMAXDOCA('')<0.3*mm)"
PromptJPsi.MotherCut = "(VFASPF(VCHI2)<15) "\
"& (ADMASS('J/psi(1S)') < 100*MeV )"
_stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles")
return Selection(name,
Algorithm=PromptJPsi,
RequiredSelections=[_stdLooseMuons])
def makeD2MuMuMuMu(name):
"""
D --> 4 mu selection
should become inclusive bb-->4 mu selection ??
"""
from Configurables import OfflineVertexFitter
D2MuMuMuMu = CombineParticles("Combine" + name)
D2MuMuMuMu.DecayDescriptor = "D0 -> mu+ mu- mu+ mu-"
# Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:
D2MuMuMuMu.addTool(OfflineVertexFitter())
D2MuMuMuMu.VertexFitters.update({"": "OfflineVertexFitter"})
D2MuMuMuMu.OfflineVertexFitter.useResonanceVertex = False
D2MuMuMuMu.ReFitPVs = True
D2MuMuMuMu.DaughtersCuts = { "mu+" : "(TRCHI2DOF < 5 ) "\
" & (MIPCHI2DV(PRIMARY)> 9.)"}
D2MuMuMuMu.CombinationCut = "(ADAMASS('D0')<1000*MeV) "\
"& (AMAXDOCA('')<0.3*mm) "
D2MuMuMuMu.MotherCut = "(VFASPF(VCHI2/VDOF)<10) "\
"& (BPVDIRA > 0.9998) "\
"& (BPVVDCHI2>48.)"\
" & (M>864.83) & (M<2868.47)"\
"& (BPVIPCHI2()< 30) "
_stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles")
return Selection(name,
Algorithm=D2MuMuMuMu,
RequiredSelections=[_stdLooseMuons])
def makeDefault(name,inputSel) :
"""
B --> 4 mu selection
should become inclusive bb-->4 mu selection ??
"""
from Configurables import OfflineVertexFitter
Detached4mu = CombineParticles("Combine"+name)
Detached4mu.DecayDescriptor = "B_s0 -> mu+ mu- mu+ mu-"
# Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:
Detached4mu.addTool( OfflineVertexFitter )
Detached4mu.ParticleCombiners.update( { "" : "OfflineVertexFitter"} )
Detached4mu.OfflineVertexFitter.useResonanceVertex = False
Detached4mu.ReFitPVs = True
Detached4mu.DaughtersCuts = { "mu+" : "(TRCHI2DOF < 2.5 ) "\
" & (MIPCHI2DV(PRIMARY)> 9.)"}
Detached4mu.CombinationCut = "(ADAMASS('B_s0')<1000*MeV) "\
"& (AMAXDOCA('')<0.3*mm)"
Detached4mu.MotherCut = "(VFASPF(VCHI2/VDOF)<9) "\
"& (BPVDIRA > 0) "\
"& (BPVVDCHI2>100)"\
" & (M>4366.3) & (M<6366.3)"\
"& (BPVIPCHI2()< 25) "
return Selection (name,
Algorithm = Detached4mu,
RequiredSelections = inputSel)
def makeB2TauMu(name):
"""
Please contact Johannes Albrecht if you think of prescaling this line!
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
Bs2TauMu = CombineParticles("Combine"+name)
Bs2TauMu.DecayDescriptors = ["[B_s0 -> tau+ mu-]cc","[B_s0 -> tau+ mu+]cc"]
# Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:
Bs2TauMu.addTool( OfflineVertexFitter )
Bs2TauMu.ParticleCombiners.update( { "" : "OfflineVertexFitter"} )
Bs2TauMu.OfflineVertexFitter.useResonanceVertex = False
#Bs2TauMu.ReFitPVs = True
Bs2TauMu.DaughtersCuts = { "mu+" : "(MIPCHI2DV(PRIMARY)> 25.)&(TRCHI2DOF < 3 ) & (TRGHOSTPROB<0.3)"}
Bs2TauMu.CombinationCut = "(ADAMASS('B_s0')<1200*MeV)"\
"& (AMAXDOCA('')<0.3*mm)"
Bs2TauMu.MotherCut = "(VFASPF(VCHI2/VDOF)<9) "\
"& (ADMASS('B_s0') < 1200*MeV )"\
"& (BPVDIRA > 0) "\
"& (BPVVDCHI2> 225)"\
"& (BPVIPCHI2()< 25) "
from CommonParticles import StdLooseDetachedTau, StdLooseDipion
_stdLooseMuons = DataOnDemand(Location = "Phys/StdLooseMuons/Particles")
_stdLooseDetachedTaus= DataOnDemand(Location = "Phys/StdLooseDetachedTau3pi/Particles")
return Selection (name,
Algorithm = Bs2TauMu,
RequiredSelections = [ _stdLooseMuons,_stdLooseDetachedTaus])
def makeXibc2JpsiKp (localname, _RequiredSelections, config=default_config['CONFIG'], controlLine=False):
myXibc = CombineParticles(localname+"Xibc2JpsipK");
myXibc.DecayDescriptor = "[Xi_bc0 -> J/psi(1S) p+ K-]cc"
if (controlLine == True):
myXibc.CombinationCut = ("(AM > %(JpsiKp_MassMin)s ) & "
"(AM < %(JpsiKp_MassLbThreshold)s) " )%config
else:
myXibc.CombinationCut = ("(AM > %(JpsiKp_MassLbThreshold)s ) & "
"(AM < %(JpsiKp_MassMax)s ) " )%config
myXibc.MotherCut = ("(VFASPF(VCHI2/VDOF)< %(JpsiKp_MaxVertexChi2)s) & "
"(BPVLTIME()> %(JpsiKp_MinTAU)s)"
) %config
myXibc.DaughtersCuts = {"J/psi(1S)" : ("(PT > %(JpsiKp_Jpsi_MinPT)s) & "+
"(ADMASS('J/psi(1S)') < %(JpsiKp_Jpsi_MassWin)s) &"+
"(MAXTREE(TRGHP, ISBASIC) < %(JpsiKp_mu_MaxTrackGhostProb)s) &"+
"(MINTREE('mu+'==ABSID,PIDmu) > %(JpsiKp_mu_MinPIDmu)s )" ) %config,
"p+" : ("(PT > %(JpsiKp_p_MinPt)s) &"+
" (PROBNNp > %(JpsiKp_p_MinProbNNp)s) &"+
" (TRGHP < %(JpsiKp_p_MaxTrackGhostProb)s) &" +
" (TRPCHI2 > %(JpsiKp_p_MinTrackPvalue)s) & "+
" (P > %(JpsiKp_p_MinP)s )" ) %config,
"K-" : ("(PT > %(JpsiKp_K_MinPT)s) &"+
"(PROBNNk > %(JpsiKp_K_MinProbNNk)s) &"+
"(TRGHP < %(JpsiKp_K_MaxTrackGhostProb)s )&" +
"(TRPCHI2 > %(JpsiKp_K_MinTrackPvalue)s) & "+
"(P > %(JpsiKp_K_MinP)s)") %config}
return Selection(localname + "Xibc2JpsipKSel", Algorithm=myXibc,
RequiredSelections = _RequiredSelections)
def makeDs2PhiPi(name, config):
"""
Please contact Johannes Albrecht if you think of prescaling this line!
Arguments:
name : name of the Selection.
"""
Ds2PhiPi = CombineParticles("Comine" + name)
Ds2PhiPi.DecayDescriptor = " [ D_s+ -> pi+ mu+ mu- ]cc "
Ds2PhiPi.DaughtersCuts = {
"pi+":
" ( PT > 300 * MeV ) & ( TRGHOSTPROB < %(TrackGhostProb)s ) & ( TRCHI2DOF < 3 ) & ( BPVIPCHI2 () > 9 ) "
% config,
"mu+":
" ( PT > 300 * MeV ) & ( TRGHOSTPROB < %(TrackGhostProb)s ) & ( TRCHI2DOF < 3 ) & ( BPVIPCHI2 () > 9 ) "
% config
}
Ds2PhiPi.CombinationCut = "(ADAMASS('D_s+')<250*MeV) & in_range ( 970 * MeV , AM23 , 1070 * MeV )"
Ds2PhiPi.MotherCut = """
( VFASPF(VCHI2) < 15 ) &
( (BPVLTIME () * c_light) >100 * micrometer ) &
( BPVIPCHI2() < 225 )
"""
_stdLoosePions = DataOnDemand(Location="Phys/StdLoosePions/Particles")
_stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles")
return Selection(name,
Algorithm=Ds2PhiPi,
RequiredSelections=[_stdLooseMuons, _stdLoosePions])
def makeBd2InflatonKst(name, SelInflatonLong):
"""
detached Bd -> Inflaton K* selection.
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
_kstar = DataOnDemand(Location='Phys/StdLooseDetachedKst2Kpi/Particles')
Bd2InflatonKst = CombineParticles("Combine" + name)
Bd2InflatonKst.DecayDescriptor = "[B0 -> KS0 K*(892)0]cc"
Bd2InflatonKst.addTool(OfflineVertexFitter)
#Bd2InflatonKst.VertexFitters.update( { "" : "OfflineVertexFitter"} )
Bd2InflatonKst.ParticleCombiners.update({"": "OfflineVertexFitter"})
Bd2InflatonKst.OfflineVertexFitter.useResonanceVertex = False
Bd2InflatonKst.ReFitPVs = True
Bd2InflatonKst.DaughtersCuts = {"K*(892)0": "MIPCHI2DV(PRIMARY)> 25."}
Bd2InflatonKst.CombinationCut = "(ADAMASS('B0') < 500*MeV)"
Bd2InflatonKst.MotherCut = "(BPVIPCHI2()< 50) & (VFASPF(VCHI2)<100)& (D2DVVDDOT(1) > 0.3*mm)"
return Selection("Sel" + name,
Algorithm=Bd2InflatonKst,
RequiredSelections=[SelInflatonLong, _kstar])
def makeTau23Mu(name, config):
"""
Please contact Johannes Albrecht if you think of prescaling this line!
Arguments:
name : name of the Selection.
"""
Tau2MuMuMu = CombineParticles("Comine" + name)
Tau2MuMuMu.DecayDescriptor = " [ tau+ -> mu+ mu+ mu- ]cc"
Tau2MuMuMu.DaughtersCuts = { "mu+" : " ( PT > 300 * MeV ) & ( TRGHOSTPROB < %(TrackGhostProb)s ) & ( TRCHI2DOF < 3 ) "\
"& ( BPVIPCHI2 () > 9 ) " % config}
Tau2MuMuMu.CombinationCut = "(ADAMASS('tau+')<400*MeV)"
Tau2MuMuMu.MotherCut = """
( VFASPF(VCHI2) < 15 ) &
( (BPVLTIME () * c_light) > 100 * micrometer ) &
( BPVIPCHI2() < 225 )
"""
_stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles")
return Selection(name,
Algorithm=Tau2MuMuMu,
RequiredSelections=[_stdLooseMuons])
def makeLambdac (localname, _RequiredSelections, config=default_config):
_lambdacCP = CombineParticles(localname+"lambdacAlgorithm")
_lambdacCP.DecayDescriptor = "[Lambda_c+ -> p+ pi+ K-]cc"
_lambdacCP.DaughtersCuts = {
"p+" : ("(TRPCHI2 > %(Protons4Lambdac_TRPCHI2)s) & " +
" (PIDp > %(Protons4Lambdac_PIDp)s) & " +
" (PT > %(Protons4Lambdac_PT)s) & " +
" (P > %(Protons4Lambdac_minP)s) & " +
" (PIDp - PIDK > %(Protons4Lambdac_PIDp-PIDK)s)" ) % config,
"K-" : ("(TRPCHI2 > %(Kaon4Lambdac_TRPCHI2)s) &"+
"(PIDK > %(Kaon4Lambdac_PIDK)s) & "+
"(P > %(Kaon4Lambdac_minP)s) & "+
"(PT > %(Kaon4Lambdac_PT)s)" ) % config,
"pi+" : ("(MIPCHI2DV(PRIMARY)> %(Pions4Lambdac_MINIPCHI2)s) &"+
" (TRPCHI2 > %(Pion4Lambdac_TRPCHI2)s) &"+
" (PIDK < %(Pion4Lambdac_PIDK)s) &"+
"(PT > %(Pion4Lambdac_PT)s)") % config
}
_lambdacCP.CombinationCut = ("(ADAMASS('Lambda_c+') < %(Lambdac_MassWindowLarge)s) & " +
"(APT > %(Lambdac_MinAPT)s) & " +
"(ADOCAMAX('') < %(Lambdac_MaxADOCA)s)"
) % config
_lambdacCP.MotherCut = ("(VFASPF(VCHI2/VDOF) < %(Lambdac_ENDVERTEXCHI2)s) & "+
"(ADMASS('Lambda_c+') < %(Lambdac_MassWindowTight)s) & "+
"(BPVDIRA > %(Lambdac_BPVDIRA)s) & "+
"(BPVLTIME('PropertimeFitter/properTime:PUBLIC')>%(Lambdac_minTAU)s)"
) % config
return Selection (name = localname + 'LcSelection', Algorithm=_lambdacCP,
RequiredSelections = _RequiredSelections);
def SelWDiJets(name, conf, desc, sel_W, TOS_HLT2=None):
"""
Create the combination of W + DiJets
"""
## Create CombineParticle, with caveat on jet combining.
DiJet = CombineParticles("Combine" + name)
DiJet.ParticleCombiners = {"": "LoKi::VertexFitter"}
DiJet.addTool(LoKi__VertexFitter, name="LoKi::VertexFitter")
vfitter = getattr(DiJet, "LoKi::VertexFitter")
vfitter.Jets = ""
## Apply cuts, with TOS optionally
# Asking AT LEAST one of the jet to be TOSed by given trigger.
ccut = "AALLSAMEBPV "\
"& ( dr_13 > %(dr_lepton_jet)s )"\
"& ( dr_23 > %(dr_lepton_jet)s )" %conf
if TOS_HLT2:
cut_tos = "(TOS('%s','Hlt2TriggerTisTos'))" % TOS_HLT2
cut_tosjet = '(ACHILDCUT({0}, 1) | ACHILDCUT({0}, 2))'.format(cut_tos)
ccut += ('&' + cut_tosjet)
DiJet.Preambulo = preambulo
DiJet.DecayDescriptor = desc
DiJet.DaughtersCuts = {"CELLjet": "(PT > %(min_jet_pT)s)" % conf}
DiJet.CombinationCut = ccut
DiJet.MotherCut = "ALL"
return Selection(name,
Algorithm=DiJet,
RequiredSelections=[sel_W, StdJets])
def makeB2ee(name):
"""
Please contact Johannes Albrecht if you think of prescaling this line!
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
Bs2ee = CombineParticles("Combine" + name)
Bs2ee.DecayDescriptor = "B_s0 -> e+ e-"
# Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:
Bs2ee.addTool(OfflineVertexFitter)
Bs2ee.ParticleCombiners.update({"": "OfflineVertexFitter"})
Bs2ee.OfflineVertexFitter.useResonanceVertex = False
#Bs2ee.ReFitPVs = True
Bs2ee.DaughtersCuts = {"e+": "(MIPCHI2DV(PRIMARY)> 25.)&(TRCHI2DOF < 4 )"}
Bs2ee.CombinationCut = "(ADAMASS('B_s0')<1200*MeV)"\
"& (AMAXDOCA('')<0.3*mm)"
Bs2ee.MotherCut = "(VFASPF(VCHI2/VDOF)<9) "\
"& (ADMASS('B_s0') < 1200*MeV )"\
"& (BPVDIRA > 0) "\
"& (BPVVDCHI2> 225)"\
"& (BPVIPCHI2()< 25) "
_stdLooseElectrons = DataOnDemand(
Location="Phys/StdLooseElectrons/Particles")
return Selection(name,
Algorithm=Bs2ee,
RequiredSelections=[_stdLooseElectrons])
def makeBd2InflatonRho(name, SelInflatonLong, SelRho) :
"""
detached Bd -> Inflaton rho selection.
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
Bd2InflatonRho = CombineParticles("Combine"+name)
Bd2InflatonRho.DecayDescriptor = "B0 -> KS0 rho(770)0"
Bd2InflatonRho.addTool( OfflineVertexFitter )
#Bd2InflatonRho.VertexFitters.update( { "" : "OfflineVertexFitter"} )
Bd2InflatonRho.ParticleCombiners.update( { "" : "OfflineVertexFitter"} )
Bd2InflatonRho.OfflineVertexFitter.useResonanceVertex = False
Bd2InflatonRho.ReFitPVs = True
Bd2InflatonRho.DaughtersCuts = { "rho(770)0" : "MIPCHI2DV(PRIMARY)> 25."}
Bd2InflatonRho.CombinationCut = "(ADAMASS('B0') < 500*MeV)"
Bd2InflatonRho.MotherCut = "(BPVIPCHI2()< 50) & (VFASPF(VCHI2)<100)& (D2DVVDDOT(1) > 0.3*mm)"
return Selection( "Sel"+name,
Algorithm = Bd2InflatonRho,
RequiredSelections=[SelInflatonLong, SelRho] )
def makeDetachedJPsi(name):
"""
detached JPsi selection for B--> JPsi X calibration and
normalization channels.
Please contact Flavio Archilli if you think of prescaling this line!
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
DetachedJPsi = CombineParticles("Combine" + name)
DetachedJPsi.DecayDescriptor = "J/psi(1S) -> e+ e-"
DetachedJPsi.addTool(OfflineVertexFitter)
DetachedJPsi.ParticleCombiners.update({"": "OfflineVertexFitter"})
DetachedJPsi.OfflineVertexFitter.useResonanceVertex = False
DetachedJPsi.ReFitPVs = True
DetachedJPsi.DaughtersCuts = { "e+" : "(TRCHI2DOF < 4 ) "\
"& (MIPCHI2DV(PRIMARY)> 25.) "\
"& (PIDe > 2) "}
DetachedJPsi.CombinationCut = "(ADAMASS('J/psi(1S)')<1000*MeV) "\
"& (AMAXDOCA('')<0.3*mm)"
DetachedJPsi.MotherCut = "(VFASPF(VCHI2)<9) "\
"& (ADMASS('J/psi(1S)') < 1000*MeV )"\
"& (BPVDIRA > 0) "\
"& (BPVVDCHI2>169)"
_stdLooseElectrons = DataOnDemand(
Location="Phys/StdLooseElectrons/Particles")
return Selection(name,
Algorithm=DetachedJPsi,
RequiredSelections=[_stdLooseElectrons])
def makeDs23Pi(name):
"""
Please contact Johannes Albrecht if you think of prescaling this line!
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
Ds2PiPiPi = CombineParticles("Comine" + name)
Ds2PiPiPi.DecayDescriptor = " [ D_s+ -> pi+ pi+ pi- ]cc "
Ds2PiPiPi.DaughtersCuts = {
"pi+":
" ( PT > 300 * MeV ) & ( TRCHI2DOF < 4 ) & ( BPVIPCHI2 () > 9 ) "
}
Ds2PiPiPi.CombinationCut = "(ADAMASS('D_s+')<80*MeV)"
Ds2PiPiPi.MotherCut = """
( VFASPF(VCHI2) < 15 ) &
( (BPVLTIME () * c_light) > 100 * micrometer ) &
( BPVIPCHI2() < 225 )
"""
_stdLoosePions = DataOnDemand(Location="Phys/StdLoosePions/Particles")
return Selection(name,
Algorithm=Ds2PiPiPi,
RequiredSelections=[_stdLoosePions])
def makeDefault(name) :
"""
default Bs2mumu selection object (tighter selection a la roadmap)
starts from Phys/StdNoPIDsMuons
Please contact Johannes Albrecht if you think of prescaling this line!
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
Bs2MuMuNoMuID = CombineParticles("Comine"+name)
Bs2MuMuNoMuID.DecayDescriptor = "B_s0 -> mu+ mu-"
# Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:
Bs2MuMuNoMuID.addTool( OfflineVertexFitter() )
Bs2MuMuNoMuID.VertexFitters.update( { "" : "OfflineVertexFitter"} )
Bs2MuMuNoMuID.OfflineVertexFitter.useResonanceVertex = False
Bs2MuMuNoMuID.ReFitPVs = True
Bs2MuMuNoMuID.DaughtersCuts = { "mu+" : "(MIPCHI2DV(PRIMARY)> 25.)&(TRCHI2DOF < 4 )" }
Bs2MuMuNoMuID.CombinationCut = "(ADAMASS('B_s0')<600*MeV)"\
"& (AMAXDOCA('')<0.3*mm)"
Bs2MuMuNoMuID.MotherCut = "(VFASPF(VCHI2/VDOF)<9) "\
"& (ADMASS('B_s0') < 600*MeV )"\
"& (BPVDIRA > 0) "\
"& (BPVVDCHI2> 225)"\
"& (BPVIPCHI2()< 25) "
_stdNoPIDsMuons = DataOnDemand(Location = "Phys/StdNoPIDsMuons/Particles")
return Selection (name,
Algorithm = Bs2MuMuNoMuID,
RequiredSelections = [ _stdNoPIDsMuons])
def makeDownstream(name):
"""
very very detached dimuon selection with downstream tracks
"""
from Configurables import OfflineVertexFitter
Detached2mu = CombineParticles("Combine" + name)
Detached2mu.DecayDescriptor = "KS0 -> mu+ mu-"
Detached2mu.addTool(OfflineVertexFitter)
#Detached2mu.VertexFitters.update( { "" : "OfflineVertexFitter"} )
Detached2mu.ParticleCombiners.update({"": "OfflineVertexFitter"})
Detached2mu.OfflineVertexFitter.useResonanceVertex = False
Detached2mu.ReFitPVs = True
Detached2mu.DaughtersCuts = { "mu+" : "(TRCHI2DOF < 4 ) "\
" & (MIPCHI2DV(PRIMARY)> 150)"\
"& (PT > 125*MeV) "\
"& (PIDmu > -4)"}
Detached2mu.CombinationCut = " (AMAXDOCA('')<0.2*mm)"
#"(ADAMASS('B_s0')<1000*MeV) "\
Detached2mu.MotherCut = "(VFASPF(VCHI2/VDOF)<12) "\
"& (M>250)"\
"& (BPVDIRA > 0) "\
"& (BPVVDCHI2>1000)"\
"& (BPVVD>200)"
_stdLooseDownMuons = DataOnDemand(
Location="Phys/StdLooseDownMuons/Particles")
return Selection(name,
Algorithm=Detached2mu,
RequiredSelections=[_stdLooseDownMuons])
def makeBs2mmWide(name):
"""
Bs2mumu selection object (tighter selection a la roadmap)
with muon Id and wide mass window (1.2GeV)
starts from Phys/StdLooseMuons
Please contact Johannes Albrecht if you think of prescaling this line!
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
Bs2MuMuWideMass = CombineParticles("Combine" + name)
Bs2MuMuWideMass.DecayDescriptor = "B_s0 -> mu+ mu-"
Bs2MuMuWideMass.addTool(OfflineVertexFitter())
Bs2MuMuWideMass.VertexFitters.update({"": "OfflineVertexFitter"})
Bs2MuMuWideMass.OfflineVertexFitter.useResonanceVertex = False
Bs2MuMuWideMass.ReFitPVs = True
Bs2MuMuWideMass.DaughtersCuts = {
"mu+": "(MIPCHI2DV(PRIMARY)> 25.)&(TRCHI2DOF < 4 )"
}
Bs2MuMuWideMass.CombinationCut = "(ADAMASS('B_s0')<1200*MeV)"\
"& (AMAXDOCA('')<0.3*mm)"
Bs2MuMuWideMass.MotherCut = "(VFASPF(VCHI2/VDOF)<9) "\
"& (ADMASS('B_s0') < 1200*MeV )"\
"& (BPVDIRA > 0) "\
"& (BPVVDCHI2> 225)"\
"& (BPVIPCHI2()< 25) "
_stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles")
return Selection(name,
Algorithm=Bs2MuMuWideMass,
RequiredSelections=[_stdLooseMuons])
def makeBu2InflatonK(name, SelInflatonLong):
"""
detached Bu -> Inflaton K selection.
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
Bu2InflatonK = CombineParticles("Combine" + name)
Bu2InflatonK.DecayDescriptor = " [B+ -> KS0 K+]cc "
Bu2InflatonK.addTool(OfflineVertexFitter)
#Bu2InflatonK.VertexFitters.update( { "" : "OfflineVertexFitter"} )
Bu2InflatonK.ParticleCombiners.update({"": "OfflineVertexFitter"})
Bu2InflatonK.OfflineVertexFitter.useResonanceVertex = False
Bu2InflatonK.ReFitPVs = True
Bu2InflatonK.DaughtersCuts = {
"K+":
"(ISLONG) & (TRCHI2DOF < 3 ) &(MIPCHI2DV(PRIMARY)>25)& (PT>250*MeV) "
}
Bu2InflatonK.CombinationCut = "(ADAMASS('B+') < 500*MeV)"
Bu2InflatonK.MotherCut = "(BPVIPCHI2()< 50)& (VFASPF(VCHI2)<100)& (D2DVVDDOT(1) > 0.3*mm)"
_kaons = DataOnDemand(Location='Phys/StdLooseKaons/Particles')
return Selection("Sel" + name,
Algorithm=Bu2InflatonK,
RequiredSelections=[SelInflatonLong, _kaons])
def makeDetachedJPsi(name):
"""
detached JPsi selection for B--> JPsi X calibration and
normalization channels. Selection is aligned to the Bs2MuMu
selection.
Please contact Johannes Albrecht if you think of prescaling this line!
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
DetachedJPsi = CombineParticles("Combine" + name)
DetachedJPsi.DecayDescriptor = "J/psi(1S) -> mu+ mu-"
# Set the OfflineVertexFitter to keep the 4 tracks and not the J/Psi Kstar:
DetachedJPsi.addTool(OfflineVertexFitter())
DetachedJPsi.VertexFitters.update({"": "OfflineVertexFitter"})
DetachedJPsi.OfflineVertexFitter.useResonanceVertex = False
DetachedJPsi.ReFitPVs = True
DetachedJPsi.DaughtersCuts = { "mu+" : "(TRCHI2DOF < 4 ) "\
"& (MIPCHI2DV(PRIMARY)> 25.)"}
DetachedJPsi.CombinationCut = "(ADAMASS('J/psi(1S)')<100*MeV) "\
"& (AMAXDOCA('')<0.3*mm)"
DetachedJPsi.MotherCut = "(VFASPF(VCHI2)<9) "\
"& (ADMASS('J/psi(1S)') < 100*MeV )"\
"& (BPVDIRA > 0) "\
"& (BPVVDCHI2>169)"
_stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles")
return Selection(name,
Algorithm=DetachedJPsi,
RequiredSelections=[_stdLooseMuons])
def makeBs2InflatonPhi(name, SelInflatonLong):
"""
detached Bs -> Inflaton Phi selection.
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
_phi = DataOnDemand(Location='Phys/StdLooseDetachedPhi2KK/Particles')
Bs2InflatonPhi = CombineParticles("Combine" + name)
Bs2InflatonPhi.DecayDescriptor = "B_s0 -> KS0 phi(1020)"
Bs2InflatonPhi.addTool(OfflineVertexFitter)
#Bs2InflatonPhi.VertexFitters.update( { "" : "OfflineVertexFitter"} )
Bs2InflatonPhi.ParticleCombiners.update({"": "OfflineVertexFitter"})
Bs2InflatonPhi.OfflineVertexFitter.useResonanceVertex = False
Bs2InflatonPhi.ReFitPVs = True
Bs2InflatonPhi.DaughtersCuts = {"phi(1020)": "MIPCHI2DV(PRIMARY)> 25."}
Bs2InflatonPhi.CombinationCut = "(ADAMASS('B_s0') < 500*MeV)"
Bs2InflatonPhi.MotherCut = "(BPVIPCHI2()< 50)& (VFASPF(VCHI2)<100)& (D2DVVDDOT(1) > 0.3*mm)"
return Selection("Sel" + name,
Algorithm=Bs2InflatonPhi,
RequiredSelections=[SelInflatonLong, _phi])
def makeJPsi2mumu(name, MuonPT, MuonIPCHI2, JPsiPT, JPsiVCHI2):
"""
Create and return a JPsi -> Mu Mu Selection object.
Starts from DataOnDemand 'Phys/StdLooseMuons/Particles'.
Arguments:
name : name of the Selection.
MuonPT : Minimum transverse momentum of Mu (MeV).
MuonIPCHI2 : Minimum impact parameter chi2 of Mu.
JPsiPT : Minimum transverse momentum of JPsi (MeV).
JPsiVCHI2 : Maximum JPsi vertex chi2 per degree of freedom.
"""
MuCuts = "(TRCHI2DOF < 5 )"\
"& (MIPCHI2DV(PRIMARY)> %(MuonIPCHI2)s)"\
"& (PT > %(MuonPT)s *MeV)" % locals()
MotherCuts = "(VFASPF(VCHI2/VDOF)< %(JPsiVCHI2)s)"\
"& (PT > %(JPsiPT)s *MeV)"\
"& (ADMASS('J/psi(1S)') < 100*MeV )" % locals()
_JPsi = CombineParticles("_" + name)
_JPsi.DecayDescriptor = "J/psi(1S) -> mu+ mu-"
_JPsi.DaughtersCuts = {"mu+": MuCuts}
_JPsi.CombinationCut = "(ADAMASS('J/psi(1S)')<100*MeV) "\
"& (AMAXDOCA('')<0.3*mm)"
_JPsi.MotherCut = MotherCuts
_stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles")
return Selection(name,
Algorithm=_JPsi,
RequiredSelections=[_stdLooseMuons])
def makeTau2eMuMu(name):
"""
Please contact Johannes Albrecht if you think of prescaling this line!
Arguments:
name : name of the Selection.
"""
from Configurables import OfflineVertexFitter
Tau2eMuMu = CombineParticles("Comine" + name)
Tau2eMuMu.DecayDescriptors = [
" [ tau+ -> e+ mu+ mu- ]cc", " [ tau+ -> mu+ mu+ e- ]cc"
]
Tau2eMuMu.DaughtersCuts = {
"mu+":
" ( PT > 300 * MeV ) & ( TRCHI2DOF < 4 ) & ( BPVIPCHI2 () > 9 ) ",
"e+":
" ( PT > 300 * MeV ) & ( TRCHI2DOF < 4 ) & ( BPVIPCHI2 () > 9 ) "
}
Tau2eMuMu.CombinationCut = "(ADAMASS('tau+')<200*MeV)"
Tau2eMuMu.MotherCut = """
( VFASPF(VCHI2) < 15 ) &
( (BPVLTIME ( 225 ) * c_light) > 100 * micrometer ) &
( BPVIPCHI2() < 225 )
"""
_stdLooseMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles")
_stdLooseElectrons = DataOnDemand(
Location="Phys/StdLooseElectrons/Particles")
return Selection(name,
Algorithm=Tau2eMuMu,
RequiredSelections=[_stdLooseMuons, _stdLooseElectrons])
def build_mc_unbiased_selection(decayDesc, arrow = '==>') :
preamble = [ "from LoKiPhysMC.decorators import *" , "from LoKiPhysMC.functions import mcMatch" ]
decayDesc.set_carets(False)
decayDescCC = decayDesc.copy()
decayDescCC.cc = True
algname = decayDesc.get_full_alias() + '_MCSel'
if algname in selections :
return selections[algname]
if not decayDesc.daughters :
alg = FilterDesktop(algname + '_Filter')
if decayDesc.particle.name in mcbasicinputs :
inputsel = mcbasicinputs[decayDesc.particle.name]
else :
conj = decayDesc.conjugate()
if conj.particle.name in mcbasicinputs :
inputsel = mcbasicinputs[conj.particle.name]
else :
raise ValueError("Can't find MC basic input for particle " + repr(decayDesc.particle.name))
alg.Code = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow))
alg.Preambulo = preamble
sel = Selection(algname,
Algorithm = alg,
RequiredSelections = [inputsel])
selections[algname] = sel
return sel
inputs = []
daughtercuts = {}
for daughter in decayDescCC.daughters :
originaldaughtercc = daughter.cc
daughter.cc = True
sel = build_mc_unbiased_selection(daughter, arrow)
daughter.cc = originaldaughtercc
inputs.append(sel)
#daughter.caret = True
#daughtercuts[daughter.particle.name] = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow))
#daughter.caret = False
#comb = nCombiners[len(decayDesc.daughters)](algname + '_Comb')
comb = CombineParticles(algname + '_Comb')
# CombineParticles uses small cc, so set ishead = False
comb.DecayDescriptors = [decayDesc.to_string(depth = 1, ishead = False)]
comb.MotherCut = 'mcMatch({0!r})'.format(decayDescCC.to_string(arrow))
comb.Preambulo = preamble
comb.DaughtersCuts = daughtercuts
sel = Selection(algname,
Algorithm = comb,
RequiredSelections = inputs)
selections[algname] = sel
return sel
year = "2016"
magnetPolarity = "Down"
######################################################################################################
# if you are setting something wrong, it should die here...
if year not in [ "2016" ]:
raise RuntimeError(year + " is not a valid year")
if magnetPolarity not in ["Up", "Down"]:
raise RuntimeError(magnetPolarity + " is not a valid magnet polarity")
######################################################################################################
from Configurables import CombineParticles
KsPiPi= CombineParticles("KsPiPi")
KsPiPi.DecayDescriptor = "KS0 -> pi+ pi-"
KsPiPi.CombinationCut = "ADAMASS('KS0')<100*MeV"
KsPiPi.MotherCut = "(VFASPF(VCHI2/VDOF)<10)"
KsPiPi.DaughtersCuts = { "pi+" : "ALL",
"pi-" : "ALL" }
KsPiPi.MotherCut = "(M > 400) & (M < 600) & (BPVVDCHI2 > 100.) & (VFASPF(VCHI2/VDOF) < 10)"
from PhysSelPython.Wrappers import Selection
from StandardParticles import StdNoPIDsDownPions, StdLoosePions
LooseKsPiPi = Selection("SelLooseKsPiPi",
Algorithm = KsPiPi,
RequiredSelections = [StdNoPIDsDownPions ])
#RequiredSelections = [StdLoosePions])
from PhysSelPython.Wrappers import SelectionSequence
SeqKsPiPi = SelectionSequence('SeqKsPiPi', TopSelection = LooseKsPiPi)
KsPiPiTuple = DecayTreeTuple("KsPiPiTuple")
# input locations
KsPiPiTuple.Inputs = [ LooseKsPiPi.outputLocation() ]
def execute(simulation=True,
turbo=True,
decay_descriptor="J/psi(1S) -> mu- mu+"):
# Configure all the unpacking, algorithms, tags and input files
appConf = ApplicationMgr()
appConf.ExtSvc+= ['ToolSvc', 'DataOnDemandSvc', LoKiSvc()]
ConfigTarFileAccessSvc().File = 'config.tar'
dv = DaVinci()
dv.DataType = "2012"
lhcbApp = LHCbApp()
lhcbApp.Simulation = simulation
CondDB().Upgrade = False
dtt = DecayTreeTuple("Early2015")
if turbo:
tesla_prefix = "Hlt2DiMuonJPsi"
dtt.Inputs = ["/Event/"+tesla_prefix+"/Particles"]
dtt.InputPrimaryVertices = "/Event/"+tesla_prefix+"/Primary"
dtt.WriteP2PVRelations = False
else:
LHCbApp().DDDBtag = "dddb-20140729"
polarity = "u"
LHCbApp().CondDBtag = "sim-20140730-vc-m%s100"%polarity
muons = AutomaticData(Location="Phys/StdAllLooseMuons/Particles")
jpsi = CombineParticles('MyJPsi')
jpsi.DecayDescriptors = [decay_descriptor]
jpsi.CombinationCut = "(AM < 7100.0 *GeV)"
jpsi.DaughtersCuts = {"": "ALL", "mu+": "ALL", "mu-": "ALL"}
jpsi.MotherCut = "(VFASPF(VCHI2/VDOF) < 999999.0)"
code = """
('J/psi(1S)' == ID) &
in_range(2.990*GeV, M, 3.210*GeV) &
DECTREE('%s') &
CHILDCUT(1, HASMUON & ISMUON) &
CHILDCUT(2, HASMUON & ISMUON) &
(MINTREE('mu+' == ABSID, PT) > 700*MeV) &
(MAXTREE(ISBASIC & HASTRACK, TRCHI2DOF) < 5) &
(MINTREE(ISBASIC & HASTRACK, CLONEDIST) > 5000) &
(VFASPF(VPCHI2) > 0.5/100) &
(abs(BPV(VZ)) < 0.5*meter) &
(BPV(vrho2) < (10*mm)**2)
"""%(decay_descriptor)
# similar to the HLT2 line
code = """
(ADMASS('J/psi(1S)')< 120*MeV) &
DECTREE('%s') &
(PT>0*MeV) &
(MAXTREE('mu-'==ABSID,TRCHI2DOF) < 4) &
(MINTREE('mu-'==ABSID,PT)> 0*MeV) &
(VFASPF(VCHI2PDOF)< 25)
"""%(decay_descriptor)
filter_jpsi = FilterDesktop("MyFilterJPsi",
Code=code,
Preambulo=["vrho2 = VX**2 + VY**2"],
ReFitPVs=True,
#IgnoreP2PVFromInputLocations=True,
#WriteP2PVRelations=True
)
jpsi_sel = Selection("SelMyJPsi", Algorithm=jpsi, RequiredSelections=[muons])
filter_jpsi_sel = Selection("SelFilterMyJPsi",
Algorithm=filter_jpsi,
RequiredSelections=[jpsi_sel])
jpsi_seq = SelectionSequence("SeqMyJPsi", TopSelection=filter_jpsi_sel)
dtt.Inputs = [jpsi_seq.outputLocation()]
# Overwriting default list of TupleTools
dtt.ToolList = ["TupleToolKinematic",
"TupleToolPid",
"TupleToolEventInfo",
"TupleToolMCBackgroundInfo",
"TupleToolMCTruth",
#"MCTupleToolHierarchy",
#"MCTupleToolPID",
"TupleToolGeometry",
"TupleToolTISTOS",
# with turbo this crashes
#"TupleToolTrackInfo",
"TupleToolTrigger",
]
tlist = ["L0HadronDecision", "L0MuonDecision",
"L0DiMuonDecision", "L0ElectronDecision",
"L0PhotonDecision",
"Hlt1DiMuonHighMassDecision", "Hlt1DiMuonLowMassDecision",
"Hlt1TrackMuonDecision", "Hlt1TrackAllL0Decision",
"Hlt2DiMuonJPsiDecision", "Hlt2SingleMuonDecision",
]
dtt.addTool(TupleToolTrigger, name="TupleToolTrigger")
dtt.addTool(TupleToolTISTOS, name="TupleToolTISTOS")
# Get trigger info
dtt.TupleToolTrigger.Verbose = True
dtt.TupleToolTrigger.TriggerList = tlist
dtt.TupleToolTISTOS.Verbose = True
dtt.TupleToolTISTOS.TriggerList = tlist
from Configurables import TupleToolMCTruth, MCTupleToolHierarchy
dtt.addTool(TupleToolMCBackgroundInfo,
name="TupleToolMCBackgroundInfo")
dtt.TupleToolMCBackgroundInfo.Verbose = True
dtt.addTool(MCTupleToolHierarchy,
name="MCTupleToolHierarchy")
dtt.MCTupleToolHierarchy.Verbose = True
dtt.addTool(TupleToolMCTruth,
name="TupleToolMCTruth")
dtt.TupleToolMCTruth.Verbose = True
if turbo:
assoc_seq = TeslaTruthUtils.associateSequence(tesla_prefix, False)
ChargedPP2MC(tesla_prefix+"ProtoAssocPP").OutputLevel = 1
assoc_seq.Members.insert(0, PatLHCbID2MCParticle())
from Configurables import MuonCoord2MCParticleLink
muon_coords = MuonCoord2MCParticleLink("TeslaMuonCoordLinker")
assoc_seq.Members.insert(1, muon_coords)
TrackAssociator("TeslaAssocTr").DecideUsingMuons = True
relations = TeslaTruthUtils.getRelLoc(tesla_prefix)
else:
relations = "Relations/Rec/ProtoP/Charged"
TeslaTruthUtils.makeTruth(dtt,
relations,
["MCTupleToolKinematic",
"MCTupleToolHierarchy",
"MCTupleToolPID",
]
)
dtt.Decay = mark(2, mark(3, decay_descriptor)) #"J/psi(1S) -> ^mu- ^mu+"
dtt.addBranches({"X": "^(%s)"%(decay_descriptor),
"muplus": mark(3, decay_descriptor),#"J/psi(1S) -> mu- ^mu+",
"muminus": mark(2, decay_descriptor),#"J/psi(1S) -> ^mu- mu+",
})
x_preamble = ["DZ = VFASPF(VZ) - BPV(VZ)",
]
x_vars = {"ETA": "ETA",
"Y": "Y",
"PHI": "PHI",
"VPCHI2": "VFASPF(VPCHI2)",
"DELTAZ": "DZ",
# DZ * M / PZ / c with c in units of mm/s
# XXX should this be the PDG mass or measured mass?
#"TZ": "DZ*M / PZ / 299792458000.0", #seconds
"TZ": "DZ*3096.916 / PZ/299792458000.0*(10**12)", #ps
"minpt": "MINTREE('mu+' == ABSID, PT)",
"minclonedist": "MINTREE(ISBASIC & HASTRACK, CLONEDIST)",
"maxtrchi2dof": "MAXTREE(ISBASIC & HASTRACK, TRCHI2DOF)",
}
muon_vars = {"ETA": "ETA",
"Y": "Y",
"PHI": "PHI",
"CHARGE": "Q",
"CLONEDIST": "CLONEDIST",
"TRCHI2DOF": "TRCHI2DOF",
}
loki_X = dtt.X.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_X")
loki_X.Variables = x_vars
loki_X.Preambulo = x_preamble
loki_mup = dtt.muplus.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_MuPlus")
loki_mup.Variables = muon_vars
#dtt.muplus.addTupleTool("TupleToolGeometry")
loki_mum = dtt.muminus.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_MuMinus")
loki_mum.Variables = muon_vars
#dtt.muminus.addTupleTool("TupleToolGeometry")
dv.TupleFile = "DVNtuples.root"
if turbo:
dv.UserAlgorithms = [assoc_seq, dtt]
else:
assocpp = ChargedPP2MC("TimsChargedPP2MC")
assocpp.OutputLevel = 1
dv.UserAlgorithms = [jpsi_seq.sequence(), assocpp, dtt]
###############
# Stripping filter
strippingFilter = LoKi__HDRFilter( 'StripPassFilter', Code="HLT_PASS('Stripping"+line+"Decision')", Location="/Event/Strip/Phys/DecReports" )
evtPreselectors.append(strippingFilter)
# Muons and kaons
looseMuons = DataOnDemand(Location = 'Phys/StdLooseMuons/Particles')
looseKaons = DataOnDemand(Location = 'Phys/StdLooseKaons/Particles')
loosePions = DataOnDemand(Location = 'Phys/StdLoosePions/Particles')
# Select Phi
recoPhi = CombineParticles("Phi2KK")
recoPhi.DecayDescriptor = 'phi(1020) -> K+ K-'
recoPhi.DaughtersCuts = {"K+": "(ISLONG) & (TRCHI2DOF < 3 ) & (TRGHOSTPROB<0.3) & ( BPVIPCHI2 () > 9 ) & (PT>300*MeV) & (PIDK > 5)",
"K-": "(ISLONG) & (TRCHI2DOF < 3 ) & (TRGHOSTPROB<0.3) & ( BPVIPCHI2 () > 9 ) & (PT>300*MeV) & (PIDK > 5)"}
recoPhi.CombinationCut = "(ADAMASS('phi(1020)')<10*MeV)"
recoPhi.MotherCut = " ( VFASPF(VCHI2) < 10 ) & (MIPCHI2DV(PRIMARY)> 16.)"
# Very loose version for testing
# recoPhi = CombineParticles("Phi2KK")
# recoPhi.DecayDescriptor = 'phi(1020) -> K+ K-'
# recoPhi.DaughtersCuts = {"K+": "(ISLONG) & (TRCHI2DOF < 3 ) & (TRGHOSTPROB<0.3) & ( BPVIPCHI2 () > 9 ) & (PT>300*MeV) & (PIDK > -5)",
# "K-": "(ISLONG) & (TRCHI2DOF < 3 ) & (TRGHOSTPROB<0.3) & ( BPVIPCHI2 () > 9 ) & (PT>300*MeV) & (PIDK > -5)"}
# recoPhi.CombinationCut = "(ADAMASS('phi(1020)')<35*MeV)"
# recoPhi.MotherCut = " ( VFASPF(VCHI2) < 25 ) & (MIPCHI2DV(PRIMARY)> 4.)"
phi_selection = Selection('SelPhi2KK', Algorithm = recoPhi, RequiredSelections = [ looseKaons ])
# Select Tau
Phi.DecayDescriptor = 'phi(1020) -> KS0 KS0'
#Cuts from the stripping line
Phi.CombinationCut = "( (ACHILDCUT(CHILDCUT(ISLONG,1),1)) | (ACHILDCUT(CHILDCUT(ISLONG,1),2)) ) & (APT > %(Phi_PT_MIN)s *MeV) & (ADAMASS('phi(1020)')<%(Phi_MASS_RANGE)s +30*MeV) & (ACUTDOCACHI2(%(Phi_DOCACHI2_MAX)s,''))" %config
Phi.MotherCut = "(ADMASS('phi(1020)')<%(Phi_MASS_RANGE)s*MeV) & (VFASPF(VCHI2/VDOF) < %(Phi_VCHI2NDOF_MAX)s)" %config
Phi_Sel = Selection(name = "Sel_Phi2KsKs",
Algorithm = Phi,
RequiredSelections = [Ks])#[StdLooseKsDD,StdLooseKsLL])
Ds = CombineParticles("Ds2PhiPi")
Ds.DecayDescriptor = '[D_s+ -> phi(1020) pi+]cc'
Ds.DaughtersCuts = { '' : 'ALL' , 'phi(1020)' : '(ALL)' , 'pi+' : '(PT >150 *MeV) & (BPVIPCHI2() > 1.0) & ( TRCHI2DOF < 5 )& (TRGHOSTPROB<0.3)'}
Ds.CombinationCut = "(ADAMASS('D_s+')<180*MeV)"
Ds.MotherCut = "(VFASPF(VCHI2/VDOF) < 25.0)& (((BPVVDCHI2 > 16.0)|(BPVLTIME() > 0.150 * picosecond)))"#& (BPVDIRA > 35.0*mrad)"
Ds.MotherCut += "&(ADMASS('D_s+')<150*MeV)" %config
Ds_Sel = Selection(name = "Sel_Ds2PhiPi",
Algorithm = Ds,
RequiredSelections = [Phi_Sel, Pions])
Ds_sequence = SelectionSequence('SeqDs2PhiPi',
TopSelection = Ds_Sel
)
#This filter is used just to speed up the process, nothing happens if there
def configure ( inputdata , ## the list of input files
catalogs = [] , ## xml-catalogs (filled by GRID)
castor = False , ## use the direct access to castor/EOS ?
params = {} ) :
## configure Track <--> MC relation table
import LoKiPhysMC.Track2MC_Configuration
import LoKiMC.MC
## import DaVinci
from Configurables import DaVinci, GaudiSequencer
## delegate the actual configurtaion to DaVinci
dv = DaVinci ( DataType = '2011' ,
InputType = 'MDST',
Lumi = True,
Simulation = True,
DDDBtag="MC11-20111102",
CondDBtag="sim-20111111-vc-md100",
HistogramFile = "mcd02kpi_tracks7_histo.root",
TupleFile = "mcd02kpi_tracks7_ntuple.root",
PrintFreq = 1000)
from Configurables import DecayTreeTuple, FilterDesktop, TupleToolGeometry, CombineParticles
from Configurables import MCDecayTreeTuple, TupleToolMCTruth, MCTupleToolHierarchy
from PhysSelPython.Wrappers import AutomaticData, Selection, SelectionSequence, DataOnDemand
from Configurables import CheckPV
# First using CombineParticle to create the D0
################################################################################
#from StandardParticles import StdAllNoPIDsPions, StdAllNoPIDsKaons
_pions = DataOnDemand(Location='Phys/StdAllNoPIDsPions/Particles')
_kaons = DataOnDemand(Location='Phys/StdAllNoPIDsKaons/Particles')
_d2kpi = CombineParticles("d2kpi")
_d2kpi.DecayDescriptor = "[D0 -> K- pi+]cc"
_d2kpi.DaughtersCuts = { "K-" : "(PT > 500.0) & (0.0 < PIDK)",
"pi+" : "(PT > 500.0) & (5.0 > PIDK)",
"K+" : "(PT > 500.0) & (0.0 < PIDK)",
"pi-" : "(PT > 500.0) & (5.0 > PIDK) " }
_d2kpi.MotherCut = "(VFASPF(VCHI2/VDOF)<10)"
_d2kpi.CombinationCut = "(ADAMASS('D0') < 50.0)"
_d2kpi.Preambulo = [
"from LoKiPhysMC.decorators import *" ,
"from PartProp.Nodes import CC" ]
#_d2kpi.ReFitPVs = True
SelD2KPi = Selection( "SelD2KPi",
Algorithm= _d2kpi,
RequiredSelections=[_pions,_kaons] )
SeqD2KPi = SelectionSequence('SeqD2KPi',TopSelection = SelD2KPi)
# Now the CheckPV method to filter algorithms
c = CheckPV("OnePV")
c.MinPVs = 1
# And a sequencer to put them together
gseq = GaudiSequencer()
gseq.Members = [ c, SeqD2KPi.sequence() ]
## define the input data
setData ( inputdata , catalogs , castor )
## get/create application manager
gaudi = appMgr()
#
## modify/update the configuration:
#
## (1) create the algorithm
alg = TrackFilter( 'TrackFilter' )
#seq = createSequencer()
## (2) replace the list of top level algorithm by
# new list, which contains only *THIS* algorithm
gaudi.setAlgorithms( [ gseq, alg ] )
return SUCCESS
from os import environ
import GaudiKernel.SystemOfUnits as Units
from Gaudi.Configuration import *
from Configurables import CombineParticles, PhysDesktop
from Configurables import LoKi__Hybrid__PlotTool as PlotTool
importOptions("$DAVINCIROOT/options/DaVinciCommon.opts")
ApplicationMgr().TopAlg += ["GaudiSequencer/TutorialSeq"]
jpsi2mumu = CombineParticles("Jpsi2MuMu")
jpsi2mumu.addTool(PhysDesktop())
jpsi2mumu.PhysDesktop.InputLocations = ["Phys/StdLooseMuons"]
jpsi2mumu.DecayDescriptor = "J/psi(1S) -> mu+ mu-"
jpsi2mumu.DaughtersCuts = {"mu+": "ALL", "mu-": "ALL"}
jpsi2mumu.CombinationCut = "ADAMASS('J/psi(1S)')<30"
jpsi2mumu.MotherCut = "(VFASPF(VCHI2/VDOF)<100)"
GaudiSequencer("TutorialSeq").Members.append(jpsi2mumu)
phi2kk = CombineParticles("Phi2KK")
phi2kk.addTool(PhysDesktop())
phi2kk.PhysDesktop.InputLocations = ["Phys/StdLooseKaons"]
phi2kk.DecayDescriptor = "phi(1020) -> K+ K-"
phi2kk.CombinationCut = "ADAMASS('phi(1020)')<50"
phi2kk.MotherCut = "(VFASPF(VCHI2/VDOF)<100)"
GaudiSequencer("TutorialSeq").Members.append(phi2kk)
bs2jpsiphi = CombineParticles("Bs2JpsiPhi")
bs2jpsiphi.addTool(PhysDesktop())
bs2jpsiphi.PhysDesktop.InputLocations = ["Phys/Jpsi2MuMu", "Phys/Phi2KK"]
bs2jpsiphi.DecayDescriptor = "B_s0 -> phi(1020) J/psi(1S)"
