gsINSPreconditioners.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsIncompressibleFlow/src/gsINSPrecondBlocks.h>
#include <gsIncompressibleFlow/src/gsFlowUtils.h>
 
#include <gsSolver/gsLinearOperator.h>
#include <gsSolver/gsMatrixOp.h>
 
namespace gismo
{
 
// === Base class for INS preconditioners === //
 
template <class T, int MatOrder>
class gsINSPreconditioner : public gsLinearOperator<T>
{
 
public: // *** Smart pointers ***
 
    typedef memory::shared_ptr<gsINSPreconditioner> Ptr;
    typedef memory::unique_ptr<gsINSPreconditioner> uPtr;
 
public: // *** Constructor/destructor ***
 
    gsINSPreconditioner() {}
 
public: // *** Static functions ***
 
    static uPtr make()
    { return memory::make_unique(new gsINSPreconditioner<T, MatOrder>()); }
 
    static uPtr make(std::string precType, const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt);
 
    static gsOptionList defaultOptions();
 
 
public: // *** Member functions ***
 
    virtual void apply(const gsMatrix<T> & input, gsMatrix<T> & x) const
    { GISMO_NO_IMPLEMENTATION }
 
    virtual void update(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat)
    { GISMO_NO_IMPLEMENTATION }
 
public: // *** Getters/setters ***
 
    virtual int rows() const
    { GISMO_NO_IMPLEMENTATION }
 
    virtual int cols() const
    { GISMO_NO_IMPLEMENTATION }
 
    virtual std::string getName()
    { GISMO_NO_IMPLEMENTATION }
 
}; // class gsINSPreconditioner
 
 
// === Block preconditioner === //
 
template <class T, int MatOrder>
class gsINSBlockPrecondBase : public gsINSPreconditioner<T, MatOrder>
{
 
protected: // *** Class members ***
 
    typename gsINSPrecondBlock<T>::Ptr m_Finv, m_Sinv;
    typename gsLinearOperator<T>::Ptr m_Bt;
    const gsOptionList m_opt;
 
public: // *** Smart pointers ***
 
    typedef memory::shared_ptr<gsINSBlockPrecondBase> Ptr;
    typedef memory::unique_ptr<gsINSBlockPrecondBase> uPtr;
 
public: // *** Constructor/destructor ***
 
    gsINSBlockPrecondBase(gsINSPrecondBlock<T>* Finv, gsLinearOperator<T>* B, gsINSPrecondBlock<T>* Sinv, const gsOptionList& opt) :
        m_Finv(Finv), m_Sinv(Sinv), m_Bt(B), m_opt(opt)
    {}
 
public: // *** Static functions ***
 
    static uPtr make(gsINSPrecondBlock<T>* Finv, gsLinearOperator<T>* B, gsINSPrecondBlock<T>* Sinv, const gsOptionList& opt)
    { return memory::make_unique(new gsINSBlockPrecondBase<T, MatOrder>(Finv, B, Sinv, opt)); }
 
public: // *** Member functions ***
 
    virtual void apply(const gsMatrix<T> & input, gsMatrix<T> & x) const;
 
protected: // *** Member functions ***
 
    void update(gsINSPrecondBlock<T>* Finv)
    {
        m_Finv.reset(Finv);
    }
 
    void update(gsINSPrecondBlock<T>* Finv, gsINSPrecondBlock<T>* Sinv)
    {
        m_Finv.reset(Finv);
        m_Sinv.reset(Sinv);
    }
 
public: // *** Getters/setters ***
 
    virtual int rows() const
    {
        return (m_Finv->rows() + m_Sinv->rows());
    }
 
    virtual int cols() const
    {
        return (m_Finv->cols() + m_Bt->cols());
    }
 
}; // class gsINSBlockPrecondBase
 
 
// === LSC preconditioner === //
 
template <class T, int MatOrder, class BlockFType = gsINSPrecondBlockF<T, MatOrder> >
class gsINSBlockPrecondLSC : public gsINSBlockPrecondBase<T, MatOrder>
{
 
public:
    typedef gsINSBlockPrecondBase<T, MatOrder> Base;
 
protected: // *** Class members ***
 
    using Base::m_Finv;
    using Base::m_opt;
 
public: // *** Smart pointers ***
 
