Get the Voronoi polyhedra for all site in a simulation cell

        Args:
            structure (Structure): Structure to be evaluated
        Returns:
            A dict of sites sharing a common Voronoi facet with the site
            n mapped to a directory containing statistics about the facet:
                - solid_angle - Solid angle subtended by face
                - angle_normalized - Solid angle normalized such that the
                    faces with the largest
                - area - Area of the facet
                - face_dist - Distance between site n and the facet
                - volume - Volume of Voronoi cell for this face
                - n_verts - Number of vertices on the facet

def get_all_voronoi_polyhedra(self, structure):
        """Get the Voronoi polyhedra for all site in a simulation cell

        Args:
            structure (Structure): Structure to be evaluated
        Returns:
            A dict of sites sharing a common Voronoi facet with the site
            n mapped to a directory containing statistics about the facet:
                - solid_angle - Solid angle subtended by face
                - angle_normalized - Solid angle normalized such that the
                    faces with the largest
                - area - Area of the facet
                - face_dist - Distance between site n and the facet
                - volume - Volume of Voronoi cell for this face
                - n_verts - Number of vertices on the facet
        """

        # Special case: For atoms with 1 site, the atom in the root image is not included
        #   in the get_all_neighbors output. Rather than creating logic to add that atom
        #   to the neighbor list, which requires detecting whether it will be translated
        #   to reside within the unit cell before neighbor detection, it is less complex
        #   to just call the one-by-one operation
        if len(structure) == 1:
            return [self.get_voronoi_polyhedra(structure, 0)]

        # Assemble the list of neighbors used in the tessellation
        if self.targets is None:
            targets = structure.composition.elements
        else:
            targets = self.targets

        # Initialize the list of sites with the atoms in the origin unit cell
        #  The `get_all_neighbors` function returns neighbors for each site's image in the
        #   original unit cell. We start off with these central atoms to ensure they are
        #   included in the tessellation

        sites = [x.to_unit_cell() for x in structure]
        indices = [(i, 0, 0, 0) for i, _ in enumerate(structure)]

        # Get all neighbors within a certain cutoff
        #   Record both the list of these neighbors, and the site indices
        all_neighs = structure.get_all_neighbors(self.cutoff,
                                                 include_index=True,
                                                 include_image=True)
        for neighs in all_neighs:
            sites.extend([x[0] for x in neighs])
            indices.extend([(x[2],) + x[3] for x in neighs])

        # Get the non-duplicates (using the site indices for performance/numerical stability)
        indices = np.array(indices, dtype=np.int)
        indices, uniq_inds = np.unique(indices, return_index=True, axis=0)
        sites = np.array(sites)[uniq_inds]

        # Sort array such that atoms in the root image are first
        #   Exploit the fact that the array is sorted by the unique operation such that
        #   the images associated with atom 0 are first, followed by atom 1, etc.
        root_images, = np.nonzero(np.abs(indices[:, 1:]).max(axis=1) == 0)

        del indices  # Save memory (tessellations can be costly)

        # Run the tessellation
        qvoronoi_input = [s.coords for s in sites]
        voro = Voronoi(qvoronoi_input)

        # Get the information for each neighbor
        return [self._extract_cell_info(structure, i, sites, targets,
                                        voro, self.compute_adj_neighbors)
                for i in root_images.tolist()]