pyfebio 0.1.1__py3-none-any.whl

pyfebio/__init__.py

@@ -0,0 +1,45 @@
+from . import (
+    boundary,
+    constraints,
+    contact,
+    control,
+    discrete,
+    globals,
+    include,
+    initial,
+    loaddata,
+    loads,
+    material,
+    mesh,
+    meshadaptor,
+    meshdata,
+    meshdomains,
+    model,
+    module,
+    output,
+    rigid,
+    step,
+)
+
+__all__ = [
+    "boundary",
+    "constraints",
+    "contact",
+    "control",
+    "discrete",
+    "globals",
+    "initial",
+    "loaddata",
+    "loads",
+    "material",
+    "mesh",
+    "meshdata",
+    "meshdomains",
+    "meshadaptor",
+    "model",
+    "module",
+    "output",
+    "rigid",
+    "step",
+    "include",
+]

pyfebio/_types.py

@@ -0,0 +1,95 @@
+from typing import Annotated
+
+from pydantic import StringConstraints
+
+StringFloatVec = Annotated[
+    str,
+    StringConstraints(
+        strip_whitespace=True,
+        pattern=r"^([+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?,)+([+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?)$",
+    ),
+]
+
+
+StringFloatVec2 = Annotated[
+    str,
+    StringConstraints(
+        strip_whitespace=True,
+        pattern=r"^" + ",".join([r"[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?"] * 2) + r"$",
+    ),
+]
+
+StringFloatVec3 = Annotated[
+    str,
+    StringConstraints(
+        strip_whitespace=True,
+        pattern=r"^" + ",".join([r"[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?"] * 3) + r"$",
+    ),
+]
+
+
+StringFloatVec9 = Annotated[
+    str,
+    StringConstraints(
+        strip_whitespace=True,
+        pattern=r"^" + ",".join([r"[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?"] * 9) + r"$",
+    ),
+]
+
+StringUIntVec = Annotated[
+    str,
+    StringConstraints(
+        strip_whitespace=True,
+        pattern=r"^(?:\d+)(?:,(?:\d+))*$",
+    ),
+]
+
+StringUIntVec2 = Annotated[
+    str,
+    StringConstraints(strip_whitespace=True, pattern=r"^" + ",".join([r"\d+"] * 2) + r"$"),
+]
+
+StringUIntVec3 = Annotated[
+    str,
+    StringConstraints(strip_whitespace=True, pattern=r"^" + ",".join([r"\d+"] * 3) + r"$"),
+]
+
+StringUIntVec4 = Annotated[
+    str,
+    StringConstraints(strip_whitespace=True, pattern=r"^" + ",".join([r"\d+"] * 4) + r"$"),
+]
+
+StringUIntVec6 = Annotated[
+    str,
+    StringConstraints(strip_whitespace=True, pattern=r"^" + ",".join([r"\d+"] * 6) + r"$"),
+]
+
+StringUIntVec8 = Annotated[
+    str,
+    StringConstraints(strip_whitespace=True, pattern=r"^" + ",".join([r"\d+"] * 8) + r"$"),
+]
+
+StringUIntVec9 = Annotated[
+    str,
+    StringConstraints(strip_whitespace=True, pattern=r"^" + ",".join([r"\d+"] * 9) + r"$"),
+]
+
+StringUIntVec10 = Annotated[
+    str,
+    StringConstraints(strip_whitespace=True, pattern=r"^" + ",".join([r"\d+"] * 10) + r"$"),
+]
+
+StringUIntVec15 = Annotated[
+    str,
+    StringConstraints(strip_whitespace=True, pattern=r"^" + ",".join([r"\d+"] * 15) + r"$"),
+]
+
+StringUIntVec20 = Annotated[
+    str,
+    StringConstraints(strip_whitespace=True, pattern=r"^" + ",".join([r"\d+"] * 20) + r"$"),
+]
+
+StringUIntVec27 = Annotated[
+    str,
+    StringConstraints(strip_whitespace=True, pattern=r"^" + ",".join([r"\d+"] * 27) + r"$"),
+]

pyfebio/boundary.py

@@ -0,0 +1,119 @@
+from typing import Literal
+
+from pydantic_xml import BaseXmlModel, attr, element
+
+from ._types import (
+    StringFloatVec3,
+    StringFloatVec9,
+)
+
+
+class Value(BaseXmlModel, validate_assignment=True):
+    lc: int = attr()
+    text: float | StringFloatVec3 = 1.0
+
+
+class BCZeroDisplacement(BaseXmlModel, tag="bc", validate_assignment=True):
+    type: Literal["zero displacement"] = attr(default="zero displacement", frozen=True)
+    node_set: str = attr()
+    x_dof: Literal[0, 1] = element(default=0)
+    y_dof: Literal[0, 1] = element(default=0)
+    z_dof: Literal[0, 1] = element(default=0)
+
+
+class BCZeroShellDisplacement(BaseXmlModel, tag="bc", validate_assignment=True):
+    type: Literal["zero shell displacement"] = attr(
+        default="zero shell displacement", frozen=True
+    )
+    node_set: str = attr()
+    sx_dof: Literal[0, 1] = element(default=0)
+    sy_dof: Literal[0, 1] = element(default=0)
+    sz_dof: Literal[0, 1] = element(default=0)
+
+
+class BCZeroFluidPressure(BaseXmlModel, tag="bc", validate_assignment=True):
+    type: Literal["zero fluid pressure"] = attr(
+        default="zero fluid pressure", frozen=True
+    )
+    node_set: str = attr()
+
+
+class BCPrescribedDisplacement(BaseXmlModel, tag="bc", validate_assignment=True):
+    type: Literal["prescribed displacement"] = attr(
+        default="prescribed displacement", frozen=True
+    )
+    node_set: str = attr()
+    dof: Literal["x", "y", "z"] = element()
+    value: Value = element()
+    relative: Literal[0, 1] = element(default=0)
+
+
+class BCPrescribedShellDisplacement(BaseXmlModel, tag="bc", validate_assignment=True):
+    type: Literal["prescribed shell displacement"] = attr(
+        default="prescribed shell displacement", frozen=True
+    )
+    node_set: str = attr()
+    dof: Literal["sx", "sy", "sz"] = element()
+    value: Value = element()
+    relative: Literal[0, 1] = element(default=0)
+
+
+class BCPrescribedFluidPressure(BaseXmlModel, tag="bc", validate_assignment=True):
+    type: Literal["prescribed fluid pressure"] = attr(
+        default="prescribed fluid pressure", frozen=True
+    )
+    node_set: str = attr()
+    value: Value = element()
+    relative: Literal[0, 1] = element(default=0)
+
+
+class BCPrescribedDeformation(BaseXmlModel, tag="bc", validate_assignment=True):
+    type: Literal["prescribed deformation"] = attr(default="prescribed deformation")
+    node_set: str = attr()
+    scale: Value = element()
+    F: StringFloatVec9 = element(default="1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0")
+    relative: Literal[0, 1] = element(default=0)
+
+
+class BCRigid(BaseXmlModel, tag="bc", validate_assignment=True):
+    type: Literal["rigid"] = attr(default="rigid", frozen=True)
+    node_set: str = attr()
+    rb: str = element()
+
+
+class BCRigidDeformation(BaseXmlModel, tag="bc", validate_assignment=True):
+    type: Literal["rigid deformation"] = attr(default="rigid deformation", frozen=True)
+    node_set: str = attr()
+    pos: StringFloatVec3 = element(default="0.0,0.0,0.0")
+    rot: Value = element()
+    relative: Literal[0, 1] = element(default=0)
+
+
+class BCNormalDisplacement(BaseXmlModel, tag="bc", validate_assignment=True):
+    type: Literal["normal displacement"] = attr(
+        default="normal displacement", frozen=True
+    )
+    surface: str = attr()
+    scale: Value = element()
+    surface_hint: Literal[0, 1] = element(default=0)
+
+
+BoundaryConditionType = (
+    BCZeroDisplacement
+    | BCZeroShellDisplacement
+    | BCZeroFluidPressure
+    | BCPrescribedDisplacement
+    | BCPrescribedShellDisplacement
+    | BCPrescribedFluidPressure
+    | BCPrescribedDeformation
+    | BCRigid
+    | BCRigidDeformation
+    | BCNormalDisplacement
+)
+
+
+class Boundary(BaseXmlModel, tag="Boundary", validate_assignment=True):
+    all_bcs: list[BoundaryConditionType] = element(default=[], tag="bc")
+
+    def add_bc(self, new_bc: BoundaryConditionType):
+        self.all_bcs.append(new_bc)

