PreconditionedSolver.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* PreconditionedSolver.h                                      (C) 2000-2026 */
/*                                                                           */
/* Tie an iterative solver and a preconditioner in a single class.           */
/*---------------------------------------------------------------------------*/
#ifndef ARCCORE_ALINA_PRECONDITIONEDSOLVER_H
#define ARCCORE_ALINA_PRECONDITIONEDSOLVER_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*
 * This file is based on the work on AMGCL library (version march 2026)
 * which can be found at https://github.com/ddemidov/amgcl.
 *
 * Copyright (c) 2012-2022 Denis Demidov <dennis.demidov@gmail.com>
 * SPDX-License-Identifier: MIT
 */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arccore/alina/BuiltinBackend.h"
#include "arccore/alina/AlinaUtils.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Alina
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class Precond, class IterativeSolver>
class PreconditionedSolver
: public Alina::detail::non_copyable
{
  static_assert(backend::backends_compatible<
                typename IterativeSolver::backend_type,
                typename Precond::backend_type>::value,
                "Backends for preconditioner and iterative solver should be compatible");
 
 public:
 
  typedef typename IterativeSolver::backend_type backend_type;
  typedef typename backend_type::matrix matrix;
 
  typedef typename backend_type::value_type value_type;
  typedef typename backend_type::col_type col_type;
  typedef typename backend_type::ptr_type ptr_type;
  typedef typename backend_type::params backend_params;
  typedef typename BuiltinBackend<value_type, col_type, ptr_type>::matrix build_matrix;
 
  typedef typename math::scalar_of<value_type>::type scalar_type;

  struct params
  {
    typename Precond::params precond; 
    typename IterativeSolver::params solver; 
 
    params() {}
 
    params(const PropertyTree& p)
    : ARCCORE_ALINA_PARAMS_IMPORT_CHILD(p, precond)
    , ARCCORE_ALINA_PARAMS_IMPORT_CHILD(p, solver)
    {
      p.check_params( { "precond", "solver" });
    }
 
    void get(PropertyTree& p, const std::string& path = "") const
    {
      ARCCORE_ALINA_PARAMS_EXPORT_CHILD(p, path, precond);
      ARCCORE_ALINA_PARAMS_EXPORT_CHILD(p, path, solver);
    }
  } prm;

  template <class Matrix>
  PreconditionedSolver(const AlinaContext& context,
                       const Matrix& A,
                       const params& prm = params(),
                       const backend_params& bprm = backend_params())
  : prm(prm)
  , n(backend::nbRow(A))
  , P(context, A, prm.precond, bprm)
  , S(context, backend::nbRow(A), prm.solver, bprm)
  {}
 
  // Constructs the preconditioner and creates iterative solver.
  // Takes shared pointer to the matrix in internal format.
  PreconditionedSolver(const AlinaContext& context,
                       std::shared_ptr<build_matrix> A,
                       const params& prm = params(),
                       const backend_params& bprm = backend_params())
  : prm(prm)
  , n(backend::nbRow(*A))
  , P(context, A, prm.precond, bprm)
  , S(context, backend::nbRow(*A), prm.solver, bprm)
  {}

  template <class Matrix, class Vec1, class Vec2>
  SolverResult operator()(const Matrix& A, const Vec1& rhs, Vec2&& x) const
  {
    return S(A, P, rhs, x);
  }

  template <class Vec1, class Vec2>
  SolverResult operator()(const Vec1& rhs, Vec2&& x) const
  {
    return S(P, rhs, x);
  }

  template <class Vec1, class Vec2>
  void apply(const Vec1& rhs, Vec2&& x) const
  {
    backend::clear(x);
    (*this)(rhs, x);
  }

  const Precond& precond() const
  {
    return P;
  }

  Precond& precond()
  {
    return P;
  }

  const IterativeSolver& solver() const
  {
    return S;
  }

  IterativeSolver& solver()
  {
    return S;
  }

  std::shared_ptr<typename Precond::matrix> system_matrix_ptr() const
  {
    return P.system_matrix_ptr();
  }
 
  typename Precond::matrix const& system_matrix() const
  {
    return P.system_matrix();
  }

  void get_params(Alina::PropertyTree& p) const
  {
    prm.get(p);
  }

  size_t size() const
  {
    return n;
  }
 
  size_t bytes() const
  {
    return backend::bytes(S) + backend::bytes(P);
  }
 
  friend std::ostream& operator<<(std::ostream& os, const PreconditionedSolver& p)
  {
    return os << "Solver\n======\n"
              << p.S << std::endl
              << "Preconditioner\n==============\n"
              << p.P;
  }
 
 private:
 
  size_t n;
  Precond P;
  IterativeSolver S;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::Alina
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/