simjecture 0.1.0__py3-none-any.whl

conjecture_solver/benchmarks/kinetic_sufficiency.py

@@ -0,0 +1,318 @@
+"""Matched-moment kinetic stability counterexample.
+
+The normalization uses electron plasma frequency equal to one. Ions are an
+immobile neutralizing background. For a Gaussian component with weight a,
+drift u, and standard deviation sigma, its electrostatic susceptibility is
+
+    a / (k sigma)^2 * [1 + zeta Z(zeta)]
+
+where zeta = (omega - k u) / (sqrt(2) k sigma) and Z is the plasma dispersion
+function. The least-damped or fastest-growing root is the primary observable.
+"""
+
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+from pydantic import Field, model_validator
+from scipy.optimize import root
+from scipy.special import wofz
+
+from ..models import (
+    DomainSpec,
+    EvidenceContract,
+    HypothesisNode,
+    HypothesisOrigin,
+    MatchedPairFormalPredicate,
+    ObservableSpec,
+    PropositionClass,
+    StrictModel,
+)
+from ..semantics import MatchedObservation, SufficiencyWitness, evaluate_predictive_sufficiency
+
+
+class GaussianComponent(StrictModel):
+    weight: float = Field(gt=0, le=1)
+    drift: float
+    sigma: float = Field(gt=0)
+
+
+class GaussianMixture(StrictModel):
+    components: tuple[GaussianComponent, ...] = Field(min_length=1)
+
+    @model_validator(mode="after")
+    def normalized_weights(self) -> GaussianMixture:
+        if abs(sum(component.weight for component in self.components) - 1.0) > 1e-12:
+            raise ValueError("component weights must sum to one")
+        return self
+
+    def density(self) -> float:
+        return sum(component.weight for component in self.components)
+
+    def mean(self) -> float:
+        return sum(component.weight * component.drift for component in self.components)
+
+    def second_moment(self) -> float:
+        return sum(
+            component.weight * (component.sigma**2 + component.drift**2)
+            for component in self.components
+        )
+
+    def variance(self) -> float:
+        return self.second_moment() - self.mean() ** 2
+
+
+class DistributionMoments(StrictModel):
+    density: float
+    mean_velocity: float
+    variance: float = Field(ge=0)
+
+
+class LinearMode(StrictModel):
+    frequency: float
+    growth_rate: float
+    dielectric_residual: float = Field(ge=0)
+
+
+class KineticCaseResult(StrictModel):
+    name: str
+    distribution: GaussianMixture
+    moments: DistributionMoments
+    mode: LinearMode
+    classification: str
+
+
+class KineticSufficiencyResult(StrictModel):
+    schema_version: str = "0.1.0"
+    experiment_id: str = "planted_kinetic_sufficiency_v1"
+    hypothesis: HypothesisNode
+    observable: ObservableSpec
+    wavenumber: float = Field(gt=0)
+    maxwellian: KineticCaseResult
+    two_stream: KineticCaseResult
+    moments_match: bool
+    witness: SufficiencyWitness
+
+
+def plasma_dispersion(zeta: complex) -> complex:
+    return 1j * np.sqrt(np.pi) * wofz(zeta)
+
+
+def dielectric(
+    omega: complex,
+    wavenumber: float,
+    distribution: GaussianMixture,
+) -> complex:
+    value = 1.0 + 0.0j
+    with np.errstate(all="ignore"):
+        for component in distribution.components:
+            zeta = (omega - wavenumber * component.drift) / (
+                np.sqrt(2.0) * wavenumber * component.sigma
+            )
+            value += component.weight / (wavenumber * component.sigma) ** 2 * (
+                1.0 + zeta * plasma_dispersion(zeta)
+            )
+    return complex(value)
+
+
+def solve_modes(
+    distribution: GaussianMixture,
+    *,
+    wavenumber: float,
+    residual_tolerance: float = 1e-8,
+) -> tuple[LinearMode, ...]:
+    guesses = (
+        complex(real, imaginary)
+        for real in np.linspace(-2.0, 2.0, 9)
+        for imaginary in np.linspace(-0.8, 0.6, 8)
+    )
+    modes: list[LinearMode] = []
+    for guess in guesses:
+        with warnings.catch_warnings(), np.errstate(all="ignore"):
+            warnings.simplefilter("ignore", RuntimeWarning)
+            solution = root(
+                lambda pair: (
+                    dielectric(
+                        complex(float(pair[0]), float(pair[1])),
+                        wavenumber,
+                        distribution,
+                    ).real,
+                    dielectric(
+                        complex(float(pair[0]), float(pair[1])),
+                        wavenumber,
+                        distribution,
+                    ).imag,
+                ),
+                (guess.real, guess.imag),
+                tol=1e-11,
+            )
+        if not solution.success or not np.all(np.isfinite(solution.x)):
+            continue
+        omega = complex(float(solution.x[0]), float(solution.x[1]))
+        residual = abs(dielectric(omega, wavenumber, distribution))
+        if residual > residual_tolerance or abs(omega) > 10:
+            continue
+        if any(
+            abs(omega - complex(mode.frequency, mode.growth_rate)) < 1e-6 for mode in modes
+        ):
+            continue
+        modes.append(
+            LinearMode(
+                frequency=omega.real,
+                growth_rate=omega.imag,
+                dielectric_residual=float(residual),
+            )
+        )
+    if not modes:
+        raise RuntimeError("dispersion solver found no validated root")
+    return tuple(sorted(modes, key=lambda mode: mode.growth_rate, reverse=True))
+
+
+def moments(distribution: GaussianMixture) -> DistributionMoments:
+    return DistributionMoments(
+        density=distribution.density(),
+        mean_velocity=distribution.mean(),
+        variance=distribution.variance(),
+    )
+
+
+def classify_mode(mode: LinearMode, *, zero_tolerance: float = 1e-6) -> str:
+    if mode.growth_rate > zero_tolerance:
+        return "unstable"
+    if mode.growth_rate < -zero_tolerance:
+        return "damped"
+    return "neutral"
+
+
+def build_problem() -> tuple[HypothesisNode, ObservableSpec]:
+    domain = DomainSpec(
+        id="domain_linear_1d_vlasov_poisson_k05",
+        description=(
+            "Linear electrostatic perturbations of smooth normalized electron "
+            "distributions with immobile ions at k=0.5"
+        ),
+        model_family="linearized_1d_electrostatic_vlasov_poisson",
+        assumptions=(
+            "electron plasma frequency equals one",
+            "immobile neutralizing ion background",
+            "Gaussian-mixture equilibrium distributions",
+        ),
+        fixed_parameters={"wavenumber": 0.5},
+    )
+    observable = ObservableSpec(
+        id="observable_dominant_growth_rate",
+        name="dominant linear growth rate",
+        semantic_kind="dominant_linear_growth_rate",
+        mathematical_definition="maximum imaginary part among validated dielectric roots",
+        estimator="analytic Gaussian-mixture dielectric root solver",
+        units="electron_plasma_frequency",
+        tolerance=0.02,
+    )
+    hypothesis = HypothesisNode(
+        id="hypothesis_low_moments_sufficient_for_stability",
+        statement=(
+            "Density, mean velocity, and variance are sufficient to determine "
+            "the dominant linear growth rate in the declared distribution family."
+        ),
+        machine_predicate=(
+            "equal(n, mean_v, variance) implies abs(gamma_left-gamma_right) <= 0.02"
+        ),
+        formal_predicate=MatchedPairFormalPredicate(
+            matched_coordinates=("density", "mean_velocity", "variance"),
+            outcome_observable_id=observable.id,
+            maximum_outcome_difference=observable.tolerance,
+        ),
+        proposition_class=PropositionClass.PREDICTIVE_SUFFICIENCY,
+        domain=domain,
+        coordinates=("density", "mean_velocity", "variance"),
+        evidence_contract=EvidenceContract(
+            primary_observable_id=observable.id,
+            falsifying_witness=(
+                "a matched pair with equal declared moments and growth rates "
+                "separated by more than 0.02"
+            ),
+            primary_tolerance=observable.tolerance,
+        ),
+        origin=HypothesisOrigin.HUMAN,
+    )
+    return hypothesis, observable
+
+
+def run_kinetic_sufficiency_benchmark(
+    *,
+    wavenumber: float = 0.5,
+) -> KineticSufficiencyResult:
+    if abs(wavenumber - 0.5) > 1e-12:
+        raise ValueError("version 1 of the planted benchmark is preregistered at k=0.5")
+
+    maxwellian_distribution = GaussianMixture(
+        components=(GaussianComponent(weight=1.0, drift=0.0, sigma=1.0),)
+    )
+    drift = 0.9
+    component_sigma = float(np.sqrt(1.0 - drift**2))
+    two_stream_distribution = GaussianMixture(
+        components=(
+            GaussianComponent(weight=0.5, drift=-drift, sigma=component_sigma),
+            GaussianComponent(weight=0.5, drift=drift, sigma=component_sigma),
+        )
+    )
+
+    maxwellian_moments = moments(maxwellian_distribution)
+    two_stream_moments = moments(two_stream_distribution)
+    maxwellian_mode = solve_modes(
+        maxwellian_distribution,
+        wavenumber=wavenumber,
+    )[0]
+    two_stream_mode = solve_modes(
+        two_stream_distribution,
+        wavenumber=wavenumber,
+    )[0]
+    hypothesis, observable = build_problem()
+    coordinate_names = hypothesis.coordinates
+    left_coordinates = {
+        coordinate: getattr(maxwellian_moments, coordinate) for coordinate in coordinate_names
+    }
+    right_coordinates = {
+        coordinate: getattr(two_stream_moments, coordinate) for coordinate in coordinate_names
+    }
+    witness = evaluate_predictive_sufficiency(
+        hypothesis,
+        MatchedObservation(
+            evidence_id="evidence_maxwellian_mode",
+            coordinates=left_coordinates,
+            outcome=maxwellian_mode.growth_rate,
+            outcome_uncertainty=maxwellian_mode.dielectric_residual,
+        ),
+        MatchedObservation(
+            evidence_id="evidence_two_stream_mode",
+            coordinates=right_coordinates,
+            outcome=two_stream_mode.growth_rate,
+            outcome_uncertainty=two_stream_mode.dielectric_residual,
+        ),
+    )
+    moments_match = all(
+        abs(left_coordinates[name] - right_coordinates[name]) <= 1e-10
+        for name in coordinate_names
+    )
+    return KineticSufficiencyResult(
+        hypothesis=hypothesis,
+        observable=observable,
+        wavenumber=wavenumber,
+        maxwellian=KineticCaseResult(
+            name="unit_variance_maxwellian",
+            distribution=maxwellian_distribution,
+            moments=maxwellian_moments,
+            mode=maxwellian_mode,
+            classification=classify_mode(maxwellian_mode),
+        ),
+        two_stream=KineticCaseResult(
+            name="matched_moment_symmetric_two_stream",
+            distribution=two_stream_distribution,
+            moments=two_stream_moments,
+            mode=two_stream_mode,
+            classification=classify_mode(two_stream_mode),
+        ),
+        moments_match=moments_match,
+        witness=witness,
+    )

conjecture_solver/builtin_skills/warpx/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: warpx
+description: Author, commission, and diagnose simulations with the pinned WarpX 26.07 PICMI capability. Use for any hypothesis whose decisive evidence may require WarpX, especially multidimensional, collisional, electromagnetic, or fully kinetic particle-in-cell calculations.
+---
+
+# WarpX 26.07 PICMI skill
+
+Use this skill when a hypothesis can be challenged with a particle-in-cell
+calculation supported by the installed `warpx-cpu-26.07` or
+`warpx-cuda-openpmd-26.07` capability. The skill
+explains the instrument; it does not prescribe the scientific question,
+parameters, diagnostics, or conclusion.
+
+## Execution contract
+
+- Author the PICMI Python program and any analysis programs in the writable
+  workspace using workspace-relative action paths such as `probe.py`, never
+  `/work/probe.py`. The sandbox maps the working directory to `/work` only at
+  execution time.
+- Execute a PICMI program with `run_capability`, selecting
+  `warpx-cuda-openpmd-26.07` for local 2D GPU work or `warpx-cpu-26.07` for
+  the CPU fallback, and an argv whose first item is the workspace-relative
+  Python filename. Arguments are passed directly to the pinned Python
+  interpreter; there is no shell.
+- The capability has no host home, network, provider credential, or writable
+  location outside `/work`.
+- Before GPU production work, read `references/gpu-launch-tuning.md`. The CUDA
+  capability is non-MPI, 2D-only, and provides HDF5 openPMD diagnostics.
+- Ordinary `run_python` does not contain `pywarpx`. Use `run_capability` for
+  programs that import `pywarpx`; use ordinary Python for independent analysis
+  when its installed packages suffice.
+- Treat a zero exit status as execution success only. It is not scientific or
+  numerical qualification.
+- The harness health-checks each exact capability build once and caches the result.
+  Do not repeat generic import, CUDA, or openPMD smokes inside each campaign when
+  `capability_preflight` is healthy.
+- Use `stage=workbench` while authoring, debugging, or revising PICMI programs.
+  Workbench artifacts are provenance-recorded but permanently non-evidentiary and
+  need no claim or contract. Once the program is stable, freeze it and use
+  `stage=evidence` for prospective five-aspect qualification and scientific runs.
+
+## Recommended use
+
+1. Translate the active subhypothesis into observables and a falsifier.
+2. Derive scientific parameters from the active hypothesis, explicit operator
+   input, or sources retrieved during the campaign. Preserve that provenance in
+   the workspace. Then choose a supported geometry, field model, boundaries,
+   species distributions, time-integration scheme, and runtime. For
+   electromagnetic calculations, read `references/time-integration.md` before
+   fixing the timestep.
+3. Iterate on unknown interfaces and candidate programs in the workbench. Before
+   promoting a stable WarpX program, register a prospective evidence contract on
+   its instrument claim and transition to the complete physical commissioning
+   contract. Workbench success cannot be promoted retroactively; the evidence-stage
+   qualification must generate fresh artifacts from the frozen source.
+4. Begin workbench development with an inexpensive anchor that exercises the intended model and
+   diagnostic path. Make the program emit a compact JSON commissioning summary
+   with qualification booleans below a top-level `checks` object, and register
+   exact `validation_checks` such as `checks.completed` for its named
+   booleans. Tag checks as `representation`, `physics_controls`, `boundaries`,
+   `diagnostics`, or `numerical_regime`; one qualifying contract must cover all
+   five. `physics_controls` verifies that the interactions, forcing, sources,
+   or constitutive controls required by the claim are present in the realized
+   run and have a measured effect where relevant. An
+   `interface` check is useful but cannot qualify a scientific run by itself.
+   Commission the mathematical representation, not only execution.
+   Keep the commissioned program source immutable and parameterize anchors,
+   sweeps, and controls through arguments or configuration. Changed source must
+   be recommissioned before it can generate scientific evidence.
+5. Inspect the realized input and outputs. Challenge charge balance, current
+   and force balance, energy, boundaries, particle loading, interaction/source
+   activation, resolution, timestep, particle statistics, finite-domain
+   effects, and diagnostic definitions as relevant. Preserve quantitative
+   metrics behind every qualification boolean; do not make a boolean a mere
+   restatement of the requested inputs.
+6. Establish a numerical practice before using production runs as evidence.
+7. Preserve raw outputs and write analysis code in the workspace. Do not rely
+   only on terminal prose.
+
+Read these resources as needed:
+
+- `references/picmi-interface.md`: main Python construction sequence.
+- `references/2d-xz-commissioning.md`: required reading before any 2D Cartesian
+  run; coordinate, field-source, equilibrium, and preflight invariants.
+- `references/diagnostics.md`: field, particle, reduced, and openPMD outputs.
+- `references/time-integration.md`: explicit and implicit PICMI evolve schemes,
+  timestep selection, and solver qualification.
+- `references/numerical-risks.md`: common validity failures.
+- `references/resource-scaling.md`: controlling experiment cost.
+- `references/cpu-launch-tuning.md`: required before a long local-host CPU
+  campaign; detects MPI support, benchmarks OpenMP count/affinity and AMReX
+  block size, and records the Ryzen 9 9900X calibration.
+- `references/gpu-launch-tuning.md`: required before a local-host CUDA run;
+  verifies the actual backend, supplies the WSL launch environment, benchmarks
+  GPU block sizes, and records RTX 4000 Ada CPU/GPU comparisons.
+- `references/local-cuda-deployment.md`: required when installing or repairing
+  the CUDA/openPMD runtime on this or a new machine; use its pinned bootstrap,
+  post-install validation, and failure signatures.
+- `examples/minimal_smoke.py`: a one-step neutral-plasma interface smoke test;
+  it is deliberately not a scientific template. Its JSON booleans are under
+  `checks`.
+- `examples/implicit_em_smoke.py`: a one-step 2D theta-implicit electromagnetic
+  wiring and native-input smoke test; it is also permanently non-evidentiary.
+  Its JSON booleans are under `checks`. Run it in the workbench only when the
+  implicit interface itself is relevant; it does not prove loaded-plasma stability.
+- Host repository demos and operator launch scripts outside this skill tree are
+  not skill resources: sandbox agents cannot `read_skill` or
+  `materialize_skill_resource` them.
+- `examples/openpmd_field_smoke.py`: a one-step 2D field-diagnostic wiring and
+  openPMD/HDF5 readback smoke test; it is permanently non-evidentiary and is the
+  CPU and CUDA/openPMD capabilities' cached harness preflight. Campaign agents
+  normally need not repeat it. Its JSON booleans are under `checks`.
+- `scripts/benchmark_cpu_threads.py`: run an isolated, validated OpenMP scaling
+  sweep for an operator-supplied PICMI program and exact argument list. Never
+  infer MPI support merely from the presence of `mpiexec`; the script queries
+  the loaded AMReX library.
+- `scripts/run_local_cuda.sh`: operator-side launcher for the project-local 2D
+  CUDA runtime. Autonomous sandbox work uses the named CUDA capability instead.
+  Skill `scripts/` are host/operator tools: they are not exact-reuse sandbox
+  programs and typically cannot run inside the capability (for example they
+  may call `nvidia-smi`). Use `examples/*.py` for in-sandbox exact reuse.
+- `scripts/bootstrap_local_cuda.sh`: create the pinned CUDA, non-MPI HDF5, and
+  openPMD environments and compile the 2D WarpX binding from an audited source
+  checkout.
+- `scripts/probe_local_cuda.py`: prove CUDA-aware AMReX plus an openPMD HDF5
+  write/read round trip after deployment.
+- `scripts/benchmark_gpu.py`: run a guarded, validated CUDA block-size sweep;
+  it passes the operator-supplied program arguments through unchanged except
+  for the explicitly named block-size option.
+- `scripts/reduced_energy_budget.py`: materialize this deterministic sandbox-safe
+  reader for pinned single-level `FieldEnergy` plus `ParticleEnergy` diagnostics.
+  It selects exact total columns by realized header, refuses unknown schemas,
+  and prevents adding totals to their component/species columns.
+
+Official WarpX 26.07 documentation:
+
+- <https://warpx.readthedocs.io/en/latest/usage/python.html>
+- <https://warpx.readthedocs.io/en/latest/usage/parameters.html>
+- <https://warpx.readthedocs.io/en/latest/usage/workflows/analysis.html>
+
+## Boundaries
+
+Do not infer that WarpX is preferable merely because it is installed. A
+smaller analytic or ordinary-Python calculation may be a better discriminator.
+Do not claim that a runtime smoke test qualifies a physical regime. Do not
+silently change an observable or numerical policy after seeing a result;
+record the reason and treat the changed calculation as a new attempt.
+Never obtain scientific parameters, expected outcomes, acceptance thresholds,
+or benchmark definitions from this skill, its smoke examples, host-performance
+records, or an earlier demonstration. Retrieve or derive them within the active
+campaign and preserve their source.

conjecture_solver/builtin_skills/warpx/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "WarpX PIC Simulation"
+  short_description: "Commission and tune kinetic WarpX simulations"
+  default_prompt: "Use $warpx to design, commission, tune, and diagnose a WarpX particle-in-cell simulation."

conjecture_solver/builtin_skills/warpx/examples/implicit_em_smoke.py

@@ -0,0 +1,74 @@
+"""One-step WarpX theta-implicit EM interface smoke; never scientific evidence.
+
+Uses a tiny 2D grid so the same program runs under both the multi-dimension
+CPU capability and the 2D-only CUDA/openPMD capability.
+"""
+
+import json
+from pathlib import Path
+
+from pywarpx import picmi
+
+grid = picmi.Cartesian2DGrid(
+    number_of_cells=[8, 8],
+    lower_bound=[0.0, 0.0],
+    upper_bound=[1.0e-3, 1.0e-3],
+    lower_boundary_conditions=["periodic", "periodic"],
+    upper_boundary_conditions=["periodic", "periodic"],
+    lower_boundary_conditions_particles=["periodic", "periodic"],
+    upper_boundary_conditions_particles=["periodic", "periodic"],
+    warpx_max_grid_size=8,
+)
+solver = picmi.ElectromagneticSolver(grid=grid, method="Yee")
+nonlinear_solver = picmi.PicardNonlinearSolver(
+    require_convergence=True,
+    max_iterations=20,
+    relative_tolerance=1.0e-8,
+    absolute_tolerance=0.0,
+    diagnostic_file="picard_iterations.txt",
+    diagnostic_interval="1",
+)
+evolve_scheme = picmi.ThetaImplicitEMEvolveScheme(
+    nonlinear_solver=nonlinear_solver,
+    theta=0.5,
+)
+simulation = picmi.Simulation(
+    solver=solver,
+    time_step_size=1.0e-12,
+    max_steps=1,
+    particle_shape=1,
+    verbose=1,
+    warpx_evolve_scheme=evolve_scheme,
+    warpx_random_seed=1,
+    warpx_serialize_initial_conditions=True,
+    warpx_amrex_the_arena_init_size=256 * 1024 * 1024,
+    warpx_used_inputs_file="implicit_used_inputs",
+)
+for particle_type, name, frozen in (
+    ("electron", "electrons", False),
+    ("proton", "ions", True),
+):
+    species = picmi.Species(
+        particle_type=particle_type,
+        name=name,
+        initial_distribution=picmi.UniformDistribution(density=1.0e15),
+        warpx_do_not_push=frozen,
+    )
+    simulation.add_species(
+        species,
+        layout=picmi.GriddedLayout(grid=grid, n_macroparticle_per_cell=[1, 1]),
+    )
+
+simulation.step()
+used_inputs = Path("implicit_used_inputs").read_text()
+checks = {
+    "completed": True,
+    "theta_implicit_native": 'algo.evolve_scheme = "theta_implicit_em"'
+    in used_inputs,
+    "picard_native": 'implicit_evolve.nonlinear_solver = "picard"' in used_inputs,
+    "convergence_required_native": "picard.require_convergence = 1" in used_inputs,
+    "scientific_evidence_eligible": False,
+}
+Path("implicit_capability_smoke.json").write_text(
+    json.dumps({"checks": checks}) + "\n"
+)

conjecture_solver/builtin_skills/warpx/examples/minimal_smoke.py

@@ -0,0 +1,54 @@
+"""One-step WarpX/PICMI interface smoke; permanently non-evidentiary."""
+
+import json
+from pathlib import Path
+
+from pywarpx import picmi
+
+grid = picmi.Cartesian1DGrid(
+    number_of_cells=[8],
+    lower_bound=[0.0],
+    upper_bound=[1.0e-3],
+    lower_boundary_conditions=["periodic"],
+    upper_boundary_conditions=["periodic"],
+    lower_boundary_conditions_particles=["periodic"],
+    upper_boundary_conditions_particles=["periodic"],
+    warpx_max_grid_size=8,
+)
+solver = picmi.ElectrostaticSolver(grid=grid)
+simulation = picmi.Simulation(
+    solver=solver,
+    time_step_size=1.0e-14,
+    max_steps=1,
+    particle_shape=1,
+    verbose=1,
+    warpx_random_seed=1,
+    warpx_serialize_initial_conditions=True,
+    warpx_used_inputs_file="warpx_used_inputs",
+)
+for particle_type, name, frozen in (
+    ("electron", "electrons", False),
+    ("proton", "ions", True),
+):
+    species = picmi.Species(
+        particle_type=particle_type,
+        name=name,
+        initial_distribution=picmi.UniformDistribution(density=1.0e15),
+        warpx_do_not_push=frozen,
+    )
+    simulation.add_species(
+        species,
+        layout=picmi.GriddedLayout(grid=grid, n_macroparticle_per_cell=[1]),
+    )
+simulation.step()
+Path("capability_smoke.json").write_text(
+    json.dumps(
+        {
+            "checks": {
+                "completed": True,
+                "scientific_evidence_eligible": False,
+            }
+        }
+    )
+    + "\n"
+)

