core.py File Reference

A comprehensive conductor script for the PICurv simulation platform. More...

Go to the source code of this file.

Data Structures
class	picurv_cli.core._LazyNumpyProxy
	Module-like proxy that preserves picurv.np without eager import. More...
class	picurv_cli.core.CheckpointIndexWidthError
	A committed checkpoint written by a PETSc of the other index width than the driven solver's. More...
class	picurv_cli.core.CommandExecutionError
	Raised when an external command exits unsuccessfully. More...
class	picurv_cli.core.PlotDependencyError
	Raised when plot.gen reports a missing optional dependency. More...

Namespaces
namespace	picurv_cli
namespace	picurv_cli.core

Functions
	picurv_cli.core._prune_incompatible_python_site_paths (paths)
	Remove site-package paths for a different Python major/minor version.
	picurv_cli.core._drop_imported_package (str package_name)
	Remove a failed/partial import package tree from sys.modules.
	picurv_cli.core.require_numpy ()
	Import NumPy only for commands that need numeric reductions.
	picurv_cli.core.optional_matplotlib_pyplot ()
	Import matplotlib.pyplot lazily for study plot generation.
str	picurv_cli.core._read_release_version ()
	Read the single release version shared by every PICurv executable.
"str | None"	picurv_cli.core._git_output (*arguments)
	Run one git command in the source checkout.
dict	picurv_cli.core._source_build_identity (str release_version)
	Resolve reproducible release, commit, and dirty-tree build identity.
dict	picurv_cli.core.picurv_build ()
	The conductor's own build identity, resolved on first use and kept for the process.
	picurv_cli.core._find_named_file_upwards (str start, str filename)
	Find a named file at or above an arbitrary filesystem anchor.
	picurv_cli.core.find_workspace_root (*anchors)
	Locate the nearest initialized PICurv workspace for supplied anchors.
dict	picurv_cli.core.load_workspace_config (str workspace_root)
	Load and validate the immutable workspace identity/configuration file.
dict	picurv_cli.core.enforce_workspace_version (str workspace_root)
	Enforce an optional workspace PICurv version requirement.
dict	picurv_cli.core.enforce_reproducibility_policy (str workspace_root)
	Enforce an optional workspace policy demanding a clean, released build.
str	picurv_cli.core.resolve_workspace_path (str anchor_file, str candidate, *bool allow_external=False)
	Resolve a user path against its workspace and reject implicit escapes.
None	picurv_cli.core.ensure_workspace_layout (str workspace_root)
	Materialize the uniform, cheap directory skeleton for one workspace.
str	picurv_cli.core.initialize_workspace_root (str workspace_root, str template_name)
	Create the workspace skeleton and its identity file at one root.
None	picurv_cli.core.ensure_run_layout (str run_dir)
	Materialize the uniform, cheap directory skeleton for one run.
tuple	picurv_cli.core.validate_run_directory_structure (str run_dir)
	Refuse a run whose root has grown a directory the layout does not define.
None	picurv_cli.core.enforce_run_directory_structure (str run_dir)
	Apply validate_run_directory_structure() as a refusal at run time.
str	picurv_cli.core.case_run_label (dict case_cfg, str case_path)
	Resolve the stable human-facing portion of a generated run identifier.
str	picurv_cli.core.allocate_generated_run_id (str runs_root, dict case_cfg, str case_path)
	Build the generated run identity, disambiguating a same-second collision.
bool	picurv_cli.core.discard_unused_run_directory (str run_dir, *bool created, bool staged=False)
	Remove a generated run directory that never received any content.
	picurv_cli.core._file_sha256 (str path)
	Content digest of one file, or None when it cannot be read.
dict	picurv_cli.core.build_software_lock ("str | None" run_dir=None)
	Capture the exact software identity a run is about to execute with.
dict	picurv_cli.core._toolchain_identity ()
	Best-effort record of the PETSc, MPI, and compiler in the shell staging the run.
str	picurv_cli.core.write_software_lock (str run_dir)
	Write the run's software lock beside its asset lock.
str	picurv_cli.core.workspace_artifact_root (str workspace_root, str kind)
	Return the canonical workspace-owned root for runs or studies.
	picurv_cli.core._relative_to_workspace (str path, str workspace_root)
	Return a portable workspace-relative path when possible.
dict	picurv_cli.core.snapshot_run_configuration (str run_dir, dict source_paths, bool continuation=False)
	Snapshot editable YAML inputs without erasing prior continuation state.
dict	picurv_cli.core.capture_continuation_records (str run_dir, str restart_dir)
	Save what a continuation's staging changes, so a refusal can undo it.
	picurv_cli.core.restore_continuation_records (str run_dir, dict saved, str revision)
	Undo a refused continuation's staging: restore its records, drop its revision.
dict	picurv_cli.core.load_active_run_configuration (str run_dir)
	Load the active immutable configuration revision for a run.
dict	picurv_cli.core.load_run_executables (str run_dir)
	Return the executables a run is pinned to, as recorded by its active configuration.
str	picurv_cli.core.run_executable_path ("str | None" run_dir, str name)
	Resolve the executable a run launches: its pinned copy, else the installation's.
dict	picurv_cli.core.pin_run_executables (str run_dir, str revision)
	Copy the installation's executables into a run's configuration revision.
dict	picurv_cli.core.plan_run_executable_paths (str run_dir, args, "str | None" workspace_root)
	Predict, without writing, which executables staging would give a run.
bool	picurv_cli.core.resolve_executable_pinning (args, "str | None" workspace_root)
	Decide whether staging pins the installation's executables into the run.
dict	picurv_cli.core.apply_run_executable_pinning (str run_dir, str revision, args, "str | None" workspace_root)
	Pin, keep, or refuse the run's executables before anything records them.
dict	picurv_cli.core.archive_active_generated_configuration (str run_dir, list paths)
	Preserve generated control sidecars beside a continuation's YAML revision.
dict	picurv_cli.core._run_component_states (str run_dir, dict stages_requested)
	Report each run component's home, retention class, and lifecycle state.
dict	picurv_cli.core.build_run_lineage (str parent_run_dir, int checkpoint_step, *workspace_root=None, statistics_state=None, requested_source=None)
	Record which run and which checkpoint a branched run was started from.
dict	picurv_cli.core.build_run_manifest (str run_dir, str run_id, *workspace_root=None, str launch_mode="local", int num_procs=1, int post_num_procs=1, stages_requested=None, stages_completed=None, inputs=None, asset_lock=None, submission=None, lineage=None, str artifact_type="run", study_id=None, case_id=None)
	Build the authoritative run identity, topology, and lifecycle manifest.
	picurv_cli.core._recorded_run_root (str run_dir)
	Return the location a run's generated files refer to.
int	picurv_cli.core.adopt_relocated_artifact (str root, str kind="run", bool dry_run=False)
	Point a moved run's or study's generated files at where it now lives.
str	picurv_cli.core._checkpoint_bundle_path (str source_dir, int step)
	Resolve a run/output root or an exact checkpoint bundle.
dict	picurv_cli.core._read_checkpoint_options (str metadata_path)
	Parse the deliberately small PETSc-options checkpoint manifest.
dict	picurv_cli.core.validate_committed_checkpoint (str source_dir, int step, bool require_particles=False)
	Validate one committed bundle using the same manifest contract as C.
"set[int]"	picurv_cli.core._scan_committed_checkpoint_steps (str source_dir, bool require_particles=False)
	Return only fully validated, committed checkpoint steps.
int	picurv_cli.core.parse_slurm_time_limit_to_seconds (str time_text)
	Parse a Slurm time-limit string into total seconds.
"dict | None"	picurv_cli.core.resolve_walltime_guard_policy ("dict | None" cluster_cfg)
	Resolve the effective Slurm walltime-guard policy for generated solver jobs.
dict	picurv_cli.core.build_walltime_guard_exports ("dict | None" cluster_cfg)
	Build shell-evaluated environment exports for the runtime walltime guard.
str	picurv_cli.core.resolve_runtime_executable (str executable_name)
	Resolve solver/post executable path, preferring local sibling binaries.
"dict | None"	picurv_cli.core._parse_binary_petsc_line (str line)
	Parse the PETSc build line a native executable reports.
"dict | None"	picurv_cli.core.read_binary_petsc_stamp (str executable_path)
	Read the PETSc build stamp from an executable's bytes, without running it.
"str | None"	picurv_cli.core.resolved_petsc_library (str executable_path)
	The PETSc shared library the dynamic loader would give this executable when picurv launches it.
bool	picurv_cli.core.petsc_library_mismatch ("dict | None" petsc, "str | None" library)
	Whether the library the loader resolves lies outside the PETSc the binary was built against.
"dict | None"	picurv_cli.core._read_binary_build_stamp (str executable_path)
	Read the build identity stamped into an executable's bytes, without running it.
dict	picurv_cli.core.read_binary_build_identity (str executable_path)
	Read the build identity a native executable was compiled with.
dict	picurv_cli.core.runtime_build_identities ("dict | None" source_identity=None, "str | None" run_dir=None)
	Read the build identity of every native executable a run would launch.
str	picurv_cli.core.rebuild_command (str name, dict identity)
	The command that rebuilds one native executable.
list	picurv_cli.core.build_identity_problems (dict identities, workspace_requirement=None, "dict | None" source_identity=None)
	Report every reason the active build identity is not internally coherent.
list	picurv_cli.core.warn_on_stale_runtime_binaries (dict identities)
	Report native executables whose build identity is not the active source.
str	picurv_cli.core._sanitize_error_field (value)
	Normalize error fields into a single-line string.
	picurv_cli.core.emit_structured_error (str code, str key="-", str file_path="-", str message="", str hint=None, stream=None)
	Emit one standardized error line for tooling and users.
	picurv_cli.core.fail_cli_usage (str message, str hint=None)
	Emit a structured CLI usage error and exit with code 2.
	picurv_cli.core._split_error_file_and_message (str raw_error)
	Separate a validation error into its source-file and message fields when possible.
str	picurv_cli.core._extract_key_path (str message)
	Best-effort key-path extraction from free-form validation messages.
str	picurv_cli.core._classify_error_code (str message)
	Map existing validation/error messages to the standardized code set.
dict	picurv_cli.core.read_yaml_file (str filepath)
	Safely reads a YAML file and returns its content.
	picurv_cli.core.write_yaml_file (str filepath, dict data)
	Write YAML with stable ordering for generated study artifacts.
	picurv_cli.core.write_json_file (str filepath, dict payload)
	Write JSON metadata/manifests with a stable, readable format.
str	picurv_cli.core.write_runtime_execution_file (str filepath, str template_source_path=None)
	Write a default runtime execution config, copying a source template when available.
bool	picurv_cli.core._launcher_arg_contains_whitespace (token)
	Return True when a launcher arg token contains embedded whitespace and should be split.
"str | None"	picurv_cli.core.resolve_runtime_execution_seed_source (str source_project_root)
	Prefer repo-local ignored runtime config, then tracked example, then built-in defaults.
dict	picurv_cli.core.ensure_case_runtime_execution_config (str case_dir, str source_project_root, bool overwrite=False)
	Create case-local runtime execution config if missing, seeded from repo-local config when available.
bool	picurv_cli.core.is_project_root (str candidate)
	Return True when a directory looks like the PICurv source repository root.
	picurv_cli.core._iter_parent_dirs (str start_path)
	Yield a path and all of its parents up to filesystem root.
	picurv_cli.core.find_project_root_upwards (str start_path)
	Search upward from an anchor and return the first matching project root.
	picurv_cli.core.discover_local_project_root (*extra_anchors)
	Best-effort source repo discovery from runtime anchors.
	picurv_cli.core.find_case_origin_metadata_file (str case_dir_hint=None)
	Find the nearest case-origin metadata file from known runtime anchors.
	picurv_cli.core.load_case_origin_metadata (str case_dir_hint=None)
	Load case-origin metadata if present, returning (case_dir, metadata_path, payload).
	picurv_cli.core.find_runtime_execution_config_file (*anchors)
	Find the nearest optional execution config from runtime/case anchors.
dict	picurv_cli.core._normalize_execution_override_section (dict payload, str section_name, str config_path, str config_label)
	Validate one execution override section while preserving missing-vs-empty semantics.
	picurv_cli.core.load_runtime_execution_config (str config_search_anchor=None, extra_search_anchors=None)
	Load optional shared execution launcher config from the nearest runtime config file.
dict	picurv_cli.core.merge_execution_overrides ("dict | None" base, "dict | None" override)
	Merge execution overrides, letting explicit override values win key-by-key.
dict	picurv_cli.core.resolve_runtime_execution_context (dict runtime_execution_cfg, str context)
	Resolve default plus context-specific execution overrides.
str	picurv_cli.core.get_git_commit (str repo_root=None)
	Best-effort git commit lookup for run/study manifests and case metadata.
	picurv_cli.core.write_case_origin_metadata (str case_dir, str source_project_root, str template_name=None, dict existing=None, template_managed_files=None)
	Create or refresh case-origin metadata for repo-aware case maintenance commands.
bool	picurv_cli.core.make_args_include_explicit_goal ("list[str]" make_args)
	Return True when make args contain an explicit target rather than only options/assignments.
	picurv_cli.core.resolve_case_origin_context (str case_dir_hint=None, str source_root_override=None, str template_name_override=None)
	Resolve case directory, source repo root, and optional template metadata.
	picurv_cli.core.require_project_root (str candidate, str purpose)
	Validate that a source repo root was resolved and is structurally valid.
	picurv_cli.core.require_existing_case_dir (str case_dir, str purpose, str source_project_root=None)
	Validate that a target case directory exists and is not the source repo root.
	picurv_cli.core.resolve_template_directory (str source_project_root, str template_name)
	Resolve an example template directory inside the source repository.
	picurv_cli.core.list_template_relative_files (str template_dir, excluded_rel_paths=None)
	List all files in a template directory as case-relative paths.
