DistributedEigenSparseLUDirectSolver.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* DistributedEigenSparseLUDirectSolver.h                      (C) 2000-2026 */
/*                                                                           */
/* Distributed wrapper for Eigen::SparseLU solver.                           */
/*---------------------------------------------------------------------------*/
#ifndef ARCCORE_ALINA_DISTRIBUTEDEIGENSPARSELUDIRECTSOLVER_H
#define ARCCORE_ALINA_DISTRIBUTEDEIGENSPARSELUDIRECTSOLVER_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/EigenSolver.h"
#include "arccore/alina/MessagePassingUtils.h"
#include "arccore/alina/DistributedDirectSolverBase.h"
 
#include <Eigen/SparseLU>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Alina
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <typename Backend>
class DistributedEigenSparseLUDirectSolver
: public DistributedDirectSolverBase<Backend, DistributedEigenSparseLUDirectSolver<Backend>>
{
  using Base = DistributedDirectSolverBase<Backend, DistributedEigenSparseLUDirectSolver<Backend>>;
 
 public:
 
  using value_type = Backend::value_type;
  using EigenMatrix = Eigen::SparseMatrix<value_type, Eigen::ColMajor, int>;
  using Solver = EigenSolver<Eigen::SparseLU<EigenMatrix>>;
  typedef typename Solver::params params;
  typedef CSRMatrix<value_type> build_matrix;

  template <class Matrix>
  DistributedEigenSparseLUDirectSolver(mpi_communicator comm, const Matrix& A,
                                       const params& prm = params())
  : prm(prm)
  {
    static_cast<Base*>(this)->init(comm, A);
  }
 
  static size_t coarse_enough()
  {
    return Base::coarse_enough();
  }
 
  int comm_size(int /*n*/) const
  {
    return 1;
  }
 
  void init(mpi_communicator, const build_matrix& A)
  {
    S = std::make_shared<Solver>(A, prm);
  }

  template <class Vec1, class Vec2>
  void solve(const Vec1& rhs, Vec2& x) const
  {
    (*S)(rhs, x);
  }
 
 private:
 
  params prm;
  std::shared_ptr<Solver> S;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::Alina
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif