Skip to content

liblaf.apple.jax.fem.region ¤

Classes:

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]