liblaf.apple.sim.actor

Modules:

• actor –
• protocol –

Classes:

• Actor –

  Actor(collision_mesh: warp.types.Mesh | None = None, dirichlet_local: liblaf.apple.sim.dirichlet.dirichlet.Dirichlet | None = None, dofs_global: liblaf.apple.sim.dofs.dofs.DOFs = None, region: liblaf.apple.sim.region.region.Region = None, *, id: str = None)

Actor

Bases: PyTreeNodeMutable

Actor(collision_mesh: warp.types.Mesh | None = None, dirichlet_local: liblaf.apple.sim.dirichlet.dirichlet.Dirichlet | None = None, dofs_global: liblaf.apple.sim.dofs.dofs.DOFs = None, region: liblaf.apple.sim.region.region.Region = None, *, id: str = None)

Parameters:

• id (str, default: None ) –
• collision_mesh (Mesh | None, default: None ) –
• dirichlet_local (Dirichlet | None, default: None ) –
• dofs_global (DOFs, default: None ) –
• region (Region, default: None ) –

Methods:

• __post_init__ –
• boundary –
• from_geometry –
• from_pyvista –
• from_region –
• make_field –
• pre_optim_iter –
• pre_optim_iter_jit –
• pre_optim_iter_no_jit –
• pre_time_step –
• replace –
• set_field_data –
• set_point_data –
• to_pyvista –
• to_warp –
• tree_at –
• update –
• update_field_data –
• update_point_data –
• with_collision_mesh –
• with_dirichlet –
• with_dofs –

Attributes:

• __dataclass_fields__ (dict[str, Field[Any]]) –
• __setattr__ –
• cell_data (GeometryAttributes) –
• collision_mesh (Mesh | None) –
• dim (int) –
• dirichlet_global (Dirichlet | None) –
• dirichlet_local (Dirichlet | None) –
• displacement (Float[Array, 'points dim']) –
• dofs_global (DOFs) –
• element (Element) –
• field_data (GeometryAttributes) –
• force_ext (Float[Array, 'points dim']) –
• geometry (Geometry) –
• id (str) –
• mass (Float[Array, points]) –
• n_cells (int) –
• n_dirichlet (int) –
• n_dofs (int) –
• n_points (int) –
• point_data (GeometryAttributes) –
• points (Float[Array, 'points dim']) –
• positions (Float[Array, 'points dim']) –
• region (Region) –
• velocity (Float[Array, 'points dim']) –

__dataclass_fields__ class-attribute

__dataclass_fields__: dict[str, Field[Any]]

__setattr__ class-attribute instance-attribute

__setattr__ = __setattr__

cell_data property

cell_data: GeometryAttributes

collision_mesh class-attribute instance-attribute

collision_mesh: Mesh | None = field(
    default=None, static=True
)

dim property

dim: int

dirichlet_global property

dirichlet_global: Dirichlet | None

dirichlet_local class-attribute instance-attribute

dirichlet_local: Dirichlet | None = field(default=None)

displacement property

displacement: Float[Array, 'points dim']

dofs_global class-attribute instance-attribute

dofs_global: DOFs = field(default=None)

element property

element: Element

field_data property

field_data: GeometryAttributes

force_ext property

force_ext: Float[Array, 'points dim']

geometry property

geometry: Geometry

id class-attribute instance-attribute

id: str = field(default=None, kw_only=True)

mass property

mass: Float[Array, points]

n_cells property

n_cells: int

n_dirichlet property

n_dirichlet: int

n_dofs property

n_dofs: int

n_points property

n_points: int

point_data property

point_data: GeometryAttributes

points property

points: Float[Array, 'points dim']

positions property

positions: Float[Array, 'points dim']

region class-attribute instance-attribute

region: Region = field(default=None)

velocity property

velocity: Float[Array, 'points dim']

__post_init__

__post_init__() -> None

Source code in src/liblaf/apple/struct/tree/_node.py

def __post_init__(self) -> None:
    if self.id is None:
        self.id = uniq_id(self)

boundary

boundary() -> Actor

Source code in src/liblaf/apple/sim/actor/actor.py

def boundary(self) -> "Actor":
    raise NotImplementedError

from_geometry classmethod

from_geometry(
    geometry: Geometry,
    *,
    collision: bool = False,
    grad: bool = False,
    id_: str | None = None,
) -> Self

Source code in src/liblaf/apple/sim/actor/actor.py

@classmethod
def from_geometry(
    cls,
    geometry: Geometry,
    *,
    collision: bool = False,
    grad: bool = False,
    id_: str | None = None,
) -> Self:
    region: Region = Region.from_geometry(geometry, grad=grad)
    return cls.from_region(region, collision=collision, id_=id_)

from_pyvista classmethod

from_pyvista(
    mesh: DataSet,
    *,
    collision: bool = False,
    grad: bool = False,
    id_: str | None = None,
) -> Self

Source code in src/liblaf/apple/sim/actor/actor.py

