Volumes#

Volume adapters connect discrete 3D grids (simulation output, CT/MRI, or other VDB-backed data) to OpenVCAD’s continuous sampling model. Instead of baking data into dense meshes, you keep a sparse OpenVDB grid and query it at any world-space point. Sampling uses trilinear interpolation between voxel centers, so fields stay smooth for rendering, slicing, and compilers.

Typical uses include mapping Hounsfield units or bone density to material properties, reusing FEA or fluid fields on printable geometry, and importing artist-authored VDBs from external tools.

Interface you use in Python

Typed volumes — FloatVolume, Vec2sVolume, Vec3sVolume, and Vec4sVolume wrap scalar or vector VDB grids. Call sample(x, y, z) for a value, bounding_box() for world-space bounds, and clone() when you need a thread-safe copy for concurrent evaluation.
VDB files — Use pyvcad.vdb_loader (load_float_volume, load_vec3s_volume, load_vec4s_volume) to open a named grid from a .vdb file, optionally centered on the origin.
DICOM stacks — DICOMLoader reads a directory of slices, applies real-world spacing and rescale metadata where available, and builds a scalar FloatVolume (commonly HU). Call as_volume() when you are ready to sample.
Unstructured result fields — UnstructuredFieldDataset copies TET4 point/connectivity arrays, stores named point- or cell-associated scalar and three-component vector results, and exposes them as ordinary FloatAttribute and Vec3Attribute objects. XDMFFieldLoader provides the same dataset from the supported XDMF 3/HDF5 subset.
Attributes — A FloatVolume is a continuous field; pass it to FloatAttribute(volume) (or set_volume on an existing FloatAttribute) and attach that attribute to geometry with set_attribute, same as expression-driven fields. Evaluation runs where your solid exists, using the volume’s values inside the part.

Examples#

The patterns below mirror the getting-started discussion of sampled scalar fields: load data, wrap in FloatAttribute, attach to a primitive or mesh.

VDB scalar grid

import pyvcad as pv

vol = pv.vdb_loader.load_float_volume("model.vdb", "density")
bbox_min, bbox_max = vol.bounding_box()
solid = pv.RectPrism.FromMinAndMax(bbox_min, bbox_max)
solid.set_attribute(pv.DefaultAttributes.DENSITY, pv.FloatAttribute(vol))

DICOM series → float volume

import pyvcad as pv

loader = pv.DICOMLoader("path/to/dicom_series")
vol = loader.as_volume()
solid = pv.RectPrism.FromMinAndMax(*vol.bounding_box())
solid.set_attribute(pv.DefaultAttributes.HU, pv.FloatAttribute(vol))

Unstructured TET4 result fields#

An unstructured field dataset is data, not geometry. Keep or separately import the OpenVCAD node that should consume the result, then attach a returned attribute to that node:

import numpy as np
import pyvcad as pv

results = pv.UnstructuredFieldDataset.from_tetrahedra(points, cells)
results.add_point_vector("displacement", displacement, units="mm")
results.add_point_scalar(
    "strain_energy_density",
    energy,
    units="mJ/mm^3",
    step_identifier="load-1",
)

energy_attribute = results.float_attribute(
    "strain_energy_density",
    outside="boundary_clamp",
    max_distance=0.8,
)
source_geometry.set_attribute("strain_energy_density", energy_attribute)

Point-associated values are interpolated with TET4 barycentric coordinates. Cell-associated values remain piecewise constant. Coordinates and input values may be contiguous or strided NumPy-compatible float32/float64 arrays; connectivity must use an integer dtype. Construction copies every input array, so later mutation or deletion of the NumPy arrays does not affect the dataset.

Outside behavior is always explicit:

"error" is the default and raises when an ordinary attribute is sampled outside the domain. A constant or max_distance supplied with this policy is rejected rather than silently changing its meaning.
"constant" requires constant_value; no implicit zero fill is used.
"boundary_clamp" projects to the closest point on the outer TET4-domain boundary and requires a finite max_distance. Beyond that band it raises, unless an explicit constant_value is also provided.

Numerical containment tolerance is separate from geometric boundary clamping. Use sample_scalar / sample_vector to inspect one query’s SampleStatus, or coverage to preflight a batch without adding counters to ordinary attribute samples:

report = results.coverage(
    query_points,
    outside="boundary_clamp",
    max_distance=0.8,
    maximum_failures=8,
)
print(report.inside_count, report.boundary_clamped_count, report.outside_count)

Coordinates default to the reference dataset coordinates. transformed uses two deliberately separate matrices: a 4x4 affine matrix maps consuming node positions into dataset positions, and a 3x3 matrix maps stored vector components into consuming coordinates. A displacement field never deforms the domain implicitly. Unit conversion is an explicit matrix scale rather than an effect of the units metadata:

aligned = results.transformed(
    consumer_to_dataset_position,
    stored_to_consumer_vector,
)

max_distance is measured after the position transform, in reference dataset-coordinate units. This keeps its meaning explicit when the transform also performs a model-to-solver unit conversion.

XDMFFieldLoader supports XDMF 3 Uniform grids with TopologyType="Tetrahedron", GeometryType="XYZ", direct HDF-backed topology/geometry/attributes, Center="Node" or Center="Cell", and scalar or three-component vector attributes. Select grid_name when a file contains more than one Uniform grid and optionally select field_names. Temporal or spatial collections, mixed topology, HEX8, inline XML arrays, functions, hyperslabs, tensors, malformed dimensions, and unsupported numeric types fail explicitly; this loader is not a general XDMF implementation.

results = pv.XDMFFieldLoader.load(
    "result.xdmf",
    grid_name="OpenVCADMesh",
    field_names=["displacement", "strain_energy_density"],
)

Volume types#

class pyvcad.FloatVolume#

A VDB volume storing scalar float values.

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: pyvcad.pyvcad.FloatVolume) -> None

Constructor. Creates an empty FloatVDBVolume.

__init__(self: pyvcad.pyvcad.FloatVolume, grid: openvdb::v13_0::Grid<openvdb::v13_0::tree::Tree<openvdb::v13_0::tree::RootNode<openvdb::v13_0::tree::InternalNode<openvdb::v13_0::tree::InternalNode<openvdb::v13_0::tree::LeafNode<float, 3u>, 4u>, 5u>>>>, center: bool = False) -> None

Constructor. Creates a FloatVDBVolume from an existing grid.

Parameters:

grid (FloatGrid) – The OpenVDB grid to use.
center (bool) – If True, centers the volume about the origin. Defaults to False.

bounding_box(self: pyvcad.pyvcad.FloatVolume) → tuple[pyvcad.pyvcad.Vec3, pyvcad.pyvcad.Vec3]#

Get the world space bounding box of the volume.

Returns:: The minimum and maximum coordinates.
Return type:: tuple[Vec3, Vec3]

clone(self: pyvcad.pyvcad.FloatVolume) → pyvcad.pyvcad.FloatVolume#

Create a thread-safe clone of this volume.

Returns:: A cloned volume instance.
Return type:: FloatVolume

grid_type(self: pyvcad.pyvcad.FloatVolume) → str#

Get the grid type name.

Returns:: The grid type name.
Return type:: str

sample(self: pyvcad.pyvcad.FloatVolume, x: SupportsFloat, y: SupportsFloat, z: SupportsFloat) → float#

Sample the volume at the given coordinates.

Parameters:

x (float) – X coordinate.
y (float) – Y coordinate.
z (float) – Z coordinate.

Returns:

The sampled value.

Return type:

float

class pyvcad.Vec2sVolume#

A VDB volume storing 2D vector values with single precision.

__init__(self: pyvcad.pyvcad.Vec2sVolume) → None#: Constructor. Creates an empty Vec2sVDBVolume.

bounding_box(self: pyvcad.pyvcad.Vec2sVolume) → tuple[pyvcad.pyvcad.Vec3, pyvcad.pyvcad.Vec3]#

Get the world space bounding box of the volume.

Returns:: The minimum and maximum coordinates.
Return type:: tuple[Vec3, Vec3]

clone(self: pyvcad.pyvcad.Vec2sVolume) → pyvcad.pyvcad.Vec2sVolume#

Create a thread-safe clone of this volume.

Returns:: A cloned volume instance.
Return type:: Vec2sVolume

grid_type(self: pyvcad.pyvcad.Vec2sVolume) → str#

Get the grid type name.

Returns:: The grid type name.
Return type:: str

sample(self: pyvcad.pyvcad.Vec2sVolume, x: SupportsFloat, y: SupportsFloat, z: SupportsFloat) → pyvcad.pyvcad.Vec2#

Sample the volume at the given coordinates.

Parameters:

x (float) – X coordinate.
y (float) – Y coordinate.
z (float) – Z coordinate.

Returns:

The sampled 2D vector value.

Return type:

Vec2

class pyvcad.Vec3sVolume#

A VDB volume storing 3D vector values with single precision.

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: pyvcad.pyvcad.Vec3sVolume) -> None

Constructor. Creates an empty Vec3sVDBVolume.

__init__(self: pyvcad.pyvcad.Vec3sVolume, grid: openvdb::v13_0::Grid<openvdb::v13_0::tree::Tree<openvdb::v13_0::tree::RootNode<openvdb::v13_0::tree::InternalNode<openvdb::v13_0::tree::InternalNode<openvdb::v13_0::tree::LeafNode<openvdb::v13_0::math::Vec3<float>, 3u>, 4u>, 5u>>>>, center: bool = False) -> None

Constructor. Creates a Vec3sVDBVolume from an existing grid.

Parameters:

grid (Vec3SGrid) – The OpenVDB grid to use.
center (bool) – If True, centers the volume about the origin. Defaults to False.

bounding_box(self: pyvcad.pyvcad.Vec3sVolume) → tuple[pyvcad.pyvcad.Vec3, pyvcad.pyvcad.Vec3]#

Get the world space bounding box of the volume.

Returns:: The minimum and maximum coordinates.
Return type:: tuple[Vec3, Vec3]

clone(self: pyvcad.pyvcad.Vec3sVolume) → pyvcad.pyvcad.Vec3sVolume#

Create a thread-safe clone of this volume.

Returns:: A cloned volume instance.
Return type:: Vec3sVolume

grid_type(self: pyvcad.pyvcad.Vec3sVolume) → str#

Get the grid type name.

Returns:: The grid type name.
Return type:: str

sample(self: pyvcad.pyvcad.Vec3sVolume, x: SupportsFloat, y: SupportsFloat, z: SupportsFloat) → pyvcad.pyvcad.Vec3#

Sample the volume at the given coordinates.

Parameters:

x (float) – X coordinate.
y (float) – Y coordinate.
z (float) – Z coordinate.

Returns:

The sampled 3D vector value.

Return type:

Vec3

class pyvcad.Vec4sVolume#

A VDB volume storing 4D vector values with single precision.

__init__(self: pyvcad.pyvcad.Vec4sVolume) → None#: Constructor. Creates an empty Vec4sVDBVolume.

bounding_box(self: pyvcad.pyvcad.Vec4sVolume) → tuple[pyvcad.pyvcad.Vec3, pyvcad.pyvcad.Vec3]#

Get the world space bounding box of the volume.

Returns:: The minimum and maximum coordinates.
Return type:: tuple[Vec3, Vec3]

clone(self: pyvcad.pyvcad.Vec4sVolume) → pyvcad.pyvcad.Vec4sVolume#

Create a thread-safe clone of this volume.

Returns:: A cloned volume instance.
Return type:: Vec4sVolume

grid_type(self: pyvcad.pyvcad.Vec4sVolume) → str#

Get the grid type name.

Returns:: The grid type name.
Return type:: str

sample(self: pyvcad.pyvcad.Vec4sVolume, x: SupportsFloat, y: SupportsFloat, z: SupportsFloat) → pyvcad.pyvcad.Vec4#

Sample the volume at the given coordinates.

Parameters:

x (float) – X coordinate.
y (float) – Y coordinate.
z (float) – Z coordinate.

Returns:

The sampled 4D vector value.

Return type:

Vec4

Loaders#

class pyvcad.DICOMLoader#

A loader for DICOM image stacks that converts them to VDB volumes.

__init__(self: pyvcad.pyvcad.DICOMLoader, directory: str, center: bool = False, rescale_slope: SupportsFloat = -inf, rescale_intercept: SupportsFloat = -inf, slice_thickness: SupportsFloat = -inf, x_pixel_spacing: SupportsFloat = -inf, y_pixel_spacing: SupportsFloat = -inf) → None#

Constructor. Creates a DICOMLoader for loading DICOM image stacks.

Parameters:

