NonLinLaplace_decl.hpp

#ifndef NonLinLaplace_decl_hpp
#define NonLinLaplace_decl_hpp
#include "feddlib/problems/abstract/NonLinearProblem.hpp"
#include <Thyra_ModelEvaluatorBase_decl.hpp>
#include <Thyra_PreconditionerBase.hpp>
 
namespace FEDD {
template <class SC = default_sc, class LO = default_lo, class GO = default_go,
          class NO = default_no>
class NonLinLaplace : public NonLinearProblem<SC, LO, GO, NO> {
 
public:

  typedef Problem<SC, LO, GO, NO> Problem_Type;
  typedef typename Problem_Type::Matrix_Type Matrix_Type;
  typedef typename Problem_Type::MatrixPtr_Type MatrixPtr_Type;
 
  typedef typename Problem_Type::MapConstPtr_Type MapConstPtr_Type;
 
  typedef typename Problem_Type::BlockMatrix_Type BlockMatrix_Type;
  typedef typename Problem_Type::BlockMatrixPtr_Type BlockMatrixPtr_Type;
 
  typedef typename Problem_Type::MultiVector_Type MultiVector_Type;
  typedef typename Problem_Type::MultiVectorPtr_Type MultiVectorPtr_Type;
  typedef
      typename Problem_Type::MultiVectorConstPtr_Type MultiVectorConstPtr_Type;
 
  typedef typename Problem_Type::BlockMultiVector_Type BlockMultiVector_Type;
  typedef
      typename Problem_Type::BlockMultiVectorPtr_Type BlockMultiVectorPtr_Type;
 
  typedef typename Problem_Type::DomainConstPtr_Type DomainConstPtr_Type;
  typedef typename Problem_Type::CommConstPtr_Type CommConstPtr_Type;
 
  typedef NonLinearProblem<SC, LO, GO, NO> NonLinearProblem_Type;
  typedef typename NonLinearProblem_Type::BlockMultiVectorPtrArray_Type
      BlockMultiVectorPtrArray_Type;
 
  typedef typename NonLinearProblem_Type::TpetraMatrix_Type TpetraMatrix_Type;
 
  typedef typename NonLinearProblem_Type::ThyraVecSpace_Type ThyraVecSpace_Type;
  typedef typename NonLinearProblem_Type::ThyraVec_Type ThyraVec_Type;
  typedef typename NonLinearProblem_Type::ThyraOp_Type ThyraOp_Type;
 
  typedef typename NonLinearProblem_Type::TpetraOp_Type TpetraOp_Type;
 
  typedef Tpetra::CrsMatrix<SC, LO, GO, NO> tpetra_matrix;



  NonLinLaplace(const DomainConstPtr_Type &domain, std::string FEType,
                ParameterListPtr_Type parameterList);
  ~NonLinLaplace();
 
  virtual void info();
 
  virtual void assemble(std::string type = "") const;
 
  void initAssemble() const;
 
  void reAssemble(std::string type) const;
 
    void reAssemble(BlockMultiVectorPtr_Type previousSolution) const override{}
 
    virtual void reAssemble(MatrixPtr_Type &massmatrix, std::string type) const {}
 
  virtual void
  reAssembleExtrapolation(BlockMultiVectorPtrArray_Type previousSolutions);
 
  virtual void calculateNonLinResidualVec(std::string type,
                                          double time = 0.) const;
 
    void getValuesOfInterest(vec_dbl_Type &values) override{}
 
    void computeValuesOfInterestAndExport() override{}
 
    //    virtual void assembleExternal( std::string type ){}
 
private:
 
  mutable MultiVectorPtr_Type u_rep_;
};
} // namespace FEDD
#endif