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