gsDPatch.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsCore/gsBoxTopology.h>
#include <gsCore/gsMultiPatch.h>
#include <gsIO/gsOptionList.h>
#include <gsUnstructuredSplines/src/gsDPatchBase.h>
// #include <gsUnstructuredSplines/src/gsDPatchBase.hpp>
namespace gismo
{
 
 
template<short_t d,class T>
class gsDPatch : public gsDPatchBase<d,T>
{
 
typedef typename std::vector<std::tuple<index_t,index_t,T>> sparseEntry_t;
 
public:
    using Base = gsDPatchBase<d,T>;
 
    typedef memory::shared_ptr< gsDPatch > Ptr;
 
    typedef memory::unique_ptr< gsDPatch > uPtr;
 
    gsDPatch() : Base()
    { }
 
    // using Base::compute;
 
    gsDPatch(const gsMultiBasis<T> & mb) ;
 
 
    gsDPatch(const gsMultiPatch<T> & mp) ;
 
    // GISMO_CLONE_FUNCTION(gsDPatch)
 
    ~gsDPatch();
 
    void defaultOptions() override;
 
    // using Base::exportToPatches;
 
protected:
    gsMatrix<T> _preCoefficients(const gsMultiPatch<T> & patches) override;
    using Base::_preCoefficients;
 
    // using Base::exportPatch;
 
protected:
 
    // using Base::_indexFromSides;
 
    // using Base::_indicesFromVert;
 
    // using Base::_indexFromVert;
 
    // using Base::_vertexData;
 
    // using Base::_sideIndex;
 
    // using Base::_vertIndex;
 
    // using Base::_getLowestCorners;
 
    // using Base::_removeLowestCorners;
 
    // using Base::_getLowestIndices;
 
    // using Base::_removeLowestIndices;
 
    // using Base::_getInterfaceIndices;
 
    // using Base::_getAllInterfaceIndices;
 
protected:
 
    using Base::_performChecks;
    using Base::_resetChecks;
 
    void _countDoFs() override;
 
    // void _computeMapper(); // also initialize the mappers!
    using Base::_computeMapper;
 
    // void _computeSmoothMatrix();
    using Base::_computeSmoothMatrix;
 
    void _initTHB() override;
 
    void _refBoxes(std::vector<std::vector<index_t>> & patchBoxes);
 
    void _initBasis() override;
 
    void _makeTHB() override;
 
    void _computeEVs() override;
 
    gsMatrix<T> _makePi(index_t valence);
 
    using Base::getSharpCorners;
    using Base::_indexFromSides;
    using Base::_indexFromVert;
    using Base::_vertexData;
    using Base::_sideIndex;
    using Base::_vertIndex;
    using Base::_getLowestCorners;
    using Base::_removeLowestCorners;
    using Base::_getLowestIndices;
    using Base::_removeLowestIndices;
 
    using Base::_push;
    using Base::_pushAndCheck;
 
 
 
protected:
    // void _computeInterfaceMapper(boundaryInterface iface);
    using Base::_computeInterfaceMapper;
 
    // void _computeBoundaryMapper(patchSide boundary);
    using Base::_computeBoundaryMapper;
 
    void _computeVertexMapper(patchCorner pcorner) override;
 
 
private:
    // // Boundary vertex of valence 1
    // template<bool _boundary, index_t _v> // valence=2
    // typename std::enable_if<  _boundary && _v==1, void>::type
    // // SAME
    // _computeVertexMapperBoundary_v1(patchCorner pcorner, index_t valence);
 
    using Base::_computeMapperRegularCorner_v1;
 
    // // Boundary vertex of valence 2 with C1 smoothness
    // template<bool _boundary, index_t _v, bool _smooth> // valence=2
    // typename std::enable_if<  _boundary && _v==2 && _smooth, void>::type
    // // SAME
    // _computeVertexMapperBoundarySmooth_v2(patchCorner pcorner, index_t valence);
    using Base::_computeMapperRegularBoundaryVertexSmooth_v2;
 
    // // Boundary vertex of valence 2 with C0 smoothness
    // template<bool _boundary, index_t _v, bool _smooth> // valence=2
    // typename std::enable_if<  _boundary && _v==2 && (!_smooth), void>::type
    // // DIFFERENT
    // _computeVertexMapperBoundaryNonSmooth_v2(patchCorner pcorner, index_t valence);
    using Base::_computeMapperRegularBoundaryVertexNonSmooth_v2;
 
