API Reference

OpenRadioss vendor plugin surface for femorph model.

class femorph_vendor_openradioss.ArtifactIssue(path: str, message: str)

One native artifact contract violation.

message: str
path: str
class femorph_vendor_openradioss.OpenRadiossBlock(header: str, tokens: tuple[str, ...], line_no: int, data: tuple[tuple[int, str], ...] = ())

One OpenRadioss slash-header block with source provenance.

data: tuple[tuple[int, str], ...] = ()
property family: str
header: str
line_no: int
property name: str
property raw_text: str
tokens: tuple[str, ...]
class femorph_vendor_openradioss.OpenRadiossCorpusCoverageReport(fixture_count: int, level_counts: dict[str, int], api_spec_count: int, covered_api_spec_count: int, runtime_surface_count: int, covered_runtime_surface_count: int, runtime_category_count: int, runtime_fixture_count: int, public_vm_count: int, first_wave_public_vm_count: int, coverage_percent: float, api_action_counts: dict[str, int], runtime_action_counts: dict[str, int], missing_api_spec_ids: tuple[str, ...], missing_runtime_surface_ids: tuple[str, ...])

Coverage summary for the full OpenRadioss clean-room corpus.

api_action_counts: dict[str, int]
api_spec_count: int
coverage_percent: float
covered_api_spec_count: int
covered_runtime_surface_count: int
first_wave_public_vm_count: int
fixture_count: int
level_counts: dict[str, int]
missing_api_spec_ids: tuple[str, ...]
missing_runtime_surface_ids: tuple[str, ...]
public_vm_count: int
runtime_action_counts: dict[str, int]
runtime_category_count: int
runtime_fixture_count: int
runtime_surface_count: int
class femorph_vendor_openradioss.OpenRadiossDynamicParityFixture(path: str, name: str, tier: str, starter_deck: str, engine_deck: str, reference_results: str, candidate_results: str, comparison_report: str, frame_count: int, time: tuple[float, ...], cycle: tuple[int, ...], node_count: int, element_count: int, comparable_fields: tuple[str, ...], commands: tuple[OpenRadiossRunCommand, ...])

Fixture-level contract for OpenRadioss dynamic result parity.

candidate_results: str
commands: tuple[OpenRadiossRunCommand, ...]
comparable_fields: tuple[str, ...]
comparison_report: str
cycle: tuple[int, ...]
element_count: int
engine_deck: str
frame_count: int
name: str
node_count: int
path: str
reference_results: str
starter_deck: str
tier: str
time: tuple[float, ...]
class femorph_vendor_openradioss.OpenRadiossNativePost(arrays: dict[str, ~numpy.ndarray], metadata: dict[str, ~typing.Any] = <factory>)

Loaded OpenRadioss post-processing arrays and metadata.

arrays: dict[str, ndarray]
property max_displacement: ndarray
metadata: dict[str, Any]
property reaction_sum: ndarray
class femorph_vendor_openradioss.OpenRadiossNativeResults(arrays: dict[str, ~numpy.ndarray], metadata: dict[str, ~typing.Any] = <factory>)

Loaded OpenRadioss result arrays and metadata.

arrays: dict[str, ndarray]
property cycle: ndarray
property elem_ids: ndarray
metadata: dict[str, Any]
property node_ids: ndarray
property time: ndarray
class femorph_vendor_openradioss.OpenRadiossPostPvSummary(path: str, point_data_arrays: tuple[str, ...], row_count: int, uses_field_data: bool)

Schema summary for a native OpenRadioss PyVista post table.

path: str
point_data_arrays: tuple[str, ...]
row_count: int
uses_field_data: bool
class femorph_vendor_openradioss.OpenRadiossRawOutput(path: str, role: str, native_artifacts: tuple[str, ...])

One raw OpenRadioss output file and its native Model artifact targets.

native_artifacts: tuple[str, ...]
path: str
role: str
exception femorph_vendor_openradioss.OpenRadiossReplayError(message: str, *, line_no: int | None = None)

Raised when an OpenRadioss deck line cannot be replayed.

class femorph_vendor_openradioss.OpenRadiossResultsPvSummary(path: str, block_names: tuple[str, ...], frame_names: tuple[str, ...], point_data_arrays: tuple[str, ...], cell_data_arrays: tuple[str, ...], time_history_arrays: tuple[str, ...], post_arrays: tuple[str, ...], frame_count: int, has_animation: bool, has_time_history: bool, has_native_results: bool, has_post: bool, uses_field_data: bool)

