AlinaLib.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* AlinaLib.h                                                  (C) 2000-2026 */
/*                                                                           */
/* API publique pour Alina.                                                  */
/*---------------------------------------------------------------------------*/
#ifndef ARCCORE_ALINA_ALINALIB_H
#define ARCCORE_ALINA_ALINALIB_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*
 * Ce fichier est basé sur le travail effectué sur la bibliothèque AMGCL (version mars 2026)
 * qui peut être trouvée à https://github.com/ddemidov/amgcl.
 *
 * Copyright (c) 2012-2022 Denis Demidov <dennis.demidov@gmail.com>
 * SPDX-License-Identifier: MIT
 */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arccore/alina/AlinaGlobal.h"
 
#include "arccore/base/Span.h"
#include "arccore/message_passing/MessagePassingGlobal.h"
 
#include <memory>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::AlinaLib
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

struct ARCCORE_ALINA_EXPORT AlinaConvergenceInfo
{
  int iterations = 0;
  double residual = 0.0;
};
 
class IAlinaSolverImpl;
class AlinaPreconditioner;
class AlinaParametersImpl;
class AlinaSolverParametersImpl;
class AlinaPreconditionerImpl;
class AlinaSequentialSolverImpl;
class AlinaDistributedSolverImpl;
class AlinaSequentialSolverImpl;
class AlinaDistributedSolverImpl;
class AlinaSolver;
// Pour compatibilité
using AlinaDistributedSolver = AlinaSolver;
using AlinaSequentialSolver = AlinaSolver;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

enum class eAlinaSolverType
{
  ConjugateGradient,
  BiCGStab,
  GMRES
};

enum class eAlinaPreconditionerType
{
  AMG,
  Diagonal
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCCORE_ALINA_EXPORT AlinaParameters
{
  friend AlinaPreconditioner;
  friend AlinaSequentialSolver;
  friend AlinaDistributedSolver;
  friend AlinaSequentialSolverImpl;
  friend AlinaDistributedSolverImpl;
 
 public:
 
  AlinaParameters();
 
 public:

  void setInt32(const char* name, Int32 value);

  void setInt64(const char* name, Int64 value);

  void setReal(const char* name, Real value);

  void setString(const char* name, const char* value);

  void readFromJSON(const char* fname);
 
 private:
 
  std::shared_ptr<AlinaParametersImpl> m_p;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCCORE_ALINA_EXPORT AlinaSolverParameters
{
  friend AlinaSolver;
  friend AlinaSequentialSolverImpl;
  friend AlinaDistributedSolverImpl;
 
 public:

  AlinaSolverParameters();

  explicit AlinaSolverParameters(MessagePassing::IMessagePassingMng* mpm, ITraceMng* tm = nullptr);
  ~AlinaSolverParameters();
 
 public:

  void setInt32(const char* name, Int32 value);

  void setInt64(const char* name, Int64 value);

  void setReal(const char* name, Real value);

  void setString(const char* name, const char* value);

  void readFromJSON(const char* fname);
 
 public:
 
  // Options spécifiques aux solveurs
  void setSolverAbsoluteTolerance(Real value);
  void setSolverRelativeTolerance(Real value);
  void setSolverMaxIteration(Int32 value);
  void setSolverVerbosity(Int32 value);
 
  void setSolverPreconditioner(eAlinaPreconditionerType v);
  void setSolverType(eAlinaSolverType v);
 
 public:
 
  ITraceMng* traceMng() const;
 
 private:
 
  std::shared_ptr<AlinaSolverParametersImpl> m_p;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCCORE_ALINA_EXPORT AlinaCSRMatrixView
{
 public:
 
  AlinaCSRMatrixView(Int32 nb_row, const Int32* row_indexes, const Int32* columns, const double* values)
  : m_nb_row(nb_row)
  , m_row_indexes(row_indexes, nb_row + 1)
  , m_columns(columns, row_indexes[nb_row])
  , m_values(values, row_indexes[nb_row])
  {}
  AlinaCSRMatrixView(SmallSpan<const Int32> row_indexes,
                     SmallSpan<const Int32> columns, SmallSpan<const double> values)
  : m_nb_row(row_indexes.size() - 1)
  , m_row_indexes(row_indexes)
  , m_columns(columns)
  , m_values(values)
  {}
 
 public:
 
  constexpr Int32 nbRow() const { return m_nb_row; }
  constexpr SmallSpan<const Int32> rowIndexes() const { return m_row_indexes; }
  constexpr SmallSpan<const Int32> columns() const { return m_columns; }
  constexpr SmallSpan<const double> values() const { return m_values; }
 
 public:
 
  void dump(std::ostream& o) const;
 
 public:

  void checkSizes() const;
 
 private:
 
  Int32 m_nb_row = 0;
  SmallSpan<const Int32> m_row_indexes;
  SmallSpan<const Int32> m_columns;
  SmallSpan<const double> m_values;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCCORE_ALINA_EXPORT AlinaPreconditioner
{
 public:
 
  AlinaPreconditioner(int n,
                      const int* ptr,
                      const int* col,
                      const double* val,
                      const AlinaParameters* prm);
 
 public:

  void apply(const double* rhs, double* x);

  void report();
 
 private:
 
  std::shared_ptr<AlinaPreconditionerImpl> m_p;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCCORE_ALINA_EXPORT AlinaSolver
{
 public:

  AlinaSolver(const AlinaSolverParameters& params,
              const AlinaCSRMatrixView& matrix_view);
 
 public:

  AlinaConvergenceInfo solve(SmallSpan<const double> rhs,
                             SmallSpan<double> x);

  AlinaConvergenceInfo solveMatrix(const AlinaCSRMatrixView& matrix_view,
                                   SmallSpan<const double> rhs,
                                   SmallSpan<double> x);

  void report();
 
 public:
 
  std::shared_ptr<IAlinaSolverImpl> m_p;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::AlinaLib
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/