gsMPBESBasis.h

Go to the documentation of this file.

#pragma once

#include <gsUtils/gsMesh/gsMesh.h>
#include <gsMSplines/gsMappedBasis.h>

namespace gismo
{
template<short_t d, class T>
class gsMPBESBasis : public gsMappedBasis<d,T>
{
private:
    static const short_t Dim = d;

    typedef T weightType;
    typedef index_t indexType; //indizes of gsMatrix
    typedef std::vector<std::pair<index_t,index_t> >::iterator step_iter;
    typedef gsBasis<T> BasisType;
    typedef typename std::vector<BasisType *>::const_iterator ConstBasisIter;
    typedef typename std::vector<BasisType *>::iterator BasisIter;
    typedef typename std::vector<gsMatrix<T> *>::const_iterator ConstMatrixPtrIter;
    typedef typename gsSparseMatrix<weightType,0,indexType>::InnerIterator InIterMat;
    typedef typename std::vector<indexType> IndexContainer;
    typedef typename std::vector<indexType>::const_iterator ConstIndexIter;
    typedef typename std::vector<weightType> WeightContainer;
    typedef typename std::vector<weightType>::const_iterator ConstWeightIter;

    typedef memory::unique_ptr< gsDomainIterator<T> > domainIter;

protected:
    using gsMappedBasis<d,T>::m_mapper;
    using gsMappedBasis<d,T>::m_topol;
    using gsMappedBasis<d,T>::m_bases;
public:
    typedef memory::shared_ptr< gsMPBESBasis > Ptr;

    typedef memory::unique_ptr< gsMPBESBasis > uPtr;

    using gsMappedBasis<d,T>::size;
    using gsMappedBasis<d,T>::degree;
    using gsMappedBasis<d,T>::nPatches;

public:
    gsMPBESBasis() : gsMappedBasis<d,T>()
    {
//        m_mapper = NULL;
    }

    virtual ~gsMPBESBasis()
    {

    } //destructor

public:
    // functions for initializing and updating

    void updateTopol()
    {
        //_setDistanceOfAllVertices(0);
        _setMapping();
    }

protected:

    BasisType* getBasePointer(index_t i)
    { return m_bases[i]; }

    virtual void _setMapping() = 0;

    void _initVertices();

    void _setDistanceOfAllVertices();

    bool _check() const;

    virtual bool _checkTopologyWithBases() const = 0;

public:
    // general functions for interacting with this class

    short_t dim() const { return Dim; }

    GISMO_UPTR_FUNCTION_PURE(gsMPBESBasis, clone)

    
    std::string detail() const
    {
        // By default just uses print(..)
        std::ostringstream os;
        print(os);
        return os.str();
    }

    std::ostream & print(std::ostream & os) const
    { os << m_mapper->asMatrix().toDense() <<"\n"; return os; }

    virtual unsigned basisFunctionsOnSide(const patchSide& ps) const = 0;

    // Look at gsBasis class for a description
    void connectivity(const gsMatrix<T> & nodes,gsMesh<T> & mesh) const;

    bool isConnected(indexType i,indexType j) const;

    virtual bool isLocallyConnected(indexType i,indexType j) const = 0;

public:
    // getters for the private fields

    index_t getIncrSmoothnessDegree() const
    { return m_incrSmoothnessDegree; }

    unsigned getMinDist() const
    { return m_minDist; }

public:
    // functions for refinement

    void uniformRefine(index_t numKnots = 1, index_t mul=1,bool updateBasis = true);

    void uniformRefine_withCoefs(gsMatrix<T>& localCoefs, index_t numKnots = 1, index_t mul=1,
                                 bool updateBasis = true);

    virtual void refine(const index_t patch, gsMatrix<T> const & boxes, bool updateBasis = true) = 0;

    virtual void refineElements(const index_t patch, std::vector<index_t> const & boxes, bool updateBasis = true) = 0;

    virtual void refine_withCoefs(gsMatrix<T>& localCoefs, const index_t patch, gsMatrix<T> const & boxes,
                                  bool updateBasis = true) = 0;

    virtual void refineElements_withCoefs(gsMatrix<T>& localCoefs, const index_t patch, std::vector<index_t> const & boxes,
                                  bool updateBasis = true) = 0;

    void degreeElevate( index_t amount = 1 , bool updateBasis = true);

    void degreeIncrease( index_t amount = 1, index_t dir=-1, bool updateBasis = true);

    virtual void repairPatches(std::vector<gsMatrix<T> *> & coefs,
                               index_t startFromPatch = -1) = 0;

    void repairPatches(gsMatrix<T> & localCoef, index_t startFromPatch=-1);

    void repairPatches(index_t startFromPatch = -1);

public:
    // functions for smoothing the basis

    void smoothCornerEdge(const patchCorner&pc,const patchSide& ps,bool updateBasis = true);

    void smoothEverything();

public:
    // functions for working with weights on interfaces

    T getWeight(const patchSide & ps) const;

    bool setWeight(const patchSide & ps, const T weight);

public:
    // functions for working with special vertices and it's C^0 distance

    void setC0(patchCorner pc);

    bool isSpecialVertex(const patchCorner & pc) const;

    T getParametricDistanceOfVertex(const patchCorner& pc,const patchSide& ps) const;

protected:
    virtual T findParameter(patchSide const & ps,patchCorner const & pc,unsigned nrBasisFuncs) const = 0;

private:
    // struct for distances from special vertices

    struct distances
    {
        boundaryInterface interface;
        patchCorner corner1;
        T parametricDistance1;
        patchCorner corner2;
        T parametricDistance2;

        distances(const boundaryInterface&  iface, const patchCorner& pc1,
                  const patchCorner& pc2,const gsMPBESBasis<d,T>& basis);

        bool isDistancesOfInterface(const boundaryInterface& bi) const
        {
            return (interface==bi) || (interface.getInverse()==bi);
        }

        void setParamDist(unsigned absoluteVal,const patchCorner& pc,const gsMPBESBasis<d,T>& basis);

        T getParamDist(const patchCorner& pc,const gsMPBESBasis<d,T>& basis) const;

        void _determineValues(patchSide side,patchSide ls,patchSide rs,index_t dist,unsigned degree,unsigned max,
                              unsigned& left,unsigned& right,const gsMPBESBasis<d,T>& basis) const;
    };

    // Data members
protected:
    short_t m_incrSmoothnessDegree;
    unsigned m_minDist;
    std::vector<std::pair<patchSide,T> > m_patchSideWeights;
    std::vector<std::pair<patchCorner,bool> > m_vertices; //true = EV, false = OV
    std::vector<distances> m_distances;
}; // class gsMappedBasis

}



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