liblaf.apple.sim.field

Modules:

• field –

Classes:

• Field –

  Field(region: liblaf.apple.sim.region.region.Region = None, values: jaxtyping.Float[Array, 'points *dim'] = None)

Field

Bases: PyTree

Field(region: liblaf.apple.sim.region.region.Region = None, values: jaxtyping.Float[Array, 'points *dim'] = None)

Parameters:

• region (Region, default: None ) –
• values (Float[Array, points * dim], default: None ) –

Methods:

• deformation_gradient –
• from_region –
• from_values –
• grad –
• replace –
• tree_at –

Attributes:

• __dataclass_fields__ (dict[str, Field[Any]]) –
• cells (Integer[Array, '{self.n_cells} {self.element.n_points}']) –
• dV (Float[Array, 'c q']) –
• dXdr (Float[Array, 'c q J J']) –
• dhdX (Float[Array, 'c q a J']) –
• dhdr (Float[Array, 'q a J']) –
• dim (Sequence[int]) –
• drdX (Float[Array, 'c q J J']) –
• element (Element) –
• geometry (Geometry) –
• h (Float[Array, 'q a']) –
• n_cells (int) –
• n_dofs (int) –
• n_points (int) –
• points (Integer[Array, '{self.n_points} {self.region.dim}']) –
• quadrature (Scheme) –
• region (Region) –
• values (Float[Array, points * dim]) –

__dataclass_fields__ class-attribute

__dataclass_fields__: dict[str, Field[Any]]

cells property

cells: Integer[
    Array, "{self.n_cells} {self.element.n_points}"
]

dV property

dV: Float[Array, 'c q']

dXdr property

dXdr: Float[Array, 'c q J J']

dhdX property

dhdX: Float[Array, 'c q a J']

dhdr property

dhdr: Float[Array, 'q a J']

dim property

dim: Sequence[int]

drdX property

drdX: Float[Array, 'c q J J']

element property

element: Element

geometry property

geometry: Geometry

h property

h: Float[Array, 'q a']

n_cells property

n_cells: int

n_dofs property

n_dofs: int

n_points property

n_points: int

points property

points: Integer[Array, '{self.n_points} {self.region.dim}']

quadrature property

quadrature: Scheme

region class-attribute instance-attribute

region: Region = field(default=None)

values class-attribute instance-attribute

values: Float[Array, points * dim] = field(default=None)

deformation_gradient

deformation_gradient() -> Float[
    Array,
    "{self.n_cells} {self.quadrature.n_points} {self.region.dim} {self.region.dim}",
]

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

@utils.jit(inline=True)
def deformation_gradient(
    self,
) -> Float[
    jax.Array,
    "{self.n_cells} {self.quadrature.n_points} {self.region.dim} {self.region.dim}",
]:
    return self.region.deformation_gradient(self.values)

from_region classmethod

from_region(region: Region, values: ArrayLike) -> Self

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

@classmethod
def from_region(cls, region: Region, values: ArrayLike) -> Self:
    values = jnp.asarray(values)
    values = jnp.broadcast_to(values, (region.n_points, *values.shape[1:]))
    chex.assert_shape(values, (region.n_points, ...))
    return cls(region=region, values=values)

from_values

from_values(values: ArrayLike) -> Self

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

def from_values(self, values: ArrayLike, /) -> Self:
    return self.replace(values=values)

grad

grad() -> Float[
    Array,
    "{self.n_cells} {self.quadrature.n_points} *dim {self.region.dim}",
]

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

@utils.jit(inline=True)
def grad(
    self,
) -> Float[
    jax.Array, "{self.n_cells} {self.quadrature.n_points} *dim {self.region.dim}"
]:
    return self.region.gradient(self.values)

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)

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)