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

Go to the documentation of this file.

#ifndef _PROBLEM_H_
#define _PROBLEM_H_

#include <deal.II/base/point.h>
#include <deal.II/base/function.h>
#include <deal.II/base/multithread_info.h>
#include <deal.II/base/thread_management.h>
#include <deal.II/base/work_stream.h>
#include <deal.II/base/parallel.h>

#include <deal.II/grid/tria.h>

#include <deal.II/hp/dof_handler.h>
#include <deal.II/hp/fe_collection.h>

#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/dofs/function_map.h>

#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_nothing.h>
#include <deal.II/fe/fe_system.h>
#include <deal.II/fe/fe_tools.h>

#include <deal.II/lac/trilinos_vector.h>
#include <deal.II/lac/trilinos_sparse_matrix.h>
#include <deal.II/lac/trilinos_solver.h>
#include <deal.II/lac/trilinos_precondition.h>
#include <deal.II/lac/compressed_sparsity_pattern.h>
#include <deal.II/lac/constraint_matrix.h>

#include <deal.II/numerics/matrix_tools.h>
#include <deal.II/numerics/vector_tools.h>
#include <deal.II/numerics/solution_transfer.h>

#include "Material.h"
#include "AsFunction.h"
#include "GroupedIterators.h"

using namespace dealii;

template<int dim> class Problem{
  public:
    Problem( const Triangulation<dim> &tria, const unsigned _n_transfers, const double _eps,
             bool _prec_needs_reinit = false, const unsigned _update_prec = 10 );
    virtual ~Problem();
    void set_dt( const double _dt );
    void init();
    virtual void solve( std::vector< AsFunction<dim> *> &data, const double time );
    const hp::FECollection<dim> &get_fe() const;
    unsigned size() const;
  protected:
    const Triangulation<dim> &tri; 
    bool mesh_has_changed; 
    hp::DoFHandler<dim> dh; 
    ConstraintMatrix constraints; 
    hp::FECollection<dim> fe; 
    unsigned n_dofs; 
    double dt; 
    unsigned steps; 
    TrilinosWrappers::Vector sol, 
                             rhs; 
    TrilinosWrappers::SparseMatrix K; 
    const double eps; 
    const unsigned update_prec; 
    const bool prec_needs_reinit; 

    void SetupDoFs();
    virtual void SetupDoFsSuffix();
    void InitLAData();
    virtual void InitLADataSuffix();
    struct PerTaskData{
      unsigned dpc; 
      std::vector<unsigned> ldi; 
      FullMatrix<double> loc_m; 
      Vector<double> loc_rhs; 
      PerTaskData( const unsigned _dpc ) : dpc( _dpc ), ldi( dpc ), loc_m( dpc, dpc ),
                loc_rhs( dpc ) {}
      PerTaskData( const PerTaskData &data ) : dpc( data.dpc ), ldi( dpc ),
                loc_m( dpc, dpc ), loc_rhs( dpc ) {}
    };
    virtual void AssembleSystem( std::vector< AsFunction<dim> *> &data, const double time,
                                  const bool m_threaded = true ) = 0;
    void CopyToGlob( const PerTaskData &data );
    void SolveSystem();
    virtual void SolveSystemPreffix();
    virtual void ReinitPrec() = 0;
    virtual void DoSolve( SolverControl &control ) = 0;
    virtual void SolveSystemSuffix();
    virtual void SetInitialData() = 0;
    const unsigned n_of_transfers; 
    std::vector<TrilinosWrappers::Vector> x_sol; 
    SolutionTransfer<dim, TrilinosWrappers::Vector, hp::DoFHandler<dim> > transfer; 

    void PreRefinement();
    virtual void PreRefinementPreffix() = 0;
    void PostRefinement();
    virtual void PostRefinementSuffix( const std::vector<TrilinosWrappers::Vector> &sol_tmp ) = 0;
    bool isNeeded( const typename hp::DoFHandler<dim>::active_cell_iterator &c,
                   const unsigned face ) const;
};

#endif