anonymous_namespace{testNSearchLib.cpp} Namespace Reference

Functions
bool	isInList (const std::vector< size_t > *list, size_t i)
void	stats (const std::vector< double > &x, double &mean, double &std)
void	lattice (double L, size_t Nx, size_t Ny, size_t Nz, double dL, int seed, std::vector< util::Point > &x, int dim=3)
void	assignRandomTags (std::vector< util::Point > &x, int numTags, int seed, std::vector< size_t > &xTags)
template<class NSearch >
double	neighSearchTree (const std::vector< util::Point > &x, const std::unique_ptr< NSearch > &nsearch, const double &r, std::vector< std::vector< size_t > > &neigh, std::vector< std::vector< float > > &neigh_sq_dist)
template<class NSearch >
double	neighSearchTreeSizet (const std::vector< util::Point > &x, const std::unique_ptr< NSearch > &nsearch, const double &r, std::vector< std::vector< size_t > > &neigh, std::vector< std::vector< float > > &neigh_sq_dist)
template<class NSearch >
double	neighSearchTreeSizetExcludeInclude (const std::vector< util::Point > &x, const std::vector< size_t > &xTags, const std::unique_ptr< NSearch > &nsearch, const double &r, std::vector< std::vector< size_t > > &neigh, std::vector< std::vector< float > > &neigh_sq_dist, int selection_criteria)
double	neighSearchBrute (const std::vector< util::Point > &x, const double &r, std::vector< std::vector< size_t > > &neigh, std::vector< std::vector< float > > &neigh_sq_dist)
double	neighSearchBruteExcludeInclude (const std::vector< util::Point > &x, const std::vector< size_t > &xTags, const double &r, std::vector< std::vector< size_t > > &neigh, std::vector< std::vector< float > > &neigh_sq_dist, int selection_criteria)
template<class NSearch >
double	neighSearchTreeClosestPointSizet (const std::vector< util::Point > &x, const std::unique_ptr< NSearch > &nsearch, const int &seed, const double &L, const double &dL, std::vector< util::Point > &search_points, std::vector< size_t > &err_points, std::vector< double > &err_dist)
std::string	compare_results (const std::vector< std::vector< size_t > > &neigh1, const std::vector< std::vector< size_t > > &neigh2, std::vector< std::string > tags, int check_nodes_num=-1, bool only_err_count=false)
std::string	compare_closest_point_results (const std::vector< util::Point > &x, const std::vector< util::Point > &search_points, const std::vector< size_t > &err_points, const std::vector< double > &err_dist, bool only_err_count=false)

Function Documentation

assignRandomTags()

void anonymous_namespace{testNSearchLib.cpp}::assignRandomTags	(	std::vector< util::Point > &	x,
		int	numTags,
		int	seed,
		std::vector< size_t > &	xTags
	)

Definition at line 95 of file testNSearchLib.cpp.

                                                {
  RandGenerator gen(util::get_rd_gen(seed));
  UniformIntDistribution dist(0, numTags - 1);
 
  for (size_t i=0; i<x.size(); i++)
    xTags[i] = dist(gen);
}

References util::get_rd_gen().

Referenced by test::testNanoflannExcludeInclude().

Here is the call graph for this function:

Here is the caller graph for this function:

compare_closest_point_results()

std::string anonymous_namespace{testNSearchLib.cpp}::compare_closest_point_results	(	const std::vector< util::Point > &	x,
		const std::vector< util::Point > &	search_points,
		const std::vector< size_t > &	err_points,
		const std::vector< double > &	err_dist,
		bool	only_err_count = false
	)

Definition at line 460 of file testNSearchLib.cpp.

                                         {
 
      size_t error_size = 0;
      std::ostringstream composs;
 
      for (size_t i = 0; i < err_points.size(); i++) {
 
        if (err_points[i] != -1) {
          composs << fmt::format("    Node = {} at location = {}, "
                                 "Search point = {}, closest point id = {} at"
                                 " location = {}. True dist = {}, found "
                                 "dist = {}\n",
                                 i, x[i].printStr(), search_points[i]
                                 .printStr(), err_points[i], x[err_points[i]]
                                 .printStr(), (x[i] - search_points[i])
                                 .length(), err_dist[i]);
          error_size++;
        }
      }
 
      if (only_err_count)
        return fmt::format("    error_size = {}\n", error_size);
      else
        return fmt::format("    error_size = {}\n", error_size) +
               composs.str();
    }

Referenced by test::testNanoflannClosestPoint().

Here is the caller graph for this function:

compare_results()

std::string anonymous_namespace{testNSearchLib.cpp}::compare_results	(	const std::vector< std::vector< size_t > > &	neigh1,
		const std::vector< std::vector< size_t > > &	neigh2,
		std::vector< std::string >	tags,
		int	check_nodes_num = -1,
		bool	only_err_count = false
	)

Definition at line 408 of file testNSearchLib.cpp.

                                                         {
  size_t error_size = 0;
  size_t error_nodes = 0;
  size_t error_neighs = 0;
  std::ostringstream composs;
  for (size_t i = 0; i < neigh1.size(); i++) {
 
    if (check_nodes_num > 0 and i > check_nodes_num)
      continue;
 
    size_t err_neighs = 0;
    auto &n1 = neigh1[i];
    auto &n2 = neigh2[i];
 
    bool header_done = false;
    if (n1.size() != n2.size()) {
      composs << "    Node = " << i << " \n";
      composs << fmt::format("      size ({}) {} != {} ({}) not matching\n",
                             tags[0], n1.size(), n2.size(), tags[1]);
      header_done = true;
      error_size++;
    }
 
    for (auto j : n2) {
      if (!isInList(&n1, j)) {
        if (!header_done)
          composs << "    Node = " << i << " \n";
 
        composs << fmt::format("      neigh = {} in {} search not found in {} "
                               "search neighs list\n",
                               j, tags[1], tags[0]);
        err_neighs += 1;
      }
    }
 
    if (err_neighs > 0)
      error_neighs += err_neighs;
  }
 
  if (only_err_count)
    return fmt::format("    error_size = {}, error_neighs = {}\n", error_size,
                       error_neighs);
  else
    return fmt::format("    error_size = {}, error_neighs = {}\n", error_size,
                       error_neighs) +
           composs.str();
}

References isInList().

Referenced by test::testNanoflann(), and test::testNanoflannExcludeInclude().

Here is the call graph for this function:

Here is the caller graph for this function:

isInList()

bool anonymous_namespace{testNSearchLib.cpp}::isInList	(	const std::vector< size_t > *	list,
		size_t	i
	)

Definition at line 31 of file testNSearchLib.cpp.

                                                       {
  for (auto j : *list)
    if (j == i)
      return true;
 
  return false;
}

Referenced by compare_results().

Here is the caller graph for this function:

lattice()

void anonymous_namespace{testNSearchLib.cpp}::lattice	(	double	L,
		size_t	Nx,
		size_t	Ny,
		size_t	Nz,
		double	dL,
		int	seed,
		std::vector< util::Point > &	x,
		int	dim = 3
	)

Definition at line 54 of file testNSearchLib.cpp.

                                                   {
 
  RandGenerator gen(util::get_rd_gen(seed));
  UniformDistribution dist(-dL, dL);
 
  if (dim == 2)
    x.resize(Nx * Ny);
  else if (dim == 3)
    x.resize(Nx * Ny * Nz);
  else {
    std::cerr << "Dimension = " << dim << " not supprted.\n";
    exit(EXIT_FAILURE);
  }
 
  size_t count = 0;
  for (size_t i = 0; i < Nx; i++) {
    for (size_t j = 0; j < Ny; j++) {
      if (dim == 2) {
        auto y = util::Point();
        y.d_x = i * L + dist(gen);
        y.d_y = j * L + dist(gen);
        y.d_z = 0.;
 
        x[count] = y;
        count++;
      } else if (dim == 3) {
        for (size_t k = 0; k < Nz; k++) {
          auto y = util::Point();
          y.d_x = i * L + dist(gen);
          y.d_y = j * L + dist(gen);
          y.d_z = k * L + dist(gen);
 
          x[count] = y;
          count++;
        } // loop over k
      } // if-else
    } // loop over j
  } // loop over i
}

References util::get_rd_gen().

Referenced by test::testNanoflann(), test::testNanoflannClosestPoint(), and test::testNanoflannExcludeInclude().

Here is the call graph for this function:

Here is the caller graph for this function:

neighSearchBrute()

double anonymous_namespace{testNSearchLib.cpp}::neighSearchBrute	(	const std::vector< util::Point > &	x,
		const double &	r,
		std::vector< std::vector< size_t > > &	neigh,
		std::vector< std::vector< float > > &	neigh_sq_dist
	)

Definition at line 236 of file testNSearchLib.cpp.

                                                                    {
 
  neigh.resize(x.size());
  neigh_sq_dist.resize(x.size());
 
  auto t1 = steady_clock::now();
 
  tf::Executor executor(util::parallel::getNThreads());
  tf::Taskflow taskflow;
 
  taskflow.for_each_index((std::size_t) 0,
                          x.size(),
                          (std::size_t) 1,
                          [&x,
                           &neigh,
                           &neigh_sq_dist,
                           r](std::size_t i) {
      auto searchPoint = x[i];
 
      for (size_t j = 0; j < x.size(); j++) {
        auto dx = searchPoint - x[j];
        auto l = dx.length();
        if (util::isLess(l, r) and j != i) {
          neigh[i].push_back(j);
          neigh_sq_dist[i].push_back(l);
        }
      }
    }
  ); // for_each
 
  executor.run(taskflow).get();
 
  auto t2 = steady_clock::now();
  return util::methods::timeDiff(t1, t2, "microseconds");
}

References util::parallel::getNThreads().

Referenced by test::testNanoflann(), and test::testNanoflannExcludeInclude().

Here is the call graph for this function:

Here is the caller graph for this function:

neighSearchBruteExcludeInclude()

double anonymous_namespace{testNSearchLib.cpp}::neighSearchBruteExcludeInclude	(	const std::vector< util::Point > &	x,
		const std::vector< size_t > &	xTags,
		const double &	r,
		std::vector< std::vector< size_t > > &	neigh,
		std::vector< std::vector< float > > &	neigh_sq_dist,
		int	selection_criteria
	)

Definition at line 275 of file testNSearchLib.cpp.

                                                {
 
  // selection_criteria = 1 --> exclude search
  // selection_criteria = 2 --> include search
 
  neigh.resize(x.size());
  neigh_sq_dist.resize(x.size());
 
  auto t1 = steady_clock::now();
 
  tf::Executor executor(util::parallel::getNThreads());
  tf::Taskflow taskflow;
 
  taskflow.for_each_index((std::size_t) 0,
                          x.size(),
                          (std::size_t) 1,
                          [&x,
                           &xTags,
                           &neigh,
                           &neigh_sq_dist,
                           r,
                           selection_criteria](std::size_t i) {
 
        auto searchPoint = x[i];
        auto searchPointTag = xTags[i];
 
        for (size_t j = 0; j < x.size(); j++) {
          auto dx = searchPoint - x[j];
          auto l = dx.length();
          if (util::isLess(l, r) and j != i) {
 
            if (selection_criteria == 1) {
              if (xTags[j] != searchPointTag) {
                neigh[i].push_back(j);
                neigh_sq_dist[i].push_back(l);
              }
            }
            else if (selection_criteria == 2) {
              if (xTags[j] == searchPointTag) {
                neigh[i].push_back(j);
                neigh_sq_dist[i].push_back(l);
              }
            }
          }
        }
    }
  ); // for_each
 
  executor.run(taskflow).get();
 
  auto t2 = steady_clock::now();
  return util::methods::timeDiff(t1, t2, "microseconds");
}

References util::parallel::getNThreads().

Referenced by test::testNanoflannExcludeInclude().

Here is the call graph for this function:

Here is the caller graph for this function:

neighSearchTree()

template<class NSearch >

double anonymous_namespace{testNSearchLib.cpp}::neighSearchTree	(	const std::vector< util::Point > &	x,
		const std::unique_ptr< NSearch > &	nsearch,
		const double &	r,
		std::vector< std::vector< size_t > > &	neigh,
		std::vector< std::vector< float > > &	neigh_sq_dist
	)

Definition at line 107 of file testNSearchLib.cpp.

                                                                   {
  neigh.resize(x.size());
  neigh_sq_dist.resize(x.size());
  auto t1 = steady_clock::now();
 
  tf::Executor executor(util::parallel::getNThreads());
  tf::Taskflow taskflow;
 
  taskflow.for_each_index((std::size_t) 0, x.size(), (std::size_t) 1, [&x, &neigh, &neigh_sq_dist, &nsearch, r](std::size_t i) {
      std::vector<int> neighs;
      std::vector<float> sqr_dist;
 
      if (nsearch->radiusSearch(x[i], r, neighs, sqr_dist) >
          0) {
        for (std::size_t j = 0; j < neighs.size(); ++j)
          if (size_t(neighs[j]) != i) {
            neigh[i].push_back(size_t(neighs[j]));
            neigh_sq_dist[i].push_back(sqr_dist[j]);
          }
      }
    }
  ); // for_each
 
  executor.run(taskflow).get();
 
  auto t2 = steady_clock::now();
  return util::methods::timeDiff(t1, t2, "microseconds");
}

References util::parallel::getNThreads().

Here is the call graph for this function:

neighSearchTreeClosestPointSizet()

template<class NSearch >

double anonymous_namespace{testNSearchLib.cpp}::neighSearchTreeClosestPointSizet	(	const std::vector< util::Point > &	x,
		const std::unique_ptr< NSearch > &	nsearch,
		const int &	seed,
		const double &	L,
		const double &	dL,
		std::vector< util::Point > &	search_points,
		std::vector< size_t > &	err_points,
		std::vector< double > &	err_dist
	)

Definition at line 336 of file testNSearchLib.cpp.

                                                         {
 
  search_points.resize(x.size());
  err_points.resize(x.size());
  err_dist.resize(x.size());
 
  // set perturbation length much smaller than the dL
  double dx_perturb = dL/100;
 
  // random number generator
  RandGenerator gen(util::get_rd_gen(seed));
  UniformDistribution dist(-dx_perturb, dx_perturb);
 
  for (size_t i=0; i<x.size(); i++) {
    const auto &xi = x[i];
 
    // get a query point that is close to xi
    auto xi_perturb = xi;
    for (size_t k=0; k<3; k++)
      xi_perturb[k] += dist(gen);
 
    search_points[i] = xi_perturb;
  }
 
  auto t1 = steady_clock::now();
 
  tf::Executor executor(util::parallel::getNThreads());
  tf::Taskflow taskflow;
 
  taskflow.for_each_index((std::size_t) 0, x.size(), (std::size_t) 1, [&x,
                                                                       &search_points,
                                                                       &err_points, &err_dist, &nsearch](std::size_t i) {
 
      const auto &xi = x[i];
 
      // get a query point that is close to xi
      const auto &xi_perturb = search_points[i];
 
      // set true values
      size_t true_neigh = i;
      double true_dist = (xi - xi_perturb).length();
 
      size_t found_neigh;
      double found_dist = 0.;
 
      // find closest neighbor using nsearch
      nsearch->closestPoint(xi_perturb, found_neigh, found_dist);
 
      if (true_neigh != found_neigh) {
        err_points[i] = found_neigh;
        err_dist[i] = true_dist - found_dist;
      }
      else {
        err_points[i] = -1;
        err_dist[i] = 0.;
      }
    }
  ); // for_each
 
  executor.run(taskflow).get();
 
  auto t2 = steady_clock::now();
  return util::methods::timeDiff(t1, t2, "microseconds");
}

References util::get_rd_gen(), and util::parallel::getNThreads().

Referenced by test::testNanoflannClosestPoint().

Here is the call graph for this function:

Here is the caller graph for this function:

neighSearchTreeSizet()

template<class NSearch >

double anonymous_namespace{testNSearchLib.cpp}::neighSearchTreeSizet	(	const std::vector< util::Point > &	x,
		const std::unique_ptr< NSearch > &	nsearch,
		const double &	r,
		std::vector< std::vector< size_t > > &	neigh,
		std::vector< std::vector< float > > &	neigh_sq_dist
	)

