diff --git a/.github/workflows/compilation.yml b/.github/workflows/compilation.yml index c3a96e3923..e30523ccfa 100644 --- a/.github/workflows/compilation.yml +++ b/.github/workflows/compilation.yml @@ -100,6 +100,18 @@ jobs: module load nvidia-hpcsdk/${NVFORTRAN_VERSION} module load hdf5/${HDF5_VERSION} netcdf_c/${NETCDF_C_VERSION} netcdf_fortran/${NETCDF_FORTRAN_VERSION} pytest -n 4 --f90=nvfortran --compile --compileopencl src/psyclone/tests + - name: Libraries compilation - gfortran + run: | + . .runner_venv/bin/activate + make -C lib/extract clean + module load gcc/${GFORTRAN_VERSION} + make -C lib/extract test + - name: Libraries compilation - nvfortran + run: | + . .runner_venv/bin/activate + make -C lib/extract clean + module load nvidia-hpcsdk/${NVFORTRAN_VERSION} + F90=nvfortran make -C lib/extract test - name: Examples with compilation - gfortran run: | . .runner_venv/bin/activate diff --git a/changelog b/changelog index 8414a1006d..be5ffd2b35 100644 --- a/changelog +++ b/changelog @@ -1,3 +1,5 @@ + 63) PR #2907 for #2878. Improves Extraction library output stats. + 62) PR #3058 for #3059. Update linkcheck parameters, fix links in docs and READMEs, update mentions of nan_check with value_range_check. diff --git a/doc/user_guide/psyke.rst b/doc/user_guide/psyke.rst index e82368d1be..0653222d5f 100644 --- a/doc/user_guide/psyke.rst +++ b/doc/user_guide/psyke.rst @@ -544,10 +544,10 @@ Therefore, compilation for a created driver, e.g. the one created in $ gfortran -g -O0 driver-main-update.F90 -o driver-main-update $ ./driver-main-update - Variable max_abs max_rel l2_diff l2_cos identical #rel<1E-9 #rel<1E-6 #rel<1E-3 - cell .0000000E+00 .0000000E+00 .0000000E+00 .1000000E+01 .1000000E+01 .0000000E+00 .0000000E+00 .0000000E+00 - field1_data .0000000E+00 .0000000E+00 .0000000E+00 .1000000E+01 .5390000E+03 .0000000E+00 .0000000E+00 .0000000E+00 - dummy_var1 .0000000E+00 .0000000E+00 .0000000E+00 .1000000E+01 .1000000E+01 .0000000E+00 .0000000E+00 .0000000E+00 + Variable count identical #rel<1E-9 #rel<1E-6 #rel<1E-3 #rel>=1E-3 max_abs max_rel l2_diff l2_cos + cell 1 1 0 0 0 0 .0000000E+00 .0000000E+00 .0000000E+00 .1000000E+01 + field1_data 539 539 0 0 0 0 .0000000E+00 .0000000E+00 .0000000E+00 .1000000E+01 + dummy_var1 1 1 0 0 0 0 .0000000E+00 .0000000E+00 .0000000E+00 .1000000E+01 (see :ref:`driver_summary_statistics` for details about the statistics`). Note that the Makefile in the example will actually provide additional include @@ -588,10 +588,10 @@ by changing the compilation options, or compiler version. Example output: .. code-block:: output - Variable max_abs max_rel l2_diff l2_cos identical #rel<1E-9 #rel<1E-6 #rel<1E-3 - cell .0000000E+00 .0000000E+00 .0000000E+00 .1000000E+01 .1000000E+01 .0000000E+00 .0000000E+00 .0000000E+00 - field1_data .0000000E+00 .0000000E+00 .0000000E+00 .1000000E+01 .5390000E+03 .0000000E+00 .0000000E+00 .0000000E+00 - dummy_var1 .0000000E+00 .0000000E+00 .0000000E+00 .1000000E+01 .1000000E+01 .0000000E+00 .0000000E+00 .0000000E+00 + Variable count identical #rel<1E-9 #rel<1E-6 #rel<1E-3 #rel>=1E-3 max_abs max_rel l2_diff l2_cos + cell 1 1 0 0 0 0 .0000000E+00 .0000000E+00 .0000000E+00 .1000000E+01 + field1_data 539 539 0 0 0 0 .0000000E+00 .0000000E+00 .0000000E+00 .1000000E+01 + dummy_var1 1 1 0 0 0 0 .0000000E+00 .0000000E+00 .0000000E+00 .1000000E+01 The columns from left to right are: @@ -607,28 +607,33 @@ The columns from left to right are: .. only:: latex or has_dvipng * The variable name. + * The number of elements for this variable (i.e. 1 for scalar). + * How many values are identical. + * How many values have a relative error of less than 10\ :sup:`-9` but are not identical. Note that + single precision variables typically do not have enough significant digits to have an error of 10\ :sup:`-9`. + * How many values have a relative error of less than 10\ :sup:`-6` but more than 10\ :sup:`-9`. + * How many values have a relative error of less than 10\ :sup:`-3` but more than 10\ :sup:`-6`. + * How many values have a relative error of more than 10\ :sup:`-3`. * The maximum absolute error of all elements. * The maximum relative error of all elements. If an element has the value 0, the relative error for this element is considered to be 1.0. * The L2 difference: :math:`\sqrt{\sum{(original-new)^2}}`. * The cosine of the angle between the two vectors: :math:`\frac{\sum{original*new}}{\sqrt{\sum{original*original}}*\sqrt{\sum{new*new}}}`. - * How many values are identical. - * How many values have a relative error of less than 10\ :sup:`-9` but are not identical. - * How many values have a relative error of less than 10\ :sup:`-6` but more than 10\ :sup:`-9`. - * How many values have a relative error of less than 10\ :sup:`-3` but more than 10\ :sup:`-6`. .. only:: html and not has_dvipng * The variable name. + * The number of elements for this variable (i.e. 1 for scalar). + * How many values are identical. + * How many values have a relative error of less than 10\ :sup:`-9` but are not identical. Note that + single precision variables typically do not have enough significant digits to have an error of 10\ :sup:`-9`. + * How many values have a relative error of less than 10\ :sup:`-6` but more than 10\ :sup:`-9`. + * How many values have a relative error of less than 10\ :sup:`-3` but more than 10\ :sup:`-6`. * The maximum absolute error of all elements. * The maximum relative error of all elements. If an element has the value 0, the relative error for this element is considered to be 1.0. * The L2 difference: `sqrt(sum((original-new)`\ :sup:`2` `))`. * The cosine of the angle between the two vectors: `sum(original*new)/(sqrt(sum(original*original))*sqrt(sum(new*new)))`. - * How many values are identical. - * How many values have a relative error of less than 10\ :sup:`-9` but are not identical. - * How many values have a relative error of less than 10\ :sup:`-6` but more than 10\ :sup:`-9`. - * How many values have a relative error of less than 10\ :sup:`-3` but more than 10\ :sup:`-6`. .. note:: The usefulness of the columns printed is still being evaluated. Early indications are that the cosine of the angle between the two vectors, diff --git a/lib/extract/.gitignore b/lib/extract/.gitignore index d430e03be5..3558d478b2 100644 --- a/lib/extract/.gitignore +++ b/lib/extract/.gitignore @@ -1,2 +1,3 @@ # The leading / means only ignore the file in this directory /compare_variables_mod.F90 +test_compare diff --git a/lib/extract/Makefile b/lib/extract/Makefile index 5b9623cbc0..428cb749ef 100644 --- a/lib/extract/Makefile +++ b/lib/extract/Makefile @@ -49,19 +49,35 @@ PSYDATA_LIB_DIR ?= ./.. # These arguments are responsible for creating the Fortran # `compare_variables_mod` file based on the jinja template. It will support -# the listed data types and scalar and 2-dimensional arrays. Note that -# domain-specific implementation will create their own version with different -# number of dimensions if required. -PROCESS_ARGS = -types=char,int,long,logical,real,double -dims=2 +# the listed data types and scalar and 2-dimensional arrays. +# The type and n-arity of the comparable type may need to be adjusted to +# match the capabilities of the target application using the arguments below. + +PROCESS_ARGS ?= -types=char,int,long,logical,real,double -dims=1,2,3,4 PROCESS = $$($(PSYDATA_LIB_DIR)/get_python.sh) $(PSYDATA_LIB_DIR)/process.py -.PHONY: all compare +.PHONY: all compare test compare: compare_variables_mod.o +test_compare: compare_variables_mod.o test_compare.o + $(F90) $(F90FLAGS) $^ -o $@ + +make test: test_compare + # The first 6 fields of the output contain the counts of various + # errors. Only check these counts, not the computed floating point + # differences (which are the next 4 columns), since they might + # slightly vary between compilers and hardware platforms. + ./test_compare | grep "a_dbl *15 *1 *2 *3 *4 *5" > /dev/null + ./test_compare | grep "a_single *10 *1 *0 *2 *3 *4" > /dev/null + ./test_compare | grep "a_int *15 *1 *2 *3 *4 *5" > /dev/null + %.o: %.F90 $(F90) -c $(F90FLAGS) $< +%.o: %.f90 + $(F90) -c $(F90FLAGS) $< + # ------------------------------------------------ compare_variables_mod.F90: compare_variables_mod.jinja Makefile $(PROCESS) $(PROCESS_ARGS) $< > compare_variables_mod.F90 @@ -74,4 +90,5 @@ all: compare clean: rm -f compare_variables_mod.mod compare_variables_mod.o \ - compare_variables_mod.F90 + compare_variables_mod.F90 test_compare.mod test_compare.o \ + test_compare diff --git a/lib/extract/binary/lfric/compare_variables_mod.F90 b/lib/extract/binary/lfric/compare_variables_mod.F90 index aa6f228bbd..11f44eadc0 100644 --- a/lib/extract/binary/lfric/compare_variables_mod.F90 +++ b/lib/extract/binary/lfric/compare_variables_mod.F90 @@ -45,16 +45,18 @@ module compare_variables_mod use, intrinsic :: iso_fortran_env, only : real64, stderr => Error_Unit implicit None - integer, parameter :: MAX_ABS_ERROR = 1 - integer, parameter :: MAX_REL_ERROR = 2 - integer, parameter :: L2_DIFF = 3 - integer, parameter :: L2_COS_SIMILAR = 4 - integer, parameter :: count_0 = 5 ! No error - integer, parameter :: count_neg_9 = 6 ! 10^-9 > rel error > 0 - integer, parameter :: count_neg_6 = 7 ! 10^-6 > rel error >=10^-9 - integer, parameter :: count_neg_3 = 8 ! 10^-3 > rel error >=10^-6 - - integer, parameter :: NUM_RESULTS = 8 + integer, parameter :: COUNT_ALL = 1 + integer, parameter :: COUNT_0 = 2 ! No error + integer, parameter :: COUNT_NEG_9 = 3 ! 10^-9 > rel error > 0 + integer, parameter :: COUNT_NEG_6 = 4 ! 10^-6 > rel error >=10^-9 + integer, parameter :: COUNT_NEG_3 = 5 ! 10^-3 > rel error >=10^-6 + integer, parameter :: COUNT_LARGER = 6 ! rel error >=10^-3 + integer, parameter :: MAX_ABS_ERROR = 7 + integer, parameter :: MAX_REL_ERROR = 8 + integer, parameter :: L2_DIFF = 9 + integer, parameter :: L2_COS_SIMILAR = 10 + + integer, parameter :: NUM_RESULTS = 10 integer, parameter :: MAX_STRING_LENGTH=512 character(MAX_STRING_LENGTH), dimension(:), allocatable :: all_names @@ -128,14 +130,16 @@ subroutine compare_summary() enddo write(out_format, "('(A',I0)" ) max_name_len - write(*,out_format//",8A13)") "Variable", "max_abs", "max_rel",& - "l2_diff", "l2_cos", "identical", "#rel<1E-9", "#rel<1E-6", "#rel<1E-3" + write(*,out_format//",10A13)") "Variable", "count", "identical", & + "#rel<1E-9", "#rel<1E-6", "#rel<1E-3", "#rel>=1E-3", & + "max_abs", "max_rel", "l2_diff", "l2_cos" - out_format = trim(out_format)//"' ',8(E12.7,' '))" + out_format = trim(out_format)//"' ',6(I12, ' '),4(E12.7,' '))" ! Then write out the results for each variable: do i=1, current_index - write(*,out_format) trim(all_names(i)), all_results(i,:) + write(*,out_format) trim(all_names(i)), int(all_results(i,1:6)), & + all_results(i,7:) enddo end subroutine compare_summary @@ -161,6 +165,7 @@ subroutine compare_scalar_Char(name, value, correct_value) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index,COUNT_ALL) = 1.0 if (value == correct_value) then ! All other values have already been initialised with 0 all_results(current_Index, L2_COS_SIMILAR) = 1 @@ -171,7 +176,7 @@ subroutine compare_scalar_Char(name, value, correct_value) all_results(current_index, L2_DIFF ) = 1.0 all_results(current_index, L2_COS_SIMILAR) = 0.0 all_results(current_index, MAX_REL_ERROR ) = 1.0 - all_results(current_Index, COUNT_NEG_3 ) = 1 + all_results(current_Index, COUNT_LARGER ) = 1 endif end subroutine compare_scalar_Char @@ -204,6 +209,7 @@ subroutine compare_array_1dChar(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -227,7 +233,7 @@ subroutine compare_array_1dChar(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -235,13 +241,16 @@ subroutine compare_array_1dChar(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_1dChar @@ -273,6 +282,7 @@ subroutine compare_array_2dChar(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -296,7 +306,7 @@ subroutine compare_array_2dChar(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -304,13 +314,16 @@ subroutine compare_array_2dChar(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_2dChar @@ -342,6 +355,7 @@ subroutine compare_array_3dChar(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -365,7 +379,7 @@ subroutine compare_array_3dChar(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -373,13 +387,16 @@ subroutine compare_array_3dChar(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_3dChar @@ -411,6 +428,7 @@ subroutine compare_array_4dChar(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -434,7 +452,7 @@ subroutine compare_array_4dChar(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -442,13 +460,16 @@ subroutine compare_array_4dChar(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_4dChar @@ -472,6 +493,7 @@ subroutine compare_scalar_Int(name, value, correct_value) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index,COUNT_ALL) = 1.0 if (value == correct_value) then ! All other values have already been initialised with 0 all_results(current_Index, L2_COS_SIMILAR) = 1 @@ -524,6 +546,7 @@ subroutine compare_array_1dInt(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -543,7 +566,7 @@ subroutine compare_array_1dInt(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -551,13 +574,16 @@ subroutine compare_array_1dInt(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_1dInt @@ -589,6 +615,7 @@ subroutine compare_array_2dInt(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -608,7 +635,7 @@ subroutine compare_array_2dInt(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -616,13 +643,16 @@ subroutine compare_array_2dInt(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_2dInt @@ -654,6 +684,7 @@ subroutine compare_array_3dInt(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -673,7 +704,7 @@ subroutine compare_array_3dInt(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -681,13 +712,16 @@ subroutine compare_array_3dInt(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_3dInt @@ -719,6 +753,7 @@ subroutine compare_array_4dInt(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -738,7 +773,7 @@ subroutine compare_array_4dInt(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -746,13 +781,16 @@ subroutine compare_array_4dInt(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_4dInt @@ -776,6 +814,7 @@ subroutine compare_scalar_Logical(name, value, correct_value) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index,COUNT_ALL) = 1.0 if (value .EQV. correct_value) then ! All other values have already been initialised with 0 all_results(current_Index, L2_COS_SIMILAR) = 1 @@ -786,7 +825,7 @@ subroutine compare_scalar_Logical(name, value, correct_value) all_results(current_index, L2_DIFF ) = 1.0 all_results(current_index, L2_COS_SIMILAR) = 0.0 all_results(current_index, MAX_REL_ERROR ) = 1.0 - all_results(current_Index, COUNT_NEG_3 ) = 1 + all_results(current_Index, COUNT_LARGER ) = 1 endif end subroutine compare_scalar_Logical @@ -819,6 +858,7 @@ subroutine compare_array_1dLogical(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values .EQV. correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -840,7 +880,7 @@ subroutine compare_array_1dLogical(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -848,13 +888,16 @@ subroutine compare_array_1dLogical(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_1dLogical @@ -886,6 +929,7 @@ subroutine compare_array_2dLogical(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values .EQV. correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -907,7 +951,7 @@ subroutine compare_array_2dLogical(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -915,13 +959,16 @@ subroutine compare_array_2dLogical(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_2dLogical @@ -953,6 +1000,7 @@ subroutine compare_array_3dLogical(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values .EQV. correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -974,7 +1022,7 @@ subroutine compare_array_3dLogical(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -982,13 +1030,16 @@ subroutine compare_array_3dLogical(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_3dLogical @@ -1020,6 +1071,7 @@ subroutine compare_array_4dLogical(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values .EQV. correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -1041,7 +1093,7 @@ subroutine compare_array_4dLogical(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -1049,13 +1101,16 @@ subroutine compare_array_4dLogical(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_4dLogical @@ -1079,6 +1134,7 @@ subroutine compare_scalar_Real(name, value, correct_value) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index,COUNT_ALL) = 1.0 if (value == correct_value) then ! All other values have already been initialised with 0 all_results(current_Index, L2_COS_SIMILAR) = 1 @@ -1130,6 +1186,7 @@ subroutine compare_array_1dReal(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -1149,7 +1206,7 @@ subroutine compare_array_1dReal(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -1157,13 +1214,16 @@ subroutine compare_array_1dReal(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_1dReal @@ -1195,6 +1255,7 @@ subroutine compare_array_2dReal(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -1214,7 +1275,7 @@ subroutine compare_array_2dReal(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -1222,13 +1283,16 @@ subroutine compare_array_2dReal(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_2dReal @@ -1260,6 +1324,7 @@ subroutine compare_array_3dReal(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -1279,7 +1344,7 @@ subroutine compare_array_3dReal(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -1287,13 +1352,16 @@ subroutine compare_array_3dReal(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_3dReal @@ -1325,6 +1393,7 @@ subroutine compare_array_4dReal(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -1344,7 +1413,7 @@ subroutine compare_array_4dReal(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -1352,13 +1421,16 @@ subroutine compare_array_4dReal(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_4dReal @@ -1382,6 +1454,7 @@ subroutine compare_scalar_Double(name, value, correct_value) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index,COUNT_ALL) = 1.0 if (value == correct_value) then ! All other values have already been initialised with 0 all_results(current_Index, L2_COS_SIMILAR) = 1 @@ -1433,6 +1506,7 @@ subroutine compare_array_1dDouble(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -1452,7 +1526,7 @@ subroutine compare_array_1dDouble(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -1460,13 +1534,16 @@ subroutine compare_array_1dDouble(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_1dDouble @@ -1498,6 +1575,7 @@ subroutine compare_array_2dDouble(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -1517,7 +1595,7 @@ subroutine compare_array_2dDouble(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -1525,13 +1603,16 @@ subroutine compare_array_2dDouble(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_2dDouble @@ -1563,6 +1644,7 @@ subroutine compare_array_3dDouble(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -1582,7 +1664,7 @@ subroutine compare_array_3dDouble(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -1590,13 +1672,16 @@ subroutine compare_array_3dDouble(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_3dDouble @@ -1628,6 +1713,7 @@ subroutine compare_array_4dDouble(name, values, correct_values) current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values == correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -1647,7 +1733,7 @@ subroutine compare_array_4dDouble(name, values, correct_values) sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -1655,13 +1741,16 @@ subroutine compare_array_4dDouble(name, values, correct_values) tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_4dDouble diff --git a/lib/extract/compare_variables_mod.jinja b/lib/extract/compare_variables_mod.jinja index 6329b43545..5f595ea6ff 100644 --- a/lib/extract/compare_variables_mod.jinja +++ b/lib/extract/compare_variables_mod.jinja @@ -74,16 +74,18 @@ module compare_variables_mod use, intrinsic :: iso_fortran_env, only : real64, stderr => Error_Unit implicit None - integer, parameter :: MAX_ABS_ERROR = 1 - integer, parameter :: MAX_REL_ERROR = 2 - integer, parameter :: L2_DIFF = 3 - integer, parameter :: L2_COS_SIMILAR = 4 - integer, parameter :: count_0 = 5 ! No error - integer, parameter :: count_neg_9 = 6 ! 10^-9 > rel error > 0 - integer, parameter :: count_neg_6 = 7 ! 10^-6 > rel error >=10^-9 - integer, parameter :: count_neg_3 = 8 ! 10^-3 > rel error >=10^-6 - - integer, parameter :: NUM_RESULTS = 8 + integer, parameter :: COUNT_ALL = 1 + integer, parameter :: COUNT_0 = 2 ! No error + integer, parameter :: COUNT_NEG_9 = 3 ! 10^-9 > rel error > 0 + integer, parameter :: COUNT_NEG_6 = 4 ! 10^-6 > rel error >=10^-9 + integer, parameter :: COUNT_NEG_3 = 5 ! 10^-3 > rel error >=10^-6 + integer, parameter :: COUNT_LARGER = 6 ! rel error >=10^-3 + integer, parameter :: MAX_ABS_ERROR = 7 + integer, parameter :: MAX_REL_ERROR = 8 + integer, parameter :: L2_DIFF = 9 + integer, parameter :: L2_COS_SIMILAR = 10 + + integer, parameter :: NUM_RESULTS = 10 integer, parameter :: MAX_STRING_LENGTH=512 character(MAX_STRING_LENGTH), dimension(:), allocatable :: all_names @@ -141,14 +143,16 @@ contains enddo write(out_format, "('(A',I0)" ) max_name_len - write(*,out_format//",8A13)") "Variable", "max_abs", "max_rel",& - "l2_diff", "l2_cos", "identical", "#rel<1E-9", "#rel<1E-6", "#rel<1E-3" + write(*,out_format//",10A13)") "Variable", "count", "identical", & + "#rel<1E-9", "#rel<1E-6", "#rel<1E-3", "#rel>=1E-3", & + "max_abs", "max_rel", "l2_diff", "l2_cos" - out_format = trim(out_format)//"' ',8(E12.7,' '))" + out_format = trim(out_format)//",' ',6(I12, ' '),4(E12.7,' '))" ! Then write out the results for each variable: do i=1, current_index - write(*,out_format) trim(all_names(i)), all_results(i,:) + write(*,out_format) trim(all_names(i)), int(all_results(i,1:6)), & + all_results(i,7:) enddo end subroutine compare_summary @@ -181,6 +185,7 @@ contains current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index,COUNT_ALL) = 1.0 if (value {{EQUAL}} correct_value) then ! All other values have already been initialised with 0 all_results(current_Index, L2_COS_SIMILAR) = 1 @@ -192,7 +197,7 @@ contains all_results(current_index, L2_DIFF ) = 1.0 all_results(current_index, L2_COS_SIMILAR) = 0.0 all_results(current_index, MAX_REL_ERROR ) = 1.0 - all_results(current_Index, COUNT_NEG_3 ) = 1 + all_results(current_Index, COUNT_LARGER ) = 1 {% else %} all_results(current_index, MAX_ABS_ERROR ) = correct_value - value if (correct_value /= 0) then @@ -254,6 +259,7 @@ contains current_index = current_index + 1 all_names(current_index) = name all_results(current_index,:) = 0.0 + all_results(current_index, COUNT_ALL) = size(values) if (all(values {{EQUAL}} correct_values)) then ! All values correct. Notice that all results are already initialised ! to 0, so only set the non-zero values here: @@ -287,7 +293,7 @@ contains sum(double_values*double_correct) & / sqrt(real(sum(double_values*double_values))) & / sqrt(real(sum(double_correct*double_correct))) - all_results(current_index, count_0) = count(tmp == 0.0d0) + all_results(current_index, COUNT_0) = count(tmp == 0.0d0) where(double_correct /= 0) tmp = abs(tmp/double_correct) @@ -295,13 +301,16 @@ contains tmp = -1 endwhere all_results(current_index, MAX_REL_ERROR) = maxval(tmp) - all_results(current_index, COUNT_NEG_3) = count(tmp > 1.0d-3) - ! Count elements >10^-6, and subtract the ones larger than 10^-3 - all_results(current_index, COUNT_NEG_6) = count(tmp > 1.0d-6) & - - all_results(current_Index, COUNT_NEG_3) - all_results(current_index, COUNT_NEG_9) = count(tmp > 1.0d-9) & - - all_results(current_Index, COUNT_NEG_6) - + all_results(current_index, COUNT_LARGER) = count(tmp >= 1.0d-3) + all_results(current_index, COUNT_NEG_9) = count(tmp < 1.0d-9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_6) = count(tmp < 1.0d-6) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_0) + all_results(current_index, COUNT_NEG_3) = count(tmp < 1.0d-3) & + - all_results(current_Index, COUNT_NEG_9) & + - all_results(current_Index, COUNT_NEG_6) & + - all_results(current_Index, COUNT_0) endif end subroutine Compare_array_{{dim}}d{{name}} diff --git a/lib/extract/netcdf/extract_netcdf_base.jinja b/lib/extract/netcdf/extract_netcdf_base.jinja index d175142e7b..be46502adb 100644 --- a/lib/extract/netcdf/extract_netcdf_base.jinja +++ b/lib/extract/netcdf/extract_netcdf_base.jinja @@ -222,7 +222,8 @@ contains call this%PSyDataBaseType%PreStart(module_name, region_name, & num_pre_vars, num_post_vars) if (this%verbosity >= 1) then - write(stderr,*) "Opening ", trim(module_name//"-"//region_name//".nc") + write(stderr,*) "Opening ", trim(module_name) // "-" // & + trim(region_name) // ".nc" endif @@ -275,8 +276,8 @@ contains call this%PSyDataBaseType%PreEndDeclaration() if (this%verbosity >= 1) then - write(stderr,*) "Ending definition ", this%module_name // & - "-"//this%region_name//".nc" + write(stderr,*) "Ending definition ", trim(this%module_name) // & + "-"//trim(this%region_name)//".nc" endif retval = CheckError(nf90_enddef(this%ncid)) @@ -297,8 +298,8 @@ contains integer :: retval if (this%verbosity >= 1) then - write(stderr,*) "Closing ", this%module_name//"-" //& - this%region_name//".nc" + write(stderr,*) "Closing ", trim(this%module_name) // "-" // & + trim(this%region_name) // ".nc" endif retval = CheckError(nf90_close(this%ncid)) call this%PSyDataBaseType%PostEnd() diff --git a/lib/extract/netcdf/lfric/Makefile b/lib/extract/netcdf/lfric/Makefile index 984c644778..eb730a9d20 100644 --- a/lib/extract/netcdf/lfric/Makefile +++ b/lib/extract/netcdf/lfric/Makefile @@ -71,7 +71,7 @@ LFRIC_INCLUDE_FLAGS += $$(nf-config --fflags) PSYDATA_LIB_NAME = _extract PSYDATA_LIB = lib$(PSYDATA_LIB_NAME).a -PROCESS_ARGS = -prefix=extract_ -types=char,int,logical,real,double \ +PROCESS_ARGS = -prefix=extract_ -types=char,int,long,logical,real,double \ -dims=1,2,3,4 PROCESS = $$($(PSYDATA_LIB_DIR)/get_python.sh) $(PSYDATA_LIB_DIR)/process.py diff --git a/lib/extract/netcdf/read_kernel_data_mod.jinja b/lib/extract/netcdf/read_kernel_data_mod.jinja index ff60203668..2168ddf2f2 100644 --- a/lib/extract/netcdf/read_kernel_data_mod.jinja +++ b/lib/extract/netcdf/read_kernel_data_mod.jinja @@ -192,14 +192,7 @@ contains end subroutine OpenReadFilename -{# This defines a mapping of the 'userfriendly' names to the NetCDF data types. #} -{% set NCDF_TYPE_MAPPING = { "Double": "NF90_DOUBLE", - "Real": "NF90_REAL", - "Logical":"NF90_INT", - "Int": "NF90_INT"} -%} - {% for name, type in ALL_TYPES %} - {% set NETCDF_TYPE = NCDF_TYPE_MAPPING[name] %} ! ------------------------------------------------------------------------- !> @brief This subroutine reads the value of a scalar {{type}} diff --git a/lib/extract/test_compare.f90 b/lib/extract/test_compare.f90 new file mode 100644 index 0000000000..5084fd7cff --- /dev/null +++ b/lib/extract/test_compare.f90 @@ -0,0 +1,44 @@ +program test_compare + + use compare_variables_mod, only: compare_init, compare, compare_summary + + implicit none + + real, dimension(10) :: a_single, a_single_correct + double precision, dimension(15) :: a_dbl, a_dbl_correct + integer, dimension(15) :: a_int, a_int_correct + + a_dbl_correct = 1.0d0 + ! This should result in counts of: + ! 1 2 3 4 5 (identical, <1e-9, <1e-6, <1e-3, >=1e-3) + a_dbl( 1: 1) = 1.0d0 + a_dbl( 2: 3) = 1.0+1d-10 + a_dbl( 4: 6) = 1.0+1d-7 + a_dbl( 7:10) = 1.0+1d-4 + a_dbl(11:15) = 1.0+1d-1 + + ! Test single precision. Note that single precision cannot store an + ! error of 1e-9, so we only test up to 1e-6: + ! resulting in counts of: 1 0 2 3 4 + a_single_correct = 1.0 + a_single( 1: 1) = 1.0 + a_single( 2: 3) = 1.0+1d-7 + a_single( 4: 6) = 1.0+1d-4 + a_single( 7:10) = 1.0+1d-1 + + ! Test integer, max. value is 2147483648, so use 2*10^9 + ! to create errors with 1e-9 etc + a_int_correct = 2000000000 + a_int( 1: 1) = 2000000000 + a_int( 2: 3) = 2000000001 + a_int( 4: 6) = 2000001000 + a_int( 7:10) = 2001000000 + a_int(11:15) = 2100000000 + + call compare_init(3) + call compare("a_dbl", a_dbl, a_dbl_correct) + call compare("a_single", a_single, a_single_correct) + call compare("a_int", a_int, a_int_correct) + call compare_summary() + +end program test_compare