bounce_solution.h

// Copyright (C) 2024 Lisa Biermann, Margarete Mühlleitner, Rui Santos, João
// Viana
//
// SPDX-FileCopyrightText: 2024 Lisa Biermann, Margarete Mühlleitner, Rui
// Santos, João Viana
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <BSMPT/bounce_solution/action_calculation.h>
#include <BSMPT/minimum_tracer/minimum_tracer.h> // MinimumTracer
#include <BSMPT/models/SMparam.h>
#include <BSMPT/utility/spline/spline.h>
#include <Eigen/Dense>
#include <algorithm>             // std::max
#include <gsl/gsl_deriv.h>       // numerical derivative
#include <gsl/gsl_integration.h> // numerical integration
 
namespace BSMPT
{
 
struct resultErrorPair
{
  double result;
  double error;
};
 
class BounceSolution
{
public:
  std::shared_ptr<Class_Potential_Origin> modelPointer;
 
  std::shared_ptr<MinimumTracer> MinTracer;
 
  double epsturb = 0.1;
 
  double vwall = 0.95;
 
  size_t NumberOfInitialScanTemperatures;
 
  bool nucleation_temp_set = false;
 
  bool percolation_temp_set = false;
 
  bool completion_temp_set = false;
 
  double Tc = -1;
 
  double Tm = -1;
 
  double Tnucl = -1;
 
  double Tnucl_approx = -1;
 
  double Tperc = -1;
 
  double Tcompl = -1;
 
  double store_Temp;
 
  double alpha = -1;
 
  double betaH = -1;
 
  double gstar;
 
  int indexTrueCandidatePhase;
 
  tk::spline S3ofT_spline;
 
  std::vector<BounceActionInt> SolutionList;
 
  std::vector<Eigen::MatrixXd> GroupElements;
 
  Eigen::MatrixXd OptimalDiscreteSymmetry;
 
  std::vector<double>
  TransformIntoOptimalDiscreteSymmetry(const std::vector<double> &vev);
 
  void CalculateOptimalDiscreteSymmetry();
 
  double TunnelingRate(const double &Temp);
  double HubbleRate(const double &Temp);
 
  friend double inner_integrand(double var, void *params);
 
  friend double outer_integrand(double var, void *params);
 
  double GetBounceSol(const double &Temp) const;
 
  friend double action_ratio(double var, void *params);
 
public:
  const double AbsErr = 0;
 
  const double RelErr = 1e-6;
 
  const double RelativeTemperatureInCalcTempAtFalseVacFraction = 1e-8;
 
  const double RelativeErrorInCalcTempAtFalseVacFraction = 1e-3;
 
  const double MarginOfCalcTempAtFalseVacFractionBeforeFailure = 1e-4;
 
  CoexPhases phase_pair;
 
  StatusGW status_bounce_sol = StatusGW::NotSet;
 
  BSMPT::StatusTemperature status_nucl_approx =
      BSMPT::StatusTemperature::NotSet;
 
  BSMPT::StatusTemperature status_nucl = BSMPT::StatusTemperature::NotSet;
 
  BSMPT::StatusTemperature status_perc = BSMPT::StatusTemperature::NotSet;
 
  BSMPT::StatusTemperature status_compl = BSMPT::StatusTemperature::NotSet;
 
  double UserDefined_vwall = 0.95;
 
  int MaxPathIntegrations = 7;
 
  BounceSolution(const std::shared_ptr<Class_Potential_Origin> &pointer_in);
 
  BounceSolution(const std::shared_ptr<Class_Potential_Origin> &pointer_in,
                 const std::shared_ptr<MinimumTracer> &MinTracer_in,
                 const CoexPhases &phase_pair_in,
                 const double &UserDefined_vwall_in,
                 const double &UserDefined_epsturb_in,
                 const int &MaxPathIntegrations_in,
                 const size_t &NumberOfInitialScanTemperatures_in);
 
  BounceSolution(const std::shared_ptr<Class_Potential_Origin> &pointer_in,
                 const std::shared_ptr<MinimumTracer> &MinTracer_in,
                 const CoexPhases &phase_pair_in,
                 const double &UserDefined_vwall_in,
                 const double &UserDefined_epsturb_in,
                 const int &MaxPathIntegrations_in,
                 const size_t &NumberOfInitialScanTemperatures_in,
                 std::vector<Eigen::MatrixXd> GroupElements_in);
 
  void GWInitialScan();
 
  void CalculateActionAt(double T, bool smart = true);
 
  void GWSecondaryScan();
 
  void GWScanTowardsHighAction();
 
  void GWScanTowardsLowAction();
 
  void SetBounceSol();
 
  double GetWallVelocity() const;
 
  double GetEpsTurb() const;
 
  void SetGstar(const double &gstar_in);
 
  double GetGstar() const;
 
  void SetCriticalTemp(const double &T_in);
 
  double GetCriticalTemp() const;
 
  void SetStoredTemp(const double &T_in);
  double GetStoredTemp() const;
 
  double GetNucleationTemp() const;
 
  double GetNucleationTempApprox() const;
 
  double GetPercolationTemp() const;
 
  double GetCompletionTemp() const;
 
  double CalcTransitionTemp(const int &which_transition_temp);
 
  double GetPTStrength() const;
 
  void CalcGstarPureRad();
 
  void CalculateNucleationTemp();
 
  void CalculateNucleationTempApprox();
 
  double CalcTempAtFalseVacFraction(const double &false_vac_frac);
 
  double CalcFalseVacFraction(const double &temp);
 
  void CalculatePercolationTemp(const double &false_vac_frac = 0.71);
 
  void CalculateCompletionTemp(const double &false_vac_frac = 0.01);
 
  void CalculatePTStrength();
 
  void CalculateWallVelocity(const Minimum &false_min, const Minimum &true_min);
 
  void CalculateInvTimeScale();
 
  double GetInvTimeScale();
};
 
struct resultErrorPair Nintegrate_Inner(BounceSolution &obj,
                                        const double &Tprime);
 
struct resultErrorPair Nintegrate_Outer(BounceSolution &obj);
 
struct resultErrorPair Nderive_BounceRatio(BounceSolution &obj);
 
} // namespace BSMPT