dict	picurv_cli.core.render_template_workspace (str template_dir, str template_name, str destination)
	Render an example template into the canonical workspace layout at a new path.
list	picurv_cli.core.list_rendered_template_files (str rendered_root)
	List the template-managed files of a rendered workspace, workspace-relative.
	picurv_cli.core.list_source_binaries (str source_project_root)
	List binary artifacts currently available in the source repo bin directory.
	picurv_cli.core.sync_case_binaries (str case_dir, str source_project_root)
	Copy current source-repo binaries into a case directory for version-pinning.
	picurv_cli.core.sync_case_template_files (str case_dir, str template_dir, bool overwrite=False, bool prune=False, managed_rel_paths=None, str template_name=None)
	Sync template files into a case directory, preserving modified files unless overwrite is requested.
	picurv_cli.core.compute_case_source_status (str case_dir, str source_project_root, str template_name=None, dict metadata=None)
	Compute source/case drift across commits, binaries, and template-managed files.
	picurv_cli.core.print_case_source_status (dict status)
	Render human-readable source/case drift details.
	picurv_cli.core.status_source_command (args)
	Report source/case drift for an initialized case directory.
str	picurv_cli.core.resolve_path (str anchor_file, str candidate)
	Resolve a potentially relative path against a source YAML file path.
	picurv_cli.core._mapping_value_with_aliases (dict mapping, *keys, default=None)
	Return the first defined value from a mapping across alias keys.
	picurv_cli.core.get_post_run_control_value (dict post_cfg, str canonical_key, default=None)
	Resolve post run_control values with backwards-compatible legacy aliases.
None	picurv_cli.core.warn_on_grid_generator_hyphen_keys (dict generator, str case_path, list warnings)
	Warn when grid.generator uses unsupported hyphenated wrapper keys.
str	picurv_cli.core.retired_destination_message (str label, str key)
	Explain why a generator may not choose its own output destination.
list	picurv_cli.core.reject_generator_destination_keys (generator, str case_path, str label)
	Reject generator settings that try to choose their own output destination.
	picurv_cli.core.get_post_source_data (dict post_cfg)
	Return source_data as a mapping when valid, else an empty mapping.
str	picurv_cli.core.get_post_source_directory_template (dict post_cfg, str default="<solver_output_dir>")
	Resolve the source directory template from source_data with a safe default.
	picurv_cli.core.get_post_input_extensions (dict post_cfg)
	Return post input_extensions, preferring io.
	picurv_cli.core.get_post_statistics_task_tokens (dict post_cfg)
	Return normalized statistics pipeline tokens that will be written into post.run.
str	picurv_cli.core.get_monitor_output_directory (dict monitor_cfg, str default="output")
	Resolve the solver output root from monitor.yml, preserving the default layout.
str	picurv_cli.core.get_post_statistics_output_prefix (dict post_cfg, str default="Stats")
	Resolve the statistics CSV prefix, preserving legacy top-level override support.
str	picurv_cli.core.resolve_post_statistics_output_prefix (dict post_cfg, monitor_cfg=None, str default="Stats")
	Resolve the runtime statistics prefix, routing bare basenames under the monitor output root.
	picurv_cli.core.get_post_statistics_output_artifacts (dict post_cfg, str run_dir, monitor_cfg=None)
	Predict statistics CSV output paths relative to the postprocessor runtime cwd.
dict	picurv_cli.core.resolve_scalar_transport (dict case_cfg, dict solver_cfg, bool warn=False)
	Resolve the scalar-transport parameters from case.yml or their deprecated location.
dict	picurv_cli.core.normalize_post_spectra_config (dict post_cfg)
	Validate and canonicalize the spectra block of post.yml.
list	picurv_cli.core.validate_post_spectra_preconditions (dict spectra_cfg, dict case_cfg, str post_path)
	Check spectra tasks against what the case can actually support.
str	picurv_cli.core._resolve_spectra_payload (dict bundle, str kind, str field, int block)
	Locate one checkpoint payload by its inventory entry rather than by path shape.
list	picurv_cli.core._spectra_mean_arguments (dict task_cfg, dict bundle, dict mean_bundle=None)
	Build the generator arguments implementing a task's fluctuation choice.
set	picurv_cli.core.resolve_post_stage_selection (only)
	Resolve the --only selector into the set of post stages to execute.
dict	picurv_cli.core.run_post_spectra_stage (str run_dir, dict post_cfg, dict monitor_cfg, str source_dir, steps, bool quiet=False, "dict | None" plan=None, bool recompute=False)
	Measure spectra for every requested task across a window of committed steps.
dict	picurv_cli.core.normalize_post_reducers_config (dict post_cfg)
	Validate and canonicalize the reducers block of post.yml.
list	picurv_cli.core.run_post_reducers_stage (str run_dir, dict post_cfg, bool quiet=False)
	Run every reducer task over the profiles the recipe has written.
list	picurv_cli.core._merge_spectra_rows (str path, tuple fieldnames, set remeasured, list new_rows)
	Combine newly measured spectra rows with those already written for other steps.
str	picurv_cli.core.compute_post_spectra_signature (dict spectra_cfg)
	Reduce a normalized spectra recipe to a stable identity string.
str	picurv_cli.core.resolve_post_spectra_output_dir (monitor_cfg=None)
	Resolve the run-relative directory spectra CSVs are written to.
str	picurv_cli.core.resolve_recipe_spectra_output_dir (dict post_cfg, monitor_cfg=None)
	Resolve the canonical spectra directory for one versioned recipe.
list	picurv_cli.core.get_post_spectra_output_artifacts (dict post_cfg, str run_dir, monitor_cfg=None)
	Predict the spectra CSV paths a recipe will write.
str	picurv_cli.core.post_spectra_task_basename (dict task_cfg, str output_prefix)
	Build the file basename one normalized spectra task writes.
list	picurv_cli.core._normalize_post_statistics_ensembles (raw)
	Validate and canonicalize the ensembles a post recipe defines.
dict	picurv_cli.core.normalize_post_field_statistics_config (dict post_cfg)
	Validate and canonicalize the field_statistics block of post.yml.
int	picurv_cli.core._post_window_derived_field_count (dict window_cfg, list outputs, dict eligible=None)
	Count the derived fields one window would produce for a set of outputs.
bool	picurv_cli.core._post_requests_field_statistics (dict post_cfg)
	Return whether the current post recipe derives accumulated field statistics.
	picurv_cli.core.get_post_field_statistics_artifacts (dict post_cfg, str run_dir)
	Predict the per-window statistics artifacts a recipe will produce.
dict	picurv_cli.core.build_post_recipe_config (dict post_cfg, monitor_cfg=None)
	Build the flat key=value mapping consumed by the C post-processor.
str	picurv_cli.core.compute_post_recipe_id (dict post_cfg)
	Compute a stable human-readable identity for one post recipe.
"tuple[dict, str]"	picurv_cli.core.apply_canonical_post_paths (dict post_cfg, str run_dir)
	Route every post artifact into its fixed analysis or visualization home.
dict	picurv_cli.core.normalize_post_recipe_signature (dict recipe_cfg)
	Normalize post recipe settings into a stable signature mapping.
"tuple[dict, str]"	picurv_cli.core.compute_post_recipe_fingerprint (dict recipe_cfg)
	Return normalized recipe signature plus SHA-256 fingerprint.
str	picurv_cli.core.get_post_resume_state_path (str run_dir, dict post_cfg=None)
	Return the JSON resume metadata path for a run directory.
str	picurv_cli.core.get_post_recipe_root (str run_dir, dict post_cfg)
	Return the versioned run-local control directory for one post recipe.
dict	picurv_cli.core.get_post_lock_paths (str run_dir, str recipe_id=None)
	Return lock-wrapper related paths for a run directory.
str	picurv_cli.core._post_output_directory_abs (str run_dir, dict post_cfg)
	Resolve the absolute post output directory for the current recipe.
bool	picurv_cli.core._post_requests_eulerian_output (dict post_cfg)
	Return whether the current post recipe expects Eulerian VTK output artifacts.
bool	picurv_cli.core._post_requests_particle_output (dict post_cfg)
	Return whether the current post recipe expects particle VTP output artifacts.
dict	picurv_cli.core.normalize_post_paraview_series_config (dict post_cfg)
	Normalize the optional ParaView collection policy in a post recipe.
str	picurv_cli.core._resolve_lineage_parent_run (str child_run_dir, dict lineage)
	Resolve and identity-check one recorded lineage parent.
list	picurv_cli.core.resolve_run_lineage (str run_dir, str scope="lineage")
	Return root-to-leaf run segments, for a ParaView collection or a reducer's metrics.
dict	picurv_cli.core._existing_pvd_times (str pvd_path)
	Read step-to-time fallbacks from an existing PVD collection.
float	picurv_cli.core._checkpoint_time_for_series (str run_dir, int step, dict fallback, float time_scale=1.0)
	Read the authoritative time of one visualization frame.
None	picurv_cli.core._write_pvd_collection (str path, list entries)
	Atomically write one VTK Collection file.
int	picurv_cli.core._lineage_reset_index (list segments, str family)
	Return the first segment belonging to one continuous artifact family.
list	picurv_cli.core.finalize_post_paraview_series (str run_dir, dict post_cfg)
	Build physical-time ParaView collections from current or lineage VTK output.
str	picurv_cli.core._post_finalize_python_source ()
	Return the importable serial finalizer used by generated jobs.
list	picurv_cli.core.build_post_finalize_command (str run_dir, str archived_post_path, dict post_cfg, post_stages=POST_STAGE_NAMES)
	Build the serial post-success command for staged execution.
None	picurv_cli.core.finalize_post_outputs (str run_dir, dict post_cfg, stages)
	Run every serial step that reads a successful field stage's output.
bool	picurv_cli.core._post_requests_statistics (dict post_cfg)
	Return whether the current post recipe expects statistics CSV artifacts.
bool	picurv_cli.core._post_needs_particle_source (dict post_cfg)
	Return whether the current post recipe requires particle source files to be present.
	picurv_cli.core._iter_post_steps (int start_step, int end_step, int step_interval)
	Yield configured post-processing steps inclusively.
"tuple[int, int, int]"	picurv_cli.core.resolve_post_requested_window (dict post_cfg, dict case_cfg=None)
	Resolve post requested start/end/interval, expanding end=-1 via case.yml when available.
int	picurv_cli.core.resolve_post_owned_start (str run_dir, dict post_cfg, int requested_start, int step_interval)
	Intersect a recipe's logical cadence with this run's branch.
dict	picurv_cli.core.prepare_effective_post_config (dict post_cfg, str resolved_source_dir, int start_step=None, int end_step=None)
	Return a copy of post_cfg with resolved source dir and optional effective bounds.
"dict[int, str]"	picurv_cli.core._scan_post_vtk_steps (str prefix_path, str extension)
	Collect the VTK files named with a prefix, step suffix, and extension.
"set[int]"	picurv_cli.core._scan_post_statistics_csv_steps (str csv_path)
	Scan step ids from the first CSV column of a statistics artifact.
"list[tuple]"	picurv_cli.core.collect_post_completion_families (str run_dir, dict post_cfg, monitor_cfg=None)
	Collect the output files each output family of the current recipe holds per step.
	picurv_cli.core._field_statistics_window_samples (str run_dir, int step)
	Read each field-statistics window's sample count from one committed checkpoint.
	picurv_cli.core.post_step_outputs (str run_dir, dict post_cfg, monitor_cfg=None)
	Return a lookup of the output files one step of the current recipe holds.
	picurv_cli.core._nearest_step ("set[int]" steps, int target)
	Return the complete source step nearest to a target step.
str	picurv_cli.core._format_optional_step (step)
	Format an optional step number for user-facing diagnostics.
"tuple[set[int], dict]"	picurv_cli.core._scan_complete_source_steps (str source_dir, dict monitor_cfg, dict post_cfg)
	Scan source artifacts and return steps with every file required by the recipe.
"list[str]"	picurv_cli.core._expected_source_paths_for_step (int step, dict source_scan, dict post_cfg)
	Build required source file paths for a single post-processing step.
dict	picurv_cli.core.detect_post_source_frontier (str source_dir, dict monitor_cfg, dict post_cfg, int start_step, int end_step, int step_interval)
	Detect the highest contiguous fully available source step for live post-processing.
"tuple[dict, dict]"	picurv_cli.core._read_post_records (str state_path)
	Read the per-step output records a recipe's state holds.
	picurv_cli.core.persist_post_resume_state (str run_dir, dict plan, steps=None, spectra=None)
	Write a recipe's state: the window last planned and its per-step output records.
	picurv_cli.core._checkpoint_commit (str source_dir, int step)
	Identify one committed checkpoint by its commit marker.
"str | None"	picurv_cli.core.classify_post_step (record, files, commit, str recipe, bool recompute=False)
	Decide whether one step's existing output is still valid.
None	picurv_cli.core.warn_overlapping_post_recipes (str run_dir, dict post_cfg, dict plan, post_stages)
	Warn when another recipe in this run already produced outputs this one repeats.
str	picurv_cli.core._build_post_lock_wrapper_source ()
	Return the Python wrapper that runs one post job under an exclusive lock.
str	picurv_cli.core.ensure_post_lock_wrapper (str run_dir)
	Ensure the lock wrapper exists for a run directory and return its path.
"tuple[list, dict]"	picurv_cli.core.build_post_locked_command (str run_dir, str recipe_fingerprint, list wrapped_command, bool create_wrapper=True, "list | None" success_command=None, "str | None" post_recipe=None, "str | None" postprocessor=None, bool recompute=False)
	Wrap a postprocessor command behind the run-dir-scoped lock wrapper.
None	picurv_cli.core.run_post_finalize_locked (str run_dir, str recipe_fingerprint, list finalize_command)
	Refresh a collection-only result under the ordinary post writer lock.
dict	picurv_cli.core.build_post_execution_plan (str run_dir, str run_id, dict case_cfg, dict monitor_cfg, dict post_cfg, bool recompute=False, bool allow_source_frontier_scan=True, "str | None" postprocessor_sha=None)
	Decide which steps of a recipe's window one invocation processes.
None	picurv_cli.core.report_post_plan (dict plan)
	Print which steps a post plan processes, keeps, and waits for.
str	picurv_cli.core.get_post_step_list_path (str run_dir, dict post_cfg)
	Return the file naming the steps a launched post job processes.
"tuple[dict, dict, dict]"	picurv_cli.core._load_post_job_configs (str run_dir, str post_recipe_path)
	Load the configuration a post job needs from the run it runs in.
int	picurv_cli.core.prepare_post_job (str run_dir, str post_recipe_path, str postprocessor, bool recompute=False)
	Decide, as a post job starts, which steps it processes.
int	picurv_cli.core.finish_post_job (str run_dir, str post_recipe_path, bool exited_cleanly=False)
	Record, after a post job ends, which steps it produced.
bool	picurv_cli.core.needs_restart_source (dict case_cfg, dict solver_cfg)
	Return True when the solver requires restart data from disk.
str	picurv_cli.core.resolve_run_output_dir (str run_dir, dict monitor_cfg)
	Resolve the output data directory within a run directory.
str	picurv_cli.core.resolve_run_restart_dir (str run_dir, dict monitor_cfg)
	Resolve the restart staging directory within a run directory.
str	picurv_cli.core.compute_physical_case_identity (dict case_cfg)
	Compute the hidden identity used to guard in-place continuation.
None	picurv_cli.core.validate_continue_case_identity (str run_dir, dict case_cfg)
	Reject in-place continuation when the physical case has changed.
	picurv_cli.core.populate_restart_directory (str source_output, str target_restart, int start_step, dict monitor_cfg, "int | None" end_step=None, bool materialize=True)
	Atomically materialize an immutable checkpoint interval into a run.
	picurv_cli.core.validate_eulerian_checkpoint (str source_dir, int step, dict monitor_cfg)
	Validate the mandatory Eulerian field set required by ReadSimulationFields().
	picurv_cli.core.detect_last_checkpoint_step (str output_dir)
	Scan output directory for the highest step number available.
dict	picurv_cli.core.detect_case_completion_status (str run_dir, dict monitor_cfg, int target_final_step)
	Determine whether a study case is complete, partially complete, or empty.
	picurv_cli.core.validate_load_mode_step_range (str source_output, int start_step, int total_steps, dict monitor_cfg)
	Validate that all required eulerian step files exist for "load" mode.
	picurv_cli.core.validate_particle_checkpoint (str source_dir, int start_step, dict monitor_cfg)
	Validate that particle checkpoint files exist for the given step.
dict	picurv_cli.core.read_monitor_from_run (str run_dir)
	Read the monitor.yml from a run directory's config/ subdirectory.
str	picurv_cli.core.resolve_latest_restart_run (dict case_cfg, str case_path, int start_step)
	Select the newest local workspace run compatible with a requested restart.
	picurv_cli.core.resolve_restart_source (args, dict case_cfg, dict solver_cfg, dict monitor_cfg, str run_dir, bool materialize=True)
	Resolve the restart source directory based on –restart-from or –continue CLI flags.
	picurv_cli.core.absolutize_case_external_paths (dict case_cfg, str case_anchor_path)
	Convert external grid/generator paths in case config to absolute paths.
	picurv_cli.core.prepare_case_for_continuation (str run_dir, str case_id, int last_step, int target_final_step, dict cluster_cfg)
	Set up a partially-completed study case for continuation in-place.
bool	picurv_cli.core.is_valid_email (str email)
	Lightweight email validation for scheduler notifications.
str	picurv_cli.core.normalize_statistics_task (str task_name)
	Normalizes user-facing statistics task names to C pipeline keywords.
	picurv_cli.core._iter_nonempty_noncomment_lines (file_obj)
	Yield (lineno, stripped_line) for non-empty, non-comment lines.
str	picurv_cli.core.format_picgrid_coordinate (float value)
	Format a coordinate with round-trip-safe binary64 precision.
dict	picurv_cli.core.validate_and_nondimensionalize_picgrid (str source_grid, str dest_grid, float L_ref, int expected_nblk=None)
	Validates PICGRID payload and writes a non-dimensionalized copy.
list	picurv_cli.core.read_picgrid_header_dimensions (str source_grid, int expected_nblk=None)
	Read only the canonical PICGRID header dimensions.
dict	picurv_cli.core.validate_and_nondimensionalize_picslice (str source_slice, str dest_slice, float U_ref, tuple expected_dims=None)
	Validate a canonical PICSLICE payload and write a solver-scale copy.
str	picurv_cli.core._face_artifact_token (str face)
	Convert a BC face token into a filesystem-friendly artifact token.
str	picurv_cli.core._resolve_run_artifact_path (str run_dir, str configured_path, str default_path, bool default_to_config_dir=False)
	Resolve a run artifact path with run-dir-relative defaults.
str	picurv_cli.core._resolve_generator_script (str configured_script, str case_path, str default_name)
	Resolve an optional generator script override or repository default.
dict	picurv_cli.core._normalize_square_duct_poiseuille_params (params, str field_name)
	Validate square-duct Poiseuille generator parameters.
dict	picurv_cli.core._normalize_field_slice_source (source, str field_name)
	Validate a prescribed_flow field_slice source block.
dict	picurv_cli.core._normalize_field_slice_selector (slice_cfg, str field_name)
	Validate the field_slice slice selector.
dict	picurv_cli.core.generate_square_duct_poiseuille_picslice (str output_path, tuple dims, dict params, str target_grid=None, int target_block=0, str target_face=None, str script=None, str case_path=None)
	Generate a dimensional canonical PICSLICE for square-duct Poiseuille flow.
dict	picurv_cli.core.generate_field_slice_picslice (str output_path, tuple expected_dims, dict source, str target_grid, str target_face, int target_block, str case_path)
	Invoke profile.gen to extract a field_slice PICSLICE artifact.
str	picurv_cli.core._resolve_case_relative_path (str path_value, str case_dir)
	Resolve a path relative to the current case directory.
float	picurv_cli.core._resolve_field_slice_velocity_scale (dict source, str case_dir)
	Resolve field_slice dimensional velocity scale.
str	picurv_cli.core.resolve_target_grid_for_field_slice (dict case_cfg, str case_path, str run_dir)
	Resolve the target canonical PICGRID path needed for field_slice normals.
str	picurv_cli.core.resolve_target_grid_for_generated_profile (dict case_cfg, str case_path, str run_dir)
	Resolve the target canonical PICGRID for generated profile sampling.
str	picurv_cli.core.write_profile_info (str config_dir, list summaries)
	Write a profile.info summary for generated inlet profiles.
list	picurv_cli.core.validate_grid_generator_cli_args (cli_args, str case_path)
	Check closed-choice values inside the generator's opaque token list.
str	picurv_cli.core.run_grid_generator (str case_path, str run_dir, dict grid_cfg, dict case_cfg=None)
	Runs generators/grid.gen to produce a PICGRID file for this run.
dict	picurv_cli.core._normalize_prescribed_flow_source (source, str field_name)
	Validate the structured source block for prescribed_flow BCs.
tuple	picurv_cli.core._bc_profile_expected_dims (str face, tuple block_dims)
	Return expected PICSLICE dimensions for a face and block node dimensions.
list	picurv_cli.core.resolve_grid_block_dimensions_for_profiles (dict case_cfg, str case_path, str run_dir=None)
	Resolve per-block node dimensions for prescribed inlet profile validation.
list	picurv_cli.core.materialize_generated_prescribed_flow_profiles (str run_dir, dict case_cfg, str case_path, list profile_grid_dims=None)
	Generate dimensional PICSLICE artifacts for generated/field_slice prescribed_flow sources.
float	picurv_cli.core._to_float (value, str field_name)
	Convert a YAML scalar to float with a clear error message.
float	picurv_cli.core._to_finite_float (value, str field_name)
	Convert a non-boolean YAML scalar to a finite float.
bool	picurv_cli.core._to_bool (value, str field_name)
	Convert a YAML scalar/string to bool with a clear error message.
	picurv_cli.core.normalize_boundary_conditions_layout (all_blocks_bcs, int num_blocks)
	Normalize boundary_conditions to list-of-lists form and validate block count.
set	picurv_cli.core._les_periodic_axes (dict case_cfg)
	Reports which logical axes a case declares periodic on both faces.
	picurv_cli.core.validate_wall_model_pairing (dict case_cfg, les_cfg, wall_cfg, str case_path, list errors, list warnings)
	Rejects wall-model selections that no turbulence treatment can support.
	picurv_cli.core._case_reynolds_number (dict case_cfg)
	Reynolds number implied by a case's scaling and fluid properties.
	picurv_cli.core.validate_les_configuration (dict case_cfg, dict les_cfg, str case_path, list errors, list warnings)
	Checks the structured LES block for values the closure cannot honour.
	picurv_cli.core.validate_and_prepare_boundary_conditions (dict case_cfg)
	Validate BC entries against currently supported C-side handlers/types and.
str	picurv_cli.core._schema_path_text (tuple path)
	Render an internal schema path tuple as a user-facing YAML path.
	picurv_cli.core._lookup_allowed_schema_keys (dict schema, tuple path)
	Return allowed keys for a path, honoring '*' dynamic mapping entries.
str	picurv_cli.core._schema_key_hint (dict schema, tuple path, str key, set allowed)
	Build a concise typo or hierarchy hint for an unsupported YAML key.
None	picurv_cli.core._validate_yaml_schema_keys (cfg, dict schema, str file_path, list errors, tuple path=())
	Reject unsupported YAML keys before they can be silently ignored by staging.
dict	picurv_cli.core._ensemble_source_fields (str source)
	Return the field table an ensemble of one source names its fields from.
tuple	picurv_cli.core.input_quantity (tuple path)
	Return the (dimension, conversion site) recorded for one configuration input.
float	picurv_cli.core.reference_scale (tuple dimension, dict scales)
	Return the factor that turns a physical quantity of this dimension into solver units.
float	picurv_cli.core.input_reference_scale (tuple path, dict scales)
	Return the reference scale of one recorded input, for converting a whole payload.
	picurv_cli.core.quantity_to_solver_units (value, tuple quantity, dict scales, str label)
	Convert a physical value, or a list of them, by one recorded quantity entry.
	picurv_cli.core.to_solver_units (value, tuple path, dict scales)
	Convert one physical configuration value, or a list of them, to solver units.
dict	picurv_cli.core.resolve_reference_scales (dict case_cfg)
	Resolve the reference length and velocity (and density, when given) of a case.
str	picurv_cli.core.directory_value_charset_problem (str value)
	Describe why a directory value cannot be written to a PETSc options line.
str	picurv_cli.core.classify_run_directory_value (value)
	Classify a configured run directory value.
str	picurv_cli.core.normalized_run_directory (str value)
	Normalized, comparable form of a contained run directory value.
bool	picurv_cli.core.paths_overlap (str first, str second)
	Whether two run-relative directories are the same or nested in one another.
tuple	picurv_cli.core.resolve_unsafe_paths_override (dict dirs, str monitor_path)
	Resolve the unsafe-paths override, requiring a real YAML boolean.
tuple	picurv_cli.core.evaluate_run_directories (dict values, bool override, set explicit=None)
	Apply every run-directory safety rule to a set of effective directory values.
list	picurv_cli.core.classify_physical_containment (str run_dir, dict values)
	Classify where each run-owned directory physically lands.
list	picurv_cli.core.check_physical_containment (str run_dir, dict values)
	Human-readable physical containment violations.
dict	picurv_cli.core.effective_run_directories (dict configured)
	Fill in defaults for run-owned directories that were not configured.
tuple	picurv_cli.core.validate_run_directory_containment (dict monitor_cfg, str monitor_path)
	Classify legacy directory values as defense-in-depth during validation.
list	picurv_cli.core.validate_reserved_directory_flags (dict config, str config_path, str label)
	Reject raw PETSc passthrough options that set run-owned directories.
list	picurv_cli.core.physical_units_transition_notices (dict case_cfg, dict solver_cfg, dict monitor_cfg)
	Name the inputs whose meaning changed when every input became physical.
	picurv_cli.core.validate_simulation_configs (dict case_cfg, dict solver_cfg, dict monitor_cfg, str case_path, str solver_path, str monitor_path, bool restart_source_given=False)
	Validates every configuration a simulation run consumes, before any work is done.
"tuple[list, list]"	picurv_cli.core.check_post_checkpoint_cadence_alignment (dict post_cfg, dict monitor_cfg, str post_path, str monitor_path="monitor.yml")
	Report post step selections that cannot land on a committed checkpoint.
	picurv_cli.core.validate_post_config (dict post_cfg, str post_path, dict monitor_cfg=None, dict case_cfg=None)
	Validates the post-processing config before running the post-processor.
	picurv_cli.core.validate_cluster_config (dict cluster_cfg, str cluster_path)
	Validate Slurm scheduler configuration from cluster.yml.
	picurv_cli.core.validate_study_config (dict study_cfg, str study_path, bool skip_base_file_check=False)
	Validate sweep/study specification from study.yml.
	picurv_cli.core._deep_set (dict container, str dotted_path, value)
	Set nested dictionary value, creating intermediate maps when needed.
list	picurv_cli.core.expand_parameter_matrix (dict parameters)
	Expand study parameter lists into cartesian-product combinations.
list	picurv_cli.core.expand_study_parameter_combinations (dict study_cfg)
	Expand either cartesian-study parameters or explicit parameter sets.
