EWSMcache.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2012 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef EWSMCACHE_H
#define EWSMCACHE_H
 
#include <cmath>
#include <PVfunctions.h>
#include <Polylogarithms.h>
#include <ClausenFunctions.h>
#include "StandardModel.h"
 
class EWSMcache {
public:
 
    EWSMcache(const StandardModel& SM_i);
 
 
 
    const StandardModel& getSM() const
    {
        return SM;
    }
 
    void setFlagDebug(bool FlagDebug)
    {
        this->FlagDebug = FlagDebug;
    }
 
    void setFlagCacheInEWSMcache(bool FlagCacheInEWSMcache)
    {
        this->FlagCacheInEWSMcache = FlagCacheInEWSMcache;
    }
 
 
 
    //const StandardModel& getSM() const
    //{
    //    return SM;
    //}
 
    const PVfunctions getPV() const
    {
        return PV;
    }
 
    const Polylogarithms getPolyLog() const
    {
        return PolyLog;
    }
 
    const ClausenFunctions getClausen() const
    {
        return Clausen;
    }
 
 
    // get functions for constants
 
    double getZeta2() const
    {
        return zeta2;
    }
 
    double getZeta3() const
    {
        return zeta3;
    }
 
    double getZeta4() const
    {
        return zeta4;
    }
 
    double getZeta5() const
    {
        return zeta5;
    }
 
    double getS2() const
    {
        return S2;
    }
 
    double getD3() const
    {
        return D3;
    }
 
    double getB4() const
    {
        return B4;
    }
 
    double getLog2() const
    {
        return log2;
    }
 
 
 
    double mf(const Particle f, const double mu = 0.0, const orders order = FULLNNLO) const;
 
    double mf2(const Particle f, const double mu = 0.0, const orders order = FULLNNLO) const
    {
        double mf1 = mf(f, mu, order);
        return ( mf1 * mf1);
    }
 
    double Q_f(const Particle f) const
    {
        return f.getCharge();
    }
 
    double I3_f(const Particle f) const
    {
        return f.getIsospin();
    }
 
    double v_f(const Particle f, const double Mw_i) const
    {
        return ( a_f(f) - 2.0 * Q_f(f) * SM.sW2(Mw_i));
    }
 
    double a_f(const Particle f) const
    {
        return ( f.getIsospin());
    }
 
    double sigma_f(const Particle f, const double Mw_i) const
    {
        return ( 1.0 - 2.0 * fabs(Q_f(f)) * SM.sW2(Mw_i));
    }
 
    double delta_f(const Particle f, const double Mw_i) const
    {
        return ( -2.0 * Q_f(f) * SM.sW2(Mw_i));
    }
 
    double f_AlphaToGF(const double Mw_i) const
    {
        return ( sqrt(2.0) * SM.getGF() * pow(SM.getMz(), 2.0) * SM.sW2(Mw_i) * SM.cW2(Mw_i) / M_PI / SM.getAle());
    }
 
    double Xt_GF() const
    {
        return ( SM.getGF() * SM.getMtpole() * SM.getMtpole() / 8.0 / sqrt(2.0) / M_PI / M_PI);
    }
 
    double Xt_alpha(const double Mw_i) const
    {
        return ( Xt_GF() / f_AlphaToGF(Mw_i));
    }
 
    double Als(const double mu, const orders order) const
    {
        return ( SM.Als(mu, order));
    }
 
    double alsMt() const
    {
        if (FlagDebug)
            return ( 0.1074432788); // for debug
        else
            return ( SM.Als(SM.getMtpole(), FULLNNLO));
    }
 
    double Phi_QCD2() const
    {
        double r_QCD2 = SM.getMz() * SM.getMz() / 4.0 / SM.getMtpole() / SM.getMtpole();
        return ( asin(sqrt(r_QCD2)));
    }
 
    double gamma_QCD2() const
    {
        double r_QCD2 = SM.getMz() * SM.getMz() / 4.0 / SM.getMtpole() / SM.getMtpole();
        return ( log(2.0 * sqrt(r_QCD2)));
    }
 
    double h_QCD2() const
    {
        double r_QCD2 = SM.getMz() * SM.getMz() / 4.0 / SM.getMtpole() / SM.getMtpole();
        return ( log(2.0 * sqrt(1.0 - r_QCD2)));
    }
 
