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