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 SharedDetachedD0ToHHHHChild_pi, SharedDetachedD0ToHHHHChild_K, SharedSoftTagChild_pi
from Stages import D02HHHH_D02PiPiPiPi, D02HHHH_D02KPiPiPi
from Stages import D02HHHH_D02KKPiPi, D02HHHH_D02KKKPi
from Stages import D02HHHHMass_D02PiPiPiPi, D02HHHHMass_D02KPiPiPi
from Stages import D02HHHHMass_D02KKPiPi, D02HHHHMass_D02KKKPi
from Stages import DstToD02HHHH_D02CFKPiPiPi
from Stages import DV4BCombiner, TagDecay
from Stages import SharedSoftTagChild_mu
## D*+ -> D0 pi+ reconstruction on D0 with wide mass windows
DstToD02HHHH_D02PiPiPiPiWideTag = TagDecay(
'DstpComb',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[D02HHHH_D02PiPiPiPi, SharedSoftTagChild_pi],
nickname='DstToD02HHHH')
DstToD02HHHH_D02KKPiPiWideTag = DstToD02HHHH_D02PiPiPiPiWideTag.clone(
'DstpComb', inputs=[D02HHHH_D02KKPiPi, SharedSoftTagChild_pi])
DstToD02HHHH_D02CFKPiPiPiWideTag = TagDecay(
'DstpComb',
decay=["[D*(2010)+ -> D0 pi+]cc"],
inputs=[D02HHHH_D02KPiPiPi, SharedSoftTagChild_pi],
nickname='DstToD02HHHH')
DstToD02HHHH_D02DCSKPiPiPiWideTag = DstToD02HHHH_D02CFKPiPiPiWideTag.clone(
'DstpComb', decay=["[D*(2010)- -> D0 pi-]cc"])
DstToD02HHHH_D02CFKKKPiWideTag = DstToD02HHHH_D02CFKPiPiPiWideTag.clone(
'DstpComb', inputs=[D02HHHH_D02KKKPi, SharedSoftTagChild_pi])
DstToD02HHHH_D02DCSKKKPiWideTag = DstToD02HHHH_D02CFKKKPiWideTag.clone(
'DstpComb', decay=["[D*(2010)- -> D0 pi-]cc"])
## D*+ -> D0 pi+ reconstruction
## The combiner for the Cabibbo-favored D*+ -> D0(K- pi- pi+ pi+) pi+
## is shared with a spectroscopy line in CharmSpectroscopyLines.py.
## Its definition is moved to Stages.py for sharing.
DstToD02HHHH_D02PiPiPiPiTag = TagDecay(
'DstpComb',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[D02HHHHMass_D02PiPiPiPi, SharedSoftTagChild_pi],
nickname='DstToD02HHHH')
DstToD02HHHH_D02KKPiPiTag = DstToD02HHHH_D02PiPiPiPiTag.clone(
'DstpComb', inputs=[D02HHHHMass_D02KKPiPi, SharedSoftTagChild_pi])
DstToD02HHHH_D02DCSKPiPiPiTag = TagDecay(
'DstpComb',
decay=["[D*(2010)- -> D0 pi-]cc"],
inputs=[D02HHHHMass_D02KPiPiPi, SharedSoftTagChild_pi],
nickname='DstToD02HHHH')
DstToD02HHHH_D02CFKKKPiTag = TagDecay(
'DstpComb',
decay=["[D*(2010)+ -> D0 pi+]cc"],
inputs=[D02HHHHMass_D02KKKPi, SharedSoftTagChild_pi],
nickname='DstToD02HHHH')
DstToD02HHHH_D02DCSKKKPiTag = DstToD02HHHH_D02CFKKKPiTag.clone(
'DstpComb', decay=["[D*(2010)- -> D0 pi-]cc"])
## Add muon-tagged versions of the D*+/- lines following the form used
## for MuTag_DstpMu_Dstp2D0Pip_D02KpPim in D02HHLines.py [150825, mds]
MuTag_Dstp_D02PimPimPipPip = TagDecay(
'DSTP_HHHH_MUTAG_CPV',
["[B0 -> D*(2010)+ mu-]cc", "[Delta(1905)++ -> D*(2010)+ mu+]cc"],
inputs=[DstToD02HHHH_D02PiPiPiPiTag, SharedSoftTagChild_mu],
ReFitPVs=True)
MuTag_Dstp_D02KmKpPimPip = TagDecay(
'DSTP_HHHH_MUTAG_CPV',
["[B0 -> D*(2010)+ mu-]cc", "[Delta(1905)++ -> D*(2010)+ mu+]cc"],
inputs=[DstToD02HHHH_D02KKPiPiTag, SharedSoftTagChild_mu],
ReFitPVs=True)
MuTag_Dstp_D02KmPimPipPip = TagDecay(
'DSTP_HHHH_MUTAG_CPV',
["[B0 -> D*(2010)+ mu-]cc", "[Delta(1905)++ -> D*(2010)+ mu+]cc"],
inputs=[DstToD02HHHH_D02CFKPiPiPi, SharedSoftTagChild_mu],
ReFitPVs=True)
MuTag_Dstp_D02KpPimPimPip = TagDecay(
'DSTP_HHHH_MUTAG_CPV',
["[B0 -> D*(2010)+ mu-]cc", "[Delta(1905)++ -> D*(2010)+ mu+]cc"],
inputs=[DstToD02HHHH_D02DCSKPiPiPiTag, SharedSoftTagChild_mu],
ReFitPVs=True)
MuTag_Dstp_D02KmKmKpPip = TagDecay(
'DSTP_HHHH_MUTAG_CPV',
["[B0 -> D*(2010)+ mu-]cc", "[Delta(1905)++ -> D*(2010)+ mu+]cc"],
inputs=[DstToD02HHHH_D02CFKKKPiTag, SharedSoftTagChild_mu],
ReFitPVs=True)
MuTag_Dstp_D02KmKpKpPim = TagDecay(
'DSTP_HHHH_MUTAG_CPV',
["[B0 -> D*(2010)+ mu-]cc", "[Delta(1905)++ -> D*(2010)+ mu+]cc"],
inputs=[DstToD02HHHH_D02DCSKKKPiTag, SharedSoftTagChild_mu],
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 = {}
# Create the nominal and wide mass combinations
stages = {
## Main lines (nominal mass window)
'D02PimPimPipPipTurbo': [D02HHHHMass_D02PiPiPiPi],
'D02KmPimPipPipTurbo': [D02HHHHMass_D02KPiPiPi],
'D02KmKpPimPipTurbo': [D02HHHHMass_D02KKPiPi],
'D02KmKmKpPipTurbo': [D02HHHHMass_D02KKKPi],
'Dstp2D0Pip_D02PimPimPipPipTurbo': [DstToD02HHHH_D02PiPiPiPiTag],
'Dstp2D0Pip_D02KmKpPimPipTurbo': [DstToD02HHHH_D02KKPiPiTag],
'Dstp2D0Pip_D02KmPimPipPipTurbo': [DstToD02HHHH_D02CFKPiPiPi],
'Dstp2D0Pip_D02KpPimPimPipTurbo': [DstToD02HHHH_D02DCSKPiPiPiTag],
'Dstp2D0Pip_D02KmKmKpPipTurbo': [DstToD02HHHH_D02CFKKKPiTag],
'Dstp2D0Pip_D02KmKpKpPimTurbo': [DstToD02HHHH_D02DCSKKKPiTag],
'MuTag_Dstp_D02PimPimPipPipTurbo': [MuTag_Dstp_D02PimPimPipPip],
'MuTag_Dstp_D02KmKpPimPipTurbo': [MuTag_Dstp_D02KmKpPimPip],
'MuTag_Dstp_D02KmPimPipPipTurbo': [MuTag_Dstp_D02KmPimPipPip],
'MuTag_Dstp_D02KpPimPimPipTurbo': [MuTag_Dstp_D02KpPimPimPip],
'MuTag_Dstp_D02KmKmKpPipTurbo': [MuTag_Dstp_D02KmKmKpPip],
'MuTag_Dstp_D02KmKpKpPimTurbo': [MuTag_Dstp_D02KmKpKpPim]
## Wide mass lines (plan for obsolescence)
,
'D02PimPimPipPip_WideTurbo': [D02HHHH_D02PiPiPiPi],
'D02KmPimPipPip_WideTurbo': [D02HHHH_D02KPiPiPi],
'D02KmKpPimPip_WideTurbo': [D02HHHH_D02KKPiPi],
'D02KmKmKpPip_WideTurbo': [D02HHHH_D02KKKPi],
'Dstp2D0Pip_D02PimPimPipPip_WideTurbo':
[DstToD02HHHH_D02PiPiPiPiWideTag],
'Dstp2D0Pip_D02KmKpPimPip_WideTurbo':
[DstToD02HHHH_D02KKPiPiWideTag],
'Dstp2D0Pip_D02KmPimPipPip_WideTurbo':
[DstToD02HHHH_D02CFKPiPiPiWideTag],
'Dstp2D0Pip_D02KpPimPimPip_WideTurbo':
[DstToD02HHHH_D02DCSKPiPiPiWideTag],
'Dstp2D0Pip_D02KmKmKpPip_WideTurbo':
[DstToD02HHHH_D02CFKKKPiWideTag],
'Dstp2D0Pip_D02KmKpKpPim_WideTurbo':
[DstToD02HHHH_D02DCSKKKPiWideTag]
}
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 stages(self): # {
## Define the sets of stages for the lines.
## NOTE!!! This method should only be called from within the
## __apply_configuration__() method of a class that inherits from
## Hlt2LinesConfigurableUser.
## I would much prefer that this is done in the class constructor.
## However, the import from Stages will not work outside of the
## __apply_configuration__ method of the Hlt2LinesConfigurableUser
## that uses these lines.
if len(self.__stages) == 0: # {
from Stages import D02HH_D0ToKmPip, D02HH_D0ToKmKp, D02HH_D0ToPimPip
from Stages import D02HH_D0ToKmPip_LTUNB, D02HH_D0ToKmKp_LTUNB, D02HH_D0ToPimPip_LTUNB
from Stages import D0_TAG_CPV_Dstp2D0Pip_D02KmPip
from Stages import TagDecay, SharedSoftTagChild_pi, SharedSoftTagChild_mu
## Create D*+ -> D0 pi+
## I (P.S.) want to make this very easy to trace, but some
## automation would help to ensure consistency. Need to
## consider better patterns. For now, i have gone with making
## it as clear as possible.
## Hmm, having several MassFilter with the same name seems strange,
## but the automatic name mangling does something sensible since
## these are not shared instances.
## <grumble, grumble, inscrutable obfuscated wrapper nonsense>
## D0 -> K pi reconstructed as "[D0 -> K- pi+]cc
## D0_TAG_CPV_Dstp2D0Pip_D02KmPip is a shared instance defined in
## Stages.py because it is also used in CharmSpectroscopyLines.py
Dstp2D0Pip_D02KpPim = TagDecay(
'CharmHadDstp2D0Pip_D02KpPim', ["[D*(2010)- -> D0 pi-]cc"],
inputs=[D02HH_D0ToKmPip, SharedSoftTagChild_pi],
shared=True,
nickname='D0_TAG_CPV',
ReFitPVs=True)
## Self-conjugate final state reconstructed only as D0
Dstp2D0Pip_D02KmKp = TagDecay(
'CharmHadDstp2D0Pip_D02KmKp',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[D02HH_D0ToKmKp, SharedSoftTagChild_pi],
shared=True,
nickname='D0_TAG_CPV',
ReFitPVs=True)
Dstp2D0Pip_D02PimPip = TagDecay(
'CharmHadDstp2D0Pip_D02PimPip',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[D02HH_D0ToPimPip, SharedSoftTagChild_pi],
shared=True,
nickname='D0_TAG_CPV',
ReFitPVs=True)
## Muon tagged lines
MuTag_DstpMu_Dstp2D0Pip_D02KpPim = TagDecay(
'DSTP_MUTAG_CPV',
["[B0 -> D*(2010)- mu+]cc", "[B0 -> D*(2010)- mu-]cc"],
inputs=[Dstp2D0Pip_D02KpPim, SharedSoftTagChild_mu],
ReFitPVs=True)
MuTag_DstpMu_Dstp2D0Pip_D02KmPip = TagDecay(
'DSTP_MUTAG_CPV',
["[B0 -> D*(2010)- mu+]cc", "[B0 -> D*(2010)- mu-]cc"],
inputs=[D0_TAG_CPV_Dstp2D0Pip_D02KmPip, SharedSoftTagChild_mu],
ReFitPVs=True)
MuTag_DstpMu_Dstp2D0Pip_D02KmKp = TagDecay(
'DSTP_MUTAG_CPV',
decay=["[B0 -> D*(2010)- mu+]cc", "[B0 -> D*(2010)- mu-]cc"],
inputs=[Dstp2D0Pip_D02KmKp, SharedSoftTagChild_mu],
ReFitPVs=True)
MuTag_DstpMu_Dstp2D0Pip_D02PimPip = TagDecay(
'DSTP_MUTAG_CPV',
decay=["[B0 -> D*(2010)- mu+]cc", "[B0 -> D*(2010)- mu-]cc"],
inputs=[Dstp2D0Pip_D02PimPip, SharedSoftTagChild_mu],
ReFitPVs=True)
## For decay-time-PDF unbiased D0s.
Dstp2D0Pip_D02KmPip_LTUNB = TagDecay(
'D0_TAG_CPV', ["[D*(2010)+ -> D0 pi+]cc"],
inputs=[D02HH_D0ToKmPip_LTUNB, SharedSoftTagChild_pi],
ReFitPVs=True)
Dstp2D0Pip_D02KpPim_LTUNB = TagDecay(
'D0_TAG_CPV', ["[D*(2010)- -> D0 pi-]cc"],
inputs=[D02HH_D0ToKmPip_LTUNB, SharedSoftTagChild_pi],
ReFitPVs=True)
Dstp2D0Pip_D02KmKp_LTUNB = TagDecay(
'D0_TAG_CPV', ["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[D02HH_D0ToKmKp_LTUNB, SharedSoftTagChild_pi],
ReFitPVs=True)
Dstp2D0Pip_D02PimPip_LTUNB = TagDecay(
'D0_TAG_CPV', ["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[D02HH_D0ToPimPip_LTUNB, SharedSoftTagChild_pi],
ReFitPVs=True)
## The stages dictionary should be a clear two-column list from
## which the lines defined in this module can be directly read.
self.__stages = {
'D02KmKpTurbo': [D02HH_D0ToKmKp],
'D02KmPipTurbo': [D02HH_D0ToKmPip],
'D02PimPipTurbo': [D02HH_D0ToPimPip]
## Now add the tagged lines
,
'Dstp2D0Pip_D02KmKpTurbo': [Dstp2D0Pip_D02KmKp],
'Dstp2D0Pip_D02PimPipTurbo': [Dstp2D0Pip_D02PimPip],
'Dstp2D0Pip_D02KmPipTurbo': [D0_TAG_CPV_Dstp2D0Pip_D02KmPip],
'Dstp2D0Pip_D02KpPimTurbo': [Dstp2D0Pip_D02KpPim]
## The muon tagged D* lines
,
'MuTag_DstpMu_Dstp2D0Pip_D02KpPimTurbo':
[MuTag_DstpMu_Dstp2D0Pip_D02KpPim],
'MuTag_DstpMu_Dstp2D0Pip_D02KmPipTurbo':
[MuTag_DstpMu_Dstp2D0Pip_D02KmPip],
'MuTag_DstpMu_Dstp2D0Pip_D02KmKpTurbo':
[MuTag_DstpMu_Dstp2D0Pip_D02KmKp],
'MuTag_DstpMu_Dstp2D0Pip_D02PimPipTurbo':
[MuTag_DstpMu_Dstp2D0Pip_D02PimPip]
## The tagged LTUNB lines
,
'Dstp2D0Pip_D02KmKp_LTUNBTurbo': [Dstp2D0Pip_D02KmKp_LTUNB],
'Dstp2D0Pip_D02PimPip_LTUNBTurbo':
[Dstp2D0Pip_D02PimPip_LTUNB],
'Dstp2D0Pip_D02KmPip_LTUNBTurbo': [Dstp2D0Pip_D02KmPip_LTUNB],
'Dstp2D0Pip_D02KpPim_LTUNBTurbo': [Dstp2D0Pip_D02KpPim_LTUNB]
}
# }
return self.__stages
def locallines(self):
from Stages import AttachParticle, TagDecay
from Stages import SharedNeutralChild_pi0R, SharedNeutralChild_pi0M
from Stages import SharedSoftTagChild_pi
from Stages import D2HHPi0_PiPi, D2HHPi0_KPi, D2HHPi0_KK
D2PiPiPi0R = AttachParticle('D2PiPiPi0R'
, decay = "D0 -> K*(892)0 pi0"
, inputs = [ D2HHPi0_PiPi , SharedNeutralChild_pi0R ]
, nickname = 'D2HHPi0R')
DstD02PiPiPi0R = TagDecay('DstD02PiPiPi0R'
, decay = ["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"]
, inputs = [ D2PiPiPi0R, SharedSoftTagChild_pi]
, nickname = 'DstD02HHPi0R' )
D2PiPiPi0M = AttachParticle('D2PiPiPi0M'
, decay = "D0 -> K*(892)0 pi0"
, inputs = [ D2HHPi0_PiPi , SharedNeutralChild_pi0M ]
, nickname = 'D2HHPi0M')
DstD02PiPiPi0M = TagDecay('DstD02PiPiPi0M'
, decay = ["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"]
, inputs = [D2PiPiPi0M, SharedSoftTagChild_pi]
, nickname = 'DstD02HHPi0M')
D2KKPi0R = AttachParticle('D2KKPi0R'
, decay = "D0 -> K*(892)0 pi0"
, inputs = [ D2HHPi0_KK , SharedNeutralChild_pi0R ]
, nickname = 'D2HHPi0R')
DstD02KKPi0R = TagDecay('DstD02KKPi0R'
, decay = ["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"]
, inputs = [ D2KKPi0R, SharedSoftTagChild_pi]
, nickname = 'DstD02HHPi0R' )
D2KKPi0M = AttachParticle('D2KKPi0M'
, decay = "D0 -> K*(892)0 pi0"
, inputs = [ D2HHPi0_KK, SharedNeutralChild_pi0M ]
, nickname = 'D2HHPi0M')
DstD02KKPi0M = TagDecay('DstD02KKPi0M'
, decay = ["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"]
, inputs = [D2KKPi0M, SharedSoftTagChild_pi]
, nickname = 'DstD02HHPi0M')
D2KPiPi0R = AttachParticle('D2KPiPi0R'
, decay = "[D0 -> K*(892)0 pi0]cc"
, inputs = [ D2HHPi0_KPi , SharedNeutralChild_pi0R ]
, nickname = 'D2HHPi0R')
DstD02KmPipPi0R = TagDecay('DstD02KPiPi0R'
, decay = ["[D*(2010)+ -> D0 pi+]cc"]
, inputs = [ D2KPiPi0R, SharedSoftTagChild_pi]
, nickname = 'DstD02HHPi0R' )
DstD02KpPimPi0R = TagDecay('DstD02KPiPi0R'
, decay = ["[D*(2010)- -> D0 pi-]cc"]
, inputs = [ D2KPiPi0R, SharedSoftTagChild_pi]
, nickname = 'DstD02HHPi0R' )
D2KPiPi0M = AttachParticle('D2KPiPi0M'
, decay = "[D0 -> K*(892)0 pi0]cc"
, inputs = [ D2HHPi0_KPi , SharedNeutralChild_pi0M ]
, nickname = 'D2HHPi0M')
DstD02KmPipPi0M = TagDecay('DstD02KPiPi0M'
, decay = ["[D*(2010)+ -> D0 pi+]cc"]
, inputs = [D2KPiPi0M, SharedSoftTagChild_pi]
, nickname = 'DstD02HHPi0M')
DstD02KpPimPi0M = TagDecay('DstD02KPiPi0M'
, decay = ["[D*(2010)- -> D0 pi-]cc"]
, inputs = [D2KPiPi0M, SharedSoftTagChild_pi]
, nickname = 'DstD02HHPi0M')
## The stages dictionary should be a clear two-column list from
## which the lines defined in this module can be directly read.
stages = {
'Dstp2D0Pip_D02PimPipPi0_Pi0R' : [DstD02PiPiPi0R],
'Dstp2D0Pip_D02PimPipPi0_Pi0M' : [DstD02PiPiPi0M],
'Dstp2D0Pip_D02KmKpPi0_Pi0R' : [DstD02KKPi0R],
'Dstp2D0Pip_D02KmKpPi0_Pi0M' : [DstD02KKPi0M],
'Dstp2D0Pip_D02KmPipPi0_Pi0R' : [DstD02KmPipPi0R],
'Dstp2D0Pip_D02KpPimPi0_Pi0R' : [DstD02KpPimPi0R],
'Dstp2D0Pip_D02KmPipPi0_Pi0M' : [DstD02KmPipPi0M],
'Dstp2D0Pip_D02KpPimPi0_Pi0M' : [DstD02KpPimPi0M],
}
return stages
def locallines(self):
## these are combiners instantiated in Stages.py
## as indicated below, there is a different grammar to access
## candidates passing trigger selections specified in other files
from Stages import D02HH_D0ToKmPip
from Stages import TagDecay, TagDecayWithNeutral
from Stages import SharedSoftTagChild_pi, SharedPromptChild_K, SharedPromptChild_p
from Stages import CharmHadSharedKsLL, CharmHadSharedKsDD
from Stages import CharmHadSharedSecondaryLambdaLL, CharmHadSharedSecondaryLambdaDD
from Stages import D02KsKK_LL, D02KsKK_DD, D02KsPiPi_LL, D02KsPiPi_DD
from Stages import D02KsKPi_LL, D02KsKPi_DD
from Stages import D2HHH_DspToKmKpPip, D2HHH_DpToKmPipPip
from Stages import D0_TAG_CPV_Dstp2D0Pip_D02KmPip
from Stages import DstToD02HHHH_D02CFKPiPiPi
from Stages import D02HHHHMass_D02KPiPiPi
from Stages import SharedNeutralLowPtChild_pi0, SharedNeutralLowPtChild_eta
from Stages import SharedNeutralLowPtChild_gamma
from Stages import PromptBachelorFilter, PromptSpectroscopyFilter
from Stages import SharedTighterPromptChild_p
from Stages import SharedSoftTagChild_pi
##
## these come from D02HHHHLines.py
D02KPiPiPiForSpectroscopy = PromptSpectroscopyFilter(
'D02KPiPiPiSpec', inputs=[D02HHHHMass_D02KPiPiPi], shared=True)
from Stages import Lc2HHH_LcpToKmPpPip
from Hlt2Lines.Utilities.Hlt2Stage import Hlt2ExternalStage
from Hlt2Lines.DPS.Stages import MergeCharm
## change from MergedD0 to separate trigger lines as D0 --> K,pi and
## D0 --> K,pi,pi,pi have very different S:B circa July 15, 2015
## mds d0 = MergeCharm('MergedD0', inputs = [D02HH_D0ToKmPip, D02KsKK_LL, D02KsKK_DD,
## mds D02KsPiPi_LL, D02KsPiPi_DD,
## mds D02KsKPi_LL, D02KsKPi_DD,
## mds D02KPiPiPiForSpectroscopy
## mds ])
## dstar = MergeCharm('MergedDstar', inputs = [D0_TAG_CPV_Dstp2D0Pip_D02KmPip, DstToD02HHHH_D02CFKPiPiPi])
## dstar = MergeCharm('MergedDstar', inputs = [D0_TAG_CPV_Dstp2D0Pip_D02KmPip])
dstarKPi = D0_TAG_CPV_Dstp2D0Pip_D02KmPip
dstarK3Pi = TagDecay(
'Dst2D0pi_D02KPiPiPi',
decay=["[D*(2010)+ -> D0 pi+]cc"],
inputs=[D02KPiPiPiForSpectroscopy, SharedSoftTagChild_pi])
##
##
## start by filtering the standard "prompt" track lists to add IPChi2 cuts
##
## shared instances should usually be defined in Stages.py.
## Consider moving them there.
BachelorPi = PromptBachelorFilter(
'CharmHadBachelorPi',
inputs=[SharedSoftTagChild_pi],
nickname='ChargedSpectroscopyBachelors',
shared=True)
BachelorK = PromptBachelorFilter(
'CharmHadBachelorK',
inputs=[SharedPromptChild_K],
nickname='ChargedSpectroscopyBachelors',
shared=True)
BachelorPr = PromptBachelorFilter(
'CharmHadBachelorPr',
inputs=[SharedTighterPromptChild_p],
nickname='ChargedSpectroscopyBachelors',
shared=True)
## LcpForSpectroscopy is meant to be used as input for spectroscopy studies. It has
## a tighter set of selections on decay time, on IPChi2 (nonexistent for
## default CPV lines), and (potentially) Lambda_c mass to create candidates for spectroscopy studies
## It should be sent to *neither* Full or Turbo.
## shared instances should usually be defined in Stages.py.
## Consider moving them there.
LcpForSpectroscopy = PromptSpectroscopyFilter(
'LcForSpec',
nickname='LcSpec',
inputs=[Lc2HHH_LcpToKmPpPip],
shared=True)
stages = {}
## recall that the "nicknake" in TagDecay is the "name" used in the dictionary of cuts.
##
##
stages.update({
'Spec_D0ToKPi_PiTurbo': [
TagDecay('Spec_D0Pi',
decay=[
"[D*(2010)+ -> D0 pi+]cc",
"[D*(2010)- -> D0 pi-]cc"
],
nickname='Spec_D0Pi',
inputs=[D02HH_D0ToKmPip, BachelorPi])
],
'Spec_D0ToKPi_KsTurbo': [
TagDecay('Spec_D0Ks',
decay=["[D*(2007)0 -> D0 KS0]cc"],
nickname='Spec_DK',
inputs=[
D02HH_D0ToKmPip, CharmHadSharedKsLL,
CharmHadSharedKsDD
])
],
'Spec_D0ToKPi_KpmTurbo': [
TagDecay(
'Spec_D0K',
decay=["[D*(2010)+ -> D0 K+]cc", "[D*(2010)- -> D0 K-]cc"],
nickname='Spec_DK',
inputs=[D02HH_D0ToKmPip, BachelorK])
],
'Spec_D0ToKPi_PrTurbo': [
TagDecay('Spec_D0Pr',
decay=[
"[D*(2010)+ -> D0 p+]cc",
"[D*(2010)- -> D0 p~-]cc"
],
nickname='Spec_DPr',
inputs=[D02HH_D0ToKmPip, BachelorPr])
],
'Spec_D0ToKPi_LambdaTurbo': [
TagDecay('Spec_D0Lambda',
decay=[
"[D*(2007)0 -> D0 Lambda0]cc",
"[D*(2007)0 -> D~0 Lambda0]cc"
],
nickname='Spec_DLambda',
inputs=[
D02HH_D0ToKmPip, CharmHadSharedSecondaryLambdaLL,
CharmHadSharedSecondaryLambdaDD
])
],
'Spec_D0ToKPi_Pi0Turbo': [
TagDecayWithNeutral(
'Spec_D0Pi0',
decay=["[D*(2007)0 -> D0 pi0]cc"],
nickname='Spec_DPi',
inputs=[D02HH_D0ToKmPip, SharedNeutralLowPtChild_pi0])
],
'Spec_D0ToKPi_EtaTurbo': [
TagDecayWithNeutral(
'Spec_D0Eta',
decay=["[D*(2007)0 -> D0 eta]cc"],
nickname='Spec_DEta',
inputs=[D02HH_D0ToKmPip, SharedNeutralLowPtChild_eta])
],
'Spec_D0ToKPi_GammaTurbo': [
TagDecayWithNeutral(
'Spec_D0Gamma',
decay=["[D*(2007)0 -> D0 gamma]cc"],
nickname='Spec_DGamma',
inputs=[D02HH_D0ToKmPip, SharedNeutralLowPtChild_gamma])
],
'Spec_D0ToK3Pi_PiTurbo': [
TagDecay('Spec_D0Pi',
decay=[
"[D*(2010)+ -> D0 pi+]cc",
"[D*(2010)- -> D0 pi-]cc"
],
nickname='Spec_D0Pi',
inputs=[D02KPiPiPiForSpectroscopy, BachelorPi])
],
'Spec_D0ToK3Pi_KsTurbo': [
TagDecay('Spec_D0Ks',
decay=["[D*(2007)0 -> D0 KS0]cc"],
nickname='Spec_DK',
inputs=[
D02KPiPiPiForSpectroscopy, CharmHadSharedKsLL,
CharmHadSharedKsDD
])
],
'Spec_D0ToK3Pi_KpmTurbo': [
TagDecay(
'Spec_D0K',
decay=["[D*(2010)+ -> D0 K+]cc", "[D*(2010)- -> D0 K-]cc"],
nickname='Spec_DK',
inputs=[D02KPiPiPiForSpectroscopy, BachelorK])
],
'Spec_D0ToK3Pi_PrTurbo': [
TagDecay('Spec_D0Pr',
decay=[
"[D*(2010)+ -> D0 p+]cc",
"[D*(2010)- -> D0 p~-]cc"
],
nickname='Spec_DPr',
inputs=[D02KPiPiPiForSpectroscopy, BachelorPr])
],
'Spec_D0ToK3Pi_LambdaTurbo': [
TagDecay('Spec_D0Lambda',
decay=[
"[D*(2007)0 -> D0 Lambda0]cc",
"[D*(2007)0 -> D~0 Lambda0]cc"
],
nickname='Spec_DLambda',
inputs=[
D02KPiPiPiForSpectroscopy,
CharmHadSharedSecondaryLambdaLL,
CharmHadSharedSecondaryLambdaDD
])
],
'Spec_D0ToK3Pi_Pi0Turbo': [
TagDecayWithNeutral('Spec_D0Pi0',
decay=["[D*(2007)0 -> D0 pi0]cc"],
nickname='Spec_DPi',
inputs=[
D02KPiPiPiForSpectroscopy,
SharedNeutralLowPtChild_pi0
])
],
'Spec_D0ToK3Pi_EtaTurbo': [
TagDecayWithNeutral('Spec_D0Eta',
decay=["[D*(2007)0 -> D0 eta]cc"],
nickname='Spec_DEta',
inputs=[
D02KPiPiPiForSpectroscopy,
SharedNeutralLowPtChild_eta
])
],
'Spec_D0ToK3Pi_GammaTurbo': [
TagDecayWithNeutral('Spec_D0Gamma',
decay=["[D*(2007)0 -> D0 gamma]cc"],
nickname='Spec_DGamma',
inputs=[
D02KPiPiPiForSpectroscopy,
SharedNeutralLowPtChild_gamma
])
],
'Spec_DsPiTurbo': [
TagDecay('Spec_D0Pi',
decay=[
"[Delta(1905)++ -> D_s+ pi+]cc",
"[D*(2007)0 -> D_s+ pi-]cc"
],
nickname='Spec_DPi',
inputs=[D2HHH_DspToKmKpPip, BachelorPi])
],
'Spec_DsKsTurbo': [
TagDecay('Spec_D0K',
decay=["[D*(2010)+ -> D_s+ KS0]cc"],
nickname='Spec_DK',
inputs=[
D2HHH_DspToKmKpPip, CharmHadSharedKsLL,
CharmHadSharedKsDD
])
],
'Spec_DsKpmTurbo': [
TagDecay('Spec_D0K',
decay=[
"[Delta(1905)++ -> D_s+ K+]cc",
"[D*(2007)0 -> D_s+ K-]cc"
],
nickname='Spec_DK',
inputs=[D2HHH_DspToKmKpPip, BachelorK])
],
'Spec_DsPrTurbo': [
TagDecay('Spec_D0Pr',
decay=[
"[Delta(1905)++ -> D_s+ p+]cc",
"[D*(2007)0 -> D_s+ p~-]cc"
],
nickname='Spec_DPr',
inputs=[D2HHH_DspToKmKpPip, BachelorPr])
],
'Spec_DsLambdaTurbo': [
TagDecay('Spec_D0Lambda',
decay=[
"[D*(2010)+ -> D_s+ Lambda0]cc",
"[D*(2010)- -> D_s- Lambda0]cc"
],
nickname='Spec_DLambda',
inputs=[
D2HHH_DspToKmKpPip,
CharmHadSharedSecondaryLambdaLL,
CharmHadSharedSecondaryLambdaDD
])
],
'Spec_DsPi0Turbo': [
TagDecayWithNeutral(
'Spec_DsPi0',
decay=["[D*(2010)+ -> D_s+ pi0]cc"],
nickname='Spec_DPi',
inputs=[D2HHH_DspToKmKpPip, SharedNeutralLowPtChild_pi0])
],
'Spec_DsEtaTurbo': [
TagDecayWithNeutral(
'Spec_DsEta',
decay=["[D*(2010)+ -> D_s+ eta]cc"],
nickname='Spec_DEta',
inputs=[D2HHH_DspToKmKpPip, SharedNeutralLowPtChild_eta])
],
'Spec_DsGammaTurbo': [
TagDecayWithNeutral(
'Spec_DsGamma',
decay=["[D*(2010)+ -> D_s+ gamma]cc"],
nickname='Spec_DGamma',
inputs=[D2HHH_DspToKmKpPip, SharedNeutralLowPtChild_gamma])
],
'Spec_DpPiTurbo': [
TagDecay('Spec_DpPi',
decay=[
"[Delta(1905)++ -> D+ pi+]cc",
"[D*(2007)0 -> D+ pi-]cc"
],
nickname='Spec_DpmPi',
inputs=[D2HHH_DpToKmPipPip, BachelorPi])
],
'Spec_DpKsTurbo': [
TagDecay('Spec_DpK',
decay=["[D*(2010)+ -> D+ KS0]cc"],
nickname='Spec_DK',
inputs=[
D2HHH_DpToKmPipPip, CharmHadSharedKsLL,
CharmHadSharedKsDD
])
],
'Spec_DpKpmTurbo': [
TagDecay('Spec_DpK',
decay=[
"[Delta(1905)++ -> D+ K+]cc",
"[D*(2007)0 -> D+ K-]cc"
],
nickname='Spec_DK',
inputs=[D2HHH_DpToKmPipPip, BachelorK])
],
'Spec_DpPrTurbo': [
TagDecay('Spec_DpPr',
decay=[
"[Delta(1905)++ -> D+ p+]cc",
"[D*(2007)0 -> D+ p~-]cc"
],
nickname='Spec_DPr',
inputs=[D2HHH_DpToKmPipPip, BachelorPr])
],
'Spec_DpLambdaTurbo': [
TagDecay('Spec_DpLambda',
decay=[
"[D*(2010)+ -> D+ Lambda0]cc",
"[D*(2010)- -> D- Lambda0]cc"
],
nickname='Spec_DLambda',
inputs=[
D2HHH_DpToKmPipPip,
CharmHadSharedSecondaryLambdaLL,
CharmHadSharedSecondaryLambdaDD
])
],
'Spec_DpPi0Turbo': [
TagDecayWithNeutral(
'Spec_DpPi0',
decay=["[D*(2010)+ -> D+ pi0]cc"],
nickname='Spec_DPi',
inputs=[D2HHH_DpToKmPipPip, SharedNeutralLowPtChild_pi0])
],
'Spec_DpEtaTurbo': [
TagDecayWithNeutral(
'Spec_DpEta',
decay=["[D*(2010)+ -> D+ eta]cc"],
nickname='Spec_DEta',
inputs=[D2HHH_DpToKmPipPip, SharedNeutralLowPtChild_eta])
],
'Spec_DpGammaTurbo': [
TagDecayWithNeutral(
'Spec_DpGamma',
decay=["[D*(2010)+ -> D+ gamma]cc"],
nickname='Spec_DGamma',
inputs=[D2HHH_DpToKmPipPip, SharedNeutralLowPtChild_gamma])
],
'Spec_LcPiTurbo': [
TagDecay('Spec_LcPi',
decay=[
"[Delta(1905)++ -> Lambda_c+ pi+]cc",
"[D*(2007)0 -> Lambda_c+ pi-]cc"
],
nickname='Spec_DPi',
inputs=[LcpForSpectroscopy, BachelorPi])
],
'Spec_LcKsTurbo': [
TagDecay('Spec_LcK',
decay=["[D*(2010)+ -> Lambda_c+ KS0]cc"],
nickname='Spec_DK',
inputs=[
LcpForSpectroscopy, CharmHadSharedKsLL,
CharmHadSharedKsDD
])
],
'Spec_LcKpmTurbo': [
TagDecay('Spec_LcK',
decay=[
"[Delta(1905)++ -> Lambda_c+ K+]cc",
"[D*(2007)0 -> Lambda_c+ K-]cc"
],
nickname='Spec_DK',
inputs=[LcpForSpectroscopy, BachelorK])
],
'Spec_LcPrTurbo': [
TagDecay('Spec_LcPr',
decay=[
"[Delta(1905)++ -> Lambda_c+ p+]cc",
"[D*(2007)0 -> Lambda_c+ p~-]cc"
],
nickname='Spec_DPr',
inputs=[LcpForSpectroscopy, BachelorPr])
],
'Spec_LcLambdaTurbo': [
TagDecay('Spec_LcLambda',
decay=[
"[D*(2010)+ -> Lambda_c+ Lambda0]cc",
"[D*(2010)- -> Lambda_c~- Lambda0]cc"
],
nickname='Spec_DLambda',
inputs=[
LcpForSpectroscopy,
CharmHadSharedSecondaryLambdaLL,
CharmHadSharedSecondaryLambdaDD
])
],
'Spec_LcPi0Turbo': [
TagDecayWithNeutral(
'Spec_LcPi0',
decay=["[D*(2010)+ -> Lambda_c+ pi0]cc"],
nickname='Spec_DPi',
inputs=[LcpForSpectroscopy, SharedNeutralLowPtChild_pi0])
],
'Spec_LcEtaTurbo': [
TagDecayWithNeutral(
'Spec_LcEta',
decay=["[D*(2010)+ -> Lambda_c+ eta]cc"],
nickname='Spec_DEta',
inputs=[LcpForSpectroscopy, SharedNeutralLowPtChild_eta])
],
'Spec_LcGammaTurbo': [
TagDecayWithNeutral(
'Spec_LcGamma',
decay=["[D*(2010)+ -> Lambda_c+ gamma]cc"],
nickname='Spec_DGamma',
inputs=[LcpForSpectroscopy, SharedNeutralLowPtChild_gamma])
],
'Spec_Dst_KPi_PiTurbo': [
TagDecay('Spec_D0Pi',
decay=[
"[Delta(1905)++ -> D*(2010)+ pi+]cc",
"[D*(2007)0 -> D*(2010)+ pi-]cc"
],
nickname='Spec_DPi',
inputs=[dstarKPi, BachelorPi])
],
'Spec_Dst_KPi_KsTurbo': [
TagDecay(
'Spec_D0K',
decay=["[Delta(1905)~+ -> D*(2010)+ KS0]cc"],
nickname='Spec_DK',
inputs=[dstarKPi, CharmHadSharedKsLL, CharmHadSharedKsDD])
],
'Spec_Dst_KPi_KpmTurbo': [
TagDecay('Spec_D0K',
decay=[
"[Delta(1905)++ -> D*(2010)+ K+]cc",
"[D*(2007)0 -> D*(2010)+ K-]cc"
],
nickname='Spec_DK',
inputs=[dstarKPi, BachelorK])
],
'Spec_Dst_KPi_PrTurbo': [
TagDecay('Spec_D0Pr',
decay=[
"[Delta(1905)++ -> D*(2010)+ p+]cc",
"[D*(2007)0 -> D*(2010)+ p~-]cc"
],
nickname='Spec_DPr',
inputs=[dstarKPi, BachelorPr])
],
'Spec_Dst_KPi_LambdaTurbo': [
TagDecay('Spec_D0Lambda',
decay=[
"[Delta(1905)~+ -> D*(2010)+ Lambda0]cc",
"[D*(2010)- -> D*(2010)- Lambda0]cc"
],
nickname='Spec_DLambda',
inputs=[
dstarKPi, CharmHadSharedSecondaryLambdaLL,
CharmHadSharedSecondaryLambdaDD
])
],
'Spec_Dst_KPi_Pi0Turbo': [
TagDecayWithNeutral(
'Spec_DstPi0',
decay=["[Delta(1905)~+ -> D*(2010)+ pi0]cc"],
nickname='Spec_DPi',
inputs=[dstarKPi, SharedNeutralLowPtChild_pi0])
],
'Spec_Dst_KPi_EtaTurbo': [
TagDecayWithNeutral(
'Spec_DstEta',
decay=["[Delta(1905)~+ -> D*(2010)+ eta]cc"],
nickname='Spec_DEta',
inputs=[dstarKPi, SharedNeutralLowPtChild_eta])
],
'Spec_Dst_KPi_GammaTurbo': [
TagDecayWithNeutral(
'Spec_DstGamma',
decay=["[Delta(1905)~+ -> D*(2010)+ gamma]cc"],
nickname='Spec_DGamma',
inputs=[dstarKPi, SharedNeutralLowPtChild_gamma])
],
'Spec_Dst_K3Pi_PiTurbo': [
TagDecay('Spec_D0Pi',
decay=[
"[Delta(1905)++ -> D*(2010)+ pi+]cc",
"[D*(2007)0 -> D*(2010)+ pi-]cc"
],
nickname='Spec_DPi',
inputs=[dstarK3Pi, BachelorPi])
],
'Spec_Dst_K3Pi_KsTurbo': [
TagDecay(
'Spec_D0K',
decay=["[Delta(1905)~+ -> D*(2010)+ KS0]cc"],
nickname='Spec_DK',
inputs=[dstarK3Pi, CharmHadSharedKsLL, CharmHadSharedKsDD])
],
'Spec_Dst_K3Pi_KpmTurbo': [
TagDecay('Spec_D0K',
decay=[
"[Delta(1905)++ -> D*(2010)+ K+]cc",
"[D*(2007)0 -> D*(2010)+ K-]cc"
],
nickname='Spec_DK',
inputs=[dstarK3Pi, BachelorK])
],
'Spec_Dst_K3Pi_PrTurbo': [
TagDecay('Spec_D0Pr',
decay=[
"[Delta(1905)++ -> D*(2010)+ p+]cc",
"[D*(2007)0 -> D*(2010)+ p~-]cc"
],
nickname='Spec_DPr',
inputs=[dstarK3Pi, BachelorPr])
],
'Spec_Dst_K3Pi_LambdaTurbo': [
TagDecay('Spec_D0Lambda',
decay=[
"[Delta(1905)~+ -> D*(2010)+ Lambda0]cc",
"[D*(2010)- -> D*(2010)- Lambda0]cc"
],
nickname='Spec_DLambda',
inputs=[
dstarK3Pi, CharmHadSharedSecondaryLambdaLL,
CharmHadSharedSecondaryLambdaDD
])
],
'Spec_Dst_K3Pi_Pi0Turbo': [
TagDecayWithNeutral(
'Spec_DstPi0',
decay=["[Delta(1905)~+ -> D*(2010)+ pi0]cc"],
nickname='Spec_DPi',
inputs=[dstarK3Pi, SharedNeutralLowPtChild_pi0])
],
'Spec_Dst_K3Pi_EtaTurbo': [
TagDecayWithNeutral(
'Spec_DstEta',
decay=["[Delta(1905)~+ -> D*(2010)+ eta]cc"],
nickname='Spec_DEta',
inputs=[dstarK3Pi, SharedNeutralLowPtChild_eta])
],
'Spec_Dst_K3Pi_GammaTurbo': [
TagDecayWithNeutral(
'Spec_DstGamma',
decay=["[Delta(1905)~+ -> D*(2010)+ gamma]cc"],
nickname='Spec_DGamma',
inputs=[dstarK3Pi, SharedNeutralLowPtChild_gamma])
],
})
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
def locallines(self):
from Stages import MassFilter
from Stages import D2HH0_3Body_Combiner
from Stages import TagDecay, TagDecayWithNeutral
from Stages import D0_gg_NeutralCombiner, D02_ee_Combiner
from Stages import D2RhoHG_3Body_Combiner
from Stages import D2HH_RhoToPipPim
from Stages import SharedNoPIDDetachedChild_pi
from Stages import SharedNoPIDDetachedChild_K
from Stages import SharedNeutralLowPtChild_gamma
from Stages import SharedNeutralLowPtChild_pi0R
from Stages import SharedNeutralLowPtChild_pi0M
from Stages import SharedNeutralLowPtChild_eta
from Stages import SharedSoftTagChild_pi
from Stages import Conv_Photon_2EmEp
from Inputs import Hlt2NoPIDsPions, Hlt2NoPIDsPhotons, Hlt2NoPIDsKaons
## D+ -> pi+ pi0, pi0 -> (e- e+) gamma. (e- e+) labeled KS0.
D2PiPi0_eegamma = D2HH0_3Body_Combiner(
'Comb',
decay="[D+ -> KS0 gamma pi+]cc",
inputs=[Conv_Photon_2EmEp, Hlt2NoPIDsPhotons, Hlt2NoPIDsPions],
nickname='D2HPi0',
shared=False)
## D+ -> K+ pi0, pi0 -> (e- e+) gamma. (e- e+) labeled KS0.
D2KPi0_eegamma = D2HH0_3Body_Combiner(
'Comb',
decay="[D+ -> KS0 gamma K+]cc",
inputs=[Conv_Photon_2EmEp, Hlt2NoPIDsPhotons, Hlt2NoPIDsKaons],
nickname='D2HPi0',
shared=False)
## D+ -> pi+ pi0, eta -> (e- e+) gamma. (e- e+) labeled KS0.
D2PiEta_eegamma = D2PiPi0_eegamma.clone('Comb', nickname='D2HEta')
## D+ -> K+ pi0, eta -> (e- e+) gamma. (e- e+) labeled KS0.
D2KEta_eegamma = D2KPi0_eegamma.clone('Comb', nickname='D2HEta')
## D*+ -> D0 pi+, D0 -> e+ e-. Why is this in CharmHad?
Dstar2PiD0_ee = TagDecay(
'Dstar2PiD0',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[D02_ee_Combiner('D0_ee'), SharedSoftTagChild_pi])
## D*+ -> D0 pi+, D0 -> gamma gamma, one gamma -> e- e+.
Dstar2PiD0_eegamma = TagDecayWithNeutral(
'Dstar2PiD0',
decay=["D*(2010)+ -> D0 pi+", "D*(2010)- -> D0 pi-"],
inputs=[D0_gg_NeutralCombiner('D0_gg'), SharedSoftTagChild_pi])
## D+ -> eta pi+, eta -> (pi+ pi-) gamma, (pi+ pi-) labeled rho(770)0.
D2EtaPi_hhgamma = D2RhoHG_3Body_Combiner(
'D2EtaPi_hhgamma',
decay=["D+ -> rho(770)0 pi+ gamma", "D- -> rho(770)0 pi- gamma"],
inputs=[
D2HH_RhoToPipPim, SharedNoPIDDetachedChild_pi,
SharedNeutralLowPtChild_gamma
])
## D+ -> eta K+, eta -> (pi+ pi-) gamma, (pi+ pi-) labeled rho(770)0.
D2EtaK_hhgamma = D2RhoHG_3Body_Combiner(
'D2EtaK_hhgamma',
decay=["D+ -> rho(770)0 K+ gamma", "D- -> rho(770)0 K- gamma"],
inputs=[
D2HH_RhoToPipPim, SharedNoPIDDetachedChild_K,
SharedNeutralLowPtChild_gamma
])
## D+ -> eta' pi+, eta' -> (pi+ pi-) gamma, (pi+ pi-) labeled rho(770)0.
D2EtaPrimePi_hhgamma = D2EtaPi_hhgamma.clone(
'D2EtaPrimePi_hhgamma', nickname='D2EtaPrimePi_hhgamma')
## D+ -> eta' K+, eta' -> (pi+ pi-) gamma, (pi+ pi-) labeled rho(770)0.
D2EtaPrimeK_hhgamma = D2EtaK_hhgamma.clone(
'D2EtaPrimeK_hhgamma', nickname='D2EtaPrimeK_hhgamma')
## D+ -> eta pi+, eta -> (pi+ pi-) pi0, (pi+ pi-) labeled rho(770)0.
D2EtaPi_3hR = D2RhoHG_3Body_Combiner(
'D2EtaPi_3hR',
decay=["D+ -> rho(770)0 pi+ pi0", "D- -> rho(770)0 pi- pi0"],
inputs=[
D2HH_RhoToPipPim, SharedNoPIDDetachedChild_pi,
SharedNeutralLowPtChild_pi0R
])
D2EtaPi_3hM = D2EtaPi_3hR.clone('D2EtaPi_3hM',
nickname='D2EtaPi_3hM',
inputs=[
D2HH_RhoToPipPim,
SharedNoPIDDetachedChild_pi,
SharedNeutralLowPtChild_pi0M
])
## D+ -> eta K+, eta -> (pi+ pi-) pi0, (pi+ pi-) labeled rho(770)0.
D2EtaK_3hR = D2RhoHG_3Body_Combiner(
'D2EtaK_3hR',
decay=["D+ -> rho(770)0 K+ pi0", "D- -> rho(770)0 K- pi0"],
inputs=[
D2HH_RhoToPipPim, SharedNoPIDDetachedChild_K,
SharedNeutralLowPtChild_pi0R
])
D2EtaK_3hM = D2EtaK_3hR.clone('D2EtaK_3hM',
nickname='D2EtaK_3hM',
inputs=[
D2HH_RhoToPipPim,
SharedNoPIDDetachedChild_K,
SharedNeutralLowPtChild_pi0M
])
## D+ -> eta' pi+, eta' -> (pi+ pi-) eta, eta -> gamma gamma
## (pi+ pi-) labeled rho(770)0.
D2EtaPrimePi_3h = D2RhoHG_3Body_Combiner(
'D2EtaPrimePi_3h',
decay=["D+ -> rho(770)0 pi+ eta", "D- -> rho(770)0 pi- eta"],
inputs=[
D2HH_RhoToPipPim, SharedNoPIDDetachedChild_pi,
SharedNeutralLowPtChild_eta
])
## D+ -> eta' K+, eta' -> (pi+ pi-) eta, eta -> gamma gamma
## (pi+ pi-) labeled rho(770)0.
D2EtaPrimeK_3h = D2RhoHG_3Body_Combiner(
'D2EtaPrimeK_3h',
decay=["D+ -> rho(770)0 K+ eta", "D- -> rho(770)0 K- eta"],
inputs=[
D2HH_RhoToPipPim, SharedNoPIDDetachedChild_K,
SharedNeutralLowPtChild_eta
])
## The stages dictionary should be a clear two-column list from
## which the lines defined in this module can be directly read.
stages = {
'Dp2PipPi0_Pi02EmEpG': [D2PiPi0_eegamma],
'Dp2KpPi0_Pi02EmEpG': [D2KPi0_eegamma],
'Dp2EtaPip_Eta2EmEpG': [D2PiEta_eegamma],
'Dp2EtaKp_Eta2EmEpG': [D2KEta_eegamma],
'Dstp2D0Pip_D02EmEp': [Dstar2PiD0_ee],
'Dstp2D0Pip_D02GG_G2EmEp': [Dstar2PiD0_eegamma],
'Dp2EtaPip_Eta2PimPipG': [D2EtaPi_hhgamma],
'Dp2EtaKp_Eta2PimPipG': [D2EtaK_hhgamma],
'Dp2EtapPip_Etap2PimPipG': [D2EtaPrimePi_hhgamma],
'Dp2EtapKp_Etap2PimPipG': [D2EtaPrimeK_hhgamma],
'Dp2EtaPip_Eta2PimPipPi0_Pi0R': [D2EtaPi_3hR],
'Dp2EtaKp_Eta2PimPipPi0_Pi0R': [D2EtaK_3hR],
'Dp2EtaPip_Eta2PimPipPi0_Pi0M': [D2EtaPi_3hM],
'Dp2EtaKp_Eta2PimPipPi0_Pi0M': [D2EtaK_3hM],
'Dp2EtapPip_Etap2EtaPimPip_EtaR': [D2EtaPrimePi_3h],
'Dp2EtapKp_Etap2EtaPimPip_EtaR': [D2EtaPrimeK_3h]
}
return stages