conjecture_solver/builtin_skills/warpx/examples/openpmd_field_smoke.py

@@ -0,0 +1,87 @@
+"""One-step 2D openPMD/HDF5 field-diagnostic smoke; never scientific evidence."""
+
+import json
+from pathlib import Path
+
+import openpmd_api as io
+from pywarpx import picmi
+
+grid = picmi.Cartesian2DGrid(
+    number_of_cells=[8, 8],
+    lower_bound=[0.0, 0.0],
+    upper_bound=[1.0e-3, 1.0e-3],
+    lower_boundary_conditions=["periodic", "periodic"],
+    upper_boundary_conditions=["periodic", "periodic"],
+    lower_boundary_conditions_particles=["periodic", "periodic"],
+    upper_boundary_conditions_particles=["periodic", "periodic"],
+    warpx_max_grid_size=8,
+)
+solver = picmi.ElectromagneticSolver(grid=grid, method="Yee")
+simulation = picmi.Simulation(
+    solver=solver,
+    time_step_size=1.0e-14,
+    max_steps=1,
+    particle_shape=1,
+    verbose=1,
+    warpx_random_seed=1,
+    warpx_serialize_initial_conditions=True,
+    warpx_amrex_the_arena_init_size=256 * 1024 * 1024,
+    warpx_used_inputs_file="openpmd_used_inputs",
+)
+for particle_type, name in (("electron", "electrons"), ("proton", "ions")):
+    species = picmi.Species(
+        particle_type=particle_type,
+        name=name,
+        initial_distribution=picmi.UniformDistribution(
+            density=1.0e15,
+            rms_velocity=[1.0e3, 1.0e3, 1.0e3],
+        ),
+        warpx_do_not_push=True,
+    )
+    simulation.add_species(
+        species,
+        layout=picmi.GriddedLayout(
+            grid=grid,
+            n_macroparticle_per_cell=[1, 1],
+        ),
+    )
+
+simulation.add_diagnostic(
+    picmi.FieldDiagnostic(
+        name="fields",
+        grid=grid,
+        period=1,
+        data_list=["E", "B", "J", "rho"],
+        write_dir="openpmd_diags",
+        warpx_format="openpmd",
+        warpx_openpmd_backend="h5",
+        warpx_openpmd_encoding="f",
+    )
+)
+simulation.step()
+
+used_inputs = Path("openpmd_used_inputs").read_text()
+h5_files = sorted(Path("openpmd_diags").rglob("*.h5"))
+iteration_count = 0
+mesh_record_count = 0
+if h5_files:
+    series = io.Series(str(h5_files[0]), io.Access.read_only)
+    # Iteration objects have .time and .meshes, not .iteration.
+    iteration_count = len(series.iterations)
+    mesh_record_count = sum(
+        len(series.iterations[index].meshes) for index in series.iterations
+    )
+    series.close()
+
+checks = {
+    "completed": True,
+    "openpmd_format_native": 'fields.format = "openpmd"' in used_inputs,
+    "h5_backend_native": 'fields.openpmd_backend = "h5"' in used_inputs,
+    "h5_file_nonempty": bool(h5_files and h5_files[0].stat().st_size > 0),
+    "iteration_readable": iteration_count > 0,
+    "mesh_records_readable": mesh_record_count > 0,
+    "scientific_evidence_eligible": False,
+}
+Path("openpmd_capability_smoke.json").write_text(
+    json.dumps({"checks": checks}) + "\n"
+)