├── .gitignore ├── .travis.yml ├── LICENSE ├── Makefile.am ├── README.md ├── configure.ac ├── examples ├── Makefile.am ├── README ├── ex1Xij.cpp ├── ex2Pole2ms.cpp └── ex3Pole2msRun.cpp ├── m4 ├── ax_boost_base.m4 ├── ax_cxx_compile_stdcxx.m4 ├── ax_openmp.m4 └── root.m4 ├── math ├── Makefile.am ├── README ├── mr.m ├── mr.tm ├── mrimpl.cpp └── rge.m ├── mr.pc.in ├── mr ├── HH.cpp ├── HH.hpp ├── Makefile.am ├── WW.cpp ├── WW.hpp ├── ZZ.cpp ├── ZZ.hpp ├── aGF │ ├── README │ ├── alphaGF10.cpp │ ├── alphaGF11.cpp │ └── alphaGF20.cpp ├── alphaGF.cpp ├── alphaGF.hpp ├── alphas.cpp ├── alphas.hpp ├── base.hpp ├── bb.cpp ├── bb.hpp ├── constants.hpp ├── dr.cpp ├── dr.hpp ├── dr │ ├── README │ ├── dr10.cpp │ ├── dr11.cpp │ ├── dr20.cpp │ ├── drbar10.cpp │ ├── drbar11.cpp │ ├── drbar20.cpp │ ├── drgl10.cpp │ ├── drgl11.cpp │ └── drgl20.cpp ├── gl │ ├── README │ ├── mHHbarGL10.cpp │ ├── mHHbarGL11.cpp │ ├── mHHbarGL20.cpp │ ├── mbbbarGL01.cpp │ ├── mbbbarGL10.cpp │ ├── mbbbarGL11.cpp │ ├── mbbbarGL20.cpp │ ├── mttbarGL01.cpp │ ├── mttbarGL10.cpp │ ├── mttbarGL11.cpp │ └── mttbarGL20.cpp ├── logger.hpp ├── mMSmOS │ ├── README │ ├── mHHbar10.cpp │ ├── mHHbar11.cpp │ ├── mHHbar20.cpp │ ├── mWWbar10.cpp │ ├── mWWbar11.cpp │ ├── mWWbar20.cpp │ ├── mZZbar10.cpp │ ├── mZZbar11.cpp │ ├── mZZbar20.cpp │ ├── mbbbar01.cpp │ ├── mbbbar10.cpp │ ├── mbbbar11.cpp │ ├── mbbbar20.cpp │ ├── mttbar01.cpp │ ├── mttbar10.cpp │ ├── mttbar11.cpp │ └── mttbar20.cpp ├── mOS2mMSQCD.cpp ├── mOSmMS │ ├── README │ ├── mHHos10.cpp │ ├── mHHos11.cpp │ ├── mHHos20.cpp │ ├── mWWos10.cpp │ ├── mWWos11.cpp │ ├── mWWos20.cpp │ ├── mZZos10.cpp │ ├── mZZos11.cpp │ ├── mZZos20.cpp │ ├── mbbos01.cpp │ ├── mbbos10.cpp │ ├── mbbos11.cpp │ ├── mbbos20.cpp │ ├── mttos01.cpp │ ├── mttos10.cpp │ ├── mttos11.cpp │ └── mttos20.cpp ├── mr.hpp ├── operators.hpp ├── p2ms.cpp ├── p2ms.hpp ├── smRGE.cpp ├── smRGE.hpp ├── sminput.hpp ├── tdecl.hpp ├── timer.hpp ├── tsil.cpp ├── tsil.hpp ├── tt.cpp ├── tt.hpp ├── yu │ ├── README │ ├── yuHH10.cpp │ ├── yuHH11.cpp │ ├── yuHH20.cpp │ ├── yuWW10.cpp │ ├── yuWW11.cpp │ ├── yuWW20.cpp │ ├── yuZZ10.cpp │ ├── yuZZ11.cpp │ ├── yuZZ20.cpp │ ├── yubb01.cpp │ ├── yubb10.cpp │ ├── yubb11.cpp │ ├── yubb20.cpp │ ├── yutt01.cpp │ ├── yutt10.cpp │ ├── yutt11.cpp │ └── yutt20.cpp └── yugl │ ├── README │ ├── yuHHGL10.cpp │ ├── yuHHGL11.cpp │ ├── yuHHGL20.cpp │ ├── yubbGL01.cpp │ ├── yubbGL10.cpp │ ├── yubbGL11.cpp │ ├── yubbGL20.cpp │ ├── yuttGL01.cpp │ ├── yuttGL10.cpp │ ├── yuttGL11.cpp │ └── yuttGL20.cpp ├── tests ├── Makefile.am ├── README ├── catch.hpp ├── testsuite.cpp ├── tst-BKKS_1205.2893.cpp ├── tst-JKV_0105304.cpp ├── tst-JKV_0212319.cpp ├── tst-MWeqMZ.cpp ├── tst-PolyLog.cpp ├── tst-RunDec.cpp ├── tst-mOSmMS_QCD.cpp └── tst-mPlanck.cpp └── tsil-1.3 ├── CHANGELOG.txt ├── ISSUES.txt ├── LICENSE.txt ├── Makefile.am ├── README.txt ├── analyticAB.c ├── analyticI.c ├── analyticM.c ├── analyticS.c ├── analyticT.c ├── analyticTbar.c ├── analyticU.c ├── analyticV.c ├── dBds.c ├── dSds.c ├── dTds.c ├── dUds.c ├── dilog.c ├── dsMds.c ├── evaluate.c ├── fevaluate.c ├── functions.c ├── generic.c ├── initB.c ├── initM.c ├── initS.c ├── initT.c ├── initU.c ├── initV.c ├── initialize.c ├── internal.h ├── rk5.c ├── rk6.c ├── setTbar.c ├── setV.c ├── setbold.c ├── special.c ├── trilog.c ├── tsil.h ├── tsil_funcs.h ├── tsil_global.h ├── tsil_names.h ├── tsil_params.h └── tsil_testparams.h /.gitignore: -------------------------------------------------------------------------------- 1 | *.html 2 | /autom4te.cache 3 | /stamp-h1 4 | Makefile 5 | /config.status 6 | /config.log 7 | /config.h 8 | /aclocal.m4 9 | Makefile.in 10 | /config/ 11 | /config.h.in 12 | /configure 13 | *~ 14 | /build*/ 15 | GIT_REVISION 16 | SVN_REVISION 17 | libtool 18 | *.o 19 | *.la 20 | *.so* 21 | *.a 22 | .deps 23 | *.tar* 24 | *.zip 25 | *.lo 26 | *.gcno 27 | *.gcda 28 | app.info 29 | coverage_report 30 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | language: cpp 3 | dist: bionic 4 | compiler: gcc 5 | 6 | # whitelist 7 | branches: 8 | only: 9 | - develop 10 | - master 11 | 12 | script: 13 | - autoreconf -iv 14 | - mkdir build 15 | - ./configure --prefix=$PWD/build 16 | - make CFLAGS='-g -O0 -w' CXXFLAGS='-g -O0 -w -std=c++11' 17 | - make install 18 | - make dist 19 | - tests/testsuite 20 | 21 | notifications: 22 | email: false 23 | -------------------------------------------------------------------------------- /Makefile.am: -------------------------------------------------------------------------------- 1 | ## 2 | ## Makefile.am for mr 3 | ## 4 | ## written by Andrey Pikelner 5 | ## 6 | ## Process this file with automake to produce Makefile.in 7 | ACLOCAL_AMFLAGS = ${ACLOCAL_FLAGS} -I m4 8 | SUBDIRS = \ 9 | tsil-1.3 \ 10 | mr \ 11 | examples \ 12 | tests 13 | 14 | 15 | if HAVE_MPREP 16 | SUBDIRS+=math 17 | endif 18 | 19 | pkgconfigdir = $(libdir)/pkgconfig 20 | pkgconfig_DATA = mr.pc 21 | 22 | EXTRA_DIST = mr.pc.in README.md 23 | DISTCLEANFILES = mr.pc 24 | 25 | $(pkgconfig_DATA): config.status 26 | 27 | -------------------------------------------------------------------------------- /examples/Makefile.am: -------------------------------------------------------------------------------- 1 | AUTOMAKE_OPTIONS = subdir-objects 2 | ACLOCAL_AMFLAGS = ${ACLOCAL_FLAGS} -I m4 3 | 4 | LDADD = ../mr/libmr.la 5 | EXCPPFLAGS = -g $(MR_CFLAGS) -I$(top_srcdir)/tsil-1.3 -I$(top_srcdir)/mr $(OPENMP_CFLAGS) 6 | 7 | EXLDDFLAGS = $(OPENMP_CFLAGS) $(MR_LIBS) -L$(top_srcdir)/mr -lmr -L$(top_srcdir)/tsil-1.3 -ltsil -lm 8 | 9 | noinst_PROGRAMS = ex1Xij ex2Pole2ms ex3Pole2msRun 10 | 11 | # CPC examples 12 | ex1Xij_SOURCES = ex1Xij.cpp 13 | ex1Xij_CPPFLAGS = $(EXCPPFLAGS) 14 | ex1Xij_LDADD = $(EXLDDFLAGS) 15 | 16 | ex2Pole2ms_SOURCES = ex2Pole2ms.cpp 17 | ex2Pole2ms_CPPFLAGS = $(EXCPPFLAGS) 18 | ex2Pole2ms_LDADD = $(EXLDDFLAGS) 19 | 20 | ex3Pole2msRun_SOURCES = ex3Pole2msRun.cpp 21 | ex3Pole2msRun_CPPFLAGS = $(EXCPPFLAGS) 22 | ex3Pole2msRun_LDADD = $(EXLDDFLAGS) 23 | 24 | 25 | EXTRA_DIST = README 26 | -------------------------------------------------------------------------------- /examples/README: -------------------------------------------------------------------------------- 1 | Examples directory content: 2 | 3 | - ex1Xij.cpp 4 | Contributions to relation between OS masses and running couplings and 5 | masses and its inverse connecting running MS masses with OS 6 | 7 | - ex2Pole2ms.cpp 8 | Running couplings from parameters defined in OS scheme 9 | 10 | - ex3Pole2msRun.cpp 11 | RGE evolution of running couplings obtained from OS parameters 12 | -------------------------------------------------------------------------------- /examples/ex2Pole2ms.cpp: -------------------------------------------------------------------------------- 1 | // Example of Pole masses and Gf conversion to 2 | // set of running couplings, running Higgs mass 3 | // term and running vev in MS scheme 4 | 5 | #include "mr.hpp" 6 | 7 | using namespace mr; 8 | 9 | int main (int argc, char *argv[]) 10 | { 11 | try 12 | { 13 | loglevel = logINFO; 14 | 15 | // Input: Pole masses and Fermi constant in OS scheme 16 | OSinput oi(pdg2014::Mb, pdg2014::MW, pdg2014::MZ, pdg2014::MH, pdg2014::Mt); 17 | 18 | // Running QCD coupling for as(Mt) from as(MZ) 19 | AlphaS as(oi); 20 | 21 | // Set of all running parameters at scale Mt 22 | P2MS pMSmt(oi,pdg2014::Gf, as(oi.Mt()), oi.Mt(), order::all); 23 | 24 | // Set of all running parameters at scale MZ 25 | P2MS pMSmZ(oi,pdg2014::Gf, as(oi.MZ()), oi.MZ(), order::all); 26 | 27 | 28 | // Input at mu=MZ for running as in [hep-ph]1208.3357 29 | std::cout << "mu= Z mass" << std::endl; 30 | std::cout << "alpha(1) = " << pMSmZ.a1()*4*Pi << std::endl 31 | << "alpha(2) = " << pMSmZ.a2()*4*Pi << std::endl 32 | << "alpha(3) = " << pMSmZ.as()*4*Pi << std::endl 33 | << "alpha(t) = " << pMSmZ.at()*4*Pi << std::endl 34 | << "alpha(b) = " << pMSmZ.ab()*4*Pi << std::endl 35 | << "4*Pi*lam = " << pMSmZ.alam()*pow(4*Pi,2) << std::endl; 36 | 37 | std::cout << "mu= Top mass" << std::endl; 38 | std::cout << "alpha(1) = " << pMSmt.a1()*4*Pi << std::endl 39 | << "alpha(2) = " << pMSmt.a2()*4*Pi << std::endl 40 | << "alpha(3) = " << pMSmt.as()*4*Pi << std::endl 41 | << "alpha(t) = " << pMSmt.at()*4*Pi << std::endl 42 | << "alpha(b) = " << pMSmt.ab()*4*Pi << std::endl 43 | << "lambda = " << pMSmt.alam()*pow(4*Pi,2) << std::endl; 44 | 45 | std::cout << std::endl; 46 | std::cout << "g_1 = " << sqrt(pMSmt.a1())*4*Pi << std::endl 47 | << "g_2 = " << sqrt(pMSmt.a2())*4*Pi << std::endl 48 | << "g_s = " << sqrt(pMSmt.as())*4*Pi << std::endl 49 | << "y_t = " << sqrt(pMSmt.at())*4*Pi << std::endl 50 | << "y_b = " << sqrt(pMSmt.ab())*4*Pi << std::endl 51 | << "lambda = " << pMSmt.alam()*pow(4*Pi,2) << std::endl 52 | << "mphi = " << pMSmt.mphi() << std::endl; 53 | 54 | 55 | } 56 | catch (std::exception &p) 57 | { 58 | std::cerr << p.what() << std::endl; 59 | return 1; 60 | } 61 | 62 | return 0; 63 | } 64 | 65 | -------------------------------------------------------------------------------- /examples/ex3Pole2msRun.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "mr.hpp" 4 | 5 | using namespace mr; 6 | 7 | int main (int argc, char *argv[]) 8 | { 9 | try 10 | { 11 | // Default log level is logERROR 12 | // loglevel = logDEBUG; 13 | 14 | // Input: Pole masses and Fermi constant in OS scheme 15 | OSinput oi(pdg2014::Mb, pdg2014::MW, pdg2014::MZ, pdg2014::MH, pdg2014::Mt); 16 | 17 | // Running QCD coupling for as(Mt) from as(MZ) 18 | AlphaS as(oi); 19 | 20 | // Set of all running parameters at scale Mt 21 | P2MS pMSmt(oi,pdg2014::Gf, as(oi.Mt()), oi.Mt(), order::all); 22 | 23 | // Initial values input by hand 24 | ParametersSM<3,3,3, 25 | 3,3,-1, 26 | 3,3,0> av( 27 | 5./3.*pow(0.35830/4./Pi,2), // GUT normalization 28 | pow(0.64779/4./Pi,2), 29 | pow(1.1666/4./Pi,2), 30 | pow(0.93690/4./Pi,2), 31 | pow(0.0/4./Pi,2), 32 | pow(0.0/4./Pi,2), 33 | 0.12604*pow(4.*Pi,-2), 34 | 131.55, 35 | 0*246, 36 | pow(173.34,2) 37 | ); 38 | 39 | // Initial values for running, input from pole masses 40 | ParametersSM<3,3,3, 41 | 3,0,-1, 42 | 3,3,0> avP2MS(pMSmt); 43 | 44 | std::cout << std::setprecision(3); 45 | 46 | for (size_t muPow = 3.; muPow <= 20.; muPow++) 47 | { 48 | 49 | SMCouplings av = avP2MS(pow(10,2*muPow)); 50 | 51 | std::cout << " log10(mu) = " << muPow 52 | << " a1 = " << av[couplings::g1] 53 | << " a2 = " << av[couplings::g2] 54 | << " a3 = " << av[couplings::gs] 55 | << " at = " << av[couplings::yt] 56 | << " ab = " << av[couplings::yb] 57 | << " atau = " << av[couplings::ytau] 58 | << " alam = " << av[couplings::lam] 59 | << " mphi = " << av[couplings::mphi] << std::endl; 60 | } 61 | 62 | } 63 | catch (std::exception &p) 64 | { 65 | std::cerr << p.what() << std::endl; 66 | return 1; 67 | } 68 | 69 | return 0; 70 | } 71 | 72 | -------------------------------------------------------------------------------- /m4/root.m4: -------------------------------------------------------------------------------- 1 | dnl -*- mode: autoconf -*- 2 | dnl 3 | dnl $Id: root.m4,v 1.3 2005/03/21 21:42:21 rdm Exp $ 4 | dnl $Author: rdm $ 5 | dnl $Date: 2005/03/21 21:42:21 $ 6 | dnl 7 | dnl Autoconf macro to check for existence or ROOT on the system 8 | dnl Synopsis: 9 | dnl 10 | dnl ROOT_PATH([MINIMUM-VERSION, [ACTION-IF-FOUND, [ACTION-IF-NOT-FOUND]]]) 11 | dnl 12 | dnl Some examples: 13 | dnl 14 | dnl ROOT_PATH(3.03/05, , AC_MSG_ERROR(Your ROOT version is too old)) 15 | dnl ROOT_PATH(, AC_DEFINE([HAVE_ROOT])) 16 | dnl 17 | dnl The macro defines the following substitution variables 18 | dnl 19 | dnl ROOTCONF full path to root-config 20 | dnl ROOTEXEC full path to root 21 | dnl ROOTCINT full path to rootcint 22 | dnl ROOTLIBDIR Where the ROOT libraries are 23 | dnl ROOTINCDIR Where the ROOT headers are 24 | dnl ROOTETCDIR Where the ROOT configuration is 25 | dnl ROOTCFLAGS Extra compiler flags 26 | dnl ROOTLIBS ROOT basic libraries 27 | dnl ROOTGLIBS ROOT basic + GUI libraries 28 | dnl ROOTAUXLIBS Auxilary libraries and linker flags for ROOT 29 | dnl ROOTAUXCFLAGS Auxilary compiler flags 30 | dnl ROOTRPATH Same as ROOTLIBDIR 31 | dnl 32 | dnl The macro will fail if root-config and rootcint isn't found. 33 | dnl 34 | dnl Christian Holm Christensen 35 | dnl 36 | AC_DEFUN([ROOT_PATH], 37 | [ 38 | AC_ARG_WITH([rootsys], 39 | [AC_HELP_STRING([--with-rootsys], 40 | [top of the ROOT installation directory])], 41 | [user_rootsys=$withval], 42 | [user_rootsys="none"]) 43 | if test ! x"$user_rootsys" = xnone; then 44 | rootbin="$user_rootsys/bin" 45 | elif test ! x"$ROOTSYS" = x ; then 46 | rootbin="$ROOTSYS/bin" 47 | else 48 | rootbin=$PATH 49 | fi 50 | AC_PATH_PROG(ROOTCONF, root-config , no, $rootbin) 51 | AC_PATH_PROG(ROOTEXEC, root , no, $rootbin) 52 | AC_PATH_PROG(ROOTCINT, rootcint , no, $rootbin) 53 | 54 | if test ! x"$ROOTCONF" = "xno" && \ 55 | test ! x"$ROOTCINT" = "xno" ; then 56 | 57 | # define some variables 58 | ROOTLIBDIR=`$ROOTCONF --libdir` 59 | ROOTINCDIR=`$ROOTCONF --incdir` 60 | ROOTETCDIR=`$ROOTCONF --etcdir` 61 | ROOTCFLAGS=`$ROOTCONF --noauxcflags --cflags` 62 | ROOTLIBS=`$ROOTCONF --noauxlibs --noldflags --libs` 63 | ROOTGLIBS=`$ROOTCONF --noauxlibs --noldflags --glibs` 64 | ROOTAUXCFLAGS=`$ROOTCONF --auxcflags` 65 | ROOTAUXLIBS=`$ROOTCONF --auxlibs` 66 | ROOTRPATH=$ROOTLIBDIR 67 | ROOTVERSION=`$ROOTCONF --version` 68 | ROOTSOVERSION=`dirname $ROOTVERSION` 69 | 70 | if test $1 ; then 71 | AC_MSG_CHECKING(wether ROOT version >= [$1]) 72 | vers=`$ROOTCONF --version | tr './' ' ' | awk 'BEGIN { FS = " "; } { printf "%d", ($''1 * 1000 + $''2) * 1000 + $''3;}'` 73 | requ=`echo $1 | tr './' ' ' | awk 'BEGIN { FS = " "; } { printf "%d", ($''1 * 1000 + $''2) * 1000 + $''3;}'` 74 | if test $vers -lt $requ ; then 75 | AC_MSG_RESULT(no) 76 | no_root="yes" 77 | else 78 | AC_MSG_RESULT(yes) 79 | fi 80 | fi 81 | else 82 | # otherwise, we say no_root 83 | no_root="yes" 84 | fi 85 | 86 | AC_SUBST(ROOTLIBDIR) 87 | AC_SUBST(ROOTINCDIR) 88 | AC_SUBST(ROOTETCDIR) 89 | AC_SUBST(ROOTCFLAGS) 90 | AC_SUBST(ROOTLIBS) 91 | AC_SUBST(ROOTGLIBS) 92 | AC_SUBST(ROOTAUXLIBS) 93 | AC_SUBST(ROOTAUXCFLAGS) 94 | AC_SUBST(ROOTRPATH) 95 | AC_SUBST(ROOTVERSION) 96 | AC_SUBST(ROOTSOVERSION) 97 | 98 | if test "x$no_root" = "x" ; then 99 | ifelse([$2], , :, [$2]) 100 | else 101 | ifelse([$3], , :, [$3]) 102 | fi 103 | ]) 104 | 105 | # 106 | # Macro to check if ROOT has a specific feature: 107 | # 108 | # ROOT_FEATURE(FEATURE,[ACTION_IF_HAVE,[ACTION_IF_NOT]]) 109 | # 110 | # For example 111 | # 112 | # ROOT_FEATURE([ldap],[AC_DEFINE([HAVE_ROOT_LDAP])]) 113 | # 114 | AC_DEFUN([ROOT_FEATURE], 115 | [ 116 | AC_REQUIRE([ROOT_PATH]) 117 | feat=$1 118 | res=`$ROOTCONF --has-$feat` 119 | if test "x$res" = "xyes" ; then 120 | ifelse([$2], , :, [$2]) 121 | else 122 | ifelse([$3], , :, [$3]) 123 | fi 124 | ]) 125 | 126 | # 127 | # EOF 128 | # 129 | -------------------------------------------------------------------------------- /math/Makefile.am: -------------------------------------------------------------------------------- 1 | AUTOMAKE_OPTIONS = subdir-objects 2 | ACLOCAL_AMFLAGS = ${ACLOCAL_FLAGS} -I m4 3 | 4 | MATHROOT=$(dir $(MPREP)) 5 | 6 | 7 | EX_CFLAGS = $(OPENMP_CFLAGS) $(MR_CFLAGS) -I$(MATHROOT) -I$(top_srcdir)/tsil-1.3 -I$(top_srcdir)/mr -I$(top_srcdir)/Eigen 8 | 9 | noinst_PROGRAMS = mr 10 | 11 | mr_SOURCES = mrimpl.cpp 12 | 13 | nodist_mr_SOURCES = mr.cpp 14 | BUILT_SOURCES = mr.cpp 15 | 16 | mr_CPPFLAGS = $(EX_CFLAGS) 17 | mr_LDADD = $(OPENMP_CFLAGS) $(MR_LIBS) -L$(MATHROOT)$(ALTMATHPATH) ${LDMATH} -L$(top_srcdir)/mr -lmr -L$(top_srcdir)/tsil-1.3 -ltsil -lm 18 | 19 | mr.cpp: mr.tm 20 | $(MPREP) $? -o $@ 21 | 22 | EXTRA_DIST = mr.tm mr.m rge.m README 23 | -------------------------------------------------------------------------------- /math/README: -------------------------------------------------------------------------------- 1 | MathLink interface to C++ package 'mr' 2 | 3 | After successfull compilation executable 'mr' produced. 4 | 5 | To check correctness of installation run test file from the same directory 6 | 7 | $ math < mr.m 8 | 9 | It will produce something like: 10 | 11 | 1 + 185.3545315192623037 aEW[173] - 19207.76644304067410 aEW[173] + 563.188663413438646 aEW[173] aQCD[173] 12 | 13 | For examples on how to apply mathematica interface see examples in notebook 'mr-usage.nb' 14 | available from https://github.com/apik/mr/releases/download/v1.3.2/mr-usage.nb 15 | 16 | RGE equations needed for couplings evolution placed in file 'rge.m' 17 | -------------------------------------------------------------------------------- /math/mr.m: -------------------------------------------------------------------------------- 1 | link=Install["mr"]; 2 | 3 | mmWMMW[4.4, 80, 91, 125, 173, 173] -------------------------------------------------------------------------------- /mr.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@prefix@ 2 | exec_prefix=@exec_prefix@ 3 | libdir=@libdir@ 4 | includedir=@includedir@ 5 | 6 | Name: mr 7 | Description: Matching and Running 8 | Version: @VERSION@ 9 | 10 | Cflags: @OPENMP_CFLAGS@ -I${includedir} 11 | Libs: -L${libdir} -lmr -ltsil 12 | -------------------------------------------------------------------------------- /mr/Makefile.am: -------------------------------------------------------------------------------- 1 | AUTOMAKE_OPTIONS = subdir-objects 2 | ACLOCAL_AMFLAGS = ${ACLOCAL_FLAGS} -I m4 3 | 4 | lib_LIBRARIES = libmr.a 5 | 6 | # Main sources 7 | MAINSRC = mr.hpp tsil.hpp tsil.cpp base.hpp tdecl.hpp mOS2mMSQCD.cpp p2ms.hpp p2ms.cpp 8 | 9 | MAINHPP = constants.hpp sminput.hpp timer.hpp tsil.hpp dr.hpp operators.hpp logger.hpp 10 | 11 | # Running 12 | RUNSRC = smRGE.hpp smRGE.cpp alphas.hpp alphas.cpp 13 | 14 | 15 | # alpha from G-Fermi and pole masses 16 | ALPHAGF = alphaGF.hpp alphaGF.cpp aGF/alphaGF10.cpp aGF/alphaGF11.cpp aGF/alphaGF20.cpp 17 | 18 | 19 | # 20 | # MS-bar masses and constants 21 | # 22 | BBMS = bb.hpp bb.cpp mMSmOS/mbbbar01.cpp mMSmOS/mbbbar10.cpp mMSmOS/mbbbar11.cpp mMSmOS/mbbbar20.cpp yu/yubb01.cpp yu/yubb10.cpp yu/yubb11.cpp yu/yubb20.cpp 23 | WWMS = WW.hpp WW.cpp mMSmOS/mWWbar10.cpp mMSmOS/mWWbar11.cpp mMSmOS/mWWbar20.cpp yu/yuWW10.cpp yu/yuWW11.cpp yu/yuWW20.cpp 24 | ZZMS = ZZ.hpp ZZ.cpp mMSmOS/mZZbar10.cpp mMSmOS/mZZbar11.cpp mMSmOS/mZZbar20.cpp yu/yuZZ10.cpp yu/yuZZ11.cpp yu/yuZZ20.cpp 25 | HHMS = HH.hpp HH.cpp mMSmOS/mHHbar10.cpp mMSmOS/mHHbar11.cpp mMSmOS/mHHbar20.cpp yu/yuHH10.cpp yu/yuHH11.cpp yu/yuHH20.cpp 26 | TTMS = tt.hpp tt.cpp mMSmOS/mttbar01.cpp mMSmOS/mttbar10.cpp mMSmOS/mttbar11.cpp mMSmOS/mttbar20.cpp yu/yutt01.cpp yu/yutt10.cpp yu/yutt11.cpp yu/yutt20.cpp 27 | 28 | # 29 | # Gauge-less limit 30 | # 31 | HHMSGL = gl/mHHbarGL10.cpp gl/mHHbarGL11.cpp gl/mHHbarGL20.cpp yugl/yuHHGL10.cpp yugl/yuHHGL11.cpp yugl/yuHHGL20.cpp 32 | BBMSGL = gl/mbbbarGL10.cpp gl/mbbbarGL11.cpp gl/mbbbarGL20.cpp yugl/yubbGL10.cpp yugl/yubbGL11.cpp yugl/yubbGL20.cpp 33 | TTMSGL = gl/mttbarGL10.cpp gl/mttbarGL11.cpp gl/mttbarGL20.cpp yugl/yuttGL10.cpp yugl/yuttGL11.cpp yugl/yuttGL20.cpp 34 | 35 | # 36 | # delta-r in MS-bar scheme with OS input 37 | # 38 | DRMSOS = dr.cpp dr/dr10.cpp dr/dr11.cpp dr/dr20.cpp dr/drgl10.cpp dr/drgl11.cpp dr/drgl20.cpp 39 | 40 | # 41 | # delta-r in MS-bar scheme with MS-bar input 42 | # 43 | DRMSMS = dr/drbar10.cpp dr/drbar11.cpp dr/drbar20.cpp 44 | 45 | # W pole mass from MS input 46 | WWMS2OS = mOSmMS/mWWos10.cpp mOSmMS/mWWos11.cpp mOSmMS/mWWos20.cpp 47 | # Z pole mass from MS input 48 | ZZMS2OS = mOSmMS/mZZos10.cpp mOSmMS/mZZos11.cpp mOSmMS/mZZos20.cpp 49 | # H pole mass from MS input 50 | HHMS2OS = mOSmMS/mHHos10.cpp mOSmMS/mHHos11.cpp mOSmMS/mHHos20.cpp 51 | # t pole mass from MS input 52 | TTMS2OS = mOSmMS/mttos01.cpp mOSmMS/mttos10.cpp mOSmMS/mttos11.cpp mOSmMS/mttos20.cpp 53 | # b pole mass from MS input 54 | BBMS2OS = mOSmMS/mbbos01.cpp mOSmMS/mbbos10.cpp mOSmMS/mbbos11.cpp mOSmMS/mbbos20.cpp 55 | 56 | 57 | libmr_a_SOURCES = $(MAINSRC) $(MAINHPP) $(ALPHAGF) $(RUNSRC) $(BBMS) $(WWMS) $(ZZMS) $(HHMS) $(TTMS)\ 58 | $(HHMSGL) $(BBMSGL) $(TTMSGL) $(DRMSOS) $(DRMSMS)\ 59 | $(WWMS2OS) $(ZZMS2OS) $(HHMS2OS) $(TTMS2OS) $(BBMS2OS) 60 | 61 | libmr_a_CPPFLAGS = $(MR_CFLAGS) -I$(top_srcdir)/tsil-1.3 $(OPENMP_CFLAGS) 62 | 63 | EXTRA_DIST = aGF/README dr/README gl/README mMSmOS/README mOSmMS/README yu/README yugl/README 64 | 65 | pkginclude_HEADERS = \ 66 | HH.hpp \ 67 | WW.hpp \ 68 | ZZ.hpp \ 69 | alphaGF.hpp \ 70 | alphas.hpp \ 71 | base.hpp \ 72 | bb.hpp \ 73 | constants.hpp \ 74 | dr.hpp \ 75 | logger.hpp \ 76 | mr.hpp \ 77 | operators.hpp \ 78 | p2ms.hpp \ 79 | smRGE.hpp \ 80 | sminput.hpp \ 81 | tdecl.hpp \ 82 | timer.hpp \ 83 | tsil.hpp \ 84 | tt.hpp 85 | 86 | 87 | 88 | -------------------------------------------------------------------------------- /mr/WW.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MR - 2-loop matching and 3-loop Running, including full 2-loop EW corrections 3 | // Copyright (C) 2014 Andrey Pikelner 4 | // 5 | // This file is part of MR. 6 | // 7 | // MR is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // (at your option) any later version. 11 | // 12 | // MR is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with MR. If not, see . 19 | // 20 | 21 | #ifndef __WW_HPP__ 22 | #define __WW_HPP__ 23 | 24 | #include "tsil.hpp" 25 | #include "sminput.hpp" 26 | #include "operators.hpp" 27 | #include "constants.hpp" 28 | #include "base.hpp" 29 | 30 | namespace mr 31 | { 32 | template 33 | class WW 34 | { 35 | }; 36 | 37 | 38 | template<> 39 | class WW : public PoleMassAndCouplings 40 | { 41 | 42 | double MMb, MMt, MMH, MMW, MMZ, mu2; 43 | double SW, CW; 44 | 45 | std::unique_ptr protWHHWW; 46 | std::unique_ptr protWHZWW; 47 | std::unique_ptr protWZZWW; 48 | std::unique_ptr protWWHHH; 49 | std::unique_ptr protWWHZZ; 50 | std::unique_ptr protWWZZH; 51 | std::unique_ptr protWtZ00; 52 | std::unique_ptr protW0HWW; 53 | std::unique_ptr protW0Htt; 54 | std::unique_ptr protW0ZWW; 55 | std::unique_ptr protW0Ztt; 56 | std::unique_ptr protW0Z00; 57 | std::unique_ptr prot0WW0W; 58 | std::unique_ptr prot0Wt0t; 59 | std::unique_ptr prot0W0Z0; 60 | std::unique_ptr prot00Wt0; 61 | std::unique_ptr prot00W00; 62 | std::unique_ptr prot00ttZ; 63 | std::unique_ptr prot00tt0; 64 | std::unique_ptr prot0000Z; 65 | std::unique_ptr prot00000; 66 | std::unique_ptr protWH0H; 67 | std::unique_ptr protWZ0Z; 68 | std::unique_ptr protHW00; 69 | 70 | public: 71 | WW() 72 | { 73 | } 74 | 75 | WW(double,double,double,double,double); 76 | 77 | WW(OSinput, double); 78 | 79 | void init(); 80 | 81 | 82 | // Pole -> MS 83 | 84 | double x10(size_t nL = 2, size_t nH = 1, size_t boson = 1); 85 | 86 | 87 | double x11(size_t nL = 2, size_t nH = 1, size_t boson = 1); 88 | 89 | 90 | double x20(size_t nL = 2, size_t nH = 1, size_t boson = 1); 91 | 92 | 93 | // Yukawa 94 | double y10(size_t nL = 2, size_t nH = 1, size_t boson = 1); 95 | 96 | 97 | double y11(size_t nL = 2, size_t nH = 1, size_t boson = 1); 98 | 99 | 100 | double y20(size_t nL = 2, size_t nH = 1, size_t boson = 1); 101 | 102 | }; 103 | 104 | 105 | template<> 106 | class WW : public BaseMass 107 | { 108 | 109 | double mmb, mmt, mmH, mmW, mmZ, mu2; 110 | double s, c; 111 | 112 | std::unique_ptr protWHHWW; 113 | std::unique_ptr protWHZWW; 114 | std::unique_ptr protWZZWW; 115 | std::unique_ptr protWWHHH; 116 | std::unique_ptr protWWHZZ; 117 | std::unique_ptr protWWZZH; 118 | std::unique_ptr protWtZ00; 119 | std::unique_ptr protW0HWW; 120 | std::unique_ptr protW0Htt; 121 | std::unique_ptr protW0ZWW; 122 | std::unique_ptr protW0Ztt; 123 | std::unique_ptr protW0Z00; 124 | std::unique_ptr prot0WW0W; 125 | std::unique_ptr prot0Wt0t; 126 | std::unique_ptr prot0W0Z0; 127 | std::unique_ptr prot00Wt0; 128 | std::unique_ptr prot00W00; 129 | std::unique_ptr prot00ttZ; 130 | std::unique_ptr prot00tt0; 131 | std::unique_ptr prot0000Z; 132 | std::unique_ptr prot00000; 133 | std::unique_ptr protWH0H; 134 | std::unique_ptr protWZ0Z; 135 | std::unique_ptr protHW00; 136 | 137 | public: 138 | WW() 139 | { 140 | } 141 | 142 | WW(double,double,double,double,double); 143 | 144 | WW(MSinput, double); 145 | 146 | void init(); 147 | 148 | // Pole -> MS 149 | 150 | double x10(size_t nL = 2, size_t nH = 1, size_t boson = 1); 151 | 152 | 153 | double x11(size_t nL = 2, size_t nH = 1, size_t boson = 1); 154 | 155 | 156 | double x20(size_t nL = 2, size_t nH = 1, size_t boson = 1); 157 | 158 | 159 | }; 160 | } // namespace mr 161 | 162 | #endif // __WW_HPP__ 163 | -------------------------------------------------------------------------------- /mr/ZZ.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MR - 2-loop matching and 3-loop Running, including full 2-loop EW corrections 3 | // Copyright (C) 2014 Andrey Pikelner 4 | // 5 | // This file is part of MR. 6 | // 7 | // MR is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // (at your option) any later version. 11 | // 12 | // MR is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with MR. If not, see . 19 | // 20 | 21 | #ifndef __ZZ_HPP__ 22 | #define __ZZ_HPP__ 23 | 24 | #include "tsil.hpp" 25 | #include "sminput.hpp" 26 | #include "operators.hpp" 27 | #include "constants.hpp" 28 | #include "base.hpp" 29 | 30 | namespace mr 31 | { 32 | template 33 | class ZZ 34 | { 35 | }; 36 | 37 | template<> 38 | class ZZ : public PoleMassAndCouplings 39 | { 40 | 41 | double MMb, MMt, MMH, MMW, MMZ, mu2; 42 | double SW, CW; 43 | 44 | std::unique_ptr protZHHZZ; 45 | std::unique_ptr protZZHHH; 46 | std::unique_ptr protZWHWW; 47 | std::unique_ptr prottZtHt; 48 | std::unique_ptr protWWWWH; 49 | std::unique_ptr protWWWWZ; 50 | std::unique_ptr protWWWW0; 51 | std::unique_ptr protWtWt0; 52 | std::unique_ptr protW0W0t; 53 | std::unique_ptr protW0W00; 54 | std::unique_ptr protttttH; 55 | std::unique_ptr protttttZ; 56 | std::unique_ptr prottttt0; 57 | std::unique_ptr prott0t0W; 58 | std::unique_ptr prot0000Z; 59 | std::unique_ptr prot0000W; 60 | std::unique_ptr prot00000; 61 | std::unique_ptr protWZWHW; 62 | std::unique_ptr protHZ00; 63 | 64 | 65 | public: 66 | ZZ() 67 | { 68 | } 69 | 70 | ZZ(double,double,double,double,double); 71 | 72 | ZZ(OSinput, double); 73 | 74 | void init(); 75 | 76 | double x10(size_t nL = 2, size_t nH = 1, size_t boson = 1); 77 | 78 | 79 | double x11(size_t nL = 2, size_t nH = 1, size_t boson = 1); 80 | 81 | 82 | double x20(size_t nL = 2, size_t nH = 1, size_t boson = 1); 83 | 84 | 85 | double y10(size_t nL = 2, size_t nH = 1, size_t boson = 1); 86 | 87 | 88 | double y11(size_t nL = 2, size_t nH = 1, size_t boson = 1); 89 | 90 | 91 | double y20(size_t nL = 2, size_t nH = 1, size_t boson = 1); 92 | 93 | }; 94 | 95 | template<> 96 | class ZZ : public BaseMass 97 | { 98 | 99 | double mmb, mmt, mmH, mmW, mmZ, mu2; 100 | double s, c; 101 | 102 | std::unique_ptr protZHHZZ; 103 | std::unique_ptr protZZHHH; 104 | std::unique_ptr protZWHWW; 105 | std::unique_ptr prottZtHt; 106 | std::unique_ptr protWWWWH; 107 | std::unique_ptr protWWWWZ; 108 | std::unique_ptr protWWWW0; 109 | std::unique_ptr protWtWt0; 110 | std::unique_ptr protW0W0t; 111 | std::unique_ptr protW0W00; 112 | std::unique_ptr protttttH; 113 | std::unique_ptr protttttZ; 114 | std::unique_ptr prottttt0; 115 | std::unique_ptr prott0t0W; 116 | std::unique_ptr prot0000Z; 117 | std::unique_ptr prot0000W; 118 | std::unique_ptr prot00000; 119 | std::unique_ptr protWZWHW; 120 | std::unique_ptr protHZ00; 121 | 122 | public: 123 | ZZ() 124 | { 125 | } 126 | 127 | ZZ(double,double,double,double,double); 128 | 129 | ZZ(MSinput, double); 130 | 131 | void init(); 132 | 133 | 134 | double x10(size_t nL = 2, size_t nH = 1, size_t boson = 1); 135 | 136 | 137 | double x11(size_t nL = 2, size_t nH = 1, size_t boson = 1); 138 | 139 | 140 | double x20(size_t nL = 2, size_t nH = 1, size_t boson = 1); 141 | 142 | 143 | }; 144 | } // namespace mr 145 | 146 | #endif // __ZZ_HPP__ 147 | -------------------------------------------------------------------------------- /mr/aGF/README: -------------------------------------------------------------------------------- 1 | 2 | running EM constant in terms of pole masses and Fermi constant 3 | 4 | M - is an on-shell mass 5 | 6 | m(mu) - runnig MS mass 7 | 8 | a_ij - functions of OS masses 9 | 10 | aw(mu) - EM running coupling (alEM/4/Pi) 11 | 12 | as(mu) - QCD running coupling (alS/4/Pi) 13 | 14 | aw(mu) = awBorn (1 + aw*a_10 + aw*as*a_11 + aw^2*a_20 + ...) 15 | -------------------------------------------------------------------------------- /mr/alphaGF.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MR - 2-loop matching and 3-loop Running, including full 2-loop EW corrections 3 | // Copyright (C) 2014 Andrey Pikelner 4 | // 5 | // This file is part of MR. 6 | // 7 | // MR is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // (at your option) any later version. 11 | // 12 | // MR is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with MR. If not, see . 19 | // 20 | 21 | #ifndef __ALPHAGF_HPP__ 22 | #define __ALPHAGF_HPP__ 23 | 24 | #include "tsil.hpp" 25 | #include "sminput.hpp" 26 | #include "operators.hpp" 27 | #include "constants.hpp" 28 | #include "base.hpp" 29 | 30 | namespace mr 31 | { 32 | class alphaGF 33 | { 34 | 35 | double MMb, MMt, MMH, MMW, MMZ, mu2; 36 | double SW, CW; 37 | 38 | std::unique_ptr WprotWHHWW; 39 | std::unique_ptr WprotWHZWW; 40 | std::unique_ptr WprotWZZWW; 41 | std::unique_ptr WprotWWHHH; 42 | std::unique_ptr WprotWWHZZ; 43 | std::unique_ptr WprotWWZZH; 44 | std::unique_ptr WprotWtZ00; 45 | std::unique_ptr WprotW0HWW; 46 | std::unique_ptr WprotW0Htt; 47 | std::unique_ptr WprotW0ZWW; 48 | std::unique_ptr WprotW0Ztt; 49 | std::unique_ptr WprotW0Z00; 50 | std::unique_ptr Wprot0WW0W; 51 | std::unique_ptr Wprot0Wt0t; 52 | std::unique_ptr Wprot0W0Z0; 53 | std::unique_ptr Wprot00Wt0; 54 | std::unique_ptr Wprot00W00; 55 | std::unique_ptr Wprot00ttZ; 56 | std::unique_ptr Wprot00tt0; 57 | std::unique_ptr Wprot0000Z; 58 | std::unique_ptr Wprot00000; 59 | std::unique_ptr WprotHW00; 60 | std::unique_ptr WprotWH0H; 61 | std::unique_ptr WprotWZ0Z; 62 | 63 | 64 | // ZZ part 65 | std::unique_ptr ZprotZHHZZ; 66 | std::unique_ptr ZprotZZHHH; 67 | std::unique_ptr ZprotZWHWW; 68 | std::unique_ptr ZprottZtHt; 69 | std::unique_ptr ZprotWWWWH; 70 | std::unique_ptr ZprotWWWWZ; 71 | std::unique_ptr ZprotWWWW0; 72 | std::unique_ptr ZprotWtWt0; 73 | std::unique_ptr ZprotW0W0t; 74 | std::unique_ptr ZprotW0W00; 75 | std::unique_ptr ZprotttttH; 76 | std::unique_ptr ZprotttttZ; 77 | std::unique_ptr Zprottttt0; 78 | std::unique_ptr Zprott0t0W; 79 | std::unique_ptr Zprot0000Z; 80 | std::unique_ptr Zprot0000W; 81 | std::unique_ptr Zprot00000; 82 | std::unique_ptr ZprotWZWHW; 83 | std::unique_ptr ZprotHZ00; 84 | 85 | public: 86 | alphaGF() 87 | { 88 | } 89 | 90 | alphaGF(double,double,double,double,double); 91 | 92 | alphaGF(OSinput, double); 93 | 94 | void init(); 95 | 96 | 97 | double a10(size_t nL = 2, size_t nH = 1, size_t boson = 1); 98 | 99 | 100 | double a11(size_t nL = 2, size_t nH = 1, size_t boson = 1); 101 | 102 | 103 | double a20(size_t nL = 2, size_t nH = 1, size_t boson = 1); 104 | }; 105 | } // namespace mr 106 | 107 | #endif // __ALPHAGF_HPP__ 108 | -------------------------------------------------------------------------------- /mr/bb.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // MR - 2-loop matching and 3-loop Running, including full 2-loop EW corrections 3 | // Copyright (C) 2014 Andrey Pikelner 4 | // 5 | // This file is part of MR. 6 | // 7 | // MR is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // (at your option) any later version. 11 | // 12 | // MR is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with MR. If not, see . 19 | // 20 | 21 | #include 22 | #include "timer.hpp" 23 | 24 | 25 | namespace mr 26 | { 27 | bb::bb(double MMb_, double MMW_,double MMZ_,double MMH_,double MMt_,double mu2_): 28 | MMb(MMb_), MMW(MMW_), MMZ(MMZ_), MMH(MMH_), MMt(MMt_), mu2(mu2_) 29 | { 30 | init(MMb, MMW, MMZ, MMH, MMt, mu2); 31 | } 32 | 33 | bb::bb(OSinput sm, double mu2_) 34 | { 35 | MMb = sm.MMb(); 36 | MMW = sm.MMW(); 37 | MMZ = sm.MMZ(); 38 | MMH = sm.MMH(); 39 | MMt = sm.MMt(); 40 | mu2 = mu2_; 41 | 42 | init(sm.MMb(),sm.MMW(), sm.MMZ(), sm.MMH(), sm.MMt(), mu2_); 43 | } 44 | 45 | 46 | void bb::init(double MMb_, double MMW_,double MMZ_,double MMH_,double MMt_,double mu2_) 47 | { 48 | 49 | CW = sqrt(MMW/MMZ); 50 | SW = sqrt(1-MMW/MMZ); 51 | 52 | this->prot0bb0b = std::unique_ptr(new Tsil( 0, MMb, MMb, 0, MMb, mu2)); 53 | 54 | Timer t; 55 | prot0bb0b->evaluate(MMb); 56 | t.elapsed(); 57 | 58 | } 59 | 60 | bb::bb(MSinput sm, double mu2_) 61 | { 62 | mmb = sm.mmb(); 63 | mmW = sm.mmW(); 64 | mmZ = sm.mmZ(); 65 | mmH = sm.mmH(); 66 | mmt = sm.mmt(); 67 | mu2 = mu2_; 68 | 69 | init(); 70 | } 71 | 72 | 73 | void bb::init() 74 | { 75 | 76 | c = sqrt(mmW/mmZ); 77 | s = sqrt(1-mmW/mmZ); 78 | 79 | prot0bb0b = std::unique_ptr(new Tsil( 0, mmb, mmb, 0, mmb, mu2)); 80 | Timer t; 81 | prot0bb0b->evaluate(mmb); 82 | t.elapsed(); 83 | } 84 | } // namespace mr 85 | -------------------------------------------------------------------------------- /mr/dr.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // MR - 2-loop matching and 3-loop Running, including full 2-loop EW corrections 3 | // Copyright (C) 2014 Andrey Pikelner 4 | // 5 | // This file is part of MR. 6 | // 7 | // MR is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // (at your option) any later version. 11 | // 12 | // MR is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with MR. If not, see . 19 | // 20 | 21 | #include 22 | #include "timer.hpp" 23 | 24 | 25 | namespace mr 26 | { 27 | dr::dr(OSinput sm, double mu2_) 28 | { 29 | MMb = sm.MMb(); 30 | MMW = sm.MMW(); 31 | MMZ = sm.MMZ(); 32 | MMH = sm.MMH(); 33 | MMt = sm.MMt(); 34 | mu2 = mu2_; 35 | 36 | init(); 37 | } 38 | 39 | 40 | void dr::init() 41 | { 42 | 43 | CW = sqrt(MMW/MMZ); 44 | SW = sqrt(1-MMW/MMZ); 45 | 46 | } 47 | 48 | dr::dr(MSinput sm, double mu2_) 49 | { 50 | mmb = sm.mmb(); 51 | mmW = sm.mmW(); 52 | mmZ = sm.mmZ(); 53 | mmH = sm.mmH(); 54 | mmt = sm.mmt(); 55 | mu2 = mu2_; 56 | 57 | init(); 58 | } 59 | 60 | 61 | void dr::init() 62 | { 63 | 64 | c = sqrt(mmW/mmZ); 65 | s = sqrt(1-mmW/mmZ); 66 | 67 | } 68 | } // namespace mr 69 | -------------------------------------------------------------------------------- /mr/dr.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MR - 2-loop matching and 3-loop Running, including full 2-loop EW corrections 3 | // Copyright (C) 2014 Andrey Pikelner 4 | // 5 | // This file is part of MR. 6 | // 7 | // MR is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // (at your option) any later version. 11 | // 12 | // MR is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with MR. If not, see . 19 | // 20 | 21 | #ifndef __DR_HPP__ 22 | #define __DR_HPP__ 23 | 24 | #include "tsil.hpp" 25 | #include "sminput.hpp" 26 | #include "operators.hpp" 27 | #include "constants.hpp" 28 | 29 | namespace mr 30 | { 31 | template 32 | class dr 33 | { 34 | }; 35 | 36 | template<> 37 | class dr 38 | { 39 | 40 | double MMb,MMt, MMH, MMW, MMZ, mu2; 41 | double SW, CW; 42 | 43 | 44 | public: 45 | dr() 46 | { 47 | } 48 | 49 | dr(double,double,double,double,double); 50 | 51 | dr(OSinput, double); 52 | 53 | void init(); 54 | 55 | // 56 | // Delta-r 57 | // 58 | double dr10(size_t nL = 2, size_t nH = 1, size_t boson = 1); 59 | 60 | double dr11(size_t nL = 2, size_t nH = 1, size_t boson = 1); 61 | 62 | double dr20(size_t nL = 2, size_t nH = 1, size_t boson = 1); 63 | 64 | 65 | // Gaugeless limit 66 | double drgl10(size_t nL = 2, size_t nH = 1, size_t boson = 1); 67 | 68 | double drgl11(size_t nL = 2, size_t nH = 1, size_t boson = 1); 69 | 70 | double drgl20(size_t nL = 2, size_t nH = 1, size_t boson = 1); 71 | 72 | 73 | }; 74 | 75 | 76 | template<> 77 | class dr 78 | { 79 | 80 | double mmb,mmt, mmH, mmW, mmZ, mu2; 81 | double s, c; 82 | 83 | 84 | public: 85 | dr() 86 | { 87 | } 88 | 89 | dr(double,double,double,double,double); 90 | 91 | dr(MSinput, double); 92 | 93 | void init(); 94 | 95 | // 96 | // Delta-r 97 | // 98 | double dr10(size_t nL = 2, size_t nH = 1, size_t boson = 1); 99 | 100 | double dr11(size_t nL = 2, size_t nH = 1, size_t boson = 1); 101 | 102 | double dr20(size_t nL = 2, size_t nH = 1, size_t boson = 1); 103 | 104 | }; 105 | } // namespace mr 106 | 107 | #endif // __DR_HPP__ 108 | -------------------------------------------------------------------------------- /mr/dr/README: -------------------------------------------------------------------------------- 1 | 2 | running vacuum expectation value (delta-r) in terms of OS and MS masses 3 | 4 | aw(mu) - EM running coupling (alEM/4/Pi) 5 | 6 | as(mu) - QCD running coupling (alS/4/Pi) 7 | 8 | DR_ij - functions of OS masses 9 | 10 | dr(mu) = awBorn (1 + aw*DR_10 + aw*as*DR_11 + aw^2*DR_20 + ...) 11 | 12 | dr_ij - functions of MS masses 13 | 14 | dr(mu) = awBorn (1 + aw*dr_10 + aw*as*dr_11 + aw^2*dr_20 + ...) 15 | 16 | 17 | -------------------------------------------------------------------------------- /mr/dr/dr10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double dr::dr10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex ardr[19], drret; 9 | 10 | ardr[1]=double(nH); 11 | ardr[2]=pow(CW,-1); 12 | ardr[3]=pow(MMZ,-1); 13 | ardr[4]=pow(SW,-1); 14 | ardr[5]=Tsil::A(MMt,mu2); 15 | ardr[6]=pow(MMH,-1); 16 | ardr[7]=double(boson); 17 | ardr[8]=Tsil::A(MMH,mu2); 18 | ardr[9]=Tsil::A(MMZ,mu2); 19 | ardr[10]=Tsil::A(MMW,mu2); 20 | ardr[11]=1/( - MMW + MMH); 21 | ardr[12]=MMZ*ardr[6]; 22 | ardr[13]=ardr[12] - 1./8.; 23 | ardr[14]=ardr[10] + 1./2.*ardr[9]; 24 | ardr[15]=ardr[6]*ardr[14]; 25 | ardr[16]=ardr[8] - ardr[10]; 26 | ardr[16]= - 1./4.*ardr[16]; 27 | ardr[16]=ardr[11]*ardr[16]; 28 | ardr[15]=ardr[16] + ardr[15] + ardr[13]; 29 | ardr[14]= - ardr[14] + 1./2.*ardr[8]; 30 | ardr[14]= - 1./4.*MMH + 3*ardr[14]; 31 | ardr[16]=1./2.*ardr[3]; 32 | ardr[14]=ardr[14]*ardr[16]; 33 | ardr[17]=pow(ardr[4],2); 34 | ardr[18]= - ardr[10] + ardr[9]; 35 | ardr[18]=ardr[3]*ardr[18]*ardr[17]; 36 | ardr[15]=3./4.*ardr[18] + 3*ardr[15] + ardr[14]; 37 | ardr[15]=ardr[15]*ardr[17]; 38 | ardr[18]=ardr[9]*ardr[6]; 39 | ardr[13]=ardr[14] + 3./2.*ardr[18] + ardr[13]; 40 | ardr[14]=pow(ardr[2],2); 41 | ardr[13]=ardr[13]*ardr[14]; 42 | ardr[12]=ardr[13] - 2*ardr[12] + ardr[15]; 43 | ardr[12]=ardr[7]*ardr[12]; 44 | ardr[13]= - ardr[17] - ardr[14]; 45 | ardr[14]=2*ardr[6]; 46 | ardr[14]=ardr[14]*ardr[5]; 47 | ardr[14]=ardr[14] - 1./4.; 48 | ardr[14]=ardr[14]*MMt*ardr[3]; 49 | ardr[15]=ardr[16]*ardr[5]; 50 | ardr[14]=ardr[14] - ardr[15]; 51 | ardr[13]=ardr[1]*ardr[14]*ardr[13]; 52 | 53 | drret = ardr[12] + 3*ardr[13]; 54 | return drret.real(); 55 | } 56 | } // namespace mr 57 | -------------------------------------------------------------------------------- /mr/dr/dr11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double dr::dr11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex ardr[13], drret; 9 | 10 | ardr[1]=double(nH); 11 | ardr[2]=pow(CW,-1); 12 | ardr[3]=pow(MMH,-1); 13 | ardr[4]=pow(MMZ,-1); 14 | ardr[5]=pow(SW,-1); 15 | ardr[6]=Tsil::I2(0,0,MMt,mu2); 16 | ardr[7]=Tsil::A(MMt,mu2); 17 | ardr[8]=pow(MMt,-1); 18 | ardr[9]=Tsil::Aeps(MMt,mu2); 19 | ardr[10]= - ardr[8] + 12*ardr[3]; 20 | ardr[11]=2*ardr[7]; 21 | ardr[10]=ardr[10]*ardr[11]; 22 | ardr[10]=ardr[10] - 5; 23 | ardr[10]=ardr[11]*ardr[10]; 24 | ardr[11]=ardr[9] - ardr[6]; 25 | ardr[12]=MMt*ardr[3]; 26 | ardr[12]= - 37./2. + 64*ardr[12]; 27 | ardr[12]=ardr[12]*MMt; 28 | ardr[10]=ardr[10] - ardr[12] - 4*ardr[11]; 29 | ardr[11]= - pow(ardr[2],2); 30 | ardr[12]= - pow(ardr[5],2); 31 | ardr[11]=ardr[11] + ardr[12]; 32 | 33 | drret = ardr[11]*ardr[10]*ardr[4]*ardr[1]; 34 | return drret.real(); 35 | } 36 | } //namespace mr 37 | -------------------------------------------------------------------------------- /mr/dr/drbar10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double dr::dr10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex ardrbar[22], drbarret; 9 | 10 | ardrbar[1]=double(nH); 11 | ardrbar[2]=pow(mmZ,-1); 12 | ardrbar[3]=pow(s,-1); 13 | ardrbar[4]=pow(c,-1); 14 | ardrbar[5]=Tsil::A(mmt,mu2); 15 | ardrbar[6]=pow(mmH,-1); 16 | ardrbar[7]=Tsil::A(mmb,mu2); 17 | ardrbar[8]=double(boson); 18 | ardrbar[9]=Tsil::A(mmW,mu2); 19 | ardrbar[10]=Tsil::A(mmZ,mu2); 20 | ardrbar[11]=Tsil::A(mmH,mu2); 21 | ardrbar[12]=1/( - mmb + mmt); 22 | ardrbar[13]=1/(mmH - mmW); 23 | ardrbar[14]=mmb*ardrbar[7]; 24 | ardrbar[15]=mmt*ardrbar[5]; 25 | ardrbar[14]=ardrbar[14] + ardrbar[15]; 26 | ardrbar[14]= - ardrbar[6]*ardrbar[14]; 27 | ardrbar[15]=ardrbar[5] + 1./2.*mmt; 28 | ardrbar[16]=ardrbar[7] + 1./2.*mmb - ardrbar[15]; 29 | ardrbar[16]= - ardrbar[12]*mmb*ardrbar[16]; 30 | ardrbar[14]=3./2.*ardrbar[16] + 6*ardrbar[14]; 31 | ardrbar[16]=pow(ardrbar[4],2); 32 | ardrbar[17]=pow(ardrbar[3],2); 33 | ardrbar[18]=ardrbar[16] + ardrbar[17]; 34 | ardrbar[18]=ardrbar[18]*ardrbar[1]; 35 | ardrbar[14]=ardrbar[18]*ardrbar[14]; 36 | ardrbar[19]= - ardrbar[9] + 1./2.*ardrbar[11]; 37 | ardrbar[20]=3./2.*ardrbar[10]; 38 | ardrbar[19]= - ardrbar[20] - 1./4.*mmH + 3*ardrbar[19]; 39 | ardrbar[21]= - ardrbar[9] + ardrbar[10]; 40 | ardrbar[21]=ardrbar[21]*ardrbar[17]; 41 | ardrbar[21]=3./2.*ardrbar[21] + ardrbar[19]; 42 | ardrbar[21]=ardrbar[21]*ardrbar[17]; 43 | ardrbar[19]=ardrbar[19]*ardrbar[16]; 44 | ardrbar[19]=ardrbar[19] + ardrbar[21]; 45 | ardrbar[19]=ardrbar[8]*ardrbar[19]; 46 | ardrbar[15]=ardrbar[15]*ardrbar[18]; 47 | ardrbar[15]=3*ardrbar[15] + ardrbar[19]; 48 | ardrbar[14]=1./2.*ardrbar[15] + ardrbar[14]; 49 | ardrbar[14]=ardrbar[2]*ardrbar[14]; 50 | ardrbar[15]=ardrbar[20] + mmZ; 51 | ardrbar[15]=ardrbar[15]*ardrbar[16]; 52 | ardrbar[17]=3*ardrbar[17]; 53 | ardrbar[18]=mmZ + ardrbar[9] + 1./2.*ardrbar[10]; 54 | ardrbar[18]=ardrbar[18]*ardrbar[17]; 55 | ardrbar[15]=ardrbar[18] - 2*mmZ + ardrbar[15]; 56 | ardrbar[15]=ardrbar[6]*ardrbar[15]; 57 | ardrbar[18]= - ardrbar[11] + ardrbar[9]; 58 | ardrbar[18]=ardrbar[13]*ardrbar[18]; 59 | ardrbar[18]= - 1./2. + ardrbar[18]; 60 | ardrbar[17]=ardrbar[18]*ardrbar[17]; 61 | ardrbar[16]= - 1./2.*ardrbar[16] + ardrbar[17]; 62 | ardrbar[15]=1./4.*ardrbar[16] + ardrbar[15]; 63 | ardrbar[15]=ardrbar[8]*ardrbar[15]; 64 | 65 | drbarret = ardrbar[14] + ardrbar[15]; 66 | return drbarret.real(); 67 | } 68 | } // namespace mr 69 | -------------------------------------------------------------------------------- /mr/dr/drbar11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double dr::dr11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex ardrbar[13], drbarret; 9 | 10 | ardrbar[1]=double(nH); 11 | ardrbar[2]=pow(mmZ,-1); 12 | ardrbar[3]=pow(mmH,-1); 13 | ardrbar[4]=pow(s,-1); 14 | ardrbar[5]=pow(c,-1); 15 | ardrbar[6]=Tsil::I2(0,0,mmt,mu2); 16 | ardrbar[7]=Tsil::A(mmt,mu2); 17 | ardrbar[8]=pow(mmt,-1); 18 | ardrbar[9]=Tsil::Aeps(mmt,mu2); 19 | ardrbar[10]=pow(ardrbar[5],2); 20 | ardrbar[11]=pow(ardrbar[4],2); 21 | ardrbar[10]=ardrbar[10] + ardrbar[11]; 22 | ardrbar[11]= - ardrbar[8] + 6*ardrbar[3]; 23 | ardrbar[12]=2*ardrbar[7]; 24 | ardrbar[11]=ardrbar[11]*ardrbar[12]; 25 | ardrbar[11]=ardrbar[11] - 1; 26 | ardrbar[11]=ardrbar[11]*ardrbar[7]; 27 | ardrbar[11]= - ardrbar[6] + ardrbar[11] + ardrbar[9]; 28 | ardrbar[12]=16*ardrbar[7] + 48*mmt; 29 | ardrbar[12]=ardrbar[3]*ardrbar[12]; 30 | ardrbar[12]= - 25./2. + ardrbar[12]; 31 | ardrbar[12]=ardrbar[12]*mmt; 32 | ardrbar[11]=ardrbar[12] + 4*ardrbar[11]; 33 | 34 | drbarret = ardrbar[11]*ardrbar[10]*ardrbar[2]*ardrbar[1]; 35 | return drbarret.real(); 36 | } 37 | } // namespace mr 38 | -------------------------------------------------------------------------------- /mr/dr/drgl10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double dr::drgl10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex ardrgl[9], drglret; 9 | 10 | ardrgl[1]=double(boson); 11 | ardrgl[2]=pow(SW,-1); 12 | ardrgl[3]=pow(MMW,-1); 13 | ardrgl[4]=Tsil::A(MMH,mu2); 14 | ardrgl[5]=Tsil::A(MMt,mu2); 15 | ardrgl[6]=pow(MMH,-1); 16 | ardrgl[7]=ardrgl[4] + MMt; 17 | ardrgl[8]=MMt*ardrgl[6]; 18 | ardrgl[8]=1./2. - 2*ardrgl[8]; 19 | ardrgl[8]=ardrgl[5]*ardrgl[8]; 20 | ardrgl[7]=1./4.*ardrgl[7] + ardrgl[8]; 21 | ardrgl[7]=3*ardrgl[7] - 1./8.*MMH; 22 | 23 | drglret = ardrgl[7]*ardrgl[3]*pow(ardrgl[2],2)*ardrgl[1]; 24 | return drglret.real(); 25 | } 26 | } // namespace mr 27 | -------------------------------------------------------------------------------- /mr/dr/drgl11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double dr::drgl11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex ardrgl[9], drglret; 9 | 10 | ardrgl[1]=double(boson); 11 | ardrgl[2]=pow(SW,-1); 12 | ardrgl[3]=pow(MMH,-1); 13 | ardrgl[4]=pow(MMW,-1); 14 | ardrgl[5]=Tsil::A(MMt,mu2); 15 | ardrgl[6]=pow(MMt,-1); 16 | ardrgl[7]=MMt*ardrgl[3]; 17 | ardrgl[8]=pow(Pi,2); 18 | ardrgl[7]=2./3.*ardrgl[8] - 29./2. + 64*ardrgl[7]; 19 | ardrgl[7]=MMt*ardrgl[7]; 20 | ardrgl[8]=ardrgl[6] - 8*ardrgl[3]; 21 | ardrgl[8]=ardrgl[5]*ardrgl[8]; 22 | ardrgl[8]=1 + ardrgl[8]; 23 | ardrgl[8]=ardrgl[5]*ardrgl[8]; 24 | ardrgl[7]=6*ardrgl[8] + ardrgl[7]; 25 | 26 | drglret = ardrgl[7]*ardrgl[4]*pow(ardrgl[2],2)*ardrgl[1]; 27 | return drglret.real(); 28 | } 29 | } // namespace mr 30 | -------------------------------------------------------------------------------- /mr/dr/drgl20.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double dr::drgl20(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex ardrgl[24], drglret; 9 | 10 | ardrgl[1]=double(boson); 11 | ardrgl[2]=pow(SW,-1); 12 | ardrgl[3]=pow(MMH,-1); 13 | ardrgl[4]=pow(MMW,-1); 14 | ardrgl[5]=Tsil::I2(MMH,MMt,MMt,mu2); 15 | ardrgl[6]=Tsil::I2(0,MMH,MMt,mu2); 16 | ardrgl[7]=Tsil::B(MMH,MMH,MMH,mu2); 17 | ardrgl[8]=Tsil::A(MMH,mu2); 18 | ardrgl[9]=Tsil::A(MMt,mu2); 19 | ardrgl[10]=Tsil::B(MMH,MMt,MMt,mu2); 20 | ardrgl[11]=Tsil::B(MMt,MMt,MMH,mu2); 21 | ardrgl[12]=std::real(Tsil::B(0,0,MMH,mu2)); 22 | ardrgl[13]=pow(MMt,-1); 23 | ardrgl[14]=std::real(Tsil::B(0,0,MMt,mu2)); 24 | ardrgl[15]=5*ardrgl[8]; 25 | ardrgl[16]=3./4.*ardrgl[8]; 26 | ardrgl[17]=ardrgl[9] - ardrgl[16]; 27 | ardrgl[17]=ardrgl[17]*ardrgl[15]; 28 | ardrgl[18]=pow(ardrgl[9],2); 29 | ardrgl[17]=11*ardrgl[18] + ardrgl[17]; 30 | ardrgl[17]=ardrgl[3]*ardrgl[17]; 31 | ardrgl[19]=ardrgl[14]*ardrgl[9]; 32 | ardrgl[17]=ardrgl[19] + ardrgl[17]; 33 | ardrgl[20]=3./2.*ardrgl[12]; 34 | ardrgl[21]=9./2.*ardrgl[7] + ardrgl[20] + 9./8.; 35 | ardrgl[21]=ardrgl[9]*ardrgl[21]; 36 | ardrgl[22]=ardrgl[10]*ardrgl[9]; 37 | ardrgl[16]=ardrgl[11]*ardrgl[16]; 38 | ardrgl[16]= - 9./8.*ardrgl[6] + 3*ardrgl[22] - 3./4.*ardrgl[5] + 39 | ardrgl[16] + ardrgl[8] + ardrgl[21] + 1./4.*ardrgl[17]; 40 | ardrgl[17]=pow(Pi,2); 41 | ardrgl[21]= - 3./32.*ardrgl[17] - 3./16.*ardrgl[10] - 1 + 5./16.* 42 | ardrgl[11]; 43 | ardrgl[21]=MMH*ardrgl[21]; 44 | ardrgl[16]=1./2.*ardrgl[16] + ardrgl[21]; 45 | ardrgl[15]= - 19./2.*ardrgl[9] - ardrgl[15]; 46 | ardrgl[21]=ardrgl[9] - 1./2.*ardrgl[8]; 47 | ardrgl[21]=ardrgl[11]*ardrgl[21]; 48 | ardrgl[23]=ardrgl[3]*pow(ardrgl[8],2); 49 | ardrgl[15]=3./8.*ardrgl[6] + 21./16.*ardrgl[23] + 9./4.*ardrgl[5] - 50 | ardrgl[19] + 1./4.*ardrgl[15] + 3*ardrgl[21]; 51 | ardrgl[15]=ardrgl[3]*ardrgl[15]; 52 | ardrgl[19]=3./4.*ardrgl[14] + 59./16. - 5*ardrgl[11]; 53 | ardrgl[21]=ardrgl[3]*ardrgl[9]; 54 | ardrgl[23]=5./4. - 4*ardrgl[21]; 55 | ardrgl[23]=ardrgl[10]*ardrgl[23]; 56 | ardrgl[15]=ardrgl[23] + 1./4.*ardrgl[19] + ardrgl[15]; 57 | ardrgl[19]=77./8. - ardrgl[14]; 58 | ardrgl[21]=ardrgl[11]*ardrgl[21]; 59 | ardrgl[19]= - 2*ardrgl[10] + 1./2.*ardrgl[19] - 12*ardrgl[21]; 60 | ardrgl[19]=3*ardrgl[19] + 29./32.*ardrgl[17]; 61 | ardrgl[19]=MMt*ardrgl[3]*ardrgl[19]; 62 | ardrgl[15]=ardrgl[19] + 3*ardrgl[15] + 35./64.*ardrgl[17]; 63 | ardrgl[15]=MMt*ardrgl[15]; 64 | ardrgl[15]=3*ardrgl[16] + ardrgl[15]; 65 | ardrgl[16]=pow(ardrgl[4],2); 66 | ardrgl[15]=MMt*ardrgl[16]*ardrgl[15]; 67 | ardrgl[19]=ardrgl[13]*ardrgl[18]; 68 | ardrgl[19]= - 3*ardrgl[19] - 11*ardrgl[8]; 69 | ardrgl[20]=ardrgl[8]*ardrgl[20]; 70 | ardrgl[19]=ardrgl[20] + 1./2.*ardrgl[19] - 3*ardrgl[5]; 71 | ardrgl[20]=ardrgl[7]*ardrgl[8]; 72 | ardrgl[19]=9./4.*ardrgl[20] + 3./2.*ardrgl[6] + 1./2.*ardrgl[19] - 73 | ardrgl[22]; 74 | ardrgl[20]=15./2.*ardrgl[12] + 131./4. - 243*S2; 75 | ardrgl[17]=45./8.*ardrgl[7] + 1./4.*ardrgl[20] + 1./3.*ardrgl[17]; 76 | ardrgl[17]=MMH*ardrgl[17]; 77 | ardrgl[17]=3*ardrgl[19] + ardrgl[17]; 78 | ardrgl[17]=MMH*ardrgl[17]; 79 | ardrgl[19]= - 5*ardrgl[9] + 9./2.*ardrgl[8]; 80 | ardrgl[19]=ardrgl[8]*ardrgl[19]; 81 | ardrgl[18]=ardrgl[18] + ardrgl[19]; 82 | ardrgl[17]=3./2.*ardrgl[18] + ardrgl[17]; 83 | ardrgl[16]=ardrgl[17]*ardrgl[16]; 84 | ardrgl[15]=1./8.*ardrgl[16] + ardrgl[15]; 85 | 86 | drglret = ardrgl[15]*pow(ardrgl[2],4)*ardrgl[1]; 87 | return drglret.real(); 88 | } 89 | } // namespace mr 90 | -------------------------------------------------------------------------------- /mr/gl/README: -------------------------------------------------------------------------------- 1 | 2 | MS running mass in terms of OS masses in gauge-less limit 3 | 4 | m(mu) - runnig MS mass 5 | 6 | M - is an on-shell mass 7 | 8 | X_ij - functions of OS masses 9 | 10 | aw(mu) - EM running coupling (alEM/4/Pi) 11 | 12 | as(mu) - QCD running coupling (alS/4/Pi) 13 | 14 | m = M (1 + as*X_01 + aw*X_10 + aw*as*X_11 + aw^2*X_20 + ...) 15 | -------------------------------------------------------------------------------- /mr/gl/mHHbarGL10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double HH::xgl10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armHHbarGL[12], mHHbarGLret; 9 | 10 | armHHbarGL[1]=double(boson); 11 | armHHbarGL[2]=Tsil::B(MMH,MMH,MMH,mu2); 12 | armHHbarGL[3]=pow(SW,-1); 13 | armHHbarGL[4]=pow(MMW,-1); 14 | armHHbarGL[5]=Tsil::B(MMt,MMt,MMH,mu2); 15 | armHHbarGL[6]=pow(MMH,-1); 16 | armHHbarGL[7]=Tsil::A(MMH,mu2); 17 | armHHbarGL[8]=Tsil::A(MMt,mu2); 18 | armHHbarGL[9]=std::real(Tsil::B(0,0,MMH,mu2)); 19 | armHHbarGL[10]= - MMt*armHHbarGL[5]; 20 | armHHbarGL[10]=armHHbarGL[10] - armHHbarGL[8]; 21 | armHHbarGL[11]=2*armHHbarGL[6]; 22 | armHHbarGL[10]=armHHbarGL[11]*armHHbarGL[10]; 23 | armHHbarGL[10]=1./2.*armHHbarGL[5] + armHHbarGL[10]; 24 | armHHbarGL[10]=MMt*armHHbarGL[10]; 25 | armHHbarGL[11]=3./2.*armHHbarGL[2] + 1./2.*armHHbarGL[9]; 26 | armHHbarGL[11]=MMH*armHHbarGL[11]; 27 | armHHbarGL[11]=armHHbarGL[7] + armHHbarGL[11]; 28 | armHHbarGL[10]=1./4.*armHHbarGL[11] + armHHbarGL[10]; 29 | 30 | mHHbarGLret = 3*armHHbarGL[10]*armHHbarGL[4]*pow(armHHbarGL[3],2) 31 | *armHHbarGL[1]; 32 | return mHHbarGLret.real(); 33 | } 34 | } // namespace mr 35 | -------------------------------------------------------------------------------- /mr/gl/mHHbarGL11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double HH::xgl11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armHHbarGL[18], mHHbarGLret; 9 | 10 | armHHbarGL[1]=double(boson); 11 | armHHbarGL[2]=pow(SW,-1); 12 | armHHbarGL[3]=pow(MMH,-1); 13 | armHHbarGL[4]=pow(MMW,-1); 14 | armHHbarGL[5]=Tsil::B(MMt,MMt,MMH,mu2); 15 | armHHbarGL[6]=Tsil::A(MMt,mu2); 16 | armHHbarGL[7]=Tsil::Beps(MMt,MMt,MMH,mu2); 17 | armHHbarGL[8]=Tsil::Aeps(MMt,mu2); 18 | armHHbarGL[9]=prottttt0->M(0); 19 | armHHbarGL[10]=prottttt0->Vxzuv(0); 20 | armHHbarGL[11]=prottttt0->Suxv(0); 21 | armHHbarGL[12]=armHHbarGL[3]*armHHbarGL[9]; 22 | armHHbarGL[13]=2*armHHbarGL[3]; 23 | armHHbarGL[14]=armHHbarGL[10]*armHHbarGL[13]; 24 | armHHbarGL[12]=armHHbarGL[12] + armHHbarGL[14]; 25 | armHHbarGL[12]=MMt*armHHbarGL[12]; 26 | armHHbarGL[14]= - 10 - 7*armHHbarGL[5]; 27 | armHHbarGL[14]=armHHbarGL[5]*armHHbarGL[14]; 28 | armHHbarGL[14]= - 9 + armHHbarGL[14]; 29 | armHHbarGL[14]=armHHbarGL[3]*armHHbarGL[14]; 30 | armHHbarGL[15]=4*armHHbarGL[3]; 31 | armHHbarGL[16]=armHHbarGL[7]*armHHbarGL[15]; 32 | armHHbarGL[12]=8*armHHbarGL[12] + armHHbarGL[16] - 4*armHHbarGL[10] 33 | - 6*armHHbarGL[9] + armHHbarGL[14]; 34 | armHHbarGL[12]=MMt*armHHbarGL[12]; 35 | armHHbarGL[14]=MMH*armHHbarGL[9]; 36 | armHHbarGL[12]=armHHbarGL[14] + armHHbarGL[12]; 37 | armHHbarGL[14]=armHHbarGL[5]*armHHbarGL[6]; 38 | armHHbarGL[16]=12*armHHbarGL[8] - 36*armHHbarGL[14]; 39 | armHHbarGL[16]=armHHbarGL[3]*armHHbarGL[16]; 40 | armHHbarGL[17]=4 + 3*armHHbarGL[5]; 41 | armHHbarGL[17]=armHHbarGL[5]*armHHbarGL[17]; 42 | armHHbarGL[13]= - armHHbarGL[11]*armHHbarGL[13]; 43 | armHHbarGL[12]=armHHbarGL[13] + 12 + armHHbarGL[17] + 2* 44 | armHHbarGL[12] + armHHbarGL[16]; 45 | armHHbarGL[12]=MMt*armHHbarGL[12]; 46 | armHHbarGL[13]= - pow(armHHbarGL[6],2)*armHHbarGL[15]; 47 | armHHbarGL[13]=armHHbarGL[14] + armHHbarGL[13]; 48 | armHHbarGL[12]=6*armHHbarGL[13] + armHHbarGL[12]; 49 | 50 | mHHbarGLret = 2*armHHbarGL[12]*armHHbarGL[4]*pow(armHHbarGL[2],2) 51 | *armHHbarGL[1]; 52 | return mHHbarGLret.real(); 53 | } 54 | } // namespace mr 55 | -------------------------------------------------------------------------------- /mr/gl/mbbbarGL01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | double bb::xgl01(size_t nL, size_t nH, size_t boson) 3 | { 4 | 5 | 6 | std::complex armbbbarGL[5], mbbbarGLret; 7 | 8 | armbbbarGL[1]=double(boson); 9 | armbbbarGL[2]=Tsil::A(mmb,mu2); 10 | armbbbarGL[3]=pow(mmb,-1); 11 | armbbbarGL[4]=armbbbarGL[3]*armbbbarGL[2]; 12 | armbbbarGL[4]= - 1./3. + armbbbarGL[4]; 13 | 14 | mbbbarGLret = 4*armbbbarGL[4]*armbbbarGL[1]; 15 | return mbbbarGLret.real(); 16 | } 17 | -------------------------------------------------------------------------------- /mr/gl/mbbbarGL10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double bb::xgl10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armbbbarGL[9], mbbbarGLret; 9 | 10 | armbbbarGL[1]=double(boson); 11 | armbbbarGL[2]=pow(SW,-1); 12 | armbbbarGL[3]=pow(MMW,-1); 13 | armbbbarGL[4]=Tsil::A(MMH,mu2); 14 | armbbbarGL[5]=Tsil::A(MMt,mu2); 15 | armbbbarGL[6]=pow(MMH,-1); 16 | armbbbarGL[7]=armbbbarGL[5] + armbbbarGL[4]; 17 | armbbbarGL[8]=armbbbarGL[6]*armbbbarGL[5]; 18 | armbbbarGL[8]=1./16. - 3*armbbbarGL[8]; 19 | armbbbarGL[8]=MMt*armbbbarGL[8]; 20 | armbbbarGL[7]=3./8.*armbbbarGL[7] + armbbbarGL[8]; 21 | 22 | mbbbarGLret = armbbbarGL[7]*armbbbarGL[3]*pow(armbbbarGL[2],2)* 23 | armbbbarGL[1]; 24 | return mbbbarGLret.real(); 25 | } 26 | } // namespace mr 27 | -------------------------------------------------------------------------------- /mr/gl/mbbbarGL11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double bb::xgl11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armbbbarGL[18], mbbbarGLret; 9 | 10 | armbbbarGL[1]=double(boson); 11 | armbbbarGL[2]=pow(SW,-1); 12 | armbbbarGL[3]=pow(MMH,-1); 13 | armbbbarGL[4]=pow(MMW,-1); 14 | armbbbarGL[5]=Tsil::I2(0,0,MMt,mu2); 15 | armbbbarGL[6]=Tsil::A(MMH,mu2); 16 | armbbbarGL[7]=Tsil::A(MMb,mu2); 17 | armbbbarGL[8]=pow(MMb,-1); 18 | armbbbarGL[9]=Tsil::A(MMt,mu2); 19 | armbbbarGL[10]=pow(MMt,-1); 20 | armbbbarGL[11]=Tsil::Aeps(MMt,mu2); 21 | armbbbarGL[12]=Tsil::Aeps(MMb,mu2); 22 | armbbbarGL[13]=pow(MMt,2); 23 | armbbbarGL[14]=armbbbarGL[8]*armbbbarGL[7]; 24 | armbbbarGL[15]=3*armbbbarGL[14]; 25 | armbbbarGL[16]=armbbbarGL[15] - 1; 26 | armbbbarGL[17]= - MMt*armbbbarGL[16]; 27 | armbbbarGL[17]=armbbbarGL[17] - 6*armbbbarGL[9]; 28 | armbbbarGL[17]=armbbbarGL[9]*armbbbarGL[17]; 29 | armbbbarGL[13]=8*armbbbarGL[13] + armbbbarGL[17]; 30 | armbbbarGL[13]=armbbbarGL[3]*armbbbarGL[13]; 31 | armbbbarGL[13]= - armbbbarGL[5] + armbbbarGL[13] + armbbbarGL[11]; 32 | armbbbarGL[17]= - armbbbarGL[9]*armbbbarGL[10]; 33 | armbbbarGL[15]=armbbbarGL[17] + 13 + armbbbarGL[15]; 34 | armbbbarGL[15]=armbbbarGL[9]*armbbbarGL[15]; 35 | armbbbarGL[16]=armbbbarGL[6]*armbbbarGL[16]; 36 | armbbbarGL[15]=armbbbarGL[16] + armbbbarGL[15]; 37 | armbbbarGL[16]=armbbbarGL[8]*pow(armbbbarGL[7],2); 38 | armbbbarGL[14]= - 103./3. + armbbbarGL[14]; 39 | armbbbarGL[14]=MMt*armbbbarGL[14]; 40 | armbbbarGL[13]=1./4.*armbbbarGL[14] - 5./2.*armbbbarGL[16] + 5* 41 | armbbbarGL[12] + 1./2.*armbbbarGL[15] + 4*armbbbarGL[13]; 42 | 43 | mbbbarGLret = armbbbarGL[13]*armbbbarGL[4]*pow(armbbbarGL[2],2)* 44 | armbbbarGL[1]; 45 | return mbbbarGLret.real(); 46 | } 47 | } // namespace mr 48 | -------------------------------------------------------------------------------- /mr/gl/mttbarGL01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | double tt::xgl01(size_t nL, size_t nH, size_t boson) 3 | { 4 | 5 | 6 | std::complex armttbarGL[5], mttbarGLret; 7 | 8 | armttbarGL[1]=double(boson); 9 | armttbarGL[2]=Tsil::A(MMt,mu2); 10 | armttbarGL[3]=pow(MMt,-1); 11 | armttbarGL[4]=armttbarGL[3]*armttbarGL[2]; 12 | armttbarGL[4]= - 1./3. + armttbarGL[4]; 13 | 14 | mttbarGLret = 4*armttbarGL[4]*armttbarGL[1]; 15 | return mttbarGLret.real(); 16 | } 17 | -------------------------------------------------------------------------------- /mr/gl/mttbarGL10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double tt::xgl10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armttbarGL[12], mttbarGLret; 9 | 10 | armttbarGL[1]=double(boson); 11 | armttbarGL[2]=Tsil::B(MMH,MMt,MMt,mu2); 12 | armttbarGL[3]=pow(SW,-1); 13 | armttbarGL[4]=pow(MMW,-1); 14 | armttbarGL[5]=Tsil::A(MMH,mu2); 15 | armttbarGL[6]=Tsil::A(MMt,mu2); 16 | armttbarGL[7]=pow(MMH,-1); 17 | armttbarGL[8]=std::real(Tsil::B(0,0,MMt,mu2)); 18 | armttbarGL[9]=armttbarGL[7]*armttbarGL[6]; 19 | armttbarGL[9]=1./2.*armttbarGL[2] + 1./8.*armttbarGL[8] - 3* 20 | armttbarGL[9]; 21 | armttbarGL[9]=MMt*armttbarGL[9]; 22 | armttbarGL[10]=armttbarGL[6] + armttbarGL[5]; 23 | armttbarGL[11]=MMH*armttbarGL[2]; 24 | armttbarGL[9]= - 1./8.*armttbarGL[11] + 1./4.*armttbarGL[10] + 25 | armttbarGL[9]; 26 | 27 | mttbarGLret = armttbarGL[9]*armttbarGL[4]*pow(armttbarGL[3],2)* 28 | armttbarGL[1]; 29 | return mttbarGLret.real(); 30 | } 31 | } // namespace mr 32 | -------------------------------------------------------------------------------- /mr/gl/mttbarGL11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double tt::xgl11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armttbarGL[30], mttbarGLret; 9 | 10 | armttbarGL[1]=double(boson); 11 | armttbarGL[2]=pow(SW,-1); 12 | armttbarGL[3]=pow(MMH,-1); 13 | armttbarGL[4]=pow(MMW,-1); 14 | armttbarGL[5]=pow(MMt,-1); 15 | armttbarGL[6]=Tsil::I2(MMH,MMt,MMt,mu2); 16 | armttbarGL[7]=Tsil::I2(0,0,MMt,mu2); 17 | armttbarGL[8]=Tsil::B(MMH,MMt,MMt,mu2); 18 | armttbarGL[9]=Tsil::A(MMH,mu2); 19 | armttbarGL[10]=Tsil::A(MMt,mu2); 20 | armttbarGL[11]=Tsil::Beps(MMH,MMt,MMt,mu2); 21 | armttbarGL[12]=std::real(Tsil::B(0,0,MMt,mu2)); 22 | armttbarGL[13]=Tsil::Aeps(MMH,mu2); 23 | armttbarGL[14]=Tsil::Aeps(MMt,mu2); 24 | armttbarGL[15]=prot0ttHt->M(0); 25 | armttbarGL[16]=prottH0H->Vxzuv(0); 26 | armttbarGL[17]=prot0ttHt->Tuxv(0); 27 | armttbarGL[18]=protWt000->Tyzv(0); 28 | armttbarGL[19]=protHtt0t->M(0); 29 | armttbarGL[20]=prot00t00->M(0); 30 | armttbarGL[21]=prot000t0->M(0); 31 | armttbarGL[22]=armttbarGL[5]*MMH; 32 | armttbarGL[23]=1./2.*armttbarGL[22]; 33 | armttbarGL[24]=armttbarGL[6] + MMH; 34 | armttbarGL[24]=armttbarGL[24]*armttbarGL[23]; 35 | armttbarGL[25]=pow(MMH,2); 36 | armttbarGL[26]=1./2.*armttbarGL[5]; 37 | armttbarGL[26]=armttbarGL[25]*armttbarGL[26]; 38 | armttbarGL[23]=2 - armttbarGL[23]; 39 | armttbarGL[23]=armttbarGL[10]*armttbarGL[23]; 40 | armttbarGL[23]=7*armttbarGL[23] - 2*armttbarGL[9] - 17*MMH + 41 | armttbarGL[26]; 42 | armttbarGL[23]=armttbarGL[8]*armttbarGL[23]; 43 | armttbarGL[26]=armttbarGL[15] + armttbarGL[19]; 44 | armttbarGL[27]=4*armttbarGL[16] - armttbarGL[26]; 45 | armttbarGL[27]=MMH*armttbarGL[27]; 46 | armttbarGL[27]=armttbarGL[27] - 13 + 4*armttbarGL[11]; 47 | armttbarGL[27]=MMH*armttbarGL[27]; 48 | armttbarGL[28]=13./2. - armttbarGL[22]; 49 | armttbarGL[28]=armttbarGL[14]*armttbarGL[28]; 50 | armttbarGL[23]=armttbarGL[23] + 5*armttbarGL[28] + armttbarGL[24] - 51 | 11*armttbarGL[6] + armttbarGL[27]; 52 | armttbarGL[24]=1./3.*armttbarGL[22]; 53 | armttbarGL[22]= - 2 + armttbarGL[22]; 54 | armttbarGL[22]=armttbarGL[10]*armttbarGL[5]*armttbarGL[22]; 55 | armttbarGL[22]=armttbarGL[22] + 4./3.*armttbarGL[12] + 23./2. - 56 | armttbarGL[24]; 57 | armttbarGL[22]=armttbarGL[10]*armttbarGL[22]; 58 | armttbarGL[27]=2*MMH; 59 | armttbarGL[25]=armttbarGL[5]*armttbarGL[25]; 60 | armttbarGL[25]= - armttbarGL[27] + 1./6.*armttbarGL[25]; 61 | armttbarGL[25]=armttbarGL[17]*armttbarGL[25]; 62 | armttbarGL[28]=pow(armttbarGL[9],2); 63 | armttbarGL[29]= - 13./3.*armttbarGL[9] - 36*armttbarGL[10]; 64 | armttbarGL[29]=armttbarGL[10]*armttbarGL[29]; 65 | armttbarGL[28]= - 4./3.*armttbarGL[28] + armttbarGL[29]; 66 | armttbarGL[28]=armttbarGL[3]*armttbarGL[28]; 67 | armttbarGL[24]=7 - armttbarGL[24]; 68 | armttbarGL[24]=armttbarGL[9]*armttbarGL[24]; 69 | armttbarGL[29]=armttbarGL[18]*MMH; 70 | armttbarGL[22]= - 13./6.*armttbarGL[7] + armttbarGL[28] + 71 | armttbarGL[25] + armttbarGL[22] - 4./3.*armttbarGL[29] + 1./2.* 72 | armttbarGL[24] + 3*armttbarGL[13] + 1./3.*armttbarGL[23]; 73 | armttbarGL[23]=pow(armttbarGL[2],2); 74 | armttbarGL[22]=armttbarGL[23]*armttbarGL[22]; 75 | armttbarGL[24]= - 8./3.*armttbarGL[16] + armttbarGL[26]; 76 | armttbarGL[24]=armttbarGL[24]*armttbarGL[27]; 77 | armttbarGL[25]= - 17./2. - 8*armttbarGL[11]; 78 | armttbarGL[27]=1 + 1./2.*armttbarGL[12]; 79 | armttbarGL[27]=armttbarGL[12]*armttbarGL[27]; 80 | armttbarGL[28]=pow(Pi,2); 81 | armttbarGL[29]=13./3.*armttbarGL[13] + 4*armttbarGL[10]; 82 | armttbarGL[29]=armttbarGL[3]*armttbarGL[29]; 83 | armttbarGL[26]= - armttbarGL[21] - 8*armttbarGL[26] - armttbarGL[20] 84 | ; 85 | armttbarGL[26]=32*armttbarGL[3] + 1./3.*armttbarGL[26]; 86 | armttbarGL[26]=MMt*armttbarGL[26]; 87 | armttbarGL[24]=armttbarGL[26] + 52./3.*armttbarGL[8] + 88 | armttbarGL[29] + 13./3.*armttbarGL[17] + 4*armttbarGL[18] - 5./12.* 89 | armttbarGL[28] + 5./6.*armttbarGL[27] + 1./3.*armttbarGL[25] + 90 | armttbarGL[24]; 91 | armttbarGL[23]=MMt*armttbarGL[23]*armttbarGL[24]; 92 | armttbarGL[22]=armttbarGL[23] + armttbarGL[22]; 93 | 94 | mttbarGLret = armttbarGL[22]*armttbarGL[4]*armttbarGL[1]; 95 | return mttbarGLret.real(); 96 | } 97 | } // namespace mr 98 | -------------------------------------------------------------------------------- /mr/logger.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MR - 2-loop matching and 3-loop Running, including full 2-loop EW corrections 3 | // Copyright (C) 2014 Andrey Pikelner 4 | // 5 | // This file is part of MR. 6 | // 7 | // MR is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // (at your option) any later version. 11 | // 12 | // MR is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with MR. If not, see . 19 | // 20 | 21 | #ifndef _LOGGER_HPP_ 22 | #define _LOGGER_HPP_ 23 | 24 | #include 25 | #include 26 | 27 | namespace mr 28 | { 29 | 30 | enum loglevel_e 31 | {logERROR, logWARNING, logINFO, logDEBUG}; 32 | 33 | class logIt 34 | { 35 | public: 36 | logIt(loglevel_e _loglevel = logERROR) { 37 | 38 | if (_loglevel == logERROR) 39 | _buffer << "[ERROR]: " ; 40 | else if (_loglevel == logWARNING) 41 | _buffer << "[WARNING]: " ; 42 | else if (_loglevel == logINFO) 43 | _buffer << "[INFO]: " ; 44 | else if (_loglevel == logDEBUG) 45 | _buffer << "[DEBUG]: " ; 46 | else 47 | { 48 | _buffer << "[DBG" << (_loglevel - logDEBUG) << "]" 49 | << std::string( 50 | _loglevel > logDEBUG 51 | ? (_loglevel - logDEBUG) * 4 52 | : 1 53 | , ' '); 54 | } 55 | } 56 | 57 | template 58 | logIt & operator << (T const & value) 59 | { 60 | _buffer << value; 61 | return *this; 62 | } 63 | logIt & operator << (std::ostream& (*fun)(std::ostream&)) { std::cout << std::endl; return *this;} 64 | 65 | ~logIt() 66 | { 67 | _buffer << std::endl; 68 | std::cerr << _buffer.str(); 69 | } 70 | 71 | private: 72 | std::ostringstream _buffer; 73 | }; 74 | 75 | extern loglevel_e loglevel; 76 | 77 | } // namespace mr 78 | 79 | 80 | 81 | #define lout(level) \ 82 | if (level > loglevel) ; \ 83 | else logIt(level) 84 | #endif 85 | 86 | 87 | -------------------------------------------------------------------------------- /mr/mMSmOS/README: -------------------------------------------------------------------------------- 1 | 2 | MS running mass in terms of OS masses 3 | 4 | m(mu) - runnig MS mass 5 | 6 | M - is an on-shell mass 7 | 8 | X_ij - functions of OS masses 9 | 10 | aw(mu) - EM running coupling (alEM/4/Pi) 11 | 12 | as(mu) - QCD running coupling (alS/4/Pi) 13 | 14 | m = M (1 + as*X_01 + aw*X_10 + aw*as*X_11 + aw^2*X_20 + ...) 15 | -------------------------------------------------------------------------------- /mr/mMSmOS/mHHbar10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double HH::x10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armHHbar[26], mHHbarret; 9 | 10 | armHHbar[1]=double(nH); 11 | armHHbar[2]=double(boson); 12 | armHHbar[3]=Tsil::B(MMt,MMt,MMH,mu2); 13 | armHHbar[4]=pow(CW,-1); 14 | armHHbar[5]=pow(MMH,-1); 15 | armHHbar[6]=pow(MMZ,-1); 16 | armHHbar[7]=pow(SW,-1); 17 | armHHbar[8]=Tsil::B(MMb,MMb,MMH,mu2); 18 | armHHbar[9]=Tsil::A(MMt,mu2); 19 | armHHbar[10]=Tsil::A(MMb,mu2); 20 | armHHbar[11]=Tsil::B(MMH,MMH,MMH,mu2); 21 | armHHbar[12]=Tsil::B(MMZ,MMZ,MMH,mu2); 22 | armHHbar[13]=Tsil::B(MMW,MMW,MMH,mu2); 23 | armHHbar[14]=Tsil::A(MMH,mu2); 24 | armHHbar[15]=Tsil::A(MMZ,mu2); 25 | armHHbar[16]=Tsil::A(MMW,mu2); 26 | armHHbar[17]=pow(armHHbar[4],2); 27 | armHHbar[18]=pow(armHHbar[7],2); 28 | armHHbar[17]=armHHbar[17] + armHHbar[18]; 29 | armHHbar[19]=MMb*armHHbar[17]*armHHbar[8]; 30 | armHHbar[20]= - armHHbar[10]*armHHbar[17]; 31 | armHHbar[20]= - armHHbar[19] + armHHbar[20]; 32 | armHHbar[20]=MMb*armHHbar[20]; 33 | armHHbar[21]=MMt*armHHbar[3]; 34 | armHHbar[22]= - armHHbar[21] - armHHbar[9]; 35 | armHHbar[22]=MMt*armHHbar[17]*armHHbar[22]; 36 | armHHbar[20]=armHHbar[22] + armHHbar[20]; 37 | armHHbar[20]=armHHbar[6]*armHHbar[1]*armHHbar[20]; 38 | armHHbar[22]=1./2.*armHHbar[15]; 39 | armHHbar[22]=armHHbar[17]*armHHbar[22]; 40 | armHHbar[23]=1./2.*armHHbar[12]; 41 | armHHbar[23]=armHHbar[17]*armHHbar[23]; 42 | armHHbar[24]= - 1 + armHHbar[18]; 43 | armHHbar[24]=armHHbar[13]*armHHbar[24]; 44 | armHHbar[24]=armHHbar[24] + armHHbar[23]; 45 | armHHbar[24]=MMZ*armHHbar[24]; 46 | armHHbar[25]=armHHbar[16]*armHHbar[18]; 47 | armHHbar[20]=armHHbar[24] + 2*armHHbar[20] + armHHbar[25] + 48 | armHHbar[22]; 49 | armHHbar[24]=3*armHHbar[5]; 50 | armHHbar[20]=armHHbar[24]*armHHbar[20]; 51 | armHHbar[21]=armHHbar[17]*armHHbar[21]; 52 | armHHbar[19]=armHHbar[21] + armHHbar[19]; 53 | armHHbar[19]=armHHbar[1]*armHHbar[19]; 54 | armHHbar[21]=9./4.*armHHbar[11] + 1./4.*armHHbar[12] + 1./2.* 55 | armHHbar[13]; 56 | armHHbar[21]=armHHbar[21]*MMH; 57 | armHHbar[21]=armHHbar[21] + armHHbar[16] + 3./2.*armHHbar[14]; 58 | armHHbar[17]=armHHbar[17]*armHHbar[21]; 59 | armHHbar[17]=armHHbar[22] + 3*armHHbar[19] + armHHbar[17]; 60 | armHHbar[17]=armHHbar[6]*armHHbar[17]; 61 | armHHbar[18]= - armHHbar[13]*armHHbar[18]; 62 | armHHbar[17]=1./2.*armHHbar[17] + armHHbar[18] - armHHbar[23] + 63 | armHHbar[20]; 64 | 65 | mHHbarret = armHHbar[17]*armHHbar[2]; 66 | return mHHbarret.real(); 67 | } 68 | } // namespace mr 69 | -------------------------------------------------------------------------------- /mr/mMSmOS/mHHbar11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double HH::x11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armHHbar[17], mHHbarret; 9 | 10 | armHHbar[1]=double(nH); 11 | armHHbar[2]=pow(CW,-1); 12 | armHHbar[3]=pow(MMH,-1); 13 | armHHbar[4]=pow(MMZ,-1); 14 | armHHbar[5]=pow(SW,-1); 15 | armHHbar[6]=Tsil::B(MMt,MMt,MMH,mu2); 16 | armHHbar[7]=Tsil::A(MMt,mu2); 17 | armHHbar[8]=Tsil::Beps(MMt,MMt,MMH,mu2); 18 | armHHbar[9]=Tsil::Aeps(MMt,mu2); 19 | armHHbar[10]=prottttt0->M(0); 20 | armHHbar[11]=prottttt0->Vxzuv(0); 21 | armHHbar[12]=prottttt0->Suxv(0); 22 | armHHbar[13]=2*armHHbar[11]; 23 | armHHbar[14]=armHHbar[13] + 3*armHHbar[10]; 24 | armHHbar[15]=4*MMt; 25 | armHHbar[14]=armHHbar[14]*armHHbar[15]; 26 | armHHbar[15]=4 + 3*armHHbar[6]; 27 | armHHbar[15]=armHHbar[15]*armHHbar[6]; 28 | armHHbar[16]=armHHbar[10]*MMH; 29 | armHHbar[16]=armHHbar[16] + 6; 30 | armHHbar[14]= - armHHbar[14] + armHHbar[15] + 2*armHHbar[16]; 31 | armHHbar[14]=armHHbar[14]*MMt; 32 | armHHbar[13]=armHHbar[13] + armHHbar[10]; 33 | armHHbar[15]=8*MMt; 34 | armHHbar[13]=armHHbar[13]*armHHbar[15]; 35 | armHHbar[15]=10 + 7*armHHbar[6]; 36 | armHHbar[15]=armHHbar[15]*armHHbar[6]; 37 | armHHbar[13]= - armHHbar[15] + armHHbar[13] - 9 + 4*armHHbar[8]; 38 | armHHbar[13]=armHHbar[13]*MMt; 39 | armHHbar[15]=armHHbar[6]*armHHbar[7]; 40 | armHHbar[16]= - armHHbar[9] + 3*armHHbar[15]; 41 | armHHbar[13]= - armHHbar[12] + armHHbar[13] - 6*armHHbar[16]; 42 | armHHbar[13]=MMt*armHHbar[13]; 43 | armHHbar[16]=pow(armHHbar[7],2); 44 | armHHbar[13]= - 12*armHHbar[16] + armHHbar[13]; 45 | armHHbar[13]=armHHbar[3]*armHHbar[13]; 46 | armHHbar[13]=2*armHHbar[13] + armHHbar[14] + 6*armHHbar[15]; 47 | armHHbar[14]=pow(armHHbar[5],2); 48 | armHHbar[15]=pow(armHHbar[2],2); 49 | armHHbar[14]=armHHbar[14] + armHHbar[15]; 50 | 51 | mHHbarret = 2*armHHbar[14]*armHHbar[13]*armHHbar[4]*armHHbar[1]; 52 | return mHHbarret.real(); 53 | } 54 | } // namespace mr 55 | -------------------------------------------------------------------------------- /mr/mMSmOS/mWWbar10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double WW::x10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armWWbar[26], mWWbarret; 9 | 10 | armWWbar[1]=double(nH); 11 | armWWbar[2]=double(boson); 12 | armWWbar[3]=pow(CW,-1); 13 | armWWbar[4]=pow(MMZ,-1); 14 | armWWbar[5]=pow(SW,-1); 15 | armWWbar[6]=Tsil::B(MMt,MMb,MMW,mu2); 16 | armWWbar[7]=Tsil::B(0,0,MMW,mu2); 17 | armWWbar[8]=Tsil::A(MMt,mu2); 18 | armWWbar[9]=pow(MMH,-1); 19 | armWWbar[10]=Tsil::A(MMb,mu2); 20 | armWWbar[11]=double(nL + nH); 21 | armWWbar[12]=Tsil::B(MMW,MMH,MMW,mu2); 22 | armWWbar[13]=Tsil::B(MMW,MMZ,MMW,mu2); 23 | armWWbar[14]=Tsil::A(MMH,mu2); 24 | armWWbar[15]=Tsil::A(MMZ,mu2); 25 | armWWbar[16]=Tsil::A(MMW,mu2); 26 | armWWbar[17]=6*armWWbar[9]; 27 | armWWbar[18]= - armWWbar[10]*armWWbar[17]; 28 | armWWbar[18]=armWWbar[18] + 1; 29 | armWWbar[19]=MMb*armWWbar[1]; 30 | armWWbar[18]=armWWbar[19]*armWWbar[18]; 31 | armWWbar[20]=armWWbar[1]*MMt; 32 | armWWbar[21]= - armWWbar[20] - armWWbar[19]; 33 | armWWbar[21]=armWWbar[6]*armWWbar[21]; 34 | armWWbar[17]= - armWWbar[20]*armWWbar[17]; 35 | armWWbar[17]=armWWbar[1] + armWWbar[17]; 36 | armWWbar[17]=armWWbar[8]*armWWbar[17]; 37 | armWWbar[22]=armWWbar[10]*armWWbar[1]; 38 | armWWbar[23]= - 1./2. - armWWbar[12]; 39 | armWWbar[23]=MMH*armWWbar[23]; 40 | armWWbar[17]=armWWbar[17] + 1./3.*armWWbar[23] + 1./2.*armWWbar[21] 41 | + armWWbar[18] + armWWbar[22] + 1./2.*armWWbar[14] + armWWbar[20]; 42 | armWWbar[18]=pow(armWWbar[5],2); 43 | armWWbar[21]=pow(armWWbar[3],2); 44 | armWWbar[22]=armWWbar[18] + armWWbar[21]; 45 | armWWbar[17]=armWWbar[22]*armWWbar[17]; 46 | armWWbar[23]=armWWbar[21] + 1; 47 | armWWbar[23]=armWWbar[23]*armWWbar[21]; 48 | armWWbar[23]=armWWbar[23] + armWWbar[18]; 49 | armWWbar[19]=armWWbar[23]*armWWbar[19]; 50 | armWWbar[20]=armWWbar[23]*armWWbar[20]; 51 | armWWbar[24]=armWWbar[19] - armWWbar[20]; 52 | armWWbar[25]=armWWbar[8] - armWWbar[10]; 53 | armWWbar[25]=1./2.*armWWbar[25]; 54 | armWWbar[24]=armWWbar[24]*armWWbar[25]; 55 | armWWbar[19]=armWWbar[20] - 1./2.*armWWbar[19]; 56 | armWWbar[19]=MMb*armWWbar[19]; 57 | armWWbar[20]=1./2.*armWWbar[1]; 58 | armWWbar[20]= - armWWbar[23]*pow(MMt,2)*armWWbar[20]; 59 | armWWbar[19]=armWWbar[20] + armWWbar[19]; 60 | armWWbar[19]=armWWbar[6]*armWWbar[19]; 61 | armWWbar[20]=armWWbar[14]*armWWbar[23]; 62 | armWWbar[23]=armWWbar[23]*MMH; 63 | armWWbar[25]=armWWbar[12]*armWWbar[23]; 64 | armWWbar[20]=armWWbar[20] + armWWbar[25]; 65 | armWWbar[20]=MMH*armWWbar[20]; 66 | armWWbar[19]=1./12.*armWWbar[20] + armWWbar[19] + armWWbar[24]; 67 | armWWbar[19]=armWWbar[4]*armWWbar[19]; 68 | armWWbar[20]=3 + 1./3.*armWWbar[21]; 69 | armWWbar[20]=armWWbar[20]*armWWbar[21]; 70 | armWWbar[20]= - 5*armWWbar[18] + armWWbar[20]; 71 | armWWbar[20]=armWWbar[15]*armWWbar[20]; 72 | armWWbar[17]=armWWbar[19] + 1./4.*armWWbar[20] + armWWbar[17]; 73 | armWWbar[17]=armWWbar[4]*armWWbar[17]; 74 | armWWbar[19]=armWWbar[15]*armWWbar[22]; 75 | armWWbar[20]=3*armWWbar[18]; 76 | armWWbar[22]=armWWbar[21] - 2 + armWWbar[20]; 77 | armWWbar[22]=MMZ*armWWbar[22]; 78 | armWWbar[19]=3./2.*armWWbar[19] + armWWbar[22]; 79 | armWWbar[19]=armWWbar[9]*armWWbar[19]; 80 | armWWbar[22]=35 - armWWbar[21]; 81 | armWWbar[22]=armWWbar[22]*armWWbar[21]; 82 | armWWbar[23]= - armWWbar[4]*armWWbar[23]; 83 | armWWbar[22]=armWWbar[23] - 13*armWWbar[18] + armWWbar[22]; 84 | armWWbar[22]=armWWbar[4]*armWWbar[22]; 85 | armWWbar[20]=armWWbar[9]*armWWbar[20]; 86 | armWWbar[20]=armWWbar[20] + 1./12.*armWWbar[22]; 87 | armWWbar[20]=armWWbar[16]*armWWbar[20]; 88 | armWWbar[22]=armWWbar[6]*armWWbar[1]; 89 | armWWbar[23]= - armWWbar[1] + 4./3.*armWWbar[11]; 90 | armWWbar[23]=armWWbar[7]*armWWbar[23]; 91 | armWWbar[22]=armWWbar[23] - 4./9.*armWWbar[11] + armWWbar[22] + 92 | armWWbar[12] - 59./18.; 93 | armWWbar[22]=armWWbar[18]*armWWbar[22]; 94 | armWWbar[23]=17 + armWWbar[21]; 95 | armWWbar[23]=armWWbar[23]*armWWbar[21]; 96 | armWWbar[18]=1./12.*armWWbar[23] + 4 - 33./4.*armWWbar[18]; 97 | armWWbar[18]=armWWbar[13]*armWWbar[18]; 98 | armWWbar[17]=armWWbar[20] + armWWbar[17] + armWWbar[18] + 99 | armWWbar[19] - 1./6.*armWWbar[21] - 4 + armWWbar[22]; 100 | 101 | mWWbarret = armWWbar[17]*armWWbar[2]; 102 | return mWWbarret.real(); 103 | } 104 | } // namespace mr 105 | -------------------------------------------------------------------------------- /mr/mMSmOS/mWWbar11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double WW::x11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armWWbar[21], mWWbarret; 9 | 10 | armWWbar[1]=double(nH); 11 | armWWbar[2]=pow(CW,-1); 12 | armWWbar[3]=pow(MMH,-1); 13 | armWWbar[4]=pow(MMZ,-1); 14 | armWWbar[5]=pow(SW,-1); 15 | armWWbar[6]=Tsil::B(0,MMt,MMW,mu2); 16 | armWWbar[7]=Tsil::A(MMt,mu2); 17 | armWWbar[8]=pow(MMt,-1); 18 | armWWbar[9]=Tsil::Aeps(MMt,mu2); 19 | armWWbar[10]=prot00tt0->M(0); 20 | armWWbar[11]=prot00tt0->Tuxv(0); 21 | armWWbar[12]=double(nL); 22 | armWWbar[13]=std::real(Tsil::B(0,0,MMW,mu2)); 23 | armWWbar[14]=prot00000->M(0); 24 | armWWbar[15]= - 1 + 1./3.*armWWbar[6]; 25 | armWWbar[16]=2*armWWbar[6]; 26 | armWWbar[15]=armWWbar[15]*armWWbar[16]; 27 | armWWbar[15]=armWWbar[15] - 13./6.; 28 | armWWbar[16]=MMt*armWWbar[3]; 29 | armWWbar[15]=8./3.*armWWbar[11] + 64*armWWbar[16] + 5*armWWbar[15]; 30 | armWWbar[15]=armWWbar[15]*MMt; 31 | armWWbar[16]= - armWWbar[8] + 6*armWWbar[3]; 32 | armWWbar[17]=2*armWWbar[7]; 33 | armWWbar[16]=armWWbar[16]*armWWbar[17]; 34 | armWWbar[18]=armWWbar[6] - 1; 35 | armWWbar[16]=armWWbar[16] - 5./3.*armWWbar[18]; 36 | armWWbar[19]=4*armWWbar[7]; 37 | armWWbar[16]=armWWbar[16]*armWWbar[19]; 38 | armWWbar[15]=armWWbar[15] - armWWbar[16] + 8./3.*armWWbar[9]; 39 | armWWbar[16]=pow(armWWbar[2],2); 40 | armWWbar[19]=pow(armWWbar[5],2); 41 | armWWbar[20]=armWWbar[16] + armWWbar[19]; 42 | armWWbar[15]=armWWbar[15]*armWWbar[20]; 43 | armWWbar[20]=armWWbar[16] + 1; 44 | armWWbar[16]=armWWbar[20]*armWWbar[16]; 45 | armWWbar[16]=armWWbar[16] + armWWbar[19]; 46 | armWWbar[17]= - armWWbar[17] + 5*MMt; 47 | armWWbar[20]=1./3.*armWWbar[7]; 48 | armWWbar[17]=armWWbar[17]*armWWbar[20]; 49 | armWWbar[20]=4./3.*armWWbar[11] + 3*armWWbar[6]; 50 | armWWbar[20]=armWWbar[20]*MMt; 51 | armWWbar[20]=armWWbar[20] + 4./3.*armWWbar[9]; 52 | armWWbar[20]=armWWbar[20]*MMt; 53 | armWWbar[17]=armWWbar[20] + armWWbar[17]; 54 | armWWbar[17]= - armWWbar[17]*armWWbar[16]; 55 | armWWbar[16]=armWWbar[10]*armWWbar[16]*pow(MMt,3); 56 | armWWbar[16]=2./3.*armWWbar[16] + armWWbar[17]; 57 | armWWbar[16]=armWWbar[4]*armWWbar[16]; 58 | armWWbar[15]=armWWbar[15] + 2*armWWbar[16]; 59 | armWWbar[15]=armWWbar[4]*armWWbar[15]; 60 | armWWbar[16]=armWWbar[7]*armWWbar[18]; 61 | armWWbar[16]=armWWbar[16] + armWWbar[9]; 62 | armWWbar[17]=16./3.*armWWbar[8]; 63 | armWWbar[16]=armWWbar[17]*armWWbar[16]; 64 | armWWbar[17]=1 + 2./3.*armWWbar[6]; 65 | armWWbar[17]=armWWbar[6]*armWWbar[17]; 66 | armWWbar[16]=16./3.*armWWbar[11] + 13 + 4*armWWbar[17] + 67 | armWWbar[16]; 68 | armWWbar[16]=armWWbar[16]*armWWbar[19]; 69 | armWWbar[17]=2./3.*MMZ; 70 | armWWbar[18]= - MMt + armWWbar[17]; 71 | armWWbar[18]=armWWbar[18]*armWWbar[19]; 72 | armWWbar[17]= - armWWbar[17] + armWWbar[18]; 73 | armWWbar[17]=armWWbar[10]*armWWbar[17]; 74 | armWWbar[15]=armWWbar[15] + armWWbar[16] + 4*armWWbar[17]; 75 | armWWbar[15]=armWWbar[1]*armWWbar[15]; 76 | armWWbar[16]=31./3. + 4*armWWbar[13]; 77 | armWWbar[16]=armWWbar[16]*armWWbar[19]; 78 | armWWbar[17]= - 1 + armWWbar[19]; 79 | armWWbar[17]=armWWbar[14]*MMZ*armWWbar[17]; 80 | armWWbar[16]=armWWbar[16] + 8./3.*armWWbar[17]; 81 | armWWbar[16]=armWWbar[12]*armWWbar[16]; 82 | 83 | mWWbarret = armWWbar[15] + armWWbar[16]; 84 | return mWWbarret.real(); 85 | } 86 | } // namespace mr 87 | -------------------------------------------------------------------------------- /mr/mMSmOS/mZZbar10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double ZZ::x10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armZZbar[35], mZZbarret; 9 | 10 | armZZbar[1]=double(nH); 11 | armZZbar[2]=double(boson); 12 | armZZbar[3]=pow(CW,-1); 13 | armZZbar[4]=pow(MMZ,-1); 14 | armZZbar[5]=pow(SW,-1); 15 | armZZbar[6]=Tsil::B(MMt,MMt,MMZ,mu2); 16 | armZZbar[7]=Tsil::B(MMb,MMb,MMZ,mu2); 17 | armZZbar[8]=Tsil::B(0,0,MMZ,mu2); 18 | armZZbar[9]=Tsil::A(MMt,mu2); 19 | armZZbar[10]=pow(MMH,-1); 20 | armZZbar[11]=Tsil::A(MMb,mu2); 21 | armZZbar[12]=double(nL + nH); 22 | armZZbar[13]=Tsil::B(MMZ,MMH,MMZ,mu2); 23 | armZZbar[14]=Tsil::B(MMW,MMW,MMZ,mu2); 24 | armZZbar[15]=Tsil::A(MMH,mu2); 25 | armZZbar[16]=Tsil::A(MMZ,mu2); 26 | armZZbar[17]=Tsil::A(MMW,mu2); 27 | armZZbar[18]=pow(armZZbar[3],2); 28 | armZZbar[19]=pow(armZZbar[5],2); 29 | armZZbar[20]=armZZbar[19] - 32./9. + 17./9.*armZZbar[18]; 30 | armZZbar[20]=armZZbar[20]*armZZbar[1]; 31 | armZZbar[21]=1./2.*armZZbar[19]; 32 | armZZbar[22]=7./18.*armZZbar[18] - 32./9. - armZZbar[21]; 33 | armZZbar[23]=armZZbar[6]*armZZbar[1]; 34 | armZZbar[22]=armZZbar[22]*armZZbar[23]; 35 | armZZbar[24]=armZZbar[18] + armZZbar[19]; 36 | armZZbar[25]=armZZbar[10]*armZZbar[1]; 37 | armZZbar[25]=6*armZZbar[25]; 38 | armZZbar[25]=armZZbar[25]*armZZbar[24]; 39 | armZZbar[26]= - armZZbar[9]*armZZbar[25]; 40 | armZZbar[22]=armZZbar[26] + armZZbar[20] + armZZbar[22]; 41 | armZZbar[22]=MMt*armZZbar[22]; 42 | armZZbar[26]= - 1./2. - armZZbar[13]; 43 | armZZbar[27]=MMH*armZZbar[13]; 44 | armZZbar[27]=armZZbar[27] - armZZbar[16] + armZZbar[15]; 45 | armZZbar[27]=armZZbar[4]*armZZbar[27]; 46 | armZZbar[26]=1./12.*armZZbar[27] + 1./3.*armZZbar[26]; 47 | armZZbar[26]=MMH*armZZbar[24]*armZZbar[26]; 48 | armZZbar[27]=armZZbar[19] + 5./9.*armZZbar[18]; 49 | armZZbar[28]= - 8./9. + armZZbar[27]; 50 | armZZbar[28]=armZZbar[1]*armZZbar[28]; 51 | armZZbar[25]= - MMb*armZZbar[25]; 52 | armZZbar[25]=armZZbar[28] + armZZbar[25]; 53 | armZZbar[25]=armZZbar[11]*armZZbar[25]; 54 | armZZbar[28]=armZZbar[24]*armZZbar[16]; 55 | armZZbar[29]=armZZbar[15]*armZZbar[24]; 56 | armZZbar[27]=MMb*armZZbar[27]; 57 | armZZbar[30]=8./9.*MMb; 58 | armZZbar[27]= - armZZbar[30] + armZZbar[27]; 59 | armZZbar[27]=armZZbar[1]*armZZbar[27]; 60 | armZZbar[20]=armZZbar[9]*armZZbar[20]; 61 | armZZbar[31]=armZZbar[21] + 17./18.*armZZbar[18]; 62 | armZZbar[32]= - MMb*armZZbar[31]; 63 | armZZbar[30]= - armZZbar[30] + armZZbar[32]; 64 | armZZbar[32]=armZZbar[7]*armZZbar[1]; 65 | armZZbar[30]=armZZbar[30]*armZZbar[32]; 66 | armZZbar[33]=1./6.*armZZbar[18]; 67 | armZZbar[34]=armZZbar[33] + 4 - 5./2.*armZZbar[19]; 68 | armZZbar[34]=armZZbar[17]*armZZbar[34]; 69 | armZZbar[20]=armZZbar[25] + armZZbar[22] + armZZbar[34] + 70 | armZZbar[30] + 1./6.*armZZbar[28] + armZZbar[20] + 1./2.* 71 | armZZbar[29] + armZZbar[27] + armZZbar[26]; 72 | armZZbar[20]=armZZbar[4]*armZZbar[20]; 73 | armZZbar[22]=pow(CW,2); 74 | armZZbar[22]=4*armZZbar[22]; 75 | armZZbar[25]=armZZbar[22] + 1./12.*armZZbar[18] + 29./3. - 33./4.* 76 | armZZbar[19]; 77 | armZZbar[25]=armZZbar[14]*armZZbar[25]; 78 | armZZbar[26]=3*armZZbar[19]; 79 | armZZbar[27]=armZZbar[18] - 2 + armZZbar[26]; 80 | armZZbar[27]=MMZ*armZZbar[27]; 81 | armZZbar[26]=armZZbar[17]*armZZbar[26]; 82 | armZZbar[26]=armZZbar[26] + armZZbar[27] + 3./2.*armZZbar[28]; 83 | armZZbar[26]=armZZbar[10]*armZZbar[26]; 84 | armZZbar[27]= - armZZbar[33] + 8 - 59./6.*armZZbar[19]; 85 | armZZbar[24]=armZZbar[13]*armZZbar[24]; 86 | armZZbar[28]= - 11./9.*armZZbar[18] + 20./9. - armZZbar[19]; 87 | armZZbar[28]=armZZbar[1]*armZZbar[8]*armZZbar[28]; 88 | armZZbar[19]=5./3.*armZZbar[18] + armZZbar[19] - 8./3.; 89 | armZZbar[29]=armZZbar[8] - 1./3.; 90 | armZZbar[19]=armZZbar[12]*armZZbar[29]*armZZbar[19]; 91 | armZZbar[29]= - 16./9. + armZZbar[31]; 92 | armZZbar[23]=armZZbar[29]*armZZbar[23]; 93 | armZZbar[18]=5./18.*armZZbar[18] - 4./9. + armZZbar[21]; 94 | armZZbar[18]=armZZbar[18]*armZZbar[32]; 95 | armZZbar[18]=armZZbar[20] + armZZbar[26] + armZZbar[25] + 96 | armZZbar[18] + armZZbar[23] + 4./3.*armZZbar[19] + armZZbar[28] + 97 | armZZbar[24] + 1./3.*armZZbar[27] + armZZbar[22]; 98 | 99 | mZZbarret = armZZbar[18]*armZZbar[2]; 100 | return mZZbarret.real(); 101 | } 102 | } // namespace mr 103 | -------------------------------------------------------------------------------- /mr/mMSmOS/mbbbar01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double bb::x01(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armbbbar[5], mbbbarret; 9 | 10 | armbbbar[1]=double(boson); 11 | armbbbar[2]=Tsil::A(MMb,mu2); 12 | armbbbar[3]=pow(MMb,-1); 13 | armbbbar[4]=armbbbar[2]*armbbbar[3]; 14 | armbbbar[4]= - 1./3. + armbbbar[4]; 15 | 16 | mbbbarret = 4*armbbbar[4]*armbbbar[1]; 17 | return mbbbarret.real(); 18 | } 19 | } // namespace mr 20 | -------------------------------------------------------------------------------- /mr/mMSmOS/mbbbar10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double bb::x10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armbbbar[27], mbbbarret; 9 | 10 | armbbbar[1]=double(nH); 11 | armbbbar[2]=double(boson); 12 | armbbbar[3]=Tsil::A(MMt,mu2); 13 | armbbbar[4]=pow(CW,-1); 14 | armbbbar[5]=pow(MMH,-1); 15 | armbbbar[6]=pow(MMZ,-1); 16 | armbbbar[7]=pow(SW,-1); 17 | armbbbar[8]=Tsil::A(MMb,mu2); 18 | armbbbar[9]=Tsil::B(MMH,MMb,MMb,mu2); 19 | armbbbar[10]=Tsil::B(MMZ,MMb,MMb,mu2); 20 | armbbbar[11]=pow(MMb,-1); 21 | armbbbar[12]=Tsil::B(MMW,MMt,MMb,mu2); 22 | armbbbar[13]=Tsil::A(MMH,mu2); 23 | armbbbar[14]=Tsil::A(MMZ,mu2); 24 | armbbbar[15]=Tsil::A(MMW,mu2); 25 | armbbbar[16]=3*armbbbar[5]; 26 | armbbbar[17]=MMZ + armbbbar[15]; 27 | armbbbar[17]=armbbbar[17]*armbbbar[16]; 28 | armbbbar[18]=armbbbar[10] - 3 + armbbbar[12]; 29 | armbbbar[19]=3./2.*armbbbar[14]; 30 | armbbbar[20]=armbbbar[5]*armbbbar[19]; 31 | armbbbar[17]=armbbbar[20] + armbbbar[17] + 1./4.*armbbbar[18]; 32 | armbbbar[17]=armbbbar[2]*armbbbar[17]; 33 | armbbbar[18]=armbbbar[10]*MMZ; 34 | armbbbar[18]=armbbbar[18] + armbbbar[14]; 35 | armbbbar[20]=MMt*armbbbar[12]; 36 | armbbbar[21]= - armbbbar[18] + armbbbar[20] + armbbbar[8]; 37 | armbbbar[22]=armbbbar[3] - armbbbar[15]; 38 | armbbbar[23]=MMZ*armbbbar[12]; 39 | armbbbar[21]= - armbbbar[23] + armbbbar[22] + 1./2.*armbbbar[21]; 40 | armbbbar[24]=armbbbar[11]*armbbbar[2]; 41 | armbbbar[21]=armbbbar[21]*armbbbar[24]; 42 | armbbbar[17]=armbbbar[17] + 1./2.*armbbbar[21]; 43 | armbbbar[21]=pow(armbbbar[7],2); 44 | armbbbar[17]=armbbbar[17]*armbbbar[21]; 45 | armbbbar[25]=armbbbar[8] - armbbbar[18]; 46 | armbbbar[25]=armbbbar[25]*armbbbar[24]; 47 | armbbbar[19]=armbbbar[19] + MMZ; 48 | armbbbar[19]=armbbbar[5]*armbbbar[19]; 49 | armbbbar[19]=17./36.*armbbbar[10] - 13./36. + armbbbar[19]; 50 | armbbbar[19]=armbbbar[2]*armbbbar[19]; 51 | armbbbar[19]=armbbbar[19] + 5./36.*armbbbar[25]; 52 | armbbbar[25]=pow(armbbbar[4],2); 53 | armbbbar[19]=armbbbar[19]*armbbbar[25]; 54 | armbbbar[17]=armbbbar[19] + armbbbar[17]; 55 | armbbbar[16]=armbbbar[16]*armbbbar[1]; 56 | armbbbar[19]=armbbbar[16]*armbbbar[8]; 57 | armbbbar[19]= - armbbbar[19] + 1./2.*armbbbar[9] + 1./8.* 58 | armbbbar[12]; 59 | armbbbar[19]=armbbbar[19]*MMb; 60 | armbbbar[26]= - armbbbar[13] - 1./2.*armbbbar[15] + armbbbar[20] - 61 | armbbbar[8]; 62 | armbbbar[16]=armbbbar[16]*MMt; 63 | armbbbar[16]=armbbbar[16] - 1./8.; 64 | armbbbar[16]=armbbbar[16]*armbbbar[3]; 65 | armbbbar[16]=armbbbar[19] - armbbbar[16] - 1./4.*armbbbar[26]; 66 | armbbbar[16]=armbbbar[2]*armbbbar[16]; 67 | armbbbar[19]=armbbbar[20] + armbbbar[22]; 68 | armbbbar[20]=1./8.*armbbbar[24]; 69 | armbbbar[19]=armbbbar[20]*armbbbar[19]*MMt; 70 | armbbbar[20]=1./8.*armbbbar[2]; 71 | armbbbar[20]=armbbbar[9]*armbbbar[20]*MMH; 72 | armbbbar[16]= - armbbbar[20] + armbbbar[19] + armbbbar[16]; 73 | armbbbar[19]=armbbbar[25] + armbbbar[21]; 74 | armbbbar[16]=armbbbar[6]*armbbbar[16]*armbbbar[19]; 75 | armbbbar[18]=2./9.*armbbbar[8] + 1./4.*armbbbar[23] + 1./9.* 76 | armbbbar[18]; 77 | armbbbar[18]=armbbbar[18]*armbbbar[24]; 78 | armbbbar[19]= - armbbbar[5]*MMZ; 79 | armbbbar[19]=2./9.*armbbbar[10] - 2./9. + armbbbar[19]; 80 | armbbbar[19]=armbbbar[2]*armbbbar[19]; 81 | 82 | mbbbarret = armbbbar[16] + 1./2.*armbbbar[17] + armbbbar[18] + 83 | armbbbar[19]; 84 | return mbbbarret.real(); 85 | } 86 | } // namespace mr 87 | -------------------------------------------------------------------------------- /mr/mMSmOS/mttbar01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double tt::x01(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armttbar[5], mttbarret; 9 | 10 | armttbar[1]=double(boson); 11 | armttbar[2]=Tsil::A(MMt,mu2); 12 | armttbar[3]=pow(MMt,-1); 13 | armttbar[4]=armttbar[2]*armttbar[3]; 14 | armttbar[4]= - 1./3. + armttbar[4]; 15 | 16 | mttbarret = 4*armttbar[4]*armttbar[1]; 17 | return mttbarret.real(); 18 | } 19 | } // namespace mr 20 | -------------------------------------------------------------------------------- /mr/mMSmOS/mttbar10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double tt::x10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armttbar[25], mttbarret; 9 | 10 | armttbar[1]=double(nH); 11 | armttbar[2]=double(boson); 12 | armttbar[3]=Tsil::A(MMt,mu2); 13 | armttbar[4]=pow(CW,-1); 14 | armttbar[5]=pow(MMH,-1); 15 | armttbar[6]=pow(MMZ,-1); 16 | armttbar[7]=pow(SW,-1); 17 | armttbar[8]=Tsil::A(MMb,mu2); 18 | armttbar[9]=Tsil::B(MMH,MMt,MMt,mu2); 19 | armttbar[10]=Tsil::B(MMZ,MMt,MMt,mu2); 20 | armttbar[11]=pow(MMt,-1); 21 | armttbar[12]=Tsil::B(MMW,MMb,MMt,mu2); 22 | armttbar[13]=Tsil::A(MMH,mu2); 23 | armttbar[14]=Tsil::A(MMZ,mu2); 24 | armttbar[15]=Tsil::A(MMW,mu2); 25 | armttbar[16]=1./2.*armttbar[14]; 26 | armttbar[17]=armttbar[10]*MMZ; 27 | armttbar[18]= - armttbar[12]*MMZ; 28 | armttbar[18]= - 1./2.*armttbar[17] + armttbar[18] + armttbar[8] - 29 | armttbar[16]; 30 | armttbar[19]=1./2.*armttbar[11]; 31 | armttbar[18]=armttbar[18]*armttbar[19]; 32 | armttbar[20]=3*armttbar[5]; 33 | armttbar[16]=MMZ + armttbar[16]; 34 | armttbar[16]=armttbar[16]*armttbar[20]; 35 | armttbar[19]=armttbar[20] - armttbar[19]; 36 | armttbar[19]=armttbar[15]*armttbar[19]; 37 | armttbar[21]=armttbar[3]*armttbar[11]; 38 | armttbar[22]=armttbar[21] + armttbar[10] - 3 + armttbar[12]; 39 | armttbar[23]=1./4.*armttbar[12]; 40 | armttbar[24]=armttbar[23]*MMb*armttbar[11]; 41 | armttbar[16]=armttbar[24] + armttbar[19] + armttbar[18] + 42 | armttbar[16] + 1./4.*armttbar[22]; 43 | armttbar[18]=MMb*armttbar[12]; 44 | armttbar[18]=armttbar[8] + armttbar[18] - armttbar[15]; 45 | armttbar[19]=1./8.*armttbar[11]; 46 | armttbar[18]=armttbar[18]*armttbar[19]; 47 | armttbar[19]=armttbar[20]*armttbar[1]; 48 | armttbar[20]=armttbar[19]*armttbar[8]; 49 | armttbar[18]=armttbar[18] - armttbar[20] - armttbar[23]; 50 | armttbar[18]=armttbar[18]*MMb; 51 | armttbar[20]=MMH*armttbar[9]; 52 | armttbar[20]=armttbar[20] - armttbar[8]; 53 | armttbar[22]=armttbar[23] + armttbar[9]; 54 | armttbar[22]=armttbar[22]*MMt; 55 | armttbar[20]=armttbar[22] - 1./4.*armttbar[20]; 56 | armttbar[19]=armttbar[19]*MMt; 57 | armttbar[19]=armttbar[19] - 1./4.; 58 | armttbar[19]=armttbar[19]*armttbar[3]; 59 | armttbar[18]= - 1./4.*armttbar[13] - armttbar[18] - 1./2.* 60 | armttbar[20] + armttbar[19] - 1./8.*armttbar[15]; 61 | armttbar[18]=armttbar[6]*armttbar[18]; 62 | armttbar[16]=1./2.*armttbar[16] - armttbar[18]; 63 | armttbar[16]=armttbar[16]*pow(armttbar[7],2); 64 | armttbar[17]=armttbar[17] + armttbar[14]; 65 | armttbar[19]= - armttbar[11]*armttbar[17]; 66 | armttbar[19]=armttbar[21] + armttbar[19]; 67 | armttbar[20]= - 1 - 7*armttbar[10]; 68 | armttbar[22]=MMZ + 3./2.*armttbar[14]; 69 | armttbar[22]=armttbar[5]*armttbar[22]; 70 | armttbar[19]=1./36.*armttbar[20] + armttbar[22] + 17./36.* 71 | armttbar[19]; 72 | armttbar[18]=1./2.*armttbar[19] - armttbar[18]; 73 | armttbar[18]=armttbar[18]*pow(armttbar[4],2); 74 | armttbar[19]=MMZ*armttbar[23]; 75 | armttbar[17]=armttbar[19] + 4./9.*armttbar[17]; 76 | armttbar[17]=armttbar[11]*armttbar[17]; 77 | armttbar[19]=armttbar[21] - 1 + armttbar[10]; 78 | armttbar[20]= - armttbar[5]*MMZ; 79 | armttbar[16]=armttbar[18] + armttbar[16] + armttbar[17] + 80 | armttbar[20] + 8./9.*armttbar[19]; 81 | 82 | mttbarret = armttbar[16]*armttbar[2]; 83 | return mttbarret.real(); 84 | } 85 | } // namespace mr 86 | -------------------------------------------------------------------------------- /mr/mOSmMS/README: -------------------------------------------------------------------------------- 1 | 2 | Pole mass in terms of running masses and couplings 3 | 4 | M - is an on-shell mass 5 | 6 | m(mu) - runnig MS mass 7 | 8 | x_ij - functions of MS masses 9 | 10 | aw(mu) - EM running coupling (alEM/4/Pi) 11 | 12 | as(mu) - QCD running coupling (alS/4/Pi) 13 | 14 | M = m (1 + as*x_01 + aw*x_10 + aw*as*x_11 + aw^2*x_20 + ...) 15 | -------------------------------------------------------------------------------- /mr/mOSmMS/mHHos10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double HH::x10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armHHos[22], mHHosret; 9 | 10 | armHHos[1]=double(nH); 11 | armHHos[2]=Tsil::B(mmt,mmt,mmH,mu2); 12 | armHHos[3]=pow(mmZ,-1); 13 | armHHos[4]=pow(mmH,-1); 14 | armHHos[5]=pow(s,-1); 15 | armHHos[6]=pow(c,-1); 16 | armHHos[7]=Tsil::A(mmt,mu2); 17 | armHHos[8]=double(boson); 18 | armHHos[9]=Tsil::B(mmW,mmW,mmH,mu2); 19 | armHHos[10]=Tsil::B(mmZ,mmZ,mmH,mu2); 20 | armHHos[11]=Tsil::B(mmH,mmH,mmH,mu2); 21 | armHHos[12]=Tsil::A(mmW,mu2); 22 | armHHos[13]=Tsil::A(mmZ,mu2); 23 | armHHos[14]=Tsil::A(mmH,mu2); 24 | armHHos[15]=2*armHHos[4]; 25 | armHHos[16]=armHHos[2]*armHHos[15]*mmt; 26 | armHHos[15]=armHHos[15]*armHHos[7]; 27 | armHHos[15]= - armHHos[16] - armHHos[15] + 1./2.*armHHos[2]; 28 | armHHos[16]=pow(armHHos[5],2); 29 | armHHos[17]=pow(armHHos[6],2); 30 | armHHos[18]= - armHHos[16] - armHHos[17]; 31 | armHHos[15]=armHHos[18]*armHHos[1]*mmt*armHHos[3]*armHHos[15]; 32 | armHHos[18]=armHHos[9] + 9./2.*armHHos[11]; 33 | armHHos[18]=1./4.*armHHos[10] + 1./2.*armHHos[18]; 34 | armHHos[18]=armHHos[18]*mmH; 35 | armHHos[19]=armHHos[13] + 3*armHHos[14]; 36 | armHHos[18]=armHHos[18] + armHHos[12] + 1./2.*armHHos[19]; 37 | armHHos[18]=armHHos[18]*armHHos[3]; 38 | armHHos[19]=3*armHHos[4]; 39 | armHHos[20]=armHHos[19]*mmZ; 40 | armHHos[21]=armHHos[20] - 1; 41 | armHHos[21]=armHHos[21]*armHHos[10]; 42 | armHHos[18]=armHHos[18] + armHHos[21]; 43 | armHHos[21]=mmZ*armHHos[9]; 44 | armHHos[21]= - armHHos[12] - 1./2.*armHHos[13] - armHHos[21]; 45 | armHHos[21]=armHHos[21]*armHHos[19]; 46 | armHHos[21]=armHHos[9] + armHHos[21] - 1./2.*armHHos[18]; 47 | armHHos[16]=armHHos[21]*armHHos[16]; 48 | armHHos[19]= - armHHos[13]*armHHos[19]; 49 | armHHos[18]=armHHos[19] - armHHos[18]; 50 | armHHos[17]=armHHos[18]*armHHos[17]; 51 | armHHos[18]=armHHos[9]*armHHos[20]; 52 | armHHos[16]=1./2.*armHHos[17] + armHHos[18] + armHHos[16]; 53 | armHHos[16]=armHHos[8]*armHHos[16]; 54 | 55 | mHHosret = 3*armHHos[15] + armHHos[16]; 56 | return mHHosret.real(); 57 | } 58 | } // namespace mr 59 | -------------------------------------------------------------------------------- /mr/mOSmMS/mHHos11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double HH::x11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armHHos[17], mHHosret; 9 | 10 | armHHos[1]=double(nH); 11 | armHHos[2]=pow(mmZ,-1); 12 | armHHos[3]=pow(mmH,-1); 13 | armHHos[4]=pow(s,-1); 14 | armHHos[5]=pow(c,-1); 15 | armHHos[6]=Tsil::B(mmt,mmt,mmH,mu2); 16 | armHHos[7]=Tsil::A(mmt,mu2); 17 | armHHos[8]=Tsil::Beps(mmt,mmt,mmH,mu2); 18 | armHHos[9]=Tsil::Aeps(mmt,mu2); 19 | armHHos[10]=prottttt0->M(0); 20 | armHHos[11]=prottttt0->Vxzuv(0); 21 | armHHos[12]=prottttt0->Suxv(0); 22 | armHHos[13]=2*armHHos[11]; 23 | armHHos[14]=armHHos[13] + armHHos[10]; 24 | armHHos[15]=8*mmt; 25 | armHHos[14]=armHHos[14]*armHHos[15]; 26 | armHHos[15]=20 + 7*armHHos[6]; 27 | armHHos[15]=armHHos[15]*armHHos[6]; 28 | armHHos[14]= - armHHos[15] + armHHos[14] - 11 + 4*armHHos[8]; 29 | armHHos[14]=armHHos[14]*mmt; 30 | armHHos[15]= - 1 + 3*armHHos[6]; 31 | armHHos[16]=2*armHHos[7]; 32 | armHHos[15]=armHHos[15]*armHHos[16]; 33 | armHHos[15]=armHHos[15] + 3*armHHos[9]; 34 | armHHos[14]= - armHHos[12] + armHHos[14] + 2*armHHos[15]; 35 | armHHos[14]=armHHos[14]*mmt; 36 | armHHos[15]=pow(armHHos[7],2); 37 | armHHos[14]=armHHos[14] + 18*armHHos[15]; 38 | armHHos[15]=armHHos[3]*armHHos[1]; 39 | armHHos[15]=2*armHHos[15]; 40 | armHHos[14]=armHHos[14]*armHHos[15]; 41 | armHHos[13]=armHHos[13] + 3*armHHos[10]; 42 | armHHos[15]=4*mmt; 43 | armHHos[13]=armHHos[13]*armHHos[15]; 44 | armHHos[15]=armHHos[6] + 2; 45 | armHHos[15]=armHHos[15]*armHHos[6]; 46 | armHHos[15]=armHHos[15] + 4; 47 | armHHos[16]=armHHos[10]*mmH; 48 | armHHos[13]=2*armHHos[16] - armHHos[13] + 3*armHHos[15]; 49 | armHHos[13]=armHHos[1]*mmt*armHHos[13]; 50 | armHHos[13]=armHHos[14] + armHHos[13]; 51 | armHHos[14]= - pow(armHHos[4],2); 52 | armHHos[15]= - pow(armHHos[5],2); 53 | armHHos[14]=armHHos[14] + armHHos[15]; 54 | 55 | mHHosret = 2*armHHos[14]*armHHos[13]*armHHos[2]; 56 | return mHHosret.real(); 57 | } 58 | } // namespace mr 59 | -------------------------------------------------------------------------------- /mr/mOSmMS/mWWos10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double WW::x10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armWWos[26], mWWosret; 9 | 10 | armWWos[1]=double(nL + nH); 11 | armWWos[2]=pow(s,-1); 12 | armWWos[3]=std::real(Tsil::B(0,0,mmW,mu2)); 13 | armWWos[4]=double(nH); 14 | armWWos[5]=pow(mmZ,-1); 15 | armWWos[6]=pow(c,-1); 16 | armWWos[7]=Tsil::B(0,mmt,mmW,mu2); 17 | armWWos[8]=Tsil::A(mmt,mu2); 18 | armWWos[9]=pow(mmH,-1); 19 | armWWos[10]=double(nL); 20 | armWWos[11]=double(boson); 21 | armWWos[12]=Tsil::B(mmW,mmZ,mmW,mu2); 22 | armWWos[13]=Tsil::B(mmW,mmH,mmW,mu2); 23 | armWWos[14]=Tsil::A(mmW,mu2); 24 | armWWos[15]=Tsil::A(mmZ,mu2); 25 | armWWos[16]=Tsil::A(mmH,mu2); 26 | armWWos[17]=armWWos[9]*armWWos[8]; 27 | armWWos[17]=6*armWWos[17] - 1 + 1./2.*armWWos[7]; 28 | armWWos[18]=mmt*armWWos[4]; 29 | armWWos[17]=armWWos[18]*armWWos[17]; 30 | armWWos[19]= - armWWos[4]*armWWos[8]; 31 | armWWos[17]=armWWos[17] + armWWos[19]; 32 | armWWos[19]=pow(armWWos[2],2); 33 | armWWos[20]=pow(armWWos[6],2); 34 | armWWos[21]=armWWos[19] + armWWos[20]; 35 | armWWos[17]=armWWos[21]*armWWos[17]; 36 | armWWos[21]=armWWos[13] + 1./2.; 37 | armWWos[22]=1./3.*mmH; 38 | armWWos[21]=armWWos[21]*armWWos[22]; 39 | armWWos[22]=1./12.*armWWos[20]; 40 | armWWos[23]= - armWWos[15] + armWWos[14]; 41 | armWWos[23]=armWWos[23]*armWWos[22]; 42 | armWWos[24]=3./2.*armWWos[15]; 43 | armWWos[25]= - armWWos[16] - armWWos[24]; 44 | armWWos[23]=armWWos[23] - 35./12.*armWWos[14] + 1./2.*armWWos[25] + 45 | armWWos[21]; 46 | armWWos[23]=armWWos[23]*armWWos[20]; 47 | armWWos[25]= - armWWos[16] + 5./2.*armWWos[15]; 48 | armWWos[21]=13./12.*armWWos[14] + 1./2.*armWWos[25] + armWWos[21]; 49 | armWWos[21]=armWWos[21]*armWWos[19]; 50 | armWWos[21]=armWWos[23] + armWWos[21]; 51 | armWWos[21]=armWWos[11]*armWWos[21]; 52 | armWWos[23]=armWWos[20] + 1; 53 | armWWos[23]=armWWos[23]*armWWos[20]; 54 | armWWos[23]=armWWos[23] + armWWos[19]; 55 | armWWos[25]=armWWos[4]*armWWos[8]*armWWos[23]; 56 | armWWos[18]=armWWos[18]*armWWos[7]*armWWos[23]; 57 | armWWos[18]=armWWos[25] + armWWos[18]; 58 | armWWos[18]=mmt*armWWos[18]; 59 | armWWos[25]=mmH*armWWos[13]; 60 | armWWos[25]= - armWWos[14] + armWWos[25] + armWWos[16]; 61 | armWWos[23]= - armWWos[11]*armWWos[23]*mmH*armWWos[25]; 62 | armWWos[18]=1./6.*armWWos[23] + armWWos[18]; 63 | armWWos[18]=armWWos[5]*armWWos[18]; 64 | armWWos[17]=1./2.*armWWos[18] + armWWos[21] + armWWos[17]; 65 | armWWos[17]=armWWos[5]*armWWos[17]; 66 | armWWos[18]= - mmZ - armWWos[24]; 67 | armWWos[18]=armWWos[9]*armWWos[18]; 68 | armWWos[18]=1./6. + armWWos[18]; 69 | armWWos[18]=armWWos[18]*armWWos[20]; 70 | armWWos[21]= - armWWos[14] - mmZ - 1./2.*armWWos[15]; 71 | armWWos[23]=3*armWWos[9]; 72 | armWWos[21]=armWWos[23]*armWWos[21]; 73 | armWWos[21]=59./18. - armWWos[13] + armWWos[21]; 74 | armWWos[21]=armWWos[21]*armWWos[19]; 75 | armWWos[20]= - 17 - armWWos[20]; 76 | armWWos[20]=armWWos[20]*armWWos[22]; 77 | armWWos[20]=33./4.*armWWos[19] - 4 + armWWos[20]; 78 | armWWos[20]=armWWos[12]*armWWos[20]; 79 | armWWos[22]=armWWos[9]*mmZ; 80 | armWWos[22]=2 + armWWos[22]; 81 | armWWos[18]=armWWos[20] + armWWos[21] + 2*armWWos[22] + armWWos[18]; 82 | armWWos[18]=armWWos[11]*armWWos[18]; 83 | armWWos[20]= - armWWos[3] + 1./3.; 84 | armWWos[21]=armWWos[10] + 1./3.*armWWos[1]; 85 | armWWos[20]=armWWos[21]*armWWos[20]; 86 | armWWos[21]=1./3. - armWWos[7]; 87 | armWWos[21]=armWWos[4]*armWWos[21]; 88 | armWWos[20]=armWWos[21] + armWWos[20]; 89 | armWWos[19]=armWWos[19]*armWWos[20]; 90 | 91 | mWWosret = armWWos[17] + armWWos[18] + armWWos[19]; 92 | return mWWosret.real(); 93 | } 94 | } // namespace mr 95 | -------------------------------------------------------------------------------- /mr/mOSmMS/mWWos11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double WW::x11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armWWos[22], mWWosret; 9 | 10 | armWWos[1]=double(nH); 11 | armWWos[2]=pow(mmZ,-1); 12 | armWWos[3]=pow(mmH,-1); 13 | armWWos[4]=pow(s,-1); 14 | armWWos[5]=pow(c,-1); 15 | armWWos[6]=Tsil::B(0,mmt,mmW,mu2); 16 | armWWos[7]=Tsil::A(mmt,mu2); 17 | armWWos[8]=pow(mmt,-1); 18 | armWWos[9]=Tsil::Aeps(mmt,mu2); 19 | armWWos[10]=prot00tt0->M(0); 20 | armWWos[11]=prot00tt0->Tuxv(0); 21 | armWWos[12]=double(nL); 22 | armWWos[13]=std::real(Tsil::B(0,0,mmW,mu2)); 23 | armWWos[14]=prot00000->M(0); 24 | armWWos[15]=pow(mmt,2); 25 | armWWos[16]=armWWos[15]*armWWos[11]; 26 | armWWos[17]=armWWos[9]*mmt; 27 | armWWos[16]=armWWos[16] + armWWos[17]; 28 | armWWos[17]=armWWos[10]*pow(mmt,3); 29 | armWWos[16]= - armWWos[17] + 2*armWWos[16]; 30 | armWWos[17]=5*armWWos[6]; 31 | armWWos[17]=armWWos[17]*armWWos[15]; 32 | armWWos[18]=armWWos[6]*mmt; 33 | armWWos[19]= - 6*armWWos[18] - 20./3.*armWWos[7] + 11./3.*mmt; 34 | armWWos[19]=armWWos[19]*armWWos[7]; 35 | armWWos[16]=armWWos[19] + armWWos[17] + 2./3.*armWWos[16]; 36 | armWWos[17]=2*armWWos[2]; 37 | armWWos[17]=armWWos[16]*armWWos[17]; 38 | armWWos[19]=armWWos[7]*armWWos[8]; 39 | armWWos[20]= - 23 + 14*armWWos[6]; 40 | armWWos[20]=2*armWWos[19] + 1./3.*armWWos[20]; 41 | armWWos[21]=4*armWWos[7]; 42 | armWWos[20]=armWWos[20]*armWWos[21]; 43 | armWWos[21]=mmt + 3*armWWos[7]; 44 | armWWos[21]=armWWos[21]*armWWos[7]; 45 | armWWos[15]=armWWos[21] + 3*armWWos[15]; 46 | armWWos[21]=16*armWWos[3]; 47 | armWWos[15]=armWWos[15]*armWWos[21]; 48 | armWWos[18]= - 5./3.*armWWos[18] + 7*mmt; 49 | armWWos[21]=2*armWWos[6]; 50 | armWWos[18]=armWWos[18]*armWWos[21]; 51 | armWWos[21]= - 17./2. + 8*armWWos[11]; 52 | armWWos[21]=armWWos[21]*mmt; 53 | armWWos[21]=armWWos[21] + 8*armWWos[9]; 54 | armWWos[15]= - 1./3.*armWWos[21] - armWWos[15] + armWWos[18] + 55 | armWWos[17] - armWWos[20]; 56 | armWWos[15]=armWWos[15]*armWWos[2]; 57 | armWWos[17]=pow(armWWos[5],2); 58 | armWWos[16]=armWWos[16]*pow(armWWos[2],2)*armWWos[17]; 59 | armWWos[16]=armWWos[15] + 2*armWWos[16]; 60 | armWWos[16]=armWWos[16]*armWWos[17]; 61 | armWWos[17]=1 - armWWos[6]; 62 | armWWos[17]=armWWos[17]*armWWos[19]; 63 | armWWos[18]=armWWos[8]*armWWos[9]; 64 | armWWos[17]=armWWos[11] + armWWos[18] - armWWos[17]; 65 | armWWos[18]=armWWos[10]*mmt; 66 | armWWos[19]= - 1 - 2./3.*armWWos[6]; 67 | armWWos[19]=armWWos[6]*armWWos[19]; 68 | armWWos[18]=armWWos[18] + armWWos[19]; 69 | armWWos[19]=8./3.*mmZ; 70 | armWWos[20]=armWWos[19]*armWWos[10]; 71 | armWWos[15]=armWWos[15] - armWWos[20] - 13 + 4*armWWos[18] - 16./3.* 72 | armWWos[17]; 73 | armWWos[17]=pow(armWWos[4],2); 74 | armWWos[15]=armWWos[15]*armWWos[17]; 75 | armWWos[15]=armWWos[15] + armWWos[20] + armWWos[16]; 76 | armWWos[15]=armWWos[1]*armWWos[15]; 77 | armWWos[16]=armWWos[19]*armWWos[14]; 78 | armWWos[18]= - armWWos[16] - 31./3. - 4*armWWos[13]; 79 | armWWos[17]=armWWos[17]*armWWos[18]; 80 | armWWos[16]=armWWos[16] + armWWos[17]; 81 | armWWos[16]=armWWos[12]*armWWos[16]; 82 | 83 | mWWosret = armWWos[15] + armWWos[16]; 84 | return mWWosret.real(); 85 | } 86 | } // namespace mr 87 | -------------------------------------------------------------------------------- /mr/mOSmMS/mZZos10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double ZZ::x10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armZZos[27], mZZosret; 9 | 10 | armZZos[1]=double(nL + nH); 11 | armZZos[2]=pow(s,-1); 12 | armZZos[3]=pow(c,-1); 13 | armZZos[4]=std::real(Tsil::B(0,0,mmZ,mu2)); 14 | armZZos[5]=double(nH); 15 | armZZos[6]=pow(mmZ,-1); 16 | armZZos[7]=Tsil::B(mmt,mmt,mmZ,mu2); 17 | armZZos[8]=Tsil::A(mmt,mu2); 18 | armZZos[9]=pow(mmH,-1); 19 | armZZos[10]=double(nL); 20 | armZZos[11]=double(boson); 21 | armZZos[12]=Tsil::B(mmW,mmW,mmZ,mu2); 22 | armZZos[13]=Tsil::B(mmZ,mmH,mmZ,mu2); 23 | armZZos[14]=Tsil::A(mmW,mu2); 24 | armZZos[15]=Tsil::A(mmZ,mu2); 25 | armZZos[16]=Tsil::A(mmH,mu2); 26 | armZZos[17]=pow(armZZos[3],2); 27 | armZZos[18]=pow(armZZos[2],2); 28 | armZZos[19]=armZZos[17] + armZZos[18]; 29 | armZZos[20]= - armZZos[15]*armZZos[19]; 30 | armZZos[21]=3*armZZos[18]; 31 | armZZos[22]= - armZZos[17] + 2 - armZZos[21]; 32 | armZZos[22]=mmZ*armZZos[22]; 33 | armZZos[20]=armZZos[22] + 3./2.*armZZos[20]; 34 | armZZos[20]=armZZos[9]*armZZos[20]; 35 | armZZos[22]=armZZos[19]*armZZos[6]; 36 | armZZos[23]=armZZos[15] - armZZos[16]; 37 | armZZos[23]=armZZos[23]*armZZos[22]; 38 | armZZos[23]=1./6.*armZZos[23] + 1./3.*armZZos[19]; 39 | armZZos[23]=mmH*armZZos[23]; 40 | armZZos[24]=armZZos[16] + 1./3.*armZZos[15]; 41 | armZZos[24]= - armZZos[24]*armZZos[19]; 42 | armZZos[23]=armZZos[23] + armZZos[24]; 43 | armZZos[23]=armZZos[6]*armZZos[23]; 44 | armZZos[24]=armZZos[6]*pow(mmH,2); 45 | armZZos[24]=mmH - 1./4.*armZZos[24]; 46 | armZZos[22]=armZZos[24]*armZZos[22]; 47 | armZZos[22]=1./3.*armZZos[22] - armZZos[19]; 48 | armZZos[22]=armZZos[13]*armZZos[22]; 49 | armZZos[24]=1./6.*armZZos[17]; 50 | armZZos[25]=armZZos[24] - 8 + 59./6.*armZZos[18]; 51 | armZZos[26]= - 1./12.*armZZos[17] - 29./3. + 33./4.*armZZos[18]; 52 | armZZos[26]=armZZos[12]*armZZos[26]; 53 | armZZos[24]= - armZZos[24] - 4 + 5./2.*armZZos[18]; 54 | armZZos[24]=armZZos[6]*armZZos[24]; 55 | armZZos[21]= - armZZos[9]*armZZos[21]; 56 | armZZos[21]=armZZos[21] + armZZos[24]; 57 | armZZos[21]=armZZos[14]*armZZos[21]; 58 | armZZos[24]= - 1 - armZZos[12]; 59 | armZZos[24]=armZZos[24]*pow(c,2); 60 | armZZos[20]=armZZos[21] + 4*armZZos[24] + armZZos[26] + armZZos[22] 61 | + 1./2.*armZZos[23] + 1./3.*armZZos[25] + armZZos[20]; 62 | armZZos[20]=armZZos[11]*armZZos[20]; 63 | armZZos[21]=17./9.*armZZos[17] + armZZos[18] - 32./9.; 64 | armZZos[19]=armZZos[8]*armZZos[9]*armZZos[19]; 65 | armZZos[22]=1./2.*armZZos[18]; 66 | armZZos[23]= - 7./18.*armZZos[17] + 32./9. + armZZos[22]; 67 | armZZos[23]=armZZos[7]*armZZos[23]; 68 | armZZos[19]=armZZos[23] + 6*armZZos[19] - armZZos[21]; 69 | armZZos[19]=mmt*armZZos[19]; 70 | armZZos[21]= - armZZos[8]*armZZos[21]; 71 | armZZos[19]=armZZos[19] + armZZos[21]; 72 | armZZos[19]=armZZos[19]*armZZos[6]; 73 | armZZos[21]=11./9.*armZZos[17] + armZZos[18] - 20./9.; 74 | armZZos[23]= - 5./18.*armZZos[17] + 4./9. - armZZos[22]; 75 | armZZos[23]=armZZos[4]*armZZos[23]; 76 | armZZos[22]= - 17./18.*armZZos[17] + 16./9. - armZZos[22]; 77 | armZZos[22]=armZZos[7]*armZZos[22]; 78 | armZZos[19]=armZZos[19] + armZZos[22] + 1./3.*armZZos[21] + 79 | armZZos[23]; 80 | armZZos[19]=armZZos[5]*armZZos[19]; 81 | armZZos[21]= - armZZos[10]*armZZos[21]; 82 | armZZos[18]=armZZos[18] - 4; 83 | armZZos[17]=armZZos[17] + 1./3.*armZZos[18]; 84 | armZZos[17]= - armZZos[1]*armZZos[17]; 85 | armZZos[17]=armZZos[17] + armZZos[21]; 86 | armZZos[18]=armZZos[4] - 1./3.; 87 | armZZos[17]=armZZos[18]*armZZos[17]; 88 | 89 | mZZosret = armZZos[17] + armZZos[19] + armZZos[20]; 90 | return mZZosret.real(); 91 | } 92 | } // namespace mr 93 | -------------------------------------------------------------------------------- /mr/mOSmMS/mbbos01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double bb::x01(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armbbos[5], mbbosret; 9 | 10 | armbbos[1]=double(boson); 11 | armbbos[2]=Tsil::A(mmb,mu2); 12 | armbbos[3]=pow(mmb,-1); 13 | armbbos[4]= - armbbos[3]*armbbos[2]; 14 | armbbos[4]=1./3. + armbbos[4]; 15 | 16 | mbbosret = 4*armbbos[4]*armbbos[1]; 17 | return mbbosret.real(); 18 | } 19 | } // namespace mr 20 | -------------------------------------------------------------------------------- /mr/mOSmMS/mbbos10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double bb::x10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armbbos[22], mbbosret; 9 | 10 | armbbos[1]=double(nH); 11 | armbbos[2]=Tsil::A(mmt,mu2); 12 | armbbos[3]=pow(mmZ,-1); 13 | armbbos[4]=pow(mmH,-1); 14 | armbbos[5]=pow(s,-1); 15 | armbbos[6]=pow(c,-1); 16 | armbbos[7]=double(boson); 17 | armbbos[8]=Tsil::A(mmW,mu2); 18 | armbbos[9]=Tsil::A(mmZ,mu2); 19 | armbbos[10]=Tsil::A(mmH,mu2); 20 | armbbos[11]=Tsil::A(mmb,mu2); 21 | armbbos[12]=pow(mmb,-1); 22 | armbbos[13]=1/(mmt - mmW); 23 | armbbos[14]=armbbos[2] - armbbos[8]; 24 | armbbos[15]=pow(armbbos[5],2); 25 | armbbos[16]=armbbos[15] - 1; 26 | armbbos[14]=armbbos[13]*armbbos[16]*armbbos[14]; 27 | armbbos[14]=armbbos[14] + 1; 28 | armbbos[14]=mmZ*armbbos[14]; 29 | armbbos[16]=armbbos[8] + mmZ; 30 | armbbos[16]=armbbos[16]*armbbos[15]; 31 | armbbos[14]= - armbbos[16] + armbbos[14]; 32 | armbbos[14]=armbbos[13]*armbbos[14]; 33 | armbbos[17]=pow(armbbos[6],2); 34 | armbbos[18]=armbbos[17] + armbbos[15]; 35 | armbbos[19]=armbbos[9]*armbbos[18]; 36 | armbbos[20]=1./2.*armbbos[17]; 37 | armbbos[21]=1 - armbbos[20]; 38 | armbbos[21]=mmZ*armbbos[21]; 39 | armbbos[16]= - 3./4.*armbbos[19] - 3./2.*armbbos[16] + armbbos[21]; 40 | armbbos[16]=armbbos[4]*armbbos[16]; 41 | armbbos[19]=1./2.*mmt + 3*armbbos[2]; 42 | armbbos[19]= - 3./8.*armbbos[10] - 1./8.*armbbos[19]; 43 | armbbos[19]=armbbos[18]*armbbos[19]; 44 | armbbos[20]=1 + armbbos[20]; 45 | armbbos[20]=armbbos[9]*armbbos[20]; 46 | armbbos[19]=1./3.*armbbos[20] + armbbos[19]; 47 | armbbos[19]=armbbos[3]*armbbos[19]; 48 | armbbos[17]=1 + 31./24.*armbbos[17]; 49 | armbbos[20]= - armbbos[12]*armbbos[11]; 50 | armbbos[17]=1./2.*armbbos[17] + armbbos[20]; 51 | armbbos[14]=armbbos[16] + 3./8.*armbbos[14] + 1./3.*armbbos[17] + 3./ 52 | 16.*armbbos[15] + armbbos[19]; 53 | armbbos[14]=armbbos[7]*armbbos[14]; 54 | armbbos[15]=armbbos[4]*armbbos[3]*armbbos[2]*armbbos[18]*armbbos[1]* 55 | mmt; 56 | 57 | mbbosret = armbbos[14] + 3*armbbos[15]; 58 | return mbbosret.real(); 59 | } 60 | } // namespace mr 61 | -------------------------------------------------------------------------------- /mr/mOSmMS/mttos01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double tt::x01(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armttos[5], mttosret; 9 | 10 | armttos[1]=double(boson); 11 | armttos[2]=Tsil::A(mmt,mu2); 12 | armttos[3]=pow(mmt,-1); 13 | armttos[4]= - armttos[3]*armttos[2]; 14 | armttos[4]=1./3. + armttos[4]; 15 | 16 | mttosret = 4*armttos[4]*armttos[1]; 17 | return mttosret.real(); 18 | } 19 | } // namespace mr 20 | -------------------------------------------------------------------------------- /mr/mOSmMS/mttos10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double tt::x10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex armttos[24], mttosret; 9 | 10 | armttos[1]=double(nH); 11 | armttos[2]=Tsil::A(mmt,mu2); 12 | armttos[3]=pow(mmZ,-1); 13 | armttos[4]=pow(mmH,-1); 14 | armttos[5]=pow(s,-1); 15 | armttos[6]=pow(c,-1); 16 | armttos[7]=double(boson); 17 | armttos[8]=Tsil::B(mmZ,mmt,mmt,mu2); 18 | armttos[9]=pow(mmt,-1); 19 | armttos[10]=Tsil::B(mmH,mmt,mmt,mu2); 20 | armttos[11]=Tsil::A(mmW,mu2); 21 | armttos[12]=Tsil::A(mmZ,mu2); 22 | armttos[13]=Tsil::A(mmH,mu2); 23 | armttos[14]=std::real(Tsil::B(0,mmW,mmt,mu2)); 24 | armttos[15]=1./4.*armttos[14]; 25 | armttos[16]=pow(armttos[5],2); 26 | armttos[17]= - 1 + armttos[16]; 27 | armttos[17]=armttos[17]*armttos[15]; 28 | armttos[18]=1./8.*armttos[16]; 29 | armttos[19]=pow(armttos[6],2); 30 | armttos[20]=armttos[18] + 17./72.*armttos[19]; 31 | armttos[21]=armttos[20] - 4./9.; 32 | armttos[22]=armttos[8]*armttos[21]; 33 | armttos[17]=armttos[17] + armttos[22]; 34 | armttos[17]=mmZ*armttos[17]; 35 | armttos[21]=armttos[12]*armttos[21]; 36 | armttos[20]= - 8./9. - armttos[20]; 37 | armttos[20]=armttos[2]*armttos[20]; 38 | armttos[22]=1./4.*armttos[11]; 39 | armttos[23]=armttos[16]*armttos[22]; 40 | armttos[17]=armttos[23] + armttos[17] + armttos[21] + armttos[20]; 41 | armttos[17]=armttos[9]*armttos[17]; 42 | armttos[20]=armttos[13] + armttos[2]; 43 | armttos[21]=armttos[10]*mmt; 44 | armttos[23]=mmH*armttos[10]; 45 | armttos[20]=1./4.*armttos[23] - armttos[22] - armttos[21] - 1./2.* 46 | armttos[20]; 47 | armttos[21]=armttos[19] + armttos[16]; 48 | armttos[20]=armttos[21]*armttos[20]; 49 | armttos[22]=armttos[21]*mmt; 50 | armttos[15]= - armttos[15]*armttos[22]; 51 | armttos[15]=armttos[15] + armttos[20]; 52 | armttos[15]=armttos[3]*armttos[15]; 53 | armttos[20]=3./2.*armttos[4]; 54 | armttos[23]= - armttos[11]*armttos[20]; 55 | armttos[23]=armttos[23] - 1./8.*armttos[14] + 3./8.; 56 | armttos[23]=armttos[16]*armttos[23]; 57 | armttos[21]= - armttos[12]*armttos[21]*armttos[4]; 58 | armttos[18]=7./72.*armttos[19] - armttos[18] - 8./9.; 59 | armttos[18]=armttos[8]*armttos[18]; 60 | armttos[16]= - armttos[16]*armttos[20]; 61 | armttos[20]= - 1./2.*armttos[19] + 1; 62 | armttos[20]=armttos[4]*armttos[20]; 63 | armttos[16]=armttos[16] + armttos[20]; 64 | armttos[16]=mmZ*armttos[16]; 65 | armttos[15]=1./2.*armttos[15] + armttos[17] + armttos[16] + 66 | armttos[18] + 3./4.*armttos[21] + 1./72.*armttos[19] + 8./9. + 67 | armttos[23]; 68 | armttos[15]=armttos[7]*armttos[15]; 69 | armttos[16]=armttos[3]*armttos[2]*armttos[1]*armttos[4]*armttos[22]; 70 | 71 | mttosret = armttos[15] + 3*armttos[16]; 72 | return mttosret.real(); 73 | } 74 | } // namespace mr 75 | -------------------------------------------------------------------------------- /mr/mr.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MR - 2-loop matching and 3-loop Running, including full 2-loop EW corrections 3 | // Copyright (C) 2014 Andrey Pikelner 4 | // 5 | // This file is part of MR. 6 | // 7 | // MR is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // (at your option) any later version. 11 | // 12 | // MR is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with MR. If not, see . 19 | // 20 | 21 | #ifndef __MR_HPP__ 22 | #define __MR_HPP__ 23 | 24 | #include "WW.hpp" 25 | #include "ZZ.hpp" 26 | #include "HH.hpp" 27 | #include "tt.hpp" 28 | #include "bb.hpp" 29 | #include "dr.hpp" 30 | #include "alphaGF.hpp" 31 | #include "alphas.hpp" 32 | #include "smRGE.hpp" 33 | #include "p2ms.hpp" 34 | #include "logger.hpp" 35 | 36 | #endif // __MR_HPP__ 37 | -------------------------------------------------------------------------------- /mr/operators.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MR - 2-loop matching and 3-loop Running, including full 2-loop EW corrections 3 | // Copyright (C) 2014 Andrey Pikelner 4 | // 5 | // This file is part of MR. 6 | // 7 | // MR is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // (at your option) any later version. 11 | // 12 | // MR is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with MR. If not, see . 19 | // 20 | 21 | #ifndef __OPERATORS_HPP__ 22 | #define __OPERATORS_HPP__ 23 | 24 | namespace mr 25 | { 26 | template 27 | inline std::complex operator*(std::complex lhs, const U& rhs) 28 | { 29 | return lhs *= rhs; 30 | } 31 | 32 | template 33 | inline std::complex operator*(const U& rhs, std::complex lhs) 34 | { 35 | return lhs *= rhs; 36 | } 37 | 38 | template 39 | inline std::complex operator/(std::complex lhs, const U& rhs) 40 | { 41 | return lhs /= rhs; 42 | } 43 | 44 | 45 | template 46 | inline std::complex operator/(const U& lhs, std::complex rhs) 47 | { 48 | return std::complex(lhs) /= rhs; 49 | } 50 | 51 | template 52 | inline std::complex operator+(std::complex lhs,const U& rhs) 53 | { 54 | return lhs += rhs; 55 | } 56 | 57 | template 58 | inline std::complex operator+(const U& rhs, std::complex lhs) 59 | { 60 | return lhs += rhs; 61 | } 62 | 63 | template 64 | inline std::complex operator-(std::complex lhs, const U& rhs) 65 | { 66 | return lhs -= rhs; 67 | } 68 | 69 | template 70 | inline std::complex operator-(const U& lhs, std::complex rhs) 71 | { 72 | return std::complex(lhs) -= rhs; 73 | } 74 | 75 | template 76 | inline std::complex Re(std::complex z) 77 | { 78 | return std::complex(z.real(),0); 79 | } 80 | } // namespace mr 81 | #endif // __OPERATORS_HPP__ 82 | -------------------------------------------------------------------------------- /mr/p2ms.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // MR - 2-loop matching and 3-loop Running, including full 2-loop EW corrections 3 | // Copyright (C) 2014 Andrey Pikelner 4 | // 5 | // This file is part of MR. 6 | // 7 | // MR is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // (at your option) any later version. 11 | // 12 | // MR is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with MR. If not, see . 19 | // 20 | 21 | #include "boost/math/tools/roots.hpp" 22 | #include "boost/numeric/interval.hpp" 23 | #include "p2ms.hpp" 24 | #include 25 | #include "alphas.hpp" 26 | #include "bb.hpp" 27 | #include "WW.hpp" 28 | #include "ZZ.hpp" 29 | #include "HH.hpp" 30 | #include "tt.hpp" 31 | #include "alphaGF.hpp" 32 | 33 | namespace mr 34 | { 35 | struct DiffGF 36 | { 37 | 38 | OSinput oi; 39 | 40 | unsigned ord; 41 | double Gf0; 42 | double alphaS; 43 | 44 | // Precalculated set of corrections 45 | double Wy10, Wy11, Wy20, Zy10, Zy11, Zy20; 46 | 47 | DiffGF(OSinput in_, double Gf0_, double as_, double mu2, unsigned order_) : oi(in_), Gf0(Gf0_), alphaS(as_), ord(order_) 48 | { 49 | WW dW(oi, mu2); 50 | ZZ dZ(oi, mu2); 51 | 52 | Wy10 = dW.y10(); 53 | Wy11 = dW.y11(); 54 | Wy20 = dW.y20(); 55 | 56 | Zy10 = dZ.y10(); 57 | Zy11 = dZ.y11(); 58 | Zy20 = dZ.y20(); 59 | } 60 | 61 | double operator()(double alpha) 62 | { 63 | double dMyW = 1; 64 | double dMyZ = 1; 65 | double Gf; 66 | 67 | if(ord & order::x10) 68 | { 69 | dMyW += alpha/4./Pi*Wy10; 70 | dMyZ += alpha/4./Pi*Zy10; 71 | } 72 | if(ord & order::x11) 73 | { 74 | dMyW += alpha/4./Pi*alphaS/4./Pi*Wy11; 75 | dMyZ += alpha/4./Pi*alphaS/4./Pi*Zy11; 76 | } 77 | if(ord & order::x20) 78 | { 79 | dMyW += pow(alpha/4./Pi,2)*Wy20; 80 | dMyZ += pow(alpha/4./Pi,2)*Zy20; 81 | } 82 | 83 | 84 | Gf = alpha*Pi/sqrt(2)/oi.MMW()/dMyW/(1-oi.MMW()/oi.MMZ()*dMyW/dMyZ); 85 | 86 | return (Gf0 - Gf)*pow(10,2); 87 | } 88 | 89 | }; 90 | 91 | 92 | 93 | 94 | double AlphaSolve::operator()(const double& mu2 ) 95 | { 96 | DiffGF dGF(oi, Gf0, alphaS, mu2, ord); 97 | 98 | boost::uintmax_t max_iter=50; 99 | std::pair found = 100 | boost::math::tools::toms748_solve(dGF, 1./140., 1./120., tol, max_iter); 101 | 102 | boost::numeric::interval fint(found.first, found.second); 103 | 104 | std::cout << std::setprecision(10); 105 | lout(logDEBUG) << "==> 1/alpha = [" << 1./found.first << ',' << 1./found.second << "]"; 106 | 107 | return boost::numeric::median(fint);; 108 | } 109 | 110 | 111 | double AlphaGF::operator()(const double& mu2 ) 112 | { 113 | 114 | alphaGF aGF = alphaGF(oi, mu2); 115 | 116 | double daGF = 1; 117 | 118 | // Tree level 119 | double alF = sqrt(2)*Gf0*oi.MMW()/Pi*(1-oi.MMW()/oi.MMZ()); 120 | 121 | if(ord & order::x10) 122 | { 123 | daGF += alF/4./Pi*aGF.a10(); 124 | } 125 | if(ord & order::x11) 126 | { 127 | daGF += alF/4./Pi*alphaS/4./Pi*aGF.a11(); 128 | } 129 | if(ord & order::x20) 130 | { 131 | daGF += pow(alF/4./Pi,2)*aGF.a20(); 132 | } 133 | 134 | lout(logDEBUG) << " Alpha from GF: " << alF*daGF << std::endl; 135 | return alF*daGF; 136 | } 137 | 138 | // logger 139 | loglevel_e loglevel = logERROR; 140 | 141 | } // namespace mr 142 | 143 | 144 | -------------------------------------------------------------------------------- /mr/tdecl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MR - 2-loop matching and 3-loop Running, including full 2-loop EW corrections 3 | // Copyright (C) 2014 Andrey Pikelner 4 | // 5 | // This file is part of MR. 6 | // 7 | // MR is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // (at your option) any later version. 11 | // 12 | // MR is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with MR. If not, see . 19 | // 20 | 21 | #ifndef __TDECL_HPP__ 22 | #define __TDECL_HPP__ 23 | 24 | 25 | // Type for couplings 26 | typedef double Rt; 27 | 28 | // Type for masses 29 | typedef double MRt; 30 | 31 | // Couplings set 32 | typedef std::vector SMCouplings; 33 | 34 | 35 | // 36 | // Tolerance class for root-finding algorithms 37 | // 38 | class Tolerance { 39 | public: 40 | Tolerance(double eps) : 41 | _eps(eps) { 42 | } 43 | bool operator()(double a, double b) { 44 | return (std::abs(b - a) <= _eps); 45 | } 46 | private: 47 | double _eps; 48 | }; 49 | 50 | 51 | #endif // __TDECL_HPP__ 52 | -------------------------------------------------------------------------------- /mr/timer.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MR - 2-loop matching and 3-loop Running, including full 2-loop EW corrections 3 | // Copyright (C) 2014 Andrey Pikelner 4 | // 5 | // This file is part of MR. 6 | // 7 | // MR is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // (at your option) any later version. 11 | // 12 | // MR is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with MR. If not, see . 19 | // 20 | 21 | #ifndef __TIMER_HPP__ 22 | #define __TIMER_HPP__ 23 | 24 | #include 25 | #include 26 | #include "logger.hpp" 27 | 28 | namespace mr 29 | { 30 | class Timer 31 | { 32 | std::clock_t start; 33 | public: 34 | Timer():start(std::clock()) 35 | { 36 | } 37 | 38 | void elapsed() 39 | { 40 | lout(logDEBUG) << "Time: " << (std::clock() - start) / (double)(CLOCKS_PER_SEC / 1000) << " ms"; 41 | } 42 | 43 | void inMs() 44 | { 45 | std::cout << "Time: " << (std::clock() - start) / (double)(CLOCKS_PER_SEC / 1000) << " ms" << std::endl; 46 | } 47 | void inSec() 48 | { 49 | std::cout << "Time: " << (std::clock() - start) / (double)(CLOCKS_PER_SEC) << " s" << std::endl; 50 | } 51 | void inMin() 52 | { 53 | std::cout << "Time: " << (std::clock() - start) / (double)(CLOCKS_PER_SEC * 60) << " min" << std::endl; 54 | } 55 | }; 56 | } // namespace mr 57 | 58 | #endif // __TIMER_HPP__ 59 | -------------------------------------------------------------------------------- /mr/tsil.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // MR - 2-loop matching and 3-loop Running, including full 2-loop EW corrections 3 | // Copyright (C) 2014 Andrey Pikelner 4 | // 5 | // This file is part of MR. 6 | // 7 | // MR is free software: you can redistribute it and/or modify 8 | // it under the terms of the GNU General Public License as published by 9 | // the Free Software Foundation, either version 3 of the License, or 10 | // (at your option) any later version. 11 | // 12 | // MR is distributed in the hope that it will be useful, 13 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | // GNU General Public License for more details. 16 | // 17 | // You should have received a copy of the GNU General Public License 18 | // along with MR. If not, see . 19 | // 20 | 21 | #include 22 | 23 | namespace mr 24 | { 25 | std::complex c2pp(TSIL_COMPLEX z) 26 | { 27 | return std::complex(__real__ z, __imag__ z); 28 | } 29 | 30 | std::complex csqrt(double z) 31 | { 32 | return sqrt(std::complex(z,0)); 33 | } 34 | 35 | std::complex Li2(std::complex z) 36 | { 37 | return TSIL_Dilog(*((TSIL_COMPLEX*) (&z))); 38 | } 39 | 40 | std::complex Li3(std::complex z) 41 | { 42 | return TSIL_Trilog(*((TSIL_COMPLEX*) (&z))); 43 | } 44 | 45 | std::complex acc(std::complex z) 46 | { return z; } 47 | 48 | std::complex inv(std::complex z) 49 | { return std::complex(1.,0)/z; } 50 | 51 | } // namespace mr 52 | -------------------------------------------------------------------------------- /mr/yu/README: -------------------------------------------------------------------------------- 1 | Corrections to MS coupling in terms of OS masses 2 | 3 | Y_ij - functions of OS masses 4 | 5 | aw(mu) - EM running coupling (alEM/4/Pi) 6 | 7 | as(mu) - QCD running coupling (alS/4/Pi) 8 | 9 | delta = 1 + as*Y_01 + aw*Y_10 + aw*as*Y_11 + aw^2*Y_20 + ... 10 | -------------------------------------------------------------------------------- /mr/yu/yuHH10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double HH::y10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryuHH[29], yuHHret; 9 | 10 | aryuHH[1]=double(nH); 11 | aryuHH[2]=double(boson); 12 | aryuHH[3]=pow(CW,-1); 13 | aryuHH[4]=pow(MMZ,-1); 14 | aryuHH[5]=pow(SW,-1); 15 | aryuHH[6]=Tsil::B(MMt,MMt,MMH,mu2); 16 | aryuHH[7]=pow(MMH,-1); 17 | aryuHH[8]=Tsil::B(MMb,MMb,MMH,mu2); 18 | aryuHH[9]=Tsil::A(MMt,mu2); 19 | aryuHH[10]=Tsil::B(MMH,MMH,MMH,mu2); 20 | aryuHH[11]=Tsil::B(MMZ,MMZ,MMH,mu2); 21 | aryuHH[12]=Tsil::B(MMW,MMW,MMH,mu2); 22 | aryuHH[13]=Tsil::A(MMZ,mu2); 23 | aryuHH[14]=Tsil::A(MMW,mu2); 24 | aryuHH[15]=1/( - MMb + MMt); 25 | aryuHH[16]=Tsil::A(MMb,mu2); 26 | aryuHH[17]=1/( - MMW + MMH); 27 | aryuHH[18]=Tsil::A(MMH,mu2); 28 | aryuHH[19]= - MMt + MMb; 29 | aryuHH[20]=1./2.*aryuHH[1]; 30 | aryuHH[19]=aryuHH[20]*aryuHH[19]; 31 | aryuHH[21]=aryuHH[16]*aryuHH[1]; 32 | aryuHH[22]=aryuHH[9]*aryuHH[1]; 33 | aryuHH[19]=aryuHH[21] - aryuHH[22] + aryuHH[19]; 34 | aryuHH[21]=3./2.*aryuHH[15]; 35 | aryuHH[19]=aryuHH[19]*aryuHH[21]; 36 | aryuHH[21]=2*aryuHH[7]; 37 | aryuHH[23]=aryuHH[21]*MMb*aryuHH[1]; 38 | aryuHH[23]=aryuHH[23] - aryuHH[20]; 39 | aryuHH[23]=aryuHH[8]*aryuHH[23]; 40 | aryuHH[19]=aryuHH[19] - 3*aryuHH[23]; 41 | aryuHH[19]=aryuHH[19]*MMb; 42 | aryuHH[23]=aryuHH[11] + 1; 43 | aryuHH[24]=1./8.*MMH; 44 | aryuHH[23]=aryuHH[24]*aryuHH[23]; 45 | aryuHH[24]=MMt*aryuHH[1]; 46 | aryuHH[21]=aryuHH[21]*aryuHH[24]; 47 | aryuHH[20]=aryuHH[21] - aryuHH[20]; 48 | aryuHH[21]=aryuHH[6]*MMt; 49 | aryuHH[21]=3*aryuHH[21]; 50 | aryuHH[20]=aryuHH[20]*aryuHH[21]; 51 | aryuHH[21]=9./8.*aryuHH[10] + 1./4.*aryuHH[12]; 52 | aryuHH[21]=aryuHH[21]*MMH; 53 | aryuHH[19]=aryuHH[19] + aryuHH[21] - 3./2.*aryuHH[22] + aryuHH[13] 54 | - aryuHH[20] - 3./4.*aryuHH[24] + 2*aryuHH[14] + aryuHH[23]; 55 | aryuHH[19]=aryuHH[19]*aryuHH[4]; 56 | aryuHH[20]=1./2.*aryuHH[11]; 57 | aryuHH[21]=aryuHH[12] + aryuHH[20]; 58 | aryuHH[22]=MMZ*aryuHH[7]; 59 | aryuHH[23]=3*aryuHH[22]; 60 | aryuHH[24]=aryuHH[23] - 1; 61 | aryuHH[21]=aryuHH[24]*aryuHH[21]; 62 | aryuHH[25]=pow(aryuHH[5],2); 63 | aryuHH[26]= - aryuHH[13] + aryuHH[14]; 64 | aryuHH[26]=aryuHH[4]*aryuHH[26]*aryuHH[25]; 65 | aryuHH[27]=aryuHH[22] - 1./8.; 66 | aryuHH[28]=aryuHH[18] - aryuHH[14]; 67 | aryuHH[28]=3./4.*aryuHH[28]; 68 | aryuHH[28]=aryuHH[17]*aryuHH[28]; 69 | aryuHH[21]=3./4.*aryuHH[26] + aryuHH[19] - 3*aryuHH[27] + aryuHH[28] 70 | + aryuHH[21]; 71 | aryuHH[21]=aryuHH[25]*aryuHH[21]; 72 | aryuHH[20]=aryuHH[24]*aryuHH[20]; 73 | aryuHH[19]=aryuHH[19] + aryuHH[20] - aryuHH[27]; 74 | aryuHH[19]=aryuHH[19]*pow(aryuHH[3],2); 75 | aryuHH[20]= - aryuHH[12]*aryuHH[23]; 76 | aryuHH[19]=aryuHH[21] + aryuHH[19] + 2*aryuHH[22] + aryuHH[20]; 77 | 78 | yuHHret = aryuHH[19]*aryuHH[2]; 79 | return yuHHret.real(); 80 | } 81 | } // namespace mr 82 | -------------------------------------------------------------------------------- /mr/yu/yuHH11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double HH::y11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryuHH[21], yuHHret; 9 | 10 | aryuHH[1]=double(nH); 11 | aryuHH[2]=pow(CW,-1); 12 | aryuHH[3]=pow(MMH,-1); 13 | aryuHH[4]=pow(MMZ,-1); 14 | aryuHH[5]=pow(SW,-1); 15 | aryuHH[6]=Tsil::I2(0,0,MMt,mu2); 16 | aryuHH[7]=Tsil::B(MMt,MMt,MMH,mu2); 17 | aryuHH[8]=Tsil::A(MMt,mu2); 18 | aryuHH[9]=Tsil::Beps(MMt,MMt,MMH,mu2); 19 | aryuHH[10]=pow(MMt,-1); 20 | aryuHH[11]=Tsil::Aeps(MMt,mu2); 21 | aryuHH[12]=prottttt0->M(0); 22 | aryuHH[13]=prottttt0->Vxzuv(0); 23 | aryuHH[14]=prottttt0->Suxv(0); 24 | aryuHH[15]=4 + 3*aryuHH[7]; 25 | aryuHH[16]=2*aryuHH[7]; 26 | aryuHH[15]=aryuHH[15]*aryuHH[16]; 27 | aryuHH[16]=2*aryuHH[13]; 28 | aryuHH[17]=aryuHH[16] + 3*aryuHH[12]; 29 | aryuHH[18]=8*MMt; 30 | aryuHH[17]=aryuHH[17]*aryuHH[18]; 31 | aryuHH[15]= - aryuHH[17] + aryuHH[15] + 85./2.; 32 | aryuHH[15]=aryuHH[15]*MMt; 33 | aryuHH[17]=aryuHH[3]*MMt; 34 | aryuHH[19]=aryuHH[17]*aryuHH[14]; 35 | aryuHH[20]=aryuHH[10]*pow(aryuHH[8],2); 36 | aryuHH[19]= - aryuHH[6] + aryuHH[19] + aryuHH[20]; 37 | aryuHH[16]=aryuHH[16] + aryuHH[12]; 38 | aryuHH[16]=aryuHH[16]*aryuHH[18]; 39 | aryuHH[18]=10 + 7*aryuHH[7]; 40 | aryuHH[18]=aryuHH[18]*aryuHH[7]; 41 | aryuHH[16]=4*aryuHH[9] - aryuHH[18] + aryuHH[16] - 25; 42 | aryuHH[18]=4*aryuHH[3]; 43 | aryuHH[16]=aryuHH[18]*aryuHH[16]*pow(MMt,2); 44 | aryuHH[18]= - 6 + 36*aryuHH[17]; 45 | aryuHH[18]=aryuHH[18]*aryuHH[7]; 46 | aryuHH[18]=aryuHH[18] + 5; 47 | aryuHH[20]=2*aryuHH[8]; 48 | aryuHH[18]=aryuHH[18]*aryuHH[20]; 49 | aryuHH[17]= - 1 + 6*aryuHH[17]; 50 | aryuHH[20]=4*aryuHH[11]; 51 | aryuHH[17]=aryuHH[17]*aryuHH[20]; 52 | aryuHH[20]=4*MMt; 53 | aryuHH[20]=aryuHH[20]*MMH*aryuHH[12]; 54 | aryuHH[15]=aryuHH[16] + aryuHH[15] - aryuHH[18] + aryuHH[17] + 55 | aryuHH[20] - 4*aryuHH[19]; 56 | aryuHH[16]=pow(aryuHH[5],2); 57 | aryuHH[17]=pow(aryuHH[2],2); 58 | aryuHH[16]=aryuHH[16] + aryuHH[17]; 59 | 60 | yuHHret = aryuHH[16]*aryuHH[15]*aryuHH[4]*aryuHH[1]; 61 | return yuHHret.real(); 62 | } 63 | } // namespace mr 64 | -------------------------------------------------------------------------------- /mr/yu/yuWW10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double WW::y10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryuWW[30], yuWWret; 9 | 10 | aryuWW[1]=double(nH); 11 | aryuWW[2]=double(boson); 12 | aryuWW[3]=pow(CW,-1); 13 | aryuWW[4]=pow(MMZ,-1); 14 | aryuWW[5]=pow(SW,-1); 15 | aryuWW[6]=Tsil::B(MMt,MMb,MMW,mu2); 16 | aryuWW[7]=Tsil::B(0,0,MMW,mu2); 17 | aryuWW[8]=Tsil::A(MMt,mu2); 18 | aryuWW[9]=Tsil::A(MMb,mu2); 19 | aryuWW[10]=double(nL + nH); 20 | aryuWW[11]=Tsil::B(MMW,MMH,MMW,mu2); 21 | aryuWW[12]=Tsil::B(MMW,MMZ,MMW,mu2); 22 | aryuWW[13]=Tsil::A(MMH,mu2); 23 | aryuWW[14]=Tsil::A(MMZ,mu2); 24 | aryuWW[15]=Tsil::A(MMW,mu2); 25 | aryuWW[16]=1/( - MMb + MMt); 26 | aryuWW[17]=1/( - MMW + MMH); 27 | aryuWW[18]=aryuWW[11]*pow(MMH,2); 28 | aryuWW[19]=aryuWW[13]*MMH; 29 | aryuWW[18]=aryuWW[18] + aryuWW[19]; 30 | aryuWW[19]=aryuWW[9] - aryuWW[8]; 31 | aryuWW[20]=MMb*aryuWW[1]; 32 | aryuWW[19]=aryuWW[20]*aryuWW[19]; 33 | aryuWW[21]=pow(MMb,2); 34 | aryuWW[22]=aryuWW[6]*aryuWW[1]; 35 | aryuWW[23]=aryuWW[21]*aryuWW[22]; 36 | aryuWW[18]= - aryuWW[19] - aryuWW[23] + 1./6.*aryuWW[18]; 37 | aryuWW[23]=aryuWW[9]*aryuWW[1]; 38 | aryuWW[24]=aryuWW[8]*aryuWW[1]; 39 | aryuWW[24]=aryuWW[23] - aryuWW[24]; 40 | aryuWW[25]=1./2.*MMt; 41 | aryuWW[26]=aryuWW[25]*aryuWW[22]; 42 | aryuWW[27]=aryuWW[20]*aryuWW[6]; 43 | aryuWW[24]= - aryuWW[26] + aryuWW[27] + 1./2.*aryuWW[24]; 44 | aryuWW[24]=aryuWW[24]*MMt; 45 | aryuWW[26]=aryuWW[15]*MMH; 46 | aryuWW[18]=1./2.*aryuWW[18] + aryuWW[24] - 1./12.*aryuWW[26]; 47 | aryuWW[18]=aryuWW[18]*aryuWW[4]; 48 | aryuWW[24]=1./2.*aryuWW[1]; 49 | aryuWW[26]=aryuWW[24] - aryuWW[22]; 50 | aryuWW[26]=aryuWW[26]*aryuWW[25]; 51 | aryuWW[28]=aryuWW[11] + 1./8.; 52 | aryuWW[29]=1./3.*MMH; 53 | aryuWW[28]=aryuWW[28]*aryuWW[29]; 54 | aryuWW[29]=aryuWW[24]*aryuWW[8]; 55 | aryuWW[23]= - aryuWW[18] - aryuWW[26] - aryuWW[20] + aryuWW[28] + 1./ 56 | 2.*aryuWW[27] + 1./4.*aryuWW[13] + aryuWW[29] - aryuWW[23]; 57 | aryuWW[26]=aryuWW[15] - aryuWW[14]; 58 | aryuWW[18]= - 1./12.*aryuWW[26] + aryuWW[18]; 59 | aryuWW[27]=pow(aryuWW[3],2); 60 | aryuWW[18]=aryuWW[18]*aryuWW[27]; 61 | aryuWW[18]=aryuWW[18] + 53./12.*aryuWW[15] + 3./2.*aryuWW[14] - 62 | aryuWW[23]; 63 | aryuWW[18]=aryuWW[4]*aryuWW[18]; 64 | aryuWW[18]= - 1./24. + aryuWW[18]; 65 | aryuWW[18]=aryuWW[18]*aryuWW[27]; 66 | aryuWW[28]=17 + aryuWW[27]; 67 | aryuWW[28]=aryuWW[28]*aryuWW[27]; 68 | aryuWW[28]=4 + 1./12.*aryuWW[28]; 69 | aryuWW[28]=aryuWW[12]*aryuWW[28]; 70 | aryuWW[18]=aryuWW[28] - 4 + aryuWW[18]; 71 | aryuWW[18]=aryuWW[2]*aryuWW[18]; 72 | aryuWW[23]=5./12.*aryuWW[15] - 1./2.*aryuWW[14] - aryuWW[23]; 73 | aryuWW[23]=aryuWW[4]*aryuWW[23]; 74 | aryuWW[28]=aryuWW[15] - aryuWW[13]; 75 | aryuWW[28]= - 3./4.*aryuWW[28]; 76 | aryuWW[28]=aryuWW[17]*aryuWW[28]; 77 | aryuWW[29]= - aryuWW[1] + 4./3.*aryuWW[10]; 78 | aryuWW[29]=aryuWW[7]*aryuWW[29]; 79 | aryuWW[22]= - 33./4.*aryuWW[12] + aryuWW[23] + aryuWW[22] + 80 | aryuWW[29] - 4./9.*aryuWW[10] - 209./72. + aryuWW[11] + aryuWW[28]; 81 | aryuWW[22]=aryuWW[2]*aryuWW[22]; 82 | aryuWW[20]=aryuWW[25]*aryuWW[20]; 83 | aryuWW[21]=aryuWW[21]*aryuWW[24]; 84 | aryuWW[19]= - aryuWW[19] + aryuWW[20] - aryuWW[21]; 85 | aryuWW[20]=aryuWW[2]*aryuWW[4]; 86 | aryuWW[21]=aryuWW[20]*aryuWW[16]; 87 | aryuWW[21]=3./2.*aryuWW[21]; 88 | aryuWW[19]=aryuWW[19]*aryuWW[21]; 89 | aryuWW[21]=pow(aryuWW[5],2); 90 | aryuWW[20]=aryuWW[26]*aryuWW[21]*aryuWW[20]; 91 | aryuWW[20]=3./4.*aryuWW[20] + aryuWW[22] - aryuWW[19]; 92 | aryuWW[20]=aryuWW[20]*aryuWW[21]; 93 | aryuWW[19]= - aryuWW[27]*aryuWW[19]; 94 | 95 | yuWWret = aryuWW[18] + aryuWW[19] + aryuWW[20]; 96 | return yuWWret.real(); 97 | } 98 | } // namespace mr 99 | -------------------------------------------------------------------------------- /mr/yu/yuWW11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double WW::y11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryuWW[22], yuWWret; 9 | 10 | aryuWW[1]=double(nH); 11 | aryuWW[2]=pow(CW,-1); 12 | aryuWW[3]=pow(MMZ,-1); 13 | aryuWW[4]=pow(SW,-1); 14 | aryuWW[5]=Tsil::I2(0,0,MMt,mu2); 15 | aryuWW[6]=Tsil::B(0,MMt,MMW,mu2); 16 | aryuWW[7]=Tsil::A(MMt,mu2); 17 | aryuWW[8]=pow(MMt,-1); 18 | aryuWW[9]=Tsil::Aeps(MMt,mu2); 19 | aryuWW[10]=prot00tt0->M(0); 20 | aryuWW[11]=prot00tt0->Tuxv(0); 21 | aryuWW[12]=double(nL); 22 | aryuWW[13]=std::real(Tsil::B(0,0,MMW,mu2)); 23 | aryuWW[14]=prot00000->M(0); 24 | aryuWW[15]= - 1 + 1./3.*aryuWW[6]; 25 | aryuWW[16]=10*aryuWW[6]; 26 | aryuWW[15]=aryuWW[15]*aryuWW[16]; 27 | aryuWW[15]=aryuWW[15] + 23./3. + 8./3.*aryuWW[11]; 28 | aryuWW[15]=aryuWW[15]*MMt; 29 | aryuWW[16]= - 5 + 2*aryuWW[6]; 30 | aryuWW[17]=5./3.*aryuWW[7]; 31 | aryuWW[16]=aryuWW[16]*aryuWW[17]; 32 | aryuWW[17]= - aryuWW[5] + 1./3.*aryuWW[9]; 33 | aryuWW[16]= - aryuWW[16] + 2*aryuWW[17]; 34 | aryuWW[17]=pow(aryuWW[7],2); 35 | aryuWW[18]=aryuWW[8]*aryuWW[17]; 36 | aryuWW[15]=4*aryuWW[18] + aryuWW[15] - 2*aryuWW[16]; 37 | aryuWW[16]=pow(aryuWW[2],2); 38 | aryuWW[18]=pow(aryuWW[4],2); 39 | aryuWW[19]=aryuWW[16] + aryuWW[18]; 40 | aryuWW[15]=aryuWW[19]*aryuWW[15]; 41 | aryuWW[19]= - aryuWW[16] - 1; 42 | aryuWW[16]=aryuWW[16]*aryuWW[19]; 43 | aryuWW[16]=aryuWW[16] - aryuWW[18]; 44 | aryuWW[19]=MMt*aryuWW[10]; 45 | aryuWW[20]= - 2./3.*aryuWW[19] + 4./3.*aryuWW[11] + 3*aryuWW[6]; 46 | aryuWW[20]=aryuWW[20]*MMt; 47 | aryuWW[21]=5*aryuWW[7] + 4*aryuWW[9]; 48 | aryuWW[20]=aryuWW[20] + 1./3.*aryuWW[21]; 49 | aryuWW[20]=aryuWW[20]*MMt; 50 | aryuWW[17]=aryuWW[20] - 2./3.*aryuWW[17]; 51 | aryuWW[16]=aryuWW[3]*aryuWW[17]*aryuWW[16]; 52 | aryuWW[15]=2*aryuWW[16] + aryuWW[15]; 53 | aryuWW[15]=aryuWW[3]*aryuWW[1]*aryuWW[15]; 54 | aryuWW[16]=1 + 2./3.*aryuWW[6]; 55 | aryuWW[16]=aryuWW[6]*aryuWW[16]; 56 | aryuWW[16]=aryuWW[19] - aryuWW[16]; 57 | aryuWW[17]= - 1 + aryuWW[6]; 58 | aryuWW[17]=aryuWW[7]*aryuWW[17]; 59 | aryuWW[17]=aryuWW[9] + aryuWW[17]; 60 | aryuWW[17]=aryuWW[8]*aryuWW[17]; 61 | aryuWW[17]=aryuWW[17] + aryuWW[11]; 62 | aryuWW[16]=13 - 4*aryuWW[16] + 16./3.*aryuWW[17]; 63 | aryuWW[16]=aryuWW[1]*aryuWW[16]; 64 | aryuWW[17]=4*aryuWW[13] + 31./3.; 65 | aryuWW[17]=aryuWW[12]*aryuWW[17]; 66 | aryuWW[16]=aryuWW[16] + aryuWW[17]; 67 | aryuWW[16]=aryuWW[18]*aryuWW[16]; 68 | aryuWW[17]=aryuWW[14]*aryuWW[12]; 69 | aryuWW[19]=aryuWW[1]*aryuWW[10]; 70 | aryuWW[17]=aryuWW[19] + aryuWW[17]; 71 | aryuWW[18]=aryuWW[18] - 1; 72 | aryuWW[17]=MMZ*aryuWW[18]*aryuWW[17]; 73 | 74 | yuWWret = aryuWW[15] + aryuWW[16] + 8./3.*aryuWW[17]; 75 | return yuWWret.real(); 76 | } 77 | } // namespace mr 78 | -------------------------------------------------------------------------------- /mr/yu/yuZZ10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double ZZ::y10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryuZZ[32], yuZZret; 9 | 10 | aryuZZ[1]=double(nH); 11 | aryuZZ[2]=double(boson); 12 | aryuZZ[3]=pow(CW,-1); 13 | aryuZZ[4]=pow(MMZ,-1); 14 | aryuZZ[5]=pow(SW,-1); 15 | aryuZZ[6]=Tsil::B(MMt,MMt,MMZ,mu2); 16 | aryuZZ[7]=Tsil::B(MMb,MMb,MMZ,mu2); 17 | aryuZZ[8]=Tsil::B(0,0,MMZ,mu2); 18 | aryuZZ[9]=Tsil::A(MMt,mu2); 19 | aryuZZ[10]=Tsil::A(MMb,mu2); 20 | aryuZZ[11]=double(nL + nH); 21 | aryuZZ[12]=Tsil::B(MMZ,MMH,MMZ,mu2); 22 | aryuZZ[13]=Tsil::B(MMW,MMW,MMZ,mu2); 23 | aryuZZ[14]=Tsil::A(MMH,mu2); 24 | aryuZZ[15]=Tsil::A(MMZ,mu2); 25 | aryuZZ[16]=Tsil::A(MMW,mu2); 26 | aryuZZ[17]=1/( - MMb + MMt); 27 | aryuZZ[18]=1/( - MMW + MMH); 28 | aryuZZ[19]=pow(aryuZZ[3],2); 29 | aryuZZ[20]=pow(aryuZZ[5],2); 30 | aryuZZ[21]=5./9.*aryuZZ[19] + aryuZZ[20] - 8./9.; 31 | aryuZZ[22]=1./2.*aryuZZ[20]; 32 | aryuZZ[23]=aryuZZ[22] + 17./18.*aryuZZ[19]; 33 | aryuZZ[24]= - 8./9. - aryuZZ[23]; 34 | aryuZZ[24]=aryuZZ[7]*aryuZZ[24]; 35 | aryuZZ[25]=aryuZZ[19] + aryuZZ[20]; 36 | aryuZZ[26]=MMt - MMb; 37 | aryuZZ[26]=aryuZZ[10] - aryuZZ[9] - 1./2.*aryuZZ[26]; 38 | aryuZZ[26]=aryuZZ[17]*aryuZZ[25]*aryuZZ[26]; 39 | aryuZZ[24]=3./2.*aryuZZ[26] + aryuZZ[21] + aryuZZ[24]; 40 | aryuZZ[26]=aryuZZ[2]*aryuZZ[1]; 41 | aryuZZ[24]=aryuZZ[24]*aryuZZ[26]*MMb; 42 | aryuZZ[27]= - 3*aryuZZ[20] + 11./3.; 43 | aryuZZ[27]=aryuZZ[15]*aryuZZ[27]; 44 | aryuZZ[27]= - aryuZZ[14] + aryuZZ[27]; 45 | aryuZZ[27]=aryuZZ[27]*aryuZZ[20]; 46 | aryuZZ[28]= - aryuZZ[14] + 11./3.*aryuZZ[15]; 47 | aryuZZ[28]=aryuZZ[28]*aryuZZ[19]; 48 | aryuZZ[27]=aryuZZ[27] + aryuZZ[28]; 49 | aryuZZ[28]= - 1 + 3./4.*aryuZZ[20]; 50 | aryuZZ[28]=aryuZZ[28]*aryuZZ[20]; 51 | aryuZZ[29]=5./3.*aryuZZ[19]; 52 | aryuZZ[28]=aryuZZ[29] + 4 + aryuZZ[28]; 53 | aryuZZ[28]=aryuZZ[16]*aryuZZ[28]; 54 | aryuZZ[30]= - aryuZZ[22] - 32./9. + 7./18.*aryuZZ[19]; 55 | aryuZZ[31]=aryuZZ[9]*aryuZZ[1]*aryuZZ[30]; 56 | aryuZZ[27]=aryuZZ[31] + 1./4.*aryuZZ[27] + aryuZZ[28]; 57 | aryuZZ[27]=aryuZZ[2]*aryuZZ[27]; 58 | aryuZZ[28]=aryuZZ[6]*aryuZZ[30]; 59 | aryuZZ[28]=aryuZZ[28] + 41./36.*aryuZZ[19] - 32./9. + 1./4.* 60 | aryuZZ[20]; 61 | aryuZZ[28]=MMt*aryuZZ[28]; 62 | aryuZZ[21]=aryuZZ[10]*aryuZZ[21]; 63 | aryuZZ[21]=aryuZZ[21] + aryuZZ[28]; 64 | aryuZZ[21]=aryuZZ[26]*aryuZZ[21]; 65 | aryuZZ[28]=aryuZZ[15] - aryuZZ[14]; 66 | aryuZZ[28]= - aryuZZ[2]*aryuZZ[28]*aryuZZ[25]; 67 | aryuZZ[25]=aryuZZ[25]*MMH*aryuZZ[2]; 68 | aryuZZ[30]=aryuZZ[12]*aryuZZ[25]; 69 | aryuZZ[28]=aryuZZ[28] + aryuZZ[30]; 70 | aryuZZ[28]=aryuZZ[4]*MMH*aryuZZ[28]; 71 | aryuZZ[30]=aryuZZ[12] + 1./8.; 72 | aryuZZ[25]= - aryuZZ[30]*aryuZZ[25]; 73 | aryuZZ[21]=1./12.*aryuZZ[28] + 1./3.*aryuZZ[25] + aryuZZ[27] + 74 | aryuZZ[21] + aryuZZ[24]; 75 | aryuZZ[21]=aryuZZ[4]*aryuZZ[21]; 76 | aryuZZ[24]= - 11./9.*aryuZZ[19] + 20./9. - aryuZZ[20]; 77 | aryuZZ[24]=aryuZZ[8]*aryuZZ[24]; 78 | aryuZZ[23]= - 16./9. + aryuZZ[23]; 79 | aryuZZ[23]=aryuZZ[6]*aryuZZ[23]; 80 | aryuZZ[23]=aryuZZ[23] + aryuZZ[24]; 81 | aryuZZ[23]=aryuZZ[1]*aryuZZ[23]; 82 | aryuZZ[24]=pow(CW,2); 83 | aryuZZ[25]=1./12.*aryuZZ[19] - 33./4.*aryuZZ[20] + 29./3. + 4* 84 | aryuZZ[24]; 85 | aryuZZ[25]=aryuZZ[13]*aryuZZ[25]; 86 | aryuZZ[27]=aryuZZ[14] - aryuZZ[16]; 87 | aryuZZ[27]=aryuZZ[18]*aryuZZ[27]; 88 | aryuZZ[27]=3./4.*aryuZZ[27] - 209./72. + aryuZZ[12]; 89 | aryuZZ[27]=aryuZZ[20]*aryuZZ[27]; 90 | aryuZZ[28]=5./72. + aryuZZ[12]; 91 | aryuZZ[28]=aryuZZ[28]*aryuZZ[19]; 92 | aryuZZ[20]=aryuZZ[29] - 8./3. + aryuZZ[20]; 93 | aryuZZ[29]=aryuZZ[8] - 1./3.; 94 | aryuZZ[20]=aryuZZ[11]*aryuZZ[29]*aryuZZ[20]; 95 | aryuZZ[24]=2./3. + aryuZZ[24]; 96 | aryuZZ[20]=aryuZZ[25] + aryuZZ[23] + 4./3.*aryuZZ[20] + aryuZZ[28] 97 | + 4*aryuZZ[24] + aryuZZ[27]; 98 | aryuZZ[20]=aryuZZ[2]*aryuZZ[20]; 99 | aryuZZ[19]=5./18.*aryuZZ[19] - 4./9. + aryuZZ[22]; 100 | aryuZZ[19]=aryuZZ[7]*aryuZZ[19]*aryuZZ[26]; 101 | 102 | yuZZret = aryuZZ[19] + aryuZZ[20] + aryuZZ[21]; 103 | return yuZZret.real(); 104 | } 105 | } // namespace mr 106 | -------------------------------------------------------------------------------- /mr/yu/yubb01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double bb::y01(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryubb[5], yubbret; 9 | 10 | aryubb[1]=double(boson); 11 | aryubb[2]=Tsil::A(MMb,mu2); 12 | aryubb[3]=pow(MMb,-1); 13 | aryubb[4]=aryubb[2]*aryubb[3]; 14 | aryubb[4]= - 1./3. + aryubb[4]; 15 | 16 | yubbret = 4*aryubb[4]*aryubb[1]; 17 | return yubbret.real(); 18 | } 19 | } // namespace mr 20 | -------------------------------------------------------------------------------- /mr/yu/yubb10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double bb::y10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryubb[27], yubbret; 9 | 10 | aryubb[1]=double(nH); 11 | aryubb[2]=double(boson); 12 | aryubb[3]=pow(CW,-1); 13 | aryubb[4]=pow(MMZ,-1); 14 | aryubb[5]=pow(SW,-1); 15 | aryubb[6]=Tsil::A(MMt,mu2); 16 | aryubb[7]=Tsil::B(MMH,MMb,MMb,mu2); 17 | aryubb[8]=Tsil::B(MMZ,MMb,MMb,mu2); 18 | aryubb[9]=pow(MMb,-1); 19 | aryubb[10]=Tsil::B(MMW,MMt,MMb,mu2); 20 | aryubb[11]=Tsil::A(MMH,mu2); 21 | aryubb[12]=Tsil::A(MMZ,mu2); 22 | aryubb[13]=Tsil::A(MMW,mu2); 23 | aryubb[14]=Tsil::A(MMb,mu2); 24 | aryubb[15]=1/( - MMb + MMt); 25 | aryubb[16]=1/( - MMW + MMH); 26 | aryubb[17]=aryubb[11] - aryubb[13]; 27 | aryubb[18]=3./2.*aryubb[16]; 28 | aryubb[17]=aryubb[18]*aryubb[17]; 29 | aryubb[18]=MMZ*aryubb[9]; 30 | aryubb[19]=aryubb[18]*aryubb[10]; 31 | aryubb[20]=1./2.*MMt; 32 | aryubb[21]=aryubb[20]*aryubb[9]*aryubb[10]; 33 | aryubb[22]= - 3./2. + aryubb[10]; 34 | aryubb[23]=aryubb[13] - aryubb[6]; 35 | aryubb[24]= - aryubb[9]*aryubb[23]; 36 | aryubb[25]=1./2.*aryubb[9]; 37 | aryubb[26]= - aryubb[12]*aryubb[25]; 38 | aryubb[17]=aryubb[21] + aryubb[26] - aryubb[19] + 1./2.*aryubb[22] 39 | + aryubb[24] + aryubb[17]; 40 | aryubb[22]=pow(aryubb[5],2); 41 | aryubb[17]=aryubb[17]*aryubb[22]; 42 | aryubb[17]=aryubb[19] + aryubb[17]; 43 | aryubb[19]=aryubb[23]*aryubb[25]; 44 | aryubb[19]= - aryubb[19] + aryubb[21] - aryubb[10]; 45 | aryubb[19]=aryubb[19]*aryubb[20]; 46 | aryubb[21]=MMb*aryubb[10]; 47 | aryubb[21]= - aryubb[11] + aryubb[6] + 1./2.*MMH + aryubb[21] + 7* 48 | aryubb[13]; 49 | aryubb[23]= - MMb + 1./4.*MMH; 50 | aryubb[23]=aryubb[23]*aryubb[7]; 51 | aryubb[19]=3./4.*aryubb[12] + aryubb[19] - aryubb[23] + 1./4.* 52 | aryubb[21]; 53 | aryubb[21]=pow(aryubb[3],2); 54 | aryubb[23]=aryubb[19]*aryubb[21]; 55 | aryubb[24]=aryubb[13] - aryubb[12]; 56 | aryubb[24]=aryubb[24]*aryubb[22]; 57 | aryubb[19]=3./4.*aryubb[24] + aryubb[19]; 58 | aryubb[19]=aryubb[19]*aryubb[22]; 59 | aryubb[24]=aryubb[15]*MMb; 60 | aryubb[25]=aryubb[24] + 1; 61 | aryubb[20]=aryubb[25]*aryubb[20]; 62 | aryubb[25]= - aryubb[6] + 1./2.*MMb; 63 | aryubb[25]=aryubb[25]*aryubb[24]; 64 | aryubb[20]=aryubb[6] + aryubb[20] - aryubb[25]; 65 | aryubb[25]=aryubb[21] + aryubb[22]; 66 | aryubb[20]= - aryubb[20]*aryubb[25]; 67 | aryubb[25]=aryubb[25]*aryubb[14]; 68 | aryubb[24]=aryubb[24]*aryubb[25]; 69 | aryubb[20]=aryubb[24] + aryubb[20]; 70 | aryubb[20]=aryubb[1]*aryubb[20]; 71 | aryubb[19]=3./2.*aryubb[20] + 1./2.*aryubb[25] + aryubb[23] + 72 | aryubb[19]; 73 | aryubb[19]=aryubb[4]*aryubb[19]; 74 | aryubb[20]=17 - 5*aryubb[18]; 75 | aryubb[20]=aryubb[20]*aryubb[21]; 76 | aryubb[20]=1./8.*aryubb[20] + 2 + aryubb[18]; 77 | aryubb[22]=1./8.*aryubb[22]; 78 | aryubb[18]=1 - aryubb[18]; 79 | aryubb[18]=aryubb[18]*aryubb[22]; 80 | aryubb[18]=1./9.*aryubb[20] + aryubb[18]; 81 | aryubb[18]=aryubb[8]*aryubb[18]; 82 | aryubb[20]=aryubb[12]*aryubb[9]; 83 | aryubb[23]= - 17./2. - 5*aryubb[20]; 84 | aryubb[23]=aryubb[23]*aryubb[21]; 85 | aryubb[21]=2 + 5./8.*aryubb[21]; 86 | aryubb[21]=1./9.*aryubb[21] + aryubb[22]; 87 | aryubb[21]=aryubb[14]*aryubb[9]*aryubb[21]; 88 | aryubb[17]=aryubb[18] + 1./2.*aryubb[19] + aryubb[21] + 1./72.* 89 | aryubb[23] + 1./9.*aryubb[20] - 2./9. + 1./4.*aryubb[17]; 90 | 91 | yubbret = aryubb[17]*aryubb[2]; 92 | return yubbret.real(); 93 | } 94 | } // namespace mr 95 | -------------------------------------------------------------------------------- /mr/yu/yutt01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double tt::y01(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryutt[5], yuttret; 9 | 10 | aryutt[1]=double(boson); 11 | aryutt[2]=Tsil::A(MMt,mu2); 12 | aryutt[3]=pow(MMt,-1); 13 | aryutt[4]=aryutt[2]*aryutt[3]; 14 | aryutt[4]= - 1./3. + aryutt[4]; 15 | 16 | yuttret = 4*aryutt[4]*aryutt[1]; 17 | return yuttret.real(); 18 | } 19 | } // namespace mr 20 | -------------------------------------------------------------------------------- /mr/yu/yutt10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double tt::y10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryutt[26], yuttret; 9 | 10 | aryutt[1]=double(nH); 11 | aryutt[2]=double(boson); 12 | aryutt[3]=pow(CW,-1); 13 | aryutt[4]=pow(MMZ,-1); 14 | aryutt[5]=pow(SW,-1); 15 | aryutt[6]=Tsil::A(MMt,mu2); 16 | aryutt[7]=Tsil::B(MMH,MMt,MMt,mu2); 17 | aryutt[8]=Tsil::B(MMZ,MMt,MMt,mu2); 18 | aryutt[9]=pow(MMt,-1); 19 | aryutt[10]=Tsil::B(MMW,MMb,MMt,mu2); 20 | aryutt[11]=Tsil::A(MMH,mu2); 21 | aryutt[12]=Tsil::A(MMZ,mu2); 22 | aryutt[13]=Tsil::A(MMW,mu2); 23 | aryutt[14]=Tsil::A(MMb,mu2); 24 | aryutt[15]=1/( - MMb + MMt); 25 | aryutt[16]=1/( - MMW + MMH); 26 | aryutt[17]=aryutt[6] + 1./2.*MMt; 27 | aryutt[18]=1./2.*MMb; 28 | aryutt[19]=aryutt[14] + aryutt[18] - aryutt[17]; 29 | aryutt[19]=MMb*aryutt[19]*aryutt[15]; 30 | aryutt[17]=aryutt[19] - aryutt[17]; 31 | aryutt[19]=3*aryutt[1]; 32 | aryutt[17]=aryutt[17]*aryutt[19]; 33 | aryutt[19]=aryutt[14] - aryutt[13]; 34 | aryutt[20]=MMb*aryutt[10]; 35 | aryutt[21]=aryutt[19] + aryutt[20]; 36 | aryutt[18]=aryutt[21]*aryutt[18]*aryutt[9]; 37 | aryutt[21]=MMt*aryutt[10]; 38 | aryutt[21]= - aryutt[11] + 3*aryutt[12] + 7*aryutt[13] + aryutt[21] 39 | + aryutt[14]; 40 | aryutt[17]=aryutt[17] + aryutt[18] - aryutt[20] + aryutt[6] + 1./2.* 41 | aryutt[21]; 42 | aryutt[18]=aryutt[7]*MMt; 43 | aryutt[17]=aryutt[18] + 1./2.*aryutt[17]; 44 | aryutt[18]=aryutt[4]*aryutt[17]; 45 | aryutt[21]=aryutt[7] - 1./2.; 46 | aryutt[22]=MMH*aryutt[4]; 47 | aryutt[22]=1./4.*aryutt[22]; 48 | aryutt[21]=aryutt[21]*aryutt[22]; 49 | aryutt[22]=aryutt[6] - aryutt[12]; 50 | aryutt[23]=aryutt[9]*aryutt[22]; 51 | aryutt[23]=7./2. + 17*aryutt[23]; 52 | aryutt[18]= - aryutt[21] + 1./36.*aryutt[23] + aryutt[18]; 53 | aryutt[23]=pow(aryutt[3],2); 54 | aryutt[18]=aryutt[18]*aryutt[23]; 55 | aryutt[24]=pow(aryutt[5],2); 56 | aryutt[25]=aryutt[13] - aryutt[12]; 57 | aryutt[25]=aryutt[25]*aryutt[24]; 58 | aryutt[17]=3./4.*aryutt[25] + aryutt[17]; 59 | aryutt[17]=aryutt[4]*aryutt[17]; 60 | aryutt[20]=aryutt[22] + aryutt[20]; 61 | aryutt[22]=MMZ*aryutt[10]; 62 | aryutt[19]= - aryutt[22] + aryutt[19] + 1./2.*aryutt[20]; 63 | aryutt[19]=aryutt[9]*aryutt[19]; 64 | aryutt[20]= - 3./2. + aryutt[10]; 65 | aryutt[25]= - aryutt[13] + aryutt[11]; 66 | aryutt[25]=aryutt[16]*aryutt[25]; 67 | aryutt[19]=3./2.*aryutt[25] + 1./2.*aryutt[20] + aryutt[19]; 68 | aryutt[17]= - aryutt[21] + 1./2.*aryutt[19] + aryutt[17]; 69 | aryutt[17]=aryutt[17]*aryutt[24]; 70 | aryutt[17]=aryutt[18] + aryutt[17]; 71 | aryutt[18]=aryutt[9]*MMZ; 72 | aryutt[19]= - 7 - 17*aryutt[18]; 73 | aryutt[19]=aryutt[19]*aryutt[23]; 74 | aryutt[20]=2 + aryutt[18]; 75 | aryutt[19]=4*aryutt[20] + 1./8.*aryutt[19]; 76 | aryutt[18]=1 - aryutt[18]; 77 | aryutt[18]=aryutt[18]*aryutt[24]; 78 | aryutt[18]=1./9.*aryutt[19] + 1./8.*aryutt[18]; 79 | aryutt[18]=aryutt[8]*aryutt[18]; 80 | aryutt[19]=8./9.*aryutt[6] + 4./9.*aryutt[12] + 1./4.*aryutt[22]; 81 | aryutt[19]=aryutt[9]*aryutt[19]; 82 | aryutt[17]=aryutt[18] - 8./9. + aryutt[19] + 1./2.*aryutt[17]; 83 | 84 | yuttret = aryutt[17]*aryutt[2]; 85 | return yuttret.real(); 86 | } 87 | } // namespace mr 88 | -------------------------------------------------------------------------------- /mr/yugl/README: -------------------------------------------------------------------------------- 1 | 2 | Corrections to MS coupling in terms of OS masses in gauge-less limit 3 | 4 | Y_ij - functions of OS masses 5 | 6 | aw(mu) - EM running coupling (alEM/4/Pi) 7 | 8 | as(mu) - QCD running coupling (alS/4/Pi) 9 | 10 | delta = 1 + as*Y_01 + aw*Y_10 + aw*as*Y_11 + aw^2*Y_20 + ... 11 | -------------------------------------------------------------------------------- /mr/yugl/yuHHGL10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double HH::ygl10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryuHHGL[11], yuHHGLret; 9 | 10 | aryuHHGL[1]=double(boson); 11 | aryuHHGL[2]=pow(SW,-1); 12 | aryuHHGL[3]=pow(MMW,-1); 13 | aryuHHGL[4]=Tsil::B(MMH,MMH,MMH,mu2); 14 | aryuHHGL[5]=Tsil::B(MMt,MMt,MMH,mu2); 15 | aryuHHGL[6]=pow(MMH,-1); 16 | aryuHHGL[7]=Tsil::A(MMt,mu2); 17 | aryuHHGL[8]=std::real(Tsil::B(0,0,MMH,mu2)); 18 | aryuHHGL[9]=MMt*aryuHHGL[6]; 19 | aryuHHGL[9]=1./2. - 2*aryuHHGL[9]; 20 | aryuHHGL[9]=aryuHHGL[5]*aryuHHGL[9]; 21 | aryuHHGL[9]= - 1./4. + aryuHHGL[9]; 22 | aryuHHGL[9]=MMt*aryuHHGL[9]; 23 | aryuHHGL[9]=aryuHHGL[9] - 1./2.*aryuHHGL[7]; 24 | aryuHHGL[10]=3*aryuHHGL[8] + 1 + 9*aryuHHGL[4]; 25 | aryuHHGL[10]=MMH*aryuHHGL[10]; 26 | aryuHHGL[9]=3*aryuHHGL[9] + 1./8.*aryuHHGL[10]; 27 | 28 | yuHHGLret = aryuHHGL[9]*aryuHHGL[3]*pow(aryuHHGL[2],2)* 29 | aryuHHGL[1]; 30 | return yuHHGLret.real(); 31 | } 32 | } // namespace mr 33 | -------------------------------------------------------------------------------- /mr/yugl/yuHHGL11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double HH::ygl11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryuHHGL[20], yuHHGLret; 9 | 10 | aryuHHGL[1]=double(boson); 11 | aryuHHGL[2]=pow(SW,-1); 12 | aryuHHGL[3]=pow(MMH,-1); 13 | aryuHHGL[4]=pow(MMW,-1); 14 | aryuHHGL[5]=Tsil::B(MMt,MMt,MMH,mu2); 15 | aryuHHGL[6]=Tsil::A(MMt,mu2); 16 | aryuHHGL[7]=Tsil::Beps(MMt,MMt,MMH,mu2); 17 | aryuHHGL[8]=pow(MMt,-1); 18 | aryuHHGL[9]=Tsil::Aeps(MMt,mu2); 19 | aryuHHGL[10]=prottttt0->M(0); 20 | aryuHHGL[11]=prottttt0->Vxzuv(0); 21 | aryuHHGL[12]=prottttt0->Suxv(0); 22 | aryuHHGL[13]=2*aryuHHGL[5]; 23 | aryuHHGL[14]=4 + 3*aryuHHGL[5]; 24 | aryuHHGL[13]=aryuHHGL[14]*aryuHHGL[13]; 25 | aryuHHGL[14]=4*aryuHHGL[3]; 26 | aryuHHGL[15]=aryuHHGL[5]*aryuHHGL[6]; 27 | aryuHHGL[16]=6*aryuHHGL[9] - aryuHHGL[12] - 18*aryuHHGL[15]; 28 | aryuHHGL[14]=aryuHHGL[16]*aryuHHGL[14]; 29 | aryuHHGL[16]=4*MMt; 30 | aryuHHGL[17]=aryuHHGL[16]*aryuHHGL[3]; 31 | aryuHHGL[18]= - 10 - 7*aryuHHGL[5]; 32 | aryuHHGL[18]=aryuHHGL[5]*aryuHHGL[18]; 33 | aryuHHGL[18]= - 25 + aryuHHGL[18]; 34 | aryuHHGL[18]=aryuHHGL[18]*aryuHHGL[17]; 35 | aryuHHGL[19]=pow(Pi,2); 36 | aryuHHGL[13]=aryuHHGL[18] - 2./3.*aryuHHGL[19] + aryuHHGL[14] + 77./ 37 | 2. + aryuHHGL[13]; 38 | aryuHHGL[13]=MMt*aryuHHGL[13]; 39 | aryuHHGL[14]=aryuHHGL[7]*aryuHHGL[3]; 40 | aryuHHGL[18]= - 1 + aryuHHGL[17]; 41 | aryuHHGL[18]=aryuHHGL[11]*aryuHHGL[18]; 42 | aryuHHGL[14]=aryuHHGL[18] + aryuHHGL[14]; 43 | aryuHHGL[18]=pow(MMt,2); 44 | aryuHHGL[18]=16*aryuHHGL[18]; 45 | aryuHHGL[14]=aryuHHGL[18]*aryuHHGL[14]; 46 | aryuHHGL[18]= - aryuHHGL[6]*aryuHHGL[8]; 47 | aryuHHGL[18]= - 1 + aryuHHGL[18]; 48 | aryuHHGL[18]=aryuHHGL[6]*aryuHHGL[18]; 49 | aryuHHGL[15]=aryuHHGL[18] + 2*aryuHHGL[15]; 50 | aryuHHGL[17]= - 3 + aryuHHGL[17]; 51 | aryuHHGL[17]=MMt*aryuHHGL[17]; 52 | aryuHHGL[17]=MMH + 2*aryuHHGL[17]; 53 | aryuHHGL[16]=aryuHHGL[10]*aryuHHGL[17]*aryuHHGL[16]; 54 | aryuHHGL[13]=aryuHHGL[16] + 6*aryuHHGL[15] + aryuHHGL[13] + 55 | aryuHHGL[14]; 56 | 57 | yuHHGLret = aryuHHGL[13]*aryuHHGL[4]*pow(aryuHHGL[2],2)* 58 | aryuHHGL[1]; 59 | return yuHHGLret.real(); 60 | } 61 | } // namespace mr 62 | -------------------------------------------------------------------------------- /mr/yugl/yubbGL01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | double bb::ygl01(size_t nL, size_t nH, size_t boson) 3 | { 4 | 5 | 6 | std::complex aryubbGL[5], yubbGLret; 7 | 8 | aryubbGL[1]=double(boson); 9 | aryubbGL[2]=Tsil::A(MMb,mu2); 10 | aryubbGL[3]=pow(MMb,-1); 11 | aryubbGL[4]=aryubbGL[2]*aryubbGL[3]; 12 | aryubbGL[4]= - 1./3. + aryubbGL[4]; 13 | 14 | yubbGLret = 4*aryubbGL[4]*aryubbGL[1]; 15 | return yubbGLret.real(); 16 | } 17 | -------------------------------------------------------------------------------- /mr/yugl/yubbGL10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double bb::ygl10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryubbGL[6], yubbGLret; 9 | 10 | aryubbGL[1]=double(boson); 11 | aryubbGL[2]=pow(SW,-1); 12 | aryubbGL[3]=pow(MMW,-1); 13 | aryubbGL[4]=Tsil::A(MMt,mu2); 14 | aryubbGL[5]=MMH - 5*MMt; 15 | aryubbGL[5]=1./2.*aryubbGL[5] - 3*aryubbGL[4]; 16 | 17 | yubbGLret = 1./8.*aryubbGL[5]*aryubbGL[3]*pow(aryubbGL[2],2)* 18 | aryubbGL[1]; 19 | return yubbGLret.real(); 20 | } 21 | } // namespace mr 22 | -------------------------------------------------------------------------------- /mr/yugl/yubbGL11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double bb::ygl11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryubbGL[14], yubbGLret; 9 | 10 | aryubbGL[1]=double(boson); 11 | aryubbGL[2]=pow(SW,-1); 12 | aryubbGL[3]=pow(MMW,-1); 13 | aryubbGL[4]=Tsil::I2(0,0,MMt,mu2); 14 | aryubbGL[5]=Tsil::A(MMt,mu2); 15 | aryubbGL[6]=pow(MMt,-1); 16 | aryubbGL[7]=Tsil::A(MMb,mu2); 17 | aryubbGL[8]=pow(MMb,-1); 18 | aryubbGL[9]=Tsil::Aeps(MMt,mu2); 19 | aryubbGL[10]=Tsil::Aeps(MMb,mu2); 20 | aryubbGL[11]=aryubbGL[5]*aryubbGL[6]; 21 | aryubbGL[11]=9 - 7*aryubbGL[11]; 22 | aryubbGL[11]=aryubbGL[5]*aryubbGL[11]; 23 | aryubbGL[12]=1./2.*MMH - 5./2.*MMt - 3*aryubbGL[5] - 5*aryubbGL[7]; 24 | aryubbGL[12]=aryubbGL[8]*aryubbGL[7]*aryubbGL[12]; 25 | aryubbGL[11]=aryubbGL[11] + aryubbGL[12]; 26 | aryubbGL[12]=aryubbGL[9] - aryubbGL[4]; 27 | aryubbGL[13]=pow(Pi,2); 28 | aryubbGL[13]= - 5./2. - aryubbGL[13]; 29 | aryubbGL[13]=MMt*aryubbGL[13]; 30 | aryubbGL[11]= - 1./12.*MMH + 1./3.*aryubbGL[13] + 5*aryubbGL[10] + 1. 31 | /2.*aryubbGL[11] + 4*aryubbGL[12]; 32 | 33 | yubbGLret = aryubbGL[11]*aryubbGL[3]*pow(aryubbGL[2],2)* 34 | aryubbGL[1]; 35 | return yubbGLret.real(); 36 | } 37 | } // namespace mr 38 | -------------------------------------------------------------------------------- /mr/yugl/yubbGL20.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double bb::ygl20(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryubbGL[29], yubbGLret; 9 | 10 | aryubbGL[1]=double(boson); 11 | aryubbGL[2]=pow(SW,-1); 12 | aryubbGL[3]=pow(MMH,-1); 13 | aryubbGL[4]=pow(MMW,-1); 14 | aryubbGL[5]=Tsil::I2(MMH,MMH,MMH,mu2); 15 | aryubbGL[6]=Tsil::I2(MMH,MMt,MMt,mu2); 16 | aryubbGL[7]=pow(MMt,-1); 17 | aryubbGL[8]=Tsil::I2(0,MMH,MMt,mu2); 18 | aryubbGL[9]=Tsil::I2(0,0,MMH,mu2); 19 | aryubbGL[10]=Tsil::I2(0,0,MMt,mu2); 20 | aryubbGL[11]=Tsil::B(MMH,MMH,MMH,mu2); 21 | aryubbGL[12]=Tsil::B(MMH,MMt,MMt,mu2); 22 | aryubbGL[13]=Tsil::A(MMt,mu2); 23 | aryubbGL[14]=Tsil::B(MMt,MMt,MMH,mu2); 24 | aryubbGL[15]=Tsil::A(MMH,mu2); 25 | aryubbGL[16]=std::real(Tsil::B(0,0,MMt,mu2)); 26 | aryubbGL[17]=Tsil::Aeps(MMH,mu2); 27 | aryubbGL[18]=Tsil::Aeps(MMt,mu2); 28 | aryubbGL[19]=std::real(Tsil::B(0,0,MMH,mu2)); 29 | aryubbGL[20]=3*aryubbGL[14]; 30 | aryubbGL[21]=pow(Pi,2); 31 | aryubbGL[22]= - 149./8. - 11*aryubbGL[16]; 32 | aryubbGL[22]= - 35./16.*aryubbGL[21] + 1./8.*aryubbGL[22] - 33 | aryubbGL[20]; 34 | aryubbGL[23]=MMt*aryubbGL[3]; 35 | aryubbGL[24]= - 3 - 1./2.*aryubbGL[21]; 36 | aryubbGL[24]=aryubbGL[24]*aryubbGL[23]; 37 | aryubbGL[25]=11*aryubbGL[18]; 38 | aryubbGL[26]= - 5./4.*aryubbGL[13] - aryubbGL[25]; 39 | aryubbGL[26]= - 11./4.*aryubbGL[8] + 3*aryubbGL[26]; 40 | aryubbGL[26]=aryubbGL[3]*aryubbGL[26]; 41 | aryubbGL[27]=aryubbGL[15]*aryubbGL[3]; 42 | aryubbGL[28]=pow(aryubbGL[27],2); 43 | aryubbGL[22]=29./8.*aryubbGL[24] - 63./8.*aryubbGL[28] - 11./4.* 44 | aryubbGL[12] + 1./2.*aryubbGL[22] + aryubbGL[26]; 45 | aryubbGL[22]=MMt*aryubbGL[22]; 46 | aryubbGL[24]= - 3*aryubbGL[13] + 11./8.*MMH; 47 | aryubbGL[24]=aryubbGL[12]*aryubbGL[24]; 48 | aryubbGL[23]=13*aryubbGL[23]; 49 | aryubbGL[26]= - 31./8. + aryubbGL[23]; 50 | aryubbGL[26]=aryubbGL[10]*aryubbGL[26]; 51 | aryubbGL[24]=aryubbGL[24] + aryubbGL[26]; 52 | aryubbGL[20]=9./2.*aryubbGL[21] + 197./8. + aryubbGL[20]; 53 | aryubbGL[20]=MMH*aryubbGL[20]; 54 | aryubbGL[26]=85./4. - 3*aryubbGL[16]; 55 | aryubbGL[26]=aryubbGL[13]*aryubbGL[26]; 56 | aryubbGL[20]=aryubbGL[26] + aryubbGL[20]; 57 | aryubbGL[26]=aryubbGL[3]*aryubbGL[13]; 58 | aryubbGL[26]=45./4.*aryubbGL[27] - 7./4. - 11*aryubbGL[26]; 59 | aryubbGL[26]=aryubbGL[15]*aryubbGL[26]; 60 | aryubbGL[27]=pow(aryubbGL[13],2); 61 | aryubbGL[28]=aryubbGL[3]*aryubbGL[27]; 62 | aryubbGL[20]=aryubbGL[22] - 17./8.*aryubbGL[6] + 1./4.*aryubbGL[26] 63 | + 49./16.*aryubbGL[8] - 51./4.*aryubbGL[28] + aryubbGL[25] + 1./8.* 64 | aryubbGL[20] + 1./2.*aryubbGL[24]; 65 | aryubbGL[20]=MMt*aryubbGL[20]; 66 | aryubbGL[22]= - 515./4. + 9*aryubbGL[11]; 67 | aryubbGL[24]=aryubbGL[7]*aryubbGL[18]; 68 | aryubbGL[22]=3./4.*aryubbGL[19] + 1./4.*aryubbGL[22] + aryubbGL[24]; 69 | aryubbGL[24]= - 3./2.*aryubbGL[8] + aryubbGL[9]; 70 | aryubbGL[24]=aryubbGL[7]*aryubbGL[24]; 71 | aryubbGL[21]=243./4.*S2 + 1./2.*aryubbGL[22] - 1./3.*aryubbGL[21] + 72 | aryubbGL[24]; 73 | aryubbGL[21]=MMH*aryubbGL[21]; 74 | aryubbGL[22]=aryubbGL[7]*aryubbGL[27]; 75 | aryubbGL[22]=aryubbGL[22] + aryubbGL[18]; 76 | aryubbGL[22]=aryubbGL[8] - 17*aryubbGL[9] - 15*aryubbGL[5] - 13./2.* 77 | aryubbGL[13] + 7*aryubbGL[22]; 78 | aryubbGL[24]=aryubbGL[12]*aryubbGL[13]; 79 | aryubbGL[25]=MMH*aryubbGL[7]; 80 | aryubbGL[25]=5./2. + aryubbGL[25]; 81 | aryubbGL[25]=aryubbGL[6]*aryubbGL[25]; 82 | aryubbGL[21]=1./2.*aryubbGL[25] + 3./2.*aryubbGL[24] + 1./4.* 83 | aryubbGL[22] + aryubbGL[21]; 84 | aryubbGL[21]=MMH*aryubbGL[21]; 85 | aryubbGL[22]= - aryubbGL[7]*aryubbGL[13]; 86 | aryubbGL[22]=61./2. + aryubbGL[22]; 87 | aryubbGL[22]=MMH*aryubbGL[22]; 88 | aryubbGL[22]= - 27./2.*aryubbGL[15] + 21./2.*aryubbGL[13] + 89 | aryubbGL[22]; 90 | aryubbGL[22]=aryubbGL[15]*aryubbGL[22]; 91 | aryubbGL[21]=1./2.*aryubbGL[22] + 123./8.*aryubbGL[27] + 92 | aryubbGL[21]; 93 | aryubbGL[22]=75./16. - aryubbGL[23]; 94 | aryubbGL[22]=MMt*aryubbGL[22]; 95 | aryubbGL[22]=7./2.*MMH + aryubbGL[22]; 96 | aryubbGL[22]=aryubbGL[17]*aryubbGL[22]; 97 | aryubbGL[20]=aryubbGL[22] + 1./4.*aryubbGL[21] + aryubbGL[20]; 98 | 99 | yubbGLret = 1./4.*aryubbGL[20]*pow(aryubbGL[4],2)*pow( 100 | aryubbGL[2],4)*aryubbGL[1]; 101 | return yubbGLret.real(); 102 | } 103 | } // namespace mr 104 | -------------------------------------------------------------------------------- /mr/yugl/yuttGL01.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | double tt::ygl01(size_t nL, size_t nH, size_t boson) 3 | { 4 | 5 | 6 | std::complex aryuttGL[5], yuttGLret; 7 | 8 | aryuttGL[1]=double(boson); 9 | aryuttGL[2]=Tsil::A(MMt,mu2); 10 | aryuttGL[3]=pow(MMt,-1); 11 | aryuttGL[4]=aryuttGL[2]*aryuttGL[3]; 12 | aryuttGL[4]= - 1./3. + aryuttGL[4]; 13 | 14 | yuttGLret = 4*aryuttGL[4]*aryuttGL[1]; 15 | return yuttGLret.real(); 16 | } 17 | -------------------------------------------------------------------------------- /mr/yugl/yuttGL10.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double tt::ygl10(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryuttGL[10], yuttGLret; 9 | 10 | aryuttGL[1]=double(boson); 11 | aryuttGL[2]=pow(SW,-1); 12 | aryuttGL[3]=pow(MMW,-1); 13 | aryuttGL[4]=Tsil::B(MMH,MMt,MMt,mu2); 14 | aryuttGL[5]=Tsil::A(MMH,mu2); 15 | aryuttGL[6]=Tsil::A(MMt,mu2); 16 | aryuttGL[7]=std::real(Tsil::B(0,0,MMt,mu2)); 17 | aryuttGL[8]=1./2. - aryuttGL[4]; 18 | aryuttGL[8]=MMH*aryuttGL[8]; 19 | aryuttGL[8]=aryuttGL[8] - aryuttGL[5]; 20 | aryuttGL[9]= - 3 + aryuttGL[7]; 21 | aryuttGL[9]=1./4.*aryuttGL[9] + aryuttGL[4]; 22 | aryuttGL[9]=MMt*aryuttGL[9]; 23 | aryuttGL[8]=aryuttGL[9] - aryuttGL[6] + 1./4.*aryuttGL[8]; 24 | 25 | yuttGLret = 1./2.*aryuttGL[8]*aryuttGL[3]*pow(aryuttGL[2],2)* 26 | aryuttGL[1]; 27 | return yuttGLret.real(); 28 | } 29 | } // namespace mr 30 | -------------------------------------------------------------------------------- /mr/yugl/yuttGL11.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | namespace mr 3 | { 4 | double tt::ygl11(size_t nL, size_t nH, size_t boson) 5 | { 6 | 7 | 8 | std::complex aryuttGL[32], yuttGLret; 9 | 10 | aryuttGL[1]=double(boson); 11 | aryuttGL[2]=pow(SW,-1); 12 | aryuttGL[3]=pow(MMW,-1); 13 | aryuttGL[4]=pow(MMt,-1); 14 | aryuttGL[5]=Tsil::I2(MMH,MMt,MMt,mu2); 15 | aryuttGL[6]=Tsil::I2(0,0,MMt,mu2); 16 | aryuttGL[7]=Tsil::B(MMH,MMt,MMt,mu2); 17 | aryuttGL[8]=Tsil::A(MMH,mu2); 18 | aryuttGL[9]=Tsil::A(MMt,mu2); 19 | aryuttGL[10]=Tsil::Beps(MMH,MMt,MMt,mu2); 20 | aryuttGL[11]=pow(MMH,-1); 21 | aryuttGL[12]=std::real(Tsil::B(0,0,MMt,mu2)); 22 | aryuttGL[13]=Tsil::Aeps(MMH,mu2); 23 | aryuttGL[14]=Tsil::Aeps(MMt,mu2); 24 | aryuttGL[15]=prot0ttHt->M(0); 25 | aryuttGL[16]=prottH0H->Vxzuv(0); 26 | aryuttGL[17]=prot0ttHt->Tuxv(0); 27 | aryuttGL[18]=protWt000->Tyzv(0); 28 | aryuttGL[19]=protHtt0t->M(0); 29 | aryuttGL[20]=prot00t00->M(0); 30 | aryuttGL[21]=prot000t0->M(0); 31 | aryuttGL[22]=aryuttGL[4]*aryuttGL[9]; 32 | aryuttGL[23]=MMH*aryuttGL[4]; 33 | aryuttGL[24]=1./2.*aryuttGL[23] - 17 - 7./2.*aryuttGL[22]; 34 | aryuttGL[24]=MMH*aryuttGL[24]; 35 | aryuttGL[25]=26*MMt + 7*aryuttGL[9] - aryuttGL[8]; 36 | aryuttGL[24]=2*aryuttGL[25] + aryuttGL[24]; 37 | aryuttGL[24]=aryuttGL[7]*aryuttGL[24]; 38 | aryuttGL[25]= - MMt*aryuttGL[20]; 39 | aryuttGL[25]=aryuttGL[25] + 59./4. + 13*aryuttGL[17]; 40 | aryuttGL[25]=MMt*aryuttGL[25]; 41 | aryuttGL[26]=5./4.*aryuttGL[12] + 5./2.; 42 | aryuttGL[26]=MMt*aryuttGL[26]; 43 | aryuttGL[26]=4*aryuttGL[9] + aryuttGL[26]; 44 | aryuttGL[26]=aryuttGL[12]*aryuttGL[26]; 45 | aryuttGL[27]=pow(MMt,2); 46 | aryuttGL[28]=aryuttGL[21]*aryuttGL[27]; 47 | aryuttGL[24]= - aryuttGL[25] - aryuttGL[26] + aryuttGL[28] - 48 | aryuttGL[24]; 49 | aryuttGL[25]=aryuttGL[5] - aryuttGL[8]; 50 | aryuttGL[26]=1./6.*aryuttGL[4]; 51 | aryuttGL[25]=aryuttGL[26]*aryuttGL[25]; 52 | aryuttGL[26]=1./2.*aryuttGL[4]; 53 | aryuttGL[28]=1 + aryuttGL[17]; 54 | aryuttGL[26]=aryuttGL[28]*aryuttGL[26]; 55 | aryuttGL[26]=4*aryuttGL[16] + aryuttGL[26]; 56 | aryuttGL[28]=1./3.*MMH; 57 | aryuttGL[26]=aryuttGL[26]*aryuttGL[28]; 58 | aryuttGL[29]=aryuttGL[4]*pow(aryuttGL[9],2); 59 | aryuttGL[30]= - 1./12.*aryuttGL[9] + aryuttGL[29]; 60 | aryuttGL[30]=aryuttGL[4]*aryuttGL[30]; 61 | aryuttGL[31]=MMt*aryuttGL[16]; 62 | aryuttGL[25]=aryuttGL[26] - 16./3.*aryuttGL[31] + aryuttGL[30] - 53./ 63 | 12. - 2*aryuttGL[17] + aryuttGL[25]; 64 | aryuttGL[25]=MMH*aryuttGL[25]; 65 | aryuttGL[26]=2*MMt; 66 | aryuttGL[30]=aryuttGL[26] - aryuttGL[28]; 67 | aryuttGL[30]=aryuttGL[30]*MMH; 68 | aryuttGL[27]=aryuttGL[30] - 8./3.*aryuttGL[27]; 69 | aryuttGL[30]=aryuttGL[15] + aryuttGL[19]; 70 | aryuttGL[27]=aryuttGL[27]*aryuttGL[30]; 71 | aryuttGL[30]= - 13*aryuttGL[9] - 4*aryuttGL[8]; 72 | aryuttGL[30]=aryuttGL[11]*aryuttGL[30]; 73 | aryuttGL[22]=1./3.*aryuttGL[30] + 4 - 3./2.*aryuttGL[22]; 74 | aryuttGL[22]=aryuttGL[8]*aryuttGL[22]; 75 | aryuttGL[29]=aryuttGL[29] - aryuttGL[9]; 76 | aryuttGL[23]=13./2. - aryuttGL[23]; 77 | aryuttGL[23]=aryuttGL[14]*aryuttGL[23]; 78 | aryuttGL[30]=MMt*aryuttGL[11]; 79 | aryuttGL[30]=3 + 13./3.*aryuttGL[30]; 80 | aryuttGL[30]=aryuttGL[13]*aryuttGL[30]; 81 | aryuttGL[31]=MMt*pow(Pi,2); 82 | aryuttGL[26]= - aryuttGL[26] + MMH; 83 | aryuttGL[26]=aryuttGL[10]*aryuttGL[26]; 84 | aryuttGL[28]=MMt - aryuttGL[28]; 85 | aryuttGL[28]=aryuttGL[18]*aryuttGL[28]; 86 | aryuttGL[22]=4*aryuttGL[28] + 4./3.*aryuttGL[26] - 3./4.* 87 | aryuttGL[31] + aryuttGL[30] + 5./3.*aryuttGL[23] + aryuttGL[27] + 88 | aryuttGL[25] - 11./3.*aryuttGL[5] - 13./6.*aryuttGL[6] + 89 | aryuttGL[22] - 8*aryuttGL[29] - 1./3.*aryuttGL[24]; 90 | 91 | yuttGLret = aryuttGL[22]*aryuttGL[3]*pow(aryuttGL[2],2)* 92 | aryuttGL[1]; 93 | return yuttGLret.real(); 94 | } 95 | } // namespace mr 96 | -------------------------------------------------------------------------------- /tests/Makefile.am: -------------------------------------------------------------------------------- 1 | AUTOMAKE_OPTIONS = subdir-objects 2 | ACLOCAL_AMFLAGS = ${ACLOCAL_FLAGS} -I m4 3 | 4 | LDADD = ../mr/libmr.a 5 | EX_CFLAGS = $(OPENMP_CFLAGS) $(MR_CFLAGS) -I$(top_srcdir)/tsil-1.3 -I$(top_srcdir)/mr 6 | 7 | noinst_PROGRAMS = testsuite 8 | 9 | TEST_FILES = tst-BKKS_1205.2893.cpp tst-JKV_0105304.cpp tst-JKV_0212319.cpp tst-mPlanck.cpp tst-MWeqMZ.cpp tst-RunDec.cpp tst-PolyLog.cpp 10 | 11 | if HAVE_EIGEN 12 | TEST_FILES += tst-mOSmMS_QCD.cpp 13 | endif 14 | 15 | testsuite_SOURCES = testsuite.cpp catch.hpp $(TEST_FILES) 16 | testsuite_CPPFLAGS = $(EX_CFLAGS) 17 | testsuite_LDADD = $(OPENMP_CFLAGS) $(MR_LIBS) -L$(top_srcdir)/mr -lmr -L$(top_srcdir)/tsil-1.3 -ltsil -lm 18 | 19 | EXTRA_DIST = README 20 | -------------------------------------------------------------------------------- /tests/README: -------------------------------------------------------------------------------- 1 | Test set 2 | 3 | Test prepared with the help of catch (https://github.com/philsquared/Catch) library. 4 | 5 | To list available tests use 6 | 7 | ./testsuite -l 8 | 9 | To run all test silently use without any arguments 10 | 11 | ./testsuite 12 | 13 | To see not only errors but also succesfully passed tests use 14 | 15 | ./testsuite -s 16 | 17 | Each test is supplied with its own tag, which can be used to run 18 | selected test. For example to run tests with tag [MS] use 19 | 20 | ./testsuite "[MS]" 21 | 22 | For other options use help with 23 | 24 | ./testsuite -h 25 | 26 | 27 | Available tests: 28 | 29 | * tst-MWeqMZ.cpp, tags:[W] [Z] 30 | 31 | Test for equality of corrections to MW and MZ in limit of equal masses MW=MZ, Mb=Mt 32 | 33 | * tst-RunDec.cpp, tags:[as] 34 | 35 | Comaprison of running and decoupling aof strong coupling constant 36 | with RunDec package 37 | 38 | * tst-mPlanck.cpp, tags: [1307.3536v2] [1307.3536v4] [g1] [g2] [gs] [lam] [yt] 39 | 40 | > Investigating the near-criticality of the Higgs boson. 41 | > https://inspirehep.net/record/1242456 42 | > By Dario Buttazzo, Giuseppe Degrassi, Pier Paolo Giardino, Gian F. Giudice, Filippo Sala, Alberto Salvio, Alessandro Strumia. 43 | > JHEP 1312 (2013) 089. 44 | 45 | Test of RGE running for all SM couplings up to a Plack 46 | scale. Different versions of arXiv versions of paper have 47 | different input at top mass scale. 48 | 49 | * tst-BKKS_1205.2893.cpp, tags: [1205.1893] [Higgs] [top] 50 | 51 | > Higgs Boson Mass and New Physics. 52 | > https://inspirehep.net/record/1114503 53 | > By Fedor Bezrukov, Mikhail Yu. Kalmykov, Bernd A. Kniehl, Mikhail Shaposhnikov. 54 | > JHEP 1210 (2012) 140. 55 | 56 | Comparison mixed EWxQCD corrections for Higgs and top masses and Yukawa top and Higgs self-coupling 57 | 58 | 59 | * tst-JKV_0105304.cpp, tags: [0105304] [W] [Z] 60 | 61 | > MS versus pole masses of gauge bosons: Electroweak bosonic two loop corrections. 62 | > https://inspirehep.net/record/557405 63 | > By F. Jegerlehner, M.Yu. Kalmykov, O. Veretin. 64 | > Nucl.Phys. B641 (2002) 285-326. 65 | 66 | Comparison of pure bosonic corrections to masses of gauge bosons 67 | MW and MZ 68 | 69 | * tst-JKV_0212319.cpp, tags: [0212319] [W] [Z] 70 | 71 | > MS-bar versus pole masses of gauge bosons. 2. Two loop electroweak fermion corrections. 72 | > https://inspirehep.net/record/605355 73 | > By F. Jegerlehner, Mikhail Yu. Kalmykov, O. Veretin. 74 | > Nucl.Phys. B658 (2003) 49-112. 75 | 76 | Comparison of bosonic and fermionic corrections to masses of gauge bosons 77 | MW and MZ 78 | 79 | * tst-mOSmMS_QCD.cpp, tags: [MS] [OS] [QCD] 80 | 81 | > Quark Mass Relations to Four-Loop Order in Perturbative QCD. 82 | > https://inspirehep.net/record/1342942 83 | > By Peter Marquard, Alexander V. Smirnov, Vladimir A. Smirnov, Matthias Steinhauser. 84 | > Phys.Rev.Lett. 114 (2015) 14, 142002. 85 | 86 | Check for correctnes of logarithm part controlled by RGE of four-loop relation 87 | between OS and MS masses in QCD 88 | -------------------------------------------------------------------------------- /tests/testsuite.cpp: -------------------------------------------------------------------------------- 1 | #define CATCH_CONFIG_MAIN 2 | #include "catch.hpp" 3 | 4 | -------------------------------------------------------------------------------- /tests/tst-BKKS_1205.2893.cpp: -------------------------------------------------------------------------------- 1 | #include "catch.hpp" 2 | #include "mr.hpp" 3 | 4 | using namespace mr; 5 | 6 | /////////////////////////////////////////////////////////////////////////////// 7 | TEST_CASE 8 | ( 9 | "Mixed QCD EW corrections to the Yukawa-top and Higgs self-coupling", 10 | "[1205.1893][top][Higgs]" 11 | ) 12 | { 13 | Approx approx = Approx::custom().epsilon( 0.00001 ); 14 | 15 | // Important Mb=0, but for comparison 16 | // mmd3->0 manualy in deltayta[...] 17 | OSinput oi = OSinput(0., 80.399, 91.1876, 125.6, 173.5); 18 | 19 | SECTION( "top,\\mu=MZ" ) 20 | { 21 | tt dMtZ(oi, oi.MMZ()); 22 | 23 | REQUIRE( dMtZ.x10() == Approx( -42.1506 ) ); 24 | REQUIRE( dMtZ.x11() == Approx( 975.307 ) ); 25 | 26 | REQUIRE( dMtZ.y10() == Approx( -20.4608 ) ); 27 | REQUIRE( dMtZ.y11() == Approx( -167.7 ) ); 28 | } 29 | SECTION( "top,\\mu=Mt" ) 30 | { 31 | tt dMtt(oi, oi.MMt()); 32 | 33 | REQUIRE( dMtt.x10() == Approx( 109.666 ) ); 34 | REQUIRE( dMtt.x11() == Approx( -417.114 ) ); 35 | 36 | REQUIRE( dMtt.y10() == Approx( 2.14111 ) ); 37 | REQUIRE( dMtt.y11() == Approx( -80.134 ) ); 38 | } 39 | SECTION( "Higgs,\\mu=Mz" ) 40 | { 41 | HH dMHZ(oi, oi.MMZ()); 42 | 43 | REQUIRE( dMHZ.x10() == Approx( 159.93 ) ); 44 | REQUIRE( dMHZ.x11() == Approx( -1527.21 ) ); 45 | 46 | REQUIRE( dMHZ.y10() == Approx( 203.31 ) ); 47 | REQUIRE( dMHZ.y11() == Approx( -3805.1 ) ); 48 | } 49 | SECTION( "Higgs,\\mu=Mt" ) 50 | { 51 | HH dMHt(oi, oi.MMt()); 52 | 53 | REQUIRE( dMHt.x10() == Approx( 196.631 ) ); 54 | REQUIRE( dMHt.x11() == Approx( -1480.94 ) ); 55 | 56 | REQUIRE( dMHt.y10() == Approx( -18.4183 ) ); 57 | REQUIRE( dMHt.y11() == Approx( -1953.91 ) ); 58 | } 59 | SECTION( "\\delta-r,\\mu=Mz" ) 60 | { 61 | dr ddrZ(oi, oi.MMZ()); 62 | 63 | REQUIRE( ddrZ.dr10() == Approx( -43.3796 ) ); 64 | REQUIRE( ddrZ.dr11() == Approx( 2277.89 ) ); 65 | } 66 | SECTION( "\\delta-r,\\mu=Mt" ) 67 | { 68 | dr ddrt(oi, oi.MMt()); 69 | 70 | REQUIRE( ddrt.dr10() == Approx( 215.049 ) ); 71 | REQUIRE( ddrt.dr11() == Approx( 472.97 ) ); 72 | } 73 | } 74 | -------------------------------------------------------------------------------- /tests/tst-JKV_0105304.cpp: -------------------------------------------------------------------------------- 1 | #include "catch.hpp" 2 | #include "mr.hpp" 3 | 4 | using namespace mr; 5 | 6 | /////////////////////////////////////////////////////////////////////////////// 7 | TEST_CASE 8 | ( 9 | "Bosonic part of two-loop EW corrections to the W,Z-boson masses", 10 | "[0105304][W][Z]" 11 | ) 12 | { 13 | MSinput mi = MSinput(0., 80.419, 91.188, 125.6, 174.3); 14 | SECTION( "One-loop" ) 15 | { 16 | SECTION( "W,\\mu=MW" ) 17 | { 18 | WW dMW_at_mu_eq_MW = WW(mi, mi.mmW()); 19 | 20 | REQUIRE( dMW_at_mu_eq_MW.x10() == Approx( 103.739 ) ); 21 | } 22 | SECTION( "Z,\\mu=MZ" ) 23 | { 24 | ZZ dMZ_at_mu_eq_MZ = ZZ(mi, mi.mmZ()); 25 | 26 | REQUIRE( dMZ_at_mu_eq_MZ.x10() == Approx( 35.446 ) ); 27 | } 28 | 29 | } 30 | SECTION( "Two-loop" ) 31 | { 32 | // Due to expansion in 1/mH we need enormously large mH = 800 GeV 33 | mi.setmH(800); 34 | // and small s_W = 0.1 35 | mi.setmW(mi.mZ()*sqrt(1 - 0.1)); 36 | 37 | SECTION( "W,\\mu=MW" ) 38 | { 39 | 40 | WW dMW_at_mu_eq_MW = WW(mi, mi.mmW()); 41 | 42 | REQUIRE( dMW_at_mu_eq_MW.x20(0, 0) == Approx( 1.95274e6 ) ); 43 | } 44 | SECTION( "Z,\\mu=MZ" ) 45 | { 46 | ZZ dMZ_at_mu_eq_MZ = ZZ(mi, mi.mmZ()); 47 | 48 | REQUIRE( dMZ_at_mu_eq_MZ.x20(0, 0) == Approx( 1.95905e6 ).epsilon(0.00001) ); 49 | } 50 | 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /tests/tst-JKV_0212319.cpp: -------------------------------------------------------------------------------- 1 | #include "catch.hpp" 2 | #include "mr.hpp" 3 | 4 | using namespace mr; 5 | 6 | /////////////////////////////////////////////////////////////////////////////// 7 | TEST_CASE 8 | ( 9 | "Full two-loop EW corrections to the W,Z-boson masses", 10 | "[0212319][W][Z]" 11 | ) 12 | { 13 | MSinput mi = MSinput(0., 80.419, 91.188, 800, 174.3); 14 | 15 | SECTION( "Two-loop" ) 16 | { 17 | // Due to expansion in 1/mH we need enormously large mH = 800 GeV 18 | mi.setmH(1800); 19 | // and small s_W = 0.1 20 | mi.setmW(mi.mZ()*sqrt(1 - 0.01)); 21 | 22 | SECTION( "W,\\mu=MW" ) 23 | { 24 | 25 | WW dMW_at_mu_eq_MW = WW(mi, mi.mmW()); 26 | 27 | REQUIRE( dMW_at_mu_eq_MW.x20() == Approx( 1.57207e9 ).epsilon(0.001) ); 28 | } 29 | SECTION( "Z,\\mu=MZ" ) 30 | { 31 | 32 | ZZ dMZ_at_mu_eq_MZ = ZZ(mi, mi.mmZ()); 33 | // Error in original files, it's normal to fail 34 | WARN( "Can not reproduce with original files" ); 35 | REQUIRE_FALSE( dMZ_at_mu_eq_MZ.x20() == Approx( 1.95306e+09 ).epsilon(0.001) ); 36 | } 37 | 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /tests/tst-MWeqMZ.cpp: -------------------------------------------------------------------------------- 1 | #include "catch.hpp" 2 | #include "mr.hpp" 3 | 4 | using namespace mr; 5 | 6 | /////////////////////////////////////////////////////////////////////////////// 7 | TEST_CASE 8 | ( 9 | "Full two-loop EW corrections to the W,Z-boson masses MW=MZ case", 10 | "[W][Z]" 11 | ) 12 | { 13 | MSinput mi = MSinput(0., 80.419, 91.188, 125.6, 174.3); 14 | // Due to expansion in 1/mH we need enormously large mH = 800 GeV 15 | mi.setmH(1800); 16 | // and small s_W = 0.001 17 | mi.setmW(mi.mZ()*sqrt(1 - 0.001)); 18 | // Mt close to Mb, but not zero, for numerical stability 19 | mi.setmt(0.4); 20 | 21 | WW dMW_at_mu_eq_MZ = WW(mi, mi.mmZ()); 22 | ZZ dMZ_at_mu_eq_MZ = ZZ(mi, mi.mmZ()); 23 | 24 | REQUIRE( dMW_at_mu_eq_MZ.x20() == Approx( dMZ_at_mu_eq_MZ.x20() ).epsilon(0.01) ); 25 | } 26 | -------------------------------------------------------------------------------- /tests/tst-PolyLog.cpp: -------------------------------------------------------------------------------- 1 | #include "catch.hpp" 2 | #include "mr.hpp" 3 | 4 | using namespace mr; 5 | 6 | /////////////////////////////////////////////////////////////////////////////// 7 | TEST_CASE 8 | ( 9 | "Check DiLog and TriLog evaluation implemented in TSIL", 10 | "[PolyLog]" 11 | ) 12 | { 13 | 14 | 15 | SECTION( "Real arguments" ) 16 | { 17 | 18 | std::complex li2 = mr::Li2( std::complex(1,0) ); 19 | REQUIRE( li2.real() == Approx( 1.64493 ) ); 20 | REQUIRE( li2.imag() == Approx( 0 ) ); 21 | 22 | std::complex li3 = mr::Li3( std::complex(1,0) ); 23 | REQUIRE( li3.real() == Approx( 1.20206 ) ); 24 | REQUIRE( li3.imag() == Approx( 0 ) ); 25 | 26 | } 27 | 28 | SECTION( "Imaginary arguments" ) 29 | { 30 | 31 | std::complex li2 = mr::Li2( std::complex(0,1) ); 32 | REQUIRE( li2.real() == Approx( -0.205617 ) ); 33 | REQUIRE( li2.imag() == Approx( 0.915966 ) ); 34 | 35 | std::complex li3 = mr::Li3( std::complex(0,1) ); 36 | REQUIRE( li3.real() == Approx( -0.112693 ) ); 37 | REQUIRE( li3.imag() == Approx( 0.968946 ) ); 38 | 39 | } 40 | 41 | SECTION( "Complex arguments" ) 42 | { 43 | 44 | std::complex li2 = mr::Li2( std::complex(1,1) ); 45 | REQUIRE( li2.real() == Approx( 0.61685 ) ); 46 | REQUIRE( li2.imag() == Approx( 1.46036 ) ); 47 | 48 | std::complex li3 = mr::Li3( std::complex(1,1) ); 49 | REQUIRE( li3.real() == Approx( 0.871159 ) ); 50 | REQUIRE( li3.imag() == Approx( 1.26708 ) ); 51 | 52 | } 53 | 54 | 55 | } 56 | -------------------------------------------------------------------------------- /tests/tst-RunDec.cpp: -------------------------------------------------------------------------------- 1 | #include "catch.hpp" 2 | #include "mr.hpp" 3 | 4 | using namespace mr; 5 | 6 | /////////////////////////////////////////////////////////////////////////////// 7 | TEST_CASE 8 | ( 9 | "Strong coupling running and decoupling", 10 | "[as]" 11 | ) 12 | { 13 | 14 | OSinput oi(pdg2014::mb,pdg2014::MW,pdg2014::MZ,pdg2014::MH,pdg2014::Mt); 15 | AlphaS aS(oi); 16 | 17 | double aMt5,aMt6,a100k6; 18 | 19 | aMt5 = run(pdg2014::asMZ, pdg2014::MZ, pdg2014::Mt, 5 , 4); 20 | 21 | aMt6 = as5nf2as6nf(pdg2014::Mt, pdg2014::Mt, aMt5, /* nl= */5, 3); 22 | 23 | a100k6 = run(aMt6, pdg2014::Mt, 100000, 6 ); 24 | 25 | SECTION( "\\mu=Mt,nf=5" ) // Only running 26 | { 27 | OSinput oi(pdg2014::mb,pdg2014::MW,pdg2014::MZ,pdg2014::MH,pdg2014::Mt); 28 | AlphaS aSnoDec(oi, pdg2014::asMZ, 4, 5); 29 | 30 | REQUIRE( aSnoDec(pdg2014::Mt) == Approx( 0.108002 ) ); 31 | } 32 | SECTION( "\\mu=Mt,nf=6" ) // Running wth decoupling at Mt 33 | { 34 | REQUIRE( aS(pdg2014::Mt) == Approx( 0.108057 ) ); 35 | } 36 | SECTION( "\\mu=mb,nf=5" ) 37 | { 38 | REQUIRE( aS(pdg2014::mb) == Approx( 0.226525 ) ); 39 | } 40 | SECTION( "\\mu=100 TeV,nf=6" ) 41 | { 42 | REQUIRE( aS(100000) == Approx( 0.0605896 ) ); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /tests/tst-mPlanck.cpp: -------------------------------------------------------------------------------- 1 | #include "catch.hpp" 2 | #include "mr.hpp" 3 | 4 | using namespace mr; 5 | 6 | /////////////////////////////////////////////////////////////////////////////// 7 | TEST_CASE 8 | ( 9 | "Running up to the Planck scale v4", 10 | "[1307.3536v4][g1][g2][gs][yt][lam]" 11 | ) 12 | { 13 | 14 | ParametersSM<3,3,3, 15 | 3,3,-1, // No dependence on Yukawa-tau 16 | 3,3,0> // And we do not need running VEV 17 | av( 18 | 5./3.*pow(0.35830/4./Pi,2), // GUT normalization 19 | pow(0.64779/4./Pi,2), 20 | pow(1.1666/4./Pi,2), 21 | pow(0.93690/4./Pi,2), 22 | pow(0.0/4./Pi,2), 23 | pow(0.0/4./Pi,2), 24 | 0.12604*pow(4.*Pi,-2), 25 | 131.55, 26 | 0*246, 27 | pow(173.34,2), 28 | 3); 29 | 30 | 31 | double mmPlanck = pow(1.2209,2) * pow(10.,2*19); 32 | SMCouplings avMpl = av(mmPlanck); 33 | 34 | REQUIRE( (4.*Pi*sqrt(avMpl[couplings::g1])) == Approx( 0.6154 ).epsilon( 0.0001 ) ); 35 | REQUIRE( (4.*Pi*sqrt(avMpl[couplings::g2])) == Approx( 0.5055 ).epsilon( 0.0001 ) ); 36 | REQUIRE( (4.*Pi*sqrt(avMpl[couplings::gs])) == Approx( 0.4873 ).epsilon( 0.0001 ) ); 37 | REQUIRE( (4.*Pi*sqrt(avMpl[couplings::yt])) == Approx( 0.3825 ).epsilon( 0.0001 ) ); 38 | REQUIRE( (16.*Pi*Pi*avMpl[couplings::lam]) == Approx(-0.0143 ).epsilon( 0.0001 ) ); 39 | REQUIRE( avMpl[couplings::mphi] == Approx( 139.4 ).epsilon( 0.01 ) ); // In 40 | // original 41 | // paper 42 | // there 43 | // is 44 | // mistake 129.4 45 | 46 | } 47 | 48 | 49 | TEST_CASE 50 | ( 51 | "Running up to the Planck scale v2", 52 | "[1307.3536v2][g1][g2][gs][yt][lam]" 53 | ) 54 | { 55 | 56 | ParametersSM<3,3,3, 57 | 3,3,-1, // No dependence on Yukawa-tau 58 | 3,3,0> // And we do not need running VEV 59 | av( 60 | 5./3.*pow(0.35761/4./Pi,2), // GUT normalization 61 | pow(0.64822/4./Pi,2), 62 | pow(1.1666/4./Pi,2), 63 | pow(0.93558/4./Pi,2), 64 | pow(0.0/4./Pi,2), 65 | pow(0.0/4./Pi,2), 66 | 0.12711*pow(4.*Pi,-2), 67 | 132.03, 68 | 0*246, 69 | pow(173.10,2), 70 | 3); 71 | 72 | 73 | double mmPlanck = pow(1.2209,2) * pow(10.,2*19); 74 | SMCouplings avMpl = av(mmPlanck); 75 | 76 | REQUIRE( (4.*Pi*sqrt(avMpl[couplings::g1])) == Approx( 0.6133 ).epsilon( 0.0001 ) ); 77 | REQUIRE( (4.*Pi*sqrt(avMpl[couplings::g2])) == Approx( 0.5057 ).epsilon( 0.0001 ) ); 78 | REQUIRE( (4.*Pi*sqrt(avMpl[couplings::gs])) == Approx( 0.4873 ).epsilon( 0.0001 ) ); 79 | REQUIRE( (4.*Pi*sqrt(avMpl[couplings::yt])) == Approx( 0.3813 ).epsilon( 0.0001 ) ); 80 | REQUIRE( (16.*Pi*Pi*avMpl[couplings::lam]) == Approx(-0.0113 ).epsilon( 0.0001 ) ); 81 | REQUIRE( avMpl[couplings::mphi] == Approx( 140.3 ).epsilon( 0.01 ) ); 82 | 83 | } 84 | -------------------------------------------------------------------------------- /tsil-1.3/ISSUES.txt: -------------------------------------------------------------------------------- 1 | KNOWN ISSUES 2 | ------------ 3 | 4 | Please send any bug reports to the authors at the email addresses in 5 | README.txt! 6 | 7 | 1. The compiler optimization flags have been set to -O3 in the 8 | Makefile. The only platform/compilers for which this is known to 9 | cause problems are 10 | 11 | (1) The Apple LLVM compiler v6.0 that ships with Xcode tools v6.1 12 | and later (at least through v6.3.2). In this case erroneous code 13 | is produced for optimization levels other than -O0 (although -O0 is 14 | fine). Note that this compiler works fine with TSIL_DOUBLE data at 15 | all optimization levels. 16 | 17 | (2) icc v12.1.4 under RedHat Linux and for TSIL_LONG datatypes. In 18 | this case erroneous code is produced for optimization levels other 19 | than -O0 (although -O0 is fine). Note that this compiler works 20 | fine with TSIL_DOUBLE data at all optimization levels. 21 | 22 | (2) gcc v2.96, also under RedHat Linux. Again, erroneous code is 23 | produced for optimization levels other than -O0. Later versions of 24 | gcc are fine with -O3, however. 25 | 26 | However, if anomalous results (very long computation times and/or 27 | wrong results) are encountered, the user may wish to test whether 28 | these can be eliminated by using -O0 instead of -O3. The speed 29 | penalty for -O0 is not excessive. 30 | 31 | (In one known case -- system running Red Hat 4.1.2-52 with gcc 32 | 4.1.2 -- erroneous code is produced for TSIL_LONG data and -O0, 33 | though not for any other optimization level. TSIL_DOUBLE data works 34 | fine at all optimization levels.) 35 | 36 | 2. The test suite can and will result in a few WARNs and even FAILs 37 | being reported. This is because some of the cases tested have large 38 | mass hierarchies, where some of the functions are very sensitive to 39 | roundoff errors. 40 | 41 | Most commonly, with TSIL_LONG data one obtains 313 PASSes and 7 42 | WARNs. With TSIL_DOUBLE data one obtains 303 PASSes, 16 WARNs, and 43 | 1 FAIL. 44 | 45 | 3. If warning messages become annoying, they can be turned off with 46 | 47 | TSIL_WarnsOff (); 48 | 49 | Alternatively, one can redirect stderr to a file; e.g. if using 50 | ksh/bash 51 | 52 | ./tsil 1 2 3 4 5 10 1 > out 2> errmsgs 53 | 54 | would place the standard output in a file "out" and warnings and 55 | errors in "errmsgs". 56 | -------------------------------------------------------------------------------- /tsil-1.3/Makefile.am: -------------------------------------------------------------------------------- 1 | AUTOMAKE_OPTIONS = subdir-objects 2 | ACLOCAL_AMFLAGS = ${ACLOCAL_FLAGS} -I m4 3 | 4 | lib_LIBRARIES = libtsil.a 5 | #################################################################### 6 | # 7 | # Makefile for TSIL (Two-loop Self-energy Integral Library) 8 | # 9 | ######################## DATA SIZE ################################# 10 | # Uncomment one of these to choose the floating point data size (if 11 | # unset, LONG will be used): 12 | # 13 | # TSIL_SIZE = -DTSIL_SIZE_LONG # long double/long double complex 14 | # 15 | TSIL_SIZE = -DTSIL_SIZE_DOUBLE # double/double complex 16 | # 17 | ########################## COMPILER ################################ 18 | # Uncomment the choices appropriate for your computing environment. 19 | # (Not guaranteed to be complete. Please send info to the authors if 20 | # you succeed in making things work on a system requiring different 21 | # flags.) 22 | # 23 | # Intel C compiler: 24 | # ================= 25 | # CC = icc 26 | # TSIL_OPT = -O3 -unroll -w 27 | # 28 | # GNU C Compiler: 29 | # =============== 30 | CC = gcc 31 | TSIL_OPT = -funroll-loops 32 | # 33 | ################### INSTALLATION DIRECTORIES ####################### 34 | # 35 | # TSIL_LIBDIR = /usr/lib 36 | # TSIL_INCDIR = /usr/include 37 | # 38 | ################### TEST SUITE MODE ################################ 39 | # 40 | # TSIL_TESTOPT = -DTSIL_TEST_STU 41 | # TSIL_TESTOPT = -DTSIL_TEST_ST 42 | # 43 | #################################################################### 44 | #################################################################### 45 | # 46 | # Users should not need to modify anything below this point!!! 47 | # 48 | #################################################################### 49 | #################################################################### 50 | 51 | libtsil_a_SOURCES = initialize.c \ 52 | evaluate.c \ 53 | generic.c \ 54 | rk6.c \ 55 | rk5.c \ 56 | functions.c \ 57 | dilog.c \ 58 | trilog.c \ 59 | dBds.c \ 60 | dSds.c \ 61 | dTds.c \ 62 | dUds.c \ 63 | dsMds.c \ 64 | initB.c \ 65 | initS.c \ 66 | initT.c \ 67 | initU.c \ 68 | initV.c \ 69 | initM.c \ 70 | special.c \ 71 | analyticAB.c \ 72 | analyticI.c \ 73 | analyticS.c \ 74 | analyticT.c \ 75 | analyticTbar.c \ 76 | analyticU.c \ 77 | analyticV.c \ 78 | analyticM.c \ 79 | setTbar.c \ 80 | setV.c \ 81 | setbold.c \ 82 | internal.h tsil.h tsil_funcs.h tsil_global.h tsil_names.h tsil_params.h 83 | 84 | 85 | libtsil_a_CFLAGS = $(TSIL_RESCALE) $(TSIL_SIZE) $(TSIL_OPT) 86 | 87 | EXTRA_DIST = CHANGELOG.txt ISSUES.txt LICENSE.txt README.txt 88 | 89 | pkginclude_HEADERS = tsil.h 90 | -------------------------------------------------------------------------------- /tsil-1.3/dBds.c: -------------------------------------------------------------------------------- 1 | /* Derivative of B function with respect to s used for Runge-Kutta. 2 | This one relies on the TSIL_DATA struct. See the function TSIL_dBds 3 | in analyticAB.c for a stand-alone version. */ 4 | 5 | #include "internal.h" 6 | 7 | /* **************************************************************** */ 8 | 9 | TSIL_COMPLEX TSIL_dBds_rk (TSIL_BTYPE B, TSIL_COMPLEX s) 10 | { 11 | return ((B.B_cB[0] * (B.value) - 0.5L*s + B.B_c[0])/(s - B.B_den[0]) 12 | + (B.B_cB[1] * (B.value) - 0.5L*s + B.B_c[1])/(s - B.B_den[1]))/s; 13 | } 14 | -------------------------------------------------------------------------------- /tsil-1.3/dSds.c: -------------------------------------------------------------------------------- 1 | /* Derivative of S function with respect to s. */ 2 | 3 | #include "internal.h" 4 | 5 | /* ******************************************************************* */ 6 | 7 | TSIL_COMPLEX TSIL_dSds (TSIL_STYPE S, TSIL_COMPLEX s) 8 | { 9 | return (S.value + 10 | S.arg[0] * *(S.tval[0]) + 11 | S.arg[1] * *(S.tval[1]) + 12 | S.arg[2] * *(S.tval[2]) + S.S_c)/s - 0.5L; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /tsil-1.3/dTds.c: -------------------------------------------------------------------------------- 1 | /* Derivative of T function with respect to s. */ 2 | 3 | #include "internal.h" 4 | 5 | /* **************************************************************** */ 6 | 7 | TSIL_COMPLEX TSIL_dTds (TSIL_TTYPE T, TSIL_COMPLEX s) 8 | { 9 | int i; 10 | TSIL_COMPLEX result = 0.0L; 11 | 12 | for (i=0; i<4; i++) 13 | { 14 | result += ( *(T.sval) * T.cTS_num[i] 15 | + *(T.tval[0]) * T.cTT1_num[i] 16 | + *(T.tval[1]) * T.cTT2_num[i] 17 | + *(T.tval[2]) * T.cTT3_num[i] 18 | + T.cT_num[i])/(s - T.T_den[i]); 19 | } 20 | 21 | result /= s; 22 | result += T.cTs_num/(s - T.T_den[0]); 23 | 24 | return result; 25 | } 26 | -------------------------------------------------------------------------------- /tsil-1.3/dUds.c: -------------------------------------------------------------------------------- 1 | /* Derivative of U function with respect to s. */ 2 | 3 | #include "internal.h" 4 | 5 | /* **************************************************************** */ 6 | 7 | TSIL_COMPLEX TSIL_dUds (TSIL_UTYPE U, TSIL_COMPLEX s) 8 | { 9 | TSIL_COMPLEX temp, num_th, num_ps, result; 10 | 11 | temp = *(U.sval) + *(U.tval[1]) * U.cT2 + *(U.tval[2]) * U.cT3 12 | + U.con - 0.125L*s; 13 | 14 | num_th = (U.value)*U.cU_th + *(U.tval[0])*U.cT1_th + temp*U.cS_th; 15 | num_ps = (U.value)*U.cU_ps + *(U.tval[0])*U.cT1_ps + temp*U.cS_ps; 16 | 17 | result = num_th/(s - U.den_th) + num_ps/(s - U.den_ps); 18 | result /= s; 19 | 20 | return result; 21 | } 22 | -------------------------------------------------------------------------------- /tsil-1.3/dsMds.c: -------------------------------------------------------------------------------- 1 | /* Derivative of s*M with respect to s. */ 2 | 3 | #include "internal.h" 4 | 5 | /* ******************************************************************* */ 6 | 7 | TSIL_COMPLEX TSIL_dsMds (TSIL_MTYPE m, TSIL_COMPLEX s) 8 | { 9 | TSIL_COMPLEX res; 10 | int i; 11 | TSIL_COMPLEX Mdenom; 12 | TSIL_COMPLEX cMU[4], cMT[5], cMB[2], cMS, cM; 13 | TSIL_COMPLEX invsminusTHxz, invsminusPSxz, invsminusTHyu, invsminusPSyu; 14 | 15 | invsminusTHxz = 1.L/(s - m.THxz); 16 | invsminusPSxz = 1.L/(s - m.PSxz); 17 | invsminusTHyu = 1.L/(s - m.THyu); 18 | invsminusPSyu = 1.L/(s - m.PSyu); 19 | 20 | cMU[0] = (m.aMU[0] + s*m.aMUs[0])* 21 | (m.bMU[0][0]*invsminusTHxz + m.bMU[0][1]*invsminusPSxz); 22 | cMU[1] = (m.aMU[1] + s*m.aMUs[1])* 23 | (m.bMU[1][0]*invsminusTHyu + m.bMU[1][1]*invsminusPSyu); 24 | cMU[2] = (m.aMU[2] + s*m.aMUs[2])* 25 | (m.bMU[2][0]*invsminusTHxz + m.bMU[2][1]*invsminusPSxz); 26 | cMU[3] = (m.aMU[3] + s*m.aMUs[3])* 27 | (m.bMU[3][0]*invsminusTHyu + m.bMU[3][1]*invsminusPSyu); 28 | 29 | for (i=0; i<5; i++) 30 | cMT[i] = m.aMT[i] + m.bMT[i][0]*invsminusTHxz + m.bMT[i][1]*invsminusPSxz 31 | + m.bMT[i][2]*invsminusTHyu + m.bMT[i][3]*invsminusPSyu; 32 | 33 | cMT[4] += s*m.aMT5s; 34 | 35 | cMS = m.aMS + m.bMS[0]*invsminusTHxz + m.bMS[1]*invsminusPSxz 36 | + m.bMS[2]*invsminusTHyu + m.bMS[3]*invsminusPSyu; 37 | 38 | cMB[0] = (m.aMB[0] + m.bMB[0][0]*invsminusTHyu + m.bMB[0][1]*invsminusPSyu); 39 | 40 | cMB[1] = (m.aMB[1] + m.bMB[1][0]*invsminusTHxz + m.bMB[1][1]*invsminusPSxz); 41 | 42 | cM = m.aM + s*m.aMs + m.bM[0]*invsminusTHxz + m.bM[1]*invsminusPSxz 43 | + m.bM[2]*invsminusTHyu + m.bM[3]*invsminusPSyu; 44 | 45 | /* Assemble result: */ 46 | res = cMT[4] * (*(m.tval[4]) + *(m.tval[5])) 47 | + (m.dMB + s*m.dMBs)*(cMB[0] * *(m.bval[0]) + cMB[1] * *(m.bval[1])) 48 | + cM + cMS * (*(m.sval[0]) + *(m.sval[1]) 49 | + 0.5L*s * *(m.bval[0]) * *(m.bval[1]) + m.cMSconst); 50 | 51 | for (i=0; i<4; i++) { 52 | res += cMU[i] * *(m.uval[i]); 53 | res += cMT[i] * *(m.tval[i]); 54 | } 55 | 56 | Mdenom = m.adenom[0] + m.adenom[1]*s + m.adenom[2]*s*s; 57 | 58 | return res/Mdenom; 59 | } 60 | -------------------------------------------------------------------------------- /tsil-1.3/evaluate.c: -------------------------------------------------------------------------------- 1 | /* ******************************************************************* */ 2 | /* EVALUATION DRIVER PROGRAM */ 3 | /* ******************************************************************* */ 4 | 5 | #include "internal.h" 6 | #include "tsil_params.h" 7 | 8 | /* ******************************************************************* */ 9 | 10 | int TSIL_Evaluate (TSIL_DATA *foo, TSIL_REAL s) 11 | { 12 | int status = 1; 13 | int isAnalytic = 0; 14 | TSIL_REAL x0, y0, z0, u0, v0, s0, qq0; 15 | int tmpWarns; 16 | 17 | if (foo->isInitialized != YES) 18 | TSIL_Error("TSIL_Evaluate", 19 | "You must first set parameter values using TSIL_SetParams!", 3); 20 | 21 | /* Set s value in foo */ 22 | foo->s = s; 23 | 24 | /* Decide if this is a special case known analytically, or a generic 25 | case that requires Runge-Kutta evaluation: */ 26 | 27 | /* Temporarily disable WARNs */ 28 | tmpWarns = printWarns; 29 | printWarns = NO; 30 | 31 | if (foo->whichFns == STUM) 32 | isAnalytic = TSIL_Manalytic (foo->x, foo->y, foo->z, foo->u, foo->v, 33 | foo->s, &(foo->M.value)); 34 | else if (foo->whichFns == STU) 35 | isAnalytic = TSIL_Uanalytic (foo->x, foo->z, foo->u, foo->v, 36 | foo->s, foo->qq, &(foo->U[xzuv].value)); 37 | else if (foo->whichFns == ST) { 38 | isAnalytic = TSIL_Tanalytic (foo->x, foo->u, foo->v, 39 | foo->s, foo->qq, &(foo->T[xuv].value)); 40 | isAnalytic *= TSIL_Tanalytic (foo->u, foo->x, foo->v, 41 | foo->s, foo->qq, &(foo->T[uxv].value)); 42 | isAnalytic *= TSIL_Tanalytic (foo->v, foo->x, foo->u, 43 | foo->s, foo->qq, &(foo->T[vxu].value)); 44 | } 45 | else 46 | TSIL_Error ("TSIL_Evaluate", 47 | "This can't happen: whichFns was not properly set!", 2); 48 | 49 | /* Restore warnings */ 50 | /* printWarns = YES; */ 51 | 52 | if (isAnalytic == TRUE) { 53 | if (0 == TSIL_CaseSpecial (foo)) 54 | TSIL_Error("TSIL_Evaluate", 55 | "This can't happen! TSIL_CaseSpecial returned 0 when isAnalytic is TRUE.", 1); 56 | /* ...and we are finished in this case */ 57 | foo->status = ANALYTIC; 58 | } 59 | else { 60 | /* Generic evaluation by integration: */ 61 | /* In v1.2 we store the initial args and restore them exactly: */ 62 | x0 = foo->x; y0 = foo->y; z0 = foo->z; u0 = foo->u; 63 | v0 = foo->v; s0 = s; qq0 = foo->qq; 64 | 65 | TSIL_Rescale (foo); 66 | 67 | /* Check if this is the "unnatural" threshold case */ 68 | if (TSIL_UnnaturalCase (foo)) 69 | TSIL_Warn ("TSIL_Evaluate", 70 | "'Unnatural' threshold case! Expect reduced accuracy."); 71 | 72 | /* Generic evaluation */ 73 | TSIL_CaseGeneric (foo); 74 | 75 | if (1 == REDOANALYTIC) { 76 | /* 77 | The following line puts in the analytic results for B, and if 78 | available, S,T,U. But leaving it out allows debugging of the 79 | RK evaluation of analytic B,S,T,U cases, which is quite useful 80 | for now. 81 | */ 82 | TSIL_CaseSpecial (foo); 83 | } 84 | 85 | /* Undo rescaling */ 86 | TSIL_Unscale (foo); 87 | foo->x = x0; foo->y = y0; foo->z = z0; foo->u = u0; 88 | foo->v = v0; s = s0; foo->qq = qq0; 89 | } 90 | 91 | /* Set additional functions: */ 92 | TSIL_SetTbar (foo); 93 | TSIL_SetV (foo); 94 | TSIL_SetBold (foo); 95 | 96 | /* if (foo->whichFns == STU) */ 97 | /* foo->B[xz].value = B(foo->x, foo->z, foo->s, foo->qq); */ 98 | 99 | /* Restore warnings */ 100 | printWarns = tmpWarns; 101 | 102 | /* Implement status codes eventually */ 103 | return status; 104 | } 105 | -------------------------------------------------------------------------------- /tsil-1.3/fevaluate.c: -------------------------------------------------------------------------------- 1 | /* 2 | === fevaluate.c === 3 | 4 | This is a simple wrapper routine that provides an interface to 5 | Fortran. In the Fortran program, include the header 6 | 'tsil_fort.inc'; this defines a common block corresponding to the 7 | struct below. One then calls the subroutine 8 | 9 | CALL tsilfevaluate(...) 10 | 11 | defined herein, to evaluate the basis integrals. 12 | 13 | This code can serve as a model if users are interested in writing 14 | their own variants with more specialized capabilities. See the 15 | file README.txt for detailed notes on the issues involved. 16 | */ 17 | 18 | #include "internal.h" 19 | #include "tsil_fortran.h" 20 | 21 | /* This struct is used to pass the results of the calculation back to 22 | the calling program; it matches the data COMMON block defined in 23 | tsil_fort.inc. Note that the type sizes MUST agree between them; 24 | the struct and COMMON block must have the same memory footprint. */ 25 | 26 | struct { 27 | 28 | /* Basic functions */ 29 | TSIL_COMPLEX_F M; 30 | TSIL_COMPLEX_F U[NUM_U_FUNCS]; 31 | TSIL_COMPLEX_F T[NUM_T_FUNCS]; 32 | TSIL_COMPLEX_F S[NUM_S_FUNCS]; 33 | TSIL_COMPLEX_F B[NUM_B_FUNCS]; 34 | TSIL_COMPLEX_F V[NUM_V_FUNCS]; 35 | TSIL_COMPLEX_F Tbar[NUM_T_FUNCS]; 36 | 37 | /* Bold functions */ 38 | TSIL_COMPLEX_F UU[NUM_U_FUNCS][3]; 39 | TSIL_COMPLEX_F VV[NUM_V_FUNCS][3]; 40 | TSIL_COMPLEX_F TT[NUM_T_FUNCS][3]; 41 | TSIL_COMPLEX_F SS[NUM_S_FUNCS][3]; 42 | 43 | } results_; 44 | 45 | /* For check that data types match (not foolproof!) */ 46 | struct { 47 | int rsize; 48 | } rsize_; 49 | 50 | /* ******************************************************************* */ 51 | /* Generic wrapper function */ 52 | 53 | void tsilfevaluate_ (TSIL_REAL_F *x, 54 | TSIL_REAL_F *y, 55 | TSIL_REAL_F *z, 56 | TSIL_REAL_F *u, 57 | TSIL_REAL_F *v, 58 | TSIL_REAL_F *qq, 59 | TSIL_REAL_F *s) 60 | { 61 | /* Below is cut and pasted directly from tsil_names.h */ 62 | const char *uname[] = {"Uzxyv","Uuyxv","Uxzuv","Uyuzv"}; 63 | const char *tname[] = {"Tvyz", "Tuxv", "Tyzv", "Txuv", "Tzyv", "Tvxu"}; 64 | const char *sname[] = {"Svyz", "Suxv"}; 65 | const char *bname[] = {"Bxz", "Byu"}; 66 | const char *vname[] = {"Vzxyv","Vuyxv","Vxzuv","Vyuzv"}; 67 | const char *tbarname[] = {"TBARvyz", "TBARuxv", "TBARyzv", 68 | "TBARxuv", "TBARzyv", "TBARvxu"}; 69 | 70 | TSIL_DATA res; 71 | int i, j; 72 | static int compiledSize = TSIL_REAL_SIZE_F; 73 | 74 | if (rsize_.rsize != compiledSize) 75 | TSIL_Warn ("tsilfevaluate", "Apparent type mismatch between Fortran and C!"); 76 | 77 | TSIL_SetParameters (&res, 78 | (TSIL_REAL) (*x), 79 | (TSIL_REAL) (*y), 80 | (TSIL_REAL) (*z), 81 | (TSIL_REAL) (*u), 82 | (TSIL_REAL) (*v), 83 | (TSIL_REAL) (*qq)); 84 | 85 | TSIL_Evaluate (&res, (TSIL_REAL) (*s)); 86 | 87 | /* Extract results */ 88 | results_.M = (TSIL_COMPLEX_F) TSIL_GetFunction (&res, "M"); 89 | 90 | /* Note non-standard indexing-by-pointer of UU, VV, TT, SS arrays 91 | for compatibility with Fortran indexing convention. */ 92 | 93 | for (i=0; iarg[0] = x; 12 | b->arg[1] = y; 13 | 14 | b->B_den[0] = TSIL_Th2 (x, y); 15 | b->B_den[1] = TSIL_Ps2 (x, y); 16 | 17 | b->B_cB[0] = 0.5L * b->B_den[0]; 18 | b->B_cB[1] = 0.5L * b->B_den[1]; 19 | 20 | sqrtx = TSIL_SQRT(x); 21 | sqrty = TSIL_SQRT(y); 22 | 23 | alphax = TSIL_Alpha(x,qq); 24 | alphay = TSIL_Alpha(y,qq); 25 | 26 | b->B_c[0] = 0.5L*(sqrtx + sqrty)*(alphax + alphay); 27 | b->B_c[1] = 0.5L*(sqrtx - sqrty)*(alphax - alphay); 28 | } 29 | 30 | -------------------------------------------------------------------------------- /tsil-1.3/initS.c: -------------------------------------------------------------------------------- 1 | /* Routines for setting up and initializing S-type functions */ 2 | 3 | #include "internal.h" 4 | 5 | /* ***************************************************************** */ 6 | 7 | void TSIL_ConstructS (TSIL_STYPE *s, 8 | int n, 9 | TSIL_REAL x, 10 | TSIL_REAL y, 11 | TSIL_REAL z, 12 | TSIL_REAL qq) 13 | { 14 | s->which = n; 15 | s->arg[0] = x; 16 | s->arg[1] = y; 17 | s->arg[2] = z; 18 | 19 | s->S_c = x + y + z - TSIL_A(x,qq) - TSIL_A(y,qq) - TSIL_A(z,qq); 20 | 21 | return; 22 | } 23 | -------------------------------------------------------------------------------- /tsil-1.3/initU.c: -------------------------------------------------------------------------------- 1 | /* Routines for setup and initial values of U-type functions */ 2 | 3 | #include "internal.h" 4 | 5 | /* **************************************************************** */ 6 | 7 | void TSIL_ConstructU (TSIL_UTYPE *u, 8 | int n, 9 | TSIL_REAL z, 10 | TSIL_REAL x, 11 | TSIL_REAL y, 12 | TSIL_REAL v, 13 | TSIL_REAL qq) 14 | { 15 | u->which = n; 16 | u->arg[0] = z; 17 | u->arg[1] = x; 18 | u->arg[2] = y; 19 | u->arg[3] = v; 20 | 21 | /*=== Precompute evolution coefficients: ===*/ 22 | 23 | /* If second argument vanishes, we will run U=0 exactly, and fix up 24 | the result afterwards with CorrectUs. */ 25 | if (x < TSIL_TOL) 26 | { 27 | /* Denominator poles (safely avoids s = pole because of rescaling) */ 28 | u->den_th = 2.0L; 29 | u->den_ps = 2.0L; 30 | 31 | /* Numerator factors: */ 32 | u->cU_th = 0.0L; 33 | u->cU_ps = 0.0L; 34 | u->cS_th = 0.0L; 35 | u->cS_ps = 0.0L; 36 | u->cT1_th = 0.0L; 37 | u->cT1_ps = 0.0L; 38 | u->cT2 = 0.0L; 39 | u->cT3 = 0.0L; 40 | u->con = 0.0L; 41 | 42 | return; 43 | } 44 | 45 | /* Denominator factors */ 46 | u->den_th = TSIL_Th2(z, x); 47 | u->den_ps = TSIL_Ps2(z, x); 48 | 49 | /* Numerator factors: */ 50 | u->cU_th = u->den_th/2.0L; 51 | u->cU_ps = u->den_ps/2.0L; 52 | 53 | u->cS_th = -TSIL_SQRT(z/x) - 1.0L; 54 | u->cS_ps = TSIL_SQRT(z/x) - 1.0L; 55 | 56 | u->cT1_th = (u->cS_th) * (z + 0.5L*TSIL_SQRT(z*x)); 57 | u->cT1_ps = (u->cS_ps) * (z - 0.5L*TSIL_SQRT(z*x)); 58 | 59 | u->cT2 = v/2.0L; 60 | u->cT3 = y/2.0L; 61 | 62 | u->con = 0.5L*(z - TSIL_A(z, qq) + y - TSIL_A(y, qq) + v - TSIL_A(v, qq) -TSIL_I2(x, y, v, qq)); 63 | 64 | return; 65 | } 66 | -------------------------------------------------------------------------------- /tsil-1.3/initV.c: -------------------------------------------------------------------------------- 1 | /* Routines for setup and initial values of V-type functions */ 2 | 3 | #include "internal.h" 4 | 5 | /* **************************************************************** */ 6 | 7 | void TSIL_ConstructV (TSIL_VTYPE *V, 8 | int n, 9 | TSIL_REAL z, 10 | TSIL_REAL x, 11 | TSIL_REAL y, 12 | TSIL_REAL v, 13 | TSIL_REAL qq) 14 | { 15 | V->which = n; 16 | V->arg[0] = z; 17 | V->arg[1] = x; 18 | V->arg[2] = y; 19 | V->arg[3] = v; 20 | 21 | return; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /tsil-1.3/internal.h: -------------------------------------------------------------------------------- 1 | /* General header for "internal" use */ 2 | 3 | #include "tsil.h" /* Contains types and user API prototypes */ 4 | #include "tsil_global.h" /* Misc. global objects */ 5 | #include "tsil_funcs.h" /* Contains remaining functions */ 6 | #include "tsil_params.h" /* Parameters, e.g. for integration */ 7 | #include 8 | #include 9 | 10 | #ifndef PI 11 | #define PI 4.0L*TSIL_ATAN(1.0L) 12 | #endif 13 | 14 | #define Zeta2 1.644934066848226436472415166646025189219L 15 | #define Zeta3 1.202056903159594285399738161511449990765L 16 | #define TSIL_Infinity ((1.0L+ 1.0L*I)/0.0L) 17 | 18 | enum {FALSE, TRUE}; 19 | enum {NO, YES}; 20 | -------------------------------------------------------------------------------- /tsil-1.3/setTbar.c: -------------------------------------------------------------------------------- 1 | /* Evaluation of Tbar functions. */ 2 | 3 | #include "internal.h" 4 | 5 | /* ******************************************************************* */ 6 | 7 | void TSIL_SetTbar (TSIL_DATA *foo) 8 | { 9 | TSIL_REAL x, y, z, u, v, qq; 10 | TSIL_COMPLEX s; 11 | 12 | if (foo->whichFns == STUM) { 13 | x = foo->x; 14 | y = foo->y; 15 | z = foo->z; 16 | u = foo->u; 17 | v = foo->v; 18 | s = foo->s; 19 | qq = foo->qq; 20 | 21 | if (v < TSIL_TOL) { 22 | foo->T[vyz].value = TSIL_Infinity; 23 | foo->T[vxu].value = TSIL_Infinity; 24 | foo->Tbar[vyz].value = TSIL_Tbar0xy(y,z,s,qq); 25 | foo->Tbar[vxu].value = TSIL_Tbar0xy(x,u,s,qq); 26 | } 27 | else { 28 | foo->Tbar[vyz].value = 29 | (foo->T[vyz].value) + TSIL_LOG(v/qq)*TSIL_B(y,z,s,qq); 30 | foo->Tbar[vxu].value = 31 | (foo->T[vxu].value) + TSIL_LOG(v/qq)*TSIL_B(x,u,s,qq); 32 | } 33 | 34 | if (x < TSIL_TOL) { 35 | foo->T[xuv].value = TSIL_Infinity; 36 | foo->Tbar[xuv].value = TSIL_Tbar0xy(u,v,s,qq); 37 | } 38 | else { 39 | foo->Tbar[xuv].value = 40 | (foo->T[xuv].value) + TSIL_LOG(x/qq)*TSIL_B(u,v,s,qq); 41 | } 42 | 43 | if (y < TSIL_TOL) { 44 | foo->T[yzv].value = TSIL_Infinity; 45 | foo->Tbar[yzv].value = TSIL_Tbar0xy(z,v,s,qq); 46 | } 47 | else { 48 | foo->Tbar[yzv].value = 49 | (foo->T[yzv].value) + TSIL_LOG(y/qq)*TSIL_B(z,v,s,qq); 50 | } 51 | 52 | if (z < TSIL_TOL) { 53 | foo->T[zyv].value = TSIL_Infinity; 54 | foo->Tbar[zyv].value = TSIL_Tbar0xy(y,v,s,qq); 55 | } 56 | else { 57 | foo->Tbar[zyv].value = 58 | (foo->T[zyv].value) + TSIL_LOG(z/qq)*TSIL_B(y,v,s,qq); 59 | } 60 | 61 | if (u < TSIL_TOL) { 62 | foo->T[uxv].value = TSIL_Infinity; 63 | foo->Tbar[uxv].value = TSIL_Tbar0xy(x,v,s,qq); 64 | } 65 | else { 66 | foo->Tbar[uxv].value = 67 | (foo->T[uxv].value) + TSIL_LOG(u/qq)*TSIL_B(x,v,s,qq); 68 | } 69 | } 70 | else { 71 | 72 | x = foo->x; 73 | u = foo->u; 74 | v = foo->v; 75 | s = foo->s; 76 | qq = foo->qq; 77 | 78 | if (v < TSIL_TOL) { 79 | foo->T[vxu].value = TSIL_Infinity; 80 | foo->Tbar[vxu].value = TSIL_Tbar0xy(x,u,s,qq); 81 | } 82 | else { 83 | foo->Tbar[vxu].value = 84 | (foo->T[vxu].value) + TSIL_LOG(v/qq)*TSIL_B(x,u,s,qq); 85 | } 86 | 87 | if (x < TSIL_TOL) { 88 | foo->T[xuv].value = TSIL_Infinity; 89 | foo->Tbar[xuv].value = TSIL_Tbar0xy(u,v,s,qq); 90 | } 91 | else { 92 | foo->Tbar[xuv].value = 93 | (foo->T[xuv].value) + TSIL_LOG(x/qq)*TSIL_B(u,v,s,qq); 94 | } 95 | 96 | if (u < TSIL_TOL) { 97 | foo->T[uxv].value = TSIL_Infinity; 98 | foo->Tbar[uxv].value = TSIL_Tbar0xy(x,v,s,qq); 99 | } 100 | else { 101 | foo->Tbar[uxv].value = 102 | (foo->T[uxv].value) + TSIL_LOG(u/qq)*TSIL_B(x,v,s,qq); 103 | } 104 | } 105 | 106 | return; 107 | } 108 | -------------------------------------------------------------------------------- /tsil-1.3/special.c: -------------------------------------------------------------------------------- 1 | /* Analytic evaluations where possible. */ 2 | 3 | #include "internal.h" 4 | 5 | /* ******************************************************************* */ 6 | 7 | int TSIL_CaseSpecial (TSIL_DATA *foo) 8 | { 9 | TSIL_REAL x, y, z, u, v, s, qq; 10 | int success = 1; 11 | int tmpWarns; 12 | 13 | TSIL_Info("SPECIAL CASE"); 14 | 15 | /* For convenience */ 16 | x = foo->x; 17 | y = foo->y; 18 | z = foo->z; 19 | u = foo->u; 20 | v = foo->v; 21 | s = foo->s; 22 | qq = foo->qq; 23 | 24 | /* Temporarily disable WARNs */ 25 | tmpWarns = printWarns; 26 | printWarns = NO; 27 | 28 | if (foo->whichFns == STUM) { 29 | foo->B[xz].value = TSIL_B(x, z, s, qq); 30 | foo->B[yu].value = TSIL_B(y, u, s, qq); 31 | 32 | success *= TSIL_Sanalytic (y, z, v, s, qq, &(foo->S[vyz].value)); 33 | success *= TSIL_Sanalytic (u, x, v, s, qq, &(foo->S[uxv].value)); 34 | 35 | success *= TSIL_Tanalytic (v, y, z, s, qq, &(foo->T[vyz].value)); 36 | success *= TSIL_Tanalytic (v, x, u, s, qq, &(foo->T[vxu].value)); 37 | success *= TSIL_Tanalytic (x, u, v, s, qq, &(foo->T[xuv].value)); 38 | success *= TSIL_Tanalytic (y, z, v, s, qq, &(foo->T[yzv].value)); 39 | success *= TSIL_Tanalytic (z, y, v, s, qq, &(foo->T[zyv].value)); 40 | success *= TSIL_Tanalytic (u, x, v, s, qq, &(foo->T[uxv].value)); 41 | 42 | success *= TSIL_Uanalytic (z, x, y, v, s, qq, &(foo->U[zxyv].value)); 43 | success *= TSIL_Uanalytic (u, y, x, v, s, qq, &(foo->U[uyxv].value)); 44 | success *= TSIL_Uanalytic (x, z, u, v, s, qq, &(foo->U[xzuv].value)); 45 | success *= TSIL_Uanalytic (y, u, z, v, s, qq, &(foo->U[yuzv].value)); 46 | } 47 | else if (foo->whichFns == STU) { 48 | foo->B[xz].value = TSIL_B(x, z, s, qq); 49 | 50 | success *= TSIL_Sanalytic (u, x, v, s, qq, &(foo->S[uxv].value)); 51 | 52 | success *= TSIL_Tanalytic (v, x, u, s, qq, &(foo->T[vxu].value)); 53 | success *= TSIL_Tanalytic (x, u, v, s, qq, &(foo->T[xuv].value)); 54 | success *= TSIL_Tanalytic (u, x, v, s, qq, &(foo->T[uxv].value)); 55 | 56 | success *= TSIL_Uanalytic (x, z, u, v, s, qq, &(foo->U[xzuv].value)); 57 | } 58 | else { 59 | success *= TSIL_Sanalytic (u, x, v, s, qq, &(foo->S[uxv].value)); 60 | 61 | success *= TSIL_Tanalytic (v, x, u, s, qq, &(foo->T[vxu].value)); 62 | success *= TSIL_Tanalytic (x, u, v, s, qq, &(foo->T[xuv].value)); 63 | success *= TSIL_Tanalytic (u, x, v, s, qq, &(foo->T[uxv].value)); 64 | } 65 | 66 | /* Restore previous warnings setting: */ 67 | printWarns = tmpWarns; 68 | 69 | return success; 70 | } 71 | -------------------------------------------------------------------------------- /tsil-1.3/tsil_global.h: -------------------------------------------------------------------------------- 1 | /* Miscellaneous useful constants. Users who #include this file 2 | should be careful to insure that there are no name conflicts with 3 | their own variables or functions. */ 4 | 5 | #ifndef TSIL_GLOBAL_H 6 | #define TSIL_GLOBAL_H 7 | 8 | /* Status codes (status) */ 9 | enum {UNEVALUATED, ANALYTIC, REAXIS, CONTOUR}; 10 | 11 | /* Function codes (whichFns) */ 12 | enum {ALL, STUM=0, STU, ST}; 13 | 14 | /* Size codes */ 15 | enum {LONG_DOUBLE, DOUBLE}; 16 | 17 | /* Number of each type of function (could just be hardwired) */ 18 | #define NUM_U_FUNCS 4 19 | #define NUM_V_FUNCS 4 20 | #define NUM_T_FUNCS 6 21 | #define NUM_S_FUNCS 2 22 | #define NUM_B_FUNCS 2 23 | 24 | /* Enums for indexing */ 25 | enum {Bxz, Byu}; 26 | enum { xz, yu}; 27 | 28 | enum {Svyz, Suxv}; 29 | /* enum {Tvyz, Tyzv, Tzyv, Tuxv, Txuv, Tvxu}; */ 30 | /* enum { vyz, yzv, zyv, uxv, xuv, vxu}; */ 31 | 32 | /* Original: */ 33 | enum {Tvyz, Tuxv, Tyzv, Txuv, Tzyv, Tvxu}; 34 | enum { vyz, uxv, yzv, xuv, zyv, vxu}; 35 | 36 | 37 | enum {Uzxyv, Uuyxv, Uxzuv, Uyuzv}; 38 | enum {Vzxyv, Vuyxv, Vxzuv, Vyuzv}; 39 | enum { zxyv, uyxv, xzuv, yuzv}; 40 | 41 | #endif /* tsil_global.h */ 42 | -------------------------------------------------------------------------------- /tsil-1.3/tsil_names.h: -------------------------------------------------------------------------------- 1 | /* Names of the various functions, including equivalent permutations. */ 2 | 3 | #define NUM_U_PERMS 2 4 | #define NUM_T_PERMS 2 5 | #define NUM_S_PERMS 6 6 | #define NUM_B_PERMS 2 7 | #define NUM_V_PERMS 2 8 | 9 | const char *uname[4][2] = {{"Uzxyv","Uzxvy"}, 10 | {"Uuyxv","Uuyvx"}, 11 | {"Uxzuv","Uxzvu"}, 12 | {"Uyuzv","Uyuvz"}}; 13 | 14 | const char *tname[6][2] = {{"Tvyz","Tvzy"}, 15 | {"Tuxv","Tuvx"}, 16 | {"Tyzv","Tyvz"}, 17 | {"Txuv","Txvu"}, 18 | {"Tzyv","Tzvy"}, 19 | {"Tvxu","Tvux"}}; 20 | 21 | const char *sname[2][6] = {{"Svyz","Szvy","Syzv","Svzy","Syvz","Szyv"}, 22 | {"Suxv","Svux","Sxvu","Suvx","Sxuv","Svxu"}}; 23 | 24 | const char *bname[2][2] = {{"Bxz","Bzx"}, 25 | {"Byu","Buy"}}; 26 | 27 | const char *vname[4][2] = {{"Vzxyv","Vzxvy"}, 28 | {"Vuyxv","Vuyvx"}, 29 | {"Vxzuv","Vxzvu"}, 30 | {"Vyuzv","Vyuvz"}}; 31 | 32 | const char *tbarname[6][2] = {{"TBARvyz","TBARvzy"}, 33 | {"TBARuxv","TBARuvx"}, 34 | {"TBARyzv","TBARyvz"}, 35 | {"TBARxuv","TBARxvu"}, 36 | {"TBARzyv","TBARzvy"}, 37 | {"TBARvxu","TBARvux"}}; 38 | 39 | /* These are only used for display purposes and by the test program, 40 | so we really don't need permutations for them. */ 41 | const char *uuname[4][3] = {{"UUzxyv0", "UUzxyv1", "UUzxyv2"}, 42 | {"UUuyxv0", "UUuyxv1", "UUuyxv2"}, 43 | {"UUxzuv0", "UUxzuv1", "UUxzuv2"}, 44 | {"UUyuzv0", "UUyuzv1", "UUyuzv2"}}; 45 | const char *vvname[4][3] = {{"VVzxyv0", "VVzxyv1", "VVzxyv2"}, 46 | {"VVuyxv0", "VVuyxv1", "VVuyxv2"}, 47 | {"VVxzuv0", "VVxzuv1", "VVxzuv2"}, 48 | {"VVyuzv0", "VVyuzv1", "VVyuzv2"}}; 49 | const char *ttname[6][3] = {{"TTvyz0", "TTvyz1", "TTvyz2"}, 50 | {"TTuxv0", "TTuxv1", "TTuxv2"}, 51 | {"TTyzv0", "TTyzv1", "TTyzv2"}, 52 | {"TTxuv0", "TTxuv1", "TTxuv2"}, 53 | {"TTzyv0", "TTzyv1", "TTzyv2"}, 54 | {"TTvxu0", "TTvxu1", "TTvxu2"}}; 55 | const char *ssname[2][3] = {{"SSvyz0", "SSvyz1", "SSvyz2"}, 56 | {"SSuxv0", "SSuxv1", "SSuxv2"}}; 57 | 58 | /* But here they are in case we want them some day: */ 59 | /* const char *uuname0[4][2] = {{"UUzxyv0","UUzxvy0"}, */ 60 | /* {"UUuyxv0","UUuyvx0"}, */ 61 | /* {"UUxzuv0","UUxzvu0"}, */ 62 | /* {"UUyuzv0","UUyuvz0"}}; */ 63 | 64 | /* const char *uuname1[4][2] = {{"UUzxyv1","UUzxvy1"}, */ 65 | /* {"UUuyxv1","UUuyvx1"}, */ 66 | /* {"UUxzuv1","UUxzvu1"}, */ 67 | /* {"UUyuzv1","UUyuvz1"}}; */ 68 | 69 | /* const char *uuname2[4][2] = {{"UUzxyv2","UUzxvy2"}, */ 70 | /* {"UUuyxv2","UUuyvx2"}, */ 71 | /* {"UUxzuv2","UUxzvu2"}, */ 72 | /* {"UUyuzv2","UUyuvz2"}}; */ 73 | 74 | /* const char *vvname0[4][2] = {{"VVzxyv0","VVzxvy0"}, */ 75 | /* {"VVuyxv0","VVuyvx0"}, */ 76 | /* {"VVxzuv0","VVxzvu0"}, */ 77 | /* {"VVyuzv0","VVyuvz0"}}; */ 78 | 79 | /* const char *vvname1[4][2] = {{"VVzxyv1","VVzxvy1"}, */ 80 | /* {"VVuyxv1","VVuyvx1"}, */ 81 | /* {"VVxzuv1","VVxzvu1"}, */ 82 | /* {"VVyuzv1","VVyuvz1"}}; */ 83 | 84 | /* const char *vvname2[4][2] = {{"VVzxyv2","VVzxvy2"}, */ 85 | /* {"VVuyxv2","VVuyvx2"}, */ 86 | /* {"VVxzuv2","VVxzvu2"}, */ 87 | /* {"VVyuzv2","VVyuvz2"}}; */ 88 | 89 | /* const char *ttname0[6][2] = {{"TTvyz0","TTvzy0"}, */ 90 | /* {"TTuxv0","TTuvx0"}, */ 91 | /* {"TTyzv0","TTyvz0"}, */ 92 | /* {"TTxuv0","TTxvu0"}, */ 93 | /* {"TTzyv0","TTzvy0"}, */ 94 | /* {"TTvxu0","TTvux0"}}; */ 95 | 96 | /* const char *ttname1[6][2] = {{"TTvyz1","TTvzy1"}, */ 97 | /* {"TTuxv1","TTuvx1"}, */ 98 | /* {"TTyzv1","TTyvz1"}, */ 99 | /* {"TTxuv1","TTxvu1"}, */ 100 | /* {"TTzyv1","TTzvy1"}, */ 101 | /* {"TTvxu1","TTvux1"}}; */ 102 | 103 | /* const char *ttname2[6][2] = {{"TTvyz2","TTvzy2"}, */ 104 | /* {"TTuxv2","TTuvx2"}, */ 105 | /* {"TTyzv2","TTyvz2"}, */ 106 | /* {"TTxuv2","TTxvu2"}, */ 107 | /* {"TTzyv2","TTzvy2"}, */ 108 | /* {"TTvxu2","TTvux2"}}; */ 109 | 110 | /* const char *ssname0[2][6] = {{"SSvyz0","SSzvy0","SSyzv0","SSvzy0","SSyvz0","SSzyv0"}, */ 111 | /* {"SSuxv0","SSvux0","SSxvu0","SSuvx0","SSxuv0","SSvxu0"}}; */ 112 | 113 | /* const char *ssname1[2][6] = {{"SSvyz1","SSzvy1","SSyzv1","SSvzy1","SSyvz1","SSzyv1"}, */ 114 | /* {"SSuxv1","SSvux1","SSxvu1","SSuvx1","SSxuv1","SSvxu1"}}; */ 115 | 116 | /* const char *ssname2[2][6] = {{"SSvyz2","SSzvy2","SSyzv2","SSvzy2","SSyvz2","SSzyv2"}, */ 117 | /* {"SSuxv2","SSvux2","SSxvu2","SSuvx2","SSxuv2","SSvxu2"}}; */ 118 | -------------------------------------------------------------------------------- /tsil-1.3/tsil_params.h: -------------------------------------------------------------------------------- 1 | #ifndef TSIL_PARAMS_H 2 | #define TSIL_PARAMS_H 3 | 4 | /* This file contains parameters associated with the numerical 5 | integration in TSIL */ 6 | 7 | /* The macros TSIL_PRECISION_GOAL, TSIL_NSTEPS_START, 8 | TSIL_NSTEPS_MAX_CON, TSIL_NSTEPS_MAX_VAR, and TSIL_NSTEPS_MIN are 9 | used by TSIL_SetParameters to set the corresponding members of the 10 | data struct. To reset them at run time, use the function 11 | TSIL_ResetStepSizeParams after calling TSIL_SetParameters */ 12 | 13 | #define TSIL_PRECISION_GOAL 1e-12 14 | /* For each RK step, require that the estimated error for each 15 | dependent variable is less than TSIL_PRECISION_GOAL times the 16 | increment of that dependent variable for that step. Otherwise, the 17 | step size is reduced and the step is retried. This requirement is 18 | ignored if the step size gets too small, or if the estimated error 19 | is less than TSIL_EPSILON [DGR - TSIL_TOL?] times the absolute value of the dependent 20 | variable. If TSIL_PRECISION_GOAL is set to 0, the step sizes will 21 | be determined by TSIL_NSTEPS_MAX_CON and TSIL_NSTEPS_MAX_VAR below. 22 | If TSIL_PRECISION_GOAL is set to a large number, the step sizes 23 | will tend towards that given by TSIL_NSTEPS_MIN below. */ 24 | 25 | #define TSIL_NSTEPS_START 500 26 | /* For each leg of the contour of the RK integration, the initial step 27 | size is chosen so that there would be 500 total steps if the step 28 | size did not change. */ 29 | 30 | #define TSIL_NSTEPS_MAX_CON 10000 31 | #define TSIL_NSTEPS_MAX_VAR 10000 32 | #define TSIL_NSTEPS_MIN 100 33 | /* The minimum step size for a leg of the contour with dimensionless 34 | rescaled independent variable length L is given by: 35 | 36 | L/(N_STEPS_MAX_CON + L * N_STEPS_MAX_VAR). 37 | 38 | The maximum step size is L/NSTEPS_MIN. */ 39 | 40 | #define IM_DISPL 0.20L 41 | /* Contour displacement in Im(s) direction to avoid thresholds, in 42 | terms of dimensionless rescaled variable. */ 43 | 44 | #define THRESH_CUTOFF 0.025L 45 | /* Maximum distance considered "close" to a threshold, in terms of 46 | dimensionless rescaled variable. */ 47 | 48 | /* DGR modified from TSIL_EPSILON */ 49 | #define SINIT 10.0*TSIL_TOL 50 | /* Starting point for integration when s=0 is (or is near) a threshold. 51 | Should usually be about TSIL_EPSILON, except in very extreme cases. */ 52 | 53 | #define REDOANALYTIC YES 54 | /* If YES (NO), program does (does not) look for analytic subcases of 55 | B,S,T,U,V, when the master integral M cannot be done in terms of 56 | polylogarithms. Should be set to YES, except for testing 57 | purposes. */ 58 | 59 | #endif /* TSIL_PARAMS_H */ 60 | -------------------------------------------------------------------------------- /tsil-1.3/tsil_testparams.h: -------------------------------------------------------------------------------- 1 | /* Parameters used in test program: */ 2 | 3 | #ifndef TSIL_TESTPARAMS_H 4 | #define TSIL_TESTPARAMS_H 5 | 6 | /* NOTE: Generic cases should usually exceed these relative precisions 7 | with ease; these pass/warn/fail parameters are aimed to be 8 | "friendly" to the more difficult cases. Even so, you should expect 9 | to see some WARNs, and possibly FAILs, when running the test suite, 10 | depending on your platform. */ 11 | 12 | #if defined(TSIL_SIZE_DOUBLE) 13 | #define TSIL_PASS 3.e-8 14 | #define TSIL_WARN 3.e-4 15 | #define TSIL_PASS_V 3.e-5 /* The V functions have weaker requirements. */ 16 | #define TSIL_WARN_V 1.e-3 17 | 18 | #else /* then it must be LONG */ 19 | #define TSIL_PASS 1.e-9 20 | #define TSIL_WARN 1.e-6 21 | #define TSIL_PASS_V 1.e-6 /* The V functions have weaker requirements. */ 22 | #define TSIL_WARN_V 1.e-4 23 | 24 | #endif 25 | 26 | #endif /* tsil_testparams.h */ 27 | --------------------------------------------------------------------------------