pyflightstream 0.2.0__py3-none-any.whl

pyflightstream/__init__.py

@@ -0,0 +1,27 @@
+"""pyflightstream: version-aware, didactic Python driver for FlightStream.
+
+The package automates the FlightStream panel-method solver through its ASCII
+scripting interface. The FlightStream version is an explicit input: every
+command emitted is validated against the per-version command database in
+``pyflightstream.commands``.
+
+Pipeline layers, dependencies flowing strictly downward:
+
+- ``versions``: canonical 26.XXX version identifiers and ordering.
+- ``commands``: the command database and per-version registry.
+- ``script``: the validating ASCII script builder.
+- ``results``: anchor-based parsers for solver output files.
+- ``cases``: simulation and campaign definitions.
+- ``run`` and ``files``: execution, run manifest, managed file layout.
+- ``post``: results into engineering data (sweep assembly, PLTET, exports).
+- ``qa``: probe harness and physics regression tooling.
+- ``fsi``: seam for the future fluid-structure interaction coupling.
+
+Milestone M0: skeleton only; functionality arrives from milestone M1 on.
+"""
+
+__version__ = "0.0.1.dev0"
+
+from pyflightstream.reference import help  # noqa: E402
+
+__all__ = ["__version__", "help"]

pyflightstream/cases/__init__.py

@@ -0,0 +1,332 @@
+"""Simulation and campaign definitions.
+
+Pipeline role: describes what to run. A :class:`SimCase` (identified
+by ``sim_id``) is one solver configuration with its sweep; a
+:class:`Campaign` groups cases with the FlightStream version and the
+executable path, both required and explicit: nothing is read from
+environment variables or guessed (SAD Section 5). Native persistence
+is ``campaign.toml``; the legacy pipe-delimited ``matriz.fs`` matrix
+of the predecessor scripts will be read unchanged, forever, by the
+legacy reader (FR-10, next step of milestone M2).
+
+Script recipes are explicitly imported functions satisfying the
+:class:`ScriptRecipe` protocol: ``build(case, script) -> None``. The
+campaign loop specializes the case per sweep point (filling
+:attr:`SimCase.point`) and the recipe translates it into script
+emissions, usually through the curated helpers. Recipe references are
+``"package.module:function"`` strings, replacing the historical
+import-by-number system (PP-7, FR-12).
+"""
+
+from __future__ import annotations
+
+import tomllib
+from collections.abc import Callable, Iterator
+from importlib import import_module
+from pathlib import Path
+from typing import Literal, Protocol, runtime_checkable
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+from pyflightstream.script import Script
+from pyflightstream.versions import resolve
+
+_TAG_PREFIXES = (("alpha", "a"), ("beta", "b"), ("advance_ratio", "j"))
+
+
+@runtime_checkable
+class ScriptRecipe(Protocol):
+    """A function that turns one case point into script emissions.
+
+    Implementations receive the per-point specialized case (the
+    campaign loop fills :attr:`SimCase.point` and stages the geometry)
+    and an empty :class:`~pyflightstream.script.Script` bound to the
+    campaign's FlightStream version; they emit the whole script,
+    usually through the curated helpers. Output files must use paths
+    relative to the execution directory, so the collected evidence
+    stays inside the managed simulation folder.
+    """
+
+    def __call__(self, case: SimCase, script: Script) -> None:
+        """Emit the complete script for one case point."""
+        ...
+
+
+class SweepAxis(BaseModel):
+    """The sweep of one case: which axis varies and its values.
+
+    Attributes
+    ----------
+    type : str
+        ``alpha`` (angle of attack, deg), ``beta`` (side slip, deg),
+        ``alpha_beta`` (paired values), or ``advance_ratio``
+        (propeller advance ratio J, dimensionless).
+    values : list
+        Axis values; for ``alpha_beta`` each entry is an
+        ``[alpha, beta]`` pair in deg.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["alpha", "beta", "alpha_beta", "advance_ratio"]
+    values: list[float] | list[tuple[float, float]]
+
+    @model_validator(mode="after")
+    def _values_match_the_axis_type(self) -> SweepAxis:
+        pairs = self.type == "alpha_beta"
+        for value in self.values:
+            if pairs != isinstance(value, tuple):
+                expected = "[alpha, beta] pairs" if pairs else "scalar values"
+                raise ValueError(f"a {self.type} sweep takes {expected}, got {value!r}")
+        return self
+
+    def points(self) -> Iterator[dict[str, float]]:
+        """Iterate the sweep as named point coordinates.
+
+        Yields
+        ------
+        dict of str to float
+            One mapping per point, keyed ``alpha``, ``beta``, or
+            ``advance_ratio`` (both keys for ``alpha_beta``).
+        """
+        for value in self.values:
+            if self.type == "alpha_beta":
+                alpha, beta = value
+                yield {"alpha": alpha, "beta": beta}
+            else:
+                yield {self.type: value}
+
+
+def point_tag(point: dict[str, float]) -> str:
+    """Return the stable file-name tag of one sweep point.
+
+    The tag encodes the point coordinates in a fixed axis order with
+    signed fixed-width values, for example ``a+02.0_b+00.0``; it names
+    the generated script and ends the ``run_id``.
+
+    Parameters
+    ----------
+    point : dict of str to float
+        Point coordinates as produced by :meth:`SweepAxis.points`.
+    """
+    parts = [f"{prefix}{point[axis]:+05.1f}" for axis, prefix in _TAG_PREFIXES if axis in point]
+    if not parts:
+        raise ValueError(f"point {point!r} has no known axis (alpha, beta, advance_ratio)")
+    return "_".join(parts)
+
+
+class ReferenceData(BaseModel):
+    """Reference quantities for coefficient normalization.
+
+    Attributes
+    ----------
+    area : float
+        Reference area S_ref in simulation length units squared.
+    length : float
+        Reference length L_ref in simulation length units.
+    velocity : float, optional
+        Reference velocity in m/s; None lets the recipe default it to
+        the free-stream velocity (steady runs) or a characteristic
+        velocity such as the rotor tip speed (SRC-003 p.201).
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    area: float
+    length: float
+    velocity: float | None = None
+
+
+class SolverSettings(BaseModel):
+    """Solver runtime settings of one case.
+
+    Field names match the keyword arguments of
+    :func:`pyflightstream.script.helpers.solver_settings`, so recipes
+    can forward them directly.
+
+    Attributes
+    ----------
+    iterations : int
+        Solver iteration limit.
+    convergence : float
+        Residual threshold declaring convergence (SRC-003 p.200).
+    forced_iterations : bool, optional
+        Run the full iteration count regardless of convergence.
+    boundary_layer : str, optional
+        ``LAMINAR``, ``TRANSITIONAL``, or ``TURBULENT``.
+    viscous_coupling : bool, optional
+        Couple the boundary layer model to the potential solution.
+    max_threads : int, optional
+        Parallel core count.
+    timeout_s : float, optional
+        Wall-clock limit for one point's solver process; enforced by
+        the executor, not by FlightStream.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    iterations: int = 500
+    convergence: float = 1e-5
+    forced_iterations: bool | None = None
+    boundary_layer: str | None = None
+    viscous_coupling: bool | None = None
+    max_threads: int | None = None
+    timeout_s: float | None = None
+
+
+class SimCase(BaseModel):
+    """One solver configuration with its sweep (SAD Section 5).
+
+    Attributes
+    ----------
+    sim_id : str
+        Case identity; also names the managed folder
+        ``sims/sim_<sim_id>``.
+    aircraft : str
+        Aircraft or configuration name.
+    description : str
+        Free-text description.
+    reynolds : float, optional
+        Chord Reynolds number of the condition.
+    mach : float, optional
+        Free-stream Mach number.
+    velocity : float, optional
+        Free-stream velocity in m/s.
+    geometry : str, optional
+        Path of the simulation (.fsm) file; the campaign loop stages
+        it into ``inputs/`` and rewrites this field to the staged
+        copy, so recipes OPEN exactly what the manifest hashed.
+    sweep : SweepAxis
+        The sweep of this case.
+    reference : ReferenceData, optional
+        Coefficient normalization references.
+    solver : SolverSettings
+        Runtime settings; defaults apply when omitted.
+    recipe : str
+        Script recipe reference, ``"package.module:function"``, or a
+        name registered with the campaign loop.
+    variables : dict
+        Free per-case variables for the recipe (strings, numbers, or
+        booleans), for example a symmetry declaration.
+    outputs : list of str
+        Output files the recipe's script exports, relative to the
+        execution directory; the loop collects them into ``raw/`` and
+        a missing one marks the point FAILED_INCOMPLETE_OUTPUT.
+    point : dict of str to float
+        The current sweep point; filled by the campaign loop before
+        the recipe builds, empty on the authored case.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    sim_id: str
+    aircraft: str
+    description: str = ""
+    reynolds: float | None = None
+    mach: float | None = None
+    velocity: float | None = None
+    geometry: str | None = None
+    sweep: SweepAxis
+    reference: ReferenceData | None = None
+    solver: SolverSettings = Field(default_factory=SolverSettings)
+    recipe: str
+    variables: dict[str, str | float | int | bool] = Field(default_factory=dict)
+    outputs: list[str] = Field(default_factory=list)
+    point: dict[str, float] = Field(default_factory=dict)
+
+
+class Campaign(BaseModel):
+    """A named group of cases bound to one FlightStream installation.
+
+    Attributes
+    ----------
+    name : str
+        Campaign name; prefixes every ``run_id``.
+    fs_version : str
+        FlightStream version, canonical or alias; validated against
+        the registered versions at load time, resolved to canonical in
+        the manifest.
+    fs_exe : str
+        Explicit path of the FlightStream executable; existence is
+        checked by the executor at construction, not here, so a
+        campaign file can be authored away from the licensed machine.
+    sims : list of SimCase
+        The cases of the campaign.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    name: str
+    fs_version: str
+    fs_exe: str
+    sims: list[SimCase]
+
+    @field_validator("fs_version")
+    @classmethod
+    def _version_is_registered(cls, value: str) -> str:
+        resolve(value)
+        return value
+
+
+def load_campaign(path: str | Path) -> Campaign:
+    """Load and validate a ``campaign.toml`` file.
+
+    The file holds one ``[campaign]`` table (name, fs_version,
+    fs_exe) and one ``[[sim]]`` array entry per case, as in SAD
+    Section 5.
+
+    Parameters
+    ----------
+    path : str or Path
+        Location of the TOML file.
+
+    Returns
+    -------
+    Campaign
+        Validated campaign; version aliases are checked against the
+        registered versions immediately, so a typo fails at load
+        time, not at the first point.
+    """
+    with open(path, "rb") as handle:
+        data = tomllib.load(handle)
+    if "campaign" not in data:
+        raise ValueError(
+            f"{path} has no [campaign] table; campaign.toml needs [campaign] with "
+            "name, fs_version, and fs_exe, plus one [[sim]] entry per case"
+        )
+    return Campaign(**data["campaign"], sims=data.get("sim", []))
+
+
+def resolve_recipe(reference: str) -> Callable[[SimCase, Script], None]:
+    """Import the recipe function a reference string names.
+
+    Parameters
+    ----------
+    reference : str
+        ``"package.module:function"``; the module must be importable
+        and the attribute callable. Explicit references replace the
+        historical import-by-number system (PP-7, FR-12).
+
+    Returns
+    -------
+    callable
+        The recipe function, satisfying :class:`ScriptRecipe`.
+    """
+    module_name, separator, function_name = reference.partition(":")
+    if not separator or not module_name or not function_name:
+        raise ValueError(
+            f"recipe reference {reference!r} is not of the form 'package.module:function'"
+        )
+    try:
+        module = import_module(module_name)
+    except ImportError as error:
+        raise ValueError(
+            f"recipe module {module_name!r} cannot be imported: {error}. Recipes are "
+            "explicitly imported functions; check the module path and the environment."
+        ) from error
+    recipe = getattr(module, function_name, None)
+    if not callable(recipe):
+        raise ValueError(
+            f"recipe {reference!r} does not name a callable in {module_name!r}; found {recipe!r}"
+        )
+    return recipe

pyflightstream/cases/matrix_legacy.py

@@ -0,0 +1,337 @@
+"""Reader for the legacy pipe-delimited run matrix (FR-10, FR-11).
+
+Pipeline role: keeps the predecessor run-matrix workflow working
+unchanged, forever (BRF-08). The verified 15-column layout is read as
+is: POL, AIRCRAFT, DESCRIPTION, RE, MACH, SWEEP_TYPE, SWEEP_VALUES,
+REF, SET, ENTRY, FS_SCRIPT, FS_BUILD, HIDDEN, RUN, VAR_NAMES_VALUES.
+Rows with RUN = 1 are active. SWEEP_TYPE names its axes separated by
+``/`` (verified codes: ``AL`` for alpha, ``BE`` for beta) and
+SWEEP_VALUES carries one comma-separated value list per axis, also
+``/``-separated; the legacy workflow varies one axis while the other
+holds a single value, which broadcasts here. VAR_NAMES_VALUES holds
+``/``-separated ``KEY:VALUE`` pairs, values may contain spaces.
+
+The historical 3-digit codes (REF, SET, ENTRY, FS_SCRIPT) were
+resolved to files by number at run time; that import-by-number system
+is replaced (PP-7, FR-12): :func:`to_campaign` maps the FS_SCRIPT
+code to a registered recipe name through an explicit mapping and
+preserves all four codes in the case variables, so the conversion is
+lossless. :func:`convert_matrix` (FR-11) emits the native
+``campaign.toml`` equivalent; RE is stored in millions in the matrix
+and converts to an absolute Reynolds number.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+
+from pyflightstream.cases import Campaign, SimCase, SweepAxis
+
+_COLUMNS = (
+    "POL",
+    "AIRCRAFT",
+    "DESCRIPTION",
+    "RE",
+    "MACH",
+    "SWEEP_TYPE",
+    "SWEEP_VALUES",
+    "REF",
+    "SET",
+    "ENTRY",
+    "FS_SCRIPT",
+    "FS_BUILD",
+    "HIDDEN",
+    "RUN",
+    "VAR_NAMES_VALUES",
+)
+_SWEEP_CODES = {"AL": "alpha", "BE": "beta"}
+
+
+class LegacyMatrixError(ValueError):
+    """A legacy matrix file does not match the verified layout.
+
+    The reader supports exactly the verified format (FR-10); a
+    deviation means the file is not a predecessor run matrix or was
+    edited beyond what the legacy workflow produced.
+    """
+
+
+@dataclass(frozen=True)
+class LegacyRow:
+    """One parsed row of the legacy run matrix.
+
+    Attributes
+    ----------
+    pol : str
+        Legacy polar identifier; maps to the native ``sim_id``.
+    aircraft, description : str
+        Configuration name and free text.
+    re_millions : float
+        Reynolds number in millions, as stored in the matrix.
+    mach : float
+        Mach number.
+    sweep : SweepAxis
+        The sweep, already in native form.
+    ref_code, set_code, entry_code, script_code : str
+        The historical 3-digit codes (REF, SET, ENTRY, FS_SCRIPT).
+    fs_build : str
+        Legacy build column, kept verbatim.
+    hidden : bool
+        Legacy hidden-mode flag.
+    run : int
+        Activity flag; rows with 1 are active.
+    variables : dict
+        The KEY:VALUE variables, values kept as strings.
+    """
+
+    pol: str
+    aircraft: str
+    description: str
+    re_millions: float
+    mach: float
+    sweep: SweepAxis
+    ref_code: str
+    set_code: str
+    entry_code: str
+    script_code: str
+    fs_build: str
+    hidden: bool
+    run: int
+    variables: dict[str, str]
+
+
+def _parse_sweep(sweep_type: str, sweep_values: str) -> SweepAxis:
+    axes = [token.strip() for token in sweep_type.split("/")]
+    groups = [token.strip() for token in sweep_values.split("/")]
+    unknown = [axis for axis in axes if axis not in _SWEEP_CODES]
+    if unknown:
+        raise LegacyMatrixError(
+            f"SWEEP_TYPE code(s) {', '.join(unknown)} are not among the verified legacy "
+            f"codes ({', '.join(sorted(_SWEEP_CODES))}); extending the mapping needs "
+            "evidence from a legacy matrix that uses the code"
+        )
+    if len(axes) != len(groups):
+        raise LegacyMatrixError(
+            f"SWEEP_TYPE names {len(axes)} axes but SWEEP_VALUES holds {len(groups)} "
+            "value groups; each axis takes one '/'-separated group"
+        )
+    values = {
+        _SWEEP_CODES[axis]: [float(token) for token in group.split(",")]
+        for axis, group in zip(axes, groups, strict=True)
+    }
+    if set(values) == {"alpha", "beta"}:
+        alpha, beta = values["alpha"], values["beta"]
+        if len(alpha) > 1 and len(beta) == 1:
+            beta = beta * len(alpha)
+        elif len(beta) > 1 and len(alpha) == 1:
+            alpha = alpha * len(beta)
+        elif len(alpha) != len(beta):
+            raise LegacyMatrixError(
+                "an AL/BE sweep varies one axis while the other holds a single "
+                f"value; got {len(alpha)} alpha and {len(beta)} beta values"
+            )
+        return SweepAxis(
+            type="alpha_beta", values=[list(pair) for pair in zip(alpha, beta, strict=True)]
+        )
+    axis_name, axis_values = next(iter(values.items()))
+    return SweepAxis(type=axis_name, values=axis_values)
+
+
+def _parse_variables(cell: str) -> dict[str, str]:
+    variables: dict[str, str] = {}
+    if not cell.strip():
+        return variables
+    for pair in cell.split("/"):
+        name, separator, value = pair.partition(":")
+        if not separator:
+            raise LegacyMatrixError(
+                f"variable {pair.strip()!r} is not a KEY:VALUE pair; VAR_NAMES_VALUES "
+                "holds '/'-separated KEY:VALUE entries"
+            )
+        variables[name.strip()] = value.strip()
+    return variables
+
+
+def read_matrix(path: str | Path, active_only: bool = True) -> list[LegacyRow]:
+    """Read a legacy ``matriz.fs`` run matrix.
+
+    Parameters
+    ----------
+    path : str or Path
+        Matrix file location.
+    active_only : bool
+        Keep only rows with RUN = 1, the legacy activity filter;
+        False returns every row.
+
+    Returns
+    -------
+    list of LegacyRow
+        Parsed rows in file order.
+    """
+    lines = Path(path).read_text(encoding="utf-8", errors="replace").splitlines()
+    content = [line for line in lines if line.strip() and not set(line.strip()) <= {"-"}]
+    if not content:
+        raise LegacyMatrixError(f"{path} holds no matrix content")
+    header = tuple(cell.strip() for cell in content[0].split("|"))
+    if header != _COLUMNS:
+        raise LegacyMatrixError(
+            f"{path} header does not match the verified 15-column layout; expected "
+            f"{', '.join(_COLUMNS)} and found {', '.join(header)}"
+        )
+    rows: list[LegacyRow] = []
+    for line in content[1:]:
+        cells = [cell.strip() for cell in line.split("|")]
+        if len(cells) != len(_COLUMNS):
+            raise LegacyMatrixError(
+                f"matrix row holds {len(cells)} cells against the 15 verified columns: "
+                f"{line.strip()[:60]}..."
+            )
+        record = dict(zip(_COLUMNS, cells, strict=True))
+        row = LegacyRow(
+            pol=record["POL"],
+            aircraft=record["AIRCRAFT"],
+            description=record["DESCRIPTION"],
+            re_millions=float(record["RE"]),
+            mach=float(record["MACH"]),
+            sweep=_parse_sweep(record["SWEEP_TYPE"], record["SWEEP_VALUES"]),
+            ref_code=record["REF"],
+            set_code=record["SET"],
+            entry_code=record["ENTRY"],
+            script_code=record["FS_SCRIPT"],
+            fs_build=record["FS_BUILD"],
+            hidden=record["HIDDEN"] == "1",
+            run=int(record["RUN"]),
+            variables=_parse_variables(record["VAR_NAMES_VALUES"]),
+        )
+        if row.run == 1 or not active_only:
+            rows.append(row)
+    return rows
+
+
+def to_campaign(
+    path: str | Path,
+    *,
+    name: str,
+    fs_version: str,
+    fs_exe: str,
+    recipes: Mapping[str, str],
+) -> Campaign:
+    """Convert a legacy matrix into a native :class:`Campaign`.
+
+    Parameters
+    ----------
+    path : str or Path
+        Legacy matrix location; only RUN = 1 rows convert.
+    name : str
+        Campaign name; the matrix has none, so it is explicit input.
+    fs_version : str
+        FlightStream version, canonical or alias; the legacy FS_BUILD
+        column does not identify one, so it is explicit input.
+    fs_exe : str
+        Explicit executable path (never guessed, SAD Section 5).
+    recipes : mapping of str to str
+        FS_SCRIPT code to recipe reference (``module:function`` or a
+        name registered with the campaign loop); replaces the
+        import-by-number system (PP-7, FR-12).
+
+    Returns
+    -------
+    Campaign
+        Native campaign; the historical codes survive in each case's
+        variables (``legacy_ref``, ``legacy_set``, ``legacy_entry``,
+        ``legacy_fs_script``, ``legacy_fs_build``, ``legacy_hidden``)
+        so the conversion is lossless (FR-11).
+    """
+    sims = []
+    for row in read_matrix(path):
+        if row.script_code not in recipes:
+            raise LegacyMatrixError(
+                f"FS_SCRIPT code {row.script_code!r} of POL {row.pol} has no recipe "
+                "mapping; the import-by-number system is replaced by explicit recipe "
+                "references, so pass recipes={code: 'package.module:function'}"
+            )
+        variables: dict[str, str | float | int | bool] = dict(row.variables)
+        variables.update(
+            legacy_ref=row.ref_code,
+            legacy_set=row.set_code,
+            legacy_entry=row.entry_code,
+            legacy_fs_script=row.script_code,
+            legacy_fs_build=row.fs_build,
+            legacy_hidden=row.hidden,
+        )
+        sims.append(
+            SimCase(
+                sim_id=row.pol,
+                aircraft=row.aircraft,
+                description=row.description,
+                reynolds=row.re_millions * 1e6,
+                mach=row.mach,
+                sweep=row.sweep,
+                recipe=recipes[row.script_code],
+                variables=variables,
+            )
+        )
+    return Campaign(name=name, fs_version=fs_version, fs_exe=fs_exe, sims=sims)
+
+
+def _toml_value(value: object) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (int, float)):
+        return repr(value)
+    if isinstance(value, list):
+        return "[" + ", ".join(_toml_value(item) for item in value) + "]"
+    escaped = str(value).replace("\\", "\\\\").replace('"', '\\"')
+    return f'"{escaped}"'
+
+
+def convert_matrix(
+    path: str | Path,
+    *,
+    name: str,
+    fs_version: str,
+    fs_exe: str,
+    recipes: Mapping[str, str],
+) -> str:
+    """Emit the native ``campaign.toml`` text of a legacy matrix (FR-11).
+
+    Parameters are those of :func:`to_campaign`. The returned text
+    loads back through :func:`pyflightstream.cases.load_campaign`, so
+    migration is one call and reversible only in the sense that the
+    legacy file itself stays untouched and readable forever (FR-10).
+    """
+    campaign = to_campaign(path, name=name, fs_version=fs_version, fs_exe=fs_exe, recipes=recipes)
+    lines = [
+        "[campaign]",
+        f"name = {_toml_value(campaign.name)}",
+        f"fs_version = {_toml_value(campaign.fs_version)}",
+        f"fs_exe = {_toml_value(campaign.fs_exe)}",
+    ]
+    for sim in campaign.sims:
+        lines += [
+            "",
+            "[[sim]]",
+            f"sim_id = {_toml_value(sim.sim_id)}",
+            f"aircraft = {_toml_value(sim.aircraft)}",
+        ]
+        if sim.description:
+            lines.append(f"description = {_toml_value(sim.description)}")
+        if sim.reynolds is not None:
+            lines.append(f"reynolds = {_toml_value(sim.reynolds)}")
+        if sim.mach is not None:
+            lines.append(f"mach = {_toml_value(sim.mach)}")
+        plain_values = [
+            list(value) if isinstance(value, tuple) else value for value in sim.sweep.values
+        ]
+        lines.append(
+            f"sweep = {{type = {_toml_value(sim.sweep.type)}, "
+            f"values = {_toml_value(plain_values)}}}"
+        )
+        lines.append(f"recipe = {_toml_value(sim.recipe)}")
+        if sim.variables:
+            lines.append("[sim.variables]")
+            for key, value in sim.variables.items():
+                lines.append(f"{_toml_value(key)} = {_toml_value(value)}")
+    return "\n".join(lines) + "\n"