Transport_K_Eps.cpp

/****************************************************************************
* Copyright (c) 2015 - 2016, 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 <Transport_K_Eps.h>
#include <Modele_turbulence_hyd_K_Eps.h>
#include <Les_Pb_Turb.h>
#include <Param.h>
#include <EChaine.h>
#include <Fluide_Quasi_Compressible.h>
#include <TRUSTTrav.h>
#include <Debog.h>
#include <Discretisation_base.h>
#include <Probleme_base.h>
#include <Equation_base.h>
#include <Nom.h>
 
// XD transport_k_epsilon transport_equation_deriv transport_k_epsilon INHERITS_BRACE The (k-eps) transport equation. To
// XD_CONT resume from a previous mixing length calculation, an external MED-format file containing reconstructed K and
// XD_CONT Epsilon quantities can be read (see fichier_ecriture_k_eps) thanks to the Champ_fonc_MED keyword. NL2
// XD_CONT Warning, When used with the Quasi-compressible model, k and eps should be viewed as rho k and rho epsilon
// XD_CONT when defining initial and boundary conditions or when visualizing values for k and eps. This bug will be
// XD_CONT fixed in a future version.
// XD attr disable_equation_residual entier disable_equation_residual OPT The equation residual will not be used for the
// XD_CONT problem residual used when checking time convergence or computing dynamic time-step
// XD attr convection bloc_convection convection OPT Keyword to alter the convection scheme.
// XD attr diffusion bloc_diffusion diffusion OPT Keyword to specify the diffusion operator.
// XD attr conditions_limites|boundary_conditions condlims conditions_limites OPT Boundary conditions.
// XD attr conditions_initiales|initial_conditions condinits conditions_initiales OPT Initial conditions.
// XD attr sources sources sources OPT To introduce a source term into an equation (in case of several source terms into
// XD_CONT the same equation, the blocks corresponding to the various terms need to be separated by a comma)
// XD attr ecrire_fichier_xyz_valeur ecrire_fichier_xyz_valeur ecrire_fichier_xyz_valeur OPT This keyword is used to
// XD_CONT write the values of a field only for some boundaries in a text file
// XD attr parametre_equation parametre_equation_base parametre_equation OPT Keyword used to specify additional
// XD_CONT parameters for the equation
// XD attr equation_non_resolue chaine equation_non_resolue OPT The equation will not be solved while condition(t) is
// XD_CONT verified if equation_non_resolue keyword is used. Exemple: The Navier-Stokes equations are not solved between
// XD_CONT time t0 and t1. NL2 Navier_Sokes_Standard NL2 { equation_non_resolue (t>t0)*(t<t1) }
// XD attr renommer_equation chaine rename_equation OPT Rename the equation with a specific name.
// XD attr exit_on_negative_k_eps rien exit_on_negative_k_eps OPT Flag to exit (with postprocessing of fields) if a
// XD_CONT negative value is found for k or epsilon
// XD attr exit_on_big_eps rien exit_on_big_eps OPT Flag to exit (with postprocessing of fields) if an excessively big
// XD_CONT values of epsilon is found
// XD attr disable_VEF_mean_value_corrections rien disable_VEF_mean_value_corrections OPT not_set
Implemente_instanciable(Transport_K_Eps,"Transport_K_Epsilon",Transport_K_Eps_base);
 
/*! @brief Imprime le type de l'equation sur un flot de sortie.
 *
 * @param (Sortie& s) un flot de sortie
 * @return (Sortie&) le flot de sortie modifie
 */
Sortie& Transport_K_Eps::printOn(Sortie& s ) const
{
  return s << que_suis_je() << "\n";
}
 
void Transport_K_Eps::set_param(Param& param) const
{
  Transport_K_Eps_base::set_param(param);
  param.ajouter("with_nu", &with_nu_);  // XD_ADD_P chaine(into=["yes","no"])
  // XD_CONT yes/no
  param.dictionnaire("no", 0);
  param.dictionnaire("yes", 1);
}
 
/*! @brief Lit les specifications d'une equation de transport K-epsilon a partir d'un flot d'entree.
 *
 *     Controle dynamique du type du terme source.
 *
 * @param (Entree& s) un flot d'entree
 * @return (Entree&) le flot d'entree modifie
 */
