Turbulence_paroi_scal_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 Turbulence_paroi_scal_base_included
#define Turbulence_paroi_scal_base_included
 
#include <Champs_compris_interface.h>
#include <Champ_Fonc_base.h>
#include <Champs_compris.h>
#include <TRUSTVects.h>
#include <TRUST_Ref.h>
 
class Modele_turbulence_scal_base;
class Domaine_Cl_dis_base;
class Domaine_dis_base;
class Probleme_base;
class EcrFicPartage;
class Domaine_VF;
 
/*! @brief Base class for the hierarchy of scalar wall-law models computing turbulent quantities near walls.
 *         The main method to implement in derived classes is calculer_scal,
 *         which must compute and fill the equivalent_distance_ array of equivalent wall distances.
 *
 * @sa abstract class
 */
class Turbulence_paroi_scal_base: public Champs_compris_interface, public Objet_U
{
  Declare_base_sans_constructeur(Turbulence_paroi_scal_base);
public:
  Turbulence_paroi_scal_base() : nb_impr_(0), calcul_ldp_en_flux_impose_(0), Prdt_sur_kappa_(2.12) { }
 
  static void typer_lire_turbulence_paroi_scal(OWN_PTR(Turbulence_paroi_scal_base)&, const Modele_turbulence_scal_base&, Entree& );
 
  /* XXX Elie Saikali : re-mets ici et pas dans Objet_U */
  int sauvegarder(Sortie& os) const override { return 0; }
  int reprendre(Entree& is) override { return 1; }
  virtual std::vector<YAML_data> data_a_sauvegarder() const { return std::vector<YAML_data>(); }
 
  inline void associer_modele(const Modele_turbulence_scal_base&);
  virtual void associer(const Domaine_dis_base&, const Domaine_Cl_dis_base&)=0;
  virtual void completer() { }
  virtual int init_lois_paroi() =0;
  virtual int calculer_scal(Champ_Fonc_base&) =0;
  virtual void compute_nusselt() const =0;
  virtual void imprimer_nusselt(Sortie&) const
  {
    Cerr << "imprimer_nusselt not implemented for " << que_suis_je() << finl;
  }
  void imprimer_premiere_ligne_nusselt(int, const LIST(Nom)&, const Nom&) const;
  void imprimer_nusselt_mean_only(Sortie&, int, const LIST(Nom)&, const Nom&) const;
 
  void creer_champ(const Motcle& motlu) override;
  const Champ_base& get_champ(const Motcle& nom) const override;
  void get_noms_champs_postraitables(Noms& nom, Option opt = NONE) const override;
  bool has_champ(const Motcle& nom, OBS_PTR(Champ_base) &ref_champ) const override;
  bool has_champ(const Motcle& nom) const override;
 
  // Writing u_star, Cisaillement_paroi, etc. to a separate file...
  void ouvrir_fichier_partage(EcrFicPartage&, const Nom&) const;
  void ouvrir_fichier_partage(EcrFicPartage&, const Nom&, const Nom&) const;
  inline const int& get_flag_calcul_ldp_en_flux_impose() const { return calcul_ldp_en_flux_impose_; }
 
  virtual bool use_equivalent_distance() const;
  virtual DoubleVect& equivalent_distance_name(DoubleVect& d_eq, const Nom& nom_bord) const = 0;
 
  inline const DoubleVects& equivalent_distance() const { return equivalent_distance_; }
  inline const DoubleVect& equivalent_distance(int bord) const
  {
    assert(bord < equivalent_distance_.size());
    return equivalent_distance_[bord];
  }
  inline double equivalent_distance(int bord, int face) const
  {
    assert(bord < equivalent_distance_.size());
    assert(face < equivalent_distance_[bord].size());
    return equivalent_distance_[bord](face);
  }
 
  inline const DoubleVects& tab_equivalent_distance() const { return equivalent_distance_; }
  inline int tab_equivalent_distance_size() { return equivalent_distance_.size(); }
 
  inline const DoubleVect& tab_equivalent_distance(int bord) const
  {
    assert(bord < equivalent_distance_.size());
    return equivalent_distance_[bord];
  }
 
protected:
  OBS_PTR(Modele_turbulence_scal_base) mon_modele_turb_scal;
  mutable int nb_impr_ = 0, nb_impr0_ = 0;                        // print counter
  int calcul_ldp_en_flux_impose_; // flag defining whether the wall law is used with imposed flux, 0 by default
  double Prdt_sur_kappa_;         // constant in the wall law
  KOKKOS_INLINE_FUNCTION
  double T_plus(double y_plus, double Pr, double Prdt_sur_kappa);
 
  DoubleVects equivalent_distance_;
  // array of equivalent distances on each boundary
  // computed during the application of wall laws
  // and to be used in the computation of
  // wall heat transfer coefficients
  // In VDF, unlike VEF, contributions from virtual boundary faces are not needed
  // because the scalar is at the cell center in VDF whereas
  // it is at the face center in VEF
  // Since virtual boundary faces must be accounted for
  // in VEF when applying the diffusion operator
  // of equivalent_distance_, one array per boundary is used and
  // each array is dimensioned to the total number of boundary faces (real+virtual)
  mutable DoubleTab tab_; // Array containing the Nusset fields
  int nb_fields_ = 6; // Number of Nusselt fields
 
  OBS_PTR(Domaine_VF) le_dom_dis_;
  OBS_PTR(Domaine_Cl_dis_base) le_dom_Cl_dis_;
private:
 
  Champs_compris champs_compris_;
 
};
 
// Analytical law with matching of the asymptotic behaviors
// of the dimensionless temperature T+
// using Kader:
// conductive sub-layer: T+=Pr y+
// logarithmic region: T+=2.12*ln(y+)+Beta
KOKKOS_INLINE_FUNCTION
double Turbulence_paroi_scal_base::T_plus(double y_plus, double Pr, double Prdt_sur_kappa)
{
  double Gamma = (0.01 * pow(Pr * y_plus, 4.)) / (1. + 5. * pow(Pr, 3.) * y_plus);
  double Beta = pow(3.85 * pow(Pr, 1. / 3.) - 1.3, 2.) + Prdt_sur_kappa * log(Pr);
  return Pr * y_plus * exp(-Gamma) + (Prdt_sur_kappa * log(1. + y_plus) + Beta) * exp(-1. / (Gamma + 1e-20));
}
 
/*! @brief Associates a turbulence model to the object.
 *
 * @brief Associates a scalar turbulence model to the object.
 * @param (Modele_turbulence_scal_base& le_modele) the scalar turbulence model to associate with the object
 */
inline void Turbulence_paroi_scal_base::associer_modele(const Modele_turbulence_scal_base& le_modele)
{
  mon_modele_turb_scal = le_modele;
}
 
#endif