Source code for skim.WGs.btocharm

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

##########################################################################
# basf2 (Belle II Analysis Software Framework)                           #
# Author: The Belle II Collaboration                                     #
#                                                                        #
# See git log for contributors and copyright holders.                    #
# This file is licensed under LGPL-3.0, see LICENSE.md.                  #
##########################################################################

"""
List of functions to skim events containing :math:`B\\to X_c + h` decays,
where :math:`X_c` stands for :math:`D^0`, :math:`D^{\\pm}`, :math:`D^{*0}` and :math:`D^{*\\pm}`,
and :math:`h` stands for :math:`\\pi^{\\pm}`, :math:`K^{\\pm}`, :math:`\\rho^{\\pm}` and :math:`a_1^{\\pm}`.
"""

import modularAnalysis as ma
from skim.standardlists.charm import (loadD0_hh_loose, loadD0_Kshh_loose,
                                      loadD0_Kspi0_loose, loadD0_Kspipipi0,
                                      loadKForBtoHadrons, loadPiForBtoHadrons,
                                      loadStdD0_Kpi, loadStdD0_Kpipi0,
                                      loadStdD0_Kpipipi, loadStdDplus_Kpipi,
                                      loadStdDplus_Kspi,
                                      loadStdDstar0_D0pi0_Kpi,
                                      loadStdDstar0_D0pi0_Kpipi0,
                                      loadStdDstar0_D0pi0_Kpipipi,
                                      loadStdDstarPlus_D0pi_Kpi,
                                      loadStdDstarPlus_D0pi_Kpipi0,
                                      loadStdDstarPlus_D0pi_Kpipipi,
                                      loadStdDstarPlus_Dpi0_Kpipi,
                                      loadCharmlessD0_Kpipi0,
                                      loadPiSkimHighEff,
                                      loadKSkimHighEff)
from skim.standardlists.lightmesons import (loadStdAllRhoPlus,
                                            loadStdPi0ForBToHadrons,
                                            loadStdSkimHighEffPhi,
                                            loadStdSkimHighEffKstar0,)
from skim.standardlists.charmless import (loadStdPi0ForBToCharmless)
from skim.standardlists.charmless import (loadStdVeryLooseTracks)
from skim import BaseSkim, fancy_skim_header
from stdCharged import stdK, stdPi
from stdPi0s import stdPi0s
from stdV0s import stdKshorts
from stdPhotons import stdPhotons

__liaison__ = "Yi Zhang <yi.zhang2@desy.de>"
_VALIDATION_SAMPLE = "mdst14.root"


