Add low temperature collapse detection

Refactor numerics: rename minimum_temperature_eV to T_minimum_eV, update checks and tests

minor:resolving conflict

minor fix: updated LowtemperatureCollapseTest

Fixing : low temperature collapse test

Fixing : low temperature collapse test

Fixing: Code duplication

Remove __init__.py from orchestration/tests

Add low-temperature collapse detection and error handling

- Add T_minimum_eV config parameter (default 50 eV) to numerics
- Implement low_temperature_below() method in CoreProfiles
- Add LOW_TEMPERATURE_COLLAPSE error state to SimError enum
- Refactor check_for_errors() as SimulationStepFn class method
- Add mock-based test for low-temperature collapse detection
- Remove empty __init__.py from orchestration/tests

Author: Mani212005

.gitignore

@@ -29,3 +29,7 @@ _build
 
 # venv
 venv
+.venv
+
+# Python version file
+.python-version

torax/_src/config/numerics.py

@@ -17,6 +17,7 @@
 import dataclasses
 import functools
 from typing import Annotated
+from typing import Optional
 
 import chex
 import jax
@@ -126,6 +127,9 @@ class Numerics(torax_pydantic.BaseModelFrozen):
   adaptive_T_source_prefactor: pydantic.PositiveFloat = 2.0e10
   adaptive_n_source_prefactor: pydantic.PositiveFloat = 2.0e8
 
+  # NEW: Minimum allowed physical temperature (in eV)
+  T_minimum_eV: pydantic.PositiveFloat = 5.0
+
   @pydantic.model_validator(mode='after')
   def model_validation(self) -> Self:
     if self.t_initial > self.t_final:

torax/_src/orchestration/step_function.py

@@ -127,7 +127,7 @@ def solver(self) -> solver_lib.Solver:
   @property
   def time_step_calculator(self) -> ts.TimeStepCalculator:
     return self._time_step_calculator
-
+  
   def is_done(self, t: jax.Array) -> bool | jax.Array:
     return self._time_step_calculator.is_done(
         t=t,
@@ -142,6 +142,7 @@ def check_for_errors(
   ) -> state.SimError:
     """Checks for errors in the simulation state."""
     if self._runtime_params_provider.numerics.adaptive_dt:
+      
       if output_state.solver_numeric_outputs.solver_error_state == 1:
         # Only check for min dt if the solver did not converge. Else we may have
         # converged at a dt > min_dt just before we reach min_dt.
@@ -151,6 +152,13 @@ def check_for_errors(
             < self._runtime_params_provider.numerics.min_dt
         ):
           return state.SimError.REACHED_MIN_DT
+    
+    # Low-temperature collapse check
+    if output_state.core_profiles.low_temperature_below(
+        self._runtime_params_provider.numerics.T_minimum_eV
+    ):
+      return state.SimError.LOW_TEMPERATURE_COLLAPSE
+    
     state_error = output_state.check_for_errors()
     if state_error != state.SimError.NO_ERROR:
       return state_error
@@ -556,4 +564,4 @@ def _fixed_step(
             input_post_processed_outputs=previous_post_processed_outputs,
         )
     )
-    return output_state, post_processed_outputs
+    return output_state, post_processed_outputs

torax/_src/orchestration/tests/initial_state_test.py

@@ -17,10 +17,19 @@
 from torax._src.config import build_runtime_params
 from torax._src.orchestration import initial_state
 from torax._src.orchestration import run_simulation
+from torax._src.orchestration import step_function
 from torax._src.output_tools import output
 from torax._src.test_utils import core_profile_helpers
 from torax._src.test_utils import sim_test_case
 from torax._src.torax_pydantic import model_config
+from torax._src.orchestration import sim_state
+from torax._src.output_tools import post_processing
+import jax.numpy as jnp
+from torax._src import state
+from torax._src.config import numerics as numerics_lib
+from torax._src.fvm import cell_variable
+from torax._src.geometry import circular_geometry
+from unittest import mock
 
 # pylint: disable=invalid-name
 