    typedef memory::shared_ptr<gsINSBlockPrecondLSC> Ptr;
    typedef memory::unique_ptr<gsINSBlockPrecondLSC> uPtr;
 
public: // *** Constructor/destructor ***
 
    gsINSBlockPrecondLSC(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt) :
        Base(new BlockFType(mat.at("matNS"), opt),
             new gsINSPrecondBlockBt<T, MatOrder>(mat.at("matNS"), opt),
             new gsINSPrecondSchurLSC<T, MatOrder>(mat, opt), opt)
    { }
 
public: // *** Static functions ***
 
    static uPtr make(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt)
    {
        return memory::make_unique(new gsINSBlockPrecondLSC<T, MatOrder, BlockFType>(mat, opt));
    }
 
public: // *** Member functions ***
 
    virtual void update(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat)
    {
        Base::update(new BlockFType(mat.at("matNS"), m_opt), new gsINSPrecondSchurLSC<T, MatOrder>(mat, m_opt));
    }
 
    virtual std::string getName()
    {
        std::string name = "LSC_" + m_Finv->getName();
        return name;
    }
 
}; // class gsINSBlockPrecondLSC
 
 
// === PCD preconditioner === //
 
template <class T, int MatOrder, class BlockFType = gsINSPrecondBlockF<T, MatOrder> >
class gsINSBlockPrecondPCD : public gsINSBlockPrecondBase<T, MatOrder>
{
 
public:
    typedef gsINSBlockPrecondBase<T, MatOrder> Base;
 
protected: // *** Class members ***
 
    using Base::m_Finv;
    using Base::m_opt;
 
public: // *** Smart pointers ***
 
    typedef memory::shared_ptr<gsINSBlockPrecondPCD> Ptr;
    typedef memory::unique_ptr<gsINSBlockPrecondPCD> uPtr;
 
public: // *** Constructor/destructor ***
 
    gsINSBlockPrecondPCD(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt) :
        Base(new BlockFType(mat.at("matNS"), opt),
            new gsINSPrecondBlockBt<T, MatOrder>(mat.at("matNS"), opt),
            new gsINSPrecondSchurPCD<T, MatOrder>(mat, opt), opt)
    { }
 
public: // *** Static functions ***
 
    static uPtr make(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt)
    {
        return memory::make_unique(new gsINSBlockPrecondPCD<T, MatOrder, BlockFType>(mat, opt));
    }
 
public: // *** Member functions ***
 
    virtual void update(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat)
    {
        Base::update(new BlockFType(mat.at("matNS"), m_opt), new gsINSPrecondSchurPCD<T, MatOrder>(mat, m_opt));
    }
 
    virtual std::string getName()
    {
        std::string name = "PCD_" + m_Finv->getName();
        return name;
    }
 
}; // class gsINSBlockPrecondPCD
 
 
// === PCDmod preconditioner === //
 
template <class T, int MatOrder, class BlockFType = gsINSPrecondBlockF<T, MatOrder> >
class gsINSBlockPrecondPCDmod : public gsINSBlockPrecondBase<T, MatOrder>
{
 
public:
    typedef gsINSBlockPrecondBase<T, MatOrder> Base;
 
protected: // *** Class members ***
 
    using Base::m_Finv;
    using Base::m_opt;
 
public: // *** Smart pointers ***
 
    typedef memory::shared_ptr<gsINSBlockPrecondPCDmod> Ptr;
    typedef memory::unique_ptr<gsINSBlockPrecondPCDmod> uPtr;
 
public: // *** Constructor/destructor ***
 
    gsINSBlockPrecondPCDmod(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt) :
        Base(new BlockFType(mat.at("matNS"), opt),
            new gsINSPrecondBlockBt<T, MatOrder>(mat.at("matNS"), opt),
            new gsINSPrecondSchurPCDmod<T, MatOrder>(mat, opt), opt)
    { }
 
public: // *** Static functions ***
 
    static uPtr make(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt)
    {
        return memory::make_unique(new gsINSBlockPrecondPCDmod<T, MatOrder, BlockFType>(mat, opt));
    }
 
public: // *** Member functions ***
 
    virtual void update(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat)
    {
        Base::update(new BlockFType(mat.at("matNS"), m_opt), new gsINSPrecondSchurPCDmod<T, MatOrder>(mat, m_opt));
    }
 
