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

Go to the documentation of this file.

#ifndef _NSE_H_
#define _NSE_H_

#include "Problem.h"

template<int dim> class Pressure: public Problem<dim>{
  public:
    Pressure( const Triangulation<dim> &tria, Material_Parameters &params, const unsigned deg,
              const double ee, const double thres, const unsigned sweeps );
    virtual ~Pressure();
  protected:
    const double rho_min; 
    TrilinosWrappers::PreconditionAMG prec; 
    TrilinosWrappers::PreconditionAMG::AdditionalData prec_data; 
    TrilinosWrappers::Vector p, 
                             pres_extr; 

    virtual void SetupDoFsSuffix();
    virtual void InitLADataSuffix();
    typedef IteratorGroup<2, typename hp::DoFHandler<dim>::active_cell_iterator> Iterator;
    struct ScratchData{
      hp::QCollection<dim> quad; 
      UpdateFlags flags; 
      hp::FEValues<dim> fe_val; 
      AsFunction<dim> velocity; 
      std::vector<double> loc_div_vel;
      ScratchData( const hp::FECollection<dim> &fe, std::vector<AsFunction<dim> *> &data,
                   const hp::QCollection<dim> &q, const UpdateFlags u_flags ) :
          quad(q), flags( u_flags ), fe_val( fe, quad, flags ), velocity( *( data[0] ) ),
          loc_div_vel( 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 ), velocity( scratch.velocity ),
          loc_div_vel( quad.max_n_quadrature_points() ) {}
    };
    virtual void AssembleSystem( std::vector< AsFunction<dim> *> &data, const double time,
                                 const bool m_threaded = true );
    void AssembleCell( const Iterator Its, ScratchData &scratch,
                       typename Problem<dim>::PerTaskData &data );
    virtual void ReinitPrec();
    virtual void DoSolve( SolverControl &control );
    virtual void SolveSystemSuffix();
    virtual void SetInitialData();
    virtual void PreRefinementPreffix();
    virtual void PostRefinementSuffix( const std::vector<TrilinosWrappers::Vector> &sol_tmp );
  public:
    AsFunction<dim> get_pressure, 
                    get_extrapolated_pressure; 
};

template<int dim> class Velocity: public Problem<dim>{
  public:
    Velocity( const Triangulation<dim> &tria, Material_Parameters &params, const unsigned deg, const unsigned u_prec,
              const double ee, const double thres, const unsigned v_sweeps, const unsigned K_size );
    virtual ~Velocity();
    void advance();
    double it_error();
  protected:
    const material_function &density, 
                            &viscosity, 
                            &slip_coeff; 
    InterfaceEnergy &gamma_fs; 
    const double alpha, 
                 lambda, 
                 gamma, 
                 delta; 
    const unsigned Krylov_size; 
    TrilinosWrappers::PreconditionAMG prec; // Preconditioner (AMG)
    TrilinosWrappers::PreconditionAMG::AdditionalData prec_data; 
    TrilinosWrappers::Vector oldsol, 
                             olditsol; 

    virtual void InitLADataSuffix();
    virtual void SetupDoFsSuffix();
    typedef IteratorGroup<7,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> fquad; 
      UpdateFlags f_flags; 
      hp::FEFaceValues<dim> fe_face_val; 
      AsFunction<dim> phase, 
                      mu, 
                      q, 
                      V, 
                      psharp, 
                      oldphase; 
      std::vector<double> loc_phase, loc_old_phase, face_phase, face_old_phase, loc_q,
                          loc_psharp, loc_divu, loc_mu;
      std::vector< Tensor<1,dim> > loc_grad_q, loc_grad_V, loc_grad_phase, face_grad_phase, loc_u, face_base,
                                   loc_face_u;
      Point<dim> normal;
      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 ),
          fquad( fq ), f_flags( u_f_flags ), fe_face_val( fe, fquad, f_flags ),
          phase( *( data[0] ) ), mu( *( data[1] ) ), q( *( data[2] ) ), V( *( data[3] ) ),
          psharp( *( data[4] ) ), oldphase( *( data[5] ) ),
          loc_phase( quad.max_n_quadrature_points() ), loc_old_phase( quad.max_n_quadrature_points() ),
          face_phase( fquad.max_n_quadrature_points() ), face_old_phase( fquad.max_n_quadrature_points() ),
          loc_q( quad.max_n_quadrature_points() ), loc_psharp( quad.max_n_quadrature_points() ),
          loc_divu( quad.max_n_quadrature_points() ), loc_mu( quad.max_n_quadrature_points() ),
          loc_grad_q( quad.max_n_quadrature_points() ), loc_grad_V( quad.max_n_quadrature_points() ),
          loc_grad_phase( quad.max_n_quadrature_points() ), face_grad_phase( fquad.max_n_quadrature_points() ),
          loc_u( quad.max_n_quadrature_points() ), face_base( fe.max_dofs_per_cell() ),
          loc_face_u( fquad.max_n_quadrature_points() ) {}
      ScratchData( const ScratchData &scratch ) :
          quad( scratch.quad ), flags( scratch.flags ), fe_val( scratch.fe_val.get_fe_collection(), quad, flags ),
          fquad( scratch.fquad ), f_flags( scratch.f_flags ),
          fe_face_val( scratch.fe_face_val.get_fe_collection(), fquad, f_flags ),
          phase( scratch.phase ), mu( scratch.mu ), q( scratch.q ), V( scratch.V ),
          psharp( scratch.psharp ), oldphase( scratch.oldphase ),
          loc_phase( quad.max_n_quadrature_points() ), loc_old_phase( quad.max_n_quadrature_points() ),
          face_phase( fquad.max_n_quadrature_points() ), face_old_phase( fquad.max_n_quadrature_points() ),
          loc_q( quad.max_n_quadrature_points() ), loc_psharp( quad.max_n_quadrature_points() ),
          loc_divu( quad.max_n_quadrature_points() ), loc_mu( quad.max_n_quadrature_points() ),
          loc_grad_q( quad.max_n_quadrature_points() ), loc_grad_V( quad.max_n_quadrature_points() ),
          loc_grad_phase( quad.max_n_quadrature_points() ), face_grad_phase( fquad.max_n_quadrature_points() ),
          loc_u( quad.max_n_quadrature_points() ), face_base( fe_val.get_fe_collection().max_dofs_per_cell() ),
          loc_face_u( fquad.max_n_quadrature_points() ) {}
    };
    virtual void AssembleSystem( std::vector< AsFunction<dim> *> &data, const double time, const bool m_threaded = true );
    void AssembleCell( const Iterator Its, ScratchData &scratch, typename Problem<dim>::PerTaskData &data ) const;
    virtual void SolveSystemPreffix();
    virtual void ReinitPrec();
    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_velocity; 
};

#endif // _NSE_H_