ThresholdCalculator.hpp

Go to the documentation of this file.

// ====================================================================
// This file is part of Himalaya.
//
// Himalaya is licenced under the GNU General Public License (GNU GPL)
// version 3.
// ====================================================================

#pragma once

#include "himalaya/Himalaya_interface.hpp"
#include "himalaya/mh2_eft/EFTFlags.hpp"

/**
 * @file ThresholdCalculator.hpp
 *
 * @brief Definition of threshold corrections class to express the
 * Higgs mass calculation in terms of SM MS-bar / MSSM DR'-bar
 * parameters.
 */

namespace himalaya{
namespace mh2_eft{

class ThresholdCalculator{
public:
   /**
    * Constructor
    * @param p_ a HimalayaInterface struct
    * @param verbose a bool enable the output of the parameter validation. Enabled by default
    * @param check a boolean which indicates if the threshold corrections should be tested
    */
   ThresholdCalculator(const Parameters& p_, bool verbose = true, bool check = false);
   /**
    * Returns a specific threshold correction
    * @param couplingOrder coupling order of threshold correction
    * @param scheme an integer key to set the scheme. Choices are {MSbar, DRbar', DRbar}
    * @param omitLogs an integer to omit all log mu terms
    * @return a threshold correction for a given couplingOrder in a given scheme for a suitable mass limit
    */
   double getThresholdCorrection(ThresholdCouplingOrders couplingOrder, RenSchemes scheme, int omitLogs) const;
   /**
    * Returns the shift needed to convert the 3L threshold correction of lambda to the MSbar scheme
    * @param xtOrder an integer key to omit the Xt contributions starting at xtOrder + 1
    * @param omitLogs an integer key to omit all log mu terms
    * @param omitXtLogs an integer key to omit all Xt^4*Log[mu] and Xt^5*Log[mu] terms
    */
   double getDRbarPrimeToMSbarShift(int xtOrder, int omitLogs, int omitXtLogs = 1) const;
   /**
    * Returns the DRbarPrime to MSbar shift of delta lambda 3L at a given xtOrder
    * @param limit an integer key for a mass limit
    * @param xtOrder an integer key to get a specific Xt order starting at 4
    * @param omitLogs an integer key to omit all log mu terms
    */
   double getDRbarPrimeToMSbarXtTerms(Limits limit, int xtOrder, int omitLogs) const;
   /**
    * Sets the mass limit to check terms
    * @param limit an integer key for a mass limit
    */
   void setLimit(Limits limit);
   /**
    * Get the mass limit determined by ThresholdCalculator
    * @return The determined mass limit
    */
   Limits getLimit() const;
   /**
    * Sets the order of Xt for getDeltaLambdaAlphatAlphas2
    * @param xtOrder an integer key to truncate delta_lambda_at_as2 at a given Xt order starting at 4
    */
   void setXtOrderOfDeltaLambdaAtAs2(int xtOrder);
private:
   /**
    * Returns delta g3_as in the MSbar scheme for a given mass limit
    * @param omitLogs an integer key to omit all mu terms
    * @return delta g3_as in the MSbar scheme for a given mass limit
    */
   double getDeltaG3Alphas(int omitLogs) const;
   /**
    * Returns delta yt_as in the MSbar scheme for a given mass limit
    * @param limit an integer key for a mass limit
    * @param omitLogs an integer key to omit all mu terms
    * @return delta yt_as in the MSbar scheme for a given mass limit
    */
   double getDeltaYtAlphas(Limits limit, int omitLogs) const;
   /**
    * Returns delta yt_as^2 in the MSbar scheme for a given mass limit
    * @param limit an integer key for a mass limit
    * @param omitLogs an integer key to omit all mu terms
    * @return delta yt_as^2 in the MSbar scheme for a given mass limit
    */
   double getDeltaYtAlphas2(Limits limit, int omitLogs) const;
   /**
    * Returns delta lambda_at in the MSbar scheme for a given mass limit
    * @param limit an integer key for a mass limit
    * @param omitLogs an integer key to omit all mu terms
    * @return delta lambda_at in the MSbar scheme for a given mass limit
    */
   double getDeltaLambdaAlphat(Limits limit, int omitLogs) const;
   /**
    * Returns delta lambda_atas in the MSbar scheme for a given mass limit
    * @param limit an integer key for a mass limit
    * @param omitLogs an integer key to omit all mu terms
    * @return delta lambda_atas in the MSbar scheme for a given mass limit
    */
   double getDeltaLambdaAlphatAlphas(Limits limit, int omitLogs) const;
   /**
    * Returns delta lambda_atas2 in the MSbar scheme for a given mass limit
    * @param limit an integer key for a mass limit
    * @param omitLogs an integer key to omit all mu terms
    * @return delta lambda_atas2 in the MSbar scheme for a given mass limit
    */
   double getDeltaLambdaAlphatAlphas2(Limits limit, int omitLogs) const;
   /**
    * Returns delta_lambda_yb^2_g1^2
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_yb^2_g1^2
    */
   double getDeltaLambdaYb2G12(int omitLogs) const;
   /**
    * Returns delta_lambda_g1^4
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_g1^4
    */
   double getDeltaLambdaG14(int omitLogs) const;
   /**
    * Returns delta_lambda_reg_g1^4
    * @return delta_lambda_reg_g1^4
    */
   double getDeltaLambdaRegG14() const;
   /**
    * Returns delta_lambda_chi_g1^4
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_chi_g1^4
    */
   double getDeltaLambdaChiG14(int omitLogs) const;
   /**
    * Returns delta_lambda_chi_g2^4
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_chi_g2^4
    */
   double getDeltaLambdaChiG24(int omitLogs) const;
   /**
    * Returns delta_lambda_g2^4
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_g2^4
    */
   double getDeltaLambdaG24(int omitLogs) const;
   /**
    * Returns delta_lambda_reg_g2^4
    * @return delta_lambda_reg_g2^4
    */
   double getDeltaLambdaRegG24() const;
   /**
    * Returns delta_lambda_g1^2_g2^2
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_g1^2_g2^2
    */
   double getDeltaLambdaG12G22(int omitLogs) const;
   /**
    * Returns delta_lambda_reg_g1^2_g2^2
    * @return delta_lambda_reg_g1^2_g2^2
    */
   double getDeltaLambdaRegG12G22() const;
   /**
    * Returns delta_lambda_chi_g1^2_g2^2
    * @return delta_lambda_chi_g1^2_g2^2
    */
   double getDeltaLambdaChiG12G22(int omitLogs) const;
   /**
    * Returns delta_lambda_yb^2_g2^2
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_yb^2_g2^2
    */
   double getDeltaLambdaYb2G22(int omitLogs) const;
   /**
    * Returns delta_lambda_yb^4
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_yb^4
    */
   double getDeltaLambdaYb4(int omitLogs) const;
   /**
    * Returns delta_lambda_yt^2_g1^2
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_yt^2_g1^2
    */
   double getDeltaLambdaYt2G12(int omitLogs) const;
   /**
    * Returns delta_lambda_yt^2_g2^2
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_yt^2_g2^2
    */
   double getDeltaLambdaYt2G22(int omitLogs) const;
   /**
    * Returns delta_lambda_ytau^2_g1^2
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_ytau^2_g1^2
    */
   double getDeltaLambdaYtau2G12(int omitLogs) const;
   /**
    * Returns delta_lambda_ytau^2_g2^2
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_ytau^2_g2^2
    */
   double getDeltaLambdaYtau2G22(int omitLogs) const;
   /**
    * Returns delta_lambda_ytau^4
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_ytau^4
    */
   double getDeltaLambdaYtau4(int omitLogs) const;
   /**
    * Returns delta_g1_g1
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_g1_g1
    */
   double getDeltaG1G1(int omitLogs) const;
   /**
    * Returns delta_g2_g2
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_g2_g2
    */
   double getDeltaG2G2(int omitLogs) const;
   /**
    * Returns delta_lambda_v_yt^2
    * @param limit an integer key for a mass limit
    * @return delta_lambda_v_yt^2
    */
   double getDeltaVevYt2(Limits limit) const;
   /**
    * Returns delta_lambda_v_yb^2
    * @return delta_lambda_v_yb^2
    */
   double getDeltaVevYb2() const;
   /**
    * Returns delta_lambda_v_ytau^2
    * @return delta_lambda_v_ytau^2
    */
   double getDeltaVevYtau2() const;
   /**
    * Returns delta_lambda_v_g1^2
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_v_g1^2
    */
   double getDeltaVevG12(int omitLogs) const;
   /**
    * Returns delta_lambda_v_g2^2
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_v_g2^2
    */
   double getDeltaVevG22(int omitLogs) const;
   /**
    * Returns delta_ytau_yb
    * @return delta_ytau_yb
    */
   double getDeltaYtauYb() const;
   /**
    * Returns delta_yt_yt
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_yt_yt
    */
   double getDeltaYtYt(int omitLogs) const;
   /**
    * Returns delta_ytau_ytau
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_ytau_ytau
    */
   double getDeltaYtauYtau(int omitLogs) const;
   /**
    * Returns delta_yt_yb
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_yt_yb
    */
   double getDeltaYtYb(int omitLogs) const;
   /**
    * Returns delta_yb_yt
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_yb_yt
    */
   double getDeltaYbYt(int omitLogs) const;
   /**
    * Returns delta_yb_as
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_yb_as
    */
   double getDeltaYbAs(int omitLogs) const;
   /**
    * Returns delta_yb_yb
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_yb_yb
    */
   double getDeltaYbYb(int omitLogs) const;
   /**
    * Returns delta_lambda_yb4_g32
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_yb4_g32
    */
   double getDeltaLambdaYb4G32(int omitLogs) const;
   /**
    * Returns delta_lambda_yb6
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_yb6
    */
   double getDeltaLambdaYb6(int omitLogs) const;
   /**
    * Returns delta_lambda_yt6
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_yt6
    */
   double getDeltaLambdaYt6(int omitLogs) const;
   /**
    * Returns delta_lambda_yt6 from SUSYHD
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_yt6
    */
   double getDeltaLambdaYt6_SUSYHD(int omitLogs) const;
   /**
    * Returns delta_lambda_ytau6
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_ytau6
    */
   double getDeltaLambdaYtau6(int omitLogs) const;
   /**
    * Returns delta_lambda_yt2_yb4
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_yt2_yb4
    */
   double getDeltaLambdaYt2Yb4(int omitLogs) const;
   /**
    * Returns delta_lambda_yt4_yb2
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_yt4_yb2
    */
   double getDeltaLambdaYt4Yb2(int omitLogs) const;
   /**
    * Returns delta_lambda_ytau4_yb2
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_ytau4_yb2
    */
   double getDeltaLambdaYtau4Yb2(int omitLogs) const;
   /**
    * Returns delta_lambda_ytau2_yb4
    * @param omitLogs an integer key to omit all mu terms
    * @return delta_lambda_ytau2_yb4
    */
   double getDeltaLambdaYtau2Yb4(int omitLogs) const;
   /// calculate beta
   double calcBeta() const;
   /// calculate tan(beta)
   double calcTanBeta() const;
   /// calculate v
   double calcV() const;
   /// calculate v^2
   double calcV2() const;
   /// calculate sin(beta)
   double calcSinBeta() const;
   /// calculate cos(beta)
   double calcCosBeta() const;
   /// calculate Xt
   double calcXt() const;
   /// calculate Xb
   double calcXb() const;
   /// calculate Xtau
   double calcXtau() const;
   /// calculate Yt
   double calcYt() const;
   /// calculate Yb
   double calcYb() const;
   /// calculate Ytau
   double calcYtau() const;
   Parameters p{}; ///< Himalaya input parameters
   double msq2{};  ///< average squared squark mass of the first two generations
   int xtOrderLambdaAtAs2 = 6; ///< flag to truncate the Xt order of delta_lambda_at_as2 at a given power starting at 4
};

} // namespace mh2_eft
} // namespace himalaya