solver_GMRES_m_Cmplx.cpp

Go to the documentation of this file.

#include "solver_GMRES_m_Cmplx.h"


#ifdef USE_FACTORY
namespace {
  Solver *create_object(Fopr *fopr)
  {
    return new Solver_GMRES_m_Cmplx(fopr);
  }


  bool init = Solver::Factory::Register("GMRES_m_Cmplx", create_object);
}
#endif

//- parameter entries
namespace {
  void append_entry(Parameters& param)
  {
    param.Register_int("maximum_number_of_iteration", 0);
    param.Register_double("convergence_criterion_squared", 0.0);

    param.Register_int("number_of_orthonormal_vectors", 0);

    param.Register_string("verbose_level", "NULL");
  }


#ifdef USE_PARAMETERS_FACTORY
  bool init_param = ParametersFactory::Register("Solver.GMRES_m_Cmplx", append_entry);
#endif
}
//- end

//- parameters class
Parameters_Solver_GMRES_m_Cmplx::Parameters_Solver_GMRES_m_Cmplx() { append_entry(*this); }
//- end

const std::string Solver_GMRES_m_Cmplx::class_name = "Solver_GMRES_m_Cmplx";

//====================================================================
void Solver_GMRES_m_Cmplx::set_parameters(const Parameters& params)
{
  const string str_vlevel = params.get_string("verbose_level");

  m_vl = vout.set_verbose_level(str_vlevel);

  //- fetch and check input parameters
  int    Niter;
  double Stop_cond;
  int    N_M;

  int err = 0;
  err += params.fetch_int("maximum_number_of_iteration", Niter);
  err += params.fetch_double("convergence_criterion_squared", Stop_cond);
  err += params.fetch_int("number_of_orthonormal_vectors", N_M);

  if (err) {
    vout.crucial(m_vl, "%s: fetch error, input parameter not found.\n", class_name.c_str());
    abort();
  }


  set_parameters(Niter, Stop_cond);
  set_parameters_GMRES_m(N_M);
}


//====================================================================
void Solver_GMRES_m_Cmplx::set_parameters(const int Niter, const double Stop_cond)
{
  ThreadManager_OpenMP::assert_single_thread(class_name);

  //- print input parameters
  vout.general(m_vl, "%s: input parameters\n", class_name.c_str());
  vout.general(m_vl, "  Niter     = %d\n", Niter);
  vout.general(m_vl, "  Stop_cond = %16.8e\n", Stop_cond);

  //- range check
  int err = 0;
  err += ParameterCheck::non_negative(Niter);
  err += ParameterCheck::square_non_zero(Stop_cond);

  if (err) {
    vout.crucial(m_vl, "%s: parameter range check failed.\n", class_name.c_str());
    abort();
  }

  //- store values
  m_Niter     = Niter;
  m_Stop_cond = Stop_cond;
}


//====================================================================
void Solver_GMRES_m_Cmplx::set_parameters_GMRES_m(const int N_M)
{
  //- print input parameters
  vout.general(m_vl, "  N_M   = %d\n", N_M);

  //- range check
  int err = 0;
  err += ParameterCheck::non_negative(N_M);

  if (err) {
    vout.crucial(m_vl, "%s: parameter range check failed.\n", class_name.c_str());
    abort();
  }

  //- store values
  m_N_M = N_M;
}


//====================================================================
void Solver_GMRES_m_Cmplx::solve(Field& xq, const Field& b,
                                 int& Nconv, double& diff)
{
  //#pragma omp parallel
  {
    double bnorm2 = b.norm2();
    double snorm  = 1.0 / bnorm2;
    int    bsize  = b.size();
    double rr;

    int nth = ThreadManager_OpenMP::get_num_threads();
    int ith = ThreadManager_OpenMP::get_thread_id();

#pragma omp master
    {
      vout.paranoiac(m_vl, "%s: starts\n", class_name.c_str());
      vout.paranoiac(m_vl, "  norm of b = %16.8e\n", bnorm2);
      vout.paranoiac(m_vl, "  size of b = %d\n", bsize);
    }
#pragma omp barrier


    reset_field(b);


    // Nconv = -1;
    int Nconv2 = 0;
    copy(s, b); // s = b;

    solve_init(b, rr);

    bool is_converged = false;

#pragma omp master
    vout.detailed(m_vl, "    iter: %8d  %22.15e\n", 0, rr * snorm);
#pragma omp barrier


    for (int iter = 0; iter < m_Niter; iter++) {
      if (!is_converged) {
        solve_step(b, rr);

#pragma omp master
        vout.detailed(m_vl, "    iter: %8d  %22.15e\n", m_N_M * (iter + 1), rr * snorm);
#pragma omp barrier

        if (rr * snorm < m_Stop_cond) {
          m_fopr->mult(s, x); // s  = m_fopr->mult(x);
          axpy(s, -1.0, b);   // s -= b;

          double diff2 = s.norm2();
          ThreadManager_OpenMP::sync_barrier_all();

          nth = ThreadManager_OpenMP::get_num_threads();
          if (ith == 0) vout.detailed(m_vl, "    iter0: %8d  %22.15e\n", nth, diff2 * snorm);

          if (diff2 * snorm < m_Stop_cond) {
            Nconv2 = m_N_M * (iter + 1);

            // break;
            is_converged = true;
          }

          copy(s, x); //  s = x;
          solve_init(b, rr);

          nth = ThreadManager_OpenMP::get_num_threads();
          if (ith == 0) vout.detailed(m_vl, "    iter1: %8d  %22.15e\n", nth, rr * snorm);
        }
      }
    }

    if (Nconv2 == -1) {
#pragma omp master
      vout.crucial(m_vl, "%s: not converged.\n", class_name.c_str());
#pragma omp barrier
      abort();
    }

    m_fopr->mult(s, x); // p  = m_fopr->mult(x);
    axpy(s, -1.0, b);   // p -= b;

    copy(xq, x);        // xq = x;

    double diff2 = s.norm2();

#pragma omp master
    {
      diff  = sqrt(diff2);
      Nconv = Nconv2;
    }
#pragma omp barrier
  } // end of parallel region
}


