def __init__(self, name, xplus="mu", xminus="mu", version="signal"):
from HltTracking.HltPVs import PV3D
# Dictionary of the inputs
inputlist = {
"mu": Hlt2Muons,
"pi": Hlt2Pions,
"K": Hlt2Kaons,
"p": Hlt2Protons,
"e": Hlt2Electrons,
}
# Current input
inputs = [inputlist[xminus]] if (
xminus == xplus) else [inputlist[xminus], inputlist[xplus]]
# dictionary of the daughter cuts
d0comb_childcut_list =\
( { xplus+'+' : self.d0comb_childcut } if ( xplus == xminus ) else \
{ xplus+'+' : self.d0comb_childcut,
xminus+'+' : self.d0comb_childcut}
)
# Decay descriptor
decay = "D0 -> " + xplus + "+ " + xminus + "-" if (
xplus == xminus) else "[D0 -> " + xplus + "+ " + xminus + "- ]cc"
# Combiner
Hlt2Combiner.__init__(
self,
name,
decay,
inputs,
dependencies=[PV3D('Hlt2')],
#tistos = 'TisTosSpec',
DaughtersCuts=d0comb_childcut_list,
CombinationCut=self.d0comb_combcut_sig
if version == "signal" else self.d0comb_combcut,
MotherCut=self.d0comb_d0cut,
Preambulo=[])
def __init__(self, name, inputs):
daughters_cuts = {
"mu-":
("(TRCHI2DOF < %(MuonTRCHI2)s ) & (P> %(MuonP)s *MeV) & (PT> %(MuonPT)s* MeV)"
+ "& (TRGHOSTPROB < %(MuonGHOSTPROB)s)" +
"& (PIDmu-PIDpi> %(MuonPIDmu)s )" +
"& (PIDmu-PIDp> %(MuonPIDp)s )" +
"& (PIDmu-PIDK> %(MuonPIDK)s )" +
"& (MIPCHI2DV(PRIMARY)> %(MuonMINIPCHI2)s )"),
"pi+": ("(P > %(Lambda0DaugP)s)& (PT > %(Lambda0DaugPT)s)" +
"& (TRCHI2DOF < %(Lambda0DaugTrackChi2)s)" +
"& (MIPCHI2DV(PRIMARY) > %(Lambda0DaugMIPChi2)s)")
}
combination_cuts = "(ADOCACHI2CUT(25, ''))"
mother_cuts = "( M > %(MajoranaCutM)s*MeV )&( BPVVDCHI2 > %(MajoranaCutFDChi2)s )&( VFASPF(VCHI2/VDOF) < %(Lambda0VertexChi2)s )&( PT > %(Lambda0PT)s*MeV )"
decay = "[Lambda0 -> mu- pi+]cc"
Hlt2Combiner.__init__(self,
name,
decay,
inputs,
nickname='LambdaMuPi',
dependencies=[PV3D('Hlt2')],
DaughtersCuts=daughters_cuts,
CombinationCut=combination_cuts,
MotherCut=mother_cuts,
Preambulo=[])
def __init__(self, inputs):
from Hlt1Lines.Hlt1MVALines import Hlt1MVALinesConf
props = Hlt1MVALinesConf().getProps()
pids = ['K+', 'K-', 'KS0', 'Lambda0', 'Lambda~0']
basic = "(ABSID=='K+')"
combos = list(combinations_with_replacement(pids, 2))
decays = ['K*(892)0 -> ' + ' '.join(combo) for combo in combos]
cc = ("(APT > %(CMB_PRT_PT_MIN)s) "
"& (ANUM((ID=='KS0')|(ABSID=='Lambda0')) < 2) "
"& (ACUTDOCACHI2(%(CMB_VRT_CHI2_MAX)s, '')) "
"& ((AALLSAMEBPV | (AMINCHILD(MIPCHI2DV(PRIMARY)) > 16)) "
"| (ANUM((ID == 'KS0') | (ABSID == 'Lambda0')) > 0)) "
"& (AM < %(CMB_VRT_MCOR_MAX)s) "
"& (ANUM(" + basic + " & (MIPCHI2DV(PRIMARY) < 16)) <"
" %(CMB_TRK_NLT16_MAX)s) ")
mc = ("(HASVERTEX)"
"& (VFASPF(VCHI2) < %(CMB_VRT_CHI2_MAX)s) "
"& (BPVVDCHI2 > %(CMB_VRT_VDCHI2_MIN)s) "
"& (in_range(%(CMB_VRT_ETA_MIN)s, BPVETA,"
" %(CMB_VRT_ETA_MAX)s)) ")
from Hlt2Lines.Utilities.Hlt2MergedStage import Hlt2MergedStage
merged = [Hlt2MergedStage('Topo2BodyTos', inputs, shared=True)]
from HltTracking.HltPVs import PV3D
Hlt2Combiner.__init__(self,
'Topo2BodyTos',
decays,
merged,
shared=True,
tistos='ALLTOS',
dependencies=[PV3D('Hlt2')],
CombinationCut=cc,
MotherCut=mc)
def __init__(self, name):
daughters_cuts = { "pi+" : "(TRCHI2DOF< %(TrChi2)s) & (TRGHOSTPROB< %(TrGP)s) & "+\
"(MIPCHI2DV(PRIMARY)>%(piMinIpChi2)s)",
}
combination_cuts = "(ADAMASS('K+') < %(KMassWin)s ) & " + \
"(AMAXDOCA('') < %(KMaxDOCA)s )"
mother_cuts = "(VFASPF(VCHI2/VDOF)< %(KVtxChi2)s) & " + \
"(PT > %(KMinPt)s ) & " + \
"(ADMASS('K+') < %(KMassWin)s ) & "\
"(BPVDIRA > %(KMinDIRA)s) & "\
"(BPVIPCHI2() < %(KMaxIpChi2)s) & "\
"(BPVLTIME() > %(KMinTauPs)s )"
inputs = [Hlt2Pions]
decay = "[K+ -> pi+ pi+ pi-]cc"
Hlt2Combiner.__init__(self,
name,
decay,
inputs,
dependencies=[PV3D('Hlt2')],
DaughtersCuts=daughters_cuts,
CombinationCut=combination_cuts,
MotherCut=mother_cuts,
Preambulo=[])
def __init__(self, inputs):
pids = ['K+', 'K-']
combos = list(combinations_with_replacement(pids, 1))
basic = "((ABSID=='K+')|(ID=='KS0')|(ABSID=='Lambda0'))"
decays = ['B0 -> D*(2010)+ ' + ' '.join(combo) for combo in combos]
cc = ("(AM < %(CMB_VRT_MCOR_MAX)s) "
"& (ACUTDOCACHI2(%(CMB_VRT_CHI2_MAX)s, '')) "
"& (AALLSAMEBPV | (AMINCHILD(MIPCHI2DV(PRIMARY)) > 16)) "
"& (APT > %(CMB_PRT_PT_MIN)s) ")
mc = ("(HASVERTEX) "
"& (VFASPF(VCHI2) < %(CMB_VRT_CHI2_MAX)s) "
"& (BPVVDCHI2 > %(CMB_VRT_VDCHI2_MIN)s) "
"& (in_range(%(CMB_VRT_ETA_MIN)s, BPVETA,"
" %(CMB_VRT_ETA_MAX)s)) "
"& (BPVDIRA > %(CMB_VRT_DIRA_MIN)s)")
from Hlt2Lines.Utilities.Hlt2MergedStage import Hlt2MergedStage
merged = [Hlt2MergedStage('Topo4Body', inputs, shared=True)]
from HltTracking.HltPVs import PV3D
Hlt2Combiner.__init__(self,
'Topo4Body',
decays,
merged,
shared=True,
dependencies=[PV3D('Hlt2')],
CombinationCut=cc,
MotherCut=mc)
def __init__(self, inputs, tag=None):
cc = ("(AMINCHILD(PT) > %(JET_PT)s)"
" & (abs(ACHILD(PHI,1) - ACHILD(PHI,2)) > %(DPHI)s)")
if tag == 'SV':
cc += (" & ((ACHILD(INFO(9600, -1), 1) != -1)"
" | (ACHILD(INFO(9600, -1), 2) != -1))")
elif tag == 'SVSV':
cc += (" & (ACHILD(INFO(9600, -1), 1) != -1)"
" & (ACHILD(INFO(9600, -1), 2) != -1)")
elif tag == 'MuMu':
cc += (" & (ACHILD(INFO(9601, -1), 1) != -1)"
" & (ACHILD(INFO(9601, -1), 2) != -1)")
elif tag == "SVMu":
cc += (" & (((ACHILD(INFO(9600, -1), 1) != -1)"
" & (ACHILD(INFO(9601, -1), 2) != -1))"
" | ((ACHILD(INFO(9601, -1), 1) != -1)"
" & (ACHILD(INFO(9600, -1), 2) != -1)))")
Hlt2Combiner.__init__(self,
'DiJet' + tag, ["CLUSjet -> CELLjet CELLjet"],
inputs,
dependencies=[PV3D('Hlt2')],
CombinationCut=cc,
MotherCut='(ALL)',
Preambulo=[],
shared=True,
ParticleCombiners={'': 'ParticleAdder'})
def __init__(self, name, inputs, nickname = None, decay = "[B+ -> J/psi(1S) K+]cc", corrm = False):
cc = ("(in_range(%(LLhCombAMLow)s, AM, %(LLhCombAMHigh)s)) & "
+ "(APT1+APT2 > %(LLhSumPTMin)s)")
if corrm:
mc_mass = " & (in_range(%(LLhCombBPVCORRMLow)s, BPVCORRM, %(LLhCombBPVCORRMHigh)s))"
else:
mc_mass = " & (in_range(%(LLhCombMLow)s, M, %(LLhCombMHigh)s))"
mc = ("(VFASPF(VCHI2)<%(LLhVChi2)s) & (BPVVDCHI2 > %(LLhVDChi2)s)"
+ " & (BPVIPCHI2()<%(LLhMaxIPChi2)s)"
+ " & (BPVDIRA > %(LLhMinBPVDIRA)s)"
+ mc_mass)
dc = { }
for daug in ['p+', 'pi+', 'K+', 'mu+', 'e+']:
dc[daug] = ("(PT > %(BachPt)s)" +
" & (P > %(BachP)s)" +
" & (MIPCHI2DV(PRIMARY) > %(BachIPChi2)s)")
if nickname is None:
nickname = name
from HltTracking.HltPVs import PV3D
Hlt2Combiner.__init__(self, 'PID' + name + 'BCombiner',
decay,
inputs,
shared = True,
nickname = nickname,
dependencies = [ PV3D('Hlt2') ],
tistos = 'CombTisTosSpec',
DaughtersCuts = dc,
CombinationCut = cc,
MotherCut = mc,
Preambulo = [ ])
def __init__(self, name):
from HltTracking.HltPVs import PV3D
twoMuElDaughterCut = "(TRCHI2DOF< %(Trk_TRCHI2DOF_MAX_mueX)s )" \
"& (PT> %(Trk_PT_MIN_mueX)s)" \
"& (P> %(Trk_P_MIN_mueX)s)" \
"& (MIPCHI2DV(PRIMARY)> %(Trk_MIPCHI2DV_MIN_mueX)s )"
twoMuElCombCut = "(AM<2100)" \
"& ((APT1+APT2)> %(Pair_SumAPT_MIN_mueX)s)" \
"& (AMINDOCA('LoKi::TrgDistanceCalculator') < %(Pair_AMINDOCA_MAX_mueX)s )" \
"& (AALLSAMEBPV)"
twoMuElMotherCut = "(BPVVD> %(Pair_BPVVD_MIN_mueX)s )" \
"& (BPVCORRM < %(Pair_BPVCORRM_MAX_mueX)s)" \
"& (BPVVDCHI2> %(Pair_BPVVDCHI2_MIN_mueX)s )"
#First stage - Combine 2 Body with pt > 500MeV
inputs = [Hlt2Muons, Hlt2Electrons]
Hlt2Combiner.__init__(self,
name, [
"J/psi(1S) -> mu+ e-", "phi(1020) -> e+ mu-",
"rho(770)0 -> mu+ e+", "eta -> mu- e-"
],
inputs,
dependencies=[PV3D('Hlt2')],
DaughtersCuts={
"mu+": twoMuElDaughterCut,
"e-": twoMuElDaughterCut
},
CombinationCut=twoMuElCombCut,
MotherCut=twoMuElMotherCut,
Preambulo=[],
shared=True)
def __init__(self, name):
picut = ("( TRCHI2DOF < %(TrChi2)s )" + " & ( PT > %(PionPT)s)" +
" & ( PIDK < %(PidCutPions)s )")
kcut = ("( TRCHI2DOF < %(TrChi2)s )" + " & ( PT > %(PionPT)s)" +
" & ( PIDK > %(PidCutKaons)s )")
pcut = ("( TRCHI2DOF < %(TrChi2)s )" + " & ( PT > %(PionPT)s)" +
" & ( PIDp > %(PidCutProtons)s )")
dc = {'pi+': picut, 'K+': kcut, 'p+': pcut}
cc = ("( (APT1 + APT2) > %(SumPT)s )" + " & ( AM > %(BMassWinLow)s )" +
" & ( AM < %(BMassWinHigh)s )" +
" & ( ACUTDOCACHI2( %(DOCACHI2)s, '' ) )")
mc = ("( PT > %(BPT)s )" + " & ( BPVDIRA > %(BDIRA)s )" +
" & ( BPVIPCHI2() < %(BIPCHI2)s )" +
" & ( BPVLTIME() > %(BLT)s )")
from HltTracking.HltPVs import PV3D
from Inputs import Hlt2RichPions, Hlt2RichKaons, Hlt2RichProtons
inputs = [Hlt2RichPions]
Hlt2Combiner.__init__(self,
'B2PiPi',
"B0 -> pi+ pi-",
inputs,
dependencies=[PV3D('Hlt2')],
tistos='TisTosSpec',
DaughtersCuts=dc,
CombinationCut=cc,
MotherCut=mc,
Preambulo=[])
def __init__(self, name, decayDesc, inputSeq):
from HltTracking.HltPVs import PV3D
# massmin = min(float("%(Sig_M_MIN_HHmumu)s"), float("%(WideMass_M_MIN_HHmumu)s"))
# massmax = max(float("%(Sig_M_MAX_HHmumu)s"), float("%(WideMass_M_MAX_HHmumu)s"))
# masscut = "in_range(%s, M, %s)" % (massmin, massmax)
masscut = "in_range( %(WideMass_M_MIN_HHmumu)s , M , %(WideMass_M_MAX_HHmumu)s )"
combcuts = "(AM<2100)" \
"& (AMAXCHILD(PT) > %(TrkPtMAX_HHmumu)s) " \
"& ((APT1+APT2+APT3+APT4) > %(DSumPt_HHmumu)s)" \
"& (AMINDOCA('LoKi::TrgDistanceCalculator') < %(PairMinDoca_HHmumu)s)" \
"& (AMAXDOCA('LoKi::TrgDistanceCalculator') < %(PairMaxDoca_HHmumu)s)" \
"& (AALLSAMEBPV)"
mothercuts = masscut + \
"& (VFASPF(VCHI2PDOF) < %(VtxChi2_HHmumu)s) " \
"& (BPVCORRM < %(MCOR_MAX_HHmumu)s)" \
"& (BPVDIRA > %(DDira_HHmumu)s ) " \
"& (BPVVDCHI2> %(VtxPVDispChi2_HHmumu)s )" \
"& ( SUMTREE( ( (ID=='K+') | (ID=='K-') | (ID=='pi+') | (ID=='pi-') | (ID=='mu+') | (ID=='mu-') | (ID=='e+') | (ID=='e-') ), sqrt(BPVIPCHI2()) ) > %(TrkPVIPChi2MAX_HHmumu)s)"\
"& (BPVIPCHI2() < %(DIPChi2_HHmumu)s )"
Hlt2Combiner.__init__(self,
name,
decayDesc,
inputSeq,
dependencies=[PV3D('Hlt2')],
CombinationCut=combcuts,
MotherCut=mothercuts,
Preambulo=[],
shared=True)
def __init__(self, mode, nickname, stat):
if nickname == 'MuonTT':
overlap = (
"(AOVERLAP(1,2, LHCb.LHCbID.TT) > %(OverlapTT)s) & (AOVERLAP(1,2, LHCb.LHCbID.Muon) > %(OverlapMuon)s)"
)
elif nickname == 'VeloMuon':
overlap = (
"(AOVERLAP(1,2, LHCb.LHCbID.Velo) > %(OverlapVelo)s) & (AOVERLAP(1,2, LHCb.LHCbID.Muon) > %(OverlapMuon)s)"
)
else:
overlap = (
"(AOVERLAP(1,2, LHCb.LHCbID.TT) > %(OverlapTT)s) & ((AOVERLAP(1,2, LHCb.LHCbID.IT) > %(OverlapIT)s) | (AOVERLAP(1,2, LHCb.LHCbID.OT) > %(OverlapOT)s))"
)
inputs = [
TagFilter(mode, nickname),
ProbeFilter(mode, nickname, stat),
LongFilter(mode, nickname)
]
decay = "J/psi(1S) -> pi+ mu+ mu-" if mode == 1 else "J/psi(1S) -> pi- mu- mu+"
Hlt2Combiner.__init__(self,
'TrackEff' + nickname + str(mode) + stat +
'N3Body',
decay,
inputs,
combiner=N3Body,
dependencies=[PV3D('Hlt2')],
nickname=nickname,
tistos=[],
Combination12Cut=overlap,
ParticleCombiners={"": "MomentumCombiner"},
MotherCut="ALL",
Preambulo=[],
shared=True)
def __init__(self, name, decay, inputs):
dc = {'K+': "(PT > %(PTmin)s)", 'K-': "(PT > %(PTmin)s)"}
mc = ("ALL")
Hlt2Combiner.__init__(self,
name,
decay,
inputs,
DaughtersCuts=dc,
MotherCut=mc,
Preambulo=[])
def __init__(self, name, decay, inputs):
dc = {'e+': "(PT > %(e_PTmin)s)", 'e-': "(PT > %(e_PTmin)s)"}
mc = "ALL"
Hlt2Combiner.__init__(self,
name,
decay,
inputs,
dependencies=[TrackGEC(name)],
DaughtersCuts=dc,
MotherCut=mc,
Preambulo=[])
def __init__(self, name, decay, inputs):
dc = {'gamma': "(PT > %(gamma_PTmin)s)"}
mc = ("( (M > %(digamma_AMmin)s) & (M < %(digamma_AMmax)s) )")
Hlt2Combiner.__init__(self,
name,
decay,
inputs,
dependencies=[TrackGEC(name)],
DaughtersCuts=dc,
ParticleCombiners={'': 'ParticleAdder'},
MotherCut=mc)
def __init__(self, name, inputs):
cc = "APT > %(PT)s"
mc = ("(HASVERTEX)"
"& (VFASPF(VCHI2) < %(VChi2)s) ")
Hlt2Combiner.__init__(self, name, "B0 -> KS0 KS0", inputs,
dependencies = [PV3D('Hlt2')],
#DaughtersCuts = dc,
CombinationCut = cc,
MotherCut = mc,
Preambulo = [])
def __init__(self, name,inputs):
combCut = ("(in_range( %(D0_MinAM)s,AM, %(D0_MaxAM)s ))"
+ "& (AMAXDOCA('LoKi::TrgDistanceCalculator') < %(D0_MaxDOCA)s)")
motherCut = ("(BPVVDZ > %(D0_MinVDZ)s) & ((acos(BPVDIRA)*180./3.142) < %(D0_MaxACosDIRADeg)s) "
+ "& (VFASPF(VCHI2/VDOF)< %(D0_MaxVCHI2NDF)s)"
+"&(in_range( %(D0_MinSimpleFitM)s,D0_M, %(D0_MaxSimpleFitM)s ))")
from HltTracking.HltPVs import PV3D
from Preambulo import D0Preambulo
Hlt2Combiner.__init__(self, name,["[D0 -> K- pi+]cc","[D0 -> K- pi-]cc"], inputs,
dependencies = [TrackGEC('TrackGEC'), PV3D('Hlt2')],
tistos = 'TisTosSpec',
CombinationCut = combCut, MotherCut = motherCut,
Preambulo = D0Preambulo())
def __init__(self, name, decay, inputs):
dc = {'mu+': "(PT > %(mu_PTmin)s)", 'mu-': "(PT > %(mu_PTmin)s)"}
cc = ("(AM > %(AMmin)s)")
mc = "ALL"
Hlt2Combiner.__init__(self,
name,
decay,
inputs,
dependencies=[TrackGEC(name)],
DaughtersCuts=dc,
CombinationCut=cc,
MotherCut=mc,
Preambulo=[])
def __init__(self, name):
DauCuts = ( "%(DauCuts)s" )
ComCuts = ( "%(ComCuts)s" )
MomCuts = ( "%(MomCuts)s" )
from Inputs import Hlt2Protons
inputs = [ Hlt2Protons ]
Hlt2Combiner.__init__(self, name, "J/psi(1S) -> p+ p~-", inputs,
DaughtersCuts = { 'p+' : DauCuts },
CombinationCut = ComCuts,
MotherCut = MomCuts,
Preambulo = [])
def __init__(self, inputs):
cc = ("(abs(ACHILD(BPVPHI, 1) - ACHILD(PHI, 2)) > (%(DPHI)s - 1.0))"
" & (ACHILD(ABSID, 1) == 313) & (ACHILD(ABSID, 2) == 13)")
Hlt2Combiner.__init__(self,
'JetsSVMu',
["D0 -> K*(892)0 mu+", "D0 -> K*(892)0 mu-"],
inputs,
dependencies=[PV3D('Hlt2')],
CombinationCut=cc,
MotherCut='(ALL)',
Preambulo=[],
shared=True,
ParticleCombiners={'': 'ParticleAdder'})
def __init__(self, inputs):
cc = "(abs(ACHILD(PHI,1)-ACHILD(PHI,2)) > (%(DPHI)s-1.0))"
Hlt2Combiner.__init__(self,
'JetsMuMu',
["[D0 -> mu+ mu+]cc", "D0 -> mu+ mu-"],
inputs,
dependencies=[PV3D('Hlt2')],
CombinationCut=cc,
MotherCut='(ALL)',
Preambulo=[],
shared=True,
ParticleCombiners={'': 'ParticleAdder'})
def __init__(self, name):
DauCuts = ( "%(DauCuts)s" )
ComCuts = ( "%(ComCuts)s" )
MomCuts = ( "%(MomCuts)s" )
from Inputs import Hlt2UnbiasedPhi
inputs = [ Hlt2UnbiasedPhi ]
Hlt2Combiner.__init__(self, name, "J/psi(1S) -> phi(1020) phi(1020)", inputs,
DaughtersCuts = { 'phi(1020)' : DauCuts },
CombinationCut = ComCuts,
MotherCut = MomCuts,
Preambulo = [])
def __init__(self, name, inputs):
decay = "rho(770)0 -> pi+ pi-"
cc = "(AMINCHILD(PT,ISBASIC)>%(PI_PT_MIN)s)"
mc = "(M>%(RHO_M_MIN)s) & (M<%(RHO_M_MAX)s) & (PT>%(RHO_PT_MIN)s)"
from HltTracking.HltPVs import PV3D
Hlt2Combiner.__init__(self,
name,
decay,
inputs,
shared=True,
dependencies=[PV3D('Hlt2')],
CombinationCut=cc,
MotherCut=mc)
def __init__(self, inputs):
cc = "(abs(ACHILD(BPVPHI,1)-ACHILD(BPVPHI,2)) > (%(DPHI)s-1.0))"
Hlt2Combiner.__init__(self,
'JetsSVSV',
"D0 -> K*(892)0 K*(892)0",
inputs,
dependencies=[PV3D('Hlt2')],
CombinationCut=cc,
MotherCut='(ALL)',
Preambulo=[],
shared=True,
ParticleCombiners={'': 'ParticleAdder'})
def __init__(self, name):
inputs = [UnbiasedPhi2KK]
mc = ("(ALL)")
Hlt2Combiner.__init__(
self,
name,
"B_s0 -> phi(1020) phi(1020)",
inputs,
dependencies=[PV3D('Hlt2')],
tistos='TisTosSpec',
#DaughtersCuts = dc,
#CombinationCut = cc,
MotherCut=mc,
Preambulo=[])
def __init__(self, name, taginput, probeinput, mode, nickname, dependencies = [ ]):
if nickname == "JPsiMuMu":
decay = "J/psi(1S) -> mu+ mu-"
extra_cut = " & (ISMUON)"
lp = "mu+"
lm = "mu-"
elif nickname == "JPsiEE":
decay = "J/psi(1S) -> e+ e-"
extra_cut = " & (PIDe > %(TagPIDe)s)"
lp = "e+"
lm = "e-"
elif nickname == "JPsiPP":
decay = "J/psi(1S) -> p+ p~-"
extra_cut = " & (PIDp > %(TagPIDp)s)"
lp = "p+"
lm = "p~-"
elif nickname == "PhiMuMu":
decay = "phi(1020) -> mu+ mu-"
extra_cut = " & (ISMUON)"
lp = "mu+"
lm = "mu-"
elif nickname == "PhiKK":
decay = "phi(1020) -> K+ K-"
extra_cut = " & (PIDK > %(TagPIDK)s)"
lp = "K+"
lm = "K-"
else:
print "Don't know how to handle: " + nickname
name = "PID" + name + "Tagged"
dc = {
lp : "ALL",
lm : "ALL"
}
cc = ("(in_range(%(LLCombAMLow)s, AM, %(LLCombAMHigh)s)) & (ACHI2DOCA(1,2) < %(LLCombMaxDocaChi2)s)")
mc = ("(in_range(%(LLCombMLow)s, M, %(LLCombMHigh)s))")
from HltTracking.HltPVs import PV3D
Hlt2Combiner.__init__(self, name,
decay,
[ TagFilter(name, taginput, mode, nickname, extra_cut), ProbeFilter(name, probeinput, mode, nickname) ],
dependencies = [ PV3D('Hlt2') ] + dependencies,
#tistos = 'LLTisTos',
DaughtersCuts = dc,
CombinationCut = cc,
MotherCut = mc,
Preambulo = [ ],
shared = True,
nickname = nickname)
def __init__(self, name):
JpsiCuts = ( "%(JpsiCuts)s" )
DauCuts = ( "%(DauCuts)s" )
ComCuts = ( "%(ComCuts)s" )
MomCuts = ( "%(MomCuts)s" )
from Inputs import BiKalmanFittedPions
inputs = [ DiMuonFilter("JpsiForBc2JpsiH", JpsiCuts, nickname=name),
BiKalmanFittedPions ]
Hlt2Combiner.__init__(self, name, "[ B_c+ -> J/psi(1S) pi+ ]cc", inputs,
DaughtersCuts = { 'pi+' : DauCuts },
CombinationCut = ComCuts,
MotherCut = MomCuts,
Preambulo = [])
def __init__(self, name):
cc = (" (APT > %(D0_PT_MIN)s)" +
" & (ACUTDOCACHI2(%(D0_DOCACHI2_MAX)s,''))" +
" & (ADAMASS('D0') < %(D0_MASS_WINDOW)s)")
mc = ("(VFASPF(VCHI2/VDOF) < %(D0_VCHI2NDOF_MAX)s)")
from HltTracking.HltPVs import PV3D
inputs = [goodKs]
Hlt2Combiner.__init__(self,
name,
"[D0 -> KS0 KS0]cc",
inputs,
dependencies=[PV3D('Hlt2')],
CombinationCut=cc,
MotherCut=mc,
Preambulo=[])
def __init__(self, name, decay, inputs, pidcut={}):
dc = pidcut
cc = ("(APT > %(APTmin)s)" + "& (APT < %(APTmax)s)" +
"& (AP > %(APmin)s)" + "& (ADOCAMAX('') < %(ADOCAmax)s)" +
"& (in_range( %(AMmin)s, AM, %(AMmax)s ))")
mc = ("(VFASPF(VCHI2PDOF) < %(VtxChi2DoFmax)s)")
Hlt2Combiner.__init__(self,
name,
decay,
inputs,
dependencies=[TrackGEC(name)],
DaughtersCuts=dc,
CombinationCut=cc,
MotherCut=mc,
Preambulo=[])
def __init__(self, name,inputs):
## opening angle between slow pion and D0 flight
dot_prod = "(ACHILD( VFASPF( VX ),1)*ACHILD(PX,2) + ACHILD( VFASPF( VY ),1)*ACHILD(PY,2) + ACHILD( VFASPF( VZ ),1)*ACHILD(PZ,2))"
mag = "math.sqrt(ACHILD( VFASPF( VX ),1)**2+ACHILD( VFASPF( VY ),1)**2+ACHILD( VFASPF( VZ ),1)**2)"
formula = "(180./3.1415)*acos( %(dot_prod)s / (ACHILD(P,2)*%(mag)s) )" %{"dot_prod":dot_prod,
"mag":mag}
DstCombinationCut = "("+formula+" < %(Dst_MaxAOA)s) & (APT > %(Dst_MinAPT)s ) & (AALLSAMEBPV)"
DstMotherCut = "(Dst_M - D0_M < %(Dst_MaxSimpleFitDeltaMass)s)"
DaughtersCuts = {'pi+' : "(PT > %(Slowpi_MinPt)s)"}
from HltTracking.HltPVs import PV3D
from Preambulo import DstPreambulo
Hlt2Combiner.__init__(self, name, "[D*(2010)+ -> D0 pi+]cc", inputs,
dependencies = [TrackGEC('TrackGEC'), PV3D('Hlt2')],
CombinationCut = DstCombinationCut, MotherCut = DstMotherCut,
DaughtersCuts = DaughtersCuts, Preambulo = DstPreambulo())
def __init__(self, tag, n, inputs):
if n == 3:
decays = [
"D*(2010)+ -> K*(892)0 K+", "D*(2010)+ -> K*(892)0 K-",
"D*(2010)+ -> K*(892)0 KS0", "D*(2010)+ -> K*(892)0 KS0",
"D*(2010)+ -> K*(892)0 Lambda0",
"D*(2010)+ -> K*(892)0 Lambda~0"
]
elif n == 4:
decays = [
"B0 -> D*(2010)+ K-", "B0 -> D*(2010)+ K+",
"B0 -> D*(2010)+ KS0", "B0 -> D*(2010)+ Lambda0",
"B0 -> D*(2010)+ Lambda~0"
]
else:
decays = [
"K*(892)0 -> K+ K+", "K*(892)0 -> K+ K-", "K*(892)0 -> K- K-",
"K*(892)0 -> K+ KS0", "K*(892)0 -> K- KS0",
"K*(892)0 -> K+ Lambda0", "K*(892)0 -> K- Lambda0",
"K*(892)0 -> K+ Lambda~0", "K*(892)0 -> K- Lambda~0",
"K*(892)0 -> KS0 KS0"
]
cc = (
"(AM < 7000*MeV) & ((ANUM((ID=='KS0') | (ABSID=='Lambda0')) > 0) "
"| ((AALLSAMEBPV | (AMINCHILD(MIPCHI2DV(PRIMARY)) > 16)) "
"& (AMAXDOCA('LoKi::DistanceCalculator') <"
" %(RUN1_AMAXDOCA_MAX)s)))")
mc = "(BPVDIRA > 0) & (BPVVDCHI2 > %(RUN1_BPVVDCHI2_MIN)s)"
if tag == 'RAD':
decays = ['B+ -> K*(892)0 gamma']
cc = "AM > 0"
from HltTracking.HltPVs import PV3D
dep = [PV3D('Hlt2')]
if tag == 'RAD':
from HltLine.HltDecodeRaw import DecodeL0CALO
dep.append(DecodeL0CALO)
from Hlt2Lines.Utilities.Hlt2MergedStage import Hlt2MergedStage
merged = Hlt2MergedStage('Run1Topo%s%iBody' % (tag, n),
inputs,
shared=True)
Hlt2Combiner.__init__(self,
'Run1Topo%s%iBody' % (tag, n),
decays, [merged],
shared=True,
dependencies=dep,
CombinationCut=cc,
MotherCut=mc)