Champ_Generique_Interpolation.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 <Champ_Generique_Interpolation.h>
#include <Postraitement.h>
#include <Discretisation_base.h>
#include <Domaine_VF.h>
#include <Synonyme_info.h>
#include <Param.h>
#include <Domaine_dis_cache.h>
#include <Champ_Inc_P0_base.h>
#include <Champ_Fonc_P0_base.h>
 
Implemente_instanciable_sans_constructeur(Champ_Generique_Interpolation,"Champ_Post_Interpolation|Interpolation",Champ_Gen_de_Champs_Gen);
 
/*! @brief see reset()
 *
 */
Champ_Generique_Interpolation::Champ_Generique_Interpolation()
{
  // default values
  reset();
}
 
//see Champ_Gen_de_Champs_Gen::readOn
Entree& Champ_Generique_Interpolation::readOn(Entree& is)
{
  Champ_Gen_de_Champs_Gen::readOn(is);
  set_localisation(localisation_);
  set_methode(methode_);
 
  return is;
}
 
/*! @brief invalid call
 *
 */
Sortie& Champ_Generique_Interpolation::printOn(Sortie& os) const
{
  exit();
  return os;
}
 
//  localisation : interpolation localisation (elem or som)
//  domaine          : interpolation domain (optional)
//  methode          : type of calculation method "calculer_champ_post" (optional, only one method available)
void Champ_Generique_Interpolation::set_param(Param& param) const
{
// XD interpolation champ_post_de_champs_post interpolation INHERITS_BRACE To create a field which is an interpolation
// XD_CONT of the field given by the keyword source.
  Champ_Gen_de_Champs_Gen::set_param(param);
  param.ajouter("localisation",&localisation_,Param::REQUIRED); // XD_ADD_P chaine
  // XD_CONT type_loc indicate where is done the interpolation (elem for element or som for node).
  param.ajouter("methode",&methode_); // XD_ADD_P chaine
  // XD_CONT The optional keyword methode is limited to calculer_champ_post for the moment.
  param.ajouter("domaine",&nom_domaine_lu_);  // XD_ADD_P chaine
  // XD_CONT the domain name where the interpolation is done (by default, the calculation domain)
  param.ajouter("optimisation_sous_maillage",&optimisation_demande_); // XD_ADD_P dico
  // XD_CONT not_set
  param.dictionnaire("default",-1); // XD_ADD_DICO not_set
  param.dictionnaire("yes",1);  // XD_ADD_DICO not_set
  param.dictionnaire("no",0); // XD_ADD_DICO not_set
 
}
/*! @brief Restore the initial configuration of the object: localisation not specified, source not specified, methode=calculer_champ_post, native domain
 *
 */
void Champ_Generique_Interpolation::reset()
{
  nom_domaine_lu_ = "";
  localisation_ = "";
  methode_      = "calculer_champ_post";
  domaine_.reset();
  Champ_Gen_de_Champs_Gen::reset();
  optimisation_sous_maillage_=-1;
  optimisation_demande_=-1;
}
 
/*! @brief Class initialization: initialization of the requested localisation.
 *
 * Valid parameters: elem, som, faces, elem_dg.
 *
 */
int Champ_Generique_Interpolation::set_localisation(const Motcle& loc, int exit_on_error)
{
  Motcles localisations(4);
  localisations[0] = "elem";
  localisations[1] = "som";
  localisations[2] = "faces";
  localisations[3] = "elem_dg";
  int ok = 0;
  if (localisations.search(loc) >= 0)
    {
      localisation_ = loc;
      ok = 1;
    }
  else
    {
      Cerr << "Error in Champ_Generique_Interpolation::set_localisation\n"
           << " Keyword read : " << loc << "\n The localizations allowed are " << localisations << finl;
      if (exit_on_error)
        {
          exit();
        }
    }
  return ok;
}
 
/*! @brief Class initialization: initialization of the interpolation method. Valid parameters: calculer_champ_post
 *
 *   (Ideas for the future: assign, assign with integral...)
 *
 */
int Champ_Generique_Interpolation::set_methode(const Motcle& methode, int exit_on_error)
{
  Motcles methodes_interpolation(1);
  methodes_interpolation[0] = "calculer_champ_post";
  int ok = 0;
  if (methodes_interpolation.search(methode) >= 0)
    {
      methode_ = methode;
      ok = 1;
    }
  else
    {
      Cerr << "Error in Champ_Generique_Interpolation::set_methode\n"
           << " Keyword read : " << methode << "\n The methods allowed are " << methodes_interpolation << finl;
      if (exit_on_error)
        {
          exit();
        }
    }
  return ok;
}
 