directory (str) – The directory containing the DICOM stack.
center (bool, optional) – Whether to center the volume at the origin. Default is false.
rescale_slope (double, optional) – The rescale slope to apply to pixel values.
rescale_intercept (double, optional) – The rescale intercept to apply to pixel values.
slice_thickness (double, optional) – The slice thickness in mm.
x_pixel_spacing (double, optional) – The pixel spacing in x direction in mm.
y_pixel_spacing (double, optional) – The pixel spacing in y direction in mm.

as_volume(self: pyvcad.pyvcad.DICOMLoader) → pyvcad.pyvcad.FloatVolume#

Convert the loaded DICOM stack to a VDB volume.

Returns:: The resulting VDB volume.
Return type:: FloatVDBVolume

get_bounding_box(self: pyvcad.pyvcad.DICOMLoader) → tuple[pyvcad.pyvcad.Vec3, pyvcad.pyvcad.Vec3]#

Get the axis-aligned bounding box of the loaded DICOM volume in mm.

Returns:: A tuple containing two glm.vec3 vectors representing the minimum and maximum corners of the bounding box ((min_x, min_y, min_z), (max_x, max_y, max_z)).
Return type:: tuple

get_dimensions(self: pyvcad.pyvcad.DICOMLoader) → pyvcad.pyvcad.Vec3#

Get the physical dimensions of the loaded DICOM volume in mm.

Returns:: A vector containing the dimensions in x, y, and z directions (x_dim, y_dim, z_dim).
Return type:: glm.vec3

get_min_max_hu(self: pyvcad.pyvcad.DICOMLoader) → tuple[float, float]#

Get the minimum and maximum Hounsfield Unit (HU) values in the loaded DICOM volume.

Returns:: A tuple containing the minimum and maximum HU values (min_hu, max_hu).
Return type:: tuple

get_rescale_intercept(self: pyvcad.pyvcad.DICOMLoader) → float#

Get the rescale intercept used for converting pixel values to Hounsfield Units (HU).

Returns:: The rescale intercept.
Return type:: double

get_rescale_slope(self: pyvcad.pyvcad.DICOMLoader) → float#

Get the rescale slope used for converting pixel values to Hounsfield Units (HU).

Returns:: The rescale slope.
Return type:: double

get_voxel_size(self: pyvcad.pyvcad.DICOMLoader) → pyvcad.pyvcad.Vec3#

Get the voxel size of the loaded DICOM volume in mm.

Returns:: A vector containing the voxel size in x, y, and z directions (x_size, y_size, z_size).
Return type:: glm.vec3

class pyvcad.TetrahedralDomain#

Immutable validated TET4 domain with shared CGAL point-location and outer-boundary queries.

__init__(self: pyvcad.pyvcad.TetrahedralDomain, points: numpy.ndarray, cells: numpy.ndarray) → None#

Construct a TET4 domain by copying NumPy-compatible arrays.

Parameters:

points (array-like) – Finite float32/float64 array with shape (N, 3).
cells (array-like) – Integer array with shape (M, 4).

Example

>>> domain = pv.TetrahedralDomain(points, cells)

property boundary_face_count#

property bounding_box#

property cell_count#

property cells#: Return a copy of normalized TET4 connectivity.

property point_count#

property points#: Return a copy of validated dataset-space point coordinates.

property reoriented_cell_count#

class pyvcad.UnstructuredFieldDataset#

Solver-neutral named point/cell scalar and Vec3 fields sharing one immutable TET4 domain.

__init__(self: pyvcad.pyvcad.UnstructuredFieldDataset, domain: pyvcad.pyvcad.TetrahedralDomain) → None#

Construct an empty field dataset sharing an immutable domain.

Parameters:: domain (TetrahedralDomain) – Prepared immutable TET4 domain.

Example

>>> results = pv.UnstructuredFieldDataset(domain)

add_cell_scalar(self: pyvcad.pyvcad.UnstructuredFieldDataset, name: str, values: numpy.ndarray, units: str = '', step_identifier: str = '', description: str = '') → None#

Add a copied cell-associated scalar field.

Parameters:

name (str) – Unique field name.
values (array-like) – Float32/float64 array with one value per cell.
units (str) – Optional units metadata.
step_identifier (str) – Optional load/time-step identifier.
description (str) – Optional descriptive metadata.

Example

>>> results.add_cell_scalar('material_id', material_ids)

add_cell_vector(self: pyvcad.pyvcad.UnstructuredFieldDataset, name: str, values: numpy.ndarray, units: str = '', step_identifier: str = '', description: str = '') → None#