Schema summary for a native OpenRadioss PyVista result container.

block_names: tuple[str, ...]
cell_data_arrays: tuple[str, ...]
frame_count: int
frame_names: tuple[str, ...]
has_animation: bool
has_native_results: bool
has_post: bool
has_time_history: bool
path: str
point_data_arrays: tuple[str, ...]
post_arrays: tuple[str, ...]
time_history_arrays: tuple[str, ...]
uses_field_data: bool
class femorph_vendor_openradioss.OpenRadiossRunCommand(argv: tuple[str, ...], env: dict[str, str])

Host command and environment for one OpenRadioss deck run.

argv: tuple[str, ...]
env: dict[str, str]
class femorph_vendor_openradioss.OpenRadiossRuntimeSurfaceReport(row_count: int, covered_row_count: int, category_count: int, fixture_count: int, action_counts: dict[str, int], status_counts: dict[str, int], level_counts: dict[str, int], row_fixture: dict[str, str], category_fixture: dict[str, str])

Coverage summary for the OpenRadioss runtime CFG surface.

action_counts: dict[str, int]
category_count: int
category_fixture: dict[str, str]
covered_row_count: int
fixture_count: int
level_counts: dict[str, int]
row_count: int
row_fixture: dict[str, str]
status_counts: dict[str, int]
class femorph_vendor_openradioss.OpenRadiossTierContract(tier: str, required_files: tuple[str, ...], npz_keys: dict[str, tuple[str, ...]], toml_artifacts: tuple[str, ...])

Expected native files and NPZ arrays for one OpenRadioss corpus tier.

npz_keys: dict[str, tuple[str, ...]]
required_files: tuple[str, ...]
tier: str
toml_artifacts: tuple[str, ...]
class femorph_vendor_openradioss.Path(*args, **kwargs)

PurePath subclass that can make system calls.

Path represents a filesystem path but unlike PurePath, also offers methods to do system calls on path objects. Depending on your system, instantiating a Path will return either a PosixPath or a WindowsPath object. You can also instantiate a PosixPath or WindowsPath directly, but cannot instantiate a WindowsPath on a POSIX system or vice versa.

absolute()

Return an absolute version of this path by prepending the current working directory. No normalization or symlink resolution is performed.

Use resolve() to get the canonical path to a file.

chmod(mode, *, follow_symlinks=True)

Change the permissions of the path, like os.chmod().

classmethod cwd()

Return a new path pointing to the current working directory (as returned by os.getcwd()).

exists()

Whether this path exists.

expanduser()

Return a new path with expanded ~ and ~user constructs (as returned by os.path.expanduser)

glob(pattern)

Iterate over this subtree and yield all existing files (of any kind, including directories) matching the given relative pattern.

group()

Return the group name of the file gid.

Make this path a hard link pointing to the same file as target.

Note the order of arguments (self, target) is the reverse of os.link’s.

classmethod home()

Return a new path pointing to the user’s home directory (as returned by os.path.expanduser(‘~’)).

is_block_device()

Whether this path is a block device.

is_char_device()

Whether this path is a character device.

is_dir()

Whether this path is a directory.

is_fifo()

Whether this path is a FIFO.

is_file()

Whether this path is a regular file (also True for symlinks pointing to regular files).

is_mount()

Check if this path is a POSIX mount point

is_socket()

Whether this path is a socket.

Whether this path is a symbolic link.

iterdir()

Iterate over the files in this directory. Does not yield any result for the special paths ‘.’ and ‘..’.

lchmod(mode)

Like chmod(), except if the path points to a symlink, the symlink’s permissions are changed, rather than its target’s.

Make the target path a hard link pointing to this path.

Note this function does not make this path a hard link to target, despite the implication of the function and argument names. The order of arguments (target, link) is the reverse of Path.symlink_to, but matches that of os.link.

Deprecated since Python 3.10 and scheduled for removal in Python 3.12. Use hardlink_to() instead.

lstat()

Like stat(), except if the path points to a symlink, the symlink’s status information is returned, rather than its target’s.

mkdir(mode=511, parents=False, exist_ok=False)

Create a new directory at this given path.

