Himalaya

Himalaya calculates three-loop corrections of order O((αt + αb)*αs^2)
to the MSSM CP-even Higgs mass matrix and to the quartic Higgs
coupling λ in the DR’-bar scheme using the results of:

R. V. Harlander, P. Kant, L. Mihaila and M. Steinhauser, Higgs
boson mass in supersymmetry to three loops, Phys. Rev. Lett.
100 (2008) 191602,
[0803.0672],
P. Kant, R. V. Harlander, L. Mihaila and M. Steinhauser, Light MSSM
Higgs boson mass to three-loop accuracy, JHEP 08 (2010)
104104),
[1005.5709].

Please refer to these papers as well as

R. V. Harlander, J. Klappert and A. Voigt, Higgs mass prediction in
the MSSM at three-loop level in a pure DR context, Eur.Phys.J.
C77 (2017) no.12, 814,
[1708.05720],
R. V. Harlander, J. Klappert, A. D. Ochoa Franco and A. Voigt,
The light CP-even MSSM Higgs mass resummed to fourth logarithmic order,
Eur.Phys.J. C78 (2018) no.10, 874,
[1807.03509]
R. V. Harlander, J. Klappert, and A. Voigt,
The light CP-even MSSM Higgs mass including N3LO+N3LL QCD corrections,
Eur.Phys.J. C80 (2020) no.3, 186,
[1910.03595]

when using Himalaya.

Requirements

Himalaya requires:

C++ compiler
FORTRAN compiler
CMake >= 3.1
Eigen3

Building Himalaya

Installation of dependencies

The required Eigen library can be installed using the package manager
of your Linux distribution. On Debian/Ubuntu, for example, one may
run:

sudo apt-get install libeigen3-dev

Alternatively, the Conan package manager can be
used to install the dependencies:

mkdir -p build
cd build
conan install ..

Compilation of Himalaya

Himalaya uses CMake to generate files for build automation. To build
Himalaya one should first create a separate build directory inside
Himalaya’s top directory. Afterwards, cmake should be called:

mkdir -p build
cd build
cmake ..

cmake will search for required dependencies on your system, see the
previous section. If you want to use the dependencies installed by
Conan (see above), you need to run instead:

cmake .. -DCMAKE_TOOLCHAIN_FILE=./conan_paths.cmake

After calling cmake the build directory contains all required build
files. Assuming that GNU make is used, one can start the build by running

make

By default the example executable example is created from
examples/example.cpp, which prints all loop
corrections calculated by Himalaya for a given MSSM parameter point:

./example

Running Himalaya

When the build is complete, the libraries libDSZ and libHimalaya
have been created. The latter must be linked to user-written programs
to call the routines of Himalaya. The library libDSZ is optional
and has to be linked in addition, if the program does not already
incorporate the associated FORTRAN code of P. Slavich for the 2-loop
corrections [hep-ph/0105096,
hep-ph/0112177,
hep-ph/0212132,
hep-ph/0305127].

C++ interface

We present a brief step by step guide how to run Himalaya at the C++
level and obtain the three-loop corrections to the CP-even Higgs mass
matrix in the MSSM in the DR’-bar scheme and the quartic Higgs
coupling of the Standard Model in the MS-bar scheme.

First one has to include the header

#include "himalaya/HierarchyCalculator.hpp"

in the C++ file. The MSSM DR’-bar parameters must be stored in a
Parameters object. Here, an example for the SPS1a benchmark point
is given:

himalaya::Parameters pars;           // DR'-bar parameters struct
pars.scale = 4.67491329E+02;         // renormalization scale
pars.mu = 3.52600579E+02;            // mu parameter
pars.g3 = 1.09949966E+00;            // gauge coupling g3 SU(3)
pars.vd = 2.49832484E+01;            // VEV of down Higgs doublet
pars.vu = 2.43650538E+02;            // VEV of up Higgs doublet
pars.mq2 << 2.99793928E+05, 0, 0,
            0, 2.99792102E+05, 0,
            0, 0, 2.49327504E+05;    // soft-breaking squared left-handed squark mass parameters
pars.md2 << 2.78275669E+05, 0, 0,
            0, 2.78273780E+05, 0,
            0, 0, 2.74928741E+05;    // soft-breaking squared right-handed down-squark mass parameters
pars.mu2 << 2.80477426E+05, 0, 0,
            0, 2.80475621E+05, 0,
            0, 0, 1.80478484E+05;    // soft-breaking squared right-handed up-squark mass parameters
pars.Ad << 0, 0, 0,
           0, 0, 0,
           0, 0, -784.3356416708631; // trilinear down type squark-Higgs coupling matrix
pars.Au << 0, 0, 0,
           0, 0, 0,
           0, 0, -527.8746242245387; // trilinear up type squark-Higgs coupling matrix