Add a copied cell-associated three-component vector field.

Parameters:

name (str) – Unique field name.
values (array-like) – Float32/float64 array with shape (cell_count, 3).
units (str) – Optional units metadata.
step_identifier (str) – Optional load/time-step identifier.
description (str) – Optional descriptive metadata.

Example

>>> results.add_cell_vector('flux', flux)

add_point_scalar(self: pyvcad.pyvcad.UnstructuredFieldDataset, name: str, values: numpy.ndarray, units: str = '', step_identifier: str = '', description: str = '') → None#

Add a copied point-associated scalar field.

Parameters:

name (str) – Unique field name.
values (array-like) – Float32/float64 array with one value per point.
units (str) – Optional units metadata.
step_identifier (str) – Optional load/time-step identifier.
description (str) – Optional descriptive metadata.

Example

>>> results.add_point_scalar('energy', energy, units='mJ/mm^3')

add_point_vector(self: pyvcad.pyvcad.UnstructuredFieldDataset, name: str, values: numpy.ndarray, units: str = '', step_identifier: str = '', description: str = '') → None#

Add a copied point-associated three-component vector field.

Parameters:

name (str) – Unique field name.
values (array-like) – Float32/float64 array with shape (point_count, 3).
units (str) – Optional units metadata.
step_identifier (str) – Optional load/time-step identifier.
description (str) – Optional descriptive metadata.

Example

>>> results.add_point_vector('displacement', displacement, units='mm')

coverage(self: pyvcad.pyvcad.UnstructuredFieldDataset, positions: numpy.ndarray, outside: object = 'error', max_distance: object = None, maximum_failures: SupportsInt = 8) → pyvcad.pyvcad.CoverageReport#

Classify a batch of consuming-coordinate query positions without persistent counters.

Parameters:

positions (array-like) – Float array with shape (N, 3).
outside (str | OutsidePolicy) – Outside policy to preflight.
max_distance (float | None) – Required finite boundary-clamp band.
maximum_failures (int) – Bounded number of representative outside points.

Example

>>> report = results.coverage(points, outside='boundary_clamp', max_distance=0.8)

property domain#

field_metadata(self: pyvcad.pyvcad.UnstructuredFieldDataset, name: str) → pyvcad.pyvcad.FieldMetadata#

Return read-only metadata for a named field.

Parameters:: name (str) – Field name.

Example

>>> metadata = results.field_metadata('displacement')

property field_names#

float_attribute(self: pyvcad.pyvcad.UnstructuredFieldDataset, name: str, outside: object = 'error', max_distance: object = None, constant_value: object = None) → pyvcad.pyvcad.FloatAttribute#

Create an ordinary FloatAttribute backed by a named scalar field.

Parameters:

name (str) – Scalar field name.
outside (str | OutsidePolicy) – error, constant, or boundary_clamp.
max_distance (float | None) – Required finite clamp band for boundary_clamp.
constant_value (float | None) – Explicit fallback; with boundary_clamp it applies beyond the band.

Example

>>> energy = results.float_attribute('energy', outside='boundary_clamp', max_distance=0.8)

static from_tetrahedra(points: numpy.ndarray, cells: numpy.ndarray) → pyvcad.pyvcad.UnstructuredFieldDataset#

Construct a dataset by copying point and TET4 connectivity arrays.

Parameters:

points (array-like) – Float32/float64 array with shape (N, 3).
cells (array-like) – Integer array with shape (M, 4).

Example

>>> results = pv.UnstructuredFieldDataset.from_tetrahedra(points, cells)

has_field(self: pyvcad.pyvcad.UnstructuredFieldDataset, name: str) → bool#

Return whether a named field exists.

Parameters:: name (str) – Field name.

Example

>>> assert results.has_field('displacement')

property position_transform#

sample_scalar(self: pyvcad.pyvcad.UnstructuredFieldDataset, name: str, position: numpy.ndarray, outside: object = 'error', max_distance: object = None, constant_value: object = None) → pyvcad.pyvcad.ScalarFieldSample#

Diagnostically sample a scalar field and return its classification.

Parameters:

name (str) – Scalar field name.
position (array-like) – Three consuming-coordinate values.
outside (str | OutsidePolicy) – Outside policy.
max_distance (float | None) – Finite clamp band.
constant_value (float | None) – Explicit fallback.

Example

