Merge pull request #3382 from stfc/1570_remove_default_precision_check_in_reductions

(towards #1570) remove the scalar precision check

Author: arporter

changelog

@@ -1,3 +1,6 @@
+   72) PR #3382 towards #1570. Removes the unnecessary check on the precision
+   of a scalar used in a reduction in the LFRic API.
+ 
    71) PR #3381. Update integration tests to LFRic_apps 3.1.1
 
    70) PR #3358 for #1734, #2975 and #2949. Improve symbol table consistency

src/psyclone/domain/lfric/lfric_constants.py

@@ -32,7 +32,7 @@
 # POSSIBILITY OF SUCH DAMAGE.
 # -----------------------------------------------------------------------------
 # Author: J. Henrichs, Bureau of Meteorology
-# Modified: I. Kavcic and L, Turner, Met Office
+# Modified: I. Kavcic, L, Turner and A. Pirrie, Met Office
 #           A. R. Porter, STFC Daresbury Laboratory
 #           R. W. Ford, STFC Daresbury Laboratory
 
@@ -389,13 +389,13 @@ def __init__(self) -> None:
         # Data structure type mandates its proxy name, Fortran intrinsic type
         # of its data and the kind (precision) for the intrinsic type.
         LFRicConstants.DATA_TYPE_MAP = {
-            # 'real'-valued scalar reduction of kind 'r_def' (used for global
-            # reductions of "field_type" data)
-            "reduction": {"module": "scalar_mod",
-                          "type": "scalar_type",
-                          "proxy_type": None,
-                          "intrinsic": "real",
-                          "kind": "r_def"},
+            # 'real'-valued scalar reduction of default kind 'None' (used for
+            # global reductions of "field_type" data)
+            "scalar": {"module": "scalar_mod",
+                       "type": "scalar_type",
+                       "proxy_type": None,
+                       "intrinsic": "real",
+                       "kind": None},
             # 'real'-valued field with data of kind 'r_def'
             "field": {"module": "field_mod",
                       "type": "field_type",
@@ -573,6 +573,10 @@ def precision_for_type(self, data_type):
         :raises InternalError: if an unknown data_type is specified.
 
         '''
+        invalid_types = ["scalar_type"]
+        if data_type in invalid_types:
+            raise ValueError(f"Cannot infer the precision of a '{data_type}'.")
+
         for module_info in self.DATA_TYPE_MAP.values():
             if module_info["type"] == data_type:
                 # TODO #2659 - this method should probably just return a name
@@ -581,8 +585,8 @@ def precision_for_type(self, data_type):
                 from psyclone.domain.lfric.lfric_types import LFRicTypes
                 return LFRicTypes(module_info["kind"].upper())
 
-        valid = [module_info["type"]
-                 for module_info in self.DATA_TYPE_MAP.values()]
+        valid = [module_info["type"] for module_info in
+                 self.DATA_TYPE_MAP.values()]
         raise InternalError(f"Unknown data type '{data_type}', expected one "
                             f"of {valid}.")
 

src/psyclone/lfric.py

@@ -5905,38 +5905,22 @@ def _init_scalar_properties(
                     "Reductions for datatypes other than real are not yet "
                     "supported in PSyclone.")
 
-            expected_precision = const.DATA_TYPE_MAP["reduction"]["kind"]
-            # If the algorithm information is not being ignored
-            # then check that the expected precision and the
-            # precision defined in the algorithm layer are
-            # the same.
-            if check and alg_precision and \
-               alg_precision != expected_precision:
-                raise GenerationError(
-                    f"This scalar is a reduction which assumes precision "
-                    f"of type '{expected_precision}' but the algorithm "
-                    f"declares this scalar with precision "
-                    f"'{alg_precision}'.")
-
-            # Use the default 'real' scalar reduction properties.
-            self._precision = expected_precision
-            self._data_type = const.DATA_TYPE_MAP["reduction"]["type"]
-            self._proxy_data_type = const.DATA_TYPE_MAP[
-                "reduction"]["proxy_type"]
-            self._module_name = const.DATA_TYPE_MAP["reduction"]["module"]
+            self._data_type = const.DATA_TYPE_MAP["scalar"]["type"]
+            self._proxy_data_type = None
+            self._module_name = const.DATA_TYPE_MAP["scalar"]["module"]
+
+        # The precision of the symbol does not depend on whether
+        # it is a reduction
+        if check and alg_precision:
+            # Use the algorithm precision if it is available
+            # and not being ignored.
+            self._precision = alg_precision
         else:
-            # This is a scalar that is not part of a reduction.
-
-            if check and alg_precision:
-                # Use the algorithm precision if it is available
-                # and not being ignored.
-                self._precision = alg_precision
-            else:
-                # Use default precision for this datatype if the
-                # algorithm precision is either not available or is
-                # being ignored.
-                self._precision = const.SCALAR_PRECISION_MAP[
-                    self.intrinsic_type]
+            # Use default precision for this datatype if the
+            # algorithm precision is either not available or is
+            # being ignored.
+            self._precision = const.SCALAR_PRECISION_MAP[
+                self.intrinsic_type]
 
     def _init_field_properties(self, alg_datatype, check=True):
         '''Set up the properties of this field using algorithm datatype

src/psyclone/tests/domain/lfric/lfric_builtins_test.py

@@ -32,7 +32,7 @@
 # POSSIBILITY OF SUCH DAMAGE.
 # -----------------------------------------------------------------------------
 # Author: A. R. Porter, STFC Daresbury Lab
-# Modified: I. Kavcic and O. Brunt, Met Office
+# Modified: I. Kavcic, O. Brunt and A. Pirrie, Met Office
 # Modified: R. W. Ford and N. Nobre, STFC Daresbury Lab
 # Modified: by J. Henrichs, Bureau of Meteorology
 
@@ -1885,6 +1885,28 @@ def test_x_innerproduct_x(fortran_writer):
             "asum = asum + f1_data(df) * f1_data(df)\n") in code
 
 
+def test_x_innerproduct_x_r_double(fortran_writer, tmp_path):
+    ''' Test the lower_to_language_level builtin methods for real64 precision.
+
+    '''
+    kern = builtin_from_file("15.9.3_X_innerproduct_X_builtin_r_double.f90")
+    assert str(kern) == "Built-in: X_innerproduct_X (real-valued field)"
+
+    # Test the 'lower_to_language_level()' method
+    lowered = kern.lower_to_language_level()
+    sum = lowered.scope.symbol_table.lookup("asum")
+    assert sum.datatype.precision.name == "r_double"
+
+    code = fortran_writer(lowered)
+    assert ("! Built-in: X_innerproduct_X (real-valued field)\n"
+            "asum = asum + f1_data(df) * f1_data(df)\n") in code
+
+    # Test compilation of generated code
+    psy, _ = get_invoke("15.9.3_X_innerproduct_X_builtin_r_double.f90",
+                        api=API, idx=0, dist_mem=True)
+    assert LFRicBuild(tmp_path).code_compiles(psy)
+
+
 def test_x_innerproduct_y(fortran_writer):
     ''' Test the metadata, str and lower_to_language_level builtin methods. '''
     metadata = lfric_builtins.LFRicXInnerproductYKern.metadata()

src/psyclone/tests/domain/lfric/lfric_constants_test.py

@@ -33,6 +33,8 @@
 # -----------------------------------------------------------------------------
 # Authors: R. W. Ford and A. R. Porter, STFC Daresbury Laboratory.
 # Modified by J. Henrichs, Bureau of Meteorology
+#             A. Pirrie, Met Office
+
 
 '''
 Module containing tests for the LFRic constants class.
@@ -111,14 +113,18 @@ def test_precision_for_type():
     '''Check the precision_for_type() method.'''
     const = LFRicConstants()
     for module_info in const.DATA_TYPE_MAP.values():
-        assert (const.precision_for_type(module_info["type"])
-                == LFRicTypes(module_info["kind"].upper()))
+        if module_info["type"] != "scalar_type":
+            assert (const.precision_for_type(module_info["type"])
+                    == LFRicTypes(module_info["kind"].upper()))
 
 
 def test_precision_for_type_error():
     '''Tests that exceptions are raised as expected from
     precision_for_type().
     '''
+    with pytest.raises(ValueError) as err:
+        LFRicConstants().precision_for_type("scalar_type")
+    assert "Cannot infer the precision of a 'scalar_type'." in str(err.value)
     with pytest.raises(InternalError) as err:
         LFRicConstants().precision_for_type("invalid")
     assert "Unknown data type 'invalid', expected one of" in str(err.value)

src/psyclone/tests/lfric_test.py

@@ -1665,14 +1665,6 @@ class for a scalar reduction.
     assert reduction._proxy_data_type is None
     assert reduction._module_name == "scalar_mod"
 
-    # Scalar reduction with inconsistent precision (expects 'r_def')
-    arg = Arg("variable", None, None, ("real", "i_def"))
-    with pytest.raises(GenerationError) as info:
-        reduction._init_data_type_properties(arg)
-    assert ("This scalar is a reduction which assumes precision of type "
-            "'r_def' but the algorithm declares this scalar with precision "
-            "'i_def'" in str(info.value))
-
     # Invalid reduction type (not a 'real')
     arg = Arg("variable", None, None, ("integer", "i_def"))
     with pytest.raises(GenerationError) as info:

src/psyclone/tests/test_files/lfric/15.9.3_X_innerproduct_X_builtin_r_double.f90

@@ -0,0 +1,50 @@
+! -----------------------------------------------------------------------------
+! BSD 3-Clause License
+!
+! Copyright (c) 2026, 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: A. Pirrie, Met Office
+
+program single_invoke
+
+  ! Description: single point-wise operation (inner product of one field by
+  ! itself) specified in an invoke call of double precision.
+  use constants_mod, only: r_double
+  use field_mod,     only: field_type
+
+  implicit none
+
+  type(field_type) :: f1
+  real(r_double)     :: asum
+
+  call invoke( X_innerproduct_X(asum, f1) )
+
+end program single_invoke