update CI images

.devcontainer/Dockerfile

@@ -2,7 +2,7 @@
 # If you are building the current `Dockerfile` to use codespaces in the cloud,
 # you most likely want to define this variable in the `.devcontainer/devcontainer.json` file.
 ARG GEOS_TPL_TAG
-FROM docker.io/geosx/ubuntu20.04-gcc10:${GEOS_TPL_TAG}
+FROM docker.io/geosx/ubuntu24.04-gcc13:${GEOS_TPL_TAG}
 
 RUN apt-get update
 RUN apt-get install -y \

.devcontainer/devcontainer.json

@@ -2,7 +2,7 @@
     "build": {
         "dockerfile": "Dockerfile",
         "args": {
-            "GEOS_TPL_TAG": "344-968"
+            "GEOS_TPL_TAG": "349-1013"
         }
     },
     "runArgs": [

.github/ci/README.md

@@ -55,6 +55,11 @@ Required fields (all of them, always):
   the prefix before the first `-`, so a runner label like `streak2-32core` will reuse the
   `streak2` entry. Use `{}` for runners that do not need an LLNL-style outbound cert bundle.
 
+- `runner_cuda_architectures`
+  Map keyed by runner label, not by workflow role. Each value is forwarded to CMake as
+  `CMAKE_CUDA_ARCHITECTURES` for CUDA jobs on that runner. The same exact-match then prefix
+  fallback used by `runner_ca_bundle_host_paths` applies. Example: `{"streak2": "86"}`.
+
 - `runners`
   Map from runner role to runner label. Required roles:
   - `default`

.github/ci/orgs/EarthFlowAI.json

@@ -5,6 +5,7 @@
   "artifact_public_url_base": "https://pub-17b272fb651e459ca81dd0fd457099ed.r2.dev",
   "artifact_public_url_bucket_scoped": true,
   "runner_ca_bundle_host_paths": {},
+  "runner_cuda_architectures": { "thinkpad": "120" },
   "runners": {
     "default": "ubuntu-22.04",
     "cpu_heavy": "32core",

.github/ci/orgs/GEOS-DEV.json

@@ -5,6 +5,7 @@
   "artifact_public_url_base": "https://storage.googleapis.com",
   "artifact_public_url_bucket_scoped": false,
   "runner_ca_bundle_host_paths": { "streak2": "/etc/pki/tls/certs/ca-bundle.crt" },
+  "runner_cuda_architectures": { "streak2": "86" },
   "runners": {
     "default": "ubuntu-22.04",
     "cpu_heavy": "streak2",

.github/workflows/build_and_test.yml

@@ -16,6 +16,10 @@ on:
       CMAKE_BUILD_TYPE:
         required: true
         type: string
+      CMAKE_CUDA_ARCHITECTURES:
+        required: false
+        type: string
+        default: ''
       CODE_COVERAGE:
         required: false
         type: boolean
@@ -626,6 +630,9 @@ jobs:
         if [ ! -z "${{ inputs.GEOS_ENABLE_BOUNDS_CHECK }}" ]; then
           script_args+=(--geos-enable-bounds-check "${{ inputs.GEOS_ENABLE_BOUNDS_CHECK }}")
         fi
+        if [ ! -z "${{ inputs.CMAKE_CUDA_ARCHITECTURES }}" ]; then
+          script_args+=(--cmake-cuda-architectures "${{ inputs.CMAKE_CUDA_ARCHITECTURES }}")
+        fi
 
         # The linear algebra environment variables (ENABLE_HYPRE, ENABLE_HYPRE_DEVICE & ENABLE_TRILINOS)
         # are passed as scripts parameters. Specific care must be taken to be sure
@@ -859,4 +866,3 @@ jobs:
           -v "${GITHUB_WORKSPACE}:/tmp/geos" \
           alpine:3.20 \
           sh -lc 'rm -rf /tmp/geos/* /tmp/geos/.[!.]* /tmp/geos/..?* || true'
-

inputFiles/poromechanics/poroElasticCoupling.ats

@@ -1,4 +1,16 @@
-from geos.ats.test_builder import TestDeck, RestartcheckParameters, generate_geos_tests
+import os
+
+from ats.tests import AtsTest
+from geos.ats.test_builder import (TestDeck, RestartcheckParameters,
+                                   collect_block_names, logger,
+                                   test_build_failures)
+from geos.ats.test_case import TestCase
+from geos.ats.test_steps import geos
+
+
+TEST_TIMELIMITS = {
+    "PoroElastic_hybridHexPrism_co2_fim_3d_01": "45m",
+}
 
 
 class Description(object):
@@ -72,6 +84,95 @@ def _build_poro_elastic_coupling_case(deck, cycles, partitions, description,
         restartcheck_params=RestartcheckParameters(**restartcheck_params))
 
 
+def _generate_poro_elastic_coupling_tests(decks, test_type='smoke'):
+    for ii, deck in enumerate(decks):
+
+        restartcheck_params = None
+        curvecheck_params = None
+
+        if deck.restartcheck_params is not None:
+            restartcheck_params = deck.restartcheck_params.as_dict()
+
+        if deck.curvecheck_params is not None:
+            curvecheck_params = deck.curvecheck_params.as_dict()
+
+        for partition in deck.partitions:
+            nx, ny, nz = partition
+            n_ranks = nx * ny * nz
+
+            testcase_name = "{}_{:02d}".format(deck.name, n_ranks)
+            base_name = "0to{:d}".format(deck.check_step)
+
+            xml_file = ''
+            for suffix in ['', f'_{test_type}']:
+                if os.path.isfile("{}{}.xml".format(deck.name, suffix)):
+                    xml_file = "{}{}.xml".format(deck.name, suffix)
+
+            if not xml_file:
+                logger.error(
+                    f'Could not find a matching xml file for the test: {deck.name}'
+                )
+                test_build_failures.append(deck.name)
+                continue
+
+            xml_blocks = collect_block_names(xml_file)
+
+            checks = []
+            if curvecheck_params:
+                checks.append('curve')
+
+            geos_kwargs = {}
+            if testcase_name in TEST_TIMELIMITS:
+                geos_kwargs["timelimit"] = TEST_TIMELIMITS[testcase_name]
+
+            steps = [
+                geos(deck=xml_file,
+                     name=base_name,
+                     np=n_ranks,
+                     ngpu=n_ranks,
+                     x_partitions=nx,
+                     y_partitions=ny,
+                     z_partitions=nz,
+                     restartcheck_params=restartcheck_params,
+                     curvecheck_params=curvecheck_params,
+                     **geos_kwargs)
+            ]
+
+            if deck.restart_step > 0:
+                checks.append('restart')
+                steps.append(
+                    geos(deck=xml_file,
+                         name="{:d}to{:d}".format(deck.restart_step,
+                                                  deck.check_step),
+                         np=n_ranks,
+                         ngpu=n_ranks,
+                         x_partitions=nx,
+                         y_partitions=ny,
+                         z_partitions=nz,
+                         restart_file=os.path.join(
+                             testcase_name,
+                             "{}_restart_{:09d}".format(
+                                 base_name, deck.restart_step)),
+                         baseline_pattern=rf"{base_name}_restart_[0-9]+\.root",
+                         allow_rebaseline=False,
+                         restartcheck_params=restartcheck_params,
+                         **geos_kwargs))
+
+            AtsTest.stick(level=ii)
+            AtsTest.stick(checks=','.join(checks))
+            AtsTest.stick(solvers=','.join(xml_blocks.get('Solvers', [])))
+            AtsTest.stick(outputs=','.join(xml_blocks.get('Outputs', [])))
+            AtsTest.stick(
+                constitutive_models=','.join(
+                    xml_blocks.get('Constitutive', [])))
+            TestCase(name=testcase_name,
+                     desc=deck.description,
+                     label="auto",
+                     owner="GEOS team",
+                     independent=True,
+                     steps=steps)
+
+
 def _build_Terzaghi_cases():
     description = Description("Terzaghi's 1D Consolidation", "auto",
                               "Nicola Castelletto", True)
@@ -333,7 +434,7 @@ def test_poro_elastic_coupling_cases():
         _build_PoroElasticCarmanKozenySequential_cases()
     ]
 
-    generate_geos_tests(deck_instances)
+    _generate_poro_elastic_coupling_tests(deck_instances)
 
 
 test_poro_elastic_coupling_cases()

scripts/ci_build_and_test_in_container.sh

@@ -106,6 +106,8 @@ Usage: $0
       Request for the build of geos only.
   --cmake-build-type ...
       One of Debug, Release, RelWithDebInfo and MinSizeRel. Forwarded to CMAKE_BUILD_TYPE.
+  --cmake-cuda-architectures ...
+      Optional override for CMAKE_CUDA_ARCHITECTURES.
   --code-coverage
       run a code build and test.
   --data-basename output.tar.gz
@@ -134,6 +136,8 @@ Usage: $0
       Do not run the unit tests (but they will be built).
   --nproc N
       Number of cores to use for the build.
+  --use-native-architecture
+      Build with compiler flags targeting the native runner CPU.
   --repository /path/to/repository
       Internal mountpoint where the geos repository will be available.
   --run-integrated-tests
@@ -153,7 +157,7 @@ exit 1
 # Then we'll move to the build dir.
 or_die cd $(dirname $0)/..
 
-args=$(or_die getopt -a -o h --long build-exe-only,cmake-build-type:,code-coverage,data-basename:,geos-enable-bounds-check:,enable-hypre:,enable-hypre-device:,enable-trilinos:,exchange-dir:,host-config:,install-dir-basename:,makefile,ninja,no-install-schema,no-run-unit-tests,nproc:,repository:,run-integrated-tests,sccache-config:,test-code-style,test-documentation,use-sccache,help -- "$@")
+args=$(or_die getopt -a -o h --long build-exe-only,cmake-build-type:,cmake-cuda-architectures:,code-coverage,data-basename:,geos-enable-bounds-check:,enable-hypre:,enable-hypre-device:,enable-trilinos:,exchange-dir:,host-config:,install-dir-basename:,makefile,ninja,no-install-schema,no-run-unit-tests,nproc:,repository:,run-integrated-tests,sccache-config:,test-code-style,test-documentation,use-native-architecture,use-sccache,help -- "$@")
 
 # Variables with default values
 BUILD_EXE_ONLY=false
@@ -174,6 +178,9 @@ NPROC="$(nproc)"
 GEOS_ENABLE_BOUNDS_CHECK=ON
 SCCACHE_BIN=""
 USE_SCCACHE=false
+CMAKE_CUDA_ARCHITECTURES_ARGS=()
+CMAKE_NATIVE_ARCHITECTURE_ARGS=()
+LCOV_CMAKE_ARGS=""
 
 eval set -- ${args}
 while :
@@ -184,6 +191,9 @@ do
       RUN_UNIT_TESTS=false
       shift;;
     --cmake-build-type)      CMAKE_BUILD_TYPE=$2;        shift 2;;
+    --cmake-cuda-architectures)
+      CMAKE_CUDA_ARCHITECTURES_ARGS+=("-DCMAKE_CUDA_ARCHITECTURES=$2")
+      shift 2;;
     --ninja)
         BUILD_GENERATOR=$1;
         shift;;
