gsMappedSpline.h

Go to the documentation of this file.

#pragma once
#include <gsCore/gsGeometry.h>
#include <gsCore/gsMultiPatch.h>
#include <gsMSplines/gsMappedSingleSpline.h>
#include <gsMSplines/gsMappedSingleBasis.h>
#include <gsMSplines/gsMappedBasis.h>
#include <gsCore/gsDomainIterator.h>

namespace gismo
{

// forward declarations of the mapper classes
template<short_t d,class T> class gsMappedSingleSpline;

template<short_t d,class T>
class gsMappedSpline : public gsFunctionSet<T>
{
    friend class gsMappedSingleSpline<d,T>;

private:
    typedef typename gsGeoTraits<d,T>::GeometryBase GeoType;
    typedef gsBasis<T> BasisType;

    typedef memory::shared_ptr< gsMappedSpline > Ptr;

    typedef memory::unique_ptr< gsMappedSpline > uPtr;

public:
    gsMappedSpline() : m_mbases(nullptr) { }

    gsMappedSpline( const gsMultiPatch<T> & mp, const gsSparseMatrix<T> & m );

    gsMappedSpline( const gsMappedBasis<d,T> & mbases, const gsMatrix<T> & coefs );

    gsMappedSpline( const gsMappedSpline& other );

    gsMappedSpline<d,T> & operator=( const gsMappedSpline& other );

    ~gsMappedSpline()
    { delete m_mbases; } //destructor

    void init(const gsMappedBasis<d,T> & mbasis)
    {
        GISMO_ASSERT(mbasis.domainDim()==d, "Error in dimensions");

        m_ss.clear();
        m_ss.reserve(mbasis.nPieces());
        for ( index_t k=0; k!=mbasis.nPieces(); k++ )
        {
            m_ss.push_back( gsMappedSingleSpline<d,T>(this,k) );
        }
    }

    void init(const gsMappedBasis<d,T> & mbasis, const gsMatrix<T> & coefs)
    {
        GISMO_ASSERT(mbasis.domainDim()==d, "Error in dimensions");

        m_global.clear();
        m_global = coefs;

        m_mbases=mbasis.clone().release();

        m_ss.clear();
        m_ss.reserve(mbasis.nPieces());
        for ( index_t k=0; k!=mbasis.nPieces(); k++ )
        {
            m_ss.push_back( gsMappedSingleSpline<d,T>(this,k) );
        }
    }

    void init(const gsMultiPatch<T> & mp, const gsSparseMatrix<T> & m )
    {
        GISMO_ASSERT(mp.nPatches()>0,"MultiPatch is empty?");
        m_mbases = new gsMappedBasis<d,T>(gsMultiBasis<T>(mp),m);

        // collect and transform the coefficients
        gsMatrix<T> local = mp.coefs();
        m_mbases->local_coef_to_global_coef(local,m_global);
        init(*m_mbases);
    }


public:

    index_t nPieces() const {return m_mbases->nPieces();}

    BasisType const & getBase(int i) const
    { return m_mbases->getBase(i); }

    BasisType & getBase(int i)
    { return m_mbases->getBase(i); }

    const std::vector<BasisType*> getBases() const
    { return m_mbases->getBases(); }

    gsWeightMapper<T> const & getMapper() const
    { return m_mbases->getMapper(); }

    gsWeightMapper<T> * getMapPointer() const
    { return m_mbases->getMapPointer(); }

    gsBoxTopology const & getTopol() const
    { return m_mbases->getTopol(); }

// Virtual base members with a new implementation

// Virtual member functions required by the base class

    GISMO_CLONE_FUNCTION(gsMappedSpline)

    short_t domainDim() const
    { return m_mbases->domainDim(); }

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

    size_t nPatches() const
    { return m_mbases->nPatches(); }

    const gsMappedSingleSpline<d,T> & piece(const index_t k) const { return m_ss[k]; }

    index_t size() const {return nPieces();}

    std::ostream &print(std::ostream &os) const
    { return m_mbases->print(os); }

    const gsMappedBasis<d,T> & getMappedBasis() const
    { return *m_mbases; }

    const gsMatrix<T> & getMappedCoefs() const
    { return m_global; }

    gsMappedBasis<d,T> & getMappedBasis()
    { return *m_mbases; }

    gsMultiPatch<T> exportToPatches() const;

    // support (domain of definition)
    gsMatrix<T> supportOf(const index_t & k) const
    { return m_mbases->getBase(k).support(); }

    gsGeometry<T> * exportPatch(int i,gsMatrix<T> const & localCoef) const;

private:
    // Avoid warnings for hidden overloads w.r.t gsFunctionSet
    void active_into(const gsMatrix<T> &,gsMatrix<index_t>&) const
    { GISMO_NO_IMPLEMENTATION; }
    void eval_into(const gsMatrix<T> &,gsMatrix<T>&) const
    { GISMO_NO_IMPLEMENTATION; }
    void deriv_into(const gsMatrix<T> &,gsMatrix<T>&) const
    { GISMO_NO_IMPLEMENTATION; }
    void deriv2_into(const gsMatrix<T> &,gsMatrix<T>&) const
    { GISMO_NO_IMPLEMENTATION; }
    void evalAllDers_into(const gsMatrix<T> &, int,
                          std::vector<gsMatrix<T> >&, bool) const
    { GISMO_NO_IMPLEMENTATION; }

public:
    // functions for evaluating and derivatives

    void eval_into(const unsigned patch, const gsMatrix<T> & u, gsMatrix<T>& result ) const;
    void deriv_into(const unsigned patch, const gsMatrix<T> & u, gsMatrix<T>& result ) const;
    void deriv2_into(const unsigned patch, const gsMatrix<T> & u, gsMatrix<T>& result ) const;

    void evalAllDers_into(const unsigned patch, const gsMatrix<T> & u,
                          const int n, std::vector<gsMatrix<T> >& result,
                          bool sameElement = false) const;



// Data members
protected:
    gsMappedBasis<d,T> * m_mbases;
    gsMatrix<T> m_global;
    std::vector<gsMappedSingleSpline<d,T> > m_ss;

}; // class gsMappedSpline

} // namespace gismo

#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsMappedSpline.hpp)
#endif