This code calculates the SUSY and Higgs particle spectrum in the unconstrained Minimal Supersymmetric Standard Model (MSSM), as well as in constrained models (cMSSMs) such as the minimal Supergravity (mSUGRA), the gauge mediated (GMSB) and anomaly mediated (AMSB) Supersymmetry breaking scenarii. All important features and ingredients are included:
  • renormalization group evolution between low and high energy scales,
  • consistent implementation of radiative electroweak symmetry breaking,
  • calculation of the physical particle masses with radiative corrections.

Practical SuSpect3

Information on installation, download and the use of SuSpect3 with different types of input is provided in the following sections.

Dowload and Installation

To download SuSpect3, either by clicking on the link on the page or in the directory where you want to install it:

To install SuSpect3:

  tar xvfz suspect3.tar.gz
The executable is suspect3 which can be run with an input file, e.g.:

  ./suspect3 -d examples/
resulting in the output of the SLHA blocks on std.

Further command line options are available with:

./suspect3 -h
Two examples:
  • -o outputFILENAME: to write the output to the file with name outputFILENAME instead of the terminal window
  • -s: silent running suppresses the output of the spectrum to the terminal window

Interfacing SuSpect3

SuSpect3 can be interfaced and run in other codes:
  1. Link the suspect library in lib subdirectory lib to your code
  2. Add the suspect.h include file
  3. Create the suspect object
  4. Run the spectrum calculation

Spectrum Calculation

In a nutshell the code will be:

#include "suspect.h"
  SUSPECT::suspect aSuspectCalculation;
The method Run takes up to three arguments, only the first one has to be provided:
  1. aSuspectCalculation.Run(inputFILENAME)
    • Spectrum calculated from the SLHA input provided in the file with the name inputFILENAME (std::string)
    • The standard SLHA blocks are output
    • The output is written to the terminal window.
  2. aSuspectCalculation.Run(inputFILENAME,iverbose)
    • Spectrum calculated from the SLHA input provided in the file with the name inputFILENAME (std::string)
    • (unsigned int) iverbose = 1: The standard SLHA blocks are output to the terminal window (default), =0 no output (silent)
    • The output is written to the terminal window.
  3. aSuspectCalculation.Run(inputFILENAME,iverbose,outputFILENAME)
    • Spectrum calculated from the SLHA input provided in the file with the name inputFILENAME (std::string)
    • (unsigned int) iverbose = 1: The standard SLHA blocks are output to the terminal window (default), =0 no output (silent)
    • The output is written to the file with the name outputFILENAME (std::string) default is to terminal with an empty string ""

Initialization in Memory

Specifying the input only in an ascii file can be tedious in particular when scanning a large parameter space, therefore SuSpect3 provides also the possibility to drive the spectrum calculation from memory. To keep things simple the method Run is overloaded to accept an object (or a pointer) of type SUSPECT::SLHA4suspect as first argument:
  1. aSuspectCalculation.Run(SLHA4suspectObject,....)
  2. aSuspectCalculation.Run(*SLHA4suspectObject)
    1. The two other (optional) arguments are the same as for the std::string filename input. If an SUSPECT::SLHA4suspect object is given as input, the object is copied internally and not modified. Therefore when scanning over a parameter range the same input object can be used and only the parameter(s) to be changed have to be modified. The SLHA4suspectObject is instantiated:
        SUSPECT::SLHA4suspect *slha4suspectInitial        = new SUSPECT::SLHA4suspect();
      or as an object instead of a pointer. The SuSpect3 specific input block and the SMINPUTS block can be set to sensible defaults:
      and the usual common blocks can be initialized with:
      where index is the SLHA (unsigned int) index and value is its value in (double) precision.

Spectrum Output

After a spectrum calculation has been performed, it is necessary to retrieve the output. Since the input object is copied, the SUSPECT::SLHA4suspect object has to be retrieved:

  SUSPECT::SLHA4suspect *SLHAoutput =aSuspectCalculation.SLHAblock(); 
To save the output for further use, a new calculation of the spectrum will reset the output as it is provided as a pointer, the assignement operator can be used:

  SUSPECT::SLHA4suspect SLHAoutput = *aSuspectCalculation.SLHAblock(); 
or alternatively the copy constructor:

  SUSPECT::SLHA4suspect SLHAoutput = SUSPECT::SLHA4suspect(*aSuspectCalculation.SLHAblock()); 
Access to the SLHA output is provided via methods which are simply the capitalized names of the SLHA blocks, e.g.:

  SLHAoutput->NMIX(index1, index2);
where the argument is the SLHA index as unsigned int. These functions return the value of the index or pair of indicies as a double.

The number of scales of the model and their values can be retrieved from MSOFT:

  unsigned int numberOfScales = SLHAout->MSOFTNbOfScales();
  std::vector <double> scales = SLHAout->MSOFTScales();
This is particularly useful for the EWSB or the GUT scale when their values are determined during the spectrum calculation. For the scale dependent blocks, the scale must be provided as the last argument:

Internally the block with a scale within 10-6 of the requested scale is given. For a simpler access, though less intuitive, the index of the scale in the vector provided by SLHAout->MSOFTScales() can also be used:

In general the scales are in rising order, e.g., mSUGRA:
Scale Index
Z boson0
However user settings may change this, in particular for the high scale MSSM. Therefore we recommend to check the order.


A fully coded example of in memory initialization and scanning a parameter is available for download here.

Mixed Input

The use of the RUN method is not compulsory, you may also use independently methods provided by the suspect object. One use case could be to read the initial values for a scan from an SLHA file with name FILENAME and then perform the scan:

  // set up the input:
  SUSPECT::SLHA4suspect SLHAinput; 
  // set the defaults for the block SMINPUTS
  // read the SLHA file
  // choose a different m0
  SLHAinput.setMINPAR(1, 901.);

  // now create SUSPECT:
  SUSPECT::suspect myS3;

  SUSPECT::SLHA4suspect *SLHAout = myS3.SLHAblock();
  std::cout << "the Higgs boson mass is " << SLHAout->MASS(25) << std::endl;
  SLHAinput.setMINPAR(1, 920.);
  SLHAout = myS3.SLHAblock();
  std::cout << "the Higgs boson mass is " << SLHAout->MASS(25) << std::endl;
The SLHA4suspect object reads the SLHA file, then the input can eb modified. SLHA4suspect is an empty structure, so the Standard Model masses have to be set via setSMINPUTSDefault. The default values can be overwritten.