LinInterpGrid.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__numerical_interpolation_linear_h__)
#define __numerical_interpolation_linear_h__

#include "../defs.h"

#include "../../ads/array/Array.h"
#include "../../geom/grid/RegularGrid.h"

#include <functional>

BEGIN_NAMESPACE_NUMERICAL


template<int N, typename F = double, bool A = true, typename T = double>
class LinInterpGrid :
  // The following is complicated, but the argument type is a Cartesian point 
  // and the return type is the field.
  public std::unary_function< 
  const typename geom::RegularGrid<N,T>::Point&, 
  typename Loki::TypeTraits<F>::ParameterType> {
  //
  // Private types.
  //

private:

  typedef std::unary_function< 
    const typename geom::RegularGrid<N,T>::Point&, 
    typename Loki::TypeTraits<F>::ParameterType>
  base_type;

  //
  // Public types.
  //

public:

  typedef typename base_type::argument_type argument_type;
  typedef typename base_type::result_type result_type;

  typedef T Number;
  typedef F Field;

  typedef geom::RegularGrid<N,Number> Grid;
  typedef ads::Array<N,Field,A> FieldArray;

  typedef typename Grid::Point Point;
  typedef typename Grid::BBox BBox;

  typedef typename FieldArray::index_type index_type;
  typedef typename FieldArray::size_type size_type;

  typedef typename FieldArray::unqualified_value_type
  unqualified_Field;

  //
  // Data.
  //

private:
  
  FieldArray _fields;
  Grid _grid;

public:

  //--------------------------------------------------------------------------

  LinInterpGrid() :
    _fields(),
    _grid()
  {}


  template <bool A2>
  LinInterpGrid(const ads::Array<N,Field,A2>& fields,
                 const BBox domain) :
    _fields(fields),
    _grid(_fields.extents(), domain)
  {}


  template <bool A2>
  void
  build(const ads::Array<N,Field,A2>& fields, const BBox domain) {
    _fields = fields;
    _grid = Grid(_fields.extents(), domain);
  }

  LinInterpGrid(const LinInterpGrid& x) :
    _fields(x._fields),
    _grid(x._grid)
  {}

  LinInterpGrid&
  operator=(const LinInterpGrid& x) {
    if (this != &x) {
      _fields = x._fields;
      _grid = x._grid;
    }
    return *this;
  }

  ~LinInterpGrid()
  {}

  //--------------------------------------------------------------------------

  result_type
  operator()(argument_type x) const;

  //--------------------------------------------------------------------------

  static
  int
  space_dimension() {
    return N;
  }

  //--------------------------------------------------------------------------

  const FieldArray&
  fields() const {
    return _fields;
  }

  const BBox&
  domain() const {
    return _grid.domain();
  }

  //--------------------------------------------------------------------------


  FieldArray&
  fields() {
    return _fields;
  }

  void
  set_domain(const BBox& domain);

  void
  resize(const index_type& extents);

};

END_NAMESPACE_NUMERICAL

#define __numerical_interpolation_LinInterpGrid_ipp__
#include "LinInterpGrid.ipp"
#undef __numerical_interpolation_LinInterpGrid_ipp__

#endif

---