Skip to content

liblaf.apple.jax ¤

Modules:

Classes:

Dirichlet ¤

Parameters:

  • dim ¤

    (int) –

  • dirichlet_index ¤

    (Integer[Array, dirichlet]) –

  • dirichlet_value ¤

    (Float[Array, dirichlet]) –

  • free_index ¤

    (Integer[Array, free]) –

  • n_points ¤

    (int) –
Returned by: Used by:

Methods:

Attributes:

dim instance-attribute ¤

dim: int

dirichlet_index instance-attribute ¤

dirichlet_index: Integer[Array, ' dirichlet']

dirichlet_value instance-attribute ¤

dirichlet_value: Float[Array, ' dirichlet']

free_index instance-attribute ¤

free_index: Integer[Array, ' free']

n_dirichlet property ¤

n_dirichlet: int

n_free property ¤

n_free: int

n_full property ¤

n_full: int

n_points instance-attribute ¤

n_points: int

get_dirichlet ¤

get_dirichlet(
    full: Float[Array, "points dim"],
) -> Float[Array, " dirichlet"]
Source code in src/liblaf/apple/jax/model/dirichlet/_dirichlet.py 
27
28
29
30
31
@eqx.filter_jit
def get_dirichlet(
    self, full: Float[Array, "points dim"]
) -> Float[Array, " dirichlet"]:
    return full.flatten()[self.dirichlet_index]

get_free ¤

get_free(
    full: Float[Array, "points dim"],
) -> Float[Array, " free"]
Source code in src/liblaf/apple/jax/model/dirichlet/_dirichlet.py 
33
34
35
@eqx.filter_jit
def get_free(self, full: Float[Array, "points dim"]) -> Float[Array, " free"]:
    return full.flatten()[self.free_index]

set_dirichlet ¤

set_dirichlet(
    full: Float[Array, "points dim"],
    values: Float[ArrayLike, " dirichlet"] | None = None,
) -> Float[Array, "points dim"]
Source code in src/liblaf/apple/jax/model/dirichlet/_dirichlet.py 
37
38
39
40
41
42
43
44
45
@eqx.filter_jit
def set_dirichlet(
    self,
    full: Float[Array, "points dim"],
    values: Float[ArrayLike, " dirichlet"] | None = None,
) -> Float[Array, "points dim"]:
    if values is None:
        values = self.dirichlet_value
    return full.flatten().at[self.dirichlet_index].set(values).reshape(full.shape)

set_free ¤

set_free(
    full: Float[Array, "points dim"],
    values: Float[ArrayLike, " free"],
) -> Float[Array, "points dim"]
Source code in src/liblaf/apple/jax/model/dirichlet/_dirichlet.py 
47
48
49
50
51
@eqx.filter_jit
def set_free(
    self, full: Float[Array, "points dim"], values: Float[ArrayLike, " free"]
) -> Float[Array, "points dim"]:
    return full.flatten().at[self.free_index].set(values).reshape(full.shape)

to_full ¤

to_full(
    free: Float[Array, " free"],
    dirichlet: Float[ArrayLike, " dirichlet"] | None = None,
) -> Float[Array, "points dim"]
Source code in src/liblaf/apple/jax/model/dirichlet/_dirichlet.py 
53
54
55
56
57
58
59
60
61
62
63
64
@eqx.filter_jit
def to_full(
    self,
    free: Float[Array, " free"],
    dirichlet: Float[ArrayLike, " dirichlet"] | None = None,
) -> Float[Array, "points dim"]:
    full: Float[Array, "points dim"] = jnp.empty(
        (self.n_points, self.dim), free.dtype
    )
    full = self.set_free(full, free)
    full = self.set_dirichlet(full, dirichlet)
    return full

DirichletBuilder ¤

DirichletBuilder(dim: int = 3)

Parameters:

  • mask ¤

    (Bool[ndarray, 'points dim']) –

  • value ¤

    (Float[ndarray, 'points dim']) –
Returned by: Used by:

Methods:

Attributes:

Source code in src/liblaf/apple/jax/model/dirichlet/_builder.py 
19
20
21
22
def __init__(self, dim: int = 3) -> None:
    mask: Bool[np.ndarray, "points dim"] = np.empty((0, dim), bool)
    value: Float[np.ndarray, "points dim"] = np.empty((0, dim))
    self.__attrs_init__(mask=mask, value=value)  # pyright: ignore[reportAttributeAccessIssue]

dim property ¤

dim: int

mask instance-attribute ¤

mask: Bool[ndarray, 'points dim']

n_points property ¤

n_points: int

value instance-attribute ¤

value: Float[ndarray, 'points dim']

add_pyvista ¤

add_pyvista(obj: DataSet) -> None
Source code in src/liblaf/apple/jax/model/dirichlet/_builder.py 
32
33
34
35
36
37
38
39
40
41
42
def add_pyvista(self, obj: pv.DataSet) -> None:
    point_id = obj.point_data[POINT_ID]
    self.resize(point_id.max() + 1)
    dirichlet_mask: Bool[Array, "points dim"] = self._left_broadcast_to(
        obj.point_data[DIRICHLET_MASK], obj.n_points
    )
    dirichlet_value: Float[Array, "points dim"] = self._left_broadcast_to(
        obj.point_data[DIRICHLET_VALUE], obj.n_points
    )
    self.mask[point_id] = dirichlet_mask
    self.value[point_id] = dirichlet_value

finalize ¤

finalize() -> Dirichlet
Source code in src/liblaf/apple/jax/model/dirichlet/_builder.py 
44
45
46
47
48
49
50
51
52
53
def finalize(self) -> Dirichlet:
    mask: Bool[Array, "points dim"] = jnp.asarray(self.mask)
    dirichlet_index: Integer[Array, " dirichlet"] = jnp.flatnonzero(mask)
    return Dirichlet(
        dim=self.dim,
        dirichlet_index=dirichlet_index,
        dirichlet_value=jnp.asarray(self.value.flat[dirichlet_index]),
        free_index=jnp.flatnonzero(~mask),
        n_points=self.n_points,
    )

resize ¤

resize(n_points: int) -> None
Source code in src/liblaf/apple/jax/model/dirichlet/_builder.py 
55
56
57
58
59
60
def resize(self, n_points: int) -> None:
    pad_after: int = n_points - self.n_points
    if pad_after <= 0:
        return
    self.mask = np.pad(self.mask, ((0, pad_after), (0, 0)), constant_values=False)
    self.value = np.pad(self.value, ((0, pad_after), (0, 0)), constant_values=0.0)

Element ¤

Base-class for a finite element which provides methods for plotting.

References
  1. felupe.Element
Returned by:

Methods:

Attributes:

cells property ¤

cells: Integer[Array, ' points']

dim property ¤

dim: int

n_points property ¤

n_points: int

points property ¤

points: Float[Array, 'points dim']

quadrature property ¤

quadrature: Scheme

function ¤

function(
    coords: Float[Array, " dim"],
) -> Float[Array, " points"]

Return the shape functions at given coordinates.

Source code in src/liblaf/apple/jax/fem/element/_element.py 
38
39
40
def function(self, coords: Float[Array, " dim"]) -> Float[Array, " points"]:
    """Return the shape functions at given coordinates."""
    raise NotImplementedError

gradient ¤

gradient(
    coords: Float[Array, " dim"],
) -> Float[Array, "points dim"]
Source code in src/liblaf/apple/jax/fem/element/_element.py 
42
43
def gradient(self, coords: Float[Array, " dim"]) -> Float[Array, "points dim"]:
    return jax.jacobian(self.function)(coords)

hessian ¤

hessian(
    coords: Float[Array, " dim"],
) -> Float[Array, "points dim dim"]
Source code in src/liblaf/apple/jax/fem/element/_element.py 
45
46
def hessian(self, coords: Float[Array, " dim"]) -> Float[Array, "points dim dim"]:
    return jax.hessian(self.function)(coords)

Geometry ¤

Parameters:

Returned by: Used by:

Methods:

Attributes:

cell_data property ¤

cell_data: DataSetAttributes

cells property ¤

cells: Integer[Array, 'c a']

cells_global property ¤

cells_global: Integer[Array, 'c a']

element property ¤

element: Element

mesh class-attribute instance-attribute ¤

mesh: DataSet = field()

n_cells property ¤

n_cells: int

point_data property ¤

point_data: DataSetAttributes

point_id property ¤

point_id: Integer[Array, 'p J']

points property ¤

points: Float[Array, 'p J']

from_pyvista classmethod ¤

from_pyvista(mesh: DataObject) -> Geometry
Source code in src/liblaf/apple/jax/fem/geometry/_geometry.py 
16
17
18
19
20
21
22
23
24
25
@classmethod
def from_pyvista(cls, mesh: pv.DataObject) -> Geometry:
    from ._tetra import GeometryTetra
    from ._triangle import GeometryTriangle

    if isinstance(mesh, pv.PolyData):
        return GeometryTriangle.from_pyvista(mesh)
    if isinstance(mesh, pv.UnstructuredGrid):
        return GeometryTetra.from_pyvista(mesh)
    raise NotImplementedError

GeometryTetra ¤

Bases: Geometry


              flowchart TD
              liblaf.apple.jax.GeometryTetra[GeometryTetra]
              liblaf.apple.jax.fem.geometry._geometry.Geometry[Geometry]

                              liblaf.apple.jax.fem.geometry._geometry.Geometry --> liblaf.apple.jax.GeometryTetra
                


              click liblaf.apple.jax.GeometryTetra href "" "liblaf.apple.jax.GeometryTetra"
              click liblaf.apple.jax.fem.geometry._geometry.Geometry href "" "liblaf.apple.jax.fem.geometry._geometry.Geometry"

Parameters:

  • mesh ¤

    (UnstructuredGrid) –

Methods:

Attributes:

cell_data property ¤

cell_data: DataSetAttributes

cells property ¤

cells: Integer[Array, 'c a']

cells_global property ¤

cells_global: Integer[Array, 'c a']

element property ¤

element: ElementTetra

mesh class-attribute instance-attribute ¤

mesh: UnstructuredGrid = field()

n_cells property ¤

n_cells: int

point_data property ¤

point_data: DataSetAttributes

point_id property ¤

point_id: Integer[Array, 'p J']

points property ¤

points: Float[Array, 'p J']

from_pyvista classmethod ¤

from_pyvista(mesh: UnstructuredGrid) -> Self
Source code in src/liblaf/apple/jax/fem/geometry/_tetra.py 
17
18
19
20
21
@override
@classmethod
def from_pyvista(cls, mesh: pv.UnstructuredGrid) -> Self:  # pyright: ignore[reportIncompatibleMethodOverride]
    self: Self = cls(mesh=mesh)
    return self

GeometryTriangle ¤

Bases: Geometry


              flowchart TD
              liblaf.apple.jax.GeometryTriangle[GeometryTriangle]
              liblaf.apple.jax.fem.geometry._geometry.Geometry[Geometry]

                              liblaf.apple.jax.fem.geometry._geometry.Geometry --> liblaf.apple.jax.GeometryTriangle
                


              click liblaf.apple.jax.GeometryTriangle href "" "liblaf.apple.jax.GeometryTriangle"
              click liblaf.apple.jax.fem.geometry._geometry.Geometry href "" "liblaf.apple.jax.fem.geometry._geometry.Geometry"

Parameters:

  • mesh ¤

    (PolyData) –

Methods:

Attributes:

cell_data property ¤

cell_data: DataSetAttributes

cells property ¤

cells: Integer[Array, 'c a']

cells_global property ¤

cells_global: Integer[Array, 'c a']

element property ¤

element: Element

mesh class-attribute instance-attribute ¤

mesh: PolyData = field()

n_cells property ¤

n_cells: int

point_data property ¤

point_data: DataSetAttributes

point_id property ¤

point_id: Integer[Array, 'p J']

points property ¤

points: Float[Array, 'p J']

from_pyvista classmethod ¤

from_pyvista(mesh: PolyData) -> Self
Source code in src/liblaf/apple/jax/fem/geometry/_triangle.py 
15
16
17
18
19
20
@override
@classmethod
def from_pyvista(cls, mesh: pv.PolyData) -> Self:  # pyright: ignore[reportIncompatibleMethodOverride]
    mesh = mesh.triangulate()  # pyright: ignore[reportAssignmentType]
    self: Self = cls(mesh=mesh)
    return self

Gravity ¤

Bases: JaxEnergy


              flowchart TD
              liblaf.apple.jax.Gravity[Gravity]
              liblaf.apple.jax.model._energy.JaxEnergy[JaxEnergy]
              liblaf.apple.utils._id_mixin.IdMixin[IdMixin]

                              liblaf.apple.jax.model._energy.JaxEnergy --> liblaf.apple.jax.Gravity
                                liblaf.apple.utils._id_mixin.IdMixin --> liblaf.apple.jax.model._energy.JaxEnergy
                



              click liblaf.apple.jax.Gravity href "" "liblaf.apple.jax.Gravity"
              click liblaf.apple.jax.model._energy.JaxEnergy href "" "liblaf.apple.jax.model._energy.JaxEnergy"
              click liblaf.apple.utils._id_mixin.IdMixin href "" "liblaf.apple.utils._id_mixin.IdMixin"

Parameters:

  • id ¤

    (str, default: <dynamic> ) –

  • requires_grad ¤

    (frozenset[str], default: frozenset() ) –

  • gravity ¤

    (Float[Array, dim]) –

  • indices ¤

    (Integer[Array, points]) –

  • mass ¤

    (Float[Array, points]) –

Methods:

Attributes:

gravity instance-attribute ¤

gravity: Float[Array, ' dim']

id class-attribute instance-attribute ¤

id: str = field(
    default=Factory(_default_id, takes_self=True),
    kw_only=True,
)

indices instance-attribute ¤

indices: Integer[Array, ' points']

mass instance-attribute ¤

mass: Float[Array, ' points']

requires_grad class-attribute instance-attribute ¤

requires_grad: frozenset[str] = field(
    default=frozenset(), kw_only=True
)

from_pyvista classmethod ¤

from_pyvista(
    obj: DataSet,
    gravity: Float[ArrayLike, " dim"] | None = None,
) -> Self
Source code in src/liblaf/apple/jax/energies/_gravity.py 
23
24
25
26
27
28
29
30
31
32
33
@classmethod
def from_pyvista(
    cls, obj: pv.DataSet, gravity: Float[ArrayLike, " dim"] | None = None
) -> Self:
    if gravity is None:
        gravity = jnp.asarray([0.0, -9.81, 0.0])
    return cls(
        gravity=jnp.asarray(gravity),
        indices=jnp.asarray(obj.point_data[POINT_ID]),
        mass=jnp.asarray(obj.point_data[MASS]),
    )

fun ¤

fun(u: Vector) -> Scalar
Source code in src/liblaf/apple/jax/energies/_gravity.py 
35
36
37
38
@override
def fun(self, u: Vector) -> Scalar:
    u = u[self.indices]
    return -jnp.vdot(self.mass, jnp.vecdot(u, self.gravity, axis=-1))

grad ¤

grad(u: Vector) -> Updates
Source code in src/liblaf/apple/jax/model/_energy.py 
33
34
35
36
@eqx.filter_jit
def grad(self, u: Vector) -> Updates:
    values: Vector = eqx.filter_grad(self.fun)(u)
    return values, jnp.arange(u.shape[0])

grad_and_hess_diag ¤

grad_and_hess_diag(u: Vector) -> tuple[Updates, Updates]
Source code in src/liblaf/apple/jax/model/_energy.py 
61
62
63
@eqx.filter_jit
def grad_and_hess_diag(self, u: Vector) -> tuple[Updates, Updates]:
    return self.grad(u), self.hess_diag(u)

hess_diag ¤

hess_diag(u: Vector) -> Updates
Source code in src/liblaf/apple/jax/energies/_gravity.py 
40
41
42
@override
def hess_diag(self, u: Vector) -> Updates:
    return jnp.zeros_like(u[self.indices]), self.indices

hess_prod ¤

hess_prod(u: Vector, p: Vector) -> Updates
Source code in src/liblaf/apple/jax/model/_energy.py 
41
42
43
44
45
@eqx.filter_jit
def hess_prod(self, u: Vector, p: Vector) -> Updates:
    values: Vector
    _, values = jax.jvp(jax.grad(self.fun), (u,), (p,))
    return values, jnp.arange(u.shape[0])

hess_quad ¤

hess_quad(u: Vector, p: Vector) -> Scalar
Source code in src/liblaf/apple/jax/model/_energy.py 
47
48
49
50
51
52
@eqx.filter_jit
def hess_quad(self, u: Vector, p: Vector) -> Scalar:
    values: Vector
    index: Index
    values, index = self.hess_prod(u, p)
    return jnp.vdot(p[index], values)

mixed_derivative_prod ¤

mixed_derivative_prod(
    u: Vector, p: Vector
) -> EnergyParams
Source code in src/liblaf/apple/jax/model/_energy.py 
65
66
67
68
69
70
71
@eqx.filter_jit
def mixed_derivative_prod(self, u: Vector, p: Vector) -> EnergyParams:
    outputs: EnergyParams = {
        name: getattr(self, f"mixed_derivative_prod_{name}")(u, p)
        for name in self.requires_grad
    }
    return outputs

update ¤

update(u: Vector) -> None
Source code in src/liblaf/apple/jax/model/_energy.py 
22
23
24
@eqx.filter_jit
def update(self, u: Vector) -> None:
    pass

update_params ¤

update_params(params: Mapping[str, Array]) -> None
Source code in src/liblaf/apple/jax/model/_energy.py 
26
27
28
def update_params(self, params: Mapping[str, Array]) -> None:
    for name, value in params.items():
        setattr(self, name, value)

value_and_grad ¤

value_and_grad(u: Vector) -> tuple[Scalar, Updates]
Source code in src/liblaf/apple/jax/model/_energy.py 
54
55
56
57
58
59
@eqx.filter_jit
def value_and_grad(self, u: Vector) -> tuple[Scalar, Updates]:
    value: Scalar
    grad: Vector
    value, grad = jax.value_and_grad(self.fun)(u)
    return value, (grad, jnp.arange(u.shape[0]))

JaxEnergy ¤

Bases: IdMixin


              flowchart TD
              liblaf.apple.jax.JaxEnergy[JaxEnergy]
              liblaf.apple.utils._id_mixin.IdMixin[IdMixin]

                              liblaf.apple.utils._id_mixin.IdMixin --> liblaf.apple.jax.JaxEnergy
                


              click liblaf.apple.jax.JaxEnergy href "" "liblaf.apple.jax.JaxEnergy"
              click liblaf.apple.utils._id_mixin.IdMixin href "" "liblaf.apple.utils._id_mixin.IdMixin"

Parameters:

  • id ¤

    (str, default: <dynamic> ) –

  • requires_grad ¤

    (frozenset[str], default: frozenset() ) –
Subclassed by: Used by:

Methods:

Attributes:

id class-attribute instance-attribute ¤

id: str = field(
    default=Factory(_default_id, takes_self=True),
    kw_only=True,
)

requires_grad class-attribute instance-attribute ¤

requires_grad: frozenset[str] = field(
    default=frozenset(), kw_only=True
)

fun ¤

fun(u: Vector) -> Scalar
Source code in src/liblaf/apple/jax/model/_energy.py 
30
31
def fun(self, u: Vector) -> Scalar:
    raise NotImplementedError

grad ¤

grad(u: Vector) -> Updates
Source code in src/liblaf/apple/jax/model/_energy.py 
33
34
35
36
@eqx.filter_jit
def grad(self, u: Vector) -> Updates:
    values: Vector = eqx.filter_grad(self.fun)(u)
    return values, jnp.arange(u.shape[0])

grad_and_hess_diag ¤

grad_and_hess_diag(u: Vector) -> tuple[Updates, Updates]
Source code in src/liblaf/apple/jax/model/_energy.py 
61
62
63
@eqx.filter_jit
def grad_and_hess_diag(self, u: Vector) -> tuple[Updates, Updates]:
    return self.grad(u), self.hess_diag(u)

hess_diag ¤

hess_diag(u: Vector) -> Updates
Source code in src/liblaf/apple/jax/model/_energy.py 
38
39
def hess_diag(self, u: Vector) -> Updates:
    raise NotImplementedError

hess_prod ¤

hess_prod(u: Vector, p: Vector) -> Updates
Source code in src/liblaf/apple/jax/model/_energy.py 
41
42
43
44
45
@eqx.filter_jit
def hess_prod(self, u: Vector, p: Vector) -> Updates:
    values: Vector
    _, values = jax.jvp(jax.grad(self.fun), (u,), (p,))
    return values, jnp.arange(u.shape[0])

hess_quad ¤

hess_quad(u: Vector, p: Vector) -> Scalar
Source code in src/liblaf/apple/jax/model/_energy.py 
47
48
49
50
51
52
@eqx.filter_jit
def hess_quad(self, u: Vector, p: Vector) -> Scalar:
    values: Vector
    index: Index
    values, index = self.hess_prod(u, p)
    return jnp.vdot(p[index], values)

mixed_derivative_prod ¤

mixed_derivative_prod(
    u: Vector, p: Vector
) -> EnergyParams
Source code in src/liblaf/apple/jax/model/_energy.py 
65
66
67
68
69
70
71
@eqx.filter_jit
def mixed_derivative_prod(self, u: Vector, p: Vector) -> EnergyParams:
    outputs: EnergyParams = {
        name: getattr(self, f"mixed_derivative_prod_{name}")(u, p)
        for name in self.requires_grad
    }
    return outputs

update ¤

update(u: Vector) -> None
Source code in src/liblaf/apple/jax/model/_energy.py 
22
23
24
@eqx.filter_jit
def update(self, u: Vector) -> None:
    pass

update_params ¤

update_params(params: Mapping[str, Array]) -> None
Source code in src/liblaf/apple/jax/model/_energy.py 
26
27
28
def update_params(self, params: Mapping[str, Array]) -> None:
    for name, value in params.items():
        setattr(self, name, value)

value_and_grad ¤

value_and_grad(u: Vector) -> tuple[Scalar, Updates]
Source code in src/liblaf/apple/jax/model/_energy.py 
54
55
56
57
58
59
@eqx.filter_jit
def value_and_grad(self, u: Vector) -> tuple[Scalar, Updates]:
    value: Scalar
    grad: Vector
    value, grad = jax.value_and_grad(self.fun)(u)
    return value, (grad, jnp.arange(u.shape[0]))

JaxModel ¤

Parameters:

  • energies ¤

    (dict[str, JaxEnergy], default: <class 'dict'> ) –

    dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object’s (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)

Returned by: Used by:

Methods:

Attributes:

energies class-attribute instance-attribute ¤

energies: dict[str, JaxEnergy] = field(
    factory=dict, kw_only=True
)

fun ¤

fun(x: Vector) -> Scalar
Source code in src/liblaf/apple/jax/model/_model.py 
29
30
31
32
33
34
@eqx.filter_jit
def fun(self, x: Vector) -> Scalar:
    output: Scalar = jnp.zeros(())
    for energy in self.energies.values():
        output += energy.fun(x)
    return output

grad ¤

grad(x: Vector) -> Vector
Source code in src/liblaf/apple/jax/model/_model.py 
36
37
38
39
40
41
42
43
44
@eqx.filter_jit
def grad(self, x: Vector) -> Vector:
    output: Vector = jnp.zeros_like(x)
    for energy in self.energies.values():
        grad: Vector
        index: Index
        grad, index = energy.grad(x)
        output = output.at[index].add(grad)
    return output

grad_and_hess_diag ¤

grad_and_hess_diag(x: Vector) -> tuple[Vector, Vector]
Source code in src/liblaf/apple/jax/model/_model.py 
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
@eqx.filter_jit
def grad_and_hess_diag(self, x: Vector) -> tuple[Vector, Vector]:
    grad: Vector = jnp.zeros_like(x)
    hess_diag: Vector = jnp.zeros_like(x)
    for energy in self.energies.values():
        grad_i: Vector
        index_g: Index
        hess_diag_i: Vector
        index_h: Index
        (grad_i, index_g), (hess_diag_i, index_h) = energy.grad_and_hess_diag(x)
        grad = grad.at[index_g].add(grad_i)
        hess_diag = hess_diag.at[index_h].add(hess_diag_i)
    return grad, hess_diag

hess_diag ¤

hess_diag(x: Vector) -> Vector
Source code in src/liblaf/apple/jax/model/_model.py 
46
47
48
49
50
51
52
53
54
@eqx.filter_jit
def hess_diag(self, x: Vector) -> Vector:
    output: Vector = jnp.zeros_like(x)
    for energy in self.energies.values():
        diag: Vector
        index: Index
        diag, index = energy.hess_diag(x)
        output = output.at[index].add(diag)
    return output

hess_prod ¤

hess_prod(x: Vector, p: Vector) -> Vector
Source code in src/liblaf/apple/jax/model/_model.py 
56
57
58
59
60
61
62
63
64
@eqx.filter_jit
def hess_prod(self, x: Vector, p: Vector) -> Vector:
    output: Vector = jnp.zeros_like(x)
    for energy in self.energies.values():
        prod: Vector
        index: Index
        prod, index = energy.hess_prod(x, p)
        output = output.at[index].add(prod)
    return output

hess_quad ¤

hess_quad(x: Vector, p: Vector) -> Scalar
Source code in src/liblaf/apple/jax/model/_model.py 
66
67
68
69
70
71
@eqx.filter_jit
def hess_quad(self, x: Vector, p: Vector) -> Scalar:
    output: Scalar = jnp.zeros(())
    for energy in self.energies.values():
        output += energy.hess_quad(x, p)
    return output

mixed_derivative_prod ¤

mixed_derivative_prod(
    x: Vector, p: Vector
) -> ModelParams
Source code in src/liblaf/apple/jax/model/_model.py 
73
74
75
76
77
78
@eqx.filter_jit
def mixed_derivative_prod(self, x: Vector, p: Vector) -> ModelParams:
    return {
        name: energy.mixed_derivative_prod(x, p)
        for name, energy in self.energies.items()
    }

update ¤

update(x: Vector) -> None
Source code in src/liblaf/apple/jax/model/_model.py 
21
22
23
def update(self, x: Vector) -> None:
    for energy in self.energies.values():
        energy.update(x)

update_params ¤

update_params(params: ModelParams) -> None
Source code in src/liblaf/apple/jax/model/_model.py 
25
26
27
def update_params(self, params: ModelParams) -> None:
    for name, energy_params in params.items():
        self.energies[name].update_params(energy_params)

value_and_grad ¤

value_and_grad(x: Vector) -> tuple[Scalar, Vector]
Source code in src/liblaf/apple/jax/model/_model.py 
80
81
82
83
84
85
86
87
88
89
90
@eqx.filter_jit
def value_and_grad(self, x: Vector) -> tuple[Scalar, Vector]:
    value: Scalar = jnp.zeros(())
    grad: Vector = jnp.zeros_like(x)
    for energy in self.energies.values():
        value_i: Scalar
        grad_i: Vector
        value_i, (grad_i, index) = energy.value_and_grad(x)
        value += value_i
        grad = grad.at[index].add(grad_i)
    return value, grad

JaxModelBuilder ¤

Parameters:

  • energies ¤

    (dict[str, JaxEnergy], default: <class 'dict'> ) –

    dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object’s (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)

Returned by: Used by:

Methods:

Attributes:

energies class-attribute instance-attribute ¤

energies: dict[str, JaxEnergy] = field(
    factory=dict, kw_only=True
)

add_energy ¤

add_energy(energy: JaxEnergy) -> None
Source code in src/liblaf/apple/jax/model/_builder.py 
11
12
def add_energy(self, energy: JaxEnergy) -> None:
    self.energies[energy.id] = energy

finalize ¤

finalize() -> JaxModel
Source code in src/liblaf/apple/jax/model/_builder.py 
14
15
def finalize(self) -> JaxModel:
    return JaxModel(energies=self.energies)

MassSpring ¤

Bases: JaxEnergy


              flowchart TD
              liblaf.apple.jax.MassSpring[MassSpring]
              liblaf.apple.jax.model._energy.JaxEnergy[JaxEnergy]
              liblaf.apple.utils._id_mixin.IdMixin[IdMixin]

                              liblaf.apple.jax.model._energy.JaxEnergy --> liblaf.apple.jax.MassSpring
                                liblaf.apple.utils._id_mixin.IdMixin --> liblaf.apple.jax.model._energy.JaxEnergy
                



              click liblaf.apple.jax.MassSpring href "" "liblaf.apple.jax.MassSpring"
              click liblaf.apple.jax.model._energy.JaxEnergy href "" "liblaf.apple.jax.model._energy.JaxEnergy"
              click liblaf.apple.utils._id_mixin.IdMixin href "" "liblaf.apple.utils._id_mixin.IdMixin"

Parameters:

  • id ¤

    (str, default: <dynamic> ) –

  • requires_grad ¤

    (frozenset[str], default: frozenset() ) –

  • edges ¤

    (Integer[Array, 'edges 2']) –

  • length ¤

    (Float[Array, edges]) –

  • points ¤

    (Float[Array, 'edges 2 3']) –

  • stiffness ¤

    (Float[Array, edges]) –

Methods:

Attributes:

edges instance-attribute ¤

edges: Integer[Array, ' edges 2']

id class-attribute instance-attribute ¤

id: str = field(
    default=Factory(_default_id, takes_self=True),
    kw_only=True,
)

length instance-attribute ¤

length: Float[Array, ' edges']

n_edges property ¤

n_edges: int

points instance-attribute ¤

points: Float[Array, 'edges 2 3']

requires_grad class-attribute instance-attribute ¤

requires_grad: frozenset[str] = field(
    default=frozenset(), kw_only=True
)

stiffness instance-attribute ¤

stiffness: Float[Array, ' edges']

from_pyvista classmethod ¤

from_pyvista(obj: PolyData) -> Self
Source code in src/liblaf/apple/jax/energies/_mass_spring.py 
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
@classmethod
def from_pyvista(cls, obj: pv.PolyData) -> Self:
    if LENGTH not in obj.cell_data:
        obj = obj.compute_cell_sizes(length=True, area=False, volume=False)  # pyright: ignore[reportAssignmentType]
    point_id: Integer[np.ndarray, " points"] = obj.point_data[POINT_ID]
    edges: Integer[np.ndarray, "edges 2"] = obj.lines.reshape((-1, 3))[:, 1:]
    length: Float[Array, " edges"] = jnp.asarray(obj.cell_data[LENGTH])
    if jnp.any(length < 0.0):
        logger.warning("Length < 0")
    return cls(
        edges=jnp.asarray(point_id[edges]),
        length=length,
        points=jnp.asarray(obj.points[edges]),
        stiffness=jnp.asarray(obj.cell_data[STIFFNESS]),
    )

fun ¤

fun(u: Vector) -> Scalar
Source code in src/liblaf/apple/jax/energies/_mass_spring.py 
49
50
51
52
53
54
55
56
57
58
@override
def fun(self, u: Vector) -> Scalar:
    x: Float[Array, "edges 2 3"] = self.points + u[self.edges]
    delta: Float[Array, "edges 3"] = x[:, 1, :] - x[:, 0, :]
    energy: Float[Array, " edges"] = (
        0.5
        * self.stiffness
        * jnp.square(jnp.linalg.norm(delta, axis=-1) - self.length)
    )
    return jnp.sum(energy)

grad ¤

grad(u: Vector) -> Updates
Source code in src/liblaf/apple/jax/energies/_mass_spring.py 
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
@override
def grad(self, u: Vector) -> Updates:
    x: Float[Array, "edges 2 3"] = self.points + u[self.edges]
    delta: Float[Array, "edges 3"] = x[:, 1, :] - x[:, 0, :]
    length: Float[Array, " edges"] = jnp.linalg.norm(delta, axis=-1)
    direction: Float[Array, "edges 3"] = (
        delta / jnp.where(length > 0, length, 1.0)[:, jnp.newaxis]
    )
    force: Float[Array, "edges 3"] = (
        self.stiffness[:, jnp.newaxis]
        * (length - self.length)[:, jnp.newaxis]
        * direction
    )
    grad: Float[Array, "edges 2 3"] = jnp.stack([-force, force], axis=1)
    return grad, self.edges.flatten()

grad_and_hess_diag ¤

grad_and_hess_diag(u: Vector) -> tuple[Updates, Updates]
Source code in src/liblaf/apple/jax/model/_energy.py 
61
62
63
@eqx.filter_jit
def grad_and_hess_diag(self, u: Vector) -> tuple[Updates, Updates]:
    return self.grad(u), self.hess_diag(u)

hess_diag ¤

hess_diag(u: Vector) -> Updates
Source code in src/liblaf/apple/jax/energies/_mass_spring.py 
76
77
78
79
80
81
@override
def hess_diag(self, u: Vector) -> Updates:
    values: Float[Array, "edges*2 3"] = einops.repeat(
        self.stiffness, "edges -> (edges i) j", i=2, j=3
    )
    return values, self.edges.flatten()

hess_prod ¤

hess_prod(u: Vector, p: Vector) -> Updates
Source code in src/liblaf/apple/jax/model/_energy.py 
41
42
43
44
45
@eqx.filter_jit
def hess_prod(self, u: Vector, p: Vector) -> Updates:
    values: Vector
    _, values = jax.jvp(jax.grad(self.fun), (u,), (p,))
    return values, jnp.arange(u.shape[0])

hess_quad ¤

hess_quad(u: Vector, p: Vector) -> Scalar
Source code in src/liblaf/apple/jax/model/_energy.py 
47
48
49
50
51
52
@eqx.filter_jit
def hess_quad(self, u: Vector, p: Vector) -> Scalar:
    values: Vector
    index: Index
    values, index = self.hess_prod(u, p)
    return jnp.vdot(p[index], values)

mixed_derivative_prod ¤

mixed_derivative_prod(
    u: Vector, p: Vector
) -> EnergyParams
Source code in src/liblaf/apple/jax/model/_energy.py 
65
66
67
68
69
70
71
@eqx.filter_jit
def mixed_derivative_prod(self, u: Vector, p: Vector) -> EnergyParams:
    outputs: EnergyParams = {
        name: getattr(self, f"mixed_derivative_prod_{name}")(u, p)
        for name in self.requires_grad
    }
    return outputs

update ¤

update(u: Vector) -> None
Source code in src/liblaf/apple/jax/model/_energy.py 
22
23
24
@eqx.filter_jit
def update(self, u: Vector) -> None:
    pass

update_params ¤

update_params(params: Mapping[str, Array]) -> None
Source code in src/liblaf/apple/jax/model/_energy.py 
26
27
28
def update_params(self, params: Mapping[str, Array]) -> None:
    for name, value in params.items():
        setattr(self, name, value)

value_and_grad ¤

value_and_grad(u: Vector) -> tuple[Scalar, Updates]
Source code in src/liblaf/apple/jax/model/_energy.py 
54
55
56
57
58
59
@eqx.filter_jit
def value_and_grad(self, u: Vector) -> tuple[Scalar, Updates]:
    value: Scalar
    grad: Vector
    value, grad = jax.value_and_grad(self.fun)(u)
    return value, (grad, jnp.arange(u.shape[0]))

MassSpringPrestrain ¤

Bases: MassSpring


              flowchart TD
              liblaf.apple.jax.MassSpringPrestrain[MassSpringPrestrain]
              liblaf.apple.jax.energies._mass_spring.MassSpring[MassSpring]
              liblaf.apple.jax.model._energy.JaxEnergy[JaxEnergy]
              liblaf.apple.utils._id_mixin.IdMixin[IdMixin]

                              liblaf.apple.jax.energies._mass_spring.MassSpring --> liblaf.apple.jax.MassSpringPrestrain
                                liblaf.apple.jax.model._energy.JaxEnergy --> liblaf.apple.jax.energies._mass_spring.MassSpring
                                liblaf.apple.utils._id_mixin.IdMixin --> liblaf.apple.jax.model._energy.JaxEnergy
                




              click liblaf.apple.jax.MassSpringPrestrain href "" "liblaf.apple.jax.MassSpringPrestrain"
              click liblaf.apple.jax.energies._mass_spring.MassSpring href "" "liblaf.apple.jax.energies._mass_spring.MassSpring"
              click liblaf.apple.jax.model._energy.JaxEnergy href "" "liblaf.apple.jax.model._energy.JaxEnergy"
              click liblaf.apple.utils._id_mixin.IdMixin href "" "liblaf.apple.utils._id_mixin.IdMixin"

Parameters:

  • id ¤

    (str, default: <dynamic> ) –

  • requires_grad ¤

    (frozenset[str], default: frozenset() ) –

  • edges ¤

    (Integer[Array, 'edges 2']) –

  • length ¤

    (Float[Array, edges]) –

  • points ¤

    (Float[Array, 'edges 2 3']) –

  • stiffness ¤

    (Float[Array, edges]) –

Methods:

Attributes:

edges instance-attribute ¤

edges: Integer[Array, ' edges 2']

id class-attribute instance-attribute ¤

id: str = field(
    default=Factory(_default_id, takes_self=True),
    kw_only=True,
)

length instance-attribute ¤

length: Float[Array, ' edges']

n_edges property ¤

n_edges: int

points instance-attribute ¤

points: Float[Array, 'edges 2 3']

requires_grad class-attribute instance-attribute ¤

requires_grad: frozenset[str] = field(
    default=frozenset(), kw_only=True
)

stiffness instance-attribute ¤

stiffness: Float[Array, ' edges']

from_pyvista classmethod ¤

from_pyvista(obj: PolyData) -> Self
Source code in src/liblaf/apple/jax/energies/_mass_spring_prestrain.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@classmethod
def from_pyvista(cls, obj: pv.PolyData) -> Self:
    if LENGTH not in obj.cell_data:
        obj = obj.compute_cell_sizes(length=True, area=False, volume=False)  # pyright: ignore[reportAssignmentType]
    point_id: Integer[np.ndarray, " points"] = obj.point_data[POINT_ID]
    edges: Integer[np.ndarray, "edges 2"] = obj.lines.reshape((-1, 3))[:, 1:]
    length: Float[Array, " edges"] = jnp.asarray(obj.cell_data[LENGTH])
    if jnp.any(length < 0.0):
        logger.warning("Length < 0")
    prestrain: Float[Array, " edges"] = jnp.asarray(obj.cell_data[PRESTRAIN])
    return cls(
        edges=jnp.asarray(point_id[edges]),
        length=length * (1.0 + prestrain),
        points=jnp.asarray(obj.points[edges]),
        stiffness=jnp.asarray(obj.cell_data[STIFFNESS]),
    )

fun ¤

fun(u: Vector) -> Scalar
Source code in src/liblaf/apple/jax/energies/_mass_spring.py 
49
50
51
52
53
54
55
56
57
58
@override
def fun(self, u: Vector) -> Scalar:
    x: Float[Array, "edges 2 3"] = self.points + u[self.edges]
    delta: Float[Array, "edges 3"] = x[:, 1, :] - x[:, 0, :]
    energy: Float[Array, " edges"] = (
        0.5
        * self.stiffness
        * jnp.square(jnp.linalg.norm(delta, axis=-1) - self.length)
    )
    return jnp.sum(energy)

grad ¤

grad(u: Vector) -> Updates
Source code in src/liblaf/apple/jax/energies/_mass_spring.py 
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
@override
def grad(self, u: Vector) -> Updates:
    x: Float[Array, "edges 2 3"] = self.points + u[self.edges]
    delta: Float[Array, "edges 3"] = x[:, 1, :] - x[:, 0, :]
    length: Float[Array, " edges"] = jnp.linalg.norm(delta, axis=-1)
    direction: Float[Array, "edges 3"] = (
        delta / jnp.where(length > 0, length, 1.0)[:, jnp.newaxis]
    )
    force: Float[Array, "edges 3"] = (
        self.stiffness[:, jnp.newaxis]
        * (length - self.length)[:, jnp.newaxis]
        * direction
    )
    grad: Float[Array, "edges 2 3"] = jnp.stack([-force, force], axis=1)
    return grad, self.edges.flatten()

grad_and_hess_diag ¤

grad_and_hess_diag(u: Vector) -> tuple[Updates, Updates]
Source code in src/liblaf/apple/jax/model/_energy.py 
61
62
63
@eqx.filter_jit
def grad_and_hess_diag(self, u: Vector) -> tuple[Updates, Updates]:
    return self.grad(u), self.hess_diag(u)

hess_diag ¤

hess_diag(u: Vector) -> Updates
Source code in src/liblaf/apple/jax/energies/_mass_spring.py 
76
77
78
79
80
81
@override
def hess_diag(self, u: Vector) -> Updates:
    values: Float[Array, "edges*2 3"] = einops.repeat(
        self.stiffness, "edges -> (edges i) j", i=2, j=3
    )
    return values, self.edges.flatten()

hess_prod ¤

hess_prod(u: Vector, p: Vector) -> Updates
Source code in src/liblaf/apple/jax/model/_energy.py 
41
42
43
44
45
@eqx.filter_jit
def hess_prod(self, u: Vector, p: Vector) -> Updates:
    values: Vector
    _, values = jax.jvp(jax.grad(self.fun), (u,), (p,))
    return values, jnp.arange(u.shape[0])

hess_quad ¤

hess_quad(u: Vector, p: Vector) -> Scalar
Source code in src/liblaf/apple/jax/model/_energy.py 
47
48
49
50
51
52
@eqx.filter_jit
def hess_quad(self, u: Vector, p: Vector) -> Scalar:
    values: Vector
    index: Index
    values, index = self.hess_prod(u, p)
    return jnp.vdot(p[index], values)

mixed_derivative_prod ¤

mixed_derivative_prod(
    u: Vector, p: Vector
) -> EnergyParams
Source code in src/liblaf/apple/jax/model/_energy.py 
65
66
67
68
69
70
71
@eqx.filter_jit
def mixed_derivative_prod(self, u: Vector, p: Vector) -> EnergyParams:
    outputs: EnergyParams = {
        name: getattr(self, f"mixed_derivative_prod_{name}")(u, p)
        for name in self.requires_grad
    }
    return outputs

update ¤

update(u: Vector) -> None
Source code in src/liblaf/apple/jax/model/_energy.py 
22
23
24
@eqx.filter_jit
def update(self, u: Vector) -> None:
    pass

update_params ¤

update_params(params: Mapping[str, Array]) -> None
Source code in src/liblaf/apple/jax/model/_energy.py 
26
27
28
def update_params(self, params: Mapping[str, Array]) -> None:
    for name, value in params.items():
        setattr(self, name, value)

value_and_grad ¤

value_and_grad(u: Vector) -> tuple[Scalar, Updates]
Source code in src/liblaf/apple/jax/model/_energy.py 
54
55
56
57
58
59
@eqx.filter_jit
def value_and_grad(self, u: Vector) -> tuple[Scalar, Updates]:
    value: Scalar
    grad: Vector
    value, grad = jax.value_and_grad(self.fun)(u)
    return value, (grad, jnp.arange(u.shape[0]))

Region ¤

Parameters:

  • geometry ¤

    (Geometry) –

  • quadrature ¤

    (Scheme) –

  • h ¤

    (Float[Array, 'q a'], default: None ) –

  • dhdr ¤

    (Float[Array, 'q a J'], default: None ) –

  • dXdr ¤

    (Float[Array, 'c q J J'], default: None ) –

  • drdX ¤

    (Float[Array, 'c q J J'], default: None ) –

  • dV ¤

    (Float[Array, 'c q'], default: None ) –

  • dhdX ¤

    (Float[Array, 'c q a J'], default: None ) –
Used by:

Methods:

Attributes:

cell_data property ¤

cell_data: DataSetAttributes

cells property ¤

cells: Integer[Array, 'c a']

cells_global property ¤

cells_global: Integer[Array, 'c a']

dV class-attribute instance-attribute ¤

dV: Float[Array, 'c q'] = array(default=None)

dXdr class-attribute instance-attribute ¤

dXdr: Float[Array, 'c q J J'] = array(default=None)

dhdX class-attribute instance-attribute ¤

dhdX: Float[Array, 'c q a J'] = array(default=None)

dhdr class-attribute instance-attribute ¤

dhdr: Float[Array, 'q a J'] = array(default=None)

drdX class-attribute instance-attribute ¤

drdX: Float[Array, 'c q J J'] = array(default=None)

element property ¤

element: Element

geometry class-attribute instance-attribute ¤

geometry: Geometry = field()

h class-attribute instance-attribute ¤

h: Float[Array, 'q a'] = array(default=None)

mesh property ¤

mesh: DataSet

n_cells property ¤

n_cells: int

point_data property ¤

point_data: DataSetAttributes

points property ¤

points: Float[Array, 'p J']

quadrature class-attribute instance-attribute ¤

quadrature: Scheme = field()

compute_grad ¤

compute_grad() -> None
Source code in src/liblaf/apple/jax/fem/region/_region.py 
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
def compute_grad(self) -> None:
    h: Float[Array, "q a"] = jnp.stack(
        [self.element.function(q) for q in self.quadrature.points]
    )
    dhdr: Float[Array, "q a J"] = jnp.stack(
        [self.element.gradient(q) for q in self.quadrature.points]
    )
    dXdr: Float[Array, "c q J J"] = einops.einsum(
        self.points[self.cells], dhdr, "c a I, q a J -> c q I J"
    )
    drdX: Float[Array, "c q J J"] = jnp.linalg.inv(dXdr)
    dV: Float[Array, "c q"] = (
        jnp.linalg.det(dXdr) * self.quadrature.weights[jnp.newaxis, :]
    )
    if jnp.any(dV <= 0):
        logger.warning("dV <= 0")
    dhdX: Float[Array, "c q a J"] = einops.einsum(
        dhdr, drdX, "q a I, c q I J -> c q a J"
    )
    self.h = h
    self.dhdr = dhdr
    self.dXdr = dXdr
    self.drdX = drdX
    self.dV = dV
    self.dhdX = dhdX

deformation_gradient ¤

deformation_gradient(
    u: Float[Array, "p J"],
) -> Float[Array, "c q J J"]
Source code in src/liblaf/apple/jax/fem/region/_region.py 
110
111
112
113
114
115
def deformation_gradient(self, u: Float[Array, "p J"]) -> Float[Array, "c q J J"]:
    grad: Float[Array, "c q J J"] = self.gradient(u)
    F: Float[Array, "c q J J"] = (
        grad + jnp.identity(3)[jnp.newaxis, jnp.newaxis, ...]
    )
    return F

from_geometry classmethod ¤

from_geometry(
    geometry: Geometry,
    *,
    grad: bool = False,
    quadrature: Scheme | None = None,
) -> Self
Source code in src/liblaf/apple/jax/fem/region/_region.py 
29
30
31
32
33
34
35
36
37
38
@classmethod
def from_geometry(
    cls, geometry: Geometry, *, grad: bool = False, quadrature: Scheme | None = None
) -> Self:
    if quadrature is None:
        quadrature = geometry.element.quadrature
    self: Self = cls(geometry=geometry, quadrature=quadrature)
    if grad:
        self.compute_grad()
    return self

from_pyvista classmethod ¤

from_pyvista(
    mesh: DataObject,
    *,
    grad: bool = False,
    quadrature: Scheme | None = None,
) -> Self
Source code in src/liblaf/apple/jax/fem/region/_region.py 
40
41
42
43
44
45
46
47
48
49
50
@classmethod
def from_pyvista(
    cls,
    mesh: pv.DataObject,
    *,
    grad: bool = False,
    quadrature: Scheme | None = None,
) -> Self:
    geometry: Geometry = Geometry.from_pyvista(mesh)
    self: Self = cls.from_geometry(geometry, grad=grad, quadrature=quadrature)
    return self

gradient ¤

gradient(
    u: Float[Array, " points *shape"],
) -> Float[Array, "c q *shape J"]
Source code in src/liblaf/apple/jax/fem/region/_region.py 
117
118
119
120
121
122
123
def gradient(
    self, u: Float[Array, " points *shape"]
) -> Float[Array, "c q *shape J"]:
    result: Float[Array, "c q *shape J"] = einops.einsum(
        self.scatter(u), self.dhdX, "c a ..., c q a J -> c q ... J"
    )
    return result

integrate ¤

integrate(
    a: Float[Array, "c q *shape"],
) -> Float[Array, " c *shape"]
Source code in src/liblaf/apple/jax/fem/region/_region.py 
125
126
def integrate(self, a: Float[Array, "c q *shape"]) -> Float[Array, " c *shape"]:
    return einops.einsum(a, self.dV, "c q ..., c q -> c ...")

scatter ¤

scatter(
    u: Float[Array, " points *shape"],
) -> Float[Array, "c a *shape"]
Source code in src/liblaf/apple/jax/fem/region/_region.py 
128
129
def scatter(self, u: Float[Array, " points *shape"]) -> Float[Array, "c a *shape"]:
    return u[self.cells_global]

Scheme ¤

Parameters:

  • points ¤

    (Float[Array, 'q J']) –

  • weights ¤

    (Float[Array, q]) –
Returned by: Used by:

Methods:

Attributes:

dim property ¤

dim: int

n_points property ¤

n_points: int

points class-attribute instance-attribute ¤

points: Float[Array, 'q J'] = array()

weights class-attribute instance-attribute ¤

weights: Float[Array, ' q'] = array()

from_felupe classmethod ¤

from_felupe(scheme: Scheme) -> Self
Source code in src/liblaf/apple/jax/fem/quadrature/_scheme.py 
14
15
16
17
18
@classmethod
def from_felupe(cls, scheme: felupe.quadrature.Scheme) -> Self:
    return cls(
        points=jnp.asarray(scheme.points), weights=jnp.asarray(scheme.weights)
    )