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

}