[yt-svn] commit/yt: 2 new changesets
Bitbucket
commits-noreply at bitbucket.org
Fri Oct 19 07:51:08 PDT 2012
2 new commits in yt:
https://bitbucket.org/yt_analysis/yt/changeset/47ed8fb04ea4/
changeset: 47ed8fb04ea4
branch: yt
user: samskillman
date: 2012-10-19 16:49:20
summary: Only reduce magnitudes if they were requested. closes issue 452.
affected #: 1 file
diff -r 598c0df9255853854419600c60ea09246a404213 -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 yt/visualization/streamlines.py
--- a/yt/visualization/streamlines.py
+++ b/yt/visualization/streamlines.py
@@ -146,7 +146,8 @@
@parallel_passthrough
def _finalize_parallel(self,data):
self.streamlines = self.comm.mpi_allreduce(self.streamlines, op='sum')
- self.magnitudes = self.comm.mpi_allreduce(self.magnitudes, op='sum')
+ if self.get_magnitude:
+ self.magnitudes = self.comm.mpi_allreduce(self.magnitudes, op='sum')
def _integrate_through_brick(self, node, stream, step,
periodic=False, mag=None):
https://bitbucket.org/yt_analysis/yt/changeset/56c2d60a99c7/
changeset: 56c2d60a99c7
branch: yt
user: samskillman
date: 2012-10-19 16:50:14
summary: Merging
affected #: 18 files
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 MANIFEST.in
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,3 +1,3 @@
-include distribute_setup.py
+include distribute_setup.py README* CREDITS FUNDING LICENSE.txt
recursive-include yt/gui/reason/html *.html *.png *.ico *.js
-recursive-include yt *.pyx *.pxd *.hh *.h README* CREDITS FUNDING LICENSE
+recursive-include yt *.pyx *.pxd *.hh *.h README*
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/analysis_modules/halo_profiler/multi_halo_profiler.py
--- a/yt/analysis_modules/halo_profiler/multi_halo_profiler.py
+++ b/yt/analysis_modules/halo_profiler/multi_halo_profiler.py
@@ -606,6 +606,7 @@
if newProfile:
mylog.info("Writing halo %d" % halo['id'])
+ if os.path.exists(filename): os.remove(filename)
if filename.endswith('.h5'):
profile.write_out_h5(filename)
else:
@@ -717,7 +718,9 @@
Default=True.
njobs : int
The number of jobs over which to split the projections. Set
- to -1 so that each halo is done by a single processor.
+ to -1 so that each halo is done by a single processor. Halo
+ projections do not currently work in parallel, so this must
+ be set to -1.
Default: -1.
dynamic : bool
If True, distribute halos using a task queue. If False,
@@ -731,6 +734,12 @@
"""
+ # Halo projections cannot run in parallel because they are done by
+ # giving a data source to the projection object.
+ if njobs > 0:
+ mylog.warn("Halo projections cannot use more than one processor per halo, setting njobs to -1.")
+ njobs = -1
+
# Get list of halos for projecting.
if halo_list == 'filtered':
halo_projection_list = self.filtered_halos
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/data_objects/data_containers.py
--- a/yt/data_objects/data_containers.py
+++ b/yt/data_objects/data_containers.py
@@ -237,6 +237,7 @@
def __set_default_field_parameters(self):
self.set_field_parameter("center",np.zeros(3,dtype='float64'))
self.set_field_parameter("bulk_velocity",np.zeros(3,dtype='float64'))
+ self.set_field_parameter("normal",np.array([0,0,1],dtype='float64'))
def _set_center(self, center):
if center is None:
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/data_objects/derived_quantities.py
--- a/yt/data_objects/derived_quantities.py
+++ b/yt/data_objects/derived_quantities.py
@@ -598,16 +598,16 @@
continue
else:
nz_filter = None
- mins.append(data[field][nz_filter].min())
- maxs.append(data[field][nz_filter].max())
+ mins.append(np.nanmin(data[field][nz_filter]))
+ maxs.append(np.nanmax(data[field][nz_filter]))
else:
if this_filter.any():
if non_zero:
nz_filter = ((this_filter) &
(data[field][this_filter] > 0.0))
else: nz_filter = this_filter
- mins.append(data[field][nz_filter].min())
- maxs.append(data[field][nz_filter].max())
+ mins.append(np.nanmin(data[field][nz_filter]))
+ maxs.append(np.nanmax(data[field][nz_filter]))
else:
mins.append(1e90)
maxs.append(-1e90)
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/data_objects/field_info_container.py
--- a/yt/data_objects/field_info_container.py
+++ b/yt/data_objects/field_info_container.py
@@ -160,7 +160,8 @@
# required attrs
pf = fake_parameter_file(lambda: 1)
pf.current_redshift = pf.omega_lambda = pf.omega_matter = \
- pf.hubble_constant = pf.cosmological_simulation = 0.0
+ pf.cosmological_simulation = 0.0
+ pf.hubble_constant = 0.7
pf.domain_left_edge = np.zeros(3, 'float64')
pf.domain_right_edge = np.ones(3, 'float64')
pf.dimensionality = 3
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/data_objects/tests/test_derived_quantities.py
--- /dev/null
+++ b/yt/data_objects/tests/test_derived_quantities.py
@@ -0,0 +1,24 @@
+from yt.testing import *
+import numpy as np
+
+def setup():
+ from yt.config import ytcfg
+ ytcfg["yt","__withintesting"] = "True"
+
+def test_extrema():
+ for nprocs in [1, 2, 4, 8]:
+ pf = fake_random_pf(16, nprocs = nprocs, fields = ("Density",
+ "x-velocity", "y-velocity", "z-velocity"))
+ sp = pf.h.sphere("c", (0.25, '1'))
+ (mi, ma), = sp.quantities["Extrema"]("Density")
+ yield assert_equal, mi, np.nanmin(sp["Density"])
+ yield assert_equal, ma, np.nanmax(sp["Density"])
+ dd = pf.h.all_data()
+ (mi, ma), = dd.quantities["Extrema"]("Density")
+ yield assert_equal, mi, np.nanmin(dd["Density"])
+ yield assert_equal, ma, np.nanmax(dd["Density"])
+ sp = pf.h.sphere("max", (0.25, '1'))
+ yield assert_equal, np.any(np.isnan(sp["RadialVelocity"])), True
+ (mi, ma), = dd.quantities["Extrema"]("RadialVelocity")
+ yield assert_equal, mi, np.nanmin(dd["RadialVelocity"])
+ yield assert_equal, ma, np.nanmax(dd["RadialVelocity"])
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/data_objects/tests/test_fields.py
--- /dev/null
+++ b/yt/data_objects/tests/test_fields.py
@@ -0,0 +1,91 @@
+from yt.testing import *
+import numpy as np
+from yt.data_objects.field_info_container import \
+ FieldInfo
+import yt.data_objects.universal_fields
+from yt.utilities.definitions import \
+ mpc_conversion, sec_conversion
+
+def setup():
+ from yt.config import ytcfg
+ ytcfg["yt","__withintesting"] = "True"
+ np.seterr(all = 'ignore')
+
+_sample_parameters = dict(
+ axis = 0,
+ center = np.array((0.0, 0.0, 0.0)),
+ bulk_velocity = np.array((0.0, 0.0, 0.0)),
+ normal = np.array((0.0, 0.0, 1.0)),
+ cp_x_vec = np.array((1.0, 0.0, 0.0)),
+ cp_y_vec = np.array((0.0, 1.0, 0.0)),
+ cp_z_vec = np.array((0.0, 0.0, 1.0)),
+)
+
+_base_fields = ["Density", "x-velocity", "y-velocity", "z-velocity"]
+
+def realistic_pf(fields, nprocs):
+ pf = fake_random_pf(16, fields = fields, nprocs = nprocs)
+ pf.parameters["HydroMethod"] = "streaming"
+ pf.parameters["Gamma"] = 5.0/3.0
+ pf.parameters["EOSType"] = 1.0
+ pf.parameters["EOSSoundSpeed"] = 1.0
+ pf.conversion_factors["Time"] = 1.0
+ pf.conversion_factors.update( dict((f, 1.0) for f in fields) )
+ pf.current_redshift = 0.0001
+ pf.hubble_constant = 0.7
+ for unit in mpc_conversion:
+ pf.units[unit+'h'] = pf.units[unit]
+ pf.units[unit+'cm'] = pf.units[unit]
+ pf.units[unit+'hcm'] = pf.units[unit]
+ return pf
+
+class TestFieldAccess(object):
+ description = None
+
+ def __init__(self, field_name, nproc):
+ # Note this should be a field name
+ self.field_name = field_name
+ self.description = "Accessing_%s_%s" % (field_name, nproc)
+ self.nproc = nproc
+
+ def __call__(self):
+ field = FieldInfo[self.field_name]
+ deps = field.get_dependencies()
+ fields = deps.requested + _base_fields
+ skip_grids = False
+ needs_spatial = False
+ for v in field.validators:
+ f = getattr(v, "fields", None)
+ if f: fields += f
+ if getattr(v, "ghost_zones", 0) > 0:
+ skip_grids = True
+ if hasattr(v, "ghost_zones"):
+ needs_spatial = True
+ pf = realistic_pf(fields, self.nproc)
+ # This gives unequal sized grids as well as subgrids
+ dd1 = pf.h.all_data()
+ dd2 = pf.h.all_data()
+ dd1.field_parameters.update(_sample_parameters)
+ dd2.field_parameters.update(_sample_parameters)
+ v1 = dd1[self.field_name]
+ conv = field._convert_function(dd1) or 1.0
+ if not needs_spatial:
+ assert_equal(v1, conv*field._function(field, dd2))
+ if not skip_grids:
+ for g in pf.h.grids:
+ g.field_parameters.update(_sample_parameters)
+ conv = field._convert_function(g) or 1.0
+ v1 = g[self.field_name]
+ g.clear_data()
+ g.field_parameters.update(_sample_parameters)
+ assert_equal(v1, conv*field._function(field, g))
+
+def test_all_fields():
+ for field in FieldInfo:
+ if field.startswith("CuttingPlane"): continue
+ if field.startswith("particle"): continue
+ if field.startswith("CIC"): continue
+ if field.startswith("WeakLensingConvergence"): continue
+ if FieldInfo[field].particle_type: continue
+ for nproc in [1, 4, 8]:
+ yield TestFieldAccess(field, nproc)
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/data_objects/tests/test_ortho_rays.py
--- /dev/null
+++ b/yt/data_objects/tests/test_ortho_rays.py
@@ -0,0 +1,25 @@
+from yt.testing import *
+
+def test_ortho_ray():
+ pf = fake_random_pf(64, nprocs=8)
+ dx = (pf.domain_right_edge - pf.domain_left_edge) / \
+ pf.domain_dimensions
+
+ axes = ['x', 'y', 'z']
+ for ax, an in enumerate(axes):
+ ocoord = np.random.random(2)
+
+ my_oray = pf.h.ortho_ray(ax, ocoord)
+
+ my_axes = range(3)
+ del my_axes[ax]
+
+ # find the cells intersected by the ortho ray
+ my_all = pf.h.all_data()
+ my_cells = (np.abs(my_all[axes[my_axes[0]]] - ocoord[0]) <=
+ 0.5 * dx[my_axes[0]]) & \
+ (np.abs(my_all[axes[my_axes[1]]] - ocoord[1]) <=
+ 0.5 * dx[my_axes[1]])
+
+ assert_equal(my_oray['Density'].sum(),
+ my_all['Density'][my_cells].sum())
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/data_objects/tests/test_rays.py
--- /dev/null
+++ b/yt/data_objects/tests/test_rays.py
@@ -0,0 +1,31 @@
+from yt.testing import *
+
+def test_ray():
+ pf = fake_random_pf(64, nprocs=8)
+ dx = (pf.domain_right_edge - pf.domain_left_edge) / \
+ pf.domain_dimensions
+
+ p1 = np.random.random(3)
+ p2 = np.random.random(3)
+
+ my_ray = pf.h.ray(p1, p2)
+ assert_rel_equal(my_ray['dts'].sum(), 1.0, 14)
+ ray_cells = my_ray['dts'] > 0
+
+ # find cells intersected by the ray
+ my_all = pf.h.all_data()
+
+ dt = np.abs(dx / (p2 - p1))
+ tin = np.concatenate([[(my_all['x'] - p1[0]) / (p2 - p1)[0] - 0.5 * dt[0]],
+ [(my_all['y'] - p1[1]) / (p2 - p1)[1] - 0.5 * dt[1]],
+ [(my_all['z'] - p1[2]) / (p2 - p1)[2] - 0.5 * dt[2]]])
+ tout = np.concatenate([[(my_all['x'] - p1[0]) / (p2 - p1)[0] + 0.5 * dt[0]],
+ [(my_all['y'] - p1[1]) / (p2 - p1)[1] + 0.5 * dt[1]],
+ [(my_all['z'] - p1[2]) / (p2 - p1)[2] + 0.5 * dt[2]]])
+ tin = tin.max(axis=0)
+ tout = tout.min(axis=0)
+ my_cells = (tin < tout) & (tin < 1) & (tout > 0)
+
+ assert_rel_equal(ray_cells.sum(), my_cells.sum(), 14)
+ assert_rel_equal(my_ray['Density'][ray_cells].sum(),
+ my_all['Density'][my_cells].sum(), 14)
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/data_objects/universal_fields.py
--- a/yt/data_objects/universal_fields.py
+++ b/yt/data_objects/universal_fields.py
@@ -32,7 +32,7 @@
from yt.funcs import *
-from yt.utilities.lib import CICDeposit_3, obtain_rvec
+from yt.utilities.lib import CICDeposit_3, obtain_rvec, obtain_rv_vec
from yt.utilities.cosmology import Cosmology
from field_info_container import \
add_field, \
@@ -54,7 +54,19 @@
kboltz, \
G, \
rho_crit_now, \
- speed_of_light_cgs
+ speed_of_light_cgs, \
+ km_per_cm
+
+from yt.utilities.math_utils import \
+ get_sph_r_component, \
+ get_sph_theta_component, \
+ get_sph_phi_component, \
+ get_cyl_r_component, \
+ get_cyl_z_component, \
+ get_cyl_theta_component, \
+ get_cyl_r, get_cyl_theta, \
+ get_cyl_z, get_sph_r, \
+ get_sph_theta, get_sph_phi
# Note that, despite my newfound efforts to comply with PEP-8,
# I violate it here in order to keep the name/func_name relationship
@@ -179,12 +191,8 @@
def _VelocityMagnitude(field, data):
"""M{|v|}"""
- bulk_velocity = data.get_field_parameter("bulk_velocity")
- if bulk_velocity == None:
- bulk_velocity = np.zeros(3)
- return ( (data["x-velocity"]-bulk_velocity[0])**2.0 + \
- (data["y-velocity"]-bulk_velocity[1])**2.0 + \
- (data["z-velocity"]-bulk_velocity[2])**2.0 )**(1.0/2.0)
+ velocities = obtain_rv_vec(data)
+ return np.sqrt(np.sum(velocities**2,axis=0))
add_field("VelocityMagnitude", function=_VelocityMagnitude,
take_log=False, units=r"\rm{cm}/\rm{s}")
@@ -194,13 +202,6 @@
function=_TangentialOverVelocityMagnitude,
take_log=False)
-def _TangentialVelocity(field, data):
- return np.sqrt(data["VelocityMagnitude"]**2.0
- - data["RadialVelocity"]**2.0)
-add_field("TangentialVelocity",
- function=_TangentialVelocity,
- take_log=False, units=r"\rm{cm}/\rm{s}")
-
def _Pressure(field, data):
"""M{(Gamma-1.0)*rho*E}"""
return (data.pf["Gamma"] - 1.0) * \
@@ -223,14 +224,9 @@
def _sph_r(field, data):
center = data.get_field_parameter("center")
- coords = np.array([data['x'] - center[0],
- data['y'] - center[1],
- data['z'] - center[2]]).transpose()
+ coords = obtain_rvec(data)
- ## The spherical coordinates radius is simply the magnitude of the
- ## coords vector.
-
- return np.sqrt(np.sum(coords**2,axis=-1))
+ return get_sph_r(coords)
def _Convert_sph_r_CGS(data):
return data.convert("cm")
@@ -245,20 +241,9 @@
center = data.get_field_parameter("center")
normal = data.get_field_parameter("normal")
- coords = np.array([data['x'] - center[0],
- data['y'] - center[1],
- data['z'] - center[2]]).transpose()
+ coords = obtain_rvec(data)
- ## The angle (theta) with respect to the normal (J), is the arccos
- ## of the dot product of the normal with the normalized coords
- ## vector.
-
- tile_shape = list(coords.shape)[:-1] + [1]
- J = np.tile(normal,tile_shape)
-
- JdotCoords = np.sum(J*coords,axis=-1)
-
- return np.arccos( JdotCoords / np.sqrt(np.sum(coords**2,axis=-1)) )
+ return get_sph_theta(coords, normal)
add_field("sph_theta", function=_sph_theta,
validators=[ValidateParameter("center"),ValidateParameter("normal")])
@@ -269,54 +254,21 @@
center = data.get_field_parameter("center")
normal = data.get_field_parameter("normal")
- coords = np.array([data['x'] - center[0],
- data['y'] - center[1],
- data['z'] - center[2]]).transpose()
-
- ## We have freedom with respect to what axis (xprime) to define
- ## the disk angle. Here I've chosen to use the axis that is
- ## perpendicular to the normal and the y-axis. When normal ==
- ## y-hat, then set xprime = z-hat. With this definition, when
- ## normal == z-hat (as is typical), then xprime == x-hat.
- ##
- ## The angle is then given by the arctan of the ratio of the
- ## yprime-component and the xprime-component of the coords vector.
+ coords = obtain_rvec(data)
- xprime = np.cross([0.0,1.0,0.0],normal)
- if np.sum(xprime) == 0: xprime = np.array([0.0, 0.0, 1.0])
- yprime = np.cross(normal,xprime)
-
- tile_shape = list(coords.shape)[:-1] + [1]
- Jx = np.tile(xprime,tile_shape)
- Jy = np.tile(yprime,tile_shape)
-
- Px = np.sum(Jx*coords,axis=-1)
- Py = np.sum(Jy*coords,axis=-1)
-
- return np.arctan2(Py,Px)
+ return get_sph_phi(coords, normal)
add_field("sph_phi", function=_sph_phi,
validators=[ValidateParameter("center"),ValidateParameter("normal")])
-
-
### cylindrical coordinates: R (radius in the cylinder's plane)
def _cyl_R(field, data):
center = data.get_field_parameter("center")
normal = data.get_field_parameter("normal")
- coords = np.array([data['x'] - center[0],
- data['y'] - center[1],
- data['z'] - center[2]]).transpose()
+ coords = obtain_rvec(data)
- ## The cross product of the normal (J) with the coords vector
- ## gives a vector of magnitude equal to the cylindrical radius.
-
- tile_shape = list(coords.shape)[:-1] + [1]
- J = np.tile(normal,tile_shape)
-
- JcrossCoords = np.cross(J,coords)
- return np.sqrt(np.sum(JcrossCoords**2,axis=-1))
+ return get_cyl_r(coords, normal)
def _Convert_cyl_R_CGS(data):
return data.convert("cm")
@@ -324,6 +276,9 @@
add_field("cyl_R", function=_cyl_R,
validators=[ValidateParameter("center"),ValidateParameter("normal")],
convert_function = _Convert_cyl_R_CGS, units=r"\rm{cm}")
+add_field("cyl_RCode", function=_cyl_R,
+ validators=[ValidateParameter("center"),ValidateParameter("normal")],
+ units=r"Radius (code)")
### cylindrical coordinates: z (height above the cylinder's plane)
@@ -331,17 +286,9 @@
center = data.get_field_parameter("center")
normal = data.get_field_parameter("normal")
- coords = np.array([data['x'] - center[0],
- data['y'] - center[1],
- data['z'] - center[2]]).transpose()
+ coords = obtain_rvec(data)
- ## The dot product of the normal (J) with the coords vector gives
- ## the cylindrical height.
-
- tile_shape = list(coords.shape)[:-1] + [1]
- J = np.tile(normal,tile_shape)
-
- return np.sum(J*coords,axis=-1)
+ return get_cyl_z(coords, normal)
def _Convert_cyl_z_CGS(data):
return data.convert("cm")
@@ -352,14 +299,17 @@
### cylindrical coordinates: theta (angle in the cylinder's plane)
-### [This is identical to the spherical coordinate's 'phi' angle.]
def _cyl_theta(field, data):
- return data['sph_phi']
+ center = data.get_field_parameter("center")
+ normal = data.get_field_parameter("normal")
+
+ coords = obtain_rvec(data)
+
+ return get_cyl_theta(coords, normal)
add_field("cyl_theta", function=_cyl_theta,
validators=[ValidateParameter("center"),ValidateParameter("normal")])
-
### The old field DiskAngle is the same as the spherical coordinates'
### 'theta' angle. I'm keeping DiskAngle for backwards compatibility.
def _DiskAngle(field, data):
@@ -392,6 +342,54 @@
ValidateParameter("normal")],
units=r"AU", display_field=False)
+def _cyl_RadialVelocity(field, data):
+ normal = data.get_field_parameter("normal")
+ velocities = obtain_rv_vec(data)
+
+ theta = data['cyl_theta']
+
+ return get_cyl_r_component(velocities, theta, normal)
+
+def _cyl_RadialVelocityABS(field, data):
+ return np.abs(_cyl_RadialVelocity(field, data))
+def _Convert_cyl_RadialVelocityKMS(data):
+ return km_per_cm
+add_field("cyl_RadialVelocity", function=_cyl_RadialVelocity,
+ units=r"\rm{cm}/\rm{s}",
+ validators=[ValidateParameter("normal")])
+add_field("cyl_RadialVelocityABS", function=_cyl_RadialVelocityABS,
+ units=r"\rm{cm}/\rm{s}",
+ validators=[ValidateParameter("normal")])
+add_field("cyl_RadialVelocityKMS", function=_cyl_RadialVelocity,
+ convert_function=_Convert_cyl_RadialVelocityKMS, units=r"\rm{km}/\rm{s}",
+ validators=[ValidateParameter("normal")])
+add_field("cyl_RadialVelocityKMSABS", function=_cyl_RadialVelocityABS,
+ convert_function=_Convert_cyl_RadialVelocityKMS, units=r"\rm{km}/\rm{s}",
+ validators=[ValidateParameter("normal")])
+
+def _cyl_TangentialVelocity(field, data):
+ normal = data.get_field_parameter("normal")
+ velocities = obtain_rv_vec(data)
+ theta = data['cyl_theta']
+
+ return get_cyl_theta_component(velocities, theta, normal)
+
+def _cyl_TangentialVelocityABS(field, data):
+ return np.abs(_cyl_TangentialVelocity(field, data))
+def _Convert_cyl_TangentialVelocityKMS(data):
+ return km_per_cm
+add_field("cyl_TangentialVelocity", function=_cyl_TangentialVelocity,
+ units=r"\rm{cm}/\rm{s}",
+ validators=[ValidateParameter("normal")])
+add_field("cyl_TangentialVelocityABS", function=_cyl_TangentialVelocityABS,
+ units=r"\rm{cm}/\rm{s}",
+ validators=[ValidateParameter("normal")])
+add_field("cyl_TangentialVelocityKMS", function=_cyl_TangentialVelocity,
+ convert_function=_Convert_cyl_TangentialVelocityKMS, units=r"\rm{km}/\rm{s}",
+ validators=[ValidateParameter("normal")])
+add_field("cyl_TangentialVelocityKMSABS", function=_cyl_TangentialVelocityABS,
+ convert_function=_Convert_cyl_TangentialVelocityKMS, units=r"\rm{km}/\rm{s}",
+ validators=[ValidateParameter("normal")])
def _DynamicalTime(field, data):
"""
@@ -450,7 +448,7 @@
# This is rho_total / rho_cr(z).
def _Convert_Overdensity(data):
- return 1 / (rho_crit_now * data.pf.hubble_constant**2 *
+ return 1.0 / (rho_crit_now * data.pf.hubble_constant**2 *
(1+data.pf.current_redshift)**3)
add_field("Overdensity",function=_Matter_Density,
convert_function=_Convert_Overdensity, units=r"")
@@ -470,8 +468,8 @@
else:
omega_baryon_now = 0.0441
return data['Density'] / (omega_baryon_now * rho_crit_now *
- (data.pf['CosmologyHubbleConstantNow']**2) *
- ((1+data.pf['CosmologyCurrentRedshift'])**3))
+ (data.pf.hubble_constant**2) *
+ ((1+data.pf.current_redshift)**3))
add_field("Baryon_Overdensity", function=_Baryon_Overdensity,
units=r"")
@@ -640,13 +638,7 @@
take_log=False, display_field=False)
def obtain_velocities(data):
- if data.has_field_parameter("bulk_velocity"):
- bv = data.get_field_parameter("bulk_velocity")
- else: bv = np.zeros(3, dtype='float64')
- xv = data["x-velocity"] - bv[0]
- yv = data["y-velocity"] - bv[1]
- zv = data["z-velocity"] - bv[2]
- return xv, yv, zv
+ return obtain_rv_vec(data)
def _convertSpecificAngularMomentum(data):
return data.convert("cm")
@@ -711,7 +703,7 @@
# convert_function=_convertSpecificAngularMomentum, vector_field=True,
# units=r"\rm{cm}^2/\rm{s}", validators=[ValidateParameter('center')])
def _convertSpecificAngularMomentumKMSMPC(data):
- return data.convert("mpc")/1e5
+ return km_per_cm*data.convert("mpc")
#add_field("ParticleSpecificAngularMomentumKMSMPC",
# function=_ParticleSpecificAngularMomentum, particle_type=True,
# convert_function=_convertSpecificAngularMomentumKMSMPC, vector_field=True,
@@ -883,33 +875,32 @@
display_name = "Radius (code)")
def _RadialVelocity(field, data):
- center = data.get_field_parameter("center")
- bulk_velocity = data.get_field_parameter("bulk_velocity")
- if bulk_velocity == None:
- bulk_velocity = np.zeros(3)
- new_field = ( (data['x']-center[0])*(data["x-velocity"]-bulk_velocity[0])
- + (data['y']-center[1])*(data["y-velocity"]-bulk_velocity[1])
- + (data['z']-center[2])*(data["z-velocity"]-bulk_velocity[2])
- )/data["RadiusCode"]
- if np.any(np.isnan(new_field)): # to fix center = point
- new_field[np.isnan(new_field)] = 0.0
- return new_field
+ normal = data.get_field_parameter("normal")
+ velocities = obtain_rv_vec(data)
+ theta = data['sph_theta']
+ phi = data['sph_phi']
+
+ return get_sph_r_component(velocities, theta, phi, normal)
+
def _RadialVelocityABS(field, data):
return np.abs(_RadialVelocity(field, data))
def _ConvertRadialVelocityKMS(data):
- return 1e-5
+ return km_per_cm
add_field("RadialVelocity", function=_RadialVelocity,
- units=r"\rm{cm}/\rm{s}",
- validators=[ValidateParameter("center")])
+ units=r"\rm{cm}/\rm{s}")
add_field("RadialVelocityABS", function=_RadialVelocityABS,
- units=r"\rm{cm}/\rm{s}",
- validators=[ValidateParameter("center")])
+ units=r"\rm{cm}/\rm{s}")
add_field("RadialVelocityKMS", function=_RadialVelocity,
- convert_function=_ConvertRadialVelocityKMS, units=r"\rm{km}/\rm{s}",
- validators=[ValidateParameter("center")])
+ convert_function=_ConvertRadialVelocityKMS, units=r"\rm{km}/\rm{s}")
add_field("RadialVelocityKMSABS", function=_RadialVelocityABS,
- convert_function=_ConvertRadialVelocityKMS, units=r"\rm{km}/\rm{s}",
- validators=[ValidateParameter("center")])
+ convert_function=_ConvertRadialVelocityKMS, units=r"\rm{km}/\rm{s}")
+
+def _TangentialVelocity(field, data):
+ return np.sqrt(data["VelocityMagnitude"]**2.0
+ - data["RadialVelocity"]**2.0)
+add_field("TangentialVelocity",
+ function=_TangentialVelocity,
+ take_log=False, units=r"\rm{cm}/\rm{s}")
def _CuttingPlaneVelocityX(field, data):
x_vec, y_vec, z_vec = [data.get_field_parameter("cp_%s_vec" % (ax))
@@ -1026,6 +1017,47 @@
display_name=r"\rm{Magnetic}\/\rm{Energy}",
units="\rm{ergs}\/\rm{cm}^{-3}")
+def _BPoloidal(field,data):
+ normal = data.get_field_parameter("normal")
+
+ Bfields = np.array([data['Bx'], data['By'], data['Bz']])
+
+ theta = data['sph_theta']
+ phi = data['sph_phi']
+
+ return get_sph_theta_component(Bfields, theta, phi, normal)
+
+add_field("BPoloidal", function=_BPoloidal,
+ units=r"\rm{Gauss}",
+ validators=[ValidateParameter("normal")])
+
+def _BToroidal(field,data):
+ normal = data.get_field_parameter("normal")
+
+ Bfields = np.array([data['Bx'], data['By'], data['Bz']])
+
+ phi = data['sph_phi']
+
+ return get_sph_phi_component(Bfields, phi, normal)
+
+add_field("BToroidal", function=_BToroidal,
+ units=r"\rm{Gauss}",
+ validators=[ValidateParameter("normal")])
+
+def _BRadial(field,data):
+ normal = data.get_field_parameter("normal")
+
+ Bfields = np.array([data['Bx'], data['By'], data['Bz']])
+
+ theta = data['sph_theta']
+ phi = data['sph_phi']
+
+ return get_sph_r_component(Bfields, theta, phi, normal)
+
+add_field("BRadial", function=_BPoloidal,
+ units=r"\rm{Gauss}",
+ validators=[ValidateParameter("normal")])
+
def _VorticitySquared(field, data):
mylog.debug("Generating vorticity on %s", data)
# We need to set up stencils
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/testing.py
--- a/yt/testing.py
+++ b/yt/testing.py
@@ -26,10 +26,10 @@
from yt.funcs import *
from numpy.testing import assert_array_equal, assert_almost_equal, \
assert_approx_equal, assert_array_almost_equal, assert_equal, \
- assert_string_equal
+ assert_array_less, assert_string_equal, assert_array_almost_equal_nulp
-def assert_rel_equal(a1, a2, decimels):
- return assert_almost_equal(a1/a2, 1.0, decimels)
+def assert_rel_equal(a1, a2, decimals):
+ return assert_almost_equal(a1/a2, 1.0, decimals)
def amrspace(extent, levels=7, cells=8):
"""Creates two numpy arrays representing the left and right bounds of
@@ -139,11 +139,16 @@
ndims = [ndims, ndims, ndims]
else:
assert(len(ndims) == 3)
- if negative:
- offset = 0.5
- else:
- offset = 0.0
+ if not iterable(negative):
+ negative = [negative for f in fields]
+ assert(len(fields) == len(negative))
+ offsets = []
+ for n in negative:
+ if n:
+ offsets.append(0.5)
+ else:
+ offsets.append(0.0)
data = dict((field, (np.random.random(ndims) - offset) * peak_value)
- for field in fields)
+ for field,offset in zip(fields,offsets))
ug = load_uniform_grid(data, ndims, 1.0, nprocs = nprocs)
return ug
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/utilities/decompose.py
--- a/yt/utilities/decompose.py
+++ b/yt/utilities/decompose.py
@@ -68,9 +68,12 @@
def evaluate_domain_decomposition(n_d, pieces, ldom):
""" Evaluate longest to shortest edge ratio
BEWARE: lot's of magic here """
- ideal_bsize = 3.0 * (pieces * np.product(n_d) ** 2) ** (1.0 / 3.0)
- bsize = int(np.sum(
- ldom / np.array(n_d, dtype=np.float64) * np.product(n_d)))
+ eff_dim = (n_d > 1).sum()
+ ideal_bsize = eff_dim * (pieces * np.product(n_d) ** (eff_dim - 1)
+ ) ** (1.0 / eff_dim)
+ mask = np.where(n_d > 1)
+ nd_arr = np.array(n_d, dtype=np.float64)[mask]
+ bsize = int(np.sum(ldom[mask] / nd_arr * np.product(nd_arr)))
load_balance = float(np.product(n_d)) / \
(float(pieces) * np.product((n_d - 1) / ldom + 1))
@@ -134,23 +137,15 @@
def split_array(tab, psize):
- """ Split array into px*py*pz subarrays using internal numpy routine. """
- temp = [np.array_split(array, psize[1], axis=1)
- for array in np.array_split(tab, psize[2], axis=2)]
- temp = [item for sublist in temp for item in sublist]
- temp = [np.array_split(array, psize[0], axis=0) for array in temp]
- temp = [item for sublist in temp for item in sublist]
- return temp
-
-
-if __name__ == "__main__":
-
- NPROC = 12
- ARRAY = np.zeros((128, 128, 129))
- BBOX = np.array([[0., 1.0], [-1.5, 1.5], [1.0, 2.5]])
-
- PROCS = get_psize(np.array(ARRAY.shape), NPROC)
- LE, RE, DATA = decompose_array(ARRAY, PROCS, BBOX)
-
- for idx in range(NPROC):
- print LE[idx, :], RE[idx, :], DATA[idx].shape
+ """ Split array into px*py*pz subarrays. """
+ n_d = np.array(tab.shape, dtype=np.int64)
+ slices = []
+ for i in range(psize[0]):
+ for j in range(psize[1]):
+ for k in range(psize[2]):
+ piece = np.array((i, j, k), dtype=np.int64)
+ lei = n_d * piece / psize
+ rei = n_d * (piece + np.ones(3, dtype=np.int64)) / psize
+ slices.append(np.s_[lei[0]:rei[0], lei[1]:
+ rei[1], lei[2]:rei[2]])
+ return [tab[slc] for slc in slices]
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/utilities/lib/geometry_utils.pyx
--- a/yt/utilities/lib/geometry_utils.pyx
+++ b/yt/utilities/lib/geometry_utils.pyx
@@ -338,3 +338,47 @@
rg[2,i,j,k] = zg[i,j,k] - c[2]
return rg
+ at cython.boundscheck(False)
+ at cython.wraparound(False)
+ at cython.cdivision(True)
+def obtain_rv_vec(data):
+ # This is just to let the pointers exist and whatnot. We can't cdef them
+ # inside conditionals.
+ cdef np.ndarray[np.float64_t, ndim=1] vxf
+ cdef np.ndarray[np.float64_t, ndim=1] vyf
+ cdef np.ndarray[np.float64_t, ndim=1] vzf
+ cdef np.ndarray[np.float64_t, ndim=2] rvf
+ cdef np.ndarray[np.float64_t, ndim=3] vxg
+ cdef np.ndarray[np.float64_t, ndim=3] vyg
+ cdef np.ndarray[np.float64_t, ndim=3] vzg
+ cdef np.ndarray[np.float64_t, ndim=4] rvg
+ cdef np.float64_t bv[3]
+ cdef int i, j, k
+ bulk_velocity = data.get_field_parameter("bulk_velocity")
+ if bulk_velocity == None:
+ bulk_velocity = np.zeros(3)
+ bv[0] = bulk_velocity[0]; bv[1] = bulk_velocity[1]; bv[2] = bulk_velocity[2]
+ if len(data['x-velocity'].shape) == 1:
+ # One dimensional data
+ vxf = data['x-velocity'].astype("float64")
+ vyf = data['y-velocity'].astype("float64")
+ vzf = data['z-velocity'].astype("float64")
+ rvf = np.empty((3, vxf.shape[0]), 'float64')
+ for i in range(vxf.shape[0]):
+ rvf[0, i] = vxf[i] - bv[0]
+ rvf[1, i] = vyf[i] - bv[1]
+ rvf[2, i] = vzf[i] - bv[2]
+ return rvf
+ else:
+ # Three dimensional data
+ vxg = data['x-velocity'].astype("float64")
+ vyg = data['y-velocity'].astype("float64")
+ vzg = data['z-velocity'].astype("float64")
+ rvg = np.empty((3, vxg.shape[0], vxg.shape[1], vxg.shape[2]), 'float64')
+ for i in range(vxg.shape[0]):
+ for j in range(vxg.shape[1]):
+ for k in range(vxg.shape[2]):
+ rvg[0,i,j,k] = vxg[i,j,k] - bv[0]
+ rvg[1,i,j,k] = vyg[i,j,k] - bv[1]
+ rvg[2,i,j,k] = vzg[i,j,k] - bv[2]
+ return rvg
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/utilities/lib/misc_utilities.pyx
--- a/yt/utilities/lib/misc_utilities.pyx
+++ b/yt/utilities/lib/misc_utilities.pyx
@@ -233,49 +233,6 @@
@cython.boundscheck(False)
@cython.wraparound(False)
@cython.cdivision(True)
-def obtain_rvec(data):
- # This is just to let the pointers exist and whatnot. We can't cdef them
- # inside conditionals.
- cdef np.ndarray[np.float64_t, ndim=1] xf
- cdef np.ndarray[np.float64_t, ndim=1] yf
- cdef np.ndarray[np.float64_t, ndim=1] zf
- cdef np.ndarray[np.float64_t, ndim=2] rf
- cdef np.ndarray[np.float64_t, ndim=3] xg
- cdef np.ndarray[np.float64_t, ndim=3] yg
- cdef np.ndarray[np.float64_t, ndim=3] zg
- cdef np.ndarray[np.float64_t, ndim=4] rg
- cdef np.float64_t c[3]
- cdef int i, j, k
- center = data.get_field_parameter("center")
- c[0] = center[0]; c[1] = center[1]; c[2] = center[2]
- if len(data['x'].shape) == 1:
- # One dimensional data
- xf = data['x']
- yf = data['y']
- zf = data['z']
- rf = np.empty((3, xf.shape[0]), 'float64')
- for i in range(xf.shape[0]):
- rf[0, i] = xf[i] - c[0]
- rf[1, i] = yf[i] - c[1]
- rf[2, i] = zf[i] - c[2]
- return rf
- else:
- # Three dimensional data
- xg = data['x']
- yg = data['y']
- zg = data['z']
- rg = np.empty((3, xg.shape[0], xg.shape[1], xg.shape[2]), 'float64')
- for i in range(xg.shape[0]):
- for j in range(xg.shape[1]):
- for k in range(xg.shape[2]):
- rg[0,i,j,k] = xg[i,j,k] - c[0]
- rg[1,i,j,k] = yg[i,j,k] - c[1]
- rg[2,i,j,k] = zg[i,j,k] - c[2]
- return rg
-
- at cython.boundscheck(False)
- at cython.wraparound(False)
- at cython.cdivision(True)
def kdtree_get_choices(np.ndarray[np.float64_t, ndim=3] data,
np.ndarray[np.float64_t, ndim=1] l_corner,
np.ndarray[np.float64_t, ndim=1] r_corner):
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/utilities/lib/tests/test_geometry_utils.py
--- /dev/null
+++ b/yt/utilities/lib/tests/test_geometry_utils.py
@@ -0,0 +1,30 @@
+from yt.testing import *
+from yt.utilities.lib import obtain_rvec, obtain_rv_vec
+
+_fields = ("Density", "x-velocity", "y-velocity", "z-velocity")
+
+def test_obtain_rvec():
+ pf = fake_random_pf(64, nprocs=8, fields=_fields,
+ negative = [False, True, True, True])
+
+ dd = pf.h.sphere((0.5,0.5,0.5), 0.2)
+
+ coords = obtain_rvec(dd)
+
+ r = np.sqrt(np.sum(coords*coords,axis=0))
+
+ assert_array_less(r.max(), 0.2)
+
+ assert_array_less(0.0, r.min())
+
+def test_obtain_rv_vec():
+ pf = fake_random_pf(64, nprocs=8, fields=_fields,
+ negative = [False, True, True, True])
+
+ dd = pf.h.all_data()
+
+ vels = obtain_rv_vec(dd)
+
+ assert_array_equal(vels[0,:], dd['x-velocity'])
+ assert_array_equal(vels[1,:], dd['y-velocity'])
+ assert_array_equal(vels[2,:], dd['z-velocity'])
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/utilities/math_utils.py
--- a/yt/utilities/math_utils.py
+++ b/yt/utilities/math_utils.py
@@ -674,3 +674,191 @@
[uz*ux*(1-cost)-uy*sint, uz*uy*(1-cost)+ux*sint, cost+uz**2*(1-cost)]])
return R
+
+def get_ortho_basis(normal):
+ xprime = np.cross([0.0,1.0,0.0],normal)
+ if np.sum(xprime) == 0: xprime = np.array([0.0, 0.0, 1.0])
+ yprime = np.cross(normal,xprime)
+ zprime = normal
+ return (xprime, yprime, zprime)
+
+def get_sph_r(coords):
+ # The spherical coordinates radius is simply the magnitude of the
+ # coordinate vector.
+
+ return np.sqrt(np.sum(coords**2, axis=0))
+
+def resize_vector(vector,vector_array):
+ if len(vector_array.shape) == 4:
+ res_vector = np.resize(vector,(3,1,1,1))
+ else:
+ res_vector = np.resize(vector,(3,1))
+ return res_vector
+
+def get_sph_theta(coords, normal):
+ # The angle (theta) with respect to the normal (J), is the arccos
+ # of the dot product of the normal with the normalized coordinate
+ # vector.
+
+ res_normal = resize_vector(normal, coords)
+
+ tile_shape = [1] + list(coords.shape)[1:]
+
+ J = np.tile(res_normal,tile_shape)
+
+ JdotCoords = np.sum(J*coords,axis=0)
+
+ return np.arccos( JdotCoords / np.sqrt(np.sum(coords**2,axis=0)) )
+
+def get_sph_phi(coords, normal):
+ # We have freedom with respect to what axis (xprime) to define
+ # the disk angle. Here I've chosen to use the axis that is
+ # perpendicular to the normal and the y-axis. When normal ==
+ # y-hat, then set xprime = z-hat. With this definition, when
+ # normal == z-hat (as is typical), then xprime == x-hat.
+ #
+ # The angle is then given by the arctan of the ratio of the
+ # yprime-component and the xprime-component of the coordinate
+ # vector.
+
+ (xprime, yprime, zprime) = get_ortho_basis(normal)
+
+ res_xprime = resize_vector(xprime, coords)
+ res_yprime = resize_vector(yprime, coords)
+
+ tile_shape = [1] + list(coords.shape)[1:]
+ Jx = np.tile(res_xprime,tile_shape)
+ Jy = np.tile(res_yprime,tile_shape)
+
+ Px = np.sum(Jx*coords,axis=0)
+ Py = np.sum(Jy*coords,axis=0)
+
+ return np.arctan2(Py,Px)
+
+def get_cyl_r(coords, normal):
+ # The cross product of the normal (J) with a coordinate vector
+ # gives a vector of magnitude equal to the cylindrical radius.
+
+ res_normal = resize_vector(normal, coords)
+
+ tile_shape = [1] + list(coords.shape)[1:]
+ J = np.tile(res_normal, tile_shape)
+
+ JcrossCoords = np.cross(J, coords, axisa=0, axisb=0, axisc=0)
+ return np.sqrt(np.sum(JcrossCoords**2, axis=0))
+
+def get_cyl_z(coords, normal):
+ # The dot product of the normal (J) with the coordinate vector
+ # gives the cylindrical height.
+
+ res_normal = resize_vector(normal, coords)
+
+ tile_shape = [1] + list(coords.shape)[1:]
+ J = np.tile(res_normal, tile_shape)
+
+ return np.sum(J*coords, axis=0)
+
+def get_cyl_theta(coords, normal):
+ # This is identical to the spherical phi component
+
+ return get_sph_phi(coords, normal)
+
+
+def get_cyl_r_component(vectors, theta, normal):
+ # The r of a vector is the vector dotted with rhat
+
+ (xprime, yprime, zprime) = get_ortho_basis(normal)
+
+ res_xprime = resize_vector(xprime, vectors)
+ res_yprime = resize_vector(yprime, vectors)
+
+ tile_shape = [1] + list(vectors.shape)[1:]
+ Jx = np.tile(res_xprime,tile_shape)
+ Jy = np.tile(res_yprime,tile_shape)
+
+ rhat = Jx*np.cos(theta) + Jy*np.sin(theta)
+
+ return np.sum(vectors*rhat,axis=0)
+
+def get_cyl_theta_component(vectors, theta, normal):
+ # The theta component of a vector is the vector dotted with thetahat
+
+ (xprime, yprime, zprime) = get_ortho_basis(normal)
+
+ res_xprime = resize_vector(xprime, vectors)
+ res_yprime = resize_vector(yprime, vectors)
+
+ tile_shape = [1] + list(vectors.shape)[1:]
+ Jx = np.tile(res_xprime,tile_shape)
+ Jy = np.tile(res_yprime,tile_shape)
+
+ thetahat = -Jx*np.sin(theta) + Jy*np.cos(theta)
+
+ return np.sum(vectors*thetahat, axis=0)
+
+def get_cyl_z_component(vectors, normal):
+ # The z component of a vector is the vector dotted with zhat
+ (xprime, yprime, zprime) = get_ortho_basis(normal)
+
+ res_zprime = resize_vector(zprime, vectors)
+
+ tile_shape = [1] + list(vectors.shape)[1:]
+ zhat = np.tile(res_zprime, tile_shape)
+
+ return np.sum(vectors*zhat, axis=0)
+
+def get_sph_r_component(vectors, theta, phi, normal):
+ # The r component of a vector is the vector dotted with rhat
+
+ (xprime, yprime, zprime) = get_ortho_basis(normal)
+
+ res_xprime = resize_vector(xprime, vectors)
+ res_yprime = resize_vector(yprime, vectors)
+ res_zprime = resize_vector(zprime, vectors)
+
+ tile_shape = [1] + list(vectors.shape)[1:]
+ Jx = np.tile(res_xprime,tile_shape)
+ Jy = np.tile(res_yprime,tile_shape)
+ Jz = np.tile(res_zprime,tile_shape)
+
+ rhat = Jx*np.sin(theta)*np.cos(phi) + \
+ Jy*np.sin(theta)*np.sin(phi) + \
+ Jz*np.cos(theta)
+
+ return np.sum(vectors*rhat, axis=0)
+
+def get_sph_phi_component(vectors, phi, normal):
+ # The phi component of a vector is the vector dotted with phihat
+
+ (xprime, yprime, zprime) = get_ortho_basis(normal)
+
+ res_xprime = resize_vector(xprime, vectors)
+ res_yprime = resize_vector(yprime, vectors)
+
+ tile_shape = [1] + list(vectors.shape)[1:]
+ Jx = np.tile(res_xprime,tile_shape)
+ Jy = np.tile(res_yprime,tile_shape)
+
+ phihat = -Jx*np.sin(phi) + Jy*np.cos(phi)
+
+ return np.sum(vectors*phihat, axis=0)
+
+def get_sph_theta_component(vectors, theta, phi, normal):
+ # The theta component of a vector is the vector dotted with thetahat
+
+ (xprime, yprime, zprime) = get_ortho_basis(normal)
+
+ res_xprime = resize_vector(xprime, vectors)
+ res_yprime = resize_vector(yprime, vectors)
+ res_zprime = resize_vector(zprime, vectors)
+
+ tile_shape = [1] + list(vectors.shape)[1:]
+ Jx = np.tile(res_xprime,tile_shape)
+ Jy = np.tile(res_yprime,tile_shape)
+ Jz = np.tile(res_zprime,tile_shape)
+
+ thetahat = Jx*np.cos(theta)*np.cos(phi) + \
+ Jy*np.cos(theta)*np.sin(phi) - \
+ Jz*np.sin(theta)
+
+ return np.sum(vectors*thetahat, axis=0)
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/utilities/tests/test_coordinate_conversions.py
--- /dev/null
+++ b/yt/utilities/tests/test_coordinate_conversions.py
@@ -0,0 +1,125 @@
+from yt.testing import *
+from yt.utilities.math_utils import \
+ get_sph_r_component, \
+ get_sph_theta_component, \
+ get_sph_phi_component, \
+ get_cyl_r_component, \
+ get_cyl_z_component, \
+ get_cyl_theta_component, \
+ get_cyl_r, get_cyl_theta, \
+ get_cyl_z, get_sph_r, \
+ get_sph_theta, get_sph_phi
+
+# Randomly generated coordinates in the domain [[-1,1],[-1,1],-1,1]]
+coords = np.array([[-0.41503037, -0.22102472, -0.55774212],
+ [ 0.73828247, -0.17913899, 0.64076921],
+ [ 0.08922066, -0.94254844, -0.61774511],
+ [ 0.10173242, -0.95789145, 0.16294352],
+ [ 0.73186508, -0.3109153 , 0.75728738],
+ [ 0.8757989 , -0.41475119, -0.57039201],
+ [ 0.58040762, 0.81969082, 0.46759728],
+ [-0.89983356, -0.9853683 , -0.38355343]]).T
+
+def test_spherical_coordinate_conversion():
+ normal = [0, 0, 1]
+ real_r = [ 0.72950559, 0.99384957, 1.13047198, 0.97696269,
+ 1.09807968, 1.12445067, 1.10788685, 1.38843954]
+ real_theta = [ 2.44113629, 0.87012028, 2.14891444, 1.4032274 ,
+ 0.80979483, 2.10280198, 1.13507735, 1.85068416]
+ real_phi = [-2.65224483, -0.23804243, -1.47641858, -1.46498842,
+ -0.40172325, -0.4422801 , 0.95466734, -2.31085392]
+
+ calc_r = get_sph_r(coords)
+ calc_theta = get_sph_theta(coords, normal)
+ calc_phi = get_sph_phi(coords, normal)
+
+ assert_array_almost_equal(calc_r, real_r)
+ assert_array_almost_equal(calc_theta, real_theta)
+ assert_array_almost_equal(calc_phi, real_phi)
+
+ normal = [1, 0, 0]
+ real_theta = [ 2.17598842, 0.73347681, 1.49179079, 1.46647589,
+ 0.8412984 , 0.67793705, 1.0193883 , 2.27586987]
+ real_phi = [-0.37729951, -2.86898397, -0.99063518, -1.73928995,
+ -2.75201227,-0.62870527, 2.08920872, -1.19959244]
+
+ calc_theta = get_sph_theta(coords, normal)
+ calc_phi = get_sph_phi(coords, normal)
+
+ assert_array_almost_equal(calc_theta, real_theta)
+ assert_array_almost_equal(calc_phi, real_phi)
+
+def test_cylindrical_coordiante_conversion():
+ normal = [0, 0, 1]
+ real_r = [ 0.47021498, 0.75970506, 0.94676179, 0.96327853,
+ 0.79516968, 0.96904193, 1.00437346, 1.3344104 ]
+ real_theta = [-2.65224483, -0.23804243, -1.47641858, -1.46498842,
+ -0.40172325, -0.4422801 , 0.95466734, -2.31085392]
+ real_z = [-0.55774212, 0.64076921, -0.61774511, 0.16294352,
+ 0.75728738, -0.57039201, 0.46759728, -0.38355343]
+
+ calc_r = get_cyl_r(coords, normal)
+ calc_theta = get_cyl_theta(coords, normal)
+ calc_z = get_cyl_z(coords, normal)
+
+ assert_array_almost_equal(calc_r, real_r)
+ assert_array_almost_equal(calc_theta, real_theta)
+ assert_array_almost_equal(calc_z, real_z)
+
+ normal = [1, 0, 0]
+ real_r = [ 0.59994016, 0.66533898, 1.12694569, 0.97165149,
+ 0.81862843, 0.70524152, 0.94368441, 1.05738542]
+ real_theta = [-0.37729951, -2.86898397, -0.99063518, -1.73928995,
+ -2.75201227, -0.62870527, 2.08920872, -1.19959244]
+ real_z = [-0.41503037, 0.73828247, 0.08922066, 0.10173242,
+ 0.73186508, 0.8757989 , 0.58040762, -0.89983356]
+
+ calc_r = get_cyl_r(coords, normal)
+ calc_theta = get_cyl_theta(coords, normal)
+ calc_z = get_cyl_z(coords, normal)
+
+ assert_array_almost_equal(calc_r, real_r)
+ assert_array_almost_equal(calc_theta, real_theta)
+ assert_array_almost_equal(calc_z, real_z)
+
+def test_spherical_coordinate_projections():
+ normal = [0, 0, 1]
+ theta = get_sph_theta(coords, normal)
+ phi = get_sph_phi(coords, normal)
+ zero = np.tile(0,coords.shape[1])
+
+ # Purely radial field
+ vecs = np.array([np.sin(theta)*np.cos(phi), np.sin(theta)*np.sin(phi), np.cos(theta)])
+ assert_array_almost_equal(zero, get_sph_theta_component(vecs, theta, phi, normal))
+ assert_array_almost_equal(zero, get_sph_phi_component(vecs, phi, normal))
+
+ # Purely toroidal field
+ vecs = np.array([-np.sin(phi), np.cos(phi), zero])
+ assert_array_almost_equal(zero, get_sph_theta_component(vecs, theta, phi, normal))
+ assert_array_almost_equal(zero, get_sph_r_component(vecs, theta, phi, normal))
+
+ # Purely poloidal field
+ vecs = np.array([np.cos(theta)*np.cos(phi), np.cos(theta)*np.sin(phi), -np.sin(theta)])
+ assert_array_almost_equal(zero, get_sph_phi_component(vecs, phi, normal))
+ assert_array_almost_equal(zero, get_sph_r_component(vecs, theta, phi, normal))
+
+def test_cylindrical_coordinate_projections():
+ normal = [0, 0, 1]
+ theta = get_cyl_theta(coords, normal)
+ z = get_cyl_z(coords, normal)
+ zero = np.tile(0, coords.shape[1])
+
+ # Purely radial field
+ vecs = np.array([np.cos(theta), np.sin(theta), zero])
+ assert_array_almost_equal(zero, get_cyl_theta_component(vecs, theta, normal))
+ assert_array_almost_equal(zero, get_cyl_z_component(vecs, normal))
+
+ # Purely toroidal field
+ vecs = np.array([-np.sin(theta), np.cos(theta), zero])
+ assert_array_almost_equal(zero, get_cyl_z_component(vecs, normal))
+ assert_array_almost_equal(zero, get_cyl_r_component(vecs, theta, normal))
+
+ # Purely z field
+ vecs = np.array([zero, zero, z])
+ assert_array_almost_equal(zero, get_cyl_theta_component(vecs, theta, normal))
+ assert_array_almost_equal(zero, get_cyl_r_component(vecs, theta, normal))
diff -r 47ed8fb04ea4a685664cd3d648ed246dc9247c82 -r 56c2d60a99c72bb9cf58f1c1f264787999ba7c01 yt/utilities/tests/test_decompose.py
--- /dev/null
+++ b/yt/utilities/tests/test_decompose.py
@@ -0,0 +1,96 @@
+"""
+Test suite for cartesian domain decomposition.
+
+Author: Kacper Kowalik <xarthisius.kk at gmail.com>
+Affiliation: CA UMK
+Homepage: http://yt-project.org/
+License:
+ Copyright (C) 2012 Kacper Kowalik. All Rights Reserved.
+
+ This file is part of yt.
+
+ yt is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""
+
+from yt.testing import assert_array_equal, assert_almost_equal
+import numpy as np
+import yt.utilities.decompose as dec
+
+
+def setup():
+ pass
+
+
+def test_psize_2d():
+ procs = dec.get_psize(np.array([5, 1, 7]), 6)
+ assert_array_equal(procs, np.array([3, 1, 2]))
+ procs = dec.get_psize(np.array([1, 7, 5]), 6)
+ assert_array_equal(procs, np.array([1, 2, 3]))
+ procs = dec.get_psize(np.array([7, 5, 1]), 6)
+ assert_array_equal(procs, np.array([2, 3, 1]))
+
+
+def test_psize_3d():
+ procs = dec.get_psize(np.array([33, 35, 37]), 12)
+ assert_array_equal(procs, np.array([3, 2, 2]))
+
+
+def test_decomposition_2d():
+ array = np.ones((7, 5, 1))
+ bbox = np.array([[-0.7, 0.0], [1.5, 2.0], [0.0, 0.7]])
+ ledge, redge, data = dec.decompose_array(array, np.array([2, 3, 1]), bbox)
+
+ assert_array_equal(data[1].shape, np.array([3, 2, 1]))
+
+ gold_le = np.array([
+ [-0.7, 1.5, 0.0], [-0.7, 1.6, 0.0],
+ [-0.7, 1.8, 0.0], [-0.4, 1.5, 0.0],
+ [-0.4, 1.6, 0.0], [-0.4, 1.8, 0.0]
+ ])
+ assert_almost_equal(ledge, gold_le, 8)
+
+ gold_re = np.array(
+ [[-0.4, 1.6, 0.7], [-0.4, 1.8, 0.7],
+ [-0.4, 2.0, 0.7], [0.0, 1.6, 0.7],
+ [0.0, 1.8, 0.7], [0.0, 2.0, 0.7]]
+ )
+ assert_almost_equal(redge, gold_re, 8)
+
+
+def test_decomposition_3d():
+ array = np.ones((33, 35, 37))
+ bbox = np.array([[0., 1.0], [-1.5, 1.5], [1.0, 2.5]])
+
+ ledge, redge, data = dec.decompose_array(array, np.array([3, 2, 2]), bbox)
+ assert_array_equal(data[0].shape, np.array([11, 17, 18]))
+
+ gold_le = np.array(
+ [[0.00000, -1.50000, 1.00000], [0.00000, -1.50000, 1.72973],
+ [0.00000, -0.04286, 1.00000], [0.00000, -0.04286, 1.72973],
+ [0.33333, -1.50000, 1.00000], [0.33333, -1.50000, 1.72973],
+ [0.33333, -0.04286, 1.00000], [0.33333, -0.04286, 1.72973],
+ [0.66667, -1.50000, 1.00000], [0.66667, -1.50000, 1.72973],
+ [0.66667, -0.04286, 1.00000], [0.66667, -0.04286, 1.72973]]
+ )
+ assert_almost_equal(ledge, gold_le, 5)
+
+ gold_re = np.array(
+ [[0.33333, -0.04286, 1.72973], [0.33333, -0.04286, 2.50000],
+ [0.33333, 1.50000, 1.72973], [0.33333, 1.50000, 2.50000],
+ [0.66667, -0.04286, 1.72973], [0.66667, -0.04286, 2.50000],
+ [0.66667, 1.50000, 1.72973], [0.66667, 1.50000, 2.50000],
+ [1.00000, -0.04286, 1.72973], [1.00000, -0.04286, 2.50000],
+ [1.00000, 1.50000, 1.72973], [1.00000, 1.50000, 2.50000]]
+ )
+ assert_almost_equal(redge, gold_re, 5)
Repository URL: https://bitbucket.org/yt_analysis/yt/
--
This is a commit notification from bitbucket.org. You are receiving
this because you have the service enabled, addressing the recipient of
this email.
More information about the yt-svn
mailing list