/*! @brief Class initialization: initialization of the interpolation domain. Valid parameters: "" => native domain, or the name of a Domaine object known to the interpreter
 *
 */
int Champ_Generique_Interpolation::set_domaine(const Nom& nom_domaine, int exit_on_error)
{
  int ok = 0;
  if (nom_domaine == "")
    {
      domaine_.reset(); // null reference => native domain of the field
      ok = 1;
    }
  else
    {
      const Objet_U& ob = interprete().objet(nom_domaine);
      if (!sub_type(Domaine, ob))
        {
          Cerr << "Error in Champ_Generique_Interpolation::set_domaine(nom_domaine)\n"
               << " The object " << nom_domaine << " is not a domain" << finl;
          if (exit_on_error)
            {
              exit();
            }
        }
      else
        {
          domaine_ = ref_cast(Domaine, ob);
        }
    }
  return ok;
}
 
/*! @brief Interpolation of the source field based on the requested method, localisation, and domain.
 *
 */
const Champ_base& Champ_Generique_Interpolation::get_champ(OWN_PTR(Champ_base)&) const
{
  OWN_PTR(Champ_base) espace_stockage_source_tmp;
  const Champ_base& source = get_source(0).get_champ_without_evaluation(espace_stockage_source_tmp);
  if (localisation_ == "")
    {
      Cerr << "Error in Champ_Generique_Interpolation::get_champ()\n"
           << " Localisation has not been initialized" << finl;
      exit();
    }
  else if (source.is_basis_function() or source.is_quadrature())
    {
      if (localisation_=="elem")
        {
          return get_source(0).get_champ(espace_stockage_source_);
        }
      else if (localisation_!="elem_dg")
        {
          Cerr << "Error in Champ_Generique_Interpolation::get_champ\n"
               << "with DG the only possible localisation for Transformation is \"elem\"" << finl;
          exit();
        }
    }
 
  if (methode_ == "calculer_champ_post")
    {
      get_champ_with_calculer_champ_post();
    }
  else
    {
      Cerr << "Champ_Generique_Interpolation::get_champ : methode " << methode_ << " uncoded" << finl;
      exit();
    }
 
  return espace_stockage_;
}
 
const Champ_base& Champ_Generique_Interpolation::get_champ_without_evaluation(OWN_PTR(Champ_base)& espace_stockage) const
{
 
  OWN_PTR(Champ_base) espace_stockage_source_tmp;
  const Champ_base& source = get_source(0).get_champ_without_evaluation(espace_stockage_source_tmp);
  // Domain on which we interpolate the field:
  //  if domaine_ is a null reference, we take the native domain of the field.
 
  const Noms compo = get_property("composantes");
  const Noms nom_champ = get_property("nom");
  const Noms syno = get_property("synonyms");
 
  int ncomp;
  //We set identifiant_appel_ to nom_champ[0] in the case where it equals ??
  if (identifiant_appel_=="??")
    {
      ncomp = -1;
    }
  else
    {
      ncomp = Champ_Generique_base::composante(identifiant_appel_,nom_champ[0],compo,syno);
    }
 
  //Creation of the storage space field
  Nature_du_champ nature_source = (ncomp==-1)?source.nature_du_champ():scalaire;
  nature_source = source.nature_du_champ();
  int nb_comp = source.nb_comp();
 
  OWN_PTR(Champ_Fonc_base)  es_tmp;
  espace_stockage = creer_espace_stockage(nature_source,nb_comp,es_tmp);
  return espace_stockage;
}
/*! @brief Interpolation of the source field using Champ_base::calculer_champ_xxx_post
 *
 */
