processforge 0.3.16__tar.gz → 0.3.17__tar.gz

{processforge-0.3.16/src/processforge.egg-info → processforge-0.3.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.16
+Version: 0.3.17
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Processforge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause

{processforge-0.3.16 → processforge-0.3.17}/flowsheets/openmc/msre_eigenvalue.json

@@ -26,7 +26,7 @@
       "id": 2,
       "density": 9.0,
       "density_units": "g/cm3",
-      "temperature": 400.0,
+      "temperature": 300.0,
       "elements": [
         { "element": "Ni", "percent": 0.72, "percent_type": "wo" },
         { "element": "Mo", "percent": 0.16, "percent_type": "wo" },

{processforge-0.3.16 → processforge-0.3.17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "processforge"
-version = "0.3.16"
+version = "0.3.17"
 description = "A Python-based process simulation framework for chemical engineering applications."
 readme = "README.md"
 license = "BSD-3-Clause"

{processforge-0.3.16 → processforge-0.3.17}/src/processforge/cli/run.py

@@ -87,6 +87,8 @@ def run(
         logger.info("=== Dynamic Results ===")
         results = fs.run()
 
+        _check_for_failed_units(fs)
+
         if hasattr(fs, "converged"):
             if fs.converged:
                 logger.info("Dynamic simulation converged.")
@@ -106,6 +108,8 @@ def run(
         logger.info("=== Steady-State EO Results ===")
         results = fs.run()
 
+        _check_for_failed_units(fs)
+
         if hasattr(fs, "converged"):
             if fs.converged:
                 logger.info("Steady-state simulation converged.")
@@ -153,3 +157,32 @@ def run(
             logger.info(f"Plots saved: {base_name}_results.png, {base_name}_timeseries.png")
         except Exception as e:
             logger.warning(f"Failed to generate plots: {type(e).__name__}: {e}")
+
+
+def _check_for_failed_units(fs):
+    """Fail loudly if any SolverUnit run returned ``status="failed"``.
+
+    Containerized providers return HTTP 200 with a structured ``EngineOutput``
+    (status="failed") rather than raising, so the failure would otherwise be
+    swallowed and recorded as a successful run. Surface it clearly and exit
+    non-zero.
+    """
+    from ..types import EngineOutput
+
+    failed = {
+        name: out
+        for name, out in getattr(fs, "engine_outputs", {}).items()
+        if isinstance(out, EngineOutput) and out.status == "failed"
+    }
+    if not failed:
+        return
+
+    for name, out in failed.items():
+        err = out.error
+        category = getattr(err, "category", "unknown") if err else "unknown"
+        message = getattr(err, "message", "") if err else ""
+        logger.error(f"Unit '{name}' simulation FAILED [{category}]: {message}")
+        hint = getattr(err, "hint", "") if err else ""
+        if hint:
+            logger.error(f"  hint: {hint}")
+    raise SystemExit(1)

{processforge-0.3.16 → processforge-0.3.17}/src/processforge/providers/container_client.py

@@ -91,6 +91,7 @@ class ContainerProviderClient(AbstractProvider):
             "out": unit_config.out,
             "sim_type": unit_config.sim_type,
             "solver_config": unit_config.solver_config,
+            "geometry_config": unit_config.geometry_config,
             **unit_config.extra,
         }
 

processforge-0.3.17/src/processforge/providers/errors.py

@@ -0,0 +1,275 @@
+"""Provider-side run-error classification.
+
+When a simulation is executed *inside* a provider/engine (e.g. OpenMC or FESTIM
+running in a Docker container) the run can fail for reasons that live entirely
+in the engine — missing nuclear-data temperatures, an MPI process abort, a
+geometry that excludes a source point, a tally that references an unknown
+filter, … . These are distinct from *flowsheet/setup* errors (bad JSON, unknown
+material, schema validation), which are caught earlier during initialization or
+flowsheet validation.
+
+This module gives every provider a single, structured way to capture such a
+run-time failure:
+
+* :class:`ProviderRunError` — a typed, engine-agnostic record of what failed,
+  attributed to ``source="provider"`` so Processforge (and the user) can tell a
+  runtime engine error apart from a flowsheet configuration error.
+* :func:`classify_run_error` — turn an exception (plus any captured
+  stdout/stderr from the engine) into a :class:`ProviderRunError`, picking a
+  category and a
+  concrete remediation hint where one is known.
+* :func:`make_failed_output` — build the ``EngineOutput(status="failed")`` that
+  providers return, populated with the classification.
+
+Categories are intentionally broad so a new engine signature can be added here
+without touching the providers.
+"""
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from pydantic import BaseModel
+
+# Error categories. Strings (not an Enum) so they serialize cleanly in JSON
+# through the provider HTTP API and are easy to match on in tests/docs.
+NUCLEAR_DATA = "nuclear_data"
+CROSS_SECTIONS = "cross_sections"
+MPI_ABORT = "mpi_abort"
+GEOMETRY = "geometry"
+TALLY = "tally"
+CONVERGENCE = "convergence"
+INPUT_VALIDATION = "input_validation"
+ENVIRONMENT = "environment"
+UNKNOWN = "unknown"
+
+# (category, compiled-regex, remediation hint). First match wins.
+# Order matters: more specific (and more actionable) patterns come first.
+_ERROR_SIGNATURES: list[tuple[str, re.Pattern[str], str]] = [
+    (
+        NUCLEAR_DATA,
+        re.compile(
+            r"nuclear data library does not contain cross sections",
+            re.IGNORECASE,
+        ),
+        (
+            "The cross-section library lacks data at the requested "
+            "temperature. "
+            "Either set the material temperature to a value present in the library "
+            "(e.g. 300 K), or enable openmc.Settings.temperature handling "
+            "(temperature_method / multipole interpolation) so intermediate "
+            "temperatures are treated."
+        ),
+    ),
+    (
+        CROSS_SECTIONS,
+        re.compile(
+            r"cross section[s]? (file|library|data|xml)|"
+            r"could not (find|read|open).*cross_section|"
+            r"no cross sections (available|found)|"
+            r"cross_sections\.xml",
+            re.IGNORECASE,
+        ),
+        (
+            "Cross-section data could not be located or parsed. Verify the "
+            "provider 'cross_sections' path points at a valid cross_sections.xml "
+            "and that the data directory is mounted into the container."
+        ),
+    ),
+    (
+        MPI_ABORT,
+        re.compile(r"MPI_ABORT|mpi abort|orted: \w+ rank", re.IGNORECASE),
+        (
+            "The solver process crashed (MPI_ABORT). The root cause is usually the "
+            "preceding engine error (e.g. nuclear-data or geometry failure); fix "
+            "that first. If it occurs with no preceding error, the container may "
+            "be out of memory or MPI may be misconfigured."
+        ),
+    ),
+    (
+        GEOMETRY,
+        re.compile(
+            r"geometry ?error|cannot find cell|no cell found|"
+            r"particle (got )?lost|surface .*? not (found|defined)|"
+            r"universe .*? not (found|defined)|geometry does not contain",
+            re.IGNORECASE,
+        ),
+        (
+            "The problem geometry is invalid or the source/particles fall outside "
+            "it. Check geometry_config dimensions and the source_point location, "
+            "and ensure every referenced material region is filled."
+        ),
+    ),
+    (
+        TALLY,
+        re.compile(r"tally ?error|tally .*? (not|does not) (exist|have)|invalid filter", re.IGNORECASE),
+        (
+            "A tally or its filter is invalid. Check mesh_tallies / tally scores, "
+            "filter IDs, and that referenced cells/meshes exist in the geometry."
+        ),
+    ),
+    (
+        CONVERGENCE,
+        re.compile(
+            r"did not converge|maximum number of (iterations|resampling)|"
+            r"failed to converge|stagnat",
+            re.IGNORECASE,
+        ),
+        (
+            "The solve did not converge. Increase batches/iterations or relax "
+            "tolerances in solver_config; verify the model is well-posed."
+        ),
+    ),
+    (
+        INPUT_VALIDATION,
+        re.compile(
+            r"valueerror|keyerror|typeerror|validation ?error|"
+            r"expected .*? (got|found)|missing .*? argument",
+            re.IGNORECASE,
+        ),
+        (
+            "The engine rejected the resolved configuration. This usually means a "
+            "value in solver_config/geometry_config is out of range or mistyped."
+        ),
+    ),
+    (
+        ENVIRONMENT,
+        re.compile(
+            r"permission denied|no such file or directory|"
+            r"cannot (write|create) .*? directory|"
+            r"shared library|lib[a-z0-9]+\.so",
+            re.IGNORECASE,
+        ),
+        (
+            "An environment/container issue (file permissions, missing library, "
+            "or unwritable output dir). Check the container mounts and that the "
+            "output directory is writable."
+        ),
+    ),
+]
+
+
+class ProviderRunError(BaseModel):
+    """Structured record of a run-time failure that originated in a provider/engine.
+
+    Attributes:
+        category: One of the ``*`` constants above (``nuclear_data``, ``mpi_abort``,
+            …). ``unknown`` when no signature matched.
+        source: Always ``"provider"`` — distinguishes engine run-time failures
+            from flowsheet/setup validation errors.
+        message: A concise, human-readable one-line summary of the failure.
+        type: The Python exception class name (e.g. ``RuntimeError``).
+        detail: The full captured error text (engine stderr/stdout + traceback
+            tail). May be long; this is what gets logged.
+        hint: A concrete remediation suggestion where a category is recognised,
+            else a generic pointer to check the engine log.
+    """
+
+    category: str = UNKNOWN
+    source: str = "provider"
+    message: str = ""
+    type: str = "Exception"
+    detail: str = ""
+    hint: str = (
+        "Inspect the engine log / run directory for the root cause; this is a "
+        "run-time error raised by the provider, not a flowsheet configuration error."
+    )
+
+    @classmethod
+    def from_exception(
+        cls,
+        exc: BaseException,
+        captured: str = "",
+        category: Optional[str] = None,
+    ) -> "ProviderRunError":
+        """Build a :class:`ProviderRunError` from an exception (category overridable)."""
+        text = str(exc)
+        if captured:
+            text = f"{text}\n\n{captured}".strip()
+        # Prefer an explicitly supplied category (e.g. a provider already knows).
+        if category is None:
+            category = _classify_text(text)
+        return cls(
+            category=category,
+            message=_summarize(text) or f"{type(exc).__name__}: {text}",
+            type=type(exc).__name__,
+            detail=text,
+            hint=_hint_for(category),
+        )
+
+
+def classify_run_error(
+    engine: str,
+    exc: BaseException,
+    captured: str = "",
+) -> ProviderRunError:
+    """Classify a provider run-time exception into a :class:`ProviderRunError`.
+
+    Args:
+        engine: Engine name (``"openmc"``, ``"festim"``, …) — recorded for context
+            only (it does not change classification today).
+        exc: The exception raised by the engine run.
+        captured: Optional captured engine stdout/stderr, used to improve the
+            classification when the raised message is terse.
+
+    Returns:
+        A populated :class:`ProviderRunError` (``source="provider"``).
+    """
+    err = ProviderRunError.from_exception(exc, captured=captured)
+    err.message = f"[{engine}] {err.message}"
+    return err
+
+
+def make_failed_output(
+    engine: str,
+    sim_type: str,
+    run_dir,
+    err: ProviderRunError,
+    unit: str = "",
+) -> "EngineOutput":  # type: ignore[name-defined]  # imported lazily to avoid cycle
+    """Build the ``EngineOutput(status="failed")`` providers return on a run error."""
+    from processforge.types import EngineOutput
+
+    return EngineOutput(
+        status="failed",
+        engine=engine,
+        sim_type=sim_type,
+        unit=unit,
+        error=err,
+        diagnostics={
+            "run_dir": str(getattr(run_dir, "resolve", lambda: run_dir)()),
+            "error": err.detail,
+            "error_category": err.category,
+            "error_source": err.source,
+        },
+    )
+
+
+def _classify_text(text: str) -> str:
+    for category, pattern, _hint in _ERROR_SIGNATURES:
+        if pattern.search(text):
+            return category
+    return UNKNOWN
+
+
+def _hint_for(category: str) -> str:
+    for cat, _pattern, hint in _ERROR_SIGNATURES:
+        if cat == category:
+            return hint
+    return ProviderRunError().hint
+
+
+def _summarize(text: str, limit: int = 280) -> str:
+    """Return the most diagnostic single line of ``text`` (engine ERROR lines win)."""
+    lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
+    if not lines:
+        return ""
+    for ln in lines:
+        if ln.upper().startswith("ERROR") or "ERROR:" in ln.upper():
+            return ln[:limit]
+    # Fall back to the first line that looks like a message (not a banner/traceback).
+    for ln in lines:
+        if ln.startswith(("Traceback", "File ", "raise ", "Proc:", "NOTE:")):
+            continue
+        return ln[:limit]
+    return lines[0][:limit]

{processforge-0.3.16 → processforge-0.3.17}/src/processforge/providers/festim_provider.py

@@ -67,6 +67,7 @@ from processforge.types import (
     OutputField,
     OutputProvenance,
 )
+from processforge.providers.errors import classify_run_error, make_failed_output
 from processforge.units import Quantity
 
 if TYPE_CHECKING:
@@ -771,15 +772,8 @@ class FestimProvider(AbstractProvider):
             logger.exception(
                 f"FestimProvider: '{sim_type}' failed in '{run_dir}': {exc}"
             )
-            return EngineOutput(
-                status="failed",
-                engine="festim",
-                sim_type=sim_type,
-                diagnostics={
-                    "run_dir": str(run_dir.resolve()),
-                    "error": str(exc),
-                },
-            )
+            err = classify_run_error("festim", exc)
+            return make_failed_output("festim", sim_type, run_dir, err)
         finally:
             os.chdir(prev_cwd)
 

{processforge-0.3.16 → processforge-0.3.17}/src/processforge/providers/openmc_provider.py

@@ -60,6 +60,7 @@ from processforge.types import (
     OutputField,
     OutputProvenance,
 )
+from processforge.providers.errors import classify_run_error, make_failed_output
 from processforge.units import Quantity
 
 
@@ -806,15 +807,8 @@ class OpenMCProvider(AbstractProvider):
                 logger.exception(
                     f"OpenMCProvider: '{sim_type}' failed in '{run_dir}': {exc}"
                 )
-                return EngineOutput(
-                    status="failed",
-                    engine="openmc",
-                    sim_type=sim_type,
-                    diagnostics={
-                        "run_dir": str(run_dir.resolve()),
-                        "error": str(exc),
-                    },
-                )
+                err = classify_run_error("openmc", exc)
+                return make_failed_output("openmc", sim_type, run_dir, err)
             finally:
                 if xs_path:
                     if original_xs is None:

{processforge-0.3.16 → processforge-0.3.17}/src/processforge/types.py

@@ -473,6 +473,10 @@ class EngineOutput(BaseModel):
     artifacts: list[OutputArtifact] = Field(default_factory=list)
     diagnostics: dict = Field(default_factory=dict)
     provenance: OutputProvenance = Field(default_factory=OutputProvenance)
+    # Structured classification of a run-time failure (populated only when
+    # status == "failed"). source is always "provider" so a runtime engine error
+    # is distinguishable from a flowsheet/setup validation error.
+    error: Optional["ProviderRunError"] = None
 
     # -- convenience accessors -------------------------------------------
     def get_field(self, name: str) -> Optional[OutputField]:
@@ -623,3 +627,14 @@ class MergedInletTimeseries(BaseModel):
 
     def __iter__(self):
         return iter(MergedInletTimeseries.model_fields)
+
+
+# Imported at the end (not at module top) to avoid an import cycle: the
+# providers package __init__ pulls in provider subclasses that themselves
+# import this module. ``ProviderRunError`` defines no dependency on types.py,
+# so importing it here — after every model above is defined — is safe.
+from processforge.providers.errors import ProviderRunError  # noqa: E402
+
+# Resolve the forward reference used in ``EngineOutput.error`` now that
+# ``ProviderRunError`` is available in this module's namespace.
+EngineOutput.model_rebuild()

{processforge-0.3.16 → processforge-0.3.17/src/processforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.16
+Version: 0.3.17
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Processforge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause

{processforge-0.3.16 → processforge-0.3.17}/src/processforge.egg-info/SOURCES.txt

@@ -88,6 +88,7 @@ src/processforge/providers/cantera_jacobian.py
 src/processforge/providers/cantera_provider.py
 src/processforge/providers/container_client.py
 src/processforge/providers/coolprop_provider.py
+src/processforge/providers/errors.py
 src/processforge/providers/festim_provider.py
 src/processforge/providers/jacobian_contributor.py
 src/processforge/providers/manager.py
@@ -122,11 +123,13 @@ src/processforge/utils/unit_consistency.py
 src/processforge/utils/validate_flowsheet.py
 src/processforge/utils/validation.py
 tests/test_cli.py
+tests/test_container_client.py
 tests/test_coupling.py
 tests/test_festim_provider.py
 tests/test_festim_schema.py
 tests/test_init.py
 tests/test_openmc_provider.py
+tests/test_provider_errors.py
 tests/test_providers.py
 tests/test_s3_upload.py
 tests/test_state.py

processforge-0.3.17/tests/test_container_client.py

@@ -0,0 +1,33 @@
+"""Tests for the CLI-side container provider HTTP client serialization."""
+
+from processforge.providers.container_client import ContainerProviderClient
+from processforge.types import UnitConfig
+
+
+def test_serialize_unit_config_includes_geometry_config():
+    """geometry_config must survive the CLI -> container body serialization.
+
+    Regression test for the bug where geometry_config (a known UnitConfig
+    field) was dropped by the hardcoded serialization list, so the container
+    received an empty geometry_config and failed validation.
+    """
+    geometry_config = {
+        "type": "reactor_core",
+        "core_radius": 72.5,
+        "core_height": 160.0,
+        "core_material": "salt",
+    }
+    uc = UnitConfig(
+        type="SolverUnit",
+        provider="openmc",
+        material=3,
+        sim_type="eigenvalue_reactor",
+        solver_config={"batches": 20},
+        geometry_config=geometry_config,
+    )
+
+    body = ContainerProviderClient._serialize_unit_config(uc)
+
+    assert body["geometry_config"] == geometry_config
+    assert body["solver_config"] == {"batches": 20}
+    assert body["sim_type"] == "eigenvalue_reactor"

{processforge-0.3.16 → processforge-0.3.17}/tests/test_festim_provider.py

@@ -837,8 +837,13 @@ class TestFestimRunSimulation:
 
         result = provider.run_simulation(unit_cfg, {})
         assert result.status == "failed"
-        assert "SNES diverged" in result.metadata["error"]
-        assert result.metadata["run_dir"] == str((tmp_path / "festim_run").resolve())
+        assert "SNES diverged" in result.diagnostics["error"]
+        assert result.diagnostics["run_dir"] == str((tmp_path / "festim_run").resolve())
+        # Failure is classified and attributed to the provider, not the flowsheet.
+        assert result.error is not None
+        assert result.error.source == "provider"
+        assert result.diagnostics["error_source"] == "provider"
+        assert result.error.detail
 
     def test_run_before_init_raises(self, fake_festim):
         from processforge.providers.festim_provider import FestimProvider

{processforge-0.3.16 → processforge-0.3.17}/tests/test_openmc_provider.py

@@ -435,6 +435,25 @@ def test_run_exception_returns_failed_result(tmp_path, fake_openmc):
     assert os.environ.get("OPENMC_CROSS_SECTIONS") == prior
 
 
+def test_run_exception_is_classified(tmp_path, fake_openmc):
+    """A nuclear-data run failure must be classified with source='provider'."""
+    from processforge.providers.errors import NUCLEAR_DATA
+
+    provider = _init_provider(tmp_path, _default_materials())
+    _CTRL.raise_msg = (
+        "Nuclear data library does not contain cross sections for Ni58 at or near "
+        "400.000000 K. Available temperatures are 300 K."
+    )
+    result = provider.run_simulation(_unit_config(), {})
+
+    assert result.status == "failed"
+    assert result.error is not None
+    assert result.error.category == NUCLEAR_DATA
+    assert result.error.source == "provider"
+    assert result.diagnostics["error_category"] == NUCLEAR_DATA
+    assert "temperature" in result.error.hint.lower()
+
+
 def test_run_without_statepoint_returns_failed(tmp_path, fake_openmc):
     provider = _init_provider(tmp_path, _default_materials())
     result = provider.run_simulation(_unit_config(), {})

processforge-0.3.17/tests/test_provider_errors.py

@@ -0,0 +1,104 @@
+"""Tests for the provider run-error classification utility."""
+from __future__ import annotations
+
+import pathlib
+
+from processforge.providers.errors import (
+    CROSS_SECTIONS,
+    GEOMETRY,
+    MPI_ABORT,
+    NUCLEAR_DATA,
+    ProviderRunError,
+    UNKNOWN,
+    classify_run_error,
+    make_failed_output,
+)
+from processforge.types import EngineOutput
+
+
+def _classify(msg: str, engine: str = "openmc", captured: str = "") -> ProviderRunError:
+    return classify_run_error(engine, RuntimeError(msg), captured=captured)
+
+
+def test_nuclear_data_category_and_hint():
+    err = _classify(
+        "Nuclear data library does not contain cross sections for Ni58 at or near "
+        "400.000000 K. Available temperatures are 300 K."
+    )
+    assert err.category == NUCLEAR_DATA
+    assert err.source == "provider"
+    assert "temperature" in err.hint.lower()
+    assert err.type == "RuntimeError"
+
+
+def test_mpi_abort_category():
+    err = _classify(
+        "RuntimeError: something bad\n"
+        "MPI_ABORT was invoked on rank 0 in communicator MPI_COMM_WORLD"
+    )
+    assert err.category == MPI_ABORT
+
+
+def test_cross_sections_category():
+    err = _classify("Could not find cross_sections.xml at the configured path")
+    assert err.category == CROSS_SECTIONS
+
+
+def test_geometry_category():
+    err = _classify("GeometryError: Could not find cell containing particle")
+    assert err.category == GEOMETRY
+
+
+def test_unknown_fallback():
+    err = _classify("some totally opaque engine complaint with no known signature")
+    assert err.category == UNKNOWN
+    assert err.source == "provider"
+    assert "run-time" in err.hint
+
+
+def test_message_prefixed_with_engine():
+    err = _classify("Nuclear data library does not contain cross sections for Ni58")
+    assert err.message.startswith("[openmc]")
+
+
+def test_captured_text_improves_classification():
+    # Raised message is terse; the real signal is in the captured engine stderr.
+    err = _classify(
+        "RuntimeError",
+        captured="ERROR: Nuclear data library does not contain cross sections for U235",
+    )
+    assert err.category == NUCLEAR_DATA
+
+
+def test_from_exception_sets_fields():
+    err = ProviderRunError.from_exception(ValueError("bad value"))
+    assert err.type == "ValueError"
+    assert err.category == "input_validation" or err.category  # input_validation or unknown
+    assert err.detail
+
+
+def test_make_failed_output_shape(tmp_path):
+    run_dir = tmp_path / "run"
+    run_dir.mkdir()
+    err = _classify("Nuclear data library does not contain cross sections for Ni58")
+    out = make_failed_output("openmc", "eigenvalue_reactor", run_dir, err, unit="msre")
+    assert isinstance(out, EngineOutput)
+    assert out.status == "failed"
+    assert out.engine == "openmc"
+    assert out.sim_type == "eigenvalue_reactor"
+    assert out.unit == "msre"
+    assert out.error is err
+    assert out.diagnostics["error_category"] == NUCLEAR_DATA
+    assert out.diagnostics["error_source"] == "provider"
+    assert out.diagnostics["run_dir"] == str(run_dir.resolve())
+    assert out.diagnostics["error"]
+
+
+def test_engine_output_roundtrip_serialization(tmp_path):
+    err = _classify("Nuclear data library does not contain cross sections for Ni58")
+    out = make_failed_output("openmc", "eigenvalue_reactor", tmp_path, err)
+    dumped = out.model_dump()
+    restored = EngineOutput.model_validate(dumped)
+    assert restored.status == "failed"
+    assert restored.error is not None
+    assert restored.error.category == NUCLEAR_DATA