def test_GenericTree():
# With information
tree2 = domain_decomp.tree('kdtree',
pts2,
left_edge2,
right_edge2,
periodic=False,
leafsize=leafsize)
tree3 = domain_decomp.tree('kdtree',
pts3,
left_edge3,
right_edge3,
periodic=False,
leafsize=leafsize)
leaves2 = domain_decomp.process_leaves(tree2.leaves, left_edge2,
right_edge2, False)
leaves3 = domain_decomp.process_leaves(tree3.leaves, left_edge3,
right_edge3, False)
# Without information
left_edges = np.array([[0.0, 0.0], [0.0, 0.5], [0.5, 0.0], [0.5, 0.5]],
'float')
right_edges = np.array([[0.5, 0.5], [0.5, 1.0], [1.0, 0.5], [1.0, 1.0]],
'float')
leaves = [
domain_decomp.GenericLeaf(5, left_edges[i, :], right_edges[i, :])
for i in range(2)
]
tree = domain_decomp.GenericTree(
np.arange(5 * left_edges.shape[0]).astype('int'), leaves, left_edge2,
right_edge2, False)
del tree, leaves2, leaves3
def test_tree():
tree2 = domain_decomp.tree('kdtree',
pts2,
left_edge2,
right_edge2,
periodic=False,
leafsize=leafsize)
tree3 = domain_decomp.tree('kdtree',
pts3,
left_edge3,
right_edge3,
periodic=False,
leafsize=leafsize)
assert_raises(ValueError, domain_decomp.tree, 'invalid', pts2, left_edge2,
right_edge2, False)
del tree2, tree3
def make_test(npts,
ndim,
distrib='uniform',
periodic=False,
leafsize=None,
nleaves=0):
# Points
pts, left_edge, right_edge = make_points(npts, ndim, distrib=distrib)
npts = pts.shape[0]
# Tree
if leafsize is None:
leafsize = npts / 2 + 2
tree = domain_decomp.tree("kdtree",
pts,
left_edge,
right_edge,
periodic=periodic,
leafsize=leafsize,
nleaves=nleaves)
return pts, tree
def triangulate(pts,
left_edge=None,
right_edge=None,
periodic=False,
use_double=False,
nproc=0,
dd_method='kdtree',
dd_kwargs={},
limit_mem=False,
**kwargs):
r"""Triangulation of points.
Args:
pts (np.ndarray of float64): (n,m) Array of n mD points.
left_edge (np.ndarray of float64, optional): (m,) lower limits on
the domain. If None, this is set to np.min(pts, axis=0).
Defaults to None.
right_edge (np.ndarray of float64, optional): (m,) upper limits on
the domain. If None, this is set to np.max(pts, axis=0).
Defaults to None.
periodic (bool optional): If True, the domain is assumed to be
periodic at its left and right edges. Defaults to False.
use_double (bool, optional): If True, the triangulation is forced to
use 64bit integers reguardless of if there are too many points for
32bit. Otherwise 32bit integers are used so long as the number of
points is <=4294967295. Defaults to False.
nproc (int, optional): The number of MPI processes that should be
spawned. If <2, no processes are spawned. Defaults to 0.
dd_method (str, optional): String specifier for a domain
decomposition method. See :meth:`cgal4py.domain_decomp.leaves`
for available values. Defaults to 'kdtree'.
dd_kwargs (dict, optional): Dictionary of keyword arguments for the
selected domain decomposition method. Defaults to empty dict.
limit_mem (bool, optional): If True, memory usage is limited by
writing things to file at a cost to performance. Defaults to
False.
\*\*kwargs: Additiona keyword arguments are passed to the appropriate
class for constructuing the triangulation.
Returns:
T (:class:`cgal4py.delaunay.Delaunay2` or
:class:`cgal4py.delaunay.Delaunay3`:): 2D or 3D triangulation
object.
Raises:
ValueError: If `pts` is not a 2D array.
ValueError: If `left_edge` is not a 1D array with `pts.shape[1]`
elements.
ValueError: If `right_edge` is not a 1D array with `pts.shape[1]`
elements.
"""
# Check input
if (pts.ndim != 2):
raise ValueError("pts must be a 2D array of coordinates")
ndim = pts.shape[1]
if left_edge is None:
left_edge = np.min(pts, axis=0)
else:
if (left_edge.ndim != 1) or (len(left_edge) != ndim):
raise ValueError("left_edge must be a 1D array with " +
"{} elements.".format(ndim))
if right_edge is None:
right_edge = np.max(pts, axis=0)
else:
if (right_edge.ndim != 1) or (len(right_edge) != ndim):
raise ValueError("right_edge must be a 1D array with " +
"{} elements.".format(ndim))
# Parallel
if nproc > 1 and FLAG_MULTIPROC:
if (not 'nleaves' in dd_kwargs) and (not 'leafsize' in dd_kwargs):
if limit_mem:
dd_kwargs['nleaves'] = 2 * nproc
else:
dd_kwargs['nleaves'] = nproc
tree = domain_decomp.tree(dd_method, pts, left_edge, right_edge,
periodic, **dd_kwargs)
T = parallel.ParallelDelaunay(pts,
tree,
nproc,
limit_mem=limit_mem,
use_double=use_double,
**kwargs)
# Serial
else:
T = Delaunay(pts,
use_double=use_double,
periodic=periodic,
left_edge=left_edge,
right_edge=right_edge,
**kwargs)
return T