open(mode='r', buffering=-1, encoding=None, errors=None, newline=None)

Open the file pointed by this path and return a file object, as the built-in open() function does.

owner()

Return the login name of the file owner.

read_bytes()

Open the file in bytes mode, read it, and close the file.

read_text(encoding=None, errors=None)

Open the file in text mode, read it, and close the file.

Return the path to which the symbolic link points.

rename(target)

Rename this path to the target path.

The target path may be absolute or relative. Relative paths are interpreted relative to the current working directory, not the directory of the Path object.

Returns the new Path instance pointing to the target path.

replace(target)

Rename this path to the target path, overwriting if that path exists.

The target path may be absolute or relative. Relative paths are interpreted relative to the current working directory, not the directory of the Path object.

Returns the new Path instance pointing to the target path.

resolve(strict=False)

Make the path absolute, resolving all symlinks on the way and also normalizing it.

rglob(pattern)

Recursively yield all existing files (of any kind, including directories) matching the given relative pattern, anywhere in this subtree.

rmdir()

Remove this directory. The directory must be empty.

samefile(other_path)

Return whether other_path is the same or not as this file (as returned by os.path.samefile()).

stat(*, follow_symlinks=True)

Return the result of the stat() system call on this path, like os.stat() does.

Make this path a symlink pointing to the target path. Note the order of arguments (link, target) is the reverse of os.symlink.

touch(mode=438, exist_ok=True)

Create this file with the given access mode, if it doesn’t exist.

Remove this file or link. If the path is a directory, use rmdir() instead.

write_bytes(data)

Open the file in bytes mode, write to it, and close the file.

write_text(data, encoding=None, errors=None, newline=None)

Open the file in text mode, write to it, and close the file.

femorph_vendor_openradioss.build_openradioss_native_result_artifacts(run_dir: str | Path, output_dir: str | Path, *, tier: str, run_name: str | None = None, path_distance: Iterable[float] = ()) → dict[str, object]

Build native result/post artifacts from one OpenRadioss run directory.

femorph_vendor_openradioss.collect_openradioss_raw_outputs(run_dir: str | Path, *, tier: str, run_name: str | None = None) → tuple[OpenRadiossRawOutput, ...]

Classify raw files from an OpenRadioss run directory for conversion.

femorph_vendor_openradioss.compare_openradioss_results_npz(reference_path: str | Path, candidate_path: str | Path, *, fields: Iterable[str] = ('time', 'cycle', 'node_ids', 'elem_ids', 'part_ids', 'U', 'V', 'A', 'RF', 'S', 'E', 'PEEQ', 'DAMAGE', 'CONTACT_FORCE', 'ENERGY', 'TIME_STEP', 'HISTORY'), rtol: float = 1e-06, atol: float = 1e-09) → dict[str, object]

Compare two native OpenRadioss results.npz artifacts field by field.

femorph_vendor_openradioss.compare_openradioss_results_npz_with_policy(reference_path: str | Path, candidate_path: str | Path, *, tolerance_policy: dict[str, dict[str, float]] | None = None) → dict[str, object]

Compare two native result NPZ artifacts with per-field tolerances.

femorph_vendor_openradioss.dataclass(cls=None, /, *, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False)

Add dunder methods based on the fields defined in the class.

Examines PEP 526 __annotations__ to determine fields.

If init is true, an __init__() method is added to the class. If repr is true, a __repr__() method is added. If order is true, rich comparison dunder methods are added. If unsafe_hash is true, a __hash__() method is added. If frozen is true, fields may not be assigned to after instance creation. If match_args is true, the __match_args__ tuple is added. If kw_only is true, then by default all fields are keyword-only. If slots is true, a new class with a __slots__ attribute is returned.

femorph_vendor_openradioss.evaluate_openradioss_dynamic_parity_run_plan(plan: dict[str, object] | str | Path, *, rtol: float = 1e-06, atol: float = 1e-09, tolerance_policy: dict[str, dict[str, float]] | None = None) → dict[str, object]

Evaluate a dynamic parity run plan against available candidate artifacts.

femorph_vendor_openradioss.generate_openradioss_dynamic_candidates(plan: dict[str, object] | str | Path, *, dt: float | None = None, n_steps: int | None = None, step: str | None = 'RUN-1', backend: str | None = None, progress: bool = False, stop_on_error: bool = False) → dict[str, object]