pyfebio/constraints.py

@@ -0,0 +1,41 @@
+from typing import Literal, Union
+
+from pydantic_xml import BaseXmlModel, attr, element
+
+
+class ConstraintSymmetryPlane(BaseXmlModel, validate_assignment=True):
+    type: Literal["symmetry plane"] = attr(default="symmetry plane", frozen=True)
+    laugon: Literal[0, 1] = element(default=1)
+    tol: float = element(default=0.1)
+    penalty: float = element(default=1)
+    rhs: float = element(default=0)
+    minaug: int = element(default=0)
+    maxaug: int = element(default=50)
+
+
+class ConstraintPrestrain(BaseXmlModel, validate_assignment=True):
+    type: Literal["prestrain"] = attr(default="prestrain", frozen=True)
+    update: Literal[0, 1] = element(default=1)
+    tolerance: Literal[0] | float = element(default=0)
+    min_iters: int = element(default=0)
+    max_iters: int = element(default=-1)
+
+
+class ConstraintInSituStretch(BaseXmlModel, validate_assignment=True):
+    type: Literal["in-situ stretch"] = attr(default="in-situ stretch", frozen=True)
+    update: Literal[0, 1] = element(default=1)
+    tolerance: Literal[0] | float = element(default=0)
+    min_iters: int = element(default=0)
+    max_iters: int = element(default=-1)
+    max_stretch: Literal[0] | float = element(default=0)
+    isochoric: Literal[0, 1] = element(default=1)
+
+
+ConstraintTypes = Union[ConstraintSymmetryPlane, ConstraintInSituStretch, ConstraintPrestrain]
+
+
+class Constraints(BaseXmlModel, tag="Constraints", validate_assignment=True):
+    all_constraints: list[ConstraintTypes] = element(default=[], tag="constraint")
+
+    def add_constraint(self, new_constraint: ConstraintTypes):
+        self.all_constraints.append(new_constraint)

pyfebio/contact.py

