add biased voronoi cells feature

cpp/locality/Voronoi.cc

@@ -15,7 +15,7 @@
 namespace freud { namespace locality {
 
 // Voronoi calculations should be kept in double precision.
-void Voronoi::compute(const freud::locality::NeighborQuery* nq)
+void Voronoi::compute(const freud::locality::NeighborQuery* nq, const double* radii)
 {
     auto box = nq->getBox();
     auto n_points = nq->getNPoints();
@@ -40,20 +40,23 @@ void Voronoi::compute(const freud::locality::NeighborQuery* nq)
     // having to create a pre_container. This saves time because the
     // pre_container cannot be used to set up container_periodic (only
     // non-periodic containers are compatible).
+    // Also, we enable the weighted voronoi diagram if the sizes of different
+    // points are provided; otherwise, the default is unbiased voronoi shapes
+    // calculations.
     float block_scale = std::pow(n_points / (voro::optimal_particles * box.getVolume()), 1.0 / 3.0);
     int voro_blocks_x = int(box.getLx() * block_scale + 1);
     int voro_blocks_y = int(box.getLy() * block_scale + 1);
     int voro_blocks_z = int(box.getLz() * block_scale + 1);
 
-    voro::container_periodic container(boxLatticeVectors[0].x, boxLatticeVectors[1].x, boxLatticeVectors[1].y,
-                                       boxLatticeVectors[2].x, boxLatticeVectors[2].y, boxLatticeVectors[2].z,
-                                       voro_blocks_x, voro_blocks_y, voro_blocks_z, 3);
-
+    voro::container_periodic_poly container(boxLatticeVectors[0].x, boxLatticeVectors[1].x, boxLatticeVectors[1].y,
+                                         boxLatticeVectors[2].x, boxLatticeVectors[2].y, boxLatticeVectors[2].z,
+                                         voro_blocks_x, voro_blocks_y, voro_blocks_z, 3);
     for (size_t query_point_id = 0; query_point_id < n_points; query_point_id++)
     {
         vec3<double> query_point((*nq)[query_point_id]);
-        container.put(query_point_id, query_point.x, query_point.y, query_point.z);
-    }
+        double radius = (radii != NULL) ? radii[query_point_id] : 0.0;
+        container.put(query_point_id, query_point.x, query_point.y, query_point.z, radius);
+        }
 
     voro::voronoicell_neighbor cell;
     voro::c_loop_all_periodic voronoi_loop(container);

cpp/locality/Voronoi.h

@@ -19,7 +19,7 @@ class Voronoi
     // default constructor
     Voronoi() : m_neighbor_list(std::make_shared<NeighborList>()) {}
 
-    void compute(const freud::locality::NeighborQuery* nq);
+    void compute(const freud::locality::NeighborQuery* nq, const double* radii = NULL);
 
     std::shared_ptr<NeighborList> getNeighborList() const
     {

freud/_locality.pxd

@@ -135,7 +135,8 @@ cdef extern from "PeriodicBuffer.h" namespace "freud::locality":
 cdef extern from "Voronoi.h" namespace "freud::locality":
     cdef cppclass Voronoi:
         Voronoi()
-        void compute(const NeighborQuery*) nogil except +
+        void compute(const NeighborQuery*,
+                     const double*) nogil except +
         vector[vector[vec3[double]]] getPolytopes() const
         const freud.util.ManagedArray[double] &getVolumes() const
         shared_ptr[NeighborList] getNeighborList() const

freud/locality.pyx

@@ -1120,17 +1120,28 @@ cdef class Voronoi(_Compute):
     def __dealloc__(self):
         del self.thisptr
 
-    def compute(self, system):
+    def compute(self, system, radii=None):
         R"""Compute Voronoi diagram.
 
         Args:
             system:
                 Any object that is a valid argument to
                 :class:`freud.locality.NeighborQuery.from_system`.
+            radii:
+                A list of :class:`numpy.ndarray` defining radii of points in
+                the system. (Default value = :code:`None`, meaning unbiased
+                Voronoi diagram.)
         """
         cdef NeighborQuery nq = NeighborQuery.from_system(system)
-        self.thisptr.compute(nq.get_ptr())
         self._box = nq.box
+        if radii is None:
+            radii = np.zeros(len(nq.points), dtype=np.float64)
+        radii = freud.util._convert_array(
+            radii,
+            shape=(len(nq.points),),
+            dtype=np.float64)
+        cdef double[::1] l_radii = radii
+        self.thisptr.compute(nq.get_ptr(), &l_radii[0])
         return self
 
     @_Compute._computed_property