From e9cf5eb64367e7d1896fdf7206358f8d888491f2 Mon Sep 17 00:00:00 2001 From: Jonah Maxwell Miller Date: Tue, 27 Oct 2026 07:24:15 -0400 Subject: [PATCH 1/3] remove eigen --- .github/workflows/sanitizer.yml | 1 + .github/workflows/tests.yml | 2 + .github/workflows/tests_clang.yml | 1 + .github/workflows/tests_minimal.yml | 1 + .github/workflows/tests_minimal_kokkos.yml | 4 ++ .github/workflows/warnings.yml | 1 + .gitmodules | 3 -- CMakeLists.txt | 44 ++++--------------- CMakePresets.json | 3 +- README.build.md | 15 +++++-- README.spack.md | 7 ++- cmake/install.cmake | 2 +- cmake/singularity-eos/Eigen3.cmake | 23 ---------- cmake/singularity-eos/kokkos.cmake | 3 -- cmake/submodule_configs.cmake | 8 ---- config/singularity-eosConfig.cmake.in | 6 +-- doc/sphinx/src/building.rst | 20 +++++---- example/CMakeLists.txt | 6 ++- .../kinetic_phasetransition_methods.hpp | 8 ---- .../kinetic_phasetransition_models.hpp | 8 ---- .../closure/kinetic_phasetransition_utils.hpp | 8 ---- singularity-eos/closure/mixed_cell_models.hpp | 29 +++--------- test/CMakeLists.txt | 2 +- test/test_solver_utils.cpp | 3 +- utils/eigen | 1 - utils/scripts/create_tar.sh | 2 - 26 files changed, 66 insertions(+), 145 deletions(-) delete mode 100644 cmake/singularity-eos/Eigen3.cmake delete mode 160000 utils/eigen diff --git a/.github/workflows/sanitizer.yml b/.github/workflows/sanitizer.yml index d16b132954e..faee7264e54 100644 --- a/.github/workflows/sanitizer.yml +++ b/.github/workflows/sanitizer.yml @@ -35,6 +35,7 @@ jobs: -DSINGULARITY_BUILD_TESTS=ON \ -DSINGULARITY_FORCE_SUBMODULE_MODE=ON \ -DSINGULARITY_USE_KOKKOS=ON \ + -DSINGULARITY_BUILD_CLOSURE=ON \ .. make -j4 ctest --output-on-failure diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 9b164e416af..dfd173f3d28 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -34,6 +34,8 @@ jobs: cmake -DCMAKE_INSTALL_PREFIX=${HOME}/install \ -DSINGULARITY_USE_SPINER=ON \ -DSINGULARITY_BUILD_TESTS=ON \ + -DSINGULARITY_BUILD_CLOSURE=ON \ + -DSINGULARITY_USE_KOKKOS=ON \ -DSINGULARITY_BUILD_EXAMPLES=ON \ -DSINGULARITY_BUILD_PYTHON=ON \ -DSINGULARITY_TEST_SESAME=OFF \ diff --git a/.github/workflows/tests_clang.yml b/.github/workflows/tests_clang.yml index f0d56d917b8..560ba67caa8 100644 --- a/.github/workflows/tests_clang.yml +++ b/.github/workflows/tests_clang.yml @@ -45,6 +45,7 @@ jobs: -DSINGULARITY_FORCE_SUBMODULE_MODE=ON \ -DSINGULARITY_USE_V_AND_V_EOS=OFF \ -DSINGULARITY_USE_KOKKOS=OFF \ + -DSINGULARITY_BUILD_CLOSURE=OFF \ -DSINGULARITY_PLUGINS=$(pwd)/../example/plugin \ -DCMAKE_CXX_FLAGS="-Wall -Werr" \ -DCMAKE_LINKER=ld.gold \ diff --git a/.github/workflows/tests_minimal.yml b/.github/workflows/tests_minimal.yml index 52f2e70e361..6686b22e3c5 100644 --- a/.github/workflows/tests_minimal.yml +++ b/.github/workflows/tests_minimal.yml @@ -33,6 +33,7 @@ jobs: -DSINGULARITY_BUILD_TESTS=ON \ -DSINGULARITY_FORCE_SUBMODULE_MODE=ON \ -DSINGULARITY_USE_KOKKOS=OFF \ + -DSINGULARITY_BUILD_CLOSURE=OFF \ .. make -j4 make install diff --git a/.github/workflows/tests_minimal_kokkos.yml b/.github/workflows/tests_minimal_kokkos.yml index 5038f44b4b1..e77c55970ca 100644 --- a/.github/workflows/tests_minimal_kokkos.yml +++ b/.github/workflows/tests_minimal_kokkos.yml @@ -10,6 +10,9 @@ jobs: tests-minimal: name: Run minimal set of tests, to constrain minimal build runs-on: ubuntu-latest + strategy: + matrix: + closure: ["ON", "OFF"] steps: - name: Checkout code @@ -33,6 +36,7 @@ jobs: -DSINGULARITY_BUILD_TESTS=ON \ -DSINGULARITY_FORCE_SUBMODULE_MODE=ON \ -DSINGULARITY_USE_KOKKOS=ON \ + -DSINGULARITY_BUILD_CLOSURE=${{ matrix.closure }} \ .. make -j4 make install diff --git a/.github/workflows/warnings.yml b/.github/workflows/warnings.yml index 98316b7ccf1..09a525f1522 100644 --- a/.github/workflows/warnings.yml +++ b/.github/workflows/warnings.yml @@ -33,5 +33,6 @@ jobs: -DSINGULARITY_BUILD_TESTS=ON \ -DSINGULARITY_FORCE_SUBMODULE_MODE=ON \ -DSINGULARITY_USE_KOKKOS=ON \ + -DSINGULARITY_BUILD_CLOSURE=ON \ .. make -j4 diff --git a/.gitmodules b/.gitmodules index 8aaf27b1c93..c71cd19a414 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,6 +1,3 @@ -[submodule "utils/eigen"] - path = utils/eigen - url = https://gitlab.com/libeigen/eigen.git [submodule "utils/spiner"] path = utils/spiner url = https://github.com/lanl/spiner diff --git a/CMakeLists.txt b/CMakeLists.txt index bdffedefef6..5c94b2a16bb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -70,14 +70,10 @@ cmake_dependent_option(SINGULARITY_EOSPAC_USE_MODERN_ERROR_CODES "Use the current eospac implementation of error codes, which must be compared with a function. Requires EOSPAC version 6.3.0 or greater." ON "SINGULARITY_USE_EOSPAC" OFF) -# TODO This should be dependent option (or fortran option) -option(SINGULARITY_BUILD_CLOSURE "Mixed Cell Closure" ON) +option(SINGULARITY_BUILD_CLOSURE "Mixed Cell Closure (requires Kokkos and Kokkos Kernels)" OFF) cmake_dependent_option(SINGULARITY_USE_CUDA "Use CUDA backend of Kokkos" OFF "SINGULARITY_USE_KOKKOS" OFF) -cmake_dependent_option( - SINGULARITY_USE_KOKKOSKERNELS "Use KokkosKernels for LA routines" ON - "SINGULARITY_USE_KOKKOS;SINGULARITY_BUILD_CLOSURE" OFF) # extra build options option(SINGULARITY_BUILD_PYTHON "Compile Python bindings" OFF) @@ -177,7 +173,6 @@ endif() # ------------------------------------------------------------------------------# # Load CMake modules for finding dependencies -include(singularity-eos/Eigen3) include(singularity-eos/eospac) include(singularity-eos/hdf5) include(singularity-eos/kokkos) @@ -273,20 +268,12 @@ if(SINGULARITY_FORCE_SUBMODULE_MODE) set(SINGULARITY_SUBMODULE_MODE ON) endif() -# Use to determine if Eigen is used or not -set(SINGULARITY_USE_EIGEN - OFF - CACHE BOOL "" FORCE) -if(SINGULARITY_BUILD_CLOSURE AND NOT SINGULARITY_USE_KOKKOSKERNELS) - if(SINGULARITY_USE_CUDA) - message( - FATAL_ERROR - "\"SINGULARITY_BUILD_CLOSURE=ON\" and \"SINGULARITY_USE_CUDA=ON\" requires \"SINGULARITY_USE_KOKKOSKERNELS=ON\"" - ) +if(SINGULARITY_BUILD_CLOSURE) + if(NOT SINGULARITY_USE_KOKKOS) + message(FATAL_ERROR + "SINGULARITY_BUILD_CLOSURE=ON requires SINGULARITY_USE_KOKKOS=ON. " + "Enable Kokkos or disable mixed cell closures.") endif() - set(SINGULARITY_USE_EIGEN - ON - CACHE BOOL "" FORCE) endif() # ------------------------------------------------------------------------------# @@ -306,7 +293,7 @@ if(SINGULARITY_SUBMODULE_MODE) # Kokkos first (ports-of-call may depend on it if PORTABILITY_STRATEGY_KOKKOS is set) if(SINGULARITY_USE_KOKKOS) singularity_import_kokkos() - if(SINGULARITY_USE_KOKKOSKERNELS) + if(SINGULARITY_BUILD_CLOSURE) singularity_import_kokkoskernels() endif() endif() @@ -319,11 +306,6 @@ if(SINGULARITY_SUBMODULE_MODE) singularity_import_spiner() endif() - # Eigen (if needed) - if(SINGULARITY_USE_EIGEN) - singularity_import_eigen() - endif() - # And pybind11 (if needed) if (SINGULARITY_BUILD_PYTHON) singularity_import_pybind11() @@ -334,7 +316,7 @@ else() # Kokkos first if(SINGULARITY_USE_KOKKOS) singularity_find_kokkos() - if(SINGULARITY_USE_KOKKOSKERNELS) + if(SINGULARITY_BUILD_CLOSURE) singularity_find_kokkoskernels() endif() endif() @@ -347,11 +329,6 @@ else() singularity_find_spiner() endif() - # Eigen (if needed) - if(SINGULARITY_USE_EIGEN) - singularity_find_eigen() - endif() - # And pybind11 (if needed) if (SINGULARITY_BUILD_PYTHON) singularity_find_pybind11() @@ -512,13 +489,10 @@ endif() # see get_sg_eos.cpp if(SINGULARITY_USE_KOKKOS) singularity_enable_kokkos(singularity-eos_Common) - if(SINGULARITY_USE_KOKKOSKERNELS) + if(SINGULARITY_BUILD_CLOSURE) singularity_enable_kokkoskernels(singularity-eos_Common) endif() endif() -if(SINGULARITY_USE_EIGEN) - singularity_enable_eigen(singularity-eos_Interface) -endif() # ----------------------------------------------------------------------------# # Optional dependencies diff --git a/CMakePresets.json b/CMakePresets.json index 612400a9ea0..6f025a0e4e0 100644 --- a/CMakePresets.json +++ b/CMakePresets.json @@ -32,7 +32,8 @@ "name": "with_kokkos_gpu", "hidden": true, "cacheVariables": { - "SINGULARITY_USE_KOKKOS": "ON" + "SINGULARITY_USE_KOKKOS": "ON", + "SINGULARITY_BUILD_CLOSURE": "ON" } }, { diff --git a/README.build.md b/README.build.md index 611d2685fb1..993f36a600e 100644 --- a/README.build.md +++ b/README.build.md @@ -49,6 +49,7 @@ The main CMake options to configure building are in the following table: | `SINGULARITY_USE_FORTRAN` | ON | Enable Fortran API for equation of state.| | `SINGULARITY_USE_KOKKOS` | OFF | Uses Kokkos as the portability backend. Currently only Kokkos is supported for GPUs.| | `SINGULARITY_USE_EOSPAC` | OFF | Link against EOSPAC. Needed for sesame2spiner and some tests.| +| `SINGULARITY_BUILD_CLOSURE` | OFF | Mixed cell closures; requires Kokkos and Kokkos Kernels on CPU and GPU.| | `SINGULARITY_BUILD_TESTS` | OFF | Build test infrastructure.| | `SINGULARITY_BUILD_PYTHON` | OFF | Build Python bindings.| | `SINGULARITY_INVERT_AT_SETUP` | OFF | For tests, pre-invert eospac tables.| @@ -82,14 +83,22 @@ These options are listed in the following table, along with their preconditions: |--|--|--|--| | `SINGULARITY_USE_SPINER_WITH_HDF5` | `SINGULARITY_USE_SPINER=ON` | ON/OFF | Requests that `spiner` be configured for `HDF5` support.| | `SINGULARITY_USE_CUDA` | `SINGULARITY_USE_KOKKOS=ON` | ON/OFF | Target nvidia GPUs for `Kokkos` offloading.| -| `SINGULARITY_USE_KOKKOSKERNELS` | `SINGULARITY_USE_KOKKOS=ON` | ON/OFF |Use Kokkos Kernels for linear algebra. Needed for mixed cell closure models on GPU.| -| `SINGULARITY_BUILD_CLOSURE` | `SINGULARITY_USE_KOKKOS=ON` `SINGULARITY_USE_KOKKOSKERNELS=ON` | ON/OFF | Mixed cell closure.| | `SINGULARITY_BUILD_SESAME2SPINER` | `SINGULARITY_USE_SPINER=ON` `SINGULARITY_USE_SPINER_WITH_HDF5=ON` | ON/OFF | Builds the conversion tool sesame2spiner which makes files readable by SpinerEOS.| | `SINGULARITY_BUILD_STELLARCOLLAPSE2SPINER` | `SINGULARITY_USE_SPINER=ON` `SINGULARITY_USE_SPINER_WITH_HDF5=ON` | ON/OFF | Builds the conversion tool stellarcollapse2spiner which optionally makes stellar collapse files faster to read.| | `SINGULARITY_TEST_SESAME` | `SINGULARITY_BUILD_TESTS=ON` `SINGULARITY_BUILD_SESAME2SPINER=ON` | ON/OFF | Test the Sesame table readers.| | `SINGULARITY_TEST_STELLAR_COLLAPSE` | `SINGULARITY_BUILD_TESTS=ON` `SINGULARITY_BUILD_STELLARCOLLAPSE2SPINER=ON` | ON/OFF | Test the Stellar Collapse table readers.| | `SINGULARITY_TEST_PYTHON` | `SINGULARITY_BUILD_TESTS=ON` `SINGULARITY_BUILD_PYTHON=ON` | ON/OFF | Test the Python bindings.| +Mixed cell closures default to OFF. To enable them on either CPU or GPU, set +`SINGULARITY_BUILD_CLOSURE=ON` and `SINGULARITY_USE_KOKKOS=ON`. Kokkos Kernels +is enabled automatically for closures. Configuring closures without Kokkos, or +without an available Kokkos Kernels dependency, is an error. +CPU closure builds previously using Eigen must migrate to Kokkos and Kokkos Kernels; Eigen is no longer used. + +With `SINGULARITY_BUILD_CLOSURE=OFF`, Kokkos remains optional and Kokkos Kernels +is not required. Set `SINGULARITY_USE_KOKKOS=OFF` for a build without either. +The Fortran mixed-cell backend also requires closures to be enabled. + ## CMake presets To further aid the developer, `singularity-eos` is distributed with *Presets*, a list of common build options with naturally named @@ -133,7 +142,7 @@ For example, suppose that the `basic` preset is mostly sufficient, but you would ```bash # in /build -$> cmake .. --preset="basic_with_testing" -DSINGULARITY_BUILD_CLOSURE=ON +$> cmake .. --preset="basic_with_testing" -DSINGULARITY_BUILD_CLOSURE=ON -DSINGULARITY_USE_KOKKOS=ON # ... ``` diff --git a/README.spack.md b/README.spack.md index 5656d6bd1fd..43c49947568 100644 --- a/README.spack.md +++ b/README.spack.md @@ -66,7 +66,7 @@ The following variants may be used to customize the dependencies and their build enable_fortran [on] on, off Enable building fortran interface enable_tests [off] on, off Build tests kokkos [on] on, off Enable kokkos - kokkos-kernels [off] on, off Enable kokkos-kernals for linear algebra + kokkos-kernels [off] on, off Enable Kokkos Kernels (required for closures) mpi [off] on, off Build with MPI support openmp [off] on, off Enable openmp ``` @@ -117,3 +117,8 @@ To build with `kokkos` using a `cuda` backend (and required CUDA architecture) ```bash $> spack install singularity-eos-deps+cuda+kokkos+kokkos-kernels cuda_arch=70 +enable_tests+enable_fortran build_extra=sesame,stellarcollapse ``` + +Mixed cell closures now require both `+kokkos` and `+kokkos-kernels` on CPU +and GPU. Builds with `~closure` can use `~kokkos~kokkos-kernels`. Externally +maintained Spack recipes must enforce these dependencies for `+closure` and +no longer depend on Eigen. diff --git a/cmake/install.cmake b/cmake/install.cmake index 668b1eb809d..f6f3277e332 100644 --- a/cmake/install.cmake +++ b/cmake/install.cmake @@ -123,7 +123,7 @@ install(FILES ${CMAKE_BINARY_DIR}/generated/singularity-eos/eos/eos.hpp DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/singularity-eos/eos) # install the fortran modules NB: cmake doesn't provide a clean way to handle -if(SINGULARITY_USE_FORTRAN) +if(SINGULARITY_USE_FORTRAN AND TARGET singularity-eos_Library) install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/fortran/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/singularity-eos/eos) endif() diff --git a/cmake/singularity-eos/Eigen3.cmake b/cmake/singularity-eos/Eigen3.cmake deleted file mode 100644 index c8dd72a855b..00000000000 --- a/cmake/singularity-eos/Eigen3.cmake +++ /dev/null @@ -1,23 +0,0 @@ -macro(singularity_import_eigen) - if(NOT TARGET Eigen3::Eigen) - set(_storBT ${BUILD_TESTING}) - set(BUILD_TESTING OFF CACHE BOOL "" FORCE) - - set(EIGEN_TEST_CXX11 OFF CACHE BOOL "" FORCE) - set(EIGEN_BUILD_PKGCONFIG OFF CACHE BOOL "" FORCE) - set(EIGEN_BUILD_DOC OFF CACHE BOOL "" FORCE) - - add_subdirectory(utils/eigen) - - set(BUILD_TESTING ${_storBT} CACHE BOOL "" FORCE) - unset(_storBT) - endif() -endmacro() - -macro(singularity_find_eigen) - find_package(Eigen3 REQUIRED) -endmacro() - -macro(singularity_enable_eigen target) - target_link_libraries(${target} INTERFACE Eigen3::Eigen) -endmacro() diff --git a/cmake/singularity-eos/kokkos.cmake b/cmake/singularity-eos/kokkos.cmake index 22e5e9c7320..c0e61465654 100644 --- a/cmake/singularity-eos/kokkos.cmake +++ b/cmake/singularity-eos/kokkos.cmake @@ -29,8 +29,6 @@ macro(singularity_enable_kokkos target) # #TODO: shouldn't be needed target_compile_definitions(${target} PUBLIC # SPINER_USE_KOKKOS) - # if(SINGULARITY_USE_KOKKOSKERNELS AND SINGULARITY_BUILD_CLOSURE) - # target_link_libraries(${target} PUBLIC Kokkos::kokkoskernels) endif() endmacro() macro(singularity_import_kokkoskernels) @@ -113,6 +111,5 @@ macro(singularity_find_kokkoskernels) endmacro() macro(singularity_enable_kokkoskernels target) - target_compile_definitions(${target} INTERFACE SINGULARITY_USE_KOKKOSKERNELS) target_link_libraries(${target} INTERFACE Kokkos::kokkoskernels) endmacro() diff --git a/cmake/submodule_configs.cmake b/cmake/submodule_configs.cmake index 64d4502b718..83aff3e20b1 100644 --- a/cmake/submodule_configs.cmake +++ b/cmake/submodule_configs.cmake @@ -48,14 +48,6 @@ macro(singularity_cmake_config pkg) set(KokkosKernels_INST_OFFSET_SIZE_T OFF CACHE BOOL "" FORCE) set(KokkosKernels_INST_ORDINAL_INT OFF CACHE BOOL "" FORCE) set(KokkosKernels_INST_ORDINAL_INT OFF CACHE BOOL "" FORCE) - elseif(${pkg} STREQUAL "Eigen3") - set(EIGEN_TEST_CXX11 OFF CACHE BOOL "" FORCE) - set(EIGEN_BUILD_PKGCONFIG OFF CACHE BOOL "" FORCE) - set(EIGEN_BUILD_DOC OFF CACHE BOOL "" FORCE) - #TODO: I don't like this as it can interfere with - # other projects, but I don't have a great solution - # to disable testing in here. - set(BUILD_TESTING OFF CACHE BOOL "" FORCE) else() set(_PKG_DEFAULT_CONFIGURED ON) endif() diff --git a/config/singularity-eosConfig.cmake.in b/config/singularity-eosConfig.cmake.in index 4ef4768d6d4..649fafb2c62 100644 --- a/config/singularity-eosConfig.cmake.in +++ b/config/singularity-eosConfig.cmake.in @@ -91,14 +91,10 @@ if(@SINGULARITY_USE_KOKKOS@) find_dependency(Kokkos) endif() -if(@SINGULARITY_USE_KOKKOSKERNELS@) +if(@SINGULARITY_BUILD_CLOSURE@) find_dependency(KokkosKernels) endif() -if(@SINGULARITY_USE_EIGEN@) - find_dependency(Eigen3) -endif() - if(@SINGULARITY_USE_EOSPAC@) # needed for EOSPAC if(NOT TARGET EOSPAC::eospac) diff --git a/doc/sphinx/src/building.rst b/doc/sphinx/src/building.rst index b6e75aac34b..3c630c68fa5 100644 --- a/doc/sphinx/src/building.rst +++ b/doc/sphinx/src/building.rst @@ -57,9 +57,8 @@ Dependencies `spiner`_ submodule [*]_ / external [*]_ Optional; enhanced backend for EOS tables `hdf5`_ external only Optional; used for table I/O `eospac`_ external only Optional; used for sesame tables. - `kokkos`_ submodule / external Optional; enables GPU offloading. - `Eigen`_ submodule / external Optional; used for linear algebra on the CPU when doing mixed-cell closures. - `kokkos-kernels`_ submodule / external Optional; used for linear algebra on the GPU when doing mixed-cell closures. + `kokkos`_ submodule / external Required for mixed-cell closures; otherwise optional. Enables GPU offloading. + `kokkos-kernels`_ submodule / external Required for mixed-cell closures on CPU and GPU; otherwise optional. `pybind11`_ external / fetchable [*]_ Optional ====================================== =============================== =========================================== @@ -77,8 +76,6 @@ Dependencies .. _kokkos: https://github.com/kokkos/kokkos -.. _Eigen: https://eigen.tuxfamily.org/index.php?title=Main_Page - .. _kokkos-kernels: https://github.com/kokkos/kokkos-kernels/ .. _pybind11: https://github.com/pybind/pybind11 @@ -143,6 +140,14 @@ preconditions and defaults are logically constructed and the most natural in practice (``SINGULARITY_TEST_*`` are only available if ``SINGLARITY_BUILD_TESTS`` is enabled, for instance). +Mixed cell closures default to OFF. Enabling ``SINGULARITY_BUILD_CLOSURE`` +requires ``SINGULARITY_USE_KOKKOS=ON`` on CPU and GPU. Kokkos Kernels is +enabled automatically for closures. Configuring closures without Kokkos, or +without an available Kokkos Kernels dependency, is a configuration error. +CPU closure builds previously using Eigen must migrate to Kokkos and Kokkos Kernels; Eigen is no longer used. +With closures disabled, Kokkos remains optional and Kokkos Kernels is not +required. The Fortran mixed-cell backend requires closures to be enabled. + These options are listed in the following table, along with their preconditions: @@ -151,7 +156,6 @@ preconditions: ============================================== ================================================================================= =========================================== ``SINGULARITY_USE_SPINER_WITH_HDF5`` ``SINGULARITY_USE_SPINER=ON`` Requests that ``spiner`` be configured for ``HDF5`` support. ``SINGULARITY_USE_CUDA`` ``SINGULARITY_USE_KOKKOS=ON`` Target nvidia GPUs for ``Kokkos`` offloading. - ``SINGULARITY_USE_KOKKOSKERNELS`` ``SINGULARITY_USE_KOKKOS=ON`` ``SINGULARITY_BUILD_CLOSURE=ON`` Use Kokkos Kernels for linear algebra. Needed for mixed cell closure models on GPU. ``SINGULARITY_BUILD_SESAME2SPINER`` ``SINGULARITY_USE_SPINER=ON`` ``SINGULARITY_USE_SPINER_WITH_HDF5=ON`` Builds the conversion tool sesame2spiner which makes files readable by SpinerEOS. ``SINGULARITY_BUILD_STELLARCOLLAPSE2SPINER`` ``SINGULARITY_USE_SPINER=ON`` ``SINGULARITY_USE_SPINER_WITH_HDF5=ON`` Builds the conversion tool stellarcollapse2spiner which optionally makes stellar collapse files faster to read. ``SINGULARITY_TEST_SESAME`` ``SINGULARITY_BUILD_TESTS=ON`` ``SINGULARITY_BUILD_SESAME2SPINER=ON`` Test the Sesame table readers. @@ -232,7 +236,7 @@ closure models: .. code:: bash # in /build - $> cmake .. --preset="basic_with_testing" -DSINGULARITY_BUILD_CLOSURE=ON + $> cmake .. --preset="basic_with_testing" -DSINGULARITY_BUILD_CLOSURE=ON -DSINGULARITY_USE_KOKKOS=ON # ... User defined presets @@ -710,7 +714,7 @@ supports a number of relevant variants: | kokkos-kernels [off] | on, off | Use kokkos-kernels for | | | | linear algebra suport, | | | | which is needed with | -| | | mixed-cell closures on GPU | +| | | mixed-cell closures | +-----------------------------+-----------------+-----------------------------+ | mpi [off] | on, off | Build with parallel HDF5 | | | | otherwise build with serial | diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt index 34f7143d989..d030225368d 100644 --- a/example/CMakeLists.txt +++ b/example/CMakeLists.txt @@ -21,8 +21,10 @@ if(SINGULARITY_USE_SPINER_WITH_HDF5) target_link_libraries(eos_grid PRIVATE singularity-eos::singularity-eos) add_executable(map_pt_space map_pt_space.cpp) target_link_libraries(map_pt_space PRIVATE singularity-eos::singularity-eos) - add_executable(pte_2mat pte_2mat.cpp) - target_link_libraries(pte_2mat PRIVATE singularity-eos::singularity-eos) + if(SINGULARITY_BUILD_CLOSURE) + add_executable(pte_2mat pte_2mat.cpp) + target_link_libraries(pte_2mat PRIVATE singularity-eos::singularity-eos) + endif() add_executable(custom_eos_to_spiner custom_eos_to_spiner.cpp) target_link_libraries(custom_eos_to_spiner PRIVATE singularity-eos::singularity-eos) endif() diff --git a/singularity-eos/closure/kinetic_phasetransition_methods.hpp b/singularity-eos/closure/kinetic_phasetransition_methods.hpp index 89a9ba9d0a1..2c5b1be7787 100644 --- a/singularity-eos/closure/kinetic_phasetransition_methods.hpp +++ b/singularity-eos/closure/kinetic_phasetransition_methods.hpp @@ -25,14 +25,6 @@ #include -#ifdef SINGULARITY_USE_KOKKOSKERNELS -#include -#include -#include -#else -#include -#endif // SINGULARITY_USE_KOKKOSKERNELS - namespace singularity { PORTABLE_INLINE_FUNCTION void SmallStepMFUpdate(const Real logdt, const int num_phases, diff --git a/singularity-eos/closure/kinetic_phasetransition_models.hpp b/singularity-eos/closure/kinetic_phasetransition_models.hpp index 8aacf94889e..bd0451e45e2 100644 --- a/singularity-eos/closure/kinetic_phasetransition_models.hpp +++ b/singularity-eos/closure/kinetic_phasetransition_models.hpp @@ -26,14 +26,6 @@ #include -#ifdef SINGULARITY_USE_KOKKOSKERNELS -#include -#include -#include -#else -#include -#endif // SINGULARITY_USE_KOKKOSKERNELS - namespace singularity { PORTABLE_INLINE_FUNCTION void LogRatesCGModel(const Real *w, const Real *b, diff --git a/singularity-eos/closure/kinetic_phasetransition_utils.hpp b/singularity-eos/closure/kinetic_phasetransition_utils.hpp index 3d3a716e8c6..55bc0bdcf48 100644 --- a/singularity-eos/closure/kinetic_phasetransition_utils.hpp +++ b/singularity-eos/closure/kinetic_phasetransition_utils.hpp @@ -25,14 +25,6 @@ #include -#ifdef SINGULARITY_USE_KOKKOSKERNELS -#include -#include -#include -#else -#include -#endif // SINGULARITY_USE_KOKKOSKERNELS - namespace singularity { constexpr Real KPT_MIN_MASS_FRACTION = 1.0e-10; diff --git a/singularity-eos/closure/mixed_cell_models.hpp b/singularity-eos/closure/mixed_cell_models.hpp index bf0b1ffd9e7..4cbeac7e95e 100644 --- a/singularity-eos/closure/mixed_cell_models.hpp +++ b/singularity-eos/closure/mixed_cell_models.hpp @@ -15,6 +15,8 @@ #ifndef _SINGULARITY_EOS_CLOSURE_MIXED_CELL_MODELS_ #define _SINGULARITY_EOS_CLOSURE_MIXED_CELL_MODELS_ +#ifdef SINGULARITY_BUILD_CLOSURE + #include #include #include @@ -26,13 +28,13 @@ #include #include -#ifdef SINGULARITY_USE_KOKKOSKERNELS +#ifndef PORTABILITY_STRATEGY_KOKKOS +#error "Mixed cell closures require Kokkos and Kokkos Kernels." +#endif + #include #include #include -#else -#include -#endif // SINGULARITY_USE_KOKKOSKERNELS namespace singularity { @@ -217,10 +219,6 @@ bool solve_Ax_b_wscr(const std::size_t n, Real *a, Real *b, Real *scr) { } else { // TODO(JMM): Should we switch to an SVD-based psuedo-inverse for // larger matrices? -#ifdef SINGULARITY_USE_KOKKOSKERNELS -#ifndef PORTABILITY_STRATEGY_KOKKOS -#error "Kokkos Kernels requires Kokkos." -#endif // aliases for kokkos views using Unmgd = Kokkos::MemoryTraits; using Lrgt = Kokkos::LayoutRight; @@ -258,20 +256,6 @@ bool solve_Ax_b_wscr(const std::size_t n, Real *a, Real *b, Real *scr) { // R^-1 R x = R^-1 Q^T B -> x = R^-1 Q^T B // store solution vector x in B InvertR::invoke(1.0, A, B); -#else -#ifdef PORTABILITY_STRATEGY_KOKKOS -#warning "Eigen should not be used with Kokkos." -#endif - // Eigen VERSION - using Matrix_t = Eigen::Matrix; - Eigen::Map A(a, n, n); - - Eigen::Map B(b, n); - Eigen::Map X(scr, n); - X = A.colPivHouseholderQr().solve(B); - - B = X; -#endif // SINGULARITY_USE_KOKKOSKERNELS } bool retval = check_nans(b, n); return retval; @@ -2292,4 +2276,5 @@ PORTABLE_INLINE_FUNCTION SolverStatus PTESolver(System &s) { } // namespace singularity +#endif // SINGULARITY_BUILD_CLOSURE #endif // _SINGULARITY_EOS_CLOSURE_MIXED_CELL_MODELS_ diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index b3ccc7c498d..1b5a8fdae2e 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -221,7 +221,7 @@ if(SINGULARITY_USE_SPINER) target_link_libraries(profile_eos singularity-eos::singularity-eos) endif() -if(SINGULARITY_USE_FORTRAN) +if(SINGULARITY_USE_FORTRAN AND SINGULARITY_BUILD_CLOSURE) add_executable(ftn_interface test_f_iface.f90) target_link_libraries(ftn_interface singularity-eos::singularity-eos) set_target_properties(ftn_interface PROPERTIES LINKER_LANGUAGE Fortran) diff --git a/test/test_solver_utils.cpp b/test/test_solver_utils.cpp index 81daa4efabf..f6085c31910 100644 --- a/test/test_solver_utils.cpp +++ b/test/test_solver_utils.cpp @@ -97,8 +97,7 @@ SCENARIO("3x3 matrix solve", "[Matrix][3x3]") { constexpr Real B2_true = 2 * (1 + delta) / denom; Real *A = (Real *)PORTABLE_MALLOC(N * N * sizeof(Real)); Real *B = (Real *)PORTABLE_MALLOC(N * sizeof(Real)); - // Kokkos QR requires 2 scratch vectors, instead of the 1 required - // by Cramer's rule or Eigen + // Kokkos QR requires 2 scratch vectors. Real *scr = (Real *)PORTABLE_MALLOC(2 * N * sizeof(Real)); portableFor( "Set values of A and B", 0, 1, PORTABLE_LAMBDA(const int) { diff --git a/utils/eigen b/utils/eigen deleted file mode 160000 index 2859db0220c..00000000000 --- a/utils/eigen +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 2859db0220cd8644c1a75a3bf04f62f551f73f22 diff --git a/utils/scripts/create_tar.sh b/utils/scripts/create_tar.sh index 88916328a4c..c7e058be45e 100755 --- a/utils/scripts/create_tar.sh +++ b/utils/scripts/create_tar.sh @@ -25,8 +25,6 @@ done cd ../../../ tar czvf singularity-eos-${B}.tar.gz --exclude-vcs --exclude=".git*" \ --exclude="build*" --exclude="nbproject" --exclude="data" \ ---exclude="eigen/doc" --exclude="eigen/demos" --exclude="eigen/failtest" \ ---exclude="eigen/test" --exclude="eigen/bench" --exclude="eigen/unsupported" \ --exclude="json/benchmarks" --exclude="json/doc" --exclude="variant/3rdparty" \ --exclude="variant/test" --exclude="utils/kokkos" --exclude="test" \ --exclude="Catch2" --exclude="singularity-eos-data" singularity-eos/ From 615c838087406d96dc2061ef9ce489a4b7fc06a8 Mon Sep 17 00:00:00 2001 From: Jonah Maxwell Miller Date: Tue, 27 Oct 2026 07:37:29 -0400 Subject: [PATCH 2/3] add plan history --- .../MR663-2026-10-27-remove-eigen.md | 180 ++++++++++++++++++ 1 file changed, 180 insertions(+) create mode 100644 plan_histories/MR663-2026-10-27-remove-eigen.md diff --git a/plan_histories/MR663-2026-10-27-remove-eigen.md b/plan_histories/MR663-2026-10-27-remove-eigen.md new file mode 100644 index 00000000000..a148b94a105 --- /dev/null +++ b/plan_histories/MR663-2026-10-27-remove-eigen.md @@ -0,0 +1,180 @@ +# Remove Eigen and Select Kokkos Kernels Automatically for Closures + +**Date recorded:** 2026-10-27 +**Status:** Implemented; available CPU tests and package checks passed +**Implementation commit:** `e9cf5eb6` (`remove eigen`) +**MR:** Not assigned in this conversation + +## Request and constraints + +Remove the dependency on Eigen. Use Kokkos Kernels when closure solvers +require linear algebra, while keeping Kokkos and Kokkos Kernels optional +when mixed cell closures are disabled. + +The user explicitly requested that we **not extend the regression suite**. +Validation was to use the existing regressions. + +After the initial implementation, the user requested removal of the separate +Kokkos Kernels flag: enable the dependency automatically when closures need +it and Kokkos is enabled. The actual flag in the repository was named +`SINGULARITY_USE_KOKKOSKERNELS` (without the extra underscore in +`KOKKOS_KERNELS`). + +## Findings that informed the plan + +- The dense solve in `singularity-eos/closure/mixed_cell_models.hpp` already + had a Kokkos Kernels implementation using KokkosBatched QR, ApplyQ, and Trsm. + Eigen supplied an alternative CPU implementation. +- Eigen used column-pivoted Householder QR; the existing Kokkos Kernels path + uses unpivoted QR. Switching CPU builds to the latter warranted running + the existing numerical regressions. +- Three `kinetic_phasetransition_*` headers included linear algebra headers + that they did not need. +- Closure headers and most closure tests were already conditionally built, + but the `pte_2mat` example and Fortran test/install rules needed additional + gating for closure-disabled builds. +- The original defaults enabled closures but disabled Kokkos. Removing the + Eigen fallback required resolving that inconsistent combination. + +## Original proposed plan + +1. Enforce that closures require Kokkos and Kokkos Kernels in both submodule + and external-package builds. Default closures to OFF, retaining Kokkos's + OFF default. Initially retain the separate Kernels option for compatibility, + but reject closure builds that disable it. +2. Remove the Eigen solver branch and unnecessary includes. Preserve the + specialized 1x1 and 2x2 solves, solver interfaces, and scratch-space contract. +3. Remove Eigen discovery, linkage, CMake helpers, installed-package dependency + declarations, submodule registration, and obsolete archive exclusions. +4. Audit closure-disabled builds, including examples, tests, headers, and the + Fortran backend. Keep ordinary EOS functionality independent of the closure + linear algebra dependency. +5. Validate numerical behavior, valid and invalid dependency combinations, + submodule builds, and installed-package consumers. The original proposal + included additional numerical coverage; the user explicitly removed that + part before implementation. No regression cases were added or extended. +6. Update CI, presets, README/Sphinx documentation, and migration guidance. + Note the corresponding changes needed in externally maintained Spack recipes. + +## What was implemented + +### Solver and headers + +- Removed Eigen from `solve_Ax_b_wscr` and retained the existing KokkosBatched + implementation for systems larger than 2x2. +- Preserved row scaling, specialized small-system solves, solver interfaces, + scratch sizing, and the existing finite-result check. +- Guarded `mixed_cell_models.hpp` with `SINGULARITY_BUILD_CLOSURE` so disabled + closures do not pull in the solver dependencies. +- Retained a compile-time diagnostic for attempting to build closures without + the Kokkos portability strategy. +- Removed unused Eigen/Kokkos linear algebra includes from the three kinetic + phase-transition headers. +- Updated the existing solver-test scratch-space comment; test behavior and + regression coverage were not extended. + +### Dependencies and configuration + +- Changed `SINGULARITY_BUILD_CLOSURE` to default OFF. +- Added a configure-time error for closures ON with Kokkos OFF. +- Removed `SINGULARITY_USE_EIGEN`, its import/find/link logic, + `cmake/singularity-eos/Eigen3.cmake`, and the Eigen branch in + `cmake/submodule_configs.cmake`. +- Removed the `utils/eigen` submodule and its `.gitmodules` entry. +- Removed Eigen from the installed package's dependency discovery and from + archive-script exclusions. +- Following the user's second request, removed the + `SINGULARITY_USE_KOKKOSKERNELS` CMake option and compile definition entirely. + Dependency import, discovery, linkage, and installed-package discovery now + follow `SINGULARITY_BUILD_CLOSURE` directly. + +The final contract is: + +| Closures | Kokkos | Kokkos Kernels | +|---|---|---| +| OFF | OFF | Not required or selected by singularity-eos | +| OFF | ON | Not required or selected by singularity-eos | +| ON | OFF | Configuration error | +| ON | ON | Automatically required and linked | + +Enable closures with: + +```sh +cmake -S . -B build \ + -DSINGULARITY_BUILD_CLOSURE=ON \ + -DSINGULARITY_USE_KOKKOS=ON +``` + +Other options and dependency locations still depend on the chosen build mode. +No separate Kokkos Kernels enable flag is needed. External-package builds must +provide Kokkos Kernels; submodule builds import the bundled dependency. + +### Build integration and documentation + +- Gated `pte_2mat` on closures as well as its existing Spiner/HDF5 requirement. +- Gated the Fortran interface test on closures, and Fortran module installation + on the existence of the compiled library target. +- Updated GitHub workflows to select closure configurations explicitly. + The existing minimal Kokkos workflow now runs with closures ON and OFF; + it uses the existing tests in both configurations. +- Updated Kokkos presets to enable closures explicitly. +- Removed references to the Kernels enable flag from presets, CI, and docs. +- Updated `README.build.md`, `README.spack.md`, and + `doc/sphinx/src/building.rst` with the dependency contract and migration notes. +- Documented that external Spack recipes must require Kokkos and Kokkos Kernels + for closures and stop depending on Eigen. Those external recipes were not + modified in this workspace. + +## Validation actually performed + +The existing suites were rerun after removing the Kernels flag: + +| Configuration | Existing tests | Result | +|---|---:|---| +| Closures ON, Kokkos Serial, automatic Kokkos Kernels; Spiner/HDF5, Helmholtz, and Fortran enabled | 107 | All passed | +| Closures OFF, Kokkos ON, no Kernels; Spiner enabled | 95 | All passed | +| Closures OFF, Kokkos OFF, no Kernels; Spiner disabled | 74 | All passed | + +The enabled closure suite included the existing solver, PTE, and KPT unit +coverage and available PTE/Fortran regressions. No test failures were observed +in these configurations. + +Additional checks: + +- Built examples in the tested submodule configurations. +- Verified that closures ON with Kokkos OFF produces the intended error. +- Verified that an external-package closure build fails when Kokkos Kernels + package discovery is disabled. +- Configured and installed external-package builds with closures both OFF + and ON, with the removed Kernels option absent from their caches. +- Built and ran temporary installed-package consumers for an ordinary EOS + and a closure solve. For the minimal consumer, Kokkos and Kokkos Kernels + discovery were explicitly disabled. Eigen discovery was disabled for both. +- Verified the removed option was absent from the three regression-build + caches and that no active repository references to the flag remained. +- Ran `git diff --check`, parsed `CMakePresets.json`, and ran the installed-header + registration check successfully. + +Temporary consumer checks were created under `/tmp`; they were not added to +the repository's regression suite. Build and test logs were also stored under +`/tmp`, including: + +- `/tmp/singularity-noeigen-cpu-test.log` +- `/tmp/singularity-noeigen-kokkos-only-test.log` +- `/tmp/singularity-noeigen-minimal-test.log` + +## Validation limitations and environment notes + +- GPU builds/regressions were not run: CUDA and HIP tooling were unavailable. +- EOSPAC-dependent regressions were not run because that dependency was not + available. The reported counts describe the enabled local configurations, + not every optional regression in the repository. +- Local testing used GNU 15.2 and Kokkos/Kokkos Kernels 5.1.0 on aarch64. +- The first fresh configure needed network access to fetch Catch2. A subsequent + configure encountered an upstream Kokkos Kernels cache-spelling issue; + local configuration removed `KOKKOSKERNELS_ENABLE_SUPERNODAL_SPTRSV` and set + `KokkosKernels_ENABLE_SUPERNODAL_SPTRSV=OFF`. No upstream source fix was made. +- Existing unrelated working-tree edits were preserved during implementation. + At the time this history was written, the removal changes were committed as + `e9cf5eb6`; the pre-existing untracked content in `utils/kokkos-kernels` + remained untouched. From 2419894529b05ca10e4b8e08f0ceeff80363fcf4 Mon Sep 17 00:00:00 2001 From: Jonah Maxwell Miller Date: Tue, 27 Oct 2026 07:39:14 -0400 Subject: [PATCH 3/3] changelog --- CHANGELOG.md | 33 +++++++++++++++++---------------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2419ab6ce90..93bb8042f9f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,28 +3,29 @@ ## Current develop ### Added (new features/APIs/variables/...) -- [[PR658]](https://github.com/lanl/singularity-eos/pull/XXX) Add `MinimumInternalEnergy`/`MaximumInternalEnergy` to the EOS introspection API, so energy bounds are reachable through modifiers and the `singularity::EOS` variant -- [[PR658]](https://github.com/lanl/singularity-eos/pull/XXX) Add `sesame2spiner::saveAllMaterials` overloads taking a list of matids instead of a list of input files, with optional per-material `Params` overrides, so host codes can generate an sp5 file without writing input decks to disk. Also added an overload taking an already-open `hid_t`, plus `writeSP5RootAttributes`, so a single sp5 file can be built up one material at a time. -- [[PR653]] (https://github.com/lanl/singularity-eos/pull/659) Added `sesame2spiner::saveAllMaterials` overloads taking a list of matids instead of a list of input files, with optional per-material `Params` overrides, so host codes can generate an sp5 file without writing input decks to disk. Also added an overload taking an already-open `hid_t`, plus `writeSP5RootAttributes`, so a single sp5 file can be built up one material at a time. +- [[PR658]](https://github.com/lanl/singularity-eos/pull/658) Add `MinimumInternalEnergy`/`MaximumInternalEnergy` to the EOS introspection API, so energy bounds are reachable through modifiers and the `singularity::EOS` variant +- [[PR659]](https://github.com/lanl/singularity-eos/pull/659) Add `sesame2spiner::saveAllMaterials` overloads taking a list of matids instead of a list of input files, with optional per-material `Params` overrides, so host codes can generate an sp5 file without writing input decks to disk. Also added an overload taking an already-open `hid_t`, plus `writeSP5RootAttributes`, so a single sp5 file can be built up one material at a time. +- [[PR659]](https://github.com/lanl/singularity-eos/pull/659) Added `sesame2spiner::saveAllMaterials` overloads taking a list of matids instead of a list of input files, with optional per-material `Params` overrides, so host codes can generate an sp5 file without writing input decks to disk. Also added an overload taking an already-open `hid_t`, plus `writeSP5RootAttributes`, so a single sp5 file can be built up one material at a time. ### Fixed (Repair bugs, etc) - [[PR661]](https://github.com/lanl/singularity-eos/pull/661) Fix bug in InternalEnergyFromDensityPressure where the lambda wasn't threaded all the way through. -- `sesame2spiner` now validates the metadata returned by `eosGetMetadata` before using it. A matid absent from the sesame file previously produced all-zero bounds with no error, which reached `log()` and generated NaN grids; it is now reported and skipped. -- `sesame2spiner` no longer reports an HDF5 failure against every material following the first failed one, and now names the offending matid. Material save status is no longer accumulated by summing `herr_t` values, which could cancel out and report success. -- [[PR653]] (https://github.com/lanl/singularity-eos/pull/659) `sesame2spiner` now validates the metadata returned by `eosGetMetadata` before using it. A matid absent from the sesame file previously produced +- [[PR659]](https://github.com/lanl/singularity-eos/pull/659) `sesame2spiner` now validates the metadata returned by `eosGetMetadata` before using it. A matid absent from the sesame file previously produced all-zero bounds with no error, which reached `log()` and generated NaN grids; it is now reported and skipped. +- [[PR659]](https://github.com/lanl/singularity-eos/pull/659) `sesame2spiner` no longer reports an HDF5 failure against every material following the first failed one, and now names the offending matid. Material save status is no longer accumulated by summing `herr_t` values, which could cancel out and report success. +- [[PR659]](https://github.com/lanl/singularity-eos/pull/659) `sesame2spiner` now validates the metadata returned by `eosGetMetadata` before using it. A matid absent from the sesame file previously produced all-zero bounds with no error, which reached `log()` and generated NaN grids; it is now reported and skipped. It also no longer reports an HDF5 failure against every material following the first failed one, and now names the offending matid. Material save status is no longer accumulated by summing `herr_t` values, which could cancel out and report success. ### Changed (changing behavior/API/variables/...) -- [[PR658]](https://github.com/lanl/singularity-eos/pull/XXX) `ScaledEOS::CheckParams` now requires a strictly positive scale factor, where it previously accepted any nonzero value. -- [[PR658]](https://github.com/lanl/singularity-eos/pull/XXX) `sesame2spiner` now honors the requested verbosity when reading material metadata, rather than always using `Verbosity::Debug`. Default command line output is correspondingly quieter. -- [[PR658]](https://github.com/lanl/singularity-eos/pull/XXX) `sesame2spiner::getMatBounds` no longer takes a leading index argument, which was unused. +- [[PR658]](https://github.com/lanl/singularity-eos/pull/658) `ScaledEOS::CheckParams` now requires a strictly positive scale factor, where it previously accepted any nonzero value. +- [[PR659]](https://github.com/lanl/singularity-eos/pull/659) `sesame2spiner` now honors the requested verbosity when reading material metadata, rather than always using `Verbosity::Debug`. Default command line output is correspondingly quieter. +- [[PR659]](https://github.com/lanl/singularity-eos/pull/659) `sesame2spiner::getMatBounds` no longer takes a leading index argument, which was unused. ### Infrastructure (changes irrelevant to downstream codes) - [[PR653]](https://github.com/lanl/singularity-eos/pull/653) Move pybind11 to a submodule rather than fetching it via cmake fetchcontent ### Deprecated (soon to be removed behavior/API/variables/...) -- [[PR658]](https://github.com/lanl/singularity-eos/pull/XXX) The table bounds accessors `sieMin()`/`sieMax()` on `SpinerEOSDependsRhoSie` and `StellarCollapse` are superseded by `MinimumInternalEnergy()`/`MaximumInternalEnergy()`, which every EOS provides and which work through modifiers and the `singularity::EOS` variant. The old names still work but will be removed. +- [[PR663]](https://github.com/lanl/singularity-eos/pull/663) Breaking change. Eigen removed as a dependency. +- [[PR658]](https://github.com/lanl/singularity-eos/pull/658) The table bounds accessors `sieMin()`/`sieMax()` on `SpinerEOSDependsRhoSie` and `StellarCollapse` are superseded by `MinimumInternalEnergy()`/`MaximumInternalEnergy()`, which every EOS provides and which work through modifiers and the `singularity::EOS` variant. The old names still work but will be removed. ## Release 1.12.1 Date: 08/10/2026 @@ -46,7 +47,7 @@ Date: 07/20/2026 ### Fixed (Repair bugs, etc) - [[PR645]](https://github.com/lanl/singularity-eos/pull/645) Fix internal energy from density and pressure for JWL -- [[PR63]](https://github.com/lanl/singularity-eos/pull/639) Fixed UnitSystem temperature bug. Temperature is now treated in the same as the time, mass, and length unit factors. +- [[PR639]](https://github.com/lanl/singularity-eos/pull/639) Fixed UnitSystem temperature bug. Temperature is now treated in the same as the time, mass, and length unit factors. - [[PR637]](https://github.com/lanl/singularity-eos/pull/637) Fix is_normal ### Changed (changing behavior/API/variables/...) @@ -100,7 +101,7 @@ Date: 12/25/2025 - [[PR563]](https://github.com/lanl/singularity-eos/pull/563) Fixed DensityFromPressureTemperature for the Carnahan-Starling EOS. - [[PR564]](https://github.com/lanl/singularity-eos/pull/564) Fix logic for numerical vs type indices by adding safeGet(), safeSet(), safeMustGet(), and safeMustSet() helpers - [[PR568]](https://github.com/lanl/singularity-eos/pull/568) Fix bug in FixedT and FixedP PTE solvers when materials have negative energies at the initial guess -- [[PR583]](https://github.com/lanl/singularity-eos/pull/582) Allow PTE solvers to operate on tables with pressure as a preferred input +- [[PR582]](https://github.com/lanl/singularity-eos/pull/582) Allow PTE solvers to operate on tables with pressure as a preferred input ### Changed (changing behavior/API/variables/...) - [[PR579]](https://github.com/lanl/singularity-eos/pull/579) Python bindings now support numpy arrays with arbitrary stride. Numpy array length no longer required input. @@ -141,7 +142,7 @@ Date: 8/27/2025 - [[PR545]](https://github.com/lanl/singularity-eos/pull/545) Implement reduced system for PTESolverRhoT - [[PR543]](https://github.com/lanl/singularity-eos/pull/543) Made PTE solvers more robust for Maxwell constructed tables - [[PR502]](https://github.com/lanl/singularity-eos/pull/502) Expose split tables to Fortran interface -- [[PR519]] (https://github.com/lanl/singularity-eos/pull/519) Split eos_spiner.hpp into eos_spiner_rho_sie.hpp and eos_spiner_rho_temp.hpp files. +- [[PR519]](https://github.com/lanl/singularity-eos/pull/519) Split eos_spiner.hpp into eos_spiner_rho_sie.hpp and eos_spiner_rho_temp.hpp files. ### Infrastructure (changes irrelevant to downstream codes) - [[PR528]](https://github.com/lanl/singularity-eos/pull/528) Remove unused variable subGroup in SpinerEOSDependsRhoT @@ -238,7 +239,7 @@ Date: 7/29/2024 - [[PR343]](https://github.com/lanl/singularity-eos/pull/343) Add chemical potentials to stellar collapse gold files - [[PR342]](https://github.com/lanl/singularity-eos/pull/342) Fix missing using statement in stellar collapse root finding routines - [[PR341]](https://github.com/lanl/singularity-eos/pull/341) Short-circuit HDF5 machinery when cray-wrappers used in-tree -- [[PR340]](https://github.com/lanl/singularity-eos/pull/335) Fix in-tree builds with plugin infrastructure +- [[PR340]](https://github.com/lanl/singularity-eos/pull/340) Fix in-tree builds with plugin infrastructure - [[PR335]](https://github.com/lanl/singularity-eos/pull/335) Fix missing hermite.hpp in CMake install required for Helmholtz EOS - [[PR356]](https://github.com/lanl/singularity-eos/pull/356) Guard against FPEs in the PTE solver - [[PR356]](https://github.com/lanl/singularity-eos/pull/356) Update CMake for proper Kokkos linking in Fortran interface @@ -278,7 +279,7 @@ Date: 11/28/2023 - [[PR238]](https://github.com/lanl/singularity-eos/pull/238) Fixed broken examples - [[PR228]](https://github.com/lanl/singularity-eos/pull/228) added untracked header files in cmake - [[PR215]](https://github.com/lanl/singularity-eos/pull/215) and [[PR216]](https://github.com/lanl/singularity-eos/pull/216) fix duplicate definition of EPS and fix CI -- [[PR232]](https://github.com/lanl/singularity-eos/pull/228) Fixed uninitialized cmake path variables +- [[PR232]](https://github.com/lanl/singularity-eos/pull/232) Fixed uninitialized cmake path variables - [[PR308]](https://github.com/lanl/singularity-eos/pull/308) spack builds +fortran now compile via correct blocking out of interfaces via preprocessor ifdef ### Added (new features/APIs/variables/...) @@ -292,7 +293,7 @@ Date: 11/28/2023 - [[PR265]](https://github.com/lanl/singularity-eos/pull/265) Add missing UnitSystem modifier combinations to variant and EOSPAC - [[PR279]](https://github.com/lanl/singularity-eos/pull/279) added noble-abel EoS - [[PR274]](https://github.com/lanl/singularity-eos/pull/274) added a stiffened gas EoS -- [[PR264]](https://github.com/lanl/singularity-eos/pull/274) added a Helmholtz EoS +- [[PR264]](https://github.com/lanl/singularity-eos/pull/264) added a Helmholtz EoS - [[PR254]](https://github.com/lanl/singularity-eos/pull/254) added ability to peel off modifiers as needed - [[PR250]](https://github.com/lanl/singularity-eos/pull/250) added mass fraction output to stellar collapse eos - [[PR226]](https://github.com/lanl/singularity-eos/pull/226) added entropy interpolation to stellar collapse eos