    double logV1primeAndA1prime() const
    {
        gsl_complex OneMinusE2Iphi = gsl_complex_rect(1.0 - cos(2.0 * Phi_QCD2()),
                -sin(2.0 * Phi_QCD2()));
        gsl_complex OneMinusE4Iphi = gsl_complex_rect(1.0 - cos(4.0 * Phi_QCD2()),
                -sin(4.0 * Phi_QCD2()));
        return ( GSL_REAL(gsl_complex_log(OneMinusE2Iphi))
                - 2.0 * GSL_REAL(gsl_complex_log(OneMinusE4Iphi)));
    }
 
    double Cl2_2Phi() const
    {
        double Phi = asin(SM.getMz() / 2.0 / SM.getMtpole());
        return ( Clausen.Cl2(2.0 * Phi));
    }
 
    double Cl2_4Phi() const
    {
        double Phi = asin(SM.getMz() / 2.0 / SM.getMtpole());
        return ( Clausen.Cl2(4.0 * Phi));
    }
 
    double Cl3_2Phi() const
    {
        double Phi = asin(SM.getMz() / 2.0 / SM.getMtpole());
        return ( Clausen.Cl3(2.0 * Phi));
    }
 
    double Cl3_4Phi() const
    {
        double Phi = asin(SM.getMz() / 2.0 / SM.getMtpole());
        return ( Clausen.Cl3(4.0 * Phi));
    }
 
 
    // Functions for the caches
 
    double logMZtoME() const;
 
    double logMZtoMMU() const;
 
    double logMZtoMTAU() const;
 
    double logMZtoMTOP() const;
 
    double logMTOPtoMH() const;
 
    double log_cW2(const double Mw_i) const;
 
    double Li2_MW2toMTOP2(const double Mw_i) const;
 
    double Li3_MW2toMTOP2(const double Mw_i) const;
 
    double Li3_for_F1(const double Mw_i) const;
 
    double A0_Mz2_Mw2(const double Mw_i) const;
 
    double A0_Mz2_mh2() const;
 
    double A0_Mw2_Mz2(const double Mw_i) const;
 
    double A0_Mw2_mh2(const double Mw_i) const;
 
    double A0_Mz2_Mz2() const;
 
    double A0_Mw2_Mw2(const double Mw_i) const;
 
    gslpp::complex B0_Mz2_Mw2_mh2_Mw2(const double Mw_i) const;
 
    gslpp::complex B0_Mz2_0_mh2_Mw2(const double Mw_i) const;
 
    gslpp::complex B0_Mw2_Mz2_Mt2_Mt2(const double Mw_i) const;
 
    gslpp::complex B0_Mz2_Mz2_Mw2_Mw2(const double Mw_i) const;
 
    gslpp::complex B0_Mz2_Mz2_mh2_Mz2() const;
 
    gslpp::complex B0_Mz2_Mw2_Mz2_Mw2(const double Mw_i) const;
 
    gslpp::complex B0_Mz2_Mw2_0_Mw2(const double Mw_i) const;
 
    gslpp::complex B0_Mz2_0_Mz2_Mw2(const double Mw_i) const;
 
    gslpp::complex B0_Mz2_0_0_Mw2(const double Mw_i) const;
 
    gslpp::complex B0_Mw2_Mz2_Mw2_Mw2(const double Mw_i) const;
 
    gslpp::complex B0_Mw2_Mw2_Mz2_Mw2(const double Mw_i) const;
 
    gslpp::complex B0_Mw2_Mw2_mh2_Mw2(const double Mw_i) const;
 
    gslpp::complex B0_Mw2_Mw2_0_Mw2(const double Mw_i) const;
 
    gslpp::complex B0_Mz2_Mz2_mf2_mf2(const Particle f) const;
 
    gslpp::complex B0p_Mz2_0_mh2_Mw2(const double Mw_i) const;
 
    gslpp::complex B0p_Mz2_Mz2_mh2_Mz2() const;
 
    gslpp::complex B0p_Mz2_0_Mz2_Mw2(const double Mw_i) const;
 
    gslpp::complex B0p_Mz2_Mz2_Mw2_Mw2(const double Mw_i) const;
 
    gslpp::complex B0p_Mw2_Mw2_Mz2_Mw2(const double Mw_i) const;
 
    gslpp::complex B0p_Mw2_Mw2_mh2_Mw2(const double Mw_i) const;
 
    gslpp::complex B0p_Mw2_Mw2_0_Mw2(const double Mw_i) const;
 
    gslpp::complex B0p_Mz2_Mz2_mf2_mf2(const Particle f) const;
 
    gslpp::complex B1_Mz2_0_mf2_mfprime2(const int gen) const;
 
    gslpp::complex B1_Mz2_0_mfprime2_mf2(const int gen) const;
 
    gslpp::complex B1_Mz2_Mw2_mf2_mfprime2(const int gen, const double Mw_i) const;
 
    gslpp::complex B1_Mz2_Mw2_mfprime2_mf2(const int gen, const double Mw_i) const;
 
    gslpp::complex B1p_Mw2_Mw2_mf2_mfprime2(const int gen, const double Mw_i) const;
 
    gslpp::complex B1p_Mw2_Mw2_mfprime2_mf2(const int gen, const double Mw_i) const;
 
    gslpp::complex Bf_Mz2_Mz2_mf2_mf2(const Particle f) const;
 
    gslpp::complex Bf_Mz2_0_mf2_mf2(const Particle f) const;
 
    gslpp::complex Bf_Mz2_Mw2_mfprime2_mf2(const int gen, const double Mw_i) const;
 
    gslpp::complex Bf_Mz2_0_mfprime2_mf2(const int gen) const;
 
    gslpp::complex Bf_Mw2_Mw2_mfprime2_mf2(const int gen, const double Mw_i) const;
 
    gslpp::complex Bfp_Mz2_Mz2_mf2_mf2(const Particle f) const;
 
    gslpp::complex Bfp_Mw2_Mw2_mfprime2_mf2(const int gen, const double Mw_i) const;
 
    gslpp::complex C0_Mz2_Mw2_Mt2_Mw2(const double Mw_i) const;
 
    gslpp::complex C0_Mz2_Mt2_Mw2_Mt2(const double Mw_i) const;
 
    gslpp::complex C0_Mz2_0_Mw2_0(const double Mw_i) const;
 
    gslpp::complex C0_Mz2_Mw2_0_Mw2(const double Mw_i) const;
 
    gslpp::complex C0_Mw2_Mw2_0_Mz2(const double Mw_i) const;
 
    gslpp::complex C0_Mw2_0_Mz2_0(const double Mw_i) const;
 
    gslpp::complex C0_Mz2_0_Mz2_0() const;
 
 
 
private:
    bool FlagDebug; 
    bool FlagCacheInEWSMcache; 
 
    const StandardModel& SM; 
    const PVfunctions PV; 
    const ClausenFunctions Clausen; 
    const Polylogarithms PolyLog; 
 
    // Constants 
    double zeta2; 
    double zeta3; 
    double zeta4; 
    double zeta5; 
    double S2; 
    double D3; 
    double B4; 
    double log2; 
 
 
    // Caches for double variables
    // The size of the caches are equal to the number of relevant parameters
    // plus one. 
 
    /* Logarithms */
    mutable double logMZtoME_cache[3]; 
    mutable double logMZtoMMU_cache[3]; 
    mutable double logMZtoMTAU_cache[3]; 
    mutable double logMZtoMTOP_cache[3]; 
    mutable double logMTOPtoMH_cache[3]; 
    mutable double log_cW2_cache[3]; 
 
    /* Dilogarithm and Trilogarithm for two-loop QCD corrections */
    mutable double Li2_MW2toMTOP2_cache[3]; 
    mutable double Li3_MW2toMTOP2_cache[3]; 
    mutable double Li3_for_F1_cache[3]; 
 
    /* One-loop functions */
    mutable double A0_Mz2_Mw2_cache[3]; 
    mutable double A0_Mz2_mh2_cache[3]; 
    mutable double A0_Mw2_Mz2_cache[3]; 
    mutable double A0_Mw2_mh2_cache[3]; 
    mutable double A0_Mz2_Mz2_cache[2]; 
    mutable double A0_Mw2_Mw2_cache[2]; 
 
    mutable double mf_atMz_params_cache[12][StandardModel::NumSMParamsForEWPO];
    mutable double mf_atMz_cache[12]; 
 
    // Caches for complex variables
    // The size of the caches are equal to the number of relevant parameters
    // plus one. 
 
    mutable double B0_Mz2_Mw2_mh2_Mw2_cache[5]; 
    mutable double B0_Mz2_0_mh2_Mw2_cache[5]; 
    mutable double B0_Mw2_Mz2_Mt2_Mt2_cache[5]; 
    mutable double B0_Mz2_Mz2_Mw2_Mw2_cache[4]; 
    mutable double B0_Mz2_Mz2_mh2_Mz2_cache[4]; 
    mutable double B0_Mz2_Mw2_Mz2_Mw2_cache[4]; 
    mutable double B0_Mz2_Mw2_0_Mw2_cache[4]; 
    mutable double B0_Mz2_0_Mz2_Mw2_cache[4]; 
    mutable double B0_Mz2_0_0_Mw2_cache[4]; 
    mutable double B0_Mw2_Mz2_Mw2_Mw2_cache[4]; 
    mutable double B0_Mw2_Mw2_Mz2_Mw2_cache[4]; 
    mutable double B0_Mw2_Mw2_mh2_Mw2_cache[4]; 
    mutable double B0_Mw2_Mw2_0_Mw2_cache[3]; 
    mutable double B0_Mz2_Mz2_mf2_mf2_cache[12][4]; 
 
    mutable double B0p_Mz2_0_mh2_Mw2_cache[5]; 
    mutable double B0p_Mz2_Mz2_mh2_Mz2_cache[4]; 
    mutable double B0p_Mz2_0_Mz2_Mw2_cache[4]; 
    mutable double B0p_Mz2_Mz2_Mw2_Mw2_cache[4]; 
    mutable double B0p_Mw2_Mw2_Mz2_Mw2_cache[4]; 
    mutable double B0p_Mw2_Mw2_mh2_Mw2_cache[4]; 
    mutable double B0p_Mw2_Mw2_0_Mw2_cache[3]; 
    mutable double B0p_Mz2_Mz2_mf2_mf2_cache[12][4]; 
 
    mutable double B1_Mz2_0_mf2_mfprime2_cache[6][5]; 
    mutable double B1_Mz2_0_mfprime2_mf2_cache[6][5]; 
    mutable double B1_Mz2_Mw2_mf2_mfprime2_cache[6][6]; 
    mutable double B1_Mz2_Mw2_mfprime2_mf2_cache[6][6]; 
 
    mutable double B1p_Mw2_Mw2_mf2_mfprime2_cache[6][5]; 
    mutable double B1p_Mw2_Mw2_mfprime2_mf2_cache[6][5]; 
 
    mutable double Bf_Mz2_Mz2_mf2_mf2_cache[12][4]; 
    mutable double Bf_Mz2_0_mf2_mf2_cache[12][4]; 
    mutable double Bf_Mz2_Mw2_mfprime2_mf2_cache[6][6]; 
    mutable double Bf_Mz2_0_mfprime2_mf2_cache[6][5]; 
    mutable double Bf_Mw2_Mw2_mfprime2_mf2_cache[6][5]; 
 
    mutable double Bfp_Mz2_Mz2_mf2_mf2_cache[12][4]; 
    mutable double Bfp_Mw2_Mw2_mfprime2_mf2_cache[6][5]; 
 
    mutable double C0_Mz2_Mw2_Mt2_Mw2_cache[5]; 
    mutable double C0_Mz2_Mt2_Mw2_Mt2_cache[5]; 
    mutable double C0_Mz2_0_Mw2_0_cache[4]; 
    mutable double C0_Mz2_Mw2_0_Mw2_cache[4]; 
    mutable double C0_Mw2_Mw2_0_Mz2_cache[4]; 
    mutable double C0_Mw2_0_Mz2_0_cache[4]; 
    mutable double C0_Mz2_0_Mz2_0_cache[3]; 
 
 
    // Methods for caching, which will be compiled as inline functions.
 
    bool CacheCheck(const double cache[],
            const int NumPar, const double params[]) const
    {
        if (!FlagCacheInEWSMcache) return false;
        bool bCache = true;
        for (int i = 0; i < NumPar; ++i)
            bCache &= (params[i] == cache[i]);
        return bCache;
    }
 
    void newCacheForDouble(double cache[], const int NumPar,
            const double params[], const double newResult) const
    {
        if (!FlagCacheInEWSMcache) return;
        for (int i = 0; i < NumPar; ++i)
            cache[i] = params[i];
        cache[NumPar] = newResult;
    }
 
    void newCacheForComplex(double cache[], const int NumPar,
            const double params[], const gslpp::complex newResult) const
    {
        if (!FlagCacheInEWSMcache) return;
        for (int i = 0; i < NumPar; ++i)
            cache[i] = params[i];
        cache[NumPar] = newResult.real();
        cache[NumPar + 1] = newResult.imag();
    }
 
};
 
#endif  /* EWSMCACHE_H */