gsAlmostC1.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 gsAlmostC1 : public gsDPatchBase<d,T>
{
protected:
 
typedef typename std::vector<std::tuple<index_t,index_t,T>> sparseEntry_t;
 
public:
 
    using Base = gsDPatchBase<d,T>;
 
 
    typedef memory::shared_ptr< gsAlmostC1 > Ptr;
 
    typedef memory::unique_ptr< gsAlmostC1 > uPtr;
 
    gsAlmostC1()
    :
    Base()
    {
    }
 
    // using Base::compute;
    // void compute();
 
    gsAlmostC1(gsMultiPatch<T> const & mp) ;
 
    // GISMO_CLONE_FUNCTION(gsAlmostC1)
 
    ~gsAlmostC1();
 
    using Base::defaultOptions;
 
    using Base::exportToPatches;
 
protected:
    gsMatrix<T> _preCoefficients();
    gsMatrix<T> _preCoefficients(const gsMultiPatch<T> & patches)
    {
        GISMO_UNUSED(patches);
        return _preCoefficients();
    }
 
    gsMatrix<T> freeCoefficients();
 
    void setCoefficients(const gsMatrix<T> & coefs, gsMultiPatch<T> & mp) const;
 
 
    // gsGeometry<T>* exportPatch(index_t patch, bool computeCoefs=true);
    using Base::exportPatch;
 
    // gsMultiPatch<T> exportToPatches();
    // using Base::exportPatch;
 
    // const void matrix_into(gsSparseMatrix<T> & matrix) const
    // { matrix = m_matrix; }
 
    // const gsSparseMatrix<T> matrix() const
    // {
    //     gsSparseMatrix<T> result; matrix_into(result);
    //     return result;
    // }
 
protected:
 
    using Base::getSharpCorners;
 
    gsMatrix<T> _getNormals(const std::vector<patchCorner> & corners) const;
 
    std::tuple<gsMatrix<T>,gsMatrix<T>,gsMatrix<index_t>> _makeTriangle(const patchCorner & corner) const;
 
    gsMatrix<T,3,3> _getRotationMatrix(const gsVector<T,3> & a, const gsVector<T,3> & b) const;
 
    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::_getInterfaceIndices;
    using Base::_getAllInterfaceIndices;
 
protected:
 
    void _countDoFs();
 
    // void _computeMapper(); // also initialize the mappers!
    using Base::_computeMapper;
 
    // void _computeSmoothMatrix();
    using Base::_computeSmoothMatrix;
 
    void _initBasis();
 
    void _initTHB();
 
    void _refBoxes(std::vector<std::vector<index_t>> & patchBoxes);
 
    void _makeTHB();
 
    void _computeEVs();
 
protected:
 
    std::vector<std::vector<patchCorner> > _getSpecialCornerLists(const gsMultiPatch<T> & patches);
 
    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);
 
 
private:
    // // Boundary vertex of valence 1
    // template<bool _boundary, index_t _v> // valence=2
    // typename std::enable_if<  _boundary && _v==1, void>::type
    // _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
    // _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
    void _computeMapperRegularBoundaryVertexNonSmooth_v2(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
    void _computeMapperIrregularBoundaryVertexSmooth_v(patchCorner pcorner, index_t valence);
 
    // 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
    // void _computeVertexMapperBoundaryNonSmooth_v(patchCorner pcorner, index_t valence);
    using Base::_computeMapperIrregularBoundaryVertexNonSmooth_v;
 
    // Ordinary interior vertex
    // template<bool _boundary, index_t _v> // valence=2
    // typename std::enable_if<  (!_boundary) && _v==4, void>::type
    void _computeMapperInteriorVertex_v4(patchCorner pcorner, index_t valence);
 
    // Extraordinary interior vertex
    // template<bool _boundary, index_t _v>
    // typename std::enable_if<  (!_boundary) && _v==-1, void>::type
    void _computeMapperInteriorVertex_v(patchCorner pcorner, index_t valence);
 
 
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 _handleRegularBoundaryVertexNonSmooth(patchCorner pcorner, index_t valence);
 
    void _handleIrregularBoundaryVertexSmooth(patchCorner pcorner, index_t valence);
 
    void _handleIrregularBoundaryVertexNonSmooth(patchCorner pcorner, index_t valence);
 
protected:
    using Base::_whichHandled;
 
protected:
    using Base::m_patches;
    gsMultiPatch<T> m_RefPatches;
    using Base::m_bases;
    using Base::m_topology;
 
    using Base::m_Bbases;
    using Base::m_tMatrix;
    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(gsAlmostC1.hpp)
#endif