gsNsTimeIntegrator.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsElasticity/gsBaseAssembler.h>
#include <gsElasticity/gsBaseUtils.h>
#include <gsElasticity/gsNsAssembler.h>
#include <gsElasticity/gsMassAssembler.h>
 
namespace gismo
{
 
template <class T>
class gsNsTimeIntegrator : public gsBaseAssembler<T>
{
public:
    typedef gsBaseAssembler<T> Base;
    gsNsTimeIntegrator(gsNsAssembler<T> & stiffAssembler_,
                       gsMassAssembler<T> & massAssembler_,
                       gsMultiPatch<T> * ALEvelocity = nullptr,
                       gsBoundaryInterface * interfaceALE2Flow = nullptr);
 
    static gsOptionList defaultOptions();
 
    void setSolutionVector(const gsMatrix<T> & solutionVector)
    {
        GISMO_ENSURE(solutionVector.rows() == stiffAssembler.numDofs(),"Wrong size of the solution vector: " + util::to_string(solutionVector.rows()) +
                     ". Must be: " + util::to_string(stiffAssembler.numDofs()));
        solVector = solutionVector;
        initialized = false;
    }
    using Base::setFixedDofs;
    virtual void setFixedDofs(const std::vector<gsMatrix<T> > & ddofs)
    {
        Base::setFixedDofs(ddofs);
        initialized = false;
    }
 
    void makeTimeStep(T timeStep);
 
    using Base::assemble;
    virtual bool assemble(const gsMatrix<T> & solutionVector,
                          const std::vector<gsMatrix<T> > & fixedDoFs);
 
    virtual int numDofs() const { return stiffAssembler.numDofs(); }
 
    const gsMatrix<T> & solutionVector() const
    {
        GISMO_ENSURE(solVector.rows() == stiffAssembler.numDofs(),
                     "No initial conditions provided!");
        return solVector;
    }
 
    void saveState();
 
    void recoverState();
 
    index_t numberIterations() const { return numIters;}
 
    using Base::constructSolution;
    void constructSolution(gsMultiPatch<T> & velocity, gsMultiPatch<T> & pressure) const;
 
    gsBaseAssembler<T> & mAssembler();
    gsBaseAssembler<T> & assembler();
 
    const gsBoundaryInterface & aleInterface() const {return *interface;}
 
protected:
    void initialize();
 
    void implicitLinear();
    void implicitNonlinear();
 
protected:
    gsNsAssembler<T> & stiffAssembler;
    gsMassAssembler<T> & massAssembler;
    bool initialized;
    T tStep;
    gsMatrix<T> solVector;
    using Base::m_system;
    using Base::m_options;
    using Base::m_ddof;
 
    T oldTimeStep;
    gsMatrix<T> oldSolVector;
 
    gsMatrix<T> constRHS;
    index_t numIters;
 
    gsMultiPatch<T> * velocityALE;
    gsBoundaryInterface * interface;
 
    bool hasSavedState;
    gsMatrix<T> velVecSaved;
    gsMatrix<T> oldVecSaved;
    gsMatrix<T> massRhsSaved;
    gsMatrix<T> stiffRhsSaved;
    gsSparseMatrix<T> stiffMatrixSaved;
    std::vector<gsMatrix<T> > ddofsSaved;
};
 
}
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsNsTimeIntegrator.hpp)
#endif