field_nicolai.hpp

Go to the documentation of this file.

 
#ifndef FIELD_NICOLAI_INCLUDED
#define FIELD_NICOLAI_INCLUDED
 
#include "field_potential.hpp"
 
#include <iomanip>
#include <fstream>
#include <time.h>   // For test_nr_method //
#include <limits.h> // For test_nr_method //
 
using std::vector; // For class NicolaiSol //
 
extern const double SOL_ID_MAXVAL;
extern const double MAX_NRERR;
extern const double NR_INTERRUPTION;
extern const int SuperPotentialTypeCustom_StdNumSol;
 
enum class SuperPotentialType {
  AlgebraA ,
  AlgebraD ,
  AlgebraE ,
  Custom   
};
 
 
class Nicolai:public Field {
protected:
  int in;
 
public:
  explicit Nicolai() {};
  explicit Nicolai(const int n1, const int n2, const int n3) :
    Field(n1, n2, Distribution::Gauss_L) {in = n3;};
  virtual ~Nicolai() {};
 
  virtual bool operator==(const Nicolai &f) {return (Li==f.Li) && (num_f == f.num_f);};
  virtual bool operator!=(const Nicolai &f) {return !(*this==f);};
 
  VectorXd nr_nvec() const;
 
  VectorXcd nrerr_nvec() const;
 
  void nic_output(const VectorXi k, const VectorXd lambda,
                  const int num_nrsol,
                  const VectorXi signs, const int dmp,
                  const double max_err,
                  const SuperPotentialType spt) const;
 
  void show() const;
};
 
 
 
class Scalar:public Field {
  SuperPotentialType spt_type = SuperPotentialType::AlgebraA;
  VectorXi k;
  VectorXd lambda;
 
  double sol_id_maxval = SOL_ID_MAXVAL;
 
  Potential superpotential_typealgebraA() const;
  Potential superpotential_typealgebraD() const;
  Potential superpotential_typealgebraE() const;
  Potential superpotential_typecustom() const;
 
  PotentialNR superpotential_nr_typealgebraA() const;
  PotentialNR superpotential_nr_typealgebraD() const;
  PotentialNR superpotential_nr_typealgebraE() const;
  PotentialNR superpotential_nr_typecustom() const;
 
public:
  explicit Scalar() {};
  explicit Scalar(const int n1, const int n2,
                  const VectorXi n3, const VectorXd n4,
                  const SuperPotentialType t
                  = SuperPotentialType::AlgebraA) :
    Field(n1, n2, Distribution::Gauss_MT_unit) {
    k = n3; lambda = n4; spt_type = t;
  };
  explicit Scalar(const VectorXcd &v,
                  const VectorXi n3, const VectorXd n4,
                  const int num_field = 1,
                  const SuperPotentialType t
                  = SuperPotentialType::AlgebraA) :
    Field(v, num_field) { k = n3; lambda = n4; spt_type = t;};
  explicit Scalar(const Scalar &f, const VectorXcd &v) :
    Field(v, f.num_f) {
    spt_type = f.spt_type;
    k = f.k; lambda = f.lambda; spt_type = f.spt_type;
  };
  explicit Scalar(const Scalar &f, const VectorXd &v) :
    Field(v, f.num_f) {
    spt_type = f.spt_type;
    k = f.k; lambda = f.lambda; spt_type = f.spt_type;
  };
  
  ~Scalar() {};
 
  bool operator==(const Scalar &f) {
    return (Li==f.Li) && (num_f == f.num_f)
      && (k==f.k) && (lambda==f.lambda) && (spt_type==f.spt_type);
  };
  bool operator!=(const Scalar &f) { return !(*this==f); };
 
  bool is_identical(const Scalar &f) const;
 
  VectorXcd nrerr_svec() const;
 
  Potential superpotential() const;
  PotentialNR superpotential_nr() const;
 
  Scalar nr_loop (const Nicolai &nic);
 
  VectorXcd nr_error_vec (const Nicolai &nic) const;
  double nr_error (const Nicolai &nic) const {
    VectorXcd er = nr_error_vec(nic);
    return er.norm();
  };
 
  void scl_output(const int in, const int num_sol, const int i,
                  const int sign, const double err) const;
 
  void show() const;
};
 
 
 
class NicolaiSol:public Nicolai {
  vector<Scalar> fs;
  vector<double> errs;
 
  double nr_interruption = NR_INTERRUPTION;
 
public:
  explicit NicolaiSol() {};
  explicit NicolaiSol(const int n1, const int n2, const int n3) :
    Nicolai(n1, n2, n3) {};
  ~NicolaiSol () {};
 
  bool operator==(const NicolaiSol &f) {
    MatrixXcd err_vec = (field-f.field) / field.norm();
    double err = err_vec.norm();
    if (err < 1.0e-15)
      return (Li==f.Li) && (num_f == f.num_f);
    else return false;
  };
  bool operator!=(const NicolaiSol &f) {return !(*this==f);};
 
  NicolaiSol &add_sol(const Scalar &f, const double &err);
  NicolaiSol &add_sol(const NicolaiSol &sol);
 
  int num_sol() const {return fs.size();};
  double max_err() const {return *max_element(errs.begin(), errs.end());};
 
  double nr_method (const VectorXi k, const VectorXd lambda,
                    const int num_nrsol, const int LOOP,
                    const SuperPotentialType t
                    = SuperPotentialType::AlgebraA);
 
  void test_nr_method (const VectorXi k, const VectorXd lambda,
                       const int LOOP, const int TRIAL,
                       const SuperPotentialType t
                       = SuperPotentialType::AlgebraA);
 
  int sign_det(const int n) const {
    return fs[n].superpotential().sign_det();
  };
 
  void phi_output(const int in, const VectorXi signs) const;
 
  void show() const;
};
 
extern int SuperPotentialType_StdNumSol (const VectorXi k, const SuperPotentialType t);
 
#endif