gsINSSolver.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsIncompressibleFlow/src/gsFlowUtils.h>
#include <gsIncompressibleFlow/src/gsFlowSolverBase.h>
#include <gsIncompressibleFlow/src/gsINSAssembler.h>
#include <gsIncompressibleFlow/src/gsFlowSolverParams.h>
 
#include <gsCore/gsDebug.h>
#include <gsCore/gsLinearAlgebra.h>
#include <gsUtils/gsStopwatch.h>
 
namespace gismo
{
 
template<class T, int MatOrder>
class gsINSSolver: public gsFlowSolverBase<T, MatOrder>
{
 
public:
    typedef gsFlowSolverBase<T, MatOrder> Base;
 
 
protected: // *** Base class members ***
 
    using Base::m_assemblerPtr;
    using Base::m_solution;
    using Base::m_iterationNumber;
    using Base::m_outFile;
    using Base::m_fileOutput;
    using Base::m_dispOutput;
 
 
public: // *** Constructor/destructor ***
 
    gsINSSolver(gsFlowSolverParams<T>& params):
    Base(params)
    { }
 
    virtual ~gsINSSolver()
    { }
 
 
public: // *** Member functions ***
 
    virtual void solveStokes();
 
 
public: // *** Getters/setters ***
 
    virtual std::string getName() { return "gsINSSolver"; }
 
    virtual gsINSAssembler<T, MatOrder>* getAssembler() const
    { return dynamic_cast<gsINSAssembler<T, MatOrder>*>(m_assemblerPtr); }
 
}; // gsINSSolver
 
// ===================================================================================================================
 
template<class T = real_t, int MatOrder = RowMajor>
class gsINSSolverSteady : public gsINSSolver<T, MatOrder>
{
 
public:
    typedef gsINSSolver<T, MatOrder> Base;
 
 
protected: // *** Base class members ***
 
    using Base::m_params;
    using Base::m_assemblerPtr;
    using Base::m_solution;
    using Base::m_iterationNumber;
 
    // m_initAssembT, m_assembT, m_solsetupT, m_solveT;
 
 
public: // *** Constructor/destructor ***
 
    gsINSSolverSteady(gsFlowSolverParams<T>& params):
    Base(params)
    { 
        m_assemblerPtr = new gsINSAssemblerSteady<T, MatOrder>(m_params);
 
        Base::initMembers();
        m_params.options().setSwitch("unsteady", false);
    }
 
 
public: // *** Member functions ***
 
    virtual void nextIteration();
 
 
public: // *** Getters/setters ***
 
    virtual gsINSAssemblerSteady<T, MatOrder>* getAssembler() const
    {
        return dynamic_cast<gsINSAssemblerSteady<T, MatOrder>*>(m_assemblerPtr);
    }
 
    virtual std::string getName() { return "gsINSSolverSteady"; }
 
 
}; // gsINSSolverSteady
 
// ===================================================================================================================
 
template<class T = real_t, int MatOrder = RowMajor>
class gsINSSolverUnsteady : public gsINSSolver<T, MatOrder>
{
 
public:
    typedef gsINSSolver<T, MatOrder> Base;
 
 
protected: // *** Class members ***
 
    T m_time, m_timeStepSize;
    T m_innerIter, m_avgPicardIter;
    T m_innerTol;
 
protected: // *** Base class members ***
 
    using Base::m_solution;
    using Base::m_iterationNumber;
    using Base::m_assemblerPtr;
    using Base::m_params;
    using Base::m_outFile;
    using Base::m_fileOutput;
    using Base::m_dispOutput;
 
 
public: // *** Constructor/destructor ***
 
    gsINSSolverUnsteady(gsFlowSolverParams<T>& params): Base(params)
    { 
        m_assemblerPtr = new gsINSAssemblerUnsteady<T, MatOrder>(m_params);
 
        initMembers();
        m_params.options().setSwitch("unsteady", true);
    }
 
 
protected: // *** Member functions ***
 
    virtual void initMembers();
 
    void plotCurrentTimeStep(std::ofstream& fileU, std::ofstream& fileP, std::string fileNameSuffix, unsigned plotPts);
 
 
public: // *** Member functions ***
 
    virtual void nextIteration();
 
    void solveWithAnimation(const int totalIter, const int iterStep, std::string fileNameSuffix = "", const T epsilon = 1e-3, unsigned plotPts = 10000, const int minIterations = 1);
 
    virtual void solveGeneralizedStokes(const int maxIterations, const T epsilon, const int minIterations = 1)
    { GISMO_NO_IMPLEMENTATION }
 
 
public: // *** Getters/setters ***
 
    gsINSAssemblerUnsteady<T, MatOrder>* getAssembler() const
    {
        return dynamic_cast<gsINSAssemblerUnsteady<T, MatOrder>*>(m_assemblerPtr);
    }
 
    // @brief Returns the elapsed simulation time.
    T getSimulationTime() const { return m_time; }
 
    T getAvgPicardIterations() const { return m_avgPicardIter / m_iterationNumber; }
 
    virtual std::string getName() { return "gsINSSolverUnsteady"; }
 
 
}; // gsINSSolverUnsteady
 
} // namespace gismo
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsINSSolver.hpp)
#endif