diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/Lb2LcDLc2pKPiD2HHH.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/Lb2LcDLc2pKPiD2HHH.py new file mode 100644 index 0000000000000000000000000000000000000000..89bb26ac590ab06816d59b8da6c792b6f1e33c11 --- /dev/null +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/Lb2LcDLc2pKPiD2HHH.py @@ -0,0 +1,305 @@ +############################################################################### +# (c) Copyright 2019 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 the Lb2LcDLc2pKPiD2HHH line, with Lc --> p K- p+ and D --> HHHH. +Translation of the Lb2LcDD2HHHPIDBeauty2CharmLine stripping line from Stripping 34. +""" + +from __future__ import absolute_import, division, print_function +import math + +from GaudiKernel.SystemOfUnits import GeV, MeV, mm, mrad, picosecond + +from RecoConf.hlt1_tracking import require_pvs, require_gec +from RecoConf.reco_objects_from_file import (make_pvs, upfront_reconstruction) + +from ..algorithms import require_all, ParticleFilterWithPVs, ParticleCombinerWithPVs, N3BodyCombinerWithPVs +from ..framework import configurable +from Moore.config import HltLine, register_line_builder + +# get the basic particles +from ..standard_particles import make_has_rich_long_kaons, make_has_rich_long_pions, make_has_rich_long_protons + +# get the filtered pions, kaons and Lc from the X2LcD0KLc2pKPiD02KPi module +from X2LcD0KLc2pKPiD02KPi import filter_d0_daughters, filter_lc_daughters, make_lc2pkpi + +all_lines = {} + + +def prefilters(): + """Basic prefilters: GEC and PV requirements""" + return [require_gec(), require_pvs(make_pvs())] + + +"""Start making the D""" + + +@configurable +def filter_D_daughters(particles, + pvs, + maxTrackChi2=4.0, + minPt=100 * MeV, + minP=1000 * MeV, + minIPChi2=4.0, + maxTrackGhostProb=0.4): + """Filter the kaons/pions used to build the D. + Translation of the KInputsBeauty2CharmFilter/PiInputsBeauty2CharmFilter from the stripping. + It is the same as used in the X2LcD0KLc2pKPiD02KPi module.""" + + return filter_d0_daughters( + particles=particles, + pvs=pvs, + maxTrackChi2=maxTrackChi2, + minPt=minPt, + minP=minP, + minIPChi2=minIPChi2, + maxTrackGhostProb=maxTrackGhostProb) + + +@configurable +def make_d2hhh(name="D2HHHMaker", + kaons, + pions, + pvs, + D_daughters, + decay_descriptors, + maxADOCA_comb12=0.5 * mm, + maxADOCA_comb13=0.5 * mm, + maxADOCA_comb23=0.5 * mm, + minSumPt=1800 * MeV, + minMass=1769.62 * MeV, + maxMass=2068.49 * MeV, + maxTrackChi2_daughter=4.0, + minPt_daughter=500 * MeV, + minP_daughter=5000 * MeV, + minDistChi2PV=1000, + maxVertexChi2_D0=10, + minDistChi2PV_D0=36, + minBPVDIRA_D0=0): + """Make the D --> H H H. + Translation of the ProtoD-2K-K-pi+Beauty2Charm combiner (and brothers) from the stripping. + The D_daughters argument must be a string of the form: "'K-','K-','pi+'" and similar.""" + + combination12_cut = require_all("ADOCA(1,2) < {maxADOCA_comb12}", ).format( + maxADOCA_comb12=maxADOCA_comb12, ) + + combination_cut = require_all( + "ASUM(PT) > {minSumPt}", + "in_range({minMass}, AWM({D_daughters}), {maxMass})", + "AHASCHILD((ISBASIC & HASTRACK & (TRCHI2DOF < {maxTrackChi2_daughter}) & (PT > {minPt_daughter}) & (P > {minP_daughter}))|((ABSID=='KS0') & (PT > {minPt_daughter}) & (P > {minP_daughter}) & (BPVVDCHI2 > {minDistChi2PV})))", + "ADOCA(1,3) < {maxADOCA_comb13}", + "ADOCA(2,3) < {maxADOCA_comb23}", + ).format( + minSumPt=minSumPt, + minMass=minMass, + D_daughters=D_daughters, + maxMass=maxMass, + maxTrackChi2_daughter=maxTrackChi2_daughter, + minPt_daughter=minPt_daughter, + minP_daughter=minP_daughter, + minDistChi2PV=minDistChi2PV, + maxADOCA_comb13=maxADOCA_comb13, + maxADOCA_comb23=maxADOCA_comb23, + ) + + mother_cut = require_all( + "VFASPF(VCHI2/VDOF) < {maxVertexChi2_D0}", + "BPVVDCHI2 > {minDistChi2PV_D0}", + "BPVDIRA > {minBPVDIRA_D0}", + ).format( + maxVertexChi2_D0=maxVertexChi2_D0, + minDistChi2PV_D0=minDistChi2PV_D0, + minBPVDIRA_D0=minBPVDIRA_D0, + ) + + return N3BodyCombinerWithPVs( + name=name, + particles=[kaons, pions], + pvs=pvs, + DecayDescriptors=["[D- -> K- K- pi+]cc"], + Combination12Cut=combination12_cut, + CombinationCut=combination_cut, + MotherCut=mother_cut) + + +@configurable +def filter_d(name="DFilter", D, pvs): + """Filter the D. + Translation of the D2HHHPIDBeauty2CharmFilter from the stripping.""" + + code = require_all( + "NINGENERATION(('p+'==ABSID) & (PIDp < -10),1) == 0", + "NINGENERATION(('K+'==ABSID) & (PIDK < -10), 1) == 0", + "NINGENERATION(('pi+'==ABSID) & (PIDK > 20), 1) == 0", + ) + + return ParticleFilterWithPVs(pions, pvs, Code=code) + + +"""It is to build the Lb --> Lc D candidate""" + + +@configurable +def make_lb2lcd(name="Lb2LcDMaker", + particles, + pvs, + minSumPt=5000 * MeV, + minMass=5200 * MeV, + maxMass=7000 * MeV, + maxVertexChi2_Lb=10, + minP=10000 * MeV, + minPt=1700 * MeV, + maxTrackChi2=4., + minDistChi2=16, + minDistPV=0.1 * mm, + minP_2=5000 * MeV, + minPt_2=500 * MeV, + minDistChi2PV=1000, + min_lifetime=0.2 * ps, + maxIPChi2=25, + minBPVDira=0.999): + """Build the Lb candidate. + Translation of the Lb2LcDD2HHHPIDBeauty2Charm combiner from the stripping.""" + + combination_cut = require_all( + "ASUM(SUMTREE(PT,(ISBASIC | (ID=='gamma')),0.0)) > {minSumPt}", + "AM > {minMass}", + "AM < {maxMass}", + ).format( + minSumPt=minSumPt, + minMass=minMass, + maxMass=maxMass, + ) + + mother_cut = require_all( + "VFASPF(VCHI2/VDOF) < {maxVertexChi2_Lb}", + "INTREE(HASTRACK & (P > {minP}) & (PT> {minPt}) & (TRCHI2DOF < {maxTrackChi2}) & (MIPCHI2DV(PRIMARY) > {minDistChi2}) & (MIPDV(PRIMARY) > {minDistPV}))", + "NINTREE((ISBASIC & HASTRACK & (TRCHI2DOF < {maxTrackChi2}) & (PT > {minPt_2}) & (P > {minP_2}))|((ABSID=='KS0') & (PT > {minPt_2}) & (P > {minP_2}) & (BPVVDCHI2 > {minDistChi2PV}))) > 1", + "BPVLTIME() > {min_lifetime}", "BPVIPCHI2() < {maxIPChi2}", + "BPVDIRA > {minBPVDira}").format( + maxVertexChi2_Lb=maxVertexChi2, + minP_Lb=minP, + minPt_Lb=minPt, + maxTrackChi2_Lb=maxTrackChi2, + minDistChi2_Lb=minDistChi2, + minDistPV=minDistPV, + minPt_2=minPt_2, + minP_2=minP_2, + minDistChi2PV=minDistChi2PV, + min_lifetime=min_lifetime, + maxIPChi2=maxIPChi2, + minBPVDira=minBPVDira, + ) + + return ParticleCombinerWithPVs( + name=name, + particles=particles, + pvs=pvs, + DecayDescriptors=['[Lambda_b0 -> Lambda_c+ D-]cc'], + CombinationCut=combination_cut, + MotherCut=mother_cut) + + +@register_line_builder(all_lines) +@configurable +def lb2lcd_lc2pkpi_d2hhh(name="HLT2Lb2LcDLc2pKPiD2HHHLine", prescale=1): + "Lb2LcDLc2pKPiD2HHH line" + + # get the PVs + pvs = make_pvs() + + # get the basic protons, kaons and pions + protons = make_has_rich_long_protons() + kaons = make_has_rich_long_kaons() + pions = make_has_rich_long_pions() + + # filter the D daughters + kaons_D = filter_d_daughters( + name="DDaughtersFilter_K_Lb2LcDLc2pKPiD2HHHLine", + particles=kaons, + pvs=pvs) + pions_D = filter_d_daughters( + name="DDaughtersFilter_Pi_Lb2LcDLc2pKPiD2HHHLine", + particles=pions, + pvs=pvs) + + # make the D --> K K K + D2KKK = make_d2hhh( + name="D2HHHMaker_KKK_Lb2LcDLc2pKPiD2HHHLine", + kaons=kaons_D, + pions=pions_D, + D_daughters="'K-','K-','K+'", + decay_descriptors=['[D- -> K- K- K+]cc'], + pvs=pvs) + + # make the D --> K K pi + D2KKPi = make_d2hhh( + name="D2HHHMaker_KKPi_Lb2LcDLc2pKPiD2HHHLine", + kaons=kaons_D, + pions=pions_D, + D_daughters="'K-','K-','pi+'", + decay_descriptors=['[D- -> K- K- pi+]cc'], + pvs=pvs) + + # make the D --> K pi pi + D2KPiPi = make_d2hhh( + name="D2HHHMaker_KPiPi_Lb2LcDLc2pKPiD2HHHLine", + kaons=kaons_D, + pions=pions_D, + D_daughters="'K-','pi-','pi+'", + decay_descriptors=['[D- -> K- pi- pi+]cc'], + pvs=pvs) + + # make the D --> pi pi pi + D2PiPiPi = make_d2hhh( + name="D2HHHMaker_PiPiPi_Lb2LcDLc2pKPiD2HHHLine", + kaons=kaons_D, + pions=pions_D, + D_daughters="'pi-','pi-','pi+'", + decay_descriptors=['[D- -> pi- pi- pi+]cc'], + pvs=pvs) + + # filter the Lc daughters + protons_Lc = filter_lc_daughters( + name="LcDaughtersFilter_p_Lb2LcDLc2pKPiD2HHHLine", + particles=protons, + pvs=pvs, + PID_code="PIDp>-10.0") + kaons_Lc = filter_lc_daughters( + name="LcDaughtersFilter_K_Lb2LcDLc2pKPiD2HHHLine", + particles=kaons, + pvs=pvs, + PID_code="PIDK>-10.0") + pions_Lc = filter_lc_daughters( + name="LcDaughtersFilter_Pi_Lb2LcDLc2pKPiD2HHHLine", + particles=kaons, + pvs=pvs, + PID_code="PIDK<20.0") + + # make the Lc + Lc = make_Lc2pKPi( + name="Lc2pKPiMaker_Lb2LcDLc2pKPiD2HHHLine", + protons=protons_Lc, + kaons=kaons_Lc, + pions=pions_Lc, + pvs=pvs) + + # make the X2LcD0K candidates + Lb2LcD = make_Lb2LcD( + name="Lb2LcDMaker_Lb2LcDLc2pKPiD2HHHLine", + particles=[D2KKK, D2KKPi, D2KPiPi, D2PiPiPi, Lc], + pvs=pvs) + + return HltLine( + name=name, + algs=upfront_reconstruction() + prefilters() + [Lb2LcD], + prescale=prescale, + ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/X2LcD0KLc2pKPiD02KPi.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/X2LcD0KLc2pKPiD02KPi.py new file mode 100644 index 0000000000000000000000000000000000000000..da64fdb168c1aa1b74678df8c59c6188f1ce4d87 --- /dev/null +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/X2LcD0KLc2pKPiD02KPi.py @@ -0,0 +1,406 @@ +############################################################################### +# (c) Copyright 2019 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 the X2LcD0K line, with Lc --> p K- pi+ and D0 --> K+ pi-. +Translation of the X2LcD0KD02KPiBeauty2CharmLine stripping line from Stripping 34. +""" + +from __future__ import absolute_import, division, print_function +import math + +from GaudiKernel.SystemOfUnits import GeV, MeV, mm, mrad, picosecond + +from RecoConf.hlt1_tracking import require_pvs, require_gec +from RecoConf.reco_objects_from_file import (make_pvs, upfront_reconstruction) + +from ..algorithms import require_all, ParticleFilterWithPVs, ParticleCombinerWithPVs, N3BodyCombinerWithPVs +from ..framework import configurable +from Moore.config import HltLine, register_line_builder + +# get the basic particles +from ..standard_particles import make_has_rich_long_kaons, make_has_rich_long_pions, make_has_rich_long_protons + +# get the basic particle filter +from D02HH import make_selected_particles + +all_lines = {} + + +def prefilters(): + """Basic prefilters: GEC and PV requirements""" + return [require_gec(), require_pvs(make_pvs())] + + +"""Start making the D0""" + + +@configurable +def filter_d0_daughters(name="D0DaughtersFilter", + particles, + pvs, + maxTrackChi2=4.0, + minPt=100 * MeV, + minP=1000 * MeV, + minIPChi2=4.0, + maxTrackGhostProb=0.4): + """Filter the kaons/pions used to build the D0. + Translation of the KInputsBeauty2CharmFilter/PiInputsBeauty2CharmFilter from the stripping.""" + + # take as input the basic charm filter in D02HH + filtered_particles = make_selected_particles(make_particles=particles, make_pvs=pvs, + trchi2_max=maxTrackChi2, + mipchi2_min=minIPChi2, + pt_min=minPt, + p_min=minP, + pid_cut=None) + + # apply the TrackGhostProbability cut + code = require_all("TRGHP < {maxTrackGhostProb}").format( + maxTrackGhostProb=maxTrackGhostProb, + ) + + return ParticleFilterWithPVs(filtered_particles, pvs, name=name, Code=code) + + +@configurable +def make_d02kpi(name="D02KPiMaker", + kaons, + pions, + pvs, + minSumPt=1800 * MeV, + minMass=1764.84 * MeV, + maxMass=1964.84 * MeV, + maxTrackChi2_daughter=4.0, + minPt_daughter=500 * MeV, + minP_daughter=5000 * MeV, + minDistChi2PV=1000, + maxVertexChi2_D0=10, + minDistChi2PV_D0=36, + minBPVDIRA_D0=0, + max_ADOCA=0.5 * mm): + """Make the D0 --> K Pi. + Translation of the ProtoD2K+pi-Beauty2Charm combiner from the stripping.""" + + combination_cut = require_all( + "ASUM(PT) > {minSumPt}", + "in_range({minMass}, AWM('K+','pi-'), {maxMass})", + "AHASCHILD((ISBASIC & HASTRACK & (TRCHI2DOF < {maxTrackChi2_daughter}) & (PT > {minPt_daughter}) & (P > {minP_daughter}))|((ABSID=='KS0') & (PT > {minPt_daughter}) & (P > {minP_daughter}) & (BPVVDCHI2 > {minDistChi2PV})))", + "ADOCA(1,2) < {max_ADOCA}", + ).format( + minSumPt=minSumPt, + minMass=minMass, + maxMass=maxMass, + maxTrackChi2_daughter=maxTrackChi2_daughter, + minPt_daughter=minPt_daughter, + minP_daughter=minP_daughter, + minDistChi2PV=minDistChi2PV, + max_ADOCA=max_ADOCA, + ) + + mother_cut = require_all( + "VFASPF(VCHI2/VDOF) < {maxVertexChi2_D0}", + "BPVVDCHI2 > {minDistChi2PV_D0}", + "BPVDIRA > {minBPVDIRA_D0}", + ).format( + maxVertexChi2_D0=maxVertexChi2_D0, + minDistChi2PV_D0=minDistChi2PV_D0, + minBPVDIRA_D0=minBPVDIRA_D0, + ) + + return ParticleCombinerWithPVs( + name=name, + particles=[kaons, pions], + pvs=pvs, + DecayDescriptors=["D0 -> K+ pi-"], + CombinationCut=combination_cut, + MotherCut=mother_cut) + + +@configurable +def filter_d0(name="D0Filter", D0, pvs): + """Filter the D0. + Translation of the D2HHPIDBeauty2CharmFilter and D2KPIPIDBeauty2CharmFilter from the stripping.""" + + code = require_all("NINGENERATION(('p+'==ABSID) & (PIDp < -10),1) == 0", + "NINGENERATION(('K+'==ABSID) & (PIDK < -10), 1) == 0", + "NINGENERATION(('pi+'==ABSID) & (PIDK > 20), 1) == 0", + "NINTREE(ABSID=='K+') == 1") + + return ParticleFilterWithPVs(pions, pvs, name=name, Code=code) + + +"""Now it's time to make the Lc""" + + +@configurable +def filter_lc_daughters(name="LcDaughtersFilter", + particles, + pvs, + maxTrackChi2=4.0, + minPt=100 * MeV, + minP=1000 * MeV, + minIPChi2=4.0, + maxTrackGhostProb=0.4, + PID_code=PID_code): + """Filter the protons/kaons/pions used to build the Lc. + Translation of the filters + P_PIDInputsBeauty2CharmFilter/K_PIDInputsBeauty2CharmFilter/Pi_PIDInputsBeauty2CharmFilter + from the stripping.""" + + # take as input the basic charm filter in D02HH + filtered_particles = make_selected_particles(make_particles=particles, make_pvs=pvs, + trchi2_max=maxTrackChi2, + mipchi2_min=minIPChi2, + pt_min=minPt, + p_min=minP, + pid_cut=None) + + # apply the TrackGhostProbability and PID cut + code = require_all( + "TRGHP < {maxTrackGhostProb}", + PID_code, + ).format( + maxTrackGhostProb=maxTrackGhostProb, + ) + + return ParticleFilterWithPVs(particles, pvs, name=name, Code=code) + + +@configurable +def make_lc2pkpi(name="Lc2pKPiMaker", + protons, + kaons, + pions, + pvs, + decay_descriptors, + maxADOCA_comb12=0.5 * mm, + maxADOCA_comb13=0.4 * mm, + maxADOCA_comb23=0.5 * mm, + minSumPt=1800 * MeV, + massWind_Lc=110 * MeV, + maxTrackChi2_daughter=4., + minPt_daughter=500 * MeV, + minP_daughter=5000 * MeV, + minDistChi2PV=1000, + maxVertexChi2_Lc=10, + minDistChi2PV_Lc=36, + minBPVDIRA_Lc=0): + """Make the Lc --> p K Pi. + Translation of N3BodyDecays/Lc2PKPiBeauty2Charm from the stripping.""" + + combination12_cut = require_all("ADOCA(1,2) < {maxADOCA_comb12}", ).format( + maxADOCA_comb12=maxADOCA_comb12, ) + + combination_cut = require_all( + "ASUM(PT) > {minSumPt}", + "ADAMASS('Lambda_c+') < {massWind_Lc}", + "(AHASCHILD((ISBASIC & HASTRACK & (TRCHI2DOF < {maxTrackChi2_daughter}) & (PT > {minPt_daughters}) & (P > {minP_daughters})) | ((ABSID=='KS0') & (PT > {minPt_daughter}) & (P > {minP_daughter}) & (BPVVDCHI2 > {minDistChi2PV}))))", + "ADOCA(1,3) < {maxADOCA_comb13}", + "ADOCA(2,3) < {maxADOCA_comb23}", + ).format( + minSumPt=minSumPt, + massWind_Lc=massWind_Lc, + maxTrackChi2_daughter=maxTrackChi2_daughter, + minPt_daughter=minPt_daughter, + minP_daughter=minP_daughter, + minDistChi2PV=minDistChi2PV, + maxADOCA_comb13=maxADOCA_comb13, + maxADOCA_comb23=maxADOCA_comb23, + ) + + mother_cut = require_all( + "ADMASS('Lambda_c+') < {massWind_Lc}", + "VFASPF(VCHI2/VDOF) < {maxVertexChi2_Lc}", + "BPVVDCHI2 > {minDistChi2PV_Lc}", + "BPVDIRA > {minBPVDIRA_Lc}", + ).format( + massWind_Lc=massWind_Lc, + maxVertexChi2_Lc=maxVertexChi2_Lc, + minDistChi2PV_Lc=minDistChi2PV_Lc, + minBPVDIRA_Lc=minBPVDIRA_Lc, + ) + + return N3BodyCombinerWithPVs( + name=name, + particles=[protons, kaons, pions], + pvs=pvs, + DecayDescriptors=["[Lambda_c+ -> p+ K- pi+]cc"], + Combination12Cut=combination12_cut, + CombinationCut=combination_cut, + DaughtersCuts=daughters_cut) + + +"""Filter the bachelor kaon""" + + +@configurable +def filter_k_bachelor(name="KBachelorFilter", + kaons, + pvs, + maxTrackChi2=4.0, + minPt=100 * MeV, + minP=1000 * MeV, + minIPChi2=4.0, + maxTrackGhostProb=0.4): + """Filter the bachelor kaon of the Lb decay. + Use the same filter of the D0 daughters.""" + + return filter_D0_daughters( + name=name, + particles=kaons, + pvs=pvs, + maxTrackChi2=maxTrackChi2, + minPt=minPt, + minP=minP, + minIPChi2=minIPChi2, + maxTrackGhostProb=maxTrackGhostProb) + + +"""It is finally time to build the X --> Lc D0 K candidate""" + + +@configurable +def make_x2lcd0k(name="X2LcD0KMaker", + D0, + Lc, + K_bachelor, + pvs, + minSumPt=5000 * MeV, + minMass=5200 * MeV, + maxMass=9000 * MeV, + maxVertexChi2_Lb=10, + minP=10000 * MeV, + minPt=1700 * MeV, + maxTrackChi2=4., + minDistChi2=16, + minDistPV=0.1 * mm, + minP_2=5000 * MeV, + minPt_2=500 * MeV, + minDistChi2PV=1000, + min_lifetime=0.2 * ps, + maxIPChi2=25, + minBPVDira=0.999): + """Build the X candidate. + Translation of the X2LcD0KD02KPiBeauty2Charm combiner from the stripping.""" + + combination_cut = require_all( + "ASUM(SUMTREE(PT,(ISBASIC | (ID=='gamma')),0.0)) > {minSumPt}", + "AM > {minMass}", + "AM < {maxMass}", + ).format( + minSumPt=minSumPt, + minMass=minMass, + maxMass=maxMass, + ) + + mother_cut = require_all( + "VFASPF(VCHI2/VDOF) < {maxVertexChi2_Lb}", + "INTREE(HASTRACK & (P > {minP}) & (PT> {minPt}) & (TRCHI2DOF < {maxTrackChi2}) & (MIPCHI2DV(PRIMARY) > {minDistChi2}) & (MIPDV(PRIMARY) > {minDistPV}))", + "NINTREE((ISBASIC & HASTRACK & (TRCHI2DOF < {maxTrackChi2}) & (PT > {minPt_2}) & (P > {minP_2}))|((ABSID=='KS0') & (PT > {minPt_2}) & (P > {minP_2}) & (BPVVDCHI2 > {minDistChi2PV}))) > 1", + "BPVLTIME() > {min_lifetime}", "BPVIPCHI2() < {maxIPChi2}", + "BPVDIRA > {minBPVDira}").format( + maxVertexChi2_Lb=maxVertexChi2, + minP_Lb=minP, + minPt_Lb=minPt, + maxTrackChi2_Lb=maxTrackChi2, + minDistChi2_Lb=minDistChi2, + minDistPV=minDistPV, + minPt_2=minPt_2, + minP_2=minP_2, + minDistChi2PV=minDistChi2PV, + min_lifetime=min_lifetime, + maxIPChi2=maxIPChi2, + minBPVDira=minBPVDira, + ) + + return ParticleCombinerWithPVs( + name=name, + particles=[Lc, D0, K_bachelor], + pvs=pvs, + DecayDescriptors=['B0 -> Lambda_c+ D0 K-', 'B0 -> Lambda_c~- D0 K+'], + CombinationCut=combination_cut, + MotherCut=mother_cut) + + +@register_line_builder(all_lines) +@configurable +def X2LcD0KLc2pKPiD02KPi(name="HLT2X2LcD0KLc2pKPiD02KPiLine", prescale=1): + "X2LcD0KLc2pKPiD02KPi line" + + # get the PVs + pvs = make_pvs() + + # get the basic protons, kaons and pions + protons = make_has_rich_long_protons() + kaons = make_has_rich_long_kaons() + pions = make_has_rich_long_pions() + + # filter the D0 daughters + kaons_D0 = filter_d0_daughters( + name="D0DaughtersFilter_K_X2LcD0KLc2pKPiD02KPiLine", + particles=kaons, + pvs=pvs) + pions_D0 = filter_d0_daughters( + name="D0DaughtersFilter_Pi_X2LcD0KLc2pKPiD02KPiLine", + particles=pions, + pvs=pvs) + + # make the D0 + D0 = make_d02kpi( + name="D02KPiMaker_X2LcD0KLc2pKPiD02KPiLine", + kaons=kaons_D0, + pions=pions_D0, + pvs=pvs) + + # filter the Lc daughters + protons_Lc = filter_lc_daughters( + name="LcDaughtersFilter_p_X2LcD0KLc2pKPiD02KPiLine", + particles=protons, + pvs=pvs, + PID_code="PIDp>-10.0") + kaons_Lc = filter_lc_daughters( + name="LcDaughtersFilter_K_X2LcD0KLc2pKPiD02KPiLine", + particles=kaons, + pvs=pvs, + PID_code="PIDK>-10.0") + pions_Lc = filter_lc_daughters( + name="LcDaughtersFilter_Pi_X2LcD0KLc2pKPiD02KPiLine", + particles=kaons, + pvs=pvs, + PID_code="PIDK<20.0") + + # make the Lc + Lc = make_lc2pKPi( + name="Lc2pKPiMaker_X2LcD0KLc2pKPiD02KPiLine", + protons=protons_Lc, + kaons=kaons_Lc, + pions=pions_Lc, + pvs=pvs) + + # filter the bachelor kaons + K_bachelor = filter_K_bachelor( + name="KBachelorFilter_X2LcD0KLc2pKPiD02KPiLine", + particles=kaons, + pvs=pvs) + + # make the X2LcD0K candidates + X2LcD0K = make_x2lcd0k( + name="X2LcD0KMaker_X2LcD0KLc2pKPiD02KPiLine", + D0=D0, + Lc=Lc, + K_bachelor=K_bachelor, + pvs=pvs) + + return HltLine( + name=name, + algs=upfront_reconstruction() + prefilters() + [X2LcD0K], + prescale=prescale, + ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/__init__.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/__init__.py index 487c0818e8f7876bd05a2d4aac5fe31680d0a18c..1cdea4ee600718a75d157db55c50163557974ea3 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/__init__.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/__init__.py @@ -15,10 +15,7 @@ to export in a registry called `all_lines`. """ from Moore.config import add_line_to_registry -from . import ( - Bs2JpsiPhi, - D02HH, -) +from . import (Bs2JpsiPhi, D02HH, Lb2LcDLc2pKPiD2HHH, X2LcD0KLc2pKPiD02KPi) __all__ = [ 'all_lines', @@ -40,9 +37,6 @@ def _get_all_lines(modules): return all_lines -modules = [ - Bs2JpsiPhi, - D02HH, -] +modules = [Bs2JpsiPhi, D02HH, Lb2LcDLc2pKPiD2HHH, X2LcD0KLc2pKPiD02KPi] all_lines = _get_all_lines(modules)