mirror of
https://github.com/Cantera/cantera.git
synced 2025-02-25 18:55:29 -06:00
2169 lines
85 KiB
Python
2169 lines
85 KiB
Python
"""
|
|
SCons build script for Cantera
|
|
|
|
Basic usage:
|
|
|
|
'scons help' - Show this help message.
|
|
|
|
'scons build' - Compile Cantera and the language interfaces using
|
|
default options.
|
|
|
|
'scons clean' - Delete files created while building Cantera.
|
|
|
|
'scons install' - Install Cantera.
|
|
|
|
'scons uninstall' - Uninstall Cantera.
|
|
|
|
'scons test' - Run all tests which did not previously pass or for which the
|
|
results may have changed.
|
|
|
|
'scons test-reset' - Reset the passing status of all tests.
|
|
|
|
'scons test-clean' - Delete files created while running the tests.
|
|
|
|
'scons test-help' - List available tests.
|
|
|
|
'scons test-{python,gtest,legacy}' - Run all Python, GTest, or legacy
|
|
(test_problems) test cases, respectively.
|
|
|
|
'scons test-NAME' - Run the test named "NAME".
|
|
|
|
'scons build-NAME' - Build the program for the test named "NAME".
|
|
|
|
'scons build-tests' - Build the programs for all tests.
|
|
|
|
'scons samples' - Compile the C++ and Fortran samples.
|
|
|
|
'scons msi' - Build a Windows installer (.msi) for Cantera.
|
|
|
|
'scons sphinx' - Build the Sphinx documentation
|
|
|
|
'scons doxygen' - Build the Doxygen documentation
|
|
|
|
Additional command options:
|
|
|
|
'scons help --options' - Print a description of user-specifiable options.
|
|
|
|
'scons help --list-options' - Print formatted list of available options.
|
|
|
|
'scons help --option=<opt>' - Print the description of a specific option
|
|
with name <opt>, for example
|
|
'scons help --option=prefix'
|
|
|
|
'scons <command> -j<X>' - Short form of '--jobs=<X>'. Run the <command> using '<X>'
|
|
parallel jobs, for example 'scons build -j4'
|
|
|
|
'scons <command> -s' - Short form of '--silent' (or '--quiet'). Suppresses output.
|
|
"""
|
|
# Note that 'scons help' supports additional command options that are intended for
|
|
# internal use (debugging or reST parsing of options) and thus are not listed above:
|
|
# --defaults ... list default values for all supported platforms
|
|
# --restructured-text ... format configuration as reST
|
|
# --dev ... add '-dev' to reST output
|
|
# --output=<fname> ... send output to file (reST only)
|
|
#
|
|
# Other features not listed above:
|
|
# 'scons sdist' - Build PyPI packages.
|
|
# 'scons <command> dump' - Dump the state of the SCons environment to the
|
|
# screen instead of doing <command>, for example
|
|
# 'scons build dump'. For debugging purposes.
|
|
|
|
from pathlib import Path
|
|
import sys
|
|
import os
|
|
import platform
|
|
import atexit
|
|
import subprocess
|
|
import re
|
|
import textwrap
|
|
from copy import deepcopy
|
|
from packaging.specifiers import SpecifierSet
|
|
from packaging.version import parse as parse_version
|
|
import SCons
|
|
|
|
from buildutils import (Option, PathOption, BoolOption, EnumOption, Configuration,
|
|
logger, remove_directory, remove_file, test_results,
|
|
add_RegressionTest, get_command_output, listify, which,
|
|
ConfigBuilder, multi_glob, quoted, add_system_include,
|
|
checkout_submodule, check_for_python, check_sundials,
|
|
config_error, run_preprocessor, make_relative_path_absolute)
|
|
|
|
# ensure that Python and SCons versions are sufficient for the build process
|
|
EnsurePythonVersion(3, 10)
|
|
EnsureSConsVersion(4, 0, 0)
|
|
|
|
if not COMMAND_LINE_TARGETS:
|
|
# Print usage help
|
|
logger.error("Missing command argument: type 'scons help' for information.")
|
|
sys.exit(1)
|
|
|
|
if os.name not in ["nt", "posix"]:
|
|
logger.error(f"Unrecognized operating system {os.name!r}")
|
|
sys.exit(1)
|
|
|
|
valid_commands = ("build", "clean", "install", "uninstall",
|
|
"help", "msi", "samples", "sphinx", "doxygen", "dump",
|
|
"sdist")
|
|
|
|
# set default logging level
|
|
if GetOption("silent"):
|
|
logger.logger.setLevel("ERROR")
|
|
else:
|
|
logger.logger.setLevel("INFO")
|
|
|
|
for command in COMMAND_LINE_TARGETS:
|
|
if command not in valid_commands and not command.startswith(('test', 'build-')):
|
|
logger.error(f"Unrecognized command line target: {command!r}")
|
|
sys.exit(1)
|
|
|
|
if "clean" in COMMAND_LINE_TARGETS:
|
|
remove_directory("build")
|
|
remove_directory("stage")
|
|
remove_directory(".sconf_temp")
|
|
remove_directory("test/work")
|
|
remove_file(".sconsign.dblite")
|
|
remove_file("include/cantera/base/config.h")
|
|
remove_file("src/extensions/PythonExtensionManager.os")
|
|
remove_file("src/extensions/delegator.h")
|
|
remove_file("src/pch/system.h.gch")
|
|
remove_directory("include/cantera/ext")
|
|
remove_file("config.log")
|
|
remove_directory("doc/sphinx/cython/examples")
|
|
remove_file("doc/sphinx/cython/examples.rst")
|
|
for name in Path(".").glob("*.msi"):
|
|
remove_file(name)
|
|
for name in Path("site_scons").glob("**/*.pyc"):
|
|
remove_file(name)
|
|
for name in Path("include/cantera/clib_experimental").glob("*.h"):
|
|
remove_file(name)
|
|
for name in Path("src/clib_experimental").glob("*.cpp"):
|
|
remove_file(name)
|
|
|
|
logger.status("Done removing output files.", print_level=False)
|
|
|
|
if COMMAND_LINE_TARGETS == ["clean"]:
|
|
# Just exit if there's nothing else to do
|
|
sys.exit(0)
|
|
else:
|
|
Alias("clean", [])
|
|
|
|
if "test-clean" in COMMAND_LINE_TARGETS:
|
|
remove_directory("build/test")
|
|
remove_directory("test/work")
|
|
remove_directory("build/python_local")
|
|
|
|
python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
|
|
logger.info(
|
|
f"SCons {SCons.__version__} is using the following Python interpreter:\n"
|
|
f" {sys.executable} (Python {python_version})", print_level=False)
|
|
|
|
cantera_version = "3.2.0a1"
|
|
# For use where pre-release tags are not permitted (MSI, sonames)
|
|
cantera_pure_version = re.match(r'(\d+\.\d+\.\d+)', cantera_version).group(0)
|
|
cantera_short_version = re.match(r'(\d+\.\d+)', cantera_version).group(0)
|
|
|
|
cantera_git_commit = os.environ.get("CT_GIT_COMMIT")
|
|
if not cantera_git_commit:
|
|
try:
|
|
cantera_git_commit = get_command_output("git", "rev-parse", "--short", "HEAD")
|
|
logger.info(f"Building Cantera from git commit {cantera_git_commit!r}")
|
|
except (subprocess.CalledProcessError, FileNotFoundError):
|
|
cantera_git_commit = "unknown"
|
|
else:
|
|
logger.info(f"Building Cantera from git commit {cantera_git_commit!r}")
|
|
|
|
|
|
# Python Package Settings
|
|
python_min_version = parse_version("3.10")
|
|
# Newest Python version not supported/tested by Cantera
|
|
python_max_version = parse_version("3.14")
|
|
# The string is used to set python_requires in setup.cfg.in
|
|
py_requires_ver_str = f">={python_min_version},<{python_max_version}"
|
|
|
|
if "sdist" in COMMAND_LINE_TARGETS:
|
|
if "clean" in COMMAND_LINE_TARGETS:
|
|
COMMAND_LINE_TARGETS.remove("clean")
|
|
if len(COMMAND_LINE_TARGETS) > 1:
|
|
logger.error("'sdist' target cannot be built simultaneously with other targets.")
|
|
sys.exit(1)
|
|
logger.info("Copying files for sdist...")
|
|
subprocess.run(
|
|
[
|
|
sys.executable,
|
|
"interfaces/python_sdist/build_sdist.py",
|
|
os.getcwd(),
|
|
"/".join((os.getcwd(), "build", "python_sdist")),
|
|
cantera_git_commit,
|
|
py_requires_ver_str,
|
|
cantera_version,
|
|
cantera_short_version,
|
|
],
|
|
check=True,
|
|
)
|
|
subprocess.run(
|
|
[
|
|
sys.executable,
|
|
"-m",
|
|
"build",
|
|
"--sdist",
|
|
"/".join((os.getcwd(), "build", "python_sdist")),
|
|
],
|
|
)
|
|
message = textwrap.dedent(f"""
|
|
****************************************************************
|
|
Python sdist 'Cantera-{cantera_version}.tar.gz' created successfully.
|
|
The sdist file is in the 'build/python_sdist/dist' directory.
|
|
****************************************************************
|
|
""")
|
|
logger.info(message, print_level=False)
|
|
sys.exit(0)
|
|
|
|
# ******************************************
|
|
# *** Specify defaults for SCons options ***
|
|
# ******************************************
|
|
|
|
windows_options = [
|
|
Option(
|
|
"msvc_version",
|
|
"""Version of Visual Studio to use. The default is the newest installed version.
|
|
Note that since multiple MSVC toolsets can be installed for a single version of
|
|
Visual Studio, you probably want to use ``msvc_toolset_version`` unless you
|
|
specifically installed multiple versions of Visual Studio. Windows MSVC only.
|
|
""",
|
|
""),
|
|
Option(
|
|
"msvc_toolset_version",
|
|
"""Version of the MSVC toolset to use. The default is the default version for
|
|
the given ``msvc_version``. Note that the toolset selected here must be
|
|
installed in the MSVC version selected by ``msvc_version``. The default
|
|
toolsets associated with various Visual Studio versions are:
|
|
|
|
* '14.1' ('14.1x'): Visual Studio 2017
|
|
* '14.2' ('14.2x'): Visual Studio 2019
|
|
* '14.3' ('14.3x'): Visual Studio 2022.
|
|
|
|
For version numbers in parentheses, 'x' is a placeholder for a minor version
|
|
number. Windows MSVC only.""",
|
|
""),
|
|
EnumOption(
|
|
"target_arch",
|
|
"""Target architecture. The default is the same architecture as the
|
|
installed version of Python. Windows only.""",
|
|
{"Windows": "amd64"},
|
|
("amd64", "x86")),
|
|
EnumOption(
|
|
"toolchain",
|
|
"""The preferred compiler toolchain. If MSVC is not on the path but
|
|
'g++' is on the path, 'mingw' is used as a backup. Windows only.""",
|
|
{"Windows": "msvc"},
|
|
("msvc", "mingw", "intel")),
|
|
]
|
|
|
|
config_options = [
|
|
Option(
|
|
"AR",
|
|
"The archiver to use.",
|
|
"${AR}"),
|
|
Option(
|
|
"CXX",
|
|
"The C++ compiler to use.",
|
|
"${CXX}"),
|
|
Option(
|
|
"cxx_flags",
|
|
"""Compiler flags passed to the C++ compiler only. Separate multiple
|
|
options with spaces, for example, "cxx_flags='-g -Wextra -O3 -std=c++20'"
|
|
""",
|
|
{
|
|
"cl": "/EHsc /std:c++17 /utf-8",
|
|
"default": "-std=c++17"
|
|
}),
|
|
Option(
|
|
"CC",
|
|
"The C compiler to use. This is only used to compile CVODE.",
|
|
"${CC}"),
|
|
Option(
|
|
"cc_flags",
|
|
"""Compiler flags passed to both the C and C++ compilers, regardless of
|
|
optimization level.""",
|
|
{
|
|
"cl": "/MD /nologo /D_SCL_SECURE_NO_WARNINGS /D_CRT_SECURE_NO_WARNINGS",
|
|
"clang": "-fcolor-diagnostics",
|
|
"default": "",
|
|
}),
|
|
PathOption(
|
|
"prefix",
|
|
r"""Set this to the directory where Cantera should be installed. If the Python
|
|
executable found during compilation is managed by 'conda', the installation
|
|
'prefix' defaults to the corresponding environment and the 'conda' layout
|
|
will be used for installation (specifying any of the options 'prefix',
|
|
'python_prefix', 'python_cmd', or 'layout' will override this default). On
|
|
Windows systems, '$ProgramFiles' typically refers to "C:\Program Files".""",
|
|
{"Windows": r"$ProgramFiles\Cantera", "default": "/usr/local"},
|
|
PathVariable.PathAccept),
|
|
PathOption(
|
|
"libdirname",
|
|
"""Set this to the directory where Cantera libraries should be installed.
|
|
Some distributions (for example, Fedora/RHEL) use 'lib64' instead of 'lib'
|
|
on 64-bit systems or could use some other library directory name instead of
|
|
'lib', depending on architecture and profile (for example, Gentoo 'libx32'
|
|
on x32 profile). If the user didn't set the 'libdirname' configuration
|
|
variable, set it to the default value 'lib'""",
|
|
"lib", PathVariable.PathAccept),
|
|
EnumOption(
|
|
"python_package",
|
|
"""Set this to 'y' to build the Python interface, including conversion
|
|
scripts for CHEMKIN, CTI, and CTML input files. Set this to 'n' to
|
|
skip building the Python interface. Building the Python interface
|
|
requires the Python headers, Cython, and NumPy. Testing the Python
|
|
interface further requires ruamel.yaml and pytest. The default
|
|
behavior is to build the full Python module for whichever version of
|
|
Python is running SCons if the required prerequisites (NumPy and
|
|
Cython) are installed.""",
|
|
"default", ("n", "y", "default")),
|
|
PathOption(
|
|
"python_cmd",
|
|
"""Cantera needs to know where to find the Python interpreter. If
|
|
'PYTHON_CMD' is not set, then the configuration process will use the
|
|
same Python interpreter being used by SCons.""",
|
|
"${PYTHON_CMD}",
|
|
PathVariable.PathAccept),
|
|
PathOption(
|
|
"python_prefix",
|
|
"""Use this option if you want to install the Cantera Python package to
|
|
an alternate location. On Unix-like systems, the default is the same
|
|
as the 'prefix' option. If the 'python_prefix' option is set to
|
|
the empty string or the 'prefix' option is not set, then the package
|
|
will be installed to the system default 'site-packages' directory.
|
|
To install to the current user's 'site-packages' directory, use
|
|
'python_prefix=USER'.""",
|
|
{"default": ""},
|
|
PathVariable.PathAccept),
|
|
EnumOption(
|
|
"f90_interface",
|
|
"""This variable controls whether the Fortran 90/95 interface will be
|
|
built. If set to 'default', the builder will look for a compatible
|
|
Fortran compiler in the 'PATH' environment variable, and compile
|
|
the Fortran 90 interface if one is found.""",
|
|
"default", ("y", "n", "default")),
|
|
PathOption(
|
|
"FORTRAN",
|
|
"""The Fortran (90) compiler. If unspecified, the builder will look for a
|
|
compatible compiler (pgfortran, gfortran, ifort, ifx, g95) in the 'PATH'
|
|
environment variable. Used only for compiling the Fortran 90 interface.""",
|
|
"", PathVariable.PathAccept),
|
|
Option(
|
|
"FORTRANFLAGS",
|
|
"Compilation options for the Fortran (90) compiler.",
|
|
"-O3"),
|
|
BoolOption(
|
|
"coverage",
|
|
"""Enable collection of code coverage information with gcov.
|
|
Available only when compiling with gcc.""",
|
|
False),
|
|
BoolOption(
|
|
"doxygen_docs",
|
|
"Build HTML documentation for the C++ interface using Doxygen.",
|
|
False),
|
|
BoolOption(
|
|
"sphinx_docs",
|
|
"Build HTML documentation for Cantera using Sphinx.",
|
|
False),
|
|
BoolOption(
|
|
"clib_experimental",
|
|
"""Build experimental CLib. Requires running 'scons doxygen' and CLib code
|
|
generation via 'python3 interfaces/sourcegen/run.py --api=clib --output=.'
|
|
prior to 'scons build' command.
|
|
""",
|
|
False),
|
|
BoolOption(
|
|
"run_examples",
|
|
"""Run examples to generate plots and outputs for Sphinx Gallery. Disable to
|
|
speed up doc builds when not working on the examples or if dependencies of
|
|
the examples are not available.""",
|
|
True),
|
|
PathOption(
|
|
"sphinx_cmd",
|
|
"Command to use for building the Sphinx documentation.",
|
|
"sphinx-build", PathVariable.PathAccept),
|
|
Option(
|
|
"sphinx_options",
|
|
"""Options passed to the 'sphinx_cmd' command line. Separate multiple
|
|
options with spaces, for example, "-W --keep-going".""",
|
|
"-W --keep-going"),
|
|
BoolOption(
|
|
"example_data",
|
|
"""Install data files used in examples. These files will be accessible on the
|
|
Cantera data path using a prefix, such as 'example_data/mech.yaml'""",
|
|
True,
|
|
),
|
|
EnumOption(
|
|
"system_eigen",
|
|
"""Select whether to use Eigen from a system installation ('y'), from a
|
|
Git submodule ('n'), or to decide automatically ('default'). If Eigen
|
|
is not installed directly into a system include directory, for example, it
|
|
is installed in '/opt/include/eigen3/Eigen', then you will need to add
|
|
'/opt/include/eigen3' to 'extra_inc_dirs'.
|
|
""",
|
|
"default", ("default", "y", "n")),
|
|
EnumOption(
|
|
"system_fmt",
|
|
"""Select whether to use the fmt library from a system installation
|
|
('y'), from a Git submodule ('n'), or to decide automatically
|
|
('default'). If you do not want to use the Git submodule and fmt
|
|
is not installed directly into system include and library
|
|
directories, then you will need to add those directories to
|
|
'extra_inc_dirs' and 'extra_lib_dirs'. This installation of fmt
|
|
must include the shared version of the library, for example,
|
|
'libfmt.so'.""",
|
|
"default", ("default", "y", "n")),
|
|
EnumOption(
|
|
"hdf_support",
|
|
"""Select whether to support HDF5 container files natively ('y'), disable HDF5
|
|
support ('n'), or to decide automatically based on the system configuration
|
|
('default'). Native HDF5 support uses the HDF5 library as well as the
|
|
header-only HighFive C++ wrapper (see option 'system_highfive'). Specifying
|
|
'hdf_include' or 'hdf_libdir' changes the default to 'y'.""",
|
|
"default", ("default", "y", "n")),
|
|
PathOption(
|
|
"hdf_include",
|
|
"""The directory where the HDF5 header files are installed. This should be the
|
|
directory that contains files 'H5Version.h' and 'H5Public.h', amongst others.
|
|
Not needed if the headers are installed in a standard location, for example,
|
|
'/usr/include'.""",
|
|
"", PathVariable.PathAccept),
|
|
PathOption(
|
|
"hdf_libdir",
|
|
"""The directory where the HDF5 libraries are installed. Not needed if the
|
|
libraries are installed in a standard location, for example, '/usr/lib'.""",
|
|
"", PathVariable.PathAccept),
|
|
EnumOption(
|
|
"system_highfive",
|
|
"""Select whether to use HighFive from a system installation ('y'), from a
|
|
Git submodule ('n'), or to decide automatically ('default'). If HighFive
|
|
is not installed directly into a system include directory, for example, it
|
|
is installed in '/opt/include/HighFive', then you will need to add
|
|
'/opt/include/HighFive' to 'extra_inc_dirs'.""",
|
|
"default", ("default", "y", "n")),
|
|
EnumOption(
|
|
"system_yamlcpp",
|
|
"""Select whether to use the yaml-cpp library from a system installation
|
|
('y'), from a Git submodule ('n'), or to decide automatically
|
|
('default'). If yaml-cpp is not installed directly into system
|
|
include and library directories, then you will need to add those
|
|
directories to 'extra_inc_dirs' and 'extra_lib_dirs'.""",
|
|
"default", ("default", "y", "n")),
|
|
EnumOption(
|
|
"system_sundials",
|
|
"""Select whether to use SUNDIALS from a system installation ('y'), from
|
|
a Git submodule ('n'), or to decide automatically ('default').
|
|
Specifying 'sundials_include' or 'sundials_libdir' changes the
|
|
default to 'y'.""",
|
|
"default", ("default", "y", "n")),
|
|
PathOption(
|
|
"sundials_include",
|
|
"""The directory where the SUNDIALS header files are installed. This
|
|
should be the directory that contains the "cvodes", "nvector", etc.
|
|
subdirectories. Not needed if the headers are installed in a
|
|
standard location, for example, '/usr/include'.""",
|
|
"", PathVariable.PathAccept),
|
|
PathOption(
|
|
"sundials_libdir",
|
|
"""The directory where the SUNDIALS static libraries are installed.
|
|
Not needed if the libraries are installed in a standard location,
|
|
for example, '/usr/lib'.""",
|
|
"", PathVariable.PathAccept),
|
|
EnumOption(
|
|
"system_blas_lapack",
|
|
"""Select whether to use BLAS/LAPACK from a system installation ('y'), use
|
|
Eigen linear algebra support ('n'), or to decide automatically based on
|
|
libraries detected on the system ('default'). Specifying 'blas_lapack_libs'
|
|
or 'blas_lapack_dir' changes the default to 'y'. On macOS, the 'default'
|
|
option uses the Accelerate framework, whereas on other operating systems the
|
|
preferred option depends on the CPU manufacturer. In general, OpenBLAS
|
|
('openblas') is prioritized over standard libraries ('lapack,blas'), with
|
|
Eigen being used if no suitable BLAS/LAPACK libraries are detected. On Intel
|
|
CPUs, MKL (Windows: 'mkl_rt' / Linux: 'mkl_rt,dl') has the highest priority,
|
|
followed by the other options. Note that Eigen is required whether or not
|
|
BLAS/LAPACK libraries are used.""",
|
|
"default", ("default", "y", "n")),
|
|
Option(
|
|
"blas_lapack_libs",
|
|
"""Cantera can use BLAS and LAPACK libraries installed on your system if you
|
|
have optimized versions available (see option 'system_blas_lapack'). To use
|
|
specific versions of BLAS and LAPACK, set 'blas_lapack_libs' to the the list
|
|
of libraries that should be passed to the linker, separated by commas, for
|
|
example, "lapack,blas" or "lapack,f77blas,cblas,atlas".""",
|
|
""),
|
|
PathOption(
|
|
"blas_lapack_dir",
|
|
"""Directory containing the libraries specified by 'blas_lapack_libs'. Not
|
|
needed if the libraries are installed in a standard location, for example,
|
|
'/usr/lib'.""",
|
|
"", PathVariable.PathAccept),
|
|
BoolOption(
|
|
"lapack_ftn_trailing_underscore",
|
|
"""Controls whether the LAPACK functions have a trailing underscore
|
|
in the Fortran libraries.""",
|
|
True),
|
|
BoolOption(
|
|
"lapack_ftn_string_len_at_end",
|
|
"""Controls whether the LAPACK functions have the string length
|
|
argument at the end of the argument list ('yes') or after
|
|
each argument ('no') in the Fortran libraries.""",
|
|
True),
|
|
EnumOption(
|
|
"googletest",
|
|
"""Select whether to use gtest/gmock from system
|
|
installation ('system'), from a Git submodule ('submodule'), to decide
|
|
automatically ('default') or don't look for gtest/gmock ('none')
|
|
and don't run tests that depend on gtest/gmock.""",
|
|
"default", ("default", "system", "submodule", "none")),
|
|
Option(
|
|
"env_vars",
|
|
"""Environment variables to propagate through to SCons. Either the
|
|
string 'all' or a comma separated list of variable names, for example,
|
|
'LD_LIBRARY_PATH,HOME'.""",
|
|
"PATH,LD_LIBRARY_PATH,DYLD_LIBRARY_PATH,PYTHONPATH,USERPROFILE"),
|
|
BoolOption(
|
|
"use_pch",
|
|
"Use a precompiled-header to speed up compilation",
|
|
True),
|
|
Option(
|
|
"pch_flags",
|
|
"Compiler flags when using precompiled-header.",
|
|
{
|
|
"cl": "/FIpch/system.h",
|
|
"gcc": "-include src/pch/system.h",
|
|
"icx": "-include-pch src/pch/system.h.gch",
|
|
"clang": "-include-pch src/pch/system.h.gch",
|
|
"default": "",
|
|
}),
|
|
Option(
|
|
"thread_flags",
|
|
"Compiler and linker flags for POSIX multithreading support.",
|
|
{"Windows": "", "macOS": "", "default": "-pthread"}),
|
|
BoolOption(
|
|
"optimize",
|
|
"""Enable extra compiler optimizations specified by the
|
|
'optimize_flags' variable, instead of the flags specified by the
|
|
'no_optimize_flags' variable.""",
|
|
True),
|
|
Option(
|
|
"optimize_flags",
|
|
"Additional compiler flags passed to the C/C++ compiler when 'optimize=yes'.",
|
|
{
|
|
"cl": "/O2",
|
|
"icx": "-O3 -fp-model precise", # cannot assume finite math
|
|
"gcc": "-O3 -Wno-inline",
|
|
"default": "-O3",
|
|
}),
|
|
Option(
|
|
"no_optimize_flags",
|
|
"Additional compiler flags passed to the C/C++ compiler when 'optimize=no'.",
|
|
{"cl": "/Od /Ob0", "default": "-O0"}),
|
|
BoolOption(
|
|
"debug",
|
|
"Enable compiler debugging symbols.",
|
|
True),
|
|
Option(
|
|
"debug_flags",
|
|
"Additional compiler flags passed to the C/C++ compiler when 'debug=yes'.",
|
|
{"cl": "/Zi /Fd${TARGET}.pdb", "default": "-g"}),
|
|
Option(
|
|
"no_debug_flags",
|
|
"Additional compiler flags passed to the C/C++ compiler when 'debug=no'.",
|
|
""),
|
|
Option(
|
|
"debug_linker_flags",
|
|
"Additional options passed to the linker when 'debug=yes'.",
|
|
{"cl": "/DEBUG", "default": ""}),
|
|
Option(
|
|
"no_debug_linker_flags",
|
|
"Additional options passed to the linker when 'debug=no'.",
|
|
""),
|
|
Option(
|
|
"warning_flags",
|
|
"""Additional compiler flags passed to the C/C++ compiler to enable
|
|
extra warnings. Used only when compiling source code that is part
|
|
of Cantera (for example, excluding code in the 'ext' directory).""",
|
|
{
|
|
"cl": "/W3",
|
|
"default": "-Wall",
|
|
}),
|
|
Option(
|
|
"extra_inc_dirs",
|
|
"""Additional directories to search for header files, with multiple
|
|
directories separated by colons (*nix, macOS) or semicolons (Windows).
|
|
If an active 'conda' environment is detected, the corresponding include
|
|
path is automatically added.""",
|
|
""),
|
|
Option(
|
|
"extra_lib_dirs",
|
|
"""Additional directories to search for libraries, with multiple
|
|
directories separated by colons (*nix, macOS) or semicolons (Windows).
|
|
If an active 'conda' environment is detected, the corresponding library
|
|
path is automatically added.""",
|
|
""),
|
|
PathOption(
|
|
"boost_inc_dir",
|
|
"""Location of the Boost header files. Not needed if the headers are
|
|
installed in a standard location, for example, '/usr/include'.""",
|
|
"",
|
|
PathVariable.PathAccept),
|
|
PathOption(
|
|
"stage_dir",
|
|
"""Directory relative to the Cantera source directory to be
|
|
used as a staging area for building for example, a Debian
|
|
package. If specified, 'scons install' will install files
|
|
to 'stage_dir/prefix/...'.""",
|
|
"",
|
|
PathVariable.PathAccept),
|
|
EnumOption(
|
|
"logging",
|
|
"""Select logging level for SCons output. By default, logging messages use
|
|
the 'info' level for 'scons build' and the 'warning' level for all other
|
|
commands. In case the SCons option '--silent' is passed, all messages below
|
|
the 'error' level are suppressed.""",
|
|
"default", ("debug", "info", "warning", "error", "default")),
|
|
Option(
|
|
"gtest_flags",
|
|
"""Additional options passed to each GTest test suite, for example,
|
|
'--gtest_filter=*pattern*'. Separate multiple options with spaces.""",
|
|
""),
|
|
BoolOption(
|
|
"renamed_shared_libraries",
|
|
"""If this option is turned on, the shared libraries that are created
|
|
will be renamed to have a '_shared' extension added to their base name.
|
|
If not, the base names will be the same as the static libraries.
|
|
In some cases this simplifies subsequent linking environments with
|
|
static libraries and avoids a bug with using valgrind with
|
|
the '-static' linking flag.""",
|
|
True),
|
|
BoolOption(
|
|
"versioned_shared_library",
|
|
"""If enabled, create a versioned shared library, with symlinks to the
|
|
more generic library name, for example, 'libcantera_shared.so.2.5.0' as the
|
|
actual library and 'libcantera_shared.so' and 'libcantera_shared.so.2'
|
|
as symlinks.""",
|
|
{"mingw": False, "cl": False, "default": True}),
|
|
BoolOption(
|
|
"use_rpath_linkage",
|
|
"""If enabled, link to all shared libraries using 'rpath', that is, a fixed
|
|
run-time search path for dynamic library loading.""",
|
|
True),
|
|
Option(
|
|
"openmp_flag",
|
|
"""Compiler flags used for multiprocessing (only used to generate sample build
|
|
scripts).""",
|
|
{
|
|
"cl": "/openmp",
|
|
"icx": "-qopenmp",
|
|
"apple-clang": "-Xpreprocessor -fopenmp",
|
|
"default": "-fopenmp",
|
|
}),
|
|
EnumOption(
|
|
"layout",
|
|
"""The layout of the directory structure. 'standard' installs files to
|
|
several subdirectories under 'prefix', for example, 'prefix/bin',
|
|
'prefix/include/cantera', 'prefix/lib' etc. This layout is best used in
|
|
conjunction with "prefix='/usr/local'". 'compact' puts all installed files
|
|
in the subdirectory defined by 'prefix'. This layout is best with a prefix
|
|
like '/opt/cantera'. If the Python executable found during compilation is
|
|
managed by 'conda', the layout will default to 'conda' irrespective of
|
|
operating system. For the 'conda' layout, the Python package as well as all
|
|
libraries and header files are installed into the active 'conda' environment.
|
|
Input data, samples, and other files are installed in the 'shared/cantera'
|
|
subdirectory of the active 'conda' environment.""",
|
|
{"Windows": "compact", "default": "standard"},
|
|
("standard", "compact", "conda")),
|
|
BoolOption(
|
|
"package_build",
|
|
"""Used in combination with packaging tools (example: 'conda-build'). If
|
|
enabled, the installed package will be independent from host and build
|
|
environments, with all external library and include paths removed. Packaged
|
|
C++ and Fortran samples assume that users will compile with local SDKs, which
|
|
should be backwards compatible with the tools used for the build process.
|
|
""",
|
|
False),
|
|
BoolOption(
|
|
"fast_fail_tests",
|
|
"If enabled, tests will exit at the first failure.",
|
|
False),
|
|
BoolOption(
|
|
"skip_slow_tests",
|
|
"""If enabled, skip a subset of tests that are known to have long runtimes.
|
|
Skipping these may be desirable when running with options that cause tests
|
|
to run slowly, like disabling optimization or activating code profiling.""",
|
|
False),
|
|
BoolOption(
|
|
"show_long_tests",
|
|
"If enabled, duration of slowest tests will be shown.",
|
|
False),
|
|
BoolOption(
|
|
"verbose_tests",
|
|
"If enabled, verbose test output will be shown.",
|
|
False),
|
|
]
|
|
|
|
config = Configuration()
|
|
|
|
if "help" in COMMAND_LINE_TARGETS:
|
|
AddOption(
|
|
"--options", dest="options",
|
|
action="store_true", help="Print description of available options")
|
|
AddOption(
|
|
"--list-options", dest="list",
|
|
action="store_true", help="List available options")
|
|
AddOption(
|
|
"--restructured-text", dest="rest",
|
|
action="store_true", help="Format defaults as reST")
|
|
AddOption(
|
|
"--option", dest="option", nargs=1, type="string",
|
|
action="store", help="Output help for specific option")
|
|
AddOption(
|
|
"--defaults", dest="defaults",
|
|
action="store_true", help="All defaults (CLI only)")
|
|
AddOption(
|
|
"--dev", dest="dev",
|
|
action="store_true", help="Append -dev (reST only)")
|
|
AddOption(
|
|
"--output", dest="output", nargs=1, type="string",
|
|
action="store", help="Output file (reST only)")
|
|
|
|
list = GetOption("list")
|
|
rest = GetOption("rest")
|
|
defaults = GetOption("defaults") is not None
|
|
options = GetOption("options")
|
|
option = GetOption("option")
|
|
|
|
if not (list or rest or defaults or options or option):
|
|
# show basic help information
|
|
logger.status(__doc__, print_level=False)
|
|
sys.exit(0)
|
|
|
|
if defaults or rest or list:
|
|
|
|
config.add(windows_options)
|
|
config.add(config_options)
|
|
|
|
if list:
|
|
# show formatted list of options
|
|
logger.status("\nConfiguration options for building Cantera:\n", print_level=False)
|
|
logger.status(config.list_options() + "\n", print_level=False)
|
|
sys.exit(0)
|
|
|
|
if defaults:
|
|
try:
|
|
# print default values: if option is None, show description for all
|
|
# available options, otherwise show description for specified option
|
|
logger.status(config.help(option), print_level=False)
|
|
sys.exit(0)
|
|
except KeyError as err:
|
|
message = "Run 'scons help --list-options' to see available options."
|
|
logger.error(f"{err}.\n{message}")
|
|
sys.exit(1)
|
|
|
|
dev = GetOption("dev") is not None
|
|
try:
|
|
# format default values as reST: if option is None, all descriptions are
|
|
# rendered, otherwise only the description of specified option is shown
|
|
message = config.to_rest(option, dev=dev)
|
|
except KeyError as err:
|
|
message = "Run 'scons help --list-options' to see available options."
|
|
logger.error(f"{err}.\n{message}")
|
|
sys.exit(1)
|
|
|
|
output = GetOption("output")
|
|
if output:
|
|
# write output to file
|
|
output_file = Path(output).with_suffix(".rst")
|
|
with open(output_file, "w+") as fid:
|
|
fid.write(message)
|
|
|
|
logger.status(f"Done writing output options to {output_file!r}.",
|
|
print_level=False)
|
|
|
|
else:
|
|
logger.status(message, print_level=False)
|
|
|
|
sys.exit(0)
|
|
|
|
if "sphinx" in COMMAND_LINE_TARGETS:
|
|
# need to buffer all options before system-dependent selections are applied
|
|
windows_options_full = deepcopy(windows_options)
|
|
config_options_full = deepcopy(config_options)
|
|
|
|
# **************************************
|
|
# *** Read user-configurable options ***
|
|
# **************************************
|
|
|
|
opts = Variables("cantera.conf")
|
|
|
|
extraEnvArgs = {}
|
|
|
|
if os.name == "nt":
|
|
config.add(windows_options)
|
|
config.add(config_options)
|
|
|
|
config["prefix"].default = (Path(os.environ["ProgramFiles"]) / "Cantera").as_posix()
|
|
config.select("Windows")
|
|
|
|
# On Windows, target the same architecture as the current copy of Python,
|
|
# unless the user specified another option.
|
|
if "64 bit" not in sys.version:
|
|
config["target_arch"].default = "x86"
|
|
|
|
opts.AddVariables(*config.to_scons(("msvc_version", "msvc_toolset_version", "target_arch")))
|
|
|
|
windows_compiler_env = Environment()
|
|
opts.Update(windows_compiler_env)
|
|
|
|
# Make an educated guess about the right default compiler
|
|
if which("g++") and not which("cl.exe"):
|
|
config["toolchain"].default = "mingw"
|
|
|
|
if windows_compiler_env["msvc_version"] or windows_compiler_env["msvc_toolset_version"]:
|
|
config["toolchain"].default = "msvc"
|
|
|
|
opts.AddVariables(*config.to_scons("toolchain"))
|
|
opts.Update(windows_compiler_env)
|
|
|
|
if windows_compiler_env["toolchain"] == "msvc":
|
|
toolchain = ["default"]
|
|
if windows_compiler_env["msvc_version"]:
|
|
extraEnvArgs["MSVC_VERSION"] = windows_compiler_env["msvc_version"]
|
|
if windows_compiler_env["msvc_toolset_version"]:
|
|
extraEnvArgs["MSVC_TOOLSET_VERSION"] = windows_compiler_env["msvc_toolset_version"]
|
|
msvc_version = (windows_compiler_env["msvc_version"] or
|
|
windows_compiler_env.get("MSVC_VERSION"))
|
|
logger.info(f"Compiling with MSVC version {msvc_version}", print_level=False)
|
|
msvc_toolset = (windows_compiler_env["msvc_toolset_version"] or
|
|
windows_compiler_env.get("MSVC_TOOLSET_VERSION") or
|
|
f"{msvc_version} (default)")
|
|
logger.info(f"Compiling with MSVC toolset {msvc_toolset}", print_level=False)
|
|
|
|
elif windows_compiler_env["toolchain"] == "mingw":
|
|
toolchain = ["mingw", "f90"]
|
|
extraEnvArgs["F77"] = None
|
|
|
|
elif windows_compiler_env["toolchain"] == "intel":
|
|
toolchain = ["intelc"] # note: untested
|
|
|
|
extraEnvArgs["TARGET_ARCH"] = windows_compiler_env["target_arch"]
|
|
logger.info(f"Compiling for architecture: {windows_compiler_env['target_arch']}",
|
|
print_level=False)
|
|
logger.info(f"Compiling using the following toolchain(s): {repr(toolchain)}",
|
|
print_level=False)
|
|
else:
|
|
config.add(config_options)
|
|
toolchain = ["default"]
|
|
|
|
env = Environment(tools=toolchain+["textfile", "subst", "recursiveInstall", "UnitsInterfaceBuilder", "wix", "gch"],
|
|
ENV={"PATH": os.environ["PATH"]},
|
|
toolchain=toolchain,
|
|
**extraEnvArgs)
|
|
|
|
# Copy variables we defined earlier into the construction environment.
|
|
# We needed them earlier to support building the sdist without doing
|
|
# any other unnecessary config
|
|
|
|
env["cantera_version"] = cantera_version
|
|
env["cantera_pure_version"] = cantera_pure_version
|
|
env["cantera_short_version"] = cantera_short_version
|
|
env["git_commit"] = cantera_git_commit
|
|
|
|
env["OS"] = platform.system()
|
|
env["OS_BITS"] = int(platform.architecture()[0][:2])
|
|
if "cygwin" in env["OS"].lower():
|
|
logger.error(f"Error: Operating system {os.name!r} is no longer supported.")
|
|
sys.exit(1)
|
|
|
|
if "FRAMEWORKS" not in env:
|
|
env["FRAMEWORKS"] = []
|
|
|
|
if os.name == "nt":
|
|
env["INSTALL_MANPAGES"] = False
|
|
|
|
# Fixes a linker error in Windows
|
|
if "TMP" in os.environ:
|
|
env["ENV"]["TMP"] = os.environ["TMP"]
|
|
|
|
# Fixes issues with Python subprocesses. See http://bugs.python.org/issue13524
|
|
env["ENV"]["SystemRoot"] = os.environ["SystemRoot"]
|
|
|
|
# Fix an issue with Unicode sneaking into the environment on Windows
|
|
for key,val in env["ENV"].items():
|
|
env["ENV"][key] = str(val)
|
|
|
|
else:
|
|
env["INSTALL_MANPAGES"] = True
|
|
|
|
add_RegressionTest(env)
|
|
|
|
opts.AddVariables(*config.to_scons(["AR", "CC", "CXX"], env=env))
|
|
opts.Update(env)
|
|
|
|
# Check if this is actually Apple's clang on macOS
|
|
env["using_apple_clang"] = False
|
|
if env["OS"] == "Darwin":
|
|
result = subprocess.check_output([env.subst("$CC"), "--version"]).decode("utf-8")
|
|
if "clang" in result.lower() and ("Xcode" in result or "Apple" in result):
|
|
env["using_apple_clang"] = True
|
|
config.select("apple-clang")
|
|
|
|
if "gcc" in env.subst("$CC") or "gnu-cc" in env.subst("$CC"):
|
|
config.select("gcc")
|
|
|
|
elif env["CC"] == "cl": # Visual Studio
|
|
config.select("cl")
|
|
|
|
elif "icc" in env.subst("$CC"):
|
|
logger.error("The deprecated Intel compiler suite (icc/icpc) is no longer supported")
|
|
|
|
elif "icx" in env.subst("$CC"):
|
|
config.select("icx")
|
|
|
|
elif "clang" in env.subst("$CC"):
|
|
config.select("clang")
|
|
|
|
else:
|
|
# Assume a GCC compatible compiler if nothing else
|
|
logger.warning(f"Unrecognized C compiler {env['CC']!r}")
|
|
config.select("gcc")
|
|
|
|
|
|
if env["OS"] == "Windows":
|
|
config.select("Windows")
|
|
elif env["OS"] == "Darwin":
|
|
config.select("macOS")
|
|
|
|
# SHLIBVERSION fails with MinGW: http://scons.tigris.org/issues/show_bug.cgi?id=3035
|
|
if "mingw" in env["toolchain"] :
|
|
config.select("mingw")
|
|
|
|
config.select("default")
|
|
config["python_cmd"].default = sys.executable
|
|
|
|
opts.AddVariables(*config.to_scons())
|
|
opts.Update(env)
|
|
opts.Save('cantera.conf', env)
|
|
|
|
# Expand ~/ and environment variables used in cantera.conf (variables used on
|
|
# the command line will be expanded by the shell)
|
|
for option in opts.keys():
|
|
original = env[option]
|
|
if isinstance(original, str):
|
|
modified = os.path.expandvars(os.path.expanduser(env[option]))
|
|
if original != modified:
|
|
logger.info(f"Expanding {original!r} to {modified!r}")
|
|
env[option] = modified
|
|
|
|
if "help" in COMMAND_LINE_TARGETS:
|
|
option = GetOption("option")
|
|
try:
|
|
# print configuration: if option is None, description is shown for all
|
|
# options; otherwise description is shown for specified option
|
|
logger.status(config.help(option, env=env), print_level=False)
|
|
sys.exit(0)
|
|
except KeyError as err:
|
|
message = "Run 'scons help --list-options' to see available options."
|
|
logger.error(f"{err}.\n{message}")
|
|
sys.exit(1)
|
|
|
|
if 'doxygen' in COMMAND_LINE_TARGETS:
|
|
env['doxygen_docs'] = True
|
|
if 'sphinx' in COMMAND_LINE_TARGETS:
|
|
env['sphinx_docs'] = True
|
|
for arg in ARGUMENTS:
|
|
if arg not in config:
|
|
logger.error(f"Encountered unexpected command line option: {arg!r}")
|
|
sys.exit(1)
|
|
|
|
# Store full config for doc build
|
|
if env['sphinx_docs']:
|
|
# rebuild configuration from buffered options
|
|
config_full = Configuration()
|
|
config_full.add(windows_options_full)
|
|
config_full.add(config_options_full)
|
|
env['config'] = config_full
|
|
def get_processor_name():
|
|
"""Check processor name"""
|
|
# adapted from:
|
|
# https://stackoverflow.com/questions/4842448/getting-processor-information-in-python
|
|
if platform.system() == "Windows":
|
|
return platform.processor().strip()
|
|
elif platform.system() == "Darwin":
|
|
os.environ['PATH'] = os.environ['PATH'] + os.pathsep + '/usr/sbin'
|
|
command ="sysctl -n machdep.cpu.brand_string"
|
|
return subprocess.check_output(command, shell=True).decode().strip()
|
|
elif platform.system() == "Linux":
|
|
command = "cat /proc/cpuinfo"
|
|
all_info = subprocess.check_output(command, shell=True).decode().strip()
|
|
for line in all_info.split("\n"):
|
|
if "model name" in line:
|
|
return re.sub(".*model name.*:", "", line, 1).strip()
|
|
return ""
|
|
|
|
env["CPU"] = get_processor_name()
|
|
logger.info(f"Compiling on {env['CPU']!r}")
|
|
|
|
# Print values of all build options:
|
|
# the (updated) "cantera.conf" combines all options that were specified by the user
|
|
cantera_conf = Path("cantera.conf").read_text()
|
|
logger.info("Configuration variables read from 'cantera.conf' and command line:")
|
|
logger.info(textwrap.indent(cantera_conf, " "), print_level=False)
|
|
|
|
# ********************************************
|
|
# *** Configure system-specific properties ***
|
|
# ********************************************
|
|
|
|
loglevel = env["logging"]
|
|
if loglevel != "default":
|
|
logger.logger.setLevel(loglevel.upper())
|
|
|
|
# Copy in external environment variables
|
|
if env['env_vars'] == 'all':
|
|
env['ENV'].update(os.environ)
|
|
if 'PYTHONHOME' in env['ENV']:
|
|
del env['ENV']['PYTHONHOME']
|
|
elif env['env_vars']:
|
|
for name in env['env_vars'].split(','):
|
|
if name in os.environ:
|
|
if name == 'PATH':
|
|
env.AppendENVPath('PATH', os.environ['PATH'])
|
|
else:
|
|
env['ENV'][name] = os.environ[name]
|
|
logger.debug(f"Propagating environment variable {name}={env['ENV'][name]}")
|
|
elif name not in config["env_vars"].default.split(','):
|
|
logger.warning(f"Failed to propagate environment variable {name!r}\n"
|
|
"Edit cantera.conf or the build command line to fix this.")
|
|
|
|
|
|
inc_dirs = []
|
|
for inc_dir in env["extra_inc_dirs"].split(os.pathsep):
|
|
if not inc_dir:
|
|
continue
|
|
inc_dirs.append(make_relative_path_absolute(inc_dir))
|
|
|
|
env["extra_inc_dirs"] = inc_dirs
|
|
|
|
lib_dirs = []
|
|
for lib_dir in env["extra_lib_dirs"].split(os.pathsep):
|
|
if not lib_dir:
|
|
continue
|
|
lib_dirs.append(make_relative_path_absolute(lib_dir))
|
|
|
|
env["extra_lib_dirs"] = lib_dirs
|
|
|
|
# Add conda library/include paths (if applicable) to extra
|
|
# Assume "CONDA_PREFIX" is always absolute if it exists
|
|
conda_prefix = os.environ.get("CONDA_PREFIX")
|
|
if conda_prefix is not None:
|
|
conda_prefix = Path(conda_prefix)
|
|
if os.name == "nt":
|
|
conda_inc_dir = (conda_prefix / "Library" / "include").as_posix()
|
|
conda_lib_dir = (conda_prefix / "Library" / env["libdirname"]).as_posix()
|
|
else:
|
|
conda_inc_dir = (conda_prefix / "include").as_posix()
|
|
conda_lib_dir = (conda_prefix / env["libdirname"]).as_posix()
|
|
env["extra_inc_dirs"].append(conda_inc_dir)
|
|
env["extra_lib_dirs"].append(conda_lib_dir)
|
|
logger.info(f"Adding conda include and library paths: {conda_prefix}")
|
|
|
|
add_system_include(env, env['extra_inc_dirs'])
|
|
env.Append(LIBPATH=env['extra_lib_dirs'])
|
|
|
|
if env['use_rpath_linkage']:
|
|
env.Append(RPATH=env['extra_lib_dirs'])
|
|
|
|
if env['CC'] == 'cl':
|
|
# embed manifest file
|
|
env['LINKCOM'] = [env['LINKCOM'],
|
|
'if exist ${TARGET}.manifest mt.exe -nologo -manifest ${TARGET}.manifest -outputresource:$TARGET;1']
|
|
env['SHLINKCOM'] = [env['SHLINKCOM'],
|
|
'if exist ${TARGET}.manifest mt.exe -nologo -manifest ${TARGET}.manifest -outputresource:$TARGET;2']
|
|
env['FORTRAN_LINK'] = 'link'
|
|
else:
|
|
env['FORTRAN_LINK'] = '$FORTRAN'
|
|
|
|
if env['boost_inc_dir']:
|
|
env["boost_inc_dir"] = make_relative_path_absolute(env["boost_inc_dir"])
|
|
add_system_include(env, env['boost_inc_dir'])
|
|
|
|
if env['blas_lapack_dir']:
|
|
env["blas_lapack_dir"] = make_relative_path_absolute(env["blas_lapack_dir"])
|
|
env.Append(LIBPATH=[env['blas_lapack_dir']])
|
|
if env['use_rpath_linkage']:
|
|
env.Append(RPATH=env['blas_lapack_dir'])
|
|
|
|
if env['system_sundials'] in ('y','default'):
|
|
if env['sundials_include']:
|
|
env["sundials_include"] = make_relative_path_absolute(env["sundials_include"])
|
|
add_system_include(env, env['sundials_include'])
|
|
env['system_sundials'] = 'y'
|
|
if env['sundials_libdir']:
|
|
env["sundials_libdir"] = make_relative_path_absolute(env["sundials_libdir"])
|
|
env.Append(LIBPATH=[env['sundials_libdir']])
|
|
env['system_sundials'] = 'y'
|
|
if env['use_rpath_linkage']:
|
|
env.Append(RPATH=env['sundials_libdir'])
|
|
|
|
# BLAS / LAPACK configuration
|
|
if env['blas_lapack_libs'] != '':
|
|
env['blas_lapack_libs'] = env['blas_lapack_libs'].split(',')
|
|
env['use_lapack'] = True
|
|
else:
|
|
env['blas_lapack_libs'] = []
|
|
env['use_lapack'] = False
|
|
|
|
# ************************************
|
|
# *** Compiler Configuration Tests ***
|
|
# ************************************
|
|
|
|
def CheckStatement(context, function, includes=""):
|
|
context.Message('Checking for %s... ' % function)
|
|
src = """
|
|
%(include)s
|
|
int main(int argc, char** argv) {
|
|
%(func)s;
|
|
return 0;
|
|
}
|
|
""" % {'func':function, 'include':includes}
|
|
result = context.TryCompile(src, '.cpp')
|
|
context.Result(result)
|
|
return result
|
|
|
|
# Set up compiler options before running configuration tests
|
|
env.Append(CXXFLAGS=listify(env['cxx_flags']))
|
|
env['CCFLAGS'] = listify(env['cc_flags']) + listify(env['thread_flags'])
|
|
env['LINKFLAGS'] += listify(env['thread_flags'])
|
|
env['CPPDEFINES'] = {}
|
|
|
|
env['warning_flags'] = listify(env['warning_flags'])
|
|
env["pch_flags"] = listify(env["pch_flags"])
|
|
env["openmp_flag"] = listify(env["openmp_flag"])
|
|
|
|
if env['optimize']:
|
|
env['CCFLAGS'] += listify(env['optimize_flags'])
|
|
env.Append(CPPDEFINES=['NDEBUG'])
|
|
else:
|
|
env['CCFLAGS'] += listify(env['no_optimize_flags'])
|
|
|
|
if env['debug']:
|
|
env['CCFLAGS'] += listify(env['debug_flags'])
|
|
env['LINKFLAGS'] += listify(env['debug_linker_flags'])
|
|
else:
|
|
env['CCFLAGS'] += listify(env['no_debug_flags'])
|
|
env['LINKFLAGS'] += listify(env['no_debug_linker_flags'])
|
|
|
|
if env['coverage']:
|
|
if 'gcc' in env.subst('$CC') or 'clang' in env.subst('$CC'):
|
|
env.Append(CCFLAGS=['-fprofile-arcs', '-ftest-coverage'])
|
|
env.Append(LINKFLAGS=['-fprofile-arcs', '-ftest-coverage'])
|
|
|
|
else:
|
|
logger.error("Coverage testing is only available with GCC.")
|
|
exit(0)
|
|
|
|
conf = Configure(env, custom_tests={'CheckStatement': CheckStatement})
|
|
env = conf.env # Retain updates to `env` after the end of the `Configure` context
|
|
|
|
# First, a sanity check:
|
|
if not conf.CheckCXXHeader("cmath", "<>"):
|
|
config_error(
|
|
"The C++ compiler is not correctly configured (incomplete include paths)."
|
|
)
|
|
|
|
def get_expression_value(includes, expression):
|
|
s = ['#include ' + i for i in includes]
|
|
s.extend(('#include <iostream>',
|
|
'int main(int argc, char** argv) {',
|
|
f' std::cout << {expression} << std::endl;',
|
|
' return 0;',
|
|
'}\n'))
|
|
return '\n'.join(s)
|
|
|
|
# Need to ensure that RPATH is working before we can continue with library checks
|
|
env['HAS_CLANG'] = conf.CheckDeclaration('__clang__', '', 'C++')
|
|
|
|
if env['OS'] == 'Solaris' or env['HAS_CLANG']:
|
|
env["RPATHPREFIX"] = "-Wl,-rpath,"
|
|
|
|
# Add initial libraries to RPATH
|
|
if env["OS"] == "Darwin" and env["use_rpath_linkage"] and not env.subst("$__RPATH"):
|
|
# SCons doesn't want to specify RPATH on macOS, so circumvent that behavior by
|
|
# specifying this directly as part of LINKFLAGS
|
|
env.Append(LINKFLAGS=[env.subst(f'$RPATHPREFIX{x}$RPATHSUFFIX')
|
|
for x in env['RPATH']])
|
|
|
|
# Check that libraries link correctly
|
|
retcode = conf.TryLink(
|
|
"#include <cmath>\nint main(int argc, char** argv) { cos(0 * argc); return 0;}",
|
|
".cpp",
|
|
)
|
|
if not retcode:
|
|
config_error(
|
|
"The C++ compiler is not correctly configured (failed at linking stage)."
|
|
)
|
|
|
|
# Check that NaN is treated correctly. Only run this check when we are not cross-
|
|
# compiling because it actually runs an executable; if we're cross-compiling then the
|
|
# build machine architecture does not support the machine code from the compiler, by
|
|
# definition, so the executable can't run. This check actually has to run because we
|
|
# care about the runtime behavior of std::isnan.
|
|
# The environment variable here is specific to the conda-forge builder environment,
|
|
# but that's the only place we regularly cross-compile as far as I know.
|
|
# See https://conda-forge.org/docs/maintainer/knowledge_base/#how-to-enable-cross-compilation
|
|
# --Bryan
|
|
if not os.environ.get("CONDA_BUILD_CROSS_COMPILATION") == "1":
|
|
nan_check_source = get_expression_value(["<cmath>"], "std::isnan(NAN + argc)")
|
|
retcode, nan_works = conf.TryRun(nan_check_source, ".cpp")
|
|
if nan_works.strip() != "1":
|
|
config_error(
|
|
"Cantera requires a working implementation of 'std::isnan'.\n"
|
|
"If you have specified '-ffast-math' or equivalent as an optimization option,\n"
|
|
"either remove this option or add the '-fno-finite-math-only' option."
|
|
)
|
|
|
|
def split_version(version):
|
|
"""Split integer version into version string."""
|
|
version = divmod(float(version.strip()), 10000)
|
|
(fmt_maj, (fmt_min, fmt_pat)) = version[0], divmod(version[1], 100)
|
|
return f"{fmt_maj:.0f}.{fmt_min:.0f}.{fmt_pat:.0f}"
|
|
|
|
# Check for fmt library and checkout submodule if needed
|
|
if env['system_fmt'] in ('y', 'default'):
|
|
retcode, fmt_version_text = run_preprocessor(
|
|
conf, ["<fmt/format.h>"], "FMT_VERSION", ["FMT_HEADER_ONLY"]
|
|
)
|
|
if retcode and fmt_version_text:
|
|
fmt_lib_version = split_version(fmt_version_text)
|
|
fmt_min_version = "8.0.0"
|
|
if parse_version(fmt_lib_version) < parse_version(fmt_min_version):
|
|
if env['system_fmt'] == 'y':
|
|
config_error(
|
|
f"System fmt version {fmt_lib_version} is not supported;"
|
|
f"version {fmt_min_version} or higher is required.")
|
|
else:
|
|
env['system_fmt'] = True
|
|
logger.info("Using system installation of fmt library.")
|
|
elif env['system_fmt'] == 'y':
|
|
config_error('Expected system installation of fmt library, but it '
|
|
'could not be found.')
|
|
|
|
if env['system_fmt'] in ('n', 'default'):
|
|
if not os.path.exists('ext/fmt/include/fmt/ostream.h'):
|
|
checkout_submodule("fmt", "ext/fmt")
|
|
retcode, fmt_version_text = run_preprocessor(
|
|
conf, ['"../ext/fmt/include/fmt/format.h"'], "FMT_VERSION", ["FMT_HEADER_ONLY"]
|
|
)
|
|
if not retcode:
|
|
config_error('Expected private installation of fmt library, but it is '
|
|
'not configured correctly.')
|
|
|
|
fmt_lib_version = split_version(fmt_version_text)
|
|
env['system_fmt'] = False
|
|
logger.info("Using private installation of fmt library.")
|
|
|
|
logger.info(f"Using fmt version {fmt_lib_version}")
|
|
|
|
# Check for yaml-cpp library and checkout submodule if needed
|
|
if env['system_yamlcpp'] in ('y', 'default'):
|
|
# We need the Mark() function, which was added in version 0.5.3
|
|
if conf.CheckStatement('YAML::Node().Mark()', '#include "yaml-cpp/yaml.h"'):
|
|
env['system_yamlcpp'] = True
|
|
logger.info("Using system installation of yaml-cpp library.")
|
|
|
|
elif env['system_yamlcpp'] == 'y':
|
|
config_error("Expected system installation of yaml-cpp library, but it "
|
|
"could not be found or it is too old (0.6 or newer is required).")
|
|
|
|
if env['system_yamlcpp'] in ('n', 'default'):
|
|
env['system_yamlcpp'] = False
|
|
logger.info("Using private installation of yaml-cpp library.")
|
|
if not os.path.exists('ext/yaml-cpp/include/yaml-cpp/yaml.h'):
|
|
checkout_submodule("yaml-cpp", "ext/yaml-cpp")
|
|
|
|
# Check for googletest and checkout submodule if needed
|
|
if env['googletest'] in ('system', 'default'):
|
|
has_gtest = conf.CheckCXXHeader('gtest/gtest.h', '""')
|
|
has_gmock = conf.CheckCXXHeader('gmock/gmock.h', '""')
|
|
if has_gtest and has_gmock:
|
|
env['googletest'] = 'system'
|
|
logger.info("Using system installation of Googletest")
|
|
elif env['googletest'] == 'system':
|
|
config_error('Expected system installation of Googletest-1.8.0, but it '
|
|
'could not be found.')
|
|
|
|
if env['googletest'] in ('submodule', 'default'):
|
|
env['googletest'] = 'submodule'
|
|
has_gtest = os.path.exists('ext/googletest/googletest/include/gtest/gtest.h')
|
|
has_gmock = os.path.exists('ext/googletest/googlemock/include/gmock/gmock.h')
|
|
if not (has_gtest and has_gmock):
|
|
checkout_submodule("Googletest", "ext/googletest")
|
|
|
|
if env['googletest'] == 'none':
|
|
logger.info("Not using GoogleTest -- unable to run complete test suite")
|
|
|
|
# Check for Eigen and checkout submodule if needed
|
|
if env["system_eigen"] in ("y", "default"):
|
|
if conf.CheckCXXHeader("eigen3/Eigen/Dense", "<>"):
|
|
env["system_eigen"] = True
|
|
env["system_eigen_prefixed"] = True
|
|
logger.info("Using system installation of Eigen.")
|
|
eigen_include = "<eigen3/Eigen/Core>"
|
|
elif conf.CheckCXXHeader("Eigen/Dense", "<>"):
|
|
env["system_eigen"] = True
|
|
env["system_eigen_prefixed"] = False
|
|
logger.info("Using system installation of Eigen.")
|
|
eigen_include = "<Eigen/Core>"
|
|
elif env["system_eigen"] == "y":
|
|
config_error("Expected system installation of Eigen, but it "
|
|
"could not be found.")
|
|
|
|
if env["system_eigen"] in ("n", "default"):
|
|
env["system_eigen"] = False
|
|
logger.info("Using private installation of Eigen.")
|
|
if not os.path.exists("ext/eigen/Eigen/Dense"):
|
|
checkout_submodule("Eigen", "ext/eigen")
|
|
eigen_include = '"../ext/eigen/Eigen/Core"'
|
|
|
|
_, eigen_lib_version = run_preprocessor(
|
|
conf,
|
|
[eigen_include],
|
|
"EIGEN_WORLD_VERSION EIGEN_MAJOR_VERSION EIGEN_MINOR_VERSION",
|
|
)
|
|
env["EIGEN_LIB_VERSION"] = eigen_lib_version.strip().replace(" ", ".")
|
|
logger.info(f"Found Eigen version {env['EIGEN_LIB_VERSION']}")
|
|
|
|
# Determine which standard library to link to when using Fortran to
|
|
# compile code that links to Cantera
|
|
if conf.CheckDeclaration('__GLIBCXX__', '#include <iostream>', 'C++'):
|
|
env['cxx_stdlib'] = ['stdc++']
|
|
elif conf.CheckDeclaration('_LIBCPP_VERSION', '#include <iostream>', 'C++'):
|
|
env['cxx_stdlib'] = ['c++']
|
|
else:
|
|
env['cxx_stdlib'] = []
|
|
|
|
|
|
# This checks for these three libraries in order and stops when it finds the
|
|
# first success. Intel = iomp5, LLVM/clang = omp, GCC = gomp. Since gomp is
|
|
# likely to be installed on the system even if other compilers are installed
|
|
# or in use, it needs to go last in the check.
|
|
env['HAS_OPENMP'] = conf.CheckLibWithHeader(
|
|
["iomp5", "omp", "gomp"], "omp.h", language="C++"
|
|
)
|
|
|
|
retcode, boost_lib_version = run_preprocessor(conf, ["<boost/version.hpp>"], "BOOST_LIB_VERSION")
|
|
if not retcode:
|
|
config_error("Boost could not be found. Install Boost headers or set "
|
|
"'boost_inc_dir' to point to the boost headers.")
|
|
else:
|
|
env['BOOST_LIB_VERSION'] = '.'.join(boost_lib_version.strip().replace('"', "").split('_'))
|
|
if parse_version(env['BOOST_LIB_VERSION']) < parse_version("1.70"):
|
|
# Boost.DLL with std::filesystem (making it header-only) is available in Boost 1.70
|
|
# or newer
|
|
config_error("Cantera requires Boost version 1.70 or newer.")
|
|
logger.info(f"Found Boost version {env['BOOST_LIB_VERSION']}")
|
|
|
|
# check BLAS/LAPACK installations
|
|
if env["system_blas_lapack"] == "n":
|
|
env["blas_lapack_libs"] = []
|
|
|
|
elif env["blas_lapack_libs"] or env["blas_lapack_dir"]:
|
|
if env["system_blas_lapack"] == "default":
|
|
env["system_blas_lapack"] = "y"
|
|
for lib in env["blas_lapack_libs"]:
|
|
if not conf.CheckLib(lib, autoadd=False):
|
|
config_error(f"Library {lib!r} could not be found.")
|
|
|
|
elif env["system_blas_lapack"] == "default":
|
|
# auto-detect versions
|
|
if env["OS"] == "Darwin":
|
|
# Use macOS Accelerate framework by default
|
|
blas_lapack_order = []
|
|
env["use_lapack"] = True
|
|
env.Append(FRAMEWORKS=["Accelerate"])
|
|
elif "intel" in env["CPU"].lower():
|
|
if env["OS"] == "Windows":
|
|
blas_lapack_order = [["mkl_rt"], ["openblas"], ["lapack", "blas"]]
|
|
else:
|
|
blas_lapack_order = [["mkl_rt", "dl"], ["openblas"], ["lapack", "blas"]]
|
|
else:
|
|
# MKL is known to have deliberately sub-optimal performance on non-Intel
|
|
# (i.e. AMD) processors
|
|
blas_lapack_order = [["openblas"], ["lapack", "blas"]]
|
|
for lib in blas_lapack_order:
|
|
if all(conf.CheckLib(l, autoadd=False) for l in lib):
|
|
env["blas_lapack_libs"] = lib
|
|
env["use_lapack"] = True
|
|
break
|
|
if not env["blas_lapack_libs"] and env["OS"] != "Darwin":
|
|
logger.info("No system BLAS/LAPACK libraries detected.")
|
|
|
|
if "mkl_rt" in env["blas_lapack_libs"]:
|
|
retcode, mkl_version = run_preprocessor(
|
|
conf, ["mkl.h"], "__INTEL_MKL__ __INTEL_MKL_MINOR__ __INTEL_MKL_UPDATE__"
|
|
)
|
|
if retcode and mkl_version:
|
|
logger.info(f"Using MKL {'.'.join(mkl_version.strip().split())}")
|
|
else:
|
|
logger.warning("Failed to determine MKL version.")
|
|
|
|
elif "openblas" in env["blas_lapack_libs"]:
|
|
retcode, openblas_version = run_preprocessor(
|
|
conf, ["<openblas_config.h>"], "OPENBLAS_VERSION"
|
|
)
|
|
if retcode and openblas_version:
|
|
logger.info("Using {}", openblas_version.replace('"', '').strip())
|
|
else:
|
|
logger.warning("Failed to determine OpenBLAS version.")
|
|
|
|
env['NEED_LIBM'] = not conf.CheckLibWithHeader(None, 'math.h', 'C',
|
|
'double x; log(x);', False)
|
|
env['LIBM'] = ['m'] if env['NEED_LIBM'] else []
|
|
|
|
|
|
if env['system_sundials'] in ("y", "default"):
|
|
# Determine Sundials version
|
|
retcode, sundials_version = run_preprocessor(
|
|
conf,
|
|
['"sundials/sundials_config.h"'],
|
|
"SUNDIALS_VERSION_MAJOR SUNDIALS_VERSION_MINOR SUNDIALS_VERSION_PATCH",
|
|
)
|
|
if retcode and sundials_version:
|
|
sundials_info = check_sundials(conf, sundials_version)
|
|
env["system_sundials"] = sundials_info["system_sundials"]
|
|
env["sundials_version"] = sundials_info["sundials_version"]
|
|
env["has_sundials_lapack"] = sundials_info["has_sundials_lapack"]
|
|
|
|
if env["system_sundials"] in ("n", "default"):
|
|
if not os.path.exists('ext/sundials/include/cvodes/cvodes.h'):
|
|
checkout_submodule("Sundials", "ext/sundials")
|
|
logger.info("Using private installation of Sundials version 5.3.")
|
|
env['sundials_version'] = '5.3'
|
|
env['has_sundials_lapack'] = int(env['use_lapack'])
|
|
env["system_sundials"] = "n"
|
|
|
|
if env['system_sundials'] == 'y':
|
|
env['sundials_libs'] = ['sundials_cvodes', 'sundials_idas', 'sundials_nvecserial']
|
|
if parse_version(env["sundials_version"]) >= parse_version("7.0.0"):
|
|
env['sundials_libs'].append('sundials_core')
|
|
if env['use_lapack']:
|
|
if env.get('has_sundials_lapack'):
|
|
env['sundials_libs'].extend(('sundials_sunlinsollapackdense',
|
|
'sundials_sunlinsollapackband'))
|
|
else:
|
|
env['sundials_libs'].extend(('sundials_sunlinsoldense',
|
|
'sundials_sunlinsolband'))
|
|
else:
|
|
env['sundials_libs'] = []
|
|
|
|
if env["hdf_include"] and env["hdf_support"] in ("y", "default"):
|
|
env["hdf_include"] = make_relative_path_absolute(env["hdf_include"])
|
|
add_system_include(env, env["hdf_include"])
|
|
env["hdf_support"] = "y"
|
|
if env["hdf_libdir"] and env["hdf_support"] in ("y", "default"):
|
|
env["hdf_libdir"] = make_relative_path_absolute(env["hdf_libdir"])
|
|
env.Append(LIBPATH=[env["hdf_libdir"]])
|
|
env["hdf_support"] = "y"
|
|
if env["use_rpath_linkage"]:
|
|
env.Append(RPATH=env["hdf_libdir"])
|
|
|
|
if env["hdf_support"] == "n":
|
|
env["use_hdf5"] = False
|
|
else:
|
|
libhdf_exists = conf.CheckLib("hdf5", autoadd=False)
|
|
libhdf_serial_exists = conf.CheckLib("hdf5_serial", autoadd=False)
|
|
env["use_hdf5"] = False
|
|
if libhdf_exists:
|
|
env["use_hdf5"] = True
|
|
env["hdf5_lib"] = "hdf5"
|
|
elif libhdf_serial_exists:
|
|
env["use_hdf5"] = True
|
|
env["hdf5_lib"] = "hdf5_serial"
|
|
if not env["hdf_include"]:
|
|
add_system_include(env, "/usr/include/hdf5/serial/")
|
|
if not env["use_hdf5"] and env["hdf_support"] == "y":
|
|
config_error("HDF5 support has been specified but libraries were not found.")
|
|
|
|
if env["use_hdf5"] and env["system_highfive"] in ("y", "default"):
|
|
if conf.CheckLibWithHeader(
|
|
"hdf5", "highfive/H5File.hpp", language="C++", autoadd=False):
|
|
|
|
highfive_include = "<highfive/H5Version.hpp>"
|
|
retcode, h5_lib_version = run_preprocessor(conf, [highfive_include], "HIGHFIVE_VERSION")
|
|
if retcode and h5_lib_version:
|
|
if parse_version(h5_lib_version) < parse_version("2.5"):
|
|
if env["system_highfive"] == "y":
|
|
config_error(
|
|
f"System HighFive version {h5_lib_version} is not "
|
|
"supported; version 2.5 or higher is required.")
|
|
logger.info(
|
|
f"System HighFive version {h5_lib_version} is not supported. "
|
|
"Using private installation instead.")
|
|
else:
|
|
env["system_highfive"] = True
|
|
logger.info("Using system installation of HighFive library.")
|
|
env["HIGHFIVE_VERSION"] = h5_lib_version.strip()
|
|
else:
|
|
config_error("Detected invalid HighFive configuration.")
|
|
|
|
highfive_include = "<highfive/H5DataType.hpp>"
|
|
|
|
elif env["system_highfive"] == "y":
|
|
config_error(
|
|
"Expected system installation of HighFive library, but it is either "
|
|
"corrupted or could not be found.")
|
|
|
|
if env["use_hdf5"] and env["system_highfive"] in ("n", "default"):
|
|
env["system_highfive"] = False
|
|
if not Path("ext/HighFive/include").is_dir():
|
|
checkout_submodule("HighFive", "ext/HighFive")
|
|
|
|
def highfive_version(cmake_lists):
|
|
"""Read highfive version from CMakeLists.txt"""
|
|
h5_version = Path(cmake_lists).read_text()
|
|
h5_version = [line for line in h5_version.split("\n")
|
|
if line.startswith("project(HighFive")]
|
|
return re.search(r'[0-9]+\.[0-9]+\.[0-9]+', h5_version[0]).group(0)
|
|
|
|
env["HIGHFIVE_VERSION"] = highfive_version("ext/HighFive/CMakeLists.txt")
|
|
highfive_include = '"../ext/HighFive/include/highfive/H5DataType.hpp"'
|
|
logger.info(f"Using private installation of HighFive library.")
|
|
|
|
if env["use_hdf5"]:
|
|
if conf.CheckStatement("HighFive::details::Boolean::HighFiveTrue",
|
|
f"#include {highfive_include}"):
|
|
env["highfive_boolean"] = True
|
|
|
|
retcode, hdf_version = run_preprocessor(
|
|
conf, ['"H5public.h"'], "H5_VERS_MAJOR H5_VERS_MINOR H5_VERS_RELEASE"
|
|
)
|
|
if retcode and hdf_version:
|
|
env["HDF_VERSION"] = ".".join(hdf_version.strip().split())
|
|
logger.info(
|
|
f"Using HighFive version {env['HIGHFIVE_VERSION']} "
|
|
f"for HDF5 {env['HDF_VERSION']}")
|
|
else:
|
|
logger.warning("Failed to determine HDF5 version.")
|
|
|
|
def set_fortran(pattern, value):
|
|
# Set compiler / flags for all Fortran versions to be the same
|
|
for version in ("FORTRAN", "F77", "F90", "F95", "F03", "F08"):
|
|
env[pattern.format(version)] = value
|
|
|
|
# Try to find a working Fortran compiler:
|
|
def check_fortran(compiler, expected=False):
|
|
hello_world = '''
|
|
program main
|
|
write(*,'(a)') 'Hello, world!'
|
|
end program main
|
|
'''
|
|
if which(compiler):
|
|
set_fortran("{}", compiler)
|
|
success, output = conf.TryRun(hello_world, '.f90')
|
|
if success and 'Hello, world!' in output:
|
|
return True
|
|
else:
|
|
logger.warning(f"Unable to use {compiler!r} to compile the Fortran "
|
|
"interface. See config.log for details.")
|
|
return False
|
|
elif expected:
|
|
logger.error(f"Could not find specified Fortran compiler: {compiler!r}")
|
|
sys.exit(1)
|
|
|
|
return False
|
|
|
|
set_fortran("{}FLAGS", env["FORTRANFLAGS"])
|
|
|
|
if env["using_apple_clang"] and env["f90_interface"] == "default":
|
|
env["f90_interface"] = "n"
|
|
|
|
if env['f90_interface'] in ('y','default'):
|
|
foundF90 = False
|
|
if env['FORTRAN']:
|
|
foundF90 = check_fortran(env['FORTRAN'], True)
|
|
|
|
for compiler in ("pgfortran", "gfortran", "ifort", "ifx", "g95"):
|
|
if foundF90:
|
|
break
|
|
foundF90 = check_fortran(compiler)
|
|
|
|
if foundF90:
|
|
logger.info(f"Using {env['FORTRAN']!r} to build the Fortran 90 interface")
|
|
env['f90_interface'] = 'y'
|
|
else:
|
|
if env['f90_interface'] == 'y':
|
|
logger.error("Could not find a suitable Fortran compiler to build the Fortran 90 interface.")
|
|
sys.exit(1)
|
|
else:
|
|
env['f90_interface'] = 'n'
|
|
env['FORTRAN'] = ''
|
|
logger.info("Skipping compilation of the Fortran 90 interface.")
|
|
|
|
if 'pgfortran' in env['FORTRAN']:
|
|
env['FORTRANMODDIRPREFIX'] = '-module '
|
|
elif 'gfortran' in env['FORTRAN']:
|
|
env['FORTRANMODDIRPREFIX'] = '-J'
|
|
elif 'g95' in env['FORTRAN']:
|
|
env['FORTRANMODDIRPREFIX'] = '-fmod='
|
|
elif 'ifort' in env['FORTRAN']:
|
|
env['FORTRANMODDIRPREFIX'] = '-module '
|
|
elif "ifx" in env["FORTRAN"]:
|
|
env["FORTRANMODDIRPREFIX"] = "-module "
|
|
|
|
set_fortran("{}", env["FORTRAN"])
|
|
set_fortran("SH{}", env["FORTRAN"])
|
|
env['FORTRANMODDIR'] = '${TARGET.dir}'
|
|
|
|
env = conf.Finish()
|
|
|
|
debug_message = [
|
|
f"\n{' begin config.log ':-^80}\n",
|
|
open("config.log").read().strip(),
|
|
f"\n{' end config.log ':-^80}\n",
|
|
]
|
|
logger.debug("\n".join(debug_message), print_level=False)
|
|
|
|
env['python_cmd_esc'] = quoted(env['python_cmd'])
|
|
env["python_min_version"] = python_min_version
|
|
env["python_max_version"] = python_max_version
|
|
env["py_requires_ver_str"] = py_requires_ver_str
|
|
env["cython_version_spec"] = SpecifierSet(">=0.29.31", prereleases=True)
|
|
# When updating NumPy spec, also update interfaces/python_sdist/pyproject.toml.in.
|
|
env["numpy_version_spec"] = SpecifierSet(">=1.21.0,<3", prereleases=True)
|
|
env["cython_version_spec_str"] = str(env["cython_version_spec"])
|
|
env["numpy_version_spec_str"] = str(env["numpy_version_spec"])
|
|
|
|
# We choose ruamel.yaml 0.17.16 as the minimum version since it is the highest version
|
|
# available in the Ubuntu 22.04 repositories. When updating this, also update the
|
|
# version string in interfaces/python_sdist/pyproject.toml.in.
|
|
env["ruamel_version_spec"] = SpecifierSet(">=0.17.16", prereleases=True)
|
|
env["ruamel_version_spec_str"] = str(env["ruamel_version_spec"])
|
|
|
|
# Minimum pytest version assumed based on Ubuntu 20.04
|
|
env["pytest_version_spec"] = SpecifierSet(">=4.6.9", prereleases=True)
|
|
|
|
env['install_python_action'] = ''
|
|
env['python_module_loc'] = ''
|
|
env["python_module"] = None
|
|
env["ct_pyscriptdir"] = "<not installed>"
|
|
|
|
if env['python_package'] != 'n':
|
|
python_config = check_for_python(env, COMMAND_LINE_TARGETS)
|
|
env["python_package"] = python_config["python_package"]
|
|
if python_config["python_package"] == "y":
|
|
env["require_numpy_1_7_API"] = python_config["require_numpy_1_7_API"]
|
|
|
|
if env["python_package"] == "y" and env["OS"] == "Darwin":
|
|
# We need to know the macOS deployment target in advance to be able to determine
|
|
# the name of the wheel file for the Python module. If this is not specified by the
|
|
# MACOSX_DEPLOYMENT_TARGET environment variable, get the value from the Python
|
|
# installation and use that.
|
|
mac_target = env["ENV"].get("MACOSX_DEPLOYMENT_TARGET", None)
|
|
if not mac_target:
|
|
info = get_command_output(
|
|
env["python_cmd"],
|
|
"-c",
|
|
"import sysconfig; print(sysconfig.get_platform())"
|
|
)
|
|
mac_target = info.split("-")[1]
|
|
if parse_version(mac_target) < parse_version('10.15'):
|
|
# macOS 10.15 is the minimum version with C++17 support
|
|
mac_target = '10.15'
|
|
|
|
env["ENV"]["MACOSX_DEPLOYMENT_TARGET"] = mac_target
|
|
logger.info(f"MACOSX_DEPLOYMENT_TARGET = {mac_target}")
|
|
|
|
|
|
# **********************************************
|
|
# *** Set additional configuration variables ***
|
|
# **********************************************
|
|
|
|
# Identify options selected either on command line or in cantera.conf
|
|
selected_options = set(line.split("=")[0].strip()
|
|
for line in cantera_conf.splitlines())
|
|
|
|
# Always set the stage directory before building an MSI installer
|
|
if "msi" in COMMAND_LINE_TARGETS:
|
|
COMMAND_LINE_TARGETS.append("install")
|
|
env["stage_dir"] = "stage"
|
|
env["prefix"] = "."
|
|
selected_options.add("prefix")
|
|
selected_options.add("stage_dir")
|
|
env["python_package"] = "n"
|
|
|
|
env["default_prefix"] = True
|
|
if "prefix" in selected_options:
|
|
env["default_prefix"] = False
|
|
|
|
# Use posix-style paths on all platforms
|
|
env["prefix"] = Path(env["prefix"]).as_posix()
|
|
|
|
# Check whether Cantera should be installed into a conda environment
|
|
if conda_prefix is not None and sys.executable.startswith(str(conda_prefix)):
|
|
# use conda layout unless any 'blocking' options were specified
|
|
blocking_options = {"layout", "prefix", "python_prefix", "python_cmd"}
|
|
if not selected_options & blocking_options:
|
|
env["layout"] = "conda"
|
|
# Directories where things will be after actually being installed. These
|
|
# variables are the ones that are used to populate header files, scripts,
|
|
# etc.
|
|
conda_prefix = Path(conda_prefix)
|
|
if "stage_dir" in selected_options:
|
|
env["prefix"] = (conda_prefix.relative_to(conda_prefix.parents[2])).as_posix()
|
|
else:
|
|
env["prefix"] = conda_prefix.resolve().as_posix()
|
|
logger.info(
|
|
f"Using conda environment as default 'prefix': {env['prefix']}")
|
|
elif env["layout"] == "conda" and not env["package_build"]:
|
|
logger.error("Layout option 'conda' requires a conda environment.")
|
|
sys.exit(1)
|
|
|
|
prefix = Path(env["prefix"])
|
|
|
|
if env["layout"] == "conda" and os.name == "nt":
|
|
env["ct_libdir"] = (prefix / "Library" / "lib").as_posix()
|
|
env["ct_shlibdir"] = (prefix / "Library" / "bin").as_posix()
|
|
env["ct_bindir"] = (prefix / "Scripts").as_posix()
|
|
env["ct_python_bindir"] = (prefix / "Scripts").as_posix()
|
|
env["ct_incdir"] = (prefix / "Library" / "include" / "cantera").as_posix()
|
|
env["ct_incroot"] = (prefix / "Library" / "include").as_posix()
|
|
else:
|
|
if "stage_dir" not in selected_options:
|
|
prefix = prefix.resolve()
|
|
env["prefix"] = prefix.as_posix()
|
|
env["ct_libdir"] = (prefix / env["libdirname"]).as_posix()
|
|
env["ct_bindir"] = (prefix / "bin").as_posix()
|
|
|
|
# On Windows, the search path for DLLs is the "bin" dir. "lib" dirs are used only for
|
|
# static and "import" libraries
|
|
if env["OS"] == "Windows":
|
|
env["ct_shlibdir"] = env["ct_bindir"]
|
|
else:
|
|
env["ct_shlibdir"] = env["ct_libdir"]
|
|
|
|
env["ct_python_bindir"] = (prefix / "bin").as_posix()
|
|
env["ct_incdir"] = (prefix / "include" / "cantera").as_posix()
|
|
env["ct_incroot"] = (prefix / "include").as_posix()
|
|
|
|
env["ct_installroot"] = env["prefix"]
|
|
|
|
if env["layout"] == "compact":
|
|
env["ct_datadir"] = (prefix / "data").as_posix()
|
|
env["ct_sampledir"] = (prefix / "samples").as_posix()
|
|
env["ct_docdir"] = (prefix / "doc").as_posix()
|
|
env["ct_mandir"] = (prefix / "man1").as_posix()
|
|
else:
|
|
env["ct_datadir"] = (prefix / "share" / "cantera" / "data").as_posix()
|
|
env["ct_sampledir"] = (prefix / "share" / "cantera" / "samples").as_posix()
|
|
env["ct_docdir"] = (prefix / "share" / "cantera" / "doc").as_posix()
|
|
env["ct_mandir"] = (prefix / "share" / "man" / "man1").as_posix()
|
|
|
|
|
|
addInstallActions = ('install' in COMMAND_LINE_TARGETS or
|
|
'uninstall' in COMMAND_LINE_TARGETS)
|
|
|
|
# Directories where things will be staged for package creation. These
|
|
# variables should always be used by the Install(...) targets
|
|
if env["stage_dir"]:
|
|
stage_prefix = Path(env["prefix"])
|
|
# Strip the root off the prefix if it's absolute
|
|
if stage_prefix.is_absolute():
|
|
stage_prefix = Path(*stage_prefix.parts[1:])
|
|
|
|
instRoot = (Path.cwd().joinpath(env["stage_dir"], stage_prefix)).as_posix()
|
|
else:
|
|
instRoot = env["prefix"]
|
|
|
|
# Prevent setting Cantera installation path to source directory
|
|
if os.path.abspath(instRoot) == Dir('.').abspath:
|
|
logger.error("cannot install Cantera into source directory.")
|
|
sys.exit(1)
|
|
|
|
env["inst_root"] = instRoot
|
|
locations = ["libdir", "shlibdir", "bindir", "python_bindir", "incdir", "incroot",
|
|
"datadir", "sampledir", "docdir", "mandir"]
|
|
for loc in locations:
|
|
if env["prefix"] == ".":
|
|
env[f"inst_{loc}"] = (Path(instRoot) / env[f"ct_{loc}"]).as_posix()
|
|
else:
|
|
env[f"inst_{loc}"] = env[f"ct_{loc}"].replace(env["ct_installroot"], instRoot)
|
|
|
|
if env['use_rpath_linkage']:
|
|
env.Append(RPATH=env['ct_libdir'])
|
|
|
|
# **************************************
|
|
# *** Set options needed in config.h ***
|
|
# **************************************
|
|
|
|
configh = {}
|
|
|
|
configh['CANTERA_VERSION'] = quoted(env['cantera_version'])
|
|
configh['CANTERA_SHORT_VERSION'] = quoted(env['cantera_short_version'])
|
|
|
|
# Conditional defines
|
|
def cdefine(definevar, configvar, comp=True, value=1):
|
|
if env.get(configvar) == comp:
|
|
configh[definevar] = value
|
|
else:
|
|
configh[definevar] = None
|
|
|
|
# Update RPATH with additional library directories
|
|
if env["OS"] == "Darwin" and env["use_rpath_linkage"] and not env.subst("$__RPATH"):
|
|
# SCons doesn't want to specify RPATH on macOS, so circumvent that behavior by
|
|
# specifying this directly as part of LINKFLAGS
|
|
env.Append(LINKFLAGS=[d for x in env['RPATH']
|
|
if (d := env.subst(f'$RPATHPREFIX{x}$RPATHSUFFIX')) not in env['LINKFLAGS']])
|
|
|
|
if env.get('has_sundials_lapack') and env['use_lapack']:
|
|
configh['CT_SUNDIALS_USE_LAPACK'] = 1
|
|
else:
|
|
configh['CT_SUNDIALS_USE_LAPACK'] = 0
|
|
|
|
cdefine('LAPACK_FTN_STRING_LEN_AT_END', 'lapack_ftn_string_len_at_end')
|
|
cdefine('LAPACK_FTN_TRAILING_UNDERSCORE', 'lapack_ftn_trailing_underscore')
|
|
cdefine('FTN_TRAILING_UNDERSCORE', 'lapack_ftn_trailing_underscore')
|
|
cdefine('CT_USE_LAPACK', 'use_lapack')
|
|
cdefine("CT_USE_HDF5", "use_hdf5")
|
|
cdefine("CT_USE_SYSTEM_HIGHFIVE", "system_highfive")
|
|
cdefine("CT_USE_HIGHFIVE_BOOLEAN", "highfive_boolean")
|
|
cdefine("CT_USE_SYSTEM_EIGEN", "system_eigen")
|
|
cdefine("CT_USE_SYSTEM_EIGEN_PREFIXED", "system_eigen_prefixed")
|
|
cdefine('CT_USE_SYSTEM_FMT', 'system_fmt')
|
|
cdefine('CT_USE_SYSTEM_YAMLCPP', 'system_yamlcpp')
|
|
|
|
config_h_build = env.Command('build/src/config.h.build',
|
|
'include/cantera/base/config.h.in',
|
|
ConfigBuilder(configh))
|
|
# This separate copy operation, which SCons will skip if config.h.build is
|
|
# unmodified, prevents unnecessary rebuilds of the precompiled header
|
|
config_h = env.Command('include/cantera/base/config.h',
|
|
'build/src/config.h.build',
|
|
Copy('$TARGET', '$SOURCE'))
|
|
env.AlwaysBuild(config_h_build)
|
|
env['config_h_target'] = config_h
|
|
|
|
# *********************
|
|
# *** Build Cantera ***
|
|
# *********************
|
|
|
|
# Some options to speed up SCons
|
|
env.SetOption('max_drift', 2)
|
|
env.SetOption('implicit_cache', True)
|
|
|
|
buildTargets = []
|
|
env['build_targets'] = buildTargets
|
|
libraryTargets = [] # objects that go in the Cantera library
|
|
installTargets = []
|
|
sampleTargets = []
|
|
|
|
def build(targets):
|
|
""" Wrapper to add target to list of build targets """
|
|
buildTargets.extend(targets)
|
|
return targets
|
|
|
|
def buildSample(*args, **kwargs):
|
|
""" Wrapper to add target to list of samples """
|
|
targets = args[0](*args[1:], **kwargs)
|
|
sampleTargets.extend(targets)
|
|
return targets
|
|
|
|
def install(*args, **kwargs):
|
|
""" Wrapper to add target to list of install targets """
|
|
if not addInstallActions:
|
|
return
|
|
if len(args) == 2:
|
|
inst = env.Install(*args, **kwargs)
|
|
else:
|
|
inst = args[0](*args[1:], **kwargs)
|
|
|
|
installTargets.extend(inst)
|
|
return inst
|
|
|
|
|
|
env.SConsignFile()
|
|
|
|
env.Prepend(CPPPATH=[],
|
|
LIBPATH=[Dir('build/lib')])
|
|
|
|
# Add build/lib to library search path in order to find Cantera shared library
|
|
if env['OS'] == 'Windows':
|
|
env.PrependENVPath('PATH', Dir('#build/lib').abspath)
|
|
elif env['OS'] == 'Darwin':
|
|
env.PrependENVPath('DYLD_LIBRARY_PATH', Dir('#build/lib').abspath)
|
|
else:
|
|
env.PrependENVPath('LD_LIBRARY_PATH', Dir('#build/lib').abspath)
|
|
|
|
|
|
if (env["example_data"]
|
|
and not list(Path("data/example_data").glob("*.yaml"))
|
|
):
|
|
checkout_submodule("cantera-example-data", "data/example_data")
|
|
|
|
|
|
if addInstallActions:
|
|
# Put headers in place
|
|
install(env.RecursiveInstall, '$inst_incdir', 'include/cantera')
|
|
|
|
# Data files
|
|
for yaml in multi_glob(env, "data", "yaml"):
|
|
install("$inst_datadir", yaml)
|
|
|
|
if env["example_data"]:
|
|
for yaml in multi_glob(env, "data/example_data", "yaml"):
|
|
install("$inst_datadir/example_data", yaml)
|
|
|
|
# List of shared libraries needed to link to Cantera
|
|
if env["renamed_shared_libraries"]:
|
|
env["cantera_shared_libs"] = ["cantera_shared"]
|
|
else:
|
|
env["cantera_shared_libs"] = ["cantera"]
|
|
|
|
# External libraries to link to
|
|
env["external_libs"] = []
|
|
env["external_libs"].extend(env["sundials_libs"])
|
|
|
|
if env["OS"] == "Linux":
|
|
env["external_libs"].append("dl")
|
|
|
|
if env["use_hdf5"]:
|
|
env["external_libs"].append(env["hdf5_lib"])
|
|
|
|
if env["system_fmt"]:
|
|
env["external_libs"].append("fmt")
|
|
# Usually need to link to fmt directly because of templated/inlined code that calls
|
|
# fmt
|
|
env["cantera_shared_libs"].append("fmt")
|
|
|
|
if env["system_yamlcpp"]:
|
|
env["external_libs"].append("yaml-cpp")
|
|
|
|
if env["blas_lapack_libs"]:
|
|
env["external_libs"].extend(env["blas_lapack_libs"])
|
|
|
|
# List of static libraries needed to link to Cantera
|
|
env["cantera_libs"] = ["cantera"] + env["external_libs"]
|
|
|
|
# Add targets from the SConscript files in the various subdirectories
|
|
Export('env', 'build', 'libraryTargets', 'install', 'buildSample', "configh")
|
|
|
|
# ext needs to come before src so that libraryTargets is fully populated
|
|
VariantDir('build/ext', 'ext', duplicate=0)
|
|
SConscript('build/ext/SConscript')
|
|
|
|
# Fortran needs to come before src so that libraryTargets is fully populated
|
|
if env['f90_interface'] == 'y':
|
|
VariantDir('build/src/fortran/', 'src/fortran', duplicate=1)
|
|
SConscript('build/src/fortran/SConscript')
|
|
|
|
VariantDir('build/src', 'src', duplicate=0)
|
|
SConscript('build/src/SConscript')
|
|
|
|
if env["python_package"] == "y":
|
|
VariantDir("build/python", "interfaces/cython", duplicate=True)
|
|
SConscript("build/python/SConscript")
|
|
|
|
if env['CC'] != 'cl':
|
|
VariantDir('build/platform', 'platform/posix', duplicate=0)
|
|
SConscript('build/platform/SConscript')
|
|
|
|
if env['doxygen_docs'] or env['sphinx_docs']:
|
|
SConscript('doc/SConscript')
|
|
|
|
# Sample programs (also used from test_problems/SConscript)
|
|
VariantDir('build/samples', 'samples', duplicate=0)
|
|
sampledir_excludes = ['\\.o$', '^~$', '\\.in', 'SConscript']
|
|
SConscript('build/samples/cxx/SConscript')
|
|
SConscript('build/samples/clib/SConscript')
|
|
|
|
# Install C++ / C samples
|
|
install(env.RecursiveInstall, '$inst_sampledir/cxx',
|
|
'samples/cxx', exclude=sampledir_excludes)
|
|
install(env.RecursiveInstall, '$inst_sampledir/clib',
|
|
'samples/clib', exclude=sampledir_excludes)
|
|
|
|
if env['f90_interface'] == 'y':
|
|
SConscript('build/samples/f77/SConscript')
|
|
SConscript('build/samples/f90/SConscript')
|
|
|
|
# install F90 / F77 samples
|
|
install(env.RecursiveInstall, '$inst_sampledir/f77',
|
|
'samples/f77', sampledir_excludes)
|
|
install(env.RecursiveInstall, '$inst_sampledir/f90',
|
|
'samples/f90', sampledir_excludes)
|
|
|
|
### Meta-targets ###
|
|
build_samples = Alias('samples', sampleTargets)
|
|
|
|
def postBuildMessage(target, source, env):
|
|
build_message = [
|
|
f"\n{' Compilation completed successfully ':*^80}\n",
|
|
"- To run the test suite, type 'scons test'.",
|
|
"- To list available tests, type 'scons test-help'.",
|
|
]
|
|
if env["googletest"] == "none":
|
|
build_message.append(" WARNING: You set the 'googletest' to 'none' "
|
|
"and all its tests will be skipped.")
|
|
build_message.append("- To install, type 'scons install'.")
|
|
if os.name == 'nt':
|
|
build_message.append("- To create a Windows MSI installer, type 'scons msi'.")
|
|
build_message.append(f"\n{'*' * 80}\n")
|
|
|
|
logger.status("\n".join(build_message), print_level=False)
|
|
|
|
finish_build = env.Command('finish_build', [], postBuildMessage)
|
|
env.Depends(finish_build, buildTargets)
|
|
build_cantera = Alias('build', finish_build)
|
|
|
|
Default('build')
|
|
|
|
def postInstallMessage(target, source, env):
|
|
env_dict = env.Dictionary()
|
|
locations = {
|
|
"library files": "ct_libdir",
|
|
"C++ headers": "ct_incroot",
|
|
"samples": "ct_sampledir",
|
|
"data files": "ct_datadir",
|
|
"input file converters": "ct_pyscriptdir",
|
|
}
|
|
install_message = ["File locations:\n"]
|
|
locations_message = " {name:<28}{location}"
|
|
for name, location in locations.items():
|
|
install_message.append(locations_message.format(
|
|
name=name, location=env_dict[location]
|
|
))
|
|
|
|
if env["sphinx_docs"] or env["doxygen_docs"]:
|
|
name = "HTML documentation"
|
|
install_message.append(locations_message.format(
|
|
name="HTML documentation", location=env_dict["inst_docdir"]
|
|
))
|
|
|
|
if env["python_package"] == "y":
|
|
env["python_example_loc"] = (Path(env["ct_sampledir"]) / "python").as_posix()
|
|
install_message.append(locations_message.format(
|
|
name="Python package", location=env_dict["python_module_loc"]
|
|
))
|
|
install_message.append(locations_message.format(
|
|
name="Python examples", location=env_dict["python_example_loc"]
|
|
))
|
|
|
|
status = f" Cantera {env['cantera_version']} has been successfully installed "
|
|
install_message = [
|
|
f"\n{status:*^80}\n",
|
|
"\n".join(install_message),
|
|
f"\n{'*' * 80}\n",
|
|
]
|
|
logger.status("\n".join(install_message), print_level=False)
|
|
|
|
finish_install = env.Command("finish_install", [], postInstallMessage)
|
|
env.Depends(finish_install, installTargets)
|
|
install_cantera = Alias('install', finish_install)
|
|
|
|
### Uninstallation
|
|
def getParentDirs(path, top=True):
|
|
head,tail = os.path.split(path)
|
|
if head == os.path.abspath(env['prefix']):
|
|
return [path]
|
|
elif not tail:
|
|
if head.endswith(os.sep):
|
|
return []
|
|
else:
|
|
return [head]
|
|
elif top:
|
|
return getParentDirs(head, False)
|
|
else:
|
|
return getParentDirs(head, False) + [path]
|
|
|
|
# Files installed by SCons
|
|
allfiles = FindInstalledFiles()
|
|
|
|
# After removing files (which SCons keeps track of),
|
|
# remove any empty directories (which SCons doesn't track)
|
|
def removeDirectories(target, source, env):
|
|
# Get all directories where files are installed
|
|
alldirs = set()
|
|
for f in allfiles:
|
|
alldirs.update(getParentDirs(f.path))
|
|
if env['layout'] == 'compact':
|
|
alldirs.add(os.path.abspath(env['prefix']))
|
|
# Sort in order of decreasing directory length so that empty subdirectories
|
|
# will be removed before their parents are checked.
|
|
alldirs = sorted(alldirs, key=lambda x: -len(x))
|
|
|
|
# Don't remove directories that probably existed before installation,
|
|
# even if they are empty
|
|
keepDirs = ['local/share', 'local/lib', 'local/include', 'local/bin',
|
|
'man/man1', 'dist-packages', 'site-packages']
|
|
for d in alldirs:
|
|
if any(d.endswith(k) for k in keepDirs):
|
|
continue
|
|
if os.path.isdir(d) and not os.listdir(d):
|
|
os.rmdir(d)
|
|
|
|
uninstall = env.Command("uninstall", None, Delete(allfiles))
|
|
env.AddPostAction(uninstall, Action(removeDirectories))
|
|
if env["python_package"] == "n":
|
|
env.AddPostAction(uninstall, Action("$python_cmd_esc -m pip uninstall -y Cantera"))
|
|
|
|
### Windows MSI Installer ###
|
|
if 'msi' in COMMAND_LINE_TARGETS:
|
|
def build_wxs(target, source, env):
|
|
import wxsgen
|
|
wxs = wxsgen.WxsGenerator(env['stage_dir'],
|
|
short_version=env['cantera_short_version'],
|
|
full_version=env['cantera_pure_version'],
|
|
x64=env['TARGET_ARCH']=='amd64')
|
|
wxs.make_wxs(str(target[0]))
|
|
|
|
wxs_target = env.Command('build/wix/cantera.wxs', [], build_wxs)
|
|
env.AlwaysBuild(wxs_target)
|
|
|
|
env.Append(WIXLIGHTFLAGS=['-ext', 'WixUIExtension'])
|
|
msi_target = env.WiX('cantera.msi', ['build/wix/cantera.wxs'])
|
|
env.Depends(wxs_target, installTargets)
|
|
env.Depends(msi_target, wxs_target)
|
|
build_msi = Alias('msi', msi_target)
|
|
|
|
### Tests ###
|
|
if any(target.startswith(('test', 'build-')) for target in COMMAND_LINE_TARGETS):
|
|
env['testNames'] = []
|
|
env['test_results'] = env.Command('test_results', [], test_results.print_report)
|
|
|
|
if env["python_package"] != "n":
|
|
env.PrependENVPath('PYTHONPATH', Dir('build/python').abspath)
|
|
|
|
env['ENV']['PYTHON_CMD'] = env.subst('$python_cmd')
|
|
|
|
# Tests written using the gtest framework or the Python unittest module
|
|
VariantDir('build/test', 'test', duplicate=0)
|
|
SConscript('build/test/SConscript')
|
|
|
|
# Regression tests
|
|
SConscript('test_problems/SConscript')
|
|
|
|
if 'test-help' in COMMAND_LINE_TARGETS:
|
|
print('\n*** Available tests ***\n')
|
|
for name in env['testNames']:
|
|
print('test-%s' % name)
|
|
sys.exit(0)
|
|
|
|
Alias('test', env['test_results'])
|
|
def set_error_code():
|
|
# After running all tests, exit with non-zero status if any tests have failed.
|
|
if test_results.failed:
|
|
sys.stdout.flush()
|
|
sys.stderr.flush()
|
|
os._exit(1)
|
|
atexit.register(set_error_code)
|
|
|
|
### Dump (debugging SCons)
|
|
if 'dump' in COMMAND_LINE_TARGETS:
|
|
import pprint
|
|
# Typical usage: 'scons build dump'
|
|
print('os.environ:\n', pprint.pprint(dict(os.environ)))
|
|
print('env.Dump():\n', env.Dump())
|
|
sys.exit(0)
|