    virtual std::string getName()
    {
        std::string name = "PCDmod_" + m_Finv->getName();
        return name;
    }
 
}; // class gsINSBlockPrecondPCDmod
 
 
// === AL preconditioner === //
 
template <class T, int MatOrder, class BlockFType = gsINSPrecondBlockFwhole<T, MatOrder> >
class gsINSBlockPrecondAL : public gsINSBlockPrecondBase<T, MatOrder>
{
 
public:
    typedef gsINSBlockPrecondBase<T, MatOrder> Base;
 
 protected: // *** Class members ***
 
    using Base::m_Finv;
    using Base::m_opt;
 
public: // *** Smart pointers ***
 
    typedef memory::shared_ptr<gsINSBlockPrecondAL> Ptr;
    typedef memory::unique_ptr<gsINSBlockPrecondAL> uPtr;
 
public: // *** Constructor/destructor ***
 
    gsINSBlockPrecondAL(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt) :
        Base(new BlockFType(mat.at("matNS"), opt),
            new gsINSPrecondBlockBt<T, MatOrder>(mat.at("matNS"), opt),
            new gsINSPrecondSchurAL<T, MatOrder>(mat, opt), opt)
    { }
 
public: // *** Static functions ***
 
    static uPtr make(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt)
    {
        return memory::make_unique(new gsINSBlockPrecondAL<T, MatOrder, BlockFType>(mat, opt));
    }
 
public: // *** Static functions ***
 
    static void fillALgammaPart_into(gsSparseMatrix<T, MatOrder>& matGammaPart, gsMatrix<T>& rhsGammaPart, const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsMatrix<T>& rhs, const gsOptionList& opt);
 
    static void fillALmodifSystem_into(gsSparseMatrix<T, MatOrder>& matGamma, gsMatrix<T>& rhsGamma, const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsMatrix<T>& rhs, const gsOptionList& opt);
 
public: // *** Member functions ***
 
    virtual void update(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat)
    {
        Base::update(new BlockFType(mat.at("matNS"), m_opt));
    }
 
    virtual std::string getName()
    {
        std::string name = "AL_" + m_Finv->getName();
        return name;
    }
 
}; // class gsINSBlockPrecondAL
 
 
// === SIMPLE preconditioner === //
 
template <class T, int MatOrder, class BlockFType = gsINSPrecondBlockF<T, MatOrder> >
class gsINSBlockPrecondSIMPLE : public gsINSBlockPrecondBase<T, MatOrder>
{
 
public:
    typedef gsINSBlockPrecondBase<T, MatOrder> Base;
 
protected: // *** Class members ***
 
    gsSparseMatrix<T, MatOrder> m_Dinv, m_B;
    real_t m_alphaP;
 
protected: // *** Base class members ***
 
    using Base::m_Finv;
    using Base::m_Bt;
    using Base::m_Sinv;
    using Base::m_opt;
 
public: // *** Smart pointers ***
 
    typedef memory::shared_ptr<gsINSBlockPrecondSIMPLE> Ptr;
    typedef memory::unique_ptr<gsINSBlockPrecondSIMPLE> uPtr;
 
public: // *** Constructor/destructor ***
 
    gsINSBlockPrecondSIMPLE(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt) :
        Base(new BlockFType(mat.at("matNS"), opt),
            new gsINSPrecondBlockBt<T, MatOrder>(mat.at("matNS"), opt),
            new gsINSPrecondSchurSIMPLE<T, MatOrder>(mat, opt), opt)
    {
        int uSize = opt.getInt("dim") * opt.getInt("udofs");
        int pdofs = opt.getInt("pdofs");
 
        const gsSparseMatrix<T, MatOrder>& matNS = mat.at("matNS");
 
        gsSparseMatrix<T, MatOrder> blockA = matNS.block(0, 0, uSize, uSize);
        diagInvMatrix_into(blockA, m_Dinv, 1, opt.getSwitch("lumpingA"));
 
        m_B = matNS.block(uSize, 0, pdofs, uSize);
 
        m_alphaP = opt.askReal("alphaP", 1.0);
    }
 
public: // *** Static functions ***
 
    static uPtr make(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt)
    {
        return memory::make_unique(new gsINSBlockPrecondSIMPLE<T, MatOrder, BlockFType>(mat, opt));
    }
 
public: // *** Member functions ***
 
