gsBasisFun.h

Go to the documentation of this file.

#pragma once

#include <gsCore/gsFunction.h>

namespace gismo
{

template<class T> class gsBasis;

template<class T>
class gsBasisFun : public gsFunction<T>
{
private:
    gsBasisFun() { }
    
public:
    typedef memory::shared_ptr< gsBasisFun > Ptr;

    typedef memory::unique_ptr< gsBasisFun > uPtr;

    gsBasisFun(const gsBasis<T> & basis, unsigned const i);

    ~gsBasisFun() { } //destructor

    GISMO_CLONE_FUNCTION(gsBasisFun)

public:

    virtual std::ostream &print(std::ostream &os) const
    {
        os << "gsBasisFun"; return os;
    }


    short_t domainDim () const {return m_basis.domainDim();}

    short_t targetDim () const {return m_basis.targetDim();}

    gsMatrix<T> support() const;

    void eval_into (const gsMatrix<T>& u, gsMatrix<T>& result ) const;

    void deriv_into(const gsMatrix<T>& u, gsMatrix<T>& result ) const;

    void setFunction( unsigned const & i );

    void first();

    bool next();

    bool valid();

    unsigned index() const { return m_index; }
    
    // temporary hack
    virtual const gsBasisFun & piece(const index_t) const
    {
        return *this; 
    }


// Data members
private:
    const gsBasis<T> & m_basis;
    unsigned m_index;

}; // class gsBasisFun


template<class T>
gsBasisFun<T>::gsBasisFun(const gsBasis<T> & basis, const unsigned i )
: m_basis(basis), m_index(i) 
{ 
    GISMO_ASSERT( i<unsigned(m_basis.size()),"Invalid basis function index" );
}

template<class T> void
gsBasisFun<T>::setFunction( unsigned const & i )
{
    GISMO_ASSERT( i<unsigned(m_basis.size()),"Invalid basis function index" );
    m_index = i;
}

template<class T> void
gsBasisFun<T>::first()
{
    m_index = 0;
}

template<class T> bool
gsBasisFun<T>::next()
{
    return ( ++m_index  < static_cast<unsigned>(m_basis.size()) );
}

template<class T> bool
gsBasisFun<T>::valid()
{
    return ( m_index  < static_cast<unsigned>(m_basis.size()) );
}

template<class T> gsMatrix<T>
gsBasisFun<T>::support()  const
{
    return m_basis.support(m_index);
}

template<class T> void
gsBasisFun<T>::eval_into(const gsMatrix<T>& u, gsMatrix<T>& result )  const
{
    m_basis.evalSingle_into(m_index, u, result);
}

template<class T> void
gsBasisFun<T>::deriv_into(const gsMatrix<T>& u, gsMatrix<T>& result )  const
{
    m_basis.derivSingle_into(m_index, u, result);
}

#ifdef GISMO_WITH_PYBIND11

  void pybind11_init_gsBasisFun(pybind11::module &m);

#endif // GISMO_WITH_PYBIND11

} // namespace gismo