gsCompositePrecOp.h

Go to the documentation of this file.

 
#pragma once
 
#include<gsCore/gsLinearAlgebra.h>
#include<gsSolver/gsLinearOperator.h>
 
namespace gismo
{
 
template <class T>
class gsCompositePrecOp GISMO_FINAL : public gsPreconditionerOp<T>
{
    typedef typename gsPreconditionerOp<T>::Ptr BasePtr;
public:
 
    typedef memory::shared_ptr<gsCompositePrecOp> Ptr;
 
    typedef memory::unique_ptr<gsCompositePrecOp> uPtr;
 
    gsCompositePrecOp() : m_ops() {}
 
    gsCompositePrecOp(std::vector< BasePtr > ops)
        : m_ops(give(ops)) {}
 
    gsCompositePrecOp(BasePtr op0, BasePtr op1)
        : m_ops(2)
    {
        m_ops[0] = give(op0); m_ops[1] = give(op1);
    }
 
    gsCompositePrecOp(BasePtr op0, BasePtr op1, BasePtr op2)
        : m_ops(3)
    {
        m_ops[0] = give(op0); m_ops[1] = give(op1); m_ops[2] = give(op2);
    }
 
    static uPtr make(std::vector< BasePtr > ops)
    {
        return uPtr( new gsCompositePrecOp(give(ops)) );
    }
 
    static uPtr make(BasePtr op0, BasePtr op1)
    {
        return uPtr( new gsCompositePrecOp(give(op0),give(op1)) );
    }
 
    static uPtr make(BasePtr op0, BasePtr op1, BasePtr op2)
    {
        return uPtr( new gsCompositePrecOp(give(op0),give(op1),give(op2)) );
    }
 
    void addOperator(BasePtr op)
    {
        m_ops.push_back(give(op));
    }
 
    virtual void step(const gsMatrix<T>& rhs, gsMatrix<T>& x) const
    {
        const size_t sz = m_ops.size();
        for ( size_t i=0; i<sz; ++i )
            m_ops[i]->step(rhs,x);
    }
 
    virtual void stepT(const gsMatrix<T>& rhs, gsMatrix<T>& x) const
    {
        const index_t sz = m_ops.size();
        for ( index_t i=sz-1; i>=0; --i )
            m_ops[i]->stepT(rhs,x);
    }
 
    typename gsLinearOperator<T>::Ptr underlyingOp() const
    { GISMO_NO_IMPLEMENTATION }
 
    index_t rows() const
    {
        GISMO_ASSERT( !m_ops.empty(), "gsCompositePrecOp::rows does not work for 0 operators.");
        return m_ops[0]->rows();
    }
 
    index_t cols() const
    {
        GISMO_ASSERT( !m_ops.empty(), "gsCompositePrecOp::rows does not work for 0 operators.");
        return m_ops[0]->cols();
    }
 
private:
    std::vector< BasePtr > m_ops;
};
 
 
} // namespace gismo