********************************
Welcome to SMDR v1.01
********************************
Copyright (C) 2019 S.P. Martin and D.G. Robertson
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or (at
your option) any later version. See the file LICENSE.txt for further
details.
Contents of this file:
I. Overview
II. Building SMDR
III. Using SMDR
IV. The SMDR API
V. Sample Program
VI. C++ Linkage
*********************************************************************
I. Overview
*********************************************************************
SMDR (/S/tandard /M/odel in /D/imensional /R/egularization) is a library
of utilities for calculations involving the full Standard Model of
particle physics. It provides a complete mapping between the MSbar
lagrangian parameters and the observable quantities to which they most
closely correspond. SMDR also contains utilities for minimizing the
effective potential to determine the relation between the Higgs vacuum
expectation value and the Lagrangian mass squared parameter, for
renormalization group running of all parameters, and for matching onto
low energy effective theories with various heavy particles decoupled.
All computations are carried out at state-of-the-art precision. The code
is written in C, and may be linked from C or C++.
SMDR requires:
* the TSIL library of utilities for the numerical calculation of
dimensionally regularized 2-loop self-energy integrals [MR05]; and
* the 3VIL library for the evaluuation of 3-loop vacuum integrals
[MR16].
The latest versions of these are always included with the SMDR
distribution, so typically users shouldn't have to worry about them.
Authors:
S.P. Martin [spmartin AT niu.edu]
Department of Physics
Northern Illinois University
DeKalb, IL 60115
USA
D.G. Robertson [drobertson AT otterbein.edu]
Department of Physics
Otterbein University
Westerville, OH 43081
USA
To cite this program, please reference the paper (referred to in this
document as [MR19]):
[MR19] "Standard Model parameters in the tadpole-free pure MSbar scheme"
by S.P. Martin and D.G. Robertson,
[arXiv:1907.02500].
Other directly relevant papers are:
[SM17] "Effective potential at three loops" Stephen P. Martin,
Phys.Rev. D96 (2017) no.9, 096005 e-Print: arXiv:1709.02397
[hep-ph]
[MR16] "Evaluation of the general 3-loop vacuum Feynman integral",
by S.P. Martin and D.G. Robertson Phys. Rev. D95 (2017) no.1,
016008 [arXiv:1610.07720]
[SM16] "Top-quark pole mass in the tadpole-free MS-bar scheme"
Stephen P. Martin Phys.Rev. D93 (2016) no.9, 094017 e-Print:
arXiv:1604.01134 [hep-ph]
[SPM15a] "Pole mass of the W boson at two-Loop order in the pure
MS-bar scheme", by Stephen P. Martin, Phys.Rev. D91 (2015)
no.11, 114003 e-Print: arXiv:1503.03782 [hep-ph]
[SPM15b] "Z-boson pole mass at two-loop order in the pure MS-bar
scheme" Stephen P. Martin Phys.Rev. D92 (2015) no.1, 014026
e-Print: arXiv:1505.04833 [hep-ph]
[SPM15c] "Four-Loop Standard Model effective potential at leading
order in QCD" Stephen P. Martin Phys.Rev. D92 (2015) no.5,
054029 e-Print: arXiv:1508.00912 [hep-ph]
[MR14] "Higgs boson mass in the Standard Model at two-loop order and
beyond", by S.P. Martin and D.G. Robertson, Phys.Rev. D90
(2014) no.7, 073010 [arXiv:1407.4336].
[MR05] "TSIL: a program for the calculation of two-loop self-energy
integrals", by S.P. Martin and D.G. Robertson,
Comp. Phys. Comm. 174 (2006) 133, [hep-ph/0501132].
Also, the following papers contain results directly used in the
Standard Model effective potential minimization routines:
[FJJ92] "The Standard model effective potential at two loops," by
C. Ford, I. Jack and D.R.T. Jones, Nucl. Phys. B387, 373
(1992) [Erratum-ibid. B504, 551 (1997)], [hep-ph/0111190]
[SPM13] "Three-loop Standard Model effective potential at leading
order in strong and top Yukawa couplings," by S.P. Martin,
Phys. Rev. D 89, 013003 (2014), arXiv:1310.7553 [hep-ph].
[SPM14] "Taming the Goldstone contributions to the effective
potential," by S.P. Martin, arXiv:1406.2355 [hep-ph].
The multi-loop renormalization group running and decoupling routines
in SMDR use results listed in [MR19]. If your work relies on these,
you should cite the corresponding works.
SMDR is available from:
http://www.niu.edu/spmartin/SMDR
http://faculty.otterbein.edu/drobertson/SMDR
Version number: 1.01
*********************************************************************
II. Building SMDR
*********************************************************************
SMDR can be compiled on any system that supports the GNU Compiler
Collection (gcc), the Intel C compiler (icc), or a similar C compiler
with support for complex mathematics.
To compile SMDR, edit the Makefile in the main SMDR directory and
choose:
1. Compiler and optimization flags.
Several sets are pre-defined in the Makefile; simply uncomment the
appropriate one for your system, if present. SMDR is currently
known to compile with gcc (under Linux or Mac OS X). Other C
compilers should work provided that complex mathematics is
supported, but in this case you will need to explicitly set the
compiler name and optimization flags.
If you succeed in building SMDR on a new platform, the authors
would be grateful to know it, and to learn of any special measures
that were needed to compile it.
2. Install directories, if desired.
You can set INSTALL_INCS and INSTALL_LIBS to point to directories
where you would like to place the header files and libraries,
respectively, after compilation. If INSTALL_INCS and INSTALL_LIBS
are not set, then the libraries and header files will be left after
compilation in the main SMDR directory; they can then be moved by
hand to any appropriate place. Standard directories that are
automatically searched by compilers and linkers typically include
/usr/lib and /usr/include, but you will need root access to write
to these directories. If you specify other directories not on the
standard search path, note that when compiling your own code it
will be necessary to specify these directories using the options
-I
and -L. See the compiler/linker man pages for
complete details.
Users should not need to edit the Makefiles in any of the
subdirectories of the main SMDR installation (./src, ./applications,
and the TSIL and 3VIL directories).
Once these choices have been made, simply type
make
to build SMDR, along with a suite of associated sample programs.
Note that as a first step in the build process, make unpacks the
distributions of TSIL and 3VIL provided with SMDR, and compiles these.
It is strongly recommended that you use the very latest versions of
these packages, which will always be supplied automatically with SMDR.
After this compilation is complete, you can optionally type
make install
to install the library and header files in the specified locations.
Congratulations, SMDR is ready for action!
As a quick introduction to the capabilities of SMDR, we recommend
starting by trying the command line executables calc_all and calc_fit
in interactive mode. These can be run (with self-explanatory prompted
input by the user) by issuing the commands
./calc_all -int
and
./calc_fit -int
In addition to calc_all and calc_fit, there are other command-line
executables to illustrate renormalization group running and effective
potential minimization:
calc_RGrun
calc_m2
calc_vev
There are also executables that generate the data for all figures
appearing in [MR19]:
fig_GFermi_vs_Q
fig_MW_vs_Q
fig_MZ_vs_Q
fig_Mh_vs_Q
fig_Mt_vs_Q
fig_RGrun_QCDQED
fig_RGrun_vs_Q
fig_lambda_m2_vs_Q
fig_lambda_vs_Q
fig_m2_vs_Q
fig_vev_vs_Q
All of these programs make use of a data file, ReferenceModel.dat, which
contains a benchmark set of MSbar and on-shell parameters. The
programs will require that this file be present in the directory from
which they are run. Users can edit this file, but be aware that it
will be overwritten with benchmark_data/ReferenceModel.dat each time
that 'make' is run. Users wishing to make their own persistent version
of this file should give it a different name, and then use the '-i'
option to the various applications to read it instead of
ReferenceModel.dat.
These programs are described in detail below.
Besides the sample programs and data files, the end product intended
for the user interested in writing their own programs to make use of
SMDR consists of the files:
libsmdr.a The static SMDR archive (will be placed in
INSTALL_LIBS upon "make install")
smdr.h The SMDR header file; must be included in any
user code that uses SMDR (will be placed in
INSTALL_INCS upon "make install")
libtsil.a The static TSIL archive (will be placed in
INSTALL_LIBS upon "make install")
tsil.h The TSIL header file, will be included
automatically when using smdr.h (will be placed
in INSTALL_INCS upon "make install")
lib3vil.a The static 3VIL archive (will be placed in
INSTALL_LIBS upon "make install")
3vil.h The 3vil header file, will be included
automatically when including smdr.h (will be
placed in INSTALL_INCS upon "make install")
*********************************************************************
III. Using SMDR
*********************************************************************
In SMDR, all dimensionful quantities are given in GeV.
To use SMDR functions in your code, you must:
1. Include the header file smdr.h in any source file that makes use
of SMDR functions, e.g., by adding the line
#include "smdr.h"
This is appropriate if the file smdr.h is located in the directory
where the code is being compiled; if it has been placed in a
standard location such as /usr/include, then
#include
would work. If it is a nonstandard directory , the
compiler option
-I
will generally be necessary. See the compiler man pages on your
system for further details.
Note that smdr.h itself #includes tsil.h and 3vil.h, so there is no
need to do this separately.
#including smdr.h will define for you a set of global variables
that represent the couplings of the Standard Model. These variable
names are prefixed by SMDR_ so that they should not collide with
other objects in users' code. These are:
SMDR_Q; MSbar renormalization scale
SMDR_g3; SU(3) gauge coupling
SMDR_gp; U(1)_Y gauge coupling
SMDR_g; SU(2) gauge coupling
SMDR_yt; Top Yukawa coupling
SMDR_yb; Bottom Yukawa coupling
SMDR_yc; Charm Yukawa coupling
SMDR_ys; Strange Yukawa coupling
SMDR_yu; Up Yukawa coupling
SMDR_yd; Down Yukawa coupling
SMDR_ytau; Tau Yukawa coupling
SMDR_ymu; Muon Yukawa coupling
SMDR_ye; Electron Yukawa coupling
SMDR_lambda; Higgs self coupling
SMDR_m2; Higgs lagrangian mass^2 parameter
SMDR_v; Higgs VEV
SMDR_Lambda; Field-independent vacuum energy
SMDR_Delta_alpha_had_5_MZ; Non-perturbative hadronic
contribution to alpha
All of these are real parameters of type SMDR_REAL. Typical tasks
will use most of these parameters as inputs. Users may set their
values freely, and SMDR functions use them in their computations.
Input values of Q and the MSbar lagrangian parameters are stored in
global "input variables" SMDR_*_in, where * can be Q, g3, g, gp,
yt, yb, yc, ys, yu, yd, ytau, ymu, ye, lambda, or v. These can be
changed by the user, but typically they stay fixed while various
calculations are performed using the "working variables"
SMDR_*. After setting input variables, e.g., by reading input
file(s), users can call
SMDR_Load_Inputs ();
to copy the input variables into working variables.
In addition, global parameters are defined that represent couplings
in various effective theories with heavy particles decoupled. For
example, the parameters in the 5-quark, 3-lepton effective theory
obtained by integrating out the top quark and W, Z bosons, include:
SMDR_alphaS_53 MSbar QCD coupling
SMDR_alpha_53 MSbar EM coupling
SMDR_mb_53 MSbar bottom quark mass
etc. See smdr.h for a full listing.
There are also global variables representing on-shell observable
output quantities. These include, notably:
SMDR_GFermi;
SMDR_alpha; Sommerfeld fine structure constant
SMDR_alphaS_5_MZ; QCD coupling, t,h,Z,W all decoupled
SMDR_Mt_pole;
SMDR_Mh_pole;
SMDR_MZ_pole;
SMDR_MZ_BreitWigner;
SMDR_MW_pole;
SMDR_MW_BreitWigner;
SMDR_mbmb;
SMDR_mcmc;
SMDR_ms_2GeV;
SMDR_mu_2GeV;
SMDR_md_2GeV;
SMDR_Mtau_pole;
SMDR_Mmuon_pole;
SMDR_Melectron_pole;
Again, see smdr.h for a full listing.
Finally, there are constant experimental reference values taken from the
Particle Data Group, and associated uncertainties. These are also
all of type SMDR_REAL:
SMDR_GFermi_EXPT;
SMDR_GFermi_EXPT_UNC;
SMDR_alpha_EXPT; /* Fine structure constant*/
SMDR_alpha_EXPT_UNC;
SMDR_s2W_MZ_EXPT; /* MSbar at Q=MZ, top decoupled */
SMDR_s2W_MZ_EXPT_UNC;
SMDR_alphaS_MZ_EXPT; /* MSbar at Q=MZ, top decoupled */
SMDR_alphaS_MZ_EXPT_UNC;
SMDR_alpha_MZ_EXPT; /* MSbar at Q=MZ, top decoupled */
SMDR_alpha_MZ_EXPT_UNC;
SMDR_Delta_alpha_had_5_MZ_EXPT;
SMDR_Delta_alpha_had_5_MZ_EXPT_UNC;
SMDR_Mt_EXPT; /* Pole mass, has renormalon ambiguity */
SMDR_Mt_EXPT_UNC;
SMDR_Mh_EXPT;
SMDR_Mh_EXPT_UNC;
SMDR_MZ_EXPT; /* Experimental Breit-Wigner mass */
SMDR_MZ_EXPT_UNC;
SMDR_MW_EXPT; /* Experimental Breit-Wigner mass */
SMDR_MW_EXPT_UNC;
SMDR_mbmb_EXPT; /* MSbar mass evaluated at itself. */
SMDR_mbmb_EXPT_UNC_hi;
SMDR_mbmb_EXPT_UNC_lo;
SMDR_mcmc_EXPT; /* MSbar mass evaluated at itself. */
SMDR_mcmc_EXPT_UNC_hi;
SMDR_mcmc_EXPT_UNC_lo;
SMDR_ms_2GeV_EXPT; /* MSbar mass at Q = 2 GeV */
SMDR_ms_2GeV_EXPT_UNC_hi;
SMDR_ms_2GeV_EXPT_UNC_lo;
SMDR_mu_2GeV_EXPT; /* MSbar mass at Q = 2 GeV */
SMDR_mu_2GeV_EXPT_UNC_hi;
SMDR_mu_2GeV_EXPT_UNC_lo;
SMDR_md_2GeV_EXPT; /* MSbar mass at Q = 2 GeV */
SMDR_md_2GeV_EXPT_UNC_hi;
SMDR_md_2GeV_EXPT_UNC_lo;
SMDR_Mtau_EXPT; /* Pole mass */
SMDR_Mtau_EXPT_UNC;
SMDR_Mmuon_EXPT; /* Pole mass */
SMDR_Mmuon_EXPT_UNC;
SMDR_Melectron_EXPT; /* Pole mass */
SMDR_Melectron_EXPT_UNC;
At present these are set to values from the 2019 update to the
2018 Review of Particle Proerties. Their values can be changed at run
time, or updated in the file
smdr_pdg.h.
2. Link to the SMDR, 3VIL, TSIL, and C math libraries at the end of
the compilation process. This is accomplished via the (linker) flag
-lsmdr -l3vil -ltsil -lm
in that order. (See examples in the SMDR Makefile.) If the
libraries are not in a standard location (including the case where
they are in the current directory), you will generally need to add
the flag
-L
where is the directory in which libtsil.a may be found.
If this is the current directory, then
-L.
may be used. Again, consult the compiler man pages for complete
details on making user libraries available to the linker.
Complete details regarding the SMDR functions are given in section IV
of this document. In the rest of this section we will describe the
operation of the programs provided with the distribution. These can
also serve as potentially useful examples of using SMDR.
There are 5 programs that implement basic SMDR computations, and 11
others that generate the data plotted in the figures of [MR19].
----------------------------------
calc_all (Source file: calc_all.c)
----------------------------------
This program calculates and prints:
1) The pole masses of the Higgs boson, W and Z bosons, and the top
quark, using the state-of-the-art approximations for each. This
means full 2-loop plus leading 3-loop order for the Higgs, full
2-loop for W and Z, and 4-loop pure QCD plus full 2-loop for the
top quark. Also given for the W and Z bosons are the
Breit-Wigner masses as usually quoted by experimentalists:
MW_BreitWigner = sqrt(MW^2 + GammaW^2) and
MZ_BreitWigner = sqrt(MZ^2 + GammaZ^2).
2) The MSbar quantities alpha_S(Q), alpha(Q), and sin^2_W(Q) at Q =
MZ, in the full Standard Model with nothing decoupled.
3) The MSbar quantities alpha_S(Q), alpha(Q), and sin^2_W(Q), at Q =
MZ, in the PDG scheme where the top-quark is decoupled but the W
boson is active.
4) The MSbar quantities alpha_S, alpha, m_b, m_c, m_s, m_d, m_u,
m_tau, m_muon, and m_electron, at the renormalization scale
Q=M_Z, in the 5-quark + 3-lepton QCD+QED effective theory.
5) The MSbar heavy quark masses m_b(m_b) in the 5-quark, 3-lepton
theory and m_c(m_c) in the 4-quark, 2-lepton theory.
6) The MSbar light quark masses m_s, m_d, m_u at Q = 2 GeV, in the
4-quark, 3-lepton theory.
7) The charged lepton pole masses M_tau, M_muon, and M_electron.
8) The Sommerfeld fine structure constant alpha.
9) The Fermi constant GFermi.
The inputs are the MSbar quantities in the non-decoupled Standard
Model consisting of the gauge couplings g_3, g, g', the Higgs
self-coupling lambda, the quark and lepton Yukawa couplings y_t, y_b,
y_c, y_s, y_d, y_u, y_tau, y_mu, y_e, the Higgs vacuum expectation
value v (defined to be the minimum of the effective potential in
Landau gauge), and the non-perturbative light quark contribution to
the fine-structure contant, Delta_hadronic^(5) alpha(MZ).
Input values are read from the file ReferenceModel.dat which should be
found in the current directory, unless a different file is specified
using the -i option; see below. These inputs can then be modified if
the -int (interactive mode) option is specified.
Dimensionful quantities are in GeV. Timing information for the
computation is also printed.
This program takes four optional command line arguments:
-V Also finds Lambda and m2 from requiring the
effective potential to be minimized with
VEV v, and prints them. This doesn't affect
the observables, and is much slower because
many three-loop integrals have to be
computed.
-i Reads model data from ; if
not specified, data are read from the file
ReferenceModel.dat.
-o Writes complete model data to
; if not specified, no
output file is written and only the
standard output mentioned above appears. If
this flag is used, then -V is automatically
also considered to be set. The output file
is in a format that can be read into other
programs (such as calc_fit or calc_RGrun)
using SMDR_Read_Values ().
-int Runs the program in interactive mode. For
each input parameter, the user is prompted
to either accept the default value, or
enter a new value. The default values are
either the ones from the input file
specified by the -i flag, or else the ones
found in ReferenceModel.dat.
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o calc_all calc_all.c -L. -lsmdr -l3vil -ltsil -lm
assuming the necessary archive files libsmdr.a and libtsil.a and
lib3vil.a and the header files smdr.h and 3vil.h and tsil.h are all in
the current directory.
Run as, for example:
./calc_all
or
./calc_all -i SampleModel.dat -V
or
./calc_all -i SampleModel.dat -o SampleOut.dat
or
./calc_all -i SampleModel.dat -int -o SampleOut.dat
----------------------------------
calc_fit (Source file: calc_fit.c)
----------------------------------
This program calculates all of the MSbar quantities of the Standard
Model, using as inputs:
1) The real part of the top-quark pole mass.
2) The real part of the Higgs boson pole masses.
3) The real part of the Z boson Breit-Wigner mass.
4) The strong coupling constant alpha_S in the 5-quark theory at
Q=MZ.
5) The Sommerfeld fine structure constant alpha = 1/137.0...
6) The non-perturbative light quark contribution to the
fine-structure contant, Delta_hadronic^(5) alpha(MZ).
7) The Fermi constant G_Fermi.
8) The MSbar bottom quark mass evaluated at itself, mb(mb), in
the 5-quark, 3-lepton QCD+QED effective theory.
9) The MSbar charm quark mass evaluated at itself, mc(mc), in the
4-quark, 2-lepton QCD+QED effective theory.
10, 11, 12) The MSbar strange, down, and up masses, evaluated at
Q=2 GeV, in the 4-quark, 3-lepton QCD+QED effective theory.
13, 14, 15) The tau, muon, and electron pole masses.
These input values are read from the file "ReferenceModel.dat", unless
a different file is specified using the argument -i; see below. These
inputs can then be modified if the -int (interactive mode) option is
specified.
Regardless of the choice of input file, the MSbar quantities in
"ReferenceModel.dat" are always used as the initial guesses, but are
otherwise not relevant to calc_fit.
The program computes (by iteration) and then prints the MSbar
quantities in the non-decoupled Standard Model consisting of: the
gauge couplings g_3, g, g', the Higgs self-coupling lambda, the quark
and lepton Yukawa couplings y_t, y_b, y_c, y_s, y_d, y_u, y_tau, y_mu,
y_e, and the Higgs vacuum expectation value v (defined to be the
minimum of the full effective potential in Landau gauge), as well as
the Higgs squared mass parameter m2 (which is negative) and the value
of the field-independent vacuum energy Lambda, determined by requiring
the total loop-corrected vacuum energy to vanish. It also computes and
prints the resulting W boson mass.
Dimensionful quantities are in GeV. Timing information for the
computation is also printed.
This program takes five optional command line arguments:
-i Reads model data from ; if
not specified, data are read from the file
ReferenceModel.dat.
-o Writes complete model data to
; if not specified, the
MSbar quantities appear on stdout but no
output file is written. The output file is
in a format that can be read into other
programs (such as calc_all or calc_RGrun)
using SMDR_Read_Values ().
-e Specifies error tolerance; if not specified,
a default value of 1.0e-7 is used.
-Q The renormalization scale at which the MSbar
parameters should be determined; if not
specified, Q_target will be the top-quark
pole mass.
-int Runs the program in interactive mode. For
each input parameter, the user is prompted
to either accept the default value, or enter
a new value. The default values are either
the ones from the input file specified by
the -i flag, or else the ones found in
ReferenceModel.dat.
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o calc_fit calc_fit.c -L. -lsmdr -l3vil -ltsil -lm
assuming the necessary archive files libsmdr.a and lib3vil.a and
libtsil.a and the header files smdr.h and 3vil.h and tsil.h are all in
the current directory.
Run as, for example:
./calc_fit
for default choices with input ReferenceModel.dat, or
./calc_fit -i SampleModelOS.dat -o SampleOutput.dat -e 1.0e-9 -Q 160
or
./calc_fit -int -o SampleOutput.dat -e 1.0e-9 -Q 160
When running, it is important that the file ReferenceModel.dat (or the
input model file, if it is different) can be found in the current directory.
----------------------------------
calc_vev (Source file: calc_vev.c)
----------------------------------
This program calculates the Higgs VEV, obtained by minimizing the
Landau gauge effective potential with resummed Goldston boson
contributions, using, by default, the full 3-loop results of
arXiv:1709.02397 plus the 4-loop QCD contribution from 1508.00912. It
takes one optional command-line inputs:
-l
The allowed values for loopOrder are:
0 [tree-level]
1 [1-loop]
2 [2-loop, from 1406.2355 eq. (4.20), or SMDeltas.anc of
1709.02397]
2.5 [adds the leading 3-loop contributions from 1406.2355
eq. (4.21)]
3 [full 3-loop, from ancillary file SMDeltas.anc of 1709.02397]
3.5.[full 3-loop plus the 4-loop contribution at leading order in
QCD, from 1508.00912 equation (5.5)]
If -l is omitted, it is taken to be 3.5 by default.
The program then prompts the user for the quantities:
Q, m2, lambda, g3, g, gp, yt, yb, ytau
with default values taken from the file ReferenceModel.dat, which
should be in the current directory. It then calculates and prints the
full set of MSbar quantities including the value of the VEV v.
Dimensionful quantities are in appropriate powers of GeV. Timing
information for the computation is also printed.
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o calc_vev calc_vev.c -L. -lsmdr -ltsil -l3vil -lm
assuming the necessary archive files libsmdr.a and lib3vil.a and
libtsil.a and the header files smdr.h and 3vil.h and tsil.h are all in
the current directory.
Run as, for example:
./calc_vev
or
./calc_vev -l 2
for the result including only the 2-loop contributions.
--------------------------------
calc_m2 (Source file: calc_m2.c)
--------------------------------
This program calculates the negative Higgs lagrangian squared mass
parameter m2, obtained by minimizing the Landau gauge effective
potential with resummed Goldston boson contributions, using, by
default, the full 3-loop results of arXiv:1709.02397 plus the leading
order in QCD at 4-loop order from 1508.00912. It takes one optional
command-line input:
-l
The values for loopOrder are:
0 [tree-level]
1 [1-loop]
2 [2-loop, from 1406.2355 eq. (4.20), or SMDeltas.anc of
1709.02397]
2.5 [adds the leading 3-loop contributions from 1406.2355
eq. (4.21)]
3 [full 3-loop, from ancillary file SMDeltas.anc of 1709.02397]
3.5 [full 3-loop plus the 4-loop contribution at leading order in
QCD, from 1508.00912 equation (5.5)]
If -l loopOrder is omitted, it is taken to be 3.5 by
default.
The program then prompts the user for the quantities:
Q, v, lambda, g3, g, gp, yt, yb, ytau
with default values taken from the file ReferenceModel.dat, which
should be in the current directory. It then calculates and prints the
full set of MSbar quantities including the value of m2.
Dimensionful quantities are in appropriate powers of GeV. Timing
information for the computation is also printed.
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o calc_m2 calc_m2.c -L. -lsmdr -ltsil -l3vil -lm
assuming the necessary archive files libsmdr.a and lib3vil.a and
libtsil.a and the header files smdr.h and 3vil.h and tsil.h are all in
the current directory.
Run as, for example:
./calc_m2
for the result with all known contributions, or
./calc_m2 -l 2
for the result including only the 2-loop contributions.
--------------------------------------
calc_RGrun (Source file: calc_RGrun.c)
--------------------------------------
This program implements renormalization group running of the Standard
Model MSbar parameters from one specified scale to another. It takes
one required argument Qfinal and up to three optional arguments:
Q_final This required command line argument is the
destination RG scale for the running.
-i Reads model data from ; if not
specified, data are read from the file
ReferenceModel.dat, which should be in the
current directory.
-int Runs the program in interactive mode. For each
input parameter, the user is prompted to
either accept the default value, or enter a
new value. The default values are either the
ones from the input file specified by the -i
flag, or else the ones found in
ReferenceModel.dat.
-l Runs the RG equations at the specified loop
order. Allowed values for loopOrder are
1,2,3,4,5. If not specified, by default
loopOrder = 5.
As output, the program prints the values of the MSbar quantities at
the scales Q = Q_in and Q_final. General and timing information for
the computation are also printed.
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o calc_RGrun calc_RGrun.c -L. -lsmdr -ltsil -lm
assuming the necessary archive files libsmdr.a and lib3vil.a and
libtsil.a and the header files smdr.h and 3vil.h and tsil.h are all in
the current directory.
Run as, for example:
./calc_RGrun 2.4e18
for full 5-loop running and input data in ReferenceModel.dat, or
./calc_RGrun 2.4e18 -l 2 -i myInFile -int
for 2-loop running and model data in myInFile, or
./calc_RGrun 2.4e18 -i myInFile -int
for prompts that allow interactive modification of the initial
parameter values.
----------------------------------------
fig_Mh_vs_Q (Source file: fig_Mh_vs_Q.c)
----------------------------------------
Calculates the Higgs pole mass as a function of the MSbar
renormalization scale Q at which it is computed, in various
approximations, using the results in 1407.4336. The input parameters
are obtained from the file "ReferenceModel.dat" unless a different
file is specified using the "-i" option; see below.
This program produces by default an output file: "FIG_Mh_vs_Q.dat"
with data in 7 columns, respectively
1 Q (MSbar renormalization scale)
2 Mh (loopOrder = 0, tree-level)
3 Mh (loopOrder = 1, 1-loop)
4 Mh (loopOrder = 1.5, 1-loop plus 2-loop QCD)
5 Mh (loopOrder = 2, full 2-loop)
6 Mh (loopOrder = 2.3, includes 3-loop QCD)
7 Mh (loopOrder = 2.5, includes 3-loop QCD and yt corrections)
In the paper: arXiv:1907.02500
Standard Model parameters in the tadpole-free pure MSbar scheme
by Stephen P. Martin and David G. Robertson,
Figure 4.1a graphs columns 3, 4, 5, and 7 as a function of column 1.
The program takes two optional command line arguments:
-i Reads model data from ; if
not specified, data are read from the file
ReferenceModel.dat.
-o Writes output data to ; if
not specified, the results appear in
"FIG_Mh_vs_Q.dat".
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o fig_Mh_vs_Q fig_Mh_vs_Q.c -L. -lsmdr -ltsil -lm
assuming the necessary archive files libsmdr.a and libtsil.a and the
header files smdr.h and tsil.h are all in the current directory.
Run as:
./fig_Mh_vs_Q
Running time is typically of order 4 minutes, depending on your
hardware, so you might want to run it in the background.
------------------------------------------------------
fig_lambda_m2_vs_Q (Source file: fig_lambda_m2_vs_Q.c)
------------------------------------------------------
Finds the Standard Model MSbar Higgs parameters lambda and m^2 at
their best fit to current experimental observables, and also the
envelope of values that lambda and m^2 take as the observables are
varied within 1 sigma and 2 sigma of their central values, as a
function of the renormalization scale from Q = MZ to Q = 10^19 GeV.
The current experimental values are all taken from the file
"smdr_pdg.h".
Output data are given by default in the file
"FIG_lambda_m2_highQ.dat", in 12 columns:
1 Q
2 Log[10,Q]
3 lambda (lower bound for observables within 2 sigma)
4 lambda (lower bound for observables within 1 sigma)
5 lambda (central value)
6 lambda (upper bound for observables within 1 sigma)
7 lambda (upper bound for observables within 2 sigma)
8 sqrt(-m2) (lower bound for observables within 2 sigma)
9 sqrt(-m2) (lower bound for observables within 1 sigma)
10 sqrt(-m2) (central value)
11 sqrt(-m2) (upper bound for observables within 1 sigma)
12 sqrt(-m2) (upper bound for observables within 2 sigma)
In the paper: arXiv:1907.02500
Standard Model parameters in the tadpole-free pure MSbar scheme
by Stephen P. Martin and David G. Robertson,
Figure 4.3a graphs columns 3, 4, 5, 6, and 7 as a function of column 2.
Figure 4.3b graphs columns 8, 9, 10, 11, and 12 as a function of
column 2.
The program takes an optional command line argument:
-o Writes output data to ; if
not specified, the results appear in
"FIG_lambda_m2_highQ.dat".
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o fig_lambda_m2_vs_Q fig_lambda_m2_vs_Q.c -L. -lsmdr -ltsil -l3vil -lm
assuming the necessary archive files libsmdr.a and libtsil.a and
lib3vil.a and the header files smdr.h and 3vil.h and tsil.h are all in
the current directory.
Run as:
./fig_lambda_m2_vs_Q
Running in the background is highly recommended, because the running
time can be of order an hour, depending on your hardware.
----------------------------------------
fig_MW_vs_Q (Source file: fig_MW_vs_Q.c)
----------------------------------------
Calculates the physical mass of the W boson as a function of the MSbar
renormalization scale Q at which it is computed, in various
approximations, using the results in 1503.03782. The input parameters
are obtained from the file "ReferenceModel.dat" unless a different
file is specified using the "-i" option; see below.
This program produces by default an output file "FIG_MW_vs_Q.dat",
with data in 14 columns:
1 Q (MSbar renormalization scale)
2 MW_pole (loopOrder = 0, tree-level)
3 MW_pole (loopOrder = 1, 1-loop)
4 MW_BreitWigner (loopOrder = 1, 1-loop)
5 GammaW_pole (loopOrder = 1, 1-loop)
6 GammaW_BreitWigner (loopOrder = 1, 1-loop)
7 MW_pole (loopOrder = 1.5, 1-loop plus 2-loop QCD)
8 MW_BreitWigner (loopOrder = 1.5, 1-loop plus 2-loop QCD)
9 GammaW_pole (loopOrder = 1.5, 1-loop plus 2-loop QCD)
10 GammaW_BreitWigner (loopOrder = 1.5, 1-loop plus 2-loop QCD)
11 MW_pole (loopOrder = 2, full 2-loop)
12 MW_BreitWigner (loopOrder = 2, full 2-loop)
13 GammaW_pole (loopOrder = 2, full 2-loop)
14 GammaW_BreitWigner (loopOrder = 2, full 2-loop)
where the complex pole squared mass is:
s_pole = MW_pole^2 - i GammaW MW.
Note that the Breit-Wigner mass reported by experimentalists is
related by
MW_BreitWigner^2 = MW_pole^2 + GammaW^2
so that MW_BreitWigner is approximately 27 MeV larger than MW.
In the paper: arXiv:1907.02500
Standard Model parameters in the tadpole-free pure MSbar scheme
by Stephen P. Martin and David G. Robertson,
Figure 4.1d graphs columns 4, 8, and 12 as a function of column 1.
The program takes two optional command line arguments:
-i Reads model data from ; if
not specified, data are read from the file
ReferenceModel.dat.
-o Writes output data to ; if
not specified, the results appear in
"FIG_MW_vs_Q.dat".
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o fig_MW_vs_Q fig_MW_vs_Q.c -L. -lsmdr -ltsil -lm
assuming the necessary archive files libsmdr.a and libtsil.a and the
header files smdr.h and tsil.h are all in the current directory.
Run as:
./fig_MW_vs_Q
The running time is typically of order 20 seconds, depending on your
hardware.
----------------------------------------
fig_MZ_vs_Q (Source file: fig_MZ_vs_Q.c)
----------------------------------------
Calculates the physical mass of the Z boson as a function of the MSbar
renormalization scale Q at which it is computed, in various
approximations, using the results in 1505.04833. The input parameters
are obtained from the file "ReferenceModel.dat" unless a different
file is specified using the "-i" option; see below.
This program produces by default the output file "FIG_MZ_vs_Q.dat",
with data in 14 columns:
1 Q (MSbar renormalization scale)
2 MZ_pole (loopOrder = 0, tree-level)
3 MZ_pole (loopOrder = 1, 1-loop)
4 MZ_BreitWigner (loopOrder = 1, 1-loop)
5 GammaZ_pole (loopOrder = 1, 1-loop)
6 GammaZ_BreitWigner (loopOrder = 1, 1-loop)
7 MZ_pole (loopOrder = 1.5, 1-loop plus 2-loop QCD)
8 MZ_BreitWigner (loopOrder = 1.5, 1-loop plus 2-loop QCD)
9 GammaZ_pole (loopOrder = 1.5, 1-loop plus 2-loop QCD)
10 GammaZ_BreitWigner (loopOrder = 1.5, 1-loop plus 2-loop QCD)
11 MZ_pole (loopOrder = 2, full 2-loop)
12 MZ_BreitWigner (loopOrder = 2, full 2-loop)
13 GammaZ_pole (loopOrder = 2, full 2-loop)
14 GammaZ_BreitWigner (loopOrder = 2, full 2-loop)
where the complex pole squared mass is denoted:
s_pole = MZ_pole^2 - i GammaZ_pole MZ_pole.
Note that the Breit-Wigner mass reported by experimentalists is
related by
MZ_BreitWigner^2 = MZ_pole^2 + GammaZ_pole^2
so that MZ_BreitWigner is approximately 34 MeV larger than MZ.
In the paper: arXiv:1907.02500
Standard Model parameters in the tadpole-free pure MSbar scheme
by Stephen P. Martin and David G. Robertson,
Figure 4.1c graphs columns 4, 8, and 12 as a function of column 1.
The program takes two optional command line arguments:
-i Reads model data from ; if
not specified, data are read from the file
ReferenceModel.dat.
-o Writes output data to ; if
not specified, the results appear in
"FIG_MZ_vs_Q.dat".
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o fig_MZ_vs_Q fig_MZ_vs_Q.c -L. -lsmdr -ltsil -lm
assuming the necessary archive files libsmdr.a and libtsil.a and the
header files smdr.h and tsil.h are all in the current directory.
Run as:
./fig_MZ_vs_Q
The running time is typically of order 15 seconds, depending on your
hardware.
----------------------------------------
fig_Mt_vs_Q (Source file: fig_Mt_vs_Q.c)
----------------------------------------
Calculates the top-quark pole mass as a function of the MSbar
renormalization scale Q at which it is computed, in various
approximations, using the results of 1604.01134 and references
therein. The input parameters are obtained from the file
"ReferenceModel.dat" unless a different file is specified using the
"-i" option; see below. This program produces output data in 12
columns:
1 Q
2 Mt tree
3 Mt 1-loop QCD
4 Mt 2-loop QCD
5 Mt 3-loop QCD
6 Mt 4-loop QCD
7 Mt 4-loop QCD + 1-loop nonQCD
8 Gammat 4-loop QCD + 1-loop nonQCD
9 Mt 4-loop QCD + 1-loop nonQCD + 2-loop mixed
10 Gammat 4-loop QCD + 1-loop nonQCD + 2-loop mixed
11 Mt 4-loop QCD + 1-loop nonQCD + 2-loop full
12 Gammat 4-loop QCD + 1-loop nonQCD + 2-loop full
Two output files are produced: "FIG_Mt_vs_Q_0.dat" and
"FIG_Mt_vs_Q_1.dat", using expansions around the tree-level and real
pole masses, respectively.
In the paper: arXiv:1907.02500
Standard Model parameters in the tadpole-free pure MSbar scheme
by Stephen P. Martin and David G. Robertson,
Figure 4.1b graphs columns 6, 7, 9, and 11 as a
function of column 1 from FIG_Mt_vs_Q_1.dat.
The program takes an optional command line argument:
-i Reads model data from ; if
not specified, data are read from the file
"ReferenceModel.dat".
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o fig_Mt_vs_Q fig_Mt_vs_Q.c -L. -lsmdr -ltsil -lm
assuming the necessary archive files libsmdr.a and libtsil.a and the
header files smdr.h and tsil.h are all in the current directory.
Run as:
./fig_Mt_vs_Q
The running time is typically of order 6 minutes, depending on your
hardware, so you might want to run it in the background.
------------------------------------------------
fig_GFermi_vs_Q (Source file: fig_GFermi_vs_Q.c)
------------------------------------------------
Calculates GFermi as a function of the MSbar renormalization scale Q
at which it is computed, in various approximations. The input
parameters are obtained from the file "ReferenceModel.dat". This
program produces by default an output file "FIG_GFermi_vs_Q.dat", with
data in 11 columns, respectively
1 Q (MSbar renormalization scale)
2 GFermi 10^5 (loopOrder = 0, tree-level)
3 GFermi 10^5 (loopOrder = 1, 1-loop)
4 GFermi 10^5 (loopOrder = 1.5, 1-loop plus 2-loop LO in QCD)
5 GFermi 10^5 (loopOrder = 2, full 2-loop)
6, 7, 8, 9 = same, but divided by GFermi(experiment)
In the paper: arXiv:1907.02500
Standard Model parameters in the tadpole-free pure MSbar scheme
by Stephen P. Martin and David G. Robertson,
Figure 3.3 graphs columns 3, 4, and 5 as a function of column 1.
This program takes two optional command line arguments:
-i Reads model data from ; if
not specified, data are read from the file
ReferenceModel.dat.
-o Writes output data to ; if
not specified, the results appear in
"FIG_GFermi_vs_Q.dat".
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o fig_GFermi_vs_Q fig_GFermi_vs_Q.c -L. -lsmdr -ltsil -lm
assuming the necessary archive files libsmdr.a and libtsil.a and the
header files smdr.h and tsil.h are all in the current directory.
Run as:
./fig_GFermi_vs_Q
------------------------------------------------
fig_lambda_vs_Q (Source file: fig_lambda_vs_Q.c)
------------------------------------------------
Calculates the Higgs self coupling lambda as a function of the MSbar
renormalization scale Q. The inputs are the experimental Higgs pole
mass SMDR_Mh_EXPT from smdr_pdg.h and the other MSbar input parameters
obtained from the file "ReferenceModel.dat" unless a different file is
specified using the "-i" option; see below. This program produces (by
default) an output file "FIG_lambda_vs_Q.dat" containing data in 13
columns:
1 Q (MSbar renormalization scale)
2 lambda (tree-level)
3 lambda (1-loop)
4 lambda (1-loop plus 2-loop QCD)
5 lambda (2-loop)
6 lambda (2-loop plus leading 3-loop QCD)
7 lambda (2-loop plus leading 3-loop QCD and yt)
8 lambda/lambdarun (tree-level)
9 lambda/lambdarun (1-loop)
10 lambda/lambdarun (1-loop plus 2-loop QCD)
11 lambda/lambdarun (2-loop)
12 lambda/lambdarun (2-loop plus leading 3-loop QCD)
13 lambda/lambdarun (2-loop plus leading 3-loop QCD and yt)
where lambda is the value obtained at Q from the input Higgs pole mass
with all other pertinent MSbar parameters having been run from their
benchmark values, and lambdarun is instead obtained by directly RG
running its benchmark input value to the scale Q.
In the paper: arXiv:1907.02500
Standard Model parameters in the tadpole-free pure MSbar scheme
by Stephen P. Martin and David G. Robertson,
Figure 4.2a graphs columns 3, 4, 5, and 7 as a function of column 1.
Figure 4.2b graphs columns 9, 10, 11, and 13 as a function of column 1.
The program takes two optional command line arguments:
-i Reads model data from ; if
not specified, data are read from the file
"ReferenceModel.dat".
-o Writes output data to ; if
not specified, the results appear in
"FIG_lambda_vs_Q.dat".
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o fig_lambda_vs_Q fig_lambda_vs_Q.c -L. -lsmdr -ltsil -lm
assuming the necessary archive files libsmdr.a and libtsil.a and the
header file smdr.h and tsil.h are all in the current directory.
Run as:
./fig_lambda_vs_Q
The running time is typically of order 3 minutes, depending on your
hardware.
----------------------------------------------
fig_RGrun_vs_Q (Source file: fig_RGrun_vs_Q.c)
----------------------------------------------
Calculates the Standard Model MSbar parameters as a function of the
renormalization scale from Q = 100 GeV to Q = 10^19 GeV, given their
input values at a benchmark point defined in the file
"ReferenceModel.dat" unless a different file is specified using the
"-i" option; see below. The full state-of-the art beta functions are
used.
The data is output by default in the file "FIG_RGrun_vs_Q.dat" in 24
columns, respectively:
1 Q
2 Log[Q]
3 g3
4 g
5 gp
6 alpha3
7 alpha2
8 alpha1
9 1/alpha3
10 1/alpha2
11 1/alpha1
12 yt
13 yb
14 yc
15 ys
16 yd
17 yu
18 ytau
19 ymu
20 ye
21 lambda
22 sqrt(-m2)
23 v
24 Lambda
In the paper: arXiv:1907.02500
Standard Model parameters in the tadpole-free pure MSbar scheme
by Stephen P. Martin and David G. Robertson,
Figure 2.1a graphs columns 9, 10, and 11 as a function of column 2.
Figure 2.1b graphs columns 12, 13, 14, 15, 16, 17, 18, 19, and 20
as a function of column 2.
The program takes two optional command line arguments:
-i Reads model data from ; if
not specified, data are read from the file
ReferenceModel.dat.
-o Writes output data to ; if
not specified, the results appear in
"FIG_RGrun_vs_Q.dat".
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o fig_RGrun_vs_Q fig_RGrun_vs_Q.c -L. -lsmdr -ltsil -lm
assuming the necessary archive files libsmdr.a and libtsil.a and the
header files smdr.h and tsil.h are all in the current directory.
Run as:
./fig_RGrun_vs_Q
--------------------------------------------------
fig_RGrun_QCDQED (Source file: fig_RGrun_QCDQED.c)
--------------------------------------------------
Prints the running MSbar parameters in the QCD+QED effective theory as
a function of the renormalization scale from Q = MZ down to Q = 1 GeV,
decoupling the bottom, tau, and charm quarks at appropriate
thresholds. The input parameters come from the file
"ReferenceModel.dat" unless a different file is specified using the
"-i" option; see below. The state-of-the-art beta functions and
decoupling relations are used.
Data are output in the following files:
"FIG_RGrun_53.dat" for the 5-quark, 3-lepton theory, in 11 columns,
1 Q (from SMDR_MZ_EXPT down to SMDR_mbmb_EXPT)
2 alphaS
3 alpha
4 mb
5 mc
6 ms
7 md
8 mu
9 mtau
10 mmuon
11 melectron
"FIG_RGrun_43.dat" for the 4-quark, 3-lepton theory, in 10 columns,
1 Q (from SMDR_mbmb_EXPT down to SMDR_Mtau_EXPT)
2 alphaS
3 alpha
4 mc
5 ms
6 md
7 mu
8 mtau
9 mmuon
10 melectron
"FIG_RGrun_42.dat" for the 4-quark, 2-lepton theory, in 9 columns,
1 Q (from SMDR_Mtau_EXPT down to SMDR_mcmc_EXPT)
2 alphaS
3 alpha
4 mc
5 ms
6 md
7 mu
8 mmuon
9 melectron
"FIG_RGrun_32.dat" for the 3-quark, 2-lepton theory, in 8 columns,
1 Q (from SMDR_mcmc_EXPT down to 1 GeV)
2 alphaS
3 alpha
4 ms
5 md
6 mu
7 mmuon
8 melectron
In the paper: arXiv:1907.02500
Standard Model parameters in the tadpole-free pure MSbar scheme
by Stephen P. Martin and David G. Robertson,
Figure 2.2a graphs columns 2 and 3 as a function of column 1 from
FIG_RGrun_53.dat FIG_RGrun_43.dat FIG_RGrun_42.dat FIG_RGrun_32.dat
Figure 2.2b graphs
columns 4, 5, 6, 7, 8, 9, 10, and 11 as a function of column 1
from FIG_RGrun_53.dat
columns 4, 5, 6, 7, 8, 9, and 10 as a function of column 1
from FIG_RGrun_43.dat
columns 4, 5, 6, 7, 8, and 9 as a function of column 1
from FIG_RGrun_42.dat
columns 4, 5, 6, 7, and 8 as a function of column 1
from FIG_RGrun_32.dat
The program takes an optional command line argument:
-i Reads model data from ; if
not specified, data are read from the file
ReferenceModel.dat.
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o fig_RGrun_QCDQED fig_RGrun_QCDQED.c -L. -lsmdr -ltsil -lm
assuming the necessary archive files libsmdr.a and libtsil.a and the
header files smdr.h and tsil.h are all in the current directory.
Run as:
./fig_RGrun_QCDQED
----------------------------------------
fig_m2_vs_Q (Source file: fig_m2_vs_Q.c)
----------------------------------------
Calculates the Higgs lagrangian mass^2 parameter m2 as a function of
the MSbar renormalization scale Q. Here m2 is determined by
minimization of the effective potential, in various approximations
from:
hep-ph/0111190 (full 1-loop and 2-loop).
1310.7553 (3-loop at leading order in g3 and yt),
1709.02397 (full 3-loop), and
1508.00912 (4-loop at leading order in g3).
The input parameters are obtained from the file "ReferenceModel.dat"
unless a different file is specified using the "-i" option; see below.
This program produces by default an output file "FIG_m2_vs_Q.dat",
with data in 13 columns:
1 Q (MSbar renormalization scale)
2 sqrt(-m2(0)) (loopOrder = 0, tree-level),
3 sqrt(-m2(1)) (loopOrder = 1, 1-loop),
4 sqrt(-m2(2)) (loopOrder = 2, 2-loop),
5 sqrt(-m2(2.5)) (loopOrder = 2.5, includes leading 3-loop),
6 sqrt(-m2(3)) (loopOrder = 3, full 3-loop),
7 sqrt(-m2(3.5)) (loopOrder = 3, full 3-loop plus QCD 4-loop),
8 m2(0)/m2run,
9 m2(1)/m2run,
10 m2(2)/m2run,
11 m2(2.5)/m2run,
12 m2(3)/m2run,
13 m2(3.5)/m2run
where m2(n) is the value of m2 obtained by requiring the effective
potential to be minimized at the scale Q at loopOrder=n, and m2run is
obtained by directly running the input value of m2 to the scale Q
using 3-loop RG equations.
In the paper: arXiv:1907.02500
Standard Model parameters in the tadpole-free pure MSbar scheme
by Stephen P. Martin and David G. Robertson,
Figure 3.1a graphs columns 3, 4, 5, 6, and 7 as a function of column 1.
Figure 3.1b graphs columns 10, 11, 12, and 13 as a function of column 1.
The program takes two optional command line arguments:
-i Reads model data from ; if
not specified, data are read from the file
"ReferenceModel.dat".
-o Writes data to ; if not
specified, the results appear in
"FIG_m2_vs_Q.dat".
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o fig_m2_vs_Q fig_m2_vs_Q.c -L. -lsmdr -ltsil -l3vil -lm
assuming the necessary archive files libsmdr.a and libtsil.a and
lib3vil.a and the header file smdr.h and tsil.h and 3vil.h are all in
the current directory.
Run as:
./fig_m2_vs_Q
Running time is typically of order 15 minutes, depending on your
hardware.
------------------------------------------
fig_vev_vs_Q (Source file: fig_vev_vs_Q.c)
------------------------------------------
Calculates the Higgs VEV as a function of the MSbar renormalization
scale Q. Here v is determined by minimization of the effective
potential, in various approximations from:
hep-ph/0111190 (full 1-loop and 2-loop).
1310.7553 (3-loop at leading order in g3 and yt),
1709.02397 (full 3-loop), and
1508.00912 (4-loop at leading order in g3).
The input parameters are obtained from the file "ReferenceModel.dat"
unless a different file is specified using the "-i" option; see
below. This program produces by default an output file
"FIG_vev_vs_Q.dat", with data in 13 columns:
1 Q (MSbar renormalization scale)
2 v(0) (loopOrder = 0, tree-level),
3 v(1) (loopOrder = 1, 1-loop),
4 v(2) (loopOrder = 2, 2-loop),
5 v(2.5) (loopOrder = 2.5, includes leading 3-loop),
6 v(3) (loopOrder = 3, full 3-loop),
7 v(3.5) (loopOrder = 3.5, full 3-loop + QCD 4-loop),
8 v(0)/vrun,
9 v(1)/vrun,
10 v(2)/vrun,
11 v(2.5)/vrun,
12 v(3)/vrun
13 v(3.5)/vrun
where v(n) is the value of v obtained by minimizing the effective
potential at the scale Q in the given approximation, and vrun is
obtained by directly running the input value of v to the scale Q using
3-loop RG equations.
In the paper: arXiv:1907.02500
Standard Model parameters in the tadpole-free pure MSbar scheme
by Stephen P. Martin and David G. Robertson,
Figure 3.2a graphs columns 3, 4, 5, 6, and 7 as a function of column 1.
Figure 3.2b graphs columns 10, 11, 12, and 13 as a function of column 1.
The program takes two optional command line arguments:
-i Reads model data from ; if
not specified, data are read from the file
"ReferenceModel.dat".
-o Writes data to ; if not
specified, the results appear in
"FIG_vev_vs_Q.dat".
The executable for this program is automatically created within the
smdr directory by make. You can also compile it separately as:
gcc -o fig_vev_vs_Q fig_vev_vs_Q.c -L. -lsmdr -ltsil -l3vil -lm
assuming the necessary archive files libsmdr.a and libtsil.a and
lib3vil.a and the header file smdr.h and tsil.h and 3vil.h are all in
the current directory.
Run as:
./fig_vev_vs_Q
Running in the background is highly recommended, as the running time
is typically of order 2 hours, depending on your hardware.
*********************************************************************
IV. The SMDR Application Programmer Interface
*********************************************************************
In this section we define the signatures of all SMDR functions in the
user API, and describe their operation. SMDR function names are all
preceded by SMDR_ to avoid collisions with user defined functions and
variables.
---------------------------------------------------------------------
==== RENORMALIZATION GROUP RUNNING ====
---------------------------------------------------------------------
For any of these functions, loopOrder should be 1, 2, 3, 4, 5. In the
case of loopOrder = 5, the known partial 5-loop order results are
included.
---------------------------------------------------------------------
int SMDR_RGeval_SM (SMDR_REAL Q_final, int loopOrder);
Copies the input MSbar parameter global variables:
Q_in, g3_in, g_in, ..., m2_in, v_in, Lambda_in,
Delta_alpha_had_5_MZ_in
to the corresponding working global variables:
Q, g3, g, ..., m2, v, Lambda, Delta_alpha_had_5_MZ.
Then, runs all of these variables (except the last, which is defined
at MZ) from the scale Q = Q_in to the scale Q_final. Uses beta
functions with loop order loopOrder. The results are stored in the
global variables:
Q = Q_final, g3, g, gp, yt, yb, ..., m2, v, Lambda.
---------------------------------------------------------------------
int SMDR_RGrun_SM (SMDR_REAL Q_final, int loopOrder);
Runs the full Standard Model MSbar parameters in the non-decoupled
theory:
Q, g3, g, gp, yt, yb, ..., m2, v, Lambda
from the current scale Q to the scale Q_final. Uses beta functions
with loop order loopOrder. The results are stored in the global
variables:
Q = Q_final, g3, gp, g, yt, yb, ..., m2, v, Lambda.
---------------------------------------------------------------------
int SMDR_RGeval_QCDQED_53 (SMDR_REAL Qfinal,
SMDR_REAL Q_thZW_dec,
int loopOrder);
Evaluates, using RG running and decoupling, the 5-quark,
3-charged-lepton QCD+QED effective theory MSbar running parameter
global variables:
alphaS, alpha, mb, mc, ms, md, mu, mtau, mmuon, melectron
at the scale Qfinal, taking the decoupling scale for top, Higgs, Z, W
to be Q_thZW_dec. The inputs are the global variables corresponding to
the non-decoupled Standard Model input MSbar parameters:
Q_in, g3_in, g_in, gp_in, yt_in, yb_in, ..., lambda_in, v_in
The results are stored as the global variables:
Q_53 = Qfinal, alphaS_53, alpha_53, m_53
with = b, c, s, d, u, tau, muon, electron. Typically,
Q_final is expected to be roughly between 4 GeV and MZ.
---------------------------------------------------------------------
int SMDR_RGeval_QCDQED_43 (SMDR_REAL Qfinal,
SMDR_REAL Q_b_dec,
SMDR_REAL Q_thZW_dec,
int loopOrder);
Evaluates, using RG running and decoupling, the 4-quark,
3-charged-lepton QCD+QED effective theory MSbar running parameters:
alphaS, alpha, mc, ms, md, mu, mtau, mmuon, melectron
at the scale Qfinal, taking decoupling scales of Q_thZW_dec for top,
Higgs, Z, W, and taking Q_b_dec for the bottom quark decoupling scale.
The inputs are the global variables corresponding to the non-decoupled
Standard Model input MSbar parameters:
Q_in, g3_in, g_in, gp_in, yt_in, yb_in, ..., lambda_in, v_in.
The results are stored as the global variables:
Q_43 = Qfinal, alphaS_43, alpha_43, m_43,
with = c, s, d, u, tau, muon, electron. Typically, Q_final
is expected to be roughly between 1.5 GeV and 5 GeV.
---------------------------------------------------------------------
int SMDR_RGeval_QCDQED_42 (SMDR_REAL Qfinal,
SMDR_REAL Q_tau_dec,
SMDR_REAL Q_b_dec,
SMDR_REAL Q_thZW_dec,
int loopOrder);
Evaluates, using RG running and decoupling, the 4-quark,
2-charged-lepton QCD+QED effective theory MSbar running parameters:
alphaS, alpha, mc, ms, md, mu, mmuon, melectron
at the scale Qfinal, taking decoupling scales of Q_thZW_dec for top,
Higgs, Z, W, and taking Q_b_dec for the bottom quark decoupling scale,
and taking Q_tau_dec for the tau lepton decoupling scale. The inputs
are the global variables corresponding to the non-decoupled Standard
Model input MSbar parameters:
Q_in, g3_in, g_in, gp_in, yt_in, yb_in, ..., lambda_in, v_in.
The results are stored as the global variables:
Q_42 = Qfinal, alphaS_42, alpha_42, m_42
with = c, s, d, u, muon, electron. Typically, Q_final is
expected to be roughly between 1 GeV and 2 GeV.
---------------------------------------------------------------------
int SMDR_RGeval_QCDQED_32 (SMDR_REAL Qfinal,
SMDR_REAL Q_c_dec,
SMDR_REAL Q_tau_dec,
SMDR_REAL Q_b_dec,
SMDR_REAL Q_thZW_dec,
int loopOrder);
Evaluates, using RG running and decoupling, the 3-quark,
2-charged-lepton QCD+QED effective theory MSbar running parameters:
alphaS, alpha, ms, mu, md, mmuon, melectron
at the scale Qfinal, taking decoupling scales of Q_thZW_dec for top,
Higgs, Z, W, and taking Q_b_dec for the bottom quark decoupling scale,
and Q_tau_dec for the tau lepton decoupling scale, and Q_c_dec for the
charm quark decoupling scale. The inputs are the non-decoupled
Standard Model input MSbar parameters:
Q_in, g3_in, g_in, gp_in, yt_in, yb_in, ..., lambda_in, v_in.
The results are stored as the global variables:
Q_32 = Qfinal, alphaS_32, alpha_32, m_32,
with = s, d, u, muon, electron. Typically, Q_final is
expected to be less than about 1.5 GeV.
---------------------------------------------------------------------
int SMDR_RGrun_QCDQED_53 (SMDR_REAL Qfinal, int loopOrder);
Runs the MSbar parameters of the 5-quark, 3-charged lepton QCD+QED
effective theory:
Q_53, alphaS_53, alpha_53, m_53,
with fermion = b, c, s, d, u, tau, muon, electron, from the current
scale Q_53 to the scale Q_final. Uses beta functions with loop order
loopOrder. The results are stored in the same global variables:
Q_53 = Qfinal, alphaS_53, alpha_53, m_53.
---------------------------------------------------------------------
int SMDR_RGrun_QCDQED_43 (SMDR_REAL Qfinal, int loopOrder);
Runs the MSbar parameters of the 4-quark, 3-charged lepton QCD+QED
effective theory:
Q_43, alphaS_43, alpha_43, m_43,
with = c, s, d, u, tau, muon, electron, from the current
scale Q_43 to the scale Q_final. Uses beta functions with loop order
loopOrder. The results are stored in the same global variables:
Q_43 = Qfinal, alphaS_43, alpha_43, m_43.
---------------------------------------------------------------------
int SMDR_RGrun_QCDQED_42 (SMDR_REAL Qfinal, int loopOrder);
Runs the MSbar parameters of the 4-quark, 2-charged lepton QCD+QED
effective theory:
Q_42, alphaS_42, alpha_42, m_42,
with = c, s, d, u, muon, electron from the current scale
Q_42 to the scale Q_final. Uses beta functions with loop order
loopOrder. The results are stored in the same global variables:
Q_42 = Qfinal, alphaS_42, alpha_42, m_42.
---------------------------------------------------------------------
int SMDR_RGrun_QCDQED_32 (SMDR_REAL Qfinal, int loopOrder);
Runs the MSbar parameters of the 3-quark, 2-charged lepton QCD+QED
effective theory:
Q_32, alphaS_32, alpha_32, m_32,
with = s, d, u, muon, electron, from the current scale Q_32
to the scale Q_final. Uses beta functions with loop order
loopOrder. The results are stored in the same global variables:
Q_32 = Qfinal, alphaS_32, alpha_32, m_32.
---------------------------------------------------------------------
int SMDR_RGrun_QCDQED (SMDR_REAL Q_init, SMDR_REAL Q_final,
int loopOrder, int nu, int nd, int ne,
SMDR_REAL alphaS_init, SMDR_REAL alpha_init,
SMDR_REAL *alphaS_final, SMDR_REAL *alpha_final,
SMDR_REAL *cu, SMDR_REAL *cd, SMDR_REAL *ce);
This function is a tool used by the preceding functions.
Runs the MSbar parameters of the QCD+QED theory with nu up-type
quarks, nd down-type quarks, and ne charged leptons, from the scale
Q_init to the scale Q_final. The values of the QCD and QED couplings
at Q_init are alphaS_init and alpha_init. The output results at
Q_final are: alphaS_final, alpha_final, and the ratios
cu=mu_final/mu_init, cd=md_final/md_init, ce=me_final/me_init.
---------------------------------------------------------------------
==== DECOUPLING AND MATCHING ROUTINES ====
---------------------------------------------------------------------
void SMDR_Decouple_thZW (int loopOrder);
Simultaneously decouples the top quark and the Higgs, Z, and W bosons,
at the current MSbar renormalization scale Q. The inputs are the
global variables corresponding to the full Standard Model:
Q, g3, g, gp, yt, yb, yc, ys, yd, yu, ytau, ymuon, yelectron,
lambda, v
The results are stored in the global variables:
alphaS_53, alpha_53, and m_53,
where = b, c, s, u, d, tau, muon, electron. These are the
MSbar QCD and EM couplings and the running masses in the QCD+QED
effective theory that contains only the 5 quarks b,c,s,u,d and the
charged leptons tau,mu,e, and the gluons and the photons. At present,
the argument loopOrder is ignored, and all known effects are included.
---------------------------------------------------------------------
void SMDR_Eval_Gauge (SMDR_REAL Mtpole,
SMDR_REAL Mhpole,
SMDR_REAL MWpole);
Evaluates:
1) alphaS(MZ) and alphaS(MZ) and s^2(thetaW) in the MSbar scheme of
the non-decoupled Standard Model theory, putting the results in
the global variables: SMDR_alphaS_MZ, SMDR_alpha_MZ, SMDR_s2W_MZ.
2) The Sommerfeld fine structure constant, using the results of
1411.7040 Degrassi, Gambino, and Giardino. The result is stored
in the global variable SMDR_alpha.
3) alpha(MZ) and s^2(thetaW) in PDG MSbar scheme with only top
decoupled but W not decoupled. The results are stored in the
global variables: SMDR_alpha_MZ_PDG, SMDR_s2W_MZ_PDG.
Uses as inputs the global variable Standard Model input values
Q_in, g3_in, g_in, gp_in, yt_in, ...
as well as the arguments Mtpole, Mhpole, MWpole.
---------------------------------------------------------------------
For the following four functions, loopOrder = 0, 1, 2, 3, 4.
EM contributions beyond 2 loops are not included.
---------------------------------------------------------------------
void SMDR_Decouple_bottom (int loopOrder);
Decouples the bottom quark at the scale given by the global variable
Q_53 = the MSbar renormalization scale of the 5-quark,
3-charged-lepton QCD+QED effective field theory. The inputs are the
global variables:
Q_53, alphaS_53, alpha_53, m_53
with = b, c, s, d, u, tau, muon, electron. The output MSbar
parameters of the 4-quark, 3-charged-lepton QCD+QED effective theory
are put in the global variables:
Q_43 = Q_53, alphaS_43, alpha_43, m_43,
with = c, s, d, u, tau, muon, electron,
---------------------------------------------------------------------
void SMDR_Decouple_tau (int loopOrder);
Decouples the tau lepton at the scale given by the global variable
Q_43 = the MSbar renormalization scale of the 4-quark,
3-charged-lepton QCD+QED effective field theory. The input are the
global variables:
Q_43, alphaS_43, alpha_43, m_43
with = c, s, d, u, tau, muon, electron. The output MSbar
parameters of the 4-quark, 2-charged-lepton QCD+QED effective theory
are put in the global variables:
Q_42 = Q_43, alphaS_42, alpha_42, m_42,
with = c, s, d, u, muon, electron,
---------------------------------------------------------------------
void SMDR_Decouple_charm (int loopOrder);
Decouples the charm quark at the scale given by the global variable
Q_42 = the MSbar renormalization scale of the 4-quark,
2-charged-lepton QCD+QED effective field theory. The inputs are the
global variables:
Q_42, alphaS_42, alpha_42, m_42
with = c, s, d, u, muon, electron. The output MSbar
parameters of the 3-quark, 2-charged-lepton QCD+QED effective theory
are put in the global variables:
Q_32 = Q_42, alphaS_32, alpha_32, m_32,
with = s, d, u, muon, electron,
---------------------------------------------------------------------
void SMDR_QCDQEDmatch (const char *Fermion_type,
SMDR_REAL Q_match,
SMDR_REAL m_Fermion,
SMDR_REAL alphaS_hi,
SMDR_REAL alpha_hi,
int nqlight,
int loopOrder,
SMDR_REAL *alphaS_lo,
SMDR_REAL *alpha_lo,
SMDR_REAL *zu,
SMDR_REAL *zd,
SMDR_REAL *ze);
This function is a tool used by the preceding functions.
The input arguments are:
Fermion_type = "u", "d", or "e" = type of heavy fermion being
decoupled
Q_match = MSbar decoupling scale.
m_Fermion = MSbar mass of heavy fermion being decoupled, in full
theory, at Q_match
alphaS_hi = strong coupling in full theory, at scale Q_match.
alpha_hi = EM coupling in full theory, at scale Q_match
nqlight = number of light quarks, not including the fermion
being decoupled. Note that the number of light
leptons doesn't matter in the approximation being
used. (It would matter if 3-loop EM contributions
were included.)
The outputs are:
alphaS_lo = strong coupling in decoupled theory, at scale Q_match.
alpha_lo = EM coupling in decoupled theory, at scale Q_match.
zu = ratio of (MSbar light up-type mass in decoupled theory)/
(MSbar light up-type mass in full theory).
zd = ratio of (MSbar light down-type mass in decoupled
theory)/ (MSbar light down-type mass in full theory).
ze = ratio of (MSbar light charged lepton mass in decoupled
theory)/ (MSbar light charged lepton mass in full
theory).
Small mass corrections are not included here, but are added in the
functions SMDR_Decouple_b and SMDR_Decouple_c.
---------------------------------------------------------------------
==== EFFECTIVE POTENTIAL ====
---------------------------------------------------------------------
For these functions, loopOrder may take the following values:
0 tree-level
1 1-loop
2 2-loop
2.5 2-loop plus 3-loop contributions in the large
g3, yt limit
3 full 3-loop
3.5 full 3-loop plus 4-loop at leading order in QCD
---------------------------------------------------------------------
SMDR_REAL SMDR_Eval_Veffmin (SMDR_REAL Q_eval, float loopOrder);
Returns the minimum value of the effective potential (in Landau
gauge, in the MSbar scheme, with Goldstone boson resummation).
If the argument Q_eval is positive, then the inputs are obtained
by first RG running the MSbar parameter global variables:
Q_in, v_in, lambda_in, g3_in, g_in, gp_in, yt_in, yb_in, ytau_in
to the scale Q_eval, using SMDR_RGeval_SM().
If the argument Q_eval is negative, then the inputs are instead
taken to be the current values of the MSbar parameter global
working variables:
Q, v, lambda, g3, g, gp, yt, yb, ytau
The function adjusts the global working variable m2 to assure that
the resummed effective potential is minimized, and returns the
corresponding minimum value of the effective potential.
---------------------------------------------------------------------
SMDR_REAL SMDR_Eval_m2 (SMDR_REAL Q_eval, float loopOrder);
Returns the value of m2 that minimizes the effective potential (in
Landau gauge, in the MSbar scheme, with Goldstone boson resummation).
If the argument Q_eval is positive, then the inputs are obtained
by first RG running the MSbar parameter global variables:
Q_in, v_in, lambda_in, g3_in, g_in, gp_in, yt_in, yb_in, ytau_in
to the scale Q_eval, using SMDR_RGeval_SM().
If the argument Q_eval is negative, then the inputs are instead
taken to be the current values of the MSbar parameter global
working variables:
Q, v, lambda, g3, g, gp, yt, yb, ytau
which are assumed to be fixed. This function does not automatically
change the global variable m2.
---------------------------------------------------------------------
SMDR_REAL SMDR_Eval_vev (SMDR_REAL Q_eval, float loopOrder);
Returns the value of the VEV v at the minimum of the effective
potential (in Landau gauge, in the MSbar scheme, with Goldstone
boson resummation, at loop order loopOrder)
If the argument Q_eval is positive, then the inputs are obtained
by first RG running the MSbar parameter global variables:
Q_in, m2_in, lambda_in, g3_in, g_in, gp_in, yt_in, yb_in, ytau_in,
to the scale Q_eval, using SMDR_RGeval_SM().
If the argument Q_eval is negative, then the inputs are instead
taken to be the current values of the MSbar parameter global
working variables:
Q, m2, lambda, g3, g, gp, yt, yb, ytau,
which are assumed to be fixed. This function does not automatically
change the global variable v.
---------------------------------------------------------------------
SMDR_REAL SMDR_Eval_vevDelta (SMDR_REAL Q_eval, float loopOrder);
Returns the value of the quantity
Delta = -G = (vtree^2 - v^2)*lambda
defined in section V.3 of 1709.02397.
If the argument Q_eval is positive, then the inputs are obtained
by first RG running the MSbar parameter global variables:
Q_in, v_in, lambda_in, g3_in, g_in, gp_in, yt_in, yb_in, ytau_in,
to the scale Q_eval, using SMDR_RGeval_SM().
If the argument Q_eval is negative, then the inputs are instead
taken to be the current values of the MSbar parameter global working variables:
Q, v, lambda, g3, g, gp, yt, yb, ytau,
which are assumed to be fixed.
---------------------------------------------------------------------
==== HIGGS SECTOR ====
---------------------------------------------------------------------
For these functions, loopOrder may take the following values:
0 tree level
1 1-loop
1.5 1-loop plus 2-loop QCD corrections
2 full 2-loop
2.3 full 2-loop plus leading 3-loop QCD
2.5 full 2-loop plus leading 3-loop QCD and nonQCD terms.
The computations use equations (2.43), (2.46)-(2.48), and
(3.2)-(3.4) of [MR14].
---------------------------------------------------------------------
void SMDR_Eval_Mh_pole (SMDR_REAL Q_eval,
float loopOrder,
SMDR_REAL *Mhpoleresult,
SMDR_REAL *Gammahpoleresult);
Computes the Higgs pole mass. The results M_h and Gamma_h for the
complex pole squared mass
M_h^2 - i Gamma_h M_h
are returned as Mhpoleresult and Gammahpoleresult.
If the argument Q_eval is positive, then the inputs are obtained by
first RG running the MSbar parameter global variables:
Q_in, g3_in, g_in, gp_in, lambda_in, yt_in, ..., v_in
to the scale Q_eval, using SMDR_RGeval_SM().
If the argument Q_eval is negative, then the inputs are instead given
directly by the current values of the MSbar parameter global
variables:
Q, g3, g, gp, lambda, yt, ..., v.
---------------------------------------------------------------------
SMDR_REAL SMDR_Eval_lambda (SMDR_REAL mhpole,
SMDR_REAL Q_eval,
float loopOrder);
Returns the Higgs self-coupling lambda, given the real part of the
Higgs pole mass and the other MSbar Standard Model parameters,
determined as follows:
If the argument Q_eval is positive, then the inputs are obtained by
first RG running the MSbar parameter global variables:
Q_in, g3_in, g_in, gp_in, yt_in, ..., v_in
to the scale Q_eval, using SMDR_RGeval_SM().
If the argument Q_eval is negative, then the inputs are instead taken to be
the current values of the MSbar parameter global variables:
Q, g3, g, gp, yt, ..., v.
---------------------------------------------------------------------
==== W, Z BOSONS ====
---------------------------------------------------------------------
For these functions, loopOrder may take the following values:
0 tree level
1 1-loop
1.5 1-loop plus 2-loop QCD corrections
2 full 2-loop
---------------------------------------------------------------------
void SMDR_Eval_MW_pole (SMDR_REAL Q_eval,
float loopOrder,
SMDR_REAL *MWpoleresult,
SMDR_REAL *GammaWpoleresult,
SMDR_REAL *MWBreitWignerresult,
SMDR_REAL *GammaWBreitWignerresult);
Computes the complex pole and Breit-Wigner squared masses of the W
boson, using the calculation from 1503.03782.
If the argument Q_eval is positive, then the inputs are obtained by
first RG running the MSbar parameter global variables:
Q_in, g3_in, g_in, gp_in, yt_in, ..., v_in
to the scale Q_eval, using SMDR_RGeval_SM().
If the argument Q_eval is negative, then the inputs are instead given
by the current values of the MSbar parameter global variables:
Q, g3, g, gp, yt, ..., v.
The results for the complex pole squared mass
M_W^2 - i Gamma_W M_W
are returned in MWpoleresult, GammaWpoleresult.
The results for the complex Breit-Wigner squared mass are also
returned as MWBreitWignerresult, GammaWBreitWignerresult.
---------------------------------------------------------------------
void SMDR_Eval_MZ_pole (SMDR_REAL Q_eval,
float loopOrder,
SMDR_REAL *MZpoleresult,
SMDR_REAL *GammaZpoleresult,
SMDR_REAL *MZBreitWignerresult,
SMDR_REAL *GammaZBreitWignerresult);
Computes the complex pole and Breit-Wigner squared masses of the Z
boson, using the calculation from 1505.04833.
If the argument Q_eval is positive, then the inputs are obtained by
first RG running the MSbar parameter global variables:
Q_in, g3_in, g_in, gp_in, yt_in, ..., v_in
to the scale Q_eval, using SMDR_RGeval_SM().
If the argument Q_eval is negative, then the inputs are instead given
by the current values of the MSbar parameter global variables:
Q, g3, g, gp, yt, ..., v.
The results for the complex pole squared mass
M_Z^2 - i Gamma_Z M_Z
are returned as MZpoleresult, GammaZpoleresult.
The results for the complex Breit-Wigner squared mass are also
returned as MZBreitWignerresult, GammaZBreitWignerresult.
---------------------------------------------------------------------
==== GFERMI ====
---------------------------------------------------------------------
SMDR_REAL SMDR_Eval_GFermi (SMDR_REAL Q_eval, float loopOrder);
Returns GFermi at up to two loops. Based on Deltartilde given in
section 3 of arXiv:1907.02500 and the ancillary file Deltartilde.txt.
See also Deltarbar in
Kniehl and Veretin 1401.1844 eqs (37)-(40) and
Kniehl, Pikelner, Veretin 1503.02138 eqs (60)-(62). Appendix A.2
Kniehl, Pikelner, Veretin 1601.08143, file
mr-1.3.2/mr/dr/drbar20.cpp in the computer code "mr".
The argument loopOrder has allowed values:
0 tree-level
1 1-loop
1.3 1-loop plus 2-loop leading order in QCD
1.5 1-loop plus 2-loop leading order in QCD and yt
2 Full 2-loop result
If the argument Q_eval is positive, then the inputs are obtained by
first RG running the MSbar parameters:
Q_in, g3_in, g_in, gp_in, yt_in, ..., v_in
to the scale Q_eval, using SMDR_RGeval_SM().
If the argument Q_eval is negative, then the inputs are instead given
by the current values of the MSbar parameters:
Q, g3, g, gp, yt, ..., v.
---------------------------------------------------------------------
SMDR_REAL SMDR_Eval_GFermi_DGG (SMDR_REAL Mtpole,
SMDR_REAL Mhpole,
SMDR_REAL MWpole);
Returns the result for the Fermi decay constant G_Fermi as found by
1411.7040 Degrassi, Gambino, and Giardino. Uses as inputs the global
variable Standard Model input values
Q_in, g3_in, g_in, gp_in, yt_in, ...
as well as the arguments Mtpole, Mhpole, MWpole. This is an
alternative to SMDR_Eval_GFermi().
---------------------------------------------------------------------
==== TOP QUARK ====
---------------------------------------------------------------------
For these functions,
method = 0 (expand around tree-level) or
1 (expand around pole. Recommended; more accurate but
slower).
QCDLoopOrder = 0, 1, 2, 3, or 4.
otherLoopOrder = 0 (tree-level) or
1 (1-loop) or
1.5 (2-loop mixed QCD/EW) or
2 (2-loop full).
The sources for the relevant results are:
4-loop pure QCD from 1502.01030, updated and perfected in
1606.06754.
2-loop non-pure-QCD from 1604.01134.
---------------------------------------------------------------------
void SMDR_Eval_Mt_pole (SMDR_REAL Q_eval,
int method,
int QCDloopOrder,
float otherLoopOrder,
SMDR_REAL *Mtpoleresult,
SMDR_REAL *Gammatpoleresult);
Computes the complex pole mass of the top quark. The results for the
complex pole squared mass M_t^2 - i Gamma_t M_t are returned as
Mtpoleresult, Gammatpoleresult.
If the argument Q_eval is positive, then the inputs are obtained by
first RG running the MSbar parameter global variables:
Q_in, g3_in, g_in, gp_in, yt_in, ..., v_in
to the scale Q_eval, using SMDR_RGeval_SM().
If the argument Q_eval is negative, then the inputs are instead given
by the current values of the MSbar parameter global variables:
Q, g3, g, gp, yt, ..., v.
---------------------------------------------------------------------
SMDR_REAL SMDR_Eval_yt (SMDR_REAL MTpoletarget,
SMDR_REAL Q_eval,
int method,
int QCDLoopOrder,
float otherLoopOrder);
Returns the top-quark Yukawa coupling, given the real part of the pole
mass of the top quark, specified as MTpoletarget. The other arguments
are as described for the previous function SMDR_Eval_Mt_pole().
If the argument Q_eval is positive, then the inputs are obtained
by first RG running the MSbar parameter global variables:
Q_in, lambda_in, g3_in, g_in, gp_in, yb_in, ..., v_in
to the scale Q_eval, using SMDR_RGeval_SM().
If the argument Q_eval is negative, then the inputs are instead taken
to be the current values of the MSbar parameter global variables:
Q, lambda, g3, g, gp, yb, ..., v.
---------------------------------------------------------------------
==== LIGHT QUARKS AND LEPTONS ====
---------------------------------------------------------------------
void SMDR_Eval_Light_Masses ();
Has the same effect as calling all of the following individual
functions:
SMDR_Eval_mbmb();
SMDR_Eval_mcmc();
SMDR_Eval_mquarks_2GeV();
SMDR_Eval_Mtau_pole();
SMDR_Eval_Mmuon_pole();
SMDR_Eval_Melectron_pole();
However, it is slightly more efficient than calling them individually,
because it doesn't unnecessarily redo the RG running each time.
---------------------------------------------------------------------
SMDR_REAL SMDR_Eval_mbmb (SMDR_REAL Q_dec_thZW, int loopOrder);
Returns the bottom-quark MSbar running mass evaluated at itself,
mb(mb), in the 5-quark, 3-charged-lepton QCD+QED effective theory.
Uses beta functions with loop order loopOrder = 1, 2, 3, 4, 5. The
inputs are the global variables corresponding to the MSbar parameters
of the full Standard Model:
Q_in, g3_in, g_in, gp_in, yt_in, yb_in, ..., v_in.
Decoupling of t, h, Z, W occurs at the scale Q_dec_thZW.
---------------------------------------------------------------------
SMDR_REAL SMDR_Eval_mcmc (SMDR_REAL Q_dec_tau,
SMDR_REAL Q_dec_bottom,
SMDR_REAL Q_dec_thZW, int loopOrder);
Returns the charm-quark MSbar running mass evaluated at itself,
mc(mc), in the 4-quark, 2-charged-lepton QCD+QED effective theory.
Uses beta functions with loop order loopOrder = 1, 2, 3, 4, 5. The
inputs are the global variables corresponding to the MSbar parameters
of the full Standard Model:
Q_in, g3_in, g_in, gp_in, yt_in, yb_in, yc_in, ..., v_in.
Decoupling of t, h, Z, W occurs at the scale Q_dec_thZW, and
decoupling of the bottom and tau occur at Q_dec_bottom, Q_dec_tau.
---------------------------------------------------------------------
void SMDR_Eval_mquarks_2GeV (SMDR_REAL Q_dec_bottom,
SMDR_REAL Q_dec_thZW,
int loopOrder,
SMDR_REAL *ms,
SMDR_REAL *mu,
SMDR_REAL *md);
Evaluates the strange, down, and up-quark MSbar running masss
evaluated at Q=2 GeV, in the 4-quark, 3-charged-lepton QCD+QED
effective theory. Uses beta functions with loop order loopOrder = 1,
2, 3, 4, 5. The inputs are the global variables corresponding to the
MSbar parameters of the full Standard Model:
Q_in, g3_in, g_in, gp_in, yt_in, yb_in, yc_in, ..., v_in.
Decoupling of t, h, Z, W occurs at the scale Q_dec_thZW, and
decoupling of the bottom at Q_dec_bottom.
---------------------------------------------------------------------
SMDR_REAL SMDR_Eval_Mb_pole (SMDR_REAL Q_eval,
SMDR_REAL Q_dec_thZW,
int loopOrder);
Returns the pole mass of the bottom quark, computed in the 5-quark,
3-charged-lepton QCD+QED effective field theory at the scale Q_eval,
in the approximation of QCD loopOrder = 0, 1, 2, 3, or 4. (The RG
running is done including all known effects up to 5-loop order.) The
starting inputs are the global variables corresponding to the MSbar
parameters of the full Standard Model:
Q_in, g3_in, g_in, gp_in, yt_in, yb_in, yc_in, ..., v_in.
Decoupling of t, h, Z, W occurs at the scale Q_dec_thZW.
NOTE: This just doesn't converge fast enough to be useful!
The Review of Particle Properties uses the 2-loop approximation, which
is horrible. See 1606.06754 for discussion of the atrocious
convergence properties of the expansion. Therefore, the bottom (and
charm) pole masses are kind of useless as observables and are
deprecated.
---------------------------------------------------------------------
SMDR_REAL SMDR_Eval_Mtau_pole (SMDR_REAL Q_eval,
SMDR_REAL Q_dec_bottom,
SMDR_REAL Q_dec_thZW,
int loopOrder);
Returns the pole mass of the tau lepton, computed in the 4-quark,
3-charged-lepton QCD+QED effective field theory at the scale Q_eval,
in the approximation of loopOrder = 0, 1, 2, 3. (The RG running is
done including all known effects up to 5-loop order.) The starting
inputs are the global variables corresponding to the MSbar parameters
of the full Standard Model:
Q_in, g3_in, g_in, gp_in, yt_in, yb_in, yc_in, ..., v_in.
Decoupling of t, h, Z, W occurs at the scale Q_dec_thZW, and
decoupling of the bottom quark occurs at the scale Q_dec_bottom.
---------------------------------------------------------------------
SMDR_REAL SMDR_Eval_Mmuon_pole (SMDR_REAL Q_eval,
SMDR_REAL Q_dec_charm,
SMDR_REAL Q_dec_tau,
SMDR_REAL Q_dec_bottom,
SMDR_REAL Q_dec_thZW,
int loopOrder);
Returns the pole mass of the muon, computed in the 3-quark,
2-charged-lepton QCD+QED effective field theory at the scale Q_eval,
in the approximation of loopOrder = 0, 1, or 2. (The RG running is
done including all known effects up to 5-loop order.) The starting
inputs are the global variables corresponding to the MSbar parameters
of the full Standard Model:
Q_in, g3_in, g_in, gp_in, yt_in, yb_in, yc_in, ..., v_in.
Decoupling of t, h, Z, W occurs at the scale Q_dec_thZW, and
decoupling of the bottom, tau, and charm occur at the scales
Q_dec_bottom, Q_dec_tau, and Q_dec_charm, respectively.
---------------------------------------------------------------------
SMDR_REAL SMDR_Eval_Melectron_pole (SMDR_REAL Q_eval,
SMDR_REAL Q_dec_charm,
SMDR_REAL Q_dec_tau,
SMDR_REAL Q_dec_bottom,
SMDR_REAL Q_dec_thZW,
int loopOrder);
Returns the pole mass of the electron, computed in the 3-quark,
2-charged-lepton QCD+QED effective field theory at the scale Q_eval,
in the approximation of loopOrder = 0, 1, or 2. (The RG running is
done including all known effects up to 5-loop order.) The starting
inputs are the global variables corresponding to the MSbar parameters
of the full Standard Model:
Q_in, g3_in, g_in, gp_in, yt_in, yb_in, yc_in, ..., v_in.
Decoupling of t, h, Z, W occurs at the scale Q_dec_thZW, and
decoupling of the bottom, tau, and charm occur at the scales
Q_dec_bottom, Q_dec_tau, and Q_dec_charm, respectively.
---------------------------------------------------------------------
==== UTILITIES ====
---------------------------------------------------------------------
int SMDR_Fit_Inputs (SMDR_REAL Q_target,
SMDR_REAL alphaS_target,
SMDR_REAL alpha_target,
SMDR_REAL GFermi_target,
SMDR_REAL MZ_target,
SMDR_REAL Mh_target,
SMDR_REAL Mt_target,
SMDR_REAL mbmb_target,
SMDR_REAL mcmc_target,
SMDR_REAL ms_2GeV_target,
SMDR_REAL md_2GeV_target,
SMDR_REAL mu_2GeV_target,
SMDR_REAL Mtau_target,
SMDR_REAL Mmuon_target,
SMDR_REAL Melectron_target,
SMDR_REAL Delta_alpha_had,
SMDR_REAL error_target);
Finds the (non-decoupled) Standard Model MSbar parameters at the scale
Q_target. The results are stored in the global variables:
Q_in = Q_target, g3_in, g_in, gp_in, v_in, lambda_in, y_in
where fermion = t, b, c, s, d, u, tau, muon, electron.
The inputs are the arguments:
alphaS_target (in the 5-quark, 3-charged-lepton QCD+QED theory at
Q=MZ),
alpha_target (in the 5-quark, 3-charged-lepton theory at Q=MZ),
MZ_target (the Z-boson Breit-Wigner mass),
GFermi_target (the Fermi constant),
Mh_target (the Higgs boson pole mass),
Mt_target (the top-quark pole mass),
mbmb_target (the MSbar bottom mass evaluated at itself in the
5-quark, 3-charged-lepton QCD+QED theory),
mcmc_target (the MSbar charm mass evaluated at itself in the
4-quark, 2-charged-lepton QCD+QED theory),
ms_2GeV_target (the MSbar strange quark mass at Q=2 GeV, in the
3-quark, 2-charged-lepton QCD+QED theory),
md_2GeV_target (the MSbar down quark mass at Q=2 GeV, in the
3-quark, 2-charged-lepton QCD+QED theory),
mu_2GeV_target (the MSbar up quark mass at Q=2 GeV, in the 3-quark,
2-charged-lepton QCD+QED theory),
Mtau_target (the tau lepton pole mass),
Mmuon_target (the muon pole mass),
Melectron_target (the electron pole mass),
Delta_alpha_had (the non-perturbative hadronic contribution to the
fine-structure constant at MZ)
The calculation proceeds by iteration, until the largest of the
fractional errors in the target quantities is less than
error_target. About 5 or fewer iterations are typically expected for
error_target = 10^-8.
---------------------------------------------------------------------
void SMDR_Load_Inputs (void);
Loads the Standard Model MSbar parameters from the "static" global input
variables X_in to the corresponding global working variables X, where
X = Q, g3, g, gp, yt, yb, yc, ys, yu, yd, ytau, ymu, ye, lambda,
m2, v, Lambda, and Delta_alpha_had_5_MZ.
This function should be called before calling other functions that need
the working variables X. It should also be called whenever a preceding
function may have altered one or more of the working variables X, if it
is necessary to reset them to the original input variables X_in. In
practice, many other functions start by calling SMDR_Load_Inputs()
anyway, in which case it is not necessary for the user application to do
so. This includes all functions whose names contain "RGeval" or "Eval".
The exception to this rule is functions with "Eval" in the special case
that they are called with the first argument Q_eval negative; this
specifies that the working variables at the current value of Q will be
used. In those cases, one should have either previously called
SMDR_Load_Inputs(), or else SMDR_RGeval_SM() to set the working
variables at the desired current scale Q.
Another common situation where the function SMDR_Load_Inputs() is
necessary in user applications is when one wants to write or display the
*input* values of the MSbar variables but using one of the functions
that are designed to write or display the working variables, namely:
SMDR_Write_MSbar_Parameters() and SMDR_Write_v() and SMDR_Write_m2() and
SMDR_Write_Lambda() or the corresponding functions
SMDR_Display_MSbar_Parameters() and SMDR_Display_v() and
SMDR_Display_m2() and SMDR_Display_Lambda().
---------------------------------------------------------------------
void SMDR_Save_Inputs (void);
Loads the Standard Model MSbar parameters from the current global
working variables X to the corresponding global input variables X_in, where
X = Q, g3, g, gp, yt, yb, yc, ys, yu, yd, ytau, ymu, ye, lambda,
m2, v, Lambda, and Delta_alpha_had_5_MZ.
This function is the inverse of SMDR_Load_Inputs().
---------------------------------------------------------------------
void SMDR_Update (void);
Updates various useful parameter combinations.
In general, this function is called automatically when needed by the
API functions, so users need not worry about it or use it under normal
circumstances.
---------------------------------------------------------------------
void SMDR_Check_Ranges (void);
void SMDR_Check_Q_Range (SMDR_REAL Q_range_lo, SMDR_REAL Q_range_hi);
void SMDR_Check_VEV_Range (SMDR_REAL vev_range_lo, SMDR_REAL vev_range_hi);
void SMDR_Check_m2_Range (SMDR_REAL m2_range_lo, SMDR_REAL m2_range_hi);
void SMDR_Check_lambda_Range (SMDR_REAL k_range_lo, SMDR_REAL k_range_hi);
void SMDR_Check_yt_Range (SMDR_REAL yt_range_lo, SMDR_REAL yt_range_hi);
void SMDR_Check_yb_Range (SMDR_REAL yb_range_hi);
void SMDR_Check_ytau_Range (SMDR_REAL ytau_range_hi);
void SMDR_Check_g3_Range (SMDR_REAL g3_range_lo, SMDR_REAL g3_range_hi);
void SMDR_Check_g_Range (SMDR_REAL g_range_lo, SMDR_REAL g_range_hi);
void SMDR_Check_gp_Range (SMDR_REAL gp_range_lo, SMDR_REAL gp_range_hi);
void SMDR_Check_Mhpole_Range (SMDR_REAL Mhpole,
SMDR_REAL Mh_range_lo,
SMDR_REAL Mh_range_hi);
void SMDR_Check_Mtpole_Range (SMDR_REAL Mtpole,
SMDR_REAL Mt_range_lo,
SMDR_REAL Mt_range_hi);
These functions performs sanity checks for the Standard Model MSbar
parameters g3, g, gp, lambda, yb, ytau, v, Q. If out of range, a
warning message is printed (but execution is not halted).
---------------------------------------------------------------------
void SMDR_Eval_thZW_pole (void);
Computes the complex pole masses of the top quark, Higgs boson, Z
boson, and W bozon, and stores the results in the global variables:
Mt_pole, Gammat_pole
Mh_pole, Gammah_pole
MZ_pole, GammaZ_pole, MZ_BreitWigner, GammaZ_BreitWigner
MW_pole, GammaW_pole, MW_BreitWigner, GammaW_BreitWigner
Works by calling the functions SMDR_Eval_Mt_pole(),
SMDR_Eval_Mh_pole(), SMDR_Eval_MZ_pole(), and SMDR_Eval_MW_pole(). In
each case, the maximum available loopOrder is used.
The input parameters are the Standard Model MSbar global variables
inputs:
Q_in, g3_in, g_in, gp_in, yt_in, ..., v_in.
---------------------------------------------------------------------
void SMDR_Eval_QCDQED_at_MZ (SMDR_REAL Q_MZ,
SMDR_REAL Q_dec_thZW,
int loopOrder);
Computes the MSbar couplings and masses in the 5-quark,
3-charged-lepton QCD+QED effective theory, at the scale Q_MZ, taking
t, h, Z, W to be decoupled at Q_dec_thZW. The RG running is evaluated
at loopOrder = 1, 2, 3, 4, or 5.
The input parameters are the Standard Model MSbar global variables
inputs:
Q_in, g3_in, g_in, gp_in, yt_in, ..., v_in.
The results are put in the global variables:
alphaS_5_MZ, alpha_5_MZ, m_53, with
fermion = b, c, s, d, u, tau, muon, electron.
---------------------------------------------------------------------
void SMDR_Make_Accelcoeffs ();
Evaluates coefficients that allow for accelerated convergence of the
iteration process in SMDR_Fit_Inputs(), and stores them in the file
src/accelcoeffs.h. This function is called by the command line program
./make_coeffs
It should only be necessary to run this when a new version of SMDR is
being prepared involving a different version of the reference model in
ReferenceModel.dat.
---------------------------------------------------------------------
void SMDR_Error (char *funcName, char *errMsg, int status);
Prints a message of the form:
ERROR (funcName): errMsg
and exits with status code status. A stack trace is also printed for
diagnostic purposes. SMDR error messages appear on stdout by default,
so they are seen even if warnings have been disabled or redirected.
---------------------------------------------------------------------
void SMDR_Warn (char *, char *);
Prints a message of the form:
WARN (funcName): errMsg
and execution continues. SMDR warnings appear on stderr so they can be
redirected by the shell or otherwise suppressed, e.g., by
fclose (stderr);
---------------------------------------------------------------------
SMDR_REAL SMDR_SGNSQRT (SMDR_REAL x);
Returns sgn(x) sqrt(|x|).
---------------------------------------------------------------------
void SMDR_Start_Timer (void);
double SMDR_Timer (void);
Functions related to timing. See sample programs for usage.
---------------------------------------------------------------------
int SMDR_Process_Arguments (int argc,
char *argv[],
int nargs,
char *arglist[],
char *argtype[],
void *argvar[]);
Simple utility to process command line arguments. The arguments and
their types are defined in the calling program, and passed in via the
variables:
nargs
-----
The total number of defined arguments, equal to the sum of the number
of required arguments and the number of possible optional arguments.
arglist
-------
A list of strings (of dimension nargs) specifying the
arguments. *Required* arguments must come first, and are given in a
specified order that cannot be modified. A required argument is
indicated with "req". After all required args are given, the arglist
entries should define a set of flags that begin with '-'. Each of
these specifies an *optional* argument. As an example, if there are
three required arguments and two optional ones, then arglist might
look like this:
char arglist[] = {"req","req","req","-a","-i"};
In this case the two optional argw would be specified on the command
line as
[-a [-i ]]
Optional arguments can be given in any order on the commad line, but
the flags specified here must match up with the correspondng elements
in the following arrays that define them.
argtype
-------
An array of strings (of dimension nargs) defining the types of the
arguments, in order. Allowed type strings are currently "real", "int",
"string", and "toggle". As an example,
char argtype[] = {"string","int","real","real","string"};
Type "toggle" is used for an argument that acts as a toggle, i.e.,
without an associated value.
argvar
------
This is an array of pointers-to-void (of dimension nargs), to data
objects in the calling program to which the read values should be
assigned. As an example,
void argvar[] = {inFile, &i, &x, &Q, outFile};
would assign the first argument in the variable inFile, the second in
the variable i, and so on. Note that no ampersand is required for
"string"-type variables.
For arguments of type "toggle", the assigned variable should normally
be of type int. The effect of including the toggle will be to set
this int to 1 (YES).
As another example, for three optional arguments corresponding to an
input filename, and output filename, and a real error tolerance, one
could specify:
int nargs = 3;
char *arglist[] = {"-e","-i","-o"};
char *argtype[] = {"real","string","string"};
void *argvar[] = {&ERROR_TOLERANCE, inputFile, outputFile};
Users should be sure to specify default values for all optional
arguments in the calling program.
Some simple tests for errors are included, but these are probably not
bulletproof. Caveat emptor!
---------------------------------------------------------------------
==== INPUT/OUTPUT ====
---------------------------------------------------------------------
int SMDR_Read_MSbar_Inputs (char *fileName);
Reads the values of the following set of MSbar inputs from a file:
SMDR_Q_in
SMDR_g3_in
SMDR_gp_in
SMDR_g_in
SMDR_yt_in
SMDR_yb_in
SMDR_yc_in
SMDR_ys_in
SMDR_yu_in
SMDR_yd_in
SMDR_ytau_in
SMDR_ymu_in
SMDR_ye_in
SMDR_lambda_in
Note that the quantities:
SMDR_v_in, SMDR_m2_in, SMDR_Lambda_in, and SMDR_Delta_alpha_had_5_MZ_in
are not read in by this function. This is because they are not always
needed by all applications. They should be read in separately using
SMDR_Read_Value() or SMDR_Read_Values(), described below.
The file format should be as in ReferenceModel.dat, although the lines
can be in any order, the trailing semicolons can be included or not,
and any line starting with a '#' is treated as a comment. Blank lines
are ignored.
If any of the listed variables are not found, they are listed and a
fatal error results.
---------------------------------------------------------------------
int SMDR_Read_OS_Inputs (char *fileName);
Reads the values of the following on-shell observables from a file:
SMDR_Delta_alpha_had_5_MZ_in
SMDR_Mt_pole
SMDR_Mh_pole
SMDR_MZ_BreitWigner
SMDR_GFermi
SMDR_alpha
SMDR_alphaS_5_MZ
SMDR_mbmb
SMDR_mcmc
SMDR_ms_2GeV
SMDR_md_2GeV
SMDR_mu_2GeV
SMDR_Mtau_pole
SMDR_Mmuon_pole
SMDR_Melectron_pole
The file format should be as in ReferenceModel.dat, although the lines
can be in any order, the trailing semicolons can be included or not,
and any line starting with a '#' is treated as a comment. Blank lines
are ignored.
If any of the listed variables are not found, they are listed and a
fatal error results.
---------------------------------------------------------------------
int SMDR_Get_Value (FILE *file, char *varName);
Searches the file stream file for the variable varName, and sets the
corresponding SMDR variable to the value found. If the value is not
found, a warning is issued.
The list of variables that may be searched can be found in
src/smdr_ioparameters.h
---------------------------------------------------------------------
int SMDR_Read_Value (char *fileName, char *varName);
Reads from a file a single input value with the name specified by the
character string varName. Here, varName can be "SMDR_Q_in",
"SMDR_g3_in", etc.
If the specified variable is not found in fileName, a fatal error
results.
The list of variables that may be searched can be found in
src/smdr_ioparameters.h
---------------------------------------------------------------------
int SMDR_Read_Values (char *fileName, int n, char *listOfNames[]);
Reads from a file a set of n input values with the name specified by
the array of strings listOfNames. Here, elements of the array
listOfNames can be "SMDR_Q_in", "SMDR_g3_in", etc.
If any of the specified variables is not found in fileName, a fatal error
results.
The list of variables that may be searched can be found in
src/smdr_ioparameters.h
---------------------------------------------------------------------
int SMDR_Set_Values_Interactively (int, char *listOfNames[]);
A simple function that takes an integer number of variables and a list
of their names, and steps through the list, printing the current value
of each to stdout and prompting the user for a new value.
The list of variables that may be set interactively can be found in
src/smdr_ioparameters.h
---------------------------------------------------------------------
int SMDR_Read_Model_File (char *fileName);
Reads a complete input file specifying a model. Format should be as in
ReferenceModel.dat, although the lines can be in any order, the
trailing semicolons can be included or not, and any line starting with
a '#' is treated as a comment.
If any of the MSbar lagrangian or on-shell parameters are not found in
the file, the missing variables are listed and a fatal error results.
See ReferenceModel.dat for a complete listing of what constitutes a
model file.
---------------------------------------------------------------------
int SMDR_Write_Model_File (char *fileName);
Writes a model file in the same format as ReferenceModel.dat, using the
current values of the MSbar inputs and the observable outputs. The
resulting file can be used as an alternative input file for any
application that could have used ReferenceModel.dat.
---------------------------------------------------------------------
void SMDR_Write_Column_Data (FILE *,
int n,
char *strings[],
char *prepend);
This utility prints a pre-defined array of strings to a file stream,
with a prepended character. See the files applications/fig_*.c for
examples of its use.
---------------------------------------------------------------------
---------------------------------------------------------------------
For the remaining seven function pairs, the first form (*_Display_*)
prints to stdout. The second (*_Write_*) prints to a general file
stream, and prepends a string to each line. Thus, e.g.,
SMDR_Display_MSbar_Parameters ()
is equivalent to
SMDR_Write_MSbar_Parameters (stdout, "");
To write values to a file pointer fp with a prepending '#', use e.g.
SMDR_Write_MSbar_Parameters (fp, "# ");
---------------------------------------------------------------------
---------------------------------------------------------------------
void SMDR_Display_MSbar_Parameters (void);
void SMDR_Write_MSbar_Parameters (FILE *file, char *prepend);
Print the current scale Q and Standard Model MSbar working parameters
SMDR_g3, SMDR_g, SMDR_gp,
SMDR_yt, SMDR_yb, SMDR_ytau,
SMDR_yc, SMDR_ys, SMDR_ymu
SMDR_yu, SMDR_yd, SMDR_ye
SMDR_lambda
Note that SMDR_v, SMDR_m2, SMDR_Lambda, and SMDR_Delta_alpha_had_5_MZ
are not included here, and have their own separate Write and Display
functions, described below.
---------------------------------------------------------------------
void SMDR_Display_OS_Inputs (void);
void SMDR_Write_OS_Inputs (FILE *fileName, char *prepend);
Print the Standard Model on-shell input parameters.
---------------------------------------------------------------------
void SMDR_Display_Delta_alpha_had5 (void);
void SMDR_Write_Delta_alpha_had5 (FILE *, char *);
Print the value of SMDR_Display_Delta_alpha_had5.
---------------------------------------------------------------------
void SMDR_Display_Lambda (void);
void SMDR_Write_Lambda (FILE *, char *);
Print the working value of SMDR_Lambda.
---------------------------------------------------------------------
void SMDR_Display_m2 (void);
void SMDR_Write_m2 (FILE *, char *);
Print the working value of SMDR_m2.
---------------------------------------------------------------------
void SMDR_Display_v (void);
void SMDR_Write_v (FILE *, char *);
Print the working value of SMDR_v.
---------------------------------------------------------------------
void SMDR_Display_Version ();
void SMDR_Write_Version (FILE *, char *);
Print SMDR name and current version.
*********************************************************************
V. Sample Program
*********************************************************************
Below is a code fragment that illustrates the use of SMDR. It is based
on the code applications/calc_all.c, provided with the distribution.
#include "smdr.h" /* Required for all applications of SMDR. Headers
for TSIL and 3VIL are also included
automatically. */
int main (int argc, char *argv[])
{
char inputFile[50], outputFile[50];
int do_Veff, interactiveMode;
/* Here is the list of input variables to be read inm consisting of
the basic MSbar parameters plus SMDR_v_in and
SMDR_Delta_alpha_had_5_MZ_in: */
int nVars = 16;
char *varList[] = {
"SMDR_Q_in",
"SMDR_v_in",
"SMDR_lambda_in",
"SMDR_g3_in",
"SMDR_g_in",
"SMDR_gp_in",
"SMDR_yt_in",
"SMDR_yb_in",
"SMDR_yc_in",
"SMDR_ys_in",
"SMDR_yu_in",
"SMDR_yd_in",
"SMDR_ytau_in",
"SMDR_ymu_in",
"SMDR_ye_in",
"SMDR_Delta_alpha_had_5_MZ_in"
};
/* Define possible command line arguments. In this case there are
four, all optional. The first and last are of type "toggle", so
that if specified the corresponding variable will be set equal to
1. There are also two "string" type arguments, corresponding to
posssible input and output files. The final array holds pointers
to the variables that will be set. */
int nargs = 4;
char *arglist[] = {"-V","-i","-o","-int"};
char *argtype[] = {"toggle","string","string","toggle"};
void *argvar[] = {&do_Veff, inputFile, outputFile, &interactiveMode};
/* Users should be sure to set default values for any optional
arguments: */
do_Veff = 0;
strcpy (inputFile, "ReferenceModel.dat");
strcpy (outputFile, "NULL");
interactiveMode = 0;
/* This processes the arguments and sets the corresponding values: */
SMDR_Process_Arguments (argc, argv, nargs, arglist, argtype, argvar);
/* If an outputFile has been specified, we will automatically set
-V: */
if (0 != strcmp ("NULL", outputFile)) do_Veff = 1;
/* Print version information: */
SMDR_Display_Version ();
/* Read in values from input file. If -i was not set, default is
"ReferenceModel.dat", in the current directory.
Note that in place of this one could equivalently eliminate the
declarations of nVars and varList above, and instead call:
SMDR_Read_MSbar_Inputs (inputFile);
SMDR_Read_Value (inputFile, "SMDR_v_in");
SMDR_Read_Value (inputFile, "SMDR_Delta_alpha_had_5_MZ_in");
*/
SMDR_Read_Values (inputFile, nVars, varList);
/* If -int was specified we are in interactive mode; offer the user
a chance to change any values by hand:
*/
if (interactiveMode)
SMDR_Set_Values_Interactively (nVars, varList);
/* (Definition of varLits allows all the parameters that were read
to also be modified interactively.) */
/* Copies input values into working variables; necessary before
displaying them. */
SMDR_Load_Inputs ();
printf("\nINPUT PARAMETERS read");
if (0 == interactiveMode) {
printf(" from \"%s\"", inputFile);
}
printf(":\n\n");
/* Print input values to stdout; */
SMDR_Display_MSbar_Parameters ();
SMDR_Display_v ();
SMDR_Display_Delta_alpha_had5 ();
SMDR_Start_Timer();
/* SMDR_Lambda and SMDR_m2 don't actually affect anything else, so
only compute them if they are asked for, since the
three-loop effective potential integrals are a speed bottleneck.
Otherwise just set them to 0.
*/
if (1 == do_Veff) {
SMDR_Lambda = 0;
SMDR_Lambda_in = SMDR_Lambda = -SMDR_Eval_Veffmin (-1, 3.5);
SMDR_m2_in = SMDR_m2;
} else {
SMDR_m2_in = SMDR_m2 = 0;
SMDR_Lambda_in = SMDR_Lambda = 0;
}
/* Evaluate top-quark pole mass. */
SMDR_Eval_Mt_pole (SMDR_Mt_EXPT, 1, 4, 2, &SMDR_Mt_pole,
&SMDR_Gammat_pole);
/* Evaluate Higgs boson pole mass. */
SMDR_Eval_Mh_pole (160., 2.5, &SMDR_Mh_pole, &SMDR_Gammah_pole);
/* Evaluate Z boson pole and Breit-Wigner masses */
SMDR_Eval_MZ_pole (160., 2, &SMDR_MZ_pole, &SMDR_GammaZ_pole,
&SMDR_MZ_BreitWigner, &SMDR_GammaZ_BreitWigner);
/* Evaluate GFermi */
SMDR_GFermi = SMDR_Eval_GFermi (SMDR_Mt_EXPT, 2);
/* Evaluate MSbar alpha(MZ), sin^2(thetaW), alphaS(MZ) in
non-decoupled theory, Sommerfeld fine structure constant alpha,
alpha(MZ) and sin^2(thetaW) in PDG MSbar scheme with only top
decoupled. */
SMDR_Eval_Gauge (SMDR_Mt_pole, SMDR_Mh_pole, SMDR_MW_BreitWigner);
/* Evaluate MSbar parameters in 5-quark, 3-lepton QCDQED theory at
MZ */
SMDR_Eval_QCDQED_at_MZ (SMDR_MZ_EXPT, SMDR_MZ_EXPT, 5);
printf("\nOUTPUT QUANTITIES:\n");
if (1 == do_Veff) {
printf("\n");
SMDR_Display_m2();
SMDR_Display_Lambda();
}
printf("\n");
printf("Mt = %Lf; Gammat = %Lf; (* complex pole *)\n\n",
SMDR_Mt_pole, SMDR_Gammat_pole);
printf("Mh = %Lf; Gammah = %Lf; (* complex pole *)]\n\n",
SMDR_Mh_pole, SMDR_Gammah_pole);
... etc. ...
SMDR_Timer();
printf("\nTotal calculation time: %.2f seconds\n", SMDR_Time_Total);
/* If an outputFile was specified, write a full model file: */
if (0 != strcmp (outputFile, "NULL"))
SMDR_Write_Model_File (outputFile);
return 0;
}
*********************************************************************
VI. C++ Linkage
*********************************************************************
The SMDR library functions are all callable "as is" from C++ code. The
header file smdr.h must of course still be included in any C++ source
code that makes use of SMDR.
Some of the utilities that take or use string arguments may produce
(harmless) compiler warnings if string literals are used. This is
because the C++ type for a string literal is slightly different (const
char[]) than in C (char *). These warnings can be avoided by
explicitly casting the C++ strings to type (char *). The sample code
C++/calc_all.cpp shows this approach in action. Note, however, that
the source file applications/calc_all.c will compile just fine under
C++ (albeit with warnings). Indeed, calc_all.cpp is identical to
calc_all.c as far as SMDR usage is concerned; only the headers and IO
statements have been re-written in a C++ idiom.
*********************************************************************
End of README.txt
*********************************************************************