Adding test coverage + heat equation tests

Author: chemardes

.github/workflows/ci.yml

@@ -14,6 +14,6 @@ jobs:
         with:
           python-version: '3.13'
           architecture: 'x64'
-      - name: Run Script
+      - name: Run python tests
         run: |
-          bash ./ci/script.sh
+          bash ./ci/run_python_tests.sh

.gitignore

@@ -16,3 +16,4 @@
 
 # Other files
 *.log
+/.coverage

ci/script.sh ci/run_python_tests.sh

@@ -11,4 +11,4 @@ source venv/bin/activate
 
 pip install -r requirements.txt
 
-pytest
+pytest --cov=pdesolvers pdesolvers/tests/

pdesolvers/pdes/heat_1d.py

@@ -38,22 +38,20 @@ def __check_conditions(self):
 
         if self.__left_boundary_temp is not None:
             err = np.abs(self.__left_boundary_temp(0) - self.__initial_temp(0))
-            assert err < 1e-12
+            assert err < 1e-12, f"Left boundary condition at t=0 does not match the initial condition."
 
         if self.__right_boundary_temp is not None:
-            err = np.abs(self.__right_boundary_temp(0) - self.__initial_temp(0))
-            assert err < 1e-12
+            err = np.abs(self.__right_boundary_temp(0) - self.__initial_temp(self.__length))
+            assert err < 1e-12, f"Right boundary condition at t=0 does not match the initial condition."
 
     @staticmethod
     def __validate_callable(func):
         if not callable(func):
             raise ValueError("Temperature conditions must be a callable function")
 
-    def generate_x_grid(self):
-        return np.linspace(0, self.__length, self.__x_nodes)
-
-    def generate_t_grid(self):
-        return np.linspace(0, self.__time, self.__t_nodes)
+    @staticmethod
+    def generate_grid(value, nodes):
+        return np.linspace(0, value, nodes)
 
     @property
     def length(self):

pdesolvers/solvers/black_scholes_solvers.py

@@ -24,9 +24,8 @@ def solve(self):
         if self.equation.t_nodes is None:
             dt = 0.9 * dt_max
             self.equation.t_nodes = int(self.equation.expiry/dt)
-            dt = self.equation.expiry / self.equation.t_nodes # to ensure that the expiration time is integer time steps away
+            dt = self.equation.expiry / self.equation.t_nodes
         else:
-            # possible fix - set a check to see that user-defined value is within cfl condition
             dt = T[1] - T[0]
 
             if dt > dt_max:

pdesolvers/solvers/heat_solvers.py

@@ -16,23 +16,29 @@ def solve(self):
         :return: the solver instance with the computed temperature values
         """
 
-        x = self.equation.generate_x_grid()
-        dx = x[1] - x[0]
+        x = self.equation.generate_grid(self.equation.length, self.equation.x_nodes)
+        t = self.equation.generate_grid(self.equation.time, self.equation.t_nodes)
 
+        dx = x[1] - x[0]
         dt_max = 0.5 * (dx**2) / self.equation.k
-        dt = 0.8 * dt_max
-        time_step = int(self.equation.time/dt)
-        self.equation.t_nodes = time_step
 
-        t = np.linspace(0, self.equation.time, self.equation.t_nodes)
+        if self.equation.t_nodes is None:
+            dt = 0.8 * dt_max
+            self.equation.t_nodes = int(self.equation.time/dt)
+            dt = self.equation.time / self.equation.t_nodes
+        else:
+            dt = t[1] - t[0]
 
-        u = np.zeros((time_step, self.equation.x_nodes))
+        if dt > dt_max:
+            raise ValueError("User-defined t nodes is too small and exceeds the CFL condition. Possible action: Increase number of t nodes for stability!")
+
+        u = np.zeros((self.equation.t_nodes, self.equation.x_nodes))
 
         u[0, :] = self.equation.get_initial_temp(x)
         u[:, 0] = self.equation.get_left_boundary(t)
         u[:, -1] = self.equation.get_right_boundary(t)
 
-        for tau in range(0, time_step-1):
+        for tau in range(0, self.equation.t_nodes-1):
             for i in range(1, self.equation.x_nodes - 1):
                 u[tau+1,i] = u[tau, i] + (dt * self.equation.k * (u[tau, i-1] - 2 * u[tau, i] + u[tau, i+1]) / dx**2)
 
@@ -49,8 +55,8 @@ def solve(self):
         :return: the solver instance with the computed temperature values
         """
 
-        x = self.equation.generate_x_grid()
-        t = self.equation.generate_t_grid()
+        x = self.equation.generate_grid(self.equation.length, self.equation.x_nodes)
+        t = self.equation.generate_grid(self.equation.time, self.equation.t_nodes)
 
         dx = x[1] - x[0]
         dt = t[1] - t[0]

pdesolvers/tests/__init__.py

@@ -86,7 +86,7 @@ def test_convergence_between_interpolated_data(self):
 
         diff = np.abs(data1 - data2)
 
-        assert diff < 1e-4
+        assert np.max(diff) < 1e-4
 
 
 

pdesolvers/tests/test_black_scholes.py

@@ -0,0 +1,46 @@
+import pytest
+import numpy as np
+
+import pdesolvers.pdes.heat_1d as heat
+import pdesolvers.solvers.heat_solvers as solver
+import pdesolvers.utils.utility as utility
+
+class TestHeatSolvers:
+
+    def setup_method(self):
+        self.equation = (heat.HeatEquation(1, 100,30,10000, 0.01)
+                 .set_initial_temp(lambda x: 10 * np.sin(2 * np.pi * x) + 15)
+                 .set_left_boundary_temp(lambda t: t + 15)
+                 .set_right_boundary_temp(lambda t: 15))
+
+    def test_check_terminal_and_boundary_conditions_at_time_zero(self):
+        length = self.equation.length
+        assert abs(self.equation.get_left_boundary(0) - self.equation.get_initial_temp(0)) < 1e-12, "Left boundary condition failed"
+        assert abs(self.equation.get_right_boundary(0) - self.equation.get_initial_temp(length)) < 1e-12, "Right boundary condition failed"
+
+    # explicit method tests
+
+    def test_check_absolute_difference_between_two_results(self):
+        result1 = solver.Heat1DExplicitSolver(self.equation).solve().get_result()
+        result2 = solver.Heat1DCNSolver(self.equation).solve().get_result()
+
+        diff = result1 - result2
+
+        assert np.max(np.abs(diff)) < 1e-2
+
+    def test_convergence_between_interpolated_data(self):
+        result1 = solver.Heat1DExplicitSolver(self.equation).solve()
+        result2 = solver.Heat1DCNSolver(self.equation).solve()
+        u1 = result1.get_result()
+        u2 = result2.get_result()
+
+        data1 = utility.RBFInterpolator(u1, 0.1, 0.03).interpolate(0.2,0.9)
+        data2 = utility.RBFInterpolator(u2, 0.1, 0.03).interpolate(0.2,0.9)
+
+        diff = np.abs(data1 - data2)
+
+        assert np.max(diff) < 1e-4
+
+
+
+    # crank-nicolson method tests

pdesolvers/tests/test_heat_solvers.py

@@ -2,4 +2,5 @@ matplotlib==3.9.2
 numpy==2.1.3
 scipy==1.14.1
 pandas==2.2.3
-pytest==8.3.4
+pytest==8.3.4
+pytest-cov==6.0.0