    // Boundary vertex of valence 3 with C1 smoothness
    // ONLY DPATCH
    void _computeMapperIrregularBoundaryVertexSmooth_v3(patchCorner pcorner, index_t valence);
 
    // Boundary vertex of valence 3 with C0 smoothness
    // template<bool _boundary, index_t _v, bool _smooth> // valence=2
    // typename std::enable_if<  _boundary && _v==3 && (!_smooth), void>::type
    // ONLY DPATCH
    void _computeMapperIrregularBoundaryVertexNonSmooth_v3(patchCorner pcorner, index_t valence);
 
    // Boundary vertex of valence !(1,2,3) with C1 smoothness
    // template<bool _boundary, index_t _v, bool _smooth>
    // typename std::enable_if<  _boundary && _v==-1 && _smooth, void>::type
    // DIFFERENT
    void _computeMapperIrregularBoundaryVertexSmooth_v(patchCorner pcorner, index_t valence) override;
 
    // Boundary vertex of valence !(1,2,3) with C0 smoothness
    // template<bool _boundary, index_t _v, bool _smooth>
    // typename std::enable_if<  _boundary && _v==-1 && (!_smooth), void>::type
    // DIFFERENT
    void _computeMapperIrregularBoundaryVertexNonSmooth_v(patchCorner pcorner, index_t valence) override;
 
    // // Interior vertex
    // template<bool _boundary, index_t _v>
    // typename std::enable_if<  (!_boundary) && _v==-1, void>::type
    // // DIFFERENT
    // _computeVertexMapperInterior_v(patchCorner pcorner, index_t valence);
    using Base::_computeMapperInteriorVertex_v;
 
protected:
 
    // void _handleVertex(patchCorner pcorner);
    // interior vertices
    // void _handleInteriorVertex(patchCorner pcorner, index_t valence);
 
    // void _handleInterface(boundaryInterface iface);
    // void _handleBoundary(patchSide side);
    // void _handleInterior();
private:
    // void _handleRegularCorner(patchCorner pcorner);
 
 
    // template<bool _regular, bool _smooth> // valence=2
    // typename std::enable_if<  _regular  &&   _smooth   , void>::type
    // _handleBoundaryVertex(patchCorner pcorner, index_t valence);
 
    // template<bool _regular, bool _smooth> // valence=2
    // typename std::enable_if<  _regular  && (!_smooth)   , void>::type
    // _handleBoundaryVertex(patchCorner pcorner, index_t valence);
 
    // template<bool _regular, bool _smooth> // valence > 2
    // typename std::enable_if<(!_regular) &&   _smooth    , void>::type
    // _handleBoundaryVertex(patchCorner pcorner, index_t valence);
 
    // template<bool _regular, bool _smooth> // valence > 1
    // typename std::enable_if<(!_regular) && (!_smooth)   , void>::type
    // _handleBoundaryVertex(patchCorner pcorner, index_t valence);
 
    // void _handleRegularBoundaryVertexSmooth(patchCorner pcorner, index_t valence);
 
    void _handleIrregularBoundaryVertexSmooth(patchCorner pcorner, index_t valence) override;
 
    void _handleIrregularBoundaryVertexNonSmooth(patchCorner pcorner, index_t valence) override;
 
protected:
    using Base::_whichHandled;
 
protected:
    using Base::m_computed;
    using Base::m_topology;
 
    using Base::m_bases;
    gsMultiBasis<T> m_bases0;
    using Base::m_Bbases;
    using Base::m_tMatrix;
    std::vector<gsSparseMatrix<T>> m_tMatrices;
    using Base::m_sideCheck;
    using Base::m_vertCheck;
    using Base::m_basisCheck;
    using Base::m_C0s;
 
    using Base::m_mapModified;
    using Base::m_mapOriginal;
 
    using Base::m_matrix;
 
    using Base::m_options;
 
    using Base::m_size;
 
    using Base::m_coefs;
 
    using Base::m_nSides;
    using Base::m_nVerts;
 
};
 
 
 
}
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsDPatch.hpp)
#endif