pyfebio 0.1.0__py3-none-any.whl

pyfebio/rigid.py

@@ -0,0 +1,275 @@
+from typing import Literal
+
+from pydantic_xml import BaseXmlModel, attr, element
+
+from ._types import (
+    StringFloatVec3,
+)
+
+
+class Value(BaseXmlModel, validate_assignment=True):
+    lc: int = attr()
+    text: float = 1.0
+
+
+class RigidFixed(BaseXmlModel, tag="rigid_bc", validate_assignment=True):
+    """ """
+
+    type: Literal["rigid_fixed"] = attr(default="rigid_fixed", frozen=True)
+    rb: str = element()
+    Rx_dof: Literal[0, 1] = element(default=0)
+    Ry_dof: Literal[0, 1] = element(default=0)
+    Rz_dof: Literal[0, 1] = element(default=0)
+    Ru_dof: Literal[0, 1] = element(default=0)
+    Rv_dof: Literal[0, 1] = element(default=0)
+    Rw_dof: Literal[0, 1] = element(default=0)
+
+
+class RigidPrescribed(BaseXmlModel, tag="rigid_bc", validate_assignment=True):
+    type: Literal["rigid_displacement", "rigid_rotation"] = attr(default="rigid_displacement", frozen=True)
+    rb: str = element()
+    dof: Literal["x", "y", "z", "Ru", "Rv", "Rw"] = element()
+    relative: Literal[0, 1] = element(default=0)
+    value: Value = element()
+
+
+class RigidBodyRotationVector(BaseXmlModel, tag="rigid_bc", validate_assignment=True):
+    class X(BaseXmlModel, tag="vx", validate_assignment=True):
+        lc: int = attr()
+        text: float = 0.0
+
+    class Y(BaseXmlModel, tag="vy", validate_assignment=True):
+        lc: int = attr()
+        text: float = 0.0
+
+    class Z(BaseXmlModel, tag="vz", validate_assignment=True):
+        lc: int = attr()
+        text: float = 0.0
+
+    type: Literal["rigid_rotation_vector"] = attr(default="rigid_rotation_vector", frozen=True)
+    rb: str = element()
+    vx: X = element()
+    vy: Y = element()
+    vz: Z = element()
+
+
+class RigidBodyEulerAngle(BaseXmlModel, tag="rigid_bc", validate_assignment=True):
+    class X(BaseXmlModel, tag="Ex", validate_assignment=True):
+        lc: int = attr()
+        text: float = 0.0
+
+    class Y(BaseXmlModel, tag="Ey", validate_assignment=True):
+        lc: int = attr()
+        text: float = 0.0
+
+    class Z(BaseXmlModel, tag="Ez", validate_assignment=True):
+        lc: int = attr()
+        text: float = 0.0
+
+    type: Literal["rigid_euler_vector"] = attr(default="rigid_euler_vector", frozen=True)
+    rb: str = element()
+    Ex: X = element()
+    Ey: Y = element()
+    Ez: Z = element()
+
+
+class RigidForceLoad(BaseXmlModel, tag="rigid_load", validate_assignment=True):
+    type: Literal["rigid_force"] = attr(default="rigid_force", frozen=True)
+    rb: str = element()
+    dof: Literal["Rx", "Ry", "Rz"] = element()
+    relative: Literal[0, 1] = element(default=0)
+    load_type: Literal[0, 1, 2] = element(default=1)
+    value: Value = element()
+
+
+class RigidFollowerForceLoad(BaseXmlModel, tag="rigid_load", validate_assignment=True):
+    type: Literal["rigid_follower_force"] = attr(default="rigid_follower_force", frozen=True)
+    rb: str = element()
+    insertion: StringFloatVec3 = element()
+    relative: Literal[0, 1] = element(default=0)
+    force: StringFloatVec3 = element()
+
+
+class RigidMomentLoad(BaseXmlModel, tag="rigid_load", validate_assignment=True):
+    type: Literal["rigid_moment"] = attr(default="rigid_moment", frozen=True)
+    rb: str = element()
+    dof: Literal["Ru", "Rv", "Rw"] = element()
+    relative: Literal[0, 1] = element(default=0)
+    value: Value = element()
+
+
+class RigidFollowerMomentLoad(BaseXmlModel, tag="rigid_load", validate_assignment=True):
+    type: Literal["rigid_follower_moment"] = attr(default="rigid_follower_moment", frozen=True)
+    rb: str = element()
+    relative: Literal[0, 1] = element(default=0)
+    moment: StringFloatVec3 = element()
+
+
+class RigidCableLoad(BaseXmlModel, tag="rigid_load", validate_assignment=True):
+    class CablePoint(BaseXmlModel, tag="rigid_cable_point", validate_assignment=True):
+        rigid_body_id: str = element()
+        position: StringFloatVec3 = element()
+
+    type: Literal["rigid_cable"] = attr(default="rigid_cable", frozen=True)
+    force_direction: StringFloatVec3 = element()
+    relative: Literal[0, 1] = element(default=1)
+    force: Value = element()
+    rigid_cable_point: list[CablePoint] = element(default=[])
+
+
+class RigidConnector(
+    BaseXmlModel,
+    tag="rigid_connector",
+    validate_assignment=True,
+):
+    """ """
+
+    name: str = attr()
+    body_a: str = element()
+    body_b: str = element()
+    tolerance: float = element(default=0.1)
+    minaug: int = element(default=0)
+    maxaug: int = element(default=10)
+    gaptol: Literal[0] | float = element(default=0)
+    angtol: Literal[0] | float = element(default=0)
+    force_penalty: float = element(default=1)
+    moment_penalty: float = element(default=1)
+    auto_penalty: Literal[0, 1] = element(default=1)
+
+
+class Free(BaseXmlModel, validate_assignment=True):
+    text: Literal[0] = 0
+
+
+class RigidSphericalJoint(RigidConnector):
+    type: Literal["rigid spherical joint"] = attr(default="rigid spherical joint", frozen=True)
+    joint_origin: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    prescribed_rotation: Literal[0, 1] = element(default=0)
+    rotation_x: Value | Free = element(default=Free())
+    rotation_y: Value | Free = element(default=Free())
+    rotation_z: Value | Free = element(default=Free())
+    moment_x: Value | Free = element(default=Free())
+    moment_y: Value | Free = element(default=Free())
+    moment_z: Value | Free = element(default=Free())
+
+
+class RigidRevoluteJoint(RigidConnector):
+    class Free(BaseXmlModel):
+        text: Literal[0] = 0
+
+    type: Literal["rigid revolute joint"] = attr(default="rigid revolute joint", frozen=True)
+    laugon: Literal[0, 1] = element(default=0)
+    joint_origin: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    prescribed_rotation: Literal[0, 1] = element(default=0)
+    rotation_axis: StringFloatVec3 = element(default="0.0,0.0,1.0")
+    moment: Value | Free = element(default=Free())
+    rotation: Value | Free = element(default=Free())
+
+
+class RigidPrismaticJoint(RigidConnector):
+    type: Literal["rigid prismatic joint"] = attr(default="rigid prismatic joint", frozen=True)
+    joint_origin: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    prescribed_translation: Literal[0, 1] = element(default=0)
+    translation: Value | Free = element(default=Free())
+    force: Value | Free = element(default=Free())
+
+
+class RigidCylindricalJoint(RigidConnector):
+    type: Literal["rigid cylindrical joint"] = attr(default="rigid cylindrical joint", frozen=True)
+    laugon: Literal["PENALTY", "AUGLAG", "LAGMULT"] = element(default="PENALTY")
+    joint_origin: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    joint_axis: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    transverse_axis: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    prescribed_rotation: Literal[0, 1] = element(default=0)
+    prescribed_translation: Literal[0, 1] = element(default=0)
+    translation: Value | Free = element(default=Free())
+    force: Value | Free = element(default=Free())
+    rotation: Value | Free = element(default=Free())
+    moment: Value | Free = element(default=Free())
+
+
+class RigidPlanarJoint(RigidConnector):
+    type: Literal["rigid planar joint"] = attr(default="rigid planar joint", frozen=True)
+    joint_origin: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    rotation_axis: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    translation_axis_1: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    translation_axis_2: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    prescribed_rotation: Literal[0, 1] = element(default=0)
+    prescribed_translation_1: Literal[0, 1] = element(default=0)
+    prescribed_translation_2: Literal[0, 1] = element(default=0)
+    rotation: Value | Free = element(default=Free())
+    translation_1: Value | Free = element(default=Free())
+    translation_2: Value | Free = element(default=Free())
+
+
+class RigidLock(RigidConnector):
+    type: Literal["rigid lock"] = attr(default="rigid lock", frozen=True)
+    joint_origin: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    first_axis: StringFloatVec3 = element(default="1.0,0.0,0.0")
+    second_axis: StringFloatVec3 = element(default="0.0,1.0,0.0")
+
+
+class RigidSpring(RigidConnector):
+    type: Literal["rigid spring"] = attr(default="rigid spring", frozen=True)
+    k: float = element(default=1)
+    insertion_a: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    insertion_b: StringFloatVec3 = element(default="1.0,0.0,0.0")
+    free_length: Literal[0] | float = element(default=0)
+
+
+class RigidDamper(RigidConnector):
+    type: Literal["rigid damper"] = attr(default="rigid damper", frozen=True)
+    c: float = element(default=1e-7)
+    insertion_a: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    insertion_b: StringFloatVec3 = element(default="1.0,0.0,0.0")
+
+
+class RigidAngularDamper(RigidConnector):
+    type: Literal["rigid angular damper"] = attr(default="rigid angular damper", frozen=True)
+    c: float = element(default=1e-7)
+
+
+class RigidContractileForce(RigidConnector):
+    type: Literal["rigid damper"] = attr(default="rigid damper", frozen=True)
+    insertion_a: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    insertion_b: StringFloatVec3 = element(default="1.0,0.0,0.0")
+    f0: Value = element()
+
+
+RigidBCType = RigidFixed | RigidPrescribed | RigidBodyRotationVector | RigidBodyEulerAngle
+
+RigidLoadType = RigidForceLoad | RigidFollowerForceLoad | RigidMomentLoad | RigidFollowerMomentLoad
+
+RigidConnectorType = (
+    RigidSphericalJoint
+    | RigidRevoluteJoint
+    | RigidCylindricalJoint
+    | RigidPrismaticJoint
+    | RigidPlanarJoint
+    | RigidLock
+    | RigidSpring
+    | RigidDamper
+    | RigidAngularDamper
+    | RigidContractileForce
+)
+
+
+class Rigid(BaseXmlModel, tag="Rigid", validate_assignment=True):
+    all_rigid_bcs: list[RigidBCType] = element(default=[], tag="rigid_bc")
+    all_rigid_loads: list[RigidLoadType] = element(default=[], tag="rigid_load")
+    all_rigid_connectors: list[RigidConnectorType] = element(default=[], tag="rigid_connector")
+
+    def add_rigid_bc(
+        self,
+        new_rigid_bc: RigidBCType,
+    ):
+        self.all_rigid_bcs.append(new_rigid_bc)
+
+    def add_rigid_load(
+        self,
+        new_rigid_load: RigidLoadType,
+    ):
+        self.all_rigid_loads.append(new_rigid_load)
+
+    def add_rigid_connector(self, new_rigid_connector: RigidConnectorType):
+        self.all_rigid_connectors.append(new_rigid_connector)

