test: mixed-dimensional consistency

inputFiles/compositionalMultiphaseFlow/initialization_2phase_no_cappres.xml

@@ -121,15 +121,6 @@
       phaseRelPermExponent="{ 3, 3 }"
       phaseRelPermMaxValue="{ 0.4, 0.9 }"/>
 
-    <TableCapillaryPressure
-      name="cappres00"
-      phaseNames="{ gas, water }"
-      wettingNonWettingCapPressureTableName="pcgw00" />
-
-    <TableCapillaryPressure
-      name="cappres01"
-      phaseNames="{ gas, water }"
-      wettingNonWettingCapPressureTableName="pcgw01" />
   </Constitutive>
 
   <FieldSpecifications>
@@ -211,16 +202,6 @@
       coordinates="{ 0.0, 100.0 }"
       values="{ 368.15, 368.15 }" />
 
-    <TableFunction
-      name="pcgw00"
-      coordinates="{ 0.12, 0.95 }"
-      values="{ 0.0, 0.0 }" />
-
-    <TableFunction
-      name="pcgw01"
-      coordinates="{ 0.12, 0.95 }"
-      values="{ 2.0e5, 0.0 }" />
-
   </Functions>
 
   <Outputs>

src/coreComponents/codingUtilities/traits.hpp

@@ -111,6 +111,13 @@ HAS_MEMBER_FUNCTION_NO_RTYPE( resizeDefault, 0, 0 );
  */
 HAS_MEMBER_FUNCTION_NO_RTYPE( reserve, localIndex( 55 ) );
 
+/**
+ * @brief Defines a static constexpr bool HasMemberFunction_reserveValues< @p CLASS >
+ *        that is true iff the method @p CLASS ::reserveValues( localIndex ) exists.
+ * @tparam CLASS The type to test.
+ */
+HAS_MEMBER_FUNCTION_NO_RTYPE( reserveValues, localIndex( 55 ) );
+
 /**
  * @brief Defines a static constexpr bool HasMemberFunction_toView< @p CLASS >
  *        that is true iff the method @p CLASS ::toView() exists.

src/coreComponents/dataRepository/Group.cpp

@@ -86,7 +86,9 @@ void Group::deregisterWrapper( string const & name )
 
 void Group::resize( indexType const newSize )
 {
-  forWrappers( [newSize] ( WrapperBase & wrapper )
+  GEOS_MARK_FUNCTION
+
+    forWrappers( [newSize] ( WrapperBase & wrapper )
   {
     if( wrapper.sizedFromParent() == 1 )
     {
@@ -123,7 +125,7 @@ void Group::reserve( indexType const newSize )
   {
     if( subGroup.sizedFromParent() == 1 )
     {
-      subGroup.resize( newSize );
+      subGroup.reserve( newSize );
     }
   } );
 

src/coreComponents/dataRepository/wrapperHelpers.hpp

@@ -241,7 +241,29 @@ numElementsFromByteSize( localIndex const byteSize )
 template< typename T >
 std::enable_if_t< traits::HasMemberFunction_reserve< T > >
 reserve( T & value, localIndex const newCapacity )
-{ value.reserve( newCapacity ); }
+{
+  value.reserve( newCapacity );
+  if constexpr ( traits::HasMemberFunction_reserveValues< T const > )
+  {
+    localIndex const oldCapacity = value.size();
+    double const oldValueCapacity = value.valueCapacity();
+    localIndex const newValueCapacity = oldValueCapacity * newCapacity / oldCapacity;
+    value.reserveValues( newValueCapacity );
+  }
+}
+
+template< typename T,
+          int NDIM,
+          typename PERMUTATION >
+void reserve( Array< T, NDIM, PERMUTATION > & value, localIndex newCapacity )
+{
+  localIndex const * const dims = value.dims();
+  for( int i=1; i<NDIM; ++i )
+  {
+    newCapacity *= dims[ i ];
+  }
+  value.reserve( newCapacity );
+}
 
 template< typename T >
 std::enable_if_t< !traits::HasMemberFunction_reserve< T > >

src/coreComponents/finiteVolume/TwoPointFluxApproximation.cpp

@@ -419,8 +419,10 @@ void TwoPointFluxApproximation::addFractureMatrixConnectionsDFM( MeshLevel & mes
   arrayView2d< real64 const > faceCenter = faceManager.faceCenter();
   arrayView2d< real64 const > faceNormal = faceManager.faceNormal();
 
-  arrayView1d< real64 const > const & transMultiplier =
-    faceManager.getReference< array1d< real64 > >( m_coeffName + viewKeyStruct::transMultiplierString() );
+  string const transMultName = m_coeffName + viewKeyStruct::transMultiplierString();
+  arrayView1d< real64 const > const transMultiplier = faceManager.hasWrapper( transMultName )
+                                                    ? faceManager.getReference< array1d< real64 > >( transMultName )
+                                                    : arrayView1d< real64 const >{};
 
   SurfaceElementRegion & fractureRegion = elemManager.getRegion< SurfaceElementRegion >( faceElementRegionName );
   localIndex const fractureRegionIndex = fractureRegion.getIndexInParent();
@@ -528,7 +530,8 @@ void TwoPointFluxApproximation::addFractureMatrixConnectionsDFM( MeshLevel & mes
                                  stencilWeights,
                                  connectorIndex );
 
-          faceToCellStencil.addVectors( transMultiplier[faceIndex], faceNormalVector, cellToFaceVec );
+          real64 const transMult = !transMultiplier.empty() ? transMultiplier[faceIndex] : 1.0;
+          faceToCellStencil.addVectors( transMult, faceNormalVector, cellToFaceVec );
         }
       }
     }

src/coreComponents/integrationTests/CMakeLists.txt

@@ -31,4 +31,5 @@ if( GEOS_ENABLE_FLUIDFLOW )
   add_subdirectory( fluidFlowTests )
 endif()
 add_subdirectory( wellsTests )
-add_subdirectory( wavePropagationTests ) 
+add_subdirectory( wavePropagationTests )
+add_subdirectory( mechanicTest )

src/coreComponents/integrationTests/fluidFlowTests/CMakeLists.txt

@@ -22,6 +22,31 @@ set( dependencyList mainInterface testingUtilities )
 geos_decorate_link_dependencies( LIST decoratedDependencies
                                  DEPENDENCIES ${dependencyList} )
 
+# Copy mesh files to the test output directory once, via a dedicated target,
+# to avoid Ninja race conditions when multiple test targets run POST_BUILD
+# copy commands for the same destination files in parallel.
+set( fluidflow_mesh_files
+     polyhedral_voronoi_regular.vtu
+     polyhedral_voronoi_lattice.vtu
+     polyhedral_voronoi_complex.vtu
+     hex_pyr_tet_nested_mixed.vtu )
+
+set( fluidflow_mesh_outputs )
+foreach( mesh_file ${fluidflow_mesh_files} )
+    set( src "${CMAKE_CURRENT_SOURCE_DIR}/${mesh_file}" )
+    set( dst "${TEST_OUTPUT_DIRECTORY}/${mesh_file}" )
+    list( APPEND fluidflow_mesh_outputs ${dst} )
+    add_custom_command(
+        OUTPUT ${dst}
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
+        DEPENDS ${src}
+        COMMENT "Copying ${mesh_file} to test output directory"
+    )
+endforeach()
+
+add_custom_target( fluidflow_copy_mesh_files ALL
+    DEPENDS ${fluidflow_mesh_outputs} )
+
 # Add gtest C++ based tests
 foreach(test ${gtest_geosx_tests})
   get_filename_component( test_name ${test} NAME_WE )
@@ -34,39 +59,33 @@ foreach(test ${gtest_geosx_tests})
   geos_add_test( NAME ${test_name}
                  COMMAND ${test_name} )
 
- set_tests_properties(${test_name} PROPERTIES ENVIRONMENT "TEST_BINARY_DIR=$<TARGET_FILE_DIR:${test_name}>")
+  set_tests_properties(${test_name} PROPERTIES ENVIRONMENT "TEST_BINARY_DIR=$<TARGET_FILE_DIR:${test_name}>")
 
-    # Add TEST_BINARY_DIR as a compile definition
-    target_compile_definitions(${test_name} PRIVATE TEST_BINARY_DIR=\"$<TARGET_FILE_DIR:${test_name}>\")
+  # Add TEST_BINARY_DIR as a compile definition
+  target_compile_definitions(${test_name} PRIVATE TEST_BINARY_DIR=\"$<TARGET_FILE_DIR:${test_name}>\")
+
+  # Ensure mesh files are copied before any test executable is linked
+  add_dependencies( ${test_name} fluidflow_copy_mesh_files )
 
-    # --- Copy mesh file to test binary dir ---
-    add_custom_command(
-        TARGET ${test_name} POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different
-                ${CMAKE_CURRENT_SOURCE_DIR}/polyhedral_voronoi_regular.vtu
-                $<TARGET_FILE_DIR:${test_name}>
-    )
-    add_custom_command(
-        TARGET ${test_name} POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different
-                ${CMAKE_CURRENT_SOURCE_DIR}/polyhedral_voronoi_lattice.vtu
-                $<TARGET_FILE_DIR:${test_name}>
-    )
-    add_custom_command(
-        TARGET ${test_name} POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different
-                ${CMAKE_CURRENT_SOURCE_DIR}/polyhedral_voronoi_complex.vtu
-                $<TARGET_FILE_DIR:${test_name}>
-    )
-    add_custom_command(
-        TARGET ${test_name} POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different
-                ${CMAKE_CURRENT_SOURCE_DIR}/hex_pyr_tet_nested_mixed.vtu
-                $<TARGET_FILE_DIR:${test_name}>
-    )
-
 endforeach()
 
+# testFixedDimensionalHydrostaticEquilibrium: serial (single-rank) variant is always built.
+
+# --- Serial variant (always built) ---
+set( test "testFixedDimensionalHydrostaticEquilibrium.cpp" )
+get_filename_component( test_name ${test} NAME_WE )
+
+blt_add_executable( NAME ${test_name}
+                    SOURCES ${test}
+                    OUTPUT_DIR ${TEST_OUTPUT_DIRECTORY}
+                    DEPENDS_ON ${decoratedDependencies} ${tplDependencyList} )
+
+geos_add_test( NAME ${test_name}
+               COMMAND ${test_name} )
+
+set_tests_properties(${test_name} PROPERTIES ENVIRONMENT "TEST_BINARY_DIR=$<TARGET_FILE_DIR:${test_name}>")
+target_compile_definitions(${test_name} PRIVATE TEST_BINARY_DIR=\"$<TARGET_FILE_DIR:${test_name}>\")
+
 # For some reason, BLT is not setting CUDA language for these source files
 if ( ENABLE_CUDA )
   set_source_files_properties( ${gtest_geosx_tests} PROPERTIES LANGUAGE CUDA )

src/coreComponents/integrationTests/fluidFlowTests/testFixedDimensionalHydrostaticEquilibrium.cpp

@@ -0,0 +1,46 @@
+/*
+ * ------------------------------------------------------------------------------------------------------------
+ * SPDX-License-Identifier: LGPL-2.1-only
+ *
+ * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
+ * Copyright (c) 2018-2024 TotalEnergies
+ * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
+ * Copyright (c) 2023-2024 Chevron
+ * Copyright (c) 2019-     GEOS/GEOSX Contributors
+ * All rights reserved
+ *
+ * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
+ * ------------------------------------------------------------------------------------------------------------
+ */
+
+/**
+ * @file testFixedDimensionalHydrostaticEquilibrium.cpp
+ *
+ * Serial (single-rank) integration test for fixed-dimensional meshes
+ * initialized with hydrostatic equilibrium.
+ * Covers two-phase and three-phase immiscible cases.
+ */
+
+#include "integrationTests/fluidFlowTests/testFixedDimensionalHydrostaticEquilibriumFixture.hpp"
+
+CommandLineOptions g_commandLineOptions;
+
+INSTANTIATE_TEST_SUITE_P(
+  FixedDimHydrostaticCases,
+  FixedDimensionalHydrostaticEquilibriumTest,
+  ::testing::Values( "two_phases",
+                     "three_phases" ),
+  []( ::testing::TestParamInfo< std::string > const & paramInfo )
+{
+  return paramInfo.param;     // use case name as the test suffix
+}
+  );
+
+int main( int argc, char * * argv )
+{
+  ::testing::InitGoogleTest( &argc, argv );
+  g_commandLineOptions = *geos::basicSetup( argc, argv );
+  int const result = RUN_ALL_TESTS();
+  geos::basicCleanup();
+  return result;
+}