search_simple.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_H_
#define PORTAGE_SEARCH_SEARCH_SIMPLE_H_

#include <vector>
#include <algorithm>

// portage includes
#include "portage/support/portage.h"
#include "wonton/support/Point.h"
using Wonton::Point;

namespace search_simple {

inline
void getBoundingBox(
    const std::vector<Point<2>> &cell_coord,
    double* xlow, double* xhigh,
    double* ylow, double* yhigh)
{
    const double big = 1.e99;
    double xl = big;  double xh = -big;
    double yl = big;  double yh = -big;

    for (const auto& p : cell_coord) {
        const double x = p[0];
        const double y = p[1];
        xl = std::min(xl, x);  xh = std::max(xh, x);
        yl = std::min(yl, y);  yh = std::max(yh, y);
    }

    *xlow = xl;  *xhigh = xh;
    *ylow = yl;  *yhigh = yh;

}  // getBoundingBox

}  // search_simple


namespace Portage {

template <typename SourceMeshType, typename TargetMeshType>
class SearchSimple {
  public:

    SearchSimple() = delete;

    // Constructor with Meshes
    SearchSimple(const SourceMeshType & source_mesh,
                 const TargetMeshType & target_mesh)
            : sourceMesh_(source_mesh), targetMesh_(target_mesh)  {

        const int numCells = sourceMesh_.num_owned_cells() +
                sourceMesh_.num_ghost_cells();
        xlow_.reserve(numCells);
        xhigh_.reserve(numCells);
        ylow_.reserve(numCells);
        yhigh_.reserve(numCells);

        // find bounding boxes for all cells
        for (int c = 0; c < numCells; ++c) {
            std::vector<Point<2>> cell_coord;
            sourceMesh_.cell_get_coordinates(c, &cell_coord);
            search_simple::getBoundingBox(cell_coord,
                           &xlow_[c], &xhigh_[c],
                           &ylow_[c], &yhigh_[c]);
        }
    }  // SearchSimple::SearchSimple

    SearchSimple(const SearchSimple &) = delete;

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

    ~SearchSimple() = default;

    void operator() (const int cellId, std::vector<int> *candidates) const;

  private:

    // Aggregate data members
    const SourceMeshType & sourceMesh_;
    const TargetMeshType & targetMesh_;
    std::vector<double> xlow_;
    std::vector<double> xhigh_;
    std::vector<double> ylow_;
    std::vector<double> yhigh_;

};  // class SearchSimple



template<typename SourceMeshType, typename TargetMeshType>
void SearchSimple<SourceMeshType, TargetMeshType>::
operator() (const int cellId, std::vector<int> *candidates)
const {
    // find bounding box for target cell
    std::vector<Point<2>> cell_coord;
    targetMesh_.cell_get_coordinates(cellId, &cell_coord);
    double txlow, txhigh, tylow, tyhigh;
    search_simple::getBoundingBox(cell_coord, &txlow, &txhigh, &tylow, &tyhigh);

    // now see which sourceMesh cells have bounding boxes overlapping
    // with target cell
    // do a naive linear search
    const int numCells = sourceMesh_.num_owned_cells() +
        sourceMesh_.num_ghost_cells();
    for (int c = 0; c < numCells; ++c) {
        if (std::max(txlow, xlow_[c]) < std::min(txhigh, xhigh_[c]) &&
                std::max(tylow, ylow_[c]) < std::min(tyhigh, yhigh_[c])) {
            candidates->push_back(c);
        }
    }

}  // SearchSimple::operator()




}  // namespace Portage

#endif  // PORTAGE_SEARCH_SEARCH_SIMPLE_H_