BUG: validate the run seed before truncating output; tidy the seed helper

simulate() set up (and, for append=False, truncated with w+) the input/output/error files before the seed was validated, so passing a rejected seed such as a Generator destroyed a previous run's results on the way to raising a TypeError. The seed is now captured and validated before __setup_files runs.

Moved _seed_sequence_to_int to rocketpy.tools so the stochastic models can share it, and corrected its docstring: a 128-bit int is accepted by default_rng and random.Random, but the legacy RandomState caps a single-int seed at 2**32-1, so the earlier 'accepted by RandomState' claim was wrong.

Signed-off-by: thc1006 <84045975+thc1006@users.noreply.github.com>

Author: thc1006

rocketpy/simulation/monte_carlo.py

@@ -30,6 +30,7 @@
 from rocketpy.prints.monte_carlo_prints import _MonteCarloPrints
 from rocketpy.simulation.flight import Flight
 from rocketpy.tools import (
+    _seed_sequence_to_int,
     generate_monte_carlo_ellipses,
     generate_monte_carlo_ellipses_coordinates,
     import_optional_dependency,
@@ -240,18 +241,22 @@ def simulate(
         self._export_config = kwargs
         self.number_of_simulations = number_of_simulations
         self._initial_sim_idx = self.num_of_loaded_sims if append else 0
-        # Small, picklable root seed state captured once per run; every
-        # simulation index derives its child seed from it (see __child_seed).
-        self.__root_state = None
+
+        # Capture the small, picklable root seed state once per run (every
+        # simulation index derives its child seed from it, see __child_seed).
+        # This validates random_seed *before* __setup_files truncates any
+        # existing output, so an invalid seed cannot destroy prior results on
+        # the way to raising.
+        self.__capture_root_state(random_seed)
 
         print("Starting Monte Carlo analysis")
 
         self.__setup_files(append)
 
         if parallel:
-            self.__run_in_parallel(n_workers, random_seed)
+            self.__run_in_parallel(n_workers)
         else:
-            self.__run_in_serial(random_seed)
+            self.__run_in_serial()
 
         self.__terminate_simulation()
 
@@ -359,14 +364,12 @@ def __seed_simulation(self, child_seed):
         self.rocket._set_stochastic(_seed_sequence_to_int(rocket_seed))
         self.flight._set_stochastic(_seed_sequence_to_int(flight_seed))
 
-    def __run_in_serial(self, random_seed=None):  # pylint: disable=too-many-statements
+    def __run_in_serial(self):  # pylint: disable=too-many-statements
         """
         Runs the monte carlo simulation in serial mode.
 
-        Parameters
-        ----------
-        random_seed : int or SeedSequence, optional
-            Root seed for the run. See ``simulate``.
+        The root seed state is captured by ``simulate`` before this runs, so each
+        simulation index derives its child seed from ``self.__root_state``.
 
         Returns
         -------
@@ -377,7 +380,6 @@ def __run_in_serial(self, random_seed=None):  # pylint: disable=too-many-stateme
             n_simulations=self.number_of_simulations,
             start_time=time(),
         )
-        self.__capture_root_state(random_seed)
         try:
             while sim_monitor.keep_simulating():
                 sim_idx = sim_monitor.increment() - 1
@@ -408,17 +410,19 @@ def __run_in_serial(self, random_seed=None):  # pylint: disable=too-many-stateme
                 f.write(inputs_json)
             raise error
 
-    def __run_in_parallel(self, n_workers=None, random_seed=None):
+    def __run_in_parallel(self, n_workers=None):
         """
         Runs the monte carlo simulation in parallel.
 
+        The root seed state is captured by ``simulate`` before this runs and
+        travels with the pickled instance, so every worker derives the same
+        per-index child seed from ``self.__root_state``.
+
         Parameters
         ----------
         n_workers: int, optional
             Number of workers to be used. If None, the number of workers
             will be equal to the number of CPUs available. Default is None.
-        random_seed : int or SeedSequence, optional
-            Root seed for the run. See ``simulate``.
 
         Returns
         -------
@@ -446,8 +450,6 @@ def __run_in_parallel(self, n_workers=None, random_seed=None):
             # the sampled inputs do not depend on the number of workers. The
             # root state is small and travels with the pickled instance, so no
             # per-index seed list is materialized or sent to each process.
-            self.__capture_root_state(random_seed)
-
             for _ in range(n_workers):
                 sim_producer = multiprocess.Process(
                     target=self.__sim_producer,
@@ -1710,26 +1712,6 @@ def export_errors_to_json(self, filename):
         self._write_log_to_json(self.errors_log, filename)
 
 
-def _seed_sequence_to_int(seed_sequence):
-    """Collapse a ``SeedSequence`` into a 128-bit Python ``int``.
-
-    A plain ``int`` is the one seed type accepted alike by
-    ``numpy.random.default_rng``, ``numpy.random.RandomState`` and the stdlib
-    ``random.Random`` (which rejects a ``SeedSequence`` with a ``TypeError``
-    since Python 3.11), so a custom sampler whose ``reset_seed`` documents an
-    ``int`` keeps working. All four ``uint32`` words are combined to keep the
-    full 128-bit pool, so the environment/rocket/flight sub-streams stay
-    decorrelated instead of collapsing to a single 32-bit word.
-
-    The words are combined by value (little-endian word order), not via
-    ``tobytes()``, so the seed is the same on big- and little-endian machines
-    -- a byte-order-dependent seed would break the cross-platform
-    reproducibility this whole scheme exists to provide.
-    """
-    words = seed_sequence.generate_state(4, dtype=np.uint32)
-    return sum(int(word) << (32 * position) for position, word in enumerate(words))
-
-
 def _claim_next_index(sim_monitor, mutex):
     """Atomically claim the next 0-based simulation index, or ``None`` if done.
 

rocketpy/tools.py

@@ -1467,6 +1467,29 @@ def find_obj_from_hash(obj, hash_, depth_limit=None):
     return None
 
 
+def _seed_sequence_to_int(seed_sequence):
+    """Collapse a ``SeedSequence`` into a 128-bit Python ``int``.
+
+    A plain ``int`` is what ``numpy.random.default_rng`` and the stdlib
+    ``random.Random`` both accept (``random.Random`` rejects a ``SeedSequence``
+    with a ``TypeError`` since Python 3.11), so a custom sampler whose
+    ``reset_seed`` documents an ``int`` and builds a modern generator keeps
+    working. The legacy ``numpy.random.RandomState`` is the exception: it caps a
+    single-integer seed at ``2**32 - 1``, so a sampler still built on it would
+    have to reduce the value (``RandomState`` is a frozen legacy API NumPy steers
+    new code away from). All four ``uint32`` words are combined to keep the full
+    128-bit pool, so sub-streams stay decorrelated instead of collapsing to a
+    single 32-bit word.
+
+    The words are combined by value (little-endian word order), not via
+    ``tobytes()``, so the seed is the same on big- and little-endian machines --
+    a byte-order-dependent seed would break the cross-platform reproducibility
+    this exists to provide.
+    """
+    words = seed_sequence.generate_state(4, dtype=np.uint32)
+    return sum(int(word) << (32 * position) for position, word in enumerate(words))
+
+
 if __name__ == "__main__":  # pragma: no cover
     import doctest
 

tests/integration/simulation/test_monte_carlo_determinism.py

@@ -150,6 +150,36 @@ def _simulate_inputs(
     return _read_inputs_by_index(montecarlo.input_file)
 
 
+def test_invalid_seed_does_not_truncate_existing_output(
+    monkeypatch,
+    tmp_path,
+    stochastic_environment,
+    stochastic_calisto_numpy_only,
+    stochastic_flight,
+):
+    """A rejected seed must fail before any output file is truncated, so passing
+    an invalid seed cannot destroy the results of a previous run."""
+    monkeypatch.setattr(mc_module, "Flight", _StubFlight)
+    montecarlo = MonteCarlo(
+        filename=str(tmp_path / "keep"),
+        environment=stochastic_environment,
+        rocket=stochastic_calisto_numpy_only,
+        flight=stochastic_flight,
+    )
+    with open(montecarlo.input_file, "w", encoding="utf-8") as existing:
+        existing.write("previous results\n")
+
+    # A Generator is not a seed and is rejected; the run must raise before the
+    # ``w+`` file setup truncates anything.
+    with pytest.raises(TypeError):
+        montecarlo.simulate(
+            number_of_simulations=3, random_seed=np.random.default_rng(0)
+        )
+
+    with open(montecarlo.input_file, encoding="utf-8") as kept:
+        assert kept.read() == "previous results\n"
+
+
 def test_serial_inputs_are_reproducible(
     monkeypatch,
     tmp_path,