1623 add training

.github/workflows/compilation.yml

@@ -130,6 +130,7 @@ jobs:
         module load gcc/${GFORTRAN_VERSION} openmpi/${OPENMPI_VERSION}
         module load hdf5/${HDF5_VERSION} netcdf-c/${NETCDF_C_VERSION} netcdf-fortran/${NETCDF_FORTRAN_VERSION}
         make -C tutorial/practicals compile
+        make -C tutorial/training/users compile
     - name: Examples with compilation - nvfortran
       run: |
         . .runner_venv/bin/activate

.github/workflows/python-package.yml

@@ -120,6 +120,7 @@ jobs:
         ( make -C tutorial/practicals transform > /dev/null )
         # Jupyter notebooks are out-of-date
         # ( make -C tutorial/notebooks notebook )
+        ( make -C tutorial/training test)
     - name: Test with pytest
       if: ${{ !(matrix.python-version == '3.9') }}
       run: |

doc/psyad/user_guide/.gitignore

@@ -0,0 +1 @@
+_build

examples/gocean/eg5/extract/Makefile

@@ -123,7 +123,6 @@ compile: transform $(NAME) $(DRIVER_INIT).$(TYPE) $(DRIVER_UPDATE).$(TYPE)
 
 transform: psy.f90
 
-
 F90FLAGS += -I$(INF_INC) -I$(EXTRACT_DIR)
 
 # The dependency on the extraction library here is required to trigger

examples/lfric/eg17/full_example/main.x90

@@ -37,18 +37,11 @@ program main
     use global_mesh_mod,        only: global_mesh_type
     use mesh_mod,               only: mesh_type, PLANE
     use local_mesh_mod,         only: local_mesh_type
-    use local_mesh_collection_mod, only: local_mesh_collection, local_mesh_collection_type
     use mesh_collection_mod,    only: mesh_collection, mesh_collection_type
-    use halo_routing_collection_mod,   only: halo_routing_collection_type,   &
-                                           halo_routing_collection
-    use function_space_collection_mod, only: function_space_collection_type, &
-                                           function_space_collection
     use driver_collections_mod, only: init_collections
-
     use partition_mod,          only: partition_type, partitioner_planar, partitioner_interface
     use extrusion_mod,          only: extrusion_type, uniform_extrusion_type
     use function_space_mod,     only: function_space_type
-    use function_space_collection_mod, only: function_space_collection
     use fs_continuity_mod,      only: W0, W1, W2, W2V, W2H
     use field_mod,              only: field_type, field_proxy_type
     use field_real64_mod,      only : field_real64_type

examples/lfric/eg17/full_example_extract/main.X90

@@ -49,18 +49,11 @@ program main
     use global_mesh_mod,        only: global_mesh_type
     use mesh_mod,               only: mesh_type, PLANE
     use local_mesh_mod,         only: local_mesh_type
-    use local_mesh_collection_mod, only: local_mesh_collection, local_mesh_collection_type
-    use mesh_collection_mod,    only: mesh_collection, mesh_collection_type
-    use halo_routing_collection_mod,   only: halo_routing_collection_type,   &
-                                           halo_routing_collection
-    use function_space_collection_mod, only: function_space_collection_type, &
-                                           function_space_collection
+    use mesh_collection_mod,    only: mesh_collection
     use driver_collections_mod, only: init_collections
-
     use partition_mod,          only: partition_type, partitioner_planar, partitioner_interface
     use extrusion_mod,          only: extrusion_type, uniform_extrusion_type
     use function_space_mod,     only: function_space_type
-    use function_space_collection_mod, only: function_space_collection
     use fs_continuity_mod,      only: W0, W1, W2, W2V, W2H
     use field_mod,              only: field_type, field_proxy_type
     use field_real64_mod,      only : field_real64_type
@@ -93,7 +86,10 @@ program main
     type(field_type)                           :: chi(3)
     real(kind=r_def)                           :: one
     logical(kind=l_def)                        :: some_logical
-    integer                                    :: i, ierr
+    integer                                    :: i
+#ifdef _MPI
+    integer                                    :: ierr
+#endif
 
 
 

src/psyclone/psyir/backend/sympy_writer.py

@@ -111,7 +111,9 @@ class SymPyWriter(FortranWriter):
         {BinaryOperation.Operator.AND: "And({lhs}, {rhs})",
          BinaryOperation.Operator.OR: "Or({lhs}, {rhs})",
          BinaryOperation.Operator.EQV: "Equivalent({lhs}, {rhs})",
-         BinaryOperation.Operator.NEQV: "Xor({lhs}, {rhs})"}
+         BinaryOperation.Operator.NEQV: "Xor({lhs}, {rhs})",
+         BinaryOperation.Operator.EQ: "Eq({lhs}, {rhs})"
+         }
 
     def __init__(self):
         super().__init__()

src/psyclone/psyir/frontend/sympy_reader.py

@@ -49,29 +49,36 @@ class FortranPrinter(Printer):
     not handle e.g. Fortran Array expressions (a(2:5)), so we specialise the
     generic SymPy Printer and handle the necessary conversions.'''
 
-    def _print_And(self, expr):
+    def _print_And(self, expr) -> str:
         '''Called when converting an AND expression.'''
         return f"({'.AND.' .join(self._print(i) for i in expr.args)})"
 
-    def _print_Or(self, expr):
+    def _print_Or(self, expr) -> str:
         '''Called when converting an OR expression.'''
         return f"({'.OR.' .join(self._print(i) for i in expr.args)})"
 
-    def _print_Equivalent(self, expr):
+    def _print_Equivalent(self, expr) -> str:
         '''Called when converting an EQUIVALENT expression.'''
         return f"({'.EQV.' .join(self._print(i) for i in expr.args)})"
 
-    def _print_Xor(self, expr):
+    def _print_Xor(self, expr) -> str:
         '''Called when converting an XOR expression, which in Fortran
         is .NEQV.'''
         return f"({'.NEQV.' .join(self._print(i) for i in expr.args)})"
 
+    def _print_Equality(self, expr) -> str:
+        '''Called when converting an Eq expression, which in Fortran
+        is =='''
+        return f"({'==' .join(self._print(i) for i in expr.args)})"
+
     def _print_BooleanTrue(self, expr) -> str:
         '''Called when converting a SymPy value of True.'''
+        # pylint: disable=unused-argument
         return ".TRUE."
 
     def _print_BooleanFalse(self, expr) -> str:
         '''Called when converting a SymPy value of False.'''
+        # pylint: disable=unused-argument
         return ".FALSE."
 
 

src/psyclone/tests/core/symbolic_maths_test.py

@@ -483,7 +483,11 @@ def test_symbolic_math_use_range(fortran_reader, expressions):
      "norm_u(idx + iw2) * u_e(idx - iw2v + LBOUND(u_e, 1),df2)"),
     (".true. .and. .false.", ".false."),
     ("zh_cum1(jk1) <= zh_cum0(jk0) .AND. zh_cum1(jk1) > zh_cum0(jk0 - 1)",
-     "zh_cum0(jk0) >= zh_cum1(jk1) .AND. zh_cum1(jk1) > zh_cum0(jk0 - 1)")])
+     "zh_cum0(jk0) >= zh_cum1(jk1) .AND. zh_cum1(jk1) > zh_cum0(jk0 - 1)"),
+    ("zh_cum1(jk1) == zh_cum0(jk0) .AND. zh_cum1(jk1) == zh_cum0(jk0 - 1)",
+     "zh_cum0(jk0) == zh_cum1(jk1) .AND. zh_cum1(jk1) == zh_cum0(jk0 - 1)"),
+    ("i == i .and. c(i,i) == 5", "c(i,i) == 5"),
+    ])
 def test_symbolic_maths_expand(fortran_reader, fortran_writer, expr, expected):
     '''Test the expand method works as expected.'''
     # A dummy program to easily create the PSyIR for the

src/psyclone/tests/domain/common/driver_creator_test.py

@@ -49,6 +49,21 @@
 from psyclone.tests.utilities import Compile, get_invoke
 
 
+# ----------------------------------------------------------------------------
+def test_lfric_driver_valid_unit_name():
+    '''Tests that we create valid unit names, i.e. less than 64 characters,
+    and no ":" in name.'''
+
+    long_name = "A"*100
+    new_name = DriverCreator._make_valid_unit_name(long_name)
+    assert new_name == "A"*63
+
+    special_characters = "aaa-bbb"
+    new_name = DriverCreator._make_valid_unit_name(special_characters)
+    assert new_name == "aaabbb"
+
+
+# ----------------------------------------------------------------------------
 def test_basic_driver_add_call(fortran_writer):
     '''Tests that adding a call detects errors and adds calls
     with and without parameters as expected.