//====================================================================
void Solver_GMRES_m_Cmplx::reset_field(const Field& b)
{
#pragma omp master
  {
    int Nin  = b.nin();
    int Nvol = b.nvol();
    int Nex  = b.nex();

    if ((s.nin() != Nin) || (s.nvol() != Nvol) || (s.nex() != Nex)) {
      s.reset(Nin, Nvol, Nex);
      r.reset(Nin, Nvol, Nex);
      x.reset(Nin, Nvol, Nex);

      v_tmp.reset(Nin, Nvol, Nex);

      v.resize(m_N_M + 1);

      for (int i = 0; i < m_N_M + 1; ++i) {
        v[i].reset(Nin, Nvol, Nex);
      }

      vout.paranoiac(m_vl, "  %s: field size reset.\n", class_name.c_str());
    }
  }
#pragma omp barrier
}


//====================================================================
void Solver_GMRES_m_Cmplx::solve_init(const Field& b, double& rr)
{
  copy(x, s);  // x  = s;

  //- r = b - A x_0
  m_fopr->mult(v_tmp, s); // v_tmp = m_fopr->mult(s);
  copy(r, b);             // r  = b;
  axpy(r, -1.0, v_tmp);   // r -= v_tmp;

  rr = r.norm2();         // rr = r * r;

#pragma omp master
  beta_prev = sqrt(rr);
#pragma omp barrier

  //- v[0] = (1.0 / beta_prev) * r;
  copy(v[0], r);                  // v[0] = r;
  scal(v[0], (1.0 / beta_prev));  // v[0] = (1.0 / beta_p) * v[0];
}


//====================================================================
void Solver_GMRES_m_Cmplx::solve_step(const Field& b, double& rr)
{
  std::valarray<dcomplex> h((m_N_M + 1) * m_N_M), y(m_N_M);

  h = cmplx(0.0, 0.0);
  y = cmplx(0.0, 0.0);


  for (int j = 0; j < m_N_M; ++j) {
    m_fopr->mult(v_tmp, v[j]);  // v_tmp = m_fopr->mult(v[j]);

    for (int i = 0; i < j + 1; ++i) {
      int ij = index_ij(i, j);
      h[ij] = dotc(v_tmp, v[i]);  // h[ij] = (A v[j], v[i]);
    }

    //- v[j+1] = A v[j] - \Sum_{i=0}^{j-1} h[i,j] * v[i]
    v[j + 1] = v_tmp;

    for (int i = 0; i < j + 1; ++i) {
      int ij = index_ij(i, j);
      axpy(v[j + 1], -h[ij], v[i]);  // v[j+1] -= h[ij] * v[i];
    }

    double v_norm2 = v[j + 1].norm2();

    int j1j = index_ij(j + 1, j);
    h[j1j] = sqrt(v_norm2);

    scal(v[j + 1], 1.0 / sqrt(v_norm2));  // v[j+1] /= sqrt(v_norm2);
  }


  // Compute y, which minimizes J := |r_new| = |beta_p - h * y|
  min_J(y, h);


  // x += Sum_{i=0}^{N_M-1} y[i] * v[i];
  for (int i = 0; i < m_N_M; ++i) {
    axpy(x, y[i], v[i]);  // x += y[i] * v[i];
  }


  // r = b - m_fopr->mult(x);
  copy(s, x);  // s = x;
  solve_init(b, rr);
}


//====================================================================
void Solver_GMRES_m_Cmplx::min_J(std::valarray<dcomplex>& y,
                                 std::valarray<dcomplex>& h)
{
  // Compute y, which minimizes J := |r_new| = |beta_p - h * y|

  std::valarray<dcomplex> g(m_N_M + 1);

  g    = dcomplex(0.0);
  g[0] = beta_prev;

  for (int i = 0; i < m_N_M; ++i) {
    int    ii    = index_ij(i, i);
    double h_1_r = abs(h[ii]);

    int    i1i   = index_ij(i + 1, i);
    double h_2_r = abs(h[i1i]);

    double denomi = sqrt(h_1_r * h_1_r + h_2_r * h_2_r);

    dcomplex cs = h[ii] / denomi;
    dcomplex sn = h[i1i] / denomi;

    for (int j = i; j < m_N_M; ++j) {
      int ij  = index_ij(i, j);
      int i1j = index_ij(i + 1, j);

      dcomplex const_1_c = conj(cs) * h[ij] + sn * h[i1j];
      dcomplex const_2_c = -sn * h[ij] + cs * h[i1j];

      h[ij]  = const_1_c;
      h[i1j] = const_2_c;
    }

    dcomplex const_1_c = conj(cs) * g[i] + sn * g[i + 1];
    dcomplex const_2_c = -sn * g[i] + cs * g[i + 1];

    g[i]     = const_1_c;
    g[i + 1] = const_2_c;
  }


  for (int i = m_N_M - 1; i > -1; --i) {
    for (int j = i + 1; j < m_N_M; ++j) {
      int ij = index_ij(i, j);
      g[i] -= h[ij] * y[j];
    }

    int ii = index_ij(i, i);
    y[i] = g[i] / h[ii];
  }
}


//====================================================================
//============================================================END=====