Make kinetic tRNA charging deterministic

Author: thalassemia

ecoli/processes/polypeptide_elongation.py

@@ -24,6 +24,7 @@
 from wholecell.utils.random import stochasticRound
 from wholecell.utils import units
 from wholecell.utils._trna_charging import (
+    seed_rng,
     get_initiations,
     reconcile_via_ribosome_positions,
     reconcile_via_trna_pools,
@@ -321,6 +322,7 @@ def __init__(self, parameters=None):
 
         self.seed = self.parameters["seed"]
         self.random_state = np.random.RandomState(seed=self.seed)
+        seed_rng(self.seed)
 
     def ports_schema(self):
         return {
@@ -2886,7 +2888,7 @@ def protein_maturation(
             candidates = np.logical_and(
                 did_terminate, [self.is_map_substrate[x] for x in protein_indexes]
             )
-            i_cannot_cleave = np.random.multinomial(
+            i_cannot_cleave = self.process.random_state.multinomial(
                 not_cleaved, candidates / candidates.sum()
             ).astype(bool)
 

wholecell/tests/utils/test_trna_charging.py

@@ -8,6 +8,7 @@
 from __future__ import absolute_import, division, print_function
 
 from wholecell.utils._trna_charging import (
+    seed_rng,
     get_initiations,
     get_codon_at,
     get_candidates_to_C,
@@ -35,7 +36,7 @@ def tearDownClass(cls):
         pass
 
     def setUp(self):
-        pass
+        seed_rng(0)
 
     def tearDown(self):
         pass
@@ -489,5 +490,91 @@ def test_get_codons_read(self):
         assert_equal(n_codons_read, np.array([3, 3], dtype=np.int64))
 
 
+def test_reconcile_different_seeds_different_results():
+    """
+    Tests that reconcile_via_ribosome_positions:
+    - Produces DIFFERENT outputs given the same inputs but DIFFERENT random seeds
+    - Produces SAME outputs given the same inputs and SAME random seeds
+    """
+    # --- 1. Define two different seeds ---
+    seed1 = 12345
+    seed2 = 54321
+
+    # --- 2. Define fixed, non-trivial inputs ---
+    # (Using the same inputs as the previous 20-codon example)
+    initial_sequence_codons = np.array(
+        [5, 2, 8, 3, 1, 4, 6, 5, 9, 3, 7, 3, 5, 1, 8, 2, 4, 6, 2, 10], dtype=np.int64
+    )
+    kinetics_codons = np.array(
+        [6, 1, 7, 4, 2, 3, 5, 3, 8, 2, 6, 4, 6, 0, 9, 1, 5, 5, 1, 9], dtype=np.int64
+    )
+    initial_elongations = np.array([8, 12, 5, 10, 7], dtype=np.int64)
+    sequences = np.array(
+        [
+            [0, 1, 2, 3, 4, 5, 6, 7, -1, -1, -1, -1, -1, -1, -1],
+            [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, -1, -1, -1],
+            [1, 3, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
+            [2, 4, 6, 8, 10, 12, 14, 16, 18, 0, -1, -1, -1, -1, -1],
+            [19, 17, 15, 13, 11, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1],
+        ],
+        dtype=np.int8,
+    )
+    max_attempts = np.int8(50)
+
+    # --- 3. Run 1 with seed1 ---
+    sequence_codons_run1 = np.copy(initial_sequence_codons)
+    elongations_run1 = np.copy(initial_elongations)
+    seed_rng(seed1)  # Seed with first seed
+    reconcile_via_ribosome_positions(
+        sequence_codons_run1,
+        elongations_run1,
+        kinetics_codons,
+        sequences,
+        max_attempts,
+    )
+
+    # --- 4. Run 2 with seed2 ---
+    sequence_codons_run2 = np.copy(initial_sequence_codons)
+    elongations_run2 = np.copy(initial_elongations)
+    seed_rng(seed2)  # Seed with second, different seed
+    reconcile_via_ribosome_positions(
+        sequence_codons_run2,
+        elongations_run2,
+        kinetics_codons,
+        sequences,
+        max_attempts,
+    )
+
+    # --- 5. Run 3 with seed1 ---
+    sequence_codons_run3 = np.copy(initial_sequence_codons)
+    elongations_run3 = np.copy(initial_elongations)
+    seed_rng(seed1)  # Seed with first seed
+    reconcile_via_ribosome_positions(
+        sequence_codons_run3,
+        elongations_run3,
+        kinetics_codons,
+        sequences,
+        max_attempts,
+    )
+
+    # --- 6. Assert inequality ---
+    # Check that the results are different for different seed.
+    sequence_codons_differ = np.any(sequence_codons_run1 != sequence_codons_run2)
+    elongations_differ = np.any(elongations_run1 != elongations_run2)
+
+    # --- 7. Assert equality ---
+    # Check that the results are same for same seed.
+    sequence_codons_same = np.all(sequence_codons_run1 == sequence_codons_run3)
+    elongations_same = np.all(elongations_run1 == elongations_run3)
+
+    assert sequence_codons_differ or elongations_differ, (
+        "Outputs were unexpectedly identical for different seeds."
+    )
+
+    assert sequence_codons_same or elongations_same, (
+        "Outputs were unexpectedly different for same seeds."
+    )
+
+
 if __name__ == "__main__":
     unittest.main()

wholecell/utils/_trna_charging.pyx

@@ -17,6 +17,10 @@ from libc.time cimport time, time_t
 np.import_array()
 cimport cython
 
+cpdef seed_rng(unsigned int seed):
+	"""Seeds the C standard library RNG used by this module."""
+	srand(seed)
+
 @cython.boundscheck(False)  # Deactivate bounds checking
 @cython.wraparound(False)   # Deactivate negative indexing
 @cython.cdivision(True)		# Deactivate 0 division checking
@@ -165,10 +169,6 @@ cpdef reconcile_via_ribosome_positions(
 	char max_attempts, # 8-bit integer
 	):
 
-	# Set random seed
-	cdef time_t t = time(NULL)
-	srand(t)
-
 	# Initialize variables
 	cdef char attempt = 0
 	cdef int i = 0
@@ -359,10 +359,6 @@ cpdef reconcile_via_trna_pools(
 	char [:] trnas_to_amino_acid_indexes, # 8-bit integer
 	):
 
-	# Set random seed
-	cdef time_t t = time(NULL)
-	srand(t)
-
 	# Initialize variables
 	cdef int i = 0
 	# cdef int j = 0