Ejemplo n.º 1
0
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))
Ejemplo n.º 2
0
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))
Ejemplo n.º 3
0
 def get_wc(self, sector, scale, par, nf_out=None):
     # intialize with complex zeros
     values_in = np.zeros(len(self.coefficients[sector]), dtype=complex)
     # see if an initial value exists
     scale_in = None
     for idx, name in enumerate(self.coefficients[sector]):
         if name in self.initial.keys():
             scale_in_new = self.initial[name][0]
             # make sure that if there are several initial values, they are at the same scale
             if scale_in is not None and scale_in_new != scale_in:
                 raise ValueError(
                     "You cannot define initial values at different scales for Wilson coefficients that mix under renormalization"
                 )
             else:
                 scale_in = scale_in_new
             values_in[idx] = self.initial[name][1]
     if scale_in is None:
         # if no initial values have been given, no need to run anyway!
         return dict(zip(self.coefficients[sector],
                         values_in))  # these are all zero
     if self.rge_derivative[sector] is None:
         # if the sector has vanishing anomalous dimensions, nno need to run!
         return dict(zip(self.coefficients[sector],
                         values_in))  # these are just the initial values
     # otherwise, run
     values_out = running.get_wilson(par,
                                     values_in,
                                     self.rge_derivative[sector],
                                     scale_in,
                                     scale,
                                     nf_out=nf_out)
     return dict(zip(self.coefficients[sector], values_out))
Ejemplo n.º 4
0
 def get_wc(self, sector, scale, par, nf_out=None):
     # intialize with complex zeros
     values_in = np.zeros(len(self.coefficients[sector]), dtype=complex)
     # see if an initial value exists
     scale_in = None
     for idx, name in enumerate(self.coefficients[sector]):
         if name in self.initial.keys():
             scale_in_new = self.initial[name][0]
             # make sure that if there are several initial values, they are at the same scale
             if scale_in is not None and scale_in_new != scale_in:
                 raise ValueError("You cannot define initial values at different scales for Wilson coefficients that mix under renormalization")
             else:
                 scale_in = scale_in_new
             values_in[idx] = self.initial[name][1]
     if scale_in is None:
         # if no initial values have been given, no need to run anyway!
         return dict(zip(self.coefficients[sector],values_in)) # these are all zero
     if self.rge_derivative[sector] is None:
         # if the sector has vanishing anomalous dimensions, nno need to run!
         return dict(zip(self.coefficients[sector],values_in)) # these are just the initial values
     # otherwise, run
     values_out = running.get_wilson(par, values_in, self.rge_derivative[sector], scale_in, scale, nf_out=nf_out)
     return dict(zip(self.coefficients[sector],values_out))
Ejemplo n.º 5
0
def run_wc_df1(par, c_in, scale_in, scale_out):
    adm = gamma_all
    return running.get_wilson(par, c_in,
                              running.make_wilson_rge_derivative(adm),
                              scale_in, scale_out)
Ejemplo n.º 6
0
def run_wc_df2(par, c_in, scale_in, scale_out):
    return running.get_wilson(par, c_in, df2_rge_derivative, scale_in,
                              scale_out)
Ejemplo n.º 7
0
def run_wc_df1(par, c_in, scale_in, scale_out):
    adm = gamma_all
    return running.get_wilson(par, c_in, running.make_wilson_rge_derivative(adm), scale_in, scale_out)
Ejemplo n.º 8
0
Archivo: rge.py Proyecto: nsahoo/flavio
def run_wc_df2(par, c_in, scale_in, scale_out):
    adm = lambda nf, alpha_s, alpha_e: gamma_df2_array(nf, alpha_s)
    return running.get_wilson(par, c_in, running.make_wilson_rge_derivative(adm), scale_in, scale_out)
Ejemplo n.º 9
0
def run_wc_df2(par, c_in, scale_in, scale_out):
    return running.get_wilson(par, c_in, df2_rge_derivative, scale_in, scale_out)
Ejemplo n.º 10
0
def run_wc_df2(par, c_in, scale_in, scale_out):
    adm = lambda nf, alpha_s, alpha_e: gamma_df2_array(nf, alpha_s)
    return running.get_wilson(par, c_in,
                              running.make_wilson_rge_derivative(adm),
                              scale_in, scale_out)