diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 4bd18e9..f502a79 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -24,7 +24,7 @@ repos:
 
 -   repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.16.0
+    rev: v0.16.1
     hooks:
       # Run the linter.
     -   id: ruff
@@ -58,7 +58,7 @@ repos:
 
 -   repo: https://github.com/astral-sh/uv-pre-commit
     # uv version.
-    rev: 0.11.32
+    rev: 0.12.0
     hooks:
     -   id: uv-lock
 
diff --git a/cable_thermal_model/model/abstract_model.py b/cable_thermal_model/model/abstract_model.py
index 8ee08e2..0278c54 100644
--- a/cable_thermal_model/model/abstract_model.py
+++ b/cable_thermal_model/model/abstract_model.py
@@ -20,30 +20,20 @@ class AbstractModel(ABC, Generic[ModelRunOptionsT, StateT, ScenarioSchemaT, Stat
     """Abstract base class for thermal cable models."""
 
     static_env: StaticEnvT
-    scenario: DataFrame[ScenarioSchemaT]
     _scenario_schema_class: type[ScenarioSchemaT]
 
     def __str__(self):
         """Generates a concise string representation of the model."""
         num_circuits = len(self.static_env.circuits)
-        num_days = (self.scenario.index[-1] - self.scenario.index[0]).days
-        num_days = round(num_days, 1) if num_days < 7 else int(num_days)  # round for readability  # noqa: PLR2004
-        return f"Model with {num_circuits} circuit environment and {num_days} day scenario"
+        return f"Model with {num_circuits} circuit environment"
 
     def __repr__(self):
         """Generates an informative string representation of the model."""
-        return (
-            "Environment\n\n"
-            + f"{tab_lines(repr(self.static_env))}\n"
-            + "\n\tScenario\n"
-            + f"{tab_lines(tab_lines(repr(self.scenario.describe())))}\n"
-        )
+        return "Environment\n\n" + f"{tab_lines(repr(self.static_env))}\n"
 
-    def __init__(self, static_env: StaticEnvT, scenario: DataFrame[ScenarioSchemaT]):
-        """Initialise the model with a static environment and scenario DataFrame."""
-        # Validate that the scenario dataframe provides the required cable loads and ambient temperature.
+    def __init__(self, static_env: StaticEnvT):
+        """Initialise the model with a static environment."""
         self.static_env = static_env
-        self.set_scenario(scenario=scenario)
         self._set_run_options(run_options=None)
 
     def _validate_scenario(self, scenario: pd.DataFrame) -> DataFrame[ScenarioSchemaT]:
@@ -63,31 +53,13 @@ def _validate_scenario(self, scenario: pd.DataFrame) -> DataFrame[ScenarioSchema
 
         return self._scenario_schema_class.validate(scenario)
 
-    def set_scenario(self, scenario: pd.DataFrame):
-        """Sets a new scenario and validates it.
-
-        Args:
-            scenario: The new scenario dataframe
-
-        """
-        self.scenario = self._validate_scenario(scenario=scenario)
-
-        # Set up time grids
-        self.time_max: float = (self.scenario.index[-1] - self.scenario.index[0]).total_seconds()
-        self.time_grid: list[float] = list((self.scenario.index - self.scenario.index[0]).total_seconds())
-        self.time_samples: int = len(self.time_grid)
-
-    @property
-    def n_scenario_rows(self) -> int:
-        """Returns the number of time steps in the scenario."""
-        return len(self.scenario.index)
-
     def run(
         self,
+        scenario: pd.DataFrame,
         initial_state: StateT | None = None,
         run_options: ModelRunOptionsT | dict | None = None,
     ) -> ModelOutputSchema[StateT]:
-        """Computes the temperature solutions for all cable objects.
+        """Computes the temperature solutions for all cable objects in the model for the given scenario.
 
         Notes:
             Be careful about changing default run option values. The following settings affect the
@@ -99,9 +71,10 @@ def run(
             - initial_state
 
         Args:
+            scenario: Scenario dataframe for this run. The dataframe is validated internally before execution.
             initial_state: Heating information from a previous computation.
-            run_options: Run options for the model. If `None` or a dictionary is provided, the
-                options are validated and default values are applied.
+            run_options: Run options for this simulation run. If `None` or a dictionary is provided,
+                the options are validated and default values are applied.
 
         Returns:
             ModelOutputSchema: Temperature solutions for all cables.
@@ -110,12 +83,14 @@ def run(
             ValueError: If the provided initial state does not match the model environment.
 
         """
+        validated_scenario = self._validate_scenario(scenario=scenario)
         self._set_run_options(run_options=run_options)
 
         self._validate_initial_state(initial_state=initial_state)
 
         # Compute the temperature solution.
         result = self._compute_temperature_solution(
+            scenario=validated_scenario,
             initial_state=initial_state,
         )
 
@@ -128,6 +103,7 @@ def _set_run_options(self, run_options: ModelRunOptionsT | dict | None) -> None:
     @abstractmethod
     def _compute_temperature_solution(
         self,
+        scenario: DataFrame[ScenarioSchemaT],
         initial_state: StateT | None = None,
     ) -> ModelOutputSchema[StateT]:
         """Compute and return the full temperature solution for the configured scenario."""
diff --git a/cable_thermal_model/model/cables/cable.py b/cable_thermal_model/model/cables/cable.py
index 667aa79..92e2d16 100644
--- a/cable_thermal_model/model/cables/cable.py
+++ b/cable_thermal_model/model/cables/cable.py
@@ -267,7 +267,7 @@ def update_pipe_fill_resistivity(self, temperature_grid: np.ndarray) -> None:
         self._update_rho_grid(
             start_index=pipe_fill_start_index,
             end_index=pipe_fill_end_index,
-            rho=new_pipe_fill_rho,
+            rho_values=new_pipe_fill_rho,
         )
 
     def get_layer_indices_for_layer(self, layer: CableLayer) -> tuple[int, int]:
@@ -446,27 +446,27 @@ def _calculate_inter_rhos(self, radii: np.ndarray, inter_radii: np.ndarray, rhos
             radii[1:] / radii[:-1]
         )
 
-    def _update_rho_grid(self, start_index: int, end_index: int, rho: float) -> None:
-        """Update a slice of the rho-grid with a new value if significant change is detected.
+    def _update_rho_grid(self, start_index: int, end_index: int, rho_values: np.ndarray | float) -> None:
+        """Update a slice of the rho-grid if any new value differs by more than 1% from the current value.
 
         Args:
             start_index (int): The starting index of the slice to update (inclusive).
             end_index (int): The ending index of the slice to update (inclusive).
-            rho (float): The new resistivity value to set for the specified slice.
+            rho_values (np.ndarray | float): The new resistivity value(s) to set for the specified slice.
 
         """
         if start_index > end_index:
             raise ValueError("The start_index exceeds the end_index. Cannot update the rho grid.")
 
-        rho_slice = self._rho_grid[start_index : end_index + 1]
-        if np.all(np.isclose(rho_slice, rho, rtol=1e-2)):
-            return
+        old_rho_values = self._rho_grid[start_index : end_index + 1]
+        rho_values_changed = not np.all(np.isclose(old_rho_values, rho_values, rtol=1e-2))
 
-        self._rho_grid[start_index : end_index + 1] = rho
-        self._invalidate_finite_difference_matrix_diagonals()
+        if rho_values_changed:
+            self._rho_grid[start_index : end_index + 1] = rho_values
+            self._invalidate_finite_difference_matrix_diagonals()
 
     def _update_capacity_grid(self, start_index: int, end_index: int, capacity: float) -> None:
-        """Update a slice of the capacity-grid with a new value if significant change is detected.
+        """Update a slice of the capacity-grid with a new value.
 
         Args:
             start_index (int): The starting index of the slice to update (inclusive).
@@ -477,10 +477,6 @@ def _update_capacity_grid(self, start_index: int, end_index: int, capacity: floa
         if start_index > end_index:
             raise ValueError("The start_index exceeds the end_index. Cannot update the capacity grid.")
 
-        capacity_slice = self._capacity_grid[start_index : end_index + 1]
-        if np.all(np.isclose(capacity_slice, capacity, rtol=1e-2)):
-            return
-
         self._capacity_grid[start_index : end_index + 1] = capacity
 
     def _update_vector_with_heat_generation_for_layer(self, heat_generation: float, layer: CableLayer) -> None:
diff --git a/cable_thermal_model/model/cables/cable_soil.py b/cable_thermal_model/model/cables/cable_soil.py
index 6ea26dc..464d5c5 100644
--- a/cable_thermal_model/model/cables/cable_soil.py
+++ b/cable_thermal_model/model/cables/cable_soil.py
@@ -105,30 +105,40 @@ def _update_soil_resistivity(self, soil_rho: float, dry_soil_radius: float | Non
 
         Args:
             soil_rho (float):
-                An optional float representing the thermal resistivity of the soil that is not dried out.
+                The new thermal resistivity of the soil that is not dried out.
             dry_soil_radius (float | None):
-                A float representing the radius of the dried-out soil around the cable.
+                The radius of the dried-out soil around the cable. If None, no dried-out soil is assumed.
+                All grid points with radius <= dry_soil_radius are treated as dry.
 
         """
-        start_index = self._get_soil_grid_start_index()
+        soil_start_index = self._get_soil_grid_start_index()
+        new_rho_values = np.full(self.grid_size - soil_start_index, soil_rho)
+
+        if dry_soil_radius is not None:
+            dry_soil_end_index = int((self._radii_grid <= dry_soil_radius).sum()) - 1
+            if dry_soil_end_index >= soil_start_index:
+                dry_soil_rho = 2.5  # mK/W, value taken from NPR3626
+                new_rho_values[: dry_soil_end_index - soil_start_index + 1] = dry_soil_rho
+
         self._update_rho_grid(
-            start_index=start_index,
+            start_index=soil_start_index,
             end_index=self.grid_size - 1,
-            rho=soil_rho,
+            rho_values=new_rho_values,
         )
 
-        if dry_soil_radius is not None:
-            dry_soil_rho = 2.5  # mK/W, value taken from NPR3626
-            end_index = int((self._radii_grid <= dry_soil_radius).sum()) - 1
-            if end_index > start_index:
-                self._update_rho_grid(
-                    start_index=start_index,
-                    end_index=end_index,
-                    rho=dry_soil_rho,
-                )
-
     def _get_dry_soil_radius(self, temperature_grid: np.ndarray, soil_drying: bool) -> float | None:
-        """Return the radius of dried-out soil based on temperature and scenario settings."""
+        """Return the dried-out soil radius from the current temperature grid.
+
+        When soil drying is enabled, all grid points with temperature >= ``_SOIL_DRYING_TEMPERATURE``
+        are considered dried out and the radius of the outermost such grid point is returned, if any.
+
+        Args:
+            temperature_grid (np.ndarray): The temperature grid for the cable, as calculated for a given timestep.
+            soil_drying (bool): Whether the scenario takes soil drying into account.
+
+        Returns:
+            float | None: Radius of dried-out soil, or None if drying is disabled or absent.
+        """
         if not soil_drying:
             return None
 
@@ -163,7 +173,7 @@ def from_cable_with_added_soil_layer(
         soil_radius: float,
         logarithmic_soil_gridpoint_density: float,
     ) -> Self:
-        """This method creates a copy of the current cable object this was run from, but with an extra added soil layer.
+        """Create a fresh copy of the current cable object this was run from, but with an extra added soil layer.
 
         Args:
             cable (Cable):
diff --git a/cable_thermal_model/model/model.py b/cable_thermal_model/model/model.py
index 5d0f39a..a55a931 100644
--- a/cable_thermal_model/model/model.py
+++ b/cable_thermal_model/model/model.py
@@ -29,45 +29,43 @@ class Model(
 
     This class implements the finite difference orchestration shared by concrete models such as ModelAir and
     ModelSoil.
+
+    Class Attributes:
+        _run_options_class: The class used to define run options for the model.
+        _state_class: The class used to define the thermal state for the model.
+
+    Internal Runtime State:
+        _cables: Per-run positioned cable copies aligned with the static environment layout.
     """
 
     _run_options_class: type[ModelRunOptionsT]
     _state_class: type[StateT]
 
-    def __init__(self, static_env: StaticEnvT, scenario: DataFrame[ScenarioSchemaT]):
-        """Initialize the model with a static environment and a scenario DataFrame.
+    def __init__(self, static_env: StaticEnvT):
+        """Initialize the model with a static environment.
 
         Args:
             static_env: The static environment containing cable circuits.
-            scenario: The scenario DataFrame describing load conditions over time.
 
         """
-        super().__init__(static_env, scenario)
-
-        self.cables: dict[CableKey, PosCable[CableT]] = {}
-        self._initialize_cables()
+        super().__init__(static_env)
 
-        self.extra_solution_layers: list[CableLayer] = []
-        self.solution_ = None
-
-        self.temperature_result: dict[CableKey, dict[CableLayer, np.ndarray]] = {}
-
-    def add_solution_location(
-        self,
-        layer_name: CableLayer,
-    ) -> None:
-        """Select an additional solution layer.
+        self._cables: dict[CableKey, PosCable[CableT]] = {}
 
-        The chosen layer is included in the returned temperature results when calling `run()`.
+    @property
+    @abstractmethod
+    def cables_in_environment(self) -> dict[CableKey, PosCable[CableT]]:
+        """Return per-run positioned cables, including any model-specific environment extensions.
 
-        Args:
-            layer_name: Cable layer to include in the returned results.
+        Concrete models return model-specific environment representations:
+        - ModelAir: standard per-run cable copies.
+        - ModelSoil: soil-extended per-run cable copies.
 
+        The cable objects in this runtime mapping may have properties that differ
+        from static/default values, depending on temperature state and scenario
+        conditions applied during the run.
         """
-        if not isinstance(layer_name, CableLayer):
-            raise TypeError("The layer argument must be of type CableLayer!")
-
-        self.extra_solution_layers.append(layer_name)
+        pass
 
     def _set_run_options(self, run_options: ModelRunOptionsT | dict | None) -> None:
         """Define run options for the model.
@@ -92,49 +90,45 @@ def _validate_state_model_consistency(self, state: StateT | None):
             )
 
     def _initialize_cables(self):
-        """Copies the cables as defined in the static_env into the model and initializes cable-related indices.
+        """Initialize the per-run cable state from the static environment.
 
-        This method sets up:
-            - The cables dictionary from the static environment.
-            - Indices for conductor and screen layers for each cable, using the dict-based CableLayerProperties.
-            - A flag indicating whether any cable contains a pipe.
+        A deep copy is taken so the model can safely mutate cable objects during a run
+        without changing the static environment definition.
         """
-        self.cables = deepcopy(self.static_env.get_cables())
-        self.number_of_cables = len(self.cables)
-
-    @property
-    @abstractmethod
-    def _cables_for_heat_vectors(self) -> dict[CableKey, PosCable[CableT]]:
-        """Return the cables used to assemble finite difference vectors."""
-        pass
+        self._cables = deepcopy(self.static_env.get_cables())
 
     def _add_dielectric_loss_to_heating_vectors(self) -> None:
         """Add dielectric loss to the heating vectors of all cables if not neglected."""
         if not self.run_options.neglect_dielectric_loss:
-            for pos_cable in self._cables_for_heat_vectors.values():
+            for pos_cable in self.cables_in_environment.values():
                 pos_cable.cable.add_dielectric_loss_to_heating_vector()
 
     def _initialize_state(
         self,
+        ambient_temperature: float,
         initial_state: StateT | None = None,
     ) -> StateT:
         """Initializes the thermal state for the model, either from a provided initial state or by creating a new state.
 
         Args:
+            ambient_temperature: Ambient temperature used to initialize the model state.
             initial_state: An optional initial state to use for the thermal state.
 
         Returns:
             StateT: The initialized thermal state for the model.
         """
-        if initial_state is not None:
-            return initial_state.model_copy(deep=True)
+        if initial_state is None:
+            return self._build_initial_state(ambient_temperature=ambient_temperature)
 
-        return self._build_initial_state()
+        return initial_state.model_copy(deep=True)
 
     @abstractmethod
-    def _build_initial_state(self) -> StateT:
+    def _build_initial_state(self, ambient_temperature: float) -> StateT:
         """Builds the initial thermal state for the model.
 
+        Args:
+            ambient_temperature: The ambient temperature to initialize the model state.
+
         Returns:
             StateT: The initial thermal state for the model.
         """
@@ -163,35 +157,53 @@ def _initialize_state_from_cables(
     def _initialize_temperature_result(
         self,
         state: StateT,
-    ) -> None:
+        n_scenario_rows: int,
+    ) -> dict[CableKey, dict[CableLayer, np.ndarray]]:
         """Initializes a nested dictionary to store temperature results for each cable and each relevant layer.
 
         Args:
             state (StateT):
                 The initial thermal state for each cable, used to initialize the results.
+            n_scenario_rows: Number of time steps in the active scenario.
 
         """
-        self._initialize_empty_temperature_result()
+        temperature_result = self._initialize_empty_temperature_result(n_scenario_rows=n_scenario_rows)
 
         # Add initial temperature state to the results
         self._update_temperature_result(
+            temperature_result=temperature_result,
             state=state,
             step_idx=0,
         )
 
-        return
+        return temperature_result
 
-    def _initialize_empty_temperature_result(self) -> None:
+    def _initialize_empty_temperature_result(
+        self,
+        n_scenario_rows: int,
+    ) -> dict[CableKey, dict[CableLayer, np.ndarray]]:
         """Initializes an empty nested dictionary.
 
         Dictionary is used to store temperature results for each cable and each relevant layer.
         """
-        self.temperature_result = {}
-        for cable_key, _ in self.cables.items():
-            self.temperature_result[cable_key] = {}
-            for layer in [CableLayer.Conductor, CableLayer.Sheath, CableLayer.Pipe] + self.extra_solution_layers:
-                if layer in self.cables[cable_key].cable.layers:
-                    self.temperature_result[cable_key][layer] = np.full(self.n_scenario_rows, np.nan, dtype=float)
+        temperature_result: dict[CableKey, dict[CableLayer, np.ndarray]] = {}
+        for cable_key, _ in self._cables.items():
+            temperature_result[cable_key] = {}
+            for layer in (
+                CableLayer.Conductor,
+                CableLayer.Sheath,
+                CableLayer.Pipe,
+                *self.run_options.extra_solution_layers,
+            ):
+                if layer in self._cables[cable_key].cable.layers:
+                    temperature_result[cable_key][layer] = np.full(n_scenario_rows, np.nan, dtype=float)
+
+        return temperature_result
+
+    def _prepare_for_run(self, first_scenario_row: pd.Series) -> None:
+        """Reset mutable cable state before executing a scenario."""
+        _ = first_scenario_row
+        self._initialize_cables()
 
     def _get_circuit_loads_from_scenario_row(self, scenario_row) -> dict[str, float]:
         """Extract circuit loads from a scenario row produced by iterrows()."""
@@ -202,26 +214,24 @@ def _update_thermal_properties_if_needed(
         self,
         temperature_state: dict[CableKey, np.ndarray],
         scenario_row: pd.Series,
-        elapsed_seconds: float,
     ) -> None:
         """Update cables and refresh matrices in one step."""
         pass
 
-    def _update_heat_vectors(
+    def _update_heating_vectors(
         self,
         temperature_state: dict[CableKey, np.ndarray],
         circuit_loads: dict[str, float],
     ) -> None:
-        """Updates the vectors (right-hand side) of the linear system for each cable at a given timestep.
+        """Updates the heating vectors (right-hand side) of the linear system for each cable at a given timestep.
 
         Args:
             temperature_state (dict[CableKey, np.ndarray]):
                 The temperature state for each cable at the current timestep.
             circuit_loads (dict[str, float]):
                 The load for each circuit at the current timestep.
-
         """
-        for cable_key, pos_cable in self._cables_for_heat_vectors.items():
+        for cable_key, pos_cable in self.cables_in_environment.items():
             circuit_name = cable_key.circuit_name
             conductor_load = circuit_loads[circuit_name]
 
@@ -270,6 +280,7 @@ def _update_pipe_fill_resistivity(
 
     def _update_temperature_result(
         self,
+        temperature_result: dict[CableKey, dict[CableLayer, np.ndarray]],
         state: StateT,
         step_idx: int,
     ) -> None:
@@ -281,46 +292,47 @@ def _update_temperature_result(
         (center or inside for hollow conductors).
 
         Args:
+            temperature_result: Accumulated temperature arrays for all cables and requested layers.
             state (StateT): Current state of the model.
             step_idx (int): The index of the current timestep in the scenario.
 
         """
-        for cable_key, pos_cable in self.cables.items():
+        for cable_key, pos_cable in self._cables.items():
             cable = pos_cable.cable
             cable_temperatures = state.temperature[cable_key]
 
             conductor_index_inner = cable.get_layer_indices_for_layer(CableLayer.Conductor)[0]
             sheath_index_outer = cable.get_layer_indices_for_layer(CableLayer.Sheath)[-1]
 
-            self.temperature_result[cable_key][CableLayer.Conductor][step_idx] = cable_temperatures[
-                conductor_index_inner
-            ]
-            self.temperature_result[cable_key][CableLayer.Sheath][step_idx] = cable_temperatures[sheath_index_outer]
+            temperature_result[cable_key][CableLayer.Conductor][step_idx] = cable_temperatures[conductor_index_inner]
+            temperature_result[cable_key][CableLayer.Sheath][step_idx] = cable_temperatures[sheath_index_outer]
 
-            for extra_solution_layer in self.extra_solution_layers:
+            for extra_solution_layer in self.run_options.extra_solution_layers:
                 if extra_solution_layer in cable.layers:
                     layer_start_index, layer_end_index = cable.get_layer_indices_for_layer(extra_solution_layer)
                     layer_index_center = int((layer_start_index + layer_end_index) / 2)
 
-                    self.temperature_result[cable_key][extra_solution_layer][step_idx] = cable_temperatures[
+                    temperature_result[cable_key][extra_solution_layer][step_idx] = cable_temperatures[
                         layer_index_center
                     ]
 
             if cable.layer_metrics.pipe is not None:
                 # Fetch temperature of pipe sheath
                 pipe_index_outer = cable.get_layer_indices_for_layer(CableLayer.Pipe)[-1]
-                self.temperature_result[cable_key][CableLayer.Pipe][step_idx] = cable_temperatures[pipe_index_outer]
+                temperature_result[cable_key][CableLayer.Pipe][step_idx] = cable_temperatures[pipe_index_outer]
 
         return
 
     def _build_temperature_result_dataframe(
         self,
+        temperature_result: dict[CableKey, dict[CableLayer, np.ndarray]],
+        scenario: DataFrame[ScenarioSchemaT],
     ) -> DataFrame[TemperatureResultSchema]:
         """Builds a DataFrame from the temperature results for each cable and layer.
 
         Args:
-            temperature_result (dict[CableKey, dict[CableLayer, np.ndarray]]):
-                A nested dictionary containing temperature results for each cable and layer.
+            temperature_result: A nested dictionary containing temperature results for each cable and layer.
+            scenario: Scenario used for the current run.
 
         Returns:
             DataFrame[TemperatureResultSchema]:
@@ -329,9 +341,9 @@ def _build_temperature_result_dataframe(
         """
         temperature_result_dfs = {
             (cable_key.circuit_name, cable_key.cable_position): pd.DataFrame(
-                self.temperature_result[cable_key], index=self.scenario.index
+                temperature_result[cable_key], index=scenario.index
             )
-            for cable_key in self.temperature_result
+            for cable_key in temperature_result
         }
 
         combined_temperature_result_df = pd.concat(
@@ -344,34 +356,43 @@ def _build_temperature_result_dataframe(
 
     def _compute_temperature_solution(
         self,
+        scenario: DataFrame[ScenarioSchemaT],
         initial_state: StateT | None = None,
     ) -> ModelOutputSchema[StateT]:
-        """Compute the temperature solution over the entire scenario.
+        """Run one transient thermal simulation over the provided scenario.
+
+        This method coordinates run setup, state initialization, and time-step updates.
+        It returns both the temperature trajectory (for analysis) and the final state
+        (for optional warm-starting of a subsequent run).
 
         Args:
-            initial_state: Optional previously computed state to initialize the simulation.
+            scenario: Time-indexed operating conditions and loads to simulate.
+            initial_state: Optional warm-start state from a previous run.
 
         Returns:
-            ModelOutputSchema[StateT]: The computed temperature solution and final thermal state.
+            ModelOutputSchema[StateT]: The temperature time series and the final
+                thermal state after the last scenario step.
         """
-        self._add_dielectric_loss_to_heating_vectors()
+        scenario_rows = scenario.iterrows()
+        _, first_scenario_row = next(scenario_rows)
 
-        state = self._initialize_state(initial_state=initial_state)
-        self._initialize_temperature_result(state=state)
+        self._prepare_for_run(first_scenario_row=first_scenario_row)
+        self._add_dielectric_loss_to_heating_vectors()
 
-        time_grid = (self.scenario.index - self.scenario.index[0]).total_seconds().to_numpy()
-        scenario_rows = self.scenario.iloc[1:].iterrows()
+        initial_ambient_temperature = first_scenario_row["ambient_temperature"]
+        state = self._initialize_state(ambient_temperature=initial_ambient_temperature, initial_state=initial_state)
+        temperature_result = self._initialize_temperature_result(state=state, n_scenario_rows=len(scenario.index))
 
+        time_grid = (scenario.index - scenario.index[0]).total_seconds().to_numpy()
         for step_idx, (_, scenario_row) in enumerate(scenario_rows, start=1):
             time_step = time_grid[step_idx] - time_grid[step_idx - 1]
 
             self._update_thermal_properties_if_needed(
                 temperature_state=state.temperature,
                 scenario_row=scenario_row,
-                elapsed_seconds=time_grid[step_idx],
             )
 
-            self._update_heat_vectors(
+            self._update_heating_vectors(
                 temperature_state=state.temperature,
                 circuit_loads=self._get_circuit_loads_from_scenario_row(scenario_row),
             )
@@ -383,10 +404,14 @@ def _compute_temperature_solution(
             )
 
             self._update_temperature_result(
+                temperature_result=temperature_result,
                 state=state,
                 step_idx=step_idx,
             )
 
-        temperature_result_df = self._build_temperature_result_dataframe()
+        temperature_result_df = self._build_temperature_result_dataframe(
+            temperature_result=temperature_result,
+            scenario=scenario,
+        )
 
         return ModelOutputSchema(result=temperature_result_df, state=state)
diff --git a/cable_thermal_model/model/model_air.py b/cable_thermal_model/model/model_air.py
index ce34cb0..98559a3 100644
--- a/cable_thermal_model/model/model_air.py
+++ b/cable_thermal_model/model/model_air.py
@@ -4,7 +4,6 @@
 
 import numpy as np
 import pandas as pd
-from pandera.typing import DataFrame
 
 from cable_thermal_model.cable.cable_circuit import CableKey, PosCable
 from cable_thermal_model.environment.static_env_air import StaticEnvAir
@@ -18,23 +17,18 @@
 class ModelAir(Model[ModelAirRunOptions, StateAir, ScenarioSchemaAir, StaticEnvAir, CableAir]):
     """ModelAir computes cable temperatures for installations in air using the finite difference method.
 
-    In most cases the model is instantiated with a StaticEnvAir and a valid scenario, then executed via `run()`.
+    In most cases the model is instantiated with a StaticEnvAir and executed with a scenario via `run()`.
     """
 
     _run_options_class = ModelAirRunOptions
     _state_class = StateAir
     _scenario_schema_class = ScenarioSchemaAir
 
-    def __init__(self, static_env: StaticEnvAir, scenario: DataFrame[ScenarioSchemaAir]):
-        """Initialize the ModelAir instance with a static environment and scenario.
-
-        Note: the scenario must contain one `load_<circuit_name>` column per circuit and an
-        `ambient_temperature` column.
+    def __init__(self, static_env: StaticEnvAir):
+        """Initialize the ModelAir instance with a static environment.
 
         Args:
             static_env: A StaticEnvAir instance containing the circuit configuration and cable properties.
-            scenario: A pandera DataFrame[ScenarioSchemaAir] containing the dynamic load data and ambient
-                temperature.
 
         """
         if not isinstance(static_env, StaticEnvAir):
@@ -44,25 +38,31 @@ def __init__(self, static_env: StaticEnvAir, scenario: DataFrame[ScenarioSchemaA
                 "ModelSoil instead."
             )
 
-        super().__init__(static_env=static_env, scenario=scenario)
+        super().__init__(static_env=static_env)
 
     @property
-    def _cables_for_heat_vectors(self) -> dict[CableKey, PosCable[CableAir]]:
-        """Return the cables used to assemble finite difference vectors."""
-        return self.cables
+    def cables_in_environment(self) -> dict[CableKey, PosCable[CableAir]]:
+        """Return per-run cable instances for the model.
+
+        Runtime cable properties can differ from their static/default values.
+        For cables in air, this mainly concerns temperature-dependent pipe-fill resistivity.
+        """
+        return self._cables
 
-    def _build_initial_state(self) -> StateAir:
+    def _build_initial_state(self, ambient_temperature: float) -> StateAir:
         """Builds the initial thermal state for the model.
 
+        Args:
+            ambient_temperature: The ambient temperature to initialize the model state.
+
         Returns:
-            StateAir: The initialized thermal state for the model.
+            An instance of StateAir containing the initialized temperature,
+                and self-heating states for each cable.
         """
-        ambient_temperature = self.scenario["ambient_temperature"].iloc[0]
-
         return StateAir(
             static_env_hash=self.static_env.compute_hash(),
-            temperature=self._initialize_state_from_cables(cables=self.cables, fill_value=ambient_temperature),
-            self_heating_contribution=self._initialize_state_from_cables(cables=self.cables),
+            temperature=self._initialize_state_from_cables(cables=self._cables, fill_value=ambient_temperature),
+            self_heating_contribution=self._initialize_state_from_cables(cables=self._cables),
             ambient_temperature=ambient_temperature,
         )
 
@@ -70,24 +70,21 @@ def _update_thermal_properties_if_needed(
         self,
         temperature_state: dict[CableKey, np.ndarray],
         scenario_row: pd.Series,
-        elapsed_seconds: float,
     ) -> None:
         """Update the pipe-fill resistivity if changed.
 
         Args:
-            matrices: Current finite difference matrices.
             temperature_state: Current temperature state for all cables.
             scenario_row: Current scenario row.
-            elapsed_seconds: Time elapsed since the start of the scenario in seconds.
 
         Notes:
-            `scenario_row` and `elapsed_seconds` are accepted for interface compatibility with other model types.
+            `scenario_row` is accepted for interface compatibility with other model types.
         """
-        _ = (scenario_row, elapsed_seconds)  # Unused in this subclass
+        _ = scenario_row  # Unused in this subclass
 
         self._update_pipe_fill_resistivity(
             temperature_state=temperature_state,
-            cables=self.cables,
+            cables=self._cables,
         )
 
     def _update_state(
@@ -102,7 +99,7 @@ def _update_state(
                 previous_solution=state.self_heating_contribution[cable_key],
                 time_step=time_step,
             )
-            for cable_key, pos_cable in self.cables.items()
+            for cable_key, pos_cable in self._cables.items()
         }
 
         new_temperature_state = {
diff --git a/cable_thermal_model/model/model_factory.py b/cable_thermal_model/model/model_factory.py
index 022e8da..4b63254 100644
--- a/cable_thermal_model/model/model_factory.py
+++ b/cable_thermal_model/model/model_factory.py
@@ -4,8 +4,6 @@
 
 from typing import overload
 
-import pandas as pd
-
 from cable_thermal_model.environment.static_env import StaticEnv, StaticEnvT
 from cable_thermal_model.environment.static_env_air import StaticEnvAir
 from cable_thermal_model.environment.static_env_soil import StaticEnvSoil
@@ -20,26 +18,24 @@ class ModelFactory:
     # Overloaded methods for type checking. Used to infer the return type based on the input static environment type.
     @staticmethod
     @overload
-    def create_model(static_env: StaticEnvAir, scenario: pd.DataFrame) -> ModelAir: ...
+    def create_model(static_env: StaticEnvAir) -> ModelAir: ...
 
     @staticmethod
     @overload
-    def create_model(static_env: StaticEnvSoil, scenario: pd.DataFrame) -> ModelSoil: ...
+    def create_model(static_env: StaticEnvSoil) -> ModelSoil: ...
 
     @staticmethod
     @overload
-    def create_model(static_env: StaticEnv, scenario: pd.DataFrame) -> Model: ...
+    def create_model(static_env: StaticEnv) -> Model: ...
 
     @staticmethod
     def create_model(
         static_env: StaticEnvT,
-        scenario: pd.DataFrame,
     ) -> Model:
         """Create a model instance based on the environment type.
 
         Args:
             static_env (StaticEnvT): Static environment configuration for the model.
-            scenario (pd.DataFrame): Scenario data used by the model.
 
         Returns:
             Model: An instance of ModelAir or ModelSoil, depending on the type of static_env.
@@ -48,9 +44,9 @@ def create_model(
             ValueError: If static_env is not a supported environment type.
         """
         if isinstance(static_env, StaticEnvAir):
-            return ModelAir(static_env=static_env, scenario=scenario)  # type: ignore
+            return ModelAir(static_env=static_env)
         elif isinstance(static_env, StaticEnvSoil):
-            return ModelSoil(static_env=static_env, scenario=scenario)  # type: ignore
+            return ModelSoil(static_env=static_env)
         else:
             raise ValueError(
                 f"Unsupported static environment type: {type(static_env).__name__}. "
diff --git a/cable_thermal_model/model/model_soil.py b/cable_thermal_model/model/model_soil.py
index d6a4d91..833df2d 100644
--- a/cable_thermal_model/model/model_soil.py
+++ b/cable_thermal_model/model/model_soil.py
@@ -1,7 +1,6 @@
 # SPDX-FileCopyrightText: Contributors to the Cable Thermal Model project
 #
 # SPDX-License-Identifier: MPL-2.0
-from copy import deepcopy
 
 import numpy as np
 import pandas as pd
@@ -14,6 +13,7 @@
     MeasurementPointKey,
 )
 from cable_thermal_model.model.cables.cable_soil import CableSoil
+from cable_thermal_model.model.cables.enum_classes_cable import CableLayer
 from cable_thermal_model.model.model import Model
 from cable_thermal_model.model.schemas import ScenarioSchemaSoil, StateSoil
 from cable_thermal_model.model.schemas.model_input_schemas import THERMAL_CAPACITY_COLUMN, THERMAL_RESISTIVITY_COLUMN
@@ -24,43 +24,34 @@
 class ModelSoil(Model[ModelSoilRunOptions, StateSoil, ScenarioSchemaSoil, StaticEnvSoil, CableSoil]):
     """ModelSoil computes temperatures for underground power cables using the finite difference method.
 
-    In most cases the model is instantiated with a StaticEnvSoil and a valid scenario, then executed via `run()`.
-
+    In most cases the model is instantiated with a StaticEnvSoil and executed with a scenario via `run()`.
 
     Class Attributes:
-        _run_options_class:                 The class used for run options.
-        _state_class:                       The class used for the state of the model.
-        _scenario_schema_class:             The class used for the scenario schema.
-
-    Attributes:
-        mirror_cables_with_soil:            A dict containing the mirror cables with soil for each cable in the
-                                            environment
-        logarithmic_soil_gridpoint_density: The density of grid points in the soil layers, this is used to compute
-                                            the number of grid points in the soil layers based on their thickness.
-                                            The default value is 20 grid points per factor 2 increase in soil layer
-                                            thickness. For a cable with radius of 3.1 cm and a soil layer radius
-                                            1 m,
-                                            this would result in 100 grid points in the soil layer.
-        minimal_soil_radius:                The minimal soil radius around a cable. For deeply buried cables, the
-                                            soil radius is set to 2.5 times the cable depth, this parameter sets
-                                            a lower bound to prevent very small soil layers for shallow cables.
-
-    .
+        _run_options_class: Run-options schema class.
+        _state_class: State schema class.
+        _scenario_schema_class: Scenario schema class.
+
+    Internal Runtime State:
+        _cables_with_soil: Per-run cable representations extended with soil layers and updated during simulation.
+        _mirror_cables_with_soil: Per-run mirrored soil cable representations for image-source calculations.
+        _measurement_point_temperature_result: Per-run cache of measurement-point temperatures.
+
+    Configuration Parameters:
+        logarithmic_soil_gridpoint_density: Soil-grid point density factor used for discretization.
+            Default is 20.
+        minimal_soil_radius: Minimum soil radius around each cable in meters. Default is 5.0.
+            The effective soil radius is max(minimal_soil_radius, 2.5 * abs(cable depth)).
     """
 
     _run_options_class = ModelSoilRunOptions
     _state_class = StateSoil
     _scenario_schema_class = ScenarioSchemaSoil
 
-    def __init__(self, static_env: StaticEnvSoil, scenario: DataFrame[ScenarioSchemaSoil]):
-        """Initialize the ModelSoil instance with a static environment and scenario.
-
-        Note: the scenario must contain one `load_<circuit_name>` column per circuit, plus ambient temperature and
-        soil-property columns.
+    def __init__(self, static_env: StaticEnvSoil):
+        """Initialize the ModelSoil instance with a static environment.
 
         Args:
             static_env: A StaticEnvSoil instance containing the soil thermal parameters and cable layout.
-            scenario: A pandera DataFrame[ScenarioSchemaSoil] containing the dynamic load and soil data.
 
         """
         if not isinstance(static_env, StaticEnvSoil):
@@ -71,15 +62,25 @@ def __init__(self, static_env: StaticEnvSoil, scenario: DataFrame[ScenarioSchema
             )
 
         # Set up cables
-        self.cables_with_soil: dict[CableKey, PosCable[CableSoil]] = {}
-        self.mirror_cables_with_soil: dict[CableKey, PosCable[CableSoil]] = {}
+        self._cables_with_soil: dict[CableKey, PosCable[CableSoil]] = {}
+        self._mirror_cables_with_soil: dict[CableKey, PosCable[CableSoil]] = {}
+
         self.logarithmic_soil_gridpoint_density: float = 20
         self.minimal_soil_radius: float = 5.0
-        self.last_soil_property_update_day: int = 0
 
-        self.measurement_point_temperature_result: dict[MeasurementPointKey, np.ndarray] = {}
+        self._measurement_point_temperature_result: dict[MeasurementPointKey, np.ndarray] = {}
 
-        super().__init__(static_env=static_env, scenario=scenario)
+        super().__init__(static_env=static_env)
+
+    @property
+    def cables_in_environment(self) -> dict[CableKey, PosCable[CableSoil]]:
+        """Return per-run soil-extended cable instances for the model.
+
+        Runtime cable properties may deviate from their static baseline defaults. For soil cables, this concerns:
+        - updated soil thermal resistivity and capacity from the active scenario (optionally with soil-drying behavior);
+        - temperature-dependent pipe-fill resistivity where a pipe layer exists.
+        """
+        return self._cables_with_soil
 
     def get_measurement_point_temp(
         self,
@@ -98,12 +99,12 @@ def get_measurement_point_temp(
         """
         measurement_point_temp = state.ambient_temperature
 
-        for cable_key, cable in self.cables_with_soil.items():
+        for cable_key, cable in self._cables_with_soil.items():
             distance_to_cable = measurement_point.distances_to_cables[cable_key]
             measurement_point_temp += cable.cable.get_heating_contribution_at_radius(
                 radius=distance_to_cable, self_heating_contribution=state.self_heating_contribution[cable_key]
             )
-        for cable_key, mirror_cable in self.mirror_cables_with_soil.items():
+        for cable_key, mirror_cable in self._mirror_cables_with_soil.items():
             distance_to_mirror_cable = measurement_point.distances_to_mirror_cables[cable_key]
             measurement_point_temp -= mirror_cable.cable.get_heating_contribution_at_radius(
                 radius=distance_to_mirror_cable, self_heating_contribution=state.self_heating_contribution[cable_key]
@@ -111,50 +112,44 @@ def get_measurement_point_temp(
 
         return measurement_point_temp
 
-    def _initialize_cables(self):
-        """Initialize cables with soil layers and mirror cables for the boundary condition."""
-        # Start from the static cables without soil, then add a soil layer per cable.
-        # Deep cables may get an extra outer soil layer to extend the domain.
-        # The outer boundary is treated as ambient.
-
-        super()._initialize_cables()
+    def _prepare_for_run(self, first_scenario_row: pd.Series) -> None:
+        """Reset cable state and rebuild the soil-extended representation for the active scenario."""
+        super()._prepare_for_run(first_scenario_row=first_scenario_row)
 
-        self._initialize_cables_with_soil()
+        self._initialize_cables_with_soil(
+            soil_rho=first_scenario_row[THERMAL_RESISTIVITY_COLUMN],
+            soil_capacity=first_scenario_row[THERMAL_CAPACITY_COLUMN],
+        )
 
-        # Create mirror cables to enforce the T=0 boundary condition on y=0.
-        self.mirror_cables_with_soil = {
-            key: return_mirror_cable(pos_cable) for key, pos_cable in self.cables_with_soil.items()
+        self._mirror_cables_with_soil = {
+            key: return_mirror_cable(pos_cable) for key, pos_cable in self._cables_with_soil.items()
         }
 
         for measurement_point in self.static_env._measurement_point_registry.points:
             measurement_point.distances_to_cables = {
                 key: pos_cable.distance_to_point(x=measurement_point.x, y=measurement_point.y)
-                for key, pos_cable in self.cables_with_soil.items()
+                for key, pos_cable in self._cables_with_soil.items()
             }
             measurement_point.distances_to_mirror_cables = {
                 key: pos_cable.distance_to_point(x=measurement_point.x, y=measurement_point.y)
-                for key, pos_cable in self.mirror_cables_with_soil.items()
+                for key, pos_cable in self._mirror_cables_with_soil.items()
             }
 
-    @property
-    def _cables_for_heat_vectors(self) -> dict[CableKey, PosCable[CableSoil]]:
-        """Return the cables used to assemble finite difference vectors."""
-        return self.cables_with_soil
-
-    def _build_initial_state(self) -> StateSoil:
+    def _build_initial_state(self, ambient_temperature: float) -> StateSoil:
         """Builds the initial state for the model.
 
+        Args:
+            ambient_temperature: The ambient temperature to initialize the model state.
+
         Returns:
             StateSoil: An instance of StateSoil containing the initialized temperature,
                             self-heating, and mutual-heating states for each cable.
         """
-        ambient_temperature = self.scenario["ambient_temperature"].iloc[0]
-
         return StateSoil(
             static_env_hash=self.static_env.compute_hash(),
-            temperature=self._initialize_state_from_cables(cables=self.cables, fill_value=ambient_temperature),
-            self_heating_contribution=self._initialize_state_from_cables(cables=self.cables_with_soil),
-            mutual_heating_contribution=self._initialize_state_from_cables(cables=self.cables),
+            temperature=self._initialize_state_from_cables(cables=self._cables, fill_value=ambient_temperature),
+            self_heating_contribution=self._initialize_state_from_cables(cables=self._cables_with_soil),
+            mutual_heating_contribution=self._initialize_state_from_cables(cables=self._cables),
             ambient_temperature=ambient_temperature,
         )
 
@@ -199,10 +194,10 @@ def _compute_mutual_heating_effect(
             dict[CableKey, float]: Temperature increases due to mutual heating, one value per cable.
 
         """
-        mutual_heating_effect = dict.fromkeys(self.cables, 0.0)
+        mutual_heating_effect = dict.fromkeys(self._cables, 0.0)
 
-        for key, pos_cable in self.cables_with_soil.items():
-            other_cables = self.cables_with_soil.copy()
+        for key, pos_cable in self._cables_with_soil.items():
+            other_cables = self._cables_with_soil.copy()
             other_cables.pop(key)
 
             mutual_heating_effect[key] += self._sum_heating_contributions(
@@ -213,7 +208,7 @@ def _compute_mutual_heating_effect(
             )
 
             mutual_heating_effect[key] -= self._sum_heating_contributions(
-                cables=self.mirror_cables_with_soil,
+                cables=self._mirror_cables_with_soil,
                 self_heating_contribution=self_heating_contribution,
                 x=pos_cable.x,
                 y=pos_cable.y,
@@ -237,7 +232,7 @@ def _update_soil_properties_for_all_cables(
             soil_capacity: Soil thermal capacity for the current time step.
 
         """
-        for cable_key, pos_cable in self.cables_with_soil.items():
+        for cable_key, pos_cable in self._cables_with_soil.items():
             pos_cable.cable.update_soil_properties(
                 soil_rho=soil_resistivity,
                 soil_c=soil_capacity,
@@ -245,28 +240,6 @@ def _update_soil_properties_for_all_cables(
                 soil_drying=soil_drying,
             )
 
-    @staticmethod
-    def _check_if_daily_update_due(
-        seconds_since_start_scenario: float, last_soil_property_update_day: int
-    ) -> tuple[bool, int]:
-        """Check if a daily update of soil properties is due based on the time elapsed since the start of the scenario.
-
-        Args:
-            seconds_since_start_scenario: The number of seconds that have passed since the start of the scenario.
-            last_soil_property_update_day: Day counter indicating when the last soil-property update occurred.
-
-        Returns:
-            A tuple containing a boolean indicating whether a daily update is due and the updated day counter.
-
-        """
-        daily_update_due = False
-        days = seconds_since_start_scenario / (60 * 60 * 24)
-        if days > last_soil_property_update_day:
-            daily_update_due = True
-            last_soil_property_update_day = int(days)
-
-        return daily_update_due, last_soil_property_update_day
-
     def _update_self_heating_contribution(
         self,
         self_heating_contribution: dict[CableKey, np.ndarray],
@@ -286,7 +259,7 @@ def _update_self_heating_contribution(
         solution_at_boundary = 0.0
 
         new_self_heating_contribution = {}
-        for cable_key, pos_cable in self.cables_with_soil.items():
+        for cable_key, pos_cable in self._cables_with_soil.items():
             new_self_heating_contribution[cable_key] = pos_cable.cable.integrate_timestep(
                 previous_solution=self_heating_contribution[cable_key],
                 time_step=time_step,
@@ -316,7 +289,7 @@ def _update_mutual_heating_contribution(
         mutual_heating_effect = self._compute_mutual_heating_effect(self_heating_contribution=self_heating_contribution)
 
         new_mutual_heating_contribution = {}
-        for cable_key, pos_cable in self.cables.items():
+        for cable_key, pos_cable in self._cables.items():
             new_mutual_heating_contribution[cable_key] = pos_cable.cable.integrate_timestep(
                 previous_solution=mutual_heating_contribution[cable_key],
                 time_step=time_step,
@@ -342,7 +315,7 @@ def _update_temperature_state(
             dict[CableKey, np.ndarray]: Updated temperature state for all cables.
         """
         new_temperature_state = {}
-        for cable_key in self.cables:
+        for cable_key in self._cables:
             mutual_heat = mutual_heating_contribution[cable_key]
             self_heat = self_heating_contribution[cable_key][: mutual_heat.size]
             new_temperature_state[cable_key] = self_heat + mutual_heat + ambient_temperature
@@ -353,7 +326,6 @@ def _update_thermal_properties_if_needed(
         self,
         temperature_state: dict[CableKey, np.ndarray],
         scenario_row: pd.Series,
-        elapsed_seconds: float,
     ) -> None:
         """Update pipe-fill resistivity and soil properties if needed.
 
@@ -363,25 +335,19 @@ def _update_thermal_properties_if_needed(
             elapsed_seconds: Time elapsed since the start of the scenario in seconds.
 
         """
+        self._update_pipe_fill_resistivity(temperature_state=temperature_state, cables=self._cables)
+        self._update_pipe_fill_resistivity(temperature_state=temperature_state, cables=self._cables_with_soil)
+
         soil_resistivity = scenario_row[THERMAL_RESISTIVITY_COLUMN]
         soil_capacity = scenario_row[THERMAL_CAPACITY_COLUMN]
 
-        self._update_pipe_fill_resistivity(temperature_state=temperature_state, cables=self.cables)
-        self._update_pipe_fill_resistivity(temperature_state=temperature_state, cables=self.cables_with_soil)
-
-        daily_update_due, self.last_soil_property_update_day = self._check_if_daily_update_due(
-            seconds_since_start_scenario=elapsed_seconds,
-            last_soil_property_update_day=self.last_soil_property_update_day,
+        self._update_soil_properties_for_all_cables(
+            soil_drying=self.run_options.soil_drying,
+            temperature_state=temperature_state,
+            soil_resistivity=soil_resistivity,
+            soil_capacity=soil_capacity,
         )
 
-        if daily_update_due:
-            self._update_soil_properties_for_all_cables(
-                soil_drying=self.run_options.soil_drying,
-                temperature_state=temperature_state,
-                soil_resistivity=soil_resistivity,
-                soil_capacity=soil_capacity,
-            )
-
     def _update_state(
         self,
         state: StateSoil,
@@ -415,71 +381,93 @@ def _update_state(
         )
         return new_state
 
-    def _initialize_empty_temperature_result(self):
+    def _initialize_empty_temperature_result(
+        self,
+        n_scenario_rows: int,
+    ) -> dict[CableKey, dict[CableLayer, np.ndarray]]:
         """Initializes an empty nested dictionary.
 
         Dictionary is used to store temperature results for each cable and each relevant layer.
         """
-        super()._initialize_empty_temperature_result()
+        temperature_result = super()._initialize_empty_temperature_result(n_scenario_rows=n_scenario_rows)
 
-        self.measurement_point_temperature_result = {
-            mp.key: np.full(self.n_scenario_rows, np.nan, dtype=float)
+        self._measurement_point_temperature_result = {
+            mp.key: np.full(n_scenario_rows, np.nan, dtype=float)
             for mp in self.static_env._measurement_point_registry.points
         }
 
-    def _update_temperature_result(self, state: StateSoil, step_idx: int):
-        """Initializes the temperature result dictionary with the initial state values."""
+        return temperature_result
+
+    def _update_temperature_result(
+        self,
+        temperature_result: dict[CableKey, dict[CableLayer, np.ndarray]],
+        state: StateSoil,
+        step_idx: int,
+    ) -> None:
+        """Update the temperature result dictionary with the current state for a given timestep."""
         super()._update_temperature_result(
+            temperature_result=temperature_result,
             state=state,
             step_idx=step_idx,
         )
 
         for measurement_point in self.static_env._measurement_point_registry.points:
-            self.measurement_point_temperature_result[measurement_point.key][step_idx] = (
+            self._measurement_point_temperature_result[measurement_point.key][step_idx] = (
                 self.get_measurement_point_temp(state=state, measurement_point=measurement_point)
             )
 
-    def _build_temperature_result_dataframe(self) -> DataFrame[TemperatureResultSchema]:
+    def _build_temperature_result_dataframe(
+        self,
+        temperature_result: dict[CableKey, dict[CableLayer, np.ndarray]],
+        scenario: DataFrame[ScenarioSchemaSoil],
+    ) -> DataFrame[TemperatureResultSchema]:
         """Builds a DataFrame from the temperature result dictionary.
 
         Returns:
             pd.DataFrame: A DataFrame containing the temperature results for all cables and layers.
 
         """
-        df = super()._build_temperature_result_dataframe()
+        df = super()._build_temperature_result_dataframe(
+            temperature_result=temperature_result,
+            scenario=scenario,
+        )
 
         # Add measurement point temperatures to the DataFrame
         for measurement_point in self.static_env._measurement_point_registry.points:
-            df[measurement_point.key] = self.measurement_point_temperature_result[measurement_point.key]
+            df[measurement_point.key] = self._measurement_point_temperature_result[measurement_point.key]
 
         return df
 
     def _initialize_cables_with_soil(
         self,
+        soil_rho: float,
+        soil_capacity: float,
     ) -> None:
-        """Add soil layers to cable attribute of the given PosCable.
+        """Build the _cables_with_soil attribute from the existing cables using the provided soil properties.
 
-        Returns:
-            New PosCable instance where the only difference is that the cable now has soil layers.
+        Make sure initialize_cables() is called before this method to ensure that the cables are set up correctly.
+
+        Args:
+            soil_rho: Soil thermal resistivity for the start of the scenario.
+            soil_capacity: Soil thermal capacity for the start of the scenario.
 
         """
-        for key, pos_cable in self.cables.items():
+        self._cables_with_soil = {}
+        for key, pos_cable in self._cables.items():
             soil_radius = max(self.minimal_soil_radius, 2.5 * abs(pos_cable.y))
 
-            # Instantiate Cable objects with the added soil layer
-            pos_cable_ = deepcopy(pos_cable)
-            cable_in_soil = pos_cable_.cable.from_cable_with_added_soil_layer(
-                cable=pos_cable_.cable,
-                soil_rho=self.scenario[THERMAL_RESISTIVITY_COLUMN].iloc[0],
-                soil_capacity=self.scenario[THERMAL_CAPACITY_COLUMN].iloc[0],
+            cable_in_soil = pos_cable.cable.from_cable_with_added_soil_layer(
+                cable=pos_cable.cable,
+                soil_rho=soil_rho,
+                soil_capacity=soil_capacity,
                 soil_radius=soil_radius,
                 logarithmic_soil_gridpoint_density=self.logarithmic_soil_gridpoint_density,
             )
 
-            self.cables_with_soil[key] = PosCable[CableSoil](
+            self._cables_with_soil[key] = PosCable[CableSoil](
                 cable=cable_in_soil,
-                x=pos_cable_.x,
-                y=pos_cable_.y,
-                circuit_name=pos_cable_.circuit_name,
-                cable_position=pos_cable_.cable_position,
+                x=pos_cable.x,
+                y=pos_cable.y,
+                circuit_name=pos_cable.circuit_name,
+                cable_position=pos_cable.cable_position,
             )
diff --git a/cable_thermal_model/model/schemas/run_options.py b/cable_thermal_model/model/schemas/run_options.py
index c4911bd..2331e97 100644
--- a/cable_thermal_model/model/schemas/run_options.py
+++ b/cable_thermal_model/model/schemas/run_options.py
@@ -4,8 +4,9 @@
 
 from typing import Generic, TypeVar
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
+from cable_thermal_model.model.cables.enum_classes_cable import CableLayer
 from cable_thermal_model.model.schemas.state_schemas import StateAir, StateSoil, StateT
 
 ModelRunOptionsT = TypeVar("ModelRunOptionsT", bound="ModelRunOptions")
@@ -34,6 +35,34 @@ class ModelRunOptions(BaseModel, Generic[StateT]):
             "If True, the model will not account for the heat generated by dielectric losses in the cable insulation."
         ),
     )
+    extra_solution_layers: tuple[CableLayer, ...] = Field(
+        default_factory=tuple,
+        description="Additional cable layers to include in the returned result for this run.",
+    )
+
+    @field_validator("extra_solution_layers", mode="after")
+    @classmethod
+    def _deduplicate_extra_solution_layers(
+        cls,
+        extra_solution_layers: tuple[CableLayer, ...],
+    ) -> tuple[CableLayer, ...]:
+        """Preserve request order while removing duplicate layers."""
+        return tuple(dict.fromkeys(extra_solution_layers))
+
+    @field_validator("extra_solution_layers", mode="after")
+    @classmethod
+    def _validate_extra_solution_layers_exclude_standard_layers(
+        cls,
+        extra_solution_layers: tuple[CableLayer, ...],
+    ) -> tuple[CableLayer, ...]:
+        """Reject layers that already have dedicated extraction logic in model output."""
+        disallowed_layers = {CableLayer.Conductor, CableLayer.Sheath, CableLayer.Pipe}
+        invalid_layers = tuple(layer for layer in extra_solution_layers if layer in disallowed_layers)
+        if invalid_layers:
+            invalid_layers_str = ", ".join(layer.value for layer in invalid_layers)
+            raise ValueError(f"extra_solution_layers must not include standard result layers: {invalid_layers_str}.")
+
+        return extra_solution_layers
 
 
 class ModelSoilRunOptions(ModelRunOptions[StateSoil]):
diff --git a/cable_thermal_model/validation/iec_60287_parameter_extractor.py b/cable_thermal_model/validation/iec_60287_parameter_extractor.py
index ca6fd29..d55c495 100644
--- a/cable_thermal_model/validation/iec_60287_parameter_extractor.py
+++ b/cable_thermal_model/validation/iec_60287_parameter_extractor.py
@@ -6,14 +6,12 @@
 
 import numpy as np
 import pandas as pd
-from pandera.typing import DataFrame
 
 from cable_thermal_model import ModelFactory, StaticEnvSoil
 from cable_thermal_model.cable.cable_circuit import CableKey
 from cable_thermal_model.model.cables.cable import Cable
 from cable_thermal_model.model.cables.enum_classes_cable import CableLayer
 from cable_thermal_model.model.schemas import StateSoil
-from cable_thermal_model.model.schemas.model_input_schemas import ScenarioSchemaSoil
 from cable_thermal_model.model.schemas.model_output_schemas import ModelOutputSchema
 from cable_thermal_model.validation.cable_analysis import CableAnalysis
 
@@ -92,7 +90,7 @@ class _CableContext:
 def _get_cable_context(
     cable: Cable,
     cable_key: CableKey,
-    scenario: DataFrame[ScenarioSchemaSoil],
+    scenario: pd.DataFrame,
     model_output: ModelOutputSchema[StateSoil],
 ) -> _CableContext:
     load_column = f"load_{cable_key.circuit_name}"
@@ -304,7 +302,7 @@ def build_scenario(
     soil_thermal_resistivity: float,
     soil_thermal_capacity: float,
     ambient_temperature: float,
-) -> DataFrame[ScenarioSchemaSoil]:
+) -> pd.DataFrame:
     """Build a static scenario DataFrame used for IEC parameter extraction.
 
     Args:
@@ -323,13 +321,13 @@ def build_scenario(
             "soil_thermal_resistivity": soil_thermal_resistivity,
             "soil_thermal_capacity": soil_thermal_capacity,
         },
-        index=pd.timedelta_range(start="0D", end="30000D", periods=20),
+        index=pd.timedelta_range(start="0D", end="100000D", periods=101),
     )
 
     for circuit_name, rating in circuit_ratings.items():
         scenario[f"load_{circuit_name}"] = rating
 
-    return ScenarioSchemaSoil.validate(scenario)
+    return scenario
 
 
 def extract_iec_60287_parameters(
@@ -359,11 +357,11 @@ def extract_iec_60287_parameters(
         ambient_temperature=ambient_temperature,
     )
 
-    model = ModelFactory.create_model(static_env, scenario)
-    model_output = model.run()
+    model = ModelFactory.create_model(static_env)
+    model_output = model.run(scenario)
 
     parameters = pd.DataFrame()
-    for cable_key, pos_cable in model.cables_with_soil.items():
+    for cable_key, pos_cable in model.cables_in_environment.items():
         context = _get_cable_context(
             cable=pos_cable.cable,
             cable_key=cable_key,
diff --git a/docs/examples/example_calculation.ipynb b/docs/examples/example_calculation.ipynb
index c517325..18e1644 100644
--- a/docs/examples/example_calculation.ipynb
+++ b/docs/examples/example_calculation.ipynb
@@ -220,8 +220,8 @@
     }
    ],
    "source": [
-    "model = ModelFactory.create_model(static_env=static_env, scenario=validated_scenario)\n",
-    "solution = model.run()\n",
+    "model = ModelFactory.create_model(static_env=static_env)\n",
+    "solution = model.run(scenario=validated_scenario)\n",
     "temperature_result = solution.result\n",
     "\n",
     "# Plot the calculated conductor temperatures for both circuits.\n",
@@ -272,7 +272,7 @@
    ],
    "source": [
     "final_state = solution.state\n",
-    "stateful_solution = model.run(initial_state=final_state)\n",
+    "stateful_solution = model.run(scenario=validated_scenario, initial_state=final_state)\n",
     "stateful_temperature_result = stateful_solution.result\n",
     "\n",
     "plt.plot(\n",
@@ -341,8 +341,8 @@
     "scenario_air[\"load_circuit_air\"] = 400 + 150 * np.sin(2 * np.pi * scenario_air.index.hour / 24)\n",
     "scenario_air[\"ambient_temperature\"] = 15  # 15 degrees Celsius\n",
     "\n",
-    "model_air = ModelFactory.create_model(static_env=static_env_air, scenario=scenario_air)\n",
-    "solution_air = model_air.run()\n",
+    "model_air = ModelFactory.create_model(static_env=static_env_air)\n",
+    "solution_air = model_air.run(scenario=scenario_air)\n",
     "temperature_result_air = solution_air.result\n",
     "plt.plot(\n",
     "    temperature_result_air.index,\n",
@@ -359,7 +359,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "cable-thermal-model-py3.11 (3.11.13)",
    "language": "python",
    "name": "python3"
   },
@@ -373,7 +373,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.11.13"
   }
  },
  "nbformat": 4,
diff --git a/docs/examples/external_heat_sources_example.ipynb b/docs/examples/external_heat_sources_example.ipynb
index ccbc729..da9d9b6 100644
--- a/docs/examples/external_heat_sources_example.ipynb
+++ b/docs/examples/external_heat_sources_example.ipynb
@@ -38,7 +38,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -118,8 +118,8 @@
     ")\n",
     "\n",
     "# We calculate the temperatures for the scenario\n",
-    "model = ModelFactory.create_model(static_env, scenario)\n",
-    "solution = model.run()\n",
+    "model = ModelFactory.create_model(static_env)\n",
+    "solution = model.run(scenario)\n",
     "\n",
     "# Plot the temperature results for the conductor and the sheath of the top cable in the circuit\n",
     "plt.plot(\n",
diff --git a/docs/examples/measurement_points.ipynb b/docs/examples/measurement_points.ipynb
index 0743676..890839d 100644
--- a/docs/examples/measurement_points.ipynb
+++ b/docs/examples/measurement_points.ipynb
@@ -256,8 +256,8 @@
        "    <tr>\n",
        "      <th></th>\n",
        "      <th colspan=\"2\" halign=\"left\">single</th>\n",
-       "      <th>x=0.100m</th>\n",
        "      <th>x=0.300m</th>\n",
+       "      <th>x=0.100m</th>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th></th>\n",
@@ -279,29 +279,29 @@
        "      <th>2026-01-01 01:00:00</th>\n",
        "      <td>24.553775</td>\n",
        "      <td>16.687167</td>\n",
-       "      <td>15.262748</td>\n",
        "      <td>15.002660</td>\n",
+       "      <td>15.262748</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2026-01-01 02:00:00</th>\n",
        "      <td>31.924032</td>\n",
        "      <td>18.656360</td>\n",
-       "      <td>15.755784</td>\n",
        "      <td>15.013093</td>\n",
+       "      <td>15.755784</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2026-01-01 03:00:00</th>\n",
        "      <td>38.759849</td>\n",
        "      <td>20.708081</td>\n",
-       "      <td>16.407640</td>\n",
        "      <td>15.036851</td>\n",
+       "      <td>16.407640</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2026-01-01 04:00:00</th>\n",
        "      <td>45.095192</td>\n",
        "      <td>22.765104</td>\n",
-       "      <td>17.163937</td>\n",
        "      <td>15.078364</td>\n",
+       "      <td>17.163937</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -309,13 +309,13 @@
       ],
       "text/plain": [
        "                     circuit_1            measurement_point           \n",
-       "                        single                     x=0.100m   x=0.300m\n",
+       "                        single                     x=0.300m   x=0.100m\n",
        "                     Conductor     Sheath         y=-1.000m  y=-1.000m\n",
        "2026-01-01 00:00:00  15.000000  15.000000         15.000000  15.000000\n",
-       "2026-01-01 01:00:00  24.553775  16.687167         15.262748  15.002660\n",
-       "2026-01-01 02:00:00  31.924032  18.656360         15.755784  15.013093\n",
-       "2026-01-01 03:00:00  38.759849  20.708081         16.407640  15.036851\n",
-       "2026-01-01 04:00:00  45.095192  22.765104         17.163937  15.078364"
+       "2026-01-01 01:00:00  24.553775  16.687167         15.002660  15.262748\n",
+       "2026-01-01 02:00:00  31.924032  18.656360         15.013093  15.755784\n",
+       "2026-01-01 03:00:00  38.759849  20.708081         15.036851  16.407640\n",
+       "2026-01-01 04:00:00  45.095192  22.765104         15.078364  17.163937"
       ]
      },
      "execution_count": null,
@@ -324,9 +324,9 @@
     }
    ],
    "source": [
-    "model = ModelFactory.create_model(static_env=static_env, scenario=scenario)\n",
+    "model = ModelFactory.create_model(static_env=static_env)\n",
     "\n",
-    "solution = model.run()\n",
+    "solution = model.run(scenario=scenario)\n",
     "temperature_result = solution.result\n",
     "\n",
     "temperature_result.head()"
@@ -348,7 +348,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -367,7 +367,7 @@
     "    temperature_result[\"circuit_1\"][CablePosition.Single][CableLayer.Sheath],\n",
     "    temperature_result[measurement_point_key1],\n",
     "    temperature_result[measurement_point_key2],\n",
-    "    model.scenario[\"ambient_temperature\"],\n",
+    "    scenario[\"ambient_temperature\"],\n",
     "]\n",
     "labels = [\n",
     "    \"Conductor\",\n",
diff --git a/docs/get_started/installation_and_overview.md b/docs/get_started/installation_and_overview.md
index 9b802fa..3b2b06f 100644
--- a/docs/get_started/installation_and_overview.md
+++ b/docs/get_started/installation_and_overview.md
@@ -198,8 +198,8 @@ Create and execute the thermal model:
 ```python
 from cable_thermal_model import ModelFactory
 
-model = ModelFactory.create_model(static_env=static_env, scenario=scenario)
-solution = model.run()
+model = ModelFactory.create_model(static_env=static_env)
+solution = model.run(scenario=scenario)
 temperature_result = solution.result
 ```
 
diff --git a/docs/get_started/model_input.md b/docs/get_started/model_input.md
index 77cb031..0dcddfa 100644
--- a/docs/get_started/model_input.md
+++ b/docs/get_started/model_input.md
@@ -202,6 +202,8 @@ scenario = pd.DataFrame({
 
 You can validate your scenario before running the model:
 
+Validation is also performed automatically as the first step of `model.run()`, so manual validation is optional.
+
 ```python
 from cable_thermal_model.model.schemas import ScenarioSchemaSoil, ScenarioSchemaAir
 
@@ -251,8 +253,8 @@ scenario = pd.DataFrame({
 }, index=pd.date_range(start=datetime(2026, 1, 1), periods=3, freq='1h'))
 
 # 4. Run the model
-model = ModelFactory.create_model(static_env=static_env, scenario=scenario)
-solution = model.run()
+model = ModelFactory.create_model(static_env=static_env)
+solution = model.run(scenario=scenario)
 temperature_result = solution.result
 ```
 
diff --git a/tests/cable/test_TB880_case_10.py b/tests/cable/test_TB880_case_10.py
index 63a54f5..69bbeef 100644
--- a/tests/cable/test_TB880_case_10.py
+++ b/tests/cable/test_TB880_case_10.py
@@ -99,7 +99,7 @@ def test_calculate_loss_for_lead_sheath(TB880_case_10_fd_cable: CableSoil):
 def test_calculate_thermal_resistances(
     TB880_case_10_model: ModelSoil, TB880_case_10_steady_state_full_solution: np.ndarray
 ):
-    TB880_case_10_fd_cable = TB880_case_10_model.cables_with_soil[
+    TB880_case_10_fd_cable = TB880_case_10_model.cables_in_environment[
         CableKey(circuit_name="TB880_case_10", cable_position=CablePosition.Single)
     ].cable
     assert CableLayer.ConductorScreen not in TB880_case_10_fd_cable.layers
@@ -115,7 +115,5 @@ def test_calculate_thermal_resistances(
     t3 = analysis.get_thermal_resistance_cable_layer(layer=CableLayer.Sheath)
     assert np.isclose(t3, 0.0886807855, rtol=RELATIVE_TOLERANCE)
 
-    t4 = analysis.get_thermal_resistance_external_medium(
-        ambient_temperature=TB880_case_10_model.scenario["ambient_temperature"].iloc[-1]
-    )
+    t4 = analysis.get_thermal_resistance_external_medium(ambient_temperature=15)
     assert np.isclose(t4, 0.6850633170, rtol=RELATIVE_TOLERANCE)
diff --git a/tests/conftest.py b/tests/conftest.py
index 8af50ac..ae873be 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -7,7 +7,6 @@
 import numpy as np
 import pandas as pd
 import pytest
-from pandera.typing import DataFrame
 
 from cable_thermal_model.cable.cable_builder import CableBuilder
 from cable_thermal_model.cable.cable_circuit import (
@@ -51,7 +50,6 @@
 from cable_thermal_model.model.model import Model
 from cable_thermal_model.model.model_factory import ModelFactory
 from cable_thermal_model.model.model_soil import ModelSoil
-from cable_thermal_model.model.schemas.model_input_schemas import ScenarioSchemaSoil
 
 # Models
 
@@ -59,52 +57,42 @@
 
 
 @pytest.fixture(scope="function")
-def model(single_circuit_env: StaticEnvSoil, scenario_constant: DataFrame[ScenarioSchemaSoil]) -> Model:
-    return ModelFactory.create_model(static_env=single_circuit_env, scenario=scenario_constant)
+def model(single_circuit_env: StaticEnvSoil) -> Model:
+    return ModelFactory.create_model(static_env=single_circuit_env)
 
 
 @pytest.fixture(scope="function")
-def model_single_config(  # type: ignore
-    single_circuit_single_config_env: StaticEnvSoil, scenario_constant: DataFrame[ScenarioSchemaSoil]
-) -> Model:
-    return ModelFactory.create_model(static_env=single_circuit_single_config_env, scenario=scenario_constant)
+def model_single_config(single_circuit_single_config_env: StaticEnvSoil) -> Model:  # type: ignore
+    return ModelFactory.create_model(static_env=single_circuit_single_config_env)
 
 
 @pytest.fixture(scope="function")
 def model_multiple_configs(
-    single_circuit_multiple_configs_env: StaticEnvSoil, scenario_constant: DataFrame[ScenarioSchemaSoil]
+    single_circuit_multiple_configs_env: StaticEnvSoil,
 ) -> Model:
-    return ModelFactory.create_model(static_env=single_circuit_multiple_configs_env, scenario=scenario_constant)
+    return ModelFactory.create_model(static_env=single_circuit_multiple_configs_env)
 
 
 @pytest.fixture(scope="function")
-def model_with_pipe(
-    single_circuit_with_pipe_env: StaticEnvSoil, scenario_constant: DataFrame[ScenarioSchemaSoil]
-) -> Model:
-    return ModelFactory.create_model(static_env=single_circuit_with_pipe_env, scenario=scenario_constant)
+def model_with_pipe(single_circuit_with_pipe_env: StaticEnvSoil) -> Model:
+    return ModelFactory.create_model(static_env=single_circuit_with_pipe_env)
 
 
 @pytest.fixture(scope="function")
-def model_dynamic_soil(
-    single_circuit_env: StaticEnvSoil, scenario_dynamic_soil_prop: DataFrame[ScenarioSchemaSoil]
-) -> Model:
-    return ModelFactory.create_model(static_env=single_circuit_env, scenario=scenario_dynamic_soil_prop)
+def model_dynamic_soil(single_circuit_env: StaticEnvSoil) -> Model:
+    return ModelFactory.create_model(static_env=single_circuit_env)
 
 
 @pytest.fixture(scope="function")
 def model_with_measurement_points(
-    single_circuit_env: StaticEnvSoil, scenario_constant: DataFrame[ScenarioSchemaSoil]
+    single_circuit_env: StaticEnvSoil,
 ) -> tuple[Model, MeasurementPointKey, MeasurementPointKey]:
     """Create a model with measurement points added to the environment."""
     # Add measurement points to the environment
     key1 = single_circuit_env.add_measurement_point(x=0.1, y=-1.0)
     key2 = single_circuit_env.add_measurement_point(x=0.3, y=-1.0)
 
-    return (
-        ModelFactory.create_model(static_env=single_circuit_env, scenario=scenario_constant),
-        key1,
-        key2,
-    )
+    return (ModelFactory.create_model(static_env=single_circuit_env), key1, key2)
 
 
 # Environments
@@ -481,7 +469,7 @@ def scenario_dynamic(load_series_dynamic, frequency) -> pd.DataFrame:
 @pytest.fixture(scope="function")
 def scenario_dynamic_soil_prop(
     load_series_constant, dynamic_soil_resistivitiy_series, dynamic_soil_capacity_series
-) -> DataFrame[ScenarioSchemaSoil]:
+) -> pd.DataFrame:
     scenario_dynamic = pd.DataFrame(
         data={
             "load_c1": load_series_constant,
@@ -491,57 +479,51 @@ def scenario_dynamic_soil_prop(
         },
         index=load_series_constant.index,
     )
-    return ScenarioSchemaSoil.validate(scenario_dynamic)
+    return scenario_dynamic
 
 
 @pytest.fixture(scope="function")
-def scenario_constant(load_series_constant) -> DataFrame[ScenarioSchemaSoil]:
-    return ScenarioSchemaSoil.validate(
-        pd.DataFrame(
-            data={
-                "load_c1": load_series_constant,
-                "ambient_temperature": 10,
-                "soil_thermal_resistivity": 0.75,
-                "soil_thermal_capacity": 2e6,
-            },
-            index=load_series_constant.index,
-        )
+def scenario_constant(load_series_constant) -> pd.DataFrame:
+    return pd.DataFrame(
+        data={
+            "load_c1": load_series_constant,
+            "ambient_temperature": 10,
+            "soil_thermal_resistivity": 0.75,
+            "soil_thermal_capacity": 2e6,
+        },
+        index=load_series_constant.index,
     )
 
 
 @pytest.fixture(scope="function")
-def scenario_constant_multi(load_series_constant) -> DataFrame[ScenarioSchemaSoil]:
-    return ScenarioSchemaSoil.validate(
-        pd.DataFrame(
-            data={
-                "load_c0": load_series_constant,
-                "load_c1": load_series_constant,
-                "ambient_temperature": 10,
-                "soil_thermal_resistivity": 0.75,
-                "soil_thermal_capacity": 2e6,
-            },
-            index=load_series_constant.index,
-        )
+def scenario_constant_multi(load_series_constant) -> pd.DataFrame:
+    return pd.DataFrame(
+        data={
+            "load_c0": load_series_constant,
+            "load_c1": load_series_constant,
+            "ambient_temperature": 10,
+            "soil_thermal_resistivity": 0.75,
+            "soil_thermal_capacity": 2e6,
+        },
+        index=load_series_constant.index,
     )
 
 
 @pytest.fixture(scope="function")
-def scenario_steady_state() -> DataFrame[ScenarioSchemaSoil]:
-    return ScenarioSchemaSoil.validate(
-        pd.DataFrame(
-            data={
-                "load_c1": 0,
-                "ambient_temperature": 10,
-                "soil_thermal_resistivity": 0.75,
-                "soil_thermal_capacity": 2e6,
-            },
-            index=pd.timedelta_range(start="0D", end="30000D", periods=5),
-        )
+def scenario_steady_state() -> pd.DataFrame:
+    return pd.DataFrame(
+        data={
+            "load_c1": 0,
+            "ambient_temperature": 10,
+            "soil_thermal_resistivity": 0.75,
+            "soil_thermal_capacity": 2e6,
+        },
+        index=pd.timedelta_range(start="0D", end="30000D", periods=5),
     )
 
 
 @pytest.fixture(scope="function")
-def b5901_scenario_steady_state(scenario_steady_state: DataFrame[ScenarioSchemaSoil]) -> DataFrame[ScenarioSchemaSoil]:
+def b5901_scenario_steady_state(scenario_steady_state: pd.DataFrame) -> pd.DataFrame:
     scenario_steady_state["ambient_temperature"] = 15
     return scenario_steady_state
 
@@ -603,7 +585,6 @@ def TB880_case_10_fd_cable() -> CableSoil:
 
 @pytest.fixture(scope="module")
 def TB880_case_10_model(TB880_case_10_fd_cable: CableSoil) -> ModelSoil:
-    I_rating = 165.7415608133
 
     static_env = StaticEnvSoil()
     static_env.add_circuit_from_cable(
@@ -617,6 +598,12 @@ def TB880_case_10_model(TB880_case_10_fd_cable: CableSoil) -> ModelSoil:
         )
     )
 
+    return ModelSoil(static_env)
+
+
+@pytest.fixture(scope="module")
+def TB880_case_10_steady_state_full_solution(TB880_case_10_model: ModelSoil) -> np.ndarray:
+    I_rating = 165.7415608133
     scenario = pd.DataFrame(
         data={
             "load_TB880_case_10": I_rating,
@@ -626,12 +613,7 @@ def TB880_case_10_model(TB880_case_10_fd_cable: CableSoil) -> ModelSoil:
         },
         index=pd.timedelta_range(start="0D", end="30000D", periods=100),
     )
-    return ModelSoil(static_env, ScenarioSchemaSoil.validate(scenario))
-
-
-@pytest.fixture(scope="module")
-def TB880_case_10_steady_state_full_solution(TB880_case_10_model: ModelSoil) -> np.ndarray:
-    return TB880_case_10_model.run().state.temperature[
+    return TB880_case_10_model.run(scenario=scenario).state.temperature[
         CableKey(circuit_name="TB880_case_10", cable_position=CablePosition.Single)
     ]
 
diff --git a/tests/model/cables/test_3cores.py b/tests/model/cables/test_3cores.py
index 4b08eb6..871a6e0 100644
--- a/tests/model/cables/test_3cores.py
+++ b/tests/model/cables/test_3cores.py
@@ -12,7 +12,6 @@
 from cable_thermal_model.model.cables.cable_soil import CableSoil
 from cable_thermal_model.model.cables.enum_classes_cable import CableLayer
 from cable_thermal_model.model.model_factory import ModelFactory
-from cable_thermal_model.model.schemas.model_input_schemas import ScenarioSchemaSoil
 
 
 def test_single_core_xlpe(single_core_cable_xlpe: CableSoil):
@@ -86,8 +85,8 @@ def test_3core_pilc_run(
             x=0, y=-0.8, circuit_name="c", cable=three_core_cable_pilc, circuit_type=CircuitType.Single
         )
     )
-    model = ModelFactory.create_model(environment, ScenarioSchemaSoil.validate(scenario))
-    solution = model.run()
+    model = ModelFactory.create_model(environment)
+    solution = model.run(scenario)
 
     assert np.isclose(
         solution.result[("c", "single")].iloc[-1][CableLayer.Conductor],
@@ -141,8 +140,8 @@ def test_3core_xlpe_run(
             x=0, y=-0.8, circuit_name="c", cable=three_core_cable_xlpe, circuit_type=CircuitType.Single
         )
     )
-    model = ModelFactory.create_model(environment, ScenarioSchemaSoil.validate(scenario))
-    solution = model.run()
+    model = ModelFactory.create_model(environment)
+    solution = model.run(scenario)
 
     assert np.isclose(
         solution.result[("c", "single")].iloc[-1][CableLayer.Conductor],
diff --git a/tests/model/cables/test_cable.py b/tests/model/cables/test_cable.py
index 9891cba..533fbfb 100644
--- a/tests/model/cables/test_cable.py
+++ b/tests/model/cables/test_cable.py
@@ -429,7 +429,7 @@ def test_update_pipe_fill_resistivity_without_inner_radius_raises(single_core_ca
 
 def test_update_rho_grid(single_core_cable_xlpe: CableSoil):
     with pytest.raises(ValueError, match="The start_index exceeds the end_index. Cannot update the rho grid."):
-        single_core_cable_xlpe._update_rho_grid(start_index=2, end_index=1, rho=1.0)
+        single_core_cable_xlpe._update_rho_grid(start_index=2, end_index=1, rho_values=1.0)
 
     # Ensure the cached diagonals are marked up-to-date before testing invalidation behavior.
     _ = single_core_cable_xlpe._banded_matrix
@@ -439,11 +439,11 @@ def test_update_rho_grid(single_core_cable_xlpe: CableSoil):
     old_values = single_core_cable_xlpe._rho_grid.copy()
     rho = float(single_core_cable_xlpe._rho_grid[start_index])
 
-    single_core_cable_xlpe._update_rho_grid(start_index=start_index, end_index=end_index, rho=rho * 1.005)
+    single_core_cable_xlpe._update_rho_grid(start_index=start_index, end_index=end_index, rho_values=rho * 1.005)
     assert np.array_equal(single_core_cable_xlpe._rho_grid, old_values)
     assert not single_core_cable_xlpe._finite_difference_matrix_diagonals_outdated
 
-    single_core_cable_xlpe._update_rho_grid(start_index=start_index, end_index=end_index, rho=rho * 1.2)
+    single_core_cable_xlpe._update_rho_grid(start_index=start_index, end_index=end_index, rho_values=rho * 1.2)
     assert np.allclose(single_core_cable_xlpe._rho_grid[start_index : end_index + 1], rho * 1.2)
     assert single_core_cable_xlpe._finite_difference_matrix_diagonals_outdated
 
@@ -453,13 +453,12 @@ def test_update_capacity_grid(single_core_cable_xlpe: CableSoil):
         single_core_cable_xlpe._update_capacity_grid(start_index=5, end_index=3, capacity=2.0e6)
 
     start_index, end_index = single_core_cable_xlpe.get_layer_indices_for_layer(CableLayer.Conductor)
-    old_values = single_core_cable_xlpe._capacity_grid.copy()
     capacity = float(single_core_cable_xlpe._capacity_grid[start_index])
 
     single_core_cable_xlpe._update_capacity_grid(
         start_index=start_index, end_index=end_index, capacity=capacity * 1.005
     )
-    assert np.array_equal(single_core_cable_xlpe._capacity_grid, old_values)
+    assert np.allclose(single_core_cable_xlpe._capacity_grid[start_index : end_index + 1], capacity * 1.005)
 
     single_core_cable_xlpe._update_capacity_grid(start_index=start_index, end_index=end_index, capacity=capacity * 1.2)
     assert np.allclose(single_core_cable_xlpe._capacity_grid[start_index : end_index + 1], capacity * 1.2)
diff --git a/tests/model/test_abstract_model.py b/tests/model/test_abstract_model.py
index 6bf7421..1caa95f 100644
--- a/tests/model/test_abstract_model.py
+++ b/tests/model/test_abstract_model.py
@@ -60,13 +60,12 @@ def test_model_init_without_arguments():
         ),
     ],
 )
-def test_set_scenario(model, new_scenario):
-    """Tests whether the updated scenario is set in the model object."""
-    model.run()
-    model.set_scenario(new_scenario)
-    assert model.scenario.equals(new_scenario)
+def test_run_accepts_different_scenarios(model, new_scenario):
+    """Tests whether the same model instance can be executed with different scenarios."""
+    first_result = model.run(new_scenario)
+    second_result = model.run(new_scenario)
 
-    model.run()
+    pd.testing.assert_frame_equal(first_result.result, second_result.result)
 
 
 @pytest.mark.parametrize(
@@ -209,24 +208,33 @@ def test_validate_scenario(
     - missing values (NaNs).
     """
     scenario_soil = cast(DataFrame[ScenarioSchemaSoil], scenario)
+    model = ModelFactory.create_model(static_env=single_circuit_env)
 
     if error_msg:
         with pytest.raises(exception, match=error_msg):
-            ModelFactory.create_model(static_env=single_circuit_env, scenario=scenario_soil)
+            model.run(scenario_soil)
     else:
         with pytest.raises(exception):
-            ModelFactory.create_model(static_env=single_circuit_env, scenario=scenario_soil)
+            model.run(scenario_soil)
 
 
 @pytest.mark.parametrize("temperature_dependent_electric_resistance", [True, False])
 @pytest.mark.parametrize("soil_drying", [True, False])
 @pytest.mark.parametrize("ac_current", [True, False])
 @pytest.mark.parametrize("initial_state", [True, False])
-def test_run(model, temperature_dependent_electric_resistance, soil_drying, ac_current, initial_state):
+def test_run(
+    model,
+    scenario_constant,
+    temperature_dependent_electric_resistance,
+    soil_drying,
+    ac_current,
+    initial_state,
+):
     """Tests whether we can go through the different options and get results but does not check output."""
-    state = model.run().state if initial_state else None
+    state = model.run(scenario_constant).state if initial_state else None
 
     solution = model.run(
+        scenario_constant,
         initial_state=state,
         run_options={
             "temperature_dependent_electric_resistance": temperature_dependent_electric_resistance,
@@ -234,9 +242,28 @@ def test_run(model, temperature_dependent_electric_resistance, soil_drying, ac_c
             "ac_current": ac_current,
         },
     )
+
     assert solution is not None
 
 
+def test_run_with_split_scenario(model, scenario_constant):
+    """Tests that explicit run scenarios preserve chained results."""
+    long_scenario = scenario_constant.copy()
+    split_idx = len(long_scenario) // 2
+    first_short_scenario = long_scenario.iloc[: split_idx + 1].copy()
+    second_short_scenario = long_scenario.iloc[split_idx:].copy()
+
+    long_output = model.__class__(model.static_env).run(long_scenario)
+
+    reused_model = model.__class__(model.static_env)
+    first_output = reused_model.run(first_short_scenario)
+    second_output = reused_model.run(second_short_scenario, initial_state=first_output.state)
+
+    reused_result = pd.concat([first_output.result.copy(), second_output.result.iloc[1:].copy()])
+
+    pd.testing.assert_frame_equal(reused_result, long_output.result, rtol=1e-10, atol=1e-10)
+
+
 def test_state_check_solution_consistency(single_core_cable_xlpe):
     """Test the check_solution_consistency validator in State class."""
     # Create test cable representation
@@ -325,17 +352,5 @@ def test_state_check_environment_hash_consistency(model):
 
 
 def test_model_str_representation(model):
-    """Test concise model string for short and long scenarios."""
-    assert str(model) == "Model with 1 circuit environment and 2 day scenario"
-
-    long_scenario = pd.DataFrame(
-        index=pd.date_range("2020-01-01", "2020-01-10", freq="1d"),
-        data={
-            "load_c1": np.linspace(90, 110, 10),
-            "ambient_temperature": 10,
-            "soil_thermal_resistivity": 0.75,
-            "soil_thermal_capacity": 2e6,
-        },
-    )
-    model.set_scenario(cast(DataFrame[ScenarioSchemaSoil], long_scenario))
-    assert str(model) == "Model with 1 circuit environment and 9 day scenario"
+    """Test concise model string for scenario-free model instances."""
+    assert str(model) == "Model with 1 circuit environment"
diff --git a/tests/model/test_model.py b/tests/model/test_model.py
index 1480d0c..11ffe33 100644
--- a/tests/model/test_model.py
+++ b/tests/model/test_model.py
@@ -61,40 +61,57 @@ def test_set_run_options_accepts_model_run_options_instance(model_class: type[Mo
     assert model.run_options is run_options_instance
 
 
-def test_add_solution_location_rejects_invalid_layer_type(model: ModelSoil):
-    """Ensure a clear TypeError is raised for non-CableLayer input."""
-    with pytest.raises(TypeError, match="The layer argument must be of type CableLayer"):
-        model.add_solution_location(layer_name="Conductor")  # type: ignore[arg-type]
+def test_run_rejects_invalid_extra_solution_layer(model: ModelSoil, scenario_constant):
+    """Ensure invalid extra solution layers are rejected through run-option validation."""
+    with pytest.raises(ValueError, match="extra_solution_layers"):
+        model.run(scenario_constant, run_options={"extra_solution_layers": ["NotALayer"]})
+
+
+@pytest.mark.parametrize(
+    "layer",
+    [
+        CableLayer.Conductor,
+        CableLayer.Sheath,
+        CableLayer.Pipe,
+    ],
+)
+def test_run_rejects_standard_layers_in_extra_solution_layers(model: ModelSoil, scenario_constant, layer: CableLayer):
+    """Ensure dedicated output layers cannot be requested through extra_solution_layers."""
+    with pytest.raises(ValueError, match="extra_solution_layers"):
+        model.run(scenario_constant, run_options={"extra_solution_layers": [layer]})
 
 
 def test_initialize_state_from_cables_uses_fill_value(model: ModelSoil):
     """Ensure helper initializes all cable arrays with the provided fill value."""
     fill_value = 42.5
-    initialized = model._initialize_state_from_cables(cables=model.cables, fill_value=fill_value)
+    initialized = model._initialize_state_from_cables(cables=model._cables, fill_value=fill_value)
 
-    assert set(initialized) == set(model.cables)
-    for cable_key in model.cables:
+    assert set(initialized) == set(model._cables)
+    for cable_key in model._cables:
         assert np.all(np.isclose(initialized[cable_key], fill_value))
 
 
-def test_get_circuit_loads_from_scenario_row(model: ModelSoil):
+def test_get_circuit_loads_from_scenario_row(model: ModelSoil, scenario_constant):
     """Ensure scenario row is mapped to circuit load dict using load_<circuit_name> keys."""
-    _, scenario_row = next(model.scenario.iterrows())
+    _, scenario_row = next(scenario_constant.iterrows())
 
     loads = model._get_circuit_loads_from_scenario_row(scenario_row)
 
     assert loads == {"c1": scenario_row["load_c1"]}
 
 
-def test_initialize_temperature_result_contains_expected_layers(model: ModelSoil):
+def test_initialize_temperature_result_contains_expected_layers(model: ModelSoil, scenario_constant):
     """Ensure initialized result includes standard and requested extra layers, and excludes absent layers."""
-    model.add_solution_location(CableLayer.Insulation)
-    initial_state = model._build_initial_state()
+    run_options = {"extra_solution_layers": [CableLayer.Insulation]}
+    model.run(scenario_constant, run_options=run_options)
+    initial_state = model._build_initial_state(scenario_constant["ambient_temperature"].iloc[0])
 
-    model._initialize_temperature_result(state=initial_state)
-    temperature_result = model.temperature_result
+    temperature_result = model._initialize_temperature_result(
+        state=initial_state,
+        n_scenario_rows=len(scenario_constant.index),
+    )
 
-    for cable_key in model.cables:
+    for cable_key in model._cables:
         assert CableLayer.Conductor in temperature_result[cable_key]
         assert CableLayer.Sheath in temperature_result[cable_key]
         assert CableLayer.Insulation in temperature_result[cable_key]
@@ -102,26 +119,30 @@ def test_initialize_temperature_result_contains_expected_layers(model: ModelSoil
         assert np.isfinite(temperature_result[cable_key][CableLayer.Conductor][0])
 
 
-def test_update_pipe_fill_resistivity_skips_cables_without_pipe(model: ModelSoil):
+def test_update_pipe_fill_resistivity_skips_cables_without_pipe(model: ModelSoil, scenario_constant):
     """Ensure no pipe-fill updates happen for cables without a pipe layer."""
-    temperature_state = model._build_initial_state().temperature
+    model.run(scenario_constant)
+    temperature_state = model._build_initial_state(scenario_constant["ambient_temperature"].iloc[0]).temperature
 
     mocked_update_methods = {}
-    for cable_key, pos_cable in model.cables.items():
+    for cable_key, pos_cable in model._cables.items():
         mocked_update_methods[cable_key] = MagicMock()
         pos_cable.cable.update_pipe_fill_resistivity = mocked_update_methods[cable_key]
 
-    model._update_pipe_fill_resistivity(temperature_state=temperature_state, cables=model.cables)
+    model._update_pipe_fill_resistivity(temperature_state=temperature_state, cables=model._cables)
 
     for cable_key in mocked_update_methods:
         mocked_update_methods[cable_key].assert_not_called()
 
 
-def test_update_pipe_fill_resistivity_updates_pipe_cables(model_with_pipe: ModelSoil):
+def test_update_pipe_fill_resistivity_updates_pipe_cables(model_with_pipe: ModelSoil, scenario_constant):
     """Ensure pipe-fill resistivity is updated with the mean PipeFill temperature when a pipe exists."""
-    temperature_state = model_with_pipe._build_initial_state().temperature
+    model_with_pipe.run(scenario_constant)
+    temperature_state = model_with_pipe._build_initial_state(
+        scenario_constant["ambient_temperature"].iloc[0]
+    ).temperature
 
-    for cable_key, pos_cable in model_with_pipe.cables.items():
+    for cable_key, pos_cable in model_with_pipe._cables.items():
         if pos_cable.cable.layer_metrics.pipe is None:
             continue
 
@@ -139,7 +160,7 @@ def test_update_pipe_fill_resistivity_updates_pipe_cables(model_with_pipe: Model
 
 def test_validate_state_model_consistency_rejects_wrong_state_type(model: ModelSoil):
     """Ensure model type check rejects states from a different model class."""
-    cable_key = next(iter(model.cables))
+    cable_key = next(iter(model.static_env.get_cables()))
     wrong_state = StateAir(
         static_env_hash=model.static_env.compute_hash(),
         temperature={cable_key: np.array([20.0])},
@@ -151,11 +172,11 @@ def test_validate_state_model_consistency_rejects_wrong_state_type(model: ModelS
         model._validate_state_model_consistency(wrong_state)
 
 
-def test_initialize_thermal_state_returns_deep_copy(model: ModelSoil):
+def test_initialize_thermal_state_returns_deep_copy(model: ModelSoil, scenario_constant):
     """Ensure provided initial state is deep-copied before reuse."""
-    initial_state = model.run().state
+    initial_state = model.run(scenario_constant).state
 
-    initialized_state = model._initialize_state(initial_state=initial_state)
+    initialized_state = model._initialize_state(scenario_constant, initial_state=initial_state)
 
     assert initialized_state is not initial_state
 
diff --git a/tests/model/test_model_air.py b/tests/model/test_model_air.py
index d7bab61..3624c58 100644
--- a/tests/model/test_model_air.py
+++ b/tests/model/test_model_air.py
@@ -6,7 +6,6 @@
 import numpy as np
 import pandas as pd
 import pytest
-from pandera.typing import DataFrame
 
 from cable_thermal_model import CableLayer, CircuitType, ModelFactory, StaticEnvAir, StaticEnvSoil
 from cable_thermal_model.cable.cable_circuit import (
@@ -19,7 +18,6 @@
 )
 from cable_thermal_model.model.model_air import ModelAir, StateAir
 from cable_thermal_model.model.model_soil import StateSoil
-from cable_thermal_model.model.schemas.model_input_schemas import ScenarioSchemaAir, ScenarioSchemaSoil
 from cable_thermal_model.validation.cable_analysis import CableAnalysis
 
 
@@ -56,16 +54,16 @@ def test_model_steady_state(
         },
     )
 
-    model = ModelAir(env, ScenarioSchemaAir.validate(scenario))
-    solution = model.run()
+    model = ModelAir(env)
+    solution = model.run(scenario)
     result = solution.result
     # First we get all the cables for test circuit 'c'
     circuit_c_cables = list(set(list(result.columns.get_level_values(1))))
     ctm_temp = max([result["c"][cable_key][CableLayer.Conductor].iloc[-1] for cable_key in circuit_c_cables])
     assert np.isclose(expected_temperature, ctm_temp, atol=max_absolute_temperature_error)
 
-    cable_key = list(model.cables.keys())[0]
-    cable = model.cables[cable_key].cable
+    cable_key = list(model.cables_in_environment.keys())[0]
+    cable = model.cables_in_environment[cable_key].cable
     cable_full_solution = solution.state.temperature[cable_key]
     conductor_start_index, conductor_end_index = cable.get_layer_indices_for_layer(CableLayer.Conductor)
     screen_start_index, screen_end_index = cable.get_layer_indices_for_layer(CableLayer.Screen)
@@ -90,7 +88,7 @@ def test_model_steady_state(
     assert np.isclose(total_heat_generation, heat_flow_for_sheath)
 
 
-def test_single_cable_in_air_compare_to_soil(scenario_steady_state: DataFrame[ScenarioSchemaSoil]):
+def test_single_cable_in_air_compare_to_soil(scenario_steady_state: pd.DataFrame):
     """Compare single cables in air and soil.
 
     When we ignore the effect of temperature-dependent resistance, the heat flux at the cable boundary should be
@@ -122,19 +120,25 @@ def test_single_cable_in_air_compare_to_soil(scenario_steady_state: DataFrame[Sc
     scenario_steady_state["load_c1"] = load
 
     # Compute the steady state solution for both environments
-    model_soil = ModelFactory.create_model(static_env_soil, scenario_steady_state)
-    steady_state_soil = model_soil.run(run_options={"temperature_dependent_electric_resistance": False}).state
-
-    model_air = ModelFactory.create_model(static_env_air, ScenarioSchemaAir.validate(scenario_steady_state))
-    steady_state_air = model_air.run(run_options={"temperature_dependent_electric_resistance": False}).state
+    model_soil = ModelFactory.create_model(static_env_soil)
+    steady_state_soil = model_soil.run(
+        scenario_steady_state,
+        run_options={"temperature_dependent_electric_resistance": False},
+    ).state
+
+    model_air = ModelFactory.create_model(static_env_air)
+    steady_state_air = model_air.run(
+        scenario_steady_state,
+        run_options={"temperature_dependent_electric_resistance": False},
+    ).state
 
     # Select the single cable from both circuits and collect their steady state solutions
     cable_key = CableKey(circuit_name="c1", cable_position=CablePosition.Single)
 
-    cable_soil = model_soil.cables_with_soil[cable_key].cable
+    cable_soil = model_soil.cables_in_environment[cable_key].cable
     steady_state_solution_soil = steady_state_soil.self_heating_contribution[cable_key]
 
-    cable_air = model_air.cables[cable_key].cable
+    cable_air = model_air.cables_in_environment[cable_key].cable
     steady_state_solution_air = steady_state_air.self_heating_contribution[cable_key]
 
     cable_analysis_soil = CableAnalysis(cable=cable_soil, solution=steady_state_solution_soil)
@@ -190,8 +194,10 @@ def test_model_air_validate_scenario_warns_for_unused_soil_columns(single_circui
         },
     )
 
+    model = ModelAir(single_circuit_in_air_env)
+
     with pytest.warns(UserWarning) as warnings_record:
-        _ = ModelAir(single_circuit_in_air_env, scenario)
+        model.run(scenario)
 
     warning_messages = [str(w.message) for w in warnings_record]
     assert any("soil_thermal_resistivity" in message for message in warning_messages)
@@ -216,12 +222,12 @@ def test_model_air_validate_state(single_core_cable_xlpe):
         data={"ambient_temperature": 30, f"load_{circuit_name}": 100.0},
     )
 
-    model = ModelAir(env, ScenarioSchemaAir.validate(scenario))
+    model = ModelAir(env)
     # Mock the output of model.compute_temperature_result() to prevent the need for a full model run
-    model._compute_temperature_solution = lambda initial_state: None
+    model._compute_temperature_solution = lambda scenario, initial_state: None
 
     # Test 1: state=None should pass
-    model.run(initial_state=None)
+    model.run(scenario, initial_state=None)
 
     # Test 2: state=StateAir instance should pass
     pos_cable = env.cables[CableKey(circuit_name=circuit_name, cable_position=CablePosition.Single)]
@@ -234,7 +240,7 @@ def test_model_air_validate_state(single_core_cable_xlpe):
         ambient_temperature=0.0,
     )
 
-    model.run(initial_state=valid_state)
+    model.run(scenario, initial_state=valid_state)
 
     # Test 3: state=StateSoil instance should raise ValueError
     invalid_state_soil = StateSoil(
@@ -246,7 +252,7 @@ def test_model_air_validate_state(single_core_cable_xlpe):
     )
 
     with pytest.raises(ValueError, match="ModelAir requires a StateAir instance, but received StateSoil"):
-        model.run(initial_state=invalid_state_soil)
+        model.run(scenario, initial_state=invalid_state_soil)
 
 
 def test_use_wrong_static_env_type():
@@ -258,4 +264,4 @@ def test_use_wrong_static_env_type():
             "environment in air. Please use ModelSoil instead."
         ),
     ):
-        ModelAir(static_env=StaticEnvSoil(), scenario=pd.DataFrame())
+        ModelAir(static_env=StaticEnvSoil())
diff --git a/tests/model/test_model_factory.py b/tests/model/test_model_factory.py
new file mode 100644
index 0000000..81d82ad
--- /dev/null
+++ b/tests/model/test_model_factory.py
@@ -0,0 +1,55 @@
+# SPDX-FileCopyrightText: Contributors to the Cable Thermal Model project
+#
+# SPDX-License-Identifier: MPL-2.0
+
+import pytest
+
+from cable_thermal_model.environment.static_env_air import StaticEnvAir
+from cable_thermal_model.environment.static_env_soil import StaticEnvSoil
+from cable_thermal_model.model.model_air import ModelAir
+from cable_thermal_model.model.model_factory import ModelFactory
+from cable_thermal_model.model.model_soil import ModelSoil
+
+
+@pytest.mark.parametrize(
+    "static_env,expected_model_type",
+    [
+        pytest.param(StaticEnvAir(), ModelAir, id="air-env"),
+        pytest.param(StaticEnvSoil(), ModelSoil, id="soil-env"),
+    ],
+)
+def test_create_model_returns_expected_type_for_supported_environments(
+    static_env: StaticEnvAir | StaticEnvSoil,
+    expected_model_type: type[ModelAir] | type[ModelSoil],
+):
+    """Supported environments should resolve to their corresponding model classes."""
+    model = ModelFactory.create_model(static_env=static_env)
+
+    assert isinstance(model, expected_model_type)
+    assert model.static_env is static_env
+
+
+def test_create_model_raises_for_unsupported_static_environment_type():
+    """Unsupported environments should raise a clear ValueError."""
+    unsupported_env = object()
+
+    with pytest.raises(
+        ValueError,
+        match=("Unsupported static environment type: object\\. Expected StaticEnvAir or StaticEnvSoil\\."),
+    ):
+        ModelFactory.create_model(static_env=unsupported_env)  # type: ignore[arg-type]
+
+
+def test_create_model_includes_custom_type_name_in_error_message():
+    """The error should include the unsupported input type name for easier debugging."""
+
+    class UnsupportedEnvironment:
+        pass
+
+    with pytest.raises(
+        ValueError,
+        match=(
+            "Unsupported static environment type: UnsupportedEnvironment\\. Expected StaticEnvAir or StaticEnvSoil\\."
+        ),
+    ):
+        ModelFactory.create_model(static_env=UnsupportedEnvironment())  # type: ignore[arg-type]
diff --git a/tests/model/test_model_soil.py b/tests/model/test_model_soil.py
index 59790ae..41da5b8 100644
--- a/tests/model/test_model_soil.py
+++ b/tests/model/test_model_soil.py
@@ -10,7 +10,6 @@
 import pandas as pd
 import pytest
 from pandera.errors import SchemaError
-from pandera.typing import DataFrame
 from pydantic import ValidationError
 
 from cable_thermal_model.cable.cable_circuit import (
@@ -35,38 +34,34 @@
 from cable_thermal_model.model.model import Model
 from cable_thermal_model.model.model_air import StateAir
 from cable_thermal_model.model.model_soil import ModelSoil, StateSoil
-from cable_thermal_model.model.schemas.model_input_schemas import ScenarioSchemaSoil
 from cable_thermal_model.model.schemas.run_options import ModelSoilRunOptions
 from cable_thermal_model.validation.cable_analysis import CableAnalysis
 
 
-def test_scenario_validation(single_circuit_env: StaticEnvSoil, scenario_constant: DataFrame[ScenarioSchemaSoil]):
-    """Test whether scenario is correctly validated when instantiating a Model instance."""
+def test_scenario_validation(single_circuit_env: StaticEnvSoil, scenario_constant: pd.DataFrame):
+    """Test whether scenario is correctly validated when running a Model instance."""
     # Check whether standard scenario passes the validation
-    ModelSoil(single_circuit_env, scenario_constant)
+    ModelSoil(single_circuit_env).run(scenario_constant)
 
     # check whether error is raised if ambient temperature column is missing
     with pytest.raises(SchemaError):
-        ModelSoil(
-            single_circuit_env,
-            cast(DataFrame[ScenarioSchemaSoil], scenario_constant.drop("ambient_temperature", axis=1)),
-        )
+        ModelSoil(single_circuit_env).run(scenario_constant.drop("ambient_temperature", axis=1))
 
     # check whether error is raised if circuit load column is missing
     with pytest.raises(ValueError):
-        ModelSoil(single_circuit_env, cast(DataFrame[ScenarioSchemaSoil], scenario_constant.drop("load_c1", axis=1)))
+        ModelSoil(single_circuit_env).run(scenario_constant.drop("load_c1", axis=1))
 
     # check whether error is raised if circuit load column is misspelled
     with pytest.raises(ValueError):
         misspelled_column_scenario = scenario_constant.copy()
         misspelled_column_scenario.columns = ["ambient_temprature", "load_c2"]  # type: ignore[assignment]
-        ModelSoil(single_circuit_env, cast(DataFrame[ScenarioSchemaSoil], misspelled_column_scenario))
+        ModelSoil(single_circuit_env).run(misspelled_column_scenario)
 
     # check whether error is raised if there are missing values
     with pytest.raises(SchemaError):
         missing_value_scenario = scenario_constant.copy()
         missing_value_scenario.iloc[4, 1] = np.nan  # set a random value to NaN
-        ModelSoil(single_circuit_env, cast(DataFrame[ScenarioSchemaSoil], missing_value_scenario))
+        ModelSoil(single_circuit_env).run(missing_value_scenario)
 
 
 @pytest.mark.parametrize(
@@ -102,15 +97,15 @@ def test_model_steady_state_linear_circuit(
         },
     )
 
-    model = ModelSoil(env, ScenarioSchemaSoil.validate(scenario))
-    result = model.run(run_options={"neglect_dielectric_loss": True}).result
+    model = ModelSoil(env)
+    result = model.run(scenario, run_options={"neglect_dielectric_loss": True}).result
     # take steady state temperature of the conductor
     for vca_temp, pos in zip(expected_temperatures, ["left", "center", "right"], strict=True):
         ctm_temp = result[("c", f"linear_{pos}")].Conductor.iloc[-1]
         assert np.isclose(vca_temp, ctm_temp, atol=max_absolute_temperature_error)
 
 
-def test_model_validate_steady_state(scenario_steady_state: DataFrame[ScenarioSchemaSoil]):
+def test_model_validate_steady_state(scenario_steady_state: pd.DataFrame):
     """Test whether the steady state solution matches the heat generation at different radii."""
     env = StaticEnvSoil()
     load = 575.0
@@ -125,12 +120,12 @@ def test_model_validate_steady_state(scenario_steady_state: DataFrame[ScenarioSc
     )
     scenario_steady_state["load_c1"] = load
 
-    model = ModelSoil(env, scenario_steady_state)
-    steady_state = model.run().state
+    model = ModelSoil(env)
+    steady_state = model.run(scenario_steady_state).state
 
     # Select a cable from the circuit
-    cable_key = next(iter(model.cables_with_soil.keys()))
-    cable = model.cables_with_soil[cable_key].cable
+    cable_key = next(iter(model.cables_in_environment.keys()))
+    cable = model.cables_in_environment[cable_key].cable
     steady_state_solution = steady_state.self_heating_contribution[cable_key]
     steady_state_full_solution = steady_state.temperature[cable_key]
 
@@ -219,8 +214,8 @@ def test_model_steady_state_vca(
             "soil_thermal_capacity": 2e6,
         },
     )
-    model = ModelSoil(elst_five_static_env, ScenarioSchemaSoil.validate(sdf))
-    solution = model.run()
+    model = ModelSoil(elst_five_static_env)
+    solution = model.run(sdf)
 
     # 'trefoil_right' is the hottest cable in circuit 'ELT2.24', since it is
     # closest to circuit 'ELT2.26'. The vca_conductor_temperatures are the
@@ -298,13 +293,14 @@ def test_model_steady_state_pipes_vca(
     scenario["soil_thermal_resistivity"] = rho
 
     # Use the model
-    model = ModelSoil(static_env, ScenarioSchemaSoil.validate(scenario))
+    model = ModelSoil(static_env)
     solution = model.run(
+        scenario,
         run_options=ModelSoilRunOptions(
             ac_current=True,
             temperature_dependent_electric_resistance=True,
             soil_drying=False,
-        )
+        ),
     )
 
     # 'trefoil_right' is the hottest cable in circuit 'ELT2.24', since it is closest to circuit 'ELT2.26'. The
@@ -335,20 +331,18 @@ def test_model_soil_thermal_resistivity_series(single_circuit_env: StaticEnvSoil
     )
     daily_sine_seconds = datetime_index.total_seconds() / (3600 * 24) * 2 * np.pi
     scenario["load_c1"] = 500 + 200 * np.sin(daily_sine_seconds)
-    scenario = ScenarioSchemaSoil.validate(scenario)
-
     # Taking a static soil resistivity
-    model = ModelSoil(static_env, scenario)
+    model = ModelSoil(static_env)
 
-    solution = model.run()
+    solution = model.run(scenario)
 
     # Set the soil thermal resistivity in this scenario
     # Create a dynamic soil thermal resistivity series starting at 0.75,
     # peaking at 2.0 midway, and going back to 0.75 within 7 days
     scenario["soil_thermal_resistivity"] = 0.75 + 1.25 * np.sin(daily_sine_seconds / 14)
 
-    model_dynamic_soil_thermal_resistivity = ModelSoil(static_env, scenario)
-    solution_dynamic_soil_thermal_resistivity = model_dynamic_soil_thermal_resistivity.run()
+    model_dynamic_soil_thermal_resistivity = ModelSoil(static_env)
+    solution_dynamic_soil_thermal_resistivity = model_dynamic_soil_thermal_resistivity.run(scenario)
 
     # Take the resulting temperatures
     conductor_temperature_base = solution.result[("c1", "trefoil_top")].Conductor
@@ -369,11 +363,12 @@ def test_model_soil_thermal_resistivity_series(single_circuit_env: StaticEnvSoil
 
 def test_run_model_soil_with_measurement_points(
     model_with_measurement_points: tuple[ModelSoil, MeasurementPointKey, MeasurementPointKey],
+    scenario_constant: pd.DataFrame,
 ):
     """Test running the model with measurement points."""
     # Run the model
     model, key1, key2 = model_with_measurement_points
-    temperature_result = model.run().result
+    temperature_result = model.run(scenario_constant).result
 
     # Check that the result contains the measurement point keys
     assert key1 in temperature_result.columns
@@ -384,7 +379,7 @@ def test_run_model_soil_with_measurement_points(
     assert not temperature_result[key2].empty
 
     # Check that the values exceed the ambient temperature except for the first time step
-    ambient_temperature = model.scenario.ambient_temperature.iloc[0]
+    ambient_temperature = scenario_constant.ambient_temperature.iloc[0]
     assert temperature_result[key1].iloc[0] == ambient_temperature
     assert temperature_result[key2].iloc[0] == ambient_temperature
     assert (temperature_result[key1].iloc[1:] > ambient_temperature).all()
@@ -403,7 +398,7 @@ def test_run_model_soil_with_measurement_points(
 @pytest.mark.parametrize("neglect_dielectric_loss", [True, False])
 def test_compute_temperature_solution(
     cable_id: str,
-    scenario_constant: DataFrame[ScenarioSchemaSoil],
+    scenario_constant: pd.DataFrame,
     temperature_dependent_electric_resistance: bool,
     soil_drying: bool,
     ac_current: bool,
@@ -422,7 +417,7 @@ def test_compute_temperature_solution(
         )
     )
 
-    model = ModelSoil(static_env, scenario_constant)
+    model = ModelSoil(static_env)
     model.run_options = ModelSoilRunOptions(
         temperature_dependent_electric_resistance=temperature_dependent_electric_resistance,
         soil_drying=soil_drying,
@@ -431,9 +426,9 @@ def test_compute_temperature_solution(
     )
 
     # Fill the initial state variable with either the state or None depending on what we are testing.
-    initial_state_val = model._compute_temperature_solution().state if initial_state is True else None
+    initial_state_val = model._compute_temperature_solution(scenario_constant).state if initial_state is True else None
 
-    result = model._compute_temperature_solution(initial_state=initial_state_val)
+    result = model._compute_temperature_solution(scenario_constant, initial_state=initial_state_val)
 
     # Loop over the cable results (e.g. cable_key could be "(c1, trefoil_top)"")
     for column in result.result.columns.droplevel(2).unique():
@@ -468,22 +463,23 @@ def test_compute_temperature_solution(
         pd.testing.assert_frame_equal(actual_df.reset_index(drop=True), expected_df.reset_index(drop=True))
 
 
-def test_initializing_thermal_state(model: ModelSoil):
+def test_initializing_thermal_state(model: ModelSoil, scenario_constant: pd.DataFrame):
     # Check whether the thermal state components have the correct sizes.
-    initial_state = model._build_initial_state()
+    model.run(scenario_constant)
+    initial_state = model._build_initial_state(scenario_constant["ambient_temperature"].iloc[0])
 
     self_heating_state = initial_state.self_heating_contribution
     temperature_state = initial_state.temperature
     mutual_heating_state = initial_state.mutual_heating_contribution
 
-    cable_count = len(model.cables_with_soil)
+    cable_count = len(model._cables_with_soil)
     assert len(self_heating_state) == cable_count
     assert len(mutual_heating_state) == cable_count
     assert len(temperature_state) == cable_count
 
-    for cable_key in model.cables_with_soil:
-        assert self_heating_state[cable_key].size == model.cables_with_soil[cable_key].cable._radii_grid.size
-        assert temperature_state[cable_key].size == model.cables[cable_key].cable._radii_grid.size
+    for cable_key in model._cables_with_soil:
+        assert self_heating_state[cable_key].size == model._cables_with_soil[cable_key].cable._radii_grid.size
+        assert temperature_state[cable_key].size == model._cables[cable_key].cable._radii_grid.size
         assert mutual_heating_state[cable_key].size == temperature_state[cable_key].size
 
 
@@ -495,6 +491,7 @@ def test_initializing_thermal_state(model: ModelSoil):
 @pytest.mark.parametrize("expected_temperature_state", [(10.0 + 5.0 + 2.0) * np.ones(3)])
 def test_update_thermal_state(
     model: ModelSoil,
+    scenario_constant: pd.DataFrame,
     time_idx: int,
     self_heating_state: np.ndarray,
     mutual_heating_state: np.ndarray,
@@ -503,15 +500,16 @@ def test_update_thermal_state(
     expected_temperature_state: np.ndarray,
 ):
     """Simple test to check if all cable states are updated correctly in one call."""
-    self_heating_state_map = {cable_key: self_heating_state.copy() for cable_key in model.cables_with_soil}
-    mutual_heating_state_map = {cable_key: mutual_heating_state.copy() for cable_key in model.cables}
+    model.run(scenario_constant)
+    self_heating_state_map = {cable_key: self_heating_state.copy() for cable_key in model._cables_with_soil}
+    mutual_heating_state_map = {cable_key: mutual_heating_state.copy() for cable_key in model._cables}
 
     current_state = StateSoil(
         static_env_hash=model.static_env.compute_hash(),
-        temperature={cable_key: np.zeros_like(mutual_heating_state_map[cable_key]) for cable_key in model.cables},
+        temperature={cable_key: np.zeros_like(mutual_heating_state_map[cable_key]) for cable_key in model._cables},
         self_heating_contribution=self_heating_state_map,
         mutual_heating_contribution=mutual_heating_state_map,
-        ambient_temperature=model.scenario["ambient_temperature"].iloc[time_idx],
+        ambient_temperature=scenario_constant["ambient_temperature"].iloc[time_idx],
     )
 
     model._update_self_heating_contribution = mock.Mock(return_value=self_heating_state_map)
@@ -520,54 +518,30 @@ def test_update_thermal_state(
     state = model._update_state(
         state=current_state,
         time_step=1.0,
-        ambient_temperature=model.scenario["ambient_temperature"].iloc[time_idx],
+        ambient_temperature=scenario_constant["ambient_temperature"].iloc[time_idx],
     )
 
-    for cable_key in model.cables:
+    for cable_key in model._cables:
         assert np.array_equal(state.self_heating_contribution[cable_key], expected_self_heating_state)
         assert np.array_equal(state.mutual_heating_contribution[cable_key], expected_mutual_heating_state)
         assert np.array_equal(state.temperature[cable_key], expected_temperature_state)
 
 
-def test_get_vector_cables_returns_cables_with_soil(model: ModelSoil):
+def test_get_vector_cables_returns_cables_with_soil(model: ModelSoil, scenario_constant: pd.DataFrame):
     """Test that _get_vector_cables returns the soil-extended cable mapping."""
-    assert model._cables_for_heat_vectors is model.cables_with_soil
-
-
-@pytest.mark.parametrize(
-    "seconds_since_start,last_update_day,expected_due,expected_day",
-    [
-        (0.0, 0, False, 0),
-        (24 * 60 * 60, 0, True, 1),
-        (24 * 60 * 60, 1, False, 1),
-        (2.9 * 24 * 60 * 60, 1, True, 2),
-    ],
-)
-def test_check_if_daily_update_due(
-    model: ModelSoil,
-    seconds_since_start: float,
-    last_update_day: int,
-    expected_due: bool,
-    expected_day: int,
-):
-    """Test daily-update decision logic around boundaries and multi-day jumps."""
-    is_due, updated_day = model._check_if_daily_update_due(
-        seconds_since_start_scenario=seconds_since_start,
-        last_soil_property_update_day=last_update_day,
-    )
-
-    assert is_due is expected_due
-    assert updated_day == expected_day
+    model.run(scenario_constant)
+    assert model.cables_in_environment is model._cables_with_soil
 
 
-def test_update_soil_properties_for_all_cables_calls_each_cable(model: ModelSoil):
+def test_update_soil_properties_for_all_cables_calls_each_cable(model: ModelSoil, scenario_constant: pd.DataFrame):
     """Test whether soil property update is forwarded to every soil-extended cable."""
+    model.run(scenario_constant)
     temperature_state = {
-        cable_key: np.ones(pos_cable.cable._radii_grid.size) for cable_key, pos_cable in model.cables_with_soil.items()
+        cable_key: np.ones(pos_cable.cable._radii_grid.size) for cable_key, pos_cable in model._cables_with_soil.items()
     }
 
     update_mocks = {}
-    for pos_cable in model.cables_with_soil.values():
+    for pos_cable in model._cables_with_soil.values():
         update_mock = mock.Mock()
         pos_cable.cable.update_soil_properties = update_mock
         update_mocks[pos_cable.key] = update_mock
@@ -579,7 +553,7 @@ def test_update_soil_properties_for_all_cables_calls_each_cable(model: ModelSoil
         soil_capacity=2.5e6,
     )
 
-    for cable_key in model.cables_with_soil:
+    for cable_key in model._cables_with_soil:
         update_mocks[cable_key].assert_called_once_with(
             soil_rho=1.6,
             soil_c=2.5e6,
@@ -588,48 +562,6 @@ def test_update_soil_properties_for_all_cables_calls_each_cable(model: ModelSoil
         )
 
 
-@pytest.mark.parametrize("daily_update_due", [False, True])
-def test_update_thermal_properties_if_needed_conditional_soil_update(model: ModelSoil, daily_update_due: bool):
-    """Test that soil-property updates are only applied when the daily-update condition is met."""
-    temperature_state = {key: np.ones_like(model.cables[key].cable._radii_grid) for key in model.cables}
-    scenario_row = model.scenario.iloc[0]
-
-    model._update_pipe_fill_resistivity = mock.Mock()
-    model._update_soil_properties_for_all_cables = mock.Mock()
-    model._check_if_daily_update_due = mock.Mock(return_value=(daily_update_due, 7))
-    model.last_soil_property_update_day = 3
-
-    model._update_thermal_properties_if_needed(
-        temperature_state=temperature_state,
-        scenario_row=scenario_row,
-        elapsed_seconds=12.0,
-    )
-
-    assert model._update_pipe_fill_resistivity.call_count == 2
-    first_call = model._update_pipe_fill_resistivity.call_args_list[0]
-    second_call = model._update_pipe_fill_resistivity.call_args_list[1]
-    assert first_call.kwargs["temperature_state"] is temperature_state
-    assert second_call.kwargs["temperature_state"] is temperature_state
-    assert first_call.kwargs["cables"] is model.cables
-    assert second_call.kwargs["cables"] is model.cables_with_soil
-
-    model._check_if_daily_update_due.assert_called_once_with(
-        seconds_since_start_scenario=12.0,
-        last_soil_property_update_day=3,
-    )
-    assert model.last_soil_property_update_day == 7
-
-    if daily_update_due:
-        model._update_soil_properties_for_all_cables.assert_called_once_with(
-            soil_drying=model.run_options.soil_drying,
-            temperature_state=temperature_state,
-            soil_resistivity=scenario_row["soil_thermal_resistivity"],
-            soil_capacity=scenario_row["soil_thermal_capacity"],
-        )
-    else:
-        model._update_soil_properties_for_all_cables.assert_not_called()
-
-
 @pytest.mark.parametrize(
     "circuit_fix,scenario_fix,has_pipe,expected_number_of_cables",
     [
@@ -645,14 +577,14 @@ def test_initialize_cables(
     """Test the cable initialization in the model to refer to if all params are set correctly."""
     circuit = request.getfixturevalue(circuit_fix)
     scenario = request.getfixturevalue(scenario_fix)
-    model = ModelSoil(circuit, scenario)
-    assert model.number_of_cables == expected_number_of_cables
-    assert model.cables is not None
-    assert len(model.cables) == expected_number_of_cables
-    assert model.cables_with_soil is not None
-    assert len(model.cables_with_soil) == expected_number_of_cables
-    assert model.mirror_cables_with_soil is not None
-    assert len(model.mirror_cables_with_soil) == expected_number_of_cables
+    model = ModelSoil(circuit)
+    model.run(scenario)
+    assert model._cables is not None
+    assert len(model._cables) == expected_number_of_cables
+    assert model._cables_with_soil is not None
+    assert len(model._cables_with_soil) == expected_number_of_cables
+    assert model._mirror_cables_with_soil is not None
+    assert len(model._mirror_cables_with_soil) == expected_number_of_cables
 
 
 def test_non_uniform_scenario(single_circuit_env: StaticEnvSoil):
@@ -669,21 +601,21 @@ def test_non_uniform_scenario(single_circuit_env: StaticEnvSoil):
         "soil_thermal_capacity": 2e6,
     }
     uniform_index = pd.timedelta_range("0 min", "40 min", freq="10 min")
-    uniform_scenario = ScenarioSchemaSoil.validate(pd.DataFrame(index=uniform_index, data=data))
+    uniform_scenario = pd.DataFrame(index=uniform_index, data=data)
 
     # create scenario where length of time steps decreases during scenario, shortening the duration of the scenario.
     # the final temperature should be lower
     longer_non_uniform_index = pd.timedelta_range("0 min", "20 min", freq="10 min").append(
         pd.timedelta_range("25 min", "30 min", freq="5 min")
     )
-    longer_scenario = ScenarioSchemaSoil.validate(pd.DataFrame(index=longer_non_uniform_index, data=data))
+    longer_scenario = pd.DataFrame(index=longer_non_uniform_index, data=data)
 
     # create scenario where length of time steps decreases during scenario, keeping the time of the scenario equal.
     # the final temperature should be higher
     same_length_non_uniform_index = pd.timedelta_range("0 min", "20 min", freq="10 min").append(
         pd.timedelta_range("25 min", "40 min", freq="5 min")
     )
-    same_length_scenario = ScenarioSchemaSoil.validate(pd.DataFrame(index=same_length_non_uniform_index, data=data))
+    same_length_scenario = pd.DataFrame(index=same_length_non_uniform_index, data=data)
 
     # compute temperatures using both all three scenarios then compare
     temps = {}
@@ -692,28 +624,91 @@ def test_non_uniform_scenario(single_circuit_env: StaticEnvSoil):
         ("non_uniform_longer", longer_scenario),
         ("non_uniform_equal", same_length_scenario),
     ]:
-        model = ModelSoil(single_circuit_env, scenario)
-        temps[name] = model.run().result[("c1", "trefoil_left")]["Conductor"].iloc[-1]
+        model = ModelSoil(single_circuit_env)
+        temps[name] = model.run(scenario).result[("c1", "trefoil_left")]["Conductor"].iloc[-1]
     assert temps["uniform"] < temps["non_uniform_equal"]
 
 
-def test_add_extra_solution_layer(model: ModelSoil):
-    """Test if solution layer is added and is found in the solution of the model."""
-    model.add_solution_location(CableLayer.Insulation)
-    assert CableLayer.Insulation in model.extra_solution_layers
-    solution = model.run()
+def test_reusing_model_for_short_scenarios_matches_single_long_scenario_dynamic_soil_resistivity(
+    single_circuit_env: StaticEnvSoil,
+):
+    """Check that chained short runs match one long run when soil resistivity varies over time.
+
+    Soil thermal capacity is kept constant in all scenarios.
+    """
+    soil_thermal_capacity = 2e6
+    long_index = pd.timedelta_range("0 h", "144 h", freq="24 h")
+
+    long_scenario = pd.DataFrame(
+        index=long_index,
+        data={
+            "ambient_temperature": [10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0],
+            "load_c1": [350.0, 450.0, 550.0, 650.0, 600.0, 500.0, 400.0],
+            "soil_thermal_resistivity": [0.75, 0.8, 0.9, 1.0, 1.05, 1.1, 1.15],
+            "soil_thermal_capacity": soil_thermal_capacity,
+        },
+    )
+
+    split_idx = 3  # split the scenario into two parts, first part has 4 time steps, second part has 3 time steps
+    first_short_scenario = long_scenario.iloc[: split_idx + 1].copy()
+    second_short_scenario = long_scenario.iloc[split_idx:].copy()
+
+    long_output = ModelSoil(single_circuit_env).run(long_scenario)
+
+    reused_model = ModelSoil(single_circuit_env)
+    first_output = reused_model.run(first_short_scenario)
+    second_output = reused_model.run(second_short_scenario, initial_state=first_output.state)
+
+    reused_result = pd.concat([first_output.result.copy(), second_output.result.iloc[1:].copy()])
+
+    pd.testing.assert_frame_equal(reused_result, long_output.result, rtol=1e-10, atol=1e-10)
+
+    for cable_key in long_output.state.temperature:
+        np.testing.assert_allclose(
+            second_output.state.temperature[cable_key],
+            long_output.state.temperature[cable_key],
+            rtol=1e-10,
+            atol=1e-10,
+        )
+        np.testing.assert_allclose(
+            second_output.state.self_heating_contribution[cable_key],
+            long_output.state.self_heating_contribution[cable_key],
+            rtol=1e-10,
+            atol=1e-10,
+        )
+        np.testing.assert_allclose(
+            second_output.state.mutual_heating_contribution[cable_key],
+            long_output.state.mutual_heating_contribution[cable_key],
+            rtol=1e-10,
+            atol=1e-10,
+        )
+
+
+def test_add_extra_solution_layer(model: ModelSoil, scenario_constant: pd.DataFrame):
+    """Test if an extra solution layer can be requested for a single model run."""
+    solution = model.run(scenario_constant, run_options={"extra_solution_layers": [CableLayer.Insulation]})
     assert CableLayer.Insulation in solution.result[("c1", "trefoil_left")].columns
 
 
+def test_extra_solution_layers_do_not_persist_between_runs(model: ModelSoil, scenario_constant: pd.DataFrame):
+    """Ensure extra solution layers affect only the run that explicitly requests them."""
+    first_solution = model.run(scenario_constant, run_options={"extra_solution_layers": [CableLayer.Insulation]})
+    second_solution = model.run(scenario_constant)
+
+    assert CableLayer.Insulation in first_solution.result[("c1", "trefoil_left")].columns
+    assert CableLayer.Insulation not in second_solution.result[("c1", "trefoil_left")].columns
+
+
 def test_compare_multiple_configs(
     model: Model,
     model_single_config: Model,
     model_multiple_configs: Model,
+    scenario_constant: pd.DataFrame,
 ):
     """Test if solution layer is added and is found in the solution of the model."""
-    solution = model.run().result[("c1", "trefoil_right")]
-    solution_single_config = model_single_config.run().result[("c1", "trefoil_right")]
-    solution_multiple_configs = model_multiple_configs.run().result[("c1", "trefoil_right")]
+    solution = model.run(scenario_constant).result[("c1", "trefoil_right")]
+    solution_single_config = model_single_config.run(scenario_constant).result[("c1", "trefoil_right")]
+    solution_multiple_configs = model_multiple_configs.run(scenario_constant).result[("c1", "trefoil_right")]
 
     assert isinstance(solution, pd.DataFrame)
     assert isinstance(solution_single_config, pd.DataFrame)
@@ -933,10 +928,11 @@ def check_function(cable: Cable):
 def test_statesoil_validate_mutual_heating_solutions(single_circuit_env, scenario_constant):
     """Test the validate_mutual_heating_solutions validator."""
     # Create an ModelSoil to get real cable representations
-    model = ModelSoil(single_circuit_env, scenario_constant)
+    model = ModelSoil(single_circuit_env)
+    model.run(scenario_constant)
 
     # Get cable keys from the model.
-    cable_keys = list(model.cables.keys())
+    cable_keys = list(model._cables.keys())
 
     # Create valid mutual heating solutions
     valid_mutual_heating_solutions = {key: np.array([1.0, 2.0, 3.0]) for key in cable_keys}
@@ -983,17 +979,7 @@ def test_model_soil_validate_state(three_core_cable_xlpe):
         )
     )
 
-    scenario = pd.DataFrame(
-        index=pd.timedelta_range("0 days", "1 hour", periods=2),
-        data={
-            "ambient_temperature": 30,
-            "load_test_circuit": 100.0,
-            "soil_thermal_resistivity": 1.0,
-            "soil_thermal_capacity": 2.0e6,
-        },
-    )
-
-    model = ModelSoil(env, ScenarioSchemaSoil.validate(scenario))
+    model = ModelSoil(env)
 
     # Test 1: state=None should pass
     model._validate_initial_state(None)
@@ -1073,7 +1059,7 @@ def test_cable_without_screen(simple_cable: CableSoil):
         },
     )
 
-    solution = ModelSoil(static_env, ScenarioSchemaSoil.validate(scenario)).run()
+    solution = ModelSoil(static_env).run(scenario)
     assert isinstance(solution, ModelOutputSchema)
 
 
@@ -1086,7 +1072,4 @@ def test_use_wrong_static_env_type():
             "environment in soil. Please use ModelAir instead."
         ),
     ):
-        ModelSoil(
-            static_env=cast(StaticEnvSoil, StaticEnvAir()),
-            scenario=cast(DataFrame[ScenarioSchemaSoil], pd.DataFrame()),
-        )
+        ModelSoil(static_env=cast(StaticEnvSoil, StaticEnvAir()))
diff --git a/tests/model/test_pipes.py b/tests/model/test_pipes.py
index 62e2165..537d47e 100644
--- a/tests/model/test_pipes.py
+++ b/tests/model/test_pipes.py
@@ -3,8 +3,8 @@
 # SPDX-License-Identifier: MPL-2.0
 
 import numpy as np
+import pandas as pd
 import pytest
-from pandera.typing import DataFrame
 
 from cable_thermal_model import CircuitType
 from cable_thermal_model.cable.cable_circuit import (
@@ -23,12 +23,11 @@
 from cable_thermal_model.model.cables.cable_air import CableAir
 from cable_thermal_model.model.cables.enum_classes_cable import CableLayer, PipeFillType
 from cable_thermal_model.model.model_factory import ModelFactory
-from cable_thermal_model.model.schemas.model_input_schemas import ScenarioSchemaAir, ScenarioSchemaSoil
 from cable_thermal_model.validation.cable_analysis import CableAnalysis
 from tests.conftest import vca_pipe_results
 
 
-def test_trefoil_in_single_pipe_heat_flow(scenario_steady_state: DataFrame[ScenarioSchemaSoil]):
+def test_trefoil_in_single_pipe_heat_flow(scenario_steady_state: pd.DataFrame):
     """Test that a trefoil cable in a single pipe in soil behaves as expected."""
     load = 575.0
 
@@ -50,12 +49,12 @@ def test_trefoil_in_single_pipe_heat_flow(scenario_steady_state: DataFrame[Scena
     scenario_steady_state["load_c1"] = load
 
     # Compute the steady state solution
-    model = ModelFactory.create_model(static_env, scenario_steady_state)
-    steady_state = model.run().state
+    model = ModelFactory.create_model(static_env)
+    steady_state = model.run(scenario_steady_state).state
 
     # Select a cable from the circuit
-    cable_key = list(model.cables_with_soil.keys())[0]
-    cable = model.cables_with_soil[cable_key].cable
+    cable_key = list(model.cables_in_environment.keys())[0]
+    cable = model.cables_in_environment[cable_key].cable
     steady_state_solution = steady_state.self_heating_contribution[cable_key]
     steady_state_full_solution = steady_state.temperature[cable_key]
 
@@ -93,7 +92,7 @@ def test_trefoil_in_single_pipe_heat_flow(scenario_steady_state: DataFrame[Scena
     )
 
 
-def test_trefoil_in_single_pipe_in_air_compare_to_soil(scenario_steady_state: DataFrame[ScenarioSchemaSoil]):
+def test_trefoil_in_single_pipe_in_air_compare_to_soil(scenario_steady_state: pd.DataFrame):
     """Compare trefoil circuits in single pipes in air and soil.
 
     When we ignore the effect of temperature-dependent resistance, the heat flow at the cable boundary should be
@@ -133,19 +132,19 @@ def test_trefoil_in_single_pipe_in_air_compare_to_soil(scenario_steady_state: Da
     run_options = {"temperature_dependent_electric_resistance": False}
 
     # Compute the steady state solution for both environments
-    model_soil = ModelFactory.create_model(static_env_soil, scenario_steady_state)
-    steady_state_soil = model_soil.run(run_options=run_options).state
+    model_soil = ModelFactory.create_model(static_env_soil)
+    steady_state_soil = model_soil.run(scenario_steady_state, run_options=run_options).state
 
-    model_air = ModelFactory.create_model(static_env_air, ScenarioSchemaAir.validate(scenario_steady_state))
-    steady_state_air = model_air.run(run_options=run_options).state
+    model_air = ModelFactory.create_model(static_env_air)
+    steady_state_air = model_air.run(scenario_steady_state, run_options=run_options).state
 
     # Select the single cable from both circuits and collect their steady state solutions
     cable_key = CableKey(circuit_name="c1", cable_position=CablePosition.TrefoilCircuitInSinglePipe)
 
-    cable_soil = model_soil.cables_with_soil[cable_key].cable
+    cable_soil = model_soil.cables_in_environment[cable_key].cable
     steady_state_solution_soil = steady_state_soil.self_heating_contribution[cable_key]
 
-    cable_air = model_air.cables[cable_key].cable
+    cable_air = model_air.cables_in_environment[cable_key].cable
     steady_state_solution_air = steady_state_air.self_heating_contribution[cable_key]
     analysis_soil = CableAnalysis(cable=cable_soil, solution=steady_state_solution_soil)
     analysis_air = CableAnalysis(cable=cable_air, solution=steady_state_solution_air)
@@ -161,7 +160,7 @@ def test_trefoil_in_single_pipe_in_air_compare_to_soil(scenario_steady_state: Da
     assert np.isclose(heat_flow_soil, heat_flow_air, atol=0.1)
 
 
-def test_trefoil_in_single_pipe_in_air_heat_flow(scenario_steady_state: DataFrame[ScenarioSchemaSoil]):
+def test_trefoil_in_single_pipe_in_air_heat_flow(scenario_steady_state: pd.DataFrame):
     """Test that a trefoil cable in a single pipe in air behaves as expected."""
     load = 575.0
 
@@ -181,12 +180,12 @@ def test_trefoil_in_single_pipe_in_air_heat_flow(scenario_steady_state: DataFram
     scenario_steady_state["load_c1"] = load
 
     # Compute the steady state solution
-    model = ModelFactory.create_model(static_env, ScenarioSchemaAir.validate(scenario_steady_state))
-    steady_state = model.run().state
+    model = ModelFactory.create_model(static_env)
+    steady_state = model.run(scenario_steady_state).state
 
     # Select a cable from the circuit
     cable_key = CableKey(circuit_name="c1", cable_position=CablePosition.TrefoilCircuitInSinglePipe)
-    cable = model.cables[cable_key].cable
+    cable = model.cables_in_environment[cable_key].cable
     steady_state_solution = steady_state.self_heating_contribution[cable_key]
     steady_state_full_solution = steady_state.temperature[cable_key]
 
@@ -224,7 +223,7 @@ def test_trefoil_in_single_pipe_in_air_heat_flow(scenario_steady_state: DataFram
     )
 
 
-def test_trefoil_in_single_pipe_in_air_norm(scenario_steady_state: DataFrame[ScenarioSchemaSoil]):
+def test_trefoil_in_single_pipe_in_air_norm(scenario_steady_state: pd.DataFrame):
     """Test that a trefoil cable in a single pipe in air behaves as expected under standard operation."""
     load = 575.0
     pipe_input_schema = PipeInputSchema(
@@ -245,12 +244,12 @@ def test_trefoil_in_single_pipe_in_air_norm(scenario_steady_state: DataFrame[Sce
     scenario_steady_state["load_c1"] = load
 
     # Compute the steady state solution
-    model = ModelFactory.create_model(static_env, ScenarioSchemaAir.validate(scenario_steady_state))
-    steady_state = model.run().state
+    model = ModelFactory.create_model(static_env)
+    steady_state = model.run(scenario_steady_state).state
 
     # Select a cable from the circuit
-    cable_key = list(model.cables.keys())[0]
-    cable = model.cables[cable_key].cable
+    cable_key = list(model.cables_in_environment.keys())[0]
+    cable = model.cables_in_environment[cable_key].cable
     assert isinstance(cable, CableAir)
     assert cable.convection_coefficient is not None
     steady_state_solution = steady_state.self_heating_contribution[cable_key]
@@ -307,7 +306,7 @@ def test_trefoil_in_single_pipe_in_air_norm(scenario_steady_state: DataFrame[Sce
     ],
 )
 def test_pipe_b5901_cases(
-    b5901_scenario_steady_state: DataFrame[ScenarioSchemaSoil],
+    b5901_scenario_steady_state: pd.DataFrame,
     max_absolute_temperature_error: float,
     cable_id: str,
     pipe_outer_radius: float,
@@ -341,9 +340,9 @@ def test_pipe_b5901_cases(
 
     # Compute the steady state solution
     b5901_scenario_steady_state["load_c1"] = load
-    model = ModelFactory.create_model(environment, b5901_scenario_steady_state)
+    model = ModelFactory.create_model(environment)
 
-    temperature_solution = model.run().result[("c1", cable_position)]
+    temperature_solution = model.run(b5901_scenario_steady_state).result[("c1", cable_position)]
     steady_state_temperatures = temperature_solution.iloc[-1]
 
     # Check that the temperatures match the VCA results
@@ -358,7 +357,7 @@ def test_pipe_b5901_cases(
     vca_pipe_results(),
 )
 def test_pipe_model_steady_state_vca(
-    b5901_scenario_steady_state: DataFrame[ScenarioSchemaSoil],
+    b5901_scenario_steady_state: pd.DataFrame,
     cable_id: str,
     pipe_outer_radius: float,
     sdr: float,
@@ -387,8 +386,8 @@ def test_pipe_model_steady_state_vca(
         CablePosition.Single if isinstance(environment.circuits["c1"], SingleCable) else CablePosition.TrefoilLeft
     )
 
-    model = ModelFactory.create_model(environment, b5901_scenario_steady_state)
-    temperature_solution = model.run().result[("c1", cable_position.value)]
+    model = ModelFactory.create_model(environment)
+    temperature_solution = model.run(b5901_scenario_steady_state).result[("c1", cable_position.value)]
     steady_state_temperatures = temperature_solution.iloc[-1]
 
     # Check that the temperatures match the VCA results
@@ -399,7 +398,7 @@ def test_pipe_model_steady_state_vca(
 
 
 def test_two_trefoil_circuits_in_single_pipes_vca(
-    b5901_scenario_steady_state: DataFrame[ScenarioSchemaSoil], max_absolute_temperature_error: float
+    b5901_scenario_steady_state: pd.DataFrame, max_absolute_temperature_error: float
 ):
     load = 575.0
 
@@ -435,8 +434,8 @@ def test_two_trefoil_circuits_in_single_pipes_vca(
     b5901_scenario_steady_state["load_c2"] = load
 
     # Compute the steady state solution
-    model = ModelFactory.create_model(static_env, b5901_scenario_steady_state)
-    result = model.run().result
+    model = ModelFactory.create_model(static_env)
+    result = model.run(b5901_scenario_steady_state).result
 
     conductor_temperature_1 = result[("c1", CablePosition.TrefoilCircuitInSinglePipe)]["Conductor"].iloc[-1]
     conductor_temperature_2 = result[("c2", CablePosition.TrefoilCircuitInSinglePipe)]["Conductor"].iloc[-1]