gsRemapInterface.h

Go to the documentation of this file.

#pragma once

#include <gsCore/gsAffineFunction.h>
#include <gsCore/gsBoundary.h>
#include <gsIO/gsOptionList.h>

namespace gismo {

template <class T>
class gsRemapInterface : public gsFunction<T>
{
public:

    typedef memory::shared_ptr< gsRemapInterface > Ptr;

    typedef memory::unique_ptr< gsRemapInterface > uPtr;

public:

    enum {
        neverAffine = -1,  
        alwaysAffine = 0   
    };

    gsRemapInterface(const gsMultiPatch<T>   & mp,
                     const gsMultiBasis<T>   & mb,
                     const boundaryInterface & bi,
                     const gsOptionList      & opt = defaultOptions() );

    static gsOptionList defaultOptions()
    {
        gsOptionList result;
        result.addInt ( "CheckAffine",             "The number of interior points (per direction) in point grid used to "
                                                   "check if the mapping is affine",                                      1     );
        result.addInt ( "NumSamplePoints",         "Number of sample points for computing fitting curve (if not affine)", 11    );
        result.addInt ( "IntervalsOfFittingCurve", "Number of knot space in the fitting curve (if not affine)",           5     );
        result.addInt ( "DegreeOfFittingCurve",    "Spline degree of fitting curve (if not affine)",                      3     );
        result.addReal( "EqualityTolerance",       "Points are considered equal iff difference is smaller",               1e-5  );
        result.addReal( "NewtonTolerance",         "Tolerance for Newton solvers",                                        1e-10 );
        return result;
    }

public:

    const typename gsFunction<T>::Ptr & interfaceMap() const { return m_intfMap; }

    virtual void eval_into(const gsMatrix<T> & u, gsMatrix<T> & result) const;

    virtual short_t domainDim() const { return m_g1->domainDim(); }

    typename gsDomainIterator<T>::uPtr makeDomainIterator() const;

    bool isMatching() const { return m_isMatching; }

    bool isAffine() const { return m_isAffine; }

    const std::vector< std::vector<T> > & breakPoints() const { return m_breakpoints; }

    virtual std::ostream & print(std::ostream& os) const;

private:

    void constructInterfaceBox();

    T estimateReparamError(index_t steps) const;

    void constructFittingCurve(index_t numSamplePoints, index_t intervalsOfFittingCurve,
            index_t degreeOfFittingCurve);

    void constructBreaks();

private:
    const gsGeometry<T> * m_g1;                       
    const gsGeometry<T> * m_g2;                       

    const gsBasis<T> * m_b1;                          
    const gsBasis<T> * m_b2;                          

    boundaryInterface m_bi;                           

    bool m_isMatching;                                
    bool m_isAffine;                                  

    std::vector< std::vector<T> > m_breakpoints;      

    typename gsFunction<T>::Ptr m_intfMap;            

    gsMatrix<T> m_parameterBounds1;

    gsMatrix<T> m_parameterBounds2;

    T m_equalityTolerance;                            
    T m_newtonTolerance;                              

}; // End gsRemapInterface

template <class T>
inline std::ostream & operator<<(std::ostream & os, const gsRemapInterface<T> & remapIf)
{ return remapIf.print(os); }

} // End namespace gismo

#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsRemapInterface.hpp)
#endif