Skip to content

simgeometry.objects.cuboid

Cuboid helpers for geometric object definitions.

Classes

NameDescription
CuboidRepresent a cuboid geometry object.

Cuboidclass#

class Cuboid(midpoint: BoundsLike, side_lengths: BoundsLike, bc: ConfigValue = None, inverted: bool = False)

Bases: Shape3D

Represent a cuboid geometry object.

midpointattributeinstance attribute#

midpoint = xp.array(midpoint)

side_lengthsattributeinstance attribute#

side_lengths = xp.array(side_lengths)

containsmethod#

def contains(coords: Array) -> bool

Check if the given coordinates are inside the cuboid.

Parameters: coords (list or tuple): Coordinates for each dimension.

Returns: bool: True if all coordinates are inside the cuboid, False otherwise.

contains_pointsmethod#

def contains_points(points: Array) -> Array

Vectorised :meth:contains: a mask of the (3, n) points inside.

copymethod#

def copy() -> Cuboid

Create a copy of the cuboid.

Returns

CuboidCuboid
A new instance of Cuboid with the same midpoint, side lengths, and boundary conditions.

get_verticesmethod#

def get_vertices(slice_axis: int, slice_position: float) -> ConfigValue

Get the corner vertices of a slice of the cuboid along a given axis.

Parameters

NameTypeDescription
slice_axisintAxis along which to slice (0 for x, 1 for y, 2 for z).
slice_indexfloatPosition along the slice_axis where the slice is taken.

Returns

verticeslist
List of corner vertices defining the slice polygon.

mirrormethod#

def mirror(axis: int, position: float) -> None

Mirror the cuboid across a specified axis at a given position.

Parameters

NameTypeDescription
axisintAxis index (0 for x-axis, 1 for y-axis, 2 for z-axis).
positionfloatPosition along the axis to mirror.

surface_areamethod#

def surface_area() -> float

Calculate the surface area of the cuboid.

translatemethod#

def translate(offset: tuple[float, float, float]) -> None

Translate the cuboid by the given offset.

Parameters

NameTypeDescription
offsettuple(dx, dy, dz) translation vector.

volumemethod#

def volume() -> float

Calculate the volume of the cuboid.

Inherited from simgeometry.shapes.Shape

ndimattributeinstance attribute#

ndim = ndim

bounding_boxproperty#

bounding_box: BoundingBox

Return the bounding box.

invertedproperty#

inverted: bool

Return whether this object represents an inverted region.

lower_boundproperty#

lower_bound: tuple[float, ...]

Return the lower coordinate bounds.

upper_boundproperty#

upper_bound: tuple[float, ...]

Return the upper coordinate bounds.

get_bound_verticesmethod#

def get_bound_vertices(slice_axis: int) -> xp.ndarray

Return vertices that bound the shape.

get_indices_in_objectmethod#

def get_indices_in_object(grid: Grid) -> list[int] | list[tuple[int, ...]]

Get the indices of grid points that are inside the shape.

Parameters: grid (object): Grid object containing indices and cell sizes.

Returns: list: The :attr:Grid.indices of the nodes inside, in their order.

node_maskmethod#

def node_mask(grid: Grid) -> np.ndarray

Return a host boolean array of the grid’s shape, set at the nodes inside.

One vectorised :meth:contains_points over :meth:Grid.node_points, so the cost is that of a few array passes over the grid.

set_bounding_boxmethod#

def set_bounding_box(lower_bound: tuple[float, ...], upper_bound: tuple[float, ...]) -> None

Set the bounding box for the shape.

Inherited from simgeometry.api.GeometryAPI

cell_fractionsmethod#

def cell_fractions(grid, *, samples_per_axis=4)

Estimate solid cell-volume and face-area fractions by subcell sampling.

Increase samples_per_axis to check convergence; unresolved thin features can be missed. This is not an exact finite-volume interface reconstruction.

closest_pointmethod#

def closest_point(points, *, resolution=64, bounds=None)

Closest surface coordinates; primitives are exact, others use a mesh.