@classmethod
def from_pyvista(
    cls,
    mesh: pv.DataSet,
    *,
    collision: bool = False,
    grad: bool = False,
    id_: str | None = None,
) -> Self:
    geometry: Geometry = Geometry.from_pyvista(mesh)
    return cls.from_geometry(geometry, collision=collision, grad=grad, id_=id_)

from_region classmethod

from_region(
    region: Region,
    *,
    collision: bool = False,
    id_: str | None = None,
) -> Self

Source code in src/liblaf/apple/sim/actor/actor.py

@classmethod
def from_region(
    cls, region: Region, *, collision: bool = False, id_: str | None = None
) -> Self:
    self: Self = cls(region=region, id=id_)  # pyright: ignore[reportArgumentType]
    self = self.update(
        displacement=jnp.zeros((region.n_points, region.dim)),
        velocity=jnp.zeros((region.n_points, region.dim)),
        force=jnp.zeros((region.n_points, region.dim)),
    )
    if collision:
        self = self.with_collision_mesh()
    return self

make_field

make_field(x: Float[ArrayLike, 'points dim']) -> Field

Source code in src/liblaf/apple/sim/actor/actor.py

def make_field(self, x: Float[ArrayLike, "points dim"]) -> Field:
    return Field.from_region(self.region, x)

pre_optim_iter

pre_optim_iter(
    displacement: Float[ArrayLike, "points dim"]
    | None = None,
) -> Self

Source code in src/liblaf/apple/sim/actor/actor.py

def pre_optim_iter(
    self, displacement: Float[ArrayLike, "points dim"] | None = None
) -> Self:
    self.update(displacement=displacement)
    if self.collision_mesh is not None:
        self.collision_mesh.points = wp.from_jax(self.positions, dtype=wp.vec3)
        self.collision_mesh.refit()
    return self

pre_optim_iter_jit deprecated

pre_optim_iter_jit(
    displacement: Float[ArrayLike, "points dim"]
    | None = None,
) -> Self

Deprecated

Actor.pre_optim_iter_jit() is deprecated.

Source code in src/liblaf/apple/sim/actor/actor.py

@utils.jit(inline=True, validate=False)
@deprecated("Actor.pre_optim_iter_jit() is deprecated.")
def pre_optim_iter_jit(
    self, displacement: Float[ArrayLike, "points dim"] | None = None
) -> Self:
    actor: Self = self.update(displacement)
    return actor

pre_optim_iter_no_jit deprecated

pre_optim_iter_no_jit(
    displacement: Float[ArrayLike, "points dim"]
    | None = None,
) -> Self

Deprecated

Actor.pre_optim_iter_no_jit() is deprecated.

Source code in src/liblaf/apple/sim/actor/actor.py

@deprecated("Actor.pre_optim_iter_no_jit() is deprecated.")
def pre_optim_iter_no_jit(
    self,
    displacement: Float[ArrayLike, "points dim"] | None = None,  # noqa: ARG002
) -> Self:
    if self.collision_mesh is not None:
        self.collision_mesh.points = wp.from_jax(self.positions, dtype=wp.vec3)
        self.collision_mesh.refit()
    return self

pre_time_step

pre_time_step() -> Self

Source code in src/liblaf/apple/sim/actor/actor.py

def pre_time_step(self) -> Self:
    return self

replace

replace(**changes: Any) -> Self

Source code in src/liblaf/apple/struct/tree/_pytree.py

def replace(self, **changes: Any) -> Self:
    return dataclasses.replace(self, **changes)

set_field_data deprecated

set_field_data(
    name: str, value: Shaped[ArrayLike, ...]
) -> Self

Deprecated

Use self.field_data[name] = value instead.

Source code in src/liblaf/apple/sim/actor/actor.py

@deprecated("Use `self.field_data[name] = value` instead.")
def set_field_data(self, name: str, value: Shaped[ArrayLike, "..."]) -> Self:
    self.field_data[name] = value
    return self

set_point_data deprecated

set_point_data(
    name: str, value: Shaped[ArrayLike, "points dim"]
) -> Self

Deprecated

Use self.point_data[name] = value instead.

Source code in src/liblaf/apple/sim/actor/actor.py

@deprecated("Use `self.point_data[name] = value` instead.")
def set_point_data(self, name: str, value: Shaped[ArrayLike, "points dim"]) -> Self:
    self.point_data[name] = value
    return self

to_pyvista

to_pyvista(*, attributes: bool = True) -> DataSet

Source code in src/liblaf/apple/sim/actor/actor.py

def to_pyvista(self, *, attributes: bool = True) -> pv.DataSet:
    mesh: pv.DataSet = self.geometry.to_pyvista(attributes=attributes)
    if attributes:
        dirichlet_mask: Bool[np.ndarray, "points dim"] = np.zeros(
            (mesh.n_points, self.dim), dtype=bool
        )
        dirichlet_values: Float[np.ndarray, "points dim"] = np.zeros(
            (mesh.n_points, self.dim)
        )
        if self.dirichlet_local is not None:
            dirichlet_mask = np.asarray(
                self.dirichlet_local.mask(dirichlet_mask), dtype=bool
            )
            dirichlet_values = np.asarray(
                self.dirichlet_local.apply(dirichlet_values)
            )
        mesh.point_data["dirichlet-mask"] = dirichlet_mask
        mesh.point_data["dirichlet-values"] = dirichlet_values
    return mesh

to_warp

to_warp(**kwargs) -> Mesh

Source code in src/liblaf/apple/sim/actor/actor.py

def to_warp(self, **kwargs) -> wp.Mesh:
    mesh: wp.Mesh = wp.Mesh(
        wp.from_jax(self.positions, dtype=wp.vec3),
        wp.from_jax(self.geometry.cells.ravel(), dtype=wp.int32),
        **kwargs,
    )
    return mesh

tree_at

tree_at(
    where: Callable[[Self], Node | Sequence[Node]],
    replace: Any | Sequence[Any] = MISSING,
    replace_fn: Callable[[Node], Any] = MISSING,
    is_leaf: Callable[[Any], bool] | None = None,
) -> Self

Source code in src/liblaf/apple/struct/tree/_pytree.py

def tree_at(
    self,
    where: Callable[[Self], Node | Sequence[Node]],
    replace: Any | Sequence[Any] | MISSING = MISSING,
    replace_fn: Callable[[Node], Any] | MISSING = MISSING,
    is_leaf: Callable[[Any], bool] | None = None,
) -> Self:
    kwargs: dict[str, Any] = {}
    if replace is not MISSING:
        kwargs["replace"] = replace
    if replace_fn is not MISSING:
        kwargs["replace_fn"] = replace_fn
    if is_leaf is not None:
        kwargs["is_leaf"] = is_leaf
    return eqx.tree_at(where, self, **kwargs)

update

update(
    displacement: Float[ArrayLike, "points dim"]
    | None = None,
    velocity: Float[ArrayLike, "points dim"] | None = None,
    force: Float[ArrayLike, "points dim"] | None = None,
) -> Self

Source code in src/liblaf/apple/sim/actor/actor.py

def update(
    self,
    displacement: Float[ArrayLike, "points dim"] | None = None,
    velocity: Float[ArrayLike, "points dim"] | None = None,
    force: Float[ArrayLike, "points dim"] | None = None,
) -> Self:
    if displacement is not None:
        self.point_data["displacement"] = displacement
    if velocity is not None:
        self.point_data["velocity"] = velocity
    if force is not None:
        self.point_data["force"] = force
    return self

update_field_data deprecated

update_field_data(
    updates: Mapping[str, Shaped[ArrayLike, ...]],
    /,
    **kwargs: Shaped[ArrayLike, ...],
) -> Self

Deprecated

Use self.field_data.update(...) instead.

Source code in src/liblaf/apple/sim/actor/actor.py

@deprecated("Use `self.field_data.update(...)` instead.")
def update_field_data(
    self,
    updates: Mapping[str, Shaped[ArrayLike, "..."]],
    /,
    **kwargs: Shaped[ArrayLike, "..."],
) -> Self:
    self.field_data.update(updates, **kwargs)
    return self

update_point_data deprecated

update_point_data(
    updates: Mapping[str, Shaped[ArrayLike, "points ..."]],
    /,
    **kwargs: Shaped[ArrayLike, "points ..."],
) -> Self

Deprecated

Use self.point_data.update(...) instead.

Source code in src/liblaf/apple/sim/actor/actor.py

@deprecated("Use `self.point_data.update(...)` instead.")
def update_point_data(
    self,
    updates: Mapping[str, Shaped[ArrayLike, "points ..."]],
    /,
    **kwargs: Shaped[ArrayLike, "points ..."],
) -> Self:
    self.point_data.update(updates, **kwargs)
    return self

with_collision_mesh

with_collision_mesh() -> Self

Source code in src/liblaf/apple/sim/actor/actor.py

def with_collision_mesh(self) -> Self:
    if self.collision_mesh is not None:
        return self
    mesh: wp.Mesh = self.to_warp()
    return self.replace(collision_mesh=mesh)

with_dirichlet

with_dirichlet(dirichlet_local: Dirichlet) -> Self

Source code in src/liblaf/apple/sim/actor/actor.py

def with_dirichlet(self, dirichlet_local: Dirichlet) -> Self:
    actor: Self = self
    actor = actor.replace(dirichlet_local=dirichlet_local)
    actor = actor.update(displacement=dirichlet_local.apply(actor.displacement))
    return actor

with_dofs

with_dofs(dofs_global: DOFs) -> Self

Source code in src/liblaf/apple/sim/actor/actor.py

def with_dofs(self, dofs_global: DOFs) -> Self:
    return self.replace(dofs_global=dofs_global)