search_simple_points.h

Go to the documentation of this file.

/*
This file is part of the Ristra portage project.
Please see the license file at the root of this repository, or at:
    https://github.com/laristra/portage/blob/master/LICENSE
*/
#ifndef PORTAGE_SEARCH_SEARCH_SIMPLE_POINTS_H_
#define PORTAGE_SEARCH_SEARCH_SIMPLE_POINTS_H_

#include <memory>
#include <vector>
#include <cmath>


#include "portage/support/portage.h"
#include "portage/accumulate/accumulate.h"
#include "wonton/support/Point.h"

using Wonton::Point;

namespace Portage {

template<int dim, class SourceSwarm, class TargetSwarm>
class SearchSimplePoints {
public:

  SearchSimplePoints() = delete;

  // Constructor with swarms and extents
  SearchSimplePoints(
    SourceSwarm const& source_swarm,
    TargetSwarm const& target_swarm,
    Portage::vector<Point<dim>> const& source_extents,
    Portage::vector<Point<dim>> const& target_extents,
    Meshfree::WeightCenter center = Meshfree::Scatter)
      : source_swarm_(source_swarm),
        target_swarm_(target_swarm),
        source_extents_(source_extents),
        target_extents_(target_extents),
        center_(center)
  {} // SearchSimplePoints::SearchSimplePoints

  //  SearchSimplePoints(const SearchSimplePoints &) = delete;

  SearchSimplePoints& operator = (SearchSimplePoints const&) = delete;

  ~SearchSimplePoints() = default;

  std::vector<int> operator() (int point_id) const {

    std::vector<int> candidates;

    // find coordinates of target point
    Point<dim> target_coord = target_swarm_.get_particle_coordinates(point_id);

    // now see which source points are within an appropriate distance
    // of the target point
    // do a naive linear search
    int const nb_points = source_swarm_.num_particles(Wonton::ALL);
    for (int i = 0; i < nb_points; ++i) {
      Point<dim> source_coord = source_swarm_.get_particle_coordinates(i);
      bool contained = true;
      Point<dim> source_point_extent = source_extents_[i];
      Point<dim> target_point_extent = target_extents_[point_id];

      for (int d = 0; d < dim; ++d) {
        double maxdist = 0.;
        if (center_ == Meshfree::Scatter) {
          maxdist = 2. * source_point_extent[d];
        } else if (center_ == Meshfree::Gather) {
          maxdist = 2. * target_point_extent[d];
        }
        contained &= (std::abs(target_coord[d] - source_coord[d]) < maxdist);
        if (!contained)
          break;
      }
      if (contained)
        candidates.push_back(i);
    }

    return candidates;
  }

private:
  // Aggregate data members
  SourceSwarm const& source_swarm_;
  TargetSwarm const& target_swarm_;
  Portage::vector<Point<dim>> const& source_extents_;
  Portage::vector<Point<dim>> const& target_extents_;
  Meshfree::WeightCenter center_ = Meshfree::Scatter;

}; // class SearchSimplePoints

}  // namespace Portage

#endif  // PORTAGE_SEARCH_SEARCH_SIMPLE_POINTS_H_