Merge branch 'master' into add-modular-precision-update

Author: sbryngelson

docs/documentation/testing.md

@@ -1,5 +1,5 @@
 ## Testing
- 
+
 To run MFC's test suite, run
 ```shell
 ./mfc.sh test -j <thread count>
@@ -8,15 +8,15 @@ To run MFC's test suite, run
 It will generate and run test cases, comparing their output to previous runs from versions of MFC considered accurate.
 *golden files*, stored in the `tests/` directory contain this data, aggregating `.dat` files generated when running MFC.
 A test is considered passing when our error tolerances are met in order to maintain a high level of stability and accuracy.
-Run `./mfc.sh test -h` for a full list of accepted arguments.
-
-Most notably, you can consult the full list of tests by running
-```shell
-./mfc.sh test -l
-```
+`./mfc.sh test` has the following unique options:
+- `-l` outputs the full list of tests
+- `--from` (`-f)` and `--to` (`t`) restrict testing to a range of contiguous slugs
+- `--only` (`-o`) restricts testing to a non-contiguous range of tests based on if their trace contains a certain feature
+- `--test-all` (`a`) test post process and ensure the Silo database files are correct
+- `--percent` (`%`) to specify a percentage of the test suite to select at random and test
+- `--max-attempts` (`-m`) the maximum number of attempts to make on a test before considering it failed
+- `--no-examples` skips the testing of cases in the examples folder
 
-To restrict to a given range, use the `--from` (`-f`) and `--to` (`-t`) options.
-To run a (non-contiguous) subset of tests, use the `--only` (`-o`) option instead.
 To specify a computer, pass the `-c` flag to `./mfc.sh run` like so:
 ```shell
 ./mfc.sh test -j <thread count> -- -c <computer name>
@@ -27,15 +27,13 @@ The use of `--` in the above command passes options to the `./mfc.sh run` comman
 
 ### Creating Tests
 
-To (re)generate *golden files*, append the `--generate` option:
-```shell
-./mfc.sh test --generate -j 8
-```
+Creating and updating test cases can be done with the following command line arguments:
+- `--generate` to generate golden files for a new test case
+- `--add-new-variables` to similar to `--generate`, but rather than generating a golden file from scratch, it generates a gold file with new variables for an updated test without changing the original golden file values.
+- `--remove-old-tests` to remove the directories of tests that no longer exist
 
 It is recommended that a range be specified when generating golden files for new test cases, as described in the previous section, in an effort not to regenerate the golden files of existing test cases.
 
