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(); }
    
    std::map<std::array<size_t, 4>, internal::ElementBlock> BezierOperator() const;
 
// 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