>>> sample = results.sample_scalar('energy', [0.1, 0.1, 0.1])

sample_vector(self: pyvcad.pyvcad.UnstructuredFieldDataset, name: str, position: numpy.ndarray, outside: object = 'error', max_distance: object = None, constant_value: object = None) → pyvcad.pyvcad.Vec3FieldSample#

Diagnostically sample a vector field and return its classification.

Parameters:

name (str) – Vector field name.
position (array-like) – Three consuming-coordinate values.
outside (str | OutsidePolicy) – Outside policy.
max_distance (float | None) – Finite clamp band.
constant_value (array-like | None) – Explicit three-component fallback.

Example

>>> sample = results.sample_vector('displacement', [0.1, 0.1, 0.1])

transformed(self: pyvcad.pyvcad.UnstructuredFieldDataset, position_transform: numpy.ndarray, vector_transform: object = None) → pyvcad.pyvcad.UnstructuredFieldDataset#

Return a field view with explicit position and vector component transforms.

position_transform maps consuming-node positions into reference dataset coordinates. vector_transform separately maps stored vector components into consuming coordinates. Neither transform implicitly deforms the TET4 domain from a displacement field.

Parameters:

position_transform (array-like) – Non-singular affine 4x4 consumer-to-dataset matrix.
vector_transform (array-like | None) – Non-singular 3x3 stored-to-consumer vector matrix.

Example

>>> aligned = results.transformed(consumer_to_dataset, dataset_to_consumer_vectors)

vec3_attribute(self: pyvcad.pyvcad.UnstructuredFieldDataset, name: str, outside: object = 'error', max_distance: object = None, constant_value: object = None) → pyvcad.pyvcad.Vec3Attribute#

Create an ordinary Vec3Attribute backed by a named vector field.

Parameters:

name (str) – Three-component field name.
outside (str | OutsidePolicy) – error, constant, or boundary_clamp.
max_distance (float | None) – Required finite clamp band for boundary_clamp.
constant_value (array-like | None) – Explicit three-component fallback.

Example

>>> displacement = results.vec3_attribute('displacement')

property vector_transform#

class pyvcad.XDMFFieldLoader#

Public loader for the documented XDMF 3/HDF5 Uniform TET4 result-field subset.

static load(xdmf_path: str, grid_name: str = '', field_names: collections.abc.Sequence[str] = []) → pyvcad.pyvcad.UnstructuredFieldDataset#

Load one supported XDMF Uniform TET4 grid and selected HDF-backed fields.

Parameters:

xdmf_path (str) – XDMF 3 document path.
grid_name (str) – Required selection when multiple Uniform grids are present.
field_names (list[str]) – Selected fields, or an empty list for all fields.

Example

>>> results = pv.XDMFFieldLoader.load('results.xdmf', field_names=['displacement'])

class pyvcad.FieldMetadata#: Read-only metadata for one named unstructured result field.

class pyvcad.CoverageReport#

Opt-in classification report for a batch of sample positions.

fraction(self: pyvcad.pyvcad.CoverageReport, status: pyvcad.pyvcad.SampleStatus) → float#

Return the fraction assigned to one SampleStatus.

Parameters:: status (SampleStatus) – Classification to inspect.

Example

>>> outside_fraction = report.fraction(pv.SampleStatus.OUTSIDE)

class pyvcad.ScalarFieldSample#: Diagnostic scalar value and geometric classification.

class pyvcad.Vec3FieldSample#: Diagnostic vector value and geometric classification.

class pyvcad.CoverageFailure#: Representative outside-domain query retained by a coverage report.

class pyvcad.FieldAssociation#

Association of result values with mesh points or cells.

Members:

POINT

CELL

FieldAssociation.name -> str

class pyvcad.OutsidePolicy#

Explicit behavior outside an unstructured field domain.

Members:

ERROR

CONSTANT

BOUNDARY_CLAMP

OutsidePolicy.name -> str

class pyvcad.SampleStatus#

Diagnostic classification for one result-field query.

Members:

INSIDE

TOLERANCE_ADJUSTED

BOUNDARY_CLAMPED

OUTSIDE

SampleStatus.name -> str

`pyvcad.vdb_loader`#

VDB file loading utilities

Volumes#

Examples#

Unstructured TET4 result fields#

Volume types#

Loaders#

pyvcad.vdb_loader#

`pyvcad.vdb_loader`#