Store and re-use computed neighbor vectors.

cpp/cluster/Cluster.cc

@@ -23,9 +23,9 @@ void Cluster::compute(const freud::locality::NeighborQuery* nq, const freud::loc
         nq, nq->getPoints(), num_points, qargs, nlist,
         [&dj](const freud::locality::NeighborBond& neighbor_bond) {
             // Merge the two sets using the disjoint set
-            if (!dj.same(neighbor_bond.point_idx, neighbor_bond.query_point_idx))
+            if (!dj.same(neighbor_bond.getPointIdx(), neighbor_bond.getQueryPointIdx()))
             {
-                dj.unite(neighbor_bond.point_idx, neighbor_bond.query_point_idx);
+                dj.unite(neighbor_bond.getPointIdx(), neighbor_bond.getQueryPointIdx());
             }
         });
 

cpp/density/CorrelationFunction.cc

@@ -88,11 +88,11 @@ void CorrelationFunction<T>::accumulate(const freud::locality::NeighborQuery* ne
     accumulateGeneral(
         neighbor_query, query_points, n_query_points, nlist, qargs,
         [&](const freud::locality::NeighborBond& neighbor_bond) {
-            size_t value_bin = m_histogram.bin({neighbor_bond.distance});
+            size_t value_bin = m_histogram.bin({neighbor_bond.getDistance()});
             m_local_histograms.increment(value_bin);
             m_local_correlation_function.increment(
                 value_bin,
-                product(values[neighbor_bond.point_idx], query_values[neighbor_bond.query_point_idx]));
+                product(values[neighbor_bond.getPointIdx()], query_values[neighbor_bond.getQueryPointIdx()]));
         });
 }
 

cpp/density/LocalDensity.cc

@@ -43,7 +43,7 @@ void LocalDensity::compute(const freud::locality::NeighborQuery* neighbor_query,
             for (freud::locality::NeighborBond nb = ppiter->next(); !ppiter->end(); nb = ppiter->next())
             {
                 // count particles that are fully in the r_max sphere
-                if (nb.distance < (m_r_max - m_diameter / float(2.0)))
+                if (nb.getDistance() < (m_r_max - m_diameter / float(2.0)))
                 {
                     num_neighbors += float(1.0);
                 }
@@ -54,7 +54,7 @@ void LocalDensity::compute(const freud::locality::NeighborQuery* neighbor_query,
                     // lots of them. It smooths out the neighbor count distributions and avoids noisy spikes
                     // that obscure data
                     num_neighbors
-                        += float(1.0) + (m_r_max - (nb.distance + m_diameter / float(2.0))) / m_diameter;
+                        += float(1.0) + (m_r_max - (nb.getDistance() + m_diameter / float(2.0))) / m_diameter;
                 }
                 m_num_neighbors_array[i] = num_neighbors;
                 if (m_box.is2D())

cpp/density/RDF.cc

@@ -88,7 +88,7 @@ void RDF::accumulate(const freud::locality::NeighborQuery* neighbor_query, const
 {
     accumulateGeneral(neighbor_query, query_points, n_query_points, nlist, qargs,
                       [&](const freud::locality::NeighborBond& neighbor_bond) {
-                          m_local_histograms(neighbor_bond.distance);
+                          m_local_histograms(neighbor_bond.getDistance());
                       });
 }
 

cpp/environment/BondOrder.cc

@@ -85,9 +85,9 @@ void BondOrder::accumulate(const locality::NeighborQuery* neighbor_query, quat<f
 {
     accumulateGeneral(neighbor_query, query_points, n_query_points, nlist, qargs,
                       [&](const freud::locality::NeighborBond& neighbor_bond) {
-                          const quat<float>& ref_q(orientations[neighbor_bond.point_idx]);
-                          vec3<float> v(bondVector(neighbor_bond, neighbor_query, query_points));
-                          const quat<float>& q = query_orientations[neighbor_bond.query_point_idx];
+                          const quat<float>& ref_q(orientations[neighbor_bond.getPointIdx()]);
+                          vec3<float> v(neighbor_bond.getVector());
+                          const quat<float>& q(query_orientations[neighbor_bond.getQueryPointIdx()]);
                           if (m_mode == obcd)
                           {
                               // give bond directions of neighboring particles rotated by the matrix

cpp/environment/LocalBondProjection.cc

@@ -71,11 +71,12 @@ void LocalBondProjection::compute(const locality::NeighborQuery* nq, const quat<
                 const size_t j(m_nlist.getNeighbors()(bond, 1));
 
                 // compute bond vector between the two particles
-                vec3<float> local_bond(bondVector(locality::NeighborBond(i, j), nq, query_points));
+                vec3<float> local_bond(m_nlist.getVectors()[bond]);
+
                 // rotate bond vector into the local frame of particle p
                 local_bond = rotate(conj(orientations[j]), local_bond);
                 // store the length of this local bond
-                float local_bond_len = std::sqrt(dot(local_bond, local_bond));
+                float local_bond_len = m_nlist.getDistances()[bond];
 
                 for (unsigned int k = 0; k < n_proj; k++)
                 {

cpp/environment/LocalDescriptors.cc

@@ -52,8 +52,7 @@ void LocalDescriptors::compute(const locality::NeighborQuery* nq, const vec3<flo
                      && m_nlist.getNeighbors()(bond_copy, 0) == i && neighbor_count < max_num_neighbors;
                      ++bond_copy, ++neighbor_count)
                 {
-                    const size_t j(m_nlist.getNeighbors()(bond_copy, 1));
-                    const vec3<float> r_ij(bondVector(locality::NeighborBond(i, j), nq, query_points));
+                    const vec3<float> r_ij(m_nlist.getVectors()[bond_copy]);
                     const float r_sq(dot(r_ij, r_ij));
 
                     for (size_t ii(0); ii < 3; ++ii)
@@ -105,14 +104,11 @@ void LocalDescriptors::compute(const locality::NeighborQuery* nq, const vec3<flo
                  ++bond, ++neighbor_count)
             {
                 const unsigned int sphCount(bond * getSphWidth());
-                const size_t j(m_nlist.getNeighbors()(bond, 1));
-                const vec3<float> r_ij(bondVector(locality::NeighborBond(i, j), nq, query_points));
-                const float r_sq(dot(r_ij, r_ij));
+                const vec3<float> r_ij(m_nlist.getVectors()[bond]);
+                const float magR(m_nlist.getDistances()[bond]);
                 const vec3<float> bond_ij(dot(rotation_0, r_ij), dot(rotation_1, r_ij),
                                           dot(rotation_2, r_ij));
 
-                const float magR(std::sqrt(r_sq));
-
                 // Wrap theta into [0, 2*pi]
                 float theta(std::atan2(bond_ij.y, bond_ij.x));
                 theta = util::modulusPositive(theta, constants::TWO_PI);

cpp/environment/MatchEnv.cc

@@ -7,7 +7,6 @@
 
 #include "MatchEnv.h"
 
-#include "NeighborBond.h"
 #include "NeighborComputeFunctional.h"
 
 namespace freud { namespace environment {
@@ -488,8 +487,7 @@ MatchEnv::~MatchEnv() = default;
 
 EnvironmentCluster::~EnvironmentCluster() = default;
 
-Environment MatchEnv::buildEnv(const freud::locality::NeighborQuery* nq,
-                               const freud::locality::NeighborList* nlist, size_t num_bonds, size_t& bond,
+Environment MatchEnv::buildEnv(const freud::locality::NeighborList* nlist, size_t num_bonds, size_t& bond,
                                unsigned int i, unsigned int env_ind)
 {
     Environment ei = Environment();
@@ -502,7 +500,7 @@ Environment MatchEnv::buildEnv(const freud::locality::NeighborQuery* nq,
         const size_t j(nlist->getNeighbors()(bond, 1));
         if (i != j)
         {
-            vec3<float> delta(bondVector(locality::NeighborBond(i, j), nq, nq->getPoints()));
+            vec3<float> delta(nlist->getVectors()[bond]);
             ei.addVec(delta);
         }
     }
@@ -540,7 +538,7 @@ void EnvironmentCluster::compute(const freud::locality::NeighborQuery* nq,
     // if you don't do this, things will get screwy.
     for (unsigned int i = 0; i < Np; i++)
     {
-        Environment ei = buildEnv(nq, &env_nlist, env_num_bonds, env_bond, i, i);
+        Environment ei = buildEnv(&env_nlist, env_num_bonds, env_bond, i, i);
         dj.s.push_back(ei);
         dj.m_max_num_neigh = std::max(dj.m_max_num_neigh, ei.num_vecs);
         ;
@@ -726,7 +724,7 @@ void EnvironmentMotifMatch::compute(const freud::locality::NeighborQuery* nq,
     for (unsigned int i = 0; i < Np; i++)
     {
         unsigned int dummy = i + 1;
-        Environment ei = buildEnv(nq, &nlist, num_bonds, bond, i, dummy);
+        Environment ei = buildEnv(&nlist, num_bonds, bond, i, dummy);
         dj.s.push_back(ei);
 
         // if the environment matches e0, merge it into the e0 environment set
@@ -803,7 +801,7 @@ void EnvironmentRMSDMinimizer::compute(const freud::locality::NeighborQuery* nq,
     for (unsigned int i = 0; i < Np; i++)
     {
         unsigned int dummy = i + 1;
-        Environment ei = buildEnv(nq, &nlist, num_bonds, bond, i, dummy);
+        Environment ei = buildEnv(&nlist, num_bonds, bond, i, dummy);
         dj.s.push_back(ei);
 
         // if the environment matches e0, merge it into the e0 environment set

cpp/environment/MatchEnv.h

@@ -205,8 +205,7 @@ class MatchEnv
 
     //! Construct and return a local environment surrounding the particle indexed by i. Set the environment
     //! index to env_ind.
-    static Environment buildEnv(const freud::locality::NeighborQuery* nq,
-                                const freud::locality::NeighborList* nlist, size_t num_bonds, size_t& bond,
+    static Environment buildEnv(const freud::locality::NeighborList* nlist, size_t num_bonds, size_t& bond,
                                 unsigned int i, unsigned int env_ind);
 
     //! Returns the entire Np by m_num_neighbors by 3 matrix of all environments for all particles

cpp/locality/AABBQuery.cc

@@ -183,7 +183,7 @@ NeighborBond AABBQueryBallIterator::next()
                         // Check ii exclusion before including the pair.
                         if (r_sq < r_max_sq && r_sq >= r_min_sq)
                         {
-                            return NeighborBond(m_query_point_idx, j, std::sqrt(r_sq));
+                            return NeighborBond(m_query_point_idx, j, std::sqrt(r_sq), 1, r_ij);
                         }
                     }
                 }
@@ -230,7 +230,7 @@ NeighborBond AABBQueryIterator::next()
             // r_min filtering because we're querying beyond the normally safe
             // bounds, so we have to do it in this class.
             m_current_neighbors.clear();
-            m_all_distances.clear();
+            m_all_bonds_minimum_distance.clear();
             m_query_points_below_r_min.clear();
             std::shared_ptr<NeighborQueryPerPointIterator> ball_it = std::make_shared<AABBQueryBallIterator>(
                 static_cast<const AABBQuery*>(m_neighbor_query), m_query_point, m_query_point_idx,
@@ -243,26 +243,28 @@ NeighborBond AABBQueryIterator::next()
                     continue;
                 }
 
-                if (!m_exclude_ii || m_query_point_idx != nb.point_idx)
+                if (!m_exclude_ii || m_query_point_idx != nb.getPointIdx())
                 {
-                    nb.query_point_idx = m_query_point_idx;
+                    nb.setQueryPointIdx(m_query_point_idx);
                     // If we've expanded our search radius beyond safe
                     // distance, use the map instead of the vector.
                     if (m_search_extended)
                     {
-                        if ((m_all_distances.count(nb.point_idx) == 0)
-                            || m_all_distances[nb.point_idx] > nb.distance)
+                        const unsigned int nb_point_idx = nb.getPointIdx();
+                        const float nb_distance = nb.getDistance();
+                        if ((m_all_bonds_minimum_distance.count(nb_point_idx) == 0)
+                            || m_all_bonds_minimum_distance[nb_point_idx].getDistance() > nb_distance)
                         {
-                            m_all_distances[nb.point_idx] = nb.distance;
-                            if (nb.distance < m_r_min)
+                            m_all_bonds_minimum_distance[nb_point_idx] = nb;
+                            if (nb_distance < m_r_min)
                             {
-                                m_query_points_below_r_min.insert(nb.point_idx);
+                                m_query_points_below_r_min.insert(nb_point_idx);
                             }
                         }
                     }
                     else
                     {
-                        if (nb.distance >= m_r_min)
+                        if (nb.getDistance() >= m_r_min)
                         {
                             m_current_neighbors.emplace_back(nb);
                         }
@@ -281,18 +283,18 @@ NeighborBond AABBQueryIterator::next()
             }
 
             if ((m_r_cur >= m_r_max) || (m_r_cur >= max_plane_distance)
-                || ((m_all_distances.size() - m_query_points_below_r_min.size()) >= m_num_neighbors))
+                || ((m_all_bonds_minimum_distance.size() - m_query_points_below_r_min.size())
+                    >= m_num_neighbors))
             {
                 // Once this condition is reached, either we found enough
                 // neighbors beyond the normal min_plane_distance
                 // condition or we conclude that there are not enough
                 // neighbors left in the system.
-                for (const auto& bond_distance : m_all_distances)
+                for (const auto& minimum_distance_bond : m_all_bonds_minimum_distance)
                 {
-                    if (bond_distance.second >= m_r_min)
+                    if (minimum_distance_bond.second.getDistance() >= m_r_min)
                     {
-                        m_current_neighbors.emplace_back(m_query_point_idx, bond_distance.first,
-                                                         bond_distance.second);
+                        m_current_neighbors.emplace_back(minimum_distance_bond.second);
                     }
                 }
                 std::sort(m_current_neighbors.begin(), m_current_neighbors.end());
@@ -320,7 +322,7 @@ NeighborBond AABBQueryIterator::next()
     while ((m_count < m_num_neighbors) && (m_count < m_current_neighbors.size()))
     {
         m_count++;
-        if (m_current_neighbors[m_count - 1].distance > m_r_max)
+        if (m_current_neighbors[m_count - 1].getDistance() > m_r_max)
         {
             m_finished = true;
             return ITERATOR_TERMINATOR;

cpp/locality/AABBQuery.h

@@ -147,7 +147,7 @@ class AABBQueryIterator : public AABBIterator
                       float r_min, float scale, bool exclude_ii)
         : AABBIterator(neighbor_query, query_point, query_point_idx, r_max, r_min, exclude_ii), m_count(0),
           m_num_neighbors(num_neighbors), m_search_extended(false), m_r_cur(r_guess), m_scale(scale),
-          m_all_distances(), m_query_points_below_r_min()
+          m_all_bonds_minimum_distance(), m_query_points_below_r_min()
     {
         updateImageVectors(0);
     }
@@ -167,8 +167,9 @@ class AABBQueryIterator : public AABBIterator
     float
         m_r_cur; //!< Current search ball cutoff distance in use for the current particle (expands as needed).
     float m_scale; //!< The amount to scale m_r by when the current ball is too small.
-    std::map<unsigned int, float> m_all_distances; //!< Hash map of minimum distances found for a given point,
-                                                   //!< used when searching beyond maximum safe AABB distance.
+    std::map<unsigned int, NeighborBond>
+        m_all_bonds_minimum_distance; //!< Hash map of minimum distances found for a given point,
+                                      //!< used when searching beyond maximum safe AABB distance.
     std::unordered_set<unsigned int> m_query_points_below_r_min; //!< The set of query_points that were too
                                                                  //!< close based on the r_min threshold.
 };

cpp/locality/LinkCell.cc

@@ -516,7 +516,7 @@ NeighborBond LinkCellQueryBallIterator::next()
 
             if (r_sq < r_max_sq && r_sq >= r_min_sq)
             {
-                return NeighborBond(m_query_point_idx, j, std::sqrt(r_sq));
+                return NeighborBond(m_query_point_idx, j, std::sqrt(r_sq), 1, r_ij);
             }
         }
 
@@ -604,7 +604,7 @@ NeighborBond LinkCellQueryIterator::next()
                     const float r_sq(dot(r_ij, r_ij));
                     if (r_sq < r_max_sq && r_sq >= r_min_sq)
                     {
-                        m_current_neighbors.emplace_back(m_query_point_idx, j, std::sqrt(r_sq));
+                        m_current_neighbors.emplace_back(m_query_point_idx, j, std::sqrt(r_sq), 1, r_ij);
                     }
                 }
             }
@@ -639,7 +639,7 @@ NeighborBond LinkCellQueryIterator::next()
             // closest possible neighbor in the new shell.
             std::sort(m_current_neighbors.begin(), m_current_neighbors.end());
             if ((m_current_neighbors.size() >= m_num_neighbors)
-                && (m_current_neighbors[m_num_neighbors - 1].distance
+                && (m_current_neighbors[m_num_neighbors - 1].getDistance()
                     < static_cast<float>(m_neigh_cell_iter.getRange() - 1) * m_linkcell->getCellWidth()))
             {
                 break;
@@ -650,7 +650,7 @@ NeighborBond LinkCellQueryIterator::next()
     while ((m_count < m_num_neighbors) && (m_count < m_current_neighbors.size()))
     {
         m_count++;
-        if (m_current_neighbors[m_count - 1].distance > m_r_max)
+        if (m_current_neighbors[m_count - 1].getDistance() > m_r_max)
         {
             m_finished = true;
             return ITERATOR_TERMINATOR;