Generate femorph dynamic candidate result artifacts for a run plan.

femorph_vendor_openradioss.model_to_native_script(model: Model) → str

Return a standalone Python script that rebuilds model without vendor parsing.

femorph_vendor_openradioss.openradioss_corpus_coverage_report(corpus_root: str | Path, api_inventory_path: str | Path | None = None, runtime_surface_path: str | Path | None = None, public_vm_inventory_path: str | Path | None = None) → OpenRadiossCorpusCoverageReport

Return fixture-backed OpenRadioss corpus coverage across all public surfaces.

femorph_vendor_openradioss.openradioss_dynamic_parity_fixture(fixture: str | Path) → OpenRadiossDynamicParityFixture

Return the dynamic parity contract for one result-bearing fixture.

femorph_vendor_openradioss.openradioss_dynamic_parity_fixtures(root: str | Path) → tuple[OpenRadiossDynamicParityFixture, ...]

Discover dynamic parity fixtures under a corpus root or fixture directory.

femorph_vendor_openradioss.openradioss_dynamic_parity_manifest(root: str | Path) → dict[str, object]

Summarize dynamic parity fixture coverage for runner orchestration.

femorph_vendor_openradioss.openradioss_dynamic_parity_run_plan(root: str | Path, *, run_root: str | Path, native_root: str | Path, reference_results_root: str | Path | None = None, limit: int | None = None) → dict[str, object]

Return an executable plan for dynamic solver/reference parity runs.

femorph_vendor_openradioss.openradioss_dynamic_parity_score_summary(pipeline_summary: dict[str, object] | str | Path) → dict[str, object]

Return a deterministic machine-readable score summary for pipeline outputs.

femorph_vendor_openradioss.openradioss_fixture_run_commands(fixture: str | Path, *, starter_executable: str | Path | None = None, engine_executable: str | Path | None = None, threads: int = 1) → tuple[OpenRadiossRunCommand, ...]

Return Starter and optional Engine commands for one corpus fixture.

femorph_vendor_openradioss.openradioss_native_conversion_plan(run_dir: str | Path, *, tier: str, run_name: str | None = None) → dict[str, object]

Return a serializable plan for converting raw OpenRadioss files.

femorph_vendor_openradioss.openradioss_post_metadata(post_path: str | Path, *, results_path: str | Path | None = None) → dict[str, object]

Summarize OpenRadioss post-processing arrays for post.toml.

femorph_vendor_openradioss.openradioss_raw_output_manifest(run_dir: str | Path, *, tier: str, run_name: str | None = None) → dict[str, object]

Return a compact raw-output inventory for one OpenRadioss run.

femorph_vendor_openradioss.openradioss_raw_reader_report(run_dir: str | Path, *, tier: str, run_name: str | None = None) → dict[str, object]

Return reader capability status for classified OpenRadioss raw outputs.

femorph_vendor_openradioss.openradioss_result_field_policy() → tuple[dict[str, str], ...]

Return the OpenRadioss result-field ownership and parity phase policy.

femorph_vendor_openradioss.openradioss_result_tolerance_policy(overrides: dict[str, dict[str, float]] | None = None, *, default_rtol: float = 1e-06, default_atol: float = 1e-09) → dict[str, dict[str, float]]

Return the field-specific result tolerance policy used for parity scoring.

femorph_vendor_openradioss.openradioss_results_metadata(run_dir: str | Path, *, run_name: str | None = None) → dict[str, object]

Summarize OpenRadioss result containers for results.toml.

femorph_vendor_openradioss.openradioss_run_command(deck: str | Path, *, stage: str = 'starter', executable: str | Path | None = None, threads: int = 1, extra_args: Iterable[str] = ()) → OpenRadiossRunCommand

Return the host command for running one OpenRadioss deck.

The command is returned rather than executed so corpus tools can stage inputs, record provenance, and run tests without requiring OpenRadioss.

femorph_vendor_openradioss.openradioss_runtime_surface_report(corpus_root: str | Path, runtime_surface_path: str | Path | None = None) → OpenRadiossRuntimeSurfaceReport

Return row-level fixture coverage for the OpenRadioss runtime surface.

femorph_vendor_openradioss.openradioss_solver_log_metadata(run_dir: str | Path, *, run_name: str | None = None, starter_command: Iterable[str] = (), engine_command: Iterable[str] = ()) → dict[str, object]