-**Note:** If you output new variables and want to update the golden files to include these without modifying the original data, use the `--add-new-variables` option instead.
-
 Adding a new test case can be done by modifying [cases.py](https://github.com/MFlowCode/MFC/tree/master/toolchain/mfc/test/cases.py).
 The function `list_cases` is responsible for generating the list of test cases.
 Loops and conditionals are used to vary parameters, whose defaults can be found in the `BASE_CFG` case object within [case.py](https://github.com/MFlowCode/MFC/tree/master/toolchain/mfc/test/case.py).
@@ -44,7 +42,7 @@ The function operates on two variables:
 - `stack`: A stack that holds the variations to the default case parameters.
 By pushing and popping the stack inside loops and conditionals, it is easier to nest test case descriptions, as it holds the variations that are common to all future test cases within the same indentation level (in most scenarios).
 
-- `cases`: A list that holds fully-formed `Case` objects, that will be returned at the end of the function. 
+- `cases`: A list that holds fully-formed `Case` objects, that will be returned at the end of the function.
 
 Internally a test case is described as:
 ```python
@@ -93,13 +91,13 @@ Finally, the case is appended to the `cases` list, which will be returned by the
 
 ### Testing Post Process
 
-To test the post-processing code, append the `-a` or `--test-all` option: 
+To test the post-processing code, append the `-a` or `--test-all` option:
 ```shell
 ./mfc.sh test -a -j 8
 ```
 
 This argument will re-run the test stack with `parallel_io='T'`, which generates silo_hdf5 files.
 It will also turn most write parameters (`*_wrt`) on.
 Then, it searches through the silo files using `h5dump` to ensure that there are no `NaN`s or `Infinity`s.
-Although adding this option does not guarantee that accurate `.silo` files are generated, it does ensure that the post-process code does not fail or produce malformed data. 
+Although adding this option does not guarantee that accurate `.silo` files are generated, it does ensure that the post-process code does not fail or produce malformed data.
 

examples/nD_perfect_reactor/case.py

@@ -26,7 +26,7 @@
 
 sol.TPX = 1_600, ct.one_atm, 'H2:0.04, O2:0.02, AR:0.94'
 
-Nx   = 25 * args.scale
+Nx   = int(25 * args.scale)
 Tend = 1e-4
 s    = 1e-2
 dt   = 1e-7

src/common/m_variables_conversion.fpp

@@ -23,7 +23,7 @@ module m_variables_conversion
     use m_helper
 
     use m_thermochem, only: &
-        num_species, get_temperature, get_pressure, &
+        num_species, get_temperature, get_pressure, gas_constant, &
         get_mixture_molecular_weight, get_mixture_energy_mass
 
     ! ==========================================================================
@@ -1116,7 +1116,7 @@ contains
                         end do
 
                         call get_mixture_molecular_weight(Ys, mix_mol_weight)
-                        T = q_prim_vf(T_idx)%sf(j, k, l)
+                        T = q_prim_vf(E_idx)%sf(j, k, l)*mix_mol_weight/(gas_constant*rho)
                         call get_mixture_energy_mass(T, Ys, e_mix)
 
                         q_cons_vf(E_idx)%sf(j, k, l) = &

src/post_process/p_main.fpp

@@ -44,6 +44,13 @@ program p_main
 
     ! Time-Marching Loop =======================================================
     do
+        ! If all time-steps are not ready to be post-processed and one rank is
+        ! faster than another, the slower rank processing the last available
+        ! step might be killed when the faster rank attempts to process the
+        ! first missing step, before the slower rank finishes writing the last
+        ! available step. To avoid this, we force synchronization here.
+        call s_mpi_barrier()
+
         call s_perform_time_step(t_step)
 
         call s_save_data(t_step, varname, pres, c, H)

src/simulation/m_chemistry.fpp

@@ -51,53 +51,6 @@ contains
 
     end subroutine s_finalize_chemistry_module
 
-    subroutine s_compute_chemistry_advection_flux(flux_n, rhs_vf)
-
-        type(vector_field), dimension(:), intent(IN) :: flux_n
-        type(scalar_field), dimension(sys_size), intent(INOUT) :: rhs_vf
-        integer :: x, y, z
-        integer :: eqn
-
-        real(wp) :: flux_x, flux_y, flux_z
-
-        #:for num_dims in range(1, 4)
-            if (num_dims == ${num_dims}$) then
-                !$acc parallel loop collapse(4) gang vector default(present) &
-                !$acc private(flux_x, flux_y, flux_z)
-                do z = idwint(3)%beg, idwint(3)%end
-                    do y = idwint(2)%beg, idwint(2)%end
-                        do x = idwint(1)%beg, idwint(1)%end
-                            do eqn = chemxb, chemxe
-                                ! \nabla \cdot (F)
-                                flux_x = (flux_n(1)%vf(eqn)%sf(x - 1, y, z) - &
-                                          flux_n(1)%vf(eqn)%sf(x, y, z))/dx(x)
-
-                                #:if num_dims >= 2
-                                    flux_y = (flux_n(2)%vf(eqn)%sf(x, y - 1, z) - &
-                                              flux_n(2)%vf(eqn)%sf(x, y, z))/dy(y)
-                                #:else
-                                    flux_y = 0._wp
-                                #:endif
-
-                                #:if num_dims == 3
-                                    flux_z = (flux_n(3)%vf(eqn)%sf(x, y, z - 1) - &
-                                              flux_n(3)%vf(eqn)%sf(x, y, z))/dz(z)
-                                #:else
-                                    flux_z = 0._wp
-                                #:endif
-
-                                rhs_vf(eqn)%sf(x, y, z) = flux_x + flux_y + flux_z
-                            end do
-
-                            rhs_vf(T_idx)%sf(x, y, z) = 0._wp
-                        end do
-                    end do
-                end do
-            end if
-        #:endfor
-
-    end subroutine s_compute_chemistry_advection_flux
-
     subroutine s_compute_chemistry_reaction_flux(rhs_vf, q_cons_qp, q_prim_qp)
 
         type(scalar_field), dimension(sys_size), intent(INOUT) :: rhs_vf, q_cons_qp, q_prim_qp

src/simulation/m_rhs.fpp

@@ -860,12 +860,6 @@ contains
         end do
         ! END: Dimensional Splitting Loop =================================
 
-        if (chemistry) then
-            call nvtxStartRange("RHS-CHEM-ADVECTION")
-            call s_compute_chemistry_advection_flux(flux_n, rhs_vf)
-            call nvtxEndRange
-        end if
-
         if (ib) then
             !$acc parallel loop collapse(3) gang vector default(present)
             do l = 0, p
@@ -904,6 +898,10 @@ contains
         end if
 
         if (chemistry) then
+            !$acc kernels
+            rhs_vf(T_idx)%sf(:, :, :) = 0d0
+            !$acc end kernels
+
             if (chem_params%reactions) then
                 call nvtxStartRange("RHS-CHEM-REACTIONS")
                 call s_compute_chemistry_reaction_flux(rhs_vf, q_cons_qp%vf, q_prim_qp%vf)

src/simulation/m_riemann_solvers.fpp

@@ -800,8 +800,8 @@ contains
                                     Y_L = qL_prim_rs${XYZ}$_vf(j, k, l, i)
                                     Y_R = qR_prim_rs${XYZ}$_vf(j + 1, k, l, i)
 
-                                    flux_rs${XYZ}$_vf(j, k, l, i) = (s_M*Y_R*rho_R*vel_R(dir_idx(norm_dir)) &
-                                                                     - s_P*Y_L*rho_L*vel_L(dir_idx(norm_dir)) &
+                                    flux_rs${XYZ}$_vf(j, k, l, i) = (s_M*Y_R*rho_R*vel_R(dir_idx(1)) &
+                                                                     - s_P*Y_L*rho_L*vel_L(dir_idx(1)) &
                                                                      + s_M*s_P*(Y_L*rho_L - Y_R*rho_R)) &
                                                                     /(s_M - s_P)
                                     flux_src_rs${XYZ}$_vf(j, k, l, i) = 0._wp