gsMPBESHSplineBasis.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsUnstructuredSplines/src/gsMPBESBasis.h>
#include <gsUnstructuredSplines/src/gsMPBESMapHB2D.h>
#include <gsHSplines/gsHTensorBasis.h>
 
namespace gismo
{
 
template<short_t d, class T>
class gsMPBESHSplineBasis : public gsMPBESBasis<d,T>
{
public:
    typedef memory::shared_ptr< gsMPBESHSplineBasis > Ptr;
 
    typedef memory::unique_ptr< gsMPBESHSplineBasis > uPtr;
 
    static const index_t Dim = d;
 
    typedef index_t                                             indexType;
    typedef gsMPBESBasis<d,T>                                   Base;
    typedef gsHTensorBasis<d,T>                                 BasisType;
    typedef typename std::vector<BasisType *>                   BasisContainer;
    typedef typename std::vector<gsBasis<T>* >::const_iterator  ConstBasisIter;
 
protected:
    using Base::m_bases;
    using Base::m_topol;
    using Base::m_incrSmoothnessDegree;
    using Base::m_mapper;
    using Base::m_vertices;
    using Base::m_distances;
    using Base::m_minDist;
public:
    using Base::nPatches;
    using Base::updateTopol;
    using Base::degree;
    using Base::repairPatches;
    using Base::maxDegree;
protected:
    using Base::_getPatch;
    using Base::_getPatchIndex;
    using Base::_setDistanceOfAllVertices;
    using Base::_initVertices;
 
//TODO: gsCompactKnotVector to gsKnotVector,
//      shift knots by constant
//      read in of thb multipatch
//      compute topology of thb multipatch
 
public:
    gsMPBESHSplineBasis()
    { }
 
    gsMPBESHSplineBasis (std::vector<BasisType *> const & bases, gsBoxTopology const & topol,
                       index_t increaseSmoothnessLevel=-1, index_t minEVDistance=-1);
 
    gsMPBESHSplineBasis (std::vector<BasisType *> const & bases, gsBoxTopology const & topol,
                       std::vector<gsMatrix<T> * > & coefs,index_t increaseSmoothnessLevel=-1, index_t minEVDistance=-1);
 
    gsMPBESHSplineBasis (BasisType const & base, gsBoxTopology const & topol);
 
    gsMPBESHSplineBasis( gsMultiPatch<T> const & mp, index_t increaseSmoothnessLevel = -1,
                       index_t minEVDistance=-1);
 
    gsMPBESHSplineBasis( gsMultiBasis<T> const & mb,gsBoxTopology const & topol, index_t increaseSmoothnessLevel = -1,
                       index_t minEVDistance=-1);
 
    gsMPBESHSplineBasis( const gsMPBESHSplineBasis& other );
 
    gsMPBESHSplineBasis<d,T>& operator=( const gsMPBESHSplineBasis& other );
 
    ~gsMPBESHSplineBasis()
    { 
 
    } //destructor
 
private:
    // functions for initializing and updating
 
    bool _checkTopologyWithBases() const
    { return true; }
 
protected:
    void _setMapping();
 
 
public:
    // general functions for interacting with this class
 
    GISMO_CLONE_FUNCTION(gsMPBESHSplineBasis)
 
    gsHTensorBasis<d,T> & basis(size_t i)
    { return static_cast<gsHTensorBasis<d,T>&>(*m_bases[i]); }
 
    const gsHTensorBasis<d,T> & basis(size_t i) const 
    { return static_cast<const gsHTensorBasis<d,T>&>(*m_bases[i]); }
 
    unsigned basisFunctionsOnSide(const patchSide& ps) const;
 
    virtual bool isLocallyConnected(indexType i,indexType j) const;
 
public:
    // functions for evaluating and derivatives
 
    void numActive_into(const index_t patch,const gsMatrix<T> & u, gsVector<index_t>& result) const
    {
        GISMO_UNUSED(patch); GISMO_UNUSED(u); GISMO_UNUSED(result);
        GISMO_NO_IMPLEMENTATION
    }
 
public:
    // functions for refinement
 
    void refine(const index_t patch, gsMatrix<T> const & boxes, bool updateBasis = true);
 
    void refineElements(const index_t patch, std::vector<index_t> const & boxes, bool updateBasis = true);
 
    void refine_withCoefs(gsMatrix<T>& localCoef, const index_t patch, gsMatrix<T> const & boxes, bool updateBasis = true);
 
    void refineElements_withCoefs(gsMatrix<T>& localCoef, const index_t patch, std::vector<index_t> const & boxes, bool updateBasis = true);
 
    virtual void refineWithExtension(const index_t patch,gsMatrix<T> const & boxes, index_t refExt = 0,bool updateBasis = true);
 
//private:
    // private helper functions for the refinement
 
    void repairPatches(std::vector<gsMatrix<T> *> & coefs, index_t startFromPatch = -1);
 
    bool _innerBoxesAreSuitable(const index_t patch,
                                std::vector<index_t>& boxes);
 
    bool _boxesMatchNeighbours(const index_t patch,
                               std::vector<index_t>& boxes, std::vector<index_t>& checkPatches);
 
    void _addBoundaryBox(const index_t patch,const boxSide s,const index_t start, const index_t end,const unsigned level, std::vector<index_t> & boxes, std::vector<bool> & sideToCheck);
 
    void _addFunBox(const index_t patch,const unsigned uMin,const unsigned vMin,const unsigned uMax,const unsigned vMax,const unsigned level, std::vector<index_t> & boxes);
 
    void _addBox(const index_t patch,const unsigned uMin,const unsigned vMin,const unsigned uMax,const unsigned vMax,const unsigned level, std::vector<index_t> & boxes);
 
protected:
    // functions going back and forth between absolute val and parametric value for C^0 parts
 
    void _endpointsOfActiveBoundaryFunctions(patchSide const & ps,bool orient,std::vector<T>& endpoints) const;
 
    T findParameter(patchSide const & ps,patchCorner const & pc,unsigned nrBasisFuncs) const;
 
}; // class gsMPBESHSplineBasis
 
}