PaperlayerView exact revision on arXiv

Source-linked AI summary

FlexibleSUSY -- A spectrum generator generator for supersymmetric models

Peter Athron, Jae-hyeon Park, Dominik Stöckinger, Alexander Voigt

arXiv:1406.2319v3hep-ph

TL;DR

FlexibleSUSY addresses the challenge of constructing fast spectrum generators for diverse supersymmetric models. It uses SARAH, Mathematica, and C++ to generate modular code and numerical solvers from model and boundary-condition files. The resulting generators run quickly, support many predefined models, and remain subject to explicit convergence and model-scope limitations.

  • Problem

    Constructing specialized spectrum generators for the many non-minimal SUSY models would require enormous effort, while spectra require solving coupled boundary conditions across scales.

  • Method

    FlexibleSUSY uses SARAH and user-provided model and boundary-condition files to generate modular C++ expressions and routines for RGEs, EWSB conditions, self-energies, tadpoles, and pole masses.

  • Results

    0.06–0.2 seconds per parameter point is typical, and speed tests found FlexibleSUSY faster than Softsusy, SPheno, and SARAH-generated MSSM code.

  • Takeaways & Limitations

    The modular two-level design enables custom spectrum generators, component reuse, and extensions such as additional RGEs, matching, and effective-theory model towers.

  • Takeaways & Limitations

    FlexibleSUSY currently assumes real couplings, supports only SUSY models with restricted gauge groups, and may struggle with extreme mass-scale hierarchies or nonconvergent fixed-point iterations.

Abstract

from arXiv · show

We introduce FlexibleSUSY, a Mathematica and C++ package, which generates a fast, precise C++ spectrum generator for any SUSY model specified by the user. The generated code is designed with both speed and modularity in mind, making it easy to adapt and extend with new features. The model is specified by supplying the superpotential, gauge structure and particle content in a SARAH model file; specific boundary conditions e.g. at the GUT, weak or intermediate scales are defined in a separate FlexibleSUSY model file. From these model files, FlexibleSUSY generates C++ code for self-energies, tadpole corrections, renormalization group equations (RGEs) and electroweak symmetry breaking (EWSB) conditions and combines them with numerical routines for solving the RGEs and EWSB conditions simultaneously. The resulting spectrum generator is then able to solve for the spectrum of the model, including loop-corrected pole masses, consistent with user specified boundary conditions. The modular structure of the generated code allows for individual components to be replaced with an alternative if available. FlexibleSUSY has been carefully designed to grow as alternative solvers and calculators are added. Predefined models include the MSSM, NMSSM, E$_6$SSM, USSM, R-symmetric models and models with right-handed neutrinos.

1. Program Summary

FlexibleSUSY generates fast spectrum generators for user-specified supersymmetric models by solving coupled boundary conditions across renormalization scales. It is designed for rapid numerical evaluation but assumes perturbative, CP-conserving models.

  • The package is distributed as a tar.gz program written in C++, Wolfram/Mathematica, FORTRAN, and Bourne shell.
  • 0.06–0.2 seconds per parameter point is the typical running time.
  • FlexibleSUSY determines supersymmetric mass spectra and mixings by solving constraints imposed at multiple renormalization scales connected by coupled RGEs.
  • FlexibleSUSY uses nested iteration and numerical minimization of the Higgs potential to solve the spectrum-generation problem.
  • The couplings must remain perturbative between the highest and lowest boundary conditions, and the generated code assumes real couplings.

2. Introduction

FlexibleSUSY addresses the need for fast, adaptable tools covering non-minimal supersymmetric models. Its modular generated code supports extensions and has been tested as a modern alternative to existing spectrum generators.

  • General tools are needed because constructing specialized spectrum generators for all non-minimal supersymmetric models would require enormous effort.
  • LHC searches increased interest in non-minimal SUSY models after expected low-energy signatures and other beyond-Standard-Model signals were not observed.
  • FlexibleSUSY uses Mathematica and C++ with SARAH to generate fast, modular spectrum generators for user-specified SUSY models.
  • The generated code is easy to modify, extend with new features, and combine with other programs.
  • The MSSM and NMSSM implementations provide modern, fast alternatives to existing public spectrum generators.

3. Overview of the program and design goals

