gsPeriodicOverlap.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsIO/gsOptionList.h>
#include "gsPeriodicParametrization.h"
 
namespace gismo
{
 
template <class T>
class GISMO_EXPORT gsPeriodicOverlap : public gsPeriodicParametrization<T>
{
    typedef typename gsParametrization<T>::Neighbourhood Neighbourhood;
    typedef typename gsMesh<T>::gsVertexHandle   gsVertexHandle;
 
public:
    typedef memory::shared_ptr<gsPeriodicOverlap<T> > uPtr;
 
public:
    explicit gsPeriodicOverlap(const gsMesh<T> &mesh,
                               const gsMatrix<T>& verticesV0,
                               const gsMatrix<T>& paramsV0,
                               const gsMatrix<T>& verticesV1,
                               const gsMatrix<T>& paramsV1,
                               const gsMesh<T>& overlap,
                               const gsOptionList &list = gsPeriodicParametrization<T>::defaultOptions())
        : gsPeriodicParametrization<T>(mesh, verticesV0, paramsV0, verticesV1, paramsV1, list),
        m_overlapHEM(overlap)
    {
        // Note: m_twins gets constructed later on.
        // Note: One could also write another constructor accepting gsHalfEdgeMesh as overlap.
    }
 
    void compute();
 
protected:
    void calculate(const size_t paraMethod);
 
    size_t findTwin(size_t vertexId) const
    {
        return this->m_mesh.getVertexIndex(m_overlapHEM.getVertexUnsorted(vertexId));
    }
 
    void constructTwinsBetween(size_t& currentNrAllVertices,
                               std::list<size_t> vertexIndices,
                               size_t from, size_t to, bool rightHandSide);
 
    void constructTwinsBetween(size_t& currentNrAllVertices,
                               std::list<size_t> vertexIndices,
                               gsVertexHandle from,
                               gsVertexHandle to,
                               bool rightHandSide)
    {
        return constructTwinsBetween(currentNrAllVertices,
                                     vertexIndices,
                                     m_overlapHEM.findVertex(from),
                                     m_overlapHEM.findVertex(to),
                                     rightHandSide);
    }
 
    void constructTwins();
 
    void constructAndSolveEquationSystem(const Neighbourhood &neighbourhood,
                                         const size_t n,
                                         const size_t N);
 
    void updateLambdasWithTwins(std::vector<T>& lambdas,
                                size_t vertexId) const;
 
    // From here on the visualisation functions.
public:
    gsMesh<T> createFlatMesh() const;
 
protected:
    gsMesh<T> createExtendedFlatMesh(const std::vector<size_t>& right,
                                     const std::vector<size_t>& left) const;
 
 
protected: // members
 
    std::vector<std::pair<size_t, size_t> > m_twins; 
    const gsHalfEdgeMesh<T> m_overlapHEM; 
};
 
} // namespace gismo
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsPeriodicOverlap.hpp)
#endif