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