FlexibleSUSY converts SUSY model and boundary-condition specifications into modular C++ spectrum generators that solve boundary-value problems and compute loop-corrected spectra. Its design emphasizes extensibility and speed, while retaining important model and solver limitations.

  • Users specify fields, superpotential, gauge symmetries, mixings, and boundary conditions, from which FlexibleSUSY generates masses, EWSB conditions, self-energies, tadpoles, and RGEs.
  • Generated algebraic expressions are organized into C++ classes with interfaces supporting module exchange, extension, and reuse.
  • The resulting routines solve the user-defined boundary-value problem and calculate pole masses using full one-loop self-energies, with leading two-loop Higgs contributions for MSSM and NMSSM.
  • FlexibleSUSY accelerates spectrum calculations by optimizing beta-function computations and multithreading pole-mass calculations for mixed particles.
  • The standard fixed-point solver is not guaranteed to converge throughout parameter space, motivating support for alternative solvers.
  • Current limitations include real couplings, SUSY-only models, semi-simple gauge groups containing the Standard Model, and difficulty with widely split mass scales.

4. Quick start

FlexibleSUSY supports quick creation of predefined and custom spectrum generators through configured dependencies and a short command sequence. The generated executable solves the CMSSM boundary-value problem and outputs pole masses and mixing data in SLHA format.

  • CMSSM workflow: Three commands create and compile a CMSSM spectrum generator, after which the resulting executable can be run with an SLHA input file.The model directory and specimen input are created first, configuration checks requirements and writes the Makefile, and make invokes Mathematica and compilation.
  • CMSSM workflow: The generator determines DR model parameters consistent with the CMSSM boundary conditions and writes pole masses and mixing matrices in SLHA format.The calculated spectrum includes particles such as the gluino, charginos, neutralinos, Higgs bosons, sleptons, squarks, and sneutrinos.
  • Predefined models: Predefined models include the MSSM, Z3-symmetric and Z3-violating NMSSM variants, USSM, E6SSM, MSSMRHN, NUHMSSM, and MRSSM.Spectrum generators for these models can be generated similarly to the CMSSM example.
  • Customization: Model boundary conditions can be customized by editing FlexibleSUSY model files, such as replacing unified trilinear couplings with a separate GUT-scale Aλ input.The modified value is supplied through the SLHA EXTPAR block entry 63.

5. Setting up a FlexibleSUSY model

A FlexibleSUSY model separates the SARAH description of the SUSY theory from the FlexibleSUSY file defining boundary conditions and solver settings. Users specify scales, inputs, EWSB outputs, and optional numerical procedures to generate a spectrum calculator.

  • Model definition: A SARAH model file defines the gauge group, fields, mixings, superpotential, and soft-breaking Lagrangian for a general SUSY model.The file is placed in sarah/<model>/ and supplies the theory information from which FlexibleSUSY constructs the generator.
  • Boundary conditions: Boundary conditions are defined separately in FlexibleSUSY.m, generated from a FlexibleSUSY.m.in template in model_files/<model>.The createmodel script places the generated file in models/<model>/ and supports selecting the model-file template explicitly.
  • Inputs: MINPAR and EXTPAR map SLHA block indices to non-Standard Model input parameters such as m0, M1/2, A0, tan β, and sign µ.Parameter settings can be literal values or values read from the SLHA input file with LHInput[value].
  • EWSB: EWSBOutputParameters identifies parameters adjusted until the electroweak symmetry-breaking conditions are fulfilled.Examples include µ and Bµ in the CMSSM and κ, |vs|, and m2_s in the NMSSM.
  • Scale constraints: FlexibleSUSY organizes the boundary-value problem around low-, SUSY-, and high-scale constraints, each with a scale definition, initial guess, and parameter settings.The high scale is commonly defined by g1 == g2, the SUSY scale imposes EWSB and calculates pole masses, and the low scale matches the SUSY model to Standard Model quantities.
  • Numerical conditions: Users can impose numerical minimization or root-finding conditions with FSMinimize and FSFindRoot, while initial parameter guesses can be supplied at the low and high scales.These functions vary selected parameters to minimize a function or drive a list of functions to zero.

6. Structure of the spectrum generator

FlexibleSUSY organizes generated spectrum-generator code around modular model classes, RG-evolution interfaces, and boundary-condition implementations. These components combine SARAH-derived expressions with numerical routines to solve constraints across scales and calculate spectra.

  • Generated model structure: SARAH-derived parameters, RGEs, mass matrices, self-energies, and EWSB equations are stored in a C++ model-class hierarchy.
  • RGE evolution: The Beta_function interface integrates RGEs between scales using adaptive Runge-Kutta evolution through get(), set(), and beta() methods.
  • Parameter organization: SUSY and soft-breaking parameters are separated into inherited classes because their β-functions have different parameter dependence.
  • Generated calculations: FlexibleSUSY algebraically generates one- and two-loop β-functions with SARAH and converts them into C++ beta() implementations.
  • Boundary conditions: Generated constraint classes impose high-scale, SUSY-scale, and low-scale conditions, including loop-level EWSB minimization and Standard Model matching.
  • Scope: FlexibleSUSY currently handles real model parameters, with global-sign parameters used to represent certain multiple EWSB solutions.