pars.MA = 3.92960954E+02;            // Mass of the CP-odd Higgs
pars.MG = 5.88220143E+02;            // Mass of the Gluino
pars.MW = 8.04136643E+01;            // Mass of the W boson
pars.MZ = 9.06817306E+01;            // Mass of the Z boson 
pars.Mt = 1.52117491E+02;            // Mass of the top quark
pars.Mb = 2.42010269E+00;            // Mass of the bottom quark
pars.Mtau = 1.777;                   // Mass of the tau lepton

Afterwards one can create a HierarchyCalculator object for the
chosen parameter point:

himalaya::HierarchyCalculator hc(pars);

To calculate the loop corrections in the DR’-bar scheme one needs to
call:

// the boolean argument switches between corrections proportional to αt (false) or αb (true)
himalaya::HierarchyObject ho = hc.calculateDMh3L(false);

All information which has been gathered during the calculation will be
stored in the returned HierarchyObject and can be accessed by member
functions.

To extract the three-loop correction to the Higgs mass matrix one
needs to call:

// returns a 2x2 matrix with the αt*αs^2 correction for the given parameter point
auto dMh3L = ho.getDMh(3);

To extract the three-loop correction to the quartic Higgs coupling λ of
the Standard Model in the DR’-bar scheme in the convention of
[1407.4081] one needs to call

double delta_lambda_3L = ho.getDLambda(3);

The three-loop shift to the MS-bar scheme, ocurring when the one- and
two-loop corrections are expressed in terms of the Standard Model
MS-bar strong gauge and top Yukawa couplings can be obtained by
calling ho.getDLambdaDRbarPrimeToMSbarShift(3).

An uncertainty estimate of the calculated three-loop λ due to the
truncation of the mass hierarchy expansions can be obtained by calling

double delta_lambda_3L_uncertainty = ho.getDLambdaUncertainty(3);

A full and detailed example can be found in
examples/example.cpp.

Example:

#include "himalaya/HierarchyCalculator.hpp"
#include <iostream>
#include <cmath>
himalaya::Parameters setup_point(double MS, double tb, double xt)
{
   himalaya::Parameters pars;
   const double MS2 = MS*MS;
   const double Xt = xt*MS;
   const double beta = std::atan(tb);
   pars.scale = MS;
   pars.mu = MS;
   pars.g1 = 0.46;
   pars.g2 = 0.65;
   pars.g3 = 1.166;
   pars.vd = 246*std::cos(beta);
   pars.vu = 246*std::sin(beta);
   pars.mq2 << MS2, 0, 0,
               0, MS2, 0,
               0, 0, MS2;
   pars.md2 << MS2, 0, 0,
               0, MS2, 0,
               0, 0, MS2;
   pars.mu2 << MS2, 0, 0,
               0, MS2, 0,
               0, 0, MS2;
   pars.ml2 << MS2, 0, 0,
               0, MS2, 0,
               0, 0, MS2;
   pars.me2 << MS2, 0, 0,
               0, MS2, 0,
               0, 0, MS2;
   pars.Au << 0, 0, 0,
              0, 0, 0,
              0, 0, Xt + pars.mu/tb;
   pars.Ad << 0, 0, 0, 0, 0, 0, 0, 0, 0;
   pars.Ae << 0, 0, 0, 0, 0, 0, 0, 0, 0;
   pars.Yu << 0, 0, 0, 0, 0, 0, 0, 0, 0.862;
   pars.Yd << 0, 0, 0, 0 ,0 ,0 ,0 ,0, 0.133;
   pars.Ye << 0, 0, 0, 0, 0, 0, 0, 0, 0.101;
   pars.MA = MS;
   pars.M1 = MS;
   pars.M2 = MS;
   pars.MG = MS;
   pars.validate(true);
   return pars;
}
int main()
{
   const auto point = setup_point(2000., 20., std::sqrt(6.));
   himalaya::HierarchyCalculator hc(point);
   try {
      // calculate the 3-loop corrections O(α_t*α_s^2)
      const auto ho = hc.calculateDMh3L(false);
      // extract 2x2 matrix with three-loop O(αt*αs^2) corrections
      const auto dMh3L = ho.getDMh(3);
      // extract three-loop O(αt*αs^2) correction to λ (DR'-bar scheme)
      const double delta_lambda_3L_DR = ho.getDLambda(3);
      // extract uncertainty estimate
      const double delta_lambda_3L_uncertainty = ho.getDLambdaUncertainty(3);
      // convert to MS-bar scheme
      const double delta_lambda_3L_MS =
         delta_lambda_3L_DR + ho.getDLambdaDRbarPrimeToMSbarShift(3);
      std::cout << "Δλ(3-loop,DR') = " << delta_lambda_3L_DR
                << " +- " << delta_lambda_3L_uncertainty << '\n'
                << "Δλ(3-loop,MS) = " << delta_lambda_3L_MS
                << " +- " << delta_lambda_3L_uncertainty << '\n';
   } catch (const std::exception& e) {
      std::cerr << e.what() << '\n';
   }
   return 0;
}

