gsC1SurfEdge.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsUnstructuredSplines/src/gsG1AuxiliaryPatch.h>
#include <gsUnstructuredSplines/src/gsC1SurfBasisEdge.h>
 
#include <gsUnstructuredSplines/src/gsC1SurfGluingData.h>
 
namespace gismo
{
template<short_t d, class T>
class gsC1SurfEdge
{
 
private:
 
    typedef memory::shared_ptr<gsC1SurfEdge> Ptr;
 
    typedef memory::unique_ptr<gsC1SurfEdge> uPtr;
 
 
public:
    ~gsC1SurfEdge() { }
 
    gsC1SurfEdge(const gsMultiPatch<T> & mp, const boundaryInterface & item){
        auxGeom.push_back(gsG1AuxiliaryPatch<d,T>(mp.patch(item.first().patch), item.first().patch));
        auxGeom.push_back(gsG1AuxiliaryPatch<d,T>(mp.patch(item.second().patch), item.second().patch));
        m_item = item;
    }
 
    gsC1SurfEdge(const gsMultiPatch<T> & sp, const patchSide & item){
        auxGeom.push_back(gsG1AuxiliaryPatch<d,T>(sp.patch(item.patch), item.patch));
    }
 
    void computeG1InterfaceBasis()
    {
        basisEdgeResult.clear();
 
        gsMultiPatch<T> mp_init;
        mp_init.addPatch(auxGeom[0].getPatch());// Right -> 0 ====> v along the interface
        mp_init.addPatch(auxGeom[1].getPatch()); // Left -> 1 ====> u along the interface
 
        reparametrizeInterface(m_item);
        gsMultiPatch<T> test_mp; // auxGeom contains now the reparametrized geometry
        test_mp.addPatch(auxGeom[0].getPatch());
        test_mp.addPatch(auxGeom[1].getPatch());
        gsMultiBasis<T> test_mb(test_mp);
        gsMultiPatch<T> g1Basis_0, g1Basis_1;
 
        gsC1SurfGluingData<T> g1BasisEdge(test_mp, test_mb);
        gsC1SurfBasisEdge<T> g1BasisEdge_0(test_mp.patch(0), test_mb.basis(0), 1, false, g1BasisEdge);
        gsC1SurfBasisEdge<T> g1BasisEdge_1(test_mp.patch(1), test_mb.basis(1), 0, false, g1BasisEdge);
        g1BasisEdge_0.setG1BasisEdge(g1Basis_0);
        g1BasisEdge_1.setG1BasisEdge(g1Basis_1);
 
        gsMatrix<T> points(1,5);
        points << 0.0, 0.25, 0.5, 0.75, 1.0;
        gsMatrix<T> alphaL = g1BasisEdge.evalAlpha_L(points);
        gsMatrix<T> alphaR = g1BasisEdge.evalAlpha_R(points);
        gsMatrix<T> betaL = g1BasisEdge.evalBeta_L(points);
        gsMatrix<T> betaR = g1BasisEdge.evalBeta_R(points);
        gsMatrix<T> beta = g1BasisEdge.evalBeta(points);
 
//      Patch 0 -> Right
        auxGeom[0].parametrizeBasisBack(g1Basis_0);
//      Patch 1 -> Left
        auxGeom[1].parametrizeBasisBack(g1Basis_1);
 
        basisEdgeResult.push_back(auxGeom[0].getG1Basis());
        basisEdgeResult.push_back(auxGeom[1].getG1Basis());
    }
 
    void computeG1BoundaryBasis(const index_t boundaryInd)
    {
        basisEdgeResult.clear();
 
        reparametrizeBoundary(boundaryInd);
        gsMultiPatch<T> test_mp(auxGeom[0].getPatch());
        gsMultiBasis<T> test_mb(test_mp);
        gsMultiPatch<T> g1Basis_edge;
 
        gsC1SurfGluingData<T> bdyGD; // Empty constructor creates the sol and solBeta in a suitable way to manage the GD on the boundary
        gsC1SurfBasisEdge<T> g1BasisEdge(test_mp, test_mb, 1, true, bdyGD);
        g1BasisEdge.setG1BasisEdge(g1Basis_edge);
 
        auxGeom[0].parametrizeBasisBack(g1Basis_edge);
 
        basisEdgeResult.push_back(auxGeom[0].getG1Basis());
    }
 
    gsG1AuxiliaryPatch<d,T> & getSinglePatch(const index_t i)
    {
        return auxGeom[i];
    }
 
    std::vector<gsMultiPatch<T>> getBasis(){return basisEdgeResult;}
 
protected:
 
    // Store temp solution
    std::vector<gsMultiPatch<T>> basisEdgeResult;
 
    std::vector<gsG1AuxiliaryPatch<d,T>> auxGeom;
 
    // Need for avoiding the computeTopology
    boundaryInterface m_item;
 
private:
 
    // Compute topology
    // After computeTopology() the patches will have the same patch-index as the position-index in auxGeom
    // EXAMPLE: global patch-index-order inside auxGeom: [2, 3, 4, 1, 0]
    //          in auxTop: 2->0, 3->1, 4->2, 1->3, 0->4
    void computeAuxTopology();
 
    void reparametrizeInterface(const boundaryInterface & item);
 
    void reparametrizeBoundary(index_t side);
 
 
}; // Class gsC1SurfEdge
 
} // namespace gismo
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsC1SurfEdge.hpp)
#endif