const Champ_base& Champ_Generique_Interpolation::get_champ_with_calculer_champ_post() const
{
  const Champ_base& source0 = get_source(0).get_champ(espace_stockage_source_);
  OWN_PTR(Champ_base) source_bis;
 
  if (optimisation_sous_maillage_==-1)
    {
      source_bis=source0;
      //source.typer(source0.que_suis_je());
 
    }
  const Champ_base& source  = ((optimisation_sous_maillage_==-1)?source_bis.valeur():source0);
  Nom nom_champ_interpole;
 
  // Domain on which we interpolate the field:
  //  if domaine_ is a null reference, we take the native domain of the field.
  const Domaine& domaine = get_ref_domain();
  const Noms compo = get_property("composantes");
  const Noms nom_champ = get_property("nom");
  const Noms syno = get_property("synonyms");
 
  int ncomp;
  //We set identifiant_appel_ to nom_champ[0] in the case where it equals ??
  if (identifiant_appel_=="??")
    {
      ncomp = -1;
    }
  else
    {
      ncomp = Champ_Generique_base::composante(identifiant_appel_,nom_champ[0],compo,syno);
    }
 
  //Creation of the storage space field
  Nature_du_champ nature_source = (ncomp==-1)?source.nature_du_champ():scalaire;
  nature_source = source.nature_du_champ();
  int nb_comp = source.nb_comp();
  if (!espace_stockage_)
    creer_espace_stockage(nature_source, nb_comp, espace_stockage_);
  espace_stockage_->changer_temps(source.temps());
 
  //double default_value=-1e35;
  //espace_stockage.valeurs()=default_value;
  int decal=10;
  if (optimisation_sous_maillage_==-1)
    {
      espace_stockage_->valeurs()=0;
      // first call with different mesh (or forced), we try to see if we can optimize
      // we set the source field values to val(i)=i, to recover the cell number afterwards
      DoubleTab& val=source_bis->valeurs();
 
      int dim0 = val.dimension_tot(0);
      for (int i=0; i<dim0; i++)
        for (int j=0; j<nb_comp; j++)
          val(i,j) = i+decal;
    }
 
  //Evaluation of the storage space field values
  DoubleTab& espace_valeurs = espace_stockage_->valeurs();
 
  if (optimisation_sous_maillage_==1)
    {
      const DoubleTab& val_temp= source.valeurs();
      int dim0 = espace_valeurs.dimension(0);
      for (int i=0; i<dim0; i++)
        if (ncomp==-1)
          for (int j=0; j<nb_comp; j++)
            {
              int n=renumerotation_maillage_[i];
              if (n>=0)
                espace_valeurs(i,j) = val_temp(n,j);
            }
        else espace_valeurs(i, ncomp) = val_temp[renumerotation_maillage_[i]];
 
      espace_valeurs.echange_espace_virtuel();
      return espace_stockage_;
    }
 
  int imax = espace_valeurs.dimension(0);
  if (localisation_ == "elem" || localisation_=="elem_DG")
    {
      const int nb_elements = domaine.nb_elem();
      nb_comp = espace_stockage_->nb_comp(); // with DG, espace_stockage has smaller dimension than source
      if (ncomp==-1)
        {
          DoubleTrav val_temp;
          source.calculer_valeurs_elem_post(val_temp,
                                            nb_elements,
                                            nom_champ_interpole,
                                            domaine);
          if (val_temp.isDataOnDevice())
            {
              CDoubleTabView val_temp_v = val_temp.view_ro();
              DoubleTabView espace_valeurs_v = espace_valeurs.view_wo();
              Kokkos::parallel_for(start_gpu_timer(__KERNEL_NAME__),
              Kokkos::MDRangePolicy < Kokkos::Rank < 2 >> ({ 0, 0 },
              {imax, nb_comp}), KOKKOS_LAMBDA(
                const int i,
                const int j)
              {
                espace_valeurs_v(i, j) = val_temp_v(i, j);
              });
              end_gpu_timer(__KERNEL_NAME__);
            }
          else
            {
              for (int i_val=0; i_val<imax; i_val++)
                for (int j_val=0; j_val<nb_comp; j_val++)
                  espace_valeurs(i_val,j_val) = val_temp(i_val,j_val);
            }
        }
      else
        //We build a value array with nb_comp components even if ncomp!=-1
        {
          DoubleTrav val_temp;
          source.calculer_valeurs_elem_compo_post(val_temp,
                                                  ncomp,
                                                  nb_elements,
                                                  nom_champ_interpole,
                                                  domaine);
          if (val_temp.isDataOnDevice())
            {
              CDoubleArrView val_temp_v = static_cast<const DoubleVect&>(val_temp).view_ro();
              DoubleTabView espace_valeurs_v = espace_valeurs.view_wo();
              Kokkos::parallel_for(start_gpu_timer(__KERNEL_NAME__),
              Kokkos::MDRangePolicy < Kokkos::Rank < 2 >> ({ 0, 0 },
              {val_temp.dimension(0), nb_comp}), KOKKOS_LAMBDA(
                const int i,
                const int j)
              {
                if (j == ncomp)
                  espace_valeurs_v(i, j) = val_temp_v(i);
              });
              end_gpu_timer(__KERNEL_NAME__);
            }
          else
            {
              int dim0 = val_temp.dimension(0);
              for (int i=0; i<dim0; i++)
                for (int j=0; j<nb_comp; j++)
                  if (j==ncomp)
                    espace_valeurs(i,j) = val_temp(i);
            }
        }
    }
  else if (localisation_=="som")
    {
      const int nb_sommets = domaine.nb_som();
      // PL: update the virtual space of the source:
      OWN_PTR(Champ_base) copie_source;
      copie_source = source;
      copie_source->valeurs().echange_espace_virtuel();
      if (ncomp==-1)
        {
          DoubleTrav val_temp;
          copie_source->calculer_valeurs_som_post(val_temp,
                                                  nb_sommets,
                                                  nom_champ_interpole,
                                                  domaine);
          if (val_temp.isDataOnDevice())
            {
              CDoubleTabView val_temp_v = val_temp.view_ro();
              DoubleTabView espace_valeurs_v = espace_valeurs.view_wo();
              Kokkos::parallel_for(start_gpu_timer(__KERNEL_NAME__),
              Kokkos::MDRangePolicy < Kokkos::Rank < 2 >> ({ 0, 0 },
              {imax, nb_comp}), KOKKOS_LAMBDA(
                const int i,
                const int j)
              {
                espace_valeurs_v(i, j) = val_temp_v(i, j);
              });
              end_gpu_timer(__KERNEL_NAME__);
            }
          else
            {
              for (int i_val=0; i_val<imax; i_val++)
                for (int j_val=0; j_val<nb_comp; j_val++)
                  espace_valeurs(i_val,j_val) = val_temp(i_val,j_val);
            }
        }
      else
        //We build a value array with nb_comp components even if ncomp!=-1
        {
          DoubleTrav val_temp;
          copie_source->calculer_valeurs_som_compo_post(val_temp,
                                                        ncomp,
                                                        nb_sommets,
                                                        nom_champ_interpole,
                                                        domaine);
          if (val_temp.isDataOnDevice())
            {
              CDoubleArrView val_temp_v = static_cast<const DoubleVect&>(val_temp).view_ro();
              DoubleTabView espace_valeurs_v = espace_valeurs.view_wo();
              Kokkos::parallel_for(start_gpu_timer(__KERNEL_NAME__),
              Kokkos::MDRangePolicy < Kokkos::Rank < 2 >> ({ 0, 0 },
              {val_temp.dimension(0), nb_comp}), KOKKOS_LAMBDA(
                const int i,
                const int j)
              {
                if (j == ncomp)
                  espace_valeurs_v(i, j) = val_temp_v(i);
              });
              end_gpu_timer(__KERNEL_NAME__);
            }
          else
            {
              int dim0 = val_temp.dimension(0);
              for (int i=0; i<dim0; i++)
                for (int j=0; j<nb_comp; j++)
                  if (j==ncomp)
                    espace_valeurs(i,j) = val_temp(i);
            }
        }
    }
  else
    {
      espace_stockage_->affecter(source);
    }
 
  if (optimisation_sous_maillage_==-1)
    {
      // we recompute the correct field
 
      DoubleTab& val=espace_valeurs;
      int dim0 = val.dimension_tot(0);
      ArrOfInt& renumerotation_maillage=ref_cast_non_const(ArrOfInt, renumerotation_maillage_);
      renumerotation_maillage.resize_array(dim0);
      int ok=1;
 
      for (int i=0; (i<dim0)&& ok; i++)
        {
          double v;
          v=espace_valeurs(i,0) ;
 
          int iproche=-1;
          if (v>0)
            {
              iproche=int(v+0.1); // we add 0.1 for the case where v equals i-epsilon
              if (std::fabs(iproche-v)>1e-5)
                {
                  ok=0;
                  Cerr<<nom_champ[0]<<" optimisation ko "<< finl;
 
                }
            }
          renumerotation_maillage[i]=iproche-decal;
 
        }
 
      int test=(int)mp_min(ok);
      if (test)
        {
          ref_cast_non_const(Champ_Generique_Interpolation,(*this)).optimisation_sous_maillage_=0;
          OWN_PTR(Champ_base) espace_stockage_test;
          espace_stockage_test = get_champ_with_calculer_champ_post();
          ref_cast_non_const(Champ_Generique_Interpolation,(*this)).optimisation_sous_maillage_=test;
          get_champ_with_calculer_champ_post();
          espace_stockage_test->valeurs()-=espace_stockage_->valeurs();
          double dmax= mp_max_abs_vect(espace_stockage_test->valeurs());
          if (dmax > 1e-7)
            {
              Cerr<<nom_champ[0]<<" optimisation ko "<< dmax<<finl;
              exit();
            }
          else
            Cerr<<nom_champ[0]<<" optimisation ok "<< dmax<<finl;
        }
 
      else
        {
          if (optimisation_demande_==1)
            {
              Cerr<<nom_champ[0]<<" optimisation not allowed "<<finl;
              exit();
            }
        }
      ref_cast_non_const(Champ_Generique_Interpolation,(*this)).optimisation_sous_maillage_=test;
      return get_champ_with_calculer_champ_post();
    }
 
  espace_valeurs.echange_espace_virtuel();
  return espace_stockage_;
}
 