dict	picurv_cli.core.flatten_study_parameters (dict parameters)
	Flatten grouped study overrides into scalar dotted-path columns.
list	picurv_cli.core.get_study_parameter_keys (dict study_cfg)
	Collect ordered parameter keys from either cross-product parameter expansions or explicit parameter sets.
int	picurv_cli.core.get_cluster_total_tasks (dict cluster_cfg)
	Return cluster total tasks.
str	picurv_cli.core.normalize_extension (str ext)
	Canonicalize a user-supplied filename extension by trimming whitespace and leading dots.
list	picurv_cli.core.resolve_conductor_entry_point ()
	Resolve how to invoke this conductor again from a batch script.
list	picurv_cli.core.build_spectra_follow_command (str run_dir, str post_path, dict post_cfg, bool recompute=False)
	Build the batch-script step that measures spectra after the field stage.
"str | None"	picurv_cli.core.executable_petsc_library_dir (str executable_path)
	The lib/ directory of the PETSc an executable was built against, from its stamp.
list	picurv_cli.core.petsc_library_path_lines ("str | None" library_dir)
	Shell lines putting one PETSc's lib/ first on LD_LIBRARY_PATH, after module setup.
list	picurv_cli.core.executable_identity_check_lines (str executable, "str | None" expected_version_line, bool pinned=False)
	Shell lines that compare an executable's reported identity with the staged one.
	picurv_cli.core.render_slurm_script (str script_path, str job_name, dict cluster_cfg, list command, str workdir, str stdout_path, str stderr_path=None, dict env_vars=None, dict shell_env_vars=None, str array_spec=None, list follow_commands=None, "tuple | None" identity_check=None)
	Render a Slurm batch script for a single command.
"tuple[str | None, list[str]]"	picurv_cli.core.split_launcher_tokens ("str | None" launcher, "list | None" launcher_args=None, str label="launcher")
	Canonicalize launcher config into executable token plus argv-style flags.
"tuple[str | None, list[str]]"	picurv_cli.core.normalize_cluster_launcher (dict execution)
	Canonicalize cluster launcher config into executable token plus argv-style flags.
"list[str]"	picurv_cli.core.strip_launcher_size_flags (str launcher_name, "list[str]" launcher_args)
	Remove explicit MPI task-count flags from known launchers.
list	picurv_cli.core.build_local_launch_command (str executable, list executable_args, int num_procs, str config_search_anchor=None, bool allow_single_rank_launcher_override=False, "int | None" force_num_procs=None)
	Build local launcher command, allowing env or shared config overrides for login-node MPI quirks.
dict	picurv_cli.core.restart_grid_inputs (str run_dir, dict case_cfg)
	The inputs a run's geometry is derived from, to compare across a restart.
	picurv_cli.core.warn_on_restart_grid_change (dict source_inputs, dict branch_inputs)
	Warn at staging when a restart's grid inputs differ from its source run's.
	picurv_cli.core.check_restart_continuation (str solver_exe, list solver_args, str run_dir, str config_search_anchor=None)
	Ask the simulator whether a staged restart's carried statistics windows can continue.
dict	picurv_cli.core.resolve_cluster_execution (dict cluster_cfg, str config_search_anchor=None, extra_search_anchors=None)
	Resolve cluster execution launcher settings from shared runtime config plus cluster.yml overrides.
list	picurv_cli.core.build_cluster_launch_command (dict cluster_cfg, str executable, list executable_args, str config_search_anchor=None, extra_search_anchors=None, "int | None" force_num_procs=None)
	Build scheduler launcher command from cluster config plus optional shared execution defaults.
str	picurv_cli.core.parse_slurm_job_id (str sbatch_output)
	Extract numeric job id from standard sbatch output.
"tuple[str, str | None]"	picurv_cli.core.slurm_job_end_state (str job_id)
	Whether a recorded Slurm job (or array) is still queued, and how it ended if not.
dict	picurv_cli.core.submit_sbatch (str script_path, str dependency=None, str dependency_type="afterok")
	Submit sbatch script and return submission metadata.
	picurv_cli.core._print_validation_errors (list errors)
	Prints validation errors and exits.
str	picurv_cli.core.generate_header (str run_id, dict source_files)
	Creates a standard header block for all generated files.
str	picurv_cli.core.generate_simple_list_file (str run_dir, str run_id, dict cfg, str section, str key, str filename, dict header_sources, str config_dir=None)
	Generic function to create a file containing a simple list of strings.
list	picurv_cli.core.normalize_monitor_function_names (list names, str field_name)
	Translate renamed solver functions in a monitor.yml function list.
bool	picurv_cli.core.has_explicit_monitor_whitelist (dict monitor_cfg)
	Return True when logging.enabled_functions contains at least one entry.
dict	picurv_cli.core.resolve_profiling_config (dict monitor_cfg)
	Resolve profiling reporting config from monitor.yml.
dict	picurv_cli.core._diagnostic_info (value)
	Validate PETSc info logging configuration.
	picurv_cli.core._diagnostic_bool_or_path (value, str key)
	Validate a diagnostics value that can be false, true, or a path/viewer string.
bool	picurv_cli.core._diagnostic_bool (value, str key)
	Validate a diagnostics boolean value.
	picurv_cli.core._diagnostic_bool_or_all (value, str key)
	Validate a diagnostics value that can be false, true, or "all".
str	picurv_cli.core._diagnostic_default_file (str run_dir, str filename)
	Return an absolute run-local diagnostics file path.
	picurv_cli.core._diagnostic_resolve_path_or_default (value, str run_dir, str default_filename)
	Resolve true/string diagnostics values to a concrete file path.
dict	picurv_cli.core.resolve_diagnostics_config (dict monitor_cfg, "str | None" run_dir=None, str stage_label="Solver")
	Resolve monitor diagnostics config and default run-local log paths.
list	picurv_cli.core.build_petsc_diagnostics_args (dict monitor_cfg, str run_dir, str stage_label)
	Build PETSc diagnostics command-line arguments for a run stage.
bool	picurv_cli.core._statistics_subsystem_available (dict case_cfg, requirement)
	Report whether the subsystem a statistics field depends on is active.
dict	picurv_cli.core.normalize_field_statistics_config (dict monitor_cfg, dict case_cfg=None)
	Validate and canonicalize the field-statistics block of monitor.yml.
	picurv_cli.core._normalize_statistics_requests (str label, fields_raw, covariances_raw, dict eligible, case_cfg=None)
	Validate and canonicalize the fields and covariances one window or ensemble requests.
list	picurv_cli.core.resolve_field_statistics_flags (dict monitor_cfg, dict case_cfg=None)
	Serialize field-statistics configuration into control-file option lines.
"int | None"	picurv_cli.core.resolve_statistics_console_output_frequency (dict io_cfg)
	Resolve the statistics console cadence, mirroring the particle one.
dict	picurv_cli.core.normalize_solution_monitoring_config (dict monitor_cfg)
	Validate and canonicalize physical-solution convergence monitoring.
dict	picurv_cli.core.resolve_solution_monitoring_flags (dict monitor_cfg)
	Translate solution-monitoring YAML into the existing C convergence flags.
dict	picurv_cli.core.prepare_monitor_files (str run_dir, str run_id, dict monitor_cfg, dict source_files, str config_dir=None)
	Generate monitor sidecar files and resolve profiling reporting behavior.
list	picurv_cli.core.generate_multi_block_bcs (str run_dir, str run_id, dict case_cfg, dict source_files, str config_dir=None)
	Parses multi-block BCs from YAML, generates a .run file for each block, and returns a list of their absolute paths.
	picurv_cli.core.format_flag_value (value)
	Converts Python types to C-style command-line flag values.
dict	picurv_cli.core.translate_programmatic_grid_settings (dict grid_settings)
	Return programmatic-grid settings translated to the C node-count contract.
None	picurv_cli.core.validate_programmatic_bridge_grid_settings (dict raw_settings)
	Validate the scalar programmatic grid settings the bridge PICGRID is built from.
dict	picurv_cli.core.generate_picgrid_from_programmatic_settings (dict raw_settings, str dest_path, float L_ref)
	Generate a canonical PICGRID file from programmatic Cartesian grid settings.
dict	picurv_cli.core.resolve_grid_da_processor_layout (dict grid_cfg)
	Resolve optional global DMDA layout, preferring grid-level keys over legacy nested keys.
"list | None"	picurv_cli.core.resolve_grid_node_dims (dict case_cfg, str case_path, "str | None" staged_grid=None)
	Per-block (IM, JM, KM) node counts the solver will read, without building the grid.
bool	picurv_cli.core.case_declares_periodic_axis (dict case_cfg)
	Whether any face of any block is PERIODIC, which sets the DMDA stencil width.
list	picurv_cli.core.da_processor_layout_problems (dict grid_cfg, "int | None" num_procs, "list | None" block_dims=None, "dict | None" solver_cfg=None, bool any_periodic=False, "str | None" source=None)
	Problems with a user-set DMDA layout that would abort grid setup.
None	picurv_cli.core.normalize_decomposition_args (args)
	Resolve -n and the optional --ni/--nj/--nk of picurv run into one rank count.
dict	picurv_cli.core._decomposition_layout (layout)
	Express an (ni, nj, nk) tuple as the da_processors mapping the layout checks read.
	picurv_cli.core.choose_decomposition (int num_procs, list block_dims, "dict | None" solver_cfg, bool any_periodic)
	Choose the MPI decomposition of a structured grid for a rank count.
dict	picurv_cli.core.resolve_decomposition (int num_procs, dict grid_cfg, "list | None" block_dims, "dict | None" solver_cfg, bool any_periodic, explicit=None, "dict | None" cluster_cfg=None)
	Resolve the MPI decomposition a stage launches with.
"dict | None"	picurv_cli.core._decomposition_record ("dict | None" resolved)
	The JSON-serializable record of a resolved decomposition for run metadata.
str	picurv_cli.core.describe_decomposition (dict resolved, int num_procs)
	One line stating the decomposition a stage launches with.
dict	picurv_cli.core.append_grid_da_processor_layout (list control_lines, dict grid_cfg, int num_procs, "list | None" block_dims=None, "dict | None" solver_cfg=None, bool any_periodic=False, explicit=None, "dict | None" cluster_cfg=None)
	Resolve the solver's MPI decomposition, report it, and append its flags.
str	picurv_cli.core.normalize_momentum_solver_type (str value)
	Maps canonical user-facing momentum solver names to C-enum CLI values.
dict	picurv_cli.core.validate_newton_krylov_config (dict cfg)
	Validate and normalize the structured Newton–Krylov solver block.
str	picurv_cli.core.normalize_solution_convergence_mode (str value)
	Normalizes the solution-convergence mode selector to the C-side canonical string.
int	picurv_cli.core.normalize_field_init_mode (str value)
	Maps canonical field init mode names to C enum/int codes (-finit).
"tuple[str, int]"	picurv_cli.core.normalize_initial_condition_field (str value)
	Normalize a file IC field selector to its staged basename and C enum value.
dict	picurv_cli.core.resolve_ic_payload_provenance (dict ic, int field_code)
	Resolve which scales a file-backed initial condition was written in.
float	picurv_cli.core.ic_payload_divisor (dict resolved_ic, str case_dir)
	Return the factor a file-backed initial condition is divided by when staged.
bool	picurv_cli.core.is_generated_ic_provider (dict resolved_ic)
	Return whether a resolved IC is backed by a registered file generator.
dict	picurv_cli.core.resolve_fluid_scaling (dict case_cfg)
	Resolve the shared physical and nondimensional fluid scaling contract.
	picurv_cli.core.load_generator_module (str script_name, str module_name)
	Load one of the extensionless scripts under generators/ as a module.
	picurv_cli.core.load_ic_generator_module ()
	Load generators/ic.gen, which owns the expression language and the IC providers.
list	picurv_cli.core.normalize_particle_fields (fields_cfg)
	Validate models.physics.particles.fields and lower each value to expressions.
dict	picurv_cli.core.ic_provider_params_to_solver_units (str generator, dict params, dict scales)
	Convert a provider's validated physical parameters to solver units.
dict	picurv_cli.core.resolve_resampled_velocity_params (dict params, prepared_blocks, dict scales, provider_context=None)
	Validate resampled_velocity parameters and convert them to the provider contract.
	picurv_cli.core.normalize_ic_initial_spectra (requested, excluded_axes, generator, required)
	Validate the spectra a structured IC provider measures on its own output.
dict	picurv_cli.core.resolve_initial_condition_config (dict ic, prepared_blocks, dict scales, provider_context=None)
	Resolve legacy and structured initial-condition YAML into one launcher contract.
int	picurv_cli.core.runtime_petsc_index_bytes ()
	Bytes of a PetscInt in the PETSc the solver this conductor drives was built on.
"int | None"	picurv_cli.core.requested_petsc_index_bytes (args=None)
	The index width a command was told to use: --petsc-index-bits, else PICURV_PETSC_INDEX_BITS.
"tuple[int, str]"	picurv_cli.core.required_petsc_index_bytes (dict case_cfg, str case_path, "dict | None" monitor_cfg, "str | None" staged_grid=None)
	The PetscInt width a new run needs, from its particle count and grid size.
"int | None"	picurv_cli.core.checkpoint_source_petsc_index_bytes (str source_dir)
	PetscInt width the committed checkpoints under a run output root were written with.
int	picurv_cli.core.select_petsc_index_bytes (int index_bytes, str reason)
	Make the current command drive the build of one PetscInt width.
int	picurv_cli.core.select_run_petsc_index_bytes (args, dict case_cfg, str case_path, "dict | None" monitor_cfg, "str | None" restart_source_dir=None)
	Choose and select the PetscInt width a run's solve stage needs.
int	picurv_cli.core.select_existing_run_petsc_index_bytes (str run_dir, args=None)
	Select the PetscInt width an existing run was staged with, for its later stages.
