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)