error.hpp

Go to the documentation of this file.

// ====================================================================
// This file is part of FlexibleSUSY.
//
// FlexibleSUSY 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 3 of the License,
// or (at your option) any later version.
//
// FlexibleSUSY is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with FlexibleSUSY.  If not, see
// <http://www.gnu.org/licenses/>.
// ====================================================================
 
#ifndef ERROR_H
#define ERROR_H
 
#include <cstring>
#include <stdexcept>
#include <string>
 
namespace flexiblesusy {
 
class Error : public std::runtime_error {
public:
   explicit Error(const std::string& msg) : std::runtime_error(msg) {}
   explicit Error(const char* msg) : std::runtime_error(msg) {}
   virtual ~Error() = default;
   virtual std::string what_detailed() const { return what(); }
};
 
class FatalError : public Error {
public:
   FatalError() : Error("Fatal error") {}
   virtual ~FatalError() = default;
};
 
class SetupError : public Error {
public:
   explicit SetupError(const std::string& msg) : Error(msg) {}
   explicit SetupError(const char* msg) : Error(msg) {}
   virtual ~SetupError() = default;
};
 
class NoConvergenceError : public Error {
public:
   explicit NoConvergenceError(int number_of_iterations_, const std::string& msg = "")
      : Error(msg)
      , number_of_iterations(number_of_iterations_) {}
   virtual ~NoConvergenceError() = default;
   std::string what_detailed() const override {
      const auto msg = Error::what();
 
      if (std::strlen(msg) > 0) {
         return msg;
      }
 
      return "NoConvergenceError: no convergence after "
         + std::to_string(number_of_iterations) + " iterations";
   }
   int get_number_of_iterations() const { return number_of_iterations; }
private:
   int number_of_iterations;
};
 
class NoGFermiConvergenceError : public Error {
public:
   NoGFermiConvergenceError(int number_of_iterations_, double g_fermi_)
      : Error("Calculation G_Fermi did not converge")
      , number_of_iterations(number_of_iterations_)
      , g_fermi(g_fermi_)
      {}
   virtual ~NoGFermiConvergenceError() = default;
   std::string what_detailed() const override {
      return "NoGFermiConvergenceError: no convergence after "
         + std::to_string(number_of_iterations) + " iterations (G_Fermi="
         + std::to_string(g_fermi) + ")";
   }
   int get_number_of_iterations() const { return number_of_iterations; }
   double get_g_fermi() const { return g_fermi; }
private:
   int number_of_iterations;
   double g_fermi;
};
 
class NoSinThetaWConvergenceError : public Error {
public:
   NoSinThetaWConvergenceError(int number_of_iterations_,
                               double sin_theta_)
      : Error("Calculation of Weinberg angle did not converge")
      , number_of_iterations(number_of_iterations_)
      , sin_theta(sin_theta_)
      {}
   virtual ~NoSinThetaWConvergenceError() = default;
   std::string what_detailed() const override {
      return "NoSinThetaWConvergenceError: no convergence after "
         + std::to_string(number_of_iterations) + " iterations (sin(theta)="
         + std::to_string(sin_theta) + ")";
   }
   int get_number_of_iterations() const { return number_of_iterations; }
   double get_sin_theta() const { return sin_theta; }
private:
   int number_of_iterations;
   double sin_theta;
};
 
class NonPerturbativeSinThetaW : public Error {
public:
   NonPerturbativeSinThetaW()
      : Error("NonPerturbativeSinThetaW: sin(theta) non-perturbative") {}
   virtual ~NonPerturbativeSinThetaW() = default;
};
 
class NonPerturbativeRunningError : public Error {
public:
   explicit NonPerturbativeRunningError(double scale_, int parameter_index_ = -1, double value_ = 0)
      : Error("Non-perturbative RG running")
      , scale(scale_)
      , value(value_)
      , parameter_index(parameter_index_)
      {}
   virtual ~NonPerturbativeRunningError() = default;
   std::string what_detailed() const override {
      if (parameter_index == -1) {
         return "NonPerturbativeRunningError: scale Q = " + std::to_string(value);
      }
 
      return "NonPerturbativeRunningError: non-perturbative running of parameter "
         + std::to_string(parameter_index) + " to scale " + std::to_string(scale);
   }
   std::string what_parameter(const std::string& parameter_name) const {
      return "NonPerturbativeRunningError: non-perturbative running"
         " of " + parameter_name + " = " + std::to_string(value)
         + " to scale " + std::to_string(scale);
   }
   int get_parameter_index() const { return parameter_index; }
   double get_parameter_value() const { return value; }
   double get_scale() const { return scale; }
private:
   double scale; 
   double value; 
   int parameter_index; 
};
 
class NonPerturbativeRunningQedQcdError : public Error {
public:
   explicit NonPerturbativeRunningQedQcdError(const std::string& msg) : Error(msg) {}
   explicit NonPerturbativeRunningQedQcdError(const char* msg) : Error(msg) {}
   virtual ~NonPerturbativeRunningQedQcdError() = default;
};
 
class OutOfMemoryError : public Error {
public:
   explicit OutOfMemoryError(const std::string& msg) : Error(msg) {}
   explicit OutOfMemoryError(const char* msg) : Error(msg) {}
   virtual ~OutOfMemoryError() = default;
   virtual std::string what_detailed() const override {
      return std::string("OutOfMemoryError: Not enought memory: ") + what();
   }
};
 
class OutOfBoundsError : public Error {
public:
   explicit OutOfBoundsError(const std::string& msg) : Error(msg) {}
   explicit OutOfBoundsError(const char* msg) : Error(msg) {}
   virtual ~OutOfBoundsError() = default;
};
 
class ReadError : public Error {
public:
   explicit ReadError(const std::string& msg) : Error(msg) {}
   explicit ReadError(const char* msg) : Error(msg) {}
   virtual ~ReadError() = default;
};
 
class PhysicalError : public Error {
public:
   explicit PhysicalError(const std::string& msg) : Error(msg) {}
   explicit PhysicalError(const char* msg) : Error(msg) {}
   virtual ~PhysicalError() = default;
};
 
class HimalayaError : public Error {
public:
   explicit HimalayaError(const std::string& msg) : Error(msg) {}
   explicit HimalayaError(const char* msg) : Error(msg) {}
   virtual ~HimalayaError() = default;
};
 
} // namespace flexiblesusy
 
#endif