    virtual void update(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat)
    {
        Base::update(new BlockFType(mat.at("matNS"), m_opt), new gsINSPrecondSchurSIMPLE<T, MatOrder>(mat, m_opt));
    }
 
    virtual void apply(const gsMatrix<T> & input, gsMatrix<T> & x) const;
 
    virtual std::string getName()
    {
        std::string name = "SIMPLE_" + m_Finv->getName();
        return name;
    }
 
}; // class gsINSBlockPrecondSIMPLE
 
 
// === SIMPLER preconditioner === //
 
template <class T, int MatOrder, class BlockFType = gsINSPrecondBlockF<T, MatOrder> >
class gsINSBlockPrecondSIMPLER : public gsINSBlockPrecondSIMPLE<T, MatOrder, BlockFType>
{
 
public:
    typedef gsINSBlockPrecondSIMPLE<T, MatOrder, BlockFType> Base;
 
protected: // *** Class members ***
 
    gsSparseMatrix<T, MatOrder> m_BDinv;
 
protected: // *** Base class members ***
 
    using Base::m_Dinv;
    using Base::m_B;
    using Base::m_alphaP;
    using gsINSBlockPrecondBase<T, MatOrder>::m_Finv;
    using gsINSBlockPrecondBase<T, MatOrder>::m_Bt;
    using gsINSBlockPrecondBase<T, MatOrder>::m_Sinv;
 
public: // *** Smart pointers ***
 
    typedef memory::shared_ptr<gsINSBlockPrecondSIMPLER> Ptr;
    typedef memory::unique_ptr<gsINSBlockPrecondSIMPLER> uPtr;
 
public: // *** Constructor/destructor ***
 
    gsINSBlockPrecondSIMPLER(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt) :
        Base(mat, opt)
    {
        m_BDinv = m_B * m_Dinv;
    }
 
public: // *** Static functions ***
 
    static uPtr make(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt)
    {
        return memory::make_unique(new gsINSBlockPrecondSIMPLER<T, MatOrder, BlockFType>(mat, opt));
    }
 
public: // *** Member functions ***
 
    virtual void apply(const gsMatrix<T> & input, gsMatrix<T> & x) const;
 
    virtual std::string getName()
    {
        std::string name = "SIMPLER_" + m_Finv->getName();
        return name;
    }
 
}; // class gsINSBlockPrecondSIMPLER
 
 
// === MSIMPLER preconditioner === //
 
template <class T, int MatOrder, class BlockFType = gsINSPrecondBlockF<T, MatOrder> >
class gsINSBlockPrecondMSIMPLER : public gsINSBlockPrecondBase<T, MatOrder>
{
 
public:
    typedef gsINSBlockPrecondBase<T, MatOrder> Base;
 
protected: // *** Class members ***
 
    gsSparseMatrix<T, MatOrder> m_velMinv, m_B, m_BMinv;
    real_t m_alphaP;
 
protected: // *** Base class members ***
 
    using Base::m_Finv;
    using Base::m_Bt;
    using Base::m_Sinv;
    using Base::m_opt;
 
public: // *** Smart pointers ***
 
    typedef memory::shared_ptr<gsINSBlockPrecondMSIMPLER> Ptr;
    typedef memory::unique_ptr<gsINSBlockPrecondMSIMPLER> uPtr;
 
public: // *** Constructor/destructor ***
 
    gsINSBlockPrecondMSIMPLER(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt) :
        Base(new BlockFType(mat.at("matNS"), opt),
            new gsINSPrecondBlockBt<T, MatOrder>(mat.at("matNS"), opt),
            new gsINSPrecondSchurMSIMPLER<T, MatOrder>(mat, opt), opt)
    {
        int dim = opt.getInt("dim");
        int udofs = opt.getInt("udofs");
        int uSize = dim * udofs;
        int pdofs = opt.getInt("pdofs");
 
        const gsSparseMatrix<T, MatOrder>& matNS = mat.at("matNS");
        const gsSparseMatrix<T, MatOrder>& velM = mat.at("matMu");
 
       // approximation of velocity mass matrix inverse
        diagInvMatrix_into(velM, m_velMinv, uSize / velM.rows(), opt.getSwitch("lumpingM"));
 
        m_B = matNS.block(uSize, 0, pdofs, uSize);
        m_BMinv = m_B * m_velMinv;
 
        m_alphaP = opt.askReal("alphaP", 1.0);
    }
 
public: // *** Static functions ***
 
