update flags to match mkmf templates and multiple test fixes

Author: rem1776

CMAKE_INSTRUCTIONS.md

@@ -1,42 +1,55 @@
 \page cmake Building with CMake
 # Instructions for building FMS with cmake
 
-## 1. Environment Variables
+## 1. Configuring the build
 
-### For GNU compilers on Linux with the bash shell:
+### Environment Variables
 
+#### For GNU compilers on Linux with the bash shell:
 ```
 export FC=mpifort
 export CC=mpicc
 ```
-
-### For Intel Compilers on Linux with the bash shell:
-
+#### For Intel Compilers on Linux with the bash shell:
 ```
 export FC=mpiifort
 export CC=mpiicc
 ```
+MPI compiler wrappers may be named different on your system, so its best to ensure the compiler commands work prior to being set.
 
-### NetCDF is provided via the `nc-config` command:
+#### NetCDF is provided via the `nc-config` command:
 ```
 export NetCDF_ROOT=`nc-config --prefix`
 ```
 
-### If building with yaml parser (-DWITH_YAML)
+#### If building with yaml parser (-DWITH_YAML)
 ```
 export LIBYAML_ROOT=<your libyaml install directory>
 ```
 
-### Setting custom flags with the bash shell
-To override the default compiler flags:
+### Running CMake
+It's best to create a build directory inside of the FMS folder to avoid building on top of the source code.
+Once that is done, CMake can be ran to generate the necessary build files:
 ```
-export FCFLAGS="<fortran flags>"
-export CFLAGS="<c flags>"
+mkdir build && cd build
+cmake [-DWITH_YAML=on] ..
 ```
-In addition, the flag below must be included with the cmake command:
+
+### Setting a Build Type
+CMake uses "build types" to set compiler flags. By default (.ie no -DCMAKE_BUILD_TYPE="Type" argument when cmake is run), it will use the "Release" build type which corresponds the the prod/opt flags used by the GFDL mkmf templates.
+
+Similarly "Repro" and "Debug" also correspond to whatever options would be set by theircorresponding mkmf template files.
+
+To reproduce the old behavior for the cmake build (2025.03 and prior), the "ReleaseUFS" and "DebugUFS" will use the same flags as before.
+
+Please open an issue in the FMS repository if you have any issues or would like to request any changes to the current build type options.
+
+### Setting custom flags
+To override the default compiler flags, you can set them via CMake arguments:
 ```
-cmake <any other options> -DCMAKE_BUILD_TYPE=Debug ..
+cmake -DCMAKE_BUILD_TYPE="NoFlags" -DCMAKE_C_FLAGS="<c flags>" -DCMAKE_Fortran_FLAGS="<fortran flags>"
 ```
+By using the "NoFlags" build type, only necessary compilation flags will be added besides what is set via the cmake arguments.
 
 ## 2. Build and install FMS with CMake
 `<prefix>` is the full install directory for FMS provided by user
@@ -45,20 +58,25 @@ cmake <any other options> -DCMAKE_BUILD_TYPE=Debug ..
 cd FMS
 mkdir -p build && cd build
 cmake -DCMAKE_INSTALL_PREFIX=<prefix> ..
-make -j4
+make -j
 make install
 ```
 
 ### User configurable options:
-By default, FMS is built without `OpenMP`, in `single precision (r4)` and delivered in static library files.
+By default, FMS is built with `OpenMP` enabled and delivered in static library files.
+
+FMS has mixed precision real support for most interfaces. By default, one library will be created,
+`libfms`, that is compiled with r8 defaults but also contains overloaded r4 routines.
 
 The 64BIT and 32BIT precision options will build distinct libraries when enabled with the given default
-real size, libfms_r4 or libfms_r8.
+real size, libfms_r4 or libfms_r8. These option are provided for backwards compatibility, but are no longer
+supported by our development team, since mixed precision can now be used with a single library.
+Unit tests currently only work when no precision option is specified.
 
 The following build options are available:
 ```
