pyfebiopt.optimize.engine

Unified optimization engine for FEBio parameter fitting.

Attributes

Array

Classes

`OptimizeResult`	Final state of an optimization run.
`IterationState`	Track iteration bookkeeping and cached evaluations.
`JacobianHelper`	Handle Jacobian scheduling/finalisation to keep Engine slim.
`Engine`	Coordinate FEBio simulations and optimization loops.

Module Contents

pyfebiopt.optimize.engine.Array

class pyfebiopt.optimize.engine.OptimizeResult

Final state of an optimization run.

phi: Array

theta: dict[str, float]

metadata: dict[str, Any]

class pyfebiopt.optimize.engine.IterationState

Track iteration bookkeeping and cached evaluations.

progress_index: int = 0

pending_initial_log: bool = True

log_progress: bool = True

last_phi: Array | None = None

last_theta_vec: Array | None = None

last_residual: Array | None = None

last_iter_dir: pathlib.Path | None = None

last_cost: float | None = None

last_metrics: dict[str, Any]

series_latest: dict[str, dict[str, Any]]

cached_jac_phi: Array | None = None

cached_jacobian: Array | None = None

reset(*, log_progress: bool) → None: Clear state between optimization runs.

cache_evaluation(phi_vec: Array, theta_vec: Array, residual: Array, iter_dir: pathlib.Path, metrics: collections.abc.Mapping[str, Any], series: collections.abc.Mapping[str, dict[str, Any]]) → None: Persist the latest evaluation payload.

next_index() → int: Return and increment the iteration index.

cache_jacobian(phi_vec: Array, J: Array) → None: Store a Jacobian associated with a specific phi vector.

cached_jac(phi_vec: Array) → Array | None: Return a cached Jacobian matching phi_vec if available.

class pyfebiopt.optimize.engine.JacobianHelper(jacobian: pyfebiopt.optimize.jacobian.JacobianComputer, case_evaluator: pyfebiopt.optimize.cases.CaseEvaluator, mapper: pyfebiopt.optimize.parameters.ParameterMapper, workspace: pyfebiopt.optimize.storage.StorageWorkspace, param_names: collections.abc.Sequence[str])

Handle Jacobian scheduling/finalisation to keep Engine slim.

Coordinate Jacobian evaluations, optionally in parallel.

jacobian

case_evaluator

mapper

workspace

param_names

compute(phi_vec: Array, state: IterationState) → Array: Return a forward-difference Jacobian for phi_vec.

class pyfebiopt.optimize.engine.Engine(parameter_space: pyfebiopt.optimize.parameters.ParameterSpace, cases: collections.abc.Sequence[pyfebiopt.optimize.cases.SimulationCase], *, options: pyfebiopt.optimize.options.EngineOptions | None = None)

Coordinate FEBio simulations and optimization loops.

Initialize the engine, wiring runner, reporter, mapper, and helpers.

parameter_space

workspace

workdir = None

persist_root

jacobian: pyfebiopt.optimize.jacobian.JacobianComputer | None

case_evaluator

artifact_exporter

interrupts

parameter_mapper

optimizer_adapter

reporter: pyfebiopt.optimize.reporting.Reporter

state

jac_helper

run(*, phi0: collections.abc.Sequence[float] | None = None, bounds: collections.abc.Sequence[tuple[float, float]] | None = None, verbose: bool = True, callbacks: collections.abc.Iterable[collections.abc.Callable[[Array, float], None]] | None = None) → OptimizeResult

Execute the optimization loop and return the optimizer’s final solution.

Returns:: OptimizeResult with optimal φ/θ and optimizer metadata.

close() → None: Cleanly stop the runner.