Entree& Transport_K_Eps::readOn(Entree& s)
{
  with_nu_ = 0;
  // Lecture des attributs de l'equation
  Transport_K_Eps_base::readOn(s);
 
  // Ajout automatique du terme source si pas instancie dans le jeu de donnees
  if (les_sources.est_vide())
    {
      Source t;
      Source& so=les_sources.add(t);
      const Probleme_base& pb = probleme();
      Cerr << "Construction and typing for the source term of the Transport_K_Eps equation." << finl;
      const Nom pbb = probleme().que_suis_je();
      if (sub_type(Pb_Hydraulique_Turbulent, pb)
          || milieu().que_suis_je()=="Fluide_Quasi_Compressible"
          || pbb.contient("ALE"))
        {
          Nom typ = "Source_Transport_K_Eps";
          Cerr << "TYPAGE DES SOURCES : this " << *this << finl;
          so.typer(typ, *this);
        }
      else if (sub_type(Pb_Thermohydraulique_Turbulent, pb))
        {
          Nom typ = "Source_Transport_K_Eps_anisotherme";
          so.typer(typ, *this);
        }
      else if (sub_type(Pb_Hydraulique_Concentration_Turbulent, pb))
        {
          Nom typ = "Source_Transport_K_Eps_aniso_concen";
          so.typer(typ, *this);
        }
      else if ((sub_type(Pb_Thermohydraulique_Concentration_Turbulent, pb)))
        {
          Nom typ = "Source_Transport_K_Eps_aniso_therm_concen";
          so.typer(typ, *this);
        }
      so->associer_eqn(*this);
      so->discretiser();
    }
  return s;
}
 
 
int Transport_K_Eps::lire_motcle_non_standard(const Motcle& mot, Entree& is)
{
  if (mot == "diffusion")
    {
      Cerr << "Reading and typing of the diffusion operator : " << finl;
 
      if (with_nu_ == 0)
        {
          Cerr << " On associe le champ de diffusion nul afin de faire comme avant !!!!!! " << finl;
          EChaine tt("Champ_Uniforme 1 0");
          tt >> Champ_don_nul_;
          terme_diffusif.associer_diffusivite(Champ_don_nul_);
        }
      else
        {
          const Fluide_base& fluide_inc = ref_cast(Fluide_base, le_fluide.valeur());
          if (sub_type(Fluide_Quasi_Compressible, fluide_inc))
            terme_diffusif.associer_diffusivite(fluide_inc.viscosite_dynamique());
          else
            terme_diffusif.associer_diffusivite(fluide_inc.viscosite_cinematique());
        }
      lire_op_diff_turbulent(is);
      return 1;
    }
  else if (mot == "convection")
    {
      Cerr << "Reading and typing of the convection operator : " << finl;
      const Champ_Inc_base& vitesse_transportante = probleme().equation(0).inconnue();
      associer_vitesse(vitesse_transportante);
      terme_convectif.associer_vitesse(vitesse_transportante);
      is >> terme_convectif;
      return 1;
    }
  else if (mot == "ecrire_fichier_xyz_valeur")
    {
      Cerr << mot << " is not understood by " << que_suis_je() << finl;
      Cerr << "Use this keyword in the Navier Stokes equation, not in KEps equation, please." << finl;
      Process::exit();
    }
  else
    return Transport_K_Eps_base::lire_motcle_non_standard(mot, is);
 
  return 1;
}
 
/*! @brief Associe un modele de turbulence K-epsilon a l'equation.
 *
 * @param (Modele_turbulence_hyd_K_Eps& modele) le modele de turbulence K-epsilon a asoocier a l'equation
 */
void Transport_K_Eps::associer_modele_turbulence(const Modele_turbulence_hyd_2_eq_base& modele)
{
  const Equation_base& eqn_hydr = modele.equation();
  associer(eqn_hydr);
  associer_milieu_base(eqn_hydr.milieu());
  associer_vitesse(eqn_hydr.inconnue());
  mon_modele = ref_cast(Modele_turbulence_hyd_K_Eps, modele);
  RefObjU le_modele;
  le_modele = mon_modele.valeur();
  liste_modeles_.add_if_not(le_modele);
  discretiser();
}
 
/*! @brief Renvoie le nombre d'operateurs de l'equation.
 *
 * Ici 2.
 *
 * @return (int) le nombre d'operateurs de l'equation
 */
int Transport_K_Eps::nombre_d_operateurs() const
{
  return 2;
}
 
/*! @brief Renvoie l'operateur specifie par son index: renvoie terme_diffusif si i = 0
 *
 *      renvoie terme_convectif si i = 1
 *      exit si i>1
 *     (version const)
 *
 * @param (int i) l'index de l'operateur a renvoyer
 * @return (Operateur&) l'operateur specifie
 * @throws l'equation n'a pas plus de 2 operateurs
 */
const Operateur& Transport_K_Eps::operateur(int i) const
{
  switch(i)
    {
    case 0:
      return terme_diffusif;
    case 1:
      return terme_convectif;
    default :
      Cerr << "Error for Transport_K_Eps::operateur(" << i << ") !! " << finl;
      Cerr << "Transport_K_Eps has " << nombre_d_operateurs() <<" operators "<<finl;
      Cerr << "and you are trying to access the " << i <<" th one."<< finl;
      Process::exit();
    }
  // Pour les compilos!!
  return terme_diffusif;
}
 
/*! @brief Renvoie l'operateur specifie par son index: renvoie terme_diffusif si i = 0
 *
 *      renvoie terme_convectif si i = 1
 *      exit si i>1
 *
 * @param (int i) l'index de l'operateur a renvoyer
 * @return (Operateur&) l'operateur specifie
 * @throws l'equation n'a pas plus de 2 operateurs
 */
Operateur& Transport_K_Eps::operateur(int i)
{
  switch(i)
    {
    case 0:
      return terme_diffusif;
    case 1:
      return terme_convectif;
    default :
      Cerr << "Error for Transport_K_Eps::operateur(" << i << ") !! " << finl;
      Cerr << "Transport_K_Eps has " << nombre_d_operateurs() <<" operators "<<finl;
      Cerr << "and you are trying to access the " << i <<" th one."<< finl;
      Process::exit();
    }
  // Pour les compilos!!
  return terme_diffusif;
}
 
 
/*! @brief Renvoie le nom du domaine d'application de l'equation.
 *
 * Ici "Transport_Keps".
 *
 * @return (Motcle&) le nom du domaine d'application de l'equation
 */
const Motcle& Transport_K_Eps::domaine_application() const
{
  static Motcle domaine = "Transport_Keps";
  return domaine;
}
 
DoubleTab& Transport_K_Eps::corriger_derivee_impl(DoubleTab& d)
{
  const Turbulence_paroi_base& loi_paroi = modele_turbulence().loi_paroi();
  loi_paroi.corriger_derivee_impl(d);
  return Transport_K_Eps_base::corriger_derivee_impl(d);
}