const DoubleTab& Champ_Generique_Interpolation::get_ref_values() const
{
  OWN_PTR(Champ_base) champ_a_ecrire;
  get_champ(champ_a_ecrire);
  return champ_a_ecrire->valeurs();
}
 
void Champ_Generique_Interpolation::get_copy_values(DoubleTab& values) const
{
  const DoubleTab& val = get_ref_values();
  // Create a copy of the array
  values = val;
}
 
Entity Champ_Generique_Interpolation::get_localisation(const int index) const
{
  Entity loc;
  if (localisation_=="elem"||localisation_=="elem_DG")
    loc = Entity::ELEMENT;
  else if (localisation_=="som")
    loc = Entity::NODE;
  else if (localisation_=="faces")
    loc = Entity::FACE;
  else
    {
      Cerr << "Error of type : localisation should be specified to elem or som or faces for the defined field " << nom_post_ << finl;
      throw Champ_Generique_erreur("INVALID");
    }
  return loc;
}
 
const Domaine& Champ_Generique_Interpolation::get_ref_domain() const
{
  if (domaine_)
    {
      return domaine_.valeur();
    }
  else
    {
      return get_source(0).get_ref_domain();
    }
}
 
void Champ_Generique_Interpolation::get_copy_domain(Domaine& domain) const
{
  const Domaine& dom = get_ref_domain();
  domain = dom;
}
 
