21.data_object_subsections.md

Arbitrary grid {#sec:dobj-arbitrary_grid}

Arguments:

• Left edge
• Right edge
• Active Dimensions

A 3D region with arbitrary bounds and dimensions. In contrast to the Covering Grid, this object accepts a left edge, a right edge, and dimensions. This allows it to be used for creating 3D particle deposition fields that are independent of the underlying mesh, whether that is yt-generated or from the simulation data. For example, arbitrary boxes around particles can be drawn and particle deposition fields can be created. This object will refuse to generate any fluid fields.

Bool {#sec:dobj-bool}

Arguments:

• Operation
• Data object 1
• Data object 2

This is a boolean operation, accepting AND, OR, XOR, and NOT for combining multiple data objects. This object is not designed to be created directly; it is designed to be created implicitly by using one of the bitwise operations (&, |, ^, ~) on one or two other data objects. These correspond to the appropriate boolean operations, and the resultant object can be nested.

Covering grid {#sec:dobj-covering_grid}

Arguments:

• Level
• Left edge
• Active Dimensions

A 3D region with all data extracted to a single, specified resolution. Left edge should align with a cell boundary, but defaults to the closest cell boundary.

Cut region {#sec:dobj-cut_region}

Arguments:

• Base object
• Conditionals

This is a data object designed to allow individuals to apply logical operations to fields and filter as a result of those cuts.

Cutting {#sec:dobj-cutting}

Arguments:

• Normal
• Center

This is a data object corresponding to an oblique slice through the simulation domain. This object is typically accessed through the cutting object that hangs off of index objects. A cutting plane is an oblique plane through the data, defined by a normal vector and a coordinate. It attempts to guess an 'north' vector, which can be overridden, and then it pixelizes the appropriate data onto the plane without interpolation.

Data collection {#sec:dobj-data_collection}

Arguments:

• Object List

By selecting an arbitrary object_list, we can act on those grids. Child cells are not returned.

Disk {#sec:dobj-disk}

Arguments:

• Center
• Normal vector
• Radius
• Height

By providing a center, a normal, a radius and a height we can define a cylinder of any proportion. Only cells whose centers are within the cylinder will be selected.

Ellipsoid {#sec:dobj-ellipsoid}

Arguments:

• Center
• a
• b
• c
• e0
• tilt

By providing a center,A,B,C,e0,tilt we can define a ellipsoid of any proportion. Only cells whose centers are within the ellipsoid will be selected.

Intersection {#sec:dobj-intersection}

Arguments:

• Data objects

This is a more efficient method of selecting the intersection of multiple data selection objects. Creating one of these objects returns the intersection of all of the sub-objects; it is designed to be a faster method than chaining & ("and") operations to create a single, large intersection.

Minimal sphere {#sec:dobj-minimal_sphere}

Arguments:

• Center
• Radius

Build the smallest sphere that encompasses a set of points.

Octree {#sec:dobj-octree}

Arguments:

• Left edge
• Right edge
• Particle count refinement criteria

A 3D region with all the data filled into an octree. This container will mean deposit particle fields onto octs using a kernel and SPH smoothing.

Ortho ray {#sec:dobj-ortho_ray}

Arguments:

• Axis
• Coords

This is an orthogonal ray cast through the entire domain, at a specific coordinate. This object is typically accessed through the ortho_ray object that hangs off of index objects. The resulting arrays have their dimensionality reduced to one, and an ordered list of points at an (x,y) tuple along axis are available.

Particle proj {#sec:dobj-particle_proj}

Arguments:

• Axis
• Field
• Weight field

A projection operation optimized for SPH particle data.

Point {#sec:dobj-point}

Arguments:

• P

A 0-dimensional object defined by a single point

Quad proj {#sec:dobj-quad_proj}

Arguments:

• Axis
• Field
• Weight field

This is a data object corresponding to a line integral through the simulation domain. This object is typically accessed through the proj object that hangs off of index objects. YTQuadTreeProj is a projection of a field along an axis. The field can have an associated weight_field, in which case the values are multiplied by a weight before being summed, and then divided by the sum of that weight; the two fundamental modes of operating are direct line integral (no weighting) and average along a line of sight (weighting.) What makes proj different from the standard projection mechanism is that it utilizes a quadtree data structure, rather than the old mechanism for projections. It will not run in parallel, but serial runs should be substantially faster. Note also that lines of sight are integrated at every projected finest-level cell.

Ray {#sec:dobj-ray}

Arguments:

• Start point
• End point

This is an arbitrarily-aligned ray cast through the entire domain, at a specific coordinate. This object is typically accessed through the ray object that hangs off of index objects. The resulting arrays have their dimensionality reduced to one, and an ordered list of points at an (x,y) tuple along axis are available, as is the t field, which corresponds to a unitless measurement along the ray from start to end.

Region {#sec:dobj-region}

Arguments:

• Center
• Left edge
• Right edge

A 3D region of data with an arbitrary center. Takes an array of three left_edge coordinates, three right_edge coordinates, and a center that can be anywhere in the domain. If the selected region extends past the edges of the domain, no data will be found there, though the object's left_edge or right_edge are not modified.

Slice {#sec:dobj-slice}

Arguments:

• Axis
• Coord

This is a data object corresponding to a slice through the simulation domain. This object is typically accessed through the slice object that hangs off of index objects. Slice is an orthogonal slice through the data, taking all the points at the finest resolution available and then indexing them. It is more appropriately thought of as a slice 'operator' than an object, however, as its field and coordinate can both change.

Smoothed covering grid {#sec:dobj-smoothed_covering_grid}

Arguments:

• Level
• Left edge
• Active Dimensions

A 3D region with all data extracted and interpolated to a single, specified resolution. (Identical to covering_grid, except that it interpolates.) Smoothed covering grids start at level 0, interpolating to fill the region to level 1, replacing any cells actually covered by level 1 data, and then recursively repeating this process until it reaches the specified level.

Sphere {#sec:dobj-sphere}

Arguments:

• Center
• Radius

A sphere of points defined by a center and a radius.

Streamline {#sec:dobj-streamline}

Arguments:

• Positions

This is a streamline, which is a set of points defined as being parallel to some vector field. This object is typically accessed through the Streamlines.path function. The resulting arrays have their dimensionality reduced to one, and an ordered list of points at an (x,y) tuple along axis are available, as is the t field, which corresponds to a unitless measurement along the ray from start to end.

Surface {#sec:dobj-surface}

Arguments:

• Data source
• Surface field
• Field value

This surface object identifies isocontours on a cell-by-cell basis, with no consideration of global connectedness, and returns the vertices of the Triangles in that isocontour. This object simply returns the vertices of all the triangles calculated by the marching cubes algorithm; for more complex operations, such as identifying connected sets of cells above a given threshold, see the extract_connected_sets function. This is more useful for calculating, for instance, total isocontour area, or visualizing in an external program (such as MeshLab.) The object has the properties .vertices and will sample values if a field is requested. The values are interpolated to the center of a given face.

Union {#sec:dobj-union}

Arguments:

• Data objects

This is a more efficient method of selecting the union of multiple data selection objects. Creating one of these objects returns the union of all of the sub-objects; it is designed to be a faster method than chaining | (or) operations to create a single, large union.