diff --git a/inputFiles/compositionalMultiphaseFlow/initialization_2phase_no_cappres.xml b/inputFiles/compositionalMultiphaseFlow/initialization_2phase_no_cappres.xml index 8825122af43..e7161fae00f 100644 --- a/inputFiles/compositionalMultiphaseFlow/initialization_2phase_no_cappres.xml +++ b/inputFiles/compositionalMultiphaseFlow/initialization_2phase_no_cappres.xml @@ -121,15 +121,6 @@ phaseRelPermExponent="{ 3, 3 }" phaseRelPermMaxValue="{ 0.4, 0.9 }"/> - - - @@ -211,16 +202,6 @@ coordinates="{ 0.0, 100.0 }" values="{ 368.15, 368.15 }" /> - - - - diff --git a/src/coreComponents/codingUtilities/traits.hpp b/src/coreComponents/codingUtilities/traits.hpp index ecf7b4e4dab..2eedf1aa861 100644 --- a/src/coreComponents/codingUtilities/traits.hpp +++ b/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. diff --git a/src/coreComponents/dataRepository/Group.cpp b/src/coreComponents/dataRepository/Group.cpp index 77328f77b28..ddf24016383 100644 --- a/src/coreComponents/dataRepository/Group.cpp +++ b/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 ); } } ); diff --git a/src/coreComponents/dataRepository/wrapperHelpers.hpp b/src/coreComponents/dataRepository/wrapperHelpers.hpp index 02fb30f7b47..42502fbf0bb 100644 --- a/src/coreComponents/dataRepository/wrapperHelpers.hpp +++ b/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 std::enable_if_t< !traits::HasMemberFunction_reserve< T > > diff --git a/src/coreComponents/finiteVolume/TwoPointFluxApproximation.cpp b/src/coreComponents/finiteVolume/TwoPointFluxApproximation.cpp index b030af8d762..d029fd291b2 100644 --- a/src/coreComponents/finiteVolume/TwoPointFluxApproximation.cpp +++ b/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 ); } } } diff --git a/src/coreComponents/integrationTests/CMakeLists.txt b/src/coreComponents/integrationTests/CMakeLists.txt index 38686825966..c3fc62cabb2 100644 --- a/src/coreComponents/integrationTests/CMakeLists.txt +++ b/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 ) diff --git a/src/coreComponents/integrationTests/fluidFlowTests/CMakeLists.txt b/src/coreComponents/integrationTests/fluidFlowTests/CMakeLists.txt index 951cac7c502..08a076df5cd 100644 --- a/src/coreComponents/integrationTests/fluidFlowTests/CMakeLists.txt +++ b/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=$") + set_tests_properties(${test_name} PROPERTIES ENVIRONMENT "TEST_BINARY_DIR=$") - # Add TEST_BINARY_DIR as a compile definition - target_compile_definitions(${test_name} PRIVATE TEST_BINARY_DIR=\"$\") + # Add TEST_BINARY_DIR as a compile definition + target_compile_definitions(${test_name} PRIVATE TEST_BINARY_DIR=\"$\") + + # 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 - $ - ) - add_custom_command( - TARGET ${test_name} POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy_if_different - ${CMAKE_CURRENT_SOURCE_DIR}/polyhedral_voronoi_lattice.vtu - $ - ) - add_custom_command( - TARGET ${test_name} POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy_if_different - ${CMAKE_CURRENT_SOURCE_DIR}/polyhedral_voronoi_complex.vtu - $ - ) - 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 - $ - ) - 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_compile_definitions(${test_name} PRIVATE TEST_BINARY_DIR=\"$\") + # 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 ) diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testFixedDimensionalHydrostaticEquilibrium.cpp b/src/coreComponents/integrationTests/fluidFlowTests/testFixedDimensionalHydrostaticEquilibrium.cpp new file mode 100644 index 00000000000..f72eafff1f3 --- /dev/null +++ b/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; +} diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testFixedDimensionalHydrostaticEquilibriumFixture.hpp b/src/coreComponents/integrationTests/fluidFlowTests/testFixedDimensionalHydrostaticEquilibriumFixture.hpp new file mode 100644 index 00000000000..ae328acae76 --- /dev/null +++ b/src/coreComponents/integrationTests/fluidFlowTests/testFixedDimensionalHydrostaticEquilibriumFixture.hpp @@ -0,0 +1,322 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 + * ------------------------------------------------------------------------------------------------------------ + */ + +/** + * @file testFixedDimensionalHydrostaticEquilibriumFixture.hpp + * + * Shared test fixture and TEST_P body for compositional multiphase flow + * on fixed-dimensional (InternalMesh) meshes initialized with hydrostatic + * equilibrium. Both the serial and (optional) MPI test executables include + * this header and only differ in the INSTANTIATE_TEST_SUITE_P parameters. + * + * Two cases are covered: + * - Two-phase (water / gas, 2 components) + * - Three-phase (oil / water / gas, 3 components) + * + * The test verifies that: + * 1. The Newton solver converges in at most @p maxExpectedNewtonIter iterations, + * because the hydrostatic equilibrium initialization guarantees that the system + * starts nearly at steady state. + * 2. The discrete accumulation term (compAmount - compAmount_n) is zero for all + * conservation equations, confirming that the initial state is perfectly consistent. + */ + +#ifndef GEOS_TEST_FIXEDDIMHYDROSTATICEQUILIBRIUM_FIXTURE_HPP +#define GEOS_TEST_FIXEDDIMHYDROSTATICEQUILIBRIUM_FIXTURE_HPP + +#include +#include +#include +#include + +#include "mainInterface/GeosxState.hpp" +#include "mainInterface/ProblemManager.hpp" +#include "mainInterface/initialization.hpp" +#include "codingUtilities/Utilities.hpp" +#include "common/MpiWrapper.hpp" +#include "physicsSolvers/PhysicsSolverManager.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseFVM.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseBaseFields.hpp" +#include "physicsSolvers/NonlinearSolverParameters.hpp" +#include "mesh/MeshLevel.hpp" +#include "mesh/ElementRegionManager.hpp" +#include "mesh/ElementSubRegionBase.hpp" +#include "mesh/DomainPartition.hpp" + +using namespace geos; + +constexpr real64 accumulation_tolerance = 1.0e-5; // same order as the newton tol in the input file + +extern CommandLineOptions g_commandLineOptions; + +/** + * @brief Integration test for compositional multiphase flow on fixed-dimensional + * meshes (InternalMesh) initialized with hydrostatic equilibrium. + * + * Parametrized with std::string that selects the case: + * - "two_phases" : 2-component, 2-phase (water, gas) + * - "three_phases" : 3-component, 3-phase (oil, water, gas) + */ +class FixedDimensionalHydrostaticEquilibriumTest + : public ::testing::TestWithParam< std::string > +{ +protected: + void SetUp() override + { + testBinaryDir = TEST_BINARY_DIR; + } + + /** + * @brief Generate the two-phase XML input string. + */ + static std::string generateTwoPhaseXml() + { + return + R"xml( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +)xml"; + } + + /** + * @brief Generate the three-phase XML input string. + */ + static std::string generateThreePhaseXml() + { + return + R"xml( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +)xml"; + } + + std::string testBinaryDir; +}; + +TEST_P( FixedDimensionalHydrostaticEquilibriumTest, Run ) +{ + std::string const & caseName = GetParam(); + + // Select the XML content based on the case name. + std::string xmlContent; + if( caseName == "two_phases" ) + { + xmlContent = generateTwoPhaseXml(); + } + else if( caseName == "three_phases" ) + { + xmlContent = generateThreePhaseXml(); + } + else + { + FAIL() << "Unknown case name: " << caseName; + } + + // Build a unique XML filename per test case. + std::string const xmlName = "test_fixed_dim_hydrostatic_" + caseName; + std::string const xmlPath = testBinaryDir + "/" + xmlName + ".xml"; + + // Only rank 0 writes the XML file; all ranks then barrier before reading it. + if( MpiWrapper::commRank( MPI_COMM_GEOS ) == 0 ) + { + std::ofstream ofs( xmlPath ); + ofs << xmlContent; + } + MpiWrapper::barrier( MPI_COMM_GEOS ); + + { + auto options = std::make_unique< CommandLineOptions >( g_commandLineOptions ); + options->inputFileNames.push_back( xmlPath ); + options->problemName = xmlName; + + GeosxState state( std::move( options ) ); + ASSERT_TRUE( state.initializeDataRepository() ); + state.applyInitialConditions(); + state.run(); + + ProblemManager & pm = state.getProblemManager(); + + // ----------------------------------------------------------------------- + // Check 1: Newton convergence + // On a regular InternalMesh the hydrostatic discretization should be exact + // (or nearly so), so only a small number of Newton iterations are expected. + // ----------------------------------------------------------------------- + { + CompositionalMultiphaseFVM & solver = + pm.getPhysicsSolverManager().getGroup< CompositionalMultiphaseFVM >( "FlowSolver" ); + + integer const maxExpectedIter = 2; + + integer const numNewtonIter = solver.getNonlinearSolverParameters().m_numNewtonIterations; + EXPECT_LE( numNewtonIter, maxExpectedIter ) + << "Case " << caseName + << ": expected at most " << maxExpectedIter + << " Newton iterations after hydrostatic init, got " << numNewtonIter; + } + + // ----------------------------------------------------------------------- + // Check 2: Zero accumulation + // compAmount == compAmount_n for every element and every component, + // confirming that the initial state is a true discrete equilibrium. + // ----------------------------------------------------------------------- + { + MeshLevel & mesh = pm.getDomainPartition().getMeshBody( 0 ).getBaseDiscretization(); + + mesh.getElemManager().forElementSubRegions( [&]( ElementSubRegionBase & subRegion ) + { + bool const isMatrixCell = dynamic_cast< CellElementSubRegion const * >( &subRegion ); + if( !isMatrixCell ) + return; + + arrayView2d< real64 const, compflow::USD_COMP > const compAmount = + subRegion.getField< fields::flow::compAmount >(); + arrayView2d< real64 const, compflow::USD_COMP > const compAmount_n = + subRegion.getField< fields::flow::compAmount_n >(); + + integer const numComp = compAmount.size( 1 ); + + for( localIndex k = 0; k < subRegion.size(); ++k ) + { + for( integer ic = 0; ic < numComp; ++ic ) + { + real64 const accumulation = compAmount[k][ic] - compAmount_n[k][ic]; + EXPECT_NEAR( accumulation, 0.0, accumulation_tolerance ) + << "Case " << caseName + << ": non-zero accumulation term at element " << k + << ", component " << ic + << " (compAmount=" << compAmount[k][ic] + << ", compAmount_n=" << compAmount_n[k][ic] << ")"; + } + } + } ); + } + } +} + +#endif /* GEOS_TEST_FIXEDDIMHYDROSTATICEQUILIBRIUM_FIXTURE_HPP */ diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibrium.cpp b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibrium.cpp new file mode 100644 index 00000000000..ef23605d585 --- /dev/null +++ b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibrium.cpp @@ -0,0 +1,61 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 + * ------------------------------------------------------------------------------------------------------------ + */ + +/** + * @file testMixedDimHydrostaticEquilibrium.cpp + * + * Serial (single-rank) variant of the mixed-dimensional hydrostatic equilibrium test. + * Test fixture and TEST_P body live in testMixedDimHydrostaticEquilibriumFixture.hpp. + */ + +#include "testMixedDimHydrostaticEquilibriumFixture.hpp" + +CommandLineOptions g_commandLineOptions; + +/** + * @brief Serial execution test cases (single rank, partition 1x1x1). + */ +INSTANTIATE_TEST_SUITE_P( + MixedDimHydrostaticEquilibriumSerialCases, + MixedDimHydrostaticEquilibriumTest, + ::testing::Combine( + ::testing::Values( + "fractured_mesh_tet_DFN_1.vtu", + "fractured_mesh_tet_DFN_123.vtu", + "fractured_wavy_mesh_tet_DFN_1.vtu", + "fractured_wavy_mesh_tet_DFN_123.vtu", + "fractured_full_span_mesh_hex_DFN_1.vtu", + "fractured_full_span_mesh_hex_DFN_123.vtu", + "fractured_full_span_mesh_tet_DFN_1.vtu", + "fractured_full_span_mesh_tet_DFN_123.vtu", + "t_shaped_wavy_mesh_hex_DFN_t1t2.vtu", + "t_shaped_wavy_mesh_tet_DFN_t1t2.vtu", + "y_shaped_wavy_mesh_hex_DFN_y1y2y3.vtu", + "y_shaped_wavy_mesh_tet_DFN_y1y2y3.vtu", + "DFN_5_fractures_hex_binarized.vtu", + "DFN_5_fractures_tet_binarized.vtu" + ), + ::testing::Values( + std::make_tuple( 1, 1, 1 ) + ) + ) + ); + +int main( int argc, char * argv[] ) +{ + ::testing::InitGoogleTest( &argc, argv ); + g_commandLineOptions = *geos::basicSetup( argc, argv, false ); + int result = RUN_ALL_TESTS(); + geos::basicCleanup(); + return result; +} diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibriumFixture.hpp b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibriumFixture.hpp new file mode 100644 index 00000000000..cd80290dcfc --- /dev/null +++ b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibriumFixture.hpp @@ -0,0 +1,383 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 + * ------------------------------------------------------------------------------------------------------------ + */ + +/** + * @file testMixedDimHydrostaticEquilibriumFixture.hpp + * + * Shared test fixture and TEST_P body for compositional multiphase flow in + * mixed-dimensional meshes initialized with hydrostatic equilibrium. + * Both the serial and MPI test executables include this header and only + * differ in the INSTANTIATE_TEST_SUITE_P parameters. + * + * The test verifies that: + * 1. The Newton solver converges in at most 2 iterations, because the hydrostatic + * equilibrium initialization guarantees that the system starts nearly at steady state. + * 2. The discrete accumulation term (compAmount - compAmount_n) is zero for all + * conservation equations, confirming that the initial state is perfectly consistent. + */ + +#ifndef GEOS_TEST_MIXEDDIMHYDROSTATICEQUILIBRIUM_FIXTURE_HPP +#define GEOS_TEST_MIXEDDIMHYDROSTATICEQUILIBRIUM_FIXTURE_HPP + +#include +#include +#include +#include + +#include "mainInterface/GeosxState.hpp" +#include "mainInterface/ProblemManager.hpp" +#include "mainInterface/initialization.hpp" +#include "codingUtilities/Utilities.hpp" +#include "common/MpiWrapper.hpp" +#include "physicsSolvers/PhysicsSolverManager.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseFVM.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseBaseFields.hpp" +#include "physicsSolvers/NonlinearSolverParameters.hpp" +#include "mesh/MeshLevel.hpp" +#include "mesh/ElementRegionManager.hpp" +#include "mesh/ElementSubRegionBase.hpp" +#include "mesh/DomainPartition.hpp" + +using namespace geos; + +constexpr real64 accumulation_tolerance = 1.0e-4; // same order as the newton tol in the input file + +extern CommandLineOptions g_commandLineOptions; + +/** + * @brief Integration test for compositional multiphase flow in mixed-dimensional meshes + * initialized with hydrostatic equilibrium. + * + * Parametrized with std::tuple>: + * - std::string: Mesh file name (e.g. "fractured_mesh_hex_DFN_1.vtu") + * - tuple: Number of MPI partitions in x, y, z directions + */ +class MixedDimHydrostaticEquilibriumTest + : public ::testing::TestWithParam< std::tuple< std::string, std::tuple< int, int, int > > > +{ +protected: + void SetUp() override + { + testBinaryDir = TEST_BINARY_DIR; + } + + std::string generateXmlInput( std::string const & meshFile, + std::string const & nodeSetNames ) + { + std::ostringstream oss; + oss << R"xml( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +)xml"; + return oss.str(); + } + + std::string testBinaryDir; +}; + +TEST_P( MixedDimHydrostaticEquilibriumTest, Run ) +{ + std::string const & meshFileName = std::get< 0 >( GetParam() ); + std::tuple< int, int, int > const & partitions = std::get< 1 >( GetParam() ); + int const xPartitions = std::get< 0 >( partitions ); + int const yPartitions = std::get< 1 >( partitions ); + int const zPartitions = std::get< 2 >( partitions ); + + std::string nodeSetNames = "{ f1_node_set }"; + if( meshFileName.find( "_DFN_123.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f1_node_set, f2_node_set, f3_node_set }"; + } + else if( meshFileName.find( "_DFN_12.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f1_node_set, f2_node_set }"; + } + else if( meshFileName.find( "_DFN_13.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f1_node_set, f3_node_set }"; + } + else if( meshFileName.find( "_DFN_23.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f2_node_set, f3_node_set }"; + } + else if( meshFileName.find( "_DFN_2.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f2_node_set }"; + } + else if( meshFileName.find( "_DFN_3.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f3_node_set }"; + } + else if( meshFileName.find( "_DFN_t1t2.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f1_node_set, f2_node_set }"; + } + else if( meshFileName.find( "_DFN_y1y2y3.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f1_node_set, f2_node_set, f3_node_set }"; + } + else if( meshFileName.find( "_5_fractures_" ) != std::string::npos ) + { + nodeSetNames = "{ f1_node_set, f2_node_set, f3_node_set, f4_node_set, f5_node_set }"; + } + + std::string const xmlContent = generateXmlInput( meshFileName, nodeSetNames ); + + // Build a unique XML filename per test case to avoid races when multiple + // test instances run concurrently and would otherwise overwrite the same file. + std::string baseName = meshFileName; + // strip the .vtu extension + std::string::size_type const extPos = baseName.rfind( ".vtu" ); + if( extPos != std::string::npos ) + baseName.erase( extPos ); + std::string const xmlName = "test_hydrostatic_" + baseName + + "_" + std::to_string( xPartitions ) + + "x" + std::to_string( yPartitions ) + + "x" + std::to_string( zPartitions ); + std::string const xmlPath = testBinaryDir + "/" + xmlName + ".xml"; + // Only rank 0 writes the XML file; all ranks then barrier before reading it. + if( MpiWrapper::commRank( MPI_COMM_GEOS ) == 0 ) + { + std::ofstream ofs( xmlPath ); + ofs << xmlContent; + } + MpiWrapper::barrier( MPI_COMM_GEOS ); + + { + auto options = std::make_unique< CommandLineOptions >( g_commandLineOptions ); + options->inputFileNames.push_back( xmlPath ); + options->problemName = xmlName; + options->xPartitionsOverride = xPartitions; + options->yPartitionsOverride = yPartitions; + options->zPartitionsOverride = zPartitions; + options->overridePartitionNumbers = true; + + GeosxState state( std::move( options ) ); + ASSERT_TRUE( state.initializeDataRepository() ); + state.applyInitialConditions(); + state.run(); + + ProblemManager & pm = state.getProblemManager(); + + // Verify that the hydrostatic equilibrium is the exact solution of the discrete system. + // For flat meshes the discretization is exact (or nearly so), so at most 2 Newton + // iterations are needed. For wavy meshes the geometry introduces a small discretization + // error with respect the exact hydrostatic equilibrium, so up to 4 iterations are allowed. + { + CompositionalMultiphaseFVM & solver = + pm.getPhysicsSolverManager().getGroup< CompositionalMultiphaseFVM >( "flowSolver" ); + + bool const isWavy = meshFileName.find( "_wavy_" ) != std::string::npos; + integer const maxExpectedIter = isWavy ? 4 : 2; + + integer const numNewtonIter = solver.getNonlinearSolverParameters().m_numNewtonIterations; + EXPECT_LE( numNewtonIter, maxExpectedIter ) + << "Mesh " << meshFileName + << ": expected at most " << maxExpectedIter + << " Newton iterations after hydrostatic init, got " << numNewtonIter; + } + + // Verify that the discrete accumulation term is zero for every element + // (compAmount == compAmount_n for all components), confirming that the + // hydrostatic initial state is consistent with the previous time-step + // snapshot and that the discrete fluxes are zero, i.e. the fluid is in equilibrium. + { + MeshLevel & mesh = pm.getDomainPartition().getMeshBody( 0 ).getBaseDiscretization(); + + mesh.getElemManager().forElementSubRegions( [&]( ElementSubRegionBase & subRegion ) + { + bool const isMatrixCell = dynamic_cast< CellElementSubRegion const * >( &subRegion ); + bool const isFractureCell = dynamic_cast< FaceElementSubRegion const * >( &subRegion ); + if( !isMatrixCell && !isFractureCell ) + return; + + // compAmount and compAmount_n are both set by applyInitialConditions + // to the same value, so their difference must be exactly zero. + arrayView2d< real64 const, compflow::USD_COMP > const compAmount = + subRegion.getField< fields::flow::compAmount >(); + arrayView2d< real64 const, compflow::USD_COMP > const compAmount_n = + subRegion.getField< fields::flow::compAmount_n >(); + + integer const numComp = compAmount.size( 1 ); + + for( localIndex k = 0; k < subRegion.size(); ++k ) + { + for( integer ic = 0; ic < numComp; ++ic ) + { + real64 const accumulation = std::fabs( compAmount[k][ic] - compAmount_n[k][ic] ); + EXPECT_NEAR( accumulation, 0.0, accumulation_tolerance ) + << "Mesh " << meshFileName + << ": non-zero accumulation term at element " << k + << ", component " << ic + << " (compAmount=" << compAmount[k][ic] + << ", compAmount_n=" << compAmount_n[k][ic] << ")"; + } + } + } ); + } + } +} + +#endif /* GEOS_TEST_MIXEDDIMHYDROSTATICEQUILIBRIUM_FIXTURE_HPP */ diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibrium_mpi.cpp b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibrium_mpi.cpp new file mode 100644 index 00000000000..782a13e6040 --- /dev/null +++ b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibrium_mpi.cpp @@ -0,0 +1,78 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 + * ------------------------------------------------------------------------------------------------------------ + */ + +/** + * @file testMixedDimHydrostaticEquilibrium_mpi.cpp + * + * MPI (multi-rank) variant of the mixed-dimensional hydrostatic equilibrium test. + * Test fixture and TEST_P body live in testMixedDimHydrostaticEquilibriumFixture.hpp. + */ + +#include "testMixedDimHydrostaticEquilibriumFixture.hpp" + +CommandLineOptions g_commandLineOptions; + +// --------------------------------------------------------------------------- +// Test suite instantiation +// +// All 28 fractured mesh variants x 6 domain partitions = 168 test cases +// (run with 4 MPI ranks) +// --------------------------------------------------------------------------- +INSTANTIATE_TEST_SUITE_P( + MixedDimHydrostaticEquilibriumCases, + MixedDimHydrostaticEquilibriumTest, + ::testing::Combine( + ::testing::Values( + // Flat tet meshes - single and triple fracture only + "fractured_mesh_tet_DFN_1.vtu", + "fractured_mesh_tet_DFN_123.vtu", + + // Wavy tet meshes - single and triple fracture only + "fractured_wavy_mesh_tet_DFN_1.vtu", + "fractured_wavy_mesh_tet_DFN_123.vtu", + + // Full span hex meshes - single and triple fracture only + "fractured_full_span_mesh_hex_DFN_1.vtu", + "fractured_full_span_mesh_hex_DFN_123.vtu", + + // Full span tet meshes - single and triple fracture only + "fractured_full_span_mesh_tet_DFN_1.vtu", + "fractured_full_span_mesh_tet_DFN_123.vtu", + + // T-shaped wavy meshes + "t_shaped_wavy_mesh_hex_DFN_t1t2.vtu", + "t_shaped_wavy_mesh_tet_DFN_t1t2.vtu", + + // Y-shaped wavy meshes + "y_shaped_wavy_mesh_hex_DFN_y1y2y3.vtu", + "y_shaped_wavy_mesh_tet_DFN_y1y2y3.vtu", + + // 5-fracture DFN market meshes + "DFN_5_fractures_hex_binarized.vtu", + "DFN_5_fractures_tet_binarized.vtu" + ), + ::testing::Values( + std::make_tuple( 1, 4, 1 ), + std::make_tuple( 2, 1, 2 ) + ) + ) + ); + +int main( int argc, char * argv[] ) +{ + ::testing::InitGoogleTest( &argc, argv ); + g_commandLineOptions = *geos::basicSetup( argc, argv, false ); + int result = RUN_ALL_TESTS(); + geos::basicCleanup(); + return result; +} diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlow.cpp b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlow.cpp new file mode 100644 index 00000000000..733618dabf7 --- /dev/null +++ b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlow.cpp @@ -0,0 +1,49 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 + * ------------------------------------------------------------------------------------------------------------ + */ + +/** + * @file testMixedDimSinglePhaseFlow.cpp + * + * Serial (single-rank) variant of the mixed-dimensional single-phase flow test. + * Test fixture and TEST_P body live in testMixedDimSinglePhaseFlowFixture.hpp. + */ + +#include "testMixedDimSinglePhaseFlowFixture.hpp" + +CommandLineOptions g_commandLineOptions; + +/** + * @brief Serial execution test cases (single rank, partition 1x1x1). + */ +INSTANTIATE_TEST_SUITE_P( + MixedDimSerialFlowCases, + MixedDimSinglePhaseFlowTest, + ::testing::Combine( + ::testing::Values( + "fractured_mesh_hex_DFN_123.vtu" + ), + ::testing::Bool(), + ::testing::Values( + std::make_tuple( 1, 1, 1 ) + ) + ) + ); + +int main( int argc, char * argv[] ) +{ + ::testing::InitGoogleTest( &argc, argv ); + g_commandLineOptions = *geos::basicSetup( argc, argv, false ); + int result = RUN_ALL_TESTS(); + geos::basicCleanup(); + return result; +} diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlowFixture.hpp b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlowFixture.hpp new file mode 100644 index 00000000000..d1d64b370f8 --- /dev/null +++ b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlowFixture.hpp @@ -0,0 +1,277 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 + * ------------------------------------------------------------------------------------------------------------ + */ + +/** + * @file testMixedDimSinglePhaseFlowFixture.hpp + * + * Shared test fixture and TEST_P body for single-phase flow in mixed-dimensional + * meshes (3D matrix + 2D fractures). Both the serial and MPI test executables + * include this header and only differ in the INSTANTIATE_TEST_SUITE_P parameters. + */ + +#ifndef GEOS_TEST_MIXEDDIMSINGLEPHASEFLOW_FIXTURE_HPP +#define GEOS_TEST_MIXEDDIMSINGLEPHASEFLOW_FIXTURE_HPP + +#include +#include +#include +#include +#include "mainInterface/GeosxState.hpp" +#include "mainInterface/ProblemManager.hpp" +#include "mainInterface/initialization.hpp" +#include "codingUtilities/Utilities.hpp" +#include "common/MpiWrapper.hpp" +#include "physicsSolvers/fluidFlow/FlowSolverBaseFields.hpp" +#include "mesh/MeshLevel.hpp" +#include "mesh/ElementRegionManager.hpp" +#include "mesh/ElementSubRegionBase.hpp" +#include "mesh/DomainPartition.hpp" + +using namespace geos; + +constexpr real64 relative_tolerance = 1.0e-6; // exact up to the order of defaultAperture="1.0e-7" + +extern CommandLineOptions g_commandLineOptions; + +/** + * @brief Integration test for single-phase flow in mixed-dimensional meshes (3D matrix + 2D fractures). + * + * This test verifies the correct initialization and solution of pressure fields in a system + * coupled with fracture elements. It checks both: + * 1. Initial condition application (when runSolver = false) + * 2. Steady-state solution with a pressure gradient (when runSolver = true) + * + * Parametrized with std::tuple>: + * - std::string: Mesh file name (e.g., "fractured_mesh_hex_DFN_1.vtu"). + * - bool: Whether to run the flow solver (true) or just check initialization (false). + * - tuple: Number of partitions in the x, y, z directions. + */ +class MixedDimSinglePhaseFlowTest : public ::testing::TestWithParam< std::tuple< std::string, bool, std::tuple< int, int, int > > > +{ +protected: + void SetUp() override + { + testBinaryDir = TEST_BINARY_DIR; + } + + std::string generateXmlInput( std::string const & meshFile, std::string const & nodeSetNames, bool const runSolver ) + { + std::ostringstream oss; + oss << R"xml( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +)xml"; + if( runSolver ) + { + oss << R"xml( +)xml"; + } + oss << R"xml( + +)xml"; + return oss.str(); + } + + std::string testBinaryDir; +}; + +TEST_P( MixedDimSinglePhaseFlowTest, Run ) +{ + std::string const & meshFileName = std::get< 0 >( GetParam() ); + bool const runSolver = std::get< 1 >( GetParam() ); + std::tuple< int, int, int > const & partitions = std::get< 2 >( GetParam() ); + int const xPartitions = std::get< 0 >( partitions ); + int const yPartitions = std::get< 1 >( partitions ); + int const zPartitions = std::get< 2 >( partitions ); + + std::string xmlPath = testBinaryDir + "/test_mixed_dim_single_phase_flow.xml"; + + std::string nodeSetNames = "{ f1_node_set }"; + if( meshFileName.find( "_DFN_12.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f1_node_set, f2_node_set }"; + } + else if( meshFileName.find( "_DFN_123.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f1_node_set, f2_node_set, f3_node_set }"; + } + + std::string xmlContent = generateXmlInput( meshFileName, nodeSetNames, runSolver ); + + // Only rank 0 writes the XML file; barrier ensures all ranks see it before proceeding. + if( MpiWrapper::commRank( MPI_COMM_GEOS ) == 0 ) + { + std::ofstream ofs( xmlPath ); + ofs << xmlContent; + } + MpiWrapper::barrier( MPI_COMM_GEOS ); + + // Scoped state to ensure cleanup + { + auto options = std::make_unique< CommandLineOptions >( g_commandLineOptions ); + options->inputFileNames.push_back( xmlPath ); + options->problemName = "test_mixed_dim_single_phase_flow"; + + options->xPartitionsOverride = xPartitions; + options->yPartitionsOverride = yPartitions; + options->zPartitionsOverride = zPartitions; + options->overridePartitionNumbers = true; + + GeosxState state( std::move( options ) ); + ASSERT_TRUE( state.initializeDataRepository() ); + state.applyInitialConditions(); + + state.run(); + + { + ProblemManager & pm = state.getProblemManager(); + MeshLevel & mesh = pm.getDomainPartition().getMeshBody( 0 ).getBaseDiscretization(); + + mesh.getElemManager().forElementSubRegions( [&]( ElementSubRegionBase & subRegion ) + { + bool const isMatrixCell = dynamic_cast< CellElementSubRegion const * >( &subRegion ) != nullptr; + bool const isFractureCell = dynamic_cast< FaceElementSubRegion const * >( &subRegion ) != nullptr; + if( !isMatrixCell && !isFractureCell ) + { + return; + } + + arrayView1d< real64 const > const pressure = subRegion.getField< fields::flow::pressure >(); + arrayView2d< real64 const > const center = subRegion.getElementCenter(); + + localIndex const numElems = subRegion.size(); + + // Use RAJA reduce to compute the maximum relative error on the device, + // since pressure data may reside on GPU memory in device builds. + RAJA::ReduceMax< parallelDeviceReduce, real64 > maxRelError( 0.0 ); + + if( runSolver ) + { + forAll< geos::parallelDevicePolicy<> >( numElems, [=] GEOS_HOST_DEVICE ( localIndex const k ) + { + real64 const x = center[k][0]; + real64 const exactPressure = 2.0 * ( 1.0 - x ) + 1.0 * x; + real64 const relErr = LvArray::math::abs( pressure[k] - exactPressure ) / exactPressure; + maxRelError.max( relErr ); + } ); + } + else + { + real64 const exactPressure = isMatrixCell ? 1.5 : 2.0; + forAll< geos::parallelDevicePolicy<> >( numElems, [=] GEOS_HOST_DEVICE ( localIndex const k ) + { + real64 const relErr = LvArray::math::abs( pressure[k] - exactPressure ) / exactPressure; + maxRelError.max( relErr ); + } ); + } + + EXPECT_NEAR( maxRelError.get(), 0.0, relative_tolerance ) + << ( isMatrixCell ? "Matrix" : "Fracture" ) << " subregion has inexact pressure."; + } ); + } + } +} + +#endif /* GEOS_TEST_MIXEDDIMSINGLEPHASEFLOW_FIXTURE_HPP */ diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlow_mpi.cpp b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlow_mpi.cpp new file mode 100644 index 00000000000..53e47f5f414 --- /dev/null +++ b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlow_mpi.cpp @@ -0,0 +1,55 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 + * ------------------------------------------------------------------------------------------------------------ + */ + +/** + * @file testMixedDimSinglePhaseFlow_mpi.cpp + * + * MPI (multi-rank) variant of the mixed-dimensional single-phase flow test. + * Test fixture and TEST_P body live in testMixedDimSinglePhaseFlowFixture.hpp. + */ + +#include "testMixedDimSinglePhaseFlowFixture.hpp" + +CommandLineOptions g_commandLineOptions; + +/** + * @brief Parallel execution test cases (4 MPI ranks). + * + * Combinations: + * - Meshes: 1 fracture, 2 fractures, 3 fractures + * - Solver: Run solver (true) vs Initialization only (false) + * - Partitioning: 1x1x4, 1x2x2 (4 ranks) + */ +INSTANTIATE_TEST_SUITE_P( + MixedDimPartitionedFlowCases, + MixedDimSinglePhaseFlowTest, + ::testing::Combine( + ::testing::Values( + "fractured_mesh_hex_DFN_123.vtu" + ), + ::testing::Bool(), + ::testing::Values( + std::make_tuple( 1, 1, 4 ), + std::make_tuple( 1, 2, 2 ) + ) + ) + ); + +int main( int argc, char * argv[] ) +{ + ::testing::InitGoogleTest( &argc, argv ); + g_commandLineOptions = *geos::basicSetup( argc, argv, false ); + int result = RUN_ALL_TESTS(); + geos::basicCleanup(); + return result; +} diff --git a/src/coreComponents/integrationTests/mechanicTest/CMakeLists.txt b/src/coreComponents/integrationTests/mechanicTest/CMakeLists.txt new file mode 100644 index 00000000000..d0a53497cb0 --- /dev/null +++ b/src/coreComponents/integrationTests/mechanicTest/CMakeLists.txt @@ -0,0 +1,82 @@ +# Specify list of tests +set( tplDependencyList ${parallelDeps} gtest ) + +set( dependencyList mainInterface testingUtilities ) + +geos_decorate_link_dependencies( LIST decoratedDependencies + DEPENDENCIES ${dependencyList} ) + +# Mesh files needed by all tests (sourced from the canonical dfn_market directory) +set( DFN_MARKET_MESH_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../meshTests/dfn_market ) + +set( mesh_files + fractured_mesh_hex_DFN_1.vtu + fractured_mesh_hex_DFN_12.vtu + fractured_mesh_hex_DFN_123.vtu + fractured_mesh_tet_DFN_1.vtu + fractured_mesh_tet_DFN_123.vtu + fractured_wavy_mesh_hex_DFN_1.vtu + fractured_wavy_mesh_hex_DFN_123.vtu + fractured_wavy_mesh_tet_DFN_1.vtu + fractured_wavy_mesh_tet_DFN_123.vtu + fractured_full_span_mesh_hex_DFN_1.vtu + fractured_full_span_mesh_hex_DFN_123.vtu + fractured_full_span_mesh_tet_DFN_1.vtu + fractured_full_span_mesh_tet_DFN_123.vtu + t_shaped_wavy_mesh_hex_DFN_t1t2.vtu + t_shaped_wavy_mesh_tet_DFN_t1t2.vtu + y_shaped_wavy_mesh_hex_DFN_y1y2y3.vtu + y_shaped_wavy_mesh_tet_DFN_y1y2y3.vtu + DFN_5_fractures_hex_binarized.vtu + DFN_5_fractures_tet_binarized.vtu +) + +# --------------------------------------------------------------------------- +# Copy DFN-market mesh files into the test output directory at configure time. +# These are static assets; a one-time copy avoids the Ninja race condition +# that arises when multiple POST_BUILD commands write the same files in parallel. +# --------------------------------------------------------------------------- +file( MAKE_DIRECTORY ${TEST_OUTPUT_DIRECTORY} ) +foreach( mesh_file ${mesh_files} ) + file( COPY ${DFN_MARKET_MESH_SOURCE_DIR}/${mesh_file} + DESTINATION ${TEST_OUTPUT_DIRECTORY} ) +endforeach() + +# testFEMConsistency: serial (single-rank) variant is always built. +# Additionally, the multi-rank MPI variant (4 ranks) is built on CPU-only MPI builds. + +# --- Serial variant (always built) --- +set( test "testFEMConsistency.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_compile_definitions(${test_name} PRIVATE TEST_BINARY_DIR=\"$\") + +# --- MPI variant (CPU-only MPI builds) --- +if( ENABLE_MPI AND NOT ENABLE_CUDA AND NOT ENABLE_HIP ) + set( test "testFEMConsistency_mpi.cpp" ) + # The FractureStressCasesPartitioned suite requires 4 ranks (e.g., 1x1x4 partitioning) + set( nranks 4 ) + + 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} -x ${nranks} + NUM_MPI_TASKS ${nranks} ) + + set_tests_properties(${test_name} PROPERTIES ENVIRONMENT "TEST_BINARY_DIR=$") + target_compile_definitions(${test_name} PRIVATE TEST_BINARY_DIR=\"$\") +endif() diff --git a/src/coreComponents/integrationTests/mechanicTest/testFEMConsistency.cpp b/src/coreComponents/integrationTests/mechanicTest/testFEMConsistency.cpp new file mode 100644 index 00000000000..ff353f31ae9 --- /dev/null +++ b/src/coreComponents/integrationTests/mechanicTest/testFEMConsistency.cpp @@ -0,0 +1,77 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 + * ------------------------------------------------------------------------------------------------------------ + */ + +/** + * @file testFEMConsistency.cpp + * + * Serial (single-rank) variant of the FEM consistency test. + * Test fixture and TEST_P body live in testFEMConsistencyFixture.hpp. + */ + +#include "testFEMConsistencyFixture.hpp" + +CommandLineOptions g_commandLineOptions; + +/** + * @brief Serial execution test cases (single rank, partition 1x1x1). + */ +INSTANTIATE_TEST_SUITE_P( + FractureStressCasesSerial, + ConsistencyTest, + ::testing::Combine( + ::testing::Values( + // Flat hex meshes - single and triple fracture only + "fractured_mesh_hex_DFN_1.vtu", + "fractured_mesh_hex_DFN_123.vtu", + + // Wavy hex meshes - single and triple fracture only + "fractured_wavy_mesh_hex_DFN_1.vtu", + "fractured_wavy_mesh_hex_DFN_123.vtu", + + // Full span hex meshes - single and triple fracture only + "fractured_full_span_mesh_hex_DFN_1.vtu", + "fractured_full_span_mesh_hex_DFN_123.vtu", + + // Full span tet meshes - single and triple fracture only + "fractured_full_span_mesh_tet_DFN_1.vtu", + "fractured_full_span_mesh_tet_DFN_123.vtu", + + // T-shaped wavy meshes + "t_shaped_wavy_mesh_hex_DFN_t1t2.vtu", + "t_shaped_wavy_mesh_tet_DFN_t1t2.vtu", + + // Y-shaped wavy meshes + "y_shaped_wavy_mesh_hex_DFN_y1y2y3.vtu", + "y_shaped_wavy_mesh_tet_DFN_y1y2y3.vtu", + + // 5-fracture DFN market meshes + "DFN_5_fractures_hex_binarized.vtu", + "DFN_5_fractures_tet_binarized.vtu" + ), + ::testing::Values( -1.0e6 ), // s_xx + ::testing::Values( -0.5e6 ), // s_yy + ::testing::Values( -2.0e6 ), // s_zz + ::testing::Values( + std::make_tuple( 1, 1, 1 ) + ) + ) + ); + +int main( int argc, char * argv[] ) +{ + ::testing::InitGoogleTest( &argc, argv ); + g_commandLineOptions = *geos::basicSetup( argc, argv, false ); + int result = RUN_ALL_TESTS(); + geos::basicCleanup(); + return result; +} diff --git a/src/coreComponents/integrationTests/mechanicTest/testFEMConsistencyFixture.hpp b/src/coreComponents/integrationTests/mechanicTest/testFEMConsistencyFixture.hpp new file mode 100644 index 00000000000..815246877fe --- /dev/null +++ b/src/coreComponents/integrationTests/mechanicTest/testFEMConsistencyFixture.hpp @@ -0,0 +1,502 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 + * ------------------------------------------------------------------------------------------------------------ + */ + +/** + * @file testFEMConsistencyFixture.hpp + * + * Shared test fixture and TEST_P body for the FEM consistency test. + * Both the serial and MPI test executables include this header and only + * differ in the INSTANTIATE_TEST_SUITE_P parameters. + * + * The test verifies the consistency of the Finite Element Method (FEM) + * implementation in GEOS for solid mechanics problems involving fractures. + */ + +#ifndef GEOS_TEST_FEMCONSISTENCY_FIXTURE_HPP +#define GEOS_TEST_FEMCONSISTENCY_FIXTURE_HPP + +#include +#include +#include +#include +#include "mainInterface/GeosxState.hpp" +#include "mainInterface/ProblemManager.hpp" +#include "mainInterface/initialization.hpp" +#include "mesh/DomainPartition.hpp" +#include "mesh/MeshBody.hpp" +#include "mesh/MeshLevel.hpp" +#include "mesh/ElementRegionManager.hpp" +#include "mesh/SurfaceElementRegion.hpp" +#include "mesh/SurfaceElementSubRegion.hpp" +#include "mesh/FaceElementSubRegion.hpp" +#include "physicsSolvers/solidMechanics/contact/ContactFields.hpp" +#include "common/format/Format.hpp" +#include "codingUtilities/Utilities.hpp" +#include "mesh/FaceManager.hpp" +#include "constitutive/solid/SolidFields.hpp" +#include "physicsSolvers/solidMechanics/SolidMechanicsFields.hpp" +#include "common/MpiWrapper.hpp" + +using namespace geos; + +constexpr real64 relative_tolerance = 1.0e-6; // Because MPa range is used + +extern CommandLineOptions g_commandLineOptions; + +/** + * @brief This integration test verifies the consistency of the Finite Element Method (FEM) implementation + * in GEOS for solid mechanics problems involving fractures. + * + * The test performs the following steps: + * 1. Generates an XML input file for a given mesh and stress boundary conditions. + * 2. Runs the simulation using the SolidMechanicsAugmentedLagrangianContact solver. + * 3. Verifies that the computed stress on fracture faces matches the expected traction derived from + * the applied stress field. + * 4. Verifies that the stress in the volume elements matches the applied stress boundary conditions. + * + * The test is parameterized to run on various mesh types (hex, tet, wavy) and fracture configurations. + * + * Parametrized with std::tuple>: + * - std::string: Mesh file name (e.g., "fractured_mesh_hex_DFN_1.vtu"). + * - real64: Applied stress component XX (s_xx). + * - real64: Applied stress component YY (s_yy). + * - real64: Applied stress component ZZ (s_zz). + * - tuple: Number of partitions in the x, y, z directions. + */ +class ConsistencyTest : public ::testing::TestWithParam< std::tuple< std::string, real64, real64, real64, std::tuple< int, int, int > > > +{ +protected: + void SetUp() override + { + testBinaryDir = TEST_BINARY_DIR; + } + + std::string generateXmlInput( std::string const & meshFile, std::string const & nodeSetNames, real64 s_xx, real64 s_yy, real64 s_zz ) + { + std::ostringstream oss; + oss << R"xml( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +)xml"; + return oss.str(); + } + + std::string testBinaryDir; +}; + +TEST_P( ConsistencyTest, Run ) +{ + auto const & params = GetParam(); + auto const & meshFileName = std::get< 0 >( params ); + real64 const s_xx = std::get< 1 >( params ); + real64 const s_yy = std::get< 2 >( params ); + real64 const s_zz = std::get< 3 >( params ); + std::tuple< int, int, int > const & partitions = std::get< 4 >( params ); + int const xPartitions = std::get< 0 >( partitions ); + int const yPartitions = std::get< 1 >( partitions ); + int const zPartitions = std::get< 2 >( partitions ); + std::string xmlPath = testBinaryDir + "/test_fem_consistency_" + meshFileName + ".xml"; + + std::string nodeSetNames = "{ f1_node_set }"; + if( meshFileName.find( "_DFN_123.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f1_node_set, f2_node_set, f3_node_set }"; + } + else if( meshFileName.find( "_DFN_12.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f1_node_set, f2_node_set }"; + } + else if( meshFileName.find( "_DFN_13.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f1_node_set, f3_node_set }"; + } + else if( meshFileName.find( "_DFN_23.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f2_node_set, f3_node_set }"; + } + else if( meshFileName.find( "_DFN_2.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f2_node_set }"; + } + else if( meshFileName.find( "_DFN_3.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f3_node_set }"; + } + else if( meshFileName.find( "_DFN_t1t2.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f1_node_set, f2_node_set }"; + } + else if( meshFileName.find( "_DFN_y1y2y3.vtu" ) != std::string::npos ) + { + nodeSetNames = "{ f1_node_set, f2_node_set, f3_node_set }"; + } + else if( meshFileName.find( "_5_fractures_" ) != std::string::npos ) + { + nodeSetNames = "{ f1_node_set, f2_node_set, f3_node_set, f4_node_set, f5_node_set }"; + } + + std::string xmlContent = generateXmlInput( meshFileName, nodeSetNames, s_xx, s_yy, s_zz ); + + if( MpiWrapper::commRank() == 0 ) + { + std::ofstream ofs( xmlPath ); + ofs << xmlContent; + } + MpiWrapper::barrier(); + + auto options = std::make_unique< CommandLineOptions >( g_commandLineOptions ); + options->inputFileNames.push_back( xmlPath ); + options->problemName = "test_fem_consistency"; + + options->xPartitionsOverride = xPartitions; + options->yPartitionsOverride = yPartitions; + options->zPartitionsOverride = zPartitions; + options->overridePartitionNumbers = true; + + // Scoped state to ensure cleanup + { + GeosxState state( std::move( options ) ); + ASSERT_TRUE( state.initializeDataRepository() ); + state.applyInitialConditions(); + state.run(); + + // Verification using bulk stress and geometric normal + ProblemManager & pm = state.getProblemManager(); + auto & fractureRegion = pm.getDomainPartition().getMeshBody( "mesh1" ).getBaseDiscretization().getElemManager().template getRegion< SurfaceElementRegion >( "Fracture" ); + auto & elemManager = pm.getDomainPartition().getMeshBody( "mesh1" ).getBaseDiscretization().getElemManager(); + auto & volumeRegion = elemManager.template getRegion< CellElementRegion >( "Region" ); + + auto const & faceManager = pm.getDomainPartition().getMeshBody( "mesh1" ).getBaseDiscretization().getFaceManager(); + auto const & nodeManager = pm.getDomainPartition().getMeshBody( "mesh1" ).getBaseDiscretization().getNodeManager(); + + auto const & faceToCell = faceManager.elementList(); + auto const & faceToRegion = faceManager.elementRegionList(); + auto const & faceToSubRegion = faceManager.elementSubRegionList(); + auto const & faceNodes = faceManager.nodeList(); + auto const & nodePos = nodeManager.referencePosition(); + + // RELAXED TOLERANCE FOR WAVY_HEX MESHES: + // Wavy-hex geometry results in faceted fracture surfaces where the local + // element normal (n_local) deviates slightly from the true analytical normal. + // + // This geometric misalignment ($\delta \theta$) projects a portion of the + // bulk compressive stress into the shear plane: $\tau = \sigma \sin(\delta \theta)$. + // To prevent these numerical shear artifacts from triggering premature + // slip or convergence failures, we increase the traction tolerance. + bool const isWavyHexMesh = ( meshFileName.find( "wavy_mesh_hex" ) != std::string::npos ); + + // Relaxed relative tolerances for wavy hex meshes + real64 const shear_tolerance = isWavyHexMesh ? 1.0e-1 : relative_tolerance; + real64 const normal_tolerance = isWavyHexMesh ? 1.0e-1 : relative_tolerance; + + fractureRegion.forElementSubRegions< FaceElementSubRegion >( [&]( FaceElementSubRegion & subRegion ) + { + auto const & fractureTraction = subRegion.getField< fields::contact::traction >(); + auto const & rotationMatrix = subRegion.getField< fields::contact::rotationMatrix >(); + auto const & faces = subRegion.faceList(); + localIndex const numFractureElements = subRegion.size(); + + // =================================================================================== + // Test 1: Verify traction from volume element stress matches expected applied stress + // This iterates over all faces adjacent to fracture elements (2 per fracture element) + // =================================================================================== + localIndex const numFaces = faces.size( 1 ); // Number of faces per fracture element (typically 2) + for( localIndex k = 0; k < numFractureElements; ++k ) + { + for( localIndex faceIdx = 0; faceIdx < numFaces; ++faceIdx ) + { + localIndex f = faces( k, faceIdx ); + + // Compute Geometric Normal using Dziuk method + auto const & fnodes = faceNodes[f]; + if( fnodes.size() < 3 ) + continue; + + real64 nx = 0.0; + real64 ny = 0.0; + real64 nz = 0.0; + + if( fnodes.size() == 4 ) + { + // For quadrilaterals: Use diagonal-based triangulation (more stable for warped quads) + // Triangle 1: (V0, V1, V2) + real64 p0[3] = { nodePos[fnodes[0]][0], nodePos[fnodes[0]][1], nodePos[fnodes[0]][2] }; + real64 p1[3] = { nodePos[fnodes[1]][0], nodePos[fnodes[1]][1], nodePos[fnodes[1]][2] }; + real64 p2[3] = { nodePos[fnodes[2]][0], nodePos[fnodes[2]][1], nodePos[fnodes[2]][2] }; + real64 p3[3] = { nodePos[fnodes[3]][0], nodePos[fnodes[3]][1], nodePos[fnodes[3]][2] }; + + real64 v01[3] = { p1[0]-p0[0], p1[1]-p0[1], p1[2]-p0[2] }; + real64 v02[3] = { p2[0]-p0[0], p2[1]-p0[1], p2[2]-p0[2] }; + real64 cp1_x = v01[1]*v02[2] - v01[2]*v02[1]; + real64 cp1_y = v01[2]*v02[0] - v01[0]*v02[2]; + real64 cp1_z = v01[0]*v02[1] - v01[1]*v02[0]; + + // Triangle 2: (V0, V2, V3) + real64 v03[3] = { p3[0]-p0[0], p3[1]-p0[1], p3[2]-p0[2] }; + real64 cp2_x = v02[1]*v03[2] - v02[2]*v03[1]; + real64 cp2_y = v02[2]*v03[0] - v02[0]*v03[2]; + real64 cp2_z = v02[0]*v03[1] - v02[1]*v03[0]; + + // Accumulate cross products + nx = cp1_x + cp2_x; + ny = cp1_y + cp2_y; + nz = cp1_z + cp2_z; + } + else + { + // For non-quad polygons: Use centroid-based fan triangulation + real64 centroid[3] = { 0.0, 0.0, 0.0 }; + for( localIndex i = 0; i < fnodes.size(); ++i ) + { + centroid[0] += nodePos[fnodes[i]][0]; + centroid[1] += nodePos[fnodes[i]][1]; + centroid[2] += nodePos[fnodes[i]][2]; + } + centroid[0] /= fnodes.size(); + centroid[1] /= fnodes.size(); + centroid[2] /= fnodes.size(); + + for( localIndex i = 0; i < fnodes.size(); ++i ) + { + localIndex const next = ( i + 1 ) % fnodes.size(); + + real64 v1[3] = { nodePos[fnodes[i]][0] - centroid[0], + nodePos[fnodes[i]][1] - centroid[1], + nodePos[fnodes[i]][2] - centroid[2] }; + real64 v2[3] = { nodePos[fnodes[next]][0] - centroid[0], + nodePos[fnodes[next]][1] - centroid[1], + nodePos[fnodes[next]][2] - centroid[2] }; + + real64 cp_x = v1[1]*v2[2] - v1[2]*v2[1]; + real64 cp_y = v1[2]*v2[0] - v1[0]*v2[2]; + real64 cp_z = v1[0]*v2[1] - v1[1]*v2[0]; + + nx += cp_x; + ny += cp_y; + nz += cp_z; + } + } + + real64 norm = std::sqrt( nx*nx + ny*ny + nz*nz ); + nx /= norm; ny /= norm; nz /= norm; + + // Get neighbor cell - try to find a valid one from either side of the face + localIndex c = -1; + localIndex er = -1; + localIndex esr = -1; + + // Try first neighbor + localIndex c0 = faceToCell[f][0]; + localIndex er0 = faceToRegion[f][0]; + localIndex esr0 = faceToSubRegion[f][0]; + + // Try second neighbor + localIndex c1 = faceToCell[f][1]; + localIndex er1 = faceToRegion[f][1]; + localIndex esr1 = faceToSubRegion[f][1]; + + // Use the first valid neighbor (one with valid cell, region, and subregion indices) + if( c0 != static_cast< localIndex >(-1) && + er0 != static_cast< localIndex >(-1) && + esr0 != static_cast< localIndex >(-1) ) + { + c = c0; + er = er0; + esr = esr0; + } + else if( c1 != static_cast< localIndex >(-1) && + er1 != static_cast< localIndex >(-1) && + esr1 != static_cast< localIndex >(-1) ) + { + c = c1; + er = er1; + esr = esr1; + } + else + { + // No valid neighbor cell found on this rank, skip this face + continue; + } + + ElementRegionBase & region = elemManager.getRegion( er ); + ElementSubRegionBase & cellSubRegion = region.getSubRegion( esr ); + auto const & avgStress = cellSubRegion.getField< fields::solidMechanics::averageStress >(); + + real64 sig_xx = avgStress( c, 0 ); + real64 sig_yy = avgStress( c, 1 ); + real64 sig_zz = avgStress( c, 2 ); + real64 sig_yz = avgStress( c, 3 ); + real64 sig_xz = avgStress( c, 4 ); + real64 sig_xy = avgStress( c, 5 ); + + // Compute t_sim = sigma * n + real64 ts_x = sig_xx * nx + sig_xy * ny + sig_xz * nz; + real64 ts_y = sig_xy * nx + sig_yy * ny + sig_yz * nz; + real64 ts_z = sig_xz * nx + sig_yz * ny + sig_zz * nz; + + // Compute t_exact = S_input * n + real64 te_x = s_xx * nx; + real64 te_y = s_yy * ny; + real64 te_z = s_zz * nz; + + // Compare (allow slightly larger relative_tolerance due to numerical precision of stress field) + real64 const err_abs = std::sqrt( std::pow( ts_x - te_x, 2 ) + std::pow( ts_y - te_y, 2 ) + std::pow( ts_z - te_z, 2 ) ); + real64 const norm_te = std::sqrt( std::pow( te_x, 2 ) + std::pow( te_y, 2 ) + std::pow( te_z, 2 ) ); + real64 const err = ( norm_te > 1.0e-16 ) ? err_abs / norm_te : err_abs; + EXPECT_LT( err, normal_tolerance ) << "Fracture element " << k << " face " << faceIdx + << " failed. t_sim=(" << ts_x << ", " << ts_y << ", " << ts_z + << ") t_exact=(" << te_x << ", " << te_y << ", " << te_z << ")"; + } + } + + // =================================================================================== + // Test 2: Verify fracture traction field matches expected traction + // This iterates only over fracture elements (not faces) + // =================================================================================== + for( localIndex k = 0; k < numFractureElements; ++k ) + { + // Get the fracture element's normal from the rotation matrix + // The rotation matrix columns are: [normal, tangent1, tangent2] + // So the normal is the first column: R[:,0] + real64 nx = rotationMatrix( k, 0, 0 ); + real64 ny = rotationMatrix( k, 1, 0 ); + real64 nz = rotationMatrix( k, 2, 0 ); + + // Compute t_exact = S_input * n (in global coordinates) + real64 te_x = s_xx * nx; + real64 te_y = s_yy * ny; + real64 te_z = s_zz * nz; + + // Project exact traction onto normal (should match tf_n) + real64 te_n = te_x * nx + te_y * ny + te_z * nz; + + // Project exact traction onto tangential plane + real64 te_tang_x = te_x - te_n * nx; + real64 te_tang_y = te_y - te_n * ny; + real64 te_tang_z = te_z - te_n * nz; + real64 te_tang_mag = std::sqrt( te_tang_x*te_tang_x + te_tang_y*te_tang_y + te_tang_z*te_tang_z ); + + // Get fracture traction from contact solver (in local coordinates: normal, tangent1, tangent2) + real64 tf_n = fractureTraction( k, 0 ); + real64 tf_t1 = fractureTraction( k, 1 ); + real64 tf_t2 = fractureTraction( k, 2 ); + real64 tf_tang_mag = std::sqrt( tf_t1*tf_t1 + tf_t2*tf_t2 ); + + real64 const norm_te = std::sqrt( te_x*te_x + te_y*te_y + te_z*te_z ); + real64 const err_n = std::fabs( tf_n - te_n ); + real64 const err_t = std::fabs( tf_tang_mag - te_tang_mag ); + + real64 const rel_err_n = ( norm_te > 1.0e-16 ) ? err_n / norm_te : err_n; + real64 const rel_err_t = ( norm_te > 1.0e-16 ) ? err_t / norm_te : err_t; + + EXPECT_LT( rel_err_n, normal_tolerance ) << "Fracture element " << k << " failed normal traction check. tf_n=" << tf_n << " te_n=" << te_n; + EXPECT_LT( rel_err_t, shear_tolerance ) << "Fracture element " << k << " failed tangential traction check. tf_t=" << tf_tang_mag << " te_t=" << te_tang_mag; + } + } ); + + volumeRegion.forElementSubRegions< ElementSubRegionBase >( [&]( ElementSubRegionBase & subRegion ) + { + auto const & avgStress = subRegion.getField< fields::solidMechanics::averageStress >(); + localIndex n_cells = subRegion.size(); + for( localIndex k=0; k < n_cells; ++k ) + { + real64 sig_xx = avgStress( k, 0 ); + real64 sig_yy = avgStress( k, 1 ); + real64 sig_zz = avgStress( k, 2 ); + real64 sig_yz = avgStress( k, 3 ); + real64 sig_xz = avgStress( k, 4 ); + real64 sig_xy = avgStress( k, 5 ); + + EXPECT_NEAR( std::fabs( (sig_xx - s_xx ) / s_xx ), 0.0, normal_tolerance ) << "Volume Element " << k << " failed xx stress."; + EXPECT_NEAR( std::fabs( (sig_yy - s_yy ) / s_yy ), 0.0, normal_tolerance ) << "Volume Element " << k << " failed yy stress."; + EXPECT_NEAR( std::fabs( (sig_zz - s_zz ) / s_zz ), 0.0, normal_tolerance ) << "Volume Element " << k << " failed zz stress."; + EXPECT_NEAR( std::fabs( sig_yz ) / 1.0e6, 0.0, shear_tolerance ) << "Volume Element " << k << " failed yz stress."; + EXPECT_NEAR( std::fabs( sig_xz ) / 1.0e6, 0.0, shear_tolerance ) << "Volume Element " << k << " failed xz stress."; + EXPECT_NEAR( std::fabs( sig_xy ) / 1.0e6, 0.0, shear_tolerance ) << "Volume Element " << k << " failed xy stress."; + } + } ); + } +} + +#endif /* GEOS_TEST_FEMCONSISTENCY_FIXTURE_HPP */ diff --git a/src/coreComponents/integrationTests/mechanicTest/testFEMConsistency_mpi.cpp b/src/coreComponents/integrationTests/mechanicTest/testFEMConsistency_mpi.cpp new file mode 100644 index 00000000000..c59ada83302 --- /dev/null +++ b/src/coreComponents/integrationTests/mechanicTest/testFEMConsistency_mpi.cpp @@ -0,0 +1,87 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 + * ------------------------------------------------------------------------------------------------------------ + */ + +/** + * @file testFEMConsistency_mpi.cpp + * + * MPI (multi-rank) variant of the FEM consistency test. + * Test fixture and TEST_P body live in testFEMConsistencyFixture.hpp. + */ + +#include "testFEMConsistencyFixture.hpp" + +CommandLineOptions g_commandLineOptions; + +/** + * @brief Parallel execution test cases (4 MPI ranks). + * + * The parameters are: + * 1. Mesh file name (std::string): The VTK mesh file containing the geometry and fractures. + * 2. s_xx (real64): Applied stress component XX. + * 3. s_yy (real64): Applied stress component YY. + * 4. s_zz (real64): Applied stress component ZZ. + * 5. Partitioning (tuple): Number of partitions in x, y, z directions. + * + * The test cases cover a subset of meshes with various partitioning schemes for 4 ranks. + */ +INSTANTIATE_TEST_SUITE_P( + FractureStressCasesPartitioned, + ConsistencyTest, + ::testing::Combine( + ::testing::Values( + // Flat hex meshes - single and triple fracture only + "fractured_mesh_hex_DFN_1.vtu", + "fractured_mesh_hex_DFN_123.vtu", + + // Wavy hex meshes - single and triple fracture only + "fractured_wavy_mesh_hex_DFN_1.vtu", + "fractured_wavy_mesh_hex_DFN_123.vtu", + + // Full span hex meshes - single and triple fracture only + "fractured_full_span_mesh_hex_DFN_1.vtu", + "fractured_full_span_mesh_hex_DFN_123.vtu", + + // Full span tet meshes - single and triple fracture only + "fractured_full_span_mesh_tet_DFN_1.vtu", + "fractured_full_span_mesh_tet_DFN_123.vtu", + + // T-shaped wavy meshes + "t_shaped_wavy_mesh_hex_DFN_t1t2.vtu", + "t_shaped_wavy_mesh_tet_DFN_t1t2.vtu", + + // Y-shaped wavy meshes + "y_shaped_wavy_mesh_hex_DFN_y1y2y3.vtu", + "y_shaped_wavy_mesh_tet_DFN_y1y2y3.vtu", + + // 5-fracture DFN market meshes + "DFN_5_fractures_hex_binarized.vtu", + "DFN_5_fractures_tet_binarized.vtu" + ), + ::testing::Values( -1.0e6 ), // s_xx + ::testing::Values( -0.5e6 ), // s_yy + ::testing::Values( -2.0e6 ), // s_zz + ::testing::Values( + std::make_tuple( 2, 2, 1 ), + std::make_tuple( 4, 1, 1 ) + ) + ) + ); + +int main( int argc, char * argv[] ) +{ + ::testing::InitGoogleTest( &argc, argv ); + g_commandLineOptions = *geos::basicSetup( argc, argv, false ); + int result = RUN_ALL_TESTS(); + geos::basicCleanup(); + return result; +} diff --git a/src/coreComponents/integrationTests/meshTests/CMakeLists.txt b/src/coreComponents/integrationTests/meshTests/CMakeLists.txt index 34ef3b4915d..68ccad22fd0 100644 --- a/src/coreComponents/integrationTests/meshTests/CMakeLists.txt +++ b/src/coreComponents/integrationTests/meshTests/CMakeLists.txt @@ -2,7 +2,8 @@ set( gtest_geosx_tests testMeshGeneration.cpp testNeighborCommunicator.cpp - testElementRegions.cpp ) + testElementRegions.cpp + testSurfaceGenerator.cpp ) set( gtest_geosx_mpi_tests testNeighborCommunicator.cpp ) @@ -26,6 +27,88 @@ set( dependencyList mainInterface ) geos_decorate_link_dependencies( LIST decoratedDependencies DEPENDENCIES ${dependencyList} ) +# --------------------------------------------------------------------------- +# Mesh files needed by testSurfaceGenerator +# --------------------------------------------------------------------------- +# DFN-market meshes: one file per fracture combination, covering flat / wavy +# and no-boundary-cut / full-span variants for both hex and tet grids. +set( dfn_market_mesh_files + # ---- flat, no-boundary-cut, hex ---- + fractured_mesh_hex_DFN_1.vtu + fractured_mesh_hex_DFN_2.vtu + fractured_mesh_hex_DFN_3.vtu + fractured_mesh_hex_DFN_12.vtu + fractured_mesh_hex_DFN_13.vtu + fractured_mesh_hex_DFN_23.vtu + fractured_mesh_hex_DFN_123.vtu + # ---- flat, no-boundary-cut, tet ---- + fractured_mesh_tet_DFN_1.vtu + fractured_mesh_tet_DFN_2.vtu + fractured_mesh_tet_DFN_3.vtu + fractured_mesh_tet_DFN_12.vtu + fractured_mesh_tet_DFN_13.vtu + fractured_mesh_tet_DFN_23.vtu + fractured_mesh_tet_DFN_123.vtu + # ---- flat, full-span, hex ---- + fractured_full_span_mesh_hex_DFN_1.vtu + fractured_full_span_mesh_hex_DFN_2.vtu + fractured_full_span_mesh_hex_DFN_3.vtu + fractured_full_span_mesh_hex_DFN_12.vtu + fractured_full_span_mesh_hex_DFN_13.vtu + fractured_full_span_mesh_hex_DFN_23.vtu + fractured_full_span_mesh_hex_DFN_123.vtu + # ---- flat, full-span, tet ---- + fractured_full_span_mesh_tet_DFN_1.vtu + fractured_full_span_mesh_tet_DFN_2.vtu + fractured_full_span_mesh_tet_DFN_3.vtu + fractured_full_span_mesh_tet_DFN_12.vtu + fractured_full_span_mesh_tet_DFN_13.vtu + fractured_full_span_mesh_tet_DFN_23.vtu + fractured_full_span_mesh_tet_DFN_123.vtu + # ---- wavy, no-boundary-cut, hex ---- + fractured_wavy_mesh_hex_DFN_1.vtu + fractured_wavy_mesh_hex_DFN_2.vtu + fractured_wavy_mesh_hex_DFN_3.vtu + fractured_wavy_mesh_hex_DFN_12.vtu + fractured_wavy_mesh_hex_DFN_13.vtu + fractured_wavy_mesh_hex_DFN_23.vtu + fractured_wavy_mesh_hex_DFN_123.vtu + # ---- wavy, no-boundary-cut, tet ---- + fractured_wavy_mesh_tet_DFN_1.vtu + fractured_wavy_mesh_tet_DFN_2.vtu + fractured_wavy_mesh_tet_DFN_3.vtu + fractured_wavy_mesh_tet_DFN_12.vtu + fractured_wavy_mesh_tet_DFN_13.vtu + fractured_wavy_mesh_tet_DFN_23.vtu + fractured_wavy_mesh_tet_DFN_123.vtu + # ---- wavy, full-span, hex ---- + fractured_wavy_full_span_mesh_hex_DFN_1.vtu + fractured_wavy_full_span_mesh_hex_DFN_2.vtu + fractured_wavy_full_span_mesh_hex_DFN_3.vtu + fractured_wavy_full_span_mesh_hex_DFN_12.vtu + fractured_wavy_full_span_mesh_hex_DFN_13.vtu + fractured_wavy_full_span_mesh_hex_DFN_23.vtu + fractured_wavy_full_span_mesh_hex_DFN_123.vtu + # ---- wavy, full-span, tet ---- + fractured_wavy_full_span_mesh_tet_DFN_1.vtu + fractured_wavy_full_span_mesh_tet_DFN_2.vtu + fractured_wavy_full_span_mesh_tet_DFN_3.vtu + fractured_wavy_full_span_mesh_tet_DFN_12.vtu + fractured_wavy_full_span_mesh_tet_DFN_13.vtu + fractured_wavy_full_span_mesh_tet_DFN_23.vtu + fractured_wavy_full_span_mesh_tet_DFN_123.vtu + # ---- T-shaped junction, boundary-cutting, hex & tet ---- + t_shaped_wavy_mesh_hex_DFN_t1t2.vtu + t_shaped_wavy_mesh_tet_DFN_t1t2.vtu + # ---- Y-shaped junction, boundary-cutting, hex & tet ---- + y_shaped_wavy_mesh_hex_DFN_y1y2y3.vtu + y_shaped_wavy_mesh_tet_DFN_y1y2y3.vtu + # ---- miscellaneous, no-boundary-cut, 5 fractures, hex & tet ---- + DFN_5_fractures_hex_binarized.vtu + DFN_5_fractures_tet_binarized.vtu +) +set( DFN_MARKET_MESH_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/dfn_market ) + # Add gtest C++ based tests foreach( test ${gtest_geosx_tests} ) @@ -35,11 +118,33 @@ foreach( test ${gtest_geosx_tests} ) OUTPUT_DIR ${TEST_OUTPUT_DIRECTORY} DEPENDS_ON ${decoratedDependencies} ${tplDependencyList} ) + # Add compile definition for TEST_BINARY_DIR. + # The escaped quotes ensure the path is always a quoted string literal + # regardless of the CMake generator (Makefiles, Ninja, Xcode, etc.). + target_compile_definitions( ${test_name} PRIVATE TEST_BINARY_DIR=\"$\" ) + geos_add_test( NAME ${test_name} - COMMAND ${test_name} ${CMAKE_CURRENT_LIST_DIR} ) + COMMAND ${test_name} ) + + set_tests_properties( ${test_name} PROPERTIES + ENVIRONMENT "TEST_BINARY_DIR=$" + LABELS "${test_name}" ) endforeach() -if( ENABLE_MPI ) +# --------------------------------------------------------------------------- +# Copy DFN-market mesh files into the test output directory at configure time. +# These are static assets committed to the repository, so a one-time copy is +# sufficient and avoids the race condition that arises with Ninja when +# multiple POST_BUILD commands from different targets write the same files +# to the same directory in parallel. +# --------------------------------------------------------------------------- +file( MAKE_DIRECTORY ${TEST_OUTPUT_DIRECTORY} ) +foreach( mesh_file ${dfn_market_mesh_files} ) + file( COPY ${DFN_MARKET_MESH_SOURCE_DIR}/${mesh_file} + DESTINATION ${TEST_OUTPUT_DIRECTORY} ) +endforeach() + +if( ENABLE_MPI AND NOT ENABLE_CUDA AND NOT ENABLE_HIP ) set( nranks 2 ) @@ -55,4 +160,32 @@ if( ENABLE_MPI ) COMMAND ${test_name} -x ${nranks} NUM_MPI_TASKS ${nranks} ) endforeach() + + # --------------------------------------------------------------------------- + # testSurfaceGenerator_mpi — SurfaceGeneratorMpiTest suite (4 MPI ranks) + # + # Now built from its own source file (testSurfaceGenerator_mpi.cpp). + # --------------------------------------------------------------------------- + set( sg_mpi_nranks 4 ) + set( sg_mpi_test_name testSurfaceGenerator_mpi ) + + blt_add_executable( NAME ${sg_mpi_test_name} + SOURCES testSurfaceGenerator_mpi.cpp + OUTPUT_DIR ${TEST_OUTPUT_DIRECTORY} + DEPENDS_ON ${decoratedDependencies} ${tplDependencyList} ) + + target_compile_definitions( ${sg_mpi_test_name} + PRIVATE TEST_BINARY_DIR=\"$\" ) + + geos_add_test( NAME ${sg_mpi_test_name} + COMMAND ${sg_mpi_test_name} + NUM_MPI_TASKS ${sg_mpi_nranks} ) + + set_tests_properties( ${sg_mpi_test_name} + PROPERTIES + ENVIRONMENT "TEST_BINARY_DIR=$" + LABELS "${sg_mpi_test_name}" ) + + # DFN-market mesh files are already copied at configure time (see above). + endif() diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/DFN_5_fractures_hex_binarized.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/DFN_5_fractures_hex_binarized.vtu new file mode 100644 index 00000000000..55fa4c5d624 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/DFN_5_fractures_hex_binarized.vtu @@ -0,0 +1,53 @@ + + + + + + + AQAAAACAAACYKQAARQAAAA==eJzt0kENwDAAxLCOP+l9Jx2BpbIB5JVzAADu8Ogmu/BV+1cXVu1fXVi1f3Vh1f7VhVX7VxdW7V9dWLV/dQH+5QUa5QAp + + + AQAAAACAAACYKQAAMgAAAA==eJzt0zENAAAIBDHwbxoRDPBJu5yCqwIAAMjSywL3fAz5fAz5fAz5fAwAAPDTAHdlACk= + + + AQAAAACAAACYKQAAOQAAAA==eJzt08EJACAQwLBz/6WdQRCkknw6QWcA+NG6VOAdH0Ofj6HPx9DnY+jzMfT5GPp8DABwZgNz0gBJ + + + AQAAAACAAACYKQAALAAAAA==eJztzLEJAAAIBLF3/6UdQcFKSJrrLgEAAAC+q2N9fTdfAAAAAABg1opDADk= + + + AQAAAACAAACYKQAALAAAAA==eJztzKENAAAMw7Du/6f3wqSSAZuEJQEAAAAAAFpT1tf38gUAAAD+W+KlADk= + + + + + AQAAAACAAABAHwAASQAAAA==eJztzCkOACAQwEDu/z8ZgdsEAw6mpm5yWuXDt/BTh8fj8Xg8Ho/H473vlcv3cB6Px+P94dXLj3Aej8fj8Xg8Ho/H23kTaW8KKQ== + + + + + AQAAAACAAADIfAAA0zAAAA==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 + + + 0 + + + 1.7320508076 + + + + + + + AgAAAACAAAAAegAARBEAAIYQAAA=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 + + + AQAAAACAAABAHwAA7AQAAA==eJw12RsDtQCiBdAz72buPJp3d55hGIZhGIZhGIbhwTAMwzAMw4NhGIbhwFnflvUb9t7B65uQEWMmTJkxZ8GSFWs2bNmx55sDR06cuXDlxp0fHjx58ebD10++BAwZMWbClBlzFixZsWbDlh17vjlw5MSZC1du3PnhwZMXbz58/fRLwJARYyZMmTFnwZIVazZs2bHnmwNHTpy5cOXGnR8ePHnx5sPXz74EDBkxZsKUGXMWLFmxZsOWHXu+OXDkxJkLV27c+eHBkxdvPnz9/EvAkBFjJkyZMWfBkhVrNmzZseebA0dOnLlw5cadHx48efHmw9cvvgQMGTFmwpQZcxYsWbFmw5Yde745cOTEmQtXbtz54cGTF28+fP3yS8CQEWMmTJkxZ8GSFWs2bNmx55sDR06cuXDlxp0fHjx58ebD16++BAwZMWbClBlzFixZsWbDlh17vjlw5MSZC1du3PnhwZMXbz58BWDIiDETpsyYs2DJijUbtuzY882BIyfOXLhy484PD568ePPh69dfAoaMGDNhyow5C5asWLNhy4493xw4cuLMhSs37vzw4MmLNx++fvMlYMiIMROmzJizYMmKNRu27NjzzYEjJ85cuHLjzg8Pnrx48+Hr/74EDBkxZsKUGXMWLFmxZsOWHXu+OXDkxJkLV27c+eHBkxdvPnz99kvAkBFjJkyZMWfBkhVrNmzZseebA0dOnLlw5cadHx48efHmw9fvvgQMGTFmwpQZcxYsWbFmw5Yde745cOTEmQtXbtz54cGTF28+fP3+S8CQEWMmTJkxZ8GSFWs2bNmx55sDR06cuXDlxp0fHjx58ebD1x++BAwZMWbClBlzFixZsWbDlh17vjlw5MSZC1du3PnhwZMXbz78UfgDhowYM2HKjDkLlqxYs2HLjj3fHDhy4syFKzfu/PDgyYs3nx9Dxx+/BAwZMWbClBlzFixZsWbDlh17vjlw5MSZC1du3PnhwZMXbz58/elLwJARYyZMmTFnwZIVazZs2bHnmwNHTpy5cOXGnR8ePHnx5sPXn78EDBkxZsKUGXMWLFmxZsOWHXu+OXDkxJkLV27c+eHBkxdvPnz95UvAkBFjJkyZMWfBkhVrNmzZseebA0dOnLlw5cadHx48efHmw9dfvwQMGTFmwpQZcxYsWbFmw5Yde745cOTEmQtXbtz54cGTF28+fP3tS8CQEWMmTJkxZ8GSFWs2bNmx55sDR06cuXDlxp0fHjx58ebD19+/BAwZMWbClBlzFixZsWbDlh17vjlw5MSZC1du3PnhwZMXbz78MfQHDBkxZsKUGXMWLFmxZsOWHXu+OXDkxJkLV27c+eHBkxdvPj8Ojv//EjBkxJgJU2bMWbBkxZoNW3bs+ebAkRNnLly5ceeHB09evPnw9Y8vAUNGjJkwZcacBUtWrNmwZceebw4cOXHmwpUbd3548OTFmw9f//wSMGTEmAlTZsxZsGTFmg1bduz55sCRE2cuXLlx54cHT168+fD1ry8BQ0aMmTBlxpwFS1as2bBlx55vDhw5cebClRt3fnjw5MWbD1///hIwZMSYCVNmzFmwZMWaDVt27PnmwJETZy5cuXHnhwdPXrz58PWfLwFDRoyZMGXGnAVLVqzZsGXHnm8OHDlx5sKVG3d+ePDkxZsPX//9EjBkxJgJU2bM+T8Kyxz2 + + + AQAAAACAAADoAwAAEQAAAA==eJzj4RkFo2AUDHcAAK4tLuE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/DFN_5_fractures_tet_binarized.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/DFN_5_fractures_tet_binarized.vtu new file mode 100644 index 00000000000..3f0f132e284 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/DFN_5_fractures_tet_binarized.vtu @@ -0,0 +1,53 @@ + + + + + + + AQAAAACAAACYKQAARQAAAA==eJzt0kENwDAAxLCOP+l9Jx2BpbIB5JVzAADu8Ogmu/BV+1cXVu1fXVi1f3Vh1f7VhVX7VxdW7V9dWLV/dQH+5QUa5QAp + + + AQAAAACAAACYKQAAMgAAAA==eJzt0zENAAAIBDHwbxoRDPBJu5yCqwIAAMjSywL3fAz5fAz5fAz5fAwAAPDTAHdlACk= + + + AQAAAACAAACYKQAAOQAAAA==eJzt08EJACAQwLBz/6WdQRCkknw6QWcA+NG6VOAdH0Ofj6HPx9DnY+jzMfT5GPp8DABwZgNz0gBJ + + + AQAAAACAAACYKQAALAAAAA==eJztzLEJAAAIBLF3/6UdQcFKSJrrLgEAAAC+q2N9fTdfAAAAAABg1opDADk= + + + AQAAAACAAACYKQAALAAAAA==eJztzKENAAAMw7Du/6f3wqSSAZuEJQEAAAAAAFpT1tf38gUAAAD+W+KlADk= + + + + + AgAAAACAAABAHAAA+AAAAFYAAAA=eJzt0TEOwkAQBEEMhv8/mYAXYK90fVJtUvFsH4/fHbzkOezqPburR0s9WurRUo+WerTUo6UeLfVoqUdLPVrq0VKPlnq01KOlHi31aKlHSz1a6tFSj5Z6tNSjpR4t9WipR0s9WurRUo+WerTUo6UeLfVoqUdLPVrq0VKPlnq01KPldI8nb/kedvWe3dWjpR4t9WipR0s9WurRUo+WerTUo6UeLfVoqUdLPVrq0VKPlnq01KOlHi2ne7x4y8+wq/fsrh4t9WipR0s9WurRUo+WerTUo6UeLfVoqUdLPVrq0VKPlnq01KOlHi31aKlHSz1a/vvvL2ZZJgl4nO3RsQqAMBAFQUHI/3+yReo0RsgKc83U93Zc88bCm1uudn3r6X/+rh4t9WipR0s9WurRUo+WerTUo6UeLfVoqUdLPVrq0VKPlnq01KPl1z0epz0MwQ== + + + + + AQAAAACAAADIfAAA0zAAAA==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 + + + 0 + + + 1.7320508076 + + + + + + + BQAAAACAAAAAcQAA2Q8AAAYQAAACEAAAAxAAAE4OAAA=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 + + + AgAAAACAAABAHAAADRUAANkEAAA=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 + + + AQAAAACAAACIEwAAHAAAAA==eJztwSEBAAAAwyC//oGf4g4oAAAAAOBtPjzDUQ== + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_1.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_1.vtu new file mode 100644 index 00000000000..683c3cf22ba --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_1.vtu @@ -0,0 +1,38 @@ + + + + + + + AQAAAACAAADYAAAAEgAAAA==eJxjYIAARgbsYKiKAwAEyAAK + + + + + + + AQAAAACAAACIAgAATwAAAA==eJyF0cENACAIQ1E2c/8tHIERPHFBn3Ah/tjQQsSv9nrzBJeu3p0nuObUv84TXL7kT/OkV++5ptzS9VzTnjRH+6qafMvHdAfp734AQnk+Ow== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_12.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_12.vtu new file mode 100644 index 00000000000..031585cec17 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_12.vtu @@ -0,0 +1,41 @@ + + + + + + + AQAAAACAAADYAAAAEgAAAA==eJxjYIAARgbsYKiKAwAEyAAK + + + AQAAAACAAADYAAAAEwAAAA==eJxjYMAOGHHQpIKBMgcABMgACg== + + + + + + + AQAAAACAAACIAgAATwAAAA==eJyF0cENACAIQ1E2c/8tHIERPHFBn3Ah/tjQQsSv9nrzBJeu3p0nuObUv84TXL7kT/OkV++5ptzS9VzTnjRH+6qafMvHdAfp734AQnk+Ow== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_123.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_123.vtu new file mode 100644 index 00000000000..efac4e2d7b2 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_123.vtu @@ -0,0 +1,44 @@ + + + + + + + AQAAAACAAADYAAAAEgAAAA==eJxjYIAARgbsYKiKAwAEyAAK + + + AQAAAACAAADYAAAAEwAAAA==eJxjYMAOGHHQpIKBMgcABMgACg== + + + AQAAAACAAADYAAAAEQAAAA==eJxjYKAOYKQSTS0AAATIAAo= + + + + + + + AQAAAACAAACIAgAATwAAAA==eJyF0cENACAIQ1E2c/8tHIERPHFBn3Ah/tjQQsSv9nrzBJeu3p0nuObUv84TXL7kT/OkV++5ptzS9VzTnjRH+6qafMvHdAfp734AQnk+Ow== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_13.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_13.vtu new file mode 100644 index 00000000000..41fbb61830b --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_13.vtu @@ -0,0 +1,41 @@ + + + + + + + AQAAAACAAADYAAAAEgAAAA==eJxjYIAARgbsYKiKAwAEyAAK + + + AQAAAACAAADYAAAAEQAAAA==eJxjYKAOYKQSTS0AAATIAAo= + + + + + + + AQAAAACAAACIAgAATwAAAA==eJyF0cENACAIQ1E2c/8tHIERPHFBn3Ah/tjQQsSv9nrzBJeu3p0nuObUv84TXL7kT/OkV++5ptzS9VzTnjRH+6qafMvHdAfp734AQnk+Ow== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_2.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_2.vtu new file mode 100644 index 00000000000..c6773412ec4 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_2.vtu @@ -0,0 +1,38 @@ + + + + + + + AQAAAACAAADYAAAAEwAAAA==eJxjYMAOGHHQpIKBMgcABMgACg== + + + + + + + AQAAAACAAACIAgAATwAAAA==eJyF0cENACAIQ1E2c/8tHIERPHFBn3Ah/tjQQsSv9nrzBJeu3p0nuObUv84TXL7kT/OkV++5ptzS9VzTnjRH+6qafMvHdAfp734AQnk+Ow== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_23.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_23.vtu new file mode 100644 index 00000000000..26a4bbbc056 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_23.vtu @@ -0,0 +1,41 @@ + + + + + + + AQAAAACAAADYAAAAEwAAAA==eJxjYMAOGHHQpIKBMgcABMgACg== + + + AQAAAACAAADYAAAAEQAAAA==eJxjYKAOYKQSTS0AAATIAAo= + + + + + + + AQAAAACAAACIAgAATwAAAA==eJyF0cENACAIQ1E2c/8tHIERPHFBn3Ah/tjQQsSv9nrzBJeu3p0nuObUv84TXL7kT/OkV++5ptzS9VzTnjRH+6qafMvHdAfp734AQnk+Ow== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_3.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_3.vtu new file mode 100644 index 00000000000..3dddbd3fa02 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_hex_DFN_3.vtu @@ -0,0 +1,38 @@ + + + + + + + AQAAAACAAADYAAAAEQAAAA==eJxjYKAOYKQSTS0AAATIAAo= + + + + + + + AQAAAACAAACIAgAATwAAAA==eJyF0cENACAIQ1E2c/8tHIERPHFBn3Ah/tjQQsSv9nrzBJeu3p0nuObUv84TXL7kT/OkV++5ptzS9VzTnjRH+6qafMvHdAfp734AQnk+Ow== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_1.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_1.vtu new file mode 100644 index 00000000000..9a15a89850a --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_1.vtu @@ -0,0 +1,47 @@ + + + + + + + AQAAAACAAADwBAAAEwEAAA==eJwtxdciEAAAAEBKiTKSVMrehCYlZc/s7LLaVFIUyqhoUAmJRP/qwd3LBQTsC/QBH3SQD/mwg33EIQ71UR9zmMMd4Ugfd5RPONonHeNTPu0zjvVZn3Oc453gRCc52SlOdZrTneFMZznbOT7vXOc53xd80Zd82Vd81QUu9DVfd5FvuNg3fcslLnWZy13hSle52jWudZ3rfdsNbnSTm93iVrf5jtvd4U53uds97vVd33Of+z3gQQ/5vh/4oR/5sZ/4qYc94md+7hce9UuP+ZVfe9wTfuO3nvSUp/3O7z3jWc953h/80Z+84EV/9hd/9Tcvednf/cM/veJfXvWa1/3bG/7jTW/5r7f9zzve9X/vAUgYMHQ= + + + AQAAAACAAADwBAAAIAAAAA==eJxjZIAARhw0pQCXudSiRzqgdfiOhvsoGE4AAHm4ACA= + + + + + AQAAAACAAABsBwAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpHMc0wAO4uAdw= + + + AQAAAACAAADYDgAA+QIAAA==eJwtxVOAEAYAANDrckNc85a1bF6Xbdu2fdm2bdu2bdu+7H303s9LHvBdCqd0Kqd2Gqd1Oqd3Bmd0Jmd2Fmd1Nmd3Dgc5p4Ody7mdx3mdz/ldwAVdyIVdxEVdzMVdwiVdyqVdxmVdzuVdwRVdyZVdxVVdzdVdwzVdy7Vdx3Vdz/XdwA3dyI3dxE3dzM3dwi3dyq3dxm3dzu3dwR3dyZ3dxV3dzSHu7h7u6V7u7T7u637u7wEe6EEe7CEe6mEe7hEe6VEe7TEe63Ee7wme6Eme7Cme6mme7hme6Vme7Tme63me7wVe6EVe7CVe6mVe7hVe6VVe7TVe63Ve7w3e6E3e7C3e6m3e7h3e6V3e7T3e633e7wM+6EM+7CM+6mM+7hM+6VM+7TM+63M+7wu+6Eu+7Cu+6mu+7hu+6Vu+7Tu+63u+7wd+6Ed+7Cd+6md+7hd+6VC/8mu/8Vu/83t/8Ed/8md/8Vd/c0AYOdBhHc7hHcERHcmRHcU/+Ef/5J8d1dEc3TEc07H8i2P7V//m3/2H//Rf/tv/+F/HcVzHc3wncEIncmIncVIn839O7hRO6VRO7TRO63RO7wzO6EzO7CzO6mzO7hwOck4HO5dzO4/zOp/zu4ALupALu4iLupiLu4RLupRLu4zLupzLu4IrupIru4qrupqru4ZrupZru47rup7ru4EbupEbu4mbupmbu4VbupVbu43bup3bu4M7upM7u4u7uptD3N093NO93Nt93Nf93N8DPNCDPNhDPNTDPNwjPNKjPNpjPNbjPN4TPNGTPNlTPNXTPN0zPNOzPNtzPNfzPN8LvNCLvNhLvNTLvNwrvNKrvNprvNbrvN4bvNGbvNlbvNXbvN07vNO7vNt7vNf7vN8HfNCHfNhHfNTHfNwnfNKnfNpnfNbnfN4XfNGXfNlXfNXXfN03fNO3fNt3fNf3fN8P/NCP/NhP/NTP/Nwv/NKhfuXXfuO3fuf3/uCP/uTP/uKv/uaAwO+FcaDDOpzDO4L/B4ug/HI= + + + + + AQAAAACAAADQDgAApAUAAA==eJy1lW1QE1cUhpdBtCgtKAqi0KlKKaL1ozoVlXJARSuIVQSlihUpWhGoOKNGnVKmtohOoGMrVUQJCBYElYKiI4hgg4BAJAlgCFBNJAE2fMgOgsiHWlpz7w6Xjak/ev9k9sm957z3PWfPUtQ/SwkU50KcgTdz9EvGIc/p47r2kfv1Pevbpy+urntJdPhA3hs903p8kwA3J+MyRDwyvr5zpH5d9SLjk7pJTvqhj+vqM9InUid5nuSkD2iRPpNcV7/q0kOut70PuXTpIu+vi+vKR8Yj872tr2R80qf/y3d9fuiaQ6QufT7+13i64irhydwx7jfnlcOUWcWfbl1Ti7msXeO2fYJG+yzHvHdG+w6vXhWc4fefFC/WYH4iLMzb00wOFrRV9kInDaFLCZfqqvlC20b8HDS40jjoEw2Ejz1r/bOLGvOWEKeXF1OVYHjX0Tz9UhXm0XY+EdJVlTDR+oI6e6kK8ylt3fn0+GaYF/zYdTC5hMgrh8vPfI5FK4sIHa2Qof1F3PtMlqQnpHQET3Lbw6MrSmBvyM4FZjvY+F7pSwqzj8ohn39LlbypHnOBIKjzF+82UHjYbttlgPJSlOhzngPPswy+TO8tfT4owzwyYersRYUqCCy2VapVIszP9XlaVmSpoM+52c7aRYO5xijPKH+MHKJfTU855cRyp8b6u3n3FcArfDZ7kYkK83j/0KcTkmgYlSoJCApguW9OlcKpXwYVaXZXrVvvYc5Mig+OPScCw9CEj9aGsPvdc+r228xvhXFZPbfWxddiPvGoxiGuXQVtXl8vrrzQgHkGp89DebU+I78R5/afokw9EldaDOUtqT7SlLqU3d/37odB9wzq4Q/B+GedcXVw+d9zVfj/10sNq+d750lyRQSXQ6Pm8IoNh9l4sbOsBo7fboXx2buWT9hWg7m9k0wgeHEXAsK6T4WPZuupNj8uNugXwgeZCuVvd9h6OmYU7OP7tcHFNb704RsVxPvDEDrVmJvyhVtly2oga/1Zc7lxMeZIJ9KH+HRt3sXafIjnp7g413wvBOtNRh9XxQgxH66Hwbr8Wh4kW6ZICa7GehBHuh4lzDnU4FqKeU+Yu2/cnVYQl0Yu/PM7GeZjbtlER7i2YT2II13c/lAUtz9DfcDpD0Vx+0NR3P5QFLc/FOVgbpEn6Gge0T/D5yBacjiY97409lET5kjXMbfHc4KntY7oq077E6bXE9n7IF1mtXsYd39WH9I1XA977srT3VK+lB7hG8pL+sBL83h0QNIEqI8Rb1Yti/d3boMWbR8jjnSSvr1eDLTnulnO9KiAjoYfBJ6etbiuuR0bJzk3tECRqmtnZYYK81fl5ZYrXqggpcD2iz2GbP+VJUWJNo6Vw3mrxKyYBg3m0vp6T2dHObzc65x7yKcM8/C0RuPQFAU8V80d5/9rA+ZOjVuuJKarQD7D37Gnh42zT/ZN4vXpEjB+cDqw+ndWT8Tm4KgBUw3kSFcXrCti9T/pqq34rFgB9bHVBQ8H2Pey3O/202LPVogy4OXeyWXfP+45xuDviy/ByfnGXV8GuOvLAHd9GeCuLwPc9WWAu74MoYedD8P1sPNheJ+z8wHpQRzNB6QH8dHa+TD8vWDnQ1JEbMKNATH0i9enB91QgElRz/YffVogdckCi7BjEpjsUDwza+i7fz4/htdcogQXAZW2+y8x2HS6hgZOqYFlk94TRfVWw7fCGJmZuQQOjL55zWoODYFzM8278yUwY5TojM0CCWRuudpttL8Sgra8U2+8lgb+TwcNjgRIoM8rZ39HNA0PB8s3bYikIcOdEp6cSkOcYVN7sj0N90tMll4YS8PmLkmZcVcLJD+saQ/niSF0cuzpB5vFsKKOuRZjRwPtc83kUHgtrMqYRkdeagK/Qvtxz01p+Cpz3c6Ny5uH6jm7KGdtNfwNSuMPIQ== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAABgOwAA7wkAAA==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 + + + AQAAAACAAADYDgAAqQIAAA==eJwtxRGAKgYAANC2tS0IgiAIgiAIgiAIgiAIgiAIgiAIgoODIAiCIAiCIAiC4OAgCIIgCIIgCIIgCIIgCD70nrxg4CPksCOOOua4E0465bQzzjrnvAsuuuSyK6665robbrrltjv+8re77rnvgYceeeyJp5557oWX/vGvV15746133vvgo08+++Krb7774adffjvw16egQw474qhjjjvhpFNOO+Osc8674KJLLrviqmuuu+GmW2674y9/u+ue+x546JHHnnjqmedeeOkf/3rltTfeeue9Dz765LMvvvrmux9++uW3A39/CjrksCOOOua4E0465bQzzjrnvAsuuuSyK6665robbrrltjv+8re77rnvgYceeeyJp5557oWX/vGvV15746133vvgo08+++Krb7774adffjvwz6egQw474qhjjjvhpFNOO+Osc8674KJLLrviqmuuu+GmW2674y9/u+ue+x546JHHnnjqmedeeOkf/3rltTfeeue9Dz765LMvvvrmux9++uW3A0E55LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY7/vK3u+6574GHHnnsiaeeee6Fl/7xr1dee+Otd9774KNPPvviq2++++GnX3478O+noEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltuu+Mvf7vrnvseeOiRx5546pnnXnjpH/965bU33nrnvQ8++uSzL7765rsffvrltwP/fQo65LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY7/vK3u+6574GHHnnsiaeeee6Fl/7xr1dee+Otd9774KNPPvviq2++++GnX3478P+noEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltu+w82teht + + + AQAAAACAAADbAQAADgAAAA==eJzj4hoFwxQAAELeEo8= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_12.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_12.vtu new file mode 100644 index 00000000000..314510490d4 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_12.vtu @@ -0,0 +1,50 @@ + + + + + + + AQAAAACAAACoBQAAPgEAAA==eJwtxdciEAAAAECpNIxSqShaGpT2IIkG7UEZRVMSTQlRlFJRpElDEoqQQh/owd3LBQRMmORAT/YUT3WQp3m6Z3imgx3iUId5lmc73HM81/Mc4fle4IWOdJQXebGjHeMlXuplXu4VjvVKr/Jqr3Gc473W65zg9d7gjd7kzd7ird7m7d7hRCd5p5O9yyne7VSneY/3ep/3O90ZPuCDPuTDPuKjPubjPuGTznSWT/m0s53jXOf5jM863wU+5/O+4Iu+5Msu9BUX+aqLfc0lLvV13/BN3/Jt33GZ77rc91zhSlf5vqtd4wd+6FrX+ZEfu95P/NQNfubnfuFGN/mlX7nZLX7tVr/xW7/ze3/wR7e53Z/82V/81R3+5k5/d5d/uNs97vVP/3Kf+/3bAx70kP942H/9zyMe9Zj/exyv0D+j + + + AQAAAACAAACoBQAALgAAAA==eJxjYMAPGAnQhNQPFEC3n5D7SVVPbXcMdHiNNEAoHoZavAw3/4wCVAAAetgAIA== + + + AQAAAACAAACoBQAAMgAAAA==eJxjYIAARjSagUg+IUCufnT3kKqPWPNI9Q+twVB3P7GAkH+Guv+GOhiNn8EFAHyYACA= + + + + + AQAAAACAAAAACQAAGwAAAA==eJztwwENAAAMw6DOv+kLOSSsmqrqowcuFgJB + + + AQAAAACAAAAAEgAAiwMAAA==eJwtxUMAEAYAAMC4bNu2bdu2bdu2bdu2bdvGll17dPe56gH+quGaruXaruO6ruf6buCGbuTGbuKmbubmbuGWbuXWbuO2buf27uCO7uTO7uKu7ubu7uGe7uXe7uO+7uf+HuCBHuTBHuKhHubhHuGRHuXRHuOxHufxnuCJnuTJnuKpnubpnuGZnuXZnuO5nuf5XuCFXuTFXuKlXublXuGVXuXVXuO1Xuf13uCN3uTN3uKt3ubt3uGd3uXd3uO93uf9PuCDPuTDPuKjPubjPuGTPuXTPuOzPufzvuCLvuTLvuKrvubrvuGbvuXbvuO7vuf7fuCHfuTHfuKnfubnfuGXfuXXfuO3/tf/+Z3f+4M/+pM/+4u/+pu/+4d/+pd/+48DBJQDObCDOKj/cTAHdwiHdCiHdhiHdTiHdwRHdCRHdhRHdTRHdwzHdCzHdhzHdTzHdwIndCIndhIndTIndwqndCqndhqndTqndwZndCZndhZndTZndw7ndC7ndh7ndT7ndwEXdCEXdhEXdTEXdwmXdCmXdhmXdTmXdwVXdCVXdhVXdTVXdw3XdC3Xdh3XdT3XdwM3dCM3dhM3dTM3dwu3dCu3dhu3dTu3dwd3dCd3dhd3dTd3dw/3dC/3dh/3dT/39wAP9CAP9hAP9TAP9wiP9CiP9hiP9TiP9wRP9CRP9hRP9TRP9wzP9CzP9hzP9TzP9wIv9CIv9hIv9TIv9wqv9Cqv9hqv9Tqv9wZv9CZv9hZv9TZv9w7v9C7v9h7v9T7v9wEf9CEf9hEf9TEf9wmf9Cmf9hmf9Tmf9wVf9CVf9hVf9TVf9w3f9C3f9h3f9T3f9wM/9CM/9hM/9TM/9wu/9Cu/9hu/9b/+z+/83h/80Z/82V/81d/83T/807/8238cINDfAjqQAzuIg/ofB3Nwh3BIh3Joh3FYh3N4R3BER3JkR3FUR3N0x3BMx3Jsx3Fcx3N8J3BCJ3JiJ3FSJ3Nyp3BKp3Jqp3Fap3N6Z3BGZ3JmZ3FWZ3N253BO53Ju53Fe53N+F3BBF3JhF3FRF3Nxl3BJl3Jpl3FZl3N5V3BFV3JlV3FVV3N113BN13Jt13Fd13N9N3BDN3JjN3FTN3Nzt3BLt3Jrt3Fbt3N7d3BHd3Jnd3FXd3N393BP93Jv93Ff93N/D/BAD/JgD/FQD/Nwj/BIj/Joj/FYj/N4T/BET/JkT/FUT/P/npYfIA== + + + + + AQAAAACAAAD4EAAAdQQAAA==eJyNVWtsFFUUnhbbhkpSSwlKovgIxhYrihpFUE5bIabFgPigJSAPjY/YVAmWV6NAFIx1URBqQYX6AIMxUuEHVRbQsoWWRs3MrstuDaaOuN2ZbotcY2sT3wvOueM9c6/Tk01u7rf3zjnfd745o2myYCDuTfh/3C/wHH0OvU9x+r9fPqao048Pzau6r7qnyq/i51e3aqVh+PTFVuAqXQ2C070qPw1Vn2ySR+UHyovmUfnEVuCq1VDUQ3kMVxd6n9ZDz1GcPtcmOmAMVxeKUz/QPdWdPo/W4+c/ek7Vb4pT3VR1q95HWhe9r+JH7/nNLVtRL82j6hPGcHXEoHlp0D7Rlf7v5zOVrn5zUZXHjQ/vrbLrWr508AT/f6F16v1Ld4edfRfH8wKhh2NlUWi4ftzv9UdTHO/eNWnN6dIOKLwz1tT053GO6x0bbz32XAysgno947cQx4/sLpkeXRuCOz76vDawsI/k6SJ1R531JMFDcJGzIv7H3+m4sh0yL2yjHBd5mpyvyNPk+fMdnogjX+SJOPJFnognHL7IE3Hk+8rrgbbGYCtfxa5QvppWsqN/xdO17bDqvVlbNm2OkvNxEFdN+/jbbwKhCRFyLgHlkx8MGoe+IngXnOmtm/FAXQfHkW/+gSfvHr3YzYd8H1k20Ph8dhvHke9Vzd+bb7TGOD5F6K8Jcr+ZIPebyfsg+s0Eud9M3oeE4DcT5H7TtIkFY4NNZ5Me/+/75alwIGyTejTt5Zk/TKq+OuXx/6q9s7pXGj0e/yd/LHtryfQ+j//PFW7JO/hOQuF/rIMRHyQJHoKM88v6PhFP+/4CvjrFcVF3xvOJujOeP0/wP4P9c98u6Bp5gvifweCyiqodrSnifwY5h6/YtK60j/ifweWVWTdEXg0p+GJQvhiUrxMevhgmyPtrQrO0vybI+2uCvL8mWE5/qd9ofz+tOd1SsyABWyeUp39xojfmcfU+f2rrnh64eVTbTaPa2sXznL+rq8jTnW8iT3e+IU/EkS/yRBz5Ik/EkS/yRFz0M/Wd62v5+85A/n1hivedgfz7wjzvu6gPRgJi/b0zl47u9czD1cHx4YbuHo6j/0Xd3Dkp6qBpmPeS+DOsYonrV/S/3A8Y1A+aJveDEx4/pBVYnrtodmkCcEVd/l1RB1ffyNGMx85UpKCwoDJ4+7s94nl8/n/mjKinO0/EuenOE1E3d56IfnPnSVLwG4NsZ56IOrvzRM4Xg/LVNDlfoiedMx7ebh3y7wVTzBOmmCcM5N8L5pknyc/G5WZep0Ptxub4T3cZUN+du+1EjgHXPr52c2qODmNu+eKewe0G7Cx/85posQ3VG2pWZC3XYd6igV1DuTbsmZ8Z/+DnMHxStDf/1/sNKKouHtow24aywc4n/iqyYU1x/8VzT1lgH9h/44yHdDg3caDltbMWPJv5QnxKxIJp68ZknVyqw/rvLO2lr3WYvL1u2tB4G/QSiLd2WtD46IuR9nQ9R44dr5x6mw3ZOYuNBtOCqrLL7uscYcM//HXzBA== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAASAAAqgsAAA==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 + + + AQAAAACAAAAAEgAANQMAAA==eJw12BG7MogChdEzc5u53ecJgiAIgiAIgiAIgiAIgiAIgiAIguBAEARBEARBEARBEARBEARBEARBEARBEAQHggtnfVvWb9hv4Ot3QYYYZoRRxhhngkmmmGaGWeaYZ4FFllhmhVXWWGeDTbbYZoff7LLHPgcccsQxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3f/jh11+/BBhkiGFGGGWMcSaYZIppZphljnkWWGSJZVZYZY11Nthki212+M0ue+xzwCFHHHPCKWecc8ElV1xzwy133PPAI08888Irb7zzwSdffPOHH379/UuAQYYYZoRRxhhngkmmmGaGWeaYZ4FFllhmhVXWWGeDTbbYZoff7LLHPgcccsQxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3f/jh139+CTDIEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvs8Jtd9tjngEOOOOaEU84454JLrrjmhlvuuOeBR5545oVX3njng0+++OYPP/wKgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaH3+yyxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPLFN3/44dc/vwQYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdvjNLnvsc8AhRxxzwilnnHPBJVdcc8Mtd9zzwCNPPPPCK2+888EnX3zzhx9+/ftLgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaH3+yyxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPLFN3/44dd/fwkwyBDDjDDKGONMMMkU08wwyxzzLLDIEsussMoa62ywyRbb7PCbXfbY54BDjjjmhFPOOOeCS6645oZb7rjngUeeeOaFV95454NPvvjmDz/8c/gDDDLEMCOMMsY4E0wyxTQzzDLHPAssssQyK6yyxjobbLLFNjv8Zpc99jngkCOOOeGUM8654JIrrrnhljvueeCRJ5554ZU33vngky+++cPPn9Dzv1/+D9jnJJk= + + + AQAAAACAAABAAgAADwAAAA==eJzj4hoFo4B8AABe9xaB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_123.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_123.vtu new file mode 100644 index 00000000000..1b5610892ff --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_123.vtu @@ -0,0 +1,53 @@ + + + + + + + AQAAAACAAABIBwAAjQEAAA==eJwtxVNjFgAAAMAvt2XbLdu1bGNLW9aybbeM1eKqLdeyl22by/gZPXT3coHAfymc0qmc2mmc1umc3kEOdgZndCZndhZndTZndw7ndC7ndh7ndT7ndwEXdCEXdhEXdTEXdwmXdIhLubTLuKzLubwruKIrubKruKqrubpruKZrubbruK7rOdT13cAN3ciN3cRN3czN3cIt3cqt3cZt3c7t3cEd3cmd3cVhDndXd3N393BPRzjSvdzbfdzX/dzfAzzQgzzYQxzloR7m4R7hkR7l0R7jsR7n8Z7giZ7kyZ7iqZ7m6Z7hmZ7l2Z7juZ7n+V7ghV7kxV7iaC/1Mi/3Cq/0Kq/2Gq/1Osd4vTc41hu9yZu9xVu9zXHe7h3e6XgneJd3e4/3ep/3+4AP+pATfdhHfNTHfNwnfNKnfNpnfNbnfN5JvuCLvuTLvuKrvubrvuGbvuXbvuO7vuf7fuCHfuTHfuKnfubnfuGXfuXXfuO3fuf3/uCP/uTPTvYXf/U3f/cP//Qv//Yf//U/bxdplQ== + + + AQAAAACAAABIBwAAOAAAAA==eJxjYMAPGAnQhNSTKk/IHdQGpLqTkDuo5W9c9tIqHOhtz1ADpOYDeoNR9w1tMBo+QxsAALvgACY= + + + AQAAAACAAABIBwAARgAAAA==eJxjYEAFjGg0OsAlT4hPLCBkP7nmE6selz/IdQ+1woVYQGq8UWo+rf1DLYDuf2qFB73AUHf/YAfDPXyHu/8GGgAAuHAAJg== + + + AQAAAACAAABIBwAARAAAAA==eJxjYIAARjQaHRCSxwXQ1RMyn5A6QvpIlUdXR64/SQW0Dmdc4rTyF73CjVj7B9o9Qw0M9/Ab7v6jNRgNP/wAALZwACY= + + + + + AQAAAACAAACEDAAAHQAAAA==eJztw0ENAAAMA6Grf9NzsRckrJqqqurTA6hlAyI= + + + AQAAAACAAAAIGQAA3wQAAA==eJwtxTMAGAYAALBytW3btm3btm1utW3btm3btu0dTZ4sDfDXMi/3Cq/0Kq/2Gq/1Oq/3Bm/0Jm/2Fm/1Nm/3Du/0Lu/2Hu/1Pu/3AR/0IR/2ER/1MR/3CZ/0KZ/2GZ/1OZ/3BV/0JV/2FV/1NV/3Dd/0Ld/2Hd/1Pd/3Az/0Iz/2Ez/1Mz/3C7/0K7/2G7/1O7/3B3/0J3/2F3/1N3/3D//0L//2HwcIKAdyYAdxUP/jYA7uEA7pUA7tMA7rcA7vCI7oSI7sKI7qaI7uGI7pWI7tOI7reI7vBE7oRE7sJE7qZE7uFE7pVE7tNE7rdE7vDM7oTM7sLM7qbM7uHM7pXM7tPM7rfM7vAi7oQi7sIi7qYi7uEi7pUi7tMi7rci7vCq7oSq7sKq7qaq7uGq7pWq7tOq7req7vBm7oRm7sJm7qZm7uFm7pVm7tNm7rdm7vDu7oTu7sLu7qbu7uHu7pXu7tPu7rfu7vAR7oQR7sf/2fh3ioh3m4R3ikR3m0x3isx3m8J3iiJ3myp3iqp3m6Z3imZ3m253iu53m+F3ihF3mxl3ipl3m5V3ilV3m113it13m9N3ijN3mzt3irt3m7d3ind3m393iv93m/D/igD/mwj/ioj/m4T/ikT/m0z/isz/m8L/iiL/myr/iqr/m6b/imb/m27/iu7/m+H/ihH/mxn/ipn/m5X/ilX/m13/it3/m9P/ijP/mzv/irv/m7f/inf/m3/zhAoL8FdCAHdhAH9T8O5uAO4ZAO5dAO47AO5/CO4IiO5MiO4qiO5uiO4ZiO5diO47iO5/hO4IRO5MRO4qRO5uRO4ZRO5dRO47RO5/TO4IzO5MzO4qzO5uzO4ZzO5dzO47zO5/wu4IIu5MIu4qIu5uIu4ZIu5dIu47Iu5/Ku4Iqu5Mqu4qqu5uqu4Zqu5dqu47qu5/pu4IZu5MZu4qZu5uZu4ZZu5dZu47Zu5/bu4I7u5M7u4q7u5u7u4Z7u5d7u477u5/4e4IEe5MH+1/95iId6mId7hEd6lEd7jMd6nMd7gid6kid7iqd6mqd7hmd6lmd7jud6nud7gRd6kRd7iZd6mZd7hVd6lVd7jdd6ndd7gzd6kzd7i7d6m7d7h3d6l3d7j/d6n/f7gA/6kA/7iI/6mI/7hE/6lE/7jM/6nM/7gi/6ki/7iq/6mq/7hm/6lm/7ju/6nu/7gR/6kR/7iZ/6mZ/7hV/6lV/7jd/6nd/7gz/6kz/7i7/6m7/7h3/6l3/7jwME/ltAB3JgB3FQ/+NgDu4QDulQDu0wDutwDu8IjuhIjuwojupoju4YjulYju04jut4ju8ETuhETuwkTupkTu4UTulUTu00Tut0Tu8MzuhMzuwszupszu4czulczu08zut8zu8CLuhCLuwiLupiLu4SLulSLu0yLutyLu8KruhKruwqrupqru4arularu06rut6ru8GbuhGbuwmbupmbu4WbulWbu02but2bu8O7uhO7uwu7upu7u4e7ule7u0+7ut+7u8BHuhBHux//Z+HeKiHebhHeKRHebTHeKzHebwneKInebKneKqnebpneKZnebbneK7neb4XeKEXebGXeKmXeblXeKVXebXXeK3Xeb03eKM3ebO3eKu3ebt3eKd3ebf3eK/3eb8P+KAP+bCP+Kj/B0Wmm6M= + + + + + AQAAAACAAADYFQAAZwMAAA==eJy1Vz1oFFEQvkQLkRRCOhWSQsVGEZuAFqNE8BdJJygI/iJILERjQARrIxiDBBEiKrGxUpAIkUBM4DgQ4mEWEjjBJWyOc2PxSgUhbu529mW+fcPtiTsEhjf73sw33/xwKRRaEZ/cZ82unbP6a6Y1MYpfo7xHO97X7rUar5lflP+VB37He2jX8GV9p33X/Gn5l8l91vpGu6+d8T3ew/sYR+vLrN9bzQelpuDW+qamxKsp8YyCE+uMcTFfxKnhwHh4nyVrPA0fC+aDeWq4UdBvWXnfrA5a/q3WAf1r9dbmEvtBm2/0g7i0ODWFH3yn7ZGsuLLi0/JBXFp8rU+0PZf1O8siSc3ixecS2GdoY6zZ8mc1kq4itdfDePTg8dDs6OR08v1gz4Hn718tkPRr4xx6+vP2jVvFxN45de171efzQip+Q08Dbh/8e2BnPzPS3l2UOrJL/HhGvyU6IvD7dOflyeGHjzyIizgQv+VDahbEH0sKP4ufM08s7DcAO/dNNVW/tjV1f0Xao76p2wdDGtlxPPqzdf/QX5noPxcovIS0v2N2X8esxbX2emR82c1XEhf73oD/Etix7w1h38v7yHcAfv2En7qf1U+JXfBjoD4RP/I98u9DnGpi5ziSf1/GSfxb3rEeDQmBL8s71qMg4s3kjBvn1ZB7/9h6y/1jyL1/TBP8LP/e9/K+T+bm5vOnDwfUtXWl99I93CPIv0+7O89M9rxYpolNv68PeEV5P4or+wxxLyq4S27cnA/ijvLJt2+SQMp+wznGeuN+M6n9li/vtq58lnFwvr3EP9tFnHXzIONEmcVxZDyWKsQrFL5OtV1ZOhFCvFg4Tmp/BsAv9r+dG9lHJplf2UcG+saQe/+bBL/sG0Pu/W9SfF0Mlt6+3hskmu1ufnz6WN55rHg0pC277o5tG7P1EHlFGvmWZ5yvkJh3tgj+ce6is3u+DOD1UnwgT9K/5Qn5kOcq8BQmvLCd+XHua6x/Dn2UV12lH8SL+9Pm4cSb2p82j3znlsXk1kdu/Ebh35AbP/hdxx/6dc+XzUPOlyH3fGEeJt88vLmGPvWloUfLNFyvw2d6EuuoOpWJPT/oal9ve9/2eXr26/KGwTdR3IEL42ffzTfeDcb/z3XPNX6HFqyfb/F71Nr3SpPvrP8CNJL+ZA== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAgZAAApw8AAA==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 + + + AQAAAACAAAAIGQAAVAQAAA==eJw12BGDMgoCheG5u+1uezcIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgoGBIAiCIAiCIAiCIAiCIAiCIAiChXm+I89vOG/g63dBhhhmhFHGGGeCSaaYZoZZ5phngUWWWGaFVdZYZ4NNtthmh1322OeAQ4445oTf/OGUM8654JIrrrnhljvueeCRJ5554ZU33vngky+++eHXX78EGGSIYUYYZYxxJphkimlmmGWOeRZYZIllVlhljXU22GSLbXbYZY99DjjkiGNO+M0fTjnjnAsuueKaG265454HHnnimRdeeeOdDz754psffv3jlwCDDDHMCKOMMc4Ek0wxzQyzzDHPAossscwKq6yxzgabbLHNDrvssc8BhxxxzAm/+cMpZ5xzwSVXXHPDLXfc88AjTzzzwitvvPPBJ19888Ovf/4SYJAhhhlhlDHGmWCSKaaZYZY55llgkSWWWWGVNdbZYJMtttlhlz32OeCQI4454Td/OOWMcy645IprbrjljnseeOSJZ1545Y13Pvjki29++BUAgwwxzAijjDHOBJNMMc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAYccccwJv/nDKWecc8ElV1xzwy133PPAI08888Irb7zzwSdffPPDr3/9EmCQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZYZc99jngkCOOOeE3fzjljHMuuOSKa2645Y57HnjkiWdeeOWNdz745Itvfvj1718CDDLEMCOMMsY4E0wyxTQzzDLHPAssssQyK6yyxjobbLLFNjvsssc+BxxyxDEn/OYPp5xxzgWXXHHNDbfccc8DjzzxzAuvvPHOB5988c0Pv/7zS4BBhhhmhFHGGGeCSaaYZoZZ5phngUWWWGaFVdZYZ4NNtthmh1322OeAQ4445oTf/OGUM8654JIrrrnhljvueeCRJ5554ZU33vngky+++eGfwx9gkCGGGWGUMcaZYJIppplhljnmWWCRJZZZYZU11tlgky222WGXPfY54JAjjjnhN3845YxzLrjkimtuuOWOex545IlnXnjljXc++OSLb37+hJ7//hJgkCGGGWGUMcaZYJIppplhljnmWWCRJZZZYZU11tlgky222WGXPfY54JAjjjnhN3845YxzLrjkimtuuOWOex545IlnXnjljXc++OSLb3749fcvAQYZYpgRRhljnAkmmWKaGWaZY54FFllimRVWWWOdDTbZYpsddtljnwMOOeKYE37zh1POOOeCS6645oZb7rjngUeeeOaFV95454NPvvjmh1//+yXAIEMMM8IoY4wzwSRTTDPDLHPMs8AiSyyzwiprrLPBJltss8Mue+xzwCFHHHPCb/5wyhnnXHDJFdfccMsd9zzwyBPPvPDKG+988MkX3/zwT+gPMMgQw4wwyhjjTDDJFNPMMMsc8yywyBLLrLDKGutssMkW2+ywyx77HPD/FRuU7A== + + + AQAAAACAAAAhAwAAEAAAAA==eJzj4hoFo2AU4AQACOofSw== + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_13.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_13.vtu new file mode 100644 index 00000000000..921323e8d63 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_13.vtu @@ -0,0 +1,50 @@ + + + + + + + AQAAAACAAACoBQAAPgEAAA==eJwtxdciEAAAAECpNIxSqShaGpT2IIkG7UEZRVMSTQlRlFJRpElDEoqQQh/owd3LBQRMmORAT/YUT3WQp3m6Z3imgx3iUId5lmc73HM81/Mc4fle4IWOdJQXebGjHeMlXuplXu4VjvVKr/Jqr3Gc473W65zg9d7gjd7kzd7ird7m7d7hRCd5p5O9yyne7VSneY/3ep/3O90ZPuCDPuTDPuKjPubjPuGTznSWT/m0s53jXOf5jM863wU+5/O+4Iu+5Msu9BUX+aqLfc0lLvV13/BN3/Jt33GZ77rc91zhSlf5vqtd4wd+6FrX+ZEfu95P/NQNfubnfuFGN/mlX7nZLX7tVr/xW7/ze3/wR7e53Z/82V/81R3+5k5/d5d/uNs97vVP/3Kf+/3bAx70kP942H/9zyMe9Zj/exyv0D+j + + + AQAAAACAAACoBQAALgAAAA==eJxjYMAPGAnQhNQPFCDWfejqSPUvtewf6PAaaYBQPAy1eBlu/hkFqAAAesAAIA== + + + AQAAAACAAACoBQAANwAAAA==eJxjYIAARjQaHRCSJwTQ9REyB90+Su0lRA9WQKz7CPlrsPmT2HgZbO4eBdQBo/FPGgAAeZgAIA== + + + + + AQAAAACAAAAACQAAGwAAAA==eJztwwENAAAMw6DOv+kLOSSsmqrqowcuFgJB + + + AQAAAACAAAAAEgAAiwMAAA==eJwtxUMAEAYAAMC4bNu2bdu2bdu2bdu2bdvGll17dPe56gH+quGaruXaruO6ruf6buCGbuTGbuKmbubmbuGWbuXWbuO2buf27uCO7uTO7uKu7ubu7uGe7uXe7uO+7uf+HuCBHuTBHuKhHubhHuGRHuXRHuOxHufxnuCJnuTJnuKpnubpnuGZnuXZnuO5nuf5XuCFXuTFXuKlXublXuGVXuXVXuO1Xuf13uCN3uTN3uKt3ubt3uGd3uXd3uO93uf9PuCDPuTDPuKjPubjPuGTPuXTPuOzPufzvuCLvuTLvuKrvubrvuGbvuXbvuO7vuf7fuCHfuTHfuKnfubnfuGXfuXXfuO3/tf/+Z3f+4M/+pM/+4u/+pu/+4d/+pd/+48DBJQDObCDOKj/cTAHdwiHdCiHdhiHdTiHdwRHdCRHdhRHdTRHdwzHdCzHdhzHdTzHdwIndCIndhIndTIndwqndCqndhqndTqndwZndCZndhZndTZndw7ndC7ndh7ndT7ndwEXdCEXdhEXdTEXdwmXdCmXdhmXdTmXdwVXdCVXdhVXdTVXdw3XdC3Xdh3XdT3XdwM3dCM3dhM3dTM3dwu3dCu3dhu3dTu3dwd3dCd3dhd3dTd3dw/3dC/3dh/3dT/39wAP9CAP9hAP9TAP9wiP9CiP9hiP9TiP9wRP9CRP9hRP9TRP9wzP9CzP9hzP9TzP9wIv9CIv9hIv9TIv9wqv9Cqv9hqv9Tqv9wZv9CZv9hZv9TZv9w7v9C7v9h7v9T7v9wEf9CEf9hEf9TEf9wmf9Cmf9hmf9Tmf9wVf9CVf9hVf9TVf9w3f9C3f9h3f9T3f9wM/9CM/9hM/9TM/9wu/9Cu/9hu/9b/+z+/83h/80Z/82V/81d/83T/807/8238cINDfAjqQAzuIg/ofB3Nwh3BIh3Joh3FYh3N4R3BER3JkR3FUR3N0x3BMx3Jsx3Fcx3N8J3BCJ3JiJ3FSJ3Nyp3BKp3Jqp3Fap3N6Z3BGZ3JmZ3FWZ3N253BO53Ju53Fe53N+F3BBF3JhF3FRF3Nxl3BJl3Jpl3FZl3N5V3BFV3JlV3FVV3N113BN13Jt13Fd13N9N3BDN3JjN3FTN3Nzt3BLt3Jrt3Fbt3N7d3BHd3Jnd3FXd3N393BP93Jv93Ff93N/D/BAD/JgD/FQD/Nwj/BIj/Joj/FYj/N4T/BET/JkT/FUT/P/npYfIA== + + + + + AQAAAACAAAD4EAAAUAQAAA==eJydVn9oVVUcv5MUqsGaT4owrdQ/1vNHIYEzZV839I9WDFTESTPnH4oalojVtsaUoMiehY0VI2mKCquhUzEnvFrMO90GQ98P53vTybzqtnv33tQDlkYW9XL3ew7n++63ix0eXM7nnnO+38/n+znf+wzjUYYF+lzAf+PcPg63yHn0fIpzg74XzHn0PT2fPv3icPv98vBb55dHlOAOw5PqSPdzutDz6ZyeT4fzP/dHmfgWwTmfUB38nlQHej6NT/Wh++h6rh5UHzo4/fzyovs5n3F+cRg+lDfnaxrX735z9aR5cnpRflFmPZcfPYfjzd0TGofzh58etB5UX8rLr59wutF4XL/xqzPF/c6jeQzB92+WOzVtvQTvhyOXL4bMWXGJN8x+9sHu9hTkhcy1iZI+iR9fvi/Q//g5uDFas3RlTbfEF7b8siNUkYafDy0p6qszJf7c6olz41+YMKP1mvV1RwIwHo0//uwheB889vBpEtyECQ9pqrz+/Dsznu8i/IakfhX2pYPPHIqR+Bbku/yQL+KD382rHijuhoLFiaamv85KPNL9yatnahMwFNgdyfnDlDjyRh0Q//yrUOc34Q5Zl0ULXmv68WASkB/iOF/SOPb+uzu6JB5o33RtxMJ5kqw3Gb6G4c3XMPI8+RqGN1/DQL62xtcwvPnisGQ+en6WzEf3myXzydf8ZoG33yxAX72g+coCzoeYTzDwdLjp1kiW/xJjo8vWTx7N8nlVeHqsYXA46158tuz6vHdeVPph3DsFe/NO7Vd1wDyfSr4nSivTUD/r9cwvKd+f3jrQtvWtIeIHHCmYn9v5Sm5nl8T/3V1/eFjWX1u+K834QTD+F+DtB8H4X4C3HwTjf0H4CvDmi36mfAV483XX71L3DPnq9VV+0+urfKXXV/lQr68FhS4vodVX+TDfra+uOw7Um/quB3I0HjjMcbwqpeOZfqfzU/da56fiIz9635Ef6oA4+hd5IT7Z5ed934XMR7/XQuaj+1KA9/dFMPddMPdaAP2+6PqoOrXe3RILxRyimyXrTPv/h81vDH4QHc7q//bNkm8ri9JZ/R91o/1fz0OQ+CMEp35QfV73g4tn/CC2P/F2WbGqtz6nfktBvD1nw41S5YOCwOrwggPD5D65IzP31lPAUU89BaOnYPQUMOLqSfuJt56C8KVzqiflK8CbL+0nqk46f+Vnnb/yrd43BPy2rbS8sSMl+SM+6adpe3YWpyV/xNHPyL+sLP6RsSoCvb2N1a23bDk/9lJz/r0VUXgQ7K+cVB6BdSvLZo6duwDOieMvL828vxP8te3LzPrqOWNPLr9kw6KdUyb2rI9A7VXb+PR8BLZP+DhZGLdh38364O2FDsxo2LutPZmJU3ilZWat+z90sQPXN6+Y8kORM/5/qyoK9+oONzcXONB9v2LNyTlRCO65/XvJRRty2jbOH5jrQENd2OnLdeBUbGrL2n4b/gHfY+pC + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAASAAA2wsAAA==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 + + + AQAAAACAAAAAEgAANQMAAA==eJw12BG7MogChdEzc5u53ecJgiAIgiAIgiAIgiAIgiAIgiAIguBAEARBEARBEARBEARBEARBEARBEARBEAQHggtnfVvWb9hv4Ot3QYYYZoRRxhhngkmmmGaGWeaYZ4FFllhmhVXWWGeDTbbYZoff7LLHPgcccsQxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3f/jh11+/BBhkiGFGGGWMcSaYZIppZphljnkWWGSJZVZYZY11Nthki212+M0ue+xzwCFHHHPCKWecc8ElV1xzwy133PPAI08888Irb7zzwSdffPOHH379/UuAQYYYZoRRxhhngkmmmGaGWeaYZ4FFllhmhVXWWGeDTbbYZoff7LLHPgcccsQxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3f/jh139+CTDIEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvs8Jtd9tjngEOOOOaEU84454JLrrjmhlvuuOeBR5545oVX3njng0+++OYPP/wKgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaH3+yyxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPLFN3/44dc/vwQYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdvjNLnvsc8AhRxxzwilnnHPBJVdcc8Mtd9zzwCNPPPPCK2+888EnX3zzhx9+/ftLgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaH3+yyxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPLFN3/44dd/fwkwyBDDjDDKGONMMMkU08wwyxzzLLDIEsussMoa62ywyRbb7PCbXfbY54BDjjjmhFPOOOeCS6645oZb7rjngUeeeOaFV95454NPvvjmDz/8c/gDDDLEMCOMMsY4E0wyxTQzzDLHPAssssQyK6yyxjobbLLFNjv8Zpc99jngkCOOOeGUM8654JIrrrnhljvueeCRJ5554ZU33vngky+++cPPn9Dzv1/+D9jnJJk= + + + AQAAAACAAABAAgAADwAAAA==eJzj4hoFo4B8AABe9xaB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_2.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_2.vtu new file mode 100644 index 00000000000..c8033da727e --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_2.vtu @@ -0,0 +1,47 @@ + + + + + + + AQAAAACAAAAABQAAFwEAAA==eJwtxdciEAAAAEBNoSGKsoqMNlJ2iTKSQkJGmWVWhJIiKmRGESr6VQ/dvVxAwH97vNf7vN8HfNCBPuQgBzvEh33ER33MoT7uMIf7hE86wpE+5dOOcrRjHOs4n/FZxzvB55zoJCc7xed9wRd9yZd9xVed6jSn+5ozfN03nOksZzvHuc5zvm/6lgt824Uu8h3fdbFLXOoy33O577vCD/zQla5ytR+5xo9d6zrX+4kb3OgmN/upn7nFrW5zuzvc6ed+4S53u8e97nO/X/qVX3vAg37jIQ97xG/9zqN+7zF/8EePe8KfPOkpf/YXf/W0Zzzrb57zvBe86CUv+7tXvOof/uk1r/uXN7zpLf/2H//1tnf8z7teXTGx + + + AQAAAACAAAAABQAAIAAAAA==eJxjZIAARhw0pQCXudSiRzqgdfiOhvsoGM4AAHu4ACA= + + + + + AQAAAACAAACcBwAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8aDBAEi1Aeg= + + + AQAAAACAAAA4DwAADAMAAA==eJwtxVOAEAYAANDrsrHm1WoL27JtXbZt27bdZd1l27Zt27a1j977eckDvkvhlE7l1E7jtE7n9M7gjM7kzM7irM7m7M7hnM7l3M7jvM7n/C7ggi7kIBd2ERd1MRd3CZd0KZd2GZd1OZd3BVd0JVd2FVd1NVd3Ddd0Ldd2Hdd1Pdd3Azd0Izd2Ezd1Mzd3C7d0K7d2G7d1O7d3B3d0J3d2F3d1N3d3D/d0L/d2H/d1P/f3AA/0IA/2EA/1MA/3CI/0KI/2GAd7rMd5vCd4oid5sqd4qqd5ukMc6hme6Vme7Tme63me7wVe6EVe7CVe6mVe7hVe6VVe7TVe63Ve7w3e6E3e7C3e6m3e7h3e6V3e7T3e633e7wM+6EM+7CM+6mM+7hM+6VM+7TM+63M+7wu+6Eu+7Cu+6mu+7hu+6Vu+7Tu+63u+7wd+6Ed+7Cd+6md+7hd+6Vd+7Td+63d+7w/+6E/+7C/+6m8OCCMHOqzDObwjOKIjObKjOKqjObpjOKZjObbj+AfH9Y/+yT/7F//q3/y7/3A8x/efTuCE/st/O5ETO4mT+h//6/+czMmdwimdyqmdxmmdzumdwRmdyZmdxVmdzdmdwzmdy7mdx3mdz/ldwAVdyEEu7CIu6mIu7hIu6VIu7TIu63Iu7wqu6Equ7Cqu6mqu7hqu6Vqu7Tqu63qu7wZu6EZu7CZu6mZu7hZu6VZu7TZu63Zu7w7u6E7u7C7u6m7u7h7u6V7u7T7u637u7wEe6EEe7CEe6mEe7hEe6VEe7TEO9liP83hP8ERP8mRP8VRP83SHONQzPNOzPNtzPNfzPN8LvNCLvNhLvNTLvNwrvNKrvNprvNbrvN4bvNGbvNlbvNXbvN07vNO7vNt7vNf7vN8HfNCHfNhHfNTHfNwnfNKnfNpnfNbnfN4XfNGXfNlXfNXXfN03fNO3fNt3fNf3fN8P/NCP/NhP/NTP/Nwv/NKv/Npv/Nbv/N4f/NGf/Nlf/NXfHBD4vTAOdFiHc3hHcERHcmRHcVRHc3THcEzHcmzH8f9auf0g + + + + + AQAAAACAAAAADwAAyAUAAA==eJyllXlQk1cQwKOiFrHIVRREqpAiLYfRKkWhLl5VkDqKUELHA7GWQxzTY0RQivdR8EDREQ9UUFRMW+h4tECFcgUNkiAYEAoEkpAvhOpXEVAKUqfNe595JBM67j/f7O+9b3ffvt19LNbrIgUtlUXD0DhNrOvj5P/6hFynDdgztM+QPX1fJGI9eZDq4dQQ8yYG3ZzMH9Ip4qtvH8nJ+PXdFzXE85HxIyHPQ3J9om+d9IuE0nM+UkdiqI7Jc5N1oO+c/zdeUvTlaaj9RNol80L6edO8kDoZr765QNrT12+G7hWJoXwY6vc3jZvJw+Npo/1+4dzD/9u6lHqs9q8FSYdq0ToLFWG3DnocOzYE9MgwT03sPS6arYKjPF7gp2Z1mFtTNjkzvcn/pXD9UXViEbsVIvs+MY6cwazHjzljd9hHDspo75dXM5n9I0o8La9dfwBJTkEJVYsrMbeyuyTP8ZKBrfpZPmXehjlnY8u8vvQyHC/i/O6gA0nSYo3/dsyzNHpgara4K1owiF9YtDmGEpZh/lX0lx+abSiDgGtzCnL2MfbzE/Nk6cH1kJYW+SQ5UI1581L22ohhxTjfV/25VNwtoUaXY75K+TB9fEYVETeLNS6xaLVkfg2kuNj8ffC3dsybzrnHNswTgLO3JC2tvwRzkWDvzN+3S0BpeVA0rLcI8/wMn7k13xXB7Kw73yauUmP//H/P+YCojzrwnR6YK/61AnPkv1UVt3BlnABz5N88J2KBxdoazOUa/2G8ZyfjRxVj7qnxP/nHZumJQskgv9r5QSIH7fywWNkrzljWGZcCyg/iXTw/7qnCdkD5QXx03qSkhHlqQPlB3C54pNuDQ0WA8oP42Wn5qTW9MqxvTd398d3kcmBFRYljRjL385nYw5UNKjjEDni425eZT3GetjPWZ9XB3mT33FluKsyNLQo4ISFyOHnM4pFUxtjfsT47+WKWCnz4ptt83Zl5NsI0olfk0Qr7vZZcLuQzfs/yEuxdnMuh1Mqfc/mxEvOOILFHyI06GDgR0GpeyOTRaXzDhWB7ORwYZWW7bhJj31/C3bXwLQmud8SRfp3gXE2f1CSNmU6Vl2He/sLRtn9CKdFHjJ3/NBp01z8NuuufBt31T4Pu+qdBd/3ToLv+WawPLK1z0/5sI+JhsX7ojKpKrKKIeFisA4ta3DdOaR/UjzFXljZtESsG9WObbP7p0LnqQf34xPnouJvn5YP6UTsepi+05zENqP635tpXpTQpBvUpihNx5Af5RRzVv1ntZtovVI15T0n5leSdzD2ElrKlclkFCMZ+URWZxvAXc9uc7HxUUOEWNiudz8QXcq1H8LxPAib9Dv1T+mSYJw04ZJx89S60Hj52zsGGea+2FHS7fjRWBinxfjNuJNzHfHimOCwyTAbVl62Ptuxi4hZecfrZrr0c9sTZKOrrmPfNaNO5qcuiZdDgnur8vRczp0yyu/KWn66FPzpds0ROTPzqgPWzKy81AFmnut8FhpP70b7i6l2KzNf8It0odpNw4kAr5jlp5t1PTj3C96t970jkoF2HzNzTvl9m7qE6RHyUZu6hOkQc3bt2PSChQXdf0KC7L2jQ3Rc06O4LGnT3BQ1kX3gdXLDyTIcI7q4JjjARimC+oPObC00iOGQb5jvmZTPwzH+a3PT81bp9iUdMQxvwVxQ8/nxZA9SL244cd6uEOcMn1L9t3Ajdy/dz+NMUYHXM4eF+jhiaJ4ayY2Or4X3XRiOZuhKsrGtvt7yyy8lrvMP1p+BZlM9Fi8UUTG3s5Jk1imCJaYznAFAwfEKwi5Athep9vgu2DaPApLhr3e4gJWSGrzz+Tng1qLmm9gJXClJSjM7uUNWA49JZBZ3blRCd8l594bsUCPu9bY88FUNhwKXVSmMR7Jzz9QqLfiVU3I6/7+RFQRsoCp6uoYB7r74zQ6kEhUY/Hx5ONbkr4NakhPK/iii4mePoKzwhhX8A+yIhmQ== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAADgPAAAMgoAAA==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 + + + AQAAAACAAAA4DwAAuAIAAA==eJwtxRGAKgYAANC2tS0IgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIguDgIAiCIAiCg4MgCIIgCIIgCD70nrxg4CPksCOOOua4E0465bQzzjrnvAsuuuSyK6665robbrrltjvuuue+Bx565LEnnnrmuRde+svfXnntjbfeee+Df/zro08+++Krb7774adffjvw16egQw474qhjjjvhpFNOO+Osc8674KJLLrviqmuuu+GmW26746577nvgoUcee+KpZ5574aW//O2V19546533PvjHvz765LMvvvrmux9++uW3A39/CjrksCOOOua4E0465bQzzjrnvAsuuuSyK6665robbrrltjvuuue+Bx565LEnnnrmuRde+svfXnntjbfeee+Df/zro08+++Krb7774adffjvwz6egQw474qhjjjvhpFNOO+Osc8674KJLLrviqmuuu+GmW26746577nvgoUcee+KpZ5574aW//O2V19546533PvjHvz765LMvvvrmux9++uW3A0E55LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY77rrnvgceeuSxJ5565rkXXvrL31557Y233nnvg3/866NPPvviq2++++GnX3478O+noEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltuu+Oue+574KFHHnviqWeee+Glv/ztldfeeOud9z74x78++uSzL7765rsffvrltwP/fQo65LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY77rrnvgceeuSxJ5565rkXXvrL31557Y233nnvg3/866NPPvviq2++++GnX3478P+noEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltuu+Oue+574KFHHnviqWee+w+qOe8J + + + AQAAAACAAADnAQAADgAAAA==eJzj4hoFIwAAACStEwc= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_23.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_23.vtu new file mode 100644 index 00000000000..104cc26f768 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_23.vtu @@ -0,0 +1,50 @@ + + + + + + + AQAAAACAAACoBQAAPgEAAA==eJwtxdciEAAAAECpNIxSqShaGpT2IIkG7UEZRVMSTQlRlFJRpElDEoqQQh/owd3LBQRMmORAT/YUT3WQp3m6Z3imgx3iUId5lmc73HM81/Mc4fle4IWOdJQXebGjHeMlXuplXu4VjvVKr/Jqr3Gc473W65zg9d7gjd7kzd7ird7m7d7hRCd5p5O9yyne7VSneY/3ep/3O90ZPuCDPuTDPuKjPubjPuGTznSWT/m0s53jXOf5jM863wU+5/O+4Iu+5Msu9BUX+aqLfc0lLvV13/BN3/Jt33GZ77rc91zhSlf5vqtd4wd+6FrX+ZEfu95P/NQNfubnfuFGN/mlX7nZLX7tVr/xW7/ze3/wR7e53Z/82V/81R3+5k5/d5d/uNs97vVP/3Kf+/3bAx70kP942H/9zyMe9Zj/exyv0D+j + + + AQAAAACAAACoBQAAMgAAAA==eJxjYEAFjGg0OsAlT4hPLqC2OYTcT0gdLnOpZf8owA4IxQ+x8TVUwUj3/0gHAH4oACA= + + + AQAAAACAAACoBQAAOAAAAA==eJxjYIAARjQaHRCSxwXQ1ROrn5A6dPeQq55U/9AaEBv+g9X9xAJC/hnq/hvqYDR+BhcAAHxoACA= + + + + + AQAAAACAAAAACQAAGwAAAA==eJztwwENAAAMw6DOv+kLOSSsmqrqowcuFgJB + + + AQAAAACAAAAAEgAAiwMAAA==eJwtxUMAEAYAAMC4bNu2bdu2bdu2bdu2bdvGll17dPe56gH+quGaruXaruO6ruf6buCGbuTGbuKmbubmbuGWbuXWbuO2buf27uCO7uTO7uKu7ubu7uGe7uXe7uO+7uf+HuCBHuTBHuKhHubhHuGRHuXRHuOxHufxnuCJnuTJnuKpnubpnuGZnuXZnuO5nuf5XuCFXuTFXuKlXublXuGVXuXVXuO1Xuf13uCN3uTN3uKt3ubt3uGd3uXd3uO93uf9PuCDPuTDPuKjPubjPuGTPuXTPuOzPufzvuCLvuTLvuKrvubrvuGbvuXbvuO7vuf7fuCHfuTHfuKnfubnfuGXfuXXfuO3/tf/+Z3f+4M/+pM/+4u/+pu/+4d/+pd/+48DBJQDObCDOKj/cTAHdwiHdCiHdhiHdTiHdwRHdCRHdhRHdTRHdwzHdCzHdhzHdTzHdwIndCIndhIndTIndwqndCqndhqndTqndwZndCZndhZndTZndw7ndC7ndh7ndT7ndwEXdCEXdhEXdTEXdwmXdCmXdhmXdTmXdwVXdCVXdhVXdTVXdw3XdC3Xdh3XdT3XdwM3dCM3dhM3dTM3dwu3dCu3dhu3dTu3dwd3dCd3dhd3dTd3dw/3dC/3dh/3dT/39wAP9CAP9hAP9TAP9wiP9CiP9hiP9TiP9wRP9CRP9hRP9TRP9wzP9CzP9hzP9TzP9wIv9CIv9hIv9TIv9wqv9Cqv9hqv9Tqv9wZv9CZv9hZv9TZv9w7v9C7v9h7v9T7v9wEf9CEf9hEf9TEf9wmf9Cmf9hmf9Tmf9wVf9CVf9hVf9TVf9w3f9C3f9h3f9T3f9wM/9CM/9hM/9TM/9wu/9Cu/9hu/9b/+z+/83h/80Z/82V/81d/83T/807/8238cINDfAjqQAzuIg/ofB3Nwh3BIh3Joh3FYh3N4R3BER3JkR3FUR3N0x3BMx3Jsx3Fcx3N8J3BCJ3JiJ3FSJ3Nyp3BKp3Jqp3Fap3N6Z3BGZ3JmZ3FWZ3N253BO53Ju53Fe53N+F3BBF3JhF3FRF3Nxl3BJl3Jpl3FZl3N5V3BFV3JlV3FVV3N113BN13Jt13Fd13N9N3BDN3JjN3FTN3Nzt3BLt3Jrt3Fbt3N7d3BHd3Jnd3FXd3N393BP93Jv93Ff93N/D/BAD/JgD/FQD/Nwj/BIj/Joj/FYj/N4T/BET/JkT/FUT/P/npYfIA== + + + + + AQAAAACAAAD4EAAAUQQAAA==eJydVn1MlVUYf1HBmWx8OcvNPmhsmR8kzZkm4wGENrAxtRxskprOzWyaa34gVvZHZHqtiBFjNZHSTWNm8Ic4buDwolwLtnsvXi7XueGr3ct94eI4Ldpa0eoK73Pened9z17wGdvZ+Z3znufH7/k9z66izCRUsN7LcAxG9jIcv2PkXRkuC7t36TnF6X16z+7/s3vPTg+7lYYXrPeyusjuUx70nN6zq782zfz0nAZ9h+KUh2ylutC60HNaP6rDdPuB8sSgeWVB/38v4Ufza5JzTZLPztc0P8Wn27cyfem5rH8oj5nqKvt+uvOG8qP3ZHpQPnb1k9VNNmfs+sPuOzvdKU7ffdxzjCCIK4Zf398iuAvm6CsiE//F4tlumDWZBr8L8fOLr5dpla09pjzlkf7vnzzng9pli/452THC8SSH661Avh+WZAcaGv69wfHBM5lH7+a5IZJ20hP3t5Hf465adf2DAKxtunbQUR7lePu53Bz/Ry7O59Kd2w5XRh/RNwhFWW86vW29HEc+D4YrC96odHMc+aS07Fmfut3P8ZDOZ+eB8boPE7o4jnyev3xP/bozQPKG+N5aH5XzFfVRIUXXp3nTt2nBeTc5jnwXl8av6PvcxfHn9PyiPiqI+gQJD4wQYJ0QwbxYJ8T/PFBcVt85AlgnxOf+/PTp43lRwDohjjxFHhgMTn3l6KpzdvIV8amV+pNBbv3oof0Hu+HIdxuqT3/pJ/cHyIoRJPXAwHeHTP6Pe7R8HBXxmO8n8YoR03tL0xY6Gx4Okfoqyo9/7PU5fJrJ/58V3s98N33E5P8jFzYMHvaGTf4f+i3/mx05UZP/x5ZUJ105G+J8xPoyzkfsC8b5iPVl3G9iXzCeV6wj4z4U/c+IPipY66NCYHS48O3UYZPPK5zP+GoHw6a+QN3WEJ8zXQfaFykD77HiHVGTHiI/xKkfEKd+0HGTHxTl6r67rfu2hqAmoyj2R32I94x+enSr5nwYXk7sWpnY1S3e5/mM+SbqaMw31BFx1BN1RBz1RB0RRz2Z4CeV6ynqqBIdGfGdoSv6Tqwv474T68u470SfM+4vsb4M6PwX9cGg+hjzTdRHUaz1URTkI/abMd+SBX0wGFj7AX1F/cDA2g/6fZMfYifvP7GtJC8EuIr5h0geRenriNv9oDg2d9JKna80hsX7+D7PQ/U0+kfUk0n8xiR+M+aJqKcxT5It+9a4Zz1PGFjPWwbW85aB9bxlYD1vmYmvtf7Il+rPwFp/Ut/Ymro+K9ET8Uztk/W1wguf+NoubUzWoKSk75iyxQMDwYWu41u88Nevn+7qcXumfp9V6L83szW4/87mBT/kaByP0/GxpeOtXzyMQOXy0fmb+iMQbml+qSD2XlU0c532Wj8UXj6x7cy9CDRlLWta3eiBiRd//yl+lhfcgdxVJ9I1WPNCYk1BbwTK8p/a+MtsDdqv3yh9dbUGCXO3e2vVCPwPWqbXkg== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAASAAA1AsAAA==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 + + + AQAAAACAAAAAEgAANQMAAA==eJw12BG7MogChdEzc5u53ecJgiAIgiAIgiAIgiAIgiAIgiAIguBAEARBEARBEARBEARBEARBEARBEARBEAQHggtnfVvWb9hv4Ot3QYYYZoRRxhhngkmmmGaGWeaYZ4FFllhmhVXWWGeDTbbYZoff7LLHPgcccsQxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3f/jh11+/BBhkiGFGGGWMcSaYZIppZphljnkWWGSJZVZYZY11Nthki212+M0ue+xzwCFHHHPCKWecc8ElV1xzwy133PPAI08888Irb7zzwSdffPOHH379/UuAQYYYZoRRxhhngkmmmGaGWeaYZ4FFllhmhVXWWGeDTbbYZoff7LLHPgcccsQxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3f/jh139+CTDIEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvs8Jtd9tjngEOOOOaEU84454JLrrjmhlvuuOeBR5545oVX3njng0+++OYPP/wKgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaH3+yyxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPLFN3/44dc/vwQYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdvjNLnvsc8AhRxxzwilnnHPBJVdcc8Mtd9zzwCNPPPPCK2+888EnX3zzhx9+/ftLgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaH3+yyxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPLFN3/44dd/fwkwyBDDjDDKGONMMMkU08wwyxzzLLDIEsussMoa62ywyRbb7PCbXfbY54BDjjjmhFPOOOeCS6645oZb7rjngUeeeOaFV95454NPvvjmDz/8c/gDDDLEMCOMMsY4E0wyxTQzzDLHPAssssQyK6yyxjobbLLFNjv8Zpc99jngkCOOOeGUM8654JIrrrnhljvueeCRJ5554ZU33vngky+++cPPn9Dzv1/+D9jnJJk= + + + AQAAAACAAABAAgAADwAAAA==eJzj4hoFo4B8AABe9xaB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_3.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_3.vtu new file mode 100644 index 00000000000..172cee464a7 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_full_span_mesh_tet_DFN_3.vtu @@ -0,0 +1,47 @@ + + + + + + + AQAAAACAAAD4BAAAFgEAAA==eJwtxdciEAAAAEAh2crIKiORUlFRKpSZLZrSsFpWSFEkSkZaqIT4Vg/uXi4gYM8+BzrIwd7vEB9wqMMc7ghHOsrRjvFBH3Ks4xzvBB92opOc7BSn+oiPOs3pznCmjznLx53tHJ9wrk/6lPN82md81vku8Dmf9wUXusgXfcnFvuwrvuoSl7rM13zd5a5wpatc7RrfcK3rXO8GN7rJzW7xTbe6zbd823d81/d83+1+4A4/9CM/9hN3usvd7nGvn/qZn/uFX7rP/R7woIf8ysMe8ahfe8xv/NbjnvA7v/ekp/zB0/7oGc/6kz97zl887wUveslfvexv/u4f/ulfXvGq1/zbf/zX6/7nDW96y/+97R3vAtC3MRI= + + + AQAAAACAAAD4BAAAIAAAAA==eJxjZIAARhw0pQCXudSiRzqgdfiOhvsoGI4AAHq4ACA= + + + + + AQAAAACAAACMBwAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8YBhACpNAeQ= + + + AQAAAACAAAAYDwAABAMAAA==eJwtxVNgEAgAANC17DrXIXfKdsu2bdu2bdu2bdu2jdVy66P3fl6ygO+SO4VTOpVTO43TOp3TO4MzOpMzO4uzOpuzO4dzOsi5nNt5nNf5nN8FXNCFXNhFXNTFXNwlXNKlXNplXNblXN4VXNGVXNlVXNXVXN01XNO1XNt1XNf1XN8N3NCN3NhN3NTN3Nwt3NKt3Npt3Nbt3N4d3NGd3Nld3NXd3N093NO93Nt93Nf93N8DPNCDPNhDPNTDPNwjPNKjPNpjPNbjPN4TPNGTPNlTPNXTPN0zPNOzPNtzPNfzPN8LvNCLvNhLvNTLvNwrvNKrvNprvNbrvN4bvNGbvNlbvNXbvN07vNO7vNt7vNf7vN8HfNCHfNhHfNTHfNwnfNKnfNpnfNbnfN4XfNGXfNlXfNXXfN03fNO3fNt3fNf3fN8P/NCP/NhP/NTP/Nwv/NKv/NrBfuO3DvE7v/cHf/Qnf/YXf3WoA8LIgQ7rcA7vCI7oSI7sKI7qaI7uGI7pWI7tH/yjf/LP/sW/+jfHcVz/7j/8p/9yPMd3Aid0Iid2Eif13/7H//o//+9kTu4UTulUTu00Tut0Tu8MzuhMzuwszupszu4czukg53Ju53Fe53N+F3BBF3JhF3FRF3Nxl3BJl3Jpl3FZl3N5V3BFV3JlV3FVV3N113BN13Jt13Fd13N9N3BDN3JjN3FTN3Nzt3BLt3Jrt3Fbt3N7d3BHd3Jnd3FXd3N393BP93Jv93Ff93N/D/BAD/JgD/FQD/Nwj/BIj/Joj/FYj/N4T/BET/JkT/FUT/N0z/BMz/Jsz/Fcz/N8L/BCL/JiL/FSL/Nyr/BKr/Jqr/Far/N6b/BGb/Jmb/FWb/N27/BO7/Ju7/Fe7/N+H/BBH/JhH/FRH/Nxn/BJn/Jpn/FZn/N5X/BFX/JlX/FVX/N13/BN3/Jt3/Fd3/N9P/BDP/JjP/FTP/Nzv/BLv/JrB/uN3zrE7/zeH/zRn/zZX/zVoQ4I/F4YBzqswzm8IziiIzmyoziqozm6Y/gbuIH81g== + + + + + AQAAAACAAADoDgAAkQUAAA==eJytlXlMVFcUxi+hagFTQFoVd5FYRIvb1KBSjhu1olM3UApa0RSqdcOUlLqgaaKiHTW2YBUNgwWtCmKhLgFFtINIAWVmWEeoMMwMwxsWfaKoEZfSdu59ecd5NU24/7zc35t3znfPOd8dQmwtPfz75OG/OX3q0e+kuNTCefAec6n3b4on9b3Ue/rUSNQBn4/uuTfUTQO2OY7Lo3g4/pu+06N8Un3B8bFuzLF+vHC9pOqI9zgvXriuuI8aiTz/Ny6Oj/XjeuL4mON+4fhS9ZLylZRenI+u7tYr9Z7rpvPgukjdN5hjXVL96654HNwb2yswe1wxDBhdMGn5vGoWr6rVErCyj8W61zH+ZERrxKInRkhUPItXT7YwfjAqKkjuooO+nHuWzM+CdOkh/U65QuVpYPs1zz92WDPBArGOxwYdmGZivGmd38vTv+jB/oav25n0Msb3jQzeoZ1dCu8OOmHKmmpkfEDLo1zO1Qzj1jZMf55yE+XVwdnHwXv26fORjmZIsz4pD0rM1HSsK3yNHw/YGMOV3IRN6yInukQI8RedmXIta7cOchVXjClLaxhXKtfc/yGoBerneq5YbZeP9NBlgrP/5ClDXAdzxgdd1uTcYjxhtHvn3qvNYLBsmbV4SyHjXn5VSuWLG+CatXpmnxUVjJvc9qrtnqlgVdSjn2J75jPum5YXrVjWAsPO1esPXa9CfSVErMfEONWTufCYm86hgHGq53FUYMiR682MUz29rgzet2N6C+NUz6ClPT4o269iXKyH5uVRfXSMn54Xwm25VIL08OCsUC2vmlEBtF6UU52Treen3MOaV6yHh9zUaf4V21UsD67TW7LtbdqvLcgvhLhkvy8Lc9UhXxCSXVgYfKfLL2JfENL56u9Vbz2ngfHQd0w1YZNKkC8ImTAyzv7cb3XQS+QLQsIueR932sCBm8gXhJSM6rvb589y5AtC7Kx1viDyBSHUF+mi+SfEti8IOeLjaeghb4ZokS8IWZq+atipXCPkiXxByN5dn83IzlAhX9DFszqL686zuVjWVJnSL1XLOO0/7TvlHdZ5rEvy2Vw7vZBxOo/qwl2y37dVMU77T/su1mUCb7e+l5Vt5td8Kr4fCaF6vr08RJtQ1/iaf/cENPisHS7Uj87jfa+DzheThT5TPS7VG/nA8BZ2fvperEeYy4yHX2kVWg7NPyE0L70vKI85NbfuG00jNFnvC8rNxhlHw/1bkF8IoTpbcwL6jZpbAm213ynl8mpWx5y2Je/51zZBvrE9sjTNyPir4uJ+s14YITXPc/5Ge6GvRcfjbi1x1MHP7smZ+2stjGtrauT+vjp4uck/Z3NwEeOxpwwO61Pr4alxrFP4j7WM+xnCMpLPGEE3Ity3o0OIE131ZfJFDw04VB7+ovykoGdH6Nq4TmcLXNDOyVuQL+i/115d8lFBPdQklOfd7RTuoeJlVx8WdM15nF1MzvUc4V4JsfqC+oNy6p8QxG37iEf95cF2f3mw3V8ebPeXB9v95cF2f3k0h4IfxXoEvVQP5XT+xXMu+JHqobyn1Y9UD+V0/qmeJMPbI2Rb1TDUcXHZg51qaBjunWp20oBjkufABUM5uPT8oPHDCDUUJGqzFpnV4JIrz4weUgkeeRke3uf1sCFw7KPO+FIYc/jQjbSu/2H5g8QpxaYmmP/0dljGSzUkmas/6a9ohP49nCKKlHoYP3Th4kkHNHB3Ja9vXc2B+8JI/60rOWjWDy4tk2ngaJaMfP9rKWgaEiZmd927wX/sHH9ymxqO2De2pnhxcPtm76knHDlICySq+IEcpNytaI2NUcP6/gmHK0PVENquKXJobwIu+HzvzbHVMDttOLcrvRFm3eHP7x/JwefnFkQumWnu6vOY/AuflkPYNS+np84c/AUaiQ7p + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAABgPAAAPQoAAA==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 + + + AQAAAACAAAAYDwAAswIAAA==eJwtxRGAKgYAANC2tS0IgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIDg6CIAiCIAiCIAiCIAiCIAiCIAiCgw/3nrxg4FfIYUccdcxxJ5x0ymlnnHXOeRdcdMllV1x1zXU33HTLbXfcdc99Dzz0yGN/+dsTTz3z3AsvvfLaG2+9894HH33y2RdfffPdDz/98tsf/zjw129Bhxx2xFHHHHfCSaecdsZZ55x3wUWXXHbFVddcd8NNt9x2x1333PfAQ4889pe/PfHUM8+98NIrr73x1jvvffDRJ5998dU33/3w0y+//fGPA3//FnTIYUccdcxxJ5x0ymlnnHXOeRdcdMllV1x1zXU33HTLbXfcdc99Dzz0yGN/+dsTTz3z3AsvvfLaG2+9894HH33y2RdfffPdDz/98tsf/zjwz29Bhxx2xFHHHHfCSaecdsZZ55x3wUWXXHbFVddcd8NNt9x2x1333PfAQ4889pe/PfHUM8+98NIrr73x1jvvffDRJ5998dU33/3w0y+//fGPA0E55LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY77rrnvgceeuSxv/ztiaeeee6Fl1557Y233nnvg48++eyLr7757oeffvntj38c+Pe3oEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltuu+Oue+574KFHHvvL35546pnnXnjpldfeeOud9z746JPPvvjqm+9++OmX3/74x4H/fgs65LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY77rrnvgceeuSxv/ztiaeeee6Fl1557Y233nnvg48++eyLr7757oeffvntj38c+P+3oEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltuu+Oue+574KFHHvsP5YPslQ== + + + AQAAAACAAADjAQAADgAAAA==eJzj4hoFwxwAANi+Et8= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_1.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_1.vtu new file mode 100644 index 00000000000..e90617ca777 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_1.vtu @@ -0,0 +1,38 @@ + + + + + + + AQAAAACAAADoAwAAGQAAAA==eJxjYBjZgHGA1FEbjPqDMnXDHQAAFaAACg== + + + + + + + AQAAAACAAAC4CwAADgEAAA==eJyN1bkVwzAMA1Bvlv27jKBSpUZIxQbJD8RGz/ABiwSg5/lX79dvfAHfwA9w8cx14gv4Bn6A5/eSN/EFfAM/wPO95E18Ad/AD/C8n7yJL+Ab+AGepbmq7+qL/rvpSGvqKnkTT101nYondZW8iaeumg+0j9RVPpd46qr5TH1KXSVv4qmr5mPNQX6W3+SHqaYbzVV9V19aDolPa+oqeW9zTjoVT+oqeW9zVD7QPlJX+dxtTstn6pPyWnk61XKnzUF+lt+mmi7bnDVvzWOq/XfTkdbUVTsnlXPSqXhSV+0cVo7KB9qHzuOpdm41n6lPyuuplmvNx5qD/DzVdN9yQnPWvKdaX1oOie97/QAgkVK8 + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAEAAAUgIAAA==eJyFk0VXEGAUBbE7EMEWAxUUsTsAuxsD7O5u/fEuvLOZc77z3uauZs59i9vR8f8mJacnpyWXJZcne5OrxU1OzpAHbkVyjTxwU5Iz5YFbmVwrD9zU5Cx54FYl18nDn/Sdk5yd5E/69iXXi6PvXHng6LtBHjj6zpMHjr4b5YHj7/nywPH3Jnn4k74LkwuS/EnfgWS/OPp2ygNH383ywNF3kTxw9N0iDxx/d8kDx9+D8vAnfbuTi5P8Sd+h5FZx9O2RB46+2+SBo+8SeeDou10eOP5eKg8cf++Qp9r3zuSu5P7kPnGtfcPtTh6Qp9o33J7kQXmqfcPtTR6Sp9o3f9L3SPKwOPp633D0PSoPXGvfcPQdlqfaNxx/j8hT7Zs/6XssOSqutW84+h6Xp9o3HH1PyFPtG24keVKeat/8Sd/TyVPiWvuGo+8Zeap9w9H3rDzVvuH4+5w81b7PJy8kryaviGvtG+5i8po81b7hLiWvy1PtG+5y8oY81b75k743k2PiWvuGo+8teap9w9H3tjzVvuH4+4481b75k74TyXFxrX3D0feuPNW+4eh7T55q33D8fV+eat/8Sd+HyQfiWvuGo+8jeap9w9H3sTzVvuH4+4k81b6fJp8lXydfiWvtG+558o081b7hXiTfylPtG+5l8p081b75k74fku/FtfYNR9+P8lT7hqPvJ3mqfcPx92d5qn3zJ32/Jr+Ia+0bjr7f5Kn2DUff7/JU+4bj7x/yVPvmT/r+Sv4U19o3HH1/y1PtG46+f+Sp9g3H33/l+QdSt3wB + + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= + + + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_12.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_12.vtu new file mode 100644 index 00000000000..08e5e376752 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_12.vtu @@ -0,0 +1,41 @@ + + + + + + + AQAAAACAAADoAwAAGQAAAA==eJxjYBjZgHGA1FEbjPqDMnXDHQAAFaAACg== + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgF+AAjDnqogVF/jGwAABWgAAo= + + + + + + + AQAAAACAAAC4CwAADgEAAA==eJyN1bkVwzAMA1Bvlv27jKBSpUZIxQbJD8RGz/ABiwSg5/lX79dvfAHfwA9w8cx14gv4Bn6A5/eSN/EFfAM/wPO95E18Ad/AD/C8n7yJL+Ab+AGepbmq7+qL/rvpSGvqKnkTT101nYondZW8iaeumg+0j9RVPpd46qr5TH1KXSVv4qmr5mPNQX6W3+SHqaYbzVV9V19aDolPa+oqeW9zTjoVT+oqeW9zVD7QPlJX+dxtTstn6pPyWnk61XKnzUF+lt+mmi7bnDVvzWOq/XfTkdbUVTsnlXPSqXhSV+0cVo7KB9qHzuOpdm41n6lPyuuplmvNx5qD/DzVdN9yQnPWvKdaX1oOie97/QAgkVK8 + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAEAAAUgIAAA==eJyFk0VXEGAUBbE7EMEWAxUUsTsAuxsD7O5u/fEuvLOZc77z3uauZs59i9vR8f8mJacnpyWXJZcne5OrxU1OzpAHbkVyjTxwU5Iz5YFbmVwrD9zU5Cx54FYl18nDn/Sdk5yd5E/69iXXi6PvXHng6LtBHjj6zpMHjr4b5YHj7/nywPH3Jnn4k74LkwuS/EnfgWS/OPp2ygNH383ywNF3kTxw9N0iDxx/d8kDx9+D8vAnfbuTi5P8Sd+h5FZx9O2RB46+2+SBo+8SeeDou10eOP5eKg8cf++Qp9r3zuSu5P7kPnGtfcPtTh6Qp9o33J7kQXmqfcPtTR6Sp9o3f9L3SPKwOPp633D0PSoPXGvfcPQdlqfaNxx/j8hT7Zs/6XssOSqutW84+h6Xp9o3HH1PyFPtG24keVKeat/8Sd/TyVPiWvuGo+8Zeap9w9H3rDzVvuH4+5w81b7PJy8kryaviGvtG+5i8po81b7hLiWvy1PtG+5y8oY81b75k743k2PiWvuGo+8teap9w9H3tjzVvuH4+4481b75k74TyXFxrX3D0feuPNW+4eh7T55q33D8fV+eat/8Sd+HyQfiWvuGo+8jeap9w9H3sTzVvuH4+4k81b6fJp8lXydfiWvtG+558o081b7hXiTfylPtG+5l8p081b75k74fku/FtfYNR9+P8lT7hqPvJ3mqfcPx92d5qn3zJ32/Jr+Ia+0bjr7f5Kn2DUff7/JU+4bj7x/yVPvmT/r+Sv4U19o3HH1/y1PtG46+f+Sp9g3H33/l+QdSt3wB + + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= + + + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_123.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_123.vtu new file mode 100644 index 00000000000..196f7c9c0a3 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_123.vtu @@ -0,0 +1,44 @@ + + + + + + + AQAAAACAAADoAwAAGQAAAA==eJxjYBjZgHGA1FEbjPqDMnXDHQAAFaAACg== + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgF+AAjDnqogVF/jGwAABWgAAo= + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgFQxkw4qBprW4UDC0AABWgAAo= + + + + + + + AQAAAACAAAC4CwAADgEAAA==eJyN1bkVwzAMA1Bvlv27jKBSpUZIxQbJD8RGz/ABiwSg5/lX79dvfAHfwA9w8cx14gv4Bn6A5/eSN/EFfAM/wPO95E18Ad/AD/C8n7yJL+Ab+AGepbmq7+qL/rvpSGvqKnkTT101nYondZW8iaeumg+0j9RVPpd46qr5TH1KXSVv4qmr5mPNQX6W3+SHqaYbzVV9V19aDolPa+oqeW9zTjoVT+oqeW9zVD7QPlJX+dxtTstn6pPyWnk61XKnzUF+lt+mmi7bnDVvzWOq/XfTkdbUVTsnlXPSqXhSV+0cVo7KB9qHzuOpdm41n6lPyuuplmvNx5qD/DzVdN9yQnPWvKdaX1oOie97/QAgkVK8 + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAEAAAUgIAAA==eJyFk0VXEGAUBbE7EMEWAxUUsTsAuxsD7O5u/fEuvLOZc77z3uauZs59i9vR8f8mJacnpyWXJZcne5OrxU1OzpAHbkVyjTxwU5Iz5YFbmVwrD9zU5Cx54FYl18nDn/Sdk5yd5E/69iXXi6PvXHng6LtBHjj6zpMHjr4b5YHj7/nywPH3Jnn4k74LkwuS/EnfgWS/OPp2ygNH383ywNF3kTxw9N0iDxx/d8kDx9+D8vAnfbuTi5P8Sd+h5FZx9O2RB46+2+SBo+8SeeDou10eOP5eKg8cf++Qp9r3zuSu5P7kPnGtfcPtTh6Qp9o33J7kQXmqfcPtTR6Sp9o3f9L3SPKwOPp633D0PSoPXGvfcPQdlqfaNxx/j8hT7Zs/6XssOSqutW84+h6Xp9o3HH1PyFPtG24keVKeat/8Sd/TyVPiWvuGo+8Zeap9w9H3rDzVvuH4+5w81b7PJy8kryaviGvtG+5i8po81b7hLiWvy1PtG+5y8oY81b75k743k2PiWvuGo+8teap9w9H3tjzVvuH4+4481b75k74TyXFxrX3D0feuPNW+4eh7T55q33D8fV+eat/8Sd+HyQfiWvuGo+8jeap9w9H3sTzVvuH4+4k81b6fJp8lXydfiWvtG+558o081b7hXiTfylPtG+5l8p081b75k74fku/FtfYNR9+P8lT7hqPvJ3mqfcPx92d5qn3zJ32/Jr+Ia+0bjr7f5Kn2DUff7/JU+4bj7x/yVPvmT/r+Sv4U19o3HH1/y1PtG46+f+Sp9g3H33/l+QdSt3wB + + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= + + + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_13.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_13.vtu new file mode 100644 index 00000000000..5f461cef077 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_13.vtu @@ -0,0 +1,41 @@ + + + + + + + AQAAAACAAADoAwAAGQAAAA==eJxjYBjZgHGA1FEbjPqDMnXDHQAAFaAACg== + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgFQxkw4qBprW4UDC0AABWgAAo= + + + + + + + AQAAAACAAAC4CwAADgEAAA==eJyN1bkVwzAMA1Bvlv27jKBSpUZIxQbJD8RGz/ABiwSg5/lX79dvfAHfwA9w8cx14gv4Bn6A5/eSN/EFfAM/wPO95E18Ad/AD/C8n7yJL+Ab+AGepbmq7+qL/rvpSGvqKnkTT101nYondZW8iaeumg+0j9RVPpd46qr5TH1KXSVv4qmr5mPNQX6W3+SHqaYbzVV9V19aDolPa+oqeW9zTjoVT+oqeW9zVD7QPlJX+dxtTstn6pPyWnk61XKnzUF+lt+mmi7bnDVvzWOq/XfTkdbUVTsnlXPSqXhSV+0cVo7KB9qHzuOpdm41n6lPyuuplmvNx5qD/DzVdN9yQnPWvKdaX1oOie97/QAgkVK8 + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAEAAAUgIAAA==eJyFk0VXEGAUBbE7EMEWAxUUsTsAuxsD7O5u/fEuvLOZc77z3uauZs59i9vR8f8mJacnpyWXJZcne5OrxU1OzpAHbkVyjTxwU5Iz5YFbmVwrD9zU5Cx54FYl18nDn/Sdk5yd5E/69iXXi6PvXHng6LtBHjj6zpMHjr4b5YHj7/nywPH3Jnn4k74LkwuS/EnfgWS/OPp2ygNH383ywNF3kTxw9N0iDxx/d8kDx9+D8vAnfbuTi5P8Sd+h5FZx9O2RB46+2+SBo+8SeeDou10eOP5eKg8cf++Qp9r3zuSu5P7kPnGtfcPtTh6Qp9o33J7kQXmqfcPtTR6Sp9o3f9L3SPKwOPp633D0PSoPXGvfcPQdlqfaNxx/j8hT7Zs/6XssOSqutW84+h6Xp9o3HH1PyFPtG24keVKeat/8Sd/TyVPiWvuGo+8Zeap9w9H3rDzVvuH4+5w81b7PJy8kryaviGvtG+5i8po81b7hLiWvy1PtG+5y8oY81b75k743k2PiWvuGo+8teap9w9H3tjzVvuH4+4481b75k74TyXFxrX3D0feuPNW+4eh7T55q33D8fV+eat/8Sd+HyQfiWvuGo+8jeap9w9H3sTzVvuH4+4k81b6fJp8lXydfiWvtG+558o081b7hXiTfylPtG+5l8p081b75k74fku/FtfYNR9+P8lT7hqPvJ3mqfcPx92d5qn3zJ32/Jr+Ia+0bjr7f5Kn2DUff7/JU+4bj7x/yVPvmT/r+Sv4U19o3HH1/y1PtG46+f+Sp9g3H33/l+QdSt3wB + + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= + + + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_2.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_2.vtu new file mode 100644 index 00000000000..1bd642cb3c5 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_2.vtu @@ -0,0 +1,38 @@ + + + + + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgF+AAjDnqogVF/jGwAABWgAAo= + + + + + + + AQAAAACAAAC4CwAADgEAAA==eJyN1bkVwzAMA1Bvlv27jKBSpUZIxQbJD8RGz/ABiwSg5/lX79dvfAHfwA9w8cx14gv4Bn6A5/eSN/EFfAM/wPO95E18Ad/AD/C8n7yJL+Ab+AGepbmq7+qL/rvpSGvqKnkTT101nYondZW8iaeumg+0j9RVPpd46qr5TH1KXSVv4qmr5mPNQX6W3+SHqaYbzVV9V19aDolPa+oqeW9zTjoVT+oqeW9zVD7QPlJX+dxtTstn6pPyWnk61XKnzUF+lt+mmi7bnDVvzWOq/XfTkdbUVTsnlXPSqXhSV+0cVo7KB9qHzuOpdm41n6lPyuuplmvNx5qD/DzVdN9yQnPWvKdaX1oOie97/QAgkVK8 + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAEAAAUgIAAA==eJyFk0VXEGAUBbE7EMEWAxUUsTsAuxsD7O5u/fEuvLOZc77z3uauZs59i9vR8f8mJacnpyWXJZcne5OrxU1OzpAHbkVyjTxwU5Iz5YFbmVwrD9zU5Cx54FYl18nDn/Sdk5yd5E/69iXXi6PvXHng6LtBHjj6zpMHjr4b5YHj7/nywPH3Jnn4k74LkwuS/EnfgWS/OPp2ygNH383ywNF3kTxw9N0iDxx/d8kDx9+D8vAnfbuTi5P8Sd+h5FZx9O2RB46+2+SBo+8SeeDou10eOP5eKg8cf++Qp9r3zuSu5P7kPnGtfcPtTh6Qp9o33J7kQXmqfcPtTR6Sp9o3f9L3SPKwOPp633D0PSoPXGvfcPQdlqfaNxx/j8hT7Zs/6XssOSqutW84+h6Xp9o3HH1PyFPtG24keVKeat/8Sd/TyVPiWvuGo+8Zeap9w9H3rDzVvuH4+5w81b7PJy8kryaviGvtG+5i8po81b7hLiWvy1PtG+5y8oY81b75k743k2PiWvuGo+8teap9w9H3tjzVvuH4+4481b75k74TyXFxrX3D0feuPNW+4eh7T55q33D8fV+eat/8Sd+HyQfiWvuGo+8jeap9w9H3sTzVvuH4+4k81b6fJp8lXydfiWvtG+558o081b7hXiTfylPtG+5l8p081b75k74fku/FtfYNR9+P8lT7hqPvJ3mqfcPx92d5qn3zJ32/Jr+Ia+0bjr7f5Kn2DUff7/JU+4bj7x/yVPvmT/r+Sv4U19o3HH1/y1PtG46+f+Sp9g3H33/l+QdSt3wB + + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= + + + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_23.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_23.vtu new file mode 100644 index 00000000000..14d7e72237e --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_23.vtu @@ -0,0 +1,41 @@ + + + + + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgF+AAjDnqogVF/jGwAABWgAAo= + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgFQxkw4qBprW4UDC0AABWgAAo= + + + + + + + AQAAAACAAAC4CwAADgEAAA==eJyN1bkVwzAMA1Bvlv27jKBSpUZIxQbJD8RGz/ABiwSg5/lX79dvfAHfwA9w8cx14gv4Bn6A5/eSN/EFfAM/wPO95E18Ad/AD/C8n7yJL+Ab+AGepbmq7+qL/rvpSGvqKnkTT101nYondZW8iaeumg+0j9RVPpd46qr5TH1KXSVv4qmr5mPNQX6W3+SHqaYbzVV9V19aDolPa+oqeW9zTjoVT+oqeW9zVD7QPlJX+dxtTstn6pPyWnk61XKnzUF+lt+mmi7bnDVvzWOq/XfTkdbUVTsnlXPSqXhSV+0cVo7KB9qHzuOpdm41n6lPyuuplmvNx5qD/DzVdN9yQnPWvKdaX1oOie97/QAgkVK8 + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAEAAAUgIAAA==eJyFk0VXEGAUBbE7EMEWAxUUsTsAuxsD7O5u/fEuvLOZc77z3uauZs59i9vR8f8mJacnpyWXJZcne5OrxU1OzpAHbkVyjTxwU5Iz5YFbmVwrD9zU5Cx54FYl18nDn/Sdk5yd5E/69iXXi6PvXHng6LtBHjj6zpMHjr4b5YHj7/nywPH3Jnn4k74LkwuS/EnfgWS/OPp2ygNH383ywNF3kTxw9N0iDxx/d8kDx9+D8vAnfbuTi5P8Sd+h5FZx9O2RB46+2+SBo+8SeeDou10eOP5eKg8cf++Qp9r3zuSu5P7kPnGtfcPtTh6Qp9o33J7kQXmqfcPtTR6Sp9o3f9L3SPKwOPp633D0PSoPXGvfcPQdlqfaNxx/j8hT7Zs/6XssOSqutW84+h6Xp9o3HH1PyFPtG24keVKeat/8Sd/TyVPiWvuGo+8Zeap9w9H3rDzVvuH4+5w81b7PJy8kryaviGvtG+5i8po81b7hLiWvy1PtG+5y8oY81b75k743k2PiWvuGo+8teap9w9H3tjzVvuH4+4481b75k74TyXFxrX3D0feuPNW+4eh7T55q33D8fV+eat/8Sd+HyQfiWvuGo+8jeap9w9H3sTzVvuH4+4k81b6fJp8lXydfiWvtG+558o081b7hXiTfylPtG+5l8p081b75k74fku/FtfYNR9+P8lT7hqPvJ3mqfcPx92d5qn3zJ32/Jr+Ia+0bjr7f5Kn2DUff7/JU+4bj7x/yVPvmT/r+Sv4U19o3HH1/y1PtG46+f+Sp9g3H33/l+QdSt3wB + + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= + + + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_3.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_3.vtu new file mode 100644 index 00000000000..43b204c04d3 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_hex_DFN_3.vtu @@ -0,0 +1,38 @@ + + + + + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgFQxkw4qBprW4UDC0AABWgAAo= + + + + + + + AQAAAACAAAC4CwAADgEAAA==eJyN1bkVwzAMA1Bvlv27jKBSpUZIxQbJD8RGz/ABiwSg5/lX79dvfAHfwA9w8cx14gv4Bn6A5/eSN/EFfAM/wPO95E18Ad/AD/C8n7yJL+Ab+AGepbmq7+qL/rvpSGvqKnkTT101nYondZW8iaeumg+0j9RVPpd46qr5TH1KXSVv4qmr5mPNQX6W3+SHqaYbzVV9V19aDolPa+oqeW9zTjoVT+oqeW9zVD7QPlJX+dxtTstn6pPyWnk61XKnzUF+lt+mmi7bnDVvzWOq/XfTkdbUVTsnlXPSqXhSV+0cVo7KB9qHzuOpdm41n6lPyuuplmvNx5qD/DzVdN9yQnPWvKdaX1oOie97/QAgkVK8 + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAEAAAUgIAAA==eJyFk0VXEGAUBbE7EMEWAxUUsTsAuxsD7O5u/fEuvLOZc77z3uauZs59i9vR8f8mJacnpyWXJZcne5OrxU1OzpAHbkVyjTxwU5Iz5YFbmVwrD9zU5Cx54FYl18nDn/Sdk5yd5E/69iXXi6PvXHng6LtBHjj6zpMHjr4b5YHj7/nywPH3Jnn4k74LkwuS/EnfgWS/OPp2ygNH383ywNF3kTxw9N0iDxx/d8kDx9+D8vAnfbuTi5P8Sd+h5FZx9O2RB46+2+SBo+8SeeDou10eOP5eKg8cf++Qp9r3zuSu5P7kPnGtfcPtTh6Qp9o33J7kQXmqfcPtTR6Sp9o3f9L3SPKwOPp633D0PSoPXGvfcPQdlqfaNxx/j8hT7Zs/6XssOSqutW84+h6Xp9o3HH1PyFPtG24keVKeat/8Sd/TyVPiWvuGo+8Zeap9w9H3rDzVvuH4+5w81b7PJy8kryaviGvtG+5i8po81b7hLiWvy1PtG+5y8oY81b75k743k2PiWvuGo+8teap9w9H3tjzVvuH4+4481b75k74TyXFxrX3D0feuPNW+4eh7T55q33D8fV+eat/8Sd+HyQfiWvuGo+8jeap9w9H3sTzVvuH4+4k81b6fJp8lXydfiWvtG+558o081b7hXiTfylPtG+5l8p081b75k74fku/FtfYNR9+P8lT7hqPvJ3mqfcPx92d5qn3zJ32/Jr+Ia+0bjr7f5Kn2DUff7/JU+4bj7x/yVPvmT/r+Sv4U19o3HH1/y1PtG46+f+Sp9g3H33/l+QdSt3wB + + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= + + + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_1.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_1.vtu new file mode 100644 index 00000000000..fa5cd33b104 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_1.vtu @@ -0,0 +1,47 @@ + + + + + + + AQAAAACAAADwBAAAEwEAAA==eJwtxdciEAAAAEBKiTKSVMrehCYlZc/s7LLaVFIUyqhoUAmJRP/qwd3LBQTsC/QBH3SQD/mwg33EIQ71UR9zmMMd4Ugfd5RPONonHeNTPu0zjvVZn3Oc453gRCc52SlOdZrTneFMZznbOT7vXOc53xd80Zd82Vd81QUu9DVfd5FvuNg3fcslLnWZy13hSle52jWudZ3rfdsNbnSTm93iVrf5jtvd4U53uds97vVd33Of+z3gQQ/5vh/4oR/5sZ/4qYc94md+7hce9UuP+ZVfe9wTfuO3nvSUp/3O7z3jWc953h/80Z+84EV/9hd/9Tcvednf/cM/veJfXvWa1/3bG/7jTW/5r7f9zzve9X/vAUgYMHQ= + + + AQAAAACAAADwBAAAHwAAAA==eJxjZIAARhw0pQCXudQyf7iD0fAbBaOAegAAN6AADQ== + + + + + AQAAAACAAACcBwAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8aDBAEi1Aeg= + + + AQAAAACAAAA4DwAADAMAAA==eJwtxVOAEAYAANDrsm3btn3hsm3btnkZlxfG2mqoLdu2bdvYR+/9vI0B323yZm/xVm/zdu/wTu/ybu/xXu/zfh/wQR/yYR/xUR/zcZ/wSZ/yaZ/xWZ/zeV/wRV/yZV/xVV/zdd/wTd/ybd/xXd/zfT/wQz/yYz/xUz/zc7/wS7/ya7/xW7/ze3/wR3/yZ3/xV39zQBg50GEdzuEdwREdyZEdxVEdzdEdwzEdy7Edx3Edz/GdwAmdyImdxEmdzMmdwimdyqmdxmmdzumdwRmdyZmdxVmdzdmdwzmdy7mdx3mdz/ldwAVdyIVdxEVdzMVdwiVdyqVdxmVdzuUd5Aqu6Equ7GBXcVVXc3XXcE3Xcm3XcV3Xc303cEM3cmM3cVM3c3O3cEu3cmu3cVu3c3t3cEd3cmd3cVd3c3f3cE/3cm/3cV/3c38P8EAP8mAP8VAP83CP8EiP8miP8ViP83hP8ERP8mRP8VSHeJqne4ZnepZne47nep7nO9QLvNCLvNhLvNTL/IOXe4VXepV/9E/+2b/4V//m1V7j3/2H13qd//Rf/tv/eL03+F//543e5M3e4q3e5u3e4Z3e5d3e473e5/0+4IM+5MM+4qM+5uM+4ZM+5dM+47M+5/O+4Iu+5Mu+4qu+5uu+4Zu+5du+47u+5/t+4Id+5Md+4qd+5ud+4Zd+5dd+47d+5/f+4I/+5M/+4q/+5oDA74VxoMM6nMM7giM6kiM7iqM6mqM7hmM6lmM7juM6nuM7gRM6kRM7iZM6mZM7hVM6lVM7jdM6ndM7gzM6kzM7i7M6m7M7h3M6l3M7j/M6n/O7gAu6kAu7iIu6mIu7hEu6lEu7jMu6nMs7yBVc0ZVc2cGu4qqu5uqu4Zqu5dqu47qu5/pu4IZu5MZu4qZu5uZu4ZZu5dZu47Zu5/bu4I7u5M7u4q7u5u7u4Z7u5d7u477u5/4e4IEe5MEe4qEe5uEe4ZEe5dEe47Ee5/Ge4Ime5Mme4qkO8TRP9wzP9CzP9hzP9TzPd6gXeKEXebGXeKmX+X+HjfBe + + + + + AQAAAACAAADQDgAAGgUAAA==eJytln9QVFUUxyFgFCGCSIyiyYAWNUNEQhTjkEPTBCw6DCg/shgERYWE0RQZgaCAFGWUyIQSEATkhwQOEYyJjIALLC5LO8qyiwH7FnmLUm8kfhS/WvDd9+Sy22J6/uDM/by7997zvWe+Fy2t2eiFuaQlxDLipAZOYlyIcTwoNVzdPHy+prGmeYvNKHrV1IfrgM9T9x3/PR5CNVzdfFxnoYY6cE5q0Bk/D6Xm/BRWL34ePJ62nv/7e/x8+LpPq9Oz6oHrivcdvj++jrp+fdb1nnffPO9z4esvVm80T4xlxGV07p7PvyTmZ8SNpY9ztIzZ57KnHxlTzcfW19Ias3oY6j1GQGbqP9+2b1IwXNchbqjjkAJee6fJcZdnJ8PTIiN9uMZiMCPNKx22KBbUUdYlSr1pze6bNFrYr+3Ih3S3lZ5/ucoZvoGTolN+9XfQa3QyLS79jeGhMT7+4xEkuA+u9wpwJhjOX22WbNstArsDfR9M5t3C9pVDxajvN6d6GxheMneOQUAZcZ/MCuFIOG8BP29rLdPjDkJU+J4NxqHs+uWvVNUU/ErAFydt3jy3U8LwE0n+W2uu3IQeD+vPwrQb4GHthytWe/CZ70PShGwuV6kbv3WF2xRbR36d9baDOnyoHdqx3EU6wPAG4tEeQQkBvNyUth3L2Pu5aJ5TcVqqgA6JhOvixPLpKJfaY74tEF8k04/I72H4OLHOIChdCofv7s352ZLtS/0734eICgiIDziQMvESe29VHR/XbW/oBGdZ4JWcYvacYqsgp5ERBfzxqJP/fhO7viRDVHdvQg6lmH5+tK6tn1wfbuKyPEX7aG197SCg7/g9+GAc3QvSk9FxLihGN6QX4jOtj3VG+iLeQuuJdEQc6Yl0RDyW1hPpiPgWWh+kC+JIZ6Qv4khnpC/iSE+kI+JIN6QX4n4qdaIY/f0wrrq/KRhrbC46myBmxkFN1r1yog14hiEd+7JZ/rfLfY6FqwLa3g1+L6+MrdO/eIw3PnkXDKYsp96aZOs8NWOZf07pA7K09AuW5qxfHrkxunajIQEZse72VfG3Gf5CoTB4XzABogKzM32JbP38Is5Vi8Fm+DrGvF8iZv1VN+KCjVc4AVLbzFUnndk6DSpGrm3P6oTu4bUl7Rz2/A+8d28SXJIuqB+NcR1V+wSrY4Mosb/wiX3RWPdYBP/1GRnDK7NNRv883wXqfFadnxrX2DgEmogX+G8Nj+fbpfRl3GcnZmajZ4HPBhjJJYFKn41d9oNF2hM+a0/77BLMZwOr1+QafE6CqcUleeUifFZ77q8cqjCfRX2I+4Emnz2M+ezO0uCVRUqfrUu9RuT9h89qzQtKjd7Kflf5rin7SeU9UKD6XWPf8fl6U6D6XaNA9btGgep3Tdn3KvVG++LvmuZ+xbnqd40C1e8aBbjeafEOdvmvCsF3Nr6j63TtBf310z+6JgvmxsZGnXTugc31/XvLhweY+XPtCr1Qd6hefPBTcsH8XaJKK95PtyES9puHT/cAJ+lo3PHYAViTarrRKINk+Ns0t7slWNeSQML+mLCtS/vuQ3KlY8Bx5f9flOzBjYw7AvCq/iXRwIMEHT+n4qLSAXBboifMcicZrkvzi43JJobWApAYhliGRQ9Abtm9+PJ0IWyL+uiNM9UCyDl7efhF13Your40y2KVEMqsyscDvUnIp3kxzb/a/fLyIzIBkzk2orjTzQNAJk6YRduT0L3ZPbfYXAAKevwvSAIzzg== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAADgPAAAqAoAAA==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 + + + AQAAAACAAAA4DwAAuAIAAA==eJwtxRGAKgYAANC2tS0IgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIguDgIAiCIAiCg4MgCIIgCIIgCD70nrxg4CPksCOOOua4E0465bQzzjrnvAsuuuSyK6665robbrrltjvuuue+Bx565LEnnnrmuRde+svfXnntjbfeee+Df/zro08+++Krb7774adffjvw16egQw474qhjjjvhpFNOO+Osc8674KJLLrviqmuuu+GmW26746577nvgoUcee+KpZ5574aW//O2V19546533PvjHvz765LMvvvrmux9++uW3A39/CjrksCOOOua4E0465bQzzjrnvAsuuuSyK6665robbrrltjvuuue+Bx565LEnnnrmuRde+svfXnntjbfeee+Df/zro08+++Krb7774adffjvwz6egQw474qhjjjvhpFNOO+Osc8674KJLLrviqmuuu+GmW26746577nvgoUcee+KpZ5574aW//O2V19546533PvjHvz765LMvvvrmux9++uW3A0E55LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY77rrnvgceeuSxJ5565rkXXvrL31557Y233nnvg3/866NPPvviq2++++GnX3478O+noEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltuu+Oue+574KFHHnviqWeee+Glv/ztldfeeOud9z74x78++uSzL7765rsffvrltwP/fQo65LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY77rrnvgceeuSxJ5565rkXXvrL31557Y233nnvg3/866NPPvviq2++++GnX3478P+noEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltuu+Oue+574KFHHnviqWee+w+qOe8J + + + AQAAAACAAADnAQAADgAAAA==eJzj4hoFIwAAACStEwc= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_12.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_12.vtu new file mode 100644 index 00000000000..57884095909 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_12.vtu @@ -0,0 +1,50 @@ + + + + + + + AQAAAACAAAAgBQAAHwEAAA==eJwtxddCCAAAAMBKhVCaKFQiLQ1JES1CQmmJ0lIJoVJmpZA0JTMr1Y966O7lAgI2BTrIWxzsEId6q7d5u8O8wzu9y+GO8G5HOsrRjnGs47zHe73P8U7wfh/wQSc6yck+5BQf9hGn+qjTnO4MZzrLx5ztHOc6z8ed7xMu8EkXusinfNrFPuOzLnGpy1zuCp/zeVf6gi/6kqt82dW+4qu+5hrX+rrrXO8GN7rJN9zsm77lFrf6ttvc7g53ust33O0e9/qu+3zP9/3A/X7oR37sAQ96yE887BE/9TM/9wu/9CuPeszjfu0JT/qN3/qdp/ze0/7gGc96zvNe8KI/esmfvOzP/uKv/ubv/uEV//Qv//Yf//Wq/3nN697wf8cnNDc= + + + AQAAAACAAAAgBQAAHgAAAA==eJxjZIAARiJpWoOBsne4gYGOx1EwCoYDAAA98AAO + + + AQAAAACAAAAgBQAAJQAAAA==eJxjYEAFjGg0OkCXJ6SeXIBuHq3sGamAXvE4CkbBUAYAPKgADg== + + + + + AQAAAACAAAAQCAAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8YjGACywAgU= + + + AQAAAACAAAAgEAAANwMAAA==eJwtxUMQGAYAALBi1Wrbtm3bWm3btm3b1mrbtm3b2t2afJIkYID/JXUyJ3cKp3Qqp3Yap3U6p3cGZ3QmZ3YWZ3U2Z3cO53Qu53Ye53U+53cBF3QhF3YRF3UxF3cJl3Qpl3YZl3U5l3cFV3QlV3YVV/U/rubqruGaruXaruO6ruf6buCGbuTGbuKmbubmbuGWbuXWbuO2buf27uCO7uTO7uKu7ubu7uGe7uXe7uO+7uf+HuCBHuTBHuKhHubhHuGRHuXRHuOxHufxnuCJnuTJnuKpnubpnuGZnuXZnuO5nuf5XuCFXuTFXuKlXublXuGVXuXVXuO1Xud/vd4bvNGbvNlbvNXbvN07vNO7vNt7vNf7vN8HfNCHfNhHfNTHfNwnfNKnfNpnfNbnfN4XfNGXfNlXfNXXfN03fNO3fNt3fNf3fN8P/NCP/NhP/NTP/Nwv/NKv/Npv/Nbv/N4f/NGf/Nlf/NXf/N0//NO//NsBAv0poAM5sP9yEAd1MAd3CP/tkA7l0A7jsA7n8I7giI7kyI7iqI7m6I7hmI7l2I7juI7n+E7ghE7kxE7ipE7m5E7hlE7l1E7jtE7n9M7gjM7kzM7irM7m7M7hnM7l3M7jvM7n/C7ggi7kwi7ioi7m4i7hki7l0i7jsi7n8q7giq7kyq7iqv7H1VzdNVzTtVzbdVzX9VzfDdzQjdzYTdzUzdzcLdzSrdzabdzW7dzeHdzRndzZXdzV3dzdPdzTvdzbfdzX/dzfAzzQgzzYQzzUwzzcIzzSozzaYzzW4zzeEzzRkzzZUzzV0zzdMzzTszzbczzX8zzfC7zQi7zYS7zUy7zcK7zSq7zaa7zW6/yv13uDN3qTN3uLt3qbt3uHd3qXd3uP93qf9/uAD/qQD/uIj/qYj/uET/qUT/uMz/qcz/uCL/qSL/uKr/qar/uGb/qWb/uO7/qe7/uBH/qRH/uJn/qZn/uFX/qVX/uN3/qd3/uDP/qTP/uLv/qbv/uHf/qXfztA4D8FdCAH9l8O4qAO5uAO4b8d0qEc2mEc1uEc3hEc0ZEc2VEc1dEc3TEc07Ec23Ec1/Ec3wmc0Imc2Emc1Mmc3P8By8kDBg== + + + + + AQAAAACAAABgDwAAuQQAAA==eJytlH9M1GUcx7/EoTNAhaHIpD8ihDAwtTmpIz5t/ZjpTgyNQTRjSBlT1lrGpZtjkAYLM6VLkfHDRCDOyEsxhxlWgIcc4ve6dXfc1aD7Hh1HWDcZP4Qj+rHn8336PvHdYfr88+x53ef7/Hg973s47u/WD/90HE/6QdKznGd4v0w9+x1bx9YP+liH/d3XfuXWwXq2eWS4XB1b72vsq26uPTY5v756OR9zvU+2yfmUqx9kOO/jfCwflOEe5jwsZ/fjYc7J7odtd3qe//s9uz923jv1dLc+WK9sHtn12Xnkcny3893r3NzrfbHzz9U31llJ74TZuZXhTpl65xy/Y7nc+nLrWMVz3LQXVqtUFhhueTY8bpNB5LWt0Slv+P81NnSFPzMtiLxNuPVaj1aAlptpS5LtLpF/ElGj+8DuBv3J4u60++n8f7yZ3LL3xWtgtNlUyYmUTwiPBmaV2aGgwbEgr7ZP5At+OJ5jqhNgj3lnzYUoej/Nxudbt7RZoOClXcVTi9witz6UlTg66galI7OpppHu06Yxtf405YTfblkMT3bQ+dNP6PjR3Xo402sq/S56SOTFfuqWb1qGoOvlr0c6VJRvI/X4HXIt+R5/j1TszPlwpkv8vfK2KtygEyD1EUXlu4VOkfMb1CvVqmvwac+Yfp6e5ulg1fL49VcEMPrteasumN6DO+BSwOX5VggpDK0/6uoVudJha790vQ8mzm9/IkFJeUVW3kjoyUGYXNGh2xFLuWdJxS5NZTcEpeWb3umg/jKav+9LmjSDNzbglGUt3efG5t63H1gzBIfSNgvlCQ6Rh73nXlk+LPzHX7qMJ6xjOY4Xbap5bukaOg+OtavHFSWP0fucDF6R2+lnE312E4/kdFBPfB4gHpHjveB9IEfP6Bc5eka/yNEz+hU58Yx+kaPndOIX+RTxjH6RlxLPocQv8tnz6oHZvdJ6li8kXhdKfHugkXhGv8jH2zsbjhZSL1kd0f1OoRv0QTnG3GrKbyf/EhP5lBu6E7LXnfrMLfKMxnH9hNcMgdNR0w966XkOzUTVHktyg+NwWVVUBH2n86+Mxa8PEkCzf+Pa5oLrIr+vns/OzRbAVLf0yM9FTpEbGmLORQ51woF9EQM2K70PRV5V7ObdAthXnXj4fSU9f6Bu9KstFRb4cSReeyOG7v/X1B2P95y2g5bxy/6/Wc7WY12bqWig/l/r4lixN8+wfMYh8i+qQ8Z+L+8V/UnzyXGZxJ805xyXQ+7hoCTnHFdKvErzzHFq4jVJkmeO8ydepXnmuBvEa4YktxyHXoclOec49CrNM8eh1zBJnul7sE3mPdUy74rc+3uVeGXfj/PoVZJnbB7RJ+YTOfpEv8jxXvCekKNnzDNy9IzekaNnBfGOHN8HzDNyfE/8iXfk6Bm9I0fP6B25XF7RJ5tvHLP16Pkqk2/0fJZ4T5xv3m8u4yHHG/at5ksXdE7EFcXlWWDZ9o/WpV5wgfHpXk3mxzzprRBOuPR3K2SaU3Upn/NiXxfXlKJ7wQL7Xn0leKKJF/vL587O86Y5YbFpdf7hizyoj7naE0+7oCR3mVKf6YRg88XXs9UuGNh6ZJUyxAgjcRuOV5VQjj3yPwHxXETN + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAACAQAAAiAsAAA==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 + + + AQAAAACAAAAgEAAA4QIAAA==eJw11xGDAgYAQOG2tS0IgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiA4OAiCIAiCIAiCIAiCIAiC4CAIgsF9e/L9hhcM/BZimBFGGWOcCSaZYpoZZpljngUWWWKZFVZZY50NNtlimx122WOfAw454pgTTjnjF78554JLrrjmhlvuuOeBR5545oVX3njng0/+8MU3Pwz88UuQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZYZc99jngkCOOOeGUM37xm3MuuOSKa2645Y57HnjkiWdeeOWNdz745A9ffPPDwJ+/BBlimBFGGWOcCSaZYpoZZpljngUWWWKZFVZZY50NNtlimx122WOfAw454pgTTjnjF78554JLrrjmhlvuuOeBR5545oVX3njng0/+8MU3Pwz89UuQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZYZc99jngkCOOOeGUM37xm3MuuOSKa2645Y57HnjkiWdeeOWNdz745A9ffPPDQBAMMcwIo4wxzgSTTDHNDLPMMc8CiyyxzAqrrLHOBptssc0Ou+yxzwGHHHHMCaec8YvfnHPBJVdcc8Mtd9zzwCNPPPPCK2+888Enf/jimx8G/v4lyBDDjDDKGONMMMkU08wwyxzzLLDIEsussMoa62ywyRbb7LDLHvsccMgRx5xwyhm/+M05F1xyxTU33HLHPQ888sQzL7zyxjsffPKHL775YeCfX4IMMcwIo4wxzgSTTDHNDLPMMc8CiyyxzAqrrLHOBptssc0Ou+yxzwGHHHHMCaec8YvfnHPBJVdcc8Mtd9zzwCNPPPPCK2+888Enf/jimx8G/v0lyBDDjDDKGONMMMkU08wwyxzzLLDIEsussMoa62ywyRbb7LDLHvsccMgRx5xwyhm/+M05F1xyxTU33HLHPQ888sQzL7zyxjsffPKHL7754f/DH2SIYUb4H7j+A2A= + + + AQAAAACAAAAEAgAADgAAAA==eJzj4hoFIx0AAF2UFCk= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_123.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_123.vtu new file mode 100644 index 00000000000..3dc6a835653 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_123.vtu @@ -0,0 +1,53 @@ + + + + + + + AQAAAACAAABgBQAALgEAAA==eJwtxdciEAAAAEBCRogGTRKKlJZo01CZlRRFKJVRaSAhRWgRpUEqilLqJz24e7mAgEWBXuIgBzvESx3qMIc7wssc6ShHe7ljHOsVXulVXu04x3uN13qd13uDNzrBid7kJG92slOc6i3e6jSne5szvN07nOmd3uXd3uO9zvI+ZzvH+33AB33Ih33ER53rPB/zcZ/wSef7lE/7jAtc6CIXu8SlPutzPu8yX3C5L/qSK1zpy77iKlf7qmtc6zpf83XX+4Zv+pYb3OgmN/u27/iuW3zP9/3AD93qNrf7kTv82J3ucrefuMdP/cy97vNz93vAg37hl37l137jIQ/7rUc86nd+7zF/8Ed/8mePe8JfPOmv/ubvnvK0f/inZzzrX/7tOf/xX8/7n/97AZDZOXM= + + + AQAAAACAAABgBQAAGgAAAA==eJxjZIAARgrpUTC0wGh8joJRQHsAAEIQAA4= + + + AQAAAACAAABgBQAAIQAAAA==eJxjYEAFjGg0LoAuj66PED0KBjcYjb9RMAooBwBAKAAO + + + AQAAAACAAABgBQAAIQAAAA==eJxjZEAFjAT4uACp+hgJ0KNgcIPR+BsFo4AwAAA/UAAO + + + + + AQAAAACAAACcCAAAHAAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8SgeJBgAUVMCKA== + + + AQAAAACAAAA4EQAAawMAAA==eJwtxUMQGAYAALDatm3btm3btu12q21stW3btm1bu1uTT7IFDPC/7M7hnM7l3M7jvM7n/C7ggi7kwi7ioi7m4i7hki7l0i7jsi7n8q7giq7kyq7iqq7m6q7hmq7l2q7juq7n+m7ghm7kxm7ipm7m5m7hlm7l1m7jtm7n9u7gju7kzu7iru7m7u7hnu7l3u7jvu7n/h7ggR7kwR7ioR7m4R7hkR7l0R7jv/y3x3qcx3uCJ3qSJ3uKp3qap3uGZ3qWZ3uO53qe53uBF3qR//G/XuwlXuplXu4VXulVXu01Xut1Xu8N3uhN3uwt3upt3u4d3uld3u093ut93u8DPuhDPuwjPupjPu4TPulTPu0zPutzPu8LvuhLvuwrvuprvu4bvulbvu07vut7vu8HfuhHfuwnfupnfu4XfulXfu03fut3fu8P/uhP/uwv/upv/u4f/ulf/u0Agf4U0IEc2EEc1MEc3CEc0qEc2mEc1uEc3hEc0ZEc2VEc1dEc3TEc07Ec23Ec1/Ec3wmc0Imc2Emc1Mmc3Cmc0qmc2mmc1umc3hmc0Zmc2Vmc1dmc3Tmc07mc23mc1/mc3wVc0IVc2EVc1MVc3CVc0qVc2mVc1uVc3hVc0ZVc2VVc1dVc3TVc07Vc23Vc1/Vc3w3c0I3c2E3c1M3c3C3c0q3c2m3c1u3c3h3c0Z3c2V3c1d3c3T3c073c233c1/3c3wM80IM82EM81MM83CM80qM82mP8l//2WI/zeE/wRE/yZE/xVE/zdM/wTM/ybM/xXM/zfC/wQi/yP/7Xi73ES73My73CK73Kq73Ga73O673BG73Jm73FW73N273DO73Lu73He73P+33AB33Ih33ER33Mx33CJ33Kp33GZ33O533BF33Jl33FV33N133DN33Lt33Hd33P9/3AD/3Ij/3ET/3Mz/3CL/3Kr/3Gb/3O7/3BH/3Jn/3FX/3N3/3DP/3Lvx0g8J8COpADO4iDOpiDO4RDOpRDO4zDOpzDO4IjOpIjO4qjOpqjO4ZjOpZjO47jOp7jO4ETOpETO4mTOpmTO4VTOpVTO43TOp3TO4MzOpMzO4uzOpuzO4dzOpdzO4/zOp/zu4ALupALu4iLupiLu4RLupRLu4zLupzLu4IrupIru4qrupqru4ZrupZru47/A8/EDhA= + + + + + AQAAAACAAAAgEAAAugMAAA==eJztll1IVEEUxxXXwlREySSyF/ODSunrQUtzeqioZE2kRDNCVBJRiciynsSiDDSikDLxq0xNJVrSHtZKI9vWXLO1LdfdJRTvprumNSh+W2Zxz1zurMOuqW/Ny2H+98ycub/538O1s/szetHfYKfmYy8V1VaesyKdb2LkmRj5ahvX0XPWfqxzLbYOiwddn/V+rHW2notVhx6YobPy6Hxrc2t5tkbWUDOes97XROlqRp1ehm6ywoE+D2bwx9T90Oehx2Lf51/X0+ej910sp6XyoLnSvqDr0/uw/LTU/ZbbN8t9Lnp/W3lDXjcVQTcy9G7qOZ2/2HXW6rPqrNS5BX7th7K2ZEnfobiaCeXkbBfRr5ZsCAxu5lCywrfXyLUTvXhK6qWScWgqvN/fe5+Z6GbHRscXq7tR/pxPxZ0wQQ/r079pfN+DsprHA4NdOKIXJWSMepSbkKRKnZiaKOixDR97wqa7kKra/6n3YCvRsWdRWkFxO3LIKAmITBfyjzTozm/cMYicZWPPo4q0RF97zbylcIhD36KTdnc8NBC9VqfJe+07iCCSuvdk6rF0JTrGR9BhTue7RZQdXDdf963m8teqUCF/ytUvtdVej56Uuo//KNQhb0lK8s25Ngt+jzrGlauUJgve0VslxVdyjERX8/fTaZ95rtJVZcHbPcej6taAjuihPO/J+lN7gkJ1FrxdYi5oLiqE+4njeU/7KWRJAToL3rMBjg+0O40WvPNjIrnCoD4L3nUMrrEUV8ijdZgDX5p37fYJyfVdwv1P87zBj8CXfwviX+ALejzvd/A/6Hm8f4Ev6OBf8DPoDrx/gS/oH3j/gp9Bl/D+HeL5gg7+Bb6gg3+BL+jAT+xXjBb2NyZ5sVQ++FfMG6N63r/gZ9DFfQITfuI+gQlvcZ/A5H7EfQIT3uI+gQlvcZ/AhLe4T2DCW9wnMAI/i/sEJrzFfQIT3jTHWgb32AX7hMBd3Ccw4Q19AnTg/b8v83VXqC/biQZG99eXyW4YzEhZntses0b47iuafI+ecZjvu6o2r/0/BT+1cCOnO2o5JB+O8Qw3DBB92JBTKpVqkUl+wGtzhIrov86Gyy8dn+/jer00PETYf5Lb5pxw24Cyq/ucMiqEvtK9KSFkbMyMQvviH5fVCHUbOg83RbVoUfaJtNwZN+H7cfp8N1lTyaHMrpSyZz7Cf5e+QNP0ZcaIvo9oVXsVPRZ+raP8mmufJX8lH0RtJ1+OKqTW+8fC38MnPvZbmdua12/jelsjvV6IvwH85BpO + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAADgRAAAHAwAAA==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 + + + AQAAAACAAAA4EQAADQMAAA==eJw11xGDAgYAQOHb1rYgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIKDgyAIgiAIgiAIgiAIgiAIgsF9e/L9hhf4+i3IEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvssMse+xxwyBHHnHDKGedc8Js/XHLFNTfccsc9DzzyxDMvvPLGOx988sU3P/z645cAgwwxzAijjDHOBJNMMc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAYccccwJp5xxzgW/+cMlV1xzwy133PPAI08888Irb7zzwSdffPPDrz9/CTDIEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvssMse+xxwyBHHnHDKGedc8Js/XHLFNTfccsc9DzzyxDMvvPLGOx988sU3P/z665cAgwwxzAijjDHOBJNMMc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAYccccwJp5xxzgW/+cMlV1xzwy133PPAI08888Irb7zzwSdffPPDrwAYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdthlj30OOOSIY0445YxzLvjNHy654pobbrnjngceeeKZF155450PPvnimx9+/f1LgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaHXfbY54BDjjjmhFPOOOeC3/zhkiuuueGWO+554JEnnnnhlTfe+eCTL7754dc/vwQYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdthlj30OOOSIY0445YxzLvjNHy654pobbrnjngceeeKZF155450PPvnimx9+/ftLgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaHXfbY54BDjjjmhFPOOOeC3/zhkiuuueGWO+554JEnnnnhlTfe+eCTL7754f/DH2CQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZYZc99jngkCOOOeGUM/4HDTwQgA== + + + AQAAAACAAAAnAgAADwAAAA==eJzj4hoFo4AgAAA3+BWH + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_13.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_13.vtu new file mode 100644 index 00000000000..27014251d88 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_13.vtu @@ -0,0 +1,50 @@ + + + + + + + AQAAAACAAAAgBQAAHwEAAA==eJwtxddCCAAAAMBKhVCaKFQiLQ1JES1CQmmJ0lIJoVJmpZA0JTMr1Y966O7lAgI2BTrIWxzsEId6q7d5u8O8wzu9y+GO8G5HOsrRjnGs47zHe73P8U7wfh/wQSc6yck+5BQf9hGn+qjTnO4MZzrLx5ztHOc6z8ed7xMu8EkXusinfNrFPuOzLnGpy1zuCp/zeVf6gi/6kqt82dW+4qu+5hrX+rrrXO8GN7rJN9zsm77lFrf6ttvc7g53ust33O0e9/qu+3zP9/3A/X7oR37sAQ96yE887BE/9TM/9wu/9CuPeszjfu0JT/qN3/qdp/ze0/7gGc96zvNe8KI/esmfvOzP/uKv/ubv/uEV//Qv//Yf//Wq/3nN697wf8cnNDc= + + + AQAAAACAAAAgBQAAHgAAAA==eJxjZIAARiJpWoOBsne4gYGOx1EwCoYDAAA98AAO + + + AQAAAACAAAAgBQAAIwAAAA==eJxjZEAFjAz4ASMBmlKAyxxq2zPSAa3jcRSMguEAADzIAA4= + + + + + AQAAAACAAAAECAAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8YjDABSAAgI= + + + AQAAAACAAAAIEAAAMgMAAA==eJwtxUMQGAYAALDatr3atr3atm3bttbVtm3btm0bu1uTT5IGDPC/ZE7uFE7pVE7tNE7rdE7vDM7oTM7sLM7qbM7uHM7pXM7tPM7rfM7vAi7oQi7sIi7qYi7uEi7pv13KpV3GZV3O5V3BFV3JlV3FVV3N1V3DNV3LtV3HdV3P9d3ADd3Ijd3ETd3Mzd3CLd3Krd3Gbd3O7d3BHd3Jnd3FXd3N3d3DPd3Lvd3Hfd3P/T3AAz3Igz3EQz3Mwz3CIz3Koz3GYz3O4z3BEz3Jkz3FUz3N/3i6//UMz/Qsz/Ycz/U8z/cCL/QiL/YSL/UyL/cKr/Qqr/Yar/U6r/cGb/Qmb/YWb/U2b/cO7/Qu7/Ye7/U+7/cBH/QhH/YRH/UxH/cJn/Qpn/YZn/U5n/cFX/QlX/YVX/U1X/cN3/Qt3/Yd3/U93/cDP/QjP/YTP/UzP/cLv/Qrv/Ybv/U7v/cHf/Qnf/YXf/U3f/cP//Qv/3aAQH8K6EAO7CAO6mAO7hAO6VAO7TAO63AO7wiO6EiO7CiO6miO7hiO6ViO7TiO63iO7wRO6ERO7CT+y0mdzMmdwimdyqmdxmmdzumdwRmdyZmdxVmdzdmdwzmdy7mdx3mdz/ldwAVdyIVdxEVdzMVdwiX9t0u5tMu4rMu5vCu4oiu5squ4qqu5umu4pmu5tuu4ruu5vhu4oRu5sZu4qZu5uVu4pVu5tdu4rdu5vTu4ozu5s7u4q7u5u3u4p3u5t/u4r/u5vwd4oAd5sId4qId5uEd4pEd5tMd4rMd5vCd4oid5sqd4qqf5H0/3v57hmZ7l2Z7juZ7n+V7ghV7kxV7ipV7m5V7hlV7l1V7jtV7n9d7gjd7kzd7ird7m7d7hnd7l3d7jvd7n/T7ggz7kwz7ioz7m4z7hkz7l0z7jsz7n877gi77ky77iq77m677hm77l277ju77n+37gh37kx37ip37m537hl37l137jt37n9/7gj/7kz/7ir/7m7/7hn/7l3w4Q+E8BHciBHcRBHczBHcIhHcqhHcZhHc7hHcERHcmRHcVRHc3RHcMxHcuxHcdxHc/xncAJnciJncR/Oan/A4daAoU= + + + + + AQAAAACAAABgDwAAswQAAA==eJytlH9M1GUcxx/iqBGIk4mMoLUIIRUsbQ4L4uNaVupOCI1BajFkOVKWlUm2NcI0mmiGY4aMX0F3yIVxBW4dFboQDznE73Hz7rizQfc9ujuEusn4IT+ics/n++375HdI+vzz7Hl9P89zz/N63vcQ8k/rh1sd4Wjfz/SczHe3TL1bpp6TmeeWmcfWzbUPuXXZerZ5ZbhcHVs/13iuujvtsbG+5Xq5+5TzMte9so2T4XL1boZzc5yP5W4Z7mXOw3J2P17mnOx+2Dbf8/zf+ez+2HXn6+lufbBe2Tyyv8+uI5fju13vXufmXu+LXf9OfWOdlemRO2W4lfnO1rPz5jtfbh9sPSHD9oJKpdICQ7r1ocs2GQRe2xqV/Jbv32NDZ+jzM7zA2/gbb3RreNANp4Uk2V0C/zKsSnvM7gF9dWFX2oNWgf/5dpLuwCuXwGizKZPWinyCfyIg84Qd8usc/rm1fQL3v/pFtknFwz7zrqqzkeL9NBs3tKa0WSD/1d2FUws9Arc+lrl2dNQDCY5tZ6rqxX3aSkytv0w54fcbFsOz7eL66ae03OgePXzdayr6OWpQ4IU+ebrzukHo3P7TSLtS5FtpPc5DrqHz8XuEYlf28dlO4Xv5TWWoQctD6gpF+ccFToFzL+Utz1NegtPdY/r79WKeDleEx8af48Hos+9d1QLxHjx+LX4/PmCFRQXB6mJXr8ATHLYLLZf7YKLptWfiEkRelpk7Elzthsml7dqdMSL3hpTtLinvgsC0/ab320V/Gc09fYmTZpiO8auxrBb3ubG5972HVw3C0bTNfGmcQ+CLP/EsLx3i/+MvXcYT1rEcxws3Vb2wZJW4Do41T44rPn1KvM/JBUtzOnxsgs8u6pGeDtTU5yHqETneC94HcvSMfpGjZ/SLHD2jX4FTz+gXOXpOp36RT1HP6Bd5EfUcTP0iv31evXB7r2I9y4Oo1yCJby/UU8/oF/n4hY664gLRS2Z7VL+T7wJ9YLYxp1LkN5N+i45Y54GuuKw1NQ0egWfUj+snps0QMBM58+i0eJ6js5G1JxM94PjsREVkmPhO7z83FhsfyEPJhxtXN+dfFvh9ai4rJ4sHk2rJ578edArcUBf9XcRgBxz6IGzAZhXvQ5FbEbN5Dw/2laceP5Ignj9AO/pDSpkFro3Eaq5Ei/u/nrrz6e6v7KBh/LL/b5az9VjXZjo4oP7X7+JYcSDXED7rEPi3lYvG/ijtFfxJ80nINupPmnNCsuk9HJbknJAi6lWaZ0LyqNdESZ4J8aVepXkm5Ar1miHJLSHodUiSc0LQqzTPhKDXxZI8i+/BVpn3VMO8K3Lv70XqlX0/mtCrJM/YvIJPzCdy9Il+keO94D0hR8+YZ+ToGb0jR88K6h05vg+YZ+T4nvhS78jRM3pHjp7RO3K5vKJPNt84ZuvR80Um3+i5kXrvKTHHWE+7QLXsTLL2ZYswZvkOc6o2+RsOQuJONjTWuOB6T86WlB1OYczyqyqTurqFg3WN59e83sDBc7d6K+05eHPFkb26cCOcDVn//bVjTmG8xdFUU9zE0d4K5iD1yni1C94ZNujII0bQjQ1s/+i4E170f6g2f68L/gI0o0lX + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAgQAAAaQsAAA==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 + + + AQAAAACAAAAIEAAA3QIAAA==eJw11xGDAgYAQOG2tS0IgiAIgiA4CIIgCIIgCIIgCIIgCILgIAiCIAiCIAiCIAiCIAiCIAiCIAiC4CAIgsF9e/L9hhcM/BZimBFGGWOcCSaZ4hfTzDDLHPMssMgSy6ywyhrrbLDJFtvssMtv9tjngEOOOOaEU84454JLrrjmhlvuuOeBR5545oVX3njng0/+8MU3Pwz88UuQIYYZYZQxxplgkil+Mc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ67/GaPfQ445IhjTjjljHMuuOSKa2645Y57HnjkiWdeeOWNdz745A9ffPPDwJ+/BBlimBFGGWOcCSaZ4hfTzDDLHPMssMgSy6ywyhrrbLDJFtvssMtv9tjngEOOOOaEU84454JLrrjmhlvuuOeBR5545oVX3njng0/+8MU3Pwz89UuQIYYZYZQxxplgkil+Mc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ67/GaPfQ445IhjTjjljHMuuOSKa2645Y57HnjkiWdeeOWNdz745A9ffPPDQBAMMcwIo4wxzgSTTPGLaWaYZY55FlhkiWVWWGWNdTbYZIttdtjlN3vsc8AhRxxzwilnnHPBJVdcc8Mtd9zzwCNPPPPCK2+888Enf/jimx8G/v4lyBDDjDDKGONMMMkUv5hmhlnmmGeBRZZYZoVV1lhng0222GaHXX6zxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPKHL775YeCfX4IMMcwIo4wxzgSTTPGLaWaYZY55FlhkiWVWWGWNdTbYZIttdtjlN3vsc8AhRxxzwilnnHPBJVdcc8Mtd9zzwCNPPPPCK2+888Enf/jimx8G/v0lyBDDjDDKGONMMMkUv5hmhlnmmGeBRZZYZoVV1lhng0222GaHXX6zxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPKHL7754f/DH+R/ajYDJA== + + + AQAAAACAAAABAgAADgAAAA==eJzj4hoFIxoAACE3FAs= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_2.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_2.vtu new file mode 100644 index 00000000000..b9dfaeb42e8 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_2.vtu @@ -0,0 +1,47 @@ + + + + + + + AQAAAACAAADQBAAADQEAAA==eJwtxddCCAAAAMBIKtIikWhoSIOMlrSXdkR70KBQSSFNRaWMpFR/66G7lwsIOHbCJx3oUw7yaQc7xKE+47MO8zmHO8KRjnK0z/uCY3zRsb7ky47zFcf7qq85wYlOcrKvO8WpTnO6bzjDN53pLGc7x7d827m+47u+5/vOc74LXOgiP3CxH7rEpS5zuStc6SpXu8a1rvMj17vBjW5ys1vc6jY/9hO3+6mfucOd7nK3e9zrPvd7wIN+7hce8rBHPOqXfuUxj/u13/itJzzpKb/ztN97xrP+4I/+5Dl/9rwXvOglL3vFX7zqNX/1N697w5v+7i1v+4d/+pd/e8d/vOu/3vO+//nAhz7yf1aOLgY= + + + AQAAAACAAADQBAAAHwAAAA==eJxjZIAARhw0pQCXudQyf7iD0fAbBaOAeAAANgAADQ== + + + + + AQAAAACAAAAgBwAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpHMQoGAGOKAck= + + + AQAAAACAAABADgAA4wIAAA==eJwtxVOAEAYAANDrsm3bdpcv27brLl225oUtDplbHGqrLbvLvGxctvnRez9vY8Bnm7zZW7zV27zdO7zTu7zbe7zX+xzu/T7ggz7kwz7ioz7m4z7hkz7lCJ/2GZ/1OZ/3BV/0JV/2FV/1NV/3Dd/0LUf6tu/4ru/5vh/4oR/5sZ/4qZ/5uV/4pV/5td/4rd/5vT/4owOiyIGO6miO7hiO6ViO7TiO63iO7wRO6ERO7CRO6mRO7hRO6VRO7TRO63RO7wzO6EzO7CzO6mzO7hzO6VzO7TzO63zO7wIu6EIu7CIu6mIu7hIu6VIu7TIOclmXc3lXcEVXcmUHu4qrupqru4ZrupZru47rup7ru4EbupEbu4mbupmbu4VbupVbu43bup3bu4M7upM7u4u7upu7u4d7updDHOre7uO+7uf+DvMAD/QgD/YQD/UwD/cIj/Qoj/YYj/U4j/cEf+Ev/ZW/9jf+1t/5e0/0JE/2FP/gHz3V0zzdMzzTs/yTf/Yv/tWzPcdzPc/zvcALvciLvcRLvcy/+Xcv9wqv9Cqv9hr/4T/9l//2Wq/zP/7X673B//l/b/Qmb/YWb/U2b/cO7/Qu7/Ye7/U+h3u/D/igD/mwj/ioj/m4T/ikTznCp33GZ33O533BF33Jl33FV33N133DN33Lkb7tO77re77vB37oR37sJ37qZ37uF37pV37tN37rd37vD/7ogMDPRXGgozqaozuGYzqWYzuO4zqe4zuBEzqREzuJkzqZkzuFUzqVUzuN0zqd0zuDMzqTMzuLszqbszuHczqXczuP8zqf87uAC7qQC7uIi7qYi7uES7qUS7uMg1zW5VzeFVzRlVzZwa7iqq7m6q7hmq7l2q7juq7n+m7ghm7kxm7ipm7m5m7hlm7l1m7jtm7n9u7gju7kzu7iru7m7u7hnu7lEIe6t/u4r/u5v8M8wAM9yIM9xEM9zMM9wiM9yqM9xmM9zuM9wZ8AZXbeJQ== + + + + + AQAAAACAAABwDgAA8wQAAA==eJytlXtQ1FUUx5eAGsUxHAlCaRRkWEkDEjIcjGMN2cQrckB55EQIliOUTBbJBIgTrQIyQEZgI2/YAGGAIYMxsQHXFZb2wSosuyjL/hbYXSV/g/IwoG3Fvb+fXHZbTO8fe+d+f3fvPedzz3wPg/FwCGFhYsj1M1qrlqmrsO+4jg/SiG5sH77f1NrUvuXOaMiXycHYbIyP3EjcQiO6sf04Z6GJPHBdZYIzHg9pJH4SyxePBx9Pms///T8eH37uk3J6Wh44V7zu8Pvxc4zV69Oe96zr5lnHhZ+/XN4SbD9aKzB98NF8nFiso7W1bLH+jYK655fAcFXyBR52PoMxvelO3J5pAoqy/v5BsENN6RZeqeOiL9Wwbgtn+/7AfkrPOXIkNMhaArYq+yavnWosDzmcHxBndTjT92ZMVY+YbedBvt/GwPu7lJTu6cIyb2i+BZZXvNfW1PVSelxyaMRMggr8Na8HR/oQlM5ztf3ebVAMHoeH354rv4rdq4TGqbCT2fJOSq9diEMDaEZ6aFGjcDKeu0QvdHNWWAZpIDH+oKd1HH1+g01La9XvBHyVydxQsE9K6acyIt5pre+AoQDnjz8z64Q7be/auQbwqO/jsvTioCAdN163nd88nUdFu/MHX5jzoG1870u+sjFK7yQmDvJrCeCWsnr2rqTfp8y+pPG0TA0iqTTI15vW/0n0bTsW1gVpbMWKhIohSp8h3K2i82VwtO/Tkl+d6LpcceOnWHEVAWmRh1mzL9Lv1iJ6vz2ksx98FFH1JTV0nJJN0d6Tk2r4a6Kf9xaHPl96Rtx+c1YJdRi/cD3X7o8u3eME0TrLLKntjzYNoO/4O4RiOnoXxJPiuDBIihvihXRt9yPOiC/Su/Q8EUekI56II9JT9DwRR6Tv1PNBXJCOOCO+SEecEV+kI56II9IRN8QL6eEGOZEU/3BMN1zfJExfucbOS5dQ62iOs1xJ9AB3VazoUDGtP/AddXHYpYae12LeKD9P5xlRM82dmesDq3mnecc5Os9srVNFgc4HFDn555zsab/8+vLU1jdXEXAmxX9bS9qflP5ctTDmUAwB4irb3OETdP48tkuzg+YafJdsPyKV0P5qkXCOGRxPgMytaHOmD52nVePkxZCz/TB4b2utwIWO//aeAzv4lbIl+aM1ztGwT9AcO8UnRqofuxetLY4l8NZrFZTeVLxm6m7hABjzWWN+at3K9IpaI1niv61cbtiAzpdxn53VPhxDS3w2crVSGqXz2ZSVPzvkPOaz2/Q++wLms1EXXi21+lwFax0qlU3L8FmzhV8ltGA+i+oQ9wNTPnsU89l9dTEb2Tqfbc+6SJT/h88yFg3SCG9dvRvsa7p6MvgOJBjua3QfX8ybBMN9jQTDfY0Ew31NV/cGeaN78b5mul5x3XBfI8FwXyMB5x3cdWDEslcE2Rx3ttBcpV8PQO4WZfzdYQV8+x4/9UeBALyTmkLTy0apuJ9/UBjsWKDvb8fHgGNDzHzi2gc5N4f318+PQWxm4lxj9sjCd+vV/WCWH1AkG+Xr10PAYt5PGrykgNOer9ye4Angw9zmyI6+62DpyCzNDh6Fqw3ri29wxqh3/62h0N+BLQLJdW2tjQcfmL3rAst097tlaXrYebdgxkNbetJPBSEvK/1Tw/mw2Y1VN50hhMrdl+2UHD6cLXbfkHdKAP8CfUsO/g== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAOQAADgoAAA==eJx121e3J0UVhvEhCIjkqIAwIDkJKMEB4aCkGXJQMhyiwhAGUaLoISkI6Awiwrflgv27mGet6pt3ndNdVTu+e1d1/3du+/7aN3jk4P8G/zG4c3H/yNz3vPmuGrxy8OrBLwf3Dv43z32dv93/MvetR473I5/njf9Dxt87+Ong3zL+pcHXIu83kc869K381bv67s1z7lv36zxnfXrX3uR/fZBen+b+fwZXdjA/Ox+Y9chTfSsfvT/J8+blN3FEvgOiR+V/PHJ9FPnuG3xq8PPcJ1/j1Px3Ra7Gl/HWpx996fdRnrP+e4N7Butf8hrf/Op6Lw6yr/HGsYfxHww+OfhZ5vvr4L8Gv8j85L9p8M3owa7WE99fZdzKDk8P/mrwN4Pyw3z89suM5y9xI8757708T/5v8jc5b8zzXa/xb/4/D+7J/cZf+c3/qyf71d4u8789yH/8aX7xaJ3yifnp7bKe/GTn1gd6s0Pt++zgo4MPDbKD+BTnB+Y+/chBzxW/kxPv/XqQPY8e/P/gQYNPDB41KP5eHpR3zR/z3ZD5jH82zz+U+68O8lvz791BerZ+qXfka3z9ZZAdGx941zqdnz3Zv/z8zKB4afy/EDm6vvHGiSfjxQ07Pj9IT/4QPx/k/mOD+AXfsD+92OeIrG9e69TO7HbbYPlHXcHL5Xf+Z6fah/ziih7kp+/vB/F84/P6bftf3w7ePfhg5CQfe9AHHxr/cObZlfHs9dzgh4P0I5/4kUf0Y3d6yUf6kYd88px8t+f+W7n/bp67Lc+Xr/AE+f49iBfb/9CH38oPjwziHXbDT+rhK4ONX/kp7vQz5P/7ID1fz318u6pTxhsnX4wXL+JHH7Yv/xcfD+f+rsX/6c8v/Gpd/nsr/z8i9+/I+H15nl3Z+Y+D9Y9x5CQfXuNveYw/xL+4b3zgB3JWPvFy3WDrl7p987b9L/mkPthntH9sv1b74xU80/qMl+UJvj53UF+1I/KSj354rvnV+V/JffX9mkH2oY/5yNv63ufNU34QZ+UT+Uiu1nf2ZVfrs696r68pP4pL/FF+ZOdVnfS8uG5/TR5xzh/kw6/tn9hHPP088uN7/Eg//EG/nw2WB/BF+bH7q8Zd/e2iR+VnJ/XFPMbTh/z0If/uQfZlb/Et7uVn4//o3O/43fn/jtzv/oGdyL+Si//Zj90ey3125v97BsUHf+F5/uQ/fR258UH125Hn3X9jEK/r0/Cr+nRAnpOf9D8567FH69/Hg/q0zsvv1scH+OGdQfGFn/gZj7Of+NPXtH9jV+cgra/0Yr/qJy/VndYjeskPF/n523qtp67ul9mHfcnfeopv9afNz6vzf+uyn/gQF+qx9fGZdX+X8fRZ9RnyQ160/2q/2/z456D4Wu2n7ft7vkh/erT+i687I7/74sC49hPifXXOpZ7oI3q+KU/M03M68cVPLv4R3/wjTtgT35Kn9ZH/2F0/Zbx47LkK/5Yvez7rMk/3h+KX/W/NOuXl1tf6z3zGsws7tU92fo3nyu/kxU/4kv74Z+Xn6iNP5GftW/vIN3q0f3apf90PusRPz5fYVf3Sr5Kf3vq46i++5KU8EF/mN2/73/YV/E1++zH7s+4vd+a5O3JfHb0vz/d8t/knX9o3Nv/xl3XK99WHnuKr/dN5g/oo4/Fa97n8yb89/xFX9U/Pn9S99g/68h8Ptg/+6eDqHKDnXvgcfx87KE/KB/aDFw+2PvXc5exB/rhwcHWOf8JgzxeuHWz/QT7+X/U99MMveKH7Y/n926xbfmOn2qf80f2o+c1b/rxgsO9f2Asf9b3jqn8TB+KifMzP3T+szmH9bf9tX0QO/jSP/NEPspO8bH03zjqr87HaQf5sDvJf+yN5TM7yq3wV1+KcfeXdah/q/JNd5Av7kA9PPRD5duW51hfxiw/wBfnkEbtdNsief9q2/9V+xrnYFYPlC/Gy6jN7fib/+z7T3+cPind980bkFJ/yoft8fmxe4RNxYBz+7v675yL2P/KHXD1/PmWw788uGsTjPR/Cc+QUL/za+Ov5ff2r7zlnsOc45DJv40dct3/Br9Zvn63vaLzjie5fug/Cv60PfQ9gX1g55UP3Z+IKr9Kf3vVPzwWNI0d5p+c/6vaqj+35T/s848hX+7m/O8+Zf3MQr+CTswblcfNbHyBuVueA5lnxFH92/00+cqmjeLr7V/1Kzye3BjcGbxnED/it+wT81rht/yOve/4q/i8dxO/43rlnv184cxAv9r2dunHioLjFi3hSHIub7qPlDx4qP90Y7H15xN/iFp+Yn//UcX7kP3ZhJ/tb9sHP+Pj4QXEgD+RFzy+tK/56PkE+823mfr+/af3ovq/vh5o3zmnUTXFz/2Djs+dCLvYXvxu5z6+tH61vW1mXHNbvfOLBvqXzd79L/55/y6Pmf/vfzUF+b7/dc+nOL396fiV/mr8bg/Sv36xHL3Gv/238d9/X/bP6d8mg99/6SRe5+Jt8jZtjBumDp84YtA/3fYj9NN7pd1Q9t2Nn9lXvWkflh3pEz/b/7Yud5+qb1SvjW99qt35PQG552vMNdUMd6ftjF7t3v66f6vmyc+f2Ze3zxDFe7P6x+5+eP+s3twabv+1Le38j4xtfx0XO1mP7r76Hs48jt/18z2/0Ce1DzUde8dz9p3pN7r5/EO+nD/Y7H3rQi749z/R37c9fPX9Q/9Xhnk/pG/FQeQpPk+vgwc1B/uj3EYcM4rnuq/p+Sp2VNz8alE/9fvHQQf1vv085fNB+8oeD+px+r8q+/Fz+kp/1H7/in9U+QD6veFBdczXP5S2e6fdc6pF+dnOw30fIe7yBv/rdIn/8YnDVNzjHtW77bH5uX4WX8LA4W/VZ4rd9JrvrQ9qniH/1YtVHr/pu+slPeekcTT6yX7/vYz917rDBfkfYvhs/bR8Uh+rrxiB+2Vrc/8kgf10+2O/PxT2ePm0Qj8l7/tgclP/Nr56TtC7Kb/GMX8xrPfHUfR1+wdP03BjcGpRH9p0nDdqPq/PkEafdH+EbPIR3zMev+KH+LW+dmvnEB7/wk/H8QJ+tQf43v3pefuy5Nn/xU98blD+7Lxf3+AV/ip/Wd/G0lfv0+kHudx9AntU5oXjQr/V7Mn3yKg/aV4g/+W5+87V/X+WN8zfxJZ7KD61b6gh95RV+4D9+ZafakTziUd0Rr+Kufbt5zHtr7vc9grq2fVC9s5512N364psdyqP8xo6tv+qyvCgPnBKUd90/0n9rkP7m04fbR62+Y/wqz/V9R39v1N/1vJbn7Of6+yj39+Z+5ze+3+v0u/S+j+n3/s41+h1Hvxfs92v2m/19R/1QPvQ8Xuv3On2v1v2K58nR75bU9db5fn9Of31Kfxfwav7+Is/rd3q+t9o3fJvnXP1+S925KX/3+y11r7/72j7Y94zb85w81n/1u6f+bmpfntOvfQfmHIMV + + + AQAAAACAAABADgAAkQIAAA==eJwtxRGAKgYAANC2tS0IgiAIgiAIgiAIgoMgCIIgCIIgODgIgiAIgiAIgiA4CIIgCIIgCIIgCIIgCIIgCD70nrxg4CPksCOOOua4E0465bQzzjrnvAv+ctEll11x1TXX3XDTLX/7x2133HXPfQ889MhjTzz1zL+ee+GlV15746133vvgo08+++Krb7774adffjvw16egQw474qhjjjvhpFNOO+Osc8674C8XXXLZFVddc90NN93yt3/cdsdd99z3wEOPPPbEU8/867kXXnrltTfeeue9Dz765LMvvvrmux9++uW3A39/CjrksCOOOua4E0465bQzzjrnvAv+ctEll11x1TXX3XDTLX/7x2133HXPfQ889MhjTzz1zL+ee+GlV15746133vvgo08+++Krb7774adffjvwz6egQw474qhjjjvhpFNOO+Osc8674C8XXXLZFVddc90NN93yt3/cdsdd99z3wEOPPPbEU8/867kXXnrltTfeeue9Dz765LMvvvrmux9++uW3A0E55LAjjjrmuBNOOuW0M84657wL/nLRJZddcdU1191w0y1/+8dtd9x1z30PPPTIY0889cy/nnvhpVdee+Otd9774KNPPvviq2++++GnX3478O+noEMOO+KoY4474aRTTjvjrHPOu+AvF11y2RVXXXPdDTfd8rd/3HbHXffc98BDjzz2xFPP/Ou5F1565bU33nrnvQ8++uSzL7765rsffvrltwP/fQo65LAjjjrmuBNOOuW0M84657wL/nLRJZddcdU1191w0y1/+8dtd9x1z30PPPTIY0889cy/nnvhpVdee+Otd9774KNPPvviq2++++GnX3478P+noEMOO+KoY4474T8b8uKQ + + + AQAAAACAAADIAQAADgAAAA==eJzj4hoFwwEAAOjREdE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_23.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_23.vtu new file mode 100644 index 00000000000..34c2b70049d --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_23.vtu @@ -0,0 +1,50 @@ + + + + + + + AQAAAACAAAAgBQAAHwEAAA==eJwtxddCCAAAAMBKhVCaKFQiLQ1JES1CQmmJ0lIJoVJmpZA0JTMr1Y966O7lAgI2BTrIWxzsEId6q7d5u8O8wzu9y+GO8G5HOsrRjnGs47zHe73P8U7wfh/wQSc6yck+5BQf9hGn+qjTnO4MZzrLx5ztHOc6z8ed7xMu8EkXusinfNrFPuOzLnGpy1zuCp/zeVf6gi/6kqt82dW+4qu+5hrX+rrrXO8GN7rJN9zsm77lFrf6ttvc7g53ust33O0e9/qu+3zP9/3A/X7oR37sAQ96yE887BE/9TM/9wu/9CuPeszjfu0JT/qN3/qdp/ze0/7gGc96zvNe8KI/esmfvOzP/uKv/ubv/uEV//Qv//Yf//Wq/3nN697wf8cnNDc= + + + AQAAAACAAAAgBQAAHgAAAA==eJxjZIAARiJpWoOBsne4gYGOx1EwCoYDAAA98AAO + + + AQAAAACAAAAgBQAAIwAAAA==eJxjZEAFjAz4ASMBmlKAyxxq2zPSAa3jcRSMguEAADzIAA4= + + + + + AQAAAACAAAAACAAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8YjCAAx4AgE= + + + AQAAAACAAAAAEAAAMAMAAA==eJwtxUMQGAYAALDatm3b5srVtm3b5mqvtm3btm1bu1uTT5IFDPC/5E7hlE7l1E7jtE7n9M7gjM7kzM7irM7m7M7hnM7l3M7jvM7n/C7ggi7kwi7ioi7m4v7LJVzSpVzaZVzWf7ucy7uCK7qSK7uKq7qaq7uGa7qWa7uO67qe67uBG7qRG7uJm7qZm7uFW7qVW7uN27qd27uDO7qTO7uLu7qbu7uHe7qXe7uP+7qf+3uAB3qQB3uIh3qYh3uER3qUR3uMx3qcx/sfT/BET/JkT/FUT/N0z/BMz/Jsz/G/nut5nu8FXuhFXuwlXuplXu4VXulVXu01Xut1Xu8N3uhN3uwt3upt3u4d3uld3u093ut93u8DPuhDPuwjPupjPu4TPulTPu0zPutzPu8LvuhLvuwrvuprvu4bvulbvu07vut7vu8HfuhHfuwnfupnfu4XfulXfu03fut3fu8P/uhP/uwv/upv/u4f/ulf/u0Agf4U0IEc2EEc1MEc3CEc0qEc2mEc1uEc3hEc0ZEc2VEc1dEc3TEc07Ec23Ec1/Ec3wmc0Imc2Emc1Mmc3Cmc0qmc2mmc1umc3hmc0Zmc2Vmc1dmc3Tmc07mc23mc1/mc3wVc0IVc2EVc1MVc3H+5hEu6lEu7jMv6b5dzeVdwRVdyZVdxVVdzdddwTddybddxXddzfTdwQzdyYzdxUzdzc7dwS7dya7dxW7dze3dwR3dyZ3dxV3dzd/dwT/dyb/dxX/dzfw/wQA/yYA/xUA/zcI/wSI/yaI/xWI/zeP/jCZ7oSZ7sKZ7qaZ7uGZ7pWZ7tOf7Xcz3P873AC73Ii73ES73My73CK73Kq73Ga73O673BG73Jm73FW73N273DO73Lu73He73P+33AB33Ih33ER33Mx33CJ33Kp33GZ33O533BF33Jl33FV33N133DN33Lt33Hd33P9/3AD/3Ij/3ET/3Mz/3CL/3Kr/3Gb/3O7/3BH/3Jn/3FX/3N3/3DP/3Lvx0g8J8COpADO4iDOpiDO4RDOpRDO4zDOpzDO4IjOpIjO4qjOpqjO4ZjOpZjO47jOp7jO4ETOpETO4mT+j9zNQJc + + + + + AQAAAACAAABgDwAAwgQAAA==eJytln9M1GUcxx/iqBmggynIoD8ihLSD1Oakjvi0Fc10Z0ZGnKQxZBlD5lzGaZtjkIaFmRoRMn4FcshFkxTnoMIW4CGHcOfNu+Ouht336O4I7Sbjh/yIqD2f77fvk9+B6fPPs+d1n+/zfZ7X877njpC/mwH+6cgNpmc5jt0S9Sw3SMzjlqh3L/C5ha5L6j1s80pwqTq2fr7xfHUL7bGx3qV6qXOVOqf56thmkOBS9W6GG+bZH8vdEtzL7IPl7Hq8zP7Y9bDtXvfzf59n18fOe6+e7tcH65XNI/t+dh6pHN/vfA86Nw96Xez8C/VtZepx7JTgbL1Tot65wOcW+n6p9xBy055fqVRaYLglKXTlJj3Pa9uiXt3jOzfWd4e+NMPxvJ27/U6vloOWmynLEu0unn8VVtX0qd0DuurCnpRHrTz/c29iy4E3roDRZlMmxgt8gnvaP/2kHfLqHYtyagd4vuj6l5mmOg72mXdVXYgUzqfZ+ErblnYL5G3LLpxa4uG59Yn0+NFRDygcad9UNQjrtBWb2n6ZcsKt2xb9853C/Kmnmgyju3Xwdb+p6KeoIZ4X+qhbfmwZgu63fhjpVAp8K63H55Br6fP4eYRsV+Zns9385+V3lKH6Jg6Sn5KVf5jv5Llhg3qVWnkFzvSO6R7WCXk6XBEuX3+JA6PPvvfqAoVz8Pi1+n3/iBWC8oM1J1z9PFc4bB2tVwdg4vyO52IVAi9LzxkJrnbD5IrOpp0xAvcuK8suLu+BgJRc0/5OwZ+q+dpAwqQZpmP8aixrhXVubO5//7E1Q3A0ZTNXGuvg+dKPPKtKh7n/+EuV8IR1LMfxkk1VL4esEebBsXb1uOzIM8J5TgauyOrysfE+e6hHujvQUJ+HqEfkeC54HsjRM/pFjp7RL3L0jH55Tj2jX+ToOZX6RT5FPaNf5EXUczD1i/zuefXC3b0K9SxfTL0uFvn2QgP1jH6Rj3d01Z/IF7ykd0bdcHI9oAvINGZVCvxO4m/RES94oCc2Y11No4fnqoZx3cS0GfxnImcenxb2c3Q2srYkwQOOYycrIsOEezr30ph8fQAHxQc3rm3Ou8rzhzSGjKwMDkx1Icd/LXDyXF8ffS5iqAsOfRA2aLMK5yHLqYjZvJsDe9ypJz9RCPv3bxr9bkuZBX4ekWv7ooX1/56889ne03bQMn7Z7zfL2XqsazcVDGr+9V4cyw7k6MNnHTz/tjJo7I/Sft6fOJ+EpFF/4pwTkknP4bAo54QUUa/iPBOipl4TRHkmxJd6FeeZkD7qVSXKLSHodViUc0LQqzjPhKDXpaI8C/fBVon7VMvcK1L372Xqlb0/zqNXUZ6xeXmfmE/k6BP9IsdzwXNCjp4xz8jRM3pHjp5l1DtyvB8wz8jxPvGl3pGjZ/SOHD2jd+RSeUWfbL5xzNaj58tMvtHzWep9+Y7P1yVfmPsde7G/OO0LAx27IC57pTXmTSdcKzbHWM+4+N4r7/t47wYL7C9xdcSfdvH9kazlCl2aE9R0HGxanXvsogHCG/cYO26ZYfD143GKICMEmi++m6F2gXybXPV2kgVCYksaz9a44HqdSVPdaoCixsTtr6mcEKo62FpzzsD3Hk1B0va5/z0s/wtJBkXd + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAQAAAeAsAAA==eJyF2+mzXFUVxuFAomEUJBJwJAwiiKKoSJzwEiAMyiCCjMqVBBQZDDEqoOBFAVGjGCQaIImt+Uf5wHqs4ld1yv7yVvc+Zw9rvWvae/fWTe99/j74gcGjg2v5/dq0b8/vuwaPDX4z/Zw7+N98//bgNwZPpP/rBr81eDzjGWfb4L/znt/1/5/0Z3zzWQ2+OUg+Wwet37o/MriW9lMzT88fy/Pmv3mQfMzX/D44eCLPe984Xf+WwcrvlDxX+RjXe/pZDT4/ePvgd9K//sj1nPRLHuR0ctbR99YGq+9deU679fmYz3VB6/P+9k3v/5B79eFT+bbfLe9//H/vG886y8dr89zaIL6xy5PT7j3y8X71XPv1HHnqF8/0X75tzvPafzLIft4aPJrv2t9M+z/TP578bfD7gz9a6P+dwb8Osl/2ZX7kaB7eP5x5dHz967f2ezjPe599GveNtB9L++t5TvuvB3cP3jnIfv8xaP3ma35vD/5p8MXM76eD+wb3Z/zKw/q9b95PDf4r7z8xSA/Vn/6so/Onf++VP88MWid9mN9Ng3cP/nCQf9W/fuv/Dwzyg/V//Mb1gyelf/Mid3I0v4cGvzd4w+BqkP75OTygf/L/8SA9kP9zg78arH5+m3HKL/M378pXf3hrPvr/S/rdSP/0Qy93DJLfbzIP+q78yO22wdUgfj86iOfmR670XP3i5UuDrw3i54OD7O9I2vHDOvHkRNrFj1szf/0a5770b77i842ZP73QEx5Yv/6ts/OvvMhR//xD49ShQfo6nOfpj1/nJ+ofyIf9kiP5sQd6vGUQv8gTP/S3GmSX/FDtk13htXWSh/70z471Tx7e41/I58+DLw+W//SCd9XPq4N/GPz5oPXjB16QU/lt/Xiuf/2SR/uv/q0L7/Dn84PscX+ew8vGx+YF5CleG3dtcCl/lwfJq/QvL5NHyWuan2/L8/Qjn9OvcY7nuzyq9cv2/C5/I1/2ye6b34hLPxvkB4xvvuZnvqtB8Yrd4Ifxd6e98aF5L3u4eRBf8OiXg9ZvfmuZJ/3h7SMZz/roFw+W+ENuxql/JofWp/Sm3+Y/9EVunZ/f9Wsc8iNP8t1IO7/DrppPPja4Pnj/YOVnXrV//kZcqn/1HjmpW1aD9w6S5yt5n3/68mD50P59jENvS3VK6x98Ysfe00/9hc8SD3xfqjPL/9bb+Ny6E2/X0l57bfzAQ++z59bR9Ud+X6qn+/xSvVw/RR+tJ83TvMir88A7PBQH8Uf+KE+t/2l8kZ+IMz70WP8kL5I3y5f5D/mn+kkeyv7FY/FZnsYerEt+K95bnw/e1B9v5Hv9B/tjd79L/6/kubsyP/mzvPnJwdXgDwb5mfqX2sV3M1/+nt3zA+y//uuzGUf+xs72ZH6NF0+nnZ6rf7x7dvCFQTwnX3KR3zU/r1/14Xeb35uPfpoP/DHj3zP4wGD3Lx8fxFfyaPyn74cH8eNg2rel3bjk2/HJkd22/sUHH3IiH/M3772Zv/n8fpB8yAtflnhKn7/I+PqnB3ppPq8/6zfOKv3jj3nRX+2PfV6S3z13V9qNTz7l9960P5Z2eUP9svzZ/NkB+ZAX/tF7+UMv9FQ+GU9/xsPXxmfxxD6Q9Vg3PawGW1/TI16WL/wO/ViP+dJH/af2g2nHX3HHuvCL/PCGPZk/v4g/9GB+1Yd9iuP53bj70r4vz3V/z/jkYx4d3/5Q53cgz2k3njwVD8s/vOl5Efm2Xluqr8xff+ZHP+yk+xf4gCf4rD/+a2mfgV7xsvo9N7+3PlX3ktfS/jA51N/zt9bd+MF+rJ8d6e9Tg12ffQNxS/1V/2z/hNxaH+E/O+3+iLpVHVv+6te+RPff9W9/qOdn5E/e1m18+Y+8p/6TPPFEPdP6l1yan5gfP1P/Yn38Sv1N9cIO6U2eu+SH8Omrg/bh7MudP1j50ZNx2YG4XX40DtEffTVO4IfxGmdWg+Qt/1cPkP/XMg4+4ssXB3v+ra7mD+X95El+fc85hn6N03nYV8NnesH3nh/QQ88B+Bc8LT8/M9j9IftG1mN9PR9o/MQD87Ge5mHdP6E3euz5vvH4ue6PPJvn6Rev8Kz2y686x6l/VY+pz1r/qMvkZa3P7KfR2ycG+UPxU53TPFC/7Lr5g/nwC81H2LV96O4/808bg60P6QOvmr/Sc3mAf+I7f9P4gNf0RC6ND/xn46u6Wp3d/cHuu7M78ui5pPHYI39sfkv+ndzoB99bd+EXPcljuj8lfzVvcbf1Tve35Ene579bx+BZ9SI+0FvPnRsHGt8/Prgnz3tfviJ+4D//3Phofc5X+Sv+CR/YR88f8Jd98E/sR51HT83H6hf5CfPAp/p3/MKj8ox/Z7/8S+N3676eP5Mf/0d/5Nd5tQ5ybrae55pfinOtF+gVn3q+Kn7hU/03e2Xf7Lnnw+LPNZlX86/LB9kpe+7+29cHrxpcuodA33jivPFo2i8bfCvP9V5A7ZM8en5Fnq1f1zO+dX9skN3Zd+K3PzrY8+7aV/ltXkt+gL/j/7r/ys8Zp+fP9LWUp/T8ufonp/o5/Kl+e8+BXeJJ+SFey1vFc/6u9VDvR9pP6D6//i4crPw28nvjCvk2nnS/zvg+3R/+3OBSHcUv8zP1L3iFb+UXv8p+8It8yrvaET6LK73nYJ5dh7yCPHu/htzNF/9aX140uDHY+yj8Ij52/588LxjsfQsfeur+t3HLA3kHuXV/AB/wu/fklvIL9iHPkM+dNyj+iKPWx7+3/ubX64fZJz2xp9Y3fu85JD7wJ/L05ufiJh40P5dv0OvGIH7TR+3IfOSd4l7zT3oyTvtXX/FH5I8/j+e5tvP/7KT5af2L8fFLviH/aP5Ez/KQ5h89F+9+Sc/Xe95SXjnvwju8lJes531xjz9o/Ov9iaX9sd7T7v10frf7R9bfewjdj+z5N/l1/633B1q3/r/72d3f7L2U7q+Ri/d6v+qUtPd+Sc+7u39av9f7kPWvvc/Q+zG9X957793/0Z+49clB+2L8Kf/Q809+lJ+pf+l9pCsHxQH5Cb/Q/JgfaZ6Az+y38Yt82MUXBntfmj3vHOx9MP32nFP/64NXDIrj6obeX7x08Eh+fzDt5Nm6pfcp8VEeKI6pP8m3+TM5N//ufW/j9n4AnsjjrZscrJ/fxoPqX/zo/Vv20HO7Tw/SD7/I/148iKfiYOMj/jRvaH6JD61Pyan5u3yD/po/tP4VV8W/Lw2SN3+9dE6Ax72/JJ/vvn7PE3r/s/tZeEnurcfJW97Q/T72hg/skBzEM+/vGKQHdkIP7NT45Cb/rvz4la8Myq/kXdZpn06+Lj9n9+Jtz6/l1Uv3ZOQbreOcq6vXek9T/Wj/ZKlOU4e1TrOvol7oPXz1a+XSfcIdg0v3iDYGxSn+mH/svWL5DHnT74cGu598+iB+9L7PaYPyvN63aVy1nyfu9n7S2YP801mD3bfAZ/UwuX14kDz5S3Z+5iB+sufW0fxW7Y4/7P2G+j3t6ij5xBmD6gj+o3ES7/BoKU623uo5Ru8l9D5Qz6XUad3/7T0L/lf+z7/2nMx9KDzvftrSvWlxqveq6qebV9ObvFsc7TmSOH/1oHjN7sXn9UFxtfe3yKP/O5PPbkr70v/1+r/B/p/Np//fa3v/H9f59f+sbff70vj9P+VS3srOa7+NQ40//M2OQX6Fn6FX/qV5Gz92JLgz7c1fzMP4/GT3jcxDnOJP+Bl+pfkZ/pBH8zN8r/+rX8NXfk8c2DEoTogD9aviGL+r3/6PTlwjn8YB/o48+cnGD36Xvdb/4oU4ST7k1n0//lPct66lffjuv9OffKBxlzz4K/MVX7u/1nmJaz1XPSO/izfy1qU88lDaux/e/V519dI+Vf9H1f2I1WDvyd6W5/ldPO692cbpo3lufbD/b6w/Lt89T1/vAq9muAw= + + + AQAAAACAAAAAEAAA3AIAAA==eJw11xGDAgYAQOG2tS0IgiAIgiAIgoMgCIIgCIIgCIIgCIIgCIKDIAiCIAiCIAiCIAiCIAiCIAiC4CAIgsF9e/L9hhcM/BZimBFGGWOcCSaZYpoZfjHLHPMssMgSy6ywyhrrbLDJFtvssMse+xzwm0OOOOaEU84454JLrrjmhlvuuOeBR5545oVX3njng0/+8MU3Pwz88UuQIYYZYZQxxplgkimmmeEXs8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAb855IhjTjjljHMuuOSKa2645Y57HnjkiWdeeOWNdz745A9ffPPDwJ+/BBlimBFGGWOcCSaZYpoZfjHLHPMssMgSy6ywyhrrbLDJFtvssMse+xzwm0OOOOaEU84454JLrrjmhlvuuOeBR5545oVX3njng0/+8MU3Pwz89UuQIYYZYZQxxplgkimmmeEXs8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAb855IhjTjjljHMuuOSKa2645Y57HnjkiWdeeOWNdz745A9ffPPDQBAMMcwIo4wxzgSTTDHNDL+YZY55FlhkiWVWWGWNdTbYZIttdthlj30O+M0hRxxzwilnnHPBJVdcc8Mtd9zzwCNPPPPCK2+888Enf/jimx8G/v4lyBDDjDDKGONMMMkU08zwi1nmmGeBRZZYZoVV1lhng0222GaHXfbY54DfHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPKHL775YeCfX4IMMcwIo4wxzgSTTDHNDL+YZY55FlhkiWVWWGWNdTbYZIttdthlj30O+M0hRxxzwilnnHPBJVdcc8Mtd9zzwCNPPPPCK2+888Enf/jimx8G/v0lyBDDjDDKGONMMMkU08zwi1nmmGeBRZZYZoVV1lhng0222GaHXfbY54DfHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPKHL7754f/D/x9RHgMY + + + AQAAAACAAAAAAgAADgAAAA==eJzj4hoFIxkAAA0sFAE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_3.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_3.vtu new file mode 100644 index 00000000000..89b831deaf3 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_mesh_tet_DFN_3.vtu @@ -0,0 +1,47 @@ + + + + + + + AQAAAACAAADIBAAACgEAAA==eJwtxdciEAAAAEDZO6QSEUIhKaQiIxnZ2ZQKldUgyaqUpMhMic/14O7lAgJOnHKggxzsEIc6zOGOcKSjHO0Yx/q04xzvBJ9xos/6nM87yRec7BRfdKrTfMnpznCmLzvL2c7xFV91rvOc72su8HUX+oZvusjFLvEtl/q27/iuy1zue65wpatc7fuu8QPXus71bvBDN7rJzW5xq9vc7kfucKe73O0e97rP/R7wYz/xoJ/6mZ97yMMe8Qu/9CuPeszjnvCkX/uN3/qdpzzt957xB8/6o+c87wUvesmf/NlfvOyv/uYVf/eqf3jNP/3L697wb296y9ve8a73/Mf7/ut/PvB/H/rIx+ZALW0= + + + AQAAAACAAADIBAAAHwAAAA==eJxjZIAARhw0pQCXudQyf7iD0fAbBaOAMAAANZgADQ== + + + + + AQAAAACAAAAEBwAAGQAAAA==eJxjZGBgYBzFo3gUj+JRPIpHIAYAMeIBwg== + + + AQAAAACAAAAIDgAA2wIAAA==eJwtxVVgCAgAANCZ7s5hupnumO7unu5uwx3Xp7tdH9fBHac7ppvpmM10N/fhvZ+3MeC9Td7sLd7qbd7uHd7pXd7tPd7rfY7wfh/wQR/yYR/xUR/zcZ/wSZ/yaZ/xWUf6nM/7gi/6ki/7iq/6mq87yjcc7RjfdKxv+bbv+K7v+b4f+KEf+bGf+Kmf+blf+KVf+bXf+K3fOSCOHOi4juf4TuCETuTETuKkTubkTuGUTuXUTuO0Tuf0zuCMzuTMzuIgZ3U2Z3ewczinczm38ziv8zm/C7igC7mwi7ioiznExV3CJV3KpV3GZV3O5V3BFV3JlV3FVV3Noa7uGq7pWq7tOq7req7vBm7oRm7sJm7qZm7uFm7pVm7tNm7rdm7vDu7oTu7sLu7qMHdzd/dwT/dyb/dxX/dzfw/wQA/yYA/xUA/zcI/wSI/yaI/xWI/zeId7gid6kj/wh57sKf7IH/sTf+rP/Lm/8Jee6mme7hme6Vme7Tme63me7wVe6EVe7CVe6mVe7hX+yl/7G3/r7/y9f/CPXulV/sk/+xf/6t/8u//wn/7Lf3u11/gf/+u1Xuf/vN4bvNGbvNlbvNXbvN07vNO7vNt7vNf7HOH9PuCDPuTDPuKjPubjPuGTPuXTPuOzjvQ5n/cFX/QlX/YVX/U1X3eUbzjaMb7pWN/ybd/xXd/zfT/wQz/yYz/xUz/zc7/wS7/ya7/xW79zQOD74jjQcR3P8Z3ACZ3IiZ3ESZ3MyZ3CKZ3KqZ3GaZ3O6Z3BGZ3JmZ3FQc7qbM7uYOdwTudybudxXudzfhdwQRdyYRdxURdziIu7hEu6lEu7jMu6nMu7giu6kiu7iqu6mkNd3TVc07Vc23Vc1/Vc3w3c0I3c2E3c1M3c3C3c0q3c2m3c1u3c3h3c0Z3c2V3c1WHu5u7u4Z7u5d7u477u5/4e4IEe5MEe4qEe5uEe4ZEe5dEe47Ee5/EO9wT/DyDM2pc= + + + + + AQAAAACAAABYDgAA8AQAAA==eJytlX1QVFUYhxeFqRUjyIIhmYmQgSwiUzAYlJeM/khZAweQjxyZFUxcCJhMhQlBjAghhshIagQEAQFBUDLI2grEVRZlcY1ddklw79LuktQN40M+ohX33Ose7m0xPX/smfvsveec9zlnfofDudskwDHqBwy91gTXYlzCwvFGsnC29/D3TT2bem+hPWp4fbiHAZaezQ/+Ht4kLJztfS3GJSbqwLnWhGd8PSTL+kmsbnw9eHvQev7v9/j68HEf1NPD+sC94ucOnx8fh+28Pux4j/rcPOp14eMv1LccjHv0ncrQ9xnzdMK4R9xaea/fr5o3/8mAMG3KOTE2D4czvuJWzJZxAopyJj/v8tZR3NzjwHD3+zp49qX2tdsCZBTPS0wM5lnLwVZr3+ixTofVMQCneqU5rc4qimeOVQ6arRVDgb9jwN9+aoqvcclaXH/mBlhc8FpWXXuN4jEpweET8VrYOPTq5ggfguLilbYfu/dJYZXg5uvTZRexedXQMBbySe5AG8Vr5tYxBKhHPLioQTIaJ5rHj7o7qyx4Q5AUt3ONdQw9fv3TTc0V3xPwwWHX5wq3KiienRm+obmuFfo3OW/fZdYGt1retFu5SUz9P6w8WMzj6b2JO+z8Z+g6yoXObycsFkPLcOgzvkoNxduIkZ1XawgQlWZ1hi6h9+e4fUnDp0oddCsUPF8vmv+T5NuSHHIZ0qpU3PjyfopPEK9YRhUoYU/PuyXfONHnkvvLl9HSCgLSIgRZU0/S+9bU/ZYwsE0GPqrIupJqep3yFVFeo6M6+GNEJl7fTo+vOCIV/jqlhlrMX5jBa8c7P9xu59E8y2xfy08tQ4D+x/chGONoX5BPyuNcIylvyBfisx33PCO/iF82+EQeEUc+kUfEUw0+kUfE1xn8IC+II8/IL+LIM/KLOPKJPCKOvCFfiIcxeiIp/2EYZz7fJIxfuFT12UE59RzV7jygJjpBtDS6O7aY5nd8f3Nx8NNB58t8z7JTdJ3h1eOiiekesJxxmnl+mq4zd9apvFCfA6q8gmNO9nRe7v1xzO21pQQcSd24uintCsUXVUr4sXwCpBW2+Tcz6PrFVS5nHIYuwUcp9oMKOZ2v5vHHXDfHEaB0L3rhsA9dp2XD6PnAr2TQd9utpsuFXv/vW3Z4Xz2hnFc/esY9MucE7bFNmjFYed+86Nk8OV68fFZF8cZim7E/j/YCW86y5al1s6tHpI18Xv42i0QhvfpcxnN2avZu65+XsxFWakWkPmdTl3ztkHdfzq425OxjWM5Gnnux1PI9LSxzOKFuXEDOms39qqEJy1l0DvE8MJWze7Cc3VrLd6zS56ww5zxR9h85yzFqJItv/XlnvNf054lxH0hgvtfoe9zYNwnM9xoJzPcaCcz3mv7cM/pG8+L3munzinPme40E5nuNBNz3RJRt0F9cNTxeoqu32quB/Qcg1/+shlrfXJeugeyzg4IuqQSCDy0P/CJFBjUfqk/vzpSAjfW3kzH1GshPTfg5aJEMEjPyfetnJHA9NKHBylECwsCkcUFND2w/2TzleWUQ0i3uWBT6SGDD+sDs0Hg1HEopfapOcR1KawUSP7kGpj1bud76cTr5sm2C4xq4sarHKvmiBvLyv/N7YpcadkSPRHS4XYNUuzfAtqQLuLH78nYr+sCSb3uaO9kP4aVBoWKhBv4FJJMDag== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAgOAAA/QkAAA==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 + + + AQAAAACAAAAIDgAAiQIAAA==eJwtxRGAKgYAANC2tS0IgoMgCIIgCIKDIAgOgiAIgiAIgiAIgiAIgoMgCIIgCIIgCIIgCIIgCIIgCIIgCD70nrxg4CPksCP+ctQxx51w0imnnfG3s8457x8XXHTJZVdcdc11N9x0y2133HXPfQ/866FHHnviqWeee+GlV15746133vvgo08+++Krb7774adffjvw16egQw474i9HHXPcCSedctoZfzvrnPP+ccFFl1x2xVXXXHfDTbfcdsdd99z3wL8eeuSxJ5565rkXXnrltTfeeue9Dz765LMvvvrmux9++uW3A39/CjrksCP+ctQxx51w0imnnfG3s8457x8XXHTJZVdcdc11N9x0y2133HXPfQ/866FHHnviqWeee+GlV15746133vvgo08+++Krb7774adffjvwz6egQw474i9HHXPcCSedctoZfzvrnPP+ccFFl1x2xVXXXHfDTbfcdsdd99z3wL8eeuSxJ5565rkXXnrltTfeeue9Dz765LMvvvrmux9++uW3A0E55LAj/nLUMcedcNIpp53xt7POOe8fF1x0yWVXXHXNdTfcdMttd9x1z30P/OuhRx574qlnnnvhpVdee+Otd9774KNPPvviq2++++GnX3478O+noEMOO+IvRx1z3AknnXLaGX8765zz/nHBRZdcdsVV11x3w0233HbHXffc98C/HnrksSeeeua5F1565bU33nrnvQ8++uSzL7765rsffvrltwP/fQo65LAj/nLUMcedcNIpp53xt7POOe8fF1x0yWVXXHXNdTfcdMttd9x1z30P/OuhRx574qlnnnvhpVdee+Otd9774KNPPvviq2++++GnX3478P+noP8Anu3h0w== + + + AQAAAACAAADBAQAADgAAAA==eJzj4hoFQxoAAGzsEYs= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_1.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_1.vtu new file mode 100644 index 00000000000..15fd267ca49 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_1.vtu @@ -0,0 +1,38 @@ + + + + + + + AQAAAACAAADYAAAAEgAAAA==eJxjYIAARgbsYKiKAwAEyAAK + + + + + + + AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_12.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_12.vtu new file mode 100644 index 00000000000..f554c14cd20 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_12.vtu @@ -0,0 +1,41 @@ + + + + + + + AQAAAACAAADYAAAAEgAAAA==eJxjYIAARgbsYKiKAwAEyAAK + + + AQAAAACAAADYAAAAEwAAAA==eJxjYMAOGHHQpIKBMgcABMgACg== + + + + + + + AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_123.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_123.vtu new file mode 100644 index 00000000000..5be0d777e2e --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_123.vtu @@ -0,0 +1,44 @@ + + + + + + + AQAAAACAAADYAAAAEgAAAA==eJxjYIAARgbsYKiKAwAEyAAK + + + AQAAAACAAADYAAAAEwAAAA==eJxjYMAOGHHQpIKBMgcABMgACg== + + + AQAAAACAAADYAAAAEQAAAA==eJxjYKAOYKQSTS0AAATIAAo= + + + + + + + AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_13.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_13.vtu new file mode 100644 index 00000000000..c7eebfbd879 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_13.vtu @@ -0,0 +1,41 @@ + + + + + + + AQAAAACAAADYAAAAEgAAAA==eJxjYIAARgbsYKiKAwAEyAAK + + + AQAAAACAAADYAAAAEQAAAA==eJxjYKAOYKQSTS0AAATIAAo= + + + + + + + AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_2.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_2.vtu new file mode 100644 index 00000000000..b575b25b751 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_2.vtu @@ -0,0 +1,38 @@ + + + + + + + AQAAAACAAADYAAAAEwAAAA==eJxjYMAOGHHQpIKBMgcABMgACg== + + + + + + + AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_23.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_23.vtu new file mode 100644 index 00000000000..2c1d1c3e1c7 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_23.vtu @@ -0,0 +1,41 @@ + + + + + + + AQAAAACAAADYAAAAEwAAAA==eJxjYMAOGHHQpIKBMgcABMgACg== + + + AQAAAACAAADYAAAAEQAAAA==eJxjYKAOYKQSTS0AAATIAAo= + + + + + + + AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_3.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_3.vtu new file mode 100644 index 00000000000..d0490517079 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_hex_DFN_3.vtu @@ -0,0 +1,38 @@ + + + + + + + AQAAAACAAADYAAAAEQAAAA==eJxjYKAOYKQSTS0AAATIAAo= + + + + + + + AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_1.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_1.vtu new file mode 100644 index 00000000000..bd90cbf97ea --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_1.vtu @@ -0,0 +1,47 @@ + + + + + + + AQAAAACAAADwBAAAEwEAAA==eJwtxdciEAAAAEBKiTKSVMrehCYlZc/s7LLaVFIUyqhoUAmJRP/qwd3LBQTsC/QBH3SQD/mwg33EIQ71UR9zmMMd4Ugfd5RPONonHeNTPu0zjvVZn3Oc453gRCc52SlOdZrTneFMZznbOT7vXOc53xd80Zd82Vd81QUu9DVfd5FvuNg3fcslLnWZy13hSle52jWudZ3rfdsNbnSTm93iVrf5jtvd4U53uds97vVd33Of+z3gQQ/5vh/4oR/5sZ/4qYc94md+7hce9UuP+ZVfe9wTfuO3nvSUp/3O7z3jWc953h/80Z+84EV/9hd/9Tcvednf/cM/veJfXvWa1/3bG/7jTW/5r7f9zzve9X/vAUgYMHQ= + + + AQAAAACAAADwBAAAIAAAAA==eJxjZIAARhw0pQCXudSiRzqgdfiOhvsoGE4AAHm4ACA= + + + + + AQAAAACAAABsBwAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpHMc0wAO4uAdw= + + + AQAAAACAAADYDgAA+QIAAA==eJwtxVOAEAYAANDrckNc85a1bF6Xbdu2fdm2bdu2bdu+7H303s9LHvBdCqd0Kqd2Gqd1Oqd3Bmd0Jmd2Fmd1Nmd3Dgc5p4Ody7mdx3mdz/ldwAVdyIVdxEVdzMVdwiVdyqVdxmVdzuVdwRVdyZVdxVVdzdVdwzVdy7Vdx3Vdz/XdwA3dyI3dxE3dzM3dwi3dyq3dxm3dzu3dwR3dyZ3dxV3dzSHu7h7u6V7u7T7u637u7wEe6EEe7CEe6mEe7hEe6VEe7TEe63Ee7wme6Eme7Cme6mme7hme6Vme7Tme63me7wVe6EVe7CVe6mVe7hVe6VVe7TVe63Ve7w3e6E3e7C3e6m3e7h3e6V3e7T3e633e7wM+6EM+7CM+6mM+7hM+6VM+7TM+63M+7wu+6Eu+7Cu+6mu+7hu+6Vu+7Tu+63u+7wd+6Ed+7Cd+6md+7hd+6VC/8mu/8Vu/83t/8Ed/8md/8Vd/c0AYOdBhHc7hHcERHcmRHcU/+Ef/5J8d1dEc3TEc07H8i2P7V//m3/2H//Rf/tv/+F/HcVzHc3wncEIncmIncVIn839O7hRO6VRO7TRO63RO7wzO6EzO7CzO6mzO7hwOck4HO5dzO4/zOp/zu4ALupALu4iLupiLu4RLupRLu4zLupzLu4IrupIru4qrupqru4ZrupZru47rup7ru4EbupEbu4mbupmbu4VbupVbu43bup3bu4M7upM7u4u7uptD3N093NO93Nt93Nf93N8DPNCDPNhDPNTDPNwjPNKjPNpjPNbjPN4TPNGTPNlTPNXTPN0zPNOzPNtzPNfzPN8LvNCLvNhLvNTLvNwrvNKrvNprvNbrvN4bvNGbvNlbvNXbvN07vNO7vNt7vNf7vN8HfNCHfNhHfNTHfNwnfNKnfNpnfNbnfN4XfNGXfNlXfNXXfN03fNO3fNt3fNf3fN8P/NCP/NhP/NTP/Nwv/NKhfuXXfuO3fuf3/uCP/uTP/uKv/uaAwO+FcaDDOpzDO4L/B4ug/HI= + + + + + AQAAAACAAADQDgAAIgYAAA==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 + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAABgOwAA7wkAAA==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 + + + AQAAAACAAADYDgAAqQIAAA==eJwtxRGAKgYAANC2tS0IgiAIgiAIgiAIgiAIgiAIgiAIgoODIAiCIAiCIAiC4OAgCIIgCIIgCIIgCIIgCD70nrxg4CPksCOOOua4E0465bQzzjrnvAsuuuSyK6665robbrrltjv+8re77rnvgYceeeyJp5557oWX/vGvV15746133vvgo08+++Krb7774adffjvw16egQw474qhjjjvhpFNOO+Osc8674KJLLrviqmuuu+GmW2674y9/u+ue+x546JHHnnjqmedeeOkf/3rltTfeeue9Dz765LMvvvrmux9++uW3A39/CjrksCOOOua4E0465bQzzjrnvAsuuuSyK6665robbrrltjv+8re77rnvgYceeeyJp5557oWX/vGvV15746133vvgo08+++Krb7774adffjvwz6egQw474qhjjjvhpFNOO+Osc8674KJLLrviqmuuu+GmW2674y9/u+ue+x546JHHnnjqmedeeOkf/3rltTfeeue9Dz765LMvvvrmux9++uW3A0E55LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY7/vK3u+6574GHHnnsiaeeee6Fl/7xr1dee+Otd9774KNPPvviq2++++GnX3478O+noEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltuu+Mvf7vrnvseeOiRx5546pnnXnjpH/965bU33nrnvQ8++uSzL7765rsffvrltwP/fQo65LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY7/vK3u+6574GHHnnsiaeeee6Fl/7xr1dee+Otd9774KNPPvviq2++++GnX3478P+noEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltu+w82teht + + + AQAAAACAAADbAQAADgAAAA==eJzj4hoFwxQAAELeEo8= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_12.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_12.vtu new file mode 100644 index 00000000000..aaf06df19f8 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_12.vtu @@ -0,0 +1,50 @@ + + + + + + + AQAAAACAAACoBQAAPgEAAA==eJwtxdciEAAAAECpNIxSqShaGpT2IIkG7UEZRVMSTQlRlFJRpElDEoqQQh/owd3LBQRMmORAT/YUT3WQp3m6Z3imgx3iUId5lmc73HM81/Mc4fle4IWOdJQXebGjHeMlXuplXu4VjvVKr/Jqr3Gc473W65zg9d7gjd7kzd7ird7m7d7hRCd5p5O9yyne7VSneY/3ep/3O90ZPuCDPuTDPuKjPubjPuGTznSWT/m0s53jXOf5jM863wU+5/O+4Iu+5Msu9BUX+aqLfc0lLvV13/BN3/Jt33GZ77rc91zhSlf5vqtd4wd+6FrX+ZEfu95P/NQNfubnfuFGN/mlX7nZLX7tVr/xW7/ze3/wR7e53Z/82V/81R3+5k5/d5d/uNs97vVP/3Kf+/3bAx70kP942H/9zyMe9Zj/exyv0D+j + + + AQAAAACAAACoBQAALgAAAA==eJxjYMAPGAnQhNQPFEC3n5D7SVVPbXcMdHiNNEAoHoZavAw3/4wCVAAAetgAIA== + + + AQAAAACAAACoBQAAMgAAAA==eJxjYIAARjSagUg+IUCufnT3kKqPWPNI9Q+twVB3P7GAkH+Guv+GOhiNn8EFAHyYACA= + + + + + AQAAAACAAAAACQAAGwAAAA==eJztwwENAAAMw6DOv+kLOSSsmqrqowcuFgJB + + + AQAAAACAAAAAEgAAiwMAAA==eJwtxUMAEAYAAMC4bNu2bdu2bdu2bdu2bdvGll17dPe56gH+quGaruXaruO6ruf6buCGbuTGbuKmbubmbuGWbuXWbuO2buf27uCO7uTO7uKu7ubu7uGe7uXe7uO+7uf+HuCBHuTBHuKhHubhHuGRHuXRHuOxHufxnuCJnuTJnuKpnubpnuGZnuXZnuO5nuf5XuCFXuTFXuKlXublXuGVXuXVXuO1Xuf13uCN3uTN3uKt3ubt3uGd3uXd3uO93uf9PuCDPuTDPuKjPubjPuGTPuXTPuOzPufzvuCLvuTLvuKrvubrvuGbvuXbvuO7vuf7fuCHfuTHfuKnfubnfuGXfuXXfuO3/tf/+Z3f+4M/+pM/+4u/+pu/+4d/+pd/+48DBJQDObCDOKj/cTAHdwiHdCiHdhiHdTiHdwRHdCRHdhRHdTRHdwzHdCzHdhzHdTzHdwIndCIndhIndTIndwqndCqndhqndTqndwZndCZndhZndTZndw7ndC7ndh7ndT7ndwEXdCEXdhEXdTEXdwmXdCmXdhmXdTmXdwVXdCVXdhVXdTVXdw3XdC3Xdh3XdT3XdwM3dCM3dhM3dTM3dwu3dCu3dhu3dTu3dwd3dCd3dhd3dTd3dw/3dC/3dh/3dT/39wAP9CAP9hAP9TAP9wiP9CiP9hiP9TiP9wRP9CRP9hRP9TRP9wzP9CzP9hzP9TzP9wIv9CIv9hIv9TIv9wqv9Cqv9hqv9Tqv9wZv9CZv9hZv9TZv9w7v9C7v9h7v9T7v9wEf9CEf9hEf9TEf9wmf9Cmf9hmf9Tmf9wVf9CVf9hVf9TVf9w3f9C3f9h3f9T3f9wM/9CM/9hM/9TM/9wu/9Cu/9hu/9b/+z+/83h/80Z/82V/81d/83T/807/8238cINDfAjqQAzuIg/ofB3Nwh3BIh3Joh3FYh3N4R3BER3JkR3FUR3N0x3BMx3Jsx3Fcx3N8J3BCJ3JiJ3FSJ3Nyp3BKp3Jqp3Fap3N6Z3BGZ3JmZ3FWZ3N253BO53Ju53Fe53N+F3BBF3JhF3FRF3Nxl3BJl3Jpl3FZl3N5V3BFV3JlV3FVV3N113BN13Jt13Fd13N9N3BDN3JjN3FTN3Nzt3BLt3Jrt3Fbt3N7d3BHd3Jnd3FXd3N393BP93Jv93Ff93N/D/BAD/JgD/FQD/Nwj/BIj/Joj/FYj/N4T/BET/JkT/FUT/P/npYfIA== + + + + + AQAAAACAAAD4EAAArAUAAA==eJyNVQtMU2cUvhjUiCQUiC9wiori3JT5mhofR1iJiGBiRpS4Tp0Jzsdw6HC6xgcGncPCLAyY04g6H/gE1OhmHRu0QlHRtlgojNgWKfTSynZ1Gp04XdX737t7eu/qSZM/9+v/33O+73z3/BQlFgwIn+3w/7ivIPvwe/B5jOP/feVjJOr0xQfnlTovdU4qvxQ/X3VLrTiMPvpCS+BSuhoRjp+l8uOQ6hON8kj5AfPCeaR8QkOqNtZy4Y7daxXsm30XvRfXg3m8qS74PO3jvRjH76WRDiTeVBeMYz/gZ6w7fh+ux5f/8D6pfmMc6yZVt9T3iOvC56X44XO+5hYtUS/OI9UnEm+qIwmcFwfuE17x/758JqWrr7kolYePE4kptPLSDRZ3cP8rnA0/DjhiYp+bODxIpf24MdYMBe8M6s6ucHG49cC4r1pi9DB6RmNx8T9XOdyg3zmpanMjOEOzDX5PtRz+y5HZs8xbtTDt1K8ZKoUb5WlCdZvZtRbhWvBnV4I/e+GJoTXQ49WjmcMJzyL10Gc77t+BsHxaJfusHQjPA+lJjyZGt0LxvGN+2fNbIJjlefJM0tS4eht0b5NdtTa4gPDsbm+KCg6yQ43751O7ZlYD4em/JHFf8WY7fFdy7v6SrqtAeD4pDKlepLTBwAfxydMOumF3nkpXpKnkVmFXMF/PyNx7b8PajBrYeHieOmePGe23gHClqDPNt1XayHq0zwFzxydrjJfrEN4EdzuV8g+Veg4n/Q0+t/KDkKV8PtLf5ekPi7b00nG4g+1vRKnNXljZyOFT2f6+1rsVGtK+t+/4Qc/5zXCsPlNe0gqFtem52/zMXP8/TX5cmzzQDpopsqLwfrzf6NNPYp96dL82OX9gxFbeb/cid8dbPLpbsoaser7BAqQe25zdtrOxdjhtSK3N+qIK+Y2ixoT21xR3dXj5/+xfq00qE+3l/2/iWsetGeby8v/GknnWL43tXv7vaIvdt2yW28v/f45WB1086JDwvwP5nPigw8v/fi+XTLcQ9/j+Fb7J5eV/4fkmEH7nDJeffOcEL1+wP7SpTzXnf4I/Sk9I2Vvp4vxP8N5X3srZFuPm/E/wwYt6jq3P1UrwJYH5ksB82fDiS1G7+t+6or9gg7hp0Rtl9Xx/F/QsPBngwQdt100f3MX3t/vE9hz5OSss/XbXmRE7Orn+Pg/Sna8Is8KMNPnb8osdXH/XlO0/dCHDBqPKj41xZrk5v5mbMxUzA2ygD02V50by/f0preVS2kcOyI+c6/lZkN6kbl7vl7vyj7bDhEDde4G6GuF+jj+vK/Hx+4kTlG21NpD3dd5pa26DUtbHa3JTVqvD7Sx/CxAfl+UldqdXWyGEWhzzbn8XEB9XVz9JuOmwwwiFwj9sYhU4WR9D3XL113F2uLy+UraqrQqIj8saTq4q72ODEQNeDD/VKuU73tfi9wsD4vcLA+L3CwPi9wsD+H4RfuckHNB4rzPuk5BOr3m4STPEVGBt53Dif6IbwUmdRAeCk7wyy+dMwjLer8T/4n4ggf1AUeJ+YMPLDx4F1gcsmR/jALISXV6vHch3DNRX+KXeTXDB6NBFmimH2sX99p85I9STnyfCucnPE6Fu/DwhfiM4mSdkbhK8FztPhDrz80ScLwnMl6LE+SI98Zzx4s3XIX5fMCB+XzAgfl8wIH5fMIDvi+DJv6sDowzQQ7U2/OFMI/xhONxwvbcRzk+s+Ts93AQPMuMVEfG3YOGVinJ9Bw3Db/ifGLC4DgqSIg4rbtIwuLlUp9xyG5KStbI9C4wwfvzI6aYkGhYeT408P4YGbdRv8w80OCGnb0qP0GQDHI8elhHb5QRr2eOVO3NoiBzVWXR0pAkmRZdkr3PUwfbGMPXDITRotJOzdNeckFfwWFnlqScmcMV1+2Yn9GtZVzo2ygkrAib0ViU44V+yC0mz + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAASAAAqgsAAA==eJyN2ufX3kURxnG72HsD0cQIKhZALNgoIhoMkqgoJETzKMGCYlCRLgQTREDEiIIaiI9gwQKo5A/0hfN58z1nD95v5tw7u7NTrpktv931rP/9nhi6MfTJoRcO3T10T/g7h+5ajN+Z9n0L+Z9Of/yvDt0/dFv45n3LM8y3M/3Kf/vQPeH7vzv9jNsWPn3pt3/RH3/v0FOGfn2oeFw+9ItDvxC+9iuHvnXBvzz9Kp/cy8Kn98lDG58rhr5p6GfDZw/7NiL/y9Hr8vC/NPQr6Y8vPuTvDf9z0esz0Y/87ZnH+DekfXv45JN7SeQXT/Q0nv/oR57x/P+1oSeHL2/kwWuHitMbo4f+8m572tlb/1+W/vifj170fDL8nem3yv9n0r/1CG5fN/Si6Ie/K/3w6bsj+tLvkrTvCP81Q8X/wvDF8+KhV4S/MVTeNj/JNc+lGU8uvep/+U8+P5Dfutl835Z2fm9+07v5uTftq/zas+DLC/Wl/lVv+WF/+BtDW99PyX96wGH1Z2ft0x+u6l/8i9Kv+UVu6y/74Iad7CPXuK4P+NvTDx++4afy/Yer+hcuxaXrA7zKn9bHS9Pe+mw9oHf9vzGU37v+0Y9ezR/zsrP1t+vP26IHf3ed3TK068KrM4/4yqvWh8a18skzT9c7uN0Y2voirvK78ZUf8qD5Ka7kPG8oPPGT8S+MXvwmfsUv+ScOLV7l7Wqds57sSrs85Df+an2RN3Dw+qFdD+VZ6we9yFXHxJt+qzziN7jrPkg/fiq+4Qku3jz04tCThnY9ZNdzhnaf+Nyhq32U+f2KT/F8dvRv3miHA/aKx6rOwRt/wd3W8Pm36xV/8E/XGf5c1en63884eta/W4YWf/zNbvnPf62jz49+1Z8f5S3/dj9xUvrtyH/9uh80jh6dv/oVn/LEPqTnrxcM7TlpS9q3pr86yO/w0/y2ntgn9Zzbul/58Nb6Z//R/Ok6U9yIt/xpXhQHPbeYT90kp3mqTvELXPKX+ml+83Y/vIqzePIvP9Z/XYdW+9CN9Hsi/J7Deg/R9aH7mJ6zKh+/55TO3/Wh+2Y47b56a/rBG/ldV7qP2J1+9Dsw9BtDnxr6r/CvTT98/uCvm8K/KuOuDd//m//P8e/MuANp7zzfHnrd0HcMZWf3B8ZfteBrZ++3hsoHeUK+/JAXVw9ln/mMJ8/4nm93hW88O2vf94beNvQ7i/l7PjbeOPVcfTf++0P594aMp9f1z8DXfl34/C2e78r8N0aPyocr4+Hr9LTrdyD8np9vjXz6Glf/8xe/82fzx/rSPGA/u7+Z8fQyrvr9IOPqvx8NFR/2Gt91r3lOPrnNb/LJrX7XRD/yOt448S6+yen4M6LvLeHDzfuGimPj992hzZ/ey+wMX/yuTn98eGBH9fth7Cif3uz4cfTnF/oXP+IuD1t/1NVVHvb8Bo9PpV0dbb3zX97U/+Km/jR/6N9zeOsv//ND84ee8qj11zz1D33FoePFrfXH/OIOV9XP/57var88aX4Yz/7GX3/5VfzQT17BY9fvMxZ8fiG3/oHbG9Ov85Nb/OO/Z2jrrPWAn+qf3g/BeeXz4zXhw4P86T6q91+tD12/3hu9V+3WndbNE6InvvjXvtZnftoytPfnza/6n9/F6d3Rh57G8V/PF/SAy+L7zKHyqTg8PbTre/O165y6wA7ztP6Igzi1fvW7Y+tZv+vV//KBH5o//Mn+5l9xCw+nDpUvJ6Y/vDb/XjyUX5q/L4nezWt2iB+5cFJ8wMNpQ+Hl+tDiZ8vQ4tv5kh7yk929X+q6Uf+dkPZrwi/u9Wdv94fuU+BMXvFH/c/fqzrS83nXA/Z2fnrxE7/xp/j13NV1nL32C92PrvQ6Ne2932AXPPT+zP5CvXzRUDhSr/lTPOCRv4tj/mY/+fxtHnWh55vy+ZN/e38lLnBQfKhTHX9r+jWu6g896NVzpPXCOtnvs3DY+qAOd3/a+tDzsfj2nEyPnkPwbw6/9xjd33UfdiD8ju/60fsFdQi+bgj/tPSDW/L7vqL69ft5z+E9x3ed7/0G++4f6j7s30P/M/TQ0I2hh8O/e+g9Q38ZPvnG7wt/I/06nlzzmu9DaT+04Fe++2Pz7Fvwjbtr6H1DPxj93GO653xgKD/eO/QXQ38S/p1DP5z++O7/Hhr6m8x/ZOivh/42fP4gn5/Id2//s6G3h993CT+N/I8O/Xn0wGefeelBPv3uXfDNy+7Obxy/Hsz4vjsqvviP3x4KX9x+lXnIhz9+qn78Qn798/HINx/54tL3P/h3hN/4NT/6/s388E8P4/uup3XiUNorn7/Ipa/x4vrg0PpP3qkDzT//2XlX+OIv7kfC104+PH4sdvR9XvO/38/Zd3/6tT7cnX70MT/88E/zmz19Z4cvn8wjXupjv1MV/3C9kf6t3+pm/X04/cgzXrzYd1/45KgzzZ+DQ9WZ1k92w/kqv+C89ZFe4lD94Bm+G9870l58wLt5il/95V/zx395fzB8dsFn7eOX4hAfHuCj+SP/uk7jy29yHgy/+w95Yn71g50Hw++6BQfvz7zypvOLp/jeE37X7bOGwhk8fmLoaj05kn74/AUHjX/jWvvoRx9xrH/E/c7wV3YdDH1p+OTIZ3a0/hc/vn/zR9+dsFe8yen30NY/daL1gZwPDO06/kDai/++v23+nj206xfck9c6pL43P/nvUPp1nVIPzfuRod1vdN/U7+vw0Xcc4vCyoat90CuG8nvnr//rbzg6OBTO4Bvezgpf/9rffG5e6S9uxR9996f/yyPHPPy2wrF56n9x4Qf+4W/+ZQf7+Jt/4V9eyTd1pu8J2q/rDjvPzv+Vn73rWK1z7GQ3feCv567up8S75yO46f6n72u6b1Sn7H/EqXkAf7WvOL4j/eCA/eLYPIJn8RSvnuPgpvc8V6a/ekAe3PRdZvc79FGX6AmXPdeyU5zgoPnRfXrP711ne35f3TN0/4Lf/c3GQv7qnqN1uvzVPr37jq67Ped3Pe85enWP0rovvvK474S6n2/eyctHhrrfenro8fCPpd/x/Me/KXztjw/9a/j+95za8b236/ed9qP36l3F6lxc/qND+x2Tn9x/uu/cjP5/Gfr3of/IeDhxT/u7jP9zxpNnfN8F1P+b6Xcs/POH/mGhX99PdHzryW3h05dc85AvLr1HwRfHT2b+4ulY+uH/fugfhz4c/dyTq7OPZX783u9UP3adHz77+n4I/2/Ri57Hw9d+QfjNH3Zb3+gLR7Wv54/6H988vT+4IHz60g9uuy7Uv/T6U/jGG/d4+Pxm3qOZv/errS/mg9Pi0zhy/pnx4qsuqBPGqx+PLPjwIj9qn7xr/qp7m0PhA97p1/rXPKM3P9C3+KZn9TMvvYrPvh9sfdLec2rrP3xVPn26v6Mff6iPmxmvv/Fw2vjxT/HR79rFr3pOj+LTfHAuT58OX3vrz2Phd37zyY/i92ja7wwf/pv/+Ozr92r+to8mV5yNI9/83R+wh31d/8hnh3nIfzj85oe8kJfw3vrTdexT4Vc/fPPRp/7p93XxFGf4g7vq13ef3Z+IS98/Nv8OpR++/N4c2vXf995VnslPfuMv+nXd7nqifVWHmhf85/za70/wR/+uKz0fws+5Q5tP8tP8rT/wS6++fyGHvc1P7V2/6Hfe0K5f5u3+4pVDxbX7sldFXu8Fuh/lX+d0+vPTuYt2enV/Yj7xgyt50/cvxd/m0HOGNi/4hf/l13lD67/uT+TpmfnfvKV//c4f7G/c+J8+3kvQs3aIQ+Oj/rQu9n6t9wrdD5vHvH3/8mja6W0c+8Wj+GM/u1tfu/71fmpzaPFgvwR37G4e80Pvf1brWvnWjb4zVK/6/qbrHz/wC1yog8VF94vdX/OPurZ6d9jvAb1n4zf61z/k9Hzc9z29R+j+sfu43jfgr87tHd/6231ez43dN8PpZvjnpB9ci2P3TUfD73mkOOi63HP0Lem/2sews+v44fTjn/8CS+nIXQ== + + + AQAAAACAAAAAEgAANQMAAA==eJw12BG7MogChdEzc5u53ecJgiAIgiAIgiAIgiAIgiAIgiAIguBAEARBEARBEARBEARBEARBEARBEARBEAQHggtnfVvWb9hv4Ot3QYYYZoRRxhhngkmmmGaGWeaYZ4FFllhmhVXWWGeDTbbYZoff7LLHPgcccsQxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3f/jh11+/BBhkiGFGGGWMcSaYZIppZphljnkWWGSJZVZYZY11Nthki212+M0ue+xzwCFHHHPCKWecc8ElV1xzwy133PPAI08888Irb7zzwSdffPOHH379/UuAQYYYZoRRxhhngkmmmGaGWeaYZ4FFllhmhVXWWGeDTbbYZoff7LLHPgcccsQxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3f/jh139+CTDIEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvs8Jtd9tjngEOOOOaEU84454JLrrjmhlvuuOeBR5545oVX3njng0+++OYPP/wKgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaH3+yyxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPLFN3/44dc/vwQYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdvjNLnvsc8AhRxxzwilnnHPBJVdcc8Mtd9zzwCNPPPPCK2+888EnX3zzhx9+/ftLgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaH3+yyxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPLFN3/44dd/fwkwyBDDjDDKGONMMMkU08wwyxzzLLDIEsussMoa62ywyRbb7PCbXfbY54BDjjjmhFPOOOeCS6645oZb7rjngUeeeOaFV95454NPvvjmDz/8c/gDDDLEMCOMMsY4E0wyxTQzzDLHPAssssQyK6yyxjobbLLFNjv8Zpc99jngkCOOOeGUM8654JIrrrnhljvueeCRJ5554ZU33vngky+++cPPn9Dzv1/+D9jnJJk= + + + AQAAAACAAABAAgAADwAAAA==eJzj4hoFo4B8AABe9xaB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_123.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_123.vtu new file mode 100644 index 00000000000..4b8c3568da1 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_123.vtu @@ -0,0 +1,53 @@ + + + + + + + AQAAAACAAABIBwAAjQEAAA==eJwtxVNjFgAAAMAvt2XbLdu1bGNLW9aybbeM1eKqLdeyl22by/gZPXT3coHAfymc0qmc2mmc1umc3kEOdgZndCZndhZndTZndw7ndC7ndh7ndT7ndwEXdCEXdhEXdTEXdwmXdIhLubTLuKzLubwruKIrubKruKqrubpruKZrubbruK7rOdT13cAN3ciN3cRN3czN3cIt3cqt3cZt3c7t3cEd3cmd3cVhDndXd3N393BPRzjSvdzbfdzX/dzfAzzQgzzYQxzloR7m4R7hkR7l0R7jsR7n8Z7giZ7kyZ7iqZ7m6Z7hmZ7l2Z7juZ7n+V7ghV7kxV7iaC/1Mi/3Cq/0Kq/2Gq/1Osd4vTc41hu9yZu9xVu9zXHe7h3e6XgneJd3e4/3ep/3+4AP+pATfdhHfNTHfNwnfNKnfNpnfNbnfN5JvuCLvuTLvuKrvubrvuGbvuXbvuO7vuf7fuCHfuTHfuKnfubnfuGXfuXXfuO3fuf3/uCP/uTPTvYXf/U3f/cP//Qv//Yf//U/bxdplQ== + + + AQAAAACAAABIBwAAOAAAAA==eJxjYMAPGAnQhNSTKk/IHdQGpLqTkDuo5W9c9tIqHOhtz1ADpOYDeoNR9w1tMBo+QxsAALvgACY= + + + AQAAAACAAABIBwAARgAAAA==eJxjYEAFjGg0OsAlT4hPLCBkP7nmE6selz/IdQ+1woVYQGq8UWo+rf1DLYDuf2qFB73AUHf/YAfDPXyHu/8GGgAAuHAAJg== + + + AQAAAACAAABIBwAARAAAAA==eJxjYIAARjQaHRCSxwXQ1RMyn5A6QvpIlUdXR64/SQW0Dmdc4rTyF73CjVj7B9o9Qw0M9/Ab7v6jNRgNP/wAALZwACY= + + + + + AQAAAACAAACEDAAAHQAAAA==eJztw0ENAAAMA6Grf9NzsRckrJqqqurTA6hlAyI= + + + AQAAAACAAAAIGQAA3wQAAA==eJwtxTMAGAYAALBytW3btm3btm1utW3btm3btu0dTZ4sDfDXMi/3Cq/0Kq/2Gq/1Oq/3Bm/0Jm/2Fm/1Nm/3Du/0Lu/2Hu/1Pu/3AR/0IR/2ER/1MR/3CZ/0KZ/2GZ/1OZ/3BV/0JV/2FV/1NV/3Dd/0Ld/2Hd/1Pd/3Az/0Iz/2Ez/1Mz/3C7/0K7/2G7/1O7/3B3/0J3/2F3/1N3/3D//0L//2HwcIKAdyYAdxUP/jYA7uEA7pUA7tMA7rcA7vCI7oSI7sKI7qaI7uGI7pWI7tOI7reI7vBE7oRE7sJE7qZE7uFE7pVE7tNE7rdE7vDM7oTM7sLM7qbM7uHM7pXM7tPM7rfM7vAi7oQi7sIi7qYi7uEi7pUi7tMi7rci7vCq7oSq7sKq7qaq7uGq7pWq7tOq7req7vBm7oRm7sJm7qZm7uFm7pVm7tNm7rdm7vDu7oTu7sLu7qbu7uHu7pXu7tPu7rfu7vAR7oQR7sf/2fh3ioh3m4R3ikR3m0x3isx3m8J3iiJ3myp3iqp3m6Z3imZ3m253iu53m+F3ihF3mxl3ipl3m5V3ilV3m113it13m9N3ijN3mzt3irt3m7d3ind3m393iv93m/D/igD/mwj/ioj/m4T/ikT/m0z/isz/m8L/iiL/myr/iqr/m6b/imb/m27/iu7/m+H/ihH/mxn/ipn/m5X/ilX/m13/it3/m9P/ijP/mzv/irv/m7f/inf/m3/zhAoL8FdCAHdhAH9T8O5uAO4ZAO5dAO47AO5/CO4IiO5MiO4qiO5uiO4ZiO5diO47iO5/hO4IRO5MRO4qRO5uRO4ZRO5dRO47RO5/TO4IzO5MzO4qzO5uzO4ZzO5dzO47zO5/wu4IIu5MIu4qIu5uIu4ZIu5dIu47Iu5/Ku4Iqu5Mqu4qqu5uqu4Zqu5dqu47qu5/pu4IZu5MZu4qZu5uZu4ZZu5dZu47Zu5/bu4I7u5M7u4q7u5u7u4Z7u5d7u477u5/4e4IEe5MH+1/95iId6mId7hEd6lEd7jMd6nMd7gid6kid7iqd6mqd7hmd6lmd7jud6nud7gRd6kRd7iZd6mZd7hVd6lVd7jdd6ndd7gzd6kzd7i7d6m7d7h3d6l3d7j/d6n/f7gA/6kA/7iI/6mI/7hE/6lE/7jM/6nM/7gi/6ki/7iq/6mq/7hm/6lm/7ju/6nu/7gR/6kR/7iZ/6mZ/7hV/6lV/7jd/6nd/7gz/6kz/7i7/6m7/7h3/6l3/7jwME/ltAB3JgB3FQ/+NgDu4QDulQDu0wDutwDu8IjuhIjuwojupoju4YjulYju04jut4ju8ETuhETuwkTupkTu4UTulUTu00Tut0Tu8MzuhMzuwszupszu4czulczu08zut8zu8CLuhCLuwiLupiLu4SLulSLu0yLutyLu8KruhKruwqrupqru4arularu06rut6ru8GbuhGbuwmbupmbu4WbulWbu02but2bu8O7uhO7uwu7upu7u4e7ule7u0+7ut+7u8BHuhBHux//Z+HeKiHebhHeKRHebTHeKzHebwneKInebKneKqnebpneKZnebbneK7neb4XeKEXebGXeKmXeblXeKVXebXXeK3Xeb03eKM3ebO3eKu3ebt3eKd3ebf3eK/3eb8P+KAP+bCP+Kj/B0Wmm6M= + + + + + AQAAAACAAADYFQAASQUAAA==eJy1VQ1MlWUUBkaOlEZFpmnjmoJLCLXSycx18GcB5XTVlJXFVs5+bGCkoqOV2FhWblIU5BAcKIgmbpYOi5/xZ3DToItdfgq99xPvxXsvBB9iw7JBH5fvvN99z/3egCZndzt7z/t+5zznOT/Xx2ciIoH+WWQXncXvttSuajtzxVv/dzwqsiC+LPie2ul70buJxhvLL5U7lQe9p++oXYRvvN+J7kX+RPmbQP8s6i/Re9GZfk/f0fc0jnqO7uS1F05JcD/RfKg4BLhFfeMQxHMI4skCnLTONC7tP4pThIPGo+9RxhtPhA+F5kPzFOGmQv2aBN+PVQdR/hOtA/UvqrdoLmk/iOab+qG4RHEcAn7od6I9Ml5c48UnyofiEsUX9Yloz433HqUdeI1iVs9GYq8Ff1Wj5Z9hRQz14OcOY4bPvthfl11Wze6fWrb88NkjbcD71eJEH+zZmbSjntmDK9+ydkl4bvOK73TsXZhaWcNwL0/N35+wTYLw77OuF5e0sjjTL18YeHHjVXj+yupPqvrRTy2c6H3kvHW3BEPxl4vXJ6hx5ij6wUHnl0ESwx+Q3lwRqtTvZEFz6YLyauY3KHdrx+MHJFjx7jeJDVEXYI2Kv2QHHLR8LMGahIH7Ps1pYfiDcvdEhhivgiFq+OUVn/+u2qvH4J3ypOHnzHM88KuCfFCekA/KE/JBeUI+vHjiBPHbiB37psurfr4jKq2btyt947bvdkFmaJzy0+p+LrGjNHGTTcCLC54IrFscWKfhGvk6s9CuzxeLS/teJv6NxE77Xgba9/z7dgi/WXnjzFwLdN9VMOVYr4357WwIj0ufZXH3UeWNrlE/wzVQnv/D4EN7rVC4aJ7/9ioVp+I3+esNSQEmK8QuaTHeznCp/iTVfyvjf9SfBHUZGzIDlp5n/B8d8QcSJK/c3vekXw3j3+1vhjTqv1rFr/BPeaf1QN5pPZB3Wg+e91ov3JgPxY35UNwsH4Ib8+H3jwz6+0erN79/ZNDfP1ofYH0RP8/L/+97NIVLD7RMjbBAh1/agDHCDoZZ3as3f9Dm7puzJVY3L0ULNP5vGXIeO3WPBVoG3ti46VAXlAb89U6KuZ7101G1n7DP9HG3C3Ab9XFjPh64MZ/J6hveD9aD7lE6x7TedI/K/F5TNOUd60F5x3pQ3rEelHesh/ze1IR1K5W+z9iZleqSIO7v4ZlJx/H/wqXGkVT/v8KjwfFly/LtcEoKyp13W4Li2MgfTX0qfs95UOeEMaTGQc3z18XioeVSpe+WzmddLJ5uHbz2p43wS/tfmxu+j2S23/g+kknfyKC//2WGn+8bGfT3v8zwTw/btfjikBV6UkLipi20weu2ztNFih7hO/eaBfo3Z4U2JduZ/5Cfiz5s7LHA3P7ZaV9VOeHe+e/nzc6zQ7e8NKzQ3wq7buXc/4Kfxg/lmz/T+XIB8o4Wjn86d8pZf75kUk+zFx+UJ96/xhPyQXlC/DxPTig3hcXWx7igKbpnW26fBQyBTa98FGxn9UaeUjx58vifHNV3ro9oXTEPWlfMg9YV603rinno46X7U8tDF6/X/tTymNy5RZEnrY/08cuEHy1vffzErwd/1K/+fGl58PMlg/580TzkScuj2tAzP8rcBG8e+G5G1NpfYEnMb9MezjZBnk9MWf5LjbAv9rmtx6N+Aktkor3lWye0plWYroU0w75Ld98MKLgOR7Jj619V/i9ypvxpCg51wtNBJw2H3zbBIXtExen1jWAf6vX1XXURkiPjB/+IcEJMdHrVnkWapveonyH3DSdem7nunMNL/wuHVPcJ + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAgZAAApw8AAA==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 + + + AQAAAACAAAAIGQAAVAQAAA==eJw12BGDMgoCheG5u+1uezcIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgoGBIAiCIAiCIAiCIAiCIAiCIAiChXm+I89vOG/g63dBhhhmhFHGGGeCSaaYZoZZ5phngUWWWGaFVdZYZ4NNtthmh1322OeAQ4445oTf/OGUM8654JIrrrnhljvueeCRJ5554ZU33vngky+++eHXX78EGGSIYUYYZYxxJphkimlmmGWOeRZYZIllVlhljXU22GSLbXbYZY99DjjkiGNO+M0fTjnjnAsuueKaG265454HHnnimRdeeeOdDz754psffv3jlwCDDDHMCKOMMc4Ek0wxzQyzzDHPAossscwKq6yxzgabbLHNDrvssc8BhxxxzAm/+cMpZ5xzwSVXXHPDLXfc88AjTzzzwitvvPPBJ19888Ovf/4SYJAhhhlhlDHGmWCSKaaZYZY55llgkSWWWWGVNdbZYJMtttlhlz32OeCQI4454Td/OOWMcy645IprbrjljnseeOSJZ1545Y13Pvjki29++BUAgwwxzAijjDHOBJNMMc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAYccccwJv/nDKWecc8ElV1xzwy133PPAI08888Irb7zzwSdffPPDr3/9EmCQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZYZc99jngkCOOOeE3fzjljHMuuOSKa2645Y57HnjkiWdeeOWNdz745Itvfvj1718CDDLEMCOMMsY4E0wyxTQzzDLHPAssssQyK6yyxjobbLLFNjvsssc+BxxyxDEn/OYPp5xxzgWXXHHNDbfccc8DjzzxzAuvvPHOB5988c0Pv/7zS4BBhhhmhFHGGGeCSaaYZoZZ5phngUWWWGaFVdZYZ4NNtthmh1322OeAQ4445oTf/OGUM8654JIrrrnhljvueeCRJ5554ZU33vngky+++eGfwx9gkCGGGWGUMcaZYJIppplhljnmWWCRJZZZYZU11tlgky222WGXPfY54JAjjjnhN3845YxzLrjkimtuuOWOex545IlnXnjljXc++OSLb37+hJ7//hJgkCGGGWGUMcaZYJIppplhljnmWWCRJZZZYZU11tlgky222WGXPfY54JAjjjnhN3845YxzLrjkimtuuOWOex545IlnXnjljXc++OSLb3749fcvAQYZYpgRRhljnAkmmWKaGWaZY54FFllimRVWWWOdDTbZYpsddtljnwMOOeKYE37zh1POOOeCS6645oZb7rjngUeeeOaFV95454NPvvjmh1//+yXAIEMMM8IoY4wzwSRTTDPDLHPMs8AiSyyzwiprrLPBJltss8Mue+xzwCFHHHPCb/5wyhnnXHDJFdfccMsd9zzwyBPPvPDKG+988MkX3/zwT+gPMMgQw4wwyhjjTDDJFNPMMMsc8yywyBLLrLDKGutssMkW2+ywyx77HPD/FRuU7A== + + + AQAAAACAAAAhAwAAEAAAAA==eJzj4hoFo2AU4AQACOofSw== + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_13.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_13.vtu new file mode 100644 index 00000000000..e9141d2b1ed --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_13.vtu @@ -0,0 +1,50 @@ + + + + + + + AQAAAACAAACoBQAAPgEAAA==eJwtxdciEAAAAECpNIxSqShaGpT2IIkG7UEZRVMSTQlRlFJRpElDEoqQQh/owd3LBQRMmORAT/YUT3WQp3m6Z3imgx3iUId5lmc73HM81/Mc4fle4IWOdJQXebGjHeMlXuplXu4VjvVKr/Jqr3Gc473W65zg9d7gjd7kzd7ird7m7d7hRCd5p5O9yyne7VSneY/3ep/3O90ZPuCDPuTDPuKjPubjPuGTznSWT/m0s53jXOf5jM863wU+5/O+4Iu+5Msu9BUX+aqLfc0lLvV13/BN3/Jt33GZ77rc91zhSlf5vqtd4wd+6FrX+ZEfu95P/NQNfubnfuFGN/mlX7nZLX7tVr/xW7/ze3/wR7e53Z/82V/81R3+5k5/d5d/uNs97vVP/3Kf+/3bAx70kP942H/9zyMe9Zj/exyv0D+j + + + AQAAAACAAACoBQAALgAAAA==eJxjYMAPGAnQhNQPFCDWfejqSPUvtewf6PAaaYBQPAy1eBlu/hkFqAAAesAAIA== + + + AQAAAACAAACoBQAANwAAAA==eJxjYIAARjQaHRCSJwTQ9REyB90+Su0lRA9WQKz7CPlrsPmT2HgZbO4eBdQBo/FPGgAAeZgAIA== + + + + + AQAAAACAAAAACQAAGwAAAA==eJztwwENAAAMw6DOv+kLOSSsmqrqowcuFgJB + + + AQAAAACAAAAAEgAAiwMAAA==eJwtxUMAEAYAAMC4bNu2bdu2bdu2bdu2bdvGll17dPe56gH+quGaruXaruO6ruf6buCGbuTGbuKmbubmbuGWbuXWbuO2buf27uCO7uTO7uKu7ubu7uGe7uXe7uO+7uf+HuCBHuTBHuKhHubhHuGRHuXRHuOxHufxnuCJnuTJnuKpnubpnuGZnuXZnuO5nuf5XuCFXuTFXuKlXublXuGVXuXVXuO1Xuf13uCN3uTN3uKt3ubt3uGd3uXd3uO93uf9PuCDPuTDPuKjPubjPuGTPuXTPuOzPufzvuCLvuTLvuKrvubrvuGbvuXbvuO7vuf7fuCHfuTHfuKnfubnfuGXfuXXfuO3/tf/+Z3f+4M/+pM/+4u/+pu/+4d/+pd/+48DBJQDObCDOKj/cTAHdwiHdCiHdhiHdTiHdwRHdCRHdhRHdTRHdwzHdCzHdhzHdTzHdwIndCIndhIndTIndwqndCqndhqndTqndwZndCZndhZndTZndw7ndC7ndh7ndT7ndwEXdCEXdhEXdTEXdwmXdCmXdhmXdTmXdwVXdCVXdhVXdTVXdw3XdC3Xdh3XdT3XdwM3dCM3dhM3dTM3dwu3dCu3dhu3dTu3dwd3dCd3dhd3dTd3dw/3dC/3dh/3dT/39wAP9CAP9hAP9TAP9wiP9CiP9hiP9TiP9wRP9CRP9hRP9TRP9wzP9CzP9hzP9TzP9wIv9CIv9hIv9TIv9wqv9Cqv9hqv9Tqv9wZv9CZv9hZv9TZv9w7v9C7v9h7v9T7v9wEf9CEf9hEf9TEf9wmf9Cmf9hmf9Tmf9wVf9CVf9hVf9TVf9w3f9C3f9h3f9T3f9wM/9CM/9hM/9TM/9wu/9Cu/9hu/9b/+z+/83h/80Z/82V/81d/83T/807/8238cINDfAjqQAzuIg/ofB3Nwh3BIh3Joh3FYh3N4R3BER3JkR3FUR3N0x3BMx3Jsx3Fcx3N8J3BCJ3JiJ3FSJ3Nyp3BKp3Jqp3Fap3N6Z3BGZ3JmZ3FWZ3N253BO53Ju53Fe53N+F3BBF3JhF3FRF3Nxl3BJl3Jpl3FZl3N5V3BFV3JlV3FVV3N113BN13Jt13Fd13N9N3BDN3JjN3FTN3Nzt3BLt3Jrt3Fbt3N7d3BHd3Jnd3FXd3N393BP93Jv93Ff93N/D/BAD/JgD/FQD/Nwj/BIj/Joj/FYj/N4T/BET/JkT/FUT/P/npYfIA== + + + + + AQAAAACAAAD4EAAAngUAAA==eJydVQlMVFcUFVtNUCrIpIDUolKw1I1qbdFSvDAOwZXESAptqUsTotZirYILNS4RomwGCYsFRavigigq1aZYLAwKWA2zMDBSwsxHBuYzg/XXLhpx6VTnvZ9/Z14n7ctPft557917z73nvjdkyH8ZHEjnAvw7zjrHwjlkD9vHOGvgdYFhD69j+/jvyg/rvKs4XO1zFYca4TyDJ84jPs/KC7aP59g+Hvz/PK9m+OcQztKJmIckpVxf3eX4f74ceQfZY9nH/nF+8Dm8n1UPnB88WPlzFRc+z9IZSy88gw/mzdI19uuqv1n1xHGy8oX5qRn7WfFhOyzerD7Bflj6cJUPXA+cX8zL1X3Cyhv2x7pvXNUZ467s4ThMcGpRAp92+SbCb0NlR2u2MkhL8YLJYwYzay3gma38tF2uo/j5JaWy2+7X4U5/mmJpWhPFZ1dcTclOtMKPxyLn6LYrKT42fthUba4SAs8ZucK6diD+sP8X/2aE6+Dl538lwpUw9DlNMa7Hz2xjXCO0JRdz6d+QuEzgn89ne33RDYXN63N3uOmof1W5dqfiZDfUhHkVvfaqDgjfVXEPmuP8OLjxbr7f+O1NEPJBe1nZk2vAn3kof+TJgX53wJqnqXowyTJVbo+UMBCUNU+/jYMzqqTm3RvrgeTBGJNlPCvnIGt/dkNRTR2tS3jY+2XfHdUD4Setlw4iDwykrktppLisdrWxjyNzPdqvRPU00XwkmtuO+h7TOOSb1JPwJbjh0LStnVEiX4KrmjJm1m9rB7OdL8FJnQlfghfljXuc/luXPe+9ND4D921WWHg3dP71q7V3VSfV2+nKxbOitUYY3OF1zdBmgdH2+LpXcuN1tnwPvnPPZ9ZiUW9bU5MKur7m4Gpu68Mp267BeLuuHhZ6X49PM4Lf/Xlxsw876pDkZ5LMp6bsbp+D/toH+qNXevc76HxLTYCmwNDr0Bd7o7unrZ1gcdD/vZA8z0uHTQ7699J/KSxYYYX8oPm2T0/Xv0/uvJz8iQnpgQwLzPBoeNujoZHi/5zOP95L6y/ZvtPK0IMAzvUggHM9COBcDwI414MAzvUgIL4COOdL9Iz5CuCcr32/je97i2ak9TQbQTHS3NXT0UPrG3cvxvslXw60kenBH9XpaX054y+Z03s4iM2Vl9+Q19P6Vu1fNLj+ugG8h3wcNcVHrG9V2+k1592NEOj7LLCi2wKCvb6mc6nuG2z9/UrEyoCj6fUw2l5fad7JIPnGumsGNzsPKa58gW+xSHHbfSfVr9jXUv2K/gk/3O+EH9E5wYl+iW4J7m3nh/tdWj/8jgg0HqkuBXD+vgjg/H0RwPn7IgB+X6Jnh2720vZRv3t8Wq40VRthzK6G8LF3eRrnkmGFp0fY8OX79lS+kd5P4xk8tStHccEAEcmKtxSX+qj+n3g2XKz1N8DE8+WTzLut9P5fW1V6pDrFCE2yJEVukInGqevYmRgxwujQh9K69SEc60G856V6sOM2PQgbRiyLjRLrLZ1jvVlAW+uWdGeBqIMQWXxN2JFe2k+S7ba5VG8ij7O/f67J1vCIj0D7Bt8nm08uNGxS9zrcJ3098pIVc6wO9wnRIb5PpPzwHOcT8xXAOV/B+dzGS8pf1LOUv6hb6bsgwJ/rFyQcqLNQ/gQffuX1nB1RVsqf4ETP9B3J2xoUk3YLfl5WMn/ecR6CFw90VftqYBTXcnnhUjUkfLZ8w4UEFRRHTF5X3NgCOSMThsriVHAidEKK/K4ZlG/+FHuozQxBE/uLjgdrYHroycyvTLegq+rB6owcHuacKE6EP3gYlbvR4LtCAw2HL07+wbMF5E8vbPcP5+FRTHTpPuBBNdf//sxNahg6VT68IoSH1NaKg+emqKE4J6MkstUMMCy+/ulGM1TeLA32WGqGvR9mJBwMMMPfyABIbw== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAASAAA2wsAAA==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 + + + AQAAAACAAAAAEgAANQMAAA==eJw12BG7MogChdEzc5u53ecJgiAIgiAIgiAIgiAIgiAIgiAIguBAEARBEARBEARBEARBEARBEARBEARBEAQHggtnfVvWb9hv4Ot3QYYYZoRRxhhngkmmmGaGWeaYZ4FFllhmhVXWWGeDTbbYZoff7LLHPgcccsQxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3f/jh11+/BBhkiGFGGGWMcSaYZIppZphljnkWWGSJZVZYZY11Nthki212+M0ue+xzwCFHHHPCKWecc8ElV1xzwy133PPAI08888Irb7zzwSdffPOHH379/UuAQYYYZoRRxhhngkmmmGaGWeaYZ4FFllhmhVXWWGeDTbbYZoff7LLHPgcccsQxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3f/jh139+CTDIEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvs8Jtd9tjngEOOOOaEU84454JLrrjmhlvuuOeBR5545oVX3njng0+++OYPP/wKgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaH3+yyxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPLFN3/44dc/vwQYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdvjNLnvsc8AhRxxzwilnnHPBJVdcc8Mtd9zzwCNPPPPCK2+888EnX3zzhx9+/ftLgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaH3+yyxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPLFN3/44dd/fwkwyBDDjDDKGONMMMkU08wwyxzzLLDIEsussMoa62ywyRbb7PCbXfbY54BDjjjmhFPOOOeCS6645oZb7rjngUeeeOaFV95454NPvvjmDz/8c/gDDDLEMCOMMsY4E0wyxTQzzDLHPAssssQyK6yyxjobbLLFNjv8Zpc99jngkCOOOeGUM8654JIrrrnhljvueeCRJ5554ZU33vngky+++cPPn9Dzv1/+D9jnJJk= + + + AQAAAACAAABAAgAADwAAAA==eJzj4hoFo4B8AABe9xaB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_2.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_2.vtu new file mode 100644 index 00000000000..cd5ae731401 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_2.vtu @@ -0,0 +1,47 @@ + + + + + + + AQAAAACAAAAABQAAFwEAAA==eJwtxdciEAAAAEBNoSGKsoqMNlJ2iTKSQkJGmWVWhJIiKmRGESr6VQ/dvVxAwH97vNf7vN8HfNCBPuQgBzvEh33ER33MoT7uMIf7hE86wpE+5dOOcrRjHOs4n/FZxzvB55zoJCc7xed9wRd9yZd9xVed6jSn+5ozfN03nOksZzvHuc5zvm/6lgt824Uu8h3fdbFLXOoy33O577vCD/zQla5ytR+5xo9d6zrX+4kb3OgmN/upn7nFrW5zuzvc6ed+4S53u8e97nO/X/qVX3vAg37jIQ97xG/9zqN+7zF/8EePe8KfPOkpf/YXf/W0Zzzrb57zvBe86CUv+7tXvOof/uk1r/uXN7zpLf/2H//1tnf8z7teXTGx + + + AQAAAACAAAAABQAAIAAAAA==eJxjZIAARhw0pQCXudSiRzqgdfiOhvsoGM4AAHu4ACA= + + + + + AQAAAACAAACcBwAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8aDBAEi1Aeg= + + + AQAAAACAAAA4DwAADAMAAA==eJwtxVOAEAYAANDrsrHm1WoL27JtXbZt27bdZd1l27Zt27a1j977eckDvkvhlE7l1E7jtE7n9M7gjM7kzM7irM7m7M7hnM7l3M7jvM7n/C7ggi7kIBd2ERd1MRd3CZd0KZd2GZd1OZd3BVd0JVd2FVd1NVd3Ddd0Ldd2Hdd1Pdd3Azd0Izd2Ezd1Mzd3C7d0K7d2G7d1O7d3B3d0J3d2F3d1N3d3D/d0L/d2H/d1P/f3AA/0IA/2EA/1MA/3CI/0KI/2GAd7rMd5vCd4oid5sqd4qqd5ukMc6hme6Vme7Tme63me7wVe6EVe7CVe6mVe7hVe6VVe7TVe63Ve7w3e6E3e7C3e6m3e7h3e6V3e7T3e633e7wM+6EM+7CM+6mM+7hM+6VM+7TM+63M+7wu+6Eu+7Cu+6mu+7hu+6Vu+7Tu+63u+7wd+6Ed+7Cd+6md+7hd+6Vd+7Td+63d+7w/+6E/+7C/+6m8OCCMHOqzDObwjOKIjObKjOKqjObpjOKZjObbj+AfH9Y/+yT/7F//q3/y7/3A8x/efTuCE/st/O5ETO4mT+h//6/+czMmdwimdyqmdxmmdzumdwRmdyZmdxVmdzdmdwzmdy7mdx3mdz/ldwAVdyEEu7CIu6mIu7hIu6VIu7TIu63Iu7wqu6Equ7Cqu6mqu7hqu6Vqu7Tqu63qu7wZu6EZu7CZu6mZu7hZu6VZu7TZu63Zu7w7u6E7u7C7u6m7u7h7u6V7u7T7u637u7wEe6EEe7CEe6mEe7hEe6VEe7TEO9liP83hP8ERP8mRP8VRP83SHONQzPNOzPNtzPNfzPN8LvNCLvNhLvNTLvNwrvNKrvNprvNbrvN4bvNGbvNlbvNXbvN07vNO7vNt7vNf7vN8HfNCHfNhHfNTHfNwnfNKnfNpnfNbnfN4XfNGXfNlXfNXXfN03fNO3fNt3fNf3fN8P/NCP/NhP/NTP/Nwv/NKv/Npv/Nbv/N4f/NGf/Nlf/NXfHBD4vTAOdFiHc3hHcERHcmRHcVRHc3THcEzHcmzH8f9auf0g + + + + + AQAAAACAAAAADwAARQYAAA==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 + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAADgPAAAMgoAAA==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 + + + AQAAAACAAAA4DwAAuAIAAA==eJwtxRGAKgYAANC2tS0IgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIguDgIAiCIAiCg4MgCIIgCIIgCD70nrxg4CPksCOOOua4E0465bQzzjrnvAsuuuSyK6665robbrrltjvuuue+Bx565LEnnnrmuRde+svfXnntjbfeee+Df/zro08+++Krb7774adffjvw16egQw474qhjjjvhpFNOO+Osc8674KJLLrviqmuuu+GmW26746577nvgoUcee+KpZ5574aW//O2V19546533PvjHvz765LMvvvrmux9++uW3A39/CjrksCOOOua4E0465bQzzjrnvAsuuuSyK6665robbrrltjvuuue+Bx565LEnnnrmuRde+svfXnntjbfeee+Df/zro08+++Krb7774adffjvwz6egQw474qhjjjvhpFNOO+Osc8674KJLLrviqmuuu+GmW26746577nvgoUcee+KpZ5574aW//O2V19546533PvjHvz765LMvvvrmux9++uW3A0E55LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY77rrnvgceeuSxJ5565rkXXvrL31557Y233nnvg3/866NPPvviq2++++GnX3478O+noEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltuu+Oue+574KFHHnviqWeee+Glv/ztldfeeOud9z74x78++uSzL7765rsffvrltwP/fQo65LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY77rrnvgceeuSxJ5565rkXXvrL31557Y233nnvg3/866NPPvviq2++++GnX3478P+noEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltuu+Oue+574KFHHnviqWee+w+qOe8J + + + AQAAAACAAADnAQAADgAAAA==eJzj4hoFIwAAACStEwc= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_23.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_23.vtu new file mode 100644 index 00000000000..14b7a35e3d8 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_23.vtu @@ -0,0 +1,50 @@ + + + + + + + AQAAAACAAACoBQAAPgEAAA==eJwtxdciEAAAAECpNIxSqShaGpT2IIkG7UEZRVMSTQlRlFJRpElDEoqQQh/owd3LBQRMmORAT/YUT3WQp3m6Z3imgx3iUId5lmc73HM81/Mc4fle4IWOdJQXebGjHeMlXuplXu4VjvVKr/Jqr3Gc473W65zg9d7gjd7kzd7ird7m7d7hRCd5p5O9yyne7VSneY/3ep/3O90ZPuCDPuTDPuKjPubjPuGTznSWT/m0s53jXOf5jM863wU+5/O+4Iu+5Msu9BUX+aqLfc0lLvV13/BN3/Jt33GZ77rc91zhSlf5vqtd4wd+6FrX+ZEfu95P/NQNfubnfuFGN/mlX7nZLX7tVr/xW7/ze3/wR7e53Z/82V/81R3+5k5/d5d/uNs97vVP/3Kf+/3bAx70kP942H/9zyMe9Zj/exyv0D+j + + + AQAAAACAAACoBQAAMgAAAA==eJxjYEAFjGg0OsAlT4hPLqC2OYTcT0gdLnOpZf8owA4IxQ+x8TVUwUj3/0gHAH4oACA= + + + AQAAAACAAACoBQAAOAAAAA==eJxjYIAARjQaHRCSxwXQ1ROrn5A6dPeQq55U/9AaEBv+g9X9xAJC/hnq/hvqYDR+BhcAAHxoACA= + + + + + AQAAAACAAAAACQAAGwAAAA==eJztwwENAAAMw6DOv+kLOSSsmqrqowcuFgJB + + + AQAAAACAAAAAEgAAiwMAAA==eJwtxUMAEAYAAMC4bNu2bdu2bdu2bdu2bdvGll17dPe56gH+quGaruXaruO6ruf6buCGbuTGbuKmbubmbuGWbuXWbuO2buf27uCO7uTO7uKu7ubu7uGe7uXe7uO+7uf+HuCBHuTBHuKhHubhHuGRHuXRHuOxHufxnuCJnuTJnuKpnubpnuGZnuXZnuO5nuf5XuCFXuTFXuKlXublXuGVXuXVXuO1Xuf13uCN3uTN3uKt3ubt3uGd3uXd3uO93uf9PuCDPuTDPuKjPubjPuGTPuXTPuOzPufzvuCLvuTLvuKrvubrvuGbvuXbvuO7vuf7fuCHfuTHfuKnfubnfuGXfuXXfuO3/tf/+Z3f+4M/+pM/+4u/+pu/+4d/+pd/+48DBJQDObCDOKj/cTAHdwiHdCiHdhiHdTiHdwRHdCRHdhRHdTRHdwzHdCzHdhzHdTzHdwIndCIndhIndTIndwqndCqndhqndTqndwZndCZndhZndTZndw7ndC7ndh7ndT7ndwEXdCEXdhEXdTEXdwmXdCmXdhmXdTmXdwVXdCVXdhVXdTVXdw3XdC3Xdh3XdT3XdwM3dCM3dhM3dTM3dwu3dCu3dhu3dTu3dwd3dCd3dhd3dTd3dw/3dC/3dh/3dT/39wAP9CAP9hAP9TAP9wiP9CiP9hiP9TiP9wRP9CRP9hRP9TRP9wzP9CzP9hzP9TzP9wIv9CIv9hIv9TIv9wqv9Cqv9hqv9Tqv9wZv9CZv9hZv9TZv9w7v9C7v9h7v9T7v9wEf9CEf9hEf9TEf9wmf9Cmf9hmf9Tmf9wVf9CVf9hVf9TVf9w3f9C3f9h3f9T3f9wM/9CM/9hM/9TM/9wu/9Cu/9hu/9b/+z+/83h/80Z/82V/81d/83T/807/8238cINDfAjqQAzuIg/ofB3Nwh3BIh3Joh3FYh3N4R3BER3JkR3FUR3N0x3BMx3Jsx3Fcx3N8J3BCJ3JiJ3FSJ3Nyp3BKp3Jqp3Fap3N6Z3BGZ3JmZ3FWZ3N253BO53Ju53Fe53N+F3BBF3JhF3FRF3Nxl3BJl3Jpl3FZl3N5V3BFV3JlV3FVV3N113BN13Jt13Fd13N9N3BDN3JjN3FTN3Nzt3BLt3Jrt3Fbt3N7d3BHd3Jnd3FXd3N393BP93Jv93Ff93N/D/BAD/JgD/FQD/Nwj/BIj/Joj/FYj/N4T/BET/JkT/FUT/P/npYfIA== + + + + + AQAAAACAAAD4EAAArAUAAA==eJydVA1QVFUUXih1EFRkRzAlHMhG8x/GUis9sEIkMjQYMxJZqPFjPwQqKKGpjZDBigkZoQyUQGqEIlmGqxbsBotm7i4uLCrsPmCXXXYx32j4hz+ttudt7759s+iZnblzv3vf/c5+5ztHIHicoMDxng/HoIk9H47f0cS7fDhfOHuXPCdx8j55z9n/c/aeMz2crWQowfGery5898k8yHPynrP6m4bIT56TQb5D4vY8EqUizbFO7srmte2DuwldSd3I+pE6DLUfyDwxSF6+IP+/ksiP5DfxnJt4+Jz5muQn8aH2LZ++5Dlf/5B5PK6ufN8Pdd6Q+ZH3+PQg83FWP7668c0ZZ/3h7DtnupM4+e6TnmO0A3vFUNv2zQQuhadtKyJ3H1hjUhO4PqLB7/TM+aHIWFPW8T85PCuMreU+FSrYM/2ZwdzTZgYfI5a+0yZSw9RX28rK7v3B4NrSWZ9cDpGDUZircLlj51fIc+Y2bG6DBVW/pYtXWBj8VEXwIvUWKWzvHl7Xn2KA6osXxNLJLeDR4b9a/Xcn+Mw48Lkm5xIsCYyRKE+cA1Fvlt8yIwXewfFzKkdboLsvK/TNLDlUzr8xrTBZB8rK130y2ppgbO2axV7xalDUx9/PTKUgr1q/ZXCYDFan/VP06XAZjDV0jrnnSoH7DGHxGystEHBER31d3wYJo1OT19/SMfpMKDSJPT/qgtaUb6jsvXJGn5RNNweuHeuCNSU++wNL1Iw+yTE3m2PGUyCZ51k0cZwajkaXCNvdGuGrW2pBuycFCWvvyitOyMF3+bCZLflSOJR//aeiTRR47a1yi67TMProwvN0h0UU/KhIbN6+voHhZdcJQw9YJ0SQF+uE+EBaRGxxvRmwToiPOPnszq0hFsA6IY55Yp3YvDTkFYhlRZJ6ZkX8v5X0Jw3Bxf0ZH6c3wcb9S3fv/FJN3NcQK0Y7x6/sd3s5/nd5uGyzsHGr7x/hmWbOe9OE3pKyK70c/x++/oFKrDJx/P9FWNesD/3NHP9vPLhUu0Fp4Pi/t0e0b+UiC8f/V6fuHvPLt3omH3Z9aSYf7AvEMR92fWnGb9gXiCMvu44040P0P5tXDzu8z5+UH9NB2ILZGz1b7Pq0BGc//1a9DqZ1BMYmvNDH8CpKLzRn+mohdt/tuKaGXibPwUOf7Qyt1UL8rh3Vz2X3wXxbPuqL21YsHKkDuTAxNH+ynsnn9rXDt5I36WAgx3D7VLmFowe7foiTfkCc9IMN5/hBIPg15fLxlLf1UDh5ifVH+hDv2fvp4a3CSgMEecjmeMia2PcZPimEuhs7ey72APrspcigrJ5mnU1HDbT194Wt8uqDmKvhXk/5UBCVL/r+jKgBMiV+qj1aA1C6S7mBPdY5IYgLmeFtBvRfTUHkYFqjFgJ8HgRUdZmBtvmppvWH94+66WDUwlV+5dkNMFaTSkdY55z+SIbbOhFF6EgTvrPrir7D+iKOvmP3Bc34ju1zmvEX1hdxth/1wO5DjHZGH0QwH9QHccwH9UEc82H3m32+edr0YfPS4NgP6CvSDzQ49oPt/v/8wDCsG/luVIgecGXz9xI8AkHLaZfE7gjr3BEul8z7zuDYbwwPqae9f9h62ucGW0/7nGHraZ8nbD3t84Stp32e4N7xvKXB8bylwfG8pcHxvKXB8bylOfk61h/zJfWnwbH+RH2tqyxvolBpVEBtuHm4i6cCfl5bvF2QqYSKjmUdwWdNkLRwYulKPxXcGOW/1Cj9C0bVFTS/uFwF3XHvtcS7nYfpNbMOagZMcCc8rGQXmECxeMK1uRuUsPh+7ZYJr5jgwGz/dNEVI8im/B5V2mqEXPdYV2GMAlxerhsfXXABqn0DGtMkJjijSS1PiFRBbb92q4urEm7Gb/DN8TfBpDJR1WvnjJA0MmiEOMIIIR5JZ6nNRhh3ee2RmVOM8C/+dUHr + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAASAAA1AsAAA==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 + + + AQAAAACAAAAAEgAANQMAAA==eJw12BG7MogChdEzc5u53ecJgiAIgiAIgiAIgiAIgiAIgiAIguBAEARBEARBEARBEARBEARBEARBEARBEAQHggtnfVvWb9hv4Ot3QYYYZoRRxhhngkmmmGaGWeaYZ4FFllhmhVXWWGeDTbbYZoff7LLHPgcccsQxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3f/jh11+/BBhkiGFGGGWMcSaYZIppZphljnkWWGSJZVZYZY11Nthki212+M0ue+xzwCFHHHPCKWecc8ElV1xzwy133PPAI08888Irb7zzwSdffPOHH379/UuAQYYYZoRRxhhngkmmmGaGWeaYZ4FFllhmhVXWWGeDTbbYZoff7LLHPgcccsQxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3f/jh139+CTDIEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvs8Jtd9tjngEOOOOaEU84454JLrrjmhlvuuOeBR5545oVX3njng0+++OYPP/wKgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaH3+yyxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPLFN3/44dc/vwQYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdvjNLnvsc8AhRxxzwilnnHPBJVdcc8Mtd9zzwCNPPPPCK2+888EnX3zzhx9+/ftLgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaH3+yyxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPLFN3/44dd/fwkwyBDDjDDKGONMMMkU08wwyxzzLLDIEsussMoa62ywyRbb7PCbXfbY54BDjjjmhFPOOOeCS6645oZb7rjngUeeeOaFV95454NPvvjmDz/8c/gDDDLEMCOMMsY4E0wyxTQzzDLHPAssssQyK6yyxjobbLLFNjv8Zpc99jngkCOOOeGUM8654JIrrrnhljvueeCRJ5554ZU33vngky+++cPPn9Dzv1/+D9jnJJk= + + + AQAAAACAAABAAgAADwAAAA==eJzj4hoFo4B8AABe9xaB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_3.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_3.vtu new file mode 100644 index 00000000000..903af8f33e0 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_full_span_mesh_tet_DFN_3.vtu @@ -0,0 +1,47 @@ + + + + + + + AQAAAACAAAD4BAAAFgEAAA==eJwtxdciEAAAAEAh2crIKiORUlFRKpSZLZrSsFpWSFEkSkZaqIT4Vg/uXi4gYM8+BzrIwd7vEB9wqMMc7ghHOsrRjvFBH3Ks4xzvBB92opOc7BSn+oiPOs3pznCmjznLx53tHJ9wrk/6lPN82md81vku8Dmf9wUXusgXfcnFvuwrvuoSl7rM13zd5a5wpatc7RrfcK3rXO8GN7rJzW7xTbe6zbd823d81/d83+1+4A4/9CM/9hN3usvd7nGvn/qZn/uFX7rP/R7woIf8ysMe8ahfe8xv/NbjnvA7v/ekp/zB0/7oGc/6kz97zl887wUveslfvexv/u4f/ulfXvGq1/zbf/zX6/7nDW96y/+97R3vAtC3MRI= + + + AQAAAACAAAD4BAAAIAAAAA==eJxjZIAARhw0pQCXudSiRzqgdfiOhvsoGI4AAHq4ACA= + + + + + AQAAAACAAACMBwAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8YBhACpNAeQ= + + + AQAAAACAAAAYDwAABAMAAA==eJwtxVNgEAgAANC17DrXIXfKdsu2bdu2bdu2bdu2jdVy66P3fl6ygO+SO4VTOpVTO43TOp3TO4MzOpMzO4uzOpuzO4dzOsi5nNt5nNf5nN8FXNCFXNhFXNTFXNwlXNKlXNplXNblXN4VXNGVXNlVXNXVXN01XNO1XNt1XNf1XN8N3NCN3NhN3NTN3Nwt3NKt3Npt3Nbt3N4d3NGd3Nld3NXd3N093NO93Nt93Nf93N8DPNCDPNhDPNTDPNwjPNKjPNpjPNbjPN4TPNGTPNlTPNXTPN0zPNOzPNtzPNfzPN8LvNCLvNhLvNTLvNwrvNKrvNprvNbrvN4bvNGbvNlbvNXbvN07vNO7vNt7vNf7vN8HfNCHfNhHfNTHfNwnfNKnfNpnfNbnfN4XfNGXfNlXfNXXfN03fNO3fNt3fNf3fN8P/NCP/NhP/NTP/Nwv/NKv/NrBfuO3DvE7v/cHf/Qnf/YXf3WoA8LIgQ7rcA7vCI7oSI7sKI7qaI7uGI7pWI7tH/yjf/LP/sW/+jfHcVz/7j/8p/9yPMd3Aid0Iid2Eif13/7H//o//+9kTu4UTulUTu00Tut0Tu8MzuhMzuwszupszu4czukg53Ju53Fe53N+F3BBF3JhF3FRF3Nxl3BJl3Jpl3FZl3N5V3BFV3JlV3FVV3N113BN13Jt13Fd13N9N3BDN3JjN3FTN3Nzt3BLt3Jrt3Fbt3N7d3BHd3Jnd3FXd3N393BP93Jv93Ff93N/D/BAD/JgD/FQD/Nwj/BIj/Joj/FYj/N4T/BET/JkT/FUT/N0z/BMz/Jsz/Fcz/N8L/BCL/JiL/FSL/Nyr/BKr/Jqr/Far/N6b/BGb/Jmb/FWb/N27/BO7/Ju7/Fe7/N+H/BBH/JhH/FRH/Nxn/BJn/Jpn/FZn/N5X/BFX/JlX/FVX/N13/BN3/Jt3/Fd3/N9P/BDP/JjP/FTP/Nzv/BLv/JrB/uN3zrE7/zeH/zRn/zZX/zVoQ4I/F4YBzqswzm8IziiIzmyoziqozm6Y/gbuIH81g== + + + + + AQAAAACAAADoDgAADQYAAA==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 + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAABgPAAAPQoAAA==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 + + + AQAAAACAAAAYDwAAswIAAA==eJwtxRGAKgYAANC2tS0IgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIDg6CIAiCIAiCIAiCIAiCIAiCIAiCgw/3nrxg4FfIYUccdcxxJ5x0ymlnnHXOeRdcdMllV1x1zXU33HTLbXfcdc99Dzz0yGN/+dsTTz3z3AsvvfLaG2+9894HH33y2RdfffPdDz/98tsf/zjw129Bhxx2xFHHHHfCSaecdsZZ55x3wUWXXHbFVddcd8NNt9x2x1333PfAQ4889pe/PfHUM8+98NIrr73x1jvvffDRJ5998dU33/3w0y+//fGPA3//FnTIYUccdcxxJ5x0ymlnnHXOeRdcdMllV1x1zXU33HTLbXfcdc99Dzz0yGN/+dsTTz3z3AsvvfLaG2+9894HH33y2RdfffPdDz/98tsf/zjwz29Bhxx2xFHHHHfCSaecdsZZ55x3wUWXXHbFVddcd8NNt9x2x1333PfAQ4889pe/PfHUM8+98NIrr73x1jvvffDRJ5998dU33/3w0y+//fGPA0E55LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY77rrnvgceeuSxv/ztiaeeee6Fl1557Y233nnvg48++eyLr7757oeffvntj38c+Pe3oEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltuu+Oue+574KFHHvvL35546pnnXnjpldfeeOud9z746JPPvvjqm+9++OmX3/74x4H/fgs65LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY77rrnvgceeuSxv/ztiaeeee6Fl1557Y233nnvg48++eyLr7757oeffvntj38c+P+3oEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltuu+Oue+574KFHHvsP5YPslQ== + + + AQAAAACAAADjAQAADgAAAA==eJzj4hoFwxwAANi+Et8= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_1.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_1.vtu new file mode 100644 index 00000000000..f2673fbf8e1 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_1.vtu @@ -0,0 +1,38 @@ + + + + + + + AQAAAACAAADoAwAAGQAAAA==eJxjYBjZgHGA1FEbjPqDMnXDHQAAFaAACg== + + + + + + + AQAAAACAAAC4CwAArwEAAA==eJyNljFLA0EQhVMJYpHCH2Blp6D4AzZEK21ttLGS/AMRBFv/QIo0go0oWIiIlVporZKIIAjKYpPF6morRbI57u19zk6z3Mvezs28eW/TaPwXfVePe8AD4AXglCc+K+4BD4AXgOt5mldxD3gAvABc39O8invAA+AF4Pq75lXcAx4ALwDXIF6p79QX+m5rjtL15W1p/qbn3clVZ3N3cTDGJ9aPbpvXwU2dtvZmdgbu63x/8m76UfLmzinlGe1rfcr+MN5/0V1Yax5qXlsH8Xu1jo3V3vHB08fofNWNzpX2OVdn+p7yq7jOlb6fq2PigfRMeiM9xCjr0bmJvP09Jrz6pO+Rj/o6LR+Sfb/5tu/br5fvPlmr9eo5Olfsc9V5DNV6k756Nzf78LzcGY7x+npzfVTnwqpD50r35fo06Yz6RH5Nfhqj1IP6TtRxvS+QbklX1j3TB58gnkteq3wTH1o/+1D9ucF9n221i5Vhslbz5t6T5HM6L3qe4jpX1j1MPko6oDroPo5Bfkx6snyffNn6H0H3AOmYeCA9x7Dm3vIJ4pn4jmH1xfIhypeuP6jlyLs= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAEAAAUgIAAA==eJyFk0VXEGAUBbE7EMEWAxUUsTsAuxsD7O5u/fEuvLOZc77z3uauZs59i9vR8f8mJacnpyWXJZcne5OrxU1OzpAHbkVyjTxwU5Iz5YFbmVwrD9zU5Cx54FYl18nDn/Sdk5yd5E/69iXXi6PvXHng6LtBHjj6zpMHjr4b5YHj7/nywPH3Jnn4k74LkwuS/EnfgWS/OPp2ygNH383ywNF3kTxw9N0iDxx/d8kDx9+D8vAnfbuTi5P8Sd+h5FZx9O2RB46+2+SBo+8SeeDou10eOP5eKg8cf++Qp9r3zuSu5P7kPnGtfcPtTh6Qp9o33J7kQXmqfcPtTR6Sp9o3f9L3SPKwOPp633D0PSoPXGvfcPQdlqfaNxx/j8hT7Zs/6XssOSqutW84+h6Xp9o3HH1PyFPtG24keVKeat/8Sd/TyVPiWvuGo+8Zeap9w9H3rDzVvuH4+5w81b7PJy8kryaviGvtG+5i8po81b7hLiWvy1PtG+5y8oY81b75k743k2PiWvuGo+8teap9w9H3tjzVvuH4+4481b75k74TyXFxrX3D0feuPNW+4eh7T55q33D8fV+eat/8Sd+HyQfiWvuGo+8jeap9w9H3sTzVvuH4+4k81b6fJp8lXydfiWvtG+558o081b7hXiTfylPtG+5l8p081b75k74fku/FtfYNR9+P8lT7hqPvJ3mqfcPx92d5qn3zJ32/Jr+Ia+0bjr7f5Kn2DUff7/JU+4bj7x/yVPvmT/r+Sv4U19o3HH1/y1PtG46+f+Sp9g3H33/l+QdSt3wB + + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= + + + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_12.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_12.vtu new file mode 100644 index 00000000000..4d21fc49eb1 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_12.vtu @@ -0,0 +1,41 @@ + + + + + + + AQAAAACAAADoAwAAGQAAAA==eJxjYBjZgHGA1FEbjPqDMnXDHQAAFaAACg== + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgF+AAjDnqogVF/jGwAABWgAAo= + + + + + + + AQAAAACAAAC4CwAArwEAAA==eJyNljFLA0EQhVMJYpHCH2Blp6D4AzZEK21ttLGS/AMRBFv/QIo0go0oWIiIlVporZKIIAjKYpPF6morRbI57u19zk6z3Mvezs28eW/TaPwXfVePe8AD4AXglCc+K+4BD4AXgOt5mldxD3gAvABc39O8invAA+AF4Pq75lXcAx4ALwDXIF6p79QX+m5rjtL15W1p/qbn3clVZ3N3cTDGJ9aPbpvXwU2dtvZmdgbu63x/8m76UfLmzinlGe1rfcr+MN5/0V1Yax5qXlsH8Xu1jo3V3vHB08fofNWNzpX2OVdn+p7yq7jOlb6fq2PigfRMeiM9xCjr0bmJvP09Jrz6pO+Rj/o6LR+Sfb/5tu/br5fvPlmr9eo5Olfsc9V5DNV6k756Nzf78LzcGY7x+npzfVTnwqpD50r35fo06Yz6RH5Nfhqj1IP6TtRxvS+QbklX1j3TB58gnkteq3wTH1o/+1D9ucF9n221i5Vhslbz5t6T5HM6L3qe4jpX1j1MPko6oDroPo5Bfkx6snyffNn6H0H3AOmYeCA9x7Dm3vIJ4pn4jmH1xfIhypeuP6jlyLs= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAEAAAUgIAAA==eJyFk0VXEGAUBbE7EMEWAxUUsTsAuxsD7O5u/fEuvLOZc77z3uauZs59i9vR8f8mJacnpyWXJZcne5OrxU1OzpAHbkVyjTxwU5Iz5YFbmVwrD9zU5Cx54FYl18nDn/Sdk5yd5E/69iXXi6PvXHng6LtBHjj6zpMHjr4b5YHj7/nywPH3Jnn4k74LkwuS/EnfgWS/OPp2ygNH383ywNF3kTxw9N0iDxx/d8kDx9+D8vAnfbuTi5P8Sd+h5FZx9O2RB46+2+SBo+8SeeDou10eOP5eKg8cf++Qp9r3zuSu5P7kPnGtfcPtTh6Qp9o33J7kQXmqfcPtTR6Sp9o3f9L3SPKwOPp633D0PSoPXGvfcPQdlqfaNxx/j8hT7Zs/6XssOSqutW84+h6Xp9o3HH1PyFPtG24keVKeat/8Sd/TyVPiWvuGo+8Zeap9w9H3rDzVvuH4+5w81b7PJy8kryaviGvtG+5i8po81b7hLiWvy1PtG+5y8oY81b75k743k2PiWvuGo+8teap9w9H3tjzVvuH4+4481b75k74TyXFxrX3D0feuPNW+4eh7T55q33D8fV+eat/8Sd+HyQfiWvuGo+8jeap9w9H3sTzVvuH4+4k81b6fJp8lXydfiWvtG+558o081b7hXiTfylPtG+5l8p081b75k74fku/FtfYNR9+P8lT7hqPvJ3mqfcPx92d5qn3zJ32/Jr+Ia+0bjr7f5Kn2DUff7/JU+4bj7x/yVPvmT/r+Sv4U19o3HH1/y1PtG46+f+Sp9g3H33/l+QdSt3wB + + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= + + + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_123.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_123.vtu new file mode 100644 index 00000000000..b39b6269f6e --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_123.vtu @@ -0,0 +1,44 @@ + + + + + + + AQAAAACAAADoAwAAGQAAAA==eJxjYBjZgHGA1FEbjPqDMnXDHQAAFaAACg== + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgF+AAjDnqogVF/jGwAABWgAAo= + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgFQxkw4qBprW4UDC0AABWgAAo= + + + + + + + AQAAAACAAAC4CwAArwEAAA==eJyNljFLA0EQhVMJYpHCH2Blp6D4AzZEK21ttLGS/AMRBFv/QIo0go0oWIiIlVporZKIIAjKYpPF6morRbI57u19zk6z3Mvezs28eW/TaPwXfVePe8AD4AXglCc+K+4BD4AXgOt5mldxD3gAvABc39O8invAA+AF4Pq75lXcAx4ALwDXIF6p79QX+m5rjtL15W1p/qbn3clVZ3N3cTDGJ9aPbpvXwU2dtvZmdgbu63x/8m76UfLmzinlGe1rfcr+MN5/0V1Yax5qXlsH8Xu1jo3V3vHB08fofNWNzpX2OVdn+p7yq7jOlb6fq2PigfRMeiM9xCjr0bmJvP09Jrz6pO+Rj/o6LR+Sfb/5tu/br5fvPlmr9eo5Olfsc9V5DNV6k756Nzf78LzcGY7x+npzfVTnwqpD50r35fo06Yz6RH5Nfhqj1IP6TtRxvS+QbklX1j3TB58gnkteq3wTH1o/+1D9ucF9n221i5Vhslbz5t6T5HM6L3qe4jpX1j1MPko6oDroPo5Bfkx6snyffNn6H0H3AOmYeCA9x7Dm3vIJ4pn4jmH1xfIhypeuP6jlyLs= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAEAAAUgIAAA==eJyFk0VXEGAUBbE7EMEWAxUUsTsAuxsD7O5u/fEuvLOZc77z3uauZs59i9vR8f8mJacnpyWXJZcne5OrxU1OzpAHbkVyjTxwU5Iz5YFbmVwrD9zU5Cx54FYl18nDn/Sdk5yd5E/69iXXi6PvXHng6LtBHjj6zpMHjr4b5YHj7/nywPH3Jnn4k74LkwuS/EnfgWS/OPp2ygNH383ywNF3kTxw9N0iDxx/d8kDx9+D8vAnfbuTi5P8Sd+h5FZx9O2RB46+2+SBo+8SeeDou10eOP5eKg8cf++Qp9r3zuSu5P7kPnGtfcPtTh6Qp9o33J7kQXmqfcPtTR6Sp9o3f9L3SPKwOPp633D0PSoPXGvfcPQdlqfaNxx/j8hT7Zs/6XssOSqutW84+h6Xp9o3HH1PyFPtG24keVKeat/8Sd/TyVPiWvuGo+8Zeap9w9H3rDzVvuH4+5w81b7PJy8kryaviGvtG+5i8po81b7hLiWvy1PtG+5y8oY81b75k743k2PiWvuGo+8teap9w9H3tjzVvuH4+4481b75k74TyXFxrX3D0feuPNW+4eh7T55q33D8fV+eat/8Sd+HyQfiWvuGo+8jeap9w9H3sTzVvuH4+4k81b6fJp8lXydfiWvtG+558o081b7hXiTfylPtG+5l8p081b75k74fku/FtfYNR9+P8lT7hqPvJ3mqfcPx92d5qn3zJ32/Jr+Ia+0bjr7f5Kn2DUff7/JU+4bj7x/yVPvmT/r+Sv4U19o3HH1/y1PtG46+f+Sp9g3H33/l+QdSt3wB + + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= + + + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_13.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_13.vtu new file mode 100644 index 00000000000..2547fa4eead --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_13.vtu @@ -0,0 +1,41 @@ + + + + + + + AQAAAACAAADoAwAAGQAAAA==eJxjYBjZgHGA1FEbjPqDMnXDHQAAFaAACg== + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgFQxkw4qBprW4UDC0AABWgAAo= + + + + + + + AQAAAACAAAC4CwAArwEAAA==eJyNljFLA0EQhVMJYpHCH2Blp6D4AzZEK21ttLGS/AMRBFv/QIo0go0oWIiIlVporZKIIAjKYpPF6morRbI57u19zk6z3Mvezs28eW/TaPwXfVePe8AD4AXglCc+K+4BD4AXgOt5mldxD3gAvABc39O8invAA+AF4Pq75lXcAx4ALwDXIF6p79QX+m5rjtL15W1p/qbn3clVZ3N3cTDGJ9aPbpvXwU2dtvZmdgbu63x/8m76UfLmzinlGe1rfcr+MN5/0V1Yax5qXlsH8Xu1jo3V3vHB08fofNWNzpX2OVdn+p7yq7jOlb6fq2PigfRMeiM9xCjr0bmJvP09Jrz6pO+Rj/o6LR+Sfb/5tu/br5fvPlmr9eo5Olfsc9V5DNV6k756Nzf78LzcGY7x+npzfVTnwqpD50r35fo06Yz6RH5Nfhqj1IP6TtRxvS+QbklX1j3TB58gnkteq3wTH1o/+1D9ucF9n221i5Vhslbz5t6T5HM6L3qe4jpX1j1MPko6oDroPo5Bfkx6snyffNn6H0H3AOmYeCA9x7Dm3vIJ4pn4jmH1xfIhypeuP6jlyLs= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAEAAAUgIAAA==eJyFk0VXEGAUBbE7EMEWAxUUsTsAuxsD7O5u/fEuvLOZc77z3uauZs59i9vR8f8mJacnpyWXJZcne5OrxU1OzpAHbkVyjTxwU5Iz5YFbmVwrD9zU5Cx54FYl18nDn/Sdk5yd5E/69iXXi6PvXHng6LtBHjj6zpMHjr4b5YHj7/nywPH3Jnn4k74LkwuS/EnfgWS/OPp2ygNH383ywNF3kTxw9N0iDxx/d8kDx9+D8vAnfbuTi5P8Sd+h5FZx9O2RB46+2+SBo+8SeeDou10eOP5eKg8cf++Qp9r3zuSu5P7kPnGtfcPtTh6Qp9o33J7kQXmqfcPtTR6Sp9o3f9L3SPKwOPp633D0PSoPXGvfcPQdlqfaNxx/j8hT7Zs/6XssOSqutW84+h6Xp9o3HH1PyFPtG24keVKeat/8Sd/TyVPiWvuGo+8Zeap9w9H3rDzVvuH4+5w81b7PJy8kryaviGvtG+5i8po81b7hLiWvy1PtG+5y8oY81b75k743k2PiWvuGo+8teap9w9H3tjzVvuH4+4481b75k74TyXFxrX3D0feuPNW+4eh7T55q33D8fV+eat/8Sd+HyQfiWvuGo+8jeap9w9H3sTzVvuH4+4k81b6fJp8lXydfiWvtG+558o081b7hXiTfylPtG+5l8p081b75k74fku/FtfYNR9+P8lT7hqPvJ3mqfcPx92d5qn3zJ32/Jr+Ia+0bjr7f5Kn2DUff7/JU+4bj7x/yVPvmT/r+Sv4U19o3HH1/y1PtG46+f+Sp9g3H33/l+QdSt3wB + + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= + + + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_2.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_2.vtu new file mode 100644 index 00000000000..45cf06e697f --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_2.vtu @@ -0,0 +1,38 @@ + + + + + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgF+AAjDnqogVF/jGwAABWgAAo= + + + + + + + AQAAAACAAAC4CwAArwEAAA==eJyNljFLA0EQhVMJYpHCH2Blp6D4AzZEK21ttLGS/AMRBFv/QIo0go0oWIiIlVporZKIIAjKYpPF6morRbI57u19zk6z3Mvezs28eW/TaPwXfVePe8AD4AXglCc+K+4BD4AXgOt5mldxD3gAvABc39O8invAA+AF4Pq75lXcAx4ALwDXIF6p79QX+m5rjtL15W1p/qbn3clVZ3N3cTDGJ9aPbpvXwU2dtvZmdgbu63x/8m76UfLmzinlGe1rfcr+MN5/0V1Yax5qXlsH8Xu1jo3V3vHB08fofNWNzpX2OVdn+p7yq7jOlb6fq2PigfRMeiM9xCjr0bmJvP09Jrz6pO+Rj/o6LR+Sfb/5tu/br5fvPlmr9eo5Olfsc9V5DNV6k756Nzf78LzcGY7x+npzfVTnwqpD50r35fo06Yz6RH5Nfhqj1IP6TtRxvS+QbklX1j3TB58gnkteq3wTH1o/+1D9ucF9n221i5Vhslbz5t6T5HM6L3qe4jpX1j1MPko6oDroPo5Bfkx6snyffNn6H0H3AOmYeCA9x7Dm3vIJ4pn4jmH1xfIhypeuP6jlyLs= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAEAAAUgIAAA==eJyFk0VXEGAUBbE7EMEWAxUUsTsAuxsD7O5u/fEuvLOZc77z3uauZs59i9vR8f8mJacnpyWXJZcne5OrxU1OzpAHbkVyjTxwU5Iz5YFbmVwrD9zU5Cx54FYl18nDn/Sdk5yd5E/69iXXi6PvXHng6LtBHjj6zpMHjr4b5YHj7/nywPH3Jnn4k74LkwuS/EnfgWS/OPp2ygNH383ywNF3kTxw9N0iDxx/d8kDx9+D8vAnfbuTi5P8Sd+h5FZx9O2RB46+2+SBo+8SeeDou10eOP5eKg8cf++Qp9r3zuSu5P7kPnGtfcPtTh6Qp9o33J7kQXmqfcPtTR6Sp9o3f9L3SPKwOPp633D0PSoPXGvfcPQdlqfaNxx/j8hT7Zs/6XssOSqutW84+h6Xp9o3HH1PyFPtG24keVKeat/8Sd/TyVPiWvuGo+8Zeap9w9H3rDzVvuH4+5w81b7PJy8kryaviGvtG+5i8po81b7hLiWvy1PtG+5y8oY81b75k743k2PiWvuGo+8teap9w9H3tjzVvuH4+4481b75k74TyXFxrX3D0feuPNW+4eh7T55q33D8fV+eat/8Sd+HyQfiWvuGo+8jeap9w9H3sTzVvuH4+4k81b6fJp8lXydfiWvtG+558o081b7hXiTfylPtG+5l8p081b75k74fku/FtfYNR9+P8lT7hqPvJ3mqfcPx92d5qn3zJ32/Jr+Ia+0bjr7f5Kn2DUff7/JU+4bj7x/yVPvmT/r+Sv4U19o3HH1/y1PtG46+f+Sp9g3H33/l+QdSt3wB + + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= + + + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_23.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_23.vtu new file mode 100644 index 00000000000..387c306b8bc --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_23.vtu @@ -0,0 +1,41 @@ + + + + + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgF+AAjDnqogVF/jGwAABWgAAo= + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgFQxkw4qBprW4UDC0AABWgAAo= + + + + + + + AQAAAACAAAC4CwAArwEAAA==eJyNljFLA0EQhVMJYpHCH2Blp6D4AzZEK21ttLGS/AMRBFv/QIo0go0oWIiIlVporZKIIAjKYpPF6morRbI57u19zk6z3Mvezs28eW/TaPwXfVePe8AD4AXglCc+K+4BD4AXgOt5mldxD3gAvABc39O8invAA+AF4Pq75lXcAx4ALwDXIF6p79QX+m5rjtL15W1p/qbn3clVZ3N3cTDGJ9aPbpvXwU2dtvZmdgbu63x/8m76UfLmzinlGe1rfcr+MN5/0V1Yax5qXlsH8Xu1jo3V3vHB08fofNWNzpX2OVdn+p7yq7jOlb6fq2PigfRMeiM9xCjr0bmJvP09Jrz6pO+Rj/o6LR+Sfb/5tu/br5fvPlmr9eo5Olfsc9V5DNV6k756Nzf78LzcGY7x+npzfVTnwqpD50r35fo06Yz6RH5Nfhqj1IP6TtRxvS+QbklX1j3TB58gnkteq3wTH1o/+1D9ucF9n221i5Vhslbz5t6T5HM6L3qe4jpX1j1MPko6oDroPo5Bfkx6snyffNn6H0H3AOmYeCA9x7Dm3vIJ4pn4jmH1xfIhypeuP6jlyLs= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAEAAAUgIAAA==eJyFk0VXEGAUBbE7EMEWAxUUsTsAuxsD7O5u/fEuvLOZc77z3uauZs59i9vR8f8mJacnpyWXJZcne5OrxU1OzpAHbkVyjTxwU5Iz5YFbmVwrD9zU5Cx54FYl18nDn/Sdk5yd5E/69iXXi6PvXHng6LtBHjj6zpMHjr4b5YHj7/nywPH3Jnn4k74LkwuS/EnfgWS/OPp2ygNH383ywNF3kTxw9N0iDxx/d8kDx9+D8vAnfbuTi5P8Sd+h5FZx9O2RB46+2+SBo+8SeeDou10eOP5eKg8cf++Qp9r3zuSu5P7kPnGtfcPtTh6Qp9o33J7kQXmqfcPtTR6Sp9o3f9L3SPKwOPp633D0PSoPXGvfcPQdlqfaNxx/j8hT7Zs/6XssOSqutW84+h6Xp9o3HH1PyFPtG24keVKeat/8Sd/TyVPiWvuGo+8Zeap9w9H3rDzVvuH4+5w81b7PJy8kryaviGvtG+5i8po81b7hLiWvy1PtG+5y8oY81b75k743k2PiWvuGo+8teap9w9H3tjzVvuH4+4481b75k74TyXFxrX3D0feuPNW+4eh7T55q33D8fV+eat/8Sd+HyQfiWvuGo+8jeap9w9H3sTzVvuH4+4k81b6fJp8lXydfiWvtG+558o081b7hXiTfylPtG+5l8p081b75k74fku/FtfYNR9+P8lT7hqPvJ3mqfcPx92d5qn3zJ32/Jr+Ia+0bjr7f5Kn2DUff7/JU+4bj7x/yVPvmT/r+Sv4U19o3HH1/y1PtG46+f+Sp9g3H33/l+QdSt3wB + + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= + + + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_3.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_3.vtu new file mode 100644 index 00000000000..9ee6b7607eb --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_hex_DFN_3.vtu @@ -0,0 +1,38 @@ + + + + + + + AQAAAACAAADoAwAAFwAAAA==eJxjYBgFQxkw4qBprW4UDC0AABWgAAo= + + + + + + + AQAAAACAAAC4CwAArwEAAA==eJyNljFLA0EQhVMJYpHCH2Blp6D4AzZEK21ttLGS/AMRBFv/QIo0go0oWIiIlVporZKIIAjKYpPF6morRbI57u19zk6z3Mvezs28eW/TaPwXfVePe8AD4AXglCc+K+4BD4AXgOt5mldxD3gAvABc39O8invAA+AF4Pq75lXcAx4ALwDXIF6p79QX+m5rjtL15W1p/qbn3clVZ3N3cTDGJ9aPbpvXwU2dtvZmdgbu63x/8m76UfLmzinlGe1rfcr+MN5/0V1Yax5qXlsH8Xu1jo3V3vHB08fofNWNzpX2OVdn+p7yq7jOlb6fq2PigfRMeiM9xCjr0bmJvP09Jrz6pO+Rj/o6LR+Sfb/5tu/br5fvPlmr9eo5Olfsc9V5DNV6k756Nzf78LzcGY7x+npzfVTnwqpD50r35fo06Yz6RH5Nfhqj1IP6TtRxvS+QbklX1j3TB58gnkteq3wTH1o/+1D9ucF9n221i5Vhslbz5t6T5HM6L3qe4jpX1j1MPko6oDroPo5Bfkx6snyffNn6H0H3AOmYeCA9x7Dm3vIJ4pn4jmH1xfIhypeuP6jlyLs= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAEAAAUgIAAA==eJyFk0VXEGAUBbE7EMEWAxUUsTsAuxsD7O5u/fEuvLOZc77z3uauZs59i9vR8f8mJacnpyWXJZcne5OrxU1OzpAHbkVyjTxwU5Iz5YFbmVwrD9zU5Cx54FYl18nDn/Sdk5yd5E/69iXXi6PvXHng6LtBHjj6zpMHjr4b5YHj7/nywPH3Jnn4k74LkwuS/EnfgWS/OPp2ygNH383ywNF3kTxw9N0iDxx/d8kDx9+D8vAnfbuTi5P8Sd+h5FZx9O2RB46+2+SBo+8SeeDou10eOP5eKg8cf++Qp9r3zuSu5P7kPnGtfcPtTh6Qp9o33J7kQXmqfcPtTR6Sp9o3f9L3SPKwOPp633D0PSoPXGvfcPQdlqfaNxx/j8hT7Zs/6XssOSqutW84+h6Xp9o3HH1PyFPtG24keVKeat/8Sd/TyVPiWvuGo+8Zeap9w9H3rDzVvuH4+5w81b7PJy8kryaviGvtG+5i8po81b7hLiWvy1PtG+5y8oY81b75k743k2PiWvuGo+8teap9w9H3tjzVvuH4+4481b75k74TyXFxrX3D0feuPNW+4eh7T55q33D8fV+eat/8Sd+HyQfiWvuGo+8jeap9w9H3sTzVvuH4+4k81b6fJp8lXydfiWvtG+558o081b7hXiTfylPtG+5l8p081b75k74fku/FtfYNR9+P8lT7hqPvJ3mqfcPx92d5qn3zJ32/Jr+Ia+0bjr7f5Kn2DUff7/JU+4bj7x/yVPvmT/r+Sv4U19o3HH1/y1PtG46+f+Sp9g3H33/l+QdSt3wB + + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= + + + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_1.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_1.vtu new file mode 100644 index 00000000000..78db4fb9cfb --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_1.vtu @@ -0,0 +1,47 @@ + + + + + + + AQAAAACAAADwBAAAEwEAAA==eJwtxdciEAAAAEBKiTKSVMrehCYlZc/s7LLaVFIUyqhoUAmJRP/qwd3LBQTsC/QBH3SQD/mwg33EIQ71UR9zmMMd4Ugfd5RPONonHeNTPu0zjvVZn3Oc453gRCc52SlOdZrTneFMZznbOT7vXOc53xd80Zd82Vd81QUu9DVfd5FvuNg3fcslLnWZy13hSle52jWudZ3rfdsNbnSTm93iVrf5jtvd4U53uds97vVd33Of+z3gQQ/5vh/4oR/5sZ/4qYc94md+7hce9UuP+ZVfe9wTfuO3nvSUp/3O7z3jWc953h/80Z+84EV/9hd/9Tcvednf/cM/veJfXvWa1/3bG/7jTW/5r7f9zzve9X/vAUgYMHQ= + + + AQAAAACAAADwBAAAHwAAAA==eJxjZIAARhw0pQCXudQyf7iD0fAbBaOAegAAN6AADQ== + + + + + AQAAAACAAACcBwAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8aDBAEi1Aeg= + + + AQAAAACAAAA4DwAADAMAAA==eJwtxVOAEAYAANDrsm3btn3hsm3btnkZlxfG2mqoLdu2bdvYR+/9vI0B323yZm/xVm/zdu/wTu/ybu/xXu/zfh/wQR/yYR/xUR/zcZ/wSZ/yaZ/xWZ/zeV/wRV/yZV/xVV/zdd/wTd/ybd/xXd/zfT/wQz/yYz/xUz/zc7/wS7/ya7/xW7/ze3/wR3/yZ3/xV39zQBg50GEdzuEdwREdyZEdxVEdzdEdwzEdy7Edx3Edz/GdwAmdyImdxEmdzMmdwimdyqmdxmmdzumdwRmdyZmdxVmdzdmdwzmdy7mdx3mdz/ldwAVdyIVdxEVdzMVdwiVdyqVdxmVdzuUd5Aqu6Equ7GBXcVVXc3XXcE3Xcm3XcV3Xc303cEM3cmM3cVM3c3O3cEu3cmu3cVu3c3t3cEd3cmd3cVd3c3f3cE/3cm/3cV/3c38P8EAP8mAP8VAP83CP8EiP8miP8ViP83hP8ERP8mRP8VSHeJqne4ZnepZne47nep7nO9QLvNCLvNhLvNTL/IOXe4VXepV/9E/+2b/4V//m1V7j3/2H13qd//Rf/tv/eL03+F//543e5M3e4q3e5u3e4Z3e5d3e473e5/0+4IM+5MM+4qM+5uM+4ZM+5dM+47M+5/O+4Iu+5Mu+4qu+5uu+4Zu+5du+47u+5/t+4Id+5Md+4qd+5ud+4Zd+5dd+47d+5/f+4I/+5M/+4q/+5oDA74VxoMM6nMM7giM6kiM7iqM6mqM7hmM6lmM7juM6nuM7gRM6kRM7iZM6mZM7hVM6lVM7jdM6ndM7gzM6kzM7i7M6m7M7h3M6l3M7j/M6n/O7gAu6kAu7iIu6mIu7hEu6lEu7jMu6nMs7yBVc0ZVc2cGu4qqu5uqu4Zqu5dqu47qu5/pu4IZu5MZu4qZu5uZu4ZZu5dZu47Zu5/bu4I7u5M7u4q7u5u7u4Z7u5d7u477u5/4e4IEe5MEe4qEe5uEe4ZEe5dEe47Ee5/Ge4Ime5Mme4qkO8TRP9wzP9CzP9hzP9TzPd6gXeKEXebGXeKmX+X+HjfBe + + + + + AQAAAACAAADQDgAAygUAAA==eJytlXlQE1ccx0FExYhgsTAoUwQBAW+gKtXyA5U6ArGooBx1RDyQAapMpRUqKo4U74NSC+0IKkZE1AaLSjxoNWKUBEgIkpBoCNkIG6o2HhCrIE0xb1c3idHq+yM777Obd3zeb76vUeI7/lK+HErOJsSsnywAs77Gh+iQfEZOnQwa+97jenycO69hVkK7juO67+RQnjcp1OZgLcHNDDa1EW7sO+r3pvqmvnvbJ2ryl/1ABeHhNU7sU27kiZv4P7XxjXBj31M989+8Dz2Om/BMXY/ayPrVFB/U9VDbu+7n//6fuj7quO/q6X19UL1S6446P3UcY/X6vuN96Lr50Ouijm/a9y3aTOuwO61Q5rB1RP4FqY6LwS5q1knOwzugWSjzchqI6fhtiAlgwI6uFhhf1OAc/L2Ob8ZAMfb0oCv9WmHG8eIHmYObX/L1CmKe42FReMY5LjE+4prR91Yu0GBQsPPZj/X+KoL399t4X/CNCkaMrZ6yJExE8D1r10bQbcVgjzuW+81Q6Z3DyWbhzqtu5LzZXcfumk/hQu7sUWFPApUE9/XIsTh9RgaW16bZlZY1EHxlRkT00xQcQjomz4uZjhGc62X/w4TbQpiU1BrUfeQ6ZV4lMLsit+2Sswl+om8dHYCeiEcUMPmdyRw9nj/BTWFJ74DU5FW+tivJ8U8Pr6hkXMIgbccY5wOLJQTfnh09s/LUVWgJdVu62pwN91jBDl6hXOL9fWlWIZ2u9catcZjdQ+6juMrtyzUWXGDdX/RxgLSd4Gzs0aq6ExhwDuXwFg0mz+ewYxFzt1QFAomEHjCN5C9SA1jpkTdhU4nCKqW4heBPsYm0uFwprGtKKDrrStal1a2fVwgZGGyKScp5bkOeW4VgblU4WwTTFbGnikrJdYpHx03r7FTBg0ci7ufV5PiSPGHVnedKKKP4i9J5rfnq8uNqOslzzL9j/cnqAPSeeg4RFI7OBfkkPPY1NeEN+UK8t+alZ+QX8Zs6n8gj4sgn8oh4ps4n8oj4DJ0f5AVx5Bn5RRx5Rn4RRz6RR8SRN+QL8SiDntSE/ygKN1zfatBcu1GyP0tM9OOq3eRKjAecISsEiYUk/yegzcMpUAW88fGfHjlJ7jO6VMN52t0EtB7XHpducp+7el2LD2hzQLEn96CrI5mX3/7RNW7qEAzyMkN8KjbVErzfMX58YjwGQob9vtYt5P65JR5nnDpuwNYMx7sSMZmv/VMOjpmXjIF0QoHnjunkPmnMzovhv4jg9uNxJ+o9yPX/tWC5f91Rqd7+UZ/q0XBOkB7Zwi13j70yL+r3T0/hjuxVELy8cFjX3/nNYCxnjeWpbeUYv9hhYr38reRwIpu1uUzN2ee9/7UWvZyNGaqUxGpzNnPwr057XslZH13ODqTkbOw570O0r3GwczqqLH+LnDXv+1VCBSVnUR1S88BUzq6j5OzisvhRJdqcrdp5ETvyhpw1e62pjfjW1rvBe01bTwbPQQ2G7zXyHn/dtxoM32tqMHyvqcHwvaate4O+0bzUe810vVK54XtNDYbvNTVQfVuHJnXOHcuDwLnBD32zlZCmVIeytrUCM9kv57KjAHrnj3Cv/EIElkv8C3vOyyHf03J7KbMdHtI0+133K+Fi0rNcRWML9C5nB20owEHOYv8+x0kEy9zd7fqlyYC2fnOYP7MWLtzkzLq6VwZrtkyu2u2HgzD9J2uPPBw6Zlsc9ubJoHpk/Jw8ZRvsWzP0nEMWDquPRzhXtbbBYgFD4vaiHnLLTo0UNtaBt9LWWRqCw9nU7I/EZe0QXr1sqkVeOzRlPQnfpn0WNqd62nS2gUtN4toV3lz4bcD8hbun4lBtNdOs26YBPIM3eknO14GLlcvEqKB64CWuW33Fkw+pn/jP3ztABSKGa/DhQQKwvzTceunmWnDh3Do/VMKHDNpn1+JsedCUmh6p2YBDrI+HLMMHh+sJ0emFjnUweh7Q07T9fwGz2WtL + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAADgPAAAqAoAAA==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 + + + AQAAAACAAAA4DwAAuAIAAA==eJwtxRGAKgYAANC2tS0IgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIguDgIAiCIAiCg4MgCIIgCIIgCD70nrxg4CPksCOOOua4E0465bQzzjrnvAsuuuSyK6665robbrrltjvuuue+Bx565LEnnnrmuRde+svfXnntjbfeee+Df/zro08+++Krb7774adffjvw16egQw474qhjjjvhpFNOO+Osc8674KJLLrviqmuuu+GmW26746577nvgoUcee+KpZ5574aW//O2V19546533PvjHvz765LMvvvrmux9++uW3A39/CjrksCOOOua4E0465bQzzjrnvAsuuuSyK6665robbrrltjvuuue+Bx565LEnnnrmuRde+svfXnntjbfeee+Df/zro08+++Krb7774adffjvwz6egQw474qhjjjvhpFNOO+Osc8674KJLLrviqmuuu+GmW26746577nvgoUcee+KpZ5574aW//O2V19546533PvjHvz765LMvvvrmux9++uW3A0E55LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY77rrnvgceeuSxJ5565rkXXvrL31557Y233nnvg3/866NPPvviq2++++GnX3478O+noEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltuu+Oue+574KFHHnviqWeee+Glv/ztldfeeOud9z74x78++uSzL7765rsffvrltwP/fQo65LAjjjrmuBNOOuW0M84657wLLrrksiuuuua6G2665bY77rrnvgceeuSxJ5565rkXXvrL31557Y233nnvg3/866NPPvviq2++++GnX3478P+noEMOO+KoY4474aRTTjvjrHPOu+CiSy674qprrrvhpltuu+Oue+574KFHHnviqWee+w+qOe8J + + + AQAAAACAAADnAQAADgAAAA==eJzj4hoFIwAAACStEwc= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_12.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_12.vtu new file mode 100644 index 00000000000..76c72936670 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_12.vtu @@ -0,0 +1,50 @@ + + + + + + + AQAAAACAAAAgBQAAHwEAAA==eJwtxddCCAAAAMBKhVCaKFQiLQ1JES1CQmmJ0lIJoVJmpZA0JTMr1Y966O7lAgI2BTrIWxzsEId6q7d5u8O8wzu9y+GO8G5HOsrRjnGs47zHe73P8U7wfh/wQSc6yck+5BQf9hGn+qjTnO4MZzrLx5ztHOc6z8ed7xMu8EkXusinfNrFPuOzLnGpy1zuCp/zeVf6gi/6kqt82dW+4qu+5hrX+rrrXO8GN7rJN9zsm77lFrf6ttvc7g53ust33O0e9/qu+3zP9/3A/X7oR37sAQ96yE887BE/9TM/9wu/9CuPeszjfu0JT/qN3/qdp/ze0/7gGc96zvNe8KI/esmfvOzP/uKv/ubv/uEV//Qv//Yf//Wq/3nN697wf8cnNDc= + + + AQAAAACAAAAgBQAAHgAAAA==eJxjZIAARiJpWoOBsne4gYGOx1EwCoYDAAA98AAO + + + AQAAAACAAAAgBQAAJQAAAA==eJxjYEAFjGg0OkCXJ6SeXIBuHq3sGamAXvE4CkbBUAYAPKgADg== + + + + + AQAAAACAAAAQCAAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8YjGACywAgU= + + + AQAAAACAAAAgEAAANwMAAA==eJwtxUMQGAYAALBi1Wrbtm3bWm3btm3b1mrbtm3b2t2afJIkYID/JXUyJ3cKp3Qqp3Yap3U6p3cGZ3QmZ3YWZ3U2Z3cO53Qu53Ye53U+53cBF3QhF3YRF3UxF3cJl3Qpl3YZl3U5l3cFV3QlV3YVV/U/rubqruGaruXaruO6ruf6buCGbuTGbuKmbubmbuGWbuXWbuO2buf27uCO7uTO7uKu7ubu7uGe7uXe7uO+7uf+HuCBHuTBHuKhHubhHuGRHuXRHuOxHufxnuCJnuTJnuKpnubpnuGZnuXZnuO5nuf5XuCFXuTFXuKlXublXuGVXuXVXuO1Xud/vd4bvNGbvNlbvNXbvN07vNO7vNt7vNf7vN8HfNCHfNhHfNTHfNwnfNKnfNpnfNbnfN4XfNGXfNlXfNXXfN03fNO3fNt3fNf3fN8P/NCP/NhP/NTP/Nwv/NKv/Npv/Nbv/N4f/NGf/Nlf/NXf/N0//NO//NsBAv0poAM5sP9yEAd1MAd3CP/tkA7l0A7jsA7n8I7giI7kyI7iqI7m6I7hmI7l2I7juI7n+E7ghE7kxE7ipE7m5E7hlE7l1E7jtE7n9M7gjM7kzM7irM7m7M7hnM7l3M7jvM7n/C7ggi7kwi7ioi7m4i7hki7l0i7jsi7n8q7giq7kyq7iqv7H1VzdNVzTtVzbdVzX9VzfDdzQjdzYTdzUzdzcLdzSrdzabdzW7dzeHdzRndzZXdzV3dzdPdzTvdzbfdzX/dzfAzzQgzzYQzzUwzzcIzzSozzaYzzW4zzeEzzRkzzZUzzV0zzdMzzTszzbczzX8zzfC7zQi7zYS7zUy7zcK7zSq7zaa7zW6/yv13uDN3qTN3uLt3qbt3uHd3qXd3uP93qf9/uAD/qQD/uIj/qYj/uET/qUT/uMz/qcz/uCL/qSL/uKr/qar/uGb/qWb/uO7/qe7/uBH/qRH/uJn/qZn/uFX/qVX/uN3/qd3/uDP/qTP/uLv/qbv/uHf/qXfztA4D8FdCAH9l8O4qAO5uAO4b8d0qEc2mEc1uEc3hEc0ZEc2VEc1dEc3TEc07Ec23Ec1/Ec3wmc0Imc2Emc1Mmc3P8By8kDBg== + + + + + AQAAAACAAABgDwAAVQUAAA==eJytlXtQVFUcx68BhoEyMiJDUjOhQBHkaxwpkJ9jmYatmhkD2AMRIxWsRgMti4E0LDQFqRaG5SlLQBYGzAj5GhFQWGAXkH2prHtXdxfRNhRFxciJ87vXe+QOmd5/zpzP/d3z+Jzvnu3UzQ44LDXAwcwZS1xkLcD8+1igk/CS6tjILTNVhCtJa6Bai7A/38jVR4RKi1Nbz4O/t6L91VgzV498eB4LNb5S9P3I67KIztM54v7oxybCxero+tH6o9X915Y89/kdbg2w9sQCdeW5B1t8P9xS50SfJzcuXWcQ2Y9ShIvVWyiuFPFpEOGWUfzT67GJrN9G7ZNeD/087H7+7/f0+uhxH9bTo/qgvdJ5pOenxxHL8aOO97hz87jXRY8/uu/LDgVj5VcN4Hf9SF+lVxfhJjjjtGD8m+cuQLn79qeltXrCNdS4Jq4d/v48DI9nouo1ou9HnsckOs/I62WYK/rkXIlEDb01C91fWNLM8aKj05Z9bHev39zk/tpdluN1bN+HrWUs1FwJcwvRmzle4JFXsVtvhcb8VEXYUxqO//1pSM3Wd06DSqeThATyfICd7hSVoYekEuO4+KJujo8781NMRzELm7ti86q9+POpUr1xdHmdGpIiN6TecbFyXDM1KrC/3wpBxlUH8kr5deoyO46eu2OCq33q5nn1/PjhWRXK/rhGKNd2pJ2Y1sPx1DGJNcdreqDp3SPX6iU8X0nq8TvkZeR7fO9pHxuzZ6iJe59zS+LeXMHCihftc75ONnFcuTjRL1FyGn5uvdE4tpHP0w7ZFP+5x1hQjdm8qXg8fw5Wh1qHw09qYGKyqzzdrOV4kFF3sralGwYq338lIIjn2VHx11zzLXDbu75ijS/PbW7ZGzJzFOAcltCxpZ73F1HV3h18uwsGfR0K1bP4dYZWaT97ZmYP7ApbykoDjByf9I3VT9rLPuAvXMQT1tEc+y5L8l6fPJMfB/tlM27a75zNn+ft8d7rTo3RcT4VxCPZHciJz+3EI3I8FzwP5OgZ/SJHz+gXOXpGvxwnntEvcvQcTvwiv0M8o1/kacSzK/GLfOS82mBkr3w9zScQrxMEvm1QSjyjX+Q3T54qSU/mvUTVTzOYWAU0Oseo1uXy/FbIJR/P+VZQBETPKfzFyvGI0puNA4Nd4HTX6+5zg/x+dg15Ff0YbAXj9xkyLw/+nk44dsN/rjMLmV+GzqpKauH4E3Jl9LpoFjqKJ++9kGLieHOJz++ePadg++ceF3Ua/jzs42W+S+NY0L+U9fx3Qfz+nSr6/1ierYaz1/zL2nz49V9esebl1v16KKP80r9vmtP1WFfXkXJRft+82LffGt88ZcjI8YO5E2/8KdVy/oT5ZJhVxJ8w5wwTQ85hhyDnDJNGvArzzDCJxGuwIM8MY0e8CvPMMG3Ea4QgtwyDXnsFOWcY9CrM873/R+J1kiDP/H2wUuQ+LaPuFbH7t4F4pe+PSvQqyDM+Ns4n5hM5+kS/yPFc8JyQo2fMM3L0jN6Ro2d74h053g+YZ+R4n9gR78jRM3pHjp7RO3KxvKJPOt/Yp+vRcwOVb/T8G/HeY+p8r3JvC0zt2rhPtdoCabvd3pLP1cL1pltf7MuywEfV8nnyehV4rHd21Cq6IMkx+dv0DDPoj7eu3qYwQ760Kli3TANvr13UvdFRBcc35O2X9ClBdqjgq7ZyNezR/hW5M70d0s6wE6JTWqGhd0vAycUXYewcW1Z3ghL8Pat3Hkkzw+5DgaXPbjNBgWxh3PQfzPCJvjChxKiED6Jr9ynXm2DT2UWwVXYJ6g40GNxbLkHEDE181a8s/AMMXa7V + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAACAQAAAiAsAAA==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 + + + AQAAAACAAAAgEAAA4QIAAA==eJw11xGDAgYAQOG2tS0IgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiAIgiA4OAiCIAiCIAiCIAiCIAiC4CAIgsF9e/L9hhcM/BZimBFGGWOcCSaZYpoZZpljngUWWWKZFVZZY50NNtlimx122WOfAw454pgTTjnjF78554JLrrjmhlvuuOeBR5545oVX3njng0/+8MU3Pwz88UuQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZYZc99jngkCOOOeGUM37xm3MuuOSKa2645Y57HnjkiWdeeOWNdz745A9ffPPDwJ+/BBlimBFGGWOcCSaZYpoZZpljngUWWWKZFVZZY50NNtlimx122WOfAw454pgTTjnjF78554JLrrjmhlvuuOeBR5545oVX3njng0/+8MU3Pwz89UuQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZYZc99jngkCOOOeGUM37xm3MuuOSKa2645Y57HnjkiWdeeOWNdz745A9ffPPDQBAMMcwIo4wxzgSTTDHNDLPMMc8CiyyxzAqrrLHOBptssc0Ou+yxzwGHHHHMCaec8YvfnHPBJVdcc8Mtd9zzwCNPPPPCK2+888Enf/jimx8G/v4lyBDDjDDKGONMMMkU08wwyxzzLLDIEsussMoa62ywyRbb7LDLHvsccMgRx5xwyhm/+M05F1xyxTU33HLHPQ888sQzL7zyxjsffPKHL775YeCfX4IMMcwIo4wxzgSTTDHNDLPMMc8CiyyxzAqrrLHOBptssc0Ou+yxzwGHHHHMCaec8YvfnHPBJVdcc8Mtd9zzwCNPPPPCK2+888Enf/jimx8G/v0lyBDDjDDKGONMMMkU08wwyxzzLLDIEsussMoa62ywyRbb7LDLHvsccMgRx5xwyhm/+M05F1xyxTU33HLHPQ888sQzL7zyxjsffPKHL7754f/DH2SIYUb4H7j+A2A= + + + AQAAAACAAAAEAgAADgAAAA==eJzj4hoFIx0AAF2UFCk= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_123.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_123.vtu new file mode 100644 index 00000000000..6954277572c --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_123.vtu @@ -0,0 +1,53 @@ + + + + + + + AQAAAACAAABgBQAALgEAAA==eJwtxdciEAAAAEBCRogGTRKKlJZo01CZlRRFKJVRaSAhRWgRpUEqilLqJz24e7mAgEWBXuIgBzvESx3qMIc7wssc6ShHe7ljHOsVXulVXu04x3uN13qd13uDNzrBid7kJG92slOc6i3e6jSne5szvN07nOmd3uXd3uO9zvI+ZzvH+33AB33Ih33ER53rPB/zcZ/wSef7lE/7jAtc6CIXu8SlPutzPu8yX3C5L/qSK1zpy77iKlf7qmtc6zpf83XX+4Zv+pYb3OgmN/u27/iuW3zP9/3AD93qNrf7kTv82J3ucrefuMdP/cy97vNz93vAg37hl37l137jIQ/7rUc86nd+7zF/8Ed/8mePe8JfPOmv/ubvnvK0f/inZzzrX/7tOf/xX8/7n/97AZDZOXM= + + + AQAAAACAAABgBQAAGgAAAA==eJxjZIAARgrpUTC0wGh8joJRQHsAAEIQAA4= + + + AQAAAACAAABgBQAAIQAAAA==eJxjYEAFjGg0LoAuj66PED0KBjcYjb9RMAooBwBAKAAO + + + AQAAAACAAABgBQAAIQAAAA==eJxjZEAFjAT4uACp+hgJ0KNgcIPR+BsFo4AwAAA/UAAO + + + + + AQAAAACAAACcCAAAHAAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8SgeJBgAUVMCKA== + + + AQAAAACAAAA4EQAAawMAAA==eJwtxUMQGAYAALDatm3btm3btu12q21stW3btm1bu1uTT7IFDPC/7M7hnM7l3M7jvM7n/C7ggi7kwi7ioi7m4i7hki7l0i7jsi7n8q7giq7kyq7iqq7m6q7hmq7l2q7juq7n+m7ghm7kxm7ipm7m5m7hlm7l1m7jtm7n9u7gju7kzu7iru7m7u7hnu7l3u7jvu7n/h7ggR7kwR7ioR7m4R7hkR7l0R7jv/y3x3qcx3uCJ3qSJ3uKp3qap3uGZ3qWZ3uO53qe53uBF3qR//G/XuwlXuplXu4VXulVXu01Xut1Xu8N3uhN3uwt3upt3u4d3uld3u093ut93u8DPuhDPuwjPupjPu4TPulTPu0zPutzPu8LvuhLvuwrvuprvu4bvulbvu07vut7vu8HfuhHfuwnfupnfu4XfulXfu03fut3fu8P/uhP/uwv/upv/u4f/ulf/u0Agf4U0IEc2EEc1MEc3CEc0qEc2mEc1uEc3hEc0ZEc2VEc1dEc3TEc07Ec23Ec1/Ec3wmc0Imc2Emc1Mmc3Cmc0qmc2mmc1umc3hmc0Zmc2Vmc1dmc3Tmc07mc23mc1/mc3wVc0IVc2EVc1MVc3CVc0qVc2mVc1uVc3hVc0ZVc2VVc1dVc3TVc07Vc23Vc1/Vc3w3c0I3c2E3c1M3c3C3c0q3c2m3c1u3c3h3c0Z3c2V3c1d3c3T3c073c233c1/3c3wM80IM82EM81MM83CM80qM82mP8l//2WI/zeE/wRE/yZE/xVE/zdM/wTM/ybM/xXM/zfC/wQi/yP/7Xi73ES73My73CK73Kq73Ga73O673BG73Jm73FW73N273DO73Lu73He73P+33AB33Ih33ER33Mx33CJ33Kp33GZ33O533BF33Jl33FV33N133DN33Lt33Hd33P9/3AD/3Ij/3ET/3Mz/3CL/3Kr/3Gb/3O7/3BH/3Jn/3FX/3N3/3DP/3Lvx0g8J8COpADO4iDOpiDO4RDOpRDO4zDOpzDO4IjOpIjO4qjOpqjO4ZjOpZjO47jOp7jO4ETOpETO4mTOpmTO4VTOpVTO43TOp3TO4MzOpMzO4uzOpuzO4dzOpdzO4/zOp/zu4ALupALu4iLupiLu4RLupRLu4zLupzLu4IrupIru4qrupqru4ZrupZru47/A8/EDhA= + + + + + AQAAAACAAAAgEAAAdgQAAA==eJztln9MU1cUx0toXRQZwcw12/AfBpIhZDqyyAZyjPuRDVZnzEZAF0OUrSFIlm1udX8Z9kNcdFm2NK4jIDAEFGLWCfxRBrjIarUtrFhtaRuk6yvSVmUvaBHQzZF5z3159/Wlc7r/dv+5ud933jnnft63J1UoFtfGACj+Xg6y++GCNy+33+CHjl7ttr3rRunzt09vcneP+yU7vqeQyXd3D9FzebGhrW7kEqkTovFY90f92pKUxmHJe2w+zJOTaT//gnaKiXfI9hX7fvJ1YvflkLmHtC+WI+Zj74/vsffHePaeGK+IuXgZXS6OjY93jhf3T3e55ZB57pfRQ4zukKnjl9FDcTiw/fCMT1hdrh923et9/u37bH9s3nvldL88WK6sL9j6bB45P91vvgftmwfdF5s/Pu+LSZuSXxv/DbrUnz1u6PMRfQyybwzMdKdfgiuqliXt00Gq3z37yXMX0YNMvSCzj0HsOkGZfHL1pXXYvrEO2zfmY/vG+rH7FvjZX9Fl6zTnoPz4TcvcbRfVP298Imf9KQ4qzRn+IGenesO8Rm0zcjBfdHl12sYw1cOqPlX/Q2Nw6E566+FCQS8MeH/pG54A3anZnPXLOarXV9RcX9EcAmW7Y2fVTkEv6zk/UbjgAlvH6pNpkbNU51fWV+sb7JBY05i1ebcQX9zj+XDVuggkGaM/bal3U/2R/eFsw1UOrmzd9dzIUR/VOz3Og6czIoA7rfud0RHdbYE3yI46ntn4lJKmlx9drHvG+clke4EQP5+cWXU2wQs/HEmd/d3ggTSltvKrO1YJv2Mjs5YllpCE99Y1yoZPa4NUd5DvM5qw54O2ZJuEd2rtivavpzxULyC857p3PJ9b4JHwXl76kXOvWfg+5YT3QqbZuCvLI+F9O0v1vfuZoIT3odLNnCE3IOHdJcO1jOGKcayOZ+TL8u5ce1N5IE/4/guEN/oR+ZJbUP8iX9S3E7+j/1E/SPyLfFFH/6KfUU8k/kW+qP9K/It+Rl1J/HuV8EUd/Yt8UUf/Il/UkZ/YrzzE9jdP48qYePSvmDcP3cS/6GfUxXOCp/zEc4KnvMVzgqffRzwneMpbPCd4yls8J3jKWzwneMpbPCd4QD+L5wRPeYvnBE95sxw7ZbiXxZwTAnfxnOApb5wTqCPv/+cyqfsfzWWFaPHQ8liT8UtfGCzNdfbSZcLvvnUw4/V3Exfnrs2qfvEPwU9D3Mw7I50cmK6VrizyTVH9mq/2iEbjhpDpJfVTJTaq//lekenjNxfnuNerKcoX8s9xTydVfOODfR2BpTWtwlwZe7IiPxoNQ0Fg+4mm40LdntFXB7cMuWHftuq6WynC72fpxW8rnW0c7HFpm3rThf9dXr1zcPxWEKZn3LYN5gmJX7sYv9Yl6Ew/myJgfWvgulkTf36wv4cvLNXThwOjUJhmPdDz8BTo8vWpVatckjPGDbc8e6N32WXQ9uvV+ogT8nZYk4qjk5IzxrHvY15785Dq/Q2Tkp19H/MeG9ivMp24INn/Aqpm7xg= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAADgRAAAHAwAAA==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 + + + AQAAAACAAAA4EQAADQMAAA==eJw11xGDAgYAQOHb1rYgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIKDgyAIgiAIgiAIgiAIgiAIgsF9e/L9hhf4+i3IEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvssMse+xxwyBHHnHDKGedc8Js/XHLFNTfccsc9DzzyxDMvvPLGOx988sU3P/z645cAgwwxzAijjDHOBJNMMc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAYccccwJp5xxzgW/+cMlV1xzwy133PPAI08888Irb7zzwSdffPPDrz9/CTDIEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvssMse+xxwyBHHnHDKGedc8Js/XHLFNTfccsc9DzzyxDMvvPLGOx988sU3P/z665cAgwwxzAijjDHOBJNMMc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAYccccwJp5xxzgW/+cMlV1xzwy133PPAI08888Irb7zzwSdffPPDrwAYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdthlj30OOOSIY0445YxzLvjNHy654pobbrnjngceeeKZF155450PPvnimx9+/f1LgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaHXfbY54BDjjjmhFPOOOeC3/zhkiuuueGWO+554JEnnnnhlTfe+eCTL7754dc/vwQYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdthlj30OOOSIY0445YxzLvjNHy654pobbrnjngceeeKZF155450PPvnimx9+/ftLgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaHXfbY54BDjjjmhFPOOOeC3/zhkiuuueGWO+554JEnnnnhlTfe+eCTL7754f/DH2CQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZYZc99jngkCOOOeGUM/4HDTwQgA== + + + AQAAAACAAAAnAgAADwAAAA==eJzj4hoFo4AgAAA3+BWH + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_13.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_13.vtu new file mode 100644 index 00000000000..1f2b8d8a4ff --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_13.vtu @@ -0,0 +1,50 @@ + + + + + + + AQAAAACAAAAgBQAAHwEAAA==eJwtxddCCAAAAMBKhVCaKFQiLQ1JES1CQmmJ0lIJoVJmpZA0JTMr1Y966O7lAgI2BTrIWxzsEId6q7d5u8O8wzu9y+GO8G5HOsrRjnGs47zHe73P8U7wfh/wQSc6yck+5BQf9hGn+qjTnO4MZzrLx5ztHOc6z8ed7xMu8EkXusinfNrFPuOzLnGpy1zuCp/zeVf6gi/6kqt82dW+4qu+5hrX+rrrXO8GN7rJN9zsm77lFrf6ttvc7g53ust33O0e9/qu+3zP9/3A/X7oR37sAQ96yE887BE/9TM/9wu/9CuPeszjfu0JT/qN3/qdp/ze0/7gGc96zvNe8KI/esmfvOzP/uKv/ubv/uEV//Qv//Yf//Wq/3nN697wf8cnNDc= + + + AQAAAACAAAAgBQAAHgAAAA==eJxjZIAARiJpWoOBsne4gYGOx1EwCoYDAAA98AAO + + + AQAAAACAAAAgBQAAIwAAAA==eJxjZEAFjAz4ASMBmlKAyxxq2zPSAa3jcRSMguEAADzIAA4= + + + + + AQAAAACAAAAECAAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8YjDABSAAgI= + + + AQAAAACAAAAIEAAAMgMAAA==eJwtxUMQGAYAALDatr3atr3atm3bttbVtm3btm0bu1uTT5IGDPC/ZE7uFE7pVE7tNE7rdE7vDM7oTM7sLM7qbM7uHM7pXM7tPM7rfM7vAi7oQi7sIi7qYi7uEi7pv13KpV3GZV3O5V3BFV3JlV3FVV3N1V3DNV3LtV3HdV3P9d3ADd3Ijd3ETd3Mzd3CLd3Krd3Gbd3O7d3BHd3Jnd3FXd3N3d3DPd3Lvd3Hfd3P/T3AAz3Igz3EQz3Mwz3CIz3Koz3GYz3O4z3BEz3Jkz3FUz3N/3i6//UMz/Qsz/Ycz/U8z/cCL/QiL/YSL/UyL/cKr/Qqr/Yar/U6r/cGb/Qmb/YWb/U2b/cO7/Qu7/Ye7/U+7/cBH/QhH/YRH/UxH/cJn/Qpn/YZn/U5n/cFX/QlX/YVX/U1X/cN3/Qt3/Yd3/U93/cDP/QjP/YTP/UzP/cLv/Qrv/Ybv/U7v/cHf/Qnf/YXf/U3f/cP//Qv/3aAQH8K6EAO7CAO6mAO7hAO6VAO7TAO63AO7wiO6EiO7CiO6miO7hiO6ViO7TiO63iO7wRO6ERO7CT+y0mdzMmdwimdyqmdxmmdzumdwRmdyZmdxVmdzdmdwzmdy7mdx3mdz/ldwAVdyIVdxEVdzMVdwiX9t0u5tMu4rMu5vCu4oiu5squ4qqu5umu4pmu5tuu4ruu5vhu4oRu5sZu4qZu5uVu4pVu5tdu4rdu5vTu4ozu5s7u4q7u5u3u4p3u5t/u4r/u5vwd4oAd5sId4qId5uEd4pEd5tMd4rMd5vCd4oid5sqd4qqf5H0/3v57hmZ7l2Z7juZ7n+V7ghV7kxV7ipV7m5V7hlV7l1V7jtV7n9d7gjd7kzd7ird7m7d7hnd7l3d7jvd7n/T7ggz7kwz7ioz7m4z7hkz7l0z7jsz7n877gi77ky77iq77m677hm77l277ju77n+37gh37kx37ip37m537hl37l137jt37n9/7gj/7kz/7ir/7m7/7hn/7l3w4Q+E8BHciBHcRBHczBHcIhHcqhHcZhHc7hHcERHcmRHcVRHc3RHcMxHcuxHcdxHc/xncAJnciJncR/Oan/A4daAoU= + + + + + AQAAAACAAABgDwAATwUAAA==eJytln1QlEUYwJc4NMOPkVFvEKyJREyhRKfUMB7H0jHszBwjT8shRRgGmbRM1MZxMJRGMMOYQoYPETkSLVFwpjP8SEWQzzsvObgLPO89uDsEu1EBPyBjYp99e1feIdP9Z2d/++y+z/72uZ0jpK/NtQL5p+lob4HfTTOCStMtUHAyesXmYP0j8/29g43VYen5SbXNdJ2DxeM+x9OmLRqVVcPWYXygf/WVt6LtjPNxcnkg59fL5YGcDNhcMlwujo8fbDxY3H/tCVl7fp6xuMkCfN8/S/sB7lPaOwaeZ+scMuv4ppPhcvEOjutkfFpkuGMQ/3w+Lpn8Xdw5+Xz49rjn+b/r+fz4fR/X05P64L3y9ch/n99Hro6fdL+nXTdPOy9+/8F9X/WcN+LdputwRJk4Pv2UmfIGmHLn9K1iv2a44ZE7RHPTxnj/2ELn6ym3cd+zsZ7fF7/Hr8d9+e9hHvy+/Pk6zAnZKpUR2rXzlS8vqmI878zE9z517xtXVSrf7hUYvyDciqotFEDbET421GxnPNc7p2iP2QnlB5Kqw59rYPyvDaHaLR9cBr3JpAqdJfK7wqueEfvMsL3AOiwu7xrjw67+EGnIF2BjfXTOST/xfkr075xZcsEI21fEJj0Y5WS84aWIWZ2dTgixrvwp57CYpynNcKbpgQ1u3jJWvVkm7r98f5Guc105HGk0JJ+f2MZ4klu89py2DSo/On27TCXyZTQe1yEvpOtx3lcRHbn3YSWbz7ynUlYVCbB0qiLzqwQb47qF8VPiVZfhx9qu8iHlYj3tzPIJnHlWAL3bxs/zR4j34PQ45VE6tAFGJ3hpUu2NjIdYTRdP1VyDu8Wr3ggKEXlGRNxtrwMOuO9fVrQmQOSusRmxaZnVMDx8k2FzmehPXXLl2pz79dAT4HHQOF3MM6yk8YsJwW2QEr5YSA+yMj5ml3NKervwiL/lMp4wjuc4HrUoZ8G4YHEfHBdO61Z8PUO8z/sj/GMq3EzMZzX1SE8HGuozkXpEjveC94EcPaNf5OgZ/SJHz+iXceoZ/SJHz8upX+QPqGf0izyZevaifpEPXK8uGNirGM/zkdTrSIlvFxymntEv8u6LFQWpCaKXiLKJFptQDeXDI/Ux2SK/F9o6yXeuE6qDVr928KiTcfXh7vK7PfXg2evX+2KPeJ6Uh355389xgvWbfVl+3uI7velsV+DM4QKkbQubXrK9hvFnNLrVMasFMOSP+/b6DhvjVQWTTvi2VUDiVu8WU4N4H4q4rIDF6wQwv7J/8u4Q8fyeRZ2/Lskwwh+3AwvrJon531i6ZnbtITMUcn753zfP+XiMu2DY0aL513dxrNgSV+Xz0Mr48ezRXX+mNzJ/0vokZCX1J61zQiLpPeyU1DkhydSrtJ4Jiade50jqmRB36lVaz4TUUa9qSd0Sgl7bJXVOCHqV1jMh6HWMpJ7F92CZzHtayL0rcu/vJeqVfz+K0auknrG5mE+sT+ToE/0ix3vBe0KOnrGekaNn9I4cPSuod+T4PmA9I8f3xJ16R46e0Tty9IzekcvVK/rk6xvHfDx6vsTVN3o+Rr3vThuq/kRrh2Mn1e+b/I1gNB2d3LHPDqaVsRmzP3SAKtlc1PVCI8Q6F2Z7nauBOxEzmxS9rbDgl5TSEzsEWO+lHetV0Qql3SQqdLcdcg2KzanbbBBzKOvj57f2/R/IWT+3vVcHvq0/2y19725/r4e033TmXePrQKexJTcnt0Cu6rLytNIAU+f7hCZa9TAh9tnv1trrYUPll6+rUhwQ0rNQqHPpICpX4678zAYZq9Q9jj12+Bty36sD + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAgQAAAaQsAAA==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 + + + AQAAAACAAAAIEAAA3QIAAA==eJw11xGDAgYAQOG2tS0IgiAIgiA4CIIgCIIgCIIgCIIgCILgIAiCIAiCIAiCIAiCIAiCIAiCIAiC4CAIgsF9e/L9hhcM/BZimBFGGWOcCSaZ4hfTzDDLHPMssMgSy6ywyhrrbLDJFtvssMtv9tjngEOOOOaEU84454JLrrjmhlvuuOeBR5545oVX3njng0/+8MU3Pwz88UuQIYYZYZQxxplgkil+Mc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ67/GaPfQ445IhjTjjljHMuuOSKa2645Y57HnjkiWdeeOWNdz745A9ffPPDwJ+/BBlimBFGGWOcCSaZ4hfTzDDLHPMssMgSy6ywyhrrbLDJFtvssMtv9tjngEOOOOaEU84454JLrrjmhlvuuOeBR5545oVX3njng0/+8MU3Pwz89UuQIYYZYZQxxplgkil+Mc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ67/GaPfQ445IhjTjjljHMuuOSKa2645Y57HnjkiWdeeOWNdz745A9ffPPDQBAMMcwIo4wxzgSTTPGLaWaYZY55FlhkiWVWWGWNdTbYZIttdtjlN3vsc8AhRxxzwilnnHPBJVdcc8Mtd9zzwCNPPPPCK2+888Enf/jimx8G/v4lyBDDjDDKGONMMMkUv5hmhlnmmGeBRZZYZoVV1lhng0222GaHXX6zxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPKHL775YeCfX4IMMcwIo4wxzgSTTPGLaWaYZY55FlhkiWVWWGWNdTbYZIttdtjlN3vsc8AhRxxzwilnnHPBJVdcc8Mtd9zzwCNPPPPCK2+888Enf/jimx8G/v0lyBDDjDDKGONMMMkUv5hmhlnmmGeBRZZYZoVV1lhng0222GaHXX6zxz4HHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPKHL7754f/DH+R/ajYDJA== + + + AQAAAACAAAABAgAADgAAAA==eJzj4hoFIxoAACE3FAs= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_2.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_2.vtu new file mode 100644 index 00000000000..628f590980e --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_2.vtu @@ -0,0 +1,47 @@ + + + + + + + AQAAAACAAADQBAAADQEAAA==eJwtxddCCAAAAMBIKtIikWhoSIOMlrSXdkR70KBQSSFNRaWMpFR/66G7lwsIOHbCJx3oUw7yaQc7xKE+47MO8zmHO8KRjnK0z/uCY3zRsb7ky47zFcf7qq85wYlOcrKvO8WpTnO6bzjDN53pLGc7x7d827m+47u+5/vOc74LXOgiP3CxH7rEpS5zuStc6SpXu8a1rvMj17vBjW5ys1vc6jY/9hO3+6mfucOd7nK3e9zrPvd7wIN+7hce8rBHPOqXfuUxj/u13/itJzzpKb/ztN97xrP+4I/+5Dl/9rwXvOglL3vFX7zqNX/1N697w5v+7i1v+4d/+pd/e8d/vOu/3vO+//nAhz7yf1aOLgY= + + + AQAAAACAAADQBAAAHwAAAA==eJxjZIAARhw0pQCXudQyf7iD0fAbBaOAeAAANgAADQ== + + + + + AQAAAACAAAAgBwAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpHMQoGAGOKAck= + + + AQAAAACAAABADgAA4wIAAA==eJwtxVOAEAYAANDrsm3bdpcv27brLl225oUtDplbHGqrLbvLvGxctvnRez9vY8Bnm7zZW7zV27zdO7zTu7zbe7zX+xzu/T7ggz7kwz7ioz7m4z7hkz7lCJ/2GZ/1OZ/3BV/0JV/2FV/1NV/3Dd/0LUf6tu/4ru/5vh/4oR/5sZ/4qZ/5uV/4pV/5td/4rd/5vT/4owOiyIGO6miO7hiO6ViO7TiO63iO7wRO6ERO7CRO6mRO7hRO6VRO7TRO63RO7wzO6EzO7CzO6mzO7hzO6VzO7TzO63zO7wIu6EIu7CIu6mIu7hIu6VIu7TIOclmXc3lXcEVXcmUHu4qrupqru4ZrupZru47rup7ru4EbupEbu4mbupmbu4VbupVbu43bup3bu4M7upM7u4u7upu7u4d7updDHOre7uO+7uf+DvMAD/QgD/YQD/UwD/cIj/Qoj/YYj/U4j/cEf+Ev/ZW/9jf+1t/5e0/0JE/2FP/gHz3V0zzdMzzTs/yTf/Yv/tWzPcdzPc/zvcALvciLvcRLvcy/+Xcv9wqv9Cqv9hr/4T/9l//2Wq/zP/7X673B//l/b/Qmb/YWb/U2b/cO7/Qu7/Ye7/U+h3u/D/igD/mwj/ioj/m4T/ikTznCp33GZ33O533BF33Jl33FV33N133DN33Lkb7tO77re77vB37oR37sJ37qZ37uF37pV37tN37rd37vD/7ogMDPRXGgozqaozuGYzqWYzuO4zqe4zuBEzqREzuJkzqZkzuFUzqVUzuN0zqd0zuDMzqTMzuLszqbszuHczqXczuP8zqf87uAC7qQC7uIi7qYi7uES7qUS7uMg1zW5VzeFVzRlVzZwa7iqq7m6q7hmq7l2q7juq7n+m7ghm7kxm7ipm7m5m7hlm7l1m7jtm7n9u7gju7kzu7iru7m7u7hnu7lEIe6t/u4r/u5v8M8wAM9yIM9xEM9zMM9wiM9yqM9xmM9zuM9wZ8AZXbeJQ== + + + + + AQAAAACAAABwDgAAdAUAAA==eJytlX9czHccx2uykE0WWbQHklrTD1LhUXoTtsfU0SNJPzZaQ0xtmJlKikdEaJNG2YNM6lRq5ZFWYzdz6uhyXd24uitd972uu/zoO+kqau109/l++XQnxueP+z4+z+99P5/P+/n5PF4fA4OnjQ9/i2Y7XE6TAPNiePCOWTUwgA0UFC9Knek95uRNigctTctK5N0B++lVtYvCW7WcT3HNdwotxxuph+v7H/7/ofpD/e9ln6hJNP0FUqpOzRPVJxniqcC+w8fDG18Pl+jhuGf+i+sYxBVDeMbXQ2L14VzfevD2qvX83+/x9eHjvqqn1/WBe8XPHT4/Po6+8/q6473pc/Om14WP/7K+6+CWidc7Po3NkDchYWLa72Lteyl0rbhjZ2ncDGaBi85z/qnX8HgCgj2zIEnVBA4ZtZOXxBAabioGj3OZD2IfN4J0RsGIv6IJap5zPoGK6BIuoPkQ75p2b51fFwHpBx8frZ6npLiRy677Nd8qYeKMcrfPfYQUT9682Z9hWgfmCosiFw/loH04Xy84eNWazo29quwWQzcupCye4vNogYzis20ShxVcuAPDr801y8mrpfi6aP+g7kgFLG2btSzYnV4/1858n2ODAGZual7Ye6YCm1cGhaqV+w9J2BTPHVhHG6An4v7phfzOCM4gnuZoLR3OaIMtEetnm66jxy8YV1yadZmA75JsJx9bJaL4gb1BXqX5V6HJ23rNBkM23CtbMsHOm0u9vy/efYrBUHvjVk5Y3EfXkcmyXv7NMC6U3Q8Y7ylupTibeLiel0sA53RiVcAoen9+scgoPCxWQo1IxPCcS/N/t3iWRa28AXFM6cjIzCaKdxNOJqEpYth2OzzjohV9LkfeOr5WkEVAXPCmxCdj6H0rrvmU5csWgrs0JD8jh15n3bTQuZ2dSnjwUMidX06PL0oVsBqfyCAP8xeo9Vr52R8d5QyaJxp+X3alrA3Qe3wf/DGO9gX5pDwONJLyhnwh3l+p8Yz8In5D6xN5RBz5RB4Rj9X6RB4R99D6QV4QR56RX8SRZ+QXceQTeUQceUO+EA/U6Ymk/AdiXPf5JqHr2nXmkd11VD+03FoiI6qAM3ptzcZTNO/xlNtYLlBClUOY65nzdJ1BOV2c7t7bYNJn1Te1l67zUL9V5jF1DkiTU05aWdB5uf1Plf2c0QSkxi51Lo67SfG3svlhG8MIEGSZ/9i8h66fy7S5YNl2HRKiLVpEdXS+GkWetF0WQYDYMf3DJHe6TpPCzku+J4TQ0GGfW21Dr/+u35fzeGfFg+pHfdyj7pygPbIFe1qyn5kX9Y2iIrmT+qUULzo1VtWeVg/6clZfnpqW2rqEjK0blL+lHM7KenUu4zn7pP9paxqUs8HvykQh6pyNHfWzZfIzOeuszVljLGdDSj46bfK1Aswsz8qKXiJnDQd+ZVCM5Sw6h3geDJWz27CcXZUXNoWpzlnWwUvEmRfkrMFzjdTjW33edd5r6vOkcx9I0H2v0ff4875J0H2vkaD7XiNB972mPvc6faN58Xtt6POKc933Ggm67zUScN/scWzLdmc+eMgSGNOjFXBiFisj/isxKIUO5E5fAnZ0bCrzmM6De2saOuesl0Po2GVxIlsC3L7wcvFlycG+h/2IKZfDit/Ourva3ob3f2Cll/S2AovY2fnT4RaINF7tdjemHuZv4BkuDK6Gdk+nX3O2S2BEfHplQDcBSZUV+cvH14KLsVHjJ6kCcE0ueM/NSw5mPObHR3it0Lb8uDBbIQRDacr8D1zU78P9uveO50JExttBjBAFHFUpe5wWNYLdLnnU1rsKcN4a4+pdwoPVMa02Y/bxQdXgPtWsggd5t6STrhyohv8AuypE4w== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAOQAADgoAAA==eJx121e3J0UVhvEhCIjkqIAwIDkJKMEB4aCkGXJQMhyiwhAGUaLoISkI6Awiwrflgv27mGet6pt3ndNdVTu+e1d1/3du+/7aN3jk4P8G/zG4c3H/yNz3vPmuGrxy8OrBLwf3Dv43z32dv93/MvetR473I5/njf9Dxt87+Ong3zL+pcHXIu83kc869K381bv67s1z7lv36zxnfXrX3uR/fZBen+b+fwZXdjA/Ox+Y9chTfSsfvT/J8+blN3FEvgOiR+V/PHJ9FPnuG3xq8PPcJ1/j1Px3Ra7Gl/HWpx996fdRnrP+e4N7Butf8hrf/Op6Lw6yr/HGsYfxHww+OfhZ5vvr4L8Gv8j85L9p8M3owa7WE99fZdzKDk8P/mrwN4Pyw3z89suM5y9xI8757708T/5v8jc5b8zzXa/xb/4/D+7J/cZf+c3/qyf71d4u8789yH/8aX7xaJ3yifnp7bKe/GTn1gd6s0Pt++zgo4MPDbKD+BTnB+Y+/chBzxW/kxPv/XqQPY8e/P/gQYNPDB41KP5eHpR3zR/z3ZD5jH82zz+U+68O8lvz791BerZ+qXfka3z9ZZAdGx941zqdnz3Zv/z8zKB4afy/EDm6vvHGiSfjxQ07Pj9IT/4QPx/k/mOD+AXfsD+92OeIrG9e69TO7HbbYPlHXcHL5Xf+Z6fah/ziih7kp+/vB/F84/P6bftf3w7ePfhg5CQfe9AHHxr/cObZlfHs9dzgh4P0I5/4kUf0Y3d6yUf6kYd88px8t+f+W7n/bp67Lc+Xr/AE+f49iBfb/9CH38oPjwziHXbDT+rhK4ONX/kp7vQz5P/7ID1fz318u6pTxhsnX4wXL+JHH7Yv/xcfD+f+rsX/6c8v/Gpd/nsr/z8i9+/I+H15nl3Z+Y+D9Y9x5CQfXuNveYw/xL+4b3zgB3JWPvFy3WDrl7p987b9L/mkPthntH9sv1b74xU80/qMl+UJvj53UF+1I/KSj354rvnV+V/JffX9mkH2oY/5yNv63ufNU34QZ+UT+Uiu1nf2ZVfrs696r68pP4pL/FF+ZOdVnfS8uG5/TR5xzh/kw6/tn9hHPP088uN7/Eg//EG/nw2WB/BF+bH7q8Zd/e2iR+VnJ/XFPMbTh/z0If/uQfZlb/Et7uVn4//o3O/43fn/jtzv/oGdyL+Si//Zj90ey3125v97BsUHf+F5/uQ/fR258UH125Hn3X9jEK/r0/Cr+nRAnpOf9D8567FH69/Hg/q0zsvv1scH+OGdQfGFn/gZj7Of+NPXtH9jV+cgra/0Yr/qJy/VndYjeskPF/n523qtp67ul9mHfcnfeopv9afNz6vzf+uyn/gQF+qx9fGZdX+X8fRZ9RnyQ160/2q/2/z456D4Wu2n7ft7vkh/erT+i687I7/74sC49hPifXXOpZ7oI3q+KU/M03M68cVPLv4R3/wjTtgT35Kn9ZH/2F0/Zbx47LkK/5Yvez7rMk/3h+KX/W/NOuXl1tf6z3zGsws7tU92fo3nyu/kxU/4kv74Z+Xn6iNP5GftW/vIN3q0f3apf90PusRPz5fYVf3Sr5Kf3vq46i++5KU8EF/mN2/73/YV/E1++zH7s+4vd+a5O3JfHb0vz/d8t/knX9o3Nv/xl3XK99WHnuKr/dN5g/oo4/Fa97n8yb89/xFX9U/Pn9S99g/68h8Ptg/+6eDqHKDnXvgcfx87KE/KB/aDFw+2PvXc5exB/rhwcHWOf8JgzxeuHWz/QT7+X/U99MMveKH7Y/n926xbfmOn2qf80f2o+c1b/rxgsO9f2Asf9b3jqn8TB+KifMzP3T+szmH9bf9tX0QO/jSP/NEPspO8bH03zjqr87HaQf5sDvJf+yN5TM7yq3wV1+KcfeXdah/q/JNd5Av7kA9PPRD5duW51hfxiw/wBfnkEbtdNsief9q2/9V+xrnYFYPlC/Gy6jN7fib/+z7T3+cPind980bkFJ/yoft8fmxe4RNxYBz+7v675yL2P/KHXD1/PmWw788uGsTjPR/Cc+QUL/za+Ov5ff2r7zlnsOc45DJv40dct3/Br9Zvn63vaLzjie5fug/Cv60PfQ9gX1g55UP3Z+IKr9Kf3vVPzwWNI0d5p+c/6vaqj+35T/s848hX+7m/O8+Zf3MQr+CTswblcfNbHyBuVueA5lnxFH92/00+cqmjeLr7V/1Kzye3BjcGbxnED/it+wT81rht/yOve/4q/i8dxO/43rlnv184cxAv9r2dunHioLjFi3hSHIub7qPlDx4qP90Y7H15xN/iFp+Yn//UcX7kP3ZhJ/tb9sHP+Pj4QXEgD+RFzy+tK/56PkE+823mfr+/af3ovq/vh5o3zmnUTXFz/2Djs+dCLvYXvxu5z6+tH61vW1mXHNbvfOLBvqXzd79L/55/y6Pmf/vfzUF+b7/dc+nOL396fiV/mr8bg/Sv36xHL3Gv/238d9/X/bP6d8mg99/6SRe5+Jt8jZtjBumDp84YtA/3fYj9NN7pd1Q9t2Nn9lXvWkflh3pEz/b/7Yud5+qb1SvjW99qt35PQG552vMNdUMd6ftjF7t3v66f6vmyc+f2Ze3zxDFe7P6x+5+eP+s3twabv+1Le38j4xtfx0XO1mP7r76Hs48jt/18z2/0Ce1DzUde8dz9p3pN7r5/EO+nD/Y7H3rQi749z/R37c9fPX9Q/9Xhnk/pG/FQeQpPk+vgwc1B/uj3EYcM4rnuq/p+Sp2VNz8alE/9fvHQQf1vv085fNB+8oeD+px+r8q+/Fz+kp/1H7/in9U+QD6veFBdczXP5S2e6fdc6pF+dnOw30fIe7yBv/rdIn/8YnDVNzjHtW77bH5uX4WX8LA4W/VZ4rd9JrvrQ9qniH/1YtVHr/pu+slPeekcTT6yX7/vYz917rDBfkfYvhs/bR8Uh+rrxiB+2Vrc/8kgf10+2O/PxT2ePm0Qj8l7/tgclP/Nr56TtC7Kb/GMX8xrPfHUfR1+wdP03BjcGpRH9p0nDdqPq/PkEafdH+EbPIR3zMev+KH+LW+dmvnEB7/wk/H8QJ+tQf43v3pefuy5Nn/xU98blD+7Lxf3+AV/ip/Wd/G0lfv0+kHudx9AntU5oXjQr/V7Mn3yKg/aV4g/+W5+87V/X+WN8zfxJZ7KD61b6gh95RV+4D9+ZafakTziUd0Rr+Kufbt5zHtr7vc9grq2fVC9s5512N364psdyqP8xo6tv+qyvCgPnBKUd90/0n9rkP7m04fbR62+Y/wqz/V9R39v1N/1vJbn7Of6+yj39+Z+5ze+3+v0u/S+j+n3/s41+h1Hvxfs92v2m/19R/1QPvQ8Xuv3On2v1v2K58nR75bU9db5fn9Of31Kfxfwav7+Is/rd3q+t9o3fJvnXP1+S925KX/3+y11r7/72j7Y94zb85w81n/1u6f+bmpfntOvfQfmHIMV + + + AQAAAACAAABADgAAkQIAAA==eJwtxRGAKgYAANC2tS0IgiAIgiAIgiAIgoMgCIIgCIIgODgIgiAIgiAIgiA4CIIgCIIgCIIgCIIgCIIgCD70nrxg4CPksCOOOua4E0465bQzzjrnvAv+ctEll11x1TXX3XDTLX/7x2133HXPfQ889MhjTzz1zL+ee+GlV15746133vvgo08+++Krb7774adffjvw16egQw474qhjjjvhpFNOO+Osc8674C8XXXLZFVddc90NN93yt3/cdsdd99z3wEOPPPbEU8/867kXXnrltTfeeue9Dz765LMvvvrmux9++uW3A39/CjrksCOOOua4E0465bQzzjrnvAv+ctEll11x1TXX3XDTLX/7x2133HXPfQ889MhjTzz1zL+ee+GlV15746133vvgo08+++Krb7774adffjvwz6egQw474qhjjjvhpFNOO+Osc8674C8XXXLZFVddc90NN93yt3/cdsdd99z3wEOPPPbEU8/867kXXnrltTfeeue9Dz765LMvvvrmux9++uW3A0E55LAjjjrmuBNOOuW0M84657wL/nLRJZddcdU1191w0y1/+8dtd9x1z30PPPTIY0889cy/nnvhpVdee+Otd9774KNPPvviq2++++GnX3478O+noEMOO+KoY4474aRTTjvjrHPOu+AvF11y2RVXXXPdDTfd8rd/3HbHXffc98BDjzz2xFPP/Ou5F1565bU33nrnvQ8++uSzL7765rsffvrltwP/fQo65LAjjjrmuBNOOuW0M84657wL/nLRJZddcdU1191w0y1/+8dtd9x1z30PPPTIY0889cy/nnvhpVdee+Otd9774KNPPvviq2++++GnX3478P+noEMOO+KoY4474T8b8uKQ + + + AQAAAACAAADIAQAADgAAAA==eJzj4hoFwwEAAOjREdE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_23.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_23.vtu new file mode 100644 index 00000000000..f01e87b754c --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_23.vtu @@ -0,0 +1,50 @@ + + + + + + + AQAAAACAAAAgBQAAHwEAAA==eJwtxddCCAAAAMBKhVCaKFQiLQ1JES1CQmmJ0lIJoVJmpZA0JTMr1Y966O7lAgI2BTrIWxzsEId6q7d5u8O8wzu9y+GO8G5HOsrRjnGs47zHe73P8U7wfh/wQSc6yck+5BQf9hGn+qjTnO4MZzrLx5ztHOc6z8ed7xMu8EkXusinfNrFPuOzLnGpy1zuCp/zeVf6gi/6kqt82dW+4qu+5hrX+rrrXO8GN7rJN9zsm77lFrf6ttvc7g53ust33O0e9/qu+3zP9/3A/X7oR37sAQ96yE887BE/9TM/9wu/9CuPeszjfu0JT/qN3/qdp/ze0/7gGc96zvNe8KI/esmfvOzP/uKv/ubv/uEV//Qv//Yf//Wq/3nN697wf8cnNDc= + + + AQAAAACAAAAgBQAAHgAAAA==eJxjZIAARiJpWoOBsne4gYGOx1EwCoYDAAA98AAO + + + AQAAAACAAAAgBQAAIwAAAA==eJxjZEAFjAz4ASMBmlKAyxxq2zPSAa3jcRSMguEAADzIAA4= + + + + + AQAAAACAAAAACAAAGgAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8YjCAAx4AgE= + + + AQAAAACAAAAAEAAAMAMAAA==eJwtxUMQGAYAALDatm3b5srVtm3b5mqvtm3btm1bu1uTT5IFDPC/5E7hlE7l1E7jtE7n9M7gjM7kzM7irM7m7M7hnM7l3M7jvM7n/C7ggi7kwi7ioi7m4v7LJVzSpVzaZVzWf7ucy7uCK7qSK7uKq7qaq7uGa7qWa7uO67qe67uBG7qRG7uJm7qZm7uFW7qVW7uN27qd27uDO7qTO7uLu7qbu7uHe7qXe7uP+7qf+3uAB3qQB3uIh3qYh3uER3qUR3uMx3qcx/sfT/BET/JkT/FUT/N0z/BMz/Jsz/G/nut5nu8FXuhFXuwlXuplXu4VXulVXu01Xut1Xu8N3uhN3uwt3upt3u4d3uld3u093ut93u8DPuhDPuwjPupjPu4TPulTPu0zPutzPu8LvuhLvuwrvuprvu4bvulbvu07vut7vu8HfuhHfuwnfupnfu4XfulXfu03fut3fu8P/uhP/uwv/upv/u4f/ulf/u0Agf4U0IEc2EEc1MEc3CEc0qEc2mEc1uEc3hEc0ZEc2VEc1dEc3TEc07Ec23Ec1/Ec3wmc0Imc2Emc1Mmc3Cmc0qmc2mmc1umc3hmc0Zmc2Vmc1dmc3Tmc07mc23mc1/mc3wVc0IVc2EVc1MVc3H+5hEu6lEu7jMv6b5dzeVdwRVdyZVdxVVdzdddwTddybddxXddzfTdwQzdyYzdxUzdzc7dwS7dya7dxW7dze3dwR3dyZ3dxV3dzd/dwT/dyb/dxX/dzfw/wQA/yYA/xUA/zcI/wSI/yaI/xWI/zeP/jCZ7oSZ7sKZ7qaZ7uGZ7pWZ7tOf7Xcz3P873AC73Ii73ES73My73CK73Kq73Ga73O673BG73Jm73FW73N273DO73Lu73He73P+33AB33Ih33ER33Mx33CJ33Kp33GZ33O533BF33Jl33FV33N133DN33Lt33Hd33P9/3AD/3Ij/3ET/3Mz/3CL/3Kr/3Gb/3O7/3BH/3Jn/3FX/3N3/3DP/3Lvx0g8J8COpADO4iDOpiDO4RDOpRDO4zDOpzDO4IjOpIjO4qjOpqjO4ZjOpZjO47jOp7jO4ETOpETO4mT+j9zNQJc + + + + + AQAAAACAAABgDwAAWQUAAA==eJytlGtMVEcUgMcCGgU0KkgAbeIqYHm0omnVYjmGtqaVosZYCto0RGmJAWKbqkixMYiK9S0hCkbER4GCbYSCScFXi+Aqu64LCLvsiuDexd3FRzdQHj7QPpwz4x3dKNX752a+OfecmW/OHUL+fbTw34u0P37PMdGxFq4YpoecymmHohMJS9aG1lNulcezt5XFl2VPjRyVd4nliZ2XU5CpuUbnrSweebCfuuH9BItQh9eXf8fzyevw+phPrEOe+dgdcEdxYvzzxs+Le9E3IV9WR+jKW9tBfD+effr8ZPyJcxpUHBuLj9YBdxRvFbjWgc92B9z6HP/ieuwO1m8X9ieuR3wGu5//+724PjHvYD29rA/Rq9iPYn0xj6M+ftl8r7pvXvW6xPwv6lsPTa4R7p+0XodjXht9cqqMdN4MN10ODy280w6Bf53uKlc0A8Y/Hl+j82YWL69rFvLxOvLveD55HV5fnl+sQ8htY/rBqCgd3Kr80OuNSBXjR89MXrDS6Z+xqs7rgwGJ8XNS11eaEgkqb0d7hhstjB/2zi/dYbSB8lCmOnqEnvGH34RXpn56EeoNhqjwmZz3S2+5xmUZYX2RaXjy0TbGhzfti28skGBVc0L+CQU/n4r6j88sPKeD9UsSM++PsjGunxQ3s6fHBmGmpb/kF/N1GrIbz7TeN8OdLp3qvVqePya3VNuTpIRjLY3bqid3Mp45JKXy98pOqPv8dHdtFOeLaTx+h7yEfo/z450T4nc9qmPzB+5GealKJVgU5HwgI93MuPajlMCUqIvwk6ZXOVTJ+2lTnm/wjLMS1A9Z9W2BOz8Hm0uVy6lhehidPqZwj6WF8TCToabqUhv0l3/xbkgY5/vjkrvHHLLCPb/a0uUBnNs99ydmH1CDW/SaxrW13F9sRUPb7HvN8CDA5YhuGl/nvIqW1RNCO2F79HwpJ8TEuMdmW2DOLekpfzEOPGGcyHE8KjJ/7rhQngfHJVP7nLdM5+d5z91vxYUhBuZTTT3S3UEh9bmRekSO54LngRw9o1/k6Bn9IkfP6Jdx6hn9IkfPMdQv8vvUM/pFvo16HkP9In92v9rh2V55vMhHUq8jZb7tUEw9o1/kfTUXivakcy9xtZPbzZIalG7x9SsOcn43/Ib/+Dk2UIcse/vIzzbGY4v7lP0PmsF1QDEw8QHfz/ZHiqN7Z9vAtDMrT+HN7+k1Z3uDZ7hJkP39vGkV6y8x/lqhdtmKZRI0FozbfX2DmXFVkf+v4zsvwMbvvDsMen4ezsl5AfOTJDC+mTtlaxjfv2tpz8mF+3VwtTu45LI/X//NRctnaX40QongV/y/RS7GY9y5xg0dhU/UxbFzarLK95GJ8bKDo3v/zGlh/uT9SchS6k/e54TE03PYJOtzQrZRr/J+JiSFep0t62dCnKhXeT8Tcpl6jZX1LSHo9ZaszwlBr/J+JgS9esj6md8Hix3cpyXCveLo/j1PvYr3Rzl6lfUzPnbmE/sTOfpEv8jxXPCckKNn7Gfk6Bm9I0fPztQ7crwfsJ+R433iRL0jR8/oHTl6Ru/IHfUr+hT7G8diPHo+L/Q3ej5OvTeNjYgJkiT4TJ+2oHiWFnyrb5dV77VAaMSeqtR1EjQlho8I1NyANL+e0qtOFvDd6XfC83UdjFRmGUbsskBQ8qa+ORUWyPDpV68MM8O6jmHTd9dYIO2aamDfZi30TsqeMKVODx6/6WqOJ2rg5I7cMkWoFfx/MCQlrm6CXM+zR4q3WqH1onbaOz4N8PCPPLfiyA54mBHmvWhfA7h9rblSt0UD3XEBfW1FOpg4VpHk514PS1q17sP6tPA3oXOnFw== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAQAAAeAsAAA==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 + + + AQAAAACAAAAAEAAA3AIAAA==eJw11xGDAgYAQOG2tS0IgiAIgiAIgoMgCIIgCIIgCIIgCIIgCIKDIAiCIAiCIAiCIAiCIAiCIAiC4CAIgsF9e/L9hhcM/BZimBFGGWOcCSaZYpoZfjHLHPMssMgSy6ywyhrrbLDJFtvssMse+xzwm0OOOOaEU84454JLrrjmhlvuuOeBR5545oVX3njng0/+8MU3Pwz88UuQIYYZYZQxxplgkimmmeEXs8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAb855IhjTjjljHMuuOSKa2645Y57HnjkiWdeeOWNdz745A9ffPPDwJ+/BBlimBFGGWOcCSaZYpoZfjHLHPMssMgSy6ywyhrrbLDJFtvssMse+xzwm0OOOOaEU84454JLrrjmhlvuuOeBR5545oVX3njng0/+8MU3Pwz89UuQIYYZYZQxxplgkimmmeEXs8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAb855IhjTjjljHMuuOSKa2645Y57HnjkiWdeeOWNdz745A9ffPPDQBAMMcwIo4wxzgSTTDHNDL+YZY55FlhkiWVWWGWNdTbYZIttdthlj30O+M0hRxxzwilnnHPBJVdcc8Mtd9zzwCNPPPPCK2+888Enf/jimx8G/v4lyBDDjDDKGONMMMkU08zwi1nmmGeBRZZYZoVV1lhng0222GaHXfbY54DfHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPKHL775YeCfX4IMMcwIo4wxzgSTTDHNDL+YZY55FlhkiWVWWGWNdTbYZIttdthlj30O+M0hRxxzwilnnHPBJVdcc8Mtd9zzwCNPPPPCK2+888Enf/jimx8G/v0lyBDDjDDKGONMMMkU08zwi1nmmGeBRZZYZoVV1lhng0222GaHXfbY54DfHHLEMSeccsY5F1xyxTU33HLHPQ888sQzL7zyxjsffPKHL7754f/D/x9RHgMY + + + AQAAAACAAAAAAgAADgAAAA==eJzj4hoFIxkAAA0sFAE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_3.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_3.vtu new file mode 100644 index 00000000000..a7d190f0ae6 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/fractured_wavy_mesh_tet_DFN_3.vtu @@ -0,0 +1,47 @@ + + + + + + + AQAAAACAAADIBAAACgEAAA==eJwtxdciEAAAAEDZO6QSEUIhKaQiIxnZ2ZQKldUgyaqUpMhMic/14O7lAgJOnHKggxzsEIc6zOGOcKSjHO0Yx/q04xzvBJ9xos/6nM87yRec7BRfdKrTfMnpznCmLzvL2c7xFV91rvOc72su8HUX+oZvusjFLvEtl/q27/iuy1zue65wpatc7fuu8QPXus71bvBDN7rJzW5xq9vc7kfucKe73O0e97rP/R7wYz/xoJ/6mZ97yMMe8Qu/9CuPeszjnvCkX/uN3/qdpzzt957xB8/6o+c87wUvesmf/NlfvOyv/uYVf/eqf3jNP/3L697wb296y9ve8a73/Mf7/ut/PvB/H/rIx+ZALW0= + + + AQAAAACAAADIBAAAHwAAAA==eJxjZIAARhw0pQCXudQyf7iD0fAbBaOAMAAANZgADQ== + + + + + AQAAAACAAAAEBwAAGQAAAA==eJxjZGBgYBzFo3gUj+JRPIpHIAYAMeIBwg== + + + AQAAAACAAAAIDgAA2wIAAA==eJwtxVVgCAgAANCZ7s5hupnumO7unu5uwx3Xp7tdH9fBHac7ppvpmM10N/fhvZ+3MeC9Td7sLd7qbd7uHd7pXd7tPd7rfY7wfh/wQR/yYR/xUR/zcZ/wSZ/yaZ/xWUf6nM/7gi/6ki/7iq/6mq87yjcc7RjfdKxv+bbv+K7v+b4f+KEf+bGf+Kmf+blf+KVf+bXf+K3fOSCOHOi4juf4TuCETuTETuKkTubkTuGUTuXUTuO0Tuf0zuCMzuTMzuIgZ3U2Z3ewczinczm38ziv8zm/C7igC7mwi7ioiznExV3CJV3KpV3GZV3O5V3BFV3JlV3FVV3Noa7uGq7pWq7tOq7req7vBm7oRm7sJm7qZm7uFm7pVm7tNm7rdm7vDu7oTu7sLu7qMHdzd/dwT/dyb/dxX/dzfw/wQA/yYA/xUA/zcI/wSI/yaI/xWI/zeId7gid6kj/wh57sKf7IH/sTf+rP/Lm/8Jee6mme7hme6Vme7Tme63me7wVe6EVe7CVe6mVe7hX+yl/7G3/r7/y9f/CPXulV/sk/+xf/6t/8u//wn/7Lf3u11/gf/+u1Xuf/vN4bvNGbvNlbvNXbvN07vNO7vNt7vNf7HOH9PuCDPuTDPuKjPubjPuGTPuXTPuOzjvQ5n/cFX/QlX/YVX/U1X3eUbzjaMb7pWN/ybd/xXd/zfT/wQz/yYz/xUz/zc7/wS7/ya7/xW79zQOD74jjQcR3P8Z3ACZ3IiZ3ESZ3MyZ3CKZ3KqZ3GaZ3O6Z3BGZ3JmZ3FQc7qbM7uYOdwTudybudxXudzfhdwQRdyYRdxURdziIu7hEu6lEu7jMu6nMu7giu6kiu7iqu6mkNd3TVc07Vc23Vc1/Vc3w3c0I3c2E3c1M3c3C3c0q3c2m3c1u3c3h3c0Z3c2V3c1WHu5u7u4Z7u5d7u477u5/4e4IEe5MEe4qEe5uEe4ZEe5dEe47Ee5/EO9wT/DyDM2pc= + + + + + AQAAAACAAABYDgAAVwUAAA==eJytlXlQU0ccx0FlRGMVB4GizGAxYilgRdTiQPlRwR6SKGNBObRSvEdpZWqp2iLFQrGCaC3FYAcQEGIAGbDoQFWsHA0a1HAYcqCQvEACBU1VjgqYppB9T5aXotX9I2/28172+Oxvvsu9sD14n0sdGA03ITRKXZ0vc1r1TzXJg1ZxcuJv3QOn+bX13ttVeq4meXHyIt8ZaTdJjsYxom0aA9zQd/j34/XH++55n/rmpSA9jDxbyX2O7uNP/D32f3JcvAkNcEM+1RgXGvDWaoCrx/GMr0eD7QvnhtaDtxfdz//9P74+fNwX9fSyPnCveN3h8+PjGKrXlx3vVdfNq14XPv74vvOtYmdzfpPp+2K4w1jxGuuuHPo+vudgM5nQ82YwD/Qu4P91F5wz6m1Xfq3n3xIQ7JkDR3pbwONs9v2oqZIRvk8BCsdC02sT5OQ8Z1mB6gMXBeQ8iPfN69q6to+A1IQnP91e3kHySUsOdtd90QGzHauXbWQ1kTxpzx5/tpkYLNXWxUs8OsacQ4GkIaGCSeVGXG9um/EyAZzwmct67KUkuat9/MTC8/fApMrNnJdfT/KtB/yD+sPVsKrTZXWwO0FygYPl9wubG2DRLvl7g1l/YPMqoag34HBiayXJ84bX0Qnoibh/apGwZzd/DOcsZCpM2J0QsXubq9lWavzCWSWlOZcJ+PLIAtuU9VKS/xAXtKL0XAW0+DI37TCuhK6ylVYOvgLyfbcsJp3N1nkT3LDyGaL2kV3OXPP5RAGUda+z8JSpSF5JPNx2K48A/un42nVTqfPJtM4oOirrgDqplO3pRvGnEZ5l+wOuQzRXMSU8u4Xk/cTbjNATMtgr2p5xwY6qyyl3Tm5pyCEgOnhX/MAM6txK6j4q96tsAndFyLkMHrVO8bxQt56eDrj/sEnwbjU1vjS5ofzugBLyMX+Beq83Nlx5VM2meLzxV2W/l3UCeo+fgz/G0bkgn6TH4aYhvSFfiGtvjHhGfhG/rveJPCKOfCKPiEfpfSKPiHvo/SAviCPPyC/iyDPyizjyiTwijrwhX4gH0nrSkP4DMU5f3xroq6rh/hgjJvuh1cxWJVEL/Glb6namU/xvz3Z7G68OqHUOW5pVQO0ziNfH7x8UAWPIbuiNQWqfiVq77BRdDiiSTqTZWVN5GXm11+mdaQQkR61aXBJ9k+QTcoVhO8MIaMixPC4/RO1fwLU/b9NZA7EHrNukYipfJ4WnLVi9mwDZwtQ3j7hT+2QU9VzyO9UEzY+c8m7bU+v/c+3m5bfOyMbsH/Vxj/Q5QXmsbDjUlvvMvKg/aX+4YI5WQfLi9Jm9DzgSMJSzhvLUrHTBkpCZ4jH5W8rnB0h0uYzn7ID239YyJmeDpyulIbqcjZr6i03SMzm7WJ+zk7GcDbn41mnGZ2owtzmjLH6OnDUe/lVCCZazqA7xPBgvZ/diObs+P2wuV5ez5QmXiKz/yFmjUU1jwLeu3mnvNV090Z6DBujvNeoeH+1bA/T3mgbo7zUN0N9rurqn9Y3mxe+18esV5/T3mgbo7zUN4L6/8/Y6fs2FgNKjrhamae0geH9lyqbXVVDDc5CZiQho5j2N1fJU4Hdto7MbRwjiHu7SHR9IwIdjMVQTcRNqDkrkeUFqeCw0j+tZ0wSnSjO7C33rQH51zs9+G4Tw5Fhk/slTjRBdkFn464N2uBLXpuSZ1sPsDwe1VRFKsLWoqC8RNoK/Y+TJiEYVZOcUsWwlIjCZPqviTqIKjlnGZG0WqcAlcVF15ydt0MSIcFfPb4TD3zDTH6TVQn+q8nS0tBl2PUxxtxC1QBef9alPlQr+AVqOQHg= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAgOAAA/QkAAA==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 + + + AQAAAACAAAAIDgAAiQIAAA==eJwtxRGAKgYAANC2tS0IgoMgCIIgCIKDIAgOgiAIgiAIgiAIgiAIgoMgCIIgCIIgCIIgCIIgCIIgCIIgCD70nrxg4CPksCP+ctQxx51w0imnnfG3s8457x8XXHTJZVdcdc11N9x0y2133HXPfQ/866FHHnviqWeee+GlV15746133vvgo08+++Krb7774adffjvw16egQw474i9HHXPcCSedctoZfzvrnPP+ccFFl1x2xVXXXHfDTbfcdsdd99z3wL8eeuSxJ5565rkXXnrltTfeeue9Dz765LMvvvrmux9++uW3A39/CjrksCP+ctQxx51w0imnnfG3s8457x8XXHTJZVdcdc11N9x0y2133HXPfQ/866FHHnviqWeee+GlV15746133vvgo08+++Krb7774adffjvwz6egQw474i9HHXPcCSedctoZfzvrnPP+ccFFl1x2xVXXXHfDTbfcdsdd99z3wL8eeuSxJ5565rkXXnrltTfeeue9Dz765LMvvvrmux9++uW3A0E55LAj/nLUMcedcNIpp53xt7POOe8fF1x0yWVXXHXNdTfcdMttd9x1z30P/OuhRx574qlnnnvhpVdee+Otd9774KNPPvviq2++++GnX3478O+noEMOO+IvRx1z3AknnXLaGX8765zz/nHBRZdcdsVV11x3w0233HbHXffc98C/HnrksSeeeua5F1565bU33nrnvQ8++uSzL7765rsffvrltwP/fQo65LAj/nLUMcedcNIpp53xt7POOe8fF1x0yWVXXHXNdTfcdMttd9x1z30P/OuhRx574qlnnnvhpVdee+Otd9774KNPPvviq2++++GnX3478P+noP8Anu3h0w== + + + AQAAAACAAADBAQAADgAAAA==eJzj4hoFQxoAAGzsEYs= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/t_shaped_wavy_mesh_hex_DFN_t1t2.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/t_shaped_wavy_mesh_hex_DFN_t1t2.vtu new file mode 100644 index 00000000000..9e8d4115aae --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/t_shaped_wavy_mesh_hex_DFN_t1t2.vtu @@ -0,0 +1,41 @@ + + + + + + + AQAAAACAAADYAAAAEwAAAA==eJxjYMAOGHHQpIKBMgcABMgACg== + + + AQAAAACAAADYAAAAFgAAAA==eJxjYIAARgbsAJc4LjBYzAEAA8AABw== + + + + + + + AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/t_shaped_wavy_mesh_tet_DFN_t1t2.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/t_shaped_wavy_mesh_tet_DFN_t1t2.vtu new file mode 100644 index 00000000000..a947bb04cc7 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/t_shaped_wavy_mesh_tet_DFN_t1t2.vtu @@ -0,0 +1,50 @@ + + + + + + + AQAAAACAAABgBQAALgEAAA==eJwtxdciEAAAAEBCRogGTRKKlJZo01CZlRRFKJVRaSAhRWgRpUEqilLqJz24e7mAgEWBXuIgBzvESx3qMIc7wssc6ShHe7ljHOsVXulVXu04x3uN13qd13uDNzrBid7kJG92slOc6i3e6jSne5szvN07nOmd3uXd3uO9zvI+ZzvH+33AB33Ih33ER53rPB/zcZ/wSef7lE/7jAtc6CIXu8SlPutzPu8yX3C5L/qSK1zpy77iKlf7qmtc6zpf83XX+4Zv+pYb3OgmN/u27/iuW3zP9/3AD93qNrf7kTv82J3ucrefuMdP/cy97vNz93vAg37hl37l137jIQ/7rUc86nd+7zF/8Ed/8mePe8JfPOmv/ubvnvK0f/inZzzrX/7tOf/xX8/7n/97AZDZOXM= + + + AQAAAACAAABgBQAAOAAAAA==eJxjYIAARjQaHRCSx6UeF5+Q+cTaQ6l+Ut1JLqDUXFz+o5V76QUI+Wu4+HO4gNH4Ig0AAHNYACA= + + + AQAAAACAAABgBQAAIAAAAA==eJxjZIAARhw0rQEue4mlRwFlYDS8R8EooB0AAFSYABM= + + + + + AQAAAACAAACMCAAAHAAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8SgeIAwALusCJA== + + + AQAAAACAAAAYEQAAYAMAAA==eJwtxUMAEAYAAMC4bNu2jWXbtm172bZt27Zt23Z7dPe5qQH+mubpnuGZnuXZnuO5nuf5XuCFXuTFXuKlXublXuGVXuXVXuO1Xuf13uCN3uTN3uKt3ubt3uGd3uXd3uO93uf9PuCDPuTDPuKjPubjPuGTPuXTPuOzPufzvuCLvuTLvuKrvubrvuGbvuXbvuO7vuf7fuCHfuTHfuKnfubnfuGXfuXXfuO3fuf3/uCP/uTP/uKv/ubv/uGf/uXf/uMAAeVADuwgDup/HMzBHcIhHcqhHcZhHc7hHcERHcmRHcVRHc3RHcMxHcuxHcdxHc/xncAJnciJncRJnczJncIpncqpncZpnc7pncEZncmZncVZnc3ZncM5ncu5ncd5nc/5/a8LuKALubCLuKiLubhLuKRLubTLuKzLubwruKIrubKruKqrubpruKZrubbruK7rub4buKEbubGbuKmbublbuKVbubXbuK3bub07uKM7ubO7uKu7ubt7uKd7ubf7uK/7ub8HeKAH+T8P9hAP9TAP9wiP9CiP9hiP9TiP9wRP9CRP9hRP9TRP9wzP9CzP9hzP9TzP9wIv9CIv9hIv9TIv9wqv9Cqv9hqv9Tqv9wZv9CZv9hZv9TZv9w7v9C7v9h7v9T7v9wEf9CEf9hEf9TEf9wmf9Cmf9hmf9Tmf9wVf9CVf9hVf9TVf9w3f9C3f9h3f9T3f9wM/9CM/9hM/9TM/9wu/9Cu/9hu/9Tu/9wd/9Cd/9hd/9Td/9w//9C//9h8HCPS3gA7kwA7ioP7HwRzcIRzSoRzaYRzW4RzeERzRkRzZURzV0RzdMRzTsRzbcRzX8RzfCZzQiZzYSZzUyZzcKZzSqZzaaZzW6ZzeGZzRmZzZWZzV2ZzdOZzTuZzbeZzX+Zzf/7qAC7qQC7uIi7qYi7uES7qUS7uMy7qcy7uCK7qSK7uKq7qaq7uGa7qWa7uO67qe67uBG7qRG7uJm7qZm7uFW7qVW7uN27qd27uDO7qTO7uLu7qbu7uHe7qXe7uP+7qf+3uAB3qQ//NgD/FQD/Nwj/BIj/Joj/FYj/N4T/BET/JkT/FUT/N0z/BMz/Jsz/Fcz/N8L/BCL/JiL/FSL/Nyr/BKr/Jqr/Far/N6b/BGb/Jmb/FWb/N2/w/nfBih + + + + + AQAAAACAAAAgEAAACQYAAA==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 + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAABgRAAAdQsAAA==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 + + + AQAAAACAAAAYEQAACAMAAA==eJw11xGDAgYAQOHb1rYgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgODgIgiAIgiAIgiAIgiAIgiAIgsF9e/L9hhf4+i3IEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvssMse+xxwyBHHnHDKGb/5wzkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3P/z645cAgwwxzAijjDHOBJNMMc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAYccccwJp5zxmz+cc8ElV1xzwy133PPAI08888Irb7zzwSdffPPDrz9/CTDIEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvssMse+xxwyBHHnHDKGb/5wzkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3P/z665cAgwwxzAijjDHOBJNMMc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAYccccwJp5zxmz+cc8ElV1xzwy133PPAI08888Irb7zzwSdffPPDrwAYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdthlj30OOOSIY0445Yzf/OGcCy654pobbrnjngceeeKZF155450PPvnimx9+/f1LgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaHXfbY54BDjjjmhFPO+M0fzrngkiuuueGWO+554JEnnnnhlTfe+eCTL7754dc/vwQYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdthlj30OOOSIY0445Yzf/OGcCy654pobbrnjngceeeKZF155450PPvnimx9+/ftLgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaHXfbY54BDjjjmhFPO+M0fzrngkiuuueGWO+554JEnnnnhlTfe+eCTL7754f/DH2CQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZYZc99jngkCP+Bxt+Dgg= + + + AQAAAACAAAAjAgAADwAAAA==eJzj4hoFowAvAADiCRVf + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/y_shaped_wavy_mesh_hex_DFN_y1y2y3.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/y_shaped_wavy_mesh_hex_DFN_y1y2y3.vtu new file mode 100644 index 00000000000..2b6e29bbea9 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/y_shaped_wavy_mesh_hex_DFN_y1y2y3.vtu @@ -0,0 +1,44 @@ + + + + + + + AQAAAACAAADYAAAAEgAAAA==eJxjYMAPGEkUHyzmAAADMAAH + + + AQAAAACAAADYAAAAEwAAAA==eJxjYMAOGNFocsFAmQMAA5AABw== + + + AQAAAACAAADYAAAAFgAAAA==eJxjYIAARgbsAJc4LjBYzAEAA8AABw== + + + + + + + AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + + AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + + AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/dfn_market/y_shaped_wavy_mesh_tet_DFN_y1y2y3.vtu b/src/coreComponents/integrationTests/meshTests/dfn_market/y_shaped_wavy_mesh_tet_DFN_y1y2y3.vtu new file mode 100644 index 00000000000..58a31ce30a3 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/dfn_market/y_shaped_wavy_mesh_tet_DFN_y1y2y3.vtu @@ -0,0 +1,53 @@ + + + + + + + AQAAAACAAABgBQAALgEAAA==eJwtxdciEAAAAEBCRogGTRKKlJZo01CZlRRFKJVRaSAhRWgRpUEqilLqJz24e7mAgEWBXuIgBzvESx3qMIc7wssc6ShHe7ljHOsVXulVXu04x3uN13qd13uDNzrBid7kJG92slOc6i3e6jSne5szvN07nOmd3uXd3uO9zvI+ZzvH+33AB33Ih33ER53rPB/zcZ/wSef7lE/7jAtc6CIXu8SlPutzPu8yX3C5L/qSK1zpy77iKlf7qmtc6zpf83XX+4Zv+pYb3OgmN/u27/iuW3zP9/3AD93qNrf7kTv82J3ucrefuMdP/cy97vNz93vAg37hl37l137jIQ/7rUc86nd+7zF/8Ed/8mePe8JfPOmv/ubvnvK0f/inZzzrX/7tOf/xX8/7n/97AZDZOXM= + + + AQAAAACAAABgBQAAJwAAAA==eJxjYMAPGAnwcaknpG6oA1zhgoseaEDIfcTSo2AUjALiAQBMWAAT + + + AQAAAACAAABgBQAALAAAAA==eJxjYIAARjSagUg+tQC6/cTag0sdrdw5VAG54UusOdQyfxSMguEEAE8IABM= + + + AQAAAACAAABgBQAAJwAAAA==eJxjYMAPGAnQgwXgcg+6+GD3B63AQPmbUPoZafEwCkYWAABMWAAT + + + + + AQAAAACAAAB0CAAAHAAAAA==eJxjZGBgYBzFo3gUj+JRPIpH8SimMQYA+7gCHg== + + + AQAAAACAAADoEAAAVwMAAA==eJwtxUMAEAYAAMC4bNu2bdeybdu2bSzbtm3btm3u0d3npgf4a4ZnepZne47nep7ne4EXepEXe4mXepmXe4VXepVXe43Xep3Xe4M3epM3e4u3epu3e4d3epd3e4/3ep/3+4AP+pAP+4iP+piP+4RP+pRP+4zP+pzP+4Iv+pIv+4qv+pqv+4Zv+pZv+47v+p7v+4Ef+pEf+4mf+pmf+4Vf+pVf+43f+p3f+4M/+pM/+4u/+pu/+4d/+pd/+48DBJQDObCDOKj/cTAHdwiHdCiHdhiHdTiHdwRHdCRHdhRHdTRHdwzHdCzHdhzHdTzHdwIndCIndhIndTIndwqndCqndhqndTqndwZndCZndhZndTZndw7ndC7ndh7ndT7ndwEXdCEXdhEXdTEXdwmXdCn/69Iu47Iu5/Ku4Iqu5Mqu4qqu5uqu4Zqu5dqu47qu5/pu4IZu5MZu4qZu5uZu4ZZu5dZu47Zu5/bu4I7u5M7u4q7u5u7u4Z7u5d7u477u5/4e4IEe5MEe4qEe5uEe4ZEe5dEe47Ee5/Ge4Ime5Mme4qme5v883TM807M823M81/M83wu80Iu82Eu81Mu83Cu80qu82mu81uu83hu80Zu82Vu81du83Tu807u823u81/u83wd80Id82Ed81Md83Cd80qd82md81ud83hd80Zd82Vd81dd83Td807d823d81/d83w/80I/82E/81M/83C/80q/82m/81u/83h/80Z/82V/81d/83T/807/8238cINDfAjqQAzuIg/ofB3Nwh3BIh3Joh3FYh3N4R3BER3JkR3FUR3N0x3BMx3Jsx3Fcx3N8J3BCJ3JiJ3FSJ3Nyp3BKp3Jqp3Fap3N6Z3BGZ3JmZ3FWZ3N253BO53Ju53Fe53N+F3BBF3JhF3FRF3Nxl3BJl/K/Lu0yLutyLu8KruhKruwqrupqru4arularu06rut6ru8GbuhGbuwmbupmbu4WbulWbu02but2bu8O7uhO7uwu7upu7u4e7ule7u0+7ut+7u8BHuhBHuwhHuphHu4RHulRHu0xHutxHu8JnuhJnuwpnupp/s/TPcMzPcuzPcdzPc/zvcALvciLvcRLvczLvcIrvcqrvcZrvc7rvcEbvcmb/T/CaxSG + + + + + AQAAAACAAAAgEAAAsAUAAA==eJzNVm1MU2cULir4GUSq6BwKip+ARJg6v8LpGBrBD6ISW9wWmYDd/JhMJyoLnYKohLkYFcdQ0WyiTsU4/AgIInSKLjDbQldQoS21pbctjCsCgptzjNxzm/vWu5ptP3b+vLlP3/ec5zzPed9UIHhV0MD91sPf484C95F5yPMkTv7urB7Nw9NZP2RdvvN8q7N9fDzIUDrRmeLB+XRSEjj5zVefDD7dKaIOn79kX2QdEv+3/ZDnKSd5SZzMS/H44qwfvvkmfSS/Sb3IfCQfZ3PDpy/ffSN58s0fyYNcnfVB4mQ+sh7fPvL3/6o+xuvqi8HnD8nzn84HWd/uT4I8rPZKg95h5ewTGVhe1aI9E2PKdOBfHyyJn2ph8DrIf1IvLj6rg+i3ZWUadzODG0FxoubeDm8tSHK6V1eUN8Hl5ceEdQPvQJUblZlyRQunZi5NKT9kgc7ESEl2mRVGReQWjHXVwWraViANN0L/4jFffvGODbrb8rukn+ugI93UXfKtDbzFrtOqD8jh4oOaTPmEahhSP26t+tcGSDO4FTZvMsG5JRIq+XolBE555N5Rr4eLVm1cYNxDGJYp/0ATpoZ23/D2kZ/o4VxiQtc2bQUYLMnhK5PvwunZnf6HpDrwEq2ZftrdBr6XdPqsMg3Eu2+Wbu3SwaBAYXZUrA1ufScKVcvk4BF4UDywjx48+rc1tmXJmfqNUHito+WoUMnqsGpba/DR4EaIabntF+WvYHUr3Reyc/I2PXRXRS508/mF1Sd1+MKZo5frwf89ac72iAo4EvDGbxk3rVC9O9rvdl897ClZtmhgkQZmny/9LPN9G7wImDdtQA+Plyt3H+/eK2f1QedRD6yLOOqHPBEfyuiEfBBHnZAP4uMZneYwfBAvYXTi8qkjVpxjNbPeI3A59GNWxH9/2RM+FdCn91NN7CfzY5D5Mcj8AsGr85M6YhiBqyNGHaCOiKBuqCPiqDPqhTjqifoiTvrrL/S6kdvS5OBj/tP1qkwV5aDH/gWNQRvGWR183H52sTZJaYIp8zW5uS9us3jT47Cc2FAbmIUZCpfn9rqtUw4OvXbSSPheR/CgCd2bHPx1+WvZZePiPbr34jusLM7VmWbrRARH31AWVTnMAVdnmu132A8fveu5xj432O/axPajKW4/sriR6deXoz/N3rtX94tB9otB9suEQ7+kr/b7omm2LPjQ0+Kg844bY1VHtCbCVxrQb+59pgH9484TDZ61m+nInneO6ysNXD52nblzZvcF6yKO9XHOEO9g3n+cM8TdmPcfeSJO8sV63PtJw3HViMvloyqh0685YcWzxyy+Zf2JeFWMEfrNkLWotlpY/PSa7HnThlbCV4mJ0Us97Hqf7837yOH/QEPSLelIWS2kd54xucyy1/3jRFxSwPkmCJm0r++lAi2LfxxwPG5xxgNISI6O6dpk12tG3r5WkdgKlVO99gbV17B4dKq1ob6/zcFnyTeXlR0b78KF3vtgdcBxRdwQP+lp8TorZAdNMLgute+vmLuRnqE2wKXhVwvzSuz6DGiZReWBDTLSY8IK8+WE7xhGYg4x6tg5RAR9586D/T3k+mt/9zyYOUQcff9/vXcCwbWgopDWKAW4uLnmPPtaCVHNgaOvLlGAcMuQw1lqJZyzNl3oW/sz+KU9txoNFKR9n16QB/fhoenYnDEUBRG2nKsjxqsgacTEO09W95wvPRQ1IYICH2p7WvxUCkQhuztL55ph5PiY0PQoMwwIGEyLFpnh+snU+6kWM0TGpgSneFFQKxs0d/AZBTzXHTD5n6IgXPDwSegqFZiE3m3i0irwbtO3yaxmiD0yuWTdBgW8OeoM5TORgmXHGks+9aVAIlux2TxdB/urEp+K240Qu3N4+q6xFBz+SVPhGaSHontDDry1vxbShmXNF6+3wIpyaXHjTRWMqdn78opEB38CXfgtlw== + + + 0 + + + 1.7320508076 + + + + + + + AQAAAACAAACgQwAALwsAAA==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 + + + AQAAAACAAADoEAAAAAMAAA==eJw11xGDAgYAQOHb1rYgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgODgIgiAIgiAIgiAIgiAIgiAIgiAIgsF9e/L9hhf4+i3IEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvssMse+xxwyBG/+cMxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3P/z645cAgwwxzAijjDHOBJNMMc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAYcc8Zs/HHPCKWecc8ElV1xzwy133PPAI08888Irb7zzwSdffPPDrz9/CTDIEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvssMse+xxwyBG/+cMxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3P/z665cAgwwxzAijjDHOBJNMMc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAYcc8Zs/HHPCKWecc8ElV1xzwy133PPAI08888Irb7zzwSdffPPDrwAYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdthlj30OOOSI3/zhmBNOOeOcCy654pobbrnjngceeeKZF155450PPvnimx9+/f1LgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaHXfbY54BDjvjNH4454ZQzzrngkiuuueGWO+554JEnnnnhlTfe+eCTL7754dc/vwQYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdthlj30OOOSI3/zhmBNOOeOcCy654pobbrnjngceeeKZF155450PPvnimx9+/ftLgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaHXfbY54BDjvjNH4454ZQzzrngkiuuueGWO+554JEnnnnhlTfe+eCTL7754f/DH2CQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZ4X+84QrM + + + AQAAAACAAAAdAgAADwAAAA==eJzj4hoFowAHAABiZRUj + + + + + diff --git a/src/coreComponents/integrationTests/meshTests/testSurfaceGenerator.cpp b/src/coreComponents/integrationTests/meshTests/testSurfaceGenerator.cpp new file mode 100644 index 00000000000..fc460f8a1ba --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/testSurfaceGenerator.cpp @@ -0,0 +1,436 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 testSurfaceGenerator.cpp + * @brief Integration tests for SurfaceGenerator topology modification (serial, no MPI). + * + * Verifies node duplication, fracture element creation, and Euler characteristic (χ = V-E+F-C) + * for boundary-cutting and internal fracture configurations on hex and tet meshes. + */ + +#include "testSurfaceGeneratorCommon.hpp" + +// Global flag to control debug printing (set to false to disable verbose output) +CommandLineOptions g_commandLineOptions; + +/// @brief Directory containing the test binary (and the copied mesh files). +/// Populated in main() from argv[0] so it is always correct regardless +/// of the build system (Makefiles, Ninja, Xcode) or how CTest sets CWD. +std::string g_testBinaryDir; + +/** + * @brief Parametrized test fixture for SurfaceGenerator. + * + * Parameters: (test-name, mesh-file, node-set-names, χ_before, χ_after). + */ +class SurfaceGeneratorTest + : public ::testing::TestWithParam< std::tuple< std::string, std::string, std::string, integer, integer > > +{ +protected: + void SetUp() override + { + // Priority: runtime argv[0]-derived dir > env var > compile-time macro. + // g_testBinaryDir is always the actual directory of the executable, so it + // is correct even when the Xcode generator bakes the wrong path into the + // TEST_BINARY_DIR macro or when CTest sets a different CWD. + if( !g_testBinaryDir.empty() ) + { + testBinaryDir = g_testBinaryDir; + } + else + { + char const * envDir = std::getenv( "TEST_BINARY_DIR" ); + testBinaryDir = ( envDir != nullptr && envDir[0] != '\0' ) ? envDir : TEST_BINARY_DIR; + } + } + + std::string testBinaryDir; + + /// @brief Build the XML input string for this test case. + std::string generateXmlInput( std::string const & meshFile, + std::string const & nodeSetNames ) + { + std::ostringstream oss; + oss << R"xml( + + + + + + + + + + + + + + + + + + + + + + + + + + +)xml"; + return oss.str(); + } + + /// @brief Execute one parametrized test case end-to-end. + void runTest( std::string const & testCaseName, + std::string const & meshFileName, + std::string const & nodeSetNames, + integer const expectedEulerBefore, + integer const expectedEulerAfter ) + { + // Prefix the mesh path with testBinaryDir so GEOS can find the .vtu files + // regardless of the CWD set by CTest (which differs from TARGET_FILE_DIR). + std::string const xmlInput = generateXmlInput( + testBinaryDir + "/" + meshFileName, + nodeSetNames ); + + // Write XML next to the binary (testBinaryDir) so the path is always valid + // whether the test is run directly or through CTest. + // Only rank 0 writes; all ranks barrier before any rank tries to open it. + std::string const xmlFileName = testBinaryDir + "/test_surface_gen_" + testCaseName + ".xml"; + if( MpiWrapper::commRank( MPI_COMM_GEOS ) == 0 ) + { + std::ofstream xmlFile( xmlFileName ); + xmlFile << xmlInput; + xmlFile.close(); + } + MpiWrapper::barrier( MPI_COMM_GEOS ); + + // Setup GEOS + std::unique_ptr< CommandLineOptions > options = std::make_unique< CommandLineOptions >( g_commandLineOptions ); + options->inputFileNames.clear(); + options->inputFileNames.push_back( xmlFileName ); + + // Scoped state to ensure GeosxState is fully destroyed before the next + // test case constructs a new one (GeosxState is a singleton). + { + GeosxState state( std::move( options ) ); + ASSERT_TRUE( state.initializeDataRepository() ) + << "Test " << testCaseName << ": Failed to initialize data repository for mesh file '" + << meshFileName << "' with node sets " << nodeSetNames; + state.applyInitialConditions(); + + // Get mesh before surface generation + ProblemManager & pm = state.getProblemManager(); + DomainPartition & domain = pm.getDomainPartition(); + MeshLevel & mesh = domain.getMeshBody( 0 ).getBaseDiscretization(); + + NodeManager & nodeManager = mesh.getNodeManager(); + EdgeManager & edgeManager = mesh.getEdgeManager(); + FaceManager & faceManager = mesh.getFaceManager(); + ElementRegionManager & elemManager = mesh.getElemManager(); + + // Store initial statistics + TopologyStats statsBefore; + statsBefore.numNodes = nodeManager.size(); + statsBefore.numEdges = edgeManager.size(); + statsBefore.numFaces = faceManager.size(); + statsBefore.numCells = 0; + elemManager.forElementSubRegions< CellElementSubRegion >( [&]( CellElementSubRegion const & subRegion ) + { + statsBefore.numCells += subRegion.size(); + } ); + + // **NEW: Preprocess fracture topology to predict duplication BEFORE mesh split** + std::vector< std::string > fractureNodeSets = parseNodeSetNames( nodeSetNames ); + ExpectedDuplication expected = preprocessFractureTopology( mesh, fractureNodeSets ); + + GEOS_LOG_RANK_0( "========================================" ); + GEOS_LOG_RANK_0( "Test: " << testCaseName ); + GEOS_LOG_RANK_0( "Expected duplication:" ); + GEOS_LOG_RANK_0( " Nodes to split: " << expected.numNodesToDuplicate + << " (new nodes created: " << expected.totalDuplicatedNodes << ")" ); + GEOS_LOG_RANK_0( " Edges to split: " << expected.numEdgesToDuplicate + << " (new edges created: " << expected.totalDuplicatedEdges << ")" ); + GEOS_LOG_RANK_0( " Faces to split: " << expected.numFacesToDuplicate + << " (new faces created: " << expected.totalDuplicatedFaces << ")" ); + + // Compute Euler-Poincaré characteristic χ = V - E + F - C (should be 1 for connected solid). + integer const eulerCharBeforeSplit = computeEulerCharacteristic( nodeManager, edgeManager, faceManager, elemManager ); + GEOS_LOG_RANK_0( " Euler characteristic before split: " << eulerCharBeforeSplit ); + + // Run the simulation (executes SurfaceGenerator and splits the mesh) + state.run(); + + // Get statistics after surface generation + TopologyStats statsAfter; + statsAfter.numNodes = nodeManager.size(); + statsAfter.numEdges = edgeManager.size(); + statsAfter.numFaces = faceManager.size(); + statsAfter.numCells = 0; + statsAfter.numFractureElements = 0; + + elemManager.forElementSubRegions< CellElementSubRegion >( [&]( CellElementSubRegion const & subRegion ) + { + statsAfter.numCells += subRegion.size(); + } ); + + elemManager.forElementSubRegions< FaceElementSubRegion >( [&]( FaceElementSubRegion const & subRegion ) + { + statsAfter.numFractureElements += subRegion.size(); + } ); + + statsAfter.numDuplicatedNodes = statsAfter.numNodes - statsBefore.numNodes; + + // **NEW: AFTER mesh split - Compare expeted vs computed values** + GEOS_LOG_RANK_0( "Actual duplication:" ); + GEOS_LOG_RANK_0( " New nodes created: " << statsAfter.numDuplicatedNodes ); + GEOS_LOG_RANK_0( " Fracture elements created: " << statsAfter.numFractureElements ); + + // Compute Euler-Poincaré characteristic χ = V - E + F - C after split + integer const eulerCharAfterSplit = computeEulerCharacteristic( nodeManager, edgeManager, faceManager, elemManager ); + GEOS_LOG_RANK_0( " Euler characteristic after split: " << eulerCharAfterSplit ); + + // Store Euler characteristic + statsAfter.eulerCharacteristic = eulerCharAfterSplit; + + // All validations are performed in one place + validateSurfaceGeneratorResults( testCaseName, + meshFileName, + nodeSetNames, + statsBefore, + statsAfter, + expected, + expectedEulerBefore, + eulerCharBeforeSplit, + expectedEulerAfter, + eulerCharAfterSplit, + nodeManager ); + + // Log statistics + GEOS_LOG_RANK_0( "Summary:" ); + GEOS_LOG_RANK_0( " Nodes before: " << statsBefore.numNodes << ", after: " << statsAfter.numNodes + << " (+" << statsAfter.numDuplicatedNodes << ")" ); + GEOS_LOG_RANK_0( " Fracture elements: " << statsAfter.numFractureElements ); + GEOS_LOG_RANK_0( "========================================" ); + + } // end scoped GeosxState + } +}; + +/// @brief Test body — dispatches to runTest(). +/// Only runs on exactly 1 MPI rank; skipped when the binary is launched under mpirun with >1 ranks. +TEST_P( SurfaceGeneratorTest, TopologyValidation ) +{ + auto const & params = GetParam(); + std::string const & testCaseName = std::get< 0 >( params ); + std::string const & meshFileName = std::get< 1 >( params ); + std::string const & nodeSetNames = std::get< 2 >( params ); + integer const expectedEulerBefore = std::get< 3 >( params ); + integer const expectedEulerAfter = std::get< 4 >( params ); + + runTest( testCaseName, meshFileName, nodeSetNames, expectedEulerBefore, expectedEulerAfter ); +} + +// --------------------------------------------------------------------------- +// NoBoundaryCut: single interior node at (0.5,0.5,0.5) is duplicated once per +// fracture plane sharing it, but Δχ = +1 regardless of additional planes → χ_after = 2. +// --------------------------------------------------------------------------- +// clang-format off +INSTANTIATE_TEST_SUITE_P( + SurfaceGeneratorCases, + SurfaceGeneratorTest, + ::testing::Values( + + // ======================================================================= + // dfn_market meshes + // ----------------------------------------------------------------------- + // Naming convention: + // fractured[_wavy][_full_span]_mesh_{hex|tet}_DFN_{suffix}.vtu + // + // Column layout: test-name, mesh-file, node-sets, χ_before, χ_after + // + // Node-set rules: + // • _DFN_1 → { f1_node_set } + // • _DFN_2 → { f2_node_set } + // • _DFN_3 → { f3_node_set } + // • _DFN_12 → { f1_node_set, f2_node_set } + // • _DFN_13 → { f1_node_set, f3_node_set } + // • _DFN_23 → { f2_node_set, f3_node_set } + // • _DFN_123 → { f1_node_set, f2_node_set, f3_node_set } + + // ----------------------------------------------------------------------- + // flat · no-boundary-cut · hex + // ----------------------------------------------------------------------- + // test name mesh file node sets χ_b χ_a + std::make_tuple( "Mkt_NoBndCut_hex_DFN_1", "fractured_mesh_hex_DFN_1.vtu", "{ f1_node_set }", 1, 2 ), + std::make_tuple( "Mkt_NoBndCut_hex_DFN_2", "fractured_mesh_hex_DFN_2.vtu", "{ f2_node_set }", 1, 2 ), + std::make_tuple( "Mkt_NoBndCut_hex_DFN_3", "fractured_mesh_hex_DFN_3.vtu", "{ f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_NoBndCut_hex_DFN_12", "fractured_mesh_hex_DFN_12.vtu", "{ f1_node_set, f2_node_set }", 1, 2 ), + std::make_tuple( "Mkt_NoBndCut_hex_DFN_13", "fractured_mesh_hex_DFN_13.vtu", "{ f1_node_set, f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_NoBndCut_hex_DFN_23", "fractured_mesh_hex_DFN_23.vtu", "{ f2_node_set, f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_NoBndCut_hex_DFN_123", "fractured_mesh_hex_DFN_123.vtu", "{ f1_node_set, f2_node_set, f3_node_set }", 1, 2 ), + + // ----------------------------------------------------------------------- + // flat · no-boundary-cut · tet + // ----------------------------------------------------------------------- + // test name mesh file node sets χ_b χ_a + std::make_tuple( "Mkt_NoBndCut_tet_DFN_1", "fractured_mesh_tet_DFN_1.vtu", "{ f1_node_set }", 1, 2 ), + std::make_tuple( "Mkt_NoBndCut_tet_DFN_2", "fractured_mesh_tet_DFN_2.vtu", "{ f2_node_set }", 1, 2 ), + std::make_tuple( "Mkt_NoBndCut_tet_DFN_3", "fractured_mesh_tet_DFN_3.vtu", "{ f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_NoBndCut_tet_DFN_12", "fractured_mesh_tet_DFN_12.vtu", "{ f1_node_set, f2_node_set }", 1, 2 ), + std::make_tuple( "Mkt_NoBndCut_tet_DFN_13", "fractured_mesh_tet_DFN_13.vtu", "{ f1_node_set, f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_NoBndCut_tet_DFN_23", "fractured_mesh_tet_DFN_23.vtu", "{ f2_node_set, f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_NoBndCut_tet_DFN_123", "fractured_mesh_tet_DFN_123.vtu", "{ f1_node_set, f2_node_set, f3_node_set }", 1, 2 ), + + // ----------------------------------------------------------------------- + // flat · full-span · hex + // ----------------------------------------------------------------------- + // test name mesh file node sets χ_b + // χ_a + std::make_tuple( "Mkt_BndCut_hex_DFN_1", "fractured_full_span_mesh_hex_DFN_1.vtu", "{ f1_node_set }", 1, 2 ), + std::make_tuple( "Mkt_BndCut_hex_DFN_2", "fractured_full_span_mesh_hex_DFN_2.vtu", "{ f2_node_set }", 1, 2 ), + std::make_tuple( "Mkt_BndCut_hex_DFN_3", "fractured_full_span_mesh_hex_DFN_3.vtu", "{ f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_BndCut_hex_DFN_12", "fractured_full_span_mesh_hex_DFN_12.vtu", "{ f1_node_set, f2_node_set }", 1, 4 ), + std::make_tuple( "Mkt_BndCut_hex_DFN_13", "fractured_full_span_mesh_hex_DFN_13.vtu", "{ f1_node_set, f3_node_set }", 1, 4 ), + std::make_tuple( "Mkt_BndCut_hex_DFN_23", "fractured_full_span_mesh_hex_DFN_23.vtu", "{ f2_node_set, f3_node_set }", 1, 4 ), + std::make_tuple( "Mkt_BndCut_hex_DFN_123", "fractured_full_span_mesh_hex_DFN_123.vtu", "{ f1_node_set, f2_node_set, f3_node_set }", 1, 8 ), + + // ----------------------------------------------------------------------- + // flat · full-span · tet + // ----------------------------------------------------------------------- + // test name mesh file node sets χ_b + // χ_a + std::make_tuple( "Mkt_BndCut_tet_DFN_1", "fractured_full_span_mesh_tet_DFN_1.vtu", "{ f1_node_set }", 1, 2 ), + std::make_tuple( "Mkt_BndCut_tet_DFN_2", "fractured_full_span_mesh_tet_DFN_2.vtu", "{ f2_node_set }", 1, 2 ), + std::make_tuple( "Mkt_BndCut_tet_DFN_3", "fractured_full_span_mesh_tet_DFN_3.vtu", "{ f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_BndCut_tet_DFN_12", "fractured_full_span_mesh_tet_DFN_12.vtu", "{ f1_node_set, f2_node_set }", 1, 4 ), + std::make_tuple( "Mkt_BndCut_tet_DFN_13", "fractured_full_span_mesh_tet_DFN_13.vtu", "{ f1_node_set, f3_node_set }", 1, 4 ), + std::make_tuple( "Mkt_BndCut_tet_DFN_23", "fractured_full_span_mesh_tet_DFN_23.vtu", "{ f2_node_set, f3_node_set }", 1, 4 ), + std::make_tuple( "Mkt_BndCut_tet_DFN_123", "fractured_full_span_mesh_tet_DFN_123.vtu", "{ f1_node_set, f2_node_set, f3_node_set }", 1, 8 ), + + // ----------------------------------------------------------------------- + // wavy · no-boundary-cut · hex + // ----------------------------------------------------------------------- + // test name mesh file node sets χ_b + // χ_a + std::make_tuple( "Mkt_WavyNoBndCut_hex_DFN_1", "fractured_wavy_mesh_hex_DFN_1.vtu", "{ f1_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyNoBndCut_hex_DFN_2", "fractured_wavy_mesh_hex_DFN_2.vtu", "{ f2_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyNoBndCut_hex_DFN_3", "fractured_wavy_mesh_hex_DFN_3.vtu", "{ f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyNoBndCut_hex_DFN_12", "fractured_wavy_mesh_hex_DFN_12.vtu", "{ f1_node_set, f2_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyNoBndCut_hex_DFN_13", "fractured_wavy_mesh_hex_DFN_13.vtu", "{ f1_node_set, f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyNoBndCut_hex_DFN_23", "fractured_wavy_mesh_hex_DFN_23.vtu", "{ f2_node_set, f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyNoBndCut_hex_DFN_123", "fractured_wavy_mesh_hex_DFN_123.vtu", "{ f1_node_set, f2_node_set, f3_node_set }", 1, 2 ), + + // ----------------------------------------------------------------------- + // wavy · no-boundary-cut · tet + // ----------------------------------------------------------------------- + // test name mesh file node sets χ_b + // χ_a + std::make_tuple( "Mkt_WavyNoBndCut_tet_DFN_1", "fractured_wavy_mesh_tet_DFN_1.vtu", "{ f1_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyNoBndCut_tet_DFN_2", "fractured_wavy_mesh_tet_DFN_2.vtu", "{ f2_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyNoBndCut_tet_DFN_3", "fractured_wavy_mesh_tet_DFN_3.vtu", "{ f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyNoBndCut_tet_DFN_12", "fractured_wavy_mesh_tet_DFN_12.vtu", "{ f1_node_set, f2_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyNoBndCut_tet_DFN_13", "fractured_wavy_mesh_tet_DFN_13.vtu", "{ f1_node_set, f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyNoBndCut_tet_DFN_23", "fractured_wavy_mesh_tet_DFN_23.vtu", "{ f2_node_set, f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyNoBndCut_tet_DFN_123", "fractured_wavy_mesh_tet_DFN_123.vtu", "{ f1_node_set, f2_node_set, f3_node_set }", 1, 2 ), + + // ----------------------------------------------------------------------- + // wavy · full-span · hex + // ----------------------------------------------------------------------- + // test name mesh file node sets + // χ_b χ_a + std::make_tuple( "Mkt_WavyBndCut_hex_DFN_1", "fractured_wavy_full_span_mesh_hex_DFN_1.vtu", "{ f1_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyBndCut_hex_DFN_2", "fractured_wavy_full_span_mesh_hex_DFN_2.vtu", "{ f2_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyBndCut_hex_DFN_3", "fractured_wavy_full_span_mesh_hex_DFN_3.vtu", "{ f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyBndCut_hex_DFN_12", "fractured_wavy_full_span_mesh_hex_DFN_12.vtu", "{ f1_node_set, f2_node_set }", 1, 4 ), + std::make_tuple( "Mkt_WavyBndCut_hex_DFN_13", "fractured_wavy_full_span_mesh_hex_DFN_13.vtu", "{ f1_node_set, f3_node_set }", 1, 4 ), + std::make_tuple( "Mkt_WavyBndCut_hex_DFN_23", "fractured_wavy_full_span_mesh_hex_DFN_23.vtu", "{ f2_node_set, f3_node_set }", 1, 4 ), + std::make_tuple( "Mkt_WavyBndCut_hex_DFN_123", "fractured_wavy_full_span_mesh_hex_DFN_123.vtu", "{ f1_node_set, f2_node_set, f3_node_set }", 1, 8 ), + + // ----------------------------------------------------------------------- + // wavy · full-span · tet + // ----------------------------------------------------------------------- + // test name mesh file node sets + // χ_b χ_a + std::make_tuple( "Mkt_WavyBndCut_tet_DFN_1", "fractured_wavy_full_span_mesh_tet_DFN_1.vtu", "{ f1_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyBndCut_tet_DFN_2", "fractured_wavy_full_span_mesh_tet_DFN_2.vtu", "{ f2_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyBndCut_tet_DFN_3", "fractured_wavy_full_span_mesh_tet_DFN_3.vtu", "{ f3_node_set }", 1, 2 ), + std::make_tuple( "Mkt_WavyBndCut_tet_DFN_12", "fractured_wavy_full_span_mesh_tet_DFN_12.vtu", "{ f1_node_set, f2_node_set }", 1, 4 ), + std::make_tuple( "Mkt_WavyBndCut_tet_DFN_13", "fractured_wavy_full_span_mesh_tet_DFN_13.vtu", "{ f1_node_set, f3_node_set }", 1, 4 ), + std::make_tuple( "Mkt_WavyBndCut_tet_DFN_23", "fractured_wavy_full_span_mesh_tet_DFN_23.vtu", "{ f2_node_set, f3_node_set }", 1, 4 ), + std::make_tuple( "Mkt_WavyBndCut_tet_DFN_123", "fractured_wavy_full_span_mesh_tet_DFN_123.vtu", "{ f1_node_set, f2_node_set, f3_node_set }", 1, 8 ), + + // ----------------------------------------------------------------------- + // T-shaped · boundary-cutting · hex & tet + // ----------------------------------------------------------------------- + // F1 fully spans the domain (boundary-cutting); F2 is the stem terminating at F1. + // The junction splits the solid into 3 parts → χ_after = 3. + // test name mesh file node sets χ_b χ_a + std::make_tuple( "Mkt_BndCut_t_shaped_hex_DFN_12", "t_shaped_wavy_mesh_hex_DFN_t1t2.vtu", "{ f1_node_set, f2_node_set }", 1, 3 ), + std::make_tuple( "Mkt_BndCut_t_shaped_tet_DFN_12", "t_shaped_wavy_mesh_tet_DFN_t1t2.vtu", "{ f1_node_set, f2_node_set }", 1, 3 ), + + // ----------------------------------------------------------------------- + // Y-shaped · boundary-cutting · hex & tet + // ----------------------------------------------------------------------- + // Three boundary-cutting fractures meeting along a common line (Y cross-section). + // Splits the solid into 3 parts → χ_after = 3. + // test name mesh file node sets + // χ_b χ_a + std::make_tuple( "Mkt_BndCut_Y_shaped_hex_DFN_123", "y_shaped_wavy_mesh_hex_DFN_y1y2y3.vtu", "{ f1_node_set, f2_node_set, f3_node_set }", 1, 3 ), + std::make_tuple( "Mkt_BndCut_Y_shaped_tet_DFN_123", "y_shaped_wavy_mesh_tet_DFN_y1y2y3.vtu", "{ f1_node_set, f2_node_set, f3_node_set }", 1, 3 ), + + // ----------------------------------------------------------------------- + // Miscellaneous · no-boundary-cutting · hex & tet + // ----------------------------------------------------------------------- + // Five no-boundary-cutting fractures with high-aspect ratio cells. + std::make_tuple( "Mkt_NoBndCut_5_fracs_hex_DFN", "DFN_5_fractures_hex_binarized.vtu", "{ f1_node_set, f2_node_set, f3_node_set, f4_node_set, f5_node_set }", 1, 2 ), + std::make_tuple( "Mkt_NoBndCut_5_fracs_tet_DFN", "DFN_5_fractures_tet_binarized.vtu", "{ f1_node_set, f2_node_set, f3_node_set, f4_node_set, f5_node_set}", 1, 2 ) + ) + ); + +int main( int argc, char * argv[] ) +{ + ::testing::InitGoogleTest( &argc, argv ); + g_commandLineOptions = *geos::basicSetup( argc, argv, false ); + int result = RUN_ALL_TESTS(); + geos::basicCleanup(); + return result; +} diff --git a/src/coreComponents/integrationTests/meshTests/testSurfaceGeneratorCommon.hpp b/src/coreComponents/integrationTests/meshTests/testSurfaceGeneratorCommon.hpp new file mode 100644 index 00000000000..d0be8388318 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/testSurfaceGeneratorCommon.hpp @@ -0,0 +1,904 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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. + * ------------------------------------------------------------------------------------------------------------ + */ + +#ifndef TESTSURFACEGENERATORCOMMON_HPP +#define TESTSURFACEGENERATORCOMMON_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // std::strlen +#include // dirname / basename (POSIX) + +#include "mainInterface/GeosxState.hpp" +#include "mainInterface/ProblemManager.hpp" +#include "mainInterface/initialization.hpp" +#include "codingUtilities/Utilities.hpp" +#include "physicsSolvers/PhysicsSolverManager.hpp" +#include "physicsSolvers/surfaceGeneration/SurfaceGenerator.hpp" +#include "mesh/MeshLevel.hpp" +#include "mesh/NodeManager.hpp" +#include "mesh/EdgeManager.hpp" +#include "mesh/FaceManager.hpp" +#include "mesh/ElementRegionManager.hpp" +#include "mesh/CellElementSubRegion.hpp" +#include "mesh/FaceElementSubRegion.hpp" +#include "mesh/DomainPartition.hpp" +#include "mesh/generators/MeshGeneratorBase.hpp" +#include "common/MpiWrapper.hpp" + +using namespace geos; + +constexpr real64 COORDINATE_TOLERANCE = 1.0e-10; +constexpr real64 JACOBIAN_TOLERANCE = 1.0e-12; + +// Global flag to control debug printing (set to false to disable verbose output) +static constexpr bool ENABLE_DEBUG_PRINTS = false; + +/** + * @brief Controls whether the SurfaceGenerator creates fracture elements for corner faces. + * + * Corner faces are triangular facets whose nodes all lie on the fracture boundary (i.e. at the + * geometric tip corners of the fracture surface). When this flag is @c false, the + * SurfaceGenerator does @e not create fracture elements for these faces and their nodes are + * never split, so the test predictions must subtract them from the expected fracture element + * count. + * + * Corner fractures are disabled by default because they are problematic for the contact + * solvers: + * 1. Both sides of a corner fracture share the same (unsplit) nodes, causing duplicate + * column indices in the CRS sparsity pattern and violating the sorted-unique invariant + * of LvArray. + * 2. The displacement jump [[u]] is identically zero (only bubble DOFs contribute), so + * the standard ALM interface kernel would assemble a singular or duplicate stiffness + * block. + * + * @note Quad faces (hex meshes) are never corner faces because the SurfaceGenerator always + * finds a valid separation path for them. + */ +static constexpr bool ENABLE_CORNER_FRACTURES = false; + + +extern CommandLineOptions g_commandLineOptions; +extern std::string g_testBinaryDir; + +/** + * @brief Represents a unique edge by its sorted node IDs + */ +struct Edge +{ + localIndex nodeA; + localIndex nodeB; + + Edge( localIndex a, localIndex b ) + : nodeA( std::min( a, b )), nodeB( std::max( a, b )) + {} + + bool operator<( Edge const & other ) const + { + return (nodeA < other.nodeA) || (nodeA == other.nodeA && nodeB < other.nodeB); + } + + bool operator==( Edge const & other ) const + { + return nodeA == other.nodeA && nodeB == other.nodeB; + } +}; + +/** + * @brief Represents a unique facet by its sorted node IDs + */ +struct Facet +{ + std::vector< localIndex > nodes; + + Facet( std::initializer_list< localIndex > nodeList ) + { + nodes.assign( nodeList ); + std::sort( nodes.begin(), nodes.end()); + } + + template< typename Iterator > + Facet( Iterator begin, Iterator end ) + { + nodes.assign( begin, end ); + std::sort( nodes.begin(), nodes.end()); + } + + Facet( arraySlice1d< localIndex const > nodeList ) + { + nodes.assign( nodeList.begin(), nodeList.end()); + std::sort( nodes.begin(), nodes.end()); + } + + bool operator<( Facet const & other ) const + { + return nodes < other.nodes; + } + + bool operator==( Facet const & other ) const + { + return nodes == other.nodes; + } +}; + +/** + * @brief Expected topology duplication statistics. + * + * Internal entities (not on the [0,1]³ boundary) are duplicated; boundary entities are not. + */ +struct ExpectedDuplication +{ + // Bulk mesh statistics (all cell elements) + localIndex numNodesInBulk = 0; + localIndex numEdgesInBulk = 0; + localIndex numFacesInBulk = 0; + localIndex numCellsInBulk = 0; + + // Fracture statistics + localIndex numFractureNodes = 0; // Total nodes in fracture nodesets + localIndex numFractureEdges = 0; // Total edges in fracture + localIndex numFractureFaces = 0; // Total faces in fracture + localIndex numFractureElements = 0; // Expected fracture elements (2D faces to create) + + // Duplication statistics (only internal entities) + localIndex numNodesToDuplicate = 0; // Internal fracture nodes (not on boundary) + localIndex numEdgesToDuplicate = 0; // Internal fracture edges (not on boundary) + localIndex numFacesToDuplicate = 0; // Fracture faces to duplicate + + localIndex totalDuplicatedNodes = 0; // New nodes created + localIndex totalDuplicatedEdges = 0; // New edges created + localIndex totalDuplicatedFaces = 0; // New faces created + + std::set< localIndex > internalNodes; // Nodes to duplicate (interior only) + std::set< localIndex > boundaryNodes; // Nodes on domain boundary (not duplicated) + std::set< Edge > internalEdges; // Edges to duplicate (interior only) + std::set< Edge > boundaryEdges; // Edges on domain boundary (not duplicated) + + localIndex numBoundaryNodesOnDomain = 0; // Count of fracture boundary nodes that touch domain boundary +}; + +/** + * @brief Helper structure to store mesh topology statistics + */ +struct TopologyStats +{ + localIndex numNodes; + localIndex numEdges; + localIndex numFaces; + localIndex numCells; + localIndex numDuplicatedNodes; + localIndex numFractureElements; + integer eulerCharacteristic; + integer numBodies; // Number of separate domain fragments +}; + +/// @brief Assert all duplicated nodes have zero spatial distance from their parent. +void checkCoordinateCoincidence( NodeManager const & nodeManager, + std::map< localIndex, localIndex > const & parentToChild ) +{ + arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const nodePositions = + nodeManager.referencePosition(); + + for( auto const & [parentIdx, childIdx] : parentToChild ) + { + real64 dx = nodePositions[childIdx][0] - nodePositions[parentIdx][0]; + real64 dy = nodePositions[childIdx][1] - nodePositions[parentIdx][1]; + real64 dz = nodePositions[childIdx][2] - nodePositions[parentIdx][2]; + real64 dist = std::sqrt( dx*dx + dy*dy + dz*dz ); + + EXPECT_NEAR( dist, 0.0, COORDINATE_TOLERANCE ) + << "Duplicated node " << childIdx << " (parent " << parentIdx << ") has non-zero spatial distance: " << dist + << "\n Parent coordinates: (" << nodePositions[parentIdx][0] << ", " << nodePositions[parentIdx][1] << ", " << nodePositions[parentIdx][2] << ")" + << "\n Child coordinates: (" << nodePositions[childIdx][0] << ", " << nodePositions[childIdx][1] << ", " << nodePositions[childIdx][2] << ")" + << "\n Expected tolerance: " << COORDINATE_TOLERANCE; + } +} + +/// @brief Assert no element has duplicate node references (degenerate Jacobian check). +void checkElementJacobians( ElementRegionManager const & elemManager ) +{ + localIndex totalElements = 0; + elemManager.forElementSubRegions< CellElementSubRegion >( [&]( CellElementSubRegion const & subRegion ) + { + totalElements += subRegion.size(); + } ); + + GEOS_LOG_RANK_0( "Checking element Jacobians for " << totalElements << " elements" ); + + elemManager.forElementSubRegions< CellElementSubRegion >( [&]( CellElementSubRegion const & subRegion ) + { + // Note: Detailed Jacobian computation would require access to shape functions + // Here we perform a simplified check that elements still reference valid nodes + arrayView2d< localIndex const, cells::NODE_MAP_USD > const elemToNodeMap = + subRegion.nodeList(); + + for( localIndex ei = 0; ei < subRegion.size(); ++ei ) + { + localIndex const numNodesPerElem = elemToNodeMap.size( 1 ); + std::set< localIndex > uniqueNodes; + for( localIndex i = 0; i < numNodesPerElem; ++i ) + { + uniqueNodes.insert( elemToNodeMap[ei][i] ); + } + + // Element should have the correct number of unique nodes + EXPECT_EQ( uniqueNodes.size(), numNodesPerElem ) + << "Element " << ei << " in subRegion '" << subRegion.getName() + << "' has duplicate node references" + << "\n Expected unique nodes: " << numNodesPerElem + << "\n Actual unique nodes: " << uniqueNodes.size() + << "\n This indicates nodes on both sides of the fracture are incorrectly connected to the same element"; + } + } ); +} + +/** + * @brief Run all assertions for a single test case (node duplication, fracture elements, + * coordinate validity, and Euler characteristic). + */ +void validateSurfaceGeneratorResults( std::string const & testCaseName, + std::string const & meshFileName, + std::string const & nodeSetNames, + TopologyStats const & statsBefore, + TopologyStats const & statsAfter, + ExpectedDuplication const & expected, + integer const expectedEulerBefore, + integer const eulerCharBeforeSplit, + integer const expectedEulerAfter, + integer const eulerCharAfterSplit, + NodeManager const & nodeManager ) +{ + // A1: Validate node duplication matches prediction + // Note: totalDuplicatedNodes = total NEW nodes created (not counting original nodes) + // For a node at N-fracture intersection: N new nodes are created + bool const a1Pass = ( statsAfter.numDuplicatedNodes == expected.totalDuplicatedNodes ); + GEOS_LOG_RANK_0( "Validating A1 " << ( a1Pass ? "(ok)" : "(notok)" ) + << ": Node duplication prediction (Expected: " << expected.totalDuplicatedNodes + << ", Actual: " << statsAfter.numDuplicatedNodes << ")" ); + EXPECT_EQ( statsAfter.numDuplicatedNodes, expected.totalDuplicatedNodes ) + << "Test " << testCaseName << ": Node duplication prediction MISMATCH" + << "\n Expected new nodes: " << expected.totalDuplicatedNodes + << "\n Actual new nodes: " << statsAfter.numDuplicatedNodes + << "\n Nodes before split: " << statsBefore.numNodes + << "\n Nodes after split: " << statsAfter.numNodes + << "\n Fracture node sets: " << nodeSetNames; + + // A2: Verify fracture elements were created and match the predicted count + bool const a2Pass = ( statsAfter.numFractureElements == expected.numFractureElements ); + GEOS_LOG_RANK_0( "Validating A2 " << ( a2Pass ? "(ok)" : "(notok)" ) + << ": Fracture elements created (Expected: " << expected.numFractureElements + << ", Actual: " << statsAfter.numFractureElements << ")" ); + EXPECT_EQ( statsAfter.numFractureElements, expected.numFractureElements ) + << "Test " << testCaseName << ": Fracture element count MISMATCH" + << "\n Expected fracture elements: " << expected.numFractureElements + << "\n Actual fracture elements: " << statsAfter.numFractureElements + << "\n Mesh file: " << meshFileName + << "\n Fracture node sets: " << nodeSetNames + << "\n Nodes split: " << statsAfter.numDuplicatedNodes + << "\n POSSIBLE CAUSES:" + << "\n - Node sets are empty or not found in mesh" + << "\n - Faces are not marked as separable (ruptureState/isFaceSeparable)" + << "\n - SurfaceGenerator did not run or failed silently" + << "\n - Fracture face count prediction is wrong (check preprocessFractureTopology)"; + + // A3: Validate all node coordinates are valid (not NaN) + bool a3Pass = true; + arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const nodePositions = + nodeManager.referencePosition(); + for( localIndex ni = 0; ni < nodeManager.size(); ++ni ) + { + real64 const x = nodePositions[ni][0]; + real64 const y = nodePositions[ni][1]; + real64 const z = nodePositions[ni][2]; + if( std::isnan( x ) || std::isnan( y ) || std::isnan( z ) ) + a3Pass = false; + EXPECT_FALSE( std::isnan( x ) || std::isnan( y ) || std::isnan( z ) ) + << "Test " << testCaseName << ": Node " << ni << " has invalid (NaN) coordinates" + << "\n Position: (" << x << ", " << y << ", " << z << ")" + << "\n Total nodes in mesh: " << nodeManager.size() + << "\n This indicates memory corruption or uninitialized node positions"; + } + GEOS_LOG_RANK_0( "Validating A3 " << ( a3Pass ? "(ok)" : "(notok)" ) + << ": Node coordinates validity (Total nodes: " << nodeManager.size() << ")" ); + + // A4: Validate expected Euler characteristic before split + bool const a4Pass = ( eulerCharBeforeSplit == expectedEulerBefore ); + GEOS_LOG_RANK_0( "Validating A4 " << ( a4Pass ? "(ok)" : "(notok)" ) + << ": Euler χ before split (Expected: " << expectedEulerBefore + << ", Actual: " << eulerCharBeforeSplit << ")" ); + EXPECT_EQ( eulerCharBeforeSplit, expectedEulerBefore ) + << "Test " << testCaseName << ": Euler characteristic MISMATCH before split" + << "\n Expected χ: " << expectedEulerBefore + << "\n Actual χ: " << eulerCharBeforeSplit + << "\n Mesh file: " << meshFileName + << "\n NOTE: For a conformal mesh, expected χ = 1 (single connected solid)"; + + // A5: Validate expected Euler characteristic after split + bool const a5Pass = ( eulerCharAfterSplit == expectedEulerAfter ); + GEOS_LOG_RANK_0( "Validating A5 " << ( a5Pass ? "(ok)" : "(notok)" ) + << ": Euler χ after split (Expected: " << expectedEulerAfter + << ", Actual: " << eulerCharAfterSplit << ")" ); + EXPECT_EQ( eulerCharAfterSplit, expectedEulerAfter ) + << "Test " << testCaseName << ": Euler characteristic MISMATCH after split" + << "\n Expected χ: " << expectedEulerAfter + << "\n Actual χ: " << eulerCharAfterSplit + << "\n Mesh file: " << meshFileName + << "\n Nodes duplicated: " << statsAfter.numDuplicatedNodes + << "\n Fracture elements: " << statsAfter.numFractureElements; +} + +/// @brief Parse "{ f1_node_set, f2_node_set, ... }" into individual set name strings. +std::vector< std::string > parseNodeSetNames( std::string const & nodeSetNames ) +{ + std::vector< std::string > result; + + // Remove surrounding braces and whitespace + size_t start = nodeSetNames.find( '{' ); + size_t end = nodeSetNames.find( '}' ); + + if( start == std::string::npos || end == std::string::npos ) + { + return result; + } + + std::string content = nodeSetNames.substr( start + 1, end - start - 1 ); + + // Split by comma + std::istringstream ss( content ); + std::string token; + + while( std::getline( ss, token, ',' ) ) + { + // Trim whitespace + size_t first = token.find_first_not_of( " \t\n\r" ); + size_t last = token.find_last_not_of( " \t\n\r" ); + + if( first != std::string::npos && last != std::string::npos ) + { + result.push_back( token.substr( first, last - first + 1 ) ); + } + } + + return result; +} + +/** + * @brief Compute expected node/edge/face duplication counts before the mesh split. + * + * Domain assumed to be [0,1]³. Entities on the boundary are not duplicated; interior + * and intersection entities are. Returns an @c ExpectedDuplication for validation. + */ +ExpectedDuplication preprocessFractureTopology( MeshLevel & mesh, + std::vector< std::string > const & fractureNodeSets ) +{ + ExpectedDuplication expected; + + NodeManager & nodeManager = mesh.getNodeManager(); + FaceManager & faceManager = mesh.getFaceManager(); + ElementRegionManager & elemManager = mesh.getElemManager(); + + ArrayOfArraysView< localIndex const > const faceToNodeMap = faceManager.nodeList().toViewConst(); + arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const nodePositions = + nodeManager.referencePosition(); + + // Ghost-rank views: entities with ghostRank > -1 are owned by another rank. + // We must skip them so that MpiWrapper::sum across ranks gives correct global totals + // without double-counting entities that appear on multiple ranks as ghosts. + arrayView1d< integer const > const nodeGhostRank = nodeManager.ghostRank(); + arrayView1d< integer const > const faceGhostRank = faceManager.ghostRank(); + + // Domain boundary tolerance for [0,1]³ + constexpr real64 boundaryTol = 1.0e-9; + + // Helper to check if a node is on the DOMAIN BOUNDARY (not to be duplicated) + // A node is on the boundary if ANY coordinate is at 0 or 1 + auto isNodeOnBoundary = [&]( localIndex nodeIdx ) -> bool + { + real64 const x = nodePositions[nodeIdx][0]; + real64 const y = nodePositions[nodeIdx][1]; + real64 const z = nodePositions[nodeIdx][2]; + + bool const onXBoundary = (std::abs( x ) < boundaryTol) || (std::abs( x - 1.0 ) < boundaryTol); + bool const onYBoundary = (std::abs( y ) < boundaryTol) || (std::abs( y - 1.0 ) < boundaryTol); + bool const onZBoundary = (std::abs( z ) < boundaryTol) || (std::abs( z - 1.0 ) < boundaryTol); + + return onXBoundary || onYBoundary || onZBoundary; + }; + + // Step 1: Compute bulk mesh statistics + std::set< localIndex > bulkNodes; + std::set< Edge > bulkEdges; + std::set< Facet > bulkFaces; + + elemManager.forElementSubRegions< CellElementSubRegion >( [&]( CellElementSubRegion const & subRegion ) + { + arrayView2d< localIndex const, cells::NODE_MAP_USD > const elemToNodeMap = subRegion.nodeList(); + + for( localIndex ei = 0; ei < subRegion.size(); ++ei ) + { + ++expected.numCellsInBulk; + localIndex const numNodesPerElem = elemToNodeMap.size( 1 ); + + for( localIndex ni = 0; ni < numNodesPerElem; ++ni ) + { + bulkNodes.insert( elemToNodeMap[ei][ni] ); + } + + if( numNodesPerElem == 8 ) // Hexahedron + { + // NOTE: GEOS uses ordering { 0, 1, 3, 2, 4, 5, 7, 6 } (see SiloFile.cpp:1338) + // Bottom face: 0->1->3->2, Top face: 4->5->7->6 + + // Create all 12 edges for this hexahedron + Edge edges[12] = { + Edge( elemToNodeMap[ei][0], elemToNodeMap[ei][1] ), + Edge( elemToNodeMap[ei][1], elemToNodeMap[ei][3] ), + Edge( elemToNodeMap[ei][3], elemToNodeMap[ei][2] ), + Edge( elemToNodeMap[ei][2], elemToNodeMap[ei][0] ), + Edge( elemToNodeMap[ei][4], elemToNodeMap[ei][5] ), + Edge( elemToNodeMap[ei][5], elemToNodeMap[ei][7] ), + Edge( elemToNodeMap[ei][7], elemToNodeMap[ei][6] ), + Edge( elemToNodeMap[ei][6], elemToNodeMap[ei][4] ), + Edge( elemToNodeMap[ei][0], elemToNodeMap[ei][4] ), + Edge( elemToNodeMap[ei][1], elemToNodeMap[ei][5] ), + Edge( elemToNodeMap[ei][3], elemToNodeMap[ei][7] ), + Edge( elemToNodeMap[ei][2], elemToNodeMap[ei][6] ) + }; + + // Insert each edge + for( int i = 0; i < 12; ++i ) + { + bulkEdges.insert( edges[i] ); + } + + // Create all 6 faces for this hexahedron + Facet faces[6] = { + Facet( {elemToNodeMap[ei][0], elemToNodeMap[ei][1], elemToNodeMap[ei][3], elemToNodeMap[ei][2]} ), // bottom + Facet( {elemToNodeMap[ei][4], elemToNodeMap[ei][5], elemToNodeMap[ei][7], elemToNodeMap[ei][6]} ), // top + Facet( {elemToNodeMap[ei][0], elemToNodeMap[ei][1], elemToNodeMap[ei][5], elemToNodeMap[ei][4]} ), // front + Facet( {elemToNodeMap[ei][2], elemToNodeMap[ei][3], elemToNodeMap[ei][7], elemToNodeMap[ei][6]} ), // back + Facet( {elemToNodeMap[ei][1], elemToNodeMap[ei][3], elemToNodeMap[ei][7], elemToNodeMap[ei][5]} ), // right + Facet( {elemToNodeMap[ei][0], elemToNodeMap[ei][2], elemToNodeMap[ei][6], elemToNodeMap[ei][4]} ) // left + }; + + // Insert each face + for( int i = 0; i < 6; ++i ) + { + bulkFaces.insert( faces[i] ); + } + } + else if( numNodesPerElem == 4 ) // Tetrahedron + { + // Edges (6) + bulkEdges.insert( Edge( elemToNodeMap[ei][0], elemToNodeMap[ei][1] ) ); + bulkEdges.insert( Edge( elemToNodeMap[ei][0], elemToNodeMap[ei][2] ) ); + bulkEdges.insert( Edge( elemToNodeMap[ei][0], elemToNodeMap[ei][3] ) ); + bulkEdges.insert( Edge( elemToNodeMap[ei][1], elemToNodeMap[ei][2] ) ); + bulkEdges.insert( Edge( elemToNodeMap[ei][1], elemToNodeMap[ei][3] ) ); + bulkEdges.insert( Edge( elemToNodeMap[ei][2], elemToNodeMap[ei][3] ) ); + + // Faces (4) + bulkFaces.insert( Facet( {elemToNodeMap[ei][0], elemToNodeMap[ei][1], elemToNodeMap[ei][2]} ) ); + bulkFaces.insert( Facet( {elemToNodeMap[ei][0], elemToNodeMap[ei][1], elemToNodeMap[ei][3]} ) ); + bulkFaces.insert( Facet( {elemToNodeMap[ei][0], elemToNodeMap[ei][2], elemToNodeMap[ei][3]} ) ); + bulkFaces.insert( Facet( {elemToNodeMap[ei][1], elemToNodeMap[ei][2], elemToNodeMap[ei][3]} ) ); + } + } + } ); + + expected.numNodesInBulk = bulkNodes.size(); + expected.numEdgesInBulk = bulkEdges.size(); + expected.numFacesInBulk = bulkFaces.size(); + + // Step 2: Identify fracture entities (track per-fracture for intersections) + std::set< localIndex > allFractureNodes; + std::map< localIndex, std::set< integer > > nodeToFractureIds; // Track which fractures each node belongs to + std::set< Facet > fractureFaces; + std::map< Facet, integer > facetToFractureId; // Track which fracture each face belongs to + + integer fractureId = 0; + for( std::string const & setName : fractureNodeSets ) + { + if( !nodeManager.sets().hasWrapper( setName ) ) + { + ++fractureId; + continue; + } + + std::set< localIndex > nodesInThisFracture; + SortedArrayView< localIndex const > const nodeSet = nodeManager.getSet( setName ).toViewConst(); + for( localIndex const & nodeIdx : nodeSet ) + { + // Skip ghost nodes: they are owned by another rank and would be double-counted + // when MpiWrapper::sum accumulates predictions across all ranks. + if( nodeGhostRank[nodeIdx] > -1 ) + continue; + + allFractureNodes.insert( nodeIdx ); + nodesInThisFracture.insert( nodeIdx ); + nodeToFractureIds[nodeIdx].insert( fractureId ); + } + + // Identify fracture faces for this specific fracture. + // Skip ghost faces for the same MPI double-counting reason. + for( localIndex fi = 0; fi < faceManager.size(); ++fi ) + { + if( faceGhostRank[fi] > -1 ) + continue; + + localIndex const numNodesInFace = faceToNodeMap.sizeOfArray( fi ); + bool allNodesInThisFracture = true; + + for( localIndex ni = 0; ni < numNodesInFace; ++ni ) + { + if( nodesInThisFracture.find( faceToNodeMap[fi][ni] ) == nodesInThisFracture.end() ) + { + allNodesInThisFracture = false; + break; + } + } + + if( allNodesInThisFracture && numNodesInFace >= 3 ) + { + std::vector< localIndex > faceNodes( numNodesInFace ); + for( localIndex ni = 0; ni < numNodesInFace; ++ni ) + { + faceNodes[ni] = faceToNodeMap[fi][ni]; + } + Facet facet( faceNodes.begin(), faceNodes.end() ); + fractureFaces.insert( facet ); + facetToFractureId[facet] = fractureId; + } + } + + ++fractureId; + } + + expected.numFractureNodes = allFractureNodes.size(); + expected.numFractureFaces = fractureFaces.size(); + expected.numFractureElements = fractureFaces.size(); + + // Step 3: Extract fracture edges from faces + std::map< Edge, localIndex > edgeToFaceCount; + std::set< Edge > fractureEdges; + + std::set< Facet > seenCombined; + std::map< integer, std::set< Facet > > seenPerFracture; + std::map< integer, std::map< Edge, localIndex > > perFractureEdgeCount; + + for( localIndex fi = 0; fi < faceManager.size(); ++fi ) + { + // Skip ghost faces to avoid double-counting under MPI. + if( faceGhostRank[fi] > -1 ) + continue; + + localIndex const numNodesInFace = faceToNodeMap.sizeOfArray( fi ); + bool allNodesInFracture = true; + + for( localIndex ni = 0; ni < numNodesInFace; ++ni ) + { + if( allFractureNodes.find( faceToNodeMap[fi][ni] ) == allFractureNodes.end() ) + { + allNodesInFracture = false; + break; + } + } + + if( allNodesInFracture && numNodesInFace >= 3 ) + { + std::vector< localIndex > faceNodes( numNodesInFace ); + for( localIndex ni = 0; ni < numNodesInFace; ++ni ) + faceNodes[ni] = faceToNodeMap[fi][ni]; + Facet facet( faceNodes.begin(), faceNodes.end() ); + + if( seenCombined.find( facet ) == seenCombined.end() ) + { + seenCombined.insert( facet ); + for( localIndex ni = 0; ni < numNodesInFace; ++ni ) + { + localIndex const nodeA = faceToNodeMap[fi][ni]; + localIndex const nodeB = faceToNodeMap[fi][(ni + 1) % numNodesInFace]; + Edge edge( nodeA, nodeB ); + fractureEdges.insert( edge ); + edgeToFaceCount[edge]++; + } + } + + auto const fracIt = facetToFractureId.find( facet ); + if( fracIt != facetToFractureId.end() ) + { + integer const faceFractureId = fracIt->second; + auto & seenForFrac = seenPerFracture[faceFractureId]; + if( seenForFrac.find( facet ) == seenForFrac.end() ) + { + seenForFrac.insert( facet ); + for( localIndex ni = 0; ni < numNodesInFace; ++ni ) + { + localIndex const nodeA = faceToNodeMap[fi][ni]; + localIndex const nodeB = faceToNodeMap[fi][(ni + 1) % numNodesInFace]; + Edge edge( nodeA, nodeB ); + perFractureEdgeCount[faceFractureId][edge]++; + } + } + } + } + } + + std::map< integer, std::set< localIndex > > perFractureBoundaryNodes; + for( auto const & [fid, edgeCount] : perFractureEdgeCount ) + { + for( auto const & [edge, count] : edgeCount ) + { + if( count == 1 ) + { + perFractureBoundaryNodes[fid].insert( edge.nodeA ); + perFractureBoundaryNodes[fid].insert( edge.nodeB ); + } + } + } + + std::map< localIndex, localIndex > nodeCombBndEdgeCount; + for( auto const & [edge, count] : edgeToFaceCount ) + { + if( count == 1 ) + { + nodeCombBndEdgeCount[edge.nodeA]++; + nodeCombBndEdgeCount[edge.nodeB]++; + } + } + + expected.numFractureEdges = fractureEdges.size(); + + // Step 4: Identify fracture boundary nodes + std::set< localIndex > fractureBoundaryNodes; + localIndex numBoundaryEdges = 0; + localIndex numBoundaryEdgesOnDomain = 0; + + for( auto const & [edge, count] : edgeToFaceCount ) + { + if( count == 1 ) // Edge is on fracture boundary + { + ++numBoundaryEdges; + fractureBoundaryNodes.insert( edge.nodeA ); + fractureBoundaryNodes.insert( edge.nodeB ); + + if( isNodeOnBoundary( edge.nodeA ) && isNodeOnBoundary( edge.nodeB ) ) + { + ++numBoundaryEdgesOnDomain; + } + } + } + + bool const isFullSpan = (numBoundaryEdges > 0) && (numBoundaryEdges == numBoundaryEdgesOnDomain); + + if( isFullSpan ) + { + fractureBoundaryNodes.clear(); + } + + // Step 4b: Count corner triangle faces in simplex (tet) meshes. + // + // A "corner face" is a triangular facet whose nodes ALL lie on the fracture boundary. + if( !ENABLE_CORNER_FRACTURES ) + { + localIndex numCornerFaces = 0; + for( Facet const & facet : fractureFaces ) + { + // Only triangular faces can be corner faces (simplex meshes). + if( facet.nodes.size() != 3 ) + continue; + + // Determine which fracture this face belongs to. + auto const fracIt = facetToFractureId.find( facet ); + if( fracIt == facetToFractureId.end() ) + continue; + + integer const fid = fracIt->second; + auto const bndIt = perFractureBoundaryNodes.find( fid ); + if( bndIt == perFractureBoundaryNodes.end() ) + continue; + + std::set< localIndex > const & bndNodes = bndIt->second; + + // A corner face has ALL its nodes on the per-fracture boundary. + bool allOnBoundary = true; + for( localIndex const & nd : facet.nodes ) + { + if( bndNodes.count( nd ) == 0 ) + { + allOnBoundary = false; + break; + } + } + + if( allOnBoundary ) + { + ++numCornerFaces; + } + } + + expected.numFractureElements -= numCornerFaces; + + if( ENABLE_DEBUG_PRINTS ) + { + GEOS_LOG_RANK_0( " Corner faces (triangle, all nodes on fracture boundary): " << numCornerFaces ); + GEOS_LOG_RANK_0( " Adjusted numFractureElements (after subtracting corners): " << expected.numFractureElements ); + } + } + + // Step 5: Apply duplication rules + // + // For boundary-cutting (isFullSpan=True) meshes the combined-boundary heuristic is correct: + // fractureBoundaryNodes was already cleared, so every fracture node is "internal". + // + // For non-boundary-cutting (isFullSpan=False) meshes the combined-boundary approach is WRONG + // when several fractures overlap: a node can sit on the perimeter of the *union* of all + // fracture faces (landing in fractureBoundaryNodes) while still being interior to one or + // more individual fractures. GEOS splits such a node independently for each fracture it is + // interior to, so we must use per-fracture boundary membership here. + localIndex numBoundaryNodesTouchingDomain = 0; + + for( localIndex nodeIdx : allFractureNodes ) + { + bool const isOnDomainBoundary = isNodeOnBoundary( nodeIdx ); + bool shouldDuplicate = false; + + if( isFullSpan ) + { + // Boundary-cutting path: fractureBoundaryNodes is empty so every fracture node is + // treated as "internal". We still need the domain-boundary bookkeeping. + bool const isOnFractureBoundary = (fractureBoundaryNodes.find( nodeIdx ) != fractureBoundaryNodes.end()); + if( !isOnFractureBoundary ) + { + shouldDuplicate = true; + } + else if( isOnDomainBoundary ) + { + shouldDuplicate = true; + ++numBoundaryNodesTouchingDomain; + } + } + else + { + // Non-boundary-cutting path: a node is duplicated if it is interior to at least one + // individual fracture (i.e. NOT on the per-fracture rim of every fracture it belongs to). + for( integer fid : nodeToFractureIds[nodeIdx] ) + { + auto const it = perFractureBoundaryNodes.find( fid ); + bool const isOnThisFracBnd = (it != perFractureBoundaryNodes.end()) + && (it->second.count( nodeIdx ) > 0); + if( !isOnThisFracBnd ) + { + shouldDuplicate = true; + break; + } + } + } + + if( shouldDuplicate ) + { + expected.internalNodes.insert( nodeIdx ); + } + else + { + expected.boundaryNodes.insert( nodeIdx ); + } + } + + expected.numBoundaryNodesOnDomain = numBoundaryNodesTouchingDomain; + + for( Edge const & edge : fractureEdges ) + { + bool const nodeADuplicated = (expected.internalNodes.find( edge.nodeA ) != expected.internalNodes.end()); + bool const nodeBDuplicated = (expected.internalNodes.find( edge.nodeB ) != expected.internalNodes.end()); + + if( nodeADuplicated || nodeBDuplicated ) + { + expected.internalEdges.insert( edge ); + } + else + { + expected.boundaryEdges.insert( edge ); + } + } + + // Step 6: Compute per-node duplication counts. + expected.numNodesToDuplicate = expected.internalNodes.size(); + expected.numEdgesToDuplicate = expected.internalEdges.size(); + expected.numFacesToDuplicate = expected.numFractureFaces; + + bool const isBoundaryCutting = isFullSpan; + expected.totalDuplicatedNodes = 0; + + for( localIndex nodeIdx : expected.internalNodes ) + { + auto const & fractureIds = nodeToFractureIds[nodeIdx]; + integer const numFractures = static_cast< integer >( fractureIds.size() ); + integer newNodesForThisNode; + + if( !isBoundaryCutting ) + { + // Non-boundary-cutting: GEOS splits a node once per fracture it is *interior* to. + // N fractures cutting independently through a node partition the neighbourhood into + // 2^N sectors → 2^N - 1 new nodes are required. + integer numFracturesInteriorTo = 0; + for( integer fid : fractureIds ) + { + auto const it = perFractureBoundaryNodes.find( fid ); + bool const isOnFracBnd = (it != perFractureBoundaryNodes.end()) + && (it->second.count( nodeIdx ) > 0); + if( !isOnFracBnd ) + ++numFracturesInteriorTo; + } + newNodesForThisNode = std::max( integer{1}, (1 << numFracturesInteriorTo) - 1 ); + } + else if( numFractures == 1 ) + { + // Boundary-cutting, single fracture: 1 new node per internal node. + newNodesForThisNode = 1; + } + else + { + // Boundary-cutting, multiple fractures: original intersection logic. + integer numInteriorTo = 0; + integer numBndOf = 0; + + for( integer fid : fractureIds ) + { + auto const it = perFractureBoundaryNodes.find( fid ); + bool const isOnFracBnd = (it != perFractureBoundaryNodes.end()) + && (it->second.count( nodeIdx ) > 0); + if( isOnFracBnd ) + ++numBndOf; + else + ++numInteriorTo; + } + + if( numBndOf == 0 ) + { + newNodesForThisNode = (1 << numFractures) - 1; + } + else if( numInteriorTo == 0 ) + { + auto const cntIt = nodeCombBndEdgeCount.find( nodeIdx ); + localIndex const nbnd = (cntIt != nodeCombBndEdgeCount.end()) ? cntIt->second : 0; + newNodesForThisNode = (nbnd > 0) + ? static_cast< integer >( std::max( localIndex{1}, nbnd - 1 ) ) + : static_cast< integer >( std::max( integer{1}, numFractures - 1 ) ); + } + else + { + newNodesForThisNode = numFractures; + } + } + + expected.totalDuplicatedNodes += newNodesForThisNode; + } + + expected.totalDuplicatedEdges = expected.numEdgesToDuplicate; + expected.totalDuplicatedFaces = expected.numFacesToDuplicate; + + return expected; +} + +#endif // TESTSURFACEGENERATORCOMMON_HPP diff --git a/src/coreComponents/integrationTests/meshTests/testSurfaceGenerator_mpi.cpp b/src/coreComponents/integrationTests/meshTests/testSurfaceGenerator_mpi.cpp new file mode 100644 index 00000000000..6b89ca4d741 --- /dev/null +++ b/src/coreComponents/integrationTests/meshTests/testSurfaceGenerator_mpi.cpp @@ -0,0 +1,507 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 testSurfaceGenerator_mpi.cpp + * @brief Integration tests for SurfaceGenerator topology modification (MPI parallel). + * + * Verifies node duplication, fracture element creation, and Euler characteristic (χ = V-E+F-C) + * for boundary-cutting and internal fracture configurations on hex and tet meshes, running + * with various partitioning configurations. + */ + +#include "testSurfaceGeneratorCommon.hpp" + +// Global flag to control debug printing (set to false to disable verbose output) +CommandLineOptions g_commandLineOptions; + +/// @brief Directory containing the test binary (and the copied mesh files). +/// Populated in main() from argv[0] so it is always correct regardless +/// of the build system (Makefiles, Ninja, Xcode) or how CTest sets CWD. +std::string g_testBinaryDir; + +/** + * @brief MPI variant of the SurfaceGenerator integration test. + * + * Same topology verification as SurfaceGeneratorTest, but the domain is + * distributed across 4 MPI ranks using a user-supplied partition tuple. + * + * Parametrized with + * std::tuple< std::string, // test case name + * std::string, // mesh file name + * std::string, // node-set names + * integer, // expected Euler characteristic before split + * integer, // expected Euler characteristic after split + * localIndex, // expected new nodes created (global, from serial ground truth) + * localIndex > // expected fracture elements created (global, from serial ground truth) + * + * Because ::testing::Combine is used, the actual ParamType produced by GTest is + * std::tuple< MeshTuple, PartitionTuple > + * where + * MeshTuple = std::tuple< std::string, std::string, std::string, integer, integer, localIndex, localIndex > + * PartitionTuple = std::tuple< int, int, int > + * + * The expected node/fracture-element counts are hard-coded from the verified serial run. + * Computing them from partitioned local topology (preprocessFractureTopology) is unreliable + * because fracture-boundary classification depends on global topology, not the local partition. + */ +using SurfaceGenerator_mpiMeshTuple = std::tuple< std::string, std::string, std::string, integer, integer, localIndex, localIndex >; +using SurfaceGenerator_mpiPartitionTuple = std::tuple< int, int, int >; + +class SurfaceGenerator_mpiTest + : public ::testing::TestWithParam< + std::tuple< SurfaceGenerator_mpiMeshTuple, SurfaceGenerator_mpiPartitionTuple > > +{ +protected: + void SetUp() override + { + if( !g_testBinaryDir.empty() ) + { + testBinaryDir = g_testBinaryDir; + } + else + { + char const * envDir = std::getenv( "TEST_BINARY_DIR" ); + testBinaryDir = ( envDir != nullptr && envDir[0] != '\0' ) ? envDir : TEST_BINARY_DIR; + } + } + + std::string testBinaryDir; + + /// @brief Reuse the same XML generator as the serial test. + std::string generateXmlInput( std::string const & meshFile, + std::string const & nodeSetNames ) + { + std::ostringstream oss; + oss << R"xml( + + + + + + + + + + + + + + + + + + + + + + +)xml"; + return oss.str(); + } +}; + +/** + * @brief MPI variant of TopologyValidation. + * + * Replicates every assertion from the serial SurfaceGeneratorTest::runTest(): + * A1 – node duplication count matches preprocessFractureTopology prediction + * A2 – fracture element count matches prediction + * A3 – no NaN node coordinates after split + * A4 – Euler characteristic before split equals expected value + * A5 – Euler characteristic after split equals expected value + * A6 – no degenerate elements (duplicate node references) + * + * The Euler characteristic is computed via computeEulerCharacteristic + * (manager-sizes production version from MeshGeneratorBase) both before + * and after the split. + */ +TEST_P( SurfaceGenerator_mpiTest, TopologyValidation ) +{ + auto const & params = GetParam(); + // ::testing::Combine produces std::tuple< MeshTuple, PartitionTuple > + SurfaceGenerator_mpiMeshTuple const & meshParams = std::get< 0 >( params ); + SurfaceGenerator_mpiPartitionTuple const & partitions = std::get< 1 >( params ); + + std::string const & testCaseName = std::get< 0 >( meshParams ); + std::string const & meshFileName = std::get< 1 >( meshParams ); + std::string const & nodeSetNames = std::get< 2 >( meshParams ); + integer const expectedEulerBefore = std::get< 3 >( meshParams ); + integer const expectedEulerAfter = std::get< 4 >( meshParams ); + localIndex const expectedNewNodes = std::get< 5 >( meshParams ); + localIndex const expectedFractureElems = std::get< 6 >( meshParams ); + + int const xPartitions = std::get< 0 >( partitions ); + int const yPartitions = std::get< 1 >( partitions ); + int const zPartitions = std::get< 2 >( partitions ); + + // Check if we are running with the correct number of ranks for this partitioning. + // This prevents the serial test runner (rank=1) from crashing when attempting + // to run a 4-partition test. + int const requiredRanks = xPartitions * yPartitions * zPartitions; + if( MpiWrapper::commSize( MPI_COMM_GEOS ) != requiredRanks ) + { + GTEST_SKIP() << "Skipping MPI test expecting " << requiredRanks + << " ranks (running on " << MpiWrapper::commSize( MPI_COMM_GEOS ) << ")"; + } + + std::string const xmlInput = generateXmlInput( testBinaryDir + "/" + meshFileName, nodeSetNames ); + + // Only rank 0 writes the XML; all ranks barrier before reading. + std::string const xmlPath = testBinaryDir + + "/test_surface_gen_mpi_" + testCaseName + + "_" + std::to_string( xPartitions ) + + "x" + std::to_string( yPartitions ) + + "x" + std::to_string( zPartitions ) + + ".xml"; + if( MpiWrapper::commRank( MPI_COMM_GEOS ) == 0 ) + { + std::ofstream ofs( xmlPath ); + ofs << xmlInput; + } + MpiWrapper::barrier( MPI_COMM_GEOS ); + + auto options = std::make_unique< CommandLineOptions >( g_commandLineOptions ); + options->inputFileNames.push_back( xmlPath ); + options->problemName = "test_surface_gen_mpi_" + testCaseName; + options->xPartitionsOverride = xPartitions; + options->yPartitionsOverride = yPartitions; + options->zPartitionsOverride = zPartitions; + options->overridePartitionNumbers = true; + + // Scoped state to ensure GeosxState is fully destroyed before the next + // test case constructs a new one (GeosxState is a singleton). + { + GeosxState state( std::move( options ) ); + ASSERT_TRUE( state.initializeDataRepository() ) + << "Test " << testCaseName << ": Failed to initialize data repository for '" + << meshFileName << "' with partitioning " + << xPartitions << "x" << yPartitions << "x" << zPartitions; + state.applyInitialConditions(); + + // ------------------------------------------------------------------ + // Obtain managers from the base mesh level + // ------------------------------------------------------------------ + ProblemManager & pm = state.getProblemManager(); + MeshLevel & mesh = pm.getDomainPartition().getMeshBody( 0 ).getBaseDiscretization(); + NodeManager & nodeManager = mesh.getNodeManager(); + EdgeManager & edgeManager = mesh.getEdgeManager(); + FaceManager & faceManager = mesh.getFaceManager(); + ElementRegionManager & elemManager = mesh.getElemManager(); + + // ------------------------------------------------------------------ + // Pre-split topology stats + // ------------------------------------------------------------------ + TopologyStats statsBefore; + statsBefore.numNodes = nodeManager.size(); + statsBefore.numEdges = edgeManager.size(); + statsBefore.numFaces = faceManager.size(); + statsBefore.numCells = 0; + elemManager.forElementSubRegions< CellElementSubRegion >( [&]( CellElementSubRegion const & sr ) + { + statsBefore.numCells += sr.size(); + } ); + + // Snapshot owned-node count BEFORE the split. + // getNumberOfLocalIndices() returns nodes with ghostRank <= -1 (owned by this rank). + // This is the correct baseline for computing new-owned-node delta after the split. + localIndex const ownedNodeCountBefore = nodeManager.getNumberOfLocalIndices(); + + // ------------------------------------------------------------------ + // Build expected-duplication from hard-coded serial ground truth. + // + // preprocessFractureTopology is unreliable for partitioned meshes because + // fracture-boundary classification depends on the *global* fracture topology + // (which edges are on the fracture tip). On a local partition each rank only + // sees a subset of the fracture; tip edges shared with a ghost face look + // interior (count == 2) instead of boundary (count == 1), causing tip nodes + // to be mis-classified as interior nodes and over-counting new nodes. + // + // The only reliable source for the global expected counts is the verified + // serial run, so they are baked into the test tuple parameters. + // ------------------------------------------------------------------ + ExpectedDuplication expected; + expected.totalDuplicatedNodes = expectedNewNodes; + expected.numFractureElements = expectedFractureElems; + + GEOS_LOG_RANK_0( "========================================" ); + GEOS_LOG_RANK_0( "Test (MPI): " << testCaseName + << " [" << xPartitions << "x" << yPartitions << "x" << zPartitions << "]" ); + GEOS_LOG_RANK_0( "Expected duplication (from serial ground truth):" ); + GEOS_LOG_RANK_0( " New nodes: " << expected.totalDuplicatedNodes ); + GEOS_LOG_RANK_0( " Fracture elements: " << expected.numFractureElements ); + + // ------------------------------------------------------------------ + // Euler characteristic BEFORE split + // ------------------------------------------------------------------ + integer const eulerCharBeforeSplit = + computeEulerCharacteristic( nodeManager, edgeManager, faceManager, elemManager ); + GEOS_LOG_RANK_0( " Euler χ before split: " << eulerCharBeforeSplit ); + + statsBefore.eulerCharacteristic = eulerCharBeforeSplit; + + // ------------------------------------------------------------------ + // Run SurfaceGenerator (the split) + // ------------------------------------------------------------------ + state.run(); + + // Synchronize all ranks before reading post-split topology. + // In Release builds, MPI message delivery is faster and without this + // barrier rank 0 may observe stale ghost-rank state on managers that + // are still being updated on other ranks. + MpiWrapper::barrier( MPI_COMM_GEOS ); + + // ------------------------------------------------------------------ + // Post-split topology stats + // ------------------------------------------------------------------ + TopologyStats statsAfter; + statsAfter.numNodes = nodeManager.size(); + statsAfter.numEdges = edgeManager.size(); + statsAfter.numFaces = faceManager.size(); + statsAfter.numCells = 0; + statsAfter.numFractureElements = 0; + + elemManager.forElementSubRegions< CellElementSubRegion >( [&]( CellElementSubRegion const & sr ) + { + statsAfter.numCells += sr.size(); + } ); + elemManager.forElementSubRegions< FaceElementSubRegion >( [&]( FaceElementSubRegion const & sr ) + { + // Use getNumberOfLocalIndices() instead of size() to count only owned + // fracture elements (ghostRank <= -1). Summing sr.size() across ranks + // would double-count ghost copies that appear on multiple ranks. + statsAfter.numFractureElements += sr.getNumberOfLocalIndices(); + } ); + + // ------------------------------------------------------------------ + // Count only OWNED new nodes (ghostRank <= -1) to avoid double-counting + // ghost copies that appear on multiple ranks after the split. + // ownedNodeCountBefore was snapshotted before state.run() so no + // ghost-count assumptions are needed. + // ------------------------------------------------------------------ + localIndex const ownedNodesAfter = nodeManager.getNumberOfLocalIndices(); + localIndex const localOwnedNewNodes = ownedNodesAfter - ownedNodeCountBefore; + + statsAfter.numDuplicatedNodes = localOwnedNewNodes; + + integer const eulerCharAfterSplit = + computeEulerCharacteristic( nodeManager, edgeManager, faceManager, elemManager ); + GEOS_LOG_RANK_0( " Euler χ after split: " << eulerCharAfterSplit ); + + statsAfter.eulerCharacteristic = eulerCharAfterSplit; + + // ------------------------------------------------------------------ + // Reduce actual counts to global totals. + // + // • localOwnedNewNodes — each node is owned by exactly one rank, so + // MPI_SUM gives the true global new-node count with no double-counting. + // • statsAfter.numFractureElements — each face element is owned by one rank; SUM is safe. + // • expected values are global constants from the serial ground truth; no reduction needed. + // ------------------------------------------------------------------ + localIndex const globalActualNewNodes = + MpiWrapper::sum( localOwnedNewNodes, MPI_COMM_GEOS ); + localIndex const globalPredictedNewNodes = expected.totalDuplicatedNodes; + localIndex const globalFractureElements = + MpiWrapper::sum( statsAfter.numFractureElements, MPI_COMM_GEOS ); + localIndex const globalPredictedFractureElements = expected.numFractureElements; + localIndex const globalNodesBefore = + MpiWrapper::sum( ownedNodeCountBefore, MPI_COMM_GEOS ); + + GEOS_LOG_RANK_0( "Actual duplication (global):" ); + GEOS_LOG_RANK_0( " New nodes created: " << globalActualNewNodes ); + GEOS_LOG_RANK_0( " Fracture elements: " << globalFractureElements ); + GEOS_LOG_RANK_0( "========================================" ); + + // ------------------------------------------------------------------ + // All GTest assertions MUST fire on rank 0 only. + // Running EXPECT_EQ on every rank produces N identical failure messages + // and confuses the test runner into thinking there are N failures. + // ------------------------------------------------------------------ + if( MpiWrapper::commRank( MPI_COMM_GEOS ) == 0 ) + { + // Build globally-reduced structs for the shared validation helper. + TopologyStats globalStatsBefore = statsBefore; + globalStatsBefore.numNodes = globalNodesBefore; + + TopologyStats globalStatsAfter = statsAfter; + globalStatsAfter.numDuplicatedNodes = globalActualNewNodes; + globalStatsAfter.numFractureElements = globalFractureElements; + globalStatsAfter.numNodes = globalNodesBefore + globalActualNewNodes; + + ExpectedDuplication globalExpected = expected; + globalExpected.totalDuplicatedNodes = globalPredictedNewNodes; + globalExpected.numFractureElements = globalPredictedFractureElements; + + validateSurfaceGeneratorResults( testCaseName, + meshFileName, + nodeSetNames, + globalStatsBefore, + globalStatsAfter, + globalExpected, + expectedEulerBefore, + eulerCharBeforeSplit, + expectedEulerAfter, + eulerCharAfterSplit, + nodeManager ); + } + + } // end scoped GeosxState + + // Cleanup XML after state is destroyed + if( MpiWrapper::commRank( MPI_COMM_GEOS ) == 0 ) + { + std::remove( xmlPath.c_str() ); + } +} + +// --------------------------------------------------------------------------- +// MPI test instantiation +// +// All 6 unique partitions of 4 ranks (product x*y*z == 4): +// (1,1,4) (1,4,1) (4,1,1) (1,2,2) (2,1,2) (2,2,1) +// +// Meshes: the 4 new junction topologies that exercise the most demanding +// splitting paths (T-junction and Y-junction, hex and tet). +// +// Meshes: every multi-fracture (_DFN_123) configuration from the serial suite +// plus the T-junction and Y-junction topologies. +// Expected node/element counts are serial ground truth (all tests pass serially). +// --------------------------------------------------------------------------- +// clang-format off +INSTANTIATE_TEST_SUITE_P( + SurfaceGenerator_mpiCases, + SurfaceGenerator_mpiTest, + ::testing::Combine( + ::testing::Values( + // ----------------------------------------------------------------------- + // flat · no-boundary-cut · hex · DFN_123 nodes: 7 elems: 12 + std::make_tuple( "Mkt_NoBndCut_hex_DFN_123", + "fractured_mesh_hex_DFN_123.vtu", + "{ f1_node_set, f2_node_set, f3_node_set }", + 1, 2, localIndex( 7 ), localIndex( 12 ) ), + // flat · no-boundary-cut · tet · DFN_123 nodes: 19 elems: 48 + std::make_tuple( "Mkt_NoBndCut_tet_DFN_123", + "fractured_mesh_tet_DFN_123.vtu", + "{ f1_node_set, f2_node_set, f3_node_set }", + 1, 2, localIndex( 19 ), localIndex( 48 ) ), + // ----------------------------------------------------------------------- + // flat · full-span · hex · DFN_123 nodes: 37 elems: 12 + std::make_tuple( "Mkt_BndCut_hex_DFN_123", + "fractured_full_span_mesh_hex_DFN_123.vtu", + "{ f1_node_set, f2_node_set, f3_node_set }", + 1, 8, localIndex( 37 ), localIndex( 12 ) ), + // flat · full-span · tet · DFN_123 nodes: 127 elems: 168 + std::make_tuple( "Mkt_BndCut_tet_DFN_123", + "fractured_full_span_mesh_tet_DFN_123.vtu", + "{ f1_node_set, f2_node_set, f3_node_set }", + 1, 8, localIndex( 127 ), localIndex( 168 ) ), + // ----------------------------------------------------------------------- + // wavy · no-boundary-cut · hex · DFN_123 nodes: 7 elems: 12 + std::make_tuple( "Mkt_WavyNoBndCut_hex_DFN_123", + "fractured_wavy_mesh_hex_DFN_123.vtu", + "{ f1_node_set, f2_node_set, f3_node_set }", + 1, 2, localIndex( 7 ), localIndex( 12 ) ), + // wavy · no-boundary-cut · tet · DFN_123 nodes: 19 elems: 48 + std::make_tuple( "Mkt_WavyNoBndCut_tet_DFN_123", + "fractured_wavy_mesh_tet_DFN_123.vtu", + "{ f1_node_set, f2_node_set, f3_node_set }", + 1, 2, localIndex( 19 ), localIndex( 48 ) ), + // ----------------------------------------------------------------------- + // wavy · full-span · hex · DFN_123 nodes: 37 elems: 12 + std::make_tuple( "Mkt_WavyBndCut_hex_DFN_123", + "fractured_wavy_full_span_mesh_hex_DFN_123.vtu", + "{ f1_node_set, f2_node_set, f3_node_set }", + 1, 8, localIndex( 37 ), localIndex( 12 ) ), + // wavy · full-span · tet · DFN_123 nodes: 127 elems: 168 + std::make_tuple( "Mkt_WavyBndCut_tet_DFN_123", + "fractured_wavy_full_span_mesh_tet_DFN_123.vtu", + "{ f1_node_set, f2_node_set, f3_node_set }", + 1, 8, localIndex( 127 ), localIndex( 168 ) ), + // ----------------------------------------------------------------------- + // T-shaped · boundary-cutting · hex nodes: 15 elems: 6 + std::make_tuple( "Mkt_BndCut_t_shaped_hex_DFN_12", + "t_shaped_wavy_mesh_hex_DFN_t1t2.vtu", + "{ f1_node_set, f2_node_set }", + 1, 3, localIndex( 15 ), localIndex( 6 ) ), + // T-shaped · boundary-cutting · tet nodes: 49 elems: 66 + std::make_tuple( "Mkt_BndCut_t_shaped_tet_DFN_12", + "t_shaped_wavy_mesh_tet_DFN_t1t2.vtu", + "{ f1_node_set, f2_node_set }", + 1, 3, localIndex( 49 ), localIndex( 66 ) ), + // ----------------------------------------------------------------------- + // Y-shaped · boundary-cutting · hex nodes: 15 elems: 6 + std::make_tuple( "Mkt_BndCut_Y_shaped_hex_DFN_123", + "y_shaped_wavy_mesh_hex_DFN_y1y2y3.vtu", + "{ f1_node_set, f2_node_set, f3_node_set }", + 1, 3, localIndex( 15 ), localIndex( 6 ) ), + // Y-shaped · boundary-cutting · tet nodes: 49 elems: 66 + std::make_tuple( "Mkt_BndCut_Y_shaped_tet_DFN_123", + "y_shaped_wavy_mesh_tet_DFN_y1y2y3.vtu", + "{ f1_node_set, f2_node_set, f3_node_set }", + 1, 3, localIndex( 49 ), localIndex( 66 ) ), + + // Miscellaneous · no-boundary-cutting · hex nodes: 180 elems: 196 + std::make_tuple( "Mkt_NoBndCut_5_fracs_hex_DFN", + "DFN_5_fractures_hex_binarized.vtu", + "{ f1_node_set, f2_node_set, f3_node_set, f4_node_set, f5_node_set }", + 1, 2, localIndex( 180 ), localIndex( 196 ) ), + + // Miscellaneous · no-boundary-cutting · tet nodes: 180 elems: 392 (minus 10 corner triangles) + std::make_tuple( "Mkt_NoBndCut_5_fracs_tet_DFN", + "DFN_5_fractures_tet_binarized.vtu", + "{ f1_node_set, f2_node_set, f3_node_set, f4_node_set, f5_node_set }", + 1, 2, localIndex( 180 ), localIndex( 382 ) ) + + ), + ::testing::Values( + std::make_tuple( 1, 1, 4 ), + std::make_tuple( 1, 4, 1 ), + std::make_tuple( 4, 1, 1 ), + std::make_tuple( 1, 2, 2 ), + std::make_tuple( 2, 1, 2 ), + std::make_tuple( 2, 2, 1 ) + ) + ) + ); + + +int main( int argc, char * argv[] ) +{ + // Derive the directory containing this executable from argv[0]. + // dirname() modifies its argument, so work on a copy. + // This is the most reliable way to find co-located mesh files regardless + // of what CWD CTest or the shell has set. + if( argc > 0 && argv[0] != nullptr ) + { + std::vector< char > exePath( argv[0], argv[0] + std::strlen( argv[0] ) + 1 ); + g_testBinaryDir = ::dirname( exePath.data() ); + } + + ::testing::InitGoogleTest( &argc, argv ); + g_commandLineOptions = *geos::basicSetup( argc, argv, false ); + int result = RUN_ALL_TESTS(); + geos::basicCleanup(); + return result; +} diff --git a/src/coreComponents/linearAlgebra/DofManagerHelpers.hpp b/src/coreComponents/linearAlgebra/DofManagerHelpers.hpp index 4956bd6abb5..ac78bc7bd6e 100644 --- a/src/coreComponents/linearAlgebra/DofManagerHelpers.hpp +++ b/src/coreComponents/linearAlgebra/DofManagerHelpers.hpp @@ -295,7 +295,8 @@ struct MeshVisitor< LOC, LOC, VISIT_GHOSTS > for( localIndex a = 0; a < locList.size(); ++a ) { localIndex const locIdx = locList[a]; - if( VISIT_GHOSTS || ghostRank[locIdx] < 0 ) + // Skip invalid indices + if( locIdx >= 0 && ( VISIT_GHOSTS || ghostRank[locIdx] < 0 ) ) { RAJA::atomicInc< parallelHostAtomic >( &visited[locIdx] ); } diff --git a/src/coreComponents/linearAlgebra/interfaces/petsc/PetscMatrix.cpp b/src/coreComponents/linearAlgebra/interfaces/petsc/PetscMatrix.cpp index 32fa3d1a7f7..94aa824bfc0 100644 --- a/src/coreComponents/linearAlgebra/interfaces/petsc/PetscMatrix.cpp +++ b/src/coreComponents/linearAlgebra/interfaces/petsc/PetscMatrix.cpp @@ -706,8 +706,18 @@ void PetscMatrix::computeScalingVector( PetscVector & scaling ) const // Compute the scaling weights for( integer c = 0; c < numComp; ++c ) { - // TODO: consider digit truncation like hypre does - weights[c] = LvArray::math::sqrt( LvArray::math::invSqrt( weights[c] ) ); + // Guard against zero or very small weights to avoid floating point errors + // If a component has zero weight, it means no contribution to the matrix, + // so we set scaling to 1.0 (no scaling) + if( weights[c] > std::numeric_limits< real64 >::epsilon() ) + { + // TODO: consider digit truncation like hypre does + weights[c] = LvArray::math::sqrt( LvArray::math::invSqrt( weights[c] ) ); + } + else + { + weights[c] = 1.0; + } } // Populate the scaling vector diff --git a/src/coreComponents/linearAlgebra/interfaces/trilinos/EpetraMatrix.cpp b/src/coreComponents/linearAlgebra/interfaces/trilinos/EpetraMatrix.cpp index d6f5ddfffb0..6b71ce09d8f 100644 --- a/src/coreComponents/linearAlgebra/interfaces/trilinos/EpetraMatrix.cpp +++ b/src/coreComponents/linearAlgebra/interfaces/trilinos/EpetraMatrix.cpp @@ -581,8 +581,18 @@ void EpetraMatrix::computeScalingVector( EpetraVector & scaling ) const // Compute the scaling weights for( integer c = 0; c < numComp; ++c ) { - // TODO: consider digit truncation like hypre does - weights[c] = LvArray::math::sqrt( LvArray::math::invSqrt( weights[c] ) ); + // Guard against zero or very small weights to avoid floating point errors + // If a component has zero weight, it means no contribution to the matrix, + // so we set scaling to 1.0 (no scaling) + if( weights[c] > std::numeric_limits< real64 >::epsilon() ) + { + // TODO: consider digit truncation like hypre does + weights[c] = LvArray::math::sqrt( LvArray::math::invSqrt( weights[c] ) ); + } + else + { + weights[c] = 1.0; + } } // Populate the scaling vector diff --git a/src/coreComponents/mainInterface/ProblemManager.cpp b/src/coreComponents/mainInterface/ProblemManager.cpp index 3c2718b1955..29c0c055217 100644 --- a/src/coreComponents/mainInterface/ProblemManager.cpp +++ b/src/coreComponents/mainInterface/ProblemManager.cpp @@ -44,6 +44,7 @@ #include "mesh/DomainPartition.hpp" #include "mesh/MeshBody.hpp" #include "mesh/MeshManager.hpp" +#include "mesh/generators/MeshGeneratorBase.hpp" #include "mesh/simpleGeometricObjects/GeometricObjectManager.hpp" #include "mesh/mpiCommunications/CommunicationTools.hpp" #include "mesh/mpiCommunications/SpatialPartition.hpp" @@ -631,6 +632,7 @@ void ProblemManager::generateMesh() ElementRegionManager & elemManager = baseMesh.getElemManager(); elemManager.generateWells( cellBlockManager, baseMesh ); + } } ); @@ -695,6 +697,33 @@ void ProblemManager::generateMesh() domain.setupCommunications( useNonblockingMPI ); domain.outputPartitionInformation(); + // Optionally validate the Euler-Poincaré characteristic χ = V − E + F − C. + // This must run AFTER setupCommunications() so that ghost cells and proper + // node ghost ranks are available. The computation reconstructs V, E, F from + // cell-to-node maps (iterating owned + ghost cells) and uses a min-global- + // node ownership rule for MPI de-duplication. + domain.forMeshBodies( [&]( MeshBody & meshBody ) + { + MeshGeneratorBase const * const meshGen = + meshManager.getGroupPointer< MeshGeneratorBase >( meshBody.getName() ); + if( meshGen != nullptr && meshGen->m_checkEulerCharacteristic ) + { + MeshLevel & baseMesh = meshBody.getBaseDiscretization(); + integer const chi = computeEulerCharacteristic( baseMesh.getNodeManager(), + baseMesh.getEdgeManager(), + baseMesh.getFaceManager(), + baseMesh.getElemManager() ); + GEOS_LOG_RANK_0_IF( chi != 1, + "Mesh \"" << meshBody.getName() << "\": Euler-Poincaré characteristic " + "χ = V − E + F − C = " << chi << " (expected 1 for a single connected " + "solid without interior voids). The mesh may contain multiple disconnected " + "bodies, interior voids, or non-manifold topology. " + "The simulation will proceed." ); + GEOS_LOG_RANK_0_IF( chi == 1, + "Mesh \"" << meshBody.getName() << "\": Euler characteristic χ = 1 ✓" ); + } + } ); + domain.forMeshBodies( [&]( MeshBody & meshBody ) { if( meshBody.hasGroup( keys::particleManager ) ) @@ -727,6 +756,10 @@ void ProblemManager::generateMesh() // 3. We flip the face normals of faces adjacent to the faceElements if they are not pointing in the // direction of the fracture. subRegion.fixNeighboringFacesNormals( faceManager, elementManager ); + + // faceToNodes(kf0, a) and faceToNodes(kf1, a) are geometrically paired (collocated) nodes. + // This is required by the conforming contact kernels which assume this pairing. + subRegion.orderKf1NodesConsistentlyWithKf0( faceManager, nodeManager ); } ); faceManager.setIsExternal(); diff --git a/src/coreComponents/mesh/EdgeManager.cpp b/src/coreComponents/mesh/EdgeManager.cpp index ed3341b2235..c84c8810e95 100644 --- a/src/coreComponents/mesh/EdgeManager.cpp +++ b/src/coreComponents/mesh/EdgeManager.cpp @@ -48,9 +48,21 @@ EdgeManager::EdgeManager( string const & name, viewKeyStruct::elementListString() } ); } + +void EdgeManager::reserve( localIndex const newSize ) +{ + GEOS_MARK_FUNCTION; + ObjectManagerBase::reserve( newSize ); + m_toFacesRelation.reserveValues( newSize * 2 * faceMapOverallocation() ); +} + + void EdgeManager::resize( localIndex const newSize ) { + GEOS_MARK_FUNCTION; + GEOS_MARK_BEGIN( "m_toFacesRelation.resize" ); m_toFacesRelation.resize( newSize, 2 * faceMapOverallocation() ); + GEOS_MARK_END( "m_toFacesRelation.resize" ); ObjectManagerBase::resize( newSize ); } @@ -241,9 +253,10 @@ localIndex EdgeManager::packUpDownMapsImpl( buffer_unit_type * & buffer, localIndex EdgeManager::unpackUpDownMaps( buffer_unit_type const * & buffer, localIndex_array & packList, bool const overwriteUpMaps, - bool const GEOS_UNUSED_PARAM( overwriteDownMaps ) ) + bool const overwriteDownMaps ) { GEOS_MARK_FUNCTION; + GEOS_UNUSED_VAR( overwriteDownMaps ); localIndex unPackedSize = 0; @@ -271,7 +284,6 @@ localIndex EdgeManager::unpackUpDownMaps( buffer_unit_type const * & buffer, overwriteUpMaps ); GEOS_ERROR_IF_NE( m_unmappedGlobalIndicesInToNodes.size(), 0 ); -// GEOS_ERROR_IF_NE( m_unmappedGlobalIndicesInToFaces.size(), 0 ); return unPackedSize; } diff --git a/src/coreComponents/mesh/EdgeManager.hpp b/src/coreComponents/mesh/EdgeManager.hpp index f955b9dd83e..447845969c4 100644 --- a/src/coreComponents/mesh/EdgeManager.hpp +++ b/src/coreComponents/mesh/EdgeManager.hpp @@ -94,6 +94,14 @@ class EdgeManager : public ObjectManagerBase ///@} + /** + * @brief Reserve the EdgeManager object and all it members. + * @details the size of the EdgeMananager is the number of edges + * in the domain. + * @param[in] newSize the new number of edges. + */ + virtual void reserve( localIndex const newSize ) override; + /** * @brief Resize the EdgeManager object and all it members. * @details the size of the EdgeMananager is the number of edges diff --git a/src/coreComponents/mesh/FaceElementSubRegion.cpp b/src/coreComponents/mesh/FaceElementSubRegion.cpp index 7ceff7e5f78..53cd06dfcaa 100644 --- a/src/coreComponents/mesh/FaceElementSubRegion.cpp +++ b/src/coreComponents/mesh/FaceElementSubRegion.cpp @@ -1212,24 +1212,44 @@ void FaceElementSubRegion::fixNeighboringFacesNormals( FaceManager & faceManager localIndex const esr1 = faceToElementSubRegionIndex[f1][0]; localIndex const ek1 = faceToElementIndex[f1][0]; - real64 f0e0vector[3] = LVARRAY_TENSOROPS_INIT_LOCAL_3( faceCenter[f0] ); - real64 f1e1vector[3] = LVARRAY_TENSOROPS_INIT_LOCAL_3( faceCenter[f1] ); + // Use element centers to orient each face normal outward (toward the fracture) + // only when valid element mappings are available. + // Ghost elements in MPI surface-generator workflows may have -1 indices. + if( er0 >= 0 && esr0 >= 0 && ek0 >= 0 && + er1 >= 0 && esr1 >= 0 && ek1 >= 0 ) + { + real64 f0e0vector[3] = LVARRAY_TENSOROPS_INIT_LOCAL_3( faceCenter[f0] ); + LvArray::tensorOps::subtract< 3 >( f0e0vector, elemCenter[er0][esr0][ek0] ); + + // Step 1: correct f0 so its normal points outward from its neighboring 3D element + // (i.e. towards the fracture). The vector faceCenter - elemCenter should be + // anti-parallel to the outward normal, so if the dot product is positive the + // normal is already pointing inward and must be flipped. + if( LvArray::tensorOps::AiBi< 3 >( faceNormal[f0], f0e0vector ) < 0.0 ) + { + LvArray::tensorOps::scale< 3 >( faceNormal[f0], -1.0 ); + std::reverse( faceToNodes[f0].begin(), faceToNodes[f0].end() ); + } - LvArray::tensorOps::subtract< 3 >( f0e0vector, elemCenter[er0][esr0][ek0] ); - LvArray::tensorOps::subtract< 3 >( f1e1vector, elemCenter[er1][esr1][ek1] ); + real64 f1e1vector[3] = LVARRAY_TENSOROPS_INIT_LOCAL_3( faceCenter[f1] ); + LvArray::tensorOps::subtract< 3 >( f1e1vector, elemCenter[er1][esr1][ek1] ); - // If the vector connecting the face center and the elem center is in the same - // direction as the unit normal, we flip the normal coz it should be pointing outward - // (i.e., towards the fracture element). - if( LvArray::tensorOps::AiBi< 3 >( faceNormal[f0], f0e0vector ) < 0.0 ) - { - GEOS_WARNING( GEOS_FMT( "For fracture element {}, I had to flip the normal nf0 of face {}", kfe, f0 ), getDataContext() ); - LvArray::tensorOps::scale< 3 >( faceNormal[f0], -1.0 ); - std::reverse( faceToNodes[f0].begin(), faceToNodes[f0].end() ); + // Step 2: correct f1 so its normal points outward from its neighboring 3D element + // (i.e. towards the fracture). The vector faceCenter - elemCenter should be + // anti-parallel to the outward normal, so if the dot product is positive the + // normal is already pointing inward and must be flipped. + if( LvArray::tensorOps::AiBi< 3 >( faceNormal[f1], f1e1vector ) < 0.0 ) + { + LvArray::tensorOps::scale< 3 >( faceNormal[f1], -1.0 ); + std::reverse( faceToNodes[f1].begin(), faceToNodes[f1].end() ); + } } - if( LvArray::tensorOps::AiBi< 3 >( faceNormal[f1], f1e1vector ) < 0.0 ) + + // Enforce the anti-parallel invariant: faceNormal[f0] and faceNormal[f1] + // must point in opposite directions so that + // Nbar = faceNormal[f0] - faceNormal[f1] is non-zero. + if( LvArray::tensorOps::AiBi< 3 >( faceNormal[f0], faceNormal[f1] ) > 0.0 ) { - GEOS_WARNING( GEOS_FMT( "For fracture element {}, I had to flip the normal nf1 of face {}", kfe, f1 ), getDataContext() ); LvArray::tensorOps::scale< 3 >( faceNormal[f1], -1.0 ); std::reverse( faceToNodes[f1].begin(), faceToNodes[f1].end() ); } @@ -1238,4 +1258,90 @@ void FaceElementSubRegion::fixNeighboringFacesNormals( FaceManager & faceManager } +void FaceElementSubRegion::orderKf1NodesConsistentlyWithKf0( FaceManager & faceManager, + NodeManager const & nodeManager ) +{ + arrayView2d< localIndex const > const elems2dToFaces = faceList().toViewConst(); + FaceManager::NodeMapType & faceToNodes = faceManager.nodeList(); + arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const X = nodeManager.referencePosition(); + + forAll< parallelHostPolicy >( this->size(), [=, &faceToNodes]( localIndex const kfe ) + { + localIndex const kf0 = elems2dToFaces[kfe][0]; + localIndex const kf1 = elems2dToFaces[kfe][1]; + + if( kf0 == -1 || kf1 == -1 ) + return; + + localIndex const numNodes0 = faceToNodes.sizeOfArray( kf0 ); + localIndex const numNodes1 = faceToNodes.sizeOfArray( kf1 ); + + if( numNodes0 != numNodes1 || numNodes0 < 3 ) + return; + + // Triangle faces (3 nodes) don't need reordering because the linear shape + // functions on triangles yield identical nodal integrals (area/3) regardless + // of which vertex is at which position. Only quadrilateral (and higher) + // faces have bilinear shape functions sensitive to the node-to-parent-coordinate + // assignment, so we restrict the fix to faces with 4+ nodes. + if( numNodes0 < 4 ) + return; + + // For each node in kf0, find the closest node in kf1 and build a reordering. + // After mesh splitting, collocated nodes are at (nearly) identical positions. + localIndex const numNodes = numNodes0; + constexpr localIndex MAX_FACE_NODES = 8; + localIndex reorderedKf1[MAX_FACE_NODES]; + bool matched[MAX_FACE_NODES]; + + for( localIndex i = 0; i < numNodes; ++i ) + { + matched[i] = false; + } + + for( localIndex a = 0; a < numNodes; ++a ) + { + localIndex const n0 = faceToNodes( kf0, a ); + real64 const x0 = X[n0][0]; + real64 const y0 = X[n0][1]; + real64 const z0 = X[n0][2]; + + real64 bestDist = LvArray::NumericLimits< real64 >::max; + localIndex bestB = -1; + + for( localIndex b = 0; b < numNodes; ++b ) + { + if( matched[b] ) + continue; + + localIndex const n1 = faceToNodes( kf1, b ); + real64 const dx = X[n1][0] - x0; + real64 const dy = X[n1][1] - y0; + real64 const dz = X[n1][2] - z0; + real64 const dist = dx * dx + dy * dy + dz * dz; + + if( dist < bestDist ) + { + bestDist = dist; + bestB = b; + } + } + + GEOS_ERROR_IF( bestB == -1, + GEOS_FMT( "FaceElementSubRegion::orderKf1NodesConsistentlyWithKf0: " + "Could not find matching kf1 node for kf0 node {} of face element {}.", + a, kfe ) ); + + reorderedKf1[a] = faceToNodes( kf1, bestB ); + matched[bestB] = true; + } + + // Apply the reordering to kf1's node list + for( localIndex a = 0; a < numNodes; ++a ) + { + faceToNodes( kf1, a ) = reorderedKf1[a]; + } + } ); +} + } /* namespace geos */ diff --git a/src/coreComponents/mesh/FaceElementSubRegion.hpp b/src/coreComponents/mesh/FaceElementSubRegion.hpp index 5455a32e979..e12c30e290d 100644 --- a/src/coreComponents/mesh/FaceElementSubRegion.hpp +++ b/src/coreComponents/mesh/FaceElementSubRegion.hpp @@ -196,6 +196,18 @@ class FaceElementSubRegion : public SurfaceElementSubRegion void flipFaceMap( FaceManager & faceManager, ElementRegionManager const & elemManager ); + /** + * @brief Reorder the node list of the second face (kf1) of each fracture element so that + * its nodes are paired with the corresponding collocated nodes of the first face (kf0). + * @param faceManager The face manager group + * @param nodeManager The node manager group + * @details After splitting, kf0 and kf1 have opposite winding. + * The contact kernels assume node a of kf0 and kf1 are paired. + * This function reorders kf1 to match kf0 based on reference coordinates. + */ + void orderKf1NodesConsistentlyWithKf0( FaceManager & faceManager, + NodeManager const & nodeManager ); + /** * @brief Struct containing the keys to all face element views. * @struct viewKeyStruct diff --git a/src/coreComponents/mesh/FaceManager.cpp b/src/coreComponents/mesh/FaceManager.cpp index a0045ec9b7f..5e21be7fe14 100644 --- a/src/coreComponents/mesh/FaceManager.cpp +++ b/src/coreComponents/mesh/FaceManager.cpp @@ -69,8 +69,18 @@ FaceManager::FaceManager( string const & name, Group * const parent ): } + +void FaceManager::reserve( localIndex const newSize ) +{ + GEOS_MARK_FUNCTION; + ObjectManagerBase::reserve( newSize ); + m_toNodesRelation.reserveValues( newSize * 2 * nodeMapOverallocation() ); + m_toEdgesRelation.reserveValues( newSize * 2 * edgeMapOverallocation() ); +} + void FaceManager::resize( localIndex const newSize ) { + GEOS_MARK_FUNCTION; m_toNodesRelation.resize( newSize, 2 * nodeMapOverallocation() ); m_toEdgesRelation.resize( newSize, 2 * edgeMapOverallocation() ); ObjectManagerBase::resize( newSize ); diff --git a/src/coreComponents/mesh/FaceManager.hpp b/src/coreComponents/mesh/FaceManager.hpp index 97fc8187671..4df022f6dbd 100644 --- a/src/coreComponents/mesh/FaceManager.hpp +++ b/src/coreComponents/mesh/FaceManager.hpp @@ -105,6 +105,13 @@ class FaceManager : public ObjectManagerBase ///@} + /** + * @brief Extend base class reserve method reserving m_toNodesRelation, m_toEdgesRelation member containers. + * @details the \p newSize of this FaceManager is the number of faces it will contain + * @param[in] newSize new size the FaceManager. + */ + virtual void reserve( localIndex const newSize ) override; + /** * @brief Extend base class resize method resizing m_toNodesRelation, m_toEdgesRelation member containers. * @details the \p newSize of this FaceManager is the number of faces it will contain diff --git a/src/coreComponents/mesh/NodeManager.cpp b/src/coreComponents/mesh/NodeManager.cpp index 2454f375e53..4bc8db73f64 100644 --- a/src/coreComponents/mesh/NodeManager.cpp +++ b/src/coreComponents/mesh/NodeManager.cpp @@ -59,8 +59,28 @@ NodeManager::NodeManager( string const & name, } +void NodeManager::reserve( localIndex const newSize ) +{ + m_toFacesRelation.reserve( newSize ); + m_toFacesRelation.reserveValues( newSize * 2 * getFaceMapOverallocation() ); + + m_toEdgesRelation.reserve( newSize ); + m_toEdgesRelation.reserveValues( newSize * 2 * getEdgeMapOverallocation() ); + + m_toElements.m_toElementRegion.reserve( newSize ); + m_toElements.m_toElementRegion.reserveValues( newSize * 2 * getElemMapOverAllocation() ); + + m_toElements.m_toElementSubRegion.reserve( newSize ); + m_toElements.m_toElementSubRegion.reserveValues( newSize * 2 * getElemMapOverAllocation() ); + + m_toElements.m_toElementIndex.reserve( newSize ); + m_toElements.m_toElementIndex.reserveValues( newSize * 2 * getElemMapOverAllocation() ); + ObjectManagerBase::reserve( newSize ); +} + void NodeManager::resize( localIndex const newSize ) { + GEOS_MARK_FUNCTION; m_toFacesRelation.resize( newSize, 2 * getFaceMapOverallocation() ); m_toEdgesRelation.resize( newSize, 2 * getEdgeMapOverallocation() ); m_toElements.m_toElementRegion.resize( newSize, 2 * getElemMapOverAllocation() ); diff --git a/src/coreComponents/mesh/NodeManager.hpp b/src/coreComponents/mesh/NodeManager.hpp index 4cc3b6fdd94..29820500e14 100644 --- a/src/coreComponents/mesh/NodeManager.hpp +++ b/src/coreComponents/mesh/NodeManager.hpp @@ -98,6 +98,13 @@ class NodeManager : public ObjectManagerBase ///@} + /** + * @brief Reserve the size of the NodeManager and all its member arrays that relate nodes to faces, to edges, and to elements. + * @details the size of the NodeManager is the number of nodes + * @param[in] newSize the new size of the NodeManager + */ + virtual void reserve( localIndex const newSize ) override; + /** * @brief Resize the NodeManager, and all its member vectors that relate nodes to faces, to edges, and to elements. * @details the size of the NodeManager is the number of nodes diff --git a/src/coreComponents/mesh/ObjectManagerBase.cpp b/src/coreComponents/mesh/ObjectManagerBase.cpp index 9f0f52484a5..2d3ab0cc76a 100644 --- a/src/coreComponents/mesh/ObjectManagerBase.cpp +++ b/src/coreComponents/mesh/ObjectManagerBase.cpp @@ -783,6 +783,8 @@ integer ObjectManagerBase::splitObject( localIndex const indexToSplit, int const GEOS_UNUSED_PARAM( rank ), localIndex & newIndex ) { + GEOS_MARK_FUNCTION; + // if the object index has a zero sized childIndices entry, then this object can be split into two // new objects diff --git a/src/coreComponents/mesh/SurfaceElementRegion.cpp b/src/coreComponents/mesh/SurfaceElementRegion.cpp index 1c6983dedce..40e5040305c 100644 --- a/src/coreComponents/mesh/SurfaceElementRegion.cpp +++ b/src/coreComponents/mesh/SurfaceElementRegion.cpp @@ -89,6 +89,7 @@ void SurfaceElementRegion::initializePreSubGroups() localIndex SurfaceElementRegion::addToSurfaceMesh( FaceManager const * const faceManager, localIndex const faceIndices[2] ) { + GEOS_MARK_FUNCTION; localIndex rval = -1; arrayView2d< localIndex const > const faceToElementRegion = faceManager->elementRegionList(); arrayView2d< localIndex const > const faceToElementSubRegion = faceManager->elementSubRegionList(); @@ -171,6 +172,7 @@ localIndex SurfaceElementRegion::addToFractureMesh( real64 const time_np1, ArrayOfArraysView< localIndex const > const & originalFaceToEdgeMap, localIndex const faceIndices[2] ) { + GEOS_MARK_FUNCTION; localIndex const kfe = this->addToSurfaceMesh( faceManager, faceIndices ); FaceElementSubRegion & subRegion = this->getUniqueSubRegion< FaceElementSubRegion >(); @@ -215,12 +217,23 @@ localIndex SurfaceElementRegion::addToFractureMesh( real64 const time_np1, subRegion.calculateSingleElementGeometricQuantities( kfe, faceManager->faceArea() ); + return kfe; +} + +void SurfaceElementRegion::updateSets( FaceManager const & faceManager ) +{ + GEOS_MARK_FUNCTION; // update the sets + FaceElementSubRegion & subRegion = this->getUniqueSubRegion< FaceElementSubRegion >(); FaceElementSubRegion::FaceMapType const & faceMap = subRegion.faceList(); - for( auto const & setIter : faceManager->sets().wrappers() ) + + // loop over all sets in the faceManaager and if the face is in the set, add the face element to the corresponding set in the subregion + for( auto const & setIter : faceManager.sets().wrappers() ) { - SortedArrayView< localIndex const > const & faceSet = faceManager->sets().getReference< SortedArray< localIndex > >( setIter.first ); + + SortedArrayView< localIndex const > const & faceSet = faceManager.sets().getReference< SortedArray< localIndex > >( setIter.first ); SortedArray< localIndex > & faceElementSet = subRegion.sets().registerWrapper< SortedArray< localIndex > >( setIter.first ).reference(); + for( localIndex a = 0; a < faceMap.size( 0 ); ++a ) { if( faceSet.count( faceMap[a][0] ) ) @@ -229,8 +242,6 @@ localIndex SurfaceElementRegion::addToFractureMesh( real64 const time_np1, } } } - - return kfe; } diff --git a/src/coreComponents/mesh/SurfaceElementRegion.hpp b/src/coreComponents/mesh/SurfaceElementRegion.hpp index 80ea705a996..0c64d31521e 100644 --- a/src/coreComponents/mesh/SurfaceElementRegion.hpp +++ b/src/coreComponents/mesh/SurfaceElementRegion.hpp @@ -123,6 +123,12 @@ class SurfaceElementRegion : public ElementRegionBase ArrayOfArraysView< localIndex const > const & originalFaceToEdges, localIndex const faceIndices[2] ); + /** + * @brief This function updates the face/surface mesh entries for the faces that are part of the surface region. + * @param faceManager pointer to the FaceManager object. + */ + void updateSets( FaceManager const & faceManager ); + ///@} diff --git a/src/coreComponents/mesh/generators/MeshGeneratorBase.cpp b/src/coreComponents/mesh/generators/MeshGeneratorBase.cpp index 97dcfad0e97..e75a677ef60 100644 --- a/src/coreComponents/mesh/generators/MeshGeneratorBase.cpp +++ b/src/coreComponents/mesh/generators/MeshGeneratorBase.cpp @@ -18,6 +18,19 @@ #include "mesh/LogLevelsInfo.hpp" #include "mesh/generators/ParticleBlockManager.hpp" #include "mesh/generators/MeshComponentBase.hpp" +#include "mesh/NodeManager.hpp" +#include "mesh/EdgeManager.hpp" +#include "mesh/FaceManager.hpp" +#include "mesh/ElementRegionManager.hpp" +#include "common/logger/Logger.hpp" +#include "common/MpiWrapper.hpp" +#include "mesh/CellElementSubRegion.hpp" + +#include +#include +#include +#include + namespace geos { using namespace dataRepository; @@ -26,6 +39,15 @@ MeshGeneratorBase::MeshGeneratorBase( string const & name, Group * const parent Group( name, parent ) { setInputFlags( InputFlags::OPTIONAL_NONUNIQUE ); + + registerWrapper( viewKeyStruct::checkEulerCharacteristicString(), &m_checkEulerCharacteristic ). + setApplyDefaultValue( 0 ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "When set to 1, compute the Euler-Poincaré characteristic χ = V − E + F − C " + "after the mesh is loaded and issue a warning if χ ≠ 1. " + "χ = 1 is expected for a single connected solid mesh without interior voids. " + "Non-unity values may indicate multiple disconnected bodies, interior voids, " + "or non-manifold topology. Default: 0 (disabled)." ); } Group * MeshGeneratorBase::createChild( string const & childKey, string const & childName ) @@ -100,4 +122,193 @@ void MeshGeneratorBase::attachWellInfo( CellBlockManager & cellBlockManager ) } ); } + +integer computeEulerCharacteristic( NodeManager const & nodeManager, + EdgeManager const & GEOS_UNUSED_PARAM( edgeManager ), + FaceManager const & GEOS_UNUSED_PARAM( faceManager ), + ElementRegionManager const & elemManager ) +{ + // Compute the Euler-Poincaré characteristic χ = V − E + F − C for the + // **bulk** mesh only (CellElementSubRegion entities). + // + // We reconstruct V, E, F directly from the cell-to-node maps so that + // fracture-induced duplicates in EdgeManager / FaceManager are excluded. + // + // MPI correctness: + // C – count only owned cells (ghostRank < 0); cells are uniquely partitioned. + // V, E, F – we must iterate ALL cells (owned + ghost) to discover every + // entity. A boundary face is generated by a single cell; if that cell + // is owned by rank 1 but the face's min-node is owned by rank 0, rank 0 + // needs to see the face from its ghost copy of that cell. Without + // including ghost cells, the face would be missed by all ranks. + // De-duplication: assign ownership of each entity to the rank that owns + // the node with the smallest global ID. Since global IDs are unique + // and each global node ID is owned by exactly one rank, each entity is + // counted exactly once. + + using EdgeKey = std::pair< globalIndex, globalIndex >; + using FaceKey = std::vector< globalIndex >; + + arrayView1d< globalIndex const > const localToGlobal = nodeManager.localToGlobalMap(); + arrayView1d< integer const > const nodeGhostRank = nodeManager.ghostRank(); + + std::set< globalIndex > allNodes; + std::set< EdgeKey > allEdges; + std::set< FaceKey > allFaces; + localIndex numOwnedCells = 0; + + // --- helpers ----------------------------------------------------------- + auto makeEdge = []( globalIndex a, globalIndex b ) -> EdgeKey + { + return a < b ? std::make_pair( a, b ) : std::make_pair( b, a ); + }; + + auto makeFace = []( std::initializer_list< globalIndex > nodes ) -> FaceKey + { + FaceKey f( nodes ); + std::sort( f.begin(), f.end() ); + return f; + }; + + // --- iterate ALL cells (owned + ghost) to collect every entity --------- + elemManager.forElementSubRegions< CellElementSubRegion >( + [&]( CellElementSubRegion const & subRegion ) + { + arrayView2d< localIndex const, cells::NODE_MAP_USD > const elemToNodeMap = + subRegion.nodeList(); + arrayView1d< integer const > const cellGhostRank = subRegion.ghostRank(); + + for( localIndex ei = 0; ei < subRegion.size(); ++ei ) + { + // Count only owned cells for C, but collect entities from ALL cells. + if( cellGhostRank[ei] < 0 ) + ++numOwnedCells; + + localIndex const npe = elemToNodeMap.size( 1 ); + std::vector< globalIndex > gn( npe ); + for( localIndex ni = 0; ni < npe; ++ni ) + { + gn[ni] = localToGlobal[ elemToNodeMap[ei][ni] ]; + allNodes.insert( gn[ni] ); + } + + if( npe == 4 ) // ---- Tetrahedron -------------------------------- + { + allEdges.insert( makeEdge( gn[0], gn[1] ) ); + allEdges.insert( makeEdge( gn[0], gn[2] ) ); + allEdges.insert( makeEdge( gn[0], gn[3] ) ); + allEdges.insert( makeEdge( gn[1], gn[2] ) ); + allEdges.insert( makeEdge( gn[1], gn[3] ) ); + allEdges.insert( makeEdge( gn[2], gn[3] ) ); + + allFaces.insert( makeFace( {gn[0], gn[1], gn[2]} ) ); + allFaces.insert( makeFace( {gn[0], gn[1], gn[3]} ) ); + allFaces.insert( makeFace( {gn[0], gn[2], gn[3]} ) ); + allFaces.insert( makeFace( {gn[1], gn[2], gn[3]} ) ); + } + else if( npe == 8 ) // ---- Hexahedron (GEOS ordering 0,1,3,2,4,5,7,6) --- + { + allEdges.insert( makeEdge( gn[0], gn[1] ) ); + allEdges.insert( makeEdge( gn[1], gn[3] ) ); + allEdges.insert( makeEdge( gn[3], gn[2] ) ); + allEdges.insert( makeEdge( gn[2], gn[0] ) ); + allEdges.insert( makeEdge( gn[4], gn[5] ) ); + allEdges.insert( makeEdge( gn[5], gn[7] ) ); + allEdges.insert( makeEdge( gn[7], gn[6] ) ); + allEdges.insert( makeEdge( gn[6], gn[4] ) ); + allEdges.insert( makeEdge( gn[0], gn[4] ) ); + allEdges.insert( makeEdge( gn[1], gn[5] ) ); + allEdges.insert( makeEdge( gn[3], gn[7] ) ); + allEdges.insert( makeEdge( gn[2], gn[6] ) ); + + allFaces.insert( makeFace( {gn[0], gn[1], gn[3], gn[2]} ) ); + allFaces.insert( makeFace( {gn[4], gn[5], gn[7], gn[6]} ) ); + allFaces.insert( makeFace( {gn[0], gn[1], gn[5], gn[4]} ) ); + allFaces.insert( makeFace( {gn[2], gn[3], gn[7], gn[6]} ) ); + allFaces.insert( makeFace( {gn[1], gn[3], gn[7], gn[5]} ) ); + allFaces.insert( makeFace( {gn[0], gn[2], gn[6], gn[4]} ) ); + } + else if( npe == 6 ) // ---- Wedge / Prism --------------------------- + { + allEdges.insert( makeEdge( gn[0], gn[1] ) ); + allEdges.insert( makeEdge( gn[1], gn[2] ) ); + allEdges.insert( makeEdge( gn[2], gn[0] ) ); + allEdges.insert( makeEdge( gn[3], gn[4] ) ); + allEdges.insert( makeEdge( gn[4], gn[5] ) ); + allEdges.insert( makeEdge( gn[5], gn[3] ) ); + allEdges.insert( makeEdge( gn[0], gn[3] ) ); + allEdges.insert( makeEdge( gn[1], gn[4] ) ); + allEdges.insert( makeEdge( gn[2], gn[5] ) ); + + allFaces.insert( makeFace( {gn[0], gn[1], gn[2]} ) ); + allFaces.insert( makeFace( {gn[3], gn[4], gn[5]} ) ); + allFaces.insert( makeFace( {gn[0], gn[1], gn[4], gn[3]} ) ); + allFaces.insert( makeFace( {gn[1], gn[2], gn[5], gn[4]} ) ); + allFaces.insert( makeFace( {gn[2], gn[0], gn[3], gn[5]} ) ); + } + else if( npe == 5 ) // ---- Pyramid --------------------------------- + { + allEdges.insert( makeEdge( gn[0], gn[1] ) ); + allEdges.insert( makeEdge( gn[1], gn[2] ) ); + allEdges.insert( makeEdge( gn[2], gn[3] ) ); + allEdges.insert( makeEdge( gn[3], gn[0] ) ); + allEdges.insert( makeEdge( gn[0], gn[4] ) ); + allEdges.insert( makeEdge( gn[1], gn[4] ) ); + allEdges.insert( makeEdge( gn[2], gn[4] ) ); + allEdges.insert( makeEdge( gn[3], gn[4] ) ); + + allFaces.insert( makeFace( {gn[0], gn[1], gn[2], gn[3]} ) ); + allFaces.insert( makeFace( {gn[0], gn[1], gn[4]} ) ); + allFaces.insert( makeFace( {gn[1], gn[2], gn[4]} ) ); + allFaces.insert( makeFace( {gn[2], gn[3], gn[4]} ) ); + allFaces.insert( makeFace( {gn[3], gn[0], gn[4]} ) ); + } + } + } ); + + // --- ownership: entity owned by this rank if the node with the smallest + // global ID in the entity is owned (ghostRank < 0) on this rank. ---- + + auto nodeIsOwned = [&]( globalIndex gid ) -> bool + { + auto it = nodeManager.globalToLocalMap().find( gid ); + if( it == nodeManager.globalToLocalMap().end() ) + return false; + return nodeGhostRank[ it->second ] < 0; + }; + + localIndex ownedV = 0; + for( globalIndex const & gid : allNodes ) + { + if( nodeIsOwned( gid ) ) + ++ownedV; + } + + localIndex ownedE = 0; + for( EdgeKey const & e : allEdges ) + { + if( nodeIsOwned( e.first ) ) // e.first is the min global ID (sorted) + ++ownedE; + } + + localIndex ownedF = 0; + for( FaceKey const & f : allFaces ) + { + if( nodeIsOwned( f[0] ) ) // f[0] is the min global ID (sorted) + ++ownedF; + } + + // --- MPI reduce -------------------------------------------------------- + globalIndex const V = MpiWrapper::sum< globalIndex >( ownedV ); + globalIndex const E = MpiWrapper::sum< globalIndex >( ownedE ); + globalIndex const F = MpiWrapper::sum< globalIndex >( ownedF ); + globalIndex const C = MpiWrapper::sum< globalIndex >( numOwnedCells ); + + GEOS_LOG_RANK_0( "computeEulerCharacteristic (bulk):" + << " V=" << V << " E=" << E << " F=" << F << " C=" << C + << " chi=" << (V - E + F - C) ); + + return static_cast< integer >( V - E + F - C ); +} + } diff --git a/src/coreComponents/mesh/generators/MeshGeneratorBase.hpp b/src/coreComponents/mesh/generators/MeshGeneratorBase.hpp index 03ae359a7ac..7df4391fc9c 100644 --- a/src/coreComponents/mesh/generators/MeshGeneratorBase.hpp +++ b/src/coreComponents/mesh/generators/MeshGeneratorBase.hpp @@ -31,16 +31,34 @@ namespace geos { -// This forward declaration prevents from exposing the internals of the module, -// which are only accessed through some private functions signatures. -// In order to avoid this forward declaration, we could expose an ABC -// instead of exposing the MeshGeneratorBase implementation. +// Forward declarations class CellBlockManager; +class NodeManager; +class EdgeManager; +class FaceManager; +class ElementRegionManager; + +/** + * @brief Compute the Euler-Poincaré characteristic χ = V − E + F − C for the bulk mesh. + * + * Only `CellElementSubRegion` elements are counted (fracture / surface sub-regions are excluded). + * For a single, connected 3-D solid without interior voids χ = 1. + * + * @param nodeManager Populated node manager. + * @param edgeManager Populated edge manager. + * @param faceManager Populated face manager. + * @param elemManager Populated element region manager. + * @return χ = V − E + F − C as a signed integer (global value, same on all ranks). + */ +integer computeEulerCharacteristic( NodeManager const & nodeManager, + EdgeManager const & edgeManager, + FaceManager const & faceManager, + ElementRegionManager const & elemManager ); /** * @class MeshGeneratorBase * @brief The MeshGeneratorBase class provides an abstract base class implementation for different mesh types. - * The MeshGeneratorBase is the Group specialization for different type of mesh handling. + * The MeshGeneratorBase is the Group specialization for different type of mesh handling. */ class MeshGeneratorBase : public dataRepository::Group { @@ -125,6 +143,19 @@ class MeshGeneratorBase : public dataRepository::Group */ stdMap< string, string > const & getSurfacicFieldsMapping() const { return m_surfacicFields; } + /// Key for the checkEulerCharacteristic XML attribute + struct viewKeyStruct + { + /** + * @brief Get the XML attribute name for the Euler characteristic check flag. + * @return The string "checkEulerCharacteristic". + */ + constexpr static char const * checkEulerCharacteristicString() { return "checkEulerCharacteristic"; } + }; + + /// When non-zero, compute χ = V − E + F − C after mesh loading and warn if χ ≠ 1. + integer m_checkEulerCharacteristic = 0; + protected: /// Mapping from volumic field source to GEOS field. stdMap< string, string > m_volumicFields; diff --git a/src/coreComponents/mesh/generators/ParMETISInterface.cpp b/src/coreComponents/mesh/generators/ParMETISInterface.cpp index d177313f44c..0152dad83f3 100644 --- a/src/coreComponents/mesh/generators/ParMETISInterface.cpp +++ b/src/coreComponents/mesh/generators/ParMETISInterface.cpp @@ -58,23 +58,34 @@ meshToDual( ArrayOfArraysView< idx_t const, idx_t > const & elemToNodes, idx_t * xadj; idx_t * adjncy; + // ParMETIS does not handle ranks with zero local elements (it crashes on NULL array pointers). + // We provide dummy non-NULL arrays for empty ranks so the collective call can proceed. + idx_t dummyOffset = 0; + idx_t dummyValue = 0; + idx_t * eptr = numElems > 0 ? const_cast< idx_t * >( elemToNodes.getOffsets() ) : &dummyOffset; + idx_t * eind = numElems > 0 ? const_cast< idx_t * >( elemToNodes.getValues() ) : &dummyValue; + // Technical UB if ParMETIS writes into these arrays; in practice we discard them right after GEOS_PARMETIS_CHECK( ParMETIS_V3_Mesh2Dual( const_cast< idx_t * >( elemDist.data() ), - const_cast< idx_t * >( elemToNodes.getOffsets() ), - const_cast< idx_t * >( elemToNodes.getValues() ), + eptr, + eind, &numflag, &ncommonnodes, &xadj, &adjncy, &comm ) ); ArrayOfArrays< idx_t, idx_t > graph; - graph.resizeFromOffsets( numElems, xadj ); - // There is no way to direct-copy values into ArrayOfArrays without UB (casting away const) - forAll< parallelHostPolicy >( numElems, [xadj, adjncy, graph = graph.toView()]( localIndex const k ) + if( numElems > 0 ) { - graph.appendToArray( k, adjncy + xadj[k], adjncy + xadj[k+1] ); - } ); + graph.resizeFromOffsets( numElems, xadj ); + + // There is no way to direct-copy values into ArrayOfArrays without UB (casting away const) + forAll< parallelHostPolicy >( numElems, [xadj, adjncy, graph = graph.toView()]( localIndex const k ) + { + graph.appendToArray( k, adjncy + xadj[k], adjncy + xadj[k+1] ); + } ); - METIS_Free( xadj ); - METIS_Free( adjncy ); + METIS_Free( xadj ); + METIS_Free( adjncy ); + } return graph; } @@ -105,22 +116,32 @@ partition( ArrayOfArraysView< idx_t const, idx_t > const & graph, idx_t edgecut = 0; real_t ubvec = 1.05; + // ParMETIS does not handle ranks with zero local vertices (it crashes on NULL adjncy pointer). + // We provide dummy non-NULL pointers for empty ranks so the collective call can proceed. + idx_t dummyAdj = 0; + idx_t dummyPart = 0; + idx_t * xadj = const_cast< idx_t * >( graph.getOffsets() ); + idx_t * adjncy = graph.size() > 0 && graph.getValues() != nullptr + ? const_cast< idx_t * >( graph.getValues() ) + : &dummyAdj; + idx_t * partData = graph.size() > 0 ? part.data() : &dummyPart; + // Technical UB if ParMETIS writes into these arrays; in practice we discard them right after GEOS_PARMETIS_CHECK( ParMETIS_V3_PartKway( const_cast< idx_t * >( vertDist.data() ), - const_cast< idx_t * >( graph.getOffsets() ), - const_cast< idx_t * >( graph.getValues() ), + xadj, + adjncy, nullptr, nullptr, &wgtflag, &numflag, &ncon, &npart, tpwgts.data(), - &ubvec, options, &edgecut, part.data(), &comm ) ); + &ubvec, options, &edgecut, partData, &comm ) ); for( int iter = 0; iter < numRefinements; ++iter ) { GEOS_PARMETIS_CHECK( ParMETIS_V3_RefineKway( const_cast< idx_t * >( vertDist.data() ), - const_cast< idx_t * >( graph.getOffsets() ), - const_cast< idx_t * >( graph.getValues() ), + xadj, + adjncy, nullptr, nullptr, &wgtflag, &numflag, &ncon, &npart, tpwgts.data(), - &ubvec, options, &edgecut, part.data(), &comm ) ); + &ubvec, options, &edgecut, partData, &comm ) ); } return part; diff --git a/src/coreComponents/mesh/generators/VTKUtilities.cpp b/src/coreComponents/mesh/generators/VTKUtilities.cpp index a85763daffa..a3bec9252a4 100644 --- a/src/coreComponents/mesh/generators/VTKUtilities.cpp +++ b/src/coreComponents/mesh/generators/VTKUtilities.cpp @@ -1028,11 +1028,35 @@ findNeighborRanks( stdVector< vtkBoundingBox > boundingBoxes ) int const numParts = LvArray::integerConversion< int >( boundingBoxes.size() ); int const thisRank = MpiWrapper::commRank(); - // Inflate boxes to detect intersections more reliably - double constexpr inflateFactor = 1.01; + // Inflate boxes to detect intersections more reliably. + // + // Pure relative scaling (ScaleAboutCenter) fails for small or thin partitions in Release builds: + // two face-adjacent partitions share an exact planar boundary, so their bounding boxes only + // *touch* rather than overlap. After scaling by 1% about the center, the expanded extents of + // one box may still not penetrate the other in that dimension if the box is very thin relative + // to floating-point rounding under -O2/-O3. + // + // Fix: compute a per-box absolute inflation in each dimension as + // max( relative_expand, absoluteMinExpand ) + // where absoluteMinExpand is a small fixed distance that guarantees overlap even for + // degenerate (zero-length) extents along a split plane. + double constexpr relativeExpandFactor = 0.01; // 1% of the box length in each dimension + double constexpr absoluteMinExpand = 1.0e-6; // absolute fallback (mesh units) + for( vtkBoundingBox & box : boundingBoxes ) { - box.ScaleAboutCenter( inflateFactor ); + double const * minPt = box.GetMinPoint(); + double const * maxPt = box.GetMaxPoint(); + double newMin[3], newMax[3]; + for( int d = 0; d < 3; ++d ) + { + double const half = 0.5 * ( maxPt[d] - minPt[d] ); + double const expand = std::max( relativeExpandFactor * half, absoluteMinExpand ); + newMin[d] = minPt[d] - expand; + newMax[d] = maxPt[d] + expand; + } + box.SetMinPoint( newMin ); + box.SetMaxPoint( newMax ); } stdVector< int > neighbors; diff --git a/src/coreComponents/mesh/graphs/GraphColoringBase.cpp b/src/coreComponents/mesh/graphs/GraphColoringBase.cpp index 55f1208b480..a8ae234dc81 100644 --- a/src/coreComponents/mesh/graphs/GraphColoringBase.cpp +++ b/src/coreComponents/mesh/graphs/GraphColoringBase.cpp @@ -67,32 +67,28 @@ bool GraphColoringBase::isColoringValid( const std::vector< camp::idx_t > & adjn const int color, MPI_Comm comm ) { - // Gather neighbor colors asynchronously - std::vector< int > neighborColors( adjncy.size()); - std::vector< MPI_Request > requests( adjncy.size() * 2, MPI_REQUEST_NULL ); // Two requests per neighbor (send and receive) - for( size_t i = 0; i < adjncy.size(); ++i ) - { - int const neighborRank = adjncy[i]; - MpiWrapper::iSend( &color, 1, neighborRank, 0, comm, &requests[i * 2] ); - MpiWrapper::iRecv( &neighborColors[i], 1, neighborRank, 0, comm, &requests[i * 2 + 1] ); - } - - // Wait for all asynchronous communications to complete - MpiWrapper::waitAll( requests.size(), requests.data(), MPI_STATUSES_IGNORE ); - + // Use a collective allgather to retrieve every rank's color. + // The original point-to-point iSend/iRecv approach with a fixed tag is + // fragile in Release builds: messages from successive calls to getColor() + // (one per SurfaceGenerator time-step) can linger in the MPI queue and be + // matched by the wrong iRecv, producing false color conflicts. + // Allgather has no tag and is always safe. + int const size = MpiWrapper::commSize( comm ); + std::vector< int > allColors( size ); + MpiWrapper::allgather( &color, 1, allColors.data(), 1, comm ); - // Check for color conflicts + // Check for color conflicts with each listed neighbor. bool isLocalColoringValid = true; - for( const auto & neighborColor : neighborColors ) + for( camp::idx_t const neighborRank : adjncy ) { - if( color == neighborColor ) + if( allColors[neighborRank] == color ) { isLocalColoringValid = false; break; } } - // Get a consolidated isColoringValid + // Reduce to a single global answer. bool isColoringValid = MpiWrapper::allReduce( &isLocalColoringValid, MpiWrapper::Reduction::LogicalAnd, comm ); return isColoringValid; diff --git a/src/coreComponents/mesh/graphs/RLFGraphColoringMPI.cpp b/src/coreComponents/mesh/graphs/RLFGraphColoringMPI.cpp index 314ca4e577c..3ed9881511c 100644 --- a/src/coreComponents/mesh/graphs/RLFGraphColoringMPI.cpp +++ b/src/coreComponents/mesh/graphs/RLFGraphColoringMPI.cpp @@ -21,6 +21,7 @@ #include "RLFGraphColoring.hpp" #include "GraphToolsMPI.hpp" #include +#include namespace geos @@ -54,6 +55,39 @@ std::vector< int > RLFGraphColoringMPI::colorGraph( const std::vector< camp::idx std::vector< int > colors; if( rank == 0 ) { + // Symmetrize the gathered graph before coloring. + // findNeighborRanks() can produce asymmetric neighbor lists in Release builds + // (A lists B but B doesn't list A). gatherGraphData() concatenates these + // directed edges verbatim; the resulting graph may be asymmetric. + // RLFGraphColoring treats the graph as undirected, so an asymmetric input + // can yield a coloring that is valid from one direction but not the other. + // Symmetrizing here ensures the coloring is globally valid. + int const numNodes = static_cast< int >( xadj.size() ) - 1; + // Build adjacency sets for each node, then add reverse edges. + std::vector< std::set< camp::idx_t > > adjSets( numNodes ); + for( int i = 0; i < numNodes; ++i ) + { + for( camp::idx_t j = xadj[i]; j < xadj[i + 1]; ++j ) + { + camp::idx_t const neighbor = adjncy[j]; + adjSets[i].insert( neighbor ); + adjSets[neighbor].insert( static_cast< camp::idx_t >( i ) ); // reverse edge + } + } + // Rebuild xadj and adjncy from the symmetrized sets. + std::vector< camp::idx_t > symXadj( numNodes + 1, 0 ); + std::vector< camp::idx_t > symAdjncy; + for( int i = 0; i < numNodes; ++i ) + { + symXadj[i + 1] = symXadj[i] + static_cast< camp::idx_t >( adjSets[i].size() ); + for( camp::idx_t nb : adjSets[i] ) + { + symAdjncy.push_back( nb ); + } + } + xadj = std::move( symXadj ); + adjncy = std::move( symAdjncy ); + geos::graph::RLFGraphColoring graphColoring; colors = graphColoring.colorGraph( xadj, adjncy ); } diff --git a/src/coreComponents/mesh/mpiCommunications/CommunicationTools.cpp b/src/coreComponents/mesh/mpiCommunications/CommunicationTools.cpp index 678c0c49fc9..b09718c2381 100644 --- a/src/coreComponents/mesh/mpiCommunications/CommunicationTools.cpp +++ b/src/coreComponents/mesh/mpiCommunications/CommunicationTools.cpp @@ -271,6 +271,8 @@ void CommunicationTools::assignGlobalIndices( ObjectManagerBase & manager, void CommunicationTools::assignNewGlobalIndices( ObjectManagerBase & manager, std::set< localIndex > const & indexList ) { + GEOS_MARK_FUNCTION; + globalIndex const glocalIndexOffset = MpiWrapper::prefixSum< globalIndex >( indexList.size(), MPI_COMM_GEOS ); arrayView1d< globalIndex > const & localToGlobal = manager.localToGlobalMap(); @@ -296,6 +298,7 @@ void CommunicationTools::assignNewGlobalIndices( ElementRegionManager & elementManager, stdMap< std::pair< localIndex, localIndex >, std::set< localIndex > > const & newElems ) { + GEOS_MARK_FUNCTION; localIndex numberOfNewObjectsHere = 0; for( auto const & iter : newElems ) { diff --git a/src/coreComponents/mesh/mpiCommunications/SpatialPartition.cpp b/src/coreComponents/mesh/mpiCommunications/SpatialPartition.cpp index fbcd9258750..0947a4e2e6e 100644 --- a/src/coreComponents/mesh/mpiCommunications/SpatialPartition.cpp +++ b/src/coreComponents/mesh/mpiCommunications/SpatialPartition.cpp @@ -24,6 +24,8 @@ #endif #include +#include +#include namespace geos { @@ -117,10 +119,66 @@ int SpatialPartition::getColor() } else { - // External partitioner such as ParMetis or PTScotch (for VTK external mesh) - std::vector< camp::idx_t > adjncy; - adjncy.reserve( m_metisNeighborList.size()); - std::copy( m_metisNeighborList.begin(), m_metisNeighborList.end(), std::back_inserter( adjncy )); + // External partitioner such as ParMetis or PTScotch (for VTK external mesh). + // + // findNeighborRanks() runs independently on each rank using bounding-box intersection, + // which can produce ASYMMETRIC neighbor lists in Release builds: rank A may include rank B + // in its list while rank B does not include rank A (or vice versa), due to floating-point + // differences in the intersection test under -O2/-O3. An asymmetric graph fed to the RLF + // coloring algorithm on rank 0 means the coloring is only valid for one direction of each + // missing edge; the subsequent isColoringValid() check (which uses the rank's own local + // adjncy) then detects the conflict and raises GEOS_ERROR. + // + // Fix: symmetrize the global neighbor graph before coloring. + // Each rank allgathers its own neighbor list; any rank i that appears in rank j's list + // automatically gets rank j added to its own list. After symmetrization the graph is + // guaranteed to be undirected and the coloring is valid for all ranks. + + int const commSize = MpiWrapper::commSize( MPI_COMM_GEOS ); + int const commRank = MpiWrapper::commRank( MPI_COMM_GEOS ); + + // Step 1: allgather the sizes of every rank's neighbor list. + int const localNeighborCount = static_cast< int >( m_metisNeighborList.size() ); + std::vector< int > allNeighborCounts( commSize ); + MpiWrapper::allgather( &localNeighborCount, 1, allNeighborCounts.data(), 1, MPI_COMM_GEOS ); + + // Step 2: allgatherv the neighbor lists themselves. + std::vector< int > displacements( commSize, 0 ); + for( int i = 1; i < commSize; ++i ) + { + displacements[i] = displacements[i - 1] + allNeighborCounts[i - 1]; + } + int const totalNeighbors = displacements[commSize - 1] + allNeighborCounts[commSize - 1]; + + std::vector< int > localNeighborVec( m_metisNeighborList.begin(), m_metisNeighborList.end() ); + std::vector< int > allNeighbors( totalNeighbors ); + MpiWrapper::allgatherv( localNeighborVec.data(), localNeighborCount, + allNeighbors.data(), allNeighborCounts.data(), + displacements.data(), MPI_COMM_GEOS ); + + // Step 3: build the symmetrized local adjacency list. + // Start from the current (possibly incomplete) local list, then add any rank j + // that lists commRank as its neighbor but is not yet in our list. + std::set< int > symmetricNeighbors( m_metisNeighborList.begin(), m_metisNeighborList.end() ); + for( int rankJ = 0; rankJ < commSize; ++rankJ ) + { + if( rankJ == commRank ) + continue; + int const start = displacements[rankJ]; + int const end = start + allNeighborCounts[rankJ]; + for( int k = start; k < end; ++k ) + { + if( allNeighbors[k] == commRank ) + { + // rank j lists us as a neighbor → we must list rank j too + symmetricNeighbors.insert( rankJ ); + break; + } + } + } + + std::vector< camp::idx_t > adjncy( symmetricNeighbors.begin(), symmetricNeighbors.end() ); + #ifdef GEOS_USE_TRILINOS geos::graph::ZoltanGraphColoring coloring; #else @@ -130,6 +188,14 @@ int SpatialPartition::getColor() if( !coloring.isColoringValid( adjncy, color )) { + // Print per-rank diagnostics to help identify the root cause. + std::string neighborStr; + for( auto const nb : adjncy ) + neighborStr += std::to_string( nb ) + " "; + GEOS_LOG_RANK( "getColor() coloring FAILED on rank " << commRank + << " assigned color=" << color + << " neighbors=[" << neighborStr << "]" ); + MpiWrapper::barrier( MPI_COMM_GEOS ); GEOS_ERROR( "Invalid partition coloring: two neighboring partitions share the same color" ); } m_numColors = coloring.getNumberOfColors( color ); diff --git a/src/coreComponents/physicsSolvers/CMakeLists.txt b/src/coreComponents/physicsSolvers/CMakeLists.txt index 246fc46be5f..dbf4df9e509 100644 --- a/src/coreComponents/physicsSolvers/CMakeLists.txt +++ b/src/coreComponents/physicsSolvers/CMakeLists.txt @@ -24,16 +24,18 @@ Contains: # Specify solver headers # set( physicsSolversBase_headers + FieldApplicator.hpp + FieldStatisticsBase.hpp LinearSolverParameters.hpp NonlinearSolverParameters.hpp PhysicsSolverBase.hpp PhysicsSolverBaseKernels.hpp - SolverStatistics.hpp - FieldStatisticsBase.hpp ) + SolverStatistics.hpp ) # # Specify solver sources # set( physicsSolversBase_sources + FieldApplicator.cpp LinearSolverParameters.cpp NonlinearSolverParameters.cpp PhysicsSolverBase.cpp @@ -134,4 +136,4 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") target_link_options(physicsSolvers PUBLIC -Wl,--no-as-needed) endif() -install( TARGETS physicsSolvers LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib ) \ No newline at end of file +install( TARGETS physicsSolvers LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib ) diff --git a/src/coreComponents/physicsSolvers/FieldApplicator.cpp b/src/coreComponents/physicsSolvers/FieldApplicator.cpp new file mode 100644 index 00000000000..0493f4b4347 --- /dev/null +++ b/src/coreComponents/physicsSolvers/FieldApplicator.cpp @@ -0,0 +1,429 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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. + * ------------------------------------------------------------------------------------------------------------ + */ + +#include "FieldApplicator.hpp" +#include "events/tasks/TasksManager.hpp" +#include "fieldSpecification/FieldSpecificationManager.hpp" +#include "fieldSpecification/FieldSpecificationBase.hpp" +#include "fieldSpecification/EquilibriumInitialCondition.hpp" +#include "common/FieldSpecificationOps.hpp" +#include "mesh/DomainPartition.hpp" +#include "mesh/MeshBody.hpp" +#include "mesh/MeshLevel.hpp" +#include "mesh/CellElementSubRegion.hpp" +#include "mesh/SurfaceElementSubRegion.hpp" +#include "functions/FunctionManager.hpp" +#include "functions/TableFunction.hpp" +#include "mesh/ElementSubRegionBase.hpp" +#include "physicsSolvers/fluidFlow/FlowSolverBase.hpp" +#include "physicsSolvers/fluidFlow/FlowSolverBaseFields.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseBase.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseBaseFields.hpp" +#include "constitutive/fluid/multifluid/MultiFluidBase.hpp" +#include "constitutive/fluid/multifluid/MultiFluidSelector.hpp" +#include "constitutive/solid/CoupledSolidBase.hpp" + +namespace geos +{ +using namespace dataRepository; + +FieldApplicator::FieldApplicator( const string & name, + Group * const parent ): + TaskBase( name, parent ), + m_fieldSpecificationNames(), + m_solverName(), + m_targetRegions() +{ + + registerWrapper( viewKeyStruct::fieldSpecificationNamesString(), &m_fieldSpecificationNames ). + setRTTypeName( rtTypes::CustomTypes::groupNameRefArray ). + setInputFlag( dataRepository::InputFlags::REQUIRED ). + setDescription( "Array containing the field specifications to apply to newly created elements" ); + + registerWrapper( viewKeyStruct::solverNameString(), &m_solverName ). + setRTTypeName( rtTypes::CustomTypes::groupNameRef ). + setInputFlag( dataRepository::InputFlags::OPTIONAL ). + setDescription( "Name of the flow solver to use for fluid state initialization (required for compositional flow)" ); + + registerWrapper( viewKeyStruct::targetRegionsString(), &m_targetRegions ). + setRTTypeName( rtTypes::CustomTypes::groupNameRefArray ). + setInputFlag( dataRepository::InputFlags::OPTIONAL ). + setDescription( "Target element regions to apply field specifications to. If empty, applies to all regions." ); + +} + +FieldApplicator::~FieldApplicator() = default; + +void FieldApplicator::postInputInitialization() +{ + TaskBase::postInputInitialization(); +} + + +bool +FieldApplicator:: + execute( real64 const time_n, + real64 const dt, + integer const cycleNumber, + integer const eventCounter, + real64 const eventProgress, + DomainPartition & domain ) +{ + GEOS_UNUSED_VAR( time_n, dt, cycleNumber, eventCounter, eventProgress ); + + FieldSpecificationManager & fsm = FieldSpecificationManager::getInstance(); + + // Check whether any of the field specifications is an EquilibriumInitialCondition. + // If so, we delegate the full re-initialization to the flow solver, which correctly + // handles multi-phase hydrostatic pressure computation and all derived state + // (phaseVolumeFraction, phaseMobility, RelPerm_phaseRelPerm, fracPerm_permeability, + // fracPorosity_porosity, etc.) + bool hasEquilibriumIC = false; + for( string const & fsName : m_fieldSpecificationNames ) + { + if( fsm.hasGroup( fsName ) ) + { + FieldSpecificationBase const & fs = fsm.getGroup< FieldSpecificationBase >( fsName ); + if( dynamic_cast< EquilibriumInitialCondition const * >( &fs ) != nullptr ) + { + hasEquilibriumIC = true; + break; + } + } + } + + if( hasEquilibriumIC ) + { + // Find the flow solver to delegate initialization to. + // Use m_solverName if provided, otherwise find the first FlowSolverBase. + FlowSolverBase * flowSolver = nullptr; + Group & solversGroup = this->getGroupByPath< Group >( "/Problem/Solvers" ); + + if( !m_solverName.empty() ) + { + flowSolver = solversGroup.getGroupPointer< FlowSolverBase >( m_solverName ); + GEOS_THROW_IF( flowSolver == nullptr, + GEOS_FMT( "FieldApplicator '{}': solver '{}' not found or is not a FlowSolverBase.", + getName(), m_solverName ), + InputError, getDataContext() ); + } + else + { + solversGroup.forSubGroups< FlowSolverBase >( [&]( FlowSolverBase & solver ) + { + if( flowSolver == nullptr ) + { + flowSolver = &solver; + } + } ); + } + + GEOS_THROW_IF( flowSolver == nullptr, + GEOS_FMT( "FieldApplicator '{}': No FlowSolverBase found to delegate HydrostaticEquilibrium " + "initialization. Please specify solverName in the FieldApplicator XML tag.", + getName() ), + InputError, getDataContext() ); + + GEOS_LOG_RANK_0( GEOS_FMT( "FieldApplicator '{}': delegating HydrostaticEquilibrium re-initialization " + "to solver '{}'.", getName(), flowSolver->getName() ) ); + + // Re-run the solver's full state initialization, which internally calls (in order): + // 1. computeHydrostaticEquilibrium → correctly assigns pressure, temperature, and + // globalCompFraction to ALL subregions including the + // newly created fracture elements, using the full + // multi-phase hydrostatic pressure algorithm + // 2. initializePorosityAndPermeability → fracPorosity_porosity, fracPerm_permeability + // 3. initializeHydraulicAperture → hydraulicAperture for fractures + // 4. initializeFluidState → globalCompDensity, phaseVolumeFraction, + // RelPerm_phaseRelPerm, phaseMobility, + // fluid.saveConvergedState() (_n arrays) + flowSolver->initializeState( domain ); + + return false; + } + + // For non-equilibrium field specifications, apply them element by element as before. + for( string const & fsName : m_fieldSpecificationNames ) + { + GEOS_THROW_IF( !fsm.hasGroup( fsName ), + GEOS_FMT( "{}: FieldSpecification named {} not found", + getWrapperDataContext( viewKeyStruct::fieldSpecificationNamesString() ), + fsName ), + InputError, getWrapperDataContext( viewKeyStruct::fieldSpecificationNamesString() ) ); + + FieldSpecificationBase const & fs = fsm.getGroup< FieldSpecificationBase >( fsName ); + + for( auto & meshBodyPair : domain.getMeshBodies().getSubGroups() ) + { + if( MeshBody * const meshBody = dynamic_cast< MeshBody * >( meshBodyPair.second ) ) + { + for( auto & meshLevelPair : meshBody->getMeshLevels().getSubGroups() ) + { + if( MeshLevel * const meshLevel = dynamic_cast< MeshLevel * >( meshLevelPair.second ) ) + { + fs.apply< ElementSubRegionBase >( *meshLevel, + [&]( FieldSpecificationBase const & bc, + string const &, + SortedArrayView< localIndex const > const & targetSet, + ElementSubRegionBase & subRegion, + string const fieldName ) + { + // If targetRegions is specified, only apply to matching regions + if( !m_targetRegions.empty() ) + { + string const & regionName = subRegion.getParent().getName(); + bool isTargetRegion = false; + for( string const & targetRegion : m_targetRegions ) + { + if( regionName == targetRegion ) + { + isTargetRegion = true; + break; + } + } + if( !isTargetRegion ) + { + return; // Skip this subregion + } + } + + string const targetFieldName = getTargetFieldName( fieldName ); + bc.applyFieldValue< FieldSpecificationEqual >( targetSet, 0.0, subRegion, targetFieldName ); + } ); + } + } + } + } + } + + return false; +} + +string FieldApplicator::getTargetFieldName( string const & fieldName ) const +{ + // HydrostaticEquilibrium is defined programatically a field specification, but it isn't actually a field itself. + // Instead, it updates the pressure field, which is the target field being modified. + if( fieldName == "HydrostaticEquilibrium" ) + { + return "pressure"; + } + return fieldName; +} + + +void FieldApplicator::initializeSubRegionFluidState( DomainPartition & domain, ElementSubRegionBase & subRegion ) +{ + GEOS_UNUSED_VAR( domain ); + + // Check if this subregion has a fluid model at all + if( !subRegion.hasWrapper( FlowSolverBase::viewKeyStruct::fluidNamesString() ) ) + { + return; // No fluid model associated - nothing to initialize + } + + // Find the CompositionalMultiphaseBase solver that targets this subregion. + // Use m_solverName if provided, otherwise search all solvers. + CompositionalMultiphaseBase * flowSolver = nullptr; + + Group & solversGroup = this->getGroupByPath< Group >( "/Problem/Solvers" ); + + if( !m_solverName.empty() ) + { + flowSolver = solversGroup.getGroupPointer< CompositionalMultiphaseBase >( m_solverName ); + GEOS_LOG_RANK_0_IF( flowSolver == nullptr, + GEOS_FMT( "FieldApplicator: solver '{}' is not a CompositionalMultiphaseBase solver; " + "skipping compositional state initialization.", m_solverName ) ); + } + else + { + // Search for the first CompositionalMultiphaseBase solver that has the same fluid name + string const & fluidName = subRegion.getReference< string >( FlowSolverBase::viewKeyStruct::fluidNamesString() ); + solversGroup.forSubGroups< CompositionalMultiphaseBase >( [&]( CompositionalMultiphaseBase & solver ) + { + if( flowSolver == nullptr ) + { + // Check that this solver's fluid name matches the subregion's fluid + GEOS_UNUSED_VAR( fluidName ); + flowSolver = &solver; + } + } ); + } + + if( flowSolver == nullptr ) + { + // Fall back to basic fluid update only (no phaseVolFrac, relPerm, or phaseMobility) + GEOS_LOG_RANK_0( "FieldApplicator: No CompositionalMultiphaseBase solver found. " + "phaseVolumeFraction, phaseMobility, and RelPerm_phaseRelPerm will not be initialized." ); + return; + } + + // ------------------------------------------------------------------------------------ + // Step 1: Initialize porosity and permeability for the fracture (SurfaceElementSubRegion) + // or bulk (CellElementSubRegion). + // + // For SurfaceElementSubRegion (fracture elements), this computes fracPerm_permeability and + // fracPorosity_porosity / fracPorosity_initialPorosity / fracPorosity_referencePorosity + // from the hydraulic aperture (defaultAperture) and the reference constitutive values. + // ------------------------------------------------------------------------------------ + if( subRegion.hasWrapper( FlowSolverBase::viewKeyStruct::solidNamesString() ) ) + { + string const & solidName = subRegion.getReference< string >( FlowSolverBase::viewKeyStruct::solidNamesString() ); + + if( subRegion.hasGroup( ElementSubRegionBase::groupKeyStruct::constitutiveModelsString() ) ) + { + dataRepository::Group & constitutiveModels = + subRegion.getGroup( ElementSubRegionBase::groupKeyStruct::constitutiveModelsString() ); + + if( constitutiveModels.hasGroup( solidName ) ) + { + constitutive::CoupledSolidBase & porousSolid = + constitutiveModels.getGroup< constitutive::CoupledSolidBase >( solidName ); + + // Dispatch the correct updatePorosityAndPermeability overload based on subregion type + SurfaceElementSubRegion * surfSubRegion = dynamic_cast< SurfaceElementSubRegion * >( &subRegion ); + CellElementSubRegion * cellSubRegion = dynamic_cast< CellElementSubRegion * >( &subRegion ); + + if( surfSubRegion != nullptr ) + { + // Fracture: initialize porosity/permeability from aperture (fracPerm_permeability, + // fracPorosity_porosity, fracPorosity_initialPorosity, fracPorosity_referencePorosity) + flowSolver->updatePorosityAndPermeability( *surfSubRegion ); + } + else if( cellSubRegion != nullptr ) + { + flowSolver->updatePorosityAndPermeability( *cellSubRegion ); + } + + // Initialize and save state so that _n fields (porosity_n) are correct + porousSolid.initializeState(); + porousSolid.saveConvergedState(); + + // Run update again after initializeState to ensure consistency + if( surfSubRegion != nullptr ) + { + flowSolver->updatePorosityAndPermeability( *surfSubRegion ); + } + else if( cellSubRegion != nullptr ) + { + flowSolver->updatePorosityAndPermeability( *cellSubRegion ); + } + } + } + } + + // ------------------------------------------------------------------------------------ + // Step 2: Check we have globalCompFraction and globalCompDensity to proceed with fluid init. + // ------------------------------------------------------------------------------------ + if( !subRegion.hasWrapper( "globalCompFraction" ) || !subRegion.hasWrapper( "globalCompDensity" ) ) + { + return; // Not a compositional flow subregion + } + + // ------------------------------------------------------------------------------------ + // Step 3: Initialize component densities (globalCompDensity) from component fractions. + // This is done via the fluid kernel wrapper (same as initializeFluidState does). + // ------------------------------------------------------------------------------------ + { + string const & fluidName = subRegion.getReference< string >( FlowSolverBase::viewKeyStruct::fluidNamesString() ); + + if( subRegion.hasGroup( ElementSubRegionBase::groupKeyStruct::constitutiveModelsString() ) ) + { + dataRepository::Group & constitutiveModels = + subRegion.getGroup( ElementSubRegionBase::groupKeyStruct::constitutiveModelsString() ); + + if( constitutiveModels.hasGroup( fluidName ) ) + { + constitutive::MultiFluidBase & fluid = + constitutiveModels.getGroup< constitutive::MultiFluidBase >( fluidName ); + + arrayView1d< real64 const > const pres = subRegion.getField< fields::flow::pressure >(); + arrayView1d< real64 const > const temp = subRegion.getField< fields::flow::temperature >(); + arrayView2d< real64 const, compflow::USD_COMP > const compFrac = subRegion.getField< fields::flow::globalCompFraction >(); + arrayView2d< real64, compflow::USD_COMP > const compDens = subRegion.getField< fields::flow::globalCompDensity >(); + + integer const numComp = compFrac.size( 1 ); + + // Update fluid model to get total density + constitutive::constitutiveUpdatePassThru( fluid, [&]( auto & castedFluid ) + { + using FluidType = TYPEOFREF( castedFluid ); + typename FluidType::KernelWrapper fluidWrapper = castedFluid.createKernelWrapper(); + + forAll< parallelHostPolicy >( subRegion.size(), [=] ( localIndex const ei ) + { + fluidWrapper.update( ei, 0, pres[ei], temp[ei], compFrac[ei] ); + } ); + } ); + + // Back-calculate component densities from total density and component fractions + arrayView2d< real64 const, constitutive::multifluid::USD_FLUID > const totalDens = fluid.totalDensity(); + + forAll< parallelHostPolicy >( subRegion.size(), [=] ( localIndex const ei ) + { + for( integer ic = 0; ic < numComp; ++ic ) + { + compDens[ei][ic] = totalDens[ei][0] * compFrac[ei][ic]; + } + } ); + } + } + } + + // ------------------------------------------------------------------------------------ + // Step 4: Call the solver's updateFluidState to compute all derived quantities: + // - phaseVolumeFraction (fixes the uninitialized phaseVolumeFraction) + // - RelPerm_phaseRelPerm (via updateRelPermModel inside updateFluidState) + // - phaseMobility (via updatePhaseMobility inside updateFluidState) + // ------------------------------------------------------------------------------------ + flowSolver->updateFluidState( subRegion ); + + // ------------------------------------------------------------------------------------ + // Step 5: Save the fluid constitutive model's converged state. + // This saves totalDensity_n, phaseDensity_n, phaseCompFraction_n, etc. + // Without this, the accumulation term residual at the first Newton iteration + // will be non-zero (phaseDensity_n=0 leads to wrong compAmount_n). + // ------------------------------------------------------------------------------------ + { + string const & fluidName2 = subRegion.getReference< string >( FlowSolverBase::viewKeyStruct::fluidNamesString() ); + if( subRegion.hasGroup( ElementSubRegionBase::groupKeyStruct::constitutiveModelsString() ) ) + { + dataRepository::Group & constModels2 = + subRegion.getGroup( ElementSubRegionBase::groupKeyStruct::constitutiveModelsString() ); + if( constModels2.hasGroup( fluidName2 ) ) + { + constitutive::MultiFluidBase const & fluid2 = + constModels2.getGroup< constitutive::MultiFluidBase >( fluidName2 ); + fluid2.saveConvergedState(); + } + } + } + + // ------------------------------------------------------------------------------------ + // Step 6: Save the solver-level converged state so that all _n fields are correctly + // initialized (pressure_n, temperature_n, compDens_n, compAmount_n). + // This is crucial so that the first time step's accumulation term is correct. + // ------------------------------------------------------------------------------------ + flowSolver->saveConvergedState( subRegion ); + + GEOS_LOG_RANK_0( GEOS_FMT( "FieldApplicator: Fully initialized fluid state (phaseVolumeFraction, " + "phaseMobility, RelPerm_phaseRelPerm, fracPerm_permeability, " + "fracPorosity_porosity) for subregion '{}'.", subRegion.getName() ) ); +} + + +REGISTER_CATALOG_ENTRY( TaskBase, FieldApplicator, string const &, Group * const ) + + +} // namespace geos diff --git a/src/coreComponents/physicsSolvers/FieldApplicator.hpp b/src/coreComponents/physicsSolvers/FieldApplicator.hpp new file mode 100644 index 00000000000..f6c25042502 --- /dev/null +++ b/src/coreComponents/physicsSolvers/FieldApplicator.hpp @@ -0,0 +1,136 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 FieldApplicator.hpp + */ + +#ifndef SRC_CORECOMPONENTS_PHYSICSSOLVERS_FIELDAPPLICATOR_HPP_ +#define SRC_CORECOMPONENTS_PHYSICSSOLVERS_FIELDAPPLICATOR_HPP_ + +#include "events/tasks/TaskBase.hpp" + +namespace geos +{ + +class EquilibriumInitialCondition; +class FunctionManager; +class FlowSolverBase; +class CompositionalMultiphaseBase; +class ElementSubRegionBase; + + +/** + * @class FieldApplicator + * @brief Task to apply field specifications to elements during runtime. + * + * This task applies field specifications to elements that are created dynamically during + * the simulation, such as fracture elements created by the SurfaceGenerator. It handles + * both simple field specifications and complex initialization like HydrostaticEquilibrium + * for compositional flow, including the computation of derived quantities like component + * densities. + */ +class FieldApplicator : public TaskBase +{ +public: + + /** + * @brief Constructor for the FieldApplicator class + * @param[in] name the name of the task coming from the xml + * @param[in] parent the parent group of the task + */ + FieldApplicator( const string & name, + Group * const parent ); + + /// Destructor for the class + ~FieldApplicator() override; + + /// Accessor for the catalog name + static string catalogName() + { + return "FieldApplicator"; + } + + /** + * @defgroup Tasks Interface Functions + * + * This function implements the interface defined by the abstract TaskBase class + */ + /**@{*/ + + virtual bool execute( real64 const time_n, + real64 const dt, + integer const cycleNumber, + integer const eventCounter, + real64 const eventProgress, + DomainPartition & domain ) override; + + /**@}*/ + +private: + + /** + * @struct viewKeyStruct holds char strings and viewKeys for fast lookup + */ + struct viewKeyStruct + { + constexpr static char const * fieldSpecificationNamesString() { return "fieldSpecificationNames"; } + constexpr static char const * solverNameString() { return "solverName"; } + constexpr static char const * targetRegionsString() { return "targetRegions"; } + }; + + void postInputInitialization() override; + + /** + * @brief Return the target field name. + * @param[in] fieldName Name of the field specification. + * @return Name of the target field being updated. + */ + string getTargetFieldName( string const & fieldName ) const; + + + /** + * @brief Initialize the fluid state for a subregion after applying equilibrium fields. + * @param[in] domain The domain partition. + * @param[in,out] subRegion The element subregion to initialize. + * + * This function is called after applying the HydrostaticEquilibrium fields to properly + * initialize all derived compositional variables. The full initialization sequence is: + * 1. Porosity and permeability (fracPorosity_porosity, fracPorosity_initialPorosity, + * fracPorosity_referencePorosity, fracPerm_permeability) via updatePorosityAndPermeability. + * For fracture elements (SurfaceElementSubRegion), this uses the hydraulic aperture + * (defaultAperture from the XML) to compute initial fracture permeability and porosity. + * 2. Component densities (globalCompDensity) from component fractions and total fluid density. + * 3. Phase volume fractions (phaseVolumeFraction) via updateFluidState. + * 4. Relative permeability values (RelPerm_phaseRelPerm) via updateFluidState. + * 5. Phase mobilities (phaseMobility) via updateFluidState. + * 6. All '_n' fields (converged state) via saveConvergedState. + */ + void initializeSubRegionFluidState( DomainPartition & domain, ElementSubRegionBase & subRegion ); + + /// Array of field specification names to apply + stdVector< string > m_fieldSpecificationNames; + + /// Name of the flow solver to use for fluid state initialization + string m_solverName; + + /// Target regions to apply field specifications to (optional filter) + stdVector< string > m_targetRegions; +}; + + +} /* namespace geos */ + +#endif /* SRC_CORECOMPONENTS_PHYSICSSOLVERS_FIELDAPPLICATOR_HPP_ */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.cpp b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.cpp index 8d0900adf38..81fa588d555 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.cpp @@ -975,6 +975,16 @@ void CompositionalMultiphaseBase::initializeFluidState( MeshLevel & mesh, { chopNegativeDensities( subRegion ); } + + // IMPORTANT: After computing compDens (the primary variables for ComponentDensities formulation), + // we must update the fluid state to ensure all fluid properties are consistent with compDens. + // This is crucial because: + // 1. updateFluidModel was called with compFrac to get totalDens + // 2. We then computed compDens = totalDens * compFrac + // 3. Now we need to recompute compFrac from compDens and update all fluid properties + // 4. Otherwise, the fluid properties will be inconsistent with the primary variables, + // leading to huge residuals on the first implicit step. + updateFluidState( subRegion ); } } ); @@ -1066,6 +1076,12 @@ void CompositionalMultiphaseBase::initializeFluidState( MeshLevel & mesh, //dispersionMaterial.saveConvergedVelocitySate( phaseVelovity ); } + // CRITICAL: Save the converged state to initialize the "_n" variables (compAmount_n, etc.) + // This is necessary for the first time step to compute the correct accumulation term. + // The accumulation is (compAmount - compAmount_n), and compAmount_n must be initialized + // to the initial state, otherwise the residual will be huge. + saveConvergedState( subRegion ); + } ); } @@ -1450,6 +1466,7 @@ void CompositionalMultiphaseBase::computeHydrostaticEquilibrium( DomainPartition RAJA::ReduceMin< parallelDeviceReduce, real64 > minPressure( LvArray::NumericLimits< real64 >::max ); arrayView3d< real64 const, constitutive::multifluid::USD_PHASE > pressureValuesView = pressureValues.toViewConst(); + arrayView4d< real64 const, constitutive::multifluid::USD_PHASE_COMP > phaseCompFracView = phaseCompFrac.toViewConst(); array1d< real64 > elevationBoundaries( numPhases ); array1d< integer > phaseIndexOrdering( numPhases ); @@ -1470,12 +1487,12 @@ void CompositionalMultiphaseBase::computeHydrostaticEquilibrium( DomainPartition phaseIndexOrdering[0] = ipWater; phaseIndexOrdering[1] = ipOil; } - if( ipOil < 0 ) + else if( ipOil < 0 ) { phaseIndexOrdering[0] = ipWater; phaseIndexOrdering[1] = ipGas; } - if( ipWater < 0 ) + else if( ipWater < 0 ) { phaseIndexOrdering[0] = ipOil; phaseIndexOrdering[1] = ipGas; @@ -1506,8 +1523,8 @@ void CompositionalMultiphaseBase::computeHydrostaticEquilibrium( DomainPartition numPointsInTable, elevationIndexTableWrapper, pressureValuesView, + phaseCompFracView, tempTableWrapper, - compFracTableWrappersViewConst, elevationsView, phaseIndexView] GEOS_HOST_DEVICE ( localIndex const i ) { @@ -1535,7 +1552,9 @@ void CompositionalMultiphaseBase::computeHydrostaticEquilibrium( DomainPartition temp[k] = tempTableWrapper.compute( &elevation ); for( integer ic = 0; ic < numComps; ++ic ) { - compFrac[k][ic] = compFracTableWrappersViewConst[ic].compute( &elevation ); + real64 const f0 = phaseCompFracView[en][0][phaseIndex][ic]; + real64 const f1 = phaseCompFracView[en+1][0][phaseIndex][ic]; + compFrac[k][ic] = (1.0-ea)*f0 + ea*f1; } minPressure.min( pres[k] ); } ); @@ -1546,60 +1565,43 @@ void CompositionalMultiphaseBase::computeHydrostaticEquilibrium( DomainPartition // For multiphase initialisation, after the computation of the pressure and composition, we invert // the capillary pressure curves to calculate new saturations. - if( !singlePhaseInitialisation ) - { - if( m_hasCapPressure ) + // This is only meaningful when a capillary pressure model is available; without one, there are no + // Pc curves to invert, so the compositions from the elevation tables are preserved. + if( !singlePhaseInitialisation && m_hasCapPressure ) + { + // Initialise porosity and permeability for capillary pressure computation + // This needs to happen before calling updateCapPressureModel + CellElementSubRegion * cellElemSubRegion = dynamicCast< CellElementSubRegion * >( &subRegion ); + if( cellElemSubRegion != nullptr ) { - // Initialise porosity and permeability for capillary pressure computaion - // This needs to happen before calling updateCapPressureModel - CellElementSubRegion * cellElemSubRegion = dynamicCast< CellElementSubRegion * >( &subRegion ); - if( cellElemSubRegion != nullptr ) - { - updatePorosityAndPermeability( *cellElemSubRegion ); - } + updatePorosityAndPermeability( *cellElemSubRegion ); + } - // initialized porosity - string const solidName = subRegion.template getReference< string >( viewKeyStruct::solidNamesString() ); - CoupledSolidBase const & porousSolid = getConstitutiveModel< CoupledSolidBase >( subRegion, solidName ); + // initialized porosity + string const solidName = subRegion.template getReference< string >( viewKeyStruct::solidNamesString() ); + CoupledSolidBase const & porousSolid = getConstitutiveModel< CoupledSolidBase >( subRegion, solidName ); - // initialized permeability - string const permeabilityName = subRegion.template getReference< string >( viewKeyStruct::permeabilityNamesString() ); - PermeabilityBase const & permeabilityMaterial = getConstitutiveModel< PermeabilityBase >( subRegion, permeabilityName ); + // initialized permeability + string const permeabilityName = subRegion.template getReference< string >( viewKeyStruct::permeabilityNamesString() ); + PermeabilityBase const & permeabilityMaterial = getConstitutiveModel< PermeabilityBase >( subRegion, permeabilityName ); - string const capPressureName = subRegion.template getReference< string >( viewKeyStruct::capPressureNamesString() ); - CapillaryPressureBase & capPressure = getConstitutiveModel< CapillaryPressureBase >( subRegion, capPressureName ); + string const capPressureName = subRegion.template getReference< string >( viewKeyStruct::capPressureNamesString() ); + CapillaryPressureBase & capPressure = getConstitutiveModel< CapillaryPressureBase >( subRegion, capPressureName ); - arrayView2d< real64 const > const porosity = porousSolid.getPorosity(); - arrayView3d< real64 const > const permeability = permeabilityMaterial.permeability(); - capPressure.initializeRockState( porosity, permeability ); - updateCapPressureModel( subRegion ); + arrayView2d< real64 const > const porosity = porousSolid.getPorosity(); + arrayView3d< real64 const > const permeability = permeabilityMaterial.permeability(); + capPressure.initializeRockState( porosity, permeability ); + updateCapPressureModel( subRegion ); - constitutiveUpdatePassThru( capPressure, [&] ( auto & castCapPressure ) - { - using CapPressureType = TYPEOFREF( castCapPressure ); - using KernelType = isothermalCompositionalMultiphaseBaseKernels::CapillaryPressureInversionKernel< CapPressureType >; - - isothermalCompositionalMultiphaseBaseKernels::KernelLaunchSelector2< KernelType >( numComps, - numPhases, - targetSet, - castCapPressure, - phaseOrder, - elemCenter, - elevationIndexTable.createKernelWrapper(), - pressureValues, - phaseDens, - phaseCompFrac, - compFrac ); - } ); - } - else + constitutiveUpdatePassThru( capPressure, [&] ( auto & castCapPressure ) { - using KernelType = isothermalCompositionalMultiphaseBaseKernels::CapillaryPressureInversionKernel< constitutive::NoOpCapillaryPressure >; - constitutive::NoOpCapillaryPressure noOpCapillaryPressure( numPhases, phaseOrder ); + using CapPressureType = TYPEOFREF( castCapPressure ); + using KernelType = isothermalCompositionalMultiphaseBaseKernels::CapillaryPressureInversionKernel< CapPressureType >; + isothermalCompositionalMultiphaseBaseKernels::KernelLaunchSelector2< KernelType >( numComps, numPhases, targetSet, - noOpCapillaryPressure, + castCapPressure, phaseOrder, elemCenter, elevationIndexTable.createKernelWrapper(), @@ -1607,7 +1609,7 @@ void CompositionalMultiphaseBase::computeHydrostaticEquilibrium( DomainPartition phaseDens, phaseCompFrac, compFrac ); - } + } ); } } ); } ); @@ -1681,6 +1683,37 @@ CompositionalMultiphaseBase::implicitStepSetup( real64 const & time_n, phaseVolFrac_n.setValues< parallelDevicePolicy<> >( phaseVolFrac ); } ); + + // For fracture elements newly created by SurfaceGenerator, deltaVolume holds the + // aperture * area volume contribution that has not yet been added to elementVolume. + // We apply it here (as SinglePhaseBase does) so that the accumulation kernel sees + // a non-zero pore volume for the new fracture cells. + mesh.getElemManager().forElementSubRegions< SurfaceElementSubRegion >( regionNames, + [&]( localIndex const, + SurfaceElementSubRegion & subRegion ) + { + applyDeltaVolume( subRegion ); + + // Save current hydraulic aperture as the reference aperture for this step + arrayView1d< real64 const > const aper = subRegion.getField< flow::hydraulicAperture >(); + arrayView1d< real64 > const aper0 = subRegion.getField< flow::aperture0 >(); + aper0.setValues< parallelDevicePolicy<> >( aper ); + + // Save the porous solid state (needed so that porosity_n is correct for new fracture elements) + CoupledSolidBase const & porousSolid = + getConstitutiveModel< CoupledSolidBase >( subRegion, subRegion.getReference< string >( viewKeyStruct::solidNamesString() ) ); + porousSolid.saveConvergedState(); + + // Re-run porosity/permeability and fluid state updates after deltaVolume is applied, + // then save the converged state so that compAmount_n reflects the updated volume. + // IMPORTANT: saveConvergedState must be called AFTER updateFluidState so that + // compAmount_n = porosity * newVolume * compDens, matching compAmount at Newton iter 0. + updatePorosityAndPermeability( subRegion ); + updateFluidState( subRegion ); + saveConvergedState( subRegion ); + + } ); + } ); } diff --git a/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.cpp b/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.cpp index bbc5a8466c3..bf63134e49d 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.cpp @@ -581,6 +581,17 @@ void FlowSolverBase::initializeHydraulicAperture( MeshLevel & mesh, string_array } ); } +void FlowSolverBase::applyDeltaVolume( ElementSubRegionBase & subRegion ) const +{ + arrayView1d< real64 > const dVol = subRegion.template getField< flow::deltaVolume >(); + arrayView1d< real64 > const vol = subRegion.template getReference< array1d< real64 > >( CellElementSubRegion::viewKeyStruct::elementVolumeString() ); + forAll< parallelDevicePolicy<> >( subRegion.size(), [=] GEOS_HOST_DEVICE ( localIndex const ei ) + { + vol[ei] += dVol[ei]; + dVol[ei] = 0.0; + } ); +} + void FlowSolverBase::saveInitialPressureAndTemperature( MeshLevel & mesh, string_array const & regionNames ) { mesh.getElemManager().forElementSubRegions( regionNames, [&]( localIndex const, diff --git a/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.hpp b/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.hpp index 8b68a5fad08..0e709372102 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.hpp @@ -203,6 +203,14 @@ class FlowSolverBase : public PhysicsSolverBase integer numberOfDofsPerCell() const { return m_numDofPerCell; } + /** + * @brief Apply the delta volume to the element volume and reset delta volume to zero + * @detail This is needed for newly created fracture elements that have a non-zero deltaVolume + * (set by SurfaceGenerator) but zero element volume. + * @param[in/out] subRegion the element subRegion + */ + void applyDeltaVolume( ElementSubRegionBase & subRegion ) const; + protected: /** diff --git a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseBase.cpp b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseBase.cpp index 71288417c49..7c1521128b7 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseBase.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseBase.cpp @@ -1379,15 +1379,4 @@ void SinglePhaseBase::saveConvergedState( ElementSubRegionBase & subRegion ) con mass_n.setValues< parallelDevicePolicy<> >( mass ); } -void SinglePhaseBase::applyDeltaVolume( ElementSubRegionBase & subRegion ) const -{ - arrayView1d< real64 > const dVol = subRegion.template getField< flow::deltaVolume >(); - arrayView1d< real64 > const vol = subRegion.template getReference< array1d< real64 > >( CellElementSubRegion::viewKeyStruct::elementVolumeString()); - forAll< parallelDevicePolicy<> >( subRegion.size(), [=] GEOS_HOST_DEVICE ( localIndex const ei ) - { - vol[ei] += dVol[ei]; - dVol[ei] = 0.0; - } ); -} - } /* namespace geos */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseBase.hpp b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseBase.hpp index 87ff12f39f7..4d01e0a5370 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseBase.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseBase.hpp @@ -362,8 +362,6 @@ class SinglePhaseBase : public FlowSolverBase CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) const; - void applyDeltaVolume( ElementSubRegionBase & subRegion ) const; - protected: /** diff --git a/src/coreComponents/physicsSolvers/multiphysics/PoromechanicsInitialization.cpp b/src/coreComponents/physicsSolvers/multiphysics/PoromechanicsInitialization.cpp index e69755df04d..40cb0eaba82 100644 --- a/src/coreComponents/physicsSolvers/multiphysics/PoromechanicsInitialization.cpp +++ b/src/coreComponents/physicsSolvers/multiphysics/PoromechanicsInitialization.cpp @@ -59,6 +59,11 @@ PoromechanicsInitialization( const string & name, setApplyDefaultValue( "" ). setDescription( "Name of the solid mechanics statistics" ); + registerWrapper( viewKeyStruct::resetDisplacementsString(), &m_resetDisplacements ). + setInputFlag( InputFlags::OPTIONAL ). + setApplyDefaultValue( 1 ). + setDescription( "Flag to reset displacements (1: reset, 0: do not reset)" ); + addLogLevel< logInfo::SolverInitialization >(); } @@ -113,7 +118,10 @@ execute( real64 const time_n, getName(), time_n, m_poromechanicsSolverName ) ); m_poromechanicsSolver->setStressInitialization( true ); - m_solidMechanicsStateResetTask.execute( time_n, dt, cycleNumber, eventCounter, eventProgress, domain ); + if( m_resetDisplacements ) + { + m_solidMechanicsStateResetTask.execute( time_n, dt, cycleNumber, eventCounter, eventProgress, domain ); + } m_poromechanicsSolver->flowSolver()->initializeState( domain ); m_poromechanicsSolver->updateBulkDensity( domain ); @@ -128,7 +136,10 @@ execute( real64 const time_n, m_solidMechanicsStatistics->execute( time_n, dt, cycleNumber, eventCounter, eventProgress, domain ); } - m_solidMechanicsStateResetTask.execute( time_n, dt, cycleNumber, eventCounter, eventProgress, domain ); + if( m_resetDisplacements ) + { + m_solidMechanicsStateResetTask.execute( time_n, dt, cycleNumber, eventCounter, eventProgress, domain ); + } // always returns false because we don't want early return (see EventManager.cpp) return false; diff --git a/src/coreComponents/physicsSolvers/multiphysics/PoromechanicsInitialization.hpp b/src/coreComponents/physicsSolvers/multiphysics/PoromechanicsInitialization.hpp index 9a6d06ed454..4b6363b069f 100644 --- a/src/coreComponents/physicsSolvers/multiphysics/PoromechanicsInitialization.hpp +++ b/src/coreComponents/physicsSolvers/multiphysics/PoromechanicsInitialization.hpp @@ -87,6 +87,8 @@ class PoromechanicsInitialization : public TaskBase constexpr static char const * poromechanicsSolverNameString() { return "poromechanicsSolverName"; } /// String for the solid mechanics statistics name constexpr static char const * solidMechanicsStatisticsNameString() { return "solidMechanicsStatisticsName"; } + /// String for the displacement reset flag + constexpr static char const * resetDisplacementsString() { return "reset_displacements"; } }; void postInputInitialization() override; @@ -105,6 +107,9 @@ class PoromechanicsInitialization : public TaskBase SolidMechanicsStateReset m_solidMechanicsStateResetTask; + /// Flag for resetting displacements (and velocities) + integer m_resetDisplacements; + }; diff --git a/src/coreComponents/physicsSolvers/solidMechanics/CMakeLists.txt b/src/coreComponents/physicsSolvers/solidMechanics/CMakeLists.txt index ced15c47ba5..483615ce5e8 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/CMakeLists.txt +++ b/src/coreComponents/physicsSolvers/solidMechanics/CMakeLists.txt @@ -36,6 +36,7 @@ set( solidMechanicsSolvers_headers kernels/ImplicitSmallStrainNewmark_impl.hpp kernels/ImplicitSmallStrainQuasiStatic.hpp kernels/ImplicitSmallStrainQuasiStatic_impl.hpp + SolidMechanicsInitialization.hpp SolidMechanicsStateReset.hpp SolidMechanicsStatistics.hpp contact/ContactSolverBase.hpp @@ -62,6 +63,7 @@ set( solidMechanicsSolvers_headers set( solidMechanicsSolvers_sources SolidMechanicsLagrangianFEM.cpp SolidMechanicsMPM.cpp + SolidMechanicsInitialization.cpp SolidMechanicsStateReset.cpp SolidMechanicsStatistics.cpp contact/ContactSolverBase.cpp @@ -112,4 +114,4 @@ install( TARGETS solidMechanicsSolvers LIBRARY DESTINATION ${CMAKE_INSTALL_PREFI if( externalComponentDeps ) target_include_directories( solidMechanicsSolvers PUBLIC ${CMAKE_SOURCE_DIR}/externalComponents ) -endif() \ No newline at end of file +endif() diff --git a/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsInitialization.cpp b/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsInitialization.cpp new file mode 100644 index 00000000000..19fca8f4c4f --- /dev/null +++ b/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsInitialization.cpp @@ -0,0 +1,150 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 SolidMechanicsInitialization.cpp + */ + +#include "SolidMechanicsInitialization.hpp" + +#include "events/tasks/TasksManager.hpp" +#include "physicsSolvers/solidMechanics/SolidMechanicsStatistics.hpp" +#include "physicsSolvers/solidMechanics/SolidMechanicsLagrangianFEM.hpp" +#include "physicsSolvers/solidMechanics/contact/SolidMechanicsLagrangeContact.hpp" +#include "physicsSolvers/solidMechanics/contact/SolidMechanicsEmbeddedFractures.hpp" +#include "physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.hpp" +#include "physicsSolvers/LogLevelsInfo.hpp" + +namespace geos +{ + +using namespace dataRepository; + +template< typename SOLID_SOLVER > +SolidMechanicsInitialization< SOLID_SOLVER >::SolidMechanicsInitialization( const string & name, + Group * const parent ): + TaskBase( name, parent ), + m_solidSolverName(), + m_solidMechanicsStatisticsName(), + m_solidSolver( nullptr ), + m_solidMechanicsStatistics( nullptr ), + m_solidMechanicsStateResetTask( name, parent ) +{ + registerWrapper( viewKeyStruct::solidSolverNameString(), &m_solidSolverName ). + setRTTypeName( rtTypes::CustomTypes::groupNameRef ). + setInputFlag( InputFlags::REQUIRED ). + setDescription( "Name of the solid mechanics solver" ); + + registerWrapper( viewKeyStruct::solidMechanicsStatisticsNameString(), &m_solidMechanicsStatisticsName ). + setRTTypeName( rtTypes::CustomTypes::groupNameRef ). + setInputFlag( InputFlags::OPTIONAL ). + setApplyDefaultValue( "" ). + setDescription( "Name of the solid mechanics statistics task" ); + + registerWrapper( viewKeyStruct::resetDisplacementsString(), &m_resetDisplacements ). + setInputFlag( InputFlags::OPTIONAL ). + setApplyDefaultValue( 1 ). + setDescription( "Flag to reset displacements (1: reset, 0: do not reset)" ); + + addLogLevel< logInfo::SolverInitialization >(); +} + +template< typename SOLID_SOLVER > +SolidMechanicsInitialization< SOLID_SOLVER >::~SolidMechanicsInitialization() = default; + +template< typename SOLID_SOLVER > +void SolidMechanicsInitialization< SOLID_SOLVER >::postInputInitialization() +{ + Group & problemManager = this->getGroupByPath( "/Problem" ); + Group & physicsSolverManager = problemManager.getGroup( "Solvers" ); + + GEOS_THROW_IF( !physicsSolverManager.hasGroup( m_solidSolverName ), + GEOS_FMT( "{}: {} solver named {} not found", + getWrapperDataContext( viewKeyStruct::solidSolverNameString() ), + SOLID_SOLVER::catalogName(), + m_solidSolverName ), + InputError, getWrapperDataContext( viewKeyStruct::solidSolverNameString() ) ); + + m_solidSolver = &physicsSolverManager.getGroup< SOLID_SOLVER >( m_solidSolverName ); + + if( !m_solidMechanicsStatisticsName.empty() ) + { + TasksManager & tasksManager = problemManager.getGroup< TasksManager >( "Tasks" ); + + GEOS_THROW_IF( !tasksManager.hasGroup( m_solidMechanicsStatisticsName ), + GEOS_FMT( "{}: {} task named {} not found", + getWrapperDataContext( viewKeyStruct::solidMechanicsStatisticsNameString() ), + SolidMechanicsStatistics::catalogName(), + m_solidMechanicsStatisticsName ), + InputError, getWrapperDataContext( viewKeyStruct::solidMechanicsStatisticsNameString() ) ); + + m_solidMechanicsStatistics = &tasksManager.getGroup< SolidMechanicsStatistics >( m_solidMechanicsStatisticsName ); + } + + m_solidMechanicsStateResetTask.setLogLevel( getLogLevel() ); + m_solidMechanicsStateResetTask.m_solidSolverName = m_solidSolverName; + m_solidMechanicsStateResetTask.postInputInitialization(); +} + +template< typename SOLID_SOLVER > +bool SolidMechanicsInitialization< SOLID_SOLVER >::execute( real64 const time_n, + real64 const dt, + integer const cycleNumber, + integer const eventCounter, + real64 const eventProgress, + DomainPartition & domain ) +{ + GEOS_LOG_LEVEL_RANK_0( logInfo::SolverInitialization, + GEOS_FMT( "Task `{}`: at time {}s, solid solver `{}` is set to perform stress initialization during the next time step(s)", + getName(), time_n, m_solidSolverName ) ); + + m_solidSolver->setStressInitialization( true ); + if( m_resetDisplacements ) + { + m_solidMechanicsStateResetTask.execute( time_n, dt, cycleNumber, eventCounter, eventProgress, domain ); + } + m_solidSolver->execute( time_n, dt, cycleNumber, eventCounter, eventProgress, domain ); + + GEOS_LOG_LEVEL_RANK_0( logInfo::SolverInitialization, + GEOS_FMT( "Task `{}`: at time {}s, solid solver `{}` has completed stress initialization", + getName(), time_n + dt, m_solidSolverName ) ); + m_solidSolver->setStressInitialization( false ); + + if( m_solidMechanicsStatistics != nullptr ) + { + m_solidMechanicsStatistics->execute( time_n, dt, cycleNumber, eventCounter, eventProgress, domain ); + } + + if( m_resetDisplacements ) + { + m_solidMechanicsStateResetTask.execute( time_n, dt, cycleNumber, eventCounter, eventProgress, domain ); + } + + return false; +} + +namespace +{ +typedef SolidMechanicsInitialization< SolidMechanicsLagrangianFEM > SolidMechanicsLagrangianFEMInitialization; +typedef SolidMechanicsInitialization< SolidMechanicsLagrangeContact > SolidMechanicsLagrangeContactInitialization; +typedef SolidMechanicsInitialization< SolidMechanicsAugmentedLagrangianContact > SolidMechanicsAugmentedLagrangianContactInitialization; +typedef SolidMechanicsInitialization< SolidMechanicsEmbeddedFractures > SolidMechanicsEmbeddedFracturesInitialization; +REGISTER_CATALOG_ENTRY( TaskBase, SolidMechanicsLagrangianFEMInitialization, string const &, Group * const ) +REGISTER_CATALOG_ENTRY( TaskBase, SolidMechanicsLagrangeContactInitialization, string const &, Group * const ) +REGISTER_CATALOG_ENTRY( TaskBase, SolidMechanicsAugmentedLagrangianContactInitialization, string const &, Group * const ) +REGISTER_CATALOG_ENTRY( TaskBase, SolidMechanicsEmbeddedFracturesInitialization, string const &, Group * const ) +} + +} /* namespace geos */ diff --git a/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsInitialization.hpp b/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsInitialization.hpp new file mode 100644 index 00000000000..f13f333920f --- /dev/null +++ b/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsInitialization.hpp @@ -0,0 +1,81 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 SolidMechanicsInitialization.hpp + */ + +#ifndef SRC_CORECOMPONENTS_PHYSICSSOLVERS_SOLIDMECHANICS_SOLIDMECHANICSINITIALIZATION_HPP_ +#define SRC_CORECOMPONENTS_PHYSICSSOLVERS_SOLIDMECHANICS_SOLIDMECHANICSINITIALIZATION_HPP_ + +#include "events/tasks/TaskBase.hpp" +#include "physicsSolvers/solidMechanics/SolidMechanicsStateReset.hpp" + +namespace geos +{ +class SolidMechanicsStatistics; + +/** + * @class SolidMechanicsInitialization + * + * Task class used to perform stress initialization in solid mechanics-only simulations. + */ +template< typename SOLID_SOLVER > +class SolidMechanicsInitialization : public TaskBase +{ +public: + + SolidMechanicsInitialization( const string & name, + Group * const parent ); + + ~SolidMechanicsInitialization() override; + + static string catalogName() + { + return SOLID_SOLVER::catalogName() + "Initialization"; + } + + virtual bool execute( real64 const time_n, + real64 const dt, + integer const cycleNumber, + integer const eventCounter, + real64 const eventProgress, + DomainPartition & domain ) override; + +private: + + struct viewKeyStruct + { + constexpr static char const * solidSolverNameString() { return "solidSolverName"; } + constexpr static char const * solidMechanicsStatisticsNameString() { return "solidMechanicsStatisticsName"; } + constexpr static char const * resetDisplacementsString() { return "reset_displacements"; } + }; + + void postInputInitialization() override; + + string m_solidSolverName; + string m_solidMechanicsStatisticsName; + + SOLID_SOLVER * m_solidSolver; + SolidMechanicsStatistics * m_solidMechanicsStatistics; + + SolidMechanicsStateReset m_solidMechanicsStateResetTask; + + integer m_resetDisplacements; +}; + +} + +#endif /* SRC_CORECOMPONENTS_PHYSICSSOLVERS_SOLIDMECHANICS_SOLIDMECHANICSINITIALIZATION_HPP_ */ diff --git a/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsStateReset.hpp b/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsStateReset.hpp index 4a9c5219038..a47c9fdeb89 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsStateReset.hpp +++ b/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsStateReset.hpp @@ -43,6 +43,7 @@ class SolidMechanicsLagrangianFEM; class SolidMechanicsStateReset : public TaskBase { template< typename > friend class PoromechanicsInitialization; + template< typename > friend class SolidMechanicsInitialization; public: diff --git a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp index 17b720bbd64..2e20a73cc3d 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp +++ b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp @@ -20,6 +20,7 @@ #include "SolidMechanicsAugmentedLagrangianContact.hpp" #include "physicsSolvers/fluidFlow/FlowSolverBase.hpp" +#include "physicsSolvers/fluidFlow/FlowSolverBaseFields.hpp" #include "physicsSolvers/solidMechanics/contact/kernels/SolidMechanicsConformingContactKernelsBase.hpp" #include "physicsSolvers/solidMechanics/contact/kernels/SolidMechanicsALMKernels.hpp" @@ -31,6 +32,7 @@ #include "physicsSolvers/solidMechanics/contact/kernels/SolidMechanicsPressureFaceBubbleKernels.hpp" #include "physicsSolvers/solidMechanics/contact/LogLevelsInfo.hpp" #include "physicsSolvers/solidMechanics/contact/ContactFields.hpp" +#include "physicsSolvers/solidMechanics/SolidMechanicsFields.hpp" #include "physicsSolvers/LogLevelsInfo.hpp" #include "constitutive/contact/FrictionSelector.hpp" #include "constitutive/solid/PorousSolid.hpp" @@ -159,6 +161,15 @@ void SolidMechanicsAugmentedLagrangianContact::registerDataOnMesh( dataRepositor setRegisteringObjects( getName()). setDescription( "An array that stores the displacement jumps used to update the penalty coefficients." ). reference().resizeDimension< 1 >( 3 ); + + // Register pressure fields for sequential poromechanics coupling and stress initialization + // In coupled poromechanics, the flow solver will overwrite these with actual values + subRegion.registerField< flow::pressure >( getName() ). + setApplyDefaultValue( 0.0 ). + setPlotLevel( PlotLevel::NOPLOT ); + subRegion.registerField< flow::pressure_n >( getName() ). + setApplyDefaultValue( 0.0 ). + setPlotLevel( PlotLevel::NOPLOT ); } ); } ); @@ -252,6 +263,41 @@ void SolidMechanicsAugmentedLagrangianContact::setupSystem( DomainPartition & do GEOS_MARK_FUNCTION; + // Recompute geometric quantities (face normals, areas) after mesh topology changes. + // This is critical for distorted/non-axis-aligned meshes and after fracture events. + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & ) + { + NodeManager const & nodeManager = mesh.getNodeManager(); + FaceManager & faceManager = mesh.getFaceManager(); + ElementRegionManager & elemManager = mesh.getElemManager(); + + // Recompute face geometry (normals and areas) + faceManager.computeGeometry( nodeManager ); + + // Recompute element geometry for volume elements (centers and volumes) + elemManager.forElementSubRegions< CellElementSubRegion >( [&]( CellElementSubRegion & subRegion ) + { + subRegion.calculateElementGeometricQuantities( nodeManager, faceManager ); + } ); + + // Recompute element geometry for face elements (uses updated face areas) + elemManager.forElementSubRegions< FaceElementSubRegion >( [&]( FaceElementSubRegion & subRegion ) + { + subRegion.calculateElementGeometricQuantities( nodeManager, faceManager ); + + // Reorder kf1 nodes to match kf0 for conforming contact kernels. + // flipFaceMap and fixNeighboringFacesNormals are already called by + // ProblemManager::applyNumericalMethods after ghosting is complete. + if( subRegion.size() > 0 ) + { + subRegion.fixNeighboringFacesNormals( faceManager, elemManager ); + subRegion.orderKf1NodesConsistentlyWithKf0( faceManager, nodeManager ); + } + } ); + } ); + // Create the lists of interface elements that have same type. createFaceTypeList( domain ); @@ -364,6 +410,15 @@ void SolidMechanicsAugmentedLagrangianContact::implicitStepSetup( real64 const & // Set the tollerances computeTolerances( domain ); + // Initialize the traction from the stress in adjacent volume elements. + // This is only done during stress initialization step to ensure the ALM solver + // starts with a physically consistent traction rather than zero. + // On subsequent time steps, the traction from the previous step is preserved. + if( m_performStressInitialization ) + { + initializeTractionFromAdjacentCellStress( domain ); + } + // Set array to update penalty coefficients arrayView2d< real64 > const dispJumpUpdPenalty = subRegion.getReference< array2d< real64 > >( viewKeyStruct::dispJumpUpdPenaltyString() ); @@ -416,6 +471,12 @@ void SolidMechanicsAugmentedLagrangianContact::implicitStepSetup( real64 const & fieldsToBeSync.addElementFields( { contact::iterativePenalty::key() }, { getUniqueFractureRegionName() } ); + // Synchronize bubble displacement fields to ensure ghost values are initialized + // This prevents race conditions when computing residuals in parallel + fieldsToBeSync.addFields( FieldLocation::Face, + { contact::incrementalBubbleDisplacement::key(), + contact::totalBubbleDisplacement::key() } ); + CommunicationTools::getInstance().synchronizeFields( fieldsToBeSync, mesh, domain.getNeighbors(), @@ -737,46 +798,42 @@ void SolidMechanicsAugmentedLagrangianContact::implicitStepComplete( real64 cons SolidMechanicsLagrangianFEM::implicitStepComplete( time_n, dt, domain ); - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & ) + forFractureRegionOnMeshTargets( domain.getMeshBodies(), [&] ( SurfaceElementRegion & fractureRegion ) { - ElementRegionManager & elemManager = mesh.getElemManager(); - SurfaceElementRegion & region = elemManager.getRegion< SurfaceElementRegion >( getUniqueFractureRegionName() ); - FaceElementSubRegion & subRegion = region.getUniqueSubRegion< FaceElementSubRegion >(); - - arrayView2d< real64 const > const dispJump = subRegion.getField< contact::dispJump >(); - arrayView2d< real64 > const oldDispJump = subRegion.getField< contact::oldDispJump >(); - arrayView2d< real64 > const deltaDispJump = subRegion.getField< contact::deltaDispJump >(); + fractureRegion.forElementSubRegions< FaceElementSubRegion >( [&]( FaceElementSubRegion & subRegion ) + { + arrayView2d< real64 const > const dispJump = subRegion.getField< contact::dispJump >(); + arrayView2d< real64 > const oldDispJump = subRegion.getField< contact::oldDispJump >(); + arrayView2d< real64 > const deltaDispJump = subRegion.getField< contact::deltaDispJump >(); - arrayView2d< real64 > const traction = subRegion.getField< contact::traction >(); + arrayView2d< real64 > const traction = subRegion.getField< contact::traction >(); - arrayView1d< integer const > const fractureState = subRegion.getField< contact::fractureState >(); - arrayView1d< integer > const oldFractureState = subRegion.getField< contact::oldFractureState >(); + arrayView1d< integer const > const fractureState = subRegion.getField< contact::fractureState >(); + arrayView1d< integer > const oldFractureState = subRegion.getField< contact::oldFractureState >(); - arrayView1d< real64 > const slip = subRegion.getField< contact::slip >(); - arrayView1d< real64 > const tangentialTraction = subRegion.getField< contact::tangentialTraction >(); + arrayView1d< real64 > const slip = subRegion.getField< contact::slip >(); + arrayView1d< real64 > const tangentialTraction = subRegion.getField< contact::tangentialTraction >(); - forAll< parallelDevicePolicy<> >( subRegion.size(), - [ = ] - GEOS_HOST_DEVICE ( localIndex const kfe ) - { - // Compute the slip - real64 const deltaDisp[2] = { deltaDispJump[kfe][1], - deltaDispJump[kfe][2] }; - slip[kfe] = LvArray::tensorOps::l2Norm< 2 >( deltaDisp ); + forAll< parallelDevicePolicy<> >( subRegion.size(), + [ = ] + GEOS_HOST_DEVICE ( localIndex const kfe ) + { + // Compute the slip + real64 const deltaDisp[2] = { deltaDispJump[kfe][1], + deltaDispJump[kfe][2] }; + slip[kfe] = LvArray::tensorOps::l2Norm< 2 >( deltaDisp ); - // Compute current Tau and limit Tau - real64 const tau[2] = { traction[kfe][1], - traction[kfe][2] }; - tangentialTraction[kfe] = LvArray::tensorOps::l2Norm< 2 >( tau ); + // Compute current Tau and limit Tau + real64 const tau[2] = { traction[kfe][1], + traction[kfe][2] }; + tangentialTraction[kfe] = LvArray::tensorOps::l2Norm< 2 >( tau ); - LvArray::tensorOps::fill< 3 >( deltaDispJump[kfe], 0.0 ); - LvArray::tensorOps::copy< 3 >( oldDispJump[kfe], dispJump[kfe] ); - oldFractureState[kfe] = fractureState[kfe]; + LvArray::tensorOps::fill< 3 >( deltaDispJump[kfe], 0.0 ); + LvArray::tensorOps::copy< 3 >( oldDispJump[kfe], dispJump[kfe] ); + oldFractureState[kfe] = fractureState[kfe]; + } ); } ); - } ); } @@ -871,6 +928,7 @@ real64 SolidMechanicsAugmentedLagrangianContact::calculateResidualNorm( real64 c } MpiWrapper::bcast( globalResidualNorm, 2, 0, MPI_COMM_GEOS ); + } ); real64 const bubbleResidualNorm = sqrt( globalResidualNorm[0] )/(globalResidualNorm[1]+1); // the + 1 is for the first @@ -1272,6 +1330,11 @@ void SolidMechanicsAugmentedLagrangianContact::updateStickSlipList( DomainPartit arrayView1d< integer const > const fractureState = subRegion.getField< contact::fractureState >(); + // Ensure the stick/slip maps contain an entry for this mesh even when + // the fracture face type map is empty (no fracture elements). + m_faceTypesToFaceElementsStick.get_inserted( meshName ); + m_faceTypesToFaceElementsSlip.get_inserted( meshName ); + forFiniteElementOnFractureSubRegions( meshName, [&] ( string const & finiteElementName, finiteElement::FiniteElementBase const &, arrayView1d< localIndex const > const & faceElementList ) @@ -1362,6 +1425,14 @@ void SolidMechanicsAugmentedLagrangianContact::createFaceTypeList( DomainPartiti SurfaceElementRegion const & region = elemManager.getRegion< SurfaceElementRegion >( getUniqueFractureRegionName() ); FaceElementSubRegion const & subRegion = region.getUniqueSubRegion< FaceElementSubRegion >(); + // When there are no fracture face elements, insert empty lists so that + // downstream .at( meshName ) lookups do not throw. + if( subRegion.size() == 0 ) + { + m_faceTypesToFaceElements.get_inserted( meshName ); + return; + } + arrayView2d< localIndex const > const elemsToFaces = subRegion.faceList().toViewConst(); array1d< localIndex > keys( subRegion.size()); @@ -1439,6 +1510,13 @@ void SolidMechanicsAugmentedLagrangianContact::createBubbleCellList( DomainParti SurfaceElementRegion const & region = elemManager.getRegion< SurfaceElementRegion >( getUniqueFractureRegionName() ); FaceElementSubRegion const & subRegion = region.getUniqueSubRegion< FaceElementSubRegion >(); + + // Nothing to do when there are no fracture face elements. + if( subRegion.size() == 0 ) + { + return; + } + // Array to store face indexes array1d< localIndex > tmpSpace( 2*subRegion.size()); SortedArray< localIndex > faceIdList; @@ -1459,6 +1537,9 @@ void SolidMechanicsAugmentedLagrangianContact::createBubbleCellList( DomainParti // Sort indexes to enable efficient searching using binary search. RAJA::stable_sort< parallelDevicePolicy<> >( tmpSpace_v ); + // Move data back to host: after the device sort the buffer lives on the GPU, + // but SortedArray::insert is a host-only operation that dereferences the iterators. + tmpSpace.move( LvArray::MemorySpace::host ); faceIdList.insert( tmpSpace_v.begin(), tmpSpace_v.end()); // Search for bubble element on each CellElementSubRegion and @@ -1480,6 +1561,9 @@ void SolidMechanicsAugmentedLagrangianContact::createBubbleCellList( DomainParti arrayView1d< localIndex > const perms_v = perms.toView(); arrayView1d< localIndex > const vals_v = vals.toView(); arrayView1d< localIndex > const localFaceIds_v = localFaceIds.toView(); + // Move faceIdList to device so that the SortedArrayView can be safely + // accessed inside the GPU kernel (faceIdList was populated on the host). + faceIdList.move( parallelDeviceMemorySpace ); SortedArrayView< localIndex const > const faceIdList_v = faceIdList.toViewConst(); forAll< parallelDevicePolicy<> >( cellElementSubRegion.size(), @@ -1526,7 +1610,16 @@ void SolidMechanicsAugmentedLagrangianContact::createBubbleCellList( DomainParti { bubbleElemsList_v[k] = keys_v[k]; } ); - cellElementSubRegion.setBubbleElementsList( bubbleElemsList.toViewConst()); + + // Get reference to the persistent storage and copy data to avoid dangling pointers + array1d< localIndex > & bubbleCellsStorage = + cellElementSubRegion.getReference< array1d< localIndex > >( CellElementSubRegion::viewKeyStruct::bubbleCellsString() ); + bubbleCellsStorage.resize( nBubElems ); + arrayView1d< localIndex > const bubbleCellsStorage_v = bubbleCellsStorage.toView(); + forAll< parallelDevicePolicy<> >( nBubElems, [ = ] GEOS_HOST_DEVICE ( localIndex const k ) + { + bubbleCellsStorage_v[k] = bubbleElemsList_v[k]; + } ); forAll< parallelDevicePolicy<> >( n_max, [ = ] GEOS_HOST_DEVICE ( localIndex const k ) { @@ -1546,7 +1639,17 @@ void SolidMechanicsAugmentedLagrangianContact::createBubbleCellList( DomainParti faceElemsList_v[k][0] = elemsToFaces[kfe][keys_v[k]]; faceElemsList_v[k][1] = keys_v[k]; } ); - cellElementSubRegion.setFaceElementsList( faceElemsList.toViewConst()); + + // Get reference to the persistent storage and copy data to avoid dangling pointers + array2d< localIndex > & faceElemsStorage = + cellElementSubRegion.getReference< array2d< localIndex > >( CellElementSubRegion::viewKeyStruct::toFaceElementsString() ); + faceElemsStorage.resize( nBubElems, 2 ); + arrayView2d< localIndex > const faceElemsStorage_v = faceElemsStorage.toView(); + forAll< parallelDevicePolicy<> >( nBubElems, [ = ] GEOS_HOST_DEVICE ( localIndex const k ) + { + faceElemsStorage_v[k][0] = faceElemsList_v[k][0]; + faceElemsStorage_v[k][1] = faceElemsList_v[k][1]; + } ); } ); @@ -1825,7 +1928,6 @@ void SolidMechanicsAugmentedLagrangianContact::computeTolerances( DomainPartitio string_array const & ) { FaceManager const & faceManager = mesh.getFaceManager(); - NodeManager const & nodeManager = mesh.getNodeManager(); ElementRegionManager & elemManager = mesh.getElemManager(); // Get the "face to element" map (valid for the entire mesh) @@ -1838,9 +1940,6 @@ void SolidMechanicsAugmentedLagrangianContact::computeTolerances( DomainPartitio ElementRegionManager::ElementViewAccessor< arrayView1d< real64 const > > const elemVolume = elemManager.constructViewAccessor< array1d< real64 >, arrayView1d< real64 const > >( ElementSubRegionBase::viewKeyStruct::elementVolumeString() ); - // Get the coordinates for all nodes - arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const nodePosition = nodeManager.referencePosition(); - // Bulk modulus accessor ElementRegionManager::ElementViewAccessor< arrayView1d< real64 const > > const bulkModulus = elemManager.constructMaterialViewAccessor< ElasticIsotropic, array1d< real64 >, arrayView1d< real64 const > >( fields::solid::bulkModulus::key() ); @@ -1851,7 +1950,6 @@ void SolidMechanicsAugmentedLagrangianContact::computeTolerances( DomainPartitio using NodeMapViewType = arrayView2d< localIndex const, cells::NODE_MAP_USD >; ElementRegionManager::ElementViewAccessor< NodeMapViewType > const elemToNode = elemManager.constructViewAccessor< CellElementSubRegion::NodeMapType, NodeMapViewType >( ElementSubRegionBase::viewKeyStruct::nodeListString() ); - ElementRegionManager::ElementViewConst< NodeMapViewType > const elemToNodeView = elemToNode.toNestedViewConst(); elemManager.forElementSubRegions< FaceElementSubRegion >( [&]( FaceElementSubRegion & subRegion ) { @@ -1886,7 +1984,7 @@ void SolidMechanicsAugmentedLagrangianContact::computeTolerances( DomainPartitio real64 stiffDiagApprox[ 2 ][ 3 ]; real64 averageYoungModulus = 0.0; real64 averageConstrainedModulus = 0.0; - real64 averageBoxSize0 = 0.0; + real64 averageCharLength = 0.0; for( localIndex i = 0; i < 2; ++i ) { @@ -1897,33 +1995,6 @@ void SolidMechanicsAugmentedLagrangianContact::computeTolerances( DomainPartitio real64 const volume = elemVolume[er][esr][ei]; - // Get the "element to node" map for the specific region/subregion - NodeMapViewType const & cellElemsToNodes = elemToNodeView[er][esr]; - localIndex const numNodesPerElem = cellElemsToNodes.size( 1 ); - - // Compute the box size - real64 maxSize[3]; - real64 minSize[3]; - for( localIndex j = 0; j < 3; ++j ) - { - maxSize[j] = nodePosition[cellElemsToNodes[ei][0]][j]; - minSize[j] = nodePosition[cellElemsToNodes[ei][0]][j]; - } - for( localIndex a = 1; a < numNodesPerElem; ++a ) - { - for( localIndex j = 0; j < 3; ++j ) - { - maxSize[j] = fmax( maxSize[j], nodePosition[cellElemsToNodes[ei][a]][j] ); - minSize[j] = fmin( minSize[j], nodePosition[cellElemsToNodes[ei][a]][j] ); - } - } - - real64 boxSize[3]; - for( localIndex j = 0; j < 3; ++j ) - { - boxSize[j] = maxSize[j] - minSize[j]; - } - // Get linear elastic isotropic constitutive parameters for the element real64 const K = bulkModulus[er][esr][ei]; real64 const G = shearModulus[er][esr][ei]; @@ -1931,15 +2002,17 @@ void SolidMechanicsAugmentedLagrangianContact::computeTolerances( DomainPartitio real64 const nu = ( 3.0 * K - 2.0 * G ) / ( 2.0 * ( 3.0 * K + G ) ); real64 const M = K + 4.0 / 3.0 * G; + real64 const charLength = pow( volume, 1.0 / 3.0 ); + // Combine E and nu to obtain a stiffness approximation (like it was an hexahedron) for( localIndex j = 0; j < 3; ++j ) { - stiffDiagApprox[ i ][ j ] = E / ( ( 1.0 + nu )*( 1.0 - 2.0*nu ) ) * 4.0 / 9.0 * ( 2.0 - 3.0 * nu ) * volume / ( boxSize[j]*boxSize[j] ); + stiffDiagApprox[ i ][ j ] = E / ( ( 1.0 + nu )*( 1.0 - 2.0*nu ) ) * 4.0 / 9.0 * ( 2.0 - 3.0 * nu ) * charLength; } averageYoungModulus += 0.5*E; averageConstrainedModulus += 0.5*M; - averageBoxSize0 += 0.5*boxSize[0]; + averageCharLength += 0.5*charLength; } // Average the stiffness and compute the inverse @@ -1960,16 +2033,244 @@ void SolidMechanicsAugmentedLagrangianContact::computeTolerances( DomainPartitio normalDisplacementTolerance[kfe] = rotatedInvStiffApprox[ 0 ][ 0 ] * averageYoungModulus * m_tolJumpDispNFac; slidingTolerance[kfe] = sqrt( pow( rotatedInvStiffApprox[ 1 ][ 1 ], 2 ) + pow( rotatedInvStiffApprox[ 2 ][ 2 ], 2 )) * averageYoungModulus * m_tolJumpDispTFac; - normalTractionTolerance[kfe] = m_tolNormalTracFac * (averageConstrainedModulus / averageBoxSize0) * + normalTractionTolerance[kfe] = m_tolNormalTracFac * (averageConstrainedModulus / averageCharLength) * (normalDisplacementTolerance[kfe]); - iterativePenalty[kfe][0] = m_iterPenaltyNFac*averageConstrainedModulus/(averageBoxSize0); - iterativePenalty[kfe][1] = m_iterPenaltyTFac*averageConstrainedModulus/(averageBoxSize0); + iterativePenalty[kfe][0] = m_iterPenaltyNFac*averageConstrainedModulus/(averageCharLength); + iterativePenalty[kfe][1] = m_iterPenaltyTFac*averageConstrainedModulus/(averageCharLength); + } + } ); + } + } ); + } ); +} + +void SolidMechanicsAugmentedLagrangianContact::initializeTractionFromAdjacentCellStress( DomainPartition & domain ) const +{ + GEOS_MARK_FUNCTION; + + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & ) + { + FaceManager & faceManager = mesh.getFaceManager(); + ElementRegionManager & elemManager = mesh.getElemManager(); + + // Get the "face to element" map (valid for the entire mesh) + FaceManager::ElemMapType const & faceToElem = faceManager.toElementRelation(); + arrayView2d< localIndex const > const faceToElemRegion = faceToElem.m_toElementRegion; + arrayView2d< localIndex const > const faceToElemSubRegion = faceToElem.m_toElementSubRegion; + arrayView2d< localIndex const > const faceToElemIndex = faceToElem.m_toElementIndex; + + arrayView2d< real64 > totalBubbleDisplacement = faceManager.getField< contact::totalBubbleDisplacement >(); + + // Get stress accessor + ElementRegionManager::ElementViewAccessor< arrayView2d< real64 const, cells::RANK2_TENSOR_USD > > const avgElementStress = + elemManager.constructViewAccessor< array2d< real64, cells::RANK2_TENSOR_PERM >, + arrayView2d< real64 const, cells::RANK2_TENSOR_USD > >( solidMechanics::averageStress::key() ); + + elemManager.forElementSubRegions< FaceElementSubRegion >( [&]( FaceElementSubRegion & subRegion ) + { + if( subRegion.hasField< contact::traction >() ) + { + arrayView3d< real64 const > const faceRotationMatrix = subRegion.getField< contact::rotationMatrix >().toViewConst(); + arrayView2d< localIndex const > const elemsToFaces = subRegion.faceList().toViewConst(); + arrayView2d< real64 > const traction = subRegion.getField< contact::traction >(); + arrayView2d< real64 > const dispJump = subRegion.getField< contact::dispJump >(); + arrayView2d< real64 const > const iterativePenalty = subRegion.getField< contact::iterativePenalty >().toViewConst(); + arrayView1d< integer const > const ghostRank = subRegion.ghostRank(); + + // Get friction law parameters for Coulomb check + string const & frictionLawName = subRegion.template getReference< string >( viewKeyStruct::frictionLawNameString() ); + FrictionBase const & frictionLaw = getConstitutiveModel< FrictionBase >( subRegion, frictionLawName ); + + // Try to get Coulomb parameters if available + bool const hasCoulombParams = + frictionLaw.hasWrapper( CoulombFriction::viewKeyStruct::cohesionString() ) && + frictionLaw.hasWrapper( CoulombFriction::viewKeyStruct::frictionCoefficientString() ); + + real64 const cohesion = hasCoulombParams + ? frictionLaw.getReference< real64 >( CoulombFriction::viewKeyStruct::cohesionString() ) + : 0.0; + + real64 const frictionCoefficient = hasCoulombParams + ? frictionLaw.getReference< real64 >( CoulombFriction::viewKeyStruct::frictionCoefficientString() ) + : 0.0; + + forAll< parallelHostPolicy >( subRegion.size(), [=, &avgElementStress] ( localIndex const kfe ) + { + if( ghostRank[kfe] < 0 ) + { + // Each fracture element has two adjacent faces (one on each side of the fracture) + // We compute traction from each side and average them + real64 tGlobalAvg[3]{}; + real64 avgSigma[6]{}; + integer numValidCells{}; + + // Use the fracture element's normal from the rotation matrix (first column) + real64 const n[3]{ faceRotationMatrix( kfe, 0, 0 ), faceRotationMatrix( kfe, 1, 0 ), faceRotationMatrix( kfe, 2, 0 ) }; + + // Loop over both faces of the fracture element + for( localIndex faceIdx = 0; faceIdx < 2; ++faceIdx ) + { + localIndex const faceIndex = elemsToFaces( kfe, faceIdx ); + + // Get the adjacent volume element for this face + localIndex const er = faceToElemRegion( faceIndex, 0 ); + localIndex const esr = faceToElemSubRegion( faceIndex, 0 ); + localIndex const ei = faceToElemIndex( faceIndex, 0 ); + + // Skip if no valid stress data available + if( avgElementStress[er].empty() || avgElementStress[er][esr].empty() ) + { + continue; + } + + // Check principal stress components in 3D elements adjecent to the fracture element. + // If the maximun principal stress is tensile, issue an error. Principal stresses are + // sorted in ascending order + real64 principalStresses[3]; + LvArray::tensorOps::symEigenvalues< 3 >( principalStresses, avgElementStress[er][esr][ei] ); + GEOS_ERROR_IF( principalStresses[2] > 0.0, + GEOS_FMT( + "ERROR: Maximum principal stress is tensile in element adjacent to fracture element {} " + "connected to face {}. Principal stresses (sorted): ({:.6e}, {:.6e}, {:.6e})", + kfe, faceIdx, principalStresses[0], principalStresses[1], principalStresses[2] ) ); + + // Accumulate stress for averaging (for warning message) + LvArray::tensorOps::add< 6 >( avgSigma, avgElementStress[er][esr][ei] ); + + // Compute and accumulate traction in global coordinates: t = sigma * n + LvArray::tensorOps::Ri_add_symAijBj< 3 >( tGlobalAvg, avgElementStress[er][esr][ei], n ); + + ++numValidCells; + } + + // Average the tractions if we have valid data from both sides + if( numValidCells > 0 ) + { + real64 const invNumCells = 1.0 / static_cast< real64 >( numValidCells ); + LvArray::tensorOps::scale< 3 >( tGlobalAvg, invNumCells ); + LvArray::tensorOps::scale< 6 >( avgSigma, invNumCells ); + + // Rotate averaged traction to local coordinate system: t_local = R^T * t_global + real64 tLocal[3]; + LvArray::tensorOps::Ri_eq_AjiBj< 3, 3 >( tLocal, faceRotationMatrix[kfe], tGlobalAvg ); + + // Store the traction + LvArray::tensorOps::copy< 3 >( traction[kfe], tLocal ); + + // Update displacement jump based on penalty stiffness + real64 const kn = iterativePenalty[kfe][0]; + real64 const kt = iterativePenalty[kfe][1]; + real64 dJump[3] = { 0.0, 0.0, 0.0 }; + + if( kn > LvArray::NumericLimits< real64 >::min ) + { + dJump[0] = tLocal[0] / kn; + } + if( kt > LvArray::NumericLimits< real64 >::min ) + { + dJump[1] = tLocal[1] / kt; + dJump[2] = tLocal[2] / kt; + } + + dispJump[kfe][0] = dJump[0]; + dispJump[kfe][1] = dJump[1]; + dispJump[kfe][2] = dJump[2]; + + // Compute Global Bubble Displacement: b_global = R * [u]_local + real64 bGlobal[3]; + LvArray::tensorOps::Ri_eq_AijBj< 3, 3 >( bGlobal, faceRotationMatrix[kfe], dJump ); + + // Store to totalBubbleDisplacement for both faces + for( localIndex faceIdx = 0; faceIdx < 2; ++faceIdx ) + { + localIndex const faceIndex = elemsToFaces( kfe, faceIdx ); + totalBubbleDisplacement[faceIndex][0] = bGlobal[0]; + totalBubbleDisplacement[faceIndex][1] = bGlobal[1]; + totalBubbleDisplacement[faceIndex][2] = bGlobal[2]; + } + + // Check Coulomb friction consistency if parameters are available + if( hasCoulombParams ) + { + real64 const normalTraction = tLocal[0]; // Negative for compression + real64 const tangentialTraction = LvArray::math::sqrt( tLocal[1] * tLocal[1] + tLocal[2] * tLocal[2] ); + + // Coulomb criterion: |tau| <= cohesion - mu * sigma_n (sigma_n < 0 for compression) + // For open fracture (sigma_n > 0): no traction should be applied + real64 const tauLimit = cohesion - frictionCoefficient * normalTraction; + + bool isInvalid = false; + string reason; + + if( normalTraction > 0.0 ) + { + // Tensile normal traction - fracture should be open, no traction + isInvalid = true; + reason = "tensile normal traction (fracture should be open)"; + } + else if( tangentialTraction > tauLimit + 1.0e-10 * LvArray::math::abs( tauLimit ) ) + { + // Tangential traction exceeds Coulomb limit + isInvalid = true; + reason = "tangential traction exceeds Coulomb friction limit"; + } + + if( isInvalid ) + { + // Get tangent vectors from rotation matrix + real64 const t1[3]{ faceRotationMatrix( kfe, 0, 1 ), faceRotationMatrix( kfe, 1, 1 ), faceRotationMatrix( kfe, 2, 1 ) }; + real64 const t2[3]{ faceRotationMatrix( kfe, 0, 2 ), faceRotationMatrix( kfe, 1, 2 ), faceRotationMatrix( kfe, 2, 2 ) }; + + GEOS_LOG_RANK( GEOS_FMT( "WARNING: Stress state inconsistent with Coulomb friction law at fracture element {}.\n" + " Reason: {}\n" + " Friction parameters: cohesion = {:.6e}, friction coefficient = {:.6f}\n" + " Normal vector (global): n = ({:.6f}, {:.6f}, {:.6f})\n" + " Tangent vector 1 (global): t1 = ({:.6f}, {:.6f}, {:.6f})\n" + " Tangent vector 2 (global): t2 = ({:.6f}, {:.6f}, {:.6f})\n" + " Average stress from {} adjacent cell(s) (Voigt: XX, YY, ZZ, YZ, XZ, XY):\n" + " sigma = ({:.6e}, {:.6e}, {:.6e}, {:.6e}, {:.6e}, {:.6e})\n" + " Traction (local: normal, tangent1, tangent2):\n" + " t = ({:.6e}, {:.6e}, {:.6e})\n" + " Coulomb check: |tau| = {:.6e}, tau_limit = {:.6e}", + kfe, reason, + cohesion, frictionCoefficient, + n[0], n[1], n[2], + t1[0], t1[1], t1[2], + t2[0], t2[1], t2[2], + numValidCells, + avgSigma[0], avgSigma[1], avgSigma[2], avgSigma[3], avgSigma[4], avgSigma[5], + tLocal[0], tLocal[1], tLocal[2], + tangentialTraction, tauLimit ) ); + } + } + } } } ); } } ); } ); + + // Synchronize the traction, displacement jump, and bubble displacement fields + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & ) + { + FieldIdentifiers fieldsToBeSync; + fieldsToBeSync.addElementFields( { contact::traction::key(), + contact::dispJump::key() }, + { getUniqueFractureRegionName() } ); + + fieldsToBeSync.addFields( FieldLocation::Face, + { contact::totalBubbleDisplacement::key() } ); + + CommunicationTools::getInstance().synchronizeFields( fieldsToBeSync, + mesh, + domain.getNeighbors(), + true ); + } ); } REGISTER_CATALOG_ENTRY( PhysicsSolverBase, SolidMechanicsAugmentedLagrangianContact, string const &, Group * const ) diff --git a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.hpp b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.hpp index c3758556deb..02af0550280 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.hpp +++ b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.hpp @@ -246,6 +246,23 @@ class SolidMechanicsAugmentedLagrangianContact : public ContactSolverBase void computeTolerances( DomainPartition & domain ) const; + /** + * @brief Initialize the traction field from the stress in adjacent volume elements. + * @param domain The physical domain object + * + * This function computes the initial traction on each fracture element by: + * 1. Getting the stress tensor from both adjacent volume elements (one on each side of the fracture) + * 2. Computing the traction vector as t = sigma * n (where n is the face normal) for each side + * 3. Averaging the tractions from both sides + * 4. Rotating the averaged traction to the local coordinate system of the fracture + * 5. Validating the traction against the Coulomb friction law and warning if inconsistent + * + * This initialization ensures that the ALM traction field starts with a physically + * consistent value rather than zero, which is important for proper convergence + * when the domain is under stress. + */ + void initializeTractionFromAdjacentCellStress( DomainPartition & domain ) const; + /// Finite element type to face element index map stdMap< string, stdMap< string, array1d< localIndex > > > m_faceTypesToFaceElements; diff --git a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsLagrangeContact.cpp b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsLagrangeContact.cpp index 72716cbaef2..0227d3ee00c 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsLagrangeContact.cpp +++ b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsLagrangeContact.cpp @@ -136,12 +136,14 @@ void SolidMechanicsLagrangeContact::registerDataOnMesh( Group & meshBodies ) setRegisteringObjects( getName()). setDescription( "An array that holds the sliding tolerance." ); - // Needed just because SurfaceGenerator initialize the field "pressure" (NEEDED!!!) - // It is used in "TwoPointFluxApproximation.cpp", called by "SurfaceGenerator.cpp" + // Register pressure fields for sequential poromechanics coupling and stress initialization + // In coupled poromechanics, the flow solver will overwrite these with actual values subRegion.registerField< flow::pressure >( getName() ). + setApplyDefaultValue( 0.0 ). setPlotLevel( PlotLevel::NOPLOT ). setRegisteringObjects( getName()); subRegion.registerField< flow::pressure_n >( getName() ). + setApplyDefaultValue( 0.0 ). setPlotLevel( PlotLevel::NOPLOT ). setRegisteringObjects( getName()); @@ -910,8 +912,6 @@ SolidMechanicsLagrangeContact::createPreconditioner( DomainPartition & domain ) { blockParams.schurType = LinearSolverParameters::Block::SchurType::FirstBlockDiagonal; precond = std::make_unique< BlockPreconditioner< LAInterface > >( blockParams ); - // Using GEOSX implementation of Jacobi preconditioner - // tracPrecond = std::make_unique< PreconditionerJacobi< LAInterface > >(); // Using LAI implementation of Jacobi preconditioner LinearSolverParameters tracParams; @@ -944,11 +944,6 @@ SolidMechanicsLagrangeContact::createPreconditioner( DomainPartition & domain ) return precond; } - else - { - // Unomment to use GEOSX's implementations of Krylov solvers instead of LA backend's - //return SolverBase::createPreconditioner( domain ); - } return {}; } diff --git a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsLagrangeContactBubbleStab.cpp b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsLagrangeContactBubbleStab.cpp index d73fb84619a..eade6fcdebb 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsLagrangeContactBubbleStab.cpp +++ b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsLagrangeContactBubbleStab.cpp @@ -72,23 +72,6 @@ real64 SolidMechanicsLagrangeContactBubbleStab::solverStep( real64 const & time_ { fieldSpecificationManager.applyInitialConditions( mesh ); - // Would like to do it like this but it is not working. There is a cast in Object path that tries to cast - // all objects that derive from ElementSubRegionBase to the specified type so this obviously fails. - // fieldSpecificationManager.forSubGroups< FieldSpecificationBase >( [&] ( FieldSpecificationBase const & fs ) - // { - // if( fs.initialCondition() ) - // { - // fs.apply< SurfaceElementSubRegion >( mesh, - // [&]( FieldSpecificationBase const & bc, - // string const &, - // SortedArrayView< localIndex const > const & targetSet, - // SurfaceElementSubRegion & targetGroup, - // string const fieldName ) - // { - // bc.applyFieldValue< FieldSpecificationEqual >( targetSet, 0.0, targetGroup, fieldName ); - // } ); - // } - // } ); } ); } @@ -269,6 +252,24 @@ void SolidMechanicsLagrangeContactBubbleStab::setupSystem( DomainPartition & dom { // setup monolithic coupled system + // Ensure kf1 node ordering is consistent with kf0 for conforming contact kernels. + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & ) + { + NodeManager const & nodeManager = mesh.getNodeManager(); + FaceManager & faceManager = mesh.getFaceManager(); + ElementRegionManager & elemManager = mesh.getElemManager(); + + elemManager.forElementSubRegions< FaceElementSubRegion >( [&]( FaceElementSubRegion & subRegion ) + { + if( subRegion.size() > 0 ) + { + subRegion.orderKf1NodesConsistentlyWithKf0( faceManager, nodeManager ); + } + } ); + } ); + // Create the lists of interface elements that have same type. createFaceTypeList( domain ); @@ -957,6 +958,11 @@ void SolidMechanicsLagrangeContactBubbleStab::updateStickSlipList( DomainPartiti arrayView1d< integer const > const fractureState = subRegion.getField< contact::fractureState >(); + // Ensure the stick/slip maps contain an entry for this mesh even when + // the fracture face type map is empty (no fracture elements). + this->m_faceTypesToFaceElementsStick.get_inserted( meshName ); + this->m_faceTypesToFaceElementsSlip.get_inserted( meshName ); + forFiniteElementOnFractureSubRegions( meshName, [&] ( string const & finiteElementName, finiteElement::FiniteElementBase const &, arrayView1d< localIndex const > const & faceElementList ) @@ -1047,6 +1053,14 @@ void SolidMechanicsLagrangeContactBubbleStab::createFaceTypeList( DomainPartitio SurfaceElementRegion const & region = elemManager.getRegion< SurfaceElementRegion >( getUniqueFractureRegionName() ); FaceElementSubRegion const & subRegion = region.getUniqueSubRegion< FaceElementSubRegion >(); + // When there are no fracture face elements, insert empty lists so that + // downstream .at( meshName ) lookups do not throw. + if( subRegion.size() == 0 ) + { + this->m_faceTypesToFaceElements.get_inserted( meshName ); + return; + } + array1d< localIndex > keys( subRegion.size()); array1d< localIndex > vals( subRegion.size()); array1d< localIndex > quadList; @@ -1122,6 +1136,13 @@ void SolidMechanicsLagrangeContactBubbleStab::createBubbleCellList( DomainPartit SurfaceElementRegion const & region = elemManager.getRegion< SurfaceElementRegion >( getUniqueFractureRegionName() ); FaceElementSubRegion const & subRegion = region.getUniqueSubRegion< FaceElementSubRegion >(); + + // Nothing to do when there are no fracture face elements. + if( subRegion.size() == 0 ) + { + return; + } + // Array to store face indexes array1d< localIndex > tmpSpace( 2*subRegion.size()); SortedArray< localIndex > faceIdList; @@ -1142,6 +1163,9 @@ void SolidMechanicsLagrangeContactBubbleStab::createBubbleCellList( DomainPartit // Sort indexes to enable efficient searching using binary search. RAJA::stable_sort< parallelDevicePolicy<> >( tmpSpace_v ); + // Move data back to host: after the device sort the buffer lives on the GPU, + // but SortedArray::insert is a host-only operation that dereferences the iterators. + tmpSpace.move( LvArray::MemorySpace::host ); faceIdList.insert( tmpSpace_v.begin(), tmpSpace_v.end()); // Search for bubble element on each CellElementSubRegion and @@ -1163,6 +1187,9 @@ void SolidMechanicsLagrangeContactBubbleStab::createBubbleCellList( DomainPartit arrayView1d< localIndex > const perms_v = perms.toView(); arrayView1d< localIndex > const vals_v = vals.toView(); arrayView1d< localIndex > const localFaceIds_v = localFaceIds.toView(); + // Move faceIdList to device so that the SortedArrayView can be safely + // accessed inside the GPU kernel (faceIdList was populated on the host). + faceIdList.move( parallelDeviceMemorySpace ); SortedArrayView< localIndex const > const faceIdList_v = faceIdList.toViewConst(); forAll< parallelDevicePolicy<> >( cellElementSubRegion.size(), diff --git a/src/coreComponents/physicsSolvers/solidMechanics/contact/kernels/SolidMechanicsALMSimultaneousKernels.hpp b/src/coreComponents/physicsSolvers/solidMechanics/contact/kernels/SolidMechanicsALMSimultaneousKernels.hpp index 07f526cdece..f539dc69ff4 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/contact/kernels/SolidMechanicsALMSimultaneousKernels.hpp +++ b/src/coreComponents/physicsSolvers/solidMechanics/contact/kernels/SolidMechanicsALMSimultaneousKernels.hpp @@ -308,7 +308,10 @@ class ALMSimultaneous : LvArray::tensorOps::Rij_eq_AikBkj< 3, numBdofs, 3 >( matDRtAtb, stack.localPenalty, matRRtAtb ); - real64 const fac = 1.0 / m_faceArea[k]; + real64 const area = m_faceArea[k]; + // Guard against division by zero for degenerate or high-aspect-ratio faces + // that can appear during dynamic fracturing before mesh stabilization + real64 const fac = ( area > LvArray::NumericLimits< real64 >::min ) ? 1.0 / area : 0.0; LvArray::tensorOps::scale< 3, numUdofs >( matDRtAtu, fac ); LvArray::tensorOps::scale< 3, numBdofs >( matDRtAtb, fac ); diff --git a/src/coreComponents/physicsSolvers/surfaceGeneration/ParallelTopologyChange.cpp b/src/coreComponents/physicsSolvers/surfaceGeneration/ParallelTopologyChange.cpp index 5ef359bb83e..b7c2c22dcdb 100644 --- a/src/coreComponents/physicsSolvers/surfaceGeneration/ParallelTopologyChange.cpp +++ b/src/coreComponents/physicsSolvers/surfaceGeneration/ParallelTopologyChange.cpp @@ -802,6 +802,7 @@ void parallelTopologyChange::synchronizeTopologyChange( MeshLevel * const mesh, ModifiedObjectLists & receivedObjects, int mpiCommOrder ) { + GEOS_MARK_FUNCTION; NodeManager & nodeManager = mesh->getNodeManager(); EdgeManager & edgeManager = mesh->getEdgeManager(); diff --git a/src/coreComponents/physicsSolvers/surfaceGeneration/ParallelTopologyChangeNoFixup.cpp b/src/coreComponents/physicsSolvers/surfaceGeneration/ParallelTopologyChangeNoFixup.cpp index 789cf60081d..c1a3e2b0b22 100644 --- a/src/coreComponents/physicsSolvers/surfaceGeneration/ParallelTopologyChangeNoFixup.cpp +++ b/src/coreComponents/physicsSolvers/surfaceGeneration/ParallelTopologyChangeNoFixup.cpp @@ -930,6 +930,7 @@ void synchronizeTopologyChange( MeshLevel * const mesh, ModifiedObjectLists & receivedObjects, int mpiCommOrder ) { + GEOS_MARK_FUNCTION; NodeManager & nodeManager = mesh->getNodeManager(); EdgeManager & edgeManager = mesh->getEdgeManager(); diff --git a/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp b/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp index 6085458d4d3..30056109400 100644 --- a/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp +++ b/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp @@ -38,6 +38,9 @@ #include "kernels/surfaceGenerationKernels.hpp" #include +#include +#include +#include namespace geos { @@ -46,6 +49,7 @@ using namespace dataRepository; using namespace constitutive; using namespace fields; +/// Return the other edge of a face given one edge. static localIndex GetOtherFaceEdge( const map< localIndex, std::pair< localIndex, localIndex > > & localFacesToEdges, const localIndex thisFace, const localIndex thisEdge ) { @@ -67,33 +71,38 @@ static localIndex GetOtherFaceEdge( const map< localIndex, std::pair< localIndex return nextEdge; } +/** + * @brief Removes dead-end faces from the rupture-ready working sets starting from @p edgeIndex. + * @param[in] edgeIndex starting edge to check + * @param[in] isEdgeExternal per-edge external flag (1 = mesh boundary) + * @param[in] edgeOnPartitionBoundary edges that touch at least one ghost-boundary face + * @param[in,out] edgesToRuptureReadyFaces working edge-to-ruptured-faces map + * @param[in,out] localVFacesToVEdges working face-to-(edge0,edge1) map + * @param[in,out] nodeToRuptureReadyFaces working set of ruptured faces for the node + */ static void checkForAndRemoveDeadEndPath( const localIndex edgeIndex, arrayView1d< integer const > const & isEdgeExternal, + std::set< localIndex > const & edgeOnPartitionBoundary, map< localIndex, std::set< localIndex > > & edgesToRuptureReadyFaces, map< localIndex, std::pair< localIndex, localIndex > > & localVFacesToVEdges, std::set< localIndex > & nodeToRuptureReadyFaces ) { - + GEOS_MARK_FUNCTION; localIndex thisEdge = edgeIndex; - // if the edge is internal and the edge is only attached to one ruptured face... - while( isEdgeExternal[thisEdge]!=1 ) + while( isEdgeExternal[thisEdge] != 1 && + edgeOnPartitionBoundary.count( thisEdge ) == 0 ) { - - // std::set& edgeToRuptureReadyFaces = stlMapLookup(edgesToRuptureReadyFaces,thisEdge); std::set< localIndex > & edgeToRuptureReadyFaces = edgesToRuptureReadyFaces[thisEdge]; - if( edgeToRuptureReadyFaces.size()!=1 ) + if( edgeToRuptureReadyFaces.size() != 1 ) break; - // then the index for the face that is a "dead end" - localIndex deadEndFace = *(edgeToRuptureReadyFaces.begin()); - + localIndex deadEndFace = *( edgeToRuptureReadyFaces.begin() ); std::pair< localIndex, localIndex > & localVFaceToVEdges = stlMapLookup( localVFacesToVEdges, deadEndFace ); - // get the edge on the other side of the "dead end" face localIndex nextEdge = -1; if( localVFaceToVEdges.first == thisEdge ) nextEdge = localVFaceToVEdges.second; @@ -104,21 +113,17 @@ static void checkForAndRemoveDeadEndPath( const localIndex edgeIndex, GEOS_ERROR( "SurfaceGenerator::FindFracturePlanes: Could not find the next edge when removing dead end faces." ); } - // delete the face from the working arrays edgeToRuptureReadyFaces.erase( deadEndFace ); edgesToRuptureReadyFaces[nextEdge].erase( deadEndFace ); nodeToRuptureReadyFaces.erase( deadEndFace ); - // if all the faces have been deleted, then go ahead and delete the top level entry if( edgeToRuptureReadyFaces.empty() ) edgesToRuptureReadyFaces.erase( thisEdge ); if( edgesToRuptureReadyFaces[nextEdge].empty() ) edgesToRuptureReadyFaces.erase( nextEdge ); - // now increment the "thisEdge" to point to the other edge on the face that was just deleted thisEdge = nextEdge; } - } @@ -126,7 +131,6 @@ SurfaceGenerator::SurfaceGenerator( const string & name, Group * const parent ): PhysicsSolverBase( name, parent ), m_failCriterion( 1 ), -// m_maxTurnAngle(91.0), m_nodeBasedSIF( 1 ), m_isPoroelastic( 0 ), m_initialRockToughness( 1.0e99 ), @@ -136,7 +140,6 @@ SurfaceGenerator::SurfaceGenerator( const string & name, { this->registerWrapper( viewKeyStruct::failCriterionString(), &this->m_failCriterion ); - registerWrapper( viewKeyStruct::initialRockToughnessString(), &m_initialRockToughness ). setInputFlag( InputFlags::REQUIRED ). setDescription( "Initial rock toughness of the solid material" ); @@ -206,9 +209,7 @@ void SurfaceGenerator::postInputInitialization() } SurfaceGenerator::~SurfaceGenerator() -{ - // TODO Auto-generated destructor stub -} +{} void SurfaceGenerator::registerDataOnMesh( Group & meshBodies ) { @@ -274,7 +275,7 @@ void SurfaceGenerator::registerDataOnMesh( Group & meshBodies ) surfaceGeneration::isFaceSeparable, surfaceGeneration::degreeFromCrackTip >( this->getName() ); - // TODO: handle this automatically in registerField() + // TODO: handle this in registerField(). faceManager.getField< surfaceGeneration::K_IC >().resizeDimension< 1 >( 3 ); Group & problemManager = this->getGroupByPath( "/Problem" ); @@ -287,7 +288,7 @@ void SurfaceGenerator::registerDataOnMesh( Group & meshBodies ) void SurfaceGenerator::initializePostInitialConditionsPreSubGroups() { - DomainPartition & domain = this->getGroupByPath< DomainPartition >( "/Problem/domain" );//this->getGroupByPath("/Problem/domain"); + DomainPartition & domain = this->getGroupByPath< DomainPartition >( "/Problem/domain" ); forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, MeshLevel & meshLevel, string_array const & ) @@ -339,7 +340,7 @@ void SurfaceGenerator::initializePostInitialConditionsPreSubGroups() arrayView2d< real64 const > const & faceNormals = faceManager.faceNormal(); arrayView2d< real64 const > const & faceCenters = faceManager.faceCenter(); - //TODO: roughness to KIC should be made a material constitutive relationship. + // TODO: move roughness-to-KIC to a constitutive relation. arrayView2d< real64 > const & KIC = faceManager.getField< surfaceGeneration::K_IC >(); for( localIndex kf=0; kfgetGroupByPath< DomainPartition >( "/Problem/domain" );//this->getGroupByPath("/Problem/domain"); + DomainPartition & domain = this->getGroupByPath< DomainPartition >( "/Problem/domain" ); NumericalMethodsManager & numericalMethodManager = domain.getNumericalMethodManager(); FiniteVolumeManager & fvManager = numericalMethodManager.getFiniteVolumeManager(); - // repopulate the fracture stencil + // Repopulate the fracture stencil. forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, MeshLevel & meshLevel, string_array const & ) @@ -463,32 +464,52 @@ real64 SurfaceGenerator::solverStep( real64 const & time_n, const int GEOS_UNUSED_PARAM( cycleNumber ), DomainPartition & domain ) { + GEOS_MARK_FUNCTION; + int rval = 0; + std::set< string > modifiedMeshBodies; - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const & meshBodyName, MeshLevel & meshLevel, string_array const & ) { SpatialPartition & partition = dynamicCast< SpatialPartition & >( domain.getReference< PartitionBase >( dataRepository::keys::partitionManager ) ); int const tileColor=partition.getColor(); - int const numTileColors=partition.numColor(); - - rval = separationDriver( domain, - meshLevel, - domain.getNeighbors(), - tileColor, - numTileColors, - 0, - time_n + dt ); - - // if the mesh has been modified, this mesh level should increment its timestamp - if( MpiWrapper::max( rval ) > 0 ) + int const numTileColorsLocal=partition.numColor(); + int const numTileColors = MpiWrapper::allReduce( numTileColorsLocal, MpiWrapper::Reduction::Max ); + + int const localRval = separationDriver( domain, + meshLevel, + domain.getNeighbors(), + tileColor, + numTileColors, + 0, + time_n + dt ); + + rval += localRval; + + // Mark the mesh body as modified on all ranks if any rank split a node. + if( MpiWrapper::allReduce( localRval, MpiWrapper::Reduction::Max ) > 0 ) { - meshLevel.modified(); + modifiedMeshBodies.insert( meshBodyName ); } } ); + for( auto const & bodyName : modifiedMeshBodies ) + { + MeshBody & meshBody = domain.getMeshBodies().getGroup< MeshBody >( bodyName ); + dataRepository::Group & levels = meshBody.getMeshLevels(); + for( auto const & levelName : levels.getSubGroupsNames() ) + { + if( levels.hasGroup< MeshLevel >( levelName ) ) + { + MeshLevel & level = levels.getGroup< MeshLevel >( levelName ); + level.modified(); + } + } + } + NumericalMethodsManager & numericalMethodManager = domain.getNumericalMethodManager(); FiniteVolumeManager & fvManager = numericalMethodManager.getFiniteVolumeManager(); @@ -511,10 +532,8 @@ real64 SurfaceGenerator::solverStep( real64 const & time_n, FaceElementSubRegion & fractureSubRegion = fractureRegion.getUniqueSubRegion< FaceElementSubRegion >(); - // Recreate geometric sets + // Rebuild geometric sets and populate the "all" set on the fracture subregion. meshLevel.getNodeManager().buildGeometricSets( GeometricObjectManager::getInstance() ); - - // Create set "all" on the faceElementSubregion dataRepository::Group & setGroup = fractureSubRegion.getGroup( ObjectManagerBase::groupKeyStruct::setsString() ); @@ -527,7 +546,7 @@ real64 SurfaceGenerator::solverStep( real64 const & time_n, targetSet.insert( ei ); } ); - // Compute gravity coefficient for new elements so that gravity term is correctly computed + // Compute gravity coefficient for new fracture elements. real64 const gravVector[3] = LVARRAY_TENSOROPS_INIT_LOCAL_3( gravityVector() ); if( fractureSubRegion.hasField< fields::flow::gravityCoefficient >() ) @@ -545,7 +564,7 @@ real64 SurfaceGenerator::solverStep( real64 const & time_n, string const permModelName = getConstitutiveName< PermeabilityBase >( fractureSubRegion ); if( !permModelName.empty() ) { - // if a permeability model exists we need to set the intial value to something meaningful + // Initialize permeability state for newly created fracture elements. PermeabilityBase & permModel = getConstitutiveModel< PermeabilityBase >( fractureSubRegion, permModelName ); permModel.initializeState(); } @@ -570,6 +589,13 @@ int SurfaceGenerator::separationDriver( DomainPartition & domain, FaceManager & faceManager = mesh.getFaceManager(); ElementRegionManager & elementManager = mesh.getElemManager(); + // Snapshot locally-owned fracture element count before splitting. + { + SurfaceElementRegion const & fractureRegion = elementManager.getRegion< SurfaceElementRegion >( m_fractureRegionName ); + FaceElementSubRegion const & fractureSubRegion = fractureRegion.getUniqueSubRegion< FaceElementSubRegion >(); + m_numFractureElementsBefore = fractureSubRegion.getNumberOfLocalIndices(); + } + stdVector< std::set< localIndex > > nodesToRupturedFaces; stdVector< std::set< localIndex > > edgesToRupturedFaces; @@ -615,8 +641,7 @@ int SurfaceGenerator::separationDriver( DomainPartition & domain, calculateKinkAngles( faceManager, edgeManager, nodeManager, modifiedObjects, prefrac ); } - // We do this here to get the nodesToRupturedFaces etc. - // The fail stress check inside has been disabled + // Populate nodesToRupturedFaces and edgesToRupturedFaces from current rupture state. postUpdateRuptureStates( nodeManager, edgeManager, faceManager, @@ -625,42 +650,11 @@ int SurfaceGenerator::separationDriver( DomainPartition & domain, edgesToRupturedFaces ); int rval = 0; - // array1d& temp = elementManager.m_ElementRegions["PM1"].m_materialStates; array1d< integer > const & isNodeGhost = nodeManager.ghostRank(); for( int color=0; color const & faceToRegionMap = faceManager.elementRegionList(); - // array2d< localIndex > const & faceToSubRegionMap = faceManager.elementSubRegionList(); - // array2d< localIndex > const & faceToElementMap = faceManager.elementList(); - // arrayView1d< globalIndex const> const faceToGlobalMap = faceManager.localToGlobalMap(); - // for( localIndex kf=0; kf( m_fractureRegionName ); + fractureElementRegion.updateSets( faceManager ); } #ifdef GEOS_USE_MPI @@ -697,82 +694,9 @@ int SurfaceGenerator::separationDriver( DomainPartition & domain, CommunicationTools::assignNewGlobalIndices( nodeManager, modifiedObjects.newNodes ); CommunicationTools::assignNewGlobalIndices( edgeManager, modifiedObjects.newEdges ); CommunicationTools::assignNewGlobalIndices( faceManager, modifiedObjects.newFaces ); -// CommunicationTools::getInstance().AssignNewGlobalIndices( elementManager, modifiedObjects.newElements ); ModifiedObjectLists receivedObjects; - /// Nodes to edges in process node is not being set on rank 2. need to check that the new node->edge map is properly - /// communicated - - // if( MpiWrapper::commRank()==6 || MpiWrapper::commRank()==0 ) - // { - // FaceManager::ElemMapType const & faceToElem = faceManager.toElementRelation(); - // arrayView2d< localIndex const > const & faceToElemRegion = faceToElem.m_toElementRegion; - // arrayView2d< localIndex const > const & faceToElemSubRegion = faceToElem.m_toElementSubRegion; - // arrayView2d< localIndex const > const & faceToElemIndex = faceToElem.m_toElementIndex; - - // arrayView1d< globalIndex const > const & faceLocalToGlobalMap = faceManager.localToGlobalMap(); - // arrayView1d< globalIndex const > const & elementLocalToGlobalMap = elementManager.getRegion(0).getSubRegion(0).localToGlobalMap(); - - // printf( "pre sync \n"); - // if( MpiWrapper::commRank()==6 ) - // { - // printf( "rank = %d\n", MpiWrapper::commRank() ); - // if( faceToElemRegion.size(0) > 8889 ) - // { - // printf( " faceToElementMap[%d(%lld)/%d(%lld)] = ( %d, %d, %d(%lld) ), ( %d, %d, %d(%lld) ) / ( %d, %d, %d(%lld) ), ( %d, - // %d, %d(%lld) )\n", - // 3082, faceLocalToGlobalMap[3082], 8889, faceLocalToGlobalMap[8889], - // faceToElemRegion[3082][0], faceToElemSubRegion[3082][0], faceToElemIndex[3082][0], faceToElemIndex[3082][0] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[3082][0]], - // faceToElemRegion[3082][1], faceToElemSubRegion[3082][1], faceToElemIndex[3082][1], faceToElemIndex[3082][1] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[3082][1]], - // faceToElemRegion[8889][0], faceToElemSubRegion[8889][0], faceToElemIndex[8889][0], faceToElemIndex[8889][0] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[8889][0]], - // faceToElemRegion[8889][1], faceToElemSubRegion[8889][1], faceToElemIndex[8889][1], faceToElemIndex[8889][1] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[8889][1]] ); - // } - // else - // { - // printf( " faceToElementMap[%d(%lld)] = ( %d, %d, %d(%lld) ), ( %d, %d, %d(%lld) ) \n", - // 3082, faceLocalToGlobalMap[3082], - // faceToElemRegion[3082][0], faceToElemSubRegion[3082][0], faceToElemIndex[3082][0], faceToElemIndex[3082][0] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[3082][0]], - // faceToElemRegion[3082][1], faceToElemSubRegion[3082][1], faceToElemIndex[3082][1], faceToElemIndex[3082][1] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[3082][1]] ); - // } - // } - // if( MpiWrapper::commRank()==0 ) - // { - // printf( "rank = %d\n", MpiWrapper::commRank() ); - // if( faceToElemRegion.size(0) > 9653 ) - // { - // printf( " faceToElementMap[%d(%lld)/%d(%lld)] = ( %d, %d, %d(%lld) ), ( %d, %d, %d(%lld) ) / ( %d, %d, %d(%lld) ), ( %d, - // %d, %d(%lld) )\n", - // 9268, faceLocalToGlobalMap[9268], 9653, faceLocalToGlobalMap[9653], - // faceToElemRegion[9268][0], faceToElemSubRegion[9268][0], faceToElemIndex[9268][0], faceToElemIndex[9268][0] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[9268][0]], - // faceToElemRegion[9268][1], faceToElemSubRegion[9268][1], faceToElemIndex[9268][1], faceToElemIndex[9268][1] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[9268][1]], - // faceToElemRegion[9653][0], faceToElemSubRegion[9653][0], faceToElemIndex[9653][0], faceToElemIndex[9653][0] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[9653][0]], - // faceToElemRegion[9653][1], faceToElemSubRegion[9653][1], faceToElemIndex[9653][1], faceToElemIndex[9653][1] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[9653][1]] ); - - // } - // else - // { - // printf( " faceToElementMap[%d(%lld)] = ( %d, %d, %d(%lld) ), ( %d, %d, %d(%lld) ) \n", - // 9268, faceLocalToGlobalMap[9268], - // faceToElemRegion[9268][0], faceToElemSubRegion[9268][0], faceToElemIndex[9268][0], faceToElemIndex[9268][0] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[9268][0]], - // faceToElemRegion[9268][1], faceToElemSubRegion[9268][1], faceToElemIndex[9268][1], faceToElemIndex[9268][1] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[9268][1]] ); - // } - // } - - // } - parallelTopologyChange::synchronizeTopologyChange( &mesh, neighbors, @@ -780,76 +704,6 @@ int SurfaceGenerator::separationDriver( DomainPartition & domain, receivedObjects, m_mpiCommOrder ); - - // if( MpiWrapper::commRank()==6 || MpiWrapper::commRank()==0 ) - // { - // FaceManager::ElemMapType const & faceToElem = faceManager.toElementRelation(); - // arrayView2d< localIndex const > const & faceToElemRegion = faceToElem.m_toElementRegion; - // arrayView2d< localIndex const > const & faceToElemSubRegion = faceToElem.m_toElementSubRegion; - // arrayView2d< localIndex const > const & faceToElemIndex = faceToElem.m_toElementIndex; - - // arrayView1d< globalIndex const > const & faceLocalToGlobalMap = faceManager.localToGlobalMap(); - // arrayView1d< globalIndex const > const & elementLocalToGlobalMap = elementManager.getRegion(0).getSubRegion(0).localToGlobalMap(); - - // printf( "post sync \n"); - // if( MpiWrapper::commRank()==6 ) - // { - // printf( "rank = %d\n", MpiWrapper::commRank() ); - // if( faceToElemRegion.size(0) > 8889 ) - // { - // printf( " faceToElementMap[%d(%lld)/%d(%lld)] = ( %d, %d, %d(%lld) ), ( %d, %d, %d(%lld) ) / ( %d, %d, %d(%lld) ), ( %d, - // %d, %d(%lld) )\n", - // 3082, faceLocalToGlobalMap[3082], 8889, faceLocalToGlobalMap[8889], - // faceToElemRegion[3082][0], faceToElemSubRegion[3082][0], faceToElemIndex[3082][0], faceToElemIndex[3082][0] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[3082][0]], - // faceToElemRegion[3082][1], faceToElemSubRegion[3082][1], faceToElemIndex[3082][1], faceToElemIndex[3082][1] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[3082][1]], - // faceToElemRegion[8889][0], faceToElemSubRegion[8889][0], faceToElemIndex[8889][0], faceToElemIndex[8889][0] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[8889][0]], - // faceToElemRegion[8889][1], faceToElemSubRegion[8889][1], faceToElemIndex[8889][1], faceToElemIndex[8889][1] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[8889][1]] ); - // } - // else - // { - // printf( " faceToElementMap[%d(%lld)] = ( %d, %d, %d(%lld) ), ( %d, %d, %d(%lld) ) \n", - // 3082, faceLocalToGlobalMap[3082], - // faceToElemRegion[3082][0], faceToElemSubRegion[3082][0], faceToElemIndex[3082][0], faceToElemIndex[3082][0] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[3082][0]], - // faceToElemRegion[3082][1], faceToElemSubRegion[3082][1], faceToElemIndex[3082][1], faceToElemIndex[3082][1] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[3082][1]] ); - // } - // } - // if( MpiWrapper::commRank()==0 ) - // { - // printf( "rank = %d\n", MpiWrapper::commRank() ); - // if( faceToElemRegion.size(0) > 9653 ) - // { - // printf( " faceToElementMap[%d(%lld)/%d(%lld)] = ( %d, %d, %d(%lld) ), ( %d, %d, %d(%lld) ) / ( %d, %d, %d(%lld) ), ( %d, - // %d, %d(%lld) )\n", - // 9268, faceLocalToGlobalMap[9268], 9653, faceLocalToGlobalMap[9653], - // faceToElemRegion[9268][0], faceToElemSubRegion[9268][0], faceToElemIndex[9268][0], faceToElemIndex[9268][0] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[9268][0]], - // faceToElemRegion[9268][1], faceToElemSubRegion[9268][1], faceToElemIndex[9268][1], faceToElemIndex[9268][1] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[9268][1]], - // faceToElemRegion[9653][0], faceToElemSubRegion[9653][0], faceToElemIndex[9653][0], faceToElemIndex[9653][0] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[9653][0]], - // faceToElemRegion[9653][1], faceToElemSubRegion[9653][1], faceToElemIndex[9653][1], faceToElemIndex[9653][1] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[9653][1]] ); - - // } - // else - // { - // printf( " faceToElementMap[%d(%lld)] = ( %d, %d, %d(%lld) ), ( %d, %d, %d(%lld) ) \n", - // 9268, faceLocalToGlobalMap[9268], - // faceToElemRegion[9268][0], faceToElemSubRegion[9268][0], faceToElemIndex[9268][0], faceToElemIndex[9268][0] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[9268][0]], - // faceToElemRegion[9268][1], faceToElemSubRegion[9268][1], faceToElemIndex[9268][1], faceToElemIndex[9268][1] == -1? -1 : - // elementLocalToGlobalMap[faceToElemIndex[9268][1]] ); - // } - // } - - // } - synchronizeTipSets( faceManager, edgeManager, nodeManager, @@ -900,7 +754,7 @@ int SurfaceGenerator::separationDriver( DomainPartition & domain, } } ); MpiWrapper::barrier(); - } + } // end color loop real64 ruptureRate = calculateRuptureRate( elementManager.getRegion< SurfaceElementRegion >( this->m_fractureRegionName ) ); @@ -909,8 +763,6 @@ int SurfaceGenerator::separationDriver( DomainPartition & domain, if( ruptureRate > 0 ) m_nextDt = ruptureRate < 1e99 ? m_cflFactor / ruptureRate : 1e99; - -// if( rval>0 ) { elementManager.forElementSubRegions< CellElementSubRegion >( [] ( auto & elemSubRegion ) { @@ -921,19 +773,48 @@ int SurfaceGenerator::separationDriver( DomainPartition & domain, faceManager.nodeList().toView().registerTouch( hostMemorySpace ); -// faceManager.edgeList().registerTouch( hostMemorySpace ); faceManager.elementList().registerTouch( hostMemorySpace ); faceManager.elementRegionList().registerTouch( hostMemorySpace ); faceManager.elementSubRegionList().registerTouch( hostMemorySpace ); edgeManager.nodeList().registerTouch( hostMemorySpace ); -// nodeManager.edgeList().registerTouch( hostMemorySpace ); -// nodeManager.faceList()().registerTouch( hostMemorySpace ); -// nodeManager.elementList().registerTouch( hostMemorySpace ); -// nodeManager.elementRegionList().registerTouch( hostMemorySpace ); -// nodeManager.elementSubRegionList().registerTouch( hostMemorySpace ); + } + // Log statistics about the mesh splitting operation + int const globalRval = MpiWrapper::allReduce( rval, MpiWrapper::Reduction::Max, MPI_COMM_GEOS ); + if( globalRval > 0 ) + { + // Count fracture elements from the FaceElementSubRegion. + SurfaceElementRegion const & fractureRegion = elementManager.getRegion< SurfaceElementRegion >( this->m_fractureRegionName ); + FaceElementSubRegion const & fractureSubRegion = fractureRegion.getUniqueSubRegion< FaceElementSubRegion >(); + + // Count locally-owned fracture elements only (exclude ghosts). + localIndex const localNumFractureElements = fractureSubRegion.getNumberOfLocalIndices(); + localIndex const localNewFractureElements = localNumFractureElements - m_numFractureElementsBefore; + + // Gather global statistics across all MPI ranks + globalIndex const globalNumFractureElements = MpiWrapper::sum( static_cast< globalIndex >( localNumFractureElements ), MPI_COMM_GEOS ); + globalIndex const globalNewFractureElements = MpiWrapper::sum( static_cast< globalIndex >( localNewFractureElements ), MPI_COMM_GEOS ); + globalIndex const globalNumSplits = MpiWrapper::sum( static_cast< globalIndex >( rval ), MPI_COMM_GEOS ); + + GEOS_LOG_RANK_0( GEOS_FMT( "SurfaceGenerator: Mesh splitting completed.\n" + " Number of nodes split: {:>8}\n" + " New fracture elements: {:>8}\n" + " Total fracture elements: {:>8}", + globalNumSplits, + globalNewFractureElements, + globalNumFractureElements ) ); + + // Extended per-rank breakdown, guarded by log level + GEOS_LOG_LEVEL_RANK_0( logInfo::SurfaceGenerator, + GEOS_FMT( "SurfaceGenerator: Per-rank breakdown.\n" + " Local fracture elements (this rank): {:>8}\n" + " Local new fracture elements (this rank): {:>8}\n" + " Local nodes split (this rank): {:>8}", + localNumFractureElements, + localNewFractureElements, + rval ) ); } return rval; @@ -944,6 +825,8 @@ void SurfaceGenerator::synchronizeTipSets ( FaceManager & faceManager, NodeManager & nodeManager, ModifiedObjectLists & receivedObjects ) { + GEOS_MARK_FUNCTION; + arrayView1d< localIndex const > const & parentNodeIndices = nodeManager.getField< fields::parentIndex >(); for( localIndex const nodeIndex : receivedObjects.newNodes ) @@ -1051,36 +934,6 @@ void SurfaceGenerator::synchronizeTipSets ( FaceManager & faceManager, } } - -//void SurfaceGenerator::setDegreeFromCrackTip( NodeManager & nodeManager, -// FaceManager & faceManager ) -//{ -// -// arrayView1d & -// nodeDegreeFromCrackTip = nodeManager.getReference( viewKeyStruct::degreeFromCrackTipString() ); -// -// arrayView1d & -// faceDegreeFromCrackTip = faceManager.getReference( viewKeyStruct::degreeFromCrackTipString() ); -// -// ArrayOfArraysView< localIndex const > const & facesToNodes = faceManager.nodeList(); -// -// arrayView1d const & ruptureState = faceManager.getReference( "ruptureState" ); -// -// faceDegreeFromCrackTip = 100000; -// -// for( localIndex kf=0 ; kf=2 ) -// { -// for( localIndex a=0 ; a & faceLocations, map< std::pair< CellElementSubRegion const *, localIndex >, int > & elemLocations ) { + GEOS_MARK_FUNCTION; + arrayView1d< localIndex const > const & parentNodeIndices = nodeManager.getField< fields::parentIndex >(); localIndex const parentNodeIndex = ObjectManagerBase::getParentRecursive( parentNodeIndices, nodeID ); @@ -1175,45 +1032,39 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, arraySlice1d< localIndex const > const nodeToSubRegionMap = nodeManager.elementSubRegionList()[nodeID]; arraySlice1d< localIndex const > const nodeToElementMap = nodeManager.elementList()[nodeID]; - // BACKWARDS COMPATIBILITY HACK! - // - // The `nodeToElementMaps` container used to be a std::set instead of a stdVector. - // The problem is that std::set was sorted using the default sorting mechanisms of std::pair. - // That is, comparing the first element of the pair, and then the second if required. - // But the first element of the std::pair being a `CellElementSubRegion const *`, - // pointers were actually compared: the std::set was sorted w.r.t. memory positions of the instances. - // - // Then the algorithm selects the *first* element of the std::set as input value. - // Depending on memory layout, the first element could not be stable, which somehow results in some random selection. - // Unfortunately it happens that the algorithm sometimes depends on the selected value of the set, but fails with others. - // - // As a quick fix for this problem, a version with stdVector is implemented. - // It imposes a stable order and also discards any duplicate like the previous std::set implementation did. - // This does not fix the algorithm itself, but at least it stabilises the order the data in the container, - // making the situation more reproducible. + // Build deterministic, sorted list of unique (subRegion, elementIndex) pairs for node-attached elements. auto buildNodeToElementMaps = [&]() { stdVector< std::pair< CellElementSubRegion const *, localIndex > > result; - for( localIndex k = 0; k < nodeManager.elementRegionList().sizeOfArray( nodeID ); ++k ) { - localIndex const er = nodeToRegionMap[k], esr = nodeToSubRegionMap[k], ei = nodeToElementMap[k]; - CellElementSubRegion const * cellElementSubRegion = &elemManager.getRegion( er ).getSubRegion< CellElementSubRegion >( esr ); - std::pair< CellElementSubRegion const *, localIndex > const p( cellElementSubRegion, ei ); - // To mimic the previous std::set behavior, we keep pairs unique within the container. - // This may not be the best implementation since we search before every insertion, - // but we'll always be looping over small number of elements (couple regions and a few subregions). + localIndex const er = nodeToRegionMap[k]; + localIndex const esr = nodeToSubRegionMap[k]; + localIndex const ei = nodeToElementMap[k]; + CellElementSubRegion const * subRegion = + &elemManager.getRegion( er ).getSubRegion< CellElementSubRegion >( esr ); + std::pair< CellElementSubRegion const *, localIndex > const p( subRegion, ei ); + + // Keep pairs unique (small N — linear search is fine). if( std::find( result.cbegin(), result.cend(), p ) == result.cend() ) { result.push_back( p ); } } + // Sort by global element index for platform independence. + std::sort( result.begin(), result.end(), + []( auto const & a, auto const & b ) + { + return a.first->localToGlobalMap()[a.second] + < b.first->localToGlobalMap()[b.second]; + } ); + return result; }; - stdVector< std::pair< CellElementSubRegion const *, localIndex > > const nodeToElementMaps( buildNodeToElementMaps() ); - // END OF BACKWARDS COMPATIBILITY HACK! + stdVector< std::pair< CellElementSubRegion const *, localIndex > > const + nodeToElementMaps( buildNodeToElementMaps() ); arrayView1d< integer const > const & isEdgeExternal = edgeManager.isExternal(); @@ -1221,9 +1072,7 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, // **** local working arrays ***************************************************************************************** - // array to hold the faces ready for rupture. It is filled with the intersection of the virtual parent faces - // associated - // with all faces attached to the node, and all ruptured virtual faces attached to the virtual parent node. + // Identify rupture-ready faces from intersection of node-attached faces and ruptured parent faces. std::set< localIndex > nodeToRuptureReadyFaces; for( localIndex const i : nodeToFaceMap[ nodeID ] ) { @@ -1236,6 +1085,7 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, } + // local map to hold the edgesToRuptureReadyFaces map< localIndex, std::set< localIndex > > edgesToRuptureReadyFaces; for( localIndex const edgeIndex : m_originalNodetoEdges[ parentNodeIndex ] ) @@ -1245,7 +1095,7 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, } - // need a map from faces to edges that are attached to the node + // Map node-attached faces to their incident edges. map< localIndex, std::pair< localIndex, localIndex > > nodeLocalFacesToEdges; for( localIndex const kf : m_originalNodetoFaces[ parentNodeIndex ] ) { @@ -1270,26 +1120,34 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, } - // ***** remove dead end paths *************************************************************************************** - // if the edge is not external, and the size of edgesToRupturedFaces is less than 2, then the edge is a dead-end - // as far as a rupture plane is concerned. The face associated with the edge should be removed from the working - // list of ruptured faces. + // Remove dead-end paths, preserving MPI partition boundaries where neighbor data is incomplete. + + // Identify edges touching MPI partition boundaries. + std::set< localIndex > edgeOnPartitionBoundary; + for( localIndex const kf : m_originalNodetoFaces[ parentNodeIndex ] ) + { + if( isGhostBoundaryFace( kf ) ) + { + // Both edges of this face touch the partition boundary (or domain exterior). + auto const & ep = nodeLocalFacesToEdges[kf]; + edgeOnPartitionBoundary.insert( ep.first ); + edgeOnPartitionBoundary.insert( ep.second ); + } + } // loop over all the edges for( localIndex const edgeIndex : m_originalNodetoEdges[ parentNodeIndex ] ) { - checkForAndRemoveDeadEndPath( edgeIndex, isEdgeExternal, + edgeOnPartitionBoundary, edgesToRuptureReadyFaces, nodeLocalFacesToEdges, nodeToRuptureReadyFaces ); - } // if there are no ruptured faces attached to the node, then we are done. - // or if there are no faces that have not been used in a rupture path for this node...we are done. - if( nodeToRuptureReadyFaces.empty() )//|| nodeToRuptureReadyFaces.size() == usedFaces.size() ) + if( nodeToRuptureReadyFaces.empty() ) { return false; } @@ -1297,15 +1155,14 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, // ***** find separation path **************************************************************************************** // ***** find starting face ***** - // We need to find a starting point for the path. The path must have a face that does has not been used in a previous - // path for this node...otherwise it is the same path as used previously. + // Find unused starting face for separation path. localIndex startingEdge = INT_MAX; localIndex startingFace = INT_MAX; bool startingEdgeExternal = false; for( std::set< localIndex >::const_iterator i=nodeToRuptureReadyFaces.begin(); i!=nodeToRuptureReadyFaces.end(); ++i ) { - // check to see if this face has been used to split this node as part of a previously used path + // Check if face was already used in a prior split. if( m_usedFacesForNode[nodeID].count( *i )==0 ) { // great! It hasn't. It's on like Donkey Kong. @@ -1330,7 +1187,7 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, } } - // if the starting face was not set, then we don't have a rupture surface....so just quit. + // Abort if no starting face found. if( startingFace==INT_MAX || startingEdge==INT_MAX ) { return false; @@ -1339,23 +1196,16 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, - // so now the working arrays have been purged of any faces that are on a dead-end path. All remaining faces - // are part of a separation plane...of course, there can be more than one...which is bad. We will just take the first - // path we find, and call this function again after the selected path is processed. Since the ruptureState of a face - // is set to 2 after it is ruptured, if we enforce that candidate paths must have a face with a ruptureState of 1, - // then - // everything will work out. Also since the new nodes that are created will have higher node indices than the - // current node, they will be checked for separation prior to completion of the separation driver. + // Process first found separation path; subsequent paths will be handled in later iterations. - // We now have to define the separation plane over which a node/face/edge will be split, and all elements on one side - // of the plane get one set of objects, and all elements on the other side get the other set. + // Define separation plane to split objects into two sets. { - // now we start the process of setting the separation path. Begin by + // Begin setting separation path. localIndex thisEdge = startingEdge; localIndex thisFace = startingFace; @@ -1379,31 +1229,27 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, facePath.emplace_back( thisFace ); edgePath.emplace_back( thisEdge ); - // now walk from face->edge->face->edge etc. until we get to an external edge, or back to the startingEdge. - // the breakFlag indicates that we have found a complete separation path + // Walk face-edge path until external edge or return to start. bool breakFlag = false; while( !breakFlag ) { - // get the next edge in the path...it is on the other side of "thisFace", so assign the other edge on the face as - // the next edge + // Get next edge on current face. nextEdge = GetOtherFaceEdge( nodeLocalFacesToEdges, thisFace, thisEdge ); - // if the nextEdge has already been used in the path, and the nextEdge is not the starting edge, then we have - // to take a step back and try a different path + // Backtrack if next edge used but not starting edge. if( edgesInPath.count( nextEdge )==1 && nextEdge!=startingEdge ) { // first check to see if we can use the path without the preceding return false; } - // if we have reached an external face, or the edge is already in the path, then we are done + // Done if external edge reached or loop closed. if( (isEdgeExternal[nextEdge]==1 && startingEdgeExternal ) || edgesInPath.count( nextEdge )==1 ) { - // check to see if nextEdge is the startingEdge. If not, then all faces must that are before the nextEdge must - // NOT be included in the path!!! + // Verify valid loop closure. if( nextEdge!=startingEdge && !(isEdgeExternal[nextEdge]==1 && startingEdgeExternal ) ) { GEOS_ERROR( GEOS_FMT( "Crap ! NodeID, ParentID = {}, {}\n" @@ -1430,10 +1276,7 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, } else { - // if the previous if statement is false, then what if we have reached an external edge, but the starting edge - // was not external?? This means that we must continue the process from the edge opposite the startingEdge on - // the - // startingFace....which is hard-coded as the second entry in localFacesToEdges. + // If started internally but hit boundary, switch direction from start. if( isEdgeExternal[nextEdge]==1 ) { nextEdge = nodeLocalFacesToEdges[startingFace].second; @@ -1442,34 +1285,22 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, // I sure hope that this is true!! if( edgesToRuptureReadyFaces[nextEdge].size() > 1 ) { - // we need to pick another face attached to the "next edge" - // increment the face and edge, and add to the separationPathFaces + // Pick next face attached to edge. { - // OK...so we have an iterator that points to a candidate face. We prefer to move towards a face that is - // ruptureState 1, so that we can get as much splitting done in this event. So we will loop over all the - // faces attached to the edge, and pick one with ruptureState==1, otherwise just pick any one. + // Select optimal next face, preferring ruptureState 1. bool pathFound = false; + // Retrieve elements adjacent to current face, handling ghost boundaries. const std::pair< CellElementSubRegion const *, localIndex > thisElem0 = std::make_pair( &elemManager.getRegion( m_originalFacesToElemRegion[thisFace][0] ). getSubRegion< CellElementSubRegion >( m_originalFacesToElemSubRegion[thisFace][0] ), m_originalFacesToElemIndex[thisFace][0] ); - const std::pair< CellElementSubRegion const *, localIndex > - thisElem1 = std::make_pair( &elemManager.getRegion( m_originalFacesToElemRegion[thisFace][1] ). - getSubRegion< CellElementSubRegion >( m_originalFacesToElemSubRegion[thisFace][1] ), - m_originalFacesToElemIndex[thisFace][1] ); - - // nextFaceQuality is intended to keep how desirable a face is for the rupture path. - // A value of: - // 0 -> the face is kind of creppy - // 1 -> the face is does not turn a corner around the elements surrounding thisFace - // 2 -> the face has not been used in a separation path - // 3 -> a combination of 1 and 2. - // 4 -> other edge on the face is the startingEdge. - // + bool const thisFaceHasSecondElem = !isGhostBoundaryFace( thisFace ); + + // Evaluate candidate face quality based on geometry and usage. int nextFaceQuality = -1; for( std::set< localIndex >::const_iterator iter_edgeToFace = edgesToRuptureReadyFaces[nextEdge].begin(); @@ -1492,20 +1323,31 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, break; } - const std::pair< CellElementSubRegion const *, localIndex > - nextElem0 = std::make_pair( &elemManager.getRegion( m_originalFacesToElemRegion[candidateFaceIndex][0] ). - getSubRegion< CellElementSubRegion >( m_originalFacesToElemSubRegion[candidateFaceIndex][0] ), - m_originalFacesToElemIndex[candidateFaceIndex][0] ); - - const std::pair< CellElementSubRegion const *, localIndex > - nextElem1 = std::make_pair( &elemManager.getRegion( m_originalFacesToElemRegion[candidateFaceIndex][1] ). - getSubRegion< CellElementSubRegion >( m_originalFacesToElemSubRegion[candidateFaceIndex][1] ), - m_originalFacesToElemIndex[candidateFaceIndex][1] ); + // Assess corner-turn quality by checking shared elements. + bool const candidateHasSecondElem = !isGhostBoundaryFace( candidateFaceIndex ); - if( thisElem0 != nextElem0 && thisElem0 != nextElem1 && - thisElem1 != nextElem0 && thisElem1 != nextElem1 ) + if( thisFaceHasSecondElem && candidateHasSecondElem ) { - candidateFaceQuality += 1; + const std::pair< CellElementSubRegion const *, localIndex > + thisElem1 = std::make_pair( &elemManager.getRegion( m_originalFacesToElemRegion[thisFace][1] ). + getSubRegion< CellElementSubRegion >( m_originalFacesToElemSubRegion[thisFace][1] ), + m_originalFacesToElemIndex[thisFace][1] ); + + const std::pair< CellElementSubRegion const *, localIndex > + nextElem0 = std::make_pair( &elemManager.getRegion( m_originalFacesToElemRegion[candidateFaceIndex][0] ). + getSubRegion< CellElementSubRegion >( m_originalFacesToElemSubRegion[candidateFaceIndex][0] ), + m_originalFacesToElemIndex[candidateFaceIndex][0] ); + + const std::pair< CellElementSubRegion const *, localIndex > + nextElem1 = std::make_pair( &elemManager.getRegion( m_originalFacesToElemRegion[candidateFaceIndex][1] ). + getSubRegion< CellElementSubRegion >( m_originalFacesToElemSubRegion[candidateFaceIndex][1] ), + m_originalFacesToElemIndex[candidateFaceIndex][1] ); + + if( thisElem0 != nextElem0 && thisElem0 != nextElem1 && + thisElem1 != nextElem0 && thisElem1 != nextElem1 ) + { + candidateFaceQuality += 1; + } } if( m_usedFacesForNode[nodeID].count( candidateFaceIndex ) == 0 ) @@ -1528,6 +1370,10 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, } if( pathFound == false ) { + if( edgeOnPartitionBoundary.count( nextEdge ) > 0 ) + { + return false; + } GEOS_ERROR( "couldn't find the next face in the rupture path (SurfaceGenerator::findFracturePlanes", getDataContext() ); } } @@ -1547,6 +1393,11 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, } else { + // Incomplete local path (likely partition boundary) - abort. + if( edgeOnPartitionBoundary.count( nextEdge ) > 0 ) + { + return false; + } GEOS_ERROR( "next edge in separation path is apparently connected to less than 2 ruptured face (SurfaceGenerator::findFracturePlanes", getDataContext() ); } @@ -1612,25 +1463,16 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, } - - /* - SetLocations( 0, separationPathFaces, faceManager, nodeToElementMaps, localFacesToEdges, //nodeToEdges, - edgeLocations, faceLocations, elemLocations ); - - if( !(SetLocations( 1, separationPathFaces, faceManager, nodeToElementMaps, localFacesToEdges, //nodeToEdges, - edgeLocations, faceLocations, elemLocations )) ) - { - return false; - }*/ - - setLocations( separationPathFaces, - elemManager, - faceManager, - nodeToElementMaps, - localFacesToEdges, - edgeLocations, - faceLocations, - elemLocations ); + // Assign sides (0 or 1) to every element, face, and edge around the + // splitting node via BFS. Ghost-boundary faces are handled internally. + assignLocationsBFS( separationPathFaces, + elemManager, + faceManager, + nodeToElementMaps, + localFacesToEdges, + edgeLocations, + faceLocations, + elemLocations ); @@ -1650,36 +1492,51 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, fail = true; } } - /* - std::cout<<" NodeID, ParentID = "< >::const_iterator k=nodeToElementMaps.begin() ; - k!=nodeToElementMaps.end() ; ++k ) - { - std::cout<<" elemLocations["<second<<"] = "<::const_iterator ke=nodeToFaces.begin() ; ke!=nodeToFaces.end() ; ++ke ) - { - std::cout<<" faceLocations["<<*ke<<"] = "<::const_iterator ke=nodeToEdges.begin() ; ke!=nodeToEdges.end() ; ++ke ) - { - std::cout<<" edgeLocations["<<*ke<<"] = "< const & separationPathFaces, - ElementRegionManager const & elemManager, - FaceManager const & faceManager, - stdVector< std::pair< CellElementSubRegion const *, localIndex > > const & nodeToElementMaps, - map< localIndex, std::pair< localIndex, localIndex > > const & localFacesToEdges, - map< localIndex, int > & edgeLocations, - map< localIndex, int > & faceLocations, - map< std::pair< CellElementSubRegion const *, localIndex >, int > & elemLocations ) +bool SurfaceGenerator::assignLocationsBFS( std::set< localIndex > const & separationPathFaces, + ElementRegionManager const & elemManager, + FaceManager const & faceManager, + stdVector< std::pair< CellElementSubRegion const *, localIndex > > const & nodeToElementMaps, + map< localIndex, std::pair< localIndex, localIndex > > const & localFacesToEdges, + map< localIndex, int > & edgeLocations, + map< localIndex, int > & faceLocations, + map< std::pair< CellElementSubRegion const *, localIndex >, int > & elemLocations ) { - bool rval = true; - // const localIndex separationFace = *(separationPathFaces.begin()); - - // insert an element attached to the separation face - // std::pair elem0 = m_virtualFaces.m_FaceToElementMap[separationFace][0] ; - - std::pair< CellElementSubRegion const *, localIndex > const elem0 = *( nodeToElementMaps.cbegin() ); - - - setElemLocations( 0, - elem0, - separationPathFaces, - elemManager, - faceManager, - nodeToElementMaps, - localFacesToEdges, - edgeLocations, - faceLocations, - elemLocations ); - - return rval; -} - + GEOS_MARK_FUNCTION; -//********************************************************************************************************************** -//********************************************************************************************************************** -//********************************************************************************************************************** -bool SurfaceGenerator::setElemLocations( int const location, - std::pair< CellElementSubRegion const *, localIndex > const & k, - std::set< localIndex > const & separationPathFaces, - ElementRegionManager const & elemManager, - FaceManager const & faceManager, - stdVector< std::pair< CellElementSubRegion const *, localIndex > > const & nodeToElementMaps, - map< localIndex, std::pair< localIndex, localIndex > > const & localFacesToEdges, - map< localIndex, int > & edgeLocations, - map< localIndex, int > & faceLocations, - map< std::pair< CellElementSubRegion const *, localIndex >, int > & elemLocations ) -{ - arrayView1d< localIndex const > const & parentFaceIndices = faceManager.getField< fields::parentIndex >(); + arrayView1d< localIndex const > const & parentFaceIndices = + faceManager.getField< fields::parentIndex >(); - const int otherlocation = (location==0) ? 1 : 0; + // Propagate assignment to element components and enqueue neighbors. + using ElemKey = std::pair< CellElementSubRegion const *, localIndex >; - elemLocations[k] = location; + // BFS queue: each entry is (element, assigned-location). + std::deque< std::pair< ElemKey, int > > bfsQueue; + // Seed the BFS with the first element (sorted by global index) + // on side 0. + ElemKey const seed = *( nodeToElementMaps.cbegin() ); + elemLocations[seed] = 0; + bfsQueue.push_back( { seed, 0 } ); - // loop over all faces on the element - for( localIndex kf=0; kffaceList().size( 1 ); ++kf ) + // ----- Main BFS loop -------------------------------------------------- + while( !bfsQueue.empty() ) { + auto const [currentElem, location] = bfsQueue.front(); + bfsQueue.pop_front(); - // define the actual face index, and the virtual face index - const localIndex faceIndex = k.first->faceList()( k.second, kf ); - const localIndex virtualFaceIndex = ( parentFaceIndices[faceIndex] == -1 ) ? - faceIndex : parentFaceIndices[faceIndex]; + int const otherLocation = ( location == 0 ) ? 1 : 0; - // see if we can find the face in the faceLocations array. - map< localIndex, int >::iterator iterFace = faceLocations.find( faceIndex ); - // if we can find the face in the faceLocations array, then we must process the face, otherwise it is not - // connected to the node, so we do nothing. - if( iterFace != faceLocations.end() ) + // Loop over every face of the current element. + for( localIndex kf = 0; kf < currentElem.first->faceList().size( 1 ); ++kf ) { + localIndex const faceIndex = currentElem.first->faceList()( currentElem.second, kf ); + localIndex const virtualFaceIndex = ( parentFaceIndices[faceIndex] == -1 ) + ? faceIndex : parentFaceIndices[faceIndex]; - if( faceLocations[faceIndex]==otherlocation ) - faceLocations[faceIndex] = -1; + // Only process faces that belong to the splitting node. + if( faceLocations.find( faceIndex ) == faceLocations.end() ) + { + continue; + } + + // --- Assign face location ----------------------------------------- + if( faceLocations[faceIndex] == otherLocation ) + { + faceLocations[faceIndex] = -1; // face is on the separation plane + } else if( faceLocations[faceIndex] == INT_MIN ) + { faceLocations[faceIndex] = location; + } - map< localIndex, std::pair< localIndex, localIndex > >::const_iterator iterF2E = localFacesToEdges.find( faceIndex ); - + // --- Assign edge locations ---------------------------------------- + auto iterF2E = localFacesToEdges.find( faceIndex ); if( iterF2E != localFacesToEdges.end() ) { - const localIndex edge0 = (iterF2E->second).first; - const localIndex edge1 = (iterF2E->second).second; + for( localIndex edgeIdx : { iterF2E->second.first, iterF2E->second.second } ) + { + if( edgeLocations[edgeIdx] == otherLocation ) + { + edgeLocations[edgeIdx] = -1; + } + else if( edgeLocations[edgeIdx] == INT_MIN ) + { + edgeLocations[edgeIdx] = location; + } + } + } + + // --- Enqueue the neighbor element across this face ---------------- + // Skip ghost-boundary faces (second element slot == -1). + if( isGhostBoundaryFace( virtualFaceIndex ) ) + { + continue; + } + + // Both element slots are populated — find the neighbor. + localIndex const er0 = m_originalFacesToElemRegion( virtualFaceIndex, 0 ); + localIndex const esr0 = m_originalFacesToElemSubRegion( virtualFaceIndex, 0 ); + ElemKey const elemKey0 = { &elemManager.getRegion( er0 ).getSubRegion< CellElementSubRegion >( esr0 ), + m_originalFacesToElemIndex( virtualFaceIndex, 0 ) }; - if( edgeLocations[edge0]==otherlocation ) - edgeLocations[edge0] = -1; - else if( edgeLocations[edge0] == INT_MIN ) - edgeLocations[edge0] = location; + localIndex const er1 = m_originalFacesToElemRegion( virtualFaceIndex, 1 ); + localIndex const esr1 = m_originalFacesToElemSubRegion( virtualFaceIndex, 1 ); + ElemKey const elemKey1 = { &elemManager.getRegion( er1 ).getSubRegion< CellElementSubRegion >( esr1 ), + m_originalFacesToElemIndex( virtualFaceIndex, 1 ) }; - if( edgeLocations[edge1]==otherlocation ) - edgeLocations[edge1] = -1; - else if( edgeLocations[edge1] == INT_MIN ) - edgeLocations[edge1] = location; + ElemKey const & neighborElem = ( elemKey0 == currentElem ) ? elemKey1 : elemKey0; + int const neighborLocation = + ( separationPathFaces.count( virtualFaceIndex ) == 0 ) ? location : otherLocation; + // Only enqueue if the neighbor is in the splitting-node's element set + // and has not yet been assigned. + if( std::find( nodeToElementMaps.cbegin(), nodeToElementMaps.cend(), neighborElem ) != nodeToElementMaps.cend() ) + { + if( elemLocations[neighborElem] == INT_MIN ) + { + elemLocations[neighborElem] = neighborLocation; + bfsQueue.push_back( { neighborElem, neighborLocation } ); + } } + } + } + // Fallback sweep: handle unreachable elements by inferring locations from neighbors. + bool progress = true; + while( progress ) + { + progress = false; + // Collect elements that still need assignment. + stdVector< ElemKey > unassigned; + for( auto const & [elem, loc] : elemLocations ) + { + if( loc == INT_MIN ) + { + unassigned.push_back( elem ); + } + } + + for( ElemKey const & elem : unassigned ) + { + // Skip if a previous iteration in this sweep already assigned it. + if( elemLocations[elem] != INT_MIN ) + continue; - // now we add the element that is a neighbor to the face - // of course, this only happens if there are more than one element - // attached to the face. - if( m_originalFacesToElemIndex[virtualFaceIndex][1] != -1 ) + // Try to find a same-node neighbor that has been assigned. + bool found = false; + for( localIndex kf = 0; kf < elem.first->faceList().size( 1 ) && !found; ++kf ) { - localIndex const er0 = m_originalFacesToElemRegion[virtualFaceIndex][0]; - localIndex const er1 = m_originalFacesToElemRegion[virtualFaceIndex][1]; + localIndex const faceIndex = elem.first->faceList()( elem.second, kf ); + localIndex const virtualFaceIndex = ( parentFaceIndices[faceIndex] == -1 ) + ? faceIndex : parentFaceIndices[faceIndex]; - localIndex const esr0 = m_originalFacesToElemSubRegion[virtualFaceIndex][0]; - localIndex const esr1 = m_originalFacesToElemSubRegion[virtualFaceIndex][1]; + // For a ghost-boundary face we can still check the [0]-side + // element — it might be the neighbor we are looking for. + // We just cannot discover elements on the missing [1]-side. + // Check both sides of the face for an assigned neighbor. + for( int side = 0; side < 2; ++side ) + { + localIndex const er = m_originalFacesToElemRegion( virtualFaceIndex, side ); + localIndex const esr = m_originalFacesToElemSubRegion( virtualFaceIndex, side ); + localIndex const ei = m_originalFacesToElemIndex( virtualFaceIndex, side ); - std::pair< CellElementSubRegion const *, localIndex > const - elemIndex0 = { &elemManager.getRegion( er0 ).getSubRegion< CellElementSubRegion >( esr0 ), - m_originalFacesToElemIndex[virtualFaceIndex][0] }; + if( ei == -1 ) + continue; // missing element on this side (ghost boundary) - std::pair< CellElementSubRegion const *, localIndex > const - elemIndex1 = { &elemManager.getRegion( er1 ).getSubRegion< CellElementSubRegion >( esr1 ), - m_originalFacesToElemIndex[virtualFaceIndex][1] }; + ElemKey const neighbor = { &elemManager.getRegion( er ).getSubRegion< CellElementSubRegion >( esr ), ei }; - std::pair< CellElementSubRegion const *, localIndex > const & nextElem = ( elemIndex0 == k ) ? elemIndex1 : elemIndex0; - int const nextLocation = ( separationPathFaces.count( virtualFaceIndex ) == 0 ) ? location : otherlocation; + if( neighbor == elem ) + continue; // that's us, not a neighbor - // if the first element is the one we are on, and the element is attached - // to the splitting node, then add the second element to the list. - if( std::find( nodeToElementMaps.cbegin(), nodeToElementMaps.cend(), nextElem ) != nodeToElementMaps.cend() ) - { - if( elemLocations[nextElem] == INT_MIN ) + auto iterNeighbor = elemLocations.find( neighbor ); + if( iterNeighbor != elemLocations.end() && iterNeighbor->second != INT_MIN ) { - setElemLocations( nextLocation, - nextElem, - separationPathFaces, - elemManager, - faceManager, - nodeToElementMaps, - localFacesToEdges, - edgeLocations, - faceLocations, - elemLocations ); + bool const crossesSeparation = ( separationPathFaces.count( virtualFaceIndex ) > 0 ); + int const inferredLocation = crossesSeparation + ? ( ( iterNeighbor->second == 0 ) ? 1 : 0 ) + : iterNeighbor->second; + + // Assign and seed a mini-BFS from this element. + elemLocations[elem] = inferredLocation; + bfsQueue.push_back( { elem, inferredLocation } ); + progress = true; + found = true; + + // Run the mini-BFS to propagate from the newly assigned element. + while( !bfsQueue.empty() ) + { + auto const [curElem, curLoc] = bfsQueue.front(); + bfsQueue.pop_front(); + int const curOther = ( curLoc == 0 ) ? 1 : 0; + + for( localIndex kf2 = 0; kf2 < curElem.first->faceList().size( 1 ); ++kf2 ) + { + localIndex const fi = curElem.first->faceList()( curElem.second, kf2 ); + localIndex const vfi = ( parentFaceIndices[fi] == -1 ) ? fi : parentFaceIndices[fi]; + + if( faceLocations.find( fi ) == faceLocations.end() ) + continue; + + if( faceLocations[fi] == curOther ) + faceLocations[fi] = -1; + else if( faceLocations[fi] == INT_MIN ) + faceLocations[fi] = curLoc; + + auto iterF2E = localFacesToEdges.find( fi ); + if( iterF2E != localFacesToEdges.end() ) + { + for( localIndex eIdx : { iterF2E->second.first, iterF2E->second.second } ) + { + if( edgeLocations[eIdx] == curOther ) + edgeLocations[eIdx] = -1; + else if( edgeLocations[eIdx] == INT_MIN ) + edgeLocations[eIdx] = curLoc; + } + } + + if( isGhostBoundaryFace( vfi ) ) + continue; + + localIndex const r0 = m_originalFacesToElemRegion( vfi, 0 ); + localIndex const sr0 = m_originalFacesToElemSubRegion( vfi, 0 ); + ElemKey const ek0 = { &elemManager.getRegion( r0 ).getSubRegion< CellElementSubRegion >( sr0 ), + m_originalFacesToElemIndex( vfi, 0 ) }; + + localIndex const r1 = m_originalFacesToElemRegion( vfi, 1 ); + localIndex const sr1 = m_originalFacesToElemSubRegion( vfi, 1 ); + ElemKey const ek1 = { &elemManager.getRegion( r1 ).getSubRegion< CellElementSubRegion >( sr1 ), + m_originalFacesToElemIndex( vfi, 1 ) }; + + ElemKey const & nbr = ( ek0 == curElem ) ? ek1 : ek0; + int const nbrLoc = ( separationPathFaces.count( vfi ) == 0 ) ? curLoc : curOther; + + if( std::find( nodeToElementMaps.cbegin(), nodeToElementMaps.cend(), nbr ) != nodeToElementMaps.cend() ) + { + if( elemLocations[nbr] == INT_MIN ) + { + elemLocations[nbr] = nbrLoc; + bfsQueue.push_back( { nbr, nbrLoc } ); + } + } + } + } + + break; // assigned via this side — stop checking sides } } } @@ -1850,6 +1804,15 @@ void SurfaceGenerator::performFracture( const localIndex nodeID, const map< localIndex, int > & faceLocations, const map< std::pair< CellElementSubRegion const *, localIndex >, int > & elemLocations ) { + GEOS_MARK_FUNCTION; + + + GEOS_MARK_BEGIN( "setup" ); + + GEOS_LOG_LEVEL_BY_RANK( logInfo::SurfaceGenerator, + GEOS_FMT( "SurfaceGenerator Statistics: Splitting node {}. Node duplicates: 1. Associated Faces (before split): {}. Associated Edges (before split): {}", + nodeID, faceLocations.size(), edgeLocations.size() ) ); + int const rank = MpiWrapper::commRank( MPI_COMM_WORLD ); array2d< real64, nodes::REFERENCE_POSITION_PERM > const & X = nodeManager.referencePosition(); @@ -1903,6 +1866,10 @@ void SurfaceGenerator::performFracture( const localIndex nodeID, GEOS_FMT( "Splitting node {} along separation plane faces: {}", nodeID, s.str() ) ); } + GEOS_MARK_END( "setup" ); + + + GEOS_MARK_BEGIN( "node split" ); nodeManager.splitObject( nodeID, rank, newNodeIndex ); @@ -1924,9 +1891,6 @@ void SurfaceGenerator::performFracture( const localIndex nodeID, nodeRuptureTime( newNodeIndex ) = time_np1; //TODO HACK...should recalculate mass -// const real64 newMass = 0.5 * (*nodeManager.m_mass)[nodeID]; -// (*nodeManager.m_mass)[nodeID] = newMass; -// (*nodeManager.m_mass)[newNodeIndex] = newMass; //TODO Either change m_usedFacesForNode to array or add insert with iterator to SortedArray for( auto const val : separationPathFaces ) @@ -1935,13 +1899,12 @@ void SurfaceGenerator::performFracture( const localIndex nodeID, m_usedFacesForNode[newNodeIndex].insert( val ); } -// SortedArray& usedFacesNew = nodeManager.getReference< array1d> -// >("usedFaces")[newNodeIndex]; -// usedFacesNew = usedFaces[nodeID]; - GEOS_LOG_LEVEL_BY_RANK( logInfo::SurfaceGenerator, GEOS_FMT( "Done splitting node {} into nodes {} and {}", nodeID, nodeID, newNodeIndex ) ); + GEOS_MARK_END( "node split" ); + + GEOS_MARK_BEGIN( "edge split" ); // split edges map< localIndex, localIndex > splitEdges; // loop over all edges connected to the node @@ -1997,6 +1960,8 @@ void SurfaceGenerator::performFracture( const localIndex nodeID, } // for( map::const_iterator iter_edge... + GEOS_MARK_END( "edge split" ); + GEOS_MARK_BEGIN( "face split" ); // split the faces array1d< integer > const & ruptureState = faceManager.getField< surfaceGeneration::ruptureState >(); map< localIndex, localIndex > splitFaces; @@ -2018,9 +1983,13 @@ void SurfaceGenerator::performFracture( const localIndex nodeID, if( faceManager.splitObject( faceIndex, rank, newFaceIndex ) ) { + GEOS_MARK_BEGIN( "splitObjectSubScope" ); + GEOS_LOG_LEVEL_BY_RANK( logInfo::SurfaceGenerator, GEOS_FMT ( "Split face {} into faces {} and {}", faceIndex, faceIndex, newFaceIndex ) ); + GEOS_MARK_BEGIN( "splitObjectSubScope1" ); + splitFaces[faceIndex] = newFaceIndex; modifiedObjects.newFaces.insert( newFaceIndex ); modifiedObjects.modifiedFaces.insert( faceIndex ); @@ -2056,7 +2025,8 @@ void SurfaceGenerator::performFracture( const localIndex nodeID, externalFaces.insert( newFaceIndex ); externalFaces.insert( faceIndex ); - + GEOS_MARK_END( "splitObjectSubScope1" ); + GEOS_MARK_BEGIN( "splitObjectSubScope2" ); // Fu: All edges of the parent face should be external now. // We have to do the following because isExternal attribute of the tip edge is not handled by the splitter. for( localIndex const edgeIndex : faceManager.edgeList()[ faceIndex ] ) @@ -2083,6 +2053,8 @@ void SurfaceGenerator::performFracture( const localIndex nodeID, edgeIsExternal[edgeIndex] = 2; } } + GEOS_MARK_END( "splitObjectSubScope2" ); + GEOS_MARK_BEGIN( "splitObjectSubScope3" ); for( localIndex const nodeIndex : faceToNodeMap[ faceIndex ] ) { if( parentNodeIndices[nodeIndex]==-1 && childNodeIndices[nodeIndex]==-1 ) @@ -2095,7 +2067,8 @@ void SurfaceGenerator::performFracture( const localIndex nodeID, nodeIsExternal[nodeIndex] = 2; } } - + GEOS_MARK_END( "splitObjectSubScope3" ); + GEOS_MARK_BEGIN( "splitObjectSubScope4" ); { localIndex faceIndices[2] = {faceIndex, newFaceIndex}; localIndex const @@ -2109,10 +2082,17 @@ void SurfaceGenerator::performFracture( const localIndex nodeID, newFaceElement, newFaceIndex, faceIndex ) ); modifiedObjects.newElements[ {fractureElementRegion.getIndexInParent(), 0} ].insert( newFaceElement ); } + GEOS_MARK_END( "splitObjectSubScope4" ); + + GEOS_MARK_END( "splitObjectSubScope" ); + } // if( faceManager.SplitObject( faceIndex, newFaceIndex ) ) } // if( location == -1 ) } // for( map::const_iterator iter_face + GEOS_MARK_END( "face split" ); + + GEOS_MARK_BEGIN( "correct relations" ); // ***** now correct all the relations between the objects ***** @@ -2492,6 +2472,8 @@ void SurfaceGenerator::performFracture( const localIndex nodeID, } // for( int kf=0 ; kf, int>::const_iterator iter_elem = elemLocations.begin() + + GEOS_MARK_END( "correct relations" ); } @@ -2502,6 +2484,8 @@ void SurfaceGenerator::mapConsistencyCheck( localIndex const GEOS_UNUSED_PARAM( ElementRegionManager const & elementManager, map< std::pair< CellElementSubRegion const *, localIndex >, int > const & elemLocations ) { + GEOS_MARK_FUNCTION; + //************************************************************************** // THIS IS ALL JUST CONSISTENCY CHECKING //************************************************************************** @@ -2874,33 +2858,6 @@ real64 SurfaceGenerator::calculateKinkAngle( localIndex const edgeID, return(-1.0); } else -// { -//// // First check if the two faces are parent-child pairs -//// if (faceManager.m_parentIndex[faces[0]]==faces[1] || faceManager.m_parentIndex[faces[1]]==faces[0] ) -//// { -//// return(0.0); -//// } -// -// R1Tensor vecFace[3]; -// faceManager.InFaceVectorNormalToEdge(nodeManager, edgeManager, faces[0], edgeID, vecFace[0]); -// faceManager.InFaceVectorNormalToEdge(nodeManager, edgeManager, faces[1], edgeID, vecFace[1]); -// vecFace[2] = vecFace[0]; -// vecFace[2] += vecFace[1]; -// vecFace[2] /= 2.0; -// -// kinkAngle = acos(LvArray::tensorOps::AiBi< 3 >(vecFace[0],vecFace[1])*0.999999) / 3.141592653589793238462 * 180.0; -// -// R1Tensor vecFaceNorm; -// vecFaceNorm = faceManager.FaceNormal(nodeManager, faces[0]); -// vecFaceNorm += faceManager.FaceNormal(nodeManager, faces[1]); -// vecFaceNorm /= 2.0; -// -// if (LvArray::tensorOps::AiBi< 3 >(vecFace[2], vecFaceNorm) < 0.0) -// kinkAngle = 360.0 - kinkAngle; -// -// return(kinkAngle); -// -// } return 1e100; } @@ -2910,6 +2867,7 @@ void SurfaceGenerator::calculateKinkAngles( FaceManager const & faceManager, ModifiedObjectLists const & modifiedObjects, bool const prefrac ) { + GEOS_MARK_FUNCTION; arrayView1d< real64 > & kinkAngle = edgeManager.getReference< real64_array >( "kinkAngle" ); if( prefrac ) @@ -2940,16 +2898,14 @@ void SurfaceGenerator::identifyRupturedFaces( DomainPartition const & domain, ElementRegionManager const & elementManager, const bool prefrac ) { + GEOS_MARK_FUNCTION; // We use the color map scheme because we can mark a face to be rupture ready from a partition // where the face is a ghost. if( !m_nodeBasedSIF ) { -// for( int color=0 ; color const & isEdgeGhost = edgeManager.ghostRank(); ModifiedObjectLists modifiedObjects; -// if( partition.Color() == color ) { for( localIndex iEdge = 0; iEdge != edgeManager.size(); ++iEdge ) { @@ -2989,7 +2945,6 @@ void SurfaceGenerator::identifyRupturedFaces( DomainPartition const & domain, } } } -// } } else { @@ -3019,6 +2974,7 @@ void SurfaceGenerator::calculateNodeAndFaceSif( DomainPartition const & domain, FaceManager & faceManager, ElementRegionManager const & elementManager ) { + GEOS_MARK_FUNCTION; arrayView1d< real64 > const & SIFNode = nodeManager.getField< surfaceGeneration::SIFNode >(); arrayView1d< real64 > const & SIFonFace = faceManager.getField< surfaceGeneration::SIFonFace >(); @@ -3187,9 +3143,8 @@ void SurfaceGenerator::calculateNodeAndFaceSif( DomainPartition const & domain, LvArray::tensorOps::scale< 3 >( nodeDisconnectForce, 0.5 ); } - //Find the trailing node according to the node index and face index - if( unpinchedNodeID.size() == 0 ) //Tet mesh under three nodes pinched scenario. Need to find the other - // trailing face that containing the trailing node. + // Find trailing node when no unpinched nodes exist (Tet mesh case). + if( unpinchedNodeID.size() == 0 ) { for( localIndex const edgeIndex: faceToEdgeMap[ trailingFaceIndex ] ) { @@ -3292,8 +3247,8 @@ void SurfaceGenerator::calculateNodeAndFaceSif( DomainPartition const & domain, tipNodeSIF = pow( (fabs( tipNodeForce[0] * trailingNodeDisp[0] / 2.0 / tipArea ) + fabs( tipNodeForce[1] * trailingNodeDisp[1] / 2.0 / tipArea ) + fabs( tipNodeForce[2] * trailingNodeDisp[2] / 2.0 / tipArea )), 0.5 ); - if( LvArray::tensorOps::AiBi< 3 >( trailingNodeDisp, faceNormalVector ) < 0.0 ) //In case the aperture is negative with the - // presence of confining stress. + // Invert SIF if aperture is negative (confining stress). + if( LvArray::tensorOps::AiBi< 3 >( trailingNodeDisp, faceNormalVector ) < 0.0 ) { tipNodeSIF *= -1; } @@ -3385,8 +3340,7 @@ void SurfaceGenerator::calculateNodeAndFaceSif( DomainPartition const & domain, // if( LvArray::tensorOps::AiBi< 3 >( vecTip, vecFace ) > cos( m_maxTurnAngle )) { - // We multiply this by 0.9999999 to avoid an exception caused by acos a number slightly larger than - // 1. + // Clamp argument for acos. real64 thetaFace = acos( LvArray::tensorOps::AiBi< 3 >( vecTip, vecFace )*0.999999 ); real64 tipCrossFace[ 3 ]; @@ -3453,6 +3407,8 @@ real64 SurfaceGenerator::calculateEdgeSif( DomainPartition const & domain, real64 ( & vecTipNorm )[3], real64 ( & vecTip )[3] ) { + GEOS_MARK_FUNCTION; + real64 rval; localIndex_array faceInvolved; arrayView1d< real64 > const & SIF_I = edgeManager.getField< surfaceGeneration::SIF_I >(); @@ -3507,10 +3463,7 @@ real64 SurfaceGenerator::calculateEdgeSif( DomainPartition const & domain, trailFaceID = faceParentIndex[faceInvolved[0]]==-1 ? faceInvolved[0] : faceParentIndex[faceInvolved[0]]; - // We define three unit vectors - // vecEdge: pointing from node 0 to node 1 along the tip edge - // vecTip: pointing from the opening into the solid - // vecTipNorm: normal of the one of the fracture faces; vecTip X vecTipNorm should point to the direction of vecEdge + // Define unit vectors: vecEdge (node0->node1), vecTip (opening->solid), vecTipNorm (face normal). LvArray::tensorOps::copy< 3 >( vecTipNorm, faceNormal[faceA] ); LvArray::tensorOps::subtract< 3 >( vecTipNorm, faceNormal[faceAp] ); @@ -3892,6 +3845,8 @@ int SurfaceGenerator::calculateElementForcesOnEdge( DomainPartition const & doma bool threeNodesPinched, bool calculatef_u ) { + GEOS_MARK_FUNCTION; + ArrayOfArraysView< localIndex const > const & nodeToRegionMap = nodeManager.elementRegionList().toViewConst(); ArrayOfArraysView< localIndex const > const & nodeToSubRegionMap = nodeManager.elementSubRegionList().toViewConst(); ArrayOfArraysView< localIndex const > const & nodeToElementMap = nodeManager.elementList().toViewConst(); @@ -4095,6 +4050,8 @@ int SurfaceGenerator::checkOrphanElement( ElementRegionManager const & elementMa FaceManager const & faceManager, localIndex iFace ) { + GEOS_MARK_FUNCTION; + arrayView2d< localIndex const > const & faceToRegionMap = faceManager.elementRegionList(); arrayView2d< localIndex const > const & faceToSubRegionMap = faceManager.elementSubRegionList(); arrayView2d< localIndex const > const & faceToElementMap = faceManager.elementList(); @@ -4143,6 +4100,8 @@ void SurfaceGenerator::markRuptureFaceFromNode( localIndex const nodeIndex, ElementRegionManager const & GEOS_UNUSED_PARAM( elementManager ), ModifiedObjectLists & modifiedObjects ) { + GEOS_MARK_FUNCTION; + arrayView1d< integer > const & ruptureState = faceManager.getField< surfaceGeneration::ruptureState >(); arrayView1d< real64 const > const & SIFonFace = faceManager.getField< surfaceGeneration::SIFonFace >(); arrayView2d< real64 const > const & KIC = faceManager.getField< surfaceGeneration::K_IC >(); @@ -4194,56 +4153,6 @@ void SurfaceGenerator::markRuptureFaceFromNode( localIndex const nodeIndex, { ruptureState[pickedFace] = 1; modifiedObjects.modifiedFaces.insert( pickedFace ); - - // Next we mark the faces that are 1) connected to this face, and 2) attached to one node of the edge (implicitly - // satisfied), and 3) almost co-plane with this face -// if( m_markExtendedLayer == 1) -// { -// for( auto iedge : faceToEdgeMap[pickedFace] ) -// { -// for( auto iface : edgeToFaceMap[iedge] ) -// { -// if( iface != pickedFace && isFaceSeparable[iface] == 1 && faceManager.isExternal()[iface] < 1 && -// fabs(LvArray::tensorOps::AiBi< 3 >(faceNormals[pickedFace], faceNormals[iface])) > cos( m_maxTurnAngle ) && -// ((faceToNodeMap[iface].size() == 3) || (faceToNodeMap[iface].size() == 4 && -// (std::find(faceToNodeMap[iface].begin(), faceToNodeMap[iface].end(), nodeIndex) != -// faceToNodeMap[iface].end())))) -// { -// //wu40: Under tet mesh scenario, the face next to the pickedFace should also be marked but it may not -// necessarily connect to the tip node. -// bool ruptureFace = true; -// for (auto edgeIndex: faceToEdgeMap[pickedFace]) -// { -// if (m_tipEdges.contains(edgeIndex)) -// { -// R1Tensor fc; -// real64 uDist, segmentLength; -// -// fc = faceCenter[iface]; -// -// R1Tensor x0_x1(X[edgeToNodeMap[edgeIndex][0]]), x0_fc(fc); -// x0_x1 -= X[edgeToNodeMap[edgeIndex][1]]; -// segmentLength = x0_x1.Normalize(); -// x0_fc -= X[edgeToNodeMap[edgeIndex][1]]; -// uDist = LvArray::tensorOps::AiBi< 3 >(x0_x1, x0_fc); -// -// if (uDist / segmentLength < -m_faceToEdgeProjectionTol || uDist / segmentLength > 1 + -// m_faceToEdgeProjectionTol) -// { -// ruptureFace = false; -// } -// } -// } -// -// if (ruptureFace) -// { -// ruptureState[iface] = 1; -// modifiedObjects.modifiedFaces.insert( iface ); -// } -// } -// } -// } -// } } } } @@ -4259,6 +4168,8 @@ void SurfaceGenerator::markRuptureFaceFromEdge( localIndex const edgeID, ModifiedObjectLists & modifiedObjects, int const edgeMode ) { + GEOS_MARK_FUNCTION; + arrayView1d< integer > const & ruptureState = faceManager.getField< surfaceGeneration::ruptureState >(); arrayView1d< real64 > const & SIFonFace = faceManager.getField< surfaceGeneration::SIFonFace >(); arrayView2d< real64 const > const & KIC = faceManager.getField< surfaceGeneration::K_IC >(); @@ -4399,88 +4310,14 @@ void SurfaceGenerator::markRuptureFaceFromEdge( localIndex const edgeID, if( highestSIF > 1.0 && edgeMode == 1 && i == 0 && isFaceSeparable[pickedFace] == 1 ) { ruptureState[pickedFace] = 1; -// if( !m_dfnPrefix.empty()) -// (*dfnIndexMap)[pickedFace] = (*dfnIndexMap)[trailFaceID]; modifiedObjects.modifiedFaces.insert( pickedFace ); } else if( highestSIF > 1.0 && edgeMode == 1 && i == 1 && isFaceSeparable[pickedFace] == 1 ) { ruptureState[pickedFace] = -1; -// if( !m_dfnPrefix.empty()) -// (*dfnIndexMap)[pickedFace] = (*dfnIndexMap)[trailFaceID]; modifiedObjects.modifiedFaces.insert( pickedFace ); primaryCandidateFace[pickedFace] = faceWithHighestScore; } - - - // We didn't really need to do this unless the criterion above has been satisfied. - // We are calculating this regardless the criterion for debugging purpose. -// if( m_markExtendedLayer == 1 && highestSIF > 1.0 && edgeMode == 1 ) -// { -// // Next we mark the faces that are 1) connected to this face, and 2) attached to one node of the edge -// (implicitly -// // satisfied), and 3) almost co-plane with this face -// for( auto iedge : faceToEdgeMap[pickedFace] ) -// { -// if( iedge != edgeID ) -// { -// for( auto iface : edgeToFaceMap[iedge] ) -// { -// if( iface != pickedFace && isFaceSeparable[iface] == 1 && faceManager.isExternal()[iface] < 1 && -// ( std::find(faceToNodeMap[iface].begin(), faceToNodeMap[iface].end(), edgeToNodeMap[edgeID][0]) != -// faceToNodeMap[iface].end() || -// std::find(faceToNodeMap[iface].begin(), faceToNodeMap[iface].end(), edgeToNodeMap[edgeID][1]) != -// faceToNodeMap[iface].end())) -// { -// R1Tensor fc, fn, vecFace, fn0, ptPrj; -// real64 uDist, segmentLength; -// -// fc = faceCenter[iface]; -// fn = faceNormal[iface]; -// fn0 = faceNormal[pickedFace]; -// -// R1Tensor x0_x1(X[edgeToNodeMap[edgeID][0]]), x0_fc(fc); -// x0_x1 -= X[edgeToNodeMap[edgeID][1]]; -// segmentLength = x0_x1.Normalize(); -// x0_fc -= X[edgeToNodeMap[edgeID][1]]; -// uDist = LvArray::tensorOps::AiBi< 3 >(x0_x1, x0_fc); -// -// ptPrj = x0_x1; -// ptPrj *= uDist; -// ptPrj += X[edgeToNodeMap[edgeID][1]]; -// vecFace = fc; -// vecFace -= ptPrj; -// vecFace.Normalize(); -// -// // thetaFace does not strictly speaking apply to this face since the tip edge is not a edge of this -// face. -// // We calculate it as if this face is coplane with the master face -// real64 thetaFace = acos( LvArray::tensorOps::AiBi< 3 >( vecTip, vecFace )*0.999999 ); -// if( LvArray::tensorOps::AiBi< 3 >( Cross( vecTip, vecFace ), vecEdge ) < 0.0 ) -// { -// thetaFace *= -1.0; -// } -// -// if( LvArray::tensorOps::AiBi< 3 >( vecTip, vecFace ) > cos( m_maxTurnAngle ) && -// uDist / segmentLength > -m_faceToEdgeProjectionTol && -// uDist / segmentLength < 1 + m_faceToEdgeProjectionTol && -// fabs( LvArray::tensorOps::AiBi< 3 >( vecEdge, fn )) < m_faceToEdgeCoplaneTol && // this face is kind of parallel to the -// tip -// // edge. -// fabs( LvArray::tensorOps::AiBi< 3 >( fn0, fn )) > 1 - m_faceToFaceCoplaneTol ) // co-plane -// { -// if( highestSIF > 1.0 && edgeMode == 1 ) -// { -// ruptureState[iface] = ruptureState[pickedFace]; -// modifiedObjects.modifiedFaces.insert( iface ); -// primaryCandidateFace[iface] = primaryCandidateFace[pickedFace]; -// } -// } -// } -// } -// } -// } -// } } } @@ -4491,6 +4328,8 @@ void SurfaceGenerator::postUpdateRuptureStates( NodeManager const & nodeManager, stdVector< std::set< localIndex > > & nodesToRupturedFaces, stdVector< std::set< localIndex > > & edgesToRupturedFaces ) { + GEOS_MARK_FUNCTION; + ArrayOfArraysView< localIndex const > const & faceToNodeMap = faceManager.nodeList().toViewConst(); ArrayOfArraysView< localIndex const > const & faceToEdgeMap = faceManager.edgeList().toViewConst(); nodesToRupturedFaces.resize( nodeManager.size() ); @@ -4525,12 +4364,186 @@ void SurfaceGenerator::postUpdateRuptureStates( NodeManager const & nodeManager, } } +stdVector< std::set< localIndex > > SurfaceGenerator::groupRupturedFacesIntoSets( + stdVector< std::set< localIndex > > const & nodesToRupturedFaces, + NodeManager const & nodeManager, + FaceManager const & faceManager ) const +{ + GEOS_MARK_FUNCTION; + + // Collect all unique ruptured face indices. + std::set< localIndex > allFaces; + for( localIndex ni = 0; ni < static_cast< localIndex >( nodesToRupturedFaces.size() ); ++ni ) + { + for( localIndex const fi : nodesToRupturedFaces[ni] ) + { + allFaces.insert( fi ); + } + } + + if( allFaces.empty() ) + { + return {}; + } + + // Union-Find data structure (map-based so we don't need a dense array). + // std::map is used instead of std::unordered_map to guarantee deterministic + // iteration order across platforms (libstdc++ vs libc++) and MPI runs. + std::map< localIndex, localIndex > parent; + std::map< localIndex, localIndex > rank; + + for( localIndex const fi : allFaces ) + { + parent[fi] = fi; + rank[fi] = 0; + } + + // Find with path compression. + std::function< localIndex( localIndex ) > findRoot = [&]( localIndex x ) -> localIndex + { + if( parent[x] != x ) + { + parent[x] = findRoot( parent[x] ); + } + return parent[x]; + }; + + // Union by rank. + auto unionSets = [&]( localIndex a, localIndex b ) + { + localIndex ra = findRoot( a ); + localIndex rb = findRoot( b ); + if( ra == rb ) + return; + if( rank[ra] < rank[rb] ) + std::swap( ra, rb ); + parent[rb] = ra; + if( rank[ra] == rank[rb] ) + ++rank[ra]; + }; + + // Two ruptured faces sharing a node belong to the same fracture set. + // Iterate through nodesToRupturedFaces: for each node that touches + // more than one ruptured face, union all those faces together. + GEOS_UNUSED_VAR( nodeManager ); + for( localIndex ni = 0; ni < static_cast< localIndex >( nodesToRupturedFaces.size() ); ++ni ) + { + std::set< localIndex > const & faces = nodesToRupturedFaces[ni]; + if( faces.size() <= 1 ) + continue; + auto it = faces.begin(); + localIndex const first = *it; + ++it; + for(; it != faces.end(); ++it ) + { + unionSets( first, *it ); + } + } + + // Gather connected components. + // std::map guarantees deterministic iteration order (by sorted key), + // so the result vector is built in the same order on every platform/rank. + std::map< localIndex, std::set< localIndex > > components; + for( localIndex const fi : allFaces ) + { + components[findRoot( fi )].insert( fi ); + } + + // Convert to a vector. + stdVector< std::set< localIndex > > result; + result.reserve( components.size() ); + for( auto & kv : components ) + { + result.push_back( std::move( kv.second ) ); + } + + // Sort by the minimum global face index in each set. + // This guarantees that every MPI rank processes the same fracture + // at the same loop iteration, which is required because + // synchronizeTopologyChange is called collectively after each set. + GEOS_UNUSED_VAR( nodeManager ); + arrayView1d< globalIndex const > const & faceLocalToGlobal = faceManager.localToGlobalMap(); + std::sort( result.begin(), result.end(), + [&faceLocalToGlobal]( std::set< localIndex > const & a, + std::set< localIndex > const & b ) + { + // Compute minimum global face index for each set. + globalIndex minA = std::numeric_limits< globalIndex >::max(); + for( localIndex const fi : a ) + { + minA = std::min( minA, faceLocalToGlobal[fi] ); + } + globalIndex minB = std::numeric_limits< globalIndex >::max(); + for( localIndex const fi : b ) + { + minB = std::min( minB, faceLocalToGlobal[fi] ); + } + return minA < minB; + } ); + + return result; +} + +void SurfaceGenerator::buildFilteredRuptureMaps( + std::set< localIndex > const & fractureSetFaces, + NodeManager const & nodeManager, + EdgeManager const & edgeManager, + FaceManager const & faceManager, + stdVector< std::set< localIndex > > & nodesToRupturedFaces, + stdVector< std::set< localIndex > > & edgesToRupturedFaces ) const +{ + GEOS_MARK_FUNCTION; + + ArrayOfArraysView< localIndex const > const & faceToNodeMap = faceManager.nodeList().toViewConst(); + ArrayOfArraysView< localIndex const > const & faceToEdgeMap = faceManager.edgeList().toViewConst(); + + nodesToRupturedFaces.clear(); + edgesToRupturedFaces.clear(); + nodesToRupturedFaces.resize( nodeManager.size() ); + edgesToRupturedFaces.resize( edgeManager.size() ); + + arrayView1d< integer const > const & faceRuptureState = faceManager.getField< surfaceGeneration::ruptureState >(); + arrayView1d< localIndex const > const & faceParentIndex = faceManager.getField< fields::parentIndex >(); + + // Iterate over all faces. Only include a face if: + // 1) its rupture state > 0 (same criterion as postUpdateRuptureStates), AND + // 2) its parent face index belongs to the current fracture set. + for( localIndex kf = 0; kf < faceManager.size(); ++kf ) + { + if( faceRuptureState[kf] <= 0 ) + continue; + + localIndex const parentFace = ( faceParentIndex[kf] == -1 ) ? kf : faceParentIndex[kf]; + + // Skip faces that don't belong to this fracture set. + if( fractureSetFaces.count( parentFace ) == 0 ) + continue; + + int const n = ( faceParentIndex[kf] == -1 ) ? 1 : 2; + for( int i = 0; i < n; ++i ) + { + for( localIndex a = 0; a < faceToNodeMap.sizeOfArray( kf ); ++a ) + { + localIndex const nodeIndex = faceToNodeMap( kf, a ); + nodesToRupturedFaces[nodeIndex].insert( parentFace ); + } + for( localIndex a = 0; a < faceToEdgeMap.sizeOfArray( kf ); ++a ) + { + localIndex const edgeIndex = faceToEdgeMap( kf, a ); + edgesToRupturedFaces[edgeIndex].insert( parentFace ); + } + } + } +} + int SurfaceGenerator::checkEdgeSplitability( localIndex const edgeID, NodeManager const & GEOS_UNUSED_PARAM( nodeManager ), FaceManager const & faceManager, EdgeManager const & edgeManager, bool const GEOS_UNUSED_PARAM( prefrac ) ) { + GEOS_MARK_FUNCTION; + // Return value = -1, this edge won't split for sure, don't do any more work; // = 0, edge is along a tip, but the fracture connected to it is not saturated yet. We will only // calculate SIF but will not perform splitting. @@ -4614,6 +4627,8 @@ real64 SurfaceGenerator::minimumToughnessOnEdge( localIndex const edgeID, EdgeManager const & edgeManager, FaceManager const & faceManager ) { + GEOS_MARK_FUNCTION; + real64 val = std::numeric_limits< real64 >::max(); arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const & X = nodeManager.referencePosition(); @@ -4646,6 +4661,8 @@ real64 SurfaceGenerator::minimumToughnessOnNode( localIndex const nodeID, EdgeManager const & edgeManager, FaceManager const & faceManager ) { + GEOS_MARK_FUNCTION; + arrayView2d< real64 const, nodes::REFERENCE_POSITION_USD > const & X = nodeManager.referencePosition(); ArrayOfSetsView< localIndex const > const & nodeToFaceMap = nodeManager.faceList().toViewConst(); @@ -4683,6 +4700,7 @@ real64 SurfaceGenerator::minimumToughnessOnNode( localIndex const nodeID, void SurfaceGenerator::assignNewGlobalIndicesSerial( ObjectManagerBase & object, std::set< localIndex > const & indexList ) { + GEOS_MARK_FUNCTION; // in serial, we can simply loop over the indexList and assign new global indices based on // the value of the maxGlobalIndex() + 1; arrayView1d< globalIndex > const & localToGlobal = object.localToGlobalMap(); @@ -4700,6 +4718,8 @@ void SurfaceGenerator::assignNewGlobalIndicesSerial( ObjectManagerBase & object, void SurfaceGenerator::assignNewGlobalIndicesSerial( ElementRegionManager & elementManager, map< std::pair< localIndex, localIndex >, std::set< localIndex > > const & newElems ) { + GEOS_MARK_FUNCTION; + // in serial, we can simply iterate over the entries in newElems and assign new global indices based on // the value of the maxGlobalIndex() + 1 for the ElementRegionManager. @@ -4729,6 +4749,8 @@ void SurfaceGenerator::assignNewGlobalIndicesSerial( ElementRegionManager & elem real64 SurfaceGenerator::calculateRuptureRate( SurfaceElementRegion & faceElementRegion ) { + GEOS_MARK_FUNCTION; + real64 maxRuptureRate = 0; FaceElementSubRegion & subRegion = faceElementRegion.getSubRegion< FaceElementSubRegion >( 0 ); @@ -4788,6 +4810,8 @@ real64 SurfaceGenerator::scalingToughness( R1Tensor const fractureOrigin, real64 const initialRockToughness, real64 const toughnessScalingFactor ) { + GEOS_MARK_FUNCTION; + real64 const distance = sqrt( (fractureOrigin[0] - faceCenter[0])*(fractureOrigin[0] - faceCenter[0]) + (fractureOrigin[1] - faceCenter[1])*(fractureOrigin[1] - faceCenter[1]) + (fractureOrigin[2] - faceCenter[2])*(fractureOrigin[2] - faceCenter[2]) ); diff --git a/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.hpp b/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.hpp index 47c45b3891e..48c6c669f3b 100644 --- a/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.hpp +++ b/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.hpp @@ -253,6 +253,45 @@ class SurfaceGenerator : public PhysicsSolverBase stdVector< std::set< localIndex > > & nodesToRupturedFaces, stdVector< std::set< localIndex > > & edgesToRupturedFaces ); + /** + * @brief Group ruptured faces into disjoint fracture sets using connected-component analysis. + * + * Two ruptured faces belong to the same fracture set if they share at least one node. + * This uses a union-find (disjoint-set) algorithm on the face connectivity graph. + * + * @param[in] nodesToRupturedFaces Per-node sets of ruptured parent-face indices. + * @param[in] nodeManager Node manager for size information. + * @param[in] faceManager Face manager (provides localToGlobalMap for + * deterministic cross-rank ordering of the returned sets). + * @return A vector of fracture sets, where each set contains the parent-face indices + * belonging to one connected fracture component. The vector is sorted by the + * minimum global face index in each set so that every MPI rank processes the + * same fracture at the same loop iteration. + */ + stdVector< std::set< localIndex > > groupRupturedFacesIntoSets( + stdVector< std::set< localIndex > > const & nodesToRupturedFaces, + NodeManager const & nodeManager, + FaceManager const & faceManager ) const; + + /** + * @brief Build filtered nodesToRupturedFaces and edgesToRupturedFaces maps + * containing only faces that belong to the given fracture set. + * + * @param[in] fractureSetFaces The set of ruptured parent-face indices for one fracture. + * @param[in] nodeManager Node manager. + * @param[in] edgeManager Edge manager. + * @param[in] faceManager Face manager. + * @param[out] nodesToRupturedFaces Filtered per-node sets of ruptured faces. + * @param[out] edgesToRupturedFaces Filtered per-edge sets of ruptured faces. + */ + void buildFilteredRuptureMaps( + std::set< localIndex > const & fractureSetFaces, + NodeManager const & nodeManager, + EdgeManager const & edgeManager, + FaceManager const & faceManager, + stdVector< std::set< localIndex > > & nodesToRupturedFaces, + stdVector< std::set< localIndex > > & edgesToRupturedFaces ) const; + /** * * @param elementManager @@ -372,50 +411,44 @@ class SurfaceGenerator : public PhysicsSolverBase map< std::pair< CellElementSubRegion const *, localIndex >, int > const & elemLocations ); /** - * @brief function to set which side of the fracture plane all objects are on - * @param separationPathFaces - * @param elemManager - * @param faceManager - * @param nodeToElementMaps The vector is assumed not to contain any duplicate. - * @param localFacesToEdges - * @param edgeLocations - * @param faceLocations - * @param elemLocations - * @return - */ - bool setLocations( std::set< localIndex > const & separationPathFaces, - ElementRegionManager const & elemManager, - FaceManager const & faceManager, - stdVector< std::pair< CellElementSubRegion const *, localIndex > > const & nodeToElementMaps, - map< localIndex, std::pair< localIndex, localIndex > > const & localFacesToEdges, - map< localIndex, int > & edgeLocations, - map< localIndex, int > & faceLocations, - map< std::pair< CellElementSubRegion const *, localIndex >, int > & elemLocations ); - - /** - * @brief function to set which side of the fracture plane all objects are on - * @param location - * @param elem - * @param separationPathFaces - * @param elemManager - * @param faceManager - * @param nodesToElements The vector is assumed not to contain any duplicate. - * @param localFacesToEdges - * @param edgeLocations - * @param faceLocations - * @param elemLocations - * @return + * @brief Assign fracture-plane sides to all elements, faces, and edges + * around a splitting node using breadth-first-search (BFS). + * + * Starting from the first element in @p nodeToElementMaps (which is sorted + * by global index for determinism), the BFS assigns location 0 to that + * element and propagates through the face-to-element connectivity graph. + * When the traversal crosses a face in @p separationPathFaces the location + * flips from 0 to 1 (or vice-versa). + * + * Ghost-boundary faces (where the second element slot is -1 because the + * neighbor lives on a different MPI rank) are handled gracefully: the BFS + * simply does not cross those faces. After the main BFS completes, a + * fallback sweep assigns any elements that were left unreached (INT_MIN) + * by finding a same-node neighbor that *has* been assigned and propagating + * through non-separation faces. + * + * @param[in] separationPathFaces Set of face indices that define the + * fracture plane. + * @param[in] elemManager Element region manager for subregion lookups. + * @param[in] faceManager Face manager for parent-index queries. + * @param[in] nodeToElementMaps Deterministically-sorted list of + * (subRegion*, localElemIndex) pairs. + * @param[in] localFacesToEdges Map from face → (edge0, edge1) for the + * two edges on the face that are attached to the splitting node. + * @param[out] edgeLocations Assigned side for each edge (0, 1, or -1 + * for edges on the fracture plane). + * @param[out] faceLocations Assigned side for each face (0, 1, or -1). + * @param[out] elemLocations Assigned side for each element (0 or 1). + * @return @c true always (kept for API compatibility). */ - bool setElemLocations( int const location, - std::pair< CellElementSubRegion const *, localIndex > const & elem, - std::set< localIndex > const & separationPathFaces, - ElementRegionManager const & elemManager, - FaceManager const & faceManager, - stdVector< std::pair< CellElementSubRegion const *, localIndex > > const & nodesToElements, - map< localIndex, std::pair< localIndex, localIndex > > const & localFacesToEdges, - map< localIndex, int > & edgeLocations, - map< localIndex, int > & faceLocations, - map< std::pair< CellElementSubRegion const *, localIndex >, int > & elemLocations ); + bool assignLocationsBFS( std::set< localIndex > const & separationPathFaces, + ElementRegionManager const & elemManager, + FaceManager const & faceManager, + stdVector< std::pair< CellElementSubRegion const *, localIndex > > const & nodeToElementMaps, + map< localIndex, std::pair< localIndex, localIndex > > const & localFacesToEdges, + map< localIndex, int > & edgeLocations, + map< localIndex, int > & faceLocations, + map< std::pair< CellElementSubRegion const *, localIndex >, int > & elemLocations ); /** * @@ -486,6 +519,25 @@ class SurfaceGenerator : public PhysicsSolverBase real64 calculateRuptureRate( SurfaceElementRegion & faceElementRegion ); + /** + * @brief Check whether a face lies on a partition boundary with incomplete + * element connectivity. + * + * On a partitioned mesh, an internal face shared between two MPI domains + * has its second element slot set to -1 on the rank that does not own the + * neighboring element. All fracture-path and flood-fill algorithms must + * handle these faces gracefully (e.g. by skipping neighbor traversal) + * instead of blindly de-referencing the -1 indices. + * + * @param faceIndex The local index of the face (use the *virtual/parent* + * face index when working with split faces). + * @return @c true if the face has only one locally-known attached element. + */ + bool isGhostBoundaryFace( localIndex const faceIndex ) const + { + return m_originalFacesToElemIndex( faceIndex, 1 ) == -1; + } + real64 scalingToughness( R1Tensor const fractureOrigin, real64 const (&faceCenter)[3], real64 const initialRockToughness, @@ -578,6 +630,10 @@ class SurfaceGenerator : public PhysicsSolverBase SortedArray< localIndex > m_faceElemsRupturedThisSolve; + /// Number of locally-owned fracture elements at the start of the current solve step. + /// Used to compute "new fracture elements" = total_after - total_before. + localIndex m_numFractureElementsBefore = 0; + }; } /* namespace geos */ diff --git a/src/docs/sphinx/basicExamples/hydraulicFracturing/Example.rst b/src/docs/sphinx/basicExamples/hydraulicFracturing/Example.rst index 67145ef2456..88995f062b1 100644 --- a/src/docs/sphinx/basicExamples/hydraulicFracturing/Example.rst +++ b/src/docs/sphinx/basicExamples/hydraulicFracturing/Example.rst @@ -162,6 +162,15 @@ Similar to other coupled physics solvers, the Hydrofracture solver is specified The final solver present in this example is the SurfaceGenerator, which manages how faces in the model break. +.. note:: + The SurfaceGenerator provides detailed logging to track fracture growth. Set ``logLevel="1"`` on the SurfaceGenerator solver to see per-rank breakdown of fracture element creation during mesh splitting. The default output (at ``logLevel="0"``) shows global statistics including: + + - Number of nodes split + - New fracture elements created + - Total fracture elements (cumulative) + + This information is helpful for monitoring fracture propagation and debugging mesh splitting issues. + .. literalinclude:: ../../../../../inputFiles/hydraulicFracturing/heterogeneousInSitu_base.xml :language: xml :start-after: