DelaunayInterpolation.h

Go to the documentation of this file.

#ifndef included_AMP_DelaunayInterpolation
#define included_AMP_DelaunayInterpolation
 
#include <stdlib.h>
#include <tuple>
 
#include "AMP/utils/Array.h"
#include "AMP/utils/kdtree.h"
 
 
namespace AMP {
 
 
template<class TYPE>
class DelaunayInterpolation
{
public:
    DelaunayInterpolation();
 
    // Deleted constructors
    DelaunayInterpolation( const DelaunayInterpolation & ) = delete;
    DelaunayInterpolation &operator=( const DelaunayInterpolation & ) = delete;
 
    ~DelaunayInterpolation();
 
 
 
    size_t get_N_tri() const;
 
 
    AMP::Array<int> get_tri() const;
 
 
    AMP::Array<int> get_tri_nab() const;
 
 
 
    void create_tessellation( const AMP::Array<TYPE> &x );
 
 
 
    void create_tessellation( size_t N, const TYPE *x, const TYPE *y, const TYPE *z );
 
 
 
    void create_tessellation( const Array<TYPE> &x, const Array<int> &tri );
 
 
 
    std::tuple<AMP::Array<TYPE>, AMP::Array<int>> copy_tessellation() const;
 
 
 
    template<class TYPE2>
    Array<size_t> find_nearest( const Array<TYPE2> &xi ) const;
 
 
 
    template<class TYPE2>
    Array<int> find_tri( const Array<TYPE2> &xi, bool extrap = false ) const;
 
 
 
    void calc_node_gradient( const double *f,
                             const int method,
                             double *grad,
                             const int n_it = 20 ) const;
 
 
 
    template<class TYPE2>
    Array<double> interp_nearest( const Array<double> &f,
                                  const Array<TYPE2> &xi,
                                  const Array<size_t> &nearest ) const;
 
 
 
    template<class TYPE2>
    std::tuple<AMP::Array<double>, AMP::Array<double>> interp_linear( const AMP::Array<double> &f,
                                                                      const AMP::Array<TYPE2> &xi,
                                                                      const AMP::Array<int> &index,
                                                                      bool extrap = false ) const;
 
 
 
    template<class TYPE2>
    std::tuple<AMP::Array<double>, AMP::Array<double>> interp_cubic( const AMP::Array<double> &f,
                                                                     const AMP::Array<double> &g,
                                                                     const AMP::Array<TYPE2> &xi,
                                                                     const AMP::Array<int> &index,
                                                                     int extrap = 0 ) const;
 
 
 
    static void compute_Barycentric( const int ndim, const double *x, const double *xi, double *L );
 
 
    void clear();
 
 
private:
    void create_node_neighbors() const;
 
    void create_tri_neighbors() const;
 
    void create_node_tri() const;
 
    void create_kdtree() const;
 
    // Subroutine to perform cubic interpolation for a single point
    void interp_cubic_single( const double f[],
                              const double g[],
                              const double xi[],
                              const int index,
                              double &fi,
                              double *gi,
                              int extrap ) const;
 
 
private:                            // Internal Data
    Array<TYPE> d_x;                // Pointer to the coordinates (ndim x N)
    Array<int> d_tri;               // Pointer to the coordinates (ndim+1 x N_tri)
    mutable Array<int> d_tri_nab;   // List of neighbor triangles ( ndim+1 x N_tri )
    mutable size_t d_N_node_sum;    // The sum of the number of node neighbors
    mutable unsigned *d_N_node;     // The number of neighbor nodes for each node (1xN)
    mutable unsigned **d_node_list; // The list of neighbor nodes for each node (1xN)
                                    // Note: The first element points to an array of size N_node_sum
    mutable int *d_node_tri;        // For each node, a triangle that contains that node
    mutable kdtree *d_tree;         // Nearest neighbor search tree
};
 
 
} // namespace AMP
 
#endif