DataCoupler.hpp

Go to the documentation of this file.

#ifndef DATACOUPLER_HPP
#define DATACOUPLER_HPP

#include "moab/Range.hpp"
#include "moab/Interface.hpp"

#include <sstream>

namespace moab {

class ParallelComm;
class SpatialLocator;
class Error;

class DataCoupler
{
public:

  enum Method {CONSTANT, LINEAR_FE, QUADRATIC_FE, SPECTRAL} ;

  enum IntegType {VOLUME};

    /* constructor
     * Constructor, which also optionally initializes the coupler
     * \param source_ents Elements in the source mesh
     * \param coupler_id Id of this coupler, should be the same over all procs
     * \param pc ParallelComm object to be used with this coupler, representing the union
     *    of processors containing source and target meshes
     * \param init_locator If true, initializes a spatial locator inside the constructor
     * \param dim Dimension of entities to be coupled; if -1, get from source_elems
     */
  DataCoupler(Interface *impl,
              Range &source_ents,
              int coupler_id,
              ParallelComm *pc = NULL,
              bool init_locator = true,
              int dim = -1);

    /* destructor
     */
  virtual ~DataCoupler();
  
    /* \brief Locate points on the source mesh
     * This is a pass-through function to SpatialLocator::locate_points
     * \param xyz Point locations (interleaved) being located
     * \param num_points Number of points in xyz
     * \param rel_iter_tol Relative tolerance for non-linear iteration
     * \param abs_iter_tol Relative tolerance for non-linear iteration, usually 10^-10 or so
     * \param inside_tol Tolerance of is_inside evaluation, usually 10^-6 or so
     * \param loc_results Tuple list containing the results; two types of results are possible,
     *      controlled by value of store_local parameter:
     *      store_local = true: each tuple T[j] consists of (p, i), p = proc with src element containing
     *        point j (or 0 if serial), i = index in stored list (in SpatialLocator) on src proc
     *      store_local = false: each tuple T[j] consists of (p, ht, hs, pr[3]), where ht = target mesh entity
     *        handle, hs = source mesh entity containing point (0 if not found), pr = parameters in hs
     * \param store_local If true, stores the located points on SpatialLocator
     */
  ErrorCode locate_points(double *xyz, int num_points,
                          const double rel_iter_tol = 1.0e-10, const double abs_iter_tol = 1.0e-10,
                          const double inside_tol = 1.0e-6);
  
    /* \brief Locate points on the source mesh
     * This is a pass-through function to SpatialLocator::locate_points
     * \param ents Target entities being located
     * \param rel_iter_tol Relative tolerance for non-linear iteration
     * \param abs_iter_tol Relative tolerance for non-linear iteration, usually 10^-10 or so
     * \param inside_tol Tolerance of is_inside evaluation, usually 10^-6 or so
     * \param loc_results Tuple list containing the results; two types of results are possible,
     *      controlled by value of store_local parameter:
     *      store_local = true: each tuple T[j] consists of (p, i), p = proc with src element containing
     *        point j (or 0 if serial), i = index in stored list (in SpatialLocator) on src proc
     *      store_local = false: each tuple T[j] consists of (p, ht, hs, pr[3]), where ht = target mesh entity
     *        handle, hs = source mesh entity containing point (0 if not found), pr = parameters in hs
     * \param store_local If true, stores the located points on SpatialLocator
     */
  ErrorCode locate_points(Range &ents,
                          const double rel_iter_tol = 1.0e-10, const double abs_iter_tol = 1.0e-10,
                          const double inside_tol = 1.0e-6);
  
    /* \brief Interpolate data from the source mesh onto points
     * All entities/points or, if tuple_list is input, only those points
     * are interpolated from the source mesh.  Application should
     * allocate enough memory in interp_vals to hold interpolation results.
     * 
     * If normalization is requested, technique used depends on the coupling
     * method.
     *
     * \param method Interpolation/normalization method
     * \param tag Tag on source mesh holding data to be interpolated
     * \param interp_vals Memory holding interpolated data; if NULL, data is written to same tag on target ents
     * \param point_indices If non-NULL, a set of indices of points input to 
     *        locate_points at which to interpolate; if NULL, interpolates at all points
     *        input to locate_points
     * \param normalize If true, normalization is done according to method
     */
  ErrorCode interpolate(/*DataCoupler::Method*/ int method,
                        Tag tag,
                        double *interp_vals = NULL,
                        std::vector<int> *point_indices = NULL,
                        bool normalize = true);

    /* \brief Interpolate data from the source mesh onto points
     * All entities/points or, if tuple_list is input, only those points
     * are interpolated from the source mesh.  Application should
     * allocate enough memory in interp_vals to hold interpolation results.
     * 
     * If normalization is requested, technique used depends on the coupling
     * method.
     *
     * \param method Interpolation/normalization method
     * \param tag_name Tag name on source mesh holding data to be interpolated
     * \param interp_vals Memory holding interpolated data; if NULL, data is written to same tag on target ents
     * \param point_indices If non-NULL, a set of indices of points input to 
     *        locate_points at which to interpolate; if NULL, interpolates at all points
     *        input to locate_points
     * \param normalize If true, normalization is done according to method
     */
  ErrorCode interpolate(/*DataCoupler::Method*/ int method,
                        const std::string &tag_name,
                        double *interp_vals = NULL,
                        std::vector<int> *point_indices = NULL,
                        bool normalize = true);

    /* \brief Interpolate data from multiple tags
     * All entities/points or, if tuple_list is input, only those points
     * are interpolated from the source mesh.  Application should
     * allocate enough memory in interp_vals to hold interpolation results.
     * 
     * In this variant, multiple tags, possibly with multiple interpolation
     * methods, are specified.  Sum of values in points_per_method should be
     * the number of points in tl or, if NULL, targetPts.
     *
     * If normalization is requested, technique used depends on the coupling
     * method.
     *
     * \param methods Vector of Interpolation/normalization methods
     * \param tag_names Names of tag being interpolated for each method
     * \param points_per_method Number of points for each method
     * \param num_methods Length of vectors in previous 3 arguments
     * \param interp_vals Memory holding interpolated data; if NULL, data is written to same tag on target ents
     * \param point_indices If non-NULL, a set of indices of points input to 
     *        locate_points at which to interpolate; if NULL, interpolates at all points
     *        input to locate_points
     * \param normalize If true, normalization is done according to method
     */
  ErrorCode interpolate(/*DataCoupler::Method*/ int *methods,
                        const std::string *tag_names,
                        int *points_per_method,
                        int num_methods,
                        double *interp_vals = NULL,
                        std::vector<int> *point_indices = NULL,
                        bool normalize = true);


    /* \brief Interpolate data from multiple tags
     * All entities/points or, if tuple_list is input, only those points
     * are interpolated from the source mesh.  Application should
     * allocate enough memory in interp_vals to hold interpolation results.
     * 
     * In this variant, multiple tags, possibly with multiple interpolation
     * methods, are specified.  Sum of values in points_per_method should be
     * the number of points in tl or, if NULL, targetPts.
     *
     * If normalization is requested, technique used depends on the coupling
     * method.
     *
     * \param methods Vector of Interpolation/normalization methods
     * \param tag_names Names of tag being interpolated for each method
     * \param points_per_method Number of points for each method
     * \param num_methods Length of vectors in previous 3 arguments
     * \param interp_vals Memory holding interpolated data; if NULL, data is written to same tag on target ents
     * \param point_indices If non-NULL, a set of indices of points input to 
     *        locate_points at which to interpolate; if NULL, interpolates at all points
     *        input to locate_points
     * \param normalize If true, normalization is done according to method
     */
  ErrorCode interpolate(/*DataCoupler::Method*/ int *methods,
                        Tag *tag_names,
                        int *points_per_method,
                        int num_methods,
                        double *interp_vals = NULL,
                        std::vector<int> *point_indices = NULL,
                        bool normalize = true);

    /* Get functions */
  inline SpatialLocator *spatial_locator() {return myLocator;}
  inline int my_id() const {return myId;}
  inline const Range &target_ents() const {return targetEnts;}
  inline Range &target_ents() {return targetEnts;}
  inline int get_dim() const {return myDim;}
        
private:

    /* \brief MOAB instance
     */
  Interface *mbImpl;
  
    /* \brief ParallelComm object for this coupler
     */
  ParallelComm *myPcomm;
  
    /* \brief SpatialLocator for local mesh
     */
  SpatialLocator *myLocator;
  
    /* \brief error object used to set last error on interface
     */
  Error *mError;

    /* \brief Id of this coupler
     */
  int myId;
  
    /* \brief Range of target entities
     */
  Range targetEnts;

  // entity dimension
  int myDim;

};

    inline ErrorCode DataCoupler::interpolate(/*DataCoupler::Method*/ int method,
                                          Tag tag,
                                          double *interp_vals,
                                          std::vector<int> *point_indices,
                                          bool normalize)
{
    // no point indices input, 
  int num_pts = (point_indices ? point_indices->size() : targetEnts.size());
  return interpolate(&method, &tag, &num_pts, 1,
                     interp_vals, point_indices, normalize);
}

} // namespace moab

#endif