pyfebio package

Submodules

pyfebio.boundary module

class pyfebio.boundary.BCLinearConstraint(**data)

Bases: BaseXmlModel

child_dof: list[ChildDof]

dof: Literal['x', 'y', 'z', 'p']

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node: int

type: Literal['linear constraint']

class pyfebio.boundary.BCNormalDisplacement(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

scale: Value

surface: str

surface_hint: Literal[0, 1]

type: Literal['normal displacement']

class pyfebio.boundary.BCPrescribedConcentration(**data)

Bases: BaseXmlModel

Assign a prescribed concentration of a solute to a node set. Hint: dof should be a string of the form “c{solute id}” e.g. “c1”, “c2”, etc.

dof: str

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

relative: Literal[0, 1]

type: Literal['prescribed concentration']

value: Value

class pyfebio.boundary.BCPrescribedDeformation(**data)

Bases: BaseXmlModel

F: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

relative: Literal[0, 1]

scale: Value

type: Literal['prescribed deformation']

class pyfebio.boundary.BCPrescribedDisplacement(**data)

Bases: BaseXmlModel

dof: Literal['x', 'y', 'z']

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

relative: Literal[0, 1]

type: Literal['prescribed displacement']

value: Value

class pyfebio.boundary.BCPrescribedFluidPressure(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

relative: Literal[0, 1]

type: Literal['prescribed fluid pressure']

value: Value

class pyfebio.boundary.BCPrescribedShellDisplacement(**data)

Bases: BaseXmlModel

dof: Literal['sx', 'sy', 'sz']

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

relative: Literal[0, 1]

type: Literal['prescribed shell displacement']

value: Value

class pyfebio.boundary.BCRigid(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

node_set: str

rb: str

type: Literal['rigid']

class pyfebio.boundary.BCRigidDeformation(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

pos: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

relative: Literal[0, 1]

rot: Value

type: Literal['rigid deformation']

class pyfebio.boundary.BCZeroConcentration(**data)

Bases: BaseXmlModel

Assign a zero concentration boundary condition for a solute to a node set. Hint: c_dof should be a string of the form “c{solute id}” e.g. “c1”, “c2”, etc.

c_dof: str

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

type: Literal['zero concentration']

class pyfebio.boundary.BCZeroDisplacement(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

type: Literal['zero displacement']

x_dof: Literal[0, 1]

y_dof: Literal[0, 1]

z_dof: Literal[0, 1]

class pyfebio.boundary.BCZeroFluidPressure(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

type: Literal['zero fluid pressure']

class pyfebio.boundary.BCZeroShellDisplacement(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

sx_dof: Literal[0, 1]

sy_dof: Literal[0, 1]

sz_dof: Literal[0, 1]

type: Literal['zero shell displacement']

class pyfebio.boundary.Boundary(**data)

Bases: BaseXmlModel

add_bc(new_bc)

all_bcs: list[BCZeroDisplacement | BCZeroShellDisplacement | BCZeroFluidPressure | BCPrescribedDisplacement | BCPrescribedShellDisplacement | BCPrescribedFluidPressure | BCPrescribedDeformation | BCRigid | BCRigidDeformation | BCNormalDisplacement | BCZeroConcentration | BCPrescribedConcentration | BCLinearConstraint]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class pyfebio.boundary.ChildDof(**data)

Bases: BaseXmlModel

dof: Literal['x', 'y', 'z', 'p']

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node: int

value: float

class pyfebio.boundary.MatchingOsmCoefficient(**data)

Bases: BaseXmlModel

ambient_osmolarity: float

ambient_pressure: float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

shell_bottom: Literal[0, 1]

surface: str

type: Literal['matching_osm_coef']

class pyfebio.boundary.Value(**data)

Bases: BaseXmlModel

lc: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float | ~typing.Annotated[str, ~pydantic.types.StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?,[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?,[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$, ascii_only=None)]

pyfebio.constraints module

class pyfebio.constraints.ConstraintInSituStretch(**data)

Bases: BaseXmlModel

isochoric: Literal[0, 1]

max_iters: int

max_stretch: Literal[0] | float

min_iters: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

tolerance: Literal[0] | float

type: Literal['in-situ stretch']

update: Literal[0, 1]

class pyfebio.constraints.ConstraintPrestrain(**data)

Bases: BaseXmlModel

max_iters: int

min_iters: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

tolerance: Literal[0] | float

type: Literal['prestrain']

update: Literal[0, 1]

class pyfebio.constraints.ConstraintSymmetryPlane(**data)

Bases: BaseXmlModel

laugon: Literal[0, 1]

maxaug: int

minaug: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

penalty: float

rhs: float

tol: float

type: Literal['symmetry plane']

class pyfebio.constraints.Constraints(**data)

Bases: BaseXmlModel

add_constraint(new_constraint)

all_constraints: list[ConstraintSymmetryPlane | ConstraintInSituStretch | ConstraintPrestrain]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

pyfebio.contact module

class pyfebio.contact.Contact(**data)

Bases: BaseXmlModel

add_contact(new_contact)

all_contact_interfaces: list[SlidingElastic | SlidingFacetOnFacet | SlidingNodeOnFacet | SlidingBiphasic | Sliding2 | ContactPotential | TiedElastic | TiedFacetOnFacet | TiedNodeOnFacet | TiedBiphasic]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class pyfebio.contact.ContactPotential(**data)

Bases: BaseXmlModel

R0_min: Literal[0] | float

R_in: float

R_out: float

check_intersections: Literal[0, 1]

integration_rule: Literal['default', 'higher-order']

kc: float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

p: int

surface_pair: str

type: Literal['contact potential']

w_tol: Literal[0] | float

class pyfebio.contact.Sliding2(**data)

Bases: SlidingBase

dual_proj: Literal[0, 1]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

pressure_penalty: float

ptol: Literal[0] | float

search_radius: Literal[0] | float

smooth_aug: int

symmetric_stiffness: Literal[0, 1]

type: Literal['sliding2']

class pyfebio.contact.SlidingBase(**data)

Bases: BaseXmlModel

auto_penalty: Literal[0, 1]

gaptol: Literal[0] | float

knmult: float

laugon: Literal['PENALTY', 'AUGLAG']

maxaug: int

minaug: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

node_reloc: Literal[0, 1]

penalty: float

search_radius: Literal[0] | float

search_tol: float

seg_up: int

surface_pair: str

tolerance: float

two_pass: Literal[0, 1]

update_penalty: Literal[0, 1]

class pyfebio.contact.SlidingBiphasic(**data)

Bases: SlidingBase

contact_frac: float

flip_primary: Literal[0, 1]

flip_secondary: Literal[0, 1]

fric_coeff: Literal[0] | float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

pressure_penalty: float

ptol: Literal[0] | float

search_radius: Literal[0] | float

shell_bottom_primary: Literal[0, 1]

shell_bottom_secondary: Literal[0, 1]

smooth_aug: int

smooth_fls: int

symmetric_stiffness: Literal[0, 1]

type: Literal['sliding-biphasic']

class pyfebio.contact.SlidingElastic(**data)

Bases: SlidingBase

flip_primary: Literal[0, 1]

flip_secondary: Literal[0, 1]

fric_coeff: Literal[0] | float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

offset: Literal[0] | float

search_radius: Literal[0] | float

shell_bottom_primary: Literal[0, 1]

shell_bottom_secondary: Literal[0, 1]

smooth_aug: int

symmetric_stiffness: Literal[0, 1]

tension: Literal[0, 1]

type: Literal['sliding-elastic']

class pyfebio.contact.SlidingFacetOnFacet(**data)

Bases: SlidingBase

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

smooth_aug: int

type: Literal['sliding-facet-on-facet']

class pyfebio.contact.SlidingNodeOnFacet(**data)

Bases: SlidingBase

fric_coeff: Literal[0] | float

fric_penalty: Literal[0] | float

ktmult: Literal[0] | float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['sliding-node-on-facet']

class pyfebio.contact.TiedBase(**data)

Bases: BaseXmlModel

laugon: Literal['PENALTY', 'AUGLAG']

maxaug: int

minaug: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

penalty: float

surface_pair: str

tolerance: float

class pyfebio.contact.TiedBiphasic(**data)

Bases: TiedBase

auto_penalty: Literal[0, 1]

gaptol: float

knmult: float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

pressure_penalty: float

ptol: float

search_radius: float

search_tol: float

symmetric_stiffness: Literal[0, 1]

two_pass: Literal[0, 1]

type: Literal['tied-biphasic']

update_penalty: Literal[0, 1]

class pyfebio.contact.TiedElastic(**data)

Bases: TiedBase

auto_penalty: Literal[0, 1]

gaptol: float

knmult: float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

search_radius: float

search_tol: float

symmetric_stiffness: Literal[0, 1]

two_pass: Literal[0, 1]

type: Literal['tied-elastic']

update_penalty: Literal[0, 1]

class pyfebio.contact.TiedFacetOnFacet(**data)

Bases: TiedBase

gap_offset: Literal[0, 1]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

search_tolerance: float

tolerance: float

type: Literal['tied-facet-on-facet']

class pyfebio.contact.TiedNodeOnFacet(**data)

Bases: TiedBase

max_distance: Literal[0] | float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_reloc: Literal[0, 1]

offset_shells: Literal[0, 1]

search_tolerance: float

special: Literal[0, 1]

tolerance: float

type: Literal['tied-node-on-facet']

pyfebio.control module

class pyfebio.control.Control(**data)

Bases: BaseXmlModel

adaptor_re_solve: int

analysis: Literal['STATIC', 'DYNAMIC', 'STEADY-STATE', 'TRANSIENT']

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

output_level: Literal['OUTPUT_NEVER', 'OUTPUT_MAJOR_ITRS', 'OUTPUT_MINOR_ITRS', 'OUTPUT_MUST_POINTS', 'OUTPUT_FINAL']

output_stride: int

plot_level: Literal['PLOT_NEVER', 'PLOT_MAJOR_ITRS', 'PLOT_MINOR_ITRS', 'PLOT_MUST_POINTS']

plot_range: str

plot_stride: int

plot_zero_state: Literal[0, 1]

solver: Solver | ExplicitSolver

step_size: float

time_stepper: TimeStepper | None

time_steps: int

class pyfebio.control.ExplicitSolver(**data)

Bases: BaseXmlModel

dyn_damping: Literal[1] | float

mass_lumping: Literal[1, 2]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['explicit-solid']

class pyfebio.control.LinearSolver(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['pardiso', 'mkl_dss']

class pyfebio.control.QuasiNewtonMethod(**data)

Bases: BaseXmlModel

cmax: float

cycle_buffer: Literal[0, 1]

max_buffer_size: int

max_ups: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['BFGS', 'Broyden', 'Full Newton', 'JFNK', 'Modified Newton']

class pyfebio.control.Solver(**data)

Bases: BaseXmlModel

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.

ctol: float | None

diverge_reform: Literal[0, 1]

dtol: float

equation_order: Literal['default', 'reverse', 'febio2']

equation_scheme: Literal['staggered', 'block']

etol: float

force_positive_concentrations: Literal[0, 1] | None

linear_solver: LinearSolver

lsiter: int

lsmin: float

lstol: float

max_refs: int

min_residual: float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

optimize_bw: Literal[0, 1]

ptol: float | None

qn_method: QuasiNewtonMethod

rtol: float

symmetric_stiffness: Literal['symmetric', 'non-symmetric', 'symmetric-structure']

type: Literal['solid', 'biphasic', 'multiphasic']

class pyfebio.control.TimeStepValue(**data)

Bases: BaseXmlModel

lc: int | None

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float

class pyfebio.control.TimeStepper(**data)

Bases: BaseXmlModel

aggressiveness: Literal[0, 1]

cutback: float

dtforce: Literal[0, 1]

dtmax: TimeStepValue

dtmin: float

max_retries: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

opt_iter: int

type: Literal['default']

pyfebio.discrete module

class pyfebio.discrete.Discrete(**data)

Bases: BaseXmlModel

add_discrete_element(new_element)

add_discrete_material(new_material)

discrete_elements: list[DiscreteEntry]

discrete_materials: list[NonlinearSpring | Spring | TensionOnlyLinearSpring | HillElement | ExperimentalSpring]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class pyfebio.discrete.DiscreteEntry(**data)

Bases: BaseXmlModel

discrete_set: str

dmat: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class pyfebio.discrete.ExperimentalSpring(**data)

Bases: BaseXmlModel

E: float

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

sM: Annotated[float, Gt(gt=0)] | Annotated[float, Lt(lt=0)]

sm: Annotated[float, Gt(gt=0)] | Annotated[float, Lt(lt=0)]

type: Literal['experimental spring']

class pyfebio.discrete.HillElement(**data)

Bases: BaseXmlModel

Fmax: float

Ftl: Scale | None

Fvl: Scale | None

Ksh: float

L0: Literal[0] | float

Lmax: float

Sv: Scale | None

Vmax: float

ac: float

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

type: Literal['Hill']

class pyfebio.discrete.NonlinearSpring(**data)

Bases: BaseXmlModel

force: NonlinearSpringForce

id: int

measure: Literal['elongation', 'strain', 'stretch']

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

scale: float

type: Literal['nonlinear spring']

class pyfebio.discrete.NonlinearSpringForce(**data)

Bases: BaseXmlModel

math: str

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['math']

class pyfebio.discrete.Scale(**data)

Bases: BaseXmlModel

All parameters are set to None initially, to handle all customization. We add a validitor to ensure consistency.

interpolate: Literal['linear', 'smooth'] | None

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

points: ScalePoints | None

type: Literal['point', 'const'] | None

validate_options()

value: float | None

class pyfebio.discrete.ScalePoints(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

pt: list[~typing.Annotated[str, ~pydantic.types.StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?,[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$, ascii_only=None)]]

class pyfebio.discrete.Spring(**data)

Bases: BaseXmlModel

E: float

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

type: str

class pyfebio.discrete.TensionOnlyLinearSpring(**data)

Bases: BaseXmlModel

E: float

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

type: Literal['tension-only linear spring']

pyfebio.globals module

class pyfebio.globals.Constants(**data)

Bases: BaseXmlModel

Fc: float

P: float

R: float

T: float

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class pyfebio.globals.Globals(**data)

Bases: BaseXmlModel

constants: Constants

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

solid_bound_molecules: SolidBoundMolecules | None

solutes: Solutes | None

class pyfebio.globals.SolidBoundMolecule(**data)

Bases: BaseXmlModel

charge_number: int

density: float

id: int

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

molar_mass: float

name: str | None

class pyfebio.globals.SolidBoundMolecules(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

solid_bound: list[SolidBoundMolecule]

class pyfebio.globals.Solute(**data)

Bases: BaseXmlModel

charge_number: int

density: float

id: int

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

molar_mass: float

name: str | None

class pyfebio.globals.Solutes(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

solute: list[Solute]

pyfebio.include module

class pyfebio.include.Include(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: str

pyfebio.initial module

class pyfebio.initial.Initial(**data)

Bases: BaseXmlModel

add_initial_condition(new_initial_condition)

all_initial_conditions: list[InitialVelocity | InitialPrestrain | InitialConcentration | InitialFluidPressure]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class pyfebio.initial.InitialConcentration(**data)

Bases: BaseXmlModel

dof: str

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

type: Literal['initial concentration']

value: float

class pyfebio.initial.InitialFluidPressure(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

type: Literal['initial fluid pressure']

value: float

class pyfebio.initial.InitialPrestrain(**data)

Bases: BaseXmlModel

init: Literal[0, 1]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

reset: Literal[0, 1]

type: Literal['prestrain']

class pyfebio.initial.InitialVelocity(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

type: Literal['velocity', 'shell_velocity', 'initial fluid velocity']

value: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

pyfebio.loaddata module

class pyfebio.loaddata.CurvePoints(**data)

Bases: BaseXmlModel

add_point(new_point)

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

points: list[~typing.Annotated[str, ~pydantic.types.StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?,[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$, ascii_only=None)]]

class pyfebio.loaddata.LoadCurve(**data)

Bases: BaseXmlModel

extend: Literal['CONSTANT', 'EXTRAPOLATE', 'REPEAT', 'REPEAT OFFSET']

id: int

interpolate: Literal['LINEAR', 'STEP', 'SMOOTH']

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

points: CurvePoints

type: Literal['loadcurve']

class pyfebio.loaddata.LoadData(**data)

Bases: BaseXmlModel

add_load_curve(new_load_curve)

add_math_controller(new_math_controller)

add_pid_controller(new_pid_controller)

load_controllers: list[LoadCurve | PIDController | MathController]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class pyfebio.loaddata.MathController(**data)

Bases: BaseXmlModel

id: int

math: str

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['math']

class pyfebio.loaddata.PIDController(**data)

Bases: BaseXmlModel

Kd: float

Ki: float

Kp: float

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

target: float

type: Literal['PID']

var: str

pyfebio.loads module

class pyfebio.loads.CentrifugalBodyForce(**data)

Bases: BaseXmlModel

angular_speed: float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rotation_axis: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

rotation_center: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

type: Literal['centrifugal']

class pyfebio.loads.ConstantBodyForce(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['const']

x: Scale

y: Scale

z: Scale

class pyfebio.loads.FluidFlux(**data)

Bases: BaseXmlModel

flux: Scale

linear: Literal[0, 1]

mixture: Literal[0, 1]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

surface: str

type: Literal['fluidflux']

class pyfebio.loads.FluidPressure(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

pressure: Scale

surface: str

type: Literal['fluid pressure']

class pyfebio.loads.Loads(**data)

Bases: BaseXmlModel

add_body_load(new_load)

add_nodal_load(new_load)

add_surface_load(new_load)

all_body_loads: list[ConstantBodyForce | NonConstantBodyForce | CentrifugalBodyForce | MovingFrame | MassDamping]

all_nodal_loads: list[NodalLoad | NodalForce | NodalTargetForce | NodalFluidFlux]

all_surface_loads: list[TractionLoad | PressureLoad | FluidFlux | FluidPressure]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class pyfebio.loads.MassDamping(**data)

Bases: BaseXmlModel

C: float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['mass damping']

class pyfebio.loads.MovingFrame(**data)

Bases: BaseXmlModel

ax: Scale

ay: Scale

az: Scale

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['moving frame']

wx: Scale

wy: Scale

wz: Scale

class pyfebio.loads.NodalFluidFlux(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

relative: Literal[0, 1]

type: Literal['nodal fluidflux']

value: Scale

class pyfebio.loads.NodalForce(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

relative: Literal[0, 1]

type: Literal['nodal_force']

value: Scale

class pyfebio.loads.NodalLoad(**data)

Bases: BaseXmlModel

dof: Literal['x', 'y', 'z', 'p']

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

relative: Literal[0, 1]

scale: Scale

type: Literal['nodal_load']

class pyfebio.loads.NodalTargetForce(**data)

Bases: BaseXmlModel

force: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_set: str

scale: Scale

type: Literal['nodal_target_force']

class pyfebio.loads.NonConstantBodyForce(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['non-const']

x: ScaleMath

y: ScaleMath

z: ScaleMath

class pyfebio.loads.PressureLoad(**data)

Bases: BaseXmlModel

linear: Literal[0, 1]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

pressure: Scale

shell_bottom: Literal[0, 1]

surface: str

symmetric_stiffness: Literal[0, 1]

type: Literal['pressure']

class pyfebio.loads.Scale(**data)

Bases: BaseXmlModel

lc: int | None

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float | ~typing.Annotated[str, ~pydantic.types.StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?,[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?,[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$, ascii_only=None)]

class pyfebio.loads.ScaleMath(**data)

Bases: BaseXmlModel

lc: int | None

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float | str

class pyfebio.loads.TractionLoad(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

scale: Scale

surface: str

traction: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

type: Literal['traction']

pyfebio.material module

class pyfebio.material.ActiveContraction(**data)

Bases: BaseXmlModel

ascl: DynamicMaterialParameter

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

ca0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

l0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

refl: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['active contraction']

class pyfebio.material.ArrudaBoyce(**data)

Bases: MaterialBase

N: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_int)]

kappa: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

n_term: int

type: Literal['Arruda-Boyce unconstrained']

class pyfebio.material.ArrudaBoyceUC(**data)

Bases: MaterialBase

N: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

mu: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['Arruda-Boyce']

class pyfebio.material.BiphasicMaterial(**data)

Bases: MaterialBaseNoDensity

active_supply: MaterialParameter | None

fluid_density: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

permeability: ConstantIsoPerm | ExponentialIsoPerm | HolmesMowPerm | RefIsoPerm | RefOrthoPerm | RefTransIsoPerm

phi0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

solid: ArrudaBoyce | CoupledMooneyRivlin | CoupledVerondaWestmann | CubicCLE | EllipsoidalFiberDistributionNeoHookean | FungOrthotropicCompressible | GentCompressible | HolmesMow | HolzapfelGasserOgdenUnconstrained | IsotropicElastic | IsotropicHencky | LargePoissonRatioLigament | Lung | NaturalNeoHookean | NeoHookean | PorousNeoHookean | OrthotropicElastic | OrthotropicCLE | ShenoyWang | TransIsoMooneyRivlin | TransIsoVerondaWestmann | UnconstrainedOgden | ArrudaBoyceUC | EllipsoidalFiberDistributionMooneyRivlinUC | EllipsoidalFiberDistributionVerondaWestmannUC | FungOrthotropicUC | GentUC | HolmesMowUC | HolzapfelGasserOgdenUC | MooneyRivlinUC | MuscleUC | OgdenUC | TendonUC | TensionCompressionNonlinearOrthoUC | TransIsoMooneyRivlinUC | TransIsoVerondaWestmannUC | MooneyRivlinVonMisesFibersUC | LeeSacksUC | Yeoh | SolidMixture | SolidMixtureUC

solvent_supply: SolventSupply | None

tau: Annotated[float, Ge(ge=0)] | None

type: Literal['biphasic']

class pyfebio.material.BiphasicSoluteMaterial(**data)

Bases: MaterialBaseNoDensity

add_solute(new_solute)

fluid_density: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

osmotic_coefficient: OsmoticCoefficientConst | OsmoticCoefficientManning

permeability: ConstantIsoPerm | ExponentialIsoPerm | HolmesMowPerm | RefIsoPerm | RefOrthoPerm | RefTransIsoPerm

phi0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

solid: ArrudaBoyce | CoupledMooneyRivlin | CoupledVerondaWestmann | CubicCLE | EllipsoidalFiberDistributionNeoHookean | FungOrthotropicCompressible | GentCompressible | HolmesMow | HolzapfelGasserOgdenUnconstrained | IsotropicElastic | IsotropicHencky | LargePoissonRatioLigament | Lung | NaturalNeoHookean | NeoHookean | PorousNeoHookean | OrthotropicElastic | OrthotropicCLE | ShenoyWang | TransIsoMooneyRivlin | TransIsoVerondaWestmann | UnconstrainedOgden | ArrudaBoyceUC | EllipsoidalFiberDistributionMooneyRivlinUC | EllipsoidalFiberDistributionVerondaWestmannUC | FungOrthotropicUC | GentUC | HolmesMowUC | HolzapfelGasserOgdenUC | MooneyRivlinUC | MuscleUC | OgdenUC | TendonUC | TensionCompressionNonlinearOrthoUC | TransIsoMooneyRivlinUC | TransIsoVerondaWestmannUC | MooneyRivlinVonMisesFibersUC | LeeSacksUC | Yeoh | SolidMixture | SolidMixtureUC

solute: list[Solute] | None

solvent_supply: SolventSupply | None

type: Literal['biphasic-solute']

class pyfebio.material.CFDCircular(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['circular']

class pyfebio.material.CFDEllipsoidal(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

spa: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

type: Literal['ellipsoidal']

class pyfebio.material.CFDElliptical(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

spa1: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

spa2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

type: Literal['elliptical']

class pyfebio.material.CFDSpherical(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['spherical']

class pyfebio.material.CFDVonMises2d(**data)

Bases: BaseXmlModel

b: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['von-Mises-2d']

class pyfebio.material.CFDVonMises3d(**data)

Bases: BaseXmlModel

b: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['von-Mises-3d']

class pyfebio.material.CarterHayes(**data)

Bases: MaterialBase

E0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

gamma: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rho0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

sbm: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_int)]

type: Literal['Carter-Hayes']

v: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

class pyfebio.material.CellGrowth(**data)

Bases: MaterialBase

ce: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

cr: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

phir: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['cell growth']

class pyfebio.material.ConstantIsoPerm(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

perm: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['perm-const-iso']

class pyfebio.material.ContinuousFiberDistribution(**data)

Bases: BaseXmlModel

distribution: CFDCircular | CFDSpherical | CFDVonMises3d | CFDVonMises2d | CFDEllipsoidal

fibers: FiberNeoHookean | FiberNaturalNeoHookean | FiberToeLinear | FiberEntropyChain | FiberExponentialPower | FiberExponentialLinear

mat_axis: MaterialAxisVector | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

scheme: GaussKronrodTrapezoidalIntegration | FiniteElementIntegration | TrapezoidalRuleIntegration

type: Literal['continuous fiber distribution']

class pyfebio.material.ContinuousFiberDistributionUC(**data)

Bases: BaseXmlModel

distribution: CFDCircular | CFDSpherical | CFDVonMises3d | CFDVonMises2d | CFDEllipsoidal

fibers: FiberToeLinearUC | FiberKiousisUC | FiberExponentialPowerUC | FiberExponentialLinearUC | FiberEntropyChainUC

mat_axis: MaterialAxisVector | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

scheme: GaussKronrodTrapezoidalIntegration | FiniteElementIntegration | TrapezoidalRuleIntegration

type: Literal['continuous fiber distribution uncoupled']

class pyfebio.material.CoupledMooneyRivlin(**data)

Bases: MaterialBase

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['coupled Mooney-Rivlin']

class pyfebio.material.CoupledVerondaWestmann(**data)

Bases: MaterialBase

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['coupled Veronda-Westmann']

class pyfebio.material.CubicCLE(**data)

Bases: MaterialBase

l2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lm1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lp1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

mu: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['cubic CLE']

class pyfebio.material.Diffusivity(**data)

Bases: BaseXmlModel

diff: MaterialParameter

free_diff: MaterialParameter

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

type: Literal['diff-const-iso']

class pyfebio.material.DonnanEquilibrium(**data)

Bases: BaseXmlModel

bosm: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

cF0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

phiw0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['Donnan equilibrium']

class pyfebio.material.DynamicMaterialParameter(**data)

Bases: BaseXmlModel

lc: int

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float | int | str

type: Literal['map', 'math'] | None

class pyfebio.material.EllipsoidalFiberDistribution(**data)

Bases: BaseXmlModel

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['ellipsoidal fiber distribution']

class pyfebio.material.EllipsoidalFiberDistributionDonnanEquilibrium(**data)

Bases: MaterialBase

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

bosm: MaterialParameter

cF0: DynamicMaterialParameter

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

phiw0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['EFD Donnan equilibrium']

class pyfebio.material.EllipsoidalFiberDistributionMooneyRivlinUC(**data)

Bases: MaterialBase

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['EFD Mooney-Rivlin']

class pyfebio.material.EllipsoidalFiberDistributionNeoHookean(**data)

Bases: MaterialBase

E: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['EFD neo-Hookean']

v: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

class pyfebio.material.EllipsoidalFiberDistributionUC(**data)

Bases: MaterialBaseNoDensity

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['EFD uncoupled']

class pyfebio.material.EllipsoidalFiberDistributionVerondaWestmannUC(**data)

Bases: MaterialBase

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['EFD Veronda-Westmann']

class pyfebio.material.ExponentialIsoPerm(**data)

Bases: BaseXmlModel

M: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

perm: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['perm-exp-iso']

class pyfebio.material.FiberEntropyChain(**data)

Bases: BaseXmlModel

N: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

fiber: FiberVector | None

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

n_term: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_int)]

type: str

class pyfebio.material.FiberEntropyChainUC(**data)

Bases: BaseXmlModel

N: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

fiber: FiberVector | None

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

n_term: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_int)]

type: str

class pyfebio.material.FiberExponentialLinear(**data)

Bases: BaseXmlModel

c3: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

c4: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c5: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

fiber: FiberVector | None

lam0: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: str

class pyfebio.material.FiberExponentialLinearUC(**data)

Bases: BaseXmlModel

c3: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

c4: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c5: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

fiber: FiberVector | None

lam0: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: str

class pyfebio.material.FiberExponentialPower(**data)

Bases: BaseXmlModel

alpha: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_gte_two_float)]

fiber: FiberVector | None

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lam0: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: str

class pyfebio.material.FiberExponentialPowerLinear(**data)

Bases: BaseXmlModel

E: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

alpha: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_gte_two_float)]

fiber: FiberVector | None

lam0: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: str

class pyfebio.material.FiberExponentialPowerUC(**data)

Bases: BaseXmlModel

alpha: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_gte_two_float)]

fiber: FiberVector | None

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: str

class pyfebio.material.FiberKiousisUC(**data)

Bases: BaseXmlModel

d1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

d2: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

fiber: FiberVector | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

n: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

type: str

class pyfebio.material.FiberNaturalNeoHookean(**data)

Bases: BaseXmlModel

fiber: FiberVector | None

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lam0: Annotated[MaterialParameter, AfterValidator(func=mat_is_gte_one_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: str

class pyfebio.material.FiberNeoHookean(**data)

Bases: BaseXmlModel

fiber: FiberVector | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

mu: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: str

class pyfebio.material.FiberToeLinear(**data)

Bases: BaseXmlModel

E: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_gte_two_float)]

fiber: FiberVector | None

lam0: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: str

class pyfebio.material.FiberToeLinearUC(**data)

Bases: BaseXmlModel

E: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_gte_two_float)]

fiber: FiberVector | None

lam0: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: str

class pyfebio.material.FiberVector(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

type: Literal['vector']

class pyfebio.material.FiniteElementIntegration(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

resolution: Literal[20, 34, 60, 74, 196, 210, 396, 410, 596, 610, 796, 810, 996, 1010, 1196, 1210, 1396, 1410, 1596, 1610, 1796]

type: Literal['fibers-3d-fei']

class pyfebio.material.FungOrthotropicCompressible(**data)

Bases: MaterialBase

E1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

E2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

E3: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

G12: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

G23: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

G31: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['Fung-ortho-compressible']

v12: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

v23: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

v31: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

class pyfebio.material.FungOrthotropicUC(**data)

Bases: MaterialBase

E1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

E2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

E3: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

G12: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

G23: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

G31: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['Fung orthotropic']

v12: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

v23: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

v31: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

class pyfebio.material.GaussKronrodTrapezoidalIntegration(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

nph: Literal[7, 11, 15, 19, 23, 27]

nth: Annotated[int, Gt(gt=0)]

type: Literal['fibers-3d-gkt']

class pyfebio.material.GentCompressible(**data)

Bases: MaterialBase

G: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

Jm: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

K: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['compressible Gent']

class pyfebio.material.GentUC(**data)

Bases: MaterialBase

G: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

Jm: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['Gent']

class pyfebio.material.HolmesMow(**data)

Bases: MaterialBase

E: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['Holmes-Mow']

v: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

class pyfebio.material.HolmesMowPerm(**data)

Bases: BaseXmlModel

M: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

alpha: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

perm: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['perm-Holmes-Mow']

class pyfebio.material.HolmesMowUC(**data)

Bases: MaterialBase

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

mu: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['uncoupled Holmes-Mow']

class pyfebio.material.HolzapfelGasserOgdenUC(**data)

Bases: MaterialBase

c: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

fiber: FiberVector | None

gamma: Annotated[MaterialParameter, AfterValidator(func=mat_is_lte_90_gte_0)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

k1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

k2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

kappa: Annotated[MaterialParameter, AfterValidator(func=mat_is_lte_onethird_gte_zero)]

mat_axis: MaterialAxisVector | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['Holzapfel-Gasser-Ogden']

class pyfebio.material.HolzapfelGasserOgdenUnconstrained(**data)

Bases: MaterialBase

c: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

fiber: FiberVector | None

gamma: Annotated[MaterialParameter, AfterValidator(func=mat_is_lte_90_gte_0)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

k1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

k2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

kappa: Annotated[MaterialParameter, AfterValidator(func=mat_is_lte_onethird_gte_zero)]

mat_axis: MaterialAxisVector | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['HGO unconstrained']

class pyfebio.material.InSituStretch(**data)

Bases: BaseXmlModel

lc: int

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: str | float

type: Literal['map', 'math'] | None

class pyfebio.material.IsotropicElastic(**data)

Bases: MaterialBase

E: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['isotropic elastic']

v: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

class pyfebio.material.IsotropicHencky(**data)

Bases: MaterialBase

E: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['isotropic Hencky']

v: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

class pyfebio.material.KinematicGrowth(**data)

Bases: MaterialBase

elastic: str

growth: Literal['volume', 'growth', 'area growth', 'fiber growth']

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class pyfebio.material.LargePoissonRatioLigament(**data)

Bases: MaterialBase

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

m: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

mu: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['PRLig']

v0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

class pyfebio.material.LeeSacksUC(**data)

Bases: MaterialBase

c0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

tangent_scale: Annotated[MaterialParameter, AfterValidator(func=mat_is_gte_one_float)]

type: Literal['uncoupled isotropic Lee-Sacks']

class pyfebio.material.Lung(**data)

Bases: MaterialBase

E: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c3: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

d1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

d3: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['lung']

v: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

class pyfebio.material.Material(**data)

Bases: BaseXmlModel

add_material(material)

all_materials: list[ArrudaBoyce | CoupledMooneyRivlin | CoupledVerondaWestmann | CubicCLE | EllipsoidalFiberDistributionNeoHookean | FungOrthotropicCompressible | GentCompressible | HolmesMow | HolzapfelGasserOgdenUnconstrained | IsotropicElastic | IsotropicHencky | LargePoissonRatioLigament | Lung | NaturalNeoHookean | NeoHookean | PorousNeoHookean | OrthotropicElastic | OrthotropicCLE | ShenoyWang | TransIsoMooneyRivlin | TransIsoVerondaWestmann | UnconstrainedOgden | EllipsoidalFiberDistributionDonnanEquilibrium | CellGrowth | OsmoticVirialPressure | PerfectOsmometer | ArrudaBoyceUC | EllipsoidalFiberDistributionMooneyRivlinUC | EllipsoidalFiberDistributionVerondaWestmannUC | FungOrthotropicUC | GentUC | HolmesMowUC | HolzapfelGasserOgdenUC | MooneyRivlinUC | MuscleUC | OgdenUC | TendonUC | TensionCompressionNonlinearOrthoUC | TransIsoMooneyRivlinUC | TransIsoVerondaWestmannUC | MooneyRivlinVonMisesFibersUC | LeeSacksUC | Yeoh | RigidBody | SolidMixture | SolidMixtureUC | BiphasicMaterial | ViscoelasticMaterial | ViscoelasticMaterialUC | BiphasicSoluteMaterial | MultiphasicMaterial]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class pyfebio.material.MaterialAxisVector(**data)

Bases: BaseXmlModel

a: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

d: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['vector']

class pyfebio.material.MaterialBase(**data)

Bases: BaseXmlModel

density: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

id: int | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

class pyfebio.material.MaterialBaseNoDensity(**data)

Bases: BaseXmlModel

id: int | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

class pyfebio.material.MaterialParameter(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float | int | str

type: Literal['map', 'math'] | None

class pyfebio.material.MooneyRivlinUC(**data)

Bases: MaterialBase

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['Mooney-Rivlin']

class pyfebio.material.MooneyRivlinVonMisesFibersUC(**data)

Bases: MaterialBase

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

c3: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c4: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c5: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

gipt: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_int_mult10)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

kf: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

mat_axis: MaterialAxisVector

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

tp: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

type: Literal['Mooney-Rivlin von Mises Fibers']

var_n: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

vmc: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

class pyfebio.material.MultiphasicMaterial(**data)

Bases: MaterialBaseNoDensity

add_sbm(new_sbm)

add_solute(new_solute)

fixed_charge_density: MaterialParameter | DynamicMaterialParameter

fluid_density: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

osmotic_coefficient: OsmoticCoefficientConst | OsmoticCoefficientManning

permeability: ConstantIsoPerm | ExponentialIsoPerm | HolmesMowPerm | RefIsoPerm | RefOrthoPerm | RefTransIsoPerm

phi0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

solid: ArrudaBoyce | CoupledMooneyRivlin | CoupledVerondaWestmann | CubicCLE | EllipsoidalFiberDistributionNeoHookean | FungOrthotropicCompressible | GentCompressible | HolmesMow | HolzapfelGasserOgdenUnconstrained | IsotropicElastic | IsotropicHencky | LargePoissonRatioLigament | Lung | NaturalNeoHookean | NeoHookean | PorousNeoHookean | OrthotropicElastic | OrthotropicCLE | ShenoyWang | TransIsoMooneyRivlin | TransIsoVerondaWestmann | UnconstrainedOgden | ArrudaBoyceUC | EllipsoidalFiberDistributionMooneyRivlinUC | EllipsoidalFiberDistributionVerondaWestmannUC | FungOrthotropicUC | GentUC | HolmesMowUC | HolzapfelGasserOgdenUC | MooneyRivlinUC | MuscleUC | OgdenUC | TendonUC | TensionCompressionNonlinearOrthoUC | TransIsoMooneyRivlinUC | TransIsoVerondaWestmannUC | MooneyRivlinVonMisesFibersUC | LeeSacksUC | Yeoh | SolidMixture | SolidMixtureUC

solid_bound: list[SolidBoundMolecule] | None

solute: list[Solute] | None

solvent_supply: SolventSupply | None

type: Literal['multiphasic']

class pyfebio.material.MuscleUC(**data)

Bases: MaterialBase

Lofl: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

fiber: FiberVector

g1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

g2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

lam_max: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

p1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

p2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

smax: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['muscle material']

class pyfebio.material.NaturalNeoHookean(**data)

Bases: MaterialBase

E: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['natural neo-Hookean']

v: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

class pyfebio.material.NeoHookean(**data)

Bases: MaterialBase

E: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['neo-Hookean']

v: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

class pyfebio.material.OgdenUC(**data)

Bases: MaterialBase

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

c3: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

c4: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

c5: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

c6: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

m1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

m2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

m3: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

m4: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

m5: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

m6: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['Ogden']

class pyfebio.material.OrthotropicCLE(**data)

Bases: MaterialBase

l12: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

l23: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

l31: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lm11: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lm22: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lm33: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lp11: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lp22: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lp33: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

mu1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

mu2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

mu3: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['orthotropic CLE']

class pyfebio.material.OrthotropicElastic(**data)

Bases: MaterialBase

E1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

E2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

E3: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

G12: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

G23: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

G31: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

mat_axis: MaterialAxisVector | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['orthotropic elastic']

v12: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

v23: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

v31: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

class pyfebio.material.OsmoticCoefficientConst(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

osmcoef: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['osm-coef-const']

class pyfebio.material.OsmoticCoefficientManning(**data)

Bases: BaseXmlModel

co_ion: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['osm-coef-Manning']

class pyfebio.material.OsmoticVirialPressure(**data)

Bases: MaterialBaseNoDensity

c1: MaterialParameter

c2: MaterialParameter

c3: MaterialParameter

cr: DynamicMaterialParameter

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

phiw0: MaterialParameter

type: Literal['osmotic virial expansion']

class pyfebio.material.PerfectOsmometer(**data)

Bases: MaterialBaseNoDensity

bosm: DynamicMaterialParameter

iosm: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

phiw0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['perfect osmometer']

class pyfebio.material.PorousNeoHookean(**data)

Bases: MaterialBase

E: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

phi0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['porous neo-Hookean']

class pyfebio.material.PrestrainElastic(**data)

Bases: MaterialBaseNoDensity

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

prestrain: PrestrainInSituStretch | PrestrainGradient

type: Literal['prestrain elastic']

class pyfebio.material.PrestrainElasticUC(**data)

Bases: MaterialBaseNoDensity

elastic: ArrudaBoyceUC | EllipsoidalFiberDistributionMooneyRivlinUC | EllipsoidalFiberDistributionVerondaWestmannUC | FungOrthotropicUC | GentUC | HolmesMowUC | HolzapfelGasserOgdenUC | MooneyRivlinUC | MuscleUC | OgdenUC | TendonUC | TensionCompressionNonlinearOrthoUC | TransIsoMooneyRivlinUC | TransIsoVerondaWestmannUC | MooneyRivlinVonMisesFibersUC | LeeSacksUC | Yeoh | SolidMixtureUC

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

prestrain: PrestrainInSituStretch | PrestrainGradient

type: Literal['prestrain elastic']

class pyfebio.material.PrestrainGradient(**data)

Bases: BaseXmlModel

F0: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec9)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

ramp: PrestrainRamp

type: Literal['prestrain gradient']

class pyfebio.material.PrestrainInSituStretch(**data)

Bases: BaseXmlModel

ischoric: Literal[0, 1]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

stretch: InSituStretch

type: Literal['in-situ stretch']

class pyfebio.material.PrestrainRamp(**data)

Bases: BaseXmlModel

lc: int

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float

class pyfebio.material.RefIsoPerm(**data)

Bases: BaseXmlModel

M: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

alpha: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

perm0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

perm1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

perm2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['perm-ref-iso']

class pyfebio.material.RefOrthoPerm(**data)

Bases: BaseXmlModel

M: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

M0: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

alpha: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

alpha0: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

perm0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

perm1: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

perm2: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

type: Literal['perm-ref-ortho']

class pyfebio.material.RefTransIsoPerm(**data)

Bases: BaseXmlModel

M0: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

MA: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

MT: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

alpha0: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

alphaA: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

alphaT: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

perm0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

perm1A: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

perm1T: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

perm2A: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

perm2T: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['perm-ref-trans-iso']

class pyfebio.material.RigidBody(**data)

Bases: MaterialBase

E: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

center_of_mass: \d+)([eE][+-]?\d+)?$, ascii_only=None)] | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['rigid body']

v: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

class pyfebio.material.ShenoyWang(**data)

Bases: MaterialBase

Ef: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lam_c: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lam_t: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

m: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

mu: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

n: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['Shenoy']

class pyfebio.material.SolidBoundMolecule(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rho0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

rhomax: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

rhomin: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

sbm: int

class pyfebio.material.SolidMixture(**data)

Bases: MaterialBase

add_solid(new_solid)

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['solid mixture']

class pyfebio.material.SolidMixtureUC(**data)

Bases: MaterialBase

add_solid(new_solid)

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['solid mixture']

class pyfebio.material.Solubility(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

solub: MaterialParameter

type: Literal['solub-const']

class pyfebio.material.Solute(**data)

Bases: BaseXmlModel

diffusivity: Diffusivity

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

sol: int

solubility: Solubility

class pyfebio.material.SolventSupply(**data)

Bases: BaseXmlModel

kp: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

pv: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['Starling']

class pyfebio.material.SphericalFiberDistribution(**data)

Bases: MaterialBaseNoDensity

alpha: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_gte_two_float)]

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['spherical fiber distribution']

class pyfebio.material.SphericalFiberDistributionSBM(**data)

Bases: MaterialBaseNoDensity

alpha: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_gte_two_float)]

gamma: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

ksi0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rho0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

sbm: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_int)]

type: Literal['spherical fiber distribution']

class pyfebio.material.TendonUC(**data)

Bases: MaterialBase

fiber: FiberVector

g1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

g2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

l1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

l2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lam_max: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['tendon material']

class pyfebio.material.TensionCompressionNonlinearOrthoUC(**data)

Bases: MaterialBase

beta: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

ksi: Annotated[MaterialParameter, AfterValidator(func=mat_is_string_float_vec3)]

mat_axis: MaterialAxisVector

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['TC nonlinear orthotropic']

class pyfebio.material.TransIsoMooneyRivlin(**data)

Bases: MaterialBase

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

c3: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

c4: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c5: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

fiber: FiberVector | None

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lam_max: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['coupled trans-iso Mooney-Rivlin']

class pyfebio.material.TransIsoMooneyRivlinUC(**data)

Bases: MaterialBase

active_contraction: ActiveContraction | None

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

c3: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

c4: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c5: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

fiber: FiberVector | None

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

lam_max: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['trans iso Mooney-Rivlin']

class pyfebio.material.TransIsoVerondaWestmann(**data)

Bases: MaterialBase

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

c3: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

c4: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c5: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

fiber: FiberVector | None

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

lam_max: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['coupled trans-iso Veronda-Westmann']

class pyfebio.material.TransIsoVerondaWestmannUC(**data)

Bases: MaterialBase

active_contraction: ActiveContraction | None

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

c3: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

c4: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c5: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

fiber: FiberVector | None

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

lam_max: Annotated[MaterialParameter, AfterValidator(func=mat_is_gt_one_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['trans iso Veronda-Westmann']

class pyfebio.material.TrapezoidalRuleIntegration(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

nth: Annotated[int, Gt(gt=0)]

type: Literal['fibers-2d-trapezoidal']

class pyfebio.material.UnconstrainedOgden(**data)

Bases: MaterialBase

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

c3: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

c4: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

c5: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

c6: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

m1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

m2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

m3: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

m4: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

m5: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

m6: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['Ogden unconstrained']

class pyfebio.material.VerondaWestmannUC(**data)

Bases: MaterialBase

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['Veronda-Westmann']

class pyfebio.material.ViscoelasticMaterial(**data)

Bases: MaterialBase

g0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

g1: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

g2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

g3: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

g4: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

g5: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

g6: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

t1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

t2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

t3: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

t4: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

t5: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

t6: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['viscoelastic']

class pyfebio.material.ViscoelasticMaterialUC(**data)

Bases: MaterialBase

elastic: ArrudaBoyceUC | EllipsoidalFiberDistributionMooneyRivlinUC | EllipsoidalFiberDistributionVerondaWestmannUC | FungOrthotropicUC | GentUC | HolmesMowUC | HolzapfelGasserOgdenUC | MooneyRivlinUC | MuscleUC | OgdenUC | TendonUC | TensionCompressionNonlinearOrthoUC | TransIsoMooneyRivlinUC | TransIsoVerondaWestmannUC | MooneyRivlinVonMisesFibersUC | LeeSacksUC | Yeoh | SolidMixtureUC

g0: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

g1: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

g2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

g3: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

g4: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

g5: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

g6: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)]

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

t1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

t2: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

t3: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

t4: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

t5: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

t6: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

type: Literal['uncoupled viscoelastic']

class pyfebio.material.Yeoh(**data)

Bases: MaterialBase

c1: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)]

c2: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)] | None

c3: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)] | None

c4: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)] | None

c5: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)] | None

c6: Annotated[MaterialParameter, AfterValidator(func=mat_is_non_negative_float)] | None

k: Annotated[MaterialParameter, AfterValidator(func=mat_is_positive_float)] | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['Yeoh']

pyfebio.material.mat_is_gt_one_float(parameter)

Return type:: MaterialParameter

pyfebio.material.mat_is_gte_one_float(parameter)

Return type:: MaterialParameter

pyfebio.material.mat_is_gte_two_float(parameter)

Return type:: MaterialParameter

pyfebio.material.mat_is_lte_90_gte_0(parameter)

Return type:: MaterialParameter

pyfebio.material.mat_is_lte_onethird_gte_zero(parameter)

Return type:: MaterialParameter

pyfebio.material.mat_is_non_negative_float(parameter)

Return type:: MaterialParameter

pyfebio.material.mat_is_positive_float(parameter)

Return type:: MaterialParameter

pyfebio.material.mat_is_positive_int(parameter)

Return type:: MaterialParameter

pyfebio.material.mat_is_positive_int_mult10(parameter)

Return type:: MaterialParameter

pyfebio.material.mat_is_string_float_vec3(parameter)

Return type:: MaterialParameter

pyfebio.material.mat_is_string_float_vec9(parameter)

Return type:: MaterialParameter

pyfebio.material.tension_only_nonlinear_spring(slack, e0, k)

Blankevoort 1991 ligament model

Parameters:

slack (float) – engineering strain representing amount of slack (will not produce force until slack strain is reached)
e0 (float) – engineering strain where fibers are fully straigtened (start of linear region)
k (float) – elastic modulus of linear region

Return type:

str

Returns:

A string expression of fiber force equation compatible with FEBio math interpreter

pyfebio.mesh module

class pyfebio.mesh.DiscreteElement(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.DiscreteSet(**data)

Bases: BaseXmlModel

add_element(new_element)

elements: list[DiscreteElement]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

class pyfebio.mesh.Edge(**data)

Bases: BaseXmlModel

add_line2(new_line2)

add_line3(new_line3)

all_line2: list[Line2Element]

all_line3: list[Line3Element]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

class pyfebio.mesh.ElementSet(**data)

Bases: BaseXmlModel

add_element(new_element_id)

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^(?:\d+)(?:,(?:\d+))*$, ascii_only=None)]

class pyfebio.mesh.Elements(**data)

Bases: BaseXmlModel

add_element(new_element)

all_elements: list[Tet4Element | Tet10Element | Tet15Element | Hex8Element | Hex20Element | Hex27Element | Penta6Element | Penta15Element | Pyra5Element | Tri3Element | Tri6Element | Quad4Element | Quad8Element | Quad9Element | Line2Element | Line3Element]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

type: Literal['tet4', 'tet10', 'tet15', 'hex8', 'hex20', 'hex27', 'penta6', 'penta15', 'pyra5', 'tri3', 'tri6', 'quad4', 'quad8', 'quad9', 'q4ans', 'q4eas', 'line2', 'line3']

validate_elements()

class pyfebio.mesh.Hex20Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Hex27Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Hex8Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Line2Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Line3Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Mesh(**data)

Bases: BaseXmlModel

add_discrete_set(new_discrete_set)

add_edge(new_edge)

add_element_domain(new_element_domain)

add_element_set(new_element_set)

add_node_domain(new_node_domain)

add_node_set(new_node_set)

add_surface(new_surface)

add_surface_pair(new_surface_pair)

discrete_sets: list[DiscreteSet]

edges: list[Edge]

element_sets: list[ElementSet]

elements: list[Elements]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_sets: list[NodeSet]

nodes: list[Nodes]

surface_pairs: list[SurfacePair]

surfaces: list[Surface]

class pyfebio.mesh.Node(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

class pyfebio.mesh.NodeSet(**data)

Bases: BaseXmlModel

add_node(new_node_id)

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^(?:\d+)(?:,(?:\d+))*$, ascii_only=None)]

class pyfebio.mesh.Nodes(**data)

Bases: BaseXmlModel

add_node(new_node)

all_nodes: list[Node]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

class pyfebio.mesh.Penta15Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Penta6Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+,\d+,\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Pyra5Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+,\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Quad4Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Quad8Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Quad9Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Surface(**data)

Bases: BaseXmlModel

add_quad4(new_quad)

add_quad8(new_quad)

add_quad9(new_quad)

add_tri3(new_tri)

add_tri6(new_tri)

all_quad4: list[Quad4Element]

all_quad8: list[Quad8Element]

all_quad9: list[Quad9Element]

all_tri3: list[Tri3Element]

all_tri6: list[Tri6Element]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

class pyfebio.mesh.SurfacePair(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

primary: str

secondary: str

class pyfebio.mesh.Tet10Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Tet15Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Tet4Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Tri3Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+$, ascii_only=None)]

class pyfebio.mesh.Tri6Element(**data)

Bases: BaseXmlModel

id: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^\d+,\d+,\d+,\d+,\d+,\d+$, ascii_only=None)]

pyfebio.mesh.numpy_to_elements(elements, element_type, name='Part', offset=0)

Return type:: Elements

pyfebio.mesh.numpy_to_nodes(nodes, name='Part', offset=0)

Return type:: Nodes

pyfebio.mesh.numpy_to_surface_list(facets, element_type, offset=0)