src/psyclone/tests/psyir/backend/sympy_writer_test.py

@@ -43,6 +43,7 @@
 from sympy import Function, Symbol
 from sympy.parsing.sympy_parser import parse_expr
 
+from psyclone.psyir.frontend.fortran import FortranReader
 from psyclone.psyir.frontend.sympy_reader import SymPyReader
 from psyclone.psyir.backend.sympy_writer import SymPyWriter
 from psyclone.psyir.backend.visitor import VisitorError
@@ -256,7 +257,7 @@ def test_sym_writer_rename_members(fortran_reader, expressions):
 
 
 @pytest.mark.parametrize(
-    "expr, positive, sym_map",
+    "expr, positive, expected_sym_map",
     [("a%x", False, {"a_x": Symbol("a%x")}),
      ("a%x", True, {"a_x": Symbol("a%x", **{"positive": True})}),
      ("a%x(i)", False, {"a_x": Function("a_x"), "i": Symbol("i")}),
@@ -269,11 +270,15 @@ def test_sym_writer_rename_members(fortran_reader, expressions):
                             "b_c": Function("b_c"),
                             "i": Symbol("i", **{"positive": True})}),
      ])
-def test_sym_writer_symbol_types(fortran_reader, expr, positive, sym_map):
+def test_sym_writer_symbol_types(fortran_reader: FortranReader,
+                                 expr: str,
+                                 positive: bool,
+                                 expected_sym_map: dict[str, Symbol]):
     '''Tests that arrays are detected as SymPy functions, and scalars
     as SymPy symbols. The 'expr' parameter contains the expression to parse,
     'positive' is whether or not to flag symbols as positive definite and
-    'sym_map' is the expected mapping of names to SymPy functions or symbols.
+    'expected_sym_map' is the expected mapping of names to SymPy functions
+    or symbols.
 
     '''
     # A dummy program to easily create the PSyIR for the
@@ -286,12 +291,12 @@ def test_sym_writer_symbol_types(fortran_reader, expr, positive, sym_map):
                 end program test_prog '''
 
     psyir = fortran_reader.psyir_from_source(source)
-    expr = psyir.children[0].children[0].rhs
+    expr_psyir = psyir.children[0].children[0].rhs
     sympy_writer = SymPyWriter()
-    _ = sympy_writer(expr, all_variables_positive=positive)
-    assert len(sympy_writer.type_map) == len(sym_map)
-    for key in sympy_writer.type_map.keys():
-        assert sympy_writer.type_map[key] == sym_map[key]
+    _ = sympy_writer(expr_psyir, all_variables_positive=positive)
+    assert len(sympy_writer.type_map) == len(expected_sym_map)
+    for key, sym_map in sympy_writer.type_map.items():
+        assert sym_map == expected_sym_map[key]
 
 
 @pytest.mark.parametrize("expr, sym_map",
@@ -517,14 +522,13 @@ def test_sympy_writer_user_types(fortran_reader, fortran_writer,
                           ("a .or. b", "Or(a, b)"),
                           ("a .eqv. b", "Equivalent(a, b)"),
                           ("a .neqv. b", "Xor(a, b)"),
+                          ("a == b", "Eq(a, b)"),
                           ])
-def test_sympy_writer_logicals(fortran_reader, fortran_writer,
-                               fortran_expr, sympy_str):
-    '''Test handling of user-defined types, e.g. conversion of
-    ``a(i)%b(j)`` to ``a_b(i,i,1,j,j,1)``. Each Fortran expression
-    ``fortran_expr`` is first converted to a string ``sympy_str`` to be
-    parsed by SymPy. The sympy expression is then converted back to PSyIR.
-    This string must be the same as the original ``fortran_expr``.
+def test_sympy_writer_logicals(fortran_reader: FortranReader,
+                               fortran_expr: str,
+                               sympy_str: str):
+    '''Test writing of logical expressions, i.e. that the Fortran
+    logical expressions are correctly converted to SymPy expressions.
 
     '''
     source = f'''program test_prog

src/psyclone/tests/psyir/frontend/sympy_reader_test.py

@@ -37,7 +37,9 @@
 
 import pytest
 
+from psyclone.psyir.backend.fortran import FortranWriter
 from psyclone.psyir.backend.sympy_writer import SymPyWriter
+from psyclone.psyir.frontend.fortran import FortranReader
 from psyclone.psyir.frontend.sympy_reader import SymPyReader
 
 
@@ -88,9 +90,12 @@ def test_sympy_reader_constructor():
                                          (".TRUE. .and. .true.", ".true."),
                                          (".TRUE. .AND. .FALSE.",
                                           ".false."),
+                                         ("b(i) == 3 .and. c(i,i) == 5",
+                                          "b(i) == 3 .AND. c(i,i) == 5"),
                                          ])
-def test_sympy_psyir_from_expression(fortran_reader, fortran_writer,
-                                     expressions):
+def test_sympy_psyir_from_expression(fortran_reader: FortranReader,
+                                     fortran_writer: FortranWriter,
+                                     expressions: tuple[str, str]):
     '''Test conversion from a SymPy expression back to PSyIR. We use the
     SymPyWriter to convert the Fortran string to a SymPy expression (we need
     a symbol table to convert from SymPy to PSyIR, which we get this way

tutorial/training/Makefile

@@ -0,0 +1,53 @@
+# -----------------------------------------------------------------------------
+# BSD 3-Clause License
+#
+# Copyright (c) 2023-2025, Science and Technology Facilities Council.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ------------------------------------------------------------------------------
+# Author: J. Henrichs, Bureau of Meteorology
+
+
+test:
+	$(MAKE) -C users test
+	$(MAKE) -C gocean test
+	$(MAKE) -C lfric test
+	$(MAKE) -C transformation test
+
+compile:
+	$(MAKE) -C users compile
+	$(MAKE) -C gocean compile
+	$(MAKE) -C lfric compile
+	$(MAKE) -C transformation compile
+
+clean:
+	$(MAKE) -C users clean
+	$(MAKE) -C gocean clean
+	$(MAKE) -C lfric clean
+	$(MAKE) -C transformation clean

tutorial/training/gocean/.gitignore

@@ -0,0 +1,5 @@
+gol
+2*/time_step_alg_mod.f90
+2*/time_step_alg_mod_psy.f90
+2*/solution/time_step_alg_mod.f90
+2*/solution/time_step_alg_mod_psy.f90

tutorial/training/gocean/2.10-GameOfLife-mpi/Makefile

@@ -0,0 +1,33 @@
+EXE = gol
+API = gocean
+MPI = no
+F90 = mpif90
+
+OBJ = time_step_alg_mod.o time_step_alg_mod_psy.o
+
+include ../common.mk
+
+$(EXE): $(OBJ)
+	$(F90) $(F90FLAGS) $(OBJ) $(LDFLAGS) -o $(EXE)
+
+run: $(EXE)
+	mpirun -np 4 ./$(EXE) ../gol-lib/config.glider
+
+# Call the default test (which checks the output file), but do a second test to make
+# sure we get a 2x2 domain decomposition, otherwise the job was not running properly
+# with MPI
+test: test-default
+	@bash -c "if [[ $$(make run | grep -c 'go_decompose: using grid of   2x  2') != 1 ]]; then \
+		echo 'Job is not running properly with MPI'; \
+	fi"
+
+
+# Dependencies:
+# -------------
+# Ensure that PSyclone has finished (which will also create the psy file)
+time_step_alg_mod_psy.f90: time_step_alg_mod.f90
+time_step_alg_mod.o: time_step_alg_mod_psy.o
+
+# PSyclone: create alg and psy layer files:
+%.f90: %.x90 Makefile
+	$(PSYCLONE) -oalg $*.f90 -opsy $*_psy.f90 $<