SplitSDMeshPartitioner.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 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) 2008  */
/*                                                                           */
/* Partitioneur de maillage reprenant le fonctionnement (simplifié) de SplitSD 
   utilisé à Dassault Aviation et développé à l'ONERA par EB en 1996-99
*/
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_FILES_SPLITSDMESHPARTITIONER_H
#define ARCANE_FILES_SPLITSDMESHPARTITIONER_H
 
// #define DEBUG_PARTITIONER
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#include "arcane/std/MeshPartitionerBase.h"
 
#include "arcane/cea/SplitSDMeshPartitioner_axl.h"
 
 
#define MPICH_SKIP_MPICXX
#define OMPI_SKIP_MPICXX
#include <mpi.h>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_BEGIN_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#define TAG_MAILLAGEMAITRE        1
 
#define CHECK_MPI_PACK_ERR(ier) \
  if (ier != MPI_SUCCESS) { \
     switch (ier) { \
     case MPI_ERR_COMM:InfoProc->m_service->pfatal()<<"erreur sur MPI_Pack de type MPI_ERR_COMM"; break; \
     case MPI_ERR_TYPE: InfoProc->m_service->pfatal()<<"erreur sur MPI_Pack de type MPI_ERR_TYPE"; break; \
     case MPI_ERR_COUNT: InfoProc->m_service->pfatal()<<"erreur sur MPI_Pack de type MPI_ERR_COUNT"; break; \
     case MPI_ERR_ARG: InfoProc->m_service->pfatal()<<"erreur sur MPI_Pack de type MPI_ERR_ARG"; break; \
     default: InfoProc->m_service->pfatal()<<"erreur sur MPI_Pack de type inconnu !"; \
     } \
  }
 
#ifndef CHECK_IF_NOT_NULL
#define CHECK_IF_NOT_NULL(Ptr) \
  if (Ptr==NULL) { \
      InfoProc->m_service->pfatal()<<"Pointeur vaut nil, (On manque peut-etre de place memoire !!! )"; \
    }
#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;
//   /** Numéro du processeur maître, 
//       c'est sur ce processeur que sont faites l'agglomération, 
//       l'insertion et le redécoupage.*/
//   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;  pas de signification ici
} 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;
//   /** Liste des processeurs sans sous-domaine */
//   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);
  
  // taille pour le transfert sans les noeuds, seulement la taille de ListeNoeuds
  int TailleDom(StructureBlocEtendu* Domaine);
  // les données sont mise dans un tableau
  void PackDom(StrucInfoProc* InfoProc, StructureBlocEtendu* Domaine, void* TabTMP, int TailleTMP, MPI_Comm comm);
  // les données sont extraite d'un tableau
  void UnpackDom(void* TabTMP, int TailleTMP, MPI_Comm comm, StrucListeDomMail* DomMail);
  
  // taille pour le transfert des numéros de domaine pour Equilibrage, et du Delta
  int TailleEquil();
  // les données sont mise dans un tableau
  void PackEquil(StrucInfoProc* InfoProc, int indDomCharge, int indDomVois, double Delta, void* TabTMP, int TailleTMP, MPI_Comm comm);
  // les données sont extraite d'un tableau
  void UnpackEquil(void* TabTMP, int TailleTMP, MPI_Comm comm, int* indDomCharge, int* indDomVois, double* Delta);
  
 
private:
  VariableCellReal m_poids_aux_mailles;    // poids que l'on calcul une fois par appel au rééquilibrage et qui suit les cellules
};
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_END_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif