Skip to content

liblaf.apple.energy.elastic ¤

Modules:

Classes:

ARAP ¤

Bases: Elastic

As-Rigid-As-Possible.

\[ \Psi = \frac{\mu}{2} \|F - R\|_F^2 = \frac{\mu}{2} (I_2 - 2 I_1 + 3) \]

Parameters:

  • id (str, default: <dynamic> ) –
  • actor (Actor) –
  • hess_diag_filter (bool, default: True ) –
  • hess_quad_filter (bool, default: True ) –

Methods:

Attributes:

actor class-attribute instance-attribute ¤

actor: Actor = data()

actors abstractmethod property ¤

actors: NodeContainer[Actor]

hess_diag_filter class-attribute instance-attribute ¤

hess_diag_filter: bool = static(default=True, kw_only=True)

hess_quad_filter class-attribute instance-attribute ¤

hess_quad_filter: bool = static(default=True, kw_only=True)

id class-attribute instance-attribute ¤

id: str = static(
    default=Factory(uniq_id, takes_self=True), kw_only=True
)

mu property ¤

mu: Float[Array, ' c']

__pdoc__ ¤

__pdoc__(**kwargs) -> AbstractDoc

...

References
  1. wadler_lindig._definitions._pformat_dataclass()
Source code in src/liblaf/apple/energy/elastic/arap.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
$$
\Psi = \frac{\mu}{2} \|F - R\|_F^2 = \frac{\mu}{2} (I_2 - 2 I_1 + 3)
$$
"""

@property
def mu(self) -> Float[jax.Array, " c"]:
    return self.actor.cell_data["mu"]

@override
@utils.jit_method(inline=True)
def energy_density(
    self, field: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    Psi: Float[jax.Array, " cq"]
    (Psi,) = arap_energy_density_warp(F, self.mu)
    Psi: Float[jax.Array, "c q"] = region.unsqueeze_cq(Psi)
    return Psi

@override
@utils.jit_method(inline=True)
def first_piola_kirchhoff_stress(

__repr__ ¤

__repr__() -> str
Source code in src/liblaf/apple/energy/elastic/arap.py 
43
44
) -> Float[jax.Array, "c q J J"]:
    region: sim.Region = field.region

energy_density ¤

energy_density(
    field: Field, /, params: GlobalParams
) -> Float[Array, "c q"]
Source code in src/liblaf/apple/energy/elastic/arap.py 
26
27
28
29
30
31
32
33
34
35
36
37
@override
@utils.jit_method(inline=True)
def energy_density(
    self, field: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    Psi: Float[jax.Array, " cq"]
    (Psi,) = arap_energy_density_warp(F, self.mu)
    Psi: Float[jax.Array, "c q"] = region.unsqueeze_cq(Psi)
    return Psi

energy_density_hess_diag ¤

energy_density_hess_diag(
    field: Field, /, params: GlobalParams
) -> Float[Array, "c q a J"]
Source code in src/liblaf/apple/energy/elastic/arap.py 
52
53
54
55
56
57
58
59
60
61
62
63
64
65
@override
@utils.jit_method(inline=True)
def energy_density_hess_diag(
    self, field: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q a J"]:
    hess_diag: Float[jax.Array, "cells 4 3"]
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    dhdX: Float[jax.Array, "cq a J"] = region.squeeze_cq(region.dhdX)
    hess_diag: Float[jax.Array, "cq a J"]
    (hess_diag,) = arap_energy_density_hess_diag_warp(F, self.mu, dhdX)
    hess_diag: Float[jax.Array, "c q a J"] = region.unsqueeze_cq(hess_diag)
    return hess_diag

energy_density_hess_quad ¤

energy_density_hess_quad(
    field: Field, p: Field, /, params: GlobalParams
) -> Float[Array, "c q"]
Source code in src/liblaf/apple/energy/elastic/arap.py 
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
@override
@utils.jit_method(inline=True)
def energy_density_hess_quad(
    self, field: sim.Field, p: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    dhdX: Float[jax.Array, "cq a J"] = region.squeeze_cq(region.dhdX)
    hess_quad: Float[jax.Array, " cq"]
    (hess_quad,) = arap_energy_density_hess_quad_warp(
        F, region.scatter(p.values), self.mu, dhdX
    )
    hess_quad: Float[jax.Array, "c q"] = region.unsqueeze_cq(hess_quad)
    return hess_quad

energy_density_jac ¤

energy_density_jac(
    field: Field, /, params: GlobalParams
) -> Float[Array, "c q a J"]
Source code in src/liblaf/apple/energy/elastic/arap.py 
118
119
120
121
122
123
124
125
126
@no_type_check
@utils.jax_kernel
def arap_energy_density_hess_quad_warp(
    F: wp.array(dtype=mat33),
    p: wp.array(dtype=mat43),
    mu: wp.array(dtype=float),
    dh_dX: wp.array(dtype=mat43),
    hess_quad: wp.array(dtype=float),
) -> None:

evolve ¤

evolve(**changes) -> Self
Source code in src/liblaf/apple/energy/elastic/arap.py 
46
47
F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
PK1: Float[jax.Array, "cq J J"]

first_piola_kirchhoff_stress ¤

first_piola_kirchhoff_stress(
    field: Field, /, params: GlobalParams
) -> Float[Array, "c q J J"]
Source code in src/liblaf/apple/energy/elastic/arap.py 
39
40
41
42
43
44
45
46
47
48
49
50
@override
@utils.jit_method(inline=True)
def first_piola_kirchhoff_stress(
    self, field: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q J J"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    PK1: Float[jax.Array, "cq J J"]
    (PK1,) = arap_first_piola_kirchhoff_stress_warp(F, self.mu)
    PK1: Float[jax.Array, "c q J J"] = region.unsqueeze_cq(PK1)
    return PK1

from_actor classmethod ¤

from_actor(
    actor: Actor,
    *,
    hess_diag_filter: bool = True,
    hess_quad_filter: bool = True,
) -> Self
Source code in src/liblaf/apple/energy/elastic/arap.py 
16
17
18
19
20
21
22
23
24
25
26
27
$$
\Psi = \frac{\mu}{2} \|F - R\|_F^2 = \frac{\mu}{2} (I_2 - 2 I_1 + 3)
$$
"""

@property
def mu(self) -> Float[jax.Array, " c"]:
    return self.actor.cell_data["mu"]

@override
@utils.jit_method(inline=True)
def energy_density(

fun ¤

fun(
    x: ArrayDict, /, params: GlobalParams
) -> Float[Array, ""]
Source code in src/liblaf/apple/energy/elastic/arap.py 
35
36
37
38
39
40
41
    (Psi,) = arap_energy_density_warp(F, self.mu)
    Psi: Float[jax.Array, "c q"] = region.unsqueeze_cq(Psi)
    return Psi

@override
@utils.jit_method(inline=True)
def first_piola_kirchhoff_stress(

fun_and_jac ¤

fun_and_jac(
    x: ArrayDict, /, params: GlobalParams
) -> tuple[Float[Array, ""], ArrayDict]
Source code in src/liblaf/apple/energy/elastic/arap.py 
78
79
80
81
    F, region.scatter(p.values), self.mu, dhdX
)
hess_quad: Float[jax.Array, "c q"] = region.unsqueeze_cq(hess_quad)
return hess_quad

hess_diag ¤

hess_diag(
    x: ArrayDict, /, params: GlobalParams
) -> ArrayDict
Source code in src/liblaf/apple/energy/elastic/arap.py 
61
62
63
64
65
66
67
68
69
    dhdX: Float[jax.Array, "cq a J"] = region.squeeze_cq(region.dhdX)
    hess_diag: Float[jax.Array, "cq a J"]
    (hess_diag,) = arap_energy_density_hess_diag_warp(F, self.mu, dhdX)
    hess_diag: Float[jax.Array, "c q a J"] = region.unsqueeze_cq(hess_diag)
    return hess_diag

@override
@utils.jit_method(inline=True)
def energy_density_hess_quad(

hess_quad ¤

hess_quad(
    x: ArrayDict, p: ArrayDict, /, params: GlobalParams
) -> Float[Array, ""]
Source code in src/liblaf/apple/energy/elastic/arap.py 
71
72
73
74
75
76
) -> Float[jax.Array, "c q"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    dhdX: Float[jax.Array, "cq a J"] = region.squeeze_cq(region.dhdX)
    hess_quad: Float[jax.Array, " cq"]

hessp ¤

hessp(
    x: ArrayDict, p: ArrayDict, /, params: GlobalParams
) -> ArrayDict
Source code in src/liblaf/apple/energy/elastic/arap.py 
54
55
56
57
58
59
def energy_density_hess_diag(
    self, field: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q a J"]:
    hess_diag: Float[jax.Array, "cells 4 3"]
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)

jac ¤

jac(x: ArrayDict, /, params: GlobalParams) -> ArrayDict
Source code in src/liblaf/apple/energy/elastic/arap.py 
43
44
45
46
47
48
49
50
51
52
) -> Float[jax.Array, "c q J J"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    PK1: Float[jax.Array, "cq J J"]
    (PK1,) = arap_first_piola_kirchhoff_stress_warp(F, self.mu)
    PK1: Float[jax.Array, "c q J J"] = region.unsqueeze_cq(PK1)
    return PK1

@override

jac_and_hess_diag ¤

jac_and_hess_diag(
    x: ArrayDict, /, params: GlobalParams
) -> tuple[ArrayDict, ArrayDict]
Source code in src/liblaf/apple/energy/elastic/arap.py 
85
86
87
88
89
90
@utils.jax_kernel
def arap_energy_density_warp(
    F: wp.array(dtype=mat33), mu: wp.array(dtype=float), Psi: wp.array(dtype=float)
) -> None:
    tid = wp.tid()
    Psi[tid] = func.elastic.arap_energy_density(F=F[tid], mu=mu[tid])

make_field ¤

make_field(x: ArrayDict) -> Field
Source code in src/liblaf/apple/energy/elastic/arap.py 
39
40
41
@override
@utils.jit_method(inline=True)
def first_piola_kirchhoff_stress(

pre_optim_iter ¤

pre_optim_iter(params: GlobalParams) -> Self
Source code in src/liblaf/apple/energy/elastic/arap.py 
24
return self.actor.cell_data["mu"]

pre_time_step ¤

pre_time_step(params: GlobalParams) -> Self
Source code in src/liblaf/apple/energy/elastic/arap.py 
21
@property

tree_at ¤

tree_at(
    where: Callable[[Self], Node | Sequence[Node]],
    replace: Any | Sequence[Any] = ...,
    replace_fn: Callable[[Node], Any] = ...,
    is_leaf: Callable[[Any], bool] | None = None,
) -> Self
Source code in src/liblaf/apple/energy/elastic/arap.py 
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
    PK1: Float[jax.Array, "c q J J"] = region.unsqueeze_cq(PK1)
    return PK1

@override
@utils.jit_method(inline=True)
def energy_density_hess_diag(
    self, field: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q a J"]:
    hess_diag: Float[jax.Array, "cells 4 3"]
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    dhdX: Float[jax.Array, "cq a J"] = region.squeeze_cq(region.dhdX)
    hess_diag: Float[jax.Array, "cq a J"]
    (hess_diag,) = arap_energy_density_hess_diag_warp(F, self.mu, dhdX)

with_actors abstractmethod ¤

with_actors(actors: NodeContainer[Actor]) -> Self
Source code in src/liblaf/apple/energy/elastic/arap.py 
27
28
29
@utils.jit_method(inline=True)
def energy_density(
    self, field: sim.Field, /, params: sim.GlobalParams

CoRot ¤

Bases: Elastic

Co-rotational.

\[ \begin{split} \Psi_{\text{CoRot}} & = \frac{\mu}{2} \|F - R\|_F^2 + \frac{\lambda}{2} \operatorname{tr}^2(S - I) \\ & = \frac{\mu}{2} \|F - R\|_F^2 + \frac{\lambda}{2} (I_1^2 - 6 I_1 + 9) \end{split} \]

Parameters:

  • id (str, default: <dynamic> ) –
  • actor (Actor) –
  • hess_diag_filter (bool, default: True ) –
  • hess_quad_filter (bool, default: True ) –

Methods:

Attributes:

actor class-attribute instance-attribute ¤

actor: Actor = data()

actors abstractmethod property ¤

actors: NodeContainer[Actor]

hess_diag_filter class-attribute instance-attribute ¤

hess_diag_filter: bool = static(default=True, kw_only=True)

hess_quad_filter class-attribute instance-attribute ¤

hess_quad_filter: bool = static(default=True, kw_only=True)

id class-attribute instance-attribute ¤

id: str = static(
    default=Factory(uniq_id, takes_self=True), kw_only=True
)

__pdoc__ ¤

__pdoc__(**kwargs) -> AbstractDoc

...

References
  1. wadler_lindig._definitions._pformat_dataclass()

__repr__ ¤

__repr__() -> str

energy_density ¤

energy_density(
    field: Field, /, params: GlobalParams
) -> Float[Array, "c q"]

energy_density_hess_diag ¤

energy_density_hess_diag(
    field: Field, /, params: GlobalParams
) -> Float[Array, "c q a J"]

energy_density_hess_quad ¤

energy_density_hess_quad(
    field: Field, p: Field, /, params: GlobalParams
) -> Float[Array, "c q"]

energy_density_jac ¤

energy_density_jac(
    field: Field, /, params: GlobalParams
) -> Float[Array, "c q a J"]

evolve ¤

evolve(**changes) -> Self

first_piola_kirchhoff_stress ¤

first_piola_kirchhoff_stress(
    field: Field, /, params: GlobalParams
) -> Float[Array, "c q J J"]

from_actor classmethod ¤

from_actor(
    actor: Actor,
    *,
    hess_diag_filter: bool = True,
    hess_quad_filter: bool = True,
) -> Self

fun ¤

fun(
    x: ArrayDict, /, params: GlobalParams
) -> Float[Array, ""]

fun_and_jac ¤

fun_and_jac(
    x: ArrayDict, /, params: GlobalParams
) -> tuple[Float[Array, ""], ArrayDict]

hess_diag ¤

hess_diag(
    x: ArrayDict, /, params: GlobalParams
) -> ArrayDict

hess_quad ¤

hess_quad(
    x: ArrayDict, p: ArrayDict, /, params: GlobalParams
) -> Float[Array, ""]

hessp ¤

hessp(
    x: ArrayDict, p: ArrayDict, /, params: GlobalParams
) -> ArrayDict

jac ¤

jac(x: ArrayDict, /, params: GlobalParams) -> ArrayDict

jac_and_hess_diag ¤

jac_and_hess_diag(
    x: ArrayDict, /, params: GlobalParams
) -> tuple[ArrayDict, ArrayDict]

make_field ¤

make_field(x: ArrayDict) -> Field

pre_optim_iter ¤

pre_optim_iter(params: GlobalParams) -> Self

pre_time_step ¤

pre_time_step(params: GlobalParams) -> Self

tree_at ¤

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

with_actors abstractmethod ¤

with_actors(actors: NodeContainer[Actor]) -> Self

PhaceStatic ¤

Bases: Elastic

As-Rigid-As-Possible.

\[ \Psi = \frac{\mu}{2} \|F - R\|_F^2 = \frac{\mu}{2} (I_2 - 2 I_1 + 3) \]

Parameters:

  • id (str, default: <dynamic> ) –
  • actor (Actor) –
  • hess_diag_filter (bool, default: True ) –
  • hess_quad_filter (bool, default: True ) –

Methods:

Attributes:

actor class-attribute instance-attribute ¤

actor: Actor = data()

actors abstractmethod property ¤

actors: NodeContainer[Actor]

hess_diag_filter class-attribute instance-attribute ¤

hess_diag_filter: bool = static(default=True, kw_only=True)

hess_quad_filter class-attribute instance-attribute ¤

hess_quad_filter: bool = static(default=True, kw_only=True)

id class-attribute instance-attribute ¤

id: str = static(
    default=Factory(uniq_id, takes_self=True), kw_only=True
)

lambda_ property ¤

lambda_: Float[Array, ' cells']

mu property ¤

mu: Float[Array, ' cells']

params property ¤

params: Float[Array, 'cells 2']

__pdoc__ ¤

__pdoc__(**kwargs) -> AbstractDoc

...

References
  1. wadler_lindig._definitions._pformat_dataclass()
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
$$
\Psi = \frac{\mu}{2} \|F - R\|_F^2 = \frac{\mu}{2} (I_2 - 2 I_1 + 3)
$$
"""

@property
def lambda_(self) -> Float[jax.Array, " cells"]:
    return self.actor.cell_data["lambda"]

@property
def mu(self) -> Float[jax.Array, " cells"]:
    return self.actor.cell_data["mu"]

@property
def params(self) -> Float[jax.Array, "cells 2"]:
    return jnp.stack((self.lambda_, self.mu), axis=-1)

@override
@utils.jit_method(inline=True)
def energy_density(
    self, field: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)

__repr__ ¤

__repr__() -> str
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
43
44
Psi: Float[jax.Array, " cq"]
(Psi,) = phace_static_energy_density_warp(F, self.params)

energy_density ¤

energy_density(
    field: Field, /, params: GlobalParams
) -> Float[Array, "c q"]
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
35
36
37
38
39
40
41
42
43
44
45
46
@override
@utils.jit_method(inline=True)
def energy_density(
    self, field: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    Psi: Float[jax.Array, " cq"]
    (Psi,) = phace_static_energy_density_warp(F, self.params)
    Psi: Float[jax.Array, "c q"] = region.unsqueeze_cq(Psi)
    return Psi

energy_density_hess_diag ¤

energy_density_hess_diag(
    field: Field, /, params: GlobalParams
) -> Float[Array, "c q a J"]
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
61
62
63
64
65
66
67
68
69
70
71
72
73
@override
@utils.jit_method(inline=True)
def energy_density_hess_diag(
    self, field: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q a J"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    dhdX: Float[jax.Array, "cq a J"] = region.squeeze_cq(region.dhdX)
    hess_diag: Float[jax.Array, "cq a J"]
    (hess_diag,) = phace_static_energy_density_hess_diag_warp(F, self.params, dhdX)
    hess_diag: Float[jax.Array, "c q a J"] = region.unsqueeze_cq(hess_diag)
    return hess_diag

energy_density_hess_quad ¤

energy_density_hess_quad(
    field: Field, p: Field, /, params: GlobalParams
) -> Float[Array, "c q"]
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
@override
@utils.jit_method(inline=True)
def energy_density_hess_quad(
    self, field: sim.Field, p: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    dhdX: Float[jax.Array, "cq a J"] = region.squeeze_cq(region.dhdX)
    hess_quad: Float[jax.Array, " cq"]
    (hess_quad,) = phace_static_energy_density_hess_quad_warp(
        F, region.scatter(p.values), self.params, dhdX
    )
    hess_quad: Float[jax.Array, "c q"] = region.unsqueeze_cq(hess_quad)
    return hess_quad

energy_density_jac ¤

energy_density_jac(
    field: Field, /, params: GlobalParams
) -> Float[Array, "c q a J"]
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
118
119
120
121
122
123
124
125
126
        F=F[tid], params=params_struct
    )


@no_type_check
@utils.jax_kernel
def phace_static_energy_density_hess_diag_warp(
    F: wp.array(dtype=mat33),
    params: wp.array(dtype=wp.vec2),

evolve ¤

evolve(**changes) -> Self
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
46
return Psi

first_piola_kirchhoff_stress ¤

first_piola_kirchhoff_stress(
    field: Field, /, params: GlobalParams
) -> Float[Array, "c q J J"]
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
48
49
50
51
52
53
54
55
56
57
58
59
@override
@utils.jit_method(inline=True)
def first_piola_kirchhoff_stress(
    self, field: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q J J"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    PK1: Float[jax.Array, "cq J J"]
    (PK1,) = phace_static_first_piola_kirchhoff_stress_warp(F, self.params)
    PK1: Float[jax.Array, "c q J J"] = region.unsqueeze_cq(PK1)
    return PK1

from_actor classmethod ¤

from_actor(
    actor: Actor,
    *,
    hess_diag_filter: bool = True,
    hess_quad_filter: bool = True,
) -> Self
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
r"""As-Rigid-As-Possible.

$$
\Psi = \frac{\mu}{2} \|F - R\|_F^2 = \frac{\mu}{2} (I_2 - 2 I_1 + 3)
$$
"""

@property
def lambda_(self) -> Float[jax.Array, " cells"]:
    return self.actor.cell_data["lambda"]

@property
def mu(self) -> Float[jax.Array, " cells"]:

fun ¤

fun(
    x: ArrayDict, /, params: GlobalParams
) -> Float[Array, ""]
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
35
36
37
38
39
40
41
@override
@utils.jit_method(inline=True)
def energy_density(
    self, field: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)

fun_and_jac ¤

fun_and_jac(
    x: ArrayDict, /, params: GlobalParams
) -> tuple[Float[Array, ""], ArrayDict]
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
78
79
80
81
82
83
    self, field: sim.Field, p: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    dhdX: Float[jax.Array, "cq a J"] = region.squeeze_cq(region.dhdX)

hess_diag ¤

hess_diag(
    x: ArrayDict, /, params: GlobalParams
) -> ArrayDict
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
61
62
63
64
65
66
67
68
69
@override
@utils.jit_method(inline=True)
def energy_density_hess_diag(
    self, field: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q a J"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    dhdX: Float[jax.Array, "cq a J"] = region.squeeze_cq(region.dhdX)

hess_quad ¤

hess_quad(
    x: ArrayDict, p: ArrayDict, /, params: GlobalParams
) -> Float[Array, ""]
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
71
72
73
74
75
76
    (hess_diag,) = phace_static_energy_density_hess_diag_warp(F, self.params, dhdX)
    hess_diag: Float[jax.Array, "c q a J"] = region.unsqueeze_cq(hess_diag)
    return hess_diag

@override
@utils.jit_method(inline=True)

hessp ¤

hessp(
    x: ArrayDict, p: ArrayDict, /, params: GlobalParams
) -> ArrayDict
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
54
55
56
57
58
59
F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
PK1: Float[jax.Array, "cq J J"]
(PK1,) = phace_static_first_piola_kirchhoff_stress_warp(F, self.params)
PK1: Float[jax.Array, "c q J J"] = region.unsqueeze_cq(PK1)
return PK1

jac ¤

jac(x: ArrayDict, /, params: GlobalParams) -> ArrayDict
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
43
44
45
46
47
48
49
50
51
52
    Psi: Float[jax.Array, " cq"]
    (Psi,) = phace_static_energy_density_warp(F, self.params)
    Psi: Float[jax.Array, "c q"] = region.unsqueeze_cq(Psi)
    return Psi

@override
@utils.jit_method(inline=True)
def first_piola_kirchhoff_stress(
    self, field: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q J J"]:

jac_and_hess_diag ¤

jac_and_hess_diag(
    x: ArrayDict, /, params: GlobalParams
) -> tuple[ArrayDict, ArrayDict]
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
85
86
87
88
89
(hess_quad,) = phace_static_energy_density_hess_quad_warp(
    F, region.scatter(p.values), self.params, dhdX
)
hess_quad: Float[jax.Array, "c q"] = region.unsqueeze_cq(hess_quad)
return hess_quad

make_field ¤

make_field(x: ArrayDict) -> Field
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
39
40
41
) -> Float[jax.Array, "c q"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)

pre_optim_iter ¤

pre_optim_iter(params: GlobalParams) -> Self
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
24
25
def lambda_(self) -> Float[jax.Array, " cells"]:
    return self.actor.cell_data["lambda"]

pre_time_step ¤

pre_time_step(params: GlobalParams) -> Self
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
21
"""

tree_at ¤

tree_at(
    where: Callable[[Self], Node | Sequence[Node]],
    replace: Any | Sequence[Any] = ...,
    replace_fn: Callable[[Node], Any] = ...,
    is_leaf: Callable[[Any], bool] | None = None,
) -> Self
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
@utils.jit_method(inline=True)
def first_piola_kirchhoff_stress(
    self, field: sim.Field, /, params: sim.GlobalParams
) -> Float[jax.Array, "c q J J"]:
    region: sim.Region = field.region
    F: Float[jax.Array, "c q J J"] = region.deformation_gradient(field.values)
    F: Float[jax.Array, "cq J J"] = region.squeeze_cq(F)
    PK1: Float[jax.Array, "cq J J"]
    (PK1,) = phace_static_first_piola_kirchhoff_stress_warp(F, self.params)
    PK1: Float[jax.Array, "c q J J"] = region.unsqueeze_cq(PK1)
    return PK1

@override
@utils.jit_method(inline=True)
def energy_density_hess_diag(

with_actors abstractmethod ¤

with_actors(actors: NodeContainer[Actor]) -> Self
Source code in src/liblaf/apple/energy/elastic/phace_static.py 
27
28
29
@property
def mu(self) -> Float[jax.Array, " cells"]:
    return self.actor.cell_data["mu"]