BUG: seed list/position sampling and decorrelate rocket components

StochasticModel list-valued attributes were sampled with the stdlib random.choice (an unseeded global) and StochasticRocket._randomize_position did the same for list-valued component positions, so random_seed did not govern either. Both now draw the index through the model's seeded generator via a shared _random_choice helper -- indexing, not numpy.random.choice, so heterogeneous objects (Function, paths, arrays) stay intact.

StochasticRocket._set_stochastic also handed the same seed to the rocket body and every surface, motor, rail button and parachute, so components sampling the same distribution drew identical values (a main and a drogue parachute got the same cd_s and lag quantiles). Each component is now reseeded from its own spawned child of a SeedSequence root, in a fixed order, so they stay independent and reproducible under random_seed.

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

Author: thc1006

rocketpy/stochastic/stochastic_model.py

@@ -506,6 +506,21 @@ def _validate_airfoil(self, airfoil):
                         "the first item"
                     )
 
+    def _random_choice(self, values):
+        """Choose one value from a list using this model's seeded generator.
+
+        The index is drawn from the seeded generator, not the stdlib global
+        ``random.choice`` (an unseeded shared instance), so the choice is
+        governed by ``random_seed``. Indexing rather than ``numpy.random.choice``
+        keeps a heterogeneous list -- ``Function`` objects, paths, arrays --
+        returned as itself instead of coerced to a common dtype. An empty
+        ``values`` is returned unchanged.
+        """
+        if not values:
+            return values
+        index = int(self.__random_number_generator.integers(len(values)))
+        return values[index]
+
     def dict_generator(self):
         """
         Generate a dictionary with randomly generated input arguments.
@@ -530,16 +545,7 @@ def dict_generator(self):
                 dist_sampler = value[-1]
                 generated_dict[arg] = dist_sampler(value[0], value[1])
             elif isinstance(value, list):
-                # Draw the index from this model's seeded generator so a
-                # list-valued attribute is reproducible under random_seed. The
-                # stdlib random.choice draws from an unseeded global instance,
-                # and numpy's choice coerces a heterogeneous list (Function,
-                # paths, arrays) to a single dtype; indexing avoids both.
-                if value:
-                    index = int(self.__random_number_generator.integers(len(value)))
-                    generated_dict[arg] = value[index]
-                else:
-                    generated_dict[arg] = value
+                generated_dict[arg] = self._random_choice(value)
             elif isinstance(value, CustomSampler):
                 try:
                     generated_dict[arg] = value.sample(n_samples=1)[0]

rocketpy/stochastic/stochastic_rocket.py

@@ -1,7 +1,8 @@
 """Defines the StochasticRocket class."""
 
 import warnings
-from random import choice
+
+import numpy as np
 
 from rocketpy.control import _Controller
 from rocketpy.mathutils.vector_matrix import Vector
@@ -21,6 +22,7 @@
 from rocketpy.rocket.rocket import Rocket
 from rocketpy.stochastic.stochastic_generic_motor import StochasticGenericMotor
 from rocketpy.stochastic.stochastic_motor_model import StochasticMotorModel
+from rocketpy.tools import _seed_sequence_to_int
 
 from .stochastic_aero_surfaces import (
     StochasticAirBrakes,
@@ -176,21 +178,29 @@ def _set_stochastic(self, seed=None):
         """Set the stochastic attributes for Components, positions and
         inputs.
 
+        Every nested component -- the rocket body, each aerodynamic surface,
+        motor, rail button and parachute -- is reseeded from its own child of a
+        ``SeedSequence`` root, so components that sample the same distribution do
+        not draw identical values (a main and a drogue parachute get independent
+        ``cd_s`` and ``lag`` samples, not the same one). Children are spawned in a
+        fixed order, so the result stays reproducible under ``random_seed``.
+
         Parameters
         ----------
         seed : int, optional
             Seed for the random number generator.
         """
-        super()._set_stochastic(seed)
+        root = np.random.SeedSequence(seed)
+        super()._set_stochastic(_seed_sequence_to_int(root.spawn(1)[0]))
         self.aerodynamic_surfaces = self.__reset_components(
-            self.aerodynamic_surfaces, seed
+            self.aerodynamic_surfaces, root
         )
-        self.motors = self.__reset_components(self.motors, seed)
-        self.rail_buttons = self.__reset_components(self.rail_buttons, seed)
+        self.motors = self.__reset_components(self.motors, root)
+        self.rail_buttons = self.__reset_components(self.rail_buttons, root)
         for parachute in self.parachutes:
-            parachute._set_stochastic(seed)
+            parachute._set_stochastic(_seed_sequence_to_int(root.spawn(1)[0]))
 
-    def __reset_components(self, components, seed):
+    def __reset_components(self, components, root):
         """Creates a new Components whose stochastic structures
         and their positions are reset.
 
@@ -199,8 +209,9 @@ def __reset_components(self, components, seed):
         components : Components
             The components which contains the stochastic structure that
             will be used to create the new components.
-        seed : int, optional
-            Seed for the random number generator.
+        root : numpy.random.SeedSequence
+            The run's seed root. Each component is reseeded from its own spawned
+            child, so components sampling the same distribution stay decorrelated.
 
         Returns
         -------
@@ -212,7 +223,7 @@ def __reset_components(self, components, seed):
         new_components = Components()
         for stochastic_obj, _ in components:
             stochastic_obj_position_info = self.__components_map[stochastic_obj]
-            stochastic_obj._set_stochastic(seed)
+            stochastic_obj._set_stochastic(_seed_sequence_to_int(root.spawn(1)[0]))
             new_components.add(
                 stochastic_obj,
                 self._validate_position(stochastic_obj, stochastic_obj_position_info),
@@ -628,7 +639,7 @@ def _randomize_position(self, position):
                 return position[-1](position[0].z, position[1])
             return position[-1](position[0], position[1])
         elif isinstance(position, list):
-            return choice(position) if position else position
+            return self._random_choice(position)
 
     # pylint: disable=stop-iteration-return
     def dict_generator(self):
@@ -638,8 +649,8 @@ def dict_generator(self):
         all attributes of the class and generating a random value for each
         attribute. The random values are generated according to the format of
         each attribute. Tuples are generated using the distribution function
-        specified in the tuple. Lists are generated using the random.choice
-        function.
+        specified in the tuple. Lists are sampled through the model's seeded
+        generator so the choice is governed by ``random_seed``.
 
         Parameters
         ----------

tests/unit/stochastic/test_stochastic_rocket_seeding.py

@@ -0,0 +1,46 @@
+"""Nested StochasticRocket components are reseeded from distinct SeedSequence
+children, so components that sample the same distribution (a main and a drogue
+parachute, for example) do not draw identical values. Reproducible under a fixed
+seed. See the seeding design in ``StochasticRocket._set_stochastic``.
+"""
+
+from rocketpy.stochastic.stochastic_model import StochasticModel
+
+# Captured once, before any patching, so wrapping it repeatedly in one test does
+# not stack (each recorder wraps the real method, not a previous recorder).
+_REAL_SET_STOCHASTIC = StochasticModel._set_stochastic
+
+
+def _record_component_seeds(monkeypatch, rocket, seed):
+    """Return the seeds handed to every nested component for one reseed."""
+    recorded = []
+
+    def recording(self, seed=None):
+        recorded.append(seed)
+        return _REAL_SET_STOCHASTIC(self, seed)
+
+    monkeypatch.setattr(StochasticModel, "_set_stochastic", recording)
+    rocket._set_stochastic(seed)
+    return recorded
+
+
+def test_rocket_components_receive_distinct_seeds(monkeypatch, stochastic_calisto):
+    """Every nested component (body, aerodynamic surfaces, motor, rail buttons and
+    the two parachutes) is reseeded from its own child, so none collide."""
+    seeds = _record_component_seeds(monkeypatch, stochastic_calisto, 42)
+
+    assert len(seeds) > 3, "expected the rocket body plus several components"
+    assert len(seeds) == len(set(seeds)), (
+        "components share a seed -- they would draw perfectly correlated samples"
+    )
+
+
+def test_rocket_component_seeds_are_reproducible(monkeypatch, stochastic_calisto):
+    """The same root seed reseeds every component identically; a different root
+    seed changes them."""
+    first = _record_component_seeds(monkeypatch, stochastic_calisto, 42)
+    again = _record_component_seeds(monkeypatch, stochastic_calisto, 42)
+    different = _record_component_seeds(monkeypatch, stochastic_calisto, 43)
+
+    assert again == first, "same seed must reproduce every component seed"
+    assert different != first, "a different seed must change the component seeds"