@@ -208,6 +218,10 @@ do
     --no-install-schema)     GEOS_INSTALL_SCHEMA=false; shift;;
     --no-run-unit-tests)     RUN_UNIT_TESTS=false;       shift;;
     --nproc)                 NPROC=$2;                   shift 2;;
+    --use-native-architecture)
+      CMAKE_NATIVE_ARCHITECTURE_ARGS+=('-DCMAKE_C_FLAGS="-march=native -mtune=native"')
+      CMAKE_NATIVE_ARCHITECTURE_ARGS+=('-DCMAKE_CXX_FLAGS="-march=native -mtune=native"')
+      shift;;
     --repository)            GEOS_SRC_DIR=$2;            shift 2;;
     --run-integrated-tests)  RUN_INTEGRATED_TESTS=true;  shift;;
     --upload-test-baselines) UPLOAD_TEST_BASELINES=true; shift;;
@@ -302,12 +316,13 @@ if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then
   phase_start "Set up integrated test environment"
   echo "Running the integrated tests has been requested."
   # We install the python environment required by ATS to run the integrated tests.
-  #or_die apt-get update
-  or_die apt-get install -y virtualenv python3-dev python-is-python3
+  or_die apt-get update
+  or_die apt-get install -y python3-dev python3-venv
   ATS_PYTHON_HOME=/tmp/run_integrated_tests_virtualenv
-  or_die virtualenv ${ATS_PYTHON_HOME}
+  or_die python3 -m venv ${ATS_PYTHON_HOME}
 
-  python3 -m pip cache purge
+  or_die ${ATS_PYTHON_HOME}/bin/python3 -m pip install --upgrade pip setuptools wheel
+  ${ATS_PYTHON_HOME}/bin/python3 -m pip cache purge
 
   # Setup a temporary directory to hold tests
   tempdir=$(mktemp -d)
@@ -316,14 +331,38 @@ if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then
   ATS_WORKING_DIR=$tempdir/GEOS_integratedTests_working
 
   export ATS_FILTER="np<=32"
-  ATS_CMAKE_ARGS="-DATS_ARGUMENTS=\"--machine openmpi --ats openmpi_mpirun=/usr/bin/mpirun --ats openmpi_args=--allow-run-as-root --ats openmpi_procspernode=32 --ats openmpi_maxprocs=32\" -DPython3_ROOT_DIR=${ATS_PYTHON_HOME} -DPython3_EXECUTABLE=${ATS_PYTHON_HOME}/bin/python3 -DATS_BASELINE_DIR=${ATS_BASELINE_DIR} -DATS_WORKING_DIR=${ATS_WORKING_DIR}"
+  ATS_CMAKE_ARGS="-DATS_ARGUMENTS=\"--machine openmpi --ats openmpi_mpirun=/usr/bin/mpirun --ats openmpi_args=--allow-run-as-root --ats openmpi_procspernode=32 --ats openmpi_maxprocs=32 --ats cutoff=45m\" -DPython3_ROOT_DIR=${ATS_PYTHON_HOME} -DPython3_EXECUTABLE=${ATS_PYTHON_HOME}/bin/python3 -DATS_BASELINE_DIR=${ATS_BASELINE_DIR} -DATS_WORKING_DIR=${ATS_WORKING_DIR}"
   phase_finish 0
 fi
 
 
 if [[ "${CODE_COVERAGE}" = true ]]; then
   or_die apt-get update
   or_die apt-get install -y lcov
+
+  LCOV_REAL=$(command -v lcov || true)
+  if [[ -n "${LCOV_REAL}" ]]; then
+    export GEOS_REAL_LCOV="${LCOV_REAL}"
+    LCOV_WRAPPER=/tmp/geos-lcov-wrapper
+    cat > "${LCOV_WRAPPER}" <<'EOF'
+#!/bin/bash
+set -e
+
+extra_args=()
+if "${GEOS_REAL_LCOV}" --version 2>&1 | grep -Eq 'LCOV version ([2-9]|[1-9][0-9])\.'; then
+  for arg in "$@"; do
+    if [[ "${arg}" == "--capture" || "${arg}" == "-c" ]]; then
+      extra_args=(--ignore-errors mismatch,empty)
+      break
+    fi
+  done
+fi
+
+exec "${GEOS_REAL_LCOV}" "${extra_args[@]}" "$@"
+EOF
+    or_die chmod +x "${LCOV_WRAPPER}"
+    LCOV_CMAKE_ARGS="-DLCOV_EXECUTABLE=${LCOV_WRAPPER}"
+  fi
 fi
 
 # The -DBLT_MPI_COMMAND_APPEND="--allow-run-as-root;--oversubscribe" option is added for OpenMPI.
@@ -355,7 +394,10 @@ or_die python3 scripts/config-build.py \
                -DGEOS_LA_INTERFACE:PATH=${GEOS_LA_INTERFACE} \
                -DENABLE_COVERAGE=$([[ "${CODE_COVERAGE}" = true ]] && echo 1 || echo 0) \
                -DGEOS_ENABLE_BOUNDS_CHECK=${GEOS_ENABLE_BOUNDS_CHECK} \
+               "${CMAKE_CUDA_ARCHITECTURES_ARGS[@]}" \
+               "${CMAKE_NATIVE_ARCHITECTURE_ARGS[@]}" \
                ${SCCACHE_CMAKE_ARGS} \
+               ${LCOV_CMAKE_ARGS} \
                ${ATS_CMAKE_ARGS}
 phase_finish 0
 
@@ -432,8 +474,13 @@ if [[ "${RUN_UNIT_TESTS}" = true ]]; then
 fi
 
 if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then
-  # fix the setuptools/distutils conflict
-  export SETUPTOOLS_USE_DISTUTILS=stdlib
+  PYTHON_MINOR_VERSION="$(${ATS_PYTHON_HOME}/bin/python3 -c 'import sys; print(sys.version_info.minor if sys.version_info.major == 3 else 99)')"
+  if (( PYTHON_MINOR_VERSION < 12 )); then
+    # fix the setuptools/distutils conflict
+    export SETUPTOOLS_USE_DISTUTILS=stdlib
+  else
+    unset SETUPTOOLS_USE_DISTUTILS
+  fi
 
   # We split the process in two steps. First installing the environment, then running the tests.
   phase_start "Build ATS environment"