[docs]@fancy_skim_header class BtoD0h_Kspi0(BaseSkim): """ Reconstructed decay modes: * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K_{\\rm S}^0 \\pi^0) \\pi^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K_{\\rm S}^0 \\pi^0) K^+`, Cuts applied: * ``1.5 < M_D0 < 2.2`` * ``5.2 < Mbc`` * ``abs(deltaE) < 0.3`` Note: This skim uses `skim.standardlists.charm.loadD0_Kspi0_loose`, where :math:`D^0` channels are defined. """ __authors__ = ["Minakshi Nayak"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True validation_sample = _VALIDATION_SAMPLE
[docs] def load_standard_lists(self, path): stdK("all", path=path) stdPi("all", path=path) stdKshorts(path=path) loadStdPi0ForBToHadrons(path=path) loadD0_Kspi0_loose(path=path)
[docs] def build_lists(self, path): Bcuts = "Mbc > 5.2 and abs(deltaE) < 0.3" BsigChannels = ["anti-D0:Kspi0 pi+:all", "anti-D0:Kspi0 K+:all"] BsigList = [] for chID, channel in enumerate(BsigChannels): ma.reconstructDecay("B+:BtoD0h_Kspi0" + str(chID) + " -> " + channel, Bcuts, chID, path=path) BsigList.append("B+:BtoD0h_Kspi0" + str(chID)) return BsigList
[docs] def validation_histograms(self, path): stdPi0s(listtype='eff50_May2020Fit', path=path) ma.reconstructDecay('D0 -> K_S0:merged pi0:eff50_May2020Fit', '1.84 < M < 1.89', path=path) ma.reconstructDecay('B-:ch3 -> D0 K-:all', '5.24 < Mbc < 5.3 and abs(deltaE) < 0.15', path=path) # the variables that are printed out are: Mbc, deltaE and the daughter particle invariant masses. ma.variablesToHistogram( filename=f'{self}_Validation.root', decayString='B-:ch3', variables=[ ('Mbc', 100, 5.2, 5.3), ('deltaE', 100, -1, 1), ('daughter(0, InvM)', 100, 1.8, 1.9)], # D0 invariant mass variables_2d=[ ('Mbc', 50, 5.23, 5.31, 'deltaE', 50, -0.7, 0.7)], path=path)
[docs]@fancy_skim_header class BtoD0h_Kspipipi0(BaseSkim): """ Reconstructed decay modes: * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K_{\\rm S}^0 \\pi^+ \\pi^- \\pi^0) \\pi^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K_{\\rm S}^0 \\pi^+ \\pi^- \\pi^0) K^+`, Cuts applied: * ``1.8 < M_D0 < 1.9`` * ``5.25 < Mbc`` * ``abs(deltaE) < 0.2`` Note: This skim uses `skim.standardlists.charm.loadD0_Kspipipi0`, where :math:`D^0` channels are defined. """ __authors__ = ["Niharika Rout"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True produce_on_tau_samples = False # retention is very close to zero on taupair validation_sample = _VALIDATION_SAMPLE
[docs] def load_standard_lists(self, path): stdK("all", path=path) stdPi("all", path=path) stdPi0s("eff40_May2020Fit", path=path) stdKshorts(path=path) loadStdPi0ForBToHadrons(path=path) loadPiForBtoHadrons(path=path) loadD0_Kspipipi0(path=path)
[docs] def build_lists(self, path): Bcuts = "Mbc > 5.25 and abs(deltaE) < 0.2" BsigChannels = ["anti-D0:Kspipipi0 pi+:all", "anti-D0:Kspipipi0 K+:all" ] BsigList = [] for chID, channel in enumerate(BsigChannels): ma.reconstructDecay("B+:BtoD0h_Kspipipi0" + str(chID) + " -> " + channel, Bcuts, chID, path=path) BsigList.append("B+:BtoD0h_Kspipipi0" + str(chID)) return BsigList
[docs] def validation_histograms(self, path): ma.reconstructDecay('D0 -> K_S0:merged pi-:all pi+:all pi0:eff40_May2020Fit', '1.84 < M < 1.89', path=path) ma.reconstructDecay('B-:ch3 -> D0 K-:all', '5.24 < Mbc < 5.3 and abs(deltaE) < 0.15', path=path) # the variables that are printed out are: Mbc, deltaE and the daughter particle invariant masses. ma.variablesToHistogram( filename=f'{self}_Validation.root', decayString='B-:ch3', variables=[ ('Mbc', 100, 5.2, 5.3), ('deltaE', 100, -1, 1), ('daughter(0, InvM)', 100, 1.8, 1.9)], # D0 invariant mass variables_2d=[ ('Mbc', 50, 5.23, 5.31, 'deltaE', 50, -0.7, 0.7)], path=path)
[docs]@fancy_skim_header class BtoDstarpipipi0_D0pi_Kpi(BaseSkim): """ Reconstructed decay modes: * :math:`B^{+}\\to D^{*-} (\\to \\overline{D}^{0} (\\to K^+ \\pi^-) \\pi^-) \\pi^+ \\pi^+ \\pi^0` Cuts applied: * ``Mbc > 5.2`` * ``abs(deltaE) < 0.3`` Note: This skim uses `skim.standardlists.charm.loadStdD0_Kpi` and `skim.standardlists.charm.loadStdDstarPlus_D0pi_Kpi`, where :math:`D^{*-}` channel is defined. """ __authors__ = ["Fedja Ceplak Mencin"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True
[docs] def load_standard_lists(self, path): loadStdPi0ForBToHadrons(path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdD0_Kpi(path=path) loadStdDstarPlus_D0pi_Kpi(path=path)
[docs] def build_lists(self, path): Bcuts = "5.2 < Mbc and abs(deltaE) < 0.3" ma.reconstructDecay("B+:Dstarpipipi0_D0pi_Kpi -> D*-:D0_Kpi pi+:GoodTrack pi+:GoodTrack pi0:bth_skim", Bcuts, path=path) return ["B+:Dstarpipipi0_D0pi_Kpi"]
[docs]@fancy_skim_header class B0toDpi_Kpipi(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to D^{-} (D^{0} \\to K^+ \\pi^- \\pi^-) \\pi^+` Cuts applied: * ``Mbc > 5.2`` * ``abs(deltaE) < 0.3`` Note: This skim uses `skim.standardlists.charm.loadStdDplus_Kpipi`, where :math:`D^-` channel is defined. """ __authors__ = ["Chiara La Licata"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True
[docs] def load_standard_lists(self, path): loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdDplus_Kpipi(path=path)
[docs] def build_lists(self, path): Bcuts = "5.2 < Mbc and abs(deltaE) < 0.3" ma.reconstructDecay("B0:Dpi_Kpipi -> D-:Kpipi pi+:GoodTrack", Bcuts, 0, path=path) return ["B0:Dpi_Kpipi"]
[docs]@fancy_skim_header class BptoD0etapi_Kpi(BaseSkim): """ Reconstructed decay modes: * :math:`B^{+}\\to \\bar{D}^{0} (\\to K^+ \\pi^-) \\eta (\\to \\gamma \\gamma) \\pi^+` Cuts applied: * ``Mbc > 5.25`` * ``abs(deltaE) < 0.32`` * ``1.7 < M_D < 2.0`` * ``0.35 < M_eta < 0.7`` * ``E_photons > 0.05`` Note: This skim uses `skim.standardlists.charm.loadStdD0_Kpi`. """ __authors__ = ["Vismaya V S"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True
[docs] def load_standard_lists(self, path): stdPhotons("all", path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdD0_Kpi(path=path)
[docs] def build_lists(self, path): Bcuts = "5.25 < Mbc and abs(deltaE) < 0.32 and 0.35 < daughter(1,M) < 0.7" etacuts = "0.35 < M < 0.7 and daughter(0,E) > 0.05 and daughter(1,E) > 0.05" ma.reconstructDecay("eta:gm -> gamma:all gamma:all", etacuts, path=path) ma.reconstructDecay("B+:BptoD0etapi_Kpi -> anti-D0:Kpi eta:gm pi+:GoodTrack", Bcuts, path=path) return ["B+:BptoD0etapi_Kpi"]
[docs]@fancy_skim_header class BptoD0pipi0_Kpi(BaseSkim): """ Reconstructed decay modes: * :math:`B^{+}\\to \\bar{D}^{0} (\\to K^+ \\pi^-) \\pi^+ \\pi^0` Cuts applied: * ``Mbc > 5.25`` * ``abs(deltaE) < 0.32`` * ``1.7 < M_D < 2.0`` Note: This skim uses `skim.standardlists.charm.loadStdD0_Kpi`. """ __authors__ = ["Vismaya V S"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True
[docs] def load_standard_lists(self, path): loadStdPi0ForBToHadrons(path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdD0_Kpi(path=path)
[docs] def build_lists(self, path): Bcuts = "5.25 < Mbc and abs(deltaE) < 0.32" ma.reconstructDecay("B+:BptoD0pipi0_Kpi -> anti-D0:Kpi pi+:GoodTrack pi0:bth_skim", Bcuts, path=path) return ["B+:BptoD0pipi0_Kpi"]
[docs]@fancy_skim_header class B0toDpi_Kspi(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to D^{-} (\\to K_{\\rm S}^0 \\pi^-) \\pi^+`, Cuts applied: * ``1.8 < M_D < 1.9`` * ``Mbc > 5.2`` * ``abs(deltaE) < 0.3`` Note: This skim uses `stdV0s.stdKshorts` and `skim.standardlists.charm.loadStdDplus_Kpipi`, where :math:`D^0` channels are defined. """ __authors__ = ["Fernando Abudinen", "Chiara La Licata"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True produce_on_tau_samples = False # retention is very close to zero on taupair
[docs] def load_standard_lists(self, path): stdKshorts(path=path) loadStdPi0ForBToHadrons(path=path) loadPiForBtoHadrons(path=path) loadStdDplus_Kspi(path=path)
[docs] def build_lists(self, path): Bcuts = "Mbc > 5.2 and abs(deltaE) < 0.3" ma.reconstructDecay("B0:B0toDpi_Kspi -> D-:Kspi pi+:GoodTrack", Bcuts, 1, path=path) return ["B0:B0toDpi_Kspi"]
[docs]@fancy_skim_header class B0toDstaretapi_D0pi_Kpi(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to \\overline{D}^{*-} (\\to \\bar{D}^{0} (\\to K^+ \\pi^-) \\pi^-) \\eta (\\to \\gamma \\gamma) \\pi^+` Cuts applied: * ``Mbc > 5.25`` * ``abs(deltaE) < 0.32`` * ``1.7 < M_D0 < 2.0`` * ``(M_D* - M_D0) < 0.16`` * ``0.35 < M_eta < 0.7`` * ``Energy_photons > 0.05`` Note: This skim uses `skim.standardlists.charm.loadStdD0_Kpi` and `skim.standardlists.charm.loadStdDstarPlus_D0pi_Kpi`, where the :math:`\\bar{D}^{0}` channel is defined. """ __authors__ = ["Vismaya V S"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True
[docs] def load_standard_lists(self, path): stdPhotons("all", path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdD0_Kpi(path=path) loadStdDstarPlus_D0pi_Kpi(path=path)
[docs] def build_lists(self, path): Bcuts = "5.25 < Mbc and abs(deltaE) < 0.32 and 0.35 < daughter(1,M) < 0.7" etacuts = "0.35 < M < 0.7 and daughter(0,E) > 0.05 and daughter(1,E) > 0.05" ma.reconstructDecay("eta:gm -> gamma:all gamma:all", etacuts, path=path) ma.reconstructDecay("B0:B0toDstaretapi_D0pi_Kpi -> D*-:D0_Kpi eta:gm pi+:GoodTrack", Bcuts, path=path) return ["B0:B0toDstaretapi_D0pi_Kpi"]
[docs]@fancy_skim_header class B0toDstarPi_D0pi_Kpi(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to D^{*-} (D^{0} \\to K^+ \\pi^-) \\pi^+` Cuts applied: * ``Mbc > 5.2`` * ``abs(deltaE) < 0.3`` Note: This skim uses `skim.standardlists.charm.loadStdDstarPlus_D0pi_Kpi`, where the :math:`D^{*-}` channel is defined. """ __authors__ = ["Chiara La Licata"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True produce_on_tau_samples = False # retention is very close to zero on taupair
[docs] def load_standard_lists(self, path): loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdD0_Kpi(path=path) loadStdDstarPlus_D0pi_Kpi(path=path)
[docs] def build_lists(self, path): Bcuts = "5.2 < Mbc and abs(deltaE) < 0.3" ma.reconstructDecay("B0:Dstarpi_Kpi -> D*-:D0_Kpi pi+:GoodTrack", Bcuts, 0, path=path) return ["B0:Dstarpi_Kpi"]
[docs]@fancy_skim_header class B0toDstarPi_D0pi_Kpipipi_Kpipi0(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to \\overline{D}{}^{*-} (\\to \\overline{D}{}^{0} (\\to K^+ \\pi^- \\pi^- \\pi^+, K^+\\pi^-\\pi^0) \\pi^-) \\pi^+` Cuts applied: * ``Mbc > 5.2`` * ``abs(deltaE) < 0.3`` """ __authors__ = ["Chiara La Licata"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True produce_on_tau_samples = False # retention is very close to zero on taupair
[docs] def load_standard_lists(self, path): loadStdPi0ForBToHadrons(path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdD0_Kpipi0(path=path) loadStdD0_Kpipipi(path=path) loadStdDstarPlus_D0pi_Kpipi0(path=path) loadStdDstarPlus_D0pi_Kpipipi(path=path)
[docs] def build_lists(self, path): Bcuts = "5.2 < Mbc and abs(deltaE) < 0.3" BsigChannels = [ "D*-:D0_Kpipipi pi+:GoodTrack", "D*-:D0_Kpipi0 pi+:GoodTrack" ] BsigList = [] for chID, channel in enumerate(BsigChannels): ma.reconstructDecay("B0:Dstarpi_Kpipipi_Kpipi0" + str(chID) + " -> " + channel, Bcuts, chID, path=path) BsigList.append("B0:Dstarpi_Kpipipi_Kpipi0" + str(chID)) return BsigList
[docs]@fancy_skim_header class B0toDrho_Kpipi(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to D^{-} (\\to K^+ \\pi^- \\pi^-) \\rho^+`, Cuts applied: * ``1.8 < M_D < 1.9`` * ``0.47 < M_rho < 1.07`` * ``Mbc > 5.2`` * ``abs(deltaE) < 0.3`` Note: This skim uses `skim.standardlists.charm.loadStdDplus_Kpipi`, where :math:`D^0` channels are defined, and `skim.standardlists.lightmesons.loadStdAllRhoPlus`. """ __authors__ = ["Fernando Abudinen"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True
[docs] def load_standard_lists(self, path): stdPi("all", path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdDplus_Kpipi(path=path) loadStdPi0ForBToHadrons(path=path) loadStdAllRhoPlus(path=path)
[docs] def build_lists(self, path): Bcuts = "Mbc > 5.2 and abs(deltaE) < 0.3" ma.reconstructDecay("B0:B0toDrho_Kpipi -> D-:Kpipi rho+:all", Bcuts, 1, path=path) return ["B0:B0toDrho_Kpipi"]
[docs]@fancy_skim_header class B0toDstarpipi0_D0pi_Kpi(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to \\overline{D}^{*-} (\\to \\bar{D}^{0} (\\to K^+ \\pi^-) \\pi^-) \\pi^+ \\pi^0` Cuts applied: * ``Mbc > 5.25`` * ``abs(deltaE) < 0.32`` * ``1.7 < M_D < 2.0`` * ``(M_D* - M_D0) < 0.16`` Note: This skim uses `skim.standardlists.charm.loadStdD0_Kpi` and `skim.standardlists.charm.loadStdDstarPlus_D0pi_Kpi`, where the :math:`\\bar{D}^{0}` channel is defined. """ __authors__ = ["Vismaya V S"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True
[docs] def load_standard_lists(self, path): loadStdPi0ForBToHadrons(path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdD0_Kpi(path=path) loadStdDstarPlus_D0pi_Kpi(path=path)
[docs] def build_lists(self, path): Bcuts = "5.25 < Mbc and abs(deltaE) < 0.32" ma.reconstructDecay("B0:B0toDstarpipi0_D0pi_Kpi -> D*-:D0_Kpi pi+:GoodTrack pi0:bth_skim", Bcuts, path=path) return ["B0:B0toDstarpipi0_D0pi_Kpi"]
[docs]@fancy_skim_header class B0toDrho_Kspi(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to D^{-} (\\to K_{\\rm S}^0 \\pi^-) \\rho^+`, Cuts applied: * ``1.8 < M_D < 1.9`` * ``0.47 < M_rho < 1.07`` * ``Mbc > 5.2`` * ``abs(deltaE) < 0.3`` Note: This skim uses `stdV0s.stdKshorts` and `skim.standardlists.charm.loadStdDplus_Kspi`, where :math:`D^0` channels are defined, and `skim.standardlists.lightmesons.loadStdAllRhoPlus`. """ __authors__ = ["Fernando Abudinen"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True produce_on_tau_samples = False # retention is very close to zero on taupair
[docs] def load_standard_lists(self, path): stdPi("all", path=path) stdKshorts(path=path) loadPiForBtoHadrons(path=path) loadStdDplus_Kspi(path=path) loadStdPi0ForBToHadrons(path=path) loadStdAllRhoPlus(path=path)
[docs] def build_lists(self, path): Bcuts = "Mbc > 5.2 and abs(deltaE) < 0.3" ma.reconstructDecay("B0:B0toDrho_Kspi -> D-:Kspi rho+:all", Bcuts, 1, path=path) return ["B0:B0toDrho_Kspi"]
[docs]@fancy_skim_header class B0toDstarRho_D0pi_Kpi(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to D^{*-} (\\to \\overline{D}{}^{0} (\\to K^+ \\pi^-) \\pi^-) \\rho^+`, Cuts applied: * ``1.7 < M_D < 2.0`` * ``0.47 < M_rho < 1.07`` * ``DM_Dstar_D < 0.16`` * ``Mbc > 5.2`` * ``abs(deltaE) < 0.3`` Note: This skim uses `skim.standardlists.charm.loadStdD0_Kpi` and `skim.standardlists.charm.loadStdDstarPlus_D0pi_Kpi` where :math:`D^0` channels are defined, and `skim.standardlists.lightmesons.loadStdAllRhoPlus`. """ __authors__ = ["Fernando Abudinen"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True produce_on_tau_samples = False # retention is very close to zero on taupair
[docs] def load_standard_lists(self, path): stdPi("all", path=path) loadStdPi0ForBToHadrons(path=path) loadStdAllRhoPlus(path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdD0_Kpi(path=path) loadStdDstarPlus_D0pi_Kpi(path=path)
[docs] def build_lists(self, path): Bcuts = "Mbc > 5.2 and abs(deltaE) < 0.3" ma.reconstructDecay("B0:BtoDstarRho_D0pi_Kpi -> D*-:D0_Kpi rho+:all", Bcuts, 1, path=path) return ["B0:BtoDstarRho_D0pi_Kpi"]
[docs]@fancy_skim_header class B0toDstarRho_D0pi_Kpipipi_Kpipi0(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to D^{*-} (\\to \\overline{D}{}^{0} (\\to K^+2\\pi^-\\pi^+, K^+\\pi^-\\pi^0)\\pi^-) \\rho^+`, Cuts applied: * ``1.7 < M_D < 2.0`` * ``0.47 < M_rho < 1.07`` * ``DM_Dstar_D < 0.16`` * ``Mbc > 5.2`` * ``abs(deltaE) < 0.3`` Note: This skim uses `skim.standardlists.charm.loadStdD0_Kpipi0`, `skim.standardlists.charm.loadStdD0_Kpipipi`, `skim.standardlists.charm.loadStdDstarPlus_D0pi_Kpipi0` and `skim.standardlists.charm.loadStdDstarPlus_D0pi_Kpipipi` where :math:`D^0` channels are defined, and `skim.standardlists.lightmesons.loadStdAllRhoPlus`. """ __authors__ = ["Fernando Abudinen"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True produce_on_tau_samples = False # retention is very close to zero on taupair
[docs] def load_standard_lists(self, path): stdPi("all", path=path) loadStdPi0ForBToHadrons(path=path) loadStdAllRhoPlus(path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdD0_Kpipi0(path=path) loadStdD0_Kpipipi(path=path) loadStdDstarPlus_D0pi_Kpipi0(path=path) loadStdDstarPlus_D0pi_Kpipipi(path=path)
[docs] def build_lists(self, path): Bcuts = "Mbc > 5.2 and abs(deltaE) < 0.3" BsigChannels = [ "D*-:D0_Kpipipi rho+:all", "D*-:D0_Kpipi0 rho+:all", ] BsigList = [] for chID, channel in enumerate(BsigChannels): ma.reconstructDecay("B+:B0toDstarRho" + str(chID) + " -> " + channel, Bcuts, chID, path=path, allowChargeViolation=True) BsigList.append("B+:B0toDstarRho" + str(chID)) return BsigList
[docs]@fancy_skim_header class BtoD0h_hh(BaseSkim): """ Skim list definitions for all charged B to charm 2 body decays. Reconstructed decay modes: * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K^+ \\pi^-) \\pi^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K^- \\pi^+) \\pi^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to \\pi^+ \\pi^-) \\pi^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K^+ K^-) \\pi^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K^+ \\pi^-) K^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K^- \\pi^+) K^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to \\pi^+ \\pi^-) K^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K^+ K^-) K^+`, Cuts applied: * ``1.5 < M_D0 < 2.2`` * ``5.2 < Mbc`` * ``abs(deltaE) < 0.3`` Note: This skim uses `skim.standardlists.charm.loadD0_hh_loose`, where :math:`D^0` channels are defined. """ __authors__ = ["Hulya Atmacan"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True validation_sample = _VALIDATION_SAMPLE
[docs] def load_standard_lists(self, path): loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadD0_hh_loose(path=path)
[docs] def build_lists(self, path): Bcuts = "Mbc > 5.2 and abs(deltaE) < 0.3" BsigChannels = [ "anti-D0:hh pi+:GoodTrack", "anti-D0:hh K+:GoodTrack" ] BsigList = [] for chID, channel in enumerate(BsigChannels): ma.reconstructDecay("B+:BtoD0h_hh" + str(chID) + " -> " + channel, Bcuts, chID, path=path) BsigList.append("B+:BtoD0h_hh" + str(chID)) return BsigList
[docs] def validation_histograms(self, path): ma.reconstructDecay('D0 -> K-:all pi+:all', '1.84 < M < 1.89', path=path) ma.reconstructDecay('B-:ch3 -> D0 K-:all', '5.24 < Mbc < 5.3 and abs(deltaE) < 0.15', path=path) # the variables that are printed out are: Mbc, deltaE and the daughter particle invariant masses. ma.variablesToHistogram( filename=f'{self}_Validation.root', decayString='B-:ch3', variables=[ ('Mbc', 100, 5.2, 5.3), ('deltaE', 100, -1, 1), ('daughter(0, InvM)', 100, 1.8, 1.9)], # D0 invariant mass variables_2d=[ ('Mbc', 50, 5.23, 5.31, 'deltaE', 50, -0.7, 0.7)], path=path)
[docs]@fancy_skim_header class BtoD0h_Kpi(BaseSkim): """ Skim list definitions for all charged B to charm 3 body decays. Reconstructed decay modes: * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K^+ \\pi^-) \\pi^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K^+ \\pi^-) K^+`, Cuts applied: * ``1.7 < M_D0 < 2.0`` * ``Mbc > 5.2`` * ``abs(deltaE) < 0.5`` Note: This skim uses `skim.standardlists.charm.loadStdD0_Kpi`, where :math:`D^0` channels are defined. """ __authors__ = ["Niharika Rout"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True
[docs] def load_standard_lists(self, path): loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdD0_Kpi(path=path)
[docs] def build_lists(self, path): Bcuts = "Mbc > 5.2 and abs(deltaE) < 0.5" BsigChannels = ["anti-D0:Kpi pi+:GoodTrack", "anti-D0:Kpi K+:GoodTrack" ] BsigList = [] for chID, channel in enumerate(BsigChannels): ma.reconstructDecay("B+:BtoD0h_Kpi" + str(chID) + " -> " + channel, Bcuts, chID, path=path) BsigList.append("B+:BtoD0h_Kpi" + str(chID)) return BsigList
[docs]@fancy_skim_header class BtoD0h_Kpipipi_Kpipi0(BaseSkim): """ Reconstructed decay modes: * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K^+ \\pi^- \\pi^- \\pi^+, \\to K^+ \\pi^- \\pi^0) \\pi^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K^+ \\pi^- \\pi^- \\pi^+, \\to K^+ \\pi^- \\pi^0) K^+`, * :math:`B^{+}\\to \\overline{D}{}^{*0} (\\to \\overline{D}{}^{0} (\\to K^+2\\pi^-\\pi^+, K^+\\pi^-\\pi^0) \\pi^0) \\pi^+` * :math:`B^{+}\\to \\overline{D}{}^{*0} (\\to \\overline{D}{}^{0} (\\to K^+2\\pi^-\\pi^+, K^+\\pi^-\\pi^0) \\pi^0) K^+` Cuts applied: * ``1.7 < M_D0 < 2.0`` * ``Mbc > 5.2`` * ``abs(deltaE) < 0.3`` Note: This skim uses `skim.standardlists.charm.loadStdD0_Kpipipi` and `skim.standardlists.charm.loadStdD0_Kpipi0`, where :math:`D^0` channels are defined. """ __authors__ = ["Chiara La Licata"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True
[docs] def load_standard_lists(self, path): loadStdPi0ForBToHadrons(path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdD0_Kpipi0(path=path) loadStdD0_Kpipipi(path=path) loadStdDstar0_D0pi0_Kpipipi(path=path) loadStdDstar0_D0pi0_Kpipi0(path=path)
[docs] def build_lists(self, path): Bcuts = "Mbc > 5.2 and abs(deltaE) < 0.3" BsigChannels = ["anti-D0:Kpipipi pi+:GoodTrack", "anti-D0:Kpipipi K+:GoodTrack", "anti-D0:Kpipi0 pi+:GoodTrack", "anti-D0:Kpipi0 K+:GoodTrack", "anti-D*0:D0_Kpipipi pi+:GoodTrack", "anti-D*0:D0_Kpipipi K+:GoodTrack", "anti-D*0:D0_Kpipi0 pi+:GoodTrack", "anti-D*0:D0_Kpipi0 K+:GoodTrack" ] BsigList = [] for chID, channel in enumerate(BsigChannels): ma.reconstructDecay("B+:BtoD0h_Khh_Khpi0" + str(chID) + " -> " + channel, Bcuts, chID, path=path) BsigList.append("B+:BtoD0h_Khh_Khpi0" + str(chID)) ma.copyLists(outputListName="B+:BtoD0h_merged", inputListNames=BsigList, path=path) # Select only three random candidates ma.rankByHighest(particleList="B+:BtoD0h_merged", variable="cos(mdstIndex)", numBest=3, outputVariable="cosMdstIndex_rank", path=path) return ["B+:BtoD0h_merged"]
[docs]@fancy_skim_header class BtoD0h_Kshh(BaseSkim): """ Reconstructed decay modes: * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K_{\\rm S}^0 K^+ \\pi^-) \\pi^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K_{\\rm S}^0 K^- \\pi^+) \\pi^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K_{\\rm S}^0 \\pi^+ \\pi^-) \\pi^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K_{\\rm S}^0 K^+ K^-) \\pi^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K_{\\rm S}^0 K^+ \\pi^-) K^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K_{\\rm S}^0 K^- \\pi^+) K^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K_{\\rm S}^0 \\pi^+ \\pi^-) K^+`, * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K_{\\rm S}^0 K^+ K^-) K^+`, Cuts applied: * ``1.5 < M_D0 < 2.2`` * ``5.2 < Mbc`` * ``deltaE < 0.3 and deltaE > -0.45`` Note: This skim uses `skim.standardlists.charm.loadD0_Kshh_loose`, where :math:`D^0` channels are defined. """ __authors__ = ["Minakshi Nayak"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True validation_sample = _VALIDATION_SAMPLE
[docs] def load_standard_lists(self, path): stdKshorts(path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadD0_Kshh_loose(path=path)
[docs] def build_lists(self, path): Bcuts = "Mbc > 5.2 and deltaE < 0.3 and deltaE > -0.45" BsigChannels = ["anti-D0:Kshh pi+:GoodTrack", "anti-D0:Kshh K+:GoodTrack" ] BsigList = [] for chID, channel in enumerate(BsigChannels): ma.reconstructDecay("B+:BtoD0h_Kshh" + str(chID) + " -> " + channel, Bcuts, chID, path=path) BsigList.append("B+:BtoD0h_Kshh" + str(chID)) return BsigList
[docs] def validation_histograms(self, path): ma.reconstructDecay('D0 -> K_S0:merged pi+:all pi-:all', '1.84 < M < 1.89', path=path) ma.reconstructDecay('B-:ch3 ->D0 K-:all', '5.24 < Mbc < 5.3 and abs(deltaE) < 0.15', path=path) # the variables that are printed out are: Mbc, deltaE and the daughter particle invariant masses. ma.variablesToHistogram( filename=f'{self}_Validation.root', decayString='B-:ch3', variables=[ ('Mbc', 100, 5.2, 5.3), ('deltaE', 100, -1, 1), ('daughter(0, InvM)', 100, 1.8, 1.9)], # D0 invariant mass variables_2d=[ ('Mbc', 50, 5.23, 5.31, 'deltaE', 50, -0.7, 0.7)], path=path)
[docs]@fancy_skim_header class BtoD0rho_Kpi(BaseSkim): """ Reconstructed decay modes: * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K^+ \\pi^-) \\rho^+`, * :math:`B^{+}\\to \\overline{D}{}^{*0} (\\to \\overline{D}{}^{0} (\\to K^+ \\pi^-) \\pi^0) \\rho^+`, Cuts applied: * ``1.7 < M_D0 < 2.0`` * ``0.47 < M_rho < 1.07`` * ``DM_Dstar_D < 0.16`` * ``Mbc > 5.2`` * ``abs(deltaE) < 0.3`` Note: This skim uses `skim.standardlists.charm.loadStdD0_Kpi` and `skim.standardlists.charm.loadStdDstar0_D0pi0_Kpi`, where :math:`D^0` channels are defined, and `skim.standardlists.lightmesons.loadStdAllRhoPlus`. """ __authors__ = ["Fernando Abudinen"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True
[docs] def load_standard_lists(self, path): stdPi("all", path=path) loadStdPi0ForBToHadrons(path=path) loadStdAllRhoPlus(path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdD0_Kpi(path=path) loadStdDstar0_D0pi0_Kpi(path=path)
[docs] def build_lists(self, path): Bcuts = "Mbc > 5.2 and abs(deltaE) < 0.3" BsigChannels = ["anti-D0:Kpi rho+:all", "anti-D*0:D0_Kpi rho+:all"] BsigList = [] for chID, channel in enumerate(BsigChannels): ma.reconstructDecay("B+:BtoD0rho_Kpi" + str(chID) + " -> " + channel, Bcuts, chID, path=path) BsigList.append("B+:BtoD0rho_Kpi" + str(chID)) return BsigList
[docs]@fancy_skim_header class BtoD0rho_Kpipipi_Kpipi0(BaseSkim): """ Reconstructed decay modes: * :math:`B^{+}\\to \\overline{D}{}^{0} (\\to K^+2\\pi^-\\pi^+, K^+\\pi^-\\pi^0) \\rho^+` * :math:`B^{+}\\to \\overline{D}{}^{*0} (\\to \\overline{D}{}^{0} (\\to K^+2 \\pi^- \\pi^+, K^+\\pi^-\\pi^0) \\pi^0) \\rho^+` Cuts applied: * ``1.7 < M_D0 < 2.0`` * ``DM_Dstar_D < 0.16`` * ``0.6 < M_rho < 0.9`` * ``cosHel_rho < 0.90`` * ``Mbc > 5.2`` * ``abs(deltaE) < 0.3`` Note: This skim uses `skim.standardlists.charm.loadStdD0_Kpipi0`, `skim.standardlists.charm.loadStdD0_Kpipipi`, `skim.standardlists.charm.loadStdDstar0_D0pi0_Kpipi0`, and `skim.standardlists.charm.loadStdDstar0_D0pi0_Kpipipi`, where :math:`D^0` channels are defined, and `skim.standardlists.lightmesons.loadStdAllRhoPlus`. Warning: This skim saves only three randomly-chosen :math:`B^{+}` candidates in a ``B+:BtoD0rho_merged`` list, since the candidate multiplicity of this skim is very high. """ __authors__ = ["Fernando Abudinen"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True
[docs] def load_standard_lists(self, path): stdPi("all", path=path) loadStdPi0ForBToHadrons(path=path) loadStdAllRhoPlus(path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdD0_Kpipi0(path=path) loadStdD0_Kpipipi(path=path) loadStdDstar0_D0pi0_Kpipi0(path=path) loadStdDstar0_D0pi0_Kpipipi(path=path)
[docs] def build_lists(self, path): Bcuts = "Mbc > 5.2 and abs(deltaE) < 0.3 and cosHelicityAngle(1,0) < 0.9 and 0.6 <= daughter(1,M) <= 0.9" BsigChannels = [ "anti-D0:Kpipipi rho+:all", "anti-D0:Kpipi0 rho+:all", "anti-D*0:D0_Kpipipi rho+:all", "anti-D*0:D0_Kpipi0 rho+:all" ] BsigList = [] for chID, channel in enumerate(BsigChannels): ma.reconstructDecay("B+:BtoD0rho_merged" + str(chID) + " -> " + channel, Bcuts, chID, path=path) BsigList.append("B+:BtoD0rho_merged" + str(chID)) ma.copyLists(outputListName="B+:BtoD0rho_merged", inputListNames=BsigList, path=path) # Select only three random candidates to save them as these channels have high multiplicity. ma.rankByHighest(particleList="B+:BtoD0rho_merged", variable="cos(mdstIndex)", numBest=3, outputVariable="cosMdstIndex_rank", path=path) return ["B+:BtoD0rho_merged"]
[docs]@fancy_skim_header class B0toDD_Kpipi_Kspi(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to D^{+}(\\to K^- \\pi^+ \\pi^+) D^{-}(\\to K^+ \\pi^- \\pi^-)` * :math:`B^{0}\\to D^{+}(\\to K^- \\pi^+ \\pi^+) D^{-}(\\to K_{\\rm S}^0 \\pi^-)` * :math:`B^{0}\\to D^{+}(\\to K_{\\rm S}^0 \\pi^-) D^{-}(\\to K_{\\rm S}^0 \\pi^-)` Cuts applied: * ``Mbc > 5.2`` * ``abs(deltaE) < 0.3`` * ``1.8 < M_D < 1.9`` Note: This skim uses `skim.standardlists.charm.loadStdDplus_Kpipi` and `skim.standardlists.charm.loadStdDplus_Kspi`, where :math:`D^-` channel is defined. """ produce_on_tau_samples = False # retention is very close to zero on taupair __authors__ = ["Chiara La Licata"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True
[docs] def load_standard_lists(self, path): stdKshorts(path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdDplus_Kpipi(path=path) loadStdDplus_Kspi(path=path)
[docs] def build_lists(self, path): Bcuts = "5.2 < Mbc and abs(deltaE) < 0.3" BsigChannels = [ "D+:Kpipi D-:Kpipi", "D+:Kpipi D-:Kspi", "D+:Kspi D-:Kspi" ] BsigList = [] for chID, channel in enumerate(BsigChannels): ma.reconstructDecay("B0:B0toDD" + str(chID) + " -> " + channel, Bcuts, chID, path=path) BsigList.append("B0:B0toDD" + str(chID)) return BsigList
[docs]@fancy_skim_header class B0toDstarD(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to \\overline{D}{}^{*-} (\\to \\overline{D}{}^{0} (\\to K^+ \\pi^-, \\to K^+ \\pi^- \\pi^- \\pi^+, K^+ \\pi^- \\pi^0) \\pi^-) D^+ (\\to K^- \\pi^+ \\pi^+)` * :math:`B^{0}\\to \\overline{D}{}^{*-} (\\to D^{-} \\pi^0) D^+ (\\to K^- \\pi^+ \\pi^+)` Cuts applied: * ``Mbc > 5.2`` * ``abs(deltaE) < 0.3`` * ``DM_Dstar_D < 0.16`` * ``1.8 < M_D < 1.9`` """ __authors__ = ["Chiara La Licata"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True produce_on_tau_samples = False # retention is very close to zero on taupair
[docs] def load_standard_lists(self, path): loadStdPi0ForBToHadrons(path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdD0_Kpi(path=path) loadStdD0_Kpipi0(path=path) loadStdD0_Kpipipi(path=path) loadStdDplus_Kpipi(path=path) loadStdDstarPlus_D0pi_Kpi(path=path) loadStdDstarPlus_D0pi_Kpipipi(path=path) loadStdDstarPlus_D0pi_Kpipi0(path=path) loadStdDstarPlus_Dpi0_Kpipi(path=path)
[docs] def build_lists(self, path): Bcuts = "5.2 < Mbc and abs(deltaE) < 0.3" BsigChannels = [ "D*+:D0_Kpi D-:Kpipi", "D*+:D0_Kpipipi D-:Kpipi", "D*+:D0_Kpipi0 D-:Kpipi", "D*+:Dpi0_Kpipi D-:Kpipi" ] BsigList = [] for chID, channel in enumerate(BsigChannels): ma.reconstructDecay("B0:B0toDstarD" + str(chID) + " -> " + channel, Bcuts, chID, path=path) BsigList.append("B0:B0toDstarD" + str(chID)) return BsigList
[docs]@fancy_skim_header class B0toDDs0star(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to D_{s0}^{*+} (\\to D_{s}^{+} (\\to \\phi (\\to K^+ K^-) \\pi^+ \\pi^0) \\pi^0) D^{-} (\\to K^+ \\pi^- \\pi^-)` * :math:`B^{0}\\to D_{s0}^{*+} (\\to D_{s}^{+} (\\to \\overline{K}{}^{*0} (\\to K^- \\pi^+ ) K^+) \\pi^0) D^{-} (\\to K^+ \\pi^- \\pi^-)` * :math:`B^{0}\\to D_{s0}^{*+} (\\to D_{s}^{+} (\\to \\phi (\\to K^+ K^-) \\pi^+) \\pi^0) D^{-} (\\to K^+ \\pi^- \\pi^-)` Cuts applied: * ``5.2 < Mbc < 5.3`` * ``abs(deltaE) < 0.2`` * ``0.31 < D_s0ST_massDifference_0 < 0.347`` """ __authors__ = ["Kuanying Wu"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True produce_on_tau_samples = False # retention is very close to zero on taupair validation_sample = _VALIDATION_SAMPLE
[docs] def load_standard_lists(self, path): loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path=path) loadStdDplus_Kpipi(path=path) loadStdPi0ForBToHadrons(path=path)
[docs] def build_lists(self, path): ma.reconstructDecay("phi -> K+:GoodTrack K-:GoodTrack", cut="[1.01 < M < 1.03]", path=path) ma.reconstructDecay("anti-K*0 -> K-:GoodTrack pi+:GoodTrack", cut="[0.793 < M < 1.015]", path=path) ma.reconstructDecay("D_s+:phipipi0 -> phi pi+:GoodTrack pi0:bth_skim", cut="[1.942 < M < 1.978]", path=path) ma.reconstructDecay("D_s+:antiKK -> anti-K*0 K+:GoodTrack", cut="[1.944 < M < 1.992]", path=path) ma.reconstructDecay("D_s+:phipi -> phi pi+:GoodTrack", cut="[1.935 < M < 1.999]", path=path) Dslist = ['D_s+:phipipi0', 'D_s+:antiKK', 'D_s+:phipi'] ma.copyLists(outputListName='D_s+:all', inputListNames=Dslist, path=path) ma.reconstructDecay("D_s0*+ -> D_s+:all pi0:bth_skim", cut="[2.249 < M < 2.298] and [0.31 < massDifference(0) < 0.347] and \ [1.017 < p < 2.552]", path=path) ma.reconstructDecay("B0:B0toDDs0star -> D_s0*+ D-:Kpipi", cut="[5.2 < Mbc < 5.3] and \ [-0.2 < deltaE < 0.2]", path=path) return ["B0:B0toDDs0star"]
[docs]@fancy_skim_header class B0toD0Kpipi0_pi0(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to \\overline{D}{}^{0} (\\to K^+ \\pi^- \\pi^0) \\pi^0` Cuts applied: * ``Mbc > 5.2`` * ``abs(deltaE) < 0.5`` Note: This skim uses `skim.standardlists.charm.loadStdD0_Kpipi0`, where the :math:`\\overline{D}{}^{0}` channel is defined. """ __authors__ = ["Francis Pham"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True produce_on_tau_samples = False # retention is very close to zero on taupair
[docs] def load_standard_lists(self, path): loadStdPi0ForBToCharmless(path=path) loadStdVeryLooseTracks('K', path=path) loadStdVeryLooseTracks('pi', path=path) loadCharmlessD0_Kpipi0(path=path)
[docs] def build_lists(self, path): Bcuts = "5.2 < Mbc and abs(deltaE) < 0.5" ma.reconstructDecay("B0:D0Kpipi0_pi0 -> anti-D0:Kpipi0_loose pi0:charmlessFit", Bcuts, path=path) return ["B0:D0Kpipi0_pi0"]
[docs]@fancy_skim_header class B0toDs1D(BaseSkim): """ Reconstructed decay modes: * :math:`B^{0}\\to D_{s1}^{+} (\\to D_s^{*+}(\\to D_s^+(\\to \\phi (\\to K^+ K^-)\\pi^+) \\gamma) \\pi^0) D^- (\\to K^+ \\pi^-\\pi^-)`, * :math:`B^{0}\\to D_{s1}^{+} (\\to D_s^{*+}(\\to D_s^+(\\to \\phi (\\to K^+ K^-) \\pi^+ \\pi^0) \\gamma) \\pi^0) D^- (\\to K^+ \\pi^-\\pi^-)`, * :math:`B^{0}\\to D_{s1}^{+} (\\to D_s^{*+}(\\to D_s^+(\\to \\overline{K}{}^{*0} (\\to K^- \\pi^+)K^+) \\gamma) \\pi^0) D^- (\\to K^+ \\pi^-\\pi^-)`, * :math:`B^{0}\\to D_{s1}^{+} (\\to D_s^{*+}(\\to D_s^+(\\to K_S^0 (\\to \\pi^- \\pi^+)K^+) \\gamma) \\pi^0) D^- (\\to K^+ \\pi^-\\pi^-)`, Cuts applied: * ``5.2 < Mbc < 5.3`` * ``-0.5 < deltaE < 0.5`` * ``0.247 < M(D_s1+) - M(D_s*+) < 0.378`` * ``0.072 < M(D_s*+) - M(D_s+) < 0.179`` * ``2.288 < M(D_s1+) < 2.507`` """ __authors__ = ["Tsai Hua Lee, Chih Han Tseng"] __description__ = "" __contact__ = __liaison__ __category__ = "physics, hadronic B to charm" ApplyHLTHadronCut = True produce_on_tau_samples = False # retention is very close to zero on taupair validation_sample = _VALIDATION_SAMPLE
[docs] def load_standard_lists(self, path): loadPiSkimHighEff(path=path) loadKSkimHighEff(path=path) loadStdPi0ForBToHadrons(path=path) stdPhotons('loose', path=path) stdKshorts(path=path) loadPiForBtoHadrons(path=path) loadKForBtoHadrons(path) loadStdDplus_Kpipi(path=path) loadStdSkimHighEffPhi(path=path) loadStdSkimHighEffKstar0(path=path)
[docs] def build_lists(self, path): ma.reconstructDecay(decayString="D_s+:phipi -> phi:SkimHighEff pi+:SkimHighEff", cut="[1.942 < M < 1.993]", path=path) ma.reconstructDecay(decayString="D_s+:phipipi0 -> phi:SkimHighEff pi+:SkimHighEff pi0:bth_skim", cut="[1.874 < M < 1.997]", path=path) ma.reconstructDecay(decayString="D_s+:Ksk -> K_S0:merged K+:SkimHighEff", cut="[1.914 < M < 2.015]", path=path) ma.reconstructDecay(decayString="D_s+:anti-Kstar0K -> anti-K*0:SkimHighEff K+:SkimHighEff", cut="[1.934 < M < 2.002]", path=path) DsList = ['D_s+:phipi', 'D_s+:phipipi0', 'D_s+:Ksk', 'D_s+:anti-Kstar0K'] ma.copyLists(outputListName="D_s+:all", inputListNames=DsList, path=path) ma.reconstructDecay(decayString="D_s*+ -> D_s+:all gamma:loose", cut="[2.062 < M < 2.131] and [0.072 < massDifference(0) < 0.179]", path=path) ma.reconstructDecay(decayString="D_s1+ -> D_s*+ pi0:bth_skim", cut="[2.288 < M < 2.507] and [0.247 < massDifference(0) < 0.378]", path=path) ma.reconstructDecay(decayString="B0:merged -> D_s1+ D-:Kpipi", cut="[5.2 < Mbc < 5.3] and [-0.5 < deltaE < 0.5]", path=path) return ["B0:merged"]