[heidrifx] Adding tests

diffusion2d.py

@@ -38,14 +38,20 @@ def __init__(self):
         self.dt = None
 
     def initialize_domain(self, w=10., h=10., dx=0.1, dy=0.1):
+        # Assert all parameters are floats
+        assert all(isinstance(param, float) for param in [w, h, dx, dy]), "All parameters must be floats"
+
         self.w = w
         self.h = h
         self.dx = dx
         self.dy = dy
         self.nx = int(w / dx)
         self.ny = int(h / dy)
 
-    def initialize_physical_parameters(self, d=4., T_cold=300, T_hot=700):
+    def initialize_physical_parameters(self, d=4., T_cold=300., T_hot=700.):
+        # Assert all parameters are floats
+        assert all(isinstance(param, float) for param in [d, T_cold, T_hot]), "All parameters must be floats"
+
         self.D = d
         self.T_cold = T_cold
         self.T_hot = T_hot

requirements.txt

@@ -0,0 +1,3 @@
+pytest
+numpy
+matplotlib

tests/integration/test_diffusion2d.py

@@ -2,18 +2,36 @@
 Tests for functionality checks in class SolveDiffusion2D
 """
 
+import numpy as np
 from diffusion2d import SolveDiffusion2D
 
 
 def test_initialize_physical_parameters():
     """
-    Checks function SolveDiffusion2D.initialize_domain
+    Checks function SolveDiffusion2D.initialize_physical_parameters
     """
     solver = SolveDiffusion2D()
 
+    w, h, dx, dy = 5., 6., 0.2, 0.2
+    d, T_cold, T_hot = 2., 300., 700.
+    expected_dt = 0.0050 # (dx ** 2 * dy ** 2) / (2 * d * (dx ** 2 + dy ** 2))
+
+    solver.initialize_domain(w, h, dx, dy)
+    solver.initialize_physical_parameters(d, T_cold, T_hot)
+
+    assert np.allclose(expected_dt, solver.dt), f"Returned dt is incorrect: is {solver.dt}, should be {expected_dt}"
+
 
 def test_set_initial_condition():
     """
-    Checks function SolveDiffusion2D.get_initial_function
+    Checks function SolveDiffusion2D.set_initial_condition
     """
     solver = SolveDiffusion2D()
+
+    u = np.full((5, 5), 300.)
+
+    solver.initialize_domain(1., 1., 0.2, 0.2)
+    solver.initialize_physical_parameters(2., 300., 700.)
+    solver_u = solver.set_initial_condition()
+
+    assert np.allclose(solver_u, u), f"Returned initial condition is incorrect: is {solver_u}, should be {u}"

tests/unit/test_diffusion2d_functions.py

@@ -2,25 +2,64 @@
 Tests for functions in class SolveDiffusion2D
 """
 
+import unittest
+import numpy as np
 from diffusion2d import SolveDiffusion2D
 
+class TestDiffusion2DFunctions(unittest.TestCase):
 
-def test_initialize_domain():
-    """
-    Check function SolveDiffusion2D.initialize_domain
-    """
-    solver = SolveDiffusion2D()
+    def test_initialize_domain(self):
+        """
+        Check function SolveDiffusion2D.initialize_domain
+        """
+        solver = SolveDiffusion2D()
 
+        nx, ny = 25., 30.
+        solver.initialize_domain(5., 6., 0.2, 0.2)
 
-def test_initialize_physical_parameters():
-    """
-    Checks function SolveDiffusion2D.initialize_domain
-    """
-    solver = SolveDiffusion2D()
+        assert solver.nx == nx, f"Returned nx is incorrect: is {solver.nx}, should be {nx}"
+        assert solver.ny == ny, f"Returned ny is incorrect: is {solver.ny}, should be {ny}"
 
 
-def test_set_initial_condition():
-    """
-    Checks function SolveDiffusion2D.get_initial_function
-    """
-    solver = SolveDiffusion2D()
+    def test_initialize_physical_parameters(self):
+        """
+        Checks function SolveDiffusion2D.initialize_domain
+        """
+        solver = SolveDiffusion2D()
+
+        dt = 0.0019
+        solver.dx, solver.dy = 0.125, 0.75
+        solver.initialize_physical_parameters(4., 300., 700.)
+        self.assertAlmostEqual(solver.dt, dt, places=4, 
+                               msg=f"Returned dt is incorrect: is {solver.dt}, should be {dt}")
+
+
+    def test_set_initial_condition(self):
+        """
+        Checks function SolveDiffusion2D.get_initial_function
+        """
+        solver = SolveDiffusion2D()
+
+        solver.dx = solver.dy = 0.3
+        solver.nx = solver.ny = 75
+        solver.T_cold, solver.T_hot = 300., 700.
+
+        solver_u = solver.set_initial_condition()
+
+        r, cx, cy = 2, 5, 5
+        r2 = r ** 2
+
+        u = solver.T_cold * np.ones((solver.nx, solver.ny))
+
+        for i in range(solver.nx):
+            for j in range(solver.ny):
+                p2 = (i * solver.dx - cx) ** 2 + (j * solver.dy - cy) ** 2
+                if p2 < r2:
+                    u[i, j] = solver.T_hot
+
+        # print(solver_u, u)
+
+        for i in range(solver.nx):
+            for j in range(solver.ny):
+                self.assertAlmostEqual(solver_u[i, j], u[i, j], places=4,
+                                       msg=f"Returned u is incorrect: is {solver_u[i, j]}, should be {u[i, j]}")

tox.toml

@@ -0,0 +1,10 @@
+requires = ["tox>=4"]
+env_list = ["testing"]
+
+[env.testing]
+desciption = "Run pytest and unittest"
+deps = ["-r requirements.txt"]
+commands = [
+    ["python", "-m", "pytest"],
+    ["python", "-m", "unittest", "discover", "-s", "tests/unit"]
+]