Summarize OpenRadioss listing/state files for solver_log.toml.

femorph_vendor_openradioss.openradioss_tier_contract(tier: str) → OpenRadiossTierContract

Return the artifact contract for an OpenRadioss corpus tier.

femorph_vendor_openradioss.openradioss_to_native_script(path: str | Path) → str

Convert an OpenRadioss deck file or fixture directory to a Python script.

femorph_vendor_openradioss.parse_openradioss_blocks(lines: str | Iterable[str]) → list[OpenRadiossBlock]

Lex OpenRadioss Block Format input into slash-header blocks.

femorph_vendor_openradioss.read_openradioss(lines: str | Iterable[str]) → Model

Replay a pure OpenRadioss Block Format deck into a new model.

femorph_vendor_openradioss.read_openradioss_binary_animation_metadata(path: str | Path) → dict[str, object]

Read structural metadata from binary OpenRadioss A animation files.

femorph_vendor_openradioss.read_openradioss_binary_time_history_metadata(path: str | Path) → dict[str, object]

Read structural metadata from binary OpenRadioss T time-history files.

femorph_vendor_openradioss.read_openradioss_deck_metadata(lines: str | Iterable[str]) → dict[str, str]

Read clean-room OpenRadioss deck metadata comments.

femorph_vendor_openradioss.read_openradioss_fixture(fixture: str | Path) → Model

Read a complete OpenRadioss corpus fixture directory into a model.

femorph_vendor_openradioss.read_openradioss_native_script_input(path: str | Path) → Model

Read an OpenRadioss deck file or fixture directory into a canonical model.

femorph_vendor_openradioss.read_openradioss_post(npz_path: str | Path, metadata_path: str | Path | None = None) → OpenRadiossNativePost

Read an OpenRadioss post.npz artifact plus optional TOML metadata.

femorph_vendor_openradioss.read_openradioss_post_pv(path: str | Path) → OpenRadiossPostPvSummary

Read and summarize a native OpenRadioss PyVista post.pv table.

femorph_vendor_openradioss.read_openradioss_results(npz_path: str | Path, metadata_path: str | Path | None = None) → OpenRadiossNativeResults

Read an OpenRadioss results.npz artifact plus optional TOML metadata.

femorph_vendor_openradioss.read_openradioss_results_pv(path: str | Path) → OpenRadiossResultsPvSummary

Read and summarize the native OpenRadioss PyVista results.pv schema.

femorph_vendor_openradioss.run_openradioss_dynamic_parity_pipeline(root: str | Path, output_dir: str | Path, *, dt: float | None = None, n_steps: int | None = None, step: str | None = 'RUN-1', backend: str | None = None, reference_results_root: str | Path | None = None, limit: int | None = None, tolerance_policy: dict[str, dict[str, float]] | None = None) → dict[str, object]

Run planning, candidate generation, and evaluation into one output directory.

femorph_vendor_openradioss.validate_neutral_geometry_mesh_parity(fixture: str | Path) → list[ArtifactIssue]

Validate fixture geometry/mesh artifacts against neutral Model state.

This gate intentionally stops at pre-processing state. It compares geometry.npz and, when present, mesh.npz against state.json.gz without inspecting solver results or post-processing artifacts.

femorph_vendor_openradioss.validate_openradioss_corpus_coverage_closure(corpus_root: str | Path, api_inventory_path: str | Path | None = None, runtime_surface_path: str | Path | None = None, public_vm_inventory_path: str | Path | None = None) → list[ArtifactIssue]

Validate fixture-backed OpenRadioss public-surface coverage closure.

femorph_vendor_openradioss.validate_openradioss_dynamic_parity_fixture(fixture: str | Path) → list[str]

Return fixture contract issues that would block dynamic parity orchestration.

femorph_vendor_openradioss.validate_openradioss_fixture_artifacts(fixture: str | Path) → list[ArtifactIssue]

Validate files and native array keys for one OpenRadioss corpus fixture.

femorph_vendor_openradioss.validate_openradioss_fixture_replay(fixture: str | Path) → list[ArtifactIssue]

Validate that OpenRadioss decks replay the fixture’s observable model state.

femorph_vendor_openradioss.validate_openradioss_neutral_geometry_mesh_parity(fixture: str | Path) → list[ArtifactIssue]

