Partitionneur_Partition.cpp

/****************************************************************************
* Copyright (c) 2026, CEA
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*****************************************************************************/
#include <Cast.h>
#include <Interprete.h>
#include <Partitionneur_Partition.h>
#include <Domaine.h>
#include <Reordonner_faces_periodiques.h>
#include <EFichier.h>
#include <Param.h>
 
Implemente_instanciable(Partitionneur_Partition,"Partitionneur_Partition",Partitionneur_base);
// XD partitionneur_partition partitionneur_deriv PARTITION INHERITS_BRACE This algorithm re-use the partition of the
// XD_CONT domain named DOMAINE_NAME. It is useful to partition for example a post processing domain. The partition
// XD_CONT should match with the calculation domain.
// XD attr domaine ref_domaine domaine REQ domain name
 
 
 
Sortie& Partitionneur_Partition::printOn(Sortie& os) const
{
  Cerr << "Partitionneur_Partition::printOn invalid\n" << finl;
  exit();
  return os;
}
 
/*! @brief The syntax is { Domaine NOM_DOM }
 *
 */
void Partitionneur_Partition::set_param(Param& param) const
{
  if (!ref_domaine_interpol_)
    {
      Cerr << " Error: the domain has not been associated" << finl;
      Process::exit();
    }
  param.ajouter("domaine",&dom_calcul_,Param::REQUIRED);
}
 
void Partitionneur_Partition::validate_params() const
{
  Cerr << que_suis_je() << "::validate_params" << finl;
  Cerr << " Reference domain : " << dom_calcul_ << finl;
 
  if (Interprete::objet_existant(dom_calcul_) == 0)
    {
      Cerr << "ERROR:  provided name '" << dom_calcul_ <<"' does not name an existing object."<< finl;
      Process::exit();
    }
 
  if (not sub_type(Domaine, Interprete::objet(dom_calcul_)))
    {
      Cerr << "ERROR:  provided name '" << dom_calcul_ <<"' is not a domain."<< finl;
      Process::exit();
    }
}
 
/*! @brief First initialisation step of the partitioner: associate a domain.
 *
 */
void Partitionneur_Partition::associer_domaine(const Domaine& domaine)
{
  ref_domaine_interpol_ = domaine;
}
 
/*! @brief Second initialisation step: define the number of slices.
 *
 * (readOn can be used instead).
 *
 * WARNING: the message above is copy-pasted from Partitionneur_Tranche and is incorrect;
 * please correct this if you know better.
 */
void Partitionneur_Partition::initialiser()
{
 
  assert(ref_domaine_interpol_);
}
 
