SplitSDMeshPartitioner.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* SplitSDMeshPartitioner.h                                    (C) 2000-2024 */
/*                                                                           */
/* Mesh partitioner replicating the functionality of SplitSD.                */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_FILES_SPLITSDMESHPARTITIONER_H
#define ARCANE_FILES_SPLITSDMESHPARTITIONER_H
 
// #define DEBUG_PARTITIONER
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#include "arcane/std/MeshPartitionerBase.h"
 
#include "arcane/std/SplitSDMeshPartitioner_axl.h"
 
#define MPICH_SKIP_MPICXX
#define OMPI_SKIP_MPICXX
#include <mpi.h>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#define TAG_MAILLAGEMAITRE 1
 
#define CHECK_MPI_PACK_ERR(ier) \
  if (ier != MPI_SUCCESS) { \
    switch (ier) { \
    case MPI_ERR_COMM: \
      InfoProc->m_service->pfatal() << "error on MPI_Pack of type MPI_ERR_COMM"; \
      break; \
    case MPI_ERR_TYPE: \
      InfoProc->m_service->pfatal() << "error on MPI_Pack of type MPI_ERR_TYPE"; \
      break; \
    case MPI_ERR_COUNT: \
      InfoProc->m_service->pfatal() << "error on MPI_Pack of type MPI_ERR_COUNT"; \
      break; \
    case MPI_ERR_ARG: \
      InfoProc->m_service->pfatal() << "error on MPI_Pack of type MPI_ERR_ARG"; \
      break; \
    default: \
      InfoProc->m_service->pfatal() << "error on MPI_Pack of unknown type !"; \
    } \
  }
 
#ifndef CHECK_IF_NOT_NULL
#define CHECK_IF_NOT_NULL(Ptr) \
  if (Ptr == NULL) { \
    InfoProc->m_service->pfatal() << "Pointer is null, (Perhaps we lack memory !!! )"; \
  }
#endif
 
#ifndef MAX
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#endif
#ifndef MIN
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#endif
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
typedef struct T_InfoProc
{
  int me;
  int nbSubDomain;
  //   /** Master processor number,
  //       this is the processor on which aggregation,
  //       insertion and repartitioning are performed.*/
  //   int      NoMaitre;
  MPI_Comm Split_Comm;

  Arcane::AbstractService* m_service;

} StrucInfoProc;
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
typedef struct T_INTERFACE
{

  int NoDomVois;
  Arcane::UniqueArray<Arcane::Node> ListeNoeuds;
 
} StructureInterface;
 
typedef struct T_BLOC_ETENDU
{

  Integer NbElements;

  double PoidsDom;

  Integer NbIntf;

  StructureInterface* Intf;
 
} StructureBlocEtendu;
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
typedef struct T_ListeVoisMail
{
  int NoDomVois;
  int NbNoeudsInterface;
  double Delta;
  //   int                 PoidsInterface;  no meaning here
} StrucListeVoisMail;

typedef struct T_ListeDomMail
{
  int NbElements;
  double Poids;
  int NbVoisins;
  StrucListeVoisMail* ListeVoisins;
} StrucListeDomMail;