scripts/setupPythonEnvironment.bash

@@ -131,11 +131,12 @@ do
         echo "  $p"
 
         # Try installing the package
-        if $VERBOSE
-            INSTALL_MSG=$($PYTHON_TARGET -m $PIP_CMD install --upgrade $PACKAGE_DIR/$p)
-            INSTALL_RC=$?
+        if [[ "${VERBOSE}" == true ]]
         then
-            INSTALL_MSG=$($PYTHON_TARGET -m $PIP_CMD install --upgrade $PACKAGE_DIR/$p 2>&1)
+            INSTALL_MSG=$("${PYTHON_TARGET}" -m ${PIP_CMD} install --upgrade "${PACKAGE_DIR}/${p}")
+            INSTALL_RC=$?
+        else
+            INSTALL_MSG=$("${PYTHON_TARGET}" -m ${PIP_CMD} install --upgrade "${PACKAGE_DIR}/${p}" 2>&1)
             INSTALL_RC=$?
         fi
 
@@ -237,4 +238,3 @@ fi
 
 
 echo "Done!"
-

src/cmake/GeosxOptions.cmake

@@ -177,6 +177,15 @@ if (ENABLE_GBENCHMARK)
                                 )
 endif()
 
+if( GEOS_ENABLE_FPE )
+  check_cxx_compiler_flag( "-ffp-exception-behavior=strict" GEOS_CXX_HAS_FP_EXCEPTION_BEHAVIOR_STRICT)
+  if( GEOS_CXX_HAS_FP_EXCEPTION_BEHAVIOR_STRICT )
+    blt_append_custom_compiler_flag( FLAGS_VAR CMAKE_CXX_FLAGS CLANG "-ffp-exception-behavior=strict" )
+  else()
+    message( WARNING "GEOS_ENABLE_FPE is ON, but ${CMAKE_CXX_COMPILER_ID} does not support -ffp-exception-behavior=strict." )
+  endif()
+endif()
+
 if( ${CMAKE_MAKE_PROGRAM} STREQUAL "ninja" OR ${CMAKE_MAKE_PROGRAM} MATCHES ".*/ninja$" )
   set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GEOS_NINJA_FLAGS}" )
 endif()

src/coreComponents/schema/schema.xsd.other

@@ -526,7 +526,7 @@ A field can represent a physical variable. (pressure, temperature, global compos
 		<!--fractureStencil => (no description available)-->
 		<xsd:attribute name="fractureStencil" type="geos_SurfaceElementStencil" />
 		<!--targetRegions => List of regions to build the stencil for-->
-		<xsd:attribute name="targetRegions" type="geos_mapBase_lt_string_cm_-geos_internal_StdVectorWrapper_lt_string_cm_-std_allocator_lt_string-_gt__cm_-false_gt__cm_-std_integral_constant_lt_bool_cm_-true_gt_-_gt_" />
+		<xsd:attribute name="targetRegions" type="geos_mapBase_lt_string_cm_-geos_internal_StdVectorWrapper_lt_string_cm_-std_allocator_lt_string-_gt__cm_-true_gt__cm_-std_integral_constant_lt_bool_cm_-true_gt_-_gt_" />
 	</xsd:complexType>
 	<xsd:complexType name="OutputsType">
 		<xsd:choice minOccurs="0" maxOccurs="unbounded">
@@ -1603,7 +1603,7 @@ A field can represent a physical variable. (pressure, temperature, global compos
 			<xsd:element name="MeshBodies" type="MeshBodiesType" />
 		</xsd:choice>
 		<!--Neighbors => (no description available)-->
-		<xsd:attribute name="Neighbors" type="geos_internal_StdVectorWrapper_lt_geos_NeighborCommunicator_cm_-std_allocator_lt_geos_NeighborCommunicator_gt__cm_-false_gt_" />
+		<xsd:attribute name="Neighbors" type="geos_internal_StdVectorWrapper_lt_geos_NeighborCommunicator_cm_-std_allocator_lt_geos_NeighborCommunicator_gt__cm_-true_gt_" />
 		<!--partitionManager => (no description available)-->
 		<xsd:attribute name="partitionManager" type="geos_PartitionBase" />
 	</xsd:complexType>