Line data    Source code

       1              : //
       2              : // This implements a basic two-phase field model with Cahn-Hilliard kinetics.
       3              : //
       4              : // The free energy is
       5              : //
       6              : // .. math::
       7              : //
       8              : //    F[\eta] = \int_\Omega \Big[\frac{1}{4}(\eta^2 - 1)^2 +
       9              : //                               \frac{1}{2}\gamma |\nabla\eta|^2\Big] d\mathbf{x}
      10              : //
      11              : // The corresponding governing equation under conservative kinetics is
      12              : //
      13              : // .. math::
      14              : //
      15              : //    \frac{\partial\eta}{\partial t} = L\nabla^2\Big(\eta^3 - \eta - \gamma\nabla^2\eta\Big)
      16              : //
      17              : // which is integrated using a forward Euler scheme.
      18              : //
      19              : // This is tested in :ref:`CahnHilliard`
      20              : 
      21              : #ifndef INTEGRATOR_CAHNHILLIARD_H
      22              : #define INTEGRATOR_CAHNHILLIARD_H
      23              : 
      24              : #include <AMReX.H>
      25              : #include <AMReX_MLMG.H>
      26              : 
      27              : #include "IC/IC.H"
      28              : #include "BC/BC.H"
      29              : #include "IO/ParmParse.H"
      30              : #include "Integrator/Integrator.H"
      31              : 
      32              : namespace Integrator
      33              : {
      34              : 
      35              : class CahnHilliard : public Integrator
      36              : {
      37              : public:
      38              :     static constexpr const char* name = "cahnhilliard";
      39              : 
      40              :     /// Basic constructor (don't use)
      41              :     CahnHilliard();
      42              :     
      43              :     /// Destroy pointers defined in Parse
      44              :     ~CahnHilliard();
      45              : 
      46              :     /// Use this constructor
      47            0 :     CahnHilliard(IO::ParmParse& pp) : CahnHilliard()
      48            0 :     { Parse(*this, pp); }
      49              : 
      50              :     /// Scan input values and initialize fields
      51              :     static void Parse(CahnHilliard& value, IO::ParmParse& pp);
      52              : 
      53              : protected:
      54              : 
      55              :     /// Set values in fields
      56              :     void Initialize (int lev) override;
      57              :     /// Integrate eta over one timestep on lev
      58              :     void Advance (int lev, Set::Scalar time, Set::Scalar dt) override;
      59              :     /// spectral version of advance
      60              :     void AdvanceSpectral (int lev, Set::Scalar time, Set::Scalar dt);
      61              :     /// realspace version of advance
      62              :     void AdvanceReal (int lev, Set::Scalar time, Set::Scalar dt);
      63              :     /// Mark any cells that need to be refined
      64              :     void TagCellsForRefinement (int lev, amrex::TagBoxArray& tags, amrex::Real time, int ngrow) override;
      65              : 
      66              : private:
      67              : 
      68              :     Set::Field<Set::Scalar> etanew_mf;     /// The new value for eta this timestep
      69              :     Set::Field<Set::Scalar> etaold_mf;     /// Last timestep's value for eta
      70              :     Set::Field<Set::Scalar> intermediate;  /// Intermediate field used for CH kinetics
      71              : 
      72              :     BC::BC<Set::Scalar> *bc; /// eta's bc object
      73              :     IC::IC<Set::Scalar> *ic; /// eta's ic object
      74              :     
      75              :     Set::Scalar gamma = NAN; 
      76              :     Set::Scalar L     = NAN; 
      77              :     Set::Scalar refinement_threshold = NAN; 
      78              : 
      79              :     std::string method; 
      80              : };
      81              : }
      82              : #endif