None	picurv_cli.core.record_run_petsc_index_bytes (str run_dir)
	Record in config/active.json the PetscInt width the current command selected.
int	picurv_cli.core.payload_petsc_index_bytes (str path)
	PetscInt width of a PETSc payload: as its checkpoint recorded it, else the driven solver's.
list	picurv_cli.core.petsc_index_arguments (int index_bytes)
	Generator arguments naming a PetscInt width; none for PETSc's default 32-bit.
dict	picurv_cli.core.validate_petsc_vec_binary (str path, "int | None" index_bytes=None)
	Validate the basic PETSc binary VecView envelope used by ReadFieldData.
dict	picurv_cli.core.write_scaled_petsc_vec_binary (str source, str destination, float divisor)
	Copy a PETSc binary Vec, dividing every scalar by one factor.
	picurv_cli.core.initial_condition_diagnostic_paths (run_dir, resolved_ic)
	Resolve spectral IC artifacts through the canonical run layout, also for dry runs.
str	picurv_cli.core.run_initial_spectrum_generator (str field_path, str staged_grid, str spectrum_path, str case_dir, task_cfg=None)
	Measure the shell-averaged spectrum of a staged initial condition.
str	picurv_cli.core.run_initial_condition_generator (str case_path, str run_dir, dict resolved_ic)
	Run the repository IC generator.
None	picurv_cli.core._check_file_ic_matches_grid (dict payload, str staged_grid, dict resolved_ic)
	Refuse a mode: file payload sized for another grid, and say what imports one.
dict	picurv_cli.core.stage_initial_condition_file (str run_dir, str case_path, dict resolved_ic)
	Materialize and stage one file-backed IC in ReadFieldData's expected layout.
int	picurv_cli.core.normalize_flow_direction_token (str value)
	Maps a face-token flow direction string to the C FlowDirection enum integer.
bool	picurv_cli.core._ic_has_inlet (prepared_blocks)
	Return True if any prepared BC block contains an INLET face.
dict	picurv_cli.core.resolve_ic_cli_params (dict ic, int finit_code, prepared_blocks, dict scales)
	Resolve all IC parameters and return a dict of PETSc option values.
str	picurv_cli.core.normalize_eulerian_field_source (str value)
	Normalizes the Eulerian field source selector to the C-side canonical string.
bool	picurv_cli.core.initial_condition_is_authoritative (dict case_cfg, dict solver_cfg)
	Whether the configured initial condition is the field the solver starts from.
tuple	picurv_cli.core.unused_asset_kinds (dict case_cfg, dict solver_cfg)
	Asset kinds a run with these configurations would build but never read.
str	picurv_cli.core.normalize_analytical_type (str value)
	Normalizes the analytical solution selector to the C-side canonical string.
"tuple[float, float, float]"	picurv_cli.core.parse_initial_velocity_components (dict initial_conditions, int finit_code, *bool require_explicit)
	Parse initial-condition velocity components with mode-aware defaults.
"str | None"	picurv_cli.core.infer_unique_inlet_axis_from_prepared_bcs (list prepared_blocks)
	Infer the unique inlet axis across all blocks using C-side "primary inlet" ordering.
int	picurv_cli.core.normalize_particle_init_mode (str value)
	Maps canonical particle init mode names to C enum/int codes (-pinit).
int	picurv_cli.core.normalize_interpolation_method (str value)
	Maps interpolation method names to C enum/int codes (-interpolation_method).
int	picurv_cli.core.normalize_les_model (value)
	Maps LES model selectors to C enum/int codes (-les).
int	picurv_cli.core.normalize_les_test_filter (value)
	Maps LES test-filter kernel names to the C -les_test_filter_kernel flag.
int	picurv_cli.core.normalize_les_filter_width (value)
	Maps LES grid-filter-width model names to the C -les_filter_width flag.
int	picurv_cli.core.normalize_les_averaging_mode (value)
	Maps LES coefficient-averaging mode names to the C -les_averaging_mode flag.
int	picurv_cli.core.normalize_les_clip_mode (value)
	Maps LES coefficient-limiting mode names to the C -les_clip_mode flag.
str	picurv_cli.core.normalize_les_averaging_directions (value)
	Maps a list of homogeneous logical directions to the C flag's string form.
int	picurv_cli.core.normalize_wall_function_model (value)
	Maps wall-function model selectors to the C -wallfunction flag.
bool	picurv_cli.core.resolve_enabled_flag (dict cfg, str path, bool default=True)
	Resolves a structured enabled flag and rejects non-boolean values.
	picurv_cli.core.append_les_parameter_flags (dict les_cfg, list control_lines)
	Appends the LES closure parameter flags from a structured les block.
"dict | None"	picurv_cli.core.resolve_les_diagnostics (dict case_cfg, dict monitor_cfg, bool warn=False)
	Resolve the LES diagnostic log settings from monitor.yml or their deprecated location.
	picurv_cli.core.append_les_diagnostics_flags ("dict | None" diagnostics, list control_lines)
	Append the LES diagnostic log flags resolved by resolve_les_diagnostics().
	picurv_cli.core.append_turbulence_flags (dict models, list control_lines, dict scales=None)
	Appends turbulence model flags from legacy or structured case.yml blocks.
	picurv_cli.core.control_value (value, str context)
	Guard a value that is written verbatim into the generated control file.
	picurv_cli.core.append_passthrough_flags (list control_lines, dict options)
	Appends raw CLI flags to the control list from a {flag: value} dict.
dict	picurv_cli.core.resolve_solver_monitoring_flags (dict monitor_cfg)
	Resolve human-readable solver monitoring YAML to raw control flags.
list	picurv_cli.core.resolve_traced_particle_ids (dict monitor_cfg)
	Return the sorted, distinct particle IDs of logging.trace_particles.
"int | None"	picurv_cli.core.resolve_particle_console_output_frequency (dict io_cfg)
	Return the effective particle-console snapshot cadence from monitor.yml.
	picurv_cli.core.parse_and_add_model_flags (dict case_cfg, list control_lines)
	Parses the 'models' section of case.yml and adds corresponding C-solver flags.
dict	picurv_cli.core.parse_solver_config (dict solver_cfg, dict scales=None, dict case_cfg=None)
	Parses the structured solver.yml into a flat dictionary of {flag: value}.
	picurv_cli.core.generate_solver_control_file (run_dir, run_id, configs, num_procs, monitor_files, restart_source_dir=None, continue_mode=False, str config_dir=None)
	Generates the main .control file for the C-solver.
dict	picurv_cli.core.resolve_post_decomposition (str run_dir, int num_procs, explicit=None, "dict | None" cluster_cfg=None)
	Resolve the postprocessor's MPI decomposition from the run's staged configuration.
str	picurv_cli.core.generate_post_recipe_file (str run_dir, str run_id, dict post_cfg, dict source_files, monitor_cfg=None, "dict | None" decomposition=None)
	Generates a key=value config file (post.run) for the C post-processor.
	picurv_cli.core.execute_command (list command, str run_dir, str log_filename, dict monitor_cfg=None)
	Executes a command, streaming its output to the console and a log file.
str	picurv_cli.core.format_command_for_display (list command)
	Render a shell-safe command string for console and log output.
str	picurv_cli.core.resolve_command_log_path (str run_dir, str log_filename)
	Resolve a command log filename relative to the run directory.
subprocess.CompletedProcess	picurv_cli.core._run_captured_command (list command, str run_dir)
	Run a command and capture combined stdout/stderr details for later inspection.
	picurv_cli.core._require_successful_command (list command, subprocess.CompletedProcess result)
	Raise CommandExecutionError when a captured command failed.
str	picurv_cli.core._capture_command_stdout (list command, str run_dir)
	Run a command, require success, and return stripped stdout text.
	picurv_cli.core._stream_command_to_console_and_log (list command, str run_dir, log_file)
	Stream command output to stdout and an already-open log file.
dict	picurv_cli.core._get_git_head_state (str run_dir)
	Capture the current git HEAD branch name and commit hash.
"list[tuple[str, str | None]]"	picurv_cli.core._get_local_branches_with_upstreams (str run_dir)
	Return local branch names plus their configured upstreams.
bool	picurv_cli.core._working_tree_has_tracked_changes (str run_dir)
	Return True when the repository has staged or unstaged tracked changes.
	picurv_cli.core._attempt_pull_cleanup (str run_dir, bool rebase, log_file)
	Best-effort cleanup after a failed git pull so the original branch can be restored.
	picurv_cli.core._restore_git_head (str run_dir, dict original_head, log_file)
	Restore the repository back to the branch or detached commit it started on.
None	picurv_cli.core._refuse_detached_source_checkout (str source_project_root, str action)
	Refuse a branch pull when the source checkout is pinned to a detached commit.
	picurv_cli.core.pull_all_source_branches (str run_dir, str log_filename, bool rebase=True)
	Refresh every local tracking branch in the source repository, then restore the starting branch.
	picurv_cli.core.auto_identify_run_inputs (str config_dir)
	Auto-detect case.yml, monitor.yml, and *.control in a run config directory.
str	picurv_cli.core.resolve_post_source_directory (str run_dir, dict monitor_cfg, dict post_cfg, bool strict=True)
	Resolve post source directory token and optionally enforce existence.
	picurv_cli.core.render_slurm_array_stage_script (str script_path, str job_name, dict cluster_cfg, str array_spec, str case_index_tsv, str stage, str solver_exe, str post_exe, str stdout_path, str stderr_path, "str | None" expected_version_line=None)
	Render array script that maps SLURM_ARRAY_TASK_ID to per-case run artifacts.
	picurv_cli.core.render_metrics_aggregate_script (str script_path, str job_name, dict cluster_cfg, str study_dir, str picurv_path)
	Generate a single-node sbatch script that runs metrics aggregation.
	picurv_cli.core.reduce_metric_values (values, str reduction)
	Reduce a metric series to one scalar according to the requested reducer.
	picurv_cli.core.extract_metric_from_csv (str case_dir, dict spec)
	Extract a scalar metric from a CSV source.
	picurv_cli.core.extract_metric_from_log (str case_dir, dict spec)
	Extract a scalar metric from a log file using regex.
	picurv_cli.core.normalize_metric_spec (metric)
	Normalize study metric definitions to a common dictionary form.
dict	picurv_cli.core._read_previous_metric_rows (str results_dir)
	Read the metrics table an earlier aggregation wrote, keyed by case id.
str	picurv_cli.core.aggregate_study_metrics (dict study_cfg, list cases, str results_dir)
	Collect metric values from generated case directories into one CSV.
str	picurv_cli.core._study_parameter_label (str key)
	Return a concise report label for a study parameter path.
str	picurv_cli.core._study_metric_label (dict study_cfg, str metric)
	Resolve an optional configured metric label or humanize its name.
"list | None"	picurv_cli.core._numeric_study_column (list rows, str key)
	Parse one complete, finite numeric study-table column.
"dict | None"	picurv_cli.core._infer_study_plot_axis (dict study_cfg, list rows)
	Infer the scientifically meaningful independent variable of a study.
	picurv_cli.core.infer_plot_x_axis (dict study_cfg, list rows)
	Infer x-axis key/values for study plots.
str	picurv_cli.core._format_study_group_value (value)
	Format a secondary study parameter compactly for a legend.
list	picurv_cli.core._study_plot_groups (dict study_cfg, list rows, dict axis, str metric)
	Group metric points by any secondary varied study parameters.
bool	picurv_cli.core._study_use_log_scale (list values, bool semantic_hint=False)
	Use log scaling only for positive data spanning a meaningful range.
"tuple[float, float] | None"	picurv_cli.core._study_linear_y_limits (list values)
	Build padded linear limits that include zero for non-negative metrics.
	picurv_cli.core.generate_study_plots (dict study_cfg, str metrics_csv, str plots_dir)
	Generate metric-vs-parameter plots for completed studies.
str	picurv_cli.core._command_to_string (list command_tokens)
	Render a command list as a shell-safe display string.
str	picurv_cli.core._resolve_post_source_directory_preview (str run_dir, dict monitor_cfg, dict post_cfg)
	Resolve post source directory without side effects or stdout/stderr output.
dict	picurv_cli.core.build_run_dry_plan (args)
	Build a no-write execution plan for run --dry-run.
None	picurv_cli.core.add_planned_grid_artifacts (dict plan, dict case_cfg, str run_dir)
	Add grid-mode-specific staged artifacts to a dry-run plan.
None	picurv_cli.core.add_planned_profile_artifacts (dict plan, dict case_cfg, str run_dir)
	Add generated prescribed-flow profile artifacts to a dry-run plan.
None	picurv_cli.core.add_planned_initial_condition_artifacts (dict plan, dict case_cfg, dict solver_cfg, str run_dir)
	Add authoritative file-backed initial-condition artifacts to a dry-run plan.
	picurv_cli.core.render_run_dry_plan (dict plan, str output_format="text")
	Render dry-run plan in human or JSON format.
	picurv_cli.core.validate_workflow (args)
	Implements picurv validate without launching solver/post workflows.
str	picurv_cli.core._asset_file_sha256 (str path)
	Hash an asset source or payload without loading it into memory.
str	picurv_cli.core._stable_mapping_sha256 (payload)
	Hash a JSON-compatible value with deterministic serialization.
dict	picurv_cli.core._provider_source_fingerprints (value, str case_path, str key="")
	Hash every existing file explicitly referenced by an asset provider.
dict	picurv_cli.core.build_case_asset_graph (dict case_cfg, str case_path)
	Classify case inputs into precomputable or simulator-runtime providers.
list	picurv_cli.core._asset_selection (dict graph, requested=None, *bool precomputable_only=False)
	Resolve requested asset kinds plus dependency closure.
list	picurv_cli.core._asset_payload_files (str build_root, str kind)
	Enumerate canonical files belonging to one asset kind in a build tree.
