Merge pull request #27 from UCL-ARC/4-add-garden-tests

4 add veggies and pFUnit tests

Author: connoraird

.gitignore

@@ -2,3 +2,5 @@
 *.mod
 *.DS_Store
 build/
+build-cmake/
+*Temporary

CMakeLists.txt

@@ -25,4 +25,13 @@ enable_testing()
 #--------------------------------------#
 #             test-drive               #
 #--------------------------------------#
-add_subdirectory("testing/test-drive")
+if (BUILD_TESTS MATCHES "ON")
+  add_subdirectory("testing/test-drive")
+endif()
+
+#--------------------------------------#
+#               pFUnit                 #
+#--------------------------------------#
+if (BUILD_TESTS MATCHES "ON")
+  add_subdirectory("testing/pFUnit")
+endif()

README.md

@@ -35,34 +35,58 @@ There are two src codes within this repository [mesh_generator](./src/mesh_gener
 
 ## Building
 
-We are utilising cmake (see [CMakeLists.txt](./CMakeLists.txt)) for our build system. Therefore, to build this repository, please run the following
+A bash script is provided for building ([build.sh](./build.sh)). However, there are some instructions below for building without this script.
+
+### CMake
+>Note: we have some [PFunit tests](./testing/pFUnit/) which require a local version of PFunit to be pre-built on your device. Once built, the path to the PFunit `installed` dir will need to be passed via `-DCMAKE_PREFIX_PATH`.
+
+One build system we are utilising is cmake (see [CMakeLists.txt](./CMakeLists.txt)). Therefore, to build this repository, please run the following
 ```sh
-cmake -B build 
+cmake -DCMAKE_PREFIX_PATH=/path/to/pfunit/installed/dir -B build-cmake 
 ``` 
 This will create a [build](./build) directory from within which the project can be compiled...
 ```sh
-cd build
-make
+cmake --build build-cmake
 ```
 This will produce executables for the two src codes, `fortran-tooling-mesh-generator` and `fortran-tooling-poisson`.
 
+### FPM
+To build the project using FPM, from the root of the repo, run
+```sh
+fpm build
+```
+
 ## Running the src
 
 ### Mesh generator
-
+If you have built using CMake, you can run the mesh generator by directly calling the executable
 ```sh
 ./build/fortran-tooling-mesh-generator <box_size> <edge_size>
 ```
 
+If you have built using FPM, you can also run the mesh generator via FPM
+```sh
+fpm run mesh_generator -- <box_size> <edge_size>
+```
+
 ### Poisson solver
+If you have built using CMake, you can also run the poisson solver by directly calling the executable
+```sh
+./build/fortran-tooling-poisson <path_to_mesh_file>
+```
 
+If you have built using FPM, you can also run the mesh generator via FPM
 ```sh
-./build/fortran-tooling-poisson # then respond to prompt with the mesh name, likely to be `square_mesh`
+fpm run poisson -- <path_to_mesh_file>
 ```
 
 ## Running the tests
+If you have built using CMake, you can run the tests by running the following from within the `build-cmake` directory.
+```sh
+ctest
+```
 
-To run the tests, from within the `build` directory, run the following.
+If you have built using fpm, you can run the tests by running the following from the root of the repo
 ```sh
-$ ctest
+fpm test
 ```

build.sh

@@ -0,0 +1,115 @@
+#!/bin/bash
+
+
+
+clean_build=false
+build_cmake=false
+build_fpm=false
+build_tests=true
+PFUNIT_INSTALLED_PATH="" # Path to pFUnit/installed directory
+run_tests=false
+
+help() {
+  echo "Usage:"
+  echo "    -h  Display this help message."
+  echo "    -c  Clean all build artifacts."
+  echo "    -m  Build via cmake."
+  echo "    -f  Build via fpm."
+  echo "    -s  Skip building cmake tests"
+  echo "    -p  Path to pFUnit/installed directory."
+  echo "    -t  Run tests."
+  exit 0
+}
+
+# check for no input arguments and show help
+if [ $# -eq 0 ];
+then
+    ./build.sh -h
+    exit 0
+fi
+
+# parse input arguments
+while getopts "hcmftp:s" opt
+do
+  case ${opt} in
+    h  ) help;;
+    c  ) clean_build=true;;
+    m  ) build_cmake=true;;
+    f  ) build_fpm=true;;
+    s  ) build_tests=false;;
+    p  ) PFUNIT_INSTALLED_PATH="${OPTARG}";;
+    t  ) run_tests=true;;
+    \? ) echo "Invalid option: $OPTARG" >&2; exit 1;;
+  esac
+done
+shift $((OPTIND -1))
+
+if [ "$clean_build" == "true" ]
+then
+    if [ "$build_cmake" == "true" ]
+    then
+        echo "Cleaning cmake build"
+        rm -rf build-cmake
+    fi
+
+    if [ "$build_fpm" == "true" ]
+    then
+        echo "Cleaning fpm build"
+        rm -rf build
+    fi
+
+    if [ "$build_cmake" == "false" ] && [ "$build_fpm" == "false" ]
+    then
+        echo "No build type specified"
+    fi
+fi
+
+# Build cmake version
+if [ "$build_cmake" == "true" ]
+then
+    echo "Building using cmake"
+    if [ "$build_tests" == "true" ]
+    then
+        echo "Building tests"
+        cmake -DCMAKE_PREFIX_PATH="$PFUNIT_INSTALLED_PATH" -DBUILD_TESTS=ON -B build-cmake 
+    else
+        echo "Skipping tests"
+        cmake -DBUILD_TESTS=OFF -B build-cmake 
+    fi
+    cmake --build build-cmake
+fi
+
+# Build fpm version
+if [ "$build_fpm" == "true" ]
+then
+    if [ "$clean_build" == "true" ]
+    then
+        echo "Cleaning fpm build"
+        rm -rf build
+    fi
+    echo "Building using fpm"
+    fpm build
+fi
+
+if [ "$run_tests" == "true" ]
+then
+    tests_run=false
+    if [ -d "build-cmake" ]; then
+        echo "Running cmake tests"
+        tests_run=true
+        pushd build-cmake
+        ctest
+        popd
+    fi
+
+    if [ -d "build" ]; then
+        echo "Running fpm tests"
+        tests_run=true
+        fpm test
+    fi
+
+    if [ "$tests_run" == "false" ]
+    then
+        echo "No tests found. Must build first."
+    fi
+fi