const DoubleTab& Champ_Generique_Interpolation::get_ref_coordinates() const
{
  const DoubleTab& coord = get_ref_domain().coord_sommets();
  return coord;
}
 
void Champ_Generique_Interpolation::get_copy_coordinates(DoubleTab& coordinates) const
{
  const DoubleTab& coord = get_ref_coordinates();
  coordinates = coord;
}
 
const Noms Champ_Generique_Interpolation::get_property(const Motcle& query) const
{
 
  Motcles motcles(2);
  motcles[0] = "composantes";
  motcles[1] = "synonyms";
  int rang = motcles.search(query);
  switch(rang)
    {
 
    case 0:
      {
        Noms source_compos = get_source(0).get_property("composantes");
        int nb_comp = source_compos.size();
        Noms compo(nb_comp);
 
        if (compo_.size()>1)
          {
            //The field was created by a macro and the compo_ attribute of Champ_Generique_base was filled
            //This allows reproducing the component names in the lml files
            compo=compo_;
          }
        else
          {
            for (int i=0; i<nb_comp; i++)
              {
                Nom nume(i);
                compo[i] = nom_post_+nume;
              }
          }
        return compo;
      }
    case 1:
      {
        if (syno_.size()>0)
          {
            return syno_;
          }
        return get_source(0).get_property("synonyms");
      }
 
    }
 
  return Champ_Gen_de_Champs_Gen::get_property(query);
 
}
//Name the field as a source by default
//nom_champ_source + "_" + localisation_ + "_" +nom_dom_interp;
void Champ_Generique_Interpolation::nommer_source()
{
  if (nom_post_=="??")
    {
      Nom nom_post_source, nom_champ_source, nom_dom_interp;
      const Noms nom = get_source(0).get_property("nom");
      nom_champ_source = nom[0];
      nom_dom_interp = get_ref_domain().le_nom();
      nom_post_source = nom_champ_source + "_" + localisation_ + "_" +nom_dom_interp;
      nommer(nom_post_source);
    }
}
 
