Cahn_Hilliard.h

/****************************************************************************
* Copyright (c) 2021, 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 Cahn_Hilliard_included
#define Cahn_Hilliard_included
 
#include <Equation_base.h>
#include <Milieu_base.h>
#include <Fermeture_Thermo_base.h>
#include <Potentiel_Chimique_base.h>
#include <Champ_Inc_base.h>
#include <Operateur_Diff_base.h>
#include <Operateur_Diff.h>
#include <Operateur_Conv.h>
#include <Solveur_non_lineaire.h>
#include <Matrice_Morse.h>
#include <Fermeture_Thermo_base.h>
#include <Milieu_Incompressible_Phase_Field.h>
 
class Schema_Temps_base;
 
/*! @brief classe Cahn_Hilliard
 *
 *      Equation de Cahn-Hilliard.
 *      L'équation s'applique à un champ conservé, ici la concentration.
 *      Elle s'écrit : dc / dt = ∇.M ∇(mutilde) où mutilde est le potentiel chimique généralisé.
 *      mutilde = beta*dW/dc - ∇. kappa ∇c
 *
 *      C'est une équation d'ordre 4, usuellement séparée en deux équations d'ordre 2.
 *      Pour cela, le vecteur d'inconnues est formé de c et mutilde en colonne.
 *      L'opérateur de diffusion est une matrice par blocs.
 *
 * @sa Equation_base
 */
class Cahn_Hilliard : public Equation_base
{
 
  Declare_instanciable(Cahn_Hilliard);
 
public:
  /* ----------------------------------------------
  *    Méthodes de Equation_base à surcharger
  ------------------------------------------------ */
 
  void set_param(Param&) const override;
  int lire_motcle_non_standard(const Motcle&, Entree&) override;
  Entree& lire_cl_potentiel(Entree&);
  const Milieu_base& milieu() const override;
  Milieu_base& milieu() override;
  void associer_milieu_base(const Milieu_base& ) override;
  int nombre_d_operateurs() const override;
  int nombre_d_operateurs_tot() const override;
  const Operateur& operateur(int) const override;
  Operateur& operateur(int) override;
 
  const Champ_Inc_base& inconnue() const override;
  Champ_Inc_base& inconnue() override;
 
  DoubleTab& derivee_en_temps_inco(DoubleTab&) override;
 
  double calculer_pas_de_temps() const override;
  void discretiser() override;
  void completer() override;
  bool initTimeStep(double dt) override;
  bool updateGivenFields() override;
  void mettre_a_jour(double temps) override;
  void abortTimeStep() override;
  void resetTime(double time) override;
 
  std::vector<YAML_data> data_a_sauvegarder() const override;
  int sauvegarder(Sortie&) const override;
  int reprendre(Entree&) override;
 
  void associer_pb_base(const Probleme_base&) override;
  void associer_sch_tps_base(const Schema_Temps_base&) override;
  int preparer_calcul() override;
 
  /////////////////////////////////////////////////////
 
  const Motcle& domaine_application() const override;
 
  /* ---------------------------------------------
   *            Nouvelles méthodes
   ----------------------------------------------*/
 
  inline int nb_parametres_d_ordre() { return nb_parametres_d_ordre_; }
 
  inline const Champ_Inc_base& mutilde() const { return mutilde_.valeur(); }
  inline Champ_Inc_base& mutilde() { return mutilde_.valeur(); }
 
  inline Domaine_Cl_dis_base& domaine_Cl_dis_mutilde() { assert(le_dom_Cl_dis_mutilde_); return le_dom_Cl_dis_mutilde_.valeur(); }
  inline const Domaine_Cl_dis_base& domaine_Cl_dis_mutilde() const { assert(le_dom_Cl_dis_mutilde_); return le_dom_Cl_dis_mutilde_.valeur(); }
  int verif_Cl_mutilde() const;
 
  void compute_mutilde();
  DoubleTab compute_mutilde(const DoubleTab&);
 
  inline Champ_Don_base& kappa() { return kappa_.valeur(); }
  inline Champ_Don_base& mobilite() { return mobilite_.valeur(); }
 
  inline const Fermeture_Thermo_base& fermeture() const { return fermeture_.valeur(); }
  inline Fermeture_Thermo_base& fermeture() { return fermeture_.valeur(); }
 
  inline bool mobilite_explicite() const { return mobilite_explicite_; }
 
  void initialiser_matrices();
  inline bool matrices_initialisees() { return matrices_initialisees_; }
  void update_terme_mobilite(const DoubleTab&);
 
  void calculer_contribution_CL_concentration(const DoubleTab&);
  void calculer_contribution_CL_mutilde(const DoubleTab&);
 
  inline Matrice_Morse& matrice_mobilite() { return mat_mobilite_; }
  inline Matrice_Morse& matrice_kappa() { return mat_kappa_; }
 
  virtual DoubleTab fonction_residu(const DoubleTab&);
 
protected:
 
  void lire_terme_mobilite();
  void lire_terme_kappa();
 
  void discretiser_concentration();
  void discretiser_mutilde();
  void discretiser_kappa();
  void discretiser_mobilite();
 
  void construire_kappa();
  void construire_mobilite(const DoubleTab&); // Dépend du champ de concentration c
 
  // Inconnue de l'équation : la concentration
  // Deuxième inconnue introduite pour résoudre le système d'ordre 4 : le potentiel chimique généralisé
  OWN_PTR(Champ_Inc_base) concentration_, mutilde_;
 
  OWN_PTR(Domaine_Cl_dis_base) le_dom_Cl_dis_mutilde_;
 
  int nb_parametres_d_ordre_ = -123;
 
  OWN_PTR(Champ_Don_base) mobilite_, kappa_;
 
  // Le milieu : peut être fluide ou solide
  // Attention : seulement le fluide à N phases a été codé pour l'instant
  OBS_PTR(Milieu_base) milieu_;
  OBS_PTR(Fermeture_Thermo_base) fermeture_;
 
  bool mobilite_explicite_=false;
  bool passer_par_ajouter_kappa_=false;
  bool passer_par_ajouter_mobilite_=false;
 
  // Terme diffusif lié à la mobilité
  Operateur_Diff terme_mobilite_;
  // Terme diffusif lié au coefficient de capillarité kappa
  Operateur_Diff terme_kappa_;
 
  // Matrices liées aux opérateurs
  bool matrices_initialisees_=false;
  Matrice_Morse mat_mobilite_;
  Matrice_Morse mat_kappa_;
 
  // Contributions des conditions limites
  DoubleTab contribution_CL_concentration_;
  DoubleTab contribution_CL_mutilde_;
 
};
 
#endif /* Cahn_Hilliard_included */