6.3. Tree-level spectrum

The spectrum calculation uses specified diagonalization conventions and an iterative multi-scale solver. The solver runs parameters between boundary-condition scales, applies constraints and EWSB conditions, and then computes pole masses when convergence is reached.

  • Tree-level spectrum: DR masses are obtained by diagonalizing SARAH-generated mass matrices with Eigen or LAPACK routines according to matrix type and size.
  • Diagonalization conventions: FlexibleSUSY uses orthogonal, singular-value, and unitary diagonalizations for scalar and Weyl-fermion mass matrices, choosing phases that yield positive masses.
  • Fixed-point iteration: The two-scale solver iteratively runs parameters between all boundary-condition scales, applies constraints, and checks convergence after each iteration.
  • Iteration steps: The iteration initializes low-scale parameters, imposes high-scale inputs, recalculates scales, applies SUSY-scale conditions, and solves loop-level EWSB equations.
  • Output spectrum: After convergence, the model parameters are known across the relevant scales and the pole-mass spectrum is calculated, with optional running to a chosen output scale.
  • Solver limitations: The solver is not guaranteed to converge, and failures may reflect either the absence of a physical solution or inability of fixed-point iteration to find one.

6.5. Pole masses

FlexibleSUSY offers three pole-mass calculation procedures that trade precision against execution time. HighPrecision is recommended for Higgs masses, while MediumPrecision can be sufficient for light sfermions; optional two-loop Higgs corrections extend the calculation.

  • Calculation procedures: FlexibleSUSY calculates pole masses from momentum-dependent one-loop mass matrices built from tree-level mass matrices and self-energies.The resulting mass matrices are diagonalized to obtain pole masses, with iterative momentum solving for the highest-precision procedure.
  • Calculation procedures: LowPrecision is fastest, MediumPrecision uses an approximation, and HighPrecision iterates over momentum to solve the pole-mass equation.The three settings can be selected globally or overridden for individual particles.
  • Precision trade-offs: HighPrecision is strongly recommended for Higgs pole masses because MediumPrecision differs by about 1.2 GeV for the lightest CP-even Higgs in the CMSSM comparison.The experimental Higgs-mass uncertainty is around 0.4 GeV, and LowPrecision is described as imprecise for this purpose.
  • Precision trade-offs: The lightest sfermion masses change by less than 0.3% across methods, so MediumPrecision can be used for them despite substantially higher HighPrecision runtime.The runtime for light sfermion multiplets increases by around a factor of 20 from LowPrecision to HighPrecision.
  • Two-loop corrections: Two-loop Higgs corrections can be enabled selectively, but several listed corrections were computed only in the MSSM and may not represent the leading terms in extended models.For models with more extended Higgs sectors, the authors recommend estimating leading-log two-loop corrections by generalizing MSSM or NMSSM results.

7. Flexible Applications

FlexibleSUSY supports model development at both the Mathematica and C++ levels. Users can modify boundary conditions, reuse existing model descriptions, extend particle content and interactions, and add or replace generated components.

  • Customization levels: Users can create custom spectrum generators by adapting Mathematica model files or extending, recombining, or replacing generated C++ modules.These two levels support applications ranging from simple model adaptations to more advanced projects using generated libraries as building blocks.
  • Boundary-condition adaptations: A NUHMSSM example reuses the MSSM specification while replacing universal Higgs soft masses with independent high-scale inputs.The parameters mHd2In and mHu2In are introduced as additional dimension-2 inputs, allowing either sign for the corresponding soft masses squared.
  • Model extensions: FlexibleSUSY can be extended from the MSSM to a supersymmetric type-I seesaw model by adding right-handed neutrinos, their couplings, and Majorana mass terms.The example also declares the new states, mixings, spinor construction, and mass eigenstates for the extended particle content.
  • C++ extensions: Problems beyond Mathematica-only edits can be addressed at the C++ level using the generated class structure and new spectrum-generator components.Appendix examples demonstrate composing components from scratch or linking them to external routines.

8. Tests and comparisons with other spectrum generators

FlexibleSUSY was tested numerically against established spectrum generators and found to reproduce their results closely while offering substantially shorter run-times.

  • Numeric tests: All tested mass matrices, EWSB equations, beta-functions, self-energies, and tadpoles agreed within double machine precision for CMSSM and NMSSM test points.
  • Numeric tests: The iterative solutions of the corrected tadpole equations agreed within machine precision, while the final pole masses and mixings agreed at the sub-permille level.
  • Numeric tests: The CE6SSM comparison found mass-spectrum deviations of ≲10%, consistent with the generators' different constraints and precision levels.
  • Run-time comparison: FlexibleSUSY-NoFV ran 1.4–1.7 times faster than SPheno and about 2–2.5 times faster than Softsusy.
  • Run-time comparison: FlexibleSUSY-FV ran 2.8–5 times faster than SPhenoMSSM, benefiting from optimized Eigen matrix expressions and multithreaded pole-mass calculations.

9. Conclusions

The paper presents FlexibleSUSY as a fast, modular framework for generating spectrum generators across constrained and non-minimal SUSY models. Its tested implementations support both reliable calculations and extensive source-code adaptation.

  • FlexibleSUSY generates fast, modular spectrum generators for user-specified SUSY models and includes predefined CMSSM, NMSSM, USSM, E6SSM, and MRSSM models.
  • Users can control models, boundary conditions, parameters, and generated components at both the Mathematica model-file and C++ source-code levels.
  • Extensive tests against Softsusy and additional non-minimal-model tests were complemented by speed tests against Softsusy, SPheno, and SARAH-generated MSSM code.
  • FlexibleSUSY runs faster than all three comparison generators in the reported speed tests.
  • The framework enables fast exploitation of new SUSY models with high precision and reliability.

Appendix A. Examples of C++ code adaptation

The appendix introduces technical details of adapting FlexibleSUSY's generated C++ code, supplementing the earlier overview of its C++-level customization.

  • The appendix provides additional technical details on programming FlexibleSUSY at the C++ level.

Appendix A.1. Stacking models in a tower of effective theories

FlexibleSUSY can combine the MSSMD5O and MSSMRHN into a tower of effective theories whose constraints, matching, models, and solvers are assembled into one RGFlow calculation. The resulting solution yields the low-energy spectrum of the lower-energy model.

  • The example represents MSSMRHN as the higher-energy theory and MSSMD5O as the lower-energy effective theory.
  • Boundary-condition and matching objects are associated with their scales and plugged into RGFlow, which solves the combined problem.
  • The multi-model spectrum generator requires hand-written matching and gluing code, while remaining components can extend single-model counterparts.
  • Future FlexibleSUSY releases were planned to generate the multi-model tower code automatically, which currently requires manual matching and gluing code.
  • Models are added from the lowest scale to the highest, with the matching object supplied for the lower-energy model.
  • After solving the boundary-value problem, the lower-energy MSSMD5O is run to its SUSY scale, its spectrum is calculated, and parameters may be evolved to an output scale.

Appendix A.2. Integrating custom-built C++ components

FlexibleSUSY’s modular C++ structure permits generated model components to be replaced or extended through derived classes and customized boundary conditions. The example modifies the MSSM beta-functions and low-energy matching while reusing existing interfaces where possible.

  • The custom low-energy constraint performs two-loop matching and implements two-step decoupling through additional gauge-coupling matching functions.
  • A custom MSSMcbs model derives from MSSM and overrides its virtual beta() method to implement custom beta-functions.
  • Existing MSSM_input_parameters and MSSM_soft_parameters are reused where possible, reducing code duplication.
  • The customized beta-function adds a three-loop g3 contribution using the coefficient bg33 adapted from prior code.
  • The replacement boundary condition class derives from Constraint<Two_scale> and retains the generated model and constraint interfaces.
  • The customized model and low-energy constraint replace their MSSM counterparts in dependent objects such as the initial guesser and spectrum generator.
  • A working realization of the customization example is provided in examples/customized-betas/.

Appendix B. Speed test SLHA input file

The speed-test SLHA input file configures the selected model, loop orders, numerical algorithm, convergence settings, and Standard Model inputs. It also controls optional calculations and output conventions.

  • The file contains blocks for model selection, SOFTSUSY-specific inputs, SPheno-specific inputs, and Standard Model inputs.
  • The file supplies Standard Model inputs such as alpha_s(MZ), the pole masses of MZ, the top quark, and the tau lepton, plus mb(mb).
  • The configured algorithm is two_scale, with two-loop running, two-loop pole-mass and EWSB calculations, and two-loop beta-functions.
  • Threshold corrections are set to one loop, while selected Higgs two-loop corrections include O(alpha_t alpha_s), O(alpha_b alpha_s), O(alpha_t^2 + alpha_t), and O(alpha_tau^2) terms.
  • Optional outputs and calculations, including branching ratios, three-body decays, WHIZARD files, HiggsBounds files, and low-energy constraints, are individually controlled.
  • The input specifies a mass-calculation precision of 1.000E-04 and a maximum of 40 iterations.
Loading 1406.2319v3…