@@ -0,0 +1,172 @@
+from typing import Literal
+
+from pydantic_xml import BaseXmlModel, attr, element
+
+
+class SlidingBase(BaseXmlModel, validate_assignment=True):
+    name: str | None = attr(default=None)
+    surface_pair: str = attr()
+    laugon: Literal["PENALTY", "AUGLAG"] = element(default="PENALTY")
+    two_pass: Literal[0, 1] = element(default=0)
+    penalty: float = element(default=1.0)
+    auto_penalty: Literal[0, 1] = element(default=0)
+    update_penalty: Literal[0, 1] = element(default=0)
+    tolerance: float = element(default=0.01)
+    gaptol: Literal[0] | float = element(default=0)
+    minaug: int = element(default=0)
+    maxaug: int = element(default=10)
+    search_tol: float = element(default=0.01)
+    search_radius: Literal[0] | float = element(default=0)
+    knmult: float = element(default=1.0)
+    seg_up: int = element(default=0)
+    node_reloc: Literal[0, 1] = element(default=0)
+
+
+class SlidingElastic(SlidingBase):
+    type: Literal["sliding-elastic"] = attr(default="sliding-elastic")
+    symmetric_stiffness: Literal[0, 1] = element(default=1)
+    smooth_aug: int = element(default=0)
+    tension: Literal[0, 1] = element(default=0)
+    fric_coeff: Literal[0] | float = element(default=0)
+    flip_primary: Literal[0, 1] = element(default=0)
+    flip_secondary: Literal[0, 1] = element(default=0)
+    shell_bottom_primary: Literal[0, 1] = element(default=0)
+    shell_bottom_secondary: Literal[0, 1] = element(default=0)
+    search_radius: Literal[0] | float = element(default=1)
+    offset: Literal[0] | float = element(default=0)
+
+
+class SlidingFacetOnFacet(SlidingBase):
+    type: Literal["sliding-facet-on-facet"] = attr(default="sliding-facet-on-facet")
+    smooth_aug: int = element(default=0)
+
+
+class SlidingNodeOnFacet(SlidingBase):
+    type: Literal["sliding-node-on-facet"] = attr(default="sliding-node-on-facet")
+    fric_coeff: Literal[0] | float = element(default=0)
+    fric_penalty: Literal[0] | float = element(default=0)
+    ktmult: Literal[0] | float = element(default=0)
+
+
+SlidingContactType = SlidingElastic | SlidingFacetOnFacet | SlidingNodeOnFacet
+
+
+class ContactPotential(BaseXmlModel, validate_assignment=True):
+    type: Literal["contact potential"] = attr(default="contact potential", frozen=True)
+    name: str = attr()
+    surface_pair: str = attr()
+    kc: float = element(default=1e-6)
+    p: int = element(default=4)
+    R_in: float = element(default=0.01)
+    R_out: float = element(default=0.05)
+
+
+class SlidingBiphasic(SlidingBase):
+    type: Literal["sliding-biphasic"] = attr(default="sliding-biphasic")
+    ptol: Literal[0] | float = element(default=0)
+    pressure_penalty: float = element(default=1)
+    symmetric_stiffness: Literal[0, 1] = element(default=1)
+    fric_coeff: Literal[0] | float = element(default=0)
+    contact_frac: float = element(default=0.0)
+    smooth_aug: int = element(default=0)
+    smooth_fls: int = element(default=0)
+    search_radius: Literal[0] | float = element(default=1)
+    flip_primary: Literal[0, 1] = element(default=0)
+    flip_secondary: Literal[0, 1] = element(default=0)
+    shell_bottom_primary: Literal[0, 1] = element(default=0)
+    shell_bottom_secondary: Literal[0, 1] = element(default=0)
+
+
+class Sliding2(SlidingBase):
+    type: Literal["sliding2"] = attr(default="sliding2")
+    ptol: Literal[0] | float = element(default=0)
+    pressure_penalty: float = element(default=1)
+    symmetric_stiffness: Literal[0, 1] = element(default=1)
+    search_radius: Literal[0] | float = element(default=1)
+    smooth_aug: int = element(default=0)
+    dual_proj: Literal[0, 1] = element(default=1)
+
+
+SlidingBiphasicContactType = SlidingBiphasic | Sliding2
+
+
+class TiedBase(BaseXmlModel, validate_assignment=True):
+    name: str = attr()
+    surface_pair: str = attr()
+    laugon: Literal["PENALTY", "AUGLAG"] = element(default="PENALTY")
+    tolerance: float = element(default=0.1)
+    penalty: float = element(default=1)
+    knmult: float = element(default=1)
+    minaug: int = element(default=0)
+    maxaug: int = element(default=10)
+
+
+class TiedElastic(TiedBase):
+    type: Literal["tied-elastic"] = attr(default="tied-elastic", frozen=True)
+    auto_penalty: Literal[0, 1] = element(default=0)
+    update_penalty: Literal[0, 1] = element(default=0)
+    two_pass: Literal[0, 1] = element(default=0)
+    search_tol: float = element(default=0.01)
+    search_radius: float = element(default=1)
+    gaptol: float = element(default=-1)
+    symmetric_stiffness: Literal[0, 1] = element(default=1)
+
+
+class TiedFacetOnFacet(TiedBase):
+    type: Literal["tied-facet-on-facet"] = attr(
+        default="tied-facet-on-facet", frozen=True
+    )
+    tolerance: float = element(default=0.01)
+    search_tolerance: float = element(default=0.0001)
+    gap_offset: Literal[0, 1] = element(default=0)
+
+
+class TiedNodeOnFacet(TiedBase):
+    type: Literal["tied-node-on-facet"] = attr(
+        default="tied-node-on-facet", frozen=True
+    )
+    tolerance: float = element(default=0.01)
+    search_tolerance: float = element(default=0.0001)
+    offset_shells: Literal[0, 1] = element(default=0)
+    max_distance: Literal[0] | float = element(deafult=0)
+    special: Literal[0, 1] = element(default=1)
+    node_reloc: Literal[0, 1] = element(default=0)
+
+
+class TiedBiphasic(TiedBase):
+    type: Literal["tied-biphasic"] = attr(default="tied-biphasic", frozen=True)
+    gaptol: float = element(default=-1)
+    ptol: float = element(default=-1)
+    auto_penalty: Literal[0, 1] = element(default=0)
+    update_penalty: Literal[0, 1] = element(default=0)
+    two_pass: Literal[0, 1] = element(default=0)
+    search_tol: float = element(default=0.01)
+    search_radius: float = element(default=1)
+    knmult: float = element(default=1)
+    pressure_penalty: float = element(default=1)
+    symmetric_stiffness: Literal[0, 1] = element(default=1)
+
+
+ContactType = (
+    SlidingElastic
+    | SlidingFacetOnFacet
+    | SlidingNodeOnFacet
+    | SlidingBiphasic
+    | Sliding2
+    | ContactPotential
+    | TiedElastic
+    | TiedFacetOnFacet
+    | TiedNodeOnFacet
+    | TiedBiphasic
+)
+
+
+class Contact(BaseXmlModel, tag="Contact", validate_assignment=True):
+    all_contact_interfaces: list[ContactType] = element(default=[], tag="contact")
+
+    def add_contact(self, new_contact: ContactType):
+        if new_contact.name is None:
+            new_contact.name = (
+                f"{new_contact.type}_{len(self.all_contact_interfaces) + 1}"
+            )
+        self.all_contact_interfaces.append(new_contact)

