/export/home/gkanscha/ANS/submissions/Salgado/include/CahnHilliard.h

Go to the documentation of this file.

#ifndef _CAHN_HILLIARD_H_
#define _CAHN_HILLIARD_H_

#include "Problem.h"

template<int dim> class Phase0: public Function<dim>{
  public:
    Phase0( const double dd, const TestCase _tc );
    virtual ~Phase0();
    virtual double value( const Point<dim> &p, const unsigned component = 0 ) const;
  protected:
    const double delta;
    const TestCase tc;
};

template<int dim> class CahnHilliard: public Problem<dim>{
  public:
    CahnHilliard( const Triangulation<dim> &tria, Material_Parameters &params, const unsigned deg,
                  const TestCase _tc );
    virtual ~CahnHilliard();
    void advance();
    double it_error();
  protected:
    const material_function &mobility, 
                            &permitivity, 
                            &density; 
    const GLPotential &W; 
    const InterfaceEnergy &gamma_fs; 
    const double gamma, 
                 delta, 
                 alpha; 
    const TestCase tc; 
    TrilinosWrappers::Vector oldsol, 
                             olditsol; 

    virtual void InitLADataSuffix();
    typedef IteratorGroup<3,typename hp::DoFHandler<dim>::active_cell_iterator> Iterator;
    struct ScratchData{
      hp::QCollection<dim> quad; 
      UpdateFlags flags; 
      hp::FEValues<dim> fe_val; 
      hp::QCollection<dim-1> f_quad; 
      UpdateFlags f_flags; 
      hp::FEFaceValues<dim> fe_face_val; 
      AsFunction<dim> voltage, 
                      velocity; 
      std::vector< Tensor<1,dim> > loc_grad_voltage, loc_vel, loc_face_vel, phase_grad, phase_face_grad;
      std::vector< Point<dim> > normals;
      std::vector<double> phase_val, phase_face_val;
      ScratchData( const hp::FECollection<dim> &fe, std::vector<AsFunction<dim> *> &data,
                   const hp::QCollection<dim> &q, const UpdateFlags u_flags,
                   const hp::QCollection<dim-1> &fq, const UpdateFlags u_f_flags ) :
          quad(q), flags( u_flags ), fe_val( fe, quad, flags ),
          f_quad(fq), f_flags( u_f_flags ), fe_face_val( fe, f_quad, f_flags ),
          voltage( *(data[0]) ), velocity( *(data[1]) ),
          loc_grad_voltage( quad.max_n_quadrature_points() ), loc_vel( quad.max_n_quadrature_points() ),
          loc_face_vel( f_quad.max_n_quadrature_points() ), phase_grad( quad.max_n_quadrature_points() ),
          phase_face_grad( f_quad.max_n_quadrature_points() ),
          normals( f_quad.max_n_quadrature_points() ),
          phase_val( quad.max_n_quadrature_points() ),
          phase_face_val( f_quad.max_n_quadrature_points() ) {}
      ScratchData ( const ScratchData &scratch ) :
          quad( scratch.quad ), flags( scratch.flags ),
          fe_val( scratch.fe_val.get_fe_collection(), quad, flags ),
          f_quad( scratch.f_quad ), f_flags( scratch.f_flags ),
          fe_face_val( scratch.fe_face_val.get_fe_collection(), f_quad, f_flags ),
          voltage( scratch.voltage ), velocity( scratch.velocity ),
          loc_grad_voltage( quad.max_n_quadrature_points() ), loc_vel( quad.max_n_quadrature_points() ),
          loc_face_vel( f_quad.max_n_quadrature_points() ), phase_grad( quad.max_n_quadrature_points() ),
          phase_face_grad( f_quad.max_n_quadrature_points() ),
          normals( f_quad.max_n_quadrature_points() ),
          phase_val( quad.max_n_quadrature_points() ),
          phase_face_val( f_quad.max_n_quadrature_points() ) {}
    };
    virtual void AssembleSystem( std::vector< AsFunction<dim> *> &data, const double time,
                                 const bool m_theaded = true );
    void AssembleCell( const Iterator Its, ScratchData &scratch,
                       typename Problem<dim>::PerTaskData &data );
    virtual void ReinitPrec();
    virtual void SolveSystemPreffix();
    virtual void DoSolve( SolverControl &control );
    virtual void SetInitialData();
    virtual void PreRefinementPreffix();
    virtual void PostRefinementSuffix( const std::vector<TrilinosWrappers::Vector> &sol_tmp );
  public:
    AsFunction<dim> get_phase, 
                    get_potential, 
                    get_old_phase; 
};

#endif