gsNsTimeIntegrator.h

Go to the documentation of this file.

#pragma once

#include <gsElasticity/gsBaseAssembler.h>
#include <gsElasticity/gsBaseUtils.h>

namespace gismo
{

template <class T>
class gsNsAssembler;
template <class T>
class gsMassAssembler;

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;
    }
    virtual void setFixedDofs(const std::vector<gsMatrix<T> > & ddofs)
    {
        Base::setFixedDofs(ddofs);
        initialized = false;
    }

    void makeTimeStep(T timeStep);

    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;}

    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