fpm.toml

@@ -8,20 +8,11 @@ copyright = "Copyright 2025, UCL ARC"
 [fortran]
 source-form = "free"
 
-[profiles.gfortran.linux]
-flags = "-ffree-line-length-none"
-
-[build]
-auto-executables = true
-auto-tests = true
-auto-examples = true
-
-[install]
-library = false
-
 [dev-dependencies]
 test-drive.git = "https://github.com/fortran-lang/test-drive"
 test-drive.tag = "v0.5.0"
+veggies.git = "https://gitlab.com/everythingfunctional/veggies"
+veggies.tag = "main"
 
 [[executable]]
 name = "poisson"
@@ -34,6 +25,11 @@ source-dir = "src/mesh_generator"
 main = "main.f90"
 
 [[test]]
-name = "test-drive-mesh-generator"
+name = "test-drive-tests"
 source-dir = "testing/test-drive"
-main = "main.f90"
+main = "main.f90"
+
+[[test]]
+name = "veggies-tests"
+source-dir = "testing/veggies"
+main = "main.f90"

src/mesh_generator/main.f90

@@ -17,19 +17,31 @@ program main
     real(kind=real64), dimension(:, :), allocatable :: nodes
 
     ! Get command line args (Fortran 2003 standard)
-    if (command_argument_count() > 0) then
+    if (command_argument_count() == 2) then
         call get_command_argument(1, length=argl)
         allocate(character(argl) :: a)
         call get_command_argument(1, a)
         read(a,*) box_size
+        deallocate(a)
+        call get_command_argument(2, length=argl)
+        allocate(character(argl) :: a)
         call get_command_argument(2, a)
         read(a,*) edge_size
+        deallocate(a)
+    else
+        write(*,'(A)') "Error: Invalid input"
+        call get_command_argument(0, length=argl)
+        allocate(character(argl) :: a)
+        call get_command_argument(0, a)
+        write(*,'(A,A,A)') "Usage: ", a, " <box_size> <edge_size>"
+        deallocate(a)
+        stop
     end if
 
     ! Output start message
     write(*,'(A)') "Generating mesh using:"
     write(*,'(A,1I16)') "box size: ", box_size 
-    write(*,*) " process: ", edge_size
+    write(*,*) " edge_size: ", edge_size
 
     call calculate_mesh_parameters(box_size, edge_size, num_edges_per_boundary, num_nodes, num_boundary_nodes, num_elements)
 

src/mesh_generator/mesh_generator.f90

@@ -146,6 +146,7 @@ subroutine write_mesh_to_file(num_nodes, num_elements, num_boundary_nodes, nodes
 
         if( iostat .ne. 0) then
             write(*,'(a)') ' *** Error when opening '//trim(file_name)
+            stop
         else
             write(*,'(/,a)') ' *** '//trim(file_name)//' opened'
         end if

src/poisson/main.f90

@@ -3,42 +3,49 @@ program main
 
     implicit none
 
-    integer       :: boundary_index(mxp), element_to_node(3,mxe),    &
-                     vb_index(mxe), boundary_node_num(2,mxb), num_side_nodes(4,mxb)
-    real          :: coordinates(2, mxp), nodal_value_of_f(mxp), rhs_vector(mxp), beta(mxp), f_increment(mxp), &
-                     vb1(mxc), vb2(mxc), vb(3,mxc), element_stiffness(6,mxe),             &
-                     pre_conditioning_matrix(mxp)
+    integer       :: num_nodes, num_elements, num_boundary_points, element_to_node(3,mxe), vb_index(mxe), boundary_node_num(2,mxb), num_side_nodes(4,mxb)
+    real          :: coordinates(2, mxp), nodal_value_of_f(mxp), vb1(mxc), vb2(mxc), vb(3,mxc)
     integer       :: fname_io = 100, fname_out_io = 101
-    character*120 :: input_fname, output_fname
+
+    !! CLI inputs
+    integer                       :: argl
+    character(len=:), allocatable :: a, input_fname, output_fname
 
     !!
-    !! *** Asks for I/O file names
-    !!
-    write(*,'(10(/),7(a,/),//)')                    &
-        '        *********************************', &
-        '        ***                           ***', &
-        '        ***    *  P O I S S O N  *    ***', &
-        '        ***                           ***', &
-        '        ***  PCG-FEM HEAT CONDUCTION  ***', &
-        '        ***                           ***', &
-        '        *********************************' 
-    input_fname = textread(' Enter input file name : ')
-    output_fname = trim(input_fname)//'.out'
+    !! *** Check for input from user
+    !!
+    if (command_argument_count() == 1) then
+        call get_command_argument(1, length=argl)
+        allocate(character(argl) :: input_fname)
+        call get_command_argument(1, input_fname)
+        allocate(character(argl + 4) :: output_fname)
+        output_fname = input_fname//'.out'
+    else
+        write(*,'(A)') "Error: Invalid input"
+        call get_command_argument(0, length=argl)
+        allocate(character(argl) :: a)
+        call get_command_argument(0, a)
+        write(*,'(A,A,A)') "Usage: ", a, " <mesh_file_name>"
+        deallocate(a)
+        stop
+    end if
+
     call open_file(input_fname, 'old', fname_io)
     call open_file(output_fname, 'new', fname_out_io)
+    
 
     !!
     !! *** Reads the triangular mesh and problem constants: Kx,Ky,Q,fp,q
     !!
-    call inp(element_to_node,vb_index,coordinates,boundary_node_num,num_side_nodes,vb,vb1,vb2,fname_io)
+    call read_input_file(num_nodes,num_elements,num_boundary_points,element_to_node,vb_index,coordinates,boundary_node_num,num_side_nodes,vb,vb1,vb2,fname_io)
 
     !!
     !! *** Assembles and solves the system of equations
     !!
-    call pcg(element_to_node,vb_index,coordinates,nodal_value_of_f,boundary_node_num,num_side_nodes,vb,vb1,vb2,element_stiffness,rhs_vector,beta,f_increment,boundary_index,pre_conditioning_matrix)
+    call pcg(num_nodes,num_elements,num_boundary_points,element_to_node,vb_index,coordinates,boundary_node_num,num_side_nodes,vb,vb1,vb2,nodal_value_of_f)
 
     !!
     !! *** Writes the computed solution
     !!
-    call out(element_to_node,coordinates,nodal_value_of_f,fname_out_io)
+    call write_output_file(num_nodes,num_elements,element_to_node,coordinates,nodal_value_of_f,fname_out_io)
 end program main