Champ_Inc_base.h

/****************************************************************************
* Copyright (c) 2025, 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.
*
*****************************************************************************/
 
#ifndef Champ_Inc_base_included
#define Champ_Inc_base_included
 
#include <Interface_blocs.h>
#include <Domaine_forward.h>
#include <Domaine_VF.h>
#include <Champ_base.h>
#include <Domaine_VF.h>
#include <TRUSTTrav.h>
#include <TRUST_Ref.h>
#include <MorEqn.h>
#include <Roue.h>
#include <Motcle.h>
 
class Frontiere_dis_base;
class Domaine_dis_base;
class MD_Vector;
class YAML_data;
 
/*! @brief Class Champ_Inc_base
 *
 *      Base class of unknown fields which are fields calculated by an equation.
 *      A Roue type object is associated with Champ_Inc, this wheel allows managing the number of time values for which the field
 *      must remain in memory. It is the time scheme that guides the number of values to keep.
 *      This class can also be used to store fields calculated from other Champ_Inc. In this case, a function calculer_valeurs(...)
 *      is called during mettre_a_jour() and must fill:
 *       - the field values at the current time;
 *       - the derivatives of these values with respect to the unknowns;
 *       - its values at the boundaries (stored in an array, because the field has no
 *         associated BC);
 *
 *      OWN_PTR(Champ_Inc_base) is a piece of equation because it inherits from MorEqn.
 *
 * @sa MorEqn OWN_PTR(Champ_Inc_base) Champ_base Ch_proto Equation_base, Abstract class, Abstract methods:, const Domaine_dis_base& associer_domaine_dis_base(const Domaine_dis_base&), const Domaine_dis_base& domaine_dis_base() const, DoubleTab& remplir_coord_noeuds(DoubleTab& ) const
 */
 
class Champ_Inc_base : public Champ_base, public MorEqn
{
  Declare_base_sans_constructeur(Champ_Inc_base);
 
public:
  Champ_Inc_base() : fonc_calc_(nullptr) { } // by default: no fonc_calc_
 
  // Reimplemented methods
  int fixer_nb_valeurs_nodales(int) override;
  double changer_temps(const double temps) override;
  void mettre_a_jour(double temps) override;
  int reprendre(Entree&) override;
  int sauvegarder(Sortie&) const override;
 
  Champ_base& affecter_compo(const Champ_base&, int compo) override;
  void resetTime(double time) override;
 
  // Pure virtual methods implemented here
  Champ_base& affecter_(const Champ_base&) override;
  virtual void verifie_valeurs_cl();
 
  /*! @brief Returns the array of field values at the current time.
   *
   * @return (DoubleTab&) the array of field values
   */
  inline DoubleTab& valeurs() override { return les_valeurs->valeurs(); }
  inline const DoubleTab& valeurs() const override { return les_valeurs->valeurs(); }
 
  DoubleVect& valeur_a(const DoubleVect& position, DoubleVect& valeurs) const override;
  DoubleTab& valeur_aux(const DoubleTab& positions, DoubleTab& valeurs) const override;
  DoubleVect& valeur_aux_compo(const DoubleTab& positions, DoubleVect& valeurs, int ncomp) const override;
 
  // New methods
  int nb_valeurs_nodales() const override;
  virtual int fixer_nb_valeurs_temporelles(int);
  virtual int nb_valeurs_temporelles() const;
  double changer_temps_futur(double, int i = 1);
  double changer_temps_passe(double, int i = 1);
  double recuperer_temps_futur(int i = 1) const;
  double recuperer_temps_passe(int i = 1) const;
  DoubleTab& valeurs(double temps) override;
  const DoubleTab& valeurs(double temps) const override;
 
  // Implicit conversion operators
  operator DoubleTab& () = delete;
  operator const DoubleTab& () const = delete;
 
  /*! @brief Returns field values at instant t+i.
   *
   * @param (int i) the future time step at which we want the field values
   * @return (DoubleTab&) the field values at instant t+i
   */
  inline DoubleTab& futur(int i = 1) override { return les_valeurs->futur(i).valeurs(); }
  inline const DoubleTab& futur(int i = 1) const override { return les_valeurs->futur(i).valeurs(); }
 
  /*! @brief Returns field values at instant t-i.
   *
   * @param (int i) the past time step at which we want the field values
   * @return (DoubleTab&) the field values at instant t-i
   */
  inline DoubleTab& passe(int i = 1) override { return les_valeurs->passe(i).valeurs(); }
  inline const DoubleTab& passe(int i = 1) const override { return les_valeurs->passe(i).valeurs(); }
 
  Champ_Inc_base& avancer(int i = 1);
  Champ_Inc_base& reculer(int i = 1);
 
  int lire_donnees(Entree&);
  int imprime(Sortie&, int) const override;
  int a_un_domaine_dis_base() const override { return 1; }
 
  virtual void associer_eqn(const Equation_base&);
  virtual void associer_domaine_cl_dis(const Domaine_Cl_dis_base&);
  void associer_domaine_dis_base(const Domaine_dis_base&) override;
 
  const Domaine_Cl_dis_base& domaine_Cl_dis() const;
  Domaine_Cl_dis_base& domaine_Cl_dis();
  const Domaine_dis_base& domaine_dis_base() const override { return le_dom_VF.valeur(); }
  const Domaine_VF& domaine_vf() const { return le_dom_VF.valeur(); }
 
  DoubleTab& trace(const Frontiere_dis_base&, DoubleTab&, double, int distant) const override;
  virtual int remplir_coord_noeuds_et_polys(DoubleTab&, IntVect&) const;
  virtual int remplir_coord_noeuds_et_polys_compo(DoubleTab&, IntVect&, int) const;
  virtual DoubleTab& remplir_coord_noeuds(DoubleTab&) const =0;
  virtual DoubleTab& remplir_coord_noeuds_compo(DoubleTab&, int) const;
 
  virtual double integrale_espace(int ncomp) const;
  const Domaine& domaine() const;
 
  //derivatives of the field with respect to unknowns:
  //returns derivatives calculated by fonc_calc_ if calculated field, deriv[unknown name] = 1 if true unknown
  const tabs_t& derivees() const { return deriv_; }
  tabs_t& derivees() { return deriv_; }
  DoubleTab& val_bord() { return val_bord_; }
 
  //field depending on other OWN_PTR(Champ_Inc_base) : setting the calculation function, initialization of val_bord_
  void init_champ_calcule(const Objet_U& obj, fonc_calc_t fonc);
  //to force the calculation of all cases on the next mettre_a_jour() (normally done only once)
  void reset_champ_calcule() { fonc_calc_init_ = 0; }
 
  void resize_val_bord();
  void set_val_bord_fluide_multiphase(const bool flag) { bord_fluide_multiphase_ = flag; }
 
  //uses boundary conditions (instead of valeur_aux() in Champ_base)
  //result is filled only for boundary faces where the BC imposes a value (val_imp or val_ext)
  DoubleTab valeur_aux_bords() const override;
 
  // Obsolete method: signature changed in order to generate a compiler error if old code is not removed
  virtual void creer_espace_distant(int dummy) { }
 
  void set_via_ch_fonc_reprise() { via_ch_fonc_reprise_ = true; }
  bool via_ch_fonc_reprise() const { return via_ch_fonc_reprise_; }
 
  void PDI_save_type(bool b) { PDI_save_type_ = b; }
  virtual std::vector<YAML_data> data_a_sauvegarder() const;
  Nom get_PDI_dname() const;
  void set_PDI_dname(const Nom& name) { PDI_dname_ = (Motcle)name; }
 
protected:
  // By default we initialize values to zero
  virtual void creer_tableau_distribue(const MD_Vector&, RESIZE_OPTIONS = RESIZE_OPTIONS::COPY_INIT);
 
 
  Roue_ptr les_valeurs;
  OBS_PTR(Domaine_Cl_dis_base) mon_dom_cl_dis;
  OBS_PTR(Domaine_VF) le_dom_VF;
 
  /* for fields depending on other OWN_PTR(Champ_Inc_base) */
  fonc_calc_t fonc_calc_;  //calculation function
  int fonc_calc_init_ = 0; //1 once the field has been calculated at least once
  RefObjU obj_calc_; //an object to pass as argument
  DoubleTab val_bord_;   //boundary values at current time
  tabs_t deriv_;        //derivatives at current time
  bool bord_fluide_multiphase_ = false, via_ch_fonc_reprise_ = false;
 
  bool PDI_save_type_ = false; // do we save the type of the unknown in pdi format?
  Nom PDI_dname_; // For restart with PDI: to use if the name of the dataset we want to read is different from the name of the field
 
};
 
#endif /* Champ_Inc_base_included */