pyfebio/step.py

@@ -0,0 +1,28 @@
+from pydantic_xml import BaseXmlModel, attr, element
+
+from .boundary import Boundary
+from .constraints import Constraints
+from .contact import Contact
+from .control import Control
+from .initial import Initial
+from .loads import Loads
+from .rigid import Rigid
+
+
+class StepEntry(BaseXmlModel, validate_assignment=True):
+    id: int = attr()
+    name: str = attr(default="Step")
+    control: Control | None = element(default=None, tag="Control")
+    initial: Initial | None = element(default=None, tag="Initial")
+    boundary: Boundary | None = element(default=None, tag="Boundary")
+    loads: Loads | None = element(default=None, tag="Loads")
+    constraints: Constraints | None = element(default=None, tag="Constraints")
+    contact: Contact | None = element(default=None, tag="Contact")
+    rigid: Rigid | None = element(default=None, tag="Rigid")
+
+
+class Step(BaseXmlModel, validate_assignment=True):
+    all_steps: list[StepEntry] = element(default=[], tag="step")
+
+    def add_step(self, new_step: StepEntry):
+        self.all_steps.append(new_step)

pyfebio-0.1.0.dist-info/METADATA

@@ -0,0 +1,336 @@
+Metadata-Version: 2.4
+Name: pyfebio
+Version: 0.1.0
+Summary: A Python API for the FEBio finite element solver.
+Author: Scott Sibole
+Author-email: Scott Sibole <scott.sibole@gmail.com>
+License-Expression: MIT
+Requires-Dist: lxml>=6.0.1
+Requires-Dist: meshio[all]>=5.3.5
+Requires-Dist: pydantic-xml>=2.17.3
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+## Overview
+
+This is a Python package for generating FEBio input files. We rely heavily on pydantic and pydantic-xml
+for type validation and XML serialization. Many of FEBio's features are covered, but not all.
+
+## Getting Started
+
+- [Installation](#installation)
+- [Testing](#testing)
+- [Example](#example)
+- [Documentation](https://comporthobiomech.github.io/pyfebio/index.html)
+- [Features](#features)
+
+## Installation
+
+We will build PyPi packages later. For now, you can install from source:
+
+Clone with https:
+
+```bash
+git clone https://github.com/CompOrthoBiomech/pyfebio.git
+```
+
+Or,
+
+Clone with ssh:
+
+```bash
+git clone git@github.com:CompOrthoBiomech/pyfebio.git
+```
+
+**Using uv:**
+
+Install uv from [here](https://docs.astral.sh/uv/getting-started/installation/)
+
+In top-level repository directory:
+
+```bash
+uv sync
+```
+
+This will create a virtual environment and install the package.
+
+**Using pip:**
+
+In top-level repository directory:
+
+Create a virtual environment:
+
+```bash
+python -m venv .venv
+```
+
+Activate the virtual environment:
+
+```bash
+source .venv/bin/activate
+```
+
+Install the package:
+
+```bash
+pip install .
+```
+
+If you want to run the tests, additionally install the dev group dependencies:
+
+```bash
+pip install . --group dev
+```
+
+## Testing
+
+We rely on FEBio to check our generated models are valid. Therefore, you will need to have FEBio installed and available in your PATH.
+
+To run all the tests, execute the following command:
+
+```bash
+cd src
+pytest
+```
+
+For tests that depend on running finite element simulations, you can find them in the pytest tmp_path directory, which varies by operating system.
+
+For the latest run:
+
+on Linux,
+
+```bash
+cd /tmp/pytest-of-[USER]/pytest-current/[TEST_FUNCTION_NAME]current
+```
+
+## Example
+
+```python
+import pyfebio
+
+# Instantiate a model tree with default values
+# This contains empty mesh, material, loads, boundary, etc. sections
+my_model = pyfebio.model.Model()
+
+# Let's create a single hex8 element explicitly
+# Normally, you would use the meshio functions to import
+nodes_list = [
+    [0.0, 0.0, 0.0],
+    [1.0, 0.0, 0.0],
+    [1.0, 1.0, 0.0],
+    [0.0, 1.0, 0.0],
+    [0.0, 0.0, 1.0],
+    [1.0, 0.0, 1.0],
+    [1.0, 1.0, 1.0],
+    [0.0, 1.0, 1.0],
+]
+
+elements_list = [[1, 2, 3, 4, 5, 6, 7, 8]]
+
+# Add Nodes to an pyfebio.Nodes object
+nodes = pyfebio.mesh.Nodes(name="nodes")
+for i, node in enumerate(nodes_list):
+    nodes.add_node(pyfebio.mesh.Node(id=i + 1, text=",".join(map(str, node))))
+
+# Add Elements to an pyfebio.Elements object
+elements = pyfebio.mesh.Elements(name="box", type="hex8")
+for i, element in enumerate(elements_list):
+    elements.add_element(pyfebio.mesh.Hex8Element(id=i + 1, text=",".join(map(str, element))))
+
+# Append nodes and elements to the model's mesh section
+my_model.mesh.nodes.append(nodes)
+my_model.mesh.elements.append(elements)
+
+# Let's make a node set for top and bottom
+bottom_nodes = [1, 2, 3, 4]
+top_nodes = [5, 6, 7, 8]
+top_node_set = pyfebio.mesh.NodeSet(name="top", text=",".join(map(str, top_nodes)))
+bottom_node_set = pyfebio.mesh.NodeSet(name="bottom", text=",".join(map(str, bottom_nodes)))
+
+# Append the node sets to the model's mesh section
+my_model.mesh.node_sets.append(top_node_set)
+my_model.mesh.node_sets.append(bottom_node_set)
+
+# We need a material
+# the use of pyfebio.material.MaterialParameter is our solution
+# to handle mapped, math, or directly specified values
+my_material = pyfebio.material.MooneyRivlin(
+    id=1,
+    name="cartilage",
+    c1=pyfebio.material.MaterialParameter(text=10.0),
+    c2=pyfebio.material.MaterialParameter(text=1.0),
+    k=pyfebio.material.MaterialParameter(text=1000.0),
+)
+
+# Define a solid domain for the box to assign the material
+solid_domain = pyfebio.meshdomains.SolidDomain(name="box", mat="cartilage")
+
+# add the solid domain
+my_model.mesh_domains.add_solid_domain(solid_domain)
+
+# add the material
+my_model.material.add_material(my_material)
+
+# Fix the bottom nodes (1 means BC DoF is active)
+fixed_bottom = pyfebio.boundary.BCZeroDisplacement(node_set="bottom",
+                                                   x_dof=1,
+                                                   y_dof=1,
+                                                   z_dof=1)
+
+# Displace the top nodes in z
+# We need to create a boundary.Value object that references a load curve
+displacement_value = pyfebio.boundary.Value(lc=1, text=-0.2)
+move_top = pyfebio.boundary.BCPrescribedDisplacement(
+    node_set="top", dof="z", value=displacement_value
+)
+
+# Add boundary conditions
+my_model.boundary.add_bc(fixed_bottom)
+my_model.boundary.add_bc(move_top)
+
+# Now, create the loadcurve 1 we referenced
+curve_points = pyfebio.loaddata.CurvePoints(points=["0.0,0.0", "1.0,1.0"])
+load_curve1 = pyfebio.loaddata.LoadCurve(id=1, points=curve_points)
+# And, add it to model
+my_model.load_data.add_load_curve(load_curve1)
+
+# Finally, save the model to disk
+my_model.save("my_model.feb")
+```
+
+Run the model from the CLI (assuming febio4 is on your PATH):
+
+```{bash}
+febio4 -i my_model.feb
+```
+
+![Short Example Simulation](assets/short_example.gif)
+
+
+## Features
+
+Brief overview, see module documentation for more details. Unchecked are not yet implemented.
+
+:white_check_mark: Implemented and tested
+
+:ballot_box_with_check: Implemented but untested
+
+:x: Not yet implemented
+
+- Control
+  - :white_check_mark: All control settings
+- Mesh Section
+  - :white_check_mark: Nodes
+  - :white_check_mark: Solid Elements:
+     - tet4, tet10, hex8, hex20, hex27, penta6
+  - :ballot_box_with_check: Shell Elements:
+     - tri3, tri6, quad4, quad8, quad9, q4ans, q4eas
+  - :ballot_box_with_check: Beam Elements:
+     - line2, line3
+  - :white_check_mark: Node, Element, Surface Sets
+- MeshDomain
+  - :white_check_mark: Solid Domain
+  - :ballot_box_with_check: Shell Domain
+  - :ballot_box_with_check: Beam Domain
+  - :ballot_box_with_check: Granular control for integration schemes, etc.
+- MeshData Section
+  - :ballot_box_with_check: Node Data
+  - :ballot_box_with_check: Scalar
+  - :ballot_box_with_check: Vector3
+  - :ballot_box_with_check: Element Data
+  - :ballot_box_with_check: Scalar
+  - :ballot_box_with_check: Vector3
+  - :x: Surface Data
+    - :x: Scalar
+    - :x: Vector3
+- MeshAdaptor
+  - :ballot_box_with_check: Erosion
+  - :white_check_mark: MMG3d Remeshing
+  - :white_check_mark: hex_refine
+  - :white_check_mark: hex_refine2d
+  - :ballot_box_with_check: Criteria
+  - :ballot_box_with_check: element selection
+  - :ballot_box_with_check: math
+  - :ballot_box_with_check: min-max filter
+  - :white_check_mark: relative error
+  - :white_check_mark: stress
+  - :ballot_box_with_check: contact gap
+  - :ballot_box_with_check: damage
+  - :ballot_box_with_check: max variable
+- Material
+  - :white_check_mark: Most Unconstrained Formulation Materials
+  - :white_check_mark: Most Uncoupled Formulation Materials
+  - :ballot_box_with_check: Prestrain Material
+  - :ballot_box_with_check: Fiber models
+  - :white_check_mark: Material Axis
+    - :white_check_mark: Vector Definition
+    - :white_check_mark: Fiber Vector
+  - :ballot_box_with_check: Continuous Fiber Distributions
+  - :ballot_box_with_check: Integration Schemes
+  - :ballot_box_with_check: Element-wise, mapped, or math parameter defintion
+  - :white_check_mark: Biphasic Materials
+  - :white_check_mark: Viscoelastic Materials
+  - :x: Multiphasic Materials
+  - :x: Biphasic-solute Materials
+  - :x: Chemical Reactions
+  - :x: Active Contraction Materials
+  - :x: Damage Materials
+  - :x: First-order Homogenization
+- Rigid
+  - :ballot_box_with_check: Fixed Displacement and Rotation
+  - :ballot_box_with_check: Prescribed Displacement and Rotation
+  - :ballot_box_with_check: Precribed Rotation about Vector
+  - :ballot_box_with_check: Prescribed Euler Rotation
+  - :ballot_box_with_check: All Connectors
+  - :ballot_box_with_check: Follower Loads
+- Initial
+  - :ballot_box_with_check: Initial Velocity
+  - :ballot_box_with_check: Initial Pre-strain
+- Loads
+  - :ballot_box_with_check: Nodal Loads
+  - :ballot_box_with_check: Traction Loads (surface)
+  - :ballot_box_with_check: Pressure Loads (surface)
+  - :ballot_box_with_check: Fluid Flux (surface)
+  - :ballot_box_with_check: Fluid Pressure (surface)
+- LoadData
+  - :white_check_mark: Load Curves
+    - :balloit_box_with_check: All Options
+  - :ballot_box_with_check: PID Controllers
+  - :ballot_box_with_check: Math Controllers
+- Boundary
+  - :white_check_mark: Fixed Displacement (solid)
+  - :white_check_mark: Prescribed Displacement (solid)
+  - :ballot_box_with_check: Fixed Displacement (shell)
+  - :ballot_box_with_check: Prescribed Displacement (shell)
+  - :ballot_box_with_check: Precribed Deformation Gradient
+  - :ballot_box_with_check: Displacement Along Normals
+  - :ballot_box_with_check: Fix to Rigid Body
+  - :white_check_mark: Rigid Node Set Deformation (rotation about axis)
+  - :white_check_mark: Zero Fluid Pressure
+  - :ballot_box_with_check: Prescribed Fluid Pressure
+- Constraints
+  - :ballot_box_with_check: Symmetry Plane
+  - :ballot_box_with_check: Prestrain
+  - :ballot_box_with_check: In-Situ Stretch
+- Contact
+  - :ballot_box_with_check: Sliding
+  - :ballot_box_with_check: Elastic
+  - :ballot_box_with_check: Facet-Facet
+  - :ballot_box_with_check: Node-Facet
+  - :ballot_box_with_check: Biphasic
+  - :ballot_box_with_check: Sliding2
+  - :ballot_box_with_check: Contact Potential Formulation
+  - :ballot_box_with_check: Tie
+  - :ballot_box_with_check: Elastic
+  - :ballot_box_with_check: Facet-Facet
+  - :ballot_box_with_check: Node-Facet
+  - :ballot_box_with_check: Biphasic
+- Step
+  - :ballot_box_with_check: Multistep Analysis
+- Output
+  - :ballot_box_with_check: Log File Configuration
+  - :ballot_box_with_check: Plot File Configuration
+  - :ballot_box_with_check: Node Variables
+  - :ballot_box_with_check: Element Variables
+  - :ballot_box_with_check: Rigid Body Variables
+  - :ballot_box_with_check: Rigid Connector Variables

pyfebio-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+pyfebio/__init__.py,sha256=t_4CsqooLVNUaCqvcb_joXCfRjvnMfrhDoo7wrVn6JQ,599
+pyfebio/_types.py,sha256=dNn1A1IR8rVnbAVBE0rfP9jgT6ky0S8NA81ApNApPlY,2326
+pyfebio/boundary.py,sha256=A266CEJrLnF-4UNZZMOlUhwGVdsNKrkjh2rxPmQARAg,3891
+pyfebio/constraints.py,sha256=QHs76vSyOKtZhWy2GoZ8aW9b8VhQwZ1o85TT_dXbPWU,1626
+pyfebio/contact.py,sha256=0FL_TcebZJu7J0GiDeStUcNPGoGZ3WeeUMOrg0HW8UY,6469
+pyfebio/control.py,sha256=uf8sY2771qwEeMRYH_AZa99oh0IPpKtTYiKwaYsgUo8,3255
+pyfebio/discrete.py,sha256=KXac8tldGSBw3bh9Amn80vP8Bb2s36W5uv52vpQnvbY,1404
+pyfebio/globals.py,sha256=33L0YV9pE6huMixHHDYID6N9MrKNYZuoeL3588ZXYc0,389
+pyfebio/include.py,sha256=kyXcwq3h7pJ842GF9KvCXTqHzQmG8aTxAhN-RgzSJBs,124
+pyfebio/initial.py,sha256=krXfiaENs9-b9RhuMHdhqrU-23fbVK_rv9ivgo1zv3w,939
+pyfebio/loaddata.py,sha256=V9M6nMjDnz5c2xPDldg5-k73JHVjNV8ntgcS4EihD4k,1735
+pyfebio/loads.py,sha256=xZdYB9Xg_q56QR1-BBbK6UvnnJIvWEAT_OWuHhv3FTw,1929
+pyfebio/material.py,sha256=nU9gMQCs7ueq1EfyMlXypPCqMAkeEKpwrrGydduGJlU,61139
+pyfebio/mesh.py,sha256=PwSGz7EqJFBkZlhf8_o0MqmsBStXznOeQcVJAFlX43U,12220
+pyfebio/meshadaptor.py,sha256=ok06o6DqngJUJz7OOqC4paPu0y1SAlPkWaSbnLMl6e4,6299
+pyfebio/meshdata.py,sha256=6w0lV98fHt3-HNmcnma0v6ngrGr9Z8JTBaGk-Kvw-hU,1549
+pyfebio/meshdomains.py,sha256=dZjOaiP5kfXy3Ym9AgSetZIKgFSf35GikmGvWOnrsIU,2125
+pyfebio/model.py,sha256=iFPvKvb1f_OzEGUCP0c3OJp4SehenuAJAiLtvCQnjQI,5320
+pyfebio/module.py,sha256=JIJkuou0fHqyBYq_x2UfsW7g0hhZeimZCqdR31z0nP8,374
+pyfebio/output.py,sha256=C-veR4HnVDscdmw4dQH51a0q933w_uawh5hXIe8LAWo,7996
+pyfebio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyfebio/rigid.py,sha256=fQSzyX5RdEiRDK0lOFr19ybnjWVkJ8UZkUXiHybR8f0,10359
+pyfebio/step.py,sha256=NGGzajCfO3ZOCJ22y1z3sIrJHyjpMcJ-uSgIKMFxZKU,1053
+pyfebio-0.1.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+pyfebio-0.1.0.dist-info/METADATA,sha256=ndWZwRs1fo3vCLJFyYisGSIMWVdtdWpn-aI7P_jysXg,10275
+pyfebio-0.1.0.dist-info/RECORD,,

pyfebio-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.24
+Root-Is-Purelib: true
+Tag: py3-none-any