Mesh fallback requires mesh extras. Its accuracy is controlled by resolution and may miss unresolved components. Points are (ndim, n), or one (ndim,) point; the returned array has the same layout.

cut_edgesmethod#

def cut_edges(grid, **kwargs)

Locate all detected grid-edge surface hits, without solver clamping.

diagnosemethod#

def diagnose(grid, **kwargs)

Report sampled overlaps, unresolved components, and short cut distances.

differencemethod#

def difference(other)

evaluatemethod#

def evaluate(x=None, y=None, z=None, *, grid=None, bounds=None, resolution=128, quantity='occupancy')

Sample geometry as an xarray.DataArray (requires the evaluate extra).

Scalars fix axes, sequences form a tensor product, and DataArrays with shared dimension names describe scattered points. Unspecified axes use grid nodes, or resolution samples across bounds/the shape bounds. quantity is occupancy, labels (collections), or signed_distance. This is a local host operation, with no implicit MPI collectives.

exportmethod#

def export(path, **kwargs)

Export a sampled mesh as NPZ, OBJ, or STL (3D only).

intersect_segmentmethod#

def intersect_segment(start, end, *, samples=256, tolerance=1e-10)

Return ordered surface hits, including multiple crossings and tangencies.

Primitive intersections are analytic. Generic membership functions use samples intervals and may miss features smaller than that sampling. Result.exact distinguishes these cases. Coincident surface segments do not have a discrete set of hits; their end contacts may be returned.

intersectionmethod#

def intersection(other)

plotmethod#

def plot(ax=None, **kwargs)

Draw without displaying and return axes for composition.

rotatedmethod#

def rotated(angle, *, axis=(0, 0, 1), origin=None)

Return a rotated snapshot; angle is in degrees, about origin (default 0).

sample_interiormethod#

def sample_interior(count, *, rng=None, bounds=None, max_draws=1000000)

Uniform rejection samples, returned as (ndim, count).

Supply bounds for inverted/unbounded shapes. Raises if max_draws is exhausted; it never silently returns too few samples.

sample_surfacemethod#

def sample_surface(count, *, rng=None, resolution=64, bounds=None)

Uniform-by-length/area samples from the faceted boundary mesh.

scaledmethod#

def scaled(factors, *, origin=None)

Return a snapshot scaled by a nonzero scalar or per-axis factors.

showmethod#

def show(**kwargs)

Display geometry, dispatching to 3D unless a slice is requested.

Returns Matplotlib axes, or a PyVista plotter for backend='pyvista'. Set display=False for scripts. save=path saves the figure.

show_3dmethod#

def show_3d(**kwargs)

Display a surface with optional wireframe, normals and clipping.

backend='pyvista' enables an interactive clipping-plane widget via clip=True (requires the interactive extra). Matplotlib supports a static clip=(origin, normal) plane. Meshes are resolution-dependent.

signed_distancemethod#

def signed_distance(points, *, resolution=64, bounds=None)

Distance to the boundary, negative inside, positive outside.

Exact for balls, boxes and simple polygons; otherwise distance to the sampled surface mesh. A membership function is not itself a distance.

slicemethod#

def slice(x=None, y=None, z=None, origin=None, normal=None)

Return a queryable section with local-to-world coordinate mappings.

Fix exactly one coordinate, or give a 3D plane’s origin and normal. Axis-aligned sections retain the remaining coordinate names; oblique sections use x/y as their local plane coordinates.

surface_normalmethod#

def surface_normal(points, *, scale=None)

Outward unit normals at boundary points; NaN where undefined.

Primitive faces use analytic normals. Other geometries estimate the normal from nearby membership samples. At corners normals are not unique.

to_meshmethod#

def to_mesh(resolution=64, bounds=None)

Return sampled contours (2D) or triangles (3D), with spacing metadata.

Requires the mesh extra. Open contours/surfaces at the sampling bounds remain open; no artificial caps are added. Refine to resolve thin features.

transformedmethod#

def transformed(matrix, offset=None)

Return an affine-transformed snapshot; the source is unchanged.

translatedmethod#

def translated(offset)

Return a translated snapshot (unlike legacy in-place translate).

unionmethod#

def union(other)