def stages(self, nickname = ""):
if hasattr(self, '_stages') and self._stages:
if nickname:
return self._stages[nickname]
else:
return self._stages
from Stages import MassFilter
from Stages import D02KPi
from Stages import DpToKmPipPip
from Stages import DspToKmKpPim
from Stages import LcpToKmPpPip
from Stages import B2PiMu
self._stages = {
'SMOGDpm2KPiPi' : [MassFilter('Dpm2KPiPi', nickname='Dpm2HHH', inputs=[DpToKmPipPip], shared=True)],
'SMOGDs2KKPi' : [MassFilter('Ds2KKPi', nickname='Ds2HHH', inputs=[DspToKmKpPim], shared=True)],
'SMOGLc2KPPi' : [MassFilter('Lc2KPPi', nickname='Lc2HHH', inputs=[LcpToKmPpPip], shared=True)],
'SMOGD02KPi' : [MassFilter('D02KPi', nickname='D02HH', inputs=[D02KPi], shared=True)],
'SMOGB2PiMu' : [MassFilter('B2PiMu', nickname='B2PiMu', inputs=[B2PiMu], shared=True)],
}
if nickname:
return self._stages[nickname]
else:
return self._stages
def locallines(self):
from Stages import MassFilter, DetachedV0V0Combiner
from Stages import CharmHadSharedKsLL, CharmHadSharedKsDD
from Stages import TagDecay, SharedSoftTagChild_pi
## If either KS0 is DD, use the DD dictionary, otherwise use LL.
D2KS0KS0_2LLComb = DetachedV0V0Combiner('Comb',
decay="D0 -> KS0 KS0",
inputs=[CharmHadSharedKsLL],
nickname='D2KS0KS0_LL')
D2KS0KS0_2LL = MassFilter('D2KS0KS0_LL', inputs=[D2KS0KS0_2LLComb])
D2KS0KS0_LLDDComb = DetachedV0V0Combiner(
'Comb',
decay="D0 -> KS0 KS0",
inputs=[CharmHadSharedKsLL, CharmHadSharedKsDD],
lldd=True,
nickname='D2KS0KS0_DD')
D2KS0KS0_LLDD = MassFilter('D2KS0KS0_DD', inputs=[D2KS0KS0_LLDDComb])
D2KS0KS0_2DDComb = DetachedV0V0Combiner('Comb',
decay="D0 -> KS0 KS0",
inputs=[CharmHadSharedKsDD],
nickname='D2KS0KS0_DD')
D2KS0KS0_2DD = MassFilter('D2KS0KS0_DD', inputs=[D2KS0KS0_2DDComb])
# Now the tagged lines
Dstp2D0Pip_D2KS0KS0_2LL = TagDecay(
'D02V0V0_TAG_CPV', ["D*(2010)- -> D0 pi-", "D*(2010)+ -> D0 pi+"],
inputs=[D2KS0KS0_2LL, SharedSoftTagChild_pi],
ReFitPVs=True)
Dstp2D0Pip_D2KS0KS0_LLDD = TagDecay(
'D02V0V0_TAG_CPV', ["D*(2010)- -> D0 pi-", "D*(2010)+ -> D0 pi+"],
inputs=[D2KS0KS0_LLDD, SharedSoftTagChild_pi],
ReFitPVs=True)
Dstp2D0Pip_D2KS0KS0_2DD = TagDecay(
'D02V0V0_TAG_CPV', ["D*(2010)- -> D0 pi-", "D*(2010)+ -> D0 pi+"],
inputs=[D2KS0KS0_2DD, SharedSoftTagChild_pi],
ReFitPVs=True)
stages = {
# First untagged
'D02KS0KS0_KS0LLTurbo': [D2KS0KS0_2LL],
'D02KS0KS0_KS0LL_KS0DDTurbo': [D2KS0KS0_LLDD],
'D02KS0KS0_KS0DDTurbo': [D2KS0KS0_2DD],
# Now tagged
'Dstp2D0Pip_D02KS0KS0_KS0LLTurbo': [Dstp2D0Pip_D2KS0KS0_2LL],
'Dstp2D0Pip_D02KS0KS0_KS0LL_KS0DDTurbo':
[Dstp2D0Pip_D2KS0KS0_LLDD],
'Dstp2D0Pip_D02KS0KS0_KS0DDTurbo': [Dstp2D0Pip_D2KS0KS0_2DD]
}
return stages
def locallines(self):
from Stages import MassFilter
from Stages import H2LambdaPrPi_LLLL, H2LambdaPrPi_DDLL
from Stages import H2LambdaPrPi_DDDD
from Stages import H2LambdaPiPr_LLLL, H2LambdaPiPr_DDLL
from Stages import H2LambdaPiPr_DDDD
# These are the "real" H --> Lambda,p+,pi- lines
Filtered_LamPrPi_LLLL = MassFilter('SecondaryH2LambdaPrPi_LLLL_Mass',
inputs=[H2LambdaPrPi_LLLL])
Filtered_LamPrPi_DDLL = MassFilter('SecondaryH2LambdaPrPi_DDLL_Mass',
inputs=[H2LambdaPrPi_DDLL])
Filtered_LamPrPi_DDDD = MassFilter('SecondaryH2LambdaPrPi_DDLL_Mass',
inputs=[H2LambdaPrPi_DDDD])
# These are the "fake" H --> Lambda,pi+,pi- lines (no net baryon number)
Filtered_LamPiPr_LLLL = MassFilter('SecondaryH2LambdaPrPi_LLLL_Mass',
inputs=[H2LambdaPiPr_LLLL])
Filtered_LamPiPr_DDLL = MassFilter('SecondaryH2LambdaPrPi_DDLL_Mass',
inputs=[H2LambdaPiPr_DDLL])
Filtered_LamPiPr_DDDD = MassFilter('SecondaryH2LambdaPrPi_DDLL_Mass',
inputs=[H2LambdaPiPr_DDDD])
stages = {
'SecondaryH2LamPpPimLLLLTurbo': [Filtered_LamPrPi_LLLL],
'SecondaryH2LamPpPimDDLLTurbo': [Filtered_LamPrPi_DDLL],
'SecondaryH2LamPpPimDDDDTurbo': [Filtered_LamPrPi_DDDD],
'SecondaryH2LamPipPmLLLLTurbo': [Filtered_LamPiPr_LLLL],
'SecondaryH2LamPipPmDDLLTurbo': [Filtered_LamPiPr_DDLL],
'SecondaryH2LamPipPmDDDDTurbo': [Filtered_LamPiPr_DDDD],
}
return stages
def locallines(self):
from Stages import HKsKsCombiner, MassFilter
from Stages import CharmHadSharedKsLL, CharmHadSharedKsDD
from Stages import SharedDetachedDpmChild_pi, SharedDetachedDpmChild_K, SharedDetachedLcChild_p
Dp2KsKsPip_LL = HKsKsCombiner('Dp2KsKsPip_LL', decay="[D+ -> KS0 KS0 pi+]cc",
inputs=[CharmHadSharedKsLL, CharmHadSharedKsDD, SharedDetachedDpmChild_pi],
nickname='Dp2KsKsH')
Dp2KsKsKp_LL = HKsKsCombiner('Dp2KsKsKp_LL', decay="[D+ -> KS0 KS0 K+]cc",
inputs=[CharmHadSharedKsLL, CharmHadSharedKsDD, SharedDetachedDpmChild_K],
nickname='Dp2KsKsH')
Dsp2KsKsPip_LL = HKsKsCombiner('Dsp2KsKsPip_LL', decay="[D_s+ -> KS0 KS0 pi+]cc",
inputs=[CharmHadSharedKsLL, CharmHadSharedKsDD, SharedDetachedDpmChild_pi],
nickname='Ds2KsKsH')
Dsp2KsKsKp_LL = HKsKsCombiner('Dsp2KsKsKp_LL', decay="[D_s+ -> KS0 KS0 K+]cc",
inputs=[CharmHadSharedKsLL, CharmHadSharedKsDD, SharedDetachedDpmChild_K],
nickname='Ds2KsKsH')
Lcp2KsKsPp_LL = HKsKsCombiner('Lcp2KsKsPp_LL', decay="[Lambda_c+ -> KS0 KS0 p+]cc",
inputs=[CharmHadSharedKsLL, CharmHadSharedKsDD, SharedDetachedLcChild_p],
nickname='Lc2KsKsH')
Dp2KS0KS0Pip = MassFilter('Dp2KsKsHMass',inputs=[Dp2KsKsPip_LL])
Dp2KS0KS0Kp = MassFilter('Dp2KsKsHMass',inputs=[Dp2KsKsKp_LL])
Dsp2KS0KS0Pip = MassFilter('Ds2KsKsHMass',inputs=[Dsp2KsKsPip_LL])
Dsp2KS0KS0Kp = MassFilter('Ds2KsKsHMass',inputs=[Dsp2KsKsKp_LL])
Lcp2KS0KS0Pp = MassFilter('Lc2KsKsHMass',inputs=[Lcp2KsKsPp_LL])
stages = {
'Dp2KS0KS0PipTurbo' : [Dp2KS0KS0Pip],
'Dp2KS0KS0KpTurbo' : [Dp2KS0KS0Kp],
'Dsp2KS0KS0PipTurbo' : [Dsp2KS0KS0Pip],
'Dsp2KS0KS0KpTurbo' : [Dsp2KS0KS0Kp],
'Lcp2KS0KS0PpTurbo' : [Lcp2KS0KS0Pp],
}
return stages
def locallines(self):
from Stages import MassFilter
from Stages import Xi2LambdaPi_LLL, Xi2LambdaPi_DDL, Xi2LambdaPi_DDD
from Stages import Omega2LambdaK_LLL, Omega2LambdaK_DDL, Omega2LambdaK_DDD
stages = {#
'Xim2LamPim_LLLTurbo' : [MassFilter('Ximinus2LambdaPi_LLL', inputs=[Xi2LambdaPi_LLL])],
'Xim2LamPim_DDLTurbo' : [MassFilter('Ximinus2LambdaPi_DDL',inputs=[Xi2LambdaPi_DDL])],
'Xim2LamPim_DDDTurbo' : [MassFilter('Ximinus2LambdaPi_DDD',inputs=[Xi2LambdaPi_DDD])],
'Omm2LamKm_LLLTurbo' : [MassFilter('Omegaminus2LambdaK_LLL',inputs=[Omega2LambdaK_LLL])],
'Omm2LamKm_DDLTurbo' : [MassFilter('Omegaminus2LambdaK_DDL',inputs=[Omega2LambdaK_DDL])],
'Omm2LamKm_DDDTurbo' : [MassFilter('Omegaminus2LambdaK_DDD',inputs=[Omega2LambdaK_DDD])],
}
return stages
def locallines(self):
from Stages import MassFilter, DetachedV0HCombiner
from Stages import SharedDetachedDpmChild_pi, SharedDetachedDpmChild_K
from Stages import CharmHadSharedKsLL, CharmHadSharedKsDD
from Stages import SharedDetachedLcChild_pi, SharedDetachedLcChild_K
from Inputs import Lambda_LL, Lambda_DD
D2V0H_D2KS0Pi_LL = DetachedV0HCombiner(
'Comb',
decay="[D+ -> pi+ KS0]cc",
inputs=[SharedDetachedDpmChild_pi, CharmHadSharedKsLL],
nickname='D2V0H')
D2KS0Pi_LL = MassFilter('D2V0H', inputs=[D2V0H_D2KS0Pi_LL])
D2V0H_D2KS0K_LL = DetachedV0HCombiner(
'Comb',
decay="[D+ -> K+ KS0]cc",
inputs=[SharedDetachedDpmChild_K, CharmHadSharedKsLL],
nickname='D2V0H')
D2KS0K_LL = MassFilter('D2V0H', inputs=[D2V0H_D2KS0K_LL])
D2V0H_D2KS0Pi_DD = DetachedV0HCombiner(
'Comb',
decay="[D+ -> pi+ KS0]cc",
inputs=[SharedDetachedDpmChild_pi, CharmHadSharedKsDD],
nickname='D2V0H')
D2KS0Pi_DD = MassFilter('D2V0H', inputs=[D2V0H_D2KS0Pi_DD])
D2V0H_D2KS0K_DD = DetachedV0HCombiner(
'Comb',
decay="[D+ -> K+ KS0]cc",
inputs=[SharedDetachedDpmChild_K, CharmHadSharedKsDD],
nickname='D2V0H')
D2KS0K_DD = MassFilter('D2V0H', inputs=[D2V0H_D2KS0K_DD])
Lc2V0H_Lc2LambdaPi_LL = DetachedV0HCombiner(
'Comb',
decay="[Lambda_c+ -> pi+ Lambda0]cc",
inputs=[SharedDetachedLcChild_pi, Lambda_LL],
nickname='Lc2V0H')
Lc2LambdaPi_LL = MassFilter('Lc2V0H', inputs=[Lc2V0H_Lc2LambdaPi_LL])
Lc2V0H_Lc2LambdaK_LL = DetachedV0HCombiner(
'Comb',
decay="[Lambda_c+ -> K+ Lambda0]cc",
inputs=[SharedDetachedLcChild_K, Lambda_LL],
nickname='Lc2V0H')
Lc2LambdaK_LL = MassFilter('Lc2V0H', inputs=[Lc2V0H_Lc2LambdaK_LL])
Lc2V0H_Lc2LambdaPi_DD = DetachedV0HCombiner(
'Comb',
decay="[Lambda_c+ -> pi+ Lambda0]cc",
inputs=[SharedDetachedLcChild_pi, Lambda_DD],
nickname='Lc2V0H')
Lc2LambdaPi_DD = MassFilter('Lc2V0H', inputs=[Lc2V0H_Lc2LambdaPi_DD])
Lc2V0H_Lc2LambdaK_DD = DetachedV0HCombiner(
'Comb',
decay="[Lambda_c+ -> K+ Lambda0]cc",
inputs=[SharedDetachedLcChild_K, Lambda_DD],
nickname='Lc2V0H')
Lc2LambdaK_DD = MassFilter('Lc2V0H', inputs=[Lc2V0H_Lc2LambdaK_DD])
stages = {
'Dp2KS0Pip_KS0LLTurbo': [D2KS0Pi_LL],
'Dp2KS0Kp_KS0LLTurbo': [D2KS0K_LL],
'Dp2KS0Pip_KS0DDTurbo': [D2KS0Pi_DD],
'Dp2KS0Kp_KS0DDTurbo': [D2KS0K_DD],
#
'Lcp2LamPip_LamLLTurbo': [Lc2LambdaPi_LL],
'Lcp2LamKp_LamLLTurbo': [Lc2LambdaK_LL],
'Lcp2LamPip_LamDDTurbo': [Lc2LambdaPi_DD],
'Lcp2LamKp_LamDDTurbo': [Lc2LambdaK_DD],
}
return stages
def get_stages(_):
from Stages import TrackGEC, MassFilter, B2XGammaCombiner, HyperonAll, SecondaryLambdaFilter, ChargedHyperonL0HCombiner, Hypb2L0HGammaCombiner
from HltTracking.HltPVs import PV3D
from Inputs import Hlt2LoosePions, Hlt2DownPions, Hlt2LooseKaons, Hlt2DownKaons
## instantiate combiners for LL and DD
from Inputs import LambdaDD, LambdaLL
SharedSecondaryLambdaLL = SecondaryLambdaFilter("SharedSecondaryLambdaLL",[LambdaLL])
SharedSecondaryLambdaDD = SecondaryLambdaFilter("SharedSecondaryLambdaDD",[LambdaDD])
Xi2L0Pi_LLL = ChargedHyperonL0HCombiner('Ximinus2L0Pi_LLL',
decay="[Xi- -> Lambda0 pi-]cc",
inputs=[SharedSecondaryLambdaLL, Hlt2LoosePions])
Xi2L0Pi_DDL = ChargedHyperonL0HCombiner('Ximinus2L0Pi_DDL',
decay="[Xi- -> Lambda0 pi-]cc",
inputs=[SharedSecondaryLambdaDD, Hlt2LoosePions])
Xi2L0Pi_DDD = ChargedHyperonL0HCombiner('Ximinus2L0Pi_DDD',
decay="[Xi- -> Lambda0 pi-]cc",
inputs=[SharedSecondaryLambdaDD, Hlt2DownPions])
Omega2L0K_LLL = ChargedHyperonL0HCombiner('Omegaminus2L0K_LLL',
decay="[Omega- -> Lambda0 K-]cc",
inputs=[SharedSecondaryLambdaLL, Hlt2LooseKaons])
Omega2L0K_DDL = ChargedHyperonL0HCombiner('Omegaminus2L0K_DDL',
decay="[Omega- -> Lambda0 K-]cc",
inputs=[SharedSecondaryLambdaDD, Hlt2LooseKaons])
Omega2L0K_DDD = ChargedHyperonL0HCombiner('Omegaminus2L0K_DDD',
decay="[Omega- -> Lambda0 K-]cc",
inputs=[SharedSecondaryLambdaDD, Hlt2DownKaons])
Xim2LamPim_LLL = MassFilter('Ximinus2L0Pi_LLL', [Xi2L0Pi_LLL])
Xim2LamPim_DDL = MassFilter('Ximinus2L0Pi_DDL', [Xi2L0Pi_DDL])
Xim2LamPim_DDD = MassFilter('Ximinus2L0Pi_DDD', [Xi2L0Pi_DDD])
Omm2LamKm_LLL = MassFilter('Omegaminus2L0K_LLL', [Omega2L0K_LLL])
Omm2LamKm_DDL = MassFilter('Omegaminus2L0K_DDL', [Omega2L0K_DDL])
Omm2LamKm_DDD = MassFilter('Omegaminus2L0K_DDD', [Omega2L0K_DDD])
Xi_minus = HyperonAll('Xi_minus',
[Xim2LamPim_LLL, Xim2LamPim_DDL, Xim2LamPim_DDD])
Omega_minus = HyperonAll('Omega_minus',
[Omm2LamKm_LLL, Omm2LamKm_DDL, Omm2LamKm_DDD])
#Build stages
stages = {'RadiativeHypb2L0HGammaXi': [TrackGEC(),
PV3D('Hlt2'),
Hypb2L0HGammaCombiner('Xibm2XimGamma',
'[Xi_b- -> Xi- gamma]cc',
Xi_minus)],
'RadiativeHypb2L0HGammaOm': [TrackGEC(),
PV3D('Hlt2'),
Hypb2L0HGammaCombiner('Ombm2OmmGamma',
'[Omega_b- -> Omega- gamma]cc',
Omega_minus)],
'RadiativeHypb2L0HGammaXiEE': [TrackGEC(),
PV3D('Hlt2'),
B2XGammaCombiner('Xibm2XimGammaEE',
'[Xi_b- -> Xi- gamma]cc',
Xi_minus,
True)],
'RadiativeHypb2L0HGammaOmEE': [TrackGEC(),
PV3D('Hlt2'),
B2XGammaCombiner('Ombm2OmmGammaEE',
'[Omega_b- -> Omega- gamma]cc',
Omega_minus,
True)]
}
return stages
def locallines(self):
from Stages import MassFilter,TagDecay,TagDecayWithNeutral
from Stages import SharedSoftTagChild_pi,SharedNeutralLowPtChild_pi0,SharedNeutralLowPtChild_gamma
from Stages import XSec_D02KPi, XSec_D02K3Pi
from Stages import XSec_DpToKmPipPip, XSec_DpToKmKpPim
from Stages import XSec_DspToKmKpPim, XSec_DspToPimPipPip
from Stages import XSec_LcpToKmPpPip, XSec_LcpToPimPpPip, XSec_LcpToKmPpKp
stages = {# First the D2HHH lines
'Dpm2KPiPi_XSecTurbo' : [MassFilter('Dpm2KPiPi_XSec',nickname='Dpm2HHH_XSec',
inputs=[XSec_DpToKmPipPip],shared=True)],
'Dpm2KKPi_XSecTurbo' : [MassFilter('Dpm2KKPi_XSec', nickname = 'Dpm2HHH_XSec',
inputs=[XSec_DpToKmKpPim],shared=True)],
'Ds2KKPi_XSecTurbo' : [MassFilter('Ds2KKPi_XSec', nickname = 'Ds2HHH_XSec',
inputs=[XSec_DspToKmKpPim],shared=True)],
'Ds2PiPiPi_XSecTurbo' : [MassFilter('Ds2PiPiPi_XSec', nickname = 'Ds2HHH_XSec',
inputs=[XSec_DspToPimPipPip],shared=True)],
# Now the Lc2HHH lines, untagged, CF shared to reuse in tagged lines
# Because of the mass window these also catch neutral Xi_c baryons
'Lc2KPPi_XSecTurbo' : [MassFilter('Lc2KPPi_XSec', nickname = 'Lc2HHH_XSec',
inputs=[XSec_LcpToKmPpPip],shared=True)],
'Lc2KPK_XSecTurbo' : [MassFilter('Lc2KPK_XSec', nickname = 'Lc2HHH_XSec',
inputs=[XSec_LcpToKmPpKp],shared=True)],
'Lc2PiPPi_XSecTurbo' : [MassFilter('Lc2PiPPi_XSec', nickname = 'Lc2HHH_XSec',
inputs=[XSec_LcpToPimPpPip],shared=True)],
# The untagged D->KPi line
'D02KPi_XSecTurbo' : [MassFilter('D02KPi_XSec',nickname='D02HH_XSec',
inputs=[XSec_D02KPi],shared=True)]
}
# Now the Sigma_c0,++->Lambda_c(pKpi)pi line
# Because of the mass window this also catches some excited Xi_c
stages['Sigmac_2LcPi_XSecTurbo'] = [TagDecay('Sigmac_2LcPi_XSec',
["[Sigma_c0 -> Lambda_c+ pi-]cc",
"[Sigma_c++ -> Lambda_c+ pi+]cc"],
inputs = [ stages["Lc2KPPi_XSecTurbo"][0],
SharedSoftTagChild_pi ],
nickname = 'Sigmac_TAG_XSec', shared=True) ]
# Now the D*->D0pi line for the D0->KPi case
stages['Dst_2D0Pi_D02KPi_XSecTurbo'] = [TagDecay('Dst_2D0Pi_D02KPi_XSec',
["[D*(2010)+ -> D0 pi+]cc"],
inputs = [ stages["D02KPi_XSecTurbo"][0],
SharedSoftTagChild_pi ],
nickname = 'D0_TAG_XSec', shared=True) ]
# Now the D*->D0pi line for the D0->K3Pi case
stages['Dst_2D0Pi_D02K3Pi_XSecTurbo'] = [TagDecay('Dst_2D0Pi_D02K3Pi_XSec',
["[D*(2010)+ -> D0 pi+]cc"],
inputs = [ MassFilter('D02K3Pi_XSec',nickname='D02HHHH_XSec',
inputs=[XSec_D02K3Pi],shared=True),
SharedSoftTagChild_pi ],
nickname='D0_TAG_XSec', shared=True) ]
# Now the lines tagged with a photon or pi0
stages['Dst_2D0Pi0_D02KPi_XSecTurbo'] = [TagDecayWithNeutral('Dst_2D0Pi0_D02KPi_XSec',
["D*(2007)0 -> D0 pi0","D*(2007)0 -> D~0 pi0"],
inputs = [ stages["D02KPi_XSecTurbo"][0],
SharedNeutralLowPtChild_pi0 ],
nickname='D_TAG_NEUTRAL_XSec', shared=True) ]
stages['Dst_2D0Gamma_D02KPi_XSecTurbo'] = [TagDecayWithNeutral('Dst_2D0Gamma_D02KPi_XSec',
["D*(2007)0 -> D0 gamma","D*(2007)0 -> D~0 gamma"],
inputs = [ stages["D02KPi_XSecTurbo"][0],
SharedNeutralLowPtChild_gamma ],
nickname='D_TAG_NEUTRAL_XSec', shared=True) ]
stages['Dst_2DsGamma_Ds2KKPi_XSecTurbo'] = [TagDecayWithNeutral('Dst_2DsGamma_Ds2KKPi_XSec',
["[D*_s+ -> D_s+ gamma]cc"],
inputs = [ stages["Ds2KKPi_XSecTurbo"][0],
SharedNeutralLowPtChild_gamma ],
nickname='D_TAG_NEUTRAL_XSec',shared=True) ]
return stages
def locallines(self):
from Stages import MassFilter, H2LambdaLambdaCombiner
from Stages import CharmHadSharedSecondaryLambdaDD, CharmHadSharedSecondaryLambdaLL
## If either Lambda is DD, use the DD dictionary, otherwise use LL.
## First, let's do the H-dibaryon candidates
H2LamLam_2LLComb = H2LambdaLambdaCombiner(
'Comb',
decay="[D0 -> Lambda0 Lambda0]cc",
inputs=[CharmHadSharedSecondaryLambdaLL],
nickname='H2LamLam_LL')
H2LamLam_2LL = MassFilter('H2LamLam_LL', inputs=[H2LamLam_2LLComb])
H2LamLam_LLDDComb = H2LambdaLambdaCombiner(
'Comb',
decay="[D0 -> Lambda0 Lambda0]cc",
inputs=[
CharmHadSharedSecondaryLambdaLL,
CharmHadSharedSecondaryLambdaDD
],
lldd=True,
nickname='H2LamLam_DD')
H2LamLam_LLDD = MassFilter('H2LamLam_DD', inputs=[H2LamLam_LLDDComb])
H2LamLam_2DDComb = H2LambdaLambdaCombiner(
'Comb',
decay="[D0 -> Lambda0 Lambda0]cc",
inputs=[CharmHadSharedSecondaryLambdaDD],
nickname='H2LamLam_DD')
H2LamLam_2DD = MassFilter('H2LamLam_DD', inputs=[H2LamLam_2DDComb])
## next, look at the corresponding Lambda,anti-Lambda candidates
H2LamLamBar_2LLComb = H2LambdaLambdaCombiner(
'Comb',
decay="D0 -> Lambda0 Lambda~0",
inputs=[CharmHadSharedSecondaryLambdaLL],
nickname='H2LamLam_LL')
H2LamLamBar_2LL = MassFilter('H2LamLam_LL',
inputs=[H2LamLamBar_2LLComb])
H2LamLamBar_LLDDComb = H2LambdaLambdaCombiner(
'Comb',
decay="D0 -> Lambda0 Lambda~0",
inputs=[
CharmHadSharedSecondaryLambdaLL,
CharmHadSharedSecondaryLambdaDD
],
lldd=True,
nickname='H2LamLam_DD')
H2LamLamBar_LLDD = MassFilter('H2LamLam_DD',
inputs=[H2LamLamBar_LLDDComb])
H2LamLamBar_2DDComb = H2LambdaLambdaCombiner(
'Comb',
decay="D0 -> Lambda0 Lambda~0",
inputs=[CharmHadSharedSecondaryLambdaDD],
nickname='H2LamLam_DD')
H2LamLamBar_2DD = MassFilter('H2LamLam_DD',
inputs=[H2LamLamBar_2DDComb])
stages = {
'PromptH2LamLam_LamLLTurbo': [H2LamLam_2LL],
'PromptH2LamLam_LamLL_LamDDTurbo': [H2LamLam_LLDD],
'PromptH2LamLam_LamDDTurbo': [H2LamLam_2DD],
'PromptH2LamLamBar_LamLLTurbo': [H2LamLamBar_2LL],
'PromptH2LamLamBar_LamLL_LamDDTurbo': [H2LamLamBar_LLDD],
'PromptH2LamLamBar_LamDDTurbo': [H2LamLamBar_2DD],
}
return stages
def locallines(self):
from Stages import MassFilter, TagDecay, HHHCombiner
from Stages import DetAsym_DpToKmPipPip
from Stages import SharedSoftTagChild_pi
from Stages import SharedPromptChild_K, SharedPromptChild_pi
from Stages import SharedTighterPromptChild_p
#
from Stages import D2HHH_DpToKmPipPip, D2HHH_DpToKpPimPip
from Stages import D2HHH_DpToKmKpPip, D2HHH_DpToKpKpPim
from Stages import D2HHH_DpToPimPipPip, D2HHH_DpToKmKpKp
#
from Stages import D2HHH_DspToKpPimPip, D2HHH_DspToKmPipPip
from Stages import D2HHH_DspToKpKpPim, D2HHH_DspToKmKpPip
from Stages import D2HHH_DspToPimPipPip, D2HHH_DspToKmKpKp
#
from Stages import LcXic2HHH_LcpToKmPpPip, LcXic2HHH_LcpToKmPpKp
from Stages import LcXic2HHH_LcpToPimPpPip, LcXic2HHH_LcpToPimPpKp
from Stages import Lc2HHH_LcpToKmPpPip, Xic2HHH_XicpToKmPpPip
## MassFilters for imported combiner instances.
## Since the D+ and D_s+ combinatorics were separated, do we still need
## to apply MassFilter?
## The end-point of the DpToKmPipPip line is used as input to the DPS
## module and must be shared. Because it is not used anywhere else
## in CharmHad, it can be defined here rather than in Stages.py
DpToKmPipPip = MassFilter('DpToKmPipPip',
inputs=[D2HHH_DpToKmPipPip],
nickname='Dpm2HHH',
shared=True,
reFitPVs=True)
## The other D+ -> 3h lines can have non-shared mass filters.
DpToKpPimPip = MassFilter('Dpm2HHH',
inputs=[D2HHH_DpToKpPimPip],
reFitPVs=True)
DpToKmKpPip = MassFilter('Dpm2HHH',
inputs=[D2HHH_DpToKmKpPip],
reFitPVs=True)
DpToPimPipPip = MassFilter('Dpm2HHH',
inputs=[D2HHH_DpToPimPipPip],
reFitPVs=True)
DpToKmKpKp = MassFilter('Dpm2HHH',
inputs=[D2HHH_DpToKmKpKp],
reFitPVs=True)
DpToKpKpPim = MassFilter('Dpm2HHH',
inputs=[D2HHH_DpToKpKpPim],
reFitPVs=True)
## The end-point of the DspToKmKpPip line is used as input to the DPS
## module and must be shared. Because it is not used anywhere else
## in CharmHad, it can be defined here rather than in Stages.py
DspToKmKpPip = MassFilter('DspToKmKpPip',
inputs=[D2HHH_DspToKmKpPip],
nickname='Ds2HHH',
shared=True,
reFitPVs=True)
## The other D_s+ -> 3h lines can have non-shared mass filters.
DspToKpKpPim = MassFilter('Ds2HHH',
inputs=[D2HHH_DspToKpKpPim],
reFitPVs=True)
DspToKpPimPip = MassFilter('Ds2HHH',
inputs=[D2HHH_DspToKpPimPip],
reFitPVs=True)
DspToPimPipPip = MassFilter('Ds2HHH',
inputs=[D2HHH_DspToPimPipPip],
reFitPVs=True)
DspToKmKpKp = MassFilter('Ds2HHH',
inputs=[D2HHH_DspToKmKpKp],
reFitPVs=True)
DspToKmPipPip = MassFilter('Ds2HHH',
inputs=[D2HHH_DspToKmPipPip],
reFitPVs=True)
## The end-point of the LcpToPpKmPip line is used as input to the DPS
## module and as input the CharmSpectroscopyLines.py lines.
## Because it is shared within CharmHad, its definition is in Stages.py.
LcpToKmPpKp = MassFilter('Lc2HHH',
inputs=[LcXic2HHH_LcpToKmPpKp],
reFitPVs=True)
LcpToPimPpPip = MassFilter('Lc2HHH',
inputs=[LcXic2HHH_LcpToPimPpPip],
reFitPVs=True)
LcpToPimPpKp = MassFilter('Lc2HHH',
inputs=[LcXic2HHH_LcpToPimPpKp],
reFitPVs=True)
## Maximally-biased-lifetime combiners.
Dpm2HHH_DpToKmPipPip_LTUNB = HHHCombiner(
'Comb',
decay="[D+ -> K- pi+ pi+]cc",
inputs=[SharedPromptChild_pi, SharedPromptChild_K],
nickname='Dpm2HHH_LTUNB')
DpToKmPipPip_LTUNB = MassFilter('Dpm2HHH_LTUNB',
inputs=[Dpm2HHH_DpToKmPipPip_LTUNB],
reFitPVs=True)
Ds2HHH_DspToKmKpPip_LTUNB = HHHCombiner(
'Comb',
decay="[D_s+ -> K- K+ pi+]cc",
inputs=[SharedPromptChild_pi, SharedPromptChild_K],
nickname='Ds2HHH_LTUNB')
DspToKmKpPip_LTUNB = MassFilter('Ds2HHH_LTUNB',
inputs=[Ds2HHH_DspToKmKpPip_LTUNB],
reFitPVs=True)
Lc2HHH_LcpToPpKmPip_LTUNB = HHHCombiner(
'Comb',
decay="[Lambda_c+ -> K- p+ pi+]cc",
inputs=[
SharedPromptChild_pi, SharedPromptChild_K,
SharedTighterPromptChild_p
],
nickname='Lc2HHH_LTUNB')
LcpToPpKmPip_LTUNB = MassFilter('Lc2HHH_LTUNB',
inputs=[Lc2HHH_LcpToPpKmPip_LTUNB],
reFitPVs=True)
## Selection specifically for detector asymmetry measurements
Dpm2KPiPi_ForKPiAsym = MassFilter('Dpm2KPiPi_ForKPiAsym',
inputs=[DetAsym_DpToKmPipPip],
reFitPVs=True)
## The stages dictionary should be a clear two-column list from
## which the lines defined in this module can be directly read.
stages = {
## CPV D+ -> HHH lines.
'DpToKmPipPipTurbo': [DpToKmPipPip],
'DpToKpPimPipTurbo': [DpToKpPimPip],
'DpToKmKpPipTurbo': [DpToKmKpPip],
'DpToPimPipPipTurbo': [DpToPimPipPip],
'DpToKmKpKpTurbo': [DpToKmKpKp],
'DpToKpKpPimTurbo': [DpToKpKpPim],
## CPV D_s+ -> HHH lines.
## Explicitly includes forbidden KmPipPip.
'DspToKmKpPipTurbo': [DspToKmKpPip],
'DspToKpKpPimTurbo': [DspToKpKpPim],
'DspToKpPimPipTurbo': [DspToKpPimPip],
'DspToPimPipPipTurbo': [DspToPimPipPip],
'DspToKmKpKpTurbo': [DspToKmKpKp],
'DspToKmPipPipTurbo': [DspToKmPipPip],
# CPV L_c+ -> HHH lines
'LcpToPpKmPipTurbo': [Lc2HHH_LcpToKmPpPip],
'LcpToPpKmKpTurbo': [LcpToKmPpKp],
'LcpToPpPimPipTurbo': [LcpToPimPpPip],
'LcpToPpKpPimTurbo': [LcpToPimPpKp],
## Xi_c+ -> p K- pi+, DO NOT SEND TO TURBO.
'XicpToPpKmPipTurbo': [Xic2HHH_XicpToKmPpPip],
# Now the three CF lifetime unbiased lines
'DpToKmPipPip_LTUNBTurbo': [DpToKmPipPip_LTUNB],
'DspToKmKpPip_LTUNBTurbo': [DspToKmKpPip_LTUNB],
'LcpToPpKmPip_LTUNBTurbo': [LcpToPpKmPip_LTUNB],
# Now the KPi asymmetry line
'DpToKmPipPip_ForKPiAsymTurbo': [Dpm2KPiPi_ForKPiAsym]
}
# Create Full stream version of this line for use in
# flavour tagging calibration.
stages['DspToKmKpPip'] = stages['DspToKmKpPipTurbo']
return stages
def locallines(self):
from Stages import MassFilter
from Stages import D02KsPiPi_LL, D02KsPiPi_DD
from Stages import D02KsKPi_LL, D02KsKPi_DD
from Stages import D02KsKK_LL, D02KsKK_DD
from Stages import D02KsPiPi_LL_LTUNB, D02KsPiPi_DD_LTUNB
from Stages import D02KsKPi_LL_LTUNB, D02KsKPi_DD_LTUNB
from Stages import D02KsKK_LL_LTUNB, D02KsKK_DD_LTUNB
from Stages import TagDecay
from Stages import SharedSoftTagChild_pi
Filtered_D02KsPiPi_LL = MassFilter('D02KshPiPi_LL',
inputs=[D02KsPiPi_LL])
Filtered_D02KsPiPi_DD = MassFilter('D02KshPiPi_DD',
inputs=[D02KsPiPi_DD])
Filtered_D02KsKPi_LL = MassFilter('D02KshKPi_LL', inputs=[D02KsKPi_LL])
Filtered_D02KsKPi_DD = MassFilter('D02KshKPi_DD', inputs=[D02KsKPi_DD])
Filtered_D02KsKK_LL = MassFilter('D02KshKK_LL', inputs=[D02KsKK_LL])
Filtered_D02KsKK_DD = MassFilter('D02KshKK_DD', inputs=[D02KsKK_DD])
Filtered_D02KsPiPi_LL_LTUNB = MassFilter('D02KshPiPi_LL',
inputs=[D02KsPiPi_LL_LTUNB])
Filtered_D02KsPiPi_DD_LTUNB = MassFilter('D02KshPiPi_DD',
inputs=[D02KsPiPi_DD_LTUNB])
Filtered_D02KsKPi_LL_LTUNB = MassFilter('D02KshKPi_LL',
inputs=[D02KsKPi_LL_LTUNB])
Filtered_D02KsKPi_DD_LTUNB = MassFilter('D02KshKPi_DD',
inputs=[D02KsKPi_DD_LTUNB])
Filtered_D02KsKK_LL_LTUNB = MassFilter('D02KshKK_LL',
inputs=[D02KsKK_LL_LTUNB])
Filtered_D02KsKK_DD_LTUNB = MassFilter('D02KshKK_DD',
inputs=[D02KsKK_DD_LTUNB])
## We can probably use only D*-tagged HHKs candidates, so let's make
## the corresponding D*-tagged lines.
##
## Recall that the first argument of Dst2D0pi is the "name" used in
## the dictionary of cuts and the second argument is the "d0" list to
## be used.
##
## All of the following lines use a common dictionary
## "name": Dst2D0pi_D02HHKsh
## as the channels should be sufficiently similar to use common cuts.
Dstp2D0Pip_D02KS0PimPip_KS0LL = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[Filtered_D02KsPiPi_LL, SharedSoftTagChild_pi])
Dstp2D0Pip_D02KS0PimPip_KS0DD = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[Filtered_D02KsPiPi_DD, SharedSoftTagChild_pi])
## These lines will produce
## D*+ --> D0,pi+; D0 --> D0 --> K-,pi+,Kshort candidates
## and also D*- --> D0bar,pi-; D0bar --> K+,pi-,Kshort candidates;
## Ignoring CPV in K0 and K0bar decays to Kshort, these are CP
## conjugate decays.
Dstp2D0Pip_D02KS0KmPip_KS0LL = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D~0 pi-"],
inputs=[Filtered_D02KsKPi_LL, SharedSoftTagChild_pi])
Dstp2D0Pip_D02KS0KmPip_KS0DD = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D~0 pi-"],
inputs=[Filtered_D02KsKPi_DD, SharedSoftTagChild_pi])
## These lines will produce
## D*+ --> D0,pi+; D0 --> D0 --> K+,pi-,Kshort candidates
## and also D*- --> D0bar,pi-; D0bar --> K-,pi+,Kshort candidates;
## Ignoring CPV in K0 and K0bar decays to Kshort, these are CP
## conjugate decays.
##
## Note that the code reuses the D02KsKPi_XX inputs where
## D0 --> Ks,K-,pi+ and D0bar --> Ks,K+,pi-. To allow this reuse,
## with the charge assignments wanted here, the descriptors say that
## the D*+ decays to D0bar,pi+ and the D*- decays to D0,pi-.
## This is OK because the descriptor is not encoded in the candidate
## beyond Hlt.
Dstp2D0Pip_D02KS0KpPim_KS0LL = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D~0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[Filtered_D02KsKPi_LL, SharedSoftTagChild_pi])
Dstp2D0Pip_D02KS0KpPim_KS0DD = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D~0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[Filtered_D02KsKPi_DD, SharedSoftTagChild_pi])
Dstp2D0Pip_D02KS0KmKp_KS0LL = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[Filtered_D02KsKK_LL, SharedSoftTagChild_pi])
Dstp2D0Pip_D02KS0KmKp_KS0DD = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[Filtered_D02KsKK_DD, SharedSoftTagChild_pi])
##
## create the LTUNB version of these D* combiners
Dstp2D0Pip_D02KS0PimPip_KS0LL_LTUNB = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[Filtered_D02KsPiPi_LL_LTUNB, SharedSoftTagChild_pi])
Dstp2D0Pip_D02KS0PimPip_KS0DD_LTUNB = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[Filtered_D02KsPiPi_DD_LTUNB, SharedSoftTagChild_pi])
Dstp2D0Pip_D02KS0KmPip_KS0LL_LTUNB = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D~0 pi-"],
inputs=[Filtered_D02KsKPi_LL_LTUNB, SharedSoftTagChild_pi])
Dstp2D0Pip_D02KS0KmPip_KS0DD_LTUNB = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D~0 pi-"],
inputs=[Filtered_D02KsKPi_DD_LTUNB, SharedSoftTagChild_pi])
Dstp2D0Pip_D02KS0KpPim_KS0LL_LTUNB = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D~0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[Filtered_D02KsKPi_LL_LTUNB, SharedSoftTagChild_pi])
Dstp2D0Pip_D02KS0KpPim_KS0DD_LTUNB = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D~0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[Filtered_D02KsKPi_DD_LTUNB, SharedSoftTagChild_pi])
Dstp2D0Pip_D02KS0KmKp_KS0LL_LTUNB = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[Filtered_D02KsKK_LL_LTUNB, SharedSoftTagChild_pi])
Dstp2D0Pip_D02KS0KmKp_KS0DD_LTUNB = TagDecay(
'Dst2D0pi_D02HHKsh',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[Filtered_D02KsKK_DD_LTUNB, SharedSoftTagChild_pi])
##
## The stages dictionary should be a clear two-column list from
## which the lines defined in this module can be directly read.
## mdsstages = {'D02KS0PimPip_KS0LLTurbo' : [MassFilter('D02KshPiPi_LL',inputs=[D02KsPiPi_LL])],
## mds 'D02KS0PimPip_KS0DDTurbo' : [MassFilter('D02KshPiPi_DD',inputs=[D02KsPiPi_DD])],
## mds 'D02KS0KmPip_KS0LLTurbo' : [MassFilter('D02KshKPi_LL',inputs=[D02KsKPi_LL])],
## mds 'D02KS0KmPip_KS0DDTurbo' : [MassFilter('D02KshKPi_DD',inputs=[D02KsKPi_DD])],
## mds 'D02KS0KmKp_KS0LLTurbo' : [MassFilter('D02KshKK_LL',inputs=[D02KsKK_LL])],
## mds 'D02KS0KmKp_KS0DDTurbo' : [MassFilter('D02KshKK_DD',inputs=[D02KsKK_DD])],
stages = {
'Dstp2D0Pip_D02KS0PimPip_KS0LLTurbo':
[Dstp2D0Pip_D02KS0PimPip_KS0LL],
'Dstp2D0Pip_D02KS0PimPip_KS0DDTurbo':
[Dstp2D0Pip_D02KS0PimPip_KS0DD],
'Dstp2D0Pip_D02KS0KmPip_KS0LLTurbo':
[Dstp2D0Pip_D02KS0KmPip_KS0LL],
'Dstp2D0Pip_D02KS0KmPip_KS0DDTurbo':
[Dstp2D0Pip_D02KS0KmPip_KS0DD],
'Dstp2D0Pip_D02KS0KpPim_KS0LLTurbo':
[Dstp2D0Pip_D02KS0KpPim_KS0LL],
'Dstp2D0Pip_D02KS0KpPim_KS0DDTurbo':
[Dstp2D0Pip_D02KS0KpPim_KS0DD],
'Dstp2D0Pip_D02KS0KmKp_KS0LLTurbo': [Dstp2D0Pip_D02KS0KmKp_KS0LL],
'Dstp2D0Pip_D02KS0KmKp_KS0DDTurbo': [Dstp2D0Pip_D02KS0KmKp_KS0DD],
## and the corresponding LTUNB line
'Dstp2D0Pip_D02KS0PimPip_KS0LL_LTUNBTurbo':
[Dstp2D0Pip_D02KS0PimPip_KS0LL_LTUNB],
'Dstp2D0Pip_D02KS0PimPip_KS0DD_LTUNBTurbo':
[Dstp2D0Pip_D02KS0PimPip_KS0DD_LTUNB],
'Dstp2D0Pip_D02KS0KmPip_KS0LL_LTUNBTurbo':
[Dstp2D0Pip_D02KS0KmPip_KS0LL_LTUNB],
'Dstp2D0Pip_D02KS0KmPip_KS0DD_LTUNBTurbo':
[Dstp2D0Pip_D02KS0KmPip_KS0DD_LTUNB],
'Dstp2D0Pip_D02KS0KpPim_KS0LL_LTUNBTurbo':
[Dstp2D0Pip_D02KS0KpPim_KS0LL_LTUNB],
'Dstp2D0Pip_D02KS0KpPim_KS0DD_LTUNBTurbo':
[Dstp2D0Pip_D02KS0KpPim_KS0DD_LTUNB],
'Dstp2D0Pip_D02KS0KmKp_KS0LL_LTUNBTurbo': [
Dstp2D0Pip_D02KS0KmKp_KS0LL_LTUNB
],
'Dstp2D0Pip_D02KS0KmKp_KS0DD_LTUNBTurbo': [
Dstp2D0Pip_D02KS0KmKp_KS0DD_LTUNB
]
}
return stages