gsApproxC1Edge.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsUnstructuredSplines/src/gsContainerBasis.h>
#include <gsUnstructuredSplines/src/gsPatchReparameterized.h>
 
#include <gsUnstructuredSplines/src/gsApproxC1GluingData.h>
 
#include <gsUnstructuredSplines/src/gsApproxC1Utils.h>
 
namespace gismo
{
 
 
template<short_t d, class T>
class gsApproxC1Edge
{
 
private:
    typedef gsContainerBasis<d, T> Basis;
    typedef typename std::vector<Basis> BasisContainer;
    typedef typename std::vector<gsPatchReparameterized<d,T>> C1AuxPatchContainer;
 
    typedef memory::shared_ptr<gsApproxC1Edge> Ptr;
 
    typedef memory::unique_ptr<gsApproxC1Edge> uPtr;
 
 
public:
    ~gsApproxC1Edge() { }
 
 
    gsApproxC1Edge(gsMultiPatch<T> const & mp,
                   BasisContainer & bases,
                const boundaryInterface & item,
                size_t & numInt,
                const gsOptionList & optionList)
                : m_mp(mp), m_bases(bases), m_optionList(optionList)
    {
        GISMO_UNUSED(numInt);
 
        m_auxPatches.clear();
        m_auxPatches.push_back(gsPatchReparameterized<d,T>(m_mp.patch(item.first().patch), m_bases[item.first().patch]));
        m_auxPatches.push_back(gsPatchReparameterized<d,T>(m_mp.patch(item.second().patch), m_bases[item.second().patch]));
 
        std::vector<patchSide> sidesContainer(2);
        sidesContainer[0] = item.first();
        sidesContainer[1] = item.second();
 
        reparametrizeInterfacePatches(sidesContainer);
 
        compute(sidesContainer);
/*
        if (m_optionList.getSwitch("plot"))
        {
            std::string fileName;
            std::string basename = "InterfaceBasisFunctions" + util::to_string(numInt);
            gsParaviewCollection collection(basename);
 
            for (size_t i = 0; i< basisEdgeResult[0].nPatches(); i++)
            {
                // First Interface Side
                fileName = basename + "_0_" + util::to_string(i);
                gsField<T> temp_field(m_mp.patch(item.first().patch), basisEdgeResult[0].patch(i));
                gsWriteParaview(temp_field, fileName, 5000);
                collection.addTimestep(fileName, i, "0.vts");
                // Second Interface Side
                fileName = basename + "_1_" + util::to_string(i);
                gsField<T> temp_field_1(m_mp.patch(item.second().patch), basisEdgeResult[1].patch(i));
                gsWriteParaview(temp_field_1, fileName, 5000);
                collection.addTimestep(fileName, i, "0.vts");
            }
            collection.save();
 
            //gsWriteParaview(basisEdgeResult[0], "interface_basis", 20000);
        }
*/
    }
 
    gsApproxC1Edge(gsMultiPatch<T> const & mp,
                   BasisContainer & bases,
                const patchSide & item,
                size_t & numBdy,
                const gsOptionList & optionList)
                : m_mp(mp), m_bases(bases), m_optionList(optionList)
    {
        GISMO_UNUSED(numBdy);
 
        m_auxPatches.clear();
        m_auxPatches.push_back(gsPatchReparameterized<d,T>(m_mp.patch(item.patch), m_bases[item.patch]));
 
        std::vector<patchSide> sidesContainer(1);
        sidesContainer[0] = item;
 
        reparametrizeSinglePatch(item.side().index());
 
        compute(sidesContainer);
/*
        if (m_optionList.getSwitch("plot")) {
            std::string fileName;
            std::string basename = "BoundaryBasisFunctions" + util::to_string(numBdy);
            gsParaviewCollection collection(basename);
 
            for (size_t i = 0; i < basisEdgeResult[0].nPatches(); i++) {
                // First Interface Side
                fileName = basename + "_0_" + util::to_string(i);
                gsField<T> temp_field(m_mp.patch(item.patch), basisEdgeResult[0].patch(i));
                gsWriteParaview(temp_field, fileName, 5000);
                collection.newTimeStep(fileName, i, "0.vts");
            }
            collection.save();
        }
*/
    }
 
    std::vector<gsMultiPatch<T>> getEdgeBasis() { return basisEdgeResult; };
 
protected:
 
    // Input
    gsMultiPatch<T> const & m_mp;
    BasisContainer & m_bases;
 
    const gsOptionList & m_optionList;
 
    // Need for rotation, etc.
    C1AuxPatchContainer m_auxPatches;
 
    // Store temp solution
    std::vector<gsMultiPatch<T>> basisEdgeResult;
 
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 reparametrizeInterfacePatches(std::vector<patchSide> & sidesContainer);
 
    void reparametrizeSinglePatch(index_t side);
 
    void compute(std::vector<patchSide> & sidesContainer);
 
}; // Class gsApproxC1Edge
 
} // namespace gismo
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsApproxC1Edge.hpp)
#endif