void Partitionneur_Partition::construire_partition(IntVect& elem_part, int& nb_parts_tot) const
{
 
 
  OBS_PTR(Domaine) ref_domaine_calcul_ = ref_cast(Domaine, Interprete::objet(dom_calcul_));
  assert(ref_domaine_interpol_);
  assert(ref_domaine_calcul_);
 
  // Domaine dom_interpol
  const Domaine& dom_interpol = ref_domaine_interpol_.valeur();
  if(dom_interpol.nb_som()==0)
    {
      Cerr << "The domain \"" << dom_interpol.le_nom() << "\" to be split is empty !" << finl;
      exit();
    }
  const int nb_elem_interpol = dom_interpol.nb_elem_tot();
  const int dim_interpol = dom_interpol.dimension;
 
  // Domaine dom_calcul
  const Domaine dom_calcul = ref_domaine_calcul_.valeur();
  if(dom_calcul.nb_som()==0)
    {
      Cerr << "The reference domain \"" << dom_calcul.le_nom() << "\" is empty !" << finl;
      exit();
    }
  const int nb_elem_calcul = dom_calcul.nb_elem();
  const int dim_calcul = dom_calcul.dimension;
 
  IntVect elem_part_calcul;
  int nb_parts_tot_calcul;
  EFichier file;
  Nom nom_fichier;
  nom_fichier=nom_du_cas()+"_"+dom_calcul.le_nom()+".dec";
  file.ouvrir(nom_fichier);
  if (!file.good())
    {
      Cerr << "Error in Partitionneur_Partition::construire_partition\n";
      Cerr << " Failed to open file " << nom_fichier << finl;
      Cerr << "To use the partitioner Partition, you must check" << finl;
      Cerr << "that you use the option:" << finl;
      Cerr << "Ecrire_decoupage " << nom_fichier << finl;
      Cerr << "In the splitting block of the computational domain " << dom_calcul.le_nom() << finl;
      exit();
    }
  file >> elem_part_calcul;
  file >> nb_parts_tot_calcul;
  file.close();
 
  const int sz = elem_part_calcul.size_array();
  if (nb_elem_calcul != sz)
    {
      Cerr << "Error in Partitionneur_Partition::construire_partition\n";
      Cerr << " The file " << nom_fichier << " contains an array of " << sz << " values.\n";
      Cerr << " The area contains " << nb_elem_calcul << " elements" << finl;
      exit();
    }
 
  // Centre of gravity of the elements of dom_interpol
  DoubleTab coord_g_interpol;
  // Compute the centres of gravity of the elements of dom_interpol
  dom_interpol.calculer_centres_gravite(coord_g_interpol);
  assert(coord_g_interpol.dimension(0) == nb_elem_interpol);
  assert(coord_g_interpol.dimension(1) == dim_interpol);
 
  // Centre of gravity of the elements of dom_calcul
  DoubleTab coord_g_calcul;
  // Compute the centres of gravity of the elements of dom_calcul
  dom_calcul.calculer_centres_gravite(coord_g_calcul);
  assert(coord_g_calcul.dimension(0) == nb_elem_calcul);
  assert(coord_g_calcul.dimension(1) == dim_calcul);
 
  elem_part.resize(nb_elem_interpol);
  elem_part = 0;
  // Find the nearest centres of gravity
  {
    int i,j;
    double distance_min,distance;
    for (i = 0; i < nb_elem_interpol; i++)
      {
        distance_min=1e+9;
        double x_interpol = coord_g_interpol(i,0);
        double y_interpol = coord_g_interpol(i,1);
        double z_interpol = (dim_interpol == 3) ? coord_g_interpol(i,2) : 0.;
        for (j = 0; j < nb_elem_calcul; j++)
          {
            double x_calcul = coord_g_calcul(j,0);
            double y_calcul = coord_g_calcul(j,1);
            double z_calcul = (dim_calcul == 3) ? coord_g_calcul(j,2) : 0.;
            distance=sqrt((x_calcul-x_interpol)*(x_calcul-x_interpol)+(y_calcul-y_interpol)*(y_calcul-y_interpol)+(z_calcul-z_interpol)*(z_calcul-z_interpol));
            if (distance < distance_min)
              {
                distance_min=distance;
                elem_part[i]=elem_part_calcul[j];
              }
          }
      }
  }
 
  int nb_parties_interpol, nb_parties_calcul;
  nb_parties_interpol=0;
  nb_parties_calcul=0;
  // Number of procs in elem_part
  if (elem_part.size_array() > 0)
    nb_parties_interpol = max_array(elem_part) + 1;
  // Number of procs in elem_part_calcul
  if (elem_part_calcul.size_array() > 0)
    nb_parties_calcul = max_array(elem_part_calcul) + 1;
  // If empty parts, take them into account
  if (nb_parties_calcul < nb_parts_tot_calcul)
    nb_parties_calcul = nb_parts_tot_calcul;
  else
    nb_parts_tot_calcul = nb_parties_calcul;
 
  // Total number of parts to generate
  if ((nb_parties_interpol < nb_parties_calcul) && nb_parts_tot==-1)
    nb_parts_tot=nb_parties_calcul;
  if (nb_parts_tot_calcul < nb_parts_tot)
    nb_parts_tot=nb_parts_tot_calcul;
}