def __init__(
self,
data_source,
conditionals,
ds=None,
field_parameters=None,
base_object=None,
locals=None,
):
if locals is None:
locals = {}
validate_object(data_source, YTSelectionContainer)
validate_sequence(conditionals)
for condition in conditionals:
validate_object(condition, str)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(base_object, YTSelectionContainer)
self.conditionals = list(always_iterable(conditionals))
if isinstance(data_source, YTCutRegion):
# If the source is also a cut region, add its conditionals
# and set the source to be its source.
# Preserve order of conditionals.
self.conditionals = data_source.conditionals + self.conditionals
data_source = data_source.base_object
super().__init__(
data_source.center, ds, field_parameters, data_source=data_source
)
self.filter_fields = self._check_filter_fields()
self.base_object = data_source
self.locals = locals
self._selector = None
def __init__(self,
data_source,
conditionals,
ds=None,
field_parameters=None,
base_object=None):
validate_object(data_source, YTSelectionContainer)
validate_iterable(conditionals)
for condition in conditionals:
validate_object(condition, string_types)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(base_object, YTSelectionContainer)
if base_object is not None:
# passing base_object explicitly has been deprecated,
# but we handle it here for backward compatibility
if data_source is not None:
raise RuntimeError(
"Cannot use both base_object and data_source")
data_source = base_object
super(YTCutRegion, self).__init__(data_source.center,
ds,
field_parameters,
data_source=data_source)
self.conditionals = ensure_list(conditionals)
self.base_object = data_source
self._selector = None
def __init__(self,
points,
ds=None,
field_parameters=None,
data_source=None):
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(data_source, YTSelectionContainer)
validate_object(points, YTArray)
points = fix_length(points, ds)
if len(points) < 2:
raise YTException(
"Not enough points. Expected at least 2, got %s" % len(points))
mylog.debug('Building minimal sphere around points.')
mb = _miniball.Miniball(points)
if not mb.is_valid():
raise YTException("Could not build valid sphere around points.")
center = ds.arr(mb.center(), points.units)
radius = ds.quan(np.sqrt(mb.squared_radius()), points.units)
super(YTMinimalSphere, self).__init__(center, ds, field_parameters,
data_source)
self.set_field_parameter('radius', radius)
self.set_field_parameter("center", self.center)
self.radius = radius
def __init__(self, data_objects, ds=None, field_parameters=None, data_source=None):
validate_sequence(data_objects)
for obj in data_objects:
validate_object(obj, YTSelectionContainer)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(data_source, YTSelectionContainer)
YTSelectionContainer3D.__init__(self, None, ds, field_parameters, data_source)
self.data_objects = list(always_iterable(data_objects))
def __init__(self, data_objects, ds=None, field_parameters=None, data_source=None):
validate_iterable(data_objects)
for obj in data_objects:
validate_object(obj, YTSelectionContainer)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(data_source, YTSelectionContainer)
YTSelectionContainer3D.__init__(self, None, ds, field_parameters, data_source)
# ensure_list doesn't check for tuples
if isinstance(data_objects, tuple):
data_objects = list(data_objects)
self.data_objects = ensure_list(data_objects)
def __init__(
self,
data_source,
conditionals,
ds=None,
field_parameters=None,
base_object=None,
locals=None,
):
if locals is None:
locals = {}
validate_object(data_source, YTSelectionContainer)
validate_iterable(conditionals)
for condition in conditionals:
validate_object(condition, str)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(base_object, YTSelectionContainer)
if base_object is not None:
# passing base_object explicitly has been deprecated,
# but we handle it here for backward compatibility
if data_source is not None:
raise RuntimeError(
"Cannot use both base_object and data_source")
data_source = base_object
self.conditionals = ensure_list(conditionals)
if isinstance(data_source, YTCutRegion):
# If the source is also a cut region, add its conditionals
# and set the source to be its source.
# Preserve order of conditionals.
self.conditionals = data_source.conditionals + self.conditionals
data_source = data_source.base_object
super(YTCutRegion, self).__init__(data_source.center,
ds,
field_parameters,
data_source=data_source)
self.base_object = data_source
self.locals = locals
self._selector = None
def __init__(self,
center,
left_edge,
right_edge,
fields=None,
ds=None,
field_parameters=None,
data_source=None):
if center is not None:
validate_center(center)
validate_3d_array(left_edge)
validate_3d_array(right_edge)
validate_iterable(fields)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(data_source, YTSelectionContainer)
YTSelectionContainer3D.__init__(self, center, ds, field_parameters,
data_source)
if not isinstance(left_edge, YTArray):
self.left_edge = self.ds.arr(left_edge, 'code_length')
else:
# need to assign this dataset's unit registry to the YTArray
self.left_edge = self.ds.arr(left_edge.copy())
if not isinstance(right_edge, YTArray):
self.right_edge = self.ds.arr(right_edge, 'code_length')
else:
# need to assign this dataset's unit registry to the YTArray
self.right_edge = self.ds.arr(right_edge.copy())
def __init__(self,
center,
normal,
radius,
height,
fields=None,
ds=None,
field_parameters=None,
data_source=None):
validate_center(center)
validate_3d_array(normal)
validate_float(radius)
validate_float(height)
validate_iterable(fields)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(data_source, YTSelectionContainer)
YTSelectionContainer3D.__init__(self, center, ds, field_parameters,
data_source)
self._norm_vec = np.array(normal) / np.sqrt(np.dot(normal, normal))
self.set_field_parameter("normal", self._norm_vec)
self.set_field_parameter("center", self.center)
self.height = fix_length(height, self.ds)
self.radius = fix_length(radius, self.ds)
self._d = -1.0 * np.dot(self._norm_vec, self.center)
def __init__(self,
normal,
center,
north_vector=None,
ds=None,
field_parameters=None,
data_source=None):
validate_3d_array(normal)
validate_center(center)
if north_vector is not None:
validate_3d_array(north_vector)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(data_source, YTSelectionContainer)
YTSelectionContainer2D.__init__(self, 4, ds, field_parameters,
data_source)
self._set_center(center)
self.set_field_parameter('center', center)
# Let's set up our plane equation
# ax + by + cz + d = 0
self.orienter = Orientation(normal, north_vector=north_vector)
self._norm_vec = self.orienter.normal_vector
self._d = -1.0 * np.dot(self._norm_vec, self.center)
self._x_vec = self.orienter.unit_vectors[0]
self._y_vec = self.orienter.unit_vectors[1]
# First we try all three, see which has the best result:
self._rot_mat = np.array([self._x_vec, self._y_vec, self._norm_vec])
self._inv_mat = np.linalg.pinv(self._rot_mat)
self.set_field_parameter('cp_x_vec', self._x_vec)
self.set_field_parameter('cp_y_vec', self._y_vec)
self.set_field_parameter('cp_z_vec', self._norm_vec)
def __init__(self,
start_point,
end_point,
ds=None,
field_parameters=None,
data_source=None):
validate_3d_array(start_point)
validate_3d_array(end_point)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(data_source, YTSelectionContainer)
super(YTRay, self).__init__(ds, field_parameters, data_source)
if isinstance(start_point, YTArray):
self.start_point = \
self.ds.arr(start_point).to("code_length")
else:
self.start_point = \
self.ds.arr(start_point, 'code_length',
dtype='float64')
if isinstance(end_point, YTArray):
self.end_point = \
self.ds.arr(end_point).to("code_length")
else:
self.end_point = \
self.ds.arr(end_point, 'code_length',
dtype='float64')
self.vec = self.end_point - self.start_point
self._set_center(self.start_point)
self.set_field_parameter('center', self.start_point)
self._dts, self._ts = None, None
def __init__(self,
axis,
coords,
ds=None,
field_parameters=None,
data_source=None):
validate_axis(ds, axis)
validate_iterable(coords)
for c in coords:
validate_float(c)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(data_source, YTSelectionContainer)
super(YTOrthoRay, self).__init__(ds, field_parameters, data_source)
self.axis = fix_axis(axis, self.ds)
xax = self.ds.coordinates.x_axis[self.axis]
yax = self.ds.coordinates.y_axis[self.axis]
self.px_ax = xax
self.py_ax = yax
# Even though we may not be using x,y,z we use them here.
self.px_dx = 'd%s' % ('xyz'[self.px_ax])
self.py_dx = 'd%s' % ('xyz'[self.py_ax])
# Convert coordinates to code length.
if isinstance(coords[0], YTQuantity):
self.px = self.ds.quan(coords[0]).to("code_length")
else:
self.px = self.ds.quan(coords[0], "code_length")
if isinstance(coords[1], YTQuantity):
self.py = self.ds.quan(coords[1]).to("code_length")
else:
self.py = self.ds.quan(coords[1], "code_length")
self.sort_by = 'xyz'[self.axis]
def __init__(self,
start_point,
end_point,
ds=None,
field_parameters=None,
data_source=None):
validate_3d_array(start_point)
validate_3d_array(end_point)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(data_source, YTSelectionContainer)
super().__init__(ds, field_parameters, data_source)
if isinstance(start_point, YTArray):
self.start_point = self.ds.arr(start_point).to("code_length")
else:
self.start_point = self.ds.arr(start_point,
"code_length",
dtype="float64")
if isinstance(end_point, YTArray):
self.end_point = self.ds.arr(end_point).to("code_length")
else:
self.end_point = self.ds.arr(end_point,
"code_length",
dtype="float64")
if (self.start_point < self.ds.domain_left_edge).any() or (
self.end_point > self.ds.domain_right_edge).any():
mylog.warning(
"Ray start or end is outside the domain. "
"Returned data will only be for the ray section inside the domain."
)
self.vec = self.end_point - self.start_point
self._set_center(self.start_point)
self.set_field_parameter("center", self.start_point)
self._dts, self._ts = None, None
def __init__(self, center, A, B, C, e0, tilt, fields=None,
ds=None, field_parameters=None, data_source=None):
validate_center(center)
validate_float(A)
validate_float(B)
validate_float(C)
validate_3d_array(e0)
validate_float(tilt)
validate_iterable(fields)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(data_source, YTSelectionContainer)
YTSelectionContainer3D.__init__(self, center, ds,
field_parameters, data_source)
# make sure the magnitudes of semi-major axes are in order
if A<B or B<C:
raise YTEllipsoidOrdering(ds, A, B, C)
# make sure the smallest side is not smaller than dx
self._A = self.ds.quan(A, 'code_length')
self._B = self.ds.quan(B, 'code_length')
self._C = self.ds.quan(C, 'code_length')
if self._C < self.index.get_smallest_dx():
raise YTSphereTooSmall(self.ds, self._C, self.index.get_smallest_dx())
self._e0 = e0 = e0 / (e0**2.0).sum()**0.5
self._tilt = tilt
# find the t1 angle needed to rotate about z axis to align e0 to x
t1 = np.arctan(e0[1] / e0[0])
# rotate e0 by -t1
RZ = get_rotation_matrix(t1, (0,0,1)).transpose()
r1 = (e0 * RZ).sum(axis = 1)
# find the t2 angle needed to rotate about y axis to align e0 to x
t2 = np.arctan(-r1[2] / r1[0])
"""
calculate the original e1
given the tilt about the x axis when e0 was aligned
to x after t1, t2 rotations about z, y
"""
RX = get_rotation_matrix(-tilt, (1, 0, 0)).transpose()
RY = get_rotation_matrix(-t2, (0, 1, 0)).transpose()
RZ = get_rotation_matrix(-t1, (0, 0, 1)).transpose()
e1 = ((0, 1, 0) * RX).sum(axis=1)
e1 = (e1 * RY).sum(axis=1)
e1 = (e1 * RZ).sum(axis=1)
e2 = np.cross(e0, e1)
self._e1 = e1
self._e2 = e2
self.set_field_parameter('A', A)
self.set_field_parameter('B', B)
self.set_field_parameter('C', C)
self.set_field_parameter('e0', e0)
self.set_field_parameter('e1', e1)
self.set_field_parameter('e2', e2)
def __init__(self, p, ds=None, field_parameters=None, data_source=None):
validate_3d_array(p)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(data_source, YTSelectionContainer)
super(YTPoint, self).__init__(ds, field_parameters, data_source)
if isinstance(p, YTArray):
# we pass p through ds.arr to ensure code units are attached
self.p = self.ds.arr(p)
else:
self.p = self.ds.arr(p, 'code_length')
def __init__(
self, obj_list, ds=None, field_parameters=None, data_source=None, center=None
):
validate_iterable(obj_list)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(data_source, YTSelectionContainer)
if center is not None:
validate_center(center)
YTSelectionContainer3D.__init__(self, center, ds, field_parameters, data_source)
self._obj_ids = np.array([o.id - o._id_offset for o in obj_list], dtype="int64")
self._obj_list = obj_list
def __init__(
self, axis, coord, center=None, ds=None, field_parameters=None, data_source=None
):
validate_axis(ds, axis)
validate_float(coord)
# center is an optional parameter
if center is not None:
validate_center(center)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(data_source, YTSelectionContainer)
YTSelectionContainer2D.__init__(self, axis, ds, field_parameters, data_source)
self._set_center(center)
self.coord = coord
def __init__(self, center, radius, ds=None,
field_parameters=None, data_source=None):
validate_center(center)
validate_float(radius)
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
validate_object(data_source, YTSelectionContainer)
super(YTSphere, self).__init__(center, ds,
field_parameters, data_source)
# Unpack the radius, if necessary
radius = fix_length(radius, self.ds)
if radius < self.index.get_smallest_dx():
raise YTSphereTooSmall(ds, radius.in_units("code_length"),
self.index.get_smallest_dx().in_units("code_length"))
self.set_field_parameter('radius', radius)
self.set_field_parameter("center", self.center)
self.radius = radius
def __init__(self, filename, ds=None, field_parameters=None, crs=None):
validate_object(ds, Dataset)
validate_object(field_parameters, dict)
self.src_crs = crs
if isinstance(filename, str):
self.filename = filename
# read shapefile with fiona
with fiona.open(filename, "r") as shapefile:
shapes_from_file = [
feature["geometry"] for feature in shapefile
]
self.src_crs = CRS.from_dict(**shapefile.crs) # shapefile crs
# save number of polygons
self._number_features = len(shapes_from_file)
# reproject to datasets crs
for i in range(self._number_features):
shapes_from_file[i] = transform_geom(
f'EPSG:{self.src_crs.to_epsg()}',
f'EPSG:{ds.parameters["crs"].to_epsg()}',
shapes_from_file[i])
# convert all polygon features in shapefile to list of shapely polygons
polygons = [
Polygon(shapes_from_file[i]["coordinates"][0])
for i in range(self._number_features)
]
# fix invalid MultiPolygons
m = MultiPolygon(polygons)
# join all shapely polygons to a single layer
self.polygon = unary_union(m)
elif isinstance(filename, Polygon):
# only one polygon
self._number_features = 1
self.polygon = filename
if not (self.src_crs is None):
self._reproject_polygon(ds.parameters['crs'])
elif isinstance(filename, MultiPolygon):
# only one polygon
self._number_features = len(filename.geoms)
self.polygon = unary_union(filename)
if not (self.src_crs is None):
self._reproject_polygon(ds.parameters['crs'])
elif isinstance(filename, list):
# assume list of shapely polygons
self._number_features = len(filename)
# fix invalid MultiPolygons
m = MultiPolygon(filename)
# join all shapely polygons to a single layer
self.polygon = unary_union(m)
if not (self.src_crs is None):
self._reproject_polygon(ds.parameters['crs'])
mylog.info(
f"Number of features in poly object: {self._number_features}")
# define coordinates of center
self.center = [
self.polygon.centroid.coords.xy[0][0],
self.polygon.centroid.coords.xy[1][0],
]
data_source = None
super().__init__(self.center, ds, field_parameters, data_source)
