def test_save_load_octree():
np.random.seed(int(0x4d3d3d3))
pos = np.random.normal(0.5, scale=0.05,
size=(NPART, 3)) * (DRE - DLE) + DLE
octree = ParticleOctreeContainer((1, 1, 1), DLE, DRE)
octree.n_ref = 32
for i in range(3):
np.clip(pos[:, i], DLE[i], DRE[i], pos[:, i])
# Convert to integers
pos = np.floor((pos - DLE) / dx).astype("uint64")
morton = get_morton_indices(pos)
morton.sort()
octree.add(morton)
octree.finalize()
saved = octree.save_octree()
loaded = OctreeContainer.load_octree(saved)
always = AlwaysSelector(None)
ir1 = octree.ires(always)
ir2 = loaded.ires(always)
yield assert_equal, ir1, ir2
fc1 = octree.fcoords(always)
fc2 = loaded.fcoords(always)
yield assert_equal, fc1, fc2
fw1 = octree.fwidth(always)
fw2 = loaded.fwidth(always)
yield assert_equal, fw1, fw2
def test_save_load_octree():
np.random.seed(int(0x4d3d3d3))
pos = np.random.normal(0.5, scale=0.05, size=(NPART,3)) * (DRE-DLE) + DLE
octree = ParticleOctreeContainer((1, 1, 1), DLE, DRE)
octree.n_ref = 32
for i in range(3):
np.clip(pos[:,i], DLE[i], DRE[i], pos[:,i])
# Convert to integers
pos = np.floor((pos - DLE)/dx).astype("uint64")
morton = get_morton_indices(pos)
morton.sort()
octree.add(morton)
octree.finalize()
saved = octree.save_octree()
loaded = OctreeContainer.load_octree(saved)
always = AlwaysSelector(None)
ir1 = octree.ires(always)
ir2 = loaded.ires(always)
yield assert_equal, ir1, ir2
fc1 = octree.fcoords(always)
fc2 = loaded.fcoords(always)
yield assert_equal, fc1, fc2
fw1 = octree.fwidth(always)
fw2 = loaded.fwidth(always)
yield assert_equal, fw1, fw2
def test_add_particles_random():
np.random.seed(int(0x4d3d3d3))
pos = np.random.normal(0.5, scale=0.05,
size=(NPART, 3)) * (DRE - DLE) + DLE
# Now convert to integers
for i in range(3):
np.clip(pos[:, i], DLE[i], DRE[i], pos[:, i])
# Convert to integers
pos = np.floor((pos - DLE) / dx).astype("uint64")
morton = get_morton_indices(pos)
morton.sort()
for ndom in [1, 2, 4, 8]:
octree = ParticleOctreeContainer((1, 1, 1), DLE, DRE)
octree.n_ref = 32
for dom, split in enumerate(np.array_split(morton, ndom)):
octree.add(split)
octree.finalize()
# This visits every oct.
tc = octree.recursively_count()
total_count = np.zeros(len(tc), dtype="int32")
for i in sorted(tc):
total_count[i] = tc[i]
yield assert_equal, octree.nocts, total_count.sum()
# This visits every cell -- including those covered by octs.
#for dom in range(ndom):
# level_count += octree.count_levels(total_count.size-1, dom, mask)
yield assert_equal, total_count, [1, 8, 64, 64, 256, 536, 1856, 1672]
def test_add_particles_random():
np.random.seed(int(0x4d3d3d3))
pos = np.random.normal(0.5, scale=0.05, size=(NPART,3)) * (DRE-DLE) + DLE
# Now convert to integers
for i in range(3):
np.clip(pos[:,i], DLE[i], DRE[i], pos[:,i])
# Convert to integers
pos = np.floor((pos - DLE)/dx).astype("uint64")
morton = get_morton_indices(pos)
morton.sort()
for ndom in [1, 2, 4, 8]:
octree = ParticleOctreeContainer((1, 1, 1), DLE, DRE)
octree.n_ref = 32
for dom, split in enumerate(np.array_split(morton, ndom)):
octree.add(split)
octree.finalize()
# This visits every oct.
tc = octree.recursively_count()
total_count = np.zeros(len(tc), dtype="int32")
for i in sorted(tc):
total_count[i] = tc[i]
yield assert_equal, octree.nocts, total_count.sum()
# This visits every cell -- including those covered by octs.
#for dom in range(ndom):
# level_count += octree.count_levels(total_count.size-1, dom, mask)
yield assert_equal, total_count, [1, 8, 64, 64, 256, 536, 1856, 1672]
def to_octree(self, over_refine_factor=1, dims=(1, 1, 1), n_ref=64):
mi = self.morton
mi.sort()
eps = np.finfo(self.dtype).eps
LE = self.min(axis=0)
LE -= np.abs(LE) * eps
RE = self.max(axis=0)
RE += np.abs(RE) * eps
octree = ParticleOctreeContainer(dims, LE, RE, over_refine=over_refine_factor)
octree.n_ref = n_ref
octree.add(mi)
octree.finalize()
return octree
def to_octree(self, over_refine_factor = 1, dims = (1,1,1),
n_ref = 64):
mi = self.morton
mi.sort()
eps = np.finfo(self.dtype).eps
LE = self.min(axis=0)
LE -= np.abs(LE) * eps
RE = self.max(axis=0)
RE += np.abs(RE) * eps
octree = ParticleOctreeContainer(dims, LE, RE,
over_refine = over_refine_factor)
octree.n_ref = n_ref
octree.add(mi)
octree.finalize()
return octree
def particle_operation(self,
positions,
fields=None,
method=None,
nneighbors=64,
kernel_name='cubic'):
r"""Operate on particles, in a particle-against-particle fashion.
This uses the octree indexing system to call a "smoothing" operation
(defined in yt/geometry/particle_smooth.pyx) that expects to be called
in a particle-by-particle fashion. For instance, the canonical example
of this would be to compute the Nth nearest neighbor, or to compute the
density for a given particle based on some kernel operation.
Many of the arguments to this are identical to those used in the smooth
and deposit functions. Note that the `fields` argument must not be
empty, as these fields will be modified in place.
Parameters
----------
positions : array_like (Nx3)
The positions of all of the particles to be examined. A new
indexed octree will be constructed on these particles.
fields : list of arrays
All the necessary fields for computing the particle operation. For
instance, this might include mass, velocity, etc. One of these
will likely be modified in place.
method : string
This is the "method name" which will be looked up in the
`particle_smooth` namespace as `methodname_smooth`.
nneighbors : int, default 64
The number of neighbors to examine during the process.
kernel_name : string, default 'cubic'
This is the name of the smoothing kernel to use. Current supported
kernel names include `cubic`, `quartic`, `quintic`, `wendland2`,
`wendland4`, and `wendland6`.
Returns
-------
Nothing.
"""
# Here we perform our particle deposition.
positions.convert_to_units("code_length")
morton = compute_morton(positions[:, 0], positions[:, 1],
positions[:, 2], self.ds.domain_left_edge,
self.ds.domain_right_edge)
morton.sort()
particle_octree = ParticleOctreeContainer([1, 1, 1],
self.ds.domain_left_edge,
self.ds.domain_right_edge,
over_refine=1)
particle_octree.n_ref = nneighbors * 2
particle_octree.add(morton)
particle_octree.finalize()
pdom_ind = particle_octree.domain_ind(self.selector)
if fields is None: fields = []
cls = getattr(particle_smooth, "%s_smooth" % method, None)
if cls is None:
raise YTParticleDepositionNotImplemented(method)
nz = self.nz
mdom_ind = self.domain_ind
nvals = (nz, nz, nz, (mdom_ind >= 0).sum())
op = cls(nvals, len(fields), nneighbors, kernel_name)
op.initialize()
mylog.debug("Smoothing %s particles into %s Octs", positions.shape[0],
nvals[-1])
op.process_particles(particle_octree, pdom_ind, positions, fields,
self.domain_id, self._domain_offset,
self.ds.periodicity, self.ds.geometry)
vals = op.finalize()
if vals is None: return
if isinstance(vals, list):
vals = [np.asfortranarray(v) for v in vals]
else:
vals = np.asfortranarray(vals)
return vals
def smooth(self,
positions,
fields=None,
index_fields=None,
method=None,
create_octree=False,
nneighbors=64,
kernel_name='cubic'):
r"""Operate on the mesh, in a particle-against-mesh fashion, with
non-local input.
This uses the octree indexing system to call a "smoothing" operation
(defined in yt/geometry/particle_smooth.pyx) that can take input from
several (non-local) particles and construct some value on the mesh.
The canonical example is to conduct a smoothing kernel operation on the
mesh.
Parameters
----------
positions : array_like (Nx3)
The positions of all of the particles to be examined. A new
indexed octree will be constructed on these particles.
fields : list of arrays
All the necessary fields for computing the particle operation. For
instance, this might include mass, velocity, etc.
index_fields : list of arrays
All of the fields defined on the mesh that may be used as input to
the operation.
method : string
This is the "method name" which will be looked up in the
`particle_smooth` namespace as `methodname_smooth`. Current
methods include `volume_weighted`, `nearest`, `idw`,
`nth_neighbor`, and `density`.
create_octree : bool
Should we construct a new octree for indexing the particles? In
cases where we are applying an operation on a subset of the
particles used to construct the mesh octree, this will ensure that
we are able to find and identify all relevant particles.
nneighbors : int, default 64
The number of neighbors to examine during the process.
kernel_name : string, default 'cubic'
This is the name of the smoothing kernel to use. Current supported
kernel names include `cubic`, `quartic`, `quintic`, `wendland2`,
`wendland4`, and `wendland6`.
Returns
-------
List of fortran-ordered, mesh-like arrays.
"""
# Here we perform our particle deposition.
positions.convert_to_units("code_length")
if create_octree:
morton = compute_morton(positions[:, 0], positions[:, 1],
positions[:, 2], self.ds.domain_left_edge,
self.ds.domain_right_edge)
morton.sort()
particle_octree = ParticleOctreeContainer(
[1, 1, 1],
self.ds.domain_left_edge,
self.ds.domain_right_edge,
over_refine=self._oref)
# This should ensure we get everything within one neighbor of home.
particle_octree.n_ref = nneighbors * 2
particle_octree.add(morton)
particle_octree.finalize()
pdom_ind = particle_octree.domain_ind(self.selector)
else:
particle_octree = self.oct_handler
pdom_ind = self.domain_ind
if fields is None: fields = []
if index_fields is None: index_fields = []
cls = getattr(particle_smooth, "%s_smooth" % method, None)
if cls is None:
raise YTParticleDepositionNotImplemented(method)
nz = self.nz
mdom_ind = self.domain_ind
nvals = (nz, nz, nz, (mdom_ind >= 0).sum())
op = cls(nvals, len(fields), nneighbors, kernel_name)
op.initialize()
mylog.debug("Smoothing %s particles into %s Octs", positions.shape[0],
nvals[-1])
# Pointer operations within 'process_octree' require arrays to be
# contiguous cf. https://bitbucket.org/yt_analysis/yt/issues/1079
fields = [np.ascontiguousarray(f, dtype="float64") for f in fields]
op.process_octree(self.oct_handler, mdom_ind, positions, self.fcoords,
fields, self.domain_id, self._domain_offset,
self.ds.periodicity, index_fields, particle_octree,
pdom_ind, self.ds.geometry)
# If there are 0s in the smoothing field this will not throw an error,
# but silently return nans for vals where dividing by 0
# Same as what is currently occurring, but suppressing the div by zero
# error.
with np.errstate(invalid='ignore'):
vals = op.finalize()
if vals is None: return
if isinstance(vals, list):
vals = [np.asfortranarray(v) for v in vals]
else:
vals = np.asfortranarray(vals)
return vals
def particle_operation(self, positions, fields = None,
method = None, nneighbors = 64):
r"""Operate on particles, in a particle-against-particle fashion.
This uses the octree indexing system to call a "smoothing" operation
(defined in yt/geometry/particle_smooth.pyx) that expects to be called
in a particle-by-particle fashion. For instance, the canonical example
of this would be to compute the Nth nearest neighbor, or to compute the
density for a given particle based on some kernel operation.
Many of the arguments to this are identical to those used in the smooth
and deposit functions. Note that the `fields` argument must not be
empty, as these fields will be modified in place.
Parameters
----------
positions : array_like (Nx3)
The positions of all of the particles to be examined. A new
indexed octree will be constructed on these particles.
fields : list of arrays
All the necessary fields for computing the particle operation. For
instance, this might include mass, velocity, etc. One of these
will likely be modified in place.
method : string
This is the "method name" which will be looked up in the
`particle_smooth` namespace as `methodname_smooth`.
nneighbors : int, default 64
The number of neighbors to examine during the process.
Returns
-------
Nothing.
"""
# Here we perform our particle deposition.
positions.convert_to_units("code_length")
morton = compute_morton(
positions[:,0], positions[:,1], positions[:,2],
self.ds.domain_left_edge,
self.ds.domain_right_edge)
morton.sort()
particle_octree = ParticleOctreeContainer([1, 1, 1],
self.ds.domain_left_edge,
self.ds.domain_right_edge,
over_refine = 1)
particle_octree.n_ref = nneighbors * 2
particle_octree.add(morton)
particle_octree.finalize()
pdom_ind = particle_octree.domain_ind(self.selector)
if fields is None: fields = []
cls = getattr(particle_smooth, "%s_smooth" % method, None)
if cls is None:
raise YTParticleDepositionNotImplemented(method)
nz = self.nz
mdom_ind = self.domain_ind
nvals = (nz, nz, nz, (mdom_ind >= 0).sum())
op = cls(nvals, len(fields), nneighbors)
op.initialize()
mylog.debug("Smoothing %s particles into %s Octs",
positions.shape[0], nvals[-1])
op.process_particles(particle_octree, pdom_ind, positions,
fields, self.domain_id, self._domain_offset, self.ds.periodicity,
self.ds.geometry)
vals = op.finalize()
if vals is None: return
if isinstance(vals, list):
vals = [np.asfortranarray(v) for v in vals]
else:
vals = np.asfortranarray(vals)
return vals
def smooth(self, positions, fields = None, index_fields = None,
method = None, create_octree = False, nneighbors = 64):
r"""Operate on the mesh, in a particle-against-mesh fashion, with
non-local input.
This uses the octree indexing system to call a "smoothing" operation
(defined in yt/geometry/particle_smooth.pyx) that can take input from
several (non-local) particles and construct some value on the mesh.
The canonical example is to conduct a smoothing kernel operation on the
mesh.
Parameters
----------
positions : array_like (Nx3)
The positions of all of the particles to be examined. A new
indexed octree will be constructed on these particles.
fields : list of arrays
All the necessary fields for computing the particle operation. For
instance, this might include mass, velocity, etc.
index_fields : list of arrays
All of the fields defined on the mesh that may be used as input to
the operation.
method : string
This is the "method name" which will be looked up in the
`particle_smooth` namespace as `methodname_smooth`. Current
methods include `volume_weighted`, `nearest`, `idw`,
`nth_neighbor`, and `density`.
create_octree : bool
Should we construct a new octree for indexing the particles? In
cases where we are applying an operation on a subset of the
particles used to construct the mesh octree, this will ensure that
we are able to find and identify all relevant particles.
nneighbors : int, default 64
The number of neighbors to examine during the process.
Returns
-------
List of fortran-ordered, mesh-like arrays.
"""
# Here we perform our particle deposition.
positions.convert_to_units("code_length")
if create_octree:
morton = compute_morton(
positions[:,0], positions[:,1], positions[:,2],
self.ds.domain_left_edge,
self.ds.domain_right_edge)
morton.sort()
particle_octree = ParticleOctreeContainer([1, 1, 1],
self.ds.domain_left_edge,
self.ds.domain_right_edge,
over_refine = self._oref)
# This should ensure we get everything within one neighbor of home.
particle_octree.n_ref = nneighbors * 2
particle_octree.add(morton)
particle_octree.finalize()
pdom_ind = particle_octree.domain_ind(self.selector)
else:
particle_octree = self.oct_handler
pdom_ind = self.domain_ind
if fields is None: fields = []
if index_fields is None: index_fields = []
cls = getattr(particle_smooth, "%s_smooth" % method, None)
if cls is None:
raise YTParticleDepositionNotImplemented(method)
nz = self.nz
mdom_ind = self.domain_ind
nvals = (nz, nz, nz, (mdom_ind >= 0).sum())
op = cls(nvals, len(fields), nneighbors)
op.initialize()
mylog.debug("Smoothing %s particles into %s Octs",
positions.shape[0], nvals[-1])
op.process_octree(self.oct_handler, mdom_ind, positions,
self.fcoords, fields,
self.domain_id, self._domain_offset, self.ds.periodicity,
index_fields, particle_octree, pdom_ind, self.ds.geometry)
# If there are 0s in the smoothing field this will not throw an error,
# but silently return nans for vals where dividing by 0
# Same as what is currently occurring, but suppressing the div by zero
# error.
with np.errstate(invalid='ignore'):
vals = op.finalize()
if vals is None: return
if isinstance(vals, list):
vals = [np.asfortranarray(v) for v in vals]
else:
vals = np.asfortranarray(vals)
return vals