--DOPENMP      "Build FMS with OpenMP support"        DEFAULT: OFF
--D32BIT       "Build 32-bit (r4) FMS library"        DEFAULT: ON
+-DOPENMP      "Build FMS with OpenMP support"        DEFAULT: ON
+-D32BIT       "Build 32-bit (r4) FMS library"        DEFAULT: OFF
 -D64BIT       "Build 64-bit (r8) FMS library"        DEFAULT: OFF
 -DFPIC        "Build with position independent code" DEFAULT: OFF
 -DSHARED_LIBS "Build shared/dynamic libraries"       DEFAULT: OFF
@@ -74,10 +92,10 @@ The following build options are available:
 
 ## 3. Installation structure
 
-When the above command finishes, the `<prefix>` will have an `include_r4` and a `lib` directory. The `lib ` directory will have these files:
+When the above command finishes, the `<prefix>` will have an `include` and a `lib` directory. The `lib ` directory will have these files:
 
 ```
-libfms_r4.a
+libfms.a
 cmake/fms/fms-targets.cmake
 cmake/fms/fms-targets-release.cmake
 cmake/fms/fms-config.cmake

CMakeLists.txt

@@ -30,12 +30,12 @@ project(FMS
 
 include(GNUInstallDirs)
 
-if(NOT CMAKE_BUILD_TYPE MATCHES "^(Debug|Release|RelWithDebInfo|MinSizeRel|DebugUFS)$")
+if(NOT CMAKE_BUILD_TYPE MATCHES "^(Debug|Release|RelWithDebInfo|MinSizeRel|DebugUFS|ReleaseUFS|NoFlags|Repro)$")
   message(STATUS "Setting build type to 'Release' as none was specified.")
   set(CMAKE_BUILD_TYPE
       "Release"
       CACHE STRING "Choose the type of build." FORCE)
-  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo" "DebugUFS")
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo" "DebugUFS" "ReleaseUFS" "NoFlags" "Repro")
 endif()
 
 if(NOT CMAKE_C_COMPILER_ID MATCHES "^(Intel|GNU|Clang|IntelLLVM)$")
@@ -52,15 +52,15 @@ endif()
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 
 # Build options
-option(OPENMP      "Build FMS with OpenMP support"        OFF)
+option(OPENMP      "Build FMS with OpenMP support"        ON)
 option(32BIT       "Build 32-bit (r4) FMS library"        OFF)
 option(64BIT       "Build 64-bit (r8) FMS library"        OFF)
 option(FPIC        "Build with position independent code" OFF)
 option(SHARED_LIBS "Build shared/dynamic libraries"       OFF)
 
 # Options for compiler definitions
 option(INTERNAL_FILE_NML     "Enable compiler definition -DINTERNAL_FILE_NML"      ON)
-option(ENABLE_QUAD_PRECISION "Enable compiler definition -DENABLE_QUAD_PRECISION"  ON)
+option(ENABLE_QUAD_PRECISION "Enable compiler definition -DENABLE_QUAD_PRECISION" OFF)
 option(PORTABLE_KINDS        "Enable compiler definition -DPORTABLE_KINDS"        OFF)
 option(GFS_PHYS              "Enable compiler definition -DGFS_PHYS"              OFF)
 option(LARGEFILE             "Enable compiler definition -Duse_LARGEFILE"         OFF)
@@ -343,7 +343,7 @@ foreach(kind ${kinds})
                                                  amip_interp/include)
   target_compile_definitions(${libTgt}_f PRIVATE "${fms_defs}")
   target_compile_definitions(${libTgt}_f PRIVATE "${${kind}_defs}")
-  set_target_properties(${libTgt}_f PROPERTIES COMPILE_FLAGS "${${kind}_flags}")
+  set_target_properties(${libTgt}_f PROPERTIES COMPILE_FLAGS ${${kind}_flags})
   set_target_properties(${libTgt}_f PROPERTIES Fortran_MODULE_DIRECTORY
                                                ${moduleDir})
   target_link_libraries(${libTgt}_f PRIVATE NetCDF::NetCDF_Fortran
@@ -485,7 +485,7 @@ if(NOT kinds)
                                                    amip_interp/include)
     target_compile_definitions(${libTgt}_f PRIVATE "${fms_defs}")
     target_compile_definitions(${libTgt}_f PRIVATE "${${kind}_defs}")
-    set_target_properties(${libTgt}_f PROPERTIES COMPILE_FLAGS "${${kind}_flags}")
+    set_target_properties(${libTgt}_f PROPERTIES COMPILE_FLAGS ${${kind}_flags})
     set_target_properties(${libTgt}_f PROPERTIES Fortran_MODULE_DIRECTORY
                                                  ${moduleDir})
     target_link_libraries(${libTgt}_f PRIVATE NetCDF::NetCDF_Fortran
@@ -551,6 +551,7 @@ if(NOT kinds)
 
     target_compile_definitions(${libTgt} PRIVATE "${fms_defs}")
     target_compile_definitions(${libTgt} PRIVATE "${${kind}_defs}")
+    set_target_properties(${libTgt}_f PROPERTIES COMPILE_FLAGS ${${kind}_flags})
 
     target_link_libraries(${libTgt} PUBLIC NetCDF::NetCDF_C
                                            NetCDF::NetCDF_Fortran
@@ -594,13 +595,14 @@ list(APPEND TEST_MODS_SRC
   test_fms/fms/test_fms.F90
   test_fms/fms2_io/argparse.F90
   test_fms/fms2_io/setup.F90
-#  test_fms/mosaic2/write_files.F90
+  test_fms/mosaic2/write_files.F90
   test_fms/mpp/compare_data_checksums.F90
   test_fms/mpp/compare_data_checksums_int.F90
   test_fms/mpp/fill_halo.F90
   test_fms/mpp/test_domains_utility_mod.F90
   test_fms/mpp/test_mpp_update_domains_int.F90
   test_fms/mpp/test_mpp_update_domains_real.F90
+  test_fms/mpp/test_mpp_update_domains_ad.F90
   test_fms/mpp/test_system_clock.F90)
 
 add_library(testLibs "${TEST_MODS_SRC}")
@@ -716,10 +718,8 @@ list(APPEND TEST_SRC_SINGLE_TARGET
   test_fms/mpp/test_mpp_sendrecv.F90
   test_fms/mpp/test_mpp_sum.F90
   test_fms/mpp/test_mpp_transmit.F90
+  test_fms/mpp/test_mpp_update_domains.F90
   test_fms/mpp/test_mpp_update_domains_ad.F90
-  test_fms/mpp/test_mpp_update_domains_int.F90
-  test_fms/mpp/test_mpp_update_domains_main.F90
-  test_fms/mpp/test_mpp_update_domains_real.F90
   test_fms/mpp/test_peset.F90
   test_fms/mpp/test_mpp_read_ascii_file.F90
   test_fms/mpp/test_read_input_nml.F90
@@ -774,7 +774,7 @@ foreach (testFile ${TEST_SRC_SINGLE_TARGET})
 
   add_executable(${TName} ${testFile})
   target_compile_definitions(${TName} PRIVATE "${r8_defs}")
-  set_target_properties(${TName} PROPERTIES COMPILE_FLAGS "${r8_flags}")
+  set_target_properties(${TName} PROPERTIES COMPILE_FLAGS ${r8_flags})
   target_link_libraries(${TName} PUBLIC FMS::fms
                                  PRIVATE testLibs
                                    )
@@ -801,14 +801,16 @@ foreach (testFile ${TEST_SRC_MULTI_TARGET})
 
   add_executable(${TName}_r8 ${testFile})
   target_compile_definitions(${TName}_r8 PRIVATE "${r8_defs}")
-  set_target_properties(${TName}_r8 PROPERTIES COMPILE_FLAGS "${r8_flags}")
+  set_target_properties(${TName}_r8 PROPERTIES COMPILE_FLAGS ${r8_flags})
   target_link_libraries(${TName}_r8 PUBLIC FMS::fms
                                     PRIVATE testLibs
                                     )
 
   add_executable(${TName}_r4 ${testFile})
   target_compile_definitions(${TName}_r4 PRIVATE "${r4_defs}")
-  set_target_properties(${TName}_r4 PROPERTIES COMPILE_FLAGS "${r4_flags}")
+  # seems counterintuitive but r4 tests use r8 default
+  # they specify kind values explicitly with the preprocessor where needed (TEST_FMS_KIND_)
+  set_target_properties(${TName}_r4 PROPERTIES COMPILE_FLAGS ${r8_flags})
   target_link_libraries(${TName}_r4 PUBLIC FMS::fms
                                     PRIVATE testLibs
                                     )
@@ -837,10 +839,15 @@ foreach (testFile ${TEST_SRC_MULTI_TARGET})
                                        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/test_fms/data_override/include
                                        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/test_fms/mosaic2
                                        PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+  #set macros used to test mixed precision
   target_compile_definitions(${TName}_r8 PRIVATE TEST_FMS_KIND_=r8_kind)
   target_compile_definitions(${TName}_r4 PRIVATE TEST_FMS_KIND_=r4_kind)
   target_compile_definitions(${TName}_r8 PRIVATE FMS_TEST_BC_TYPE_=bc)
   target_compile_definitions(${TName}_r4 PRIVATE FMS_TEST_BC_TYPE_=bc_r4)
+  target_compile_definitions(${TName}_r8 PRIVATE FMS_TEST_BC_TYPE_=bc)
+  target_compile_definitions(${TName}_r4 PRIVATE FMS_TEST_BC_TYPE_=bc_r4)
+  target_compile_definitions(${TName}_r8 PRIVATE WRITE_FILES_MOD_=write_files_r8)
+  target_compile_definitions(${TName}_r4 PRIVATE WRITE_FILES_MOD_=write_files_r4)
 endforeach ()
 
 # gather all test scripts
@@ -862,7 +869,9 @@ foreach (testScript ${TEST_SCRIPTS})
   set_property(TEST ${testName} PROPERTY LABELS ${testDirName})
   # set an environment variable so the scripts know to skip tests that use libyaml
   if(NOT WITH_YAML)
-    set_property(TEST ${testName} PROPERTY ENVIRONMENT skipflag=skip;parser_skip=skip;skip_yaml=yes)
+    set_tests_properties(${testName} PROPERTIES
+        ENVIRONMENT "skipflag=skip;parser_skip=skip;skip_yaml=yes"
+    )
   endif()
 endforeach()
 

cmake/compiler_flags_GNU_C.cmake

@@ -1,6 +1,11 @@
 # GNU C
-set(CMAKE_C_FLAGS_RELEASE "-O3")
-
-set(CMAKE_C_FLAGS_DEBUGUFS "-O0 -g")
+set(CMAKE_C_FLAGS "")
+set(CMAKE_C_FLAGS_RELEASE "-O2")
+set(CMAKE_C_FLAGS_REPRO "-O2")
+set(CMAKE_C_FLAGS_DEBUG "-O0 -g")
 
 set(CMAKE_C_LINK_FLAGS "")
+
+# ufs flags
+set(CMAKE_C_FLAGS_RELEASEUFS "-O3")
+set(CMAKE_C_FLAGS_DEBUGUFS "-O0 -g")

cmake/compiler_flags_GNU_Fortran.cmake

@@ -2,10 +2,15 @@
 set(r8_flags "-fdefault-real-8 -fdefault-double-8") # Fortran flags for 64BIT precision
 
 # GNU Fortran
-set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -fcray-pointer -fconvert=big-endian -ffree-line-length-none -fno-range-check -fbacktrace")
+set(CMAKE_Fortran_FLAGS "")
 
-set(CMAKE_Fortran_FLAGS_RELEASE "-O3 -funroll-all-loops -finline-functions")
+set(base_flags "-fcray-pointer -fdefault-double-8 -Waliasing -ffree-line-length-none -fno-range-check -fallow-argument-mismatch")
 
-set(CMAKE_Fortran_FLAGS_DEBUGUFS "-O0 -g -fcheck=bounds -ffpe-trap=invalid,zero,overflow,underflow" )
+set(CMAKE_Fortran_FLAGS_RELEASE "${base_flags} -O2 -fno-expensive-optimizations")
+set(CMAKE_Fortran_FLAGS_DEBUG "${base_flags} -O0 -g -W -fbounds-check -ffpe-trap=invalid,zero,overflow")
 
 set(CMAKE_Fortran_LINK_FLAGS "" )
+
+#ufs flags
+set(CMAKE_Fortran_FLAGS_RELEASEUFS "-O3 -funroll-all-loops -finline-functions")
+set(CMAKE_Fortran_FLAGS_DEBUGUFS "-O0 -g -fcheck=bounds -ffpe-trap=invalid,zero,overflow,underflow" )

cmake/compiler_flags_IntelLLVM_C.cmake

@@ -1,9 +1,21 @@
 # Intel LLVM based C
 
-set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -traceback")
+# flags from mkmf intel oneapi template
+# Release is prod/opt flags, debug and repro are the same
+set( CMAKE_C_FLAGS_BASE "-sox -traceback -march=core-avx-i")
 
-set( CMAKE_C_FLAGS_RELEASE "-qno-opt-dynamic-align -O2 -debug minimal")
+set( isa_flags "-march=core-avx-i")
 
-set( CMAKE_C_FLAGS_DEBUGUFS "-O0 -g -ftrapv")
+set( CMAKE_C_FLAGS "")
+
+set( CMAKE_C_FLAGS_RELEASE "-O2 -debug minimal ${CMAKE_C_FLAGS_BASE} ${isa_flags}")
+set( CMAKE_C_FLAGS_DEBUG "-O0 -g ${CMAKE_C_FLAGS_BASE}")
+set( CMAKE_C_FLAGS_REPRO "-O2 -debug minimal ${CMAKE_C_FLAGS_BASE} ${isa_flags}")
+set( CMAKE_C_FLAGS_NOFLAGS "")
 
 set( CMAKE_C_LINK_FLAGS "")
+
+# sets of flags used by ufs
+set( CMAKE_C_FLAGS_DEBUGUFS "-O0 -g -ftrapv -traceback")
+set( CMAKE_C_FLAGS_RELEASEUFS "-qno-opt-dynamic-align -O2 -debug minimal")
+

cmake/compiler_flags_IntelLLVM_Fortran.cmake

@@ -2,10 +2,22 @@
 set(r4_flags "-real-size 32") # Fortran flags for 32BIT precision
 set(r8_flags "-real-size 64") # Fortran flags for 64BIT precision
 
-set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -fpp -fno-alias -auto -safe-cray-ptr -ftz -assume byterecl -align array64byte -nowarn -traceback")
+set(isa_flag "-march=core-avx-i")
 
-set(CMAKE_Fortran_FLAGS_RELEASE "-O2 -debug minimal -nowarn -qoverride-limits -qno-opt-dynamic-align")
+# base flags from mkmf oneapi template
+set(CMAKE_Fortran_FLAGS_BASE "-fno-alias -auto -safe-cray-ptr -ftz -assume byterecl -i4 -nowarn -traceback")
 
-set(CMAKE_Fortran_FLAGS_DEBUGUFS "-g -O0 -check -check noarg_temp_created -check nopointer -warn -warn noerrors -fpe0 -ftrapuv")
+# set the default as empty so we can add on to it
+set(CMAKE_Fortran_FLAGS "")
 
-set(CMAKE_Fortran_LINK_FLAGS "")
+set(CMAKE_Fortran_FLAGS_RELEASE "-O3 -debug minimal -fp-model source ${isa_flag} ${CMAKE_Fortran_FLAGS_BASE}")
+set(CMAKE_Fortran_FLAGS_DEBUG "-g -O0 -check -check noarg_temp_created -check nopointer -check nouninit -warn -warn noerrors -fpe0 -ftrapuv ${isa_flag} ${CMAKE_Fortran_FLAGS_BASE}")
+set(CMAKE_Fortran_FLAGS_REPRO "-O2 -debug minimal -fp-model source ${isa_flag} ${CMAKE_Fortran_FLAGS_BASE}")
+set(CMAKE_Fortran_FLAGS_NOFLAGS "")
+
+set(CMAKE_Fortran_LINK_FLAGS "-fuse-ld=lld")
+
+# ufs flags 
+set(CMAKE_Fortran_SHARED_FLAGS "-fpp -fno-alias -auto -safe-cray-ptr -ftz -assume byterecl -align array64byte -nowarn -traceback")
+set(CMAKE_Fortran_FLAGS_RELEASEUFS "-O2 -debug minimal -nowarn -qoverride-limits -qno-opt-dynamic-align ${CMAKE_Fortran_SHARED_FLAGS}")
+set(CMAKE_Fortran_FLAGS_DEBUGUFS "-g -O0 -check -check noarg_temp_created -check nopointer -warn -warn noerrors -fpe0 -ftrapuv ${CMAKE_Fortran_SHARED_FLAGS}")

cmake/compiler_flags_Intel_C.cmake

@@ -1,8 +1,16 @@
 # Intel C
-set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -sox -traceback")
+set( CMAKE_C_FLAGS "")
 
-set( CMAKE_C_FLAGS_RELEASE "-qno-opt-dynamic-align -O2 -debug minimal -fp-model source")
+set( base_flags "-sox -traceback")
 
-set( CMAKE_C_FLAGS_DEBUGUFS "-O0 -g -ftrapuv")
+set( isa_flags "-march=core-avx-i -qno-opt-dynamic-align")
+
+set( CMAKE_C_FLAGS_RELEASE "-O2 -debug minimal ${base_flags} ${isa_flags}")
+set( CMAKE_C_FLAGS_REPRO "-O2 -debug minimal ${base_flags} ${isa_flags}")
+set( CMAKE_C_FLAGS_DEBUG "-O0 -g -ftrapuv ${base_flags} ${isa_flags}")
 
 set( CMAKE_C_LINK_FLAGS "")
+
+# ufs flags
+set( CMAKE_C_FLAGS_RELEASEUFS "-qno-opt-dynamic-align -O2 -debug minimal -fp-model source")
+set( CMAKE_C_FLAGS_DEBUGUFS "-O0 -g -ftrapuv")

cmake/compiler_flags_Intel_Fortran.cmake

@@ -3,10 +3,17 @@ set(r4_flags "-real-size 32") # Fortran flags for 32BIT precision
 set(r8_flags "-real-size 64") # Fortran flags for 64BIT precision
 set(r8_flags "${r8_flags} -no-prec-div -no-prec-sqrt")
 
-set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -fpp -fno-alias -auto -safe-cray-ptr -ftz -assume byterecl -align array64byte -nowarn -sox -traceback")
+set(isa_flags "-march=core-avx-i -qno-opt-dynamic-align")
 
-set(CMAKE_Fortran_FLAGS_RELEASE "-O2 -debug minimal -fp-model source -nowarn -qoverride-limits -qno-opt-dynamic-align -qopt-prefetch=3")
+set(CMAKE_Fortran_FLAGS "")
+set(CMAKE_Fortran_FLAGS_RELEASE "-O3 -debug minimal -fp-model source ${isa_flags}")
+set(CMAKE_Fortran_FLAGS_REPRO "-O2 -debug minimal -fp-model source ${isa_flags}")
+set(CMAKE_Fortran_FLAGS_DEBUG "-g -O0 -check -check noarg_temp_created -check nopointer -warn -warn noerrors -fpe0 -ftrapuv ${isa_flags}")
 
-set(CMAKE_Fortran_FLAGS_DEBUGUFS "-g -O0 -check -check noarg_temp_created -check nopointer -warn -warn noerrors -fpe0 -ftrapuv")
+# ufs flags
+set(ufs_flags_base "${CMAKE_Fortran_FLAGS} -fpp -fno-alias -auto -safe-cray-ptr -ftz -assume byterecl -align array64byte -nowarn -sox -traceback")
+
+set(CMAKE_Fortran_FLAGS_RELEASE "${ufs_flags_base} -O2 -debug minimal -fp-model source -nowarn -qoverride-limits -qno-opt-dynamic-align -qopt-prefetch=3")
+set(CMAKE_Fortran_FLAGS_DEBUGUFS "${ufs_flags_base} -g -O0 -check -check noarg_temp_created -check nopointer -warn -warn noerrors -fpe0 -ftrapuv")
 
 set(CMAKE_Fortran_LINK_FLAGS "")