docs: def cluster_nodes(self, tol=0.2):
          """
          Cluster nodes that are too close together using a tol.
  
          Args:
              tol (float): A distance tolerance. PBC is taken into account.
          """
          lattice = self.structure.lattice
          vf_coords = self.extrema_coords
  
          if len(vf_coords) == 0:
              if self.extrema_type is None:
                  logger.warning(
                      "Please run ChargeDensityAnalyzer.get_local_extrema first!")
                  return
              new_f_coords = []
              self._update_extrema(new_f_coords, self.extrema_type)
              return new_f_coords
  
          # Manually generate the distance matrix (which needs to take into
          # account PBC.
          dist_matrix = np.array(lattice.get_all_distances(vf_coords, vf_coords))
          dist_matrix = (dist_matrix + dist_matrix.T) / 2
  
          for i in range(len(dist_matrix)):
              dist_matrix[i, i] = 0
          condensed_m = squareform(dist_matrix)
          z = linkage(condensed_m)
          cn = fcluster(z, tol, criterion="distance")
          merged_fcoords = []
  
          for n in set(cn):
              frac_coords = []
              for i, j in enumerate(np.where(cn == n)[0]):
                  if i == 0:
                      frac_coords.append(self.extrema_coords[j])
                  else:
                      f_coords = self.extrema_coords[j]
                      # We need the image to combine the frac_coords properly.
                      d, image = lattice.get_distance_and_image(frac_coords[0],
                                                                f_coords)
                      frac_coords.append(f_coords + image)
              merged_fcoords.append(np.average(frac_coords, axis=0))
  
          merged_fcoords = [f - np.floor(f) for f in merged_fcoords]
          merged_fcoords = [f * (np.abs(f - 1) > 1E-15) for f in merged_fcoords]
          # the second line for fringe cases like 
          # np.array([ 5.0000000e-01 -4.4408921e-17  5.0000000e-01])
          # where the shift to [0,1) does not work due to float precision
          self._update_extrema(merged_fcoords, extrema_type=self.extrema_type)
          logger.debug(
              "{} vertices after combination.".format(len(self.extrema_coords)))