const Noms& Champ_Generique_Interpolation::fixer_noms_synonyms(const Noms& noms)
{
  return syno_=noms;
}
const Noms& Champ_Generique_Interpolation::fixer_noms_compo(const Noms& noms)
{
  return compo_=noms;
}
 
void Champ_Generique_Interpolation::completer(const Postraitement_base& post)
{
  Champ_Gen_de_Champs_Gen::completer(post);
  // Verifications:
  if (get_nb_sources() != 1)
    {
      Cerr << "Error in Champ_Generique_Interpolation::readOn\n"
           << " You must specify exactly 1 \"Source\"." << finl;
      exit();
    }
  // If the read domain is not the calculation domain, we set the domain
  const Domaine& domaine_calcul = get_source(0).get_ref_domain();
  if (optimisation_demande_!=1)
    optimisation_sous_maillage_=0;
  if ( (nom_domaine_lu_!="") && (nom_domaine_lu_!=domaine_calcul.le_nom()) )
    {
      set_domaine(nom_domaine_lu_);
    }
  else
    {
      // sub-mesh optimization not needed
      if (optimisation_demande_==-1)
        optimisation_sous_maillage_=0;
    }
 
  discretiser_domaine();
}
const Domaine_dis_base& Champ_Generique_Interpolation::get_ref_domaine_dis_base() const
{
  if (domaine_)
    {
      if (!le_dom_dis)
        {
          Cerr << "Error in Interpolation definition:" << finl;
          Cerr << "The domain " << domaine_->le_nom() << " is not built." << finl;
          exit();
        }
      return le_dom_dis.valeur();
    }
  else
    {
      return Champ_Gen_de_Champs_Gen::get_ref_domaine_dis_base();
    }
}
 
const Motcle Champ_Generique_Interpolation::get_directive_pour_discr() const
{
  Motcle directive;
 
  if (localisation_=="elem")
    {
      OWN_PTR(Champ_base) espace_stockage_source_tmp;
      const Champ_base& ch = get_source(0).get_champ_without_evaluation(espace_stockage_source_tmp);
      directive = ch.is_basis_function() ? "champ_elem_DG" : (ch.is_quadrature() ? "champ_fonc_quad_DG" : "champ_elem");
    }
  else if (localisation_=="elem_DG")
    directive = "champ_elem";
  else if (localisation_=="som")
    directive = "champ_sommets";
  else if (localisation_=="faces")
    directive = "champ_face";
  else
    {
      Cerr<<"Localisation "<<localisation_<<" is not recognized by "<<que_suis_je()<<finl;
      exit();
    }
 
  return directive;
}
 
//Discretisation of the interpolation domain if it is not the calculation domain
//This discretisation is necessary to associate a discretized domain to the storage space
//in the get_champ() method
void Champ_Generique_Interpolation::discretiser_domaine()
{
  if (domaine_)
    {
      const Probleme_base& Pb = get_ref_pb_base();
      const Discretisation_base& discr = Pb.discretisation();
      Nom type_discr = discr.que_suis_je();
      if (type_discr == "VEFPreP1B") type_discr = "VEF";
      // we do not create faces unless we want a face interpolation or we have polyhedra
      // Nom type = sub_type(Poly_geom_base, domaine_->type_elem().valeur()) ? "Domaine_" : "NO_FACE_Domaine_";
      Nom type = "NO_FACE_Domaine_";
      if (localisation_=="faces")
        {
          type="Domaine_";
          // We verify that face localisation is possible on the domain (otherwise elem or som)
          if (domaine_->type_elem()->nb_som_face()<=2 && dimension==3)
            {
              Cerr << "'localisation faces' is not possible in 3D on the 2D surface mesh " << domaine_->le_nom() << " with the field: " << get_property("NOM")[0] << finl;
              Cerr << "Please use 'localisation elem' instead." << finl;
              exit();
            }
        }
      type += type_discr;
      le_dom_dis = Domaine_dis_cache::Build_or_get(type, domaine_.valeur());
    }
}