    static uPtr make(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt)
    {
        return memory::make_unique(new gsINSBlockPrecondMSIMPLER<T, MatOrder, BlockFType>(mat, opt));
    }
 
public: // *** Member functions ***
 
    virtual void update(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat)
    {
        Base::update(new BlockFType(mat.at("matNS"), m_opt));
    }
 
    virtual void apply(const gsMatrix<T> & input, gsMatrix<T> & x) const;
 
    virtual std::string getName()
    {
        std::string name = "MSIMPLER_" + m_Finv->getName();
        return name;
    }
 
}; // class gsINSBlockPrecondMSIMPLER
 
 
// === Stokes diagonal preconditioner === //
 
template <class T, int MatOrder, class BlockFType = gsINSPrecondBlockF<T, MatOrder> >
class gsBlockPrecondStokes : public gsINSPreconditioner<T, MatOrder>
{
 
protected: // *** Class members ***
 
    typename gsINSPrecondBlock<T>::Ptr m_Finv, m_Sinv;
    const gsOptionList m_opt;
 
public: // *** Smart pointers ***
 
    typedef memory::shared_ptr<gsBlockPrecondStokes> Ptr;
    typedef memory::unique_ptr<gsBlockPrecondStokes> uPtr;
 
public: // *** Constructor/destructor ***
 
    gsBlockPrecondStokes(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt) :
        m_Finv(new BlockFType(mat.at("matNS"), opt)), m_Sinv(new gsINSPrecondSchurStokes<T, MatOrder>(mat, opt)), m_opt(opt)
    {}
 
public: // *** Static functions ***
 
    static uPtr make(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt)
    {
        return memory::make_unique(new gsBlockPrecondStokes<T, MatOrder, BlockFType>(mat, opt));
    }
 
public: // *** Member functions ***
 
    virtual void update(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat)
    {
        m_Finv.reset(new BlockFType(mat.at("matNS"), m_opt));
    }
 
 
    virtual void apply(const gsMatrix<T> & input, gsMatrix<T> & x) const;
 
public: // *** Getters/setters ***
 
    virtual int rows() const
    {
        return (m_Finv->rows() + m_Sinv->rows());
    }
 
    virtual int cols() const
    {
        return (m_Finv->cols() + m_Sinv->cols());
    }
 
    virtual std::string getName()
    {
        std::string name = "StokesDiag_" + m_Finv->getName();
        return name;
    }
 
}; // class gsBlockPrecondStokes
 
 
// === Stokes triangular preconditioner === //
 
template <class T, int MatOrder, class BlockFType = gsINSPrecondBlockF<T, MatOrder> >
class gsBlockPrecondStokesTriang : public gsINSBlockPrecondBase<T, MatOrder>
{
 
public:
    typedef gsINSBlockPrecondBase<T, MatOrder> Base;
 
protected: // *** Base class members ***
 
    using Base::m_Finv;
    using Base::m_opt;
 
public: // *** Smart pointers ***
    
    typedef memory::shared_ptr<gsBlockPrecondStokesTriang> Ptr;
    typedef memory::unique_ptr<gsBlockPrecondStokesTriang> uPtr;
 
public: // *** Constructor/destructor ***
 
    gsBlockPrecondStokesTriang(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt) :
        Base(new BlockFType(mat.at("matNS"), opt),
            new gsINSPrecondBlockBt<T, MatOrder>(mat.at("matNS"), opt),
            new gsINSPrecondSchurStokes<T, MatOrder>(mat, opt), opt)
    { }
 
public: // *** Static functions ***
 
    static uPtr make(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat, const gsOptionList& opt)
    {
        return memory::make_unique(new gsBlockPrecondStokesTriang<T, MatOrder, BlockFType>(mat, opt));
    }
 
public: // *** Member functions ***
 
    virtual void update(const std::map<std::string, gsSparseMatrix<T, MatOrder> >& mat)
    {
        Base::update(new BlockFType(mat.at("matNS"), m_opt));
    }
 
    virtual std::string getName()
    {
        std::string name = "StokesTriang_" + m_Finv->getName();
        return name;
    }
 
}; // class gsBlockPrecondStokesTriang
 
} // namespace gismo
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsINSPreconditioners.hpp)
#endif