gsFlowSolverBase.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsIncompressibleFlow/src/gsFlowAssemblerBase.h>
#include <gsIncompressibleFlow/src/gsFlowLinSystSolver.h>
#include <gsIncompressibleFlow/src/gsFlowSolverParams.h>
#include <gsIncompressibleFlow/src/gsFlowUtils.h>
 
namespace gismo
{
 
template<class T, int MatOrder>
class gsFlowSolverBase
{
 
protected: // *** Class members ***
 
    gsFlowSolverParams<T> m_params;
    gsFlowAssemblerBase<T, MatOrder>* m_assemblerPtr;
    gsFlowLinSystSolver<T, MatOrder>* m_linSolverPtr;
 
    gsMatrix<T> m_solution;
    unsigned m_iterationNumber;
    gsStopwatch m_clock;
    T m_initAssembT, m_assembT, m_relNorm;
 
    bool m_fileOutput, m_dispOutput;
    std::ofstream m_outFile;
    std::stringstream m_outStream;
    
 
public: // *** Constructor/destructor ***
 
    gsFlowSolverBase(const gsFlowSolverParams<T>& params):
    m_params(params)
    {
        m_assemblerPtr = NULL;
    }
 
    virtual ~gsFlowSolverBase()
    {
        if (m_assemblerPtr)
        {
            delete m_assemblerPtr;
            m_assemblerPtr = NULL;
        }
 
        if (m_linSolverPtr)
        {
            delete m_linSolverPtr;
            m_linSolverPtr = NULL;
        }
 
        if (m_outFile.is_open())
            m_outFile.close();
    }
 
 
protected: // *** Member functions ***
 
    virtual void initMembers();
 
    virtual void updateSizes();
 
    virtual void createOutputFile();
 
    real_t stopwatchStart();
 
    real_t stopwatchStop();
 
 
public: // *** Member functions ***
 
    virtual void initialize();
 
    virtual void initIteration()
    { getLinSolver()->setupSolver(getAssembler()->matrix()); }
 
    virtual void initIteration(const gsSparseMatrix<T, MatOrder>& mat)
    { getLinSolver()->setupSolver(mat); }
 
    virtual void applySolver(gsMatrix<T>& solution)
    { getLinSolver()->applySolver(getAssembler()->matrix(), getAssembler()->rhs(), solution); }
 
    virtual void nextIteration() { GISMO_NO_IMPLEMENTATION }
 
    virtual void nextIteration(const unsigned numberOfIterations);
    
    void solve(const int maxIterations, const T epsilon = 1e-3, const int minIterations = 1);
 
    virtual void updateAssembler(const gsMatrix<T>& sol, bool updateSol = true);
 
    virtual void updateAssembler(bool updateSol = true)
    { updateAssembler(m_solution, updateSol); }
 
    T solutionChangeRelNorm() const;
 
    T solutionChangeRelNorm(gsMatrix<T> solOld, gsMatrix<T> solNew) const;
 
    virtual void writeSolChangeRelNorm(gsMatrix<T> solOld, gsMatrix<T> solNew);
 
    virtual T residualRelNorm() const 
    { return residualRelNorm(m_solution); }
 
    virtual T residualRelNorm(const gsMatrix<T>& solution) const
    { GISMO_NO_IMPLEMENTATION }
 
    gsField<T> constructSolution(int unk) const
    { return getAssembler()->constructSolution(m_solution, unk); }
 
    virtual void markDofsAsEliminatedZeros(const std::vector< gsMatrix< index_t > > & boundaryDofs, const int unk);
 
    int checkGeoJacobian(int npts = -1, T dist = -1, T tol = -1);
    
public: // *** Getters/setters ***
 
    virtual std::string getName() { return "gsFlowSolverBase"; }
 
    virtual gsFlowSolverParams<T> getParams() { return m_params; }
 
    virtual gsFlowAssemblerBase<T, MatOrder>* getAssembler() const { return m_assemblerPtr; }
 
    gsFlowLinSystSolver<T, MatOrder>* getLinSolver() const { return m_linSolverPtr; }
 
    const gsMatrix<T> & getSolution() const { return m_solution; }
 
    virtual void setSolution(const gsMatrix<T> & solVector) { m_solution = solVector; }
 
    unsigned getIterationNumber() const { return m_iterationNumber; }
 
    int numDofs() const { return getAssembler()->numDofs(); }
 
    virtual const T getInitAssemblyTime() const { return m_initAssembT; }
 
    virtual const T getAssemblyTime() const { return m_initAssembT + m_assembT; }
 
    virtual const T getSolverSetupTime() const { return getLinSolver()->getSolverSetupTime(); }
 
    virtual const T getSolveTime() const { return getLinSolver()->getSolveTime(); }
 
 
}; // gsFlowSolverBase
 
} // namespace gismo
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsFlowSolverBase.hpp)
#endif