typedef struct T_Maillage
{
  int NbElements;
  double Poids;

  int NbDomainesPleins;
  int NbDomainesMax;
  StrucListeDomMail* ListeDomaines;

  int NbProcsVides;
  //   /** List of processors without a subdomain */
  //   int*                ListeNoProcsVides;

} StrucMaillage;
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class SplitSDMeshPartitioner
: public ArcaneSplitSDMeshPartitionerObject
//: public MeshPartitionerBase
{
 public:
 
  SplitSDMeshPartitioner(const ServiceBuildInfo& sbi);
 
 public:
 
  virtual void build() {}
 
 public:
 
  virtual void partitionMesh(bool initial_partition);
  virtual void partitionMesh(bool initial_partition, Int32 nb_part)
  {
    ARCANE_UNUSED(initial_partition);
    ARCANE_UNUSED(nb_part);
    throw NotImplementedException(A_FUNCINFO);
  }
 
 private:

  void init(bool initial_partition, StrucInfoProc*& InfoProc, StructureBlocEtendu*& Domaine, StrucMaillage*& Maillage);

  void initPoids(bool initial_partition);

  void fin(StrucInfoProc*& InfoProc, StructureBlocEtendu*& Domaine, StrucMaillage*& Maillage);

  void MAJDomaine(StructureBlocEtendu* Domaine);

  void MAJMaillageMaitre(StrucInfoProc* InfoProc, StructureBlocEtendu* Domaine, StrucMaillage* Maillage);

  void verifMaillageMaitre(StrucMaillage* Maillage);

  void MAJDeltaGlobal(StrucInfoProc* InfoProc, StrucMaillage* Maillage, double tolerance);
  void MAJDelta(double don, int iDOmTmpPrec, int iDomTmp, StrucListeDomMail* ListeDomaines);

  double CalculDeltaMin(StrucMaillage* Maillage, double deltaMin, int iterEquilibrage, int NbMaxIterEquil);

  void Equilibrage(StrucInfoProc* InfoProc, StructureBlocEtendu* Domaine, StrucMaillage* Maillage);

  void Equil2Dom(int* MasqueDesNoeuds, int* MasqueDesElements, int marqueVu, int marqueNonVu,
                 StrucInfoProc* InfoProc, StructureBlocEtendu* Domaine, StrucMaillage* Maillage,
                 int indDomCharge, int indDomVois, double Delta);

  void SelectElements(int* MasqueDesNoeuds, int* MasqueDesElements, int marqueVu, int marqueNonVu,
                      StrucInfoProc* InfoProc, StructureBlocEtendu* Domaine,
                      double Delta, int indDomVois, Arcane::Array<Arcane::Cell>& ListeElements);

  int ParcoursFrontalDelta(int* MasqueDesNoeuds, int* MasqueDesElements,
                           int marqueVu, int marqueNonVu,
                           double Delta,
                           int* pNbFronts, int NbFrontsMax,
                           Arcane::Array<Arcane::Node>& FrontsNoeuds, int* IndFrontsNoeuds,
                           Arcane::Array<Arcane::Cell>& FrontsElements, int* IndFrontsElements);

  void LissageDuFront(int* MasqueDesNoeuds, int* MasqueDesElements,
                      int marqueVu, int marqueNonVu,
                      int NbFronts,
                      Arcane::Array<Arcane::Node>& FrontsNoeuds, int* IndFrontsNoeuds,
                      Arcane::Array<Arcane::Cell>& FrontsElements, int* IndFrontsElements);

  void ConnexifieDomaine(StrucInfoProc* InfoProc, StructureBlocEtendu* Domaine, StrucMaillage* Maillage, double tolConnexite);

  int getDomVoisMaxFace(Arcane::Array<Arcane::Cell>& ListeElements, int me);

  int* GetMasqueDesNoeuds(StrucInfoProc* InfoProc);
  int* GetMasqueDesElements(StrucInfoProc* InfoProc);
 
  void LibereInfoProc(StrucInfoProc*& InfoProc);
  void LibereDomaine(StructureBlocEtendu*& Domaine);
  void LibereMaillage(StrucMaillage*& Maillage);
 
  void AfficheDomaine(int NbDom, StructureBlocEtendu* Domaine);
  void AfficheMaillage(StrucMaillage* Maillage);
  void AfficheListeDomaines(StrucListeDomMail* ListeDomaines, int NbDomaines);
  void AfficheEquilMaillage(StrucMaillage* Maillage);
 
  void* RecoitMessage(StrucInfoProc* InfoProc, int FromProc, int Tag, int* pTailleTMP);
  void EnvoieMessage(StrucInfoProc* InfoProc, int ToProc, int Tag, void* TabTMP, int TailleTMP);
  //   MPI_Request*  EnvoieIMessage(StrucInfoProc* InfoProc, int ToProc, int Tag, void* TabTMP, int TailleTMP);
  void* DiffuseMessage(StrucInfoProc* InfoProc, int FromProc, void* TabTMP, int TailleTMP);
 
  // size for transfer without nodes, only the size of ListeNoeuds
  int TailleDom(StructureBlocEtendu* Domaine);
  // the data is put into an array
  void PackDom(StrucInfoProc* InfoProc, StructureBlocEtendu* Domaine, void* TabTMP, int TailleTMP, MPI_Comm comm);
  // the data is extracted from an array
  void UnpackDom(void* TabTMP, int TailleTMP, MPI_Comm comm, StrucListeDomMail* DomMail);
 
  // size for domain transfer for Balancing, and for Delta
  int TailleEquil();
  // the data is put into an array
  void PackEquil(StrucInfoProc* InfoProc, int indDomCharge, int indDomVois, double Delta, void* TabTMP, int TailleTMP, MPI_Comm comm);
  // the data is extracted from an array
  void UnpackEquil(void* TabTMP, int TailleTMP, MPI_Comm comm, int* indDomCharge, int* indDomVois, double* Delta);
 
 private:
 
  VariableCellReal m_poids_aux_mailles; // weight calculated once per rebalancing call and follows the cells
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif