pyfebio package

Submodules

pyfebio.boundary module

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.BCPrescribedDeformation(**data)

Bases: BaseXmlModel

F: \d+)([eE][+-]?\d+)?$)]

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].

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+)?$)]

relative: Literal[0, 1]

rot: Value

type: Literal['rigid deformation']

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]

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

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+)?$)]

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.

diverge_reform: Literal[0, 1]

dtol: float

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

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

etol: float

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']

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]

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.NonlinearSpring(**data)

Bases: BaseXmlModel

force: NonlinearSpringForce

id: int

measure: Literal['strain']

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: str

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.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

pyfebio.globals module

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

Bases: BaseXmlModel

Fc: float

P: float

R: float

T: float

model_config: ClassVar[ConfigDict] = {'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].

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]

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

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+)?$)]

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+)?$)]]

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+)?$)]

rotation_center: \d+)([eE][+-]?\d+)?$)]

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+)?$)]

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+)?$)]

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+)?$)]

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

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.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.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+)?$)]

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]

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+)?$)]

d: \d+)([eE][+-]?\d+)?$)]

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.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.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+)?$)] | 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)]

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

sbm: int

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

Bases: MaterialBaseNoDensity

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: MaterialBaseNoDensity

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.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: MaterialBaseNoDensity

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: MaterialBaseNoDensity

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+$)]

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+))*$)]

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+$)]

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+$)]

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+$)]

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+$)]

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+$)]

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+)?$)]

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+))*$)]

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+$)]

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+$)]

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+$)]

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+$)]

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+$)]

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+$)]

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+$)]

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+$)]

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+$)]

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+$)]

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+$)]

pyfebio.mesh.translate_meshio(meshobj, nodeoffset=0, elementoffset=0, surfaceoffset=0, shell_sets=None)

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+)?$)]

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+)?$)]

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

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”, “multiphasic”, “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']

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', 'contact area', 'contact force', 'contact gap', 'contact penalty', 'contact pressure', 'contact traction', 'current density', 'current element angular momentum', 'current element center of mass', 'current element kinetic energy', 'current element linear momentum', 'current element strain energy', 'deformation gradient', 'damage', 'density', 'deviatoric strain energy density', 'displacement', 'effective elasticity', 'effective fluid pressure', 'effective friction coefficient', 'effective solute concentration', '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', 'fiber stretch', 'fiber vector', 'field', 'fixed charge density', 'fluid acceleration', 'fluid density', '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 rate of deformation', 'fluid shear viscosity', '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 vorticity', 'heat flux', 'kinetic energy density', 'Lagrange strain', 'left Hencky', 'left stretch', 'local fluid load support', 'nested damage', 'nodal acceleration', 'nodal contact gap', 'nodal contact pressure', 'nodal contact traction', 'nodal fluid flux', 'nodal fluid velocity', 'nodal stress', 'nodal surface traction', 'nodal vector gap', 'nodal velocity', 'osmolarity', 'parameter', 'pressure gap', 'reaction forces', 'receptor-ligand concentration', 'referential fixed charge density', 'referential solid volume fraction', 'relative fluid velocity', 'relative volume', 'right Hencky', 'right stretch', 'rigid acceleration', 'rigid angular 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', 'RVE generations', 'RVE reforming bonds', 'RVE strain', 'sbm concentration', 'sbm referential apparent density', 'shell director', 'shell relative volume', 'shell strain', 'shell thickness', 'solute concentration', 'solute flux', 'specific strain energy', 'SPR principal stress', 'SPR stress', 'SPR-P1 stress', 'strain energy density', 'stress', 'stress error', 'surface traction', 'uncoupled pressure', 'ut4 nodal stress', 'vector gap', 'velocity', 'volume fraction', 'in-situ target stretch', 'prestrain stretch', 'prestrain correction', 'SPR prestrain correction']

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+)?$)]

rigid_body_id: str

force: Value

force_direction: \d+)([eE][+-]?\d+)?$)]

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+)?$)]

insertion_b: \d+)([eE][+-]?\d+)?$)]

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+)?$)]

joint_origin: \d+)([eE][+-]?\d+)?$)]

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+)?$)]

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+)?$)]

insertion_b: \d+)([eE][+-]?\d+)?$)]

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: \d+)([eE][+-]?\d+)?$)]

insertion: \d+)([eE][+-]?\d+)?$)]

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: \d+)([eE][+-]?\d+)?$)]

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+)?$)]

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+)?$)]

class pyfebio.rigid.RigidLock(**data)

Bases: RigidConnector

first_axis: \d+)([eE][+-]?\d+)?$)]

joint_origin: \d+)([eE][+-]?\d+)?$)]

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+)?$)]

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+)?$)]

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+)?$)]

translation_1: Value | Free

translation_2: Value | Free

translation_axis_1: \d+)([eE][+-]?\d+)?$)]

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+)?$)]

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+)?$)]

transverse_axis: \d+)([eE][+-]?\d+)?$)]

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+)?$)]

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+)?$)]

transverse_axis: \d+)([eE][+-]?\d+)?$)]

type: Literal['rigid revolute joint']

class pyfebio.rigid.RigidSphericalJoint(**data)

Bases: RigidConnector

joint_origin: \d+)([eE][+-]?\d+)?$)]

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+)?$)]

insertion_b: \d+)([eE][+-]?\d+)?$)]

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

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:

..code-block:: bash

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:

..code-block:: python

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