pyfebio/control.py

@@ -0,0 +1,76 @@
+from typing import Literal
+
+from pydantic_xml import BaseXmlModel, attr, element
+
+
+class TimeStepValue(BaseXmlModel, validate_assignment=True):
+    lc: int | None = attr(default=None)
+    text: float = 1.0
+
+
+class TimeStepper(BaseXmlModel, validate_assignment=True):
+    type: Literal["default"] = attr(default="default", frozen=True)
+    max_retries: int = element(default=5, ge=0)
+    opt_iter: int = element(default=11, ge=0)
+    dtmin: float = element(default=0.0, ge=0.0)
+    dtmax: TimeStepValue = element(default=TimeStepValue())
+    aggressiveness: Literal[0, 1] = element(default=0)
+    cutback: float = element(default=0.5, ge=0.0, le=1.0)
+    dtforce: Literal[0, 1] = element(default=0)
+
+
+class LinearSolver(BaseXmlModel, validate_assignment=True):
+    type: Literal["pardiso", "mkl_dss"] = attr(default="pardiso")
+
+
+class QuasiNewtonMethod(BaseXmlModel, validate_assignment=True):
+    type: Literal["BFGS", "Broyden", "Full Newton", "JFNK", "Modified Newton"] = attr(default="BFGS")
+    max_ups: int = element(default=10, ge=0)
+    max_buffer_size: int = element(default=0, ge=0)
+    cycle_buffer: Literal[0, 1] = element(default=1)
+    cmax: float = element(default=1.0e5)
+
+
+class Solver(BaseXmlModel, validate_assignment=True, skip_empty=True):
+    """
+    Class for Non-Linear Solver settings. Currently, only supporting
+    "solid" and "biphasic" analyses, and direct linear solvers "pardiso"
+    and "mkl_dss".
+
+    More nuanced parameters can be added as needed.
+    """
+
+    type: Literal["solid", "biphasic"] = attr(default="solid")
+    dtol: float = element(default=0.001, gt=0)
+    etol: float = element(default=0.01, ge=0)
+    rtol: float = element(default=0, ge=0)
+    ptol: float | None = element(default=None)
+    lstol: float = element(default=0.9, ge=0)
+    lsmin: float = element(default=0.01, gt=0)
+    lsiter: int = element(default=5, ge=0)
+    max_refs: int = element(default=15, ge=0)
+    diverge_reform: Literal[0, 1] = element(default=1)
+    min_residual: float = element(default=1e-20, gt=0.0)
+    qn_method: QuasiNewtonMethod = element(default=QuasiNewtonMethod())
+    symmetric_stiffness: Literal["symmetric", "non-symmetric", "symmetric-structure"] = element(default="non-symmetric")
+    equation_scheme: Literal["staggered", "block"] = element(default="staggered")
+    equation_order: Literal["default", "reverse", "febio2"] = element(default="default")
+    optimize_bw: Literal[0, 1] = element(default=0)
+    linear_solver: LinearSolver = element(default=LinearSolver())
+
+
+class Control(BaseXmlModel, tag="Control", validate_assignment=True):
+    analysis: Literal["STATIC", "DYNAMIC", "STEADY-STATE", "TRANSIENT"] = element(default="STATIC")
+    time_steps: int = element(default=10)
+    step_size: float = element(default=0.1)
+    plot_zero_state: Literal[0, 1] = element(default=0)
+    plot_range: str = element(default="0,-1")
+    plot_level: Literal["PLOT_NEVER", "PLOT_MAJOR_ITRS", "PLOT_MINOR_ITRS", "PLOT_MUST_POINTS"] = element(default="PLOT_MAJOR_ITRS")
+    output_level: Literal["OUTPUT_NEVER", "OUTPUT_MAJOR_ITRS", "OUTPUT_MINOR_ITRS", "OUTPUT_MUST_POINTS", "OUTPUT_FINAL"] = element(
+        default="OUTPUT_MAJOR_ITRS"
+    )
+    plot_stride: int = element(default=1)
+    output_stride: int = element(default=1)
+    adaptor_re_solve: int = element(default=1)
+    time_stepper: TimeStepper | None = element(default=TimeStepper())
+    solver: Solver = element(default=Solver())