@@ -127,5 +136,51 @@ def test_core_profile_final_step(self, test_config):
     )
 
 
+class LowTemperatureCollapseTest(sim_test_case.SimTestCase):
+    """Tests for low temperature collapse error detection."""
+
+    def test_low_temperature_triggers_error(self):
+        """Test that temperatures below threshold trigger LOW_TEMPERATURE_COLLAPSE error."""
+        
+        # Create mock CoreProfiles
+        mock_core_profiles = mock.MagicMock()
+        mock_core_profiles.low_temperature_below.return_value = True
+        
+        # Create mock output_state
+        mock_output_state = mock.MagicMock()
+        mock_output_state.core_profiles = mock_core_profiles
+        mock_output_state.solver_numeric_outputs.solver_error_state = 0
+        mock_output_state.check_for_errors.return_value = state.SimError.NO_ERROR
+        
+        # Create mock post_processed_outputs
+        mock_post_processed_outputs = mock.MagicMock()
+        mock_post_processed_outputs.check_for_errors.return_value = state.SimError.NO_ERROR
+        
+        # Create a real step_fn from a test config
+        torax_config = self._get_torax_config('test_iterhybrid_rampup.py')
+        real_step_fn = run_simulation.make_step_fn(torax_config)
+        
+        # Mock the numerics to have our test value
+        mock_numerics = mock.MagicMock()
+        mock_numerics.T_minimum_eV = 50.0
+        mock_numerics.adaptive_dt = False
+        
+        # Replace the runtime_params_provider's numerics
+        original_provider = real_step_fn._runtime_params_provider
+        mock_provider = mock.MagicMock()
+        mock_provider.numerics = mock_numerics
+        real_step_fn._runtime_params_provider = mock_provider
+        
+        # Call check_for_errors
+        error = real_step_fn.check_for_errors(mock_output_state, mock_post_processed_outputs)
+        
+        # Restore original provider
+        real_step_fn._runtime_params_provider = original_provider
+        
+        # Assert that LOW_TEMPERATURE_COLLAPSE error is detected
+        self.assertEqual(error, state.SimError.LOW_TEMPERATURE_COLLAPSE)
+        # Verify that low_temperature_below was called with the right threshold
+        mock_core_profiles.low_temperature_below.assert_called_once_with(50.0)
+
 if __name__ == '__main__':
-  absltest.main()
+  absltest.main()

torax/_src/state.py

@@ -167,6 +167,19 @@ def negative_temperature_or_density(self) -> jax.Array:
         ])
     )
 
+  def low_temperature_below(self, T_minimum_eV: float) -> bool:
+      """Return True if T_e or T_i fall below the minimum temperature threshold."""
+      # Convert eV → keV since internal storage is keV
+      te_min_keV = T_minimum_eV / 1000.0
+
+      return np.any(
+          np.array([
+              np.any(np.less(self.T_e.value, te_min_keV)),
+              np.any(np.less(self.T_i.value, te_min_keV)),
+          ])
+      )
+
+
   def __str__(self) -> str:
     return f"""
       CoreProfiles(
@@ -292,6 +305,8 @@ class SimError(enum.Enum):
   QUASINEUTRALITY_BROKEN = 2
   NEGATIVE_CORE_PROFILES = 3
   REACHED_MIN_DT = 4
+  LOW_TEMPERATURE_COLLAPSE = 5
+
 
   def log_error(self):
     match self:
@@ -320,6 +335,12 @@ def log_error(self):
             quasineutrality. Check the output file for near-zero temperatures or
             densities at the last valid step.
             """)
+      case SimError.LOW_TEMPERATURE_COLLAPSE:
+        logging.error("""
+          Simulation stopped because electron temperature fell below the configured minimum
+          threshold (Te_min). This is usually caused by radiative collapse or runaway
+          cooling. Output file contains all profiles up to the last valid step
+        """)
       case SimError.NO_ERROR:
         pass
       case _: