def __F2__(self, Rho, conf):
"""
Make a f_2(1950) -> p pbar
"""
f2SubMMZAlg = SubPIDMMFilter(self.name+"_F2SubMMZ_Alg", Code= "DECTREE('rho(770)0 -> pi+ pi-')", MinMM=0, MaxMM=6050, PIDs = [ [ 'p+', 'p~-'] ] )
f2SubMMPAlg = SubPIDMMFilter(self.name+"_F2SubMMP_Alg", Code= "DECTREE('rho(770)0 -> pi+ pi+')", MinMM=0, MaxMM=6050, PIDs = [ [ 'p+', 'p+'] ] )
f2SubMMMAlg = SubPIDMMFilter(self.name+"_F2SubMMM_Alg", Code= "DECTREE('rho(770)0 -> pi- pi-')", MinMM=0, MaxMM=6050, PIDs = [ [ 'p~-', 'p~-'] ] )
f2SubMMZSel = Selection( self.name+"_F2SubMMZ_Sel", Algorithm = f2SubMMZAlg, RequiredSelections = [ Rho ] )
f2SubMMPSel = Selection( self.name+"_F2SubMMP_Sel", Algorithm = f2SubMMPAlg, RequiredSelections = [ Rho ] )
f2SubMMMSel = Selection( self.name+"_F2SubMMM_Sel", Algorithm = f2SubMMMAlg, RequiredSelections = [ Rho ] )
f2Merge = MergedSelection( self.name+"_F2Merge", RequiredSelections = [ f2SubMMZSel, f2SubMMPSel, f2SubMMMSel ] )
f2SubAlg = SubstitutePID( self.name+"_F2Sub_Alg",
Code = "ALL" , #(DECTREE('rho(770)0 -> p+ p~-')) | (DECTREE('rho(770)0 -> p+ p+')) | (DECTREE('rho(770)0 -> p~- p~-'))",
MaxChi2PerDoF = -666 )
f2SubAlg.Substitutions = {
'rho(770)0 -> p+ p~-' : 'f_2(1950)' ,
'rho(770)0 -> p+ p+' : 'f_2(1950)' ,
'rho(770)0 -> p~- p~-' : 'f_2(1950)'
}
f2SubSel = Selection( self.name+"_F2Sub_Sel", Algorithm = f2SubAlg, RequiredSelections = [ f2Merge ] )
f2FilterAlg = FilterDesktop( Code = "(ABSID=='f_2(1950)')" )
f2FilterSel = Selection( self.name + "_F2Filter", Algorithm = f2FilterAlg, RequiredSelections = [ f2SubSel ] )
return f2FilterSel
def topoSubPID(name, inputs):
sub = SubstitutePID(name + 'SubPID', Code="DECTREE('X0 -> X X')")
sub.MaxChi2PerDoF = -666
sub.Substitutions = {'X0 -> X X': 'B0'}
sel = Selection(name + 'FinalSel',
Algorithm=sub,
RequiredSelections=[inputs])
filter = "INTREE(ID=='B0')"
return filterSelection(name, filter, [sel])
def __Lambdastar__(self, Rho, conf):
"""
Make a Lambdastar
"""
lstarChangeAlg1 = SubstitutePID(
self.name + "lstarChangeAlg1",
Code=
"(DECTREE('X0 -> X+ X-')) | (DECTREE('X0 -> X+ X+')) | (DECTREE('X0 -> X- X-')) ",
Substitutions={
' X0 -> ^X+ X- ': 'p+',
' X0 -> X+ ^X- ': 'K-',
' X0 -> X+ X- ': 'Lambda(1520)0',
' X0 -> ^X+ X+ ': 'p+',
' X0 -> X+ ^X+ ': 'K+',
' X0 -> X+ X+ ': 'Lambda(1520)0',
' X0 -> ^X- X- ': 'p~-',
' X0 -> X- ^X- ': 'K-',
' X0 -> X- X- ': 'Lambda(1520)~0'
},
MaxParticles=20000,
MaxChi2PerDoF=-666)
lstarChangeAlg2 = SubstitutePID(
self.name + "lstarChangeAlg2",
Code=
"(DECTREE('X0 -> X+ X-')) | (DECTREE('X0 -> X+ X+')) | (DECTREE('X0 -> X- X-')) ",
Substitutions={
' X0 -> X+ ^X- ': 'p~-',
' X0 -> ^X+ X- ': 'K+',
' X0 -> X+ X- ': 'Lambda(1520)~0',
' X0 -> ^X+ X+ ': 'K+',
' X0 -> X+ ^X+ ': 'p+',
' X0 -> X+ X+ ': 'Lambda(1520)0',
' X0 -> ^X- X- ': 'K-',
' X0 -> X- ^X- ': 'p~-',
' X0 -> X- X- ': 'Lambda(1520)~0'
},
MaxParticles=20000,
MaxChi2PerDoF=-666)
lsDescr1 = Selection(self.name + "_Lambdastar_SubPIDAlg1",
Algorithm=lstarChangeAlg1,
RequiredSelections=[Rho])
lsDescr2 = Selection(self.name + "_Lambdastar_SubPIDAlg2",
Algorithm=lstarChangeAlg2,
RequiredSelections=[Rho])
pick = Selection(
self.name + "_Lambdastar_PickDecay",
Algorithm=FilterDesktop(
Code=
"(DECTREE('Lambda(1520)0 -> p+ K-')) | (DECTREE('Lambda(1520)~0 -> p~- K+')) | (DECTREE('Lambda(1520)0 -> p+ K+')) | (DECTREE('Lambda(1520)~0 -> p~- K-'))"
),
RequiredSelections=[lsDescr1, lsDescr2])
return pick
def subPID(name,p,d,inputs):
sub = SubstitutePID(name+'SubPIDBeauty2XGamma',
Code="DECTREE('X0 -> X+ X-')")
sub.MaxChi2PerDoF = -666
sub.Substitutions = {'X0 -> ^X+ X-' : d[0],'X0 -> X+ ^X-' : d[1],
'X0 -> X+ X-' : p}
sel = Selection(name+'Beauty2XGammaSel',Algorithm=sub,
RequiredSelections=inputs)
filter = "INTREE(ID=='%s') & INTREE(ID=='%s') & INTREE(ID=='%s')" \
% (p,d[0],d[1])
return filterSelection(name,filter,[sel])
def __Kstar__(self, Rho, conf):
"""
Make a kstar
"""
kstarChangeAlg1 = SubstitutePID(
self.name + "kstarChangeAlg1",
Code=
"(DECTREE('X0 -> X+ X-')) | (DECTREE('X0 -> X+ X+')) | (DECTREE('X0 -> X- X-')) ",
Substitutions={
' X0 -> ^X+ X- ': 'K+',
' X0 -> X+ X- ': 'K*(892)0',
' X0 -> ^X+ X+ ': 'K+',
' X0 -> X+ X+ ': 'K*(892)0',
' X0 -> ^X- X- ': 'K-',
' X0 -> X- X- ': 'K*(892)~0'
},
MaxParticles=20000,
MaxChi2PerDoF=-666)
kstarChangeAlg2 = SubstitutePID(
self.name + "kstarChangeAlg2",
Code=
"(DECTREE('X0 -> X+ X-')) | (DECTREE('X0 -> X+ X+')) | (DECTREE('X0 -> X- X-')) ",
Substitutions={
' X0 -> X+ ^X- ': 'K-',
' X0 -> X+ X- ': 'K*(892)~0',
' X0 -> X+ ^X+ ': 'K+',
' X0 -> X+ X+ ': 'K*(892)0',
' X0 -> X- ^X- ': 'K-',
' X0 -> X- X- ': 'K*(892)~0'
},
MaxParticles=20000,
MaxChi2PerDoF=-666)
ksDescr1 = Selection(self.name + "_Kstar_SubPIDAlg1",
Algorithm=kstarChangeAlg1,
RequiredSelections=[Rho])
ksDescr2 = Selection(self.name + "_Kstar_SubPIDAlg2",
Algorithm=kstarChangeAlg2,
RequiredSelections=[Rho])
pick = Selection(
self.name + "_Kstar_PickDecay",
Algorithm=FilterDesktop(
Code=
"(DECTREE('K*(892)0 -> K+ pi-')) | (DECTREE('K*(892)~0 -> K- pi+')) | (DECTREE('K*(892)0 -> K+ pi+')) | (DECTREE('K*(892)~0 -> K- pi-'))"
),
RequiredSelections=[ksDescr1, ksDescr2])
return pick
def makeB2DstarX(sel, uppions, config):
# change B to something that doesn't fly
sub = SubstitutePID('SubPID' + sel.name(),
Code="DECTREE('Beauty -> Charm ...')")
sub.MaxChi2PerDoF = -666
sub.Substitutions = {'Beauty -> Charm ...': 'J/psi(1S)'}
subsel = Selection(sel.name() + 'DstarUPSel',
Algorithm=sub,
RequiredSelections=[sel])
filter = "INTREE(ID=='J/psi(1S)')"
subsel = filterSelection(sel.name() + 'DstarUPFilter', filter, [subsel])
# Delta M cut on D* (preambulo is below)
#dmcut = '((ISD1 & ((MD1PI-MD1) < 180)) | (ISD2 & ((MD2PI-MD2) < 180)))'
#dmcut = '((MD1PI-MD1) < 180) | ((MD2PI-MD2) < 180)'
dmcut = "((((IDD1==421)|(IDD1==411)) & ((MD1PI-MD1) < 180)) | (((IDD2==421)|(IDD2==411)) & ((MD2PI-MD2) < 180)))"
# add UP track
combConfig = {'AMAXDOCA_MAX': '0.5*mm'}
comboCuts = [LoKiCuts(['AMAXDOCA'], combConfig).code(), dmcut]
comboCuts = LoKiCuts.combine(comboCuts)
momCuts = LoKiCuts(['VCHI2DOF', 'BPVVDCHI2', 'BPVDIRA'], config).code()
#did = "((ABSID=='D+')|(ABSID=='D0'))"
preambulo = [
'PXPI = ACHILD(PX,2)',
'PYPI = ACHILD(PY,2)',
'PZPI = ACHILD(PZ,2)',
'EPI = ACHILD(E,2)',
'IDD1 = ACHILD(CHILD(ABSID,1),1)',
#'ISD1 = ACHILD(CHILD(%s,1),1)' % did,
'PXD1 = ACHILD(CHILD(PX,1),1)',
'PYD1 = ACHILD(CHILD(PY,1),1)',
'PZD1 = ACHILD(CHILD(PZ,1),1)',
'ED1 = ACHILD(CHILD(E,1),1)',
'MD1 = ACHILD(CHILD(M,1),1)',
'MD1PI = sqrt((EPI+ED1)**2 - (PXPI+PXD1)**2 - (PYPI+PYD1)**2 - (PZPI+PZD1)**2)',
#'ISD2 = ACHILD(CHILD(%s,2),1)' % did,
'IDD2 = ACHILD(CHILD(ABSID,2),1)',
'PXD2 = ACHILD(CHILD(PX,2),1)',
'PYD2 = ACHILD(CHILD(PY,2),1)',
'PZD2 = ACHILD(CHILD(PZ,2),1)',
'ED2 = ACHILD(CHILD(E,2),1)',
'MD2 = ACHILD(CHILD(M,2),1)',
'MD2PI = sqrt((EPI+ED2)**2 - (PXPI+PXD2)**2 - (PYPI+PYD2)**2 - (PZPI+PZD2)**2)',
]
cp = CombineParticles(CombinationCut=comboCuts,
MotherCut=momCuts,
Preambulo=preambulo,
DecayDescriptor='[B+ -> J/psi(1S) pi+]cc')
return Selection('DstarUP' + sel.name(),
Algorithm=cp,
RequiredSelections=[uppions] + [subsel])
def __K2__(self, A1, conf):
"""
SubPID:
K_2 -> K K K
"""
#replace head with K_2(1770)
_a1k2_SubPID = SubstitutePID(self.name+"_a1k2_SubPID", Code="(DECTREE('a_1(1260)+ -> pi+ pi+ pi-')) | (DECTREE('a_1(1260)- -> pi- pi- pi+'))",
Substitutions={'a_1(1260)+ -> pi+ pi+ pi-' : 'K_2(1770)+', 'a_1(1260)- -> pi- pi- pi+' : 'K_2(1770)-'}, MaxParticles=20000, MaxChi2PerDoF=-666)
_sel_k2 = Selection(self.name+"_a1k2_SubPIDAlg",
Algorithm = _a1k2_SubPID, RequiredSelections = [A1])
#replace daughters for K_2(1770)+, order is important for this tool
_a1k2_SubPIDp = SubPIDMMFilter(self.name+"_a1k2_SubPIDp", Code="DECTREE('K_2(1770)+ -> pi+ pi+ pi-')",
MinMM=0, MaxMM=6050, PIDs = [['K+','K+','K-']] )
_sel_k2p = Selection(self.name+"_a1k2_SubPIDAlgp",
Algorithm = _a1k2_SubPIDp, RequiredSelections = [_sel_k2])
#replace daughters for K_2(1770)-
_a1k2_SubPIDm = SubPIDMMFilter(self.name+"_a1k2_SubPIDm", Code="DECTREE('K_2(1770)- -> pi- pi- pi+')",
MinMM=0, MaxMM=6050, PIDs = [['K-','K-','K+']] )
_sel_k2m = Selection(self.name+"_a1k2_SubPIDAlgm",
Algorithm = _a1k2_SubPIDm, RequiredSelections = [_sel_k2])
pick = Selection(self.name+"_K2_PickDecay",
Algorithm = FilterDesktop( Code = "(DECTREE('K_2(1770)+ -> K- K+ K+')) | (DECTREE('K_2(1770)- -> K+ K- K-'))" ),
RequiredSelections = [_sel_k2p, _sel_k2m])
return pick
def splitPhiPi(self, name, phiPiSelection):
"""Split the input phi pi+ Selection in to a D+ and D_s+ selection.
Returns a two-tuple as (D+ Selection, D_s+ Selection).
Keyword arguments:
phiPiSelection -- A single Selection instance; output of makeD2PhiPi
"""
dpFilter = FilterDesktop(
'FilterDp{0}'.format(name),
Code="(ADMASS('D+') < {0[Dp_ADAMASS_WIN]})".format(self.config))
dsFilter = FilterDesktop(
'FilterDs{0}'.format(name),
Code="(ADMASS('D_s+') < {0[Ds_ADAMASS_WIN]})".format(self.config))
dpSel = Selection('SelFilteredDp{0}'.format(name),
Algorithm=dpFilter,
RequiredSelections=[phiPiSelection])
dsSel = Selection('SelFilteredDs{0}'.format(name),
Algorithm=dsFilter,
RequiredSelections=[phiPiSelection])
# The PhiPi selection is labelled as a D_s+, so rename the candidates
# in the Dp selection as such
dpSubPID = SubstitutePID(name='SubPidDp{0}'.format(name),
Code="DECTREE('[D_s+ -> X0 X+]CC')",
Substitutions={
'D_s+ -> X0 X+': 'D+',
'D_s- -> X0 X-': 'D-'
},
MaxChi2PerDoF=-1)
dpSubPIDSel = Selection('SubPIDDpSel{0}'.format(name),
Algorithm=dpSubPID,
RequiredSelections=[dpSel])
return dpSubPIDSel, dsSel
def __F2__(self, Rho, conf):
"""
Make a f_2(1950) -> p pbar
"""
f2ChangeAlg1 = SubstitutePID(
self.name + "f2ChangeAlg",
Code=
"(DECTREE('X0 -> X+ X-')) | (DECTREE('X0 -> X+ X+')) | (DECTREE('X0 -> X- X-')) ",
Substitutions={
' X0 -> ^X+ X- ': 'p+',
' X0 -> X+ ^X- ': 'p~-',
' X0 -> X+ X- ': 'f_2(1950)',
' X0 -> ^X+ X+ ': 'p+',
' X0 -> X+ ^X+ ': 'p+',
' X0 -> X+ X+ ': 'f_2(1950)',
' X0 -> ^X- X- ': 'p~-',
' X0 -> X- ^X- ': 'p~-',
' X0 -> X- X- ': 'f_2(1950)'
},
MaxParticles=20000,
MaxChi2PerDoF=-666)
f2Descr1 = Selection(self.name + "_F2_SubPIDAlg",
Algorithm=f2ChangeAlg1,
RequiredSelections=[Rho])
pick = Selection(
self.name + "_F2_PickDecay",
Algorithm=FilterDesktop(
Code=
"(DECTREE('f_2(1950) -> p+ p~-')) | (DECTREE('f_2(1950) -> p+ p+')) | (DECTREE('f_2(1950) -> p~- p~-'))"
),
RequiredSelections=[f2Descr1])
return pick
def __K1__(self, A1, conf):
"""
SubPID:
K_1 -> K pi pi
"""
#replace head with K_1(1270)
_a1k1_SubPID = SubstitutePID(self.name+"_a1k1_SubPID", Code="(DECTREE('a_1(1260)+ -> pi+ pi+ pi-')) | (DECTREE('a_1(1260)- -> pi- pi- pi+'))",
Substitutions={'a_1(1260)+ -> pi+ pi+ pi-' : 'K_1(1270)+', 'a_1(1260)- -> pi- pi- pi+' : 'K_1(1270)-'}, MaxChi2PerDoF=-666)
_sel_k1 = Selection(self.name+"_a1k1_SubPIDAlg",
Algorithm = _a1k1_SubPID, RequiredSelections = [A1])
#replace daughters for K_1(1270)+, order is important for this tool
_a1k1_SubPIDp = SubPIDMMFilter(self.name+"_a1k1_SubPIDp", Code="DECTREE('K_1(1270)+ -> pi+ pi+ pi-')",
MinMM=0, MaxMM=conf['A1_Comb_MassHigh'], PIDs = [['K+','pi+','pi-'], ['pi+','K+','pi-']] )
_sel_k1p = Selection(self.name+"_a1k1_SubPIDAlgp",
Algorithm = _a1k1_SubPIDp, RequiredSelections = [_sel_k1])
#replace daughters for K_1(1270)-
_a1k1_SubPIDm = SubPIDMMFilter(self.name+"_a1k1_SubPIDm", Code="DECTREE('K_1(1270)- -> pi- pi- pi+')",
MinMM=0, MaxMM=conf['A1_Comb_MassHigh'], PIDs = [['K-','pi-','pi+'], ['pi-','K-','pi+']] )
_sel_k1m = Selection(self.name+"_a1k1_SubPIDAlgm",
Algorithm = _a1k1_SubPIDm, RequiredSelections = [_sel_k1])
pick = Selection(self.name+"_K1_PickDecay",
Algorithm = FilterDesktop( Code = "(DECTREE('K_1(1270)+ -> K+ pi+ pi-')) | (DECTREE('K_1(1270)- -> pi+ K- pi-'))" ),
RequiredSelections = [_sel_k1p, _sel_k1m])
return pick
def __Phi__(self, Rho, conf):
"""
Make a phi
"""
phiChangeAlg1 = SubstitutePID( self.name+"phiChangeAlg",
Code = "(DECTREE('X0 -> X+ X-')) | (DECTREE('X0 -> X+ X+')) | (DECTREE('X0 -> X- X-')) ",
Substitutions = { ' X0 -> ^X+ X- ' : 'K+' ,
' X0 -> X+ ^X- ' : 'K-' ,
' X0 -> X+ X- ' : 'phi(1020)',
' X0 -> ^X+ X+ ' : 'K+',
' X0 -> X+ ^X+ ' : 'K+',
' X0 -> X+ X+ ' : 'phi(1020)',
' X0 -> ^X- X- ' : 'K-',
' X0 -> X- ^X- ' : 'K-',
' X0 -> X- X- ' : 'phi(1020)' },
MaxParticles = 20000,
MaxChi2PerDoF = -666 )
phiDescr1 = Selection( self.name+"_Phi_SubPIDAlg",
Algorithm = phiChangeAlg1,
RequiredSelections = [Rho])
pick = Selection(self.name+"_Phi_PickDecay",
Algorithm = FilterDesktop( Code = "(DECTREE('phi(1020) -> K+ K-')) | (DECTREE('phi(1020) -> K+ K+')) | (DECTREE('phi(1020) -> K- K-'))" ),
RequiredSelections = [phiDescr1])
return pick
def filterEE(which,econf,xconf,inputs):
code = "(ID=='J/psi(1S)') & (PT > %s) & (MINTREE('e+'==ABSID,PIDe) > %s)" \
% (xconf['PT_MIN'],econf['PIDe_MIN'])
code += " & (MINTREE('e+'==ABSID,MIPCHI2DV(PRIMARY)) > %s)" \
% econf['MIPCHI2DV_MIN']
code += " & (MINTREE('e+'==ABSID,PT) > %s)" % econf['PT_MIN']
code += " & (MAXTREE('e+'==ABSID,TRGHP) < %s)" % econf['TRGHP_MAX']
code = LoKiCuts.combine([code,LoKiCuts(['HASVERTEX','BPVVDCHI2','VCHI2DOF'],
xconf).code()])
#print "filterEE: ", code
sel = Selection(which+'FilterEEDarkBosonFilter',
Algorithm=FilterDesktop(Code=code),
RequiredSelections=inputs)
sub = SubstitutePID(which+'EESubPIDDarkBoson',
Code="DECTREE('J/psi(1S) -> e+ e-')")
sub.MaxChi2PerDoF = -666
sub.Substitutions = {'J/psi(1S) -> e+ e-' : 'KS0'}
return Selection(which+'EESubPIDDarkBosonSel',Algorithm=sub,
RequiredSelections=[sel])
def __Lambdastar__(self, Rho, conf):
"""
Make a Lambdastar
"""
lambdastarSubMMZAlg = SubPIDMMFilter(self.name+"_LambdastarSubMMZ_Alg", Code= "DECTREE('rho(770)0 -> pi+ pi-')", MinMM=0, MaxMM=6050, PIDs = [ [ 'p+', 'K-'], ['K+', 'p~-' ] ])
lambdastarSubMMPAlg = SubPIDMMFilter(self.name+"_LambdastarSubMMP_Alg", Code= "DECTREE('rho(770)0 -> pi+ pi+')", MinMM=0, MaxMM=6050, PIDs = [ [ 'p+', 'K+'], ['K+', 'p+' ] ])
lambdastarSubMMMAlg = SubPIDMMFilter(self.name+"_LambdastarSubMMM_Alg", Code= "DECTREE('rho(770)0 -> pi- pi-')", MinMM=0, MaxMM=6050, PIDs = [ [ 'p~-', 'K-'], ['K-', 'p~-' ] ])
lambdastarSubMMZSel = Selection( self.name+"_LambdastarSubMMZ_Sel", Algorithm = lambdastarSubMMZAlg, RequiredSelections = [ Rho ] )
lambdastarSubMMPSel = Selection( self.name+"_LambdastarSubMMP_Sel", Algorithm = lambdastarSubMMPAlg, RequiredSelections = [ Rho ] )
lambdastarSubMMMSel = Selection( self.name+"_LambdastarSubMMM_Sel", Algorithm = lambdastarSubMMMAlg, RequiredSelections = [ Rho ] )
lambdastarMerge = MergedSelection( self.name+"_LambdastarMerge", RequiredSelections = [ lambdastarSubMMZSel, lambdastarSubMMPSel, lambdastarSubMMMSel ] )
lambdastarSubAlg = SubstitutePID( self.name+"_LambdastarSub_Alg", Code = "ALL", MaxChi2PerDoF = -666 )
#lambdastarSubAlg.Code = "ALL"
#(DECTREE('rho(770)0 -> p+ K-')) | (DECTREE('rho(770)0 -> K+ p~-')) | (DECTREE('rho(770)0 -> p+ K+')) | (DECTREE('rho(770)0 -> p~- K-'))"
lambdastarSubAlg.Substitutions = {
'rho(770)0 -> p+ K-' : 'Lambda(1520)0',
'rho(770)0 -> p+ K+' : 'Lambda(1520)0',
'rho(770)0 -> p~- K-' : 'Lambda(1520)~0',
'rho(770)0 -> K+ p~-' : 'Lambda(1520)~0'
}
lambdastarSubSel = Selection( self.name+"_LambdastarSub_Sel", Algorithm = lambdastarSubAlg, RequiredSelections = [ lambdastarMerge ] )
lambdastarFilterAlg = FilterDesktop( Code = "(ABSID=='Lambda(1520)0')" )
lambdastarFilterSel = Selection( self.name + "_LambdastarFilter", Algorithm = lambdastarFilterAlg, RequiredSelections = [ lambdastarSubSel ] )
return lambdastarFilterSel
def __Kstar__(self, Rho, conf):
"""
Make a kstar
"""
kstarSubMMZAlg = SubPIDMMFilter(self.name+"_KstarSubMMZ_Alg", Code= "DECTREE('rho(770)0 -> pi+ pi-')", MinMM=0, MaxMM=6050, PIDs = [ [ 'K+', 'pi-'], ['pi+', 'K-' ] ])
kstarSubMMPAlg = SubPIDMMFilter(self.name+"_KstarSubMMP_Alg", Code= "DECTREE('rho(770)0 -> pi+ pi+')", MinMM=0, MaxMM=6050, PIDs = [ [ 'K+', 'pi+'], ['pi+', 'K+' ] ])
kstarSubMMMAlg = SubPIDMMFilter(self.name+"_KstarSubMMM_Alg", Code= "DECTREE('rho(770)0 -> pi- pi-')", MinMM=0, MaxMM=6050, PIDs = [ [ 'K-', 'pi-'], ['pi-', 'K-' ] ])
kstarSubMMZSel = Selection( self.name+"_KstarSubMMZ_Sel", Algorithm = kstarSubMMZAlg, RequiredSelections = [ Rho ] )
kstarSubMMPSel = Selection( self.name+"_KstarSubMMP_Sel", Algorithm = kstarSubMMPAlg, RequiredSelections = [ Rho ] )
kstarSubMMMSel = Selection( self.name+"_KstarSubMMM_Sel", Algorithm = kstarSubMMMAlg, RequiredSelections = [ Rho ] )
kstarMerge = MergedSelection( self.name+"_KstarMerge", RequiredSelections = [ kstarSubMMZSel, kstarSubMMPSel, kstarSubMMMSel ] )
kstarSubAlg = SubstitutePID( self.name+"_KstarSub_Alg", Code = "ALL", MaxChi2PerDoF = -666 )
#kstarSubAlg.Code = "ALL" #(DECTREE('rho(770)0 -> K+ pi-')) | (DECTREE('rho(770)0 -> K- pi+')) | (DECTREE('rho(770)0 -> K+ pi+')) | (DECTREE('rho(770)0 -> K- pi-'))"
kstarSubAlg.Substitutions = {
'rho(770)0 -> K+ pi-' : 'K*(892)0',
'rho(770)0 -> K+ pi+' : 'K*(892)0',
'rho(770)0 -> pi+ K-' : 'K*(892)~0',
'rho(770)0 -> K- pi-' : 'K*(892)~0'
}
kstarSubSel = Selection( self.name+"_KstarSub_Sel", Algorithm = kstarSubAlg, RequiredSelections = [ kstarMerge ] )
kstarFilterAlg = FilterDesktop( Code = "(ABSID=='K*(892)0')" )
kstarFilterSel = Selection( self.name + "_KstarFilter", Algorithm = kstarFilterAlg, RequiredSelections = [ kstarSubSel ] )
return kstarFilterSel
def subPID(name, input, mother, plusD, minusD):
ddChangeAlg = SubstitutePID( name+"SubPIDAlg",
Code = "DECTREE('rho(770)0 -> pi+ pi-')",
Substitutions = { ' rho(770)0 -> ^pi+ X- ' : plusD,
' rho(770)0 -> X+ X- ' : mother},
MaxChi2PerDoF = -666 )
newDDescr = Selection( name+"SubPIDSel",
Algorithm = ddChangeAlg,
RequiredSelections = [input])
return Selection(name+"pickDecay",
Algorithm = FilterDesktop( Code = "DECTREE('%s -> %s %s')" % (mother, plusD, minusD) ),
RequiredSelections = [newDDescr])
def __Phi__(self, Rho, conf):
"""
Make a phi through substitution
"""
phiSubMMZAlg = SubPIDMMFilter(self.name+"_PhiSubMMZ_Alg", Code= "DECTREE('rho(770)0 -> pi+ pi-')", MinMM=0, MaxMM=6050, PIDs = [ [ 'K+', 'K-'] ] )
phiSubMMPAlg = SubPIDMMFilter(self.name+"_PhiSubMMP_Alg", Code= "DECTREE('rho(770)0 -> pi+ pi+')", MinMM=0, MaxMM=6050, PIDs = [ [ 'K+', 'K+'] ] )
phiSubMMMAlg = SubPIDMMFilter(self.name+"_PhiSubMMM_Alg", Code= "DECTREE('rho(770)0 -> pi- pi-')", MinMM=0, MaxMM=6050, PIDs = [ [ 'K-', 'K-'] ] )
phiSubMMZSel = Selection( self.name+"_PhiSubMMZ_Sel", Algorithm = phiSubMMZAlg, RequiredSelections = [ Rho ] )
phiSubMMPSel = Selection( self.name+"_PhiSubMMP_Sel", Algorithm = phiSubMMPAlg, RequiredSelections = [ Rho ] )
phiSubMMMSel = Selection( self.name+"_PhiSubMMM_Sel", Algorithm = phiSubMMMAlg, RequiredSelections = [ Rho ] )
phiMerge = MergedSelection( self.name+"_PhiMerge", RequiredSelections = [ phiSubMMZSel, phiSubMMPSel, phiSubMMMSel ] )
phiSubAlg = SubstitutePID( self.name+"_PhiSub_Alg", Code = "ALL", MaxChi2PerDoF = -666 )
#(DECTREE('rho(770)0 -> K+ K-')) | (DECTREE('rho(770)0 -> K+ K+')) | (DECTREE('rho(770)0 -> K- K-'))",
phiSubAlg.Substitutions = {
'rho(770)0 -> K+ K-' : 'phi(1020)' ,
'rho(770)0 -> K+ K+' : 'phi(1020)' ,
'rho(770)0 -> K- K-' : 'phi(1020)'
}
phiSubSel = Selection( self.name+"_PhiSub_Sel", Algorithm = phiSubAlg, RequiredSelections = [ phiMerge ] )
phiFilterAlg = FilterDesktop( Code = "(ABSID=='phi(1020)')" )
phiFilterSel = Selection( self.name + "_PhiFilter", Algorithm = phiFilterAlg, RequiredSelections = [ phiSubSel ] )
return phiFilterSel
def splitHHH(self, name, hhhSelection):
"""Split the input h-h+h+ Selection in to a D+ and D_s+ selection.
Returns a two-tuple as (D+ Selection, D_s+ Selection).
Keyword arguments:
hhhSelection -- A single Selection instance; the output of makeD2HHH
"""
dpFilter = FilterDesktop(
'FilterDp{0}'.format(name),
Code="(ADMASS('D+') < {0[Dp_ADAMASS_WIN]})".format(self.config)
)
dsFilter = FilterDesktop(
'FilterDs{0}'.format(name),
Code="(ADMASS('D_s+') < {0[Ds_ADAMASS_WIN]})".format(self.config)
)
dpSel = Selection(
'SelFilteredDp{0}'.format(name),
Algorithm=dpFilter,
RequiredSelections=[hhhSelection]
)
dsSel = Selection(
'SelFilteredDs{0}'.format(name),
Algorithm=dsFilter,
RequiredSelections=[hhhSelection]
)
# The HHH selection is labelled as a D+, so rename the candidates in
# the D_s+ selection as such
dsSubPID = SubstitutePID(
name='SubPidDs{0}'.format(name),
Code="DECTREE('[D+ -> X- X+ X+]CC')",
Substitutions={
'D+ -> X- X+ X+': 'D_s+',
'D- -> X+ X- X-': 'D_s-'
},
MaxChi2PerDoF=-1
)
dsSubPIDSel = Selection(
'SubPIDDsSel{0}'.format(name),
Algorithm=dsSubPID,
RequiredSelections=[dsSel]
)
return dpSel, dsSubPIDSel
def add_line_tuple_sequence(self, linesettings,
toolList = ["TupleToolPropertime",
"TupleToolKinematic",
"TupleToolGeometry",
"TupleToolEventInfo",
"TupleToolPrimaries",
"TupleToolPid",
"TupleToolANNPID",
"TupleToolTrackInfo",
"TupleToolRecoStats",],
mcToolList = ['TupleToolMCTruth',
'TupleToolMCBackgroundInfo',
'MCTupleToolPrompt'],
L0List = [],
HLT1List = [],
HLT2List = [],
strippingList = [],
aliases = {},
labXAliases = False,
substitutions = {},
suffix = '') :
if not isinstance(linesettings, dict) :
linesettings = self.get_line_settings(*linesettings)
isTrigger = is_trigger(linesettings['version'])
rootInTES = linesettings['rootInTES']
linename = linesettings['linename']
version = linesettings['version']
decayDescs = linesettings['decayDescs']
inputlocation = linesettings['inputLocation']
if self.getProp('Simulation') and not isTrigger :
rootInTES = '/'.join(rootInTES.split('/')[:-1] + ['AllStreams'])
if self.getProp('InputType').lower() != 'mdst' :
inputlocation = os.path.join(rootInTES, inputlocation)
rootInTES = ''
self.RootInTES = rootInTES
if isTrigger :
from Configurables import DstConf
dstconf = DstConf()
dstconf.Turbo = True
self.extraobjs.add(dstconf)
lineseq = GaudiSequencer(linename + '-Sequence')
if substitutions :
subs = {}
for i, desc in enumerate(decayDescs) :
descsubs, newdesc = desc.get_substitutions(substitutions)
subs.update(descsubs)
decayDescs[i] = newdesc
newinputlocation = inputlocation.split('/')
newinputlocation[-2] += '-SubPID'
newinputlocation = '/'.join(newinputlocation)
subpid = SubstitutePID(linename + '-SubPID',
Code = 'ALL',
Substitutions = subs,
Inputs = [inputlocation],
Output = newinputlocation)
lineseq.Members += [subpid]
inputlocation = newinputlocation
for desc in decayDescs :
if labXAliases :
desc.set_labX_aliases()
elif aliases :
desc.set_aliases(aliases)
desctuple = DecayTreeTuple(desc.get_full_alias() + suffix + 'Tuple',
ToolList = [])
desctuple.configure_for_line(desc, inputlocation,
linename, version,
self.getProp('Simulation'),
toolList,
mcToolList,
L0List, HLT1List, HLT2List,
strippingList)
lineseq.Members.append(desctuple)
self.UserAlgorithms.append(lineseq)
return linesettings, lineseq
def _buildAlgorithmChain(self, name, decayCombos, massLow, massHigh,
inputSelection):
print 'build shit!!!!'
uniqueCombos = []
for nominalDecay, validDecays in decayCombos.items():
uniqueCombos.extend(validDecays)
uniqueCombos = list(set(uniqueCombos))
wmSelections = {}
for combo in uniqueCombos:
comboName = ''.join(self._unsignDecay(combo))
functor = self._buildUnsignedWMFunctor({combo: [combo]}, massLow,
massHigh)
_filter = FilterDesktop("%s_WMFilter_%s" % (name, comboName),
Code=functor)
print '_filter', _filter
wmSelections[comboName] = Selection(
"%s_WMSel_%s" % (name, comboName),
Algorithm=_filter,
RequiredSelections=[inputSelection])
mySelections = {}
for nominalDecay, validDecays in decayCombos.items():
nominalDecayName = ''.join(nominalDecay)
nDaughters = len(nominalDecay)
algoList = []
for validDecay in validDecays:
validDecayName = ''.join(validDecay)
wmSel = wmSelections[''.join(self._unsignDecay(validDecay))]
_subsAlgo = SubstitutePID("%s_SubsAlg_%s" %
(name, validDecayName),
Code="DECTREE( 'Charm -> %s' )" %
(' '.join(self.referenceDecay)),
Substitutions={})
_subsAlgo.MaxChi2PerDoF = -666
mySubs = {}
for i, validDaughter in enumerate(validDecay):
#if validDaughter == self.referenceDecay[i]:
# continue
if not validDaughter in mySubs:
mySubs[validDaughter] = self.referenceDecay[:]
mySubs[validDaughter][i] = '^' + mySubs[validDaughter][i]
for sub, descriptor in mySubs.items():
subsString = 'Charm -> ' + ' '.join(descriptor)
_subsAlgo.Substitutions[subsString] = sub
#print 'Combo:', 'alg =', _subsAlgo
print 'subs:', _subsAlgo.Substitutions
print 'code:', _subsAlgo.Code
sel = Selection("%sSel_%s" % (name, validDecayName),
Algorithm=_subsAlgo,
RequiredSelections=[wmSel])
sel = Selection(name + 'Sel_' + validDecayName + 'Filter',
Algorithm=FilterDesktop(
'DummyName',
Code='(in_range(1764.84, MM, 1964.84))'),
RequiredSelections=[sel]) # hi
algoList.append(sel)
#mySelections[validDecayName] = sel
print 'algoList', algoList
mySelections[nominalDecayName] = MergedSelection(
"%sMSel_%s" % (name, nominalDecayName),
RequiredSelections=algoList)
print 'mySelections', mySelections
return mySelections
# Stream and stripping line we want to use
stream = 'AllStreams'
line = 'D2hhPromptDst2D2KKLine'
tesLoc = '/Event/{0}/Phys/{1}/Particles'.format(stream, line)
# get the selection(s) created by the stripping
strippingSels = [DataOnDemand(Location=tesLoc)]
# configure an algorithm to substitute the Kaon in the D0-decay by a second
# pion
subs = SubstitutePID(
'MakeD02pipi',
Code="DECTREE('[D*(2010)+ -> (D0 -> K- K+) pi+]CC')",
# note that SubstitutePID can't handle automatic CC
Substitutions={
'Charm -> (D0 -> ^K- pi+) Meson': 'pi-',
'Charm -> (D~0 -> ^K+ pi-) Meson': 'pi+',
'Charm -> (D0 -> K- ^K+) Meson': 'pi+',
'Charm -> (D~0 -> K+ ^K-) Meson': 'pi-'
}
)
# create a selection using the substitution algorithm
selSub = Selection(
'Dst2D0pi_D02pipi_Sel',
Algorithm=subs,
RequiredSelections=strippingSels
)
# in order to add the selection into the program make a sequence
selSeq = SelectionSequence('SelSeq', TopSelection=selSub)
##### Mass substitution ##########
# ie do the magic
from Configurables import SubstitutePID
from PhysSelPython.Wrappers import DataOnDemand
name = 'kkpi0RG'
line = 'Beauty2XGamma2pi_pi0R_Line'
#line = 'Beauty2XGammaphiOmega_2pipi0R_Line'
particles = '/Event/AllStreams/Phys/'+line+'/Particles'
inputs = [DataOnDemand(particles)]
b = 'B_s0'
r = ['phi(1680)' ,'phi(1020)']
d = ['K+' ,'K-']
sub = SubstitutePID(name+'Subst', Code="DECTREE('X0 -> (X0 -> (X0 -> X+ X- ) pi0 ) gamma')")
sub.Substitutions[' X0 -> ( X0 -> (X0 -> ^X+ X- ) pi0 ) gamma']= d[0]
sub.Substitutions[' X0 -> ( X0 -> (X0 -> X+ ^X- ) pi0 ) gamma']= d[1]
sub.Substitutions[' X0 -> ^( X0 -> (X0 -> X+ X- ) pi0 ) gamma']= r[0]
sub.Substitutions[' X0 -> ( X0 -> ^(X0 -> X+ X- ) pi0 ) gamma']= r[1]
sub.Substitutions[' X0 -> ( X0 -> (X0 -> X+ X- ) pi0 ) gamma']= b
filter = "INTREE(ID=='%s') & INTREE(ID=='%s') & INTREE(ID=='%s') & INTREE(ID=='%s') & INTREE(ID=='%s')" % (b,r[0],r[1],d[0],d[1]) # why is this needed??
sub.MaxParticles=2000
# define selection and sequence
from PhysSelPython.Wrappers import Selection, SelectionSequence
from Configurables import FilterDesktop, GaudiSequencer
sel_sub = Selection(name+'SubSel', Algorithm=sub, RequiredSelections=inputs)
filt = FilterDesktop(name+'Filt', Code=filter)
sel_filt= Selection(name+'FiltSel', Algorithm=filt, RequiredSelections=[sel_sub])
def __Lambdastar__(self, Rho, conf):
"""
Make a Lambda*
"""
ddksrsChangeAlg = SubstitutePID( self.name+"LSrsSubPIDAlg",
Code = "DECTREE('X0 -> X+ X-')",
Substitutions = { ' X0 -> ^X+ X- ' : 'p+' ,
' X0 -> X+ ^X- ' : 'K-' ,
' X0 -> X+ X- ' : 'Lambda(1520)0'},
MaxChi2PerDoF = -666 )
newDksrsDescr = Selection( self.name+"_Lambdastar_rsSubPIDSel",
Algorithm = ddksrsChangeAlg,
RequiredSelections = [Rho])
srsPick = Selection(self.name+"_Lambdastar_rsPickDecay",
Algorithm = FilterDesktop( Code = "DECTREE('Lambda(1520)0 -> p+ K-')" ),
RequiredSelections = [newDksrsDescr])
ddaksrsChangeAlg = SubstitutePID( self.name+"LSarsSubPIDAlg",
Code = "DECTREE('X0 -> X+ X-')",
Substitutions = { ' X0 -> X+ ^X- ' : 'p~-' ,
' X0 -> ^X+ X- ' : 'K+' ,
' X0 -> X+ X- ' : 'Lambda(1520)~0'},
MaxChi2PerDoF = -666 )
newDaksrsDescr = Selection( self.name+"_aLambdastar_rsSubPIDSel",
Algorithm = ddaksrsChangeAlg,
RequiredSelections = [Rho])
asrsPick = Selection(self.name+"_Lambdastar_arsPickDecay",
Algorithm = FilterDesktop( Code = "DECTREE('Lambda(1520)~0 -> p~- K+')" ),
RequiredSelections = [newDaksrsDescr])
ddkswsChangeAlg = SubstitutePID( self.name+"LSwsSubPIDAlg",
Code = "DECTREE('X0 -> X+ X+')",
Substitutions = { ' X0 -> ^X+ X+ ' : 'p+' ,
' X0 -> X+ ^X+ ' : 'K+' ,
' X0 -> X+ X+ ' : 'Lambda(1520)0'},
MaxChi2PerDoF = -666 )
newDkswsDescr = Selection( self.name+"_Lambdastar_wsSubPIDSel",
Algorithm = ddkswsChangeAlg,
RequiredSelections = [Rho])
dd2kswsChangeAlg = SubstitutePID( self.name+"LSws2SubPIDAlg",
Code = "DECTREE('X0 -> X+ X+')",
Substitutions = { ' X0 -> X+ ^X+ ' : 'p+' ,
' X0 -> ^X+ X+ ' : 'K+' ,
' X0 -> X+ X+ ' : 'Lambda(1520)0'},
MaxChi2PerDoF = -666 )
newD2kswsDescr = Selection( self.name+"_Lambdastar_ws2SubPIDSel",
Algorithm = dd2kswsChangeAlg,
RequiredSelections = [Rho])
swsPick = Selection(self.name+"_Lambdastar_wsPickDecay",
Algorithm = FilterDesktop( Code = "DECTREE('Lambda(1520)0 -> p+ K+')" ),
RequiredSelections = [newDkswsDescr, newD2kswsDescr])
ddakswsChangeAlg = SubstitutePID( self.name+"LSawsSubPIDAlg",
Code = "DECTREE('X0 -> X- X-')",
Substitutions = { ' X0 -> ^X- X- ' : 'p~-' ,
' X0 -> X- ^X- ' : 'K-' ,
' X0 -> X- X- ' : 'Lambda(1520)~0'},
MaxChi2PerDoF = -666 )
newDakswsDescr = Selection( self.name+"_Lambdastar_awsSubPIDSel",
Algorithm = ddakswsChangeAlg,
RequiredSelections = [Rho])
dd2akswsChangeAlg = SubstitutePID( self.name+"LSaws2SubPIDAlg",
Code = "DECTREE('X0 -> X- X-')",
Substitutions = { ' X0 -> X- ^X- ' : 'p~-' ,
' X0 -> ^X- X- ' : 'K-' ,
' X0 -> X- X- ' : 'Lambda(1520)~0'},
MaxChi2PerDoF = -666 )
newD2akswsDescr = Selection( self.name+"_Lambdastar_aws2SubPIDSel",
Algorithm = dd2akswsChangeAlg,
RequiredSelections = [Rho])
aswsPick = Selection(self.name+"_Lambdastar_awsPickDecay",
Algorithm = FilterDesktop( Code = "DECTREE('Lambda(1520)~0 -> p~- K-')" ),
RequiredSelections = [newDakswsDescr, newD2akswsDescr])
_selLAMBDASTAR2PK = MergedSelection("Selection_"+self.name+"_Lambdastar",
RequiredSelections = [srsPick, asrsPick, swsPick, aswsPick])
return _selLAMBDASTAR2PK
def __Phi__(self, Rho, conf):
"""
Make a phi
"""
# _phi2kk = CombineParticles()
# _phi2kk.DecayDescriptors = [ "phi(1020) -> K+ K-", "phi(1020) -> K+ K+", "phi(1020) -> K- K-" ]
# _phi2kk.MotherCut = self.__KpiCuts__(conf)
#
# _selPHI2KK = Selection( "Selection_"+self.name+"_Phi",
# Algorithm = _phi2kk,
# RequiredSelections = [ Kaons ] )
ddksrsChangeAlg = SubstitutePID( self.name+"PhirsSubPIDAlg",
Code = "DECTREE('X0 -> X+ X-')",
Substitutions = { ' X0 -> ^X+ X- ' : 'K+' ,
' X0 -> X+ ^X- ' : 'K-' ,
' X0 -> X+ X- ' : 'phi(1020)'},
MaxChi2PerDoF = -666 )
newDksrsDescr = Selection( self.name+"_Phi_rsSubPIDSel",
Algorithm = ddksrsChangeAlg,
RequiredSelections = [Rho])
srsPick = Selection(self.name+"_Phi_rsPickDecay",
Algorithm = FilterDesktop( Code = "DECTREE('phi(1020) -> K+ K-')" ),
RequiredSelections = [newDksrsDescr])
ddkswsChangeAlg = SubstitutePID( self.name+"PhiwsSubPIDAlg",
Code = "DECTREE('X0 -> X+ X+')",
Substitutions = { ' X0 -> ^X+ X+ ' : 'K+' ,
' X0 -> X+ ^X+ ' : 'K+' ,
' X0 -> X+ X+ ' : 'phi(1020)'},
MaxChi2PerDoF = -666 )
newDkswsDescr = Selection( self.name+"_Phi_wsSubPIDSel",
Algorithm = ddkswsChangeAlg,
RequiredSelections = [Rho])
swsPick = Selection(self.name+"_Phi_wsPickDecay",
Algorithm = FilterDesktop( Code = "DECTREE('phi(1020) -> K+ K+')" ),
RequiredSelections = [newDkswsDescr])
ddakswsChangeAlg = SubstitutePID( self.name+"PhiawsSubPIDAlg",
Code = "DECTREE('X0 -> X- X-')",
Substitutions = { ' X0 -> X- ^X- ' : 'K-' ,
' X0 -> ^X- X- ' : 'K-' ,
' X0 -> X- X- ' : 'phi(1020)'},
MaxChi2PerDoF = -666 )
newDakswsDescr = Selection( self.name+"_Phi_awsSubPIDSel",
Algorithm = ddakswsChangeAlg,
RequiredSelections = [Rho])
aswsPick = Selection(self.name+"_Phi_awsPickDecay",
Algorithm = FilterDesktop( Code = "DECTREE('phi(1020) -> K- K-')" ),
RequiredSelections = [newDakswsDescr])
_selPHI2KK = MergedSelection("Selection_"+self.name+"_Phi",
RequiredSelections = [srsPick, swsPick, aswsPick])
return _selPHI2KK
def __Kstar__(self, Rho, conf):
"""
Make a kstar
"""
ddksrsChangeAlg = SubstitutePID( self.name+"rsSubPIDAlg",
Code = "DECTREE('X0 -> X+ X-')",
Substitutions = { ' X0 -> ^X+ X- ' : 'K+' ,
' X0 -> X+ X- ' : 'K*(892)0'},
MaxChi2PerDoF = -666 )
newDksrsDescr = Selection( self.name+"_Kstar_rsSubPIDSel",
Algorithm = ddksrsChangeAlg,
RequiredSelections = [Rho])
srsPick = Selection(self.name+"_Kstar_rsPickDecay",
Algorithm = FilterDesktop( Code = "DECTREE('K*(892)0 -> K+ pi-')" ),
RequiredSelections = [newDksrsDescr])
ddaksrsChangeAlg = SubstitutePID( self.name+"arsSubPIDAlg",
Code = "DECTREE('X0 -> X+ X-')",
Substitutions = { ' X0 -> X+ ^X- ' : 'K-' ,
' X0 -> X+ X- ' : 'K*(892)~0'},
MaxChi2PerDoF = -666 )
newDaksrsDescr = Selection( self.name+"_aKstar_rsSubPIDSel",
Algorithm = ddaksrsChangeAlg,
RequiredSelections = [Rho])
asrsPick = Selection(self.name+"_Kstar_arsPickDecay",
Algorithm = FilterDesktop( Code = "DECTREE('K*(892)~0 -> K- pi+')" ),
RequiredSelections = [newDaksrsDescr])
ddkswsChangeAlg = SubstitutePID( self.name+"wsSubPIDAlg",
Code = "DECTREE('X0 -> X+ X+')",
Substitutions = { ' X0 -> ^X+ X+ ' : 'K+' ,
' X0 -> X+ X+ ' : 'K*(892)0'},
MaxChi2PerDoF = -666 )
newDkswsDescr = Selection( self.name+"_Kstar_wsSubPIDSel",
Algorithm = ddkswsChangeAlg,
RequiredSelections = [Rho])
dd2kswsChangeAlg = SubstitutePID( self.name+"ws2SubPIDAlg",
Code = "DECTREE('X0 -> X+ X+')",
Substitutions = { ' X0 -> X+ ^X+ ' : 'K+' ,
' X0 -> X+ X+ ' : 'K*(892)0'},
MaxChi2PerDoF = -666 )
newD2kswsDescr = Selection( self.name+"_Kstar_ws2SubPIDSel",
Algorithm = dd2kswsChangeAlg,
RequiredSelections = [Rho])
swsPick = Selection(self.name+"_Kstar_wsPickDecay",
Algorithm = FilterDesktop( Code = "DECTREE('K*(892)0 -> K+ pi+')" ),
RequiredSelections = [newDkswsDescr, newD2kswsDescr])
ddakswsChangeAlg = SubstitutePID( self.name+"awsSubPIDAlg",
Code = "DECTREE('X0 -> X- X-')",
Substitutions = { ' X0 -> ^X- X- ' : 'K-' ,
' X0 -> X- X- ' : 'K*(892)~0'},
MaxChi2PerDoF = -666 )
newDakswsDescr = Selection( self.name+"_aKstar_wsSubPIDSel",
Algorithm = ddakswsChangeAlg,
RequiredSelections = [Rho])
dd2akswsChangeAlg = SubstitutePID( self.name+"aws2SubPIDAlg",
Code = "DECTREE('X0 -> X- X-')",
Substitutions = { ' X0 -> X- ^X- ' : 'K-' ,
' X0 -> X- X- ' : 'K*(892)~0'},
MaxChi2PerDoF = -666 )
newD2akswsDescr = Selection( self.name+"_aKstar_ws2SubPIDSel",
Algorithm = dd2akswsChangeAlg,
RequiredSelections = [Rho])
aswsPick = Selection(self.name+"_Kstar_awsPickDecay",
Algorithm = FilterDesktop( Code = "DECTREE('K*(892)~0 -> K- pi-')" ),
RequiredSelections = [newDakswsDescr, newD2akswsDescr])
_selKSTAR2KPI = MergedSelection("Selection_"+self.name+"_Kstar",
RequiredSelections = [srsPick, asrsPick, swsPick, aswsPick])
# _kstar2kpi.DecayDescriptors = [ "[K*(892)0 -> K+ pi-]cc", "[K*(892)0 -> K+ pi+]cc" ]
#
return _selKSTAR2KPI
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)
