def helicity_amps_ff(q2, wc_obj, par_dict, B, P, l1, l2, cp_conjugate): par = par_dict.copy() if cp_conjugate: par = conjugate_par(par) scale = config['renormalization scale']['bpll'] label = meson_quark[(B,P)] + l1 + l2 # e.g. bsmumu, bdtautau if l1 == l2: # include SM contributions for LF conserving decay wc = wctot_dict(wc_obj, label, scale, par) else: wc = wc_obj.get_wc(label, scale, par) if cp_conjugate: wc = conjugate_wc(wc) if l1 == l2: wc_eff = get_wceff(q2, wc, par, B, P, l1, scale) else: wc_eff = get_wceff_lfv(q2, wc, par, B, P, l1, l2, scale) ml1 = par['m_'+l1] ml2 = par['m_'+l2] mB = par['m_'+B] mP = par['m_'+P] mb = running.get_mb(par, scale) N = prefactor(q2, par, B, P) ff = get_ff(q2, par, B, P) h = angular.helicity_amps_p(q2, mB, mP, mb, 0, ml1, ml2, ff, wc_eff, N) return h
def _get_angularcoeff(q2, wc_obj, par, B, V, lep, nu): scale = config['renormalization scale']['bvll'] mb = running.get_mb(par, scale) wc = get_wceff_fccc(wc_obj, par, meson_quark[(B, V)], lep, nu, mb, scale, nf=5) if lep != nu and all(C == 0 for C in wc.values()): # if all WCs vanish, so does the AC! return { k: 0 for k in ['1s', '1c', '2s', '2c', '6s', '6c', 3, 4, 5, 7, 8, 9] } ml = par['m_' + lep] mB = par['m_' + B] mV = par['m_' + V] qi_qj = meson_quark[(B, V)] if qi_qj == 'bu': mlight = 0. # neglecting the up quark mass if qi_qj == 'bc': mlight = running.get_mc( par, scale) # this is needed for scalar contributions N = prefactor(q2, par, B, V, lep) ff = get_ff(q2, par, B, V) h = angular.helicity_amps_v(q2, mB, mV, mb, mlight, ml, 0, ff, wc, N) J = angular.angularcoeffs_general_v(h, q2, mB, mV, mb, mlight, ml, 0) return J
def wctot_dict(wc_obj, sector, scale, par, nf_out=5): r"""Get a dictionary with the total (SM + new physics) values of the $\Delta F=1$ Wilson coefficients at a given scale, given a WilsonCoefficients instance.""" wc_np_dict = wc_obj.get_wc(sector, scale, par, nf_out=nf_out) if nf_out == 5: wc_sm = wcsm_nf5(scale) else: raise NotImplementedError( "DeltaF=1 Wilson coefficients only implemented for B physics") # fold in approximate m_t-dependence of C_10 (see eq. 4 of arXiv:1311.0903) flavio.citations.register("Bobeth:2013uxa") wc_sm[9] = wc_sm[9] * (par['m_t'] / 173.1)**1.53 # go from the effective to the "non-effective" WCs for C7 and C8 yi = np.array([0, 0, -1 / 3., -4 / 9., -20 / 3., -80 / 9.]) zi = np.array([0, 0, 1, -1 / 6., 20, -10 / 3.]) wc_sm[6] = wc_sm[6] - np.dot(yi, wc_sm[:6]) # c7 (not effective!) wc_sm[7] = wc_sm[7] - np.dot(zi, wc_sm[:6]) # c8 (not effective!) wc_labels = fcnclabels[sector] wc_sm_dict = dict(zip(wc_labels, wc_sm)) # now here comes an ugly fix. If we have b->s transitions, we should take # into account the fact that C7' = C7*ms/mb, and the same for C8, which is # not completely negligible. To find out whether we have b->s, we look at # the "sector" string. if sector[:2] == 'bs': eps_s = running.get_ms(par, scale) / running.get_mb(par, scale) wc_sm_dict['C7p_bs'] = eps_s * wc_sm_dict['C7_bs'] wc_sm_dict['C8p_bs'] = eps_s * wc_sm_dict['C8_bs'] tot_dict = add_dict((wc_np_dict, wc_sm_dict)) # add C7eff(p) and C8eff(p) tot_dict.update(get_C78eff(tot_dict, sector[:2])) return tot_dict
def wctot_dict(wc_obj, sector, scale, par, nf_out=None): r"""Get a dictionary with the total (SM + new physics) values of the $\Delta F=1$ Wilson coefficients at a given scale, given a WilsonCoefficients instance.""" wc_np_dict = wc_obj.get_wc(sector, scale, par, nf_out=nf_out) wcsm_120 = _wcsm_120.copy() wc_sm = running.get_wilson(par, wcsm_120, wc_obj.rge_derivative[sector], 120., scale, nf_out=nf_out) # now here comes an ugly fix. If we have b->s transitions, we should take # into account the fact that C7' = C7*ms/mb, and the same for C8, which is # not completely negligible. To find out whether we have b->s, we look at # the "sector" string. if sector[:2] == 'bs': # go from the effective to the "non-effective" WCs yi = np.array([0, 0, -1/3., -4/9., -20/3., -80/9.]) zi = np.array([0, 0, 1, -1/6., 20, -10/3.]) c7 = wc_sm[6] - np.dot(yi, wc_sm[:6]) # c7 (not effective!) c8 = wc_sm[7] - np.dot(zi, wc_sm[:6]) # c8 (not effective!) eps_s = running.get_ms(par, scale)/running.get_mb(par, scale) c7p = eps_s * c7 c8p = eps_s * c8 # go back to the effective WCs wc_sm[21] = c7p + np.dot(yi, wc_sm[15:21]) # c7p_eff wc_sm[22] = c7p + np.dot(zi, wc_sm[15:21]) # c8p_eff wc_labels = wc_obj.coefficients[sector] wc_sm_dict = dict(zip(wc_labels, wc_sm)) return add_dict((wc_np_dict, wc_sm_dict))
def wctot_dict(wc_obj, sector, scale, par, nf_out=None): r"""Get a dictionary with the total (SM + new physics) values of the $\Delta F=1$ Wilson coefficients at a given scale, given a WilsonCoefficients instance.""" wc_np_dict = wc_obj.get_wc(sector, scale, par, nf_out=nf_out) wcsm_120 = _wcsm_120.copy() # fold in approximate m_t-dependence of C_10 (see eq. 4 of arXiv:1311.0903) wcsm_120[9] = wcsm_120[9] * (par['m_t'] / 173.1)**1.53 wc_sm = running.get_wilson(par, wcsm_120, wc_obj.rge_derivative[sector], 120., scale, nf_out=nf_out) # now here comes an ugly fix. If we have b->s transitions, we should take # into account the fact that C7' = C7*ms/mb, and the same for C8, which is # not completely negligible. To find out whether we have b->s, we look at # the "sector" string. if sector[:2] == 'bs': # go from the effective to the "non-effective" WCs yi = np.array([0, 0, -1 / 3., -4 / 9., -20 / 3., -80 / 9.]) zi = np.array([0, 0, 1, -1 / 6., 20, -10 / 3.]) c7 = wc_sm[6] - np.dot(yi, wc_sm[:6]) # c7 (not effective!) c8 = wc_sm[7] - np.dot(zi, wc_sm[:6]) # c8 (not effective!) eps_s = running.get_ms(par, scale) / running.get_mb(par, scale) c7p = eps_s * c7 c8p = eps_s * c8 # go back to the effective WCs wc_sm[21] = c7p + np.dot(yi, wc_sm[15:21]) # c7p_eff wc_sm[22] = c8p + np.dot(zi, wc_sm[15:21]) # c8p_eff wc_labels = wc_obj.coefficients[sector] wc_sm_dict = dict(zip(wc_labels, wc_sm)) return add_dict((wc_np_dict, wc_sm_dict))
def get_wceff(q2, wc, par, B, M, lep, scale): r"""Get a dictionary with the effective $\Delta F=1$ Wilson coefficients in the convention appropriate for the generalized angular distributions. """ xi_u = ckm.xi('u',meson_quark[(B,M)])(par) xi_t = ckm.xi('t',meson_quark[(B,M)])(par) qiqj=meson_quark[(B,M)] Yq2 = matrixelements.Y(q2, wc, par, scale, qiqj) + (xi_u/xi_t)*matrixelements.Yu(q2, wc, par, scale, qiqj) # b) NNLO Q1,2 delta_C7 = matrixelements.delta_C7(par=par, wc=wc, q2=q2, scale=scale, qiqj=qiqj) delta_C9 = matrixelements.delta_C9(par=par, wc=wc, q2=q2, scale=scale, qiqj=qiqj) mb = running.get_mb(par, scale) ll = lep + lep c = {} c['7'] = wc['C7eff_'+qiqj] + delta_C7 c['7p'] = wc['C7effp_'+qiqj] c['v'] = wc['C9_'+qiqj+ll] + delta_C9 + Yq2 c['vp'] = wc['C9p_'+qiqj+ll] c['a'] = wc['C10_'+qiqj+ll] c['ap'] = wc['C10p_'+qiqj+ll] c['s'] = mb * wc['CS_'+qiqj+ll] c['sp'] = mb * wc['CSp_'+qiqj+ll] c['p'] = mb * wc['CP_'+qiqj+ll] c['pp'] = mb * wc['CPp_'+qiqj+ll] c['t'] = 0 c['tp'] = 0 return c
def getfft(s, par, B, ff, ff0, lep, wc): scale = config['renormalization scale']['bllgamma'] mb = running.get_mb(par, scale, nf_out=5) bq = meson_quark[B] a1 = -wc['C1_' + bq] - wc[ 'C2_' + bq] / 3 #minus sign comes from WC sign convention fftv = ff['tv'] + ff0['tv'] + 16 / 3 * a1 / wc['C7_' + bq] * par['f_' + B] / mb ffta = ff['ta'] + ff0['ta'] #Add light meson resonances resonances = {'Bs': ['phi'], 'B0': ['rho0', 'omega']} flavio.citations.register("Kozachuk:2017mdk") fVtofVemfactors = { 'phi': -1 / 3, 'rho0': 1 / sqrt(2), 'omega': 1 / (3 * sqrt(2)) } # Given in Sec. 8.A.3 of 1712.07926 #We use the general B->rho and B->omega parameters, hence the isotopic factors resgV = { ('Bs', 'phi'): -par['Bs->phi BSZ a0_T1'], ('B0', 'rho0'): 1 / sqrt(2) * par['B->rho BSZ a0_T1'], ('B0', 'omega'): -1 / sqrt(2) * par['B->omega BSZ a0_T1'], } for V in resonances[B]: gV = resgV[(B, V)] fV = fVtofVemfactors[V] * par['f_' + V] fftv -= 2 * fV * gV * par['m_' + B]**2 * s / par['m_' + V] / ( par['m_' + B]**2 * s - par['m_' + V]**2 + 1j * par['m_' + V] / par['tau_' + V]) ffta -= 2 * fV * gV * par['m_' + B]**2 * s / par['m_' + V] / ( par['m_' + B]**2 * s - par['m_' + V]**2 + 1j * par['m_' + V] / par['tau_' + V]) return (fftv, ffta)
def _get_angularcoeff(q2, wc_obj, par, B, V, lep, nu): scale = config['renormalization scale']['bvll'] mb = running.get_mb(par, scale) wc = get_wceff_fccc2(wc_obj, par, meson_quark[(B, V)], lep, nu, mb, scale, nf=5) ml = par['m_' + lep] mB = par['m_' + B] mV = par['m_' + V] qi_qj = meson_quark[(B, V)] if qi_qj == 'bu': mlight = 0. # neglecting the up quark mass if qi_qj == 'bc': mlight = running.get_mc( par, scale) # this is needed for scalar contributions N = prefactor(q2, par, B, V, lep) ff = get_ff(q2, par, B, V) h = angular.helicity_amps_v(q2, mB, mV, mb, mlight, ml, 0, ff, wc, N) J = angular.angularcoeffs_general_v(h, q2, mB, mV, mb, mlight, ml, 0) return J
def prefactor(par, B, V): mB = par["m_" + B] mV = par["m_" + V] scale = config["renormalization scale"]["bvgamma"] alphaem = running.get_alpha(par, scale)["alpha_e"] mb = running.get_mb(par, scale) GF = par["GF"] bq = meson_quark[(B, V)] xi_t = ckm.xi("t", bq)(par) return sqrt((GF ** 2 * alphaem * mB ** 3 * mb ** 2) / (32 * pi ** 4) * (1 - mV ** 2 / mB ** 2) ** 3) * xi_t
def getF1(s, par, B, ff, ff0, lep, wc): scale = config['renormalization scale']['bllgamma'] mb = running.get_mb(par, scale, nf_out=5) mbh = mb / par['m_' + B] bq = meson_quark[B] label = bq + lep + lep fftv, ffta = getfft(s, par, B, ff, ff0, lep, wc) return (abs(wc['C9_' + label])**2 + abs(wc['C10_' + label])**2) * ff['v']**2 + 4 * mbh**2 / s**2 * abs( wc['C7_' + bq] * fftv)**2 + 4 * mbh / s * ff['v'] * _Re( wc['C7_' + bq] * ffta * _Co(wc['C9_' + label]))
def B120(s, par, B, ff, ff0, lep, wc): scale = config['renormalization scale']['bllgamma'] mb = running.get_mb(par, scale, nf_out=5) mbh = mb / par['m_' + B] mlh = par['m_' + lep] / par['m_' + B] bq = meson_quark[B] label = bq + lep + lep fftv, ffta = getfft(s, par, B, ff, ff0, lep, wc) return -16 * mlh**2 * (1 - s) * ( ff['v'] * _Re(wc['C9_' + label] * _Co(wc['C10_' + label])) + 2 * mbh / s * _Re(_Co(wc['C10_' + label]) * fftv * wc['C7_' + bq]))
def prefactor(par, B, V): mB = par['m_'+B] mV = par['m_'+V] scale = config['renormalization scale']['bvgamma'] alphaem = running.get_alpha(par, scale)['alpha_e'] mb = running.get_mb(par, scale) GF = par['GF'] bq = meson_quark[(B,V)] xi_t = ckm.xi('t',bq)(par) return ( sqrt((GF**2 * alphaem * mB**3 * mb**2)/(32 * pi**4) * (1-mV**2/mB**2)**3) * xi_t )
def bpll_obs(function, q2, wc, par, B, P, l1, l2): ml1 = par['m_'+l1] ml2 = par['m_'+l2] mB = par['m_'+B] mP = par['m_'+P] if q2 <= (ml1+ml2)**2 or q2 > (mB-mP)**2: return 0 scale = config['renormalization scale']['bpll'] mb = running.get_mb(par, scale) h = helicity_amps(q2, wc, par, B, P, l1, l2) J = angular.angularcoeffs_general_p(h, q2, mB, mP, mb, 0, ml1, ml2) return function(J)
def helicity_amps(q2, wc, par_dict, B, P, l1, l2): par = par_dict.copy() scale = config['renormalization scale']['bpll'] wc_eff = get_wceff_lfv(q2, wc, par, B, P, l1, l2, scale) ml1 = par['m_'+l1] ml2 = par['m_'+l2] mB = par['m_'+B] mP = par['m_'+P] mb = running.get_mb(par, scale) N = prefactor(q2, par, B, P) ff = get_ff(q2, par, B, P) h = angular.helicity_amps_p(q2, mB, mP, mb, 0, ml1, ml2, ff, wc_eff, N) return h
def B120(s, par, B, ff, ff0, lep, wc): flavio.citations.register("Melikhov:2004mk") flavio.citations.register("Guadagnoli:2016erb") scale = config['renormalization scale']['bllgamma'] mb = running.get_mb(par, scale, nf_out=5) mbh = mb / par['m_' + B] mlh = par['m_' + lep] / par['m_' + B] bq = meson_quark[B] label = bq + lep + lep fftv, ffta = getfft(s, par, B, ff, ff0, lep, wc) return -16 * mlh**2 * (1 - s) * ( ff['v'] * _Re(wc['C9_' + label] * _Co(wc['C10_' + label])) + 2 * mbh / s * _Re(_Co(wc['C10_' + label]) * fftv * wc['C7_' + bq]))
def bvll_obs(function, q2, wc_obj, par, B, V, lep): ml = par['m_'+lep] mB = par['m_'+B] mV = par['m_'+V] if q2 < 4*ml**2 or q2 > (mB-mV)**2: return 0 scale = config['renormalization scale']['bvll'] mb = running.get_mb(par, scale) ff = get_ff(q2, par, B, V) h = helicity_amps(q2, wc_obj, par, B, V, lep) h_bar = helicity_amps_bar(q2, wc_obj, par, B, V, lep) J = angular.angularcoeffs_general_v(h, q2, mB, mV, mb, 0, ml, ml) J_bar = angular.angularcoeffs_general_v(h_bar, q2, mB, mV, mb, 0, ml, ml) return function(J, J_bar)
def bvll_obs(function, q2, wc_obj, par, B, V, lep): ml = par['m_' + lep] mB = par['m_' + B] mV = par['m_' + V] if q2 < 4 * ml**2 or q2 > (mB - mV)**2: return 0 scale = config['renormalization scale']['bvll'] mb = running.get_mb(par, scale) ff = get_ff(q2, par, B, V) h = helicity_amps(q2, wc_obj, par, B, V, lep) h_bar = helicity_amps_bar(q2, wc_obj, par, B, V, lep) J = angular.angularcoeffs_general_v(h, q2, mB, mV, mb, 0, ml, ml) J_bar = angular.angularcoeffs_general_v(h_bar, q2, mB, mV, mb, 0, ml, ml) return function(J, J_bar)
def helicity_amps_ff(q2, ff, wc_obj, par_dict, B, V, lep, cp_conjugate): par = par_dict.copy() if cp_conjugate: par = conjugate_par(par) scale = config['renormalization scale']['bvll'] label = meson_quark[(B,V)] + lep + lep # e.g. bsmumu, bdtautau wc = wctot_dict(wc_obj, label, scale, par) if cp_conjugate: wc = conjugate_wc(wc) wc_eff = get_wceff(q2, wc, par, B, V, lep, scale) ml = par['m_'+lep] mB = par['m_'+B] mV = par['m_'+V] mb = running.get_mb(par, scale) N = prefactor(q2, par, B, V) h = angular.helicity_amps_v(q2, mB, mV, mb, 0, ml, ml, ff, wc_eff, N) return h
def get_angularcoeff(q2, wc_obj, par, B, V, lep): scale = config['renormalization scale']['bvll'] mb = running.get_mb(par, scale) wc = get_wceff_fccc(wc_obj, par, meson_quark[(B,V)], lep, mb, scale, nf=5) ml = par['m_'+lep] mB = par['m_'+B] mV = par['m_'+V] qi_qj = meson_quark[(B, V)] if qi_qj == 'bu': mlight = 0. # neglecting the up quark mass if qi_qj == 'bc': mlight = running.get_mc(par, scale) # this is needed for scalar contributions N = prefactor(q2, par, B, V, lep) ff = get_ff(q2, par, B, V) h = angular.helicity_amps_v(q2, mB, mV, mb, mlight, ml, 0, ff, wc, N) J = angular.angularcoeffs_general_v(h, q2, mB, mV, mb, mlight, ml, 0) return J
def helicity_amps_ff(q2, ff, wc_obj, par_dict, B, V, lep, cp_conjugate): par = par_dict.copy() if cp_conjugate: par = conjugate_par(par) scale = config['renormalization scale']['bvll'] label = meson_quark[(B, V)] + lep + lep # e.g. bsmumu, bdtautau wc = wctot_dict(wc_obj, label, scale, par) if cp_conjugate: wc = conjugate_wc(wc) wc_eff = get_wceff(q2, wc, par, B, V, lep, scale) ml = par['m_' + lep] mB = par['m_' + B] mV = par['m_' + V] mb = running.get_mb(par, scale) N = prefactor(q2, par, B, V) h = angular.helicity_amps_v(q2, mB, mV, mb, 0, ml, ml, ff, wc_eff, N) return h
def bpll_obs(function, q2, wc_obj, par, B, P, lep): ml = par['m_'+lep] mB = par['m_'+B] mP = par['m_'+P] if q2 <= (ml+ml)**2 or q2 > (mB-mP)**2: return 0 scale = config['renormalization scale']['bpll'] mb = running.get_mb(par, scale) h = helicity_amps(q2, wc_obj, par, B, P, lep) J = angular.angularcoeffs_general_p(h, q2, mB, mP, mb, 0, ml, ml) if lep == lep: h_bar = helicity_amps_bar(q2, wc_obj, par, B, P, lep) J_bar = angular.angularcoeffs_general_p(h_bar, q2, mB, mP, mb, 0, ml, ml) else: # for LFV decays, don't bother about the CP average. There is no strong phase. J_bar = J return function(J, J_bar)
def get_angularcoeff(q2, wc_obj, par, B, P, lep): ml = par['m_' + lep] mB = par['m_' + B] mP = par['m_' + P] scale = config['renormalization scale']['bpll'] mb = running.get_mb(par, scale) wc = get_wceff_fccc(wc_obj, par, meson_quark[(B, P)], lep, mb, scale) N = prefactor(q2, par, B, P, lep) ff = get_ff(q2, par, B, P) qi_qj = meson_quark[(B, P)] if qi_qj == 'bu': mlight = 0. # neglecting the up quark mass if qi_qj == 'bc': mlight = running.get_mc( par, scale) # this is needed for scalar contributions h = angular.helicity_amps_p(q2, mB, mP, mb, mlight, ml, 0, ff, wc, N) J = angular.angularcoeffs_general_p(h, q2, mB, mP, mb, mlight, ml, 0) return J
def bpll_obs(function, q2, wc_obj, par, B, P, lep): ml = par['m_' + lep] mB = par['m_' + B] mP = par['m_' + P] if q2 <= (ml + ml)**2 or q2 > (mB - mP)**2: return 0 scale = config['renormalization scale']['bpll'] mb = running.get_mb(par, scale) h = helicity_amps(q2, wc_obj, par, B, P, lep) J = angular.angularcoeffs_general_p(h, q2, mB, mP, mb, 0, ml, ml) if lep == lep: h_bar = helicity_amps_bar(q2, wc_obj, par, B, P, lep) J_bar = angular.angularcoeffs_general_p(h_bar, q2, mB, mP, mb, 0, ml, ml) else: # for LFV decays, don't bother about the CP average. There is no strong phase. J_bar = J return function(J, J_bar)
def _get_angularcoeff(q2, wc_obj, par, B, P, lep, nu): scale = config['renormalization scale']['bpll'] mb = running.get_mb(par, scale) wc = get_wceff_fccc(wc_obj, par, meson_quark[(B,P)], lep, nu, mb, scale, nf=5) if lep != nu and all(C == 0 for C in wc.values()): return {'a': 0, 'b': 0, 'c': 0} # if all WCs vanish, so does the AC! ml = par['m_'+lep] mB = par['m_'+B] mP = par['m_'+P] N = prefactor(q2, par, B, P, lep) ff = get_ff(q2, par, B, P) qi_qj = meson_quark[(B, P)] if qi_qj == 'bu': mlight = 0. # neglecting the up quark mass if qi_qj == 'bc': mlight = running.get_mc(par, scale) # this is needed for scalar contributions h = angular.helicity_amps_p(q2, mB, mP, mb, mlight, ml, 0, ff, wc, N) J = angular.angularcoeffs_general_p(h, q2, mB, mP, mb, mlight, ml, 0) return J
def amplitudes(par, wc, B, l1, l2): r"""Amplitudes P and S entering the $B_q\to\ell_1^+\ell_2^-$ observables. Parameters ---------- - `par`: parameter dictionary - `B`: should be `'Bs'` or `'B0'` - `l1` and `l2`: should be `'e'`, `'mu'`, or `'tau'` Returns ------- `(P, S)` where for the special case `l1 == l2` one has - $P = \frac{2m_\ell}{m_{B_q}} (C_{10}-C_{10}') + m_{B_q} (C_P-C_P')$ - $S = m_{B_q} (C_S-C_S')$ """ scale = config['renormalization scale']['bll'] # masses ml1 = par['m_' + l1] ml2 = par['m_' + l2] mB = par['m_' + B] mb = running.get_mb(par, scale, nf_out=5) # get the mass of the spectator quark if B == 'Bs': mspec = running.get_ms(par, scale, nf_out=5) elif B == 'B0': mspec = running.get_md(par, scale, nf_out=5) # Wilson coefficients qqll = meson_quark[B] + l1 + l2 # For LFV expressions see arXiv:1602.00881 eq. (5) C9m = wc['C9_' + qqll] - wc['C9p_' + qqll] # only relevant for l1 != l2! C10m = wc['C10_' + qqll] - wc['C10p_' + qqll] CPm = wc['CP_' + qqll] - wc['CPp_' + qqll] CSm = wc['CS_' + qqll] - wc['CSp_' + qqll] beta_m = sqrt(1 - (ml1 - ml2)**2 / mB**2) beta_p = sqrt(1 - (ml1 + ml2)**2 / mB**2) P = beta_m * ((ml2 + ml1) / mB * C10m + mB * mb / (mb + mspec) * CPm) S = beta_p * ((ml2 - ml1) / mB * C9m + mB * mb / (mb + mspec) * CSm) return P, S
def get_wceff_lfv(q2, wc, par, B, M, l1, l2, scale): r"""Get a dictionary with the effective $\Delta F=1$ Wilson coefficients with lepton flavour violation in the convention appropriate for the generalized angular distributions. """ mb = running.get_mb(par, scale) qiqj=meson_quark[(B,M)] c = {} c['7'] = 0 c['7p'] = 0 c['v'] = wc['C9_'+qiqj+l1+l2] c['vp'] = wc['C9p_'+qiqj+l1+l2] c['a'] = wc['C10_'+qiqj+l1+l2] c['ap'] = wc['C10p_'+qiqj+l1+l2] c['s'] = mb * wc['CS_'+qiqj+l1+l2] c['sp'] = mb * wc['CSp_'+qiqj+l1+l2] c['p'] = mb * wc['CP_'+qiqj+l1+l2] c['pp'] = mb * wc['CPp_'+qiqj+l1+l2] c['t'] = 0 c['tp'] = 0 return c
def get_wceff_lfv(q2, wc, par, B, M, l1, l2, scale): r"""Get a dictionary with the effective $\Delta F=1$ Wilson coefficients with lepton flavour violation in the convention appropriate for the generalized angular distributions. """ mb = running.get_mb(par, scale) qiqj = meson_quark[(B, M)] c = {} c['7'] = 0 c['7p'] = 0 c['v'] = wc['C9_' + qiqj + l1 + l2] c['vp'] = wc['C9p_' + qiqj + l1 + l2] c['a'] = wc['C10_' + qiqj + l1 + l2] c['ap'] = wc['C10p_' + qiqj + l1 + l2] c['s'] = mb * wc['CS_' + qiqj + l1 + l2] c['sp'] = mb * wc['CSp_' + qiqj + l1 + l2] c['p'] = mb * wc['CP_' + qiqj + l1 + l2] c['pp'] = mb * wc['CPp_' + qiqj + l1 + l2] c['t'] = 0 c['tp'] = 0 return c
def _get_angularcoeff(q2, wc_obj, par, B, V, lep, nu): scale = config['renormalization scale']['bvll'] mb = running.get_mb(par, scale) wc = get_wceff_fccc(wc_obj, par, meson_quark[(B,V)], lep, nu, mb, scale, nf=5) if lep != nu and all(C == 0 for C in wc.values()): # if all WCs vanish, so does the AC! return {k: 0 for k in ['1s', '1c', '2s', '2c', '6s', '6c', 3, 4, 5, 7, 8, 9]} ml = par['m_'+lep] mB = par['m_'+B] mV = par['m_'+V] qi_qj = meson_quark[(B, V)] if qi_qj == 'bu': mlight = 0. # neglecting the up quark mass if qi_qj == 'bc': mlight = running.get_mc(par, scale) # this is needed for scalar contributions N = prefactor(q2, par, B, V, lep) ff = get_ff(q2, par, B, V) h = angular.helicity_amps_v(q2, mB, mV, mb, mlight, ml, 0, ff, wc, N) J = angular.angularcoeffs_general_v(h, q2, mB, mV, mb, mlight, ml, 0) return J
def amplitudes(par, wc, B, l1, l2): r"""Amplitudes P and S entering the $B_q\to\ell_1^+\ell_2^-$ observables. Parameters ---------- - `par`: parameter dictionary - `B`: should be `'Bs'` or `'B0'` - `l1` and `l2`: should be `'e'`, `'mu'`, or `'tau'` Returns ------- `(P, S)` where for the special case `l1 == l2` one has - $P = \frac{2m_\ell}{m_{B_q}} (C_{10}-C_{10}') + m_{B_q} (C_P-C_P')$ - $S = m_{B_q} (C_S-C_S')$ """ scale = config['renormalization scale']['bll'] # masses ml1 = par['m_'+l1] ml2 = par['m_'+l2] mB = par['m_'+B] mb = running.get_mb(par, scale, nf_out=5) # get the mass of the spectator quark if B=='Bs': mspec = running.get_ms(par, scale, nf_out=5) elif B=='B0': mspec = running.get_md(par, scale, nf_out=5) # Wilson coefficients qqll = meson_quark[B] + l1 + l2 # For LFV expressions see arXiv:1602.00881 eq. (5) C9m = wc['C9_'+qqll] - wc['C9p_'+qqll] # only relevant for l1 != l2! C10m = wc['C10_'+qqll] - wc['C10p_'+qqll] CPm = wc['CP_'+qqll] - wc['CPp_'+qqll] CSm = wc['CS_'+qqll] - wc['CSp_'+qqll] P = (ml2 + ml1)/mB * C10m + mB * mb/(mb + mspec) * CPm S = (ml2 - ml1)/mB * C9m + mB * mb/(mb + mspec) * CSm return P, S
def get_wceff(q2, wc, par, B, M, lep, scale): r"""Get a dictionary with the effective $\Delta F=1$ Wilson coefficients in the convention appropriate for the generalized angular distributions. """ xi_u = ckm.xi('u', meson_quark[(B, M)])(par) xi_t = ckm.xi('t', meson_quark[(B, M)])(par) qiqj = meson_quark[(B, M)] Yq2 = matrixelements.Y( q2, wc, par, scale, qiqj) + (xi_u / xi_t) * matrixelements.Yu(q2, wc, par, scale, qiqj) # b) NNLO Q1,2 delta_C7 = matrixelements.delta_C7(par=par, wc=wc, q2=q2, scale=scale, qiqj=qiqj) delta_C9 = matrixelements.delta_C9(par=par, wc=wc, q2=q2, scale=scale, qiqj=qiqj) mb = running.get_mb(par, scale) ll = lep + lep c = {} c['7'] = wc['C7eff_' + qiqj] + delta_C7 c['7p'] = wc['C7effp_' + qiqj] c['v'] = wc['C9_' + qiqj + ll] + delta_C9 + Yq2 c['vp'] = wc['C9p_' + qiqj + ll] c['a'] = wc['C10_' + qiqj + ll] c['ap'] = wc['C10p_' + qiqj + ll] c['s'] = mb * wc['CS_' + qiqj + ll] c['sp'] = mb * wc['CSp_' + qiqj + ll] c['p'] = mb * wc['CP_' + qiqj + ll] c['pp'] = mb * wc['CPp_' + qiqj + ll] c['t'] = 0 c['tp'] = 0 return c
def __init__(self, B, V, lep, wc_obj, par): """Initialize the class and cache results needed more often.""" self.B = B self.V = V self.lep = lep self.wc_obj = wc_obj self.par = par self.par_conjugate = conjugate_par(par) self.prefactor = prefactor(None, self.par, B, V) self.prefactor_conjugate = prefactor(None, self.par_conjugate, B, V) self.scale = config['renormalization scale']['bvll'] self.label = meson_quark[(B,V)] + lep + lep # e.g. bsmumu, bdtautau self.wctot_dict = wctot_dict(wc_obj, self.label, self.scale, par) self._ff = {} self._wceff = {} self._wceff_bar = {} self._ha = {} self._ha_bar = {} self._j = {} self._j_bar = {} self.ml = par['m_'+lep] self.mB = par['m_'+B] self.mV = par['m_'+V] self.mb = running.get_mb(par, self.scale)