pyfebio/discrete.py

@@ -0,0 +1,40 @@
+from typing import Literal
+
+from pydantic_xml import BaseXmlModel, attr, element
+
+
+class Spring(BaseXmlModel, tag="discrete_material", validate_assignment=True):
+    id: int = attr()
+    name: str = attr()
+    type: str = attr(default="linear spring", frozen=True)
+    E: float = element(default=1.0)
+
+
+class NonlinearSpringForce(BaseXmlModel, tag="force", validate_assignment=True):
+    type: Literal["math"] = attr(default="math", frozen=True)
+    math: str = element()
+
+
+class NonlinearSpring(BaseXmlModel, tag="discrete_material", validate_assignment=True):
+    id: int = attr()
+    name: str = attr()
+    type: str = attr(default="nonlinear spring", frozen=True)
+    scale: float = element(default=1.0)
+    measure: Literal["strain"] = element(default="strain", frozen=True)
+    force: NonlinearSpringForce = element()
+
+
+class DiscreteEntry(BaseXmlModel, tag="discrete", validate_assignment=True):
+    dmat: int = attr()
+    discrete_set: str = attr()
+
+
+class Discrete(BaseXmlModel, validate_assignment=True):
+    discrete_materials: list[NonlinearSpring | Spring] = element(default=[])
+    discrete_elements: list[DiscreteEntry] = element(default=[])
+
+    def add_discrete_material(self, new_material: NonlinearSpring | Spring):
+        self.discrete_materials.append(new_material)
+
+    def add_discrete_element(self, new_element: DiscreteEntry):
+        self.discrete_elements.append(new_element)

