AssembleFE_decl.hpp

#ifndef ASSEMBLEFE_DECL_hpp
#define ASSEMBLEFE_DECL_hpp
 
 
#include "feddlib/core/FEDDCore.hpp"
#include "feddlib/core/LinearAlgebra/Matrix.hpp"
#include "feddlib/core/FE/Helper.hpp"
 
namespace FEDD {
 
   template <class SC = default_sc,
              class LO = default_lo,
              class GO = default_go,
              class NO = default_no>
    class AssembleFEFactory;
    
    template <class SC = default_sc, class LO = default_lo, class GO = default_go, class NO = default_no>
    class AssembleFE {
    public:
 
 
        typedef SmallMatrix<SC> SmallMatrix_Type;
        typedef Teuchos::RCP<SmallMatrix_Type> SmallMatrixPtr_Type;
 
        // Teuchos:: Array anstatt vec_dbl_Type
 
        typedef AssembleFE<SC,LO,GO,NO> AssembleFE_Type;

        //virtual void compute() = 0;

        virtual void assembleJacobian() = 0;
 

        virtual void assembleJacobianBlock(LO i) = 0;

        virtual void assembleRHS() = 0;

        SmallMatrixPtr_Type getJacobian() {return jacobian_;}

        SmallMatrixPtr_Type getJacobianBlock(LO i) {return jacobianBlock_;}

        vec_dbl_ptr_Type getRHS(){return rhsVec_;}
 
        //virtual void assembleMass(MatrixPtr_Type &A) =0;

        virtual void checkParameters();

        virtual void updateParams(ParameterListPtr_Type params);

        virtual void updateParameter(std::string type, double value) {}
        virtual void advanceInTime(double dt);
        double getTimeStep();

        void advanceNewtonStep();

        int getNewtonStep();

        void updateSolution(vec_dbl_Type solution);

        vec_dbl_ptr_Type getSolution();

        void preProcessing();

        void postProcessing();

        int getDim();

        vec2D_dbl_Type getNodesRefConfig();

        void addRHSFunc(RhsFunc_Type rhsFunc){ rhsFunc_ = rhsFunc;}

        tuple_sd_vec_ptr_Type getTupleElement(){return elementIntormation_;}

        double getTimeIncrement(){return timeIncrement_;}
 
        void setGlobalElementID(GO goID){globalElementID_ = goID;}
 
        GO getGlobalElementID(){return globalElementID_;}

        virtual void computeLocalconstOutputField() {TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "computeLocalconstOutputField not yet implemented")}

        vec_dbl_Type getLocalconstOutputField() {return constOutputField_;}
 

        void changeLinearization(std::string linearization) {this->linearization_ = linearization;};
    protected:

        AssembleFE(int flag,
                   vec2D_dbl_Type nodesRefConfig,
                   ParameterListPtr_Type parameters,
                tuple_disk_vec_ptr_Type tuple);
 
        //void readTuple(); /// TODO: To have tuple information in basis class as well?
        //tuple_disk_vec_ptr_Type getTuple();  
 
        SmallMatrixPtr_Type jacobian_;
        SmallMatrixPtr_Type jacobianBlock_;
 
        vec_dbl_ptr_Type rhsVec_;
 
        RhsFunc_Type rhsFunc_;
 
        int dim_;
 
        tuple_disk_vec_ptr_Type diskTuple_;
        tuple_sd_vec_ptr_Type elementIntormation_;
        vec2D_dbl_Type nodesRefConfig_;
        bool timeProblem_;
        int flag_;
        double timeStep_ ; 
        int newtonStep_ ;
        ParameterListPtr_Type paramsMaterial_;
        ParameterListPtr_Type params_;
        vec_dbl_ptr_Type solution_ ;
        double timeIncrement_;
        GO globalElementID_;
 
        std::string linearization_; // Store in here which linearization e.g. FixedPoint or Newton is used -> Relevant for assembleFEElement-Specific construction of Jacobian in NavierStokes
 
        // This can be any postprocessing output field ddefined inside an element using converged solution
        vec_dbl_Type constOutputField_ ; // can be a vector with values on P1/ P2 nodes or just averaged element value
 
        friend class AssembleFEFactory<SC,LO,GO,NO>;
    };
}
#endif