TestDistributedAlinaLib.cc

// -*- 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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*
 * 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/MessagePassingUtils.h"
 
#include "arccore/common/Array.h"
 
#include "arccore/message_passing_mpi/StandaloneMpiMessagePassingMng.h"
 
#include "arccore/alina/AlinaLib.h"
 
#include "./SampleProblemCommon.h"
 
#include <gtest/gtest.h>
 
using namespace Arcane;
using namespace Arcane::AlinaLib;
 
TEST(alina_test_mpi, DistributedAlinaLib)
{
  Ref<IMessagePassingMng> mpm = MessagePassing::Mpi::StandaloneMpiMessagePassingMng::createRef(MPI_COMM_WORLD);
 
  int comm_rank = mpm->commRank();
  int comm_size = mpm->commSize();
 
  const Int32 n = 64;
 
  // Pour l'indexation en 32 bits
  using ColumnType = Int32;
  // Pour l'indexation en 64 bits
  // using ColumnType = Int64;
 
  std::vector<ColumnType> ptr;
  std::vector<ColumnType> col;
  std::vector<double> val;
  std::vector<double> rhs;
 
  Int32 chunk = Alina::PoissonProblemGenerator::createDistributedMatrix(comm_rank, comm_size, n, 1, ptr, col, val, rhs);
 
  // Configuration
  AlinaSolverParameters prm(mpm.get());
 
  prm.setString("precond.coarsening.type", "smoothed_aggregation");
  prm.setString("precond.relax.type", "spai0");
 
  UniqueArray<double> x(rhs.size(), 0.0);
 
  // Résolution
  {
    AlinaCSRMatrixView matrix_view(chunk, ptr.data(), col.data(), val.data());
    AlinaDistributedSolver solver(prm, matrix_view);
    SmallSpan<const double> rhs_view(rhs.data(), rhs.size());
    AlinaConvergenceInfo cnv = solver.solve(rhs_view, x.smallSpan());
 
    std::cout << "Iterations: " << cnv.iterations << std::endl
              << "Error:      " << cnv.residual << std::endl;
  }
}