Definition at line 141 of file testNSearchLib.cpp.

                                                                   {
  neigh.resize(x.size());
  neigh_sq_dist.resize(x.size());
  auto t1 = steady_clock::now();
 
  tf::Executor executor(util::parallel::getNThreads());
  tf::Taskflow taskflow;
 
  taskflow.for_each_index((std::size_t) 0, x.size(), (std::size_t) 1, [&x, &neigh, &neigh_sq_dist, &nsearch, r](std::size_t i) {
      std::vector<size_t> neighs;
      std::vector<double> sqr_dist;
 
      if (nsearch->radiusSearch(x[i], r, neighs, sqr_dist) >
          0) {
        for (std::size_t j = 0; j < neighs.size(); ++j)
          if (size_t(neighs[j]) != i) {
            neigh[i].push_back(size_t(neighs[j]));
            neigh_sq_dist[i].push_back(sqr_dist[j]);
          }
      }
    }
  ); // for_each
 
  executor.run(taskflow).get();
 
  auto t2 = steady_clock::now();
  return util::methods::timeDiff(t1, t2, "microseconds");
}

References util::parallel::getNThreads().

Referenced by test::testNanoflann(), and test::testNanoflannExcludeInclude().

Here is the call graph for this function:

Here is the caller graph for this function:

neighSearchTreeSizetExcludeInclude()

template<class NSearch >

double anonymous_namespace{testNSearchLib.cpp}::neighSearchTreeSizetExcludeInclude	(	const std::vector< util::Point > &	x,
		const std::vector< size_t > &	xTags,
		const std::unique_ptr< NSearch > &	nsearch,
		const double &	r,
		std::vector< std::vector< size_t > > &	neigh,
		std::vector< std::vector< float > > &	neigh_sq_dist,
		int	selection_criteria
	)

Definition at line 175 of file testNSearchLib.cpp.

                                                    {
 
  // selection_criteria = 1 --> exclude search
  // selection_criteria = 2 --> include search
 
  neigh.resize(x.size());
  neigh_sq_dist.resize(x.size());
  auto t1 = steady_clock::now();
 
  tf::Executor executor(util::parallel::getNThreads());
  tf::Taskflow taskflow;
 
  taskflow.for_each_index((std::size_t) 0,
                          x.size(),
                          (std::size_t) 1,
                          [&x,
                           &xTags,
                           &neigh,
                           &neigh_sq_dist,
                           &nsearch,
                           r,
                           selection_criteria](std::size_t i) {
 
          std::vector<size_t> neighs;
          std::vector<double> sqr_dist;
          size_t n = 0;
 
          if (selection_criteria == 1)
            n = nsearch->radiusSearchExcludeTag(x[i], r,
                                                neighs,
                                                sqr_dist,
                                                xTags[i],
                                                xTags);
          else if (selection_criteria == 2)
            n = nsearch->radiusSearchIncludeTag(x[i], r,
                                                neighs,
                                                sqr_dist,
                                                xTags[i],
                                                xTags);
          if (n > 0) {
            for (std::size_t j = 0; j < neighs.size(); ++j)
              if (size_t(neighs[j]) != i) {
                neigh[i].push_back(size_t(neighs[j]));
                neigh_sq_dist[i].push_back(sqr_dist[j]);
              }
          }
      }
  ); // for_each
 
  executor.run(taskflow).get();
 
  auto t2 = steady_clock::now();
  return util::methods::timeDiff(t1, t2, "microseconds");
}

References util::parallel::getNThreads().

Referenced by test::testNanoflannExcludeInclude().

Here is the call graph for this function:

Here is the caller graph for this function:

stats()

void anonymous_namespace{testNSearchLib.cpp}::stats	(	const std::vector< double > &	x,
		double &	mean,
		double &	std
	)

Definition at line 39 of file testNSearchLib.cpp.

                                                                  {
  double mu = 0.;
  for (auto &y : x)
    mu += y;
  mu = mu / x.size();
 
  double s = 0.;
  for (auto &y : x)
    s += (y - mu) * (y - mu);
  s = s / x.size();
 
  std = std::sqrt(s);
  mean = mu;
}