add more tests, including HSE (#29)

Author: zingale

.codespell-ignore-words

@@ -1,3 +1,4 @@
+ans
 blocs
 bloc
 inout

ppmpy/tests/test_euler.py

@@ -1,11 +1,35 @@
 import numpy as np
 from numpy.testing import assert_array_almost_equal_nulp
 
-from ppmpy.euler import Euler
-from ppmpy.initial_conditions import sod
+from ppmpy.euler import Euler, FluidVars
+from ppmpy.initial_conditions import sod, acoustic_pulse
 
 
-class TestGrid:
+class TestFluidVars:
+
+    @classmethod
+    def setup_class(cls):
+        """ this is run once for each class before any tests """
+
+    @classmethod
+    def teardown_class(cls):
+        """ this is run once for each class after all tests """
+
+    def setup_method(self):
+        """ this is run before each test """
+
+        self.v = FluidVars()
+
+    def teardown_method(self):
+        """ this is run after each test """
+
+    def test_indices(self):
+        assert self.v.urho == self.v.qrho
+        assert self.v.umx == self.v.qu
+        assert self.v.uener == self.v.qp
+
+
+class TestEuler:
 
     @classmethod
     def setup_class(cls):
@@ -47,7 +71,7 @@ def test_cons_to_prim(self):
         assert q[-1, v.qu] == u_r
         assert q[-1, v.qp] == p_r
 
-    def test_properties(self):
+    def test_estimate_dt(self):
 
         # for sod, there is only a left and right state.  No initial velocity
         # so we can just get the soundspeed
@@ -80,3 +104,57 @@ def test_result(self):
                            0.125001080305388, 0.1250000106083176])
 
         assert_array_almost_equal_nulp(self.euler.U[self.euler.grid.lo:self.euler.grid.hi+1, 0], answer, nulp=9)
+
+
+class TestEulerReconstruction:
+
+    @classmethod
+    def setup_class(cls):
+        """ this is run once for each class before any tests """
+
+    @classmethod
+    def teardown_class(cls):
+        """ this is run once for each class after all tests """
+
+    def setup_method(self):
+        """ this is run before each test """
+
+        self.euler = Euler(16, 0.5, init_cond=acoustic_pulse)
+        self.euler.estimate_dt()
+
+    def teardown_method(self):
+        """ this is run after each test """
+
+    def test_construct_parabola(self):
+
+        self.euler.construct_parabola()
+
+        ans = np.array([0.0000000000000000e+00, 0.0000000000000000e+00,
+                        0.0000000000000000e+00, 0.0000000000000000e+00,
+                        0.0000000000000000e+00, -1.4925725604797435e-05,
+                        -5.5892314022898404e-04, -3.1886159900746947e-03,
+                        -1.1509891420676155e-02, -1.5395301015125540e-02,
+                        -7.3670928260867186e-03, 0.0000000000000000e+00,
+                        0.0000000000000000e+00, -7.3670928260867186e-03,
+                        -1.5395301015125540e-02, -1.1509891420676155e-02,
+                        -3.1886159900746947e-03, -5.5892314022898404e-04,
+                        -1.4925725604797435e-05, 0.0000000000000000e+00,
+                        0.0000000000000000e+00, 0.0000000000000000e+00,
+                        0.0000000000000000e+00, 0.0000000000000000e+00])
+
+        assert_array_almost_equal_nulp(self.euler.q_parabola[0].a6, ans)
+
+        ans2 = np.array([0.0000000000000000e+00, 0.0000000000000000e+00,
+                         -8.8817841970012523e-16, 0.0000000000000000e+00,
+                         -8.8817841970012523e-16, -1.4925738349269579e-05,
+                         -5.5894233322995035e-04, -3.1567942491133039e-03,
+                         -1.1552096619801056e-02, -1.5947978794340401e-02,
+                         -8.1712935823112787e-03, 0.0000000000000000e+00,
+                         0.0000000000000000e+00, -8.1712935823112787e-03,
+                         -1.5947978794340401e-02, -1.1552096619801056e-02,
+                         -3.1567942491133039e-03, -5.5894233322995035e-04,
+                         -1.4925738349269579e-05, -8.8817841970012523e-16,
+                         0.0000000000000000e+00, -8.8817841970012523e-16,
+                         0.0000000000000000e+00, 0.0000000000000000e+00])
+
+        assert_array_almost_equal_nulp(self.euler.q_parabola[2].a6, ans2)

ppmpy/tests/test_hse_reconstruction.py

@@ -0,0 +1,68 @@
+import numpy as np
+from numpy.testing import assert_array_almost_equal_nulp
+
+from ppmpy.euler import Euler
+from ppmpy.gravity import constant_gravity
+from ppmpy.initial_conditions import hse
+
+
+class TestHSE:
+
+    @classmethod
+    def setup_class(cls):
+        """ this is run once for each class before any tests """
+
+    @classmethod
+    def teardown_class(cls):
+        """ this is run once for each class after all tests """
+
+    def setup_method(self):
+        """ this is run before each test """
+
+        params = {"base_density": 1.0, "base_pressure": 1.0, "g_const": -1.0}
+
+        self.hse = Euler(16, 0.5, init_cond=hse,
+                         grav_func=constant_gravity,
+                         use_hse_reconstruction=True,
+                         bc_left_type="reflect", bc_right_type="reflect", params=params)
+
+        self.nohse = Euler(16, 0.5, init_cond=hse,
+                         grav_func=constant_gravity,
+                         use_hse_reconstruction=False,
+                         bc_left_type="reflect", bc_right_type="reflect", params=params)
+
+    def teardown_method(self):
+        """ this is run after each test """
+
+    def test_hse_pressure_reconstruction(self):
+
+        self.hse.construct_parabola()
+
+        # the key here is that the left parabola state for the first interior
+        # zone (4, starting from 0) is high -- it is the dp/dr we expect
+
+        ans = np.array([0.8034735033053615, 0.8553105035186105, 0.9104918263262627,
+                        0.9692332344763441, 0.9995217730537299, 0.9389446958989583,
+                        0.882038956753567, 0.8285820502836542, 0.7783649563270688,
+                        0.7311913226102768, 0.6868766969975327, 0.6452478062704096,
+                        0.6061418786176574, 0.5694060071862842, 0.5348965522052972,
+                        0.5024785793443701, 0.4720253321113781, 0.4434177362258399,
+                        0.4165439340303344, 0.3912988471194051, 0.379441306297605,
+                        0.40392139057486975, 0.42998083512808716, 0.457721534168609])
+
+        assert_array_almost_equal_nulp(self.hse.q_parabola[self.hse.v.qp].am, ans)
+
+    def test_standard_pressure_reconstruction(self):
+
+        self.nohse.construct_parabola()
+
+        ans = np.array([0.8034735033053615, 0.8553105035186105, 0.8327632963498921,
+                        0.9692332344763441, 0.9692332344763441, 0.9493560913144479,
+                        0.8823257975943671, 0.8288515068310723, 0.7786180821746437,
+                        0.7314291074973925, 0.6871000706793687, 0.6454576421533463,
+                        0.6063389971743558, 0.5695911791637885, 0.5350705016387105,
+                        0.5026419863878796, 0.472178835697705, 0.44356193656451076,
+                        0.41667939495454037, 0.379441306297605, 0.379441306297605,
+                        0.40392139057486975, 0.42998083512808716, 0.457721534168609])
+
+        assert_array_almost_equal_nulp(self.nohse.q_parabola[self.nohse.v.qp].am, ans)