dict	picurv_cli.core._build_selected_asset_payloads (str build_root, dict case_cfg, str case_path, list selected)
	Execute existing generators into one isolated run-like build tree.
dict	picurv_cli.core._picgrid_geometry_summary (str path)
	Read a canonical PICGRID and summarize what a user would want to check.
bool	picurv_cli.core._write_structured_grid_preview (str picgrid_path, str destination, dims)
	Write a single-block ASCII VTS preview of a staged PICGRID.
dict	picurv_cli.core._build_asset_inspection (str kind, str build_root, dict provider, list payload_files)
	Produce the inspection material published beside an asset's payload.
dict	picurv_cli.core._publish_asset_object (str workspace_root, str build_root, dict provider, list payload_files)
	Publish one immutable content-addressed asset object atomically.
str	picurv_cli.core._workspace_asset_set_name (str workspace_root, str case_path)
	Return a collision-free, readable mutable asset-set name.
str	picurv_cli.core._write_workspace_asset_set (str workspace_root, str case_path, dict graph, dict references)
	Atomically update the named asset set and workspace asset catalog.
dict	picurv_cli.core.precompute_case_assets (str workspace_root, dict case_cfg, str case_path, requested=None, bool precomputable_only=False)
	Build and publish a selected deterministic asset dependency closure.
str	picurv_cli.core._workspace_asset_set_path (str workspace_root, str case_path)
	Return the mutable asset-set pointer associated with a case config name.
	picurv_cli.core._find_stored_asset (str workspace_root, dict provider)
	Find a published object built from exactly this provider's inputs.
dict	picurv_cli.core.plan_run_assets (dict case_cfg, str case_path, skip_kinds=())
	Plan reuse/build/runtime actions for all configured run providers.
str	picurv_cli.core._materialize_asset_file (str source, str destination)
	Expose one immutable shared-asset file through reflink, hardlink, or copy.
dict	picurv_cli.core.materialize_run_assets (str run_dir, dict case_cfg, str case_path, bool require_precomputed=False, bool fetch_missing=False, skip_kinds=())
	Resolve/build workspace assets and write the exact run input lock.
	picurv_cli.core.precompute_workflow (args)
	Resolve, preflight, and atomically publish reusable workspace assets.
	picurv_cli.core.run_workflow (args)
	Main orchestrator for the 'run' command (local and Slurm modes).
list	picurv_cli.core.parse_case_index_tsv (str tsv_path)
	Parse a case_index.tsv file back into a list of case entry dicts.
dict	picurv_cli.core.resolve_sweep_stage_executables (list run_dirs)
	Choose the executables an array stage launches for every member of a study.
	picurv_cli.core.sweep_workflow (args)
	Study/sweep orchestration using Slurm job arrays.
	picurv_cli.core.sweep_continue_workflow (args)
	Continue a partially-completed Slurm parameter sweep study.
	picurv_cli.core.sweep_reaggregate_workflow (args)
	Re-run metrics aggregation and plot generation for an existing study.
	picurv_cli.core._read_yaml_if_exists (str filepath)
	Read YAML when present, otherwise return None.
	picurv_cli.core._read_json_if_exists (str filepath)
	Read JSON when present, otherwise return None.
	picurv_cli.core._parse_int_loose (value)
	Best-effort integer parsing for summary extraction.
	picurv_cli.core._parse_float_loose (value)
	Best-effort float parsing for summary extraction.
	picurv_cli.core._extract_numeric_tuple (str text)
	Extract a numeric tuple from a string like '(1, 2, 3)'.
dict	picurv_cli.core._build_summary_context (str run_dir)
	Resolve run-local config and artifact paths for summarize.
dict	picurv_cli.core._require_summary_config (dict context, str name)
	Return one explicitly requested copied config or fail with a structured error.
dict	picurv_cli.core._build_run_overview (dict context)
	Build timestep-independent run metadata for summarize.
dict	picurv_cli.core._summarize_turbulence (dict turbulence_cfg)
	Build compact turbulence and wall-model selections.
dict	picurv_cli.core._build_case_overview (dict context)
	Build a curated case.yml summary with useful derived quantities.
dict	picurv_cli.core._summary_scalar_transport (dict context, dict solver_cfg)
	Scalar-transport parameters as the run resolves them, wherever they are set.
dict	picurv_cli.core._build_solver_overview (dict context)
	Build a curated solver.yml summary with normalized selections.
dict	picurv_cli.core._build_monitor_overview (dict context)
	Build a curated monitor.yml summary with resolved defaults.
"tuple[dict, list[int]]"	picurv_cli.core._parse_continuity_metrics_log (str log_dir)
	Read the continuity record into rows by step (one per block) plus observed order.
"tuple[dict, list[int]]"	picurv_cli.core._parse_particle_metrics_log (str log_dir, str metrics_dir)
	Read the per-step particle record into rows by step plus observed order.
"tuple[dict, dict, list[int]]"	picurv_cli.core._parse_momentum_convergence_logs (str log_dir)
	Read the per-block momentum records (Picard history, Newton summary) into rows by step.
"tuple[dict, dict, list[int]]"	picurv_cli.core._parse_poisson_convergence_logs (str log_dir)
	Read the per-block Poisson histories into each step's last iteration.
"tuple[dict, list[int]]"	picurv_cli.core._parse_profiling_timestep_csv (str filepath)
	Parse profiling timestep CSV into latest rows by step plus observed order.
"tuple[dict, list[int], dict]"	picurv_cli.core._parse_runtime_memory_log (str filepath)
	Read the runtime memory record into rows by step and its final status.
"tuple[dict, list[int]]"	picurv_cli.core._parse_solution_convergence_log (str log_dir)
	Read the solution-convergence record into rows by step plus observed order.
"list[str]"	picurv_cli.core._find_solver_stream_log_candidates (str run_dir, str log_dir)
	Return plausible solver stream logs for local and Slurm runs.
dict	picurv_cli.core._parse_particle_snapshot_file (str filepath)
	Parse sampled particle snapshots from a solver stream log.
"int | None"	picurv_cli.core._find_previous_snapshot_step ("list[int]" snapshot_steps, int step)
	Return the nearest earlier snapshot step when available.
dict	picurv_cli.core._compute_particle_snapshot_delta ("list[dict]" current_rows, "list[dict]" previous_rows)
	Compute sampled deltas between two particle snapshot samples.
dict	picurv_cli.core._build_particle_snapshot_summary (str source, int step, "list[dict]" rows, int preview_rows, particle_console_output_freq, particle_log_interval, "int | None" previous_step=None, "list[dict] | None" previous_rows=None)
	Build sampled diagnostics for one particle console snapshot.
dict	picurv_cli.core._find_particle_snapshot_for_step (str run_dir, str log_dir, int step, int preview_rows, particle_console_output_freq, particle_log_interval)
	Locate and summarize a particle console snapshot for one step.
	picurv_cli.core._resolve_summary_step (requested_step, continuity_rows, particle_rows, momentum_rows, poisson_rows, profiling_rows, memory_rows=None, convergence_rows=None, step_orders=None, str selection_mode="latest")
	Select a step to summarize from available metric artifacts.
str	picurv_cli.core._format_summary_float (value, str spec=".6e", str missing="n/a")
	Format optional numeric values for summary text output.
float	picurv_cli.core._summary_source_mtime (paths)
	Return the newest modification time among one or more summary sources.
"list[list[int]]"	picurv_cli.core._order_summary_step_orders ("list[tuple[list[int], object]]" sources)
	Order observed step sequences by the recency of their source files.
dict	picurv_cli.core.build_run_summary_payload (str run_dir, "int | None" step=None, int snapshot_rows=5, str selection_mode="latest")
	Build a read-only run-step summary from existing PICurv artifacts.
	picurv_cli.core.render_run_summary (dict payload, str output_format="text")
	Render a run-step summary in human or JSON form.
str	picurv_cli.core._summary_display_value (value)
	Format one configuration-summary value for compact text output.
	picurv_cli.core._print_config_header (str title, "str | None" subtitle=None)
	Print a strong dashboard-style configuration summary header.
	picurv_cli.core._print_config_group (str title, list rows)
	Print an aligned configuration-summary field group.
list	picurv_cli.core._flatten_summary_mapping (dict mapping, str prefix="")
	Flatten nested summary mappings into readable dotted field rows.
	picurv_cli.core._render_run_overview_text (dict summary)
	Render run metadata as a compact dashboard.
	picurv_cli.core._render_case_summary_text (dict summary)
	Render the case summary as a glanceable simulation dashboard.
	picurv_cli.core._render_solver_summary_text (dict summary)
	Render the solver summary as a glanceable numerical-method dashboard.
	picurv_cli.core._render_monitor_summary_text (dict summary)
	Render the monitor summary as a glanceable observability dashboard.
	picurv_cli.core.render_selected_summary (dict payload, str output_format="text")
	Render selected timestep-independent config views and optional health.
str	picurv_cli.core._humanize_plot_identifier (str value)
	Convert one machine-oriented identifier into a readable plot label.
str	picurv_cli.core._summary_field_label (str field)
	Return the report-facing label for one logged scalar field.
"float | None"	picurv_cli.core._summary_physical_time (dict context, dict record)
	Resolve a record's physical time from its artifact or copied case configuration.
	picurv_cli.core._read_runtime_diagnostics_csv (path)
	Yields (segment, row) for each data line of one of the solver's CSV records.
"str | None"	picurv_cli.core._log_family_path (str log_dir, str base)
	Return a solver record's CSV, or the text log an older run wrote instead.
"list[tuple[int, str]]"	picurv_cli.core._block_family_paths (str log_dir, *str bases)
	Return (block, path) for each per-block solver record, CSV preferred per block.
"tuple[str | None, list]"	picurv_cli.core._continuity_rows (str log_dir)
	Return the continuity record's path and its (segment, row) pairs.
"tuple[str | None, list]"	picurv_cli.core._particle_step_rows (str log_dir, str metrics_dir)
	Return the per-step particle record's path and its (segment, row) pairs.
"list[tuple[int, str, list]]"	picurv_cli.core._picard_history_rows (str log_dir)
	Return (block, path, [(segment, row)]) for each Picard momentum history.
"list[tuple[int, str, list]]"	picurv_cli.core._newton_history_rows (str log_dir)
	Return (block, path, [(segment, row)]) for each Newton iteration history.
"list[tuple[int, str, list]]"	picurv_cli.core._newton_summary_rows (str log_dir)
	Return (block, path, [(segment, row)]) for each Newton per-step summary.
"list[tuple[int, str, list]]"	picurv_cli.core._poisson_history_rows (str log_dir)
	Return (block, path, [(segment, row)]) for each Poisson iteration history.
list	picurv_cli.core._runtime_memory_rows (str path)
	Return the runtime memory record's (segment, row) pairs (CSV, or an older run's text log).
	picurv_cli.core._typed_csv_value (str text)
	Return a CSV cell as a float (written with a point or exponent), an int, or the text.
"tuple[str | None, list]"	picurv_cli.core._solution_convergence_rows (str log_dir)
	Return the solution-convergence record's path and its (segment, row) pairs.
	picurv_cli.core._append_summary_plot_record (list records, str source, step, str line, dict values, str source_path, int segment=0, dict coordinates=None)
	Append one numeric append-ordered record for summarize plotting.
bool	picurv_cli.core._is_summary_plot_continuation_marker (str line)
	Return whether a log line starts a new continuation segment.
list	picurv_cli.core._collect_summary_plot_records (dict context)
	Collect append-ordered numeric records from summarize-supported scalar logs.
list	picurv_cli.core._collect_spectra_plot_records (dict context)
	Collect the per-step scalar histories written by the spectra post stage.
list	picurv_cli.core._collect_profile_plot_records (dict context)
	Collect the profile histories the profile_series reducer wrote.
list	picurv_cli.core._build_summary_plot_catalog (list records)
	Build available qualified-series metadata from plot records.
list	picurv_cli.core._representative_indices (int count, int maximum=6)
	Select evenly distributed indices while always retaining both endpoints.
dict	picurv_cli.core._build_spectrum_plot_request (dict context, str task, bool reference, bool linear_y, "str | None" output_path)
	Build a plot.gen request drawing representative measured spectra.
dict	picurv_cli.core._build_summary_plot_request (dict context, list records, str series, "int | None" last_n, bool linear_y, "str | None" output_path)
	Build one normalized plot.gen request from collected summarize records.
	picurv_cli.core._render_summary_plot_catalog (list catalog, str output_format)
	Render available summarize plot-series metadata.
str	picurv_cli.core._summary_table_path (dict context, str name)
	Resolve a summarize --table name to the CSV it prints.
	picurv_cli.core._list_summary_tables (dict context, str output_format)
	Print the summarize --table names whose CSV this run has, with row counts.
	picurv_cli.core._render_summary_table (dict context, str name, last_n, columns, str output_format)
	Print the last rows of one of the run's CSV records as aligned columns (or JSON).
	picurv_cli.core._invoke_plot_gen (dict request)
	Invoke standalone plot.gen with one normalized request over stdin.
	picurv_cli.core.summarize_workflow (args)
	Build and render a read-only health summary for a run step.
dict	picurv_cli.core._resolve_submission_target (str run_dir=None, str study_dir=None)
	Resolve a run/study submission target from explicit directory flags.
dict	picurv_cli.core._get_submission_stage_metadata (dict target_context, str stage_name)
	Return stored metadata for one staged submission target.
list	picurv_cli.core._get_recorded_submission_stages (dict target_context)
	Return stage names explicitly recorded in scheduler submission metadata.
str	picurv_cli.core._build_submit_missing_stage_hint (dict target_context, str requested_stage, list selected_stages)
	Build an actionable hint for requested submit stages missing from metadata.
	picurv_cli.core._set_submission_stage_metadata (dict target_context, str stage_name, dict stage_meta)
	Persist one stage's metadata back into the submission payload.
	picurv_cli.core._write_submission_target_metadata (dict target_context)
	Write updated submission metadata back to disk.
