diff --git a/packages/boutpp/fix_thirdparty_cmake_v5.0.0.patch b/packages/boutpp/fix_thirdparty_cmake_v5.0.0.patch new file mode 100644 index 0000000..a13aa44 --- /dev/null +++ b/packages/boutpp/fix_thirdparty_cmake_v5.0.0.patch @@ -0,0 +1,225 @@ +diff --git a/cmake/FindnetCDF.cmake b/cmake/FindnetCDF.cmake +index 824fb4a3c2..42dae86b14 100644 +--- a/cmake/FindnetCDF.cmake ++++ b/cmake/FindnetCDF.cmake +@@ -3,139 +3,138 @@ + # + # Find the netCDF IO library + # +-# This module uses the ``nc-config`` helper script as a hint for the +-# location of the netCDF libraries. It should be in your PATH. ++# This module uses the ``nc-config`` helper script as a hint for the location of ++# the netCDF libraries. It should be in your PATH. + # + # This module will define the following variables: + # + # :: + # +-# netCDF_FOUND - true if netCDF was found +-# netCDF_VERSION - netCDF version in format Major.Minor.Release +-# netCDF_INCLUDE_DIRS - Location of the netCDF includes +-# netCDF_LIBRARIES - Required libraries ++# netCDF_FOUND - true if netCDF was found netCDF_VERSION - netCDF version in ++# format Major.Minor.Release netCDF_INCLUDE_DIRS - Location of the netCDF ++# includes netCDF_LIBRARIES - Required libraries + # + # This module will also export the ``netCDF::netcdf`` target. + # + # You can also set the following variables: + # +-# ``netCDF_ROOT`` +-# Specify the path to the netCDF installation to use ++# ``netCDF_ROOT`` Specify the path to the netCDF installation to use + # +-# ``netCDF_DEBUG`` +-# Set to TRUE to get extra debugging output ++# ``netCDF_DEBUG`` Set to TRUE to get extra debugging output + + include(BOUT++functions) + include(CMakePrintHelpers) + ++if(NOT netCDF_ROOT AND EXISTS "${BOUT_USE_NETCDF}") ++ set(netCDF_ROOT "${BOUT_USE_NETCDF}") ++endif() ++ ++enable_language(C) + find_package(netCDF QUIET CONFIG) + +-if (netCDF_FOUND) ++if(netCDF_FOUND) + message(STATUS "netCDF CONFIG found") + set(netCDF_FOUND TRUE) +- if (NOT TARGET netCDF::netcdf) ++ if(NOT TARGET netCDF::netcdf) + bout_add_library_alias(netCDF::netcdf netcdf) + endif() +- if (netCDF_DEBUG) +- cmake_print_properties(TARGETS netcdf PROPERTIES LOCATION VERSION) +- endif (netCDF_DEBUG) ++ if(netCDF_DEBUG) ++ cmake_print_properties(TARGETS netcdf PROPERTIES LOCATION VERSION) ++ endif(netCDF_DEBUG) + return() + endif() + +-find_program(NC_CONFIG "nc-config" ++find_program( ++ NC_CONFIG "nc-config" + PATHS "${netCDF_ROOT}" + PATH_SUFFIXES bin + DOC "Path to netCDF C config helper" +- NO_DEFAULT_PATH +- ) ++ NO_DEFAULT_PATH) + +-find_program(NC_CONFIG "nc-config" +- DOC "Path to netCDF C config helper" +- ) ++find_program(NC_CONFIG "nc-config" DOC "Path to netCDF C config helper") + + get_filename_component(NC_CONFIG_TMP "${NC_CONFIG}" DIRECTORY) + get_filename_component(NC_CONFIG_LOCATION "${NC_CONFIG_TMP}" DIRECTORY) +-if (netCDF_DEBUG) ++if(netCDF_DEBUG) + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " +- " NC_CONFIG_LOCATION = ${NC_CONFIG_LOCATION}" +- " netCDF_ROOT = ${netCDF_ROOT}") ++ " NC_CONFIG_LOCATION = ${NC_CONFIG_LOCATION}" ++ " netCDF_ROOT = ${netCDF_ROOT}") + endif() + + bout_inspect_netcdf_config(NC_HINTS_INCLUDE_DIR "${NC_CONFIG}" "--includedir") + bout_inspect_netcdf_config(NC_HINTS_PREFIX "${NC_CONFIG}" "--prefix") + +-find_path(netCDF_C_INCLUDE_DIR ++find_path( ++ netCDF_C_INCLUDE_DIR + NAMES netcdf.h + DOC "netCDF C include directories" +- HINTS +- "${NC_HINTS_INCLUDE_DIR}" +- "${NC_HINTS_PREFIX}" +- "${NC_CONFIG_LOCATION}" +- PATH_SUFFIXES +- "include" +- ) +-if (netCDF_DEBUG) +- message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " +- " netCDF_C_INCLUDE_DIR = ${netCDF_C_INCLUDE_DIR}" +- " NC_HINTS_INCLUDE_DIR = ${NC_HINTS_INCLUDE_DIR}" +- " NC_HINTS_PREFIX = ${NC_HINTS_PREFIX}" +- ) ++ HINTS "${NC_HINTS_INCLUDE_DIR}" "${NC_HINTS_PREFIX}" "${NC_CONFIG_LOCATION}" ++ PATH_SUFFIXES "include") ++if(netCDF_DEBUG) ++ message( ++ STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " ++ " netCDF_C_INCLUDE_DIR = ${netCDF_C_INCLUDE_DIR}" ++ " NC_HINTS_INCLUDE_DIR = ${NC_HINTS_INCLUDE_DIR}" ++ " NC_HINTS_PREFIX = ${NC_HINTS_PREFIX}") + endif() + mark_as_advanced(netCDF_C_INCLUDE_DIR) + +-find_library(netCDF_C_LIBRARY ++find_library( ++ netCDF_C_LIBRARY + NAMES netcdf + DOC "netCDF C library" +- HINTS +- "${NC_HINTS_INCLUDE_DIR}" +- "${NC_HINTS_PREFIX}" +- "${NC_CONFIG_LOCATION}" +- PATH_SUFFIXES +- "lib" "lib64" +- ) +-if (netCDF_DEBUG) +- message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " +- " netCDF_C_LIBRARY = ${netCDF_C_LIBRARY}" +- " NC_HINTS_INCLUDE_DIR = ${NC_HINTS_INCLUDE_DIR}" +- " NC_HINTS_PREFIX = ${NC_HINTS_PREFIX}" +- ) ++ HINTS "${NC_HINTS_INCLUDE_DIR}" "${NC_HINTS_PREFIX}" "${NC_CONFIG_LOCATION}" ++ PATH_SUFFIXES "lib" "lib64") ++if(netCDF_DEBUG) ++ message( ++ STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " ++ " netCDF_C_LIBRARY = ${netCDF_C_LIBRARY}" ++ " NC_HINTS_INCLUDE_DIR = ${NC_HINTS_INCLUDE_DIR}" ++ " NC_HINTS_PREFIX = ${NC_HINTS_PREFIX}") + endif() + mark_as_advanced(netCDF_C_LIBRARY) + +-if (netCDF_C_INCLUDE_DIR) ++if(netCDF_C_INCLUDE_DIR) + file(STRINGS "${netCDF_C_INCLUDE_DIR}/netcdf_meta.h" _netcdf_version_lines +- REGEX "#define[ \t]+NC_VERSION_(MAJOR|MINOR|PATCH|NOTE)") +- string(REGEX REPLACE ".*NC_VERSION_MAJOR *\([0-9]*\).*" "\\1" _netcdf_version_major "${_netcdf_version_lines}") +- string(REGEX REPLACE ".*NC_VERSION_MINOR *\([0-9]*\).*" "\\1" _netcdf_version_minor "${_netcdf_version_lines}") +- string(REGEX REPLACE ".*NC_VERSION_PATCH *\([0-9]*\).*" "\\1" _netcdf_version_patch "${_netcdf_version_lines}") +- string(REGEX REPLACE ".*NC_VERSION_NOTE *\"\([^\"]*\)\".*" "\\1" _netcdf_version_note "${_netcdf_version_lines}") +- if (NOT _netcdf_version_note STREQUAL "") ++ REGEX "#define[ \t]+NC_VERSION_(MAJOR|MINOR|PATCH|NOTE)") ++ string(REGEX REPLACE ".*NC_VERSION_MAJOR *\([0-9]*\).*" "\\1" ++ _netcdf_version_major "${_netcdf_version_lines}") ++ string(REGEX REPLACE ".*NC_VERSION_MINOR *\([0-9]*\).*" "\\1" ++ _netcdf_version_minor "${_netcdf_version_lines}") ++ string(REGEX REPLACE ".*NC_VERSION_PATCH *\([0-9]*\).*" "\\1" ++ _netcdf_version_patch "${_netcdf_version_lines}") ++ string(REGEX REPLACE ".*NC_VERSION_NOTE *\"\([^\"]*\)\".*" "\\1" ++ _netcdf_version_note "${_netcdf_version_lines}") ++ if(NOT _netcdf_version_note STREQUAL "") + # Make development version compare higher than any patch level + set(_netcdf_version_note ".99") + endif() +- set(netCDF_VERSION "${_netcdf_version_major}.${_netcdf_version_minor}.${_netcdf_version_patch}${_netcdf_version_note}") ++ set(netCDF_VERSION ++ "${_netcdf_version_major}.${_netcdf_version_minor}.${_netcdf_version_patch}${_netcdf_version_note}" ++ ) + unset(_netcdf_version_major) + unset(_netcdf_version_minor) + unset(_netcdf_version_patch) + unset(_netcdf_version_note) + unset(_netcdf_version_lines) +-endif () ++endif() + + include(FindPackageHandleStandardArgs) +-find_package_handle_standard_args(netCDF ++find_package_handle_standard_args( ++ netCDF + REQUIRED_VARS netCDF_C_LIBRARY netCDF_C_INCLUDE_DIR + VERSION_VAR netCDF_VERSION) + +-if (netCDF_FOUND) ++if(netCDF_FOUND) + set(netCDF_INCLUDE_DIR "${netCDF_C_INCLUDE_DIR}") + set(netCDF_INCLUDE_DIRS "${netCDF_C_INCLUDE_DIR}") + set(netCDF_LIBRARIES "${netCDF_C_LIBRARY}") + +- if (NOT TARGET netCDF::netcdf) ++ if(NOT TARGET netCDF::netcdf) + add_library(netCDF::netcdf UNKNOWN IMPORTED) +- set_target_properties(netCDF::netcdf PROPERTIES +- IMPORTED_LOCATION "${netCDF_C_LIBRARY}" +- INTERFACE_INCLUDE_DIRECTORIES "${netCDF_C_INCLUDE_DIR}" +- ) +- endif () +-endif () ++ set_target_properties( ++ netCDF::netcdf ++ PROPERTIES IMPORTED_LOCATION "${netCDF_C_LIBRARY}" ++ INTERFACE_INCLUDE_DIRECTORIES "${netCDF_C_INCLUDE_DIR}") ++ endif() ++endif() +diff --git a/cmake/SetupBOUTThirdParty.cmake b/cmake/SetupBOUTThirdParty.cmake +index c04cc98a69..9ee32c7214 100644 +--- a/cmake/SetupBOUTThirdParty.cmake ++++ b/cmake/SetupBOUTThirdParty.cmake +@@ -213,6 +213,7 @@ option(BOUT_DOWNLOAD_SUNDIALS "Download and build SUNDIALS" OFF) + cmake_dependent_option(BOUT_USE_SUNDIALS "Enable support for SUNDIALS time solvers" OFF + "NOT BOUT_DOWNLOAD_SUNDIALS" ON) + if (BOUT_USE_SUNDIALS) ++ enable_language(C) + if (BOUT_DOWNLOAD_SUNDIALS) + message(STATUS "Downloading and configuring SUNDIALS") + include(FetchContent) diff --git a/packages/boutpp/fix_thirdparty_cmake_v5.1.x.patch b/packages/boutpp/fix_thirdparty_cmake_v5.1.x.patch new file mode 100644 index 0000000..9b77c1c --- /dev/null +++ b/packages/boutpp/fix_thirdparty_cmake_v5.1.x.patch @@ -0,0 +1,24 @@ +diff --git a/cmake/FindnetCDF.cmake b/cmake/FindnetCDF.cmake +index 393c57549b..361095954e 100644 +--- a/cmake/FindnetCDF.cmake ++++ b/cmake/FindnetCDF.cmake +@@ -32,6 +32,7 @@ if (NOT netCDF_ROOT AND EXISTS "${BOUT_USE_NETCDF}") + set(netCDF_ROOT "${BOUT_USE_NETCDF}") + endif() + ++enable_language(C) + find_package(netCDF QUIET CONFIG) + + if (netCDF_FOUND) +diff --git a/cmake/SetupBOUTThirdParty.cmake b/cmake/SetupBOUTThirdParty.cmake +index 78dfc6b56e..37af2337d9 100644 +--- a/cmake/SetupBOUTThirdParty.cmake ++++ b/cmake/SetupBOUTThirdParty.cmake +@@ -233,6 +233,7 @@ option(BOUT_DOWNLOAD_SUNDIALS "Download and build SUNDIALS" OFF) + cmake_dependent_option(BOUT_USE_SUNDIALS "Enable support for SUNDIALS time solvers" OFF + "NOT BOUT_DOWNLOAD_SUNDIALS" ON) + if (BOUT_USE_SUNDIALS) ++ enable_language(C) + if (BOUT_DOWNLOAD_SUNDIALS) + message(STATUS "Downloading and configuring SUNDIALS") + include(FetchContent) diff --git a/packages/boutpp/package.py b/packages/boutpp/package.py new file mode 100644 index 0000000..eeef8e3 --- /dev/null +++ b/packages/boutpp/package.py @@ -0,0 +1,206 @@ +# Copyright 2013-2024 Lawrence Livermore National Security, LLC and other +# Spack Project Developers. See the top-level COPYRIGHT file for details. +# +# SPDX-License-Identifier: (LGPL-3.0-only) + +# ---------------------------------------------------------------------------- + +from spack.package import CMakePackage, conflicts, depends_on, patch, variant, version + + +class Boutpp(CMakePackage): + """BOUT++ is a framework for writing fluid and plasma simulations in curvilinear geometry. It is intended to be quite modular, with a variety of numerical methods and time-integration solvers available. BOUT++ is primarily designed and tested with reduced plasma fluid models in mind, but it can evolve any number of equations, with equations appearing in a readable form.""" + + homepage = "https://bout-dev.readthedocs.io" + git = "https://github.com/boutproject/BOUT-dev" + url = "https://github.com/boutproject/BOUT-dev/releases/download/v5.1.0/BOUT++-v5.1.0.tar.gz" + + maintainers("oparry-ukaea") + + license("LGPL-3.0-only") + + version("develop", branch="next", submodules=True) + version("master", branch="master", submodules=True, preferred=True) + + # Include tagged versions that use CMake (5.0.0 onwards) + tagged_versions = ["5.0.0", "5.1.0", "5.1.1", "5.2.0"] + for v in tagged_versions: + version(v, tag=f"v{v}", submodules=True) + + # Patches + patch("fix_thirdparty_cmake_v5.0.0.patch", when="@5.0.0") + patch("fix_thirdparty_cmake_v5.1.x.patch", when="@5.1") + + # Variants + variant("adios2", default=False, description="Builds with ADIOS2 support.") + variant("backtrace", default=True, description="Enable backtrace.") + variant("builddocs", default=False, description="Builds the documentation.") + variant("buildexamples", default=False, description="Builds the examples.") + variant( + "buildtests", + description="Choose whether to build the standard set of tests ('default'), the complete set ('all'), or none at all ('none').", + values=("all", "default", "none"), + default="none", + multi=True, + ) + variant("caliper", default=False, description="Builds with Caliper support.") + variant( + "check", + description="Sets the CHECK variable which controls the level of internal runtime checking.", + values=("0", "1", "2", "3", "4"), + default="2", + multi=True, + ) + variant("cuda", default=False, description="Builds with CUDA support.") + variant("fftw", default=True, description="Builds with FFTW support.") + variant("hypre", default=False, description="Builds with Hypre support.") + variant("lapack", default=False, description="Builds with LAPACK support.") + variant("metric3d", default=False, description="Enable 3D metric support.") + variant("netcdf", default=True, description="Enable support for NetCDF output.") + variant("openmp", default=False, description="Enable OpenMP support.") + variant("petsc", default=False, description="Builds with PETSc support.") + variant("python", default=False, description="Builds with Python support.") + variant("raja", default=False, description="Builds with RAJA support.") + variant("sanitize_address", default=False, description="Enable address sanitizer.") + variant("sanitize_leak", default=False, description="Enable leak sanitizer.") + variant("sanitize_memory", default=False, description="Enable memory sanitizer.") + variant("sanitize_thread", default=False, description="Enable thread sanitizer.") + variant( + "sanitize_undefined", + default=False, + description="Enable undefined behavior sanitizer.", + ) + variant("scorep", default=False, description="Builds with Score-P support.") + variant("slepc", default=False, description="Builds with SLEPC support.") + variant("shared", default=True, description="Build shared libraries.") + variant("sigfpe", default=False, description="Signal floating point exceptions.") + variant("signal", default=True, description="Signal handling.") + variant("sundials", default=False, description="Builds with SUNDIALS support.") + variant("track", default=True, description="Enable field name tracking.") + variant("umpire", default=False, description="Builds with Umpire support.") + variant("uuid", default=True, description="Use system UUID generator") + + # Fixed dependencies + depends_on("c", type="build") + depends_on("cxx", type="build") + depends_on("cmake@3.17:", type="build") + depends_on("mpi", type=("build", "link", "run")) + + # Simple build dependencies + # Derived from variants with the same name, an optional version specifier, but no special variant options of their own + simple_deps = [ + "adios2", + "caliper", + "cuda", + "fftw", + "hypre", + "lapack", + "python", + "raja", + "scorep", + "slepc", + "sundials", + "umpire", + ] + simple_dep_versions = {"sundials": "2.6:6.7.0"} + for dep in simple_deps: + dep_spec = ( + dep + if not dep in simple_dep_versions + else f"{dep}@{simple_dep_versions[dep]}" + ) + depends_on(dep_spec, type=("build", "link"), when=f"+{dep}") + + # Other dependencies affected by variants + depends_on("netcdf-cxx4", type=("build", "link"), when="+netcdf") + depends_on("py-cython", type=("build", "link"), when="+python") + depends_on("py-jinja2", type=("build", "link"), when="+python") + depends_on("py-numpy", type=("build", "link"), when="+python") + + # PETSc dependency + # Always use MPI and specify supported version range (across all BOUT versions) + depends_on("petsc@3.7:3.23+mpi", type=("build", "link"), when="+petsc") + # BOUT v5.0.0 won't build with PETSc v3.18 onwards + conflicts("petsc@3.18:", when="+petsc@:5.0.0") + + def cmake_args(self): + # Definitions controlled by variants + variant_defs = { + "BOUT_USE_ADIOS2": "adios2", + "BOUT_ENABLE_BACKTRACE": "backtrace", + "BOUT_BUILD_DOCS": "builddocs", + "BOUT_BUILD_EXAMPLES": "buildexamples", + "BOUT_ENABLE_CALIPER": "caliper", + "CHECK": "check", + "BOUT_ENABLE_CUDA": "cuda", + "BOUT_USE_HYPRE": "hypre", + "BOUT_USE_LAPACK": "lapack", + "BOUT_ENABLE_METRIC_3D": "metric3d", + "BOUT_USE_NETCDF": "netcdf", + "BOUT_ENABLE_OPENMP": "openmp", + "BOUT_USE_PETSC": "petsc", + "BOUT_ENABLE_PYTHON": "python", + "BOUT_ENABLE_RAJA": "raja", + "ENABLE_SANITIZER_ADDRESS": "sanitize_address", + "ENABLE_SANITIZER_LEAK": "sanitize_leak", + "ENABLE_SANITIZER_MEMORY": "sanitize_memory", + "ENABLE_SANITIZER_THREAD": "sanitize_thread", + "ENABLE_SANITIZER_UNDEFINED_BEH": "sanitize_undefined", + "BOUT_USE_SCOREP": "scorep", + "BOUT_USE_SLEPC": "slepc", + "BUILD_SHARED_LIBS": "shared", + "BOUT_ENABLE_SIGFPE": "sigfpe", + "BOUT_ENABLE_SIGNAL": "signal", + "BOUT_USE_SUNDIALS": "sundials", + "BOUT_ENABLE_TRACK": "track", + "BOUT_ENABLE_UMPIRE": "umpire", + "BOUT_USE_UUID_SYSTEM_GENERATOR": "uuid", + } + variant_args = [ + self.define_from_variant(def_str, var_str) + for def_str, var_str in variant_defs.items() + ] + + # Build tests unless variant buildtests=none + variant_args.append( + self.define( + "BOUT_TESTS", self.spec.variants["buildtests"].value[0] != "none" + ) + ) + # Build ALL tests if variant buildtests=all + variant_args.append( + self.define( + "BOUT_ENABLE_ALL_TESTS", + self.spec.variants["buildtests"].value[0] == "all", + ) + ) + + # Always use these definitions + fixed_args = [ + # Don't download any dependencies (use spack to resolve them instead) + self.define("BOUT_DOWNLOAD_ADIOS2", False), + self.define("BOUT_DOWNLOAD_NETCDF_CXX4", False), + self.define("BOUT_DOWNLOAD_SUNDIALS", False), + # Always build with MPI + self.define("BOUT_ENABLE_MPI", True), + # Avoid any confusion between conda and spack + self.define("BOUT_IGNORE_CONDA_ENV",True), + # Ensure bout submodules are up to date before building + self.define("BOUT_UPDATE_GIT_SUBMODULE", True), + # Always build with PVODE + self.define("BOUT_USE_PVODE", True), + # Don't install gtest (resolve dependency with spack instead) + self.define("INSTALL_GTEST", False), + ] + # There are problems with how CMake finds the glibc/standalone versions + # of gettext (see + # https://github.com/boutproject/hermes-3/issues/356#issuecomment-2999715879). + # Workaround is to turn off natural language support for now. + fixed_args.append(self.define("BOUT_USE_NLS", False)) + + # Concatenate different arg types and return + args = [] + args.extend(fixed_args) + args.extend(variant_args) + + return args diff --git a/packages/hermes-3/package.py b/packages/hermes-3/package.py index a1add45..189649c 100644 --- a/packages/hermes-3/package.py +++ b/packages/hermes-3/package.py @@ -3,7 +3,7 @@ # # SPDX-License-Identifier: (Apache-2.0 OR MIT) -from spack import * +from spack.package import CMakePackage, depends_on, maintainers, variant, version import spack.repo @@ -51,8 +51,6 @@ class Hermes3(CMakePackage): values=("MC", "MinMod"), multi=False, ) - variant("petsc", default=False, description="Builds with PETSc support.") - variant("sundials", default=True, description="Builds with SUNDIALS support.") variant( "xhermes", default=True, description="Builds xhermes (required for some tests)." ) @@ -63,44 +61,34 @@ class Hermes3(CMakePackage): validator=check_pkg_available, ) - # Always-required dependencies - # depends_on("adios2", type=("build", "link")) depends_on("cmake@3.24:", type="build") depends_on("fftw", type=("build", "link")) depends_on("mpi", type=("build", "link", "run")) + depends_on("boutpp", type=("build", "link")) depends_on("netcdf-cxx4", type=("build", "link")) depends_on("py-boutdata@0.3.0:", type=("run")) - # Needed for BOUT++ python bindings, should be able to move this when BOUT is split into a separate package - depends_on("py-numpy", type=("build", "link")) # Variant-controlled dependencies - depends_on( - "petsc+hypre+mpi~debug~fortran", when="+petsc", type=("build", "link") - ) depends_on("py-xhermes", when="+xhermes", type=("run")) - depends_on("sundials", when="+sundials", type=("build", "link")) if vantagereactions_pkg_available(): depends_on("vantagereactions", when="+vantagereactions", type=("build", "link")) def cmake_args(self): - # ON/OFF definitions controlled by variants - binary_def_variants = { + # Definitions controlled by variants + variant_defs = { "HERMES_SLOPE_LIMITER": "limiter", - "BOUT_USE_PETSC": "petsc", - "BOUT_USE_SUNDIALS": "sundials", "HERMES_USE_VANTAGE": "vantagereactions", } - variants_args = [ + variant_args = [ self.define_from_variant(def_str, var_str) - for def_str, var_str in binary_def_variants.items() + for def_str, var_str in variant_defs.items() ] + fixed_args = [self.define("HERMES_BUILD_BOUT", False)] + # Concatenate different arg types and return args = [] - args.extend(variants_args) - # There are problems with how CMake finds the - # glibc/standalone versions of gettext. See - # https://github.com/boutproject/hermes-3/issues/356#issuecomment-2999715879 - args.append(self.define("BOUT_USE_NLS", False)) + args.extend(fixed_args) + args.extend(variant_args) return args