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