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