gsMappedSingleSpline.h

Go to the documentation of this file.

#pragma once

#include <gsCore/gsGeometry.h>
#include <gsMSplines/gsMappedSpline.h>
#include <gsMSplines/gsMappedSingleBasis.h>

namespace gismo
{

template<short_t d,class T> class gsMappedSpline;

template<short_t d,class T>
class gsMappedSingleSpline : public gsFunction<T>
{
private:
    typedef gsFunction<T> Base;

    typedef gsMappedSingleBasis<d,T> Basis;

public:
    typedef memory::shared_ptr< gsMappedSingleSpline > Ptr;

    typedef memory::unique_ptr< gsMappedSingleSpline > uPtr;

private:
    gsMappedSingleSpline() : m_spline(nullptr) { }

public:

    gsMappedSingleSpline(gsMappedSpline<d,T> * spline, unsigned const & i = 0)
    : m_spline(spline),m_index(i)
    {
        GISMO_ASSERT( i<unsigned(m_spline->nPatches()),"Invalid spline function index" );
    }

    gsMappedSingleSpline( const gsMappedSingleSpline& other ) : Base( other )
    {
        m_spline = other.m_spline;
        m_index = other.m_index;
    }

    static uPtr make(   const gsMappedSingleSpline& other)
    { return uPtr( new gsMappedSingleSpline( other ) ); }

    ~gsMappedSingleSpline() { } //destructor

    GISMO_BASIS_ACCESSORS

public:

    short_t domainDim() const
    {
        return d;
    }

    short_t targetDim() const
    { return m_spline->m_global.cols(); }

    void eval_into(const gsMatrix<T> & u, gsMatrix<T>& result) const
    {
        // m_spline->evalGlobal_into(m_index,u,result);
        m_spline->eval_into(m_index,u,result);
    }

    void deriv_into(const gsMatrix<T> & u, gsMatrix<T>& result ) const
    {
        m_spline->deriv_into(m_index,u,result);
    }

    void deriv2_into(const gsMatrix<T> & u, gsMatrix<T>& result ) const
    {
        m_spline->deriv2_into(m_index,u,result);
    }

    void evalAllDers_into(const gsMatrix<T> & u, int n, std::vector<gsMatrix<T> >& result,
                          bool sameElement = false) const
    {
        m_spline->evalAllDers_into(m_index,u,n,result,sameElement);
    }

    // support (domain of definition)
    gsMatrix<T> support() const
    { return m_spline->supportOf(m_index); }


    GISMO_CLONE_FUNCTION(gsMappedSingleSpline)

    std::ostream &print(std::ostream &os) const
    {
        GISMO_UNUSED(os);
        GISMO_NO_IMPLEMENTATION;
    }

    // Virtual member that may be implemented or not by the derived class

    short_t degree(short_t i) const
    {
        return m_spline->degree(m_index,i);
    }
  
    void setPiece( unsigned const & i )
    {
        GISMO_ASSERT( i<unsigned(m_spline->nPatches()),"Invalid spline index" );
        m_index = i;
    }

    void setSource(gsMappedSpline<d,T> & s)
    { m_spline = &s; }

// Data members
private:
    gsMappedSpline<d,T> * m_spline;
    mutable index_t m_index;

}; // class gsMappedSingleSpline


} // namespace gismo