Return type:: list[Literal['tri3', 'tri6', 'quad4', 'quad8', 'quad9', 'q4ans', 'q4eas']]

pyfebio.mesh.translate_meshio(meshobj, nodeoffset=0, elementoffset=0, surfaceoffset=0, shell_sets=None, elements_name=None, nodes_name=None, node_sets_from_surfaces=False)

Return type:: Mesh

pyfebio.meshdata module

class pyfebio.meshdata.ElementData(**data)

Bases: BaseXmlModel

add_element(new_element)

all_elements: list[ElementDataElement]

data_type: Literal['scalar', 'vec3']

elem_set: str

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

class pyfebio.meshdata.ElementDataElement(**data)

Bases: BaseXmlModel

lid: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float | ~typing.Annotated[str, ~pydantic.types.StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?,[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?,[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$, ascii_only=None)]

class pyfebio.meshdata.MeshData(**data)

Bases: BaseXmlModel

add_element_data(new_element_data)

add_node_data(new_node_data)

element_data: list[ElementData]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_data: list[NodeData]

class pyfebio.meshdata.NodeData(**data)

Bases: BaseXmlModel

add_node(new_node)

all_nodes: list[NodeDataNode]

data_type: Literal['scalar', 'vec3']

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

node_set: str

class pyfebio.meshdata.NodeDataNode(**data)

Bases: BaseXmlModel

lid: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float | ~typing.Annotated[str, ~pydantic.types.StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?,[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?,[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$, ascii_only=None)]

class pyfebio.meshdata.SurfaceData(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

pyfebio.meshdomains module

class pyfebio.meshdomains.BeamDomain(**data)

Bases: BaseXmlModel

cross_sectional_area: float | None

mat: str

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

type: Literal['linear-truss', 'elastic-truss', 'linear-beam']

v: float | None

validate_material()

class pyfebio.meshdomains.MeshDomains(**data)

Bases: BaseXmlModel

add_beam_domain(new_beam_domain)

add_shell_domain(new_shell_domain)

add_solid_domain(new_solid_domain)

beam_domains: list[BeamDomain]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

shell_domains: list[ShellDomain]

solid_domains: list[SolidDomain]

class pyfebio.meshdomains.ShellDomain(**data)

Bases: BaseXmlModel

mat: str

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

shell_thickness: float

type: Literal['elastic-shell', 'three-field-shell', 'rigid-shell', 'elastic-shell-old', 'elastic-shell-eas', 'elastic-shell-ans'] | None

class pyfebio.meshdomains.SolidDomain(**data)

Bases: BaseXmlModel

alpha: float | None

elem_type: Literal['HEX8G6', 'HEX8G8', 'HEX20G8', 'TET4G1', 'TET4G4', 'TET10G4', 'TET10G8', 'TET10GL11', 'TET15G8', 'TET15G11', 'TET15G15', 'PENTA15G8'] | None

iso_stab: Literal[0, 1] | None

mat: str

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

type: Literal['elastic-solid', 'three-field-solid', 'rigid-solid', 'udg-hex', 'sri-solid', 'remodelling-solid', 'ut4-solid'] | None

pyfebio.model module

class pyfebio.model.BiphasicModel(**data)

Bases: Model

control_: Control | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

module_: Module | None

class pyfebio.model.FEBioRoot(**data)

Bases: BaseXmlModel

add_section(section)

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

save(filename)

sections: list[Module | Globals | Control | Material | RigidBody | MeshDomains | Mesh | MeshData | Discrete | LoadData | Loads | Rigid | Initial | Boundary | Contact | Constraints | Step | Output | Include]

version: str

class pyfebio.model.Model(**data)

Bases: BaseXmlModel

add_simple_rigid_body(origin, name)

boundary_: Boundary

constraints_: Constraints

contact_: Contact

control_: Control | None

discrete_: Discrete

globals_: Globals

initial_: Initial

loaddata_: LoadData

loads_: Loads

material_: Material

mesh_: Mesh

meshadaptor_: MeshAdaptor

meshdata_: MeshData

meshdomains_: MeshDomains

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

module_: Module | None

output_: Output

rigid_: Rigid

save(filename)

step_: Step

version: str

class pyfebio.model.MultiphasicModel(**data)

Bases: Model

control_: Control | None

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

module_: Module | None

pyfebio.model.run_model(filepath, silent=False)

Return type:: int

pyfebio.module module

class pyfebio.module.Module(**data)

Bases: BaseXmlModel

FEBio module – currently, only supporting “solid” and “biphasic”.

Unsupported modules: “solute”, “heat”, “fluid”, “fluid-FSI”

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['solid', 'biphasic', 'multiphasic']

pyfebio.output module

class pyfebio.output.DataEntry(**data)

Bases: BaseXmlModel

data: str

delim: str

file: str | None

format: str | None

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: str | None

class pyfebio.output.ElementDataEnum(*values)

Bases: str, Enum

devaiatoric_strain_energy_density = 'devsed'

fluid_pressure = 'p'

p1_strain = 'E1'

p1_stress = 's1'

p2_strain = 'E2'

p2_stress = 's2'

p3_strain = 'E3'

p3_stress = 's3'

strain_energy_density = 'sed'

x_coordinate = 'x'

x_flux = 'wx'

x_strain = 'Ex'

x_stress = 'sx'

xy_strain = 'Exy'

xy_stress = 'sxy'

xz_strain = 'Exz'

xz_stress = 'sxz'

y_coordinate = 'y'

y_flux = 'wy'

y_strain = 'Ey'

y_stress = 'sy'

yz_strain = 'Eyz'

yz_stress = 'syz'

z_coordinate = 'z'

z_flux = 'wz'

z_strain = 'Ez'

z_stress = 'sz'

class pyfebio.output.NodeDataEnum(*values)

Bases: str, Enum

fluid_pressure = 'p'

x_acceleration = 'ax'

x_coordinate = 'x'

x_displacement = 'ux'

x_reaction_force = 'Rx'

x_velocity = 'vx'

y_acceleration = 'ay'

y_coordinate = 'y'

y_displacement = 'uy'

y_reaction_force = 'Ry'

y_velocity = 'vy'

z_acceleration = 'az'

z_coordinate = 'z'

z_displacement = 'uz'

z_reaction_force = 'Rz'

z_velocity = 'vz'

class pyfebio.output.Output(**data)

Bases: BaseXmlModel

add_logfile(new_logfile)

add_plotfile(new_plotfile)

logfile: list[OutputLogfile]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

plotfile: list[OutputPlotfile]

class pyfebio.output.OutputLogfile(**data)

Bases: BaseXmlModel

add_element_data(new_output)

add_face_data(new_output)

add_node_data(new_output)

add_rigid_body_data(new_output)

add_rigid_connector_data(new_output)

element_data: list[DataEntry]

face_data: list[DataEntry]

file: str | None

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

node_data: list[DataEntry]

rigid_body_data: list[DataEntry]

rigid_connector_data: list[DataEntry]

class pyfebio.output.OutputPlotfile(**data)

Bases: BaseXmlModel

add_var(new_var)

all_vars: list[Var]

file: str | None

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['febio', 'vtk']

class pyfebio.output.RigidBodyDataEnum(*values)

Bases: str, Enum

x_acceleration = 'ax'

x_angular_acceleration = 'alx'

x_angular_velocity = 'omx'

x_coordinate = 'x'

x_euler = 'XEuler'

x_force = 'Fx'

x_moment = 'Mx'

x_rotation = 'thx'

x_velocity = 'vx'

y_acceleration = 'ay'

y_angular_acceleration = 'aly'

y_angular_velocity = 'omy'

y_coordinate = 'y'

y_euler = 'YEuler'

y_force = 'Fy'

y_moment = 'My'

y_rotation = 'thy'

y_velocity = 'vy'

z_acceleration = 'az'

z_angular_acceleration = 'alz'

z_angular_velocity = 'omz'

z_coordinate = 'z'

z_euler = 'ZEuler'

z_force = 'Fz'

z_moment = 'Mz'

z_rotation = 'thz'

z_velocity = 'vz'

class pyfebio.output.RigidConnectorDataEnum(*values)

Bases: str, Enum

x_force = 'RCFx'

x_moment = 'RCMx'

x_rotation = 'RCthx'

x_translation = 'RCx'

y_force = 'RCFy'

y_moment = 'RCMy'

y_rotation = 'RCthy'

y_translation = 'RCy'

z_force = 'RCFz'

z_moment = 'RCMz'

z_rotation = 'RCthz'

z_translation = 'RCz'

class pyfebio.output.Var(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

type: Literal['acceleration', 'Almansi strain', 'beam curvature', 'beam reference stress', 'beam reference stress couple', 'beam strain', 'beam stress', 'beam stress couple', 'body force', 'concentration gap', 'contact area', 'contact force', 'contact gap', 'contact penalty', 'contact pressure', 'contact status', 'contact stick', 'contact traction', 'continuous damage', 'continuous damage beta', 'continuous damage D1', 'continuous damage D2', 'continuous damage D2beta', 'continuous damage D3', 'continuous damage Ds', 'continuous damage gamma', 'continuous damage P', 'continuous damage Psi0', 'current density', 'current element angular momentum', 'current element center of mass', 'current element kinetic energy', 'current element linear momentum', 'current element strain energy', 'damage', 'deformation gradient', 'density', 'Deshpande-Fleck stress', 'deviatoric elasticity', 'deviatoric fiber stretch', 'deviatoric strain energy density', 'deviatoric strong bond SED', 'deviatoric weak bond SED', 'dilatation gradient', 'discrte element direction', 'discrete element elongation', 'discrete element force', 'discrete element length', 'discrete element percent elongation', 'discrete element signed force', 'discrete element strain energy', 'discrete element stretch', 'displacement', 'Drucker shear stress', 'Drucker-Prager stress', 'edge contact gap', 'effective elasticity', 'effective fluid pressure', 'effective friction coefficient', 'effective shell fluid pressure', 'effective shell solute concentration', 'effective solute concentration', 'elastic fluid pressure', 'elasticity', 'electric potential', 'element angular momentum', 'element center of mass', 'element kinetic energy', 'element linear momentum', 'element strain energy', 'element stress power', 'enclosed volume', 'enclosed volume change', 'Euler angle', 'facet area', 'fatigue bone fraction', 'fiber stretch', 'fiber vector', 'field', 'fixed charge density', 'fluid acceleration', 'fluid body force', 'fluid bulk modulus', 'fluid density', 'fluid density rate', 'fluid dilatation', 'fluid element angular momentum', 'fluid element center of mass', 'fluid element kinetic energy', 'fluid element linear momentum', 'fluid element strain energy', 'fluid energy density', 'fluid flow rate', 'fluid flux', 'fluid force', 'fluid force2', 'fluid heat supply density', 'fluid kinetic energy density', 'fluid load support', 'fluid mass flow rate', 'fluid pressure', 'fluid pressure tangent strain', 'fluid rate of deformation', 'fluid relative Reynolds number', 'fluid shear stress error', 'fluid shear viscosity', 'fluid specific entropy', 'fluid specific free energy', 'fluid specific free enthalpy', 'fluid specific gauge enthalpy', 'fluid specific internal energy', 'fluid specific strain energy', 'fluid strain energy density', 'fluid stress', 'fluid stress power density', 'fluid surface energy flux', 'fluid surface force', 'fluid surface pressure', 'fluid surface traction power', 'fluid velocity', 'fluid volume ratio', 'fluid volume ratio gradient', 'fluid vorticity', 'growth infinitesimal strain', 'growth Lagrange strain', 'growth left Hencky', 'growth left stretch', 'growth relative volume', 'growth right Hencky', 'growth right stretch', 'ideal gas pressure', 'incremental displacement', 'infinitesimal strain', 'in-situ target stretch', 'intact bond fraction', 'kinetic energy density', 'Lagrange strain', 'left Cauchy-Green', 'left Hencky', 'left stretch', 'local fluid load support', 'material axes', 'mesh_data', 'micro energy', 'mixture deviatoric strain energy density', 'mixture specific strain energy', 'mixture strain energy density', 'mixture stress', 'nodal acceleration', 'nodal contact gap', 'nodal contact pressure', 'nodal contact traction', 'nodal fluid flux', 'nodal fluid velocity', 'nodal shell director', 'nodal strain', 'nodal stress', 'nodal surface traction', 'nodal vector gap', 'nodal veleocity', 'octahedral plastic strain', 'osmolarity', 'osmotic coefficient', 'parameter', 'partition coefficient', 'permeability', 'pid controller', 'PK1 norm', 'PK1 stress', 'PK2 stress', 'plastic yield stress', 'plasticity heat supply density', 'porosity', 'pressure gap', 'prestrain compatibility', 'prestrain correction', 'prestrain stretch', 'prestrain stretch error', 'rate of deformation', 'reaction forces', 'receptor-ligand', 'referential fixed charge density', 'referential solid volume fraction', 'relative fluid velocity', 'relative volume', 'right Cauchy-Green', 'right Hencky', 'right stretch', 'rigid acceleration', 'rigid angular momentum', 'rigid angular position', 'rigid angular velocity', 'rigid force', 'rigid kinetic energy', 'rigid linear momentum', 'rigid position', 'rigid rotation vector', 'rigid torque', 'rigid velocity', 'rotation', 'RVE generations', 'RVE recruitment', 'RVE strain', 's norm', 'sbm areal concentration', 'sbm concentration', 'sbm referential apparent density', 'scalar surface load', 'shell bottom nodal strain', 'shell bottom nodal stress', 'shell bottom strain', 'shell bottom stress', 'shell director', 'shell displacement', 'shell relative volume', 'shell strain', 'shell thickness', 'shell top nodal strain', 'shell top nodal stress', 'shell top strain', 'shell top stress', 'solid stress', 'solid volume fraction', 'solute concentration', 'solute flux', 'solute relative Peclet number', 'solute volumetric flux', 'specific strain energy', 'SPR infinitesimal strain', 'SPR Lagrange strain', 'SPR prestrain correction', 'SPR principal stress', 'SPR relative volume', 'SPR stress', 'SPR-P1 stress', 'strain energy density', 'stress', 'stress error', 'strong bond SED', 'surface area', 'surface reaction force', 'surface reaction moment', 'surface traction', 'total angular momentum', 'total energy', 'total linear momentum', 'truss stretch', 'uncoupled pressure', 'ut4 nodal stress', 'vector gap', 'velocity', 'volume fraction', 'weak bond SED', 'yielded bond fraction']

pyfebio.output.assemble_data_string(requests)

Return type:: str

pyfebio.rigid module

class pyfebio.rigid.Free(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: Literal[0]

class pyfebio.rigid.Rigid(**data)

Bases: BaseXmlModel

add_rigid_bc(new_rigid_bc)

add_rigid_connector(new_rigid_connector)

add_rigid_initial_condition(new_rigid_initial_condition)

add_rigid_load(new_rigid_load)

all_rigid_bcs: list[RigidFixed | RigidPrescribed | RigidBodyRotationVector | RigidBodyEulerAngle]

all_rigid_connectors: list[RigidSphericalJoint | RigidRevoluteJoint | RigidCylindricalJoint | RigidPrismaticJoint | RigidPlanarJoint | RigidLock | RigidSpring | RigidDamper | RigidAngularDamper | RigidContractileForce]

all_rigid_initial_conditions: list[RigidInitialVelocity | RigidInitialAngularVelocity]

all_rigid_loads: list[RigidForceLoad | RigidFollowerForceLoad | RigidMomentLoad | RigidFollowerMomentLoad | RigidCableLoad]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class pyfebio.rigid.RigidAngularDamper(**data)

Bases: BaseXmlModel

body_a: str

body_b: str

c: float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

type: Literal['rigid angular damper']

class pyfebio.rigid.RigidBodyEulerAngle(**data)

Bases: BaseXmlModel

Ex: X

Ey: Y

Ez: Z

class X(**data)

Bases: BaseXmlModel

lc: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float

class Y(**data)

Bases: BaseXmlModel

lc: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float

class Z(**data)

Bases: BaseXmlModel

lc: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rb: str

type: Literal['rigid_euler_angles']

class pyfebio.rigid.RigidBodyRotationVector(**data)

Bases: BaseXmlModel

class X(**data)

Bases: BaseXmlModel

lc: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float

class Y(**data)

Bases: BaseXmlModel

lc: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float

class Z(**data)

Bases: BaseXmlModel

lc: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rb: str

type: Literal['rigid_rotation_vector']

vx: X

vy: Y

vz: Z

class pyfebio.rigid.RigidCableLoad(**data)

Bases: BaseXmlModel

class CablePoint(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

position: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

rigid_body_id: str

force: Value

force_direction: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

relative: Literal[0, 1]

rigid_cable_point: list[CablePoint]

type: Literal['rigid_cable']

class pyfebio.rigid.RigidConnector(**data)

Bases: BaseXmlModel

angtol: Literal[0] | float

auto_penalty: Literal[0, 1]

body_a: str

body_b: str

force_penalty: float

gaptol: Literal[0] | float

maxaug: int

minaug: int

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

moment_penalty: float

name: str

tolerance: float

class pyfebio.rigid.RigidContractileForce(**data)

Bases: BaseXmlModel

body_a: str

body_b: str

f0: Value

insertion_a: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

insertion_b: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

type: Literal['rigid contractile force']

class pyfebio.rigid.RigidCylindricalJoint(**data)

Bases: RigidConnector

force: Value | Free

joint_axis: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

joint_origin: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

laugon: Literal['PENALTY', 'AUGLAG', 'LAGMULT']

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

moment: Value | Free

prescribed_rotation: Literal[0, 1]

prescribed_translation: Literal[0, 1]

rotation: Value | Free

translation: Value | Free

transverse_axis: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

type: Literal['rigid cylindrical joint']

class pyfebio.rigid.RigidDamper(**data)

Bases: BaseXmlModel

body_a: str

body_b: str

c: float

insertion_a: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

insertion_b: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

type: Literal['rigid damper']

class pyfebio.rigid.RigidFixed(**data)

Bases: BaseXmlModel

Ru_dof: Literal[0, 1]

Rv_dof: Literal[0, 1]

Rw_dof: Literal[0, 1]

Rx_dof: Literal[0, 1]

Ry_dof: Literal[0, 1]

Rz_dof: Literal[0, 1]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rb: str

type: Literal['rigid_fixed']

class pyfebio.rigid.RigidFollowerForceLoad(**data)

Bases: BaseXmlModel

force: Value

insertion: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rb: str

relative: Literal[0, 1]

type: Literal['rigid_follower_force']

class pyfebio.rigid.RigidFollowerMomentLoad(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

moment: Value

rb: str

type: Literal['rigid_follower_moment']

class pyfebio.rigid.RigidForceLoad(**data)

Bases: BaseXmlModel

dof: Literal['Rx', 'Ry', 'Rz']

load_type: Literal[0, 1, 2]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rb: str

relative: Literal[0, 1]

type: Literal['rigid_force']

value: Value

class pyfebio.rigid.RigidInitialAngularVelocity(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rb: str

type: Literal['initial_rigid_angular_velocity']

value: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

class pyfebio.rigid.RigidInitialVelocity(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rb: str

type: Literal['initial_rigid_velocity']

value: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

class pyfebio.rigid.RigidLock(**data)

Bases: RigidConnector

first_axis: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

joint_origin: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

second_axis: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

type: Literal['rigid lock']

class pyfebio.rigid.RigidMomentLoad(**data)

Bases: BaseXmlModel

dof: Literal['Ru', 'Rv', 'Rw']

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rb: str

relative: Literal[0, 1]

type: Literal['rigid_moment']

value: Value

class pyfebio.rigid.RigidPlanarJoint(**data)

Bases: RigidConnector

joint_origin: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

prescribed_rotation: Literal[0, 1]

prescribed_translation_1: Literal[0, 1]

prescribed_translation_2: Literal[0, 1]

rotation: Value | Free

rotation_axis: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

translation_1: Value | Free

translation_2: Value | Free

translation_axis_1: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

type: Literal['rigid planar joint']

class pyfebio.rigid.RigidPrescribed(**data)

Bases: BaseXmlModel

dof: Literal['x', 'y', 'z', 'Ru', 'Rv', 'Rw']

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

rb: str

relative: Literal[0, 1]

type: Literal['rigid_displacement', 'rigid_rotation']

validate_type()

value: Value

class pyfebio.rigid.RigidPrismaticJoint(**data)

Bases: RigidConnector

force: Value | Free

joint_origin: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

prescribed_translation: Literal[0, 1]

translation: Value | Free

translation_axis: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

transverse_axis: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

type: Literal['rigid prismatic joint']

class pyfebio.rigid.RigidRevoluteJoint(**data)

Bases: RigidConnector

class Free(**data)

Bases: BaseXmlModel

model_config: ClassVar[ConfigDict] = {}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: Literal[0]

joint_origin: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

laugon: Literal[0, 1]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

moment: Value | Free

prescribed_rotation: Literal[0, 1]

rotation: Value | Free

rotation_axis: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

transverse_axis: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

type: Literal['rigid revolute joint']

class pyfebio.rigid.RigidSphericalJoint(**data)

Bases: RigidConnector

joint_origin: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

moment_x: Value | Free

moment_y: Value | Free

moment_z: Value | Free

prescribed_rotation: Literal[0, 1]

rotation_x: Value | Free

rotation_y: Value | Free

rotation_z: Value | Free

type: Literal['rigid spherical joint']

class pyfebio.rigid.RigidSpring(**data)

Bases: BaseXmlModel

body_a: str

body_b: str

free_length: Literal[0] | float

insertion_a: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

insertion_b: \d+)([eE][+-]?\d+)?$, ascii_only=None)]

k: float

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

type: Literal['rigid spring']

class pyfebio.rigid.Value(**data)

Bases: BaseXmlModel

lc: int | None

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

text: float | ~typing.Annotated[str, ~pydantic.types.StringConstraints(strip_whitespace=True, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern=^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?,[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?,[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$, ascii_only=None)]

pyfebio.step module

class pyfebio.step.Step(**data)

Bases: BaseXmlModel

add_step(new_step)

all_steps: list[StepEntry]

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class pyfebio.step.StepEntry(**data)

Bases: BaseXmlModel

boundary: Boundary | None

constraints: Constraints | None

contact: Contact | None

control: Control | None

id: int

initial: Initial | None

loads: Loads | None

model_config: ClassVar[ConfigDict] = {'validate_assignment': True}: Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str

rigid: Rigid | None

pyfebio.xplt module

This module converts XPLT files to HDF5. It can be run from the command line with:

python -m pyfebio.xplt [path/to/xplt_file] Optional[path/to/hdf5_output]

If the output path is not provided it will be set to [path/to/xplt_file] with the extension changed to .hdf5

To use in a script:

from pyfebio import xplt

xplt.to_hdf5("/path/to/xplt_file", "/path/to/hdf5_output")

Note that the xplt module is not imported by default with the pyfebio package, but must be imported explicitly as above.

We reference:: https://github.com/febiosoftware/FEBioStudio/blob/master/XPLTLib/xpltReader3.h commit: 7c7f171
as:: xpltReader3.h:LINE_NUMBER

class pyfebio.xplt.DicItem(*args, **kwargs)

Bases: object

array_size: int

iformat: int

itype: int

name: str

units: str | None = None

class pyfebio.xplt.Xtag(*args, **kwargs)

Bases: object

format: Literal['float32', 'uint32', 'int32', 'szname', 'node'] = 'int32'

name: str

pyname: str

pyfebio.xplt.check_file_is_febio(buffer)

pyfebio.xplt.dtypes_to_little_endian(_DTYPES)

Uncommon these days, but if your XPLT file was created on a big-_ENDIAN machine, this will do a byte swap to little-_ENDIAN for all _DTYPES

Note: szname being a byte string type will be unchanged

pyfebio.xplt.parse_blocks(buffer, f)

pyfebio.xplt.parse_dictionary(buffer)

Return type:: dict[str, list[DicItem]]

pyfebio.xplt.parse_elementset_section(buffer)

pyfebio.xplt.parse_mesh(buffer, mesh_cnt, f)

pyfebio.xplt.parse_nodeset_section(buffer)

pyfebio.xplt.parse_objects_section(buffer)

pyfebio.xplt.parse_parts_section(buffer)

pyfebio.xplt.parse_prefix(buffer)

Return type:: tuple[int, int]

pyfebio.xplt.parse_root_header(buffer, f)

pyfebio.xplt.parse_state(buffer, state_cnt, xdictionary, mesh_dict, f)

pyfebio.xplt.to_hdf5(inputfile, outputfile=None)

pyfebio package

Submodules

pyfebio.boundary module

pyfebio.constraints module

pyfebio.contact module

pyfebio.control module

pyfebio.discrete module

pyfebio.globals module

pyfebio.include module

pyfebio.initial module

pyfebio.loaddata module

pyfebio.loads module

pyfebio.material module

pyfebio.mesh module

pyfebio.meshdata module

pyfebio.meshdomains module

pyfebio.model module

pyfebio.module module

pyfebio.output module

pyfebio.rigid module

pyfebio.step module

pyfebio.xplt module

Module contents