Validate OpenRadioss geometry and mesh arrays against neutral Model state.

femorph_vendor_openradioss.validate_openradioss_post_pv_against_npz(pv_path: str | Path, post_path: str | Path) → list[str]

Return parity issues between post.pv schema and post.npz arrays.

femorph_vendor_openradioss.validate_openradioss_results_pv(path: str | Path) → list[str]

Return schema issues for a native OpenRadioss PyVista result container.

femorph_vendor_openradioss.validate_openradioss_results_pv_against_npz(pv_path: str | Path, results_path: str | Path) → list[str]

Return parity issues between results.pv schema and results.npz arrays.

femorph_vendor_openradioss.validate_openradioss_runtime_surface_closure(corpus_root: str | Path, runtime_surface_path: str | Path | None = None) → list[ArtifactIssue]

Validate row-level OpenRadioss runtime CFG coverage and policy closure.

femorph_vendor_openradioss.write_openradioss_dynamic_candidate_from_fixture(fixture: str | Path, output_path: str | Path, *, dt: float, n_steps: int, step: str | None = 'RUN-1', backend: str | None = None, progress: bool = False) → dict[str, object]

Solve one fixture dynamically and write a native OpenRadioss candidate NPZ.

femorph_vendor_openradioss.write_openradioss_dynamic_candidate_generation(plan: dict[str, object] | str | Path, output_path: str | Path, *, dt: float | None = None, n_steps: int | None = None, step: str | None = 'RUN-1', backend: str | None = None, progress: bool = False, stop_on_error: bool = False) → dict[str, object]

Write a TOML summary for dynamic candidate generation.

femorph_vendor_openradioss.write_openradioss_dynamic_parity_evaluation(plan: dict[str, object] | str | Path, output_path: str | Path, *, rtol: float = 1e-06, atol: float = 1e-09, tolerance_policy: dict[str, dict[str, float]] | None = None) → dict[str, object]

Write a TOML summary for a dynamic parity run-plan evaluation.

femorph_vendor_openradioss.write_openradioss_dynamic_parity_pipeline_summary(root: str | Path, output_dir: str | Path, *, dt: float | None = None, n_steps: int | None = None, step: str | None = 'RUN-1', backend: str | None = None, reference_results_root: str | Path | None = None, limit: int | None = None, tolerance_policy: dict[str, dict[str, float]] | None = None) → dict[str, object]

Run the dynamic parity pipeline and write its top-level summary.

femorph_vendor_openradioss.write_openradioss_dynamic_parity_probe_scoreboard(root: str | Path, output_dir: str | Path, *, dt: float | None = None, n_steps: int | None = None, scoreboard_path: str | Path | None = None, step: str | None = 'RUN-1', backend: str | None = None, reference_results_root: str | Path | None = None, limit: int | None = None, tolerance_policy: dict[str, dict[str, float]] | None = None) → dict[str, object]

Run the dynamic parity pipeline and write the current parity score summary.

femorph_vendor_openradioss.write_openradioss_dynamic_parity_run_plan(root: str | Path, output_path: str | Path, *, run_root: str | Path, native_root: str | Path, reference_results_root: str | Path | None = None, limit: int | None = None) → dict[str, object]

Write a TOML dynamic parity run plan and return the plan dictionary.

femorph_vendor_openradioss.write_openradioss_dynamic_parity_score_summary(pipeline_summary: dict[str, object] | str | Path, output_path: str | Path) → dict[str, object]

Write or update a TOML parity score summary from current pipeline outputs.

femorph_vendor_openradioss.write_openradioss_post_metadata(post_path: str | Path, output_path: str | Path, *, results_path: str | Path | None = None) → dict[str, object]

Write post.toml metadata for OpenRadioss post arrays.

femorph_vendor_openradioss.write_openradioss_post_npz_from_results(results_path: str | Path, output_path: str | Path, *, path_distance: Iterable[float] = ()) → dict[str, object]

Write first-pass OpenRadioss post reductions from results.npz.

femorph_vendor_openradioss.write_openradioss_post_preview(post_path: str | Path, output_path: str | Path) → str

Write a native PyVista post.pv reduction container.

femorph_vendor_openradioss.write_openradioss_raw_output_manifest(run_dir: str | Path, output_path: str | Path, *, tier: str, run_name: str | None = None) → dict[str, object]

Write a TOML raw-output inventory for one OpenRadioss run.

femorph_vendor_openradioss.write_openradioss_raw_reader_report(run_dir: str | Path, output_path: str | Path, *, tier: str, run_name: str | None = None) → dict[str, object]

Write a TOML reader capability report for one OpenRadioss run.

femorph_vendor_openradioss.write_openradioss_results_metadata(run_dir: str | Path, output_path: str | Path, *, run_name: str | None = None) → dict[str, object]

Write results.toml metadata parsed from OpenRadioss raw output.

femorph_vendor_openradioss.write_openradioss_results_npz_from_binary_time_history(run_dir: str | Path, output_path: str | Path, *, run_name: str | None = None) → dict[str, object]

Write minimal results.npz data from binary OpenRadioss time histories.

femorph_vendor_openradioss.write_openradioss_results_npz_from_converted_animation(run_dir: str | Path, output_path: str | Path, *, run_name: str | None = None) → dict[str, object]

Write results.npz from OpenRadioss animation files converted to VTK.

OpenRadioss’ public tooling exposes A-file animation data through VTK conversion. This reader ingests those converted VTK frames directly into the femorph native result contract, and can merge time-history CSV exports from the same run.

femorph_vendor_openradioss.write_openradioss_results_npz_from_dynamic_result(model: Model, result: Any, output_path: str | Path, *, cycles: Iterable[int] | None = None) → dict[str, object]

Write a native OpenRadioss results.npz candidate from a dynamic solve.

femorph_vendor_openradioss.write_openradioss_results_npz_from_exports(run_dir: str | Path, output_path: str | Path, *, run_name: str | None = None) → dict[str, object]

Write results.npz from OpenRadioss field/history CSV exports.

femorph_vendor_openradioss.write_openradioss_results_npz_from_static_result(model: Model, result: Any, output_path: str | Path, *, time: float = 0.0, cycle: int = 0) → dict[str, object]

Write a native OpenRadioss results.npz candidate from a static solve.

femorph_vendor_openradioss.write_openradioss_results_npz_from_status(run_dir: str | Path, output_path: str | Path, *, run_name: str | None = None) → dict[str, object]

Write minimal results.npz frame data from OpenRadioss status listings.

femorph_vendor_openradioss.write_openradioss_results_npz_from_time_history(run_dir: str | Path, output_path: str | Path, *, run_name: str | None = None) → dict[str, object]

Write results.npz from text OpenRadioss T*/.thy time histories.

femorph_vendor_openradioss.write_openradioss_results_npz_parity_report(reference_path: str | Path, candidate_path: str | Path, output_path: str | Path, *, fields: Iterable[str] = ('time', 'cycle', 'node_ids', 'elem_ids', 'part_ids', 'U', 'V', 'A', 'RF', 'S', 'E', 'PEEQ', 'DAMAGE', 'CONTACT_FORCE', 'ENERGY', 'TIME_STEP', 'HISTORY'), rtol: float = 1e-06, atol: float = 1e-09) → dict[str, object]

Write a TOML parity report for two native OpenRadioss results.npz artifacts.

femorph_vendor_openradioss.write_openradioss_results_npz_policy_parity_report(reference_path: str | Path, candidate_path: str | Path, output_path: str | Path, *, tolerance_policy: dict[str, dict[str, float]] | None = None) → dict[str, object]

Write a per-field-tolerance parity report for result NPZ artifacts.

femorph_vendor_openradioss.write_openradioss_results_pv_from_converted_animation(run_dir: str | Path, output_path: str | Path, *, run_name: str | None = None, results_path: str | Path | None = None, post_path: str | Path | None = None) → dict[str, object]

Write a native PyVista .pv result container from converted animation frames.

femorph_vendor_openradioss.write_openradioss_results_pv_from_results_npz(results_path: str | Path, output_path: str | Path, *, post_path: str | Path | None = None) → dict[str, object]

Write a native PyVista .pv result container from native NPZ arrays.

femorph_vendor_openradioss.write_openradioss_solver_log(run_dir: str | Path, output_path: str | Path, *, run_name: str | None = None, starter_command: Iterable[str] = (), engine_command: Iterable[str] = ()) → dict[str, object]

Write solver_log.toml metadata parsed from OpenRadioss raw output.