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