###############################################################################
# (c) Copyright 2020-2021 CERN for the benefit of the LHCb Collaboration #
# #
# This software is distributed under the terms of the GNU General Public #
# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". #
# #
# In applying this licence, CERN does not waive the privileges and immunities #
# granted to it by virtue of its status as an Intergovernmental Organization #
# or submit itself to any jurisdiction. #
###############################################################################
"""Definition of b -> s tau tau HLT2 lines.
Final states built are (one tau decays to an electron and neutrinos, and one tau decays to a muon and neutrinos):
1. Bs decays to phi
- Bs -> phi(-> K+ K-) tau+ tau-
- Bs -> phi(-> K+ K+) tau+ tau- and its charge conjugate
- Bs -> phi(-> K+ K-) tau+ tau+ and its charge conjugate
- Bs -> phi(-> K+ K-) tau+ tau- with a fake kaon
- Bs -> phi(-> K+ K-) tau+ tau- with a fake muon
2. Lb decays to pK
- Lb -> Lambda(-> p+ K-) tau+ tau- and its charge conjugate
- Lb -> Lambda(-> p+ K+) tau+ tau- and its charge conjugate
- Lb -> Lambda(-> p+ K-) tau+ tau+, Lambda(-> p+ K-) tau- tau- and their charge conjugates
- Lb -> Lambda(-> p+ K-) tau+ tau- with a fake kaon
- Lb -> Lambda(-> p+ K-) tau+ tau- with a fake proton
- Lb -> Lambda(-> K+ K-) tau+ tau- with a fake muon
3. Bd decays to K*
- Bd -> K*(-> K+ pi-) tau+ tau-
- Bd -> K*(-> K+ pi+) tau+ tau- and its charge conjugate
- Bd -> K*(-> K+ pi-) tau+ tau+, K*(-> K+ pi-) tau- tau- and their charge conjugates
- Bd -> K*(-> K+ pi-) tau+ tau- with a fake kaon
- Bd -> K*(-> K+ pi-) tau+ tau- with a fake pion
- Bd -> K*(-> K+ pi-) tau+ tau- with a fake muon
4. Bs decays to K* K*
- Bs -> K*(-> K+ pi-) K~*(-> K- pi+) tau+ tau-
- Bs -> K*(-> K+ pi-) K*(-> K+ pi-) tau+ tau- and its charge conjugate
- Bs -> K*(-> K+ pi-) K~*(-> K- pi+) tau+ tau+ and its charge conjugate
- Bs -> K*(-> K+ pi-) K~*(-> K- pi+) tau+ tau- with a fake muon
5. B+ decays to K+
- B+ -> K+ tau+ tau-
- B+ -> K+ tau- tau- and its charge conjugate
- B+ -> K+ tau+ tau+ and its charge conjugate
- B+ -> K+ tau+ tau- with a fake muon
- B+ -> K+ tau+ tau- with a fake kaon
Note a: fake particles are obtained through reversing the PID requirements
Note b: leptons from the taus are combined with a ParticleCombiner with DecayDescriptor [D0 -> mu+ e-]cc
Note c: in general, the dihadron is mainly used as a way to add more cuts on the particle combination, and is not intended to represent a given particle (hence the loose mass requirements)
"""
from Moore.config import register_line_builder
from Moore.lines import Hlt2Line
from RecoConf.reconstruction_objects import make_pvs
from GaudiKernel.SystemOfUnits import MeV, GeV
import Functors as F
from Hlt2Conf.lines.rd.builders import rdbuilder_thor
from Hlt2Conf.lines.rd.builders import btostautau_exclusive
from Hlt2Conf.lines.rd.builders.rd_isolation import parent_and_children_isolation
from Hlt2Conf.lines.rd.builders.rd_prefilters import rd_prefilter, _RD_MONITORING_VARIABLES
all_lines = {}
kwargs_kst_bs2kstkst = {
"comb_pt_min": 600 * MeV,
"vchi2pdof_max": 6,
"bpvfdchi2_min": 16
}
kwargs_kaons = {
"p_min": 3 * GeV,
"pt_min": 250. * MeV,
"mipchi2dvprimary_min": 25,
"pid": F.require_all(F.PID_K > 4, ~F.ISMUON)
}
kwargs_kaons_reverse_pid = {
"p_min": 3 * GeV,
"pt_min": 250. * MeV,
"mipchi2dvprimary_min": 25,
"pid": (F.PID_K < 4)
}
kwargs_kaons_for_bu = {
"p_min": 5 * GeV,
"pt_min": 750 * MeV,
"mipchi2dvprimary_min": 36,
"pid": F.require_all(F.PID_K > 6, F.PID_K - F.PID_P > 0, ~F.ISMUON)
}
kwargs_kaons_for_bu_reverse_pid = {
"p_min": 5 * GeV,
"pt_min": 750 * MeV,
"mipchi2dvprimary_min": 36,
"pid": (F.PID_K < 6)
}
kwargs_kaons_for_kstar = {
"p_min": 3 * GeV,
"pt_min": 250. * MeV,
"mipchi2dvprimary_min": 25,
"pid": F.require_all(F.PID_K > 4, ~F.ISMUON)
}
kwargs_kaons_for_kstar_reverse_pid = {
"p_min": 3 * GeV,
"pt_min": 250. * MeV,
"mipchi2dvprimary_min": 25,
"pid": (F.PID_K < 4)
}
kwargs_pions = {
"p_min": 0 * GeV,
"pt_min": 250. * MeV,
"mipchi2dvprimary_min": 25,
"pid": F.require_all(F.PID_K < 0, ~F.ISMUON)
}
kwargs_pions_reverse_pid = {
"p_min": 0 * GeV,
"pt_min": 250. * MeV,
"mipchi2dvprimary_min": 25,
"pid": (F.PID_K > 0)
}
kwargs_protons = {
"p_min": 3 * GeV,
"pt_min": 250. * MeV,
"mipchi2dvprimary_min": 25,
"pid": F.require_all(F.PID_P > 4.5, ~F.ISMUON)
}
kwargs_protons_reverse_pid = {
"p_min": 3 * GeV,
"pt_min": 250. * MeV,
"mipchi2dvprimary_min": 25,
"pid": (F.PID_P < 4.5)
}
kwargs_muons = {
"p_min": 3 * GeV,
"pt_min": 250 * MeV,
"mipchi2dvprimary_min": 16,
"pid": F.require_all(F.PID_MU > 1., F.ISMUON)
}
kwargs_muons_reverse_pid = {
"p_min": 3 * GeV,
"pt_min": 250 * MeV,
"mipchi2dvprimary_min": 16,
"pid": (F.PID_MU < 1.)
}
kwargs_electrons = {
"p_min": 3 * GeV,
"pt_min": 250 * MeV,
"mipchi2dvprimary_min": 16,
"pid": F.require_all(F.PID_E > 6., ~F.ISMUON)
}
kwargs_electrons_reverse_pid = {
"p_min": 3 * GeV,
"pt_min": 250 * MeV,
"mipchi2dvprimary_min": 16,
"pid": (F.PID_E < 6.)
}
[docs]@register_line_builder(all_lines)
def bstophitautau_tautomu_tautoe_line(
name='Hlt2RD_BsToPhiTauTau_PhiToKK_TauToMu_TauToE', prescale=0.1):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
phis = btostautau_exclusive.make_phi(kaons, kaons, pvs)
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
bs = btostautau_exclusive.make_bs(phis, mues, pvs)
algs = rd_prefilter() + [mues, bs]
iso_parts = parent_and_children_isolation(
parents={
'Bs': bs,
'phi': phis
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bstophitautau_tautomu_tautoe_same_sign_kaons_sskmu_line(
name='Hlt2RD_BsToPhiTauTau_PhiToKK_TauToMu_TauToE_SSK_SSKmu',
prescale=0.1):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
phis = btostautau_exclusive.make_phi(
kaons,
kaons,
pvs,
decay_descriptor="[phi(1020) -> K+ K+]cc",
name="rd_same_sign_dikaons_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
bs = btostautau_exclusive.make_bs(
phis, mues, pvs, name="rd_make_bs_to_kktautau_same_sign_kaons_{hash}")
algs = rd_prefilter() + [mues, bs]
iso_parts = parent_and_children_isolation(
parents={
'Bs': bs,
'phi': phis
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bstophitautau_tautomu_tautoe_same_sign_kaons_oskmu_line(
name='Hlt2RD_BsToPhiTauTau_PhiToKK_TauToMu_TauToE_SSK_OSKmu',
prescale=0.5):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
phis = btostautau_exclusive.make_phi(
kaons,
kaons,
pvs,
decay_descriptor="[phi(1020) -> K+ K+]cc",
name="rd_same_sign_dikaons_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(
muons, electrons, pvs, decay_descriptor="[D0 -> mu- e+]cc")
bs = btostautau_exclusive.make_bs(
phis, mues, pvs, name="rd_make_bs_to_kktautau_same_sign_kaons_{hash}")
algs = rd_prefilter() + [mues, bs]
iso_parts = parent_and_children_isolation(
parents={
'Bs': bs,
'phi': phis
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bstophitautau_tautomu_tautoe_same_sign_mues_line(
name='Hlt2RD_BsToPhiTauTau_PhiToKK_TauToMu_TauToE_SSemu',
prescale=0.5):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
phis = btostautau_exclusive.make_phi(kaons, kaons, pvs)
mues = btostautau_exclusive.make_mue(
muons,
electrons,
pvs,
decay_descriptor="[D0 -> mu+ e+]cc",
name="rd_same_sign_mues_for_btostautau_{hash}")
bs = btostautau_exclusive.make_bs(
phis, mues, pvs, name="rd_make_bs_to_kktautau_same_sign_mues_{hash}")
algs = rd_prefilter() + [mues, bs]
iso_parts = parent_and_children_isolation(
parents={
'Bs': bs,
'phi': phis
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bstophitautau_tautomu_tautoe_fakemuon_line(
name='Hlt2RD_BsToPhiTauTau_PhiToKK_TauToMu_TauToE_FakeMuon',
prescale=0.004):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
fake_muons = rdbuilder_thor.make_rd_detached_muons(
**kwargs_muons_reverse_pid)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
phis = btostautau_exclusive.make_phi(kaons, kaons, pvs)
mues = btostautau_exclusive.make_mue(
fake_muons,
electrons,
pvs,
name="rd_mues_fake_muons_for_btostautau_{hash}")
bs = btostautau_exclusive.make_bs(
phis, mues, pvs, name="rd_make_bs_to_kktautau_fake_muons_{hash}")
algs = rd_prefilter() + [mues, phis, bs]
iso_parts = parent_and_children_isolation(
parents={
'Bs': bs,
'phi': phis
},
decay_products={
'muon': fake_muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bstophitautau_tautomu_tautoe_fakeelectron_line(
name='Hlt2RD_BsToPhiTauTau_PhiToKK_TauToMu_TauToE_FakeElectron',
prescale=0.04):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
fake_electrons = rdbuilder_thor.make_rd_detached_electrons(
**kwargs_electrons_reverse_pid)
phis = btostautau_exclusive.make_phi(kaons, kaons, pvs)
mues = btostautau_exclusive.make_mue(
muons,
fake_electrons,
pvs,
name="rd_mues_fake_electrons_for_btostautau_{hash}")
bs = btostautau_exclusive.make_bs(
phis, mues, pvs, name="rd_make_bs_to_kktautau_fake_electrons_{hash}")
algs = rd_prefilter() + [mues, phis, bs]
iso_parts = parent_and_children_isolation(
parents={
'Bs': bs,
'phi': phis
},
decay_products={
'muon': muons,
'electron': fake_electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bstophitautau_tautomu_tautoe_fakekaon_line(
name='Hlt2RD_BsToPhiTauTau_PhiToKK_TauToMu_TauToE_FakeKaon',
prescale=0.1):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
fake_kaons = rdbuilder_thor.make_rd_detached_kaons(
**kwargs_kaons_reverse_pid)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
phis = btostautau_exclusive.make_phi(
kaons, fake_kaons, pvs, name="rd_fake_dikaons_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
bs = btostautau_exclusive.make_bs(
phis, mues, pvs, name="rd_make_bs_to_kktautau_fake_kaons_{hash}")
algs = rd_prefilter() + [mues, phis, bs]
iso_parts = parent_and_children_isolation(
parents={
'Bs': bs,
'phi': phis
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def lbtopktautau_tautomu_tautoe_sspmu_line(
name='Hlt2RD_LbToPKTauTau_TauToMu_TauToE_SSpmu', prescale=0.1):
pvs = make_pvs()
protons = rdbuilder_thor.make_rd_detached_protons(**kwargs_protons)
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
pks = btostautau_exclusive.make_lst(protons, kaons, pvs)
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
lb = btostautau_exclusive.make_lb(pks, mues, pvs)
algs = rd_prefilter() + [mues, pks, lb]
iso_parts = parent_and_children_isolation(
parents={
'Lb': lb,
'pk': pks
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def lbtopktautau_tautomu_tautoe_ospmu_line(
name='Hlt2RD_LbToPKTauTau_TauToMu_TauToE_OSpmu', prescale=1):
pvs = make_pvs()
protons = rdbuilder_thor.make_rd_detached_protons(**kwargs_protons)
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
pks = btostautau_exclusive.make_lst(protons, kaons, pvs)
mues = btostautau_exclusive.make_mue(
muons, electrons, pvs, decay_descriptor="[D0 -> mu- e+]cc")
lb = btostautau_exclusive.make_lb(pks, mues, pvs)
algs = rd_prefilter() + [mues, pks, lb]
iso_parts = parent_and_children_isolation(
parents={
'Lb': lb,
'pk': pks
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def lbtopktautau_tautomu_tautoe_same_sign_pK_sspmu_line(
name='Hlt2RD_LbToPKTauTau_TauToMu_TauToE_SSpK_SSpmu', prescale=1):
pvs = make_pvs()
protons = rdbuilder_thor.make_rd_detached_protons(**kwargs_protons)
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
pks = btostautau_exclusive.make_lst(
protons,
kaons,
pvs,
decay_descriptor="[Lambda(1520)0 -> p+ K+]cc",
name="rd_same_sign_pk_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
lb = btostautau_exclusive.make_lb(
pks, mues, pvs, name="rd_make_lb_to_pktautau_same_sign_pk_{hash}")
algs = rd_prefilter() + [mues, pks, lb]
iso_parts = parent_and_children_isolation(
parents={
'Lb': lb,
'pk': pks
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def lbtopktautau_tautomu_tautoe_same_sign_pK_ospmu_line(
name='Hlt2RD_LbToPKTauTau_TauToMu_TauToE_SSpK_OSpmu', prescale=1):
pvs = make_pvs()
protons = rdbuilder_thor.make_rd_detached_protons(**kwargs_protons)
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
pks = btostautau_exclusive.make_lst(
protons,
kaons,
pvs,
decay_descriptor="[Lambda(1520)0 -> p+ K+]cc",
name="rd_same_sign_pk_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(
muons, electrons, pvs, decay_descriptor="[D0 -> mu- e+]cc")
lb = btostautau_exclusive.make_lb(
pks, mues, pvs, name="rd_make_lb_to_pktautau_same_sign_pk_{hash}")
algs = rd_prefilter() + [mues, pks, lb]
iso_parts = parent_and_children_isolation(
parents={
'Lb': lb,
'pk': pks
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def lbtopktautau_tautomu_tautoe_same_sign_emus_sspmu_line(
name='Hlt2RD_LbToPKTauTau_TauToMu_TauToE_SSemu_SSpmu', prescale=1):
pvs = make_pvs()
protons = rdbuilder_thor.make_rd_detached_protons(**kwargs_protons)
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
pks = btostautau_exclusive.make_lst(protons, kaons, pvs)
mues = btostautau_exclusive.make_mue(
muons,
electrons,
pvs,
decay_descriptor="[D0 -> mu+ e+]cc",
name="rd_same_sign_mues_for_btostautau_{hash}")
lb = btostautau_exclusive.make_lb(
pks, mues, pvs, name="rd_make_lb_to_pktautau_same_sign_emus_{hash}")
algs = rd_prefilter() + [mues, pks, lb]
iso_parts = parent_and_children_isolation(
parents={
'Lb': lb,
'pk': pks
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def lbtopktautau_tautomu_tautoe_same_sign_emus_ospmu_line(
name='Hlt2RD_LbToPKTauTau_TauToMu_TauToE_SSemu_OSpmu', prescale=0.1):
pvs = make_pvs()
protons = rdbuilder_thor.make_rd_detached_protons(**kwargs_protons)
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
pks = btostautau_exclusive.make_lst(protons, kaons, pvs)
mues = btostautau_exclusive.make_mue(
muons,
electrons,
pvs,
decay_descriptor="[D0 -> mu- e-]cc",
name="rd_same_sign_mues_for_btostautau_{hash}")
lb = btostautau_exclusive.make_lb(
pks, mues, pvs, name="rd_make_lb_to_pktautau_same_sign_emus_{hash}")
algs = rd_prefilter() + [mues, pks, lb]
iso_parts = parent_and_children_isolation(
parents={
'Lb': lb,
'pk': pks
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def lbtopktautau_tautomu_tautoe_fakemuon_sspmu_line(
name='Hlt2RD_LbToPKTauTau_TauToMu_TauToE_FakeMuon_SSpmu',
prescale=0.01):
pvs = make_pvs()
protons = rdbuilder_thor.make_rd_detached_protons(**kwargs_protons)
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
fake_muons = rdbuilder_thor.make_rd_detached_muons(
**kwargs_muons_reverse_pid)
pks = btostautau_exclusive.make_lst(protons, kaons, pvs)
mues = btostautau_exclusive.make_mue(
fake_muons,
electrons,
pvs,
name="rd_mues_fake_muons_for_btostautau_{hash}")
lb = btostautau_exclusive.make_lb(
pks, mues, pvs, name="rd_make_lb_to_pktautau_fake_muons_{hash}")
algs = rd_prefilter() + [mues, pks, lb]
iso_parts = parent_and_children_isolation(
parents={
'Lb': lb,
'pk': pks
},
decay_products={
'muon': fake_muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def lbtopktautau_tautomu_tautoe_fakemuon_ospmu_line(
name='Hlt2RD_LbToPKTauTau_TauToMu_TauToE_FakeMuon_OSpmu',
prescale=0.04):
pvs = make_pvs()
protons = rdbuilder_thor.make_rd_detached_protons(**kwargs_protons)
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
fake_muons = rdbuilder_thor.make_rd_detached_muons(
**kwargs_muons_reverse_pid)
pks = btostautau_exclusive.make_lst(protons, kaons, pvs)
mues = btostautau_exclusive.make_mue(
fake_muons,
electrons,
pvs,
name="rd_mues_fake_muons_for_btostautau_{hash}",
decay_descriptor="[D0 -> mu- e+]cc")
lb = btostautau_exclusive.make_lb(
pks, mues, pvs, name="rd_make_lb_to_pktautau_fake_muons_{hash}")
algs = rd_prefilter() + [mues, pks, lb]
iso_parts = parent_and_children_isolation(
parents={
'Lb': lb,
'pk': pks
},
decay_products={
'muon': fake_muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def lbtopktautau_tautomu_tautoe_fakeelectron_sspmu_line(
name='Hlt2RD_LbToPKTauTau_TauToMu_TauToE_FakeElectron_SSpmu',
prescale=0.02):
pvs = make_pvs()
protons = rdbuilder_thor.make_rd_detached_protons(**kwargs_protons)
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
fake_electrons = rdbuilder_thor.make_rd_detached_electrons(
**kwargs_electrons_reverse_pid)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
pks = btostautau_exclusive.make_lst(protons, kaons, pvs)
mues = btostautau_exclusive.make_mue(
muons,
fake_electrons,
pvs,
name="rd_mues_fake_electrons_for_btostautau_{hash}")
lb = btostautau_exclusive.make_lb(
pks, mues, pvs, name="rd_make_lb_to_pktautau_fake_muons_{hash}")
algs = rd_prefilter() + [mues, pks, lb]
iso_parts = parent_and_children_isolation(
parents={
'Lb': lb,
'pk': pks
},
decay_products={
'muon': muons,
'electron': fake_electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def lbtopktautau_tautomu_tautoe_fakeelectron_ospmu_line(
name='Hlt2RD_LbToPKTauTau_TauToMu_TauToE_FakeElectron_OSpmu',
prescale=0.02):
pvs = make_pvs()
protons = rdbuilder_thor.make_rd_detached_protons(**kwargs_protons)
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
fake_electrons = rdbuilder_thor.make_rd_detached_electrons(
**kwargs_electrons_reverse_pid)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
pks = btostautau_exclusive.make_lst(protons, kaons, pvs)
mues = btostautau_exclusive.make_mue(
muons,
fake_electrons,
pvs,
name="rd_mues_fake_electrons_for_btostautau_{hash}",
decay_descriptor="[D0 -> mu- e+]cc")
lb = btostautau_exclusive.make_lb(
pks, mues, pvs, name="rd_make_lb_to_pktautau_fake_muons_{hash}")
algs = rd_prefilter() + [mues, pks, lb]
iso_parts = parent_and_children_isolation(
parents={
'Lb': lb,
'pk': pks
},
decay_products={
'muon': muons,
'electron': fake_electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def lbtopktautau_tautomu_tautoe_fakeproton_sspmu_line(
name='Hlt2RD_LbToPKTauTau_TauToMu_TauToE_FakeProton_SSpmu',
prescale=0.1):
pvs = make_pvs()
protons = rdbuilder_thor.make_rd_detached_protons(
**kwargs_protons_reverse_pid)
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
pks = btostautau_exclusive.make_lst(
protons, kaons, pvs, name="rd_pk_fake_proton_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
lb = btostautau_exclusive.make_lb(
pks, mues, pvs, name="rd_make_lb_to_pktautau_fake_protons_{hash}")
algs = rd_prefilter() + [mues, pks, lb]
iso_parts = parent_and_children_isolation(
parents={
'Lb': lb,
'pk': pks
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
def lbtopktautau_tautomu_tautoe_fakeproton_ospmu_line(
name='Hlt2RD_LbToPKTauTau_TauToMu_TauToE_FakeProton_OSpmu',
prescale=0.05):
pvs = make_pvs()
protons = rdbuilder_thor.make_rd_detached_protons(
**kwargs_protons_reverse_pid)
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
pks = btostautau_exclusive.make_lst(
protons, kaons, pvs, name="rd_pk_fake_proton_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(
muons, electrons, pvs, decay_descriptor="[D0 -> mu- e+]cc")
lb = btostautau_exclusive.make_lb(
pks, mues, pvs, name="rd_make_lb_to_pktautau_fake_protons_{hash}")
algs = rd_prefilter() + [mues, pks, lb]
iso_parts = parent_and_children_isolation(
parents={
'Lb': lb,
'pk': pks
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def lbtopktautau_tautomu_tautoe_fakekaon_sspmu_line(
name='Hlt2RD_LbToPKTauTau_TauToMu_TauToE_FakeKaon_SSpmu',
prescale=0.1):
pvs = make_pvs()
protons = rdbuilder_thor.make_rd_detached_protons(**kwargs_protons)
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_reverse_pid)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
pks = btostautau_exclusive.make_lst(
protons, kaons, pvs, name="rd_pk_fake_kaon_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
lb = btostautau_exclusive.make_lb(
pks, mues, pvs, name="rd_make_lb_to_pktautau_fake_kaons_{hash}")
algs = rd_prefilter() + [mues, pks, lb]
iso_parts = parent_and_children_isolation(
parents={
'Lb': lb,
'pk': pks
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def lbtopktautau_tautomu_tautoe_fakekaon_ospmu_line(
name='Hlt2RD_LbToPKTauTau_TauToMu_TauToE_FakeKaon_OSpmu',
prescale=0.4):
pvs = make_pvs()
protons = rdbuilder_thor.make_rd_detached_protons(**kwargs_protons)
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_reverse_pid)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
pks = btostautau_exclusive.make_lst(
protons, kaons, pvs, name="rd_pk_fake_kaon_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(
muons, electrons, pvs, decay_descriptor="[D0 -> mu- e+]cc")
lb = btostautau_exclusive.make_lb(
pks, mues, pvs, name="rd_make_lb_to_pktautau_fake_kaons_{hash}")
algs = rd_prefilter() + [mues, pks, lb]
iso_parts = parent_and_children_isolation(
parents={
'Lb': lb,
'pk': pks
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bdtoksttautau_tautomu_tautoe_sskmu_line(
name='Hlt2RD_BdToKstTauTau_KstToKPi_TauToMu_TauToE_SSKmu',
prescale=0.1):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_kstar)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
ksts = btostautau_exclusive.make_kst(kaons, pions, pvs)
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
bd = btostautau_exclusive.make_bd(ksts, mues, pvs)
algs = rd_prefilter() + [mues, ksts, bd]
iso_parts = parent_and_children_isolation(
parents={
'Bd': bd,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bdtoksttautau_tautomu_tautoe_oskmu_line(
name='Hlt2RD_BdToKstTauTau_KstToKPi_TauToMu_TauToE_OSKmu',
prescale=0.2):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_kstar)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
ksts = btostautau_exclusive.make_kst(kaons, pions, pvs)
mues = btostautau_exclusive.make_mue(
muons, electrons, pvs, decay_descriptor="[D0 -> mu- e+]cc")
bd = btostautau_exclusive.make_bd(ksts, mues, pvs)
algs = rd_prefilter() + [mues, ksts, bd]
iso_parts = parent_and_children_isolation(
parents={
'Bd': bd,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bdtoksttautau_tautomu_tautoe_same_sign_Kpi_sskmu_line(
name='Hlt2RD_BdToKstTauTau_KstToKPi_TauToMu_TauToE_SSKpi_SSKmu',
prescale=0.1):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_kstar)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
ksts = btostautau_exclusive.make_kst(
kaons,
pions,
pvs,
decay_descriptor="[K*(892)0 -> K+ pi+]cc",
name="rd_same_sign_kpi_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
bd = btostautau_exclusive.make_bd(
ksts, mues, pvs, name="rd_make_bd_to_kpitautau_same_sign_kpi_{hash}")
algs = rd_prefilter() + [mues, ksts, bd]
iso_parts = parent_and_children_isolation(
parents={
'Bd': bd,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bdtoksttautau_tautomu_tautoe_same_sign_Kpi_oskmu_line(
name='Hlt2RD_BdToKstTauTau_KstToKPi_TauToMu_TauToE_SSKpi_OSKmu',
prescale=0.5):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_kstar)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
ksts = btostautau_exclusive.make_kst(
kaons,
pions,
pvs,
decay_descriptor="[K*(892)0 -> K+ pi+]cc",
name="rd_same_sign_kpi_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(
muons, electrons, pvs, decay_descriptor="[D0 -> mu- e+]cc")
bd = btostautau_exclusive.make_bd(
ksts, mues, pvs, name="rd_make_bd_to_kpitautau_same_sign_kpi_{hash}")
algs = rd_prefilter() + [mues, ksts, bd]
iso_parts = parent_and_children_isolation(
parents={
'Bd': bd,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bdtoksttautau_tautomu_tautoe_same_sign_mues_sskmu_line(
name='Hlt2RD_BdToKstTauTau_KstToKPi_TauToMu_TauToE_SSmue_SSKmu',
prescale=0.1):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_kstar)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
ksts = btostautau_exclusive.make_kst(kaons, pions, pvs)
mues = btostautau_exclusive.make_mue(
muons,
electrons,
pvs,
decay_descriptor="[D0 -> mu+ e+]cc",
name="rd_same_sign_mues_for_btostautau_{hash}")
bd = btostautau_exclusive.make_bd(
ksts, mues, pvs, name="rd_make_bd_to_kpitautau_same_sign_mues_{hash}")
algs = rd_prefilter() + [mues, ksts, bd]
iso_parts = parent_and_children_isolation(
parents={
'Bd': bd,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bdtoksttautau_tautomu_tautoe_same_sign_mues_oskmu_line(
name='Hlt2RD_BdToKstTauTau_KstToKPi_TauToMu_TauToE_SSmue_OSKmu',
prescale=0.2):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_kstar)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
ksts = btostautau_exclusive.make_kst(kaons, pions, pvs)
mues = btostautau_exclusive.make_mue(
muons,
electrons,
pvs,
decay_descriptor="[D0 -> mu- e-]cc",
name="rd_same_sign_mues_for_btostautau_{hash}")
bd = btostautau_exclusive.make_bd(
ksts, mues, pvs, name="rd_make_bd_to_kpitautau_same_sign_mues_{hash}")
algs = rd_prefilter() + [mues, ksts, bd]
iso_parts = parent_and_children_isolation(
parents={
'Bd': bd,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bdtoksttautau_tautomu_tautoe_fakemuon_sskmu_line(
name='Hlt2RD_BdToKstTauTau_KstToKPi_TauToMu_TauToE_FakeMuon_SSKmu',
prescale=0.02):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_kstar)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
fake_muons = rdbuilder_thor.make_rd_detached_muons(
**kwargs_muons_reverse_pid)
ksts = btostautau_exclusive.make_kst(kaons, pions, pvs)
mues = btostautau_exclusive.make_mue(
fake_muons,
electrons,
pvs,
name="rd_mues_fake_muons_for_btostautau_{hash}")
bd = btostautau_exclusive.make_bd(
ksts, mues, pvs, name="rd_make_bd_to_kpitautau_fake_muons_{hash}")
algs = rd_prefilter() + [mues, ksts, bd]
iso_parts = parent_and_children_isolation(
parents={
'Bd': bd,
'kst': ksts
},
decay_products={
'muon': fake_muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bdtoksttautau_tautomu_tautoe_fakemuon_oskmu_line(
name='Hlt2RD_BdToKstTauTau_KstToKPi_TauToMu_TauToE_FakeMuon_OSKmu',
prescale=0.02):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_kstar)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
fake_muons = rdbuilder_thor.make_rd_detached_muons(
**kwargs_muons_reverse_pid)
ksts = btostautau_exclusive.make_kst(kaons, pions, pvs)
mues = btostautau_exclusive.make_mue(
fake_muons,
electrons,
pvs,
decay_descriptor="[D0 -> mu- e+]cc",
name="rd_mues_fake_muons_for_btostautau_{hash}")
bd = btostautau_exclusive.make_bd(
ksts, mues, pvs, name="rd_make_bd_to_kpitautau_fake_muons_{hash}")
algs = rd_prefilter() + [mues, ksts, bd]
iso_parts = parent_and_children_isolation(
parents={
'Bd': bd,
'kst': ksts
},
decay_products={
'muon': fake_muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bdtoksttautau_tautomu_tautoe_fakeelectron_sskmu_line(
name='Hlt2RD_BdToKstTauTau_KstToKPi_TauToMu_TauToE_FakeElectron_SSKmu',
prescale=0.02):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_kstar)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
fake_electrons = rdbuilder_thor.make_rd_detached_electrons(
**kwargs_electrons_reverse_pid)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
ksts = btostautau_exclusive.make_kst(kaons, pions, pvs)
mues = btostautau_exclusive.make_mue(
muons,
fake_electrons,
pvs,
name="rd_mues_fake_electrons_for_btostautau_{hash}")
bd = btostautau_exclusive.make_bd(
ksts, mues, pvs, name="rd_make_bd_to_kpitautau_fake_electrons_{hash}")
algs = rd_prefilter() + [mues, ksts, bd]
iso_parts = parent_and_children_isolation(
parents={
'Bd': bd,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': fake_electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bdtoksttautau_tautomu_tautoe_fakeelectron_oskmu_line(
name='Hlt2RD_BdToKstTauTau_KstToKPi_TauToMu_TauToE_FakeElectron_OSKmu',
prescale=0.02):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_kstar)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
fake_electrons = rdbuilder_thor.make_rd_detached_electrons(
**kwargs_electrons_reverse_pid)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
ksts = btostautau_exclusive.make_kst(kaons, pions, pvs)
mues = btostautau_exclusive.make_mue(
muons,
fake_electrons,
pvs,
decay_descriptor="[D0 -> mu- e+]cc",
name="rd_mues_fake_electrons_for_btostautau_{hash}")
bd = btostautau_exclusive.make_bd(
ksts, mues, pvs, name="rd_make_bd_to_kpitautau_fake_electrons_{hash}")
algs = rd_prefilter() + [mues, ksts, bd]
iso_parts = parent_and_children_isolation(
parents={
'Bd': bd,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': fake_electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bdtoksttautau_tautomu_tautoe_fakekaon_sskmu_line(
name='Hlt2RD_BdToKstTauTau_KstToKPi_TauToMu_TauToE_FakeKaon_SSKmu',
prescale=0.4):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(
**kwargs_kaons_for_kstar_reverse_pid)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
ksts = btostautau_exclusive.make_kst(
kaons, pions, pvs, name="rd_kpi_fake_kaon_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
bd = btostautau_exclusive.make_bd(
ksts, mues, pvs, name="rd_make_bd_to_kpitautau_fake_kaons_{hash}")
algs = rd_prefilter() + [mues, ksts, bd]
iso_parts = parent_and_children_isolation(
parents={
'Bd': bd,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bdtoksttautau_tautomu_tautoe_fakekaon_oskmu_line(
name='Hlt2RD_BdToKstTauTau_KstToKPi_TauToMu_TauToE_FakeKaon_OSKmu',
prescale=0.05):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(
**kwargs_kaons_for_kstar_reverse_pid)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
ksts = btostautau_exclusive.make_kst(
kaons, pions, pvs, name="rd_kpi_fake_kaon_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(
muons, electrons, pvs, decay_descriptor="[D0 -> mu- e+]cc")
bd = btostautau_exclusive.make_bd(
ksts, mues, pvs, name="rd_make_bd_to_kpitautau_fake_kaons_{hash}")
algs = rd_prefilter() + [mues, ksts, bd]
iso_parts = parent_and_children_isolation(
parents={
'Bd': bd,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bdtoksttautau_tautomu_tautoe_fakepion_sskmu_line(
name='Hlt2RD_BdToKstTauTau_KstToKPi_TauToMu_TauToE_FakePion_SSKmu',
prescale=0.1):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_kstar)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions_reverse_pid)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
ksts = btostautau_exclusive.make_kst(
kaons, pions, pvs, name="rd_kpi_fake_pion_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
bd = btostautau_exclusive.make_bd(
ksts, mues, pvs, name="rd_make_bd_to_kpitautau_fake_pions_{hash}")
algs = rd_prefilter() + [mues, ksts, bd]
iso_parts = parent_and_children_isolation(
parents={
'Bd': bd,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bdtoksttautau_tautomu_tautoe_fakepion_oskmu_line(
name='Hlt2RD_BdToKstTauTau_KstToKPi_TauToMu_TauToE_FakePion_OSKmu',
prescale=0.1):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_kstar)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions_reverse_pid)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
ksts = btostautau_exclusive.make_kst(
kaons, pions, pvs, name="rd_kpi_fake_pion_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(
muons, electrons, pvs, decay_descriptor="[D0 -> mu- e+]cc")
bd = btostautau_exclusive.make_bd(
ksts, mues, pvs, name="rd_make_bd_to_kpitautau_fake_pions_{hash}")
algs = rd_prefilter() + [mues, ksts, bd]
iso_parts = parent_and_children_isolation(
parents={
'Bd': bd,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bstokstksttautau_tautomu_tautoe_line(
name='Hlt2RD_BsToKstKstTauTau_KstToKPi_TauToMu_TauToE', prescale=1):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
ksts = btostautau_exclusive.make_kst(
kaons,
pions,
pvs,
**kwargs_kst_bs2kstkst,
name="rd_kpi_kstkst_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
bs = btostautau_exclusive.make_bs_to_kstkst(ksts, mues, pvs)
algs = rd_prefilter() + [mues, ksts, bs]
iso_parts = parent_and_children_isolation(
parents={
'Bs': bs,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bstokstksttautau_tautomu_tautoe_same_sign_kstar_sskstmu_line(
name='Hlt2RD_BsToKstKstTauTau_KstToKPi_TauToMu_TauToE_SSKst_SSKstmu',
prescale=1):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
ksts = btostautau_exclusive.make_kst(
kaons,
pions,
pvs,
**kwargs_kst_bs2kstkst,
name="rd_kpi_kstkst_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
bs = btostautau_exclusive.make_bs_to_kstkst(
ksts,
mues,
pvs,
decay_descriptor="[B_s0 -> K*(892)0 K*(892)0 D0]cc",
name="rd_make_bs_to_kstksttautau_same_sign_kst_{hash}")
algs = rd_prefilter() + [mues, ksts, bs]
iso_parts = parent_and_children_isolation(
parents={
'Bs': bs,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bstokstksttautau_tautomu_tautoe_same_sign_kstar_oskstmu_line(
name='Hlt2RD_BsToKstKstTauTau_KstToKPi_TauToMu_TauToE_SSKst_OSKstmu',
prescale=1):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
ksts = btostautau_exclusive.make_kst(
kaons,
pions,
pvs,
**kwargs_kst_bs2kstkst,
name="rd_kpi_kstkst_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(
muons, electrons, pvs, decay_descriptor="[D0 -> mu- e+]cc")
bs = btostautau_exclusive.make_bs_to_kstkst(
ksts,
mues,
pvs,
decay_descriptor="[B_s0 -> K*(892)0 K*(892)0 D0]cc",
name="rd_make_bs_to_kstksttautau_same_sign_kst_{hash}")
algs = rd_prefilter() + [mues, ksts, bs]
iso_parts = parent_and_children_isolation(
parents={
'Bs': bs,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bstokstksttautau_tautomu_tautoe_same_sign_mues_line(
name='Hlt2RD_BsToKstKstTauTau_KstToKPi_TauToMu_TauToE_SSmue',
prescale=1):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
ksts = btostautau_exclusive.make_kst(
kaons,
pions,
pvs,
**kwargs_kst_bs2kstkst,
name="rd_kpi_kstkst_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(
muons,
electrons,
pvs,
decay_descriptor="[D0 -> mu+ e+]cc",
name="rd_same_sign_mues_for_btostautau_{hash}")
bs = btostautau_exclusive.make_bs_to_kstkst(
ksts,
mues,
pvs,
decay_descriptor="[B_s0 -> K*(892)0 K*(892)~0 D0]cc",
name="rd_make_bs_to_kstksttautau_same_sign_mues_{hash}")
algs = rd_prefilter() + [mues, ksts, bs]
iso_parts = parent_and_children_isolation(
parents={
'Bs': bs,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bstokstksttautau_tautomu_tautoe_fakemuon_line(
name='Hlt2RD_BsToKstKstTauTau_KstToKPi_TauToMu_TauToE_FakeMuon',
prescale=0.01):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
fake_muons = rdbuilder_thor.make_rd_detached_muons(
**kwargs_muons_reverse_pid)
ksts = btostautau_exclusive.make_kst(
kaons,
pions,
pvs,
**kwargs_kst_bs2kstkst,
name="rd_kpi_kstkst_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(
fake_muons,
electrons,
pvs,
name="rd_mues_fake_muons_for_btostautau_{hash}")
bs = btostautau_exclusive.make_bs_to_kstkst(
ksts, mues, pvs, name="rd_make_bs_to_kstksttautau_fake_muons_{hash}")
algs = rd_prefilter() + [mues, ksts, bs]
iso_parts = parent_and_children_isolation(
parents={
'Bs': bs,
'kst': ksts
},
decay_products={
'muon': fake_muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def bstokstksttautau_tautomu_tautoe_fakeelectron_line(
name='Hlt2RD_BsToKstKstTauTau_KstToKPi_TauToMu_TauToE_FakeElectron',
prescale=0.01):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons)
pions = rdbuilder_thor.make_rd_detached_pions(**kwargs_pions)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
fake_electrons = rdbuilder_thor.make_rd_detached_electrons(
**kwargs_electrons_reverse_pid)
ksts = btostautau_exclusive.make_kst(
kaons,
pions,
pvs,
**kwargs_kst_bs2kstkst,
name="rd_kpi_kstkst_for_btostautau_{hash}")
mues = btostautau_exclusive.make_mue(
muons,
fake_electrons,
pvs,
name="rd_mues_fake_electrons_for_btostautau_{hash}")
bs = btostautau_exclusive.make_bs_to_kstkst(
ksts,
mues,
pvs,
name="rd_make_bs_to_kstksttautau_fake_electrons_{hash}")
algs = rd_prefilter() + [mues, ksts, bs]
iso_parts = parent_and_children_isolation(
parents={
'Bs': bs,
'kst': ksts
},
decay_products={
'muon': muons,
'electron': fake_electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def butoktautau_tautomu_tautoe_sskmu_line(
name='Hlt2RD_BuToKTauTau_TauToMu_TauToE_SSKmu', prescale=0.1):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_bu)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
bu = btostautau_exclusive.make_bu(kaons, mues, pvs)
algs = rd_prefilter() + [mues, bu]
iso_parts = parent_and_children_isolation(
parents={'Bu': bu},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def butoktautau_tautomu_tautoe_oskmu_line(
name='Hlt2RD_BuToKTauTau_TauToMu_TauToE_OSKmu', prescale=0.1):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_bu)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
mues = btostautau_exclusive.make_mue(
muons, electrons, pvs, decay_descriptor="[D0 -> mu- e+]cc")
bu = btostautau_exclusive.make_bu(kaons, mues, pvs)
algs = rd_prefilter() + [mues, bu]
iso_parts = parent_and_children_isolation(
parents={'Bu': bu},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def butoktautau_tautomu_tautoe_same_sign_mues_oskmu_line(
name='Hlt2RD_BuToKTauTau_TauToMu_TauToE_SSmue_OSKmu', prescale=0.05):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_bu)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
mues = btostautau_exclusive.make_mue(
muons,
electrons,
pvs,
decay_descriptor="[D0 -> mu- e-]cc",
name="rd_same_sign_mues_for_btostautau_{hash}")
bu = btostautau_exclusive.make_bu(
kaons, mues, pvs, name="rd_make_bu_to_ktautau_same_sign_mues_{hash}")
algs = rd_prefilter() + [mues, bu]
iso_parts = parent_and_children_isolation(
parents={'Bu': bu},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def butoktautau_tautomu_tautoe_same_sign_mues_sskmu_line(
name='Hlt2RD_BuToKTauTau_TauToMu_TauToE_SSmue_SSKmu', prescale=0.5):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_bu)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
mues = btostautau_exclusive.make_mue(
muons,
electrons,
pvs,
decay_descriptor="[D0 -> mu+ e+]cc",
name="rd_same_sign_mues_for_btostautau_{hash}")
bu = btostautau_exclusive.make_bu(
kaons, mues, pvs, name="rd_make_bu_to_ktautau_same_sign_mues_{hash}")
algs = rd_prefilter() + [mues, bu]
iso_parts = parent_and_children_isolation(
parents={'Bu': bu},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def butoktautau_tautomu_tautoe_fakemuon_sskmu_line(
name='Hlt2RD_BuToKTauTau_TauToMu_TauToE_FakeMuon_SSKmu',
prescale=0.01):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_bu)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
fake_muons = rdbuilder_thor.make_rd_detached_muons(
**kwargs_muons_reverse_pid)
mues = btostautau_exclusive.make_mue(
fake_muons,
electrons,
pvs,
name="rd_mues_fake_muons_for_btostautau_{hash}")
bu = btostautau_exclusive.make_bu(
kaons, mues, pvs, name="rd_make_bu_to_ktautau_fake_muon_{hash}")
algs = rd_prefilter() + [mues, bu]
iso_parts = parent_and_children_isolation(
parents={'Bu': bu},
decay_products={
'muon': fake_muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def butoktautau_tautomu_tautoe_fakemuon_oskmu_line(
name='Hlt2RD_BuToKTauTau_TauToMu_TauToE_FakeMuon_OSKmu',
prescale=0.01):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_bu)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
fake_muons = rdbuilder_thor.make_rd_detached_muons(
**kwargs_muons_reverse_pid)
mues = btostautau_exclusive.make_mue(
fake_muons,
electrons,
pvs,
name="rd_mues_fake_muons_for_btostautau_{hash}",
decay_descriptor="[D0 -> mu- e+]cc")
bu = btostautau_exclusive.make_bu(
kaons, mues, pvs, name="rd_make_bu_to_ktautau_fake_muon_{hash}")
algs = rd_prefilter() + [mues, bu]
iso_parts = parent_and_children_isolation(
parents={'Bu': bu},
decay_products={
'muon': fake_muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def butoktautau_tautomu_tautoe_fakeelectron_sskmu_line(
name='Hlt2RD_BuToKTauTau_TauToMu_TauToE_FakeElectron_SSKmu',
prescale=0.005):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_bu)
fake_electrons = rdbuilder_thor.make_rd_detached_electrons(
**kwargs_electrons_reverse_pid)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
mues = btostautau_exclusive.make_mue(
muons,
fake_electrons,
pvs,
name="rd_mues_fake_electrons_for_btostautau_{hash}")
bu = btostautau_exclusive.make_bu(
kaons, mues, pvs, name="rd_make_bu_to_ktautau_fake_electron_{hash}")
algs = rd_prefilter() + [mues, bu]
iso_parts = parent_and_children_isolation(
parents={'Bu': bu},
decay_products={
'muon': muons,
'electron': fake_electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def butoktautau_tautomu_tautoe_fakeelectron_oskmu_line(
name='Hlt2RD_BuToKTauTau_TauToMu_TauToE_FakeElectron_OSKmu',
prescale=0.01):
pvs = make_pvs()
kaons = rdbuilder_thor.make_rd_detached_kaons(**kwargs_kaons_for_bu)
fake_electrons = rdbuilder_thor.make_rd_detached_electrons(
**kwargs_electrons_reverse_pid)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
mues = btostautau_exclusive.make_mue(
muons,
fake_electrons,
pvs,
name="rd_mues_fake_electrons_for_btostautau_{hash}",
decay_descriptor="[D0 -> mu- e+]cc")
bu = btostautau_exclusive.make_bu(
kaons, mues, pvs, name="rd_make_bu_to_ktautau_fake_electron_{hash}")
algs = rd_prefilter() + [mues, bu]
iso_parts = parent_and_children_isolation(
parents={'Bu': bu},
decay_products={
'muon': muons,
'electron': fake_electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def butoktautau_tautomu_tautoe_fakekaon_sskmu_line(
name='Hlt2RD_BuToKTauTau_TauToMu_TauToE_FakeKaon_SSKmu', prescale=0.1):
pvs = make_pvs()
fake_kaons = rdbuilder_thor.make_rd_detached_kaons(
**kwargs_kaons_for_bu_reverse_pid)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
mues = btostautau_exclusive.make_mue(muons, electrons, pvs)
bu = btostautau_exclusive.make_bu(
fake_kaons,
mues,
pvs,
name="rd_make_bu_to_ktautau_mue_fake_kaon_{hash}")
algs = rd_prefilter() + [mues, bu]
iso_parts = parent_and_children_isolation(
parents={'Bu': bu},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)
[docs]@register_line_builder(all_lines)
def butoktautau_tautomu_tautoe_fakekaon_oskmu_line(
name='Hlt2RD_BuToKTauTau_TauToMu_TauToE_FakeKaon_OSKmu', prescale=0.1):
pvs = make_pvs()
fake_kaons = rdbuilder_thor.make_rd_detached_kaons(
**kwargs_kaons_for_bu_reverse_pid)
muons = rdbuilder_thor.make_rd_detached_muons(**kwargs_muons)
electrons = rdbuilder_thor.make_rd_detached_electrons(**kwargs_electrons)
mues = btostautau_exclusive.make_mue(
muons, electrons, pvs, decay_descriptor="[D0 -> mu- e+]cc")
bu = btostautau_exclusive.make_bu(
fake_kaons,
mues,
pvs,
name="rd_make_bu_to_ktautau_mue_fake_kaon_{hash}")
algs = rd_prefilter() + [mues, bu]
iso_parts = parent_and_children_isolation(
parents={'Bu': bu},
decay_products={
'muon': muons,
'electron': electrons
})
return Hlt2Line(
name=name,
algs=algs,
prescale=prescale,
extra_outputs=iso_parts,
monitoring_variables=_RD_MONITORING_VARIABLES)