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