Output:

Himalaya info: Δλ(3-loop,DR') = 0.000315613 +- 0.00203118
Himalaya info: Δλ(3-loop,MS) = -0.000455415 +- 0.00203118

Mathematica interface

Since version 2.0.0 Himalaya can be run from within Mathematica using
the LibraryLink interface. To load Himalaya into a Mathematica
session, first, the file
source/himalaya/LibraryLink/Himalaya_LibraryLink.m
must be loaded, which defines the Himalaya’s Mathematica interface
functions. Assuming the current directory is the build/
sub-directory of Himalaya, loading Himalaya_LibraryLink.m may be
done by calling

Get[FileNameJoin[{"..", "source", "himalaya", "LibraryLink", "Himalaya_LibraryLink.m"}]];

Afterwards, the LibraryLink Himalaya_LibraryLink.so must be loaded
using the InitializeHimalaya[] function:

InitializeHimalaya[FileNameJoin[{".", "Himalaya_LibraryLink.so"}]];

After the initialization, the function HimalayaCalculateDMh3L[] is
available, which calculates the loop corrections implemented in
Himalaya. A full and detailed example can be found in
examples/example.m.

Example:

Get[FileNameJoin[{"..", "source", "himalaya", "LibraryLink", "Himalaya_LibraryLink.m"}]];
InitializeHimalaya[FileNameJoin[{".", "Himalaya_LibraryLink.so"}]];
MS = 2000;
TB = 20;
Xt = Sqrt[6] MS;
result = HimalayaCalculateDMh3L[
   settings -> {
       bottom -> False,
       loopOrder -> 3,
       verbose -> True
   },
   parameters -> {
       scale -> MS,
       mu -> MS,
       g1 -> 0.46,
       g2 -> 0.65,
       g3 -> 1.166,
       vd -> 246*Cos[ArcTan[TB]],
       vu -> 246*Sin[ArcTan[TB]],
       mq2 -> MS^2 IdentityMatrix[3],
       md2 -> MS^2 IdentityMatrix[3],
       mu2 -> MS^2 IdentityMatrix[3],
       ml2 -> MS^2 IdentityMatrix[3],
       me2 -> MS^2 IdentityMatrix[3],
       Au -> {{0,0,0},
              {0,0,0},
              {0,0, Xt + MS/TB }},
       Ad -> 0 IdentityMatrix[3],
       Ae -> 0 IdentityMatrix[3],
       Yu -> {{0,0,0},
              {0,0,0},
              {0,0, 0.862 }},
       Yd -> {{0,0,0},
              {0,0,0},
              {0,0, 0.133 }},
       Ye -> {{0,0,0},
              {0,0,0},
              {0,0, 0.101 }},
       MA -> MS,
       M1 -> MS,
       M2 -> MS,
       M3 -> MS
   }
]

The result contains a list with replacement rules for all loop
corrections:

{ hierarchyID -> 1, hierarchyName -> h32q2g, 
  MstopMDRPrime -> {1807.42, 2176.21}, 
  Mh2 -> {
    {{3.99005*10^6, -199916.}, {-199916., 18267.1}},
    {{-639.597, 38.1108}, {38.1108, 10354.7}},
    {{-2.06776, 47.4491}, {47.4491, 1872.69}},
    {{-4.18629, 26.4403}, {26.4403, 695.96}}
  },
  Mh2ShiftDRbarPrimeToMDRPrime -> {
    {{0., 0.}, {0., 0.}},
    {{0., 0.}, {0., 0.}},
    {{0., 0.}, {0., 0.}},
    {{-0.0655621, 6.45183}, {6.45183, -47.4757}}
  },
  Mh2ShiftDRbarPrimeToH3m -> {
    {{0., 0.}, {0., 0.}},
    {{0., 0.}, {0.,  0.}},
    {{0., 0.}, {0., 0.}},
    {{-1.53177, 1.95573}, {1.95573, 7.44666}}
  },
  expansionUncertainty -> {0., 0., 0.29937, 0.0298342},
  Mh2EFTAt -> {8230.07, 10337.5, 830.688, 695.611},
  Mh2FO -> {8229.9, 8148.24, 819.187, 696.836},
  Mh2FOAt -> {0., 10331.8, 820.621, 696.836},
  lambda -> {0.135998, 0.0625136, 0.00149099, 0.000315613},
  lambdaUncertainty -> {0., 0., 0., 0.00203118},
  lambdaShiftDRbarPrimeToMSbar -> {0., 0., 7.28983 10^-6  , -0.000771028} }

See ?HimalayaCalculateDMh3L for a detailed documentation of the
input and output.

Code Documentation

The Himalaya source code documentation can be found online at
https://himalaya-library.github.io.

The source code documentation can also be generated using Doxygen.
To generate the documentation, run

make doc

The generated documentation can be found in doc/html/index.html.