gsFlowSolverParams.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsIncompressibleFlow/src/gsNavStokesPde.h>
#include <gsIncompressibleFlow/src/gsINSPreconditioners.h>
 
namespace gismo
{
 
template<class T>
class gsFlowSolverParams
{
 
protected: // *** Class members ***
 
    gsNavStokesPde<T>               m_pde;
    std::vector<gsMultiBasis<T> >   m_bases;
    gsAssemblerOptions              m_assembOpt;
    gsOptionList                    m_opt;
    gsOptionList                    m_precOpt;
 
    bool m_isBndSet;
    std::vector<std::pair<int, boxSide> > m_bndIn, m_bndOut, m_bndWall;
 
public: // *** Constructor/destructor ***
 
    gsFlowSolverParams() {}
    
 
    gsFlowSolverParams(const gsNavStokesPde<T>& pde, const std::vector<gsMultiBasis<T> >& bases)
        : m_pde(pde), m_bases(bases)
    {
        m_assembOpt.dirStrategy = dirichlet::elimination;
        m_assembOpt.dirValues = dirichlet::interpolation;
        m_assembOpt.intStrategy = iFace::glue;
 
        m_opt = gsFlowSolverParams<T>::defaultOptions();
        m_precOpt = gsINSPreconditioner<T, RowMajor>::defaultOptions();
 
        m_isBndSet = false;
    }
 
    ~gsFlowSolverParams()
    {
    }
 
public: // *** Static functions ***
 
    static gsOptionList defaultOptions()
    {
        gsOptionList opt;
 
        // nonlinear iteration
        opt.addInt("nonlin.maxIt", "Maximum number of Picard iterations in one time step", 10);
        opt.addReal("nonlin.tol", "Stopping tolerance for Picard iteration", 1e-5);
        
        // solving linear systems
        opt.addString("lin.solver", "The type of linear system solver (direct / iter / petsc)", "direct");
        opt.addString("lin.krylov", "The Krylov subspace method from G+Smo/Eigen (for lin.solver = iter)", "gmres");
        opt.addString("lin.precType", "Preconditioner to be used with iterative linear solver", "MSIMPLER_FdiagEqual");
        opt.addInt("lin.maxIt", "Maximum number of iterations for linear solver (if iterative)", 200);
        opt.addReal("lin.tol", "Stopping tolerance for linear solver (if iterative)", 1e-6);
 
        // asssembly 
        //opt.addString("assemb.quad", "The numerical quadrature (Gauss/WQ)", "Gauss");
        opt.addString("assemb.loop", "EbE = element by element, RbR = row by row", "EbE");
        //opt.addSwitch("assemb.sumFact", "Use sum factorization for integration", false);
        opt.addSwitch("fillGlobalSyst", "Fill the global linear systems from blocks", true);
        
        // time-dependent problem
        opt.addSwitch("unsteady", "Assemble the velocity mass matrix", false);
        opt.addReal("timeStep", "Time step size", 0.1);
 
        // output
        opt.addSwitch("fileOutput", "Create an output file", false);
        opt.addSwitch("quiet", "Do not display output in terminal", false);
        opt.addString("outFile", "Name of the output file (or the full path to it)", "");
 
        // parallel 
        opt.addSwitch("parallel", "Currently running in parallel", false);
 
        // geometry jacobian evaluation
        opt.addInt("jac.npts", "Number of points along a patch side (in each direction) for geometry jacobian check", 100);
        opt.addReal("jac.dist", "Distance from boundary (in the parametric space) for geometry jacobian check", 1e-2);
        opt.addReal("jac.tol", "Critical value of geometry jacobian to throw warning", 1e-4);
 
        return opt;
    }
 
 
public: // *** Member functions ***
 
    void createDofMappers(std::vector<gsDofMapper>& mappers)
    {
        mappers.resize(2);
    
        m_bases.front().getMapper(m_assembOpt.dirStrategy, m_assembOpt.intStrategy, m_pde.bc(), mappers.front(), 0);
        m_bases.back().getMapper(m_assembOpt.dirStrategy, m_assembOpt.intStrategy,  m_pde.bc(), mappers.back(), 1);
    }
 
    void setBndParts(std::vector<std::pair<int, boxSide> > bndIn, std::vector<std::pair<int, boxSide> > bndOut, std::vector<std::pair<int, boxSide> > bndWall)
    {
        m_bndIn = bndIn;
        m_bndOut = bndOut;
        m_bndWall = bndWall;
 
        m_isBndSet = true;
    }
 
 
public: // *** Getters/setters ***
 
    const gsNavStokesPde<T>& getPde() const { return m_pde; }
 
    const gsBoundaryConditions<T>& getBCs() const { return m_pde.bc(); }
 
    std::vector<gsMultiBasis<T> >&       getBases() { return m_bases; }
    const std::vector<gsMultiBasis<T> >& getBases() const { return m_bases; }
 
    gsAssemblerOptions& assemblerOptions() { return m_assembOpt; }
    const gsAssemblerOptions& assemblerOptions() const { return m_assembOpt; }
 
    void setAssemblerOptions(const gsAssemblerOptions& opt) { m_assembOpt = opt; }
 
    gsOptionList& precOptions() { return m_precOpt; }
    const gsOptionList& precOptions() const { return m_precOpt; }
 
    void setPrecOptions(const gsOptionList& opt) { m_precOpt = opt; }
 
    gsOptionList& options() { return m_opt; }
    const gsOptionList& options() const { return m_opt; }
 
    void setOptions(const gsOptionList& opt) { m_opt = opt; }
 
    std::vector<std::pair<int, boxSide> > getBndIn()
    {
        GISMO_ASSERT(m_isBndSet, "Boundary parts are not set in gsFlowSolverParams, call setBndParts(...).");
        return m_bndIn;
    }
 
    std::vector<std::pair<int, boxSide> > getBndOut()
    {
        GISMO_ASSERT(m_isBndSet, "Boundary parts are not set in gsFlowSolverParams, call setBndParts(...).");
        return m_bndOut;
    }
 
    std::vector<std::pair<int, boxSide> > getBndWall()
    {
        GISMO_ASSERT(m_isBndSet, "Boundary parts are not set in gsFlowSolverParams, call setBndParts(...).");
        return m_bndWall;
    }
 
 
}; // class gsFlowSolverParams
 
} // namespace gismo