pyfebio/globals.py

@@ -0,0 +1,12 @@
+from pydantic_xml import BaseXmlModel, element
+
+
+class Constants(BaseXmlModel, validate_assignment=True):
+    T: float = element(default=298)
+    P: float = element(default=0)
+    R: float = element(default=8.314e-6)
+    Fc: float = element(default=96485e-9)
+
+
+class Globals(BaseXmlModel, validate_assignment=True):
+    constants: Constants = element(default=Constants(), tag="Constants")

pyfebio/include.py

@@ -0,0 +1,5 @@
+from pydantic_xml import BaseXmlModel
+
+
+class Include(BaseXmlModel, tag="Include", validate_assignment=True):
+    text: str

pyfebio/initial.py

@@ -0,0 +1,27 @@
+from typing import Literal
+
+from pydantic_xml import BaseXmlModel, attr, element
+
+from ._types import (
+    StringFloatVec3,
+)
+
+
+class InitialVelocity(BaseXmlModel, validate_assignment=True):
+    type: Literal["velocity", "shell_velocity", "initial fluid velocity"] = attr()
+    node_set: str = attr()
+    value: StringFloatVec3 = element(default="0.0,0.0,0.0")
+
+
+class InitialPrestrain(BaseXmlModel, validate_assignment=True):
+    type: Literal["prestrain"] = attr(default="prestrain", frozen=True)
+    node_set: str = attr()
+    init: Literal[0, 1] = element(default=1)
+    reset: Literal[0, 1] = element(default=1)
+
+
+class Initial(BaseXmlModel, validate_assignment=True):
+    all_initial_conditions: list[InitialVelocity | InitialPrestrain] = element(default=[], tag="ic")
+
+    def add_initial_condition(self, new_initial_condition: InitialVelocity | InitialPrestrain):
+        self.all_initial_conditions.append(new_initial_condition)

pyfebio/loaddata.py

@@ -0,0 +1,51 @@
+from typing import Literal
+
+from pydantic_xml import BaseXmlModel, attr, element
+
+from ._types import (
+    StringFloatVec2,
+)
+
+
+class CurvePoints(BaseXmlModel, validate_assignment=True):
+    points: list[StringFloatVec2] = element(default=[], tag="pt")
+
+    def add_point(self, new_point: StringFloatVec2):
+        self.points.append(new_point)
+
+
+class LoadCurve(BaseXmlModel, tag="load_controller", validate_assignment=True):
+    id: int = attr()
+    type: Literal["loadcurve"] = attr(default="loadcurve", frozen=True)
+    interpolate: Literal["LINEAR", "STEP", "SMOOTH"] = element(default="LINEAR")
+    extend: Literal["CONSTANT", "EXTRAPOLATE", "REPEAT", "REPEAT OFFSET"] = element(default="CONSTANT")
+    points: CurvePoints = element()
+
+
+class PIDController(BaseXmlModel, validate_assignment=True):
+    id: int = attr()
+    type: Literal["PID"] = attr(default="PID", frozen=True)
+    var: str = element()
+    target: float = element()
+    Kp: float = element()
+    Kd: float = element()
+    Ki: float = element()
+
+
+class MathController(BaseXmlModel, validate_assignment=True):
+    id: int = attr()
+    type: Literal["math"] = attr(default="math", frozen=True)
+    math: str = element()
+
+
+class LoadData(BaseXmlModel, validate_assignment=True):
+    load_controllers: list[LoadCurve | PIDController | MathController] = element(default=[], tag="load_controller")
+
+    def add_load_curve(self, new_load_curve: LoadCurve):
+        self.load_controllers.append(new_load_curve)
+
+    def add_pid_controller(self, new_pid_controller: PIDController):
+        self.load_controllers.append(new_pid_controller)
+
+    def add_math_controller(self, new_math_controller: MathController):
+        self.load_controllers.append(new_math_controller)