tuple	picurv_cli.core.staged_control_directories (str control_path)
	Read run-owned directory values from a staged control file.
list	picurv_cli.core.preflight_config_directories (str root_dir)
	Every config directory under a run or study root that may hold a control file.
tuple	picurv_cli.core.preflight_staged_run_directories (str root_dir)
	Re-check run-directory safety against an already-staged run or study.
list	picurv_cli.core.read_text_file_lines (str path)
	Read a text file into a list of lines.
	picurv_cli.core.submit_staged_jobs (args)
	Submit previously staged Slurm artifacts from an existing run/study directory.
	picurv_cli.core.submit_staged_local_run (args, dict target_context, list selected_stages)
	Execute previously staged local run commands from scheduler/submission.json.
	picurv_cli.core.cancel_run_jobs (args)
	Cancel Slurm-submitted jobs for an existing run directory.
	picurv_cli.core._workspace_yaml_role (str path)
	Infer the owned workspace role of one copied YAML file.
	picurv_cli.core._rewrite_workspace_path_values (value, dict replacements)
	Rewrite copied template path scalars to workspace-root-relative homes.
	picurv_cli.core._choose_primary_workspace_role (list candidates, str role, str template_name)
	Select the canonical role file from a template that may carry variants.
dict	picurv_cli.core.organize_initialized_workspace (str workspace_root, str template_name, str source_template_root=None)
	Convert a copied example into the canonical editable workspace layout.
dict	picurv_cli.core.import_workspace_input (str workspace_root, str kind, str source, str name=None, str mode="copy")
	Explicitly import or register one workspace input.
	picurv_cli.core.inputs_workflow (args)
	Handle explicit workspace input management.
	picurv_cli.core.version_workflow (args)
	Report, and for the status action validate, the shared build identity.
None	picurv_cli.core._print_petsc_build (dict identity)
	Print the PETSc an executable was built against and the library it would load.
None	picurv_cli.core._require_clean_source_checkout (str action)
	Refuse version-changing Git operations in a dirty source checkout.
subprocess.CompletedProcess	picurv_cli.core._git_source_command (list arguments)
	Run a checked Git command against the active PICurv source checkout.
	picurv_cli.core.source_workflow (args)
	Fetch source history without silently changing the active code.
	picurv_cli.core._workspace_requested_version (str workspace_root)
	Resolve an exact version requested by an initialized workspace.
	picurv_cli.core.versions_workflow (args)
	List or activate a release using the existing source/build owners.
str	picurv_cli.core._resolve_version_ref (str version)
	Resolve a user-named version to a Git ref that exists in the source checkout.
	picurv_cli.core.init_case (args)
	Implements the 'init' command.
	picurv_cli.core.sync_case_config_command (args)
	Refresh template-managed config/docs files in a case directory.
	picurv_cli.core.pull_source_repo (args)
	Refresh source branches in the repository resolved from a case directory.
	picurv_cli.core.build_project (args)
	Implements the 'build' command.
None	picurv_cli.core.run_project_make (str source_project_root, "list[str]" make_args)
	Run the project Makefile with caller-supplied arguments, defaulting to all.

Variables
	picurv_cli.core._package_parent = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
	picurv_cli.core._storage_module = importlib.import_module("picurv_cli.storage")
	picurv_cli.core.StorageError = _storage_module.StorageError
	picurv_cli.core.cold_study_members = _storage_module.cold_study_members
	picurv_cli.core.restore_cold_study_members = _storage_module.restore_cold_study_members
	picurv_cli.core.is_artifact_cold = _storage_module.is_artifact_cold
	picurv_cli.core.read_artifact_identity = _storage_module.read_artifact_identity
	picurv_cli.core.STORAGE_LOCK_FILENAME = _storage_module.STORAGE_LOCK_FILENAME
	picurv_cli.core.STORAGE_STATE_FILENAME = _storage_module.STORAGE_STATE_FILENAME
	picurv_cli.core.require_storage_payload_local = _storage_module.require_storage_payload_local
	picurv_cli.core.runtime_stage_lock = _storage_module.runtime_stage_lock
	picurv_cli.core.storage_state_summary = _storage_module.storage_state_summary
	picurv_cli.core._rebase_restored_text_paths = _storage_module._rebase_restored_text_paths
	picurv_cli.core._NUMPY_MODULE = None
	picurv_cli.core._MATPLOTLIB_PYPLOT = None
	picurv_cli.core.np = _LazyNumpyProxy()
	picurv_cli.core.PACKAGE_PATH = os.path.dirname(os.path.realpath(__file__))
	picurv_cli.core.PACKAGE_PROJECT_ROOT = os.path.dirname(PACKAGE_PATH)
	picurv_cli.core.INVOKED_SCRIPT_DIR
	picurv_cli.core.SCRIPT_PATH
	picurv_cli.core.PROJECT_ROOT = os.path.dirname(SCRIPT_PATH)
	picurv_cli.core.GENERATORS_PATH = os.path.join(PACKAGE_PROJECT_ROOT, "generators")
	picurv_cli.core.DEFAULT_BIN_DIR = SCRIPT_PATH
	picurv_cli.core.VERSION_FILE = os.path.join(PACKAGE_PROJECT_ROOT, "VERSION")
str	picurv_cli.core.PICURV_RELEASE_VERSION = _read_release_version()
str	picurv_cli.core.CASE_ORIGIN_METADATA_FILENAME = ".picurv-origin.json"
str	picurv_cli.core.WORKSPACE_CONFIG_FILENAME = ".picurv-workspace.yml"
int	picurv_cli.core.WORKSPACE_SCHEMA_VERSION = 1
int	picurv_cli.core.RUN_MANIFEST_SCHEMA_VERSION = 3
int	picurv_cli.core.ASSET_MANIFEST_SCHEMA_VERSION = 1
int	picurv_cli.core.ASSET_LOCK_SCHEMA_VERSION = 1
str	picurv_cli.core.RUNTIME_EXECUTION_CONFIG_FILENAME = ".picurv-execution.yml"
str	picurv_cli.core.LEGACY_LOCAL_RUNTIME_CONFIG_FILENAME = ".picurv-local.yml"
str	picurv_cli.core.RUNTIME_EXECUTION_EXAMPLE_FILENAME = "execution.example.yml"
tuple	picurv_cli.core.RUNTIME_EXECUTION_CONFIG_FILENAMES
str	picurv_cli.core.DEFAULT_RUNTIME_EXECUTION_CONFIG_TEMPLATE
str	picurv_cli.core.CLUSTER_TEMPLATE_PLACEHOLDER_ACCOUNT = "my_project_account"
str	picurv_cli.core.CLUSTER_TEMPLATE_PLACEHOLDER_MAIL = "user@example.edu"
dict	picurv_cli.core.DEFAULT_WALLTIME_GUARD_POLICY
str	picurv_cli.core.WALLTIME_GUARD_ENV_JOB_START_EPOCH = "PICURV_JOB_START_EPOCH"
str	picurv_cli.core.WALLTIME_GUARD_ENV_LIMIT_SECONDS = "PICURV_WALLTIME_LIMIT_SECONDS"
str	picurv_cli.core.POST_RESUME_STATE_FILENAME = "post.resume.json"
str	picurv_cli.core.POST_LOCK_FILENAME = "post.lock"
str	picurv_cli.core.POST_LOCK_METADATA_FILENAME = "post.lock.json"
str	picurv_cli.core.POST_LOCK_WRAPPER_FILENAME = "post_lock_wrapper.py"
int	picurv_cli.core.POST_RESUME_SCHEMA_VERSION = 2
dict	picurv_cli.core.POST_RECIPE_SIGNATURE_EXCLUDED_KEYS = {"startTime", "endTime", "timeStep", "source_directory"}
str	picurv_cli.core.CHECKPOINT_FORMAT = "picurv-checkpoint"
int	picurv_cli.core.CHECKPOINT_VERSION = 1
int	picurv_cli.core.CHECKPOINT_STEP_WIDTH = 12
dict	picurv_cli.core.CHECKPOINT_REQUIRED_EULERIAN_FIELDS = {"Ucat", "Ucont", "Ucont_rm1", "P", "Nvert"}
tuple	picurv_cli.core.WORKSPACE_DIRECTORY_LAYOUT
tuple	picurv_cli.core.RUN_DIRECTORY_LAYOUT
dict	picurv_cli.core.CANONICAL_RUN_PATHS
	picurv_cli.core.INITIAL_CONDITION_SPECTRUM_RELPATH
dict	picurv_cli.core._WORKSPACE_ARTIFACT_ROOT_VALUES = {"runs", "studies"}
dict	picurv_cli.core._ASSET_SOURCE_REFERENCE_KEYS
dict	picurv_cli.core._PYTHON_INITIAL_CONDITION_PROVIDERS
tuple	picurv_cli.core.SPECTRAL_IC_PROVIDERS
tuple	picurv_cli.core.SHELL_SPECTRUM_IC_PROVIDERS = ("spectral_random_velocity", "resampled_velocity")
	picurv_cli.core.SPECTRAL_RANDOM_VELOCITY_PARAMS
	picurv_cli.core.RESAMPLED_VELOCITY_PARAMS
tuple	picurv_cli.core.RESAMPLED_VELOCITY_FASTEST_AXES = ("x", "z")
tuple	picurv_cli.core.RESAMPLED_VELOCITY_COMPONENT_LAYOUTS = ("interleaved", "separate")
tuple	picurv_cli.core.RESAMPLED_VELOCITY_RAW_DTYPES = ("float32", "float64")
tuple	picurv_cli.core.RESAMPLED_VELOCITY_BYTE_ORDERS = ("little", "big", "native")
tuple	picurv_cli.core.RESAMPLED_VELOCITY_PROJECTIONS = ("picurv_discrete", "continuum", "none")
dict	picurv_cli.core.RESAMPLED_VELOCITY_LAYOUT_KEYS
dict	picurv_cli.core._FILE_BACKED_GRID_VALUES = {"file", "grid_gen"}
dict	picurv_cli.core._WORKSPACE_MANAGED_PATHS = {"assets", "inputs", "runs", "studies"}
dict	picurv_cli.core._VENDORABLE_CONFIG_REFERENCE_KEYS = {"config_file", "script"}
dict	picurv_cli.core._PLAIN_FILENAME_SENTINELS = {"", ".", ".."}
dict	picurv_cli.core._VERSION_BUILD_ACTIONS = {"install", "activate"}
	picurv_cli.core.RUN_DIRECTORY_ROOTS
	picurv_cli.core.RUN_ROOT_ALLOWED_FILES = frozenset({"manifest.json"})
tuple	picurv_cli.core.CONTINUATION_STAGED_RECORDS
tuple	picurv_cli.core.RUN_EXECUTABLE_NAMES = ("simulator", "postprocessor")
	picurv_cli.core.STORAGE_OFFLOADED_STATES = frozenset({"COLD", "PARTIAL"})
tuple	picurv_cli.core.RUN_COMPONENT_STATES
tuple	picurv_cli.core.RUN_COMPONENT_LAYOUT
	picurv_cli.core._SELECTED_PETSC_INDEX_BYTES = None
	picurv_cli.core._BINARY_VERSION_PATTERN
	picurv_cli.core._BINARY_PETSC_PATTERN
dict	picurv_cli.core.PETSC_INDEX_BYTES = {"int32": 4, "int64": 8}
str	picurv_cli.core._BINARY_PETSC_STAMP_MARKER = b"PICURV_PETSC_BUILD:"
str	picurv_cli.core._BINARY_BUILD_STAMP_MARKER = b"PICURV_BUILD:"
str	picurv_cli.core.ERROR_CODE_CLI_USAGE_INVALID = "CLI_USAGE_INVALID"
str	picurv_cli.core.ERROR_CODE_CFG_MISSING_SECTION = "CFG_MISSING_SECTION"
str	picurv_cli.core.ERROR_CODE_CFG_MISSING_KEY = "CFG_MISSING_KEY"
str	picurv_cli.core.ERROR_CODE_CFG_INVALID_TYPE = "CFG_INVALID_TYPE"
str	picurv_cli.core.ERROR_CODE_CFG_INVALID_VALUE = "CFG_INVALID_VALUE"
str	picurv_cli.core.ERROR_CODE_CFG_FILE_NOT_FOUND = "CFG_FILE_NOT_FOUND"
str	picurv_cli.core.ERROR_CODE_CFG_GRID_PARSE = "CFG_GRID_PARSE"
str	picurv_cli.core.ERROR_CODE_CFG_INCONSISTENT_COMBO = "CFG_INCONSISTENT_COMBO"
str	picurv_cli.core.ERROR_CODE_DEPENDENCY_MISSING = "DEPENDENCY_MISSING"
tuple	picurv_cli.core.RESTART_RUN_DIR_REQUIRED_MESSAGE
dict	picurv_cli.core._ERROR_HINTS
tuple	picurv_cli.core._RESTART_HINT
tuple	picurv_cli.core._STORAGE_RESTORE_HINT
str	picurv_cli.core._STUDY_DIR_HINT = "Pass a study directory that 'picurv sweep' created (studies/<study_id>)."
	picurv_cli.core._MAKE_ASSIGNMENT_PATTERN = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*[:+?]?=.*$")
dict	picurv_cli.core.POST_RUN_CONTROL_ALIASES
dict	picurv_cli.core.GRID_GENERATOR_HYPHEN_KEY_HINTS
tuple	picurv_cli.core.RETIRED_GENERATOR_DESTINATION_KEYS
tuple	picurv_cli.core.RETIRED_INITIAL_CONDITION_DESTINATION_KEYS = ("output_file", "summary_json", "spectrum_csv")
dict	picurv_cli.core.POST_SPECTRA_TASKS
tuple	picurv_cli.core.POST_SPECTRA_SYMBOLS = ("continuum", "discrete")
tuple	picurv_cli.core.POST_SPECTRA_MEAN_MODES = ("none", "domain", "sample")
tuple	picurv_cli.core.POST_FIELD_STATISTICS_OUTPUTS = ("mean", "reynolds_stress", "rms", "tke", "flux", "point_variance")
tuple	picurv_cli.core.POST_FIELD_STATISTICS_DEFAULT_OUTPUTS = POST_FIELD_STATISTICS_OUTPUTS[:-1]
tuple	picurv_cli.core.POST_FIELD_STATISTICS_FORMATS = ("vtk", "csv")
tuple	picurv_cli.core.GRID_MODES = ("file", "programmatic_c", "grid_gen")
tuple	picurv_cli.core.DOMAIN_DIMENSIONALITY_MODES = ("3D", "2D")
tuple	picurv_cli.core.GRID_GENERATOR_TYPES = ("box", "sweep")
tuple	picurv_cli.core.GRID_CROSS_SECTION_KINDS = ("rectangle", "circle")
tuple	picurv_cli.core.GRID_WALL_SEGMENT_KINDS = ("flat", "step", "ramp", "arc", "sine", "gaussian", "hill")
tuple	picurv_cli.core.GRID_PATH_SEGMENT_KINDS = ("straight", "arc")
tuple	picurv_cli.core.GRID_TRANSFORM_KINDS = ("anchor", "translate", "scale", "rotate", "mirror", "permute", "reverse")
tuple	picurv_cli.core.PARTICLE_RESTART_MODES = ("init", "load")
tuple	picurv_cli.core.POST_EULERIAN_PIPELINE_TASKS = ("q_criterion", "normalize_field", "nodal_average")
tuple	picurv_cli.core.POST_LAGRANGIAN_PIPELINE_TASKS = ("specific_ke",)
tuple	picurv_cli.core.STUDY_TYPES = ("grid_independence", "timestep_independence", "sensitivity")
tuple	picurv_cli.core.NEWTON_KRYLOV_PRECONDITIONER_MODELS = ("none", "frozen_momentum_jacobian")
tuple	picurv_cli.core.NEWTON_KRYLOV_PRECONDITIONER_STRUCTURES = ("none", "point_block")
tuple	picurv_cli.core.POISSON_PRECONDITIONER_TYPES = ("multigrid",)
dict	picurv_cli.core.POISSON_PRECONDITIONER_SPELLINGS = {"mg": "multigrid", "pcmg": "multigrid"}
tuple	picurv_cli.core.PRESCRIBED_FLOW_SOURCE_TYPES = ("file", "generated", "field_slice")
tuple	picurv_cli.core.VERIFICATION_SCALAR_PROFILES = ("CONSTANT", "LINEAR_X", "SIN_PRODUCT")
dict	picurv_cli.core.SCALAR_TRANSPORT_FLAGS
dict	picurv_cli.core.SCALAR_TRANSPORT_CASE_PATHS
tuple	picurv_cli.core.STUDY_PLOT_FORMATS = ("png", "pdf", "svg")
tuple	picurv_cli.core.PROFILING_TIMESTEP_MODES = ("off", "selected", "all")
dict	picurv_cli.core.RENAMED_MONITOR_FUNCTIONS
tuple	picurv_cli.core.REMOVED_MONITOR_FUNCTIONS
tuple	picurv_cli.core.GMRES_RESTART_METHODS = ("gmres", "fgmres", "lgmres")
dict	picurv_cli.core.POISSON_KSP_METHODS
dict	picurv_cli.core.POISSON_KSP_REFUSED
tuple	picurv_cli.core.ANALYTICAL_SOLUTION_TYPES = ("TGV3D", "ZERO_FLOW", "UNIFORM_FLOW")
tuple	picurv_cli.core.LEGACY_FIELD_INIT_SPELLINGS = ("Zero", "Constant", "Poiseuille")
tuple	picurv_cli.core.PROJECTION_OPERATORS = ("continuum", "picurv_discrete")
tuple	picurv_cli.core.METRIC_SOURCE_KINDS = ("statistics_csv", "csv", "log_regex", "log")
tuple	picurv_cli.core.LAUNCH_MODES = ("local", "cluster")
tuple	picurv_cli.core.POST_SPECTRA_SCALAR_COLUMNS
tuple	picurv_cli.core.POST_STAGE_NAMES = ("fields", "spectra", "reducers")
dict	picurv_cli.core.POST_REDUCER_TASKS
dict	picurv_cli.core.POST_REDUCER_FRICTION_SOURCES
dict	picurv_cli.core._REDUCER_AXIS_TOKENS = {"i": "Xi", "j": "Eta", "k": "Zeta"}
dict	picurv_cli.core.POST_PARAVIEW_SERIES_SCOPES = {"run", "lineage"}
dict	picurv_cli.core.POST_PROCESS_REASON_LABELS
str	picurv_cli.core.PICGRID_FLOAT_FORMAT = ".17e"
dict	picurv_cli.core.GENERATED_PROFILE_GENERATORS = {"square_duct_poiseuille"}
dict	picurv_cli.core.GRID_GENERATOR_CHOICE_FLAGS
dict	picurv_cli.core.GRID_GENERATOR_SPEC_FLAGS
dict	picurv_cli.core.BC_FACE_MAP
dict	picurv_cli.core.BC_TYPE_MAP
tuple	picurv_cli.core.PARTICLE_BOUNDARY_POLICIES = ("reflect", "remove", "wrap")
dict	picurv_cli.core.BC_HANDLER_SPECS
dict	picurv_cli.core._NUMERIC_BC_PARAMS = {"vx", "vy", "vz", "v_max", "target_flux"}
dict	picurv_cli.core._BOOL_BC_PARAMS = {"enforce_seam_flux", "apply_trim"}
dict	picurv_cli.core._DEPRECATED_BC_PARAM_ALIASES = {"apply_trim": "enforce_seam_flux"}
tuple	picurv_cli.core.RANS_PLANNED_REFUSAL
dict	picurv_cli.core._CASE_SCHEMA
dict	picurv_cli.core._SOLVER_SCHEMA
dict	picurv_cli.core._MONITOR_SCHEMA
dict	picurv_cli.core.STATISTICS_ELIGIBLE_FIELDS
dict	picurv_cli.core.STATISTICS_PARTICLE_FIELDS
tuple	picurv_cli.core.POST_STATISTICS_ENSEMBLE_SOURCES = ("particles", "eulerian")
tuple	picurv_cli.core.STATISTICS_MOMENT_NAMES = ("first", "second")
tuple	picurv_cli.core.STATISTICS_WEIGHTING_MODES = ("sample", "physical_time")
dict	picurv_cli.core._POST_SCHEMA
dict	picurv_cli.core._CLUSTER_SCHEMA
dict	picurv_cli.core._STUDY_SCHEMA
dict	picurv_cli.core._WORKSPACE_SCHEMA
tuple	picurv_cli.core.DIMENSIONLESS = (0, 0, 0)
tuple	picurv_cli.core.LENGTH = (1, 0, 0)
tuple	picurv_cli.core.VELOCITY = (0, 1, 0)
tuple	picurv_cli.core.TIME = (1, -1, 0)
tuple	picurv_cli.core.WAVENUMBER = (-1, 0, 0)
tuple	picurv_cli.core.VOLUME_FLUX = (2, 1, 0)
tuple	picurv_cli.core.DIFFUSIVITY = (1, 1, 0)
tuple	picurv_cli.core.PRESSURE = (0, 2, 1)
tuple	picurv_cli.core.DENSITY = (0, 0, 1)
tuple	picurv_cli.core.DYNAMIC_VISCOSITY = (1, 1, 1)
tuple	picurv_cli.core.INPUT_CONVERSION_SITES = ("cli", "c", "staging", "provider", "evaluator", "reference", "passthrough", "")
tuple	picurv_cli.core.NOT_A_QUANTITY = (None, "")
tuple	picurv_cli.core.UNITLESS = (DIMENSIONLESS, "")
dict	picurv_cli.core.INPUT_QUANTITIES
dict	picurv_cli.core.BC_PARAM_QUANTITIES
dict	picurv_cli.core.IC_PARAM_QUANTITIES
tuple	picurv_cli.core.RUN_OWNED_DIRECTORY_KEYS = ("log", "output")
str	picurv_cli.core.UNSAFE_PATHS_OVERRIDE_KEY = "allow_unsafe_paths"
tuple	picurv_cli.core.RESERVED_RUN_DIRECTORY_NAMES = ("config", "scheduler", "checkpoints", "visualization")
dict	picurv_cli.core.RUN_DIRECTORY_DEFAULTS = {"log": "logs", "output": "output"}
tuple	picurv_cli.core.RESERVED_DIRECTORY_FLAGS
tuple	picurv_cli.core.RESERVED_INDIRECTION_FLAGS = ("-options_file", "-options_file_yaml", "-alias")
tuple	picurv_cli.core.UNSAFE_DIRECTORY_CHARACTERS = ('"', "'", "#", "\n", "\r", "\t")
str	picurv_cli.core.PHYSICAL_VERDICT_CONTAINED = "contained"
str	picurv_cli.core.PHYSICAL_VERDICT_RUN_ROOT = "run_root"
str	picurv_cli.core.PHYSICAL_VERDICT_ANCESTOR = "ancestor"
str	picurv_cli.core.PHYSICAL_VERDICT_RELATIVE_ESCAPE = "relative_escape"
str	picurv_cli.core.PHYSICAL_VERDICT_EXTERNAL_ABSOLUTE = "external_absolute"
	picurv_cli.core.WAIVABLE_PHYSICAL_VERDICTS = frozenset({PHYSICAL_VERDICT_EXTERNAL_ABSOLUTE})
dict	picurv_cli.core._SLURM_FAILED_END_STATES
str	picurv_cli.core.RUNTIME_MEMORY_FILE = "Runtime_Memory.csv"
str	picurv_cli.core.PROFILING_TIMESTEP_FILE = "Profiling_Timestep_Summary.csv"
dict	picurv_cli.core.DIAGNOSTICS_PETSC_KEYS
tuple	picurv_cli.core.PROGRAMMATIC_BRIDGE_GRID_KEYS
tuple	picurv_cli.core.GRID_DA_PROCESSOR_KEYS = ("da_processors_x", "da_processors_y", "da_processors_z")
dict	picurv_cli.core.IC_PAYLOAD_DIMENSIONS = {0: VELOCITY, 1: VOLUME_FLUX}
dict	picurv_cli.core.GENERATED_IC_PROVIDERS
dict	picurv_cli.core.PARTICLE_SETTABLE_FIELDS = {"Psi": 1}
tuple	picurv_cli.core.PETSC_INDEX_BITS_CHOICES = ("32", "64")
int	picurv_cli.core.PETSC_MAX_INT_32BIT = 2**31 - 1
int	picurv_cli.core.PARTICLE_FIELD_MAX_COMPONENTS = 3
int	picurv_cli.core.GRID_FIELD_MAX_COMPONENTS = 3
int	picurv_cli.core.STATISTICS_FIELD_COMPONENTS = 6
dict	picurv_cli.core.LES_MODEL_NAMES = {1: "constant_smagorinsky", 2: "dynamic_smagorinsky", 3: "vreman", 4: "wale"}
dict	picurv_cli.core.LES_MODEL_OWNED_KEYS
dict	picurv_cli.core.LES_MODEL_KEY_OWNER_DESCRIPTIONS
tuple	picurv_cli.core.LES_AVERAGING_DIRECTION_AXES = ("i", "j", "k")
dict	picurv_cli.core.SOLVER_MONITORING_POISSON_FLAG_MAP
dict	picurv_cli.core.SOLVER_MONITORING_MOMENTUM_FLAG_MAP
int	picurv_cli.core.MAX_TRACED_PARTICLES = 64
dict	picurv_cli.core.KRYLOV_KSP_TYPES
tuple	picurv_cli.core._STUDY_REPORT_COLORS
dict	picurv_cli.core.ASSET_KIND_DIRECTORIES
int	picurv_cli.core.ASSET_PREVIEW_NODE_LIMIT = 2_000_000
	picurv_cli.core._SUMMARY_NUMERIC_RE = re.compile(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?")
int	picurv_cli.core._CONFIG_SUMMARY_WIDTH = 78
dict	picurv_cli.core._SUMMARY_PLOT_LOG_SCALE_FIELDS
dict	picurv_cli.core._SUMMARY_PLOT_FIELD_LABELS
dict	picurv_cli.core._SUMMARY_PLOT_SOURCE_TITLES
dict	picurv_cli.core._SUMMARY_ITERATION_HISTORY_FIELDS
dict	picurv_cli.core._SUMMARY_COUNT_FIELDS
	picurv_cli.core._LEGACY_PICARD_REGEX
	picurv_cli.core._LEGACY_NEWTON_HISTORY_REGEX
	picurv_cli.core._LEGACY_NEWTON_SUMMARY_REGEX
	picurv_cli.core._LEGACY_POISSON_REGEX
tuple	picurv_cli.core._PLOT_ROW_IDENTITY_KEYS = ("step", "block")
dict	picurv_cli.core.SUMMARY_TABLES
dict	picurv_cli.core.WORKSPACE_INPUT_DIRECTORIES

Detailed Description

A comprehensive conductor script for the PICurv simulation platform.

This script acts as the central user interface for running simulations, managing configurations, and orchestrating the entire end-to-end workflow. It translates user-friendly YAML files into C-solver compatible control files, supports full multi-block configurations, and provides live log streaming. It features intelligent, content-based config file discovery and robustly manages data I/O paths for the post-processor. It also supports Slurm job generation/submission and parameter sweeps via job arrays.

Definition in file core.py.