From 3bda7f6cff8392734c3dec208122d533ac85bf98 Mon Sep 17 00:00:00 2001 From: Nicolas Pillardou <71120126+npillardou@users.noreply.github.com> Date: Wed, 15 Apr 2026 00:34:15 +0200 Subject: [PATCH 01/53] feat: Add Young Modulus & Poisson import from VTK mesh (#4021) * Add Poisson's ratio and Young's modulus to register data fields * Delete comments * Change logs * regenerate schema after adding youngModulus/poissonRatio fields to ElasticIsotropic * Uncrustify * Rebaseline --------- Co-authored-by: Jian Huang <53012159+jhuang2601@users.noreply.github.com> Co-authored-by: dkachuma --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 4 + .../constitutive/solid/ElasticIsotropic.cpp | 88 +++++++++++++++++++ .../constitutive/solid/ElasticIsotropic.hpp | 9 ++ .../constitutive/solid/SolidFields.hpp | 16 ++++ src/coreComponents/schema/schema.xsd.other | 44 ++++++++++ 6 files changed, 162 insertions(+), 1 deletion(-) diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index 1730dfbd691..b262b6aa27b 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr3883-16299-3037085 + baseline: integratedTests/baseline_integratedTests-pr4021-16339-bb862da allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index 843f5a9564f..e1c07a01361 100644 --- a/BASELINE_NOTES.md +++ b/BASELINE_NOTES.md @@ -5,6 +5,10 @@ This file is designed to track changes to the integrated test baselines. Any developer who updates the baseline ID in the .integrated_tests.yaml file is expected to create an entry in this file with the pull request number, date, and their justification for rebaselining. These notes should be in reverse-chronological order, and use the following time format: (YYYY-MM-DD). +PR #4021 (2026-04-14) +===================== +Add Young Modulus & Poisson import from VTK mesh + PR #3883 (2026-04-10) ===================== Move PVT Driver tests from unit tests to integrated tests diff --git a/src/coreComponents/constitutive/solid/ElasticIsotropic.cpp b/src/coreComponents/constitutive/solid/ElasticIsotropic.cpp index be60e9fd6ee..95ed49740c7 100644 --- a/src/coreComponents/constitutive/solid/ElasticIsotropic.cpp +++ b/src/coreComponents/constitutive/solid/ElasticIsotropic.cpp @@ -19,6 +19,7 @@ #include "ElasticIsotropic.hpp" #include "SolidFields.hpp" +#include "common/MpiWrapper.hpp" namespace geos { @@ -54,6 +55,10 @@ ElasticIsotropic::ElasticIsotropic( string const & name, Group * const parent ): registerField< fields::solid::bulkModulus >( &m_bulkModulus ); registerField< fields::solid::shearModulus >( &m_shearModulus ); + + registerField< fields::solid::youngModulus >( &m_youngModulus ); + + registerField< fields::solid::poissonRatio >( &m_poissonRatio ); } void ElasticIsotropic::postInputInitialization() @@ -147,6 +152,89 @@ void ElasticIsotropic::postInputInitialization() setApplyDefaultValue( m_defaultShearModulus ); } +void ElasticIsotropic::initializePostInitialConditionsPreSubGroups() +{ + SolidBase::initializePostInitialConditionsPreSubGroups(); + + // If per-cell Young's modulus and Poisson's ratio were imported from an external mesh + // convert them to bulk and shear modulus on a cell-by-cell basis. + arrayView1d< real64 const > const youngMod = m_youngModulus; + arrayView1d< real64 const > const nu = m_poissonRatio; + arrayView1d< real64 > const bulkMod = m_bulkModulus; + arrayView1d< real64 > const shearMod = m_shearModulus; + + localIndex numConverted = 0; + localIndex numInvalidE = 0; + localIndex numInvalidNu = 0; + localIndex numNegativeNu = 0; + + for( localIndex k = 0; k < m_youngModulus.size(); ++k ) + { + // youngModulus default is 0: negative values are invalid, zero means not imported + if( youngMod[k] < 0.0 ) + { + ++numInvalidE; + continue; + } + + // youngModulus default is 0: not imported — skip silently + if( !( youngMod[k] > 0.0 ) ) + continue; + + // E was imported and is positive: nu must also be valid + if( nu[k] <= -0.5 || nu[k] >= 0.5 ) + { + ++numInvalidNu; + continue; + } + + // Count negative Poisson's ratio (physically unusual but not always invalid) + if( nu[k] < 0.0 ) + ++numNegativeNu; + + bulkMod[k] = conversions::youngModAndPoissonRatio::toBulkMod( youngMod[k], nu[k] ); + shearMod[k] = conversions::youngModAndPoissonRatio::toShearMod( youngMod[k], nu[k] ); + ++numConverted; + } + + // Aggregate counters across all MPI ranks to report global totals + localIndex const globalConverted = MpiWrapper::sum( numConverted ); + localIndex const globalInvalidE = MpiWrapper::sum( numInvalidE ); + localIndex const globalInvalidNu = MpiWrapper::sum( numInvalidNu ); + localIndex const globalNegativeNu = MpiWrapper::sum( numNegativeNu ); + + if( globalConverted + globalInvalidE + globalInvalidNu > 0 ) + { + GEOS_LOG_RANK_0_IF( globalInvalidE > 0, + GEOS_FMT( "ElasticIsotropic '{}': {} element(s) had negative Young's modulus " + "and were skipped (default bulk/shear modulus used).", + getName(), globalInvalidE ) ); + + GEOS_LOG_RANK_0_IF( globalInvalidNu > 0, + GEOS_FMT( "ElasticIsotropic '{}': {} element(s) had Poisson's ratio outside " + "(-0.5, 0.5) and were skipped (default bulk/shear modulus used).", + getName(), globalInvalidNu ) ); + + GEOS_LOG_RANK_0_IF( globalNegativeNu > 0, + GEOS_FMT( "ElasticIsotropic '{}': {} element(s) have a negative Poisson's ratio. " + "Please verify your input data.", + getName(), globalNegativeNu ) ); + + GEOS_LOG_RANK_0( GEOS_FMT( "ElasticIsotropic '{}': per-cell E/nu conversion — " + "{} converted, {} skipped (invalid E), {} skipped (invalid nu), " + "{} with negative nu.", + getName(), globalConverted, globalInvalidE, globalInvalidNu, globalNegativeNu ) ); + } + + // Back-compute E and nu for all cells from the final K/G so that output fields are meaningful + // for both imported and default cells. + for( localIndex k = 0; k < m_bulkModulus.size(); ++k ) + { + m_youngModulus[k] = conversions::bulkModAndShearMod::toYoungMod( bulkMod[k], shearMod[k] ); + m_poissonRatio[k] = conversions::bulkModAndShearMod::toPoissonRatio( bulkMod[k], shearMod[k] ); + } +} + REGISTER_CATALOG_ENTRY( ConstitutiveBase, ElasticIsotropic, string const &, Group * const ) } } /* namespace geos */ diff --git a/src/coreComponents/constitutive/solid/ElasticIsotropic.hpp b/src/coreComponents/constitutive/solid/ElasticIsotropic.hpp index a6663232fe8..79c186a5c06 100644 --- a/src/coreComponents/constitutive/solid/ElasticIsotropic.hpp +++ b/src/coreComponents/constitutive/solid/ElasticIsotropic.hpp @@ -573,6 +573,9 @@ class ElasticIsotropic : public SolidBase /// Post-process XML data virtual void postInputInitialization() override; + /// Convert per-cell Young's modulus / Poisson's ratio to bulk / shear modulus if imported from mesh + virtual void initializePostInitialConditionsPreSubGroups() override; + /// The default value of the bulk modulus for any new allocations. real64 m_defaultBulkModulus; @@ -585,6 +588,12 @@ class ElasticIsotropic : public SolidBase /// The shear modulus for each upper level dimension (i.e. cell) of *this array1d< real64 > m_shearModulus; + /// Young's modulus per cell (optional; used only when imported from an external mesh) + array1d< real64 > m_youngModulus; + + /// Poisson's ratio per cell (optional; used only when imported from an external mesh) + array1d< real64 > m_poissonRatio; + }; } /* namespace constitutive */ diff --git a/src/coreComponents/constitutive/solid/SolidFields.hpp b/src/coreComponents/constitutive/solid/SolidFields.hpp index dc98487c15a..8ed466eadc7 100644 --- a/src/coreComponents/constitutive/solid/SolidFields.hpp +++ b/src/coreComponents/constitutive/solid/SolidFields.hpp @@ -74,6 +74,22 @@ DECLARE_FIELD( shearModulus, WRITE_AND_READ, "Shear modulus" ); +DECLARE_FIELD( youngModulus, + "youngModulus", + array1d< real64 >, + 0, + NOPLOT, + WRITE_AND_READ, + "Young's modulus (per-cell, used when imported from external mesh; converted to bulk/shear modulus at initialization)" ); + +DECLARE_FIELD( poissonRatio, + "poissonRatio", + array1d< real64 >, + 0, + NOPLOT, + WRITE_AND_READ, + "Poisson's ratio (per-cell, used when imported from external mesh; converted to bulk/shear modulus at initialization)" ); + DECLARE_FIELD( biotCoefficient, "biotCoefficient", array1d< real64 >, diff --git a/src/coreComponents/schema/schema.xsd.other b/src/coreComponents/schema/schema.xsd.other index ffe564b7c6e..c7434b7b99c 100644 --- a/src/coreComponents/schema/schema.xsd.other +++ b/src/coreComponents/schema/schema.xsd.other @@ -2071,12 +2071,16 @@ A field can represent a physical variable. (pressure, temperature, global compos + + + + @@ -2506,6 +2510,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + @@ -2518,6 +2524,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + @@ -2548,6 +2556,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + @@ -2560,6 +2570,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + @@ -2584,6 +2596,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + @@ -2596,6 +2610,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + @@ -2664,6 +2680,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + @@ -2678,6 +2696,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + @@ -2696,12 +2716,16 @@ A field can represent a physical variable. (pressure, temperature, global compos + + + + @@ -2710,12 +2734,16 @@ A field can represent a physical variable. (pressure, temperature, global compos + + + + @@ -2808,6 +2836,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + @@ -2820,6 +2850,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + @@ -2959,6 +2991,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + @@ -2967,6 +3001,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + @@ -3406,12 +3442,16 @@ A field can represent a physical variable. (pressure, temperature, global compos + + + + @@ -3428,6 +3468,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + @@ -3440,6 +3482,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + From afa830a5bcb86ed3fd62716100ae718e144390e6 Mon Sep 17 00:00:00 2001 From: "Victor A. P. Magri" <50467563+victorapm@users.noreply.github.com> Date: Wed, 15 Apr 2026 19:07:08 -0400 Subject: [PATCH 02/53] fix: HIP build issues (#4028) * Fix HIP build issues * LvArray --------- Co-authored-by: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> --- .../fluid/multiFluid/PVTDriver.cpp | 14 +++++------ .../interfaces/hypre/HypreKernels.hpp | 25 ++++++++++++++++++- 2 files changed, 31 insertions(+), 8 deletions(-) diff --git a/src/coreComponents/constitutiveDrivers/fluid/multiFluid/PVTDriver.cpp b/src/coreComponents/constitutiveDrivers/fluid/multiFluid/PVTDriver.cpp index e5ece32c7c8..afb5934ec13 100644 --- a/src/coreComponents/constitutiveDrivers/fluid/multiFluid/PVTDriver.cpp +++ b/src/coreComponents/constitutiveDrivers/fluid/multiFluid/PVTDriver.cpp @@ -91,12 +91,12 @@ void PVTDriver::postInputInitialization() // Check that the functions exist FunctionManager & functionManager = FunctionManager::getInstance(); GEOS_ERROR_IF( !functionManager.hasGroup< TableFunction >( m_pressureFunctionName ), - getWrapperDataContext( viewKeyStruct::pressureFunctionString() ) << - "Pressure function with name '" << m_pressureFunctionName << "' not found" ); + GEOS_FMT( "Pressure function with name '{}' not found", m_pressureFunctionName ), + getWrapperDataContext( viewKeyStruct::pressureFunctionString() ) ); GEOS_ERROR_IF( !functionManager.hasGroup< TableFunction >( m_temperatureFunctionName ), - getWrapperDataContext( viewKeyStruct::temperatureFunctionString() ) << - "Temperature function with name '" << m_temperatureFunctionName << "' not found" ); + GEOS_FMT( "Temperature function with name '{}' not found", m_temperatureFunctionName ), + getWrapperDataContext( viewKeyStruct::temperatureFunctionString() ) ); // get number of phases and components MultiFluidBase & baseFluid = getFluid(); @@ -105,9 +105,9 @@ void PVTDriver::postInputInitialization() m_numComponents = baseFluid.numFluidComponents(); GEOS_ERROR_IF( m_feed.size() != m_numComponents, - getWrapperDataContext( viewKeyStruct::feedString() ) << - "Feed must have the same number of components as the fluid. " - "Feed has " << m_feed.size() << " and fluid has " << m_numComponents ); + GEOS_FMT( "Feed must have the same number of components as the fluid. Feed has {} and fluid has {}", + m_feed.size(), m_numComponents ), + getWrapperDataContext( viewKeyStruct::feedString() ) ); string_array columnNames; getColumnNames( columnNames ); diff --git a/src/coreComponents/linearAlgebra/interfaces/hypre/HypreKernels.hpp b/src/coreComponents/linearAlgebra/interfaces/hypre/HypreKernels.hpp index 846fc66084a..58f93dc02f5 100644 --- a/src/coreComponents/linearAlgebra/interfaces/hypre/HypreKernels.hpp +++ b/src/coreComponents/linearAlgebra/interfaces/hypre/HypreKernels.hpp @@ -36,6 +36,29 @@ namespace hypre /// @cond DO_NOT_DOCUMENT +namespace internal +{ + +struct ZeroRowSumMessage +{ + long long row; +}; + +inline std::ostream & operator<<( std::ostream & os, ZeroRowSumMessage const & msg ) +{ + return os << "Zero row sum in row " << msg.row; +} + +GEOS_HOST_DEVICE inline ZeroRowSumMessage zeroRowSumMessage( globalIndex const row ) +{ +#if defined(__CUDA_ARCH__) || defined(__HIP_DEVICE_COMPILE__) + printf( "***** Zero row sum in row %lld\n", static_cast< long long >( row ) ); +#endif + return { static_cast< long long >( row ) }; +} + +} // namespace internal + template< bool CONST > struct CSRData { @@ -103,7 +126,7 @@ void rescaleMatrixRows( hypre_ParCSRMatrix * const mat, } } - GEOS_ASSERT_MSG( !isZero( scale ), GEOS_FMT( "Zero row sum in row {}", rowIndices[i] ) ); + GEOS_ASSERT_MSG( !isZero( scale ), internal::zeroRowSumMessage( rowIndices[i] ) ); scale = 1.0 / scale; for( HYPRE_Int k = diag.rowptr[localRow]; k < diag.rowptr[localRow + 1]; ++k ) { From 3a821027ddcd6b8d634bae8b0c3f807f6ef3bb7b Mon Sep 17 00:00:00 2001 From: Randolph Settgast Date: Sun, 19 Apr 2026 15:28:08 -0700 Subject: [PATCH 03/53] remove semantic_pull_request check (#4031) --- .github/workflows/ci_tests.yml | 26 -------------------------- 1 file changed, 26 deletions(-) diff --git a/.github/workflows/ci_tests.yml b/.github/workflows/ci_tests.yml index 56ee878668e..a1de2583cb0 100644 --- a/.github/workflows/ci_tests.yml +++ b/.github/workflows/ci_tests.yml @@ -16,36 +16,10 @@ concurrency: # Please define `build.args.GEOS_TPL_TAG` in `.devcontainer/devcontainer.json` jobs: - # Checks if PR title follows conventional semantics - semantic_pull_request: - permissions: - pull-requests: write # for amannn/action-semantic-pull-request to analyze PRs and - statuses: write # for amannn/action-semantic-pull-request to mark status of analyzed PR - contents: read - runs-on: ubuntu-latest - - steps: - - name: Check if the PR name has conventional semantics - if: github.event_name == 'pull_request' - uses: amannn/action-semantic-pull-request@v5.5.3 - id: lint_pr_title - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - with: - wip: true - # Configure that a scope doesn't need to be provided. - requireScope: false - - - name: Skip the check on develop branch - if: github.ref_name == 'develop' - run: | - echo "This in't a Pull-Request, skipping" - # Jobs will be cancelled if PR is a draft. # PR status must be "Open" to run CI. is_not_draft_pull_request: # if: ${{ always() }} - needs: [semantic_pull_request] # Everywhere in this workflow, we use the most recent ubuntu distribution available in Github Actions # to ensure maximum support of google cloud's sdk. runs-on: ubuntu-22.04 From b6a2b7c9aabe790fbfe6e4aaf394eba53ab7701d Mon Sep 17 00:00:00 2001 From: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> Date: Tue, 21 Apr 2026 18:22:03 -0500 Subject: [PATCH 04/53] Fix inverse capillary pressure (#4027) --- .../InverseCapillaryPressure.hpp | 6 +++- .../testInverseCapillaryPressure.cpp | 28 +++++++++---------- 2 files changed, 19 insertions(+), 15 deletions(-) diff --git a/src/coreComponents/constitutive/capillaryPressure/InverseCapillaryPressure.hpp b/src/coreComponents/constitutive/capillaryPressure/InverseCapillaryPressure.hpp index e1b91433042..c38f2a9858f 100644 --- a/src/coreComponents/constitutive/capillaryPressure/InverseCapillaryPressure.hpp +++ b/src/coreComponents/constitutive/capillaryPressure/InverseCapillaryPressure.hpp @@ -290,7 +290,11 @@ class InverseCapillaryPressureUpdate real64 stepSize = 1.0; if( epsilon < LvArray::math::abs( dS )) { - real64 const phaseStepSize = LvArray::math::max((minSaturation[phase0] - saturation[phase0])/dS, (maxSaturation[phase0] - saturation[phase0])/dS ); + real64 phaseStepSize = LvArray::math::max((minSaturation[phase0] - saturation[phase0])/dS, (maxSaturation[phase0] - saturation[phase0])/dS ); + if( phaseStepSize < 1.0 ) + { + phaseStepSize *= (1.0 - STEP_TOLERANCE); + } stepSize = LvArray::math::min( stepSize, phaseStepSize ); } diff --git a/src/coreComponents/constitutive/unitTests/testInverseCapillaryPressure.cpp b/src/coreComponents/constitutive/unitTests/testInverseCapillaryPressure.cpp index f4a71a4b33e..391708394d6 100644 --- a/src/coreComponents/constitutive/unitTests/testInverseCapillaryPressure.cpp +++ b/src/coreComponents/constitutive/unitTests/testInverseCapillaryPressure.cpp @@ -249,24 +249,24 @@ INSTANTIATE_TEST_SUITE_P( {{ 0.00e+00, 2.07e+05, -0.00e+00}, { 0.79807692, 0.20192308, 0.00000000}, 1.00e+00}, {{ 0.00e+00, 2.07e+05, -1.00e+03}, { 0.78292541, 0.20192308, 0.01515152}, 1.00e+00}, {{ 0.00e+00, 2.07e+05, -1.00e+05}, { 0.23307692, 0.20192308, 0.56500000}, 1.00e+00}, - {{ 0.00e+00, 2.07e+05, -2.37e+05}, { 0.00000000, 0.20000000, 0.80000000}, 1.00e+00}, + {{ 0.00e+00, 2.07e+05, -2.37e+05}, { 0.00000000, 0.20076923, 0.79923077}, 1.00e+00}, {{ 0.00e+00, 2.07e+05, -3.00e+05}, { 0.00000000, 0.20000000, 0.80000000}, 1.00e+00}, {{ 0.00e+00, 1.72e+05, 5.00e+04}, { 0.72058824, 0.27941176, 0.00000000}, 1.00e+00}, {{ 0.00e+00, 1.72e+05, -0.00e+00}, { 0.72058824, 0.27941176, 0.00000000}, 1.00e+00}, {{ 0.00e+00, 1.72e+05, -1.00e+03}, { 0.70543672, 0.27941176, 0.01515152}, 1.00e+00}, {{ 0.00e+00, 1.72e+05, -1.00e+05}, { 0.15558824, 0.27941176, 0.56500000}, 1.00e+00}, - {{ 0.00e+00, 1.72e+05, -2.37e+05}, { 0.00000000, 0.20000000, 0.80000000}, 1.00e+00}, + {{ 0.00e+00, 1.72e+05, -2.37e+05}, { 0.00000000, 0.22769231, 0.77230769}, 1.00e+00}, {{ 0.00e+00, 1.72e+05, -3.00e+05}, { 0.00000000, 0.20000000, 0.80000000}, 1.00e+00}, {{ 0.00e+00, 1.04e+05, 5.00e+04}, { 0.00000000, 1.00000000, 0.00000000}, 1.00e+00}, {{ 0.00e+00, 1.04e+05, -0.00e+00}, { 0.00000000, 1.00000000, 0.00000000}, 1.00e+00}, {{ 0.00e+00, 1.04e+05, -1.00e+03}, { 0.08484848, 0.90000000, 0.01515152}, 1.00e+00}, {{ 0.00e+00, 1.04e+05, -1.00e+05}, { 0.00000000, 0.51025641, 0.48974359}, 1.00e+00}, - {{ 0.00e+00, 1.04e+05, -3.00e+05}, { 0.00000000, 0.20000000, 0.80000000}, 1.00e+00}, + {{ 0.00e+00, 1.04e+05, -3.00e+05}, { 0.00000000, 0.23153846, 0.76846154}, 1.00e+00}, {{ 0.00e+00, 8.60e+04, 5.00e+04}, { 0.00000000, 1.00000000, 0.00000000}, 1.00e+00}, {{ 0.00e+00, 8.60e+04, -0.00e+00}, { 0.00000000, 1.00000000, 0.00000000}, 1.00e+00}, {{ 0.00e+00, 8.60e+04, -1.00e+03}, { 0.08484848, 0.90000000, 0.01515152}, 1.00e+00}, {{ 0.00e+00, 8.60e+04, -1.00e+05}, { 0.00000000, 0.55771605, 0.44228395}, 1.00e+00}, - {{ 0.00e+00, 8.60e+04, -3.00e+05}, { 0.00000000, 0.20000000, 0.80000000}, 1.00e+00}, + {{ 0.00e+00, 8.60e+04, -3.00e+05}, { 0.00000000, 0.24538462, 0.75461538}, 1.00e+00}, {{ 0.00e+00, -1.20e+05, 5.00e+04}, { 0.00000000, 1.00000000, 0.00000000}, 1.00e+00}, {{ 0.00e+00, -1.20e+05, -0.00e+00}, { 0.00000000, 1.00000000, 0.00000000}, 1.00e+00}, {{ 0.00e+00, -1.20e+05, -1.00e+03}, { 0.08484848, 0.90000000, 0.01515152}, 1.00e+00}, @@ -374,21 +374,21 @@ INSTANTIATE_TEST_SUITE_P( {{-8.47e+00, 0.00e+00, 1.08e+03}, { 0.15047219, 0.64763992, 0.20188790}, 3.14e+01}, {{-8.47e+01, 0.00e+00, 1.08e+03}, { 0.60939575, 0.18871635, 0.20188790}, 3.14e+01}, {{-1.61e+02, 0.00e+00, 1.08e+03}, { 0.78495752, 0.01315458, 0.20188790}, 3.14e+01}, - {{-1.69e+02, 0.00e+00, 1.08e+03}, { 0.80000000, 0.00000000, 0.20000000}, 3.14e+01}, + {{-1.69e+02, 0.00e+00, 1.08e+03}, { 0.79831597, 0.00000000, 0.20168403}, 3.14e+01}, {{-1.86e+02, 0.00e+00, 1.08e+03}, { 0.80000000, 0.00000000, 0.20000000}, 3.14e+01}, {{ 8.47e+00, 0.00e+00, 1.06e+03}, { 0.00000000, 0.79073966, 0.20926034}, 3.14e+01}, {{-0.00e+00, 0.00e+00, 1.06e+03}, { 0.00000000, 0.79073966, 0.20926034}, 3.14e+01}, {{-8.47e+00, 0.00e+00, 1.06e+03}, { 0.15047219, 0.64026747, 0.20926034}, 3.14e+01}, {{-8.47e+01, 0.00e+00, 1.06e+03}, { 0.60939575, 0.18134391, 0.20926034}, 3.14e+01}, {{-1.61e+02, 0.00e+00, 1.06e+03}, { 0.78495752, 0.00578214, 0.20926034}, 3.14e+01}, - {{-1.69e+02, 0.00e+00, 1.06e+03}, { 0.80000000, 0.00000000, 0.20000000}, 3.14e+01}, - {{-1.86e+02, 0.00e+00, 1.06e+03}, { 0.80000000, 0.00000000, 0.20000000}, 3.14e+01}, + {{-1.69e+02, 0.00e+00, 1.06e+03}, { 0.79220027, 0.00000000, 0.20779973}, 3.14e+01}, + {{-1.86e+02, 0.00e+00, 1.06e+03}, { 0.79739861, 0.00000000, 0.20260139}, 3.14e+01}, {{ 8.47e+00, 0.00e+00, 8.14e+02}, { 0.00000000, 0.66262690, 0.33737310}, 3.14e+01}, {{-0.00e+00, 0.00e+00, 8.14e+02}, { 0.00000000, 0.66262690, 0.33737310}, 3.14e+01}, {{-8.47e+00, 0.00e+00, 8.14e+02}, { 0.15047219, 0.51215471, 0.33737310}, 3.14e+01}, {{-8.47e+01, 0.00e+00, 8.14e+02}, { 0.60939575, 0.05323115, 0.33737310}, 3.14e+01}, - {{-1.61e+02, 0.00e+00, 8.14e+02}, { 0.80000000, 0.00000000, 0.20000000}, 3.14e+01}, - {{-1.86e+02, 0.00e+00, 8.14e+02}, { 0.80000000, 0.00000000, 0.20000000}, 3.14e+01}, + {{-1.61e+02, 0.00e+00, 8.14e+02}, { 0.69772877, 0.00000000, 0.30227123}, 3.14e+01}, + {{-1.86e+02, 0.00e+00, 8.14e+02}, { 0.70947676, 0.00000000, 0.29052324}, 3.14e+01}, {{ 8.47e+00, 0.00e+00, 5.70e+02}, { 0.00000000, 0.20649138, 0.79350862}, 3.14e+01}, {{-0.00e+00, 0.00e+00, 5.70e+02}, { 0.00000000, 0.20649138, 0.79350862}, 3.14e+01}, {{-8.47e+00, 0.00e+00, 5.70e+02}, { 0.15047219, 0.05601920, 0.79350862}, 3.14e+01}, @@ -429,14 +429,14 @@ INSTANTIATE_TEST_SUITE_P( {{-5.88e+02, 0.00e+00, 7.35e+04}, { 0.15034233, 0.63947471, 0.21018296}, 6.50e-03}, {{-5.88e+03, 0.00e+00, 7.35e+04}, { 0.60910358, 0.18071346, 0.21018296}, 6.50e-03}, {{-1.12e+04, 0.00e+00, 7.35e+04}, { 0.78521299, 0.00460405, 0.21018296}, 6.50e-03}, - {{-1.18e+04, 0.00e+00, 7.35e+04}, { 0.80000000, 0.00000000, 0.20000000}, 6.50e-03}, - {{-1.30e+04, 0.00e+00, 7.35e+04}, { 0.80000000, 0.00000000, 0.20000000}, 6.50e-03}, + {{-1.18e+04, 0.00e+00, 7.35e+04}, { 0.79167193, 0.00000000, 0.20832807}, 6.50e-03}, + {{-1.30e+04, 0.00e+00, 7.35e+04}, { 0.79695138, 0.00000000, 0.20304862}, 6.50e-03}, {{ 5.88e+02, 0.00e+00, 5.66e+04}, { 0.00000000, 0.66290222, 0.33709778}, 6.50e-03}, {{-0.00e+00, 0.00e+00, 5.66e+04}, { 0.00000000, 0.66290222, 0.33709778}, 6.50e-03}, {{-5.88e+02, 0.00e+00, 5.66e+04}, { 0.15034233, 0.51255988, 0.33709778}, 6.50e-03}, {{-5.88e+03, 0.00e+00, 5.66e+04}, { 0.60910358, 0.05379863, 0.33709778}, 6.50e-03}, - {{-1.18e+04, 0.00e+00, 5.66e+04}, { 0.80000000, 0.00000000, 0.20000000}, 6.50e-03}, - {{-1.30e+04, 0.00e+00, 5.66e+04}, { 0.80000000, 0.00000000, 0.20000000}, 6.50e-03}, + {{-1.18e+04, 0.00e+00, 5.66e+04}, { 0.70240462, 0.00000000, 0.29759538}, 6.50e-03}, + {{-1.30e+04, 0.00e+00, 5.66e+04}, { 0.71009357, 0.00000000, 0.28990643}, 6.50e-03}, {{ 5.88e+02, 0.00e+00, 3.96e+04}, { 0.00000000, 0.20531037, 0.79468963}, 6.50e-03}, {{-0.00e+00, 0.00e+00, 3.96e+04}, { 0.00000000, 0.20531037, 0.79468963}, 6.50e-03}, {{-5.88e+02, 0.00e+00, 3.96e+04}, { 0.15034233, 0.05496804, 0.79468963}, 6.50e-03}, @@ -477,7 +477,7 @@ INSTANTIATE_TEST_SUITE_P( {{-4.75e+01, 0.00e+00, 5.93e+03}, { 0.15055948, 0.63953651, 0.20990400}, 1.00e+00}, {{-4.75e+02, 0.00e+00, 5.93e+03}, { 0.60959217, 0.18050382, 0.20990400}, 1.00e+00}, {{-9.02e+02, 0.00e+00, 5.93e+03}, { 0.78490156, 0.00519444, 0.20990400}, 1.00e+00}, - {{-9.49e+02, 0.00e+00, 5.93e+03}, { 0.80000000, 0.00000000, 0.20000000}, 1.00e+00}, + {{-9.49e+02, 0.00e+00, 5.93e+03}, { 0.79177529, 0.00000000, 0.20822471}, 1.00e+00}, {{ 4.75e+01, 0.00e+00, 4.56e+03}, { 0.00000000, 0.66244072, 0.33755928}, 1.00e+00}, {{-0.00e+00, 0.00e+00, 4.56e+03}, { 0.00000000, 0.66244072, 0.33755928}, 1.00e+00}, {{-4.75e+01, 0.00e+00, 4.56e+03}, { 0.15055948, 0.51188124, 0.33755928}, 1.00e+00}, From 0139435c8222a007d988585c040979e9c399ad2b Mon Sep 17 00:00:00 2001 From: Randolph Settgast Date: Tue, 21 Apr 2026 22:57:23 -0700 Subject: [PATCH 05/53] allow for forks in different orgs to have different CI specifications (#4032) ci: decouple build pipeline from GCP and add per-org/provider config The reusable workflow and its container script were coupled to Google Cloud (hardcoded GCP auth step, GCS bucket input, GCP-shaped sccache credentials). Forks running on different storage backends or self-hosted runners had to fork the workflow files. This change moves the per-org and per-provider details into checked-in JSON consumed by a new resolver job, leaving the workflows declarative. - Add `.github/ci/orgs/.json` and `.github/ci/providers/.json` as the single source of truth for storage provider, sccache profile, artifact bucket path, public URL base, runner labels, and per-runner CA bundle paths. Schema is documented and required-field-only (no defaults) in `.github/ci/README.md`. Ships configs for EarthFlowAI (Cloudflare R2) and GEOS-DEV (GCS). - Add a `resolve_ci_provider` job in `ci_tests.yml` that loads and validates the org+provider JSON and exposes outputs to the matrix jobs. Per-row build options stay in `matrix:`; runtime resolution lives in the resolver. - Replace the GCP-only `auth` step in `build_and_test.yml` with a provider-agnostic step that resolves sccache config (TOML, env vars, files, or a named profile from `SCCACHE_PROFILES_JSON`) and artifact upload commands from inherited secrets. Drop `GCP_BUCKET`; add `STORAGE_PROVIDER`, `SCCACHE_PROFILE`, `ARTIFACT_UPLOAD_*`, and `ARTIFACT_PUBLIC_URL_*` inputs. - Support self-hosted runners with private trust stores via `DOCKER_CA_BUNDLE_HOST_PATH`, mounted into the container as `/certs/ca-bundle.crt`. - Generalize the in-container script: drop the GCP-coupled `--sccache-credentials` flag in favor of `--use-sccache` plus a relative `--sccache-config` path. Add phase timing instrumentation (per-phase start/duration markers and an end-of-run summary). Remove a stray `printenv` that was leaking secrets into job logs. - Fix label re-checking on private repos: restore live REST API fetch in `does_pr_have_necessary_labels` (the frozen `github.event.pull_request` payload misses labels added after the first trigger), and add the `Authorization: Bearer ${GITHUB_TOKEN}` header so private repos and fork PRs don't get an empty response. Switch the draft-PR check to read `github.event.pull_request.draft` directly instead of the REST API round-trip. --- .github/ci/README.md | 101 ++++ .github/ci/orgs/EarthFlowAI.json | 15 + .github/ci/orgs/GEOS-DEV.json | 15 + .github/ci/providers/cloudflare.json | 5 + .github/ci/providers/gcp.json | 5 + .github/workflows/build_and_test.yml | 555 ++++++++++++++++++++-- .github/workflows/ci_tests.yml | 282 ++++++++--- scripts/ci_build_and_test_in_container.sh | 207 ++++++-- 8 files changed, 1034 insertions(+), 151 deletions(-) create mode 100644 .github/ci/README.md create mode 100644 .github/ci/orgs/EarthFlowAI.json create mode 100644 .github/ci/orgs/GEOS-DEV.json create mode 100644 .github/ci/providers/cloudflare.json create mode 100644 .github/ci/providers/gcp.json diff --git a/.github/ci/README.md b/.github/ci/README.md new file mode 100644 index 00000000000..2662cf5d3ce --- /dev/null +++ b/.github/ci/README.md @@ -0,0 +1,101 @@ +This directory contains runtime CI configuration consumed by `.github/workflows/ci_tests.yml`. + +Two checked-in files drive behavior for each CI run: + +1. `.github/ci/orgs/.json` — per-organization choices (which provider, which runners, etc.). +2. `.github/ci/providers/.json` — the shell commands and URI scheme for that + provider. Reused by any org that selects this provider. + +Every field in both files is required. There are no defaults: the full behavior of a CI run is +always visible by reading these two JSON files and nothing else. + +## Org files (`.github/ci/orgs/.json`) + +`` matches `github.repository_owner`. The resolver also checks the lowercase form of the +owner name. Each file contains the config entry for that org directly; there is no top-level +wrapper keyed by the org name. + +Required fields (all of them, always): + +- `storage_provider` + Name of a file under `.github/ci/providers/`. Must match `^[A-Za-z0-9_-]+$`. Selects the upload + CLI and URI scheme. + +- `sccache_profile` + Name of the sccache profile to pull from the inherited `SCCACHE_PROFILES_JSON` secret. Does not + need to match `storage_provider`, though it typically does. + +- `integrated_tests_artifact_bucket_path` + Path under the bucket where integrated-test artifacts are uploaded. For providers whose URI + scheme is `:///`, the first path segment is the bucket name. + +- `artifact_public_url_base` + Public URL root for uploaded artifacts. The consumer builds each final URL as + `${artifact_public_url_base}/${integrated_tests_artifact_bucket_path}/${filename}`, so the base + must already include any bucket/host prefix required for a valid public URL. For GCS this is + typically `https://storage.googleapis.com`. For Cloudflare R2 public dev URLs it is the + `https://pub-.r2.dev` domain for the bucket. + +- `artifact_public_url_bucket_scoped` + Boolean. Set `true` when `artifact_public_url_base` is rooted *inside* a specific bucket and + cannot traverse up to the account root (e.g. Cloudflare R2 public dev URLs of the form + `https://pub-.r2.dev`, which always resolve to one bucket). With the flag set, the + consumer strips the first path segment (the bucket name) from + `integrated_tests_artifact_bucket_path` before appending it to the base, so a base of + `https://pub-.r2.dev` and a path of `geosx/integratedTests` yields + `https://pub-.r2.dev/integratedTests/...` rather than doubling the bucket. Set `false` + for providers whose public root sits above the bucket (GCS, custom domains mapped to the + account, etc.). + +- `runner_ca_bundle_host_paths` + Map keyed by runner label, not by workflow role. Each value is a host-side certificate bundle + path to bind into the container as `/certs/ca-bundle.crt`. + Example: `{"streak2": "/etc/pki/tls/certs/ca-bundle.crt"}`. + The resolver first looks for an exact runner-label match. If none is found, it falls back to + the prefix before the first `-`, so a runner label like `streak2-32core` will reuse the + `streak2` entry. Use `{}` for runners that do not need an LLNL-style outbound cert bundle. + +- `runners` + Map from runner role to runner label. Required roles: + - `default` + - `cpu_heavy` + - `integrated_tests` + - `code_coverage` + - `cuda` + + Each value is a single runner label string, e.g. `"ubuntu-22.04"` or `"streak2"`. + +## Provider files (`.github/ci/providers/.json`) + +Required fields (all of them, always): + +- `artifact_upload_command` + Shell command that uploads a single file. `$UPLOAD_SRC` and `$UPLOAD_DST` are exported by the + consumer before execution. The string is passed to `eval` — see the Security section below. + +- `artifact_upload_pre_command` + Shell command that runs once per job before the first upload, typically to authenticate the + CLI and validate credentials. `$ARTIFACT_UPLOAD_CREDENTIALS_FILE` is exported by the consumer. + The string is passed to `eval`. + +- `artifact_upload_uri_root` + URI scheme prefix the upload CLI expects, e.g. `"gs://"` or `"s3://"`. The consumer composes + `${artifact_upload_uri_root}${integrated_tests_artifact_bucket_path}/${filename}` as + `$UPLOAD_DST`. + +## Security + +The `artifact_upload_command` and `artifact_upload_pre_command` strings in every provider file +are passed to `eval` on the runner at upload time. They are executable shell, not inert +configuration. A change to those strings is a change to code that runs with the job's +environment — including credentials files, sccache tokens, and on self-hosted runners, the +runner host itself. + +Review edits to `.github/ci/providers/*.json` with the same scrutiny you would apply to a +workflow YAML change. Never populate these strings from PR- or user-controllable sources. + +## Secrets + +Secret payloads (artifact upload credentials, sccache config) are supplied through GitHub +repo/org secrets and consumed in the reusable workflow. They are not part of the JSON files +described here. diff --git a/.github/ci/orgs/EarthFlowAI.json b/.github/ci/orgs/EarthFlowAI.json new file mode 100644 index 00000000000..36a01decd7f --- /dev/null +++ b/.github/ci/orgs/EarthFlowAI.json @@ -0,0 +1,15 @@ +{ + "storage_provider": "cloudflare", + "sccache_profile": "cloudflare", + "integrated_tests_artifact_bucket_path": "geosx/integratedTests", + "artifact_public_url_base": "https://pub-17b272fb651e459ca81dd0fd457099ed.r2.dev", + "artifact_public_url_bucket_scoped": true, + "runner_ca_bundle_host_paths": {}, + "runners": { + "default": "ubuntu-22.04", + "cpu_heavy": "32core", + "integrated_tests": "32core", + "code_coverage": "32core", + "cuda": "thinkpad" + } +} diff --git a/.github/ci/orgs/GEOS-DEV.json b/.github/ci/orgs/GEOS-DEV.json new file mode 100644 index 00000000000..7700b33d6d6 --- /dev/null +++ b/.github/ci/orgs/GEOS-DEV.json @@ -0,0 +1,15 @@ +{ + "storage_provider": "gcp", + "sccache_profile": "gcp", + "integrated_tests_artifact_bucket_path": "geosx/integratedTests", + "artifact_public_url_base": "https://storage.googleapis.com", + "artifact_public_url_bucket_scoped": false, + "runner_ca_bundle_host_paths": { "streak2": "/etc/pki/tls/certs/ca-bundle.crt" }, + "runners": { + "default": "ubuntu-22.04", + "cpu_heavy": "streak2", + "integrated_tests": "streak2-32core", + "code_coverage": "streak2", + "cuda": "streak2" + } +} diff --git a/.github/ci/providers/cloudflare.json b/.github/ci/providers/cloudflare.json new file mode 100644 index 00000000000..8aa8f4ceb8f --- /dev/null +++ b/.github/ci/providers/cloudflare.json @@ -0,0 +1,5 @@ +{ + "artifact_upload_command": "aws s3 cp --only-show-errors \"$UPLOAD_SRC\" \"$UPLOAD_DST\" --endpoint-url \"$ARTIFACT_UPLOAD_ENDPOINT\"", + "artifact_upload_pre_command": "if [[ -z \"$ARTIFACT_UPLOAD_CREDENTIALS_FILE\" || ! -f \"$ARTIFACT_UPLOAD_CREDENTIALS_FILE\" ]]; then echo \"ARTIFACT_UPLOAD_CREDENTIALS_FILE is required when artifact upload is enabled.\" >&2; exit 1; fi; if ! command -v aws >/dev/null; then echo \"aws CLI is required for cloudflare artifact upload backend.\" >&2; exit 1; fi; if ! jq -e \"type == \\\"object\\\"\" \"$ARTIFACT_UPLOAD_CREDENTIALS_FILE\" >/dev/null 2>&1; then echo \"::error::Invalid JSON object in artifact upload credentials file.\" >&2; exit 1; fi; ACCESS_KEY_ID=\"$(jq -er \".access_key_id // empty\" \"$ARTIFACT_UPLOAD_CREDENTIALS_FILE\")\"; SECRET_ACCESS_KEY=\"$(jq -er \".secret_access_key // empty\" \"$ARTIFACT_UPLOAD_CREDENTIALS_FILE\")\"; ENDPOINT=\"$(jq -er \".endpoint // empty\" \"$ARTIFACT_UPLOAD_CREDENTIALS_FILE\")\"; if [[ -z \"$ACCESS_KEY_ID\" || -z \"$SECRET_ACCESS_KEY\" || -z \"$ENDPOINT\" ]]; then echo \"::error::Cloudflare artifact upload credentials must include access_key_id, secret_access_key, and endpoint.\" >&2; exit 1; fi; export AWS_ACCESS_KEY_ID=\"$ACCESS_KEY_ID\"; export AWS_SECRET_ACCESS_KEY=\"$SECRET_ACCESS_KEY\"; export AWS_DEFAULT_REGION=\"${AWS_DEFAULT_REGION:-auto}\"; export AWS_EC2_METADATA_DISABLED=true; export ARTIFACT_UPLOAD_ENDPOINT=\"$ENDPOINT\"", + "artifact_upload_uri_root": "s3://" +} diff --git a/.github/ci/providers/gcp.json b/.github/ci/providers/gcp.json new file mode 100644 index 00000000000..9a1b617db60 --- /dev/null +++ b/.github/ci/providers/gcp.json @@ -0,0 +1,5 @@ +{ + "artifact_upload_command": "CLOUDSDK_PYTHON=python3 gcloud storage cp --quiet -a publicRead \"$UPLOAD_SRC\" \"$UPLOAD_DST\"", + "artifact_upload_pre_command": "if [[ -z \"$ARTIFACT_UPLOAD_CREDENTIALS_FILE\" || ! -f \"$ARTIFACT_UPLOAD_CREDENTIALS_FILE\" ]]; then echo \"ARTIFACT_UPLOAD_CREDENTIALS_FILE is required when artifact upload is enabled.\" >&2; exit 1; fi; if ! jq -e . \"$ARTIFACT_UPLOAD_CREDENTIALS_FILE\" >/dev/null 2>&1; then echo \"::error::Invalid JSON in artifact upload credentials file.\" >&2; exit 1; fi; CLOUDSDK_PYTHON=python3 gcloud auth activate-service-account --key-file \"$ARTIFACT_UPLOAD_CREDENTIALS_FILE\"; CLOUDSDK_PYTHON=python3 gcloud config set storage/parallel_composite_upload_enabled True", + "artifact_upload_uri_root": "gs://" +} diff --git a/.github/workflows/build_and_test.yml b/.github/workflows/build_and_test.yml index 20d30da61f9..9242f4bbb2e 100644 --- a/.github/workflows/build_and_test.yml +++ b/.github/workflows/build_and_test.yml @@ -29,6 +29,10 @@ on: DOCKER_RUN_ARGS: required: false type: string + DOCKER_CA_BUNDLE_HOST_PATH: + required: false + type: string + default: '' ENABLE_HYPRE: required: false type: string @@ -38,9 +42,6 @@ on: ENABLE_TRILINOS: required: false type: string - GCP_BUCKET: - required: false - type: string HOST_CONFIG: required: false type: string @@ -68,19 +69,104 @@ on: GEOS_ENABLE_BOUNDS_CHECK: required: false type: string + STORAGE_PROVIDER: + required: false + type: string + default: '' + SCCACHE_PROFILE: + required: false + type: string + default: '' + ARTIFACT_UPLOAD_BUCKET_PATH: + required: false + type: string + default: '' + ARTIFACT_UPLOAD_COMMAND: + required: false + type: string + default: '' + ARTIFACT_UPLOAD_PRE_COMMAND: + required: false + type: string + default: '' + ARTIFACT_UPLOAD_URI_ROOT: + required: false + type: string + default: '' + ARTIFACT_PUBLIC_URL_ROOT: + required: false + type: string + default: '' + ARTIFACT_PUBLIC_URL_BUCKET_SCOPED: + description: > + When "true", ARTIFACT_PUBLIC_URL_ROOT is treated as already rooted + inside the bucket (e.g. R2 public dev URLs of the form + https://pub-.r2.dev, which always resolve to one bucket). The + first path segment of ARTIFACT_UPLOAD_BUCKET_PATH (the bucket name) + is stripped before concatenation to avoid doubling up the bucket in + the final URL. Any value other than the literal string "true" is + treated as false. + required: false + type: string + default: '' + ARTIFACT_UPLOAD_URI_PREFIX: + required: false + type: string + default: '' + ARTIFACT_PUBLIC_URL_PREFIX: + required: false + type: string + default: '' secrets: - CODECOV_TOKEN: + SCCACHE_CONFIG_TOML: + required: false + SCCACHE_ENV_VARS_JSON: + required: false + SCCACHE_FILES_JSON: + required: false + SCCACHE_PROFILES_JSON: + required: false + ARTIFACT_UPLOAD_CREDENTIALS_JSON: + required: false + ARTIFACT_PROVIDER_CREDENTIALS_JSON: required: false GOOGLE_CLOUD_GCP: required: false + SCCACHE_BUCKET: + required: false + SCCACHE_ENDPOINT: + required: false + CLOUDFLARE_R2_ACCESS_KEY_ID: + required: false + CLOUDFLARE_R2_SECRET_ACCESS_KEY: + required: false + CODECOV_TOKEN: + required: false jobs: build_test_deploy: runs-on: ${{ inputs.RUNS_ON }} + defaults: + run: + shell: bash steps: - name: does_pr_have_necessary_labels if: ${{inputs.REQUIRED_LABEL && github.event_name == 'pull_request'}} + # Fetch labels live from the GitHub REST API rather than reading + # github.event.pull_request.labels. The event payload is a snapshot + # frozen at the time the workflow was first triggered, so labels + # added after that first run are invisible to re-runs. The curl + # call below always returns current state, which is required for + # CI re-runs to pick up newly added labels (e.g. "ci: run CUDA + # builds"). Do not replace with github.event.pull_request.labels. + # The Authorization header is required for private repos/forks; + # GITHUB_TOKEN is provided automatically to every workflow run. + env: + GITHUB_TOKEN: ${{ github.token }} run: | - pr_json=$(curl -H "Accept: application/vnd.github+json" https://api.github.com/repos/${{ github.repository }}/pulls/${{ github.event.number }}) + pr_json=$(curl --fail --silent --show-error \ + -H "Accept: application/vnd.github+json" \ + -H "Authorization: Bearer ${GITHUB_TOKEN}" \ + https://api.github.com/repos/${{ github.repository }}/pulls/${{ github.event.number }}) LABELS=$(echo ${pr_json} | jq -crM '[.labels[].name]') echo " the labels are ${LABELS}" echo " the required label is ${{inputs.REQUIRED_LABEL}}" @@ -104,40 +190,342 @@ jobs: lfs: ${{ inputs.BUILD_TYPE == 'integrated_tests' }} fetch-depth: 1 - - id: 'auth' - if: ${{ inputs.GCP_BUCKET || inputs.USE_SCCACHE }} - uses: 'google-github-actions/auth@v2.1.10' - with: - credentials_json: '${{ secrets.GOOGLE_CLOUD_GCP }}' - create_credentials_file: true + - id: sccache_config + name: Resolve sccache configuration + env: + INPUT_USE_SCCACHE: ${{ inputs.USE_SCCACHE }} + INPUT_SCCACHE_PROFILE: ${{ inputs.SCCACHE_PROFILE }} + INPUT_STORAGE_PROVIDER: ${{ inputs.STORAGE_PROVIDER }} + DIRECT_SCCACHE_CONFIG_TOML: ${{ secrets.SCCACHE_CONFIG_TOML }} + DIRECT_SCCACHE_ENV_VARS_JSON: ${{ secrets.SCCACHE_ENV_VARS_JSON }} + DIRECT_SCCACHE_FILES_JSON: ${{ secrets.SCCACHE_FILES_JSON }} + SCCACHE_PROFILES_JSON: ${{ secrets.SCCACHE_PROFILES_JSON }} + LEGACY_SCCACHE_BUCKET: ${{ secrets.SCCACHE_BUCKET }} + LEGACY_SCCACHE_ENDPOINT: ${{ secrets.SCCACHE_ENDPOINT }} + LEGACY_CLOUDFLARE_R2_ACCESS_KEY_ID: ${{ secrets.CLOUDFLARE_R2_ACCESS_KEY_ID }} + LEGACY_CLOUDFLARE_R2_SECRET_ACCESS_KEY: ${{ secrets.CLOUDFLARE_R2_SECRET_ACCESS_KEY }} + run: | + set -euo pipefail + + validate_optional_json_object() { + local name="$1" + local json="${2:-}" + if [[ -z "${json}" ]]; then + printf '{}' + return 0 + fi + if ! jq -e 'type == "object"' <<< "${json}" >/dev/null 2>&1; then + echo "::error::Invalid JSON object in ${name}." >&2 + exit 1 + fi + printf '%s' "${json}" + } + + use_sccache=false + sccache_config_file= + sccache_env_file= + sccache_runtime_dir= + selected_sccache_config_toml= + selected_sccache_env_vars_json= + selected_sccache_files_json= + direct_sccache_env_vars_json= + direct_sccache_files_json= + + if [[ "${INPUT_USE_SCCACHE}" == "true" ]]; then + # Generic payload contract: + # - SCCACHE_CONFIG_TOML: literal TOML contents for ~/.config/sccache/config + # - SCCACHE_ENV_VARS_JSON: JSON object of {"ENV_VAR":"value"} + # - SCCACHE_FILES_JSON: JSON object of {"relative/path":"file-content"} + sccache_profile="${INPUT_SCCACHE_PROFILE:-${INPUT_STORAGE_PROVIDER}}" + + if [[ -n "${DIRECT_SCCACHE_ENV_VARS_JSON:-}" ]]; then + direct_sccache_env_vars_json="$(validate_optional_json_object "SCCACHE_ENV_VARS_JSON" "${DIRECT_SCCACHE_ENV_VARS_JSON}")" + fi - - name: Prepare Codecov verification key - if: inputs.CODE_COVERAGE + if [[ -n "${DIRECT_SCCACHE_FILES_JSON:-}" ]]; then + direct_sccache_files_json="$(validate_optional_json_object "SCCACHE_FILES_JSON" "${DIRECT_SCCACHE_FILES_JSON}")" + fi + + if [[ -n "${DIRECT_SCCACHE_CONFIG_TOML:-}" || -n "${direct_sccache_env_vars_json}" || -n "${direct_sccache_files_json}" ]]; then + selected_sccache_config_toml="${DIRECT_SCCACHE_CONFIG_TOML:-}" + selected_sccache_env_vars_json="${direct_sccache_env_vars_json}" + selected_sccache_files_json="${direct_sccache_files_json}" + elif [[ -n "${SCCACHE_PROFILES_JSON:-}" && -n "${sccache_profile}" ]]; then + sccache_profiles_json="$(validate_optional_json_object "SCCACHE_PROFILES_JSON" "${SCCACHE_PROFILES_JSON}")" + + selected_profile_json="$(jq -c --arg profile "${sccache_profile}" '.[$profile] // empty' <<< "${sccache_profiles_json}")" + if [[ -n "${selected_profile_json}" ]]; then + selected_profile_json="$(validate_optional_json_object "SCCACHE_PROFILES_JSON[${sccache_profile}]" "${selected_profile_json}")" + selected_sccache_config_toml="$(jq -r '.config_toml // ""' <<< "${selected_profile_json}")" + selected_sccache_env_vars_json="$(jq -c '.env_vars // {}' <<< "${selected_profile_json}")" + selected_sccache_files_json="$(jq -c '.files // {}' <<< "${selected_profile_json}")" + fi + elif [[ "${sccache_profile}" == "cloudflare" ]]; then + if [[ -n "${LEGACY_SCCACHE_BUCKET:-}" && -n "${LEGACY_SCCACHE_ENDPOINT:-}" && -n "${LEGACY_CLOUDFLARE_R2_ACCESS_KEY_ID:-}" && -n "${LEGACY_CLOUDFLARE_R2_SECRET_ACCESS_KEY:-}" ]]; then + selected_sccache_env_vars_json="$(jq -cn \ + --arg bucket "${LEGACY_SCCACHE_BUCKET}" \ + --arg access_key_id "${LEGACY_CLOUDFLARE_R2_ACCESS_KEY_ID}" \ + --arg secret_access_key "${LEGACY_CLOUDFLARE_R2_SECRET_ACCESS_KEY}" \ + --arg endpoint "${LEGACY_SCCACHE_ENDPOINT}" \ + '{ + SCCACHE_BUCKET: $bucket, + AWS_ACCESS_KEY_ID: $access_key_id, + AWS_SECRET_ACCESS_KEY: $secret_access_key, + SCCACHE_ENDPOINT: $endpoint, + SCCACHE_S3_USE_SSL: "true", + SCCACHE_REGION: "auto" + }' + )" + fi + fi + + if [[ "${selected_sccache_env_vars_json:-}" == "{}" ]]; then + selected_sccache_env_vars_json= + fi + + if [[ "${selected_sccache_files_json:-}" == "{}" ]]; then + selected_sccache_files_json= + fi + + if [[ -z "${selected_sccache_config_toml:-}" && -z "${selected_sccache_env_vars_json:-}" && -z "${selected_sccache_files_json:-}" ]]; then + echo "::warning::USE_SCCACHE=true but no sccache payload was provided (direct SCCACHE_* secrets or a matching entry in SCCACHE_PROFILES_JSON). Disabling sccache for this run." + else + use_sccache=true + # Keep the runtime directory stable so profile JSON can refer to helper files + # using a fixed path inside the mounted repository. + sccache_runtime_dir=".sccache-runtime" + runtime_path="${GITHUB_WORKSPACE}/${sccache_runtime_dir}" + rm -rf "${runtime_path}" + mkdir -p "${runtime_path}" + + if [[ -n "${selected_sccache_config_toml:-}" ]]; then + sccache_config_file="${sccache_runtime_dir}/config.toml" + printf '%s' "${selected_sccache_config_toml}" > "${GITHUB_WORKSPACE}/${sccache_config_file}" + chmod 600 "${GITHUB_WORKSPACE}/${sccache_config_file}" + fi + + if [[ -n "${selected_sccache_env_vars_json:-}" ]]; then + selected_sccache_env_vars_json="$(validate_optional_json_object "selected sccache env vars" "${selected_sccache_env_vars_json}")" + + sccache_env_file="${sccache_runtime_dir}/env.list" + : > "${GITHUB_WORKSPACE}/${sccache_env_file}" + + while IFS=$'\t' read -r key value_b64; do + if [[ ! "${key}" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]]; then + echo "Invalid env var name in SCCACHE_ENV_VARS_JSON: ${key}" >&2 + exit 1 + fi + + value="$(printf '%s' "${value_b64}" | base64 --decode)" + if [[ "${value}" == *$'\n'* ]]; then + echo "Multiline env values are not supported in SCCACHE_ENV_VARS_JSON for key ${key}." >&2 + exit 1 + fi + + printf '%s=%s\n' "${key}" "${value}" >> "${GITHUB_WORKSPACE}/${sccache_env_file}" + done < <(jq -r 'to_entries[]? | [.key, (.value | tostring | @base64)] | @tsv' <<< "${selected_sccache_env_vars_json}") + + chmod 600 "${GITHUB_WORKSPACE}/${sccache_env_file}" + fi + + if [[ -n "${selected_sccache_files_json:-}" ]]; then + selected_sccache_files_json="$(validate_optional_json_object "selected sccache files" "${selected_sccache_files_json}")" + + while IFS=$'\t' read -r rel_path content_b64; do + if [[ ! "${rel_path}" =~ ^[A-Za-z0-9._/-]+$ ]] || [[ "${rel_path}" == /* ]] || [[ "${rel_path}" == *".."* ]]; then + echo "Invalid file path in SCCACHE_FILES_JSON: ${rel_path}" >&2 + exit 1 + fi + + file_path="${runtime_path}/${rel_path}" + mkdir -p "$(dirname "${file_path}")" + printf '%s' "${content_b64}" | base64 --decode > "${file_path}" + chmod 600 "${file_path}" + done < <(jq -r 'to_entries[]? | [.key, (.value | tostring | @base64)] | @tsv' <<< "${selected_sccache_files_json}") + fi + fi + fi + + { + echo "use_sccache=${use_sccache}" + echo "sccache_config_file=${sccache_config_file}" + echo "sccache_env_file=${sccache_env_file}" + echo "sccache_runtime_dir=${sccache_runtime_dir}" + } >> "$GITHUB_OUTPUT" + + - id: artifact_upload_credentials + name: Resolve artifact upload credentials + env: + INPUT_STORAGE_PROVIDER: ${{ inputs.STORAGE_PROVIDER }} + INPUT_ARTIFACT_UPLOAD_BUCKET_PATH: ${{ inputs.ARTIFACT_UPLOAD_BUCKET_PATH }} + DIRECT_ARTIFACT_UPLOAD_CREDENTIALS_JSON: ${{ secrets.ARTIFACT_UPLOAD_CREDENTIALS_JSON }} + ARTIFACT_PROVIDER_CREDENTIALS_JSON: ${{ secrets.ARTIFACT_PROVIDER_CREDENTIALS_JSON }} + LEGACY_GOOGLE_CLOUD_GCP: ${{ secrets.GOOGLE_CLOUD_GCP }} run: | - set -euxo pipefail - GNUPGHOME="${RUNNER_TEMP}/codecov-gnupg" - export GNUPGHOME - mkdir -p "${GNUPGHOME}" - chmod 700 "${GNUPGHOME}" - gpg --batch --import "${GITHUB_WORKSPACE}/.github/codecov/verification.gpg.asc" || true - gpg --batch --list-keys 806BB28AED779869 >/dev/null - echo "GNUPGHOME=${GNUPGHOME}" >> "${GITHUB_ENV}" - - - name: 'Set up Cloud SDK' - if: inputs.GCP_BUCKET - uses: 'google-github-actions/setup-gcloud@v2.1.4' - with: - version: '>= 363.0.0' + set -euo pipefail + + validate_optional_json() { + local name="$1" + local json="${2:-}" + if [[ -z "${json}" ]]; then + return 0 + fi + if ! jq -e . <<< "${json}" >/dev/null 2>&1; then + echo "::error::Invalid JSON in ${name}." >&2 + exit 1 + fi + } + + validate_optional_json_object() { + local name="$1" + local json="${2:-}" + if [[ -z "${json}" ]]; then + printf '{}' + return 0 + fi + if ! jq -e 'type == "object"' <<< "${json}" >/dev/null 2>&1; then + echo "::error::Invalid JSON object in ${name}." >&2 + exit 1 + fi + printf '%s' "${json}" + } + + credentials_file= + credentials_payload= + storage_provider="${INPUT_STORAGE_PROVIDER}" + provider_credentials_json= + + if [[ -n "${DIRECT_ARTIFACT_UPLOAD_CREDENTIALS_JSON:-}" ]]; then + validate_optional_json "ARTIFACT_UPLOAD_CREDENTIALS_JSON" "${DIRECT_ARTIFACT_UPLOAD_CREDENTIALS_JSON}" + credentials_payload="${DIRECT_ARTIFACT_UPLOAD_CREDENTIALS_JSON}" + fi + + if [[ -n "${INPUT_ARTIFACT_UPLOAD_BUCKET_PATH}" && -z "${credentials_payload}" && -n "${ARTIFACT_PROVIDER_CREDENTIALS_JSON:-}" && -n "${storage_provider}" ]]; then + provider_credentials_json="$(validate_optional_json_object "ARTIFACT_PROVIDER_CREDENTIALS_JSON" "${ARTIFACT_PROVIDER_CREDENTIALS_JSON}")" + + entry_type="$(jq -r --arg provider "${storage_provider}" '(.[$provider] // null) | type' <<< "${provider_credentials_json}")" + case "${entry_type}" in + string) + credentials_payload="$(jq -r --arg provider "${storage_provider}" '.[$provider]' <<< "${provider_credentials_json}")" + ;; + object|array) + credentials_payload="$(jq -c --arg provider "${storage_provider}" '.[$provider]' <<< "${provider_credentials_json}")" + ;; + null) + ;; + *) + echo "::error::Unsupported credential payload type '${entry_type}' for storage provider '${storage_provider}'." + exit 1 + ;; + esac + fi + + # Legacy GCP fallback: the repo historically provided a single + # GOOGLE_CLOUD_GCP service-account JSON secret. It is kept so existing + # orgs do not have to migrate immediately. No equivalent Cloudflare + # fallback exists: new Cloudflare setups must provide credentials via + # ARTIFACT_PROVIDER_CREDENTIALS_JSON (or ARTIFACT_UPLOAD_CREDENTIALS_JSON + # for one-off overrides). Reusing SCCACHE_ENDPOINT as the R2 artifact + # endpoint is incorrect whenever cache and artifact buckets diverge. + if [[ -n "${INPUT_ARTIFACT_UPLOAD_BUCKET_PATH}" && -z "${credentials_payload}" ]]; then + case "${storage_provider}" in + gcp) + credentials_payload="${LEGACY_GOOGLE_CLOUD_GCP:-}" + ;; + esac + fi + + if [[ -n "${INPUT_ARTIFACT_UPLOAD_BUCKET_PATH}" && -z "${credentials_payload}" ]]; then + echo "::error::No artifact upload credentials resolved for storage provider '${storage_provider}'. Set ARTIFACT_PROVIDER_CREDENTIALS_JSON (keyed by provider) or ARTIFACT_UPLOAD_CREDENTIALS_JSON for a one-off override." + exit 1 + fi + + if [[ -n "${credentials_payload}" ]]; then + validate_optional_json "resolved artifact upload credentials" "${credentials_payload}" + credentials_dir="${RUNNER_TEMP}/artifact-upload-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}" + mkdir -p "${credentials_dir}" + credentials_file="${credentials_dir}/${storage_provider:-artifact}.json" + printf '%s' "${credentials_payload}" > "${credentials_file}" + chmod 600 "${credentials_file}" + fi + + echo "credentials_file=${credentials_file}" >> "$GITHUB_OUTPUT" - name: Print environment run: printenv - name: Build, test, deploy. + env: + INPUT_DOCKER_CA_BUNDLE_HOST_PATH: ${{ inputs.DOCKER_CA_BUNDLE_HOST_PATH }} run: | # Those two bash arrays will be populated depending on the required options, # and expended as CLI arguments for the docker and scripts calls. docker_args=() script_args=() + HAS_DATA_EXCHANGE=false + HAS_UPLOAD_TARGET=false + DATA_BASENAME= + DATA_EXCHANGE_DIR= + STORAGE_PROVIDER="${{ inputs.STORAGE_PROVIDER }}" + ARTIFACT_UPLOAD_BUCKET_PATH="${{ inputs.ARTIFACT_UPLOAD_BUCKET_PATH }}" + ARTIFACT_UPLOAD_URI_ROOT="${{ inputs.ARTIFACT_UPLOAD_URI_ROOT }}" + ARTIFACT_PUBLIC_URL_ROOT="${{ inputs.ARTIFACT_PUBLIC_URL_ROOT }}" + ARTIFACT_PUBLIC_URL_BUCKET_SCOPED="${{ inputs.ARTIFACT_PUBLIC_URL_BUCKET_SCOPED }}" + ARTIFACT_UPLOAD_URI_PREFIX="${{ inputs.ARTIFACT_UPLOAD_URI_PREFIX }}" + ARTIFACT_PUBLIC_URL_PREFIX="${{ inputs.ARTIFACT_PUBLIC_URL_PREFIX }}" + ARTIFACT_UPLOAD_CREDENTIALS_FILE="${{ steps.artifact_upload_credentials.outputs.credentials_file }}" + ARTIFACT_UPLOAD_COMMAND="$(cat <<'__ARTIFACT_UPLOAD_COMMAND__' + ${{ inputs.ARTIFACT_UPLOAD_COMMAND }} + __ARTIFACT_UPLOAD_COMMAND__ + )" + ARTIFACT_UPLOAD_PRE_COMMAND="$(cat <<'__ARTIFACT_UPLOAD_PRE_COMMAND__' + ${{ inputs.ARTIFACT_UPLOAD_PRE_COMMAND }} + __ARTIFACT_UPLOAD_PRE_COMMAND__ + )" + + if [[ -z "${ARTIFACT_UPLOAD_URI_PREFIX}" && -n "${ARTIFACT_UPLOAD_BUCKET_PATH}" ]]; then + ARTIFACT_UPLOAD_URI_PREFIX="${ARTIFACT_UPLOAD_URI_ROOT%/}/${ARTIFACT_UPLOAD_BUCKET_PATH}" + fi + + # The org config's artifact_public_url_base (propagated as + # ARTIFACT_PUBLIC_URL_ROOT) must already be rooted wherever the bucket + # is publicly served from. We simply append the bucket path. + # + # Exception: when ARTIFACT_PUBLIC_URL_BUCKET_SCOPED=="true" the root is + # already rooted *inside* the bucket (e.g. R2 public dev URLs of the + # form https://pub-.r2.dev, which always resolve to one bucket). + # In that case the leading path segment of ARTIFACT_UPLOAD_BUCKET_PATH + # is the bucket name and must be stripped before concatenation, + # otherwise we would double up the bucket in the final URL. + if [[ -z "${ARTIFACT_PUBLIC_URL_PREFIX}" && -n "${ARTIFACT_PUBLIC_URL_ROOT}" ]]; then + if [[ -n "${ARTIFACT_UPLOAD_BUCKET_PATH}" ]]; then + PUBLIC_URL_BUCKET_PATH="${ARTIFACT_UPLOAD_BUCKET_PATH}" + if [[ "${ARTIFACT_PUBLIC_URL_BUCKET_SCOPED}" == "true" ]]; then + # Strip the first segment (the bucket name) and any leading slash. + PUBLIC_URL_BUCKET_PATH="${PUBLIC_URL_BUCKET_PATH#/}" + if [[ "${PUBLIC_URL_BUCKET_PATH}" == */* ]]; then + PUBLIC_URL_BUCKET_PATH="${PUBLIC_URL_BUCKET_PATH#*/}" + else + PUBLIC_URL_BUCKET_PATH='' + fi + fi + if [[ -n "${PUBLIC_URL_BUCKET_PATH}" ]]; then + ARTIFACT_PUBLIC_URL_PREFIX="${ARTIFACT_PUBLIC_URL_ROOT%/}/${PUBLIC_URL_BUCKET_PATH}" + else + ARTIFACT_PUBLIC_URL_PREFIX="${ARTIFACT_PUBLIC_URL_ROOT%/}" + fi + else + ARTIFACT_PUBLIC_URL_PREFIX="${ARTIFACT_PUBLIC_URL_ROOT%/}" + fi + fi + + if [[ -n "${ARTIFACT_UPLOAD_BUCKET_PATH}" || -n "${ARTIFACT_UPLOAD_URI_PREFIX}" || -n "${ARTIFACT_PUBLIC_URL_PREFIX}" ]]; then + if [[ -z "${ARTIFACT_UPLOAD_COMMAND}" || -z "${ARTIFACT_UPLOAD_URI_PREFIX}" ]]; then + echo "::error::ARTIFACT_UPLOAD_COMMAND and ARTIFACT_UPLOAD_URI_PREFIX must both be set when enabling artifact upload." + exit 1 + fi + HAS_UPLOAD_TARGET=true + fi if [[ -n "${{ inputs.NPROC }}" ]]; then NPROC=${{ inputs.NPROC }} @@ -150,17 +538,29 @@ jobs: docker_args+=(${{ inputs.DOCKER_RUN_ARGS }}) + if [[ -n "${INPUT_DOCKER_CA_BUNDLE_HOST_PATH}" ]]; then + if [[ ! -f "${INPUT_DOCKER_CA_BUNDLE_HOST_PATH}" ]]; then + echo "::error::Configured DOCKER_CA_BUNDLE_HOST_PATH does not exist: ${INPUT_DOCKER_CA_BUNDLE_HOST_PATH}" + exit 1 + fi + docker_args+=("--volume=${INPUT_DOCKER_CA_BUNDLE_HOST_PATH}:/certs/ca-bundle.crt:ro") + docker_args+=(-e SSL_CERT_FILE=/certs/ca-bundle.crt) + docker_args+=(-e REQUESTS_CA_BUNDLE=/certs/ca-bundle.crt) + docker_args+=(-e CURL_CA_BUNDLE=/certs/ca-bundle.crt) + fi + COMMIT=${{ github.event.pull_request.head.sha }} SHORT_COMMIT=${COMMIT:0:7} script_args+=(--install-dir-basename GEOS-${SHORT_COMMIT}) - # All the data exchanged with the docker container is eventually meant to be sent to the cloud. - if [[ ! -z "${{ inputs.GCP_BUCKET }}" ]]; then - if [ "${{ inputs.BUILD_TYPE }}" = "build" ]; then - DATA_BASENAME=GEOS-and-TPL-${SHORT_COMMIT}.tar.gz - elif [ "${{ inputs.BUILD_TYPE }}" = "integrated_tests" ]; then + if [[ "${{ inputs.BUILD_TYPE }}" == "integrated_tests" || "${HAS_UPLOAD_TARGET}" == "true" ]]; then + HAS_DATA_EXCHANGE=true + + if [[ "${{ inputs.BUILD_TYPE }}" == "integrated_tests" ]]; then DATA_BASENAME=integratedTests-pr${{ github.event.number }}-${{ github.run_number }}-${SHORT_COMMIT}.tar.gz script_args+=(--run-integrated-tests) + else + DATA_BASENAME=GEOS-and-TPL-${SHORT_COMMIT}.tar.gz fi script_args+=(--data-basename ${DATA_BASENAME}) @@ -177,8 +577,22 @@ jobs: HOST_CONFIG=${{ inputs.HOST_CONFIG }} script_args+=(${HOST_CONFIG:+"--host-config ${HOST_CONFIG}"}) - if ${{ inputs.USE_SCCACHE }} == 'true'; then - script_args+=(--sccache-credentials $(basename ${GOOGLE_GHA_CREDS_PATH})) + if [[ "${{ steps.sccache_config.outputs.use_sccache }}" == "true" ]]; then + script_args+=(--use-sccache) + + sccache_config_file="${{ steps.sccache_config.outputs.sccache_config_file }}" + if [[ -n "${sccache_config_file}" ]]; then + script_args+=(--sccache-config "${sccache_config_file}") + fi + + sccache_env_file="${{ steps.sccache_config.outputs.sccache_env_file }}" + if [[ -n "${sccache_env_file}" && -f "${GITHUB_WORKSPACE}/${sccache_env_file}" ]]; then + while IFS='=' read -r key value || [[ -n "${key}" ]]; do + [[ -z "${key}" ]] && continue + export "${key}=${value}" + docker_args+=(-e "${key}") + done < "${GITHUB_WORKSPACE}/${sccache_env_file}" + fi fi # We need to know where the code folder is mounted inside the container so we can run the script at the proper location! @@ -286,8 +700,6 @@ jobs: ${GITHUB_WORKSPACE_MOUNT_POINT}/scripts/ci_build_and_test_in_container.sh \ ${script_args[@]}" - # In case of integrated tests run, we still want to send the results to the cloud for inspection. - # While for standard build (if even possible), pushing a failed build would be pointless. # GHA set `-e` to bash scripts by default to fail asap, # but for this precise call, we want to deal with it more precisely set +e @@ -301,24 +713,55 @@ jobs: echo "Received exit status ${EXIT_STATUS} from the build process." set -e - # Send to the bucket and print the download link when it makes sense. - if [[ ! -z "${{ inputs.GCP_BUCKET }}" ]]; then - if [[ "${{ inputs.BUILD_TYPE }}" = "integrated_tests" || ${EXIT_STATUS} -eq 0 ]]; then - # disable warning about parallel composite upload - CLOUDSDK_PYTHON=python3 gcloud config set storage/parallel_composite_upload_enabled True + artifact_upload_prepared=false + function upload_artifact () { + local source_file="$1" + local output_message="$2" + + if [[ "${HAS_UPLOAD_TARGET}" != "true" ]]; then + return 0 + fi + if [[ ! -f "${source_file}" ]]; then + return 0 + fi - if [ -f ${DATA_EXCHANGE_DIR}/${DATA_BASENAME} ]; then - CLOUDSDK_PYTHON=python3 gcloud storage cp --quiet -a publicRead ${DATA_EXCHANGE_DIR}/${DATA_BASENAME} gs://${{ inputs.GCP_BUCKET }}/ - echo "Download the bundle at https://storage.googleapis.com/${{ inputs.GCP_BUCKET }}/${DATA_BASENAME}" + if [[ "${artifact_upload_prepared}" != "true" ]]; then + if [[ -n "${ARTIFACT_UPLOAD_PRE_COMMAND}" ]]; then + eval "${ARTIFACT_UPLOAD_PRE_COMMAND}" + fi + artifact_upload_prepared=true + fi + + artifact_name="$(basename "${source_file}")" + artifact_destination="${ARTIFACT_UPLOAD_URI_PREFIX%/}/${artifact_name}" + ( + set -euo pipefail + export UPLOAD_SRC="${source_file}" + export UPLOAD_DST="${artifact_destination}" + export ARTIFACT_UPLOAD_CREDENTIALS_FILE="${ARTIFACT_UPLOAD_CREDENTIALS_FILE}" + eval "${ARTIFACT_UPLOAD_COMMAND}" + ) + + if [[ -n "${ARTIFACT_PUBLIC_URL_PREFIX}" ]]; then + echo "${output_message} ${ARTIFACT_PUBLIC_URL_PREFIX%/}/${artifact_name}" + else + echo "${output_message} ${artifact_destination}" + fi + } + + if [[ "${HAS_DATA_EXCHANGE}" == "true" ]]; then + if [[ "${{ inputs.BUILD_TYPE }}" = "integrated_tests" || ${EXIT_STATUS} -eq 0 ]]; then + if [[ -f ${DATA_EXCHANGE_DIR}/${DATA_BASENAME} ]]; then + echo "Generated artifact at ${DATA_EXCHANGE_DIR}/${DATA_BASENAME}" + upload_artifact "${DATA_EXCHANGE_DIR}/${DATA_BASENAME}" "Download the bundle at" fi if [ -f ${DATA_EXCHANGE_DIR}/test_logs_${DATA_BASENAME} ]; then - CLOUDSDK_PYTHON=python3 gcloud storage cp --quiet -a publicRead ${DATA_EXCHANGE_DIR}/test_logs_${DATA_BASENAME} gs://${{ inputs.GCP_BUCKET }}/ - echo "Download integrated test logs here: https://storage.googleapis.com/${{ inputs.GCP_BUCKET }}/test_logs_${DATA_BASENAME}" + echo "Generated integrated test logs at ${DATA_EXCHANGE_DIR}/test_logs_${DATA_BASENAME}" + upload_artifact "${DATA_EXCHANGE_DIR}/test_logs_${DATA_BASENAME}" "Download integrated test logs here:" fi if [ -f ${DATA_EXCHANGE_DIR}/baseline_${DATA_BASENAME} ];then - if [[ -n "${{ inputs.LOCAL_BASELINE_DIR }}" ]]; then # 1. We copy the baselines to a local directory to store them @@ -335,9 +778,8 @@ jobs: cp "${SOURCE_FILE}" "${TARGET_DIR}" fi - # 2. We push the baselines to the cloud - CLOUDSDK_PYTHON=python3 gcloud storage cp --quiet -a publicRead ${DATA_EXCHANGE_DIR}/baseline_${DATA_BASENAME} gs://${{ inputs.GCP_BUCKET }}/ - echo "Download test baselines here: https://storage.googleapis.com/${{ inputs.GCP_BUCKET }}/baseline_${DATA_BASENAME}" + # 2. We push the baselines to cloud storage if an upload backend is configured. + upload_artifact "${DATA_EXCHANGE_DIR}/baseline_${DATA_BASENAME}" "Download test baselines here:" echo "New baseline ID: baseline_${DATA_BASENAME::-7}" else echo "Baselines ${DATA_EXCHANGE_DIR}/baseline_${DATA_BASENAME} were not uploaded. Likeyly because no rebaseline was necessary." @@ -384,3 +826,16 @@ jobs: -v "${GITHUB_WORKSPACE}:/tmp/geos" \ alpine:3.20 \ sh -lc 'rm -rf /tmp/geos/* /tmp/geos/.[!.]* /tmp/geos/..?* || true' + + - name: Show sccache stats + if: ${{ always() && steps.sccache_config.outputs.use_sccache == 'true' }} + run: | + sccache_env_file="${{ steps.sccache_config.outputs.sccache_env_file }}" + if [[ -n "${sccache_env_file}" && -f "${GITHUB_WORKSPACE}/${sccache_env_file}" ]]; then + while IFS='=' read -r key value || [[ -n "${key}" ]]; do + [[ -z "${key}" ]] && continue + export "${key}=${value}" + done < "${GITHUB_WORKSPACE}/${sccache_env_file}" + fi + + command -v sccache >/dev/null && sccache --show-stats || true diff --git a/.github/workflows/ci_tests.yml b/.github/workflows/ci_tests.yml index a1de2583cb0..921643de9d5 100644 --- a/.github/workflows/ci_tests.yml +++ b/.github/workflows/ci_tests.yml @@ -20,21 +20,18 @@ jobs: # PR status must be "Open" to run CI. is_not_draft_pull_request: # if: ${{ always() }} - # Everywhere in this workflow, we use the most recent ubuntu distribution available in Github Actions - # to ensure maximum support of google cloud's sdk. + # Everywhere in this workflow, we use the most recent ubuntu distribution available in Github Actions. runs-on: ubuntu-22.04 outputs: DOCKER_IMAGE_TAG: ${{ steps.extract_docker_image_tag.outputs.DOCKER_IMAGE_TAG }} steps: - name: Check that the PR is not a draft (cancel rest of jobs otherwise) id: extract_pr_info - env: - GITHUB_TOKEN: ${{ github.token }} run: | set -euo pipefail if [[ "${{ github.event_name }}" == "pull_request" ]]; then - draft_status=$( curl -fsSL -H "Accept: application/vnd.github+json" -H "Authorization: Bearer ${GITHUB_TOKEN}" "https://api.github.com/repos/${{ github.repository }}/pulls/${{ github.event.number }}" | jq -r '.draft') + draft_status="${{ github.event.pull_request.draft }}" echo "Draft status of PR is ${draft_status}." if [[ "${draft_status}" == "true" ]]; then @@ -42,7 +39,6 @@ jobs: fi fi - # The TPL tag is contained in the codespaces configuration to avoid duplications. - name: Checkout .devcontainer/devcontainer.json @@ -59,6 +55,181 @@ jobs: run: | echo "DOCKER_IMAGE_TAG=$(jq '.build.args.GEOS_TPL_TAG' -r .devcontainer/devcontainer.json)" >> "$GITHUB_OUTPUT" + # Resolve CI settings once and keep the build jobs declarative. + # + # Two checked-in files drive behavior: + # .github/ci/orgs/.json + # Per-org choices: storage provider name, sccache profile name, integrated-tests bucket + # path, public URL base and bucket-scoping, runner labels, and per-runner CA bundle paths. + # Every field is required; there are no defaults. See .github/ci/README.md for the schema. + # .github/ci/providers/.json + # Provider-level CLI details: the shell commands that upload artifacts and the URI scheme. + # Reused by any org that selects this provider. Every field is required. + # + # Provider payloads (credentials, sccache profiles) are supplied through inherited secrets: + # - SCCACHE_PROFILES_JSON + # - ARTIFACT_PROVIDER_CREDENTIALS_JSON + # Direct one-off overrides remain available in the reusable workflow via SCCACHE_* and + # ARTIFACT_UPLOAD_CREDENTIALS_JSON. + # + # SECURITY: the artifact_upload_command and artifact_upload_pre_command strings in each + # provider JSON file are passed to `eval` on the runner. A change to those strings is a + # change to executable shell, not a data-config tweak. Review edits to + # .github/ci/providers/*.json with the same scrutiny as workflow YAML. Do not populate + # those values from PR- or user-controllable sources. + resolve_ci_provider: + runs-on: ubuntu-22.04 + outputs: + STORAGE_PROVIDER: ${{ steps.resolve.outputs.STORAGE_PROVIDER }} + SCCACHE_PROFILE: ${{ steps.resolve.outputs.SCCACHE_PROFILE }} + INTEGRATED_TESTS_ARTIFACT_BUCKET_PATH: ${{ steps.resolve.outputs.INTEGRATED_TESTS_ARTIFACT_BUCKET_PATH }} + DOCKER_CA_BUNDLE_HOST_PATHS_JSON: ${{ steps.resolve.outputs.DOCKER_CA_BUNDLE_HOST_PATHS_JSON }} + RUNNER_LABELS_JSON: ${{ steps.resolve.outputs.RUNNER_LABELS_JSON }} + ARTIFACT_UPLOAD_COMMAND: ${{ steps.resolve.outputs.ARTIFACT_UPLOAD_COMMAND }} + ARTIFACT_UPLOAD_PRE_COMMAND: ${{ steps.resolve.outputs.ARTIFACT_UPLOAD_PRE_COMMAND }} + ARTIFACT_UPLOAD_URI_ROOT: ${{ steps.resolve.outputs.ARTIFACT_UPLOAD_URI_ROOT }} + ARTIFACT_PUBLIC_URL_ROOT: ${{ steps.resolve.outputs.ARTIFACT_PUBLIC_URL_ROOT }} + ARTIFACT_PUBLIC_URL_BUCKET_SCOPED: ${{ steps.resolve.outputs.ARTIFACT_PUBLIC_URL_BUCKET_SCOPED }} + env: + CI_REPOSITORY_OWNER: ${{ github.repository_owner }} + steps: + - name: Checkout CI config + uses: actions/checkout@v4.2.2 + with: + sparse-checkout: | + .github/ci/orgs + .github/ci/providers + sparse-checkout-cone-mode: false + submodules: false + lfs: false + fetch-depth: 1 + - id: resolve + run: | + set -euo pipefail + + # --- Locate the org config file. Owners are matched case-insensitively. --- + REPOSITORY_OWNER_LOWER="$(printf '%s' "${CI_REPOSITORY_OWNER}" | tr '[:upper:]' '[:lower:]')" + ORG_CONFIG_PATH='' + for candidate in \ + "${GITHUB_WORKSPACE}/.github/ci/orgs/${CI_REPOSITORY_OWNER}.json" \ + "${GITHUB_WORKSPACE}/.github/ci/orgs/${REPOSITORY_OWNER_LOWER}.json" + do + if [[ -f "${candidate}" ]]; then + ORG_CONFIG_PATH="${candidate}" + break + fi + done + + if [[ -z "${ORG_CONFIG_PATH}" ]]; then + echo "::error::No CI organization config was found for repository owner '${CI_REPOSITORY_OWNER}'. Expected .github/ci/orgs/${CI_REPOSITORY_OWNER}.json or .github/ci/orgs/${REPOSITORY_OWNER_LOWER}.json." + exit 1 + fi + + if ! jq -e 'type == "object"' "${ORG_CONFIG_PATH}" >/dev/null; then + echo "::error::Invalid JSON object in ${ORG_CONFIG_PATH}." + exit 1 + fi + + ORG_CONFIG_JSON="$(jq -c . "${ORG_CONFIG_PATH}")" + + # --- Validate the full org schema. Every field is required; there are no defaults. --- + if ! jq -e ' + (.storage_provider | type == "string" and length > 0) + and (.sccache_profile | type == "string" and length > 0) + and (.integrated_tests_artifact_bucket_path | type == "string" and length > 0) + and (.artifact_public_url_base | type == "string") + and (.artifact_public_url_bucket_scoped | type == "boolean") + and (.runner_ca_bundle_host_paths | type == "object") + and (.runner_ca_bundle_host_paths | all(.[]; type == "string")) + and (.runners | type == "object") + and (.runners.default | type == "string" and length > 0) + and (.runners.cpu_heavy | type == "string" and length > 0) + and (.runners.integrated_tests | type == "string" and length > 0) + and (.runners.code_coverage | type == "string" and length > 0) + and (.runners.cuda | type == "string" and length > 0) + ' <<< "${ORG_CONFIG_JSON}" >/dev/null; then + echo "::error::${ORG_CONFIG_PATH} must define every required field: storage_provider, sccache_profile, integrated_tests_artifact_bucket_path, artifact_public_url_base, artifact_public_url_bucket_scoped, runner_ca_bundle_host_paths, and runners.{default,cpu_heavy,integrated_tests,code_coverage,cuda}. See .github/ci/README.md for the full schema." + exit 1 + fi + + # --- Extract org values. --- + STORAGE_PROVIDER="$(jq -r '.storage_provider' <<< "${ORG_CONFIG_JSON}")" + SCCACHE_PROFILE="$(jq -r '.sccache_profile' <<< "${ORG_CONFIG_JSON}")" + INTEGRATED_TESTS_ARTIFACT_BUCKET_PATH="$(jq -r '.integrated_tests_artifact_bucket_path' <<< "${ORG_CONFIG_JSON}")" + ARTIFACT_PUBLIC_URL_ROOT="$(jq -r '.artifact_public_url_base' <<< "${ORG_CONFIG_JSON}")" + ARTIFACT_PUBLIC_URL_BUCKET_SCOPED="$(jq -r '.artifact_public_url_bucket_scoped' <<< "${ORG_CONFIG_JSON}")" + RUNNER_LABELS_JSON="$(jq -c '.runners' <<< "${ORG_CONFIG_JSON}")" + RUNNER_CA_BUNDLE_HOST_PATHS_JSON="$(jq -c '.runner_ca_bundle_host_paths' <<< "${ORG_CONFIG_JSON}")" + + # --- Resolve per-runner-role CA bundle paths. --- + # Each runner role picks up the bundle path for its label; if no exact match, + # fall back to the prefix before the first '-' (so "streak2-32core" reuses "streak2"). + DOCKER_CA_BUNDLE_HOST_PATHS_JSON="$(jq -cn \ + --argjson runners "${RUNNER_LABELS_JSON}" \ + --argjson cert_paths "${RUNNER_CA_BUNDLE_HOST_PATHS_JSON}" ' + def resolve_path($runner_label): + ($cert_paths[$runner_label] + // (($runner_label | split("-")[0]) as $runner_prefix | $cert_paths[$runner_prefix]) + // ""); + { + default: resolve_path($runners.default), + cpu_heavy: resolve_path($runners.cpu_heavy), + integrated_tests: resolve_path($runners.integrated_tests), + code_coverage: resolve_path($runners.code_coverage), + cuda: resolve_path($runners.cuda) + }' + )" + + # --- Load and validate the provider file. --- + # storage_provider names a file under .github/ci/providers/. + # Restrict the allowed characters so the provider name cannot escape the directory. + if ! [[ "${STORAGE_PROVIDER}" =~ ^[A-Za-z0-9_-]+$ ]]; then + echo "::error::storage_provider '${STORAGE_PROVIDER}' contains disallowed characters. Allowed: letters, digits, '_', '-'." + exit 1 + fi + PROVIDER_CONFIG_PATH="${GITHUB_WORKSPACE}/.github/ci/providers/${STORAGE_PROVIDER}.json" + if [[ ! -f "${PROVIDER_CONFIG_PATH}" ]]; then + echo "::error::No provider config file at ${PROVIDER_CONFIG_PATH} for storage_provider '${STORAGE_PROVIDER}' (selected in ${ORG_CONFIG_PATH})." + exit 1 + fi + + if ! jq -e 'type == "object"' "${PROVIDER_CONFIG_PATH}" >/dev/null; then + echo "::error::Invalid JSON object in ${PROVIDER_CONFIG_PATH}." + exit 1 + fi + + PROVIDER_CONFIG_JSON="$(jq -c . "${PROVIDER_CONFIG_PATH}")" + + if ! jq -e ' + (.artifact_upload_command | type == "string" and length > 0) + and (.artifact_upload_pre_command | type == "string" and length > 0) + and (.artifact_upload_uri_root | type == "string" and length > 0) + ' <<< "${PROVIDER_CONFIG_JSON}" >/dev/null; then + echo "::error::${PROVIDER_CONFIG_PATH} must define artifact_upload_command, artifact_upload_pre_command, and artifact_upload_uri_root as non-empty strings." + exit 1 + fi + + ARTIFACT_UPLOAD_COMMAND="$(jq -r '.artifact_upload_command' <<< "${PROVIDER_CONFIG_JSON}")" + ARTIFACT_UPLOAD_PRE_COMMAND="$(jq -r '.artifact_upload_pre_command' <<< "${PROVIDER_CONFIG_JSON}")" + ARTIFACT_UPLOAD_URI_ROOT="$(jq -r '.artifact_upload_uri_root' <<< "${PROVIDER_CONFIG_JSON}")" + + { + echo "STORAGE_PROVIDER=${STORAGE_PROVIDER}" + echo "SCCACHE_PROFILE=${SCCACHE_PROFILE}" + echo "INTEGRATED_TESTS_ARTIFACT_BUCKET_PATH=${INTEGRATED_TESTS_ARTIFACT_BUCKET_PATH}" + echo "DOCKER_CA_BUNDLE_HOST_PATHS_JSON=${DOCKER_CA_BUNDLE_HOST_PATHS_JSON}" + echo "RUNNER_LABELS_JSON=${RUNNER_LABELS_JSON}" + echo "ARTIFACT_UPLOAD_COMMAND<<__EOF__" + printf '%s\n' "${ARTIFACT_UPLOAD_COMMAND}" + echo "__EOF__" + echo "ARTIFACT_UPLOAD_PRE_COMMAND<<__EOF__" + printf '%s\n' "${ARTIFACT_UPLOAD_PRE_COMMAND}" + echo "__EOF__" + echo "ARTIFACT_UPLOAD_URI_ROOT=${ARTIFACT_UPLOAD_URI_ROOT}" + echo "ARTIFACT_PUBLIC_URL_ROOT=${ARTIFACT_PUBLIC_URL_ROOT}" + echo "ARTIFACT_PUBLIC_URL_BUCKET_SCOPED=${ARTIFACT_PUBLIC_URL_BUCKET_SCOPED}" + } >> "$GITHUB_OUTPUT" + # PR must be assigned to be merged. # This job will fail if this is not the case. if_not_unassigned_pull_request: @@ -66,12 +237,15 @@ jobs: runs-on: ubuntu-22.04 steps: - name: If this is a PR, Check that it is assigned + env: + PR_JSON: ${{ toJson(github.event.pull_request) }} run: | - if [[ ${{github.event_name}} != 'pull_request' ]]; then exit 0 ; fi - pr_json=$(curl -H "Accept: application/vnd.github+json" https://api.github.com/repos/${{ github.repository }}/pulls/${{ github.event.number }}) - NUM_ASSIGNEES=$(echo ${pr_json} | jq '.assignees | length') + set -euo pipefail + + if [[ "${{ github.event_name }}" != 'pull_request' ]]; then exit 0 ; fi + NUM_ASSIGNEES=$(jq -r '.assignees | length' <<< "${PR_JSON}") echo "There are ${NUM_ASSIGNEES} assignees on this PR." - if [[ $NUM_ASSIGNEES == 0 ]]; then exit 1 ; fi + if [[ "${NUM_ASSIGNEES}" == 0 ]]; then exit 1 ; fi # Validates that the PR is still pointing to the HEAD of the main branch of the submodules repositories. # (There are exceptions, read the script about those). @@ -118,7 +292,7 @@ jobs: # Those are quite fast and can efficiently benefit from the `sccache' tool to make them even faster. cpu_builds: name: ${{ matrix.name }} - needs: [is_not_draft_pull_request] + needs: [is_not_draft_pull_request, resolve_ci_provider] strategy: # In-progress jobs will not be cancelled if there is a failure fail-fast : false @@ -141,9 +315,10 @@ jobs: ENABLE_HYPRE: OFF ENABLE_TRILINOS: ON GEOS_ENABLE_BOUNDS_CHECK: ON - RUNS_ON: streak2 + # Resolved from .github/ci/orgs/.json. + RUNNER_KEY: cpu_heavy NPROC: 8 - DOCKER_RUN_ARGS: "--cpus=8 --memory=256g --runtime=nvidia -v /etc/pki/tls/certs/ca-bundle.crt:/etc/pki/tls/certs/ca-bundle.crt:ro -v /etc/pki/tls/certs/ca-bundle.crt:/certs/ca-bundle.crt:ro" + DOCKER_RUN_ARGS: "--cpus=8 --memory=256g" HOST_CONFIG: /spack-generated.cmake @@ -163,13 +338,11 @@ jobs: ENABLE_TRILINOS: OFF BUILD_SHARED_LIBS: ON GEOS_ENABLE_BOUNDS_CHECK: OFF - GCP_BUCKET: geosx/ubuntu22.04-gcc11 HOST_CONFIG: /spack-generated.cmake - name: Ubuntu (22.04, gcc 12.3.0, open-mpi 4.1.2) CMAKE_BUILD_TYPE: Release DOCKER_REPOSITORY: geosx/ubuntu22.04-gcc12 - GCP_BUCKET: geosx/ubuntu22.04-gcc12 ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF BUILD_SHARED_LIBS: ON @@ -179,7 +352,6 @@ jobs: - name: Ubuntu (22.04, gcc 12.3.0, open-mpi 4.1.2, +hypredrive) CMAKE_BUILD_TYPE: Release DOCKER_REPOSITORY: geosx/ubuntu22.04-gcc12-hypredrive - GCP_BUCKET: geosx/ubuntu22.04-gcc12-hypredrive ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF BUILD_SHARED_LIBS: ON @@ -189,32 +361,12 @@ jobs: - name: Ubuntu (22.04, gcc 12.3.0, open-mpi 4.1.2) - NO BOUNDS CHECK CMAKE_BUILD_TYPE: Release DOCKER_REPOSITORY: geosx/ubuntu22.04-gcc12 - GCP_BUCKET: geosx/ubuntu22.04-gcc12 ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF BUILD_SHARED_LIBS: ON GEOS_ENABLE_BOUNDS_CHECK: OFF HOST_CONFIG: /spack-generated.cmake - #- name: Ubuntu (22.04, clang 15.0.7, open-mpi 4.1.2) - # CMAKE_BUILD_TYPE: Release - # DOCKER_REPOSITORY: geosx/ubuntu22.04-clang15 - # ENABLE_HYPRE: ON - # ENABLE_TRILINOS: OFF - # GEOS_ENABLE_BOUNDS_CHECK: ON - # BUILD_SHARED_LIBS: ON - # HOST_CONFIG: /spack-generated.cmake - - #- name: Sherlock CPU (centos 7.9.2009, gcc 10.1.0, open-mpi 4.1.2, openblas 0.3.10) - # CMAKE_BUILD_TYPE: Release - # DOCKER_REPOSITORY: geosx/sherlock-gcc10.1.0-openmpi4.1.2-openblas0.3.10-zlib1.2.11 - # ENABLE_HYPRE: ON - # ENABLE_TRILINOS: OFF - # GEOS_ENABLE_BOUNDS_CHECK: OFF - # GCP_BUCKET: geosx/Sherlock-CPU - # HOST_CONFIG: /spack-generated.cmake -# # HOST_CONFIG: host-configs/Stanford/sherlock-gcc10.cmake - # BUILD_SHARED_LIBS: ON uses: ./.github/workflows/build_and_test.yml with: @@ -227,10 +379,12 @@ jobs: ENABLE_HYPRE: ${{ matrix.ENABLE_HYPRE }} ENABLE_TRILINOS: ${{ matrix.ENABLE_TRILINOS }} GEOS_ENABLE_BOUNDS_CHECK: ${{ matrix.GEOS_ENABLE_BOUNDS_CHECK }} - GCP_BUCKET: ${{ matrix.GCP_BUCKET }} + STORAGE_PROVIDER: ${{ needs.resolve_ci_provider.outputs.STORAGE_PROVIDER }} + SCCACHE_PROFILE: ${{ needs.resolve_ci_provider.outputs.SCCACHE_PROFILE }} HOST_CONFIG: ${{ matrix.HOST_CONFIG }} NPROC: ${{ matrix.NPROC || '' }} - RUNS_ON: ${{ matrix.RUNS_ON || 'ubuntu-22.04' }} + DOCKER_CA_BUNDLE_HOST_PATH: ${{ fromJSON(needs.resolve_ci_provider.outputs.DOCKER_CA_BUNDLE_HOST_PATHS_JSON || '{}')[matrix.RUNNER_KEY || 'default'] || '' }} + RUNS_ON: ${{ fromJSON(needs.resolve_ci_provider.outputs.RUNNER_LABELS_JSON)[matrix.RUNNER_KEY || 'default'] }} secrets: inherit # If the 'ci: run integrated tests' PR label is found, the integrated tests will be run immediately after the cpu jobs. @@ -238,6 +392,7 @@ jobs: run_integrated_tests: needs: - is_not_draft_pull_request + - resolve_ci_provider - cpu_builds uses: ./.github/workflows/build_and_test.yml secrets: inherit @@ -250,10 +405,18 @@ jobs: ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF GEOS_ENABLE_BOUNDS_CHECK: ON - GCP_BUCKET: geosx/integratedTests - RUNS_ON: streak2-32core + STORAGE_PROVIDER: ${{ needs.resolve_ci_provider.outputs.STORAGE_PROVIDER }} + SCCACHE_PROFILE: ${{ needs.resolve_ci_provider.outputs.SCCACHE_PROFILE }} + ARTIFACT_UPLOAD_BUCKET_PATH: ${{ needs.resolve_ci_provider.outputs.INTEGRATED_TESTS_ARTIFACT_BUCKET_PATH }} + ARTIFACT_UPLOAD_COMMAND: ${{ needs.resolve_ci_provider.outputs.ARTIFACT_UPLOAD_COMMAND }} + ARTIFACT_UPLOAD_PRE_COMMAND: ${{ needs.resolve_ci_provider.outputs.ARTIFACT_UPLOAD_PRE_COMMAND }} + ARTIFACT_UPLOAD_URI_ROOT: ${{ needs.resolve_ci_provider.outputs.ARTIFACT_UPLOAD_URI_ROOT }} + ARTIFACT_PUBLIC_URL_ROOT: ${{ needs.resolve_ci_provider.outputs.ARTIFACT_PUBLIC_URL_ROOT }} + ARTIFACT_PUBLIC_URL_BUCKET_SCOPED: ${{ needs.resolve_ci_provider.outputs.ARTIFACT_PUBLIC_URL_BUCKET_SCOPED }} + DOCKER_CA_BUNDLE_HOST_PATH: ${{ fromJSON(needs.resolve_ci_provider.outputs.DOCKER_CA_BUNDLE_HOST_PATHS_JSON || '{}').integrated_tests || '' }} + RUNS_ON: ${{ fromJSON(needs.resolve_ci_provider.outputs.RUNNER_LABELS_JSON).integrated_tests }} NPROC: 32 - DOCKER_RUN_ARGS: "--cpus=32 --memory=384g -v /etc/pki/tls/certs/ca-bundle.crt:/etc/pki/tls/certs/ca-bundle.crt:ro -v /etc/pki/tls/certs/ca-bundle.crt:/certs/ca-bundle.crt:ro" + DOCKER_RUN_ARGS: "--cpus=32 --memory=384g" REQUIRED_LABEL: "ci: run integrated tests" LOCAL_BASELINE_DIR: /data/GEOS/baselines HOST_CONFIG: /spack-generated.cmake @@ -276,10 +439,9 @@ jobs: code_coverage: needs: - is_not_draft_pull_request + - resolve_ci_provider uses: ./.github/workflows/build_and_test.yml - secrets: - CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} - GOOGLE_CLOUD_GCP: ${{ secrets.GOOGLE_CLOUD_GCP }} + secrets: inherit with: BUILD_AND_TEST_CLI_ARGS: "--no-run-unit-tests" CMAKE_BUILD_TYPE: Debug @@ -288,11 +450,13 @@ jobs: DOCKER_REPOSITORY: geosx/ubuntu22.04-gcc11 ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF - RUNS_ON: streak2 + SCCACHE_PROFILE: ${{ needs.resolve_ci_provider.outputs.SCCACHE_PROFILE }} + RUNS_ON: ${{ fromJSON(needs.resolve_ci_provider.outputs.RUNNER_LABELS_JSON).code_coverage }} + DOCKER_CA_BUNDLE_HOST_PATH: ${{ fromJSON(needs.resolve_ci_provider.outputs.DOCKER_CA_BUNDLE_HOST_PATHS_JSON || '{}').code_coverage || '' }} REQUIRED_LABEL: "ci: run code coverage" HOST_CONFIG: /spack-generated.cmake NPROC: 8 - DOCKER_RUN_ARGS: "--cpus=8 --memory=256g --runtime=nvidia -v /etc/pki/tls/certs/ca-bundle.crt:/etc/pki/tls/certs/ca-bundle.crt:ro -v /etc/pki/tls/certs/ca-bundle.crt:/certs/ca-bundle.crt:ro" + DOCKER_RUN_ARGS: "--cpus=8 --memory=256g" # mac_builds: @@ -311,6 +475,7 @@ jobs: name: ${{ matrix.name }} needs: - is_not_draft_pull_request + - resolve_ci_provider strategy: # In-progress jobs will not be cancelled if there is a failure fail-fast : false @@ -325,9 +490,10 @@ jobs: ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF GEOS_ENABLE_BOUNDS_CHECK: OFF - RUNS_ON: streak2 + # Resolved from .github/ci/orgs/.json. + RUNNER_KEY: cuda NPROC: 8 - DOCKER_RUN_ARGS: "--cpus=8 --memory=128g --runtime=nvidia -v /etc/pki/tls/certs/ca-bundle.crt:/etc/pki/tls/certs/ca-bundle.crt:ro -v /etc/pki/tls/certs/ca-bundle.crt:/certs/ca-bundle.crt:ro" + DOCKER_RUN_ARGS: "--cpus=8 --memory=128g --runtime=nvidia" HOST_CONFIG: /spack-generated.cmake - name: Ubuntu CUDA (20.04, clang 10.0.0 + gcc 9.4.0, open-mpi 4.0.3, cuda-11.8.89) @@ -339,9 +505,9 @@ jobs: ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF GEOS_ENABLE_BOUNDS_CHECK: OFF - RUNS_ON: streak2 + RUNNER_KEY: cuda NPROC: 8 - DOCKER_RUN_ARGS: "--cpus=8 --memory=256g --runtime=nvidia -v /etc/pki/tls/certs/ca-bundle.crt:/etc/pki/tls/certs/ca-bundle.crt:ro -v /etc/pki/tls/certs/ca-bundle.crt:/certs/ca-bundle.crt:ro" + DOCKER_RUN_ARGS: "--cpus=8 --memory=256g --runtime=nvidia" HOST_CONFIG: /spack-generated.cmake - name: Rockylinux CUDA (8, clang 17.0.6, cuda 12.9.1) @@ -353,9 +519,9 @@ jobs: ENABLE_TRILINOS: OFF GEOS_ENABLE_BOUNDS_CHECK: OFF DOCKER_REPOSITORY: geosx/rockylinux8-clang17-cuda12.9.1 - RUNS_ON: streak2 + RUNNER_KEY: cuda NPROC: 8 - DOCKER_RUN_ARGS: "--cpus=8 --memory=128g --runtime=nvidia -e NVIDIA_VISIBLE_DEVICES=all -v /etc/pki/tls/certs/ca-bundle.crt:/etc/pki/tls/certs/ca-bundle.crt:ro -v /etc/pki/tls/certs/ca-bundle.crt:/certs/ca-bundle.crt:ro" + DOCKER_RUN_ARGS: "--cpus=8 --memory=128g --runtime=nvidia -e NVIDIA_VISIBLE_DEVICES=all" HOST_CONFIG: /spack-generated.cmake - name: Rockylinux CUDA (8, gcc 13.3, cuda 12.9.1) @@ -367,9 +533,9 @@ jobs: ENABLE_TRILINOS: OFF GEOS_ENABLE_BOUNDS_CHECK: OFF DOCKER_REPOSITORY: geosx/rockylinux8-gcc13-cuda12.9.1 - RUNS_ON: streak2 + RUNNER_KEY: cuda NPROC: 8 - DOCKER_RUN_ARGS: "--cpus=8 --memory=128g --runtime=nvidia -v /etc/pki/tls/certs/ca-bundle.crt:/etc/pki/tls/certs/ca-bundle.crt:ro -v /etc/pki/tls/certs/ca-bundle.crt:/certs/ca-bundle.crt:ro" + DOCKER_RUN_ARGS: "--cpus=8 --memory=128g --runtime=nvidia" HOST_CONFIG: /spack-generated.cmake #- name: Sherlock GPU (centos 7.9.2009, gcc 10.1.0, open-mpi 4.1.2, openblas 0.3.10, cuda 12.4.0,) @@ -381,7 +547,6 @@ jobs: # ENABLE_HYPRE: ON # ENABLE_TRILINOS: OFF # GEOS_ENABLE_BOUNDS_CHECK: OFF - # GCP_BUCKET: geosx/Sherlock-GPU # RUNS_ON: streak2 # NPROC: 8 # DOCKER_RUN_ARGS: "--cpus=8 --memory=128g --runtime=nvidia -v /etc/pki/tls/certs/ca-bundle.crt:/etc/pki/tls/certs/ca-bundle.crt:ro -v /etc/pki/tls/certs/ca-bundle.crt:/certs/ca-bundle.crt:ro" @@ -389,8 +554,6 @@ jobs: # DOCKER_CERTS_UPDATE_COMMAND: "update-ca-trust" # HOST_CONFIG: /spack-generated.cmake - # Below this line, jobs that deploy to Google Cloud. - uses: ./.github/workflows/build_and_test.yml with: BUILD_AND_TEST_CLI_ARGS: ${{ matrix.BUILD_AND_TEST_CLI_ARGS }} @@ -403,10 +566,11 @@ jobs: ENABLE_HYPRE: ${{ matrix.ENABLE_HYPRE }} ENABLE_TRILINOS: ${{ matrix.ENABLE_TRILINOS }} GEOS_ENABLE_BOUNDS_CHECK: ${{ matrix.GEOS_ENABLE_BOUNDS_CHECK }} - GCP_BUCKET: ${{ matrix.GCP_BUCKET }} + SCCACHE_PROFILE: ${{ needs.resolve_ci_provider.outputs.SCCACHE_PROFILE }} HOST_CONFIG: ${{ matrix.HOST_CONFIG }} NPROC: ${{ matrix.NPROC }} - RUNS_ON: ${{ matrix.RUNS_ON }} + DOCKER_CA_BUNDLE_HOST_PATH: ${{ fromJSON(needs.resolve_ci_provider.outputs.DOCKER_CA_BUNDLE_HOST_PATHS_JSON || '{}')[matrix.RUNNER_KEY || 'default'] || '' }} + RUNS_ON: ${{ fromJSON(needs.resolve_ci_provider.outputs.RUNNER_LABELS_JSON)[matrix.RUNNER_KEY || 'default'] }} REQUIRED_LABEL: "ci: run CUDA builds" secrets: inherit diff --git a/scripts/ci_build_and_test_in_container.sh b/scripts/ci_build_and_test_in_container.sh index 4a45e8565e1..3fc3f7ced32 100755 --- a/scripts/ci_build_and_test_in_container.sh +++ b/scripts/ci_build_and_test_in_container.sh @@ -3,8 +3,6 @@ set -o pipefail export PYTHONDONTWRITEBYTECODE=1 -printenv - SCRIPT_NAME=$0 echo "Running CLI ${SCRIPT_NAME} $@" @@ -22,11 +20,85 @@ function or_die () { local status=$? if [[ $status != 0 ]] ; then + if [[ -n "${CURRENT_PHASE_LABEL:-}" ]]; then + phase_finish "${status}" + fi echo ERROR $status command: $@ exit $status fi } +PHASE_TIMINGS=() +CURRENT_PHASE_LABEL="" +CURRENT_PHASE_START="" +tempdir="" + +function now_epoch () { + date +%s +} + +function format_duration () { + local total_seconds=$1 + local hours=$(( total_seconds / 3600 )) + local minutes=$(( (total_seconds % 3600) / 60 )) + local seconds=$(( total_seconds % 60 )) + + if (( hours > 0 )); then + printf '%dh %02dm %02ds' "${hours}" "${minutes}" "${seconds}" + elif (( minutes > 0 )); then + printf '%dm %02ds' "${minutes}" "${seconds}" + else + printf '%ds' "${seconds}" + fi +} + +function phase_start () { + CURRENT_PHASE_LABEL="$1" + CURRENT_PHASE_START="$(now_epoch)" + echo ">>> ${CURRENT_PHASE_LABEL} started at $(date -u +"%Y-%m-%dT%H:%M:%SZ")" +} + +function phase_finish () { + local status="${1:-0}" + local label="${CURRENT_PHASE_LABEL:-}" + local start="${CURRENT_PHASE_START:-}" + + if [[ -z "${label}" || -z "${start}" ]]; then + return 0 + fi + + local duration=$(( $(now_epoch) - start )) + PHASE_TIMINGS+=("${label}|${duration}|${status}") + + if [[ "${status}" -eq 0 ]]; then + echo ">>> ${label} completed in $(format_duration "${duration}")" + else + echo ">>> ${label} failed after $(format_duration "${duration}") (exit ${status})" + fi + + CURRENT_PHASE_LABEL="" + CURRENT_PHASE_START="" +} + +function print_phase_summary () { + local entry label duration status status_text + + if [[ ${#PHASE_TIMINGS[@]} -eq 0 ]]; then + return 0 + fi + + echo "Phase timing summary:" + for entry in "${PHASE_TIMINGS[@]}"; do + IFS='|' read -r label duration status <<< "${entry}" + if [[ "${status}" -eq 0 ]]; then + status_text="ok" + else + status_text="exit ${status}" + fi + printf ' - %s: %s (%s)\n' "${label}" "$(format_duration "${duration}")" "${status_text}" + done +} + function usage () { >&2 cat << EOF Usage: $0 @@ -66,8 +138,10 @@ Usage: $0 Internal mountpoint where the geos repository will be available. --run-integrated-tests Run the integrated tests. Then bundle and send the results to the cloud. - --sccache-credentials credentials.json - Basename of the json credentials file to connect to the sccache cloud cache. + --use-sccache + Enable sccache as compiler launcher. + --sccache-config config.toml + Relative path to an sccache config file to use inside the container. --test-code-style --test-documentation -h | --help @@ -79,7 +153,7 @@ exit 1 # Then we'll move to the build dir. or_die cd $(dirname $0)/.. -args=$(or_die getopt -a -o h --long build-exe-only,cmake-build-type:,code-coverage,data-basename:,geos-enable-bounds-check:,enable-hypre:,enable-hypre-device:,enable-trilinos:,exchange-dir:,host-config:,install-dir-basename:,makefile,ninja,no-install-schema,no-run-unit-tests,nproc:,repository:,run-integrated-tests,sccache-credentials:,test-code-style,test-documentation,help -- "$@") +args=$(or_die getopt -a -o h --long build-exe-only,cmake-build-type:,code-coverage,data-basename:,geos-enable-bounds-check:,enable-hypre:,enable-hypre-device:,enable-trilinos:,exchange-dir:,host-config:,install-dir-basename:,makefile,ninja,no-install-schema,no-run-unit-tests,nproc:,repository:,run-integrated-tests,sccache-config:,test-code-style,test-documentation,use-sccache,help -- "$@") # Variables with default values BUILD_EXE_ONLY=false @@ -98,6 +172,8 @@ ENABLE_TRILINOS=OFF CODE_COVERAGE=false NPROC="$(nproc)" GEOS_ENABLE_BOUNDS_CHECK=ON +SCCACHE_BIN="" +USE_SCCACHE=false eval set -- ${args} while : @@ -136,7 +212,8 @@ do --run-integrated-tests) RUN_INTEGRATED_TESTS=true; shift;; --upload-test-baselines) UPLOAD_TEST_BASELINES=true; shift;; --code-coverage) CODE_COVERAGE=true; shift;; - --sccache-credentials) SCCACHE_CREDS=$2; shift 2;; + --sccache-config) SCCACHE_CONFIG_FILE=$2; shift 2;; + --use-sccache) USE_SCCACHE=true; shift;; --test-code-style) TEST_CODE_STYLE=true; shift;; --test-documentation) TEST_DOCUMENTATION=true; shift;; -h | --help) usage; shift;; @@ -154,7 +231,15 @@ fi cleanup() { + if [[ -n "${CURRENT_PHASE_LABEL:-}" ]]; then + phase_finish 1 + fi + + print_phase_summary echo "Container cleanup..." + if [[ -n "${tempdir:-}" ]]; then + rm -rf "${tempdir}" || true + fi rm -rf "${GEOS_SRC_DIR}/src/docs/sphinx/datastructure" || true if [[ -n "${HOST_UID:-}" && -n "${HOST_GID:-}" ]]; then @@ -176,33 +261,35 @@ else GEOS_LA_INTERFACE=Trilinos fi -if [[ ! -z "${SCCACHE_CREDS}" ]]; then - # The credential json file is available at the root of the geos repository. - # We hereafter create the config file that points to it. - # We use this file since it's managed by the 'google-github-actions/auth' actions. - or_die mkdir -p ${HOME}/.config/sccache - or_die cat <> ${HOME}/.config/sccache/config -[cache.gcs] -rw_mode = "READ_WRITE" -cred_path = "${GEOS_SRC_DIR}/${SCCACHE_CREDS}" -bucket = "geos-dev" -key_prefix = "sccache" -EOT - - # To use `sccache`, it's enough to tell `cmake` to launch the compilation using `sccache`. - # The path to the `sccache` executable is available through the SCCACHE environment variable. - SCCACHE_CMAKE_ARGS="-DCMAKE_CXX_COMPILER_LAUNCHER=${SCCACHE} -DCMAKE_CUDA_COMPILER_LAUNCHER=${SCCACHE}" - - case "$(hostname -f 2>/dev/null || hostname)" in - *.llnl.gov|streak2*|streak*) - export SSL_CERT_FILE=/certs/ca-bundle.crt - export CURL_CA_BUNDLE=/certs/ca-bundle.crt - export REQUESTS_CA_BUNDLE=/certs/ca-bundle.crt - ;; - esac +if [[ "${USE_SCCACHE}" == true ]]; then + SCCACHE_BIN=${SCCACHE:-$(command -v sccache || true)} + + if [[ -z "${SCCACHE_BIN}" ]]; then + echo "sccache was requested, but no sccache binary is available in the container." + exit 1 + fi + + if [[ -n "${SCCACHE_CONFIG_FILE:-}" ]]; then + if [[ ! -f "${GEOS_SRC_DIR}/${SCCACHE_CONFIG_FILE}" ]]; then + echo "Unable to find requested sccache config file at ${GEOS_SRC_DIR}/${SCCACHE_CONFIG_FILE}." + exit 1 + fi + + or_die mkdir -p ${HOME}/.config/sccache + or_die cp "${GEOS_SRC_DIR}/${SCCACHE_CONFIG_FILE}" "${HOME}/.config/sccache/config" + fi + + # Backend-specific credentials and endpoints are injected through the environment and/or config file. + SCCACHE_CMAKE_ARGS="-DCMAKE_C_COMPILER_LAUNCHER=${SCCACHE_BIN} -DCMAKE_CXX_COMPILER_LAUNCHER=${SCCACHE_BIN} -DCMAKE_CUDA_COMPILER_LAUNCHER=${SCCACHE_BIN}" + + if [[ -f /certs/ca-bundle.crt ]]; then + export SSL_CERT_FILE=/certs/ca-bundle.crt + export CURL_CA_BUNDLE=/certs/ca-bundle.crt + export REQUESTS_CA_BUNDLE=/certs/ca-bundle.crt + fi echo "sccache initial state" - ${SCCACHE} --show-stats + ${SCCACHE_BIN} --show-stats || true fi if [ -z "${NPROC}" ]; then @@ -212,6 +299,7 @@ fi echo "Using ${NPROC} cores." if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then + phase_start "Set up integrated test environment" echo "Running the integrated tests has been requested." # We install the python environment required by ATS to run the integrated tests. #or_die apt-get update @@ -224,12 +312,12 @@ if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then # Setup a temporary directory to hold tests tempdir=$(mktemp -d) echo "Setting up a temporary directory to hold tests and baselines: $tempdir" - trap "rm -rf $tempdir" EXIT ATS_BASELINE_DIR=$tempdir/GEOS_integratedTests_baselines ATS_WORKING_DIR=$tempdir/GEOS_integratedTests_working export ATS_FILTER="np<=32" ATS_CMAKE_ARGS="-DATS_ARGUMENTS=\"--machine openmpi --ats openmpi_mpirun=/usr/bin/mpirun --ats openmpi_args=--allow-run-as-root --ats openmpi_procspernode=32 --ats openmpi_maxprocs=32\" -DPython3_ROOT_DIR=${ATS_PYTHON_HOME} -DPython3_EXECUTABLE=${ATS_PYTHON_HOME}/bin/python3 -DATS_BASELINE_DIR=${ATS_BASELINE_DIR} -DATS_WORKING_DIR=${ATS_WORKING_DIR}" + phase_finish 0 fi @@ -252,6 +340,7 @@ fi # This will tells OpenMPI to discover the number of hardware threads on the node, # and use that as the number of slots available. (There is a distinction between threads and cores). GEOS_BUILD_DIR=/tmp/geos-build +phase_start "Configure" or_die python3 scripts/config-build.py \ -hc ${HOST_CONFIG} \ -bt ${CMAKE_BUILD_TYPE} \ @@ -268,23 +357,29 @@ or_die python3 scripts/config-build.py \ -DGEOS_ENABLE_BOUNDS_CHECK=${GEOS_ENABLE_BOUNDS_CHECK} \ ${SCCACHE_CMAKE_ARGS} \ ${ATS_CMAKE_ARGS} +phase_finish 0 # The configuration step is now over, we can now move to the build directory for the build! or_die cd ${GEOS_BUILD_DIR} # Code style check if [[ "${TEST_CODE_STYLE}" = true ]]; then + phase_start "Code style check" or_die ctest --output-on-failure -R "testUncrustifyCheck" + phase_finish 0 exit 0 fi # Documentation check if [[ "${TEST_DOCUMENTATION}" = true ]]; then + phase_start "Documentation check" or_die ctest --output-on-failure -R "testDoxygenCheck" + phase_finish 0 exit 0 fi # Performing the requested build. +phase_start "Build" if [[ "${BUILD_EXE_ONLY}" = true ]]; then or_die cmake --build . -j $NPROC --target geosx else @@ -303,25 +398,30 @@ else or_die tar czf ${DATA_EXCHANGE_DIR}/${DATA_BASENAME_WE}.tar.gz --directory=${GEOS_TPL_DIR}/.. --transform "s|^./|${DATA_BASENAME_WE}/|" . fi fi +phase_finish 0 -if [[ ! -z "${SCCACHE_CREDS}" ]]; then +if [[ -n "${SCCACHE_BIN}" ]]; then echo "sccache post-build state" - or_die ${SCCACHE} --show-adv-stats + or_die ${SCCACHE_BIN} --show-adv-stats fi if [[ "${CODE_COVERAGE}" = true ]]; then + phase_start "Generate code coverage" export OMP_NUM_THREADS=1 or_die cmake --build . --target coreComponents_coverage - cp -r ${GEOS_BUILD_DIR}/coreComponents_coverage.info.cleaned ${GEOS_SRC_DIR}/geos_coverage.info.cleaned + or_die cp -r ${GEOS_BUILD_DIR}/coreComponents_coverage.info.cleaned ${GEOS_SRC_DIR}/geos_coverage.info.cleaned + phase_finish 0 fi # Run the unit tests (excluding previously ran checks). if [[ "${RUN_UNIT_TESTS}" = true ]]; then + phase_start "Unit tests" if [ ${HOSTNAME} == 'streak.llnl.gov' ] || [ ${HOSTNAME} == 'streak2.llnl.gov' ]; then or_die ctest --output-on-failure -E "testUncrustifyCheck|testDoxygenCheck|testExternalSolvers" else or_die ctest --output-on-failure -E "testUncrustifyCheck|testDoxygenCheck" fi + phase_finish 0 fi if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then @@ -329,7 +429,9 @@ if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then export SETUPTOOLS_USE_DISTUTILS=stdlib # We split the process in two steps. First installing the environment, then running the tests. + phase_start "Build ATS environment" or_die cmake --build . --target ats_environment + phase_finish 0 # The tests are not run using cmake (`cmake --build . --verbose --target ats_run`) # because with ninja it swallows the output while all the @@ -339,15 +441,27 @@ if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then ls -lR /tmp/geos/baselines echo "Running integrated tests..." + phase_start "Integrated tests" integratedTests/geos_ats.sh --baselineCacheDirectory /tmp/geos/baselines + ATS_RUN_STATUS=$? + phase_finish "${ATS_RUN_STATUS}" + + phase_start "Process integrated test logs" + PROCESS_LOGS_STATUS=0 echo "Processing logs..." - bin/geos_ats_process_tests_fails --directory integratedTests/TestResults &> integratedTests/TestResults/processedTestsLogs.txt - echo "Packing logs..." - tar -czf ${DATA_EXCHANGE_DIR}/test_logs_${DATA_BASENAME_WE}.tar.gz integratedTests/TestResults + bin/geos_ats_process_tests_fails --directory integratedTests/TestResults &> integratedTests/TestResults/processedTestsLogs.txt || PROCESS_LOGS_STATUS=$? + if [[ "${PROCESS_LOGS_STATUS}" -eq 0 ]]; then + echo "Packing logs..." + tar -czf ${DATA_EXCHANGE_DIR}/test_logs_${DATA_BASENAME_WE}.tar.gz integratedTests/TestResults || PROCESS_LOGS_STATUS=$? + fi + phase_finish "${PROCESS_LOGS_STATUS}" echo "Checking results..." + phase_start "Check integrated test results" bin/geos_ats_log_check integratedTests/TestResults/test_results.ini -y ${GEOS_SRC_DIR}/.integrated_tests.yaml &> $tempdir/log_check.txt + LOG_CHECK_STATUS=$? cat $tempdir/log_check.txt + phase_finish "${LOG_CHECK_STATUS}" if grep -q "Overall status: PASSED" "$tempdir/log_check.txt"; then echo "IntegratedTests passed. No rebaseline required." @@ -357,10 +471,15 @@ if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then # Rebaseline and pack into an archive echo "Rebaselining..." - integratedTests/geos_ats.sh -a rebaselinefailed + phase_start "Rebaseline integrated tests" + REBASELINE_STATUS=0 + integratedTests/geos_ats.sh -a rebaselinefailed || REBASELINE_STATUS=$? - echo "Packing baselines..." - integratedTests/geos_ats.sh -a pack_baselines --baselineArchiveName ${DATA_EXCHANGE_DIR}/baseline_${DATA_BASENAME_WE}.tar.gz --baselineCacheDirectory /tmp/geos/baselines + if [[ "${REBASELINE_STATUS}" -eq 0 ]]; then + echo "Packing baselines..." + integratedTests/geos_ats.sh -a pack_baselines --baselineArchiveName ${DATA_EXCHANGE_DIR}/baseline_${DATA_BASENAME_WE}.tar.gz --baselineCacheDirectory /tmp/geos/baselines || REBASELINE_STATUS=$? + fi + phase_finish "${REBASELINE_STATUS}" INTEGRATED_TEST_EXIT_STATUS=1 fi @@ -371,11 +490,15 @@ if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then fi # Cleaning the build directory. +phase_start "Clean build directory" or_die cmake --build . --target clean +phase_finish 0 # Clean the repository +phase_start "Clean repository" or_die cd ${GEOS_SRC_DIR}/inputFiles -find . -name *.pyc | xargs rm -f +find . -name '*.pyc' -delete +phase_finish 0 # If we're here, either everything went OK or we have to deal with the integrated tests manually. if [[ ! -z "${INTEGRATED_TEST_EXIT_STATUS+x}" ]]; then From 5881085e1e4fa84ed98f2d98a639cfaf630fe37f Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Tue, 28 Apr 2026 10:30:10 +0200 Subject: [PATCH 06/53] add cpptrace --- host-configs/tpls.cmake | 4 +++ src/CMakeLists.txt | 4 +++ src/cmake/GeosxConfig.cmake | 1 + .../thirdparty/SetupGeosxThirdParty.cmake | 36 +++++++++++++++++++ src/coreComponents/common/GeosxConfig.hpp.in | 3 ++ 5 files changed, 48 insertions(+) diff --git a/host-configs/tpls.cmake b/host-configs/tpls.cmake index 1a4ab1701e6..ded9597c5be 100644 --- a/host-configs/tpls.cmake +++ b/host-configs/tpls.cmake @@ -109,3 +109,7 @@ endif() if(EXISTS ${GEOS_TPL_DIR}/mathpresso) set(MATHPRESSO_DIR ${GEOS_TPL_DIR}/mathpresso CACHE PATH "" FORCE) endif() + +if(EXISTS ${GEOS_TPL_DIR}/cpptrace) + set(CPPTRACE_DIR ${GEOS_TPL_DIR}/cpptrace CACHE PATH "" FORCE) +endif() \ No newline at end of file diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 36dc61610ac..49f662b4c91 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -133,6 +133,10 @@ if( ENABLE_HIP ) list( APPEND extraComponentsLinkList blt::hip ) endif() +if( ENABLE_CPPTRACE ) + list( APPEND extraComponentsLinkList cpptrace::cpptrace ) +endif() + blt_add_executable( NAME geosx SOURCES main/main.cpp DEPENDS_ON geosx_core diff --git a/src/cmake/GeosxConfig.cmake b/src/cmake/GeosxConfig.cmake index 39c206418f8..c79c1e07a8b 100644 --- a/src/cmake/GeosxConfig.cmake +++ b/src/cmake/GeosxConfig.cmake @@ -1,5 +1,6 @@ set( PREPROCESSOR_DEFINES BOUNDS_CHECK CALIPER + CPPTRACE CHAI CUDA CUDA_NVTOOLSEXT diff --git a/src/cmake/thirdparty/SetupGeosxThirdParty.cmake b/src/cmake/thirdparty/SetupGeosxThirdParty.cmake index 2bb024b2b05..b400c51f3d8 100644 --- a/src/cmake/thirdparty/SetupGeosxThirdParty.cmake +++ b/src/cmake/thirdparty/SetupGeosxThirdParty.cmake @@ -897,6 +897,7 @@ else() set(ENABLE_PETSC OFF CACHE BOOL "" FORCE) message(STATUS "Not using PETSc") endif() + ################################ # VTK ################################ @@ -935,6 +936,41 @@ else() message(STATUS "Not using VTK") endif() +################################ +# CPPTRACE +################################ +if( DEFINED CPPTRACE_DIR ) + message( STATUS "CPPTRACE_DIR = ${CPPTRACE_DIR}" ) + + if( DEFINED ZSTD_DIR ) + message( STATUS "ZSTD_DIR = ${ZSTD_DIR}" ) + list( PREPEND CMAKE_PREFIX_PATH "${ZSTD_DIR}" ) + endif() + if( DEFINED LIBDWARF_DIR ) + message( STATUS "LIBDWARF_DIR = ${LIBDWARF_DIR}" ) + list( PREPEND CMAKE_PREFIX_PATH "${LIBDWARF_DIR}" ) + endif() + + find_package( cpptrace REQUIRED + PATHS ${CPPTRACE_DIR} + NO_DEFAULT_PATH ) + + if( DEFINED cpptrace_VERSION ) + message( " ----> cpptrace_VERSION=${cpptrace_VERSION}") + endif() + + blt_convert_to_system_includes( TARGET cpptrace::cpptrace ) + + set( ENABLE_CPPTRACE ON CACHE BOOL "" ) + set( thirdPartyLibs ${thirdPartyLibs} cpptrace::cpptrace ) +else() + if( ENABLE_CPPTRACE ) + message( WARNING "ENABLE_CPPTRACE is ON but CPPTRACE_DIR isn't defined." ) + endif() + + set( ENABLE_CPPTRACE OFF CACHE BOOL "" ) + message( STATUS "Not using cpptrace" ) +endif() ################################ # uncrustify diff --git a/src/coreComponents/common/GeosxConfig.hpp.in b/src/coreComponents/common/GeosxConfig.hpp.in index 0c8ee16237f..aec6965c34b 100644 --- a/src/coreComponents/common/GeosxConfig.hpp.in +++ b/src/coreComponents/common/GeosxConfig.hpp.in @@ -38,6 +38,9 @@ /// Enables use of CHAI (CMake option ENABLE_CHAI) #cmakedefine GEOS_USE_CHAI +/// Enables use of Cpptrace (CMake option ENABLE_CPPTRACE) +#cmakedefine GEOS_USE_CPPTRACE + /// Enables use of Mathpresso library (CMake option ENABLE_MATHPRESSO) #cmakedefine GEOS_USE_MATHPRESSO From 6a684f27202ba3c6afbc4dc5a422f9fe398a8d92 Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Tue, 28 Apr 2026 10:31:31 +0200 Subject: [PATCH 07/53] modify main to use cpptrace stacktrace --- .../common/logger/ErrorHandling.cpp | 13 ++- src/main/main.cpp | 85 +++++++++++++++++++ 2 files changed, 94 insertions(+), 4 deletions(-) diff --git a/src/coreComponents/common/logger/ErrorHandling.cpp b/src/coreComponents/common/logger/ErrorHandling.cpp index 6881e11259a..3b36f7edf37 100644 --- a/src/coreComponents/common/logger/ErrorHandling.cpp +++ b/src/coreComponents/common/logger/ErrorHandling.cpp @@ -203,20 +203,25 @@ DiagnosticMsgBuilder & DiagnosticMsgBuilder::addRank( integer const rank ) DiagnosticMsgBuilder & DiagnosticMsgBuilder::addCallStackInfo( std::string_view ossStackTrace ) { + m_errorMsg.m_sourceCallStack.clear(); + m_errorMsg.m_isValidStackTrace = false; + std::string str = std::string( ossStackTrace ); std::istringstream iss( str ); std::string stackLine; std::size_t index; - std::regex pattern( R"(Frame \d+: \S+)" ); + std::regex lvArrayPattern( R"(Frame \d+: \S+)" ); + std::regex cpptracePattern( R"(^\s*#\d+\s+)" ); while( std::getline( iss, stackLine ) ) { - if( std::regex_search( stackLine, pattern )) + std::smatch m; + if( std::regex_search( stackLine, m, lvArrayPattern ) || + std::regex_search( stackLine, m, cpptracePattern ) ) { m_errorMsg.m_isValidStackTrace = true; - index = stackLine.find( ':' ); - m_errorMsg.m_sourceCallStack.push_back( stackLine.substr( index + 1 ) ); + m_errorMsg.m_sourceCallStack.push_back( stackLine.substr( m.position() + m.length() ) ); } } diff --git a/src/main/main.cpp b/src/main/main.cpp index 00c7a560ef6..d347d17e48e 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -16,6 +16,7 @@ // Source includes #include "common/logger/ErrorHandling.hpp" #include "common/logger/Logger.hpp" +#include "common/GeosxConfig.hpp" #include "common/MemoryInfos.hpp" #include "common/TimingMacros.hpp" #include "common/Units.hpp" @@ -23,6 +24,9 @@ #include "mainInterface/ProblemManager.hpp" #include "mainInterface/GeosxState.hpp" #include "mainInterface/version.hpp" +#ifdef GEOS_USE_CPPTRACE +#include "" +#endif using namespace geos; @@ -30,6 +34,51 @@ using namespace geos; int main( int argc, char *argv[] ) { +#ifdef GEOS_USE_CPPTRACE + cpptrace::try_catch + ( + [&] + { + std::chrono::system_clock::time_point startTime = std::chrono::system_clock::now(); + + std::unique_ptr< CommandLineOptions > commandLineOptions = basicSetup( argc, argv, true ); + + outputVersionInfo(); + + GEOS_LOG_RANK_0( GEOS_FMT( "Started at {:%Y-%m-%d %H:%M:%S}", startTime ) ); + + std::chrono::system_clock::duration initTime; + std::chrono::system_clock::duration runTime; + { + GeosxState state( std::move( commandLineOptions ) ); + + bool const problemToRun = state.initializeDataRepository(); + if( problemToRun ) + { + state.applyInitialConditions(); + state.run(); + GEOS_WARNING_IF( state.getState() != State::COMPLETED, "Simulation exited early." ); + } + + initTime = state.getInitTime(); + runTime = state.getRunTime(); + } + + MemoryLogging::getInstance().memoryStatsReport(); + + basicCleanup( false ); + + std::chrono::system_clock::time_point endTime = std::chrono::system_clock::now(); + std::chrono::system_clock::duration totalTime = endTime - startTime; + + GEOS_LOG_RANK_0( GEOS_FMT( "Finished at {:%Y-%m-%d %H:%M:%S}", endTime ) ); + GEOS_LOG_RANK_0( GEOS_FMT( "total time {}", units::TimeFormatInfo::fromDuration( totalTime ) ) ); + GEOS_LOG_RANK_0( GEOS_FMT( "initialization time {}", units::TimeFormatInfo::fromDuration( initTime ) ) ); + GEOS_LOG_RANK_0( GEOS_FMT( "run time {}", units::TimeFormatInfo::fromDuration( runTime ) ) ); + + // don't return with cpptrace (Windows limitation) + }, +#else try { std::chrono::system_clock::time_point startTime = std::chrono::system_clock::now(); @@ -71,18 +120,52 @@ int main( int argc, char *argv[] ) return 0; } +#endif + +#ifdef GEOS_USE_CPPTRACE + // A NotAnError is thrown if "-h" or "--help" option is used. + [&]( NotAnError const & ) + { + basicCleanup( false ); + }, +#else // A NotAnError is thrown if "-h" or "--help" option is used. catch( NotAnError const & ) { basicCleanup( false ); return 0; } +#endif + +#ifdef GEOS_USE_CPPTRACE + [&]( geos::Exception & e ) + { // GEOS generated exceptions management + ErrorLogger::global().flushCurrentExceptionMessage(); + basicCleanup( true ); + LvArray::system::callErrorHandler(); + }, +#else catch( geos::Exception & e ) { // GEOS generated exceptions management ErrorLogger::global().flushCurrentExceptionMessage(); basicCleanup( true ); LvArray::system::callErrorHandler(); } +#endif + +#ifdef GEOS_USE_CPPTRACE + [&]( std::exception const & e ) + { // native exceptions management + cpptrace::stacktrace const trace = cpptrace::from_current_exception(); + ErrorLogger::global().flushErrorMsg( ErrorLogger::global().initCurrentExceptionMessage( + MsgType::Exception, e.what(), + ::geos::logger::internal::g_rank ) + .addCallStackInfo( trace.to_string() ) + .getDiagnosticMsg()); + basicCleanup( true ); + LvArray::system::callErrorHandler(); + }, +#else catch( std::exception const & e ) { // native exceptions management ErrorLogger::global().flushErrorMsg( ErrorLogger::global().initCurrentExceptionMessage( @@ -93,5 +176,7 @@ int main( int argc, char *argv[] ) basicCleanup( true ); LvArray::system::callErrorHandler(); } +#endif + return 0; } From 69ba20e114a1694637ec54d700738126f9aecc1f Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Tue, 28 Apr 2026 14:43:03 +0200 Subject: [PATCH 08/53] fix typo in include --- src/main/main.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/main.cpp b/src/main/main.cpp index d347d17e48e..4bee88b340b 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -25,7 +25,7 @@ #include "mainInterface/GeosxState.hpp" #include "mainInterface/version.hpp" #ifdef GEOS_USE_CPPTRACE -#include "" +#include #endif From 39051faf88dc886d61fd6624f10e1746f4a2e4fd Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Tue, 28 Apr 2026 14:43:19 +0200 Subject: [PATCH 09/53] add missing parenthesis --- src/main/main.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/main.cpp b/src/main/main.cpp index 4bee88b340b..082eaf7218b 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -164,7 +164,7 @@ int main( int argc, char *argv[] ) .getDiagnosticMsg()); basicCleanup( true ); LvArray::system::callErrorHandler(); - }, + } ); #else catch( std::exception const & e ) { // native exceptions management From 8abfda8430972f45aa93b8e863dd5d6f88c655ce Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Tue, 28 Apr 2026 15:45:49 +0200 Subject: [PATCH 10/53] reorganize main.cpp for readability --- src/main/main.cpp | 116 +++++++++++++--------------------------------- 1 file changed, 31 insertions(+), 85 deletions(-) diff --git a/src/main/main.cpp b/src/main/main.cpp index 082eaf7218b..be58645cb58 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -34,52 +34,7 @@ using namespace geos; int main( int argc, char *argv[] ) { -#ifdef GEOS_USE_CPPTRACE - cpptrace::try_catch - ( - [&] - { - std::chrono::system_clock::time_point startTime = std::chrono::system_clock::now(); - - std::unique_ptr< CommandLineOptions > commandLineOptions = basicSetup( argc, argv, true ); - - outputVersionInfo(); - - GEOS_LOG_RANK_0( GEOS_FMT( "Started at {:%Y-%m-%d %H:%M:%S}", startTime ) ); - - std::chrono::system_clock::duration initTime; - std::chrono::system_clock::duration runTime; - { - GeosxState state( std::move( commandLineOptions ) ); - - bool const problemToRun = state.initializeDataRepository(); - if( problemToRun ) - { - state.applyInitialConditions(); - state.run(); - GEOS_WARNING_IF( state.getState() != State::COMPLETED, "Simulation exited early." ); - } - - initTime = state.getInitTime(); - runTime = state.getRunTime(); - } - - MemoryLogging::getInstance().memoryStatsReport(); - - basicCleanup( false ); - - std::chrono::system_clock::time_point endTime = std::chrono::system_clock::now(); - std::chrono::system_clock::duration totalTime = endTime - startTime; - - GEOS_LOG_RANK_0( GEOS_FMT( "Finished at {:%Y-%m-%d %H:%M:%S}", endTime ) ); - GEOS_LOG_RANK_0( GEOS_FMT( "total time {}", units::TimeFormatInfo::fromDuration( totalTime ) ) ); - GEOS_LOG_RANK_0( GEOS_FMT( "initialization time {}", units::TimeFormatInfo::fromDuration( initTime ) ) ); - GEOS_LOG_RANK_0( GEOS_FMT( "run time {}", units::TimeFormatInfo::fromDuration( runTime ) ) ); - - // don't return with cpptrace (Windows limitation) - }, -#else - try + auto runMain = [&] { std::chrono::system_clock::time_point startTime = std::chrono::system_clock::now(); @@ -117,64 +72,55 @@ int main( int argc, char *argv[] ) GEOS_LOG_RANK_0( GEOS_FMT( "total time {}", units::TimeFormatInfo::fromDuration( totalTime ) ) ); GEOS_LOG_RANK_0( GEOS_FMT( "initialization time {}", units::TimeFormatInfo::fromDuration( initTime ) ) ); GEOS_LOG_RANK_0( GEOS_FMT( "run time {}", units::TimeFormatInfo::fromDuration( runTime ) ) ); + }; - return 0; - } -#endif - -#ifdef GEOS_USE_CPPTRACE // A NotAnError is thrown if "-h" or "--help" option is used. - [&]( NotAnError const & ) + auto onNotAnError = [&]( NotAnError const & ) { basicCleanup( false ); - }, -#else - // A NotAnError is thrown if "-h" or "--help" option is used. - catch( NotAnError const & ) - { - basicCleanup( false ); - return 0; - } -#endif + }; -#ifdef GEOS_USE_CPPTRACE - [&]( geos::Exception & e ) + auto onGeosException = [&]( geos::Exception & e ) { // GEOS generated exceptions management ErrorLogger::global().flushCurrentExceptionMessage(); basicCleanup( true ); LvArray::system::callErrorHandler(); - }, -#else - catch( geos::Exception & e ) - { // GEOS generated exceptions management - ErrorLogger::global().flushCurrentExceptionMessage(); - basicCleanup( true ); - LvArray::system::callErrorHandler(); - } -#endif + }; -#ifdef GEOS_USE_CPPTRACE - [&]( std::exception const & e ) + auto onStdException = [&]( std::exception const & e ) { // native exceptions management - cpptrace::stacktrace const trace = cpptrace::from_current_exception(); +#ifdef GEOS_USE_CPPTRACE + std::string const stacktrace = cpptrace::from_current_exception().to_string(); +#else + std::string const stacktrace = LvArray::system::stackTrace( true ); +#endif ErrorLogger::global().flushErrorMsg( ErrorLogger::global().initCurrentExceptionMessage( MsgType::Exception, e.what(), ::geos::logger::internal::g_rank ) - .addCallStackInfo( trace.to_string() ) + .addCallStackInfo( stacktrace ) .getDiagnosticMsg()); basicCleanup( true ); LvArray::system::callErrorHandler(); - } ); + }; + +#ifdef GEOS_USE_CPPTRACE + cpptrace::try_catch( runMain, onNotAnError, onGeosException, onStdException ); #else + try + { + runMain(); + } + catch( NotAnError const & e ) + { + onNotAnError( e ); + } + catch( geos::Exception & e ) + { + onGeosException( e ); + } catch( std::exception const & e ) - { // native exceptions management - ErrorLogger::global().flushErrorMsg( ErrorLogger::global().initCurrentExceptionMessage( - MsgType::Exception, e.what(), - ::geos::logger::internal::g_rank ) - .addCallStackInfo( LvArray::system::stackTrace( true ) ) - .getDiagnosticMsg()); - basicCleanup( true ); - LvArray::system::callErrorHandler(); + { + onStdException( e ); } #endif From ae726405aca3f794823223dc2279841bbf7adbfa Mon Sep 17 00:00:00 2001 From: Tom Byer <149726499+tjb-ltk@users.noreply.github.com> Date: Thu, 30 Apr 2026 10:26:34 -0700 Subject: [PATCH 11/53] fix: thermal prod well inflow der (#4024) * thermal prod well inflow der fix * activate more unit tests, fix for case where there is 2 phase injection, probably an artifact of this unit test * cleanup inflow ders * use correct density for upstream inflow calc * clarify and fix test * refactor for PR review 1) prodwell mobs are not recomputed, 2) thermal inj well calcs need a bit of streamlining, but first lets see if the reg tests still work * add stackvariables and arrayslices * rearrange compute order to match integratedTests * streamline loops * Update src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/PerforationFluxKernels.hpp Co-authored-by: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> * fix schema * review suggestion --------- Co-authored-by: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> --- .../wellsTests/CMakeLists.txt | 2 + ...testReservoirThermalSinglePhaseMSWells.cpp | 160 ++-- ...rvoirThermalSinglePhaseMSWells_RateInj.cpp | 160 ++-- .../wellsTests/testThermalInjWell.cpp | 828 ++++++++++++++++++ .../wellsTests/testThermalProdWell.cpp | 820 +++++++++++++++++ ...eservoirCompositionalMultiphaseMSWells.cpp | 332 +++---- .../wells/kernels/PerforationFluxKernels.hpp | 613 +++++++------ 7 files changed, 2342 insertions(+), 573 deletions(-) create mode 100644 src/coreComponents/integrationTests/wellsTests/testThermalInjWell.cpp create mode 100644 src/coreComponents/integrationTests/wellsTests/testThermalProdWell.cpp diff --git a/src/coreComponents/integrationTests/wellsTests/CMakeLists.txt b/src/coreComponents/integrationTests/wellsTests/CMakeLists.txt index 5a30f2fe376..adf09e99b02 100644 --- a/src/coreComponents/integrationTests/wellsTests/CMakeLists.txt +++ b/src/coreComponents/integrationTests/wellsTests/CMakeLists.txt @@ -14,6 +14,8 @@ if( ENABLE_PVTPackage ) testReservoirThermalSinglePhaseMSWells_RateInj.cpp testIsothermalReservoirCompositionalMultiphaseMSWells.cpp testIsothermalReservoirCompositionalMultiphaseSSWells.cpp + testThermalInjWell.cpp + testThermalProdWell.cpp testThermalReservoirCompositionalMultiphaseSSWells.cpp testThermalReservoirCompositionalMultiphaseMSWells.cpp ) endif() diff --git a/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells.cpp b/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells.cpp index d10f1da56f6..8b1e19af0a7 100644 --- a/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells.cpp @@ -257,106 +257,104 @@ void testNumericalJacobian( SinglePhaseReservoirAndWells<> & solver, domain.forMeshBodies( [&] ( MeshBody & meshBody ) { - meshBody.forMeshLevels( [&] ( MeshLevel & mesh ) - { - ElementRegionManager & elemManager = mesh.getElemManager(); + MeshLevel & mesh = meshBody.getBaseDiscretization(); + ElementRegionManager & elemManager = mesh.getElemManager(); - for( localIndex er = 0; er < elemManager.numRegions(); ++er ) + for( localIndex er = 0; er < elemManager.numRegions(); ++er ) + { + ElementRegionBase & elemRegion = elemManager.getRegion( er ); + elemRegion.forElementSubRegions< CellElementSubRegion >( [&]( CellElementSubRegion & subRegion ) { - ElementRegionBase & elemRegion = elemManager.getRegion( er ); - elemRegion.forElementSubRegions< CellElementSubRegion >( [&]( CellElementSubRegion & subRegion ) + // get the dof numbers and ghosting information + arrayView1d< globalIndex const > const & dofNumber = + subRegion.getReference< array1d< globalIndex > >( resDofKey ); + + // get the primary variables on reservoir elements + arrayView1d< real64 > const & pres = + subRegion.getField< fields::well::pressure >(); + pres.move( hostMemorySpace, false ); + + // get the primary variables on reservoir elements + arrayView1d< real64 > const & temp = + subRegion.getField< fields::well::temperature >(); + temp.move( hostMemorySpace, false ); + + // a) compute all the derivatives wrt to the pressure in RESERVOIR elem ei + for( localIndex ei = 0; ei < subRegion.size(); ++ei ) { - // get the dof numbers and ghosting information - arrayView1d< globalIndex const > const & dofNumber = - subRegion.getReference< array1d< globalIndex > >( resDofKey ); - - // get the primary variables on reservoir elements - arrayView1d< real64 > const & pres = - subRegion.getField< fields::well::pressure >(); - pres.move( hostMemorySpace, false ); - - // get the primary variables on reservoir elements - arrayView1d< real64 > const & temp = - subRegion.getField< fields::well::temperature >(); - temp.move( hostMemorySpace, false ); - - // a) compute all the derivatives wrt to the pressure in RESERVOIR elem ei - for( localIndex ei = 0; ei < subRegion.size(); ++ei ) { - { - solver.resetStateToBeginningOfStep( domain ); + solver.resetStateToBeginningOfStep( domain ); - // here is the perturbation in the pressure of the element - real64 const dP = perturbParameter * (pres[ei] + perturbParameter); - pres.move( hostMemorySpace, true ); - pres[ei] += dP; + // here is the perturbation in the pressure of the element + real64 const dP = perturbParameter * (pres[ei] + perturbParameter); + pres.move( hostMemorySpace, true ); + pres[ei] += dP; - // after perturbing, update the pressure-dependent quantities in the reservoir - flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh2, - string_array const & regionNames2 ) + // after perturbing, update the pressure-dependent quantities in the reservoir + flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh2, + string_array const & regionNames2 ) + { + mesh2.getElemManager().forElementSubRegions( regionNames2, + [&]( localIndex const, + ElementSubRegionBase & subRegion2 ) { - mesh2.getElemManager().forElementSubRegions( regionNames2, - [&]( localIndex const, - ElementSubRegionBase & subRegion2 ) - { - flowSolver.updateFluidState( subRegion2 ); - } ); + flowSolver.updateFluidState( subRegion2 ); } ); + } ); - wellSolver.updateState( domain ); + wellSolver.updateState( domain ); - residual.zero(); - jacobian.zero(); - assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); - fillNumericalJacobian( residual.toViewConst(), - residualOrig.toViewConst(), - dofNumber[ei], - dP, - jacobianFD.toViewConstSizes() ); - } + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + dofNumber[ei], + dP, + jacobianFD.toViewConstSizes() ); } - // b) compute all the derivatives wrt to the temperature in RESERVOIR elem ei - for( localIndex ei = 0; ei < subRegion.size(); ++ei ) + } + // b) compute all the derivatives wrt to the temperature in RESERVOIR elem ei + for( localIndex ei = 0; ei < subRegion.size(); ++ei ) + { { - { - solver.resetStateToBeginningOfStep( domain ); + solver.resetStateToBeginningOfStep( domain ); - // here is the perturbation in the temperature of the element - real64 const dT = perturbParameter * (temp[ei] + perturbParameter); - temp.move( hostMemorySpace, true ); - temp[ei] += dT; + // here is the perturbation in the temperature of the element + real64 const dT = perturbParameter * (temp[ei] + perturbParameter); + temp.move( hostMemorySpace, true ); + temp[ei] += dT; - // after perturbing, update the temperature-dependent quantities in the reservoir - flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh2, - string_array const & regionNames2 ) + // after perturbing, update the temperature-dependent quantities in the reservoir + flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh2, + string_array const & regionNames2 ) + { + mesh2.getElemManager().forElementSubRegions( regionNames2, + [&]( localIndex const, + ElementSubRegionBase & subRegion2 ) { - mesh2.getElemManager().forElementSubRegions( regionNames2, - [&]( localIndex const, - ElementSubRegionBase & subRegion2 ) - { - flowSolver.updateFluidState( subRegion2 ); - } ); + flowSolver.updateFluidState( subRegion2 ); } ); + } ); - wellSolver.updateState( domain ); + wellSolver.updateState( domain ); - residual.zero(); - jacobian.zero(); - assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); - fillNumericalJacobian( residual.toViewConst(), - residualOrig.toViewConst(), - dofNumber[ei], - dT, - jacobianFD.toViewConstSizes() ); - } + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + dofNumber[ei]+1, + dT, + jacobianFD.toViewConstSizes() ); } - } ); - } - } ); + } + } ); + } } ); ///////////////////////////////////////////////// @@ -528,6 +526,10 @@ class SinglePhaseReservoirSolverTest : public ::testing::Test [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { + // commented out due to treatement of temp well constraint. This is the only term that is causing the test to fail, and the test is + // good otherwise. If this is fixed, uncomment out printCompareLocalMatrices and look at FD and computed derivatives + // uncomment out printCompareLocalMatrices and look at FD and computed derivatives + // solver->wellSolver()->assembleSystem( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); solver->assembleCouplingTerms( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); } ); } diff --git a/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells_RateInj.cpp b/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells_RateInj.cpp index 255b0201692..b1fa0d9cb84 100644 --- a/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells_RateInj.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells_RateInj.cpp @@ -340,108 +340,107 @@ void testNumericalJacobian( SinglePhaseReservoirAndWells<> & solver, domain.forMeshBodies( [&] ( MeshBody & meshBody ) { - meshBody.forMeshLevels( [&] ( MeshLevel & mesh ) - { - ElementRegionManager & elemManager = mesh.getElemManager(); + MeshLevel & mesh = meshBody.getBaseDiscretization(); + ElementRegionManager & elemManager = mesh.getElemManager(); - for( localIndex er = 0; er < elemManager.numRegions(); ++er ) + for( localIndex er = 0; er < elemManager.numRegions(); ++er ) + { + ElementRegionBase & elemRegion = elemManager.getRegion( er ); + elemRegion.forElementSubRegions< CellElementSubRegion >( [&]( CellElementSubRegion & subRegion ) { - ElementRegionBase & elemRegion = elemManager.getRegion( er ); - elemRegion.forElementSubRegions< CellElementSubRegion >( [&]( CellElementSubRegion & subRegion ) + // get the dof numbers and ghosting information + arrayView1d< globalIndex const > const & dofNumber = + subRegion.getReference< array1d< globalIndex > >( resDofKey ); + + // get the primary variables on reservoir elements + arrayView1d< real64 > const & pres = + subRegion.getField< fields::well::pressure >(); + pres.move( hostMemorySpace, false ); + + // get the primary variables on reservoir elements + arrayView1d< real64 > const & temp = + subRegion.getField< fields::well::temperature >(); + temp.move( hostMemorySpace, false ); + + // a) compute all the derivatives wrt to the pressure in RESERVOIR elem ei + for( localIndex ei = 0; ei < subRegion.size(); ++ei ) { - // get the dof numbers and ghosting information - arrayView1d< globalIndex const > const & dofNumber = - subRegion.getReference< array1d< globalIndex > >( resDofKey ); - - // get the primary variables on reservoir elements - arrayView1d< real64 > const & pres = - subRegion.getField< fields::well::pressure >(); - pres.move( hostMemorySpace, false ); - - // get the primary variables on reservoir elements - arrayView1d< real64 > const & temp = - subRegion.getField< fields::well::temperature >(); - temp.move( hostMemorySpace, false ); - - // a) compute all the derivatives wrt to the pressure in RESERVOIR elem ei - for( localIndex ei = 0; ei < subRegion.size(); ++ei ) { - { - solver.resetStateToBeginningOfStep( domain ); + solver.resetStateToBeginningOfStep( domain ); - // here is the perturbation in the pressure of the element - real64 const dP = perturbParameter * (pres[ei] + perturbParameter); - pres.move( hostMemorySpace, true ); - pres[ei] += dP; + // here is the perturbation in the pressure of the element + real64 const dP = perturbParameter * (pres[ei] + perturbParameter); + pres.move( hostMemorySpace, true ); + pres[ei] += dP; - // after perturbing, update the pressure-dependent quantities in the reservoir - flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh2, - string_array const & regionNames2 ) + // after perturbing, update the pressure-dependent quantities in the reservoir + flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh2, + string_array const & regionNames2 ) + { + mesh2.getElemManager().forElementSubRegions( regionNames2, + [&]( localIndex const, + ElementSubRegionBase & subRegion2 ) { - mesh2.getElemManager().forElementSubRegions( regionNames2, - [&]( localIndex const, - ElementSubRegionBase & subRegion2 ) - { - flowSolver.updateFluidState( subRegion2 ); - } ); + flowSolver.updateFluidState( subRegion2 ); } ); + } ); - wellSolver.updateState( domain ); + wellSolver.updateState( domain ); - residual.zero(); - jacobian.zero(); - assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); - fillNumericalJacobian( residual.toViewConst(), - residualOrig.toViewConst(), - dofNumber[ei], - dP, - jacobianFD.toViewConstSizes() ); - } + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + dofNumber[ei], + dP, + jacobianFD.toViewConstSizes() ); } - // b) compute all the derivatives wrt to the temperature in RESERVOIR elem ei - for( localIndex ei = 0; ei < subRegion.size(); ++ei ) + } + // b) compute all the derivatives wrt to the temperature in RESERVOIR elem ei + for( localIndex ei = 0; ei < subRegion.size(); ++ei ) + { { - { - solver.resetStateToBeginningOfStep( domain ); + solver.resetStateToBeginningOfStep( domain ); - // here is the perturbation in the temperature of the element - real64 const dT = perturbParameter * (temp[ei] + perturbParameter); - temp.move( hostMemorySpace, true ); - temp[ei] += dT; + // here is the perturbation in the temperature of the element + real64 const dT = perturbParameter * (temp[ei] + perturbParameter); + temp.move( hostMemorySpace, true ); + temp[ei] += dT; - // after perturbing, update the temperature-dependent quantities in the reservoir - flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh2, - string_array const & regionNames2 ) + // after perturbing, update the temperature-dependent quantities in the reservoir + flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh2, + string_array const & regionNames2 ) + { + mesh2.getElemManager().forElementSubRegions( regionNames2, + [&]( localIndex const, + ElementSubRegionBase & subRegion2 ) { - mesh2.getElemManager().forElementSubRegions( regionNames2, - [&]( localIndex const, - ElementSubRegionBase & subRegion2 ) - { - flowSolver.updateFluidState( subRegion2 ); - } ); + flowSolver.updateFluidState( subRegion2 ); } ); + } ); - wellSolver.updateState( domain ); + wellSolver.updateState( domain ); - residual.zero(); - jacobian.zero(); - assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); - fillNumericalJacobian( residual.toViewConst(), - residualOrig.toViewConst(), - dofNumber[ei], - dT, - jacobianFD.toViewConstSizes() ); - } + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + dofNumber[ei]+1, + dT, + jacobianFD.toViewConstSizes() ); } - } ); - } - } ); + } + } ); + } } ); + ///////////////////////////////////////////////// // Step 2) Compute the terms in J_RW and J_WW // ///////////////////////////////////////////////// @@ -606,10 +605,11 @@ class SinglePhaseReservoirSolverTest : public ::testing::Test DomainPartition & domain = state.getProblemManager().getDomainPartition(); - testNumericalJacobian( *solver, domain, perturb, tol, false, __func__, + testNumericalJacobian( *solver, domain, perturb, tol, true, __func__, [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { + solver->wellSolver()->assembleSystem( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); solver->assembleCouplingTerms( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); } ); } diff --git a/src/coreComponents/integrationTests/wellsTests/testThermalInjWell.cpp b/src/coreComponents/integrationTests/wellsTests/testThermalInjWell.cpp new file mode 100644 index 00000000000..b7bfa1a4ce6 --- /dev/null +++ b/src/coreComponents/integrationTests/wellsTests/testThermalInjWell.cpp @@ -0,0 +1,828 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 "integrationTests/fluidFlowTests/testCompFlowUtils.hpp" + +#include "common/DataTypes.hpp" +#include "mainInterface/initialization.hpp" +#include "constitutive/fluid/multifluid/MultiFluidBase.hpp" +#include "mainInterface/ProblemManager.hpp" +#include "mesh/DomainPartition.hpp" +#include "mainInterface/GeosxState.hpp" +#include "mesh/WellElementSubRegion.hpp" +#include "physicsSolvers/PhysicsSolverManager.hpp" +#include "physicsSolvers/multiphysics/CompositionalMultiphaseReservoirAndWells.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseFVM.hpp" +#include "physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.hpp" +#include "physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWellFields.hpp" +#include "physicsSolvers/fluidFlow/wells/WellSolverBaseFields.hpp" +#include "physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellKernels.hpp" + +using namespace geos; +using namespace geos::dataRepository; +using namespace geos::constitutive; +using namespace geos::testing; + +CommandLineOptions g_commandLineOptions; + +void writeTableToFile( string const & filename, char const * str ) +{ + std::ofstream os( filename ); + ASSERT_TRUE( os.is_open() ); + os << str; + os.close(); +} + +void removeFile( string const & filename ) +{ + int const ret = std::remove( filename.c_str() ); + ASSERT_TRUE( ret == 0 ); +} +char const * co2flash = "FlashModel CO2Solubility 1e5 7.5e7 5e5 283.15 414.15 10 0\n"; +char const * pvtLiquid = "DensityFun PhillipsBrineDensity 1e5 7.5e7 5e5 283.15 414.15 10 0\n" + "ViscosityFun PhillipsBrineViscosity 0\n" + "EnthalpyFun BrineEnthalpy 1e5 7.5e7 5e5 283.15 414.15 10 0\n"; + +char const * pvtGas = "DensityFun SpanWagnerCO2Density 1e5 7.5e7 5e5 283.15 414.15 10\n" + "ViscosityFun FenghourCO2Viscosity 1e5 7.5e7 5e5 283.15 414.15 10\n" + "EnthalpyFun CO2Enthalpy 1e5 7.5e7 5e5 283.15 414.15 10\n"; +char const * xmlInput = + R"xml( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +)xml"; + +template< typename T, typename COL_INDEX > +void printCompareLocalMatrices( CRSMatrixView< T const, COL_INDEX const > const & matrix1, + CRSMatrixView< T const, COL_INDEX const > const & matrix2, std::string const & testName ) +{ + std::ofstream omat1( testName+".csv" ); + + + std::vector< std::vector< double > > fmat1( matrix1.numRows(), std::vector< double >( matrix1.numRows(), 0.0 )); + std::vector< std::vector< double > > fmat2( matrix2.numRows(), std::vector< double >( matrix2.numRows(), 0.0 )); + + for( localIndex i = 0; i < matrix1.numRows(); ++i ) + { + arraySlice1d< globalIndex const > indices1 = matrix1.getColumns( i ); + arraySlice1d< globalIndex const > indices2 = matrix2.getColumns( i ); + arraySlice1d< double const > values1 = matrix1.getEntries( i ); + arraySlice1d< double const > values2 = matrix2.getEntries( i ); + for( integer j=0; j const & rsd1, + array1d< real64 > const & rsd2, std::string const & testName ) +{ + std::ofstream omat1( testName+".csv" ); + + for( integer i=0; i +void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< CompositionalMultiphaseBase > & solver, + DomainPartition & domain, + real64 const perturbParameter, + real64 const time_n, + real64 const relTol, bool diag_check, std::string const & testName, + LAMBDA && assembleFunction ) +{ + GEOS_UNUSED_VAR( time_n ); + GEOS_UNUSED_VAR ( testName ); + CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); + + CompositionalMultiphaseFVM & flowSolver = dynamicCast< CompositionalMultiphaseFVM & >( *solver.reservoirSolver() ); + + localIndex const NC = flowSolver.numFluidComponents(); + + CRSMatrix< real64, globalIndex > const & jacobian = solver.getLocalMatrix(); + array1d< real64 > residual( jacobian.numRows() ); + DofManager const & dofManager = solver.getDofManager(); + + // assemble the analytical residual + solver.resetStateToBeginningOfStep( domain ); + string const resDofKey = dofManager.getKey( wellSolver.resElementDofName() ); + string const wellDofKey = dofManager.getKey( wellSolver.wellElementDofName() ); + residual.zero(); + jacobian.zero(); + + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + residual.move( hostMemorySpace, false ); + + // copy the analytical residual + array1d< real64 > residualOrig( residual ); + + // create the numerical jacobian + jacobian.move( hostMemorySpace ); + CRSMatrix< real64, globalIndex > jacobianFD( jacobian ); + jacobianFD.zero(); + //////////////////////////////////////////////// + // Step 1) Compute the terms in J_RR and J_WR // + //////////////////////////////////////////////// +#if 1 + domain.forMeshBodies( [&] ( MeshBody & meshBody ) + { + MeshLevel & mesh = meshBody.getBaseDiscretization(); + + ElementRegionManager & elemManager = mesh.getElemManager(); + for( localIndex er = 0; er < elemManager.numRegions(); ++er ) + { + ElementRegionBase & elemRegion = elemManager.getRegion( er ); + elemRegion.forElementSubRegionsIndex< CellElementSubRegion >( [&]( localIndex const, CellElementSubRegion & subRegion ) + { + // get the degrees of freedom and ghosting information + arrayView1d< globalIndex const > const & dofNumber = + subRegion.getReference< array1d< globalIndex > >( resDofKey ); + + // get the primary variables on the reservoir elements + arrayView1d< real64 > const & pres = + subRegion.getField< fields::flow::pressure >(); + pres.move( hostMemorySpace, false ); + + arrayView1d< real64 > const & temperature = + subRegion.getField< fields::flow::temperature >(); + temperature.move( hostMemorySpace, false ); + + arrayView2d< real64, compflow::USD_COMP > const & compDens = + subRegion.getField< fields::flow::globalCompDensity >(); + compDens.move( hostMemorySpace, false ); + + // a) compute all the derivatives wrt to the pressure in RESERVOIR elem ei + for( localIndex ei = 0; ei < subRegion.size(); ++ei ) + { +#if 1 + { + solver.resetStateToBeginningOfStep( domain ); + + // here is the perturbation in the pressure of the element + real64 const dP = perturbParameter * (pres[ei] + perturbParameter); + pres.move( hostMemorySpace, true ); + pres[ei] += dP; + + // after perturbing, update the pressure-dependent quantities in the reservoir + flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh2, + string_array const & regionNames2 ) + { + mesh2.getElemManager().forElementSubRegions( regionNames2, + [&]( localIndex const, + ElementSubRegionBase & subRegion2 ) + { + flowSolver.updateFluidState( subRegion2 ); + } ); + } ); + + wellSolver.updateState( domain ); + + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + dofNumber[ei], + dP, + jacobianFD.toViewConstSizes() ); + } +#endif +#if 1 + { + solver.resetStateToBeginningOfStep( domain ); + + // here is the perturbation in the temperature of the element + real64 const dT = 1; //perturbParameter * (temperature[ei] + perturbParameter); + temperature.move( hostMemorySpace, true ); + temperature[ei] += dT; + + // after perturbing, update the temperature-dependent quantities in the reservoir + flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh2, + string_array const & regionNames2 ) + { + mesh2.getElemManager().forElementSubRegions( regionNames2, + [&]( localIndex const, + ElementSubRegionBase & subRegion2 ) + { + flowSolver.updateFluidState( subRegion2 ); + } ); + } ); + + wellSolver.updateState( domain ); + + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + dofNumber[ei]+NC+1, + dT, + jacobianFD.toViewConstSizes() ); + } +#endif +#if 1 + real64 totalDensity = 0.0; + for( localIndex ic = 0; ic < NC; ++ic ) + { + totalDensity += compDens[ei][ic]; + } + + for( localIndex jc = 0; jc < NC; ++jc ) + { + solver.resetStateToBeginningOfStep( domain ); + + real64 const dRho = perturbParameter * totalDensity; + compDens.move( hostMemorySpace, true ); + compDens[ei][jc] += dRho; + + flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh2, + string_array const & regionNames2 ) + { + mesh2.getElemManager().forElementSubRegions( regionNames2, + [&]( localIndex const, + ElementSubRegionBase & subRegion2 ) + { + flowSolver.updateFluidState( subRegion2 ); + } ); + } ); + + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + dofNumber[ei] + jc + 1, + dRho, + jacobianFD.toViewConstSizes() ); + } +#endif + } + + return; + } ); + } + + } ); + +#endif + // at this point we start assembling the finite-difference block by block + + + ///////////////////////////////////////////////// + // Step 2) Compute the terms in J_RW and J_WW // + ///////////////////////////////////////////////// + + // loop over the wells + if( 1 ) + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + mesh.getElemManager().forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + // get the degrees of freedom, ghosting info and next well elem index + arrayView1d< globalIndex const > const & wellElemDofNumber = + subRegion.getReference< array1d< globalIndex > >( wellDofKey ); + + // get the primary variables on the well elements + arrayView1d< real64 > const & wellElemPressure = + subRegion.getField< fields::well::pressure >(); + wellElemPressure.move( hostMemorySpace, false ); + + arrayView1d< real64 > const & wellElemTemperature = + subRegion.getField< fields::well::temperature >(); + wellElemTemperature.move( hostMemorySpace, false ); + + arrayView2d< real64, compflow::USD_COMP > const & wellElemCompDens = + subRegion.getField< fields::well::globalCompDensity >(); + wellElemCompDens.move( hostMemorySpace, false ); + + arrayView1d< real64 > const & connRate = + subRegion.getField< fields::well::mixtureConnectionRate >(); + connRate.move( hostMemorySpace, false ); + + // a) compute all the derivatives wrt to the pressure in WELL elem iwelem + for( localIndex iwelem = 0; iwelem < subRegion.size(); ++iwelem ) + { + +#if 1 + { + solver.resetStateToBeginningOfStep( domain ); + + // here is the perturbation in the pressure of the well element + real64 const dP = perturbParameter * ( wellElemPressure[iwelem] + perturbParameter ); + wellElemPressure.move( hostMemorySpace, true ); + wellElemPressure[iwelem] += dP; + + // after perturbing, update the pressure-dependent quantities in the well + wellSolver.updateState( domain ); + + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + wellElemDofNumber[iwelem] + compositionalMultiphaseWellKernels::ColOffset::DPRES, + dP, + jacobianFD.toViewConstSizes() ); + } +#endif +#if 1 + real64 wellElemTotalDensity = 0.0; + for( localIndex ic = 0; ic < NC; ++ic ) + { + wellElemTotalDensity += wellElemCompDens[iwelem][ic]; + } + for( localIndex jc = 0; jc < NC; ++jc ) + { + solver.resetStateToBeginningOfStep( domain ); + + real64 const dRho = perturbParameter * wellElemTotalDensity; + wellElemCompDens.move( hostMemorySpace, true ); + wellElemCompDens[iwelem][jc] += dRho; + + wellSolver.updateState( domain ); + + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + wellElemDofNumber[iwelem] + compositionalMultiphaseWellKernels::ColOffset::DCOMP + jc, + dRho, + jacobianFD.toViewConstSizes() ); + } + { + solver.resetStateToBeginningOfStep( domain ); + residual.zero(); + jacobian.zero(); + if( diag_check || iwelem > 0 ) + { + // here is the perturbation in the temperature of the well element + real64 const dT = perturbParameter * ( wellElemTemperature[iwelem] + perturbParameter ); + wellElemTemperature.move( hostMemorySpace, true ); + wellElemTemperature[iwelem] += dT; + + // after perturbing, update the pressure-dependent quantities in the well + wellSolver.updateState( domain ); + + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + wellElemDofNumber[iwelem] + compositionalMultiphaseWellKernels::ColOffset::DCOMP + NC+1, + dT, + jacobianFD.toViewConstSizes() ); + if( iwelem == 1 ) + { + real64 dRdX = 0.0; + localIndex rowIndex = wellElemDofNumber[0] + compositionalMultiphaseWellKernels::ColOffset::DCOMP + NC+1;; + for( integer ider=0; ider< 3; ider++ ) + { + globalIndex colIndex = wellElemDofNumber[0]+ ider; + setNumericalJacobianValue( rowIndex, colIndex, dRdX, jacobianFD.toViewConstSizes() ); + } + globalIndex colIndex = wellElemDofNumber[1]+3; + setNumericalJacobianValue( rowIndex, colIndex, dRdX, jacobianFD.toViewConstSizes() ); + + } + } + else + { + localIndex rowIndex = wellElemDofNumber[iwelem] + compositionalMultiphaseWellKernels::ColOffset::DCOMP + NC+1;; + globalIndex colIndex = wellElemDofNumber[iwelem] + compositionalMultiphaseWellKernels::ColOffset::DCOMP + NC+1;; + setNumericalJacobianValue( rowIndex, colIndex, 1.0, jacobianFD.toViewConstSizes() ); + } + } +#endif + } + +#if 1 + // b) compute all the derivatives wrt to the connection in WELL elem + // iwelem + for( localIndex iwelem = 0; iwelem < subRegion.size(); ++iwelem ) + { + { + solver.resetStateToBeginningOfStep( domain ); + + // here is the perturbation in the rate of the well element + real64 const dRate = perturbParameter * ( connRate[iwelem] + perturbParameter ); + connRate.move( hostMemorySpace, true ); + connRate[iwelem] += dRate; + + wellSolver.updateState( domain ); + + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + wellElemDofNumber[iwelem] + compositionalMultiphaseWellKernels::ColOffset::DCOMP + NC, + dRate, + jacobianFD.toViewConstSizes() ); + } + } +#endif + } ); + } ); + + // assemble the analytical jacobian + solver.resetStateToBeginningOfStep( domain ); + + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + //printCompareLocalMatrices( jacobian.toViewConst(), jacobianFD.toViewConst(), testName ); + compareLocalMatrices( jacobian.toViewConst(), jacobianFD.toViewConst(), relTol ); +} + +class CompositionalMultiphaseReservoirSolverTest : public ::testing::Test +{ +public: + + CompositionalMultiphaseReservoirSolverTest(): + state( std::make_unique< CommandLineOptions >( g_commandLineOptions ) ) + {} + +protected: + + void SetUp() override + { + setupProblemFromXML( state.getProblemManager(), xmlInput ); + solver = &state.getProblemManager().getPhysicsSolverManager().getGroup< CompositionalMultiphaseReservoirAndWells<> >( "reservoirSystem" ); + + DomainPartition & domain = state.getProblemManager().getDomainPartition(); + + solver->setupSystem( domain, + solver->getDofManager(), + solver->getLocalMatrix(), + solver->getSystemRhs(), + solver->getSystemSolution() ); + + solver->implicitStepSetup( time, dt, domain ); + } + static real64 constexpr time = 0.0; + static real64 constexpr dt = 1e4; + static real64 constexpr eps = std::numeric_limits< real64 >::epsilon(); + + GeosxState state; + CompositionalMultiphaseReservoirAndWells< CompositionalMultiphaseBase > * solver; +}; + +real64 constexpr CompositionalMultiphaseReservoirSolverTest::time; +real64 constexpr CompositionalMultiphaseReservoirSolverTest::dt; +real64 constexpr CompositionalMultiphaseReservoirSolverTest::eps; + + + +#if 0 +// There are a few terms that cause this test to fail, these are dt terms of cell connected to cell with boundary condtion. +// The could be zeroed out in the jacobian assembly and then this test should pass. +// Otherwise the test is good, uncomment out printCompareLocalMatrices and look at FD and computed derivatives +TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_System ) +{ + real64 const perturb = std::sqrt( eps ); + real64 const tol = 1e-1; // 10% error margin + + DomainPartition & domain = state.getProblemManager().getDomainPartition(); + + testWellNumericalJacobian( *solver, domain, perturb, time, tol, false, "Check_System", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + + solver->wellSolver()->assembleSystem( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + solver->assembleCouplingTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + + } ); +} +#endif +TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Accum ) +{ + real64 const perturb = std::sqrt( eps ); + real64 const tol = 1e-1; // 10% error margin + + DomainPartition & domain = state.getProblemManager().getDomainPartition(); + + testWellNumericalJacobian( *solver, domain, perturb, time, tol, false, "Check_Accum", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + solver->wellSolver()->assembleAccumulationTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + } ); +} +#if 1 +TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_PressureRelation ) +{ + real64 const perturb = std::sqrt( eps ); + real64 const tol = 1e-1; // 10% error margin + + DomainPartition & domain = state.getProblemManager().getDomainPartition(); + + testWellNumericalJacobian( *solver, domain, perturb, time, tol, true, "Check_PressureRelation", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + solver->wellSolver()->assemblePressureRelations( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + } ); +} +#endif +#if 1 +TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Flux ) +{ + real64 const perturb = std::sqrt( eps ); + real64 const tol = 1e-1; // 10% error margin + + DomainPartition & domain = state.getProblemManager().getDomainPartition(); + + testWellNumericalJacobian( *solver, domain, perturb, time, tol, true, "Check_Flux", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + solver->wellSolver()->assembleFluxTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + } ); +} +#endif +int main( int argc, char * * argv ) +{ + writeTableToFile( "co2flash.txt", co2flash ); + writeTableToFile( "pvtliquid.txt", pvtLiquid ); + writeTableToFile( "pvtgas.txt", pvtGas ); + ::testing::InitGoogleTest( &argc, argv ); + g_commandLineOptions = *geos::basicSetup( argc, argv ); + int const result = RUN_ALL_TESTS(); + geos::basicCleanup(); + removeFile( "co2flash.txt" ); + removeFile( "pvtliquid.txt" ); + removeFile( "pvtgas.txt" ); + + return result; +} diff --git a/src/coreComponents/integrationTests/wellsTests/testThermalProdWell.cpp b/src/coreComponents/integrationTests/wellsTests/testThermalProdWell.cpp new file mode 100644 index 00000000000..a0bbc409c9e --- /dev/null +++ b/src/coreComponents/integrationTests/wellsTests/testThermalProdWell.cpp @@ -0,0 +1,820 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 "integrationTests/fluidFlowTests/testCompFlowUtils.hpp" + +#include "common/DataTypes.hpp" +#include "mainInterface/initialization.hpp" +#include "constitutive/fluid/multifluid/MultiFluidBase.hpp" +#include "mainInterface/ProblemManager.hpp" +#include "mesh/DomainPartition.hpp" +#include "mainInterface/GeosxState.hpp" +#include "mesh/WellElementSubRegion.hpp" +#include "physicsSolvers/PhysicsSolverManager.hpp" +#include "physicsSolvers/multiphysics/CompositionalMultiphaseReservoirAndWells.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseFVM.hpp" +#include "physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.hpp" +#include "physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWellFields.hpp" +#include "physicsSolvers/fluidFlow/wells/WellSolverBaseFields.hpp" +#include "physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellKernels.hpp" + +using namespace geos; +using namespace geos::dataRepository; +using namespace geos::constitutive; +using namespace geos::testing; + +CommandLineOptions g_commandLineOptions; + + + +void writeTableToFile( string const & filename, char const * str ) +{ + std::ofstream os( filename ); + ASSERT_TRUE( os.is_open() ); + os << str; + os.close(); +} + +void removeFile( string const & filename ) +{ + int const ret = std::remove( filename.c_str() ); + ASSERT_TRUE( ret == 0 ); +} +char const * co2flash = "FlashModel CO2Solubility 1e5 7.5e7 5e5 283.15 414.15 10 0\n"; +char const * pvtLiquid = "DensityFun PhillipsBrineDensity 1e5 7.5e7 5e5 283.15 414.15 10 0\n" + "ViscosityFun PhillipsBrineViscosity 0\n" + "EnthalpyFun BrineEnthalpy 1e5 7.5e7 5e5 283.15 414.15 10 0\n"; + +char const * pvtGas = "DensityFun SpanWagnerCO2Density 1e5 7.5e7 5e5 283.15 414.15 10\n" + "ViscosityFun FenghourCO2Viscosity 1e5 7.5e7 5e5 283.15 414.15 10\n" + "EnthalpyFun CO2Enthalpy 1e5 7.5e7 5e5 283.15 414.15 10\n"; +char const * xmlInput = + R"xml( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +)xml"; + +template< typename T, typename COL_INDEX > +void printCompareLocalMatrices( CRSMatrixView< T const, COL_INDEX const > const & matrix1, + CRSMatrixView< T const, COL_INDEX const > const & matrix2, std::string const & testName ) +{ + std::ofstream omat1( testName+".csv" ); + + + std::vector< std::vector< double > > fmat1( matrix1.numRows(), std::vector< double >( matrix1.numRows(), 0.0 )); + std::vector< std::vector< double > > fmat2( matrix2.numRows(), std::vector< double >( matrix2.numRows(), 0.0 )); + + for( localIndex i = 0; i < matrix1.numRows(); ++i ) + { + arraySlice1d< globalIndex const > indices1 = matrix1.getColumns( i ); + arraySlice1d< globalIndex const > indices2 = matrix2.getColumns( i ); + arraySlice1d< double const > values1 = matrix1.getEntries( i ); + arraySlice1d< double const > values2 = matrix2.getEntries( i ); + for( integer j=0; j const & rsd1, + array1d< real64 > const & rsd2, std::string const & testName ) +{ + std::ofstream omat1( testName+".csv" ); + + for( integer i=0; i +void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< CompositionalMultiphaseBase > & solver, + DomainPartition & domain, + real64 const perturbParameter, + real64 const time_n, + real64 const relTol, std::string const & testName, + LAMBDA && assembleFunction ) +{ + GEOS_UNUSED_VAR( time_n ); + GEOS_UNUSED_VAR ( testName ); + CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); + + CompositionalMultiphaseFVM & flowSolver = dynamicCast< CompositionalMultiphaseFVM & >( *solver.reservoirSolver() ); + + localIndex const NC = flowSolver.numFluidComponents(); + + CRSMatrix< real64, globalIndex > const & jacobian = solver.getLocalMatrix(); + array1d< real64 > residual( jacobian.numRows() ); + DofManager const & dofManager = solver.getDofManager(); + // assemble the analytical residual + solver.resetStateToBeginningOfStep( domain ); + string const resDofKey = dofManager.getKey( wellSolver.resElementDofName() ); + string const wellDofKey = dofManager.getKey( wellSolver.wellElementDofName() ); + residual.zero(); + jacobian.zero(); + + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + residual.move( hostMemorySpace, false ); + + // copy the analytical residual + array1d< real64 > residualOrig( residual ); + + // create the numerical jacobian + jacobian.move( hostMemorySpace ); + CRSMatrix< real64, globalIndex > jacobianFD( jacobian ); + jacobianFD.zero(); + //////////////////////////////////////////////// + // Step 1) Compute the terms in J_RR and J_WR // + //////////////////////////////////////////////// +#if 1 + domain.forMeshBodies( [&] ( MeshBody & meshBody ) + { + MeshLevel & mesh = meshBody.getBaseDiscretization(); + + ElementRegionManager & elemManager = mesh.getElemManager(); + for( localIndex er = 0; er < elemManager.numRegions(); ++er ) + { + ElementRegionBase & elemRegion = elemManager.getRegion( er ); + elemRegion.forElementSubRegionsIndex< CellElementSubRegion >( [&]( localIndex const, CellElementSubRegion & subRegion ) + { + // get the degrees of freedom and ghosting information + arrayView1d< globalIndex const > const & dofNumber = + subRegion.getReference< array1d< globalIndex > >( resDofKey ); + + // get the primary variables on the reservoir elements + arrayView1d< real64 > const & pres = + subRegion.getField< fields::flow::pressure >(); + pres.move( hostMemorySpace, false ); + + arrayView1d< real64 > const & temperature = + subRegion.getField< fields::flow::temperature >(); + temperature.move( hostMemorySpace, false ); + + arrayView2d< real64, compflow::USD_COMP > const & compDens = + subRegion.getField< fields::flow::globalCompDensity >(); + compDens.move( hostMemorySpace, false ); + + // a) compute all the derivatives wrt to the pressure in RESERVOIR elem ei + for( localIndex ei = 0; ei < subRegion.size(); ++ei ) + { + + + { + solver.resetStateToBeginningOfStep( domain ); + + // here is the perturbation in the pressure of the element + real64 const dP = perturbParameter * (pres[ei] + perturbParameter); + pres.move( hostMemorySpace, true ); + pres[ei] += dP; + + // after perturbing, update the pressure-dependent quantities in the reservoir + flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh2, + string_array const & regionNames2 ) + { + mesh2.getElemManager().forElementSubRegions( regionNames2, + [&]( localIndex const, + ElementSubRegionBase & subRegion2 ) + { + flowSolver.updateFluidState( subRegion2 ); + } ); + } ); + + wellSolver.updateState( domain ); + + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + fillNumericalJacobian ( residual.toViewConst(), + residualOrig.toViewConst(), + dofNumber[ei], + dP, + jacobianFD.toViewConstSizes() ); + } +#if 1 + { + solver.resetStateToBeginningOfStep( domain ); + + // here is the perturbation in the temperature of the element + real64 const dT = 1; //perturbParameter * (temperature[ei] + perturbParameter); + temperature.move( hostMemorySpace, true ); + temperature[ei] += dT; + + // after perturbing, update the temperature-dependent quantities in the reservoir + flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh2, + string_array const & regionNames2 ) + { + mesh2.getElemManager().forElementSubRegions( regionNames2, + [&]( localIndex const, + ElementSubRegionBase & subRegion2 ) + { + flowSolver.updateFluidState( subRegion2 ); + } ); + } ); + + wellSolver.updateState( domain ); + + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + dofNumber[ei]+NC+1, + dT, + jacobianFD.toViewConstSizes() ); + } +#endif +#if 1 + real64 totalDensity = 0.0; + for( localIndex ic = 0; ic < NC; ++ic ) + { + totalDensity += compDens[ei][ic]; + } + + for( localIndex jc = 0; jc < NC; ++jc ) + { + solver.resetStateToBeginningOfStep( domain ); + + real64 const dRho = perturbParameter * totalDensity; + compDens.move( hostMemorySpace, true ); + compDens[ei][jc] += dRho; + + flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh2, + string_array const & regionNames2 ) + { + mesh2.getElemManager().forElementSubRegions( regionNames2, + [&]( localIndex const, + ElementSubRegionBase & subRegion2 ) + { + flowSolver.updateFluidState( subRegion2 ); + } ); + } ); + + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + dofNumber[ei] + jc + 1, + dRho, + jacobianFD.toViewConstSizes() ); + } +#endif + } + + return; + } ); + } + + } ); + +#endif + // at this point we start assembling the finite-difference block by block + + + ///////////////////////////////////////////////// + // Step 2) Compute the terms in J_RW and J_WW // + ///////////////////////////////////////////////// + + // loop over the wells + if( 1 ) + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + mesh.getElemManager().forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + // get the degrees of freedom, ghosting info and next well elem index + arrayView1d< globalIndex const > const & wellElemDofNumber = + subRegion.getReference< array1d< globalIndex > >( wellDofKey ); + + // get the primary variables on the well elements + arrayView1d< real64 > const & wellElemPressure = + subRegion.getField< fields::well::pressure >(); + wellElemPressure.move( hostMemorySpace, false ); + + arrayView1d< real64 > const & wellElemTemperature = + subRegion.getField< fields::well::temperature >(); + wellElemTemperature.move( hostMemorySpace, false ); + + arrayView2d< real64, compflow::USD_COMP > const & wellElemCompDens = + subRegion.getField< fields::well::globalCompDensity >(); + wellElemCompDens.move( hostMemorySpace, false ); + + arrayView1d< real64 > const & connRate = + subRegion.getField< fields::well::mixtureConnectionRate >(); + connRate.move( hostMemorySpace, false ); + + // a) compute all the derivatives wrt to the pressure in WELL elem iwelem + for( localIndex iwelem = 0; iwelem < subRegion.size(); ++iwelem ) + { + +#if 1 + { + solver.resetStateToBeginningOfStep( domain ); + + // here is the perturbation in the pressure of the well element + real64 const dP = perturbParameter * ( wellElemPressure[iwelem] + perturbParameter ); + wellElemPressure.move( hostMemorySpace, true ); + wellElemPressure[iwelem] += dP; + + // after perturbing, update the pressure-dependent quantities in the well + wellSolver.updateState( domain ); + + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + wellElemDofNumber[iwelem] + compositionalMultiphaseWellKernels::ColOffset::DPRES, + dP, + jacobianFD.toViewConstSizes() ); + } +#endif +#if 1 + real64 wellElemTotalDensity = 0.0; + for( localIndex ic = 0; ic < NC; ++ic ) + { + wellElemTotalDensity += wellElemCompDens[iwelem][ic]; + } + for( localIndex jc = 0; jc < NC; ++jc ) + { + solver.resetStateToBeginningOfStep( domain ); + + real64 const dRho = perturbParameter * wellElemTotalDensity; + wellElemCompDens.move( hostMemorySpace, true ); + wellElemCompDens[iwelem][jc] += dRho; + + wellSolver.updateState( domain ); + + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + wellElemDofNumber[iwelem] + compositionalMultiphaseWellKernels::ColOffset::DCOMP + jc, + dRho, + jacobianFD.toViewConstSizes() ); + } + { + solver.resetStateToBeginningOfStep( domain ); + residual.zero(); + jacobian.zero(); + // here is the perturbation in the temperature of the well element + real64 const dT = 1.0; + wellElemTemperature.move( hostMemorySpace, true ); + wellElemTemperature[iwelem] += dT; + + // after perturbing, update the pressure-dependent quantities in the well + wellSolver.updateState( domain ); + + + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + wellElemDofNumber[iwelem] + compositionalMultiphaseWellKernels::ColOffset::DCOMP + NC+1, + dT, + jacobianFD.toViewConstSizes() ); + + } +#endif + } + +#if 1 + // b) compute all the derivatives wrt to the connection in WELL elem + // iwelem + for( localIndex iwelem = 0; iwelem < subRegion.size(); ++iwelem ) + { + { + solver.resetStateToBeginningOfStep( domain ); + + // here is the perturbation in the rate of the well element + real64 const dRate = perturbParameter * ( connRate[iwelem] + perturbParameter ); + connRate.move( hostMemorySpace, true ); + connRate[iwelem] += dRate; + + wellSolver.updateState( domain ); + + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + wellElemDofNumber[iwelem] + compositionalMultiphaseWellKernels::ColOffset::DCOMP + NC, + dRate, + jacobianFD.toViewConstSizes() ); + } + } +#endif + } ); + } ); + + // assemble the analytical jacobian + solver.resetStateToBeginningOfStep( domain ); + + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + //printCompareLocalMatrices( jacobian.toViewConst(), jacobianFD.toViewConst(), testName ); + compareLocalMatrices( jacobian.toViewConst(), jacobianFD.toViewConst(), relTol ); +} + +class CompositionalMultiphaseReservoirSolverTest : public ::testing::Test +{ +public: + + CompositionalMultiphaseReservoirSolverTest(): + state( std::make_unique< CommandLineOptions >( g_commandLineOptions ) ) + {} + +protected: + + void SetUp() override + { + setupProblemFromXML( state.getProblemManager(), xmlInput ); + solver = &state.getProblemManager().getPhysicsSolverManager().getGroup< CompositionalMultiphaseReservoirAndWells<> >( "reservoirSystem" ); + + DomainPartition & domain = state.getProblemManager().getDomainPartition(); + + solver->setupSystem( domain, + solver->getDofManager(), + solver->getLocalMatrix(), + solver->getSystemRhs(), + solver->getSystemSolution() ); + + solver->implicitStepSetup( time, dt, domain ); + } + static real64 constexpr time = 0.0; + static real64 constexpr dt = 1e4; + static real64 constexpr eps = std::numeric_limits< real64 >::epsilon(); + + GeosxState state; + CompositionalMultiphaseReservoirAndWells< CompositionalMultiphaseBase > * solver; +}; + +real64 constexpr CompositionalMultiphaseReservoirSolverTest::time; +real64 constexpr CompositionalMultiphaseReservoirSolverTest::dt; +real64 constexpr CompositionalMultiphaseReservoirSolverTest::eps; + +#if 0 +TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_FullSystem ) +{ + real64 const perturb = std::sqrt( eps ); + real64 const tol = 1e-1; // 10% error margin + + DomainPartition & domain = state.getProblemManager().getDomainPartition(); + + testWellEstimatorNumericalJacobian( *solver, domain, perturb, time, tol, "Check_FullSystem", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + solver->assembleSystem( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + solver->assembleCouplingTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + } ); +} +#endif + +#if 1 +TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_System ) +{ + real64 const perturb = std::sqrt( eps ); + real64 const tol = 1e-1; // 10% error margin + + DomainPartition & domain = state.getProblemManager().getDomainPartition(); + + testWellNumericalJacobian( *solver, domain, perturb, time, tol, "Check_System", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + + solver->wellSolver()->assembleSystem( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + solver->assembleCouplingTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + + } ); +} +#endif +TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Accum ) +{ + real64 const perturb = std::sqrt( eps ); + real64 const tol = 1e-1; // 10% error margin + + DomainPartition & domain = state.getProblemManager().getDomainPartition(); + + testWellNumericalJacobian( *solver, domain, perturb, time, tol, "Check_Accum", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + solver->wellSolver()->assembleAccumulationTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + } ); +} +#if 1 +TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_PressureRelation ) +{ + real64 const tol = 1e-1; // 10% error margin + real64 const perturb = std::sqrt( eps ); + + DomainPartition & domain = state.getProblemManager().getDomainPartition(); + + testWellNumericalJacobian( *solver, domain, perturb, time, tol, "Check_PressureRelation", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + solver->wellSolver()->assemblePressureRelations( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + } ); +} +#endif +#if 1 +TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Flux ) +{ + real64 const perturb = std::sqrt( eps ); + real64 const tol = 1e-1; // 10% error margin + + DomainPartition & domain = state.getProblemManager().getDomainPartition(); + + testWellNumericalJacobian( *solver, domain, perturb, time, tol, "Check_Flux", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + solver->wellSolver()->assembleFluxTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + } ); +} +#endif +int main( int argc, char * * argv ) +{ + writeTableToFile( "co2flash.txt", co2flash ); + writeTableToFile( "pvtliquid.txt", pvtLiquid ); + writeTableToFile( "pvtgas.txt", pvtGas ); + ::testing::InitGoogleTest( &argc, argv ); + g_commandLineOptions = *geos::basicSetup( argc, argv ); + int const result = RUN_ALL_TESTS(); + geos::basicCleanup(); + removeFile( "co2flash.txt" ); + removeFile( "pvtliquid.txt" ); + removeFile( "pvtgas.txt" ); + + return result; +} diff --git a/src/coreComponents/integrationTests/wellsTests/testThermalReservoirCompositionalMultiphaseMSWells.cpp b/src/coreComponents/integrationTests/wellsTests/testThermalReservoirCompositionalMultiphaseMSWells.cpp index 98aa57a5c84..269b4e6fdeb 100644 --- a/src/coreComponents/integrationTests/wellsTests/testThermalReservoirCompositionalMultiphaseMSWells.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testThermalReservoirCompositionalMultiphaseMSWells.cpp @@ -86,7 +86,7 @@ char const * xmlInput = logLevel="4" discretization="fluidTPFA" temperature="368.15" - useMass="1" + useMass="0" isThermal="1" initialDt="1e4" targetRelativePressureChangeInTimeStep="1" @@ -102,7 +102,7 @@ char const * xmlInput = isThermal="1" logLevel="1" initialDt="1e4" - useMass="1"> + useMass="0"> )xml"; +template< typename T, typename COL_INDEX > +void printCompareLocalMatrices( CRSMatrixView< T const, COL_INDEX const > const & matrix1, + CRSMatrixView< T const, COL_INDEX const > const & matrix2, std::string const & testName ) +{ + std::ofstream omat1( testName+".csv" ); + + + std::vector< std::vector< double > > fmat1( matrix1.numRows(), std::vector< double >( matrix1.numRows(), 0.0 )); + std::vector< std::vector< double > > fmat2( matrix2.numRows(), std::vector< double >( matrix2.numRows(), 0.0 )); + + for( localIndex i = 0; i < matrix1.numRows(); ++i ) + { + arraySlice1d< globalIndex const > indices1 = matrix1.getColumns( i ); + arraySlice1d< globalIndex const > indices2 = matrix2.getColumns( i ); + arraySlice1d< double const > values1 = matrix1.getEntries( i ); + arraySlice1d< double const > values2 = matrix2.getEntries( i ); + for( integer j=0; j void testNumericalJacobian( CompositionalMultiphaseReservoirAndWells< CompositionalMultiphaseBase > & solver, DomainPartition & domain, real64 const perturbParameter, - real64 const relTol, bool diag_check, + real64 const relTol, bool diag_check, std::string const & testName, LAMBDA && assembleFunction ) { + GEOS_UNUSED_VAR( testName ); CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); CompositionalMultiphaseFVM & flowSolver = dynamicCast< CompositionalMultiphaseFVM & >( *solver.reservoirSolver() ); @@ -362,148 +409,151 @@ void testNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compositio //////////////////////////////////////////////// // Step 1) Compute the terms in J_RR and J_WR // //////////////////////////////////////////////// - if( 1 ) - domain.forMeshBodies( [&] ( MeshBody & meshBody ) + + bool processMesh = true; + domain.forMeshBodies( [&] ( MeshBody & meshBody ) + { + meshBody.forMeshLevels( [&] ( MeshLevel & mesh ) { - meshBody.forMeshLevels( [&] ( MeshLevel & mesh ) + if( !processMesh ) + return; + processMesh = false; + ElementRegionManager & elemManager = mesh.getElemManager(); + for( localIndex er = 0; er < elemManager.numRegions(); ++er ) { - ElementRegionManager & elemManager = mesh.getElemManager(); - for( localIndex er = 0; er < elemManager.numRegions(); ++er ) + ElementRegionBase & elemRegion = elemManager.getRegion( er ); + elemRegion.forElementSubRegionsIndex< CellElementSubRegion >( [&]( localIndex const, CellElementSubRegion & subRegion ) { - ElementRegionBase & elemRegion = elemManager.getRegion( er ); - elemRegion.forElementSubRegionsIndex< CellElementSubRegion >( [&]( localIndex const, CellElementSubRegion & subRegion ) - { - // get the degrees of freedom and ghosting information - arrayView1d< globalIndex const > const & dofNumber = - subRegion.getReference< array1d< globalIndex > >( resDofKey ); + // get the degrees of freedom and ghosting information + arrayView1d< globalIndex const > const & dofNumber = + subRegion.getReference< array1d< globalIndex > >( resDofKey ); - // get the primary variables on the reservoir elements - arrayView1d< real64 > const & pres = - subRegion.getField< fields::flow::pressure >(); - pres.move( hostMemorySpace, false ); + // get the primary variables on the reservoir elements + arrayView1d< real64 > const & pres = + subRegion.getField< fields::flow::pressure >(); + pres.move( hostMemorySpace, false ); - arrayView2d< real64, compflow::USD_COMP > const & compDens = - subRegion.getField< fields::flow::globalCompDensity >(); - compDens.move( hostMemorySpace, false ); + arrayView2d< real64, compflow::USD_COMP > const & compDens = + subRegion.getField< fields::flow::globalCompDensity >(); + compDens.move( hostMemorySpace, false ); - arrayView1d< real64 > const & temp = - subRegion.getField< fields::flow::temperature >(); - temp.move( hostMemorySpace, false ); + arrayView1d< real64 > const & temp = + subRegion.getField< fields::flow::temperature >(); + temp.move( hostMemorySpace, false ); + + // a) compute all the derivatives wrt to the pressure in RESERVOIR elem ei + for( localIndex ei = 0; ei < subRegion.size(); ++ei ) + { - // a) compute all the derivatives wrt to the pressure in RESERVOIR elem ei - for( localIndex ei = 0; ei < subRegion.size(); ++ei ) + real64 totalDensity = 0.0; + for( localIndex ic = 0; ic < NC; ++ic ) { - if( ei !=0 ) - break; - real64 totalDensity = 0.0; - for( localIndex ic = 0; ic < NC; ++ic ) - { - totalDensity += compDens[ei][ic]; - } + totalDensity += compDens[ei][ic]; + } - { - solver.resetStateToBeginningOfStep( domain ); + { + solver.resetStateToBeginningOfStep( domain ); - // here is the perturbation in the pressure of the element - real64 const dP = perturbParameter * (pres[ei] + perturbParameter); - pres.move( hostMemorySpace, true ); - pres[ei] += dP; + // here is the perturbation in the pressure of the element + real64 const dP = perturbParameter * (pres[ei] + perturbParameter); + pres.move( hostMemorySpace, true ); + pres[ei] += dP; - // after perturbing, update the pressure-dependent quantities in the reservoir - flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh2, - string_array const & regionNames2 ) + // after perturbing, update the pressure-dependent quantities in the reservoir + flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh2, + string_array const & regionNames2 ) + { + mesh2.getElemManager().forElementSubRegions( regionNames2, + [&]( localIndex const, + ElementSubRegionBase & subRegion2 ) { - mesh2.getElemManager().forElementSubRegions( regionNames2, - [&]( localIndex const, - ElementSubRegionBase & subRegion2 ) - { - flowSolver.updateFluidState( subRegion2 ); - } ); + flowSolver.updateFluidState( subRegion2 ); } ); + } ); - wellSolver.updateState( domain ); + wellSolver.updateState( domain ); - residual.zero(); - jacobian.zero(); - assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); - fillNumericalJacobian( residual.toViewConst(), - residualOrig.toViewConst(), - dofNumber[ei], - dP, - jacobianFD.toViewConstSizes() ); - } + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + dofNumber[ei], + dP, + jacobianFD.toViewConstSizes() ); + } - for( localIndex jc = 0; jc < NC; ++jc ) - { - solver.resetStateToBeginningOfStep( domain ); + for( localIndex jc = 0; jc < NC; ++jc ) + { + solver.resetStateToBeginningOfStep( domain ); - real64 const dRho = perturbParameter * totalDensity; - compDens.move( hostMemorySpace, true ); - compDens[ei][jc] += dRho; + real64 const dRho = perturbParameter * totalDensity; + compDens.move( hostMemorySpace, true ); + compDens[ei][jc] += dRho; - flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh2, - string_array const & regionNames2 ) + flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh2, + string_array const & regionNames2 ) + { + mesh2.getElemManager().forElementSubRegions( regionNames2, + [&]( localIndex const, + ElementSubRegionBase & subRegion2 ) { - mesh2.getElemManager().forElementSubRegions( regionNames2, - [&]( localIndex const, - ElementSubRegionBase & subRegion2 ) - { - flowSolver.updateFluidState( subRegion2 ); - } ); + flowSolver.updateFluidState( subRegion2 ); } ); - wellSolver.updateState( domain ); - residual.zero(); - jacobian.zero(); - assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); - - fillNumericalJacobian( residual.toViewConst(), - residualOrig.toViewConst(), - dofNumber[ei] + jc + 1, - dRho, - jacobianFD.toViewConstSizes() ); - } - { - solver.resetStateToBeginningOfStep( domain ); + } ); + wellSolver.updateState( domain ); + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + dofNumber[ei] + jc + 1, + dRho, + jacobianFD.toViewConstSizes() ); + } + { + solver.resetStateToBeginningOfStep( domain ); - // here is the perturbation in the pressure of the element - real64 const dTemp = perturbParameter * (temp[ei] + perturbParameter); - temp.move( hostMemorySpace, true ); - temp[ei] += dTemp; + // here is the perturbation in the pressure of the element + real64 const dTemp = perturbParameter * (temp[ei] + perturbParameter); + temp.move( hostMemorySpace, true ); + temp[ei] += dTemp; - // after perturbing, update the pressure-dependent quantities in the reservoir - flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh2, - string_array const & regionNames2 ) + // after perturbing, update the pressure-dependent quantities in the reservoir + flowSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh2, + string_array const & regionNames2 ) + { + mesh2.getElemManager().forElementSubRegions( regionNames2, + [&]( localIndex const, + ElementSubRegionBase & subRegion2 ) { - mesh2.getElemManager().forElementSubRegions( regionNames2, - [&]( localIndex const, - ElementSubRegionBase & subRegion2 ) - { - flowSolver.updateFluidState( subRegion2 ); - } ); + flowSolver.updateFluidState( subRegion2 ); } ); + } ); - wellSolver.updateState( domain ); + wellSolver.updateState( domain ); - residual.zero(); - jacobian.zero(); - assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); + residual.zero(); + jacobian.zero(); + assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); - fillNumericalJacobian( residual.toViewConst(), - residualOrig.toViewConst(), - dofNumber[ei]+NC+1, - dTemp, - jacobianFD.toViewConstSizes() ); - } + fillNumericalJacobian( residual.toViewConst(), + residualOrig.toViewConst(), + dofNumber[ei]+NC+1, + dTemp, + jacobianFD.toViewConstSizes() ); } - } ); - } - } ); - return; + } + } ); + } } ); + return; + } ); ///////////////////////////////////////////////// // Step 2) Compute the terms in J_RW and J_WW // @@ -564,7 +614,6 @@ void testNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compositio residual.zero(); jacobian.zero(); assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); - fillNumericalJacobian( residual.toViewConst(), residualOrig.toViewConst(), wellElemDofNumber[iwelem] + compositionalMultiphaseWellKernels::ColOffset::DPRES, @@ -671,7 +720,7 @@ void testNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compositio residual.zero(); jacobian.zero(); assembleFunction( jacobian.toViewConstSizes(), residual.toView() ); - //printCompareLocalMatrices( jacobian.toViewConst(), jacobianFD.toViewConst()); + //printCompareLocalMatrices( jacobian.toViewConst(), jacobianFD.toViewConst(),testName); compareLocalMatrices( jacobian.toViewConst(), jacobianFD.toViewConst(), relTol ); } @@ -714,7 +763,9 @@ real64 constexpr CompositionalMultiphaseReservoirSolverTest::dt; real64 constexpr CompositionalMultiphaseReservoirSolverTest::eps; #if 0 - +// There are a few terms that cause this test to fail, these are dt terms of cell connected to cell with boundary condtion. +// The could be zeroed out in the jacobian assembly and then this test should pass. +// Otherwise the test is good, uncomment out printCompareLocalMatrices and look at FD and computed derivatives TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Perforation ) { real64 const perturb = std::sqrt( eps ); @@ -722,55 +773,19 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Perfo DomainPartition & domain = state.getProblemManager().getDomainPartition(); - testNumericalJacobian( *solver, domain, perturb, tol, + testNumericalJacobian( *solver, domain, perturb, tol, false, "Check_Perforation", [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { + solver->wellSolver()->assembleSystem( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); solver->assembleCouplingTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); - //solver->assembleSystem( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); - } ); -} - -#endif - -#if 0 -TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Flux ) -{ - real64 const perturb = std::sqrt( eps ); - real64 const tol = 1e-1; // 10% error margin - DomainPartition & domain = state.getProblemManager().getDomainPartition(); - - testNumericalJacobian( *solver, domain, perturb, tol, false, - [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) - { - solver->wellSolver()->assembleSystem( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); - //solver->assembleSystem( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); - //solver->assembleCouplingTerms( time,dt, domain, solver->getDofManager(), localMatrix, localRhs ); } ); } #endif -#if 0 -TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_flux ) -{ - real64 const perturb = std::sqrt( eps ); - real64 const tol = 1e-1; // 10% error margin - - DomainPartition & domain = state.getProblemManager().getDomainPartition(); - testNumericalJacobian( *solver, domain, perturb, tol, true, - [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) - { - solver->wellSolver()->computePerforationRates( time, dt, domain ); - solver->wellSolver()->assembleFluxTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); - solver->assembleCouplingTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); - } ); -} -#endif #if 1 TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Accum_Vol_Energy_Bal ) @@ -780,7 +795,7 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Accum DomainPartition & domain = state.getProblemManager().getDomainPartition(); - testNumericalJacobian( *solver, domain, perturb, tol, false, + testNumericalJacobian( *solver, domain, perturb, tol, false, "Check_Accum_Vol_Energy_Bal", [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { @@ -794,7 +809,8 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Press DomainPartition & domain = state.getProblemManager().getDomainPartition(); - testNumericalJacobian( *solver, domain, perturb, tol, true, + + testNumericalJacobian( *solver, domain, perturb, tol, true, "Check_PressureRel", [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/PerforationFluxKernels.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/PerforationFluxKernels.hpp index 18a48ee1e63..bcdc141a179 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/PerforationFluxKernels.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/PerforationFluxKernels.hpp @@ -137,56 +137,33 @@ class PerforationFluxKernel m_isCrossflowEnabled( isCrossflowEnabled ) {} - template< typename FUNC = NoOpFunc > + /** + * @struct StackVariables + * @brief Kernel variables ) located on the stack + */ + struct StackVariables + { +public: + + real64 m_potDiff; + real64 m_dPotDiff[2][constitutive::multifluid::DerivativeOffsetC< NC, IS_THERMAL >::nDer]; + + }; + + GEOS_HOST_DEVICE inline - void - computeFlux( localIndex const iperf, FUNC && fluxKernelOp= NoOpFunc {} ) const + void initialize( localIndex const iperf, StackVariables & stack ) const { using CP_Deriv = constitutive::multifluid::DerivativeOffsetC< NC, IS_THERMAL >; - - if( !m_perfStatus[iperf] ) + stack.m_potDiff = 0.0; + for( integer i = 0; i < 2; ++i ) { - for( integer ic = 0; ic < NC; ++ic ) + for( integer ic = 0; ic < CP_Deriv::nDer; ++ic ) { - m_compPerfRate[iperf][ic] = 0.0; - for( integer ke = 0; ke < 2; ++ke ) - { - for( integer jc = 0; jc < CP_Deriv::nDer; ++jc ) - { - m_dCompPerfRate[iperf][ke][ic][jc] = 0.0; - } - } + stack.m_dPotDiff[i][ic] = 0.0; } - return; } - // get the index of the reservoir elem - localIndex const er = m_resElementRegion[iperf]; - localIndex const esr = m_resElementSubRegion[iperf]; - localIndex const ei = m_resElementIndex[iperf]; - - // get the index of the well elem - localIndex const iwelem = m_perfWellElemIndex[iperf]; - - using Deriv = constitutive::multifluid::DerivativeOffset; - - - // local working variables and arrays - real64 pres[2]{}; - real64 multiplier[2]{}; - - // local working variables - compact - // All derivative quantiites generated are stored in arrays using CP_Deriv offsets - // The input well/reservoir quantites use the Deriv offsets - // The arrays using the deriv offsets have extra column for dT in isothermal cases - - real64 dPres[2][CP_Deriv::nDer]{}; - real64 dFlux[2][CP_Deriv::nDer]{}; - real64 dMob[CP_Deriv::nDer]{}; - real64 dPotDiff[2][CP_Deriv::nDer]{}; - real64 dCompFrac[CP_Deriv::nDer]{}; - - // Step 1: reset the perforation rates for( integer ic = 0; ic < NC; ++ic ) { m_compPerfRate[iperf][ic] = 0.0; @@ -198,11 +175,20 @@ class PerforationFluxKernel } } } + } + GEOS_HOST_DEVICE + inline + void computePotentialandDeriv( localIndex const iperf, localIndex const er, localIndex const esr, localIndex const ei, localIndex const iwelem, StackVariables & stack ) const + { + using CP_Deriv = constitutive::multifluid::DerivativeOffsetC< NC, IS_THERMAL >; + using Deriv = constitutive::multifluid::DerivativeOffset; + real64 dPres[2][CP_Deriv::nDer]{}; - // Step 2: copy the variables from the reservoir and well element + // local working variables and arrays + real64 pres[2]{}; + real64 multiplier[2]{}; // a) get reservoir variables - pres[TAG::RES] = m_resPres[er][esr][ei]; dPres[TAG::RES][CP_Deriv::dP] = 1.0; multiplier[TAG::RES] = 1.0; @@ -210,9 +196,7 @@ class PerforationFluxKernel // Here in the absence of a buoyancy term we assume that the reservoir cell is perforated at its center // TODO: add a buoyancy term for the reservoir side here - // b) get well variables - pres[TAG::WELL] = m_wellElemPres[iwelem]; dPres[TAG::WELL][CP_Deriv::dP] = 1.0; multiplier[TAG::WELL] = -1.0; @@ -231,22 +215,162 @@ class PerforationFluxKernel dPres[TAG::WELL][CP_Deriv::dC+ic] += m_dWellElemTotalMassDens[iwelem][Deriv::dC+ic] * gravD; } - // Step 3: compute potential difference - - real64 potDiff = 0.0; + // compute potential difference + stack.m_potDiff = 0.0; for( integer i = 0; i < 2; ++i ) { - potDiff += multiplier[i] * m_perfTrans[iperf] * pres[i]; + stack.m_potDiff += multiplier[i] * m_perfTrans[iperf] * pres[i]; // LHS & RHS both use CP_Deriv for( integer ic = 0; ic < CP_Deriv::nDer; ++ic ) { - dPotDiff[i][ic] += multiplier[i] * m_perfTrans[iperf] * dPres[i][ic]; + stack.m_dPotDiff[i][ic] += multiplier[i] * m_perfTrans[iperf] * dPres[i][ic]; } } - // Step 4: upwinding based on the flow direction + } + GEOS_HOST_DEVICE + inline + void computeMobilityandDeriv( localIndex const ip, localIndex const er, localIndex const esr, localIndex const ei, + real64 & mob, real64 (& dMob)[constitutive::multifluid::DerivativeOffsetC< NC, IS_THERMAL >::nDer] ) const + { + using CP_Deriv = constitutive::multifluid::DerivativeOffsetC< NC, IS_THERMAL >; + using Deriv = constitutive::multifluid::DerivativeOffset; + + + // viscosity + real64 const resVisc = m_resPhaseVisc[er][esr][ei][0][ip]; + real64 dVisc[CP_Deriv::nDer]{}; + dVisc[CP_Deriv::dP] = m_dResPhaseVisc[er][esr][ei][0][ip][Deriv::dP]; + if constexpr ( IS_THERMAL ) + { + dVisc[CP_Deriv::dT] = m_dResPhaseVisc[er][esr][ei][0][ip][Deriv::dT]; + } + + applyChainRule( NC, m_dResCompFrac_dCompDens[er][esr][ei], + m_dResPhaseVisc[er][esr][ei][0][ip], + &dVisc[CP_Deriv::dC], + Deriv::dC ); + + // relative permeability + real64 const resRelPerm = m_resPhaseRelPerm[er][esr][ei][0][ip]; + real64 dRelPerm[CP_Deriv::nDer]{}; + for( integer jp = 0; jp < NP; ++jp ) + { + real64 const dResRelPerm_dS = m_dResPhaseRelPerm_dPhaseVolFrac[er][esr][ei][0][ip][jp]; + dRelPerm[CP_Deriv::dP] += dResRelPerm_dS * m_dResPhaseVolFrac[er][esr][ei][jp][Deriv::dP]; + if constexpr ( IS_THERMAL ) + { + dRelPerm[CP_Deriv::dT] += dResRelPerm_dS * m_dResPhaseVolFrac[er][esr][ei][jp][Deriv::dT]; + } + for( integer jc = 0; jc < NC; ++jc ) + { + dRelPerm[CP_Deriv::dC+jc] += dResRelPerm_dS * m_dResPhaseVolFrac[er][esr][ei][jp][Deriv::dC+jc]; + } + } + // compute mobility kr/mu + mob += resRelPerm / resVisc; + for( integer jc = 0; jc < CP_Deriv::nDer; ++jc ) + { + dMob[jc] += (dRelPerm[jc] *resVisc - resRelPerm * dVisc[jc] ) + / ( resVisc * resVisc); + } + } + + GEOS_HOST_DEVICE + inline + void computeDensityMobilityandDeriv( localIndex const ip, localIndex const er, localIndex const esr, localIndex const ei, + + real64 & mob, real64 (& dMob)[constitutive::multifluid::DerivativeOffsetC< NC, IS_THERMAL >::nDer] ) const + { + using CP_Deriv = constitutive::multifluid::DerivativeOffsetC< NC, IS_THERMAL >; + using Deriv = constitutive::multifluid::DerivativeOffset; + + // density + real64 const resDens = m_resPhaseDens[er][esr][ei][0][ip]; + real64 dDens[CP_Deriv::nDer]{}; + + dDens[CP_Deriv::dP] = m_dResPhaseDens[er][esr][ei][0][ip][Deriv::dP]; + if constexpr ( IS_THERMAL ) + { + dDens[CP_Deriv::dT] = m_dResPhaseDens[er][esr][ei][0][ip][Deriv::dT]; + } + applyChainRule( NC, m_dResCompFrac_dCompDens[er][esr][ei], + m_dResPhaseDens[er][esr][ei][0][ip], + &dDens[CP_Deriv::dC], + Deriv::dC ); + + // viscosity + real64 const resVisc = m_resPhaseVisc[er][esr][ei][0][ip]; + real64 dVisc[CP_Deriv::nDer]{}; + dVisc[CP_Deriv::dP] = m_dResPhaseVisc[er][esr][ei][0][ip][Deriv::dP]; + if constexpr ( IS_THERMAL ) + { + dVisc[CP_Deriv::dT] = m_dResPhaseVisc[er][esr][ei][0][ip][Deriv::dT]; + } + + applyChainRule( NC, m_dResCompFrac_dCompDens[er][esr][ei], + m_dResPhaseVisc[er][esr][ei][0][ip], + &dVisc[CP_Deriv::dC], + Deriv::dC ); + + // relative permeability + real64 const resRelPerm = m_resPhaseRelPerm[er][esr][ei][0][ip]; + real64 dRelPerm[CP_Deriv::nDer]{}; + for( integer jc = 0; jc < CP_Deriv::nDer; ++jc ) + { + dRelPerm[jc]=0; + } + for( integer jp = 0; jp < NP; ++jp ) + { + real64 const dResRelPerm_dS = m_dResPhaseRelPerm_dPhaseVolFrac[er][esr][ei][0][ip][jp]; + dRelPerm[CP_Deriv::dP] += dResRelPerm_dS * m_dResPhaseVolFrac[er][esr][ei][jp][Deriv::dP]; + if constexpr ( IS_THERMAL ) + { + dRelPerm[CP_Deriv::dT] += dResRelPerm_dS * m_dResPhaseVolFrac[er][esr][ei][jp][Deriv::dT]; + } + for( integer jc = 0; jc < NC; ++jc ) + { + dRelPerm[CP_Deriv::dC+jc] += dResRelPerm_dS * m_dResPhaseVolFrac[er][esr][ei][jp][Deriv::dC+jc]; + } + } + // compute mobility kr/mu + mob = resDens * resRelPerm / resVisc; + for( integer jc = 0; jc < CP_Deriv::nDer; ++jc ) + { + dMob[jc] = dRelPerm[jc] * resDens / resVisc + + mob * (dDens[jc] / resDens - dVisc[jc] / resVisc); + } + } + + template< typename FUNC = NoOpFunc > + GEOS_HOST_DEVICE + inline + void + computeFlux( localIndex const iperf, localIndex const er, localIndex const esr, localIndex const ei, localIndex const iwelem, StackVariables & stack, FUNC && fluxKernelOp= NoOpFunc {} ) const + { + + // perf closed or inactive, return + if( !m_perfStatus[iperf] ) + { + return; + } + + using Deriv = constitutive::multifluid::DerivativeOffset; + using CP_Deriv = constitutive::multifluid::DerivativeOffsetC< NC, IS_THERMAL >; + + // Step 2: compute potential difference and its derivatives + //computePotentialandDeriv( iperf, er, esr, ei, iwelem ); + + // Step 3: compute mobility kr/mu and its derivatives + real64 mob; + real64 dMob[CP_Deriv::nDer]{}; + + //computeDensityMobilityandDeriv( ip, er, esr, ei, mob, dMob, fluxKernelOp ); real64 flux = 0.0; - if( potDiff >= 0 ) // ** reservoir cell is upstream ** + real64 dFlux[2][CP_Deriv::nDer]{}; + real64 dCompFrac[CP_Deriv::nDer]{}; + + if( stack.m_potDiff >= 0 ) // ** well is downstream ** { // loop over phases, compute and upwind phase flux @@ -255,84 +379,27 @@ class PerforationFluxKernel { // skip the rest of the calculation if the phase is absent // or if crossflow is disabled for injectors - bool const phaseExists = (m_resPhaseVolFrac[er][esr][ei][ip] > 0); + real64 const resPhaseVolFrac = m_resPhaseVolFrac[er][esr][ei][ip]; + bool const phaseExists = (resPhaseVolFrac > 0); if( !phaseExists || (m_isInjector && !m_isCrossflowEnabled) ) { continue; } - // here, we have to recompute the reservoir phase mobility (not including density) - - // density - real64 const resDens = m_resPhaseDens[er][esr][ei][0][ip]; - real64 dDens[CP_Deriv::nDer]{}; - - dDens[CP_Deriv::dP] = m_dResPhaseDens[er][esr][ei][0][ip][Deriv::dP]; - if constexpr ( IS_THERMAL ) - { - dDens[CP_Deriv::dT] = m_dResPhaseDens[er][esr][ei][0][ip][Deriv::dT]; - } - applyChainRule( NC, m_dResCompFrac_dCompDens[er][esr][ei], - m_dResPhaseDens[er][esr][ei][0][ip], - &dDens[CP_Deriv::dC], - Deriv::dC ); - // viscosity - real64 const resVisc = m_resPhaseVisc[er][esr][ei][0][ip]; - real64 dVisc[CP_Deriv::nDer]{}; - dVisc[CP_Deriv::dP] = m_dResPhaseVisc[er][esr][ei][0][ip][Deriv::dP]; - if constexpr ( IS_THERMAL ) - { - dVisc[CP_Deriv::dT] = m_dResPhaseVisc[er][esr][ei][0][ip][Deriv::dT]; - } - - applyChainRule( NC, m_dResCompFrac_dCompDens[er][esr][ei], - m_dResPhaseVisc[er][esr][ei][0][ip], - &dVisc[CP_Deriv::dC], - Deriv::dC ); - - // relative permeability - real64 const resRelPerm = m_resPhaseRelPerm[er][esr][ei][0][ip]; - real64 dRelPerm[CP_Deriv::nDer]{}; - for( integer jc = 0; jc < CP_Deriv::nDer; ++jc ) - { - dRelPerm[jc]=0; - } - for( integer jp = 0; jp < NP; ++jp ) - { - real64 const dResRelPerm_dS = m_dResPhaseRelPerm_dPhaseVolFrac[er][esr][ei][0][ip][jp]; - dRelPerm[CP_Deriv::dP] += dResRelPerm_dS * m_dResPhaseVolFrac[er][esr][ei][jp][Deriv::dP]; - if constexpr ( IS_THERMAL ) - { - dRelPerm[CP_Deriv::dT] += dResRelPerm_dS * m_dResPhaseVolFrac[er][esr][ei][jp][Deriv::dT]; - } - for( integer jc = 0; jc < NC; ++jc ) - { - dRelPerm[CP_Deriv::dC+jc] += dResRelPerm_dS * m_dResPhaseVolFrac[er][esr][ei][jp][Deriv::dC+jc]; - } - } - - // compute the reservoir phase mobility, including phase density - real64 const resPhaseMob = resDens * resRelPerm / resVisc; - - // Handles all dependencies - for( integer jc = 0; jc < CP_Deriv::nDer; ++jc ) - { - dMob[jc] = dRelPerm[jc] * resDens / resVisc - + resPhaseMob * (dDens[jc] / resDens - dVisc[jc] / resVisc); - } + computeDensityMobilityandDeriv( ip, er, esr, ei, mob, dMob ); + fluxKernelOp( ip, resPhaseVolFrac, mob, dMob ); // compute the phase flux and derivatives using upstream cell mobility - flux = resPhaseMob * potDiff; + flux = mob * stack.m_potDiff; // Handles all dependencies for( integer jc = 0; jc < CP_Deriv::nDer; ++jc ) { - dFlux[TAG::RES][jc] = dMob[jc] * potDiff + resPhaseMob * dPotDiff[TAG::RES][jc]; - dFlux[TAG::WELL][jc] = resPhaseMob * dPotDiff[TAG::WELL][jc]; + dFlux[TAG::RES][jc] = dMob[jc] * stack.m_potDiff + mob * stack.m_dPotDiff[TAG::RES][jc]; + dFlux[TAG::WELL][jc] = mob * stack.m_dPotDiff[TAG::WELL][jc]; } // increment component fluxes for( integer ic = 0; ic < NC; ++ic ) { - // Note this needs to be uncommented out m_compPerfRate[iperf][ic] += flux * m_resPhaseCompFrac[er][esr][ei][0][ip][ic]; dCompFrac[CP_Deriv::dP] = m_dResPhaseCompFrac[er][esr][ei][0][ip][ic][Deriv::dP]; if constexpr (IS_THERMAL) @@ -353,19 +420,12 @@ class PerforationFluxKernel m_dCompPerfRate[iperf][TAG::WELL][ic][jc] += dFlux[TAG::WELL][jc] * m_resPhaseCompFrac[er][esr][ei][0][ip][ic]; } } - if constexpr ( IS_THERMAL ) - { - fluxKernelOp( iwelem, er, esr, ei, ip, potDiff, flux, dFlux ); - } - } // end resevoir is upstream phase loop - } else // ** well is upstream ** { - real64 resTotalMob = 0.0; - + real64 dResTotalMob[CP_Deriv::nDer]{}; // we re-compute here the total mass (when useMass == 1) or molar (when useMass == 0) density real64 wellElemTotalDens = 0; for( integer ic = 0; ic < NC; ++ic ) @@ -376,7 +436,6 @@ class PerforationFluxKernel // first, compute the reservoir total mobility (excluding phase density) for( integer ip = 0; ip < NP; ++ip ) { - // skip the rest of the calculation if the phase is absent // or if crossflow is disabled for non-injectors aka producers bool const phaseExists = (m_resPhaseVolFrac[er][esr][ei][ip] > 0); @@ -384,50 +443,7 @@ class PerforationFluxKernel { continue; } - - // viscosity - real64 const resVisc = m_resPhaseVisc[er][esr][ei][0][ip]; - real64 dVisc[CP_Deriv::nDer]{}; - dVisc[CP_Deriv::dP] = m_dResPhaseVisc[er][esr][ei][0][ip][Deriv::dP]; - if constexpr ( IS_THERMAL ) - { - dVisc[CP_Deriv::dT] = m_dResPhaseVisc[er][esr][ei][0][ip][Deriv::dT]; - } - - applyChainRule( NC, m_dResCompFrac_dCompDens[er][esr][ei], - m_dResPhaseVisc[er][esr][ei][0][ip], - &dVisc[CP_Deriv::dC], - Deriv::dC ); - - - // relative permeability - real64 const resRelPerm = m_resPhaseRelPerm[er][esr][ei][0][ip]; - real64 dRelPerm[CP_Deriv::nDer]{}; - for( integer jc = 0; jc < CP_Deriv::nDer; ++jc ) - { - dRelPerm[jc]=0; - } - for( integer jp = 0; jp < NP; ++jp ) - { - real64 const dResRelPerm_dS = m_dResPhaseRelPerm_dPhaseVolFrac[er][esr][ei][0][ip][jp]; - dRelPerm[CP_Deriv::dP] += dResRelPerm_dS * m_dResPhaseVolFrac[er][esr][ei][jp][Deriv::dP]; - if constexpr ( IS_THERMAL ) - { - dRelPerm[CP_Deriv::dT] += dResRelPerm_dS * m_dResPhaseVolFrac[er][esr][ei][jp][Deriv::dT]; - } - for( integer jc = 0; jc < NC; ++jc ) - { - dRelPerm[CP_Deriv::dC+jc] += dResRelPerm_dS * m_dResPhaseVolFrac[er][esr][ei][jp][Deriv::dC+jc]; - } - } - // increment total mobility - resTotalMob += resRelPerm / resVisc; - // Handles all dependencies - for( integer jc = 0; jc < CP_Deriv::nDer; ++jc ) - { - dMob[jc] += (dRelPerm[jc] *resVisc - resRelPerm * dVisc[jc] ) - / ( resVisc * resVisc); - } + computeMobilityandDeriv( ip, er, esr, ei, resTotalMob, dResTotalMob ); } // end well is upstream phase loop // compute a potdiff multiplier = wellElemTotalDens * resTotalMob @@ -446,17 +462,16 @@ class PerforationFluxKernel } for( integer jc = 0; jc < CP_Deriv::nDer; ++jc ) { - dMult[TAG::RES][jc] = wellElemTotalDens * dMob[jc]; + dMult[TAG::RES][jc] = wellElemTotalDens * dResTotalMob[jc]; } - // compute the volumetric flux and derivatives using upstream cell mobility - flux = mult * potDiff; - + flux = mult * stack.m_potDiff; for( integer ic = 0; ic < CP_Deriv::nDer; ++ic ) { - dFlux[TAG::RES][ic] = dMult[TAG::RES][ic] * potDiff + mult * dPotDiff[TAG::RES][ic]; - dFlux[TAG::WELL][ic] = dMult[TAG::WELL][ic] * potDiff + mult * dPotDiff[TAG::WELL][ic]; + dFlux[TAG::RES][ic] = dMult[TAG::RES][ic] * stack.m_potDiff + mult * stack.m_dPotDiff[TAG::RES][ic]; + dFlux[TAG::WELL][ic] = dMult[TAG::WELL][ic] * stack.m_potDiff + mult * stack.m_dPotDiff[TAG::WELL][ic]; + } // compute component fluxes for( integer ic = 0; ic < NC; ++ic ) @@ -482,9 +497,11 @@ class PerforationFluxKernel } if constexpr ( IS_THERMAL ) { - fluxKernelOp( iwelem, er, esr, ei, -1, potDiff, flux, dFlux ); + // Cant have different dispatch functions + // so need to have arg list with union of upstream and downstream args, even if some are unused in one of the cases + fluxKernelOp( -1, -1, resTotalMob, dResTotalMob ); } - } // end upstream + } // end upstream } /** * @brief Performs the kernel launch @@ -501,7 +518,17 @@ class PerforationFluxKernel GEOS_MARK_FUNCTION; forAll< POLICY >( numElements, [=] GEOS_HOST_DEVICE ( localIndex const iperf ) { - kernelComponent.computeFlux( iperf ); + typename KERNEL_TYPE::StackVariables stack; + // get the index of the reservoir elem + localIndex const er = kernelComponent.m_resElementRegion[iperf]; + localIndex const esr = kernelComponent.m_resElementSubRegion[iperf]; + localIndex const ei = kernelComponent.m_resElementIndex[iperf]; + // get the index of the well elem + localIndex const iwelem = kernelComponent.m_perfWellElemIndex[iperf]; + + kernelComponent.initialize( iperf, stack ); + kernelComponent.computePotentialandDeriv( iperf, er, esr, ei, iwelem, stack ); + kernelComponent.computeFlux( iperf, er, esr, ei, iwelem, stack ); } ); } @@ -569,7 +596,7 @@ class PerforationFluxKernelFactory string const flowSolverName, PerforationData * const perforationData, ElementSubRegionBase const & subRegion, - ElementRegionManager & elemManager, + ElementRegionManager const & elemManager, bool const isInjector, bool const isCrossflowEnabled ) { @@ -607,10 +634,36 @@ class PerforationFluxKernel : public isothermalPerforationFluxKernels::Perforati public: using Base = isothermalPerforationFluxKernels::PerforationFluxKernel< NC, NP, IS_THERMAL >; - using Base::m_resPhaseCompFrac; - using Base::m_dResCompFrac_dCompDens; using Base::m_dWellElemCompFrac_dCompDens; - + using Base::m_resPres; + using Base::m_resPhaseVolFrac; + using Base::m_dResPhaseVolFrac; + using Base::m_dResCompFrac_dCompDens; + using Base::m_resPhaseDens; + using Base::m_dResPhaseDens; + using Base::m_resPhaseVisc; + using Base::m_dResPhaseVisc; + using Base::m_resPhaseCompFrac; + using Base::m_dResPhaseCompFrac; + using Base::m_resPhaseRelPerm; + using Base::m_dResPhaseRelPerm_dPhaseVolFrac; + using Base::m_isInjector; + using Base::m_isCrossflowEnabled; + using Base::m_resElementRegion; + using Base::m_resElementSubRegion; + using Base::m_resElementIndex; + using Base::m_perfWellElemIndex; + + struct StackVariables : public Base::StackVariables + { +public: + GEOS_HOST_DEVICE + StackVariables() + : Base::StackVariables() + {} + using Base::StackVariables::m_potDiff; + using Base::StackVariables::m_dPotDiff; + }; /// Compile time value for the number of components static constexpr integer numComp = NC; @@ -631,6 +684,8 @@ class PerforationFluxKernel : public isothermalPerforationFluxKernels::Perforati using ThermalMultiFluidAccessors = StencilMaterialAccessors< MultiFluidBase, + fields::multifluid::phaseFraction, + fields::multifluid::dPhaseFraction, fields::multifluid::phaseEnthalpy, fields::multifluid::dPhaseEnthalpy >; @@ -645,7 +700,7 @@ class PerforationFluxKernel : public isothermalPerforationFluxKernels::Perforati using ElementViewConst = ElementRegionManager::ElementViewConst< VIEWTYPE >; PerforationFluxKernel ( PerforationData * const perforationData, - ElementSubRegionBase const & subRegion, + ElementSubRegionBase & subRegion, MultiFluidBase const & wellFluid, CompFlowAccessors const & compFlowAccessors, MultiFluidAccessors const & multiFluidAccessors, @@ -661,13 +716,17 @@ class PerforationFluxKernel : public isothermalPerforationFluxKernels::Perforati relPermAccessors, isInjector, isCrossflowEnabled ), - m_wellElemPhaseFrac( wellFluid.phaseFraction() ), - m_dWellElemPhaseFrac( wellFluid.dPhaseFraction() ), + m_wellElemPhaseVolFrac( subRegion.getField< fields::well::phaseVolumeFraction >() ), + m_dWellElemPhaseVolFrac( subRegion.getField< fields::well::dPhaseVolumeFraction >() ), + m_wellElemPhaseDensity( wellFluid.phaseDensity() ), + m_dWellElemPhaseDensity( wellFluid.dPhaseDensity()), m_wellElemPhaseEnthalpy( wellFluid.phaseEnthalpy()), m_dWellElemPhaseEnthalpy( wellFluid.dPhaseEnthalpy()), m_energyPerfFlux( perforationData->getField< fields::well::energyPerforationFlux >() ), m_dEnergyPerfFlux( perforationData->getField< fields::well::dEnergyPerforationFlux >() ), m_temp( thermalCompFlowAccessors.get( fields::flow::temperature {} ) ), + m_resPhaseFraction( thermalMultiFluidAccessors.get( fields::multifluid::phaseFraction {} ) ), + m_dResPhaseFraction( thermalMultiFluidAccessors.get( fields::multifluid::dPhaseFraction {} )), m_resPhaseEnthalpy( thermalMultiFluidAccessors.get( fields::multifluid::phaseEnthalpy {} ) ), m_dResPhaseEnthalpy( thermalMultiFluidAccessors.get( fields::multifluid::dPhaseEnthalpy {} ) ) {} @@ -676,7 +735,7 @@ class PerforationFluxKernel : public isothermalPerforationFluxKernels::Perforati GEOS_HOST_DEVICE inline void - computeFlux( localIndex const iperf ) const + computeFlux( localIndex const iperf, localIndex const er, localIndex const esr, localIndex const ei, localIndex const iwelem, StackVariables & stack ) const { using Deriv = constitutive::multifluid::DerivativeOffset; using CP_Deriv =constitutive::multifluid::DerivativeOffsetC< NC, IS_THERMAL >; @@ -689,94 +748,122 @@ class PerforationFluxKernel : public isothermalPerforationFluxKernels::Perforati m_dEnergyPerfFlux[iperf][ke][i]=0; } } - - Base::computeFlux ( iperf, [&]( localIndex const iwelem, localIndex const er, localIndex const esr, localIndex const ei, localIndex const ip, - real64 const potDiff, real64 const flux, real64 const (&dFlux)[2][CP_Deriv::nDer] ) + if( stack.m_potDiff >= 0 ) // ** well is downstream ** { - if( potDiff >= 0 ) // ** reservoir cell is upstream ** + real64 dEmob[CP_Deriv::nDer]{}; + Base::computeFlux ( iperf, er, esr, ei, iwelem, stack, [&]( localIndex const ip, real64 const resPhaseVolFrac, real64 const mob, real64 const (&dMob)[CP_Deriv::nDer] ) { + // enthalpy + real64 const resEnthalpy = m_resPhaseEnthalpy[er][esr][ei][0][ip]; + real64 dResEnthalpy[CP_Deriv::nDer]{}; + dResEnthalpy[CP_Deriv::dP] = m_dResPhaseEnthalpy[er][esr][ei][0][ip][Deriv::dP]; + dResEnthalpy[CP_Deriv::dT] = m_dResPhaseEnthalpy[er][esr][ei][0][ip][Deriv::dT]; - real64 const res_enthalpy = m_resPhaseEnthalpy[er][esr][ei][0][ip]; - - m_energyPerfFlux[iperf] += flux * res_enthalpy; - + applyChainRule( NC, m_dResCompFrac_dCompDens[er][esr][ei], + m_dResPhaseEnthalpy[er][esr][ei][0][ip], + &dResEnthalpy[CP_Deriv::dC], + Deriv::dC ); + for( integer jc = 0; jc < CP_Deriv::nDer; ++jc ) + { + dEmob[jc] = dMob[jc] * m_resPhaseEnthalpy[er][esr][ei][0][ip] + mob * dResEnthalpy[jc]; + } + real64 resPhaseMobE = mob * resEnthalpy; + real64 eflux = resPhaseMobE * stack.m_potDiff; + real64 dEFlux[2][CP_Deriv::nDer]{}; + dEFlux[TAG::WELL][CP_Deriv::dP] = resPhaseMobE * stack.m_dPotDiff[TAG::WELL][CP_Deriv::dP]; + dEFlux[TAG::WELL][CP_Deriv::dT] = resPhaseMobE * stack.m_dPotDiff[TAG::WELL][CP_Deriv::dT]; + // Handles all dependencies + for( integer jc = 0; jc < CP_Deriv::nDer; ++jc ) + { + dEFlux[TAG::RES][jc] = dEmob[jc] * stack.m_potDiff + resPhaseMobE * stack.m_dPotDiff[TAG::RES][jc]; + m_dEnergyPerfFlux[iperf][TAG::WELL][jc] = resPhaseMobE * stack.m_dPotDiff[TAG::WELL][jc]; + } + m_energyPerfFlux[iperf] += eflux; // energy equation derivatives WRT res P & T - m_dEnergyPerfFlux[iperf][TAG::RES][CP_Deriv::dP] += dFlux[TAG::RES][CP_Deriv::dP] * res_enthalpy + - flux * m_dResPhaseEnthalpy[er][esr][ei][0][ip][Deriv::dP]; - m_dEnergyPerfFlux[iperf][TAG::RES][CP_Deriv::dT] += dFlux[TAG::RES][CP_Deriv::dT] * res_enthalpy + - flux * m_dResPhaseEnthalpy[er][esr][ei][0][ip][Deriv::dT]; - // energy equation derivatives WRT well P - m_dEnergyPerfFlux[iperf][TAG::WELL][CP_Deriv::dP] += dFlux[TAG::WELL][CP_Deriv::dP] * res_enthalpy; - m_dEnergyPerfFlux[iperf][TAG::WELL][CP_Deriv::dT] += dFlux[TAG::WELL][CP_Deriv::dT] * res_enthalpy; - - - // energy equation derivatives WRT reservoir dens + m_dEnergyPerfFlux[iperf][TAG::RES][CP_Deriv::dP] += dEFlux[TAG::RES][CP_Deriv::dP] * resPhaseVolFrac + + eflux * m_dResPhaseFraction[er][esr][ei][0][ip][Deriv::dP]; + m_dEnergyPerfFlux[iperf][TAG::RES][CP_Deriv::dT] += dEFlux[TAG::RES][CP_Deriv::dT] * resPhaseVolFrac + + eflux *m_dResPhaseFraction[er][esr][ei][0][ip][Deriv::dT]; real64 dProp_dC[numComp]{}; applyChainRule( NC, m_dResCompFrac_dCompDens[er][esr][ei], - m_dResPhaseEnthalpy[er][esr][ei][0][ip], + m_dResPhaseFraction[er][esr][ei][0][ip], dProp_dC, Deriv::dC ); - for( integer jc = 0; jc < NC; ++jc ) { - m_dEnergyPerfFlux[iperf][TAG::RES][CP_Deriv::dC+jc] += flux * dProp_dC[jc]; + m_dEnergyPerfFlux[iperf][TAG::RES][CP_Deriv::dC+jc] += dEFlux[TAG::RES][CP_Deriv::dC+jc]; } - } - else // ** reservoir cell is downstream + } ); + } + else // ** well element is upstream ** + { + Base::computeFlux ( iperf, er, esr, ei, iwelem, stack, [&]( localIndex const null1, real64 const null2, real64 const mob, real64 const (&dMob)[CP_Deriv::nDer] ) { + GEOS_UNUSED_VAR( null1 ); + GEOS_UNUSED_VAR( null2 ); + real64 dMult[CP_Deriv::nDer]{}; + real64 dProp_dC[NC]{}; + real64 totalEnthalpy=0; + + arraySlice1d< real64 const, compflow::USD_PHASE - 1 > phaseVolFrac = m_wellElemPhaseVolFrac[iwelem]; + arraySlice2d< real64 const, compflow::USD_PHASE_DC - 1 > dPhaseVolFrac = m_dWellElemPhaseVolFrac[iwelem]; + arraySlice1d< real64 const, constitutive::multifluid::USD_PHASE - 2 > phaseDens = m_wellElemPhaseDensity[iwelem][0]; + arraySlice2d< real64 const, constitutive::multifluid::USD_PHASE_DC - 2 > dPhaseDens = m_dWellElemPhaseDensity[iwelem][0]; + arraySlice1d< real64 const, constitutive::multifluid::USD_PHASE - 2 > phaseEnthalpy = m_wellElemPhaseEnthalpy[iwelem][0]; + arraySlice2d< real64 const, constitutive::multifluid::USD_PHASE_DC - 2 > dPhaseEnthalpy = m_dWellElemPhaseEnthalpy[iwelem][0]; + // Compute total enthalpy in the well element and its derivatives, then use it to compute energy flux and derivatives for( integer iphase = 0; iphase < NP; ++iphase ) { - bool const phaseExists = m_wellElemPhaseFrac[iwelem][0][iphase] > 0.0; - if( !phaseExists ) - continue; - real64 const phaseFlux = m_wellElemPhaseFrac[iwelem][0][iphase] * flux; - real64 const wellelem_enthalpy = m_wellElemPhaseEnthalpy[iwelem][0][iphase]; - m_energyPerfFlux[iperf] += phaseFlux * wellelem_enthalpy; - - // energy equation derivatives WRT res P & T - m_dEnergyPerfFlux[iperf][TAG::RES][CP_Deriv::dP] += dFlux[TAG::RES][CP_Deriv::dP] * wellelem_enthalpy; - m_dEnergyPerfFlux[iperf][TAG::RES][CP_Deriv::dT] += dFlux[TAG::RES][CP_Deriv::dT] * wellelem_enthalpy; - - m_dEnergyPerfFlux[iperf][TAG::WELL][CP_Deriv::dP] += dFlux[TAG::WELL][CP_Deriv::dP] * wellelem_enthalpy - + phaseFlux * m_dWellElemPhaseEnthalpy[iwelem][0][iphase][Deriv::dP] - + phaseFlux * wellelem_enthalpy * m_dWellElemPhaseFrac[iwelem][0][iphase][Deriv::dP]; - m_dEnergyPerfFlux[iperf][TAG::WELL][CP_Deriv::dT] += dFlux[TAG::WELL][CP_Deriv::dT] * wellelem_enthalpy - + phaseFlux * m_dWellElemPhaseEnthalpy[iwelem][0][iphase][Deriv::dT] - + phaseFlux * wellelem_enthalpy * m_dWellElemPhaseFrac[iwelem][0][iphase][Deriv::dT]; - - //energy e - real64 dPVF_dC[numComp]{}; - applyChainRule( NC, - m_dWellElemCompFrac_dCompDens[iwelem], - m_dWellElemPhaseFrac[iwelem][0][iphase], - dPVF_dC, - Deriv::dC ); - for( integer ic=0; ic 0); + if( !phaseExists || (!m_isInjector && !m_isCrossflowEnabled) ) { - m_dEnergyPerfFlux[iperf][TAG::WELL][CP_Deriv::dC+ic] += wellelem_enthalpy * dFlux[TAG::WELL][CP_Deriv::dC+ic] * m_wellElemPhaseFrac[iwelem][0][iphase]; - m_dEnergyPerfFlux[iperf][TAG::WELL][CP_Deriv::dC+ic] += wellelem_enthalpy * phaseFlux * dPVF_dC[ic]; + continue; } - // energy equation enthalpy derivatives WRT well dens - real64 dProp_dC[numComp]{}; - applyChainRule( NC, - m_dWellElemCompFrac_dCompDens[iwelem], - m_dWellElemPhaseEnthalpy[iwelem][0][iphase], - dProp_dC, - Deriv::dC ); + totalEnthalpy += phaseEnthalpy[iphase] * phaseVolFrac[iphase] * phaseDens[iphase]; + dMult[CP_Deriv::dP] += phaseEnthalpy[iphase] * dPhaseVolFrac[iphase][Deriv::dP] * phaseDens[iphase] + + dPhaseEnthalpy[iphase][Deriv::dP] * phaseVolFrac[iphase] * phaseDens[iphase] + + phaseEnthalpy[iphase] * phaseVolFrac[iphase] * dPhaseDens[iphase][Deriv::dP]; + dMult[CP_Deriv::dT ] += phaseEnthalpy[iphase] * dPhaseVolFrac[iphase][Deriv::dT] * phaseDens[iphase] + + dPhaseEnthalpy[iphase][Deriv::dT] *phaseVolFrac[iphase] * phaseDens[iphase]+ + phaseEnthalpy[iphase] * phaseVolFrac[iphase] * dPhaseDens[iphase][Deriv::dT]; for( integer jc = 0; jc < NC; ++jc ) { - m_dEnergyPerfFlux[iperf][TAG::WELL][CP_Deriv::dC+jc] += phaseFlux * dProp_dC[jc]; + dProp_dC[jc] += phaseVolFrac[iphase] * phaseDens[iphase] * dPhaseEnthalpy[iphase][Deriv::dC+jc] + + phaseVolFrac[iphase] * dPhaseDens[iphase][Deriv::dC+jc] * phaseEnthalpy[iphase]; + dMult[CP_Deriv::dC+jc] += phaseEnthalpy[iphase] * phaseDens[iphase] * dPhaseVolFrac[iphase][Deriv::dC+jc]; } } - } - } ); - } - + real64 dProp_dD[numComp]{}; + applyChainRule( NC, + m_dWellElemCompFrac_dCompDens[iwelem], + dProp_dC, + dProp_dD, + 0 ); + for( integer iphase=0; iphase < NP; ++iphase ) + { + for( integer jc = 0; jc < NC; ++jc ) + { + dMult[CP_Deriv::dC+jc] += phaseVolFrac[iphase] * phaseDens[iphase] * dProp_dD[jc] + + phaseEnthalpy[iphase] * phaseVolFrac[iphase] * dProp_dD[jc]; + } + } + real64 eflux = mob * totalEnthalpy*stack.m_potDiff; + m_energyPerfFlux[iperf] = eflux; + for( integer jc = 0; jc < CP_Deriv::nDer; ++jc ) + { + m_dEnergyPerfFlux[iperf][TAG::WELL][jc] = mob* dMult[jc]*stack.m_potDiff + + mob* totalEnthalpy * stack.m_dPotDiff[TAG::WELL][jc]; + m_dEnergyPerfFlux[iperf][TAG::RES][jc] = dMob[jc]*totalEnthalpy*stack.m_potDiff + + mob* totalEnthalpy * stack.m_dPotDiff[TAG::RES][jc]; + } + } ); + } + } /** * @brief Performs the kernel launch * @tparam POLICY the policy used in the RAJA kernels @@ -793,16 +880,28 @@ class PerforationFluxKernel : public isothermalPerforationFluxKernels::Perforati GEOS_MARK_FUNCTION; forAll< POLICY >( numElements, [=] GEOS_HOST_DEVICE ( localIndex const iperf ) { - kernelComponent.computeFlux( iperf ); + typename KERNEL_TYPE::StackVariables stack; + // get the index of the reservoir elem + localIndex const er = kernelComponent.m_resElementRegion[iperf]; + localIndex const esr = kernelComponent.m_resElementSubRegion[iperf]; + localIndex const ei = kernelComponent.m_resElementIndex[iperf]; + // get the index of the well elem + localIndex const iwelem = kernelComponent.m_perfWellElemIndex[iperf]; + kernelComponent.initialize( iperf, stack ); + kernelComponent.computePotentialandDeriv( iperf, er, esr, ei, iwelem, stack ); + kernelComponent.computeFlux( iperf, er, esr, ei, iwelem, stack ); } ); } protected: /// Views on well element properties - /// Element phase fraction - arrayView3d< real64 const, multifluid::USD_PHASE > const m_wellElemPhaseFrac; - arrayView4d< real64 const, multifluid::USD_PHASE_DC > const m_dWellElemPhaseFrac; + + arrayView2d< real64 const, compflow::USD_PHASE > const m_wellElemPhaseVolFrac; + arrayView3d< real64 const, compflow::USD_PHASE_DC > const m_dWellElemPhaseVolFrac; + + arrayView3d< real64 const, multifluid::USD_PHASE > const m_wellElemPhaseDensity; + arrayView4d< real64 const, multifluid::USD_PHASE_DC > const m_dWellElemPhaseDensity; arrayView3d< real64 const, multifluid::USD_PHASE > const m_wellElemPhaseEnthalpy; arrayView4d< real64 const, multifluid::USD_PHASE_DC > const m_dWellElemPhaseEnthalpy; @@ -814,6 +913,8 @@ class PerforationFluxKernel : public isothermalPerforationFluxKernels::Perforati ElementViewConst< arrayView1d< real64 const > > const m_temp; /// Views on phase enthalpies + ElementViewConst< arrayView3d< real64 const, multifluid::USD_PHASE > > const m_resPhaseFraction; + ElementViewConst< arrayView4d< real64 const, multifluid::USD_PHASE_DC > > const m_dResPhaseFraction; ElementViewConst< arrayView3d< real64 const, multifluid::USD_PHASE > > const m_resPhaseEnthalpy; ElementViewConst< arrayView4d< real64 const, multifluid::USD_PHASE_DC > > const m_dResPhaseEnthalpy; @@ -846,9 +947,9 @@ class PerforationFluxKernelFactory integer const numPhases, string const flowSolverName, PerforationData * const perforationData, - ElementSubRegionBase const & subRegion, + ElementSubRegionBase & subRegion, MultiFluidBase const & fluid, - ElementRegionManager & elemManager, + ElementRegionManager const & elemManager, bool const isInjector, bool const isCrossflowEnabled ) { From 10ade7d1378a055390276a9d1fa40582aad9d2ad Mon Sep 17 00:00:00 2001 From: Randolph Settgast Date: Sun, 3 May 2026 14:28:41 -0700 Subject: [PATCH 12/53] reanable sccache using a legacy backup that uses existing GCP secret (#4045) * reanable sccache using a legacy backup that uses existing GCP secret * fix sccache stats output step --- .github/workflows/build_and_test.yml | 81 ++++++++++++++--------- scripts/ci_build_and_test_in_container.sh | 9 ++- 2 files changed, 59 insertions(+), 31 deletions(-) diff --git a/.github/workflows/build_and_test.yml b/.github/workflows/build_and_test.yml index 9242f4bbb2e..823792690d0 100644 --- a/.github/workflows/build_and_test.yml +++ b/.github/workflows/build_and_test.yml @@ -204,6 +204,7 @@ jobs: LEGACY_SCCACHE_ENDPOINT: ${{ secrets.SCCACHE_ENDPOINT }} LEGACY_CLOUDFLARE_R2_ACCESS_KEY_ID: ${{ secrets.CLOUDFLARE_R2_ACCESS_KEY_ID }} LEGACY_CLOUDFLARE_R2_SECRET_ACCESS_KEY: ${{ secrets.CLOUDFLARE_R2_SECRET_ACCESS_KEY }} + LEGACY_GOOGLE_CLOUD_GCP: ${{ secrets.GOOGLE_CLOUD_GCP }} run: | set -euo pipefail @@ -250,7 +251,9 @@ jobs: selected_sccache_config_toml="${DIRECT_SCCACHE_CONFIG_TOML:-}" selected_sccache_env_vars_json="${direct_sccache_env_vars_json}" selected_sccache_files_json="${direct_sccache_files_json}" - elif [[ -n "${SCCACHE_PROFILES_JSON:-}" && -n "${sccache_profile}" ]]; then + fi + + if [[ -z "${selected_sccache_config_toml:-}" && -z "${selected_sccache_env_vars_json:-}" && -z "${selected_sccache_files_json:-}" && -n "${SCCACHE_PROFILES_JSON:-}" && -n "${sccache_profile}" ]]; then sccache_profiles_json="$(validate_optional_json_object "SCCACHE_PROFILES_JSON" "${SCCACHE_PROFILES_JSON}")" selected_profile_json="$(jq -c --arg profile "${sccache_profile}" '.[$profile] // empty' <<< "${sccache_profiles_json}")" @@ -260,23 +263,42 @@ jobs: selected_sccache_env_vars_json="$(jq -c '.env_vars // {}' <<< "${selected_profile_json}")" selected_sccache_files_json="$(jq -c '.files // {}' <<< "${selected_profile_json}")" fi - elif [[ "${sccache_profile}" == "cloudflare" ]]; then - if [[ -n "${LEGACY_SCCACHE_BUCKET:-}" && -n "${LEGACY_SCCACHE_ENDPOINT:-}" && -n "${LEGACY_CLOUDFLARE_R2_ACCESS_KEY_ID:-}" && -n "${LEGACY_CLOUDFLARE_R2_SECRET_ACCESS_KEY:-}" ]]; then - selected_sccache_env_vars_json="$(jq -cn \ - --arg bucket "${LEGACY_SCCACHE_BUCKET}" \ - --arg access_key_id "${LEGACY_CLOUDFLARE_R2_ACCESS_KEY_ID}" \ - --arg secret_access_key "${LEGACY_CLOUDFLARE_R2_SECRET_ACCESS_KEY}" \ - --arg endpoint "${LEGACY_SCCACHE_ENDPOINT}" \ - '{ - SCCACHE_BUCKET: $bucket, - AWS_ACCESS_KEY_ID: $access_key_id, - AWS_SECRET_ACCESS_KEY: $secret_access_key, - SCCACHE_ENDPOINT: $endpoint, - SCCACHE_S3_USE_SSL: "true", - SCCACHE_REGION: "auto" - }' - )" - fi + fi + + if [[ -z "${selected_sccache_config_toml:-}" && -z "${selected_sccache_env_vars_json:-}" && -z "${selected_sccache_files_json:-}" ]]; then + # Temporary compatibility for orgs that still use pre-profile + # sccache secrets. Prefer SCCACHE_PROFILES_JSON for new setup. + case "${sccache_profile}" in + cloudflare) + if [[ -n "${LEGACY_SCCACHE_BUCKET:-}" && -n "${LEGACY_SCCACHE_ENDPOINT:-}" && -n "${LEGACY_CLOUDFLARE_R2_ACCESS_KEY_ID:-}" && -n "${LEGACY_CLOUDFLARE_R2_SECRET_ACCESS_KEY:-}" ]]; then + selected_sccache_env_vars_json="$(jq -cn \ + --arg bucket "${LEGACY_SCCACHE_BUCKET}" \ + --arg access_key_id "${LEGACY_CLOUDFLARE_R2_ACCESS_KEY_ID}" \ + --arg secret_access_key "${LEGACY_CLOUDFLARE_R2_SECRET_ACCESS_KEY}" \ + --arg endpoint "${LEGACY_SCCACHE_ENDPOINT}" \ + '{ + SCCACHE_BUCKET: $bucket, + AWS_ACCESS_KEY_ID: $access_key_id, + AWS_SECRET_ACCESS_KEY: $secret_access_key, + SCCACHE_ENDPOINT: $endpoint, + SCCACHE_S3_USE_SSL: "true", + SCCACHE_REGION: "auto" + }' + )" + fi + ;; + gcp) + if [[ -n "${LEGACY_GOOGLE_CLOUD_GCP:-}" ]]; then + selected_sccache_config_toml="$(printf '%s\n' \ + '[cache.gcs]' \ + 'rw_mode = "READ_WRITE"' \ + 'cred_path = "/tmp/geos/.sccache-runtime/gcp-service-account.json"' \ + 'bucket = "geos-dev"' \ + 'key_prefix = "sccache"')" + selected_sccache_files_json="$(jq -cn --arg credentials "${LEGACY_GOOGLE_CLOUD_GCP}" '{"gcp-service-account.json": $credentials}')" + fi + ;; + esac fi if [[ "${selected_sccache_env_vars_json:-}" == "{}" ]]; then @@ -818,6 +840,17 @@ jobs: REQUESTS_CA_BUNDLE: /etc/pki/tls/certs/ca-bundle.crt CURL_CA_BUNDLE: /etc/pki/tls/certs/ca-bundle.crt + - name: Show sccache stats + if: ${{ always() && steps.sccache_config.outputs.use_sccache == 'true' }} + run: | + sccache_runtime_dir="${{ steps.sccache_config.outputs.sccache_runtime_dir }}" + sccache_stats_file="${GITHUB_WORKSPACE}/${sccache_runtime_dir}/stats.txt" + if [[ -n "${sccache_runtime_dir}" && -f "${sccache_stats_file}" ]]; then + cat "${sccache_stats_file}" + else + echo "No in-container sccache stats file was captured." + fi + - name: 'Cleanup build folder' if: always() run: | @@ -827,15 +860,3 @@ jobs: alpine:3.20 \ sh -lc 'rm -rf /tmp/geos/* /tmp/geos/.[!.]* /tmp/geos/..?* || true' - - name: Show sccache stats - if: ${{ always() && steps.sccache_config.outputs.use_sccache == 'true' }} - run: | - sccache_env_file="${{ steps.sccache_config.outputs.sccache_env_file }}" - if [[ -n "${sccache_env_file}" && -f "${GITHUB_WORKSPACE}/${sccache_env_file}" ]]; then - while IFS='=' read -r key value || [[ -n "${key}" ]]; do - [[ -z "${key}" ]] && continue - export "${key}=${value}" - done < "${GITHUB_WORKSPACE}/${sccache_env_file}" - fi - - command -v sccache >/dev/null && sccache --show-stats || true diff --git a/scripts/ci_build_and_test_in_container.sh b/scripts/ci_build_and_test_in_container.sh index 3fc3f7ced32..61a6ef16a39 100755 --- a/scripts/ci_build_and_test_in_container.sh +++ b/scripts/ci_build_and_test_in_container.sh @@ -402,7 +402,14 @@ phase_finish 0 if [[ -n "${SCCACHE_BIN}" ]]; then echo "sccache post-build state" - or_die ${SCCACHE_BIN} --show-adv-stats + SCCACHE_STATS_FILE="${GEOS_SRC_DIR}/.sccache-runtime/stats.txt" + or_die mkdir -p "$(dirname "${SCCACHE_STATS_FILE}")" + ${SCCACHE_BIN} --show-adv-stats | tee "${SCCACHE_STATS_FILE}" + SCCACHE_STATS_STATUS=${PIPESTATUS[0]} + if [[ ${SCCACHE_STATS_STATUS} != 0 ]]; then + echo ERROR ${SCCACHE_STATS_STATUS} command: ${SCCACHE_BIN} --show-adv-stats + exit ${SCCACHE_STATS_STATUS} + fi fi if [[ "${CODE_COVERAGE}" = true ]]; then From 0c6b674b50b9aabaca9a6d93c137754e2d37e5dd Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sun, 3 May 2026 18:05:57 -0700 Subject: [PATCH 13/53] build(deps): bump the github-actions group across 1 directory with 2 updates (#4044) Bumps the github-actions group with 2 updates in the / directory: [actions/checkout](https://github.com/actions/checkout) and [codecov/codecov-action](https://github.com/codecov/codecov-action). Updates `actions/checkout` from 4.2.2 to 6.0.2 - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v4.2.2...v6.0.2) Updates `codecov/codecov-action` from 5.4.2 to 6.0.0 - [Release notes](https://github.com/codecov/codecov-action/releases) - [Changelog](https://github.com/codecov/codecov-action/blob/main/CHANGELOG.md) - [Commits](https://github.com/codecov/codecov-action/compare/v5.4.2...v6.0.0) --- updated-dependencies: - dependency-name: actions/checkout dependency-version: 6.0.2 dependency-type: direct:production update-type: version-update:semver-major dependency-group: github-actions - dependency-name: codecov/codecov-action dependency-version: 6.0.0 dependency-type: direct:production update-type: version-update:semver-major dependency-group: github-actions Co-authored-by: Randolph Settgast --- .github/workflows/build_and_test.yml | 4 ++-- .github/workflows/ci_tests.yml | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/build_and_test.yml b/.github/workflows/build_and_test.yml index 823792690d0..08e7a8d8370 100644 --- a/.github/workflows/build_and_test.yml +++ b/.github/workflows/build_and_test.yml @@ -184,7 +184,7 @@ jobs: ls -la ./ - name: Checkout Repository - uses: actions/checkout@v4.2.2 + uses: actions/checkout@v6.0.2 with: submodules: true lfs: ${{ inputs.BUILD_TYPE == 'integrated_tests' }} @@ -828,7 +828,7 @@ jobs: - name: Upload coverage to Codecov if: inputs.CODE_COVERAGE - uses: codecov/codecov-action@v5.4.2 + uses: codecov/codecov-action@v6.0.0 with: files: ${GITHUB_WORKSPACE}/geos_coverage.info.cleaned fail_ci_if_error: true diff --git a/.github/workflows/ci_tests.yml b/.github/workflows/ci_tests.yml index 921643de9d5..e607900f87e 100644 --- a/.github/workflows/ci_tests.yml +++ b/.github/workflows/ci_tests.yml @@ -42,7 +42,7 @@ jobs: # The TPL tag is contained in the codespaces configuration to avoid duplications. - name: Checkout .devcontainer/devcontainer.json - uses: actions/checkout@v4.2.2 + uses: actions/checkout@v6.0.2 with: sparse-checkout: | .devcontainer/devcontainer.json @@ -94,7 +94,7 @@ jobs: CI_REPOSITORY_OWNER: ${{ github.repository_owner }} steps: - name: Checkout CI config - uses: actions/checkout@v4.2.2 + uses: actions/checkout@v6.0.2 with: sparse-checkout: | .github/ci/orgs @@ -256,7 +256,7 @@ jobs: # The integrated test submodule repository contains large data (using git lfs). # To save time (and money) we do not let Github Actions automatically clone all our (lfs) subrepositories and do it by hand. - name: Checkout Repository - uses: actions/checkout@v4.2.2 + uses: actions/checkout@v6.0.2 with: # Let script update submodules; Github Actions submodule history causes error submodules: false @@ -426,7 +426,7 @@ jobs: runs-on: ubuntu-22.04 steps: - name: Checkout Repository - uses: actions/checkout@v4.2.2 + uses: actions/checkout@v6.0.2 with: submodules: false lfs: false From e971774095ed4d5a0477c685b4f222fc2990a464 Mon Sep 17 00:00:00 2001 From: Randolph Settgast Date: Sun, 3 May 2026 20:01:40 -0700 Subject: [PATCH 14/53] fix assignement check (#4046) --- .github/workflows/ci_tests.yml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci_tests.yml b/.github/workflows/ci_tests.yml index e607900f87e..761296099db 100644 --- a/.github/workflows/ci_tests.yml +++ b/.github/workflows/ci_tests.yml @@ -238,11 +238,15 @@ jobs: steps: - name: If this is a PR, Check that it is assigned env: - PR_JSON: ${{ toJson(github.event.pull_request) }} + GITHUB_TOKEN: ${{ github.token }} run: | set -euo pipefail if [[ "${{ github.event_name }}" != 'pull_request' ]]; then exit 0 ; fi + PR_JSON=$(curl --fail --silent --show-error \ + -H "Accept: application/vnd.github+json" \ + -H "Authorization: Bearer ${GITHUB_TOKEN}" \ + https://api.github.com/repos/${{ github.repository }}/pulls/${{ github.event.number }}) NUM_ASSIGNEES=$(jq -r '.assignees | length' <<< "${PR_JSON}") echo "There are ${NUM_ASSIGNEES} assignees on this PR." if [[ "${NUM_ASSIGNEES}" == 0 ]]; then exit 1 ; fi From a02d8632bb69d507572daccddfbb521f48f1d0eb Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Tue, 5 May 2026 16:41:16 +0200 Subject: [PATCH 15/53] use cpptrace for GeosException --- src/coreComponents/common/CMakeLists.txt | 6 ++ .../common/initializeEnvironment.cpp | 5 +- .../common/logger/ErrorHandling.cpp | 6 +- src/coreComponents/common/logger/Logger.hpp | 7 +- .../common/logger/StackTrace.cpp | 86 +++++++++++++++++++ .../common/logger/StackTrace.hpp | 67 +++++++++++++++ src/main/main.cpp | 12 ++- 7 files changed, 181 insertions(+), 8 deletions(-) create mode 100644 src/coreComponents/common/logger/StackTrace.cpp create mode 100644 src/coreComponents/common/logger/StackTrace.hpp diff --git a/src/coreComponents/common/CMakeLists.txt b/src/coreComponents/common/CMakeLists.txt index d0143b9564b..9dbfd6081f1 100644 --- a/src/coreComponents/common/CMakeLists.txt +++ b/src/coreComponents/common/CMakeLists.txt @@ -43,6 +43,7 @@ set( common_headers logger/Logger.hpp logger/ErrorHandling.hpp logger/ExternalErrorHandler.hpp + logger/StackTrace.hpp MpiWrapper.hpp Path.hpp Span.hpp @@ -82,6 +83,7 @@ set( common_sources logger/Logger.cpp logger/ErrorHandling.cpp logger/ExternalErrorHandler.cpp + logger/StackTrace.cpp BufferAllocator.cpp MemoryInfos.cpp MpiWrapper.cpp @@ -136,6 +138,10 @@ if( ENABLE_CALIPER ) endif() endif() +if( ENABLE_CPPTRACE ) + list( APPEND dependencyList cpptrace::cpptrace ) +endif() + blt_add_library( NAME common SOURCES ${common_sources} HEADERS ${common_headers} diff --git a/src/coreComponents/common/initializeEnvironment.cpp b/src/coreComponents/common/initializeEnvironment.cpp index e43263c8528..90f00b5a731 100644 --- a/src/coreComponents/common/initializeEnvironment.cpp +++ b/src/coreComponents/common/initializeEnvironment.cpp @@ -26,6 +26,7 @@ #include #include #include +#include "logger/StackTrace.hpp" #include "umpire/util/MemoryResourceTraits.hpp" #include "umpire/util/Platform.hpp" @@ -86,7 +87,7 @@ void setupLogger() } else { - std::string const stackHistory = LvArray::system::stackTrace( true ); + std::string const stackHistory = StackTrace::stackTrace(); DiagnosticMsg diagnosticMsg; ErrorLogger::global().flushErrorMsg( DiagnosticMsgBuilder::init( diagnosticMsg, MsgType::Error, errorMsg, @@ -109,7 +110,7 @@ void setupLogger() ExternalErrorHandler::instance().flush( "before signal error output" ); // error message output - std::string const stackHistory = LvArray::system::stackTrace( true ); + std::string const stackHistory = StackTrace::stackTrace(); DiagnosticMsg diagnosticMsg; ErrorLogger::global().flushErrorMsg( DiagnosticMsgBuilder::init( diagnosticMsg, MsgType::ExternalError, "", diff --git a/src/coreComponents/common/logger/ErrorHandling.cpp b/src/coreComponents/common/logger/ErrorHandling.cpp index 3b36f7edf37..7eefeb74f3c 100644 --- a/src/coreComponents/common/logger/ErrorHandling.cpp +++ b/src/coreComponents/common/logger/ErrorHandling.cpp @@ -18,8 +18,11 @@ */ #include "ErrorHandling.hpp" +#include "Logger.hpp" +#include "StackTrace.hpp" #include "common/DataTypes.hpp" #include "common/logger/Logger.hpp" +#include "common/logger/StackTrace.hpp" #include "common/format/StringUtilities.hpp" #include @@ -66,7 +69,7 @@ DiagnosticMsgBuilder ErrorLogger::initCurrentExceptionMessage( MsgType msgType, m_getCurrentExceptionMsg = DiagnosticMsgBuilder::init( diagnosticMsg, msgType, msgContent, rank ) - .addCallStackInfo( LvArray::system::stackTrace( true ) ) + .addCallStackInfo( StackTrace::stackTrace() ) .getDiagnosticMsg(); return DiagnosticMsgBuilder::modify( m_getCurrentExceptionMsg ); } @@ -209,7 +212,6 @@ DiagnosticMsgBuilder & DiagnosticMsgBuilder::addCallStackInfo( std::string_view std::string str = std::string( ossStackTrace ); std::istringstream iss( str ); std::string stackLine; - std::size_t index; std::regex lvArrayPattern( R"(Frame \d+: \S+)" ); std::regex cpptracePattern( R"(^\s*#\d+\s+)" ); diff --git a/src/coreComponents/common/logger/Logger.hpp b/src/coreComponents/common/logger/Logger.hpp index b23ba87a39d..f692ff96b3a 100644 --- a/src/coreComponents/common/logger/Logger.hpp +++ b/src/coreComponents/common/logger/Logger.hpp @@ -23,6 +23,7 @@ // Source includes #include "LvArray/src/Macros.hpp" #include "common/logger/GeosExceptions.hpp" +#include "common/logger/StackTrace.hpp" // System includes #include @@ -161,7 +162,7 @@ ::geos::logger::internal::g_rank ) \ .setCodeLocation( __FILE__, __LINE__ ) \ .setCause( __causemsgsoss.str() ) \ - .addCallStackInfo( LvArray::system::stackTrace( true ) ) \ + .addCallStackInfo( StackTrace::stackTrace() ) \ .addContextInfo( GEOS_DETAIL_REST_ARGS( __VA_ARGS__ )); \ GEOS_GLOBAL_LOGGER.flushCurrentExceptionMessage(); \ LvArray::system::callErrorHandler(); \ @@ -248,7 +249,7 @@ ::geos::logger::internal::g_rank ) \ .setCodeLocation( __FILE__, __LINE__ ) \ .setCause( __causemsgsoss.str() ) \ - .addCallStackInfo( LvArray::system::stackTrace( true ) ) \ + .addCallStackInfo( StackTrace::stackTrace() ) \ .addContextInfo( GEOS_DETAIL_REST_ARGS( __VA_ARGS__ )) \ .getDiagnosticMsg(); \ auto ex = GEOS_DETAIL_FIRST_ARG( __VA_ARGS__ )(); \ @@ -341,7 +342,7 @@ ::geos::logger::internal::g_rank ) \ .setCodeLocation( __FILE__, __LINE__ ) \ .setCause( __causemsgsoss.str() ) \ - .addCallStackInfo( LvArray::system::stackTrace( true ) ) \ + .addCallStackInfo( StackTrace::stackTrace() ) \ .addContextInfo( GEOS_DETAIL_REST_ARGS( __VA_ARGS__ )) \ .getDiagnosticMsg() ); \ } \ diff --git a/src/coreComponents/common/logger/StackTrace.cpp b/src/coreComponents/common/logger/StackTrace.cpp new file mode 100644 index 00000000000..c94a483f310 --- /dev/null +++ b/src/coreComponents/common/logger/StackTrace.cpp @@ -0,0 +1,86 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 StackTrace.cpp + */ + +#include "StackTrace.hpp" +#include "LvArray/src/system.hpp" + +#include "common/GeosxConfig.hpp" +#ifdef GEOS_USE_CPPTRACE +#include +#include +#include +#endif + +namespace geos +{ + + +std::string StackTrace::stackTrace() +{ +#ifdef GEOS_USE_CPPTRACE + return formatter().format( cpptrace::generate_trace( /* skip = */ 1 ) ); +#else + return LvArray::system::stackTrace( true ); +#endif +} + +#ifdef GEOS_USE_CPPTRACE +cpptrace::formatter & StackTrace::formatter() +{ + static cpptrace::formatter fmt = cpptrace::formatter{} + .header( "" ) + .addresses( cpptrace::formatter::address_mode::none ) + .paths( cpptrace::formatter::path_mode::basename ) + .symbols( cpptrace::formatter::symbol_mode::pretty ) + .snippets( false ) + .columns( true ) + .filtered_frame_placeholders( false ) + .filter( []( cpptrace::stacktrace_frame const & frame ) + { + static char const * const blacklist[] = { + "__cxa_throw", + "__cxa_rethrow", + "_Unwind_RaiseException", + "_Unwind_Resume", + "cpptrace::detail::", + "cpptrace::v1::detail::", + "cpptrace::try_catch::", + "cpptrace::v1::try_catch::", + }; + for( char const * symbolToHide : blacklist ) + { + if( frame.symbol.find( symbolToHide ) != std::string::npos ) + { + return false; + } + } + return true; + } ); + + return fmt; +} + +std::string StackTrace::formatStackTrace( cpptrace::v1::stacktrace stacktrace ) +{ + return formatter().format( stacktrace ); +} +#endif + + +} /* namespace geos */ diff --git a/src/coreComponents/common/logger/StackTrace.hpp b/src/coreComponents/common/logger/StackTrace.hpp new file mode 100644 index 00000000000..91e01d3869f --- /dev/null +++ b/src/coreComponents/common/logger/StackTrace.hpp @@ -0,0 +1,67 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 StackTrace.hpp + */ + +#ifndef GEOS_COMMON_LOGGER_STACKTRACE_HPP +#define GEOS_COMMON_LOGGER_STACKTRACE_HPP + +#include "common/GeosxConfig.hpp" // For the following guards +#ifdef GEOS_USE_CPPTRACE +#include +#include +#endif + +#include + +namespace geos +{ + +/** + * @brief Utility class to interact with stack traces. + */ +class StackTrace +{ +public: + + /** + * @brief Get a stack trace for the current thread. + * @return The stack trace as a string. + */ + static std::string stackTrace(); + +#ifdef GEOS_USE_CPPTRACE + /** + * @brief Access the configured cpptrace formatter. + * @return The formatter instance. + */ + static cpptrace::formatter & formatter(); + + /** + * @brief Format a cpptrace stacktrace using the configured formatter. + * @param stacktrace The cpptrace stack trace to format. + * @return Formatted stack trace string. + */ + static std::string formatStackTrace( cpptrace::v1::stacktrace stacktrace ); +#endif + +}; + + +} /* namespace geos */ + +#endif /* GEOS_COMMON_LOGGER_STACKTRACE_HPP */ diff --git a/src/main/main.cpp b/src/main/main.cpp index be58645cb58..75e633b252f 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -16,6 +16,7 @@ // Source includes #include "common/logger/ErrorHandling.hpp" #include "common/logger/Logger.hpp" +#include "common/logger/StackTrace.hpp" #include "common/GeosxConfig.hpp" #include "common/MemoryInfos.hpp" #include "common/TimingMacros.hpp" @@ -82,6 +83,15 @@ int main( int argc, char *argv[] ) auto onGeosException = [&]( geos::Exception & e ) { // GEOS generated exceptions management +#ifdef GEOS_USE_CPPTRACE + std::string const stacktrace = StackTrace::formatStackTrace( cpptrace::from_current_exception() ); +#else + std::string const stacktrace = LvArray::system::stackTrace( true ); +#endif + if( !stacktrace.empty() ) + { + ErrorLogger::global().modifyCurrentExceptionMessage().addCallStackInfo( stacktrace ); + } ErrorLogger::global().flushCurrentExceptionMessage(); basicCleanup( true ); LvArray::system::callErrorHandler(); @@ -90,7 +100,7 @@ int main( int argc, char *argv[] ) auto onStdException = [&]( std::exception const & e ) { // native exceptions management #ifdef GEOS_USE_CPPTRACE - std::string const stacktrace = cpptrace::from_current_exception().to_string(); + std::string const stacktrace = StackTrace::formatStackTrace( cpptrace::from_current_exception() ); #else std::string const stacktrace = LvArray::system::stackTrace( true ); #endif From 2977086104b262e6b4d368974cdbf1e63c6642ea Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Tue, 5 May 2026 17:07:27 +0200 Subject: [PATCH 16/53] add cpptrace in buildGuide --- src/docs/sphinx/buildGuide/BuildProcess.rst | 1 + src/docs/sphinx/buildGuide/Dependencies.rst | 2 ++ 2 files changed, 3 insertions(+) diff --git a/src/docs/sphinx/buildGuide/BuildProcess.rst b/src/docs/sphinx/buildGuide/BuildProcess.rst index cd3910c451c..25ab8af4a4d 100644 --- a/src/docs/sphinx/buildGuide/BuildProcess.rst +++ b/src/docs/sphinx/buildGuide/BuildProcess.rst @@ -70,6 +70,7 @@ Option Default Explanation ``ENABLE_CUDA_NVTOOLSEXT`` ``OFF`` Enable CUDA NVTX user instrumentation (via GEOS_MARK_SCOPE or GEOS_MARK_FUNCTION macros) ``ENABLE_HIP`` ``OFF`` Build with HIP/ROCM (also applies to TPLs) ``ENABLE_DOCS`` ``ON`` Build documentation (Sphinx and Doxygen) +``ENABLE_CPPTRACE`` ``ON`` Enable cpptrace stack traces ``ENABLE_WARNINGS_AS_ERRORS`` ``ON`` Treat all warnings as errors ``ENABLE_PVTPackage`` ``ON`` Enable PVTPackage library (required for compositional flow runs) ``ENABLE_TOTALVIEW_OUTPUT`` ``OFF`` Enables TotalView debugger custom view of GEOS data structures diff --git a/src/docs/sphinx/buildGuide/Dependencies.rst b/src/docs/sphinx/buildGuide/Dependencies.rst index 03824bb29a4..a8f26eceda4 100644 --- a/src/docs/sphinx/buildGuide/Dependencies.rst +++ b/src/docs/sphinx/buildGuide/Dependencies.rst @@ -25,6 +25,7 @@ Adiak_ 0.2.0 :code:`ENABLE_CALIPER` :code:`ADIAK_DIR` Caliper_ 2.4.0 :code:`ENABLE_CALIPER` :code:`CALIPER_DIR` Instrumentation and performance profiling library. conduit_ 0.5.0 *mandatory* :code:`CONDUIT_DIR` Simplified Data Exchange for HPC Simulations. CHAI_ 2.2.2 *mandatory* :code:`CHAI_DIR` Copy-hiding array abstraction to automatically migrate data between memory spaces. +cpptrace_ 1.0.0 :code:`ENABLE_CPPTRACE` :code:`CPPTRACE_DIR` Optional stack trace library that captures full throw-site stack traces (including STL frames). RAJA_ 0.12.1 *mandatory* :code:`RAJA_DIR` Collection of C++ software abstractions that enable architecture portability for HPC applications. hdf5_ 1.10.5 *mandatory* :code:`HDF5_DIR` High-performance data management and storage suite. mathpresso_ 2015-12-15 :code:`ENABLE_MATHPRESSO` :code:`MATHPRESSO_DIR` Mathematical Expression Parser and JIT Compiler. @@ -56,6 +57,7 @@ uncrustify_ 401a409 :code:`ENABLE_UNCRUSTIFY` :code:`UNCRUSTIFY_EXECUTABL .. _Caliper: https://github.com/LLNL/Caliper .. _conduit: https://github.com/LLNL/conduit .. _CHAI : https://github.com/LLNL/CHAI +.. _cpptrace : https://github.com/jeremy-rifkin/cpptrace .. _RAJA : https://github.com/LLNL/RAJA .. _hdf5 : https://portal.hdfgroup.org/display/HDF5/HDF5 .. _mathpresso : https://github.com/kobalicek/mathpresso From 473d53a9161bb30fc7b43e82a111d86c469e76ab Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Tue, 5 May 2026 17:30:00 +0200 Subject: [PATCH 17/53] fix default in BuildProcess --- src/docs/sphinx/buildGuide/BuildProcess.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/docs/sphinx/buildGuide/BuildProcess.rst b/src/docs/sphinx/buildGuide/BuildProcess.rst index 25ab8af4a4d..88d5a4e914c 100644 --- a/src/docs/sphinx/buildGuide/BuildProcess.rst +++ b/src/docs/sphinx/buildGuide/BuildProcess.rst @@ -70,7 +70,7 @@ Option Default Explanation ``ENABLE_CUDA_NVTOOLSEXT`` ``OFF`` Enable CUDA NVTX user instrumentation (via GEOS_MARK_SCOPE or GEOS_MARK_FUNCTION macros) ``ENABLE_HIP`` ``OFF`` Build with HIP/ROCM (also applies to TPLs) ``ENABLE_DOCS`` ``ON`` Build documentation (Sphinx and Doxygen) -``ENABLE_CPPTRACE`` ``ON`` Enable cpptrace stack traces +``ENABLE_CPPTRACE`` ``OFF`` Enable cpptrace stack traces ``ENABLE_WARNINGS_AS_ERRORS`` ``ON`` Treat all warnings as errors ``ENABLE_PVTPackage`` ``ON`` Enable PVTPackage library (required for compositional flow runs) ``ENABLE_TOTALVIEW_OUTPUT`` ``OFF`` Enables TotalView debugger custom view of GEOS data structures From 5a981de50d97effeaca0e20b97b56802dac8f98e Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Tue, 5 May 2026 18:05:02 +0200 Subject: [PATCH 18/53] fix regex --- src/coreComponents/common/logger/ErrorHandling.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreComponents/common/logger/ErrorHandling.cpp b/src/coreComponents/common/logger/ErrorHandling.cpp index 7eefeb74f3c..75dd7f98ec1 100644 --- a/src/coreComponents/common/logger/ErrorHandling.cpp +++ b/src/coreComponents/common/logger/ErrorHandling.cpp @@ -213,7 +213,7 @@ DiagnosticMsgBuilder & DiagnosticMsgBuilder::addCallStackInfo( std::string_view std::istringstream iss( str ); std::string stackLine; - std::regex lvArrayPattern( R"(Frame \d+: \S+)" ); + std::regex lvArrayPattern( R"(Frame \d+:\s*)" ); std::regex cpptracePattern( R"(^\s*#\d+\s+)" ); while( std::getline( iss, stackLine ) ) From 0f9d2023b3a0630a712413719c6606bb18d04976 Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Tue, 5 May 2026 18:06:02 +0200 Subject: [PATCH 19/53] add signal-safe stack trace method --- src/coreComponents/common/initializeEnvironment.cpp | 2 +- src/coreComponents/common/logger/StackTrace.cpp | 5 +++++ src/coreComponents/common/logger/StackTrace.hpp | 7 +++++++ 3 files changed, 13 insertions(+), 1 deletion(-) diff --git a/src/coreComponents/common/initializeEnvironment.cpp b/src/coreComponents/common/initializeEnvironment.cpp index 90f00b5a731..2bc60ddc860 100644 --- a/src/coreComponents/common/initializeEnvironment.cpp +++ b/src/coreComponents/common/initializeEnvironment.cpp @@ -110,7 +110,7 @@ void setupLogger() ExternalErrorHandler::instance().flush( "before signal error output" ); // error message output - std::string const stackHistory = StackTrace::stackTrace(); + std::string const stackHistory = StackTrace::signalSafeStackTrace(); DiagnosticMsg diagnosticMsg; ErrorLogger::global().flushErrorMsg( DiagnosticMsgBuilder::init( diagnosticMsg, MsgType::ExternalError, "", diff --git a/src/coreComponents/common/logger/StackTrace.cpp b/src/coreComponents/common/logger/StackTrace.cpp index c94a483f310..04a7cfa176f 100644 --- a/src/coreComponents/common/logger/StackTrace.cpp +++ b/src/coreComponents/common/logger/StackTrace.cpp @@ -40,6 +40,11 @@ std::string StackTrace::stackTrace() #endif } +std::string StackTrace::signalSafeStackTrace() +{ + return LvArray::system::stackTrace( true ); +} + #ifdef GEOS_USE_CPPTRACE cpptrace::formatter & StackTrace::formatter() { diff --git a/src/coreComponents/common/logger/StackTrace.hpp b/src/coreComponents/common/logger/StackTrace.hpp index 91e01d3869f..44e2a38d090 100644 --- a/src/coreComponents/common/logger/StackTrace.hpp +++ b/src/coreComponents/common/logger/StackTrace.hpp @@ -41,9 +41,16 @@ class StackTrace /** * @brief Get a stack trace for the current thread. * @return The stack trace as a string. + * @note Not signal-safe. Use signalSafeStackTrace() from inside a signal handler. */ static std::string stackTrace(); + /** + * @brief Get a stack trace from a context where signal-safety is required. + * @return The stack trace as a string. + */ + static std::string signalSafeStackTrace(); + #ifdef GEOS_USE_CPPTRACE /** * @brief Access the configured cpptrace formatter. From e88e821756f12475b762087233e3432f19d037c0 Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Tue, 5 May 2026 18:12:09 +0200 Subject: [PATCH 20/53] modify types --- src/coreComponents/common/logger/StackTrace.cpp | 6 +++--- src/coreComponents/common/logger/StackTrace.hpp | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/coreComponents/common/logger/StackTrace.cpp b/src/coreComponents/common/logger/StackTrace.cpp index 04a7cfa176f..1fa59d0be60 100644 --- a/src/coreComponents/common/logger/StackTrace.cpp +++ b/src/coreComponents/common/logger/StackTrace.cpp @@ -46,9 +46,9 @@ std::string StackTrace::signalSafeStackTrace() } #ifdef GEOS_USE_CPPTRACE -cpptrace::formatter & StackTrace::formatter() +cpptrace::formatter const & StackTrace::formatter() { - static cpptrace::formatter fmt = cpptrace::formatter{} + static cpptrace::formatter const fmt = cpptrace::formatter{} .header( "" ) .addresses( cpptrace::formatter::address_mode::none ) .paths( cpptrace::formatter::path_mode::basename ) @@ -81,7 +81,7 @@ cpptrace::formatter & StackTrace::formatter() return fmt; } -std::string StackTrace::formatStackTrace( cpptrace::v1::stacktrace stacktrace ) +std::string StackTrace::formatStackTrace( cpptrace::stacktrace const & stacktrace ) { return formatter().format( stacktrace ); } diff --git a/src/coreComponents/common/logger/StackTrace.hpp b/src/coreComponents/common/logger/StackTrace.hpp index 44e2a38d090..e09cce7a0e5 100644 --- a/src/coreComponents/common/logger/StackTrace.hpp +++ b/src/coreComponents/common/logger/StackTrace.hpp @@ -56,14 +56,14 @@ class StackTrace * @brief Access the configured cpptrace formatter. * @return The formatter instance. */ - static cpptrace::formatter & formatter(); + static cpptrace::formatter const & formatter(); /** * @brief Format a cpptrace stacktrace using the configured formatter. * @param stacktrace The cpptrace stack trace to format. * @return Formatted stack trace string. */ - static std::string formatStackTrace( cpptrace::v1::stacktrace stacktrace ); + static std::string formatStackTrace( cpptrace::stacktrace const & stacktrace ); #endif }; From 197c7ee244d1074e492a78e33014425e4a1dc29f Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Tue, 5 May 2026 18:12:31 +0200 Subject: [PATCH 21/53] move include position --- src/coreComponents/common/initializeEnvironment.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreComponents/common/initializeEnvironment.cpp b/src/coreComponents/common/initializeEnvironment.cpp index 2bc60ddc860..89d071ef26c 100644 --- a/src/coreComponents/common/initializeEnvironment.cpp +++ b/src/coreComponents/common/initializeEnvironment.cpp @@ -22,11 +22,11 @@ #include "logger/ErrorHandling.hpp" #include "logger/ExternalErrorHandler.hpp" #include +#include "logger/StackTrace.hpp" // TPL includes #include #include #include -#include "logger/StackTrace.hpp" #include "umpire/util/MemoryResourceTraits.hpp" #include "umpire/util/Platform.hpp" From 506fae70ac05aea6da8498bb39992cf0cf15db45 Mon Sep 17 00:00:00 2001 From: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> Date: Tue, 5 May 2026 12:21:46 -0500 Subject: [PATCH 22/53] feat: Add reference thermal conductivity (#3959) * feat: Add reference thermal conductivity * Update reference temperature * Capture local variable for kernel launch * Update schema * Initialise thermal conductivity * Add thermal conductivity to embedded fracture solver * Add threshold to conductivity check * Update baseline in integrated tests configuration * Change test case * Updated the entry for PR #3959 with a new date and link. --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 4 +- inputFiles/singlePhaseFlow/.gitattributes | 1 + inputFiles/singlePhaseFlow/mesh_1d.vtr | 3 + ...rmalCompressible_referenceConductivity.xml | 182 ++++++++++++++++++ .../thermalSinglePhaseFlow.ats | 7 + .../SinglePhaseThermalConductivity.cpp | 54 +++++- .../SinglePhaseThermalConductivity.hpp | 15 +- .../SinglePhaseThermalConductivityBase.cpp | 5 + .../SinglePhaseThermalConductivityBase.hpp | 19 +- .../ThermalConductivityFields.hpp | 8 + .../EmbeddedSurfaceGenerator.cpp | 9 + .../surfaceGeneration/SurfaceGenerator.cpp | 9 + src/coreComponents/schema/schema.xsd.other | 2 + 14 files changed, 305 insertions(+), 15 deletions(-) create mode 100644 inputFiles/singlePhaseFlow/.gitattributes create mode 100644 inputFiles/singlePhaseFlow/mesh_1d.vtr create mode 100644 inputFiles/singlePhaseFlow/thermalCompressible_referenceConductivity.xml diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index b262b6aa27b..a21eed60480 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr4021-16339-bb862da + baseline: integratedTests/baseline_integratedTests-pr3959-16478-faf1698 allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index e1c07a01361..05c25880f29 100644 --- a/BASELINE_NOTES.md +++ b/BASELINE_NOTES.md @@ -5,12 +5,14 @@ This file is designed to track changes to the integrated test baselines. Any developer who updates the baseline ID in the .integrated_tests.yaml file is expected to create an entry in this file with the pull request number, date, and their justification for rebaselining. These notes should be in reverse-chronological order, and use the following time format: (YYYY-MM-DD). +PR #3959 (2026-05-04) +Add reference thermal conductivity + PR #4021 (2026-04-14) ===================== Add Young Modulus & Poisson import from VTK mesh PR #3883 (2026-04-10) -===================== Move PVT Driver tests from unit tests to integrated tests PR #4007 (2026-04-03) diff --git a/inputFiles/singlePhaseFlow/.gitattributes b/inputFiles/singlePhaseFlow/.gitattributes new file mode 100644 index 00000000000..507ac808a4f --- /dev/null +++ b/inputFiles/singlePhaseFlow/.gitattributes @@ -0,0 +1 @@ +mesh_1d.vtr filter=lfs diff=lfs merge=lfs -text diff --git a/inputFiles/singlePhaseFlow/mesh_1d.vtr b/inputFiles/singlePhaseFlow/mesh_1d.vtr new file mode 100644 index 00000000000..40f887362ab --- /dev/null +++ b/inputFiles/singlePhaseFlow/mesh_1d.vtr @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6df3056da5d3838b0ef835e2d73b56b1623a150b41deb1329c242b4e1a0cc18d +size 2110 diff --git a/inputFiles/singlePhaseFlow/thermalCompressible_referenceConductivity.xml b/inputFiles/singlePhaseFlow/thermalCompressible_referenceConductivity.xml new file mode 100644 index 00000000000..19c80f5194c --- /dev/null +++ b/inputFiles/singlePhaseFlow/thermalCompressible_referenceConductivity.xml @@ -0,0 +1,182 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/inputFiles/singlePhaseFlow/thermalSinglePhaseFlow.ats b/inputFiles/singlePhaseFlow/thermalSinglePhaseFlow.ats index b47f93c6527..84830049dc3 100644 --- a/inputFiles/singlePhaseFlow/thermalSinglePhaseFlow.ats +++ b/inputFiles/singlePhaseFlow/thermalSinglePhaseFlow.ats @@ -45,6 +45,13 @@ decks = [ restart_step=0, check_step=1, restartcheck_params=RestartcheckParameters(**restartcheck_params)), + TestDeck( + name="thermalCompressible_referenceConductivity", + description='Thermal reference conductivity (1D, thermal)', + partitions=((1, 1, 1),), + restart_step=6, + check_step=10, + restartcheck_params=RestartcheckParameters(**restartcheck_params)) ] generate_geos_tests(decks) diff --git a/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivity.cpp b/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivity.cpp index 85c990f83ea..84cfc3126b3 100644 --- a/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivity.cpp +++ b/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivity.cpp @@ -46,11 +46,25 @@ SinglePhaseThermalConductivity::SinglePhaseThermalConductivity( string const & n setDescription( "The reference temperature at which the conductivity components are equal to the default values" ); } +void SinglePhaseThermalConductivity::allocateConstitutiveData( Group & parent, localIndex const numPts ) +{ + SinglePhaseThermalConductivityBase::allocateConstitutiveData( parent, numPts ); + + initializeState( parent.size()); +} + +void SinglePhaseThermalConductivity::initializeState() const +{ + SinglePhaseThermalConductivityBase::initializeState(); + localIndex const size = m_referenceThermalConductivity.size( 0 ); + initializeState( size ); +} + void SinglePhaseThermalConductivity::initializeRockFluidState( arrayView2d< real64 const > const & initialPorosity ) const { + arrayView3d< real64 const > referenceThermalConductivity = m_referenceThermalConductivity.toViewConst(); arrayView3d< real64 > dEffectiveConductivity_dT = m_dEffectiveConductivity_dT.toView(); arrayView3d< real64 > effectiveConductivity = m_effectiveConductivity.toView(); - R1Tensor const defaultThermalConductivityComponents = m_defaultThermalConductivityComponents; R1Tensor const thermalConductivityGradientComponents = m_thermalConductivityGradientComponents; forAll< parallelDevicePolicy<> >( initialPorosity.size( 0 ), [=] GEOS_HOST_DEVICE ( localIndex const ei ) @@ -58,9 +72,9 @@ void SinglePhaseThermalConductivity::initializeRockFluidState( arrayView2d< real // NOTE: enforcing 1 quadrature point for( localIndex q = 0; q < 1; ++q ) { - effectiveConductivity[ei][q][0] = defaultThermalConductivityComponents[0]; - effectiveConductivity[ei][q][1] = defaultThermalConductivityComponents[1]; - effectiveConductivity[ei][q][2] = defaultThermalConductivityComponents[2]; + effectiveConductivity[ei][q][0] = referenceThermalConductivity[ei][q][0]; + effectiveConductivity[ei][q][1] = referenceThermalConductivity[ei][q][1]; + effectiveConductivity[ei][q][2] = referenceThermalConductivity[ei][q][2]; dEffectiveConductivity_dT[ei][q][0] = thermalConductivityGradientComponents[0]; dEffectiveConductivity_dT[ei][q][1] = thermalConductivityGradientComponents[1]; @@ -71,9 +85,9 @@ void SinglePhaseThermalConductivity::initializeRockFluidState( arrayView2d< real void SinglePhaseThermalConductivity::updateFromTemperature( arrayView1d< real64 const > const & temperature ) const { + arrayView3d< real64 const > referenceThermalConductivity = m_referenceThermalConductivity.toViewConst(); arrayView3d< real64 > dEffectiveConductivity_dT = m_dEffectiveConductivity_dT.toView(); arrayView3d< real64 > effectiveConductivity = m_effectiveConductivity.toView(); - R1Tensor const defaultThermalConductivityComponents = m_defaultThermalConductivityComponents; R1Tensor const thermalConductivityGradientComponents = m_thermalConductivityGradientComponents; real64 const referenceTemperature = m_referenceTemperature; @@ -84,9 +98,9 @@ void SinglePhaseThermalConductivity::updateFromTemperature( arrayView1d< real64 real64 const deltaTemperature = temperature[ei] - referenceTemperature; - effectiveConductivity[ei][q][0] = defaultThermalConductivityComponents[0] + thermalConductivityGradientComponents[0] * deltaTemperature; - effectiveConductivity[ei][q][1] = defaultThermalConductivityComponents[1] + thermalConductivityGradientComponents[1] * deltaTemperature; - effectiveConductivity[ei][q][2] = defaultThermalConductivityComponents[2] + thermalConductivityGradientComponents[2] * deltaTemperature; + effectiveConductivity[ei][q][0] = referenceThermalConductivity[ei][q][0] + thermalConductivityGradientComponents[0] * deltaTemperature; + effectiveConductivity[ei][q][1] = referenceThermalConductivity[ei][q][1] + thermalConductivityGradientComponents[1] * deltaTemperature; + effectiveConductivity[ei][q][2] = referenceThermalConductivity[ei][q][2] + thermalConductivityGradientComponents[2] * deltaTemperature; for( localIndex i=0; i<=2; i++ ) { @@ -113,6 +127,30 @@ void SinglePhaseThermalConductivity::postInputInitialization() } +void SinglePhaseThermalConductivity::initializeState( localIndex const size ) const +{ + integer constexpr numQuad = 1; // NOTE: enforcing 1 quadrature point + + arrayView3d< real64 > referenceThermalConductivity = m_referenceThermalConductivity.toView(); + R1Tensor const defaultThermalConductivityComponents = m_defaultThermalConductivityComponents; + + real64 constexpr threshold = LvArray::NumericLimits< real64 >::epsilon; + + forAll< parallelDevicePolicy<> >( size, [=] GEOS_HOST_DEVICE ( localIndex const ei ) + { + for( localIndex q = 0; q < numQuad; ++q ) + { + for( integer dim=0; dim < 3; ++dim ) + { + if( referenceThermalConductivity[ei][q][dim] < threshold ) + { + referenceThermalConductivity[ei][q][dim] = defaultThermalConductivityComponents[dim]; + } + } + } + } ); +} + REGISTER_CATALOG_ENTRY( ConstitutiveBase, SinglePhaseThermalConductivity, string const &, Group * const ) } // namespace constitutive diff --git a/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivity.hpp b/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivity.hpp index 2e65c26f48b..81431564f81 100644 --- a/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivity.hpp +++ b/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivity.hpp @@ -40,9 +40,11 @@ class SinglePhaseThermalConductivityUpdate : public SinglePhaseThermalConductivi * @param effectiveConductivity the array of cell-wise effective conductivities in the subregion * the subregion */ - SinglePhaseThermalConductivityUpdate( arrayView3d< real64 > const & effectiveConductivity, + SinglePhaseThermalConductivityUpdate( arrayView3d< real64 > const & referenceThermalConductivity, + arrayView3d< real64 > const & effectiveConductivity, arrayView3d< real64 > const & dEffectiveConductivity_dT ) - : SinglePhaseThermalConductivityBaseUpdate( effectiveConductivity, + : SinglePhaseThermalConductivityBaseUpdate( referenceThermalConductivity, + effectiveConductivity, dEffectiveConductivity_dT ) {} @@ -72,10 +74,16 @@ class SinglePhaseThermalConductivity : public SinglePhaseThermalConductivityBase virtual string getCatalogName() const override { return catalogName(); } + virtual void allocateConstitutiveData( Group & parent, localIndex const numPts ) override; + virtual void initializeRockFluidState( arrayView2d< real64 const > const & initialPorosity ) const override final; virtual void updateFromTemperature( arrayView1d< real64 const > const & temperature ) const override final; + virtual void initializeState() const override; + + void initializeState( localIndex const size ) const; + /// Type of kernel wrapper for in-kernel update using KernelWrapper = SinglePhaseThermalConductivityUpdate; @@ -85,7 +93,8 @@ class SinglePhaseThermalConductivity : public SinglePhaseThermalConductivityBase */ KernelWrapper createKernelWrapper() const { - return KernelWrapper( m_effectiveConductivity, + return KernelWrapper( m_referenceThermalConductivity, + m_effectiveConductivity, m_dEffectiveConductivity_dT ); } diff --git a/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivityBase.cpp b/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivityBase.cpp index 240a3792df4..82dd3f86aee 100644 --- a/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivityBase.cpp +++ b/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivityBase.cpp @@ -31,6 +31,7 @@ namespace constitutive SinglePhaseThermalConductivityBase::SinglePhaseThermalConductivityBase( string const & name, Group * const parent ) : ConstitutiveBase( name, parent ) { + registerField< fields::thermalconductivity::referenceThermalConductivity >( &m_referenceThermalConductivity ); registerField< fields::thermalconductivity::effectiveConductivity >( &m_effectiveConductivity ); registerField< fields::thermalconductivity::dEffectiveConductivity_dT >( &m_dEffectiveConductivity_dT ); } @@ -38,12 +39,16 @@ SinglePhaseThermalConductivityBase::SinglePhaseThermalConductivityBase( string c void SinglePhaseThermalConductivityBase::allocateConstitutiveData( Group & parent, localIndex const numPts ) { // NOTE: enforcing 1 quadrature point + m_referenceThermalConductivity.resize( 0, 1, 3 ); m_effectiveConductivity.resize( 0, 1, 3 ); m_dEffectiveConductivity_dT.resize( 0, 1, 3 ); ConstitutiveBase::allocateConstitutiveData( parent, numPts ); } +void SinglePhaseThermalConductivityBase::initializeState() const +{} + } // namespace constitutive } // namespace geos diff --git a/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivityBase.hpp b/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivityBase.hpp index 09444cd7e06..ef599ce59c2 100644 --- a/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivityBase.hpp +++ b/src/coreComponents/constitutive/thermalConductivity/SinglePhaseThermalConductivityBase.hpp @@ -55,14 +55,21 @@ class SinglePhaseThermalConductivityBaseUpdate /** * @brief Constructor for the class performing the thermal conductivity updates + * @param referenceThermalConductivity the array of cell-wise reference conductivities in the subregion * @param effectiveConductivity the array of cell-wise effective conductivities in the subregion + * @param dEffectiveConductivity_dT the array of cell-wise derivatives of the effective conductivities w.r.t. temperature in the subregion */ - SinglePhaseThermalConductivityBaseUpdate( arrayView3d< real64 > const & effectiveConductivity, + SinglePhaseThermalConductivityBaseUpdate( arrayView3d< real64 > const & referenceThermalConductivity, + arrayView3d< real64 > const & effectiveConductivity, arrayView3d< real64 > const & dEffectiveConductivity_dT ) - : m_effectiveConductivity( effectiveConductivity ), + : m_referenceThermalConductivity( referenceThermalConductivity ), + m_effectiveConductivity( effectiveConductivity ), m_dEffectiveConductivity_dT( dEffectiveConductivity_dT ) {} + /// View on the cell-wise reference conductivities + arrayView3d< real64 > m_referenceThermalConductivity; + /// View on the cell-wise effective conductivities arrayView3d< real64 > m_effectiveConductivity; @@ -145,8 +152,16 @@ class SinglePhaseThermalConductivityBase : public ConstitutiveBase */ arrayView3d< real64 const > dEffectiveConductivity_dT() const { return m_dEffectiveConductivity_dT; } + /** + * @brief Initialize the thermal conductivity state + */ + virtual void initializeState() const; + protected: + /// cell-wise reference conductivities in the subregion + array3d< real64 > m_referenceThermalConductivity; + /// cell-wise effective conductivities in the subregion array3d< real64 > m_effectiveConductivity; diff --git a/src/coreComponents/constitutive/thermalConductivity/ThermalConductivityFields.hpp b/src/coreComponents/constitutive/thermalConductivity/ThermalConductivityFields.hpp index a04c1a2bffc..35302d1e321 100644 --- a/src/coreComponents/constitutive/thermalConductivity/ThermalConductivityFields.hpp +++ b/src/coreComponents/constitutive/thermalConductivity/ThermalConductivityFields.hpp @@ -48,6 +48,14 @@ DECLARE_FIELD( dEffectiveConductivity_dT, WRITE_AND_READ, "Derivative of effective conductivity w.r.t. temperature" ); +DECLARE_FIELD( referenceThermalConductivity, + "referenceThermalConductivity", + array3d< real64 >, + 0, + LEVEL_0, + WRITE_AND_READ, + "Reference thermal conductivity" ); + DECLARE_FIELD( rockThermalConductivity, "rockThermalConductivity", array3d< real64 >, diff --git a/src/coreComponents/physicsSolvers/surfaceGeneration/EmbeddedSurfaceGenerator.cpp b/src/coreComponents/physicsSolvers/surfaceGeneration/EmbeddedSurfaceGenerator.cpp index 4af9efde608..d96124bf8c6 100644 --- a/src/coreComponents/physicsSolvers/surfaceGeneration/EmbeddedSurfaceGenerator.cpp +++ b/src/coreComponents/physicsSolvers/surfaceGeneration/EmbeddedSurfaceGenerator.cpp @@ -28,6 +28,7 @@ #include "mesh/MeshFields.hpp" #include "mesh/utilities/ComputationalGeometry.hpp" #include "mesh/utilities/CIcomputationKernel.hpp" +#include "constitutive/thermalConductivity/SinglePhaseThermalConductivityBase.hpp" #include "physicsSolvers/solidMechanics/kernels/SolidMechanicsLagrangianFEMKernels.hpp" #include "mesh/simpleGeometricObjects/GeometricObjectManager.hpp" #include "mesh/simpleGeometricObjects/Rectangle.hpp" @@ -283,6 +284,14 @@ real64 EmbeddedSurfaceGenerator::solverStep( real64 const & GEOS_UNUSED_PARAM( t gravityCoef[ ei ] = LvArray::tensorOps::AiBi< 3 >( elemCenter[ ei ], gravVector ); } ); } + + string const thermalCondModelName = getConstitutiveName< SinglePhaseThermalConductivityBase >( fractureSubRegion ); + if( !thermalCondModelName.empty() ) + { + // if a thermal conductivity model exists we need to set the initial value to something meaningful + SinglePhaseThermalConductivityBase & thermalCondModel = getConstitutiveModel< SinglePhaseThermalConductivityBase >( fractureSubRegion, thermalCondModelName ); + thermalCondModel.initializeState(); + } } ); return rval; diff --git a/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp b/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp index 2da482cf3ea..8e02b388405 100644 --- a/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp +++ b/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp @@ -28,6 +28,7 @@ #include "finiteVolume/FluxApproximationBase.hpp" #include "mesh/SurfaceElementRegion.hpp" #include "mesh/utilities/ComputationalGeometry.hpp" +#include "constitutive/thermalConductivity/SinglePhaseThermalConductivityBase.hpp" #include "physicsSolvers/solidMechanics/SolidMechanicsFields.hpp" #include "physicsSolvers/solidMechanics/SolidMechanicsLagrangianFEM.hpp" #include "physicsSolvers/solidMechanics/kernels/SolidMechanicsLagrangianFEMKernels.hpp" @@ -574,6 +575,14 @@ real64 SurfaceGenerator::solverStep( real64 const & time_n, PermeabilityBase & permModel = getConstitutiveModel< PermeabilityBase >( fractureSubRegion, permModelName ); permModel.initializeState(); } + + string const thermalCondModelName = getConstitutiveName< SinglePhaseThermalConductivityBase >( fractureSubRegion ); + if( !thermalCondModelName.empty() ) + { + // if a thermal conductivity model exists we need to set the intial value to something meaningful + SinglePhaseThermalConductivityBase & thermalCondModel = getConstitutiveModel< SinglePhaseThermalConductivityBase >( fractureSubRegion, thermalCondModelName ); + thermalCondModel.initializeState(); + } } ); return rval; diff --git a/src/coreComponents/schema/schema.xsd.other b/src/coreComponents/schema/schema.xsd.other index c7434b7b99c..5bcdf600de2 100644 --- a/src/coreComponents/schema/schema.xsd.other +++ b/src/coreComponents/schema/schema.xsd.other @@ -3264,6 +3264,8 @@ A field can represent a physical variable. (pressure, temperature, global compos + + From 05b7dfc5e8cbe42998081cf52c85f01e070376b5 Mon Sep 17 00:00:00 2001 From: Jacques Franc <49998870+jafranc@users.noreply.github.com> Date: Thu, 7 May 2026 00:41:39 +0200 Subject: [PATCH 23/53] fix: moved FieldApplicator (#4016) * moved FieldApplicator * Clean up fwd declare Removed unused class declarations from FieldApplicator.hpp. --------- Co-authored-by: Omar Duran --- src/coreComponents/physicsSolvers/CMakeLists.txt | 2 -- .../physicsSolvers/multiphysics/CMakeLists.txt | 2 ++ .../{ => multiphysics}/FieldApplicator.cpp | 5 ----- .../{ => multiphysics}/FieldApplicator.hpp | 12 +++++------- 4 files changed, 7 insertions(+), 14 deletions(-) rename src/coreComponents/physicsSolvers/{ => multiphysics}/FieldApplicator.cpp (98%) rename src/coreComponents/physicsSolvers/{ => multiphysics}/FieldApplicator.hpp (94%) diff --git a/src/coreComponents/physicsSolvers/CMakeLists.txt b/src/coreComponents/physicsSolvers/CMakeLists.txt index dbf4df9e509..ee5c8ff2a0b 100644 --- a/src/coreComponents/physicsSolvers/CMakeLists.txt +++ b/src/coreComponents/physicsSolvers/CMakeLists.txt @@ -24,7 +24,6 @@ Contains: # Specify solver headers # set( physicsSolversBase_headers - FieldApplicator.hpp FieldStatisticsBase.hpp LinearSolverParameters.hpp NonlinearSolverParameters.hpp @@ -35,7 +34,6 @@ set( physicsSolversBase_headers # Specify solver sources # set( physicsSolversBase_sources - FieldApplicator.cpp LinearSolverParameters.cpp NonlinearSolverParameters.cpp PhysicsSolverBase.cpp diff --git a/src/coreComponents/physicsSolvers/multiphysics/CMakeLists.txt b/src/coreComponents/physicsSolvers/multiphysics/CMakeLists.txt index 82c1d57e4ee..976f03d0c6c 100644 --- a/src/coreComponents/physicsSolvers/multiphysics/CMakeLists.txt +++ b/src/coreComponents/physicsSolvers/multiphysics/CMakeLists.txt @@ -23,6 +23,7 @@ set( multiPhysicsSolvers_headers CoupledReservoirAndWellsBase.hpp CoupledReservoirAndWellKernels.hpp CoupledSolver.hpp + FieldApplicator.hpp PoromechanicsSolver.hpp PoromechanicsConformingFractures.hpp FlowProppantTransportSolver.hpp @@ -70,6 +71,7 @@ set( multiPhysicsSolvers_sources CoupledReservoirAndWellsBase.cpp FlowProppantTransportSolver.cpp HydrofractureSolver.cpp + FieldApplicator.cpp MultiphasePoromechanics.cpp OneWayCoupledFractureFlowContactMechanics.cpp MultiphasePoromechanicsConformingFractures.cpp diff --git a/src/coreComponents/physicsSolvers/FieldApplicator.cpp b/src/coreComponents/physicsSolvers/multiphysics/FieldApplicator.cpp similarity index 98% rename from src/coreComponents/physicsSolvers/FieldApplicator.cpp rename to src/coreComponents/physicsSolvers/multiphysics/FieldApplicator.cpp index 0493f4b4347..9b139e775d6 100644 --- a/src/coreComponents/physicsSolvers/FieldApplicator.cpp +++ b/src/coreComponents/physicsSolvers/multiphysics/FieldApplicator.cpp @@ -17,19 +17,14 @@ #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" diff --git a/src/coreComponents/physicsSolvers/FieldApplicator.hpp b/src/coreComponents/physicsSolvers/multiphysics/FieldApplicator.hpp similarity index 94% rename from src/coreComponents/physicsSolvers/FieldApplicator.hpp rename to src/coreComponents/physicsSolvers/multiphysics/FieldApplicator.hpp index f6c25042502..ce082cfec79 100644 --- a/src/coreComponents/physicsSolvers/FieldApplicator.hpp +++ b/src/coreComponents/physicsSolvers/multiphysics/FieldApplicator.hpp @@ -21,17 +21,15 @@ #define SRC_CORECOMPONENTS_PHYSICSSOLVERS_FIELDAPPLICATOR_HPP_ #include "events/tasks/TaskBase.hpp" +#include "fieldSpecification/EquilibriumInitialCondition.hpp" +#include "functions/FunctionManager.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseBase.hpp" +#include "physicsSolvers/fluidFlow/FlowSolverBase.hpp" +#include "mesh/ElementSubRegionBase.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. From 5cec03f0bb641acdaadada3980b3a9517bf66b9c Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Thu, 7 May 2026 14:36:16 +0200 Subject: [PATCH 24/53] document signalSafeStackTrace() reverting to LvArray --- src/coreComponents/common/logger/StackTrace.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/coreComponents/common/logger/StackTrace.hpp b/src/coreComponents/common/logger/StackTrace.hpp index e09cce7a0e5..04d04978431 100644 --- a/src/coreComponents/common/logger/StackTrace.hpp +++ b/src/coreComponents/common/logger/StackTrace.hpp @@ -48,6 +48,7 @@ class StackTrace /** * @brief Get a stack trace from a context where signal-safety is required. * @return The stack trace as a string. + * @note Implementation reverts back to LvArray::system stack trace for signal-safety */ static std::string signalSafeStackTrace(); From 86ab9c6d4e3ec9cd0c76daf38490a45fc29df5fa Mon Sep 17 00:00:00 2001 From: Randolph Settgast Date: Thu, 7 May 2026 07:31:15 -0700 Subject: [PATCH 25/53] update CI images (#4043) Update CI images, runners, and host-config coverage This updates CI to the current Ubuntu/Rocky CUDA and CPU images, refreshes LLNL host-configs for Dane, Matrix, and Tuolumne, and adds reusable workflow support for per-runner CUDA architecture selection and ctest parallelism. The devcontainer now uses the Ubuntu 24.04 gcc13 image with TPL tag `349-1014`. Active configurations: - Code style / documentation: `geosx/ubuntu24.04-gcc13` - CPU: Ubuntu 24.04 gcc13 Debug, Ubuntu 24.04 gcc13 Release, Ubuntu 24.04 clang20 Release no-bounds, Rocky Linux 8 gcc12, Rocky Linux 8 gcc13, Rocky Linux 8 clang19, Rocky Linux 9 clang22 - Integrated tests: Ubuntu 24.04 gcc12, Release, Hypre ON, Trilinos OFF, bounds ON, 32 cores / 256 GB, label-gated by `ci: run integrated tests` - CUDA: Ubuntu 24.04 clang19 CUDA 12.9.1 Debug, Ubuntu 24.04 gcc13 CUDA 12.9.1, Ubuntu 24.04 clang19 CUDA 12.9.1, Rocky Linux 8 gcc13 CUDA 12.9.1 - CUDA architecture mapping: GEOS-DEV `streak2 -> 86`, EarthFlowAI `thinkpad -> 120` - LLNL host-configs: Dane gcc 12.1.1, Dane gcc 13.3.1, Dane llvm 14.0.6, Dane llvm 19.1.3, Matrix gcc 12.1.1 CUDA 12.6.0, Matrix gcc 13.3.1 CUDA 12.9.1, Matrix llvm 14.0.6 CUDA 12.6.0, Matrix llvm 19.1.3 CUDA 12.9.1, Tuolumne CCE 20.0.0 ROCm 6.4.3, Tuolumne llvm-amdgpu ROCm 6.4.3 Disabled entries and re-enable conditions: - Ubuntu 24.04 gcc12 CPU matrix: re-enable after more capacity is available. - Ubuntu 24.04 clang19 CPU matrix: disabled because it keeps missing `sccache`; re-enable after the clang19 image has consistent `sccache` hits. - Rocky Linux 8 clang19 CUDA 12.9.1 matrix: re-enable after more compute capacity is available. - Code coverage job: kept commented; re-enable OOM 137 failure is fixed. --- .devcontainer/Dockerfile | 2 +- .devcontainer/devcontainer.json | 2 +- .github/ci/README.md | 5 + .github/ci/orgs/EarthFlowAI.json | 1 + .github/ci/orgs/GEOS-DEV.json | 1 + .github/workflows/build_and_test.yml | 16 +- .github/workflows/ci_tests.yml | 217 +++++++++++------- .../dane-toss_4_x86_64_ib-gcc@12.1.1.cmake | 52 ++--- .../dane-toss_4_x86_64_ib-gcc@13.3.1.cmake | 56 ++--- .../dane-toss_4_x86_64_ib-llvm@14.0.6.cmake | 52 ++--- .../dane-toss_4_x86_64_ib-llvm@19.1.3.cmake | 52 ++--- ...s_4_x86_64_ib-gcc@12.1.1-cuda@12.6.0.cmake | 50 ++-- ...s_4_x86_64_ib-gcc@13.3.1-cuda@12.9.1.cmake | 54 ++--- ..._4_x86_64_ib-llvm@14.0.6-cuda@12.6.0.cmake | 50 ++-- ..._4_x86_64_ib-llvm@19.1.3-cuda@12.9.1.cmake | 50 ++-- ...x86_64_ib_cray-cce@20.0.0-rocm@6.4.3.cmake | 48 ++-- ...ib_cray-llvm-amdgpu@6.4.3-rocm@6.4.3.cmake | 48 ++-- .../poromechanics/poroElasticCoupling.ats | 105 ++++++++- scripts/ci_build_and_test_in_container.sh | 88 ++++++- scripts/setupPythonEnvironment.bash | 10 +- src/cmake/GeosxOptions.cmake | 9 + src/coreComponents/schema/schema.xsd.other | 4 +- 22 files changed, 577 insertions(+), 395 deletions(-) diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index 8cad1411244..69ac2cc78ba 100644 --- a/.devcontainer/Dockerfile +++ b/.devcontainer/Dockerfile @@ -2,7 +2,7 @@ # If you are building the current `Dockerfile` to use codespaces in the cloud, # you most likely want to define this variable in the `.devcontainer/devcontainer.json` file. ARG GEOS_TPL_TAG -FROM docker.io/geosx/ubuntu20.04-gcc10:${GEOS_TPL_TAG} +FROM docker.io/geosx/ubuntu24.04-gcc13:${GEOS_TPL_TAG} RUN apt-get update RUN apt-get install -y \ diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index e5913100b8d..692ecc9d08e 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -2,7 +2,7 @@ "build": { "dockerfile": "Dockerfile", "args": { - "GEOS_TPL_TAG": "344-968" + "GEOS_TPL_TAG": "349-1014" } }, "runArgs": [ diff --git a/.github/ci/README.md b/.github/ci/README.md index 2662cf5d3ce..6b37d03012c 100644 --- a/.github/ci/README.md +++ b/.github/ci/README.md @@ -55,6 +55,11 @@ Required fields (all of them, always): the prefix before the first `-`, so a runner label like `streak2-32core` will reuse the `streak2` entry. Use `{}` for runners that do not need an LLNL-style outbound cert bundle. +- `runner_cuda_architectures` + Map keyed by runner label, not by workflow role. Each value is forwarded to CMake as + `CMAKE_CUDA_ARCHITECTURES` for CUDA jobs on that runner. The same exact-match then prefix + fallback used by `runner_ca_bundle_host_paths` applies. Example: `{"streak2": "86"}`. + - `runners` Map from runner role to runner label. Required roles: - `default` diff --git a/.github/ci/orgs/EarthFlowAI.json b/.github/ci/orgs/EarthFlowAI.json index 36a01decd7f..d3653a97192 100644 --- a/.github/ci/orgs/EarthFlowAI.json +++ b/.github/ci/orgs/EarthFlowAI.json @@ -5,6 +5,7 @@ "artifact_public_url_base": "https://pub-17b272fb651e459ca81dd0fd457099ed.r2.dev", "artifact_public_url_bucket_scoped": true, "runner_ca_bundle_host_paths": {}, + "runner_cuda_architectures": { "thinkpad": "120" }, "runners": { "default": "ubuntu-22.04", "cpu_heavy": "32core", diff --git a/.github/ci/orgs/GEOS-DEV.json b/.github/ci/orgs/GEOS-DEV.json index 7700b33d6d6..9ad891e74a0 100644 --- a/.github/ci/orgs/GEOS-DEV.json +++ b/.github/ci/orgs/GEOS-DEV.json @@ -5,6 +5,7 @@ "artifact_public_url_base": "https://storage.googleapis.com", "artifact_public_url_bucket_scoped": false, "runner_ca_bundle_host_paths": { "streak2": "/etc/pki/tls/certs/ca-bundle.crt" }, + "runner_cuda_architectures": { "streak2": "86" }, "runners": { "default": "ubuntu-22.04", "cpu_heavy": "streak2", diff --git a/.github/workflows/build_and_test.yml b/.github/workflows/build_and_test.yml index 08e7a8d8370..03e502ae485 100644 --- a/.github/workflows/build_and_test.yml +++ b/.github/workflows/build_and_test.yml @@ -16,10 +16,18 @@ on: CMAKE_BUILD_TYPE: required: true type: string + CMAKE_CUDA_ARCHITECTURES: + required: false + type: string + default: '' CODE_COVERAGE: required: false type: boolean default: false + CTEST_PARALLEL_LEVEL: + required: false + type: string + default: '' DOCKER_IMAGE_TAG: required: true type: string @@ -626,6 +634,9 @@ jobs: if [ ! -z "${{ inputs.GEOS_ENABLE_BOUNDS_CHECK }}" ]; then script_args+=(--geos-enable-bounds-check "${{ inputs.GEOS_ENABLE_BOUNDS_CHECK }}") fi + if [ ! -z "${{ inputs.CMAKE_CUDA_ARCHITECTURES }}" ]; then + script_args+=(--cmake-cuda-architectures "${{ inputs.CMAKE_CUDA_ARCHITECTURES }}") + fi # The linear algebra environment variables (ENABLE_HYPRE, ENABLE_HYPRE_DEVICE & ENABLE_TRILINOS) # are passed as scripts parameters. Specific care must be taken to be sure @@ -670,6 +681,10 @@ jobs: docker_args+=(--name ${CONTAINER_NAME}) + if [[ -n "${{ inputs.CTEST_PARALLEL_LEVEL }}" ]]; then + script_args+=(--ctest-parallel-level "${{ inputs.CTEST_PARALLEL_LEVEL }}") + fi + if ${{ inputs.CODE_COVERAGE }} == 'true'; then script_args+=(--code-coverage) fi @@ -859,4 +874,3 @@ jobs: -v "${GITHUB_WORKSPACE}:/tmp/geos" \ alpine:3.20 \ sh -lc 'rm -rf /tmp/geos/* /tmp/geos/.[!.]* /tmp/geos/..?* || true' - diff --git a/.github/workflows/ci_tests.yml b/.github/workflows/ci_tests.yml index 761296099db..6b553f07160 100644 --- a/.github/workflows/ci_tests.yml +++ b/.github/workflows/ci_tests.yml @@ -84,6 +84,7 @@ jobs: SCCACHE_PROFILE: ${{ steps.resolve.outputs.SCCACHE_PROFILE }} INTEGRATED_TESTS_ARTIFACT_BUCKET_PATH: ${{ steps.resolve.outputs.INTEGRATED_TESTS_ARTIFACT_BUCKET_PATH }} DOCKER_CA_BUNDLE_HOST_PATHS_JSON: ${{ steps.resolve.outputs.DOCKER_CA_BUNDLE_HOST_PATHS_JSON }} + CMAKE_CUDA_ARCHITECTURES_JSON: ${{ steps.resolve.outputs.CMAKE_CUDA_ARCHITECTURES_JSON }} RUNNER_LABELS_JSON: ${{ steps.resolve.outputs.RUNNER_LABELS_JSON }} ARTIFACT_UPLOAD_COMMAND: ${{ steps.resolve.outputs.ARTIFACT_UPLOAD_COMMAND }} ARTIFACT_UPLOAD_PRE_COMMAND: ${{ steps.resolve.outputs.ARTIFACT_UPLOAD_PRE_COMMAND }} @@ -141,6 +142,8 @@ jobs: and (.artifact_public_url_bucket_scoped | type == "boolean") and (.runner_ca_bundle_host_paths | type == "object") and (.runner_ca_bundle_host_paths | all(.[]; type == "string")) + and (.runner_cuda_architectures | type == "object") + and (.runner_cuda_architectures | all(.[]; type == "string" and length > 0)) and (.runners | type == "object") and (.runners.default | type == "string" and length > 0) and (.runners.cpu_heavy | type == "string" and length > 0) @@ -148,7 +151,7 @@ jobs: and (.runners.code_coverage | type == "string" and length > 0) and (.runners.cuda | type == "string" and length > 0) ' <<< "${ORG_CONFIG_JSON}" >/dev/null; then - echo "::error::${ORG_CONFIG_PATH} must define every required field: storage_provider, sccache_profile, integrated_tests_artifact_bucket_path, artifact_public_url_base, artifact_public_url_bucket_scoped, runner_ca_bundle_host_paths, and runners.{default,cpu_heavy,integrated_tests,code_coverage,cuda}. See .github/ci/README.md for the full schema." + echo "::error::${ORG_CONFIG_PATH} must define every required field: storage_provider, sccache_profile, integrated_tests_artifact_bucket_path, artifact_public_url_base, artifact_public_url_bucket_scoped, runner_ca_bundle_host_paths, runner_cuda_architectures, and runners.{default,cpu_heavy,integrated_tests,code_coverage,cuda}. See .github/ci/README.md for the full schema." exit 1 fi @@ -160,6 +163,7 @@ jobs: ARTIFACT_PUBLIC_URL_BUCKET_SCOPED="$(jq -r '.artifact_public_url_bucket_scoped' <<< "${ORG_CONFIG_JSON}")" RUNNER_LABELS_JSON="$(jq -c '.runners' <<< "${ORG_CONFIG_JSON}")" RUNNER_CA_BUNDLE_HOST_PATHS_JSON="$(jq -c '.runner_ca_bundle_host_paths' <<< "${ORG_CONFIG_JSON}")" + RUNNER_CUDA_ARCHITECTURES_JSON="$(jq -c '.runner_cuda_architectures' <<< "${ORG_CONFIG_JSON}")" # --- Resolve per-runner-role CA bundle paths. --- # Each runner role picks up the bundle path for its label; if no exact match, @@ -180,6 +184,30 @@ jobs: }' )" + # --- Resolve CUDA architectures by runner role. --- + # Like CA bundle paths, CUDA architectures are keyed by runner label and use prefix fallback. + CMAKE_CUDA_ARCHITECTURES_JSON="$(jq -cn \ + --argjson runners "${RUNNER_LABELS_JSON}" \ + --argjson cuda_architectures "${RUNNER_CUDA_ARCHITECTURES_JSON}" ' + def resolve_arch($runner_label): + ($cuda_architectures[$runner_label] + // (($runner_label | split("-")[0]) as $runner_prefix | $cuda_architectures[$runner_prefix]) + // ""); + { + default: resolve_arch($runners.default), + cpu_heavy: resolve_arch($runners.cpu_heavy), + integrated_tests: resolve_arch($runners.integrated_tests), + code_coverage: resolve_arch($runners.code_coverage), + cuda: resolve_arch($runners.cuda) + }' + )" + + CUDA_RUNNER_LABEL="$(jq -r '.cuda' <<< "${RUNNER_LABELS_JSON}")" + if ! jq -e '.cuda | type == "string" and length > 0' <<< "${CMAKE_CUDA_ARCHITECTURES_JSON}" >/dev/null; then + echo "::error::${ORG_CONFIG_PATH} must define runner_cuda_architectures for CUDA runner '${CUDA_RUNNER_LABEL}'." + exit 1 + fi + # --- Load and validate the provider file. --- # storage_provider names a file under .github/ci/providers/. # Restrict the allowed characters so the provider name cannot escape the directory. @@ -218,6 +246,7 @@ jobs: echo "SCCACHE_PROFILE=${SCCACHE_PROFILE}" echo "INTEGRATED_TESTS_ARTIFACT_BUCKET_PATH=${INTEGRATED_TESTS_ARTIFACT_BUCKET_PATH}" echo "DOCKER_CA_BUNDLE_HOST_PATHS_JSON=${DOCKER_CA_BUNDLE_HOST_PATHS_JSON}" + echo "CMAKE_CUDA_ARCHITECTURES_JSON=${CMAKE_CUDA_ARCHITECTURES_JSON}" echo "RUNNER_LABELS_JSON=${RUNNER_LABELS_JSON}" echo "ARTIFACT_UPLOAD_COMMAND<<__EOF__" printf '%s\n' "${ARTIFACT_UPLOAD_COMMAND}" @@ -288,7 +317,7 @@ jobs: CMAKE_BUILD_TYPE: Release DOCKER_IMAGE_TAG: ${{ needs.is_not_draft_pull_request.outputs.DOCKER_IMAGE_TAG }} HOST_CONFIG: /spack-generated.cmake - DOCKER_REPOSITORY: geosx/ubuntu20.04-gcc9 + DOCKER_REPOSITORY: geosx/ubuntu24.04-gcc13 RUNS_ON: ubuntu-22.04 USE_SCCACHE: false @@ -302,75 +331,102 @@ jobs: fail-fast : false matrix: include: - - name: Ubuntu (20.04, gcc 9.4.0, open-mpi 4.0.3) - CMAKE_BUILD_TYPE: Release - DOCKER_REPOSITORY: geosx/ubuntu20.04-gcc9 - BUILD_SHARED_LIBS: ON - ENABLE_HYPRE: OFF - ENABLE_TRILINOS: ON - GEOS_ENABLE_BOUNDS_CHECK: ON - HOST_CONFIG: /spack-generated.cmake - - - name: Ubuntu debug (20.04, gcc 10.5.0, open-mpi 4.0.3) - github codespaces + # - name: Ubuntu 24.04 - gcc 12 + # CMAKE_BUILD_TYPE: Release + # BUILD_AND_TEST_CLI_ARGS: "--use-native-architecture" + # DOCKER_REPOSITORY: geosx/ubuntu24.04-gcc12 + # GCP_BUCKET: geosx/ubuntu24.04-gcc12 + # BUILD_SHARED_LIBS: ON + # ENABLE_HYPRE: ON + # ENABLE_TRILINOS: OFF + # GEOS_ENABLE_BOUNDS_CHECK: ON + # RUNNER_KEY: cpu_heavy + # NPROC: 8 + # DOCKER_RUN_ARGS: "--cpus=8 --memory=192g" + # HOST_CONFIG: /spack-generated.cmake + + - name: Ubuntu 24.04 - gcc 13 debug BUILD_AND_TEST_CLI_ARGS: "--no-run-unit-tests" CMAKE_BUILD_TYPE: Debug - DOCKER_REPOSITORY: geosx/ubuntu20.04-gcc10 + DOCKER_REPOSITORY: geosx/ubuntu24.04-gcc13 BUILD_SHARED_LIBS: ON - ENABLE_HYPRE: OFF - ENABLE_TRILINOS: ON + ENABLE_HYPRE: ON + ENABLE_TRILINOS: OFF GEOS_ENABLE_BOUNDS_CHECK: ON # Resolved from .github/ci/orgs/.json. RUNNER_KEY: cpu_heavy - NPROC: 8 - DOCKER_RUN_ARGS: "--cpus=8 --memory=256g" - + NPROC: 4 + DOCKER_RUN_ARGS: "--cpus=8 --memory=192g" HOST_CONFIG: /spack-generated.cmake - - name: Ubuntu (20.04, gcc 10.5.0, open-mpi 4.0.3) - github codespaces + - name: Ubuntu 24.04 - gcc 13 CMAKE_BUILD_TYPE: Release - DOCKER_REPOSITORY: geosx/ubuntu20.04-gcc10 + DOCKER_REPOSITORY: geosx/ubuntu24.04-gcc13 + GCP_BUCKET: geosx/ubuntu24.04-gcc13 BUILD_SHARED_LIBS: ON - ENABLE_HYPRE: OFF - ENABLE_TRILINOS: ON + ENABLE_HYPRE: ON + ENABLE_TRILINOS: OFF GEOS_ENABLE_BOUNDS_CHECK: ON HOST_CONFIG: /spack-generated.cmake - - name: Ubuntu (22.04, gcc 11.4.0, open-mpi 4.1.2) + # this keeps missing sccache so we are skipping it for now. + # - name: Ubuntu 24.04 - clang 19 + # CMAKE_BUILD_TYPE: Release + # BUILD_AND_TEST_CLI_ARGS: "--no-run-unit-tests" + # DOCKER_REPOSITORY: geosx/ubuntu24.04-clang19 + # ENABLE_HYPRE: ON + # ENABLE_TRILINOS: OFF + # BUILD_SHARED_LIBS: ON + # GEOS_ENABLE_BOUNDS_CHECK: ON + # HOST_CONFIG: /spack-generated.cmake + + - name: Ubuntu 24.04 - clang 20 - NO BOUNDS CHECK CMAKE_BUILD_TYPE: Release - DOCKER_REPOSITORY: geosx/ubuntu22.04-gcc11 + BUILD_AND_TEST_CLI_ARGS: "--no-run-unit-tests" + DOCKER_REPOSITORY: geosx/ubuntu24.04-clang20 ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF BUILD_SHARED_LIBS: ON GEOS_ENABLE_BOUNDS_CHECK: OFF HOST_CONFIG: /spack-generated.cmake - - name: Ubuntu (22.04, gcc 12.3.0, open-mpi 4.1.2) + - name: Rocky Linux 8 - gcc 12 CMAKE_BUILD_TYPE: Release - DOCKER_REPOSITORY: geosx/ubuntu22.04-gcc12 + DOCKER_REPOSITORY: geosx/rockylinux8-gcc12 ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF BUILD_SHARED_LIBS: ON GEOS_ENABLE_BOUNDS_CHECK: ON HOST_CONFIG: /spack-generated.cmake - - name: Ubuntu (22.04, gcc 12.3.0, open-mpi 4.1.2, +hypredrive) + - name: Rocky Linux 8 - gcc 13 CMAKE_BUILD_TYPE: Release - DOCKER_REPOSITORY: geosx/ubuntu22.04-gcc12-hypredrive + DOCKER_REPOSITORY: geosx/rockylinux8-gcc13 ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF BUILD_SHARED_LIBS: ON GEOS_ENABLE_BOUNDS_CHECK: ON HOST_CONFIG: /spack-generated.cmake - - name: Ubuntu (22.04, gcc 12.3.0, open-mpi 4.1.2) - NO BOUNDS CHECK + - name: Rocky Linux 8 - clang 19 CMAKE_BUILD_TYPE: Release - DOCKER_REPOSITORY: geosx/ubuntu22.04-gcc12 + BUILD_AND_TEST_CLI_ARGS: "--no-run-unit-tests" + DOCKER_REPOSITORY: geosx/rockylinux8-clang19 ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF BUILD_SHARED_LIBS: ON - GEOS_ENABLE_BOUNDS_CHECK: OFF + GEOS_ENABLE_BOUNDS_CHECK: ON HOST_CONFIG: /spack-generated.cmake + - name: Rocky Linux 9 - clang 22 + CMAKE_BUILD_TYPE: Release + BUILD_AND_TEST_CLI_ARGS: "--no-run-unit-tests" + DOCKER_REPOSITORY: geosx/rockylinux9-clang22 + ENABLE_HYPRE: ON + ENABLE_TRILINOS: OFF + BUILD_SHARED_LIBS: ON + GEOS_ENABLE_BOUNDS_CHECK: ON + HOST_CONFIG: /spack-generated.cmake uses: ./.github/workflows/build_and_test.yml with: @@ -401,11 +457,11 @@ jobs: uses: ./.github/workflows/build_and_test.yml secrets: inherit with: - BUILD_AND_TEST_CLI_ARGS: --build-exe-only + BUILD_AND_TEST_CLI_ARGS: "--build-exe-only" BUILD_TYPE: integrated_tests CMAKE_BUILD_TYPE: Release DOCKER_IMAGE_TAG: ${{ needs.is_not_draft_pull_request.outputs.DOCKER_IMAGE_TAG }} - DOCKER_REPOSITORY: geosx/ubuntu22.04-gcc12 + DOCKER_REPOSITORY: geosx/ubuntu24.04-gcc12 ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF GEOS_ENABLE_BOUNDS_CHECK: ON @@ -420,7 +476,7 @@ jobs: DOCKER_CA_BUNDLE_HOST_PATH: ${{ fromJSON(needs.resolve_ci_provider.outputs.DOCKER_CA_BUNDLE_HOST_PATHS_JSON || '{}').integrated_tests || '' }} RUNS_ON: ${{ fromJSON(needs.resolve_ci_provider.outputs.RUNNER_LABELS_JSON).integrated_tests }} NPROC: 32 - DOCKER_RUN_ARGS: "--cpus=32 --memory=384g" + DOCKER_RUN_ARGS: "--cpus=32 --memory=256g" REQUIRED_LABEL: "ci: run integrated tests" LOCAL_BASELINE_DIR: /data/GEOS/baselines HOST_CONFIG: /spack-generated.cmake @@ -440,27 +496,27 @@ jobs: - name: Check that the baseline logs are modified if rebaselines are detected run: "scripts/check_baseline_log.sh" - code_coverage: - needs: - - is_not_draft_pull_request - - resolve_ci_provider - uses: ./.github/workflows/build_and_test.yml - secrets: inherit - with: - BUILD_AND_TEST_CLI_ARGS: "--no-run-unit-tests" - CMAKE_BUILD_TYPE: Debug - CODE_COVERAGE: true - DOCKER_IMAGE_TAG: ${{ needs.is_not_draft_pull_request.outputs.DOCKER_IMAGE_TAG }} - DOCKER_REPOSITORY: geosx/ubuntu22.04-gcc11 - ENABLE_HYPRE: ON - ENABLE_TRILINOS: OFF - SCCACHE_PROFILE: ${{ needs.resolve_ci_provider.outputs.SCCACHE_PROFILE }} - RUNS_ON: ${{ fromJSON(needs.resolve_ci_provider.outputs.RUNNER_LABELS_JSON).code_coverage }} - DOCKER_CA_BUNDLE_HOST_PATH: ${{ fromJSON(needs.resolve_ci_provider.outputs.DOCKER_CA_BUNDLE_HOST_PATHS_JSON || '{}').code_coverage || '' }} - REQUIRED_LABEL: "ci: run code coverage" - HOST_CONFIG: /spack-generated.cmake - NPROC: 8 - DOCKER_RUN_ARGS: "--cpus=8 --memory=256g" + # code_coverage: + # needs: + # - is_not_draft_pull_request + # - resolve_ci_provider + # uses: ./.github/workflows/build_and_test.yml + # secrets: inherit + # with: + # BUILD_AND_TEST_CLI_ARGS: "--no-run-unit-tests" + # CMAKE_BUILD_TYPE: Debug + # CODE_COVERAGE: true + # DOCKER_IMAGE_TAG: ${{ needs.is_not_draft_pull_request.outputs.DOCKER_IMAGE_TAG }} + # DOCKER_REPOSITORY: geosx/ubuntu24.04-gcc13 + # ENABLE_HYPRE: ON + # ENABLE_TRILINOS: OFF + # SCCACHE_PROFILE: ${{ needs.resolve_ci_provider.outputs.SCCACHE_PROFILE }} + # RUNS_ON: ${{ fromJSON(needs.resolve_ci_provider.outputs.RUNNER_LABELS_JSON).code_coverage }} + # DOCKER_CA_BUNDLE_HOST_PATH: ${{ fromJSON(needs.resolve_ci_provider.outputs.DOCKER_CA_BUNDLE_HOST_PATHS_JSON || '{}').code_coverage || '' }} + # REQUIRED_LABEL: "ci: run code coverage" + # HOST_CONFIG: /spack-generated.cmake + # NPROC: 4 + # DOCKER_RUN_ARGS: "--cpus=8 --memory=256g" # mac_builds: @@ -485,11 +541,11 @@ jobs: fail-fast : false matrix: include: - - name: Ubuntu CUDA debug (20.04, clang 10.0.0 + gcc 9.4.0, open-mpi 4.0.3, cuda-11.8.89) + - name: Ubuntu 24.04 - clang 19 + CUDA 12.9.1 debug BUILD_AND_TEST_CLI_ARGS: "--build-exe-only --no-install-schema" CMAKE_BUILD_TYPE: Debug BUILD_GENERATOR: "--ninja" - DOCKER_REPOSITORY: geosx/ubuntu20.04-clang10.0.0-cuda11.8.89 + DOCKER_REPOSITORY: geosx/ubuntu24.04-clang19-cuda12.9.1 ENABLE_HYPRE_DEVICE: CUDA ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF @@ -500,35 +556,49 @@ jobs: DOCKER_RUN_ARGS: "--cpus=8 --memory=128g --runtime=nvidia" HOST_CONFIG: /spack-generated.cmake - - name: Ubuntu CUDA (20.04, clang 10.0.0 + gcc 9.4.0, open-mpi 4.0.3, cuda-11.8.89) + - name: Ubuntu 24.04 - gcc 13 + CUDA 12.9.1 BUILD_AND_TEST_CLI_ARGS: "--no-run-unit-tests --no-install-schema" CMAKE_BUILD_TYPE: Release BUILD_GENERATOR: "--ninja" - DOCKER_REPOSITORY: geosx/ubuntu20.04-clang10.0.0-cuda11.8.89 + DOCKER_REPOSITORY: geosx/ubuntu24.04-gcc13-cuda12.9.1 ENABLE_HYPRE_DEVICE: CUDA ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF GEOS_ENABLE_BOUNDS_CHECK: OFF RUNNER_KEY: cuda NPROC: 8 - DOCKER_RUN_ARGS: "--cpus=8 --memory=256g --runtime=nvidia" + DOCKER_RUN_ARGS: "--cpus=8 --memory=128g --runtime=nvidia" HOST_CONFIG: /spack-generated.cmake - - name: Rockylinux CUDA (8, clang 17.0.6, cuda 12.9.1) - BUILD_AND_TEST_CLI_ARGS: "--no-install-schema" + - name: Ubuntu 24.04 - clang 19 + CUDA 12.9.1 + BUILD_AND_TEST_CLI_ARGS: "--no-run-unit-tests --no-install-schema" CMAKE_BUILD_TYPE: Release BUILD_GENERATOR: "--ninja" + DOCKER_REPOSITORY: geosx/ubuntu24.04-clang19-cuda12.9.1 ENABLE_HYPRE_DEVICE: CUDA ENABLE_HYPRE: ON ENABLE_TRILINOS: OFF GEOS_ENABLE_BOUNDS_CHECK: OFF - DOCKER_REPOSITORY: geosx/rockylinux8-clang17-cuda12.9.1 RUNNER_KEY: cuda NPROC: 8 - DOCKER_RUN_ARGS: "--cpus=8 --memory=128g --runtime=nvidia -e NVIDIA_VISIBLE_DEVICES=all" + DOCKER_RUN_ARGS: "--cpus=8 --memory=128g --runtime=nvidia" HOST_CONFIG: /spack-generated.cmake + + # - name: Rocky Linux 8 - clang 19 + CUDA 12.9.1 + # BUILD_AND_TEST_CLI_ARGS: "--no-install-schema" + # CMAKE_BUILD_TYPE: Release + # BUILD_GENERATOR: "--ninja" + # ENABLE_HYPRE_DEVICE: CUDA + # ENABLE_HYPRE: ON + # ENABLE_TRILINOS: OFF + # GEOS_ENABLE_BOUNDS_CHECK: OFF + # DOCKER_REPOSITORY: geosx/rockylinux8-clang19-cuda12.9.1 + # RUNNER_KEY: cuda + # NPROC: 8 + # DOCKER_RUN_ARGS: "--cpus=8 --memory=128g --runtime=nvidia -e NVIDIA_VISIBLE_DEVICES=all" + # HOST_CONFIG: /spack-generated.cmake - - name: Rockylinux CUDA (8, gcc 13.3, cuda 12.9.1) + - name: Rocky Linux 8 - gcc 13 + CUDA 12.9.1 BUILD_AND_TEST_CLI_ARGS: "--no-run-unit-tests --no-install-schema" CMAKE_BUILD_TYPE: Release BUILD_GENERATOR: "--ninja" @@ -542,26 +612,13 @@ jobs: DOCKER_RUN_ARGS: "--cpus=8 --memory=128g --runtime=nvidia" HOST_CONFIG: /spack-generated.cmake - #- name: Sherlock GPU (centos 7.9.2009, gcc 10.1.0, open-mpi 4.1.2, openblas 0.3.10, cuda 12.4.0,) - # BUILD_AND_TEST_CLI_ARGS: "--no-run-unit-tests --no-install-schema" - # BUILD_GENERATOR: "--ninja" - # CMAKE_BUILD_TYPE: Release - # DOCKER_REPOSITORY: geosx/sherlock-gcc10.1.0-openmpi4.1.2-cuda12.4.0-openblas0.3.10-zlib1.2.11 - # ENABLE_HYPRE_DEVICE: CUDA - # ENABLE_HYPRE: ON - # ENABLE_TRILINOS: OFF - # GEOS_ENABLE_BOUNDS_CHECK: OFF - # RUNS_ON: streak2 - # NPROC: 8 - # DOCKER_RUN_ARGS: "--cpus=8 --memory=128g --runtime=nvidia -v /etc/pki/tls/certs/ca-bundle.crt:/etc/pki/tls/certs/ca-bundle.crt:ro -v /etc/pki/tls/certs/ca-bundle.crt:/certs/ca-bundle.crt:ro" - # DOCKER_CERTS_DIR: "/etc/pki/ca-trust/source/anchors" - # DOCKER_CERTS_UPDATE_COMMAND: "update-ca-trust" - # HOST_CONFIG: /spack-generated.cmake + # Below this line, jobs that deploy to Google Cloud. uses: ./.github/workflows/build_and_test.yml with: BUILD_AND_TEST_CLI_ARGS: ${{ matrix.BUILD_AND_TEST_CLI_ARGS }} CMAKE_BUILD_TYPE: ${{ matrix.CMAKE_BUILD_TYPE }} + CMAKE_CUDA_ARCHITECTURES: ${{ fromJSON(needs.resolve_ci_provider.outputs.CMAKE_CUDA_ARCHITECTURES_JSON)[matrix.RUNNER_KEY || 'default'] }} BUILD_GENERATOR: ${{ matrix.BUILD_GENERATOR }} DOCKER_IMAGE_TAG: ${{ needs.is_not_draft_pull_request.outputs.DOCKER_IMAGE_TAG }} DOCKER_REPOSITORY: ${{ matrix.DOCKER_REPOSITORY }} diff --git a/host-configs/LLNL/dane-toss_4_x86_64_ib-gcc@12.1.1.cmake b/host-configs/LLNL/dane-toss_4_x86_64_ib-gcc@12.1.1.cmake index f9131045ed3..f78c70e7f09 100644 --- a/host-configs/LLNL/dane-toss_4_x86_64_ib-gcc@12.1.1.cmake +++ b/host-configs/LLNL/dane-toss_4_x86_64_ib-gcc@12.1.1.cmake @@ -65,15 +65,15 @@ set(ENABLE_HIP OFF CACHE BOOL "") set(ENABLE_CHAI ON CACHE BOOL "") -set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/chai-2025.12.0-gj4cge5skn5pmcq7h4rd7vg47zygtx63" CACHE PATH "") +set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/chai-2025.12.0-gj4cge5skn5pmcq7h4rd7vg47zygtx63" CACHE PATH "") -set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/raja-2025.12.0-7tz3a6vkc7e642t7zmpxexyi5lqsfafg" CACHE PATH "") +set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/raja-2025.12.0-7tz3a6vkc7e642t7zmpxexyi5lqsfafg" CACHE PATH "") set(ENABLE_UMPIRE ON CACHE BOOL "") -set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/umpire-2025.12.0-qxwp33yhikgs2fkl2vdeobbmal6bqw6n" CACHE PATH "") +set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/umpire-2025.12.0-qxwp33yhikgs2fkl2vdeobbmal6bqw6n" CACHE PATH "") -set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/camp-2025.12.0-v3got3dbxmrizv3nk7m6gftc37aen4ym" CACHE PATH "") +set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/camp-2025.12.0-v3got3dbxmrizv3nk7m6gftc37aen4ym" CACHE PATH "") #-------------------------------------------------------------------------------- # IO TPLs @@ -81,23 +81,23 @@ set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/ca set(ENABLE_CALIPER ON CACHE BOOL "") -set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/caliper-2.14.0-lwnj4cxlrnclq564deuu7tljugndvtnt" CACHE PATH "") +set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/caliper-2.14.0-lwnj4cxlrnclq564deuu7tljugndvtnt" CACHE PATH "") -set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/adiak-0.4.0-6lz2sfblhg3haec5wghtcahttyei5h3v" CACHE PATH "") +set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/adiak-0.4.0-6lz2sfblhg3haec5wghtcahttyei5h3v" CACHE PATH "") set(ZLIB_DIR "/usr" CACHE PATH "") -set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/hdf5-1.14.6-7n343tz7mztayupsigyaj7chzbsltayo" CACHE PATH "") +set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/hdf5-1.14.6-7n343tz7mztayupsigyaj7chzbsltayo" CACHE PATH "") -set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/conduit-0.9.5-j25t5t5kvxjhbt3vzvrig6ejqyjuy3pl" CACHE PATH "") +set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/conduit-0.9.5-j25t5t5kvxjhbt3vzvrig6ejqyjuy3pl" CACHE PATH "") -set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/silo-4.12.0-wo3vlynxc3jkwkunrlikk3645pg76gog" CACHE PATH "") +set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/silo-4.12.0-wo3vlynxc3jkwkunrlikk3645pg76gog" CACHE PATH "") -set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/pugixml-1.13-vnpomoy3m4sh7zsnz5uqfn2hp6zh2mzw" CACHE PATH "") +set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/pugixml-1.13-vnpomoy3m4sh7zsnz5uqfn2hp6zh2mzw" CACHE PATH "") -set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/vtk-9.4.2-mu24yirl5ddhfv3qzhhbwilxxsjn47dp" CACHE PATH "") +set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/vtk-9.4.2-mu24yirl5ddhfv3qzhhbwilxxsjn47dp" CACHE PATH "") -set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/fmt-11.0.2-fbj372jbpfsajq5bzeyhdj4ouz4pgbzm" CACHE PATH "") +set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/fmt-11.0.2-fbj372jbpfsajq5bzeyhdj4ouz4pgbzm" CACHE PATH "") #-------------------------------------------------------------------------------- # System Math Libraries @@ -111,19 +111,19 @@ set(LAPACK_LIBRARIES /usr/lib64/libopenblas.so CACHE STRING "") # Math TPLs #-------------------------------------------------------------------------------- -set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/metis-5.1.0-pxv4jh6tetihokv5u7keagd7cytygua7" CACHE PATH "") +set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/metis-5.1.0-pxv4jh6tetihokv5u7keagd7cytygua7" CACHE PATH "") -set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/parmetis-4.0.3-rbzv62lqv7bqm54x5ofwvlgw43wjcalo" CACHE PATH "") +set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/parmetis-4.0.3-rbzv62lqv7bqm54x5ofwvlgw43wjcalo" CACHE PATH "") -set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/scotch-7.0.8-eqsq7le3z5srqx2ezsez4yvwu2vq5n6g" CACHE PATH "") +set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/scotch-7.0.8-eqsq7le3z5srqx2ezsez4yvwu2vq5n6g" CACHE PATH "") -set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/superlu-dist-9.2.1-n2ffm6w6nh6s7lc3puw6uiffldvtuto4" CACHE PATH "") +set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/superlu-dist-9.2.1-n2ffm6w6nh6s7lc3puw6uiffldvtuto4" CACHE PATH "") -set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/suite-sparse-5.10.1-d6clmff6msrxrgoecsx6one2cbju6a4t" CACHE PATH "") +set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/suite-sparse-5.10.1-d6clmff6msrxrgoecsx6one2cbju6a4t" CACHE PATH "") -set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/trilinos-16.1.0-jxdbiuqjoiln4ezxfbjzgi6dbs4dtpus" CACHE PATH "") +set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/trilinos-16.1.0-jxdbiuqjoiln4ezxfbjzgi6dbs4dtpus" CACHE PATH "") -set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-wfynro7iqqothqthqpz3obnelkmpmcnr" CACHE PATH "") +set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-wfynro7iqqothqthqpz3obnelkmpmcnr" CACHE PATH "") set(ENABLE_HYPREDRV OFF CACHE BOOL "") @@ -149,7 +149,7 @@ set(ENABLE_PYGEOSX ON CACHE BOOL "") set(SPHINX_EXECUTABLE "/usr/gapps/GEOSX/thirdPartyLibs/python/quartz-gcc-python/python/bin/sphinx-build" CACHE PATH "") -set(DOXYGEN_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/doxygen-1.8.20-lbqhlrg3msfivysu2rfxq674siosbmob/bin/doxygen" CACHE PATH "") +set(DOXYGEN_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/doxygen-1.8.20-lbqhlrg3msfivysu2rfxq674siosbmob/bin/doxygen" CACHE PATH "") #-------------------------------------------------------------------------------- # Development tools @@ -157,15 +157,7 @@ set(DOXYGEN_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc set(ENABLE_UNCRUSTIFY ON CACHE BOOL "") -set(UNCRUSTIFY_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/uncrustify-git.401a4098bce9dcc47e024987403f2d59d9ba7bd2_0.70.1-git.319-yqfbyrbgcnjjpkfaijkdtsejzjtpp4ig/bin/uncrustify" CACHE PATH "") - -#-------------------------------------------------------------------------------- -# addr2line -#-------------------------------------------------------------------------------- - -set(ENABLE_ADDR2LINE ON CACHE BOOL "") - -set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") +set(UNCRUSTIFY_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/uncrustify-git.401a4098bce9dcc47e024987403f2d59d9ba7bd2_0.70.1-git.319-yqfbyrbgcnjjpkfaijkdtsejzjtpp4ig/bin/uncrustify" CACHE PATH "") #-------------------------------------------------------------------------------- # Other @@ -173,7 +165,7 @@ set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") set(ENABLE_MATHPRESSO ON CACHE BOOL "") -set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-12_tpls/gcc-12.1.1/mathpresso-geos-iz4kph2ijg7inklauzcits2sivybrttp" CACHE PATH "") +set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-12_tpls/gcc-12.1.1/mathpresso-geos-iz4kph2ijg7inklauzcits2sivybrttp" CACHE PATH "") set(ENABLE_XML_UPDATES ON CACHE BOOL "") diff --git a/host-configs/LLNL/dane-toss_4_x86_64_ib-gcc@13.3.1.cmake b/host-configs/LLNL/dane-toss_4_x86_64_ib-gcc@13.3.1.cmake index f713ff43622..cbe77f33a44 100644 --- a/host-configs/LLNL/dane-toss_4_x86_64_ib-gcc@13.3.1.cmake +++ b/host-configs/LLNL/dane-toss_4_x86_64_ib-gcc@13.3.1.cmake @@ -65,15 +65,15 @@ set(ENABLE_HIP OFF CACHE BOOL "") set(ENABLE_CHAI ON CACHE BOOL "") -set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/chai-2025.12.0-qbuudn4fk6m7wftxulklbk5cw7ozacjf" CACHE PATH "") +set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/chai-2025.12.0-qbuudn4fk6m7wftxulklbk5cw7ozacjf" CACHE PATH "") -set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/raja-2025.12.0-g37z6m2jmvyqb7qiwwa37hom3uyp2ypp" CACHE PATH "") +set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/raja-2025.12.0-g37z6m2jmvyqb7qiwwa37hom3uyp2ypp" CACHE PATH "") set(ENABLE_UMPIRE ON CACHE BOOL "") -set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/umpire-2025.12.0-hqtbmsfujzpjxj3kl3jk3bmt3a7k5ety" CACHE PATH "") +set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/umpire-2025.12.0-hqtbmsfujzpjxj3kl3jk3bmt3a7k5ety" CACHE PATH "") -set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/camp-2025.12.0-3q3quidchcepoysqupvlwla577e3smyt" CACHE PATH "") +set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/camp-2025.12.0-3q3quidchcepoysqupvlwla577e3smyt" CACHE PATH "") #-------------------------------------------------------------------------------- # IO TPLs @@ -81,23 +81,23 @@ set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/ca set(ENABLE_CALIPER ON CACHE BOOL "") -set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/caliper-2.14.0-xixabnkvywrgd6a7v766yr74mobs73tx" CACHE PATH "") +set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/caliper-2.14.0-xixabnkvywrgd6a7v766yr74mobs73tx" CACHE PATH "") -set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/adiak-0.4.0-u3s7u7hqxlxok3vyus63lfao77t3wvdq" CACHE PATH "") +set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/adiak-0.4.0-u3s7u7hqxlxok3vyus63lfao77t3wvdq" CACHE PATH "") set(ZLIB_DIR "/usr" CACHE PATH "") -set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/hdf5-1.14.6-ptzjlsdhytvyf5dxp6js6iugmpfd6pqc" CACHE PATH "") +set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/hdf5-1.14.6-ptzjlsdhytvyf5dxp6js6iugmpfd6pqc" CACHE PATH "") -set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/conduit-0.9.5-6ockgir74o2gncru2tfhabauss3leyqb" CACHE PATH "") +set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/conduit-0.9.5-6ockgir74o2gncru2tfhabauss3leyqb" CACHE PATH "") -set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/silo-4.12.0-zwey5kdj32q7nfz6o6gbgay5mln6qozf" CACHE PATH "") +set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/silo-4.12.0-zwey5kdj32q7nfz6o6gbgay5mln6qozf" CACHE PATH "") -set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/pugixml-1.13-vykyowhrjriqfjysczgzijjvo6fbimew" CACHE PATH "") +set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/pugixml-1.13-vykyowhrjriqfjysczgzijjvo6fbimew" CACHE PATH "") -set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/vtk-9.4.2-xllx5twzha2typ6vabecuwrdb7dt5vdn" CACHE PATH "") +set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/vtk-9.4.2-xllx5twzha2typ6vabecuwrdb7dt5vdn" CACHE PATH "") -set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/fmt-11.0.2-g27pu3mcspwrp46iuo32tkyrrxrhzdrk" CACHE PATH "") +set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/fmt-11.0.2-g27pu3mcspwrp46iuo32tkyrrxrhzdrk" CACHE PATH "") #-------------------------------------------------------------------------------- # System Math Libraries @@ -111,21 +111,23 @@ set(LAPACK_LIBRARIES /usr/lib64/libopenblas.so CACHE STRING "") # Math TPLs #-------------------------------------------------------------------------------- -set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/metis-5.1.0-7lnhkbv2fdcbtcrv5ubv7og3l6cor54b" CACHE PATH "") +set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/metis-5.1.0-7lnhkbv2fdcbtcrv5ubv7og3l6cor54b" CACHE PATH "") -set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/parmetis-4.0.3-3mayiemdzkvic4myatatjp37gx7wmk3k" CACHE PATH "") +set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/parmetis-4.0.3-3mayiemdzkvic4myatatjp37gx7wmk3k" CACHE PATH "") -set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/scotch-7.0.8-smdrzzop27f3svwxzwq63aoaol7wwyzu" CACHE PATH "") +set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/scotch-7.0.8-smdrzzop27f3svwxzwq63aoaol7wwyzu" CACHE PATH "") -set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/superlu-dist-9.2.1-lkn6ca4m4oejawk3pauulv7qmeiruuhq" CACHE PATH "") +set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/superlu-dist-9.2.1-lkn6ca4m4oejawk3pauulv7qmeiruuhq" CACHE PATH "") -set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/suite-sparse-5.10.1-avjp6ihuavwtlx4xgtotehbz2noze2fh" CACHE PATH "") +set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/suite-sparse-5.10.1-avjp6ihuavwtlx4xgtotehbz2noze2fh" CACHE PATH "") -set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/trilinos-16.1.0-47kt3mvxzybxrfomkqkr3qbo64hwjzc7" CACHE PATH "") +set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/trilinos-16.1.0-47kt3mvxzybxrfomkqkr3qbo64hwjzc7" CACHE PATH "") -set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-gme2drnput4pakha7r4x4i7vcuteuobt" CACHE PATH "") +set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-gme2drnput4pakha7r4x4i7vcuteuobt" CACHE PATH "") -set(ENABLE_HYPREDRV OFF CACHE BOOL "") +set(ENABLE_HYPREDRV ON CACHE BOOL "") + +set(HYPREDRV_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/hypredrive-git.d062c48cc8d26a9bee92f33f3c588d071c230d30_master-vuvlhl4fs7nhdoqxqz5op37gzuj66m7p" CACHE PATH "") set(ENABLE_PETSC OFF CACHE BOOL "") @@ -149,7 +151,7 @@ set(ENABLE_PYGEOSX ON CACHE BOOL "") set(SPHINX_EXECUTABLE "/usr/gapps/GEOSX/thirdPartyLibs/python/quartz-gcc-python/python/bin/sphinx-build" CACHE PATH "") -set(DOXYGEN_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/doxygen-1.8.20-x3azuxonudnfy6nnvzjyovjkjfncioq2/bin/doxygen" CACHE PATH "") +set(DOXYGEN_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/doxygen-1.8.20-x3azuxonudnfy6nnvzjyovjkjfncioq2/bin/doxygen" CACHE PATH "") #-------------------------------------------------------------------------------- # Development tools @@ -157,15 +159,7 @@ set(DOXYGEN_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc set(ENABLE_UNCRUSTIFY ON CACHE BOOL "") -set(UNCRUSTIFY_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/uncrustify-git.401a4098bce9dcc47e024987403f2d59d9ba7bd2_0.70.1-git.319-wp72eon5hcohsatqntmggcspmd3ibryy/bin/uncrustify" CACHE PATH "") - -#-------------------------------------------------------------------------------- -# addr2line -#-------------------------------------------------------------------------------- - -set(ENABLE_ADDR2LINE ON CACHE BOOL "") - -set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") +set(UNCRUSTIFY_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/uncrustify-git.401a4098bce9dcc47e024987403f2d59d9ba7bd2_0.70.1-git.319-wp72eon5hcohsatqntmggcspmd3ibryy/bin/uncrustify" CACHE PATH "") #-------------------------------------------------------------------------------- # Other @@ -173,7 +167,7 @@ set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") set(ENABLE_MATHPRESSO ON CACHE BOOL "") -set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-gcc-13_tpls/gcc-13.3.1/mathpresso-geos-fzt67tuymmzyrl5lhcprtffdhnanu4xq" CACHE PATH "") +set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-gcc-13-hypredrive_tpls/gcc-13.3.1/mathpresso-geos-fzt67tuymmzyrl5lhcprtffdhnanu4xq" CACHE PATH "") set(ENABLE_XML_UPDATES ON CACHE BOOL "") diff --git a/host-configs/LLNL/dane-toss_4_x86_64_ib-llvm@14.0.6.cmake b/host-configs/LLNL/dane-toss_4_x86_64_ib-llvm@14.0.6.cmake index ff9f267a962..95cf462ce94 100644 --- a/host-configs/LLNL/dane-toss_4_x86_64_ib-llvm@14.0.6.cmake +++ b/host-configs/LLNL/dane-toss_4_x86_64_ib-llvm@14.0.6.cmake @@ -65,15 +65,15 @@ set(ENABLE_HIP OFF CACHE BOOL "") set(ENABLE_CHAI ON CACHE BOOL "") -set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/chai-2025.12.0-pvwccufebbexz5j5332lq7jq7ynwhv3y" CACHE PATH "") +set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/chai-2025.12.0-pvwccufebbexz5j5332lq7jq7ynwhv3y" CACHE PATH "") -set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/raja-2025.12.0-s45pq56nd5qutsia5icxw7c7odt4wngp" CACHE PATH "") +set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/raja-2025.12.0-s45pq56nd5qutsia5icxw7c7odt4wngp" CACHE PATH "") set(ENABLE_UMPIRE ON CACHE BOOL "") -set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/umpire-2025.12.0-62eh5t3wbqm3skcy5sl7d744mdrmpi2j" CACHE PATH "") +set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/umpire-2025.12.0-62eh5t3wbqm3skcy5sl7d744mdrmpi2j" CACHE PATH "") -set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/camp-2025.12.0-agkxhbph6l3wdetnbv5mrmq5chogauge" CACHE PATH "") +set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/camp-2025.12.0-agkxhbph6l3wdetnbv5mrmq5chogauge" CACHE PATH "") #-------------------------------------------------------------------------------- # IO TPLs @@ -81,23 +81,23 @@ set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/ set(ENABLE_CALIPER ON CACHE BOOL "") -set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/caliper-2.14.0-oahv5uuriqn2vyqbzespzkrfsghxjfew" CACHE PATH "") +set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/caliper-2.14.0-oahv5uuriqn2vyqbzespzkrfsghxjfew" CACHE PATH "") -set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/adiak-0.4.0-iitjnfmanurcrmlyau4qm7kpep6q6vxt" CACHE PATH "") +set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/adiak-0.4.0-iitjnfmanurcrmlyau4qm7kpep6q6vxt" CACHE PATH "") set(ZLIB_DIR "/usr" CACHE PATH "") -set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/hdf5-1.14.6-ottiokh52c2uvkujg6s4yc63afy24e7d" CACHE PATH "") +set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/hdf5-1.14.6-ottiokh52c2uvkujg6s4yc63afy24e7d" CACHE PATH "") -set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/conduit-0.9.5-y5dwa2wdrmelzcpyx7yzayckzo3gpgrm" CACHE PATH "") +set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/conduit-0.9.5-y5dwa2wdrmelzcpyx7yzayckzo3gpgrm" CACHE PATH "") -set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/silo-4.12.0-24vfiuq62fnn5ui6uqdhvouz65zytin2" CACHE PATH "") +set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/silo-4.12.0-24vfiuq62fnn5ui6uqdhvouz65zytin2" CACHE PATH "") -set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/pugixml-1.13-rd24lxieweuz24w7ycbaryfyk6lbznmb" CACHE PATH "") +set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/pugixml-1.13-rd24lxieweuz24w7ycbaryfyk6lbznmb" CACHE PATH "") -set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/vtk-9.4.2-fnpua5soyrcqbkrqnnh4zqt6yn5hem5e" CACHE PATH "") +set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/vtk-9.4.2-fnpua5soyrcqbkrqnnh4zqt6yn5hem5e" CACHE PATH "") -set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/fmt-11.0.2-voxs6pm2ttqbwt3gszcbvcb2xmugiosj" CACHE PATH "") +set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/fmt-11.0.2-voxs6pm2ttqbwt3gszcbvcb2xmugiosj" CACHE PATH "") #-------------------------------------------------------------------------------- # System Math Libraries @@ -111,19 +111,19 @@ set(LAPACK_LIBRARIES /usr/lib64/libopenblas.so CACHE STRING "") # Math TPLs #-------------------------------------------------------------------------------- -set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/metis-5.1.0-7ultypmkrm5nnur3o6ntl557ut4zpi3a" CACHE PATH "") +set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/metis-5.1.0-7ultypmkrm5nnur3o6ntl557ut4zpi3a" CACHE PATH "") -set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/parmetis-4.0.3-l7zdwdi3icsmd2ei7lmnytikc4kitsrf" CACHE PATH "") +set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/parmetis-4.0.3-l7zdwdi3icsmd2ei7lmnytikc4kitsrf" CACHE PATH "") -set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/scotch-7.0.8-kfvnwp3qofbqvm4duccjctx23zsjfyj3" CACHE PATH "") +set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/scotch-7.0.8-kfvnwp3qofbqvm4duccjctx23zsjfyj3" CACHE PATH "") -set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/superlu-dist-9.2.1-ft373aafcmpgtywcvvti4taddmsbqn2r" CACHE PATH "") +set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/superlu-dist-9.2.1-ft373aafcmpgtywcvvti4taddmsbqn2r" CACHE PATH "") -set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/suite-sparse-5.10.1-6s5wuk2jv66hevvxm4tjnrxmad6cuqw3" CACHE PATH "") +set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/suite-sparse-5.10.1-6s5wuk2jv66hevvxm4tjnrxmad6cuqw3" CACHE PATH "") -set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/trilinos-16.1.0-ugaxqluqwxpbnupdzgkjqjcjx42k5d4n" CACHE PATH "") +set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/trilinos-16.1.0-ugaxqluqwxpbnupdzgkjqjcjx42k5d4n" CACHE PATH "") -set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-lb2bbdvaubmyonpm4cecnwyclpp2nt7g" CACHE PATH "") +set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-lb2bbdvaubmyonpm4cecnwyclpp2nt7g" CACHE PATH "") set(ENABLE_HYPREDRV OFF CACHE BOOL "") @@ -149,7 +149,7 @@ set(ENABLE_PYGEOSX ON CACHE BOOL "") set(SPHINX_EXECUTABLE "/usr/gapps/GEOSX/thirdPartyLibs/python/quartz-gcc-python/python/bin/sphinx-build" CACHE PATH "") -set(DOXYGEN_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/doxygen-1.8.20-r35mgsl7acmueg3o7lu4sm436u6lmeye/bin/doxygen" CACHE PATH "") +set(DOXYGEN_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/doxygen-1.8.20-r35mgsl7acmueg3o7lu4sm436u6lmeye/bin/doxygen" CACHE PATH "") #-------------------------------------------------------------------------------- # Development tools @@ -157,15 +157,7 @@ set(DOXYGEN_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/ll set(ENABLE_UNCRUSTIFY ON CACHE BOOL "") -set(UNCRUSTIFY_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/uncrustify-git.401a4098bce9dcc47e024987403f2d59d9ba7bd2_0.70.1-git.319-rmqswrm2hqjas6bshjhhf6vljdk3c663/bin/uncrustify" CACHE PATH "") - -#-------------------------------------------------------------------------------- -# addr2line -#-------------------------------------------------------------------------------- - -set(ENABLE_ADDR2LINE ON CACHE BOOL "") - -set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") +set(UNCRUSTIFY_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/uncrustify-git.401a4098bce9dcc47e024987403f2d59d9ba7bd2_0.70.1-git.319-rmqswrm2hqjas6bshjhhf6vljdk3c663/bin/uncrustify" CACHE PATH "") #-------------------------------------------------------------------------------- # Other @@ -173,7 +165,7 @@ set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") set(ENABLE_MATHPRESSO ON CACHE BOOL "") -set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-14_tpls/llvm-14.0.6/mathpresso-geos-kxwkykrmexwzjykwccwn3p4hl54nsmym" CACHE PATH "") +set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-14_tpls/llvm-14.0.6/mathpresso-geos-kxwkykrmexwzjykwccwn3p4hl54nsmym" CACHE PATH "") set(ENABLE_XML_UPDATES ON CACHE BOOL "") diff --git a/host-configs/LLNL/dane-toss_4_x86_64_ib-llvm@19.1.3.cmake b/host-configs/LLNL/dane-toss_4_x86_64_ib-llvm@19.1.3.cmake index 2c474985f4a..67374c9c7e3 100644 --- a/host-configs/LLNL/dane-toss_4_x86_64_ib-llvm@19.1.3.cmake +++ b/host-configs/LLNL/dane-toss_4_x86_64_ib-llvm@19.1.3.cmake @@ -65,15 +65,15 @@ set(ENABLE_HIP OFF CACHE BOOL "") set(ENABLE_CHAI ON CACHE BOOL "") -set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/chai-2025.12.0-zggmegavyen23j54tmeg7q6utmnjse5f" CACHE PATH "") +set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/chai-2025.12.0-zggmegavyen23j54tmeg7q6utmnjse5f" CACHE PATH "") -set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/raja-2025.12.0-cajra6jawhf4w6oqzxecxe427r6o2bui" CACHE PATH "") +set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/raja-2025.12.0-cajra6jawhf4w6oqzxecxe427r6o2bui" CACHE PATH "") set(ENABLE_UMPIRE ON CACHE BOOL "") -set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/umpire-2025.12.0-h5pfqtbchzkbxxjxjhmv3paldoeorwme" CACHE PATH "") +set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/umpire-2025.12.0-h5pfqtbchzkbxxjxjhmv3paldoeorwme" CACHE PATH "") -set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/camp-2025.12.0-mh3yb77ywuf32gplrc4lhml23ote7yp3" CACHE PATH "") +set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/camp-2025.12.0-mh3yb77ywuf32gplrc4lhml23ote7yp3" CACHE PATH "") #-------------------------------------------------------------------------------- # IO TPLs @@ -81,23 +81,23 @@ set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/ set(ENABLE_CALIPER ON CACHE BOOL "") -set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/caliper-2.14.0-wrc2ypphd35igian2fzgjoy6fsk77oho" CACHE PATH "") +set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/caliper-2.14.0-wrc2ypphd35igian2fzgjoy6fsk77oho" CACHE PATH "") -set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/adiak-0.4.0-ujr4y5se43yq4lockjqy7vowt67dw4xw" CACHE PATH "") +set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/adiak-0.4.0-ujr4y5se43yq4lockjqy7vowt67dw4xw" CACHE PATH "") set(ZLIB_DIR "/usr" CACHE PATH "") -set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/hdf5-1.14.6-4fjfrpi2m2m7h2i3stkstsfpyxf3cgqs" CACHE PATH "") +set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/hdf5-1.14.6-4fjfrpi2m2m7h2i3stkstsfpyxf3cgqs" CACHE PATH "") -set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/conduit-0.9.5-r62ftdczyms4lqbth3pwxgklrvhk4pjo" CACHE PATH "") +set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/conduit-0.9.5-r62ftdczyms4lqbth3pwxgklrvhk4pjo" CACHE PATH "") -set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/silo-4.12.0-fq3zneqbjlbdm3oabe7do6q6ujl37igk" CACHE PATH "") +set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/silo-4.12.0-fq3zneqbjlbdm3oabe7do6q6ujl37igk" CACHE PATH "") -set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/gcc-13.3.1/pugixml-1.13-vykyowhrjriqfjysczgzijjvo6fbimew" CACHE PATH "") +set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/gcc-13.3.1/pugixml-1.13-vykyowhrjriqfjysczgzijjvo6fbimew" CACHE PATH "") -set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/vtk-9.4.2-scfh7fve7yam3m7e2fd4yvxj4ahndf7k" CACHE PATH "") +set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/vtk-9.4.2-scfh7fve7yam3m7e2fd4yvxj4ahndf7k" CACHE PATH "") -set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/fmt-11.0.2-togw47kavsjrlxnebp23byhiwvhylawl" CACHE PATH "") +set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/fmt-11.0.2-togw47kavsjrlxnebp23byhiwvhylawl" CACHE PATH "") #-------------------------------------------------------------------------------- # System Math Libraries @@ -111,19 +111,19 @@ set(LAPACK_LIBRARIES /usr/lib64/libopenblas.so CACHE STRING "") # Math TPLs #-------------------------------------------------------------------------------- -set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/metis-5.1.0-oxwylf6j2verzocr4vn4njqhtlennylg" CACHE PATH "") +set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/metis-5.1.0-oxwylf6j2verzocr4vn4njqhtlennylg" CACHE PATH "") -set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/parmetis-4.0.3-gtl5bhyxtkun2ppcnnzb4ocximklfs4n" CACHE PATH "") +set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/parmetis-4.0.3-gtl5bhyxtkun2ppcnnzb4ocximklfs4n" CACHE PATH "") -set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/scotch-7.0.8-4y2qvry7rn7wavoepaoa5wkzf6zmvwce" CACHE PATH "") +set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/scotch-7.0.8-4y2qvry7rn7wavoepaoa5wkzf6zmvwce" CACHE PATH "") -set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/superlu-dist-9.2.1-uoomikhpvwtlzu7odatw5duzka7tebar" CACHE PATH "") +set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/superlu-dist-9.2.1-uoomikhpvwtlzu7odatw5duzka7tebar" CACHE PATH "") -set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/suite-sparse-5.10.1-tbp64oxbjdeyijs22ngwvsdeszamufwq" CACHE PATH "") +set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/suite-sparse-5.10.1-tbp64oxbjdeyijs22ngwvsdeszamufwq" CACHE PATH "") -set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/trilinos-16.1.0-bl7mwswoitytxfeirisjumvgeqyqbgg7" CACHE PATH "") +set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/trilinos-16.1.0-bl7mwswoitytxfeirisjumvgeqyqbgg7" CACHE PATH "") -set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-32rnedneuddz3yee6mikkf2xo4m4rb2z" CACHE PATH "") +set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-32rnedneuddz3yee6mikkf2xo4m4rb2z" CACHE PATH "") set(ENABLE_HYPREDRV OFF CACHE BOOL "") @@ -149,7 +149,7 @@ set(ENABLE_PYGEOSX ON CACHE BOOL "") set(SPHINX_EXECUTABLE "/usr/gapps/GEOSX/thirdPartyLibs/python/quartz-gcc-python/python/bin/sphinx-build" CACHE PATH "") -set(DOXYGEN_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/gcc-13.3.1/doxygen-1.8.20-x3azuxonudnfy6nnvzjyovjkjfncioq2/bin/doxygen" CACHE PATH "") +set(DOXYGEN_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/gcc-13.3.1/doxygen-1.8.20-x3azuxonudnfy6nnvzjyovjkjfncioq2/bin/doxygen" CACHE PATH "") #-------------------------------------------------------------------------------- # Development tools @@ -157,15 +157,7 @@ set(DOXYGEN_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/gc set(ENABLE_UNCRUSTIFY ON CACHE BOOL "") -set(UNCRUSTIFY_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/llvm-19.1.3/uncrustify-git.401a4098bce9dcc47e024987403f2d59d9ba7bd2_0.70.1-git.319-mjajvyor26b46jvqafzpmxt5vc32lica/bin/uncrustify" CACHE PATH "") - -#-------------------------------------------------------------------------------- -# addr2line -#-------------------------------------------------------------------------------- - -set(ENABLE_ADDR2LINE ON CACHE BOOL "") - -set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") +set(UNCRUSTIFY_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/llvm-19.1.3/uncrustify-git.401a4098bce9dcc47e024987403f2d59d9ba7bd2_0.70.1-git.319-mjajvyor26b46jvqafzpmxt5vc32lica/bin/uncrustify" CACHE PATH "") #-------------------------------------------------------------------------------- # Other @@ -173,7 +165,7 @@ set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") set(ENABLE_MATHPRESSO ON CACHE BOOL "") -set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/dane-llvm-19_tpls/gcc-13.3.1/mathpresso-geos-fzt67tuymmzyrl5lhcprtffdhnanu4xq" CACHE PATH "") +set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/dane-llvm-19_tpls/gcc-13.3.1/mathpresso-geos-fzt67tuymmzyrl5lhcprtffdhnanu4xq" CACHE PATH "") set(ENABLE_XML_UPDATES ON CACHE BOOL "") diff --git a/host-configs/LLNL/matrix-toss_4_x86_64_ib-gcc@12.1.1-cuda@12.6.0.cmake b/host-configs/LLNL/matrix-toss_4_x86_64_ib-gcc@12.1.1-cuda@12.6.0.cmake index 60bbc2da7ce..fb1ca157390 100644 --- a/host-configs/LLNL/matrix-toss_4_x86_64_ib-gcc@12.1.1-cuda@12.6.0.cmake +++ b/host-configs/LLNL/matrix-toss_4_x86_64_ib-gcc@12.1.1-cuda@12.6.0.cmake @@ -61,7 +61,7 @@ set(CMAKE_CUDA_COMPILER "${CUDA_TOOLKIT_ROOT_DIR}/bin/nvcc" CACHE PATH "") set(CMAKE_CUDA_ARCHITECTURES "90" CACHE STRING "") -set(CMAKE_CUDA_FLAGS "-restrict --expt-extended-lambda -Werror cross-execution-space-call,reorder,deprecated-declarations -arch sm_90" CACHE STRING "") +set(CMAKE_CUDA_FLAGS "-restrict --expt-extended-lambda -Werror cross-execution-space-call,reorder,deprecated-declarations -gencode arch=compute_90,code=sm_90" CACHE STRING "") set(CMAKE_CUDA_FLAGS_RELWITHDEBINFO "-g -lineinfo ${CMAKE_CUDA_FLAGS_RELEASE}" CACHE STRING "") @@ -79,15 +79,15 @@ set(ENABLE_HIP OFF CACHE BOOL "") set(ENABLE_CHAI ON CACHE BOOL "") -set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/chai-2025.12.0-eai7qn6635lcxbo52rxsydh4rytkpjxs" CACHE PATH "") +set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/chai-2025.12.0-eai7qn6635lcxbo52rxsydh4rytkpjxs" CACHE PATH "") -set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/raja-2025.12.0-5uzmmaqpyuxzh3c4swijeeihtbbaturz" CACHE PATH "") +set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/raja-2025.12.0-5uzmmaqpyuxzh3c4swijeeihtbbaturz" CACHE PATH "") set(ENABLE_UMPIRE ON CACHE BOOL "") -set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/umpire-2025.12.0-75jwccjcgnx6kkdsabgkulooqpiqe6ks" CACHE PATH "") +set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/umpire-2025.12.0-75jwccjcgnx6kkdsabgkulooqpiqe6ks" CACHE PATH "") -set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/camp-2025.12.0-hgj24s6p3cdle65yjc752zkoc75v7zxn" CACHE PATH "") +set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/camp-2025.12.0-hgj24s6p3cdle65yjc752zkoc75v7zxn" CACHE PATH "") #-------------------------------------------------------------------------------- # IO TPLs @@ -95,23 +95,23 @@ set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/g set(ENABLE_CALIPER ON CACHE BOOL "") -set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/caliper-2.14.0-lwnj4cxlrnclq564deuu7tljugndvtnt" CACHE PATH "") +set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/caliper-2.14.0-lwnj4cxlrnclq564deuu7tljugndvtnt" CACHE PATH "") -set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/adiak-0.4.0-6lz2sfblhg3haec5wghtcahttyei5h3v" CACHE PATH "") +set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/adiak-0.4.0-6lz2sfblhg3haec5wghtcahttyei5h3v" CACHE PATH "") set(ZLIB_DIR "/usr" CACHE PATH "") -set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/hdf5-1.14.6-7n343tz7mztayupsigyaj7chzbsltayo" CACHE PATH "") +set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/hdf5-1.14.6-7n343tz7mztayupsigyaj7chzbsltayo" CACHE PATH "") -set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/conduit-0.9.5-j25t5t5kvxjhbt3vzvrig6ejqyjuy3pl" CACHE PATH "") +set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/conduit-0.9.5-j25t5t5kvxjhbt3vzvrig6ejqyjuy3pl" CACHE PATH "") -set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/silo-4.12.0-wo3vlynxc3jkwkunrlikk3645pg76gog" CACHE PATH "") +set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/silo-4.12.0-wo3vlynxc3jkwkunrlikk3645pg76gog" CACHE PATH "") -set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/pugixml-1.13-vnpomoy3m4sh7zsnz5uqfn2hp6zh2mzw" CACHE PATH "") +set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/pugixml-1.13-vnpomoy3m4sh7zsnz5uqfn2hp6zh2mzw" CACHE PATH "") -set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/vtk-9.4.2-mu24yirl5ddhfv3qzhhbwilxxsjn47dp" CACHE PATH "") +set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/vtk-9.4.2-mu24yirl5ddhfv3qzhhbwilxxsjn47dp" CACHE PATH "") -set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/fmt-11.0.2-fbj372jbpfsajq5bzeyhdj4ouz4pgbzm" CACHE PATH "") +set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/fmt-11.0.2-fbj372jbpfsajq5bzeyhdj4ouz4pgbzm" CACHE PATH "") #-------------------------------------------------------------------------------- # System Math Libraries @@ -125,19 +125,19 @@ set(LAPACK_LIBRARIES /usr/lib64/libopenblas.so CACHE STRING "") # Math TPLs #-------------------------------------------------------------------------------- -set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/metis-5.1.0-pxv4jh6tetihokv5u7keagd7cytygua7" CACHE PATH "") +set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/metis-5.1.0-pxv4jh6tetihokv5u7keagd7cytygua7" CACHE PATH "") -set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/parmetis-4.0.3-rbzv62lqv7bqm54x5ofwvlgw43wjcalo" CACHE PATH "") +set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/parmetis-4.0.3-rbzv62lqv7bqm54x5ofwvlgw43wjcalo" CACHE PATH "") -set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/scotch-7.0.8-eqsq7le3z5srqx2ezsez4yvwu2vq5n6g" CACHE PATH "") +set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/scotch-7.0.8-eqsq7le3z5srqx2ezsez4yvwu2vq5n6g" CACHE PATH "") -set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/superlu-dist-9.2.1-o4lnuxo5k5i7ztokmixcdhewg6yfxzr3" CACHE PATH "") +set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/superlu-dist-9.2.1-o4lnuxo5k5i7ztokmixcdhewg6yfxzr3" CACHE PATH "") -set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/suite-sparse-5.10.1-d6clmff6msrxrgoecsx6one2cbju6a4t" CACHE PATH "") +set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/suite-sparse-5.10.1-d6clmff6msrxrgoecsx6one2cbju6a4t" CACHE PATH "") -set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/trilinos-16.1.0-jxdbiuqjoiln4ezxfbjzgi6dbs4dtpus" CACHE PATH "") +set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/trilinos-16.1.0-jxdbiuqjoiln4ezxfbjzgi6dbs4dtpus" CACHE PATH "") -set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-dggrbwctr2m3vnchkkewncxak6bl6lts" CACHE PATH "") +set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-dggrbwctr2m3vnchkkewncxak6bl6lts" CACHE PATH "") set(ENABLE_HYPRE_DEVICE "CUDA" CACHE STRING "") @@ -175,21 +175,13 @@ set(ENABLE_SPHINX OFF CACHE BOOL "") set(ENABLE_UNCRUSTIFY OFF CACHE BOOL "") -#-------------------------------------------------------------------------------- -# addr2line -#-------------------------------------------------------------------------------- - -set(ENABLE_ADDR2LINE ON CACHE BOOL "") - -set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") - #-------------------------------------------------------------------------------- # Other #-------------------------------------------------------------------------------- set(ENABLE_MATHPRESSO ON CACHE BOOL "") -set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/mathpresso-geos-iz4kph2ijg7inklauzcits2sivybrttp" CACHE PATH "") +set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-12-cuda-12.6_tpls/gcc-12.1.1/mathpresso-geos-iz4kph2ijg7inklauzcits2sivybrttp" CACHE PATH "") set(ENABLE_XML_UPDATES ON CACHE BOOL "") diff --git a/host-configs/LLNL/matrix-toss_4_x86_64_ib-gcc@13.3.1-cuda@12.9.1.cmake b/host-configs/LLNL/matrix-toss_4_x86_64_ib-gcc@13.3.1-cuda@12.9.1.cmake index c8ed5eb9e11..4023206e459 100644 --- a/host-configs/LLNL/matrix-toss_4_x86_64_ib-gcc@13.3.1-cuda@12.9.1.cmake +++ b/host-configs/LLNL/matrix-toss_4_x86_64_ib-gcc@13.3.1-cuda@12.9.1.cmake @@ -61,7 +61,7 @@ set(CMAKE_CUDA_COMPILER "${CUDA_TOOLKIT_ROOT_DIR}/bin/nvcc" CACHE PATH "") set(CMAKE_CUDA_ARCHITECTURES "90" CACHE STRING "") -set(CMAKE_CUDA_FLAGS "-restrict --expt-extended-lambda -Werror cross-execution-space-call,reorder,deprecated-declarations -arch sm_90" CACHE STRING "") +set(CMAKE_CUDA_FLAGS "-restrict --expt-extended-lambda -Werror cross-execution-space-call,reorder,deprecated-declarations -gencode arch=compute_90,code=sm_90" CACHE STRING "") set(CMAKE_CUDA_FLAGS_RELWITHDEBINFO "-g -lineinfo ${CMAKE_CUDA_FLAGS_RELEASE}" CACHE STRING "") @@ -79,15 +79,15 @@ set(ENABLE_HIP OFF CACHE BOOL "") set(ENABLE_CHAI ON CACHE BOOL "") -set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/chai-2025.12.0-meix2nqnb76bnykuhxydtp6ikahodwld" CACHE PATH "") +set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/chai-2025.12.0-meix2nqnb76bnykuhxydtp6ikahodwld" CACHE PATH "") -set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/raja-2025.12.0-ofcrxyx6kb2iwsugddcps4yjsfaws4dz" CACHE PATH "") +set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/raja-2025.12.0-ofcrxyx6kb2iwsugddcps4yjsfaws4dz" CACHE PATH "") set(ENABLE_UMPIRE ON CACHE BOOL "") -set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/umpire-2025.12.0-w3o2oo5becpghphnwxqli5pogj7ni7vi" CACHE PATH "") +set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/umpire-2025.12.0-w3o2oo5becpghphnwxqli5pogj7ni7vi" CACHE PATH "") -set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/camp-2025.12.0-c4wmxpp5jwkkfdo3c5ygbfcdpf7xjk2x" CACHE PATH "") +set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/camp-2025.12.0-c4wmxpp5jwkkfdo3c5ygbfcdpf7xjk2x" CACHE PATH "") #-------------------------------------------------------------------------------- # IO TPLs @@ -95,23 +95,23 @@ set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/g set(ENABLE_CALIPER ON CACHE BOOL "") -set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/caliper-2.14.0-xixabnkvywrgd6a7v766yr74mobs73tx" CACHE PATH "") +set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/caliper-2.14.0-xixabnkvywrgd6a7v766yr74mobs73tx" CACHE PATH "") -set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/adiak-0.4.0-u3s7u7hqxlxok3vyus63lfao77t3wvdq" CACHE PATH "") +set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/adiak-0.4.0-u3s7u7hqxlxok3vyus63lfao77t3wvdq" CACHE PATH "") set(ZLIB_DIR "/usr" CACHE PATH "") -set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/hdf5-1.14.6-ptzjlsdhytvyf5dxp6js6iugmpfd6pqc" CACHE PATH "") +set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/hdf5-1.14.6-ptzjlsdhytvyf5dxp6js6iugmpfd6pqc" CACHE PATH "") -set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/conduit-0.9.5-6ockgir74o2gncru2tfhabauss3leyqb" CACHE PATH "") +set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/conduit-0.9.5-6ockgir74o2gncru2tfhabauss3leyqb" CACHE PATH "") -set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/silo-4.12.0-zwey5kdj32q7nfz6o6gbgay5mln6qozf" CACHE PATH "") +set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/silo-4.12.0-zwey5kdj32q7nfz6o6gbgay5mln6qozf" CACHE PATH "") -set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/pugixml-1.13-vykyowhrjriqfjysczgzijjvo6fbimew" CACHE PATH "") +set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/pugixml-1.13-vykyowhrjriqfjysczgzijjvo6fbimew" CACHE PATH "") -set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/vtk-9.4.2-xllx5twzha2typ6vabecuwrdb7dt5vdn" CACHE PATH "") +set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/vtk-9.4.2-xllx5twzha2typ6vabecuwrdb7dt5vdn" CACHE PATH "") -set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/fmt-11.0.2-g27pu3mcspwrp46iuo32tkyrrxrhzdrk" CACHE PATH "") +set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/fmt-11.0.2-g27pu3mcspwrp46iuo32tkyrrxrhzdrk" CACHE PATH "") #-------------------------------------------------------------------------------- # System Math Libraries @@ -125,23 +125,25 @@ set(LAPACK_LIBRARIES /usr/lib64/libopenblas.so CACHE STRING "") # Math TPLs #-------------------------------------------------------------------------------- -set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/metis-5.1.0-7lnhkbv2fdcbtcrv5ubv7og3l6cor54b" CACHE PATH "") +set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/metis-5.1.0-7lnhkbv2fdcbtcrv5ubv7og3l6cor54b" CACHE PATH "") -set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/parmetis-4.0.3-3mayiemdzkvic4myatatjp37gx7wmk3k" CACHE PATH "") +set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/parmetis-4.0.3-3mayiemdzkvic4myatatjp37gx7wmk3k" CACHE PATH "") -set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/scotch-7.0.8-smdrzzop27f3svwxzwq63aoaol7wwyzu" CACHE PATH "") +set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/scotch-7.0.8-smdrzzop27f3svwxzwq63aoaol7wwyzu" CACHE PATH "") -set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/superlu-dist-9.2.1-t7vgyyy3wvegm3sbx3d7o2nts3rrq2bi" CACHE PATH "") +set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/superlu-dist-9.2.1-t7vgyyy3wvegm3sbx3d7o2nts3rrq2bi" CACHE PATH "") -set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/suite-sparse-5.10.1-avjp6ihuavwtlx4xgtotehbz2noze2fh" CACHE PATH "") +set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/suite-sparse-5.10.1-avjp6ihuavwtlx4xgtotehbz2noze2fh" CACHE PATH "") -set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/trilinos-16.1.0-47kt3mvxzybxrfomkqkr3qbo64hwjzc7" CACHE PATH "") +set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/trilinos-16.1.0-47kt3mvxzybxrfomkqkr3qbo64hwjzc7" CACHE PATH "") -set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-zr2d6bddefdt57yp4jixmyabbx3df3rm" CACHE PATH "") +set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-zr2d6bddefdt57yp4jixmyabbx3df3rm" CACHE PATH "") set(ENABLE_HYPRE_DEVICE "CUDA" CACHE STRING "") -set(ENABLE_HYPREDRV OFF CACHE BOOL "") +set(ENABLE_HYPREDRV ON CACHE BOOL "") + +set(HYPREDRV_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/hypredrive-git.d062c48cc8d26a9bee92f33f3c588d071c230d30_master-f4xxel6xtoqnbkv5t2jswoya5atjav6o" CACHE PATH "") set(ENABLE_PETSC OFF CACHE BOOL "") @@ -175,21 +177,13 @@ set(ENABLE_SPHINX OFF CACHE BOOL "") set(ENABLE_UNCRUSTIFY OFF CACHE BOOL "") -#-------------------------------------------------------------------------------- -# addr2line -#-------------------------------------------------------------------------------- - -set(ENABLE_ADDR2LINE ON CACHE BOOL "") - -set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") - #-------------------------------------------------------------------------------- # Other #-------------------------------------------------------------------------------- set(ENABLE_MATHPRESSO ON CACHE BOOL "") -set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-gcc-13-cuda-12.9_tpls/gcc-13.3.1/mathpresso-geos-fzt67tuymmzyrl5lhcprtffdhnanu4xq" CACHE PATH "") +set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-gcc-13-cuda-12.9-hypredrive_tpls/gcc-13.3.1/mathpresso-geos-fzt67tuymmzyrl5lhcprtffdhnanu4xq" CACHE PATH "") set(ENABLE_XML_UPDATES ON CACHE BOOL "") diff --git a/host-configs/LLNL/matrix-toss_4_x86_64_ib-llvm@14.0.6-cuda@12.6.0.cmake b/host-configs/LLNL/matrix-toss_4_x86_64_ib-llvm@14.0.6-cuda@12.6.0.cmake index 961ecfb1481..88b72ef4f57 100644 --- a/host-configs/LLNL/matrix-toss_4_x86_64_ib-llvm@14.0.6-cuda@12.6.0.cmake +++ b/host-configs/LLNL/matrix-toss_4_x86_64_ib-llvm@14.0.6-cuda@12.6.0.cmake @@ -61,7 +61,7 @@ set(CMAKE_CUDA_COMPILER "${CUDA_TOOLKIT_ROOT_DIR}/bin/nvcc" CACHE PATH "") set(CMAKE_CUDA_ARCHITECTURES "90" CACHE STRING "") -set(CMAKE_CUDA_FLAGS "-restrict --expt-extended-lambda -Werror cross-execution-space-call,reorder,deprecated-declarations -arch sm_90" CACHE STRING "") +set(CMAKE_CUDA_FLAGS "-restrict --expt-extended-lambda -Werror cross-execution-space-call,reorder,deprecated-declarations -gencode arch=compute_90,code=sm_90" CACHE STRING "") set(CMAKE_CUDA_FLAGS_RELWITHDEBINFO "-g -lineinfo ${CMAKE_CUDA_FLAGS_RELEASE}" CACHE STRING "") @@ -79,15 +79,15 @@ set(ENABLE_HIP OFF CACHE BOOL "") set(ENABLE_CHAI ON CACHE BOOL "") -set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/chai-2025.12.0-434reoatceiqmp5nhsvqhmqqh5v66ekl" CACHE PATH "") +set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/chai-2025.12.0-434reoatceiqmp5nhsvqhmqqh5v66ekl" CACHE PATH "") -set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/raja-2025.12.0-ftze7ut2hidtld6s6557vwo7kqd7m2d2" CACHE PATH "") +set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/raja-2025.12.0-ftze7ut2hidtld6s6557vwo7kqd7m2d2" CACHE PATH "") set(ENABLE_UMPIRE ON CACHE BOOL "") -set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/umpire-2025.12.0-zvalmcwps5dsita5uhmu5g3zzwdbux7x" CACHE PATH "") +set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/umpire-2025.12.0-zvalmcwps5dsita5uhmu5g3zzwdbux7x" CACHE PATH "") -set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/camp-2025.12.0-hzukgfyf3dys4u6ehe6tjpq7r2cwpjgb" CACHE PATH "") +set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/camp-2025.12.0-hzukgfyf3dys4u6ehe6tjpq7r2cwpjgb" CACHE PATH "") #-------------------------------------------------------------------------------- # IO TPLs @@ -95,23 +95,23 @@ set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/ set(ENABLE_CALIPER ON CACHE BOOL "") -set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/caliper-2.14.0-oahv5uuriqn2vyqbzespzkrfsghxjfew" CACHE PATH "") +set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/caliper-2.14.0-oahv5uuriqn2vyqbzespzkrfsghxjfew" CACHE PATH "") -set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/adiak-0.4.0-iitjnfmanurcrmlyau4qm7kpep6q6vxt" CACHE PATH "") +set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/adiak-0.4.0-iitjnfmanurcrmlyau4qm7kpep6q6vxt" CACHE PATH "") set(ZLIB_DIR "/usr" CACHE PATH "") -set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/hdf5-1.14.6-ottiokh52c2uvkujg6s4yc63afy24e7d" CACHE PATH "") +set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/hdf5-1.14.6-ottiokh52c2uvkujg6s4yc63afy24e7d" CACHE PATH "") -set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/conduit-0.9.5-y5dwa2wdrmelzcpyx7yzayckzo3gpgrm" CACHE PATH "") +set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/conduit-0.9.5-y5dwa2wdrmelzcpyx7yzayckzo3gpgrm" CACHE PATH "") -set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/silo-4.12.0-24vfiuq62fnn5ui6uqdhvouz65zytin2" CACHE PATH "") +set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/silo-4.12.0-24vfiuq62fnn5ui6uqdhvouz65zytin2" CACHE PATH "") -set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/pugixml-1.13-rd24lxieweuz24w7ycbaryfyk6lbznmb" CACHE PATH "") +set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/pugixml-1.13-rd24lxieweuz24w7ycbaryfyk6lbznmb" CACHE PATH "") -set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/vtk-9.4.2-fnpua5soyrcqbkrqnnh4zqt6yn5hem5e" CACHE PATH "") +set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/vtk-9.4.2-fnpua5soyrcqbkrqnnh4zqt6yn5hem5e" CACHE PATH "") -set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/fmt-11.0.2-voxs6pm2ttqbwt3gszcbvcb2xmugiosj" CACHE PATH "") +set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/fmt-11.0.2-voxs6pm2ttqbwt3gszcbvcb2xmugiosj" CACHE PATH "") #-------------------------------------------------------------------------------- # System Math Libraries @@ -125,19 +125,19 @@ set(LAPACK_LIBRARIES /usr/lib64/libopenblas.so CACHE STRING "") # Math TPLs #-------------------------------------------------------------------------------- -set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/metis-5.1.0-7ultypmkrm5nnur3o6ntl557ut4zpi3a" CACHE PATH "") +set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/metis-5.1.0-7ultypmkrm5nnur3o6ntl557ut4zpi3a" CACHE PATH "") -set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/parmetis-4.0.3-l7zdwdi3icsmd2ei7lmnytikc4kitsrf" CACHE PATH "") +set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/parmetis-4.0.3-l7zdwdi3icsmd2ei7lmnytikc4kitsrf" CACHE PATH "") -set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/scotch-7.0.8-kfvnwp3qofbqvm4duccjctx23zsjfyj3" CACHE PATH "") +set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/scotch-7.0.8-kfvnwp3qofbqvm4duccjctx23zsjfyj3" CACHE PATH "") -set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/superlu-dist-9.2.1-qyykp4rzu22h7hzag5xubujl2oxl6iqu" CACHE PATH "") +set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/superlu-dist-9.2.1-qyykp4rzu22h7hzag5xubujl2oxl6iqu" CACHE PATH "") -set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/suite-sparse-5.10.1-6s5wuk2jv66hevvxm4tjnrxmad6cuqw3" CACHE PATH "") +set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/suite-sparse-5.10.1-6s5wuk2jv66hevvxm4tjnrxmad6cuqw3" CACHE PATH "") -set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/trilinos-16.1.0-ugaxqluqwxpbnupdzgkjqjcjx42k5d4n" CACHE PATH "") +set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/trilinos-16.1.0-ugaxqluqwxpbnupdzgkjqjcjx42k5d4n" CACHE PATH "") -set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-rp25dcvyczbf7kusq2gn52o2fqufn5eo" CACHE PATH "") +set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-rp25dcvyczbf7kusq2gn52o2fqufn5eo" CACHE PATH "") set(ENABLE_HYPRE_DEVICE "CUDA" CACHE STRING "") @@ -175,21 +175,13 @@ set(ENABLE_SPHINX OFF CACHE BOOL "") set(ENABLE_UNCRUSTIFY OFF CACHE BOOL "") -#-------------------------------------------------------------------------------- -# addr2line -#-------------------------------------------------------------------------------- - -set(ENABLE_ADDR2LINE ON CACHE BOOL "") - -set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") - #-------------------------------------------------------------------------------- # Other #-------------------------------------------------------------------------------- set(ENABLE_MATHPRESSO ON CACHE BOOL "") -set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/mathpresso-geos-kxwkykrmexwzjykwccwn3p4hl54nsmym" CACHE PATH "") +set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-14-cuda-12.6_tpls/llvm-14.0.6/mathpresso-geos-kxwkykrmexwzjykwccwn3p4hl54nsmym" CACHE PATH "") set(ENABLE_XML_UPDATES ON CACHE BOOL "") diff --git a/host-configs/LLNL/matrix-toss_4_x86_64_ib-llvm@19.1.3-cuda@12.9.1.cmake b/host-configs/LLNL/matrix-toss_4_x86_64_ib-llvm@19.1.3-cuda@12.9.1.cmake index f5a481a0ca4..ded82c4e0b3 100644 --- a/host-configs/LLNL/matrix-toss_4_x86_64_ib-llvm@19.1.3-cuda@12.9.1.cmake +++ b/host-configs/LLNL/matrix-toss_4_x86_64_ib-llvm@19.1.3-cuda@12.9.1.cmake @@ -61,7 +61,7 @@ set(CMAKE_CUDA_COMPILER "${CUDA_TOOLKIT_ROOT_DIR}/bin/nvcc" CACHE PATH "") set(CMAKE_CUDA_ARCHITECTURES "90" CACHE STRING "") -set(CMAKE_CUDA_FLAGS "-restrict --expt-extended-lambda -Werror cross-execution-space-call,reorder,deprecated-declarations -arch sm_90" CACHE STRING "") +set(CMAKE_CUDA_FLAGS "-restrict --expt-extended-lambda -Werror cross-execution-space-call,reorder,deprecated-declarations -gencode arch=compute_90,code=sm_90" CACHE STRING "") set(CMAKE_CUDA_FLAGS_RELWITHDEBINFO "-g -lineinfo ${CMAKE_CUDA_FLAGS_RELEASE}" CACHE STRING "") @@ -79,15 +79,15 @@ set(ENABLE_HIP OFF CACHE BOOL "") set(ENABLE_CHAI ON CACHE BOOL "") -set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/chai-2025.12.0-ib2cqysjlzt3wwjl2cufzyi3ue4uhuc7" CACHE PATH "") +set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/chai-2025.12.0-ib2cqysjlzt3wwjl2cufzyi3ue4uhuc7" CACHE PATH "") -set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/raja-2025.12.0-r37be665umopzrbi24zswofosnvh7jmz" CACHE PATH "") +set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/raja-2025.12.0-r37be665umopzrbi24zswofosnvh7jmz" CACHE PATH "") set(ENABLE_UMPIRE ON CACHE BOOL "") -set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/umpire-2025.12.0-wgk2v4jqd3unptjuwdaih7p5ulzxv47x" CACHE PATH "") +set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/umpire-2025.12.0-wgk2v4jqd3unptjuwdaih7p5ulzxv47x" CACHE PATH "") -set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/camp-2025.12.0-pbx76ulylargqljlodtht4pkntpck35q" CACHE PATH "") +set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/camp-2025.12.0-pbx76ulylargqljlodtht4pkntpck35q" CACHE PATH "") #-------------------------------------------------------------------------------- # IO TPLs @@ -95,23 +95,23 @@ set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/ set(ENABLE_CALIPER ON CACHE BOOL "") -set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/caliper-2.14.0-kehdscqwtewmtqo5dvchiuc5zazlffuz" CACHE PATH "") +set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/caliper-2.14.0-kehdscqwtewmtqo5dvchiuc5zazlffuz" CACHE PATH "") -set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/adiak-0.4.0-pxpenoo7xnjrwg5ozcdvtbiuffclwth7" CACHE PATH "") +set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/adiak-0.4.0-pxpenoo7xnjrwg5ozcdvtbiuffclwth7" CACHE PATH "") set(ZLIB_DIR "/usr" CACHE PATH "") -set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/hdf5-1.14.6-bnpjs5nouol4334iecw7htzgbdanzx5o" CACHE PATH "") +set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/hdf5-1.14.6-bnpjs5nouol4334iecw7htzgbdanzx5o" CACHE PATH "") -set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/conduit-0.9.5-6cuckjyq7gda3nufjxfynbqchpk32f34" CACHE PATH "") +set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/conduit-0.9.5-6cuckjyq7gda3nufjxfynbqchpk32f34" CACHE PATH "") -set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/silo-4.12.0-na7kwpkogxpv7phnw2nxj3wl2fdq2tgf" CACHE PATH "") +set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/silo-4.12.0-na7kwpkogxpv7phnw2nxj3wl2fdq2tgf" CACHE PATH "") -set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/pugixml-1.13-croztjo7eqsnni3vkno6zmydkeix4t3a" CACHE PATH "") +set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/pugixml-1.13-croztjo7eqsnni3vkno6zmydkeix4t3a" CACHE PATH "") -set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/vtk-9.4.2-scfh7fve7yam3m7e2fd4yvxj4ahndf7k" CACHE PATH "") +set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/vtk-9.4.2-scfh7fve7yam3m7e2fd4yvxj4ahndf7k" CACHE PATH "") -set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/fmt-11.0.2-7spm6qh5pp5lnym2whrsq3ry5ektpxyv" CACHE PATH "") +set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/fmt-11.0.2-7spm6qh5pp5lnym2whrsq3ry5ektpxyv" CACHE PATH "") #-------------------------------------------------------------------------------- # System Math Libraries @@ -125,19 +125,19 @@ set(LAPACK_LIBRARIES /usr/lib64/libopenblas.so CACHE STRING "") # Math TPLs #-------------------------------------------------------------------------------- -set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/metis-5.1.0-cnjdtwvpu6ncfkvjrcaeolixz65ph5m5" CACHE PATH "") +set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/metis-5.1.0-cnjdtwvpu6ncfkvjrcaeolixz65ph5m5" CACHE PATH "") -set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/parmetis-4.0.3-k2l6kwiu536k2mv6tuqkh2cexgutz5un" CACHE PATH "") +set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/parmetis-4.0.3-k2l6kwiu536k2mv6tuqkh2cexgutz5un" CACHE PATH "") -set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/scotch-7.0.8-ayjsxukjfngehyi4dc26f3hf4gtcwgfh" CACHE PATH "") +set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/scotch-7.0.8-ayjsxukjfngehyi4dc26f3hf4gtcwgfh" CACHE PATH "") -set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/superlu-dist-9.2.1-fxwj4hn3denaalhokks5zr7jwi62otz3" CACHE PATH "") +set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/superlu-dist-9.2.1-fxwj4hn3denaalhokks5zr7jwi62otz3" CACHE PATH "") -set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/suite-sparse-5.10.1-vludha7jex5ir5uofrvfjwuofcfa2lz2" CACHE PATH "") +set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/suite-sparse-5.10.1-vludha7jex5ir5uofrvfjwuofcfa2lz2" CACHE PATH "") -set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/trilinos-16.1.0-wmjfqvmzmnf6r6ywlltau4535jy65rdz" CACHE PATH "") +set(TRILINOS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/trilinos-16.1.0-wmjfqvmzmnf6r6ywlltau4535jy65rdz" CACHE PATH "") -set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-6r5iizitmkl4xixkqwiinqychzjdqrxq" CACHE PATH "") +set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-6r5iizitmkl4xixkqwiinqychzjdqrxq" CACHE PATH "") set(ENABLE_HYPRE_DEVICE "CUDA" CACHE STRING "") @@ -175,21 +175,13 @@ set(ENABLE_SPHINX OFF CACHE BOOL "") set(ENABLE_UNCRUSTIFY OFF CACHE BOOL "") -#-------------------------------------------------------------------------------- -# addr2line -#-------------------------------------------------------------------------------- - -set(ENABLE_ADDR2LINE ON CACHE BOOL "") - -set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") - #-------------------------------------------------------------------------------- # Other #-------------------------------------------------------------------------------- set(ENABLE_MATHPRESSO ON CACHE BOOL "") -set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/mathpresso-geos-bqegytlbvvg4io324svtlc74dzam4ifs" CACHE PATH "") +set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/matrix-llvm-19-cuda-12.9_tpls/llvm-19.1.3/mathpresso-geos-bqegytlbvvg4io324svtlc74dzam4ifs" CACHE PATH "") set(ENABLE_XML_UPDATES ON CACHE BOOL "") diff --git a/host-configs/LLNL/tuolumne-toss_4_x86_64_ib_cray-cce@20.0.0-rocm@6.4.3.cmake b/host-configs/LLNL/tuolumne-toss_4_x86_64_ib_cray-cce@20.0.0-rocm@6.4.3.cmake index 6cdb8f0d220..e5c9306c3c1 100644 --- a/host-configs/LLNL/tuolumne-toss_4_x86_64_ib_cray-cce@20.0.0-rocm@6.4.3.cmake +++ b/host-configs/LLNL/tuolumne-toss_4_x86_64_ib_cray-cce@20.0.0-rocm@6.4.3.cmake @@ -73,15 +73,15 @@ set(ROCM_PATH "/opt/rocm-6.4.3" CACHE PATH "") set(ENABLE_CHAI ON CACHE BOOL "") -set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/chai-2025.12.0-xnyu3aqqd7benfr7fkwlates66mruuth" CACHE PATH "") +set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/chai-2025.12.0-xnyu3aqqd7benfr7fkwlates66mruuth" CACHE PATH "") -set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/raja-2025.12.0-amgdvrnkwl2oh5lpddgvyupteldgl6ip" CACHE PATH "") +set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/raja-2025.12.0-amgdvrnkwl2oh5lpddgvyupteldgl6ip" CACHE PATH "") set(ENABLE_UMPIRE ON CACHE BOOL "") -set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/umpire-2025.12.0-l7ni3umhaf7f4rwoy4qhjfyrnye3oit6" CACHE PATH "") +set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/umpire-2025.12.0-l7ni3umhaf7f4rwoy4qhjfyrnye3oit6" CACHE PATH "") -set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/camp-2025.12.0-p2srwdveimzi7csrjw7o3u4ryxpaz5wm" CACHE PATH "") +set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/camp-2025.12.0-p2srwdveimzi7csrjw7o3u4ryxpaz5wm" CACHE PATH "") #-------------------------------------------------------------------------------- # IO TPLs @@ -89,23 +89,23 @@ set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpl set(ENABLE_CALIPER ON CACHE BOOL "") -set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/caliper-2.14.0-xfkj7r2zaqfuuugu2wdkppydyr3fwrph" CACHE PATH "") +set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/caliper-2.14.0-xfkj7r2zaqfuuugu2wdkppydyr3fwrph" CACHE PATH "") -set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/adiak-0.4.0-6rim24h5wdcrhoaxgpw5mldcufzkfqxb" CACHE PATH "") +set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/adiak-0.4.0-6rim24h5wdcrhoaxgpw5mldcufzkfqxb" CACHE PATH "") set(ZLIB_DIR "/usr" CACHE PATH "") -set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/hdf5-1.14.6-b55srpmbowvfsql65n2652uh5xj3n3b5" CACHE PATH "") +set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/hdf5-1.14.6-b55srpmbowvfsql65n2652uh5xj3n3b5" CACHE PATH "") -set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/conduit-0.9.5-74psmq2xghvj4rfuqymomncufbxjxb7b" CACHE PATH "") +set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/conduit-0.9.5-74psmq2xghvj4rfuqymomncufbxjxb7b" CACHE PATH "") -set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/silo-4.12.0-dvjbdqytwnsndxfskcpkdodgj6zr7k5n" CACHE PATH "") +set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/silo-4.12.0-dvjbdqytwnsndxfskcpkdodgj6zr7k5n" CACHE PATH "") -set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/pugixml-1.13-o2jle7fb6idvyr32ibcsvm552yq5xqbe" CACHE PATH "") +set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/pugixml-1.13-o2jle7fb6idvyr32ibcsvm552yq5xqbe" CACHE PATH "") -set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/vtk-9.4.2-ztzvsmp6mlmtyk5o3rpqbgn7phg7ervu" CACHE PATH "") +set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/vtk-9.4.2-ztzvsmp6mlmtyk5o3rpqbgn7phg7ervu" CACHE PATH "") -set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/fmt-11.0.2-x7b5m6zdgekxl3mmjyampxc2pmt4lgur" CACHE PATH "") +set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/fmt-11.0.2-x7b5m6zdgekxl3mmjyampxc2pmt4lgur" CACHE PATH "") #-------------------------------------------------------------------------------- # System Math Libraries @@ -119,19 +119,19 @@ set(LAPACK_LIBRARIES /usr/lib64/liblapack.so CACHE STRING "") # Math TPLs #-------------------------------------------------------------------------------- -set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/metis-5.1.0-oo45sjxzdfx4e4z3qgrmnudzvwfboi7n" CACHE PATH "") +set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/metis-5.1.0-oo45sjxzdfx4e4z3qgrmnudzvwfboi7n" CACHE PATH "") -set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/parmetis-4.0.3-onkwfgqwdwkund4tmpvzo3gif3cewf7y" CACHE PATH "") +set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/parmetis-4.0.3-onkwfgqwdwkund4tmpvzo3gif3cewf7y" CACHE PATH "") -set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/scotch-7.0.8-wphygatd54wcwziiuvi63jzkzx3pvrp7" CACHE PATH "") +set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/scotch-7.0.8-wphygatd54wcwziiuvi63jzkzx3pvrp7" CACHE PATH "") -set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/superlu-dist-9.2.1-t3fmcjdkmgtbi3il5fji6t4mihzrxzni" CACHE PATH "") +set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/superlu-dist-9.2.1-t3fmcjdkmgtbi3il5fji6t4mihzrxzni" CACHE PATH "") -set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/suite-sparse-5.10.1-x3vbz2scbieouiqnnqxoirfsvrx7fj5t" CACHE PATH "") +set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/suite-sparse-5.10.1-x3vbz2scbieouiqnnqxoirfsvrx7fj5t" CACHE PATH "") set(ENABLE_TRILINOS OFF CACHE BOOL "") -set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-bwdj6fuiqwuyd25pegpk3s6zu6bfzvju" CACHE PATH "") +set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-bwdj6fuiqwuyd25pegpk3s6zu6bfzvju" CACHE PATH "") set(ENABLE_HYPRE_DEVICE "HIP" CACHE STRING "") @@ -169,15 +169,7 @@ set(ENABLE_SPHINX OFF CACHE BOOL "") set(ENABLE_UNCRUSTIFY ON CACHE BOOL "") -set(UNCRUSTIFY_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/uncrustify-git.401a4098bce9dcc47e024987403f2d59d9ba7bd2_0.70.1-git.319-6hvpggvwvhbhd322pnqivylw2ywdkhaq/bin/uncrustify" CACHE PATH "") - -#-------------------------------------------------------------------------------- -# addr2line -#-------------------------------------------------------------------------------- - -set(ENABLE_ADDR2LINE ON CACHE BOOL "") - -set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") +set(UNCRUSTIFY_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/uncrustify-git.401a4098bce9dcc47e024987403f2d59d9ba7bd2_0.70.1-git.319-6hvpggvwvhbhd322pnqivylw2ywdkhaq/bin/uncrustify" CACHE PATH "") #-------------------------------------------------------------------------------- # Other @@ -185,7 +177,7 @@ set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") set(ENABLE_MATHPRESSO ON CACHE BOOL "") -set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/mathpresso-geos-w3ssu5ocek533pxesneyk3urbxhnhgmw" CACHE PATH "") +set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-cce-20-rocm-6.4.3_tpls/cce-20.0.0/mathpresso-geos-w3ssu5ocek533pxesneyk3urbxhnhgmw" CACHE PATH "") set(ENABLE_XML_UPDATES ON CACHE BOOL "") diff --git a/host-configs/LLNL/tuolumne-toss_4_x86_64_ib_cray-llvm-amdgpu@6.4.3-rocm@6.4.3.cmake b/host-configs/LLNL/tuolumne-toss_4_x86_64_ib_cray-llvm-amdgpu@6.4.3-rocm@6.4.3.cmake index f1dbb398895..9a69cb84a20 100644 --- a/host-configs/LLNL/tuolumne-toss_4_x86_64_ib_cray-llvm-amdgpu@6.4.3-rocm@6.4.3.cmake +++ b/host-configs/LLNL/tuolumne-toss_4_x86_64_ib_cray-llvm-amdgpu@6.4.3-rocm@6.4.3.cmake @@ -73,15 +73,15 @@ set(ROCM_PATH "/opt/rocm-6.4.3" CACHE PATH "") set(ENABLE_CHAI ON CACHE BOOL "") -set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/chai-2025.12.0-bui2qjacbspelk7pwk3ap474padtsriy" CACHE PATH "") +set(CHAI_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/chai-2025.12.0-bui2qjacbspelk7pwk3ap474padtsriy" CACHE PATH "") -set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/raja-2025.12.0-phw2uaei64dmmcxcle5ct3jsso262eny" CACHE PATH "") +set(RAJA_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/raja-2025.12.0-phw2uaei64dmmcxcle5ct3jsso262eny" CACHE PATH "") set(ENABLE_UMPIRE ON CACHE BOOL "") -set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/umpire-2025.12.0-7nyetx7q5rljh7z2bcchdutu7ugkxpas" CACHE PATH "") +set(UMPIRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/umpire-2025.12.0-7nyetx7q5rljh7z2bcchdutu7ugkxpas" CACHE PATH "") -set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/camp-2025.12.0-n4t7sxktutnfffuwc2e6z2hya4dbxiti" CACHE PATH "") +set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/camp-2025.12.0-n4t7sxktutnfffuwc2e6z2hya4dbxiti" CACHE PATH "") #-------------------------------------------------------------------------------- # IO TPLs @@ -89,23 +89,23 @@ set(CAMP_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpl set(ENABLE_CALIPER ON CACHE BOOL "") -set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/caliper-2.14.0-nchdbsxkkfwgrezu5azi4iaiwnjx6zy3" CACHE PATH "") +set(CALIPER_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/caliper-2.14.0-nchdbsxkkfwgrezu5azi4iaiwnjx6zy3" CACHE PATH "") -set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/adiak-0.4.0-x7wwsvhjq2ehtw4r7jvzjecdpcxiwfl7" CACHE PATH "") +set(ADIAK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/adiak-0.4.0-x7wwsvhjq2ehtw4r7jvzjecdpcxiwfl7" CACHE PATH "") set(ZLIB_DIR "/usr" CACHE PATH "") -set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/hdf5-1.14.6-qqfx3gxy555optxhwmffsjtwuo7wpwlo" CACHE PATH "") +set(HDF5_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/hdf5-1.14.6-qqfx3gxy555optxhwmffsjtwuo7wpwlo" CACHE PATH "") -set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/conduit-0.9.5-qqbspejhqzbjqxr7antnfuedgxehjysl" CACHE PATH "") +set(CONDUIT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/conduit-0.9.5-qqbspejhqzbjqxr7antnfuedgxehjysl" CACHE PATH "") -set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/silo-4.12.0-ale723hmqzp6vwhbqp3r7xnslpj73pww" CACHE PATH "") +set(SILO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/silo-4.12.0-ale723hmqzp6vwhbqp3r7xnslpj73pww" CACHE PATH "") -set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/pugixml-1.13-yo2g6mdyjdcz3saiq6cewsmilagincwn" CACHE PATH "") +set(PUGIXML_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/pugixml-1.13-yo2g6mdyjdcz3saiq6cewsmilagincwn" CACHE PATH "") -set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/vtk-9.4.2-7rwq4ausmeiweksccifubmdxgb6kmgjw" CACHE PATH "") +set(VTK_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/vtk-9.4.2-7rwq4ausmeiweksccifubmdxgb6kmgjw" CACHE PATH "") -set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/fmt-11.0.2-vjwb72ugeomwqz4kcgt64id6mnkgqzhp" CACHE PATH "") +set(FMT_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/fmt-11.0.2-vjwb72ugeomwqz4kcgt64id6mnkgqzhp" CACHE PATH "") #-------------------------------------------------------------------------------- # System Math Libraries @@ -119,19 +119,19 @@ set(LAPACK_LIBRARIES /usr/lib64/liblapack.so CACHE STRING "") # Math TPLs #-------------------------------------------------------------------------------- -set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/metis-5.1.0-fah7yojtygjosrxaywxuhy6arel2a5o3" CACHE PATH "") +set(METIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/metis-5.1.0-fah7yojtygjosrxaywxuhy6arel2a5o3" CACHE PATH "") -set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/parmetis-4.0.3-ztyzko3dlrcb5mfhkvxdwvgoyyq7wbl3" CACHE PATH "") +set(PARMETIS_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/parmetis-4.0.3-ztyzko3dlrcb5mfhkvxdwvgoyyq7wbl3" CACHE PATH "") -set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/scotch-7.0.8-5t6uibtbtbfdbkisch7rgxvy44pgw6pm" CACHE PATH "") +set(SCOTCH_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/scotch-7.0.8-5t6uibtbtbfdbkisch7rgxvy44pgw6pm" CACHE PATH "") -set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/superlu-dist-9.2.1-m66d72gxlkboj7tdkfmuxww2auhzraii" CACHE PATH "") +set(SUPERLU_DIST_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/superlu-dist-9.2.1-m66d72gxlkboj7tdkfmuxww2auhzraii" CACHE PATH "") -set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/suite-sparse-5.10.1-iwxia6d76g2r6dwnto2iajidfws2j3ts" CACHE PATH "") +set(SUITESPARSE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/suite-sparse-5.10.1-iwxia6d76g2r6dwnto2iajidfws2j3ts" CACHE PATH "") set(ENABLE_TRILINOS OFF CACHE BOOL "") -set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-jiobpmxaz3fp5dp6wt5tyqewmzv3a3q6" CACHE PATH "") +set(HYPRE_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/hypre-git.8b0093306228fef1b92384d9face7fbe5a63b460_master-jiobpmxaz3fp5dp6wt5tyqewmzv3a3q6" CACHE PATH "") set(ENABLE_HYPRE_DEVICE "HIP" CACHE STRING "") @@ -169,15 +169,7 @@ set(ENABLE_SPHINX OFF CACHE BOOL "") set(ENABLE_UNCRUSTIFY ON CACHE BOOL "") -set(UNCRUSTIFY_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/uncrustify-git.401a4098bce9dcc47e024987403f2d59d9ba7bd2_0.70.1-git.319-b7rjjhdbf6yqcn5br6rzvsngyvb2i4ha/bin/uncrustify" CACHE PATH "") - -#-------------------------------------------------------------------------------- -# addr2line -#-------------------------------------------------------------------------------- - -set(ENABLE_ADDR2LINE ON CACHE BOOL "") - -set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") +set(UNCRUSTIFY_EXECUTABLE "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/uncrustify-git.401a4098bce9dcc47e024987403f2d59d9ba7bd2_0.70.1-git.319-b7rjjhdbf6yqcn5br6rzvsngyvb2i4ha/bin/uncrustify" CACHE PATH "") #-------------------------------------------------------------------------------- # Other @@ -185,7 +177,7 @@ set(ADDR2LINE_EXEC "/usr/bin/addr2line" CACHE PATH "") set(ENABLE_MATHPRESSO ON CACHE BOOL "") -set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-04-03/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/mathpresso-geos-nolryyeptxklghofeiszkkyyhd6don35" CACHE PATH "") +set(MATHPRESSO_DIR "/usr/WS1/GEOS/GEOSX/TPLs_2026-05-05/tuolumne-llvm-amdgpu-6.4.3_tpls/llvm-amdgpu-6.4.3/mathpresso-geos-nolryyeptxklghofeiszkkyyhd6don35" CACHE PATH "") set(ENABLE_XML_UPDATES ON CACHE BOOL "") diff --git a/inputFiles/poromechanics/poroElasticCoupling.ats b/inputFiles/poromechanics/poroElasticCoupling.ats index df11ee9ec8e..adfd5cf05ae 100644 --- a/inputFiles/poromechanics/poroElasticCoupling.ats +++ b/inputFiles/poromechanics/poroElasticCoupling.ats @@ -1,4 +1,16 @@ -from geos.ats.test_builder import TestDeck, RestartcheckParameters, generate_geos_tests +import os + +from ats.tests import AtsTest +from geos.ats.test_builder import (TestDeck, RestartcheckParameters, + collect_block_names, logger, + test_build_failures) +from geos.ats.test_case import TestCase +from geos.ats.test_steps import geos + + +TEST_TIMELIMITS = { + "PoroElastic_hybridHexPrism_co2_fim_3d_01": "45m", +} class Description(object): @@ -72,6 +84,95 @@ def _build_poro_elastic_coupling_case(deck, cycles, partitions, description, restartcheck_params=RestartcheckParameters(**restartcheck_params)) +def _generate_poro_elastic_coupling_tests(decks, test_type='smoke'): + for ii, deck in enumerate(decks): + + restartcheck_params = None + curvecheck_params = None + + if deck.restartcheck_params is not None: + restartcheck_params = deck.restartcheck_params.as_dict() + + if deck.curvecheck_params is not None: + curvecheck_params = deck.curvecheck_params.as_dict() + + for partition in deck.partitions: + nx, ny, nz = partition + n_ranks = nx * ny * nz + + testcase_name = "{}_{:02d}".format(deck.name, n_ranks) + base_name = "0to{:d}".format(deck.check_step) + + xml_file = '' + for suffix in ['', f'_{test_type}']: + if os.path.isfile("{}{}.xml".format(deck.name, suffix)): + xml_file = "{}{}.xml".format(deck.name, suffix) + + if not xml_file: + logger.error( + f'Could not find a matching xml file for the test: {deck.name}' + ) + test_build_failures.append(deck.name) + continue + + xml_blocks = collect_block_names(xml_file) + + checks = [] + if curvecheck_params: + checks.append('curve') + + geos_kwargs = {} + if testcase_name in TEST_TIMELIMITS: + geos_kwargs["timelimit"] = TEST_TIMELIMITS[testcase_name] + + steps = [ + geos(deck=xml_file, + name=base_name, + np=n_ranks, + ngpu=n_ranks, + x_partitions=nx, + y_partitions=ny, + z_partitions=nz, + restartcheck_params=restartcheck_params, + curvecheck_params=curvecheck_params, + **geos_kwargs) + ] + + if deck.restart_step > 0: + checks.append('restart') + steps.append( + geos(deck=xml_file, + name="{:d}to{:d}".format(deck.restart_step, + deck.check_step), + np=n_ranks, + ngpu=n_ranks, + x_partitions=nx, + y_partitions=ny, + z_partitions=nz, + restart_file=os.path.join( + testcase_name, + "{}_restart_{:09d}".format( + base_name, deck.restart_step)), + baseline_pattern=rf"{base_name}_restart_[0-9]+\.root", + allow_rebaseline=False, + restartcheck_params=restartcheck_params, + **geos_kwargs)) + + AtsTest.stick(level=ii) + AtsTest.stick(checks=','.join(checks)) + AtsTest.stick(solvers=','.join(xml_blocks.get('Solvers', []))) + AtsTest.stick(outputs=','.join(xml_blocks.get('Outputs', []))) + AtsTest.stick( + constitutive_models=','.join( + xml_blocks.get('Constitutive', []))) + TestCase(name=testcase_name, + desc=deck.description, + label="auto", + owner="GEOS team", + independent=True, + steps=steps) + + def _build_Terzaghi_cases(): description = Description("Terzaghi's 1D Consolidation", "auto", "Nicola Castelletto", True) @@ -333,7 +434,7 @@ def test_poro_elastic_coupling_cases(): _build_PoroElasticCarmanKozenySequential_cases() ] - generate_geos_tests(deck_instances) + _generate_poro_elastic_coupling_tests(deck_instances) test_poro_elastic_coupling_cases() diff --git a/scripts/ci_build_and_test_in_container.sh b/scripts/ci_build_and_test_in_container.sh index 61a6ef16a39..2709ae3dbaf 100755 --- a/scripts/ci_build_and_test_in_container.sh +++ b/scripts/ci_build_and_test_in_container.sh @@ -106,8 +106,12 @@ Usage: $0 Request for the build of geos only. --cmake-build-type ... One of Debug, Release, RelWithDebInfo and MinSizeRel. Forwarded to CMAKE_BUILD_TYPE. + --cmake-cuda-architectures ... + Optional override for CMAKE_CUDA_ARCHITECTURES. --code-coverage run a code build and test. + --ctest-parallel-level N + Number of tests ctest may run in parallel. --data-basename output.tar.gz If some data needs to be extracted from the build, the argument will define the tarball. Has to be a `tar.gz`. --geos-enable-bounds-check @@ -134,6 +138,8 @@ Usage: $0 Do not run the unit tests (but they will be built). --nproc N Number of cores to use for the build. + --use-native-architecture + Build with compiler flags targeting the native runner CPU. --repository /path/to/repository Internal mountpoint where the geos repository will be available. --run-integrated-tests @@ -153,7 +159,7 @@ exit 1 # Then we'll move to the build dir. or_die cd $(dirname $0)/.. -args=$(or_die getopt -a -o h --long build-exe-only,cmake-build-type:,code-coverage,data-basename:,geos-enable-bounds-check:,enable-hypre:,enable-hypre-device:,enable-trilinos:,exchange-dir:,host-config:,install-dir-basename:,makefile,ninja,no-install-schema,no-run-unit-tests,nproc:,repository:,run-integrated-tests,sccache-config:,test-code-style,test-documentation,use-sccache,help -- "$@") +args=$(or_die getopt -a -o h --long build-exe-only,cmake-build-type:,cmake-cuda-architectures:,code-coverage,ctest-parallel-level:,data-basename:,geos-enable-bounds-check:,enable-hypre:,enable-hypre-device:,enable-trilinos:,exchange-dir:,host-config:,install-dir-basename:,makefile,ninja,no-install-schema,no-run-unit-tests,nproc:,repository:,run-integrated-tests,sccache-config:,test-code-style,test-documentation,use-native-architecture,use-sccache,help -- "$@") # Variables with default values BUILD_EXE_ONLY=false @@ -170,10 +176,15 @@ TEST_CODE_STYLE=false TEST_DOCUMENTATION=false ENABLE_TRILINOS=OFF CODE_COVERAGE=false +CTEST_PARALLEL_LEVEL_ARG="" NPROC="$(nproc)" GEOS_ENABLE_BOUNDS_CHECK=ON SCCACHE_BIN="" USE_SCCACHE=false +CMAKE_CUDA_ARCHITECTURES_ARGS=() +CMAKE_NATIVE_ARCHITECTURE_ARGS=() +ATS_CMAKE_ARGS=() +LCOV_CMAKE_ARGS="" eval set -- ${args} while : @@ -184,6 +195,9 @@ do RUN_UNIT_TESTS=false shift;; --cmake-build-type) CMAKE_BUILD_TYPE=$2; shift 2;; + --cmake-cuda-architectures) + CMAKE_CUDA_ARCHITECTURES_ARGS+=("-DCMAKE_CUDA_ARCHITECTURES=$2") + shift 2;; --ninja) BUILD_GENERATOR=$1; shift;; @@ -208,10 +222,17 @@ do --no-install-schema) GEOS_INSTALL_SCHEMA=false; shift;; --no-run-unit-tests) RUN_UNIT_TESTS=false; shift;; --nproc) NPROC=$2; shift 2;; + --use-native-architecture) + CMAKE_NATIVE_ARCHITECTURE_ARGS+=('-DCMAKE_C_FLAGS:STRING="-march=native -mtune=native"') + CMAKE_NATIVE_ARCHITECTURE_ARGS+=('-DCMAKE_CXX_FLAGS:STRING="-march=native -mtune=native"') + shift;; --repository) GEOS_SRC_DIR=$2; shift 2;; --run-integrated-tests) RUN_INTEGRATED_TESTS=true; shift;; --upload-test-baselines) UPLOAD_TEST_BASELINES=true; shift;; --code-coverage) CODE_COVERAGE=true; shift;; + --ctest-parallel-level) + CTEST_PARALLEL_LEVEL_ARG=$2 + shift 2;; --sccache-config) SCCACHE_CONFIG_FILE=$2; shift 2;; --use-sccache) USE_SCCACHE=true; shift;; --test-code-style) TEST_CODE_STYLE=true; shift;; @@ -298,16 +319,22 @@ if [ -z "${NPROC}" ]; then fi echo "Using ${NPROC} cores." +if [[ -n "${CTEST_PARALLEL_LEVEL_ARG}" ]]; then + export CTEST_PARALLEL_LEVEL="${CTEST_PARALLEL_LEVEL_ARG}" + echo "Running ctest with CTEST_PARALLEL_LEVEL=${CTEST_PARALLEL_LEVEL}." +fi + if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then phase_start "Set up integrated test environment" echo "Running the integrated tests has been requested." # We install the python environment required by ATS to run the integrated tests. - #or_die apt-get update - or_die apt-get install -y virtualenv python3-dev python-is-python3 + or_die apt-get update + or_die apt-get install -y python3-dev python3-venv ATS_PYTHON_HOME=/tmp/run_integrated_tests_virtualenv - or_die virtualenv ${ATS_PYTHON_HOME} + or_die python3 -m venv ${ATS_PYTHON_HOME} - python3 -m pip cache purge + or_die ${ATS_PYTHON_HOME}/bin/python3 -m pip install --upgrade pip setuptools wheel + ${ATS_PYTHON_HOME}/bin/python3 -m pip cache purge # Setup a temporary directory to hold tests tempdir=$(mktemp -d) @@ -316,7 +343,12 @@ if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then ATS_WORKING_DIR=$tempdir/GEOS_integratedTests_working export ATS_FILTER="np<=32" - ATS_CMAKE_ARGS="-DATS_ARGUMENTS=\"--machine openmpi --ats openmpi_mpirun=/usr/bin/mpirun --ats openmpi_args=--allow-run-as-root --ats openmpi_procspernode=32 --ats openmpi_maxprocs=32\" -DPython3_ROOT_DIR=${ATS_PYTHON_HOME} -DPython3_EXECUTABLE=${ATS_PYTHON_HOME}/bin/python3 -DATS_BASELINE_DIR=${ATS_BASELINE_DIR} -DATS_WORKING_DIR=${ATS_WORKING_DIR}" + ATS_ARGUMENTS="--machine openmpi --ats openmpi_mpirun=/usr/bin/mpirun --ats openmpi_args=--allow-run-as-root --ats openmpi_procspernode=32 --ats openmpi_maxprocs=32 --ats cutoff=45m" + ATS_CMAKE_ARGS=("-DATS_ARGUMENTS:STRING=\"${ATS_ARGUMENTS}\"" + "-DPython3_ROOT_DIR=${ATS_PYTHON_HOME}" + "-DPython3_EXECUTABLE=${ATS_PYTHON_HOME}/bin/python3" + "-DATS_BASELINE_DIR=${ATS_BASELINE_DIR}" + "-DATS_WORKING_DIR=${ATS_WORKING_DIR}") phase_finish 0 fi @@ -324,6 +356,36 @@ fi if [[ "${CODE_COVERAGE}" = true ]]; then or_die apt-get update or_die apt-get install -y lcov + + LCOV_REAL=$(command -v lcov || true) + if [[ -n "${LCOV_REAL}" ]]; then + export GEOS_REAL_LCOV="${LCOV_REAL}" + LCOV_WRAPPER=/tmp/geos-lcov-wrapper + cat > "${LCOV_WRAPPER}" <<'EOF' +#!/bin/bash +set -e + +extra_args=() +if "${GEOS_REAL_LCOV}" --version 2>&1 | grep -Eq 'LCOV version ([2-9]|[1-9][0-9])\.'; then + for arg in "$@"; do + case "${arg}" in + --capture|-c) + extra_args=(--ignore-errors mismatch,empty) + break + ;; + --remove|-r) + extra_args=(--ignore-errors unused) + break + ;; + esac + done +fi + +exec "${GEOS_REAL_LCOV}" "${extra_args[@]}" "$@" +EOF + or_die chmod +x "${LCOV_WRAPPER}" + LCOV_CMAKE_ARGS="-DLCOV_EXECUTABLE=${LCOV_WRAPPER}" + fi fi # The -DBLT_MPI_COMMAND_APPEND="--allow-run-as-root;--oversubscribe" option is added for OpenMPI. @@ -355,8 +417,11 @@ or_die python3 scripts/config-build.py \ -DGEOS_LA_INTERFACE:PATH=${GEOS_LA_INTERFACE} \ -DENABLE_COVERAGE=$([[ "${CODE_COVERAGE}" = true ]] && echo 1 || echo 0) \ -DGEOS_ENABLE_BOUNDS_CHECK=${GEOS_ENABLE_BOUNDS_CHECK} \ + "${CMAKE_CUDA_ARCHITECTURES_ARGS[@]}" \ + "${CMAKE_NATIVE_ARCHITECTURE_ARGS[@]}" \ ${SCCACHE_CMAKE_ARGS} \ - ${ATS_CMAKE_ARGS} + ${LCOV_CMAKE_ARGS} \ + "${ATS_CMAKE_ARGS[@]}" phase_finish 0 # The configuration step is now over, we can now move to the build directory for the build! @@ -432,8 +497,13 @@ if [[ "${RUN_UNIT_TESTS}" = true ]]; then fi if [[ "${RUN_INTEGRATED_TESTS}" = true ]]; then - # fix the setuptools/distutils conflict - export SETUPTOOLS_USE_DISTUTILS=stdlib + PYTHON_MINOR_VERSION="$(${ATS_PYTHON_HOME}/bin/python3 -c 'import sys; print(sys.version_info.minor if sys.version_info.major == 3 else 99)')" + if (( PYTHON_MINOR_VERSION < 12 )); then + # fix the setuptools/distutils conflict + export SETUPTOOLS_USE_DISTUTILS=stdlib + else + unset SETUPTOOLS_USE_DISTUTILS + fi # We split the process in two steps. First installing the environment, then running the tests. phase_start "Build ATS environment" diff --git a/scripts/setupPythonEnvironment.bash b/scripts/setupPythonEnvironment.bash index 9868b75e1ab..fdf478884d3 100755 --- a/scripts/setupPythonEnvironment.bash +++ b/scripts/setupPythonEnvironment.bash @@ -131,11 +131,12 @@ do echo " $p" # Try installing the package - if $VERBOSE - INSTALL_MSG=$($PYTHON_TARGET -m $PIP_CMD install --upgrade $PACKAGE_DIR/$p) - INSTALL_RC=$? + if [[ "${VERBOSE}" == true ]] then - INSTALL_MSG=$($PYTHON_TARGET -m $PIP_CMD install --upgrade $PACKAGE_DIR/$p 2>&1) + INSTALL_MSG=$("${PYTHON_TARGET}" -m ${PIP_CMD} install --upgrade "${PACKAGE_DIR}/${p}") + INSTALL_RC=$? + else + INSTALL_MSG=$("${PYTHON_TARGET}" -m ${PIP_CMD} install --upgrade "${PACKAGE_DIR}/${p}" 2>&1) INSTALL_RC=$? fi @@ -237,4 +238,3 @@ fi echo "Done!" - diff --git a/src/cmake/GeosxOptions.cmake b/src/cmake/GeosxOptions.cmake index fd566db2d62..1840f699809 100644 --- a/src/cmake/GeosxOptions.cmake +++ b/src/cmake/GeosxOptions.cmake @@ -177,6 +177,15 @@ if (ENABLE_GBENCHMARK) ) endif() +if( GEOS_ENABLE_FPE ) + check_cxx_compiler_flag( "-ffp-exception-behavior=strict" GEOS_CXX_HAS_FP_EXCEPTION_BEHAVIOR_STRICT) + if( GEOS_CXX_HAS_FP_EXCEPTION_BEHAVIOR_STRICT ) + blt_append_custom_compiler_flag( FLAGS_VAR CMAKE_CXX_FLAGS CLANG "-ffp-exception-behavior=strict" ) + else() + message( WARNING "GEOS_ENABLE_FPE is ON, but ${CMAKE_CXX_COMPILER_ID} does not support -ffp-exception-behavior=strict." ) + endif() +endif() + if( ${CMAKE_MAKE_PROGRAM} STREQUAL "ninja" OR ${CMAKE_MAKE_PROGRAM} MATCHES ".*/ninja$" ) set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GEOS_NINJA_FLAGS}" ) endif() diff --git a/src/coreComponents/schema/schema.xsd.other b/src/coreComponents/schema/schema.xsd.other index 5bcdf600de2..469438cab1a 100644 --- a/src/coreComponents/schema/schema.xsd.other +++ b/src/coreComponents/schema/schema.xsd.other @@ -526,7 +526,7 @@ A field can represent a physical variable. (pressure, temperature, global compos - + @@ -1603,7 +1603,7 @@ A field can represent a physical variable. (pressure, temperature, global compos - + From e4334c2fabd4a91fd75117ab2ab4c666c9d7ac38 Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Thu, 7 May 2026 17:23:32 +0200 Subject: [PATCH 26/53] use match_results::suffix instead of pos + len --- src/coreComponents/common/logger/ErrorHandling.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreComponents/common/logger/ErrorHandling.cpp b/src/coreComponents/common/logger/ErrorHandling.cpp index 75dd7f98ec1..a21a7348bb4 100644 --- a/src/coreComponents/common/logger/ErrorHandling.cpp +++ b/src/coreComponents/common/logger/ErrorHandling.cpp @@ -223,7 +223,7 @@ DiagnosticMsgBuilder & DiagnosticMsgBuilder::addCallStackInfo( std::string_view std::regex_search( stackLine, m, cpptracePattern ) ) { m_errorMsg.m_isValidStackTrace = true; - m_errorMsg.m_sourceCallStack.push_back( stackLine.substr( m.position() + m.length() ) ); + m_errorMsg.m_sourceCallStack.push_back( m.suffix().str() ); } } From 1566e6ed08007f0ec5684e1899fc3b6f7557b339 Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Thu, 7 May 2026 17:29:57 +0200 Subject: [PATCH 27/53] remove unused exception parameter --- src/main/main.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/main/main.cpp b/src/main/main.cpp index 75e633b252f..1d9ad3657ba 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -81,7 +81,7 @@ int main( int argc, char *argv[] ) basicCleanup( false ); }; - auto onGeosException = [&]( geos::Exception & e ) + auto onGeosException = [&]( geos::Exception & ) { // GEOS generated exceptions management #ifdef GEOS_USE_CPPTRACE std::string const stacktrace = StackTrace::formatStackTrace( cpptrace::from_current_exception() ); @@ -120,13 +120,13 @@ int main( int argc, char *argv[] ) { runMain(); } - catch( NotAnError const & e ) + catch( NotAnError const & ) { - onNotAnError( e ); + onNotAnError(); } - catch( geos::Exception & e ) + catch( geos::Exception & ) { - onGeosException( e ); + onGeosException(); } catch( std::exception const & e ) { From 2a8971dff07db3ca0528580f7d83c0d6bd27a490 Mon Sep 17 00:00:00 2001 From: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> Date: Thu, 7 May 2026 19:42:03 -0500 Subject: [PATCH 28/53] feat: Add single phase viscosity dependency on temperature (#4029) * Add temperature dependency of viscosity * Update inputFiles/singlePhaseFlow/thermalSinglePhaseFlow.ats Co-authored-by: Jian Huang <53012159+jhuang2601@users.noreply.github.com> * Update src/coreComponents/constitutive/docs/CompressibleSinglePhaseFluid.rst Co-authored-by: Jian Huang <53012159+jhuang2601@users.noreply.github.com> * Update baseline for integrated tests * Update BASELINE_NOTES.md * Change restart point * Update src/coreComponents/constitutive/fluid/singlefluid/ThermalCompressibleSinglePhaseFluid.hpp Co-authored-by: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> * expansivity -> temperature coefficient * Updating baselines * Update baseline path in integrated tests configuration * Update baseline entry for PR #4029 with new date * Update baseline for integrated tests * Update baseline entry date and link for PR #4029 * Correct date for PR #4029 in baseline notes Updated the date for PR #4029 to 2026-05-06. --------- Co-authored-by: Jian Huang <53012159+jhuang2601@users.noreply.github.com> Co-authored-by: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 3 + .../thermalSinglePhaseFlow.ats | 7 + .../singlePhaseFlow/thermalViscosity_1d.xml | 183 ++++++++++++++++++ .../docs/CompressibleSinglePhaseFluid.rst | 56 +++++- .../ThermalCompressibleSinglePhaseFluid.cpp | 11 +- .../ThermalCompressibleSinglePhaseFluid.hpp | 12 +- src/coreComponents/schema/schema.xsd | 4 + 8 files changed, 262 insertions(+), 16 deletions(-) create mode 100644 inputFiles/singlePhaseFlow/thermalViscosity_1d.xml diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index a21eed60480..b421a007a64 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr3959-16478-faf1698 + baseline: integratedTests/baseline_integratedTests-pr4029-16507-7e3d8b5 allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index 05c25880f29..5617896e12c 100644 --- a/BASELINE_NOTES.md +++ b/BASELINE_NOTES.md @@ -5,6 +5,9 @@ This file is designed to track changes to the integrated test baselines. Any developer who updates the baseline ID in the .integrated_tests.yaml file is expected to create an entry in this file with the pull request number, date, and their justification for rebaselining. These notes should be in reverse-chronological order, and use the following time format: (YYYY-MM-DD). +PR #4029 (2026-05-06) +Add single phase viscosity dependency on temperature + PR #3959 (2026-05-04) Add reference thermal conductivity diff --git a/inputFiles/singlePhaseFlow/thermalSinglePhaseFlow.ats b/inputFiles/singlePhaseFlow/thermalSinglePhaseFlow.ats index 84830049dc3..a8681877cbb 100644 --- a/inputFiles/singlePhaseFlow/thermalSinglePhaseFlow.ats +++ b/inputFiles/singlePhaseFlow/thermalSinglePhaseFlow.ats @@ -45,6 +45,13 @@ decks = [ restart_step=0, check_step=1, restartcheck_params=RestartcheckParameters(**restartcheck_params)), + TestDeck( + name="thermalViscosity_1d", + description='Thermal problem with temperature dependent viscosity', + partitions=((1, 1, 1),), + restart_step=0, + check_step=1, + restartcheck_params=RestartcheckParameters(**restartcheck_params)), TestDeck( name="thermalCompressible_referenceConductivity", description='Thermal reference conductivity (1D, thermal)', diff --git a/inputFiles/singlePhaseFlow/thermalViscosity_1d.xml b/inputFiles/singlePhaseFlow/thermalViscosity_1d.xml new file mode 100644 index 00000000000..fd24ed980ba --- /dev/null +++ b/inputFiles/singlePhaseFlow/thermalViscosity_1d.xml @@ -0,0 +1,183 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/coreComponents/constitutive/docs/CompressibleSinglePhaseFluid.rst b/src/coreComponents/constitutive/docs/CompressibleSinglePhaseFluid.rst index 1781ed99222..2b8b4e3d0fd 100644 --- a/src/coreComponents/constitutive/docs/CompressibleSinglePhaseFluid.rst +++ b/src/coreComponents/constitutive/docs/CompressibleSinglePhaseFluid.rst @@ -9,31 +9,46 @@ Overview This model represents a compressible single-phase fluid with constant compressibility and pressure-dependent viscosity. +For thermal simulations, fluid density and viscosity are temperature-dependent, governed by a constant thermal +expansion coefficient and a constant temperature-viscosity coefficient, respectively. These assumptions are valid for slightly compressible fluids, such as water, and some types of oil with negligible amounts of dissolved gas. Specifically, fluid density is computed as .. math:: - \rho(p) = \rho_0 ( e^{c_\rho(p - p_0)} + e^{\beta_f (T - T_0)} ) + \rho(p) = \rho_0 e^{c_\rho(p - p_0)} -where :math:`c_\rho` is compressibility, :math:`p_0` is reference pressure, :math:`\rho_0` is -density at reference pressure, :math:`\beta_f` is the fluid thermal expansion coefficient, :math:`T_0` is reference temperature. +for isothermal cases and, + +.. math:: + \rho(p,T) = \rho_0 e^{c_\rho(p - p_0)} e^{-\beta_\rho (T - T_0)} + +for thermal cases. + +where :math:`c_\rho` is compressibility, :math:`p_0` is reference pressure, :math:`\rho_0` is the +density at the reference pressure, :math:`\beta_\rho` is the fluid thermal expansion coefficient, +:math:`T_0` is reference temperature. Similarly, .. math:: \mu(p) = \mu_0 e^{c_\mu(p - p_0)} -where :math:`c_\mu` is viscosibility (viscosity compressibility), :math:`\mu_0` is reference viscosity. +for isothermal cases and, -Either exponent may be approximated by linear (default) or quadratic terms of Taylor series expansion. -Currently there is no temperature dependence in the model, although it may be added in future. +.. math:: + \mu(p,T) = \mu_0 e^{c_\mu(p - p_0)} e^{-\beta_\mu (T - T_0)} + +for thermal cases. + +where :math:`c_\mu` is viscosibility (viscosity compressibility), :math:`\mu_0` is reference viscosity, +:math:`\beta_\rho` is the fluid viscosity thermal coefficient. Parameters ========================= -The model is represented by ```` node in the input. +For the isothermal case, the model is represented by ```` node in the input. The following attributes are supported: @@ -51,4 +66,29 @@ Example compressibility="1e-19" referenceViscosity="0.001" viscosibility="0.0"/> - \ No newline at end of file + + +For the thermal case, the model is represented by ```` node in the input. + +The following attributes are supported: + +.. include:: /docs/sphinx/datastructure/ThermalCompressibleSinglePhaseFluid.rst + +Example +========================= + +.. code-block:: xml + + + + diff --git a/src/coreComponents/constitutive/fluid/singlefluid/ThermalCompressibleSinglePhaseFluid.cpp b/src/coreComponents/constitutive/fluid/singlefluid/ThermalCompressibleSinglePhaseFluid.cpp index e52ab6a878e..d8a6e2c16d4 100644 --- a/src/coreComponents/constitutive/fluid/singlefluid/ThermalCompressibleSinglePhaseFluid.cpp +++ b/src/coreComponents/constitutive/fluid/singlefluid/ThermalCompressibleSinglePhaseFluid.cpp @@ -32,12 +32,18 @@ namespace constitutive ThermalCompressibleSinglePhaseFluid::ThermalCompressibleSinglePhaseFluid( string const & name, Group * const parent ): CompressibleSinglePhaseFluid( name, parent ) { - m_numDOF=2; + m_numDOF = 2; + registerWrapper( viewKeyStruct::thermalExpansionCoeffString(), &m_thermalExpansionCoeff ). setApplyDefaultValue( 0.0 ). setInputFlag( InputFlags::OPTIONAL ). setDescription( "Fluid thermal expansion coefficient. Unit: 1/K" ); + registerWrapper( viewKeyStruct::temperatureViscosityCoefficient(), &m_temperatureViscosityCoefficient ). + setApplyDefaultValue( 0.0 ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Fluid viscosity thermal expansion coefficient at the reference temperature. Unit: 1/K" ); + registerWrapper( viewKeyStruct::specificHeatCapacityString(), &m_specificHeatCapacity ). setApplyDefaultValue( 0.0 ). setInputFlag( InputFlags::OPTIONAL ). @@ -80,6 +86,7 @@ void ThermalCompressibleSinglePhaseFluid::postInputInitialization() }; checkNonnegative( m_thermalExpansionCoeff, viewKeyStruct::thermalExpansionCoeffString() ); + checkNonnegative( m_temperatureViscosityCoefficient, viewKeyStruct::temperatureViscosityCoefficient() ); checkNonnegative( m_specificHeatCapacity, viewKeyStruct::specificHeatCapacityString() ); checkNonnegative( m_referenceInternalEnergy, viewKeyStruct::referenceInternalEnergyString() ); @@ -98,7 +105,7 @@ ThermalCompressibleSinglePhaseFluid::KernelWrapper ThermalCompressibleSinglePhaseFluid::createKernelWrapper() { return KernelWrapper( KernelWrapper::DensRelationType( m_referencePressure, m_referenceTemperature, m_referenceDensity, m_compressibility, -m_thermalExpansionCoeff ), - KernelWrapper::ViscRelationType( m_referencePressure, m_referenceViscosity, m_viscosibility ), + KernelWrapper::ViscRelationType( m_referencePressure, m_referenceTemperature, m_referenceViscosity, m_viscosibility, -m_temperatureViscosityCoefficient ), KernelWrapper::IntEnergyRelationType( m_referenceTemperature, m_referenceInternalEnergy, m_specificHeatCapacity/m_referenceInternalEnergy ), m_density.value, m_density.derivs, diff --git a/src/coreComponents/constitutive/fluid/singlefluid/ThermalCompressibleSinglePhaseFluid.hpp b/src/coreComponents/constitutive/fluid/singlefluid/ThermalCompressibleSinglePhaseFluid.hpp index 2f110c295ef..83958834e33 100644 --- a/src/coreComponents/constitutive/fluid/singlefluid/ThermalCompressibleSinglePhaseFluid.hpp +++ b/src/coreComponents/constitutive/fluid/singlefluid/ThermalCompressibleSinglePhaseFluid.hpp @@ -43,7 +43,7 @@ class ThermalCompressibleSinglePhaseUpdate : public SingleFluidBaseUpdate public: using DensRelationType = ExponentialRelation< real64, DENS_EAT, 3 >; - using ViscRelationType = ExponentialRelation< real64, VISC_EAT >; + using ViscRelationType = ExponentialRelation< real64, VISC_EAT, 3 >; using IntEnergyRelationType = ExponentialRelation< real64, INTENERGY_EAT >; using DerivOffset = constitutive::singlefluid::DerivativeOffsetC< 1 >; @@ -114,11 +114,10 @@ class ThermalCompressibleSinglePhaseUpdate : public SingleFluidBaseUpdate real64 & dEnthalpy_dPressure, real64 & dEnthalpy_dTemperature ) const override { - m_viscRelation.compute( pressure, viscosity, dViscosity_dPressure ); - dViscosity_dTemperature = 0.0; - m_densRelation.compute( pressure, temperature, density, dDensity_dPressure, dDensity_dTemperature ); + m_viscRelation.compute( pressure, temperature, viscosity, dViscosity_dPressure, dViscosity_dTemperature ); + /// Compute the internal energy (only sensitive to temperature) m_intEnergyRelation.compute( temperature, internalEnergy, dInternalEnergy_dTemperature ); dInternalEnergy_dPressure = 0.0; @@ -126,7 +125,6 @@ class ThermalCompressibleSinglePhaseUpdate : public SingleFluidBaseUpdate enthalpy = internalEnergy - m_refIntEnergy; dEnthalpy_dPressure = 0.0; dEnthalpy_dTemperature = dInternalEnergy_dTemperature; - } GEOS_HOST_DEVICE @@ -240,6 +238,7 @@ class ThermalCompressibleSinglePhaseFluid : public CompressibleSinglePhaseFluid struct viewKeyStruct : public CompressibleSinglePhaseFluid::viewKeyStruct { static constexpr char const * thermalExpansionCoeffString() { return "thermalExpansionCoeff"; } + static constexpr char const * temperatureViscosityCoefficient() { return "temperatureViscosityCoefficient"; } static constexpr char const * specificHeatCapacityString() { return "specificHeatCapacity"; } static constexpr char const * referenceTemperatureString() { return "referenceTemperature"; } static constexpr char const * referenceInternalEnergyString() { return "referenceInternalEnergy"; } @@ -255,6 +254,9 @@ class ThermalCompressibleSinglePhaseFluid : public CompressibleSinglePhaseFluid /// scalar fluid thermal expansion coefficient real64 m_thermalExpansionCoeff; + /// scalar fluid temperature-viscosity coefficient + real64 m_temperatureViscosityCoefficient; + /// scalar fluid volumetric heat capacity coefficient real64 m_specificHeatCapacity; diff --git a/src/coreComponents/schema/schema.xsd b/src/coreComponents/schema/schema.xsd index 9a9bb51d843..4805f560fa5 100644 --- a/src/coreComponents/schema/schema.xsd +++ b/src/coreComponents/schema/schema.xsd @@ -8612,6 +8612,8 @@ If you want to do a three-phase simulation, please use instead wettingIntermedia + + @@ -8770,6 +8772,8 @@ To neglect hysteresis on this phase, just use the same table name for the draina + + From 4bb02177ccecba63a4de2e0c5889b37407dba817 Mon Sep 17 00:00:00 2001 From: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> Date: Fri, 8 May 2026 22:37:03 -0700 Subject: [PATCH 29/53] Fixing macOS build (#4052) * Fixing macOS build * update PVTPackage submodule hash --- src/coreComponents/constitutive/PVTPackage | 2 +- .../constitutive/solid/Damage.cpp | 2 ++ .../physicsSolvers/PhysicsSolverBase.cpp | 17 +++++++++-------- .../physicsSolvers/fluidFlow/CMakeLists.txt | 4 +++- .../physicsSolvers/multiphysics/CMakeLists.txt | 2 +- 5 files changed, 16 insertions(+), 11 deletions(-) diff --git a/src/coreComponents/constitutive/PVTPackage b/src/coreComponents/constitutive/PVTPackage index a2cdca31546..5f0e203391c 160000 --- a/src/coreComponents/constitutive/PVTPackage +++ b/src/coreComponents/constitutive/PVTPackage @@ -1 +1 @@ -Subproject commit a2cdca315464da11f2bdcc902c894ed1340b8572 +Subproject commit 5f0e203391c83d2c64830501438c5fd1bfcb622b diff --git a/src/coreComponents/constitutive/solid/Damage.cpp b/src/coreComponents/constitutive/solid/Damage.cpp index 1b9e0c1e5da..525d6e0f0bf 100644 --- a/src/coreComponents/constitutive/solid/Damage.cpp +++ b/src/coreComponents/constitutive/solid/Damage.cpp @@ -168,6 +168,8 @@ void Damage< BASE >::saveConvergedState() const } ); } +template class Damage< ElasticIsotropic >; + typedef Damage< ElasticIsotropic > DamageElasticIsotropic; REGISTER_CATALOG_ENTRY( ConstitutiveBase, DamageElasticIsotropic, string const &, Group * const ) diff --git a/src/coreComponents/physicsSolvers/PhysicsSolverBase.cpp b/src/coreComponents/physicsSolvers/PhysicsSolverBase.cpp index 3d57a8a1b38..8d05dfd6958 100644 --- a/src/coreComponents/physicsSolvers/PhysicsSolverBase.cpp +++ b/src/coreComponents/physicsSolvers/PhysicsSolverBase.cpp @@ -1651,16 +1651,17 @@ Timestamp PhysicsSolverBase::getMeshModificationTimestamp( DomainPartition & dom R1Tensor const PhysicsSolverBase::gravityVector() const { - R1Tensor rval; - if( dynamicCast< PhysicsSolverManager const * >( &getParent() ) != nullptr ) + // Avoid dynamic_cast< PhysicsSolverManager const * > here: it would force the + // base library (physicsSolversBase) to link against PhysicsSolverManager's + // typeinfo, which lives in the dependent physicsSolvers library — circular + // on macOS dylibs. Probe by wrapper presence; the gravityVector wrapper is + // only ever registered by PhysicsSolverManager. + auto const key = PhysicsSolverManager::viewKeyStruct::gravityVectorString(); + if( getParent().hasWrapper( key ) ) { - rval = getParent().getReference< R1Tensor >( PhysicsSolverManager::viewKeyStruct::gravityVectorString() ); + return getParent().getReference< R1Tensor >( key ); } - else - { - rval = {0.0, 0.0, -9.81}; - } - return rval; + return { 0.0, 0.0, -9.81 }; } bool PhysicsSolverBase::checkSequentialSolutionIncrements( DomainPartition & GEOS_UNUSED_PARAM( domain ) ) const diff --git a/src/coreComponents/physicsSolvers/fluidFlow/CMakeLists.txt b/src/coreComponents/physicsSolvers/fluidFlow/CMakeLists.txt index 70bed3ec99e..645008d0dda 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/CMakeLists.txt +++ b/src/coreComponents/physicsSolvers/fluidFlow/CMakeLists.txt @@ -213,8 +213,10 @@ generateKernels( TEMPLATE "CompositionalMultiphaseFVMKernel_thermal.cpp.template list(APPEND fluidFlowSolvers_headers ${headerFiles}) list(APPEND fluidFlowSolvers_sources ${sourceFiles}) +set( dependencyList ${parallelDeps} physicsSolversBase ) - +geos_decorate_link_dependencies( LIST decoratedDependencies + DEPENDENCIES ${dependencyList} ) blt_add_library( NAME fluidFlowSolvers diff --git a/src/coreComponents/physicsSolvers/multiphysics/CMakeLists.txt b/src/coreComponents/physicsSolvers/multiphysics/CMakeLists.txt index 976f03d0c6c..36e8a23c9c0 100644 --- a/src/coreComponents/physicsSolvers/multiphysics/CMakeLists.txt +++ b/src/coreComponents/physicsSolvers/multiphysics/CMakeLists.txt @@ -87,7 +87,7 @@ set( multiPhysicsSolvers_sources #include(poromechanicsKernels/PoromechanicsKernels.cmake) -set( dependencyList ${parallelDeps} fluidFlowSolvers simplePDESolvers solidMechanicsSolvers ) +set( dependencyList ${parallelDeps} fluidFlowSolvers simplePDESolvers solidMechanicsSolvers surfaceGeneration ) geos_decorate_link_dependencies( LIST decoratedDependencies DEPENDENCIES ${dependencyList} ) From 4015dc1778f4d5b59b16f6b8d0129aa828f6a31b Mon Sep 17 00:00:00 2001 From: Bertrand Denel <120652669+bd713@users.noreply.github.com> Date: Wed, 13 May 2026 10:20:52 -0700 Subject: [PATCH 30/53] fix: WaveEquation backward propagation and adjoint test (#4051) * Draft * tol --------- Co-authored-by: DENEL Bertrand Co-authored-by: Randolph Settgast --- .../testWavePropagationAdjoint1.cpp | 94 ++++++++----------- .../wavePropagation/shared/WaveSolverBase.cpp | 8 +- 2 files changed, 45 insertions(+), 57 deletions(-) diff --git a/src/coreComponents/integrationTests/wavePropagationTests/testWavePropagationAdjoint1.cpp b/src/coreComponents/integrationTests/wavePropagationTests/testWavePropagationAdjoint1.cpp index 025320fceb3..d5a9c29a482 100644 --- a/src/coreComponents/integrationTests/wavePropagationTests/testWavePropagationAdjoint1.cpp +++ b/src/coreComponents/integrationTests/wavePropagationTests/testWavePropagationAdjoint1.cpp @@ -44,9 +44,9 @@ char const * xmlInput = cflFactor="0.25" discretization="FE1" targetRegions="{ Region }" - sourceCoordinates="{ { 100, 250, 300 } }" + sourceCoordinates="{ { 20, 50, 60 } }" timeSourceFrequency="1" - receiverCoordinates="{ { 300.1, 350.1, 350.1 }, { 100.1, 250.1, 300.1 }, { 200.1, 325.1, 350.1 }, { 301.1, 351.1, 351.1 } }" + receiverCoordinates="{ { 60.02, 70.02, 70.02 }, { 20.02, 50.02, 60.02 }, { 40.02, 65.02, 70.02 }, { 60.22, 70.22, 70.22 } }" outputSeismoTrace="0" dtSeismoTrace="0.005"/> @@ -54,12 +54,12 @@ char const * xmlInput = getReference< localIndex >( AcousticWaveEquationSEM::viewKeyStruct::rickerOrderString() ); real64 time_n = time; - std::cout << "Begin forward:" << time_n << std::endl; - // run for 0.25s (100 steps) + GEOS_LOG_RANK_0( GEOS_FMT( "Begin forward: {}", time_n ) ); + // run for 0.25s for( int i=0; i<50; i++ ) { rhsForward[i][0]=WaveSolverUtils::evaluateRicker( time_n, *ptrTimeSourceFrequency, *ptrTimeSourceDelay, *ptrRickerOrder ); @@ -241,12 +241,6 @@ TEST_P( AcousticWaveEquationSEMTest, SeismoTrace ) // save receiver value forward on uForward. for( int i = 0; i < 51; i++ ) { - /*std::cout << "time: " << i*dt << std::endl; - std::cout << "pReceivers1 " << i << ":" << pReceivers[i][0] << std::endl; - std::cout << "pReceivers2 " << i << ":" << pReceivers[i][1] << std::endl; - std::cout << "pReceivers3 " << i << ":" << pReceivers[i][2] << std::endl; - std::cout << "pReceivers4 " << i << ":" << pReceivers[i][3] << std::endl; - std::cout << "rhsForward " << i << ":" << rhsForward[i][0] << std::endl;*/ uForward[i][0] = pReceivers[i][0]; pReceivers[i][0] = 0.; pReceivers[i][1] = 0.; @@ -260,11 +254,11 @@ TEST_P( AcousticWaveEquationSEMTest, SeismoTrace ) arrayView2d< localIndex > const rNodeIds = propagator->getReference< array2d< localIndex > >( AcousticWaveEquationSEM::viewKeyStruct::receiverNodeIdsString() ).toView(); rNodeIds.move( hostMemorySpace, false ); localIndex sNodesIdsAfterModif=rNodeIds[0][0]; - std::cout << "ref back sNodeIds[0][0]:" << sNodesIdsAfterModif << std::endl; + GEOS_LOG_RANK_0( GEOS_FMT( "ref back sNodeIds[0][0]: {}", sNodesIdsAfterModif ) ); /*---------------------------------------------------*/ - std::cout << "Begin backward:" << time_n << std::endl; + GEOS_LOG_RANK_0( GEOS_FMT( "Begin backward: {}", time_n ) ); //----------Switch source and receiver1 position for backward----------------------// arrayView2d< real64 > const sCoord = propagator->getReference< array2d< real64 > >( AcousticWaveEquationSEM::viewKeyStruct::sourceCoordinatesString() ).toView(); @@ -281,17 +275,17 @@ TEST_P( AcousticWaveEquationSEMTest, SeismoTrace ) sCoord.registerTouch( hostMemorySpace ); rCoord.registerTouch( hostMemorySpace ); - std::cout << "sCoord :" << sCoord[0][0] <<" "<< sCoord[0][1] <<" "<< sCoord[0][2] << std::endl; - std::cout << "rCoord1 :" << rCoord[0][0] <<" "<< rCoord[0][1] <<" "<< rCoord[0][2] << std::endl; - std::cout << "rCoord2 :" << rCoord[1][0] <<" "<< rCoord[1][1] <<" "<< rCoord[1][2] << std::endl; - std::cout << "rCoord3 :" << rCoord[2][0] <<" "<< rCoord[2][1] <<" "<< rCoord[2][2] << std::endl; - std::cout << "rCoord4 :" << rCoord[3][0] <<" "<< rCoord[3][1] <<" "<< rCoord[3][2] << std::endl; + GEOS_LOG_RANK_0( GEOS_FMT( "sCoord : {} {} {}", sCoord[0][0], sCoord[0][1], sCoord[0][2] ) ); + GEOS_LOG_RANK_0( GEOS_FMT( "rCoord1 : {} {} {}", rCoord[0][0], rCoord[0][1], rCoord[0][2] ) ); + GEOS_LOG_RANK_0( GEOS_FMT( "rCoord2 : {} {} {}", rCoord[1][0], rCoord[1][1], rCoord[1][2] ) ); + GEOS_LOG_RANK_0( GEOS_FMT( "rCoord3 : {} {} {}", rCoord[2][0], rCoord[2][1], rCoord[2][2] ) ); + GEOS_LOG_RANK_0( GEOS_FMT( "rCoord4 : {} {} {}", rCoord[3][0], rCoord[3][1], rCoord[3][2] ) ); //change timeSourceFrequency - std::cout << "timeSourceFrequency forward:" << *ptrTimeSourceFrequency << std::endl; + GEOS_LOG_RANK_0( GEOS_FMT( "timeSourceFrequency forward: {}", *ptrTimeSourceFrequency ) ); real32 newTimeFreq=2; *ptrTimeSourceFrequency = newTimeFreq; - std::cout << "timeSourceFrequency backward:" << *ptrTimeSourceFrequency << std::endl; + GEOS_LOG_RANK_0( GEOS_FMT( "timeSourceFrequency backward: {}", *ptrTimeSourceFrequency ) ); //reinit m_indexSeismoTrace localIndex * ptrISeismo = &propagator->getReference< localIndex >( AcousticWaveEquationSEM::viewKeyStruct::indexSeismoTraceString() ); @@ -309,12 +303,17 @@ TEST_P( AcousticWaveEquationSEMTest, SeismoTrace ) arrayView2d< localIndex > const sNodeIds_new2 = propagator->getReference< array2d< localIndex > >( AcousticWaveEquationSEM::viewKeyStruct::sourceNodeIdsString() ).toView(); sNodeIds_new2.move( hostMemorySpace, false ); - std::cout << "sNodeIds[0][0] second get2:" << sNodeIds_new2[0][0] << std::endl; + GEOS_LOG_RANK_0( GEOS_FMT( "sNodeIds[0][0] second get2: {}", sNodeIds_new2[0][0] ) ); ASSERT_TRUE( sNodeIds_new2[0][0] == sNodesIdsAfterModif ); /*---------------------------------------------------*/ - // run backward solver - for( int i = 50; i > 0; i-- ) + // Run backward solver. + // Mirrors the forward loop (50 steps + cleanup gives 51 receiver slots): + // we run 51 backward iterations so that the final iteration at i=0, + // time_n=0 writes pReceivers[0] = q(0). Without this final slot, sum_qff loses + // the q(0)*f(0) boundary term and the discrete adjoint identity fails to + // single-precision tolerance. + for( int i = 50; i >= 0; i-- ) { rhsBackward[i][0]=WaveSolverUtils::evaluateRicker( time_n, *ptrTimeSourceFrequency, *ptrTimeSourceDelay, *ptrRickerOrder ); propagator->explicitStepBackward( time_n, dt, i, domain, gradient ); @@ -329,20 +328,17 @@ TEST_P( AcousticWaveEquationSEMTest, SeismoTrace ) pReceivers.move( hostMemorySpace, false ); localIndex mForward2 = propagator->getReference< localIndex >( AcousticWaveEquationSEM::viewKeyStruct::forwardString() ); - std::cout << "m_forward second get:" << mForward2 << std::endl; + GEOS_LOG_RANK_0( GEOS_FMT( "m_forward second get: {}", mForward2 ) ); ASSERT_TRUE( mForward2 == 0 ); arrayView2d< localIndex > const sNodeIds_new3 = propagator->getReference< array2d< localIndex > >( AcousticWaveEquationSEM::viewKeyStruct::sourceNodeIdsString() ).toView(); sNodeIds_new3.move( hostMemorySpace, false ); - std::cout << "sNodeIds[0][0] get3:" << sNodeIds_new3[0][0] << std::endl; + GEOS_LOG_RANK_0( GEOS_FMT( "sNodeIds[0][0] get3: {}", sNodeIds_new3[0][0] ) ); ASSERT_TRUE( sNodeIds_new3[0][0] == sNodesIdsAfterModif ); real32 const timeSourceFrequency_new = propagator->getReference< real32 >( AcousticWaveEquationSEM::viewKeyStruct::timeSourceFrequencyString() ); ASSERT_TRUE( std::abs( timeSourceFrequency_new - newTimeFreq ) < 1.e-8 ); - /*std::cout << "pReceiver size(0):" << pReceivers.size(0) << std::endl; - std::cout << "pReceiver size(1):" << pReceivers.size(1) << std::endl;*/ - /*----------Save receiver backward----------------------*/ array2d< real32 > qBackward; @@ -355,15 +351,9 @@ TEST_P( AcousticWaveEquationSEMTest, SeismoTrace ) real32 sum_ff2=0.; real32 sum_fb2=0.; - // fill backward field at receiver. - for( int i=50; i > 0; i-- ) + // fill backward field at receiver, pReceivers[i] = q(i*dt) for i=0..50. + for( int i = 0; i <= 50; i++ ) { - /*std::cout << "back time: " << i*dt << std::endl; - std::cout << "back pReceivers1 " << i << ":" << pReceivers[i][0] << std::endl; - std::cout << "back pReceivers2 " << i << ":" << pReceivers[i][1] << std::endl; - std::cout << "back pReceivers3 " << i << ":" << pReceivers[i][2] << std::endl; - std::cout << "back pReceivers4 " << i << ":" << pReceivers[i][3] << std::endl; - std::cout << "back rhsBackward " << i << ":" << rhsBackward[i][0] << std::endl;*/ qBackward[i][0] = pReceivers[i][0]; } @@ -377,23 +367,21 @@ TEST_P( AcousticWaveEquationSEMTest, SeismoTrace ) sum_q2 += qBackward[i][0]*qBackward[i][0]; sum_ff2 += rhsForward[i][0]*rhsForward[i][0]; sum_fb2 += rhsBackward[i][0]*rhsBackward[i][0]; - /*std::cout << "sum evol sum_ufb:" << sum_ufb << " / sum_qff:" << sum_qff << std::endl; - std::cout << "uForward:" << uForward[i][0] << " / qBackward:" << qBackward[i][0] << std::endl; - std::cout << "ufb:" << uForward[i][0]*rhsBackward[i][0] << " / qff:" << qBackward[i][0]*rhsForward[i][0] << std::endl;*/ } // check scalar products and are non null - ASSERT_TRUE( sum_ufb > 1.e-8 ); - ASSERT_TRUE( sum_qff > 1.e-8 ); - - // check || - ||/max(||f||.||q||,||f'||.||u||) < 10^1or2 x epsilon_machine with f rhs direct and f' rhs backward - std::cout << ": " << sum_ufb << " / : " << sum_qff << std::endl; - std::cout << "|| - ||=" << std::abs( sum_ufb-sum_qff ) << " / ||f||.||q||=" << std::sqrt( sum_q2*sum_ff2 ); - std::cout << " / ||f'||.||u||=" << std::sqrt( sum_fb2*sum_u2 ) << " / ||f||.||f'||=" << std::sqrt( sum_ff2*sum_fb2 ) << std::endl; + ASSERT_TRUE( std::abs( sum_ufb ) > 1.e-8 ); + ASSERT_TRUE( std::abs( sum_qff ) > 1.e-8 ); + + // check || - ||/max(||f||.||q||,||f'||.||u||) at single-precision machine accuracy. + GEOS_LOG_RANK_0( GEOS_FMT( ": {} / : {}", sum_ufb, sum_qff ) ); + GEOS_LOG_RANK_0( GEOS_FMT( "|| - ||={} / ||f||.||q||={} / ||f'||.||u||={} / ||f||.||f'||={}", + std::abs( sum_ufb-sum_qff ), std::sqrt( sum_q2*sum_ff2 ), + std::sqrt( sum_fb2*sum_u2 ), std::sqrt( sum_ff2*sum_fb2 ) ) ); real32 diffToCheck; diffToCheck=std::abs( sum_ufb-sum_qff ) / std::max( std::sqrt( sum_fb2*sum_u2 ), std::sqrt( sum_q2*sum_ff2 )); - std::cout << " Diff to compare with 9e-3: " << diffToCheck << std::endl; - ASSERT_TRUE( diffToCheck < 9e-3 ); + GEOS_LOG_RANK_0( GEOS_FMT( "Diff to compare with 5e-7: {}", diffToCheck ) ); + ASSERT_TRUE( diffToCheck < 5e-7 ); } INSTANTIATE_TEST_SUITE_P( diff --git a/src/coreComponents/physicsSolvers/wavePropagation/shared/WaveSolverBase.cpp b/src/coreComponents/physicsSolvers/wavePropagation/shared/WaveSolverBase.cpp index 20e62efb0c9..ca598f505df 100644 --- a/src/coreComponents/physicsSolvers/wavePropagation/shared/WaveSolverBase.cpp +++ b/src/coreComponents/physicsSolvers/wavePropagation/shared/WaveSolverBase.cpp @@ -552,10 +552,10 @@ void WaveSolverBase::computeAllSeismoTraces( real64 const time_n, if( m_nsamplesSeismoTrace == 0 ) return; integer const dir = m_forward ? +1 : -1; - integer const beginIndex = m_forward ? m_indexSeismoTrace : m_nsamplesSeismoTrace-m_indexSeismoTrace; + integer const beginIndex = m_forward ? m_indexSeismoTrace : (m_nsamplesSeismoTrace - 1) - m_indexSeismoTrace; for( localIndex iSeismo = beginIndex; iSeismo < m_nsamplesSeismoTrace; iSeismo++ ) { - localIndex seismoIndex = m_forward ? iSeismo : m_nsamplesSeismoTrace-iSeismo; + localIndex seismoIndex = m_forward ? iSeismo : (m_nsamplesSeismoTrace - 1) - iSeismo; real64 const timeSeismo = m_dtSeismoTrace * seismoIndex; if( dir * timeSeismo > dir * time_n + epsilonLoc ) break; @@ -574,10 +574,10 @@ void WaveSolverBase::compute2dVariableAllSeismoTraces( localIndex const regionIn if( m_nsamplesSeismoTrace == 0 ) return; integer const dir = m_forward ? +1 : -1; - integer const beginIndex = m_forward ? m_indexSeismoTrace : m_nsamplesSeismoTrace-m_indexSeismoTrace; + integer const beginIndex = m_forward ? m_indexSeismoTrace : (m_nsamplesSeismoTrace - 1) - m_indexSeismoTrace; for( localIndex iSeismo = beginIndex; iSeismo < m_nsamplesSeismoTrace; iSeismo++ ) { - localIndex seismoIndex = m_forward ? iSeismo : m_nsamplesSeismoTrace-iSeismo; + localIndex seismoIndex = m_forward ? iSeismo : (m_nsamplesSeismoTrace - 1) - iSeismo; real64 const timeSeismo = m_dtSeismoTrace * seismoIndex; if( dir * timeSeismo > dir * time_n + epsilonLoc ) break; From f35e287cd2350ea5ee20b1de8200ee451624932d Mon Sep 17 00:00:00 2001 From: Omar Duran Date: Wed, 13 May 2026 14:35:24 -0700 Subject: [PATCH 31/53] Refactor/oduran/speed up integration tests (#4054) * wip: decrease mesh sizes. * wip: process testFEMConsistency * wip: process testSurfaceGenerator * wip: * wip: process testMixedDimSinglePhaseFlow * wip: uncrustify * wip: remove DFN_5_fractures_hex_binarized and DFN_5_fractures_tet_binarized from mpi tests * wip: no need to test the same topology in testSurfaceGenerator * wip: no need to test the wavy meshes in testMixedDimHydrostaticEquilibrium_mpi * wip: test wavy and flat meshes in separate tests * wip: mpi test full span on tets and no boundary for hex * wip: mpi test full span meshes targeting BC data on ghosted surface cells * Trigger CI --- .../testMixedDimHydrostaticEquilibrium.cpp | 4 +- ...tMixedDimHydrostaticEquilibriumFixture.hpp | 20 ++-- ...testMixedDimHydrostaticEquilibrium_mpi.cpp | 27 +----- .../testMixedDimSinglePhaseFlow.cpp | 4 +- .../testMixedDimSinglePhaseFlowFixture.hpp | 13 +-- .../testMixedDimSinglePhaseFlow_mpi.cpp | 7 +- .../mechanicTest/testFEMConsistency.cpp | 12 +-- .../testFEMConsistencyFixture.hpp | 17 ++-- .../mechanicTest/testFEMConsistency_mpi.cpp | 29 +----- .../fractured_full_span_mesh_hex_DFN_1.vtu | 24 ++--- .../fractured_full_span_mesh_hex_DFN_12.vtu | 28 +++--- .../fractured_full_span_mesh_hex_DFN_123.vtu | 32 ++++--- .../fractured_full_span_mesh_hex_DFN_13.vtu | 28 +++--- .../fractured_full_span_mesh_hex_DFN_2.vtu | 24 ++--- .../fractured_full_span_mesh_hex_DFN_23.vtu | 28 +++--- .../fractured_full_span_mesh_hex_DFN_3.vtu | 24 ++--- .../fractured_full_span_mesh_tet_DFN_1.vtu | 16 ++-- .../fractured_full_span_mesh_tet_DFN_12.vtu | 20 ++-- .../fractured_full_span_mesh_tet_DFN_123.vtu | 24 +++-- .../fractured_full_span_mesh_tet_DFN_13.vtu | 20 ++-- .../fractured_full_span_mesh_tet_DFN_2.vtu | 16 ++-- .../fractured_full_span_mesh_tet_DFN_23.vtu | 20 ++-- .../fractured_full_span_mesh_tet_DFN_3.vtu | 16 ++-- .../dfn_market/fractured_mesh_hex_DFN_1.vtu | 10 +- .../dfn_market/fractured_mesh_hex_DFN_12.vtu | 14 ++- .../dfn_market/fractured_mesh_hex_DFN_123.vtu | 18 ++-- .../dfn_market/fractured_mesh_hex_DFN_13.vtu | 14 ++- .../dfn_market/fractured_mesh_hex_DFN_2.vtu | 10 +- .../dfn_market/fractured_mesh_hex_DFN_23.vtu | 14 ++- .../dfn_market/fractured_mesh_hex_DFN_3.vtu | 10 +- .../dfn_market/fractured_mesh_tet_DFN_1.vtu | 16 ++-- .../dfn_market/fractured_mesh_tet_DFN_12.vtu | 20 ++-- .../dfn_market/fractured_mesh_tet_DFN_123.vtu | 24 +++-- .../dfn_market/fractured_mesh_tet_DFN_13.vtu | 20 ++-- .../dfn_market/fractured_mesh_tet_DFN_2.vtu | 16 ++-- .../dfn_market/fractured_mesh_tet_DFN_23.vtu | 20 ++-- .../dfn_market/fractured_mesh_tet_DFN_3.vtu | 16 ++-- ...ractured_wavy_full_span_mesh_hex_DFN_1.vtu | 24 ++--- ...actured_wavy_full_span_mesh_hex_DFN_12.vtu | 28 +++--- ...ctured_wavy_full_span_mesh_hex_DFN_123.vtu | 32 ++++--- ...actured_wavy_full_span_mesh_hex_DFN_13.vtu | 28 +++--- ...ractured_wavy_full_span_mesh_hex_DFN_2.vtu | 24 ++--- ...actured_wavy_full_span_mesh_hex_DFN_23.vtu | 28 +++--- ...ractured_wavy_full_span_mesh_hex_DFN_3.vtu | 24 ++--- ...ractured_wavy_full_span_mesh_tet_DFN_1.vtu | 18 ++-- ...actured_wavy_full_span_mesh_tet_DFN_12.vtu | 22 +++-- ...ctured_wavy_full_span_mesh_tet_DFN_123.vtu | 26 ++++-- ...actured_wavy_full_span_mesh_tet_DFN_13.vtu | 22 +++-- ...ractured_wavy_full_span_mesh_tet_DFN_2.vtu | 18 ++-- ...actured_wavy_full_span_mesh_tet_DFN_23.vtu | 22 +++-- ...ractured_wavy_full_span_mesh_tet_DFN_3.vtu | 18 ++-- .../fractured_wavy_mesh_hex_DFN_1.vtu | 10 +- .../fractured_wavy_mesh_hex_DFN_12.vtu | 14 ++- .../fractured_wavy_mesh_hex_DFN_123.vtu | 18 ++-- .../fractured_wavy_mesh_hex_DFN_13.vtu | 14 ++- .../fractured_wavy_mesh_hex_DFN_2.vtu | 10 +- .../fractured_wavy_mesh_hex_DFN_23.vtu | 14 ++- .../fractured_wavy_mesh_hex_DFN_3.vtu | 10 +- .../fractured_wavy_mesh_tet_DFN_1.vtu | 18 ++-- .../fractured_wavy_mesh_tet_DFN_12.vtu | 22 +++-- .../fractured_wavy_mesh_tet_DFN_123.vtu | 26 ++++-- .../fractured_wavy_mesh_tet_DFN_13.vtu | 22 +++-- .../fractured_wavy_mesh_tet_DFN_2.vtu | 18 ++-- .../fractured_wavy_mesh_tet_DFN_23.vtu | 22 +++-- .../fractured_wavy_mesh_tet_DFN_3.vtu | 18 ++-- .../t_shaped_wavy_mesh_hex_DFN_t1t2.vtu | 14 ++- .../t_shaped_wavy_mesh_tet_DFN_t1t2.vtu | 42 +++++---- .../y_shaped_wavy_mesh_hex_DFN_y1y2y3.vtu | 18 ++-- .../y_shaped_wavy_mesh_tet_DFN_y1y2y3.vtu | 48 ++++++---- .../meshTests/testSurfaceGenerator_mpi.cpp | 92 ++++++------------- .../mesh/generators/MeshGeneratorBase.cpp | 9 +- 71 files changed, 819 insertions(+), 649 deletions(-) diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibrium.cpp b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibrium.cpp index ef23605d585..9b7b92db896 100644 --- a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibrium.cpp +++ b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibrium.cpp @@ -45,9 +45,7 @@ INSTANTIATE_TEST_SUITE_P( "DFN_5_fractures_hex_binarized.vtu", "DFN_5_fractures_tet_binarized.vtu" ), - ::testing::Values( - std::make_tuple( 1, 1, 1 ) - ) + ::testing::Values( 1 ) ) ); diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibriumFixture.hpp b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibriumFixture.hpp index cd80290dcfc..b73c7f2b35c 100644 --- a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibriumFixture.hpp +++ b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibriumFixture.hpp @@ -60,10 +60,10 @@ extern CommandLineOptions g_commandLineOptions; * * 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 + * - int: Number of MPI partitions */ class MixedDimHydrostaticEquilibriumTest - : public ::testing::TestWithParam< std::tuple< std::string, std::tuple< int, int, int > > > + : public ::testing::TestWithParam< std::tuple< std::string, int > > { protected: void SetUp() override @@ -240,10 +240,7 @@ class MixedDimHydrostaticEquilibriumTest 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 ); + int const n_partitions = std::get< 1 >( GetParam() ); std::string nodeSetNames = "{ f1_node_set }"; if( meshFileName.find( "_DFN_123.vtu" ) != std::string::npos ) @@ -292,10 +289,7 @@ TEST_P( MixedDimHydrostaticEquilibriumTest, Run ) 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 xmlName = "test_hydrostatic_" + baseName + "_" + std::to_string( n_partitions ); 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 ) @@ -309,9 +303,9 @@ TEST_P( MixedDimHydrostaticEquilibriumTest, Run ) 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->xPartitionsOverride = n_partitions; + options->yPartitionsOverride = 0; + options->zPartitionsOverride = 0; options->overridePartitionNumbers = true; GeosxState state( std::move( options ) ); diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibrium_mpi.cpp b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibrium_mpi.cpp index 782a13e6040..0f1745c3018 100644 --- a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibrium_mpi.cpp +++ b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimHydrostaticEquilibrium_mpi.cpp @@ -33,38 +33,15 @@ INSTANTIATE_TEST_SUITE_P( 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" + "fractured_full_span_mesh_tet_DFN_123.vtu" ), - ::testing::Values( - std::make_tuple( 1, 4, 1 ), - std::make_tuple( 2, 1, 2 ) - ) + ::testing::Values( 4 ) ) ); diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlow.cpp b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlow.cpp index 733618dabf7..8c4d77927ff 100644 --- a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlow.cpp +++ b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlow.cpp @@ -33,9 +33,7 @@ INSTANTIATE_TEST_SUITE_P( "fractured_mesh_hex_DFN_123.vtu" ), ::testing::Bool(), - ::testing::Values( - std::make_tuple( 1, 1, 1 ) - ) + ::testing::Values( 1 ) ) ); diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlowFixture.hpp b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlowFixture.hpp index d1d64b370f8..635b77593ef 100644 --- a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlowFixture.hpp +++ b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlowFixture.hpp @@ -56,7 +56,7 @@ extern CommandLineOptions g_commandLineOptions; * - 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 > > > +class MixedDimSinglePhaseFlowTest : public ::testing::TestWithParam< std::tuple< std::string, bool, int > > { protected: void SetUp() override @@ -181,10 +181,7 @@ 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 ); + int const n_partitions = std::get< 2 >( GetParam() ); std::string xmlPath = testBinaryDir + "/test_mixed_dim_single_phase_flow.xml"; @@ -214,9 +211,9 @@ TEST_P( MixedDimSinglePhaseFlowTest, Run ) options->inputFileNames.push_back( xmlPath ); options->problemName = "test_mixed_dim_single_phase_flow"; - options->xPartitionsOverride = xPartitions; - options->yPartitionsOverride = yPartitions; - options->zPartitionsOverride = zPartitions; + options->xPartitionsOverride = n_partitions; + options->yPartitionsOverride = 0; + options->zPartitionsOverride = 0; options->overridePartitionNumbers = true; GeosxState state( std::move( options ) ); diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlow_mpi.cpp b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlow_mpi.cpp index 53e47f5f414..75d53cb0fdd 100644 --- a/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlow_mpi.cpp +++ b/src/coreComponents/integrationTests/fluidFlowTests/testMixedDimSinglePhaseFlow_mpi.cpp @@ -28,7 +28,7 @@ CommandLineOptions g_commandLineOptions; * Combinations: * - Meshes: 1 fracture, 2 fractures, 3 fractures * - Solver: Run solver (true) vs Initialization only (false) - * - Partitioning: 1x1x4, 1x2x2 (4 ranks) + * - Partitioning: 4 ranks */ INSTANTIATE_TEST_SUITE_P( MixedDimPartitionedFlowCases, @@ -38,10 +38,7 @@ INSTANTIATE_TEST_SUITE_P( "fractured_mesh_hex_DFN_123.vtu" ), ::testing::Bool(), - ::testing::Values( - std::make_tuple( 1, 1, 4 ), - std::make_tuple( 1, 2, 2 ) - ) + ::testing::Values( 4 ) ) ); diff --git a/src/coreComponents/integrationTests/mechanicTest/testFEMConsistency.cpp b/src/coreComponents/integrationTests/mechanicTest/testFEMConsistency.cpp index ff353f31ae9..a68c9d5b665 100644 --- a/src/coreComponents/integrationTests/mechanicTest/testFEMConsistency.cpp +++ b/src/coreComponents/integrationTests/mechanicTest/testFEMConsistency.cpp @@ -23,16 +23,16 @@ CommandLineOptions g_commandLineOptions; /** - * @brief Serial execution test cases (single rank, partition 1x1x1). + * @brief Serial execution test cases (single rank, partition number 1). */ 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 tet meshes - single and triple fracture only + "fractured_wavy_mesh_tet_DFN_1.vtu", + "fractured_wavy_mesh_tet_DFN_123.vtu", // Wavy hex meshes - single and triple fracture only "fractured_wavy_mesh_hex_DFN_1.vtu", @@ -61,9 +61,7 @@ INSTANTIATE_TEST_SUITE_P( ::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 ) - ) + ::testing::Values( 1 ) ) ); diff --git a/src/coreComponents/integrationTests/mechanicTest/testFEMConsistencyFixture.hpp b/src/coreComponents/integrationTests/mechanicTest/testFEMConsistencyFixture.hpp index f20c09fe632..009a30975e5 100644 --- a/src/coreComponents/integrationTests/mechanicTest/testFEMConsistencyFixture.hpp +++ b/src/coreComponents/integrationTests/mechanicTest/testFEMConsistencyFixture.hpp @@ -73,7 +73,7 @@ extern CommandLineOptions g_commandLineOptions; * - 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 > > > +class ConsistencyTest : public ::testing::TestWithParam< std::tuple< std::string, real64, real64, real64, int > > { protected: void SetUp() override @@ -111,8 +111,8 @@ class ConsistencyTest : public ::testing::TestWithParam< std::tuple< std::string tolJumpT="1.e-4" discretization="FE1" targetRegions="{ Region, Fracture }" - logLevel="1"> - + logLevel="0"> + @@ -172,10 +172,7 @@ TEST_P( ConsistencyTest, Run ) 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 ); + int const nPartitions = std::get< 4 >( params ); std::string xmlPath = testBinaryDir + "/test_fem_consistency_" + meshFileName + ".xml"; std::string nodeSetNames = "{ f1_node_set }"; @@ -229,9 +226,9 @@ TEST_P( ConsistencyTest, Run ) options->inputFileNames.push_back( xmlPath ); options->problemName = "test_fem_consistency"; - options->xPartitionsOverride = xPartitions; - options->yPartitionsOverride = yPartitions; - options->zPartitionsOverride = zPartitions; + options->xPartitionsOverride = nPartitions; + options->yPartitionsOverride = 0; + options->zPartitionsOverride = 0; options->overridePartitionNumbers = true; // Scoped state to ensure cleanup diff --git a/src/coreComponents/integrationTests/mechanicTest/testFEMConsistency_mpi.cpp b/src/coreComponents/integrationTests/mechanicTest/testFEMConsistency_mpi.cpp index c59ada83302..ab36c57f8cf 100644 --- a/src/coreComponents/integrationTests/mechanicTest/testFEMConsistency_mpi.cpp +++ b/src/coreComponents/integrationTests/mechanicTest/testFEMConsistency_mpi.cpp @@ -30,7 +30,7 @@ CommandLineOptions g_commandLineOptions; * 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. + * 5. Partitioning int: Number of partitions 4. * * The test cases cover a subset of meshes with various partitioning schemes for 4 ranks. */ @@ -43,37 +43,14 @@ INSTANTIATE_TEST_SUITE_P( "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" + "fractured_full_span_mesh_tet_DFN_123.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 ) - ) + ::testing::Values( 4 ) ) ); 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 index ba7a9695eb5..ae6d1843b65 100644 --- 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 @@ -1,15 +1,17 @@ - + - - - AQAAAACAAAAbAAAADQAAAA==eJxjYGRgwIEAAJkACg== + + + + AQAAAACAAAB9AAAADwAAAA==eJxjYGBkAIKBIQAGpAAa + - AQAAAACAAACIAgAATwAAAA==eJyF0cENACAIQ1E2c/8tHIERPHFBn3Ah/tjQQsSv9nrzBJeu3p0nuObUv84TXL7kT/OkV++5ptzS9VzTnjRH+6qafMvHdAfp734AQnk+Ow== + 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 @@ -21,16 +23,16 @@ - - AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + 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 - - AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= - AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB - \ No newline at end of file + 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 index b14d92bea06..15391ef1673 100644 --- 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 @@ -1,16 +1,20 @@ - + - - - AQAAAACAAAAbAAAADQAAAA==eJxjYGRgwIEAAJkACg== - AQAAAACAAAAbAAAAEgAAAA==eJxjYGBgZGRkAAM0BgAAmQAK + + + + AQAAAACAAAB9AAAADwAAAA==eJxjYGBkAIKBIQAGpAAa + + + AQAAAACAAAB9AAAAEwAAAA==eJxjYIABRhBgwAJoJwEABqQAGg== + - AQAAAACAAACIAgAATwAAAA==eJyF0cENACAIQ1E2c/8tHIERPHFBn3Ah/tjQQsSv9nrzBJeu3p0nuObUv84TXL7kT/OkV++5ptzS9VzTnjRH+6qafMvHdAfp734AQnk+Ow== + 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 @@ -22,16 +26,16 @@ - - AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + 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 - - AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= - AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB - \ No newline at end of file + 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 index 151bf7525eb..b506e0ccb5e 100644 --- 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 @@ -1,17 +1,23 @@ - + - - - AQAAAACAAAAbAAAADQAAAA==eJxjYGRgwIEAAJkACg== - AQAAAACAAAAbAAAAEgAAAA==eJxjYGBgZGRkAAM0BgAAmQAK - AQAAAACAAAAbAAAAEQAAAA==eJxjYIACRhiACTAAAACZAAo= + + + + AQAAAACAAAB9AAAADwAAAA==eJxjYGBkAIKBIQAGpAAa + + + AQAAAACAAAB9AAAAEwAAAA==eJxjYIABRhBgwAJoJwEABqQAGg== + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAVMOICJJvEAAAGpAAa + - AQAAAACAAACIAgAATwAAAA==eJyF0cENACAIQ1E2c/8tHIERPHFBn3Ah/tjQQsSv9nrzBJeu3p0nuObUv84TXL7kT/OkV++5ptzS9VzTnjRH+6qafMvHdAfp734AQnk+Ow== + 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 @@ -23,16 +29,16 @@ - - AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + 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 - - AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= - AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB - \ No newline at end of file + 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 index 851be8bc2ce..49417e3881d 100644 --- 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 @@ -1,16 +1,20 @@ - + - - - AQAAAACAAAAbAAAADQAAAA==eJxjYGRgwIEAAJkACg== - AQAAAACAAAAbAAAAEQAAAA==eJxjYIACRhiACTAAAACZAAo= + + + + AQAAAACAAAB9AAAADwAAAA==eJxjYGBkAIKBIQAGpAAa + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAVMOICJJvEAAAGpAAa + - AQAAAACAAACIAgAATwAAAA==eJyF0cENACAIQ1E2c/8tHIERPHFBn3Ah/tjQQsSv9nrzBJeu3p0nuObUv84TXL7kT/OkV++5ptzS9VzTnjRH+6qafMvHdAfp734AQnk+Ow== + 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 @@ -22,16 +26,16 @@ - - AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + 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 - - AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= - AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB - \ No newline at end of file + 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 index e86ffb2adbd..17f66cc1b7d 100644 --- 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 @@ -1,15 +1,17 @@ - + - - - AQAAAACAAAAbAAAAEgAAAA==eJxjYGBgZGRkAAM0BgAAmQAK + + + + AQAAAACAAAB9AAAAEwAAAA==eJxjYIABRhBgwAJoJwEABqQAGg== + - AQAAAACAAACIAgAATwAAAA==eJyF0cENACAIQ1E2c/8tHIERPHFBn3Ah/tjQQsSv9nrzBJeu3p0nuObUv84TXL7kT/OkV++5ptzS9VzTnjRH+6qafMvHdAfp734AQnk+Ow== + 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 @@ -21,16 +23,16 @@ - - AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + 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 - - AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= - AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB - \ No newline at end of file + 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 index 6fb93e1008e..ace7ff9faa9 100644 --- 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 @@ -1,16 +1,20 @@ - + - - - AQAAAACAAAAbAAAAEgAAAA==eJxjYGBgZGRkAAM0BgAAmQAK - AQAAAACAAAAbAAAAEQAAAA==eJxjYIACRhiACTAAAACZAAo= + + + + AQAAAACAAAB9AAAAEwAAAA==eJxjYIABRhBgwAJoJwEABqQAGg== + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAVMOICJJvEAAAGpAAa + - AQAAAACAAACIAgAATwAAAA==eJyF0cENACAIQ1E2c/8tHIERPHFBn3Ah/tjQQsSv9nrzBJeu3p0nuObUv84TXL7kT/OkV++5ptzS9VzTnjRH+6qafMvHdAfp734AQnk+Ow== + 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 @@ -22,16 +26,16 @@ - - AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + 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 - - AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= - AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB - \ No newline at end of file + 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 index ae04af7a985..8de7716be51 100644 --- 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 @@ -1,15 +1,17 @@ - + - - - AQAAAACAAAAbAAAAEQAAAA==eJxjYIACRhiACTAAAACZAAo= + + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAVMOICJJvEAAAGpAAa + - AQAAAACAAACIAgAATwAAAA==eJyF0cENACAIQ1E2c/8tHIERPHFBn3Ah/tjQQsSv9nrzBJeu3p0nuObUv84TXL7kT/OkV++5ptzS9VzTnjRH+6qafMvHdAfp734AQnk+Ow== + 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 @@ -21,16 +23,16 @@ - - AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + 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 - - AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= - AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB - \ No newline at end of file + 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 index fa23628746c..2a16fb0931e 100644 --- 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 @@ -1,15 +1,19 @@ - + - + AQAAAACAAADwBAAAEwEAAA==eJwtxdciEAAAAEBKiTKSVMrehCYlZc/s7LLaVFIUyqhoUAmJRP/qwd3LBQTsC/QBH3SQD/mwg33EIQ71UR9zmMMd4Ugfd5RPONonHeNTPu0zjvVZn3Oc453gRCc52SlOdZrTneFMZznbOT7vXOc53xd80Zd82Vd81QUu9DVfd5FvuNg3fcslLnWZy13hSle52jWudZ3rfdsNbnSTm93iVrf5jtvd4U53uds97vVd33Of+z3gQQ/5vh/4oR/5sZ/4qYc94md+7hce9UuP+ZVfe9wTfuO3nvSUp/3O7z3jWc953h/80Z+84EV/9hd/9Tcvednf/cM/veJfXvWa1/3bG/7jTW/5r7f9zzve9X/vAUgYMHQ= - AQAAAACAAACeAAAAGgAAAA==eJxjZGRkZIACRiTAQAAwogJCyskEAA83ACA= + + AQAAAACAAACeAAAAGgAAAA==eJxjZGRkZIACRiTAQAAwogJCyskEAA83ACA= + - - AQAAAACAAADbAQAADgAAAA==eJxjZBwFwxQAALuEAdw= + + + 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= @@ -40,4 +44,4 @@ - \ No newline at end of file + 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 index eb93bfaa1e4..3cdf8228ea7 100644 --- 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 @@ -1,16 +1,22 @@ - + - + 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 - AQAAAACAAAC1AAAAJQAAAA==eJxjYGBgYAQCEMmAChhBElASIYCuCj9gZMSlBbcMYQAAD1sAIA== - AQAAAACAAAC1AAAAJQAAAA==eJxjYGRkAEEQgNKMjBAKzILIIANc4gxQvTjlcAHS9QAAD5MAIA== + + AQAAAACAAAC1AAAAJQAAAA==eJxjYGBgYAQCEMmAChhBElASIYCuCj9gZMSlBbcMYQAAD1sAIA== + + + AQAAAACAAAC1AAAAJQAAAA==eJxjYGRkAEEQgNKMjBAKzILIIANc4gxQvTjlcAHS9QAAD5MAIA== + - - AQAAAACAAABAAgAADwAAAA==eJxjZBwFo4B8AACLfgJB + + + 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== @@ -41,4 +47,4 @@ - \ No newline at end of file + 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 index e6a57c3768e..cb38840cc01 100644 --- 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 @@ -1,17 +1,25 @@ - + - + AQAAAACAAABIBwAAjQEAAA==eJwtxVNjFgAAAMAvt2XbLdu1bGNLW9aybbeM1eKqLdeyl22by/gZPXT3coHAfymc0qmc2mmc1umc3kEOdgZndCZndhZndTZndw7ndC7ndh7ndT7ndwEXdCEXdhEXdTEXdwmXdIhLubTLuKzLubwruKIrubKruKqrubpruKZrubbruK7rOdT13cAN3ciN3cRN3czN3cIt3cqt3cZt3c7t3cEd3cmd3cVhDndXd3N393BPRzjSvdzbfdzX/dzfAzzQgzzYQxzloR7m4R7hkR7l0R7jsR7n8Z7giZ7kyZ7iqZ7m6Z7hmZ7l2Z7juZ7n+V7ghV7kxV7iaC/1Mi/3Cq/0Kq/2Gq/1Osd4vTc41hu9yZu9xVu9zXHe7h3e6XgneJd3e4/3ep/3+4AP+pATfdhHfNTHfNwnfNKnfNpnfNbnfN5JvuCLvuTLvuKrvubrvuGbvuXbvuO7vuf7fuCHfuTHfuKnfubnfuGXfuXXfuO3fuf3/uCP/uTPTvYXf/U3f/cP//Qv//Yf//U/bxdplQ== - AQAAAACAAADpAAAAKwAAAA==eJxjYGBgYAQCEAnBIAEGOIAIMsJZYAYjkgJUDnYAsYA8MXLUYAMAF3wAJg== - AQAAAACAAADpAAAALgAAAA==eJxjYGBkZABhEAQDEB/KZoQQMBG4EpgkIyOcjSyDUMLISJI4qWpJMQcAFw4AJg== - AQAAAACAAADpAAAAMgAAAA==eJxjYGRkYABhIGBkYIQSDGACwoBKMkCVIBTDlEJlkJVB9KGJYAf41FHDDBgAABbOACY= + + AQAAAACAAADpAAAAKwAAAA==eJxjYGBgYAQCEAnBIAEGOIAIMsJZYAYjkgJUDnYAsYA8MXLUYAMAF3wAJg== + + + AQAAAACAAADpAAAALgAAAA==eJxjYGBkZABhEAQDEB/KZoQQMBG4EpgkIyOcjSyDUMLISJI4qWpJMQcAFw4AJg== + + + AQAAAACAAADpAAAAMgAAAA==eJxjYGRkYABhIGBkYIQSDGACwoBKMkCVIBTDlEJlkJVB9KGJYAf41FHDDBgAABbOACY= + - - AQAAAACAAAAhAwAAEAAAAA==eJxjZBwFo2AU4AQA6g4DIg== + + + 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= @@ -42,4 +50,4 @@ - \ No newline at end of file + 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 index f988c3f7484..2c9a03762e1 100644 --- 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 @@ -1,16 +1,22 @@ - + - + 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 - AQAAAACAAAC1AAAAJQAAAA==eJxjYGBgYAQCEMmACsBijFBZOB9dFX7AyIhLC24ZwgAAD1gAIA== - AQAAAACAAAC1AAAAKAAAAA==eJxjYGRkYABhEGBkADEY4VxGOBMFMEIlGTAlGXHpIRIQpx8ADzMAIA== + + AQAAAACAAAC1AAAAJQAAAA==eJxjYGBgYAQCEMmACsBijFBZOB9dFX7AyIhLC24ZwgAAD1gAIA== + + + AQAAAACAAAC1AAAAKAAAAA==eJxjYGRkYABhEGBkADEY4VxGOBMFMEIlGTAlGXHpIRIQpx8ADzMAIA== + - - AQAAAACAAABAAgAADwAAAA==eJxjZBwFo4B8AACLfgJB + + + 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== @@ -41,4 +47,4 @@ - \ No newline at end of file + 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 index a3ea8ca5163..4d414faea8f 100644 --- 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 @@ -1,15 +1,19 @@ - + - + AQAAAACAAAAABQAAFwEAAA==eJwtxdciEAAAAEBNoSGKsoqMNlJ2iTKSQkJGmWVWhJIiKmRGESr6VQ/dvVxAwH97vNf7vN8HfNCBPuQgBzvEh33ER33MoT7uMIf7hE86wpE+5dOOcrRjHOs4n/FZxzvB55zoJCc7xed9wRd9yZd9xVed6jSn+5ozfN03nOksZzvHuc5zvm/6lgt824Uu8h3fdbFLXOoy33O577vCD/zQla5ytR+5xo9d6zrX+4kb3OgmN/upn7nFrW5zuzvc6ed+4S53u8e97nO/X/qVX3vAg37jIQ97xG/9zqN+7zF/8EePe8KfPOkpf/YXf/W0Zzzrb57zvBe86CUv+7tXvOof/uk1r/uXN7zpLf/2H//1tnf8z7teXTGx - AQAAAACAAACgAAAAGgAAAA==eJxjZGRkZIACRiTAQAAwogJCyskGAA93ACA= + + AQAAAACAAACgAAAAGgAAAA==eJxjZGRkZIACRiTAQAAwogJCyskGAA93ACA= + - - AQAAAACAAADnAQAADgAAAA==eJxjZBwFIwAAANIiAeg= + + + 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 @@ -40,4 +44,4 @@ - \ No newline at end of file + 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 index eb523f5df86..daf7800828e 100644 --- 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 @@ -1,16 +1,22 @@ - + - + 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 - AQAAAACAAAC1AAAAJQAAAA==eJxjYGBkZABhEIQCBAMkDiKgYmA+A2HAyAjVRaY8IQAAD8UAIA== - AQAAAACAAAC1AAAAKAAAAA==eJxjYGRkYABhIGBkYIRQIBEoCZFBBow4xCGSjLjlcAHS9QAAD40AIA== + + AQAAAACAAAC1AAAAJQAAAA==eJxjYGBkZABhEIQCBAMkDiKgYmA+A2HAyAjVRaY8IQAAD8UAIA== + + + AQAAAACAAAC1AAAAKAAAAA==eJxjYGRkYABhIGBkYIRQIBEoCZFBBow4xCGSjLjlcAHS9QAAD40AIA== + - - AQAAAACAAABAAgAADwAAAA==eJxjZBwFo4B8AACLfgJB + + + 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== @@ -41,4 +47,4 @@ - \ No newline at end of file + 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 index 902995fa8f5..e1dc00ac1e9 100644 --- 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 @@ -1,15 +1,19 @@ - + - + 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= - AQAAAACAAACfAAAAGgAAAA==eJxjZGRkZIACRiTAQAAwogJCyskFAA9XACA= + + AQAAAACAAACfAAAAGgAAAA==eJxjZGRkZIACRiTAQAAwogJCyskFAA9XACA= + - - AQAAAACAAADjAQAADgAAAA==eJxjZBwFwxwAAMqIAeQ= + + + 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== @@ -40,4 +44,4 @@ - \ No newline at end of file + 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 index fb5078c396f..cc7772b4262 100644 --- 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 @@ -1,9 +1,11 @@ - + - - AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK + @@ -33,4 +35,4 @@ - \ No newline at end of file + 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 index f846514cae4..024c5b6afbf 100644 --- 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 @@ -1,10 +1,14 @@ - + - - AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK + @@ -34,4 +38,4 @@ - \ No newline at end of file + 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 index f2584dc3e28..84e12ac6c6a 100644 --- 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 @@ -1,11 +1,17 @@ - + - - AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + @@ -35,4 +41,4 @@ - \ No newline at end of file + 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 index 0064b1b6964..3ce36f7c5ea 100644 --- 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 @@ -1,10 +1,14 @@ - + - - AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + @@ -34,4 +38,4 @@ - \ No newline at end of file + 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 index 4dce7480ee7..fed3120cded 100644 --- 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 @@ -1,9 +1,11 @@ - + - - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK + @@ -33,4 +35,4 @@ - \ No newline at end of file + 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 index 3284ae46cab..7d008649b6b 100644 --- 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 @@ -1,10 +1,14 @@ - + - - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + @@ -34,4 +38,4 @@ - \ No newline at end of file + 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 index 631c553371b..a26980008de 100644 --- 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 @@ -1,9 +1,11 @@ - + - - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + @@ -33,4 +35,4 @@ - \ No newline at end of file + 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 index 499037bd4ab..63beaad0afd 100644 --- 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 @@ -1,15 +1,19 @@ - + - + AQAAAACAAADwBAAAEwEAAA==eJwtxdciEAAAAEBKiTKSVMrehCYlZc/s7LLaVFIUyqhoUAmJRP/qwd3LBQTsC/QBH3SQD/mwg33EIQ71UR9zmMMd4Ugfd5RPONonHeNTPu0zjvVZn3Oc453gRCc52SlOdZrTneFMZznbOT7vXOc53xd80Zd82Vd81QUu9DVfd5FvuNg3fcslLnWZy13hSle52jWudZ3rfdsNbnSTm93iVrf5jtvd4U53uds97vVd33Of+z3gQQ/5vh/4oR/5sZ/4qYc94md+7hce9UuP+ZVfe9wTfuO3nvSUp/3O7z3jWc953h/80Z+84EV/9hd/9Tcvednf/cM/veJfXvWa1/3bG/7jTW/5r7f9zzve9X/vAUgYMHQ= - AQAAAACAAACeAAAAFwAAAA==eJxjZGRkZIACRiQ2PkCsOsoBAAb0AA0= + + AQAAAACAAACeAAAAFwAAAA==eJxjZGRkZIACRiQ2PkCsOsoBAAb0AA0= + - - AQAAAACAAADnAQAADgAAAA==eJxjZBwFIwAAANIiAeg= + + + 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 @@ -40,4 +44,4 @@ - \ No newline at end of file + 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 index 9172fa52b01..15ee475f800 100644 --- 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 @@ -1,16 +1,22 @@ - + - + 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= - AQAAAACAAACkAAAAFgAAAA==eJxjZAQBBiSAxsUN0DXSDAAAB74ADg== - AQAAAACAAACkAAAAGwAAAA==eJxjYGBkZABiEAkFjAxIHAIARSOtAAAHlQAO + + AQAAAACAAACkAAAAFgAAAA==eJxjZAQBBiSAxsUN0DXSDAAAB74ADg== + + + AQAAAACAAACkAAAAGwAAAA==eJxjYGBkZABiEAkFjAxIHAIARSOtAAAHlQAO + - - AQAAAACAAAAEAgAADgAAAA==eJxjZBwFIx0AAAssAgU= + + + 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== @@ -41,4 +47,4 @@ - \ No newline at end of file + 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 index 914bf5aca41..ace19173ab9 100644 --- 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 @@ -1,17 +1,25 @@ - + - + AQAAAACAAABgBQAALgEAAA==eJwtxdciEAAAAEBCRogGTRKKlJZo01CZlRRFKJVRaSAhRWgRpUEqilLqJz24e7mAgEWBXuIgBzvESx3qMIc7wssc6ShHe7ljHOsVXulVXu04x3uN13qd13uDNzrBid7kJG92slOc6i3e6jSne5szvN07nOmd3uXd3uO9zvI+ZzvH+33AB33Ih33ER53rPB/zcZ/wSef7lE/7jAtc6CIXu8SlPutzPu8yX3C5L/qSK1zpy77iKlf7qmtc6zpf83XX+4Zv+pYb3OgmN/u27/iuW3zP9/3AD93qNrf7kTv82J3ucrefuMdP/cy97vNz93vAg37hl37l137jIQ/7rUc86nd+7zF/8Ed/8mePe8JfPOmv/ubvnvK0f/inZzzrX/7tOf/xX8/7n/97AZDZOXM= - AQAAAACAAACsAAAAEgAAAA==eJxjZIQCBrIA+TrJAAAIQgAO - AQAAAACAAACsAAAAGgAAAA==eJxjYGBkZGBgYARSIMBABiBXH8kAAAgFAA4= - AQAAAACAAACsAAAAGQAAAA==eJxjZGAEQiCAUIxAwEAGIFcfSQAAB+oADg== + + AQAAAACAAACsAAAAEgAAAA==eJxjZIQCBrIA+TrJAAAIQgAO + + + AQAAAACAAACsAAAAGgAAAA==eJxjYGBkZGBgYARSIMBABiBXH8kAAAgFAA4= + + + AQAAAACAAACsAAAAGQAAAA==eJxjZGAEQiCAUIxAwEAGIFcfSQAAB+oADg== + - - AQAAAACAAAAnAgAADwAAAA==eJxjZBwFo4AgAABUUQIo + + + 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= @@ -42,4 +50,4 @@ - \ No newline at end of file + 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 index 66738415c11..ff93241357f 100644 --- 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 @@ -1,16 +1,22 @@ - + - + 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= - AQAAAACAAACkAAAAFgAAAA==eJxjZAQBBiSAxsUN0DXSDAAAB74ADg== - AQAAAACAAACkAAAAHAAAAA==eJxjZGBkYGBgBAIGKGAEcRmIBMgaaQYAB5kADg== + + AQAAAACAAACkAAAAFgAAAA==eJxjZAQBBiSAxsUN0DXSDAAAB74ADg== + + + AQAAAACAAACkAAAAHAAAAA==eJxjZGBkYGBgBAIGKGAEcRmIBMgaaQYAB5kADg== + - - AQAAAACAAAABAgAADgAAAA==eJxjZBwFIxoAAAUgAgI= + + + 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= @@ -41,4 +47,4 @@ - \ No newline at end of file + 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 index eb43304ed53..e357c99ee6d 100644 --- 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 @@ -1,15 +1,19 @@ - + - + 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= - AQAAAACAAACaAAAAFwAAAA==eJxjZGRkZIACRiQ2PkCsOsoAAAbAAA0= + + AQAAAACAAACaAAAAFwAAAA==eJxjZGRkZIACRiQ2PkCsOsoAAAbAAA0= + - - AQAAAACAAADIAQAADgAAAA==eJxjZBwFwwEAAJjbAck= + + + 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== @@ -40,4 +44,4 @@ - \ No newline at end of file + 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 index 803f7afa9f8..850bc3f7f72 100644 --- 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 @@ -1,16 +1,22 @@ - + - + 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= - AQAAAACAAACkAAAAFgAAAA==eJxjZAQBBiSAxsUN0DXSDAAAB74ADg== - AQAAAACAAACkAAAAHAAAAA==eJxjZGBkYGBgBAIGKGAEcRmIBMgaaQYAB5kADg== + + AQAAAACAAACkAAAAFgAAAA==eJxjZAQBBiSAxsUN0DXSDAAAB74ADg== + + + AQAAAACAAACkAAAAHAAAAA==eJxjZGBkYGBgBAIGKGAEcRmIBMgaaQYAB5kADg== + - - AQAAAACAAAAAAgAADgAAAA==eJxjZBwFIxkAAAMeAgE= + + + 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 @@ -41,4 +47,4 @@ - \ No newline at end of file + 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 index 131a9744f10..6cc957ab042 100644 --- 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 @@ -1,15 +1,19 @@ - + - + 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= - AQAAAACAAACZAAAAFwAAAA==eJxjZGRkZIACRiQ2PkCsOooAAAazAA0= + + AQAAAACAAACZAAAAFwAAAA==eJxjZGRkZIACRiQ2PkCsOooAAAazAA0= + - - AQAAAACAAADBAQAADgAAAA==eJxjZBwFQxoAAIxxAcI= + + + 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= @@ -40,4 +44,4 @@ - \ No newline at end of file + 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 index 2ff1126094e..3b132963aca 100644 --- 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 @@ -1,15 +1,17 @@ - + - - - AQAAAACAAAAbAAAADQAAAA==eJxjYGRgwIEAAJkACg== + + + + AQAAAACAAAB9AAAADwAAAA==eJxjYGBkAIKBIQAGpAAa + - AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + AQAAAACAAAC4CwAArwEAAA==eJyNljFLA0EQhVMJYpHCH2Blp6D4AzZEK21ttLGS/AMRBFv/QIo0go0oWIiIlVporZKIIAjKYpPF6morRbI57u19zk6z3Mvezs28eW/TaPwXfVePe8AD4AXglCc+K+4BD4AXgOt5mldxD3gAvABc39O8invAA+AF4Pq75lXcAx4ALwDXIF6p79QX+m5rjtL15W1p/qbn3clVZ3N3cTDGJ9aPbpvXwU2dtvZmdgbu63x/8m76UfLmzinlGe1rfcr+MN5/0V1Yax5qXlsH8Xu1jo3V3vHB08fofNWNzpX2OVdn+p7yq7jOlb6fq2PigfRMeiM9xCjr0bmJvP09Jrz6pO+Rj/o6LR+Sfb/5tu/br5fvPlmr9eo5Olfsc9V5DNV6k756Nzf78LzcGY7x+npzfVTnwqpD50r35fo06Yz6RH5Nfhqj1IP6TtRxvS+QbklX1j3TB58gnkteq3wTH1o/+1D9ucF9n221i5Vhslbz5t6T5HM6L3qe4jpX1j1MPko6oDroPo5Bfkx6snyffNn6H0H3AOmYeCA9x7Dm3vIJ4pn4jmH1xfIhypeuP6jlyLs= 0 @@ -21,16 +23,16 @@ - - AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + 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 - - AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= - AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB - \ No newline at end of file + 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 index 205ce112da6..a5dd73c557b 100644 --- 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 @@ -1,16 +1,20 @@ - + - - - AQAAAACAAAAbAAAADQAAAA==eJxjYGRgwIEAAJkACg== - AQAAAACAAAAbAAAAEgAAAA==eJxjYGBgZGRkAAM0BgAAmQAK + + + + AQAAAACAAAB9AAAADwAAAA==eJxjYGBkAIKBIQAGpAAa + + + AQAAAACAAAB9AAAAEwAAAA==eJxjYIABRhBgwAJoJwEABqQAGg== + - AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + AQAAAACAAAC4CwAArwEAAA==eJyNljFLA0EQhVMJYpHCH2Blp6D4AzZEK21ttLGS/AMRBFv/QIo0go0oWIiIlVporZKIIAjKYpPF6morRbI57u19zk6z3Mvezs28eW/TaPwXfVePe8AD4AXglCc+K+4BD4AXgOt5mldxD3gAvABc39O8invAA+AF4Pq75lXcAx4ALwDXIF6p79QX+m5rjtL15W1p/qbn3clVZ3N3cTDGJ9aPbpvXwU2dtvZmdgbu63x/8m76UfLmzinlGe1rfcr+MN5/0V1Yax5qXlsH8Xu1jo3V3vHB08fofNWNzpX2OVdn+p7yq7jOlb6fq2PigfRMeiM9xCjr0bmJvP09Jrz6pO+Rj/o6LR+Sfb/5tu/br5fvPlmr9eo5Olfsc9V5DNV6k756Nzf78LzcGY7x+npzfVTnwqpD50r35fo06Yz6RH5Nfhqj1IP6TtRxvS+QbklX1j3TB58gnkteq3wTH1o/+1D9ucF9n221i5Vhslbz5t6T5HM6L3qe4jpX1j1MPko6oDroPo5Bfkx6snyffNn6H0H3AOmYeCA9x7Dm3vIJ4pn4jmH1xfIhypeuP6jlyLs= 0 @@ -22,16 +26,16 @@ - - AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + 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 - - AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= - AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB - \ No newline at end of file + 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 index 014b35c36a5..16c6290ecc7 100644 --- 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 @@ -1,17 +1,23 @@ - + - - - AQAAAACAAAAbAAAADQAAAA==eJxjYGRgwIEAAJkACg== - AQAAAACAAAAbAAAAEgAAAA==eJxjYGBgZGRkAAM0BgAAmQAK - AQAAAACAAAAbAAAAEQAAAA==eJxjYIACRhiACTAAAACZAAo= + + + + AQAAAACAAAB9AAAADwAAAA==eJxjYGBkAIKBIQAGpAAa + + + AQAAAACAAAB9AAAAEwAAAA==eJxjYIABRhBgwAJoJwEABqQAGg== + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAVMOICJJvEAAAGpAAa + - AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + AQAAAACAAAC4CwAArwEAAA==eJyNljFLA0EQhVMJYpHCH2Blp6D4AzZEK21ttLGS/AMRBFv/QIo0go0oWIiIlVporZKIIAjKYpPF6morRbI57u19zk6z3Mvezs28eW/TaPwXfVePe8AD4AXglCc+K+4BD4AXgOt5mldxD3gAvABc39O8invAA+AF4Pq75lXcAx4ALwDXIF6p79QX+m5rjtL15W1p/qbn3clVZ3N3cTDGJ9aPbpvXwU2dtvZmdgbu63x/8m76UfLmzinlGe1rfcr+MN5/0V1Yax5qXlsH8Xu1jo3V3vHB08fofNWNzpX2OVdn+p7yq7jOlb6fq2PigfRMeiM9xCjr0bmJvP09Jrz6pO+Rj/o6LR+Sfb/5tu/br5fvPlmr9eo5Olfsc9V5DNV6k756Nzf78LzcGY7x+npzfVTnwqpD50r35fo06Yz6RH5Nfhqj1IP6TtRxvS+QbklX1j3TB58gnkteq3wTH1o/+1D9ucF9n221i5Vhslbz5t6T5HM6L3qe4jpX1j1MPko6oDroPo5Bfkx6snyffNn6H0H3AOmYeCA9x7Dm3vIJ4pn4jmH1xfIhypeuP6jlyLs= 0 @@ -23,16 +29,16 @@ - - AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + 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 - - AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= - AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB - \ No newline at end of file + 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 index 15b9bdc54fc..4269a51ad82 100644 --- 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 @@ -1,16 +1,20 @@ - + - - - AQAAAACAAAAbAAAADQAAAA==eJxjYGRgwIEAAJkACg== - AQAAAACAAAAbAAAAEQAAAA==eJxjYIACRhiACTAAAACZAAo= + + + + AQAAAACAAAB9AAAADwAAAA==eJxjYGBkAIKBIQAGpAAa + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAVMOICJJvEAAAGpAAa + - AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + AQAAAACAAAC4CwAArwEAAA==eJyNljFLA0EQhVMJYpHCH2Blp6D4AzZEK21ttLGS/AMRBFv/QIo0go0oWIiIlVporZKIIAjKYpPF6morRbI57u19zk6z3Mvezs28eW/TaPwXfVePe8AD4AXglCc+K+4BD4AXgOt5mldxD3gAvABc39O8invAA+AF4Pq75lXcAx4ALwDXIF6p79QX+m5rjtL15W1p/qbn3clVZ3N3cTDGJ9aPbpvXwU2dtvZmdgbu63x/8m76UfLmzinlGe1rfcr+MN5/0V1Yax5qXlsH8Xu1jo3V3vHB08fofNWNzpX2OVdn+p7yq7jOlb6fq2PigfRMeiM9xCjr0bmJvP09Jrz6pO+Rj/o6LR+Sfb/5tu/br5fvPlmr9eo5Olfsc9V5DNV6k756Nzf78LzcGY7x+npzfVTnwqpD50r35fo06Yz6RH5Nfhqj1IP6TtRxvS+QbklX1j3TB58gnkteq3wTH1o/+1D9ucF9n221i5Vhslbz5t6T5HM6L3qe4jpX1j1MPko6oDroPo5Bfkx6snyffNn6H0H3AOmYeCA9x7Dm3vIJ4pn4jmH1xfIhypeuP6jlyLs= 0 @@ -22,16 +26,16 @@ - - AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + 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 - - AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= - AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB - \ No newline at end of file + 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 index a3200a8c5cf..d53a7b8b620 100644 --- 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 @@ -1,15 +1,17 @@ - + - - - AQAAAACAAAAbAAAAEgAAAA==eJxjYGBgZGRkAAM0BgAAmQAK + + + + AQAAAACAAAB9AAAAEwAAAA==eJxjYIABRhBgwAJoJwEABqQAGg== + - AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + AQAAAACAAAC4CwAArwEAAA==eJyNljFLA0EQhVMJYpHCH2Blp6D4AzZEK21ttLGS/AMRBFv/QIo0go0oWIiIlVporZKIIAjKYpPF6morRbI57u19zk6z3Mvezs28eW/TaPwXfVePe8AD4AXglCc+K+4BD4AXgOt5mldxD3gAvABc39O8invAA+AF4Pq75lXcAx4ALwDXIF6p79QX+m5rjtL15W1p/qbn3clVZ3N3cTDGJ9aPbpvXwU2dtvZmdgbu63x/8m76UfLmzinlGe1rfcr+MN5/0V1Yax5qXlsH8Xu1jo3V3vHB08fofNWNzpX2OVdn+p7yq7jOlb6fq2PigfRMeiM9xCjr0bmJvP09Jrz6pO+Rj/o6LR+Sfb/5tu/br5fvPlmr9eo5Olfsc9V5DNV6k756Nzf78LzcGY7x+npzfVTnwqpD50r35fo06Yz6RH5Nfhqj1IP6TtRxvS+QbklX1j3TB58gnkteq3wTH1o/+1D9ucF9n221i5Vhslbz5t6T5HM6L3qe4jpX1j1MPko6oDroPo5Bfkx6snyffNn6H0H3AOmYeCA9x7Dm3vIJ4pn4jmH1xfIhypeuP6jlyLs= 0 @@ -21,16 +23,16 @@ - - AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + 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 - - AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= - AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB - \ No newline at end of file + 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 index f1f1e9514d7..9d1b4d0d560 100644 --- 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 @@ -1,16 +1,20 @@ - + - - - AQAAAACAAAAbAAAAEgAAAA==eJxjYGBgZGRkAAM0BgAAmQAK - AQAAAACAAAAbAAAAEQAAAA==eJxjYIACRhiACTAAAACZAAo= + + + + AQAAAACAAAB9AAAAEwAAAA==eJxjYIABRhBgwAJoJwEABqQAGg== + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAVMOICJJvEAAAGpAAa + - AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + AQAAAACAAAC4CwAArwEAAA==eJyNljFLA0EQhVMJYpHCH2Blp6D4AzZEK21ttLGS/AMRBFv/QIo0go0oWIiIlVporZKIIAjKYpPF6morRbI57u19zk6z3Mvezs28eW/TaPwXfVePe8AD4AXglCc+K+4BD4AXgOt5mldxD3gAvABc39O8invAA+AF4Pq75lXcAx4ALwDXIF6p79QX+m5rjtL15W1p/qbn3clVZ3N3cTDGJ9aPbpvXwU2dtvZmdgbu63x/8m76UfLmzinlGe1rfcr+MN5/0V1Yax5qXlsH8Xu1jo3V3vHB08fofNWNzpX2OVdn+p7yq7jOlb6fq2PigfRMeiM9xCjr0bmJvP09Jrz6pO+Rj/o6LR+Sfb/5tu/br5fvPlmr9eo5Olfsc9V5DNV6k756Nzf78LzcGY7x+npzfVTnwqpD50r35fo06Yz6RH5Nfhqj1IP6TtRxvS+QbklX1j3TB58gnkteq3wTH1o/+1D9ucF9n221i5Vhslbz5t6T5HM6L3qe4jpX1j1MPko6oDroPo5Bfkx6snyffNn6H0H3AOmYeCA9x7Dm3vIJ4pn4jmH1xfIhypeuP6jlyLs= 0 @@ -22,16 +26,16 @@ - - AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + 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 - - AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= - AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB - \ No newline at end of file + 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 index c81c0873941..629bbf199e9 100644 --- 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 @@ -1,15 +1,17 @@ - + - - - AQAAAACAAAAbAAAAEQAAAA==eJxjYIACRhiACTAAAACZAAo= + + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAVMOICJJvEAAAGpAAa + - AQAAAACAAACIAgAAVgAAAA==eJxjYMAHHthjF/+AQxyXPhgfXfwDDnFc9sDUoYt/wCGOy1243IfLPkz9qYecrm++i0mjmkOsv3HpQ/cXoXDCZQ+u8EL3FyF34XIfLvtw6cekAcoTSas= + AQAAAACAAAC4CwAArwEAAA==eJyNljFLA0EQhVMJYpHCH2Blp6D4AzZEK21ttLGS/AMRBFv/QIo0go0oWIiIlVporZKIIAjKYpPF6morRbI57u19zk6z3Mvezs28eW/TaPwXfVePe8AD4AXglCc+K+4BD4AXgOt5mldxD3gAvABc39O8invAA+AF4Pq75lXcAx4ALwDXIF6p79QX+m5rjtL15W1p/qbn3clVZ3N3cTDGJ9aPbpvXwU2dtvZmdgbu63x/8m76UfLmzinlGe1rfcr+MN5/0V1Yax5qXlsH8Xu1jo3V3vHB08fofNWNzpX2OVdn+p7yq7jOlb6fq2PigfRMeiM9xCjr0bmJvP09Jrz6pO+Rj/o6LR+Sfb/5tu/br5fvPlmr9eo5Olfsc9V5DNV6k756Nzf78LzcGY7x+npzfVTnwqpD50r35fo06Yz6RH5Nfhqj1IP6TtRxvS+QbklX1j3TB58gnkteq3wTH1o/+1D9ucF9n221i5Vhslbz5t6T5HM6L3qe4jpX1j1MPko6oDroPo5Bfkx6snyffNn6H0H3AOmYeCA9x7Dm3vIJ4pn4jmH1xfIhypeuP6jlyLs= 0 @@ -21,16 +23,16 @@ - - AQAAAACAAAAAAgAAZwAAAA==eJyFjzcOwDAMA504vTen/f+hGXJaCBjWcouOBJ37L4MF9LCFHRzhIF4OS8kxr4eT5Hj5r2ElPfa/wFk8620kxzzrXSUntW+DOzxhEC+2z7wDXpKT2hfk/4G3eLF95lnvKzkfjh4DQQ== + + 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 - - AQAAAACAAABAAAAAHgAAAA==eJzjYIAAASgtAaUVoLQGlDaA0hZQ2gFKAwAeQAEh + + AQAAAACAAAAAAgAAegAAAA==eJwtxREAgwAAALB+CsPwGIbhMQzDY3gMwzAMj2EYhmEYhmEYHtpkYXCLHPvlxKkzv527cOmPK39du3Hrzr1/Hjx68uzFqzfvPnz6cvC4Cx059suJU2d+O3fh0h9X/rp249ade/88ePTk2YtXb959+PTl4Hn3BzUDHyM= - AQAAAACAAAAIAAAACwAAAA==eJzj4YEAAAG4AGE= + AQAAAACAAABAAAAADAAAAA==eJzj4aEMAABhwAMB - \ No newline at end of file + 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 index a7957f2f494..8a777166107 100644 --- 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 @@ -1,22 +1,26 @@ - + - + AQAAAACAAADwBAAAEwEAAA==eJwtxdciEAAAAEBKiTKSVMrehCYlZc/s7LLaVFIUyqhoUAmJRP/qwd3LBQTsC/QBH3SQD/mwg33EIQ71UR9zmMMd4Ugfd5RPONonHeNTPu0zjvVZn3Oc453gRCc52SlOdZrTneFMZznbOT7vXOc53xd80Zd82Vd81QUu9DVfd5FvuNg3fcslLnWZy13hSle52jWudZ3rfdsNbnSTm93iVrf5jtvd4U53uds97vVd33Of+z3gQQ/5vh/4oR/5sZ/4qYc94md+7hce9UuP+ZVfe9wTfuO3nvSUp/3O7z3jWc953h/80Z+84EV/9hd/9Tcvednf/cM/veJfXvWa1/3bG/7jTW/5r7f9zzve9X/vAUgYMHQ= - AQAAAACAAACeAAAAGgAAAA==eJxjZGRkZIACRiTAQAAwogJCyskEAA83ACA= + + AQAAAACAAACeAAAAGgAAAA==eJxjZGRkZIACRiTAQAAwogJCyskEAA83ACA= + - - AQAAAACAAADbAQAADgAAAA==eJxjZBwFwxQAALuEAdw= + + + 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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 + AQAAAACAAADQDgAAJAYAAA==eJy1lXs0lGkcx8eROpSdQiyp00US6bLbKU74UWmLpmxFUm1S25J0JVGSbVsxpG1t5DJCJbWKjtoz1OSSSwxm0AymnRnGZWawplyiyNp23vc9HjM7u3/s88973s/7PL/n+3x/v+f3kkh/DSGQFA6My+CfOfZE46DrVHFl89D5qt5VzVMVV9m5WEp8QM+NvYtV+MYCxRyNK0PiofFVrUP1K8sXGh/VjXLUD1VcWZ2hPqE60fUoR33ABuozypXVqzI96Piv50GHMl3o+ZVxZfuh8dD9/quvaHzUp//Ld1V+KOtDqC5VPv7beBPjfvYmUWbAFYK2b10Zp54JRhYlq/Zu5sJDYXxfX4UAkiJYoVcWSuTzG8CHWv5m9lUBaMVVDQ9miuAG9f3PNdYSuDCzcXfYdCH0t60ofNTCBX2xYc5KGwmua1aczGtjFB/uN9ZRi0xaYIHtmXz33QIwT7T0y+wVQ4hWovEV+1Z4sHDjD8PBAjA6tc0pktYC6i+sdDPv10LfsnmhPZ7NYERNskgYrQA941utOWtEMGXp63mpx/iQRUlz0ahrh+W+zQ7DaaUwfJZ2ITpICMm2DO9c40b4dcD1cpSwGG5Xu7cdbOPDiP2Fj/5xErj3SY8UyKZ3pD0uQjBU+9x01eJSnJeFeQTHkIWQalTPitQsgxNHDn05/dtSMKrJGAkobgbGVL0bjyg8eErNF6XtbIJFh492+4z5o8PbX64V3QkCZ5N93mrFeF0wNwaaB1Jewq7Md2WDwxycX0qetWT1cxEcLDERtoqYOE8aohhUZotgyK7d1NhegnOJRp7G0ykNEDU6P/26DcFtWppe5FUJIPD5wJLV00Q4T/D069W5KYZJd1hePl4Ed8+tFdi850BlhukjY2k5zmUzE3xjk5ig7pe8aMsRYr5TbmPA7BVSmJrdn++SwMW53o8S8/guEXRuO2BdfYuHc8xH7InveyOb1X+kDHbInxjH3tH5ZOeUDfpj+5bWfd92Zw0xf0h7oU+5WhM8pM0Y6Ikfy/OndbXIPWyFTSt25LHoTIQ3QIskeP32YCJerIXhh4hnUpiR471OZ189zs1sODTayAvwOt53PWQykc9W3YgatfdFMPeBQPhLAZFPq3sMf+qeTri72V0c/KQSvz9ydxGdrTgnU4v2ctbWQ/bXiboNmiU4x3Ri+jA+X76vtXw/jD9Nt7erP18Exjs1LGuji3A+Xo8M17Wn41WaQTob4a24HoxjuvjJS4N4DmU47z/u5B5fIIWasksrC89xcD4lf3ZUqEMnrgfjmC7F/pBIiv0ZqwOF/pBIiv0hkRT7QyIp9odEMtfVz6N1t0+oH06XxHG/jmRC/ZzJm8OO5bfhHNN12bF5qe886YS66jG7Sn6cQpwH0zWde0zm5Enow3SN10Osy+o9zKayxRN8w/ZFfQjMcOafZrUBVscYbxetTfC064QOeR1jHNOJ+vb3kEEX3dFgsXMldPPCaBQKF88rvdttph2vA4pFbw9V3xPhfLSiwmD9iAjSGSZbj6kT9ffyZjjTTasBUg1TsqN5Epyzm5oodlYN8PGEHT3I9SXOQzJaNP3SBTAoWjbV8xoP5zYtu7NSxv5HDQs8rfr7iTj+nO9SHs9ngearuIN1twk9oR6+4R/IEshlb2K4FBP6/3jLrbQtEUBTbB3j9w/EvazY86y3hCKFcLVAegGduH+K+5hM/p+T4t8xjvY3xfmVgeL8ykBxfmWgOL8yUJxfGSjOrwzRQ/SH8XqI/jC+zon+gOnBONYfMD0YnyzvD+PvBdEf1tJCbO9OZkFxnvbcZWF8KLewDAh40wHqjv5vDwRWQ3LB8jlBA20w6YumSEZQMzA9a2PWmbGAvMmDVLqjHgYZqYy0VfXA19HuOpVVBaVqfgv6KsXwzFT/+NkhNlyzHzkn8GCDmcbpKr4JEw6f9HR1aRFDYYlZjNE3LHDg5hygR4pB72PkYES4GK55uf7Ev9gBAv0zZq+vdoDboa2vW092wMWYCuvrY/NGHWW+lV0sMBpYuSFwkAkBezlPpOZi4FnSvaUnuXDx6G+7bt1uA5ftX3HekcUwrfZ8otu6djAo7NuWu6UO/gQoL0HL 0 @@ -40,4 +44,4 @@ - \ No newline at end of file + 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 index 07e855c1748..49fe7f38661 100644 --- 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 @@ -1,23 +1,29 @@ - + - + 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 - AQAAAACAAAC1AAAAJQAAAA==eJxjYGBgYAQCEMmAChhBElASIYCuCj9gZMSlBbcMYQAAD1sAIA== - AQAAAACAAAC1AAAAJQAAAA==eJxjYGRkAEEQgNKMjBAKzILIIANc4gxQvTjlcAHS9QAAD5MAIA== + + AQAAAACAAAC1AAAAJQAAAA==eJxjYGBgYAQCEMmAChhBElASIYCuCj9gZMSlBbcMYQAAD1sAIA== + + + AQAAAACAAAC1AAAAJQAAAA==eJxjYGRkAEEQgNKMjBAKzILIIANc4gxQvTjlcAHS9QAAD5MAIA== + - - AQAAAACAAABAAgAADwAAAA==eJxjZBwFo4B8AACLfgJB + + + 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 + AQAAAACAAAD4EAAArAUAAA==eJyNVWtQE1cUXhSfQ1UIxaFjURlaqQ/QoI3WxzG+OijW94hWBbWdUhkftVgBqdqOHR+oIIOUwQqiTqWKtv6oSGoQgoC2ahKICWqbLJDHkmhdilJt6VjUvbvdk93GM5m5s1/u3XO+73x7LkVJBQviZxr+H/cVZB9+Dz6Pcfy/r3ysTJ2++OC8cuflzsnll+Pnq265FYfBR18YGVxOVwPC8bNcfhxyfWJQHjk/YF44j5xPGHhaXLan8iLttYr20U3ovbgezONldcHnGR/vxTh+L4N0IPGyumAc+wE/Y93x+3A9vvyH98n1G+NYN7m65b5HXBc+L8cPn/M1txiZenEeuT6ReFkdSeC8OHCf8Ir/9+UzOV19zUW5PEKUxMUz6Rd+4XA7//8K163jA08YuedGHu+fqVtpnmaC3BGhf+/VunncejQq7a66DiInmQsL/7nC4/q6r8ZWZZjBpdir9/tLx+OXTkydYtqugwmnK1IyV3hQnkZUt4lbryJcB/7cSvDOp10xuBa6PX808TjhGXli47AZsVYI0asHr412AOE5KiY57kwnDf6X+4zcXHUHAjmezf3zltlv26C17dBxg9ENhOeCdbY5BwNoGJmW1EAra4Dw7P4kd+ftj2joOLikKqLgChCeTzKy0gqzbRDmPL9sUK4H9h3KrM7TVPKruCuYL0VNzb+3ZUNKLWwtnpO9P8uE9ltAvFJU6e2GTF1EPdpnh9gxizWG8usIb4Tm1vQZi9LreJz0N/B80vSgBCEf6e+aTQ/zPu9ZzeN2rr9Dztnow5VmHh/P9feF3k3wOEel6h57lffblzb/kPLEJrgwt3Tihm8a+P4vqU09NSuYhvaC+DLNIMFv6qyIA/NfoSH83dKS4BTBbzVhn17qnUSDufz7cSlxFiD1OCa227NVNJw7mjAm8FgV8htFDVeEaArvO738f7Z9nTHTyHj5f8/MpqjkoW4v/289Ncf6mcHh5X9ny7SCxCkeL/8/iMzu/2ORXcb/duRzopfTy/9+z5adHjHe5fvneKrby//i840g/s5ZPj/5zgn+w4IjisY+Nbz/Cf5o0+z4/Eo373+C9/rp9f071B7e/wQftLTHqPoDOhm+JDBfEpgvF158KeoT7Yi6bZU2yFtJjSoxC/0Nje5UWS/bQBncd/guRuhvRlnIln6tVnCOVE9bXtjK9/e75j+DC5Ot0Nbx2h9Ds5x8f6OCLD08mTbY1ALa+ake3m9jEpPDY2JsMPdrtVMxQehv2fq7F9a/b4eciNiunwXpTeoW9H62K+ekA5QB1aMDqmvF+3n+gq7Ex5ZckyOo3gYXrYdbJtMtcI7z8a4hRfGPQ2iOvwWIjy/dvPym9YkVFu4+OS5Q6Qbi4/R5esWZChrS/Gqv3jFVgYvz8b6nneHsBBqmjlfdtQTqgPhY++uas1qlDRYuf9jjjQ453wm+lr5fWJC+X1iQvl9YkL5fWMD3i/g7J2EH873WmauDWr3mYaomzJhrdfA48T/RjeCkTqIDwUneAZaN7OxEwa/E/9J+IIH9QFHSfuDCyw9dCmzuu+o9tR3ISnR5sTqR71io1/p92DzbDZGKpRrVMYe03/4zZ8R6CvNEPDeFeSLWTZgnxG8EJ/OEzE2C9+TmiVhnYZ5I8yWB+VKUNF+kJ54zXryFOqTvCxak7wsWpO8LFqTvCxbwfZEwRKPvO0wPr+67+U77ZAOsXBjz6FovA9zvXdNz928G2JZh/GDglZuwuqSs+lodA8sgryjYeh0S5v++paOUgZjQnLYvJjaA8sZk588LDDB6gDH6wVwGGnoXR+cOZ+DtRW352bdcMGvYJNvMxXpQ+j94a959FxRr+32bup6Btaejtu9yGSAkbvfRosQbEDuU6vYojIGKparA6msuCFLZV+m66jHvOBZQc8QFSWtCxwbPckG5onvFuo9d8C+oKkg1 0 @@ -41,4 +47,4 @@ - \ No newline at end of file + 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 index 9b6122203c5..d71ee77fa6c 100644 --- 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 @@ -1,24 +1,32 @@ - + - + AQAAAACAAABIBwAAjQEAAA==eJwtxVNjFgAAAMAvt2XbLdu1bGNLW9aybbeM1eKqLdeyl22by/gZPXT3coHAfymc0qmc2mmc1umc3kEOdgZndCZndhZndTZndw7ndC7ndh7ndT7ndwEXdCEXdhEXdTEXdwmXdIhLubTLuKzLubwruKIrubKruKqrubpruKZrubbruK7rOdT13cAN3ciN3cRN3czN3cIt3cqt3cZt3c7t3cEd3cmd3cVhDndXd3N393BPRzjSvdzbfdzX/dzfAzzQgzzYQxzloR7m4R7hkR7l0R7jsR7n8Z7giZ7kyZ7iqZ7m6Z7hmZ7l2Z7juZ7n+V7ghV7kxV7iaC/1Mi/3Cq/0Kq/2Gq/1Osd4vTc41hu9yZu9xVu9zXHe7h3e6XgneJd3e4/3ep/3+4AP+pATfdhHfNTHfNwnfNKnfNpnfNbnfN5JvuCLvuTLvuKrvubrvuGbvuXbvuO7vuf7fuCHfuTHfuKnfubnfuGXfuXXfuO3fuf3/uCP/uTPTvYXf/U3f/cP//Qv//Yf//U/bxdplQ== - AQAAAACAAADpAAAAKwAAAA==eJxjYGBgYAQCEAnBIAEGOIAIMsJZYAYjkgJUDnYAsYA8MXLUYAMAF3wAJg== - AQAAAACAAADpAAAALgAAAA==eJxjYGBkZABhEAQDEB/KZoQQMBG4EpgkIyOcjSyDUMLISJI4qWpJMQcAFw4AJg== - AQAAAACAAADpAAAAMgAAAA==eJxjYGRkYABhIGBkYIQSDGACwoBKMkCVIBTDlEJlkJVB9KGJYAf41FHDDBgAABbOACY= + + AQAAAACAAADpAAAAKwAAAA==eJxjYGBgYAQCEAnBIAEGOIAIMsJZYAYjkgJUDnYAsYA8MXLUYAMAF3wAJg== + + + AQAAAACAAADpAAAALgAAAA==eJxjYGBkZABhEAQDEB/KZoQQMBG4EpgkIyOcjSyDUMLISJI4qWpJMQcAFw4AJg== + + + AQAAAACAAADpAAAAMgAAAA==eJxjYGRkYABhIGBkYIQSDGACwoBKMkCVIBTDlEJlkJVB9KGJYAf41FHDDBgAABbOACY= + - - AQAAAACAAAAhAwAAEAAAAA==eJxjZBwFo2AU4AQA6g4DIg== + + + 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 + AQAAAACAAADYFQAASwUAAA==eJy1VX1MlWUUFxRFJSfDjYlDzYV9yIjQwqHrgNCENP8oiz7MHEK5HOQnwUKlWiWiG7CFOYHsa7pwDbebKIzGV1eIxGte4Zruvi94L14ulg+VhmDQC7zneXnPfZ+AJs/u9uw5z/Oe8zu/3znnTpo0niWD8VlkF53F7wa+KN9ffcZz/+94dDFBfCb4ntrpe9G78cYbzS9d9ysPek/fUbsI31i/E92L/Inyt4DxWVRfoveiM/2evqPvaRz1LLfpdw+csuB+vPnQ5RLgFtWNSxDPJYjHBDipzjQurT+KU4SDxqPvcY01nggfLpoPzVOEmy7q1yL4fjQdRPmPVwfqX6S3qC9pPYj6m/qhuERxXAJ+6HeiOTJWXGPFJ8qH4hLFF9WJaM6N9R6XDfQ7Lqt6biD2Wpii7mi5N6CsBWbwHgpjhQP5uXWFFdX8fkVkVInpy1bQ+9XiRH92c3faLjO3B1RtkTpkPLd6xE89XLN4xc4ajvtqSllj8wYZmtOOd+VGtfA4b5Vfuv1McBvMvX6oe1cj+qmFQ93mjIpkGdYntM/87QU1zkIzvFjQs6rPT+b4N8S+Ujxf0a+3hC33r6zmfv0++LBtb7oMEb6zPu670ghxKv68pw48mrxNhkVzvI9PT7vM8SclukPmZrVB/XfWNRE9V1R79Si8U540/DrzQg0/mpAPyhPyQXlCPihPyAflSY8L8TuIHeumw0M/r8Etu0tvV+pmyJ7hhoKHEpSfpnt56tXTqa85BLy4IcKvLtyvTsM1+HXB105jvnhcWveM+G8gdlr3DGjd69/bIHNNyefRO+wQ92t4mWR2cL83+npWpm21wwNKHcX/1DHsZ6AGun22rYsulGD6P+dskknFqfi1nyiaOs0mQX7pqax7uW7Vn6z6b+H8D/tT+uDv7sxrLfWcf99Bf8tksM+Ui7JDazj/Q/4C5GH/DSp+hX/KO9UDead6IO9UDz3vtR64MR+KG/OhuHk+BDfmo58/DIznj6a3fv4wMJ4/Wh2gvohfz8v/r3s0ZaTkn1qaaYdl1TEfmaY4YUFQV+zmPa1DdVNYIQ3NH9Mijf/ed7J7KzbZ4cxXZ/2zt3fAad+7W9OtZl5Pvmo9YZ0Z47YJcDcY48Z8RuDGfCaqbvR+UA86R2kfU73pHGX6uabslHfUg/KOelDeUQ/KO+rBdszYuC5GqfvnIh9+s06Gw/uybhfewf8LtxpHVv1fgkcCEisijzkhLy8pMf6iDN+67m66+WkdID+0vzlDahzc9fx18Hho+aXKK6X9WTePZ6iDx/x0EH5p/Wt9o68jxuebvo4YqRsGxvOfcfz6umFgPP8Zx5+fsPlEf78ES3Lm+ISEOSDJ0V72jbIP8u0dIMFfe7Lmv5/j5P7T9klPlwZJ4B/TkL66pRNmL36veF6xE9L+PNm4P0zRP7MlOS5Q44fyrT/T/nID8o4WHf+075SzcX8xoqfVgw/Kk96/xhPyQXlC/HqeOqHSEhJvXu2Gk3Lc697BEpxzulduf8zJ9UaeykfyNOJ/cni/f3VEdcU8qK6Yh4euqt5UV8zDGC+dn1oehng95qeWx8T2LS42YXVkjJ8RfrS8jfETvyP4o36N+0vLQ99fDIz7i+bBJiyP3UFBTWHWZnjpwbd/CFt7AUpnP/lGYKEFjk79w/eg13nIWXVsXlVeI2y8FXjWcrQT6nueD2vaeRGkl39vYu/egGuVa7s+WX8ZloT/bEuZ1gmmg7N+nBxugUS4ULSl9jyE+vQfeSK2CSbfejU4KrQTvt+bfWTp49pO73E3kfs7pdeXz2hyeez/Ald+CB8= 0 @@ -42,4 +50,4 @@ - \ No newline at end of file + 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 index f09423cd04d..f5c56548e98 100644 --- 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 @@ -1,23 +1,29 @@ - + - + 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 - AQAAAACAAAC1AAAAJQAAAA==eJxjYGBgYAQCEMmACsBijFBZOB9dFX7AyIhLC24ZwgAAD1gAIA== - AQAAAACAAAC1AAAAKAAAAA==eJxjYGRkYABhEGBkADEY4VxGOBMFMEIlGTAlGXHpIRIQpx8ADzMAIA== + + AQAAAACAAAC1AAAAJQAAAA==eJxjYGBgYAQCEMmACsBijFBZOB9dFX7AyIhLC24ZwgAAD1gAIA== + + + AQAAAACAAAC1AAAAKAAAAA==eJxjYGRkYABhEGBkADEY4VxGOBMFMEIlGTAlGXHpIRIQpx8ADzMAIA== + - - AQAAAACAAABAAgAADwAAAA==eJxjZBwFo4B8AACLfgJB + + + 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== + AQAAAACAAAD4EAAAnwUAAA==eJydVQtQlFUUFlNTh0BYBsciTLLEB6iYrYZ6WMdHmpaGjkiapD2cGB8pGhJjaZDa+gBmRcZkfeAoOoo6FSi5CqsulCkLLru+2v0X9vHvrg6/Sqal2aZ77z//2b3u1J1/5p/73XvPOd8537m3Q4f/MjiQzgV4Os46x8I5ZA/bxzhr4HWBYQ+vY/v4H8wP63ywOILtCxaHHuE8gyfOIz7Pygu2j+fYPh78/zyvZ/jnEM7SiZiHR7ur1tcc9/8/WbYieyz72D/ODz6H97PqgfODByt/weLC51k6Y+mFZ/DBvFm6xn6D9TernjhOVr4wPz1jPys+bIfFm9Un2A9LH8HygeuB84t5BbtPWHnD/lj3TbA6YzyYPRyHDcqnpPE5lecRfhkOXbmk1PZtorhqYK+/NmjcEK7UzjWONVD86PTvZJe7nYMWV8641Jw6io88eCpLOccDJ8tSxhhWaykeM6tzQtMmLcRVWLitNUYg/rD/J/96hBug0+O/FuFa6PiYphjXg0fe0VsH94rk8mcmETs2iG5Q9F4w2AqVUw8lL95xifpfa+kUfSLDCne2p1VVxxiA8J2py94/IYqDuImHyqOy6iB+lFGtfngWFFv6bpr2HAfGE0eGZ00xgU22oSHkTy2ci11+sutCDipK5w2N2FULJA/25Du2AjkH3xYqzxRX19C6JMvfUP+wxwSEn7ReBkgpubFicZaO4jLNQouDI3MT2q9F9bTRfMxxNu/pWdbol29ST8KX4ObSxFXXFCJfgjfU5b9Wm2sEp48vwUmdCV+Cx5ct6TduktmXdzuN78Pk629WdLFC6MsT21TGq1RvLeHFs21XLOC6VbhH3+iGCF98hdN76IZ48z1uc2XmQ4Wot4KNM/aN+ISDsrxv1tT3Pwsv+XR1P3fLKnWBBWIdx2bHqPx1SPIzQBZdrb7p8NOf8YZr/AeRLj+dZ1fHNqrMdr++WD/empjZx+2n/7b4gvAfd9r89N/DtESYnOGBor6TvJ+Jrlctula56D0b0gMZbkgKPTMk9IyO4v+eLtprp/WXbP/Kw9CDAIH1IEBgPQgQWA8CBNaDAIH1ICC+AgTmS/SM+QoQmK9vv5evSWWwRzZZ4Lh5a+torpXWV7fDMTJBxsERrqS9/RcTra893Ho7VcNBt4p9VXdba2l9T148/ar5vhneXbd3eESSWF/N9fmHNUkWmJbe3vmVu24QfPU9FdHy7Dxvf1cX5543HK2FCF99pXkng+Qb664eQnw8pLj2CZ7tluLe+06qX7GvpfoV/RN+uN8JP6JzghP9Et0SPNLHD/e7tH74HRFoPFJdChD4fREg8PsiQOD3RQD8vhTP7ZBQbnRQv59pBtZ9UWOBpKjuA/J4nsbZa/ADufm0BRyDFGPT1S4aT25V9Iowlxlu3X3+dp8tDqr/8pY/otSZZljaCppp2R56/ydGmjp7lBaYuk3hkI200TiHZmTGDRtm8etDad0cCMd6EO95qR58uFcPwrLu77+tEOstnWO9uaFJE/JRy2RRB/GyWdXyXXbaT5Lt3rlUbyKPw3c+bVQ28oiPQPsG3yef73/LvFJv97tPHK1jt2eM8fjdJ0SH+D6R8sNznE/MV4DAfIXAcy8vKX9Rz1L+om6l74IAvy+dnFZS46b8Cd7lpxc3fqnwUP4EJ3om/Oend/2+R/uvsPOF7dOv5POg13luNl/Vw9/FpUtHp+rh56+Xt6nSGmBz9DFrju4iTOg3yjJ+RgMkdWrr/85NJ7yeequkoNkJCw4mrs5z6kE2ZV3pzowLsEsTti97EQ8X8hWGoc082EJ6poXFNUJEydzf9MqLID/gOpWSzMPuCzHpC4GHtSMys9as1MNMe7/dB+J5SMir//jIID3kh257lHLJCd3vJRruFTkhXnVe6LjMCeGZsY7C0U74B9blTOQ= 0 @@ -41,4 +47,4 @@ - \ No newline at end of file + 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 index 628dc0dde5a..4a31c60bd72 100644 --- 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 @@ -1,22 +1,26 @@ - + - + AQAAAACAAAAABQAAFwEAAA==eJwtxdciEAAAAEBNoSGKsoqMNlJ2iTKSQkJGmWVWhJIiKmRGESr6VQ/dvVxAwH97vNf7vN8HfNCBPuQgBzvEh33ER33MoT7uMIf7hE86wpE+5dOOcrRjHOs4n/FZxzvB55zoJCc7xed9wRd9yZd9xVed6jSn+5ozfN03nOksZzvHuc5zvm/6lgt824Uu8h3fdbFLXOoy33O577vCD/zQla5ytR+5xo9d6zrX+4kb3OgmN/upn7nFrW5zuzvc6ed+4S53u8e97nO/X/qVX3vAg37jIQ97xG/9zqN+7zF/8EePe8KfPOkpf/YXf/W0Zzzrb57zvBe86CUv+7tXvOof/uk1r/uXN7zpLf/2H//1tnf8z7teXTGx - AQAAAACAAACgAAAAGgAAAA==eJxjZGRkZIACRiTAQAAwogJCyskGAA93ACA= + + AQAAAACAAACgAAAAGgAAAA==eJxjZGRkZIACRiTAQAAwogJCyskGAA93ACA= + - - AQAAAACAAADnAQAADgAAAA==eJxjZBwFIwAAANIiAeg= + + + 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==eJyllX00VHkYx6cXlaUXoy2sJEm2UKmoxEMJyVpJxVnbeqlTpE2dliiRantBUbJRJpLUJEntng27TfIamhkx0WxjmhnmzlDulpdKsp1dv3uba+awp+efOc/n3vk9z+/5fb+/S6N9GkJQSGk4DI/jlOeqOPX/qoL6HB9ivaHeG2o9Vb8oOCrmIFTBsWHOjQPKOXV+KMcov6reo3Jq/6rOCxvm/qj9o6Duh8pVharn1LooMBX7o+YohtIxdd9UHaja5//tlxqq5jRcP1HXpc6FWudz50LNqf2quheo66ny21DnimKoeQzl98/tm5zDy3ljXX+f/xCKtU68angoBF7Gj9dTPJqA1y5b5U+XgVeHM33UVCHU2R+e5cN6Aj0z27d49ojB39kj3depGTRywTuvG4PE0FCvbyY1gjbrYKxTVTPsP792+igPGdHXC/fCMNxBANebHseVGIsg6L2TepClDEZGfb1ha1AzmM0T+zx4JgZpyPIPV68IIWuZtDPHVwQZG0+t0dCsg3iT9dFc50dwfGdprWCsAOqObcm3FktAr62zGNNqhahrQZIiqRD4mrPO6IhKBuo2Qunfdtl1TCEsznePo5mWD9SXQ3lpekRzrgDGF19ysdz3cZ+p+ZyukAqYpGG3kGXbDEb1i3aLjsghY9XOcKy6HGKarA9G0YXgx9dpYd0sB89ry+7d+rkRJth8q5/GfA69N++EG58RAIMR1JHk1QZxLonWpSs/7sPVvCa16z4x76tu3ljkb9UDuYTgvtKGS1OzuETfiE+MK/met6Iekufq9h7/Q05wQbpFBN+hAkyX8xiMvlKCsyuOLLq/nwdS7ePsEe9KCF6cZW9Xf6AEljL/3BPn20bUz/13HnUUfTTC6gVehZy7NQRH9UWySMd1kRUER/W1bm1bSf+hnuCSgfoBoZ0pUWMeEHzJQH3DvGbhWRZvUF3F+aCQgOJ8aLT8tee1G9XLAM0H8a5QV+9zLDmg+SA+tmhafLRDG6D5IK6/Uc28LqEE0HwQvzCvOLX+nZjI96Yesq1KqgRacDAnXI08nw0cKzNjkEGCsWfDodXk/RS5RM8ykNkIR5IsChebywiuTr8338dHAimn6U1CMbl+TGB+UiZTBva5E/attiDvs1ETtr1jW4ngqI1LNiuXrHshNNpgrmkllE12m5/9Ukrw9vUcK587jdB/1lOkxSLnaDKVn7HRQALHxkzW859Gru/G8451HMcD5oAvEEf5dQr3HvBJffwXC7DKcoLL387U69MpI3xEXee/DAfl+sdBuf5xUK5/HJTrHwfl+sdBuf5ptDnaUwoZL1oH+fHG62BuHBej9EOjHVv13GL7DPkgP4bnrBGEcVoG+bFVvCLNz65tkB87TBMn/npRMsiPiv2QvkD3MeJI/3sLDbjJgpZBPkV9Io7qoLqII/1PerITd/VrI3hPaWVO0kHyHPzKjIUScQ1UaG7mBjFI/tau1UTfXgY15gGLL+WS/flc66l4854HGn1GfTPeiwke32+UlbJcBqKTp9ONdMnvVdi9bjNrTTEkR7la3omuJfjIK5yAoAAxPM6ekvg8luy7OsekQF9eCYcjdVueNpLft9E70me7h4iBb5FqesKGvKc08ruKPNKewF+vzZhsE7L/Ns/ApY8u84GqU5Qr6pnk1PfRew8ex7Zc+aQuykdH7Kj+ql9E8FsMre6Oc03E+SqeOwoJKOqQvPcUz5e895AOER8zcO8hHSKOzl1RDyhwUO4LHJT7AgflvsBBuS9wUO4LHKi+kD4925DXzobKEK7coJoN08yiu28L2PD2jBRXrxXC+KNWBbsbamBXgs9TBr8VCpY2wcnNAniZPiIJ62SD53ddFvwgARj+svDUGttW6A1T21NtVgc2y6rm+OVxISLu0SZmEwfUfnKIvqxTCw57mly7+zBwT7Aqj3LGoL/34abNfDa4dGTaJAMGGVVOjiGzm8GkTc0la5cU4s/bBm5fK4WJ1nkXHYu4YD5z3ZStcgzM/Re4YVE8iKEb6uD7pfDmXFhU6XQMDBld9UdfcYA7i5nWqs4GjwMsQ3qfFOhbLT6Y2GBwwz0zNSlPCs/8vrxYYC2FYN707SNuSiEzVdSpdUMC7SXjYlpuYyB9fequrokQ/gGrr1OL + AQAAAACAAAAADwAARQYAAA==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 0 @@ -40,4 +44,4 @@ - \ No newline at end of file + 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 index c16e6b55d14..03cea2ede5d 100644 --- 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 @@ -1,23 +1,29 @@ - + - + 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 - AQAAAACAAAC1AAAAJQAAAA==eJxjYGBkZABhEIQCBAMkDiKgYmA+A2HAyAjVRaY8IQAAD8UAIA== - AQAAAACAAAC1AAAAKAAAAA==eJxjYGRkYABhIGBkYIRQIBEoCZFBBow4xCGSjLjlcAHS9QAAD40AIA== + + AQAAAACAAAC1AAAAJQAAAA==eJxjYGBkZABhEIQCBAMkDiKgYmA+A2HAyAjVRaY8IQAAD8UAIA== + + + AQAAAACAAAC1AAAAKAAAAA==eJxjYGRkYABhIGBkYIRQIBEoCZFBBow4xCGSjLjlcAHS9QAAD40AIA== + - - AQAAAACAAABAAgAADwAAAA==eJxjZBwFo4B8AACLfgJB + + + 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 + AQAAAACAAAD4EAAApwUAAA==eJydVAtMU1cYLuBjGCdiHRtGZRpxOsUHsoDR8YmvBVh84SuKg7G4MQnOLQjM6dAlTF1RgQgSUJRhfGyKLJmi1SIULU4dLVgLPtJeoO29pTrvJjPodAxdz+3uaW+K+9Pk5Hzn3PP9/f7v/2WylwkG7vdSOAme2kvh5DueelcKlwpP79LnNE7fp+95+n+e3vOkh6eVDh3c76XqInWfzoM+p+95qj/XS376nA76HRp35tFdVrWj5qzrKuZ17JlWSldaN7p+tA697Qc6TxI0r1TQ/19H5UfzcxLnnASfJ1/T/DTe276V0pc+l+ofOo+X1VXq+97OGzo/+p6UHnQ+nuonVTepOeOpPzx950l3Gqff/b/nJFogXknoHfsrFK5GH8dKkKfdPRGkgfcLGvKdWTg/9v5KbtOZay488ezN718vb8TeCYF/7VR1CLifQr3GMFuPcTMNpaXPLgm48cCkL+9E1YOV79R6PXHya+uzw2o3GzD9h+o0RbxdwC+Uz4rUf61G6ieVvz2YYsGJWzcU6jFNGNCmWdzvPSOStabiacNuI3rqUqXu3HW0XTy//lINg+XsuKYgLzvabJvmxm2qh/FWRsPjrSb4RjInj2zXwP+n5DlDEvTwTn9ywxzPYH3yspynPnVI2tBZuKVfHXbbInZt8WaQHJDNViTYMbrCxBTUGPC34u7W049Ngj4B2qigjya3ois/PNwn+oqgz7d55RkxKa1IW5QzIihUL+izTJN5dP5QBg+LV1Yph+tRubhE3uJ7GcHafst9BzEYM+VCfMCpegxf0TekaZcaSbFvFjz7mAHqd4T039Ms6GOZ8dCcG86g4kDCVP9DtQKvuE4kzCB1IgjhJXUi+J8bYlYW1XSA1Ing/c+PyMmKsoPUieAkT1InMS+P7/IUdYXKGmEl+L8r7U8es4rubVyfpkFGWWxuzh49db+ZWkm0uPhV/K7Vxf9ez5etdjHe4/sXeGaHy3tvywOUpfetLv4/+XBdo6KRc/H/jnmtk1JGdbj4P+NorDFdZ3Hxv7V9dnFipN3F/w/G5fqdPmgW8hHXlxfyIX1BcJKPuL684DfSFwQnvOI68oIPif/FvGZ8rppQ/1WNCYVrZCHHDE59TjFFnZ1XTdi/U5e1O9gm8E6s6LvEL9WINVe767gSq5Dn5qqAjYNsRlgnRs1eVWpDhCOfqYkpo6dNM2HBviirfLpZyEd7cMbCbXkmaLnFXcf32V30ENeP4LQfCE77wYG7+EEmq0q9cyZ1tRn5Y6J7frQPyT1nPz2/lX/YgtCBdVMG1mnE9wU+Nc4aC9rfZdpBfNa8V28Z0mRy6NgMwz3bvA+H2KDZb50eImfgW3Gk6lF7LTKVIxv3Gi2w+LX+EadisGT74Xf8QztA/Heh4eJY42MjFq3q7Bv8qAO8w0+qu0knVaEmKAs3X9NX1sK/+TM+JtGOav+2/gnhDKUjT/nOqSvxHakvwYnvxH3BC74T+5wX/EXqS3CxH80Q9yGJFkEfgpB8iD4EJ/kQfQhO8hH3m3O+DXboI+bl4d4PxFe0H3i494Pj/n/8IDB8MeCDBVFmkFXMb6V4ZLImldfatpieuSNfoQw/ZHHvN4GH1tPZP2I9nXNDrKdzzoj1dM4TsZ7OeSLW0zlPyN79vOXhft7ycD9vebiftzzcz1veJV/3+pN8af15uNefqm/POlYfzWpZLYbmvXFHNliLgJ+Pp8oydRhZOShrzo8cVpvz29YyOmB8+VJ7ZAMOdgcOiwtshOraksnB2Q1YwB5JNBo4lP06fFUyOHwTkZK2LV2HiOO26lkzOIT2eTB+4X0W4XG/F+XeZDHnrZmmeUu1uH8ivRS3b6Ak4ZWwrgIOjzIUr/m82oj8spxQb28dhv2i3pg9ikNXmHnR/Osszsl9qtd9yuJm1qGBl0tYJCcFhg2dz+Ifyx5H1A== 0 @@ -41,4 +47,4 @@ - \ No newline at end of file + 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 index dfc222bd1f0..916a87b840d 100644 --- 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 @@ -1,22 +1,26 @@ - + - + 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= - AQAAAACAAACfAAAAGgAAAA==eJxjZGRkZIACRiTAQAAwogJCyskFAA9XACA= + + AQAAAACAAACfAAAAGgAAAA==eJxjZGRkZIACRiTAQAAwogJCyskFAA9XACA= + - - AQAAAACAAADjAQAADgAAAA==eJxjZBwFwxwAAMqIAeQ= + + + 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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 + AQAAAACAAADoDgAAEQYAAA==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 0 @@ -40,4 +44,4 @@ - \ No newline at end of file + 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 index ff1cc3b8885..9b0bcc81818 100644 --- 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 @@ -1,9 +1,11 @@ - + - - AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK + @@ -33,4 +35,4 @@ - \ No newline at end of file + 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 index 1861c33b2f2..01db1d5816a 100644 --- 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 @@ -1,10 +1,14 @@ - + - - AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK + @@ -34,4 +38,4 @@ - \ No newline at end of file + 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 index 5c0a678ca1b..65d17fce651 100644 --- 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 @@ -1,11 +1,17 @@ - + - - AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + @@ -35,4 +41,4 @@ - \ No newline at end of file + 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 index ceee015e85c..930c5d4f1c8 100644 --- 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 @@ -1,10 +1,14 @@ - + - - AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYMAPGFEJSiQwAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + @@ -34,4 +38,4 @@ - \ No newline at end of file + 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 index cf6baa14765..0e3e6c0e231 100644 --- 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 @@ -1,9 +1,11 @@ - + - - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK + @@ -33,4 +35,4 @@ - \ No newline at end of file + 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 index 942f8e14867..673c7a8b70a 100644 --- 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 @@ -1,10 +1,14 @@ - + - - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAMGBkZqSWBCgACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + @@ -34,4 +38,4 @@ - \ No newline at end of file + 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 index 1934ec64f6d..a0ea5026181 100644 --- 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 @@ -1,9 +1,11 @@ - + - - AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + + + AQAAAACAAAB9AAAAEgAAAA==eJxjYCAPMDIyIhPkAQACtAAK + @@ -33,4 +35,4 @@ - \ No newline at end of file + 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 index 6878f8f16df..a1e5fc2a2ec 100644 --- 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 @@ -1,22 +1,26 @@ - + - + AQAAAACAAADwBAAAEwEAAA==eJwtxdciEAAAAEBKiTKSVMrehCYlZc/s7LLaVFIUyqhoUAmJRP/qwd3LBQTsC/QBH3SQD/mwg33EIQ71UR9zmMMd4Ugfd5RPONonHeNTPu0zjvVZn3Oc453gRCc52SlOdZrTneFMZznbOT7vXOc53xd80Zd82Vd81QUu9DVfd5FvuNg3fcslLnWZy13hSle52jWudZ3rfdsNbnSTm93iVrf5jtvd4U53uds97vVd33Of+z3gQQ/5vh/4oR/5sZ/4qYc94md+7hce9UuP+ZVfe9wTfuO3nvSUp/3O7z3jWc953h/80Z+84EV/9hd/9Tcvednf/cM/veJfXvWa1/3bG/7jTW/5r7f9zzve9X/vAUgYMHQ= - AQAAAACAAACeAAAAFwAAAA==eJxjZGRkZIACRiQ2PkCsOsoBAAb0AA0= + + AQAAAACAAACeAAAAFwAAAA==eJxjZGRkZIACRiQ2PkCsOsoBAAb0AA0= + - - AQAAAACAAADnAQAADgAAAA==eJxjZBwFIwAAANIiAeg= + + + 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 + AQAAAACAAADQDgAAxwUAAA==eJytlX9czHccxzvxMGUtj1RrsnFaYdFGkQfujWErzppHUTLSxHrQ6DGGLGHqEE3NLPaoayotxa4kxXY8+iHcVZfG1V2uu/te+t5RvqSrLXW71X2+X7535xifP+77+Dy/3/v8eH7ej9eHl2i185M4OaxxZmiT+kRg1d9EwMX7hkUzmoHX/x434gFbdPtKdrcaOG74Tg6sul4H5aAakluZbIQZbu47+veW+pa+e9EnavKBvlxBeniGk/uUm3niFv5PbyIz3Nz3dM+i5+/DiOMWPNPXQ5hZP0HzQV8Pvb3sfv7v/+nro4/7sp5e1QfdK73u6PPTxzFXr6863uuum9e9Lvr4ln1zitaEXT6sALvI8iu7RkkNvAEuvut7caefDDIJjDlPqjTwJshYVdQ8ulufb16SB3bfYQN8NwYpbslNGWI53Cm+s5Af1jjAtyvJeX5bHIzHFAvI8RHvGnc/YmkXBscT//mxdoaa5IO9d7XVfaOGdz6onPbFYjHJkzZvDmTbN4AT7lLgPUttdA75jfWJZW7UvPHaUy2MaQJImT9m8eM5KpJPdedYny2UwZAKX4fcvJskj4gJDOmOwsFf89GSFTMxkgsmOCVMbqqHDzco5j45eZU2rwp42qD9h+TlJD/dvw4NoCfigcd5os6NVUY8dbKbcghbA9Eb1021j6DGPzuyqCT7Dwy2HvR479hyCckPxIfMKzlTBs2L3FZ/xSiH+6ULnCcsEpDv26R70tlsvTfBDef5vdQ+Mvlun22yFkBp2zJHlrSV5OXYo3U1pzGoyuAIl9lQ5/OrC5d3WKqGOomEzfKleF80q3RH0HWIy1EOi8psJnk35mUbliKFLbfXc88zqbocduvntfXZGMSt2MDpeYs6t6I6P35AuRhmKkPPcHOpdTaMC/Pt7FRD+yOxYHYlNb7kaD3/To8K8mj+gg1eb6z8s6OSTXEOY1vplVINoPf0cwikcXQuyCfpsb8RpDfkC3HdjQHPyC/i1w0+kUfEkU/kEfFYg0/kEfFZBj/IC+LIM/KLOPKM/CKOfCKPiCNvyBfiwSY9EaT/YBo3Xd8EdFVcy0ne00D2wyrd5CpMCFXD19ZFplP8b9Zdd9c5ahBOCvc5mU/tMyS3q6r7yW2w7WX2jn1C7fOQjpl5TJ8DyqSUNKYLlZffXtZ6Th+OwdFY/ylFcdUkH3RKFB4ZjkF9ttMRxV5q/4Ic90JXzTXYF+PSImmg8nVwVJrHko0YSCcfH39wJrVPW17npYATYmjq8Dxd606t/97SL2fUZEmN9o/6dI+mc4LyWF6/t+XUU/Oi/uAdUYJROiXJC9JHaB+kNoK5nDWXp/YlHt6hIxqM8rekqiqoUZ/L9Jzt0f3Xmo1ydoWdShKqz9lYm19ck57K2SmGnB1Ky9nQ4okZtl/j4OCapSp4gZxl9P+qoIiWs6gO6XlgKWe30HJ2eV74mBx9zvITL2Enn5OzVs80woxvfb2bvNf09WTyHAgwfa9R9/izvgkwfa8RYPpeI8D0vaave5O+0bz0e81yvdK56XuNANP3GgF03xGsOUMf3xbCx4vSPFUcFYTzP7384HMF5Mqu9LIFItC1/3R94WwxeG2XWE+Ml8OB+3HWty61grgsofBWsgquhuyMWf+wGfyS2yRZP+BwpLLaUe0iBneuX8S+JBmkrjy3wJ1XDdb730yRCWWQNGm2zMYJh+E340Yyj+pzoCLyoI9OBlbBRwLs++5C3vgQf589+rrVimu5irvQyX+4K62vFpg2JWs6/qoBSUG+F+aPw9up3VaivFZYEnBTFF3YCprVmu879M/f21PwWIdWSExvPx+UK4BizgRBgTMO6qwEx02iOmgcu9Uj80INKLjT3x87txZGVV8gsseLoMdvW1kCjkP+Pc1hjlAEWimLH9xdDcnWfpvvpYlAVPFGTul+IdjZnytoWYXDaEfu+pgpOHB9PIMyXGrgBMO7Yqu+/y9gMIKO 0 @@ -40,4 +44,4 @@ - \ No newline at end of file + 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 index 972320fe465..b9b3f64b776 100644 --- 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 @@ -1,23 +1,29 @@ - + - + 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= - AQAAAACAAACkAAAAFgAAAA==eJxjZAQBBiSAxsUN0DXSDAAAB74ADg== - AQAAAACAAACkAAAAGwAAAA==eJxjYGBkZABiEAkFjAxIHAIARSOtAAAHlQAO + + AQAAAACAAACkAAAAFgAAAA==eJxjZAQBBiSAxsUN0DXSDAAAB74ADg== + + + AQAAAACAAACkAAAAGwAAAA==eJxjYGBkZABiEAkFjAxIHAIARSOtAAAHlQAO + - - AQAAAACAAAAEAgAADgAAAA==eJxjZBwFIx0AAAssAgU= + + + 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 + AQAAAACAAABgDwAATwUAAA==eJytlHtQVFUcxy+y1BCKI6GI2EzigzQFtWm0IH78oflqkSFjNEwRMYeEIdNEaopQCApFZZhCBljEAEGdtqRJNAVDWGBxWdiJXXYt1r0ru4uvHZX3qybO717vkTtkev85cz73d8/jc773yNOZz1clGiGweehF0wQVMP8+VpATvs3DoTtjWE04tkaqtQr7xhtcvcw67LzboR1C9o4kn//KwtUjH53HSo2vFn0/9rqsovPIx9wf/dhFuFgdXT9ef7y6/9qS5xG/BMDIiV/Tqs4/3uL70ZY6J/o8uXHpOqPIftQiXKzeSnG1iE+jCLeO459ej11k/XZqn/R66OdJ9/N/v6fXR4/7pJ6e1gftlc4jPT89jliOn3a8Z52bZ70uevzxfa/QL5a31xohYV2+LOiTVsLNkFq+LaLy8A1wja6u+tLLQLiOGtfMtaPf/wWj45mpep3o+7HnMYvOM/Z6GeaOISlfKtXC7YqVHvPXKTl+8vKc9XGO//SVDR4rhliOV7P3P1SVsVBxJ2xqoMHC8ROeMvlhgw0UBamNYS/oOD68O7Ai4b16aNbrpYHLed7L+rlEZBogscTkHHuynePOf3wfpSliYW/rTtkv3vz5lDevuRxSrYXE93elDky2cVw3O2J5V5cN/E3hZ2Wl/Dr1WZrLfw6Y4e59rfKtGn78jcfl6q4YBZxu06T/PqeT46kO8RVVFZ3QsPnSgxopzzeQevwOeRn5Ht/PlOyMOjLSwL3P7ZN6KOUshL4qyT2YZOa4enX8gnhpPZxSdSueU/B5SsnzWriskoVmh717iibx52BzuuD02/M6mJLkVnzM0sZxf5P+6oVr7dB7bsubi/x5nhMR+8CtwAr9c2vk2314bp+asysrtxEmhu3T7K/h/W0qb2kP6G+FQR+nQu1Sfp1ry9s+fWlJJxwKC2azF5k47v61bUH2bfYxfxtFPGEdzbE/eZ3s7WlL+HGwX7a4R5L2Gn+e/ZPmRtc56DmfjcQj2R0UE5/JxCNyPBc8D+ToGf0iR8/oFzl6Rr8cJ57RL3L0vJH4RT5APKNf5OnEsxvxi3zsvNphbK98Pc1diVdXgW87lBLP6Bd5z9W6kmNJvJeImjlGM9sIiolRzdH5PO8L7Jg3M8gGjYsiXy88Y+P4ptIeRe9gK7gMeQ/NGuT3c2jE++R3ATYwZWTmeXvy9/S+yu6FyyaykPXF2qXlidc4PqFYHRkdyYKmaNrRGwfMHFeWzPt5ZmcdJH/meVOv489DEpvnExzDgsH3+Cvf+vP7d5F3XQzJ0cL1BwvLmubx678Vuv0N1Q8GKKP80v83zel6rKvWHLhZ/Mi82JckxCq9Rkwc/yl/Sve97DbOnzCfDBNO/AlzzjBR5BxSBDlnmHTiVZhnhoknXgMEeWYYR+JVmGeGaSJeNwlyyzDo9bYg5wyDXoV5Zhj06i7IM38fbBC5T8uoe0Xs/q0lXun74xx6FeQZHzvnE/OJHH2iX+R4LnhOyNEz5hk5ekbvyNGzhHhHjvcD5hk53ieOxDty9IzekaNn9I5cLK/ok8439ul69FxL5Rs9/0i8J01TFabOV8HB61s/XrXSClUPs30Dbumg6bw1J22PFZrik2fdy2yGyAzfhrvTtTA9pi1kc7YFdiye4VRQZwHN1h3KuHAdJErrz0T3qcHvVGZxb4ca6gtmv9OQq4V0L0mwPagFFO+mXewbUEHNpAk++1++CR+sD4kuSVIDm3LJreWIBSJPp125sM8MWwbP3lp21AK+M7oqP+pUQ6FjqHtdnBkiDX61DVc6QP2NZ2GCrQNW+1U9dNKw8DfPo6vC 0 @@ -41,4 +47,4 @@ - \ No newline at end of file + 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 index 7e13faae85c..b5e40d737aa 100644 --- 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 @@ -1,24 +1,32 @@ - + - + AQAAAACAAABgBQAALgEAAA==eJwtxdciEAAAAEBCRogGTRKKlJZo01CZlRRFKJVRaSAhRWgRpUEqilLqJz24e7mAgEWBXuIgBzvESx3qMIc7wssc6ShHe7ljHOsVXulVXu04x3uN13qd13uDNzrBid7kJG92slOc6i3e6jSne5szvN07nOmd3uXd3uO9zvI+ZzvH+33AB33Ih33ER53rPB/zcZ/wSef7lE/7jAtc6CIXu8SlPutzPu8yX3C5L/qSK1zpy77iKlf7qmtc6zpf83XX+4Zv+pYb3OgmN/u27/iuW3zP9/3AD93qNrf7kTv82J3ucrefuMdP/cy97vNz93vAg37hl37l137jIQ/7rUc86nd+7zF/8Ed/8mePe8JfPOmv/ubvnvK0f/inZzzrX/7tOf/xX8/7n/97AZDZOXM= - AQAAAACAAACsAAAAEgAAAA==eJxjZIQCBrIA+TrJAAAIQgAO - AQAAAACAAACsAAAAGgAAAA==eJxjYGBkZGBgYARSIMBABiBXH8kAAAgFAA4= - AQAAAACAAACsAAAAGQAAAA==eJxjZGAEQiCAUIxAwEAGIFcfSQAAB+oADg== + + AQAAAACAAACsAAAAEgAAAA==eJxjZIQCBrIA+TrJAAAIQgAO + + + AQAAAACAAACsAAAAGgAAAA==eJxjYGBkZGBgYARSIMBABiBXH8kAAAgFAA4= + + + AQAAAACAAACsAAAAGQAAAA==eJxjZGAEQiCAUIxAwEAGIFcfSQAAB+oADg== + - - AQAAAACAAAAnAgAADwAAAA==eJxjZBwFo4AgAABUUQIo + + + 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= + AQAAAACAAAAgEAAAdgQAAA==eJztln9sU1UUx1vXiROQwITFMP/BsUUcEfEP0M0e/kBEl86F6DJAyWCLZIHFTKaTkLhN0ZEMRA3BuWwrOBlSYigwAkXcFkYprmO+UVnXNtqur9vaOfAGsu4X21zknvvy7utLRfA/7z839/vOO+fcz/v2pBrN9PL1gObvJdDdB+ZKza5XSn2wOUEb/nxSYM+nDp/d03LOp9jxPY1Kvrt7kJ2Nwcm4Iq2X1gmyeKyr75yI9z/UoXiPz4d5soqndp8r6+fiBdW+It9PvU7kvgSVeyj74jliPv7++B5/f4zn74nxmoiLqOhqcXx8tHO0uH+6qy1B5blPRQ9yuqBSx6eiB6Nw4PshnE94Xa0fft3rff7t+3x/fN575XS/PHiuvC/4+nweNT/db74H7ZsH3RefPzrvisbNuc37euCxgtaWjxZ6qN4NOzPqjKve+x1Wu5eZvZcDTL979tHnXVQPcPUC3N4NkesEVPKp1VfW4fvGOnzfmI/vG+tH7lvi1762ZEmJ4WdYf2zYNnKni+mf1i5MXdEsQr41yRcQ25leM2pIsJtFGNX3JSeuCjE9FHs+9sKMbtg7taj+YLqkp/vdl85f9UJJczh1xSyR6dW5hbfnHQqCrkHYUrBF0nMar3nTx7rAfjT5VOLAFaaT+dXbDtS0Q0xhbUrmdin+tUbX+08+NwAzzUM/ZlU7mf74Z6ElVYMi/LEu74WO7zxMN7kclReTBgB3VvcbszC03QZv0B11PPPxczKMaxZM173s+Li3IU2KH529uOCK1g0n6uaG/6xyQaJua/7+qTYFv+87wraHbUEF73XP6Go+KQ8wXaDfp1NbvOPIbLuC99zyeQ1f9ruYnkZ5j5ze9OLSNJeC96zsDxwfWqXvs57yHltsNeeluBS876TEfutcHlDw3pudKVYt9St4H1fhmsNxxThexzPy5Xmblg3r9jwvff8xyhv9iHzpLZh/kS/qG6nf0f+oV1L/Il/U0b/oZ9RjqH+RL+q/UP+in1HXUf8OUr6oo3+RL+roX+SLOvKT+5VAZH8TFpfDxaN/5bwJnKb+RT+jLp8ThPGTzwnCeMvnBGHfRz4nCOMtnxOE8ZbPCcJ4y+cEYbzlc4IA+lk+JwjjLZ8ThPHmOZpUuOdEnBMSd/mcIIw3zgnUkff/c5nW/Y/mska2CBx+wmje5wmB7VBFe/aj0u++vinp9XdjpueuvS1h9YTkp1bx1jsdJhEsN7Ln6z39TL/hKa8zGJwQtLyc8HSGnemTRXrLzjen57jbbdCvlPKPiM/OzP3KA6VH/XGF9dJc6X4qd+XQUAjS/Bt/MB6T6jZ2vtqU1eqE0g3bKsbnSL+fuOtf5zuOiFDctdV4ZpH0v8t9wNH023gAbt5y2l+yehV+Pc75tUJbYmmxDEDbWz/dthqizw/+91C7S5foSL8Gyy9OFB3s6YO83eNiaut1xRnjyk6mhgcf6QNNbUN88k0HlGU64uKHexVnjOPfx7wm81Wd9+1exc6/j3nPriWuS1/8qtj/AsTY83c= 0 @@ -42,4 +50,4 @@ - \ No newline at end of file + 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 index 064c56db772..efe7a44869b 100644 --- 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 @@ -1,23 +1,29 @@ - + - + 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= - AQAAAACAAACkAAAAFgAAAA==eJxjZAQBBiSAxsUN0DXSDAAAB74ADg== - AQAAAACAAACkAAAAHAAAAA==eJxjZGBkYGBgBAIGKGAEcRmIBMgaaQYAB5kADg== + + AQAAAACAAACkAAAAFgAAAA==eJxjZAQBBiSAxsUN0DXSDAAAB74ADg== + + + AQAAAACAAACkAAAAHAAAAA==eJxjZGBkYGBgBAIGKGAEcRmIBMgaaQYAB5kADg== + - - AQAAAACAAAABAgAADgAAAA==eJxjZBwFIxoAAAUgAgI= + + + 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 + AQAAAACAAABgDwAATQUAAA==eJytlHtQVFUYwA/vQRBHfCAD/REhPoLykWlifDRjkTJrpMiAOg0KxTDKOBaB5BSCmCRK6ZAhI6z4AKHXkphiBU6Iq4CwC8nCrsqyd3F3CWtH4iHPnDzfvd0jd8j0/HPm/M53zv3O73z3EPKg6TuA/NNUtNeDIovsCknVw2YPm77sUdUj8w97Mz+Wm0edd9i003VmPh73CVKPTDPYNvDrMD4scSzjwm4Tz9k4qTyQs+ul8kBOxm1WCS4Vx8ZPNJ4o7r/2hIwVns+8dEEPbP9wlvbj3Ke4N48/z68zS6xjm0qCS8WbGa6S8KmX4OYJ/LP5WCXytzLnZPNh2+Oe5/+uZ/Nj931cT0/qg/XK1iP7fXYfqTp+0v2edt087bzY/Sf2va98c3TVwQ5wi6++9ImXjvJWSAktkAe/fxtWahco2q8Yef5wrKfzLZQbme8Z+Z7dF7/Hrsd92e9hHuy+7Pnu6tIKZDINdFe87jEvtI7nJyt939pu92BcV+uxcoTjeTV3772GUg4q7kbMCNKZeF7oKVcc1FlAeXxffcSkVp6P7giqSFl/DdRarSxomcAHuBddog/rILXY4JxwUnjnnW98Fdt8moPEljj5OR/hfsrVqyrDqjWQumHrvqEpFp63Phe9rLfXAoGGjd/KS4Q8tTnNlbeGjPDHPU3dqzXC/pFHFarebUr4uq0561ffLuE+bZIrLlV0Qe2mX3pqZAIPp/G4DnkpXY/z3vZxsZ+P1fLzx+7LPOoUHKx93v7YnjQjz1VvJs9Pll2DMw19SkelUE978738l1ZxoLZJ/OD0ZOEeLA4XHX52aoWpae5Fh0xtPA80aC9fvN4OA2ffWR4QKPC86IQe9+NmGJxdo4iZI3DrjLytOcfqwTUiqXlnjeAvqrypfcVgCwzPcTihWSTkubq87cNnFnbBgYg1XG6AgefTP7XMz+3mHvEXKeEJ41iO4ymh8jdmLhT2wXHpgn77zMXCfQ5Onh1/1UbL+6ynHunpoIj6zKAekeO94H0gR8/oFzl6Rr/I0TP65Tn1jH6Ro+dI6hf5EPWMfpFnUc/u1C/y8evVCuN7FeJZ7ka9uol8W6GEeka/yPsvXy0+lCZ4ia7x1Ru5elC6xqrjCwR+P+iOn3ewBeoDtiw58Y2F51El/cqB4RZwGfEZeXZYOM+BMZ+TR1ZYwJB9ON/HU3ink6r6/Je6cpDz8epF5anXeW5bpNoSv4WD5tMzv+hIN/K8rtjvB++uq5DxkWentlW4D/uE/DlrtnGge+Ho3P2BwvldFL0/heVp4GaPf2mjn5D/72tjXmk4pYNSxi/7f7Ocjce46ub0zqJ/fRfH9ikJdV5jBp6XFUzt+zO3jfcnrk9CNlJ/4jonJJbew15RnROSRb2K65mQZOp1haieCbGjXsX1TEgj9RolqltC0Gu3qM4JQa/ieiYEvU4X1bPwHoRLvKelzLsi9f5eoV7Z9+MsehXVMzYr7xPrEzn6RL/I8V7wnpCjZ6xn5OgZvSNHz/bUO3J8H7CekeN7Yke9I0fP6B05ekbvyKXqFX2y9Y1jNh49X2HqGz1/T72/VvWbSv6jCSIL4ormBmjAv3HxupwjJojqLN40b7kZHHeN9nY1tcKAs930+RsaYDDde33hLBO4Hi5b71PMwcvdt75L674DvTc8Q97ONsGedcEhC3caoeiUX9XtDBWcKzxTGW5VgWyR0+rQaW20V0PihrKbkfJG6IuRmzM3d8JdZZB6anUTOE3an+KoUMPw6KkvPV7SQPrugCV/vWuG7b7lZekDKlil1ZlGkoxwfrbvLNvPTPA3bQumIA== 0 @@ -41,4 +47,4 @@ - \ No newline at end of file + 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 index 77f33ebd22e..70330e3a2fa 100644 --- 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 @@ -1,22 +1,26 @@ - + - + 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= - AQAAAACAAACaAAAAFwAAAA==eJxjZGRkZIACRiQ2PkCsOsoAAAbAAA0= + + AQAAAACAAACaAAAAFwAAAA==eJxjZGRkZIACRiQ2PkCsOsoAAAbAAA0= + - - AQAAAACAAADIAQAADgAAAA==eJxjZBwFwwEAAJjbAck= + + + 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== + AQAAAACAAABwDgAAcAUAAA==eJytlXtQE0ccxwlCW8ShWClMFKsiBV9Fq5RiUX7WoVKFIGVAebQVAR8UqDjYB1hAHV6KMIqOSh0eikIBddChToItOEaIEg3BjAKJSMgFOCjoCSUg8miE7J0uiWh1/8jNfi63u7/P7nxXT+9ZE0NJqt5u13g5bLZgqdKHxTCK9UiaO9cOTVPoi2ieQw4b7WQ1geeukQTunjYNF9N87DtSw/FG6eC6/of/f6L+RP971Sdq8rG+vJmuc+yJ6pNP8CSx7/Dx8CbWweU6OO5Z/PI6xnFyAs/4eiisPpzrWg/eXree//s9vj583Nf19KY+cK/4ucPnx8fRdV7fdLy3fW7e9rrw8V/Vdz0kl24OrEhrBpNQ/tW4GTLNewXkUYTVapkcyj5yLNu9VjrG9xCQ+31p08x+db4tlj4y+Y0Y46YyaLzcuKbc8wFkWB++n7ueoOf5w92XjLksBDQf4n1zO7d49RGQmTpwpGZ5O80N7OO6aqPaYfrCSofv3Otonh4Z6c0xrQdzkn3RfkX7uH041yBJvWatoHmiKr+F5SCEDJfZ7v+uUtJ8mU3ypAuXHoDhdcdphcV3aL4lxtuvP4KEdR2fevg7MesXzjdPsrsvgSVhzV8Onq7C5lVCicon5aCcT/Oi0XV0AHoi7p1ZIu4NF4zjJ+ysFYacDtgZvnWZ6RZm/AtmpdyzfxHw0wHbWcc2Smm+P9FvNff8NWhys960ncWHTt5XFvPdhPT7LtnebA5H7U1YbeEyxNSRV269fsckIfC6NnzoLGujOZ/o3ioqIkCQm3xrw2Rmf06xc0rSZO1QK5VynB0ZPrzTmRftcxPiCxRGEXlNNO8nFhsHZshg171tOX9aMefS6O7xEMlZAuL9w5Kfvs/sW2nt2nJPfh04KQLO5xQy66yfG+jY29sOD7vrhCsrmfGlRyXljU+VUIz589V4rf72755KDsOTWb/wrvI6AL3H98Eb42hfkE/a42ijaG/IF+Ij1WOekV/Eb2p8Io+II5/II+KxGp/II+IrNH6QF8SRZ+QXceQZ+UUc+UQeEUfekC/EfbV6omj/vhjXfr4p6Lt+o+Dw3nq6H1hpLVcSt0AwJaQ2NJvhT5xbbSxXtcOtT4I+O32OqdOvsE/QP3gPjIeshuYMMnUeHLHKO6bOAUV6RpYVm8nLnytUiz6fQsDR2HVLS+Nv01w/XxwUGkSA5Kz5oeZ9TP3CAptLlh03ICGG3SKtZ/LVICLL1iOcAJld5rwDTkydxiW9Vzx/r4P7PYuKamyY9f/jFbxcdEY2rn7Uxz1qzwnGI1+yryX/uXlR3yA6QjhjREHzi9lTVY9ONICunNWVp6ZcW/uAqfXj8pcrEPg0qHMZz9mnI89a07ic9TdRSgPUORs7+aRl+nM5u1STs+9iORtweUGu8Y8kTLM8o7z4CjnLGv1VQimWs+gc4nkwUc7uwnJ2Y3HQ7AJ1zpanXiFOvyRn9V5olA7f6vOu9V5Tnyet+0CB9nuNucdf9E2B9nuNAu33GgXa7zX1udfqG82L32sTn1eca7/XKNB+r1GA+16SknJk5q9imLVpTnL4VhKIar+F4TYykLaoDEydCRBtGExwCxdBdHpRIjuyFT7mhVXI3QhoqPEM/lrRCusHOKcc9NqgtarBMMP2Hiy03FHWNNgGCSMDwh1pLZAU4HF+jVkDpLgERxq61oDAyGsbz0MO3SfnfdDFJ6DCYvsZc24thESpHr9TLYFJg8fjXVxaISnqUJHl7TZ4aDH8XmpnHVTbhf7Q/fgO7H7CNu/JFILD0H5W0hck6JeZZT2MaQS3xxV3c2tISHMMMinMF8ECtv5K4yQxkPxv1hlXiSDOfbord38N/AeTdUYO 0 @@ -40,4 +44,4 @@ - \ No newline at end of file + 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 index e870dd086c1..9fc87e722cc 100644 --- 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 @@ -1,23 +1,29 @@ - + - + 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= - AQAAAACAAACkAAAAFgAAAA==eJxjZAQBBiSAxsUN0DXSDAAAB74ADg== - AQAAAACAAACkAAAAHAAAAA==eJxjZGBkYGBgBAIGKGAEcRmIBMgaaQYAB5kADg== + + AQAAAACAAACkAAAAFgAAAA==eJxjZAQBBiSAxsUN0DXSDAAAB74ADg== + + + AQAAAACAAACkAAAAHAAAAA==eJxjZGBkYGBgBAIGKGAEcRmIBMgaaQYAB5kADg== + - - AQAAAACAAAAAAgAADgAAAA==eJxjZBwFIxkAAAMeAgE= + + + 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== + AQAAAACAAABgDwAAWgUAAA==eJytl3tQVFUYwA8PaXwgI4mMQS8UKAXzOVoYn86gqQxGjpFmUyhMDqNMaSRpU4RpOKCUDGNgwK6iINtrVZqACkwE5CEs7sAuuxbL3oXdRcwNAxWBzeJ893iP7vi8/5w5v/Pd7zv3d749M0vIf48K/h+IYWQ0dNC5CpRp5ONXkgyw3tupP30Y4yzSeHG0iPGhzUOPG50bxTwyy/DoLU7tdN0ixiOPTLDvKvnMzNVh9aXvsXzSOqw+5uPrkDs+NgfcURwff7f53eLudSTEfujnPadKDMCPI6u3n5+E33JO9xUnzvlH5YA7irdwXOXAp8EBt9zFP78fm4P927jv4/fDP/f7PQ/6Pr8/Pu/9enpYH7xXvh/5+nweR338sPkedd886n3x+e/VtxZSitdHV+zrgPFxlac+9dHTdROE6WYq26sNsD08T7Zoaytg/Mj8T7puEuOldU1cPlZH+h7LJ63D6kvz83UIuaRPzouI0EBP6RLv58PrRZ5fPvXV91xuzuvrvMOGBJFXCr3vNioEKL0U5RWqN4v80GSZcp/eCjXylIaoMVqRD28JLd3+ei0063QRoQsYvya8MDY6Qw9JhcbR8fnsnh/d8nWs+qgACa0bZT/5sfMpbl5eHlmpgaQ3N6Xc8LCKXDslekFfnxVCjOu+lxWxfeoy1eV/3DDBX72a+perWP412UpV3+Ya+LZNnXZ6arfIU5wSS0+VdkPdW79dqYpgfDWNx/eQK+j7uO7rujH2S3uduJ5zPcK7XinAqumuOZ8nm0SuWpY4LTGiFo419te41bB+2p3rEzS/QoBmp4QPjrqzc7COKhv162NamJDsWbDf3CbyEKPuTNm5drh28u2XgkMYPxgdf8VTboEB/yplTCDjNq+DmzJzGmBc1Db1R1XM39ri8+0LB1phMHDUYc1sts8VxW0fPjmrG/ZGrRSygo0in/iFdVpWj3CbvzUOPGEcz3HuES5bOmkWy4NzxcyrrnvmsPMccPePO+ukE302UI/066CA+txFPSLHc8HzQI6e0S9y9Ix+kaNn9Cty6hn9IkfPa6hf5DeoZ/SLPI169qR+kd+5X21wZ68snufjqdfxEt82KKKe0S/yq2fOFu5PZl6iq6YaTEID1IyLbY7LY/x6aFeA7yIrNARvmHf4O6vI1xZdrbk22Apjh/yGnh1k37PX7pd/YKEVjOkZuX6T2T29raI/aP44ATI/WTG7OOmcyJ0LVBviNgigPjrpq46dJpHXFwac8O0+C7t2TO7Uadl5uMbnBq7cLIB+RvZzqSHs+8cq+36JPKiBC1eCFE0BbP8XV8W82HhEDwrOL//75jkfj3GV6p2dBbfUxbnr9vh6H7tR5MfzJvRfzmoT/Un7k5B11J+0zwmJpeewW9LnhKRRr9J+JiSRel0o6WdCXKhXaT8T0kS9rpX0LSHotUfS54SgV2k/E4JeJ0r6md0Hqx3cpwruXnF0/1ZTr/z9cRK9SvoZH5voE/sTOfpEv8jxXPCckKNn7Gfk6Bm9I0fPrtQ7crwfsJ+R433iQr0jR8/oHTl6Ru/IHfUr+uT7G+d8PHqu5vobPf9Ivc+TNwWm6AU4UBGt/HuZCqrd5ubqvjGD2/KWiT1yARRbd8bm9HbBO+7vX173tBlAvdjF318DMqs8OSPDDDG1Xpczj5vhh8BjxepFJnhN+0Z4UIUZuo9fmPB7ugoKyxZ09ezQwonU9DkBY5qgNvupyGBPCwxOt5SXn26BGWEl1+0xFpiVHbA0t70ZJlndn1gypROCz/vMTV16HjaqWsLanZugd3HHjLosDTzzjz7f4+b/1yM5l+zyiyr4F33vqwc= 0 @@ -41,4 +47,4 @@ - \ No newline at end of file + 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 index 8bf8e2b0202..01ca79e3e13 100644 --- 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 @@ -1,22 +1,26 @@ - + - + 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= - AQAAAACAAACZAAAAFwAAAA==eJxjZGRkZIACRiQ2PkCsOooAAAazAA0= + + AQAAAACAAACZAAAAFwAAAA==eJxjZGRkZIACRiQ2PkCsOooAAAazAA0= + - - AQAAAACAAADBAQAADgAAAA==eJxjZBwFQxoAAIxxAcI= + + + 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= + AQAAAACAAABYDgAAUwUAAA==eJytlXtQVFUcx0FBUpR0MIlAJcQ1y8AADQflp6aVD4xhQBFKgQBjgIKJChFFHREVZBAdEkwhUAhQBpzNdkXBXGmFRdxlFZZdcGHvwi4vvYPyCHm0wZ579XA3ND1/7J3zuXfP43N+8z1+Zvq9ScNC0BttQihK0NvzWWyT9qmmeIZ6eGqEvhzcIkcOcfartFxNcRfRkKliUjXF0Th6jI3UwXV9h38/UX+i7170qW1NzZQHLaD2+Xwff+Lvsf9T4+JNqIPr8qnGuFCHtyYdXD2BZ3w9JLYvnOtaD95edj//9//4+vBxX9bTq/rAveJ1h8+Pj6OrXl91vNddN697Xfj4E/s2Cebd2Gch0/YlEM/28y073gzZJGG9VqbQ8ga4Os/p6p4ND8DNTvrIJIYY4/sJyNzBls/tl0PjlcZPS33rx3iUAlJsTjRk1tHz/7bZSx19RUDNg3jfgs5A9z4C0hIGTt5d0UZxA8d9XaLv2+CdD8qXf7W5juJJ4eEerjMlMEdtXuy4sm3cOVysFyfctFFQPK43p0V/uQBS1lltfrJaSXEHVvzkwssPwPCWk2leQQ3FA6M9tveHqWFj+0dbvJ0JigsWzzls2yCGpSHNawaz/sLmVUJRr+eRxCYexfNH19EO6Im4R1qRsCeUP46ftrVRGLq2Q0RokMPMQHr8wtlszoVrBPxwbNH81G1Sih+N276Wc+kmyDfZ7PxGnwed3PVmizcJqPddsgPnXF013gSVZuuG6H1kl9p88d1kAXC7tr7lIlNRnEd0B1XnE8DPjK/aOo0+n1/NM4qOy9pAJJW6ujjRfDjChbvbswJicxVTw7LlFO8n7Ix9U2QQWbsr43drui6n3v85QHyBgFjvkPinb9LnxhZtKHXj1YGzwudSRh69TskCX6eenjZ42F0nWFVOjy89JS5tfKqEAsyfl9Zr5ZfXH5e70jxe/yfuDW47oPf4OXhgHJ0L8kl5HG0k5Q35Qnykcswz8ot4hdYn8og48ok8Ir5X6xN5RHyl1g/ygjjyjPwijjwjv4gjn8gj4sgb8oW4F6MnkvLvhXHm+iah79bt3BMHJFTft9ymSUlUAX96gCj4HM3/dmllWa5ug6oP/ZdlXaT3uT2vj98/WAvGQ9ZD7w7S+0wcsc5O1eSAIinlrLU5nZc/lvUu+Xg6Aaf2brRnx96h+KQcoX+wPwHiC3OSmw/S+xfksi5btt+GQ9HmLVIJna8GYWcXbQklQGab9t4xZ3qfxkU9JW7pddDweEn+XRa9/g73r1dUn5eN2z/q4x6Zc4L2yBMfbMl5Zl7UN9gdJrAYUVC8+Nys3ken60FXzurK05mcRY4+syTj8pfD53vWa3IZz9mnI/82+bic9TZRSn00Obt32hnLpGdy1l6bs0ZYzvpceT/T+Fs1mFqeVxa/QM7qj/4qgY3lLKpDPA8mytlILGe3Ffhb5WpytjShhMj6j5zVe66ROnxr6p3xXtPUE+M5kMB8r9H3+PO+SWC+10hgvtdIYL7XNHXP6BvNi99rE9crzpnvNRKY7zUScN+hn3PjKjwJOJMcU+/wZytcH3gYvNReBTEz+o1NGglQKPaljWSpwKCs4g9WlhDedioJSB+QgKX4yIxNxtXgETocOH+VGrhhUUqDT+rgpF2ksNBFBDsL89LWuwsh3FDgn9x9DxYeWBi0oawV3rAoBVGJCHpJx06jCCV477lmv6PmHviFPLGafV8FRicdOvvltcD6hT1lXbIKutOVR6+JVdCRyK8vX9YCaelTUjkiMRR3DHOs5t0B1q6auTHSBvCR1m4xbZCDx5oouTdPBf8A1HlAMw== 0 @@ -40,4 +44,4 @@ - \ No newline at end of file + 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 index 6519bc2434b..099c80dded1 100644 --- 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 @@ -1,10 +1,14 @@ - + - - AQAAAACAAAAbAAAAEgAAAA==eJxjYGBgZGRkAAM0BgAAmQAK - AQAAAACAAAAbAAAAEgAAAA==eJxjYGRgACIGMInKAAAAeAAH + + + AQAAAACAAAAbAAAAEgAAAA==eJxjYGBgZGRkAAM0BgAAmQAK + + + AQAAAACAAAAbAAAAEgAAAA==eJxjYGRgACIGMInKAAAAeAAH + @@ -34,4 +38,4 @@ - \ No newline at end of file + 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 index f0cba8a57e1..aa8ef4e1f49 100644 --- 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 @@ -1,23 +1,29 @@ - + - - - - AQAAAACAAABgBQAALgEAAA==eJwtxdciEAAAAEBCRogGTRKKlJZo01CZlRRFKJVRaSAhRWgRpUEqilLqJz24e7mAgEWBXuIgBzvESx3qMIc7wssc6ShHe7ljHOsVXulVXu04x3uN13qd13uDNzrBid7kJG92slOc6i3e6jSne5szvN07nOmd3uXd3uO9zvI+ZzvH+33AB33Ih33ER53rPB/zcZ/wSef7lE/7jAtc6CIXu8SlPutzPu8yX3C5L/qSK1zpy77iKlf7qmtc6zpf83XX+4Zv+pYb3OgmN/u27/iuW3zP9/3AD93qNrf7kTv82J3ucrefuMdP/cy97vNz93vAg37hl37l137jIQ/7rUc86nd+7zF/8Ed/8mePe8JfPOmv/ubvnvK0f/inZzzrX/7tOf/xX8/7n/97AZDZOXM= + + + + AQAAAACAAAAQAQAARQAAAA==eJwtxUkCQgAAAECEypole+j/n3Qwc5kguIWO/HDsxKmffvntzLkLl65c++PGrTv3/nrw6MmzF6/e/PPuw6f/vgDNmAIy + + + AQAAAACAAAAiAAAAFgAAAA==eJxjYGRkYABhIMkApqAknAUAANwACQ== + + + AQAAAACAAAAiAAAAEgAAAA==eJxjZGRkZEACKBwwAAAAtgAG - AQAAAACAAACsAAAAKQAAAA==eJxjYGRkYABhIMkAohghHBgNEYQCGJMRpggTMDLikcQJiNMFAA5rACA= - AQAAAACAAACsAAAAGAAAAA==eJxjZGRkZEACjFDAQCQgTTVlAAAKkwAT - - AQAAAACAAAAjAgAADwAAAA==eJxjZBwFowAvAABLtwIk - - 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 + + + AQAAAACAAABUAQAAEAAAAA==eJxjZGBgYBzFVMUAOnAAVg== + + + AQAAAACAAACoAgAAmgAAAA==eJwtxUkiAgAAAMBeUkKKtJCyVBKyFUqJaBMiS+j/hw5mLhMM/At5wWEvesnLjnjFUce86jXHve6Ek0457Q1vOuMtZ53ztne86z3nXXDR+y75wGUf+sjHrvjEpz7zuS9cdc2XvvK16274xk23fOu273zvjh/86K577nvgoZ888rNf/Oqx3/zuiT/86S9/e+of//rPM88B5M8X6Q== - AQAAAACAAAAgEAAACQYAAA==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 + AQAAAACAAAAwAwAAiwAAAA==eJyNkEsOgCAMROvJ8EJ6PM+BaxcSTYzLnsAfAsaRCU5ISKfltVTkkjOSVfQxj76SOiVc9JGD/l8p4bCY3ThPiVv6N3sfVE/Bt4RnTfXyLdya4t1rvOs/XPvhvmPsu6a+Q9ecZzbRj31bn+hD3VLYI+OI5DlRCvWOxOjjfpTs+ZljC/vLc0QOT0xwdw== 0 @@ -29,16 +35,16 @@ - - AQAAAACAAABgRAAAdQsAAA==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 + + AQAAAACAAACgCgAAmAEAAA==eJx1lttWwkAMRWdaLQUUKLUWS7n9/0/6YPaDe6305azMyeUkEwdr+fuawDHwFNgFvgcO8nsL3Iifyv+vVV74QedfiY5B/CS031l5XMc8eWuSbyM/6nbys35sPveP7fmjj7zMeRJ/1jn5mLfvi3skDv1Vfuh2X8yhk13kZ53W3wrp3/eDriKeOuRFp/trdO75er/hvwP3gZ+Bt8BVfj+B28Be5zvFfQTO8uvlvxW/KJ76o/wuyflVcZnfLN764MmX6fRcXL+XnenH5j6pv5NN/JrYnh962APf/0W2/46oy554PxbZ8OwT++366PL+ei6d/Jmz9XvO5EO357kKPTf0u3/00ucim36JJ/+c+Lu+7/kqnrlU8aP8vOeOh0dHI78qfpEfeV0X3u+t8xPP+8jH+/dUHr+f6PL79RB/CDwq70NI3pf8TvKDv4m/J/Xv8oMn/0t8EU9/xJHP/bm+9cO34q3P++1+mHM2hyr+KZt83Af1/P8Tuojz/RJ/0DlxeyHn7s+/e9ZfdO49QTf50fNUvOeB/l+MQxgM - - 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= + + AQAAAACAAACoAgAAtgAAAA==eJwtxRF0AgEAANB6LwiCIDg4CIIgCILg4OAgCIIgGATBYBAMBkEQBIPBYBAEQRAEQRAEg8EgCIJgEARBMAgGg/6Xn0ndZZ1z3gUHDl10yWVXXHXNdUeOnbjhpltuu+MHd93zo5/c97NfPPDQI4/96je/+8MTTz3z3AsvvfLaG2/96S9/e+e9Dz76xyefffHVv775z6n0vYyzzjnvggOHLrrksiuuuua6I8dO3HDTLbf9D+ZfIzM= - AQAAAACAAAAjAgAADwAAAA==eJzj4hoFowAvAADiCRVf + AQAAAACAAABVAAAADAAAAA==eJzj4qIBAACPGwNT - \ No newline at end of file + 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 index 26203ec6a86..70db4d5ae31 100644 --- 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 @@ -1,11 +1,17 @@ - + - - AQAAAACAAAAbAAAAEAAAAA==eJxjYGBgYAQjDAYAAGYABw== - AQAAAACAAAAbAAAAEQAAAA==eJxjYGBgZGSAADQGAAByAAc= - AQAAAACAAAAbAAAAEgAAAA==eJxjYGRgACIGMInKAAAAeAAH + + + AQAAAACAAAAbAAAAEAAAAA==eJxjYGBgYAQjDAYAAGYABw== + + + AQAAAACAAAAbAAAAEQAAAA==eJxjYGBgZGSAADQGAAByAAc= + + + AQAAAACAAAAbAAAAEgAAAA==eJxjYGRgACIGMInKAAAAeAAH + @@ -35,4 +41,4 @@ - \ No newline at end of file + 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 index 4ded1a6bec8..75dd7f06223 100644 --- 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 @@ -1,24 +1,32 @@ - + - - - - AQAAAACAAABgBQAALgEAAA==eJwtxdciEAAAAEBCRogGTRKKlJZo01CZlRRFKJVRaSAhRWgRpUEqilLqJz24e7mAgEWBXuIgBzvESx3qMIc7wssc6ShHe7ljHOsVXulVXu04x3uN13qd13uDNzrBid7kJG92slOc6i3e6jSne5szvN07nOmd3uXd3uO9zvI+ZzvH+33AB33Ih33ER53rPB/zcZ/wSef7lE/7jAtc6CIXu8SlPutzPu8yX3C5L/qSK1zpy77iKlf7qmtc6zpf83XX+4Zv+pYb3OgmN/u27/iuW3zP9/3AD93qNrf7kTv82J3ucrefuMdP/cy97vNz93vAg37hl37l137jIQ/7rUc86nd+7zF/8Ed/8mePe8JfPOmv/ubvnvK0f/inZzzrX/7tOf/xX8/7n/97AZDZOXM= - - AQAAAACAAACsAAAAHwAAAA==eJxjYGBgYARCIAkicAGgEkZMBYwwgEcnFQEACYsAEw== - AQAAAACAAACsAAAAIAAAAA==eJxjYGRkAEE4YGQEcxgZkAVxAKhaMAPOph0AAAnhABM= - AQAAAACAAACsAAAAIAAAAA==eJxjYGBgYAQCBnTACELYJJDVoEozMmI1iWoAAAmLABM= + + + + AQAAAACAAAAQAQAARQAAAA==eJwtxUkCQgAAAECEypole+j/n3Qwc5kguIWO/HDsxKmffvntzLkLl65c++PGrTv3/nrw6MmzF6/e/PPuw6f/vgDNmAIy + + + AQAAAACAAAAiAAAAFQAAAA==eJxjYGBgYARCIAkiwCxUAAAAnQAG + + + AQAAAACAAAAiAAAAEgAAAA==eJxjYGRkAEE4QGJCAAAArgAG + + + AQAAAACAAAAiAAAAFAAAAA==eJxjYGBgYAQCBjhAYoIBAACkAAY= + - - AQAAAACAAAAdAgAADwAAAA==eJxjZBwFowAHAAA+7gIe - - 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 + + + AQAAAACAAABUAQAAEAAAAA==eJxjZGBgYBzFVMUAOnAAVg== + + + AQAAAACAAACoAgAAmgAAAA==eJwtxUkiAgAAAMBeUkKKtJCyVBKyFUqJaBMiS+j/hw5mLhMM/At5wWEvesnLjnjFUce86jXHve6Ek0457Q1vOuMtZ53ztne86z3nXXDR+y75wGUf+sjHrvjEpz7zuS9cdc2XvvK16274xk23fOu273zvjh/86K577nvgoZ888rNf/Oqx3/zuiT/86S9/e+of//rPM88B5M8X6Q== - 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== + AQAAAACAAAAwAwAAigAAAA==eJyFkjsOgCAQRNe7cA9s8XiejNZKY6FbcgI1KkiYMLIN7O/NkCBSi2DLfLH/9VakOeTgPtax39ILxGfrPajL9tnZmmM+0I+CD1/m/fqdXewf5x0zcH3sI8eDL6zn/XSr85XwlfAD+MT5zB1G40YzfXuvzmbdU9+Br4TP/pGSd6GuSF1X5AKJeHp+ 0 @@ -30,16 +38,16 @@ - - AQAAAACAAACgQwAALwsAAA==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 + + AQAAAACAAACgCgAAlQEAAA==eJx1lcF2glAMRC0qCKjFJ9VWEeH/f7KL5i56zwmbnLyZJJPhofXm79lFvEQsET8iVsKvm//PVue3iPuIjc5LklM/RvxK8FuCW192PioHp18lfCuc+aNy5u2FW0fmN/3riPhvnZk/6LDffl/enz7sWSn33o146LWP5OzB3J3yonP847Hf4Jlv6GM/5vPQp414iHiP+CM93m+I2EfsVAeOP8yn3nM4/xZ+EQ980Dm8R4I/xLvr3N+39bXig2d6va914We2D35S1wuHb528R/r6fXHOe2Vv5rCn93N/9LGH/bNueINw85jPPPto/Z1y+0nu+01f31/qXhH9+8339o7IXk/pKAk+iHfUvHPEWfGkuZ+qB2cOde63qJ65k/TBX8UzTp33m3UO7yic/plO5lI3iQee9cFn66PPIr79te/2l3tj/16K/r1EL/eEvtw35i3K4XMfuV/0ZQ79/X14/0k838deuX3OdOMbOr0H/vp7cb9FuP/f4Nsv3yO/P8+rxS/KfX/8e/YUfxa+Cve8VXzqfwHPZRgE - - AQAAAACAAADoEAAAAAMAAA==eJw11xGDAgYAQOHb1rYgCIIgCIIgCIIgCIIgCIIgCIIgCIIgCIIgODgIgiAIgiAIgiAIgiAIgiAIgiAIgsF9e/L9hhf4+i3IEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvssMse+xxwyBG/+cMxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3P/z645cAgwwxzAijjDHOBJNMMc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAYcc8Zs/HHPCKWecc8ElV1xzwy133PPAI08888Irb7zzwSdffPPDrz9/CTDIEMOMMMoY40wwyRTTzDDLHPMssMgSy6ywyhrrbLDJFtvssMse+xxwyBG/+cMxJ5xyxjkXXHLFNTfccsc9DzzyxDMvvPLGOx988sU3P/z665cAgwwxzAijjDHOBJNMMc0Ms8wxzwKLLLHMCqussc4Gm2yxzQ677LHPAYcc8Zs/HHPCKWecc8ElV1xzwy133PPAI08888Irb7zzwSdffPPDrwAYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdthlj30OOOSI3/zhmBNOOeOcCy654pobbrnjngceeeKZF155450PPvnimx9+/f1LgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaHXfbY54BDjvjNH4454ZQzzrngkiuuueGWO+554JEnnnnhlTfe+eCTL7754dc/vwQYZIhhRhhljHEmmGSKaWaYZY55FlhkiWVWWGWNdTbYZIttdthlj30OOOSI3/zhmBNOOeOcCy654pobbrnjngceeeKZF155450PPvnimx9+/ftLgEGGGGaEUcYYZ4JJpphmhlnmmGeBRZZYZoVV1lhng0222GaHXfbY54BDjvjNH4454ZQzzrngkiuuueGWO+554JEnnnnhlTfe+eCTL7754f/DH2CQIYYZYZQxxplgkimmmWGWOeZZYJEllllhlTXW2WCTLbbZ4X+84QrM + + AQAAAACAAACoAgAAtgAAAA==eJwtxRF0AgEAANB6LwiCIDg4CIIgCILg4OAgCIIgGATBYBAMBkEQBIPBYBAEQRAEQRAEg8EgCIJgEARBMAgGg/6Xn0ndZZ1z3gUHDl10yWVXXHXNdUeOnbjhpltuu+MHd93zo5/c97NfPPDQI4/96je/+8MTTz3z3AsvvfLaG2/96S9/e+e9Dz76xyefffHVv775z6n0vYyzzjnvggOHLrrksiuuuua6I8dO3HDTLbf9D+ZfIzM= - AQAAAACAAAAdAgAADwAAAA==eJzj4hoFowAHAABiZRUj + AQAAAACAAABVAAAADAAAAA==eJzj4qIBAACPGwNT - \ No newline at end of file + diff --git a/src/coreComponents/integrationTests/meshTests/testSurfaceGenerator_mpi.cpp b/src/coreComponents/integrationTests/meshTests/testSurfaceGenerator_mpi.cpp index 6b89ca4d741..b66b1e7b14a 100644 --- a/src/coreComponents/integrationTests/meshTests/testSurfaceGenerator_mpi.cpp +++ b/src/coreComponents/integrationTests/meshTests/testSurfaceGenerator_mpi.cpp @@ -58,11 +58,11 @@ std::string g_testBinaryDir; * 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 >; +using SurfaceGenerator_mpiPartitions = int; class SurfaceGenerator_mpiTest : public ::testing::TestWithParam< - std::tuple< SurfaceGenerator_mpiMeshTuple, SurfaceGenerator_mpiPartitionTuple > > + std::tuple< SurfaceGenerator_mpiMeshTuple, SurfaceGenerator_mpiPartitions > > { protected: void SetUp() override @@ -143,7 +143,7 @@ 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 ); + SurfaceGenerator_mpiPartitions const & partitions = std::get< 1 >( params ); std::string const & testCaseName = std::get< 0 >( meshParams ); std::string const & meshFileName = std::get< 1 >( meshParams ); @@ -153,29 +153,19 @@ TEST_P( SurfaceGenerator_mpiTest, TopologyValidation ) 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 ) + if( MpiWrapper::commSize( MPI_COMM_GEOS ) != partitions ) { - GTEST_SKIP() << "Skipping MPI test expecting " << requiredRanks + GTEST_SKIP() << "Skipping MPI test expecting " << partitions << " 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"; + std::string const xmlPath = testBinaryDir + "/test_surface_gen_mpi_" + testCaseName + ".xml"; if( MpiWrapper::commRank( MPI_COMM_GEOS ) == 0 ) { std::ofstream ofs( xmlPath ); @@ -186,9 +176,9 @@ TEST_P( SurfaceGenerator_mpiTest, TopologyValidation ) 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->xPartitionsOverride = partitions; + options->yPartitionsOverride = 0; + options->zPartitionsOverride = 0; options->overridePartitionNumbers = true; // Scoped state to ensure GeosxState is fully destroyed before the next @@ -197,8 +187,7 @@ TEST_P( SurfaceGenerator_mpiTest, TopologyValidation ) 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; + << meshFileName << "' with partitioning " << partitions; state.applyInitialConditions(); // ------------------------------------------------------------------ @@ -248,7 +237,7 @@ TEST_P( SurfaceGenerator_mpiTest, TopologyValidation ) GEOS_LOG_RANK_0( "========================================" ); GEOS_LOG_RANK_0( "Test (MPI): " << testCaseName - << " [" << xPartitions << "x" << yPartitions << "x" << zPartitions << "]" ); + << " [" << partitions << "]" ); 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 ); @@ -407,82 +396,53 @@ INSTANTIATE_TEST_SUITE_P( "{ 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 + // flat · full-span · hex · DFN_123 nodes: 91 elems: 48 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 ) ), + 1, 8, localIndex( 91 ), localIndex( 48 ) ), // 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 + // T-shaped · boundary-cutting · tet nodes: 13 elems: 12 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 ) ), + 1, 3, localIndex( 13 ), localIndex( 12 ) ), // ----------------------------------------------------------------------- // 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 + // Y-shaped · boundary-cutting · tet nodes: 13 elems: 12 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 ) ), + 1, 3, localIndex( 13 ), localIndex( 12 ) ) // 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 ) ), +// 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 ) ) +// 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 ) - ) + ::testing::Values( 4 ) ) ); diff --git a/src/coreComponents/mesh/generators/MeshGeneratorBase.cpp b/src/coreComponents/mesh/generators/MeshGeneratorBase.cpp index e75a677ef60..5cb6a6516dc 100644 --- a/src/coreComponents/mesh/generators/MeshGeneratorBase.cpp +++ b/src/coreComponents/mesh/generators/MeshGeneratorBase.cpp @@ -284,17 +284,22 @@ integer computeEulerCharacteristic( NodeManager const & nodeManager, ++ownedV; } + // --- Strict Edge Ownership --- localIndex ownedE = 0; for( EdgeKey const & e : allEdges ) { - if( nodeIsOwned( e.first ) ) // e.first is the min global ID (sorted) + // e.first is the minimum global node ID for the edge because makeEdge() sorted the pair + if( nodeIsOwned( e.first ) ) + { ++ownedE; + } } localIndex ownedF = 0; for( FaceKey const & f : allFaces ) { - if( nodeIsOwned( f[0] ) ) // f[0] is the min global ID (sorted) + // f ([0] is the minimum global node ID for the face because makeFace() sorts the node list + if( nodeIsOwned( f[0] ) ) ++ownedF; } From 137426146be73382746726954ee5debca5dbbce6 Mon Sep 17 00:00:00 2001 From: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> Date: Thu, 14 May 2026 15:02:09 -0500 Subject: [PATCH 32/53] fix: Avoid overflow in event check (#4048) * Fix event check * Update src/coreComponents/events/EventBase.cpp * Use std::clamp --------- Co-authored-by: Jacques Franc <49998870+jafranc@users.noreply.github.com> --- src/coreComponents/events/EventBase.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/coreComponents/events/EventBase.cpp b/src/coreComponents/events/EventBase.cpp index 9575dfe318d..0b850371750 100644 --- a/src/coreComponents/events/EventBase.cpp +++ b/src/coreComponents/events/EventBase.cpp @@ -183,7 +183,10 @@ void EventBase::checkEvents( real64 const time, } else { - this->setForecast( int( ( m_beginTime - time ) / dt ) ); + real64 constexpr min_ratio = static_cast< real64 >(LvArray::NumericLimits< integer >::min); + real64 constexpr max_ratio = static_cast< real64 >(LvArray::NumericLimits< integer >::max); + + this->setForecast( static_cast< integer >(std::clamp(( m_beginTime - time ) / dt, min_ratio, max_ratio )) ); } } else if( time >= m_endTime ) From 14f2c52b70f2e9776477147ac01b2b4f16a50345 Mon Sep 17 00:00:00 2001 From: Jacques Franc <49998870+jafranc@users.noreply.github.com> Date: Fri, 15 May 2026 16:46:52 +0200 Subject: [PATCH 33/53] fix: Fault Perm Update for Contact solvers (#3999) * draft/ enable disp update in SEQ ALM * throw error if not one of the model * update slip calculation for ALM * reset bubble displacement after initialization * add ExponentialDecayPermeability model * add a check for totalBubbleDisplacement * missing include * more reset * refactor: Change nodeset import from Int64 to unsigned integer (#4018) * Refactored importNodesets * Update dfn_market meshes * Uncrustify * Replace bitwise AND with equality check * some comments clean up + robustness * add a missing placeholder * uncrustify * fix compilation error * add conditional check to contact solver fields * allow constant permeability model * Update src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.cpp Co-authored-by: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> * revert a change * Update baseline for integrated tests * Update BASELINE_NOTES.md * address review comment --------- Co-authored-by: Jian HUANG Co-authored-by: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> Co-authored-by: Jian Huang <53012159+jhuang2601@users.noreply.github.com> Co-authored-by: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 9 +++ .../constitutive/solid/CoupledSolid.hpp | 4 ++ .../fluidFlow/FlowSolverBase.cpp | 64 ++++++++++++++++++- .../SolidMechanicsStateReset.cpp | 18 ++++++ ...lidMechanicsAugmentedLagrangianContact.cpp | 61 ++++++++++-------- 6 files changed, 129 insertions(+), 29 deletions(-) diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index b421a007a64..e02fa93ce73 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr4029-16507-7e3d8b5 + baseline: integratedTests/baseline_integratedTests-pr3999-16602-542583d allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index 5617896e12c..c6d8989ec23 100644 --- a/BASELINE_NOTES.md +++ b/BASELINE_NOTES.md @@ -5,10 +5,16 @@ This file is designed to track changes to the integrated test baselines. Any developer who updates the baseline ID in the .integrated_tests.yaml file is expected to create an entry in this file with the pull request number, date, and their justification for rebaselining. These notes should be in reverse-chronological order, and use the following time format: (YYYY-MM-DD). +PR #3999 (2026-05-14) +===================== +Fault Perm Update for Contact solvers + PR #4029 (2026-05-06) +===================== Add single phase viscosity dependency on temperature PR #3959 (2026-05-04) +===================== Add reference thermal conductivity PR #4021 (2026-04-14) @@ -16,6 +22,7 @@ PR #4021 (2026-04-14) +===================== Move PVT Driver tests from unit tests to integrated tests PR #4007 (2026-04-03) @@ -23,9 +30,11 @@ PR #4007 (2026-04-03) +===================== Add checkEulerCharacteristic option, rebaseline due to new input. PR #3967 (2026-03-27) +===================== Fix 2D/3D cell co-location in parallel mesh redistribution PR #3986 (2026-02-27) diff --git a/src/coreComponents/constitutive/solid/CoupledSolid.hpp b/src/coreComponents/constitutive/solid/CoupledSolid.hpp index ddab1b97a19..da74fb42ce8 100644 --- a/src/coreComponents/constitutive/solid/CoupledSolid.hpp +++ b/src/coreComponents/constitutive/solid/CoupledSolid.hpp @@ -160,8 +160,12 @@ class CoupledSolid : public CoupledSolidBase getPermModel() ); } +public: + typedef PERM_TYPE PermType; + //START_SPHINX_INCLUDE_01 protected: + SOLID_TYPE const & getSolidModel() const { return this->getParent().template getGroup< SOLID_TYPE >( m_solidModelName ); } diff --git a/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.cpp b/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.cpp index bf63134e49d..c98270ee548 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.cpp @@ -33,6 +33,13 @@ #include "mesh/DomainPartition.hpp" #include "physicsSolvers/LogLevelsInfo.hpp" #include "physicsSolvers/fluidFlow/FlowSolverBaseFields.hpp" + +#include "physicsSolvers/solidMechanics/contact/ContactFields.hpp" +#include "constitutive/permeability/ExponentialDecayPermeability.hpp" +#include "constitutive/permeability/ParallelPlatesPermeability.hpp" +#include "constitutive/permeability/SlipDependentPermeability.hpp" +#include "constitutive/permeability/WillisRichardsPermeability.hpp" + #include "physicsSolvers/fluidFlow/kernels/MinPoreVolumeMaxPorosityKernel.hpp" #include "physicsSolvers/fluidFlow/kernels/StencilWeightsUpdateKernel.hpp" @@ -104,6 +111,35 @@ void updatePorosityAndPermeabilityFromPressureAndAperture( POROUSWRAPPER_TYPE po } ); } +template< typename POROUSWRAPPER_TYPE > +void updatePorosityAndPermeabilityFromPressureApertureJumpAndTraction( POROUSWRAPPER_TYPE porousWrapper, + SurfaceElementSubRegion & subRegion, + arrayView1d< real64 const > const & pressure, + arrayView1d< real64 const > const & oldHydraulicAperture, + arrayView1d< real64 const > const & newHydraulicAperture, + arrayView1d< real64 const > const & dHydraulicAperture_dNormalJump, + arrayView2d< real64 const > const & dispJump, + arrayView2d< real64 const > const & fracTraction ) +{ + forAll< parallelDevicePolicy<> >( subRegion.size(), [=] GEOS_DEVICE ( localIndex const k ) + { + for( localIndex q = 0; q < porousWrapper.numGauss(); ++q ) + { + real64 const jump[3] = LVARRAY_TENSOROPS_INIT_LOCAL_3 ( dispJump[k] ); + real64 const traction[3] = LVARRAY_TENSOROPS_INIT_LOCAL_3 ( fracTraction[k] ); + porousWrapper.updateStateFromPressureApertureJumpAndTraction( k, q, + pressure[k], + oldHydraulicAperture[k], + newHydraulicAperture[k], + dHydraulicAperture_dNormalJump[k], + jump, + traction + ); + } + } ); + +} + FlowSolverBase::FlowSolverBase( string const & name, Group * const parent ): PhysicsSolverBase( name, parent ), @@ -649,7 +685,33 @@ void FlowSolverBase::updatePorosityAndPermeability( SurfaceElementSubRegion & su constitutive::ConstitutivePassThru< CompressibleSolidBase >::execute( porousSolid, [=, &subRegion] ( auto & castedPorousSolid ) { typename TYPEOFREF( castedPorousSolid ) ::KernelWrapper porousWrapper = castedPorousSolid.createKernelUpdates(); - updatePorosityAndPermeabilityFromPressureAndAperture( porousWrapper, subRegion, pressure, oldHydraulicAperture, newHydraulicAperture ); + + if constexpr (std::is_same_v< typename TYPEOFREF( castedPorousSolid ) ::PermType, constitutive::ParallelPlatesPermeability >) { + updatePorosityAndPermeabilityFromPressureAndAperture( porousWrapper, subRegion, pressure, oldHydraulicAperture, newHydraulicAperture ); + } + else if constexpr ( std::is_same_v< typename TYPEOFREF( castedPorousSolid ) ::PermType, constitutive::SlipDependentPermeability > || + std::is_same_v< typename TYPEOFREF( castedPorousSolid ) ::PermType, constitutive::WillisRichardsPermeability > || + std::is_same_v< typename TYPEOFREF( castedPorousSolid ) ::PermType, constitutive::ExponentialDecayPermeability > ) + { + if( subRegion.hasField< fields::contact::dispJump >() && subRegion.hasField< fields::contact::traction >() ) + { + arrayView2d< real64 const > const dispJump = subRegion.getField< fields::contact::dispJump >(); + arrayView2d< real64 const > const fractureTraction = subRegion.getField< fields::contact::traction >(); + /*dHydraulicAperture_dNormalJump dummy entry*/ + arrayView1d< real64 const > const unusedDeriv = subRegion.getField< flow::aperture0 >(); + updatePorosityAndPermeabilityFromPressureApertureJumpAndTraction( porousWrapper, + subRegion, pressure, oldHydraulicAperture, newHydraulicAperture, unusedDeriv, + dispJump, fractureTraction ); + } + else + { + updatePorosityAndPermeabilityFromPressureAndAperture( porousWrapper, subRegion, pressure, oldHydraulicAperture, newHydraulicAperture ); + } + } + else + { + updatePorosityAndPermeabilityFromPressureAndAperture( porousWrapper, subRegion, pressure, oldHydraulicAperture, newHydraulicAperture ); + } } ); } diff --git a/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsStateReset.cpp b/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsStateReset.cpp index 51086bdc70c..a67fabbf24b 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsStateReset.cpp +++ b/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsStateReset.cpp @@ -20,6 +20,7 @@ #include "SolidMechanicsStateReset.hpp" #include "physicsSolvers/PhysicsSolverManager.hpp" +#include "physicsSolvers/solidMechanics/contact/ContactFields.hpp" #include "physicsSolvers/solidMechanics/SolidMechanicsLagrangianFEM.hpp" #include "physicsSolvers/LogLevelsInfo.hpp" #include "mesh/DomainPartition.hpp" @@ -107,6 +108,23 @@ bool SolidMechanicsStateReset::execute( real64 const time_n, subRegion.getField< solidMechanics::averagePlasticStrain >().zero(); } ); + + elemManager.forElementSubRegions< SurfaceElementSubRegion >( regionNames, + [&]( localIndex const, + ElementSubRegionBase & subRegion ) + { + subRegion.getField< contact::dispJump >().zero(); + subRegion.getField< contact::slip >().zero(); + } ); + + + FaceManager & faceManager = mesh.getFaceManager(); + if( faceManager.hasField< contact::totalBubbleDisplacement >() ) + { + faceManager.getField< contact::totalBubbleDisplacement >().zero(); + faceManager.getField< contact::incrementalBubbleDisplacement >().zero(); + } + } // Option 2: enable / disable inelastic behavior diff --git a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp index ce0081a82cd..8dd1d59330e 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp +++ b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp @@ -802,43 +802,50 @@ void SolidMechanicsAugmentedLagrangianContact::implicitStepComplete( real64 cons SolidMechanicsLagrangianFEM::implicitStepComplete( time_n, dt, domain ); - forFractureRegionOnMeshTargets( domain.getMeshBodies(), [&] ( SurfaceElementRegion & fractureRegion ) + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & ) { - 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 >(); + //fractureRegion.forElementSubRegions< FaceElementSubRegion >( [&]( FaceElementSubRegion & subRegion ) + //{ - arrayView2d< real64 > const traction = subRegion.getField< contact::traction >(); + ElementRegionManager & elemManager = mesh.getElemManager(); + SurfaceElementRegion & region = elemManager.getRegion< SurfaceElementRegion >( getUniqueFractureRegionName() ); + FaceElementSubRegion & subRegion = region.getUniqueSubRegion< FaceElementSubRegion >(); - arrayView1d< integer const > const fractureState = subRegion.getField< contact::fractureState >(); - arrayView1d< integer > const oldFractureState = subRegion.getField< contact::oldFractureState >(); + 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 >(); - arrayView1d< real64 > const slip = subRegion.getField< contact::slip >(); - arrayView1d< real64 > const tangentialTraction = subRegion.getField< contact::tangentialTraction >(); + arrayView2d< real64 > const traction = subRegion.getField< contact::traction >(); - forAll< parallelDevicePolicy<> >( subRegion.size(), - [ = ] - GEOS_DEVICE ( localIndex const kfe ) - { - // Compute the slip - real64 const deltaDisp[2] = { deltaDispJump[kfe][1], - deltaDispJump[kfe][2] }; - slip[kfe] = LvArray::tensorOps::l2Norm< 2 >( deltaDisp ); + 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 >(); + + forAll< parallelDevicePolicy<> >( subRegion.size(), + [ = ] + GEOS_DEVICE ( localIndex const kfe ) + { + // Compute the slip + real64 const shearDisp[2] = { dispJump[kfe][1], + dispJump[kfe][2] }; + slip[kfe] = LvArray::tensorOps::l2Norm< 2 >( shearDisp ); - // 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]; - } ); } ); } ); + // } ); } From 01a4f15b2ebffae0a7895c4347dc873116be1391 Mon Sep 17 00:00:00 2001 From: Jacques Franc <49998870+jafranc@users.noreply.github.com> Date: Sat, 16 May 2026 02:12:44 +0200 Subject: [PATCH 34/53] feat: Change to local Newell's normal (#3977) * try local newell * Local Newell / debug * clean up * some more warning * discard unused and style * std::sqrt->LvArray * fix constness in test * style * epsiloning Surface Gen to avoid zero div w/ new normals * rebaseline * fix repeated entry in test * ERRROR>WARNING and cleanup * Update baseline entry for PR #3977 Updated the link for PR #3977 to the new baseline tar.gz file. * Update baseline path in integrated tests configuration --------- Co-authored-by: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> Co-authored-by: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> Co-authored-by: Jian Huang <53012159+jhuang2601@users.noreply.github.com> --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 4 +- .../unitTests/testComputationalGeometry.cpp | 53 +++++++++++++++++++ .../mesh/utilities/ComputationalGeometry.hpp | 24 +++++++-- .../surfaceGeneration/SurfaceGenerator.cpp | 2 +- 5 files changed, 77 insertions(+), 8 deletions(-) diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index e02fa93ce73..439f8b2e2b0 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr3999-16602-542583d + baseline: integratedTests/baseline_integratedTests-pr3977-16644-9fc03e7 allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index c6d8989ec23..6e4f040c298 100644 --- a/BASELINE_NOTES.md +++ b/BASELINE_NOTES.md @@ -5,8 +5,10 @@ This file is designed to track changes to the integrated test baselines. Any developer who updates the baseline ID in the .integrated_tests.yaml file is expected to create an entry in this file with the pull request number, date, and their justification for rebaselining. These notes should be in reverse-chronological order, and use the following time format: (YYYY-MM-DD). +PR #3977 (2026-05-15) +Change face normal, centers and area for local Newell's formula + PR #3999 (2026-05-14) -===================== Fault Perm Update for Contact solvers PR #4029 (2026-05-06) diff --git a/src/coreComponents/mesh/unitTests/testComputationalGeometry.cpp b/src/coreComponents/mesh/unitTests/testComputationalGeometry.cpp index 403d5f25483..39f0588fb8f 100644 --- a/src/coreComponents/mesh/unitTests/testComputationalGeometry.cpp +++ b/src/coreComponents/mesh/unitTests/testComputationalGeometry.cpp @@ -17,6 +17,7 @@ * @file testComputationalGeometry.cpp */ #include "../utilities/ComputationalGeometry.hpp" +#include #include #include @@ -70,4 +71,56 @@ TEST( testComputationalGeometry, checkCentroid3DPolygon ) } } +TEST( testComputationalGeometry, checkHighAspectRatio ) +{ + constexpr localIndex numNodes = 3; + + array2d< real64, nodes::REFERENCE_POSITION_PERM > points; + points.resize( numNodes, 3 ); + array1d< localIndex > indices( 3 ); + indices( 0 ) = 0; + indices( 1 ) = 1; + indices( 2 ) = 2; + + //mimic a perfect triangle but with huge offset + constexpr real64 xa = 1.e4, ya = 1.e-2, za = 1.e0; + constexpr real64 xb = 1.e-1, yb = 1.e2, zb = -1.e-2; + constexpr real64 TOL = 1e-6; + + points( 0, 0 ) = 1.e6; + points( 0, 1 ) = 1.e6; + points( 0, 2 ) = 1.e6; + + points( 1, 0 ) = 1.e6 + xa; + points( 1, 1 ) = 1.e6 + ya; + points( 1, 2 ) = 1.e6 + za; + + points( 2, 0 ) = 1.e6 + xb; + points( 2, 1 ) = 1.e6 + yb; + points( 2, 2 ) = 1.e6 + zb; + + real64 faceCenter[ 3 ], faceNormal[ 3 ]; + auto faceArea = computationalGeometry::centroid_3DPolygon( indices.toSliceConst(), points.toViewConst(), faceCenter, faceNormal, TOL ); + + const real64 EXPECTED_AREA = 0.5*LvArray::math::sqrt( LvArray::math::square( xa*yb-ya*xb ) + + LvArray::math::square( ya*zb-za*yb ) + + LvArray::math::square( za*xb-xa*zb ) ); + + const real64 EXPECTED_CENTER[3] = { 1.e6 + (xa+xb)/3, 1.e6 + (ya+yb)/3., 1.e6 + (za+zb)/3}; + + const real64 EXPECTED_NORMAL[3] = { (ya*zb-za*yb)/2/EXPECTED_AREA, (za*xb-xa*zb)/2/EXPECTED_AREA, (xa*yb-ya*xb)/2/EXPECTED_AREA}; + + EXPECT_LT( abs( faceArea - EXPECTED_AREA ), 1e-6 ); + EXPECT_LT( abs( faceNormal[0]-EXPECTED_NORMAL[0] ), 1e-6 ); + EXPECT_LT( abs( faceNormal[1]-EXPECTED_NORMAL[1] ), 1e-6 ); + EXPECT_LT( abs( faceNormal[2]-EXPECTED_NORMAL[2] ), 1e-6 ); + EXPECT_LT( abs( faceCenter[0]-EXPECTED_CENTER[0] ), 1e-6 ); + EXPECT_LT( abs( faceCenter[1]-EXPECTED_CENTER[1] ), 1e-6 ); + EXPECT_LT( abs( faceCenter[2]-EXPECTED_CENTER[2] ), 1e-6 ); + + real64 norm = LvArray::math::square( faceNormal[0] ) + LvArray::math::square( faceNormal[1] ) + LvArray::math::square( faceNormal[2] ); + EXPECT_LT( abs( sqrt( norm ) - 1.0 ), 1e-6 ); + +} + } /* namespace geos */ diff --git a/src/coreComponents/mesh/utilities/ComputationalGeometry.hpp b/src/coreComponents/mesh/utilities/ComputationalGeometry.hpp index da4e4746bdb..b42090eb5e6 100644 --- a/src/coreComponents/mesh/utilities/ComputationalGeometry.hpp +++ b/src/coreComponents/mesh/utilities/ComputationalGeometry.hpp @@ -215,7 +215,7 @@ real64 computeDiameter( POINT_COORDS_TYPE points, } /** - * @brief Calculate the centroid of a convex 3D polygon as well as the normal and the rotation matrix. + * @brief Calculate the centroid of a convex 3D polygon as well as the normal. * @tparam CENTER_TYPE The type of @p center. * @tparam NORMAL_TYPE The type of @p normal. * @param[in] pointsIndices list of index references for the points array in @@ -245,14 +245,17 @@ real64 centroid_3DPolygon( arraySlice1d< localIndex const > const pointsIndices, GEOS_ERROR_IF_LT( numberOfPoints, 2 ); - real64 current[ 3 ], next[ 3 ], crossProduct[ 3 ]; + real64 current[ 3 ], next[ 3 ], origin[ 3 ], crossProduct[ 3 ]; LvArray::tensorOps::copy< 3 >( next, points[ pointsIndices[ numberOfPoints - 1 ] ] ); + LvArray::tensorOps::copy< 3 >( origin, points[ pointsIndices[ 0 ]] ); - for( localIndex a=0; a( current, next ); - LvArray::tensorOps::copy< 3 >( next, points[ pointsIndices[ a ] ] ); + LvArray::tensorOps::copy< 3 >( current, points[ pointsIndices[ a++ ]] ); + LvArray::tensorOps::scaledAdd< 3 >( current, origin, -1. ); + LvArray::tensorOps::copy< 3 >( next, points[ pointsIndices[ a % numberOfPoints ] ] ); + LvArray::tensorOps::scaledAdd< 3 >( next, origin, -1. ); LvArray::tensorOps::crossProduct( crossProduct, current, next ); @@ -262,6 +265,7 @@ real64 centroid_3DPolygon( arraySlice1d< localIndex const > const pointsIndices, area = LvArray::tensorOps::l2Norm< 3 >( normal ); LvArray::tensorOps::scale< 3 >( center, 1.0 / numberOfPoints ); + LvArray::tensorOps::scaledAdd< 3 >( center, origin, 1. ); if( area > areaTolerance ) { @@ -282,6 +286,16 @@ real64 centroid_3DPolygon( arraySlice1d< localIndex const > const pointsIndices, } else { + for( localIndex a=0; a( direction, edgeCenter ); LvArray::tensorOps::normalize< 3 >( direction ); - faceToughness = std::fabs( LvArray::tensorOps::AiBi< 3 >( direction, KIC[faceIndex] )); + faceToughness = std::fabs( LvArray::tensorOps::AiBi< 3 >( direction, KIC[faceIndex] )) + 1e-108; faceSIFToToughnessRatio.emplace_back( SIFonFace[faceIndex]/faceToughness ); highestSIF = std::max( highestSIF, SIFonFace[faceIndex]/faceToughness ); From 299508ed8db648b27d27c42437409081dad10326 Mon Sep 17 00:00:00 2001 From: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> Date: Fri, 15 May 2026 23:09:19 -0500 Subject: [PATCH 35/53] Avoid method hiding warning (#4059) Co-authored-by: Jian Huang <53012159+jhuang2601@users.noreply.github.com> --- .../constitutiveDrivers/fluid/multiFluid/PVTDriver.hpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/coreComponents/constitutiveDrivers/fluid/multiFluid/PVTDriver.hpp b/src/coreComponents/constitutiveDrivers/fluid/multiFluid/PVTDriver.hpp index 1a5beebea60..89a811cdebe 100644 --- a/src/coreComponents/constitutiveDrivers/fluid/multiFluid/PVTDriver.hpp +++ b/src/coreComponents/constitutiveDrivers/fluid/multiFluid/PVTDriver.hpp @@ -47,6 +47,8 @@ class PVTDriver : public ConstitutiveDriver void postInputInitialization() override; + using ConstitutiveDriver::execute; + bool execute() override; void getColumnNames( string_array & columnNames ) const override; From 27cd5ae7f905eddb91ebacfbad18f44de015a728 Mon Sep 17 00:00:00 2001 From: Bertrand Denel <120652669+bd713@users.noreply.github.com> Date: Sun, 17 May 2026 22:26:57 -0700 Subject: [PATCH 36/53] fix: wellbore nonlinear thermal diffusion documentation example (#4041) * Draft * Fixed label * Path * Path * Typo * Path again * Rabaseline --------- Co-authored-by: DENEL Bertrand Co-authored-by: Jian Huang <53012159+jhuang2601@users.noreply.github.com> Co-authored-by: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 4 + .../scripts/wellboreTemperatureFigure.py | 226 ++++ .../scripts/wellboreTemperatureQueries.py | 137 +++ .../scripts/wellboreTemperatureSolutions.py | 232 ++++ src/conf.py | 2 + .../solid/SolidInternalEnergy.hpp | 7 +- .../linearThermalDiffusion/Example.rst | 2 +- .../linearThermalDiffusion/data_1.csv | 1002 ----------------- .../linearThermalDiffusion/data_10.csv | 1002 ----------------- .../linearThermalDiffusion/data_2.csv | 1002 ----------------- .../linearThermalDiffusion/data_5.csv | 1002 ----------------- .../linearThermalDiffusionFigure.py | 8 + .../linearThermalDiffusionQueries.py | 6 + .../linearThermalDiffusion_plot.py | 147 --- .../linearThermalDiffusion/model-results.txt | 465 ++++++++ .../Example.rst | 2 +- .../data_1.csv | 1002 ----------------- .../data_10.csv | 1002 ----------------- .../data_2.csv | 1002 ----------------- .../data_5.csv | 1002 ----------------- .../model-results.txt | 465 ++++++++ ...dentSinglePhaseThermalConductivity_plot.py | 218 ---- .../thermalConductivityFigure.py | 8 + .../thermalConductivityQueries.py | 6 + .../Example.rst | 2 +- .../data_1.csv | 1002 ----------------- .../data_10.csv | 1002 ----------------- .../data_2.csv | 1002 ----------------- .../data_5.csv | 1002 ----------------- .../model-results.txt | 465 ++++++++ ...ureDependentVolumetricHeatCapacity_plot.py | 216 ---- .../volumetricHeatCapacityFigure.py | 8 + .../volumetricHeatCapacityQueries.py | 6 + 34 files changed, 2046 insertions(+), 12612 deletions(-) create mode 100644 inputFiles/singlePhaseFlow/scripts/wellboreTemperatureFigure.py create mode 100644 inputFiles/singlePhaseFlow/scripts/wellboreTemperatureQueries.py create mode 100644 inputFiles/singlePhaseFlow/scripts/wellboreTemperatureSolutions.py delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_1.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_10.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_2.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_5.csv create mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/linearThermalDiffusionFigure.py create mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/linearThermalDiffusionQueries.py delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/linearThermalDiffusion_plot.py create mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/model-results.txt delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_1.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_10.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_2.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_5.csv create mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/model-results.txt delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/temperatureDependentSinglePhaseThermalConductivity_plot.py create mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/thermalConductivityFigure.py create mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/thermalConductivityQueries.py delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_1.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_10.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_2.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_5.csv create mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/model-results.txt delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/temperatureDependentVolumetricHeatCapacity_plot.py create mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/volumetricHeatCapacityFigure.py create mode 100644 src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/volumetricHeatCapacityQueries.py diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index 439f8b2e2b0..36cbe38311e 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr3977-16644-9fc03e7 + baseline: integratedTests/baseline_integratedTests-pr4041-16664-9a29348 allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index 6e4f040c298..e6f3978c390 100644 --- a/BASELINE_NOTES.md +++ b/BASELINE_NOTES.md @@ -5,6 +5,10 @@ This file is designed to track changes to the integrated test baselines. Any developer who updates the baseline ID in the .integrated_tests.yaml file is expected to create an entry in this file with the pull request number, date, and their justification for rebaselining. These notes should be in reverse-chronological order, and use the following time format: (YYYY-MM-DD). +PR #4041 (2026-05-16) +===================== +Fix wellbore nonlinear thermal diffusion + PR #3977 (2026-05-15) Change face normal, centers and area for local Newell's formula diff --git a/inputFiles/singlePhaseFlow/scripts/wellboreTemperatureFigure.py b/inputFiles/singlePhaseFlow/scripts/wellboreTemperatureFigure.py new file mode 100644 index 00000000000..5112ae788af --- /dev/null +++ b/inputFiles/singlePhaseFlow/scripts/wellboreTemperatureFigure.py @@ -0,0 +1,226 @@ +""" +wellboreTemperatureFigure.py + +Reads GEOS results (produced by wellboreTemperatureQueries.py) +and produces a 2x2 subplot figure comparing at 4 time steps: + - GEOS results (from model-results.txt) + - FDM non-linear reference + - Linear analytic solution for infinite domain(Wang & Papamichos 1994) + - Steady-state log solution + +Supports three test cases via xmlFilePrefix: + - 'thermalCompressible_2d' (linear / constant properties) + - 'thermalCompressible_temperatureDependentVolumetricHeatCapacity' + - 'thermalCompressible_temperatureDependentSinglePhaseThermalConductivity' + +Usage: + python wellboreTemperatureFigure.py --xmlFilePrefix [--geosDir /path/to/GEOS] [--savePng] +""" + +import os +import sys +import argparse + +import numpy as np +import matplotlib.pyplot as plt +from xml.etree import ElementTree + +sys.path.append(os.path.dirname(os.path.abspath(__file__))) +import wellboreTemperatureSolutions as wts + + +# --------------------------------------------------------------------------- +# XML helpers +# --------------------------------------------------------------------------- + +def _xmlList(s): + return s.replace('{', '').replace('}', '').strip().split(',') + + +def getWellboreGeometryFromXML(xmlPath): + tree = ElementTree.parse(xmlPath) + radii = _xmlList(tree.find('Mesh/InternalWellbore').get('radius')) + return float(radii[0]), float(radii[-1]) + + +def getParametersFromXML(xmlPath, xmlFilePrefix): + """Parse constitutive / BC parameters from the base XML. + + Parameters + ---------- + xmlPath : str + Path to the base XML file (thermalCompressible_2d_base.xml). + xmlFilePrefix : str + Test-case prefix, determines which constitutive models to look for. + + Returns + ------- + tuple + (Tin, Tout, lambda0, lambda_gradient, c0, c_gradient, Tref, porosity) + """ + tree = ElementTree.parse(xmlPath) + fsParams = tree.findall('FieldSpecifications/FieldSpecification') + + Pin = Pout = Tin = Tout = None + for fs in fsParams: + if fs.get('fieldName') == 'pressure' and fs.get('initialCondition') != '1': + if fs.get('setNames') == '{ rneg }': + Pin = float(fs.get('scale')) + if fs.get('setNames') == '{ rpos }': + Pout = float(fs.get('scale')) + for fs in fsParams: + if fs.get('fieldName') == 'temperature' and fs.get('initialCondition') != '1': + if fs.get('setNames') == '{ rneg }': + Tin = float(fs.get('scale')) + if fs.get('setNames') == '{ rpos }': + Tout = float(fs.get('scale')) + + lambda0 = lambda_gradient = Tref = c0 = c_gradient = None + + if 'ThermalConductivity' in xmlFilePrefix: + # T-dependent conductivity, constant heat capacity + for tc in tree.findall('Constitutive/SinglePhaseThermalConductivity'): + if tc.get('name') == 'thermalCond_nonLinear': + lambda0 = float(_xmlList(tc.get('defaultThermalConductivityComponents'))[0]) + lambda_gradient = float(_xmlList(tc.get('thermalConductivityGradientComponents'))[0]) + Tref = float(tc.get('referenceTemperature')) + for sie in tree.findall('Constitutive/SolidInternalEnergy'): + if sie.get('name') == 'rockInternalEnergy_linear': + c0 = float(sie.get('referenceVolumetricHeatCapacity')) + c_gradient = 0.0 + if Tref is None: + Tref = float(sie.get('referenceTemperature')) + elif 'VolumetricHeatCapacity' in xmlFilePrefix: + # T-dependent heat capacity, constant conductivity + for tc in tree.findall('Constitutive/SinglePhaseThermalConductivity'): + if tc.get('name') == 'thermalCond_linear': + lambda0 = float(_xmlList(tc.get('defaultThermalConductivityComponents'))[0]) + lambda_gradient = 0.0 + for sie in tree.findall('Constitutive/SolidInternalEnergy'): + if sie.get('name') == 'rockInternalEnergy_nonLinear': + c0 = float(sie.get('referenceVolumetricHeatCapacity')) + c_gradient = float(sie.get('dVolumetricHeatCapacity_dTemperature')) + Tref = float(sie.get('referenceTemperature')) + else: + # Linear / constant properties + for tc in tree.findall('Constitutive/SinglePhaseThermalConductivity'): + if tc.get('name') == 'thermalCond_linear': + lambda0 = float(_xmlList(tc.get('defaultThermalConductivityComponents'))[0]) + lambda_gradient = 0.0 + for sie in tree.findall('Constitutive/SolidInternalEnergy'): + if sie.get('name') == 'rockInternalEnergy_linear': + c0 = float(sie.get('referenceVolumetricHeatCapacity')) + c_gradient = 0.0 + Tref = float(sie.get('referenceTemperature')) + + porosity = float(tree.find('Constitutive/PressurePorosity').get('defaultReferencePorosity')) + + return Tin, Tout, lambda0, lambda_gradient, c0, c_gradient, Tref, porosity + + +# --------------------------------------------------------------------------- +# Main +# --------------------------------------------------------------------------- + +def main(xmlFilePrefix='', outputDir=None): + _scripts_dir = os.path.dirname(os.path.abspath(__file__)) + _default_geos_dir = os.path.normpath(os.path.join(_scripts_dir, '..', '..', '..')) + + parser = argparse.ArgumentParser( + description='Plot wellbore temperature validation (reads model-results.txt).') + parser.add_argument('--geosDir', default=_default_geos_dir, + help='Path to the GEOS repository root') + parser.add_argument('--xmlFilePrefix', default='', + help='Test-case XML prefix') + parser.add_argument('--outputDir', default=outputDir if outputDir is not None else '.', + help='Path to the directory containing model-results.txt and where the figure is saved') + parser.add_argument('--savePng', action='store_true', + help='Save PNG to outputDir using .png') + args = parser.parse_args() + + if not xmlFilePrefix: + xmlFilePrefix = args.xmlFilePrefix + if not xmlFilePrefix: + raise ValueError('xmlFilePrefix must be provided either as argument or via --xmlFilePrefix') + + xmlBase = os.path.join(args.geosDir, 'inputFiles', 'singlePhaseFlow', + 'thermalCompressible_2d_base.xml') + xmlBenchmark = os.path.join(args.geosDir, 'inputFiles', 'singlePhaseFlow', + xmlFilePrefix + '_benchmark.xml') + + Rin, Rout = getWellboreGeometryFromXML(xmlBenchmark) + (Tin, Tout, + lambda0, lambda_gradient, + c0, c_gradient, Tref, porosity) = getParametersFromXML(xmlBase, xmlFilePrefix) + + # Whether properties are temperature-dependent (non-linear) + isNonLinear = (lambda_gradient != 0.0) or (c_gradient != 0.0) + + # Porosity-weighted reference diffusivity for the linear analytic solution + effectiveRefCap = (1.0 - porosity) * c0 + thermalDiffusivity = lambda0 / effectiveRefCap + + # ----------------------------------------------------------------------- + # Load results + # ----------------------------------------------------------------------- + dataPath = os.path.join(args.outputDir, 'model-results.txt') + data = np.loadtxt(dataPath, skiprows=1) + # columns: time, r, temperature + unique_times = np.unique(data[:, 0]) + + # ----------------------------------------------------------------------- + # Plot + # ----------------------------------------------------------------------- + fig, axes = plt.subplots(2, 2, figsize=(10, 7)) + plt.rc('font', size=16) + + for chart_idx, t_val in enumerate(unique_times): + mask = data[:, 0] == t_val + r_cells = data[mask, 1] + temperature_geos = data[mask, 2] + + # FDM non-linear reference (only when λ or c depends on T) + if isNonLinear: + T_fdm = wts.solveRadialDiffusion( + r_cells, Rin, Rout, + t_val, t_val / 100.0, + Tin, Tout, + lambda0, lambda_gradient, + c0, c_gradient, Tref, porosity) + + # Linear analytic (Wang & Papamichos 1994) + T_linear = wts.transientTemperature(Tin, Tout, Rin, r_cells, thermalDiffusivity, t_val) + + # Steady-state log profile + T_ss = wts.steadyState(Tin, Tout, Rin, Rout, r_cells) + + ax = axes.flat[chart_idx] + ax.plot(r_cells, temperature_geos, 'k+', label='GEOS') + if isNonLinear: + ax.plot(r_cells, T_fdm, 'g-', label='FDM Non-Linear') + ax.plot(r_cells, T_linear, 'r-', label='Analytic Linear, infinite domain') + ax.plot(r_cells, T_ss, 'b-', label='Steady State') + + if chart_idx == 1: + ax.legend(fontsize=11) + if chart_idx in [2, 3]: + ax.set_xlabel('Radial distance from well centre (m)') + if chart_idx in [0, 2]: + ax.set_ylabel('Temperature (°C)') + + ax.set_ylim(-30, 110) + ax.set_xlim(0.0, 1.0 if not isNonLinear else 0.5) + ax.set_title(f't = {t_val:g} s') + ax.grid(True) + + plt.tight_layout() + if args.savePng: + pngName = xmlFilePrefix + '.png' + pngPath = os.path.join(args.outputDir, pngName) + plt.savefig(pngPath, dpi=150) + print(f'Saved {pngPath}') + plt.show() + + +if __name__ == '__main__': + main() diff --git a/inputFiles/singlePhaseFlow/scripts/wellboreTemperatureQueries.py b/inputFiles/singlePhaseFlow/scripts/wellboreTemperatureQueries.py new file mode 100644 index 00000000000..de58f23e773 --- /dev/null +++ b/inputFiles/singlePhaseFlow/scripts/wellboreTemperatureQueries.py @@ -0,0 +1,137 @@ +""" +wellboreTemperatureQueries.py + +Query script for the wellbore thermal diffusion validation tests. + +Reads GEOS VTK output, extracts radial temperature profiles at selected timesteps, +and writes model-results.txt that can be read by wellboreTemperatureFigure.py. + +Usage: + python wellboreTemperatureQueries.py --outputDir /path/to/vtkOutput [--snapshotIndices 1 2 5 10] + +Output: model-results.txt with columns: + time r temperature +""" + +import os +import argparse + +import numpy as np +from xml.etree import ElementTree + +import vtk +from vtk.util.numpy_support import vtk_to_numpy + + +# --------------------------------------------------------------------------- +# VTK I/O helpers +# --------------------------------------------------------------------------- + +def getTimestepsFromPVD(outputDir): + """Parse vtkOutput.pvd → list of (time, vtmPath) tuples.""" + pvdPath = os.path.join(outputDir, 'vtkOutput.pvd') + tree = ElementTree.parse(pvdPath) + timesteps = [] + for dataset in tree.findall('.//DataSet'): + time = float(dataset.get('timestep')) + vtmPath = os.path.join(outputDir, dataset.get('file')) + timesteps.append((time, vtmPath)) + return timesteps + + +def _readVTU(vtuPath): + """Read a single VTU file; return (centers, temperatures) as numpy arrays.""" + reader = vtk.vtkXMLUnstructuredGridReader() + reader.SetFileName(vtuPath) + reader.Update() + grid = reader.GetOutput() + cd = grid.GetCellData() + + ec_vtk = cd.GetArray('elementCenter') + if ec_vtk is None: + raise RuntimeError(f"Array 'elementCenter' not found in {vtuPath}") + centers = vtk_to_numpy(ec_vtk).reshape(-1, 3) + + t_vtk = cd.GetArray('temperature') + if t_vtk is None: + raise RuntimeError(f"Array 'temperature' not found in {vtuPath}") + temperatures = vtk_to_numpy(t_vtk).ravel() + + return centers, temperatures + + +def readVTMData(vtmPath): + """Read all VTU pieces in a VTM file; return one cell (closest to θ = 45°) per radial ring.""" + tree = ElementTree.parse(vtmPath) + vtmDir = os.path.dirname(vtmPath) + + all_centers, all_temps = [], [] + for ds in tree.findall('.//DataSet'): + vtuFile = ds.get('file') + if vtuFile is None: + continue + centers, temps = _readVTU(os.path.join(vtmDir, vtuFile)) + all_centers.append(centers) + all_temps.append(temps) + + centers = np.vstack(all_centers) + temps = np.concatenate(all_temps) + + x, y = centers[:, 0], centers[:, 1] + r = np.sqrt(x**2 + y**2) + theta = np.arctan2(y, x) + target_theta = np.pi / 4.0 + + r_rounded = np.round(r, decimals=8) + unique_r = np.unique(r_rounded) + keep = [] + for rv in unique_r: + mask = r_rounded == rv + idx = np.where(mask)[0] + best = idx[np.argmin(np.abs(theta[idx] - target_theta))] + keep.append(best) + keep = np.array(keep) + + return r[keep], temps[keep] + + +# --------------------------------------------------------------------------- +# Main +# --------------------------------------------------------------------------- + +def main(): + parser = argparse.ArgumentParser( + description='Extract radial temperature profiles from GEOS VTK output.') + parser.add_argument('--outputDir', + help='Path to GEOS VTK output directory (contains vtkOutput.pvd)', + default='.') + parser.add_argument('--snapshotIndices', nargs='+', type=int, + default=[1, 2, 5, 10], + help='Indices into the PVD timestep list to extract (default: 1 2 5 10)') + args = parser.parse_args() + + timesteps = getTimestepsFromPVD(args.outputDir) + + rows = [] + for idx in args.snapshotIndices: + if idx >= len(timesteps): + raise ValueError(f"Snapshot index {idx} out of range (file has {len(timesteps)} entries).") + time, vtmPath = timesteps[idx] + r, temperature = readVTMData(vtmPath) + + # Sort by radius + sort_idx = np.argsort(r) + r = r[sort_idx] + temperature = temperature[sort_idx] + + for ri, Ti in zip(r, temperature): + rows.append([time, ri, Ti]) + + rows = np.array(rows) + header = ' time r temperature' + np.savetxt('model-results.txt', rows, header=header, fmt='%15.6g', comments='') + print(f"Wrote model-results.txt ({len(rows)} rows, {len(args.snapshotIndices)} snapshots).") + + +if __name__ == '__main__': + main() diff --git a/inputFiles/singlePhaseFlow/scripts/wellboreTemperatureSolutions.py b/inputFiles/singlePhaseFlow/scripts/wellboreTemperatureSolutions.py new file mode 100644 index 00000000000..938ef6dc5a7 --- /dev/null +++ b/inputFiles/singlePhaseFlow/scripts/wellboreTemperatureSolutions.py @@ -0,0 +1,232 @@ +""" +wellboreTemperatureSolutions.py + +Shared analytic and numerical reference solutions for wellbore thermal +diffusion validation tests. + +Covers: + - Linear analytic transient (Wang & Papamichos 1994) + - Log steady-state + - Non-linear FDM reference +""" + +import numpy as np +from scipy import special +from scipy.sparse import csr_matrix +from scipy.sparse.linalg import spsolve + + +# --------------------------------------------------------------------------- +# Linear analytic solutions +# --------------------------------------------------------------------------- + +def steadyState(Tin, Tout, Rin, Rout, r): + """Log-linear steady-state radial temperature profile. + + Parameters + ---------- + Tin, Tout : float + Temperature imposed at inner (r=Rin) and outer (r=Rout) boundaries (°C or K). + Rin, Rout : float + Inner and outer radii (m). + r : array_like + Radial coordinates at which to evaluate the solution (m). + + Returns + ------- + numpy.ndarray + Temperature at each r. + """ + r = np.asarray(r) + return Tin + (Tout - Tin) * (np.log(r) - np.log(Rin)) / (np.log(Rout) - np.log(Rin)) + + +def transientTemperature(Tin, Tout, Rin, r, thermalDiffusivity, t): + """Approximate transient radial temperature (Wang & Papamichos 1994). + + Valid for an infinite domain in the early-time regime. + + Reference + --------- + Wang, Y. and Papamichos, E. (1994). Conductive heat flow and thermally + induced fluid flow around a wellbore in a poroelastic medium. + Water Resources Research, 30(12), 3375–3384. + + Parameters + ---------- + Tin : float + Temperature at the wellbore wall (r = Rin). + Tout : float + Initial / far-field temperature. + Rin : float + Wellbore radius (m). + r : array_like + Radial coordinates (m). + thermalDiffusivity : float + κ = λ / (ρ c_eff) (m²/s). + t : float + Elapsed time (s). + + Returns + ------- + numpy.ndarray + Temperature at each r. + """ + r = np.asarray(r) + xi = (r - Rin) / (2.0 * np.sqrt(thermalDiffusivity * t)) + return Tout + (Tin - Tout) * np.sqrt(Rin / r) * special.erfc(xi) + + +# --------------------------------------------------------------------------- +# Temperature-dependent material properties +# --------------------------------------------------------------------------- + +def thermalConductivity(lambda0, lambda_gradient, T, Tref): + """Linear T-dependent thermal conductivity: λ(T) = λ0 + dλ/dT * (T - Tref). + + Parameters + ---------- + lambda0 : float or array + Reference thermal conductivity at Tref (W/m/K). + lambda_gradient : float or array + dλ/dT (W/m/K²). + T : array_like + Current temperature field (°C or K). + Tref : float + Reference temperature (°C or K). + + Returns + ------- + numpy.ndarray + λ(T) at each point. + """ + return np.asarray(lambda0) + np.asarray(lambda_gradient) * (np.asarray(T) - Tref) + + +def effectiveVolumetricHeatCapacity(c0, c_gradient, T, Tref, porosity): + """Porosity-weighted solid volumetric heat capacity: c_eff(T) = (1-φ)(c0 + dc/dT*(T-Tref)). + + Consistent with the GEOS energy-balance assembly, which stores the + solid-only heat capacity and multiplies by the solid volume fraction + (1 - φ) when computing the effective capacity. + + Parameters + ---------- + c0 : float + Reference solid volumetric heat capacity at Tref (J/m³/K). + c_gradient : float + dc/dT (J/m³/K²). + T : array_like + Current temperature field (°C or K). + Tref : float + Reference temperature (°C or K). + porosity : float + Rock porosity φ ∈ [0, 1]. + + Returns + ------- + numpy.ndarray + Effective volumetric heat capacity at each point. + """ + return (1.0 - porosity) * (c0 + c_gradient * (np.asarray(T) - Tref)) + + +# --------------------------------------------------------------------------- +# Non-linear FD solver +# --------------------------------------------------------------------------- + +def _buildMatrix(lam, cap, r, dt, N): + """Assemble the implicit backward-Euler system matrix for one time step. + + Grid layout (N+1 nodes): + r[0] = Rin — Dirichlet boundary face (inner) + r[1:-1] = GEOS cell centres (N-1 interior nodes) + r[N] = Rout — Dirichlet boundary face (outer) + + Interior node i (1 ≤ i ≤ N-1): + dr_L = r[i] - r[i-1], dr_R = r[i+1] - r[i], S = dr_L + dr_R + + Discretised PDE (cylindrical): + c_eff * dT/dt = d/dr[λ dT/dr] + λ/r * dT/dr + + d²T/dr² ≈ (2/S) * [(T[i+1]-T[i])/dr_R − (T[i]-T[i-1])/dr_L] + dT/dr ≈ (T[i+1] - T[i-1]) / S + dλ/dr ≈ (λ[i+1] - λ[i-1]) / S (lagged) + + Material coefficients are lagged at T^n (explicit treatment of non-linearity). + """ + A = np.zeros((N + 1, N + 1)) + + for i in range(1, N): + dr_L = r[i] - r[i - 1] + dr_R = r[i + 1] - r[i] + S = dr_L + dr_R + r_i = r[i] + + alpha_i = lam[i] / cap[i] + dlambda_i = (lam[i + 1] - lam[i - 1]) / S + beta_i = dlambda_i / cap[i] + + fd1 = (alpha_i / r_i + beta_i) / S + + A[i, i - 1] = -dt * (2.0 * alpha_i / (S * dr_L) - fd1) + A[i, i ] = 1.0 + dt * 2.0 * alpha_i / (dr_L * dr_R) + A[i, i + 1] = -dt * (2.0 * alpha_i / (S * dr_R) + fd1) + + # Dirichlet BCs at boundary faces + A[0, 0] = 1.0 + A[N, N] = 1.0 + return A + + +def solveRadialDiffusion(r_cells, Rin, Rout, tmax, dt, + Tin, Tout, + lambda0, lambda_gradient, + c0, c_gradient, Tref, porosity): + """Solve the non-linear radial heat equation with an implicit FD scheme. + + The computational grid augments the GEOS cell centres with the actual + boundary faces so that Dirichlet conditions are imposed at the correct + radial positions. + + Parameters + ---------- + r_cells : array_like + GEOS cell-centre radial coordinates (m), sorted ascending. + Rin, Rout : float + Inner and outer boundary radii (m). + tmax : float + Total simulation time (s). + dt : float + Time-step size (s). A smaller dt improves accuracy. + Tin, Tout : float + Dirichlet temperatures at Rin and Rout (°C or K). + lambda0, lambda_gradient : float + Thermal conductivity reference value and gradient (W/m/K and W/m/K²). + c0, c_gradient : float + Solid heat capacity reference value and gradient (J/m³/K and J/m³/K²). + Tref : float + Reference temperature for material property linearisation (°C or K). + porosity : float + Rock porosity φ. + + Returns + ------- + numpy.ndarray + Temperature at each GEOS cell centre after tmax seconds. + """ + r_cells = np.asarray(r_cells, dtype=float) + r = np.concatenate([[Rin], r_cells, [Rout]]) + N = len(r) - 1 + n_steps = max(1, int(round(tmax / dt))) + + T = np.full(N + 1, Tout, dtype=float) + T[0] = Tin + + for _ in range(n_steps): + lam = thermalConductivity(lambda0, lambda_gradient, T, Tref) + cap = effectiveVolumetricHeatCapacity(c0, c_gradient, T, Tref, porosity) + A = csr_matrix(_buildMatrix(lam, cap, r, dt, N)) + T = spsolve(A, T) + + return T[1:-1] # strip the two boundary-face nodes diff --git a/src/conf.py b/src/conf.py index c7347bd29fb..a93874178a6 100644 --- a/src/conf.py +++ b/src/conf.py @@ -26,6 +26,8 @@ for m in python_modules: sys.path.insert(0, os.path.abspath(os.path.join(python_root, m))) +sys.path.insert(0, os.path.abspath('../inputFiles/singlePhaseFlow/scripts')) + # Call doxygen in ReadtheDocs read_the_docs_build = os.environ.get('READTHEDOCS', None) == 'True' if read_the_docs_build: diff --git a/src/coreComponents/constitutive/solid/SolidInternalEnergy.hpp b/src/coreComponents/constitutive/solid/SolidInternalEnergy.hpp index c9e70f9abd9..254635b0689 100644 --- a/src/coreComponents/constitutive/solid/SolidInternalEnergy.hpp +++ b/src/coreComponents/constitutive/solid/SolidInternalEnergy.hpp @@ -62,10 +62,11 @@ class SolidInternalEnergyUpdates real64 & internalEnergy, real64 & dInternalEnergy_dTemperature ) const { - real64 volumetricHeatCapacity = m_referenceVolumetricHeatCapacity + m_dVolumetricHeatCapacity_dTemperature * ( temperature - m_referenceTemperature ); + real64 const deltaT = temperature - m_referenceTemperature; + real64 const volumetricHeatCapacity = m_referenceVolumetricHeatCapacity + m_dVolumetricHeatCapacity_dTemperature * deltaT; - internalEnergy = m_referenceInternalEnergy + volumetricHeatCapacity * ( temperature - m_referenceTemperature ); - dInternalEnergy_dTemperature = volumetricHeatCapacity + m_dVolumetricHeatCapacity_dTemperature * ( temperature - m_referenceTemperature ); + internalEnergy = m_referenceInternalEnergy + m_referenceVolumetricHeatCapacity * deltaT + 0.5 * m_dVolumetricHeatCapacity_dTemperature * deltaT * deltaT; + dInternalEnergy_dTemperature = volumetricHeatCapacity; } private: diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/Example.rst b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/Example.rst index a16e28b359f..be250750271 100644 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/Example.rst +++ b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/Example.rst @@ -100,7 +100,7 @@ Results and benchmark A good agreement between the GEOS results and analytical results is shown in the figure below: -.. plot:: docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/linearThermalDiffusion_plot.py +.. plot:: docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/linearThermalDiffusionFigure.py ------------------------------------------------------------------ diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_1.csv b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_1.csv deleted file mode 100644 index 27b265b8428..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_1.csv +++ /dev/null @@ -1,1002 +0,0 @@ -Time,"elementCenter:0","elementCenter:1","elementCenter:2","temperature" -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,0.07071,0.072112,0.05,-18.996 -10000,0.07071,0.072112,0.05,-18.996 -10000,0.07211,0.07354,0.05,-17.027 -10000,0.07351,0.074968,0.05,-15.096 -10000,0.075155,0.076646,0.05,-12.871 -10000,0.075155,0.076646,0.05,-12.871 -10000,0.077046,0.078574,0.05,-10.378 -10000,0.077046,0.078574,0.05,-10.378 -10000,0.078936,0.080501,0.05,-7.9475 -10000,0.078936,0.080501,0.05,-7.9475 -10000,0.080826,0.082429,0.05,-5.5759 -10000,0.080826,0.082429,0.05,-5.5759 -10000,0.082716,0.084357,0.05,-3.2609 -10000,0.082716,0.084357,0.05,-3.2609 -10000,0.084607,0.086285,0.05,-1.0005 -10000,0.084607,0.086285,0.05,-1.0005 -10000,0.086497,0.088212,0.05,1.2075 -10000,0.086497,0.088212,0.05,1.2075 -10000,0.088387,0.09014,0.05,3.365 -10000,0.088387,0.09014,0.05,3.365 -10000,0.090278,0.092068,0.05,5.4737 -10000,0.090278,0.092068,0.05,5.4737 -10000,0.092168,0.093995,0.05,7.5355 -10000,0.092168,0.093995,0.05,7.5355 -10000,0.094031,0.095896,0.05,9.5228 -10000,0.095885,0.097786,0.05,11.459 -10000,0.095885,0.097786,0.05,11.459 -10000,0.097776,0.099715,0.05,13.391 -10000,0.097776,0.099715,0.05,13.391 -10000,0.099704,0.10168,0.05,15.318 -10000,0.099704,0.10168,0.05,15.318 -10000,0.10167,0.10369,0.05,17.241 -10000,0.10167,0.10369,0.05,17.241 -10000,0.10368,0.10573,0.05,19.159 -10000,0.10368,0.10573,0.05,19.159 -10000,0.10572,0.10782,0.05,21.071 -10000,0.10572,0.10782,0.05,21.071 -10000,0.10781,0.10995,0.05,22.977 -10000,0.10781,0.10995,0.05,22.977 -10000,0.10993,0.11211,0.05,24.877 -10000,0.10993,0.11211,0.05,24.877 -10000,0.10993,0.11211,0.05,24.877 -10000,0.1121,0.11433,0.05,26.769 -10000,0.1121,0.11433,0.05,26.769 -10000,0.11432,0.11658,0.05,28.653 -10000,0.11432,0.11658,0.05,28.653 -10000,0.11657,0.11888,0.05,30.529 -10000,0.11657,0.11888,0.05,30.529 -10000,0.11887,0.12123,0.05,32.396 -10000,0.11887,0.12123,0.05,32.396 -10000,0.11887,0.12123,0.05,32.396 -10000,0.12122,0.12362,0.05,34.254 -10000,0.12122,0.12362,0.05,34.254 -10000,0.12361,0.12607,0.05,36.1 -10000,0.12361,0.12607,0.05,36.1 -10000,0.12361,0.12607,0.05,36.1 -10000,0.12605,0.12855,0.05,37.936 -10000,0.12605,0.12855,0.05,37.936 -10000,0.12854,0.13109,0.05,39.76 -10000,0.12854,0.13109,0.05,39.76 -10000,0.12854,0.13109,0.05,39.76 -10000,0.13108,0.13368,0.05,41.571 -10000,0.13108,0.13368,0.05,41.571 -10000,0.13367,0.13632,0.05,43.368 -10000,0.13367,0.13632,0.05,43.368 -10000,0.13367,0.13632,0.05,43.368 -10000,0.13631,0.13901,0.05,45.152 -10000,0.13631,0.13901,0.05,45.152 -10000,0.13631,0.13901,0.05,45.152 -10000,0.139,0.14176,0.05,46.92 -10000,0.139,0.14176,0.05,46.92 -10000,0.14175,0.14456,0.05,48.672 -10000,0.14175,0.14456,0.05,48.672 -10000,0.14175,0.14456,0.05,48.672 -10000,0.14455,0.14742,0.05,50.407 -10000,0.14455,0.14742,0.05,50.407 -10000,0.14455,0.14742,0.05,50.407 -10000,0.1474,0.15033,0.05,52.125 -10000,0.1474,0.15033,0.05,52.125 -10000,0.1474,0.15033,0.05,52.125 -10000,0.15032,0.1533,0.05,53.824 -10000,0.15032,0.1533,0.05,53.824 -10000,0.15032,0.1533,0.05,53.824 -10000,0.15329,0.15633,0.05,55.503 -10000,0.15329,0.15633,0.05,55.503 -10000,0.15329,0.15633,0.05,55.503 -10000,0.15632,0.15942,0.05,57.161 -10000,0.15632,0.15942,0.05,57.161 -10000,0.15632,0.15942,0.05,57.161 -10000,0.15941,0.16257,0.05,58.797 -10000,0.15941,0.16257,0.05,58.797 -10000,0.15941,0.16257,0.05,58.797 -10000,0.16256,0.16578,0.05,60.411 -10000,0.16256,0.16578,0.05,60.411 -10000,0.16256,0.16578,0.05,60.411 -10000,0.16577,0.16906,0.05,62.001 -10000,0.16577,0.16906,0.05,62.001 -10000,0.16577,0.16906,0.05,62.001 -10000,0.16577,0.16906,0.05,62.001 -10000,0.16905,0.1724,0.05,63.566 -10000,0.16905,0.1724,0.05,63.566 -10000,0.16905,0.1724,0.05,63.566 -10000,0.17239,0.1758,0.05,65.106 -10000,0.17239,0.1758,0.05,65.106 -10000,0.17239,0.1758,0.05,65.106 -10000,0.17579,0.17928,0.05,66.619 -10000,0.17579,0.17928,0.05,66.619 -10000,0.17579,0.17928,0.05,66.619 -10000,0.17579,0.17928,0.05,66.619 -10000,0.17927,0.18282,0.05,68.104 -10000,0.17927,0.18282,0.05,68.104 -10000,0.17927,0.18282,0.05,68.104 -10000,0.18281,0.18644,0.05,69.56 -10000,0.18281,0.18644,0.05,69.56 -10000,0.18281,0.18644,0.05,69.56 -10000,0.18281,0.18644,0.05,69.56 -10000,0.18643,0.19013,0.05,70.986 -10000,0.18643,0.19013,0.05,70.986 -10000,0.18643,0.19013,0.05,70.986 -10000,0.18643,0.19013,0.05,70.986 -10000,0.19011,0.19388,0.05,72.382 -10000,0.19011,0.19388,0.05,72.382 -10000,0.19011,0.19388,0.05,72.382 -10000,0.19387,0.19772,0.05,73.746 -10000,0.19387,0.19772,0.05,73.746 -10000,0.19387,0.19772,0.05,73.746 -10000,0.19387,0.19772,0.05,73.746 -10000,0.19771,0.20163,0.05,75.077 -10000,0.19771,0.20163,0.05,75.077 -10000,0.19771,0.20163,0.05,75.077 -10000,0.19771,0.20163,0.05,75.077 -10000,0.20162,0.20562,0.05,76.375 -10000,0.20162,0.20562,0.05,76.375 -10000,0.20162,0.20562,0.05,76.375 -10000,0.20162,0.20562,0.05,76.375 -10000,0.2056,0.20968,0.05,77.639 -10000,0.2056,0.20968,0.05,77.639 -10000,0.2056,0.20968,0.05,77.639 -10000,0.2056,0.20968,0.05,77.639 -10000,0.20967,0.21383,0.05,78.867 -10000,0.20967,0.21383,0.05,78.867 -10000,0.20967,0.21383,0.05,78.867 -10000,0.20967,0.21383,0.05,78.867 -10000,0.21382,0.21806,0.05,80.06 -10000,0.21382,0.21806,0.05,80.06 -10000,0.21382,0.21806,0.05,80.06 -10000,0.21382,0.21806,0.05,80.06 -10000,0.21382,0.21806,0.05,80.06 -10000,0.21805,0.22237,0.05,81.216 -10000,0.21805,0.22237,0.05,81.216 -10000,0.21805,0.22237,0.05,81.216 -10000,0.21805,0.22237,0.05,81.216 -10000,0.22236,0.22677,0.05,82.334 -10000,0.22236,0.22677,0.05,82.334 -10000,0.22236,0.22677,0.05,82.334 -10000,0.22236,0.22677,0.05,82.334 -10000,0.22676,0.23125,0.05,83.416 -10000,0.22676,0.23125,0.05,83.416 -10000,0.22676,0.23125,0.05,83.416 -10000,0.22676,0.23125,0.05,83.416 -10000,0.22676,0.23125,0.05,83.416 -10000,0.23124,0.23583,0.05,84.459 -10000,0.23124,0.23583,0.05,84.459 -10000,0.23124,0.23583,0.05,84.459 -10000,0.23124,0.23583,0.05,84.459 -10000,0.23582,0.2405,0.05,85.463 -10000,0.23582,0.2405,0.05,85.463 -10000,0.23582,0.2405,0.05,85.463 -10000,0.23582,0.2405,0.05,85.463 -10000,0.23582,0.2405,0.05,85.463 -10000,0.24048,0.24525,0.05,86.429 -10000,0.24048,0.24525,0.05,86.429 -10000,0.24048,0.24525,0.05,86.429 -10000,0.24048,0.24525,0.05,86.429 -10000,0.24048,0.24525,0.05,86.429 -10000,0.24524,0.25011,0.05,87.355 -10000,0.24524,0.25011,0.05,87.355 -10000,0.24524,0.25011,0.05,87.355 -10000,0.24524,0.25011,0.05,87.355 -10000,0.24524,0.25011,0.05,87.355 -10000,0.25009,0.25505,0.05,88.242 -10000,0.25009,0.25505,0.05,88.242 -10000,0.25009,0.25505,0.05,88.242 -10000,0.25009,0.25505,0.05,88.242 -10000,0.25009,0.25505,0.05,88.242 -10000,0.25504,0.2601,0.05,89.09 -10000,0.25504,0.2601,0.05,89.09 -10000,0.25504,0.2601,0.05,89.09 -10000,0.25504,0.2601,0.05,89.09 -10000,0.25504,0.2601,0.05,89.09 -10000,0.26009,0.26525,0.05,89.899 -10000,0.26009,0.26525,0.05,89.899 -10000,0.26009,0.26525,0.05,89.899 -10000,0.26009,0.26525,0.05,89.899 -10000,0.26009,0.26525,0.05,89.899 -10000,0.26524,0.2705,0.05,90.669 -10000,0.26524,0.2705,0.05,90.669 -10000,0.26524,0.2705,0.05,90.669 -10000,0.26524,0.2705,0.05,90.669 -10000,0.26524,0.2705,0.05,90.669 -10000,0.27048,0.27585,0.05,91.4 -10000,0.27048,0.27585,0.05,91.4 -10000,0.27048,0.27585,0.05,91.4 -10000,0.27048,0.27585,0.05,91.4 -10000,0.27048,0.27585,0.05,91.4 -10000,0.27584,0.28131,0.05,92.092 -10000,0.27584,0.28131,0.05,92.092 -10000,0.27584,0.28131,0.05,92.092 -10000,0.27584,0.28131,0.05,92.092 -10000,0.27584,0.28131,0.05,92.092 -10000,0.27584,0.28131,0.05,92.092 -10000,0.2813,0.28687,0.05,92.746 -10000,0.2813,0.28687,0.05,92.746 -10000,0.2813,0.28687,0.05,92.746 -10000,0.2813,0.28687,0.05,92.746 -10000,0.2813,0.28687,0.05,92.746 -10000,0.28686,0.29255,0.05,93.363 -10000,0.28686,0.29255,0.05,93.363 -10000,0.28686,0.29255,0.05,93.363 -10000,0.28686,0.29255,0.05,93.363 -10000,0.28686,0.29255,0.05,93.363 -10000,0.28686,0.29255,0.05,93.363 -10000,0.29254,0.29834,0.05,93.944 -10000,0.29254,0.29834,0.05,93.944 -10000,0.29254,0.29834,0.05,93.944 -10000,0.29254,0.29834,0.05,93.944 -10000,0.29254,0.29834,0.05,93.944 -10000,0.29254,0.29834,0.05,93.944 -10000,0.29833,0.30425,0.05,94.488 -10000,0.29833,0.30425,0.05,94.488 -10000,0.29833,0.30425,0.05,94.488 -10000,0.29833,0.30425,0.05,94.488 -10000,0.29833,0.30425,0.05,94.488 -10000,0.29833,0.30425,0.05,94.488 -10000,0.30424,0.31027,0.05,94.997 -10000,0.30424,0.31027,0.05,94.997 -10000,0.30424,0.31027,0.05,94.997 -10000,0.30424,0.31027,0.05,94.997 -10000,0.30424,0.31027,0.05,94.997 -10000,0.30424,0.31027,0.05,94.997 -10000,0.31026,0.31641,0.05,95.472 -10000,0.31026,0.31641,0.05,95.472 -10000,0.31026,0.31641,0.05,95.472 -10000,0.31026,0.31641,0.05,95.472 -10000,0.31026,0.31641,0.05,95.472 -10000,0.31026,0.31641,0.05,95.472 -10000,0.3164,0.32267,0.05,95.914 -10000,0.3164,0.32267,0.05,95.914 -10000,0.3164,0.32267,0.05,95.914 -10000,0.3164,0.32267,0.05,95.914 -10000,0.3164,0.32267,0.05,95.914 -10000,0.3164,0.32267,0.05,95.914 -10000,0.32266,0.32906,0.05,96.324 -10000,0.32266,0.32906,0.05,96.324 -10000,0.32266,0.32906,0.05,96.324 -10000,0.32266,0.32906,0.05,96.324 -10000,0.32266,0.32906,0.05,96.324 -10000,0.32266,0.32906,0.05,96.324 -10000,0.32266,0.32906,0.05,96.324 -10000,0.32905,0.33558,0.05,96.703 -10000,0.32905,0.33558,0.05,96.703 -10000,0.32905,0.33558,0.05,96.703 -10000,0.32905,0.33558,0.05,96.703 -10000,0.32905,0.33558,0.05,96.703 -10000,0.32905,0.33558,0.05,96.703 -10000,0.33556,0.34222,0.05,97.052 -10000,0.33556,0.34222,0.05,97.052 -10000,0.33556,0.34222,0.05,97.052 -10000,0.33556,0.34222,0.05,97.052 -10000,0.33556,0.34222,0.05,97.052 -10000,0.33556,0.34222,0.05,97.052 -10000,0.33556,0.34222,0.05,97.052 -10000,0.34221,0.34899,0.05,97.373 -10000,0.34221,0.34899,0.05,97.373 -10000,0.34221,0.34899,0.05,97.373 -10000,0.34221,0.34899,0.05,97.373 -10000,0.34221,0.34899,0.05,97.373 -10000,0.34221,0.34899,0.05,97.373 -10000,0.34221,0.34899,0.05,97.373 -10000,0.34898,0.3559,0.05,97.667 -10000,0.34898,0.3559,0.05,97.667 -10000,0.34898,0.3559,0.05,97.667 -10000,0.34898,0.3559,0.05,97.667 -10000,0.34898,0.3559,0.05,97.667 -10000,0.34898,0.3559,0.05,97.667 -10000,0.35589,0.36295,0.05,97.935 -10000,0.35589,0.36295,0.05,97.935 -10000,0.35589,0.36295,0.05,97.935 -10000,0.35589,0.36295,0.05,97.935 -10000,0.35589,0.36295,0.05,97.935 -10000,0.35589,0.36295,0.05,97.935 -10000,0.35589,0.36295,0.05,97.935 -10000,0.36294,0.37013,0.05,98.179 -10000,0.36294,0.37013,0.05,98.179 -10000,0.36294,0.37013,0.05,98.179 -10000,0.36294,0.37013,0.05,98.179 -10000,0.36294,0.37013,0.05,98.179 -10000,0.36294,0.37013,0.05,98.179 -10000,0.36294,0.37013,0.05,98.179 -10000,0.36294,0.37013,0.05,98.179 -10000,0.37012,0.37746,0.05,98.4 -10000,0.37012,0.37746,0.05,98.4 -10000,0.37012,0.37746,0.05,98.4 -10000,0.37012,0.37746,0.05,98.4 -10000,0.37012,0.37746,0.05,98.4 -10000,0.37012,0.37746,0.05,98.4 -10000,0.37012,0.37746,0.05,98.4 -10000,0.37745,0.38494,0.05,98.599 -10000,0.37745,0.38494,0.05,98.599 -10000,0.37745,0.38494,0.05,98.599 -10000,0.37745,0.38494,0.05,98.599 -10000,0.37745,0.38494,0.05,98.599 -10000,0.37745,0.38494,0.05,98.599 -10000,0.37745,0.38494,0.05,98.599 -10000,0.38493,0.39256,0.05,98.778 -10000,0.38493,0.39256,0.05,98.778 -10000,0.38493,0.39256,0.05,98.778 -10000,0.38493,0.39256,0.05,98.778 -10000,0.38493,0.39256,0.05,98.778 -10000,0.38493,0.39256,0.05,98.778 -10000,0.38493,0.39256,0.05,98.778 -10000,0.38493,0.39256,0.05,98.778 -10000,0.39255,0.40033,0.05,98.939 -10000,0.39255,0.40033,0.05,98.939 -10000,0.39255,0.40033,0.05,98.939 -10000,0.39255,0.40033,0.05,98.939 -10000,0.39255,0.40033,0.05,98.939 -10000,0.39255,0.40033,0.05,98.939 -10000,0.39255,0.40033,0.05,98.939 -10000,0.39255,0.40033,0.05,98.939 -10000,0.40032,0.40826,0.05,99.082 -10000,0.40032,0.40826,0.05,99.082 -10000,0.40032,0.40826,0.05,99.082 -10000,0.40032,0.40826,0.05,99.082 -10000,0.40032,0.40826,0.05,99.082 -10000,0.40032,0.40826,0.05,99.082 -10000,0.40032,0.40826,0.05,99.082 -10000,0.40032,0.40826,0.05,99.082 -10000,0.40825,0.41634,0.05,99.209 -10000,0.40825,0.41634,0.05,99.209 -10000,0.40825,0.41634,0.05,99.209 -10000,0.40825,0.41634,0.05,99.209 -10000,0.40825,0.41634,0.05,99.209 -10000,0.40825,0.41634,0.05,99.209 -10000,0.40825,0.41634,0.05,99.209 -10000,0.40825,0.41634,0.05,99.209 -10000,0.41633,0.42459,0.05,99.321 -10000,0.41633,0.42459,0.05,99.321 -10000,0.41633,0.42459,0.05,99.321 -10000,0.41633,0.42459,0.05,99.321 -10000,0.41633,0.42459,0.05,99.321 -10000,0.41633,0.42459,0.05,99.321 -10000,0.41633,0.42459,0.05,99.321 -10000,0.41633,0.42459,0.05,99.321 -10000,0.42458,0.433,0.05,99.42 -10000,0.42458,0.433,0.05,99.42 -10000,0.42458,0.433,0.05,99.42 -10000,0.42458,0.433,0.05,99.42 -10000,0.42458,0.433,0.05,99.42 -10000,0.42458,0.433,0.05,99.42 -10000,0.42458,0.433,0.05,99.42 -10000,0.42458,0.433,0.05,99.42 -10000,0.42458,0.433,0.05,99.42 -10000,0.43298,0.44157,0.05,99.507 -10000,0.43298,0.44157,0.05,99.507 -10000,0.43298,0.44157,0.05,99.507 -10000,0.43298,0.44157,0.05,99.507 -10000,0.43298,0.44157,0.05,99.507 -10000,0.43298,0.44157,0.05,99.507 -10000,0.43298,0.44157,0.05,99.507 -10000,0.43298,0.44157,0.05,99.507 -10000,0.44156,0.45031,0.05,99.583 -10000,0.44156,0.45031,0.05,99.583 -10000,0.44156,0.45031,0.05,99.583 -10000,0.44156,0.45031,0.05,99.583 -10000,0.44156,0.45031,0.05,99.583 -10000,0.44156,0.45031,0.05,99.583 -10000,0.44156,0.45031,0.05,99.583 -10000,0.44156,0.45031,0.05,99.583 -10000,0.44156,0.45031,0.05,99.583 -10000,0.4503,0.45923,0.05,99.649 -10000,0.4503,0.45923,0.05,99.649 -10000,0.4503,0.45923,0.05,99.649 -10000,0.4503,0.45923,0.05,99.649 -10000,0.4503,0.45923,0.05,99.649 -10000,0.4503,0.45923,0.05,99.649 -10000,0.4503,0.45923,0.05,99.649 -10000,0.4503,0.45923,0.05,99.649 -10000,0.4503,0.45923,0.05,99.649 -10000,0.45922,0.46833,0.05,99.706 -10000,0.45922,0.46833,0.05,99.706 -10000,0.45922,0.46833,0.05,99.706 -10000,0.45922,0.46833,0.05,99.706 -10000,0.45922,0.46833,0.05,99.706 -10000,0.45922,0.46833,0.05,99.706 -10000,0.45922,0.46833,0.05,99.706 -10000,0.45922,0.46833,0.05,99.706 -10000,0.45922,0.46833,0.05,99.706 -10000,0.46832,0.4776,0.05,99.754 -10000,0.46832,0.4776,0.05,99.754 -10000,0.46832,0.4776,0.05,99.754 -10000,0.46832,0.4776,0.05,99.754 -10000,0.46832,0.4776,0.05,99.754 -10000,0.46832,0.4776,0.05,99.754 -10000,0.46832,0.4776,0.05,99.754 -10000,0.46832,0.4776,0.05,99.754 -10000,0.46832,0.4776,0.05,99.754 -10000,0.47759,0.48706,0.05,99.796 -10000,0.47759,0.48706,0.05,99.796 -10000,0.47759,0.48706,0.05,99.796 -10000,0.47759,0.48706,0.05,99.796 -10000,0.47759,0.48706,0.05,99.796 -10000,0.47759,0.48706,0.05,99.796 -10000,0.47759,0.48706,0.05,99.796 -10000,0.47759,0.48706,0.05,99.796 -10000,0.47759,0.48706,0.05,99.796 -10000,0.47759,0.48706,0.05,99.796 -10000,0.48705,0.49671,0.05,99.832 -10000,0.48705,0.49671,0.05,99.832 -10000,0.48705,0.49671,0.05,99.832 -10000,0.48705,0.49671,0.05,99.832 -10000,0.48705,0.49671,0.05,99.832 -10000,0.48705,0.49671,0.05,99.832 -10000,0.48705,0.49671,0.05,99.832 -10000,0.48705,0.49671,0.05,99.832 -10000,0.48705,0.49671,0.05,99.832 -10000,0.4967,0.50655,0.05,99.862 -10000,0.4967,0.50655,0.05,99.862 -10000,0.4967,0.50655,0.05,99.862 -10000,0.4967,0.50655,0.05,99.862 -10000,0.4967,0.50655,0.05,99.862 -10000,0.4967,0.50655,0.05,99.862 -10000,0.4967,0.50655,0.05,99.862 -10000,0.4967,0.50655,0.05,99.862 -10000,0.4967,0.50655,0.05,99.862 -10000,0.4967,0.50655,0.05,99.862 -10000,0.50654,0.51658,0.05,99.887 -10000,0.50654,0.51658,0.05,99.887 -10000,0.50654,0.51658,0.05,99.887 -10000,0.50654,0.51658,0.05,99.887 -10000,0.50654,0.51658,0.05,99.887 -10000,0.50654,0.51658,0.05,99.887 -10000,0.50654,0.51658,0.05,99.887 -10000,0.50654,0.51658,0.05,99.887 -10000,0.50654,0.51658,0.05,99.887 -10000,0.50654,0.51658,0.05,99.887 -10000,0.51657,0.52681,0.05,99.908 -10000,0.51657,0.52681,0.05,99.908 -10000,0.51657,0.52681,0.05,99.908 -10000,0.51657,0.52681,0.05,99.908 -10000,0.51657,0.52681,0.05,99.908 -10000,0.51657,0.52681,0.05,99.908 -10000,0.51657,0.52681,0.05,99.908 -10000,0.51657,0.52681,0.05,99.908 -10000,0.51657,0.52681,0.05,99.908 -10000,0.51657,0.52681,0.05,99.908 -10000,0.5268,0.53725,0.05,99.926 -10000,0.5268,0.53725,0.05,99.926 -10000,0.5268,0.53725,0.05,99.926 -10000,0.5268,0.53725,0.05,99.926 -10000,0.5268,0.53725,0.05,99.926 -10000,0.5268,0.53725,0.05,99.926 -10000,0.5268,0.53725,0.05,99.926 -10000,0.5268,0.53725,0.05,99.926 -10000,0.5268,0.53725,0.05,99.926 -10000,0.5268,0.53725,0.05,99.926 -10000,0.5268,0.53725,0.05,99.926 -10000,0.53724,0.54789,0.05,99.941 -10000,0.53724,0.54789,0.05,99.941 -10000,0.53724,0.54789,0.05,99.941 -10000,0.53724,0.54789,0.05,99.941 -10000,0.53724,0.54789,0.05,99.941 -10000,0.53724,0.54789,0.05,99.941 -10000,0.53724,0.54789,0.05,99.941 -10000,0.53724,0.54789,0.05,99.941 -10000,0.53724,0.54789,0.05,99.941 -10000,0.53724,0.54789,0.05,99.941 -10000,0.54788,0.55874,0.05,99.953 -10000,0.54788,0.55874,0.05,99.953 -10000,0.54788,0.55874,0.05,99.953 -10000,0.54788,0.55874,0.05,99.953 -10000,0.54788,0.55874,0.05,99.953 -10000,0.54788,0.55874,0.05,99.953 -10000,0.54788,0.55874,0.05,99.953 -10000,0.54788,0.55874,0.05,99.953 -10000,0.54788,0.55874,0.05,99.953 -10000,0.54788,0.55874,0.05,99.953 -10000,0.54788,0.55874,0.05,99.953 -10000,0.55873,0.56981,0.05,99.962 -10000,0.55873,0.56981,0.05,99.962 -10000,0.55873,0.56981,0.05,99.962 -10000,0.55873,0.56981,0.05,99.962 -10000,0.55873,0.56981,0.05,99.962 -10000,0.55873,0.56981,0.05,99.962 -10000,0.55873,0.56981,0.05,99.962 -10000,0.55873,0.56981,0.05,99.962 -10000,0.55873,0.56981,0.05,99.962 -10000,0.55873,0.56981,0.05,99.962 -10000,0.55873,0.56981,0.05,99.962 -10000,0.5698,0.5811,0.05,99.97 -10000,0.5698,0.5811,0.05,99.97 -10000,0.5698,0.5811,0.05,99.97 -10000,0.5698,0.5811,0.05,99.97 -10000,0.5698,0.5811,0.05,99.97 -10000,0.5698,0.5811,0.05,99.97 -10000,0.5698,0.5811,0.05,99.97 -10000,0.5698,0.5811,0.05,99.97 -10000,0.5698,0.5811,0.05,99.97 -10000,0.5698,0.5811,0.05,99.97 -10000,0.5698,0.5811,0.05,99.97 -10000,0.5698,0.5811,0.05,99.97 -10000,0.58109,0.59261,0.05,99.977 -10000,0.58109,0.59261,0.05,99.977 -10000,0.58109,0.59261,0.05,99.977 -10000,0.58109,0.59261,0.05,99.977 -10000,0.58109,0.59261,0.05,99.977 -10000,0.58109,0.59261,0.05,99.977 -10000,0.58109,0.59261,0.05,99.977 -10000,0.58109,0.59261,0.05,99.977 -10000,0.58109,0.59261,0.05,99.977 -10000,0.58109,0.59261,0.05,99.977 -10000,0.58109,0.59261,0.05,99.977 -10000,0.5926,0.60435,0.05,99.982 -10000,0.5926,0.60435,0.05,99.982 -10000,0.5926,0.60435,0.05,99.982 -10000,0.5926,0.60435,0.05,99.982 -10000,0.5926,0.60435,0.05,99.982 -10000,0.5926,0.60435,0.05,99.982 -10000,0.5926,0.60435,0.05,99.982 -10000,0.5926,0.60435,0.05,99.982 -10000,0.5926,0.60435,0.05,99.982 -10000,0.5926,0.60435,0.05,99.982 -10000,0.5926,0.60435,0.05,99.982 -10000,0.5926,0.60435,0.05,99.982 -10000,0.60434,0.61632,0.05,99.986 -10000,0.60434,0.61632,0.05,99.986 -10000,0.60434,0.61632,0.05,99.986 -10000,0.60434,0.61632,0.05,99.986 -10000,0.60434,0.61632,0.05,99.986 -10000,0.60434,0.61632,0.05,99.986 -10000,0.60434,0.61632,0.05,99.986 -10000,0.60434,0.61632,0.05,99.986 -10000,0.60434,0.61632,0.05,99.986 -10000,0.60434,0.61632,0.05,99.986 -10000,0.60434,0.61632,0.05,99.986 -10000,0.60434,0.61632,0.05,99.986 -10000,0.61631,0.62853,0.05,99.99 -10000,0.61631,0.62853,0.05,99.99 -10000,0.61631,0.62853,0.05,99.99 -10000,0.61631,0.62853,0.05,99.99 -10000,0.61631,0.62853,0.05,99.99 -10000,0.61631,0.62853,0.05,99.99 -10000,0.61631,0.62853,0.05,99.99 -10000,0.61631,0.62853,0.05,99.99 -10000,0.61631,0.62853,0.05,99.99 -10000,0.61631,0.62853,0.05,99.99 -10000,0.61631,0.62853,0.05,99.99 -10000,0.61631,0.62853,0.05,99.99 -10000,0.62852,0.64098,0.05,99.992 -10000,0.62852,0.64098,0.05,99.992 -10000,0.62852,0.64098,0.05,99.992 -10000,0.62852,0.64098,0.05,99.992 -10000,0.62852,0.64098,0.05,99.992 -10000,0.62852,0.64098,0.05,99.992 -10000,0.62852,0.64098,0.05,99.992 -10000,0.62852,0.64098,0.05,99.992 -10000,0.62852,0.64098,0.05,99.992 -10000,0.62852,0.64098,0.05,99.992 -10000,0.62852,0.64098,0.05,99.992 -10000,0.62852,0.64098,0.05,99.992 -10000,0.62852,0.64098,0.05,99.992 -10000,0.64097,0.65368,0.05,99.994 -10000,0.64097,0.65368,0.05,99.994 -10000,0.64097,0.65368,0.05,99.994 -10000,0.64097,0.65368,0.05,99.994 -10000,0.64097,0.65368,0.05,99.994 -10000,0.64097,0.65368,0.05,99.994 -10000,0.64097,0.65368,0.05,99.994 -10000,0.64097,0.65368,0.05,99.994 -10000,0.64097,0.65368,0.05,99.994 -10000,0.64097,0.65368,0.05,99.994 -10000,0.64097,0.65368,0.05,99.994 -10000,0.64097,0.65368,0.05,99.994 -10000,0.65367,0.66663,0.05,99.996 -10000,0.65367,0.66663,0.05,99.996 -10000,0.65367,0.66663,0.05,99.996 -10000,0.65367,0.66663,0.05,99.996 -10000,0.65367,0.66663,0.05,99.996 -10000,0.65367,0.66663,0.05,99.996 -10000,0.65367,0.66663,0.05,99.996 -10000,0.65367,0.66663,0.05,99.996 -10000,0.65367,0.66663,0.05,99.996 -10000,0.65367,0.66663,0.05,99.996 -10000,0.65367,0.66663,0.05,99.996 -10000,0.65367,0.66663,0.05,99.996 -10000,0.65367,0.66663,0.05,99.996 -10000,0.66662,0.67984,0.05,99.997 -10000,0.66662,0.67984,0.05,99.997 -10000,0.66662,0.67984,0.05,99.997 -10000,0.66662,0.67984,0.05,99.997 -10000,0.66662,0.67984,0.05,99.997 -10000,0.66662,0.67984,0.05,99.997 -10000,0.66662,0.67984,0.05,99.997 -10000,0.66662,0.67984,0.05,99.997 -10000,0.66662,0.67984,0.05,99.997 -10000,0.66662,0.67984,0.05,99.997 -10000,0.66662,0.67984,0.05,99.997 -10000,0.66662,0.67984,0.05,99.997 -10000,0.66662,0.67984,0.05,99.997 -10000,0.67983,0.69331,0.05,99.998 -10000,0.67983,0.69331,0.05,99.998 -10000,0.67983,0.69331,0.05,99.998 -10000,0.67983,0.69331,0.05,99.998 -10000,0.67983,0.69331,0.05,99.998 -10000,0.67983,0.69331,0.05,99.998 -10000,0.67983,0.69331,0.05,99.998 -10000,0.67983,0.69331,0.05,99.998 -10000,0.67983,0.69331,0.05,99.998 -10000,0.67983,0.69331,0.05,99.998 -10000,0.67983,0.69331,0.05,99.998 -10000,0.67983,0.69331,0.05,99.998 -10000,0.67983,0.69331,0.05,99.998 -10000,0.67983,0.69331,0.05,99.998 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_10.csv b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_10.csv deleted file mode 100644 index 7980a3a5bfe..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_10.csv +++ /dev/null @@ -1,1002 +0,0 @@ -Time,"elementCenter:0","elementCenter:1","elementCenter:2","temperature" -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,0.07071,0.072112,0.05,-19.432 -1e+05,0.07071,0.072112,0.05,-19.432 -1e+05,0.07211,0.07354,0.05,-18.317 -1e+05,0.07351,0.074968,0.05,-17.224 -1e+05,0.075155,0.076646,0.05,-15.964 -1e+05,0.075155,0.076646,0.05,-15.964 -1e+05,0.077046,0.078574,0.05,-14.552 -1e+05,0.077046,0.078574,0.05,-14.552 -1e+05,0.078936,0.080501,0.05,-13.175 -1e+05,0.078936,0.080501,0.05,-13.175 -1e+05,0.080826,0.082429,0.05,-11.83 -1e+05,0.080826,0.082429,0.05,-11.83 -1e+05,0.082716,0.084357,0.05,-10.516 -1e+05,0.082716,0.084357,0.05,-10.516 -1e+05,0.084607,0.086285,0.05,-9.2319 -1e+05,0.084607,0.086285,0.05,-9.2319 -1e+05,0.086497,0.088212,0.05,-7.9764 -1e+05,0.086497,0.088212,0.05,-7.9764 -1e+05,0.088387,0.09014,0.05,-6.748 -1e+05,0.088387,0.09014,0.05,-6.748 -1e+05,0.090278,0.092068,0.05,-5.5458 -1e+05,0.090278,0.092068,0.05,-5.5458 -1e+05,0.092168,0.093995,0.05,-4.3685 -1e+05,0.092168,0.093995,0.05,-4.3685 -1e+05,0.094031,0.095896,0.05,-3.2318 -1e+05,0.095885,0.097786,0.05,-2.1226 -1e+05,0.095885,0.097786,0.05,-2.1226 -1e+05,0.097776,0.099715,0.05,-1.0134 -1e+05,0.097776,0.099715,0.05,-1.0134 -1e+05,0.099704,0.10168,0.05,0.095763 -1e+05,0.099704,0.10168,0.05,0.095763 -1e+05,0.10167,0.10369,0.05,1.2049 -1e+05,0.10167,0.10369,0.05,1.2049 -1e+05,0.10368,0.10573,0.05,2.3141 -1e+05,0.10368,0.10573,0.05,2.3141 -1e+05,0.10572,0.10782,0.05,3.4231 -1e+05,0.10572,0.10782,0.05,3.4231 -1e+05,0.10781,0.10995,0.05,4.5321 -1e+05,0.10781,0.10995,0.05,4.5321 -1e+05,0.10993,0.11211,0.05,5.641 -1e+05,0.10993,0.11211,0.05,5.641 -1e+05,0.10993,0.11211,0.05,5.641 -1e+05,0.1121,0.11433,0.05,6.7497 -1e+05,0.1121,0.11433,0.05,6.7497 -1e+05,0.11432,0.11658,0.05,7.8584 -1e+05,0.11432,0.11658,0.05,7.8584 -1e+05,0.11657,0.11888,0.05,8.9668 -1e+05,0.11657,0.11888,0.05,8.9668 -1e+05,0.11887,0.12123,0.05,10.075 -1e+05,0.11887,0.12123,0.05,10.075 -1e+05,0.11887,0.12123,0.05,10.075 -1e+05,0.12122,0.12362,0.05,11.183 -1e+05,0.12122,0.12362,0.05,11.183 -1e+05,0.12361,0.12607,0.05,12.291 -1e+05,0.12361,0.12607,0.05,12.291 -1e+05,0.12361,0.12607,0.05,12.291 -1e+05,0.12605,0.12855,0.05,13.399 -1e+05,0.12605,0.12855,0.05,13.399 -1e+05,0.12854,0.13109,0.05,14.506 -1e+05,0.12854,0.13109,0.05,14.506 -1e+05,0.12854,0.13109,0.05,14.506 -1e+05,0.13108,0.13368,0.05,15.613 -1e+05,0.13108,0.13368,0.05,15.613 -1e+05,0.13367,0.13632,0.05,16.72 -1e+05,0.13367,0.13632,0.05,16.72 -1e+05,0.13367,0.13632,0.05,16.72 -1e+05,0.13631,0.13901,0.05,17.826 -1e+05,0.13631,0.13901,0.05,17.826 -1e+05,0.13631,0.13901,0.05,17.826 -1e+05,0.139,0.14176,0.05,18.932 -1e+05,0.139,0.14176,0.05,18.932 -1e+05,0.14175,0.14456,0.05,20.037 -1e+05,0.14175,0.14456,0.05,20.037 -1e+05,0.14175,0.14456,0.05,20.037 -1e+05,0.14455,0.14742,0.05,21.142 -1e+05,0.14455,0.14742,0.05,21.142 -1e+05,0.14455,0.14742,0.05,21.142 -1e+05,0.1474,0.15033,0.05,22.246 -1e+05,0.1474,0.15033,0.05,22.246 -1e+05,0.1474,0.15033,0.05,22.246 -1e+05,0.15032,0.1533,0.05,23.35 -1e+05,0.15032,0.1533,0.05,23.35 -1e+05,0.15032,0.1533,0.05,23.35 -1e+05,0.15329,0.15633,0.05,24.453 -1e+05,0.15329,0.15633,0.05,24.453 -1e+05,0.15329,0.15633,0.05,24.453 -1e+05,0.15632,0.15942,0.05,25.556 -1e+05,0.15632,0.15942,0.05,25.556 -1e+05,0.15632,0.15942,0.05,25.556 -1e+05,0.15941,0.16257,0.05,26.658 -1e+05,0.15941,0.16257,0.05,26.658 -1e+05,0.15941,0.16257,0.05,26.658 -1e+05,0.16256,0.16578,0.05,27.759 -1e+05,0.16256,0.16578,0.05,27.759 -1e+05,0.16256,0.16578,0.05,27.759 -1e+05,0.16577,0.16906,0.05,28.859 -1e+05,0.16577,0.16906,0.05,28.859 -1e+05,0.16577,0.16906,0.05,28.859 -1e+05,0.16577,0.16906,0.05,28.859 -1e+05,0.16905,0.1724,0.05,29.959 -1e+05,0.16905,0.1724,0.05,29.959 -1e+05,0.16905,0.1724,0.05,29.959 -1e+05,0.17239,0.1758,0.05,31.057 -1e+05,0.17239,0.1758,0.05,31.057 -1e+05,0.17239,0.1758,0.05,31.057 -1e+05,0.17579,0.17928,0.05,32.155 -1e+05,0.17579,0.17928,0.05,32.155 -1e+05,0.17579,0.17928,0.05,32.155 -1e+05,0.17579,0.17928,0.05,32.155 -1e+05,0.17927,0.18282,0.05,33.251 -1e+05,0.17927,0.18282,0.05,33.251 -1e+05,0.17927,0.18282,0.05,33.251 -1e+05,0.18281,0.18644,0.05,34.346 -1e+05,0.18281,0.18644,0.05,34.346 -1e+05,0.18281,0.18644,0.05,34.346 -1e+05,0.18281,0.18644,0.05,34.346 -1e+05,0.18643,0.19013,0.05,35.441 -1e+05,0.18643,0.19013,0.05,35.441 -1e+05,0.18643,0.19013,0.05,35.441 -1e+05,0.18643,0.19013,0.05,35.441 -1e+05,0.19011,0.19388,0.05,36.534 -1e+05,0.19011,0.19388,0.05,36.534 -1e+05,0.19011,0.19388,0.05,36.534 -1e+05,0.19387,0.19772,0.05,37.625 -1e+05,0.19387,0.19772,0.05,37.625 -1e+05,0.19387,0.19772,0.05,37.625 -1e+05,0.19387,0.19772,0.05,37.625 -1e+05,0.19771,0.20163,0.05,38.715 -1e+05,0.19771,0.20163,0.05,38.715 -1e+05,0.19771,0.20163,0.05,38.715 -1e+05,0.19771,0.20163,0.05,38.715 -1e+05,0.20162,0.20562,0.05,39.804 -1e+05,0.20162,0.20562,0.05,39.804 -1e+05,0.20162,0.20562,0.05,39.804 -1e+05,0.20162,0.20562,0.05,39.804 -1e+05,0.2056,0.20968,0.05,40.891 -1e+05,0.2056,0.20968,0.05,40.891 -1e+05,0.2056,0.20968,0.05,40.891 -1e+05,0.2056,0.20968,0.05,40.891 -1e+05,0.20967,0.21383,0.05,41.976 -1e+05,0.20967,0.21383,0.05,41.976 -1e+05,0.20967,0.21383,0.05,41.976 -1e+05,0.20967,0.21383,0.05,41.976 -1e+05,0.21382,0.21806,0.05,43.06 -1e+05,0.21382,0.21806,0.05,43.06 -1e+05,0.21382,0.21806,0.05,43.06 -1e+05,0.21382,0.21806,0.05,43.06 -1e+05,0.21382,0.21806,0.05,43.06 -1e+05,0.21805,0.22237,0.05,44.142 -1e+05,0.21805,0.22237,0.05,44.142 -1e+05,0.21805,0.22237,0.05,44.142 -1e+05,0.21805,0.22237,0.05,44.142 -1e+05,0.22236,0.22677,0.05,45.222 -1e+05,0.22236,0.22677,0.05,45.222 -1e+05,0.22236,0.22677,0.05,45.222 -1e+05,0.22236,0.22677,0.05,45.222 -1e+05,0.22676,0.23125,0.05,46.299 -1e+05,0.22676,0.23125,0.05,46.299 -1e+05,0.22676,0.23125,0.05,46.299 -1e+05,0.22676,0.23125,0.05,46.299 -1e+05,0.22676,0.23125,0.05,46.299 -1e+05,0.23124,0.23583,0.05,47.375 -1e+05,0.23124,0.23583,0.05,47.375 -1e+05,0.23124,0.23583,0.05,47.375 -1e+05,0.23124,0.23583,0.05,47.375 -1e+05,0.23582,0.2405,0.05,48.448 -1e+05,0.23582,0.2405,0.05,48.448 -1e+05,0.23582,0.2405,0.05,48.448 -1e+05,0.23582,0.2405,0.05,48.448 -1e+05,0.23582,0.2405,0.05,48.448 -1e+05,0.24048,0.24525,0.05,49.519 -1e+05,0.24048,0.24525,0.05,49.519 -1e+05,0.24048,0.24525,0.05,49.519 -1e+05,0.24048,0.24525,0.05,49.519 -1e+05,0.24048,0.24525,0.05,49.519 -1e+05,0.24524,0.25011,0.05,50.587 -1e+05,0.24524,0.25011,0.05,50.587 -1e+05,0.24524,0.25011,0.05,50.587 -1e+05,0.24524,0.25011,0.05,50.587 -1e+05,0.24524,0.25011,0.05,50.587 -1e+05,0.25009,0.25505,0.05,51.653 -1e+05,0.25009,0.25505,0.05,51.653 -1e+05,0.25009,0.25505,0.05,51.653 -1e+05,0.25009,0.25505,0.05,51.653 -1e+05,0.25009,0.25505,0.05,51.653 -1e+05,0.25504,0.2601,0.05,52.715 -1e+05,0.25504,0.2601,0.05,52.715 -1e+05,0.25504,0.2601,0.05,52.715 -1e+05,0.25504,0.2601,0.05,52.715 -1e+05,0.25504,0.2601,0.05,52.715 -1e+05,0.26009,0.26525,0.05,53.775 -1e+05,0.26009,0.26525,0.05,53.775 -1e+05,0.26009,0.26525,0.05,53.775 -1e+05,0.26009,0.26525,0.05,53.775 -1e+05,0.26009,0.26525,0.05,53.775 -1e+05,0.26524,0.2705,0.05,54.832 -1e+05,0.26524,0.2705,0.05,54.832 -1e+05,0.26524,0.2705,0.05,54.832 -1e+05,0.26524,0.2705,0.05,54.832 -1e+05,0.26524,0.2705,0.05,54.832 -1e+05,0.27048,0.27585,0.05,55.885 -1e+05,0.27048,0.27585,0.05,55.885 -1e+05,0.27048,0.27585,0.05,55.885 -1e+05,0.27048,0.27585,0.05,55.885 -1e+05,0.27048,0.27585,0.05,55.885 -1e+05,0.27584,0.28131,0.05,56.935 -1e+05,0.27584,0.28131,0.05,56.935 -1e+05,0.27584,0.28131,0.05,56.935 -1e+05,0.27584,0.28131,0.05,56.935 -1e+05,0.27584,0.28131,0.05,56.935 -1e+05,0.27584,0.28131,0.05,56.935 -1e+05,0.2813,0.28687,0.05,57.982 -1e+05,0.2813,0.28687,0.05,57.982 -1e+05,0.2813,0.28687,0.05,57.982 -1e+05,0.2813,0.28687,0.05,57.982 -1e+05,0.2813,0.28687,0.05,57.982 -1e+05,0.28686,0.29255,0.05,59.025 -1e+05,0.28686,0.29255,0.05,59.025 -1e+05,0.28686,0.29255,0.05,59.025 -1e+05,0.28686,0.29255,0.05,59.025 -1e+05,0.28686,0.29255,0.05,59.025 -1e+05,0.28686,0.29255,0.05,59.025 -1e+05,0.29254,0.29834,0.05,60.063 -1e+05,0.29254,0.29834,0.05,60.063 -1e+05,0.29254,0.29834,0.05,60.063 -1e+05,0.29254,0.29834,0.05,60.063 -1e+05,0.29254,0.29834,0.05,60.063 -1e+05,0.29254,0.29834,0.05,60.063 -1e+05,0.29833,0.30425,0.05,61.098 -1e+05,0.29833,0.30425,0.05,61.098 -1e+05,0.29833,0.30425,0.05,61.098 -1e+05,0.29833,0.30425,0.05,61.098 -1e+05,0.29833,0.30425,0.05,61.098 -1e+05,0.29833,0.30425,0.05,61.098 -1e+05,0.30424,0.31027,0.05,62.129 -1e+05,0.30424,0.31027,0.05,62.129 -1e+05,0.30424,0.31027,0.05,62.129 -1e+05,0.30424,0.31027,0.05,62.129 -1e+05,0.30424,0.31027,0.05,62.129 -1e+05,0.30424,0.31027,0.05,62.129 -1e+05,0.31026,0.31641,0.05,63.155 -1e+05,0.31026,0.31641,0.05,63.155 -1e+05,0.31026,0.31641,0.05,63.155 -1e+05,0.31026,0.31641,0.05,63.155 -1e+05,0.31026,0.31641,0.05,63.155 -1e+05,0.31026,0.31641,0.05,63.155 -1e+05,0.3164,0.32267,0.05,64.177 -1e+05,0.3164,0.32267,0.05,64.177 -1e+05,0.3164,0.32267,0.05,64.177 -1e+05,0.3164,0.32267,0.05,64.177 -1e+05,0.3164,0.32267,0.05,64.177 -1e+05,0.3164,0.32267,0.05,64.177 -1e+05,0.32266,0.32906,0.05,65.194 -1e+05,0.32266,0.32906,0.05,65.194 -1e+05,0.32266,0.32906,0.05,65.194 -1e+05,0.32266,0.32906,0.05,65.194 -1e+05,0.32266,0.32906,0.05,65.194 -1e+05,0.32266,0.32906,0.05,65.194 -1e+05,0.32266,0.32906,0.05,65.194 -1e+05,0.32905,0.33558,0.05,66.205 -1e+05,0.32905,0.33558,0.05,66.205 -1e+05,0.32905,0.33558,0.05,66.205 -1e+05,0.32905,0.33558,0.05,66.205 -1e+05,0.32905,0.33558,0.05,66.205 -1e+05,0.32905,0.33558,0.05,66.205 -1e+05,0.33556,0.34222,0.05,67.212 -1e+05,0.33556,0.34222,0.05,67.212 -1e+05,0.33556,0.34222,0.05,67.212 -1e+05,0.33556,0.34222,0.05,67.212 -1e+05,0.33556,0.34222,0.05,67.212 -1e+05,0.33556,0.34222,0.05,67.212 -1e+05,0.33556,0.34222,0.05,67.212 -1e+05,0.34221,0.34899,0.05,68.214 -1e+05,0.34221,0.34899,0.05,68.214 -1e+05,0.34221,0.34899,0.05,68.214 -1e+05,0.34221,0.34899,0.05,68.214 -1e+05,0.34221,0.34899,0.05,68.214 -1e+05,0.34221,0.34899,0.05,68.214 -1e+05,0.34221,0.34899,0.05,68.214 -1e+05,0.34898,0.3559,0.05,69.209 -1e+05,0.34898,0.3559,0.05,69.209 -1e+05,0.34898,0.3559,0.05,69.209 -1e+05,0.34898,0.3559,0.05,69.209 -1e+05,0.34898,0.3559,0.05,69.209 -1e+05,0.34898,0.3559,0.05,69.209 -1e+05,0.35589,0.36295,0.05,70.2 -1e+05,0.35589,0.36295,0.05,70.2 -1e+05,0.35589,0.36295,0.05,70.2 -1e+05,0.35589,0.36295,0.05,70.2 -1e+05,0.35589,0.36295,0.05,70.2 -1e+05,0.35589,0.36295,0.05,70.2 -1e+05,0.35589,0.36295,0.05,70.2 -1e+05,0.36294,0.37013,0.05,71.184 -1e+05,0.36294,0.37013,0.05,71.184 -1e+05,0.36294,0.37013,0.05,71.184 -1e+05,0.36294,0.37013,0.05,71.184 -1e+05,0.36294,0.37013,0.05,71.184 -1e+05,0.36294,0.37013,0.05,71.184 -1e+05,0.36294,0.37013,0.05,71.184 -1e+05,0.36294,0.37013,0.05,71.184 -1e+05,0.37012,0.37746,0.05,72.162 -1e+05,0.37012,0.37746,0.05,72.162 -1e+05,0.37012,0.37746,0.05,72.162 -1e+05,0.37012,0.37746,0.05,72.162 -1e+05,0.37012,0.37746,0.05,72.162 -1e+05,0.37012,0.37746,0.05,72.162 -1e+05,0.37012,0.37746,0.05,72.162 -1e+05,0.37745,0.38494,0.05,73.134 -1e+05,0.37745,0.38494,0.05,73.134 -1e+05,0.37745,0.38494,0.05,73.134 -1e+05,0.37745,0.38494,0.05,73.134 -1e+05,0.37745,0.38494,0.05,73.134 -1e+05,0.37745,0.38494,0.05,73.134 -1e+05,0.37745,0.38494,0.05,73.134 -1e+05,0.38493,0.39256,0.05,74.099 -1e+05,0.38493,0.39256,0.05,74.099 -1e+05,0.38493,0.39256,0.05,74.099 -1e+05,0.38493,0.39256,0.05,74.099 -1e+05,0.38493,0.39256,0.05,74.099 -1e+05,0.38493,0.39256,0.05,74.099 -1e+05,0.38493,0.39256,0.05,74.099 -1e+05,0.38493,0.39256,0.05,74.099 -1e+05,0.39255,0.40033,0.05,75.057 -1e+05,0.39255,0.40033,0.05,75.057 -1e+05,0.39255,0.40033,0.05,75.057 -1e+05,0.39255,0.40033,0.05,75.057 -1e+05,0.39255,0.40033,0.05,75.057 -1e+05,0.39255,0.40033,0.05,75.057 -1e+05,0.39255,0.40033,0.05,75.057 -1e+05,0.39255,0.40033,0.05,75.057 -1e+05,0.40032,0.40826,0.05,76.009 -1e+05,0.40032,0.40826,0.05,76.009 -1e+05,0.40032,0.40826,0.05,76.009 -1e+05,0.40032,0.40826,0.05,76.009 -1e+05,0.40032,0.40826,0.05,76.009 -1e+05,0.40032,0.40826,0.05,76.009 -1e+05,0.40032,0.40826,0.05,76.009 -1e+05,0.40032,0.40826,0.05,76.009 -1e+05,0.40825,0.41634,0.05,76.954 -1e+05,0.40825,0.41634,0.05,76.954 -1e+05,0.40825,0.41634,0.05,76.954 -1e+05,0.40825,0.41634,0.05,76.954 -1e+05,0.40825,0.41634,0.05,76.954 -1e+05,0.40825,0.41634,0.05,76.954 -1e+05,0.40825,0.41634,0.05,76.954 -1e+05,0.40825,0.41634,0.05,76.954 -1e+05,0.41633,0.42459,0.05,77.891 -1e+05,0.41633,0.42459,0.05,77.891 -1e+05,0.41633,0.42459,0.05,77.891 -1e+05,0.41633,0.42459,0.05,77.891 -1e+05,0.41633,0.42459,0.05,77.891 -1e+05,0.41633,0.42459,0.05,77.891 -1e+05,0.41633,0.42459,0.05,77.891 -1e+05,0.41633,0.42459,0.05,77.891 -1e+05,0.42458,0.433,0.05,78.821 -1e+05,0.42458,0.433,0.05,78.821 -1e+05,0.42458,0.433,0.05,78.821 -1e+05,0.42458,0.433,0.05,78.821 -1e+05,0.42458,0.433,0.05,78.821 -1e+05,0.42458,0.433,0.05,78.821 -1e+05,0.42458,0.433,0.05,78.821 -1e+05,0.42458,0.433,0.05,78.821 -1e+05,0.42458,0.433,0.05,78.821 -1e+05,0.43298,0.44157,0.05,79.743 -1e+05,0.43298,0.44157,0.05,79.743 -1e+05,0.43298,0.44157,0.05,79.743 -1e+05,0.43298,0.44157,0.05,79.743 -1e+05,0.43298,0.44157,0.05,79.743 -1e+05,0.43298,0.44157,0.05,79.743 -1e+05,0.43298,0.44157,0.05,79.743 -1e+05,0.43298,0.44157,0.05,79.743 -1e+05,0.44156,0.45031,0.05,80.658 -1e+05,0.44156,0.45031,0.05,80.658 -1e+05,0.44156,0.45031,0.05,80.658 -1e+05,0.44156,0.45031,0.05,80.658 -1e+05,0.44156,0.45031,0.05,80.658 -1e+05,0.44156,0.45031,0.05,80.658 -1e+05,0.44156,0.45031,0.05,80.658 -1e+05,0.44156,0.45031,0.05,80.658 -1e+05,0.44156,0.45031,0.05,80.658 -1e+05,0.4503,0.45923,0.05,81.565 -1e+05,0.4503,0.45923,0.05,81.565 -1e+05,0.4503,0.45923,0.05,81.565 -1e+05,0.4503,0.45923,0.05,81.565 -1e+05,0.4503,0.45923,0.05,81.565 -1e+05,0.4503,0.45923,0.05,81.565 -1e+05,0.4503,0.45923,0.05,81.565 -1e+05,0.4503,0.45923,0.05,81.565 -1e+05,0.4503,0.45923,0.05,81.565 -1e+05,0.45922,0.46833,0.05,82.464 -1e+05,0.45922,0.46833,0.05,82.464 -1e+05,0.45922,0.46833,0.05,82.464 -1e+05,0.45922,0.46833,0.05,82.464 -1e+05,0.45922,0.46833,0.05,82.464 -1e+05,0.45922,0.46833,0.05,82.464 -1e+05,0.45922,0.46833,0.05,82.464 -1e+05,0.45922,0.46833,0.05,82.464 -1e+05,0.45922,0.46833,0.05,82.464 -1e+05,0.46832,0.4776,0.05,83.355 -1e+05,0.46832,0.4776,0.05,83.355 -1e+05,0.46832,0.4776,0.05,83.355 -1e+05,0.46832,0.4776,0.05,83.355 -1e+05,0.46832,0.4776,0.05,83.355 -1e+05,0.46832,0.4776,0.05,83.355 -1e+05,0.46832,0.4776,0.05,83.355 -1e+05,0.46832,0.4776,0.05,83.355 -1e+05,0.46832,0.4776,0.05,83.355 -1e+05,0.47759,0.48706,0.05,84.238 -1e+05,0.47759,0.48706,0.05,84.238 -1e+05,0.47759,0.48706,0.05,84.238 -1e+05,0.47759,0.48706,0.05,84.238 -1e+05,0.47759,0.48706,0.05,84.238 -1e+05,0.47759,0.48706,0.05,84.238 -1e+05,0.47759,0.48706,0.05,84.238 -1e+05,0.47759,0.48706,0.05,84.238 -1e+05,0.47759,0.48706,0.05,84.238 -1e+05,0.47759,0.48706,0.05,84.238 -1e+05,0.48705,0.49671,0.05,85.112 -1e+05,0.48705,0.49671,0.05,85.112 -1e+05,0.48705,0.49671,0.05,85.112 -1e+05,0.48705,0.49671,0.05,85.112 -1e+05,0.48705,0.49671,0.05,85.112 -1e+05,0.48705,0.49671,0.05,85.112 -1e+05,0.48705,0.49671,0.05,85.112 -1e+05,0.48705,0.49671,0.05,85.112 -1e+05,0.48705,0.49671,0.05,85.112 -1e+05,0.4967,0.50655,0.05,85.979 -1e+05,0.4967,0.50655,0.05,85.979 -1e+05,0.4967,0.50655,0.05,85.979 -1e+05,0.4967,0.50655,0.05,85.979 -1e+05,0.4967,0.50655,0.05,85.979 -1e+05,0.4967,0.50655,0.05,85.979 -1e+05,0.4967,0.50655,0.05,85.979 -1e+05,0.4967,0.50655,0.05,85.979 -1e+05,0.4967,0.50655,0.05,85.979 -1e+05,0.4967,0.50655,0.05,85.979 -1e+05,0.50654,0.51658,0.05,86.837 -1e+05,0.50654,0.51658,0.05,86.837 -1e+05,0.50654,0.51658,0.05,86.837 -1e+05,0.50654,0.51658,0.05,86.837 -1e+05,0.50654,0.51658,0.05,86.837 -1e+05,0.50654,0.51658,0.05,86.837 -1e+05,0.50654,0.51658,0.05,86.837 -1e+05,0.50654,0.51658,0.05,86.837 -1e+05,0.50654,0.51658,0.05,86.837 -1e+05,0.50654,0.51658,0.05,86.837 -1e+05,0.51657,0.52681,0.05,87.687 -1e+05,0.51657,0.52681,0.05,87.687 -1e+05,0.51657,0.52681,0.05,87.687 -1e+05,0.51657,0.52681,0.05,87.687 -1e+05,0.51657,0.52681,0.05,87.687 -1e+05,0.51657,0.52681,0.05,87.687 -1e+05,0.51657,0.52681,0.05,87.687 -1e+05,0.51657,0.52681,0.05,87.687 -1e+05,0.51657,0.52681,0.05,87.687 -1e+05,0.51657,0.52681,0.05,87.687 -1e+05,0.5268,0.53725,0.05,88.53 -1e+05,0.5268,0.53725,0.05,88.53 -1e+05,0.5268,0.53725,0.05,88.53 -1e+05,0.5268,0.53725,0.05,88.53 -1e+05,0.5268,0.53725,0.05,88.53 -1e+05,0.5268,0.53725,0.05,88.53 -1e+05,0.5268,0.53725,0.05,88.53 -1e+05,0.5268,0.53725,0.05,88.53 -1e+05,0.5268,0.53725,0.05,88.53 -1e+05,0.5268,0.53725,0.05,88.53 -1e+05,0.5268,0.53725,0.05,88.53 -1e+05,0.53724,0.54789,0.05,89.364 -1e+05,0.53724,0.54789,0.05,89.364 -1e+05,0.53724,0.54789,0.05,89.364 -1e+05,0.53724,0.54789,0.05,89.364 -1e+05,0.53724,0.54789,0.05,89.364 -1e+05,0.53724,0.54789,0.05,89.364 -1e+05,0.53724,0.54789,0.05,89.364 -1e+05,0.53724,0.54789,0.05,89.364 -1e+05,0.53724,0.54789,0.05,89.364 -1e+05,0.53724,0.54789,0.05,89.364 -1e+05,0.54788,0.55874,0.05,90.19 -1e+05,0.54788,0.55874,0.05,90.19 -1e+05,0.54788,0.55874,0.05,90.19 -1e+05,0.54788,0.55874,0.05,90.19 -1e+05,0.54788,0.55874,0.05,90.19 -1e+05,0.54788,0.55874,0.05,90.19 -1e+05,0.54788,0.55874,0.05,90.19 -1e+05,0.54788,0.55874,0.05,90.19 -1e+05,0.54788,0.55874,0.05,90.19 -1e+05,0.54788,0.55874,0.05,90.19 -1e+05,0.54788,0.55874,0.05,90.19 -1e+05,0.55873,0.56981,0.05,91.009 -1e+05,0.55873,0.56981,0.05,91.009 -1e+05,0.55873,0.56981,0.05,91.009 -1e+05,0.55873,0.56981,0.05,91.009 -1e+05,0.55873,0.56981,0.05,91.009 -1e+05,0.55873,0.56981,0.05,91.009 -1e+05,0.55873,0.56981,0.05,91.009 -1e+05,0.55873,0.56981,0.05,91.009 -1e+05,0.55873,0.56981,0.05,91.009 -1e+05,0.55873,0.56981,0.05,91.009 -1e+05,0.55873,0.56981,0.05,91.009 -1e+05,0.5698,0.5811,0.05,91.82 -1e+05,0.5698,0.5811,0.05,91.82 -1e+05,0.5698,0.5811,0.05,91.82 -1e+05,0.5698,0.5811,0.05,91.82 -1e+05,0.5698,0.5811,0.05,91.82 -1e+05,0.5698,0.5811,0.05,91.82 -1e+05,0.5698,0.5811,0.05,91.82 -1e+05,0.5698,0.5811,0.05,91.82 -1e+05,0.5698,0.5811,0.05,91.82 -1e+05,0.5698,0.5811,0.05,91.82 -1e+05,0.5698,0.5811,0.05,91.82 -1e+05,0.5698,0.5811,0.05,91.82 -1e+05,0.58109,0.59261,0.05,92.624 -1e+05,0.58109,0.59261,0.05,92.624 -1e+05,0.58109,0.59261,0.05,92.624 -1e+05,0.58109,0.59261,0.05,92.624 -1e+05,0.58109,0.59261,0.05,92.624 -1e+05,0.58109,0.59261,0.05,92.624 -1e+05,0.58109,0.59261,0.05,92.624 -1e+05,0.58109,0.59261,0.05,92.624 -1e+05,0.58109,0.59261,0.05,92.624 -1e+05,0.58109,0.59261,0.05,92.624 -1e+05,0.58109,0.59261,0.05,92.624 -1e+05,0.5926,0.60435,0.05,93.422 -1e+05,0.5926,0.60435,0.05,93.422 -1e+05,0.5926,0.60435,0.05,93.422 -1e+05,0.5926,0.60435,0.05,93.422 -1e+05,0.5926,0.60435,0.05,93.422 -1e+05,0.5926,0.60435,0.05,93.422 -1e+05,0.5926,0.60435,0.05,93.422 -1e+05,0.5926,0.60435,0.05,93.422 -1e+05,0.5926,0.60435,0.05,93.422 -1e+05,0.5926,0.60435,0.05,93.422 -1e+05,0.5926,0.60435,0.05,93.422 -1e+05,0.5926,0.60435,0.05,93.422 -1e+05,0.60434,0.61632,0.05,94.213 -1e+05,0.60434,0.61632,0.05,94.213 -1e+05,0.60434,0.61632,0.05,94.213 -1e+05,0.60434,0.61632,0.05,94.213 -1e+05,0.60434,0.61632,0.05,94.213 -1e+05,0.60434,0.61632,0.05,94.213 -1e+05,0.60434,0.61632,0.05,94.213 -1e+05,0.60434,0.61632,0.05,94.213 -1e+05,0.60434,0.61632,0.05,94.213 -1e+05,0.60434,0.61632,0.05,94.213 -1e+05,0.60434,0.61632,0.05,94.213 -1e+05,0.60434,0.61632,0.05,94.213 -1e+05,0.61631,0.62853,0.05,94.998 -1e+05,0.61631,0.62853,0.05,94.998 -1e+05,0.61631,0.62853,0.05,94.998 -1e+05,0.61631,0.62853,0.05,94.998 -1e+05,0.61631,0.62853,0.05,94.998 -1e+05,0.61631,0.62853,0.05,94.998 -1e+05,0.61631,0.62853,0.05,94.998 -1e+05,0.61631,0.62853,0.05,94.998 -1e+05,0.61631,0.62853,0.05,94.998 -1e+05,0.61631,0.62853,0.05,94.998 -1e+05,0.61631,0.62853,0.05,94.998 -1e+05,0.61631,0.62853,0.05,94.998 -1e+05,0.62852,0.64098,0.05,95.778 -1e+05,0.62852,0.64098,0.05,95.778 -1e+05,0.62852,0.64098,0.05,95.778 -1e+05,0.62852,0.64098,0.05,95.778 -1e+05,0.62852,0.64098,0.05,95.778 -1e+05,0.62852,0.64098,0.05,95.778 -1e+05,0.62852,0.64098,0.05,95.778 -1e+05,0.62852,0.64098,0.05,95.778 -1e+05,0.62852,0.64098,0.05,95.778 -1e+05,0.62852,0.64098,0.05,95.778 -1e+05,0.62852,0.64098,0.05,95.778 -1e+05,0.62852,0.64098,0.05,95.778 -1e+05,0.62852,0.64098,0.05,95.778 -1e+05,0.64097,0.65368,0.05,96.553 -1e+05,0.64097,0.65368,0.05,96.553 -1e+05,0.64097,0.65368,0.05,96.553 -1e+05,0.64097,0.65368,0.05,96.553 -1e+05,0.64097,0.65368,0.05,96.553 -1e+05,0.64097,0.65368,0.05,96.553 -1e+05,0.64097,0.65368,0.05,96.553 -1e+05,0.64097,0.65368,0.05,96.553 -1e+05,0.64097,0.65368,0.05,96.553 -1e+05,0.64097,0.65368,0.05,96.553 -1e+05,0.64097,0.65368,0.05,96.553 -1e+05,0.64097,0.65368,0.05,96.553 -1e+05,0.65367,0.66663,0.05,97.325 -1e+05,0.65367,0.66663,0.05,97.325 -1e+05,0.65367,0.66663,0.05,97.325 -1e+05,0.65367,0.66663,0.05,97.325 -1e+05,0.65367,0.66663,0.05,97.325 -1e+05,0.65367,0.66663,0.05,97.325 -1e+05,0.65367,0.66663,0.05,97.325 -1e+05,0.65367,0.66663,0.05,97.325 -1e+05,0.65367,0.66663,0.05,97.325 -1e+05,0.65367,0.66663,0.05,97.325 -1e+05,0.65367,0.66663,0.05,97.325 -1e+05,0.65367,0.66663,0.05,97.325 -1e+05,0.65367,0.66663,0.05,97.325 -1e+05,0.66662,0.67984,0.05,98.093 -1e+05,0.66662,0.67984,0.05,98.093 -1e+05,0.66662,0.67984,0.05,98.093 -1e+05,0.66662,0.67984,0.05,98.093 -1e+05,0.66662,0.67984,0.05,98.093 -1e+05,0.66662,0.67984,0.05,98.093 -1e+05,0.66662,0.67984,0.05,98.093 -1e+05,0.66662,0.67984,0.05,98.093 -1e+05,0.66662,0.67984,0.05,98.093 -1e+05,0.66662,0.67984,0.05,98.093 -1e+05,0.66662,0.67984,0.05,98.093 -1e+05,0.66662,0.67984,0.05,98.093 -1e+05,0.66662,0.67984,0.05,98.093 -1e+05,0.67983,0.69331,0.05,98.858 -1e+05,0.67983,0.69331,0.05,98.858 -1e+05,0.67983,0.69331,0.05,98.858 -1e+05,0.67983,0.69331,0.05,98.858 -1e+05,0.67983,0.69331,0.05,98.858 -1e+05,0.67983,0.69331,0.05,98.858 -1e+05,0.67983,0.69331,0.05,98.858 -1e+05,0.67983,0.69331,0.05,98.858 -1e+05,0.67983,0.69331,0.05,98.858 -1e+05,0.67983,0.69331,0.05,98.858 -1e+05,0.67983,0.69331,0.05,98.858 -1e+05,0.67983,0.69331,0.05,98.858 -1e+05,0.67983,0.69331,0.05,98.858 -1e+05,0.67983,0.69331,0.05,98.858 -1e+05,0.6933,0.70704,0.05,99.622 -1e+05,0.6933,0.70704,0.05,99.622 -1e+05,0.6933,0.70704,0.05,99.622 -1e+05,0.6933,0.70704,0.05,99.622 -1e+05,0.6933,0.70704,0.05,99.622 -1e+05,0.6933,0.70704,0.05,99.622 -1e+05,0.6933,0.70704,0.05,99.622 -1e+05,0.6933,0.70704,0.05,99.622 -1e+05,0.6933,0.70704,0.05,99.622 -1e+05,0.6933,0.70704,0.05,99.622 -1e+05,0.6933,0.70704,0.05,99.622 -1e+05,0.6933,0.70704,0.05,99.622 -1e+05,0.6933,0.70704,0.05,99.622 -1e+05,0.6933,0.70704,0.05,99.622 -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_2.csv b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_2.csv deleted file mode 100644 index 898f12c9d0d..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_2.csv +++ /dev/null @@ -1,1002 +0,0 @@ -Time,"elementCenter:0","elementCenter:1","elementCenter:2","temperature" -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,0.07071,0.072112,0.05,-19.178 -20000,0.07071,0.072112,0.05,-19.178 -20000,0.07211,0.07354,0.05,-17.568 -20000,0.07351,0.074968,0.05,-15.988 -20000,0.075155,0.076646,0.05,-14.167 -20000,0.075155,0.076646,0.05,-14.167 -20000,0.077046,0.078574,0.05,-12.127 -20000,0.077046,0.078574,0.05,-12.127 -20000,0.078936,0.080501,0.05,-10.136 -20000,0.078936,0.080501,0.05,-10.136 -20000,0.080826,0.082429,0.05,-8.1938 -20000,0.080826,0.082429,0.05,-8.1938 -20000,0.082716,0.084357,0.05,-6.2968 -20000,0.082716,0.084357,0.05,-6.2968 -20000,0.084607,0.086285,0.05,-4.4434 -20000,0.084607,0.086285,0.05,-4.4434 -20000,0.086497,0.088212,0.05,-2.6319 -20000,0.086497,0.088212,0.05,-2.6319 -20000,0.088387,0.09014,0.05,-0.86037 -20000,0.088387,0.09014,0.05,-0.86037 -20000,0.090278,0.092068,0.05,0.87259 -20000,0.090278,0.092068,0.05,0.87259 -20000,0.092168,0.093995,0.05,2.5685 -20000,0.092168,0.093995,0.05,2.5685 -20000,0.094031,0.095896,0.05,4.2049 -20000,0.095885,0.097786,0.05,5.8006 -20000,0.095885,0.097786,0.05,5.8006 -20000,0.097776,0.099715,0.05,7.3951 -20000,0.097776,0.099715,0.05,7.3951 -20000,0.099704,0.10168,0.05,8.9883 -20000,0.099704,0.10168,0.05,8.9883 -20000,0.10167,0.10369,0.05,10.58 -20000,0.10167,0.10369,0.05,10.58 -20000,0.10368,0.10573,0.05,12.17 -20000,0.10368,0.10573,0.05,12.17 -20000,0.10572,0.10782,0.05,13.758 -20000,0.10572,0.10782,0.05,13.758 -20000,0.10781,0.10995,0.05,15.344 -20000,0.10781,0.10995,0.05,15.344 -20000,0.10993,0.11211,0.05,16.928 -20000,0.10993,0.11211,0.05,16.928 -20000,0.10993,0.11211,0.05,16.928 -20000,0.1121,0.11433,0.05,18.509 -20000,0.1121,0.11433,0.05,18.509 -20000,0.11432,0.11658,0.05,20.088 -20000,0.11432,0.11658,0.05,20.088 -20000,0.11657,0.11888,0.05,21.664 -20000,0.11657,0.11888,0.05,21.664 -20000,0.11887,0.12123,0.05,23.237 -20000,0.11887,0.12123,0.05,23.237 -20000,0.11887,0.12123,0.05,23.237 -20000,0.12122,0.12362,0.05,24.806 -20000,0.12122,0.12362,0.05,24.806 -20000,0.12361,0.12607,0.05,26.372 -20000,0.12361,0.12607,0.05,26.372 -20000,0.12361,0.12607,0.05,26.372 -20000,0.12605,0.12855,0.05,27.933 -20000,0.12605,0.12855,0.05,27.933 -20000,0.12854,0.13109,0.05,29.491 -20000,0.12854,0.13109,0.05,29.491 -20000,0.12854,0.13109,0.05,29.491 -20000,0.13108,0.13368,0.05,31.044 -20000,0.13108,0.13368,0.05,31.044 -20000,0.13367,0.13632,0.05,32.592 -20000,0.13367,0.13632,0.05,32.592 -20000,0.13367,0.13632,0.05,32.592 -20000,0.13631,0.13901,0.05,34.135 -20000,0.13631,0.13901,0.05,34.135 -20000,0.13631,0.13901,0.05,34.135 -20000,0.139,0.14176,0.05,35.673 -20000,0.139,0.14176,0.05,35.673 -20000,0.14175,0.14456,0.05,37.204 -20000,0.14175,0.14456,0.05,37.204 -20000,0.14175,0.14456,0.05,37.204 -20000,0.14455,0.14742,0.05,38.73 -20000,0.14455,0.14742,0.05,38.73 -20000,0.14455,0.14742,0.05,38.73 -20000,0.1474,0.15033,0.05,40.248 -20000,0.1474,0.15033,0.05,40.248 -20000,0.1474,0.15033,0.05,40.248 -20000,0.15032,0.1533,0.05,41.76 -20000,0.15032,0.1533,0.05,41.76 -20000,0.15032,0.1533,0.05,41.76 -20000,0.15329,0.15633,0.05,43.264 -20000,0.15329,0.15633,0.05,43.264 -20000,0.15329,0.15633,0.05,43.264 -20000,0.15632,0.15942,0.05,44.76 -20000,0.15632,0.15942,0.05,44.76 -20000,0.15632,0.15942,0.05,44.76 -20000,0.15941,0.16257,0.05,46.248 -20000,0.15941,0.16257,0.05,46.248 -20000,0.15941,0.16257,0.05,46.248 -20000,0.16256,0.16578,0.05,47.726 -20000,0.16256,0.16578,0.05,47.726 -20000,0.16256,0.16578,0.05,47.726 -20000,0.16577,0.16906,0.05,49.195 -20000,0.16577,0.16906,0.05,49.195 -20000,0.16577,0.16906,0.05,49.195 -20000,0.16577,0.16906,0.05,49.195 -20000,0.16905,0.1724,0.05,50.655 -20000,0.16905,0.1724,0.05,50.655 -20000,0.16905,0.1724,0.05,50.655 -20000,0.17239,0.1758,0.05,52.103 -20000,0.17239,0.1758,0.05,52.103 -20000,0.17239,0.1758,0.05,52.103 -20000,0.17579,0.17928,0.05,53.541 -20000,0.17579,0.17928,0.05,53.541 -20000,0.17579,0.17928,0.05,53.541 -20000,0.17579,0.17928,0.05,53.541 -20000,0.17927,0.18282,0.05,54.967 -20000,0.17927,0.18282,0.05,54.967 -20000,0.17927,0.18282,0.05,54.967 -20000,0.18281,0.18644,0.05,56.381 -20000,0.18281,0.18644,0.05,56.381 -20000,0.18281,0.18644,0.05,56.381 -20000,0.18281,0.18644,0.05,56.381 -20000,0.18643,0.19013,0.05,57.781 -20000,0.18643,0.19013,0.05,57.781 -20000,0.18643,0.19013,0.05,57.781 -20000,0.18643,0.19013,0.05,57.781 -20000,0.19011,0.19388,0.05,59.169 -20000,0.19011,0.19388,0.05,59.169 -20000,0.19011,0.19388,0.05,59.169 -20000,0.19387,0.19772,0.05,60.542 -20000,0.19387,0.19772,0.05,60.542 -20000,0.19387,0.19772,0.05,60.542 -20000,0.19387,0.19772,0.05,60.542 -20000,0.19771,0.20163,0.05,61.9 -20000,0.19771,0.20163,0.05,61.9 -20000,0.19771,0.20163,0.05,61.9 -20000,0.19771,0.20163,0.05,61.9 -20000,0.20162,0.20562,0.05,63.243 -20000,0.20162,0.20562,0.05,63.243 -20000,0.20162,0.20562,0.05,63.243 -20000,0.20162,0.20562,0.05,63.243 -20000,0.2056,0.20968,0.05,64.57 -20000,0.2056,0.20968,0.05,64.57 -20000,0.2056,0.20968,0.05,64.57 -20000,0.2056,0.20968,0.05,64.57 -20000,0.20967,0.21383,0.05,65.88 -20000,0.20967,0.21383,0.05,65.88 -20000,0.20967,0.21383,0.05,65.88 -20000,0.20967,0.21383,0.05,65.88 -20000,0.21382,0.21806,0.05,67.173 -20000,0.21382,0.21806,0.05,67.173 -20000,0.21382,0.21806,0.05,67.173 -20000,0.21382,0.21806,0.05,67.173 -20000,0.21382,0.21806,0.05,67.173 -20000,0.21805,0.22237,0.05,68.447 -20000,0.21805,0.22237,0.05,68.447 -20000,0.21805,0.22237,0.05,68.447 -20000,0.21805,0.22237,0.05,68.447 -20000,0.22236,0.22677,0.05,69.702 -20000,0.22236,0.22677,0.05,69.702 -20000,0.22236,0.22677,0.05,69.702 -20000,0.22236,0.22677,0.05,69.702 -20000,0.22676,0.23125,0.05,70.938 -20000,0.22676,0.23125,0.05,70.938 -20000,0.22676,0.23125,0.05,70.938 -20000,0.22676,0.23125,0.05,70.938 -20000,0.22676,0.23125,0.05,70.938 -20000,0.23124,0.23583,0.05,72.153 -20000,0.23124,0.23583,0.05,72.153 -20000,0.23124,0.23583,0.05,72.153 -20000,0.23124,0.23583,0.05,72.153 -20000,0.23582,0.2405,0.05,73.347 -20000,0.23582,0.2405,0.05,73.347 -20000,0.23582,0.2405,0.05,73.347 -20000,0.23582,0.2405,0.05,73.347 -20000,0.23582,0.2405,0.05,73.347 -20000,0.24048,0.24525,0.05,74.519 -20000,0.24048,0.24525,0.05,74.519 -20000,0.24048,0.24525,0.05,74.519 -20000,0.24048,0.24525,0.05,74.519 -20000,0.24048,0.24525,0.05,74.519 -20000,0.24524,0.25011,0.05,75.669 -20000,0.24524,0.25011,0.05,75.669 -20000,0.24524,0.25011,0.05,75.669 -20000,0.24524,0.25011,0.05,75.669 -20000,0.24524,0.25011,0.05,75.669 -20000,0.25009,0.25505,0.05,76.796 -20000,0.25009,0.25505,0.05,76.796 -20000,0.25009,0.25505,0.05,76.796 -20000,0.25009,0.25505,0.05,76.796 -20000,0.25009,0.25505,0.05,76.796 -20000,0.25504,0.2601,0.05,77.898 -20000,0.25504,0.2601,0.05,77.898 -20000,0.25504,0.2601,0.05,77.898 -20000,0.25504,0.2601,0.05,77.898 -20000,0.25504,0.2601,0.05,77.898 -20000,0.26009,0.26525,0.05,78.976 -20000,0.26009,0.26525,0.05,78.976 -20000,0.26009,0.26525,0.05,78.976 -20000,0.26009,0.26525,0.05,78.976 -20000,0.26009,0.26525,0.05,78.976 -20000,0.26524,0.2705,0.05,80.029 -20000,0.26524,0.2705,0.05,80.029 -20000,0.26524,0.2705,0.05,80.029 -20000,0.26524,0.2705,0.05,80.029 -20000,0.26524,0.2705,0.05,80.029 -20000,0.27048,0.27585,0.05,81.055 -20000,0.27048,0.27585,0.05,81.055 -20000,0.27048,0.27585,0.05,81.055 -20000,0.27048,0.27585,0.05,81.055 -20000,0.27048,0.27585,0.05,81.055 -20000,0.27584,0.28131,0.05,82.055 -20000,0.27584,0.28131,0.05,82.055 -20000,0.27584,0.28131,0.05,82.055 -20000,0.27584,0.28131,0.05,82.055 -20000,0.27584,0.28131,0.05,82.055 -20000,0.27584,0.28131,0.05,82.055 -20000,0.2813,0.28687,0.05,83.028 -20000,0.2813,0.28687,0.05,83.028 -20000,0.2813,0.28687,0.05,83.028 -20000,0.2813,0.28687,0.05,83.028 -20000,0.2813,0.28687,0.05,83.028 -20000,0.28686,0.29255,0.05,83.973 -20000,0.28686,0.29255,0.05,83.973 -20000,0.28686,0.29255,0.05,83.973 -20000,0.28686,0.29255,0.05,83.973 -20000,0.28686,0.29255,0.05,83.973 -20000,0.28686,0.29255,0.05,83.973 -20000,0.29254,0.29834,0.05,84.89 -20000,0.29254,0.29834,0.05,84.89 -20000,0.29254,0.29834,0.05,84.89 -20000,0.29254,0.29834,0.05,84.89 -20000,0.29254,0.29834,0.05,84.89 -20000,0.29254,0.29834,0.05,84.89 -20000,0.29833,0.30425,0.05,85.779 -20000,0.29833,0.30425,0.05,85.779 -20000,0.29833,0.30425,0.05,85.779 -20000,0.29833,0.30425,0.05,85.779 -20000,0.29833,0.30425,0.05,85.779 -20000,0.29833,0.30425,0.05,85.779 -20000,0.30424,0.31027,0.05,86.638 -20000,0.30424,0.31027,0.05,86.638 -20000,0.30424,0.31027,0.05,86.638 -20000,0.30424,0.31027,0.05,86.638 -20000,0.30424,0.31027,0.05,86.638 -20000,0.30424,0.31027,0.05,86.638 -20000,0.31026,0.31641,0.05,87.468 -20000,0.31026,0.31641,0.05,87.468 -20000,0.31026,0.31641,0.05,87.468 -20000,0.31026,0.31641,0.05,87.468 -20000,0.31026,0.31641,0.05,87.468 -20000,0.31026,0.31641,0.05,87.468 -20000,0.3164,0.32267,0.05,88.268 -20000,0.3164,0.32267,0.05,88.268 -20000,0.3164,0.32267,0.05,88.268 -20000,0.3164,0.32267,0.05,88.268 -20000,0.3164,0.32267,0.05,88.268 -20000,0.3164,0.32267,0.05,88.268 -20000,0.32266,0.32906,0.05,89.038 -20000,0.32266,0.32906,0.05,89.038 -20000,0.32266,0.32906,0.05,89.038 -20000,0.32266,0.32906,0.05,89.038 -20000,0.32266,0.32906,0.05,89.038 -20000,0.32266,0.32906,0.05,89.038 -20000,0.32266,0.32906,0.05,89.038 -20000,0.32905,0.33558,0.05,89.778 -20000,0.32905,0.33558,0.05,89.778 -20000,0.32905,0.33558,0.05,89.778 -20000,0.32905,0.33558,0.05,89.778 -20000,0.32905,0.33558,0.05,89.778 -20000,0.32905,0.33558,0.05,89.778 -20000,0.33556,0.34222,0.05,90.487 -20000,0.33556,0.34222,0.05,90.487 -20000,0.33556,0.34222,0.05,90.487 -20000,0.33556,0.34222,0.05,90.487 -20000,0.33556,0.34222,0.05,90.487 -20000,0.33556,0.34222,0.05,90.487 -20000,0.33556,0.34222,0.05,90.487 -20000,0.34221,0.34899,0.05,91.166 -20000,0.34221,0.34899,0.05,91.166 -20000,0.34221,0.34899,0.05,91.166 -20000,0.34221,0.34899,0.05,91.166 -20000,0.34221,0.34899,0.05,91.166 -20000,0.34221,0.34899,0.05,91.166 -20000,0.34221,0.34899,0.05,91.166 -20000,0.34898,0.3559,0.05,91.815 -20000,0.34898,0.3559,0.05,91.815 -20000,0.34898,0.3559,0.05,91.815 -20000,0.34898,0.3559,0.05,91.815 -20000,0.34898,0.3559,0.05,91.815 -20000,0.34898,0.3559,0.05,91.815 -20000,0.35589,0.36295,0.05,92.433 -20000,0.35589,0.36295,0.05,92.433 -20000,0.35589,0.36295,0.05,92.433 -20000,0.35589,0.36295,0.05,92.433 -20000,0.35589,0.36295,0.05,92.433 -20000,0.35589,0.36295,0.05,92.433 -20000,0.35589,0.36295,0.05,92.433 -20000,0.36294,0.37013,0.05,93.02 -20000,0.36294,0.37013,0.05,93.02 -20000,0.36294,0.37013,0.05,93.02 -20000,0.36294,0.37013,0.05,93.02 -20000,0.36294,0.37013,0.05,93.02 -20000,0.36294,0.37013,0.05,93.02 -20000,0.36294,0.37013,0.05,93.02 -20000,0.36294,0.37013,0.05,93.02 -20000,0.37012,0.37746,0.05,93.578 -20000,0.37012,0.37746,0.05,93.578 -20000,0.37012,0.37746,0.05,93.578 -20000,0.37012,0.37746,0.05,93.578 -20000,0.37012,0.37746,0.05,93.578 -20000,0.37012,0.37746,0.05,93.578 -20000,0.37012,0.37746,0.05,93.578 -20000,0.37745,0.38494,0.05,94.106 -20000,0.37745,0.38494,0.05,94.106 -20000,0.37745,0.38494,0.05,94.106 -20000,0.37745,0.38494,0.05,94.106 -20000,0.37745,0.38494,0.05,94.106 -20000,0.37745,0.38494,0.05,94.106 -20000,0.37745,0.38494,0.05,94.106 -20000,0.38493,0.39256,0.05,94.604 -20000,0.38493,0.39256,0.05,94.604 -20000,0.38493,0.39256,0.05,94.604 -20000,0.38493,0.39256,0.05,94.604 -20000,0.38493,0.39256,0.05,94.604 -20000,0.38493,0.39256,0.05,94.604 -20000,0.38493,0.39256,0.05,94.604 -20000,0.38493,0.39256,0.05,94.604 -20000,0.39255,0.40033,0.05,95.074 -20000,0.39255,0.40033,0.05,95.074 -20000,0.39255,0.40033,0.05,95.074 -20000,0.39255,0.40033,0.05,95.074 -20000,0.39255,0.40033,0.05,95.074 -20000,0.39255,0.40033,0.05,95.074 -20000,0.39255,0.40033,0.05,95.074 -20000,0.39255,0.40033,0.05,95.074 -20000,0.40032,0.40826,0.05,95.515 -20000,0.40032,0.40826,0.05,95.515 -20000,0.40032,0.40826,0.05,95.515 -20000,0.40032,0.40826,0.05,95.515 -20000,0.40032,0.40826,0.05,95.515 -20000,0.40032,0.40826,0.05,95.515 -20000,0.40032,0.40826,0.05,95.515 -20000,0.40032,0.40826,0.05,95.515 -20000,0.40825,0.41634,0.05,95.929 -20000,0.40825,0.41634,0.05,95.929 -20000,0.40825,0.41634,0.05,95.929 -20000,0.40825,0.41634,0.05,95.929 -20000,0.40825,0.41634,0.05,95.929 -20000,0.40825,0.41634,0.05,95.929 -20000,0.40825,0.41634,0.05,95.929 -20000,0.40825,0.41634,0.05,95.929 -20000,0.41633,0.42459,0.05,96.315 -20000,0.41633,0.42459,0.05,96.315 -20000,0.41633,0.42459,0.05,96.315 -20000,0.41633,0.42459,0.05,96.315 -20000,0.41633,0.42459,0.05,96.315 -20000,0.41633,0.42459,0.05,96.315 -20000,0.41633,0.42459,0.05,96.315 -20000,0.41633,0.42459,0.05,96.315 -20000,0.42458,0.433,0.05,96.674 -20000,0.42458,0.433,0.05,96.674 -20000,0.42458,0.433,0.05,96.674 -20000,0.42458,0.433,0.05,96.674 -20000,0.42458,0.433,0.05,96.674 -20000,0.42458,0.433,0.05,96.674 -20000,0.42458,0.433,0.05,96.674 -20000,0.42458,0.433,0.05,96.674 -20000,0.42458,0.433,0.05,96.674 -20000,0.43298,0.44157,0.05,97.009 -20000,0.43298,0.44157,0.05,97.009 -20000,0.43298,0.44157,0.05,97.009 -20000,0.43298,0.44157,0.05,97.009 -20000,0.43298,0.44157,0.05,97.009 -20000,0.43298,0.44157,0.05,97.009 -20000,0.43298,0.44157,0.05,97.009 -20000,0.43298,0.44157,0.05,97.009 -20000,0.44156,0.45031,0.05,97.318 -20000,0.44156,0.45031,0.05,97.318 -20000,0.44156,0.45031,0.05,97.318 -20000,0.44156,0.45031,0.05,97.318 -20000,0.44156,0.45031,0.05,97.318 -20000,0.44156,0.45031,0.05,97.318 -20000,0.44156,0.45031,0.05,97.318 -20000,0.44156,0.45031,0.05,97.318 -20000,0.44156,0.45031,0.05,97.318 -20000,0.4503,0.45923,0.05,97.603 -20000,0.4503,0.45923,0.05,97.603 -20000,0.4503,0.45923,0.05,97.603 -20000,0.4503,0.45923,0.05,97.603 -20000,0.4503,0.45923,0.05,97.603 -20000,0.4503,0.45923,0.05,97.603 -20000,0.4503,0.45923,0.05,97.603 -20000,0.4503,0.45923,0.05,97.603 -20000,0.4503,0.45923,0.05,97.603 -20000,0.45922,0.46833,0.05,97.866 -20000,0.45922,0.46833,0.05,97.866 -20000,0.45922,0.46833,0.05,97.866 -20000,0.45922,0.46833,0.05,97.866 -20000,0.45922,0.46833,0.05,97.866 -20000,0.45922,0.46833,0.05,97.866 -20000,0.45922,0.46833,0.05,97.866 -20000,0.45922,0.46833,0.05,97.866 -20000,0.45922,0.46833,0.05,97.866 -20000,0.46832,0.4776,0.05,98.107 -20000,0.46832,0.4776,0.05,98.107 -20000,0.46832,0.4776,0.05,98.107 -20000,0.46832,0.4776,0.05,98.107 -20000,0.46832,0.4776,0.05,98.107 -20000,0.46832,0.4776,0.05,98.107 -20000,0.46832,0.4776,0.05,98.107 -20000,0.46832,0.4776,0.05,98.107 -20000,0.46832,0.4776,0.05,98.107 -20000,0.47759,0.48706,0.05,98.327 -20000,0.47759,0.48706,0.05,98.327 -20000,0.47759,0.48706,0.05,98.327 -20000,0.47759,0.48706,0.05,98.327 -20000,0.47759,0.48706,0.05,98.327 -20000,0.47759,0.48706,0.05,98.327 -20000,0.47759,0.48706,0.05,98.327 -20000,0.47759,0.48706,0.05,98.327 -20000,0.47759,0.48706,0.05,98.327 -20000,0.47759,0.48706,0.05,98.327 -20000,0.48705,0.49671,0.05,98.527 -20000,0.48705,0.49671,0.05,98.527 -20000,0.48705,0.49671,0.05,98.527 -20000,0.48705,0.49671,0.05,98.527 -20000,0.48705,0.49671,0.05,98.527 -20000,0.48705,0.49671,0.05,98.527 -20000,0.48705,0.49671,0.05,98.527 -20000,0.48705,0.49671,0.05,98.527 -20000,0.48705,0.49671,0.05,98.527 -20000,0.4967,0.50655,0.05,98.708 -20000,0.4967,0.50655,0.05,98.708 -20000,0.4967,0.50655,0.05,98.708 -20000,0.4967,0.50655,0.05,98.708 -20000,0.4967,0.50655,0.05,98.708 -20000,0.4967,0.50655,0.05,98.708 -20000,0.4967,0.50655,0.05,98.708 -20000,0.4967,0.50655,0.05,98.708 -20000,0.4967,0.50655,0.05,98.708 -20000,0.4967,0.50655,0.05,98.708 -20000,0.50654,0.51658,0.05,98.872 -20000,0.50654,0.51658,0.05,98.872 -20000,0.50654,0.51658,0.05,98.872 -20000,0.50654,0.51658,0.05,98.872 -20000,0.50654,0.51658,0.05,98.872 -20000,0.50654,0.51658,0.05,98.872 -20000,0.50654,0.51658,0.05,98.872 -20000,0.50654,0.51658,0.05,98.872 -20000,0.50654,0.51658,0.05,98.872 -20000,0.50654,0.51658,0.05,98.872 -20000,0.51657,0.52681,0.05,99.019 -20000,0.51657,0.52681,0.05,99.019 -20000,0.51657,0.52681,0.05,99.019 -20000,0.51657,0.52681,0.05,99.019 -20000,0.51657,0.52681,0.05,99.019 -20000,0.51657,0.52681,0.05,99.019 -20000,0.51657,0.52681,0.05,99.019 -20000,0.51657,0.52681,0.05,99.019 -20000,0.51657,0.52681,0.05,99.019 -20000,0.51657,0.52681,0.05,99.019 -20000,0.5268,0.53725,0.05,99.152 -20000,0.5268,0.53725,0.05,99.152 -20000,0.5268,0.53725,0.05,99.152 -20000,0.5268,0.53725,0.05,99.152 -20000,0.5268,0.53725,0.05,99.152 -20000,0.5268,0.53725,0.05,99.152 -20000,0.5268,0.53725,0.05,99.152 -20000,0.5268,0.53725,0.05,99.152 -20000,0.5268,0.53725,0.05,99.152 -20000,0.5268,0.53725,0.05,99.152 -20000,0.5268,0.53725,0.05,99.152 -20000,0.53724,0.54789,0.05,99.27 -20000,0.53724,0.54789,0.05,99.27 -20000,0.53724,0.54789,0.05,99.27 -20000,0.53724,0.54789,0.05,99.27 -20000,0.53724,0.54789,0.05,99.27 -20000,0.53724,0.54789,0.05,99.27 -20000,0.53724,0.54789,0.05,99.27 -20000,0.53724,0.54789,0.05,99.27 -20000,0.53724,0.54789,0.05,99.27 -20000,0.53724,0.54789,0.05,99.27 -20000,0.54788,0.55874,0.05,99.374 -20000,0.54788,0.55874,0.05,99.374 -20000,0.54788,0.55874,0.05,99.374 -20000,0.54788,0.55874,0.05,99.374 -20000,0.54788,0.55874,0.05,99.374 -20000,0.54788,0.55874,0.05,99.374 -20000,0.54788,0.55874,0.05,99.374 -20000,0.54788,0.55874,0.05,99.374 -20000,0.54788,0.55874,0.05,99.374 -20000,0.54788,0.55874,0.05,99.374 -20000,0.54788,0.55874,0.05,99.374 -20000,0.55873,0.56981,0.05,99.467 -20000,0.55873,0.56981,0.05,99.467 -20000,0.55873,0.56981,0.05,99.467 -20000,0.55873,0.56981,0.05,99.467 -20000,0.55873,0.56981,0.05,99.467 -20000,0.55873,0.56981,0.05,99.467 -20000,0.55873,0.56981,0.05,99.467 -20000,0.55873,0.56981,0.05,99.467 -20000,0.55873,0.56981,0.05,99.467 -20000,0.55873,0.56981,0.05,99.467 -20000,0.55873,0.56981,0.05,99.467 -20000,0.5698,0.5811,0.05,99.549 -20000,0.5698,0.5811,0.05,99.549 -20000,0.5698,0.5811,0.05,99.549 -20000,0.5698,0.5811,0.05,99.549 -20000,0.5698,0.5811,0.05,99.549 -20000,0.5698,0.5811,0.05,99.549 -20000,0.5698,0.5811,0.05,99.549 -20000,0.5698,0.5811,0.05,99.549 -20000,0.5698,0.5811,0.05,99.549 -20000,0.5698,0.5811,0.05,99.549 -20000,0.5698,0.5811,0.05,99.549 -20000,0.5698,0.5811,0.05,99.549 -20000,0.58109,0.59261,0.05,99.621 -20000,0.58109,0.59261,0.05,99.621 -20000,0.58109,0.59261,0.05,99.621 -20000,0.58109,0.59261,0.05,99.621 -20000,0.58109,0.59261,0.05,99.621 -20000,0.58109,0.59261,0.05,99.621 -20000,0.58109,0.59261,0.05,99.621 -20000,0.58109,0.59261,0.05,99.621 -20000,0.58109,0.59261,0.05,99.621 -20000,0.58109,0.59261,0.05,99.621 -20000,0.58109,0.59261,0.05,99.621 -20000,0.5926,0.60435,0.05,99.685 -20000,0.5926,0.60435,0.05,99.685 -20000,0.5926,0.60435,0.05,99.685 -20000,0.5926,0.60435,0.05,99.685 -20000,0.5926,0.60435,0.05,99.685 -20000,0.5926,0.60435,0.05,99.685 -20000,0.5926,0.60435,0.05,99.685 -20000,0.5926,0.60435,0.05,99.685 -20000,0.5926,0.60435,0.05,99.685 -20000,0.5926,0.60435,0.05,99.685 -20000,0.5926,0.60435,0.05,99.685 -20000,0.5926,0.60435,0.05,99.685 -20000,0.60434,0.61632,0.05,99.74 -20000,0.60434,0.61632,0.05,99.74 -20000,0.60434,0.61632,0.05,99.74 -20000,0.60434,0.61632,0.05,99.74 -20000,0.60434,0.61632,0.05,99.74 -20000,0.60434,0.61632,0.05,99.74 -20000,0.60434,0.61632,0.05,99.74 -20000,0.60434,0.61632,0.05,99.74 -20000,0.60434,0.61632,0.05,99.74 -20000,0.60434,0.61632,0.05,99.74 -20000,0.60434,0.61632,0.05,99.74 -20000,0.60434,0.61632,0.05,99.74 -20000,0.61631,0.62853,0.05,99.789 -20000,0.61631,0.62853,0.05,99.789 -20000,0.61631,0.62853,0.05,99.789 -20000,0.61631,0.62853,0.05,99.789 -20000,0.61631,0.62853,0.05,99.789 -20000,0.61631,0.62853,0.05,99.789 -20000,0.61631,0.62853,0.05,99.789 -20000,0.61631,0.62853,0.05,99.789 -20000,0.61631,0.62853,0.05,99.789 -20000,0.61631,0.62853,0.05,99.789 -20000,0.61631,0.62853,0.05,99.789 -20000,0.61631,0.62853,0.05,99.789 -20000,0.62852,0.64098,0.05,99.832 -20000,0.62852,0.64098,0.05,99.832 -20000,0.62852,0.64098,0.05,99.832 -20000,0.62852,0.64098,0.05,99.832 -20000,0.62852,0.64098,0.05,99.832 -20000,0.62852,0.64098,0.05,99.832 -20000,0.62852,0.64098,0.05,99.832 -20000,0.62852,0.64098,0.05,99.832 -20000,0.62852,0.64098,0.05,99.832 -20000,0.62852,0.64098,0.05,99.832 -20000,0.62852,0.64098,0.05,99.832 -20000,0.62852,0.64098,0.05,99.832 -20000,0.62852,0.64098,0.05,99.832 -20000,0.64097,0.65368,0.05,99.869 -20000,0.64097,0.65368,0.05,99.869 -20000,0.64097,0.65368,0.05,99.869 -20000,0.64097,0.65368,0.05,99.869 -20000,0.64097,0.65368,0.05,99.869 -20000,0.64097,0.65368,0.05,99.869 -20000,0.64097,0.65368,0.05,99.869 -20000,0.64097,0.65368,0.05,99.869 -20000,0.64097,0.65368,0.05,99.869 -20000,0.64097,0.65368,0.05,99.869 -20000,0.64097,0.65368,0.05,99.869 -20000,0.64097,0.65368,0.05,99.869 -20000,0.65367,0.66663,0.05,99.903 -20000,0.65367,0.66663,0.05,99.903 -20000,0.65367,0.66663,0.05,99.903 -20000,0.65367,0.66663,0.05,99.903 -20000,0.65367,0.66663,0.05,99.903 -20000,0.65367,0.66663,0.05,99.903 -20000,0.65367,0.66663,0.05,99.903 -20000,0.65367,0.66663,0.05,99.903 -20000,0.65367,0.66663,0.05,99.903 -20000,0.65367,0.66663,0.05,99.903 -20000,0.65367,0.66663,0.05,99.903 -20000,0.65367,0.66663,0.05,99.903 -20000,0.65367,0.66663,0.05,99.903 -20000,0.66662,0.67984,0.05,99.933 -20000,0.66662,0.67984,0.05,99.933 -20000,0.66662,0.67984,0.05,99.933 -20000,0.66662,0.67984,0.05,99.933 -20000,0.66662,0.67984,0.05,99.933 -20000,0.66662,0.67984,0.05,99.933 -20000,0.66662,0.67984,0.05,99.933 -20000,0.66662,0.67984,0.05,99.933 -20000,0.66662,0.67984,0.05,99.933 -20000,0.66662,0.67984,0.05,99.933 -20000,0.66662,0.67984,0.05,99.933 -20000,0.66662,0.67984,0.05,99.933 -20000,0.66662,0.67984,0.05,99.933 -20000,0.67983,0.69331,0.05,99.961 -20000,0.67983,0.69331,0.05,99.961 -20000,0.67983,0.69331,0.05,99.961 -20000,0.67983,0.69331,0.05,99.961 -20000,0.67983,0.69331,0.05,99.961 -20000,0.67983,0.69331,0.05,99.961 -20000,0.67983,0.69331,0.05,99.961 -20000,0.67983,0.69331,0.05,99.961 -20000,0.67983,0.69331,0.05,99.961 -20000,0.67983,0.69331,0.05,99.961 -20000,0.67983,0.69331,0.05,99.961 -20000,0.67983,0.69331,0.05,99.961 -20000,0.67983,0.69331,0.05,99.961 -20000,0.67983,0.69331,0.05,99.961 -20000,0.6933,0.70704,0.05,99.987 -20000,0.6933,0.70704,0.05,99.987 -20000,0.6933,0.70704,0.05,99.987 -20000,0.6933,0.70704,0.05,99.987 -20000,0.6933,0.70704,0.05,99.987 -20000,0.6933,0.70704,0.05,99.987 -20000,0.6933,0.70704,0.05,99.987 -20000,0.6933,0.70704,0.05,99.987 -20000,0.6933,0.70704,0.05,99.987 -20000,0.6933,0.70704,0.05,99.987 -20000,0.6933,0.70704,0.05,99.987 -20000,0.6933,0.70704,0.05,99.987 -20000,0.6933,0.70704,0.05,99.987 -20000,0.6933,0.70704,0.05,99.987 -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_5.csv b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_5.csv deleted file mode 100644 index a0165428e76..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/data_5.csv +++ /dev/null @@ -1,1002 +0,0 @@ -Time,"elementCenter:0","elementCenter:1","elementCenter:2","temperature" -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,0.07071,0.072112,0.05,-19.345 -50000,0.07071,0.072112,0.05,-19.345 -50000,0.07211,0.07354,0.05,-18.062 -50000,0.07351,0.074968,0.05,-16.803 -50000,0.075155,0.076646,0.05,-15.352 -50000,0.075155,0.076646,0.05,-15.352 -50000,0.077046,0.078574,0.05,-13.727 -50000,0.077046,0.078574,0.05,-13.727 -50000,0.078936,0.080501,0.05,-12.141 -50000,0.078936,0.080501,0.05,-12.141 -50000,0.080826,0.082429,0.05,-10.592 -50000,0.080826,0.082429,0.05,-10.592 -50000,0.082716,0.084357,0.05,-9.0797 -50000,0.082716,0.084357,0.05,-9.0797 -50000,0.084607,0.086285,0.05,-7.6016 -50000,0.084607,0.086285,0.05,-7.6016 -50000,0.086497,0.088212,0.05,-6.1563 -50000,0.086497,0.088212,0.05,-6.1563 -50000,0.088387,0.09014,0.05,-4.7426 -50000,0.088387,0.09014,0.05,-4.7426 -50000,0.090278,0.092068,0.05,-3.359 -50000,0.090278,0.092068,0.05,-3.359 -50000,0.092168,0.093995,0.05,-2.0045 -50000,0.092168,0.093995,0.05,-2.0045 -50000,0.094031,0.095896,0.05,-0.69679 -50000,0.095885,0.097786,0.05,0.57908 -50000,0.095885,0.097786,0.05,0.57908 -50000,0.097776,0.099715,0.05,1.8547 -50000,0.097776,0.099715,0.05,1.8547 -50000,0.099704,0.10168,0.05,3.1301 -50000,0.099704,0.10168,0.05,3.1301 -50000,0.10167,0.10369,0.05,4.4051 -50000,0.10167,0.10369,0.05,4.4051 -50000,0.10368,0.10573,0.05,5.6798 -50000,0.10368,0.10573,0.05,5.6798 -50000,0.10572,0.10782,0.05,6.9541 -50000,0.10572,0.10782,0.05,6.9541 -50000,0.10781,0.10995,0.05,8.2279 -50000,0.10781,0.10995,0.05,8.2279 -50000,0.10993,0.11211,0.05,9.5012 -50000,0.10993,0.11211,0.05,9.5012 -50000,0.10993,0.11211,0.05,9.5012 -50000,0.1121,0.11433,0.05,10.774 -50000,0.1121,0.11433,0.05,10.774 -50000,0.11432,0.11658,0.05,12.046 -50000,0.11432,0.11658,0.05,12.046 -50000,0.11657,0.11888,0.05,13.317 -50000,0.11657,0.11888,0.05,13.317 -50000,0.11887,0.12123,0.05,14.588 -50000,0.11887,0.12123,0.05,14.588 -50000,0.11887,0.12123,0.05,14.588 -50000,0.12122,0.12362,0.05,15.858 -50000,0.12122,0.12362,0.05,15.858 -50000,0.12361,0.12607,0.05,17.127 -50000,0.12361,0.12607,0.05,17.127 -50000,0.12361,0.12607,0.05,17.127 -50000,0.12605,0.12855,0.05,18.395 -50000,0.12605,0.12855,0.05,18.395 -50000,0.12854,0.13109,0.05,19.662 -50000,0.12854,0.13109,0.05,19.662 -50000,0.12854,0.13109,0.05,19.662 -50000,0.13108,0.13368,0.05,20.927 -50000,0.13108,0.13368,0.05,20.927 -50000,0.13367,0.13632,0.05,22.192 -50000,0.13367,0.13632,0.05,22.192 -50000,0.13367,0.13632,0.05,22.192 -50000,0.13631,0.13901,0.05,23.455 -50000,0.13631,0.13901,0.05,23.455 -50000,0.13631,0.13901,0.05,23.455 -50000,0.139,0.14176,0.05,24.716 -50000,0.139,0.14176,0.05,24.716 -50000,0.14175,0.14456,0.05,25.977 -50000,0.14175,0.14456,0.05,25.977 -50000,0.14175,0.14456,0.05,25.977 -50000,0.14455,0.14742,0.05,27.235 -50000,0.14455,0.14742,0.05,27.235 -50000,0.14455,0.14742,0.05,27.235 -50000,0.1474,0.15033,0.05,28.492 -50000,0.1474,0.15033,0.05,28.492 -50000,0.1474,0.15033,0.05,28.492 -50000,0.15032,0.1533,0.05,29.746 -50000,0.15032,0.1533,0.05,29.746 -50000,0.15032,0.1533,0.05,29.746 -50000,0.15329,0.15633,0.05,30.999 -50000,0.15329,0.15633,0.05,30.999 -50000,0.15329,0.15633,0.05,30.999 -50000,0.15632,0.15942,0.05,32.249 -50000,0.15632,0.15942,0.05,32.249 -50000,0.15632,0.15942,0.05,32.249 -50000,0.15941,0.16257,0.05,33.497 -50000,0.15941,0.16257,0.05,33.497 -50000,0.15941,0.16257,0.05,33.497 -50000,0.16256,0.16578,0.05,34.743 -50000,0.16256,0.16578,0.05,34.743 -50000,0.16256,0.16578,0.05,34.743 -50000,0.16577,0.16906,0.05,35.986 -50000,0.16577,0.16906,0.05,35.986 -50000,0.16577,0.16906,0.05,35.986 -50000,0.16577,0.16906,0.05,35.986 -50000,0.16905,0.1724,0.05,37.226 -50000,0.16905,0.1724,0.05,37.226 -50000,0.16905,0.1724,0.05,37.226 -50000,0.17239,0.1758,0.05,38.464 -50000,0.17239,0.1758,0.05,38.464 -50000,0.17239,0.1758,0.05,38.464 -50000,0.17579,0.17928,0.05,39.698 -50000,0.17579,0.17928,0.05,39.698 -50000,0.17579,0.17928,0.05,39.698 -50000,0.17579,0.17928,0.05,39.698 -50000,0.17927,0.18282,0.05,40.928 -50000,0.17927,0.18282,0.05,40.928 -50000,0.17927,0.18282,0.05,40.928 -50000,0.18281,0.18644,0.05,42.155 -50000,0.18281,0.18644,0.05,42.155 -50000,0.18281,0.18644,0.05,42.155 -50000,0.18281,0.18644,0.05,42.155 -50000,0.18643,0.19013,0.05,43.379 -50000,0.18643,0.19013,0.05,43.379 -50000,0.18643,0.19013,0.05,43.379 -50000,0.18643,0.19013,0.05,43.379 -50000,0.19011,0.19388,0.05,44.598 -50000,0.19011,0.19388,0.05,44.598 -50000,0.19011,0.19388,0.05,44.598 -50000,0.19387,0.19772,0.05,45.813 -50000,0.19387,0.19772,0.05,45.813 -50000,0.19387,0.19772,0.05,45.813 -50000,0.19387,0.19772,0.05,45.813 -50000,0.19771,0.20163,0.05,47.024 -50000,0.19771,0.20163,0.05,47.024 -50000,0.19771,0.20163,0.05,47.024 -50000,0.19771,0.20163,0.05,47.024 -50000,0.20162,0.20562,0.05,48.23 -50000,0.20162,0.20562,0.05,48.23 -50000,0.20162,0.20562,0.05,48.23 -50000,0.20162,0.20562,0.05,48.23 -50000,0.2056,0.20968,0.05,49.431 -50000,0.2056,0.20968,0.05,49.431 -50000,0.2056,0.20968,0.05,49.431 -50000,0.2056,0.20968,0.05,49.431 -50000,0.20967,0.21383,0.05,50.627 -50000,0.20967,0.21383,0.05,50.627 -50000,0.20967,0.21383,0.05,50.627 -50000,0.20967,0.21383,0.05,50.627 -50000,0.21382,0.21806,0.05,51.818 -50000,0.21382,0.21806,0.05,51.818 -50000,0.21382,0.21806,0.05,51.818 -50000,0.21382,0.21806,0.05,51.818 -50000,0.21382,0.21806,0.05,51.818 -50000,0.21805,0.22237,0.05,53.002 -50000,0.21805,0.22237,0.05,53.002 -50000,0.21805,0.22237,0.05,53.002 -50000,0.21805,0.22237,0.05,53.002 -50000,0.22236,0.22677,0.05,54.181 -50000,0.22236,0.22677,0.05,54.181 -50000,0.22236,0.22677,0.05,54.181 -50000,0.22236,0.22677,0.05,54.181 -50000,0.22676,0.23125,0.05,55.353 -50000,0.22676,0.23125,0.05,55.353 -50000,0.22676,0.23125,0.05,55.353 -50000,0.22676,0.23125,0.05,55.353 -50000,0.22676,0.23125,0.05,55.353 -50000,0.23124,0.23583,0.05,56.518 -50000,0.23124,0.23583,0.05,56.518 -50000,0.23124,0.23583,0.05,56.518 -50000,0.23124,0.23583,0.05,56.518 -50000,0.23582,0.2405,0.05,57.677 -50000,0.23582,0.2405,0.05,57.677 -50000,0.23582,0.2405,0.05,57.677 -50000,0.23582,0.2405,0.05,57.677 -50000,0.23582,0.2405,0.05,57.677 -50000,0.24048,0.24525,0.05,58.828 -50000,0.24048,0.24525,0.05,58.828 -50000,0.24048,0.24525,0.05,58.828 -50000,0.24048,0.24525,0.05,58.828 -50000,0.24048,0.24525,0.05,58.828 -50000,0.24524,0.25011,0.05,59.971 -50000,0.24524,0.25011,0.05,59.971 -50000,0.24524,0.25011,0.05,59.971 -50000,0.24524,0.25011,0.05,59.971 -50000,0.24524,0.25011,0.05,59.971 -50000,0.25009,0.25505,0.05,61.107 -50000,0.25009,0.25505,0.05,61.107 -50000,0.25009,0.25505,0.05,61.107 -50000,0.25009,0.25505,0.05,61.107 -50000,0.25009,0.25505,0.05,61.107 -50000,0.25504,0.2601,0.05,62.233 -50000,0.25504,0.2601,0.05,62.233 -50000,0.25504,0.2601,0.05,62.233 -50000,0.25504,0.2601,0.05,62.233 -50000,0.25504,0.2601,0.05,62.233 -50000,0.26009,0.26525,0.05,63.351 -50000,0.26009,0.26525,0.05,63.351 -50000,0.26009,0.26525,0.05,63.351 -50000,0.26009,0.26525,0.05,63.351 -50000,0.26009,0.26525,0.05,63.351 -50000,0.26524,0.2705,0.05,64.46 -50000,0.26524,0.2705,0.05,64.46 -50000,0.26524,0.2705,0.05,64.46 -50000,0.26524,0.2705,0.05,64.46 -50000,0.26524,0.2705,0.05,64.46 -50000,0.27048,0.27585,0.05,65.559 -50000,0.27048,0.27585,0.05,65.559 -50000,0.27048,0.27585,0.05,65.559 -50000,0.27048,0.27585,0.05,65.559 -50000,0.27048,0.27585,0.05,65.559 -50000,0.27584,0.28131,0.05,66.648 -50000,0.27584,0.28131,0.05,66.648 -50000,0.27584,0.28131,0.05,66.648 -50000,0.27584,0.28131,0.05,66.648 -50000,0.27584,0.28131,0.05,66.648 -50000,0.27584,0.28131,0.05,66.648 -50000,0.2813,0.28687,0.05,67.726 -50000,0.2813,0.28687,0.05,67.726 -50000,0.2813,0.28687,0.05,67.726 -50000,0.2813,0.28687,0.05,67.726 -50000,0.2813,0.28687,0.05,67.726 -50000,0.28686,0.29255,0.05,68.794 -50000,0.28686,0.29255,0.05,68.794 -50000,0.28686,0.29255,0.05,68.794 -50000,0.28686,0.29255,0.05,68.794 -50000,0.28686,0.29255,0.05,68.794 -50000,0.28686,0.29255,0.05,68.794 -50000,0.29254,0.29834,0.05,69.85 -50000,0.29254,0.29834,0.05,69.85 -50000,0.29254,0.29834,0.05,69.85 -50000,0.29254,0.29834,0.05,69.85 -50000,0.29254,0.29834,0.05,69.85 -50000,0.29254,0.29834,0.05,69.85 -50000,0.29833,0.30425,0.05,70.894 -50000,0.29833,0.30425,0.05,70.894 -50000,0.29833,0.30425,0.05,70.894 -50000,0.29833,0.30425,0.05,70.894 -50000,0.29833,0.30425,0.05,70.894 -50000,0.29833,0.30425,0.05,70.894 -50000,0.30424,0.31027,0.05,71.926 -50000,0.30424,0.31027,0.05,71.926 -50000,0.30424,0.31027,0.05,71.926 -50000,0.30424,0.31027,0.05,71.926 -50000,0.30424,0.31027,0.05,71.926 -50000,0.30424,0.31027,0.05,71.926 -50000,0.31026,0.31641,0.05,72.945 -50000,0.31026,0.31641,0.05,72.945 -50000,0.31026,0.31641,0.05,72.945 -50000,0.31026,0.31641,0.05,72.945 -50000,0.31026,0.31641,0.05,72.945 -50000,0.31026,0.31641,0.05,72.945 -50000,0.3164,0.32267,0.05,73.951 -50000,0.3164,0.32267,0.05,73.951 -50000,0.3164,0.32267,0.05,73.951 -50000,0.3164,0.32267,0.05,73.951 -50000,0.3164,0.32267,0.05,73.951 -50000,0.3164,0.32267,0.05,73.951 -50000,0.32266,0.32906,0.05,74.943 -50000,0.32266,0.32906,0.05,74.943 -50000,0.32266,0.32906,0.05,74.943 -50000,0.32266,0.32906,0.05,74.943 -50000,0.32266,0.32906,0.05,74.943 -50000,0.32266,0.32906,0.05,74.943 -50000,0.32266,0.32906,0.05,74.943 -50000,0.32905,0.33558,0.05,75.921 -50000,0.32905,0.33558,0.05,75.921 -50000,0.32905,0.33558,0.05,75.921 -50000,0.32905,0.33558,0.05,75.921 -50000,0.32905,0.33558,0.05,75.921 -50000,0.32905,0.33558,0.05,75.921 -50000,0.33556,0.34222,0.05,76.885 -50000,0.33556,0.34222,0.05,76.885 -50000,0.33556,0.34222,0.05,76.885 -50000,0.33556,0.34222,0.05,76.885 -50000,0.33556,0.34222,0.05,76.885 -50000,0.33556,0.34222,0.05,76.885 -50000,0.33556,0.34222,0.05,76.885 -50000,0.34221,0.34899,0.05,77.833 -50000,0.34221,0.34899,0.05,77.833 -50000,0.34221,0.34899,0.05,77.833 -50000,0.34221,0.34899,0.05,77.833 -50000,0.34221,0.34899,0.05,77.833 -50000,0.34221,0.34899,0.05,77.833 -50000,0.34221,0.34899,0.05,77.833 -50000,0.34898,0.3559,0.05,78.766 -50000,0.34898,0.3559,0.05,78.766 -50000,0.34898,0.3559,0.05,78.766 -50000,0.34898,0.3559,0.05,78.766 -50000,0.34898,0.3559,0.05,78.766 -50000,0.34898,0.3559,0.05,78.766 -50000,0.35589,0.36295,0.05,79.683 -50000,0.35589,0.36295,0.05,79.683 -50000,0.35589,0.36295,0.05,79.683 -50000,0.35589,0.36295,0.05,79.683 -50000,0.35589,0.36295,0.05,79.683 -50000,0.35589,0.36295,0.05,79.683 -50000,0.35589,0.36295,0.05,79.683 -50000,0.36294,0.37013,0.05,80.583 -50000,0.36294,0.37013,0.05,80.583 -50000,0.36294,0.37013,0.05,80.583 -50000,0.36294,0.37013,0.05,80.583 -50000,0.36294,0.37013,0.05,80.583 -50000,0.36294,0.37013,0.05,80.583 -50000,0.36294,0.37013,0.05,80.583 -50000,0.36294,0.37013,0.05,80.583 -50000,0.37012,0.37746,0.05,81.466 -50000,0.37012,0.37746,0.05,81.466 -50000,0.37012,0.37746,0.05,81.466 -50000,0.37012,0.37746,0.05,81.466 -50000,0.37012,0.37746,0.05,81.466 -50000,0.37012,0.37746,0.05,81.466 -50000,0.37012,0.37746,0.05,81.466 -50000,0.37745,0.38494,0.05,82.332 -50000,0.37745,0.38494,0.05,82.332 -50000,0.37745,0.38494,0.05,82.332 -50000,0.37745,0.38494,0.05,82.332 -50000,0.37745,0.38494,0.05,82.332 -50000,0.37745,0.38494,0.05,82.332 -50000,0.37745,0.38494,0.05,82.332 -50000,0.38493,0.39256,0.05,83.18 -50000,0.38493,0.39256,0.05,83.18 -50000,0.38493,0.39256,0.05,83.18 -50000,0.38493,0.39256,0.05,83.18 -50000,0.38493,0.39256,0.05,83.18 -50000,0.38493,0.39256,0.05,83.18 -50000,0.38493,0.39256,0.05,83.18 -50000,0.38493,0.39256,0.05,83.18 -50000,0.39255,0.40033,0.05,84.01 -50000,0.39255,0.40033,0.05,84.01 -50000,0.39255,0.40033,0.05,84.01 -50000,0.39255,0.40033,0.05,84.01 -50000,0.39255,0.40033,0.05,84.01 -50000,0.39255,0.40033,0.05,84.01 -50000,0.39255,0.40033,0.05,84.01 -50000,0.39255,0.40033,0.05,84.01 -50000,0.40032,0.40826,0.05,84.821 -50000,0.40032,0.40826,0.05,84.821 -50000,0.40032,0.40826,0.05,84.821 -50000,0.40032,0.40826,0.05,84.821 -50000,0.40032,0.40826,0.05,84.821 -50000,0.40032,0.40826,0.05,84.821 -50000,0.40032,0.40826,0.05,84.821 -50000,0.40032,0.40826,0.05,84.821 -50000,0.40825,0.41634,0.05,85.613 -50000,0.40825,0.41634,0.05,85.613 -50000,0.40825,0.41634,0.05,85.613 -50000,0.40825,0.41634,0.05,85.613 -50000,0.40825,0.41634,0.05,85.613 -50000,0.40825,0.41634,0.05,85.613 -50000,0.40825,0.41634,0.05,85.613 -50000,0.40825,0.41634,0.05,85.613 -50000,0.41633,0.42459,0.05,86.386 -50000,0.41633,0.42459,0.05,86.386 -50000,0.41633,0.42459,0.05,86.386 -50000,0.41633,0.42459,0.05,86.386 -50000,0.41633,0.42459,0.05,86.386 -50000,0.41633,0.42459,0.05,86.386 -50000,0.41633,0.42459,0.05,86.386 -50000,0.41633,0.42459,0.05,86.386 -50000,0.42458,0.433,0.05,87.139 -50000,0.42458,0.433,0.05,87.139 -50000,0.42458,0.433,0.05,87.139 -50000,0.42458,0.433,0.05,87.139 -50000,0.42458,0.433,0.05,87.139 -50000,0.42458,0.433,0.05,87.139 -50000,0.42458,0.433,0.05,87.139 -50000,0.42458,0.433,0.05,87.139 -50000,0.42458,0.433,0.05,87.139 -50000,0.43298,0.44157,0.05,87.872 -50000,0.43298,0.44157,0.05,87.872 -50000,0.43298,0.44157,0.05,87.872 -50000,0.43298,0.44157,0.05,87.872 -50000,0.43298,0.44157,0.05,87.872 -50000,0.43298,0.44157,0.05,87.872 -50000,0.43298,0.44157,0.05,87.872 -50000,0.43298,0.44157,0.05,87.872 -50000,0.44156,0.45031,0.05,88.586 -50000,0.44156,0.45031,0.05,88.586 -50000,0.44156,0.45031,0.05,88.586 -50000,0.44156,0.45031,0.05,88.586 -50000,0.44156,0.45031,0.05,88.586 -50000,0.44156,0.45031,0.05,88.586 -50000,0.44156,0.45031,0.05,88.586 -50000,0.44156,0.45031,0.05,88.586 -50000,0.44156,0.45031,0.05,88.586 -50000,0.4503,0.45923,0.05,89.278 -50000,0.4503,0.45923,0.05,89.278 -50000,0.4503,0.45923,0.05,89.278 -50000,0.4503,0.45923,0.05,89.278 -50000,0.4503,0.45923,0.05,89.278 -50000,0.4503,0.45923,0.05,89.278 -50000,0.4503,0.45923,0.05,89.278 -50000,0.4503,0.45923,0.05,89.278 -50000,0.4503,0.45923,0.05,89.278 -50000,0.45922,0.46833,0.05,89.951 -50000,0.45922,0.46833,0.05,89.951 -50000,0.45922,0.46833,0.05,89.951 -50000,0.45922,0.46833,0.05,89.951 -50000,0.45922,0.46833,0.05,89.951 -50000,0.45922,0.46833,0.05,89.951 -50000,0.45922,0.46833,0.05,89.951 -50000,0.45922,0.46833,0.05,89.951 -50000,0.45922,0.46833,0.05,89.951 -50000,0.46832,0.4776,0.05,90.602 -50000,0.46832,0.4776,0.05,90.602 -50000,0.46832,0.4776,0.05,90.602 -50000,0.46832,0.4776,0.05,90.602 -50000,0.46832,0.4776,0.05,90.602 -50000,0.46832,0.4776,0.05,90.602 -50000,0.46832,0.4776,0.05,90.602 -50000,0.46832,0.4776,0.05,90.602 -50000,0.46832,0.4776,0.05,90.602 -50000,0.47759,0.48706,0.05,91.234 -50000,0.47759,0.48706,0.05,91.234 -50000,0.47759,0.48706,0.05,91.234 -50000,0.47759,0.48706,0.05,91.234 -50000,0.47759,0.48706,0.05,91.234 -50000,0.47759,0.48706,0.05,91.234 -50000,0.47759,0.48706,0.05,91.234 -50000,0.47759,0.48706,0.05,91.234 -50000,0.47759,0.48706,0.05,91.234 -50000,0.47759,0.48706,0.05,91.234 -50000,0.48705,0.49671,0.05,91.844 -50000,0.48705,0.49671,0.05,91.844 -50000,0.48705,0.49671,0.05,91.844 -50000,0.48705,0.49671,0.05,91.844 -50000,0.48705,0.49671,0.05,91.844 -50000,0.48705,0.49671,0.05,91.844 -50000,0.48705,0.49671,0.05,91.844 -50000,0.48705,0.49671,0.05,91.844 -50000,0.48705,0.49671,0.05,91.844 -50000,0.4967,0.50655,0.05,92.434 -50000,0.4967,0.50655,0.05,92.434 -50000,0.4967,0.50655,0.05,92.434 -50000,0.4967,0.50655,0.05,92.434 -50000,0.4967,0.50655,0.05,92.434 -50000,0.4967,0.50655,0.05,92.434 -50000,0.4967,0.50655,0.05,92.434 -50000,0.4967,0.50655,0.05,92.434 -50000,0.4967,0.50655,0.05,92.434 -50000,0.4967,0.50655,0.05,92.434 -50000,0.50654,0.51658,0.05,93.004 -50000,0.50654,0.51658,0.05,93.004 -50000,0.50654,0.51658,0.05,93.004 -50000,0.50654,0.51658,0.05,93.004 -50000,0.50654,0.51658,0.05,93.004 -50000,0.50654,0.51658,0.05,93.004 -50000,0.50654,0.51658,0.05,93.004 -50000,0.50654,0.51658,0.05,93.004 -50000,0.50654,0.51658,0.05,93.004 -50000,0.50654,0.51658,0.05,93.004 -50000,0.51657,0.52681,0.05,93.553 -50000,0.51657,0.52681,0.05,93.553 -50000,0.51657,0.52681,0.05,93.553 -50000,0.51657,0.52681,0.05,93.553 -50000,0.51657,0.52681,0.05,93.553 -50000,0.51657,0.52681,0.05,93.553 -50000,0.51657,0.52681,0.05,93.553 -50000,0.51657,0.52681,0.05,93.553 -50000,0.51657,0.52681,0.05,93.553 -50000,0.51657,0.52681,0.05,93.553 -50000,0.5268,0.53725,0.05,94.083 -50000,0.5268,0.53725,0.05,94.083 -50000,0.5268,0.53725,0.05,94.083 -50000,0.5268,0.53725,0.05,94.083 -50000,0.5268,0.53725,0.05,94.083 -50000,0.5268,0.53725,0.05,94.083 -50000,0.5268,0.53725,0.05,94.083 -50000,0.5268,0.53725,0.05,94.083 -50000,0.5268,0.53725,0.05,94.083 -50000,0.5268,0.53725,0.05,94.083 -50000,0.5268,0.53725,0.05,94.083 -50000,0.53724,0.54789,0.05,94.593 -50000,0.53724,0.54789,0.05,94.593 -50000,0.53724,0.54789,0.05,94.593 -50000,0.53724,0.54789,0.05,94.593 -50000,0.53724,0.54789,0.05,94.593 -50000,0.53724,0.54789,0.05,94.593 -50000,0.53724,0.54789,0.05,94.593 -50000,0.53724,0.54789,0.05,94.593 -50000,0.53724,0.54789,0.05,94.593 -50000,0.53724,0.54789,0.05,94.593 -50000,0.54788,0.55874,0.05,95.084 -50000,0.54788,0.55874,0.05,95.084 -50000,0.54788,0.55874,0.05,95.084 -50000,0.54788,0.55874,0.05,95.084 -50000,0.54788,0.55874,0.05,95.084 -50000,0.54788,0.55874,0.05,95.084 -50000,0.54788,0.55874,0.05,95.084 -50000,0.54788,0.55874,0.05,95.084 -50000,0.54788,0.55874,0.05,95.084 -50000,0.54788,0.55874,0.05,95.084 -50000,0.54788,0.55874,0.05,95.084 -50000,0.55873,0.56981,0.05,95.557 -50000,0.55873,0.56981,0.05,95.557 -50000,0.55873,0.56981,0.05,95.557 -50000,0.55873,0.56981,0.05,95.557 -50000,0.55873,0.56981,0.05,95.557 -50000,0.55873,0.56981,0.05,95.557 -50000,0.55873,0.56981,0.05,95.557 -50000,0.55873,0.56981,0.05,95.557 -50000,0.55873,0.56981,0.05,95.557 -50000,0.55873,0.56981,0.05,95.557 -50000,0.55873,0.56981,0.05,95.557 -50000,0.5698,0.5811,0.05,96.012 -50000,0.5698,0.5811,0.05,96.012 -50000,0.5698,0.5811,0.05,96.012 -50000,0.5698,0.5811,0.05,96.012 -50000,0.5698,0.5811,0.05,96.012 -50000,0.5698,0.5811,0.05,96.012 -50000,0.5698,0.5811,0.05,96.012 -50000,0.5698,0.5811,0.05,96.012 -50000,0.5698,0.5811,0.05,96.012 -50000,0.5698,0.5811,0.05,96.012 -50000,0.5698,0.5811,0.05,96.012 -50000,0.5698,0.5811,0.05,96.012 -50000,0.58109,0.59261,0.05,96.45 -50000,0.58109,0.59261,0.05,96.45 -50000,0.58109,0.59261,0.05,96.45 -50000,0.58109,0.59261,0.05,96.45 -50000,0.58109,0.59261,0.05,96.45 -50000,0.58109,0.59261,0.05,96.45 -50000,0.58109,0.59261,0.05,96.45 -50000,0.58109,0.59261,0.05,96.45 -50000,0.58109,0.59261,0.05,96.45 -50000,0.58109,0.59261,0.05,96.45 -50000,0.58109,0.59261,0.05,96.45 -50000,0.5926,0.60435,0.05,96.872 -50000,0.5926,0.60435,0.05,96.872 -50000,0.5926,0.60435,0.05,96.872 -50000,0.5926,0.60435,0.05,96.872 -50000,0.5926,0.60435,0.05,96.872 -50000,0.5926,0.60435,0.05,96.872 -50000,0.5926,0.60435,0.05,96.872 -50000,0.5926,0.60435,0.05,96.872 -50000,0.5926,0.60435,0.05,96.872 -50000,0.5926,0.60435,0.05,96.872 -50000,0.5926,0.60435,0.05,96.872 -50000,0.5926,0.60435,0.05,96.872 -50000,0.60434,0.61632,0.05,97.279 -50000,0.60434,0.61632,0.05,97.279 -50000,0.60434,0.61632,0.05,97.279 -50000,0.60434,0.61632,0.05,97.279 -50000,0.60434,0.61632,0.05,97.279 -50000,0.60434,0.61632,0.05,97.279 -50000,0.60434,0.61632,0.05,97.279 -50000,0.60434,0.61632,0.05,97.279 -50000,0.60434,0.61632,0.05,97.279 -50000,0.60434,0.61632,0.05,97.279 -50000,0.60434,0.61632,0.05,97.279 -50000,0.60434,0.61632,0.05,97.279 -50000,0.61631,0.62853,0.05,97.673 -50000,0.61631,0.62853,0.05,97.673 -50000,0.61631,0.62853,0.05,97.673 -50000,0.61631,0.62853,0.05,97.673 -50000,0.61631,0.62853,0.05,97.673 -50000,0.61631,0.62853,0.05,97.673 -50000,0.61631,0.62853,0.05,97.673 -50000,0.61631,0.62853,0.05,97.673 -50000,0.61631,0.62853,0.05,97.673 -50000,0.61631,0.62853,0.05,97.673 -50000,0.61631,0.62853,0.05,97.673 -50000,0.61631,0.62853,0.05,97.673 -50000,0.62852,0.64098,0.05,98.054 -50000,0.62852,0.64098,0.05,98.054 -50000,0.62852,0.64098,0.05,98.054 -50000,0.62852,0.64098,0.05,98.054 -50000,0.62852,0.64098,0.05,98.054 -50000,0.62852,0.64098,0.05,98.054 -50000,0.62852,0.64098,0.05,98.054 -50000,0.62852,0.64098,0.05,98.054 -50000,0.62852,0.64098,0.05,98.054 -50000,0.62852,0.64098,0.05,98.054 -50000,0.62852,0.64098,0.05,98.054 -50000,0.62852,0.64098,0.05,98.054 -50000,0.62852,0.64098,0.05,98.054 -50000,0.64097,0.65368,0.05,98.424 -50000,0.64097,0.65368,0.05,98.424 -50000,0.64097,0.65368,0.05,98.424 -50000,0.64097,0.65368,0.05,98.424 -50000,0.64097,0.65368,0.05,98.424 -50000,0.64097,0.65368,0.05,98.424 -50000,0.64097,0.65368,0.05,98.424 -50000,0.64097,0.65368,0.05,98.424 -50000,0.64097,0.65368,0.05,98.424 -50000,0.64097,0.65368,0.05,98.424 -50000,0.64097,0.65368,0.05,98.424 -50000,0.64097,0.65368,0.05,98.424 -50000,0.65367,0.66663,0.05,98.785 -50000,0.65367,0.66663,0.05,98.785 -50000,0.65367,0.66663,0.05,98.785 -50000,0.65367,0.66663,0.05,98.785 -50000,0.65367,0.66663,0.05,98.785 -50000,0.65367,0.66663,0.05,98.785 -50000,0.65367,0.66663,0.05,98.785 -50000,0.65367,0.66663,0.05,98.785 -50000,0.65367,0.66663,0.05,98.785 -50000,0.65367,0.66663,0.05,98.785 -50000,0.65367,0.66663,0.05,98.785 -50000,0.65367,0.66663,0.05,98.785 -50000,0.65367,0.66663,0.05,98.785 -50000,0.66662,0.67984,0.05,99.138 -50000,0.66662,0.67984,0.05,99.138 -50000,0.66662,0.67984,0.05,99.138 -50000,0.66662,0.67984,0.05,99.138 -50000,0.66662,0.67984,0.05,99.138 -50000,0.66662,0.67984,0.05,99.138 -50000,0.66662,0.67984,0.05,99.138 -50000,0.66662,0.67984,0.05,99.138 -50000,0.66662,0.67984,0.05,99.138 -50000,0.66662,0.67984,0.05,99.138 -50000,0.66662,0.67984,0.05,99.138 -50000,0.66662,0.67984,0.05,99.138 -50000,0.66662,0.67984,0.05,99.138 -50000,0.67983,0.69331,0.05,99.486 -50000,0.67983,0.69331,0.05,99.486 -50000,0.67983,0.69331,0.05,99.486 -50000,0.67983,0.69331,0.05,99.486 -50000,0.67983,0.69331,0.05,99.486 -50000,0.67983,0.69331,0.05,99.486 -50000,0.67983,0.69331,0.05,99.486 -50000,0.67983,0.69331,0.05,99.486 -50000,0.67983,0.69331,0.05,99.486 -50000,0.67983,0.69331,0.05,99.486 -50000,0.67983,0.69331,0.05,99.486 -50000,0.67983,0.69331,0.05,99.486 -50000,0.67983,0.69331,0.05,99.486 -50000,0.67983,0.69331,0.05,99.486 -50000,0.6933,0.70704,0.05,99.83 -50000,0.6933,0.70704,0.05,99.83 -50000,0.6933,0.70704,0.05,99.83 -50000,0.6933,0.70704,0.05,99.83 -50000,0.6933,0.70704,0.05,99.83 -50000,0.6933,0.70704,0.05,99.83 -50000,0.6933,0.70704,0.05,99.83 -50000,0.6933,0.70704,0.05,99.83 -50000,0.6933,0.70704,0.05,99.83 -50000,0.6933,0.70704,0.05,99.83 -50000,0.6933,0.70704,0.05,99.83 -50000,0.6933,0.70704,0.05,99.83 -50000,0.6933,0.70704,0.05,99.83 -50000,0.6933,0.70704,0.05,99.83 -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/linearThermalDiffusionFigure.py b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/linearThermalDiffusionFigure.py new file mode 100644 index 00000000000..e0bc114041e --- /dev/null +++ b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/linearThermalDiffusionFigure.py @@ -0,0 +1,8 @@ +import os +try: + _this_dir = os.path.dirname(os.path.abspath(__file__)) +except NameError: + _this_dir = os.getcwd() + +import wellboreTemperatureFigure +wellboreTemperatureFigure.main(xmlFilePrefix='thermalCompressible_2d', outputDir=_this_dir) diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/linearThermalDiffusionQueries.py b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/linearThermalDiffusionQueries.py new file mode 100644 index 00000000000..47499e593be --- /dev/null +++ b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/linearThermalDiffusionQueries.py @@ -0,0 +1,6 @@ +import sys + +sys.path.append('../../../../../../../inputFiles/singlePhaseFlow/scripts') +import wellboreTemperatureQueries + +wellboreTemperatureQueries.main() diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/linearThermalDiffusion_plot.py b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/linearThermalDiffusion_plot.py deleted file mode 100644 index 67e336576c2..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/linearThermalDiffusion_plot.py +++ /dev/null @@ -1,147 +0,0 @@ -import os -import sys -import os -import argparse - -import numpy as np -import matplotlib.pyplot as plt -import pandas as pd -import scipy.linalg -from scipy import special -from xml.etree import ElementTree - -# Analytical results -def steadyState(Tin, Tout, Rin, Rout, radialCoordinate): - return Tin + (Tout - Tin) * (np.log(radialCoordinate) - np.log(Rin)) / (np.log(Rout) - np.log(Rin)) - -def diffusionFunction(radialCoordinate, Rin, diffusionCoefficient, diffusionTime): - return special.erfc( (radialCoordinate - Rin) / 2.0 / np.sqrt( diffusionCoefficient * diffusionTime ) ) - -def computeTransientTemperature(Tin, Tout, Rin, radialCoordinate, thermalDiffusionCoefficient, diffusionTime): - # Ref. Wang and Papamichos (1994), https://agupubs.onlinelibrary.wiley.com/doi/abs/10.1029/94WR01774 - return Tout + (Tin-Tout) * np.sqrt(Rin/radialCoordinate) * diffusionFunction(radialCoordinate, Rin, thermalDiffusionCoefficient, diffusionTime) - -def computeThermalDiffusionCoefficient(thermalConductivity, volumetricHeatCapacity): - return thermalConductivity / volumetricHeatCapacity - -def extractDataFromXMLList(paramList): - # Extract data from a list in XML such as "{ 1, 2, 3}" - return paramList.replace('{', '').replace('}', '').strip().split(',') - -def getWellboreGeometryFromXML(xmlFilePath): - tree = ElementTree.parse(xmlFilePath) - - meshParam = tree.find('Mesh/InternalWellbore') - radii = extractDataFromXMLList( meshParam.get("radius") ) - - Rin = float(radii[0]) - Rout = float(radii[-1]) - - return [Rin, Rout] - -def getLoadingFromXML(xmlFilePath): - tree = ElementTree.parse(xmlFilePath) - fsParams = tree.findall('FieldSpecifications/FieldSpecification') - - for fsParam in fsParams: - if ( (fsParam.get('fieldName') == "pressure") & (fsParam.get('initialCondition') != "1") ): - if fsParam.get('setNames') == "{ rneg }": - Pin = float(fsParam.get('scale')) - if fsParam.get('setNames') == "{ rpos }": - Pout = float(fsParam.get('scale')) - - for fsParam in fsParams: - if ( (fsParam.get('fieldName') == "temperature") & (fsParam.get('initialCondition') != "1") ): - if fsParam.get('setNames') == "{ rneg }": - Tin = float(fsParam.get('scale')) - if fsParam.get('setNames') == "{ rpos }": - Tout = float(fsParam.get('scale')) - - tree_SinglePhaseThermalConductivities = tree.findall('Constitutive/SinglePhaseThermalConductivity') - - for tree_SinglePhaseThermalConductivity in tree_SinglePhaseThermalConductivities: - if tree_SinglePhaseThermalConductivity.get('name') == "thermalCond_linear": - thermalConductivity = float( extractDataFromXMLList( tree_SinglePhaseThermalConductivity.get('defaultThermalConductivityComponents') )[0] ) - - tree_SolidInternalEnergies = tree.findall('Constitutive/SolidInternalEnergy') - - for tree_SolidInternalEnergy in tree_SolidInternalEnergies: - if tree_SolidInternalEnergy.get('name') == "rockInternalEnergy_linear": - volumetricHeatCapacity = float( tree_SolidInternalEnergy.get('referenceVolumetricHeatCapacity') ) - - permeability = float( extractDataFromXMLList( tree.find('Constitutive/ConstantPermeability').get('permeabilityComponents') )[0] ) - - porosity = float( tree.find('Constitutive/PressurePorosity').get('defaultReferencePorosity') ) - - fluidViscosity = float( tree.find('Constitutive/ThermalCompressibleSinglePhaseFluid').get('defaultViscosity') ) - - fluidCompressibility = float( tree.find('Constitutive/ThermalCompressibleSinglePhaseFluid').get('compressibility') ) - - fluidThermalExpansionCoefficient = float( tree.find('Constitutive/ThermalCompressibleSinglePhaseFluid').get('thermalExpansionCoeff') ) - - return [Pin, Pout, Tin, Tout, thermalConductivity, volumetricHeatCapacity, permeability, porosity, fluidViscosity, fluidCompressibility, fluidThermalExpansionCoefficient] - - -def main(): - - # Initialize the argument parser - parser = argparse.ArgumentParser(description="Script to generate figure from tutorial.") - - # Add arguments to accept individual file paths - parser.add_argument('--geosDir', help='Path to the GEOS repository ', default='../../../../../../..') - - # Parse the command-line arguments - args = parser.parse_args() - - geosDir = args.geosDir - - xmlFilePath = geosDir + "/inputFiles/singlePhaseFlow/thermalCompressible_2d" - - Rin, Rout = getWellboreGeometryFromXML(xmlFilePath+"_benchmark.xml") - - Pin, Pout, Tin, Tout, thermalConductivity, volumetricHeatCapacity, permeability, porosity, fluidViscosity, fluidCompressibility, fluidThermalExpansionCoefficient = getLoadingFromXML(xmlFilePath+"_base.xml") - - plt.figure(figsize=(10,7)) - font = {'size' : 16} - plt.rc('font', **font) - - for chart_idx, idx in enumerate([1, 2, 5, 10]): - # Numerical results - data = pd.read_csv(f'data_{idx}.csv') - radialCoordinate = (data['elementCenter:0']**2.0 + data['elementCenter:1']**2.0)**0.5 - temperature = data['temperature'] - diffusionTime = data['Time'][0] - - # Analytical results - thermalDiffusionCoefficient = computeThermalDiffusionCoefficient(thermalConductivity, volumetricHeatCapacity) - - T_transient = computeTransientTemperature(Tin, Tout, Rin, radialCoordinate, thermalDiffusionCoefficient, diffusionTime) - - # Analytical results of the steady state regime for comparison - T_steadyState = steadyState(Tin, Tout, Rin, Rout, radialCoordinate) - - # Visualization - # Temperature - plt.subplot(2,2,chart_idx+1) - plt.plot( radialCoordinate, temperature, 'k+' , label='GEOSX' ) - plt.plot( radialCoordinate, T_transient, 'r-' , label='Analytic, infinite domain' ) - plt.plot( radialCoordinate, T_steadyState, 'b-' , label='Steady State' ) - - if chart_idx==1: - plt.legend() - - if chart_idx in [2,3]: - plt.xlabel('Radial distance from well center') - - if chart_idx in [0,2]: - plt.ylabel('Temperature (°C)') - - plt.ylim(-30,110) - plt.xlim(0,1.0) - plt.title('t = '+str(diffusionTime)+'(s)') - plt.tight_layout() - - plt.show() - -if __name__ == "__main__": - main() diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/model-results.txt b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/model-results.txt new file mode 100644 index 00000000000..63ed251a6ac --- /dev/null +++ b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/linearThermalDiffusion/model-results.txt @@ -0,0 +1,465 @@ + time r temperature + 10000 0.100995 -18.9958 + 10000 0.102995 -17.027 + 10000 0.104995 -15.0962 + 10000 0.107345 -12.8707 + 10000 0.110045 -10.3783 + 10000 0.112745 -7.94752 + 10000 0.115444 -5.57586 + 10000 0.118144 -3.26092 + 10000 0.120844 -1.00049 + 10000 0.123544 1.2075 + 10000 0.126244 3.36498 + 10000 0.128944 5.47374 + 10000 0.131644 7.53547 + 10000 0.134305 9.52276 + 10000 0.136953 11.4586 + 10000 0.139654 13.3905 + 10000 0.142408 15.3182 + 10000 0.145217 17.2412 + 10000 0.148081 19.1591 + 10000 0.151003 21.0713 + 10000 0.153982 22.9774 + 10000 0.15702 24.8769 + 10000 0.160119 26.7691 + 10000 0.163279 28.6534 + 10000 0.166502 30.5294 + 10000 0.169788 32.3963 + 10000 0.17314 34.2535 + 10000 0.176558 36.1003 + 10000 0.180044 37.9359 + 10000 0.183599 39.7597 + 10000 0.187225 41.5708 + 10000 0.190922 43.3684 + 10000 0.194693 45.1518 + 10000 0.198539 46.92 + 10000 0.202461 48.6722 + 10000 0.20646 50.4075 + 10000 0.210539 52.1249 + 10000 0.214699 53.8236 + 10000 0.218941 55.5025 + 10000 0.223267 57.1607 + 10000 0.22768 58.7972 + 10000 0.232179 60.411 + 10000 0.236768 62.001 + 10000 0.241448 63.5663 + 10000 0.24622 65.1059 + 10000 0.251088 66.6186 + 10000 0.256051 68.1036 + 10000 0.261114 69.5598 + 10000 0.266276 70.9862 + 10000 0.271541 72.3818 + 10000 0.27691 73.7458 + 10000 0.282386 75.0771 + 10000 0.28797 76.375 + 10000 0.293665 77.6385 + 10000 0.299473 78.8669 + 10000 0.305396 80.0595 + 10000 0.311437 81.2156 + 10000 0.317597 82.3345 + 10000 0.32388 83.4157 + 10000 0.330287 84.4587 + 10000 0.336821 85.4631 + 10000 0.343485 86.4287 + 10000 0.35028 87.3551 + 10000 0.357211 88.2424 + 10000 0.364279 89.0903 + 10000 0.371487 89.899 + 10000 0.378838 90.6687 + 10000 0.386335 91.3995 + 10000 0.39398 92.0919 + 10000 0.401777 92.7464 + 10000 0.409728 93.3634 + 10000 0.417838 93.9437 + 10000 0.426108 94.4881 + 10000 0.434542 94.9973 + 10000 0.443143 95.4723 + 10000 0.451915 95.9142 + 10000 0.46086 96.324 + 10000 0.469983 96.7029 + 10000 0.479287 97.0522 + 10000 0.488776 97.373 + 10000 0.498452 97.6668 + 10000 0.508321 97.9349 + 10000 0.518385 98.1787 + 10000 0.528649 98.3995 + 10000 0.539116 98.5988 + 10000 0.54979 98.7781 + 10000 0.560677 98.9386 + 10000 0.571779 99.0818 + 10000 0.583101 99.2089 + 10000 0.594648 99.3214 + 10000 0.606424 99.4204 + 10000 0.618433 99.5072 + 10000 0.63068 99.5829 + 10000 0.643171 99.6487 + 10000 0.655908 99.7055 + 10000 0.668899 99.7544 + 10000 0.682147 99.7962 + 10000 0.695657 99.8318 + 10000 0.709436 99.8619 + 10000 0.723488 99.8872 + 10000 0.737818 99.9084 + 10000 0.752433 99.9261 + 10000 0.767337 99.9407 + 10000 0.782537 99.9527 + 10000 0.798038 99.9625 + 10000 0.813846 99.9705 + 10000 0.829968 99.9769 + 10000 0.84641 99.9821 + 10000 0.863178 99.9862 + 10000 0.880278 99.9895 + 10000 0.897717 99.9922 + 10000 0.915502 99.9943 + 10000 0.933639 99.9959 + 10000 0.952136 99.9973 + 10000 0.971 99.9985 + 10000 0.990238 99.9995 + 20000 0.100995 -19.1784 + 20000 0.102995 -17.5676 + 20000 0.104995 -15.9878 + 20000 0.107345 -14.1666 + 20000 0.110045 -12.1266 + 20000 0.112745 -10.1364 + 20000 0.115444 -8.19384 + 20000 0.118144 -6.29684 + 20000 0.120844 -4.44345 + 20000 0.123544 -2.63186 + 20000 0.126244 -0.860371 + 20000 0.128944 0.872587 + 20000 0.131644 2.5685 + 20000 0.134305 4.20487 + 20000 0.136953 5.80061 + 20000 0.139654 7.39514 + 20000 0.142408 8.98829 + 20000 0.145217 10.5799 + 20000 0.148081 12.1699 + 20000 0.151003 13.758 + 20000 0.153982 15.344 + 20000 0.15702 16.9279 + 20000 0.160119 18.5092 + 20000 0.163279 20.088 + 20000 0.166502 21.6638 + 20000 0.169788 23.2365 + 20000 0.17314 24.8059 + 20000 0.176558 26.3716 + 20000 0.180044 27.9333 + 20000 0.183599 29.4909 + 20000 0.187225 31.044 + 20000 0.190922 32.5922 + 20000 0.194693 34.1352 + 20000 0.198539 35.6728 + 20000 0.202461 37.2044 + 20000 0.20646 38.7297 + 20000 0.210539 40.2484 + 20000 0.214699 41.7599 + 20000 0.218941 43.264 + 20000 0.223267 44.76 + 20000 0.22768 46.2476 + 20000 0.232179 47.7262 + 20000 0.236768 49.1954 + 20000 0.241448 50.6546 + 20000 0.24622 52.1033 + 20000 0.251088 53.5409 + 20000 0.256051 54.9668 + 20000 0.261114 56.3805 + 20000 0.266276 57.7814 + 20000 0.271541 59.1687 + 20000 0.27691 60.5419 + 20000 0.282386 61.9004 + 20000 0.28797 63.2434 + 20000 0.293665 64.5702 + 20000 0.299473 65.8802 + 20000 0.305396 67.1727 + 20000 0.311437 68.447 + 20000 0.317597 69.7023 + 20000 0.32388 70.9379 + 20000 0.330287 72.1531 + 20000 0.336821 73.3472 + 20000 0.343485 74.5195 + 20000 0.35028 75.6692 + 20000 0.357211 76.7956 + 20000 0.364279 77.8981 + 20000 0.371487 78.976 + 20000 0.378838 80.0285 + 20000 0.386335 81.0551 + 20000 0.39398 82.0552 + 20000 0.401777 83.0281 + 20000 0.409728 83.9734 + 20000 0.417838 84.8905 + 20000 0.426108 85.7789 + 20000 0.434542 86.6382 + 20000 0.443143 87.4681 + 20000 0.451915 88.2682 + 20000 0.46086 89.0382 + 20000 0.469983 89.7779 + 20000 0.479287 90.4873 + 20000 0.488776 91.1662 + 20000 0.498452 91.8146 + 20000 0.508321 92.4326 + 20000 0.518385 93.0203 + 20000 0.528649 93.578 + 20000 0.539116 94.1059 + 20000 0.54979 94.6045 + 20000 0.560677 95.0741 + 20000 0.571779 95.5152 + 20000 0.583101 95.9286 + 20000 0.594648 96.3147 + 20000 0.606424 96.6745 + 20000 0.618433 97.0086 + 20000 0.63068 97.3179 + 20000 0.643171 97.6034 + 20000 0.655908 97.866 + 20000 0.668899 98.1067 + 20000 0.682147 98.3266 + 20000 0.695657 98.5267 + 20000 0.709436 98.7081 + 20000 0.723488 98.872 + 20000 0.737818 99.0194 + 20000 0.752433 99.1516 + 20000 0.767337 99.2695 + 20000 0.782537 99.3744 + 20000 0.798038 99.4673 + 20000 0.813846 99.5493 + 20000 0.829968 99.6215 + 20000 0.84641 99.6848 + 20000 0.863178 99.7403 + 20000 0.880278 99.7889 + 20000 0.897717 99.8315 + 20000 0.915502 99.8691 + 20000 0.933639 99.9026 + 20000 0.952136 99.9328 + 20000 0.971 99.9607 + 20000 0.990238 99.9872 + 50000 0.100995 -19.3455 + 50000 0.102995 -18.0621 + 50000 0.104995 -16.8034 + 50000 0.107345 -15.3524 + 50000 0.110045 -13.7267 + 50000 0.112745 -12.1406 + 50000 0.115444 -10.5922 + 50000 0.118144 -9.07968 + 50000 0.120844 -7.60157 + 50000 0.123544 -6.15634 + 50000 0.126244 -4.7426 + 50000 0.128944 -3.35905 + 50000 0.131644 -2.00447 + 50000 0.134305 -0.696793 + 50000 0.136953 0.579079 + 50000 0.139654 1.85472 + 50000 0.142408 3.13009 + 50000 0.145217 4.40514 + 50000 0.148081 5.67984 + 50000 0.151003 6.95412 + 50000 0.153982 8.22794 + 50000 0.15702 9.50125 + 50000 0.160119 10.774 + 50000 0.163279 12.0461 + 50000 0.166502 13.3175 + 50000 0.169788 14.5881 + 50000 0.17314 15.858 + 50000 0.176558 17.1269 + 50000 0.180044 18.3948 + 50000 0.183599 19.6616 + 50000 0.187225 20.9273 + 50000 0.190922 22.1917 + 50000 0.194693 23.4548 + 50000 0.198539 24.7164 + 50000 0.202461 25.9765 + 50000 0.20646 27.2349 + 50000 0.210539 28.4915 + 50000 0.214699 29.7462 + 50000 0.218941 30.9989 + 50000 0.223267 32.2493 + 50000 0.22768 33.4974 + 50000 0.232179 34.7431 + 50000 0.236768 35.9861 + 50000 0.241448 37.2263 + 50000 0.24622 38.4635 + 50000 0.251088 39.6976 + 50000 0.256051 40.9283 + 50000 0.261114 42.1554 + 50000 0.266276 43.3788 + 50000 0.271541 44.5982 + 50000 0.27691 45.8134 + 50000 0.282386 47.0241 + 50000 0.28797 48.2302 + 50000 0.293665 49.4313 + 50000 0.299473 50.6272 + 50000 0.305396 51.8176 + 50000 0.311437 53.0023 + 50000 0.317597 54.1808 + 50000 0.32388 55.353 + 50000 0.330287 56.5185 + 50000 0.336821 57.6769 + 50000 0.343485 58.828 + 50000 0.35028 59.9713 + 50000 0.357211 61.1065 + 50000 0.364279 62.2333 + 50000 0.371487 63.3512 + 50000 0.378838 64.4598 + 50000 0.386335 65.5588 + 50000 0.39398 66.6477 + 50000 0.401777 67.7261 + 50000 0.409728 68.7936 + 50000 0.417838 69.8496 + 50000 0.426108 70.8939 + 50000 0.434542 71.9258 + 50000 0.443143 72.945 + 50000 0.451915 73.951 + 50000 0.46086 74.9432 + 50000 0.469983 75.9213 + 50000 0.479287 76.8848 + 50000 0.488776 77.8332 + 50000 0.498452 78.7659 + 50000 0.508321 79.6826 + 50000 0.518385 80.5828 + 50000 0.528649 81.4661 + 50000 0.539116 82.3319 + 50000 0.54979 83.1799 + 50000 0.560677 84.0097 + 50000 0.571779 84.8209 + 50000 0.583101 85.6131 + 50000 0.594648 86.3859 + 50000 0.606424 87.1391 + 50000 0.618433 87.8724 + 50000 0.63068 88.5856 + 50000 0.643171 89.2784 + 50000 0.655908 89.9508 + 50000 0.668899 90.6025 + 50000 0.682147 91.2336 + 50000 0.695657 91.8441 + 50000 0.709436 92.434 + 50000 0.723488 93.0036 + 50000 0.737818 93.553 + 50000 0.752433 94.0825 + 50000 0.767337 94.5926 + 50000 0.782537 95.0838 + 50000 0.798038 95.5565 + 50000 0.813846 96.0116 + 50000 0.829968 96.4498 + 50000 0.84641 96.872 + 50000 0.863178 97.2793 + 50000 0.880278 97.6729 + 50000 0.897717 98.0541 + 50000 0.915502 98.4243 + 50000 0.933639 98.7851 + 50000 0.952136 99.1384 + 50000 0.971 99.4861 + 50000 0.990238 99.8302 + 100000 0.100995 -19.4316 + 100000 0.102995 -18.3171 + 100000 0.104995 -17.224 + 100000 0.107345 -15.9639 + 100000 0.110045 -14.5521 + 100000 0.112745 -13.1746 + 100000 0.115444 -11.8297 + 100000 0.118144 -10.516 + 100000 0.120844 -9.23194 + 100000 0.123544 -7.97638 + 100000 0.126244 -6.74804 + 100000 0.128944 -5.54577 + 100000 0.131644 -4.36851 + 100000 0.134305 -3.23185 + 100000 0.136953 -2.12264 + 100000 0.139654 -1.01343 + 100000 0.142408 0.0957633 + 100000 0.145217 1.20493 + 100000 0.148081 2.31405 + 100000 0.151003 3.42311 + 100000 0.153982 4.53209 + 100000 0.15702 5.64098 + 100000 0.160119 6.74974 + 100000 0.163279 7.85837 + 100000 0.166502 8.96684 + 100000 0.169788 10.0751 + 100000 0.17314 11.1832 + 100000 0.176558 12.2911 + 100000 0.180044 13.3986 + 100000 0.183599 14.506 + 100000 0.187225 15.6129 + 100000 0.190922 16.7196 + 100000 0.194693 17.8258 + 100000 0.198539 18.9317 + 100000 0.202461 20.0371 + 100000 0.20646 21.142 + 100000 0.210539 22.2464 + 100000 0.214699 23.3502 + 100000 0.218941 24.4534 + 100000 0.223267 25.556 + 100000 0.22768 26.6578 + 100000 0.232179 27.7589 + 100000 0.236768 28.8592 + 100000 0.241448 29.9586 + 100000 0.24622 31.0571 + 100000 0.251088 32.1546 + 100000 0.256051 33.2511 + 100000 0.261114 34.3465 + 100000 0.266276 35.4406 + 100000 0.271541 36.5335 + 100000 0.27691 37.6251 + 100000 0.282386 38.7153 + 100000 0.28797 39.8039 + 100000 0.293665 40.891 + 100000 0.299473 41.9764 + 100000 0.305396 43.06 + 100000 0.311437 44.1418 + 100000 0.317597 45.2216 + 100000 0.32388 46.2993 + 100000 0.330287 47.3748 + 100000 0.336821 48.448 + 100000 0.343485 49.5188 + 100000 0.35028 50.587 + 100000 0.357211 51.6526 + 100000 0.364279 52.7153 + 100000 0.371487 53.7751 + 100000 0.378838 54.8318 + 100000 0.386335 55.8852 + 100000 0.39398 56.9353 + 100000 0.401777 57.9817 + 100000 0.409728 59.0245 + 100000 0.417838 60.0634 + 100000 0.426108 61.0983 + 100000 0.434542 62.1289 + 100000 0.443143 63.1551 + 100000 0.451915 64.1767 + 100000 0.46086 65.1936 + 100000 0.469983 66.2055 + 100000 0.479287 67.2122 + 100000 0.488776 68.2136 + 100000 0.498452 69.2095 + 100000 0.508321 70.1996 + 100000 0.518385 71.1838 + 100000 0.528649 72.1619 + 100000 0.539116 73.1336 + 100000 0.54979 74.0989 + 100000 0.560677 75.0574 + 100000 0.571779 76.0091 + 100000 0.583101 76.9537 + 100000 0.594648 77.8911 + 100000 0.606424 78.821 + 100000 0.618433 79.7435 + 100000 0.63068 80.6582 + 100000 0.643171 81.5651 + 100000 0.655908 82.464 + 100000 0.668899 83.355 + 100000 0.682147 84.2378 + 100000 0.695657 85.1125 + 100000 0.709436 85.979 + 100000 0.723488 86.8373 + 100000 0.737818 87.6875 + 100000 0.752433 88.5296 + 100000 0.767337 89.3638 + 100000 0.782537 90.1901 + 100000 0.798038 91.0088 + 100000 0.813846 91.8201 + 100000 0.829968 92.6244 + 100000 0.84641 93.4218 + 100000 0.863178 94.213 + 100000 0.880278 94.9983 + 100000 0.897717 95.7782 + 100000 0.915502 96.5535 + 100000 0.933639 97.3247 + 100000 0.952136 98.0926 + 100000 0.971 98.8581 + 100000 0.990238 99.622 diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/Example.rst b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/Example.rst index aa8fbb0677e..af5e72dcbe7 100644 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/Example.rst +++ b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/Example.rst @@ -49,7 +49,7 @@ Results and benchmark A good agreement between the results obtained using GEOS and the reference results that are obtained by the classical finite difference method is shown in the figure below: -.. plot:: docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/temperatureDependentSinglePhaseThermalConductivity_plot.py +.. plot:: docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/thermalConductivityFigure.py ------------------------------------------------------------------ diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_1.csv b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_1.csv deleted file mode 100644 index 8771183d7fa..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_1.csv +++ /dev/null @@ -1,1002 +0,0 @@ -Time,"elementCenter:0","elementCenter:1","elementCenter:2","temperature" -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,0.07071,0.072112,0.05,-19.002 -10000,0.07071,0.072112,0.05,-19.002 -10000,0.07211,0.07354,0.05,-17.045 -10000,0.07351,0.074968,0.05,-15.122 -10000,0.075155,0.076646,0.05,-12.902 -10000,0.075155,0.076646,0.05,-12.902 -10000,0.077046,0.078574,0.05,-10.412 -10000,0.077046,0.078574,0.05,-10.412 -10000,0.078936,0.080501,0.05,-7.9783 -10000,0.078936,0.080501,0.05,-7.9783 -10000,0.080826,0.082429,0.05,-5.5998 -10000,0.080826,0.082429,0.05,-5.5998 -10000,0.082716,0.084357,0.05,-3.2741 -10000,0.082716,0.084357,0.05,-3.2741 -10000,0.084607,0.086285,0.05,-0.99929 -10000,0.084607,0.086285,0.05,-0.99929 -10000,0.086497,0.088212,0.05,1.2264 -10000,0.086497,0.088212,0.05,1.2264 -10000,0.088387,0.09014,0.05,3.4046 -10000,0.088387,0.09014,0.05,3.4046 -10000,0.090278,0.092068,0.05,5.537 -10000,0.090278,0.092068,0.05,5.537 -10000,0.092168,0.093995,0.05,7.6248 -10000,0.092168,0.093995,0.05,7.6248 -10000,0.094031,0.095896,0.05,9.6402 -10000,0.095885,0.097786,0.05,11.606 -10000,0.095885,0.097786,0.05,11.606 -10000,0.097776,0.099715,0.05,13.57 -10000,0.097776,0.099715,0.05,13.57 -10000,0.099704,0.10168,0.05,15.533 -10000,0.099704,0.10168,0.05,15.533 -10000,0.10167,0.10369,0.05,17.494 -10000,0.10167,0.10369,0.05,17.494 -10000,0.10368,0.10573,0.05,19.451 -10000,0.10368,0.10573,0.05,19.451 -10000,0.10572,0.10782,0.05,21.405 -10000,0.10572,0.10782,0.05,21.405 -10000,0.10781,0.10995,0.05,23.355 -10000,0.10781,0.10995,0.05,23.355 -10000,0.10993,0.11211,0.05,25.301 -10000,0.10993,0.11211,0.05,25.301 -10000,0.10993,0.11211,0.05,25.301 -10000,0.1121,0.11433,0.05,27.241 -10000,0.1121,0.11433,0.05,27.241 -10000,0.11432,0.11658,0.05,29.174 -10000,0.11432,0.11658,0.05,29.174 -10000,0.11657,0.11888,0.05,31.102 -10000,0.11657,0.11888,0.05,31.102 -10000,0.11887,0.12123,0.05,33.021 -10000,0.11887,0.12123,0.05,33.021 -10000,0.11887,0.12123,0.05,33.021 -10000,0.12122,0.12362,0.05,34.932 -10000,0.12122,0.12362,0.05,34.932 -10000,0.12361,0.12607,0.05,36.834 -10000,0.12361,0.12607,0.05,36.834 -10000,0.12361,0.12607,0.05,36.834 -10000,0.12605,0.12855,0.05,38.726 -10000,0.12605,0.12855,0.05,38.726 -10000,0.12854,0.13109,0.05,40.606 -10000,0.12854,0.13109,0.05,40.606 -10000,0.12854,0.13109,0.05,40.606 -10000,0.13108,0.13368,0.05,42.475 -10000,0.13108,0.13368,0.05,42.475 -10000,0.13367,0.13632,0.05,44.33 -10000,0.13367,0.13632,0.05,44.33 -10000,0.13367,0.13632,0.05,44.33 -10000,0.13631,0.13901,0.05,46.171 -10000,0.13631,0.13901,0.05,46.171 -10000,0.13631,0.13901,0.05,46.171 -10000,0.139,0.14176,0.05,47.997 -10000,0.139,0.14176,0.05,47.997 -10000,0.14175,0.14456,0.05,49.807 -10000,0.14175,0.14456,0.05,49.807 -10000,0.14175,0.14456,0.05,49.807 -10000,0.14455,0.14742,0.05,51.599 -10000,0.14455,0.14742,0.05,51.599 -10000,0.14455,0.14742,0.05,51.599 -10000,0.1474,0.15033,0.05,53.373 -10000,0.1474,0.15033,0.05,53.373 -10000,0.1474,0.15033,0.05,53.373 -10000,0.15032,0.1533,0.05,55.127 -10000,0.15032,0.1533,0.05,55.127 -10000,0.15032,0.1533,0.05,55.127 -10000,0.15329,0.15633,0.05,56.86 -10000,0.15329,0.15633,0.05,56.86 -10000,0.15329,0.15633,0.05,56.86 -10000,0.15632,0.15942,0.05,58.57 -10000,0.15632,0.15942,0.05,58.57 -10000,0.15632,0.15942,0.05,58.57 -10000,0.15941,0.16257,0.05,60.257 -10000,0.15941,0.16257,0.05,60.257 -10000,0.15941,0.16257,0.05,60.257 -10000,0.16256,0.16578,0.05,61.92 -10000,0.16256,0.16578,0.05,61.92 -10000,0.16256,0.16578,0.05,61.92 -10000,0.16577,0.16906,0.05,63.556 -10000,0.16577,0.16906,0.05,63.556 -10000,0.16577,0.16906,0.05,63.556 -10000,0.16577,0.16906,0.05,63.556 -10000,0.16905,0.1724,0.05,65.165 -10000,0.16905,0.1724,0.05,65.165 -10000,0.16905,0.1724,0.05,65.165 -10000,0.17239,0.1758,0.05,66.746 -10000,0.17239,0.1758,0.05,66.746 -10000,0.17239,0.1758,0.05,66.746 -10000,0.17579,0.17928,0.05,68.296 -10000,0.17579,0.17928,0.05,68.296 -10000,0.17579,0.17928,0.05,68.296 -10000,0.17579,0.17928,0.05,68.296 -10000,0.17927,0.18282,0.05,69.816 -10000,0.17927,0.18282,0.05,69.816 -10000,0.17927,0.18282,0.05,69.816 -10000,0.18281,0.18644,0.05,71.303 -10000,0.18281,0.18644,0.05,71.303 -10000,0.18281,0.18644,0.05,71.303 -10000,0.18281,0.18644,0.05,71.303 -10000,0.18643,0.19013,0.05,72.756 -10000,0.18643,0.19013,0.05,72.756 -10000,0.18643,0.19013,0.05,72.756 -10000,0.18643,0.19013,0.05,72.756 -10000,0.19011,0.19388,0.05,74.175 -10000,0.19011,0.19388,0.05,74.175 -10000,0.19011,0.19388,0.05,74.175 -10000,0.19387,0.19772,0.05,75.558 -10000,0.19387,0.19772,0.05,75.558 -10000,0.19387,0.19772,0.05,75.558 -10000,0.19387,0.19772,0.05,75.558 -10000,0.19771,0.20163,0.05,76.904 -10000,0.19771,0.20163,0.05,76.904 -10000,0.19771,0.20163,0.05,76.904 -10000,0.19771,0.20163,0.05,76.904 -10000,0.20162,0.20562,0.05,78.213 -10000,0.20162,0.20562,0.05,78.213 -10000,0.20162,0.20562,0.05,78.213 -10000,0.20162,0.20562,0.05,78.213 -10000,0.2056,0.20968,0.05,79.482 -10000,0.2056,0.20968,0.05,79.482 -10000,0.2056,0.20968,0.05,79.482 -10000,0.2056,0.20968,0.05,79.482 -10000,0.20967,0.21383,0.05,80.712 -10000,0.20967,0.21383,0.05,80.712 -10000,0.20967,0.21383,0.05,80.712 -10000,0.20967,0.21383,0.05,80.712 -10000,0.21382,0.21806,0.05,81.901 -10000,0.21382,0.21806,0.05,81.901 -10000,0.21382,0.21806,0.05,81.901 -10000,0.21382,0.21806,0.05,81.901 -10000,0.21382,0.21806,0.05,81.901 -10000,0.21805,0.22237,0.05,83.048 -10000,0.21805,0.22237,0.05,83.048 -10000,0.21805,0.22237,0.05,83.048 -10000,0.21805,0.22237,0.05,83.048 -10000,0.22236,0.22677,0.05,84.154 -10000,0.22236,0.22677,0.05,84.154 -10000,0.22236,0.22677,0.05,84.154 -10000,0.22236,0.22677,0.05,84.154 -10000,0.22676,0.23125,0.05,85.218 -10000,0.22676,0.23125,0.05,85.218 -10000,0.22676,0.23125,0.05,85.218 -10000,0.22676,0.23125,0.05,85.218 -10000,0.22676,0.23125,0.05,85.218 -10000,0.23124,0.23583,0.05,86.239 -10000,0.23124,0.23583,0.05,86.239 -10000,0.23124,0.23583,0.05,86.239 -10000,0.23124,0.23583,0.05,86.239 -10000,0.23582,0.2405,0.05,87.216 -10000,0.23582,0.2405,0.05,87.216 -10000,0.23582,0.2405,0.05,87.216 -10000,0.23582,0.2405,0.05,87.216 -10000,0.23582,0.2405,0.05,87.216 -10000,0.24048,0.24525,0.05,88.15 -10000,0.24048,0.24525,0.05,88.15 -10000,0.24048,0.24525,0.05,88.15 -10000,0.24048,0.24525,0.05,88.15 -10000,0.24048,0.24525,0.05,88.15 -10000,0.24524,0.25011,0.05,89.041 -10000,0.24524,0.25011,0.05,89.041 -10000,0.24524,0.25011,0.05,89.041 -10000,0.24524,0.25011,0.05,89.041 -10000,0.24524,0.25011,0.05,89.041 -10000,0.25009,0.25505,0.05,89.889 -10000,0.25009,0.25505,0.05,89.889 -10000,0.25009,0.25505,0.05,89.889 -10000,0.25009,0.25505,0.05,89.889 -10000,0.25009,0.25505,0.05,89.889 -10000,0.25504,0.2601,0.05,90.694 -10000,0.25504,0.2601,0.05,90.694 -10000,0.25504,0.2601,0.05,90.694 -10000,0.25504,0.2601,0.05,90.694 -10000,0.25504,0.2601,0.05,90.694 -10000,0.26009,0.26525,0.05,91.456 -10000,0.26009,0.26525,0.05,91.456 -10000,0.26009,0.26525,0.05,91.456 -10000,0.26009,0.26525,0.05,91.456 -10000,0.26009,0.26525,0.05,91.456 -10000,0.26524,0.2705,0.05,92.175 -10000,0.26524,0.2705,0.05,92.175 -10000,0.26524,0.2705,0.05,92.175 -10000,0.26524,0.2705,0.05,92.175 -10000,0.26524,0.2705,0.05,92.175 -10000,0.27048,0.27585,0.05,92.853 -10000,0.27048,0.27585,0.05,92.853 -10000,0.27048,0.27585,0.05,92.853 -10000,0.27048,0.27585,0.05,92.853 -10000,0.27048,0.27585,0.05,92.853 -10000,0.27584,0.28131,0.05,93.49 -10000,0.27584,0.28131,0.05,93.49 -10000,0.27584,0.28131,0.05,93.49 -10000,0.27584,0.28131,0.05,93.49 -10000,0.27584,0.28131,0.05,93.49 -10000,0.27584,0.28131,0.05,93.49 -10000,0.2813,0.28687,0.05,94.087 -10000,0.2813,0.28687,0.05,94.087 -10000,0.2813,0.28687,0.05,94.087 -10000,0.2813,0.28687,0.05,94.087 -10000,0.2813,0.28687,0.05,94.087 -10000,0.28686,0.29255,0.05,94.644 -10000,0.28686,0.29255,0.05,94.644 -10000,0.28686,0.29255,0.05,94.644 -10000,0.28686,0.29255,0.05,94.644 -10000,0.28686,0.29255,0.05,94.644 -10000,0.28686,0.29255,0.05,94.644 -10000,0.29254,0.29834,0.05,95.164 -10000,0.29254,0.29834,0.05,95.164 -10000,0.29254,0.29834,0.05,95.164 -10000,0.29254,0.29834,0.05,95.164 -10000,0.29254,0.29834,0.05,95.164 -10000,0.29254,0.29834,0.05,95.164 -10000,0.29833,0.30425,0.05,95.646 -10000,0.29833,0.30425,0.05,95.646 -10000,0.29833,0.30425,0.05,95.646 -10000,0.29833,0.30425,0.05,95.646 -10000,0.29833,0.30425,0.05,95.646 -10000,0.29833,0.30425,0.05,95.646 -10000,0.30424,0.31027,0.05,96.092 -10000,0.30424,0.31027,0.05,96.092 -10000,0.30424,0.31027,0.05,96.092 -10000,0.30424,0.31027,0.05,96.092 -10000,0.30424,0.31027,0.05,96.092 -10000,0.30424,0.31027,0.05,96.092 -10000,0.31026,0.31641,0.05,96.504 -10000,0.31026,0.31641,0.05,96.504 -10000,0.31026,0.31641,0.05,96.504 -10000,0.31026,0.31641,0.05,96.504 -10000,0.31026,0.31641,0.05,96.504 -10000,0.31026,0.31641,0.05,96.504 -10000,0.3164,0.32267,0.05,96.883 -10000,0.3164,0.32267,0.05,96.883 -10000,0.3164,0.32267,0.05,96.883 -10000,0.3164,0.32267,0.05,96.883 -10000,0.3164,0.32267,0.05,96.883 -10000,0.3164,0.32267,0.05,96.883 -10000,0.32266,0.32906,0.05,97.23 -10000,0.32266,0.32906,0.05,97.23 -10000,0.32266,0.32906,0.05,97.23 -10000,0.32266,0.32906,0.05,97.23 -10000,0.32266,0.32906,0.05,97.23 -10000,0.32266,0.32906,0.05,97.23 -10000,0.32266,0.32906,0.05,97.23 -10000,0.32905,0.33558,0.05,97.548 -10000,0.32905,0.33558,0.05,97.548 -10000,0.32905,0.33558,0.05,97.548 -10000,0.32905,0.33558,0.05,97.548 -10000,0.32905,0.33558,0.05,97.548 -10000,0.32905,0.33558,0.05,97.548 -10000,0.33556,0.34222,0.05,97.836 -10000,0.33556,0.34222,0.05,97.836 -10000,0.33556,0.34222,0.05,97.836 -10000,0.33556,0.34222,0.05,97.836 -10000,0.33556,0.34222,0.05,97.836 -10000,0.33556,0.34222,0.05,97.836 -10000,0.33556,0.34222,0.05,97.836 -10000,0.34221,0.34899,0.05,98.098 -10000,0.34221,0.34899,0.05,98.098 -10000,0.34221,0.34899,0.05,98.098 -10000,0.34221,0.34899,0.05,98.098 -10000,0.34221,0.34899,0.05,98.098 -10000,0.34221,0.34899,0.05,98.098 -10000,0.34221,0.34899,0.05,98.098 -10000,0.34898,0.3559,0.05,98.334 -10000,0.34898,0.3559,0.05,98.334 -10000,0.34898,0.3559,0.05,98.334 -10000,0.34898,0.3559,0.05,98.334 -10000,0.34898,0.3559,0.05,98.334 -10000,0.34898,0.3559,0.05,98.334 -10000,0.35589,0.36295,0.05,98.547 -10000,0.35589,0.36295,0.05,98.547 -10000,0.35589,0.36295,0.05,98.547 -10000,0.35589,0.36295,0.05,98.547 -10000,0.35589,0.36295,0.05,98.547 -10000,0.35589,0.36295,0.05,98.547 -10000,0.35589,0.36295,0.05,98.547 -10000,0.36294,0.37013,0.05,98.738 -10000,0.36294,0.37013,0.05,98.738 -10000,0.36294,0.37013,0.05,98.738 -10000,0.36294,0.37013,0.05,98.738 -10000,0.36294,0.37013,0.05,98.738 -10000,0.36294,0.37013,0.05,98.738 -10000,0.36294,0.37013,0.05,98.738 -10000,0.36294,0.37013,0.05,98.738 -10000,0.37012,0.37746,0.05,98.908 -10000,0.37012,0.37746,0.05,98.908 -10000,0.37012,0.37746,0.05,98.908 -10000,0.37012,0.37746,0.05,98.908 -10000,0.37012,0.37746,0.05,98.908 -10000,0.37012,0.37746,0.05,98.908 -10000,0.37012,0.37746,0.05,98.908 -10000,0.37745,0.38494,0.05,99.059 -10000,0.37745,0.38494,0.05,99.059 -10000,0.37745,0.38494,0.05,99.059 -10000,0.37745,0.38494,0.05,99.059 -10000,0.37745,0.38494,0.05,99.059 -10000,0.37745,0.38494,0.05,99.059 -10000,0.37745,0.38494,0.05,99.059 -10000,0.38493,0.39256,0.05,99.193 -10000,0.38493,0.39256,0.05,99.193 -10000,0.38493,0.39256,0.05,99.193 -10000,0.38493,0.39256,0.05,99.193 -10000,0.38493,0.39256,0.05,99.193 -10000,0.38493,0.39256,0.05,99.193 -10000,0.38493,0.39256,0.05,99.193 -10000,0.38493,0.39256,0.05,99.193 -10000,0.39255,0.40033,0.05,99.31 -10000,0.39255,0.40033,0.05,99.31 -10000,0.39255,0.40033,0.05,99.31 -10000,0.39255,0.40033,0.05,99.31 -10000,0.39255,0.40033,0.05,99.31 -10000,0.39255,0.40033,0.05,99.31 -10000,0.39255,0.40033,0.05,99.31 -10000,0.39255,0.40033,0.05,99.31 -10000,0.40032,0.40826,0.05,99.414 -10000,0.40032,0.40826,0.05,99.414 -10000,0.40032,0.40826,0.05,99.414 -10000,0.40032,0.40826,0.05,99.414 -10000,0.40032,0.40826,0.05,99.414 -10000,0.40032,0.40826,0.05,99.414 -10000,0.40032,0.40826,0.05,99.414 -10000,0.40032,0.40826,0.05,99.414 -10000,0.40825,0.41634,0.05,99.504 -10000,0.40825,0.41634,0.05,99.504 -10000,0.40825,0.41634,0.05,99.504 -10000,0.40825,0.41634,0.05,99.504 -10000,0.40825,0.41634,0.05,99.504 -10000,0.40825,0.41634,0.05,99.504 -10000,0.40825,0.41634,0.05,99.504 -10000,0.40825,0.41634,0.05,99.504 -10000,0.41633,0.42459,0.05,99.582 -10000,0.41633,0.42459,0.05,99.582 -10000,0.41633,0.42459,0.05,99.582 -10000,0.41633,0.42459,0.05,99.582 -10000,0.41633,0.42459,0.05,99.582 -10000,0.41633,0.42459,0.05,99.582 -10000,0.41633,0.42459,0.05,99.582 -10000,0.41633,0.42459,0.05,99.582 -10000,0.42458,0.433,0.05,99.65 -10000,0.42458,0.433,0.05,99.65 -10000,0.42458,0.433,0.05,99.65 -10000,0.42458,0.433,0.05,99.65 -10000,0.42458,0.433,0.05,99.65 -10000,0.42458,0.433,0.05,99.65 -10000,0.42458,0.433,0.05,99.65 -10000,0.42458,0.433,0.05,99.65 -10000,0.42458,0.433,0.05,99.65 -10000,0.43298,0.44157,0.05,99.708 -10000,0.43298,0.44157,0.05,99.708 -10000,0.43298,0.44157,0.05,99.708 -10000,0.43298,0.44157,0.05,99.708 -10000,0.43298,0.44157,0.05,99.708 -10000,0.43298,0.44157,0.05,99.708 -10000,0.43298,0.44157,0.05,99.708 -10000,0.43298,0.44157,0.05,99.708 -10000,0.44156,0.45031,0.05,99.758 -10000,0.44156,0.45031,0.05,99.758 -10000,0.44156,0.45031,0.05,99.758 -10000,0.44156,0.45031,0.05,99.758 -10000,0.44156,0.45031,0.05,99.758 -10000,0.44156,0.45031,0.05,99.758 -10000,0.44156,0.45031,0.05,99.758 -10000,0.44156,0.45031,0.05,99.758 -10000,0.44156,0.45031,0.05,99.758 -10000,0.4503,0.45923,0.05,99.8 -10000,0.4503,0.45923,0.05,99.8 -10000,0.4503,0.45923,0.05,99.8 -10000,0.4503,0.45923,0.05,99.8 -10000,0.4503,0.45923,0.05,99.8 -10000,0.4503,0.45923,0.05,99.8 -10000,0.4503,0.45923,0.05,99.8 -10000,0.4503,0.45923,0.05,99.8 -10000,0.4503,0.45923,0.05,99.8 -10000,0.45922,0.46833,0.05,99.836 -10000,0.45922,0.46833,0.05,99.836 -10000,0.45922,0.46833,0.05,99.836 -10000,0.45922,0.46833,0.05,99.836 -10000,0.45922,0.46833,0.05,99.836 -10000,0.45922,0.46833,0.05,99.836 -10000,0.45922,0.46833,0.05,99.836 -10000,0.45922,0.46833,0.05,99.836 -10000,0.45922,0.46833,0.05,99.836 -10000,0.46832,0.4776,0.05,99.866 -10000,0.46832,0.4776,0.05,99.866 -10000,0.46832,0.4776,0.05,99.866 -10000,0.46832,0.4776,0.05,99.866 -10000,0.46832,0.4776,0.05,99.866 -10000,0.46832,0.4776,0.05,99.866 -10000,0.46832,0.4776,0.05,99.866 -10000,0.46832,0.4776,0.05,99.866 -10000,0.46832,0.4776,0.05,99.866 -10000,0.47759,0.48706,0.05,99.891 -10000,0.47759,0.48706,0.05,99.891 -10000,0.47759,0.48706,0.05,99.891 -10000,0.47759,0.48706,0.05,99.891 -10000,0.47759,0.48706,0.05,99.891 -10000,0.47759,0.48706,0.05,99.891 -10000,0.47759,0.48706,0.05,99.891 -10000,0.47759,0.48706,0.05,99.891 -10000,0.47759,0.48706,0.05,99.891 -10000,0.47759,0.48706,0.05,99.891 -10000,0.48705,0.49671,0.05,99.912 -10000,0.48705,0.49671,0.05,99.912 -10000,0.48705,0.49671,0.05,99.912 -10000,0.48705,0.49671,0.05,99.912 -10000,0.48705,0.49671,0.05,99.912 -10000,0.48705,0.49671,0.05,99.912 -10000,0.48705,0.49671,0.05,99.912 -10000,0.48705,0.49671,0.05,99.912 -10000,0.48705,0.49671,0.05,99.912 -10000,0.4967,0.50655,0.05,99.93 -10000,0.4967,0.50655,0.05,99.93 -10000,0.4967,0.50655,0.05,99.93 -10000,0.4967,0.50655,0.05,99.93 -10000,0.4967,0.50655,0.05,99.93 -10000,0.4967,0.50655,0.05,99.93 -10000,0.4967,0.50655,0.05,99.93 -10000,0.4967,0.50655,0.05,99.93 -10000,0.4967,0.50655,0.05,99.93 -10000,0.4967,0.50655,0.05,99.93 -10000,0.50654,0.51658,0.05,99.944 -10000,0.50654,0.51658,0.05,99.944 -10000,0.50654,0.51658,0.05,99.944 -10000,0.50654,0.51658,0.05,99.944 -10000,0.50654,0.51658,0.05,99.944 -10000,0.50654,0.51658,0.05,99.944 -10000,0.50654,0.51658,0.05,99.944 -10000,0.50654,0.51658,0.05,99.944 -10000,0.50654,0.51658,0.05,99.944 -10000,0.50654,0.51658,0.05,99.944 -10000,0.51657,0.52681,0.05,99.955 -10000,0.51657,0.52681,0.05,99.955 -10000,0.51657,0.52681,0.05,99.955 -10000,0.51657,0.52681,0.05,99.955 -10000,0.51657,0.52681,0.05,99.955 -10000,0.51657,0.52681,0.05,99.955 -10000,0.51657,0.52681,0.05,99.955 -10000,0.51657,0.52681,0.05,99.955 -10000,0.51657,0.52681,0.05,99.955 -10000,0.51657,0.52681,0.05,99.955 -10000,0.5268,0.53725,0.05,99.965 -10000,0.5268,0.53725,0.05,99.965 -10000,0.5268,0.53725,0.05,99.965 -10000,0.5268,0.53725,0.05,99.965 -10000,0.5268,0.53725,0.05,99.965 -10000,0.5268,0.53725,0.05,99.965 -10000,0.5268,0.53725,0.05,99.965 -10000,0.5268,0.53725,0.05,99.965 -10000,0.5268,0.53725,0.05,99.965 -10000,0.5268,0.53725,0.05,99.965 -10000,0.5268,0.53725,0.05,99.965 -10000,0.53724,0.54789,0.05,99.973 -10000,0.53724,0.54789,0.05,99.973 -10000,0.53724,0.54789,0.05,99.973 -10000,0.53724,0.54789,0.05,99.973 -10000,0.53724,0.54789,0.05,99.973 -10000,0.53724,0.54789,0.05,99.973 -10000,0.53724,0.54789,0.05,99.973 -10000,0.53724,0.54789,0.05,99.973 -10000,0.53724,0.54789,0.05,99.973 -10000,0.53724,0.54789,0.05,99.973 -10000,0.54788,0.55874,0.05,99.979 -10000,0.54788,0.55874,0.05,99.979 -10000,0.54788,0.55874,0.05,99.979 -10000,0.54788,0.55874,0.05,99.979 -10000,0.54788,0.55874,0.05,99.979 -10000,0.54788,0.55874,0.05,99.979 -10000,0.54788,0.55874,0.05,99.979 -10000,0.54788,0.55874,0.05,99.979 -10000,0.54788,0.55874,0.05,99.979 -10000,0.54788,0.55874,0.05,99.979 -10000,0.54788,0.55874,0.05,99.979 -10000,0.55873,0.56981,0.05,99.984 -10000,0.55873,0.56981,0.05,99.984 -10000,0.55873,0.56981,0.05,99.984 -10000,0.55873,0.56981,0.05,99.984 -10000,0.55873,0.56981,0.05,99.984 -10000,0.55873,0.56981,0.05,99.984 -10000,0.55873,0.56981,0.05,99.984 -10000,0.55873,0.56981,0.05,99.984 -10000,0.55873,0.56981,0.05,99.984 -10000,0.55873,0.56981,0.05,99.984 -10000,0.55873,0.56981,0.05,99.984 -10000,0.5698,0.5811,0.05,99.987 -10000,0.5698,0.5811,0.05,99.987 -10000,0.5698,0.5811,0.05,99.987 -10000,0.5698,0.5811,0.05,99.987 -10000,0.5698,0.5811,0.05,99.987 -10000,0.5698,0.5811,0.05,99.987 -10000,0.5698,0.5811,0.05,99.987 -10000,0.5698,0.5811,0.05,99.987 -10000,0.5698,0.5811,0.05,99.987 -10000,0.5698,0.5811,0.05,99.987 -10000,0.5698,0.5811,0.05,99.987 -10000,0.5698,0.5811,0.05,99.987 -10000,0.58109,0.59261,0.05,99.99 -10000,0.58109,0.59261,0.05,99.99 -10000,0.58109,0.59261,0.05,99.99 -10000,0.58109,0.59261,0.05,99.99 -10000,0.58109,0.59261,0.05,99.99 -10000,0.58109,0.59261,0.05,99.99 -10000,0.58109,0.59261,0.05,99.99 -10000,0.58109,0.59261,0.05,99.99 -10000,0.58109,0.59261,0.05,99.99 -10000,0.58109,0.59261,0.05,99.99 -10000,0.58109,0.59261,0.05,99.99 -10000,0.5926,0.60435,0.05,99.993 -10000,0.5926,0.60435,0.05,99.993 -10000,0.5926,0.60435,0.05,99.993 -10000,0.5926,0.60435,0.05,99.993 -10000,0.5926,0.60435,0.05,99.993 -10000,0.5926,0.60435,0.05,99.993 -10000,0.5926,0.60435,0.05,99.993 -10000,0.5926,0.60435,0.05,99.993 -10000,0.5926,0.60435,0.05,99.993 -10000,0.5926,0.60435,0.05,99.993 -10000,0.5926,0.60435,0.05,99.993 -10000,0.5926,0.60435,0.05,99.993 -10000,0.60434,0.61632,0.05,99.995 -10000,0.60434,0.61632,0.05,99.995 -10000,0.60434,0.61632,0.05,99.995 -10000,0.60434,0.61632,0.05,99.995 -10000,0.60434,0.61632,0.05,99.995 -10000,0.60434,0.61632,0.05,99.995 -10000,0.60434,0.61632,0.05,99.995 -10000,0.60434,0.61632,0.05,99.995 -10000,0.60434,0.61632,0.05,99.995 -10000,0.60434,0.61632,0.05,99.995 -10000,0.60434,0.61632,0.05,99.995 -10000,0.60434,0.61632,0.05,99.995 -10000,0.61631,0.62853,0.05,99.996 -10000,0.61631,0.62853,0.05,99.996 -10000,0.61631,0.62853,0.05,99.996 -10000,0.61631,0.62853,0.05,99.996 -10000,0.61631,0.62853,0.05,99.996 -10000,0.61631,0.62853,0.05,99.996 -10000,0.61631,0.62853,0.05,99.996 -10000,0.61631,0.62853,0.05,99.996 -10000,0.61631,0.62853,0.05,99.996 -10000,0.61631,0.62853,0.05,99.996 -10000,0.61631,0.62853,0.05,99.996 -10000,0.61631,0.62853,0.05,99.996 -10000,0.62852,0.64098,0.05,99.997 -10000,0.62852,0.64098,0.05,99.997 -10000,0.62852,0.64098,0.05,99.997 -10000,0.62852,0.64098,0.05,99.997 -10000,0.62852,0.64098,0.05,99.997 -10000,0.62852,0.64098,0.05,99.997 -10000,0.62852,0.64098,0.05,99.997 -10000,0.62852,0.64098,0.05,99.997 -10000,0.62852,0.64098,0.05,99.997 -10000,0.62852,0.64098,0.05,99.997 -10000,0.62852,0.64098,0.05,99.997 -10000,0.62852,0.64098,0.05,99.997 -10000,0.62852,0.64098,0.05,99.997 -10000,0.64097,0.65368,0.05,99.998 -10000,0.64097,0.65368,0.05,99.998 -10000,0.64097,0.65368,0.05,99.998 -10000,0.64097,0.65368,0.05,99.998 -10000,0.64097,0.65368,0.05,99.998 -10000,0.64097,0.65368,0.05,99.998 -10000,0.64097,0.65368,0.05,99.998 -10000,0.64097,0.65368,0.05,99.998 -10000,0.64097,0.65368,0.05,99.998 -10000,0.64097,0.65368,0.05,99.998 -10000,0.64097,0.65368,0.05,99.998 -10000,0.64097,0.65368,0.05,99.998 -10000,0.65367,0.66663,0.05,99.999 -10000,0.65367,0.66663,0.05,99.999 -10000,0.65367,0.66663,0.05,99.999 -10000,0.65367,0.66663,0.05,99.999 -10000,0.65367,0.66663,0.05,99.999 -10000,0.65367,0.66663,0.05,99.999 -10000,0.65367,0.66663,0.05,99.999 -10000,0.65367,0.66663,0.05,99.999 -10000,0.65367,0.66663,0.05,99.999 -10000,0.65367,0.66663,0.05,99.999 -10000,0.65367,0.66663,0.05,99.999 -10000,0.65367,0.66663,0.05,99.999 -10000,0.65367,0.66663,0.05,99.999 -10000,0.66662,0.67984,0.05,99.999 -10000,0.66662,0.67984,0.05,99.999 -10000,0.66662,0.67984,0.05,99.999 -10000,0.66662,0.67984,0.05,99.999 -10000,0.66662,0.67984,0.05,99.999 -10000,0.66662,0.67984,0.05,99.999 -10000,0.66662,0.67984,0.05,99.999 -10000,0.66662,0.67984,0.05,99.999 -10000,0.66662,0.67984,0.05,99.999 -10000,0.66662,0.67984,0.05,99.999 -10000,0.66662,0.67984,0.05,99.999 -10000,0.66662,0.67984,0.05,99.999 -10000,0.66662,0.67984,0.05,99.999 -10000,0.67983,0.69331,0.05,99.999 -10000,0.67983,0.69331,0.05,99.999 -10000,0.67983,0.69331,0.05,99.999 -10000,0.67983,0.69331,0.05,99.999 -10000,0.67983,0.69331,0.05,99.999 -10000,0.67983,0.69331,0.05,99.999 -10000,0.67983,0.69331,0.05,99.999 -10000,0.67983,0.69331,0.05,99.999 -10000,0.67983,0.69331,0.05,99.999 -10000,0.67983,0.69331,0.05,99.999 -10000,0.67983,0.69331,0.05,99.999 -10000,0.67983,0.69331,0.05,99.999 -10000,0.67983,0.69331,0.05,99.999 -10000,0.67983,0.69331,0.05,99.999 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_10.csv b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_10.csv deleted file mode 100644 index f84f6a0a181..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_10.csv +++ /dev/null @@ -1,1002 +0,0 @@ -Time,"elementCenter:0","elementCenter:1","elementCenter:2","temperature" -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,0.07071,0.072112,0.05,-19.444 -1e+05,0.07071,0.072112,0.05,-19.444 -1e+05,0.07211,0.07354,0.05,-18.353 -1e+05,0.07351,0.074968,0.05,-17.283 -1e+05,0.075155,0.076646,0.05,-16.048 -1e+05,0.075155,0.076646,0.05,-16.048 -1e+05,0.077046,0.078574,0.05,-14.662 -1e+05,0.077046,0.078574,0.05,-14.662 -1e+05,0.078936,0.080501,0.05,-13.309 -1e+05,0.078936,0.080501,0.05,-13.309 -1e+05,0.080826,0.082429,0.05,-11.987 -1e+05,0.080826,0.082429,0.05,-11.987 -1e+05,0.082716,0.084357,0.05,-10.693 -1e+05,0.082716,0.084357,0.05,-10.693 -1e+05,0.084607,0.086285,0.05,-9.4284 -1e+05,0.084607,0.086285,0.05,-9.4284 -1e+05,0.086497,0.088212,0.05,-8.1901 -1e+05,0.086497,0.088212,0.05,-8.1901 -1e+05,0.088387,0.09014,0.05,-6.9775 -1e+05,0.088387,0.09014,0.05,-6.9775 -1e+05,0.090278,0.092068,0.05,-5.7896 -1e+05,0.090278,0.092068,0.05,-5.7896 -1e+05,0.092168,0.093995,0.05,-4.6253 -1e+05,0.092168,0.093995,0.05,-4.6253 -1e+05,0.094031,0.095896,0.05,-3.5002 -1e+05,0.095885,0.097786,0.05,-2.4013 -1e+05,0.095885,0.097786,0.05,-2.4013 -1e+05,0.097776,0.099715,0.05,-1.3015 -1e+05,0.097776,0.099715,0.05,-1.3015 -1e+05,0.099704,0.10168,0.05,-0.20076 -1e+05,0.099704,0.10168,0.05,-0.20076 -1e+05,0.10167,0.10369,0.05,0.90087 -1e+05,0.10167,0.10369,0.05,0.90087 -1e+05,0.10368,0.10573,0.05,2.0034 -1e+05,0.10368,0.10573,0.05,2.0034 -1e+05,0.10572,0.10782,0.05,3.1067 -1e+05,0.10572,0.10782,0.05,3.1067 -1e+05,0.10781,0.10995,0.05,4.2109 -1e+05,0.10781,0.10995,0.05,4.2109 -1e+05,0.10993,0.11211,0.05,5.316 -1e+05,0.10993,0.11211,0.05,5.316 -1e+05,0.10993,0.11211,0.05,5.316 -1e+05,0.1121,0.11433,0.05,6.4218 -1e+05,0.1121,0.11433,0.05,6.4218 -1e+05,0.11432,0.11658,0.05,7.5284 -1e+05,0.11432,0.11658,0.05,7.5284 -1e+05,0.11657,0.11888,0.05,8.6358 -1e+05,0.11657,0.11888,0.05,8.6358 -1e+05,0.11887,0.12123,0.05,9.7439 -1e+05,0.11887,0.12123,0.05,9.7439 -1e+05,0.11887,0.12123,0.05,9.7439 -1e+05,0.12122,0.12362,0.05,10.853 -1e+05,0.12122,0.12362,0.05,10.853 -1e+05,0.12361,0.12607,0.05,11.962 -1e+05,0.12361,0.12607,0.05,11.962 -1e+05,0.12361,0.12607,0.05,11.962 -1e+05,0.12605,0.12855,0.05,13.072 -1e+05,0.12605,0.12855,0.05,13.072 -1e+05,0.12854,0.13109,0.05,14.183 -1e+05,0.12854,0.13109,0.05,14.183 -1e+05,0.12854,0.13109,0.05,14.183 -1e+05,0.13108,0.13368,0.05,15.294 -1e+05,0.13108,0.13368,0.05,15.294 -1e+05,0.13367,0.13632,0.05,16.406 -1e+05,0.13367,0.13632,0.05,16.406 -1e+05,0.13367,0.13632,0.05,16.406 -1e+05,0.13631,0.13901,0.05,17.518 -1e+05,0.13631,0.13901,0.05,17.518 -1e+05,0.13631,0.13901,0.05,17.518 -1e+05,0.139,0.14176,0.05,18.631 -1e+05,0.139,0.14176,0.05,18.631 -1e+05,0.14175,0.14456,0.05,19.744 -1e+05,0.14175,0.14456,0.05,19.744 -1e+05,0.14175,0.14456,0.05,19.744 -1e+05,0.14455,0.14742,0.05,20.858 -1e+05,0.14455,0.14742,0.05,20.858 -1e+05,0.14455,0.14742,0.05,20.858 -1e+05,0.1474,0.15033,0.05,21.972 -1e+05,0.1474,0.15033,0.05,21.972 -1e+05,0.1474,0.15033,0.05,21.972 -1e+05,0.15032,0.1533,0.05,23.086 -1e+05,0.15032,0.1533,0.05,23.086 -1e+05,0.15032,0.1533,0.05,23.086 -1e+05,0.15329,0.15633,0.05,24.201 -1e+05,0.15329,0.15633,0.05,24.201 -1e+05,0.15329,0.15633,0.05,24.201 -1e+05,0.15632,0.15942,0.05,25.315 -1e+05,0.15632,0.15942,0.05,25.315 -1e+05,0.15632,0.15942,0.05,25.315 -1e+05,0.15941,0.16257,0.05,26.43 -1e+05,0.15941,0.16257,0.05,26.43 -1e+05,0.15941,0.16257,0.05,26.43 -1e+05,0.16256,0.16578,0.05,27.544 -1e+05,0.16256,0.16578,0.05,27.544 -1e+05,0.16256,0.16578,0.05,27.544 -1e+05,0.16577,0.16906,0.05,28.659 -1e+05,0.16577,0.16906,0.05,28.659 -1e+05,0.16577,0.16906,0.05,28.659 -1e+05,0.16577,0.16906,0.05,28.659 -1e+05,0.16905,0.1724,0.05,29.774 -1e+05,0.16905,0.1724,0.05,29.774 -1e+05,0.16905,0.1724,0.05,29.774 -1e+05,0.17239,0.1758,0.05,30.888 -1e+05,0.17239,0.1758,0.05,30.888 -1e+05,0.17239,0.1758,0.05,30.888 -1e+05,0.17579,0.17928,0.05,32.002 -1e+05,0.17579,0.17928,0.05,32.002 -1e+05,0.17579,0.17928,0.05,32.002 -1e+05,0.17579,0.17928,0.05,32.002 -1e+05,0.17927,0.18282,0.05,33.116 -1e+05,0.17927,0.18282,0.05,33.116 -1e+05,0.17927,0.18282,0.05,33.116 -1e+05,0.18281,0.18644,0.05,34.229 -1e+05,0.18281,0.18644,0.05,34.229 -1e+05,0.18281,0.18644,0.05,34.229 -1e+05,0.18281,0.18644,0.05,34.229 -1e+05,0.18643,0.19013,0.05,35.342 -1e+05,0.18643,0.19013,0.05,35.342 -1e+05,0.18643,0.19013,0.05,35.342 -1e+05,0.18643,0.19013,0.05,35.342 -1e+05,0.19011,0.19388,0.05,36.454 -1e+05,0.19011,0.19388,0.05,36.454 -1e+05,0.19011,0.19388,0.05,36.454 -1e+05,0.19387,0.19772,0.05,37.566 -1e+05,0.19387,0.19772,0.05,37.566 -1e+05,0.19387,0.19772,0.05,37.566 -1e+05,0.19387,0.19772,0.05,37.566 -1e+05,0.19771,0.20163,0.05,38.676 -1e+05,0.19771,0.20163,0.05,38.676 -1e+05,0.19771,0.20163,0.05,38.676 -1e+05,0.19771,0.20163,0.05,38.676 -1e+05,0.20162,0.20562,0.05,39.786 -1e+05,0.20162,0.20562,0.05,39.786 -1e+05,0.20162,0.20562,0.05,39.786 -1e+05,0.20162,0.20562,0.05,39.786 -1e+05,0.2056,0.20968,0.05,40.895 -1e+05,0.2056,0.20968,0.05,40.895 -1e+05,0.2056,0.20968,0.05,40.895 -1e+05,0.2056,0.20968,0.05,40.895 -1e+05,0.20967,0.21383,0.05,42.002 -1e+05,0.20967,0.21383,0.05,42.002 -1e+05,0.20967,0.21383,0.05,42.002 -1e+05,0.20967,0.21383,0.05,42.002 -1e+05,0.21382,0.21806,0.05,43.108 -1e+05,0.21382,0.21806,0.05,43.108 -1e+05,0.21382,0.21806,0.05,43.108 -1e+05,0.21382,0.21806,0.05,43.108 -1e+05,0.21382,0.21806,0.05,43.108 -1e+05,0.21805,0.22237,0.05,44.213 -1e+05,0.21805,0.22237,0.05,44.213 -1e+05,0.21805,0.22237,0.05,44.213 -1e+05,0.21805,0.22237,0.05,44.213 -1e+05,0.22236,0.22677,0.05,45.316 -1e+05,0.22236,0.22677,0.05,45.316 -1e+05,0.22236,0.22677,0.05,45.316 -1e+05,0.22236,0.22677,0.05,45.316 -1e+05,0.22676,0.23125,0.05,46.418 -1e+05,0.22676,0.23125,0.05,46.418 -1e+05,0.22676,0.23125,0.05,46.418 -1e+05,0.22676,0.23125,0.05,46.418 -1e+05,0.22676,0.23125,0.05,46.418 -1e+05,0.23124,0.23583,0.05,47.517 -1e+05,0.23124,0.23583,0.05,47.517 -1e+05,0.23124,0.23583,0.05,47.517 -1e+05,0.23124,0.23583,0.05,47.517 -1e+05,0.23582,0.2405,0.05,48.615 -1e+05,0.23582,0.2405,0.05,48.615 -1e+05,0.23582,0.2405,0.05,48.615 -1e+05,0.23582,0.2405,0.05,48.615 -1e+05,0.23582,0.2405,0.05,48.615 -1e+05,0.24048,0.24525,0.05,49.71 -1e+05,0.24048,0.24525,0.05,49.71 -1e+05,0.24048,0.24525,0.05,49.71 -1e+05,0.24048,0.24525,0.05,49.71 -1e+05,0.24048,0.24525,0.05,49.71 -1e+05,0.24524,0.25011,0.05,50.804 -1e+05,0.24524,0.25011,0.05,50.804 -1e+05,0.24524,0.25011,0.05,50.804 -1e+05,0.24524,0.25011,0.05,50.804 -1e+05,0.24524,0.25011,0.05,50.804 -1e+05,0.25009,0.25505,0.05,51.894 -1e+05,0.25009,0.25505,0.05,51.894 -1e+05,0.25009,0.25505,0.05,51.894 -1e+05,0.25009,0.25505,0.05,51.894 -1e+05,0.25009,0.25505,0.05,51.894 -1e+05,0.25504,0.2601,0.05,52.982 -1e+05,0.25504,0.2601,0.05,52.982 -1e+05,0.25504,0.2601,0.05,52.982 -1e+05,0.25504,0.2601,0.05,52.982 -1e+05,0.25504,0.2601,0.05,52.982 -1e+05,0.26009,0.26525,0.05,54.067 -1e+05,0.26009,0.26525,0.05,54.067 -1e+05,0.26009,0.26525,0.05,54.067 -1e+05,0.26009,0.26525,0.05,54.067 -1e+05,0.26009,0.26525,0.05,54.067 -1e+05,0.26524,0.2705,0.05,55.149 -1e+05,0.26524,0.2705,0.05,55.149 -1e+05,0.26524,0.2705,0.05,55.149 -1e+05,0.26524,0.2705,0.05,55.149 -1e+05,0.26524,0.2705,0.05,55.149 -1e+05,0.27048,0.27585,0.05,56.227 -1e+05,0.27048,0.27585,0.05,56.227 -1e+05,0.27048,0.27585,0.05,56.227 -1e+05,0.27048,0.27585,0.05,56.227 -1e+05,0.27048,0.27585,0.05,56.227 -1e+05,0.27584,0.28131,0.05,57.302 -1e+05,0.27584,0.28131,0.05,57.302 -1e+05,0.27584,0.28131,0.05,57.302 -1e+05,0.27584,0.28131,0.05,57.302 -1e+05,0.27584,0.28131,0.05,57.302 -1e+05,0.27584,0.28131,0.05,57.302 -1e+05,0.2813,0.28687,0.05,58.373 -1e+05,0.2813,0.28687,0.05,58.373 -1e+05,0.2813,0.28687,0.05,58.373 -1e+05,0.2813,0.28687,0.05,58.373 -1e+05,0.2813,0.28687,0.05,58.373 -1e+05,0.28686,0.29255,0.05,59.44 -1e+05,0.28686,0.29255,0.05,59.44 -1e+05,0.28686,0.29255,0.05,59.44 -1e+05,0.28686,0.29255,0.05,59.44 -1e+05,0.28686,0.29255,0.05,59.44 -1e+05,0.28686,0.29255,0.05,59.44 -1e+05,0.29254,0.29834,0.05,60.503 -1e+05,0.29254,0.29834,0.05,60.503 -1e+05,0.29254,0.29834,0.05,60.503 -1e+05,0.29254,0.29834,0.05,60.503 -1e+05,0.29254,0.29834,0.05,60.503 -1e+05,0.29254,0.29834,0.05,60.503 -1e+05,0.29833,0.30425,0.05,61.562 -1e+05,0.29833,0.30425,0.05,61.562 -1e+05,0.29833,0.30425,0.05,61.562 -1e+05,0.29833,0.30425,0.05,61.562 -1e+05,0.29833,0.30425,0.05,61.562 -1e+05,0.29833,0.30425,0.05,61.562 -1e+05,0.30424,0.31027,0.05,62.615 -1e+05,0.30424,0.31027,0.05,62.615 -1e+05,0.30424,0.31027,0.05,62.615 -1e+05,0.30424,0.31027,0.05,62.615 -1e+05,0.30424,0.31027,0.05,62.615 -1e+05,0.30424,0.31027,0.05,62.615 -1e+05,0.31026,0.31641,0.05,63.664 -1e+05,0.31026,0.31641,0.05,63.664 -1e+05,0.31026,0.31641,0.05,63.664 -1e+05,0.31026,0.31641,0.05,63.664 -1e+05,0.31026,0.31641,0.05,63.664 -1e+05,0.31026,0.31641,0.05,63.664 -1e+05,0.3164,0.32267,0.05,64.708 -1e+05,0.3164,0.32267,0.05,64.708 -1e+05,0.3164,0.32267,0.05,64.708 -1e+05,0.3164,0.32267,0.05,64.708 -1e+05,0.3164,0.32267,0.05,64.708 -1e+05,0.3164,0.32267,0.05,64.708 -1e+05,0.32266,0.32906,0.05,65.746 -1e+05,0.32266,0.32906,0.05,65.746 -1e+05,0.32266,0.32906,0.05,65.746 -1e+05,0.32266,0.32906,0.05,65.746 -1e+05,0.32266,0.32906,0.05,65.746 -1e+05,0.32266,0.32906,0.05,65.746 -1e+05,0.32266,0.32906,0.05,65.746 -1e+05,0.32905,0.33558,0.05,66.778 -1e+05,0.32905,0.33558,0.05,66.778 -1e+05,0.32905,0.33558,0.05,66.778 -1e+05,0.32905,0.33558,0.05,66.778 -1e+05,0.32905,0.33558,0.05,66.778 -1e+05,0.32905,0.33558,0.05,66.778 -1e+05,0.33556,0.34222,0.05,67.804 -1e+05,0.33556,0.34222,0.05,67.804 -1e+05,0.33556,0.34222,0.05,67.804 -1e+05,0.33556,0.34222,0.05,67.804 -1e+05,0.33556,0.34222,0.05,67.804 -1e+05,0.33556,0.34222,0.05,67.804 -1e+05,0.33556,0.34222,0.05,67.804 -1e+05,0.34221,0.34899,0.05,68.824 -1e+05,0.34221,0.34899,0.05,68.824 -1e+05,0.34221,0.34899,0.05,68.824 -1e+05,0.34221,0.34899,0.05,68.824 -1e+05,0.34221,0.34899,0.05,68.824 -1e+05,0.34221,0.34899,0.05,68.824 -1e+05,0.34221,0.34899,0.05,68.824 -1e+05,0.34898,0.3559,0.05,69.838 -1e+05,0.34898,0.3559,0.05,69.838 -1e+05,0.34898,0.3559,0.05,69.838 -1e+05,0.34898,0.3559,0.05,69.838 -1e+05,0.34898,0.3559,0.05,69.838 -1e+05,0.34898,0.3559,0.05,69.838 -1e+05,0.35589,0.36295,0.05,70.844 -1e+05,0.35589,0.36295,0.05,70.844 -1e+05,0.35589,0.36295,0.05,70.844 -1e+05,0.35589,0.36295,0.05,70.844 -1e+05,0.35589,0.36295,0.05,70.844 -1e+05,0.35589,0.36295,0.05,70.844 -1e+05,0.35589,0.36295,0.05,70.844 -1e+05,0.36294,0.37013,0.05,71.844 -1e+05,0.36294,0.37013,0.05,71.844 -1e+05,0.36294,0.37013,0.05,71.844 -1e+05,0.36294,0.37013,0.05,71.844 -1e+05,0.36294,0.37013,0.05,71.844 -1e+05,0.36294,0.37013,0.05,71.844 -1e+05,0.36294,0.37013,0.05,71.844 -1e+05,0.36294,0.37013,0.05,71.844 -1e+05,0.37012,0.37746,0.05,72.835 -1e+05,0.37012,0.37746,0.05,72.835 -1e+05,0.37012,0.37746,0.05,72.835 -1e+05,0.37012,0.37746,0.05,72.835 -1e+05,0.37012,0.37746,0.05,72.835 -1e+05,0.37012,0.37746,0.05,72.835 -1e+05,0.37012,0.37746,0.05,72.835 -1e+05,0.37745,0.38494,0.05,73.819 -1e+05,0.37745,0.38494,0.05,73.819 -1e+05,0.37745,0.38494,0.05,73.819 -1e+05,0.37745,0.38494,0.05,73.819 -1e+05,0.37745,0.38494,0.05,73.819 -1e+05,0.37745,0.38494,0.05,73.819 -1e+05,0.37745,0.38494,0.05,73.819 -1e+05,0.38493,0.39256,0.05,74.795 -1e+05,0.38493,0.39256,0.05,74.795 -1e+05,0.38493,0.39256,0.05,74.795 -1e+05,0.38493,0.39256,0.05,74.795 -1e+05,0.38493,0.39256,0.05,74.795 -1e+05,0.38493,0.39256,0.05,74.795 -1e+05,0.38493,0.39256,0.05,74.795 -1e+05,0.38493,0.39256,0.05,74.795 -1e+05,0.39255,0.40033,0.05,75.763 -1e+05,0.39255,0.40033,0.05,75.763 -1e+05,0.39255,0.40033,0.05,75.763 -1e+05,0.39255,0.40033,0.05,75.763 -1e+05,0.39255,0.40033,0.05,75.763 -1e+05,0.39255,0.40033,0.05,75.763 -1e+05,0.39255,0.40033,0.05,75.763 -1e+05,0.39255,0.40033,0.05,75.763 -1e+05,0.40032,0.40826,0.05,76.722 -1e+05,0.40032,0.40826,0.05,76.722 -1e+05,0.40032,0.40826,0.05,76.722 -1e+05,0.40032,0.40826,0.05,76.722 -1e+05,0.40032,0.40826,0.05,76.722 -1e+05,0.40032,0.40826,0.05,76.722 -1e+05,0.40032,0.40826,0.05,76.722 -1e+05,0.40032,0.40826,0.05,76.722 -1e+05,0.40825,0.41634,0.05,77.672 -1e+05,0.40825,0.41634,0.05,77.672 -1e+05,0.40825,0.41634,0.05,77.672 -1e+05,0.40825,0.41634,0.05,77.672 -1e+05,0.40825,0.41634,0.05,77.672 -1e+05,0.40825,0.41634,0.05,77.672 -1e+05,0.40825,0.41634,0.05,77.672 -1e+05,0.40825,0.41634,0.05,77.672 -1e+05,0.41633,0.42459,0.05,78.614 -1e+05,0.41633,0.42459,0.05,78.614 -1e+05,0.41633,0.42459,0.05,78.614 -1e+05,0.41633,0.42459,0.05,78.614 -1e+05,0.41633,0.42459,0.05,78.614 -1e+05,0.41633,0.42459,0.05,78.614 -1e+05,0.41633,0.42459,0.05,78.614 -1e+05,0.41633,0.42459,0.05,78.614 -1e+05,0.42458,0.433,0.05,79.545 -1e+05,0.42458,0.433,0.05,79.545 -1e+05,0.42458,0.433,0.05,79.545 -1e+05,0.42458,0.433,0.05,79.545 -1e+05,0.42458,0.433,0.05,79.545 -1e+05,0.42458,0.433,0.05,79.545 -1e+05,0.42458,0.433,0.05,79.545 -1e+05,0.42458,0.433,0.05,79.545 -1e+05,0.42458,0.433,0.05,79.545 -1e+05,0.43298,0.44157,0.05,80.467 -1e+05,0.43298,0.44157,0.05,80.467 -1e+05,0.43298,0.44157,0.05,80.467 -1e+05,0.43298,0.44157,0.05,80.467 -1e+05,0.43298,0.44157,0.05,80.467 -1e+05,0.43298,0.44157,0.05,80.467 -1e+05,0.43298,0.44157,0.05,80.467 -1e+05,0.43298,0.44157,0.05,80.467 -1e+05,0.44156,0.45031,0.05,81.379 -1e+05,0.44156,0.45031,0.05,81.379 -1e+05,0.44156,0.45031,0.05,81.379 -1e+05,0.44156,0.45031,0.05,81.379 -1e+05,0.44156,0.45031,0.05,81.379 -1e+05,0.44156,0.45031,0.05,81.379 -1e+05,0.44156,0.45031,0.05,81.379 -1e+05,0.44156,0.45031,0.05,81.379 -1e+05,0.44156,0.45031,0.05,81.379 -1e+05,0.4503,0.45923,0.05,82.282 -1e+05,0.4503,0.45923,0.05,82.282 -1e+05,0.4503,0.45923,0.05,82.282 -1e+05,0.4503,0.45923,0.05,82.282 -1e+05,0.4503,0.45923,0.05,82.282 -1e+05,0.4503,0.45923,0.05,82.282 -1e+05,0.4503,0.45923,0.05,82.282 -1e+05,0.4503,0.45923,0.05,82.282 -1e+05,0.4503,0.45923,0.05,82.282 -1e+05,0.45922,0.46833,0.05,83.173 -1e+05,0.45922,0.46833,0.05,83.173 -1e+05,0.45922,0.46833,0.05,83.173 -1e+05,0.45922,0.46833,0.05,83.173 -1e+05,0.45922,0.46833,0.05,83.173 -1e+05,0.45922,0.46833,0.05,83.173 -1e+05,0.45922,0.46833,0.05,83.173 -1e+05,0.45922,0.46833,0.05,83.173 -1e+05,0.45922,0.46833,0.05,83.173 -1e+05,0.46832,0.4776,0.05,84.055 -1e+05,0.46832,0.4776,0.05,84.055 -1e+05,0.46832,0.4776,0.05,84.055 -1e+05,0.46832,0.4776,0.05,84.055 -1e+05,0.46832,0.4776,0.05,84.055 -1e+05,0.46832,0.4776,0.05,84.055 -1e+05,0.46832,0.4776,0.05,84.055 -1e+05,0.46832,0.4776,0.05,84.055 -1e+05,0.46832,0.4776,0.05,84.055 -1e+05,0.47759,0.48706,0.05,84.926 -1e+05,0.47759,0.48706,0.05,84.926 -1e+05,0.47759,0.48706,0.05,84.926 -1e+05,0.47759,0.48706,0.05,84.926 -1e+05,0.47759,0.48706,0.05,84.926 -1e+05,0.47759,0.48706,0.05,84.926 -1e+05,0.47759,0.48706,0.05,84.926 -1e+05,0.47759,0.48706,0.05,84.926 -1e+05,0.47759,0.48706,0.05,84.926 -1e+05,0.47759,0.48706,0.05,84.926 -1e+05,0.48705,0.49671,0.05,85.786 -1e+05,0.48705,0.49671,0.05,85.786 -1e+05,0.48705,0.49671,0.05,85.786 -1e+05,0.48705,0.49671,0.05,85.786 -1e+05,0.48705,0.49671,0.05,85.786 -1e+05,0.48705,0.49671,0.05,85.786 -1e+05,0.48705,0.49671,0.05,85.786 -1e+05,0.48705,0.49671,0.05,85.786 -1e+05,0.48705,0.49671,0.05,85.786 -1e+05,0.4967,0.50655,0.05,86.636 -1e+05,0.4967,0.50655,0.05,86.636 -1e+05,0.4967,0.50655,0.05,86.636 -1e+05,0.4967,0.50655,0.05,86.636 -1e+05,0.4967,0.50655,0.05,86.636 -1e+05,0.4967,0.50655,0.05,86.636 -1e+05,0.4967,0.50655,0.05,86.636 -1e+05,0.4967,0.50655,0.05,86.636 -1e+05,0.4967,0.50655,0.05,86.636 -1e+05,0.4967,0.50655,0.05,86.636 -1e+05,0.50654,0.51658,0.05,87.475 -1e+05,0.50654,0.51658,0.05,87.475 -1e+05,0.50654,0.51658,0.05,87.475 -1e+05,0.50654,0.51658,0.05,87.475 -1e+05,0.50654,0.51658,0.05,87.475 -1e+05,0.50654,0.51658,0.05,87.475 -1e+05,0.50654,0.51658,0.05,87.475 -1e+05,0.50654,0.51658,0.05,87.475 -1e+05,0.50654,0.51658,0.05,87.475 -1e+05,0.50654,0.51658,0.05,87.475 -1e+05,0.51657,0.52681,0.05,88.303 -1e+05,0.51657,0.52681,0.05,88.303 -1e+05,0.51657,0.52681,0.05,88.303 -1e+05,0.51657,0.52681,0.05,88.303 -1e+05,0.51657,0.52681,0.05,88.303 -1e+05,0.51657,0.52681,0.05,88.303 -1e+05,0.51657,0.52681,0.05,88.303 -1e+05,0.51657,0.52681,0.05,88.303 -1e+05,0.51657,0.52681,0.05,88.303 -1e+05,0.51657,0.52681,0.05,88.303 -1e+05,0.5268,0.53725,0.05,89.121 -1e+05,0.5268,0.53725,0.05,89.121 -1e+05,0.5268,0.53725,0.05,89.121 -1e+05,0.5268,0.53725,0.05,89.121 -1e+05,0.5268,0.53725,0.05,89.121 -1e+05,0.5268,0.53725,0.05,89.121 -1e+05,0.5268,0.53725,0.05,89.121 -1e+05,0.5268,0.53725,0.05,89.121 -1e+05,0.5268,0.53725,0.05,89.121 -1e+05,0.5268,0.53725,0.05,89.121 -1e+05,0.5268,0.53725,0.05,89.121 -1e+05,0.53724,0.54789,0.05,89.928 -1e+05,0.53724,0.54789,0.05,89.928 -1e+05,0.53724,0.54789,0.05,89.928 -1e+05,0.53724,0.54789,0.05,89.928 -1e+05,0.53724,0.54789,0.05,89.928 -1e+05,0.53724,0.54789,0.05,89.928 -1e+05,0.53724,0.54789,0.05,89.928 -1e+05,0.53724,0.54789,0.05,89.928 -1e+05,0.53724,0.54789,0.05,89.928 -1e+05,0.53724,0.54789,0.05,89.928 -1e+05,0.54788,0.55874,0.05,90.724 -1e+05,0.54788,0.55874,0.05,90.724 -1e+05,0.54788,0.55874,0.05,90.724 -1e+05,0.54788,0.55874,0.05,90.724 -1e+05,0.54788,0.55874,0.05,90.724 -1e+05,0.54788,0.55874,0.05,90.724 -1e+05,0.54788,0.55874,0.05,90.724 -1e+05,0.54788,0.55874,0.05,90.724 -1e+05,0.54788,0.55874,0.05,90.724 -1e+05,0.54788,0.55874,0.05,90.724 -1e+05,0.54788,0.55874,0.05,90.724 -1e+05,0.55873,0.56981,0.05,91.511 -1e+05,0.55873,0.56981,0.05,91.511 -1e+05,0.55873,0.56981,0.05,91.511 -1e+05,0.55873,0.56981,0.05,91.511 -1e+05,0.55873,0.56981,0.05,91.511 -1e+05,0.55873,0.56981,0.05,91.511 -1e+05,0.55873,0.56981,0.05,91.511 -1e+05,0.55873,0.56981,0.05,91.511 -1e+05,0.55873,0.56981,0.05,91.511 -1e+05,0.55873,0.56981,0.05,91.511 -1e+05,0.55873,0.56981,0.05,91.511 -1e+05,0.5698,0.5811,0.05,92.288 -1e+05,0.5698,0.5811,0.05,92.288 -1e+05,0.5698,0.5811,0.05,92.288 -1e+05,0.5698,0.5811,0.05,92.288 -1e+05,0.5698,0.5811,0.05,92.288 -1e+05,0.5698,0.5811,0.05,92.288 -1e+05,0.5698,0.5811,0.05,92.288 -1e+05,0.5698,0.5811,0.05,92.288 -1e+05,0.5698,0.5811,0.05,92.288 -1e+05,0.5698,0.5811,0.05,92.288 -1e+05,0.5698,0.5811,0.05,92.288 -1e+05,0.5698,0.5811,0.05,92.288 -1e+05,0.58109,0.59261,0.05,93.055 -1e+05,0.58109,0.59261,0.05,93.055 -1e+05,0.58109,0.59261,0.05,93.055 -1e+05,0.58109,0.59261,0.05,93.055 -1e+05,0.58109,0.59261,0.05,93.055 -1e+05,0.58109,0.59261,0.05,93.055 -1e+05,0.58109,0.59261,0.05,93.055 -1e+05,0.58109,0.59261,0.05,93.055 -1e+05,0.58109,0.59261,0.05,93.055 -1e+05,0.58109,0.59261,0.05,93.055 -1e+05,0.58109,0.59261,0.05,93.055 -1e+05,0.5926,0.60435,0.05,93.814 -1e+05,0.5926,0.60435,0.05,93.814 -1e+05,0.5926,0.60435,0.05,93.814 -1e+05,0.5926,0.60435,0.05,93.814 -1e+05,0.5926,0.60435,0.05,93.814 -1e+05,0.5926,0.60435,0.05,93.814 -1e+05,0.5926,0.60435,0.05,93.814 -1e+05,0.5926,0.60435,0.05,93.814 -1e+05,0.5926,0.60435,0.05,93.814 -1e+05,0.5926,0.60435,0.05,93.814 -1e+05,0.5926,0.60435,0.05,93.814 -1e+05,0.5926,0.60435,0.05,93.814 -1e+05,0.60434,0.61632,0.05,94.564 -1e+05,0.60434,0.61632,0.05,94.564 -1e+05,0.60434,0.61632,0.05,94.564 -1e+05,0.60434,0.61632,0.05,94.564 -1e+05,0.60434,0.61632,0.05,94.564 -1e+05,0.60434,0.61632,0.05,94.564 -1e+05,0.60434,0.61632,0.05,94.564 -1e+05,0.60434,0.61632,0.05,94.564 -1e+05,0.60434,0.61632,0.05,94.564 -1e+05,0.60434,0.61632,0.05,94.564 -1e+05,0.60434,0.61632,0.05,94.564 -1e+05,0.60434,0.61632,0.05,94.564 -1e+05,0.61631,0.62853,0.05,95.306 -1e+05,0.61631,0.62853,0.05,95.306 -1e+05,0.61631,0.62853,0.05,95.306 -1e+05,0.61631,0.62853,0.05,95.306 -1e+05,0.61631,0.62853,0.05,95.306 -1e+05,0.61631,0.62853,0.05,95.306 -1e+05,0.61631,0.62853,0.05,95.306 -1e+05,0.61631,0.62853,0.05,95.306 -1e+05,0.61631,0.62853,0.05,95.306 -1e+05,0.61631,0.62853,0.05,95.306 -1e+05,0.61631,0.62853,0.05,95.306 -1e+05,0.61631,0.62853,0.05,95.306 -1e+05,0.62852,0.64098,0.05,96.042 -1e+05,0.62852,0.64098,0.05,96.042 -1e+05,0.62852,0.64098,0.05,96.042 -1e+05,0.62852,0.64098,0.05,96.042 -1e+05,0.62852,0.64098,0.05,96.042 -1e+05,0.62852,0.64098,0.05,96.042 -1e+05,0.62852,0.64098,0.05,96.042 -1e+05,0.62852,0.64098,0.05,96.042 -1e+05,0.62852,0.64098,0.05,96.042 -1e+05,0.62852,0.64098,0.05,96.042 -1e+05,0.62852,0.64098,0.05,96.042 -1e+05,0.62852,0.64098,0.05,96.042 -1e+05,0.62852,0.64098,0.05,96.042 -1e+05,0.64097,0.65368,0.05,96.771 -1e+05,0.64097,0.65368,0.05,96.771 -1e+05,0.64097,0.65368,0.05,96.771 -1e+05,0.64097,0.65368,0.05,96.771 -1e+05,0.64097,0.65368,0.05,96.771 -1e+05,0.64097,0.65368,0.05,96.771 -1e+05,0.64097,0.65368,0.05,96.771 -1e+05,0.64097,0.65368,0.05,96.771 -1e+05,0.64097,0.65368,0.05,96.771 -1e+05,0.64097,0.65368,0.05,96.771 -1e+05,0.64097,0.65368,0.05,96.771 -1e+05,0.64097,0.65368,0.05,96.771 -1e+05,0.65367,0.66663,0.05,97.495 -1e+05,0.65367,0.66663,0.05,97.495 -1e+05,0.65367,0.66663,0.05,97.495 -1e+05,0.65367,0.66663,0.05,97.495 -1e+05,0.65367,0.66663,0.05,97.495 -1e+05,0.65367,0.66663,0.05,97.495 -1e+05,0.65367,0.66663,0.05,97.495 -1e+05,0.65367,0.66663,0.05,97.495 -1e+05,0.65367,0.66663,0.05,97.495 -1e+05,0.65367,0.66663,0.05,97.495 -1e+05,0.65367,0.66663,0.05,97.495 -1e+05,0.65367,0.66663,0.05,97.495 -1e+05,0.65367,0.66663,0.05,97.495 -1e+05,0.66662,0.67984,0.05,98.214 -1e+05,0.66662,0.67984,0.05,98.214 -1e+05,0.66662,0.67984,0.05,98.214 -1e+05,0.66662,0.67984,0.05,98.214 -1e+05,0.66662,0.67984,0.05,98.214 -1e+05,0.66662,0.67984,0.05,98.214 -1e+05,0.66662,0.67984,0.05,98.214 -1e+05,0.66662,0.67984,0.05,98.214 -1e+05,0.66662,0.67984,0.05,98.214 -1e+05,0.66662,0.67984,0.05,98.214 -1e+05,0.66662,0.67984,0.05,98.214 -1e+05,0.66662,0.67984,0.05,98.214 -1e+05,0.66662,0.67984,0.05,98.214 -1e+05,0.67983,0.69331,0.05,98.931 -1e+05,0.67983,0.69331,0.05,98.931 -1e+05,0.67983,0.69331,0.05,98.931 -1e+05,0.67983,0.69331,0.05,98.931 -1e+05,0.67983,0.69331,0.05,98.931 -1e+05,0.67983,0.69331,0.05,98.931 -1e+05,0.67983,0.69331,0.05,98.931 -1e+05,0.67983,0.69331,0.05,98.931 -1e+05,0.67983,0.69331,0.05,98.931 -1e+05,0.67983,0.69331,0.05,98.931 -1e+05,0.67983,0.69331,0.05,98.931 -1e+05,0.67983,0.69331,0.05,98.931 -1e+05,0.67983,0.69331,0.05,98.931 -1e+05,0.67983,0.69331,0.05,98.931 -1e+05,0.6933,0.70704,0.05,99.646 -1e+05,0.6933,0.70704,0.05,99.646 -1e+05,0.6933,0.70704,0.05,99.646 -1e+05,0.6933,0.70704,0.05,99.646 -1e+05,0.6933,0.70704,0.05,99.646 -1e+05,0.6933,0.70704,0.05,99.646 -1e+05,0.6933,0.70704,0.05,99.646 -1e+05,0.6933,0.70704,0.05,99.646 -1e+05,0.6933,0.70704,0.05,99.646 -1e+05,0.6933,0.70704,0.05,99.646 -1e+05,0.6933,0.70704,0.05,99.646 -1e+05,0.6933,0.70704,0.05,99.646 -1e+05,0.6933,0.70704,0.05,99.646 -1e+05,0.6933,0.70704,0.05,99.646 -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_2.csv b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_2.csv deleted file mode 100644 index 7645d62f469..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_2.csv +++ /dev/null @@ -1,1002 +0,0 @@ -Time,"elementCenter:0","elementCenter:1","elementCenter:2","temperature" -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,0.07071,0.072112,0.05,-19.187 -20000,0.07071,0.072112,0.05,-19.187 -20000,0.07211,0.07354,0.05,-17.591 -20000,0.07351,0.074968,0.05,-16.025 -20000,0.075155,0.076646,0.05,-14.216 -20000,0.075155,0.076646,0.05,-14.216 -20000,0.077046,0.078574,0.05,-12.188 -20000,0.077046,0.078574,0.05,-12.188 -20000,0.078936,0.080501,0.05,-10.206 -20000,0.078936,0.080501,0.05,-10.206 -20000,0.080826,0.082429,0.05,-8.2679 -20000,0.080826,0.082429,0.05,-8.2679 -20000,0.082716,0.084357,0.05,-6.373 -20000,0.082716,0.084357,0.05,-6.373 -20000,0.084607,0.086285,0.05,-4.519 -20000,0.084607,0.086285,0.05,-4.519 -20000,0.086497,0.088212,0.05,-2.7043 -20000,0.086497,0.088212,0.05,-2.7043 -20000,0.088387,0.09014,0.05,-0.92736 -20000,0.088387,0.09014,0.05,-0.92736 -20000,0.090278,0.092068,0.05,0.81323 -20000,0.090278,0.092068,0.05,0.81323 -20000,0.092168,0.093995,0.05,2.5188 -20000,0.092168,0.093995,0.05,2.5188 -20000,0.094031,0.095896,0.05,4.1665 -20000,0.095885,0.097786,0.05,5.7753 -20000,0.095885,0.097786,0.05,5.7753 -20000,0.097776,0.099715,0.05,7.3847 -20000,0.097776,0.099715,0.05,7.3847 -20000,0.099704,0.10168,0.05,8.9946 -20000,0.099704,0.10168,0.05,8.9946 -20000,0.10167,0.10369,0.05,10.605 -20000,0.10167,0.10369,0.05,10.605 -20000,0.10368,0.10573,0.05,12.215 -20000,0.10368,0.10573,0.05,12.215 -20000,0.10572,0.10782,0.05,13.825 -20000,0.10572,0.10782,0.05,13.825 -20000,0.10781,0.10995,0.05,15.435 -20000,0.10781,0.10995,0.05,15.435 -20000,0.10993,0.11211,0.05,17.045 -20000,0.10993,0.11211,0.05,17.045 -20000,0.10993,0.11211,0.05,17.045 -20000,0.1121,0.11433,0.05,18.654 -20000,0.1121,0.11433,0.05,18.654 -20000,0.11432,0.11658,0.05,20.261 -20000,0.11432,0.11658,0.05,20.261 -20000,0.11657,0.11888,0.05,21.868 -20000,0.11657,0.11888,0.05,21.868 -20000,0.11887,0.12123,0.05,23.473 -20000,0.11887,0.12123,0.05,23.473 -20000,0.11887,0.12123,0.05,23.473 -20000,0.12122,0.12362,0.05,25.076 -20000,0.12122,0.12362,0.05,25.076 -20000,0.12361,0.12607,0.05,26.677 -20000,0.12361,0.12607,0.05,26.677 -20000,0.12361,0.12607,0.05,26.677 -20000,0.12605,0.12855,0.05,28.275 -20000,0.12605,0.12855,0.05,28.275 -20000,0.12854,0.13109,0.05,29.871 -20000,0.12854,0.13109,0.05,29.871 -20000,0.12854,0.13109,0.05,29.871 -20000,0.13108,0.13368,0.05,31.463 -20000,0.13108,0.13368,0.05,31.463 -20000,0.13367,0.13632,0.05,33.052 -20000,0.13367,0.13632,0.05,33.052 -20000,0.13367,0.13632,0.05,33.052 -20000,0.13631,0.13901,0.05,34.637 -20000,0.13631,0.13901,0.05,34.637 -20000,0.13631,0.13901,0.05,34.637 -20000,0.139,0.14176,0.05,36.217 -20000,0.139,0.14176,0.05,36.217 -20000,0.14175,0.14456,0.05,37.793 -20000,0.14175,0.14456,0.05,37.793 -20000,0.14175,0.14456,0.05,37.793 -20000,0.14455,0.14742,0.05,39.363 -20000,0.14455,0.14742,0.05,39.363 -20000,0.14455,0.14742,0.05,39.363 -20000,0.1474,0.15033,0.05,40.927 -20000,0.1474,0.15033,0.05,40.927 -20000,0.1474,0.15033,0.05,40.927 -20000,0.15032,0.1533,0.05,42.484 -20000,0.15032,0.1533,0.05,42.484 -20000,0.15032,0.1533,0.05,42.484 -20000,0.15329,0.15633,0.05,44.035 -20000,0.15329,0.15633,0.05,44.035 -20000,0.15329,0.15633,0.05,44.035 -20000,0.15632,0.15942,0.05,45.578 -20000,0.15632,0.15942,0.05,45.578 -20000,0.15632,0.15942,0.05,45.578 -20000,0.15941,0.16257,0.05,47.113 -20000,0.15941,0.16257,0.05,47.113 -20000,0.15941,0.16257,0.05,47.113 -20000,0.16256,0.16578,0.05,48.64 -20000,0.16256,0.16578,0.05,48.64 -20000,0.16256,0.16578,0.05,48.64 -20000,0.16577,0.16906,0.05,50.157 -20000,0.16577,0.16906,0.05,50.157 -20000,0.16577,0.16906,0.05,50.157 -20000,0.16577,0.16906,0.05,50.157 -20000,0.16905,0.1724,0.05,51.664 -20000,0.16905,0.1724,0.05,51.664 -20000,0.16905,0.1724,0.05,51.664 -20000,0.17239,0.1758,0.05,53.16 -20000,0.17239,0.1758,0.05,53.16 -20000,0.17239,0.1758,0.05,53.16 -20000,0.17579,0.17928,0.05,54.645 -20000,0.17579,0.17928,0.05,54.645 -20000,0.17579,0.17928,0.05,54.645 -20000,0.17579,0.17928,0.05,54.645 -20000,0.17927,0.18282,0.05,56.118 -20000,0.17927,0.18282,0.05,56.118 -20000,0.17927,0.18282,0.05,56.118 -20000,0.18281,0.18644,0.05,57.578 -20000,0.18281,0.18644,0.05,57.578 -20000,0.18281,0.18644,0.05,57.578 -20000,0.18281,0.18644,0.05,57.578 -20000,0.18643,0.19013,0.05,59.024 -20000,0.18643,0.19013,0.05,59.024 -20000,0.18643,0.19013,0.05,59.024 -20000,0.18643,0.19013,0.05,59.024 -20000,0.19011,0.19388,0.05,60.456 -20000,0.19011,0.19388,0.05,60.456 -20000,0.19011,0.19388,0.05,60.456 -20000,0.19387,0.19772,0.05,61.873 -20000,0.19387,0.19772,0.05,61.873 -20000,0.19387,0.19772,0.05,61.873 -20000,0.19387,0.19772,0.05,61.873 -20000,0.19771,0.20163,0.05,63.273 -20000,0.19771,0.20163,0.05,63.273 -20000,0.19771,0.20163,0.05,63.273 -20000,0.19771,0.20163,0.05,63.273 -20000,0.20162,0.20562,0.05,64.657 -20000,0.20162,0.20562,0.05,64.657 -20000,0.20162,0.20562,0.05,64.657 -20000,0.20162,0.20562,0.05,64.657 -20000,0.2056,0.20968,0.05,66.023 -20000,0.2056,0.20968,0.05,66.023 -20000,0.2056,0.20968,0.05,66.023 -20000,0.2056,0.20968,0.05,66.023 -20000,0.20967,0.21383,0.05,67.37 -20000,0.20967,0.21383,0.05,67.37 -20000,0.20967,0.21383,0.05,67.37 -20000,0.20967,0.21383,0.05,67.37 -20000,0.21382,0.21806,0.05,68.698 -20000,0.21382,0.21806,0.05,68.698 -20000,0.21382,0.21806,0.05,68.698 -20000,0.21382,0.21806,0.05,68.698 -20000,0.21382,0.21806,0.05,68.698 -20000,0.21805,0.22237,0.05,70.005 -20000,0.21805,0.22237,0.05,70.005 -20000,0.21805,0.22237,0.05,70.005 -20000,0.21805,0.22237,0.05,70.005 -20000,0.22236,0.22677,0.05,71.291 -20000,0.22236,0.22677,0.05,71.291 -20000,0.22236,0.22677,0.05,71.291 -20000,0.22236,0.22677,0.05,71.291 -20000,0.22676,0.23125,0.05,72.555 -20000,0.22676,0.23125,0.05,72.555 -20000,0.22676,0.23125,0.05,72.555 -20000,0.22676,0.23125,0.05,72.555 -20000,0.22676,0.23125,0.05,72.555 -20000,0.23124,0.23583,0.05,73.796 -20000,0.23124,0.23583,0.05,73.796 -20000,0.23124,0.23583,0.05,73.796 -20000,0.23124,0.23583,0.05,73.796 -20000,0.23582,0.2405,0.05,75.013 -20000,0.23582,0.2405,0.05,75.013 -20000,0.23582,0.2405,0.05,75.013 -20000,0.23582,0.2405,0.05,75.013 -20000,0.23582,0.2405,0.05,75.013 -20000,0.24048,0.24525,0.05,76.205 -20000,0.24048,0.24525,0.05,76.205 -20000,0.24048,0.24525,0.05,76.205 -20000,0.24048,0.24525,0.05,76.205 -20000,0.24048,0.24525,0.05,76.205 -20000,0.24524,0.25011,0.05,77.371 -20000,0.24524,0.25011,0.05,77.371 -20000,0.24524,0.25011,0.05,77.371 -20000,0.24524,0.25011,0.05,77.371 -20000,0.24524,0.25011,0.05,77.371 -20000,0.25009,0.25505,0.05,78.511 -20000,0.25009,0.25505,0.05,78.511 -20000,0.25009,0.25505,0.05,78.511 -20000,0.25009,0.25505,0.05,78.511 -20000,0.25009,0.25505,0.05,78.511 -20000,0.25504,0.2601,0.05,79.624 -20000,0.25504,0.2601,0.05,79.624 -20000,0.25504,0.2601,0.05,79.624 -20000,0.25504,0.2601,0.05,79.624 -20000,0.25504,0.2601,0.05,79.624 -20000,0.26009,0.26525,0.05,80.708 -20000,0.26009,0.26525,0.05,80.708 -20000,0.26009,0.26525,0.05,80.708 -20000,0.26009,0.26525,0.05,80.708 -20000,0.26009,0.26525,0.05,80.708 -20000,0.26524,0.2705,0.05,81.764 -20000,0.26524,0.2705,0.05,81.764 -20000,0.26524,0.2705,0.05,81.764 -20000,0.26524,0.2705,0.05,81.764 -20000,0.26524,0.2705,0.05,81.764 -20000,0.27048,0.27585,0.05,82.79 -20000,0.27048,0.27585,0.05,82.79 -20000,0.27048,0.27585,0.05,82.79 -20000,0.27048,0.27585,0.05,82.79 -20000,0.27048,0.27585,0.05,82.79 -20000,0.27584,0.28131,0.05,83.785 -20000,0.27584,0.28131,0.05,83.785 -20000,0.27584,0.28131,0.05,83.785 -20000,0.27584,0.28131,0.05,83.785 -20000,0.27584,0.28131,0.05,83.785 -20000,0.27584,0.28131,0.05,83.785 -20000,0.2813,0.28687,0.05,84.75 -20000,0.2813,0.28687,0.05,84.75 -20000,0.2813,0.28687,0.05,84.75 -20000,0.2813,0.28687,0.05,84.75 -20000,0.2813,0.28687,0.05,84.75 -20000,0.28686,0.29255,0.05,85.684 -20000,0.28686,0.29255,0.05,85.684 -20000,0.28686,0.29255,0.05,85.684 -20000,0.28686,0.29255,0.05,85.684 -20000,0.28686,0.29255,0.05,85.684 -20000,0.28686,0.29255,0.05,85.684 -20000,0.29254,0.29834,0.05,86.585 -20000,0.29254,0.29834,0.05,86.585 -20000,0.29254,0.29834,0.05,86.585 -20000,0.29254,0.29834,0.05,86.585 -20000,0.29254,0.29834,0.05,86.585 -20000,0.29254,0.29834,0.05,86.585 -20000,0.29833,0.30425,0.05,87.454 -20000,0.29833,0.30425,0.05,87.454 -20000,0.29833,0.30425,0.05,87.454 -20000,0.29833,0.30425,0.05,87.454 -20000,0.29833,0.30425,0.05,87.454 -20000,0.29833,0.30425,0.05,87.454 -20000,0.30424,0.31027,0.05,88.291 -20000,0.30424,0.31027,0.05,88.291 -20000,0.30424,0.31027,0.05,88.291 -20000,0.30424,0.31027,0.05,88.291 -20000,0.30424,0.31027,0.05,88.291 -20000,0.30424,0.31027,0.05,88.291 -20000,0.31026,0.31641,0.05,89.094 -20000,0.31026,0.31641,0.05,89.094 -20000,0.31026,0.31641,0.05,89.094 -20000,0.31026,0.31641,0.05,89.094 -20000,0.31026,0.31641,0.05,89.094 -20000,0.31026,0.31641,0.05,89.094 -20000,0.3164,0.32267,0.05,89.864 -20000,0.3164,0.32267,0.05,89.864 -20000,0.3164,0.32267,0.05,89.864 -20000,0.3164,0.32267,0.05,89.864 -20000,0.3164,0.32267,0.05,89.864 -20000,0.3164,0.32267,0.05,89.864 -20000,0.32266,0.32906,0.05,90.6 -20000,0.32266,0.32906,0.05,90.6 -20000,0.32266,0.32906,0.05,90.6 -20000,0.32266,0.32906,0.05,90.6 -20000,0.32266,0.32906,0.05,90.6 -20000,0.32266,0.32906,0.05,90.6 -20000,0.32266,0.32906,0.05,90.6 -20000,0.32905,0.33558,0.05,91.303 -20000,0.32905,0.33558,0.05,91.303 -20000,0.32905,0.33558,0.05,91.303 -20000,0.32905,0.33558,0.05,91.303 -20000,0.32905,0.33558,0.05,91.303 -20000,0.32905,0.33558,0.05,91.303 -20000,0.33556,0.34222,0.05,91.973 -20000,0.33556,0.34222,0.05,91.973 -20000,0.33556,0.34222,0.05,91.973 -20000,0.33556,0.34222,0.05,91.973 -20000,0.33556,0.34222,0.05,91.973 -20000,0.33556,0.34222,0.05,91.973 -20000,0.33556,0.34222,0.05,91.973 -20000,0.34221,0.34899,0.05,92.609 -20000,0.34221,0.34899,0.05,92.609 -20000,0.34221,0.34899,0.05,92.609 -20000,0.34221,0.34899,0.05,92.609 -20000,0.34221,0.34899,0.05,92.609 -20000,0.34221,0.34899,0.05,92.609 -20000,0.34221,0.34899,0.05,92.609 -20000,0.34898,0.3559,0.05,93.212 -20000,0.34898,0.3559,0.05,93.212 -20000,0.34898,0.3559,0.05,93.212 -20000,0.34898,0.3559,0.05,93.212 -20000,0.34898,0.3559,0.05,93.212 -20000,0.34898,0.3559,0.05,93.212 -20000,0.35589,0.36295,0.05,93.782 -20000,0.35589,0.36295,0.05,93.782 -20000,0.35589,0.36295,0.05,93.782 -20000,0.35589,0.36295,0.05,93.782 -20000,0.35589,0.36295,0.05,93.782 -20000,0.35589,0.36295,0.05,93.782 -20000,0.35589,0.36295,0.05,93.782 -20000,0.36294,0.37013,0.05,94.32 -20000,0.36294,0.37013,0.05,94.32 -20000,0.36294,0.37013,0.05,94.32 -20000,0.36294,0.37013,0.05,94.32 -20000,0.36294,0.37013,0.05,94.32 -20000,0.36294,0.37013,0.05,94.32 -20000,0.36294,0.37013,0.05,94.32 -20000,0.36294,0.37013,0.05,94.32 -20000,0.37012,0.37746,0.05,94.825 -20000,0.37012,0.37746,0.05,94.825 -20000,0.37012,0.37746,0.05,94.825 -20000,0.37012,0.37746,0.05,94.825 -20000,0.37012,0.37746,0.05,94.825 -20000,0.37012,0.37746,0.05,94.825 -20000,0.37012,0.37746,0.05,94.825 -20000,0.37745,0.38494,0.05,95.3 -20000,0.37745,0.38494,0.05,95.3 -20000,0.37745,0.38494,0.05,95.3 -20000,0.37745,0.38494,0.05,95.3 -20000,0.37745,0.38494,0.05,95.3 -20000,0.37745,0.38494,0.05,95.3 -20000,0.37745,0.38494,0.05,95.3 -20000,0.38493,0.39256,0.05,95.743 -20000,0.38493,0.39256,0.05,95.743 -20000,0.38493,0.39256,0.05,95.743 -20000,0.38493,0.39256,0.05,95.743 -20000,0.38493,0.39256,0.05,95.743 -20000,0.38493,0.39256,0.05,95.743 -20000,0.38493,0.39256,0.05,95.743 -20000,0.38493,0.39256,0.05,95.743 -20000,0.39255,0.40033,0.05,96.157 -20000,0.39255,0.40033,0.05,96.157 -20000,0.39255,0.40033,0.05,96.157 -20000,0.39255,0.40033,0.05,96.157 -20000,0.39255,0.40033,0.05,96.157 -20000,0.39255,0.40033,0.05,96.157 -20000,0.39255,0.40033,0.05,96.157 -20000,0.39255,0.40033,0.05,96.157 -20000,0.40032,0.40826,0.05,96.541 -20000,0.40032,0.40826,0.05,96.541 -20000,0.40032,0.40826,0.05,96.541 -20000,0.40032,0.40826,0.05,96.541 -20000,0.40032,0.40826,0.05,96.541 -20000,0.40032,0.40826,0.05,96.541 -20000,0.40032,0.40826,0.05,96.541 -20000,0.40032,0.40826,0.05,96.541 -20000,0.40825,0.41634,0.05,96.898 -20000,0.40825,0.41634,0.05,96.898 -20000,0.40825,0.41634,0.05,96.898 -20000,0.40825,0.41634,0.05,96.898 -20000,0.40825,0.41634,0.05,96.898 -20000,0.40825,0.41634,0.05,96.898 -20000,0.40825,0.41634,0.05,96.898 -20000,0.40825,0.41634,0.05,96.898 -20000,0.41633,0.42459,0.05,97.227 -20000,0.41633,0.42459,0.05,97.227 -20000,0.41633,0.42459,0.05,97.227 -20000,0.41633,0.42459,0.05,97.227 -20000,0.41633,0.42459,0.05,97.227 -20000,0.41633,0.42459,0.05,97.227 -20000,0.41633,0.42459,0.05,97.227 -20000,0.41633,0.42459,0.05,97.227 -20000,0.42458,0.433,0.05,97.53 -20000,0.42458,0.433,0.05,97.53 -20000,0.42458,0.433,0.05,97.53 -20000,0.42458,0.433,0.05,97.53 -20000,0.42458,0.433,0.05,97.53 -20000,0.42458,0.433,0.05,97.53 -20000,0.42458,0.433,0.05,97.53 -20000,0.42458,0.433,0.05,97.53 -20000,0.42458,0.433,0.05,97.53 -20000,0.43298,0.44157,0.05,97.807 -20000,0.43298,0.44157,0.05,97.807 -20000,0.43298,0.44157,0.05,97.807 -20000,0.43298,0.44157,0.05,97.807 -20000,0.43298,0.44157,0.05,97.807 -20000,0.43298,0.44157,0.05,97.807 -20000,0.43298,0.44157,0.05,97.807 -20000,0.43298,0.44157,0.05,97.807 -20000,0.44156,0.45031,0.05,98.061 -20000,0.44156,0.45031,0.05,98.061 -20000,0.44156,0.45031,0.05,98.061 -20000,0.44156,0.45031,0.05,98.061 -20000,0.44156,0.45031,0.05,98.061 -20000,0.44156,0.45031,0.05,98.061 -20000,0.44156,0.45031,0.05,98.061 -20000,0.44156,0.45031,0.05,98.061 -20000,0.44156,0.45031,0.05,98.061 -20000,0.4503,0.45923,0.05,98.292 -20000,0.4503,0.45923,0.05,98.292 -20000,0.4503,0.45923,0.05,98.292 -20000,0.4503,0.45923,0.05,98.292 -20000,0.4503,0.45923,0.05,98.292 -20000,0.4503,0.45923,0.05,98.292 -20000,0.4503,0.45923,0.05,98.292 -20000,0.4503,0.45923,0.05,98.292 -20000,0.4503,0.45923,0.05,98.292 -20000,0.45922,0.46833,0.05,98.502 -20000,0.45922,0.46833,0.05,98.502 -20000,0.45922,0.46833,0.05,98.502 -20000,0.45922,0.46833,0.05,98.502 -20000,0.45922,0.46833,0.05,98.502 -20000,0.45922,0.46833,0.05,98.502 -20000,0.45922,0.46833,0.05,98.502 -20000,0.45922,0.46833,0.05,98.502 -20000,0.45922,0.46833,0.05,98.502 -20000,0.46832,0.4776,0.05,98.691 -20000,0.46832,0.4776,0.05,98.691 -20000,0.46832,0.4776,0.05,98.691 -20000,0.46832,0.4776,0.05,98.691 -20000,0.46832,0.4776,0.05,98.691 -20000,0.46832,0.4776,0.05,98.691 -20000,0.46832,0.4776,0.05,98.691 -20000,0.46832,0.4776,0.05,98.691 -20000,0.46832,0.4776,0.05,98.691 -20000,0.47759,0.48706,0.05,98.861 -20000,0.47759,0.48706,0.05,98.861 -20000,0.47759,0.48706,0.05,98.861 -20000,0.47759,0.48706,0.05,98.861 -20000,0.47759,0.48706,0.05,98.861 -20000,0.47759,0.48706,0.05,98.861 -20000,0.47759,0.48706,0.05,98.861 -20000,0.47759,0.48706,0.05,98.861 -20000,0.47759,0.48706,0.05,98.861 -20000,0.47759,0.48706,0.05,98.861 -20000,0.48705,0.49671,0.05,99.013 -20000,0.48705,0.49671,0.05,99.013 -20000,0.48705,0.49671,0.05,99.013 -20000,0.48705,0.49671,0.05,99.013 -20000,0.48705,0.49671,0.05,99.013 -20000,0.48705,0.49671,0.05,99.013 -20000,0.48705,0.49671,0.05,99.013 -20000,0.48705,0.49671,0.05,99.013 -20000,0.48705,0.49671,0.05,99.013 -20000,0.4967,0.50655,0.05,99.149 -20000,0.4967,0.50655,0.05,99.149 -20000,0.4967,0.50655,0.05,99.149 -20000,0.4967,0.50655,0.05,99.149 -20000,0.4967,0.50655,0.05,99.149 -20000,0.4967,0.50655,0.05,99.149 -20000,0.4967,0.50655,0.05,99.149 -20000,0.4967,0.50655,0.05,99.149 -20000,0.4967,0.50655,0.05,99.149 -20000,0.4967,0.50655,0.05,99.149 -20000,0.50654,0.51658,0.05,99.27 -20000,0.50654,0.51658,0.05,99.27 -20000,0.50654,0.51658,0.05,99.27 -20000,0.50654,0.51658,0.05,99.27 -20000,0.50654,0.51658,0.05,99.27 -20000,0.50654,0.51658,0.05,99.27 -20000,0.50654,0.51658,0.05,99.27 -20000,0.50654,0.51658,0.05,99.27 -20000,0.50654,0.51658,0.05,99.27 -20000,0.50654,0.51658,0.05,99.27 -20000,0.51657,0.52681,0.05,99.377 -20000,0.51657,0.52681,0.05,99.377 -20000,0.51657,0.52681,0.05,99.377 -20000,0.51657,0.52681,0.05,99.377 -20000,0.51657,0.52681,0.05,99.377 -20000,0.51657,0.52681,0.05,99.377 -20000,0.51657,0.52681,0.05,99.377 -20000,0.51657,0.52681,0.05,99.377 -20000,0.51657,0.52681,0.05,99.377 -20000,0.51657,0.52681,0.05,99.377 -20000,0.5268,0.53725,0.05,99.47 -20000,0.5268,0.53725,0.05,99.47 -20000,0.5268,0.53725,0.05,99.47 -20000,0.5268,0.53725,0.05,99.47 -20000,0.5268,0.53725,0.05,99.47 -20000,0.5268,0.53725,0.05,99.47 -20000,0.5268,0.53725,0.05,99.47 -20000,0.5268,0.53725,0.05,99.47 -20000,0.5268,0.53725,0.05,99.47 -20000,0.5268,0.53725,0.05,99.47 -20000,0.5268,0.53725,0.05,99.47 -20000,0.53724,0.54789,0.05,99.552 -20000,0.53724,0.54789,0.05,99.552 -20000,0.53724,0.54789,0.05,99.552 -20000,0.53724,0.54789,0.05,99.552 -20000,0.53724,0.54789,0.05,99.552 -20000,0.53724,0.54789,0.05,99.552 -20000,0.53724,0.54789,0.05,99.552 -20000,0.53724,0.54789,0.05,99.552 -20000,0.53724,0.54789,0.05,99.552 -20000,0.53724,0.54789,0.05,99.552 -20000,0.54788,0.55874,0.05,99.624 -20000,0.54788,0.55874,0.05,99.624 -20000,0.54788,0.55874,0.05,99.624 -20000,0.54788,0.55874,0.05,99.624 -20000,0.54788,0.55874,0.05,99.624 -20000,0.54788,0.55874,0.05,99.624 -20000,0.54788,0.55874,0.05,99.624 -20000,0.54788,0.55874,0.05,99.624 -20000,0.54788,0.55874,0.05,99.624 -20000,0.54788,0.55874,0.05,99.624 -20000,0.54788,0.55874,0.05,99.624 -20000,0.55873,0.56981,0.05,99.686 -20000,0.55873,0.56981,0.05,99.686 -20000,0.55873,0.56981,0.05,99.686 -20000,0.55873,0.56981,0.05,99.686 -20000,0.55873,0.56981,0.05,99.686 -20000,0.55873,0.56981,0.05,99.686 -20000,0.55873,0.56981,0.05,99.686 -20000,0.55873,0.56981,0.05,99.686 -20000,0.55873,0.56981,0.05,99.686 -20000,0.55873,0.56981,0.05,99.686 -20000,0.55873,0.56981,0.05,99.686 -20000,0.5698,0.5811,0.05,99.739 -20000,0.5698,0.5811,0.05,99.739 -20000,0.5698,0.5811,0.05,99.739 -20000,0.5698,0.5811,0.05,99.739 -20000,0.5698,0.5811,0.05,99.739 -20000,0.5698,0.5811,0.05,99.739 -20000,0.5698,0.5811,0.05,99.739 -20000,0.5698,0.5811,0.05,99.739 -20000,0.5698,0.5811,0.05,99.739 -20000,0.5698,0.5811,0.05,99.739 -20000,0.5698,0.5811,0.05,99.739 -20000,0.5698,0.5811,0.05,99.739 -20000,0.58109,0.59261,0.05,99.785 -20000,0.58109,0.59261,0.05,99.785 -20000,0.58109,0.59261,0.05,99.785 -20000,0.58109,0.59261,0.05,99.785 -20000,0.58109,0.59261,0.05,99.785 -20000,0.58109,0.59261,0.05,99.785 -20000,0.58109,0.59261,0.05,99.785 -20000,0.58109,0.59261,0.05,99.785 -20000,0.58109,0.59261,0.05,99.785 -20000,0.58109,0.59261,0.05,99.785 -20000,0.58109,0.59261,0.05,99.785 -20000,0.5926,0.60435,0.05,99.825 -20000,0.5926,0.60435,0.05,99.825 -20000,0.5926,0.60435,0.05,99.825 -20000,0.5926,0.60435,0.05,99.825 -20000,0.5926,0.60435,0.05,99.825 -20000,0.5926,0.60435,0.05,99.825 -20000,0.5926,0.60435,0.05,99.825 -20000,0.5926,0.60435,0.05,99.825 -20000,0.5926,0.60435,0.05,99.825 -20000,0.5926,0.60435,0.05,99.825 -20000,0.5926,0.60435,0.05,99.825 -20000,0.5926,0.60435,0.05,99.825 -20000,0.60434,0.61632,0.05,99.858 -20000,0.60434,0.61632,0.05,99.858 -20000,0.60434,0.61632,0.05,99.858 -20000,0.60434,0.61632,0.05,99.858 -20000,0.60434,0.61632,0.05,99.858 -20000,0.60434,0.61632,0.05,99.858 -20000,0.60434,0.61632,0.05,99.858 -20000,0.60434,0.61632,0.05,99.858 -20000,0.60434,0.61632,0.05,99.858 -20000,0.60434,0.61632,0.05,99.858 -20000,0.60434,0.61632,0.05,99.858 -20000,0.60434,0.61632,0.05,99.858 -20000,0.61631,0.62853,0.05,99.887 -20000,0.61631,0.62853,0.05,99.887 -20000,0.61631,0.62853,0.05,99.887 -20000,0.61631,0.62853,0.05,99.887 -20000,0.61631,0.62853,0.05,99.887 -20000,0.61631,0.62853,0.05,99.887 -20000,0.61631,0.62853,0.05,99.887 -20000,0.61631,0.62853,0.05,99.887 -20000,0.61631,0.62853,0.05,99.887 -20000,0.61631,0.62853,0.05,99.887 -20000,0.61631,0.62853,0.05,99.887 -20000,0.61631,0.62853,0.05,99.887 -20000,0.62852,0.64098,0.05,99.911 -20000,0.62852,0.64098,0.05,99.911 -20000,0.62852,0.64098,0.05,99.911 -20000,0.62852,0.64098,0.05,99.911 -20000,0.62852,0.64098,0.05,99.911 -20000,0.62852,0.64098,0.05,99.911 -20000,0.62852,0.64098,0.05,99.911 -20000,0.62852,0.64098,0.05,99.911 -20000,0.62852,0.64098,0.05,99.911 -20000,0.62852,0.64098,0.05,99.911 -20000,0.62852,0.64098,0.05,99.911 -20000,0.62852,0.64098,0.05,99.911 -20000,0.62852,0.64098,0.05,99.911 -20000,0.64097,0.65368,0.05,99.932 -20000,0.64097,0.65368,0.05,99.932 -20000,0.64097,0.65368,0.05,99.932 -20000,0.64097,0.65368,0.05,99.932 -20000,0.64097,0.65368,0.05,99.932 -20000,0.64097,0.65368,0.05,99.932 -20000,0.64097,0.65368,0.05,99.932 -20000,0.64097,0.65368,0.05,99.932 -20000,0.64097,0.65368,0.05,99.932 -20000,0.64097,0.65368,0.05,99.932 -20000,0.64097,0.65368,0.05,99.932 -20000,0.64097,0.65368,0.05,99.932 -20000,0.65367,0.66663,0.05,99.95 -20000,0.65367,0.66663,0.05,99.95 -20000,0.65367,0.66663,0.05,99.95 -20000,0.65367,0.66663,0.05,99.95 -20000,0.65367,0.66663,0.05,99.95 -20000,0.65367,0.66663,0.05,99.95 -20000,0.65367,0.66663,0.05,99.95 -20000,0.65367,0.66663,0.05,99.95 -20000,0.65367,0.66663,0.05,99.95 -20000,0.65367,0.66663,0.05,99.95 -20000,0.65367,0.66663,0.05,99.95 -20000,0.65367,0.66663,0.05,99.95 -20000,0.65367,0.66663,0.05,99.95 -20000,0.66662,0.67984,0.05,99.966 -20000,0.66662,0.67984,0.05,99.966 -20000,0.66662,0.67984,0.05,99.966 -20000,0.66662,0.67984,0.05,99.966 -20000,0.66662,0.67984,0.05,99.966 -20000,0.66662,0.67984,0.05,99.966 -20000,0.66662,0.67984,0.05,99.966 -20000,0.66662,0.67984,0.05,99.966 -20000,0.66662,0.67984,0.05,99.966 -20000,0.66662,0.67984,0.05,99.966 -20000,0.66662,0.67984,0.05,99.966 -20000,0.66662,0.67984,0.05,99.966 -20000,0.66662,0.67984,0.05,99.966 -20000,0.67983,0.69331,0.05,99.98 -20000,0.67983,0.69331,0.05,99.98 -20000,0.67983,0.69331,0.05,99.98 -20000,0.67983,0.69331,0.05,99.98 -20000,0.67983,0.69331,0.05,99.98 -20000,0.67983,0.69331,0.05,99.98 -20000,0.67983,0.69331,0.05,99.98 -20000,0.67983,0.69331,0.05,99.98 -20000,0.67983,0.69331,0.05,99.98 -20000,0.67983,0.69331,0.05,99.98 -20000,0.67983,0.69331,0.05,99.98 -20000,0.67983,0.69331,0.05,99.98 -20000,0.67983,0.69331,0.05,99.98 -20000,0.67983,0.69331,0.05,99.98 -20000,0.6933,0.70704,0.05,99.994 -20000,0.6933,0.70704,0.05,99.994 -20000,0.6933,0.70704,0.05,99.994 -20000,0.6933,0.70704,0.05,99.994 -20000,0.6933,0.70704,0.05,99.994 -20000,0.6933,0.70704,0.05,99.994 -20000,0.6933,0.70704,0.05,99.994 -20000,0.6933,0.70704,0.05,99.994 -20000,0.6933,0.70704,0.05,99.994 -20000,0.6933,0.70704,0.05,99.994 -20000,0.6933,0.70704,0.05,99.994 -20000,0.6933,0.70704,0.05,99.994 -20000,0.6933,0.70704,0.05,99.994 -20000,0.6933,0.70704,0.05,99.994 -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_5.csv b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_5.csv deleted file mode 100644 index 03f9eb13744..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/data_5.csv +++ /dev/null @@ -1,1002 +0,0 @@ -Time,"elementCenter:0","elementCenter:1","elementCenter:2","temperature" -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,0.07071,0.072112,0.05,-19.355 -50000,0.07071,0.072112,0.05,-19.355 -50000,0.07211,0.07354,0.05,-18.09 -50000,0.07351,0.074968,0.05,-16.848 -50000,0.075155,0.076646,0.05,-15.415 -50000,0.075155,0.076646,0.05,-15.415 -50000,0.077046,0.078574,0.05,-13.807 -50000,0.077046,0.078574,0.05,-13.807 -50000,0.078936,0.080501,0.05,-12.236 -50000,0.078936,0.080501,0.05,-12.236 -50000,0.080826,0.082429,0.05,-10.701 -50000,0.080826,0.082429,0.05,-10.701 -50000,0.082716,0.084357,0.05,-9.2003 -50000,0.082716,0.084357,0.05,-9.2003 -50000,0.084607,0.086285,0.05,-7.7316 -50000,0.084607,0.086285,0.05,-7.7316 -50000,0.086497,0.088212,0.05,-6.294 -50000,0.086497,0.088212,0.05,-6.294 -50000,0.088387,0.09014,0.05,-4.8861 -50000,0.088387,0.09014,0.05,-4.8861 -50000,0.090278,0.092068,0.05,-3.5069 -50000,0.090278,0.092068,0.05,-3.5069 -50000,0.092168,0.093995,0.05,-2.1551 -50000,0.092168,0.093995,0.05,-2.1551 -50000,0.094031,0.095896,0.05,-0.84874 -50000,0.095885,0.097786,0.05,0.42708 -50000,0.095885,0.097786,0.05,0.42708 -50000,0.097776,0.099715,0.05,1.7039 -50000,0.097776,0.099715,0.05,1.7039 -50000,0.099704,0.10168,0.05,2.9817 -50000,0.099704,0.10168,0.05,2.9817 -50000,0.10167,0.10369,0.05,4.2604 -50000,0.10167,0.10369,0.05,4.2604 -50000,0.10368,0.10573,0.05,5.54 -50000,0.10368,0.10573,0.05,5.54 -50000,0.10572,0.10782,0.05,6.8204 -50000,0.10572,0.10782,0.05,6.8204 -50000,0.10781,0.10995,0.05,8.1016 -50000,0.10781,0.10995,0.05,8.1016 -50000,0.10993,0.11211,0.05,9.3835 -50000,0.10993,0.11211,0.05,9.3835 -50000,0.10993,0.11211,0.05,9.3835 -50000,0.1121,0.11433,0.05,10.666 -50000,0.1121,0.11433,0.05,10.666 -50000,0.11432,0.11658,0.05,11.949 -50000,0.11432,0.11658,0.05,11.949 -50000,0.11657,0.11888,0.05,13.233 -50000,0.11657,0.11888,0.05,13.233 -50000,0.11887,0.12123,0.05,14.517 -50000,0.11887,0.12123,0.05,14.517 -50000,0.11887,0.12123,0.05,14.517 -50000,0.12122,0.12362,0.05,15.801 -50000,0.12122,0.12362,0.05,15.801 -50000,0.12361,0.12607,0.05,17.086 -50000,0.12361,0.12607,0.05,17.086 -50000,0.12361,0.12607,0.05,17.086 -50000,0.12605,0.12855,0.05,18.371 -50000,0.12605,0.12855,0.05,18.371 -50000,0.12854,0.13109,0.05,19.655 -50000,0.12854,0.13109,0.05,19.655 -50000,0.12854,0.13109,0.05,19.655 -50000,0.13108,0.13368,0.05,20.94 -50000,0.13108,0.13368,0.05,20.94 -50000,0.13367,0.13632,0.05,22.225 -50000,0.13367,0.13632,0.05,22.225 -50000,0.13367,0.13632,0.05,22.225 -50000,0.13631,0.13901,0.05,23.51 -50000,0.13631,0.13901,0.05,23.51 -50000,0.13631,0.13901,0.05,23.51 -50000,0.139,0.14176,0.05,24.794 -50000,0.139,0.14176,0.05,24.794 -50000,0.14175,0.14456,0.05,26.077 -50000,0.14175,0.14456,0.05,26.077 -50000,0.14175,0.14456,0.05,26.077 -50000,0.14455,0.14742,0.05,27.36 -50000,0.14455,0.14742,0.05,27.36 -50000,0.14455,0.14742,0.05,27.36 -50000,0.1474,0.15033,0.05,28.642 -50000,0.1474,0.15033,0.05,28.642 -50000,0.1474,0.15033,0.05,28.642 -50000,0.15032,0.1533,0.05,29.924 -50000,0.15032,0.1533,0.05,29.924 -50000,0.15032,0.1533,0.05,29.924 -50000,0.15329,0.15633,0.05,31.204 -50000,0.15329,0.15633,0.05,31.204 -50000,0.15329,0.15633,0.05,31.204 -50000,0.15632,0.15942,0.05,32.483 -50000,0.15632,0.15942,0.05,32.483 -50000,0.15632,0.15942,0.05,32.483 -50000,0.15941,0.16257,0.05,33.761 -50000,0.15941,0.16257,0.05,33.761 -50000,0.15941,0.16257,0.05,33.761 -50000,0.16256,0.16578,0.05,35.037 -50000,0.16256,0.16578,0.05,35.037 -50000,0.16256,0.16578,0.05,35.037 -50000,0.16577,0.16906,0.05,36.311 -50000,0.16577,0.16906,0.05,36.311 -50000,0.16577,0.16906,0.05,36.311 -50000,0.16577,0.16906,0.05,36.311 -50000,0.16905,0.1724,0.05,37.583 -50000,0.16905,0.1724,0.05,37.583 -50000,0.16905,0.1724,0.05,37.583 -50000,0.17239,0.1758,0.05,38.853 -50000,0.17239,0.1758,0.05,38.853 -50000,0.17239,0.1758,0.05,38.853 -50000,0.17579,0.17928,0.05,40.12 -50000,0.17579,0.17928,0.05,40.12 -50000,0.17579,0.17928,0.05,40.12 -50000,0.17579,0.17928,0.05,40.12 -50000,0.17927,0.18282,0.05,41.385 -50000,0.17927,0.18282,0.05,41.385 -50000,0.17927,0.18282,0.05,41.385 -50000,0.18281,0.18644,0.05,42.647 -50000,0.18281,0.18644,0.05,42.647 -50000,0.18281,0.18644,0.05,42.647 -50000,0.18281,0.18644,0.05,42.647 -50000,0.18643,0.19013,0.05,43.906 -50000,0.18643,0.19013,0.05,43.906 -50000,0.18643,0.19013,0.05,43.906 -50000,0.18643,0.19013,0.05,43.906 -50000,0.19011,0.19388,0.05,45.161 -50000,0.19011,0.19388,0.05,45.161 -50000,0.19011,0.19388,0.05,45.161 -50000,0.19387,0.19772,0.05,46.413 -50000,0.19387,0.19772,0.05,46.413 -50000,0.19387,0.19772,0.05,46.413 -50000,0.19387,0.19772,0.05,46.413 -50000,0.19771,0.20163,0.05,47.66 -50000,0.19771,0.20163,0.05,47.66 -50000,0.19771,0.20163,0.05,47.66 -50000,0.19771,0.20163,0.05,47.66 -50000,0.20162,0.20562,0.05,48.904 -50000,0.20162,0.20562,0.05,48.904 -50000,0.20162,0.20562,0.05,48.904 -50000,0.20162,0.20562,0.05,48.904 -50000,0.2056,0.20968,0.05,50.142 -50000,0.2056,0.20968,0.05,50.142 -50000,0.2056,0.20968,0.05,50.142 -50000,0.2056,0.20968,0.05,50.142 -50000,0.20967,0.21383,0.05,51.376 -50000,0.20967,0.21383,0.05,51.376 -50000,0.20967,0.21383,0.05,51.376 -50000,0.20967,0.21383,0.05,51.376 -50000,0.21382,0.21806,0.05,52.604 -50000,0.21382,0.21806,0.05,52.604 -50000,0.21382,0.21806,0.05,52.604 -50000,0.21382,0.21806,0.05,52.604 -50000,0.21382,0.21806,0.05,52.604 -50000,0.21805,0.22237,0.05,53.826 -50000,0.21805,0.22237,0.05,53.826 -50000,0.21805,0.22237,0.05,53.826 -50000,0.21805,0.22237,0.05,53.826 -50000,0.22236,0.22677,0.05,55.043 -50000,0.22236,0.22677,0.05,55.043 -50000,0.22236,0.22677,0.05,55.043 -50000,0.22236,0.22677,0.05,55.043 -50000,0.22676,0.23125,0.05,56.253 -50000,0.22676,0.23125,0.05,56.253 -50000,0.22676,0.23125,0.05,56.253 -50000,0.22676,0.23125,0.05,56.253 -50000,0.22676,0.23125,0.05,56.253 -50000,0.23124,0.23583,0.05,57.456 -50000,0.23124,0.23583,0.05,57.456 -50000,0.23124,0.23583,0.05,57.456 -50000,0.23124,0.23583,0.05,57.456 -50000,0.23582,0.2405,0.05,58.652 -50000,0.23582,0.2405,0.05,58.652 -50000,0.23582,0.2405,0.05,58.652 -50000,0.23582,0.2405,0.05,58.652 -50000,0.23582,0.2405,0.05,58.652 -50000,0.24048,0.24525,0.05,59.84 -50000,0.24048,0.24525,0.05,59.84 -50000,0.24048,0.24525,0.05,59.84 -50000,0.24048,0.24525,0.05,59.84 -50000,0.24048,0.24525,0.05,59.84 -50000,0.24524,0.25011,0.05,61.019 -50000,0.24524,0.25011,0.05,61.019 -50000,0.24524,0.25011,0.05,61.019 -50000,0.24524,0.25011,0.05,61.019 -50000,0.24524,0.25011,0.05,61.019 -50000,0.25009,0.25505,0.05,62.191 -50000,0.25009,0.25505,0.05,62.191 -50000,0.25009,0.25505,0.05,62.191 -50000,0.25009,0.25505,0.05,62.191 -50000,0.25009,0.25505,0.05,62.191 -50000,0.25504,0.2601,0.05,63.353 -50000,0.25504,0.2601,0.05,63.353 -50000,0.25504,0.2601,0.05,63.353 -50000,0.25504,0.2601,0.05,63.353 -50000,0.25504,0.2601,0.05,63.353 -50000,0.26009,0.26525,0.05,64.505 -50000,0.26009,0.26525,0.05,64.505 -50000,0.26009,0.26525,0.05,64.505 -50000,0.26009,0.26525,0.05,64.505 -50000,0.26009,0.26525,0.05,64.505 -50000,0.26524,0.2705,0.05,65.647 -50000,0.26524,0.2705,0.05,65.647 -50000,0.26524,0.2705,0.05,65.647 -50000,0.26524,0.2705,0.05,65.647 -50000,0.26524,0.2705,0.05,65.647 -50000,0.27048,0.27585,0.05,66.779 -50000,0.27048,0.27585,0.05,66.779 -50000,0.27048,0.27585,0.05,66.779 -50000,0.27048,0.27585,0.05,66.779 -50000,0.27048,0.27585,0.05,66.779 -50000,0.27584,0.28131,0.05,67.9 -50000,0.27584,0.28131,0.05,67.9 -50000,0.27584,0.28131,0.05,67.9 -50000,0.27584,0.28131,0.05,67.9 -50000,0.27584,0.28131,0.05,67.9 -50000,0.27584,0.28131,0.05,67.9 -50000,0.2813,0.28687,0.05,69.008 -50000,0.2813,0.28687,0.05,69.008 -50000,0.2813,0.28687,0.05,69.008 -50000,0.2813,0.28687,0.05,69.008 -50000,0.2813,0.28687,0.05,69.008 -50000,0.28686,0.29255,0.05,70.105 -50000,0.28686,0.29255,0.05,70.105 -50000,0.28686,0.29255,0.05,70.105 -50000,0.28686,0.29255,0.05,70.105 -50000,0.28686,0.29255,0.05,70.105 -50000,0.28686,0.29255,0.05,70.105 -50000,0.29254,0.29834,0.05,71.189 -50000,0.29254,0.29834,0.05,71.189 -50000,0.29254,0.29834,0.05,71.189 -50000,0.29254,0.29834,0.05,71.189 -50000,0.29254,0.29834,0.05,71.189 -50000,0.29254,0.29834,0.05,71.189 -50000,0.29833,0.30425,0.05,72.259 -50000,0.29833,0.30425,0.05,72.259 -50000,0.29833,0.30425,0.05,72.259 -50000,0.29833,0.30425,0.05,72.259 -50000,0.29833,0.30425,0.05,72.259 -50000,0.29833,0.30425,0.05,72.259 -50000,0.30424,0.31027,0.05,73.315 -50000,0.30424,0.31027,0.05,73.315 -50000,0.30424,0.31027,0.05,73.315 -50000,0.30424,0.31027,0.05,73.315 -50000,0.30424,0.31027,0.05,73.315 -50000,0.30424,0.31027,0.05,73.315 -50000,0.31026,0.31641,0.05,74.357 -50000,0.31026,0.31641,0.05,74.357 -50000,0.31026,0.31641,0.05,74.357 -50000,0.31026,0.31641,0.05,74.357 -50000,0.31026,0.31641,0.05,74.357 -50000,0.31026,0.31641,0.05,74.357 -50000,0.3164,0.32267,0.05,75.384 -50000,0.3164,0.32267,0.05,75.384 -50000,0.3164,0.32267,0.05,75.384 -50000,0.3164,0.32267,0.05,75.384 -50000,0.3164,0.32267,0.05,75.384 -50000,0.3164,0.32267,0.05,75.384 -50000,0.32266,0.32906,0.05,76.395 -50000,0.32266,0.32906,0.05,76.395 -50000,0.32266,0.32906,0.05,76.395 -50000,0.32266,0.32906,0.05,76.395 -50000,0.32266,0.32906,0.05,76.395 -50000,0.32266,0.32906,0.05,76.395 -50000,0.32266,0.32906,0.05,76.395 -50000,0.32905,0.33558,0.05,77.389 -50000,0.32905,0.33558,0.05,77.389 -50000,0.32905,0.33558,0.05,77.389 -50000,0.32905,0.33558,0.05,77.389 -50000,0.32905,0.33558,0.05,77.389 -50000,0.32905,0.33558,0.05,77.389 -50000,0.33556,0.34222,0.05,78.367 -50000,0.33556,0.34222,0.05,78.367 -50000,0.33556,0.34222,0.05,78.367 -50000,0.33556,0.34222,0.05,78.367 -50000,0.33556,0.34222,0.05,78.367 -50000,0.33556,0.34222,0.05,78.367 -50000,0.33556,0.34222,0.05,78.367 -50000,0.34221,0.34899,0.05,79.327 -50000,0.34221,0.34899,0.05,79.327 -50000,0.34221,0.34899,0.05,79.327 -50000,0.34221,0.34899,0.05,79.327 -50000,0.34221,0.34899,0.05,79.327 -50000,0.34221,0.34899,0.05,79.327 -50000,0.34221,0.34899,0.05,79.327 -50000,0.34898,0.3559,0.05,80.269 -50000,0.34898,0.3559,0.05,80.269 -50000,0.34898,0.3559,0.05,80.269 -50000,0.34898,0.3559,0.05,80.269 -50000,0.34898,0.3559,0.05,80.269 -50000,0.34898,0.3559,0.05,80.269 -50000,0.35589,0.36295,0.05,81.192 -50000,0.35589,0.36295,0.05,81.192 -50000,0.35589,0.36295,0.05,81.192 -50000,0.35589,0.36295,0.05,81.192 -50000,0.35589,0.36295,0.05,81.192 -50000,0.35589,0.36295,0.05,81.192 -50000,0.35589,0.36295,0.05,81.192 -50000,0.36294,0.37013,0.05,82.097 -50000,0.36294,0.37013,0.05,82.097 -50000,0.36294,0.37013,0.05,82.097 -50000,0.36294,0.37013,0.05,82.097 -50000,0.36294,0.37013,0.05,82.097 -50000,0.36294,0.37013,0.05,82.097 -50000,0.36294,0.37013,0.05,82.097 -50000,0.36294,0.37013,0.05,82.097 -50000,0.37012,0.37746,0.05,82.981 -50000,0.37012,0.37746,0.05,82.981 -50000,0.37012,0.37746,0.05,82.981 -50000,0.37012,0.37746,0.05,82.981 -50000,0.37012,0.37746,0.05,82.981 -50000,0.37012,0.37746,0.05,82.981 -50000,0.37012,0.37746,0.05,82.981 -50000,0.37745,0.38494,0.05,83.845 -50000,0.37745,0.38494,0.05,83.845 -50000,0.37745,0.38494,0.05,83.845 -50000,0.37745,0.38494,0.05,83.845 -50000,0.37745,0.38494,0.05,83.845 -50000,0.37745,0.38494,0.05,83.845 -50000,0.37745,0.38494,0.05,83.845 -50000,0.38493,0.39256,0.05,84.688 -50000,0.38493,0.39256,0.05,84.688 -50000,0.38493,0.39256,0.05,84.688 -50000,0.38493,0.39256,0.05,84.688 -50000,0.38493,0.39256,0.05,84.688 -50000,0.38493,0.39256,0.05,84.688 -50000,0.38493,0.39256,0.05,84.688 -50000,0.38493,0.39256,0.05,84.688 -50000,0.39255,0.40033,0.05,85.51 -50000,0.39255,0.40033,0.05,85.51 -50000,0.39255,0.40033,0.05,85.51 -50000,0.39255,0.40033,0.05,85.51 -50000,0.39255,0.40033,0.05,85.51 -50000,0.39255,0.40033,0.05,85.51 -50000,0.39255,0.40033,0.05,85.51 -50000,0.39255,0.40033,0.05,85.51 -50000,0.40032,0.40826,0.05,86.311 -50000,0.40032,0.40826,0.05,86.311 -50000,0.40032,0.40826,0.05,86.311 -50000,0.40032,0.40826,0.05,86.311 -50000,0.40032,0.40826,0.05,86.311 -50000,0.40032,0.40826,0.05,86.311 -50000,0.40032,0.40826,0.05,86.311 -50000,0.40032,0.40826,0.05,86.311 -50000,0.40825,0.41634,0.05,87.089 -50000,0.40825,0.41634,0.05,87.089 -50000,0.40825,0.41634,0.05,87.089 -50000,0.40825,0.41634,0.05,87.089 -50000,0.40825,0.41634,0.05,87.089 -50000,0.40825,0.41634,0.05,87.089 -50000,0.40825,0.41634,0.05,87.089 -50000,0.40825,0.41634,0.05,87.089 -50000,0.41633,0.42459,0.05,87.845 -50000,0.41633,0.42459,0.05,87.845 -50000,0.41633,0.42459,0.05,87.845 -50000,0.41633,0.42459,0.05,87.845 -50000,0.41633,0.42459,0.05,87.845 -50000,0.41633,0.42459,0.05,87.845 -50000,0.41633,0.42459,0.05,87.845 -50000,0.41633,0.42459,0.05,87.845 -50000,0.42458,0.433,0.05,88.577 -50000,0.42458,0.433,0.05,88.577 -50000,0.42458,0.433,0.05,88.577 -50000,0.42458,0.433,0.05,88.577 -50000,0.42458,0.433,0.05,88.577 -50000,0.42458,0.433,0.05,88.577 -50000,0.42458,0.433,0.05,88.577 -50000,0.42458,0.433,0.05,88.577 -50000,0.42458,0.433,0.05,88.577 -50000,0.43298,0.44157,0.05,89.287 -50000,0.43298,0.44157,0.05,89.287 -50000,0.43298,0.44157,0.05,89.287 -50000,0.43298,0.44157,0.05,89.287 -50000,0.43298,0.44157,0.05,89.287 -50000,0.43298,0.44157,0.05,89.287 -50000,0.43298,0.44157,0.05,89.287 -50000,0.43298,0.44157,0.05,89.287 -50000,0.44156,0.45031,0.05,89.973 -50000,0.44156,0.45031,0.05,89.973 -50000,0.44156,0.45031,0.05,89.973 -50000,0.44156,0.45031,0.05,89.973 -50000,0.44156,0.45031,0.05,89.973 -50000,0.44156,0.45031,0.05,89.973 -50000,0.44156,0.45031,0.05,89.973 -50000,0.44156,0.45031,0.05,89.973 -50000,0.44156,0.45031,0.05,89.973 -50000,0.4503,0.45923,0.05,90.636 -50000,0.4503,0.45923,0.05,90.636 -50000,0.4503,0.45923,0.05,90.636 -50000,0.4503,0.45923,0.05,90.636 -50000,0.4503,0.45923,0.05,90.636 -50000,0.4503,0.45923,0.05,90.636 -50000,0.4503,0.45923,0.05,90.636 -50000,0.4503,0.45923,0.05,90.636 -50000,0.4503,0.45923,0.05,90.636 -50000,0.45922,0.46833,0.05,91.275 -50000,0.45922,0.46833,0.05,91.275 -50000,0.45922,0.46833,0.05,91.275 -50000,0.45922,0.46833,0.05,91.275 -50000,0.45922,0.46833,0.05,91.275 -50000,0.45922,0.46833,0.05,91.275 -50000,0.45922,0.46833,0.05,91.275 -50000,0.45922,0.46833,0.05,91.275 -50000,0.45922,0.46833,0.05,91.275 -50000,0.46832,0.4776,0.05,91.89 -50000,0.46832,0.4776,0.05,91.89 -50000,0.46832,0.4776,0.05,91.89 -50000,0.46832,0.4776,0.05,91.89 -50000,0.46832,0.4776,0.05,91.89 -50000,0.46832,0.4776,0.05,91.89 -50000,0.46832,0.4776,0.05,91.89 -50000,0.46832,0.4776,0.05,91.89 -50000,0.46832,0.4776,0.05,91.89 -50000,0.47759,0.48706,0.05,92.481 -50000,0.47759,0.48706,0.05,92.481 -50000,0.47759,0.48706,0.05,92.481 -50000,0.47759,0.48706,0.05,92.481 -50000,0.47759,0.48706,0.05,92.481 -50000,0.47759,0.48706,0.05,92.481 -50000,0.47759,0.48706,0.05,92.481 -50000,0.47759,0.48706,0.05,92.481 -50000,0.47759,0.48706,0.05,92.481 -50000,0.47759,0.48706,0.05,92.481 -50000,0.48705,0.49671,0.05,93.049 -50000,0.48705,0.49671,0.05,93.049 -50000,0.48705,0.49671,0.05,93.049 -50000,0.48705,0.49671,0.05,93.049 -50000,0.48705,0.49671,0.05,93.049 -50000,0.48705,0.49671,0.05,93.049 -50000,0.48705,0.49671,0.05,93.049 -50000,0.48705,0.49671,0.05,93.049 -50000,0.48705,0.49671,0.05,93.049 -50000,0.4967,0.50655,0.05,93.593 -50000,0.4967,0.50655,0.05,93.593 -50000,0.4967,0.50655,0.05,93.593 -50000,0.4967,0.50655,0.05,93.593 -50000,0.4967,0.50655,0.05,93.593 -50000,0.4967,0.50655,0.05,93.593 -50000,0.4967,0.50655,0.05,93.593 -50000,0.4967,0.50655,0.05,93.593 -50000,0.4967,0.50655,0.05,93.593 -50000,0.4967,0.50655,0.05,93.593 -50000,0.50654,0.51658,0.05,94.113 -50000,0.50654,0.51658,0.05,94.113 -50000,0.50654,0.51658,0.05,94.113 -50000,0.50654,0.51658,0.05,94.113 -50000,0.50654,0.51658,0.05,94.113 -50000,0.50654,0.51658,0.05,94.113 -50000,0.50654,0.51658,0.05,94.113 -50000,0.50654,0.51658,0.05,94.113 -50000,0.50654,0.51658,0.05,94.113 -50000,0.50654,0.51658,0.05,94.113 -50000,0.51657,0.52681,0.05,94.611 -50000,0.51657,0.52681,0.05,94.611 -50000,0.51657,0.52681,0.05,94.611 -50000,0.51657,0.52681,0.05,94.611 -50000,0.51657,0.52681,0.05,94.611 -50000,0.51657,0.52681,0.05,94.611 -50000,0.51657,0.52681,0.05,94.611 -50000,0.51657,0.52681,0.05,94.611 -50000,0.51657,0.52681,0.05,94.611 -50000,0.51657,0.52681,0.05,94.611 -50000,0.5268,0.53725,0.05,95.086 -50000,0.5268,0.53725,0.05,95.086 -50000,0.5268,0.53725,0.05,95.086 -50000,0.5268,0.53725,0.05,95.086 -50000,0.5268,0.53725,0.05,95.086 -50000,0.5268,0.53725,0.05,95.086 -50000,0.5268,0.53725,0.05,95.086 -50000,0.5268,0.53725,0.05,95.086 -50000,0.5268,0.53725,0.05,95.086 -50000,0.5268,0.53725,0.05,95.086 -50000,0.5268,0.53725,0.05,95.086 -50000,0.53724,0.54789,0.05,95.539 -50000,0.53724,0.54789,0.05,95.539 -50000,0.53724,0.54789,0.05,95.539 -50000,0.53724,0.54789,0.05,95.539 -50000,0.53724,0.54789,0.05,95.539 -50000,0.53724,0.54789,0.05,95.539 -50000,0.53724,0.54789,0.05,95.539 -50000,0.53724,0.54789,0.05,95.539 -50000,0.53724,0.54789,0.05,95.539 -50000,0.53724,0.54789,0.05,95.539 -50000,0.54788,0.55874,0.05,95.971 -50000,0.54788,0.55874,0.05,95.971 -50000,0.54788,0.55874,0.05,95.971 -50000,0.54788,0.55874,0.05,95.971 -50000,0.54788,0.55874,0.05,95.971 -50000,0.54788,0.55874,0.05,95.971 -50000,0.54788,0.55874,0.05,95.971 -50000,0.54788,0.55874,0.05,95.971 -50000,0.54788,0.55874,0.05,95.971 -50000,0.54788,0.55874,0.05,95.971 -50000,0.54788,0.55874,0.05,95.971 -50000,0.55873,0.56981,0.05,96.382 -50000,0.55873,0.56981,0.05,96.382 -50000,0.55873,0.56981,0.05,96.382 -50000,0.55873,0.56981,0.05,96.382 -50000,0.55873,0.56981,0.05,96.382 -50000,0.55873,0.56981,0.05,96.382 -50000,0.55873,0.56981,0.05,96.382 -50000,0.55873,0.56981,0.05,96.382 -50000,0.55873,0.56981,0.05,96.382 -50000,0.55873,0.56981,0.05,96.382 -50000,0.55873,0.56981,0.05,96.382 -50000,0.5698,0.5811,0.05,96.773 -50000,0.5698,0.5811,0.05,96.773 -50000,0.5698,0.5811,0.05,96.773 -50000,0.5698,0.5811,0.05,96.773 -50000,0.5698,0.5811,0.05,96.773 -50000,0.5698,0.5811,0.05,96.773 -50000,0.5698,0.5811,0.05,96.773 -50000,0.5698,0.5811,0.05,96.773 -50000,0.5698,0.5811,0.05,96.773 -50000,0.5698,0.5811,0.05,96.773 -50000,0.5698,0.5811,0.05,96.773 -50000,0.5698,0.5811,0.05,96.773 -50000,0.58109,0.59261,0.05,97.145 -50000,0.58109,0.59261,0.05,97.145 -50000,0.58109,0.59261,0.05,97.145 -50000,0.58109,0.59261,0.05,97.145 -50000,0.58109,0.59261,0.05,97.145 -50000,0.58109,0.59261,0.05,97.145 -50000,0.58109,0.59261,0.05,97.145 -50000,0.58109,0.59261,0.05,97.145 -50000,0.58109,0.59261,0.05,97.145 -50000,0.58109,0.59261,0.05,97.145 -50000,0.58109,0.59261,0.05,97.145 -50000,0.5926,0.60435,0.05,97.499 -50000,0.5926,0.60435,0.05,97.499 -50000,0.5926,0.60435,0.05,97.499 -50000,0.5926,0.60435,0.05,97.499 -50000,0.5926,0.60435,0.05,97.499 -50000,0.5926,0.60435,0.05,97.499 -50000,0.5926,0.60435,0.05,97.499 -50000,0.5926,0.60435,0.05,97.499 -50000,0.5926,0.60435,0.05,97.499 -50000,0.5926,0.60435,0.05,97.499 -50000,0.5926,0.60435,0.05,97.499 -50000,0.5926,0.60435,0.05,97.499 -50000,0.60434,0.61632,0.05,97.837 -50000,0.60434,0.61632,0.05,97.837 -50000,0.60434,0.61632,0.05,97.837 -50000,0.60434,0.61632,0.05,97.837 -50000,0.60434,0.61632,0.05,97.837 -50000,0.60434,0.61632,0.05,97.837 -50000,0.60434,0.61632,0.05,97.837 -50000,0.60434,0.61632,0.05,97.837 -50000,0.60434,0.61632,0.05,97.837 -50000,0.60434,0.61632,0.05,97.837 -50000,0.60434,0.61632,0.05,97.837 -50000,0.60434,0.61632,0.05,97.837 -50000,0.61631,0.62853,0.05,98.159 -50000,0.61631,0.62853,0.05,98.159 -50000,0.61631,0.62853,0.05,98.159 -50000,0.61631,0.62853,0.05,98.159 -50000,0.61631,0.62853,0.05,98.159 -50000,0.61631,0.62853,0.05,98.159 -50000,0.61631,0.62853,0.05,98.159 -50000,0.61631,0.62853,0.05,98.159 -50000,0.61631,0.62853,0.05,98.159 -50000,0.61631,0.62853,0.05,98.159 -50000,0.61631,0.62853,0.05,98.159 -50000,0.61631,0.62853,0.05,98.159 -50000,0.62852,0.64098,0.05,98.468 -50000,0.62852,0.64098,0.05,98.468 -50000,0.62852,0.64098,0.05,98.468 -50000,0.62852,0.64098,0.05,98.468 -50000,0.62852,0.64098,0.05,98.468 -50000,0.62852,0.64098,0.05,98.468 -50000,0.62852,0.64098,0.05,98.468 -50000,0.62852,0.64098,0.05,98.468 -50000,0.62852,0.64098,0.05,98.468 -50000,0.62852,0.64098,0.05,98.468 -50000,0.62852,0.64098,0.05,98.468 -50000,0.62852,0.64098,0.05,98.468 -50000,0.62852,0.64098,0.05,98.468 -50000,0.64097,0.65368,0.05,98.764 -50000,0.64097,0.65368,0.05,98.764 -50000,0.64097,0.65368,0.05,98.764 -50000,0.64097,0.65368,0.05,98.764 -50000,0.64097,0.65368,0.05,98.764 -50000,0.64097,0.65368,0.05,98.764 -50000,0.64097,0.65368,0.05,98.764 -50000,0.64097,0.65368,0.05,98.764 -50000,0.64097,0.65368,0.05,98.764 -50000,0.64097,0.65368,0.05,98.764 -50000,0.64097,0.65368,0.05,98.764 -50000,0.64097,0.65368,0.05,98.764 -50000,0.65367,0.66663,0.05,99.05 -50000,0.65367,0.66663,0.05,99.05 -50000,0.65367,0.66663,0.05,99.05 -50000,0.65367,0.66663,0.05,99.05 -50000,0.65367,0.66663,0.05,99.05 -50000,0.65367,0.66663,0.05,99.05 -50000,0.65367,0.66663,0.05,99.05 -50000,0.65367,0.66663,0.05,99.05 -50000,0.65367,0.66663,0.05,99.05 -50000,0.65367,0.66663,0.05,99.05 -50000,0.65367,0.66663,0.05,99.05 -50000,0.65367,0.66663,0.05,99.05 -50000,0.65367,0.66663,0.05,99.05 -50000,0.66662,0.67984,0.05,99.328 -50000,0.66662,0.67984,0.05,99.328 -50000,0.66662,0.67984,0.05,99.328 -50000,0.66662,0.67984,0.05,99.328 -50000,0.66662,0.67984,0.05,99.328 -50000,0.66662,0.67984,0.05,99.328 -50000,0.66662,0.67984,0.05,99.328 -50000,0.66662,0.67984,0.05,99.328 -50000,0.66662,0.67984,0.05,99.328 -50000,0.66662,0.67984,0.05,99.328 -50000,0.66662,0.67984,0.05,99.328 -50000,0.66662,0.67984,0.05,99.328 -50000,0.66662,0.67984,0.05,99.328 -50000,0.67983,0.69331,0.05,99.6 -50000,0.67983,0.69331,0.05,99.6 -50000,0.67983,0.69331,0.05,99.6 -50000,0.67983,0.69331,0.05,99.6 -50000,0.67983,0.69331,0.05,99.6 -50000,0.67983,0.69331,0.05,99.6 -50000,0.67983,0.69331,0.05,99.6 -50000,0.67983,0.69331,0.05,99.6 -50000,0.67983,0.69331,0.05,99.6 -50000,0.67983,0.69331,0.05,99.6 -50000,0.67983,0.69331,0.05,99.6 -50000,0.67983,0.69331,0.05,99.6 -50000,0.67983,0.69331,0.05,99.6 -50000,0.67983,0.69331,0.05,99.6 -50000,0.6933,0.70704,0.05,99.868 -50000,0.6933,0.70704,0.05,99.868 -50000,0.6933,0.70704,0.05,99.868 -50000,0.6933,0.70704,0.05,99.868 -50000,0.6933,0.70704,0.05,99.868 -50000,0.6933,0.70704,0.05,99.868 -50000,0.6933,0.70704,0.05,99.868 -50000,0.6933,0.70704,0.05,99.868 -50000,0.6933,0.70704,0.05,99.868 -50000,0.6933,0.70704,0.05,99.868 -50000,0.6933,0.70704,0.05,99.868 -50000,0.6933,0.70704,0.05,99.868 -50000,0.6933,0.70704,0.05,99.868 -50000,0.6933,0.70704,0.05,99.868 -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/model-results.txt b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/model-results.txt new file mode 100644 index 00000000000..3b70901645e --- /dev/null +++ b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/model-results.txt @@ -0,0 +1,465 @@ + time r temperature + 10000 0.100995 -19.0009 + 10000 0.102995 -17.0404 + 10000 0.104995 -15.1148 + 10000 0.107345 -12.8913 + 10000 0.110045 -10.3968 + 10000 0.112745 -7.95936 + 10000 0.115444 -5.57668 + 10000 0.118144 -3.24674 + 10000 0.120844 -0.96765 + 10000 0.123544 1.26237 + 10000 0.126244 3.44496 + 10000 0.128944 5.58168 + 10000 0.131644 7.67395 + 10000 0.134305 9.6936 + 10000 0.136953 11.6637 + 10000 0.139654 13.6326 + 10000 0.142408 15.5997 + 10000 0.145217 17.5646 + 10000 0.148081 19.5267 + 10000 0.151003 21.4853 + 10000 0.153982 23.44 + 10000 0.15702 25.39 + 10000 0.160119 27.3347 + 10000 0.163279 29.2733 + 10000 0.166502 31.2051 + 10000 0.169788 33.1292 + 10000 0.17314 35.0449 + 10000 0.176558 36.9512 + 10000 0.180044 38.8473 + 10000 0.183599 40.7322 + 10000 0.187225 42.605 + 10000 0.190922 44.4645 + 10000 0.194693 46.3098 + 10000 0.198539 48.1397 + 10000 0.202461 49.9531 + 10000 0.20646 51.7489 + 10000 0.210539 53.5259 + 10000 0.214699 55.2829 + 10000 0.218941 57.0186 + 10000 0.223267 58.7317 + 10000 0.22768 60.4211 + 10000 0.232179 62.0854 + 10000 0.236768 63.7233 + 10000 0.241448 65.3336 + 10000 0.24622 66.915 + 10000 0.251088 68.4661 + 10000 0.256051 69.9857 + 10000 0.261114 71.4727 + 10000 0.266276 72.9257 + 10000 0.271541 74.3436 + 10000 0.27691 75.7253 + 10000 0.282386 77.0696 + 10000 0.28797 78.3757 + 10000 0.293665 79.6425 + 10000 0.299473 80.8692 + 10000 0.305396 82.055 + 10000 0.311437 83.1992 + 10000 0.317597 84.3012 + 10000 0.32388 85.3605 + 10000 0.330287 86.3766 + 10000 0.336821 87.3495 + 10000 0.343485 88.2788 + 10000 0.35028 89.1646 + 10000 0.357211 90.007 + 10000 0.364279 90.8062 + 10000 0.371487 91.5625 + 10000 0.378838 92.2765 + 10000 0.386335 92.9488 + 10000 0.39398 93.58 + 10000 0.401777 94.1711 + 10000 0.409728 94.723 + 10000 0.417838 95.2368 + 10000 0.426108 95.7137 + 10000 0.434542 96.155 + 10000 0.443143 96.5619 + 10000 0.451915 96.9359 + 10000 0.46086 97.2786 + 10000 0.469983 97.5913 + 10000 0.479287 97.8758 + 10000 0.488776 98.1336 + 10000 0.498452 98.3664 + 10000 0.508321 98.5757 + 10000 0.518385 98.7631 + 10000 0.528649 98.9303 + 10000 0.539116 99.0787 + 10000 0.54979 99.21 + 10000 0.560677 99.3256 + 10000 0.571779 99.4269 + 10000 0.583101 99.5152 + 10000 0.594648 99.5919 + 10000 0.606424 99.6581 + 10000 0.618433 99.715 + 10000 0.63068 99.7637 + 10000 0.643171 99.8051 + 10000 0.655908 99.8401 + 10000 0.668899 99.8695 + 10000 0.682147 99.8941 + 10000 0.695657 99.9146 + 10000 0.709436 99.9315 + 10000 0.723488 99.9454 + 10000 0.737818 99.9567 + 10000 0.752433 99.9659 + 10000 0.767337 99.9734 + 10000 0.782537 99.9793 + 10000 0.798038 99.984 + 10000 0.813846 99.9877 + 10000 0.829968 99.9907 + 10000 0.84641 99.993 + 10000 0.863178 99.9947 + 10000 0.880278 99.9961 + 10000 0.897717 99.9972 + 10000 0.915502 99.998 + 10000 0.933639 99.9986 + 10000 0.952136 99.9991 + 10000 0.971 99.9995 + 10000 0.990238 99.9998 + 20000 0.100995 -19.1862 + 20000 0.102995 -17.5897 + 20000 0.104995 -16.0219 + 20000 0.107345 -14.2121 + 20000 0.110045 -12.1819 + 20000 0.112745 -10.1982 + 20000 0.115444 -8.25908 + 20000 0.118144 -6.36259 + 20000 0.120844 -4.507 + 20000 0.123544 -2.6907 + 20000 0.126244 -0.912177 + 20000 0.128944 0.829996 + 20000 0.131644 2.53715 + 20000 0.134305 4.18643 + 20000 0.136953 5.79673 + 20000 0.139654 7.40772 + 20000 0.142408 9.01922 + 20000 0.145217 10.6311 + 20000 0.148081 12.2431 + 20000 0.151003 13.855 + 20000 0.153982 15.4668 + 20000 0.15702 17.078 + 20000 0.160119 18.6885 + 20000 0.163279 20.298 + 20000 0.166502 21.9063 + 20000 0.169788 23.513 + 20000 0.17314 25.118 + 20000 0.176558 26.7207 + 20000 0.180044 28.321 + 20000 0.183599 29.9184 + 20000 0.187225 31.5126 + 20000 0.190922 33.1032 + 20000 0.194693 34.6897 + 20000 0.198539 36.2718 + 20000 0.202461 37.8489 + 20000 0.20646 39.4207 + 20000 0.210539 40.9865 + 20000 0.214699 42.546 + 20000 0.218941 44.0984 + 20000 0.223267 45.6433 + 20000 0.22768 47.18 + 20000 0.232179 48.708 + 20000 0.236768 50.2266 + 20000 0.241448 51.7352 + 20000 0.24622 53.233 + 20000 0.251088 54.7193 + 20000 0.256051 56.1934 + 20000 0.261114 57.6546 + 20000 0.266276 59.102 + 20000 0.271541 60.5349 + 20000 0.27691 61.9525 + 20000 0.282386 63.3539 + 20000 0.28797 64.7383 + 20000 0.293665 66.1048 + 20000 0.299473 67.4526 + 20000 0.305396 68.7807 + 20000 0.311437 70.0883 + 20000 0.317597 71.3745 + 20000 0.32388 72.6384 + 20000 0.330287 73.879 + 20000 0.336821 75.0956 + 20000 0.343485 76.2872 + 20000 0.35028 77.453 + 20000 0.357211 78.5922 + 20000 0.364279 79.7039 + 20000 0.371487 80.7873 + 20000 0.378838 81.8417 + 20000 0.386335 82.8665 + 20000 0.39398 83.8608 + 20000 0.401777 84.8241 + 20000 0.409728 85.7559 + 20000 0.417838 86.6555 + 20000 0.426108 87.5227 + 20000 0.434542 88.357 + 20000 0.443143 89.1581 + 20000 0.451915 89.9258 + 20000 0.46086 90.6599 + 20000 0.469983 91.3605 + 20000 0.479287 92.0276 + 20000 0.488776 92.6612 + 20000 0.498452 93.2616 + 20000 0.508321 93.8292 + 20000 0.518385 94.3643 + 20000 0.528649 94.8674 + 20000 0.539116 95.3391 + 20000 0.54979 95.7802 + 20000 0.560677 96.1913 + 20000 0.571779 96.5734 + 20000 0.583101 96.9272 + 20000 0.594648 97.254 + 20000 0.606424 97.5546 + 20000 0.618433 97.8301 + 20000 0.63068 98.0819 + 20000 0.643171 98.311 + 20000 0.655908 98.5187 + 20000 0.668899 98.7061 + 20000 0.682147 98.8747 + 20000 0.695657 99.0256 + 20000 0.709436 99.1602 + 20000 0.723488 99.2795 + 20000 0.737818 99.3849 + 20000 0.752433 99.4776 + 20000 0.767337 99.5587 + 20000 0.782537 99.6294 + 20000 0.798038 99.6905 + 20000 0.813846 99.7433 + 20000 0.829968 99.7887 + 20000 0.84641 99.8275 + 20000 0.863178 99.8606 + 20000 0.880278 99.8887 + 20000 0.897717 99.9128 + 20000 0.915502 99.9333 + 20000 0.933639 99.9511 + 20000 0.952136 99.9666 + 20000 0.971 99.9806 + 20000 0.990238 99.9937 + 50000 0.100995 -19.3549 + 50000 0.102995 -18.0894 + 50000 0.104995 -16.8471 + 50000 0.107345 -15.4133 + 50000 0.110045 -13.8052 + 50000 0.112745 -12.2343 + 50000 0.115444 -10.6988 + 50000 0.118144 -9.19722 + 50000 0.120844 -7.72807 + 50000 0.123544 -6.28997 + 50000 0.126244 -4.88167 + 50000 0.128944 -3.50195 + 50000 0.131644 -2.1497 + 50000 0.134305 -0.842944 + 50000 0.136953 0.433309 + 50000 0.139654 1.71058 + 50000 0.142408 2.98882 + 50000 0.145217 4.26799 + 50000 0.148081 5.54803 + 50000 0.151003 6.82891 + 50000 0.153982 8.11055 + 50000 0.15702 9.39291 + 50000 0.160119 10.6759 + 50000 0.163279 11.9595 + 50000 0.166502 13.2436 + 50000 0.169788 14.5281 + 50000 0.17314 15.813 + 50000 0.176558 17.0982 + 50000 0.180044 18.3835 + 50000 0.183599 19.6689 + 50000 0.187225 20.9543 + 50000 0.190922 22.2396 + 50000 0.194693 23.5246 + 50000 0.198539 24.8092 + 50000 0.202461 26.0934 + 50000 0.20646 27.377 + 50000 0.210539 28.6597 + 50000 0.214699 29.9416 + 50000 0.218941 31.2224 + 50000 0.223267 32.5019 + 50000 0.22768 33.78 + 50000 0.232179 35.0566 + 50000 0.236768 36.3313 + 50000 0.241448 37.604 + 50000 0.24622 38.8745 + 50000 0.251088 40.1426 + 50000 0.256051 41.408 + 50000 0.261114 42.6704 + 50000 0.266276 43.9297 + 50000 0.271541 45.1855 + 50000 0.27691 46.4376 + 50000 0.282386 47.6857 + 50000 0.28797 48.9294 + 50000 0.293665 50.1684 + 50000 0.299473 51.4024 + 50000 0.305396 52.6311 + 50000 0.311437 53.8541 + 50000 0.317597 55.0709 + 50000 0.32388 56.2813 + 50000 0.330287 57.4848 + 50000 0.336821 58.6809 + 50000 0.343485 59.8693 + 50000 0.35028 61.0495 + 50000 0.357211 62.221 + 50000 0.364279 63.3834 + 50000 0.371487 64.5361 + 50000 0.378838 65.6787 + 50000 0.386335 66.8106 + 50000 0.39398 67.9313 + 50000 0.401777 69.0402 + 50000 0.409728 70.1369 + 50000 0.417838 71.2207 + 50000 0.426108 72.291 + 50000 0.434542 73.3474 + 50000 0.443143 74.3892 + 50000 0.451915 75.4157 + 50000 0.46086 76.4265 + 50000 0.469983 77.4209 + 50000 0.479287 78.3984 + 50000 0.488776 79.3583 + 50000 0.498452 80.3001 + 50000 0.508321 81.2232 + 50000 0.518385 82.127 + 50000 0.528649 83.011 + 50000 0.539116 83.8747 + 50000 0.54979 84.7176 + 50000 0.560677 85.5391 + 50000 0.571779 86.3389 + 50000 0.583101 87.1164 + 50000 0.594648 87.8714 + 50000 0.606424 88.6035 + 50000 0.618433 89.3124 + 50000 0.63068 89.9978 + 50000 0.643171 90.6596 + 50000 0.655908 91.2977 + 50000 0.668899 91.9119 + 50000 0.682147 92.5022 + 50000 0.695657 93.0688 + 50000 0.709436 93.6119 + 50000 0.723488 94.1315 + 50000 0.737818 94.6282 + 50000 0.752433 95.1022 + 50000 0.767337 95.5542 + 50000 0.782537 95.9846 + 50000 0.798038 96.3944 + 50000 0.813846 96.7843 + 50000 0.829968 97.1553 + 50000 0.84641 97.5084 + 50000 0.863178 97.8449 + 50000 0.880278 98.1662 + 50000 0.897717 98.4737 + 50000 0.915502 98.7691 + 50000 0.933639 99.0543 + 50000 0.952136 99.3311 + 50000 0.971 99.6017 + 50000 0.990238 99.8685 + 100000 0.100995 -19.444 + 100000 0.102995 -18.3532 + 100000 0.104995 -17.2826 + 100000 0.107345 -16.0471 + 100000 0.110045 -14.6616 + 100000 0.112745 -13.3083 + 100000 0.115444 -11.9857 + 100000 0.118144 -10.6924 + 100000 0.120844 -9.42708 + 100000 0.123544 -8.18863 + 100000 0.126244 -6.97588 + 100000 0.128944 -5.78778 + 100000 0.131644 -4.62334 + 100000 0.134305 -3.49806 + 100000 0.136953 -2.39902 + 100000 0.139654 -1.29905 + 100000 0.142408 -0.198159 + 100000 0.145217 0.903626 + 100000 0.148081 2.00629 + 100000 0.151003 3.10982 + 100000 0.153982 4.2142 + 100000 0.15702 5.3194 + 100000 0.160119 6.42541 + 100000 0.163279 7.53219 + 100000 0.166502 8.63974 + 100000 0.169788 9.74801 + 100000 0.17314 10.857 + 100000 0.176558 11.9666 + 100000 0.180044 13.0769 + 100000 0.183599 14.1878 + 100000 0.187225 15.2993 + 100000 0.190922 16.4113 + 100000 0.194693 17.5239 + 100000 0.198539 18.6369 + 100000 0.202461 19.7503 + 100000 0.20646 20.864 + 100000 0.210539 21.9781 + 100000 0.214699 23.0925 + 100000 0.218941 24.2071 + 100000 0.223267 25.3218 + 100000 0.22768 26.4366 + 100000 0.232179 27.5515 + 100000 0.236768 28.6663 + 100000 0.241448 29.7811 + 100000 0.24622 30.8956 + 100000 0.251088 32.0099 + 100000 0.256051 33.1239 + 100000 0.261114 34.2374 + 100000 0.266276 35.3504 + 100000 0.271541 36.4628 + 100000 0.27691 37.5745 + 100000 0.282386 38.6853 + 100000 0.28797 39.7952 + 100000 0.293665 40.9041 + 100000 0.299473 42.0118 + 100000 0.305396 43.1182 + 100000 0.311437 44.2232 + 100000 0.317597 45.3266 + 100000 0.32388 46.4283 + 100000 0.330287 47.5281 + 100000 0.336821 48.6258 + 100000 0.343485 49.7214 + 100000 0.35028 50.8147 + 100000 0.357211 51.9053 + 100000 0.364279 52.9933 + 100000 0.371487 54.0783 + 100000 0.378838 55.1602 + 100000 0.386335 56.2388 + 100000 0.39398 57.3138 + 100000 0.401777 58.3851 + 100000 0.409728 59.4524 + 100000 0.417838 60.5154 + 100000 0.426108 61.574 + 100000 0.434542 62.6279 + 100000 0.443143 63.6768 + 100000 0.451915 64.7204 + 100000 0.46086 65.7586 + 100000 0.469983 66.7909 + 100000 0.479287 67.8172 + 100000 0.488776 68.8372 + 100000 0.498452 69.8506 + 100000 0.508321 70.8571 + 100000 0.518385 71.8563 + 100000 0.528649 72.8481 + 100000 0.539116 73.8321 + 100000 0.54979 74.808 + 100000 0.560677 75.7756 + 100000 0.571779 76.7346 + 100000 0.583101 77.6847 + 100000 0.594648 78.6256 + 100000 0.606424 79.5571 + 100000 0.618433 80.479 + 100000 0.63068 81.3909 + 100000 0.643171 82.2928 + 100000 0.655908 83.1845 + 100000 0.668899 84.0657 + 100000 0.682147 84.9363 + 100000 0.695657 85.7963 + 100000 0.709436 86.6456 + 100000 0.723488 87.4841 + 100000 0.737818 88.3119 + 100000 0.752433 89.1291 + 100000 0.767337 89.9357 + 100000 0.782537 90.7319 + 100000 0.798038 91.518 + 100000 0.813846 92.2944 + 100000 0.829968 93.0612 + 100000 0.84641 93.8192 + 100000 0.863178 94.5687 + 100000 0.880278 95.3105 + 100000 0.897717 96.0452 + 100000 0.915502 96.7737 + 100000 0.933639 97.497 + 100000 0.952136 98.2161 + 100000 0.971 98.9322 + 100000 0.990238 99.6466 diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/temperatureDependentSinglePhaseThermalConductivity_plot.py b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/temperatureDependentSinglePhaseThermalConductivity_plot.py deleted file mode 100644 index 74dc2483e90..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/temperatureDependentSinglePhaseThermalConductivity_plot.py +++ /dev/null @@ -1,218 +0,0 @@ -import os -import sys -import os -import argparse - -import numpy as np -import matplotlib.pyplot as plt -import pandas as pd -import scipy.linalg -from scipy import special - -from scipy.sparse import diags -from scipy.sparse.linalg import spsolve - -from xml.etree import ElementTree - -# Analytical results for linear thermal behavior -def steadyState(Tin, Tout, Rin, Rout, radialCoordinate): - return Tin + (Tout - Tin) * (np.log(radialCoordinate) - np.log(Rin)) / (np.log(Rout) - np.log(Rin)) - -def diffusionFunction(radialCoordinate, Rin, diffusionCoefficient, diffusionTime): - return special.erfc( (radialCoordinate - Rin) / 2.0 / np.sqrt( diffusionCoefficient * diffusionTime ) ) - -def computeTransientTemperature(Tin, Tout, Rin, radialCoordinate, thermalDiffusionCoefficient, diffusionTime): - # Ref. Wang and Papamichos (1994), https://agupubs.onlinelibrary.wiley.com/doi/abs/10.1029/94WR01774 - return Tout + (Tin-Tout) * np.sqrt(Rin/radialCoordinate) * diffusionFunction(radialCoordinate, Rin, thermalDiffusionCoefficient, diffusionTime) - -def computeThermalDiffusionCoefficient(thermalConductivity, volumetricHeatCapacity): - return thermalConductivity / volumetricHeatCapacity - -# Finite difference results for non-linear thermal behavior -def temperatureDependentThermalConductivity(lambda0, lambda_gradient, T, Treference): - return lambda0 + lambda_gradient*(T-Treference) - -def temperatureDependentVolumetricHeat(c0, c_gradient, T, Treference): - return c0 + c_gradient*(T-Treference) - -def coefficientMatrix(thermalConductivity, volumetricHeatCapacity, r, dt, N): - # Coefficients for the matrix - A = np.zeros((N+1, N+1)) - - for i in range(1,N): - dr = r[i] - r[i-1] - r_i = r[i] - - diffusivity_i = thermalConductivity[i]/volumetricHeatCapacity[i] - A[i, i-1] = - diffusivity_i * (dt/(dr**2) - dt/(2 * r_i * dr)) \ - + (thermalConductivity[i+1] - thermalConductivity[i-1])/volumetricHeatCapacity[i]*dt/4/(dr**2) - A[i, i] = 1.0 + 2.0 * diffusivity_i * dt / (dr**2) - A[i, i+1] = - diffusivity_i * (dt/(dr**2) + dt/(2 * r_i * dr)) \ - - (thermalConductivity[i+1] - thermalConductivity[i-1])/volumetricHeatCapacity[i]*dt/4/(dr**2) - - # Boundary conditions - # No-flux at r=0 approximated by setting the flux between the first two cells to zero - A[0, 0] = 1.0 - A[N, N] = 1.0 - return A - -def solve_radial_diffusion(r, tmax, dt, Tin, Tout, lambda0, lambda_gradient, c0, c_gradient, Treference): - N = len(r)-1 - # Time setup - n_steps = int(tmax / dt) - - # Time-stepping - T = np.zeros(N+1) + Tout # initial condition u(r, 0) - T[0] = Tin - for step in range(n_steps): - thermalConductivity = temperatureDependentThermalConductivity(lambda0, lambda_gradient, T, Treference) - - volumetricHeatCapacity = temperatureDependentVolumetricHeat(c0, c_gradient, T, Treference) - - A = coefficientMatrix(thermalConductivity, volumetricHeatCapacity, r, dt, N) - T = spsolve(A, T) - - return T - - -def extractDataFromXMLList(paramList): - # Extract data from a list in XML such as "{ 1, 2, 3}" - return paramList.replace('{', '').replace('}', '').strip().split(',') - -def getWellboreGeometryFromXML(xmlFilePath): - tree = ElementTree.parse(xmlFilePath) - - meshParam = tree.find('Mesh/InternalWellbore') - radii = extractDataFromXMLList( meshParam.get("radius") ) - - Rin = float(radii[0]) - Rout = float(radii[-1]) - - return [Rin, Rout] - -def getLoadingFromXML(xmlFilePath): - tree = ElementTree.parse(xmlFilePath) - fsParams = tree.findall('FieldSpecifications/FieldSpecification') - - for fsParam in fsParams: - if ( (fsParam.get('fieldName') == "pressure") & (fsParam.get('initialCondition') != "1") ): - if fsParam.get('setNames') == "{ rneg }": - Pin = float(fsParam.get('scale')) - if fsParam.get('setNames') == "{ rpos }": - Pout = float(fsParam.get('scale')) - - for fsParam in fsParams: - if ( (fsParam.get('fieldName') == "temperature") & (fsParam.get('initialCondition') != "1") ): - if fsParam.get('setNames') == "{ rneg }": - Tin = float(fsParam.get('scale')) - if fsParam.get('setNames') == "{ rpos }": - Tout = float(fsParam.get('scale')) - - - tree_SinglePhaseThermalConductivities = tree.findall('Constitutive/SinglePhaseThermalConductivity') - - for tree_SinglePhaseThermalConductivity in tree_SinglePhaseThermalConductivities: - if tree_SinglePhaseThermalConductivity.get('name') == "thermalCond_nonLinear": - defaultThermalConductivity = float( extractDataFromXMLList( tree_SinglePhaseThermalConductivity.get('defaultThermalConductivityComponents') )[0] ) - - thermalConductivityGradient = float( extractDataFromXMLList( tree_SinglePhaseThermalConductivity.get('thermalConductivityGradientComponents') )[0] ) - referenceTemperature = float( tree_SinglePhaseThermalConductivity.get('referenceTemperature') ) - - - tree_SolidInternalEnergies = tree.findall('Constitutive/SolidInternalEnergy') - - for tree_SolidInternalEnergy in tree_SolidInternalEnergies: - if tree_SolidInternalEnergy.get('name') == "rockInternalEnergy_linear": - volumetricHeatCapacity = float( tree_SolidInternalEnergy.get('referenceVolumetricHeatCapacity') ) - dVolumetricHeatCapacity_dTemperature = 0.0 - - - permeability = float( extractDataFromXMLList( tree.find('Constitutive/ConstantPermeability').get('permeabilityComponents') )[0] ) - - porosity = float( tree.find('Constitutive/PressurePorosity').get('defaultReferencePorosity') ) - - fluidViscosity = float( tree.find('Constitutive/ThermalCompressibleSinglePhaseFluid').get('defaultViscosity') ) - - fluidCompressibility = float( tree.find('Constitutive/ThermalCompressibleSinglePhaseFluid').get('compressibility') ) - - fluidThermalExpansionCoefficient = float( tree.find('Constitutive/ThermalCompressibleSinglePhaseFluid').get('thermalExpansionCoeff') ) - - return [Pin, Pout, Tin, Tout, defaultThermalConductivity, thermalConductivityGradient, referenceTemperature, volumetricHeatCapacity, dVolumetricHeatCapacity_dTemperature, permeability, porosity, fluidViscosity, fluidCompressibility, fluidThermalExpansionCoefficient] - - -def main(): - - # Initialize the argument parser - parser = argparse.ArgumentParser(description="Script to generate figure from tutorial.") - - # Add arguments to accept individual file paths - parser.add_argument('--geosDir', help='Path to the GEOS repository ', default='../../../../../../..') - - # Parse the command-line arguments - args = parser.parse_args() - - geosDir = args.geosDir - - xmlFilePath = geosDir + "/inputFiles/singlePhaseFlow/" - - Rin, Rout = getWellboreGeometryFromXML(xmlFilePath+"thermalCompressible_temperatureDependentSinglePhaseThermalConductivity_benchmark.xml") - - Pin, Pout, Tin, Tout, defaultThermalConductivity, thermalConductivityGradient, referenceTemperature, volumetricHeatCapacity, dVolumetricHeatCapacity_dTemperature, permeability, porosity, fluidViscosity, fluidCompressibility, fluidThermalExpansionCoefficient = getLoadingFromXML(xmlFilePath+"thermalCompressible_2d_base.xml") - - plt.figure(figsize=(10,7)) - font = {'size' : 16} - plt.rc('font', **font) - - for chart_idx, idx in enumerate([1, 2, 5, 10]): - # Numerical results - data = pd.read_csv(f'data_{idx}.csv') - data.dropna(inplace=True) - data.drop_duplicates(inplace=True) - data.reset_index(drop=True, inplace=True) - - radialCoordinate = (data['elementCenter:0']**2.0 + data['elementCenter:1']**2.0)**0.5 - temperature = data['temperature'] - #pressure = data['pressure'] - diffusionTime = data['Time'][0] - - # Analytical results for linear thermal behavior, for comparison - radialCoordinate_anal = np.arange(Rin, Rout, (Rout-Rin)/100) - - thermalDiffusionCoefficient = computeThermalDiffusionCoefficient(defaultThermalConductivity, volumetricHeatCapacity) - - T_transient_linear = computeTransientTemperature(Tin, Tout, Rin, radialCoordinate_anal, thermalDiffusionCoefficient, diffusionTime) - - # Analytical results of the steady state regime for comparison - T_steadyState = steadyState(Tin, Tout, Rin, Rout, radialCoordinate_anal) - - # Finite different results for non-linear thermal behavior - - T_transient_nonLinear = solve_radial_diffusion(radialCoordinate_anal, diffusionTime, diffusionTime/1000, Tin, Tout, defaultThermalConductivity, thermalConductivityGradient, volumetricHeatCapacity, dVolumetricHeatCapacity_dTemperature, referenceTemperature) - - # Visualization - # Temperature - plt.subplot(2,2,chart_idx+1) - plt.plot( radialCoordinate, temperature, 'k+' , label='GEOS' ) - plt.plot( radialCoordinate_anal, T_transient_nonLinear, 'g.' , label='FDM Non-Linear' ) - plt.plot( radialCoordinate_anal, T_transient_linear, 'r-' , label='Analytic Linear' ) - plt.plot( radialCoordinate_anal, T_steadyState, 'b-' , label='Steady State' ) - - if chart_idx==1: - plt.legend() - - if chart_idx in [2,3]: - plt.xlabel('Radial distance from well center') - - if chart_idx in [0,2]: - plt.ylabel('Temperature (°C)') - - plt.ylim(Tin-10,Tout+10) - plt.xlim(0.1,0.3) - plt.title('t = '+str(diffusionTime)+'(s)') - plt.tight_layout() - - plt.show() - -if __name__ == "__main__": - main() - diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/thermalConductivityFigure.py b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/thermalConductivityFigure.py new file mode 100644 index 00000000000..5f6644615e7 --- /dev/null +++ b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/thermalConductivityFigure.py @@ -0,0 +1,8 @@ +import os +try: + _this_dir = os.path.dirname(os.path.abspath(__file__)) +except NameError: + _this_dir = os.getcwd() + +import wellboreTemperatureFigure +wellboreTemperatureFigure.main(xmlFilePrefix='thermalCompressible_temperatureDependentSinglePhaseThermalConductivity', outputDir=_this_dir) diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/thermalConductivityQueries.py b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/thermalConductivityQueries.py new file mode 100644 index 00000000000..47499e593be --- /dev/null +++ b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentSinglePhaseThermalConductivity/thermalConductivityQueries.py @@ -0,0 +1,6 @@ +import sys + +sys.path.append('../../../../../../../inputFiles/singlePhaseFlow/scripts') +import wellboreTemperatureQueries + +wellboreTemperatureQueries.main() diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/Example.rst b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/Example.rst index 959302bd7a2..56af18ded94 100644 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/Example.rst +++ b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/Example.rst @@ -49,7 +49,7 @@ Results and benchmark A good agreement between the results obtained using GEOS and the reference results that are obtained by the classical finite difference method is shown in the figure below: -.. plot:: docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/temperatureDependentVolumetricHeatCapacity_plot.py +.. plot:: docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/volumetricHeatCapacityFigure.py ------------------------------------------------------------------ diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_1.csv b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_1.csv deleted file mode 100644 index 92fbae1a86a..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_1.csv +++ /dev/null @@ -1,1002 +0,0 @@ -Time,"elementCenter:0","elementCenter:1","elementCenter:2","temperature" -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,0.07071,0.072112,0.05,-13.76 -10000,0.07071,0.072112,0.05,-13.76 -10000,0.07211,0.07354,0.05,-1.5083 -10000,0.07351,0.074968,0.05,10.502 -10000,0.075155,0.076646,0.05,24.239 -10000,0.075155,0.076646,0.05,24.239 -10000,0.077046,0.078574,0.05,39.135 -10000,0.077046,0.078574,0.05,39.135 -10000,0.078936,0.080501,0.05,52.698 -10000,0.078936,0.080501,0.05,52.698 -10000,0.080826,0.082429,0.05,64.497 -10000,0.080826,0.082429,0.05,64.497 -10000,0.082716,0.084357,0.05,74.262 -10000,0.082716,0.084357,0.05,74.262 -10000,0.084607,0.086285,0.05,81.944 -10000,0.084607,0.086285,0.05,81.944 -10000,0.086497,0.088212,0.05,87.71 -10000,0.086497,0.088212,0.05,87.71 -10000,0.088387,0.09014,0.05,91.858 -10000,0.088387,0.09014,0.05,91.858 -10000,0.090278,0.092068,0.05,94.735 -10000,0.090278,0.092068,0.05,94.735 -10000,0.092168,0.093995,0.05,96.667 -10000,0.092168,0.093995,0.05,96.667 -10000,0.094031,0.095896,0.05,97.913 -10000,0.095885,0.097786,0.05,98.714 -10000,0.095885,0.097786,0.05,98.714 -10000,0.097776,0.099715,0.05,99.227 -10000,0.097776,0.099715,0.05,99.227 -10000,0.099704,0.10168,0.05,99.547 -10000,0.099704,0.10168,0.05,99.547 -10000,0.10167,0.10369,0.05,99.741 -10000,0.10167,0.10369,0.05,99.741 -10000,0.10368,0.10573,0.05,99.855 -10000,0.10368,0.10573,0.05,99.855 -10000,0.10572,0.10782,0.05,99.921 -10000,0.10572,0.10782,0.05,99.921 -10000,0.10781,0.10995,0.05,99.958 -10000,0.10781,0.10995,0.05,99.958 -10000,0.10993,0.11211,0.05,99.978 -10000,0.10993,0.11211,0.05,99.978 -10000,0.10993,0.11211,0.05,99.978 -10000,0.1121,0.11433,0.05,99.989 -10000,0.1121,0.11433,0.05,99.989 -10000,0.11432,0.11658,0.05,99.995 -10000,0.11432,0.11658,0.05,99.995 -10000,0.11657,0.11888,0.05,99.997 -10000,0.11657,0.11888,0.05,99.997 -10000,0.11887,0.12123,0.05,99.999 -10000,0.11887,0.12123,0.05,99.999 -10000,0.11887,0.12123,0.05,99.999 -10000,0.12122,0.12362,0.05,99.999 -10000,0.12122,0.12362,0.05,99.999 -10000,0.12361,0.12607,0.05,100 -10000,0.12361,0.12607,0.05,100 -10000,0.12361,0.12607,0.05,100 -10000,0.12605,0.12855,0.05,100 -10000,0.12605,0.12855,0.05,100 -10000,0.12854,0.13109,0.05,100 -10000,0.12854,0.13109,0.05,100 -10000,0.12854,0.13109,0.05,100 -10000,0.13108,0.13368,0.05,100 -10000,0.13108,0.13368,0.05,100 -10000,0.13367,0.13632,0.05,100 -10000,0.13367,0.13632,0.05,100 -10000,0.13367,0.13632,0.05,100 -10000,0.13631,0.13901,0.05,100 -10000,0.13631,0.13901,0.05,100 -10000,0.13631,0.13901,0.05,100 -10000,0.139,0.14176,0.05,100 -10000,0.139,0.14176,0.05,100 -10000,0.14175,0.14456,0.05,100 -10000,0.14175,0.14456,0.05,100 -10000,0.14175,0.14456,0.05,100 -10000,0.14455,0.14742,0.05,100 -10000,0.14455,0.14742,0.05,100 -10000,0.14455,0.14742,0.05,100 -10000,0.1474,0.15033,0.05,100 -10000,0.1474,0.15033,0.05,100 -10000,0.1474,0.15033,0.05,100 -10000,0.15032,0.1533,0.05,100 -10000,0.15032,0.1533,0.05,100 -10000,0.15032,0.1533,0.05,100 -10000,0.15329,0.15633,0.05,100 -10000,0.15329,0.15633,0.05,100 -10000,0.15329,0.15633,0.05,100 -10000,0.15632,0.15942,0.05,100 -10000,0.15632,0.15942,0.05,100 -10000,0.15632,0.15942,0.05,100 -10000,0.15941,0.16257,0.05,100 -10000,0.15941,0.16257,0.05,100 -10000,0.15941,0.16257,0.05,100 -10000,0.16256,0.16578,0.05,100 -10000,0.16256,0.16578,0.05,100 -10000,0.16256,0.16578,0.05,100 -10000,0.16577,0.16906,0.05,100 -10000,0.16577,0.16906,0.05,100 -10000,0.16577,0.16906,0.05,100 -10000,0.16577,0.16906,0.05,100 -10000,0.16905,0.1724,0.05,100 -10000,0.16905,0.1724,0.05,100 -10000,0.16905,0.1724,0.05,100 -10000,0.17239,0.1758,0.05,100 -10000,0.17239,0.1758,0.05,100 -10000,0.17239,0.1758,0.05,100 -10000,0.17579,0.17928,0.05,100 -10000,0.17579,0.17928,0.05,100 -10000,0.17579,0.17928,0.05,100 -10000,0.17579,0.17928,0.05,100 -10000,0.17927,0.18282,0.05,100 -10000,0.17927,0.18282,0.05,100 -10000,0.17927,0.18282,0.05,100 -10000,0.18281,0.18644,0.05,100 -10000,0.18281,0.18644,0.05,100 -10000,0.18281,0.18644,0.05,100 -10000,0.18281,0.18644,0.05,100 -10000,0.18643,0.19013,0.05,100 -10000,0.18643,0.19013,0.05,100 -10000,0.18643,0.19013,0.05,100 -10000,0.18643,0.19013,0.05,100 -10000,0.19011,0.19388,0.05,100 -10000,0.19011,0.19388,0.05,100 -10000,0.19011,0.19388,0.05,100 -10000,0.19387,0.19772,0.05,100 -10000,0.19387,0.19772,0.05,100 -10000,0.19387,0.19772,0.05,100 -10000,0.19387,0.19772,0.05,100 -10000,0.19771,0.20163,0.05,100 -10000,0.19771,0.20163,0.05,100 -10000,0.19771,0.20163,0.05,100 -10000,0.19771,0.20163,0.05,100 -10000,0.20162,0.20562,0.05,100 -10000,0.20162,0.20562,0.05,100 -10000,0.20162,0.20562,0.05,100 -10000,0.20162,0.20562,0.05,100 -10000,0.2056,0.20968,0.05,100 -10000,0.2056,0.20968,0.05,100 -10000,0.2056,0.20968,0.05,100 -10000,0.2056,0.20968,0.05,100 -10000,0.20967,0.21383,0.05,100 -10000,0.20967,0.21383,0.05,100 -10000,0.20967,0.21383,0.05,100 -10000,0.20967,0.21383,0.05,100 -10000,0.21382,0.21806,0.05,100 -10000,0.21382,0.21806,0.05,100 -10000,0.21382,0.21806,0.05,100 -10000,0.21382,0.21806,0.05,100 -10000,0.21382,0.21806,0.05,100 -10000,0.21805,0.22237,0.05,100 -10000,0.21805,0.22237,0.05,100 -10000,0.21805,0.22237,0.05,100 -10000,0.21805,0.22237,0.05,100 -10000,0.22236,0.22677,0.05,100 -10000,0.22236,0.22677,0.05,100 -10000,0.22236,0.22677,0.05,100 -10000,0.22236,0.22677,0.05,100 -10000,0.22676,0.23125,0.05,100 -10000,0.22676,0.23125,0.05,100 -10000,0.22676,0.23125,0.05,100 -10000,0.22676,0.23125,0.05,100 -10000,0.22676,0.23125,0.05,100 -10000,0.23124,0.23583,0.05,100 -10000,0.23124,0.23583,0.05,100 -10000,0.23124,0.23583,0.05,100 -10000,0.23124,0.23583,0.05,100 -10000,0.23582,0.2405,0.05,100 -10000,0.23582,0.2405,0.05,100 -10000,0.23582,0.2405,0.05,100 -10000,0.23582,0.2405,0.05,100 -10000,0.23582,0.2405,0.05,100 -10000,0.24048,0.24525,0.05,100 -10000,0.24048,0.24525,0.05,100 -10000,0.24048,0.24525,0.05,100 -10000,0.24048,0.24525,0.05,100 -10000,0.24048,0.24525,0.05,100 -10000,0.24524,0.25011,0.05,100 -10000,0.24524,0.25011,0.05,100 -10000,0.24524,0.25011,0.05,100 -10000,0.24524,0.25011,0.05,100 -10000,0.24524,0.25011,0.05,100 -10000,0.25009,0.25505,0.05,100 -10000,0.25009,0.25505,0.05,100 -10000,0.25009,0.25505,0.05,100 -10000,0.25009,0.25505,0.05,100 -10000,0.25009,0.25505,0.05,100 -10000,0.25504,0.2601,0.05,100 -10000,0.25504,0.2601,0.05,100 -10000,0.25504,0.2601,0.05,100 -10000,0.25504,0.2601,0.05,100 -10000,0.25504,0.2601,0.05,100 -10000,0.26009,0.26525,0.05,100 -10000,0.26009,0.26525,0.05,100 -10000,0.26009,0.26525,0.05,100 -10000,0.26009,0.26525,0.05,100 -10000,0.26009,0.26525,0.05,100 -10000,0.26524,0.2705,0.05,100 -10000,0.26524,0.2705,0.05,100 -10000,0.26524,0.2705,0.05,100 -10000,0.26524,0.2705,0.05,100 -10000,0.26524,0.2705,0.05,100 -10000,0.27048,0.27585,0.05,100 -10000,0.27048,0.27585,0.05,100 -10000,0.27048,0.27585,0.05,100 -10000,0.27048,0.27585,0.05,100 -10000,0.27048,0.27585,0.05,100 -10000,0.27584,0.28131,0.05,100 -10000,0.27584,0.28131,0.05,100 -10000,0.27584,0.28131,0.05,100 -10000,0.27584,0.28131,0.05,100 -10000,0.27584,0.28131,0.05,100 -10000,0.27584,0.28131,0.05,100 -10000,0.2813,0.28687,0.05,100 -10000,0.2813,0.28687,0.05,100 -10000,0.2813,0.28687,0.05,100 -10000,0.2813,0.28687,0.05,100 -10000,0.2813,0.28687,0.05,100 -10000,0.28686,0.29255,0.05,100 -10000,0.28686,0.29255,0.05,100 -10000,0.28686,0.29255,0.05,100 -10000,0.28686,0.29255,0.05,100 -10000,0.28686,0.29255,0.05,100 -10000,0.28686,0.29255,0.05,100 -10000,0.29254,0.29834,0.05,100 -10000,0.29254,0.29834,0.05,100 -10000,0.29254,0.29834,0.05,100 -10000,0.29254,0.29834,0.05,100 -10000,0.29254,0.29834,0.05,100 -10000,0.29254,0.29834,0.05,100 -10000,0.29833,0.30425,0.05,100 -10000,0.29833,0.30425,0.05,100 -10000,0.29833,0.30425,0.05,100 -10000,0.29833,0.30425,0.05,100 -10000,0.29833,0.30425,0.05,100 -10000,0.29833,0.30425,0.05,100 -10000,0.30424,0.31027,0.05,100 -10000,0.30424,0.31027,0.05,100 -10000,0.30424,0.31027,0.05,100 -10000,0.30424,0.31027,0.05,100 -10000,0.30424,0.31027,0.05,100 -10000,0.30424,0.31027,0.05,100 -10000,0.31026,0.31641,0.05,100 -10000,0.31026,0.31641,0.05,100 -10000,0.31026,0.31641,0.05,100 -10000,0.31026,0.31641,0.05,100 -10000,0.31026,0.31641,0.05,100 -10000,0.31026,0.31641,0.05,100 -10000,0.3164,0.32267,0.05,100 -10000,0.3164,0.32267,0.05,100 -10000,0.3164,0.32267,0.05,100 -10000,0.3164,0.32267,0.05,100 -10000,0.3164,0.32267,0.05,100 -10000,0.3164,0.32267,0.05,100 -10000,0.32266,0.32906,0.05,100 -10000,0.32266,0.32906,0.05,100 -10000,0.32266,0.32906,0.05,100 -10000,0.32266,0.32906,0.05,100 -10000,0.32266,0.32906,0.05,100 -10000,0.32266,0.32906,0.05,100 -10000,0.32266,0.32906,0.05,100 -10000,0.32905,0.33558,0.05,100 -10000,0.32905,0.33558,0.05,100 -10000,0.32905,0.33558,0.05,100 -10000,0.32905,0.33558,0.05,100 -10000,0.32905,0.33558,0.05,100 -10000,0.32905,0.33558,0.05,100 -10000,0.33556,0.34222,0.05,100 -10000,0.33556,0.34222,0.05,100 -10000,0.33556,0.34222,0.05,100 -10000,0.33556,0.34222,0.05,100 -10000,0.33556,0.34222,0.05,100 -10000,0.33556,0.34222,0.05,100 -10000,0.33556,0.34222,0.05,100 -10000,0.34221,0.34899,0.05,100 -10000,0.34221,0.34899,0.05,100 -10000,0.34221,0.34899,0.05,100 -10000,0.34221,0.34899,0.05,100 -10000,0.34221,0.34899,0.05,100 -10000,0.34221,0.34899,0.05,100 -10000,0.34221,0.34899,0.05,100 -10000,0.34898,0.3559,0.05,100 -10000,0.34898,0.3559,0.05,100 -10000,0.34898,0.3559,0.05,100 -10000,0.34898,0.3559,0.05,100 -10000,0.34898,0.3559,0.05,100 -10000,0.34898,0.3559,0.05,100 -10000,0.35589,0.36295,0.05,100 -10000,0.35589,0.36295,0.05,100 -10000,0.35589,0.36295,0.05,100 -10000,0.35589,0.36295,0.05,100 -10000,0.35589,0.36295,0.05,100 -10000,0.35589,0.36295,0.05,100 -10000,0.35589,0.36295,0.05,100 -10000,0.36294,0.37013,0.05,100 -10000,0.36294,0.37013,0.05,100 -10000,0.36294,0.37013,0.05,100 -10000,0.36294,0.37013,0.05,100 -10000,0.36294,0.37013,0.05,100 -10000,0.36294,0.37013,0.05,100 -10000,0.36294,0.37013,0.05,100 -10000,0.36294,0.37013,0.05,100 -10000,0.37012,0.37746,0.05,100 -10000,0.37012,0.37746,0.05,100 -10000,0.37012,0.37746,0.05,100 -10000,0.37012,0.37746,0.05,100 -10000,0.37012,0.37746,0.05,100 -10000,0.37012,0.37746,0.05,100 -10000,0.37012,0.37746,0.05,100 -10000,0.37745,0.38494,0.05,100 -10000,0.37745,0.38494,0.05,100 -10000,0.37745,0.38494,0.05,100 -10000,0.37745,0.38494,0.05,100 -10000,0.37745,0.38494,0.05,100 -10000,0.37745,0.38494,0.05,100 -10000,0.37745,0.38494,0.05,100 -10000,0.38493,0.39256,0.05,100 -10000,0.38493,0.39256,0.05,100 -10000,0.38493,0.39256,0.05,100 -10000,0.38493,0.39256,0.05,100 -10000,0.38493,0.39256,0.05,100 -10000,0.38493,0.39256,0.05,100 -10000,0.38493,0.39256,0.05,100 -10000,0.38493,0.39256,0.05,100 -10000,0.39255,0.40033,0.05,100 -10000,0.39255,0.40033,0.05,100 -10000,0.39255,0.40033,0.05,100 -10000,0.39255,0.40033,0.05,100 -10000,0.39255,0.40033,0.05,100 -10000,0.39255,0.40033,0.05,100 -10000,0.39255,0.40033,0.05,100 -10000,0.39255,0.40033,0.05,100 -10000,0.40032,0.40826,0.05,100 -10000,0.40032,0.40826,0.05,100 -10000,0.40032,0.40826,0.05,100 -10000,0.40032,0.40826,0.05,100 -10000,0.40032,0.40826,0.05,100 -10000,0.40032,0.40826,0.05,100 -10000,0.40032,0.40826,0.05,100 -10000,0.40032,0.40826,0.05,100 -10000,0.40825,0.41634,0.05,100 -10000,0.40825,0.41634,0.05,100 -10000,0.40825,0.41634,0.05,100 -10000,0.40825,0.41634,0.05,100 -10000,0.40825,0.41634,0.05,100 -10000,0.40825,0.41634,0.05,100 -10000,0.40825,0.41634,0.05,100 -10000,0.40825,0.41634,0.05,100 -10000,0.41633,0.42459,0.05,100 -10000,0.41633,0.42459,0.05,100 -10000,0.41633,0.42459,0.05,100 -10000,0.41633,0.42459,0.05,100 -10000,0.41633,0.42459,0.05,100 -10000,0.41633,0.42459,0.05,100 -10000,0.41633,0.42459,0.05,100 -10000,0.41633,0.42459,0.05,100 -10000,0.42458,0.433,0.05,100 -10000,0.42458,0.433,0.05,100 -10000,0.42458,0.433,0.05,100 -10000,0.42458,0.433,0.05,100 -10000,0.42458,0.433,0.05,100 -10000,0.42458,0.433,0.05,100 -10000,0.42458,0.433,0.05,100 -10000,0.42458,0.433,0.05,100 -10000,0.42458,0.433,0.05,100 -10000,0.43298,0.44157,0.05,100 -10000,0.43298,0.44157,0.05,100 -10000,0.43298,0.44157,0.05,100 -10000,0.43298,0.44157,0.05,100 -10000,0.43298,0.44157,0.05,100 -10000,0.43298,0.44157,0.05,100 -10000,0.43298,0.44157,0.05,100 -10000,0.43298,0.44157,0.05,100 -10000,0.44156,0.45031,0.05,100 -10000,0.44156,0.45031,0.05,100 -10000,0.44156,0.45031,0.05,100 -10000,0.44156,0.45031,0.05,100 -10000,0.44156,0.45031,0.05,100 -10000,0.44156,0.45031,0.05,100 -10000,0.44156,0.45031,0.05,100 -10000,0.44156,0.45031,0.05,100 -10000,0.44156,0.45031,0.05,100 -10000,0.4503,0.45923,0.05,100 -10000,0.4503,0.45923,0.05,100 -10000,0.4503,0.45923,0.05,100 -10000,0.4503,0.45923,0.05,100 -10000,0.4503,0.45923,0.05,100 -10000,0.4503,0.45923,0.05,100 -10000,0.4503,0.45923,0.05,100 -10000,0.4503,0.45923,0.05,100 -10000,0.4503,0.45923,0.05,100 -10000,0.45922,0.46833,0.05,100 -10000,0.45922,0.46833,0.05,100 -10000,0.45922,0.46833,0.05,100 -10000,0.45922,0.46833,0.05,100 -10000,0.45922,0.46833,0.05,100 -10000,0.45922,0.46833,0.05,100 -10000,0.45922,0.46833,0.05,100 -10000,0.45922,0.46833,0.05,100 -10000,0.45922,0.46833,0.05,100 -10000,0.46832,0.4776,0.05,100 -10000,0.46832,0.4776,0.05,100 -10000,0.46832,0.4776,0.05,100 -10000,0.46832,0.4776,0.05,100 -10000,0.46832,0.4776,0.05,100 -10000,0.46832,0.4776,0.05,100 -10000,0.46832,0.4776,0.05,100 -10000,0.46832,0.4776,0.05,100 -10000,0.46832,0.4776,0.05,100 -10000,0.47759,0.48706,0.05,100 -10000,0.47759,0.48706,0.05,100 -10000,0.47759,0.48706,0.05,100 -10000,0.47759,0.48706,0.05,100 -10000,0.47759,0.48706,0.05,100 -10000,0.47759,0.48706,0.05,100 -10000,0.47759,0.48706,0.05,100 -10000,0.47759,0.48706,0.05,100 -10000,0.47759,0.48706,0.05,100 -10000,0.47759,0.48706,0.05,100 -10000,0.48705,0.49671,0.05,100 -10000,0.48705,0.49671,0.05,100 -10000,0.48705,0.49671,0.05,100 -10000,0.48705,0.49671,0.05,100 -10000,0.48705,0.49671,0.05,100 -10000,0.48705,0.49671,0.05,100 -10000,0.48705,0.49671,0.05,100 -10000,0.48705,0.49671,0.05,100 -10000,0.48705,0.49671,0.05,100 -10000,0.4967,0.50655,0.05,100 -10000,0.4967,0.50655,0.05,100 -10000,0.4967,0.50655,0.05,100 -10000,0.4967,0.50655,0.05,100 -10000,0.4967,0.50655,0.05,100 -10000,0.4967,0.50655,0.05,100 -10000,0.4967,0.50655,0.05,100 -10000,0.4967,0.50655,0.05,100 -10000,0.4967,0.50655,0.05,100 -10000,0.4967,0.50655,0.05,100 -10000,0.50654,0.51658,0.05,100 -10000,0.50654,0.51658,0.05,100 -10000,0.50654,0.51658,0.05,100 -10000,0.50654,0.51658,0.05,100 -10000,0.50654,0.51658,0.05,100 -10000,0.50654,0.51658,0.05,100 -10000,0.50654,0.51658,0.05,100 -10000,0.50654,0.51658,0.05,100 -10000,0.50654,0.51658,0.05,100 -10000,0.50654,0.51658,0.05,100 -10000,0.51657,0.52681,0.05,100 -10000,0.51657,0.52681,0.05,100 -10000,0.51657,0.52681,0.05,100 -10000,0.51657,0.52681,0.05,100 -10000,0.51657,0.52681,0.05,100 -10000,0.51657,0.52681,0.05,100 -10000,0.51657,0.52681,0.05,100 -10000,0.51657,0.52681,0.05,100 -10000,0.51657,0.52681,0.05,100 -10000,0.51657,0.52681,0.05,100 -10000,0.5268,0.53725,0.05,100 -10000,0.5268,0.53725,0.05,100 -10000,0.5268,0.53725,0.05,100 -10000,0.5268,0.53725,0.05,100 -10000,0.5268,0.53725,0.05,100 -10000,0.5268,0.53725,0.05,100 -10000,0.5268,0.53725,0.05,100 -10000,0.5268,0.53725,0.05,100 -10000,0.5268,0.53725,0.05,100 -10000,0.5268,0.53725,0.05,100 -10000,0.5268,0.53725,0.05,100 -10000,0.53724,0.54789,0.05,100 -10000,0.53724,0.54789,0.05,100 -10000,0.53724,0.54789,0.05,100 -10000,0.53724,0.54789,0.05,100 -10000,0.53724,0.54789,0.05,100 -10000,0.53724,0.54789,0.05,100 -10000,0.53724,0.54789,0.05,100 -10000,0.53724,0.54789,0.05,100 -10000,0.53724,0.54789,0.05,100 -10000,0.53724,0.54789,0.05,100 -10000,0.54788,0.55874,0.05,100 -10000,0.54788,0.55874,0.05,100 -10000,0.54788,0.55874,0.05,100 -10000,0.54788,0.55874,0.05,100 -10000,0.54788,0.55874,0.05,100 -10000,0.54788,0.55874,0.05,100 -10000,0.54788,0.55874,0.05,100 -10000,0.54788,0.55874,0.05,100 -10000,0.54788,0.55874,0.05,100 -10000,0.54788,0.55874,0.05,100 -10000,0.54788,0.55874,0.05,100 -10000,0.55873,0.56981,0.05,100 -10000,0.55873,0.56981,0.05,100 -10000,0.55873,0.56981,0.05,100 -10000,0.55873,0.56981,0.05,100 -10000,0.55873,0.56981,0.05,100 -10000,0.55873,0.56981,0.05,100 -10000,0.55873,0.56981,0.05,100 -10000,0.55873,0.56981,0.05,100 -10000,0.55873,0.56981,0.05,100 -10000,0.55873,0.56981,0.05,100 -10000,0.55873,0.56981,0.05,100 -10000,0.5698,0.5811,0.05,100 -10000,0.5698,0.5811,0.05,100 -10000,0.5698,0.5811,0.05,100 -10000,0.5698,0.5811,0.05,100 -10000,0.5698,0.5811,0.05,100 -10000,0.5698,0.5811,0.05,100 -10000,0.5698,0.5811,0.05,100 -10000,0.5698,0.5811,0.05,100 -10000,0.5698,0.5811,0.05,100 -10000,0.5698,0.5811,0.05,100 -10000,0.5698,0.5811,0.05,100 -10000,0.5698,0.5811,0.05,100 -10000,0.58109,0.59261,0.05,100 -10000,0.58109,0.59261,0.05,100 -10000,0.58109,0.59261,0.05,100 -10000,0.58109,0.59261,0.05,100 -10000,0.58109,0.59261,0.05,100 -10000,0.58109,0.59261,0.05,100 -10000,0.58109,0.59261,0.05,100 -10000,0.58109,0.59261,0.05,100 -10000,0.58109,0.59261,0.05,100 -10000,0.58109,0.59261,0.05,100 -10000,0.58109,0.59261,0.05,100 -10000,0.5926,0.60435,0.05,100 -10000,0.5926,0.60435,0.05,100 -10000,0.5926,0.60435,0.05,100 -10000,0.5926,0.60435,0.05,100 -10000,0.5926,0.60435,0.05,100 -10000,0.5926,0.60435,0.05,100 -10000,0.5926,0.60435,0.05,100 -10000,0.5926,0.60435,0.05,100 -10000,0.5926,0.60435,0.05,100 -10000,0.5926,0.60435,0.05,100 -10000,0.5926,0.60435,0.05,100 -10000,0.5926,0.60435,0.05,100 -10000,0.60434,0.61632,0.05,100 -10000,0.60434,0.61632,0.05,100 -10000,0.60434,0.61632,0.05,100 -10000,0.60434,0.61632,0.05,100 -10000,0.60434,0.61632,0.05,100 -10000,0.60434,0.61632,0.05,100 -10000,0.60434,0.61632,0.05,100 -10000,0.60434,0.61632,0.05,100 -10000,0.60434,0.61632,0.05,100 -10000,0.60434,0.61632,0.05,100 -10000,0.60434,0.61632,0.05,100 -10000,0.60434,0.61632,0.05,100 -10000,0.61631,0.62853,0.05,100 -10000,0.61631,0.62853,0.05,100 -10000,0.61631,0.62853,0.05,100 -10000,0.61631,0.62853,0.05,100 -10000,0.61631,0.62853,0.05,100 -10000,0.61631,0.62853,0.05,100 -10000,0.61631,0.62853,0.05,100 -10000,0.61631,0.62853,0.05,100 -10000,0.61631,0.62853,0.05,100 -10000,0.61631,0.62853,0.05,100 -10000,0.61631,0.62853,0.05,100 -10000,0.61631,0.62853,0.05,100 -10000,0.62852,0.64098,0.05,100 -10000,0.62852,0.64098,0.05,100 -10000,0.62852,0.64098,0.05,100 -10000,0.62852,0.64098,0.05,100 -10000,0.62852,0.64098,0.05,100 -10000,0.62852,0.64098,0.05,100 -10000,0.62852,0.64098,0.05,100 -10000,0.62852,0.64098,0.05,100 -10000,0.62852,0.64098,0.05,100 -10000,0.62852,0.64098,0.05,100 -10000,0.62852,0.64098,0.05,100 -10000,0.62852,0.64098,0.05,100 -10000,0.62852,0.64098,0.05,100 -10000,0.64097,0.65368,0.05,100 -10000,0.64097,0.65368,0.05,100 -10000,0.64097,0.65368,0.05,100 -10000,0.64097,0.65368,0.05,100 -10000,0.64097,0.65368,0.05,100 -10000,0.64097,0.65368,0.05,100 -10000,0.64097,0.65368,0.05,100 -10000,0.64097,0.65368,0.05,100 -10000,0.64097,0.65368,0.05,100 -10000,0.64097,0.65368,0.05,100 -10000,0.64097,0.65368,0.05,100 -10000,0.64097,0.65368,0.05,100 -10000,0.65367,0.66663,0.05,100 -10000,0.65367,0.66663,0.05,100 -10000,0.65367,0.66663,0.05,100 -10000,0.65367,0.66663,0.05,100 -10000,0.65367,0.66663,0.05,100 -10000,0.65367,0.66663,0.05,100 -10000,0.65367,0.66663,0.05,100 -10000,0.65367,0.66663,0.05,100 -10000,0.65367,0.66663,0.05,100 -10000,0.65367,0.66663,0.05,100 -10000,0.65367,0.66663,0.05,100 -10000,0.65367,0.66663,0.05,100 -10000,0.65367,0.66663,0.05,100 -10000,0.66662,0.67984,0.05,100 -10000,0.66662,0.67984,0.05,100 -10000,0.66662,0.67984,0.05,100 -10000,0.66662,0.67984,0.05,100 -10000,0.66662,0.67984,0.05,100 -10000,0.66662,0.67984,0.05,100 -10000,0.66662,0.67984,0.05,100 -10000,0.66662,0.67984,0.05,100 -10000,0.66662,0.67984,0.05,100 -10000,0.66662,0.67984,0.05,100 -10000,0.66662,0.67984,0.05,100 -10000,0.66662,0.67984,0.05,100 -10000,0.66662,0.67984,0.05,100 -10000,0.67983,0.69331,0.05,100 -10000,0.67983,0.69331,0.05,100 -10000,0.67983,0.69331,0.05,100 -10000,0.67983,0.69331,0.05,100 -10000,0.67983,0.69331,0.05,100 -10000,0.67983,0.69331,0.05,100 -10000,0.67983,0.69331,0.05,100 -10000,0.67983,0.69331,0.05,100 -10000,0.67983,0.69331,0.05,100 -10000,0.67983,0.69331,0.05,100 -10000,0.67983,0.69331,0.05,100 -10000,0.67983,0.69331,0.05,100 -10000,0.67983,0.69331,0.05,100 -10000,0.67983,0.69331,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,0.6933,0.70704,0.05,100 -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan -10000,nan,nan,nan,nan diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_10.csv b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_10.csv deleted file mode 100644 index f8bba333145..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_10.csv +++ /dev/null @@ -1,1002 +0,0 @@ -Time,"elementCenter:0","elementCenter:1","elementCenter:2","temperature" -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,0.07071,0.072112,0.05,-17.679 -1e+05,0.07071,0.072112,0.05,-17.679 -1e+05,0.07211,0.07354,0.05,-13.128 -1e+05,0.07351,0.074968,0.05,-8.6631 -1e+05,0.075155,0.076646,0.05,-3.5144 -1e+05,0.075155,0.076646,0.05,-3.5144 -1e+05,0.077046,0.078574,0.05,2.2548 -1e+05,0.077046,0.078574,0.05,2.2548 -1e+05,0.078936,0.080501,0.05,7.8811 -1e+05,0.078936,0.080501,0.05,7.8811 -1e+05,0.080826,0.082429,0.05,13.366 -1e+05,0.080826,0.082429,0.05,13.366 -1e+05,0.082716,0.084357,0.05,18.708 -1e+05,0.082716,0.084357,0.05,18.708 -1e+05,0.084607,0.086285,0.05,23.905 -1e+05,0.084607,0.086285,0.05,23.905 -1e+05,0.086497,0.088212,0.05,28.953 -1e+05,0.086497,0.088212,0.05,28.953 -1e+05,0.088387,0.09014,0.05,33.846 -1e+05,0.088387,0.09014,0.05,33.846 -1e+05,0.090278,0.092068,0.05,38.579 -1e+05,0.090278,0.092068,0.05,38.579 -1e+05,0.092168,0.093995,0.05,43.144 -1e+05,0.092168,0.093995,0.05,43.144 -1e+05,0.094031,0.095896,0.05,47.472 -1e+05,0.095885,0.097786,0.05,51.606 -1e+05,0.095885,0.097786,0.05,51.606 -1e+05,0.097776,0.099715,0.05,55.636 -1e+05,0.097776,0.099715,0.05,55.636 -1e+05,0.099704,0.10168,0.05,59.545 -1e+05,0.099704,0.10168,0.05,59.545 -1e+05,0.10167,0.10369,0.05,63.317 -1e+05,0.10167,0.10369,0.05,63.317 -1e+05,0.10368,0.10573,0.05,66.937 -1e+05,0.10368,0.10573,0.05,66.937 -1e+05,0.10572,0.10782,0.05,70.39 -1e+05,0.10572,0.10782,0.05,70.39 -1e+05,0.10781,0.10995,0.05,73.659 -1e+05,0.10781,0.10995,0.05,73.659 -1e+05,0.10993,0.11211,0.05,76.734 -1e+05,0.10993,0.11211,0.05,76.734 -1e+05,0.10993,0.11211,0.05,76.734 -1e+05,0.1121,0.11433,0.05,79.604 -1e+05,0.1121,0.11433,0.05,79.604 -1e+05,0.11432,0.11658,0.05,82.259 -1e+05,0.11432,0.11658,0.05,82.259 -1e+05,0.11657,0.11888,0.05,84.696 -1e+05,0.11657,0.11888,0.05,84.696 -1e+05,0.11887,0.12123,0.05,86.911 -1e+05,0.11887,0.12123,0.05,86.911 -1e+05,0.11887,0.12123,0.05,86.911 -1e+05,0.12122,0.12362,0.05,88.906 -1e+05,0.12122,0.12362,0.05,88.906 -1e+05,0.12361,0.12607,0.05,90.684 -1e+05,0.12361,0.12607,0.05,90.684 -1e+05,0.12361,0.12607,0.05,90.684 -1e+05,0.12605,0.12855,0.05,92.253 -1e+05,0.12605,0.12855,0.05,92.253 -1e+05,0.12854,0.13109,0.05,93.623 -1e+05,0.12854,0.13109,0.05,93.623 -1e+05,0.12854,0.13109,0.05,93.623 -1e+05,0.13108,0.13368,0.05,94.805 -1e+05,0.13108,0.13368,0.05,94.805 -1e+05,0.13367,0.13632,0.05,95.814 -1e+05,0.13367,0.13632,0.05,95.814 -1e+05,0.13367,0.13632,0.05,95.814 -1e+05,0.13631,0.13901,0.05,96.664 -1e+05,0.13631,0.13901,0.05,96.664 -1e+05,0.13631,0.13901,0.05,96.664 -1e+05,0.139,0.14176,0.05,97.373 -1e+05,0.139,0.14176,0.05,97.373 -1e+05,0.14175,0.14456,0.05,97.956 -1e+05,0.14175,0.14456,0.05,97.956 -1e+05,0.14175,0.14456,0.05,97.956 -1e+05,0.14455,0.14742,0.05,98.429 -1e+05,0.14455,0.14742,0.05,98.429 -1e+05,0.14455,0.14742,0.05,98.429 -1e+05,0.1474,0.15033,0.05,98.808 -1e+05,0.1474,0.15033,0.05,98.808 -1e+05,0.1474,0.15033,0.05,98.808 -1e+05,0.15032,0.1533,0.05,99.108 -1e+05,0.15032,0.1533,0.05,99.108 -1e+05,0.15032,0.1533,0.05,99.108 -1e+05,0.15329,0.15633,0.05,99.341 -1e+05,0.15329,0.15633,0.05,99.341 -1e+05,0.15329,0.15633,0.05,99.341 -1e+05,0.15632,0.15942,0.05,99.521 -1e+05,0.15632,0.15942,0.05,99.521 -1e+05,0.15632,0.15942,0.05,99.521 -1e+05,0.15941,0.16257,0.05,99.656 -1e+05,0.15941,0.16257,0.05,99.656 -1e+05,0.15941,0.16257,0.05,99.656 -1e+05,0.16256,0.16578,0.05,99.757 -1e+05,0.16256,0.16578,0.05,99.757 -1e+05,0.16256,0.16578,0.05,99.757 -1e+05,0.16577,0.16906,0.05,99.831 -1e+05,0.16577,0.16906,0.05,99.831 -1e+05,0.16577,0.16906,0.05,99.831 -1e+05,0.16577,0.16906,0.05,99.831 -1e+05,0.16905,0.1724,0.05,99.885 -1e+05,0.16905,0.1724,0.05,99.885 -1e+05,0.16905,0.1724,0.05,99.885 -1e+05,0.17239,0.1758,0.05,99.922 -1e+05,0.17239,0.1758,0.05,99.922 -1e+05,0.17239,0.1758,0.05,99.922 -1e+05,0.17579,0.17928,0.05,99.949 -1e+05,0.17579,0.17928,0.05,99.949 -1e+05,0.17579,0.17928,0.05,99.949 -1e+05,0.17579,0.17928,0.05,99.949 -1e+05,0.17927,0.18282,0.05,99.967 -1e+05,0.17927,0.18282,0.05,99.967 -1e+05,0.17927,0.18282,0.05,99.967 -1e+05,0.18281,0.18644,0.05,99.979 -1e+05,0.18281,0.18644,0.05,99.979 -1e+05,0.18281,0.18644,0.05,99.979 -1e+05,0.18281,0.18644,0.05,99.979 -1e+05,0.18643,0.19013,0.05,99.987 -1e+05,0.18643,0.19013,0.05,99.987 -1e+05,0.18643,0.19013,0.05,99.987 -1e+05,0.18643,0.19013,0.05,99.987 -1e+05,0.19011,0.19388,0.05,99.992 -1e+05,0.19011,0.19388,0.05,99.992 -1e+05,0.19011,0.19388,0.05,99.992 -1e+05,0.19387,0.19772,0.05,99.995 -1e+05,0.19387,0.19772,0.05,99.995 -1e+05,0.19387,0.19772,0.05,99.995 -1e+05,0.19387,0.19772,0.05,99.995 -1e+05,0.19771,0.20163,0.05,99.997 -1e+05,0.19771,0.20163,0.05,99.997 -1e+05,0.19771,0.20163,0.05,99.997 -1e+05,0.19771,0.20163,0.05,99.997 -1e+05,0.20162,0.20562,0.05,99.998 -1e+05,0.20162,0.20562,0.05,99.998 -1e+05,0.20162,0.20562,0.05,99.998 -1e+05,0.20162,0.20562,0.05,99.998 -1e+05,0.2056,0.20968,0.05,99.999 -1e+05,0.2056,0.20968,0.05,99.999 -1e+05,0.2056,0.20968,0.05,99.999 -1e+05,0.2056,0.20968,0.05,99.999 -1e+05,0.20967,0.21383,0.05,99.999 -1e+05,0.20967,0.21383,0.05,99.999 -1e+05,0.20967,0.21383,0.05,99.999 -1e+05,0.20967,0.21383,0.05,99.999 -1e+05,0.21382,0.21806,0.05,100 -1e+05,0.21382,0.21806,0.05,100 -1e+05,0.21382,0.21806,0.05,100 -1e+05,0.21382,0.21806,0.05,100 -1e+05,0.21382,0.21806,0.05,100 -1e+05,0.21805,0.22237,0.05,100 -1e+05,0.21805,0.22237,0.05,100 -1e+05,0.21805,0.22237,0.05,100 -1e+05,0.21805,0.22237,0.05,100 -1e+05,0.22236,0.22677,0.05,100 -1e+05,0.22236,0.22677,0.05,100 -1e+05,0.22236,0.22677,0.05,100 -1e+05,0.22236,0.22677,0.05,100 -1e+05,0.22676,0.23125,0.05,100 -1e+05,0.22676,0.23125,0.05,100 -1e+05,0.22676,0.23125,0.05,100 -1e+05,0.22676,0.23125,0.05,100 -1e+05,0.22676,0.23125,0.05,100 -1e+05,0.23124,0.23583,0.05,100 -1e+05,0.23124,0.23583,0.05,100 -1e+05,0.23124,0.23583,0.05,100 -1e+05,0.23124,0.23583,0.05,100 -1e+05,0.23582,0.2405,0.05,100 -1e+05,0.23582,0.2405,0.05,100 -1e+05,0.23582,0.2405,0.05,100 -1e+05,0.23582,0.2405,0.05,100 -1e+05,0.23582,0.2405,0.05,100 -1e+05,0.24048,0.24525,0.05,100 -1e+05,0.24048,0.24525,0.05,100 -1e+05,0.24048,0.24525,0.05,100 -1e+05,0.24048,0.24525,0.05,100 -1e+05,0.24048,0.24525,0.05,100 -1e+05,0.24524,0.25011,0.05,100 -1e+05,0.24524,0.25011,0.05,100 -1e+05,0.24524,0.25011,0.05,100 -1e+05,0.24524,0.25011,0.05,100 -1e+05,0.24524,0.25011,0.05,100 -1e+05,0.25009,0.25505,0.05,100 -1e+05,0.25009,0.25505,0.05,100 -1e+05,0.25009,0.25505,0.05,100 -1e+05,0.25009,0.25505,0.05,100 -1e+05,0.25009,0.25505,0.05,100 -1e+05,0.25504,0.2601,0.05,100 -1e+05,0.25504,0.2601,0.05,100 -1e+05,0.25504,0.2601,0.05,100 -1e+05,0.25504,0.2601,0.05,100 -1e+05,0.25504,0.2601,0.05,100 -1e+05,0.26009,0.26525,0.05,100 -1e+05,0.26009,0.26525,0.05,100 -1e+05,0.26009,0.26525,0.05,100 -1e+05,0.26009,0.26525,0.05,100 -1e+05,0.26009,0.26525,0.05,100 -1e+05,0.26524,0.2705,0.05,100 -1e+05,0.26524,0.2705,0.05,100 -1e+05,0.26524,0.2705,0.05,100 -1e+05,0.26524,0.2705,0.05,100 -1e+05,0.26524,0.2705,0.05,100 -1e+05,0.27048,0.27585,0.05,100 -1e+05,0.27048,0.27585,0.05,100 -1e+05,0.27048,0.27585,0.05,100 -1e+05,0.27048,0.27585,0.05,100 -1e+05,0.27048,0.27585,0.05,100 -1e+05,0.27584,0.28131,0.05,100 -1e+05,0.27584,0.28131,0.05,100 -1e+05,0.27584,0.28131,0.05,100 -1e+05,0.27584,0.28131,0.05,100 -1e+05,0.27584,0.28131,0.05,100 -1e+05,0.27584,0.28131,0.05,100 -1e+05,0.2813,0.28687,0.05,100 -1e+05,0.2813,0.28687,0.05,100 -1e+05,0.2813,0.28687,0.05,100 -1e+05,0.2813,0.28687,0.05,100 -1e+05,0.2813,0.28687,0.05,100 -1e+05,0.28686,0.29255,0.05,100 -1e+05,0.28686,0.29255,0.05,100 -1e+05,0.28686,0.29255,0.05,100 -1e+05,0.28686,0.29255,0.05,100 -1e+05,0.28686,0.29255,0.05,100 -1e+05,0.28686,0.29255,0.05,100 -1e+05,0.29254,0.29834,0.05,100 -1e+05,0.29254,0.29834,0.05,100 -1e+05,0.29254,0.29834,0.05,100 -1e+05,0.29254,0.29834,0.05,100 -1e+05,0.29254,0.29834,0.05,100 -1e+05,0.29254,0.29834,0.05,100 -1e+05,0.29833,0.30425,0.05,100 -1e+05,0.29833,0.30425,0.05,100 -1e+05,0.29833,0.30425,0.05,100 -1e+05,0.29833,0.30425,0.05,100 -1e+05,0.29833,0.30425,0.05,100 -1e+05,0.29833,0.30425,0.05,100 -1e+05,0.30424,0.31027,0.05,100 -1e+05,0.30424,0.31027,0.05,100 -1e+05,0.30424,0.31027,0.05,100 -1e+05,0.30424,0.31027,0.05,100 -1e+05,0.30424,0.31027,0.05,100 -1e+05,0.30424,0.31027,0.05,100 -1e+05,0.31026,0.31641,0.05,100 -1e+05,0.31026,0.31641,0.05,100 -1e+05,0.31026,0.31641,0.05,100 -1e+05,0.31026,0.31641,0.05,100 -1e+05,0.31026,0.31641,0.05,100 -1e+05,0.31026,0.31641,0.05,100 -1e+05,0.3164,0.32267,0.05,100 -1e+05,0.3164,0.32267,0.05,100 -1e+05,0.3164,0.32267,0.05,100 -1e+05,0.3164,0.32267,0.05,100 -1e+05,0.3164,0.32267,0.05,100 -1e+05,0.3164,0.32267,0.05,100 -1e+05,0.32266,0.32906,0.05,100 -1e+05,0.32266,0.32906,0.05,100 -1e+05,0.32266,0.32906,0.05,100 -1e+05,0.32266,0.32906,0.05,100 -1e+05,0.32266,0.32906,0.05,100 -1e+05,0.32266,0.32906,0.05,100 -1e+05,0.32266,0.32906,0.05,100 -1e+05,0.32905,0.33558,0.05,100 -1e+05,0.32905,0.33558,0.05,100 -1e+05,0.32905,0.33558,0.05,100 -1e+05,0.32905,0.33558,0.05,100 -1e+05,0.32905,0.33558,0.05,100 -1e+05,0.32905,0.33558,0.05,100 -1e+05,0.33556,0.34222,0.05,100 -1e+05,0.33556,0.34222,0.05,100 -1e+05,0.33556,0.34222,0.05,100 -1e+05,0.33556,0.34222,0.05,100 -1e+05,0.33556,0.34222,0.05,100 -1e+05,0.33556,0.34222,0.05,100 -1e+05,0.33556,0.34222,0.05,100 -1e+05,0.34221,0.34899,0.05,100 -1e+05,0.34221,0.34899,0.05,100 -1e+05,0.34221,0.34899,0.05,100 -1e+05,0.34221,0.34899,0.05,100 -1e+05,0.34221,0.34899,0.05,100 -1e+05,0.34221,0.34899,0.05,100 -1e+05,0.34221,0.34899,0.05,100 -1e+05,0.34898,0.3559,0.05,100 -1e+05,0.34898,0.3559,0.05,100 -1e+05,0.34898,0.3559,0.05,100 -1e+05,0.34898,0.3559,0.05,100 -1e+05,0.34898,0.3559,0.05,100 -1e+05,0.34898,0.3559,0.05,100 -1e+05,0.35589,0.36295,0.05,100 -1e+05,0.35589,0.36295,0.05,100 -1e+05,0.35589,0.36295,0.05,100 -1e+05,0.35589,0.36295,0.05,100 -1e+05,0.35589,0.36295,0.05,100 -1e+05,0.35589,0.36295,0.05,100 -1e+05,0.35589,0.36295,0.05,100 -1e+05,0.36294,0.37013,0.05,100 -1e+05,0.36294,0.37013,0.05,100 -1e+05,0.36294,0.37013,0.05,100 -1e+05,0.36294,0.37013,0.05,100 -1e+05,0.36294,0.37013,0.05,100 -1e+05,0.36294,0.37013,0.05,100 -1e+05,0.36294,0.37013,0.05,100 -1e+05,0.36294,0.37013,0.05,100 -1e+05,0.37012,0.37746,0.05,100 -1e+05,0.37012,0.37746,0.05,100 -1e+05,0.37012,0.37746,0.05,100 -1e+05,0.37012,0.37746,0.05,100 -1e+05,0.37012,0.37746,0.05,100 -1e+05,0.37012,0.37746,0.05,100 -1e+05,0.37012,0.37746,0.05,100 -1e+05,0.37745,0.38494,0.05,100 -1e+05,0.37745,0.38494,0.05,100 -1e+05,0.37745,0.38494,0.05,100 -1e+05,0.37745,0.38494,0.05,100 -1e+05,0.37745,0.38494,0.05,100 -1e+05,0.37745,0.38494,0.05,100 -1e+05,0.37745,0.38494,0.05,100 -1e+05,0.38493,0.39256,0.05,100 -1e+05,0.38493,0.39256,0.05,100 -1e+05,0.38493,0.39256,0.05,100 -1e+05,0.38493,0.39256,0.05,100 -1e+05,0.38493,0.39256,0.05,100 -1e+05,0.38493,0.39256,0.05,100 -1e+05,0.38493,0.39256,0.05,100 -1e+05,0.38493,0.39256,0.05,100 -1e+05,0.39255,0.40033,0.05,100 -1e+05,0.39255,0.40033,0.05,100 -1e+05,0.39255,0.40033,0.05,100 -1e+05,0.39255,0.40033,0.05,100 -1e+05,0.39255,0.40033,0.05,100 -1e+05,0.39255,0.40033,0.05,100 -1e+05,0.39255,0.40033,0.05,100 -1e+05,0.39255,0.40033,0.05,100 -1e+05,0.40032,0.40826,0.05,100 -1e+05,0.40032,0.40826,0.05,100 -1e+05,0.40032,0.40826,0.05,100 -1e+05,0.40032,0.40826,0.05,100 -1e+05,0.40032,0.40826,0.05,100 -1e+05,0.40032,0.40826,0.05,100 -1e+05,0.40032,0.40826,0.05,100 -1e+05,0.40032,0.40826,0.05,100 -1e+05,0.40825,0.41634,0.05,100 -1e+05,0.40825,0.41634,0.05,100 -1e+05,0.40825,0.41634,0.05,100 -1e+05,0.40825,0.41634,0.05,100 -1e+05,0.40825,0.41634,0.05,100 -1e+05,0.40825,0.41634,0.05,100 -1e+05,0.40825,0.41634,0.05,100 -1e+05,0.40825,0.41634,0.05,100 -1e+05,0.41633,0.42459,0.05,100 -1e+05,0.41633,0.42459,0.05,100 -1e+05,0.41633,0.42459,0.05,100 -1e+05,0.41633,0.42459,0.05,100 -1e+05,0.41633,0.42459,0.05,100 -1e+05,0.41633,0.42459,0.05,100 -1e+05,0.41633,0.42459,0.05,100 -1e+05,0.41633,0.42459,0.05,100 -1e+05,0.42458,0.433,0.05,100 -1e+05,0.42458,0.433,0.05,100 -1e+05,0.42458,0.433,0.05,100 -1e+05,0.42458,0.433,0.05,100 -1e+05,0.42458,0.433,0.05,100 -1e+05,0.42458,0.433,0.05,100 -1e+05,0.42458,0.433,0.05,100 -1e+05,0.42458,0.433,0.05,100 -1e+05,0.42458,0.433,0.05,100 -1e+05,0.43298,0.44157,0.05,100 -1e+05,0.43298,0.44157,0.05,100 -1e+05,0.43298,0.44157,0.05,100 -1e+05,0.43298,0.44157,0.05,100 -1e+05,0.43298,0.44157,0.05,100 -1e+05,0.43298,0.44157,0.05,100 -1e+05,0.43298,0.44157,0.05,100 -1e+05,0.43298,0.44157,0.05,100 -1e+05,0.44156,0.45031,0.05,100 -1e+05,0.44156,0.45031,0.05,100 -1e+05,0.44156,0.45031,0.05,100 -1e+05,0.44156,0.45031,0.05,100 -1e+05,0.44156,0.45031,0.05,100 -1e+05,0.44156,0.45031,0.05,100 -1e+05,0.44156,0.45031,0.05,100 -1e+05,0.44156,0.45031,0.05,100 -1e+05,0.44156,0.45031,0.05,100 -1e+05,0.4503,0.45923,0.05,100 -1e+05,0.4503,0.45923,0.05,100 -1e+05,0.4503,0.45923,0.05,100 -1e+05,0.4503,0.45923,0.05,100 -1e+05,0.4503,0.45923,0.05,100 -1e+05,0.4503,0.45923,0.05,100 -1e+05,0.4503,0.45923,0.05,100 -1e+05,0.4503,0.45923,0.05,100 -1e+05,0.4503,0.45923,0.05,100 -1e+05,0.45922,0.46833,0.05,100 -1e+05,0.45922,0.46833,0.05,100 -1e+05,0.45922,0.46833,0.05,100 -1e+05,0.45922,0.46833,0.05,100 -1e+05,0.45922,0.46833,0.05,100 -1e+05,0.45922,0.46833,0.05,100 -1e+05,0.45922,0.46833,0.05,100 -1e+05,0.45922,0.46833,0.05,100 -1e+05,0.45922,0.46833,0.05,100 -1e+05,0.46832,0.4776,0.05,100 -1e+05,0.46832,0.4776,0.05,100 -1e+05,0.46832,0.4776,0.05,100 -1e+05,0.46832,0.4776,0.05,100 -1e+05,0.46832,0.4776,0.05,100 -1e+05,0.46832,0.4776,0.05,100 -1e+05,0.46832,0.4776,0.05,100 -1e+05,0.46832,0.4776,0.05,100 -1e+05,0.46832,0.4776,0.05,100 -1e+05,0.47759,0.48706,0.05,100 -1e+05,0.47759,0.48706,0.05,100 -1e+05,0.47759,0.48706,0.05,100 -1e+05,0.47759,0.48706,0.05,100 -1e+05,0.47759,0.48706,0.05,100 -1e+05,0.47759,0.48706,0.05,100 -1e+05,0.47759,0.48706,0.05,100 -1e+05,0.47759,0.48706,0.05,100 -1e+05,0.47759,0.48706,0.05,100 -1e+05,0.47759,0.48706,0.05,100 -1e+05,0.48705,0.49671,0.05,100 -1e+05,0.48705,0.49671,0.05,100 -1e+05,0.48705,0.49671,0.05,100 -1e+05,0.48705,0.49671,0.05,100 -1e+05,0.48705,0.49671,0.05,100 -1e+05,0.48705,0.49671,0.05,100 -1e+05,0.48705,0.49671,0.05,100 -1e+05,0.48705,0.49671,0.05,100 -1e+05,0.48705,0.49671,0.05,100 -1e+05,0.4967,0.50655,0.05,100 -1e+05,0.4967,0.50655,0.05,100 -1e+05,0.4967,0.50655,0.05,100 -1e+05,0.4967,0.50655,0.05,100 -1e+05,0.4967,0.50655,0.05,100 -1e+05,0.4967,0.50655,0.05,100 -1e+05,0.4967,0.50655,0.05,100 -1e+05,0.4967,0.50655,0.05,100 -1e+05,0.4967,0.50655,0.05,100 -1e+05,0.4967,0.50655,0.05,100 -1e+05,0.50654,0.51658,0.05,100 -1e+05,0.50654,0.51658,0.05,100 -1e+05,0.50654,0.51658,0.05,100 -1e+05,0.50654,0.51658,0.05,100 -1e+05,0.50654,0.51658,0.05,100 -1e+05,0.50654,0.51658,0.05,100 -1e+05,0.50654,0.51658,0.05,100 -1e+05,0.50654,0.51658,0.05,100 -1e+05,0.50654,0.51658,0.05,100 -1e+05,0.50654,0.51658,0.05,100 -1e+05,0.51657,0.52681,0.05,100 -1e+05,0.51657,0.52681,0.05,100 -1e+05,0.51657,0.52681,0.05,100 -1e+05,0.51657,0.52681,0.05,100 -1e+05,0.51657,0.52681,0.05,100 -1e+05,0.51657,0.52681,0.05,100 -1e+05,0.51657,0.52681,0.05,100 -1e+05,0.51657,0.52681,0.05,100 -1e+05,0.51657,0.52681,0.05,100 -1e+05,0.51657,0.52681,0.05,100 -1e+05,0.5268,0.53725,0.05,100 -1e+05,0.5268,0.53725,0.05,100 -1e+05,0.5268,0.53725,0.05,100 -1e+05,0.5268,0.53725,0.05,100 -1e+05,0.5268,0.53725,0.05,100 -1e+05,0.5268,0.53725,0.05,100 -1e+05,0.5268,0.53725,0.05,100 -1e+05,0.5268,0.53725,0.05,100 -1e+05,0.5268,0.53725,0.05,100 -1e+05,0.5268,0.53725,0.05,100 -1e+05,0.5268,0.53725,0.05,100 -1e+05,0.53724,0.54789,0.05,100 -1e+05,0.53724,0.54789,0.05,100 -1e+05,0.53724,0.54789,0.05,100 -1e+05,0.53724,0.54789,0.05,100 -1e+05,0.53724,0.54789,0.05,100 -1e+05,0.53724,0.54789,0.05,100 -1e+05,0.53724,0.54789,0.05,100 -1e+05,0.53724,0.54789,0.05,100 -1e+05,0.53724,0.54789,0.05,100 -1e+05,0.53724,0.54789,0.05,100 -1e+05,0.54788,0.55874,0.05,100 -1e+05,0.54788,0.55874,0.05,100 -1e+05,0.54788,0.55874,0.05,100 -1e+05,0.54788,0.55874,0.05,100 -1e+05,0.54788,0.55874,0.05,100 -1e+05,0.54788,0.55874,0.05,100 -1e+05,0.54788,0.55874,0.05,100 -1e+05,0.54788,0.55874,0.05,100 -1e+05,0.54788,0.55874,0.05,100 -1e+05,0.54788,0.55874,0.05,100 -1e+05,0.54788,0.55874,0.05,100 -1e+05,0.55873,0.56981,0.05,100 -1e+05,0.55873,0.56981,0.05,100 -1e+05,0.55873,0.56981,0.05,100 -1e+05,0.55873,0.56981,0.05,100 -1e+05,0.55873,0.56981,0.05,100 -1e+05,0.55873,0.56981,0.05,100 -1e+05,0.55873,0.56981,0.05,100 -1e+05,0.55873,0.56981,0.05,100 -1e+05,0.55873,0.56981,0.05,100 -1e+05,0.55873,0.56981,0.05,100 -1e+05,0.55873,0.56981,0.05,100 -1e+05,0.5698,0.5811,0.05,100 -1e+05,0.5698,0.5811,0.05,100 -1e+05,0.5698,0.5811,0.05,100 -1e+05,0.5698,0.5811,0.05,100 -1e+05,0.5698,0.5811,0.05,100 -1e+05,0.5698,0.5811,0.05,100 -1e+05,0.5698,0.5811,0.05,100 -1e+05,0.5698,0.5811,0.05,100 -1e+05,0.5698,0.5811,0.05,100 -1e+05,0.5698,0.5811,0.05,100 -1e+05,0.5698,0.5811,0.05,100 -1e+05,0.5698,0.5811,0.05,100 -1e+05,0.58109,0.59261,0.05,100 -1e+05,0.58109,0.59261,0.05,100 -1e+05,0.58109,0.59261,0.05,100 -1e+05,0.58109,0.59261,0.05,100 -1e+05,0.58109,0.59261,0.05,100 -1e+05,0.58109,0.59261,0.05,100 -1e+05,0.58109,0.59261,0.05,100 -1e+05,0.58109,0.59261,0.05,100 -1e+05,0.58109,0.59261,0.05,100 -1e+05,0.58109,0.59261,0.05,100 -1e+05,0.58109,0.59261,0.05,100 -1e+05,0.5926,0.60435,0.05,100 -1e+05,0.5926,0.60435,0.05,100 -1e+05,0.5926,0.60435,0.05,100 -1e+05,0.5926,0.60435,0.05,100 -1e+05,0.5926,0.60435,0.05,100 -1e+05,0.5926,0.60435,0.05,100 -1e+05,0.5926,0.60435,0.05,100 -1e+05,0.5926,0.60435,0.05,100 -1e+05,0.5926,0.60435,0.05,100 -1e+05,0.5926,0.60435,0.05,100 -1e+05,0.5926,0.60435,0.05,100 -1e+05,0.5926,0.60435,0.05,100 -1e+05,0.60434,0.61632,0.05,100 -1e+05,0.60434,0.61632,0.05,100 -1e+05,0.60434,0.61632,0.05,100 -1e+05,0.60434,0.61632,0.05,100 -1e+05,0.60434,0.61632,0.05,100 -1e+05,0.60434,0.61632,0.05,100 -1e+05,0.60434,0.61632,0.05,100 -1e+05,0.60434,0.61632,0.05,100 -1e+05,0.60434,0.61632,0.05,100 -1e+05,0.60434,0.61632,0.05,100 -1e+05,0.60434,0.61632,0.05,100 -1e+05,0.60434,0.61632,0.05,100 -1e+05,0.61631,0.62853,0.05,100 -1e+05,0.61631,0.62853,0.05,100 -1e+05,0.61631,0.62853,0.05,100 -1e+05,0.61631,0.62853,0.05,100 -1e+05,0.61631,0.62853,0.05,100 -1e+05,0.61631,0.62853,0.05,100 -1e+05,0.61631,0.62853,0.05,100 -1e+05,0.61631,0.62853,0.05,100 -1e+05,0.61631,0.62853,0.05,100 -1e+05,0.61631,0.62853,0.05,100 -1e+05,0.61631,0.62853,0.05,100 -1e+05,0.61631,0.62853,0.05,100 -1e+05,0.62852,0.64098,0.05,100 -1e+05,0.62852,0.64098,0.05,100 -1e+05,0.62852,0.64098,0.05,100 -1e+05,0.62852,0.64098,0.05,100 -1e+05,0.62852,0.64098,0.05,100 -1e+05,0.62852,0.64098,0.05,100 -1e+05,0.62852,0.64098,0.05,100 -1e+05,0.62852,0.64098,0.05,100 -1e+05,0.62852,0.64098,0.05,100 -1e+05,0.62852,0.64098,0.05,100 -1e+05,0.62852,0.64098,0.05,100 -1e+05,0.62852,0.64098,0.05,100 -1e+05,0.62852,0.64098,0.05,100 -1e+05,0.64097,0.65368,0.05,100 -1e+05,0.64097,0.65368,0.05,100 -1e+05,0.64097,0.65368,0.05,100 -1e+05,0.64097,0.65368,0.05,100 -1e+05,0.64097,0.65368,0.05,100 -1e+05,0.64097,0.65368,0.05,100 -1e+05,0.64097,0.65368,0.05,100 -1e+05,0.64097,0.65368,0.05,100 -1e+05,0.64097,0.65368,0.05,100 -1e+05,0.64097,0.65368,0.05,100 -1e+05,0.64097,0.65368,0.05,100 -1e+05,0.64097,0.65368,0.05,100 -1e+05,0.65367,0.66663,0.05,100 -1e+05,0.65367,0.66663,0.05,100 -1e+05,0.65367,0.66663,0.05,100 -1e+05,0.65367,0.66663,0.05,100 -1e+05,0.65367,0.66663,0.05,100 -1e+05,0.65367,0.66663,0.05,100 -1e+05,0.65367,0.66663,0.05,100 -1e+05,0.65367,0.66663,0.05,100 -1e+05,0.65367,0.66663,0.05,100 -1e+05,0.65367,0.66663,0.05,100 -1e+05,0.65367,0.66663,0.05,100 -1e+05,0.65367,0.66663,0.05,100 -1e+05,0.65367,0.66663,0.05,100 -1e+05,0.66662,0.67984,0.05,100 -1e+05,0.66662,0.67984,0.05,100 -1e+05,0.66662,0.67984,0.05,100 -1e+05,0.66662,0.67984,0.05,100 -1e+05,0.66662,0.67984,0.05,100 -1e+05,0.66662,0.67984,0.05,100 -1e+05,0.66662,0.67984,0.05,100 -1e+05,0.66662,0.67984,0.05,100 -1e+05,0.66662,0.67984,0.05,100 -1e+05,0.66662,0.67984,0.05,100 -1e+05,0.66662,0.67984,0.05,100 -1e+05,0.66662,0.67984,0.05,100 -1e+05,0.66662,0.67984,0.05,100 -1e+05,0.67983,0.69331,0.05,100 -1e+05,0.67983,0.69331,0.05,100 -1e+05,0.67983,0.69331,0.05,100 -1e+05,0.67983,0.69331,0.05,100 -1e+05,0.67983,0.69331,0.05,100 -1e+05,0.67983,0.69331,0.05,100 -1e+05,0.67983,0.69331,0.05,100 -1e+05,0.67983,0.69331,0.05,100 -1e+05,0.67983,0.69331,0.05,100 -1e+05,0.67983,0.69331,0.05,100 -1e+05,0.67983,0.69331,0.05,100 -1e+05,0.67983,0.69331,0.05,100 -1e+05,0.67983,0.69331,0.05,100 -1e+05,0.67983,0.69331,0.05,100 -1e+05,0.6933,0.70704,0.05,100 -1e+05,0.6933,0.70704,0.05,100 -1e+05,0.6933,0.70704,0.05,100 -1e+05,0.6933,0.70704,0.05,100 -1e+05,0.6933,0.70704,0.05,100 -1e+05,0.6933,0.70704,0.05,100 -1e+05,0.6933,0.70704,0.05,100 -1e+05,0.6933,0.70704,0.05,100 -1e+05,0.6933,0.70704,0.05,100 -1e+05,0.6933,0.70704,0.05,100 -1e+05,0.6933,0.70704,0.05,100 -1e+05,0.6933,0.70704,0.05,100 -1e+05,0.6933,0.70704,0.05,100 -1e+05,0.6933,0.70704,0.05,100 -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan -1e+05,nan,nan,nan,nan diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_2.csv b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_2.csv deleted file mode 100644 index 52362b795f0..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_2.csv +++ /dev/null @@ -1,1002 +0,0 @@ -Time,"elementCenter:0","elementCenter:1","elementCenter:2","temperature" -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,0.07071,0.072112,0.05,-15.478 -20000,0.07071,0.072112,0.05,-15.478 -20000,0.07211,0.07354,0.05,-6.6062 -20000,0.07351,0.074968,0.05,2.1009 -20000,0.075155,0.076646,0.05,12.127 -20000,0.075155,0.076646,0.05,12.127 -20000,0.077046,0.078574,0.05,23.273 -20000,0.077046,0.078574,0.05,23.273 -20000,0.078936,0.080501,0.05,33.948 -20000,0.078936,0.080501,0.05,33.948 -20000,0.080826,0.082429,0.05,44.021 -20000,0.080826,0.082429,0.05,44.021 -20000,0.082716,0.084357,0.05,53.356 -20000,0.082716,0.084357,0.05,53.356 -20000,0.084607,0.086285,0.05,61.822 -20000,0.084607,0.086285,0.05,61.822 -20000,0.086497,0.088212,0.05,69.322 -20000,0.086497,0.088212,0.05,69.322 -20000,0.088387,0.09014,0.05,75.802 -20000,0.088387,0.09014,0.05,75.802 -20000,0.090278,0.092068,0.05,81.26 -20000,0.090278,0.092068,0.05,81.26 -20000,0.092168,0.093995,0.05,85.744 -20000,0.092168,0.093995,0.05,85.744 -20000,0.094031,0.095896,0.05,89.288 -20000,0.095885,0.097786,0.05,92.071 -20000,0.095885,0.097786,0.05,92.071 -20000,0.097776,0.099715,0.05,94.256 -20000,0.097776,0.099715,0.05,94.256 -20000,0.099704,0.10168,0.05,95.926 -20000,0.099704,0.10168,0.05,95.926 -20000,0.10167,0.10369,0.05,97.173 -20000,0.10167,0.10369,0.05,97.173 -20000,0.10368,0.10573,0.05,98.08 -20000,0.10368,0.10573,0.05,98.08 -20000,0.10572,0.10782,0.05,98.724 -20000,0.10572,0.10782,0.05,98.724 -20000,0.10781,0.10995,0.05,99.171 -20000,0.10781,0.10995,0.05,99.171 -20000,0.10993,0.11211,0.05,99.473 -20000,0.10993,0.11211,0.05,99.473 -20000,0.10993,0.11211,0.05,99.473 -20000,0.1121,0.11433,0.05,99.672 -20000,0.1121,0.11433,0.05,99.672 -20000,0.11432,0.11658,0.05,99.801 -20000,0.11432,0.11658,0.05,99.801 -20000,0.11657,0.11888,0.05,99.882 -20000,0.11657,0.11888,0.05,99.882 -20000,0.11887,0.12123,0.05,99.931 -20000,0.11887,0.12123,0.05,99.931 -20000,0.11887,0.12123,0.05,99.931 -20000,0.12122,0.12362,0.05,99.961 -20000,0.12122,0.12362,0.05,99.961 -20000,0.12361,0.12607,0.05,99.978 -20000,0.12361,0.12607,0.05,99.978 -20000,0.12361,0.12607,0.05,99.978 -20000,0.12605,0.12855,0.05,99.988 -20000,0.12605,0.12855,0.05,99.988 -20000,0.12854,0.13109,0.05,99.994 -20000,0.12854,0.13109,0.05,99.994 -20000,0.12854,0.13109,0.05,99.994 -20000,0.13108,0.13368,0.05,99.997 -20000,0.13108,0.13368,0.05,99.997 -20000,0.13367,0.13632,0.05,99.998 -20000,0.13367,0.13632,0.05,99.998 -20000,0.13367,0.13632,0.05,99.998 -20000,0.13631,0.13901,0.05,99.999 -20000,0.13631,0.13901,0.05,99.999 -20000,0.13631,0.13901,0.05,99.999 -20000,0.139,0.14176,0.05,100 -20000,0.139,0.14176,0.05,100 -20000,0.14175,0.14456,0.05,100 -20000,0.14175,0.14456,0.05,100 -20000,0.14175,0.14456,0.05,100 -20000,0.14455,0.14742,0.05,100 -20000,0.14455,0.14742,0.05,100 -20000,0.14455,0.14742,0.05,100 -20000,0.1474,0.15033,0.05,100 -20000,0.1474,0.15033,0.05,100 -20000,0.1474,0.15033,0.05,100 -20000,0.15032,0.1533,0.05,100 -20000,0.15032,0.1533,0.05,100 -20000,0.15032,0.1533,0.05,100 -20000,0.15329,0.15633,0.05,100 -20000,0.15329,0.15633,0.05,100 -20000,0.15329,0.15633,0.05,100 -20000,0.15632,0.15942,0.05,100 -20000,0.15632,0.15942,0.05,100 -20000,0.15632,0.15942,0.05,100 -20000,0.15941,0.16257,0.05,100 -20000,0.15941,0.16257,0.05,100 -20000,0.15941,0.16257,0.05,100 -20000,0.16256,0.16578,0.05,100 -20000,0.16256,0.16578,0.05,100 -20000,0.16256,0.16578,0.05,100 -20000,0.16577,0.16906,0.05,100 -20000,0.16577,0.16906,0.05,100 -20000,0.16577,0.16906,0.05,100 -20000,0.16577,0.16906,0.05,100 -20000,0.16905,0.1724,0.05,100 -20000,0.16905,0.1724,0.05,100 -20000,0.16905,0.1724,0.05,100 -20000,0.17239,0.1758,0.05,100 -20000,0.17239,0.1758,0.05,100 -20000,0.17239,0.1758,0.05,100 -20000,0.17579,0.17928,0.05,100 -20000,0.17579,0.17928,0.05,100 -20000,0.17579,0.17928,0.05,100 -20000,0.17579,0.17928,0.05,100 -20000,0.17927,0.18282,0.05,100 -20000,0.17927,0.18282,0.05,100 -20000,0.17927,0.18282,0.05,100 -20000,0.18281,0.18644,0.05,100 -20000,0.18281,0.18644,0.05,100 -20000,0.18281,0.18644,0.05,100 -20000,0.18281,0.18644,0.05,100 -20000,0.18643,0.19013,0.05,100 -20000,0.18643,0.19013,0.05,100 -20000,0.18643,0.19013,0.05,100 -20000,0.18643,0.19013,0.05,100 -20000,0.19011,0.19388,0.05,100 -20000,0.19011,0.19388,0.05,100 -20000,0.19011,0.19388,0.05,100 -20000,0.19387,0.19772,0.05,100 -20000,0.19387,0.19772,0.05,100 -20000,0.19387,0.19772,0.05,100 -20000,0.19387,0.19772,0.05,100 -20000,0.19771,0.20163,0.05,100 -20000,0.19771,0.20163,0.05,100 -20000,0.19771,0.20163,0.05,100 -20000,0.19771,0.20163,0.05,100 -20000,0.20162,0.20562,0.05,100 -20000,0.20162,0.20562,0.05,100 -20000,0.20162,0.20562,0.05,100 -20000,0.20162,0.20562,0.05,100 -20000,0.2056,0.20968,0.05,100 -20000,0.2056,0.20968,0.05,100 -20000,0.2056,0.20968,0.05,100 -20000,0.2056,0.20968,0.05,100 -20000,0.20967,0.21383,0.05,100 -20000,0.20967,0.21383,0.05,100 -20000,0.20967,0.21383,0.05,100 -20000,0.20967,0.21383,0.05,100 -20000,0.21382,0.21806,0.05,100 -20000,0.21382,0.21806,0.05,100 -20000,0.21382,0.21806,0.05,100 -20000,0.21382,0.21806,0.05,100 -20000,0.21382,0.21806,0.05,100 -20000,0.21805,0.22237,0.05,100 -20000,0.21805,0.22237,0.05,100 -20000,0.21805,0.22237,0.05,100 -20000,0.21805,0.22237,0.05,100 -20000,0.22236,0.22677,0.05,100 -20000,0.22236,0.22677,0.05,100 -20000,0.22236,0.22677,0.05,100 -20000,0.22236,0.22677,0.05,100 -20000,0.22676,0.23125,0.05,100 -20000,0.22676,0.23125,0.05,100 -20000,0.22676,0.23125,0.05,100 -20000,0.22676,0.23125,0.05,100 -20000,0.22676,0.23125,0.05,100 -20000,0.23124,0.23583,0.05,100 -20000,0.23124,0.23583,0.05,100 -20000,0.23124,0.23583,0.05,100 -20000,0.23124,0.23583,0.05,100 -20000,0.23582,0.2405,0.05,100 -20000,0.23582,0.2405,0.05,100 -20000,0.23582,0.2405,0.05,100 -20000,0.23582,0.2405,0.05,100 -20000,0.23582,0.2405,0.05,100 -20000,0.24048,0.24525,0.05,100 -20000,0.24048,0.24525,0.05,100 -20000,0.24048,0.24525,0.05,100 -20000,0.24048,0.24525,0.05,100 -20000,0.24048,0.24525,0.05,100 -20000,0.24524,0.25011,0.05,100 -20000,0.24524,0.25011,0.05,100 -20000,0.24524,0.25011,0.05,100 -20000,0.24524,0.25011,0.05,100 -20000,0.24524,0.25011,0.05,100 -20000,0.25009,0.25505,0.05,100 -20000,0.25009,0.25505,0.05,100 -20000,0.25009,0.25505,0.05,100 -20000,0.25009,0.25505,0.05,100 -20000,0.25009,0.25505,0.05,100 -20000,0.25504,0.2601,0.05,100 -20000,0.25504,0.2601,0.05,100 -20000,0.25504,0.2601,0.05,100 -20000,0.25504,0.2601,0.05,100 -20000,0.25504,0.2601,0.05,100 -20000,0.26009,0.26525,0.05,100 -20000,0.26009,0.26525,0.05,100 -20000,0.26009,0.26525,0.05,100 -20000,0.26009,0.26525,0.05,100 -20000,0.26009,0.26525,0.05,100 -20000,0.26524,0.2705,0.05,100 -20000,0.26524,0.2705,0.05,100 -20000,0.26524,0.2705,0.05,100 -20000,0.26524,0.2705,0.05,100 -20000,0.26524,0.2705,0.05,100 -20000,0.27048,0.27585,0.05,100 -20000,0.27048,0.27585,0.05,100 -20000,0.27048,0.27585,0.05,100 -20000,0.27048,0.27585,0.05,100 -20000,0.27048,0.27585,0.05,100 -20000,0.27584,0.28131,0.05,100 -20000,0.27584,0.28131,0.05,100 -20000,0.27584,0.28131,0.05,100 -20000,0.27584,0.28131,0.05,100 -20000,0.27584,0.28131,0.05,100 -20000,0.27584,0.28131,0.05,100 -20000,0.2813,0.28687,0.05,100 -20000,0.2813,0.28687,0.05,100 -20000,0.2813,0.28687,0.05,100 -20000,0.2813,0.28687,0.05,100 -20000,0.2813,0.28687,0.05,100 -20000,0.28686,0.29255,0.05,100 -20000,0.28686,0.29255,0.05,100 -20000,0.28686,0.29255,0.05,100 -20000,0.28686,0.29255,0.05,100 -20000,0.28686,0.29255,0.05,100 -20000,0.28686,0.29255,0.05,100 -20000,0.29254,0.29834,0.05,100 -20000,0.29254,0.29834,0.05,100 -20000,0.29254,0.29834,0.05,100 -20000,0.29254,0.29834,0.05,100 -20000,0.29254,0.29834,0.05,100 -20000,0.29254,0.29834,0.05,100 -20000,0.29833,0.30425,0.05,100 -20000,0.29833,0.30425,0.05,100 -20000,0.29833,0.30425,0.05,100 -20000,0.29833,0.30425,0.05,100 -20000,0.29833,0.30425,0.05,100 -20000,0.29833,0.30425,0.05,100 -20000,0.30424,0.31027,0.05,100 -20000,0.30424,0.31027,0.05,100 -20000,0.30424,0.31027,0.05,100 -20000,0.30424,0.31027,0.05,100 -20000,0.30424,0.31027,0.05,100 -20000,0.30424,0.31027,0.05,100 -20000,0.31026,0.31641,0.05,100 -20000,0.31026,0.31641,0.05,100 -20000,0.31026,0.31641,0.05,100 -20000,0.31026,0.31641,0.05,100 -20000,0.31026,0.31641,0.05,100 -20000,0.31026,0.31641,0.05,100 -20000,0.3164,0.32267,0.05,100 -20000,0.3164,0.32267,0.05,100 -20000,0.3164,0.32267,0.05,100 -20000,0.3164,0.32267,0.05,100 -20000,0.3164,0.32267,0.05,100 -20000,0.3164,0.32267,0.05,100 -20000,0.32266,0.32906,0.05,100 -20000,0.32266,0.32906,0.05,100 -20000,0.32266,0.32906,0.05,100 -20000,0.32266,0.32906,0.05,100 -20000,0.32266,0.32906,0.05,100 -20000,0.32266,0.32906,0.05,100 -20000,0.32266,0.32906,0.05,100 -20000,0.32905,0.33558,0.05,100 -20000,0.32905,0.33558,0.05,100 -20000,0.32905,0.33558,0.05,100 -20000,0.32905,0.33558,0.05,100 -20000,0.32905,0.33558,0.05,100 -20000,0.32905,0.33558,0.05,100 -20000,0.33556,0.34222,0.05,100 -20000,0.33556,0.34222,0.05,100 -20000,0.33556,0.34222,0.05,100 -20000,0.33556,0.34222,0.05,100 -20000,0.33556,0.34222,0.05,100 -20000,0.33556,0.34222,0.05,100 -20000,0.33556,0.34222,0.05,100 -20000,0.34221,0.34899,0.05,100 -20000,0.34221,0.34899,0.05,100 -20000,0.34221,0.34899,0.05,100 -20000,0.34221,0.34899,0.05,100 -20000,0.34221,0.34899,0.05,100 -20000,0.34221,0.34899,0.05,100 -20000,0.34221,0.34899,0.05,100 -20000,0.34898,0.3559,0.05,100 -20000,0.34898,0.3559,0.05,100 -20000,0.34898,0.3559,0.05,100 -20000,0.34898,0.3559,0.05,100 -20000,0.34898,0.3559,0.05,100 -20000,0.34898,0.3559,0.05,100 -20000,0.35589,0.36295,0.05,100 -20000,0.35589,0.36295,0.05,100 -20000,0.35589,0.36295,0.05,100 -20000,0.35589,0.36295,0.05,100 -20000,0.35589,0.36295,0.05,100 -20000,0.35589,0.36295,0.05,100 -20000,0.35589,0.36295,0.05,100 -20000,0.36294,0.37013,0.05,100 -20000,0.36294,0.37013,0.05,100 -20000,0.36294,0.37013,0.05,100 -20000,0.36294,0.37013,0.05,100 -20000,0.36294,0.37013,0.05,100 -20000,0.36294,0.37013,0.05,100 -20000,0.36294,0.37013,0.05,100 -20000,0.36294,0.37013,0.05,100 -20000,0.37012,0.37746,0.05,100 -20000,0.37012,0.37746,0.05,100 -20000,0.37012,0.37746,0.05,100 -20000,0.37012,0.37746,0.05,100 -20000,0.37012,0.37746,0.05,100 -20000,0.37012,0.37746,0.05,100 -20000,0.37012,0.37746,0.05,100 -20000,0.37745,0.38494,0.05,100 -20000,0.37745,0.38494,0.05,100 -20000,0.37745,0.38494,0.05,100 -20000,0.37745,0.38494,0.05,100 -20000,0.37745,0.38494,0.05,100 -20000,0.37745,0.38494,0.05,100 -20000,0.37745,0.38494,0.05,100 -20000,0.38493,0.39256,0.05,100 -20000,0.38493,0.39256,0.05,100 -20000,0.38493,0.39256,0.05,100 -20000,0.38493,0.39256,0.05,100 -20000,0.38493,0.39256,0.05,100 -20000,0.38493,0.39256,0.05,100 -20000,0.38493,0.39256,0.05,100 -20000,0.38493,0.39256,0.05,100 -20000,0.39255,0.40033,0.05,100 -20000,0.39255,0.40033,0.05,100 -20000,0.39255,0.40033,0.05,100 -20000,0.39255,0.40033,0.05,100 -20000,0.39255,0.40033,0.05,100 -20000,0.39255,0.40033,0.05,100 -20000,0.39255,0.40033,0.05,100 -20000,0.39255,0.40033,0.05,100 -20000,0.40032,0.40826,0.05,100 -20000,0.40032,0.40826,0.05,100 -20000,0.40032,0.40826,0.05,100 -20000,0.40032,0.40826,0.05,100 -20000,0.40032,0.40826,0.05,100 -20000,0.40032,0.40826,0.05,100 -20000,0.40032,0.40826,0.05,100 -20000,0.40032,0.40826,0.05,100 -20000,0.40825,0.41634,0.05,100 -20000,0.40825,0.41634,0.05,100 -20000,0.40825,0.41634,0.05,100 -20000,0.40825,0.41634,0.05,100 -20000,0.40825,0.41634,0.05,100 -20000,0.40825,0.41634,0.05,100 -20000,0.40825,0.41634,0.05,100 -20000,0.40825,0.41634,0.05,100 -20000,0.41633,0.42459,0.05,100 -20000,0.41633,0.42459,0.05,100 -20000,0.41633,0.42459,0.05,100 -20000,0.41633,0.42459,0.05,100 -20000,0.41633,0.42459,0.05,100 -20000,0.41633,0.42459,0.05,100 -20000,0.41633,0.42459,0.05,100 -20000,0.41633,0.42459,0.05,100 -20000,0.42458,0.433,0.05,100 -20000,0.42458,0.433,0.05,100 -20000,0.42458,0.433,0.05,100 -20000,0.42458,0.433,0.05,100 -20000,0.42458,0.433,0.05,100 -20000,0.42458,0.433,0.05,100 -20000,0.42458,0.433,0.05,100 -20000,0.42458,0.433,0.05,100 -20000,0.42458,0.433,0.05,100 -20000,0.43298,0.44157,0.05,100 -20000,0.43298,0.44157,0.05,100 -20000,0.43298,0.44157,0.05,100 -20000,0.43298,0.44157,0.05,100 -20000,0.43298,0.44157,0.05,100 -20000,0.43298,0.44157,0.05,100 -20000,0.43298,0.44157,0.05,100 -20000,0.43298,0.44157,0.05,100 -20000,0.44156,0.45031,0.05,100 -20000,0.44156,0.45031,0.05,100 -20000,0.44156,0.45031,0.05,100 -20000,0.44156,0.45031,0.05,100 -20000,0.44156,0.45031,0.05,100 -20000,0.44156,0.45031,0.05,100 -20000,0.44156,0.45031,0.05,100 -20000,0.44156,0.45031,0.05,100 -20000,0.44156,0.45031,0.05,100 -20000,0.4503,0.45923,0.05,100 -20000,0.4503,0.45923,0.05,100 -20000,0.4503,0.45923,0.05,100 -20000,0.4503,0.45923,0.05,100 -20000,0.4503,0.45923,0.05,100 -20000,0.4503,0.45923,0.05,100 -20000,0.4503,0.45923,0.05,100 -20000,0.4503,0.45923,0.05,100 -20000,0.4503,0.45923,0.05,100 -20000,0.45922,0.46833,0.05,100 -20000,0.45922,0.46833,0.05,100 -20000,0.45922,0.46833,0.05,100 -20000,0.45922,0.46833,0.05,100 -20000,0.45922,0.46833,0.05,100 -20000,0.45922,0.46833,0.05,100 -20000,0.45922,0.46833,0.05,100 -20000,0.45922,0.46833,0.05,100 -20000,0.45922,0.46833,0.05,100 -20000,0.46832,0.4776,0.05,100 -20000,0.46832,0.4776,0.05,100 -20000,0.46832,0.4776,0.05,100 -20000,0.46832,0.4776,0.05,100 -20000,0.46832,0.4776,0.05,100 -20000,0.46832,0.4776,0.05,100 -20000,0.46832,0.4776,0.05,100 -20000,0.46832,0.4776,0.05,100 -20000,0.46832,0.4776,0.05,100 -20000,0.47759,0.48706,0.05,100 -20000,0.47759,0.48706,0.05,100 -20000,0.47759,0.48706,0.05,100 -20000,0.47759,0.48706,0.05,100 -20000,0.47759,0.48706,0.05,100 -20000,0.47759,0.48706,0.05,100 -20000,0.47759,0.48706,0.05,100 -20000,0.47759,0.48706,0.05,100 -20000,0.47759,0.48706,0.05,100 -20000,0.47759,0.48706,0.05,100 -20000,0.48705,0.49671,0.05,100 -20000,0.48705,0.49671,0.05,100 -20000,0.48705,0.49671,0.05,100 -20000,0.48705,0.49671,0.05,100 -20000,0.48705,0.49671,0.05,100 -20000,0.48705,0.49671,0.05,100 -20000,0.48705,0.49671,0.05,100 -20000,0.48705,0.49671,0.05,100 -20000,0.48705,0.49671,0.05,100 -20000,0.4967,0.50655,0.05,100 -20000,0.4967,0.50655,0.05,100 -20000,0.4967,0.50655,0.05,100 -20000,0.4967,0.50655,0.05,100 -20000,0.4967,0.50655,0.05,100 -20000,0.4967,0.50655,0.05,100 -20000,0.4967,0.50655,0.05,100 -20000,0.4967,0.50655,0.05,100 -20000,0.4967,0.50655,0.05,100 -20000,0.4967,0.50655,0.05,100 -20000,0.50654,0.51658,0.05,100 -20000,0.50654,0.51658,0.05,100 -20000,0.50654,0.51658,0.05,100 -20000,0.50654,0.51658,0.05,100 -20000,0.50654,0.51658,0.05,100 -20000,0.50654,0.51658,0.05,100 -20000,0.50654,0.51658,0.05,100 -20000,0.50654,0.51658,0.05,100 -20000,0.50654,0.51658,0.05,100 -20000,0.50654,0.51658,0.05,100 -20000,0.51657,0.52681,0.05,100 -20000,0.51657,0.52681,0.05,100 -20000,0.51657,0.52681,0.05,100 -20000,0.51657,0.52681,0.05,100 -20000,0.51657,0.52681,0.05,100 -20000,0.51657,0.52681,0.05,100 -20000,0.51657,0.52681,0.05,100 -20000,0.51657,0.52681,0.05,100 -20000,0.51657,0.52681,0.05,100 -20000,0.51657,0.52681,0.05,100 -20000,0.5268,0.53725,0.05,100 -20000,0.5268,0.53725,0.05,100 -20000,0.5268,0.53725,0.05,100 -20000,0.5268,0.53725,0.05,100 -20000,0.5268,0.53725,0.05,100 -20000,0.5268,0.53725,0.05,100 -20000,0.5268,0.53725,0.05,100 -20000,0.5268,0.53725,0.05,100 -20000,0.5268,0.53725,0.05,100 -20000,0.5268,0.53725,0.05,100 -20000,0.5268,0.53725,0.05,100 -20000,0.53724,0.54789,0.05,100 -20000,0.53724,0.54789,0.05,100 -20000,0.53724,0.54789,0.05,100 -20000,0.53724,0.54789,0.05,100 -20000,0.53724,0.54789,0.05,100 -20000,0.53724,0.54789,0.05,100 -20000,0.53724,0.54789,0.05,100 -20000,0.53724,0.54789,0.05,100 -20000,0.53724,0.54789,0.05,100 -20000,0.53724,0.54789,0.05,100 -20000,0.54788,0.55874,0.05,100 -20000,0.54788,0.55874,0.05,100 -20000,0.54788,0.55874,0.05,100 -20000,0.54788,0.55874,0.05,100 -20000,0.54788,0.55874,0.05,100 -20000,0.54788,0.55874,0.05,100 -20000,0.54788,0.55874,0.05,100 -20000,0.54788,0.55874,0.05,100 -20000,0.54788,0.55874,0.05,100 -20000,0.54788,0.55874,0.05,100 -20000,0.54788,0.55874,0.05,100 -20000,0.55873,0.56981,0.05,100 -20000,0.55873,0.56981,0.05,100 -20000,0.55873,0.56981,0.05,100 -20000,0.55873,0.56981,0.05,100 -20000,0.55873,0.56981,0.05,100 -20000,0.55873,0.56981,0.05,100 -20000,0.55873,0.56981,0.05,100 -20000,0.55873,0.56981,0.05,100 -20000,0.55873,0.56981,0.05,100 -20000,0.55873,0.56981,0.05,100 -20000,0.55873,0.56981,0.05,100 -20000,0.5698,0.5811,0.05,100 -20000,0.5698,0.5811,0.05,100 -20000,0.5698,0.5811,0.05,100 -20000,0.5698,0.5811,0.05,100 -20000,0.5698,0.5811,0.05,100 -20000,0.5698,0.5811,0.05,100 -20000,0.5698,0.5811,0.05,100 -20000,0.5698,0.5811,0.05,100 -20000,0.5698,0.5811,0.05,100 -20000,0.5698,0.5811,0.05,100 -20000,0.5698,0.5811,0.05,100 -20000,0.5698,0.5811,0.05,100 -20000,0.58109,0.59261,0.05,100 -20000,0.58109,0.59261,0.05,100 -20000,0.58109,0.59261,0.05,100 -20000,0.58109,0.59261,0.05,100 -20000,0.58109,0.59261,0.05,100 -20000,0.58109,0.59261,0.05,100 -20000,0.58109,0.59261,0.05,100 -20000,0.58109,0.59261,0.05,100 -20000,0.58109,0.59261,0.05,100 -20000,0.58109,0.59261,0.05,100 -20000,0.58109,0.59261,0.05,100 -20000,0.5926,0.60435,0.05,100 -20000,0.5926,0.60435,0.05,100 -20000,0.5926,0.60435,0.05,100 -20000,0.5926,0.60435,0.05,100 -20000,0.5926,0.60435,0.05,100 -20000,0.5926,0.60435,0.05,100 -20000,0.5926,0.60435,0.05,100 -20000,0.5926,0.60435,0.05,100 -20000,0.5926,0.60435,0.05,100 -20000,0.5926,0.60435,0.05,100 -20000,0.5926,0.60435,0.05,100 -20000,0.5926,0.60435,0.05,100 -20000,0.60434,0.61632,0.05,100 -20000,0.60434,0.61632,0.05,100 -20000,0.60434,0.61632,0.05,100 -20000,0.60434,0.61632,0.05,100 -20000,0.60434,0.61632,0.05,100 -20000,0.60434,0.61632,0.05,100 -20000,0.60434,0.61632,0.05,100 -20000,0.60434,0.61632,0.05,100 -20000,0.60434,0.61632,0.05,100 -20000,0.60434,0.61632,0.05,100 -20000,0.60434,0.61632,0.05,100 -20000,0.60434,0.61632,0.05,100 -20000,0.61631,0.62853,0.05,100 -20000,0.61631,0.62853,0.05,100 -20000,0.61631,0.62853,0.05,100 -20000,0.61631,0.62853,0.05,100 -20000,0.61631,0.62853,0.05,100 -20000,0.61631,0.62853,0.05,100 -20000,0.61631,0.62853,0.05,100 -20000,0.61631,0.62853,0.05,100 -20000,0.61631,0.62853,0.05,100 -20000,0.61631,0.62853,0.05,100 -20000,0.61631,0.62853,0.05,100 -20000,0.61631,0.62853,0.05,100 -20000,0.62852,0.64098,0.05,100 -20000,0.62852,0.64098,0.05,100 -20000,0.62852,0.64098,0.05,100 -20000,0.62852,0.64098,0.05,100 -20000,0.62852,0.64098,0.05,100 -20000,0.62852,0.64098,0.05,100 -20000,0.62852,0.64098,0.05,100 -20000,0.62852,0.64098,0.05,100 -20000,0.62852,0.64098,0.05,100 -20000,0.62852,0.64098,0.05,100 -20000,0.62852,0.64098,0.05,100 -20000,0.62852,0.64098,0.05,100 -20000,0.62852,0.64098,0.05,100 -20000,0.64097,0.65368,0.05,100 -20000,0.64097,0.65368,0.05,100 -20000,0.64097,0.65368,0.05,100 -20000,0.64097,0.65368,0.05,100 -20000,0.64097,0.65368,0.05,100 -20000,0.64097,0.65368,0.05,100 -20000,0.64097,0.65368,0.05,100 -20000,0.64097,0.65368,0.05,100 -20000,0.64097,0.65368,0.05,100 -20000,0.64097,0.65368,0.05,100 -20000,0.64097,0.65368,0.05,100 -20000,0.64097,0.65368,0.05,100 -20000,0.65367,0.66663,0.05,100 -20000,0.65367,0.66663,0.05,100 -20000,0.65367,0.66663,0.05,100 -20000,0.65367,0.66663,0.05,100 -20000,0.65367,0.66663,0.05,100 -20000,0.65367,0.66663,0.05,100 -20000,0.65367,0.66663,0.05,100 -20000,0.65367,0.66663,0.05,100 -20000,0.65367,0.66663,0.05,100 -20000,0.65367,0.66663,0.05,100 -20000,0.65367,0.66663,0.05,100 -20000,0.65367,0.66663,0.05,100 -20000,0.65367,0.66663,0.05,100 -20000,0.66662,0.67984,0.05,100 -20000,0.66662,0.67984,0.05,100 -20000,0.66662,0.67984,0.05,100 -20000,0.66662,0.67984,0.05,100 -20000,0.66662,0.67984,0.05,100 -20000,0.66662,0.67984,0.05,100 -20000,0.66662,0.67984,0.05,100 -20000,0.66662,0.67984,0.05,100 -20000,0.66662,0.67984,0.05,100 -20000,0.66662,0.67984,0.05,100 -20000,0.66662,0.67984,0.05,100 -20000,0.66662,0.67984,0.05,100 -20000,0.66662,0.67984,0.05,100 -20000,0.67983,0.69331,0.05,100 -20000,0.67983,0.69331,0.05,100 -20000,0.67983,0.69331,0.05,100 -20000,0.67983,0.69331,0.05,100 -20000,0.67983,0.69331,0.05,100 -20000,0.67983,0.69331,0.05,100 -20000,0.67983,0.69331,0.05,100 -20000,0.67983,0.69331,0.05,100 -20000,0.67983,0.69331,0.05,100 -20000,0.67983,0.69331,0.05,100 -20000,0.67983,0.69331,0.05,100 -20000,0.67983,0.69331,0.05,100 -20000,0.67983,0.69331,0.05,100 -20000,0.67983,0.69331,0.05,100 -20000,0.6933,0.70704,0.05,100 -20000,0.6933,0.70704,0.05,100 -20000,0.6933,0.70704,0.05,100 -20000,0.6933,0.70704,0.05,100 -20000,0.6933,0.70704,0.05,100 -20000,0.6933,0.70704,0.05,100 -20000,0.6933,0.70704,0.05,100 -20000,0.6933,0.70704,0.05,100 -20000,0.6933,0.70704,0.05,100 -20000,0.6933,0.70704,0.05,100 -20000,0.6933,0.70704,0.05,100 -20000,0.6933,0.70704,0.05,100 -20000,0.6933,0.70704,0.05,100 -20000,0.6933,0.70704,0.05,100 -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan -20000,nan,nan,nan,nan diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_5.csv b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_5.csv deleted file mode 100644 index c4a1fbb52a2..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/data_5.csv +++ /dev/null @@ -1,1002 +0,0 @@ -Time,"elementCenter:0","elementCenter:1","elementCenter:2","temperature" -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,0.07071,0.072112,0.05,-16.946 -50000,0.07071,0.072112,0.05,-16.946 -50000,0.07211,0.07354,0.05,-10.957 -50000,0.07351,0.074968,0.05,-5.0805 -50000,0.075155,0.076646,0.05,1.6961 -50000,0.075155,0.076646,0.05,1.6961 -50000,0.077046,0.078574,0.05,9.2828 -50000,0.077046,0.078574,0.05,9.2828 -50000,0.078936,0.080501,0.05,16.663 -50000,0.078936,0.080501,0.05,16.663 -50000,0.080826,0.082429,0.05,23.824 -50000,0.080826,0.082429,0.05,23.824 -50000,0.082716,0.084357,0.05,30.745 -50000,0.082716,0.084357,0.05,30.745 -50000,0.084607,0.086285,0.05,37.403 -50000,0.084607,0.086285,0.05,37.403 -50000,0.086497,0.088212,0.05,43.771 -50000,0.086497,0.088212,0.05,43.771 -50000,0.088387,0.09014,0.05,49.822 -50000,0.088387,0.09014,0.05,49.822 -50000,0.090278,0.092068,0.05,55.527 -50000,0.090278,0.092068,0.05,55.527 -50000,0.092168,0.093995,0.05,60.865 -50000,0.092168,0.093995,0.05,60.865 -50000,0.094031,0.095896,0.05,65.743 -50000,0.095885,0.097786,0.05,70.214 -50000,0.095885,0.097786,0.05,70.214 -50000,0.097776,0.099715,0.05,74.369 -50000,0.097776,0.099715,0.05,74.369 -50000,0.099704,0.10168,0.05,78.184 -50000,0.099704,0.10168,0.05,78.184 -50000,0.10167,0.10369,0.05,81.643 -50000,0.10167,0.10369,0.05,81.643 -50000,0.10368,0.10573,0.05,84.738 -50000,0.10368,0.10573,0.05,84.738 -50000,0.10572,0.10782,0.05,87.469 -50000,0.10572,0.10782,0.05,87.469 -50000,0.10781,0.10995,0.05,89.844 -50000,0.10781,0.10995,0.05,89.844 -50000,0.10993,0.11211,0.05,91.879 -50000,0.10993,0.11211,0.05,91.879 -50000,0.10993,0.11211,0.05,91.879 -50000,0.1121,0.11433,0.05,93.596 -50000,0.1121,0.11433,0.05,93.596 -50000,0.11432,0.11658,0.05,95.022 -50000,0.11432,0.11658,0.05,95.022 -50000,0.11657,0.11888,0.05,96.186 -50000,0.11657,0.11888,0.05,96.186 -50000,0.11887,0.12123,0.05,97.123 -50000,0.11887,0.12123,0.05,97.123 -50000,0.11887,0.12123,0.05,97.123 -50000,0.12122,0.12362,0.05,97.862 -50000,0.12122,0.12362,0.05,97.862 -50000,0.12361,0.12607,0.05,98.437 -50000,0.12361,0.12607,0.05,98.437 -50000,0.12361,0.12607,0.05,98.437 -50000,0.12605,0.12855,0.05,98.876 -50000,0.12605,0.12855,0.05,98.876 -50000,0.12854,0.13109,0.05,99.205 -50000,0.12854,0.13109,0.05,99.205 -50000,0.12854,0.13109,0.05,99.205 -50000,0.13108,0.13368,0.05,99.448 -50000,0.13108,0.13368,0.05,99.448 -50000,0.13367,0.13632,0.05,99.623 -50000,0.13367,0.13632,0.05,99.623 -50000,0.13367,0.13632,0.05,99.623 -50000,0.13631,0.13901,0.05,99.747 -50000,0.13631,0.13901,0.05,99.747 -50000,0.13631,0.13901,0.05,99.747 -50000,0.139,0.14176,0.05,99.834 -50000,0.139,0.14176,0.05,99.834 -50000,0.14175,0.14456,0.05,99.893 -50000,0.14175,0.14456,0.05,99.893 -50000,0.14175,0.14456,0.05,99.893 -50000,0.14455,0.14742,0.05,99.932 -50000,0.14455,0.14742,0.05,99.932 -50000,0.14455,0.14742,0.05,99.932 -50000,0.1474,0.15033,0.05,99.958 -50000,0.1474,0.15033,0.05,99.958 -50000,0.1474,0.15033,0.05,99.958 -50000,0.15032,0.1533,0.05,99.975 -50000,0.15032,0.1533,0.05,99.975 -50000,0.15032,0.1533,0.05,99.975 -50000,0.15329,0.15633,0.05,99.985 -50000,0.15329,0.15633,0.05,99.985 -50000,0.15329,0.15633,0.05,99.985 -50000,0.15632,0.15942,0.05,99.991 -50000,0.15632,0.15942,0.05,99.991 -50000,0.15632,0.15942,0.05,99.991 -50000,0.15941,0.16257,0.05,99.995 -50000,0.15941,0.16257,0.05,99.995 -50000,0.15941,0.16257,0.05,99.995 -50000,0.16256,0.16578,0.05,99.997 -50000,0.16256,0.16578,0.05,99.997 -50000,0.16256,0.16578,0.05,99.997 -50000,0.16577,0.16906,0.05,99.999 -50000,0.16577,0.16906,0.05,99.999 -50000,0.16577,0.16906,0.05,99.999 -50000,0.16577,0.16906,0.05,99.999 -50000,0.16905,0.1724,0.05,99.999 -50000,0.16905,0.1724,0.05,99.999 -50000,0.16905,0.1724,0.05,99.999 -50000,0.17239,0.1758,0.05,100 -50000,0.17239,0.1758,0.05,100 -50000,0.17239,0.1758,0.05,100 -50000,0.17579,0.17928,0.05,100 -50000,0.17579,0.17928,0.05,100 -50000,0.17579,0.17928,0.05,100 -50000,0.17579,0.17928,0.05,100 -50000,0.17927,0.18282,0.05,100 -50000,0.17927,0.18282,0.05,100 -50000,0.17927,0.18282,0.05,100 -50000,0.18281,0.18644,0.05,100 -50000,0.18281,0.18644,0.05,100 -50000,0.18281,0.18644,0.05,100 -50000,0.18281,0.18644,0.05,100 -50000,0.18643,0.19013,0.05,100 -50000,0.18643,0.19013,0.05,100 -50000,0.18643,0.19013,0.05,100 -50000,0.18643,0.19013,0.05,100 -50000,0.19011,0.19388,0.05,100 -50000,0.19011,0.19388,0.05,100 -50000,0.19011,0.19388,0.05,100 -50000,0.19387,0.19772,0.05,100 -50000,0.19387,0.19772,0.05,100 -50000,0.19387,0.19772,0.05,100 -50000,0.19387,0.19772,0.05,100 -50000,0.19771,0.20163,0.05,100 -50000,0.19771,0.20163,0.05,100 -50000,0.19771,0.20163,0.05,100 -50000,0.19771,0.20163,0.05,100 -50000,0.20162,0.20562,0.05,100 -50000,0.20162,0.20562,0.05,100 -50000,0.20162,0.20562,0.05,100 -50000,0.20162,0.20562,0.05,100 -50000,0.2056,0.20968,0.05,100 -50000,0.2056,0.20968,0.05,100 -50000,0.2056,0.20968,0.05,100 -50000,0.2056,0.20968,0.05,100 -50000,0.20967,0.21383,0.05,100 -50000,0.20967,0.21383,0.05,100 -50000,0.20967,0.21383,0.05,100 -50000,0.20967,0.21383,0.05,100 -50000,0.21382,0.21806,0.05,100 -50000,0.21382,0.21806,0.05,100 -50000,0.21382,0.21806,0.05,100 -50000,0.21382,0.21806,0.05,100 -50000,0.21382,0.21806,0.05,100 -50000,0.21805,0.22237,0.05,100 -50000,0.21805,0.22237,0.05,100 -50000,0.21805,0.22237,0.05,100 -50000,0.21805,0.22237,0.05,100 -50000,0.22236,0.22677,0.05,100 -50000,0.22236,0.22677,0.05,100 -50000,0.22236,0.22677,0.05,100 -50000,0.22236,0.22677,0.05,100 -50000,0.22676,0.23125,0.05,100 -50000,0.22676,0.23125,0.05,100 -50000,0.22676,0.23125,0.05,100 -50000,0.22676,0.23125,0.05,100 -50000,0.22676,0.23125,0.05,100 -50000,0.23124,0.23583,0.05,100 -50000,0.23124,0.23583,0.05,100 -50000,0.23124,0.23583,0.05,100 -50000,0.23124,0.23583,0.05,100 -50000,0.23582,0.2405,0.05,100 -50000,0.23582,0.2405,0.05,100 -50000,0.23582,0.2405,0.05,100 -50000,0.23582,0.2405,0.05,100 -50000,0.23582,0.2405,0.05,100 -50000,0.24048,0.24525,0.05,100 -50000,0.24048,0.24525,0.05,100 -50000,0.24048,0.24525,0.05,100 -50000,0.24048,0.24525,0.05,100 -50000,0.24048,0.24525,0.05,100 -50000,0.24524,0.25011,0.05,100 -50000,0.24524,0.25011,0.05,100 -50000,0.24524,0.25011,0.05,100 -50000,0.24524,0.25011,0.05,100 -50000,0.24524,0.25011,0.05,100 -50000,0.25009,0.25505,0.05,100 -50000,0.25009,0.25505,0.05,100 -50000,0.25009,0.25505,0.05,100 -50000,0.25009,0.25505,0.05,100 -50000,0.25009,0.25505,0.05,100 -50000,0.25504,0.2601,0.05,100 -50000,0.25504,0.2601,0.05,100 -50000,0.25504,0.2601,0.05,100 -50000,0.25504,0.2601,0.05,100 -50000,0.25504,0.2601,0.05,100 -50000,0.26009,0.26525,0.05,100 -50000,0.26009,0.26525,0.05,100 -50000,0.26009,0.26525,0.05,100 -50000,0.26009,0.26525,0.05,100 -50000,0.26009,0.26525,0.05,100 -50000,0.26524,0.2705,0.05,100 -50000,0.26524,0.2705,0.05,100 -50000,0.26524,0.2705,0.05,100 -50000,0.26524,0.2705,0.05,100 -50000,0.26524,0.2705,0.05,100 -50000,0.27048,0.27585,0.05,100 -50000,0.27048,0.27585,0.05,100 -50000,0.27048,0.27585,0.05,100 -50000,0.27048,0.27585,0.05,100 -50000,0.27048,0.27585,0.05,100 -50000,0.27584,0.28131,0.05,100 -50000,0.27584,0.28131,0.05,100 -50000,0.27584,0.28131,0.05,100 -50000,0.27584,0.28131,0.05,100 -50000,0.27584,0.28131,0.05,100 -50000,0.27584,0.28131,0.05,100 -50000,0.2813,0.28687,0.05,100 -50000,0.2813,0.28687,0.05,100 -50000,0.2813,0.28687,0.05,100 -50000,0.2813,0.28687,0.05,100 -50000,0.2813,0.28687,0.05,100 -50000,0.28686,0.29255,0.05,100 -50000,0.28686,0.29255,0.05,100 -50000,0.28686,0.29255,0.05,100 -50000,0.28686,0.29255,0.05,100 -50000,0.28686,0.29255,0.05,100 -50000,0.28686,0.29255,0.05,100 -50000,0.29254,0.29834,0.05,100 -50000,0.29254,0.29834,0.05,100 -50000,0.29254,0.29834,0.05,100 -50000,0.29254,0.29834,0.05,100 -50000,0.29254,0.29834,0.05,100 -50000,0.29254,0.29834,0.05,100 -50000,0.29833,0.30425,0.05,100 -50000,0.29833,0.30425,0.05,100 -50000,0.29833,0.30425,0.05,100 -50000,0.29833,0.30425,0.05,100 -50000,0.29833,0.30425,0.05,100 -50000,0.29833,0.30425,0.05,100 -50000,0.30424,0.31027,0.05,100 -50000,0.30424,0.31027,0.05,100 -50000,0.30424,0.31027,0.05,100 -50000,0.30424,0.31027,0.05,100 -50000,0.30424,0.31027,0.05,100 -50000,0.30424,0.31027,0.05,100 -50000,0.31026,0.31641,0.05,100 -50000,0.31026,0.31641,0.05,100 -50000,0.31026,0.31641,0.05,100 -50000,0.31026,0.31641,0.05,100 -50000,0.31026,0.31641,0.05,100 -50000,0.31026,0.31641,0.05,100 -50000,0.3164,0.32267,0.05,100 -50000,0.3164,0.32267,0.05,100 -50000,0.3164,0.32267,0.05,100 -50000,0.3164,0.32267,0.05,100 -50000,0.3164,0.32267,0.05,100 -50000,0.3164,0.32267,0.05,100 -50000,0.32266,0.32906,0.05,100 -50000,0.32266,0.32906,0.05,100 -50000,0.32266,0.32906,0.05,100 -50000,0.32266,0.32906,0.05,100 -50000,0.32266,0.32906,0.05,100 -50000,0.32266,0.32906,0.05,100 -50000,0.32266,0.32906,0.05,100 -50000,0.32905,0.33558,0.05,100 -50000,0.32905,0.33558,0.05,100 -50000,0.32905,0.33558,0.05,100 -50000,0.32905,0.33558,0.05,100 -50000,0.32905,0.33558,0.05,100 -50000,0.32905,0.33558,0.05,100 -50000,0.33556,0.34222,0.05,100 -50000,0.33556,0.34222,0.05,100 -50000,0.33556,0.34222,0.05,100 -50000,0.33556,0.34222,0.05,100 -50000,0.33556,0.34222,0.05,100 -50000,0.33556,0.34222,0.05,100 -50000,0.33556,0.34222,0.05,100 -50000,0.34221,0.34899,0.05,100 -50000,0.34221,0.34899,0.05,100 -50000,0.34221,0.34899,0.05,100 -50000,0.34221,0.34899,0.05,100 -50000,0.34221,0.34899,0.05,100 -50000,0.34221,0.34899,0.05,100 -50000,0.34221,0.34899,0.05,100 -50000,0.34898,0.3559,0.05,100 -50000,0.34898,0.3559,0.05,100 -50000,0.34898,0.3559,0.05,100 -50000,0.34898,0.3559,0.05,100 -50000,0.34898,0.3559,0.05,100 -50000,0.34898,0.3559,0.05,100 -50000,0.35589,0.36295,0.05,100 -50000,0.35589,0.36295,0.05,100 -50000,0.35589,0.36295,0.05,100 -50000,0.35589,0.36295,0.05,100 -50000,0.35589,0.36295,0.05,100 -50000,0.35589,0.36295,0.05,100 -50000,0.35589,0.36295,0.05,100 -50000,0.36294,0.37013,0.05,100 -50000,0.36294,0.37013,0.05,100 -50000,0.36294,0.37013,0.05,100 -50000,0.36294,0.37013,0.05,100 -50000,0.36294,0.37013,0.05,100 -50000,0.36294,0.37013,0.05,100 -50000,0.36294,0.37013,0.05,100 -50000,0.36294,0.37013,0.05,100 -50000,0.37012,0.37746,0.05,100 -50000,0.37012,0.37746,0.05,100 -50000,0.37012,0.37746,0.05,100 -50000,0.37012,0.37746,0.05,100 -50000,0.37012,0.37746,0.05,100 -50000,0.37012,0.37746,0.05,100 -50000,0.37012,0.37746,0.05,100 -50000,0.37745,0.38494,0.05,100 -50000,0.37745,0.38494,0.05,100 -50000,0.37745,0.38494,0.05,100 -50000,0.37745,0.38494,0.05,100 -50000,0.37745,0.38494,0.05,100 -50000,0.37745,0.38494,0.05,100 -50000,0.37745,0.38494,0.05,100 -50000,0.38493,0.39256,0.05,100 -50000,0.38493,0.39256,0.05,100 -50000,0.38493,0.39256,0.05,100 -50000,0.38493,0.39256,0.05,100 -50000,0.38493,0.39256,0.05,100 -50000,0.38493,0.39256,0.05,100 -50000,0.38493,0.39256,0.05,100 -50000,0.38493,0.39256,0.05,100 -50000,0.39255,0.40033,0.05,100 -50000,0.39255,0.40033,0.05,100 -50000,0.39255,0.40033,0.05,100 -50000,0.39255,0.40033,0.05,100 -50000,0.39255,0.40033,0.05,100 -50000,0.39255,0.40033,0.05,100 -50000,0.39255,0.40033,0.05,100 -50000,0.39255,0.40033,0.05,100 -50000,0.40032,0.40826,0.05,100 -50000,0.40032,0.40826,0.05,100 -50000,0.40032,0.40826,0.05,100 -50000,0.40032,0.40826,0.05,100 -50000,0.40032,0.40826,0.05,100 -50000,0.40032,0.40826,0.05,100 -50000,0.40032,0.40826,0.05,100 -50000,0.40032,0.40826,0.05,100 -50000,0.40825,0.41634,0.05,100 -50000,0.40825,0.41634,0.05,100 -50000,0.40825,0.41634,0.05,100 -50000,0.40825,0.41634,0.05,100 -50000,0.40825,0.41634,0.05,100 -50000,0.40825,0.41634,0.05,100 -50000,0.40825,0.41634,0.05,100 -50000,0.40825,0.41634,0.05,100 -50000,0.41633,0.42459,0.05,100 -50000,0.41633,0.42459,0.05,100 -50000,0.41633,0.42459,0.05,100 -50000,0.41633,0.42459,0.05,100 -50000,0.41633,0.42459,0.05,100 -50000,0.41633,0.42459,0.05,100 -50000,0.41633,0.42459,0.05,100 -50000,0.41633,0.42459,0.05,100 -50000,0.42458,0.433,0.05,100 -50000,0.42458,0.433,0.05,100 -50000,0.42458,0.433,0.05,100 -50000,0.42458,0.433,0.05,100 -50000,0.42458,0.433,0.05,100 -50000,0.42458,0.433,0.05,100 -50000,0.42458,0.433,0.05,100 -50000,0.42458,0.433,0.05,100 -50000,0.42458,0.433,0.05,100 -50000,0.43298,0.44157,0.05,100 -50000,0.43298,0.44157,0.05,100 -50000,0.43298,0.44157,0.05,100 -50000,0.43298,0.44157,0.05,100 -50000,0.43298,0.44157,0.05,100 -50000,0.43298,0.44157,0.05,100 -50000,0.43298,0.44157,0.05,100 -50000,0.43298,0.44157,0.05,100 -50000,0.44156,0.45031,0.05,100 -50000,0.44156,0.45031,0.05,100 -50000,0.44156,0.45031,0.05,100 -50000,0.44156,0.45031,0.05,100 -50000,0.44156,0.45031,0.05,100 -50000,0.44156,0.45031,0.05,100 -50000,0.44156,0.45031,0.05,100 -50000,0.44156,0.45031,0.05,100 -50000,0.44156,0.45031,0.05,100 -50000,0.4503,0.45923,0.05,100 -50000,0.4503,0.45923,0.05,100 -50000,0.4503,0.45923,0.05,100 -50000,0.4503,0.45923,0.05,100 -50000,0.4503,0.45923,0.05,100 -50000,0.4503,0.45923,0.05,100 -50000,0.4503,0.45923,0.05,100 -50000,0.4503,0.45923,0.05,100 -50000,0.4503,0.45923,0.05,100 -50000,0.45922,0.46833,0.05,100 -50000,0.45922,0.46833,0.05,100 -50000,0.45922,0.46833,0.05,100 -50000,0.45922,0.46833,0.05,100 -50000,0.45922,0.46833,0.05,100 -50000,0.45922,0.46833,0.05,100 -50000,0.45922,0.46833,0.05,100 -50000,0.45922,0.46833,0.05,100 -50000,0.45922,0.46833,0.05,100 -50000,0.46832,0.4776,0.05,100 -50000,0.46832,0.4776,0.05,100 -50000,0.46832,0.4776,0.05,100 -50000,0.46832,0.4776,0.05,100 -50000,0.46832,0.4776,0.05,100 -50000,0.46832,0.4776,0.05,100 -50000,0.46832,0.4776,0.05,100 -50000,0.46832,0.4776,0.05,100 -50000,0.46832,0.4776,0.05,100 -50000,0.47759,0.48706,0.05,100 -50000,0.47759,0.48706,0.05,100 -50000,0.47759,0.48706,0.05,100 -50000,0.47759,0.48706,0.05,100 -50000,0.47759,0.48706,0.05,100 -50000,0.47759,0.48706,0.05,100 -50000,0.47759,0.48706,0.05,100 -50000,0.47759,0.48706,0.05,100 -50000,0.47759,0.48706,0.05,100 -50000,0.47759,0.48706,0.05,100 -50000,0.48705,0.49671,0.05,100 -50000,0.48705,0.49671,0.05,100 -50000,0.48705,0.49671,0.05,100 -50000,0.48705,0.49671,0.05,100 -50000,0.48705,0.49671,0.05,100 -50000,0.48705,0.49671,0.05,100 -50000,0.48705,0.49671,0.05,100 -50000,0.48705,0.49671,0.05,100 -50000,0.48705,0.49671,0.05,100 -50000,0.4967,0.50655,0.05,100 -50000,0.4967,0.50655,0.05,100 -50000,0.4967,0.50655,0.05,100 -50000,0.4967,0.50655,0.05,100 -50000,0.4967,0.50655,0.05,100 -50000,0.4967,0.50655,0.05,100 -50000,0.4967,0.50655,0.05,100 -50000,0.4967,0.50655,0.05,100 -50000,0.4967,0.50655,0.05,100 -50000,0.4967,0.50655,0.05,100 -50000,0.50654,0.51658,0.05,100 -50000,0.50654,0.51658,0.05,100 -50000,0.50654,0.51658,0.05,100 -50000,0.50654,0.51658,0.05,100 -50000,0.50654,0.51658,0.05,100 -50000,0.50654,0.51658,0.05,100 -50000,0.50654,0.51658,0.05,100 -50000,0.50654,0.51658,0.05,100 -50000,0.50654,0.51658,0.05,100 -50000,0.50654,0.51658,0.05,100 -50000,0.51657,0.52681,0.05,100 -50000,0.51657,0.52681,0.05,100 -50000,0.51657,0.52681,0.05,100 -50000,0.51657,0.52681,0.05,100 -50000,0.51657,0.52681,0.05,100 -50000,0.51657,0.52681,0.05,100 -50000,0.51657,0.52681,0.05,100 -50000,0.51657,0.52681,0.05,100 -50000,0.51657,0.52681,0.05,100 -50000,0.51657,0.52681,0.05,100 -50000,0.5268,0.53725,0.05,100 -50000,0.5268,0.53725,0.05,100 -50000,0.5268,0.53725,0.05,100 -50000,0.5268,0.53725,0.05,100 -50000,0.5268,0.53725,0.05,100 -50000,0.5268,0.53725,0.05,100 -50000,0.5268,0.53725,0.05,100 -50000,0.5268,0.53725,0.05,100 -50000,0.5268,0.53725,0.05,100 -50000,0.5268,0.53725,0.05,100 -50000,0.5268,0.53725,0.05,100 -50000,0.53724,0.54789,0.05,100 -50000,0.53724,0.54789,0.05,100 -50000,0.53724,0.54789,0.05,100 -50000,0.53724,0.54789,0.05,100 -50000,0.53724,0.54789,0.05,100 -50000,0.53724,0.54789,0.05,100 -50000,0.53724,0.54789,0.05,100 -50000,0.53724,0.54789,0.05,100 -50000,0.53724,0.54789,0.05,100 -50000,0.53724,0.54789,0.05,100 -50000,0.54788,0.55874,0.05,100 -50000,0.54788,0.55874,0.05,100 -50000,0.54788,0.55874,0.05,100 -50000,0.54788,0.55874,0.05,100 -50000,0.54788,0.55874,0.05,100 -50000,0.54788,0.55874,0.05,100 -50000,0.54788,0.55874,0.05,100 -50000,0.54788,0.55874,0.05,100 -50000,0.54788,0.55874,0.05,100 -50000,0.54788,0.55874,0.05,100 -50000,0.54788,0.55874,0.05,100 -50000,0.55873,0.56981,0.05,100 -50000,0.55873,0.56981,0.05,100 -50000,0.55873,0.56981,0.05,100 -50000,0.55873,0.56981,0.05,100 -50000,0.55873,0.56981,0.05,100 -50000,0.55873,0.56981,0.05,100 -50000,0.55873,0.56981,0.05,100 -50000,0.55873,0.56981,0.05,100 -50000,0.55873,0.56981,0.05,100 -50000,0.55873,0.56981,0.05,100 -50000,0.55873,0.56981,0.05,100 -50000,0.5698,0.5811,0.05,100 -50000,0.5698,0.5811,0.05,100 -50000,0.5698,0.5811,0.05,100 -50000,0.5698,0.5811,0.05,100 -50000,0.5698,0.5811,0.05,100 -50000,0.5698,0.5811,0.05,100 -50000,0.5698,0.5811,0.05,100 -50000,0.5698,0.5811,0.05,100 -50000,0.5698,0.5811,0.05,100 -50000,0.5698,0.5811,0.05,100 -50000,0.5698,0.5811,0.05,100 -50000,0.5698,0.5811,0.05,100 -50000,0.58109,0.59261,0.05,100 -50000,0.58109,0.59261,0.05,100 -50000,0.58109,0.59261,0.05,100 -50000,0.58109,0.59261,0.05,100 -50000,0.58109,0.59261,0.05,100 -50000,0.58109,0.59261,0.05,100 -50000,0.58109,0.59261,0.05,100 -50000,0.58109,0.59261,0.05,100 -50000,0.58109,0.59261,0.05,100 -50000,0.58109,0.59261,0.05,100 -50000,0.58109,0.59261,0.05,100 -50000,0.5926,0.60435,0.05,100 -50000,0.5926,0.60435,0.05,100 -50000,0.5926,0.60435,0.05,100 -50000,0.5926,0.60435,0.05,100 -50000,0.5926,0.60435,0.05,100 -50000,0.5926,0.60435,0.05,100 -50000,0.5926,0.60435,0.05,100 -50000,0.5926,0.60435,0.05,100 -50000,0.5926,0.60435,0.05,100 -50000,0.5926,0.60435,0.05,100 -50000,0.5926,0.60435,0.05,100 -50000,0.5926,0.60435,0.05,100 -50000,0.60434,0.61632,0.05,100 -50000,0.60434,0.61632,0.05,100 -50000,0.60434,0.61632,0.05,100 -50000,0.60434,0.61632,0.05,100 -50000,0.60434,0.61632,0.05,100 -50000,0.60434,0.61632,0.05,100 -50000,0.60434,0.61632,0.05,100 -50000,0.60434,0.61632,0.05,100 -50000,0.60434,0.61632,0.05,100 -50000,0.60434,0.61632,0.05,100 -50000,0.60434,0.61632,0.05,100 -50000,0.60434,0.61632,0.05,100 -50000,0.61631,0.62853,0.05,100 -50000,0.61631,0.62853,0.05,100 -50000,0.61631,0.62853,0.05,100 -50000,0.61631,0.62853,0.05,100 -50000,0.61631,0.62853,0.05,100 -50000,0.61631,0.62853,0.05,100 -50000,0.61631,0.62853,0.05,100 -50000,0.61631,0.62853,0.05,100 -50000,0.61631,0.62853,0.05,100 -50000,0.61631,0.62853,0.05,100 -50000,0.61631,0.62853,0.05,100 -50000,0.61631,0.62853,0.05,100 -50000,0.62852,0.64098,0.05,100 -50000,0.62852,0.64098,0.05,100 -50000,0.62852,0.64098,0.05,100 -50000,0.62852,0.64098,0.05,100 -50000,0.62852,0.64098,0.05,100 -50000,0.62852,0.64098,0.05,100 -50000,0.62852,0.64098,0.05,100 -50000,0.62852,0.64098,0.05,100 -50000,0.62852,0.64098,0.05,100 -50000,0.62852,0.64098,0.05,100 -50000,0.62852,0.64098,0.05,100 -50000,0.62852,0.64098,0.05,100 -50000,0.62852,0.64098,0.05,100 -50000,0.64097,0.65368,0.05,100 -50000,0.64097,0.65368,0.05,100 -50000,0.64097,0.65368,0.05,100 -50000,0.64097,0.65368,0.05,100 -50000,0.64097,0.65368,0.05,100 -50000,0.64097,0.65368,0.05,100 -50000,0.64097,0.65368,0.05,100 -50000,0.64097,0.65368,0.05,100 -50000,0.64097,0.65368,0.05,100 -50000,0.64097,0.65368,0.05,100 -50000,0.64097,0.65368,0.05,100 -50000,0.64097,0.65368,0.05,100 -50000,0.65367,0.66663,0.05,100 -50000,0.65367,0.66663,0.05,100 -50000,0.65367,0.66663,0.05,100 -50000,0.65367,0.66663,0.05,100 -50000,0.65367,0.66663,0.05,100 -50000,0.65367,0.66663,0.05,100 -50000,0.65367,0.66663,0.05,100 -50000,0.65367,0.66663,0.05,100 -50000,0.65367,0.66663,0.05,100 -50000,0.65367,0.66663,0.05,100 -50000,0.65367,0.66663,0.05,100 -50000,0.65367,0.66663,0.05,100 -50000,0.65367,0.66663,0.05,100 -50000,0.66662,0.67984,0.05,100 -50000,0.66662,0.67984,0.05,100 -50000,0.66662,0.67984,0.05,100 -50000,0.66662,0.67984,0.05,100 -50000,0.66662,0.67984,0.05,100 -50000,0.66662,0.67984,0.05,100 -50000,0.66662,0.67984,0.05,100 -50000,0.66662,0.67984,0.05,100 -50000,0.66662,0.67984,0.05,100 -50000,0.66662,0.67984,0.05,100 -50000,0.66662,0.67984,0.05,100 -50000,0.66662,0.67984,0.05,100 -50000,0.66662,0.67984,0.05,100 -50000,0.67983,0.69331,0.05,100 -50000,0.67983,0.69331,0.05,100 -50000,0.67983,0.69331,0.05,100 -50000,0.67983,0.69331,0.05,100 -50000,0.67983,0.69331,0.05,100 -50000,0.67983,0.69331,0.05,100 -50000,0.67983,0.69331,0.05,100 -50000,0.67983,0.69331,0.05,100 -50000,0.67983,0.69331,0.05,100 -50000,0.67983,0.69331,0.05,100 -50000,0.67983,0.69331,0.05,100 -50000,0.67983,0.69331,0.05,100 -50000,0.67983,0.69331,0.05,100 -50000,0.67983,0.69331,0.05,100 -50000,0.6933,0.70704,0.05,100 -50000,0.6933,0.70704,0.05,100 -50000,0.6933,0.70704,0.05,100 -50000,0.6933,0.70704,0.05,100 -50000,0.6933,0.70704,0.05,100 -50000,0.6933,0.70704,0.05,100 -50000,0.6933,0.70704,0.05,100 -50000,0.6933,0.70704,0.05,100 -50000,0.6933,0.70704,0.05,100 -50000,0.6933,0.70704,0.05,100 -50000,0.6933,0.70704,0.05,100 -50000,0.6933,0.70704,0.05,100 -50000,0.6933,0.70704,0.05,100 -50000,0.6933,0.70704,0.05,100 -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan -50000,nan,nan,nan,nan diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/model-results.txt b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/model-results.txt new file mode 100644 index 00000000000..859ec3fbff8 --- /dev/null +++ b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/model-results.txt @@ -0,0 +1,465 @@ + time r temperature + 10000 0.100995 -15.3322 + 10000 0.102995 -6.17415 + 10000 0.104995 2.80966 + 10000 0.107345 13.1432 + 10000 0.110045 24.5997 + 10000 0.112745 35.5166 + 10000 0.115444 45.7437 + 10000 0.118144 55.1274 + 10000 0.120844 63.538 + 10000 0.123544 70.8903 + 10000 0.126244 77.1565 + 10000 0.128944 82.3664 + 10000 0.131644 86.5972 + 10000 0.134305 89.9102 + 10000 0.136953 92.497 + 10000 0.139654 94.5208 + 10000 0.142408 96.0698 + 10000 0.145217 97.2306 + 10000 0.148081 98.0827 + 10000 0.151003 98.6958 + 10000 0.153982 99.1282 + 10000 0.15702 99.4274 + 10000 0.160119 99.6304 + 10000 0.163279 99.7657 + 10000 0.166502 99.854 + 10000 0.169788 99.9107 + 10000 0.17314 99.9463 + 10000 0.176558 99.9683 + 10000 0.180044 99.9816 + 10000 0.183599 99.9895 + 10000 0.187225 99.9942 + 10000 0.190922 99.9968 + 10000 0.194693 99.9983 + 10000 0.198539 99.9991 + 10000 0.202461 99.9995 + 10000 0.20646 99.9998 + 10000 0.210539 99.9999 + 10000 0.214699 99.9999 + 10000 0.218941 100 + 10000 0.223267 100 + 10000 0.22768 100 + 10000 0.232179 100 + 10000 0.236768 100 + 10000 0.241448 100 + 10000 0.24622 100 + 10000 0.251088 100 + 10000 0.256051 100 + 10000 0.261114 100 + 10000 0.266276 100 + 10000 0.271541 100 + 10000 0.27691 100 + 10000 0.282386 100 + 10000 0.28797 100 + 10000 0.293665 100 + 10000 0.299473 100 + 10000 0.305396 100 + 10000 0.311437 100 + 10000 0.317597 100 + 10000 0.32388 100 + 10000 0.330287 100 + 10000 0.336821 100 + 10000 0.343485 100 + 10000 0.35028 100 + 10000 0.357211 100 + 10000 0.364279 100 + 10000 0.371487 100 + 10000 0.378838 100 + 10000 0.386335 100 + 10000 0.39398 100 + 10000 0.401777 100 + 10000 0.409728 100 + 10000 0.417838 100 + 10000 0.426108 100 + 10000 0.434542 100 + 10000 0.443143 100 + 10000 0.451915 100 + 10000 0.46086 100 + 10000 0.469983 100 + 10000 0.479287 100 + 10000 0.488776 100 + 10000 0.498452 100 + 10000 0.508321 100 + 10000 0.518385 100 + 10000 0.528649 100 + 10000 0.539116 100 + 10000 0.54979 100 + 10000 0.560677 100 + 10000 0.571779 100 + 10000 0.583101 100 + 10000 0.594648 100 + 10000 0.606424 100 + 10000 0.618433 100 + 10000 0.63068 100 + 10000 0.643171 100 + 10000 0.655908 100 + 10000 0.668899 100 + 10000 0.682147 100 + 10000 0.695657 100 + 10000 0.709436 100 + 10000 0.723488 100 + 10000 0.737818 100 + 10000 0.752433 100 + 10000 0.767337 100 + 10000 0.782537 100 + 10000 0.798038 100 + 10000 0.813846 100 + 10000 0.829968 100 + 10000 0.84641 100 + 10000 0.863178 100 + 10000 0.880278 100 + 10000 0.897717 100 + 10000 0.915502 100 + 10000 0.933639 100 + 10000 0.952136 100 + 10000 0.971 100 + 10000 0.990238 100 + 20000 0.100995 -16.5749 + 20000 0.102995 -9.857 + 20000 0.104995 -3.26579 + 20000 0.107345 4.33136 + 20000 0.110045 12.8238 + 20000 0.112745 21.06 + 20000 0.115444 29.0092 + 20000 0.118144 36.6331 + 20000 0.120844 43.8883 + 20000 0.123544 50.7302 + 20000 0.126244 57.117 + 20000 0.128944 63.0131 + 20000 0.131644 68.3922 + 20000 0.134305 73.17 + 20000 0.136953 77.4165 + 20000 0.139654 81.2286 + 20000 0.142408 84.5992 + 20000 0.145217 87.5331 + 20000 0.148081 90.046 + 20000 0.151003 92.1634 + 20000 0.153982 93.9182 + 20000 0.15702 95.3483 + 20000 0.160119 96.4945 + 20000 0.163279 97.3976 + 20000 0.166502 98.0973 + 20000 0.169788 98.6303 + 20000 0.17314 99.0294 + 20000 0.176558 99.3231 + 20000 0.180044 99.5356 + 20000 0.183599 99.6866 + 20000 0.187225 99.792 + 20000 0.190922 99.8643 + 20000 0.194693 99.913 + 20000 0.198539 99.9452 + 20000 0.202461 99.9661 + 20000 0.20646 99.9794 + 20000 0.210539 99.9878 + 20000 0.214699 99.9928 + 20000 0.218941 99.9959 + 20000 0.223267 99.9977 + 20000 0.22768 99.9987 + 20000 0.232179 99.9993 + 20000 0.236768 99.9996 + 20000 0.241448 99.9998 + 20000 0.24622 99.9999 + 20000 0.251088 99.9999 + 20000 0.256051 100 + 20000 0.261114 100 + 20000 0.266276 100 + 20000 0.271541 100 + 20000 0.27691 100 + 20000 0.282386 100 + 20000 0.28797 100 + 20000 0.293665 100 + 20000 0.299473 100 + 20000 0.305396 100 + 20000 0.311437 100 + 20000 0.317597 100 + 20000 0.32388 100 + 20000 0.330287 100 + 20000 0.336821 100 + 20000 0.343485 100 + 20000 0.35028 100 + 20000 0.357211 100 + 20000 0.364279 100 + 20000 0.371487 100 + 20000 0.378838 100 + 20000 0.386335 100 + 20000 0.39398 100 + 20000 0.401777 100 + 20000 0.409728 100 + 20000 0.417838 100 + 20000 0.426108 100 + 20000 0.434542 100 + 20000 0.443143 100 + 20000 0.451915 100 + 20000 0.46086 100 + 20000 0.469983 100 + 20000 0.479287 100 + 20000 0.488776 100 + 20000 0.498452 100 + 20000 0.508321 100 + 20000 0.518385 100 + 20000 0.528649 100 + 20000 0.539116 100 + 20000 0.54979 100 + 20000 0.560677 100 + 20000 0.571779 100 + 20000 0.583101 100 + 20000 0.594648 100 + 20000 0.606424 100 + 20000 0.618433 100 + 20000 0.63068 100 + 20000 0.643171 100 + 20000 0.655908 100 + 20000 0.668899 100 + 20000 0.682147 100 + 20000 0.695657 100 + 20000 0.709436 100 + 20000 0.723488 100 + 20000 0.737818 100 + 20000 0.752433 100 + 20000 0.767337 100 + 20000 0.782537 100 + 20000 0.798038 100 + 20000 0.813846 100 + 20000 0.829968 100 + 20000 0.84641 100 + 20000 0.863178 100 + 20000 0.880278 100 + 20000 0.897717 100 + 20000 0.915502 100 + 20000 0.933639 100 + 20000 0.952136 100 + 20000 0.971 100 + 20000 0.990238 100 + 50000 0.100995 -17.6411 + 50000 0.102995 -13.0154 + 50000 0.104995 -8.47757 + 50000 0.107345 -3.24538 + 50000 0.110045 2.61605 + 50000 0.112745 8.33038 + 50000 0.115444 13.8982 + 50000 0.118144 19.3181 + 50000 0.120844 24.5868 + 50000 0.123544 29.6995 + 50000 0.126244 34.6503 + 50000 0.128944 39.4325 + 50000 0.131644 44.0386 + 50000 0.134305 48.3976 + 50000 0.136953 52.5538 + 50000 0.139654 56.5966 + 50000 0.142408 60.5098 + 50000 0.145217 64.2768 + 50000 0.148081 67.8815 + 50000 0.151003 71.3089 + 50000 0.153982 74.545 + 50000 0.15702 77.5778 + 50000 0.160119 80.3977 + 50000 0.163279 82.9978 + 50000 0.166502 85.3741 + 50000 0.169788 87.526 + 50000 0.17314 89.4558 + 50000 0.176558 91.1694 + 50000 0.180044 92.6752 + 50000 0.183599 93.9843 + 50000 0.187225 95.1099 + 50000 0.190922 96.0669 + 50000 0.194693 96.871 + 50000 0.198539 97.5387 + 50000 0.202461 98.0863 + 50000 0.20646 98.5299 + 50000 0.210539 98.8845 + 50000 0.214699 99.1643 + 50000 0.218941 99.3821 + 50000 0.223267 99.5493 + 50000 0.22768 99.6759 + 50000 0.232179 99.7702 + 50000 0.236768 99.8395 + 50000 0.241448 99.8896 + 50000 0.24622 99.9252 + 50000 0.251088 99.9502 + 50000 0.256051 99.9674 + 50000 0.261114 99.979 + 50000 0.266276 99.9867 + 50000 0.271541 99.9917 + 50000 0.27691 99.995 + 50000 0.282386 99.997 + 50000 0.28797 99.9982 + 50000 0.293665 99.999 + 50000 0.299473 99.9994 + 50000 0.305396 99.9997 + 50000 0.311437 99.9998 + 50000 0.317597 99.9999 + 50000 0.32388 99.9999 + 50000 0.330287 100 + 50000 0.336821 100 + 50000 0.343485 100 + 50000 0.35028 100 + 50000 0.357211 100 + 50000 0.364279 100 + 50000 0.371487 100 + 50000 0.378838 100 + 50000 0.386335 100 + 50000 0.39398 100 + 50000 0.401777 100 + 50000 0.409728 100 + 50000 0.417838 100 + 50000 0.426108 100 + 50000 0.434542 100 + 50000 0.443143 100 + 50000 0.451915 100 + 50000 0.46086 100 + 50000 0.469983 100 + 50000 0.479287 100 + 50000 0.488776 100 + 50000 0.498452 100 + 50000 0.508321 100 + 50000 0.518385 100 + 50000 0.528649 100 + 50000 0.539116 100 + 50000 0.54979 100 + 50000 0.560677 100 + 50000 0.571779 100 + 50000 0.583101 100 + 50000 0.594648 100 + 50000 0.606424 100 + 50000 0.618433 100 + 50000 0.63068 100 + 50000 0.643171 100 + 50000 0.655908 100 + 50000 0.668899 100 + 50000 0.682147 100 + 50000 0.695657 100 + 50000 0.709436 100 + 50000 0.723488 100 + 50000 0.737818 100 + 50000 0.752433 100 + 50000 0.767337 100 + 50000 0.782537 100 + 50000 0.798038 100 + 50000 0.813846 100 + 50000 0.829968 100 + 50000 0.84641 100 + 50000 0.863178 100 + 50000 0.880278 100 + 50000 0.897717 100 + 50000 0.915502 100 + 50000 0.933639 100 + 50000 0.952136 100 + 50000 0.971 100 + 50000 0.990238 100 + 100000 0.100995 -18.1768 + 100000 0.102995 -14.6017 + 100000 0.104995 -11.095 + 100000 0.107345 -7.05181 + 100000 0.110045 -2.52137 + 100000 0.112745 1.89876 + 100000 0.115444 6.21229 + 100000 0.118144 10.4221 + 100000 0.120844 14.5304 + 100000 0.123544 18.5387 + 100000 0.126244 22.4479 + 100000 0.128944 26.2583 + 100000 0.131644 29.97 + 100000 0.134305 33.5305 + 100000 0.136953 36.9787 + 100000 0.139654 40.3953 + 100000 0.142408 43.7746 + 100000 0.145217 47.1101 + 100000 0.148081 50.3951 + 100000 0.151003 53.6223 + 100000 0.153982 56.7841 + 100000 0.15702 59.8725 + 100000 0.160119 62.8794 + 100000 0.163279 65.7966 + 100000 0.166502 68.6159 + 100000 0.169788 71.3293 + 100000 0.17314 73.9292 + 100000 0.176558 76.4087 + 100000 0.180044 78.7613 + 100000 0.183599 80.9816 + 100000 0.187225 83.0653 + 100000 0.190922 85.009 + 100000 0.194693 86.8108 + 100000 0.198539 88.4701 + 100000 0.202461 89.9876 + 100000 0.20646 91.3655 + 100000 0.210539 92.6074 + 100000 0.214699 93.7179 + 100000 0.218941 94.703 + 100000 0.223267 95.5695 + 100000 0.22768 96.3252 + 100000 0.232179 96.9784 + 100000 0.236768 97.5377 + 100000 0.241448 98.0122 + 100000 0.24622 98.4106 + 100000 0.251088 98.7418 + 100000 0.256051 99.0143 + 100000 0.261114 99.236 + 100000 0.266276 99.4145 + 100000 0.271541 99.5563 + 100000 0.27691 99.6678 + 100000 0.282386 99.7544 + 100000 0.28797 99.8207 + 100000 0.293665 99.8708 + 100000 0.299473 99.9082 + 100000 0.305396 99.9357 + 100000 0.311437 99.9556 + 100000 0.317597 99.9698 + 100000 0.32388 99.9798 + 100000 0.330287 99.9867 + 100000 0.336821 99.9914 + 100000 0.343485 99.9945 + 100000 0.35028 99.9966 + 100000 0.357211 99.9979 + 100000 0.364279 99.9987 + 100000 0.371487 99.9992 + 100000 0.378838 99.9996 + 100000 0.386335 99.9998 + 100000 0.39398 99.9999 + 100000 0.401777 99.9999 + 100000 0.409728 100 + 100000 0.417838 100 + 100000 0.426108 100 + 100000 0.434542 100 + 100000 0.443143 100 + 100000 0.451915 100 + 100000 0.46086 100 + 100000 0.469983 100 + 100000 0.479287 100 + 100000 0.488776 100 + 100000 0.498452 100 + 100000 0.508321 100 + 100000 0.518385 100 + 100000 0.528649 100 + 100000 0.539116 100 + 100000 0.54979 100 + 100000 0.560677 100 + 100000 0.571779 100 + 100000 0.583101 100 + 100000 0.594648 100 + 100000 0.606424 100 + 100000 0.618433 100 + 100000 0.63068 100 + 100000 0.643171 100 + 100000 0.655908 100 + 100000 0.668899 100 + 100000 0.682147 100 + 100000 0.695657 100 + 100000 0.709436 100 + 100000 0.723488 100 + 100000 0.737818 100 + 100000 0.752433 100 + 100000 0.767337 100 + 100000 0.782537 100 + 100000 0.798038 100 + 100000 0.813846 100 + 100000 0.829968 100 + 100000 0.84641 100 + 100000 0.863178 100 + 100000 0.880278 100 + 100000 0.897717 100 + 100000 0.915502 100 + 100000 0.933639 100 + 100000 0.952136 100 + 100000 0.971 100 + 100000 0.990238 100 diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/temperatureDependentVolumetricHeatCapacity_plot.py b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/temperatureDependentVolumetricHeatCapacity_plot.py deleted file mode 100644 index 20d7eed6613..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/temperatureDependentVolumetricHeatCapacity_plot.py +++ /dev/null @@ -1,216 +0,0 @@ -import os -import sys -import os -import argparse - -import numpy as np -import matplotlib.pyplot as plt -import pandas as pd -import scipy.linalg -from scipy import special - -from scipy.sparse import diags -from scipy.sparse.linalg import spsolve - -from xml.etree import ElementTree - -# Analytical results for linear thermal behavior -def steadyState(Tin, Tout, Rin, Rout, radialCoordinate): - return Tin + (Tout - Tin) * (np.log(radialCoordinate) - np.log(Rin)) / (np.log(Rout) - np.log(Rin)) - -def diffusionFunction(radialCoordinate, Rin, diffusionCoefficient, diffusionTime): - return special.erfc( (radialCoordinate - Rin) / 2.0 / np.sqrt( diffusionCoefficient * diffusionTime ) ) - -def computeTransientTemperature(Tin, Tout, Rin, radialCoordinate, thermalDiffusionCoefficient, diffusionTime): - # Ref. Wang and Papamichos (1994), https://agupubs.onlinelibrary.wiley.com/doi/abs/10.1029/94WR01774 - return Tout + (Tin-Tout) * np.sqrt(Rin/radialCoordinate) * diffusionFunction(radialCoordinate, Rin, thermalDiffusionCoefficient, diffusionTime) - -def computeThermalDiffusionCoefficient(thermalConductivity, volumetricHeatCapacity): - return thermalConductivity / volumetricHeatCapacity - -# Finite difference results for non-linear thermal behavior -def temperatureDependentThermalConductivity(lambda0, lambda_gradient, T, Treference): - return lambda0 + lambda_gradient*(T-Treference) - -def temperatureDependentVolumetricHeat(c0, c_gradient, T, Treference): - return c0 + c_gradient*(T-Treference) - -def coefficientMatrix(thermalConductivity, volumetricHeatCapacity, r, dt, N): - # Coefficients for the matrix - A = np.zeros((N+1, N+1)) - - for i in range(1,N): - dr = r[i] - r[i-1] - r_i = r[i] - - diffusivity_i = thermalConductivity[i]/volumetricHeatCapacity[i] - A[i, i-1] = - diffusivity_i * (dt/(dr**2) - dt/(2 * r_i * dr)) \ - + (thermalConductivity[i+1] - thermalConductivity[i-1])/volumetricHeatCapacity[i]*dt/4/(dr**2) - A[i, i] = 1.0 + 2.0 * diffusivity_i * dt / (dr**2) - A[i, i+1] = - diffusivity_i * (dt/(dr**2) + dt/(2 * r_i * dr)) \ - - (thermalConductivity[i+1] - thermalConductivity[i-1])/volumetricHeatCapacity[i]*dt/4/(dr**2) - - # Boundary conditions - # No-flux at r=0 approximated by setting the flux between the first two cells to zero - A[0, 0] = 1.0 - A[N, N] = 1.0 - return A - -def solve_radial_diffusion(r, tmax, dt, Tin, Tout, lambda0, lambda_gradient, c0, c_gradient, Treference): - N = len(r)-1 - # Time setup - n_steps = int(tmax / dt) - - # Time-stepping - T = np.zeros(N+1) + Tout # initial condition u(r, 0) - T[0] = Tin - for step in range(n_steps): - thermalConductivity = temperatureDependentThermalConductivity(lambda0, lambda_gradient, T, Treference) - - volumetricHeatCapacity = temperatureDependentVolumetricHeat(c0, c_gradient, T, Treference) - - A = coefficientMatrix(thermalConductivity, volumetricHeatCapacity, r, dt, N) - T = spsolve(A, T) - - return T - - -def extractDataFromXMLList(paramList): - # Extract data from a list in XML such as "{ 1, 2, 3}" - return paramList.replace('{', '').replace('}', '').strip().split(',') - -def getWellboreGeometryFromXML(xmlFilePath): - tree = ElementTree.parse(xmlFilePath) - - meshParam = tree.find('Mesh/InternalWellbore') - radii = extractDataFromXMLList( meshParam.get("radius") ) - - Rin = float(radii[0]) - Rout = float(radii[-1]) - - return [Rin, Rout] - -def getLoadingFromXML(xmlFilePath): - tree = ElementTree.parse(xmlFilePath) - fsParams = tree.findall('FieldSpecifications/FieldSpecification') - - for fsParam in fsParams: - if ( (fsParam.get('fieldName') == "pressure") & (fsParam.get('initialCondition') != "1") ): - if fsParam.get('setNames') == "{ rneg }": - Pin = float(fsParam.get('scale')) - if fsParam.get('setNames') == "{ rpos }": - Pout = float(fsParam.get('scale')) - - for fsParam in fsParams: - if ( (fsParam.get('fieldName') == "temperature") & (fsParam.get('initialCondition') != "1") ): - if fsParam.get('setNames') == "{ rneg }": - Tin = float(fsParam.get('scale')) - if fsParam.get('setNames') == "{ rpos }": - Tout = float(fsParam.get('scale')) - - - tree_SinglePhaseThermalConductivities = tree.findall('Constitutive/SinglePhaseThermalConductivity') - - for tree_SinglePhaseThermalConductivity in tree_SinglePhaseThermalConductivities: - if tree_SinglePhaseThermalConductivity.get('name') == "thermalCond_linear": - defaultThermalConductivity = float( extractDataFromXMLList( tree_SinglePhaseThermalConductivity.get('defaultThermalConductivityComponents') )[0] ) - thermalConductivityGradient = 0.0 - - tree_SolidInternalEnergies = tree.findall('Constitutive/SolidInternalEnergy') - - for tree_SolidInternalEnergy in tree_SolidInternalEnergies: - if tree_SolidInternalEnergy.get('name') == "rockInternalEnergy_nonLinear": - referenceVolumetricHeatCapacity = float( tree_SolidInternalEnergy.get('referenceVolumetricHeatCapacity') ) - dVolumetricHeatCapacity_dTemperature = float( tree_SolidInternalEnergy.get('dVolumetricHeatCapacity_dTemperature') ) - referenceTemperature = float( tree_SolidInternalEnergy.get('referenceTemperature') ) - - - permeability = float( extractDataFromXMLList( tree.find('Constitutive/ConstantPermeability').get('permeabilityComponents') )[0] ) - - porosity = float( tree.find('Constitutive/PressurePorosity').get('defaultReferencePorosity') ) - - fluidViscosity = float( tree.find('Constitutive/ThermalCompressibleSinglePhaseFluid').get('defaultViscosity') ) - - fluidCompressibility = float( tree.find('Constitutive/ThermalCompressibleSinglePhaseFluid').get('compressibility') ) - - fluidThermalExpansionCoefficient = float( tree.find('Constitutive/ThermalCompressibleSinglePhaseFluid').get('thermalExpansionCoeff') ) - - return [Pin, Pout, Tin, Tout, defaultThermalConductivity, thermalConductivityGradient, referenceTemperature, referenceVolumetricHeatCapacity, dVolumetricHeatCapacity_dTemperature, permeability, porosity, fluidViscosity, fluidCompressibility, fluidThermalExpansionCoefficient] - - -def main(): - - # Initialize the argument parser - parser = argparse.ArgumentParser(description="Script to generate figure from tutorial.") - - # Add arguments to accept individual file paths - parser.add_argument('--geosDir', help='Path to the GEOS repository ', default='../../../../../../..') - - # Parse the command-line arguments - args = parser.parse_args() - - geosDir = args.geosDir - - xmlFilePath = geosDir + "/inputFiles/singlePhaseFlow/" - - Rin, Rout = getWellboreGeometryFromXML(xmlFilePath+"thermalCompressible_temperatureDependentVolumetricHeatCapacity_benchmark.xml") - - Pin, Pout, Tin, Tout, defaultThermalConductivity, thermalConductivityGradient, referenceTemperature, volumetricHeatCapacity, dVolumetricHeatCapacity_dTemperature, permeability, porosity, fluidViscosity, fluidCompressibility, fluidThermalExpansionCoefficient = getLoadingFromXML(xmlFilePath+"thermalCompressible_2d_base.xml") - - plt.figure(figsize=(10,7)) - font = {'size' : 16} - plt.rc('font', **font) - - for chart_idx, idx in enumerate([1, 2, 5, 10]): - # Numerical results - data = pd.read_csv(f'data_{idx}.csv') - data.dropna(inplace=True) - data.drop_duplicates(inplace=True) - data.reset_index(drop=True, inplace=True) - - radialCoordinate = (data['elementCenter:0']**2.0 + data['elementCenter:1']**2.0)**0.5 - temperature = data['temperature'] - #pressure = data['pressure'] - diffusionTime = data['Time'][0] - - # Analytical results for linear thermal behavior, for comparison - radialCoordinate_anal = radialCoordinate# np.arange(Rin, Rout, (Rout-Rin)/100) - - thermalDiffusionCoefficient = computeThermalDiffusionCoefficient(defaultThermalConductivity, volumetricHeatCapacity) - - T_transient_linear = computeTransientTemperature(Tin, Tout, Rin, radialCoordinate_anal, thermalDiffusionCoefficient, diffusionTime) - - # Analytical results of the steady state regime for comparison - T_steadyState = steadyState(Tin, Tout, Rin, Rout, radialCoordinate_anal) - - # Finite different results for non-linear thermal behavior - - T_transient_nonLinear = solve_radial_diffusion(radialCoordinate_anal, diffusionTime, diffusionTime/100, Tin, Tout, defaultThermalConductivity, thermalConductivityGradient, volumetricHeatCapacity, dVolumetricHeatCapacity_dTemperature, referenceTemperature) - - # Visualization - # Temperature - plt.subplot(2,2,chart_idx+1) - plt.plot( radialCoordinate, temperature, 'k+' , label='GEOS' ) - plt.plot( radialCoordinate_anal, T_transient_nonLinear, 'g-' , label='FDM Non-Linear' ) - plt.plot( radialCoordinate_anal, T_transient_linear, 'r-' , label='Analytic Linear' ) - plt.plot( radialCoordinate_anal, T_steadyState, 'b-' , label='Steady State' ) - - if chart_idx==1: - plt.legend() - - if chart_idx in [2,3]: - plt.xlabel('Radial distance from well center') - - if chart_idx in [0,2]: - plt.ylabel('Temperature (°C)') - - plt.ylim(-30,110) - plt.xlim(0.,0.5) - plt.title('t = '+str(diffusionTime)+'(s)') - plt.tight_layout() - - plt.show() - -if __name__ == "__main__": - main() - diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/volumetricHeatCapacityFigure.py b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/volumetricHeatCapacityFigure.py new file mode 100644 index 00000000000..470685dacbc --- /dev/null +++ b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/volumetricHeatCapacityFigure.py @@ -0,0 +1,8 @@ +import os +try: + _this_dir = os.path.dirname(os.path.abspath(__file__)) +except NameError: + _this_dir = os.getcwd() + +import wellboreTemperatureFigure +wellboreTemperatureFigure.main(xmlFilePrefix='thermalCompressible_temperatureDependentVolumetricHeatCapacity', outputDir=_this_dir) diff --git a/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/volumetricHeatCapacityQueries.py b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/volumetricHeatCapacityQueries.py new file mode 100644 index 00000000000..47499e593be --- /dev/null +++ b/src/docs/sphinx/advancedExamples/validationStudies/wellboreProblems/nonLinearThermalDiffusion_TemperatureDependentVolumetricHeatCapacity/volumetricHeatCapacityQueries.py @@ -0,0 +1,6 @@ +import sys + +sys.path.append('../../../../../../../inputFiles/singlePhaseFlow/scripts') +import wellboreTemperatureQueries + +wellboreTemperatureQueries.main() From be9bfe12ead536c6c25f014efef46723451aebd9 Mon Sep 17 00:00:00 2001 From: Matteo Cusini <49037133+CusiniM@users.noreply.github.com> Date: Mon, 18 May 2026 00:33:30 -0700 Subject: [PATCH 37/53] fix: Fix SeismicityRate script. (#3441) * fix: Fix SeismicityRate script. * add write tables option. * fix syntax. --------- Co-authored-by: Pavel Tomin Co-authored-by: Jian Huang <53012159+jhuang2601@users.noreply.github.com> Co-authored-by: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> Co-authored-by: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> --- .../scripts/SeismicityRate_curveChecks.py | 37 +++++++++---------- 1 file changed, 18 insertions(+), 19 deletions(-) diff --git a/inputFiles/inducedSeismicity/scripts/SeismicityRate_curveChecks.py b/inputFiles/inducedSeismicity/scripts/SeismicityRate_curveChecks.py index c1e40e9bba6..5343b6e4a4a 100644 --- a/inputFiles/inducedSeismicity/scripts/SeismicityRate_curveChecks.py +++ b/inputFiles/inducedSeismicity/scripts/SeismicityRate_curveChecks.py @@ -55,7 +55,7 @@ def curve_check_solution(**kwargs): return np.array(analytical_rates) -def debug( xmlFilePath ): +def debug( xmlFilePath, hdf5FilePath, write_tables ): #-------- Extract info from XML parameters = getParametersFromXML( xmlFilePath ) @@ -70,51 +70,50 @@ def debug( xmlFilePath ): while time < final_time: tau = analytical_solution.compute_shear_stress(time, dt) analytical_rate = analytical_solution.compute_seismic_rate(time, dt, tau) - time += dt times.append(time) analytical_rates.append(analytical_rate) tau_plot.append(tau) + time += dt + + if write_tables: + import csv - import csv - - # Write times to a CSV file without headers - with open('shearStress_time.csv', 'w', newline='') as file: + # Write times to a CSV file without headers + with open('shearStress_time.csv', 'w', newline='') as file: writer = csv.writer(file) for time in times: writer.writerow([time]) - # Write tau_plot to a CSV file without headers - with open('shearStress_values.csv', 'w', newline='') as file: + # Write tau_plot to a CSV file without headers + with open('shearStress_values.csv', 'w', newline='') as file: writer = csv.writer(file) for tau in tau_plot: writer.writerow([tau]) import h5py - file_path = '/usr/workspace/cusini1/geosx/geosx_dev/GEOS_2/build-quartz-gcc-12-release/Output/seismicityRate.hdf5' - with h5py.File(file_path, 'r') as file: - # List all groups - print("Keys: %s" % file.keys()) - + with h5py.File(hdf5FilePath, 'r') as file: # Get the data time = np.squeeze(file['seismicityRate Time'][:]) seismicityRate = np.squeeze(file['seismicityRate'][:]) - print(time) - print(seismicityRate) # Plot analytical (continuous line) and numerical (markers) aperture solution fig, ax = plt.subplots(figsize=(16, 12), nrows=2, ncols=1) - ax[0].plot(times, tau_plot) + ax[0].plot(times, tau_plot, color='r', lw=4) ax[0].set_xlabel('time [s]', weight="bold") ax[0].set_ylabel('shear stress', weight="bold") - ax[1].plot(times, analytical_rates) + ax[1].plot(times, analytical_rates, label='Analytical Solution', color='r', lw=4) + ax[1].plot(time, seismicityRate, label='geos', color='k', lw=4) ax[1].set_xlabel('time [s]', weight="bold") ax[1].set_ylabel('seismic rate', weight="bold") + ax[1].legend( bbox_to_anchor=(0.1, 0.8), loc='center', borderaxespad=0., fontsize=12) plt.savefig("seismicRate.png") if __name__ == "__main__": parser = argparse.ArgumentParser() - parser.add_argument('-f', '--xml-file', type=str, help='Path to XML file') + parser.add_argument('-f', '--xml-file', type=str, required=True, help='Path to XML file') + parser.add_argument('-h5', '--hdf5-file', type=str, required=True, help='Path to hdf5 file') + parser.add_argument('-wt', '--write-tables', action='store_true', help='Write the input tables.') args = parser.parse_args() - debug( args.xml_file ) + debug( args.xml_file, args.hdf5_file, args.write_tables ) From 40f1a05488a8e9ed515e769be6c9901f15938d31 Mon Sep 17 00:00:00 2001 From: Jian Huang <53012159+jhuang2601@users.noreply.github.com> Date: Mon, 18 May 2026 10:21:14 -0500 Subject: [PATCH 38/53] fix: reporting invalid input of mechanical properties (#3717) * add checks for mechanical properties * Update src/coreComponents/constitutive/solid/porosity/BiotPorosity.hpp * Apply suggestion from @castelletto1 * fix CI failures --------- Co-authored-by: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> --- .../constitutive/solid/porosity/BiotPorosity.hpp | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/coreComponents/constitutive/solid/porosity/BiotPorosity.hpp b/src/coreComponents/constitutive/solid/porosity/BiotPorosity.hpp index 36e04505a86..b020cecf8bb 100644 --- a/src/coreComponents/constitutive/solid/porosity/BiotPorosity.hpp +++ b/src/coreComponents/constitutive/solid/porosity/BiotPorosity.hpp @@ -22,6 +22,7 @@ #include "PorosityBase.hpp" #include "LvArray/src/tensorOps.hpp" +#include "common/logger/Logger.hpp" namespace geos { @@ -190,6 +191,14 @@ class BiotPorosityUpdates : public PorosityBaseUpdates m_bulkModulus[k] = bulkModulus; m_shearModulus[k] = shearModulus; + GEOS_THROW_IF( m_bulkModulus[k] <= 0, + GEOS_FMT( "Element {}: the rock bulk modulus must be strictly positive", k ), + InputError ); + + GEOS_THROW_IF_GT_MSG( m_bulkModulus[k], m_grainBulkModulus[k], + GEOS_FMT( "Element {}: the rock bulk modulus cannot be greater than the grain bulk modulus", k ), + InputError ); + m_biotCoefficient[k] = 1.0 - bulkModulus / m_grainBulkModulus[k]; } From dce57408dce8ecd1905fbeb03f7767a90c3415ce Mon Sep 17 00:00:00 2001 From: Bertrand Denel <120652669+bd713@users.noreply.github.com> Date: Mon, 18 May 2026 10:56:23 -0700 Subject: [PATCH 39/53] Draft (#4038) Co-authored-by: DENEL Bertrand Co-authored-by: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> --- .../linearAlgebra/unitTests/testHypredrive.cpp | 6 +++--- .../linearAlgebra/utilities/LinearSolverParameters.hpp | 2 +- .../physicsSolvers/LinearSolverParameters.cpp | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/coreComponents/linearAlgebra/unitTests/testHypredrive.cpp b/src/coreComponents/linearAlgebra/unitTests/testHypredrive.cpp index 25e3de8b2ab..c004631a83d 100644 --- a/src/coreComponents/linearAlgebra/unitTests/testHypredrive.cpp +++ b/src/coreComponents/linearAlgebra/unitTests/testHypredrive.cpp @@ -375,7 +375,7 @@ TEST( HypredriveYaml, UsesAuthoritativeFileWhenProvided ) LinearSolverParameters params; params.solverType = LinearSolverParameters::SolverType::direct; params.preconditionerType = LinearSolverParameters::PreconditionerType::none; - params.hypredriveInputFile = authoritativeFile; + params.hypredriveInputFile = Path( authoritativeFile.c_str() ); hypre::hypredrive::InputArgsParseTarget target; ASSERT_TRUE( hypre::hypredrive::buildInputArgsParseTarget( params, target ) ); @@ -455,7 +455,7 @@ TEST( HypredriveLogging, PrintsStatisticsSummaryWhenHandleIsDestroyed ) } LinearSolverParameters params; - params.hypredriveInputFile = authoritativeFile; + params.hypredriveInputFile = Path( authoritativeFile.c_str() ); HypreMatrix matrix; testing::computeIdentity( MPI_COMM_GEOS, 4, matrix ); @@ -599,7 +599,7 @@ TEST( HypredriveSolverReuse, RecreatesHandleWhenAuthoritativeYamlChanges ) } LinearSolverParameters params; - params.hypredriveInputFile = authoritativeFile; + params.hypredriveInputFile = Path( authoritativeFile.c_str() ); HypreMatrix matrix; testing::computeIdentity( MPI_COMM_GEOS, 4, matrix ); diff --git a/src/coreComponents/linearAlgebra/utilities/LinearSolverParameters.hpp b/src/coreComponents/linearAlgebra/utilities/LinearSolverParameters.hpp index 9988198ffbc..d9c6a954a54 100644 --- a/src/coreComponents/linearAlgebra/utilities/LinearSolverParameters.hpp +++ b/src/coreComponents/linearAlgebra/utilities/LinearSolverParameters.hpp @@ -79,7 +79,7 @@ struct LinearSolverParameters SolverType solverType = SolverType::direct; ///< Solver type PreconditionerType preconditionerType = PreconditionerType::iluk; ///< Preconditioner type - string hypredriveInputFile; ///< Optional authoritative hypredrive YAML file + Path hypredriveInputFile; ///< Optional authoritative hypredrive YAML file /// Direct solver parameters: used for SuperLU_Dist interface through hypre and PETSc struct Direct diff --git a/src/coreComponents/physicsSolvers/LinearSolverParameters.cpp b/src/coreComponents/physicsSolvers/LinearSolverParameters.cpp index 6160164edbc..4ae2a849af0 100644 --- a/src/coreComponents/physicsSolvers/LinearSolverParameters.cpp +++ b/src/coreComponents/physicsSolvers/LinearSolverParameters.cpp @@ -912,7 +912,7 @@ void LinearSolverParametersInput::print() const tableData.addRow( "Preconditioner type", m_parameters.preconditionerType ); if( !m_parameters.hypredriveInputFile.empty() ) { - tableData.addRow( "hypredrive input file", m_parameters.hypredriveInputFile ); + tableData.addRow( "hypredrive input file", string_view( m_parameters.hypredriveInputFile ) ); } tableData.addRow( "Stop if error", m_parameters.stopIfError ); if( m_parameters.solverType == LinearSolverParameters::SolverType::direct ) From 634f2f9ca652c54befdc238ff11f0fa1bd243fca Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Mon, 18 May 2026 22:47:40 +0200 Subject: [PATCH 40/53] refactor: split FieldSpecificationBase into two classes (#4025) * add static class for FieldSpecification behavior * change calls from FSBase to FSImpl in FSManager * CMBase: update calls to FieldSpecificationImpl * CMHybridFVM: update calls to FieldSpecificationImpl * RCMOBL: update calls to FieldSpecificationImpl * SPBase: update calls to FieldSpecificationImpl * SPFVM: update calls to FieldSpecificationImpl * SPHybridFVM: update calls to FieldSpecificationImpl * SPReactiveTransport: update calls to FieldSpecificationImpl * ImmiscibleMP: update calls to FieldSpecificationImpl * SeismicityRate: update calls to FieldSpecificationImpl * LaplaceBaseH1: update calls to FieldSpecificationImpl * fix: add missing `fs` parameter to an applyBoundaryConditionToSystem call * PhaseFieldDamageFEM: update calls to FieldSpecificationImpl * SMLagrangianFEM: update calls to FieldSpecificationImpl * SMEmbFractures: update calls to FieldSpecificationImpl * SMLCBS: update calls to FieldSpecificationImpl * ProppantTransport: update calls to FieldSpecificationImpl * testRecFieldAppl: update calls to FieldSpecificationImpl * add FieldSpecification as temporary alias of FieldSpecificationBase * AquiferBC: update calls to FieldSpecification * DirichletBC: update calls to FieldSpecification * EquilibriumIC: update calls to FieldSpecification * FSImpl: update calls to FieldSpecification * PerfectlyMatchedLayer: update calls to FieldSpecification * SourceFluxBC: update calls to FieldSpecification * TractionBC: update calls to FieldSpecification * FSManager: update calls to FieldSpecification * FluxApproxBase: update calls to FieldSpecification * ProblemManager: update calls to FieldSpecification * testRecFieldAppl: update calls to FieldSpecification * testXMLFile: update calls to FieldSpecification * CMBase: update calls to FieldSpecification * CMFVM: update calls to FieldSpecification * CMHybridFVM: update calls to FieldSpecification * ImmiscibleMF: update calls to FieldSpecification * RCMOBL: update calls to FieldSpecification * SPBase: update calls to FieldSpecification * SPFVM: update calls to FieldSpecification * SPHybridFVM: update calls to FieldSpecification * SPRT: update calls to FieldSpecification * ProppantTransport: update calls to FieldSpecification * SeismicityRate: update calls to FieldSpecification * LaplaceBaseH1: update calls to FieldSpecification * PhaseFieldDamageFEM: update calls to FieldSpecification * SMLFEM: update calls to FieldSpecification * SMEmbFrac: update calls to FieldSpecification * SMLCBS: update calls to FieldSpecification * AWEDG: update calls to FieldSpecification * AFOWESEM: update calls to FieldSpecification * AVTIWESEM: update calls to FieldSpecification * AWESEM: update calls to FieldSpecification * EFOWESEM: update calls to FieldSpecification * EWESEM: update calls to FieldSpecification * replace FieldSpecificationBase with FieldSpecification ProppantTransport.hpp and PhaseFieldDamageFEM.hpp both had the "class FieldSpecification;" line that would cause an error with the temporary alias in FieldSpecification.hpp. That's why they are in this commit. * fix extension name in CMakeLists.txt * add brief documentation * uncrustify * resolve conflict * FieldApplicator: update calls to FS and FSImpl * fix doxygen parameter name * move long method definitions below the class * one line one liners * move FSManager apply checks into an FSImpl * remove includes * one line getCatalogName method in FieldSpecification * relocate solver's applyFieldValue The affected part may need a larger refactor to generalize logging on field application. * Format lines to stay under 100 char (when appropriate) * remove unnecessary include * uncrustify * fix type * remove commented code * remove unused or transitive includes --------- Co-authored-by: Omar Duran Co-authored-by: Randolph Settgast Co-authored-by: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> --- .../AquiferBoundaryCondition.cpp | 12 +- .../AquiferBoundaryCondition.hpp | 8 +- .../fieldSpecification/CMakeLists.txt | 5 +- .../DirichletBoundaryCondition.cpp | 4 +- .../DirichletBoundaryCondition.hpp | 4 +- .../EquilibriumInitialCondition.cpp | 13 +- .../EquilibriumInitialCondition.hpp | 8 +- ...icationBase.cpp => FieldSpecification.cpp} | 18 +- .../fieldSpecification/FieldSpecification.hpp | 326 +++++++ ...ionBase.hpp => FieldSpecificationImpl.hpp} | 805 +++++++----------- .../FieldSpecificationManager.cpp | 62 +- .../FieldSpecificationManager.hpp | 66 +- .../PerfectlyMatchedLayer.cpp | 8 +- .../PerfectlyMatchedLayer.hpp | 8 +- .../SourceFluxBoundaryCondition.cpp | 14 +- .../SourceFluxBoundaryCondition.hpp | 6 +- .../TractionBoundaryCondition.cpp | 9 +- .../TractionBoundaryCondition.hpp | 8 +- .../finiteVolume/FluxApproximationBase.cpp | 2 +- .../testRecursiveFieldApplication.cpp | 7 +- .../integrationTests/xmlTests/testXMLFile.cpp | 3 +- .../mainInterface/ProblemManager.cpp | 2 +- .../fluidFlow/CompositionalMultiphaseBase.cpp | 36 +- .../fluidFlow/CompositionalMultiphaseBase.hpp | 54 -- .../fluidFlow/CompositionalMultiphaseFVM.cpp | 8 +- .../CompositionalMultiphaseHybridFVM.cpp | 19 +- .../fluidFlow/FlowSolverBase.cpp | 55 ++ .../fluidFlow/FlowSolverBase.hpp | 17 + .../fluidFlow/ImmiscibleMultiphaseFlow.cpp | 32 +- .../fluidFlow/ImmiscibleMultiphaseFlow.hpp | 54 -- .../ReactiveCompositionalMultiphaseOBL.cpp | 68 +- .../fluidFlow/SinglePhaseBase.cpp | 37 +- .../fluidFlow/SinglePhaseFVM.cpp | 40 +- .../fluidFlow/SinglePhaseHybridFVM.cpp | 14 +- .../SinglePhaseReactiveTransport.cpp | 33 +- .../SinglePhaseReactiveTransport.hpp | 53 -- .../proppantTransport/ProppantTransport.cpp | 37 +- .../proppantTransport/ProppantTransport.hpp | 2 +- .../inducedSeismicity/SeismicityRate.cpp | 16 +- .../multiphysics/FieldApplicator.cpp | 27 +- .../simplePDE/LaplaceBaseH1.cpp | 22 +- .../simplePDE/PhaseFieldDamageFEM.cpp | 22 +- .../simplePDE/PhaseFieldDamageFEM.hpp | 2 +- .../SolidMechanicsLagrangianFEM.cpp | 47 +- .../SolidMechanicsEmbeddedFractures.cpp | 13 +- ...olidMechanicsLagrangeContactBubbleStab.cpp | 1 + .../isotropic/AcousticWaveEquationDG.cpp | 2 +- .../AcousticFirstOrderWaveEquationSEM.cpp | 2 +- .../AcousticVTIWaveEquationSEM.cpp | 6 +- .../isotropic/AcousticWaveEquationSEM.cpp | 2 +- .../ElasticFirstOrderWaveEquationSEM.cpp | 2 +- .../isotropic/ElasticWaveEquationSEM.cpp | 2 +- src/coreComponents/schema/schema.xsd | 16 +- 53 files changed, 1123 insertions(+), 1016 deletions(-) rename src/coreComponents/fieldSpecification/{FieldSpecificationBase.cpp => FieldSpecification.cpp} (90%) create mode 100644 src/coreComponents/fieldSpecification/FieldSpecification.hpp rename src/coreComponents/fieldSpecification/{FieldSpecificationBase.hpp => FieldSpecificationImpl.hpp} (50%) diff --git a/src/coreComponents/fieldSpecification/AquiferBoundaryCondition.cpp b/src/coreComponents/fieldSpecification/AquiferBoundaryCondition.cpp index 4a9c99a7b2f..e420fc303dc 100644 --- a/src/coreComponents/fieldSpecification/AquiferBoundaryCondition.cpp +++ b/src/coreComponents/fieldSpecification/AquiferBoundaryCondition.cpp @@ -19,13 +19,15 @@ #include "AquiferBoundaryCondition.hpp" +#include "functions/FunctionManager.hpp" + namespace geos { using namespace dataRepository; AquiferBoundaryCondition::AquiferBoundaryCondition( string const & name, Group * parent ) - : FieldSpecificationBase( name, parent ), + : FieldSpecification( name, parent ), m_waterPhaseIndex( -1 ), m_cumulativeFlux( 0.0 ) { @@ -99,15 +101,15 @@ AquiferBoundaryCondition::AquiferBoundaryCondition( string const & name, Group * registerWrapper( viewKeyStruct::cumulativeFluxString(), &m_cumulativeFlux ). setInputFlag( InputFlags::FALSE ); - getWrapper< string >( FieldSpecificationBase::viewKeyStruct::fieldNameString() ). + getWrapper< string >( FieldSpecification::viewKeyStruct::fieldNameString() ). setInputFlag( InputFlags::FALSE ); setFieldName( catalogName() ); - getWrapper< string >( FieldSpecificationBase::viewKeyStruct::objectPathString() ). + getWrapper< string >( FieldSpecification::viewKeyStruct::objectPathString() ). setInputFlag( InputFlags::FALSE ); setObjectPath( "faceManager" ); - getWrapper< int >( FieldSpecificationBase::viewKeyStruct::componentString() ). + getWrapper< int >( FieldSpecification::viewKeyStruct::componentString() ). setInputFlag( InputFlags::FALSE ); } @@ -300,7 +302,7 @@ AquiferBoundaryCondition::KernelWrapper AquiferBoundaryCondition::createKernelWr pressureInfluenceFunction.createKernelWrapper() ); } -REGISTER_CATALOG_ENTRY( FieldSpecificationBase, AquiferBoundaryCondition, string const &, Group * const ) +REGISTER_CATALOG_ENTRY( FieldSpecification, AquiferBoundaryCondition, string const &, Group * const ) } /* namespace geos */ diff --git a/src/coreComponents/fieldSpecification/AquiferBoundaryCondition.hpp b/src/coreComponents/fieldSpecification/AquiferBoundaryCondition.hpp index 275bc645ec4..8e726beed0e 100644 --- a/src/coreComponents/fieldSpecification/AquiferBoundaryCondition.hpp +++ b/src/coreComponents/fieldSpecification/AquiferBoundaryCondition.hpp @@ -21,7 +21,7 @@ #ifndef GEOS_FIELDSPECIFICATION_AQUIFERBOUNDARYCONDITION_HPP #define GEOS_FIELDSPECIFICATION_AQUIFERBOUNDARYCONDITION_HPP -#include "FieldSpecificationBase.hpp" +#include "FieldSpecification.hpp" #include "functions/TableFunction.hpp" namespace geos @@ -31,7 +31,7 @@ namespace geos * @class AquiferBoundaryCondition * Holds data and methods to apply a traction boundary condition */ -class AquiferBoundaryCondition : public FieldSpecificationBase +class AquiferBoundaryCondition : public FieldSpecification { public: @@ -118,7 +118,7 @@ class AquiferBoundaryCondition : public FieldSpecificationBase }; - /// @copydoc FieldSpecificationBase(string const &, dataRepository::Group *) + /// @copydoc FieldSpecification(string const &, dataRepository::Group *) AquiferBoundaryCondition( string const & name, Group * parent ); /// deleted default constructor @@ -202,7 +202,7 @@ class AquiferBoundaryCondition : public FieldSpecificationBase /** * @brief View keys */ - struct viewKeyStruct : public FieldSpecificationBase::viewKeyStruct + struct viewKeyStruct : public FieldSpecification::viewKeyStruct { // aquifer geological properties diff --git a/src/coreComponents/fieldSpecification/CMakeLists.txt b/src/coreComponents/fieldSpecification/CMakeLists.txt index 8dc6827d664..1ab2ae911b0 100644 --- a/src/coreComponents/fieldSpecification/CMakeLists.txt +++ b/src/coreComponents/fieldSpecification/CMakeLists.txt @@ -25,8 +25,9 @@ Contains: set( fieldSpecification_headers DirichletBoundaryCondition.hpp EquilibriumInitialCondition.hpp - FieldSpecificationBase.hpp + FieldSpecification.hpp FieldSpecificationManager.hpp + FieldSpecificationImpl.hpp SourceFluxBoundaryCondition.hpp TractionBoundaryCondition.hpp AquiferBoundaryCondition.hpp @@ -39,7 +40,7 @@ set( fieldSpecification_headers set( fieldSpecification_sources DirichletBoundaryCondition.cpp EquilibriumInitialCondition.cpp - FieldSpecificationBase.cpp + FieldSpecification.cpp FieldSpecificationManager.cpp SourceFluxBoundaryCondition.cpp TractionBoundaryCondition.cpp diff --git a/src/coreComponents/fieldSpecification/DirichletBoundaryCondition.cpp b/src/coreComponents/fieldSpecification/DirichletBoundaryCondition.cpp index 19a62d921dd..31ce54725c0 100644 --- a/src/coreComponents/fieldSpecification/DirichletBoundaryCondition.cpp +++ b/src/coreComponents/fieldSpecification/DirichletBoundaryCondition.cpp @@ -24,7 +24,7 @@ namespace geos using namespace dataRepository; DirichletBoundaryCondition::DirichletBoundaryCondition( string const & name, Group * const parent ): - FieldSpecificationBase( name, parent ) + FieldSpecification( name, parent ) { // TODO Auto-generated constructor stub @@ -37,6 +37,6 @@ DirichletBoundaryCondition::~DirichletBoundaryCondition() -REGISTER_CATALOG_ENTRY( FieldSpecificationBase, DirichletBoundaryCondition, string const &, Group * const ) +REGISTER_CATALOG_ENTRY( FieldSpecification, DirichletBoundaryCondition, string const &, Group * const ) } /* namespace geos */ diff --git a/src/coreComponents/fieldSpecification/DirichletBoundaryCondition.hpp b/src/coreComponents/fieldSpecification/DirichletBoundaryCondition.hpp index 553ac23e7dc..0803fa289d2 100644 --- a/src/coreComponents/fieldSpecification/DirichletBoundaryCondition.hpp +++ b/src/coreComponents/fieldSpecification/DirichletBoundaryCondition.hpp @@ -20,7 +20,7 @@ #ifndef GEOS_FIELDSPECIFICATION_DIRICHLETBOUNDARYCONDITION_HPP_ #define GEOS_FIELDSPECIFICATION_DIRICHLETBOUNDARYCONDITION_HPP_ -#include "FieldSpecificationBase.hpp" +#include "FieldSpecification.hpp" namespace geos { @@ -29,7 +29,7 @@ namespace geos * @class DirichletBoundaryCondition * A class to manage Dirichlet boundary conditions */ -class DirichletBoundaryCondition : public FieldSpecificationBase +class DirichletBoundaryCondition : public FieldSpecification { public: /// @copydoc geos::dataRepository::Group::Group( string const & name, Group * const parent ) diff --git a/src/coreComponents/fieldSpecification/EquilibriumInitialCondition.cpp b/src/coreComponents/fieldSpecification/EquilibriumInitialCondition.cpp index 6e0f1181e6e..8654e47b1b5 100644 --- a/src/coreComponents/fieldSpecification/EquilibriumInitialCondition.cpp +++ b/src/coreComponents/fieldSpecification/EquilibriumInitialCondition.cpp @@ -19,6 +19,7 @@ #include "EquilibriumInitialCondition.hpp" +#include "functions/FunctionManager.hpp" #include "functions/TableFunction.hpp" namespace geos @@ -27,7 +28,7 @@ namespace geos using namespace dataRepository; EquilibriumInitialCondition::EquilibriumInitialCondition( string const & name, Group * parent ): - FieldSpecificationBase( name, parent ) + FieldSpecification( name, parent ) { registerWrapper( viewKeyStruct::datumElevationString(), &m_datumElevation ). setInputFlag( InputFlags::REQUIRED ). @@ -77,18 +78,18 @@ EquilibriumInitialCondition::EquilibriumInitialCondition( string const & name, G setInputFlag( InputFlags::OPTIONAL ). setDescription( "Phase contacts' elevations [m]" ); - getWrapper< string >( FieldSpecificationBase::viewKeyStruct::fieldNameString() ). + getWrapper< string >( FieldSpecification::viewKeyStruct::fieldNameString() ). setInputFlag( InputFlags::FALSE ); setFieldName( catalogName() ); - getWrapper< int >( FieldSpecificationBase::viewKeyStruct::componentString() ). + getWrapper< int >( FieldSpecification::viewKeyStruct::componentString() ). setInputFlag( InputFlags::FALSE ); - getWrapper< int >( FieldSpecificationBase::viewKeyStruct::initialConditionString() ). + getWrapper< int >( FieldSpecification::viewKeyStruct::initialConditionString() ). setInputFlag( InputFlags::FALSE ); initialCondition( false ); // to make sure this is not called by applyInitialConditions - getWrapper< string_array >( FieldSpecificationBase::viewKeyStruct::setNamesString() ). + getWrapper< string_array >( FieldSpecification::viewKeyStruct::setNamesString() ). setRTTypeName( rtTypes::CustomTypes::groupNameRefArray ). setInputFlag( InputFlags::FALSE ); addSetName( "all" ); @@ -243,7 +244,7 @@ void EquilibriumInitialCondition::initializePreSubGroups() } } -REGISTER_CATALOG_ENTRY( FieldSpecificationBase, EquilibriumInitialCondition, string const &, Group * const ) +REGISTER_CATALOG_ENTRY( FieldSpecification, EquilibriumInitialCondition, string const &, Group * const ) } /* namespace geos */ diff --git a/src/coreComponents/fieldSpecification/EquilibriumInitialCondition.hpp b/src/coreComponents/fieldSpecification/EquilibriumInitialCondition.hpp index 08c91e96b2f..5d5c739f241 100644 --- a/src/coreComponents/fieldSpecification/EquilibriumInitialCondition.hpp +++ b/src/coreComponents/fieldSpecification/EquilibriumInitialCondition.hpp @@ -21,7 +21,7 @@ #ifndef GEOS_FIELDSPECIFICATION_EQUILIBRIUMINITIALCONDITION_HPP #define GEOS_FIELDSPECIFICATION_EQUILIBRIUMINITIALCONDITION_HPP -#include "FieldSpecificationBase.hpp" +#include "FieldSpecification.hpp" namespace geos { @@ -30,11 +30,11 @@ namespace geos * @class EquilibriumInitialCondition * Holds data to compute an hydrostatic equilibrium condition for flow problems */ -class EquilibriumInitialCondition : public FieldSpecificationBase +class EquilibriumInitialCondition : public FieldSpecification { public: - /// @copydoc FieldSpecificationBase(string const &, dataRepository::Group *) + /// @copydoc FieldSpecification(string const &, dataRepository::Group *) EquilibriumInitialCondition( string const & name, Group * parent ); /// deleted default constructor @@ -124,7 +124,7 @@ class EquilibriumInitialCondition : public FieldSpecificationBase /** * @brief View keys */ - struct viewKeyStruct : public FieldSpecificationBase::viewKeyStruct + struct viewKeyStruct : public FieldSpecification::viewKeyStruct { // equilibration parameters diff --git a/src/coreComponents/fieldSpecification/FieldSpecificationBase.cpp b/src/coreComponents/fieldSpecification/FieldSpecification.cpp similarity index 90% rename from src/coreComponents/fieldSpecification/FieldSpecificationBase.cpp rename to src/coreComponents/fieldSpecification/FieldSpecification.cpp index 94e78e7e06a..74f910d6cb4 100644 --- a/src/coreComponents/fieldSpecification/FieldSpecificationBase.cpp +++ b/src/coreComponents/fieldSpecification/FieldSpecification.cpp @@ -13,15 +13,13 @@ * ------------------------------------------------------------------------------------------------------------ */ -#include "FieldSpecificationBase.hpp" - -#include "fieldSpecification/FieldSpecificationManager.hpp" +#include "FieldSpecification.hpp" namespace geos { using namespace dataRepository; -FieldSpecificationBase::FieldSpecificationBase( string const & name, Group * parent ): +FieldSpecification::FieldSpecification( string const & name, Group * parent ): Group( name, parent ) { setInputFlags( InputFlags::OPTIONAL_NONUNIQUE ); @@ -99,19 +97,19 @@ FieldSpecificationBase::FieldSpecificationBase( string const & name, Group * par } -FieldSpecificationBase::~FieldSpecificationBase() +FieldSpecification::~FieldSpecification() {} -FieldSpecificationBase::CatalogInterface::CatalogType & -FieldSpecificationBase::getCatalog() +FieldSpecification::CatalogInterface::CatalogType & +FieldSpecification::getCatalog() { - static FieldSpecificationBase::CatalogInterface::CatalogType catalog; + static FieldSpecification::CatalogInterface::CatalogType catalog; return catalog; } -void FieldSpecificationBase::setMeshObjectPath( Group const & meshBodies ) +void FieldSpecification::setMeshObjectPath( Group const & meshBodies ) { try { @@ -131,6 +129,6 @@ void FieldSpecificationBase::setMeshObjectPath( Group const & meshBodies ) -REGISTER_CATALOG_ENTRY( FieldSpecificationBase, FieldSpecificationBase, string const &, Group * const ) +REGISTER_CATALOG_ENTRY( FieldSpecification, FieldSpecification, string const &, Group * const ) } diff --git a/src/coreComponents/fieldSpecification/FieldSpecification.hpp b/src/coreComponents/fieldSpecification/FieldSpecification.hpp new file mode 100644 index 00000000000..da0caa4195c --- /dev/null +++ b/src/coreComponents/fieldSpecification/FieldSpecification.hpp @@ -0,0 +1,326 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 FieldSpecification.hpp + */ + +#ifndef GEOS_FIELDSPECIFICATION_FIELDSPECIFICATION_HPP +#define GEOS_FIELDSPECIFICATION_FIELDSPECIFICATION_HPP + + +#include "common/DataTypes.hpp" +#include "common/format/EnumStrings.hpp" +#include "dataRepository/Group.hpp" +#include "mesh/MeshObjectPath.hpp" + +namespace geos +{ +class Function; + + +/** + * @class FieldSpecification + * A class to hold values for and administer a single boundary condition + */ +class FieldSpecification : public dataRepository::Group +{ +public: + + /** + * @defgroup alias and functions to defined statically initialized catalog + * @{ + */ + + /** + * alias to define the catalog type for this base type + */ + using CatalogInterface = dataRepository::CatalogInterface< FieldSpecification, + string const &, + dataRepository::Group * const >; + /** + * @enum SetErrorMode + * @brief Indicate the error handling mode. + */ + enum class SetErrorMode : integer + { + silent, + error, + warning + }; + + /** + * @brief static function to return static catalog. + * @return the static catalog to create derived types through the static factory methods. + */ + static CatalogInterface::CatalogType & getCatalog(); + + /** + * @brief Static Factory Catalog Functions + * @return the catalog name + */ + static string catalogName() { return "FieldSpecification"; } + + /** + * @brief return the catalog name + * @return the catalog name + */ + virtual const string getCatalogName() const + { return FieldSpecification::catalogName(); } + + /** + * @} + */ + + + /** + * @brief constructor + * @param name the name of the FieldSpecification in the data repository + * @param parent the parent group of this group. + */ + FieldSpecification( string const & name, dataRepository::Group * parent ); + + /** + * destructor + */ + virtual ~FieldSpecification() override; + + + /// Deleted copy constructor + FieldSpecification( FieldSpecification const & ) = delete; + + /// Defaulted move constructor + FieldSpecification( FieldSpecification && ) = default; + + /// deleted copy assignment + FieldSpecification & operator=( FieldSpecification const & ) = delete; + + /// deleted move assignement + FieldSpecification & operator=( FieldSpecification && ) = delete; + + /** + * @brief View keys + */ + struct viewKeyStruct + { + /// @return The key for setName + constexpr static char const * setNamesString() { return "setNames"; } + /// @return The key for constitutivePath + constexpr static char const * constitutivePathString() { return "constitutivePath"; } + /// @return The key for objectPath + constexpr static char const * objectPathString() { return "objectPath"; } + /// @return The key for fieldName + constexpr static char const * fieldNameString() { return "fieldName"; } + /// @return The key for dataType + constexpr static char const * dataTypeString() { return "dataType"; } + /// @return The key for component + constexpr static char const * componentString() { return "component"; } + /// @return The key for direction + constexpr static char const * directionString() { return "direction"; } + /// @return The key for bcApplicationTableName + constexpr static char const * bcApplicationTableNameString() { return "bcApplicationTableName"; } + /// @return The key for scale + constexpr static char const * scaleString() { return "scale"; } + /// @return The key for functionName + constexpr static char const * functionNameString() { return "functionName"; } + /// @return The key for initialCondition + constexpr static char const * initialConditionString() { return "initialCondition"; } + /// @return The key for beginTime + constexpr static char const * beginTimeString() { return "beginTime"; } + /// @return The key for endTime + constexpr static char const * endTimeString() { return "endTime"; } + /// @return The key errorSetMode + constexpr static char const * errorSetModeString() { return "errorSetMode"; } + }; + + /** + * Accessor + * @return const reference to m_function + */ + string const & getFunctionName() const + { return m_functionName; } + + /** + * Accessor + * @return const reference to m_objectPath + */ + virtual const string & getObjectPath() const + { return m_objectPath; } + + /** + * Accessor + * @return const reference to m_fieldName + */ + virtual const string & getFieldName() const + { return m_fieldName; } + + /** + * Accessing the considered component. + * @return The component axis or a special value. + */ + virtual int getComponent() const + { return m_component; } + + /** + * Accessor + * @return const reference to m_direction + */ + virtual R1Tensor const & getDirection() const + { return m_direction; } + + /** + * Accessor + * @return const m_beginTime + */ + real64 getStartTime() const + { return m_beginTime; } + + /** + * Accessor + * @return const m_endTime + */ + real64 getEndTime() const + { return m_endTime; } + + /** + * Accessor + * @return const reference to m_setNames + */ + string_array const & getSetNames() const + { return m_setNames; } + + /** + * Accessor + * @return const m_initialCondition + */ + int initialCondition() const + { return m_initialCondition; } + + /** + * Accessor + * @return const m_scale + */ + real64 getScale() const + { return m_scale; } + + /** + * Mutator + * @param[in] fieldName The name of the field + */ + void setFieldName( string const & fieldName ) + { m_fieldName = fieldName; } + + /** + * Mutator + * @param[in] objectPath The path for the object + */ + void setObjectPath( string const & objectPath ) + { m_objectPath = objectPath; } + + /** + * Mutator + * @param[in] scale Scaling factor + */ + void setScale( real64 const & scale ) + { m_scale = scale; } + + /** + * Mutator + * @param[in] isInitialCondition Logical value to indicate if it is an initial condition + */ + void initialCondition( bool isInitialCondition ) + { m_initialCondition = isInitialCondition; } + + /** + * Mutator + * @param[in] setName The name of the set + */ + void addSetName( string const & setName ) + { m_setNames.emplace_back( setName ); } + + /** + * @brief Set the Mesh Object Path object + * + * @param meshBodies The group containing all the MeshBody objects + */ + void setMeshObjectPath( Group const & meshBodies ); + + /** + * @brief Get the Mesh Object Paths object + * + * @return reference to const m_meshObjectPaths + */ + MeshObjectPath const & getMeshObjectPaths() const + { return *(m_meshObjectPaths.get()); } + + +protected: + + +private: + + + /// the names of the sets that the boundary condition is applied to + string_array m_setNames; + + /// the path to the object which contains the fields that the boundary condition is applied to + string m_objectPath; + + std::unique_ptr< MeshObjectPath > m_meshObjectPaths; + + /// the name of the field the boundary condition is applied to or a key string to use for + /// determining whether or not to apply the boundary condition. + string m_fieldName; + + + /// The component the boundary condition acts on. Not used if field is a scalar. + int m_component; + + /// The direction the boundary condition acts in. + R1Tensor m_direction; + + /// Whether or not the boundary condition is an initial condition. + int m_initialCondition; + + /// The name of the function used to generate values for application. + string m_functionName; + + /// The scale factor to use on the value of the boundary condition. + real64 m_scale; + + /// Time after which the bc is allowed to be applied + real64 m_beginTime; + + /// Time after which the bc will no longer be applied. + real64 m_endTime; + + /// The name of a function used to turn on and off the boundary condition. + string m_bcApplicationFunctionName; + + /// Enum containing the possible output modes when an error occur + SetErrorMode m_emptySetErrorMode; +}; + +/** + * @brief Indicate the error handling mode + */ +ENUM_STRINGS( FieldSpecification::SetErrorMode, + "silent", + "error", + "warning" ); + +} + +#endif //GEOS_FIELDSPECIFICATION_FIELDSPECIFICATION_HPP diff --git a/src/coreComponents/fieldSpecification/FieldSpecificationBase.hpp b/src/coreComponents/fieldSpecification/FieldSpecificationImpl.hpp similarity index 50% rename from src/coreComponents/fieldSpecification/FieldSpecificationBase.hpp rename to src/coreComponents/fieldSpecification/FieldSpecificationImpl.hpp index 1905a4e5c36..e23419628f1 100644 --- a/src/coreComponents/fieldSpecification/FieldSpecificationBase.hpp +++ b/src/coreComponents/fieldSpecification/FieldSpecificationImpl.hpp @@ -14,16 +14,15 @@ */ /** - * @file FieldSpecificationBase.hpp + * @file FieldSpecificationImpl.hpp */ -#ifndef GEOS_FIELDSPECIFICATION_FIELDSPECIFICATIONBASE_HPP -#define GEOS_FIELDSPECIFICATION_FIELDSPECIFICATIONBASE_HPP +#ifndef GEOS_FIELDSPECIFICATION_FIELDSPECIFICATIONIMPL_HPP +#define GEOS_FIELDSPECIFICATION_FIELDSPECIFICATIONIMPL_HPP +#include "FieldSpecification.hpp" #include "common/DataTypes.hpp" #include "common/TypeDispatch.hpp" -#include "codingUtilities/traits.hpp" -#include "codingUtilities/Utilities.hpp" #include "dataRepository/Group.hpp" #include "functions/FunctionBase.hpp" #include "common/FieldSpecificationOps.hpp" @@ -38,192 +37,137 @@ class Function; /** - * @class FieldSpecificationBase - * A class to hold values for and administer a single boundary condition + * @class FieldSpecificationImpl + * @brief Methods to apply field specifications */ -class FieldSpecificationBase : public dataRepository::Group +class FieldSpecificationImpl { public: /** - * @defgroup alias and functions to defined statically initialized catalog - * @{ - */ - - /** - * alias to define the catalog type for this base type - */ - using CatalogInterface = dataRepository::CatalogInterface< FieldSpecificationBase, - string const &, - dataRepository::Group * const >; - /** - * @enum SetErrorMode - * @brief Indicate the error handling mode. - */ - enum class SetErrorMode : integer - { - silent, - error, - warning - }; - - /** - * @brief static function to return static catalog. - * @return the static catalog to create derived types through the static factory methods. - */ - static CatalogInterface::CatalogType & getCatalog(); - - /** - * @brief Static Factory Catalog Functions - * @return the catalog name - */ - static string catalogName() { return "FieldSpecification"; } - - /** - * @brief return the catalog name - * @return the catalog name - */ - virtual const string getCatalogName() const - { - return FieldSpecificationBase::catalogName(); - } - - /** - * @} - */ - - - /** - * @brief constructor - * @param name the name of the FieldSpecificationBase in the data repository - * @param parent the parent group of this group. - */ - FieldSpecificationBase( string const & name, dataRepository::Group * parent ); - - /** - * destructor + * @brief Apply this field specification to the discretization + * + * @tparam OBJECT_TYPE The type of discretization/mesh object that the + * specification is being applied to. + * @tparam BC_TYPE The type of BC being applied + * @tparam LAMBDA + * @param fs The field specification data object + * @param mesh The MeshLevel that the specification is applied to + * @param lambda The being executed */ - virtual ~FieldSpecificationBase() override; - - - /// Deleted copy constructor - FieldSpecificationBase( FieldSpecificationBase const & ) = delete; - - /// Defaulted move constructor - FieldSpecificationBase( FieldSpecificationBase && ) = default; - - /// deleted copy assignment - FieldSpecificationBase & operator=( FieldSpecificationBase const & ) = delete; - - /// deleted move assignement - FieldSpecificationBase & operator=( FieldSpecificationBase && ) = delete; + template< typename OBJECT_TYPE, typename BC_TYPE = FieldSpecification, typename LAMBDA > + static void apply( BC_TYPE const & fs, MeshLevel & mesh, LAMBDA && lambda ); /** - * @brief Apply this field specification to the discretization + * @brief If applicable in the current time and field, apply this field specification + * to the discretization * * @tparam OBJECT_TYPE The type of discretization/mesh object that the * specification is being applied to. * @tparam BC_TYPE The type of BC being applied * @tparam LAMBDA + * @param fs The field specification data object * @param mesh The MeshLevel that the specification is applied to * @param lambda The being executed + * @param time The time at which the field will be evaluated. For instance if the + * field is a time dependent function, this is the evaluation time. + * @param fieldName The name of the field/variable that the value will be applied to. + * It may not be necessary that this name is in the data repository, as the user + * supplied lambda may apply whatever it condition it would like. However, this + * name is used for comparing against the value given in the specification. + + * This function checks if the field should be applied, and applies it. More specifically, + * this function simply checks the values of fieldName against its FieldSpecification object + * and decides on whether or not to call the user defined lambda. */ - template< typename OBJECT_TYPE, - typename BC_TYPE = FieldSpecificationBase, - typename LAMBDA > - void apply( MeshLevel & mesh, - LAMBDA && lambda ) const - { - MeshObjectPath const & meshObjectPaths = this->getMeshObjectPaths(); - meshObjectPaths.forObjectsInPath< OBJECT_TYPE >( mesh, - [&] ( OBJECT_TYPE & object ) - { - { - dataRepository::Group const & setGroup = object.getGroup( ObjectManagerBase::groupKeyStruct::setsString() ); - string_array setNames = this->getSetNames(); - for( auto & setName : setNames ) - { - if( setGroup.hasWrapper( setName ) ) - { - SortedArrayView< localIndex const > const & targetSet = setGroup.getReference< SortedArray< localIndex > >( setName ); - lambda( dynamic_cast< BC_TYPE const & >(*this), setName, targetSet, object, getFieldName() ); - } - } - } - } ); - } + template< typename OBJECT_TYPE, typename BC_TYPE = FieldSpecification, typename LAMBDA > + static void apply( BC_TYPE const & fs, + MeshLevel & mesh, + LAMBDA && lambda, + real64 const & time, + string const & fieldName ); /** * @tparam FIELD_OP type that contains static functions to apply the value to the field + * @param[in] fs the field specification data object. * @param[in] field the field to apply the value to. * @param[in] targetSet the set of indices which the value will be applied. - * @param[in] time The time at which any time dependent functions are to be evaluated as part of the - * application of the value. + * @param[in] time The time at which any time dependent functions are to be evaluated as + * part of the application of the value. * @param[in] dataGroup the Group that contains the field to apply the value to. * * This function applies the value to a field variable. */ template< typename FIELD_OP, typename POLICY, typename T, int N, int USD > - void applyFieldValueKernel( ArrayView< T, N, USD > const & field, - SortedArrayView< localIndex const > const & targetSet, - real64 const time, - Group & dataGroup ) const; + static void applyFieldValueKernel( FieldSpecification const & fs, + ArrayView< T, N, USD > const & field, + SortedArrayView< localIndex const > const & targetSet, + real64 const time, + dataRepository::Group & dataGroup ); /** * @tparam FIELD_OP type that contains static functions to apply the value to the field + * @param[in] fs the field specification data object * @param[in] targetSet the set of indices which the value will be applied. - * @param[in] time The time at which any time dependent functions are to be evaluated as part of the - * application of the value. + * @param[in] time The time at which any time dependent functions are to be evaluated as + * part of the application of the value. * @param[in] dataGroup the Group that contains the field to apply the value to. - * @param[in] fieldname the name of the field to apply the value to. + * @param[in] fieldName the name of the field to apply the value to. * * This function applies the value to a field variable. This function is typically * called from within the lambda to a call to FieldSpecificationManager::applyFieldValue(). */ template< typename FIELD_OP, typename POLICY=parallelHostPolicy > - void applyFieldValue( SortedArrayView< localIndex const > const & targetSet, - real64 const time, - dataRepository::Group & dataGroup, - string const & fieldname ) const; + static void applyFieldValue( FieldSpecification const & fs, + SortedArrayView< localIndex const > const & targetSet, + real64 const time, + dataRepository::Group & dataGroup, + string const & fieldName ); /** * @brief Apply a boundary condition to a system of equations. - * @tparam FIELD_OP A wrapper struct to define how the boundary condition operates on the variables. - * Either \ref OpEqual or \ref OpAdd. + * @tparam FIELD_OP A wrapper struct to define how the boundary condition operates on + * the variables. Either \ref OpEqual or \ref OpAdd. * @tparam POLICY Execution policy to use when iterating over the target set. * @tparam T Data type of the field. * @tparam NDIM Number of dimensions in the field array. * @tparam USD Unit stride dimension of the field array. + * @param fs The field specification data object. * @param targetSet The set of indices which the boundary condition will be applied. - * @param time The time at which any time dependent functions are to be evaluated as part of the - * application of the boundary condition. + * @param time The time at which any time dependent functions are to be evaluated as + * part of the application of the boundary condition. * @param dataGroup The Group that contains the field to apply the boundary condition to. - * @param dofMap The map from the local index of the primary field to the global degree of freedom number. + * @param dofMap The map from the local index of the primary field to the global degree of + * freedom number. * @param dofRankOffset Offset of dof indices on current rank. * @param matrix Local part of the system matrix. * @param rhs Local part of the system rhs vector. * @param fieldView Array view of the field data. * - * @note This function is rarely used directly. More often it is called by other ApplyBoundaryCondition functions. + * @note This function is rarely used directly. More often it is called by + * other ApplyBoundaryCondition functions. */ template< typename FIELD_OP, typename POLICY, typename T, int NDIM, int USD > - void applyBoundaryConditionToSystemKernel( SortedArrayView< localIndex const > const & targetSet, - real64 const time, - dataRepository::Group const & dataGroup, - arrayView1d< globalIndex const > const & dofMap, - globalIndex const dofRankOffset, - CRSMatrixView< real64, globalIndex const > const & matrix, - arrayView1d< real64 > const & rhs, - ArrayView< T const, NDIM, USD > const & fieldView ) const; + static void + applyBoundaryConditionToSystemKernel( FieldSpecification const & fs, + SortedArrayView< localIndex const > const & targetSet, + real64 const time, + dataRepository::Group const & dataGroup, + arrayView1d< globalIndex const > const & dofMap, + globalIndex const dofRankOffset, + CRSMatrixView< real64, globalIndex const > const & matrix, + arrayView1d< real64 > const & rhs, + ArrayView< T const, NDIM, USD > const & fieldView ); /** * @brief Apply a boundary condition to a system of equations. - * @tparam FIELD_OP A wrapper struct to define how the boundary condition operates on the variables. - * Either \ref OpEqual or \ref OpAdd. + * @tparam FIELD_OP A wrapper struct to define how the boundary condition operates on + * the variables. Either \ref OpEqual or \ref OpAdd. * @tparam POLICY Execution policy to use when iterating over target set. + * @param[in] fs The field specification data object * @param[in] targetSet The set of indices which the boundary condition will be applied. - * @param[in] time The time at which any time dependent functions are to be evaluated as part of the - * application of the boundary condition. + * @param[in] time The time at which any time dependent functions are to be evaluated as + * part of the application of the boundary condition. * @param[in] dataGroup The Group that contains the field to apply the boundary condition to. * @param[in] fieldName The name of the field to apply the boundary condition to. * @param[in] dofMapName The name of the map from the local index of the primary field to the @@ -232,61 +176,67 @@ class FieldSpecificationBase : public dataRepository::Group * @param[in,out] matrix Local part of the system matrix. * @param[in,out] rhs Local part of the system rhs vector. * - * This function applies the boundary condition to a linear system of equations. This function is - * typically called from within the lambda to a call to BoundaryConditionManager::ApplyBoundaryCondition(). + * This function applies the boundary condition to a linear system of equations. + * This function is typically called from within the lambda to a call to + * BoundaryConditionManager::ApplyBoundaryCondition(). */ template< typename FIELD_OP, typename POLICY > - void applyBoundaryConditionToSystem( SortedArrayView< localIndex const > const & targetSet, - real64 const time, - dataRepository::Group const & dataGroup, - string const & fieldName, - string const & dofMapName, - globalIndex const dofRankOffset, - CRSMatrixView< real64, globalIndex const > const & matrix, - arrayView1d< real64 > const & rhs ) const; + static void + applyBoundaryConditionToSystem( FieldSpecification const & fs, + SortedArrayView< localIndex const > const & targetSet, + real64 const time, + dataRepository::Group const & dataGroup, + string const & fieldName, + string const & dofMapName, + globalIndex const dofRankOffset, + CRSMatrixView< real64, globalIndex const > const & matrix, + arrayView1d< real64 > const & rhs ); /** * @brief Apply a boundary condition to a system of equations. - * @tparam FIELD_OP A wrapper struct to define how the boundary condition operates on the variables. - * Either \ref OpEqual or \ref OpAdd. + * @tparam FIELD_OP A wrapper struct to define how the boundary condition operates on + * the variables. Either \ref OpEqual or \ref OpAdd. * @tparam POLICY Execution policy to use when iterating over target set. * @tparam LAMBDA The type of lambda function passed into the parameter list. + * @param[in] fs The field specification data object. * @param[in] targetSet The set of indices which the boundary condition will be applied. - * @param[in] time The time at which any time dependent functions are to be evaluated as part of the - * application of the boundary condition. + * @param[in] time The time at which any time dependent functions are to be evaluated as + * part of the application of the boundary condition. * @param[in] dataGroup The Group that contains the field to apply the boundary condition to. * @param[in] dofMap The map from the local index of the primary field to the global degree of * freedom number. * @param[in] dofRankOffset Offset of dof indices on current rank. * @param[inout] matrix Local part of the system matrix. * @param[inout] rhs Local part of the system rhs vector. - * @param[in] lambda A lambda function which defines how the value that is passed into the functions - * provided by the FIELD_OP templated type. + * @param[in] lambda A lambda function which defines how the value that is passed into + * the functions provided by the FIELD_OP templated type. * - * This function applies the boundary condition to a linear system of equations. This function is - * typically called from within the lambda to a call to + * This function applies the boundary condition to a linear system of equations. + * This function is typically called from within the lambda to a call to * BoundaryConditionManager::ApplyBoundaryCondition(). */ template< typename FIELD_OP, typename POLICY, typename LAMBDA > - void - applyBoundaryConditionToSystem( SortedArrayView< localIndex const > const & targetSet, + static void + applyBoundaryConditionToSystem( FieldSpecification const & fs, + SortedArrayView< localIndex const > const & targetSet, real64 const time, dataRepository::Group const & dataGroup, arrayView1d< globalIndex const > const & dofMap, globalIndex const dofRankOffset, CRSMatrixView< real64, globalIndex const > const & matrix, arrayView1d< real64 > const & rhs, - LAMBDA && lambda ) const; + LAMBDA && lambda ); /** * @brief Apply a boundary condition to a system of equations. - * @tparam FIELD_OP A wrapper struct to define how the boundary condition operates on the variables. - * Either \ref OpEqual or \ref OpAdd. + * @tparam FIELD_OP A wrapper struct to define how the boundary condition operates on + * the variables. Either \ref OpEqual or \ref OpAdd. * @tparam POLICY Execution policy to use when iterating over target set. * @tparam LAMBDA The type of lambda function passed into the parameter list. + * @param[in] fs The field specification data object. * @param[in] targetSet The set of indices which the boundary condition will be applied. - * @param[in] time The time at which any time dependent functions are to be evaluated as part of the - * application of the boundary condition. + * @param[in] time The time at which any time dependent functions are to be evaluated as + * part of the application of the boundary condition. * @param[in] dt time step size which is applied as a factor to bc values * @param[in] dataGroup The Group that contains the field to apply the boundary condition to. * @param[in] dofMap The map from the local index of the primary field to the global degree of @@ -294,16 +244,17 @@ class FieldSpecificationBase : public dataRepository::Group * @param[in] dofRankOffset Offset of dof indices on current rank. * @param[inout] matrix Local part of the system matrix. * @param[inout] rhs Local part of the system rhs vector. - * @param[in] lambda A lambda function which defines how the value that is passed into the functions - * provided by the FIELD_OP templated type. + * @param[in] lambda A lambda function which defines how the value that is passed into the + * functions provided by the FIELD_OP templated type. * - * This function applies the boundary condition to a linear system of equations. This function is - * typically called from within the lambda to a call to + * This function applies the boundary condition to a linear system of equations. + * This function is typically called from within the lambda to a call to * BoundaryConditionManager::ApplyBoundaryCondition(). */ template< typename FIELD_OP, typename POLICY, typename LAMBDA > - void - applyBoundaryConditionToSystem( SortedArrayView< localIndex const > const & targetSet, + static void + applyBoundaryConditionToSystem( FieldSpecification const & fs, + SortedArrayView< localIndex const > const & targetSet, real64 const time, real64 const dt, dataRepository::Group const & dataGroup, @@ -311,40 +262,48 @@ class FieldSpecificationBase : public dataRepository::Group globalIndex const dofRankOffset, CRSMatrixView< real64, globalIndex const > const & matrix, arrayView1d< real64 > const & rhs, - LAMBDA && lambda ) const; + LAMBDA && lambda ); /** - * @brief Compute the contributions that will be added/enforced to the right-hand side, and collect the corresponding dof numbers - * @tparam FIELD_OP A wrapper struct to define how the boundary condition operates on the variables. - * Either \ref OpEqual or \ref OpAdd. + * @brief Compute the contributions that will be added/enforced to the right-hand side, + * and collect the corresponding dof numbers + * @tparam FIELD_OP A wrapper struct to define how the boundary condition operates on + * the variables. Either \ref OpEqual or \ref OpAdd. * @tparam POLICY Execution policy to use when iterating over target set. * @tparam LAMBDA The type of lambda function passed into the parameter list. + * @param[in] fs The field specification data object. * @param[in] targetSet The set of indices which the boundary condition will be applied. - * @param[in] time The time at which any time dependent functions are to be evaluated as part of the - * application of the boundary condition. + * @param[in] time The time at which any time dependent functions are to be evaluated as + * part of the application of the boundary condition. * @param[in] dt time step size which is applied as a factor to bc values * @param[in] dataGroup The Group that contains the field to apply the boundary condition to. * @param[in] dofMap The map from the local index of the primary field to the global degree of * freedom number. * @param[in] dofRankOffset Offset of dof indices on current rank. * @param[inout] matrix Local part of the system matrix. - * @param[inout] dof array storing the degrees of freedom of the rhsContribution, to know where in the rhs they will be added/enforced - * @param[inout] rhsContribution array storing the values that will be added/enforced to the right-hand side - * @param[in] lambda A lambda function which defines how the value that is passed into the functions - * provided by the FIELD_OP templated type. + * @param[inout] dof array storing the degrees of freedom of the rhsContribution, to know where + * in the rhs they will be added/enforced + * @param[inout] rhsContribution array storing the values that will be added/enforced to the + * right-hand side + * @param[in] lambda A lambda function which defines how the value that is passed into the + * functions provided by the FIELD_OP templated type. * - * Note that this function only computes the rhs contributions, but does not apply them to the right-hand side. + * Note that this function only computes the rhs contributions, but does not apply them + * to the right-hand side. * The application of these rhs contributions is done in applyBoundaryConditionToSystem. * - * Why did we have to extract the computation of the rhs contributions from applyBoundaryConditionToSystem? - * Because applyBoundaryConditionToSystem is not very well suited to apply the rhsContributions to the equation layout used in the - * compositional solvers. - * Therefore, the compositional solvers do not call applyBoundaryConditionToSystem, but instead call computeRhsContribution directly, and - * apply these rhs contributions "manually" according to the equation layout used in the solver + * Why did we have to extract the computation of the rhs contributions from + * applyBoundaryConditionToSystem? + * Because applyBoundaryConditionToSystem is not very well suited to apply the rhsContributions + * to the equation layout used in the compositional solvers. + * Therefore, the compositional solvers do not call applyBoundaryConditionToSystem, but instead + * call computeRhsContribution directly, and apply these rhs contributions "manually" according + * to the equation layout used in the solver */ template< typename FIELD_OP, typename POLICY, typename LAMBDA > - void - computeRhsContribution( SortedArrayView< localIndex const > const & targetSet, + static void + computeRhsContribution( FieldSpecification const & fs, + SortedArrayView< localIndex const > const & targetSet, real64 const time, real64 const dt, dataRepository::Group const & dataGroup, @@ -353,12 +312,12 @@ class FieldSpecificationBase : public dataRepository::Group CRSMatrixView< real64, globalIndex const > const & matrix, arrayView1d< globalIndex > const & dof, arrayView1d< real64 > const & rhsContribution, - LAMBDA && lambda ) const; - + LAMBDA && lambda ); /** * @brief Function to zero matrix rows to apply boundary conditions * @tparam POLICY the execution policy to use when zeroing rows + * @param[in] fs The field specification data object * @param[in] targetSet The set of indices which the boundary condition will be applied. * @param[in] dofMap The map from the local index of the primary field to the global degree of * freedom number. @@ -367,259 +326,71 @@ class FieldSpecificationBase : public dataRepository::Group * This function zeroes the rows of the matrix that correspond to boundary conditions. */ template< typename POLICY > - void zeroSystemRowsForBoundaryCondition( SortedArrayView< localIndex const > const & targetSet, - arrayView1d< globalIndex const > const & dofMap, - CRSMatrixView< real64, globalIndex const > const & matrix ) const; - - /** - * @brief View keys - */ - struct viewKeyStruct - { - /// @return The key for setName - constexpr static char const * setNamesString() { return "setNames"; } - /// @return The key for constitutivePath - constexpr static char const * constitutivePathString() { return "constitutivePath"; } - /// @return The key for objectPath - constexpr static char const * objectPathString() { return "objectPath"; } - /// @return The key for fieldName - constexpr static char const * fieldNameString() { return "fieldName"; } - /// @return The key for dataType - constexpr static char const * dataTypeString() { return "dataType"; } - /// @return The key for component - constexpr static char const * componentString() { return "component"; } - /// @return The key for direction - constexpr static char const * directionString() { return "direction"; } - /// @return The key for bcApplicationTableName - constexpr static char const * bcApplicationTableNameString() { return "bcApplicationTableName"; } - /// @return The key for scale - constexpr static char const * scaleString() { return "scale"; } - /// @return The key for functionName - constexpr static char const * functionNameString() { return "functionName"; } - /// @return The key for initialCondition - constexpr static char const * initialConditionString() { return "initialCondition"; } - /// @return The key for beginTime - constexpr static char const * beginTimeString() { return "beginTime"; } - /// @return The key for endTime - constexpr static char const * endTimeString() { return "endTime"; } - /// @return The key errorSetMode - constexpr static char const * errorSetModeString() { return "errorSetMode"; } - }; - - /** - * Accessor - * @return const reference to m_function - */ - string const & getFunctionName() const - { - return m_functionName; - } - - /** - * Accessor - * @return const reference to m_objectPath - */ - virtual const string & getObjectPath() const - { - return m_objectPath; - } - - /** - * Accessor - * @return const reference to m_fieldName - */ - virtual const string & getFieldName() const - { - return m_fieldName; - } - - /** - * Accessing the considered component. - * @return The component axis or a special value. - */ - virtual int getComponent() const - { - return m_component; - } - - /** - * Accessor - * @return const reference to m_direction - */ - virtual R1Tensor const & getDirection() const - { - GEOS_UNUSED_VAR( time ); - return m_direction; - } - - /** - * Accessor - * @return const m_beginTime - */ - real64 getStartTime() const - { - return m_beginTime; - } - - /** - * Accessor - * @return const m_endTime - */ - real64 getEndTime() const - { - return m_endTime; - } - - /** - * Accessor - * @return const reference to m_setNames - */ - string_array const & getSetNames() const - { - return m_setNames; - } - - /** - * Accessor - * @return const m_initialCondition - */ - int initialCondition() const - { - return m_initialCondition; - } - - /** - * Accessor - * @return const m_scale - */ - real64 getScale() const - { - return m_scale; - } - - /** - * Mutator - * @param[in] fieldName The name of the field - */ - void setFieldName( string const & fieldName ) - { - m_fieldName = fieldName; - } - - /** - * Mutator - * @param[in] objectPath The path for the object - */ - void setObjectPath( string const & objectPath ) - { - m_objectPath = objectPath; - } - - /** - * Mutator - * @param[in] scale Scaling factor - */ - void setScale( real64 const & scale ) - { - m_scale = scale; - } - - /** - * Mutator - * @param[in] isInitialCondition Logical value to indicate if it is an initial condition - */ - void initialCondition( bool isInitialCondition ) - { - m_initialCondition = isInitialCondition; - } + static void + zeroSystemRowsForBoundaryCondition( FieldSpecification const & fs, + SortedArrayView< localIndex const > const & targetSet, + arrayView1d< globalIndex const > const & dofMap, + CRSMatrixView< real64, globalIndex const > const & matrix ); +}; - /** - * Mutator - * @param[in] setName The name of the set - */ - void addSetName( string const & setName ) +template< typename OBJECT_TYPE, typename BC_TYPE, typename LAMBDA > +void FieldSpecificationImpl::apply( BC_TYPE const & fs, + MeshLevel & mesh, + LAMBDA && lambda ) +{ + MeshObjectPath const & meshObjectPaths = fs.getMeshObjectPaths(); + meshObjectPaths.forObjectsInPath< OBJECT_TYPE >( mesh, + [&] ( OBJECT_TYPE & object ) { - m_setNames.emplace_back( setName ); - } - - /** - * @brief Set the Mesh Object Path object - * - * @param meshBodies The group containing all the MeshBody objects - */ - void setMeshObjectPath( Group const & meshBodies ); + { + dataRepository::Group const & setGroup = object.getGroup( ObjectManagerBase::groupKeyStruct::setsString() ); + string_array setNames = fs.getSetNames(); + for( auto & setName : setNames ) + { + if( setGroup.hasWrapper( setName ) ) + { + SortedArrayView< localIndex const > const & targetSet = + setGroup.getReference< SortedArray< localIndex > >( setName ); + lambda( fs, setName, targetSet, object, fs.getFieldName() ); + } + } + } + } ); +} - /** - * @brief Get the Mesh Object Paths object - * - * @return reference to const m_meshObjectPaths - */ - MeshObjectPath const & getMeshObjectPaths() const +template< typename OBJECT_TYPE, typename BC_TYPE, typename LAMBDA > +void FieldSpecificationImpl::apply( BC_TYPE const & fs, + MeshLevel & mesh, + LAMBDA && lambda, + real64 const & time, + string const & fieldName ) +{ + integer const isInitialCondition = fs.initialCondition(); + if( ( isInitialCondition && fieldName=="") || // this only use case for this line is in the unit test for field specification + ( !isInitialCondition && time >= fs.getStartTime() + && time < fs.getEndTime() + && fieldName == fs.getFieldName() ) ) { - return *(m_meshObjectPaths.get()); + FieldSpecificationImpl::apply< OBJECT_TYPE >( fs, mesh, std::forward< LAMBDA >( lambda ) ); } - - -protected: - - -private: - - - /// the names of the sets that the boundary condition is applied to - string_array m_setNames; - - /// the path to the object which contains the fields that the boundary condition is applied to - string m_objectPath; - - std::unique_ptr< MeshObjectPath > m_meshObjectPaths; - - /// the name of the field the boundary condition is applied to or a key string to use for - /// determining whether or not to apply the boundary condition. - string m_fieldName; - - - /// The component the boundary condition acts on. Not used if field is a scalar. - int m_component; - - /// The direction the boundary condition acts in. - R1Tensor m_direction; - - /// Whether or not the boundary condition is an initial condition. - int m_initialCondition; - - /// The name of the function used to generate values for application. - string m_functionName; - - /// The scale factor to use on the value of the boundary condition. - real64 m_scale; - - /// Time after which the bc is allowed to be applied - real64 m_beginTime; - - /// Time after which the bc will no longer be applied. - real64 m_endTime; - - /// The name of a function used to turn on and off the boundary condition. - string m_bcApplicationFunctionName; - - /// Enum containing the possible output modes when an error occur - SetErrorMode m_emptySetErrorMode; -}; - +} template< typename FIELD_OP, typename POLICY, typename T, int N, int USD > -void FieldSpecificationBase::applyFieldValueKernel( ArrayView< T, N, USD > const & field, - SortedArrayView< localIndex const > const & targetSet, - real64 const time, - Group & dataGroup ) const +void +FieldSpecificationImpl:: + applyFieldValueKernel( FieldSpecification const & fs, + ArrayView< T, N, USD > const & field, + SortedArrayView< localIndex const > const & targetSet, + real64 const time, + dataRepository::Group & dataGroup ) { - integer const component = getComponent(); + integer const component = fs.getComponent(); + string const & functionName = fs.getFunctionName(); FunctionManager & functionManager = FunctionManager::getInstance(); - if( m_functionName.empty() ) + if( functionName.empty() ) { - real64 const value = m_scale; + real64 const value = fs.getScale(); forAll< POLICY >( targetSet.size(), [=] GEOS_HOST_DEVICE ( localIndex const i ) { localIndex const a = targetSet[ i ]; @@ -632,15 +403,18 @@ void FieldSpecificationBase::applyFieldValueKernel( ArrayView< T, N, USD > const { try { - return functionManager.getGroup< FunctionBase >( m_functionName ); + return functionManager.getGroup< FunctionBase >( functionName ); } catch( std::exception const & e ) { string const errorMsg = GEOS_FMT( "Error while reading {}:\n", - getWrapperDataContext( viewKeyStruct::functionNameString() ) ); + fs.getWrapperDataContext( FieldSpecification:: + viewKeyStruct:: + functionNameString() ) ); ErrorLogger::global().modifyCurrentExceptionMessage() .addToMsg( errorMsg ) - .addContextInfo( getWrapperDataContext( viewKeyStruct::functionNameString() ).getContextInfo() + .addContextInfo( fs.getWrapperDataContext( FieldSpecification::viewKeyStruct::functionNameString() ) + .getContextInfo() .setPriority( 1 ) ); throw InputError( e, errorMsg ); } @@ -648,7 +422,7 @@ void FieldSpecificationBase::applyFieldValueKernel( ArrayView< T, N, USD > const if( function.isFunctionOfTime()==2 ) { - real64 const value = m_scale * function.evaluate( &time ); + real64 const value = fs.getScale() * function.evaluate( &time ); forAll< POLICY >( targetSet.size(), [=] GEOS_HOST_DEVICE ( localIndex const i ) { localIndex const a = targetSet[ i ]; @@ -660,7 +434,7 @@ void FieldSpecificationBase::applyFieldValueKernel( ArrayView< T, N, USD > const real64_array result( static_cast< localIndex >( targetSet.size() ) ); function.evaluate( dataGroup, time, targetSet, result ); arrayView1d< real64 const > const & resultView = result.toViewConst(); - real64 const scale = m_scale; + real64 const scale = fs.getScale(); forAll< POLICY >( targetSet.size(), [=] GEOS_HOST_DEVICE ( localIndex const i ) { localIndex const a = targetSet[ i ]; @@ -670,17 +444,19 @@ void FieldSpecificationBase::applyFieldValueKernel( ArrayView< T, N, USD > const } } - template< typename FIELD_OP, typename POLICY > -void FieldSpecificationBase::applyFieldValue( SortedArrayView< localIndex const > const & targetSet, - real64 const time, - dataRepository::Group & dataGroup, - string const & fieldName ) const +void +FieldSpecificationImpl:: + applyFieldValue( FieldSpecification const & fs, + SortedArrayView< localIndex const > const & targetSet, + real64 const time, + dataRepository::Group & dataGroup, + string const & fieldName ) { dataRepository::WrapperBase & wrapper = dataGroup.getWrapperBase( fieldName ); - // // This function is used in setting boundary/initial conditions on simulation fields. - // // This is meaningful for 1/2/3D real arrays and sometimes 1D integer (indicator) arrays. + // This function is used in setting boundary/initial conditions on simulation fields. + // This is meaningful for 1/2/3D real arrays and sometimes 1D integer (indicator) arrays. using FieldTypes = types::ListofTypeList< types::Join< types::ArrayTypes< types::RealTypes, types::DimsUpTo< 3 > >, types::ArrayTypes< types::TypeList< integer >, types::DimsSingle< 1 > > > >; @@ -689,23 +465,37 @@ void FieldSpecificationBase::applyFieldValue( SortedArrayView< localIndex const { using ArrayType = camp::first< decltype( tupleOfTypes ) >; auto & wrapperT = dataRepository::Wrapper< ArrayType >::cast( wrapper ); - applyFieldValueKernel< FIELD_OP, POLICY >( wrapperT.reference().toView(), targetSet, time, dataGroup ); + applyFieldValueKernel< FIELD_OP, POLICY >( fs, + wrapperT.reference().toView(), + targetSet, + time, + dataGroup ); }, wrapper ); } template< typename FIELD_OP, typename POLICY, typename T, int NDIM, int USD > -void FieldSpecificationBase::applyBoundaryConditionToSystemKernel( SortedArrayView< localIndex const > const & targetSet, - real64 const time, - dataRepository::Group const & dataGroup, - arrayView1d< globalIndex const > const & dofMap, - globalIndex const dofRankOffset, - CRSMatrixView< real64, globalIndex const > const & matrix, - arrayView1d< real64 > const & rhs, - ArrayView< T const, NDIM, USD > const & fieldView ) const +void +FieldSpecificationImpl:: + applyBoundaryConditionToSystemKernel( FieldSpecification const & fs, + SortedArrayView< localIndex const > const & targetSet, + real64 const time, + dataRepository::Group const & dataGroup, + arrayView1d< globalIndex const > const & dofMap, + globalIndex const dofRankOffset, + CRSMatrixView< real64, globalIndex const > const & matrix, + arrayView1d< real64 > const & rhs, + ArrayView< T const, NDIM, USD > const & fieldView ) { - integer const component = getComponent(); - this->applyBoundaryConditionToSystem< FIELD_OP, POLICY >( targetSet, time, dataGroup, dofMap, dofRankOffset, matrix, rhs, - [fieldView, component] GEOS_HOST_DEVICE ( localIndex const a ) + integer const component = fs.getComponent(); + applyBoundaryConditionToSystem< FIELD_OP, POLICY >( fs, + targetSet, + time, + dataGroup, + dofMap, + dofRankOffset, + matrix, + rhs, + [fieldView, component] GEOS_HOST_DEVICE ( localIndex const a ) { real64 value = 0.0; FieldSpecificationEqual::readFieldValue( fieldView, a, component, value ); @@ -714,14 +504,17 @@ void FieldSpecificationBase::applyBoundaryConditionToSystemKernel( SortedArrayVi } template< typename FIELD_OP, typename POLICY > -void FieldSpecificationBase::applyBoundaryConditionToSystem( SortedArrayView< localIndex const > const & targetSet, - real64 const time, - dataRepository::Group const & dataGroup, - string const & fieldName, - string const & dofMapName, - globalIndex const dofRankOffset, - CRSMatrixView< real64, globalIndex const > const & matrix, - arrayView1d< real64 > const & rhs ) const +void +FieldSpecificationImpl:: + applyBoundaryConditionToSystem( FieldSpecification const & fs, + SortedArrayView< localIndex const > const & targetSet, + real64 const time, + dataRepository::Group const & dataGroup, + string const & fieldName, + string const & dofMapName, + globalIndex const dofRankOffset, + CRSMatrixView< real64, globalIndex const > const & matrix, + arrayView1d< real64 > const & rhs ) { dataRepository::WrapperBase const & wrapper = dataGroup.getWrapperBase( fieldName ); arrayView1d< globalIndex const > const & dofMap = dataGroup.getReference< array1d< globalIndex > >( dofMapName ); @@ -732,7 +525,8 @@ void FieldSpecificationBase::applyBoundaryConditionToSystem( SortedArrayView< lo { using ArrayType = camp::first< decltype( tupleOfTypes ) >; auto const & wrapperT = dataRepository::Wrapper< ArrayType >::cast( wrapper ); - applyBoundaryConditionToSystemKernel< FIELD_OP, POLICY >( targetSet, + applyBoundaryConditionToSystemKernel< FIELD_OP, POLICY >( fs, + targetSet, time, dataGroup, dofMap, @@ -745,17 +539,19 @@ void FieldSpecificationBase::applyBoundaryConditionToSystem( SortedArrayView< lo template< typename FIELD_OP, typename POLICY, typename LAMBDA > void -FieldSpecificationBase:: - applyBoundaryConditionToSystem( SortedArrayView< localIndex const > const & targetSet, +FieldSpecificationImpl:: + applyBoundaryConditionToSystem( FieldSpecification const & fs, + SortedArrayView< localIndex const > const & targetSet, real64 const time, dataRepository::Group const & dataGroup, arrayView1d< globalIndex const > const & dofMap, globalIndex const dofRankOffset, CRSMatrixView< real64, globalIndex const > const & matrix, arrayView1d< real64 > const & rhs, - LAMBDA && lambda ) const + LAMBDA && lambda ) { - return applyBoundaryConditionToSystem< FIELD_OP, POLICY >( targetSet, + return applyBoundaryConditionToSystem< FIELD_OP, POLICY >( fs, + targetSet, time, 1.0, dataGroup, @@ -768,8 +564,9 @@ FieldSpecificationBase:: template< typename FIELD_OP, typename POLICY, typename LAMBDA > void -FieldSpecificationBase:: - applyBoundaryConditionToSystem( SortedArrayView< localIndex const > const & targetSet, +FieldSpecificationImpl:: + applyBoundaryConditionToSystem( FieldSpecification const & fs, + SortedArrayView< localIndex const > const & targetSet, real64 const time, real64 const dt, dataRepository::Group const & dataGroup, @@ -777,7 +574,7 @@ FieldSpecificationBase:: globalIndex const dofRankOffset, CRSMatrixView< real64, globalIndex const > const & matrix, arrayView1d< real64 > const & rhs, - LAMBDA && lambda ) const + LAMBDA && lambda ) { array1d< globalIndex > dofArray( targetSet.size() ); arrayView1d< globalIndex > const & dof = dofArray.toView(); @@ -785,7 +582,8 @@ FieldSpecificationBase:: array1d< real64 > rhsContributionArray( targetSet.size() ); arrayView1d< real64 > const & rhsContribution = rhsContributionArray.toView(); - computeRhsContribution< FIELD_OP, POLICY, LAMBDA >( targetSet, + computeRhsContribution< FIELD_OP, POLICY, LAMBDA >( fs, + targetSet, time, dt, dataGroup, @@ -801,8 +599,9 @@ FieldSpecificationBase:: template< typename FIELD_OP, typename POLICY, typename LAMBDA > void -FieldSpecificationBase:: - computeRhsContribution( SortedArrayView< localIndex const > const & targetSet, +FieldSpecificationImpl:: + computeRhsContribution( FieldSpecification const & fs, + SortedArrayView< localIndex const > const & targetSet, real64 const time, real64 const dt, dataRepository::Group const & dataGroup, @@ -811,18 +610,20 @@ FieldSpecificationBase:: CRSMatrixView< real64, globalIndex const > const & matrix, arrayView1d< globalIndex > const & dof, arrayView1d< real64 > const & rhsContribution, - LAMBDA && lambda ) const + LAMBDA && lambda ) { - integer const component = ( getComponent() >=0 ) ? getComponent() : 0; - string const & functionName = getReference< string >( viewKeyStruct::functionNameString() ); + integer const component = ( fs.getComponent() >= 0 ) ? fs.getComponent() : 0; + string const & functionName = fs.getFunctionName(); FunctionManager & functionManager = FunctionManager::getInstance(); // Compute the value of the rhs terms, and collect the dof numbers - // The rhs terms will be assembled in applyBoundaryConditionToSystem (or in the solver for CompositionalMultiphaseBase) + // The rhs terms will be assembled in applyBoundaryConditionToSystem + // (or in the solver for CompositionalMultiphaseBase) - if( functionName.empty() || functionManager.getGroup< FunctionBase >( functionName ).isFunctionOfTime() == 2 ) + if( functionName.empty() || + functionManager.getGroup< FunctionBase >( functionName ).isFunctionOfTime() == 2 ) { - real64 value = m_scale * dt; + real64 value = fs.getScale() * dt; if( !functionName.empty() ) { FunctionBase const & function = functionManager.getGroup< FunctionBase >( functionName ); @@ -830,7 +631,15 @@ FieldSpecificationBase:: } forAll< POLICY >( targetSet.size(), - [targetSet, dof, dofMap, dofRankOffset, component, matrix, rhsContribution, value, lambda] GEOS_HOST_DEVICE ( localIndex const i ) + [targetSet, + dof, + dofMap, + dofRankOffset, + component, + matrix, + rhsContribution, + value, + lambda] GEOS_HOST_DEVICE ( localIndex const i ) { localIndex const a = targetSet[ i ]; dof[ i ] = dofMap[ a ] + component; @@ -849,11 +658,19 @@ FieldSpecificationBase:: real64_array resultsArray( targetSet.size() ); function.evaluate( dataGroup, time, targetSet, resultsArray ); arrayView1d< real64 const > const & results = resultsArray.toViewConst(); - real64 const value = m_scale * dt; + real64 const value = fs.getScale() * dt; forAll< POLICY >( targetSet.size(), - [targetSet, dof, dofMap, dofRankOffset, component, matrix, rhsContribution, results, value, lambda] GEOS_HOST_DEVICE ( - localIndex const i ) + [targetSet, + dof, + dofMap, + dofRankOffset, + component, + matrix, + rhsContribution, + results, + value, + lambda] GEOS_HOST_DEVICE ( localIndex const i ) { localIndex const a = targetSet[ i ]; dof[ i ] = dofMap[ a ] + component; @@ -867,15 +684,17 @@ FieldSpecificationBase:: } } - template< typename POLICY > -void FieldSpecificationBase::zeroSystemRowsForBoundaryCondition( SortedArrayView< localIndex const > const & targetSet, - arrayView1d< globalIndex const > const & dofMap, - CRSMatrixView< real64, globalIndex const > const & matrix ) const - +void +FieldSpecificationImpl:: + zeroSystemRowsForBoundaryCondition( FieldSpecification const & fs, + SortedArrayView< localIndex const > const & targetSet, + arrayView1d< globalIndex const > const & dofMap, + CRSMatrixView< real64, globalIndex const > const & matrix ) { - integer const component = ( getComponent() >=0 ) ? getComponent() : 0; - forAll< POLICY >( targetSet.size(), [targetSet, dofMap, matrix, component] GEOS_HOST_DEVICE ( localIndex const i ) + integer const component = ( fs.getComponent() >= 0 ) ? fs.getComponent() : 0; + forAll< POLICY >( targetSet.size(), + [targetSet, dofMap, matrix, component] GEOS_HOST_DEVICE ( localIndex const i ) { localIndex const a = targetSet[ i ]; globalIndex const dof = dofMap[ a ] + component; @@ -891,14 +710,6 @@ void FieldSpecificationBase::zeroSystemRowsForBoundaryCondition( SortedArrayView } -/** - * @brief Indicate the error handling mode - */ -ENUM_STRINGS( FieldSpecificationBase::SetErrorMode, - "silent", - "error", - "warning" ); - -} +} /* namespace geos */ -#endif //GEOS_FIELDSPECIFICATION_FIELDSPECIFICATIONBASE_HPP +#endif //GEOS_FIELDSPECIFICATION_FIELDSPECIFICATIONIMPL_HPP diff --git a/src/coreComponents/fieldSpecification/FieldSpecificationManager.cpp b/src/coreComponents/fieldSpecification/FieldSpecificationManager.cpp index 6697c275715..f5fe8126991 100644 --- a/src/coreComponents/fieldSpecification/FieldSpecificationManager.cpp +++ b/src/coreComponents/fieldSpecification/FieldSpecificationManager.cpp @@ -53,8 +53,8 @@ FieldSpecificationManager & FieldSpecificationManager::getInstance() Group * FieldSpecificationManager::createChild( string const & childKey, string const & childName ) { GEOS_LOG_RANK_0( GEOS_FMT( "{}: adding {} {}", getName(), childKey, childName ) ); - std::unique_ptr< FieldSpecificationBase > bc = - FieldSpecificationBase::CatalogInterface::factory( childKey, getDataContext(), childName, this ); + std::unique_ptr< FieldSpecification > bc = + FieldSpecification::CatalogInterface::factory( childKey, getDataContext(), childName, this ); return &this->registerGroup( childName, std::move( bc ) ); } @@ -62,7 +62,7 @@ Group * FieldSpecificationManager::createChild( string const & childKey, string void FieldSpecificationManager::expandObjectCatalogs() { // During schema generation, register one of each type derived from BoundaryConditionBase here - for( auto & catalogIter: FieldSpecificationBase::getCatalog()) + for( auto & catalogIter: FieldSpecification::getCatalog()) { createChild( catalogIter.first, catalogIter.first ); } @@ -73,7 +73,7 @@ void FieldSpecificationManager::validateBoundaryConditions( MeshLevel & mesh ) c DomainPartition const & domain = this->getGroupByPath< DomainPartition >( "/Problem/domain" ); Group const & meshBodies = domain.getMeshBodies(); // loop over all the FieldSpecification of the XML file - this->forSubGroups< FieldSpecificationBase >( [&] ( FieldSpecificationBase const & fs ) + this->forSubGroups< FieldSpecification >( [&] ( FieldSpecification const & fs ) { localIndex isFieldNameFound = 0; // map from set name to a flag (1 if targetSet has been created, 0 otherwise) @@ -102,14 +102,15 @@ void FieldSpecificationManager::validateBoundaryConditions( MeshLevel & mesh ) c // Step 2: apply the boundary condition - fs.apply< Group >( mesh, - [&]( FieldSpecificationBase const &, - string const & setName, - SortedArrayView< localIndex const > const & targetSet, - Group & targetGroup, - string const fieldName ) + FieldSpecificationImpl::apply< Group >( fs, + mesh, + [&]( FieldSpecification const &, + string const & setName, + SortedArrayView< localIndex const > const & targetSet, + Group & targetGroup, + string const fieldName ) { - InputFlags const flag = fs.getWrapper< string >( FieldSpecificationBase::viewKeyStruct::fieldNameString() ).getInputFlag(); + InputFlags const flag = fs.getWrapper< string >( FieldSpecification::viewKeyStruct::fieldNameString() ).getInputFlag(); // 2.a) If we enter this loop, we know that the set has been created // Fracture/fault sets are created later and the "apply" call silently ignores them @@ -194,14 +195,14 @@ void FieldSpecificationManager::validateBoundaryConditions( MeshLevel & mesh ) c std::ostringstream errorMessageBuilder; errorMessageBuilder << GEOS_FMT( "\n{}: there are no set(s) named `{}` under the {} `{}`.\n", - fs.getWrapperDataContext( FieldSpecificationBase::viewKeyStruct::objectPathString() ), + fs.getWrapperDataContext( FieldSpecification::viewKeyStruct::objectPathString() ), fmt::join( missingSetNames, ", " ), - FieldSpecificationBase::viewKeyStruct::objectPathString(), fs.getObjectPath() ); + FieldSpecification::viewKeyStruct::objectPathString(), fs.getObjectPath() ); errorMessageBuilder << ( !registeredSets.empty() ? GEOS_FMT( "Available set(s) are: {}", stringutilities::join( registeredSets, ", " ) ) : GEOS_FMT( "No set are available for the targeted `{}`", - FieldSpecificationBase::viewKeyStruct::objectPathString() ) ); + FieldSpecification::viewKeyStruct::objectPathString() ) ); GEOS_THROW( errorMessageBuilder.str(), InputError, getDataContext() ); } @@ -241,22 +242,22 @@ void FieldSpecificationManager::validateBoundaryConditions( MeshLevel & mesh ) c message << GEOS_FMT( "Set '{}' does not capture anything in the mesh ", setName ); } } - auto errMode = fs.getReference< FieldSpecificationBase::SetErrorMode >( - FieldSpecificationBase::viewKeyStruct::errorSetModeString()); + auto errMode = fs.getReference< FieldSpecification::SetErrorMode >( + FieldSpecification::viewKeyStruct::errorSetModeString()); - if( errMode == FieldSpecificationBase::SetErrorMode::error && m_isSurfaceGenerationCase ) + if( errMode == FieldSpecification::SetErrorMode::error && m_isSurfaceGenerationCase ) { - errMode = FieldSpecificationBase::SetErrorMode::warning; + errMode = FieldSpecification::SetErrorMode::warning; } switch( errMode ) { - case FieldSpecificationBase::SetErrorMode::silent: + case FieldSpecification::SetErrorMode::silent: break; - case FieldSpecificationBase::SetErrorMode::error: + case FieldSpecification::SetErrorMode::error: GEOS_THROW( message.str(), InputError, getDataContext() ); break; - case FieldSpecificationBase::SetErrorMode::warning: + case FieldSpecification::SetErrorMode::warning: if( m_isSurfaceGenerationCase ) message << "As the simulation includes a SurfaceGenerator, the set may be modified later"; GEOS_WARNING( message.str() ); @@ -268,7 +269,7 @@ void FieldSpecificationManager::validateBoundaryConditions( MeshLevel & mesh ) c { std::ostringstream errorMessageBuilder; errorMessageBuilder << GEOS_FMT( "\n{}: there are no field named `{}` under the region `{}`.\n", - fs.getWrapperDataContext( FieldSpecificationBase::viewKeyStruct::fieldNameString() ), + fs.getWrapperDataContext( FieldSpecification::viewKeyStruct::fieldNameString() ), fs.getFieldName(), fs.getObjectPath() ); std::set< string > registeredFields; @@ -295,18 +296,19 @@ void FieldSpecificationManager::validateBoundaryConditions( MeshLevel & mesh ) c void FieldSpecificationManager::applyInitialConditions( MeshLevel & mesh ) const { - this->forSubGroups< FieldSpecificationBase >( [&] ( FieldSpecificationBase const & fs ) + this->forSubGroups< FieldSpecification >( [&] ( FieldSpecification const & fs ) { if( fs.initialCondition() ) { - fs.apply< dataRepository::Group >( mesh, - [&]( FieldSpecificationBase const & bc, - string const &, - SortedArrayView< localIndex const > const & targetObject, - Group & targetGroup, - string const fieldName ) + FieldSpecificationImpl::apply< dataRepository::Group >( fs, + mesh, + [&]( FieldSpecification const & bc, + string const &, + SortedArrayView< localIndex const > const & targetObject, + Group & targetGroup, + string const fieldName ) { - bc.applyFieldValue< FieldSpecificationEqual >( targetObject, 0.0, targetGroup, fieldName ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual >( bc, targetObject, 0.0, targetGroup, fieldName ); } ); } } ); diff --git a/src/coreComponents/fieldSpecification/FieldSpecificationManager.hpp b/src/coreComponents/fieldSpecification/FieldSpecificationManager.hpp index b1d929e6561..cd033d27b62 100644 --- a/src/coreComponents/fieldSpecification/FieldSpecificationManager.hpp +++ b/src/coreComponents/fieldSpecification/FieldSpecificationManager.hpp @@ -20,7 +20,8 @@ #ifndef GEOS_FIELDSPECIFICATION_FIELDSPECIFICATIONMANAGER_HPP_ #define GEOS_FIELDSPECIFICATION_FIELDSPECIFICATIONMANAGER_HPP_ -#include "FieldSpecificationBase.hpp" +#include "FieldSpecification.hpp" +#include "FieldSpecificationImpl.hpp" #include "common/format/StringUtilities.hpp" #include "common/DataTypes.hpp" @@ -64,9 +65,9 @@ class FieldSpecificationManager : public dataRepository::Group static FieldSpecificationManager & getInstance(); /** - * @brief Create a new FieldSpecificationBase object as a child of this group. - * @param childKey the catalog key of the new FieldSpecificationBase derived type to create - * @param childName the name of the new FieldSpecificationBase object in the repository + * @brief Create a new FieldSpecification object as a child of this group. + * @param childKey the catalog key of the new FieldSpecification derived type to create + * @param childName the name of the new FieldSpecification object in the repository * @return the group child */ virtual Group * createChild( string const & childKey, string const & childName ) override; @@ -86,11 +87,11 @@ class FieldSpecificationManager : public dataRepository::Group * name is used for comparing against the value given in the field specification. * * Interface function that applies a boundary condition directly to a field variable by looping - * through all FieldSpecificationBase objects present in the FieldSpecificationManager. Searches + * through all FieldSpecification objects present in the FieldSpecificationManager. Searches * for the string specified in fieldPath as a substring in the objectPath specified in the input * file, checks if fieldName is equal to the fieldName specified in the input file, and check if - * the time parameter falls within the beginTime and endTime of the FieldSpecificationBase object, - * and calls FieldSpecificationBase::applyFieldValue(). + * the time parameter falls within the beginTime and endTime of the FieldSpecification object, + * and calls FieldSpecification::applyFieldValue(). * */ template< typename POLICY=parallelHostPolicy > @@ -101,7 +102,7 @@ class FieldSpecificationManager : public dataRepository::Group GEOS_MARK_FUNCTION; applyFieldValue< POLICY >( time, mesh, fieldName, - [&]( FieldSpecificationBase const &, + [&]( FieldSpecification const &, SortedArrayView< localIndex const > const & ){} ); } @@ -121,13 +122,13 @@ class FieldSpecificationManager : public dataRepository::Group * after application of value to the field. * * Interface function that applies a value directly to a field by looping - * through all FieldSpecificationBase objects present in the FieldSpecificationManager. Searches + * through all FieldSpecification objects present in the FieldSpecificationManager. Searches * for the string specified in fieldPath as a substring in the objectPath specified in the input * file, checks if fieldName is equal to the fieldName specified in the input file, and check if - * the time parameter falls within the beginTime and endTime of the FieldSpecificationBase object, - * and calls FieldSpecificationBase::applyFieldValue(), and calls the lambda function - * to apply any operations required for completing the application of the value to the field in addition to - * setting the target field. + * the time parameter falls within the beginTime and endTime of the FieldSpecification object, + * and calls FieldSpecification::applyFieldValue(), and calls the lambda function + * to apply any operations required for completing the application of the value to the field in + * addition to setting the target field. */ template< typename POLICY=parallelHostPolicy, typename LAMBDA=void > void applyFieldValue( real64 const time, @@ -154,13 +155,13 @@ class FieldSpecificationManager : public dataRepository::Group * after application of value to the field. * * Interface function that applies a value directly to a field by looping - * through all FieldSpecificationBase objects present in the FieldSpecificationManager. Calls the + * through all FieldSpecification objects present in the FieldSpecificationManager. Calls the * preLambda function to apply any operations required before the application of the value to the * field in addition to setting the target field. Searches for the string specified in fieldPath * as a substring in the objectPath specified in the input file, checks if fieldName is equal to * the fieldName specified in the input file, and check if the time parameter falls within the - * beginTime and endTime of the FieldSpecificationBase object, and calls - * FieldSpecificationBase::applyFieldValue(), and calls the postLambda function to apply any + * beginTime and endTime of the FieldSpecification object, and calls + * FieldSpecification::applyFieldValue(), and calls the postLambda function to apply any * operations required for completing the application of the value to the field in addition to * setting the target field. */ @@ -201,11 +202,11 @@ class FieldSpecificationManager : public dataRepository::Group * * This function loops through all available fields, checks to see if they * should be applied, and applies them. More specifically, this function simply checks - * values of fieldPath,fieldName, against each FieldSpecificationBase object contained in the + * values of fieldPath,fieldName, against each FieldSpecification object contained in the * FieldSpecificationManager and decides on whether or not to call the user defined lambda. */ template< typename OBJECT_TYPE=dataRepository::Group, - typename BCTYPE = FieldSpecificationBase, + typename BCTYPE = FieldSpecification, typename LAMBDA > void apply( real64 const time, MeshLevel & mesh, @@ -217,15 +218,14 @@ class FieldSpecificationManager : public dataRepository::Group string const meshBodyName = mesh.getParent().getParent().getName(); string const meshLevelName = mesh.getName(); - // loop over all FieldSpecificationBase objects + // loop over all FieldSpecification objects this->forSubGroups< BCTYPE >( [&] ( BCTYPE const & fs ) { - integer const isInitialCondition = fs.initialCondition(); - if( ( isInitialCondition && fieldName=="") || // this only use case for this line is in the unit test for field specification - ( !isInitialCondition && time >= fs.getStartTime() && time < fs.getEndTime() && fieldName == fs.getFieldName() ) ) - { - fs.template apply< OBJECT_TYPE, BCTYPE, LAMBDA >( mesh, std::forward< LAMBDA >( lambda ) ); - } + FieldSpecificationImpl::apply< OBJECT_TYPE, BCTYPE, LAMBDA >( fs, + mesh, + std::forward< LAMBDA >( lambda ), + time, + fieldName ); } ); } @@ -256,13 +256,17 @@ FieldSpecificationManager:: GEOS_MARK_FUNCTION; apply( time, mesh, fieldName, - [&]( FieldSpecificationBase const & fs, + [&]( FieldSpecification const & fs, string const &, SortedArrayView< localIndex const > const & targetSet, Group & targetGroup, string const & targetField ) { - fs.applyFieldValue< FieldSpecificationEqual, POLICY >( targetSet, time, targetGroup, targetField ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual, POLICY >( fs, + targetSet, + time, + targetGroup, + targetField ); lambda( fs, targetSet ); } ); } @@ -279,14 +283,18 @@ FieldSpecificationManager:: GEOS_MARK_FUNCTION; apply( time, mesh, fieldName, - [&]( FieldSpecificationBase const & fs, + [&]( FieldSpecification const & fs, string const &, SortedArrayView< localIndex const > const & targetSet, Group & targetGroup, string const & targetField ) { preLambda( fs, targetSet ); - fs.applyFieldValue< FieldSpecificationEqual, POLICY >( targetSet, time, targetGroup, targetField ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual, POLICY >( fs, + targetSet, + time, + targetGroup, + targetField ); postLambda( fs, targetSet ); } ); } diff --git a/src/coreComponents/fieldSpecification/PerfectlyMatchedLayer.cpp b/src/coreComponents/fieldSpecification/PerfectlyMatchedLayer.cpp index 7e71480536c..e8bfabcf5bd 100644 --- a/src/coreComponents/fieldSpecification/PerfectlyMatchedLayer.cpp +++ b/src/coreComponents/fieldSpecification/PerfectlyMatchedLayer.cpp @@ -25,7 +25,7 @@ namespace geos using namespace dataRepository; PerfectlyMatchedLayer::PerfectlyMatchedLayer( string const & name, Group * const parent ): - FieldSpecificationBase( name, parent ) + FieldSpecification( name, parent ) { registerWrapper( viewKeyStruct::xMinString(), &m_xMin ). setInputFlag( InputFlags::OPTIONAL ). @@ -66,11 +66,11 @@ PerfectlyMatchedLayer::PerfectlyMatchedLayer( string const & name, Group * const setApplyDefaultValue( {-1.0, -1.0, -1.0} ). setDescription( "Wave speed in the PML, at right, back, and bottom sides, used to compute the damping profile" ); - getWrapper< string >( FieldSpecificationBase::viewKeyStruct::fieldNameString() ). + getWrapper< string >( FieldSpecification::viewKeyStruct::fieldNameString() ). setInputFlag( InputFlags::FALSE ); setFieldName( catalogName() ); - getWrapper< int >( FieldSpecificationBase::viewKeyStruct::initialConditionString() ). + getWrapper< int >( FieldSpecification::viewKeyStruct::initialConditionString() ). setInputFlag( InputFlags::FALSE ); initialCondition( false ); // to make sure this is not called by applyInitialConditions @@ -121,6 +121,6 @@ void PerfectlyMatchedLayer::postInputInitialization() } -REGISTER_CATALOG_ENTRY( FieldSpecificationBase, PerfectlyMatchedLayer, string const &, Group * const ) +REGISTER_CATALOG_ENTRY( FieldSpecification, PerfectlyMatchedLayer, string const &, Group * const ) } /* namespace geos */ diff --git a/src/coreComponents/fieldSpecification/PerfectlyMatchedLayer.hpp b/src/coreComponents/fieldSpecification/PerfectlyMatchedLayer.hpp index 802e2be9cc7..63bfe334d39 100644 --- a/src/coreComponents/fieldSpecification/PerfectlyMatchedLayer.hpp +++ b/src/coreComponents/fieldSpecification/PerfectlyMatchedLayer.hpp @@ -21,7 +21,7 @@ #ifndef GEOS_FIELDSPECIFICATION_PERFECTLYMATCHEDLAYER_HPP_ #define GEOS_FIELDSPECIFICATION_PERFECTLYMATCHEDLAYER_HPP_ -#include "FieldSpecificationBase.hpp" +#include "FieldSpecification.hpp" namespace geos { @@ -30,12 +30,12 @@ namespace geos * @class PerfectlyMatchedLayer * A class to manage Perfectly Matched Layer for wave propagation solvers */ -class PerfectlyMatchedLayer : public FieldSpecificationBase +class PerfectlyMatchedLayer : public FieldSpecification { public: /** * @brief constructor - * @param name the name of the FieldSpecificationBase in the data repository + * @param name the name of the FieldSpecification in the data repository * @param parent the parent group of this group. */ PerfectlyMatchedLayer( string const & name, dataRepository::Group * const parent ); @@ -101,7 +101,7 @@ class PerfectlyMatchedLayer : public FieldSpecificationBase /** * @brief View keys */ - struct viewKeyStruct : public FieldSpecificationBase::viewKeyStruct + struct viewKeyStruct : public FieldSpecification::viewKeyStruct { /// @return String key for the mininum (x,y,z) coordinates of inner PML boundaries static constexpr char const * xMinString() { return "xMin"; } diff --git a/src/coreComponents/fieldSpecification/SourceFluxBoundaryCondition.cpp b/src/coreComponents/fieldSpecification/SourceFluxBoundaryCondition.cpp index 8a05108fe9d..08ce7843a75 100644 --- a/src/coreComponents/fieldSpecification/SourceFluxBoundaryCondition.cpp +++ b/src/coreComponents/fieldSpecification/SourceFluxBoundaryCondition.cpp @@ -25,24 +25,24 @@ namespace geos using namespace dataRepository; SourceFluxBoundaryCondition::SourceFluxBoundaryCondition( string const & name, Group * const parent ): - FieldSpecificationBase( name, parent ) + FieldSpecification( name, parent ) { - getWrapper< string >( FieldSpecificationBase::viewKeyStruct::fieldNameString() ). + getWrapper< string >( FieldSpecification::viewKeyStruct::fieldNameString() ). setInputFlag( InputFlags::FALSE ); setFieldName( catalogName() ); - getWrapper< string >( FieldSpecificationBase::viewKeyStruct::functionNameString() ). + getWrapper< string >( FieldSpecification::viewKeyStruct::functionNameString() ). setDescription( GEOS_FMT( "Name of a function that specifies the variation of the production rate variations of this {}." "Multiplied by {}. If no function is provided, a constant value of 1 is used." "The produced fluid rate unit is in kg by default, or in mole if the flow solver uses moles.", catalogName(), - FieldSpecificationBase::viewKeyStruct::scaleString() ) ); + FieldSpecification::viewKeyStruct::scaleString() ) ); - getWrapper< real64 >( FieldSpecificationBase::viewKeyStruct::scaleString() ). + getWrapper< real64 >( FieldSpecification::viewKeyStruct::scaleString() ). setDescription( GEOS_FMT( "Multiplier of the {0} value. If no {0} is provided, this value is used directly.", - FieldSpecificationBase::viewKeyStruct::functionNameString() ) ); + FieldSpecification::viewKeyStruct::functionNameString() ) ); } -REGISTER_CATALOG_ENTRY( FieldSpecificationBase, SourceFluxBoundaryCondition, string const &, Group * const ) +REGISTER_CATALOG_ENTRY( FieldSpecification, SourceFluxBoundaryCondition, string const &, Group * const ) } /* namespace geos */ diff --git a/src/coreComponents/fieldSpecification/SourceFluxBoundaryCondition.hpp b/src/coreComponents/fieldSpecification/SourceFluxBoundaryCondition.hpp index 2ee5e258bef..5fb3c562f82 100644 --- a/src/coreComponents/fieldSpecification/SourceFluxBoundaryCondition.hpp +++ b/src/coreComponents/fieldSpecification/SourceFluxBoundaryCondition.hpp @@ -21,7 +21,7 @@ #ifndef GEOS_FIELDSPECIFICATION_SOURCEFLUXBOUNDARYCONDITION_HPP_ #define GEOS_FIELDSPECIFICATION_SOURCEFLUXBOUNDARYCONDITION_HPP_ -#include "FieldSpecificationBase.hpp" +#include "FieldSpecification.hpp" namespace geos { @@ -30,12 +30,12 @@ namespace geos * @class SourceFluxBoundaryCondition * A class to manage Neumann boundary conditions */ -class SourceFluxBoundaryCondition : public FieldSpecificationBase +class SourceFluxBoundaryCondition : public FieldSpecification { public: /** * @brief constructor - * @param name the name of the FieldSpecificationBase in the data repository + * @param name the name of the FieldSpecification in the data repository * @param parent the parent group of this group. */ SourceFluxBoundaryCondition( string const & name, dataRepository::Group * const parent ); diff --git a/src/coreComponents/fieldSpecification/TractionBoundaryCondition.cpp b/src/coreComponents/fieldSpecification/TractionBoundaryCondition.cpp index 49392b016f0..6025988406e 100644 --- a/src/coreComponents/fieldSpecification/TractionBoundaryCondition.cpp +++ b/src/coreComponents/fieldSpecification/TractionBoundaryCondition.cpp @@ -21,6 +21,7 @@ #include "finiteElement/elementFormulations/H1_TriangleFace_Lagrange1_Gauss.hpp" #include "finiteElement/elementFormulations/H1_QuadrilateralFace_Lagrange1_GaussLegendre2.hpp" +#include "functions/FunctionManager.hpp" #include "functions/TableFunction.hpp" namespace geos @@ -29,7 +30,7 @@ namespace geos using namespace dataRepository; TractionBoundaryCondition::TractionBoundaryCondition( string const & name, Group * parent ): - FieldSpecificationBase( name, parent ), + FieldSpecification( name, parent ), m_tractionType( TractionType::vector ), m_inputStress{}, m_scaleSet(), @@ -66,11 +67,11 @@ TractionBoundaryCondition::TractionBoundaryCondition( string const & name, Group setInputFlag( InputFlags::OPTIONAL ). setDescription( "The flag to indicate whether to apply the nodal scale on the traction magnitude" ); - getWrapper< string >( FieldSpecificationBase::viewKeyStruct::fieldNameString() ). + getWrapper< string >( FieldSpecification::viewKeyStruct::fieldNameString() ). setInputFlag( InputFlags::FALSE ); setFieldName( catalogName() ); - getWrapper< int >( FieldSpecificationBase::viewKeyStruct::componentString() ). + getWrapper< int >( FieldSpecification::viewKeyStruct::componentString() ). setInputFlag( InputFlags::FALSE ); } @@ -437,7 +438,7 @@ void TractionBoundaryCondition::reinitScaleSet( FaceManager const & faceManager, } ); } -REGISTER_CATALOG_ENTRY( FieldSpecificationBase, TractionBoundaryCondition, string const &, Group * const ) +REGISTER_CATALOG_ENTRY( FieldSpecification, TractionBoundaryCondition, string const &, Group * const ) } /* namespace geos */ diff --git a/src/coreComponents/fieldSpecification/TractionBoundaryCondition.hpp b/src/coreComponents/fieldSpecification/TractionBoundaryCondition.hpp index 9d32b2becc0..a4aeb779590 100644 --- a/src/coreComponents/fieldSpecification/TractionBoundaryCondition.hpp +++ b/src/coreComponents/fieldSpecification/TractionBoundaryCondition.hpp @@ -21,7 +21,7 @@ #ifndef GEOS_FIELDSPECIFICATION_TRACTIONBOUNDARYCONDITION_HPP #define GEOS_FIELDSPECIFICATION_TRACTIONBOUNDARYCONDITION_HPP -#include "FieldSpecificationBase.hpp" +#include "FieldSpecification.hpp" #include "mesh/FaceManager.hpp" #include "mesh/NodeManager.hpp" @@ -34,10 +34,10 @@ class TableFunction; * @class TractionBoundaryCondition * Holds data and methods to apply a traction boundary condition */ -class TractionBoundaryCondition : public FieldSpecificationBase +class TractionBoundaryCondition : public FieldSpecification { public: - /// @copydoc FieldSpecificationBase(string const &, dataRepository::Group *) + /// @copydoc FieldSpecification(string const &, dataRepository::Group *) TractionBoundaryCondition( string const & name, Group * parent ); /// deleted default constructor @@ -98,7 +98,7 @@ class TractionBoundaryCondition : public FieldSpecificationBase /** * @brief View keys */ - struct viewKeyStruct : public FieldSpecificationBase::viewKeyStruct + struct viewKeyStruct : public FieldSpecification::viewKeyStruct { /// @return The key for tractionType constexpr static char const * tractionTypeString() { return "tractionType"; } diff --git a/src/coreComponents/finiteVolume/FluxApproximationBase.cpp b/src/coreComponents/finiteVolume/FluxApproximationBase.cpp index 673d6f1b53c..4104ab292b9 100644 --- a/src/coreComponents/finiteVolume/FluxApproximationBase.cpp +++ b/src/coreComponents/finiteVolume/FluxApproximationBase.cpp @@ -143,7 +143,7 @@ void FluxApproximationBase::initializePostInitialConditionsPreSubGroups() fsManager.apply< FaceManager >( 0.0, // time = 0 mesh, fieldName, - [&] ( FieldSpecificationBase const &, + [&] ( FieldSpecification const &, string const & setName, SortedArrayView< localIndex const > const & faceSet, FaceManager const &, diff --git a/src/coreComponents/integrationTests/fieldSpecificationTests/testRecursiveFieldApplication.cpp b/src/coreComponents/integrationTests/fieldSpecificationTests/testRecursiveFieldApplication.cpp index 0e948a64332..e257939aa0c 100644 --- a/src/coreComponents/integrationTests/fieldSpecificationTests/testRecursiveFieldApplication.cpp +++ b/src/coreComponents/integrationTests/fieldSpecificationTests/testRecursiveFieldApplication.cpp @@ -17,6 +17,7 @@ #include "mainInterface/ProblemManager.hpp" #include "mainInterface/GeosxState.hpp" #include "mainInterface/initialization.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" #include "fieldSpecification/FieldSpecificationManager.hpp" #include "mesh/DomainPartition.hpp" #include "mesh/generators/CellBlockManager.hpp" @@ -40,7 +41,7 @@ void RegisterAndApplyField( DomainPartition & domain, { FieldSpecificationManager & fieldSpecificationManager = FieldSpecificationManager::getInstance(); - FieldSpecificationBase & fieldSpec = fieldSpecificationManager.registerGroup< FieldSpecificationBase >( fieldName ); + FieldSpecification & fieldSpec = fieldSpecificationManager.registerGroup< FieldSpecification >( fieldName ); fieldSpec.setFieldName( fieldName ); fieldSpec.setObjectPath( objectPath ); fieldSpec.setMeshObjectPath( domain.getMeshBodies() ); @@ -51,13 +52,13 @@ void RegisterAndApplyField( DomainPartition & domain, fieldSpecificationManager.apply( 0., domain.getMeshBody( 0 ).getBaseDiscretization(), "", - [&] ( FieldSpecificationBase const & bc, + [&] ( FieldSpecification const & bc, string const &, SortedArrayView< localIndex const > const & targetSet, Group & targetGroup, string const name ) { - bc.applyFieldValue< FieldSpecificationEqual >( targetSet, 0.0, targetGroup, name ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual >( bc, targetSet, 0.0, targetGroup, name ); } ); } diff --git a/src/coreComponents/integrationTests/xmlTests/testXMLFile.cpp b/src/coreComponents/integrationTests/xmlTests/testXMLFile.cpp index 274a5d52e9b..8c0fd3aad89 100644 --- a/src/coreComponents/integrationTests/xmlTests/testXMLFile.cpp +++ b/src/coreComponents/integrationTests/xmlTests/testXMLFile.cpp @@ -18,7 +18,6 @@ #include "mainInterface/initialization.hpp" #include "mainInterface/GeosxState.hpp" #include "fieldSpecification/FieldSpecificationManager.hpp" -#include "fieldSpecification/FieldSpecificationBase.hpp" #include "dataRepository/Group.hpp" #include "dataRepository/DataContext.hpp" @@ -39,7 +38,7 @@ TEST( testXML, testXMLFile ) problemManager.parseInputFile(); // Check that we've read the full XML with all nested includes by inspecting boundary conditions - EXPECT_TRUE( problemManager.getFieldSpecificationManager().hasGroup< FieldSpecificationBase >( "v0" ) ); + EXPECT_TRUE( problemManager.getFieldSpecificationManager().hasGroup< FieldSpecification >( "v0" ) ); } /** diff --git a/src/coreComponents/mainInterface/ProblemManager.cpp b/src/coreComponents/mainInterface/ProblemManager.cpp index 8f824fa7b04..bdf792ea36d 100644 --- a/src/coreComponents/mainInterface/ProblemManager.cpp +++ b/src/coreComponents/mainInterface/ProblemManager.cpp @@ -1283,7 +1283,7 @@ DomainPartition const & ProblemManager::getDomainPartition() const void ProblemManager::applyInitialConditions() { - m_fieldSpecificationManager->forSubGroups< FieldSpecificationBase >( [&]( FieldSpecificationBase & fs ) + m_fieldSpecificationManager->forSubGroups< FieldSpecification >( [&]( FieldSpecification & fs ) { fs.setMeshObjectPath( getDomainPartition().getMeshBodies() ); } ); diff --git a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.cpp b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.cpp index 48362c574a6..29c200f034a 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.cpp @@ -30,6 +30,7 @@ #include "constitutive/relativePermeability/RelativePermeabilitySelector.hpp" #include "constitutive/solid/SolidInternalEnergy.hpp" #include "constitutive/thermalConductivity/MultiPhaseThermalConductivitySelector.hpp" +#include "fieldSpecification/FieldSpecificationManager.hpp" #include "fieldSpecification/AquiferBoundaryCondition.hpp" #include "fieldSpecification/EquilibriumInitialCondition.hpp" #include "fieldSpecification/SourceFluxBoundaryCondition.hpp" @@ -1867,7 +1868,7 @@ void CompositionalMultiphaseBase::applySourceFluxBC( real64 const time, arrayView1d< integer const > const ghostRank = subRegion.ghostRank(); // Step 3.1: get the values of the source boundary condition that need to be added to the rhs - // We don't use FieldSpecificationBase::applyConditionToSystem here because we want to account for the row permutation used in the + // We don't use FieldSpecificationImpl::applyConditionToSystem here because we want to account for the row permutation used in the // compositional solvers array1d< globalIndex > dofArray( targetSet.size() ); @@ -1878,17 +1879,18 @@ void CompositionalMultiphaseBase::applySourceFluxBC( real64 const time, RAJA::ReduceSum< parallelDeviceReduce, real64 > massProd( 0.0 ); // note that the dofArray will not be used after this step (simpler to use dofNumber instead) - fs.computeRhsContribution< FieldSpecificationAdd, - parallelDevicePolicy<> >( targetSet.toViewConst(), - time + dt, - dt, - subRegion, - dofNumber, - rankOffset, - localMatrix, - dofArray.toView(), - rhsContributionArrayView, - [] GEOS_HOST_DEVICE ( localIndex const ) + FieldSpecificationImpl::computeRhsContribution< FieldSpecificationAdd, + parallelDevicePolicy<> >( fs, + targetSet.toViewConst(), + time + dt, + dt, + subRegion, + dofNumber, + rankOffset, + localMatrix, + dofArray.toView(), + rhsContributionArrayView, + [] GEOS_HOST_DEVICE ( localIndex const ) { return 0.0; } ); @@ -1973,7 +1975,7 @@ bool CompositionalMultiphaseBase::validateDirichletBC( DomainPartition & domain, fsManager.apply< ElementSubRegionBase >( time, mesh, flow::pressure::key(), - [&]( FieldSpecificationBase const &, + [&]( FieldSpecification const &, string const & setName, SortedArrayView< localIndex const > const &, ElementSubRegionBase & subRegion, @@ -1999,7 +2001,7 @@ bool CompositionalMultiphaseBase::validateDirichletBC( DomainPartition & domain, fsManager.apply< ElementSubRegionBase >( time, mesh, flow::temperature::key(), - [&]( FieldSpecificationBase const &, + [&]( FieldSpecification const &, string const & setName, SortedArrayView< localIndex const > const &, ElementSubRegionBase & subRegion, @@ -2024,7 +2026,7 @@ bool CompositionalMultiphaseBase::validateDirichletBC( DomainPartition & domain, fsManager.apply< ElementSubRegionBase >( time, mesh, flow::globalCompFraction::key(), - [&] ( FieldSpecificationBase const & fs, + [&] ( FieldSpecification const & fs, string const & setName, SortedArrayView< localIndex const > const &, ElementSubRegionBase & subRegion, @@ -2152,7 +2154,7 @@ void CompositionalMultiphaseBase::applyDirichletBC( real64 const time_n, fsManager.apply< ElementSubRegionBase >( time_n + dt, mesh, flow::pressure::key(), - [&] ( FieldSpecificationBase const &, + [&] ( FieldSpecification const &, string const &, SortedArrayView< localIndex const > const & targetSet, ElementSubRegionBase & subRegion, @@ -2283,7 +2285,7 @@ void CompositionalMultiphaseBase::applyDirichletBC( real64 const time_n, fsManager.apply< ElementSubRegionBase >( time_n + dt, mesh, flow::temperature::key(), - [&] ( FieldSpecificationBase const &, + [&] ( FieldSpecification const &, string const &, SortedArrayView< localIndex const > const & targetSet, ElementSubRegionBase & subRegion, diff --git a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.hpp b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.hpp index 227055bf3ed..d43cca1af06 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.hpp @@ -25,7 +25,6 @@ #include "constitutive/fluid/multifluid/Layouts.hpp" #include "constitutive/relativePermeability/Layouts.hpp" #include "constitutive/capillaryPressure/Layouts.hpp" -#include "fieldSpecification/FieldSpecificationManager.hpp" #include "constitutive/fluid/multifluid/MultiFluidBase.hpp" #include "constitutive/solid/CoupledSolidBase.hpp" #include "physicsSolvers/fluidFlow/kernels/compositional/AccumulationKernel.hpp" @@ -457,23 +456,6 @@ class CompositionalMultiphaseBase : public FlowSolverBase */ void initializeAquiferBC( constitutive::ConstitutiveManager const & cm ) const; - /** - * @brief Utility function that encapsulates the call to FieldSpecificationBase::applyFieldValue in BC application - * @param[in] time_n the time at the beginning of the step - * @param[in] dt the time step - * @param[in] mesh the mesh level object - * @param[in] logMessage the log message issued by the solver if the bc is called - * @param[in] fieldKey the key of the field specified in the xml file - * @param[in] boundaryFieldKey the key of the boundary field - */ - template< typename OBJECT_TYPE > - void applyFieldValue( real64 const & time_n, - real64 const & dt, - MeshLevel & mesh, - char const logMessage[], - string const fieldKey, - string const boundaryFieldKey ) const; - /// the max number of fluid phases integer m_numPhases; @@ -564,42 +546,6 @@ class CompositionalMultiphaseBase : public FlowSolverBase }; -template< typename OBJECT_TYPE > -void CompositionalMultiphaseBase::applyFieldValue( real64 const & time_n, - real64 const & dt, - MeshLevel & mesh, - char const logMessage[], - string const fieldKey, - string const boundaryFieldKey ) const -{ - FieldSpecificationManager & fsManager = FieldSpecificationManager::getInstance(); - - fsManager.apply< OBJECT_TYPE >( time_n + dt, - mesh, - fieldKey, - [&]( FieldSpecificationBase const & fs, - string const & setName, - SortedArrayView< localIndex const > const & lset, - OBJECT_TYPE & targetGroup, - string const & ) - { - if( fs.getLogLevel() >= 1 && m_nonlinearSolverParameters.m_numNewtonIterations == 0 ) - { - globalIndex const numTargetElems = MpiWrapper::sum< globalIndex >( lset.size() ); - GEOS_LOG_RANK_0( GEOS_FMT( logMessage, - getName(), time_n+dt, fs.getCatalogName(), fs.getName(), - setName, targetGroup.getName(), fs.getScale(), numTargetElems ) ); - } - - // Specify the bc value of the field - fs.applyFieldValue< FieldSpecificationEqual, - parallelDevicePolicy<> >( lset, - time_n + dt, - targetGroup, - boundaryFieldKey ); - } ); -} - template< typename SUBREGION_TYPE > void CompositionalMultiphaseBase::accumulationAssemblyLaunch( DofManager const & dofManager, SUBREGION_TYPE const & subRegion, diff --git a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseFVM.cpp b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseFVM.cpp index 4d3f7ddbbbf..d8a98890142 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseFVM.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseFVM.cpp @@ -1150,7 +1150,7 @@ bool CompositionalMultiphaseFVM::validateFaceDirichletBC( DomainPartition & doma fsManager.apply< FaceManager >( time, mesh, flow::pressure::key(), - [&]( FieldSpecificationBase const &, + [&]( FieldSpecification const &, string const & setName, SortedArrayView< localIndex const > const &, FaceManager &, @@ -1169,7 +1169,7 @@ bool CompositionalMultiphaseFVM::validateFaceDirichletBC( DomainPartition & doma fsManager.apply< FaceManager >( time, mesh, flow::temperature::key(), - [&]( FieldSpecificationBase const &, + [&]( FieldSpecification const &, string const & setName, SortedArrayView< localIndex const > const &, FaceManager &, @@ -1195,7 +1195,7 @@ bool CompositionalMultiphaseFVM::validateFaceDirichletBC( DomainPartition & doma fsManager.apply< FaceManager >( time, mesh, flow::globalCompFraction::key(), - [&] ( FieldSpecificationBase const & fs, + [&] ( FieldSpecification const & fs, string const & setName, SortedArrayView< localIndex const > const &, FaceManager &, @@ -1309,7 +1309,7 @@ void CompositionalMultiphaseFVM::applyFaceDirichletBC( real64 const time_n, fsManager.apply< FaceManager >( time_n + dt, mesh, flow::pressure::key(), // we have required that pressure is always present - [&] ( FieldSpecificationBase const &, + [&] ( FieldSpecification const &, string const & setName, SortedArrayView< localIndex const > const &, FaceManager &, diff --git a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseHybridFVM.cpp b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseHybridFVM.cpp index c4f33665dd0..6fd5cba3a5c 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseHybridFVM.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseHybridFVM.cpp @@ -27,6 +27,7 @@ #include "constitutive/relativePermeability/RelativePermeabilityBase.hpp" #include "fieldSpecification/AquiferBoundaryCondition.hpp" #include "fieldSpecification/FieldSpecificationManager.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" #include "finiteVolume/HybridMimeticDiscretization.hpp" #include "finiteVolume/MimeticInnerProductDispatch.hpp" #include "finiteVolume/FluxApproximationBase.hpp" @@ -207,7 +208,7 @@ void CompositionalMultiphaseHybridFVM::initializePostInitialConditionsPreSubGrou // isBoundaryFaceView is default-initialized to zero FieldSpecificationManager & fsManager = FieldSpecificationManager::getInstance(); - fsManager.forSubGroups< FieldSpecificationBase >( [&]( FieldSpecificationBase const & fs ) + fsManager.forSubGroups< FieldSpecification >( [&]( FieldSpecification const & fs ) { string const & fieldName = fs.getFieldName(); if( fieldName == flow::bcPressure::key() || @@ -740,7 +741,7 @@ void CompositionalMultiphaseHybridFVM::applyFaceDirichletBC( real64 const time_n // Get all face sets that have Dirichlet BCs std::set< string > bcFaceSets; - fsManager.forSubGroups< FieldSpecificationBase >( [&]( FieldSpecificationBase const & fs ) + fsManager.forSubGroups< FieldSpecification >( [&]( FieldSpecification const & fs ) { string const & fieldName = fs.getFieldName(); if( fieldName == flow::bcPressure::key() || @@ -953,19 +954,19 @@ void CompositionalMultiphaseHybridFVM::applyFaceDirichletBC( real64 const time_n fsManager.apply< FaceManager >( time_n + dt, mesh, flow::bcPressure::key(), - [&] ( FieldSpecificationBase const & fs, + [&] ( FieldSpecification const & fs, string const & setName, SortedArrayView< localIndex const > const & targetSet, FaceManager & targetGroup, string const & ) { GEOS_UNUSED_VAR( setName ); - // Using the field specification functions to apply the boundary conditions to the system - fs.applyFieldValue< FieldSpecificationEqual, - parallelDevicePolicy<> >( targetSet, - time_n + dt, - targetGroup, - flow::bcPressure::key() ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual, + parallelDevicePolicy<> >( fs, + targetSet, + time_n + dt, + targetGroup, + flow::bcPressure::key() ); forAll< parallelDevicePolicy<> >( targetSet.size(), [=] GEOS_HOST_DEVICE ( localIndex const a ) { diff --git a/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.cpp b/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.cpp index c98270ee548..3a948b6fee9 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.cpp @@ -31,6 +31,8 @@ #include "finiteVolume/FiniteVolumeManager.hpp" #include "finiteVolume/FluxApproximationBase.hpp" #include "mesh/DomainPartition.hpp" +#include "mesh/ElementSubRegionBase.hpp" +#include "mesh/FaceManager.hpp" #include "physicsSolvers/LogLevelsInfo.hpp" #include "physicsSolvers/fluidFlow/FlowSolverBaseFields.hpp" @@ -1083,4 +1085,57 @@ string FlowSolverBase::BCMessage::notAppliedOnRegion( int componentIndex, string fieldName, setName ); } +template< typename OBJECT_TYPE > +void FlowSolverBase::applyFieldValue( real64 const & time_n, + real64 const & dt, + MeshLevel & mesh, + char const logMessage[], + string const fieldKey, + string const boundaryFieldKey ) const +{ + FieldSpecificationManager & fsManager = FieldSpecificationManager::getInstance(); + + fsManager.apply< OBJECT_TYPE >( time_n + dt, + mesh, + fieldKey, + [&]( FieldSpecification const & fs, + string const & setName, + SortedArrayView< localIndex const > const & lset, + OBJECT_TYPE & targetGroup, + string const & ) + { + if( fs.getLogLevel() >= 1 && m_nonlinearSolverParameters.m_numNewtonIterations == 0 ) + { + globalIndex const numTargetElems = MpiWrapper::sum< globalIndex >( lset.size() ); + GEOS_LOG_RANK_0( GEOS_FMT( logMessage, + getName(), time_n+dt, fs.getCatalogName(), fs.getName(), + setName, targetGroup.getName(), fs.getScale(), numTargetElems ) ); + } + + // Specify the bc value of the field + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual, + parallelDevicePolicy<> >( fs, + lset, + time_n + dt, + targetGroup, + boundaryFieldKey ); + } ); +} + +template void +FlowSolverBase::applyFieldValue< ElementSubRegionBase >( real64 const & time_n, + real64 const & dt, + MeshLevel & mesh, + char const logMessage[], + string const fieldKey, + string const boundaryFieldKey ) const; + +template void +FlowSolverBase::applyFieldValue< FaceManager >( real64 const & time_n, + real64 const & dt, + MeshLevel & mesh, + char const logMessage[], + string const fieldKey, + string const boundaryFieldKey ) const; + } // namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.hpp b/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.hpp index 0e709372102..75afb4fcd65 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/FlowSolverBase.hpp @@ -213,6 +213,23 @@ class FlowSolverBase : public PhysicsSolverBase protected: + /** + * @brief Utility function that encapsulates the call to FieldSpecificationImpl::applyFieldValue in BC application + * @param[in] time_n the time at the beginning of the step + * @param[in] dt the time step + * @param[in] mesh the mesh level object + * @param[in] logMessage the log message issued by the solver if the bc is called + * @param[in] fieldKey the key of the field specified in the xml file + * @param[in] boundaryFieldKey the key of the boundary field + */ + template< typename OBJECT_TYPE > + void applyFieldValue( real64 const & time_n, + real64 const & dt, + MeshLevel & mesh, + char const logMessage[], + string const fieldKey, + string const boundaryFieldKey ) const; + /** * @brief Increment the cumulative flux from each aquifer * @param[in] time the time at the beginning of the time step diff --git a/src/coreComponents/physicsSolvers/fluidFlow/ImmiscibleMultiphaseFlow.cpp b/src/coreComponents/physicsSolvers/fluidFlow/ImmiscibleMultiphaseFlow.cpp index 6bd4ead9e6b..1531799faeb 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/ImmiscibleMultiphaseFlow.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/ImmiscibleMultiphaseFlow.cpp @@ -30,6 +30,8 @@ #include "constitutive/relativePermeability/RelativePermeabilitySelector.hpp" #include "fieldSpecification/EquilibriumInitialCondition.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" +#include "fieldSpecification/FieldSpecificationManager.hpp" #include "fieldSpecification/SourceFluxBoundaryCondition.hpp" #include "physicsSolvers/fluidFlow/SourceFluxStatistics.hpp" #include "physicsSolvers/LogLevelsInfo.hpp" @@ -685,7 +687,7 @@ bool ImmiscibleMultiphaseFlow::validateDirichletBC( DomainPartition & domain, fsManager.apply< ElementSubRegionBase >( time, mesh, fields::flow::pressure::key(), - [&]( FieldSpecificationBase const &, + [&]( FieldSpecification const &, string const & setName, SortedArrayView< localIndex const > const &, ElementSubRegionBase & subRegion, @@ -708,7 +710,7 @@ bool ImmiscibleMultiphaseFlow::validateDirichletBC( DomainPartition & domain, fsManager.apply< ElementSubRegionBase >( time, mesh, fields::immiscibleMultiphaseFlow::phaseVolumeFraction::key(), - [&] ( FieldSpecificationBase const & fs, + [&] ( FieldSpecification const & fs, string const & setName, SortedArrayView< localIndex const > const &, ElementSubRegionBase & subRegion, @@ -742,7 +744,6 @@ bool ImmiscibleMultiphaseFlow::validateDirichletBC( DomainPartition & domain, fsManager.forSubGroups< EquilibriumInitialCondition >( [&] ( EquilibriumInitialCondition const & bc ) { string_array const & componentNames = bc.getComponentNames(); - GEOS_UNUSED_VAR( componentNames ); GEOS_WARNING( BCMessage::conflictingComposition( comp, componentNames[comp], regionName, subRegionName, setName, fields::immiscibleMultiphaseFlow::phaseVolumeFraction::key() ) @@ -822,7 +823,7 @@ void ImmiscibleMultiphaseFlow::applyDirichletBC( real64 const time_n, fsManager.apply< ElementSubRegionBase >( time_n + dt, mesh, fields::flow::pressure::key(), - [&] ( FieldSpecificationBase const &, + [&] ( FieldSpecification const &, string const &, SortedArrayView< localIndex const > const & targetSet, ElementSubRegionBase & subRegion, @@ -977,17 +978,18 @@ void ImmiscibleMultiphaseFlow::applySourceFluxBC( real64 const time, RAJA::ReduceSum< parallelDeviceReduce, real64 > massProd( 0.0 ); // note that the dofArray will not be used after this step (simpler to use dofNumber instead) - fs.computeRhsContribution< FieldSpecificationAdd, - parallelDevicePolicy<> >( targetSet.toViewConst(), - time + dt, - dt, - subRegion, - dofNumber, - rankOffset, - localMatrix, - dofArray.toView(), - rhsContributionArrayView, - [] GEOS_HOST_DEVICE ( localIndex const ) + FieldSpecificationImpl::computeRhsContribution< FieldSpecificationAdd, + parallelDevicePolicy<> >( fs, + targetSet.toViewConst(), + time + dt, + dt, + subRegion, + dofNumber, + rankOffset, + localMatrix, + dofArray.toView(), + rhsContributionArrayView, + [] GEOS_HOST_DEVICE ( localIndex const ) { return 0.0; } ); diff --git a/src/coreComponents/physicsSolvers/fluidFlow/ImmiscibleMultiphaseFlow.hpp b/src/coreComponents/physicsSolvers/fluidFlow/ImmiscibleMultiphaseFlow.hpp index 7526130316c..b7229c75b83 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/ImmiscibleMultiphaseFlow.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/ImmiscibleMultiphaseFlow.hpp @@ -21,7 +21,6 @@ #define GEOS_PHYSICSSOLVERS_FLUIDFLOW_IMMISCIBLEMULTIPHASEFLOW_HPP_ #include "physicsSolvers/fluidFlow/FlowSolverBase.hpp" -#include "fieldSpecification/FieldSpecificationManager.hpp" #include "physicsSolvers/fluidFlow/kernels/immiscibleMultiphase/ImmiscibleMultiphaseKernels.hpp" namespace geos @@ -262,23 +261,6 @@ class ImmiscibleMultiphaseFlow : public FlowSolverBase */ void updatePhaseMobility( ObjectManagerBase & dataGroup ) const; - /** - * @brief Utility function that encapsulates the call to FieldSpecificationBase::applyFieldValue in BC application - * @param[in] time_n the time at the beginning of the step - * @param[in] dt the time step - * @param[in] mesh the mesh level object - * @param[in] logMessage the log message issued by the solver if the bc is called - * @param[in] fieldKey the key of the field specified in the xml file - * @param[in] boundaryFieldKey the key of the boundary field - */ - template< typename OBJECT_TYPE > - void applyFieldValue( real64 const & time_n, - real64 const & dt, - MeshLevel & mesh, - char const logMessage[], - string const fieldKey, - string const boundaryFieldKey ) const; - /// the max number of fluid phases integer m_numPhases; @@ -315,42 +297,6 @@ class ImmiscibleMultiphaseFlow : public FlowSolverBase }; -template< typename OBJECT_TYPE > -void ImmiscibleMultiphaseFlow::applyFieldValue( real64 const & time_n, - real64 const & dt, - MeshLevel & mesh, - char const logMessage[], - string const fieldKey, - string const boundaryFieldKey ) const -{ - FieldSpecificationManager & fsManager = FieldSpecificationManager::getInstance(); - - fsManager.apply< OBJECT_TYPE >( time_n + dt, - mesh, - fieldKey, - [&]( FieldSpecificationBase const & fs, - string const & setName, - SortedArrayView< localIndex const > const & lset, - OBJECT_TYPE & targetGroup, - string const & ) - { - if( fs.getLogLevel() >= 1 && m_nonlinearSolverParameters.m_numNewtonIterations == 0 ) - { - globalIndex const numTargetElems = MpiWrapper::sum< globalIndex >( lset.size() ); - GEOS_LOG_RANK_0( GEOS_FMT( logMessage, - getName(), time_n+dt, fs.getCatalogName(), fs.getName(), - setName, targetGroup.getName(), fs.getScale(), numTargetElems ) ); - } - - // Specify the bc value of the field - fs.applyFieldValue< FieldSpecificationEqual, - parallelDevicePolicy<> >( lset, - time_n + dt, - targetGroup, - boundaryFieldKey ); - } ); -} - } // namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/ReactiveCompositionalMultiphaseOBL.cpp b/src/coreComponents/physicsSolvers/fluidFlow/ReactiveCompositionalMultiphaseOBL.cpp index 29bc7397087..6ba70a82cf5 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/ReactiveCompositionalMultiphaseOBL.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/ReactiveCompositionalMultiphaseOBL.cpp @@ -22,6 +22,7 @@ #include "constitutive/solid/CoupledSolidBase.hpp" #include "dataRepository/Group.hpp" #include "discretizationMethods/NumericalMethodsManager.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" #include "fieldSpecification/FieldSpecificationManager.hpp" #include "fieldSpecification/SourceFluxBoundaryCondition.hpp" #include "fieldSpecification/EquilibriumInitialCondition.hpp" @@ -843,17 +844,18 @@ void ReactiveCompositionalMultiphaseOBL::applySourceFluxBC( real64 const time, RAJA::ReduceSum< parallelDeviceReduce, real64 > massProd( 0.0 ); // note that the dofArray will not be used after this step (simpler to use dofNumber instead) - fs.computeRhsContribution< FieldSpecificationAdd, - parallelDevicePolicy<> >( targetSet.toViewConst(), - time + dt, - dt, - subRegion, - dofNumber, - rankOffset, - localMatrix, - dofArray.toView(), - rhsContributionArrayView, - [] GEOS_HOST_DEVICE ( localIndex const ) + FieldSpecificationImpl::computeRhsContribution< FieldSpecificationAdd, + parallelDevicePolicy<> >( fs, + targetSet.toViewConst(), + time + dt, + dt, + subRegion, + dofNumber, + rankOffset, + localMatrix, + dofArray.toView(), + rhsContributionArrayView, + [] GEOS_HOST_DEVICE ( localIndex const ) { return 0.0; } ); @@ -923,7 +925,7 @@ bool ReactiveCompositionalMultiphaseOBL::validateDirichletBC( DomainPartition & fsManager.apply< ElementSubRegionBase >( time, mesh, flow::pressure::key(), - [&]( FieldSpecificationBase const &, + [&]( FieldSpecification const &, string const & setName, SortedArrayView< localIndex const > const &, ElementSubRegionBase & subRegion, @@ -947,7 +949,7 @@ bool ReactiveCompositionalMultiphaseOBL::validateDirichletBC( DomainPartition & fsManager.apply< ElementSubRegionBase >( time, mesh, flow::globalCompFraction::key(), - [&] ( FieldSpecificationBase const & fs, + [&] ( FieldSpecification const & fs, string const & setName, SortedArrayView< localIndex const > const &, ElementSubRegionBase & subRegion, @@ -995,7 +997,7 @@ bool ReactiveCompositionalMultiphaseOBL::validateDirichletBC( DomainPartition & fsManager.apply< ElementSubRegionBase >( time, mesh, flow::temperature::key(), - [&]( FieldSpecificationBase const &, + [&]( FieldSpecification const &, string const & setName, SortedArrayView< localIndex const > const &, ElementSubRegionBase & subRegion, @@ -1082,7 +1084,7 @@ void ReactiveCompositionalMultiphaseOBL::applyDirichletBC( real64 const time, fsManager.apply< ElementSubRegionBase >( time + dt, mesh, flow::pressure::key(), - [&]( FieldSpecificationBase const & fs, + [&]( FieldSpecification const & fs, string const & setName, SortedArrayView< localIndex const > const & targetSet, ElementSubRegionBase & subRegion, @@ -1098,33 +1100,37 @@ void ReactiveCompositionalMultiphaseOBL::applyDirichletBC( real64 const time, fs ); } - fs.applyFieldValue< FieldSpecificationEqual, parallelDevicePolicy<> >( targetSet, - time + dt, - subRegion, - flow::bcPressure::key() ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual, + parallelDevicePolicy<> >( fs, + targetSet, + time + dt, + subRegion, + flow::bcPressure::key() ); } ); // 2. Apply composition BC (global component fraction), store in a separate field fsManager.apply< ElementSubRegionBase >( time + dt, mesh, flow::globalCompFraction::key(), - [&] ( FieldSpecificationBase const & fs, + [&] ( FieldSpecification const & fs, string const &, SortedArrayView< localIndex const > const & targetSet, ElementSubRegionBase & subRegion, string const & ) { - fs.applyFieldValue< FieldSpecificationEqual, parallelDevicePolicy<> >( targetSet, - time + dt, - subRegion, - flow::bcGlobalCompFraction::key() ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual, + parallelDevicePolicy<> >( fs, + targetSet, + time + dt, + subRegion, + flow::bcGlobalCompFraction::key() ); } ); // 3. Apply temperature Dirichlet BCs, store in a separate field fsManager.apply< ElementSubRegionBase >( time + dt, mesh, flow::temperature::key(), - [&]( FieldSpecificationBase const & fs, + [&]( FieldSpecification const & fs, string const & setName, SortedArrayView< localIndex const > const & targetSet, ElementSubRegionBase & subRegion, @@ -1140,10 +1146,12 @@ void ReactiveCompositionalMultiphaseOBL::applyDirichletBC( real64 const time, fs ); } - fs.applyFieldValue< FieldSpecificationEqual, parallelDevicePolicy<> >( targetSet, - time + dt, - subRegion, - flow::bcTemperature::key() ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual, + parallelDevicePolicy<> >( fs, + targetSet, + time + dt, + subRegion, + flow::bcTemperature::key() ); } ); globalIndex const rankOffset = dofManager.rankOffset(); @@ -1154,7 +1162,7 @@ void ReactiveCompositionalMultiphaseOBL::applyDirichletBC( real64 const time, fsManager.apply< ElementSubRegionBase >( time + dt, mesh, flow::pressure::key(), - [&] ( FieldSpecificationBase const &, + [&] ( FieldSpecification const &, string const &, SortedArrayView< localIndex const > const & targetSet, ElementSubRegionBase & subRegion, diff --git a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseBase.cpp b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseBase.cpp index 7c1521128b7..562cfae6df4 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseBase.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseBase.cpp @@ -29,6 +29,7 @@ #include "constitutive/thermalConductivity/SinglePhaseThermalConductivitySelector.hpp" #include "fieldSpecification/AquiferBoundaryCondition.hpp" #include "fieldSpecification/EquilibriumInitialCondition.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" #include "fieldSpecification/FieldSpecificationManager.hpp" #include "fieldSpecification/SourceFluxBoundaryCondition.hpp" #include "physicsSolvers/fluidFlow/SourceFluxStatistics.hpp" @@ -894,18 +895,19 @@ void applyAndSpecifyFieldValue( real64 const & time_n, fsManager.apply< ElementSubRegionBase >( time_n + dt, mesh, fieldKey, - [&]( FieldSpecificationBase const & fs, + [&]( FieldSpecification const & fs, string const &, SortedArrayView< localIndex const > const & lset, ElementSubRegionBase & subRegion, string const & ) { // Specify the bc value of the field - fs.applyFieldValue< FieldSpecificationEqual, - parallelDevicePolicy<> >( lset, - time_n + dt, - subRegion, - boundaryFieldKey ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual, + parallelDevicePolicy<> >( fs, + lset, + time_n + dt, + subRegion, + boundaryFieldKey ); arrayView1d< integer const > const ghostRank = subRegion.ghostRank(); arrayView1d< globalIndex const > const dofNumber = @@ -1055,17 +1057,18 @@ void SinglePhaseBase::applySourceFluxBC( real64 const time_n, RAJA::ReduceSum< parallelDeviceReduce, real64 > massProd( 0.0 ); // note that the dofArray will not be used after this step (simpler to use dofNumber instead) - fs.computeRhsContribution< FieldSpecificationAdd, - parallelDevicePolicy<> >( targetSet.toViewConst(), - time_n + dt, - dt, - subRegion, - dofNumber, - rankOffset, - localMatrix, - dofArray.toView(), - rhsContributionArrayView, - [] GEOS_HOST_DEVICE ( localIndex const ) + FieldSpecificationImpl::computeRhsContribution< FieldSpecificationAdd, + parallelDevicePolicy<> >( fs, + targetSet.toViewConst(), + time_n + dt, + dt, + subRegion, + dofNumber, + rankOffset, + localMatrix, + dofArray.toView(), + rhsContributionArrayView, + [] GEOS_HOST_DEVICE ( localIndex const ) { return 0.0; } ); diff --git a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseFVM.cpp b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseFVM.cpp index bff2fbd0f78..b507ea1b22c 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseFVM.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseFVM.cpp @@ -26,6 +26,7 @@ #include "finiteVolume/BoundaryStencil.hpp" #include "finiteVolume/FiniteVolumeManager.hpp" #include "finiteVolume/FluxApproximationBase.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" #include "fieldSpecification/FieldSpecificationManager.hpp" #include "fieldSpecification/AquiferBoundaryCondition.hpp" #include "linearAlgebra/multiscale/MultiscalePreconditioner.hpp" @@ -715,7 +716,7 @@ void SinglePhaseFVM< BASE >::applyFaceDirichletBC( real64 const time_n, fsManager.apply< FaceManager >( time_n + dt, mesh, flow::pressure::key(), - [&] ( FieldSpecificationBase const & fs, + [&] ( FieldSpecification const & fs, string const & setName, SortedArrayView< localIndex const > const & targetSet, FaceManager & targetGroup, @@ -740,18 +741,19 @@ void SinglePhaseFVM< BASE >::applyFaceDirichletBC( real64 const time_n, pressureSets.insert( setName ); // first, evaluate BC to get primary field values (pressure) - fs.applyFieldValue< FieldSpecificationEqual, - parallelDevicePolicy<> >( targetSet, - time_n + dt, - targetGroup, - flow::facePressure::key() ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual, + parallelDevicePolicy<> >( fs, + targetSet, + time_n + dt, + targetGroup, + flow::facePressure::key() ); } ); // Take BCs defined for "temperature" field and apply values to "faceTemperature" fsManager.apply< FaceManager >( time_n + dt, mesh, flow::temperature::key(), - [&] ( FieldSpecificationBase const & fs, + [&] ( FieldSpecification const & fs, string const & setName, SortedArrayView< localIndex const > const & targetSet, FaceManager & targetGroup, @@ -775,11 +777,12 @@ void SinglePhaseFVM< BASE >::applyFaceDirichletBC( real64 const time_n, temperatureSets.insert( setName ); // Specify the bc value of the field - fs.applyFieldValue< FieldSpecificationEqual, - parallelDevicePolicy<> >( targetSet, - time_n + dt, - targetGroup, - flow::faceTemperature::key() ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual, + parallelDevicePolicy<> >( fs, + targetSet, + time_n + dt, + targetGroup, + flow::faceTemperature::key() ); } ); @@ -821,7 +824,7 @@ void SinglePhaseFVM< BASE >::applyFaceDirichletBC( real64 const time_n, fsManager.apply< FaceManager >( time_n + dt, mesh, flow::pressure::key(), - [&] ( FieldSpecificationBase const & fs, + [&] ( FieldSpecification const & fs, string const & setName, SortedArrayView< localIndex const > const & targetSet, FaceManager & targetGroup, @@ -845,11 +848,12 @@ void SinglePhaseFVM< BASE >::applyFaceDirichletBC( real64 const time_n, } // first, evaluate BC to get primary field values (pressure) - fs.applyFieldValue< FieldSpecificationEqual, - parallelDevicePolicy<> >( targetSet, - time_n + dt, - targetGroup, - flow::facePressure::key() ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual, + parallelDevicePolicy<> >( fs, + targetSet, + time_n + dt, + targetGroup, + flow::facePressure::key() ); // TODO: currently we just use model from the first cell in this stencil diff --git a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseHybridFVM.cpp b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseHybridFVM.cpp index 3c96ad83984..fdaf8496edb 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseHybridFVM.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseHybridFVM.cpp @@ -23,6 +23,7 @@ #include "constitutive/ConstitutivePassThru.hpp" #include "constitutive/fluid/singlefluid/SingleFluidBase.hpp" #include "fieldSpecification/AquiferBoundaryCondition.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" #include "fieldSpecification/FieldSpecificationManager.hpp" #include "discretizationMethods/NumericalMethodsManager.hpp" #include "finiteVolume/FiniteVolumeManager.hpp" @@ -371,7 +372,7 @@ void SinglePhaseHybridFVM::applyFaceDirichletBC( real64 const time_n, fsManager.apply< FaceManager >( time_n + dt, mesh, flow::bcPressure::key(), - [&] ( FieldSpecificationBase const & fs, + [&] ( FieldSpecification const & fs, string const & setName, SortedArrayView< localIndex const > const & targetSet, FaceManager & targetGroup, @@ -392,11 +393,12 @@ void SinglePhaseHybridFVM::applyFaceDirichletBC( real64 const time_n, // next, we use the field specification functions to apply the boundary conditions to the system // Populate the face pressure vector at the boundaries of the domain - fs.applyFieldValue< FieldSpecificationEqual, - parallelDevicePolicy<> >( targetSet, - time_n + dt, - targetGroup, - flow::bcPressure::key() ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual, + parallelDevicePolicy<> >( fs, + targetSet, + time_n + dt, + targetGroup, + flow::bcPressure::key() ); // Second, modify the residual/jacobian matrix as needed to impose the boundary conditions forAll< parallelDevicePolicy<> >( targetSet.size(), [=] GEOS_HOST_DEVICE ( localIndex const a ) diff --git a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseReactiveTransport.cpp b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseReactiveTransport.cpp index 5d543342aaa..7c2643a52b2 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseReactiveTransport.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseReactiveTransport.cpp @@ -965,17 +965,18 @@ void SinglePhaseReactiveTransport::applySourceFluxBC( real64 const time_n, RAJA::ReduceSum< parallelDeviceReduce, real64 > massProd( 0.0 ); // note that the dofArray will not be used after this step (simpler to use dofNumber instead) - fs.computeRhsContribution< FieldSpecificationAdd, - parallelDevicePolicy<> >( targetSet.toViewConst(), - time_n + dt, - dt, - subRegion, - dofNumber, - rankOffset, - localMatrix, - dofArray.toView(), - rhsContributionArrayView, - [] GEOS_HOST_DEVICE ( localIndex const ) + FieldSpecificationImpl::computeRhsContribution< FieldSpecificationAdd, + parallelDevicePolicy<> >( fs, + targetSet.toViewConst(), + time_n + dt, + dt, + subRegion, + dofNumber, + rankOffset, + localMatrix, + dofArray.toView(), + rhsContributionArrayView, + [] GEOS_HOST_DEVICE ( localIndex const ) { return 0.0; } ); @@ -1069,7 +1070,7 @@ void SinglePhaseReactiveTransport::applyDirichletBC( real64 const time_n, fsManager.apply< ElementSubRegionBase >( time_n + dt, mesh, fields::flow::pressure::key(), - [&] ( FieldSpecificationBase const &, + [&] ( FieldSpecification const &, string const &, SortedArrayView< localIndex const > const & targetSet, ElementSubRegionBase & subRegion, @@ -1111,7 +1112,7 @@ void SinglePhaseReactiveTransport::applyDirichletBC( real64 const time_n, fsManager.apply< ElementSubRegionBase >( time_n + dt, mesh, fields::flow::logPrimarySpeciesConcentration::key(), - [&] ( FieldSpecificationBase const &, + [&] ( FieldSpecification const &, string const &, SortedArrayView< localIndex const > const & targetSet, ElementSubRegionBase & subRegion, @@ -1163,7 +1164,7 @@ void SinglePhaseReactiveTransport::applyDirichletBC( real64 const time_n, fsManager.apply< ElementSubRegionBase >( time_n + dt, mesh, fields::flow::temperature::key(), - [&] ( FieldSpecificationBase const &, + [&] ( FieldSpecification const &, string const &, SortedArrayView< localIndex const > const & targetSet, ElementSubRegionBase & subRegion, @@ -1477,7 +1478,7 @@ void SinglePhaseReactiveTransport::applyFaceDirichletBC( real64 const time_n, fsManager.apply< FaceManager >( time_n + dt, mesh, fields::flow::pressure::key(), // we have required that pressure is always present - [&] ( FieldSpecificationBase const &, + [&] ( FieldSpecification const &, string const & setName, SortedArrayView< localIndex const > const &, FaceManager &, @@ -1528,7 +1529,7 @@ void SinglePhaseReactiveTransport::applyFaceDirichletBC( real64 const time_n, fsManager.apply< FaceManager >( time_n + dt, mesh, fields::flow::pressure::key(), // we have required that pressure is always present - [&] ( FieldSpecificationBase const &, + [&] ( FieldSpecification const &, string const & setName, SortedArrayView< localIndex const > const &, FaceManager &, diff --git a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseReactiveTransport.hpp b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseReactiveTransport.hpp index 8ed4b4d47e3..544b0f612f3 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseReactiveTransport.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseReactiveTransport.hpp @@ -20,7 +20,6 @@ #ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_SINGLEPHASEREACTIVETRANSPORT_HPP_ #define GEOS_PHYSICSSOLVERS_FLUIDFLOW_SINGLEPHASEREACTIVETRANSPORT_HPP_ -#include "fieldSpecification/FieldSpecificationManager.hpp" #include "physicsSolvers/fluidFlow/SinglePhaseBase.hpp" #include "physicsSolvers/fluidFlow/SinglePhaseFVM.hpp" #include "physicsSolvers/fluidFlow/SinglePhaseReactiveTransportFields.hpp" @@ -242,23 +241,6 @@ class SinglePhaseReactiveTransport : public SinglePhaseBase CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) const override; - /** - * @brief Utility function that encapsulates the call to FieldSpecificationBase::applyFieldValue in BC application - * @param[in] time_n the time at the beginning of the step - * @param[in] dt the time step - * @param[in] mesh the mesh level object - * @param[in] logMessage the log message issued by the solver if the bc is called - * @param[in] fieldKey the key of the field specified in the xml file - * @param[in] boundaryFieldKey the key of the boundary field - */ - template< typename OBJECT_TYPE > - void applyFieldValue( real64 const & time_n, - real64 const & dt, - MeshLevel & mesh, - char const logMessage[], - string const fieldKey, - string const boundaryFieldKey ) const; - virtual void applyAquiferBC( real64 const time, real64 const dt, @@ -334,41 +316,6 @@ class SinglePhaseReactiveTransport : public SinglePhaseBase }; -template< typename OBJECT_TYPE > -void SinglePhaseReactiveTransport::applyFieldValue( real64 const & time_n, - real64 const & dt, - MeshLevel & mesh, - char const logMessage[], - string const fieldKey, - string const boundaryFieldKey ) const -{ - FieldSpecificationManager & fsManager = FieldSpecificationManager::getInstance(); - - fsManager.apply< OBJECT_TYPE >( time_n + dt, - mesh, - fieldKey, - [&]( FieldSpecificationBase const & fs, - string const & setName, - SortedArrayView< localIndex const > const & lset, - OBJECT_TYPE & targetGroup, - string const & ) - { - if( fs.getLogLevel() >= 1 && m_nonlinearSolverParameters.m_numNewtonIterations == 0 ) - { - globalIndex const numTargetElems = MpiWrapper::sum< globalIndex >( lset.size() ); - GEOS_LOG_RANK_0( GEOS_FMT( logMessage, - getName(), time_n+dt, fs.getCatalogName(), fs.getName(), - setName, targetGroup.getName(), fs.getScale(), numTargetElems ) ); - } - - // Specify the bc value of the field - fs.applyFieldValue< FieldSpecificationEqual, - parallelDevicePolicy<> >( lset, - time_n + dt, - targetGroup, - boundaryFieldKey ); - } ); -} } /* namespace geos */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/proppantTransport/ProppantTransport.cpp b/src/coreComponents/physicsSolvers/fluidFlow/proppantTransport/ProppantTransport.cpp index c0718a19e35..3087c47b322 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/proppantTransport/ProppantTransport.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/proppantTransport/ProppantTransport.cpp @@ -29,6 +29,7 @@ #include "constitutive/fluid/singlefluid/ParticleFluidFields.hpp" #include "constitutive/permeability/PermeabilityFields.hpp" #include "discretizationMethods/NumericalMethodsManager.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" #include "fieldSpecification/FieldSpecificationManager.hpp" #include "mesh/DomainPartition.hpp" #include "mesh/mpiCommunications/CommunicationTools.hpp" @@ -661,7 +662,7 @@ void ProppantTransport::applyBoundaryConditions( real64 const time_n, fsManager.apply< ElementSubRegionBase >( time_n + dt, mesh, proppant::proppantConcentration::key(), - [&]( FieldSpecificationBase const & fs, + [&]( FieldSpecification const & fs, string const &, SortedArrayView< localIndex const > const & lset, ElementSubRegionBase & subRegion, @@ -673,15 +674,16 @@ void ProppantTransport::applyBoundaryConditions( real64 const time_n, arrayView1d< real64 const > const proppantConc = subRegion.getReference< array1d< real64 > >( proppant::proppantConcentration::key() ); - fs.applyBoundaryConditionToSystem< FieldSpecificationEqual, - parallelDevicePolicy<> >( lset, - time_n + dt, - subRegion, - dofNumber, - rankOffset, - localMatrix, - localRhs, - proppantConc ); + FieldSpecificationImpl::applyBoundaryConditionToSystem< FieldSpecificationEqual, + parallelDevicePolicy<> >( fs, + lset, + time_n + dt, + subRegion, + dofNumber, + rankOffset, + localMatrix, + localRhs, + proppantConc ); } ); // Apply Dirichlet BC for component concentration @@ -692,7 +694,7 @@ void ProppantTransport::applyBoundaryConditions( real64 const time_n, fsManager.apply< ElementSubRegionBase >( time_n + dt, mesh, proppant::proppantConcentration::key(), - [&]( FieldSpecificationBase const &, + [&]( FieldSpecification const &, string const & setName, SortedArrayView< localIndex const > const &, ElementSubRegionBase & subRegion, @@ -711,7 +713,7 @@ void ProppantTransport::applyBoundaryConditions( real64 const time_n, fsManager.apply< ElementSubRegionBase >( time_n + dt, mesh, proppant::componentConcentration::key(), - [&] ( FieldSpecificationBase const & fs, + [&] ( FieldSpecification const & fs, string const & setName, SortedArrayView< localIndex const > const & targetSet, ElementSubRegionBase & subRegion, @@ -729,10 +731,11 @@ void ProppantTransport::applyBoundaryConditions( real64 const time_n, getDataContext() ); bcStatusMap[subRegionName][setName][comp] = true; - fs.applyFieldValue< FieldSpecificationEqual >( targetSet, - time_n + dt, - subRegion, - proppant::bcComponentConcentration::key() ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual >( fs, + targetSet, + time_n + dt, + subRegion, + proppant::bcComponentConcentration::key() ); } ); @@ -760,7 +763,7 @@ void ProppantTransport::applyBoundaryConditions( real64 const time_n, fsManager.apply< ElementSubRegionBase >( time_n + dt, mesh, proppant::proppantConcentration::key(), - [&] ( FieldSpecificationBase const &, + [&] ( FieldSpecification const &, string const &, SortedArrayView< localIndex const > const & targetSet, ElementSubRegionBase & subRegion, diff --git a/src/coreComponents/physicsSolvers/fluidFlow/proppantTransport/ProppantTransport.hpp b/src/coreComponents/physicsSolvers/fluidFlow/proppantTransport/ProppantTransport.hpp index 4b53d67075c..4345675794d 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/proppantTransport/ProppantTransport.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/proppantTransport/ProppantTransport.hpp @@ -31,7 +31,7 @@ namespace dataRepository { class Group; } -class FieldSpecificationBase; +class FieldSpecification; class FiniteElementBase; class DomainPartition; diff --git a/src/coreComponents/physicsSolvers/inducedSeismicity/SeismicityRate.cpp b/src/coreComponents/physicsSolvers/inducedSeismicity/SeismicityRate.cpp index f614a96c67b..5be2a38d1e0 100644 --- a/src/coreComponents/physicsSolvers/inducedSeismicity/SeismicityRate.cpp +++ b/src/coreComponents/physicsSolvers/inducedSeismicity/SeismicityRate.cpp @@ -29,6 +29,7 @@ #include "physicsSolvers/fluidFlow/FlowSolverBase.hpp" #include "physicsSolvers/fluidFlow/FlowSolverBaseFields.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" #include "fieldSpecification/FieldSpecificationManager.hpp" @@ -360,7 +361,7 @@ real64 SeismicityRate::updateStresses( real64 const & time_n, fsManager.apply< ElementSubRegionBase >( time_n + dt, mesh, key, - [&]( FieldSpecificationBase const & fs, + [&]( FieldSpecification const & fs, string const & setName, SortedArrayView< localIndex const > const & lset, ElementSubRegionBase & subRegion, @@ -369,16 +370,17 @@ real64 SeismicityRate::updateStresses( real64 const & time_n, globalIndex const numTargetElems = MpiWrapper::sum< globalIndex >( lset.size() ); GEOS_LOG_LEVEL_RANK_0_ON_GROUP( logInfo::BoundaryConditions, GEOS_FMT( bcLogMessage, - this->getName(), time_n+dt, FieldSpecificationBase::catalogName(), + this->getName(), time_n+dt, FieldSpecification::catalogName(), fs.getName(), setName, subRegion.getName(), fs.getScale(), numTargetElems ), fs ); // Specify the bc value of the field - fs.applyFieldValue< FieldSpecificationEqual, - parallelDevicePolicy<> >( lset, - time_n + dt, - subRegion, - key ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual, + parallelDevicePolicy<> >( fs, + lset, + time_n + dt, + subRegion, + key ); } ); } } ); diff --git a/src/coreComponents/physicsSolvers/multiphysics/FieldApplicator.cpp b/src/coreComponents/physicsSolvers/multiphysics/FieldApplicator.cpp index 9b139e775d6..98595748809 100644 --- a/src/coreComponents/physicsSolvers/multiphysics/FieldApplicator.cpp +++ b/src/coreComponents/physicsSolvers/multiphysics/FieldApplicator.cpp @@ -15,8 +15,9 @@ #include "FieldApplicator.hpp" #include "events/tasks/TasksManager.hpp" +#include "fieldSpecification/FieldSpecification.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" #include "fieldSpecification/FieldSpecificationManager.hpp" -#include "fieldSpecification/FieldSpecificationBase.hpp" #include "common/FieldSpecificationOps.hpp" #include "mesh/DomainPartition.hpp" #include "mesh/MeshBody.hpp" @@ -90,7 +91,7 @@ FieldApplicator:: { if( fsm.hasGroup( fsName ) ) { - FieldSpecificationBase const & fs = fsm.getGroup< FieldSpecificationBase >( fsName ); + FieldSpecification const & fs = fsm.getGroup< FieldSpecification >( fsName ); if( dynamic_cast< EquilibriumInitialCondition const * >( &fs ) != nullptr ) { hasEquilibriumIC = true; @@ -158,7 +159,7 @@ FieldApplicator:: fsName ), InputError, getWrapperDataContext( viewKeyStruct::fieldSpecificationNamesString() ) ); - FieldSpecificationBase const & fs = fsm.getGroup< FieldSpecificationBase >( fsName ); + FieldSpecification const & fs = fsm.getGroup< FieldSpecification >( fsName ); for( auto & meshBodyPair : domain.getMeshBodies().getSubGroups() ) { @@ -168,12 +169,14 @@ FieldApplicator:: { 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 ) + FieldSpecificationImpl:: + apply< ElementSubRegionBase >( fs, + *meshLevel, + [&]( FieldSpecification 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() ) @@ -195,7 +198,11 @@ FieldApplicator:: } string const targetFieldName = getTargetFieldName( fieldName ); - bc.applyFieldValue< FieldSpecificationEqual >( targetSet, 0.0, subRegion, targetFieldName ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual >( bc, + targetSet, + 0.0, + subRegion, + targetFieldName ); } ); } } diff --git a/src/coreComponents/physicsSolvers/simplePDE/LaplaceBaseH1.cpp b/src/coreComponents/physicsSolvers/simplePDE/LaplaceBaseH1.cpp index c0a49eb8bcc..1433c3ac6c0 100644 --- a/src/coreComponents/physicsSolvers/simplePDE/LaplaceBaseH1.cpp +++ b/src/coreComponents/physicsSolvers/simplePDE/LaplaceBaseH1.cpp @@ -20,6 +20,7 @@ #include "LaplaceBaseH1.hpp" #include "dataRepository/InputFlags.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" #include "mainInterface/GeosxState.hpp" #include "mesh/mpiCommunications/CommunicationTools.hpp" #include "mesh/DomainPartition.hpp" @@ -210,21 +211,22 @@ void LaplaceBaseH1:: fsManager.apply< NodeManager >( time, mesh, m_fieldName, - [&]( FieldSpecificationBase const & bc, + [&]( FieldSpecification const & bc, string const &, SortedArrayView< localIndex const > const & targetSet, NodeManager & targetGroup, string const & GEOS_UNUSED_PARAM( fieldName ) ) { - bc.applyBoundaryConditionToSystem< FieldSpecificationEqual, - parallelDevicePolicy< > >( targetSet, - time, - targetGroup, - m_fieldName, - dofManager.getKey( m_fieldName ), - dofManager.rankOffset(), - localMatrix, - localRhs ); + FieldSpecificationImpl::applyBoundaryConditionToSystem< FieldSpecificationEqual, + parallelDevicePolicy< > >( bc, + targetSet, + time, + targetGroup, + m_fieldName, + dofManager.getKey( m_fieldName ), + dofManager.rankOffset(), + localMatrix, + localRhs ); } ); } ); } diff --git a/src/coreComponents/physicsSolvers/simplePDE/PhaseFieldDamageFEM.cpp b/src/coreComponents/physicsSolvers/simplePDE/PhaseFieldDamageFEM.cpp index aced6493e37..bfe09b66e6d 100644 --- a/src/coreComponents/physicsSolvers/simplePDE/PhaseFieldDamageFEM.cpp +++ b/src/coreComponents/physicsSolvers/simplePDE/PhaseFieldDamageFEM.cpp @@ -33,6 +33,7 @@ #include "constitutive/solid/Damage.hpp" #include "physicsSolvers/LogLevelsInfo.hpp" #include "constitutive/solid/SolidBase.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" #include "finiteElement/FiniteElementDiscretization.hpp" #include "finiteElement/Kinematics.h" @@ -590,21 +591,22 @@ void PhaseFieldDamageFEM::applyDirichletBCImplicit( real64 const time, fsManager.template apply< NodeManager >( time, mesh, m_fieldName, - [&]( FieldSpecificationBase const & bc, + [&]( FieldSpecification const & bc, string const &, SortedArrayView< localIndex const > const & targetSet, NodeManager & targetGroup, string const GEOS_UNUSED_PARAM( fieldName ) ) -> void { - bc.applyBoundaryConditionToSystem< FieldSpecificationEqual, - parallelDevicePolicy< > >( targetSet, - time, - targetGroup, - m_fieldName, - dofManager.getKey( m_fieldName ), - dofManager.rankOffset(), - localMatrix, - localRhs ); + FieldSpecificationImpl::applyBoundaryConditionToSystem< FieldSpecificationEqual, + parallelDevicePolicy< > >( bc, + targetSet, + time, + targetGroup, + m_fieldName, + dofManager.getKey( m_fieldName ), + dofManager.rankOffset(), + localMatrix, + localRhs ); } ); fsManager.applyFieldValue< serialPolicy >( time, mesh, viewKeyStruct::coeffNameString() ); diff --git a/src/coreComponents/physicsSolvers/simplePDE/PhaseFieldDamageFEM.hpp b/src/coreComponents/physicsSolvers/simplePDE/PhaseFieldDamageFEM.hpp index 2e69325e94d..d4d0bb5ad93 100644 --- a/src/coreComponents/physicsSolvers/simplePDE/PhaseFieldDamageFEM.hpp +++ b/src/coreComponents/physicsSolvers/simplePDE/PhaseFieldDamageFEM.hpp @@ -36,7 +36,7 @@ namespace dataRepository { class Group; } -class FieldSpecificationBase; +class FieldSpecification; class FiniteElementBase; class DomainPartition; diff --git a/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsLagrangianFEM.cpp b/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsLagrangianFEM.cpp index 9c919cffa96..2e2ab2d365d 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsLagrangianFEM.cpp +++ b/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsLagrangianFEM.cpp @@ -30,6 +30,7 @@ #include "constitutive/ConstitutiveManager.hpp" #include "common/GEOS_RAJA_Interface.hpp" #include "discretizationMethods/NumericalMethodsManager.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" #include "fieldSpecification/FieldSpecificationManager.hpp" #include "fieldSpecification/TractionBoundaryCondition.hpp" #include "finiteElement/FiniteElementDiscretizationManager.hpp" @@ -636,7 +637,7 @@ real64 SolidMechanicsLagrangianFEM::explicitStep( real64 const & time_n, fsManager.applyFieldValue( time_n + dt, mesh, solidMechanics::totalDisplacement::key(), - [&]( FieldSpecificationBase const & bc, + [&]( FieldSpecification const & bc, SortedArrayView< localIndex const > const & targetSet ) { integer const component = bc.getComponent(); @@ -650,7 +651,7 @@ real64 SolidMechanicsLagrangianFEM::explicitStep( real64 const & time_n, vel( a, component ) = u( a, component ); } ); }, - [&]( FieldSpecificationBase const & bc, + [&]( FieldSpecification const & bc, SortedArrayView< localIndex const > const & targetSet ) { integer const component = bc.getComponent(); @@ -730,21 +731,22 @@ void SolidMechanicsLagrangianFEM::applyDisplacementBCImplicit( real64 const time fsManager.apply< NodeManager >( time, mesh, solidMechanics::totalDisplacement::key(), - [&]( FieldSpecificationBase const & bc, + [&]( FieldSpecification const & bc, string const &, SortedArrayView< localIndex const > const & targetSet, NodeManager & targetGroup, string const fieldName ) { - bc.applyBoundaryConditionToSystem< FieldSpecificationEqual, - parallelDevicePolicy< > >( targetSet, - time, - targetGroup, - fieldName, - dofKey, - dofManager.rankOffset(), - localMatrix, - localRhs ); + FieldSpecificationImpl::applyBoundaryConditionToSystem< FieldSpecificationEqual, + parallelDevicePolicy< > >( bc, + targetSet, + time, + targetGroup, + fieldName, + dofKey, + dofManager.rankOffset(), + localMatrix, + localRhs ); if( targetSet.size() > 0 && bc.getComponent() == 0 ) { @@ -1261,22 +1263,23 @@ SolidMechanicsLagrangianFEM:: fsManager.apply< NodeManager >( time_n + dt, mesh, viewKeyStruct::forceString(), - [&]( FieldSpecificationBase const & bc, + [&]( FieldSpecification const & bc, string const &, SortedArrayView< localIndex const > const & targetSet, NodeManager & targetGroup, string const & GEOS_UNUSED_PARAM( fieldName ) ) { // TODO: fix use of dummy name - bc.applyBoundaryConditionToSystem< FieldSpecificationAdd, - parallelDevicePolicy< > >( targetSet, - time_n + dt, - targetGroup, - solidMechanics::totalDisplacement::key(), - dofKey, - dofManager.rankOffset(), - localMatrix, - localRhs ); + FieldSpecificationImpl::applyBoundaryConditionToSystem< FieldSpecificationAdd, + parallelDevicePolicy< > >( bc, + targetSet, + time_n + dt, + targetGroup, + solidMechanics::totalDisplacement::key(), + dofKey, + dofManager.rankOffset(), + localMatrix, + localRhs ); } ); } ); diff --git a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsEmbeddedFractures.cpp b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsEmbeddedFractures.cpp index 0fe6810a514..49058898c65 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsEmbeddedFractures.cpp +++ b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsEmbeddedFractures.cpp @@ -22,6 +22,7 @@ #include "common/TimingMacros.hpp" #include "common/GEOS_RAJA_Interface.hpp" #include "constitutive/contact/FrictionSelector.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" #include "fieldSpecification/FieldSpecificationManager.hpp" #include "finiteElement/elementFormulations/FiniteElementBase.hpp" #include "linearAlgebra/utilities/LAIHelperFunctions.hpp" @@ -528,16 +529,18 @@ void SolidMechanicsEmbeddedFractures::applyTractionBC( real64 const time_n, fsManager.apply< ElementSubRegionBase >( time_n+ dt, mesh, contact::traction::key(), - [&] ( FieldSpecificationBase const & fs, + [&] ( FieldSpecification const & fs, string const &, SortedArrayView< localIndex const > const & targetSet, ElementSubRegionBase & subRegion, string const & ) { - fs.applyFieldValue< FieldSpecificationEqual, parallelHostPolicy >( targetSet, - time_n+dt, - subRegion, - contact::traction::key() ); + FieldSpecificationImpl::applyFieldValue< FieldSpecificationEqual, + parallelHostPolicy >( fs, + targetSet, + time_n+dt, + subRegion, + contact::traction::key() ); } ); } ); } diff --git a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsLagrangeContactBubbleStab.cpp b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsLagrangeContactBubbleStab.cpp index e3d63a5fed1..34417df75db 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsLagrangeContactBubbleStab.cpp +++ b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsLagrangeContactBubbleStab.cpp @@ -29,6 +29,7 @@ #include "physicsSolvers/LogLevelsInfo.hpp" #include "finiteElement/FiniteElementDiscretization.hpp" #include "constitutive/contact/FrictionSelector.hpp" +#include "fieldSpecification/FieldSpecificationImpl.hpp" #include "fieldSpecification/FieldSpecificationManager.hpp" diff --git a/src/coreComponents/physicsSolvers/wavePropagation/dg/acoustic/secondOrderEqn/isotropic/AcousticWaveEquationDG.cpp b/src/coreComponents/physicsSolvers/wavePropagation/dg/acoustic/secondOrderEqn/isotropic/AcousticWaveEquationDG.cpp index 51956b4a801..d2ed40b724b 100644 --- a/src/coreComponents/physicsSolvers/wavePropagation/dg/acoustic/secondOrderEqn/isotropic/AcousticWaveEquationDG.cpp +++ b/src/coreComponents/physicsSolvers/wavePropagation/dg/acoustic/secondOrderEqn/isotropic/AcousticWaveEquationDG.cpp @@ -409,7 +409,7 @@ void AcousticWaveEquationDG::applyFreeSurfaceBC( real64 const time, DomainPartit // fsManager.apply< FaceManager >( time, // domain.getMeshBody( 0 ).getMeshLevel( m_discretizationName ), // string( "FreeSurface" ), -// [&]( FieldSpecificationBase const & bc, +// [&]( FieldSpecification const & bc, // string const &, // SortedArrayView< localIndex const > const & targetSet, // FaceManager &, diff --git a/src/coreComponents/physicsSolvers/wavePropagation/sem/acoustic/firstOrderEqn/isotropic/AcousticFirstOrderWaveEquationSEM.cpp b/src/coreComponents/physicsSolvers/wavePropagation/sem/acoustic/firstOrderEqn/isotropic/AcousticFirstOrderWaveEquationSEM.cpp index 1dbb298ceca..e56ca81c75c 100644 --- a/src/coreComponents/physicsSolvers/wavePropagation/sem/acoustic/firstOrderEqn/isotropic/AcousticFirstOrderWaveEquationSEM.cpp +++ b/src/coreComponents/physicsSolvers/wavePropagation/sem/acoustic/firstOrderEqn/isotropic/AcousticFirstOrderWaveEquationSEM.cpp @@ -379,7 +379,7 @@ void AcousticFirstOrderWaveEquationSEM::applyFreeSurfaceBC( real64 const time, D fsManager.apply< FaceManager >( time, domain.getMeshBody( 0 ).getMeshLevel( m_discretizationName ), WaveSolverBase::viewKeyStruct::freeSurfaceString(), - [&]( FieldSpecificationBase const & bc, + [&]( FieldSpecification const & bc, string const &, SortedArrayView< localIndex const > const & targetSet, FaceManager &, diff --git a/src/coreComponents/physicsSolvers/wavePropagation/sem/acoustic/secondOrderEqn/anisotropic/AcousticVTIWaveEquationSEM.cpp b/src/coreComponents/physicsSolvers/wavePropagation/sem/acoustic/secondOrderEqn/anisotropic/AcousticVTIWaveEquationSEM.cpp index a9a9206afdc..1cd6fafaa2f 100644 --- a/src/coreComponents/physicsSolvers/wavePropagation/sem/acoustic/secondOrderEqn/anisotropic/AcousticVTIWaveEquationSEM.cpp +++ b/src/coreComponents/physicsSolvers/wavePropagation/sem/acoustic/secondOrderEqn/anisotropic/AcousticVTIWaveEquationSEM.cpp @@ -389,7 +389,7 @@ void AcousticVTIWaveEquationSEM::precomputeSurfaceFieldIndicator( DomainPartitio fsManager.apply< FaceManager >( time, domain.getMeshBody( 0 ).getMeshLevel( m_discretizationName ), viewKeyStruct::lateralSurfaceString(), - [&]( FieldSpecificationBase const & bc, + [&]( FieldSpecification const & bc, string const &, SortedArrayView< localIndex const > const & targetSet, FaceManager &, @@ -422,7 +422,7 @@ void AcousticVTIWaveEquationSEM::precomputeSurfaceFieldIndicator( DomainPartitio fsManager.apply< FaceManager >( time, domain.getMeshBody( 0 ).getMeshLevel( m_discretizationName ), viewKeyStruct::bottomSurfaceString(), - [&]( FieldSpecificationBase const & bc, + [&]( FieldSpecification const & bc, string const &, SortedArrayView< localIndex const > const & targetSet, FaceManager &, @@ -479,7 +479,7 @@ void AcousticVTIWaveEquationSEM::applyFreeSurfaceBC( real64 time, DomainPartitio fsManager.apply< FaceManager >( time, domain.getMeshBody( 0 ).getMeshLevel( m_discretizationName ), WaveSolverBase::viewKeyStruct::freeSurfaceString(), - [&]( FieldSpecificationBase const & bc, + [&]( FieldSpecification const & bc, string const &, SortedArrayView< localIndex const > const & targetSet, FaceManager &, diff --git a/src/coreComponents/physicsSolvers/wavePropagation/sem/acoustic/secondOrderEqn/isotropic/AcousticWaveEquationSEM.cpp b/src/coreComponents/physicsSolvers/wavePropagation/sem/acoustic/secondOrderEqn/isotropic/AcousticWaveEquationSEM.cpp index f6613f6c4f4..69c5bdbd525 100644 --- a/src/coreComponents/physicsSolvers/wavePropagation/sem/acoustic/secondOrderEqn/isotropic/AcousticWaveEquationSEM.cpp +++ b/src/coreComponents/physicsSolvers/wavePropagation/sem/acoustic/secondOrderEqn/isotropic/AcousticWaveEquationSEM.cpp @@ -637,7 +637,7 @@ void AcousticWaveEquationSEM::applyFreeSurfaceBC( real64 time, DomainPartition & fsManager.apply< FaceManager >( time, domain.getMeshBody( 0 ).getMeshLevel( m_discretizationName ), string( "FreeSurface" ), - [&]( FieldSpecificationBase const & bc, + [&]( FieldSpecification const & bc, string const &, SortedArrayView< localIndex const > const & targetSet, FaceManager &, diff --git a/src/coreComponents/physicsSolvers/wavePropagation/sem/elastic/firstOrderEqn/isotropic/ElasticFirstOrderWaveEquationSEM.cpp b/src/coreComponents/physicsSolvers/wavePropagation/sem/elastic/firstOrderEqn/isotropic/ElasticFirstOrderWaveEquationSEM.cpp index ffc9fc8b4d3..833d8a76c0d 100644 --- a/src/coreComponents/physicsSolvers/wavePropagation/sem/elastic/firstOrderEqn/isotropic/ElasticFirstOrderWaveEquationSEM.cpp +++ b/src/coreComponents/physicsSolvers/wavePropagation/sem/elastic/firstOrderEqn/isotropic/ElasticFirstOrderWaveEquationSEM.cpp @@ -444,7 +444,7 @@ void ElasticFirstOrderWaveEquationSEM::applyFreeSurfaceBC( real64 const time, Do fsManager.apply( time, domain.getMeshBody( 0 ).getMeshLevel( m_discretizationName ), WaveSolverBase::viewKeyStruct::freeSurfaceString(), - [&]( FieldSpecificationBase const & bc, + [&]( FieldSpecification const & bc, string const &, SortedArrayView< localIndex const > const & targetSet, Group &, diff --git a/src/coreComponents/physicsSolvers/wavePropagation/sem/elastic/secondOrderEqn/isotropic/ElasticWaveEquationSEM.cpp b/src/coreComponents/physicsSolvers/wavePropagation/sem/elastic/secondOrderEqn/isotropic/ElasticWaveEquationSEM.cpp index 52af88358e0..07f7c4ad5e4 100644 --- a/src/coreComponents/physicsSolvers/wavePropagation/sem/elastic/secondOrderEqn/isotropic/ElasticWaveEquationSEM.cpp +++ b/src/coreComponents/physicsSolvers/wavePropagation/sem/elastic/secondOrderEqn/isotropic/ElasticWaveEquationSEM.cpp @@ -729,7 +729,7 @@ void ElasticWaveEquationSEM::applyFreeSurfaceBC( real64 const time, DomainPartit fsManager.apply( time, domain.getMeshBody( 0 ).getMeshLevel( m_discretizationName ), WaveSolverBase::viewKeyStruct::freeSurfaceString(), - [&]( FieldSpecificationBase const & bc, + [&]( FieldSpecification const & bc, string const &, SortedArrayView< localIndex const > const & targetSet, Group &, diff --git a/src/coreComponents/schema/schema.xsd b/src/coreComponents/schema/schema.xsd index 4805f560fa5..8a586eebe36 100644 --- a/src/coreComponents/schema/schema.xsd +++ b/src/coreComponents/schema/schema.xsd @@ -1360,7 +1360,7 @@ When set to "silent", no output. When set to "warning", output a warning. When set to "error", output a throw. --> - + @@ -1377,7 +1377,7 @@ A set can be be defined by a 'Geometry' component, or correspond to imported set - + @@ -1399,7 +1399,7 @@ When set to "silent", no output. When set to "warning", output a warning. When set to "error", output a throw. --> - + @@ -1435,7 +1435,7 @@ When set to "silent", no output. When set to "warning", output a warning. When set to "error", output a throw. --> - + @@ -1480,7 +1480,7 @@ When set to "silent", no output. When set to "warning", output a warning. When set to "error", output a throw. --> - + @@ -1515,7 +1515,7 @@ When set to "silent", no output. When set to "warning", output a warning. When set to "error", output a throw. --> - + @@ -1560,7 +1560,7 @@ When set to "silent", no output. When set to "warning", output a warning. When set to "error", output a throw. --> - + @@ -1590,7 +1590,7 @@ When set to "silent", no output. When set to "warning", output a warning. When set to "error", output a throw. --> - + From 08bd4c6df04693ba54e04a00efe99a903807ae10 Mon Sep 17 00:00:00 2001 From: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> Date: Mon, 18 May 2026 21:23:46 -0500 Subject: [PATCH 41/53] Trim tests (#4055) * Trim tests * Update baseline notes with recent PR entries Added entries for pull requests 4055, 4029, and 3959 with details. * Update baseline for integrated tests * rebaseline --------- Co-authored-by: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> Co-authored-by: DENEL Bertrand --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 4 +- .../compositionalMultiphaseWell.ats | 4 +- .../dome_initialisation.xml | 145 ------------------ .../dome_kvalue_base.xml | 60 ++++++-- .../dome_kvalue_bench.xml | 48 +----- .../dome_kvalue_smoke.xml | 48 +----- .../dome_mesh_bench.xml | 49 ++++++ .../dome_mesh_smoke.xml | 49 ++++++ .../dome_smoke.vti | 4 +- .../dome_soreide_whitson_base.xml | 60 ++++++-- .../dome_soreide_whitson_bench.xml | 48 +----- .../dome_soreide_whitson_smoke.xml | 48 +----- .../tables/INITIAL.CH4.CLAY.txt | 17 -- .../tables/INITIAL.CH4.SAND.txt | 17 -- .../tables/INITIAL.CO2.CLAY.txt | 17 -- .../tables/INITIAL.CO2.SAND.txt | 17 -- .../tables/INITIAL.ELEVATION.txt | 17 -- .../tables/INITIAL.H2O.CLAY.txt | 17 -- .../tables/INITIAL.H2O.SAND.txt | 17 -- .../tables/INITIAL.H2S.CLAY.txt | 17 -- .../tables/INITIAL.H2S.SAND.txt | 17 -- .../tables/INITIAL.PRESSURE.CLAY.txt | 17 -- .../tables/INITIAL.PRESSURE.SAND.txt | 17 -- .../compositionalMultiphaseWell/tables/xy.txt | 2 - 25 files changed, 200 insertions(+), 558 deletions(-) delete mode 100644 inputFiles/compositionalMultiphaseWell/dome_initialisation.xml create mode 100644 inputFiles/compositionalMultiphaseWell/dome_mesh_bench.xml create mode 100644 inputFiles/compositionalMultiphaseWell/dome_mesh_smoke.xml delete mode 100644 inputFiles/compositionalMultiphaseWell/tables/INITIAL.CH4.CLAY.txt delete mode 100644 inputFiles/compositionalMultiphaseWell/tables/INITIAL.CH4.SAND.txt delete mode 100644 inputFiles/compositionalMultiphaseWell/tables/INITIAL.CO2.CLAY.txt delete mode 100644 inputFiles/compositionalMultiphaseWell/tables/INITIAL.CO2.SAND.txt delete mode 100644 inputFiles/compositionalMultiphaseWell/tables/INITIAL.ELEVATION.txt delete mode 100644 inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2O.CLAY.txt delete mode 100644 inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2O.SAND.txt delete mode 100644 inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2S.CLAY.txt delete mode 100644 inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2S.SAND.txt delete mode 100644 inputFiles/compositionalMultiphaseWell/tables/INITIAL.PRESSURE.CLAY.txt delete mode 100644 inputFiles/compositionalMultiphaseWell/tables/INITIAL.PRESSURE.SAND.txt delete mode 100644 inputFiles/compositionalMultiphaseWell/tables/xy.txt diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index 36cbe38311e..3dc5fa17937 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr4041-16664-9a29348 + baseline: integratedTests/baseline_integratedTests-pr4055-16683-0251bb6 allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index e6f3978c390..9205b8e80d9 100644 --- a/BASELINE_NOTES.md +++ b/BASELINE_NOTES.md @@ -5,8 +5,10 @@ This file is designed to track changes to the integrated test baselines. Any developer who updates the baseline ID in the .integrated_tests.yaml file is expected to create an entry in this file with the pull request number, date, and their justification for rebaselining. These notes should be in reverse-chronological order, and use the following time format: (YYYY-MM-DD). +PR #4055 (2026-05-18) +Trim some fluid model tests + PR #4041 (2026-05-16) -===================== Fix wellbore nonlinear thermal diffusion PR #3977 (2026-05-15) diff --git a/inputFiles/compositionalMultiphaseWell/compositionalMultiphaseWell.ats b/inputFiles/compositionalMultiphaseWell/compositionalMultiphaseWell.ats index facc77ba589..a9eae7db309 100644 --- a/inputFiles/compositionalMultiphaseWell/compositionalMultiphaseWell.ats +++ b/inputFiles/compositionalMultiphaseWell/compositionalMultiphaseWell.ats @@ -137,14 +137,14 @@ decks = [ name="dome_soreide_whitson_smoke", description="Injection into a depleted reservoir using the Soreide Whitson EoS", partitions=[(1, 1, 1), (2, 2, 1)], - restart_step=50, + restart_step=100, check_step=150, restartcheck_params=RestartcheckParameters(**restartcheck_params)), TestDeck( name="dome_kvalue_smoke", description="Injection into a depleted reservoir using a K-Value model", partitions=[(1, 1, 1), (2, 2, 1)], - restart_step=50, + restart_step=100, check_step=150, restartcheck_params=RestartcheckParameters(**restartcheck_params)) ] diff --git a/inputFiles/compositionalMultiphaseWell/dome_initialisation.xml b/inputFiles/compositionalMultiphaseWell/dome_initialisation.xml deleted file mode 100644 index 25702aaabeb..00000000000 --- a/inputFiles/compositionalMultiphaseWell/dome_initialisation.xml +++ /dev/null @@ -1,145 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/inputFiles/compositionalMultiphaseWell/dome_kvalue_base.xml b/inputFiles/compositionalMultiphaseWell/dome_kvalue_base.xml index 305c01ce806..a35ff384e89 100644 --- a/inputFiles/compositionalMultiphaseWell/dome_kvalue_base.xml +++ b/inputFiles/compositionalMultiphaseWell/dome_kvalue_base.xml @@ -7,22 +7,19 @@ wellSolverName="WELL.SOLVER" targetRegions="{ SAND, CLAY, WATER.INJECTOR, GAS.INJECTOR, PRODUCER }" logLevel="1" - initialDt="3600"> + initialDt="86400"> - + + + + + @@ -200,7 +210,7 @@ + + + + + + + coordinates="{ -31557600, 0, 157788000, 252460800 }" + values="{ 0, 15, 15, 0 }" /> - diff --git a/inputFiles/compositionalMultiphaseWell/dome_kvalue_bench.xml b/inputFiles/compositionalMultiphaseWell/dome_kvalue_bench.xml index e1dd8ee0a9c..6a2c5950aca 100644 --- a/inputFiles/compositionalMultiphaseWell/dome_kvalue_bench.xml +++ b/inputFiles/compositionalMultiphaseWell/dome_kvalue_bench.xml @@ -2,52 +2,6 @@ + - - - - - - - - - - - - - - diff --git a/inputFiles/compositionalMultiphaseWell/dome_kvalue_smoke.xml b/inputFiles/compositionalMultiphaseWell/dome_kvalue_smoke.xml index c8f3fef6334..95a923187e8 100644 --- a/inputFiles/compositionalMultiphaseWell/dome_kvalue_smoke.xml +++ b/inputFiles/compositionalMultiphaseWell/dome_kvalue_smoke.xml @@ -2,52 +2,6 @@ + - - - - - - - - - - - - - - diff --git a/inputFiles/compositionalMultiphaseWell/dome_mesh_bench.xml b/inputFiles/compositionalMultiphaseWell/dome_mesh_bench.xml new file mode 100644 index 00000000000..df49c76f6b6 --- /dev/null +++ b/inputFiles/compositionalMultiphaseWell/dome_mesh_bench.xml @@ -0,0 +1,49 @@ + + + + + + + + + + + + + + + + diff --git a/inputFiles/compositionalMultiphaseWell/dome_mesh_smoke.xml b/inputFiles/compositionalMultiphaseWell/dome_mesh_smoke.xml new file mode 100644 index 00000000000..52429f8bd40 --- /dev/null +++ b/inputFiles/compositionalMultiphaseWell/dome_mesh_smoke.xml @@ -0,0 +1,49 @@ + + + + + + + + + + + + + + + + diff --git a/inputFiles/compositionalMultiphaseWell/dome_smoke.vti b/inputFiles/compositionalMultiphaseWell/dome_smoke.vti index f3bcf1e6236..e7fa7af9876 100644 --- a/inputFiles/compositionalMultiphaseWell/dome_smoke.vti +++ b/inputFiles/compositionalMultiphaseWell/dome_smoke.vti @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:3293ad94e9e66c65295dc5542a2c67e203fcb7959dacc997e32bf549ebaf868f -size 642 +oid sha256:8dab9433a76414a6d5f19d31cd221ffd3b9d0e7a294838e8e7716bc834d03f4b +size 733 diff --git a/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_base.xml b/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_base.xml index 2e00878f00e..718e7894417 100644 --- a/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_base.xml +++ b/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_base.xml @@ -7,22 +7,19 @@ wellSolverName="WELL.SOLVER" targetRegions="{ SAND, CLAY, WATER.INJECTOR, GAS.INJECTOR, PRODUCER }" logLevel="1" - initialDt="3600"> + initialDt="86400"> - + + + + + @@ -208,7 +218,7 @@ + + + + + + + coordinates="{ -31557600, 0, 157788000, 252460800 }" + values="{ 0, 15, 15, 0 }" /> - diff --git a/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_bench.xml b/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_bench.xml index 42ef79fa806..faeefdc59a0 100644 --- a/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_bench.xml +++ b/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_bench.xml @@ -2,52 +2,6 @@ + - - - - - - - - - - - - - - diff --git a/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_smoke.xml b/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_smoke.xml index 202f057d4ab..c62694aea22 100644 --- a/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_smoke.xml +++ b/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_smoke.xml @@ -2,52 +2,6 @@ + - - - - - - - - - - - - - - diff --git a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.CH4.CLAY.txt b/inputFiles/compositionalMultiphaseWell/tables/INITIAL.CH4.CLAY.txt deleted file mode 100644 index ef070045ace..00000000000 --- a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.CH4.CLAY.txt +++ /dev/null @@ -1,17 +0,0 @@ -0.017513 -0.0175868 -0.0244635 -0.0246012 -0.025056 -0.0255622 -0.02568 -0.0258657 -0.0274863 -0.248651 -0.270079 -0.28153 -0.293519 -0.319267 -0.441271 -0.918423 -0.917946 diff --git a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.CH4.SAND.txt b/inputFiles/compositionalMultiphaseWell/tables/INITIAL.CH4.SAND.txt deleted file mode 100644 index 74daf54e88f..00000000000 --- a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.CH4.SAND.txt +++ /dev/null @@ -1,17 +0,0 @@ -0.0108852 -0.0120584 -0.0171054 -0.0171596 -0.0174948 -0.0242155 -0.026641 -0.0291073 -0.0316157 -0.352342 -0.417053 -0.461118 -0.918477 -0.918461 -0.918454 -0.918448 -0.917972 diff --git a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.CO2.CLAY.txt b/inputFiles/compositionalMultiphaseWell/tables/INITIAL.CO2.CLAY.txt deleted file mode 100644 index 1da7f2d7aae..00000000000 --- a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.CO2.CLAY.txt +++ /dev/null @@ -1,17 +0,0 @@ -1.95801e-14 -1.45309e-14 -2.08699e-15 -2.08712e-15 -2.0874e-15 -2.09081e-15 -2.08939e-15 -2.09085e-15 -2.20656e-15 -4.43057e-15 -4.79837e-15 -4.99513e-15 -5.20116e-15 -5.64432e-15 -7.7897e-15 -1.61852e-14 -1.65008e-14 diff --git a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.CO2.SAND.txt b/inputFiles/compositionalMultiphaseWell/tables/INITIAL.CO2.SAND.txt deleted file mode 100644 index 711a35c2e29..00000000000 --- a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.CO2.SAND.txt +++ /dev/null @@ -1,17 +0,0 @@ -2.61508e-14 -2.47424e-14 -2.02446e-15 -2.02002e-15 -2.02012e-15 -2.46014e-15 -2.41303e-15 -2.38057e-15 -2.3572e-15 -6.2714e-15 -7.39946e-15 -8.16889e-15 -1.62366e-14 -1.61974e-14 -1.61826e-14 -1.61705e-14 -1.65063e-14 diff --git a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.ELEVATION.txt b/inputFiles/compositionalMultiphaseWell/tables/INITIAL.ELEVATION.txt deleted file mode 100644 index d0c38e4b692..00000000000 --- a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.ELEVATION.txt +++ /dev/null @@ -1,17 +0,0 @@ --4680 --4651.25 --4463.75 --4461.25 --4453.75 --4446.25 --4443.75 --4441.25 --4438.75 --4338.75 --4333.75 --4331.25 --4328.75 --4323.75 --4321.25 --4318.75 --4000 diff --git a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2O.CLAY.txt b/inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2O.CLAY.txt deleted file mode 100644 index b1d46588fac..00000000000 --- a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2O.CLAY.txt +++ /dev/null @@ -1,17 +0,0 @@ -0.982487 -0.982413 -0.973991 -0.973696 -0.972759 -0.971787 -0.971525 -0.971201 -0.969393 -0.735424 -0.71287 -0.700818 -0.688202 -0.661105 -0.53272 -0.0306163 -0.0311123 diff --git a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2O.SAND.txt b/inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2O.SAND.txt deleted file mode 100644 index 458caaac085..00000000000 --- a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2O.SAND.txt +++ /dev/null @@ -1,17 +0,0 @@ -0.989115 -0.987942 -0.982049 -0.981883 -0.981176 -0.973886 -0.97125 -0.968566 -0.965832 -0.626322 -0.558219 -0.511847 -0.0305755 -0.0305831 -0.0305869 -0.0305907 -0.0310858 diff --git a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2S.CLAY.txt b/inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2S.CLAY.txt deleted file mode 100644 index 133ea6efbed..00000000000 --- a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2S.CLAY.txt +++ /dev/null @@ -1,17 +0,0 @@ -2.45744e-15 -2.45882e-15 -0.00154586 -0.00170309 -0.00218507 -0.00265091 -0.00279451 -0.00293372 -0.00312061 -0.0159255 -0.0170509 -0.0176515 -0.0182798 -0.0196284 -0.0260089 -0.0509609 -0.0509412 diff --git a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2S.SAND.txt b/inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2S.SAND.txt deleted file mode 100644 index 1894436199c..00000000000 --- a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.H2S.SAND.txt +++ /dev/null @@ -1,17 +0,0 @@ -2.24261e-15 -2.28086e-15 -0.000845954 -0.000957176 -0.0013292 -0.00189817 -0.00210872 -0.00232686 -0.00255207 -0.0213366 -0.0247278 -0.027035 -0.0509471 -0.0509562 -0.0509591 -0.0509612 -0.0509426 diff --git a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.PRESSURE.CLAY.txt b/inputFiles/compositionalMultiphaseWell/tables/INITIAL.PRESSURE.CLAY.txt deleted file mode 100644 index 8f2c64fd4c2..00000000000 --- a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.PRESSURE.CLAY.txt +++ /dev/null @@ -1,17 +0,0 @@ -2.90037e+07 -2.89785e+07 -2.70996e+07 -2.70751e+07 -2.70017e+07 -2.69288e+07 -2.69041e+07 -2.68799e+07 -2.68659e+07 -2.66921e+07 -2.66834e+07 -2.6679e+07 -2.66747e+07 -2.6666e+07 -2.66616e+07 -2.66573e+07 -2.61096e+07 diff --git a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.PRESSURE.SAND.txt b/inputFiles/compositionalMultiphaseWell/tables/INITIAL.PRESSURE.SAND.txt deleted file mode 100644 index bfe963de64b..00000000000 --- a/inputFiles/compositionalMultiphaseWell/tables/INITIAL.PRESSURE.SAND.txt +++ /dev/null @@ -1,17 +0,0 @@ -2.89131e+07 -2.8899e+07 -2.70193e+07 -2.69943e+07 -2.69208e+07 -2.69078e+07 -2.69036e+07 -2.68994e+07 -2.68952e+07 -2.67219e+07 -2.67132e+07 -2.67088e+07 -2.67044e+07 -2.66957e+07 -2.66914e+07 -2.6687e+07 -2.61388e+07 diff --git a/inputFiles/compositionalMultiphaseWell/tables/xy.txt b/inputFiles/compositionalMultiphaseWell/tables/xy.txt deleted file mode 100644 index 6efa97fe5b5..00000000000 --- a/inputFiles/compositionalMultiphaseWell/tables/xy.txt +++ /dev/null @@ -1,2 +0,0 @@ -0.0 - From a458b6e26c50ca9699081172f7068b59ebf8dd9c Mon Sep 17 00:00:00 2001 From: Bertrand Denel <120652669+bd713@users.noreply.github.com> Date: Tue, 19 May 2026 00:29:39 -0700 Subject: [PATCH 42/53] fix: Fracture/3D cell co-location in parallel mesh redistribution (#4008) * Draft * working version * Clean * Clean * Fixed map * Clean * gpu * Clean Omar * JF Review * Missing protection * stdContainer 1 * stdContainer 2 * stdContainer 3 * Added schema * rebaseline --------- Co-authored-by: DENEL Bertrand Co-authored-by: Omar Duran Co-authored-by: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> Co-authored-by: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 3 + .../meshTests/testVTKImport.cpp | 77 +- src/coreComponents/mesh/CMakeLists.txt | 2 + .../mesh/generators/CollocatedNodes.cpp | 30 +- .../mesh/generators/CollocatedNodes.hpp | 5 +- .../mesh/generators/ParMETISInterface.cpp | 58 + .../mesh/generators/ParMETISInterface.hpp | 17 + .../mesh/generators/VTKFaceBlockUtilities.cpp | 75 +- .../mesh/generators/VTKMeshGenerator.cpp | 5 + .../mesh/generators/VTKMeshGenerator.hpp | 4 + .../generators/VTKSuperCellPartitioning.cpp | 1035 +++++++++++++++++ .../generators/VTKSuperCellPartitioning.hpp | 167 +++ .../mesh/generators/VTKUtilities.cpp | 1006 ++++++++++++---- .../mesh/generators/VTKUtilities.hpp | 19 + src/coreComponents/schema/schema.xsd | 4 +- 16 files changed, 2197 insertions(+), 312 deletions(-) create mode 100644 src/coreComponents/mesh/generators/VTKSuperCellPartitioning.cpp create mode 100644 src/coreComponents/mesh/generators/VTKSuperCellPartitioning.hpp diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index 3dc5fa17937..460e76c7fbb 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr4055-16683-0251bb6 + baseline: integratedTests/baseline_integratedTests-pr4008-16688-17c55fe allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index 9205b8e80d9..57232417cad 100644 --- a/BASELINE_NOTES.md +++ b/BASELINE_NOTES.md @@ -5,6 +5,9 @@ This file is designed to track changes to the integrated test baselines. Any developer who updates the baseline ID in the .integrated_tests.yaml file is expected to create an entry in this file with the pull request number, date, and their justification for rebaselining. These notes should be in reverse-chronological order, and use the following time format: (YYYY-MM-DD). +PR #4008 (2026-05-18) +Fix Fracture/3D cell co-location in parallel mesh redistribution + PR #4055 (2026-05-18) Trim some fluid model tests diff --git a/src/coreComponents/integrationTests/meshTests/testVTKImport.cpp b/src/coreComponents/integrationTests/meshTests/testVTKImport.cpp index 3eab728a833..a2f13b88748 100644 --- a/src/coreComponents/integrationTests/meshTests/testVTKImport.cpp +++ b/src/coreComponents/integrationTests/meshTests/testVTKImport.cpp @@ -53,17 +53,22 @@ using namespace geos::dataRepository; template< class V > void TestMeshImport( string const & meshFilePath, V const & validate, string const fractureName="" ) { + // Automatically use global IDs when fractures are present + string const useGlobalIdsStr = fractureName.empty() ? "0" : "1"; + string const pattern = R"xml( )xml"; - string const meshNode = GEOS_FMT( pattern, meshFilePath, fractureName.empty() ? "" : "faceBlocks=\"{" + fractureName + "}\"" ); + string const meshNode = GEOS_FMT( pattern, meshFilePath, useGlobalIdsStr, + fractureName.empty() ? "" : "faceBlocks=\"{" + fractureName + "}\"" ); + xmlWrapper::xmlDocument xmlDocument; xmlDocument.loadString( meshNode ); xmlWrapper::xmlNode xmlMeshNode = xmlDocument.getChild( "Mesh" ); @@ -148,11 +153,12 @@ class TestFractureImport : public ::testing::Test static std::filesystem::path createFractureMesh( std::filesystem::path const & folder ) { - // The main mesh + // The main mesh - 3 hexahedra vtkNew< vtkUnstructuredGrid > main; { - int constexpr numPoints = 16; + int constexpr numPoints = 24; // 3 hexahedra * 8 points each double const pointsCoords[numPoints][3] = { + // First hexahedron (x: -1 to 0, y: 0 to 1) { -1, 0, 0 }, { -1, 1, 0 }, { -1, 1, 1 }, @@ -161,6 +167,7 @@ class TestFractureImport : public ::testing::Test { 0, 1, 0 }, { 0, 1, 1 }, { 0, 0, 1 }, + // Second hexahedron (x: 0 to 1, y: 0 to 1) - shares face with first via fracture { 0, 0, 0 }, { 0, 1, 0 }, { 0, 1, 1 }, @@ -168,7 +175,18 @@ class TestFractureImport : public ::testing::Test { 1, 0, 0 }, { 1, 1, 0 }, { 1, 1, 1 }, - { 1, 0, 1 } }; + { 1, 0, 1 }, + // Third hexahedron (x: -1 to 0, y: 2 to 3) - disconnected from first two + { -1, 2, 0 }, + { -1, 3, 0 }, + { -1, 3, 1 }, + { -1, 2, 1 }, + { 0, 2, 0 }, + { 0, 3, 0 }, + { 0, 3, 1 }, + { 0, 2, 1 } + }; + vtkNew< vtkPoints > points; points->Allocate( numPoints ); for( double const * pointsCoord: pointsCoords ) @@ -177,15 +195,17 @@ class TestFractureImport : public ::testing::Test } main->SetPoints( points ); - int constexpr numHexs = 2; - vtkIdType const cubes[numHexs][8] = { - { 0, 1, 2, 3, 4, 5, 6, 7 }, - { 8, 9, 10, 11, 12, 13, 14, 15 } + int constexpr numHexs = 3; + int constexpr pointsPerHex = 8; + vtkIdType const cubes[numHexs][pointsPerHex] = { + { 0, 1, 2, 3, 4, 5, 6, 7 }, // Hex 0 + { 8, 9, 10, 11, 12, 13, 14, 15 }, // Hex 1 + { 16, 17, 18, 19, 20, 21, 22, 23 } // Hex 2 }; main->Allocate( numHexs ); for( vtkIdType const * cube: cubes ) { - main->InsertNextCell( VTK_HEXAHEDRON, 8, cube ); + main->InsertNextCell( VTK_HEXAHEDRON, pointsPerHex, cube ); } vtkNew< vtkIdTypeArray > cellGlobalIds; @@ -207,7 +227,7 @@ class TestFractureImport : public ::testing::Test main->GetPointData()->SetGlobalIds( pointGlobalIds ); } - // The fracture mesh + // The fracture mesh - 1 fracture connecting only hex 0 and hex 1 vtkNew< vtkUnstructuredGrid > fracture; { int constexpr numPoints = 4; @@ -215,7 +235,9 @@ class TestFractureImport : public ::testing::Test { 0, 0, 0 }, { 0, 1, 0 }, { 0, 1, 1 }, - { 0, 0, 1 } }; + { 0, 0, 1 } + }; + vtkNew< vtkPoints > points; points->Allocate( numPoints ); for( double const * pointsCoord: pointsCoords ) @@ -225,11 +247,12 @@ class TestFractureImport : public ::testing::Test fracture->SetPoints( points ); int constexpr numQuads = 1; - vtkIdType const quad[numQuads][4] = { { 0, 1, 2, 3 } }; + int constexpr pointsPerQuad = 4; + vtkIdType const quad[numQuads][pointsPerQuad] = { { 0, 1, 2, 3 } }; fracture->Allocate( numQuads ); for( vtkIdType const * q: quad ) { - fracture->InsertNextCell( VTK_QUAD, numPoints, q ); + fracture->InsertNextCell( VTK_QUAD, pointsPerQuad, q ); } vtkNew< vtkIdTypeArray > cellGlobalIds; @@ -250,15 +273,15 @@ class TestFractureImport : public ::testing::Test } fracture->GetPointData()->SetGlobalIds( pointGlobalIds ); - // Do not forget the collocated_nodes fields + // Collocated nodes - connects hex 0 and hex 1 vtkNew< vtkIdTypeArray > collocatedNodes; collocatedNodes->SetName( "collocated_nodes" ); collocatedNodes->SetNumberOfComponents( 2 ); collocatedNodes->SetNumberOfTuples( numPoints ); - collocatedNodes->SetTuple2( 0, 4, 8 ); - collocatedNodes->SetTuple2( 1, 5, 9 ); - collocatedNodes->SetTuple2( 2, 6, 10 ); - collocatedNodes->SetTuple2( 3, 7, 11 ); + collocatedNodes->SetTuple2( 0, 4, 8 ); // Main mesh points 4 and 8 + collocatedNodes->SetTuple2( 1, 5, 9 ); // Main mesh points 5 and 9 + collocatedNodes->SetTuple2( 2, 6, 10 ); // Main mesh points 6 and 10 + collocatedNodes->SetTuple2( 3, 7, 11 ); // Main mesh points 7 and 11 fracture->GetPointData()->AddArray( collocatedNodes ); } @@ -289,29 +312,36 @@ TEST_F( TestFractureImport, fracture ) // Instead of checking each rank on its own, // we check that all the data is present across the ranks. auto const sum = []( auto i ) // Alias + { return MpiWrapper::sum( i ); }; - // Volumic mesh validations - ASSERT_EQ( sum( cellBlockManager.numNodes() ), 16 ); - ASSERT_EQ( sum( cellBlockManager.numEdges() ), 24 ); - ASSERT_EQ( sum( cellBlockManager.numFaces() ), 12 ); + // Volumic mesh validations - 3 hexahedra with 24 points + // Points are NOT merged even though some are at same coordinates + // because they have different global IDs (4-7 vs 8-11) + ASSERT_EQ( sum( cellBlockManager.numNodes() ), 24 ); + // Edges and faces will be different too - just check they exist + ASSERT_GT( sum( cellBlockManager.numEdges() ), 0 ); + ASSERT_GT( sum( cellBlockManager.numFaces() ), 0 ); // Fracture mesh validations ASSERT_EQ( sum( cellBlockManager.getFaceBlocks().numSubGroups() ), MpiWrapper::commSize() ); FaceBlockABC const & faceBlock = cellBlockManager.getFaceBlocks().getGroup< FaceBlockABC >( 0 ); ASSERT_EQ( sum( faceBlock.num2dElements() ), 1 ); ASSERT_EQ( sum( faceBlock.num2dFaces() ), 4 ); + auto ecn = faceBlock.get2dElemsToCollocatedNodesBuckets(); auto const num2dElems = ecn.size(); ASSERT_EQ( sum( num2dElems ), 1 ); + auto numNodesInFrac = 0; for( int ei = 0; ei < num2dElems; ++ei ) { numNodesInFrac += ecn[ei].size(); } ASSERT_EQ( sum( numNodesInFrac ), 4 ); + for( int ei = 0; ei < num2dElems; ++ei ) { for( int ni = 0; ni < numNodesInFrac; ++ni ) @@ -327,7 +357,6 @@ TEST_F( TestFractureImport, fracture ) TestMeshImport( m_vtkFile, validate, "fracture" ); } - TEST( VTKImport, cube ) { auto validate = []( CellBlockManagerABC const & cellBlockManager ) -> void diff --git a/src/coreComponents/mesh/CMakeLists.txt b/src/coreComponents/mesh/CMakeLists.txt index 3b7e7a825cb..65db05207f1 100644 --- a/src/coreComponents/mesh/CMakeLists.txt +++ b/src/coreComponents/mesh/CMakeLists.txt @@ -215,6 +215,7 @@ if( ENABLE_VTK ) generators/VTKMeshGenerator.hpp generators/VTKMeshGeneratorTools.hpp generators/VTKWellGenerator.hpp + generators/VTKSuperCellPartitioning.hpp generators/VTKUtilities.hpp ) set( mesh_sources ${mesh_sources} @@ -224,6 +225,7 @@ if( ENABLE_VTK ) generators/VTKMeshGenerator.cpp generators/VTKMeshGeneratorTools.cpp generators/VTKWellGenerator.cpp + generators/VTKSuperCellPartitioning.cpp generators/VTKUtilities.cpp ) list( APPEND tplDependencyList VTK::IOLegacy VTK::FiltersParallelDIY2 ) diff --git a/src/coreComponents/mesh/generators/CollocatedNodes.cpp b/src/coreComponents/mesh/generators/CollocatedNodes.cpp index 72b8e218102..a026b515f30 100644 --- a/src/coreComponents/mesh/generators/CollocatedNodes.cpp +++ b/src/coreComponents/mesh/generators/CollocatedNodes.cpp @@ -24,29 +24,35 @@ namespace geos::vtk { CollocatedNodes::CollocatedNodes( string const & faceBlockName, - vtkSmartPointer< vtkDataSet > faceMesh ) + vtkSmartPointer< vtkDataSet > faceMesh, + bool performGlobalCheck ) { // The vtk field to the collocated nodes for fractures. string const COLLOCATED_NODES = "collocated_nodes"; vtkIdTypeArray const * collocatedNodes = vtkIdTypeArray::FastDownCast( faceMesh->GetPointData()->GetArray( COLLOCATED_NODES.c_str() ) ); - // Depending on the parallel split, the vtk face mesh may be empty on a rank. - // In that case, vtk will not provide any field for the emtpy mesh. - // Therefore, not finding the duplicated nodes field on a rank cannot be interpreted as a globally missing field. - // Converting the address into an integer and exchanging it through the MPI ranks let us find out - // if the field is globally missing or not. - std::uintptr_t const address = MpiWrapper::max( reinterpret_cast< std::uintptr_t >(collocatedNodes) ); - if( address == 0 ) + // With performGlobalCheck, a NULL on the local rank is OK if any other rank found the field + // (vtk does not provide fields for empty meshes). Otherwise we require it on every rank. + // After MPI max a non-zero result means the field exists on at + // least one rank, so the field is not globally missing. + bool const isMissing = performGlobalCheck + ? ( MpiWrapper::max( reinterpret_cast< std::uintptr_t >( collocatedNodes ) ) == 0 ) + : ( collocatedNodes == nullptr ); + + if( isMissing ) { - GEOS_LOG_RANK_0( "Available point data fields in '" << faceBlockName << "':" ); + GEOS_LOG_RANK_0( GEOS_FMT( "Available point data fields in '{}':", faceBlockName ) ); for( int i = 0; i < faceMesh->GetPointData()->GetNumberOfArrays(); ++i ) { - GEOS_LOG_RANK_0( " - " << faceMesh->GetPointData()->GetArrayName( i ) << " of type '" << faceMesh->GetPointData()->GetArray( i )->GetDataTypeAsString() << "'" ); + GEOS_LOG_RANK_0( GEOS_FMT( " - {} of type '{}'", + faceMesh->GetPointData()->GetArrayName( i ), + faceMesh->GetPointData()->GetArray( i )->GetDataTypeAsString() ) ); } - GEOS_ERROR( GEOS_FMT( "Could not find valid field \"{}\" for fracture \"{}\".", + GEOS_ERROR( GEOS_FMT( "Could not find valid field \"{}\" for fracture \"{}\"{}.", COLLOCATED_NODES, - faceBlockName ) ); + faceBlockName, + performGlobalCheck ? "" : " on this rank" ) ); } if( collocatedNodes ) diff --git a/src/coreComponents/mesh/generators/CollocatedNodes.hpp b/src/coreComponents/mesh/generators/CollocatedNodes.hpp index 98142dae589..114c6d9c5f9 100644 --- a/src/coreComponents/mesh/generators/CollocatedNodes.hpp +++ b/src/coreComponents/mesh/generators/CollocatedNodes.hpp @@ -35,9 +35,12 @@ class CollocatedNodes * @brief Build a convenience wrapper around the raw vtk collocated nodes information. * @param faceBlockName The face block name. * @param faceMesh The face mesh for which the collocated nodes structure will be fed. + * @param performGlobalCheck Whether to check across all MPI ranks if field is missing (default: true). + * Set to false when only calling on a subset of ranks. */ CollocatedNodes( string const & faceBlockName, - vtkSmartPointer< vtkDataSet > faceMesh ); + vtkSmartPointer< vtkDataSet > faceMesh, + bool performGlobalCheck = true ); /** * @brief For node @p i of the face block, returns all the duplicated global node indices in the main 3d mesh. diff --git a/src/coreComponents/mesh/generators/ParMETISInterface.cpp b/src/coreComponents/mesh/generators/ParMETISInterface.cpp index 0152dad83f3..e1f38e0a852 100644 --- a/src/coreComponents/mesh/generators/ParMETISInterface.cpp +++ b/src/coreComponents/mesh/generators/ParMETISInterface.cpp @@ -97,6 +97,8 @@ partition( ArrayOfArraysView< idx_t const, idx_t > const & graph, MPI_Comm comm, int const numRefinements ) { + GEOS_ERROR_IF( numParts <= 0, "Number of partitions must be strictly positive" ); + array1d< idx_t > part( graph.size() ); // all 0 by default if( numParts == 1 ) { @@ -147,5 +149,61 @@ partition( ArrayOfArraysView< idx_t const, idx_t > const & graph, return part; } +array1d< idx_t > +partitionWeighted( ArrayOfArraysView< idx_t const, idx_t > const & graph, + arrayView1d< idx_t const > const & vertexWeights, + arrayView1d< idx_t const > const & vertDist, + idx_t const numParts, + MPI_Comm comm, + int const numRefinements ) +{ + GEOS_ERROR_IF( numParts <= 0, "Number of partitions must be strictly positive" ); + + array1d< idx_t > part( graph.size() ); + if( numParts == 1 ) + { + return part; + } + + array1d< real_t > tpwgts( numParts ); + tpwgts.setValues< serialPolicy >( 1.0f / static_cast< real_t >( numParts ) ); + + idx_t wgtflag = 2; // vertex weights only + idx_t numflag = 0; + idx_t ncon = 1; + idx_t npart = numParts; + + // Options: [use_defaults, log_level, seed, coupling] + idx_t options[4] = { 1, 0, 2022, PARMETIS_PSR_UNCOUPLED }; + + idx_t edgecut = 0; + real_t ubvec = 1.05; + + GEOS_PARMETIS_CHECK( ParMETIS_V3_PartKway( + const_cast< idx_t * >( vertDist.data() ), + const_cast< idx_t * >( graph.getOffsets() ), + const_cast< idx_t * >( graph.getValues() ), + const_cast< idx_t * >( vertexWeights.data() ), + nullptr, // edge weights + &wgtflag, + &numflag, &ncon, &npart, tpwgts.data(), + &ubvec, options, &edgecut, part.data(), &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() ), + const_cast< idx_t * >( vertexWeights.data() ), + nullptr, + &wgtflag, + &numflag, &ncon, &npart, tpwgts.data(), + &ubvec, options, &edgecut, part.data(), &comm ) ); + } + + return part; +} + } // namespace parmetis } // namespace geos diff --git a/src/coreComponents/mesh/generators/ParMETISInterface.hpp b/src/coreComponents/mesh/generators/ParMETISInterface.hpp index 8e948f762e1..b4cc93b5087 100644 --- a/src/coreComponents/mesh/generators/ParMETISInterface.hpp +++ b/src/coreComponents/mesh/generators/ParMETISInterface.hpp @@ -65,6 +65,23 @@ partition( ArrayOfArraysView< pmet_idx_t const, pmet_idx_t > const & graph, MPI_Comm comm, int const numRefinements ); +/** + * @brief Partition a graph with vertex weights + * @param graph The adjacency graph + * @param vertexWeights The vertex weights for load balancing + * @param vertDist The element distribution + * @param numParts The number of partitions + * @param comm The MPI communicator + * @param numRefinements Number of refinement passes + * @return Partition assignment for each vertex + */ +array1d< pmet_idx_t > +partitionWeighted( ArrayOfArraysView< pmet_idx_t const, pmet_idx_t > const & graph, + arrayView1d< pmet_idx_t const > const & vertexWeights, + arrayView1d< pmet_idx_t const > const & vertDist, + pmet_idx_t const numParts, + MPI_Comm comm, + int const numRefinements ); } // namespace parmetis } // namespace geos diff --git a/src/coreComponents/mesh/generators/VTKFaceBlockUtilities.cpp b/src/coreComponents/mesh/generators/VTKFaceBlockUtilities.cpp index 46eff42dfd2..21f0d17fafe 100644 --- a/src/coreComponents/mesh/generators/VTKFaceBlockUtilities.cpp +++ b/src/coreComponents/mesh/generators/VTKFaceBlockUtilities.cpp @@ -451,7 +451,7 @@ Elem2dTo3dInfo buildElem2dTo3dElemAndFaces( vtkSmartPointer< vtkDataSet > faceMe stdMap< vtkIdType, localIndex > ng2l; // global to local mapping for nodes. for( vtkIdType i = 0; i < globalPtIds->GetNumberOfValues(); ++i ) { - ng2l.insert( { globalPtIds->GetValue( i ), i} ); + ng2l.emplace( globalPtIds->GetValue( i ), i ); } // Let's build the elem2d to elem3d mapping. @@ -491,7 +491,7 @@ Elem2dTo3dInfo buildElem2dTo3dElemAndFaces( vtkSmartPointer< vtkDataSet > faceMe { stdVector< vtkIdType > const & tmp = it->second; std::set< vtkIdType > const cells{ tmp.cbegin(), tmp.cend() }; - nodesToCells.insert( {n, cells} ); + nodesToCells.emplace( n, cells ); } } } @@ -508,8 +508,14 @@ Elem2dTo3dInfo buildElem2dTo3dElemAndFaces( vtkSmartPointer< vtkDataSet > faceMe { // We collect all the duplicated points that are involved for each 2d element. vtkIdList * pointIds = faceMesh->GetCell( e2d )->GetPointIds(); - std::size_t const elem2dNumPoints = pointIds->GetNumberOfIds(); - // All the duplicated points of the 2d element. Note that we lose the collocation of the duplicated nodes. + + // Use the common matching function to find candidate 3D cells + stdVector< vtkIdType > matchingCells = vtk::findMatchingCellsForFractureElement( + pointIds, + collocatedNodes, + nodesToCells ); + + // Collect all duplicated nodes for this 2D element (needed for elem2dToNodes) std::set< vtkIdType > duplicatedPointOfElem2d; for( vtkIdType j = 0; j < pointIds->GetNumberOfIds(); ++j ) { @@ -517,6 +523,7 @@ Elem2dTo3dInfo buildElem2dTo3dElemAndFaces( vtkSmartPointer< vtkDataSet > faceMe duplicatedPointOfElem2d.insert( ns.cbegin(), ns.cend() ); } + // Build elem2dToNodes mapping for( vtkIdType const & gni: duplicatedPointOfElem2d ) { auto it = ng2l.find( gni ); @@ -532,42 +539,41 @@ Elem2dTo3dInfo buildElem2dTo3dElemAndFaces( vtkSmartPointer< vtkDataSet > faceMe } } - // Here, we collect all the 3d elements that are concerned by at least one of those duplicated elements. - stdMap< vtkIdType, std::set< vtkIdType > > elem3dToDuplicatedNodes; - for( vtkIdType const & n: duplicatedPointOfElem2d ) + // Process each matching 3D cell + for( vtkIdType const & cellGlobalId : matchingCells ) { - auto const ncs = nodesToCells.find( n ); - if( ncs != nodesToCells.cend() ) + elem2dToElem3d.emplaceBack( e2d, elemToFaces.getElementIndexInCellBlock( cellGlobalId ) ); + + // Find which face matches + auto faces = elemToFaces[cellGlobalId]; + for( int j = 0; j < faces.size( 0 ); ++j ) { - for( vtkIdType const & c: ncs->second ) + localIndex const faceIndex = faces[j]; + auto nodes = faceToNodes[faceIndex]; + std::set< vtkIdType > globalNodes; + for( auto const & n: nodes ) { - elem3dToDuplicatedNodes.get_inserted( c ).insert( n ); + globalNodes.insert( globalPtIds->GetValue( n ) ); } - } - } - // Last we extract which of those candidate 3d elements are the ones actually neighboring the 2d element. - for( auto const & e2n: elem3dToDuplicatedNodes ) - { - // If the face of the element 3d has the same number of nodes than the elem 2d, it should be a successful (the mesh is conformal). - if( e2n.second.size() == elem2dNumPoints ) - { - // Now we know that the element 3d has a face that touches the element 2d. Let's find which one. - elem2dToElem3d.emplaceBack( e2d, elemToFaces.getElementIndexInCellBlock( e2n.first ) ); - // Computing the elem2dToFaces mapping. - auto faces = elemToFaces[e2n.first]; - for( int j = 0; j < faces.size( 0 ); ++j ) + + // Check if face nodes are a subset of duplicated nodes + // Face should have same number of nodes as the fracture element + if( globalNodes.size() == static_cast< std::size_t >(pointIds->GetNumberOfIds()) ) { - localIndex const faceIndex = faces[j]; - auto nodes = faceToNodes[faceIndex]; - std::set< vtkIdType > globalNodes; - for( auto const & n: nodes ) + bool faceMatch = true; + for( vtkIdType gn : globalNodes ) { - globalNodes.insert( globalPtIds->GetValue( n ) ); + if( duplicatedPointOfElem2d.find( gn ) == duplicatedPointOfElem2d.end() ) + { + faceMatch = false; + break; + } } - if( globalNodes == e2n.second ) + + if( faceMatch ) { elem2dToFaces.emplaceBack( e2d, faceIndex ); - elem2dToCellBlock.emplaceBack( e2d, elemToFaces.getCellBlockIndex( e2n.first ) ); + elem2dToCellBlock.emplaceBack( e2d, elemToFaces.getCellBlockIndex( cellGlobalId ) ); break; } } @@ -598,7 +604,12 @@ array1d< globalIndex > buildLocalToGlobal( vtkIdTypeArray const * faceMeshCellGl // In order to avoid any cell global id collision, we gather the max cell global id over all the ranks. // Then we use this maximum as on offset. // TODO This does not take into account multiple fractures. - vtkIdType const maxLocalCellId = meshCellGlobalIds->GetMaxId(); + vtkIdType maxLocalCellId = 0; + for( vtkIdType i = 0; i < meshCellGlobalIds->GetNumberOfTuples(); ++i ) + { + maxLocalCellId = std::max( maxLocalCellId, + static_cast< vtkIdType >(meshCellGlobalIds->GetValue( i )) ); + } vtkIdType const maxGlobalCellId = MpiWrapper::max( maxLocalCellId ); vtkIdType const cellGlobalOffset = maxGlobalCellId + 1; diff --git a/src/coreComponents/mesh/generators/VTKMeshGenerator.cpp b/src/coreComponents/mesh/generators/VTKMeshGenerator.cpp index b90bd1651e7..4a881414782 100644 --- a/src/coreComponents/mesh/generators/VTKMeshGenerator.cpp +++ b/src/coreComponents/mesh/generators/VTKMeshGenerator.cpp @@ -82,6 +82,10 @@ VTKMeshGenerator::VTKMeshGenerator( string const & name, setInputFlag( InputFlags::OPTIONAL ). setDescription( "Method (library) used to partition the mesh" ); + registerWrapper( viewKeyStruct::partitionFractureWeightString(), &m_partitionFractureWeight ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Additional weight to fracture-connected super-cells during partitioning" ); + registerWrapper( viewKeyStruct::useGlobalIdsString(), &m_useGlobalIds ). setInputFlag( InputFlags::OPTIONAL ). setApplyDefaultValue( 0 ). @@ -208,6 +212,7 @@ void VTKMeshGenerator::fillCellBlockManager( CellBlockManager & cellBlockManager comm, m_partitionMethod, m_partitionRefinement, + m_partitionFractureWeight, m_useGlobalIds, m_structuredIndexAttributeName, numPartZ ); diff --git a/src/coreComponents/mesh/generators/VTKMeshGenerator.hpp b/src/coreComponents/mesh/generators/VTKMeshGenerator.hpp index cd968c2abd4..e31ada4bb1e 100644 --- a/src/coreComponents/mesh/generators/VTKMeshGenerator.hpp +++ b/src/coreComponents/mesh/generators/VTKMeshGenerator.hpp @@ -114,6 +114,7 @@ class VTKMeshGenerator : public ExternalMeshGeneratorBase constexpr static char const * nodesetNamesString() { return "nodesetNames"; } constexpr static char const * partitionRefinementString() { return "partitionRefinement"; } constexpr static char const * partitionMethodString() { return "partitionMethod"; } + constexpr static char const * partitionFractureWeightString() { return "partitionFractureWeight"; } constexpr static char const * useGlobalIdsString() { return "useGlobalIds"; } constexpr static char const * dataSourceString() { return "dataSourceName"; } }; @@ -161,6 +162,9 @@ class VTKMeshGenerator : public ExternalMeshGeneratorBase /// Number of graph partitioning refinement iterations integer m_partitionRefinement = 0; + /// Additional weight to fracture-connected super-cells during partitioning + integer m_partitionFractureWeight = 0; + /// Whether global id arrays should be used, if available integer m_useGlobalIds = 0; diff --git a/src/coreComponents/mesh/generators/VTKSuperCellPartitioning.cpp b/src/coreComponents/mesh/generators/VTKSuperCellPartitioning.cpp new file mode 100644 index 00000000000..679cdc95f11 --- /dev/null +++ b/src/coreComponents/mesh/generators/VTKSuperCellPartitioning.cpp @@ -0,0 +1,1035 @@ +/** + * ------------------------------------------------------------------------------------------------------------ + * 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 "VTKSuperCellPartitioning.hpp" + +// GEOS mesh includes +#include "mesh/generators/VTKMeshGeneratorTools.hpp" + +// GEOS common includes +#include "common/MpiWrapper.hpp" +#include "common/DataTypes.hpp" +#include "common/format/StringUtilities.hpp" + +// LvArray +#include "LvArray/src/ArrayOfArrays.hpp" + +// VTK includes +#include +#include +#include +#include +#include +#include + +#include + + +namespace geos +{ + +namespace vtk +{ + +// ============================================================================================= +// SECTION 1: SUPER-CELL IDENTIFICATION (rank 0 only) +// ============================================================================================= +pmet_idx_t computeSuperCellWeight( vtkIdType numCells, integer fractureWeight ) +{ + if( numCells > 1 ) + { + return numCells + fractureWeight; // Fracture super-cell + } + else + { + return numCells; // Regular cell + } +} + +SuperCellInfo tagCellsWithSuperCellIds( + vtkSmartPointer< vtkUnstructuredGrid > cells3D, + stdMap< string, ArrayOfArrays< localIndex, int64_t > > const & fractureNeighbors, + + integer fractureWeight ) +{ + vtkIdType const numLocalCells = cells3D->GetNumberOfCells(); + + vtkIdTypeArray * globalIds = + vtkIdTypeArray::SafeDownCast( cells3D->GetCellData()->GetGlobalIds() ); + + GEOS_ERROR_IF( !globalIds, "3D mesh missing global IDs" ); + + // ----------------------------------------------------------------------- + // Step 1: Build 3D cell connectivity graph via fractures + // ----------------------------------------------------------------------- + stdMap< vtkIdType, std::set< vtkIdType > > fractureGraph; + vtkIdType totalFractureElements = 0; + + for( auto const & [fractureName, neighbors] : fractureNeighbors ) + { + totalFractureElements += static_cast< vtkIdType >( neighbors.size() ); + + for( vtkIdType i = 0; i < neighbors.size(); ++i ) + { + auto neighborList = neighbors[i]; + + GEOS_ERROR_IF( neighborList.size() != 2, + GEOS_FMT( "Fracture '{}' element {} has {} 3D neighbors (expected exactly 2). ", + fractureName, i, neighborList.size() ) ); + + vtkIdType gidA = neighborList[0]; + vtkIdType gidB = neighborList[1]; + + fractureGraph.get_inserted( gidA ).insert( gidB ); + fractureGraph.get_inserted( gidB ).insert( gidA ); + } + } + + GEOS_LOG_RANK_0( GEOS_FMT( "Built fracture graph: {} 3D cells connected via {} fracture elements", + fractureGraph.size(), totalFractureElements ) ); + + // ----------------------------------------------------------------------- + // Step 2: Find the maximum global ID from ALL cells (not just fracture cells) + // ----------------------------------------------------------------------- + vtkIdType const maxGlobalId = numLocalCells > 0 + ? globalIds->GetValueRange( 0 )[1] + : 0; + + // ----------------------------------------------------------------------- + // Step 3: Find connected components using DFS + // ----------------------------------------------------------------------- + stdMap< vtkIdType, vtkIdType > cellToSuperCell; + std::set< vtkIdType > visited; + + // Start super-cell IDs AFTER the maximum global ID to avoid collisions + vtkIdType nextSuperCellId = maxGlobalId + 1; + + std::function< void(vtkIdType, vtkIdType, stdVector< vtkIdType > &) > dfs = + [&]( vtkIdType cell, vtkIdType superCellId, stdVector< vtkIdType > & component ) + { + if( visited.count( cell ) ) + return; + visited.insert( cell ); + cellToSuperCell.try_emplace( cell, superCellId ); + component.push_back( cell ); + + // Recursively visit all neighbors + if( fractureGraph.count( cell ) ) + { + for( vtkIdType neighbor : fractureGraph.at( cell ) ) + { + dfs( neighbor, superCellId, component ); + } + } + }; + + stdMap< vtkIdType, stdVector< vtkIdType > > superCellComponents; + + for( auto const & [cell, neighbors] : fractureGraph ) + { + if( !visited.count( cell ) ) + { + stdVector< vtkIdType > component; + dfs( cell, nextSuperCellId, component ); + + superCellComponents.try_emplace( nextSuperCellId, component ); + nextSuperCellId++; + } + } + + // ----------------------------------------------------------------------- + // Step 4: Build SuperCellInfo + // ----------------------------------------------------------------------- + SuperCellInfo info; + + vtkIdType numSuperCellsCreated = 0; + vtkIdType largestSuperCellSize = 0; + + for( auto const & [scId, members] : superCellComponents ) + { + info.superCellToOriginalCells.try_emplace( scId, members ); + info.vertexWeights.try_emplace( scId, computeSuperCellWeight( members.size(), fractureWeight ) ); + + if( members.size() > 1 ) + { + // Mark as atomic super-cell (cannot be split during partitioning) + info.atomicSuperCells.insert( scId ); + } + + numSuperCellsCreated++; + largestSuperCellSize = std::max( largestSuperCellSize, + static_cast< vtkIdType >( members.size() ) ); + } + + // ----------------------------------------------------------------------- + // Step 5: Tag cells with SuperCellIds + // ----------------------------------------------------------------------- + vtkNew< vtkIdTypeArray > superCellIdArray; + superCellIdArray->SetName( "SuperCellId" ); + superCellIdArray->SetNumberOfTuples( numLocalCells ); + + for( vtkIdType i = 0; i < numLocalCells; ++i ) + { + vtkIdType globalId = globalIds->GetValue( i ); + + if( cellToSuperCell.count( globalId ) ) + { + // Cell is part of a fracture-connected super-cell + superCellIdArray->SetValue( i, cellToSuperCell.at( globalId ) ); + } + else + { + // Regular cell - use its own global ID as super-cell ID + // This is safe because super-cell IDs start at maxGlobalId + 1 + superCellIdArray->SetValue( i, globalId ); + } + } + + cells3D->GetCellData()->AddArray( superCellIdArray ); + + // ----------------------------------------------------------------------- + // Step 6: Report statistics + // ----------------------------------------------------------------------- + GEOS_LOG_RANK_0( GEOS_FMT( "Super-cells: {} created (largest: {} cells)", + numSuperCellsCreated, largestSuperCellSize ) ); + + return info; +} + + +// ============================================================================================= +// SECTION 2: SUPER-CELL RECONSTRUCTION (after redistribution) +// ============================================================================================= +SuperCellInfo reconstructSuperCellInfo( vtkSmartPointer< vtkUnstructuredGrid > mesh, integer fractureWeight ) +{ + SuperCellInfo info; + + vtkIdTypeArray * superCellIdArray = + vtkIdTypeArray::SafeDownCast( mesh->GetCellData()->GetArray( "SuperCellId" ) ); + + if( !superCellIdArray ) + { + return info; // No super-cells, return empty info + } + + vtkIdTypeArray * globalIds = + vtkIdTypeArray::SafeDownCast( mesh->GetCellData()->GetGlobalIds() ); + + GEOS_ERROR_IF( !globalIds, "Mesh missing global IDs" ); + + // Build map: super-cell ID -> vector of cell global IDs + stdMap< vtkIdType, stdVector< vtkIdType > > localSuperCells; + + for( vtkIdType i = 0; i < mesh->GetNumberOfCells(); ++i ) + { + vtkIdType scId = superCellIdArray->GetValue( i ); + vtkIdType globalId = globalIds->GetValue( i ); + localSuperCells.get_inserted( scId ).push_back( globalId ); + } + + for( auto const & [scId, cells] : localSuperCells ) + { + info.superCellToOriginalCells.try_emplace( scId, cells ); + info.vertexWeights.try_emplace( scId, computeSuperCellWeight( cells.size(), fractureWeight ) ); + + if( cells.size() > 1 ) + { + info.atomicSuperCells.insert( scId ); + } + } + + return info; +} + + +// ============================================================================================= +// SECTION 3: INITIAL REDISTRIBUTION +// ============================================================================================= +vtkSmartPointer< vtkDataSet > +redistributeBySuperCellBlocks( vtkSmartPointer< vtkUnstructuredGrid > cells3D, + MPI_Comm comm, + InitialDistributionStrategy strategy ) +{ + GEOS_MARK_FUNCTION; + + int const rank = MpiWrapper::commRank( comm ); + int const numRanks = MpiWrapper::commSize( comm ); + + vtkSmartPointer< vtkPartitionedDataSet > partitionedMesh = + vtkSmartPointer< vtkPartitionedDataSet >::New(); + + if( rank == 0 ) + { + vtkIdTypeArray * superCellIdArray = + vtkIdTypeArray::SafeDownCast( cells3D->GetCellData()->GetArray( "SuperCellId" ) ); + + GEOS_ERROR_IF( !superCellIdArray, "SuperCellId array not found" ); + + vtkIdType const numCells = cells3D->GetNumberOfCells(); + + // Build super-cell metadata + stdMap< vtkIdType, stdVector< vtkIdType > > superCellToLocalCells; + + for( vtkIdType i = 0; i < numCells; ++i ) + { + vtkIdType scId = superCellIdArray->GetValue( i ); + superCellToLocalCells.get_inserted( scId ).push_back( i ); + } + vtkIdType numSuperCells = superCellToLocalCells.size(); + + GEOS_LOG_RANK_0( GEOS_FMT( "Initial distribution: {} super-cells across {} ranks ({} ordering)", + numSuperCells, numRanks, + (strategy == InitialDistributionStrategy::MORTON ? "MORTON" : "BLOCK") ) ); + + // ----------------------------------------------------------------------- + // Step 1: Build super-cell list and optionally sort by spatial locality + // ----------------------------------------------------------------------- + struct SuperCellDistributionInfo + { + vtkIdType scId; + stdVector< vtkIdType > cellIndices; + stdArray< double, 3 > centroid; // Only computed for Morton strategy + }; + + stdVector< SuperCellDistributionInfo > superCells; + superCells.reserve( numSuperCells ); + + if( strategy == InitialDistributionStrategy::MORTON ) + { + vtkPoints * meshPoints = cells3D->GetPoints(); + + // Compute super-cell centroids directly + for( auto const & [scId, cellIndices] : superCellToLocalCells ) + { + stdArray< double, 3 > centroid = {0.0, 0.0, 0.0}; + vtkIdType totalPoints = 0; + + // Accumulate all points from all cells in this super-cell + for( vtkIdType cellIdx : cellIndices ) + { + vtkIdType npts; + const vtkIdType * pts; + cells3D->GetCellPoints( cellIdx, npts, pts ); + + for( vtkIdType i = 0; i < npts; ++i ) + { + double pt[3]; + meshPoints->GetPoint( pts[i], pt ); + centroid[0] += pt[0]; + centroid[1] += pt[1]; + centroid[2] += pt[2]; + } + totalPoints += npts; + } + + // Average over all points + centroid[0] /= totalPoints; + centroid[1] /= totalPoints; + centroid[2] /= totalPoints; + + superCells.push_back( SuperCellDistributionInfo{ scId, cellIndices, centroid } ); + } + + // Find bounding box + double minCoord[3] = {std::numeric_limits< double >::max(), + std::numeric_limits< double >::max(), + std::numeric_limits< double >::max()}; + double maxCoord[3] = {std::numeric_limits< double >::lowest(), + std::numeric_limits< double >::lowest(), + std::numeric_limits< double >::lowest()}; + + for( auto const & sc : superCells ) + { + for( int d = 0; d < 3; ++d ) + { + minCoord[d] = std::min( minCoord[d], sc.centroid[d] ); + maxCoord[d] = std::max( maxCoord[d], sc.centroid[d] ); + } + } + + // Morton encoding + auto computeMorton = []( stdArray< double, 3 > const & centroid, + double bounds_min[3], + double bounds_max[3] ) -> uint64_t + { + auto normalize = [&]( double val, int dim ) -> uint32_t + { + double range = bounds_max[dim] - bounds_min[dim]; + if( range < 1e-10 ) + return 0; + double norm = (val - bounds_min[dim]) / range; + norm = std::max( 0.0, std::min( 1.0, norm ) ); + return static_cast< uint32_t >( norm * ((1u << 21) - 1) ); + }; + + uint32_t x = normalize( centroid[0], 0 ); + uint32_t y = normalize( centroid[1], 1 ); + uint32_t z = normalize( centroid[2], 2 ); + + uint64_t code = 0; + for( int i = 0; i < 21; ++i ) + { + code |= ((x & (1u << i)) ? (1ull << (3*i)) : 0); + code |= ((y & (1u << i)) ? (1ull << (3*i + 1)) : 0); + code |= ((z & (1u << i)) ? (1ull << (3*i + 2)) : 0); + } + return code; + }; + + // Sort by Morton code + std::sort( superCells.begin(), superCells.end(), + [&]( SuperCellDistributionInfo const & a, SuperCellDistributionInfo const & b ) + { + return computeMorton( a.centroid, minCoord, maxCoord ) < + computeMorton( b.centroid, minCoord, maxCoord ); + } ); + + } + else + { + // BLOCK: Simple ordering by super-cell ID (no centroid computation needed) + for( auto const & [scId, cellIndices] : superCellToLocalCells ) + { + superCells.push_back( SuperCellDistributionInfo{ scId, cellIndices, {0.0, 0.0, 0.0} } ); + } + + // Sort by super-cell ID for deterministic partitioning + std::sort( superCells.begin(), superCells.end(), + []( SuperCellDistributionInfo const & a, SuperCellDistributionInfo const & b ) + { + return a.scId < b.scId; + } ); + } + + // ----------------------------------------------------------------------- + // Step 2: Assign super-cells to ranks in contiguous blocks + // ----------------------------------------------------------------------- + array1d< int64_t > cellPartitions( numCells ); + stdVector< vtkIdType > cellsPerRank( numRanks, 0 ); + + vtkIdType superCellsPerRank = (numSuperCells + numRanks - 1) / numRanks; + + for( vtkIdType scIdx = 0; scIdx < numSuperCells; ++scIdx ) + { + int targetRank = std::min( static_cast< int >(scIdx / superCellsPerRank), numRanks - 1 ); + + // All cells in this super-cell go to the same rank + for( vtkIdType cellIdx : superCells[scIdx].cellIndices ) + { + cellPartitions[cellIdx] = targetRank; + cellsPerRank[targetRank]++; + } + } + + // ----------------------------------------------------------------------- + // Step 3: Build partitions + // ----------------------------------------------------------------------- + partitionedMesh->SetNumberOfPartitions( numRanks ); + + for( int r = 0; r < numRanks; ++r ) + { + vtkNew< vtkIdList > cellsForRank; + + for( vtkIdType i = 0; i < numCells; ++i ) + { + if( cellPartitions[i] == r ) + { + cellsForRank->InsertNextId( i ); + } + } + + if( cellsForRank->GetNumberOfIds() == 0 ) + { + vtkNew< vtkUnstructuredGrid > emptyPart; + partitionedMesh->SetPartition( r, emptyPart ); + continue; + } + + vtkNew< vtkExtractCells > extractor; + extractor->SetInputData( cells3D ); + extractor->SetCellList( cellsForRank ); + extractor->Update(); + + vtkSmartPointer< vtkUnstructuredGrid > partition = + vtkUnstructuredGrid::SafeDownCast( extractor->GetOutput() ); + + partitionedMesh->SetPartition( r, partition ); + } + } + else + { + // Other ranks: create empty partitioned dataset + partitionedMesh->SetNumberOfPartitions( numRanks ); + for( int r = 0; r < numRanks; ++r ) + { + vtkNew< vtkUnstructuredGrid > emptyPart; + partitionedMesh->SetPartition( r, emptyPart ); + } + } + + // ----------------------------------------------------------------------- + // Step 4: Redistribute using VTK + // ----------------------------------------------------------------------- + vtkSmartPointer< vtkDataSet > result = vtk::redistribute( *partitionedMesh, comm ); + + partitionedMesh = nullptr; + if( rank == 0 ) + { + cells3D = nullptr; + } + + vtkIdType localCells = result->GetNumberOfCells(); + + // Verify SuperCellId array survived redistribution + if( localCells > 0 ) + { + vtkIdTypeArray * resultSuperCellIdArray = + vtkIdTypeArray::SafeDownCast( result->GetCellData()->GetArray( "SuperCellId" ) ); + + GEOS_ERROR_IF( !resultSuperCellIdArray, + GEOS_FMT( "Rank {}: SuperCellId array lost during redistribution", rank ) ); + } + + return result; +} + + +// ============================================================================================= +// SECTION 4: SUPER-CELL GRAPH BUILDING +// ============================================================================================= +std::pair< ArrayOfArrays< pmet_idx_t, pmet_idx_t >, array1d< pmet_idx_t > > +buildSuperCellGraph( + vtkSmartPointer< vtkUnstructuredGrid > cells3D, + ArrayOfArrays< pmet_idx_t, pmet_idx_t > const & baseGraph, + arrayView1d< pmet_idx_t const > const & baseElemDist, + SuperCellInfo const & info, + MPI_Comm comm ) +{ + int const rank = MpiWrapper::commRank( comm ); + int const numRanks = MpiWrapper::commSize( comm ); + + vtkIdTypeArray * superCellIdArray = + vtkIdTypeArray::SafeDownCast( cells3D->GetCellData()->GetArray( "SuperCellId" ) ); + GEOS_ERROR_IF( superCellIdArray == nullptr, "SuperCellId array not found" ); + + vtkIdTypeArray * cellGlobalIds = + vtkIdTypeArray::SafeDownCast( cells3D->GetCellData()->GetGlobalIds() ); + GEOS_ERROR_IF( cellGlobalIds == nullptr, "Cell global IDs not found" ); + + vtkIdType numLocalCells = cells3D->GetNumberOfCells(); + + stdMap< vtkIdType, stdVector< vtkIdType > > superCellToLocalCells; + for( vtkIdType i = 0; i < numLocalCells; ++i ) + { + vtkIdType superCellId = superCellIdArray->GetValue( i ); + superCellToLocalCells.get_inserted( superCellId ).push_back( i ); + } + + localIndex numLocalSuperCells = superCellToLocalCells.size(); + + // Build super-cell global index distribution across ranks + array1d< pmet_idx_t > superElemDist( numRanks + 1 ); + pmet_idx_t localSuperCellCount = numLocalSuperCells; + MpiWrapper::allgather( &localSuperCellCount, 1, superElemDist.data(), 1, comm ); + + pmet_idx_t temp = superElemDist[0]; + superElemDist[0] = 0; + for( int r = 1; r <= numRanks; ++r ) + { + pmet_idx_t next = superElemDist[r]; + superElemDist[r] = superElemDist[r-1] + temp; + temp = next; + } + + pmet_idx_t localGlobalStart = superElemDist[rank]; + pmet_idx_t localGlobalEnd = superElemDist[rank + 1]; + + stdVector< vtkIdType > orderedSuperCellIds; + orderedSuperCellIds.reserve( numLocalSuperCells ); + for( auto const & [superCellId, localCells] : superCellToLocalCells ) + { + orderedSuperCellIds.push_back( superCellId ); + } + std::sort( orderedSuperCellIds.begin(), orderedSuperCellIds.end() ); + + stdMap< vtkIdType, pmet_idx_t > superCellIdToGlobalIdx; + for( pmet_idx_t i = 0; i < numLocalSuperCells; ++i ) + { + superCellIdToGlobalIdx.try_emplace( orderedSuperCellIds[i], localGlobalStart + i ); + } + + // ----------------------------------------------------------------------- + // Step 1: Build mappings for exchange + // ----------------------------------------------------------------------- + // Local maps + stdUnorderedMap< pmet_idx_t, vtkIdType > localGlobalCellToSuperCell; + localGlobalCellToSuperCell.reserve( numLocalCells ); + + stdUnorderedMap< pmet_idx_t, vtkIdType > localParmetisToVtk; + localParmetisToVtk.reserve( numLocalCells ); + + pmet_idx_t localParmetisStart = baseElemDist[rank]; + pmet_idx_t localParmetisEnd = baseElemDist[rank + 1]; + + for( vtkIdType i = 0; i < numLocalCells; ++i ) + { + vtkIdType vtkGlobalId = cellGlobalIds->GetValue( i ); + vtkIdType superCellId = superCellIdArray->GetValue( i ); + + localGlobalCellToSuperCell.try_emplace( vtkGlobalId, superCellId ); + localParmetisToVtk.try_emplace( localParmetisStart + i, vtkGlobalId ); + } + + // ----------------------------------------------------------------------- + // Step 2: Identify unique ghost ParMETIS indices + // ----------------------------------------------------------------------- + std::set< pmet_idx_t > ghostParmetisSet; + + for( localIndex i = 0; i < baseGraph.size(); ++i ) + { + auto neighbors = baseGraph[i]; + for( localIndex j = 0; j < neighbors.size(); ++j ) + { + pmet_idx_t nbrIdx = neighbors[j]; + if( nbrIdx < localParmetisStart || nbrIdx >= localParmetisEnd ) + { + ghostParmetisSet.insert( nbrIdx ); + } + } + } + + // ----------------------------------------------------------------------- + // Step 3: Exchange ghost mappings + // ----------------------------------------------------------------------- + // Prepare local data to send + array1d< pmet_idx_t > localParmetisIndices; + array1d< vtkIdType > localVtkIds; + array1d< vtkIdType > localSuperCellIds; + + localParmetisIndices.reserve( numLocalCells ); + localVtkIds.reserve( numLocalCells ); + localSuperCellIds.reserve( numLocalCells ); + + for( vtkIdType i = 0; i < numLocalCells; ++i ) + { + localParmetisIndices.emplace_back( localParmetisStart + i ); + localVtkIds.emplace_back( cellGlobalIds->GetValue( i ) ); + localSuperCellIds.emplace_back( superCellIdArray->GetValue( i ) ); + } + + // Gather all mappings + array1d< pmet_idx_t > allParmetisIndices; + array1d< vtkIdType > allVtkIds; + array1d< vtkIdType > allSuperCellIds; + + MpiWrapper::allGatherv( localParmetisIndices.toViewConst(), allParmetisIndices, comm ); + MpiWrapper::allGatherv( localVtkIds.toViewConst(), allVtkIds, comm ); + MpiWrapper::allGatherv( localSuperCellIds.toViewConst(), allSuperCellIds, comm ); + + // Build lookup tables from gathered data (only for ghosts + local) + stdUnorderedMap< pmet_idx_t, vtkIdType > parmetisToVtk; + stdUnorderedMap< vtkIdType, vtkIdType > vtkToSuperCell; + + parmetisToVtk.reserve( ghostParmetisSet.size() + numLocalCells ); + vtkToSuperCell.reserve( ghostParmetisSet.size() + numLocalCells ); + + for( localIndex i = 0; i < allParmetisIndices.size(); ++i ) + { + pmet_idx_t const parmetisIdx = allParmetisIndices[i]; + + // Only store if it's local or a ghost we need + if( (parmetisIdx >= localParmetisStart && parmetisIdx < localParmetisEnd) || + ghostParmetisSet.count( parmetisIdx ) > 0 ) + { + vtkIdType const vtkId = allVtkIds[i]; + vtkIdType const superCellId = allSuperCellIds[i]; + + parmetisToVtk.try_emplace( parmetisIdx, vtkId ); + vtkToSuperCell.try_emplace( vtkId, superCellId ); + } + } + + // ----------------------------------------------------------------------- + // Step 4: Exchange super-cell global indices + // ----------------------------------------------------------------------- + array1d< vtkIdType > sendSCIds; + array1d< pmet_idx_t > sendSCGlobalIndices; + + sendSCIds.reserve( superCellIdToGlobalIdx.size() ); + sendSCGlobalIndices.reserve( superCellIdToGlobalIdx.size() ); + + for( auto const & [scId, gIdx] : superCellIdToGlobalIdx ) + { + sendSCIds.emplace_back( scId ); + sendSCGlobalIndices.emplace_back( gIdx ); + } + + array1d< vtkIdType > allSCIds; + array1d< pmet_idx_t > allSCGlobalIndices; + + MpiWrapper::allGatherv( sendSCIds.toViewConst(), allSCIds, comm ); + MpiWrapper::allGatherv( sendSCGlobalIndices.toViewConst(), allSCGlobalIndices, comm ); + + // Update local map with all super-cell mappings + for( localIndex i = 0; i < allSCIds.size(); ++i ) + { + superCellIdToGlobalIdx.insert_or_assign( allSCIds[i], allSCGlobalIndices[i] ); + } + + // ----------------------------------------------------------------------- + // Step 5: Build super-cell graph edges + // ----------------------------------------------------------------------- + array1d< pmet_idx_t > superVertexWeights( numLocalSuperCells ); + stdVector< std::set< pmet_idx_t > > neighborSets( numLocalSuperCells ); + + for( localIndex localSuperIdx = 0; localSuperIdx < numLocalSuperCells; ++localSuperIdx ) + { + vtkIdType superCellId = orderedSuperCellIds[localSuperIdx]; + auto const & localCells = superCellToLocalCells.at( superCellId ); + + auto itWeight = info.vertexWeights.find( superCellId ); + superVertexWeights[localSuperIdx] = (itWeight != info.vertexWeights.end()) + ? itWeight->second : localCells.size(); + + for( vtkIdType cellLocalIdx : localCells ) + { + auto neighbors = baseGraph[cellLocalIdx]; + for( localIndex j = 0; j < neighbors.size(); ++j ) + { + pmet_idx_t nbrParmetis = neighbors[j]; + + auto itVtk = parmetisToVtk.find( nbrParmetis ); + if( itVtk == parmetisToVtk.end() ) + continue; + + vtkIdType nbrVtkId = itVtk->second; + + auto itSC = vtkToSuperCell.find( nbrVtkId ); + if( itSC == vtkToSuperCell.end() ) + continue; + + vtkIdType nbrSuperCellId = itSC->second; + if( nbrSuperCellId == superCellId ) + continue; // Skip self-loops + + auto itGlobal = superCellIdToGlobalIdx.find( nbrSuperCellId ); + if( itGlobal != superCellIdToGlobalIdx.end() ) + { + neighborSets[localSuperIdx].insert( itGlobal->second ); + } + } + } + } + + // ----------------------------------------------------------------------- + // Step 6: Symmetrize + // ----------------------------------------------------------------------- + // Collect ALL edges to send (to any rank) + stdVector< pmet_idx_t > localEdgesSrc; + stdVector< pmet_idx_t > localEdgesDst; + + for( localIndex i = 0; i < numLocalSuperCells; ++i ) + { + pmet_idx_t globalI = localGlobalStart + i; + for( pmet_idx_t nbrIdx : neighborSets[i] ) + { + if( nbrIdx < localGlobalStart || nbrIdx >= localGlobalEnd ) + { + localEdgesSrc.push_back( nbrIdx ); // destination of reverse edge + localEdgesDst.push_back( globalI ); // source of reverse edge + } + } + } + + int localEdgeCount = static_cast< int >( localEdgesSrc.size() ); + + // Gather counts from all ranks + array1d< int > allEdgeCounts( numRanks ); + MpiWrapper::allgather( &localEdgeCount, 1, allEdgeCounts.data(), 1, comm ); + + // Compute displacements for symmetrization + array1d< int > edgeDispls( numRanks + 1 ); + edgeDispls[0] = 0; + std::partial_sum( allEdgeCounts.begin(), allEdgeCounts.end(), + edgeDispls.begin() + 1 ); + + int totalEdges = edgeDispls[numRanks]; + + // Gather all edges + array1d< pmet_idx_t > allEdgeSrc( totalEdges > 0 ? totalEdges : 1 ); + array1d< pmet_idx_t > allEdgeDst( totalEdges > 0 ? totalEdges : 1 ); + + if( localEdgeCount > 0 ) + { + MpiWrapper::allgatherv( localEdgesSrc.data(), localEdgeCount, + allEdgeSrc.data(), allEdgeCounts.data(), edgeDispls.data(), comm ); + MpiWrapper::allgatherv( localEdgesDst.data(), localEdgeCount, + allEdgeDst.data(), allEdgeCounts.data(), edgeDispls.data(), comm ); + } + else + { + // Handle empty send + pmet_idx_t dummy = 0; + MpiWrapper::allgatherv( &dummy, 0, + allEdgeSrc.data(), allEdgeCounts.data(), edgeDispls.data(), comm ); + MpiWrapper::allgatherv( &dummy, 0, + allEdgeDst.data(), allEdgeCounts.data(), edgeDispls.data(), comm ); + } + + // ----------------------------------------------------------------------- + // Step 7: Build final ArrayOfArrays + // ----------------------------------------------------------------------- + ArrayOfArrays< pmet_idx_t, pmet_idx_t > superGraph; + array1d< pmet_idx_t > offsets( numLocalSuperCells + 1 ); + offsets[0] = 0; + + for( localIndex i = 0; i < numLocalSuperCells; ++i ) + { + offsets[i + 1] = offsets[i] + neighborSets[i].size(); + } + + superGraph.resizeFromOffsets( numLocalSuperCells, offsets.data() ); + + for( localIndex i = 0; i < numLocalSuperCells; ++i ) + { + superGraph.appendToArray( i, neighborSets[i].begin(), neighborSets[i].end() ); + } + + return std::make_pair( std::move( superGraph ), std::move( superVertexWeights ) ); +} + +void validateSuperCellGraph( + ArrayOfArrays< pmet_idx_t, pmet_idx_t > const & superGraph, + arrayView1d< pmet_idx_t const > const & superElemDist, + arrayView1d< pmet_idx_t const > const & vertexWeights, + MPI_Comm comm ) +{ + int const rank = MpiWrapper::commRank( comm ); + int const numRanks = MpiWrapper::commSize( comm ); + + pmet_idx_t localStart = superElemDist[rank]; + pmet_idx_t localEnd = superElemDist[rank + 1]; + + // ----------------------------------------------------------------------- + // Check 1: No self-loops + // ----------------------------------------------------------------------- + { + for( localIndex i = 0; i < superGraph.size(); ++i ) + { + pmet_idx_t localGlobalId = localStart + i; + + for( localIndex j = 0; j < superGraph.sizeOfArray( i ); ++j ) + { + GEOS_ERROR_IF( superGraph[i][j] == localGlobalId, + GEOS_FMT( "Rank {}: Super-cell {} (global {}) has self-loop", + rank, i, localGlobalId ) ); + } + } + } + + // ----------------------------------------------------------------------- + // Check 2: All neighbors in valid global range + // ----------------------------------------------------------------------- + { + pmet_idx_t globalMin = 0; + pmet_idx_t globalMax = superElemDist[numRanks] - 1; + + for( localIndex i = 0; i < superGraph.size(); ++i ) + { + for( localIndex j = 0; j < superGraph.sizeOfArray( i ); ++j ) + { + pmet_idx_t neighbor = superGraph[i][j]; + + GEOS_ERROR_IF( neighbor< globalMin || neighbor > globalMax, + GEOS_FMT( "Rank {}: Super-cell {} has out-of-range neighbor {} (valid: [{}, {}])", + rank, i, neighbor, globalMin, globalMax ) ); + } + } + } + + // ----------------------------------------------------------------------- + // Check 3: No duplicate edges + // ----------------------------------------------------------------------- + { + for( localIndex i = 0; i < superGraph.size(); ++i ) + { + std::set< pmet_idx_t > uniqueNeighbors; + + for( localIndex j = 0; j < superGraph.sizeOfArray( i ); ++j ) + { + pmet_idx_t neighbor = superGraph[i][j]; + + GEOS_ERROR_IF( !uniqueNeighbors.insert( neighbor ).second, + GEOS_FMT( "Rank {}: Super-cell {} has duplicate neighbor {}", + rank, i, neighbor ) ); + } + } + } + + // ----------------------------------------------------------------------- + // Check 4: Isolated vertices + // ----------------------------------------------------------------------- + { + localIndex isolated = 0; + + for( localIndex i = 0; i < superGraph.size(); ++i ) + { + if( superGraph.sizeOfArray( i ) == 0 ) + { + isolated++; + if( isolated <= 5 ) + { + pmet_idx_t globalId = localStart + i; + GEOS_LOG_RANK( GEOS_FMT( "WARNING: Super-cell {} (global {}) has no neighbors (isolated)", + i, globalId ) ); + } + } + } + GEOS_WARNING_IF( isolated > 0, GEOS_FMT( "Found {} isolated vertices ", isolated ) ); + } + + // ----------------------------------------------------------------------- + // Check 5: Verify weights + // ----------------------------------------------------------------------- + { + if( !vertexWeights.empty() ) + { + GEOS_ERROR_IF( vertexWeights.size() != superGraph.size(), + GEOS_FMT( "Rank {}: Vertex weights size ({}) != graph size ({})", + rank, vertexWeights.size(), superGraph.size() ) ); + + for( localIndex i = 0; i < vertexWeights.size(); ++i ) + { + GEOS_ERROR_IF( vertexWeights[i] <= 0, + GEOS_FMT( "Rank {}: Super-cell {} has invalid weight {}", + rank, i, vertexWeights[i] ) ); + } + } + } + + // ----------------------------------------------------------------------- + // Check 6: Graph symmetry for local edges + // ----------------------------------------------------------------------- + { + // Pack a pair of (<32-bit) ids into a single uint64_t hash key. + auto const edgeKey = []( pmet_idx_t a, pmet_idx_t b ) -> uint64_t + { + return (static_cast< uint64_t >( a ) << 32) | static_cast< uint64_t >( b ); + }; + + // Iterate every edge whose endpoints are both local to this rank. + auto const forEachLocalEdge = [&]( auto && fn ) + { + for( localIndex i = 0; i < superGraph.size(); ++i ) + { + pmet_idx_t const globalI = localStart + i; + auto neighbors = superGraph[i]; + for( localIndex j = 0; j < neighbors.size(); ++j ) + { + pmet_idx_t const globalJ = neighbors[j]; + if( globalJ >= localStart && globalJ < localEnd ) + { + fn( globalI, globalJ ); + } + } + } + }; + + std::unordered_set< uint64_t > localOutgoingNeighbors; + + forEachLocalEdge( [&]( pmet_idx_t globalI, pmet_idx_t globalJ ) + { + localOutgoingNeighbors.insert( edgeKey( globalI, globalJ ) ); + } ); + + forEachLocalEdge( [&]( pmet_idx_t globalI, pmet_idx_t globalJ ) + { + GEOS_ERROR_IF( localOutgoingNeighbors.find( edgeKey( globalJ, globalI ) ) == localOutgoingNeighbors.end(), + GEOS_FMT( "Rank {}: Asymmetric edge ({} -> {}) - reverse edge missing", + rank, globalI, globalJ ) ); + } ); + } + +} + + +// ============================================================================================= +// SECTION 5: PARTITION EXPANSION (after ParMETIS) +// ============================================================================================= +array1d< int64_t > +expandSuperCellPartitioningToCells( + vtkSmartPointer< vtkUnstructuredGrid > cells3D, + array1d< int64_t > const & superPartitioning, + stdMap< vtkIdType, localIndex > const & superCellIdToLocalIdx, + MPI_Comm comm ) +{ + int const rank = MpiWrapper::commRank( comm ); + + // ----------------------------------------------------------------------- + // Step 1: Get super-cell ID array + // ----------------------------------------------------------------------- + vtkIdTypeArray * superCellIdArray = + vtkIdTypeArray::SafeDownCast( cells3D->GetCellData()->GetArray( "SuperCellId" ) ); + + GEOS_ERROR_IF( superCellIdArray == nullptr, + GEOS_FMT( "Rank {}: SuperCellId array not found", rank ) ); + + GEOS_ERROR_IF( static_cast< size_t >(superPartitioning.size()) != superCellIdToLocalIdx.size(), + GEOS_FMT( "Rank {}: Super-cell partitioning size ({}) doesn't match number of local super-cells ({})", + rank, superPartitioning.size(), superCellIdToLocalIdx.size() ) ); + + // ----------------------------------------------------------------------- + // Step 2: Assign cells to ranks based on super-cell partitioning + // ----------------------------------------------------------------------- + vtkIdType const numCells = cells3D->GetNumberOfCells(); + array1d< int64_t > cellPartitioning( numCells ); + + for( vtkIdType i = 0; i < numCells; ++i ) + { + vtkIdType superCellId = superCellIdArray->GetValue( i ); + auto it = superCellIdToLocalIdx.find( superCellId ); + + GEOS_ERROR_IF( it == superCellIdToLocalIdx.end(), + GEOS_FMT( "Rank {}: Cell {} has unknown super-cell ID {}", + rank, i, superCellId ) ); + + cellPartitioning[i] = superPartitioning[it->second]; + } + + // ----------------------------------------------------------------------- + // Step 3: Validate that super-cells weren't split + // ----------------------------------------------------------------------- + stdMap< vtkIdType, std::set< int64_t > > superCellToRanks; + vtkIdType numSplitSuperCells = 0; + + for( vtkIdType i = 0; i < numCells; ++i ) + { + vtkIdType const scId = superCellIdArray->GetValue( i ); + auto & ranks = superCellToRanks.get_inserted( scId ); + // A super-cell becomes "split" the first time we add a second distinct rank. + numSplitSuperCells += ( ranks.insert( cellPartitioning[i] ).second && ranks.size() == 2 ); + } + + vtkIdType totalSplitSuperCells = MpiWrapper::sum( numSplitSuperCells, comm ); + + GEOS_ERROR_IF( totalSplitSuperCells > 0, + GEOS_FMT( "Partitioning failed: {:L} super-cells were split across ranks!", + totalSplitSuperCells ) ); + + return cellPartitioning; +} + +} // namespace vtk +} // namespace geos diff --git a/src/coreComponents/mesh/generators/VTKSuperCellPartitioning.hpp b/src/coreComponents/mesh/generators/VTKSuperCellPartitioning.hpp new file mode 100644 index 00000000000..16f2db45fa3 --- /dev/null +++ b/src/coreComponents/mesh/generators/VTKSuperCellPartitioning.hpp @@ -0,0 +1,167 @@ +/** + * ------------------------------------------------------------------------------------------------------------ + * 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 GEOS_MESH_GENERATORS_VTKSUPERCELLPARTITIONING_HPP +#define GEOS_MESH_GENERATORS_VTKSUPERCELLPARTITIONING_HPP + +#include "common/DataTypes.hpp" +#include "common/MpiWrapper.hpp" +#include "common/TimingMacros.hpp" +#include "mesh/generators/VTKMeshGeneratorTools.hpp" +#include "mesh/generators/ParMETISInterface.hpp" +#include "LvArray/src/ArrayOfArrays.hpp" + +#include + +class vtkUnstructuredGrid; +class vtkDataSet; + +namespace geos +{ +namespace vtk +{ + +/** + * @brief Initial distribution strategy for super-cells + */ +enum class InitialDistributionStrategy +{ + MORTON, ///< Morton Z-curve ordering for spatial locality + BLOCK ///< Contiguous block distribution +}; + +/** + * @brief Super-cell metadata for constrained partitioning + * + * Groups cells that must remain co-located (e.g., fracture-connected cells). + */ +struct SuperCellInfo +{ + /// SuperCellId to global cell IDs + stdMap< vtkIdType, stdVector< vtkIdType > > superCellToOriginalCells; + + /// SuperCellId to vertex weight + stdMap< vtkIdType, vtkIdType > vertexWeights; + + /// SuperCellIds containing multiple cells + std::set< vtkIdType > atomicSuperCells; +}; + +/** + * @brief Assign super-cell IDs based on fracture connectivity + * + * Cells sharing a fracture get the same ID; isolated cells use their global ID. + * Adds a "SuperCellId" array to the mesh. Runs on rank 0. + * + * @param cells3D Volumetric mesh (modified in-place) + * @param fractureNeighbors Fracture element to 3D neighbor mappings + * @param fractureWeight Load balancing weight boost for fracture super-cells + * @return Super-cell metadata + */ +SuperCellInfo tagCellsWithSuperCellIds( + vtkSmartPointer< vtkUnstructuredGrid > cells3D, + stdMap< string, ArrayOfArrays< localIndex, int64_t > > const & fractureNeighbors, + integer fractureWeight ); + +/** + * @brief Rebuild super-cell metadata from SuperCellId array + * + * After redistribution, each rank reconstructs local super-cell info. + * Applies fracture weights to account for contact computation cost. + * + * @param mesh Distributed mesh with SuperCellId array + * @param fractureWeight Weight boost for multi-cell super-cells + * @return Local super-cell metadata + */ +SuperCellInfo reconstructSuperCellInfo( vtkSmartPointer< vtkUnstructuredGrid > mesh, + integer fractureWeight ); + +/** + * @brief Initial redistribution preserving super-cell integrity + * + * Distributes super-cells across ranks without graph partitioning. + * Faster than ParMETIS for initial scatter. + * + * @param cells3D Input mesh (non-empty on rank 0 only) + * @param comm MPI communicator + * @param strategy Distribution strategy (MORTON or BLOCK) + * @return Redistributed mesh with preserved SuperCellId array + */ +vtkSmartPointer< vtkDataSet > +redistributeBySuperCellBlocks( vtkSmartPointer< vtkUnstructuredGrid > cells3D, + MPI_Comm comm, + InitialDistributionStrategy strategy = InitialDistributionStrategy::MORTON ); + +/** + * @brief Build super-cell adjacency graph + * + * Collapses the cell graph into a super-cell graph where each vertex + * represents a super-cell and edges connect neighboring super-cells. + * + * @param cells3D Mesh with SuperCellId array + * @param baseGraph Original cell-to-cell adjacency + * @param baseElemDist Element distribution for base graph + * @param info Super-cell metadata + * @param comm MPI communicator + * @return (super-cell graph, vertex weights) + */ +std::pair< ArrayOfArrays< pmet_idx_t, pmet_idx_t >, array1d< pmet_idx_t > > +buildSuperCellGraph( + vtkSmartPointer< vtkUnstructuredGrid > cells3D, + ArrayOfArrays< pmet_idx_t, pmet_idx_t > const & baseGraph, + arrayView1d< pmet_idx_t const > const & baseElemDist, + SuperCellInfo const & info, + MPI_Comm comm ); + +/** + * @brief Validate super-cell graph before partitioning + * + * Checks for self-loops, invalid indices, duplicate edges, + * isolated vertices, and invalid weights. + * + * @param superGraph Super-cell adjacency graph + * @param superElemDist Element distribution array + * @param vertexWeights Vertex weights + * @param comm MPI communicator + */ +void validateSuperCellGraph( + ArrayOfArrays< pmet_idx_t, pmet_idx_t > const & superGraph, + arrayView1d< pmet_idx_t const > const & superElemDist, + arrayView1d< pmet_idx_t const > const & vertexWeights, + MPI_Comm comm ); + +/** + * @brief Map super-cell partitions back to individual cells + * + * Converts super-cell -> rank assignments into cell -> rank assignments. + * All cells in a super-cell go to the same rank. + * + * @param cells3D Mesh with SuperCellId array + * @param superPartitioning Super-cell to rank assignments from ParMETIS + * @param superCellIdToLocalIdx SuperCellId to local index mapping + * @param comm MPI communicator + * @return Cell-level partition assignments + */ +array1d< int64_t > +expandSuperCellPartitioningToCells( + vtkSmartPointer< vtkUnstructuredGrid > cells3D, + array1d< int64_t > const & superPartitioning, + stdMap< vtkIdType, localIndex > const & superCellIdToLocalIdx, + MPI_Comm comm ); + +} // namespace vtk +} // namespace geos + +#endif /* GEOS_MESH_GENERATORS_VTKSUPERCELLPARTITIONING_HPP */ diff --git a/src/coreComponents/mesh/generators/VTKUtilities.cpp b/src/coreComponents/mesh/generators/VTKUtilities.cpp index 0f5bea2f589..78f6b905404 100644 --- a/src/coreComponents/mesh/generators/VTKUtilities.cpp +++ b/src/coreComponents/mesh/generators/VTKUtilities.cpp @@ -22,6 +22,7 @@ #include "mesh/generators/VTKMeshGeneratorTools.hpp" #include "mesh/generators/VTKUtilities.hpp" #include "mesh/MeshFields.hpp" +#include "mesh/generators/VTKSuperCellPartitioning.hpp" #ifdef GEOS_USE_PARMETIS #include "mesh/generators/ParMETISInterface.hpp" @@ -206,141 +207,48 @@ generateGlobalIDs( vtkSmartPointer< vtkDataSet > mesh ) /** - * @brief Get the Cell Array object - * @details Replaces GetCells() that exist only in vtkUnstructuredGrid - * @param[in] mesh a vtk grid - * @return an array of cells - */ -vtkSmartPointer< vtkCellArray > getCellArray( vtkSmartPointer< vtkDataSet > mesh ) -{ - vtkSmartPointer< vtkCellArray > cells = vtkSmartPointer< vtkCellArray >::New(); - if( mesh->IsA( "vtkUnstructuredGrid" ) ) - { - cells = vtkUnstructuredGrid::SafeDownCast( mesh )->GetCells(); - } - else if( isMeshStructured( mesh ) ) - { - // All cells are either hexahedra or voxels - vtkIdType const numCells = mesh->GetNumberOfCells(); - cells->AllocateExact( numCells, 8 * numCells ); - for( vtkIdType c = 0; c < numCells; ++c ) - { - cells->InsertNextCell( mesh->GetCell( c ) ); - } - } - else - { - GEOS_ERROR( "Unsupported mesh format" ); - } - return cells; -} - - -/** - * @brief Build the element to nodes mappings for all the @p meshes. - * @tparam INDEX_TYPE The indexing type that will be used by the toolbox that will perfomrn the parallel split. - * @tparam POLICY The computational policy (parallel/serial) - * @param meshes All the meshes involved (volumic and surfacic (for fractures)) - * @param cells The vtk cell array. - * @return The mapping. + * @brief Build the element to nodes mappings for the 3D mesh only + * @tparam INDEX_TYPE The indexing type + * @param mesh The 3D mesh + * @return The mapping for 3D cells only (fractures excluded) + * @note Fractures are partitioned separately based on 3D neighbors, not included in ParMETIS graph */ -template< typename INDEX_TYPE, typename POLICY > +template< typename INDEX_TYPE > ArrayOfArrays< INDEX_TYPE, INDEX_TYPE > -buildElemToNodesImpl( AllMeshes & meshes, - vtkSmartPointer< vtkCellArray > const & cells ) +buildElemToNodes( vtkSmartPointer< vtkDataSet > mesh ) { - localIndex const num3dCells = LvArray::integerConversion< localIndex >( meshes.getMainMesh()->GetNumberOfCells() ); + GEOS_MARK_FUNCTION; + + localIndex const numCells = LvArray::integerConversion< localIndex >( mesh->GetNumberOfCells() ); - localIndex num2dCells = 0; - stdMap< string, CollocatedNodes > collocatedNodesMap; - for( auto & [fractureName, fractureMesh]: meshes.getFaceBlocks() ) - { - num2dCells += fractureMesh->GetNumberOfCells(); - collocatedNodesMap.insert( { fractureName, CollocatedNodes( fractureName, fractureMesh ) } ); - } - localIndex const numCells = num3dCells + num2dCells; array1d< INDEX_TYPE > nodeCounts( numCells ); - // GetCellSize() is always thread-safe, can run in parallel - forAll< parallelHostPolicy >( num3dCells, [nodeCounts = nodeCounts.toView(), &cells] ( localIndex const cellIdx ) + forAll< parallelHostPolicy >( numCells, [&mesh, nodeCounts = nodeCounts.toView()] ( localIndex const cellIdx ) { - nodeCounts[cellIdx] = LvArray::integerConversion< INDEX_TYPE >( cells->GetCellSize( cellIdx ) ); + nodeCounts[cellIdx] = LvArray::integerConversion< INDEX_TYPE >( mesh->GetCellSize( cellIdx ) ); } ); - localIndex offset = num3dCells; - for( auto & [fractureName, fractureMesh]: meshes.getFaceBlocks() ) - { - CollocatedNodes const & collocatedNodes = collocatedNodesMap.at( fractureName ); - forAll< parallelHostPolicy >( fractureMesh->GetNumberOfCells(), [&, nodeCounts = nodeCounts.toView(), fracture = fractureMesh.Get()] ( localIndex const cellIdx ) - { - nodeCounts[cellIdx + offset] = 0; - // We are doing a very strict allocation because some TPLs rely on not having any over allocation. - for( vtkIdType const pointId: *fracture->GetCell( cellIdx )->GetPointIds() ) - { - nodeCounts[cellIdx + offset] += collocatedNodes[pointId].size(); - } - } ); - offset += fractureMesh->GetNumberOfCells(); - } - ArrayOfArrays< INDEX_TYPE, INDEX_TYPE > elemToNodes; elemToNodes.template resizeFromCapacities< parallelHostPolicy >( numCells, nodeCounts.data() ); - vtkIdTypeArray const & globalPointId = *vtkIdTypeArray::FastDownCast( meshes.getMainMesh()->GetPointData()->GetGlobalIds() ); + vtkIdTypeArray const & globalPointId = *vtkIdTypeArray::FastDownCast( mesh->GetPointData()->GetGlobalIds() ); - // GetCellAtId() is conditionally thread-safe, use POLICY argument - forAll< POLICY >( num3dCells, [&cells, &globalPointId, elemToNodes = elemToNodes.toView()] ( localIndex const cellIdx ) + forAll< parallelHostPolicy >( numCells, [&mesh, &globalPointId, elemToNodes = elemToNodes.toView()] ( localIndex const cellIdx ) { - vtkIdType numPts; - vtkIdType const * points; - cells->GetCellAtId( cellIdx, numPts, points ); - for( int a = 0; a < numPts; ++a ) + vtkSmartPointer< vtkIdList > const ptIds = vtkSmartPointer< vtkIdList >::New(); + mesh->GetCellPoints( cellIdx, ptIds ); + vtkIdType const numPts = ptIds->GetNumberOfIds(); + for( vtkIdType a = 0; a < numPts; ++a ) { - vtkIdType const pointIdx = globalPointId.GetValue( points[a] ); + vtkIdType const pointIdx = globalPointId.GetValue( ptIds->GetId( a ) ); elemToNodes.emplaceBack( cellIdx, LvArray::integerConversion< INDEX_TYPE >( pointIdx ) ); } } ); - offset = num3dCells; // Restarting the loop from the beginning. - for( auto & [fractureName, fractureMesh]: meshes.getFaceBlocks() ) - { - CollocatedNodes const & collocatedNodes = collocatedNodesMap.at( fractureName ); - for( vtkIdType i = 0; i < fractureMesh->GetNumberOfCells(); ++i ) - { - for( vtkIdType const pointId: *fractureMesh->GetCell( i )->GetPointIds() ) - { - for( vtkIdType const & tmp: collocatedNodes[pointId] ) - { - elemToNodes.emplaceBack( offset + i, tmp ); - } - } - } - offset += fractureMesh->GetNumberOfCells(); - } - return elemToNodes; } -/** - * @brief Build the element to nodes mappings for all the @p meshes. - * @tparam INDEX_TYPE The indexing type that will be used by the toolbox that will perfomrn the parallel split. - * @param meshes All the meshes involved (volumic and surfacic (for fractures))l - * @return The mapping. - */ -template< typename INDEX_TYPE > -ArrayOfArrays< INDEX_TYPE, INDEX_TYPE > -buildElemToNodes( AllMeshes & meshes ) -{ - vtkSmartPointer< vtkCellArray > const & cells = vtk::getCellArray( meshes.getMainMesh() ); - // According to VTK docs, IsStorageShareable() indicates whether pointers extracted via - // vtkCellArray::GetCellAtId() are pointers into internal storage rather than temp buffer - // and thus results can be used in a thread-safe way. - return cells->IsStorageShareable() - ? buildElemToNodesImpl< INDEX_TYPE, parallelHostPolicy >( meshes, cells ) - : buildElemToNodesImpl< INDEX_TYPE, serialPolicy >( meshes, cells ); -} - /** * @brief Split a mesh by partitioning it * @@ -593,13 +501,14 @@ AllMeshes loadAllMeshes( Path const & filePath, string const & mainBlockName, string_array const & faceBlockNames ) { - int const lastRank = MpiWrapper::commSize() - 1; vtkSmartPointer< vtkDataSet > main = loadMesh( filePath, mainBlockName ); stdMap< string, vtkSmartPointer< vtkDataSet > > faces; + // Load fractures on rank 0 (same as main mesh for 2D cells) + // This allows building fracture-to-3D connectivity before redistribution for( string const & faceBlockName: faceBlockNames ) { - faces.insert( { faceBlockName, loadMesh( filePath, faceBlockName, lastRank ) } ); + faces.insert( { faceBlockName, loadMesh( filePath, faceBlockName, 0 ) } ); } return AllMeshes( main, faces ); @@ -618,7 +527,7 @@ AllMeshes loadAllMeshes( Path const & filePath, * @return the cell partitioning array */ array1d< int64_t > -partitionByCellGraph( AllMeshes & input, +partitionByCellGraph( vtkSmartPointer< vtkDataSet > mesh3D, PartitionMethod const method, MPI_Comm const comm, int const numParts, @@ -627,16 +536,10 @@ partitionByCellGraph( AllMeshes & input, { GEOS_MARK_FUNCTION; - pmet_idx_t const numElems = input.getMainMesh()->GetNumberOfCells(); + pmet_idx_t const numElems = mesh3D->GetNumberOfCells(); pmet_idx_t const numRanks = MpiWrapper::commSize( comm ); - int const rank = MpiWrapper::commRank( comm ); - int const lastRank = numRanks - 1; - // Value at each index (i.e. MPI rank) of `elemDist` gives the first element index of the MPI rank. - // It's assumed that MPI ranks spans continuous numbers of elements. - // Thus, the number of elements of each rank can be deduced by subtracting - // the values between two consecutive ranks. To be able to do this even for the last rank, - // a last additional value is appended, and the size of the array is then the comm size plus 1. + // Note: elemDist contains 3D cells only. Fractures are assigned later based on 3D neighbors. array1d< pmet_idx_t > const elemDist( numRanks + 1 ); { array1d< pmet_idx_t > elemCounts; @@ -644,21 +547,8 @@ partitionByCellGraph( AllMeshes & input, std::partial_sum( elemCounts.begin(), elemCounts.end(), elemDist.begin() + 1 ); } - vtkIdType localNumFracCells = 0; - if( rank == lastRank ) // Let's add artificially the fracture to the last rank (for numbering reasons). - { - // Adding one fracture element - for( auto const & [fractureName, fracture]: input.getFaceBlocks() ) - { - localNumFracCells += fracture->GetNumberOfCells(); - } - } - vtkIdType globalNumFracCells = localNumFracCells; - MpiWrapper::broadcast( globalNumFracCells, lastRank, comm ); - elemDist[lastRank + 1] += globalNumFracCells; - - // The `elemToNodes` mapping binds element indices (local to the rank) to the global indices of their support nodes. - ArrayOfArrays< pmet_idx_t, pmet_idx_t > const elemToNodes = buildElemToNodes< pmet_idx_t >( input ); + // Build element-to-node connectivity for the 3D mesh only + ArrayOfArrays< pmet_idx_t, pmet_idx_t > const elemToNodes = buildElemToNodes< pmet_idx_t >( mesh3D ); ArrayOfArrays< pmet_idx_t, pmet_idx_t > graph; #ifdef GEOS_USE_PARMETIS graph = parmetis::meshToDual( elemToNodes.toViewConst(), elemDist, comm, minCommonNodes ); @@ -698,57 +588,260 @@ partitionByCellGraph( AllMeshes & input, } /** - * @brief Redistribute the mesh using cell graph methods (ParMETIS or PTScotch) - * @param[in] mesh a vtk grid - * @param[in] method the partitioning method - * @param[in] comm the MPI communicator - * @param[in] numRefinements the number of refinements for PTScotch - * @return + * @brief Redistribute the 3D mesh using cell graph methods (ParMETIS or PTScotch) + * @param[in] mesh3D The 3D main mesh to partition + * @param[in] method The partitioning method + * @param[in] comm The MPI communicator + * @param[in] numRefinements The number of refinement iterations + * @return Redistributed 3D mesh + * @note Fractures are NOT partitioned here - they will be assigned later */ -AllMeshes -redistributeByCellGraph( AllMeshes & input, +vtkSmartPointer< vtkDataSet > +redistributeByCellGraph( vtkSmartPointer< vtkDataSet > mesh3D, PartitionMethod const method, MPI_Comm const comm, int const numRefinements ) { GEOS_MARK_FUNCTION; + int const numRanks = MpiWrapper::commSize( comm ); + + // Partition the 3D main mesh only + array1d< int64_t > newPartitions = partitionByCellGraph( mesh3D, method, comm, numRanks, 3, numRefinements ); + + // Split and redistribute the 3D mesh + vtkSmartPointer< vtkPartitionedDataSet > const splitMesh = + splitMeshByPartition( mesh3D, numRanks, newPartitions.toViewConst() ); + + return vtk::redistribute( *splitMesh, comm ); +} + + +/** + * @brief Partition mesh while keeping super-cells (cell groups) intact + * + * Builds a weighted graph where vertices represent super-cells, then partitions + * using ParMETIS/PTScotch. Ensures cells with the same SuperCellId stay together. + * + * @param mesh Input mesh with "SuperCellId" cell data array + * @param method Partitioning algorithm (parmetis or ptscotch) + * @param comm MPI communicator + * @param numRefinementIterations Number of ParMETIS refinement passes + * @return Redistributed mesh with super-cells kept intact + */ +vtkSmartPointer< vtkDataSet > +redistributeBySuperCellGraph( + vtkSmartPointer< vtkDataSet > mesh, + PartitionMethod const method, + MPI_Comm comm, + int const numRefinementIterations, + int const fractureWeight ) +{ + GEOS_MARK_FUNCTION; + int const rank = MpiWrapper::commRank( comm ); int const numRanks = MpiWrapper::commSize( comm ); - array1d< int64_t > newPartitions = partitionByCellGraph( input, method, comm, numRanks, 3, numRefinements ); - // Extract the partition information related to the fracture mesh. - stdMap< string, array1d< pmet_idx_t > > newFracturePartitions; - vtkIdType fracOffset = input.getMainMesh()->GetNumberOfCells(); - vtkIdType localNumFracCells = 0; - for( auto const & [fractureName, fracture]: input.getFaceBlocks() ) + // ----------------------------------------------------------------------- + // Step 1: Build base cell graph (standard adjacency) + // ----------------------------------------------------------------------- + vtkSmartPointer< vtkUnstructuredGrid > ugrid = + vtkUnstructuredGrid::SafeDownCast( mesh ); + + GEOS_ERROR_IF( !ugrid, "Mesh is not vtkUnstructuredGrid" ); + + ArrayOfArrays< pmet_idx_t, pmet_idx_t > baseCellGraph; + array1d< pmet_idx_t > baseElemDist( numRanks + 1 ); + { + // Build element distribution based on local cell counts + pmet_idx_t const numLocalCells = ugrid->GetNumberOfCells(); + + array1d< pmet_idx_t > cellCounts; + MpiWrapper::allGather( numLocalCells, cellCounts, comm ); + + baseElemDist[0] = 0; + std::partial_sum( cellCounts.begin(), cellCounts.end(), baseElemDist.begin() + 1 ); + + // Build element-to-node connectivity local to each rank + ArrayOfArrays< pmet_idx_t, pmet_idx_t > const elemToNodes = + buildElemToNodes< pmet_idx_t >( ugrid ); + + // Build dual graph (cell-to-cell via shared nodes) +#ifdef GEOS_USE_PARMETIS + int const minCommonNodes = 3; // Minimum shared nodes for edge + baseCellGraph = parmetis::meshToDual( elemToNodes.toViewConst(), baseElemDist, comm, minCommonNodes ); +#else + GEOS_THROW( "GEOS must be built with ParMETIS support (ENABLE_PARMETIS=ON) " + "to build cell graphs for partitioning", InputError ); +#endif + } + + // ----------------------------------------------------------------------- + // Step 2: Reconstruct super-cell info on all ranks (from SuperCellId array) + // ----------------------------------------------------------------------- + SuperCellInfo localSuperCellInfo = reconstructSuperCellInfo( ugrid, fractureWeight ); + + // ----------------------------------------------------------------------- + // Step 3: Build super-cell graph + // ----------------------------------------------------------------------- + auto [superCellGraph, superVertexWeights] = buildSuperCellGraph( + ugrid, + baseCellGraph, + baseElemDist, + localSuperCellInfo, + comm + ); + + // ----------------------------------------------------------------------- + // Step 4: Compute super-cell element distribution + // ----------------------------------------------------------------------- + array1d< pmet_idx_t > superElemDist( numRanks + 1 ); + { + pmet_idx_t const localSuperCellCount = LvArray::integerConversion< pmet_idx_t >( superCellGraph.size() ); + + array1d< pmet_idx_t > superCellCounts; + MpiWrapper::allGather( localSuperCellCount, superCellCounts, comm ); + + superElemDist[0] = 0; + std::partial_sum( superCellCounts.begin(), superCellCounts.end(), + superElemDist.begin() + 1 ); + } + + // ----------------------------------------------------------------------- + // Step 5: Validate graph before partitioning + // ----------------------------------------------------------------------- + validateSuperCellGraph( + superCellGraph, + superElemDist.toViewConst(), + superVertexWeights.toViewConst(), + comm + ); + + // ----------------------------------------------------------------------- + // Step 6: Partition super-cell graph using ParMETIS/PTScotch + // ----------------------------------------------------------------------- + array1d< int64_t > superCellPartitioning; + + if( method == PartitionMethod::parmetis ) + { + GEOS_LOG_RANK_0( "Partitioning super-cell graph with ParMETIS..." ); + + // Basic validation + pmet_idx_t const minGraphSize = MpiWrapper::min( static_cast< pmet_idx_t >( superCellGraph.size() ), comm ); + GEOS_ERROR_IF( minGraphSize == 0, "At least one rank has an empty super-cell graph!" ); + + superCellPartitioning = parmetis::partitionWeighted( + superCellGraph.toViewConst(), + superVertexWeights.toViewConst(), + superElemDist.toViewConst(), + numRanks, + comm, + numRefinementIterations + ); + } + else { - localIndex const numFracCells = fracture->GetNumberOfCells(); - localNumFracCells += (rank == numRanks - 1) ? fracture->GetNumberOfCells() : 0; - array1d< pmet_idx_t > tmp( numFracCells ); - std::copy( newPartitions.begin() + fracOffset, newPartitions.begin() + fracOffset + numFracCells, tmp.begin() ); - newFracturePartitions.insert( { fractureName, tmp } ); - fracOffset += numFracCells; + GEOS_ERROR( GEOS_FMT( "Unsupported partition method: {}", + EnumStrings< PartitionMethod >::toString( method ) ) ); + } + + // ----------------------------------------------------------------------- + // Step 7: Map SuperCellId to local super-cell indices for partition unpacking + // ----------------------------------------------------------------------- + + vtkIdTypeArray * superCellIdArray = + vtkIdTypeArray::SafeDownCast( ugrid->GetCellData()->GetArray( "SuperCellId" ) ); + + GEOS_ERROR_IF( !superCellIdArray, + GEOS_FMT( "SuperCellId array not found on rank {}", rank ) ); + + stdMap< vtkIdType, localIndex > superCellIdToLocalIdx; + +// Build ordered list of local super-cell IDs + stdVector< vtkIdType > orderedSuperCellIds; + orderedSuperCellIds.reserve( localSuperCellInfo.superCellToOriginalCells.size() ); + + for( auto const & [scId, cells] : localSuperCellInfo.superCellToOriginalCells ) + { + orderedSuperCellIds.push_back( scId ); + } + + // Sort to ensure consistent ordering + std::sort( orderedSuperCellIds.begin(), orderedSuperCellIds.end() ); + + localIndex const numLocalSuperCells = LvArray::integerConversion< localIndex >( orderedSuperCellIds.size() ); + for( localIndex i = 0; i < numLocalSuperCells; ++i ) + { + superCellIdToLocalIdx.insert( { orderedSuperCellIds[i], i } ); + } + + // ----------------------------------------------------------------------- + // Step 8: Unpack super-cell partitioning to individual cells + // ----------------------------------------------------------------------- + array1d< int64_t > cellPartitioning = expandSuperCellPartitioningToCells( + ugrid, + superCellPartitioning, + superCellIdToLocalIdx, + comm + ); + + // ----------------------------------------------------------------------- + // Step 9: Verify no super-cells were split across ranks + // ----------------------------------------------------------------------- + stdMap< vtkIdType, int64_t > superCellToRank; + + vtkIdType const numCells = ugrid->GetNumberOfCells(); + for( vtkIdType i = 0; i < numCells; ++i ) + { + vtkIdType const scId = superCellIdArray->GetValue( i ); + int64_t const targetRank = cellPartitioning[i]; + + auto [it, inserted] = superCellToRank.insert( {scId, targetRank} ); + + GEOS_ERROR_IF( !inserted && it->second != targetRank, + GEOS_FMT( "Super-cell {} is split: assigned to both rank {} and rank {}", + scId, it->second, targetRank ) ); } - // Now do the same for the 3d mesh, simply by trimming the fracture information. - newPartitions.resize( newPartitions.size() - localNumFracCells ); - // Now, perform the final steps: first, a new split following the new partitions. - // Then those newly split meshes will be redistributed across the ranks. + // ----------------------------------------------------------------------- + // Step 10: Redistribute mesh according to cell partitioning + // ----------------------------------------------------------------------- + // Split mesh according to partitioning + vtkSmartPointer< vtkPartitionedDataSet > splitMesh = + splitMeshByPartition( ugrid, numRanks, cellPartitioning.toViewConst() ); + + // Redistribute using VTK + vtkSmartPointer< vtkDataSet > redistributed = vtk::redistribute( *splitMesh, comm ); + + // ----------------------------------------------------------------------- + // Step 11: Report final distribution statistics + // ----------------------------------------------------------------------- + array1d< vtkIdType > cellsPerRank; + vtkIdType const localCells = redistributed->GetNumberOfCells(); + MpiWrapper::allGather( localCells, cellsPerRank, comm ); - // First for the main 3d mesh... - vtkSmartPointer< vtkPartitionedDataSet > const splitMesh = splitMeshByPartition( input.getMainMesh(), numRanks, newPartitions.toViewConst() ); - vtkSmartPointer< vtkUnstructuredGrid > finalMesh = vtk::redistribute( *splitMesh, MPI_COMM_GEOS ); - // ... and then for the fractures. - stdMap< string, vtkSmartPointer< vtkDataSet > > finalFractures; - for( auto const & [fractureName, fracture]: input.getFaceBlocks() ) + if( rank == 0 ) { - vtkSmartPointer< vtkPartitionedDataSet > const splitFracMesh = splitMeshByPartition( fracture, numRanks, newFracturePartitions[fractureName].toViewConst() ); - vtkSmartPointer< vtkUnstructuredGrid > const finalFracMesh = vtk::redistribute( *splitFracMesh, MPI_COMM_GEOS ); - finalFractures.insert( {fractureName, finalFracMesh} ); + vtkIdType totalCells = 0; + vtkIdType minCells = std::numeric_limits< vtkIdType >::max(); + vtkIdType maxCells = 0; + + for( int r = 0; r < numRanks; ++r ) + { + totalCells += cellsPerRank[r]; + minCells = std::min( minCells, cellsPerRank[r] ); + maxCells = std::max( maxCells, cellsPerRank[r] ); + } + + real64 const avgCells = static_cast< real64 >( totalCells ) / numRanks; + real64 const imbalance = (numRanks > 1) ? (maxCells - avgCells) / avgCells * 100.0 : 0.0; + + GEOS_LOG_RANK_0( GEOS_FMT( "Final 3D cells redistribution: {} total, {} avg/rank, [{}-{}] range, {:.1f}% imbalance", + totalCells, static_cast< vtkIdType >(avgCells), + minCells, maxCells, imbalance ) ); } - return AllMeshes( finalMesh, finalFractures ); + return redistributed; } @@ -980,12 +1073,22 @@ build2DTo3DNeighbors( vtkDataSet & mesh, } // Print diagnostic summary - GEOS_LOG_RANK_0( "\n2D-to-3D Neighbor Topology" ); - GEOS_LOG_RANK_0( GEOS_FMT( " Total 2D cells: {}", cells2DIndices.size() ) ); - GEOS_LOG_RANK_0( GEOS_FMT( " Standalone (0 neighbors): {}", numStandalone ) ); - GEOS_LOG_RANK_0( GEOS_FMT( " Boundary (1 neighbor): {}", numBoundary ) ); - GEOS_LOG_RANK_0( GEOS_FMT( " Internal (2 neighbors): {}", numInternal ) ); - GEOS_LOG_RANK_0( GEOS_FMT( " Junction (>2 neighbors):{}", numJunction ) ); + if( numStandalone > 0 || numJunction > 0 ) + { + // Show detailed breakdown when anomalies exist + GEOS_LOG_RANK_0( "\n2D-to-3D Neighbor Topology" ); + GEOS_LOG_RANK_0( GEOS_FMT( " Total 2D cells: {}", cells2DIndices.size() ) ); + GEOS_LOG_RANK_0( GEOS_FMT( " Standalone (0 neighbors): {}", numStandalone ) ); + GEOS_LOG_RANK_0( GEOS_FMT( " Boundary (1 neighbor): {}", numBoundary ) ); + GEOS_LOG_RANK_0( GEOS_FMT( " Internal (2 neighbors): {}", numInternal ) ); + GEOS_LOG_RANK_0( GEOS_FMT( " Junction (>2 neighbors):{}\n", numJunction ) ); + } + else + { + // Condensed output for normal cases + GEOS_LOG_RANK_0( GEOS_FMT( "2D cells: {} (1-neighbor/boundary: {}, 2-neighbor/internal: {})", + cells2DIndices.size(), numBoundary, numInternal ) ); + } // Standalone 2D cells indicate mesh topology errors GEOS_ERROR_IF( numStandalone > 0, @@ -997,20 +1100,23 @@ build2DTo3DNeighbors( vtkDataSet & mesh, } /** - * @brief Assign 2D cells to partitions based on their 3D neighbor locations + * @brief Assign cells to partitions based on their 3D neighbor locations * + * Generic function for assigning 2D cells or fracture elements to partitions. + * Uses deterministic tie-breaking (minimum neighbor global ID) to ensure + * each cell is co-located with at least one of its 3D neighbors. * - * @param[in] neighbors2Dto3D Neighbor mapping (2D cell index to 3D global IDs) + * @param[in] neighborsTo3D Neighbor mapping (cell index -> 3D global IDs) * @param[in] local3DGlobalIds Global IDs of 3D cells on this rank * @param[in] local3DPartitions Partition assignments for local 3D cells * @param[in] comm MPI communicator - * @return Partition assignments for each 2D cell + * @return Partition assignments for each input cell */ static array1d< int > -assign2DCellsTo3DPartitions( ArrayOfArrays< localIndex, int64_t > const & neighbors2Dto3D, - arrayView1d< int64_t const > local3DGlobalIds, - arrayView1d< int const > local3DPartitions, - MPI_Comm const comm ) +assignCellsBasedOn3DNeighbors( ArrayOfArrays< localIndex, int64_t > const & neighbors2Dto3D, + arrayView1d< int64_t const > local3DGlobalIds, + arrayView1d< int const > local3DPartitions, + MPI_Comm const comm ) { GEOS_MARK_FUNCTION; @@ -1159,28 +1265,40 @@ extractGlobalIds( vtkDataSet & mesh ) return result; } + /** - * @brief Redistribute 2D cells and merge with already-redistributed 3D cells + * @brief Redistribute 2D cells and fractures, then merge with already-redistributed 3D cells * - * This function completes the 2D/3D redistribution workflow: + * This function completes the 2D/3D/fracture redistribution workflow: * 1. Assigns 2D cells to partitions based on their 3D neighbor locations * 2. Redistributes 2D cells to appropriate ranks - * 3. Merges local 2D and 3D cells on each rank into a unified mesh + * 3. Assigns fracture cells to partitions based on their 3D neighbor locations + * 4. Redistributes fracture cells to appropriate ranks + * 5. Merges local 2D and 3D cells on each rank into a unified mesh + * + * Both 2D cells and fractures are assigned to ranks using the same strategy: + * - Find all 3D neighbors of each 2D/fracture element + * - Assign to the rank owning the 3D neighbor with minimum global ID (deterministic) + * - Uses efficient MPI communication (only gathers needed 3D partition info) * * @param[in] redistributed3D Already partitioned 3D cells with global IDs * @param[in] originalMesh Original mesh containing 2D cells (on rank 0) * @param[in] cells2DIndices Indices of 2D cells in original mesh - * @param[in] neighbors2Dto3D Pre-computed 2D-to-3D neighbor mapping - * @param[in] redistributedFractures Already partitioned fracture meshes (pass-through) + * @param[in] neighbors2Dto3D Pre-computed 2D-to-3D neighbor mapping (fracture element -> 3D cell global IDs) + * @param[in] unpartitionedFractures Unpartitioned fracture meshes (on rank 0, empty on others) + * @param[in] fractureNeighbors Pre-computed fracture-to-3D neighbor mappings (on rank 0, empty on others) + * @param[in] fractureNames Ordered list of fracture names (consistent across all ranks) * @param[in] comm MPI communicator - * @return Complete AllMeshes object with merged main mesh and fractures + * @return Complete AllMeshes object with merged main mesh (3D+2D) and redistributed fractures */ static AllMeshes redistribute2DAndMergeWith3D( vtkSmartPointer< vtkDataSet > redistributed3D, vtkSmartPointer< vtkDataSet > originalMesh, arrayView1d< vtkIdType const > cells2DIndices, ArrayOfArrays< localIndex, int64_t > const & neighbors2Dto3D, - stdMap< string, vtkSmartPointer< vtkDataSet > > const & redistributedFractures, + stdMap< string, vtkSmartPointer< vtkDataSet > > const & unpartitionedFractures, + stdMap< string, ArrayOfArrays< localIndex, int64_t > > const & fractureNeighbors, + stdVector< string > const & fractureNames, MPI_Comm const comm ) { GEOS_MARK_FUNCTION; @@ -1188,35 +1306,32 @@ redistribute2DAndMergeWith3D( vtkSmartPointer< vtkDataSet > redistributed3D, int const rank = MpiWrapper::commRank( comm ); int const numRanks = MpiWrapper::commSize( comm ); - - // Step 1: Assign 2D cells to partitions based on 3D neighbor locations + // ----------------------------------------------------------------------- + // Step 1: Assign and redistribute 2D cells + // ----------------------------------------------------------------------- array1d< int64_t > local3DGlobalIds = extractGlobalIds( *redistributed3D ); array1d< int > partitions3D( redistributed3D->GetNumberOfCells() ); partitions3D.setValues< parallelHostPolicy >( rank ); bool const hasLocal2DCells = (rank == 0 && !cells2DIndices.empty()); - // Collective 2D partition assignment (pass empty array if no local 2D cells) - array1d< int > partitions2D = assign2DCellsTo3DPartitions( + array1d< int > partitions2D = assignCellsBasedOn3DNeighbors( hasLocal2DCells ? neighbors2Dto3D : ArrayOfArrays< localIndex, int64_t >{}, local3DGlobalIds.toViewConst(), partitions3D.toViewConst(), comm ); - // Extract 2D cells where applicable vtkSmartPointer< vtkUnstructuredGrid > cells2D = hasLocal2DCells ? extractCellsByIndices( *originalMesh, cells2DIndices ) : vtkSmartPointer< vtkUnstructuredGrid >::New(); - // Step 2: Split and redistribute 2D cells - // All ranks participate (cells2D and partitions2D are empty on non-root ranks) vtkSmartPointer< vtkPartitionedDataSet > split2D = splitMeshByPartition( cells2D, numRanks, partitions2D.toViewConst() ); vtkSmartPointer< vtkUnstructuredGrid > redistributed2D = vtk::redistribute( *split2D, comm ); - // Conservation check - verify no 2D cells were lost + // Conservation check vtkIdType const total2DCells = MpiWrapper::sum( redistributed2D->GetNumberOfCells(), comm ); vtkIdType expected2DCells = cells2DIndices.size(); MpiWrapper::broadcast( expected2DCells, 0, comm ); @@ -1225,29 +1340,294 @@ redistribute2DAndMergeWith3D( vtkSmartPointer< vtkDataSet > redistributed3D, GEOS_FMT( "2D cell redistribution failed: expected {} cells, got {} cells", expected2DCells, total2DCells ) ); - // Step 3: Merge local 2D and 3D cells on each rank + // ----------------------------------------------------------------------- + // Step 2: Redistribute fractures + // ----------------------------------------------------------------------- + stdMap< string, vtkSmartPointer< vtkDataSet > > redistributedFractures; + + for( string const & fractureName : fractureNames ) + { + vtkIdType expectedFractureCells = 0; + + ArrayOfArrays< localIndex, int64_t > localFractureNeighbors; + vtkSmartPointer< vtkDataSet > unpartitionedFracture; + + if( rank == 0 ) + { + auto fracIt = unpartitionedFractures.find( fractureName ); + unpartitionedFracture = (fracIt != unpartitionedFractures.end()) ? fracIt->second : nullptr; + + if( unpartitionedFracture && unpartitionedFracture->GetNumberOfCells() > 0 ) + { + expectedFractureCells = unpartitionedFracture->GetNumberOfCells(); + + auto fracNeighborIt = fractureNeighbors.find( fractureName ); + GEOS_ERROR_IF( fracNeighborIt == fractureNeighbors.end(), + GEOS_FMT( "Fracture '{}' not found in fractureNeighbors map", fractureName ) ); + + localFractureNeighbors = fracNeighborIt->second; + } + } + + array1d< int > partitionsFracture = assignCellsBasedOn3DNeighbors( + localFractureNeighbors, // Empty on non-root ranks + local3DGlobalIds.toViewConst(), + partitions3D.toViewConst(), + comm ); + + // Split and redistribute + vtkSmartPointer< vtkPartitionedDataSet > splitFracture; + + if( rank == 0 && unpartitionedFracture && unpartitionedFracture->GetNumberOfCells() > 0 ) + { + splitFracture = splitMeshByPartition( unpartitionedFracture, numRanks, + partitionsFracture.toViewConst() ); + } + else + { + splitFracture = vtkSmartPointer< vtkPartitionedDataSet >::New(); + splitFracture->SetNumberOfPartitions( numRanks ); + for( int r = 0; r < numRanks; ++r ) + { + splitFracture->SetPartition( r, vtkSmartPointer< vtkUnstructuredGrid >::New() ); + } + } + + vtkSmartPointer< vtkUnstructuredGrid > localFracture = + vtk::redistribute( *splitFracture, comm ); + + vtkIdType const totalFractureCells = MpiWrapper::sum( localFracture->GetNumberOfCells(), comm ); + MpiWrapper::broadcast( expectedFractureCells, 0, comm ); + + GEOS_ERROR_IF( totalFractureCells != expectedFractureCells, + GEOS_FMT( "Fracture '{}' redistribution lost cells: expected {}, got {}", + fractureName, expectedFractureCells, totalFractureCells ) ); + + redistributedFractures.insert( { fractureName, localFracture } ); + } + + // ----------------------------------------------------------------------- + // Step 3: Merge local 2D and 3D cells + // ----------------------------------------------------------------------- vtkSmartPointer< vtkUnstructuredGrid > mergedMesh = vtkSmartPointer< vtkUnstructuredGrid >::New(); if( redistributed2D->GetNumberOfCells() > 0 ) { - // Merge 3D and 2D cells using VTK append filter vtkNew< vtkAppendFilter > appendFilter; appendFilter->AddInputData( redistributed3D ); appendFilter->AddInputData( redistributed2D ); - appendFilter->MergePointsOn(); // Ensures shared nodes are not duplicated + appendFilter->MergePointsOn(); appendFilter->Update(); mergedMesh->ShallowCopy( appendFilter->GetOutput() ); } else { - // Only 3D cells on this rank mergedMesh->ShallowCopy( redistributed3D ); } return AllMeshes( mergedMesh, redistributedFractures ); } +/** + * @brief Find 3D cells whose faces exactly match a fracture element + * + * A 3D cell matches if it has a face that shares all nodes with the fracture element, + * accounting for collocated nodes at split interfaces. + * + * @param fractureNodeIds Local node IDs of the fracture element + * @param collocatedNodes Mapping from local node ID to all collocated global IDs + * @param nodesToCells Reverse map from global node ID to cells containing that node + * @return Global IDs of matching 3D cells (typically 0-2 neighbors for fractures) + */ +stdVector< vtkIdType > findMatchingCellsForFractureElement( + vtkIdList * fractureNodeIds, + CollocatedNodes const & collocatedNodes, + stdMap< vtkIdType, std::set< vtkIdType > > const & nodesToCells ) +{ + vtkIdType const numFractureNodes = fractureNodeIds->GetNumberOfIds(); + + // Build set of ALL collocated nodes for this fracture element + std::unordered_set< vtkIdType > fractureCollocatedNodes; + fractureCollocatedNodes.reserve( numFractureNodes * 2 ); // Typical case: 2 versions per node + + for( vtkIdType j = 0; j < numFractureNodes; ++j ) + { + vtkIdType const localNodeIdx = fractureNodeIds->GetId( j ); + stdVector< vtkIdType > const & ns = collocatedNodes[ localNodeIdx ]; + fractureCollocatedNodes.insert( ns.begin(), ns.end() ); + } + + // Build map: candidate cellId -> set of its nodes that match fracture's collocated nodes + std::unordered_map< vtkIdType, std::unordered_set< vtkIdType > > cellToMatchedNodes; + cellToMatchedNodes.reserve( fractureCollocatedNodes.size() ); + + for( vtkIdType const & collocatedNode : fractureCollocatedNodes ) + { + auto it = nodesToCells.find( collocatedNode ); + if( it != nodesToCells.cend() ) + { + for( vtkIdType const & cellId : it->second ) + { + cellToMatchedNodes[cellId].insert( collocatedNode ); + } + } + } + + // Filter to cells that form a valid matching face + stdVector< vtkIdType > matchingCells; + matchingCells.reserve( 2 ); // Most fractures have 0-2 neighbors + + for( auto const & cellToNodes : cellToMatchedNodes ) + { + vtkIdType const cellId = cellToNodes.first; + auto const & matchedNodes = cellToNodes.second; + + // Must match exactly the number of fracture nodes + if( matchedNodes.size() != static_cast< std::size_t >( numFractureNodes ) ) + { + continue; + } + + // Verify each fracture node has at least one collocated version in the matched set + // (ensures we matched a true face, not just any numFractureNodes nodes) + bool allFractureNodesRepresented = true; + + for( vtkIdType j = 0; j < numFractureNodes; ++j ) + { + vtkIdType const localNodeIdx = fractureNodeIds->GetId( j ); + stdVector< vtkIdType > const & nodeCollocated = collocatedNodes[ localNodeIdx ]; + + // Check if ANY collocated version of this node is in the matched set + bool nodeRepresented = std::any_of( + nodeCollocated.begin(), + nodeCollocated.end(), + [&matchedNodes]( vtkIdType collocNode ) { return matchedNodes.count( collocNode ) > 0; } + ); + + if( !nodeRepresented ) + { + allFractureNodesRepresented = false; + break; + } + } + + if( allFractureNodesRepresented ) + { + matchingCells.push_back( cellId ); + + // Early exit - most fractures have ≤2 neighbors (boundary or internal) + if( matchingCells.size() >= 2 ) + { + return matchingCells; + } + } + } + + return matchingCells; +} + +/** + * @brief Build fracture-to-3D neighbor connectivity + * + * @param originalMesh The original mesh containing both 3D cells and fractures + * @param fractureMesh The fracture mesh (separate mesh on rank 0) + * @param cells3DIndices Indices of 3D cells in the original mesh + * @return Mapping: fracture element index -> global IDs of neighboring 3D cells + */ +static ArrayOfArrays< localIndex, int64_t > +buildFractureTo3DNeighbors( vtkDataSet & originalMesh, + vtkSmartPointer< vtkDataSet > fractureMesh, + arrayView1d< vtkIdType const > cells3DIndices ) +{ + GEOS_MARK_FUNCTION; + + vtkIdType const numFractureElems = fractureMesh->GetNumberOfCells(); + + vtkDataArray * meshGlobalCellIds = originalMesh.GetCellData()->GetGlobalIds(); + vtkDataArray * meshGlobalNodeIds = originalMesh.GetPointData()->GetGlobalIds(); + + GEOS_ERROR_IF( meshGlobalCellIds == nullptr, "Original mesh must have cell GlobalIds" ); + GEOS_ERROR_IF( meshGlobalNodeIds == nullptr, "Original mesh must have node GlobalIds" ); + + // ----------------------------------------------------------------------- + // Step 1: Build reverse lookup: original mesh index -> global cell ID (3D cells only) + // ----------------------------------------------------------------------- + stdUnorderedMap< vtkIdType, int64_t > mesh3DIdxToGlobalId; + mesh3DIdxToGlobalId.reserve( cells3DIndices.size() ); + + for( localIndex i = 0; i < cells3DIndices.size(); ++i ) + { + vtkIdType const origIdx = cells3DIndices[i]; + int64_t const globalId = static_cast< int64_t >( meshGlobalCellIds->GetTuple1( origIdx ) ); + mesh3DIdxToGlobalId.emplace( origIdx, globalId ); + } + + // ----------------------------------------------------------------------- + // Step 2: Build node-to-3D-cell connectivity for the original mesh + // ----------------------------------------------------------------------- + stdMap< vtkIdType, std::set< vtkIdType > > nodeGlobalIdToCells3D; + + vtkSmartPointer< vtkIdList > const ptIds = vtkSmartPointer< vtkIdList >::New(); + for( localIndex i = 0; i < cells3DIndices.size(); ++i ) + { + vtkIdType const origCellIdx = cells3DIndices[i]; + originalMesh.GetCellPoints( origCellIdx, ptIds ); + + for( vtkIdType p = 0; p < ptIds->GetNumberOfIds(); ++p ) + { + vtkIdType const nodeLocalId = ptIds->GetId( p ); + vtkIdType const nodeGlobalId = static_cast< vtkIdType >( meshGlobalNodeIds->GetTuple1( nodeLocalId ) ); + + nodeGlobalIdToCells3D.get_inserted( nodeGlobalId ).insert( origCellIdx ); + } + } + + // ----------------------------------------------------------------------- + // Step 3: Build collocated nodes for fracture mesh + // ----------------------------------------------------------------------- + CollocatedNodes collocatedNodes( "fracture", fractureMesh, false ); + + // ----------------------------------------------------------------------- + // Step 4: Build fracture-to-3D neighbor mapping + // ----------------------------------------------------------------------- + ArrayOfArrays< localIndex, int64_t > result; + result.reserve( numFractureElems ); + + vtkSmartPointer< vtkIdList > const fracPtIds = vtkSmartPointer< vtkIdList >::New(); + for( vtkIdType fracElemIdx = 0; fracElemIdx < numFractureElems; ++fracElemIdx ) + { + fractureMesh->GetCellPoints( fracElemIdx, fracPtIds ); + + // Find matching 3D cells using exact node matching + stdVector< vtkIdType > matchingOriginalCells = findMatchingCellsForFractureElement( + fracPtIds, + collocatedNodes, + nodeGlobalIdToCells3D ); + + // Convert original mesh indices to global cell IDs + array1d< int64_t > neighbor3DGlobalIds; + neighbor3DGlobalIds.reserve( matchingOriginalCells.size() ); + + for( vtkIdType origCellIdx : matchingOriginalCells ) + { + auto it = mesh3DIdxToGlobalId.find( origCellIdx ); + if( it != mesh3DIdxToGlobalId.end() ) + { + neighbor3DGlobalIds.emplace_back( it->second ); + } + } + + // Error on orphaned fractures + GEOS_ERROR_IF( neighbor3DGlobalIds.empty(), + GEOS_FMT( "Fracture element {} has no 3D neighbors", fracElemIdx ) ); + + result.appendArray( neighbor3DGlobalIds.begin(), neighbor3DGlobalIds.end() ); + } + + return result; +} + vtkSmartPointer< vtkUnstructuredGrid > threshold( vtkDataSet & mesh, @@ -1347,7 +1727,7 @@ redistributeByAreaGraphAndLayer( AllMeshes & input, if( haveLayer0 ) { AllMeshes layer0input( layer0, {} ); // fracture mesh not supported yet - layer0Parts = partitionByCellGraph( layer0input, method, subComm, numPartA, 3, numRefinements ); + layer0Parts = partitionByCellGraph( layer0input.getMainMesh(), method, subComm, numPartA, 3, numRefinements ); MpiWrapper::commFree( subComm ); } @@ -1656,6 +2036,7 @@ redistributeMeshes( integer const logLevel, MPI_Comm const comm, PartitionMethod const method, int const partitionRefinement, + int const partitionFractureWeight, int const useGlobalIds, string const & structuredIndexAttributeName, int const numPartZ ) @@ -1679,11 +2060,25 @@ redistributeMeshes( integer const logLevel, mesh = vtkSmartPointer< vtkUnstructuredGrid >::New(); } + // Verify fractures are on rank 0 + if( rank != 0 ) + { + for( auto const & [name, fracture]: namesToFractures ) + { + GEOS_UNUSED_VAR( name ); + GEOS_ASSERT_EQ( fracture->GetNumberOfCells(), 0 ); + } + } + + // ----------------------------------------------------------------------- // Step 1: Classify cells by dimension + // ----------------------------------------------------------------------- array1d< vtkIdType > cells3DIndices, cells2DIndices; classifyCellsByDimension( *mesh, cells3DIndices, cells2DIndices ); + // ----------------------------------------------------------------------- // Step 2: Build 2D-to-3D neighbor mapping + // ----------------------------------------------------------------------- ArrayOfArrays< localIndex, int64_t > neighbors2Dto3D; if( !cells2DIndices.empty() ) { @@ -1692,60 +2087,188 @@ redistributeMeshes( integer const logLevel, cells3DIndices.toViewConst() ); } - // Step 3: Extract and redistribute 3D cells (+ fractures) - vtkIdType const minCellsOnAnyRank = MpiWrapper::min( static_cast< vtkIdType >( cells3DIndices.size() ), comm ); + // ----------------------------------------------------------------------- + // Step 3: Build fracture-to-3D neighbor mappings + // ----------------------------------------------------------------------- + stdMap< string, ArrayOfArrays< localIndex, int64_t > > fractureNeighbors; + stdVector< string > fractureNames; - AllMeshes result3DAndFractures; + // Collect fracture names on rank 0 + if( rank == 0 ) + { + for( auto const & [fractureName, fractureMesh]: namesToFractures ) + { + fractureNames.push_back( fractureName ); + } + } - if( minCellsOnAnyRank == 0 ) + // Broadcast fracture names to all ranks { - // Extract 3D cells for initial redistribution - vtkSmartPointer< vtkUnstructuredGrid > cells3D = extractCellsByIndices( *mesh, cells3DIndices.toViewConst() ); + int numFractures = LvArray::integerConversion< int >( fractureNames.size() ); + MpiWrapper::broadcast( numFractures, 0, comm ); - // Redistribute the 3D mesh over all ranks using simple octree partitions - vtkSmartPointer< vtkDataSet > redistributed3D = redistributeByKdTree( *cells3D ); + if( rank != 0 ) + { + fractureNames.resize( numFractures ); + } - // Check if a rank does not have a cell after the redistribution - if( MpiWrapper::min( redistributed3D->GetNumberOfCells(), comm ) == 0 ) + for( string & name : fractureNames ) { - redistributed3D = ensureNoEmptyRank( redistributed3D, comm ); + MpiWrapper::broadcast( name, 0, comm ); } + } - result3DAndFractures.setMainMesh( redistributed3D ); - result3DAndFractures.setFaceBlocks( namesToFractures ); + // Initialize empty neighbor arrays + for( auto const & fractureName : fractureNames ) + { + fractureNeighbors.get_inserted( fractureName ).resize( 0, 0 ); } - else + + // Build actual neighbors only on rank 0 + if( rank == 0 ) + { + for( auto const & [fractureName, fractureMesh]: namesToFractures ) + { + if( fractureMesh && fractureMesh->GetNumberOfCells() > 0 ) + { + fractureNeighbors[fractureName] = buildFractureTo3DNeighbors( + *mesh, + fractureMesh, + cells3DIndices.toViewConst() ); + } + } + } + + // ----------------------------------------------------------------------- + // Step 4: Extract cells and tag super-cells + // ----------------------------------------------------------------------- + SuperCellInfo superCellInfo; + bool hasSuperCells = false; + + vtkSmartPointer< vtkUnstructuredGrid > cells3D = extractCellsByIndices( *mesh, cells3DIndices ); + + if( rank == 0 && !fractureNames.empty() ) + { + superCellInfo = tagCellsWithSuperCellIds( cells3D, fractureNeighbors, partitionFractureWeight ); + + // Verify SuperCellId array was actually created + vtkIdTypeArray * scArray = + vtkIdTypeArray::SafeDownCast( cells3D->GetCellData()->GetArray( "SuperCellId" ) ); + hasSuperCells = (scArray != nullptr); + + if( hasSuperCells ) + { + GEOS_LOG_RANK_0( GEOS_FMT( "Tagged {} super-cells from fracture connectivity", + superCellInfo.atomicSuperCells.size() )); + } + } + + // Broadcast whether we have super-cells { - // Extract 3D cells for partitioning - vtkSmartPointer< vtkUnstructuredGrid > cells3D = extractCellsByIndices( *mesh, cells3DIndices.toViewConst() ); - result3DAndFractures.setMainMesh( cells3D ); - result3DAndFractures.setFaceBlocks( namesToFractures ); + int hasSuperCellsInt = hasSuperCells ? 1 : 0; + MpiWrapper::broadcast( hasSuperCellsInt, 0, comm ); + hasSuperCells = (hasSuperCellsInt > 0); } - // Fine-tune redistribution using higher-quality graph partitioner - if( !structuredIndexAttributeName.empty() ) + // ----------------------------------------------------------------------- + // Step 5: Initial redistribution of 3D cells + // ----------------------------------------------------------------------- + vtkIdType const minCellsOnAnyRank = MpiWrapper::min( cells3D->GetNumberOfCells(), comm ); + + vtkSmartPointer< vtkDataSet > redistributed3D; + + if( minCellsOnAnyRank == 0 ) { - result3DAndFractures = redistributeByAreaGraphAndLayer( result3DAndFractures, - method, - structuredIndexAttributeName, - comm, - numPartZ, - partitionRefinement - 1 ); + if( hasSuperCells ) + { + redistributed3D = redistributeBySuperCellBlocks( cells3D, comm ); + } + else + { + GEOS_LOG_RANK_0( "Initial redistribution using KD-tree..." ); + redistributed3D = redistributeByKdTree( *cells3D ); + + if( MpiWrapper::min( redistributed3D->GetNumberOfCells(), comm ) == 0 ) + { + redistributed3D = ensureNoEmptyRank( redistributed3D, comm ); + } + } } - else if( partitionRefinement > 0 ) + else { - result3DAndFractures = redistributeByCellGraph( result3DAndFractures, method, comm, partitionRefinement - 1 ); + // All ranks already have cells - no redistribution needed + redistributed3D = cells3D; } - // Step 4: Redistribute 2D cells and merge with 3D - AllMeshes finalResult = redistribute2DAndMergeWith3D( result3DAndFractures.getMainMesh(), - mesh, - cells2DIndices.toViewConst(), - neighbors2Dto3D, - result3DAndFractures.getFaceBlocks(), - comm ); + // Check all ranks have cells after redistribution + GEOS_ERROR_IF( redistributed3D->GetNumberOfCells() == 0, "Rank has no cells after initial redistribution." ); - // Step 5: Final logging + + // ----------------------------------------------------------------------- + // Step 6: Refined partitioning + // ----------------------------------------------------------------------- + if( partitionRefinement > 0 ) + { + if( hasSuperCells ) + { + GEOS_LOG_RANK_0( "Refining partition with super-cell constraints..." ); + + redistributed3D = redistributeBySuperCellGraph( + redistributed3D, + method, + comm, + partitionRefinement - 1, + partitionFractureWeight ); + } + else if( !structuredIndexAttributeName.empty() ) + { + // Use structured mesh layered partitioning (no fractures/super-cells) + GEOS_LOG_RANK_0( "Refining partition with structured mesh layers..." ); + + // Wrap in AllMeshes for compatibility with redistributeByAreaGraphAndLayer + AllMeshes tempWrapper; + tempWrapper.setMainMesh( redistributed3D ); + tempWrapper.setFaceBlocks( stdMap< string, vtkSmartPointer< vtkDataSet > >() ); // Empty fractures + + tempWrapper = redistributeByAreaGraphAndLayer( + tempWrapper, + method, + structuredIndexAttributeName, + comm, + numPartZ, + partitionRefinement - 1 ); + + redistributed3D = tempWrapper.getMainMesh(); + } + else + { + // Use standard cell graph partitioning + GEOS_LOG_RANK_0( "Refining partition with standard cell graph..." ); + + redistributed3D = redistributeByCellGraph( + redistributed3D, + method, + comm, + partitionRefinement - 1 ); + } + } + + // ----------------------------------------------------------------------- + // Step 7: Merge 2D cells and fractures back with redistributed 3D cells + // ----------------------------------------------------------------------- + AllMeshes finalResult = redistribute2DAndMergeWith3D( + redistributed3D, + mesh, + cells2DIndices.toViewConst(), + neighbors2Dto3D, + namesToFractures, + fractureNeighbors, + fractureNames, + comm ); + + // ----------------------------------------------------------------------- + // Step 8: Final logging + // ----------------------------------------------------------------------- if( logLevel >= 5 ) { vtkIdType local2DCells = 0; @@ -1799,6 +2322,7 @@ redistributeMeshes( integer const logLevel, return finalResult; } + /** * @brief Identify the GEOSX type of the polyhedron * diff --git a/src/coreComponents/mesh/generators/VTKUtilities.hpp b/src/coreComponents/mesh/generators/VTKUtilities.hpp index ef660d7641c..a0181fbfd8b 100644 --- a/src/coreComponents/mesh/generators/VTKUtilities.hpp +++ b/src/coreComponents/mesh/generators/VTKUtilities.hpp @@ -35,6 +35,7 @@ namespace geos { namespace vtk { +class CollocatedNodes; /** * @brief Choice of advanced mesh partitioner @@ -152,6 +153,7 @@ findNeighborRanks( stdVector< vtkBoundingBox > boundingBoxes ); * @param[in] comm the MPI communicator * @param[in] method the partitioning method * @param[in] partitionRefinement number of graph partitioning refinement cycles + * @param[in] partitionFractureWeight additional weight to fracture-connected super-cells during partitioning * @param[in] useGlobalIds controls whether global id arrays from the vtk input should be used * @param[in] structuredIndexAttributeName VTK array name for structured index attribute, if present * @param[in] numPartZ number of MPI partitions in Z direction (only if @p structuredIndexAttributeName is used) @@ -164,6 +166,7 @@ redistributeMeshes( integer const logLevel, MPI_Comm const comm, PartitionMethod const method, int const partitionRefinement, + int const partitionFractureWeight, int const useGlobalIds, string const & structuredIndexAttributeName, int const numPartZ ); @@ -243,6 +246,22 @@ void importRegularField( stdVector< vtkIdType > const & cellIds, void importRegularField( vtkDataArray * vtkArray, dataRepository::WrapperBase & wrapper ); +/** + * @brief Find 3D cells whose faces exactly match a fracture element. + * + * A 3D cell matches if it has a face that shares all nodes with the fracture element, + * accounting for collocated nodes at split interfaces. + * + * @param fractureNodeIds Local node IDs of the fracture element + * @param collocatedNodes Mapping from local node ID to all collocated global IDs + * @param nodesToCells Reverse map from global node ID to cells containing that node + * @return Global IDs of matching 3D cells (typically 0-2 neighbors for fractures) + */ +stdVector< vtkIdType > findMatchingCellsForFractureElement( + vtkIdList * fractureNodeIds, + CollocatedNodes const & collocatedNodes, + stdMap< vtkIdType, std::set< vtkIdType > > const & nodesToCells ); + } // namespace vtk diff --git a/src/coreComponents/schema/schema.xsd b/src/coreComponents/schema/schema.xsd index 8a586eebe36..00589e978ab 100644 --- a/src/coreComponents/schema/schema.xsd +++ b/src/coreComponents/schema/schema.xsd @@ -2095,6 +2095,8 @@ Information output from lower logLevels is added with the desired log level + + @@ -2225,7 +2227,7 @@ Information output from lower logLevels is added with the desired log level - + From 1a1a4797e6d331b0269a64405e3820de7ba29a30 Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Wed, 20 May 2026 15:48:37 +0200 Subject: [PATCH 43/53] move formatter() into the .cpp --- src/coreComponents/common/logger/StackTrace.cpp | 8 ++++++-- src/coreComponents/common/logger/StackTrace.hpp | 6 ------ 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/src/coreComponents/common/logger/StackTrace.cpp b/src/coreComponents/common/logger/StackTrace.cpp index 1fa59d0be60..5c9e5d80b69 100644 --- a/src/coreComponents/common/logger/StackTrace.cpp +++ b/src/coreComponents/common/logger/StackTrace.cpp @@ -34,7 +34,7 @@ namespace geos std::string StackTrace::stackTrace() { #ifdef GEOS_USE_CPPTRACE - return formatter().format( cpptrace::generate_trace( /* skip = */ 1 ) ); + return formatStackTrace( cpptrace::generate_trace( /* skip = */ 1 ) ); #else return LvArray::system::stackTrace( true ); #endif @@ -46,7 +46,11 @@ std::string StackTrace::signalSafeStackTrace() } #ifdef GEOS_USE_CPPTRACE -cpptrace::formatter const & StackTrace::formatter() +/** + * @brief Access the configured cpptrace formatter. + * @return The formatter instance. + */ +static cpptrace::formatter const & formatter() { static cpptrace::formatter const fmt = cpptrace::formatter{} .header( "" ) diff --git a/src/coreComponents/common/logger/StackTrace.hpp b/src/coreComponents/common/logger/StackTrace.hpp index 04d04978431..7fcfd08a21b 100644 --- a/src/coreComponents/common/logger/StackTrace.hpp +++ b/src/coreComponents/common/logger/StackTrace.hpp @@ -53,12 +53,6 @@ class StackTrace static std::string signalSafeStackTrace(); #ifdef GEOS_USE_CPPTRACE - /** - * @brief Access the configured cpptrace formatter. - * @return The formatter instance. - */ - static cpptrace::formatter const & formatter(); - /** * @brief Format a cpptrace stacktrace using the configured formatter. * @param stacktrace The cpptrace stack trace to format. From 146f3f42ae15aae2cc85cc6d8a1ed5d3fb7a2939 Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Wed, 20 May 2026 15:49:07 +0200 Subject: [PATCH 44/53] use the cpptrace forward declared (light) header --- src/coreComponents/common/logger/StackTrace.hpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/coreComponents/common/logger/StackTrace.hpp b/src/coreComponents/common/logger/StackTrace.hpp index 7fcfd08a21b..5162d9584fe 100644 --- a/src/coreComponents/common/logger/StackTrace.hpp +++ b/src/coreComponents/common/logger/StackTrace.hpp @@ -22,8 +22,7 @@ #include "common/GeosxConfig.hpp" // For the following guards #ifdef GEOS_USE_CPPTRACE -#include -#include +#include #endif #include From 5c790b63e06aecc69da69f161cf4868f4ce84c7c Mon Sep 17 00:00:00 2001 From: Bertrand Denel <120652669+bd713@users.noreply.github.com> Date: Thu, 21 May 2026 10:48:29 -0700 Subject: [PATCH 45/53] fix: Fix RLF coloring (#3814) * Switched to size_t, adressed reviews. * Fixed sequential mode * Limit parallel test to 4 ranks * zoltan int * Missing size_t * Included extended neighbors for coloring * Uncrustify * container * random graph test * rebaseline --------- Co-authored-by: DENEL Bertrand Co-authored-by: Omar Duran Co-authored-by: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 3 + src/coreComponents/common/MpiWrapper.hpp | 2 +- .../mesh/graphs/GraphColoringBase.cpp | 29 +++-- .../mesh/graphs/GraphColoringBase.hpp | 19 ++- src/coreComponents/mesh/graphs/GraphTools.cpp | 64 +++++----- src/coreComponents/mesh/graphs/GraphTools.hpp | 14 +-- .../mesh/graphs/GraphToolsMPI.cpp | 48 ++++---- .../mesh/graphs/GraphToolsMPI.hpp | 21 ++-- .../mesh/graphs/RLFGraphColoring.cpp | 113 +++++++++++------- .../mesh/graphs/RLFGraphColoring.hpp | 10 +- .../mesh/graphs/RLFGraphColoringMPI.cpp | 44 +++---- .../mesh/graphs/RLFGraphColoringMPI.hpp | 8 +- .../mesh/graphs/ZoltanGraphColoring.cpp | 36 ++++-- .../mesh/graphs/ZoltanGraphColoring.hpp | 14 +-- .../mpiCommunications/SpatialPartition.cpp | 45 ++++--- .../mpiCommunications/SpatialPartition.hpp | 18 +++ .../mesh/unitTests/CMakeLists.txt | 2 +- .../mesh/unitTests/testGraphColoring.cpp | 30 ++--- .../mesh/unitTests/testGraphColoringMPI.cpp | 32 ++--- 20 files changed, 304 insertions(+), 250 deletions(-) diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index 460e76c7fbb..428d43f1d7c 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr4008-16688-17c55fe + baseline: integratedTests/baseline_integratedTests-pr3814-16717-d17ea59 allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index 57232417cad..4daa1929dda 100644 --- a/BASELINE_NOTES.md +++ b/BASELINE_NOTES.md @@ -5,6 +5,9 @@ This file is designed to track changes to the integrated test baselines. Any developer who updates the baseline ID in the .integrated_tests.yaml file is expected to create an entry in this file with the pull request number, date, and their justification for rebaselining. These notes should be in reverse-chronological order, and use the following time format: (YYYY-MM-DD). +PR #3814 (2026-05-20) +Fix RLF coloring + PR #4008 (2026-05-18) Fix Fracture/3D cell co-location in parallel mesh redistribution diff --git a/src/coreComponents/common/MpiWrapper.hpp b/src/coreComponents/common/MpiWrapper.hpp index bb5bca75954..30e65f896c0 100644 --- a/src/coreComponents/common/MpiWrapper.hpp +++ b/src/coreComponents/common/MpiWrapper.hpp @@ -1307,7 +1307,7 @@ int MpiWrapper::scatterv( TS const * const sendbuf, #else static_assert( std::is_same< TS, TR >::value, "MpiWrapper::scatterv() for serial run requires send and receive buffers are of the same type" ); - std::size_t const sendBufferSize = sendcounts * sizeof(TS); + std::size_t const sendBufferSize = sendcounts[0] * sizeof(TS); std::size_t const recvBufferSize = recvcount * sizeof(TR); GEOS_ERROR_IF_NE_MSG( sendBufferSize, recvBufferSize, "size of send buffer and receive buffer are not equal" ); memcpy( recvbuf, sendbuf, sendBufferSize ); diff --git a/src/coreComponents/mesh/graphs/GraphColoringBase.cpp b/src/coreComponents/mesh/graphs/GraphColoringBase.cpp index a8ae234dc81..857dfcc1cee 100644 --- a/src/coreComponents/mesh/graphs/GraphColoringBase.cpp +++ b/src/coreComponents/mesh/graphs/GraphColoringBase.cpp @@ -27,16 +27,15 @@ namespace geos namespace graph { -bool GraphColoringBase::isColoringValid( const std::vector< camp::idx_t > & xadj, - const std::vector< camp::idx_t > & adjncy, - const std::vector< int > & coloring ) +bool GraphColoringBase::isColoringValid( const stdVector< size_t > & xadj, + const stdVector< size_t > & adjncy, + const stdVector< int > & coloring ) { for( size_t node = 0; node < coloring.size(); ++node ) { int node_color = coloring[node]; - std::unordered_set< camp::idx_t > neighbors = getGraphNodeNeighbors( node, xadj, adjncy ); - - for( camp::idx_t neighbor : neighbors ) + std::unordered_set< size_t > neighbors = getGraphNodeNeighbors( node, xadj, adjncy ); + for( size_t neighbor : neighbors ) { if( coloring[neighbor] == node_color ) { @@ -48,7 +47,7 @@ bool GraphColoringBase::isColoringValid( const std::vector< camp::idx_t > & xadj } -size_t GraphColoringBase::getNumberOfColors( const std::vector< int > & colors ) +size_t GraphColoringBase::getNumberOfColors( const stdVector< int > & colors ) { std::unordered_set< int > uniqueColors; for( int color : colors ) @@ -63,7 +62,7 @@ size_t GraphColoringBase::getNumberOfColors( const std::vector< int > & colors ) // Assume only one node per rank. -bool GraphColoringBase::isColoringValid( const std::vector< camp::idx_t > & adjncy, +bool GraphColoringBase::isColoringValid( const stdVector< size_t > & adjncy, const int color, MPI_Comm comm ) { @@ -74,7 +73,7 @@ bool GraphColoringBase::isColoringValid( const std::vector< camp::idx_t > & adjn // 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 ); + stdVector< int > allColors( size ); MpiWrapper::allgather( &color, 1, allColors.data(), 1, comm ); // Check for color conflicts with each listed neighbor. @@ -97,27 +96,27 @@ bool GraphColoringBase::isColoringValid( const std::vector< camp::idx_t > & adjn size_t GraphColoringBase::getNumberOfColors( const int color, MPI_Comm comm ) { - std::vector< int > colors = {color}; + stdVector< int > colors = {color}; return getNumberOfColors( colors, comm ); } -size_t GraphColoringBase::getNumberOfColors( const std::vector< int > & colors, MPI_Comm comm ) +size_t GraphColoringBase::getNumberOfColors( const stdVector< int > & colors, MPI_Comm comm ) { int const rank = MpiWrapper::commRank( comm ); int const size = MpiWrapper::commSize( comm ); std::set< int > localDistinctColors = std::set< int >( colors.begin(), colors.end()); - std::vector< int > localDistinctColorsVector( localDistinctColors.begin(), localDistinctColors.end()); + stdVector< int > localDistinctColorsVector( localDistinctColors.begin(), localDistinctColors.end()); int const localSize = localDistinctColorsVector.size(); // Gather the sizes of the local color vectors from all ranks - std::vector< int > allSizes( size ); + stdVector< int > allSizes( size ); MpiWrapper::gather( &localSize, 1, allSizes.data(), 1, 0, comm ); // Calculate the total number of colors and the displacements for gathering int totalSize = 0; - std::vector< int > displacements( size, 0 ); + stdVector< int > displacements( size, 0 ); if( rank == 0 ) { for( int i = 0; i < size; ++i ) @@ -128,7 +127,7 @@ size_t GraphColoringBase::getNumberOfColors( const std::vector< int > & colors, } // Gather all colors from all ranks to rank 0 - std::vector< int > allColors( totalSize ); + stdVector< int > allColors( totalSize ); MpiWrapper::gatherv( localDistinctColorsVector.data(), localSize, allColors.data(), allSizes.data(), displacements.data(), 0, comm ); diff --git a/src/coreComponents/mesh/graphs/GraphColoringBase.hpp b/src/coreComponents/mesh/graphs/GraphColoringBase.hpp index 2b8242c70cf..5994be4fcd2 100644 --- a/src/coreComponents/mesh/graphs/GraphColoringBase.hpp +++ b/src/coreComponents/mesh/graphs/GraphColoringBase.hpp @@ -34,8 +34,8 @@ namespace graph * @class GraphColoringBase * @brief Abstract base class for graph coloring strategies. * - * Provides a common interface for graph coloring algorithms used in GEOS. - * Derived classes must implement the coloring logic for adjacency graphs. + * Provides a common interface for graph coloring algorithms used in GEOS. Derived classes must implement the coloring logic for adjacency + * graphs. */ class GraphColoringBase { @@ -54,14 +54,14 @@ class GraphColoringBase * @param adjncy Adjacency list containing neighbors of each node. * @return A vector of colors assigned to each node. */ - virtual std::vector< int > colorGraph( const std::vector< camp::idx_t > & xadj, const std::vector< camp::idx_t > & adjncy ) = 0; + virtual stdVector< int > colorGraph( const stdVector< size_t > & xadj, const stdVector< size_t > & adjncy ) = 0; /** * @brief Pure virtual method to color a graph assuming one node per rank. * @param adjncy Adjacency list containing neighbors of each node. * @return Color of the node. */ - virtual int colorGraph( const std::vector< camp::idx_t > & adjncy ) = 0; + virtual int colorGraph( const stdVector< size_t > & adjncy ) = 0; /** @@ -81,7 +81,7 @@ class GraphColoringBase * @param coloring A vector where the index represents the node and the value represents the assigned color.* * @return True if the coloring is valid, false otherwise. */ - static bool isColoringValid( const std::vector< camp::idx_t > & xadj, const std::vector< camp::idx_t > & adjncy, const std::vector< int > & coloring ); + static bool isColoringValid( const stdVector< size_t > & xadj, const stdVector< size_t > & adjncy, const stdVector< int > & coloring ); /** * @brief Checks the validity of the graph coloring assuming one node per rank. @@ -92,18 +92,17 @@ class GraphColoringBase * * @return True if the coloring is valid, false otherwise. */ - static bool isColoringValid( const std::vector< camp::idx_t > & adjncy, const int color, MPI_Comm comm ); + static bool isColoringValid( const stdVector< size_t > & adjncy, const int color, MPI_Comm comm ); /** * @brief Counts the number of distinct colors. * - * This function takes a vector of integers representing colors - * and returns the number of distinct (positive) colors present in the vector. + * This function takes a vector of integers representing colors and returns the number of distinct (positive) colors present in the vector. * * @param colors A vector of integers representing colors. * @return The number of distinct colors in the vector. */ - static size_t getNumberOfColors( const std::vector< int > & colors ); + static size_t getNumberOfColors( const stdVector< int > & colors ); /** * @brief Counts the number of distinct colors (parallel version). @@ -111,7 +110,7 @@ class GraphColoringBase * @param comm MPI communicator. * @return Number of distinct colors. */ - static size_t getNumberOfColors( const std::vector< int > & colors, MPI_Comm comm ); + static size_t getNumberOfColors( const stdVector< int > & colors, MPI_Comm comm ); /** * @brief Counts the number of distinct colors assuming one node per rank (parallel version). diff --git a/src/coreComponents/mesh/graphs/GraphTools.cpp b/src/coreComponents/mesh/graphs/GraphTools.cpp index 84b5f287591..e232b0a9e6c 100644 --- a/src/coreComponents/mesh/graphs/GraphTools.cpp +++ b/src/coreComponents/mesh/graphs/GraphTools.cpp @@ -29,16 +29,16 @@ namespace geos namespace graph { -size_t getGraphNodeDegree( idx_t node, const std::vector< idx_t > & xadj ) +size_t getGraphNodeDegree( size_t node, const stdVector< size_t > & xadj ) { return xadj[node + 1] - xadj[node]; } -std::unordered_set< idx_t > getGraphNodeNeighbors( idx_t node, const std::vector< idx_t > & xadj, const std::vector< idx_t > & adjncy ) +std::unordered_set< size_t > getGraphNodeNeighbors( size_t node, const stdVector< size_t > & xadj, const stdVector< size_t > & adjncy ) { - std::unordered_set< idx_t > neighbors; - for( idx_t i = xadj[node]; i < xadj[node + 1]; ++i ) + std::unordered_set< size_t > neighbors; + for( size_t i = xadj[node]; i < xadj[node + 1]; ++i ) { neighbors.insert( adjncy[i] ); } @@ -46,17 +46,17 @@ std::unordered_set< idx_t > getGraphNodeNeighbors( idx_t node, const std::vector } -bool isGraphValid( const std::vector< idx_t > & xadj, - const std::vector< idx_t > & adjncy ) +bool isGraphValid( const stdVector< size_t > & xadj, + const stdVector< size_t > & adjncy ) { - idx_t num_nodes = xadj.size() - 1; + size_t num_nodes = xadj.size() - 1; - for( idx_t i = 0; i < num_nodes; ++i ) + for( size_t i = 0; i < num_nodes; ++i ) { - std::unordered_set< idx_t > neighbors; - for( idx_t j = xadj[i]; j < xadj[i + 1]; ++j ) + std::unordered_set< size_t > neighbors; + for( size_t j = xadj[i]; j < xadj[i + 1]; ++j ) { - idx_t neighbor = adjncy[j]; + size_t neighbor = adjncy[j]; // Check for out-of-bounds indices if( neighbor >= num_nodes ) @@ -75,7 +75,7 @@ bool isGraphValid( const std::vector< idx_t > & xadj, // Check for bidirectional connection bool bidirectional = false; - for( idx_t k = xadj[neighbor]; k < xadj[neighbor + 1]; ++k ) + for( size_t k = xadj[neighbor]; k < xadj[neighbor + 1]; ++k ) { if( adjncy[k] == i ) { @@ -95,9 +95,9 @@ bool isGraphValid( const std::vector< idx_t > & xadj, } -std::tuple< std::vector< idx_t >, std::vector< idx_t > > generateGraphRandom( size_t numVertices, size_t numEdges ) +std::tuple< stdVector< size_t >, stdVector< size_t > > generateGraphRandom( size_t numVertices, size_t numEdges ) { - std::vector< std::pair< size_t, size_t > > edges; + stdVector< std::pair< size_t, size_t > > edges; srand( static_cast< unsigned int >(time( 0 ))); // Generate random edges @@ -116,8 +116,8 @@ std::tuple< std::vector< idx_t >, std::vector< idx_t > > generateGraphRandom( si std::sort( edges.begin(), edges.end()); // Initialize xadj and adjncy - std::vector< idx_t > xadj( numVertices + 1, 0 ); - std::vector< idx_t > adjncy; + stdVector< size_t > xadj( numVertices + 1, 0 ); + stdVector< size_t > adjncy; adjncy.reserve( edges.size()); // Fill xadj and adjncy @@ -142,25 +142,25 @@ std::tuple< std::vector< idx_t >, std::vector< idx_t > > generateGraphRandom( si } -std::tuple< std::vector< idx_t >, std::vector< idx_t > > generateGraphCartPartitionning3D( idx_t nx, idx_t ny, idx_t nz, const std::vector< std::array< int, 3 > > & neighbor_offsets ) +std::tuple< stdVector< size_t >, stdVector< size_t > > generateGraphCartPartitioning3D( size_t nx, size_t ny, size_t nz, const stdVector< stdArray< int, 3 > > & neighbor_offsets ) { - idx_t num_nodes = nx * ny * nz; - std::vector< idx_t > xadj( num_nodes + 1, 0 ); - std::vector< idx_t > adjncy; + size_t num_nodes = nx * ny * nz; + stdVector< size_t > xadj( num_nodes + 1, 0 ); + stdVector< size_t > adjncy; - auto getNodeIndex = [nx, ny] ( const idx_t x, const idx_t y, const idx_t z ) + auto getNodeIndex = [nx, ny] ( const size_t x, const size_t y, const size_t z ) { return x + nx * (y + ny * z); }; - idx_t node_counter = 0; - for( idx_t z = 0; z < nz; ++z ) + size_t node_counter = 0; + for( size_t z = 0; z < nz; ++z ) { - for( idx_t y = 0; y < ny; ++y ) + for( size_t y = 0; y < ny; ++y ) { - for( idx_t x = 0; x < nx; ++x ) + for( size_t x = 0; x < nx; ++x ) { - std::vector< idx_t > neighbors; + stdVector< size_t > neighbors; for( const auto & offset : neighbor_offsets ) { @@ -186,17 +186,17 @@ std::tuple< std::vector< idx_t >, std::vector< idx_t > > generateGraphCartPartit return {xadj, adjncy}; } -std::tuple< std::vector< idx_t >, std::vector< idx_t > > generateGraphCartPartitionning3D6( idx_t nx, idx_t ny, idx_t nz ) +std::tuple< stdVector< size_t >, stdVector< size_t > > generateGraphCartPartitioning3D6( size_t nx, size_t ny, size_t nz ) { - std::vector< std::array< int, 3 > > neighbor_offsets = { + stdVector< stdArray< int, 3 > > neighbor_offsets = { {-1, 0, 0}, {1, 0, 0}, {0, -1, 0}, {0, 1, 0}, {0, 0, -1}, {0, 0, 1} }; - return generateGraphCartPartitionning3D( nx, ny, nz, neighbor_offsets ); + return generateGraphCartPartitioning3D( nx, ny, nz, neighbor_offsets ); } -std::tuple< std::vector< idx_t >, std::vector< idx_t > > generateGraphCartPartitionning3D26( idx_t nx, idx_t ny, idx_t nz ) +std::tuple< stdVector< size_t >, stdVector< size_t > > generateGraphCartPartitioning3D26( size_t nx, size_t ny, size_t nz ) { - std::vector< std::array< int, 3 > > neighbor_offsets; + stdVector< stdArray< int, 3 > > neighbor_offsets; for( int dz = -1; dz <= 1; ++dz ) { for( int dy = -1; dy <= 1; ++dy ) @@ -210,7 +210,7 @@ std::tuple< std::vector< idx_t >, std::vector< idx_t > > generateGraphCartPartit } } } - return generateGraphCartPartitionning3D( nx, ny, nz, neighbor_offsets ); + return generateGraphCartPartitioning3D( nx, ny, nz, neighbor_offsets ); } diff --git a/src/coreComponents/mesh/graphs/GraphTools.hpp b/src/coreComponents/mesh/graphs/GraphTools.hpp index 0aa09887889..ccc699b2e81 100644 --- a/src/coreComponents/mesh/graphs/GraphTools.hpp +++ b/src/coreComponents/mesh/graphs/GraphTools.hpp @@ -31,8 +31,6 @@ namespace geos namespace graph { -using camp::idx_t; - /** * @brief Validates the graph based on the given criteria. * @@ -45,7 +43,7 @@ using camp::idx_t; * @param adjncy The adjacency list containing the neighbors of each node. * @return True if the graph meets all criteria, false otherwise. */ -bool isGraphValid( const std::vector< idx_t > & xadj, const std::vector< idx_t > & adjncy ); +bool isGraphValid( const stdVector< size_t > & xadj, const stdVector< size_t > & adjncy ); /** * @brief Calculates the degree of a node in the graph. @@ -56,7 +54,7 @@ bool isGraphValid( const std::vector< idx_t > & xadj, const std::vector< idx_t > * @param xadj The adjacency list offsets for each node. * @return The degree of the node. */ -size_t getGraphNodeDegree( idx_t node, const std::vector< idx_t > & xadj ); +size_t getGraphNodeDegree( size_t node, const stdVector< size_t > & xadj ); /** * @brief Retrieves the neighbors of a node in the graph. @@ -68,7 +66,7 @@ size_t getGraphNodeDegree( idx_t node, const std::vector< idx_t > & xadj ); * @param adjncy The adjacency list containing the neighbors of each node. * @return A set of indices representing the neighbors of the node. */ -std::unordered_set< idx_t > getGraphNodeNeighbors( idx_t node, const std::vector< idx_t > & xadj, const std::vector< idx_t > & adjncy ); +std::unordered_set< size_t > getGraphNodeNeighbors( size_t node, const stdVector< size_t > & xadj, const stdVector< size_t > & adjncy ); @@ -81,7 +79,7 @@ std::unordered_set< idx_t > getGraphNodeNeighbors( idx_t node, const std::vector * @param num_edges Number of edges in the graph. * @return A tuple containing xadj and adjncy. */ -std::tuple< std::vector< idx_t >, std::vector< idx_t > > generateGraphRandom( size_t num_nodes, size_t num_edges ); +std::tuple< stdVector< size_t >, stdVector< size_t > > generateGraphRandom( size_t num_nodes, size_t num_edges ); /** * @brief Generates the adjacency list representation (xadj and adjncy) for a Cartesian domain decomposition in 3D. @@ -94,7 +92,7 @@ std::tuple< std::vector< idx_t >, std::vector< idx_t > > generateGraphRandom( si * @param nz Number of divisions along the z-axis. * @return A tuple containing xadj and adjncy. */ -std::tuple< std::vector< idx_t >, std::vector< idx_t > > generateGraphCartPartitionning3D6( idx_t nx, idx_t ny, idx_t nz ); +std::tuple< stdVector< size_t >, stdVector< size_t > > generateGraphCartPartitioning3D6( size_t nx, size_t ny, size_t nz ); /** * @brief Generates the adjacency list representation (xadj and adjncy) for a Cartesian domain decomposition in 3D. @@ -107,7 +105,7 @@ std::tuple< std::vector< idx_t >, std::vector< idx_t > > generateGraphCartPartit * @param nz Number of divisions along the z-axis. * @return A tuple containing xadj and adjncy. */ -std::tuple< std::vector< idx_t >, std::vector< idx_t > > generateGraphCartPartitionning3D26( idx_t nx, idx_t ny, idx_t nz ); +std::tuple< stdVector< size_t >, stdVector< size_t > > generateGraphCartPartitioning3D26( size_t nx, size_t ny, size_t nz ); } // namespace geos diff --git a/src/coreComponents/mesh/graphs/GraphToolsMPI.cpp b/src/coreComponents/mesh/graphs/GraphToolsMPI.cpp index c5206b26dd2..514dac7a6e8 100644 --- a/src/coreComponents/mesh/graphs/GraphToolsMPI.cpp +++ b/src/coreComponents/mesh/graphs/GraphToolsMPI.cpp @@ -26,9 +26,9 @@ namespace geos namespace graph { -std::pair< std::vector< camp::idx_t >, std::vector< camp::idx_t > > -scatterGraphData( const std::vector< camp::idx_t > & xadj, - const std::vector< camp::idx_t > & adjncy, +std::pair< stdVector< size_t >, stdVector< size_t > > +scatterGraphData( const stdVector< size_t > & xadj, + const stdVector< size_t > & adjncy, MPI_Comm comm ) { int const rank = MpiWrapper::commRank( comm ); @@ -40,9 +40,9 @@ scatterGraphData( const std::vector< camp::idx_t > & xadj, GEOS_ASSERT_EQ_MSG( size, static_cast< int >(xadj.size()) - 1, "Number of ranks does not match the size of xadj-1" ); } - std::vector< int > sendCounts; - std::vector< int > displacements; - std::vector< camp::idx_t > xadjToScatter; + stdVector< int > sendCounts; + stdVector< int > displacements; + stdVector< size_t > xadjToScatter; if( rank == 0 ) { @@ -64,13 +64,13 @@ scatterGraphData( const std::vector< camp::idx_t > & xadj, } } - std::vector< camp::idx_t > localXadj( 2 ); // Each rank will have two elements in localXadj: xadj[i] and xadj[i+1] + stdVector< size_t > localXadj( 2 ); // Each rank will have two elements in localXadj: xadj[i] and xadj[i+1] MpiWrapper::scatter( xadjToScatter.data(), 2, localXadj.data(), 2, 0, comm ); int localSize; MpiWrapper::scatter( sendCounts.data(), 1, &localSize, 1, 0, comm ); - std::vector< camp::idx_t > localAdjncy( localSize ); + stdVector< size_t > localAdjncy( localSize ); MpiWrapper::scatterv( adjncy.data(), sendCounts.data(), displacements.data(), localAdjncy.data(), localSize, 0, comm ); @@ -78,9 +78,9 @@ scatterGraphData( const std::vector< camp::idx_t > & xadj, } -std::pair< std::vector< camp::idx_t >, std::vector< camp::idx_t > > -gatherGraphData( const std::vector< camp::idx_t > & localXadj, - const std::vector< camp::idx_t > & localAdjncy, +std::pair< stdVector< size_t >, stdVector< size_t > > +gatherGraphData( const stdVector< size_t > & localXadj, + const stdVector< size_t > & localAdjncy, MPI_Comm comm ) { int const rank = MpiWrapper::commRank( comm ); @@ -90,11 +90,11 @@ gatherGraphData( const std::vector< camp::idx_t > & localXadj, int nCounts = (rank < size - 1) ? static_cast< int >(localXadj.size() - 1) : static_cast< int >(localXadj.size()); // Gather the counts of elements from each rank - std::vector< int > recvCounts( size ); + stdVector< int > recvCounts( size ); MpiWrapper::gather( &nCounts, 1, recvCounts.data(), 1, 0, comm ); // Calculate displacements for the gathered data - std::vector< int > displacements( size ); + stdVector< int > displacements( size ); if( rank == 0 ) { displacements[0] = 0; @@ -105,7 +105,7 @@ gatherGraphData( const std::vector< camp::idx_t > & localXadj, } // Resize the xadj vector on rank 0 to hold the gathered data - std::vector< camp::idx_t > xadj; + stdVector< size_t > xadj; if( rank == 0 ) { int totalSize = std::accumulate( recvCounts.begin(), recvCounts.end(), 0 ); @@ -133,7 +133,7 @@ gatherGraphData( const std::vector< camp::idx_t > & localXadj, } // Resize the adjncy vector on rank 0 to hold the gathered data - std::vector< camp::idx_t > adjncy; + stdVector< size_t > adjncy; if( rank == 0 ) { int totalSize = std::accumulate( recvCounts.begin(), recvCounts.end(), 0 ); @@ -150,21 +150,21 @@ gatherGraphData( const std::vector< camp::idx_t > & localXadj, } -std::vector< camp::idx_t > createXadjFromAdjncy( const std::vector< camp::idx_t > & localAdjncy, MPI_Comm comm ) +stdVector< size_t > createXadjFromAdjncy( const stdVector< size_t > & localAdjncy, MPI_Comm comm ) { int const size = MpiWrapper::commSize( comm ); // Gather the counts of elements from each rank for localAdjncy int localAdjncySize = static_cast< int >(localAdjncy.size()); - std::vector< int > adjncyCounts( size ); + stdVector< int > adjncyCounts( size ); MpiWrapper::allgather( &localAdjncySize, 1, adjncyCounts.data(), 1, comm ); // Calculate xadj - std::vector< camp::idx_t > xadj( size + 1, 0 ); + stdVector< size_t > xadj( size + 1, 0 ); std::partial_sum( adjncyCounts.begin(), adjncyCounts.end(), xadj.begin() + 1 ); // Prepare data to scatter - std::vector< camp::idx_t > xadjToScatter( 2 * size ); + stdVector< size_t > xadjToScatter( 2 * size ); for( int i = 0; i < size; ++i ) { xadjToScatter[2 * i] = xadj[i]; @@ -172,29 +172,29 @@ std::vector< camp::idx_t > createXadjFromAdjncy( const std::vector< camp::idx_t } // Scatter the xadj data - std::vector< camp::idx_t > localXadj( 2 ); + stdVector< size_t > localXadj( 2 ); MpiWrapper::scatter( xadjToScatter.data(), 2, localXadj.data(), 2, 0, comm ); return localXadj; } -std::vector< int > createVertexGlobalID( const std::vector< camp::idx_t > & localXadj, MPI_Comm comm ) +stdVector< int > createVertexGlobalID( const stdVector< size_t > & localXadj, MPI_Comm comm ) { int const rank = MpiWrapper::commRank( comm ); int const size = MpiWrapper::commSize( comm ); int localNumVertices = static_cast< int >(localXadj.size()) - 1; - std::vector< int > allNumVertices( size ); + stdVector< int > allNumVertices( size ); MpiWrapper::allgather( &localNumVertices, 1, allNumVertices.data(), 1, comm ); // Compute displacement for the current rank - std::vector< int > displacements( size, 0 ); + stdVector< int > displacements( size, 0 ); std::partial_sum( allNumVertices.begin(), allNumVertices.end() - 1, displacements.begin() + 1 ); int displacement = displacements[rank]; - std::vector< int > globalID( localNumVertices ); + stdVector< int > globalID( localNumVertices ); std::iota( globalID.begin(), globalID.end(), displacement ); return globalID; diff --git a/src/coreComponents/mesh/graphs/GraphToolsMPI.hpp b/src/coreComponents/mesh/graphs/GraphToolsMPI.hpp index c0f09fe7086..dc1f2274159 100644 --- a/src/coreComponents/mesh/graphs/GraphToolsMPI.hpp +++ b/src/coreComponents/mesh/graphs/GraphToolsMPI.hpp @@ -30,8 +30,6 @@ namespace geos namespace graph { -using camp::idx_t; - /** * @brief Distributes graph data and returns local adjacency lists for each rank. * @@ -44,17 +42,16 @@ using camp::idx_t; * @param comm The MPI communicator (default is MPI_COMM_GEOS). * @return A pair of vectors containing the local adjacency list offsets and neighbors for each rank. */ -std::pair< std::vector< camp::idx_t >, std::vector< camp::idx_t > > -scatterGraphData( const std::vector< camp::idx_t > & xadj, - const std::vector< camp::idx_t > & adjncy, +std::pair< stdVector< size_t >, stdVector< size_t > > +scatterGraphData( const stdVector< size_t > & xadj, + const stdVector< size_t > & adjncy, MPI_Comm comm = MPI_COMM_GEOS ); /** * @brief Gathers distributed graph data from MPI ranks. * - * This function collects local adjacency lists from all ranks and reconstructs - * the global xadj and adjncy arrays. + * This function collects local adjacency lists from all ranks and reconstructs the global xadj and adjncy arrays. * * @param localXadj Local adjacency list offsets. * @param localAdjncy Local adjacency list. @@ -62,9 +59,9 @@ scatterGraphData( const std::vector< camp::idx_t > & xadj, * @return A pair of vectors: global xadj and adjncy. */ -std::pair< std::vector< camp::idx_t >, std::vector< camp::idx_t > > -gatherGraphData( const std::vector< camp::idx_t > & localXadj, - const std::vector< camp::idx_t > & localAdjncy, +std::pair< stdVector< size_t >, stdVector< size_t > > +gatherGraphData( const stdVector< size_t > & localXadj, + const stdVector< size_t > & localAdjncy, MPI_Comm comm= MPI_COMM_GEOS ); @@ -78,7 +75,7 @@ gatherGraphData( const std::vector< camp::idx_t > & localXadj, * @param comm The MPI communicator. * @return The xadj array. */ -std::vector< camp::idx_t > createXadjFromAdjncy( const std::vector< camp::idx_t > & localAdjncy, MPI_Comm comm ); +stdVector< size_t > createXadjFromAdjncy( const stdVector< size_t > & localAdjncy, MPI_Comm comm ); /** @@ -90,7 +87,7 @@ std::vector< camp::idx_t > createXadjFromAdjncy( const std::vector< camp::idx_t * @param comm MPI communicator. * @return A vector of global vertex IDs. */ -std::vector< int > createVertexGlobalID( const std::vector< camp::idx_t > & localXadj, MPI_Comm comm ); +stdVector< int > createVertexGlobalID( const stdVector< size_t > & localXadj, MPI_Comm comm ); } // namespace geos } // namespace graph diff --git a/src/coreComponents/mesh/graphs/RLFGraphColoring.cpp b/src/coreComponents/mesh/graphs/RLFGraphColoring.cpp index 0abb5b5066f..f6a7610e4dd 100644 --- a/src/coreComponents/mesh/graphs/RLFGraphColoring.cpp +++ b/src/coreComponents/mesh/graphs/RLFGraphColoring.cpp @@ -34,21 +34,27 @@ RLFGraphColoring::~RLFGraphColoring() {} -int RLFGraphColoring::colorGraph( const std::vector< camp::idx_t > & GEOS_UNUSED_PARAM( adjncy )) +int RLFGraphColoring::colorGraph( const stdVector< size_t > & GEOS_UNUSED_PARAM( adjncy )) { return -1; } -std::vector< int > RLFGraphColoring::colorGraph( const std::vector< camp::idx_t > & xadj, const std::vector< camp::idx_t > & adjncy ) +stdVector< int > RLFGraphColoring::colorGraph( const stdVector< size_t > & xadj, const stdVector< size_t > & adjncy ) { return RecursiveLargestFirstColoring( xadj, adjncy ); } -std::vector< int > RLFGraphColoring::RecursiveLargestFirstColoring( const std::vector< camp::idx_t > & xadj, const std::vector< camp::idx_t > & adjncy ) + +stdVector< int > RLFGraphColoring::RecursiveLargestFirstColoring( const stdVector< size_t > & xadj, const stdVector< size_t > & adjncy ) { - std::vector< int > color( xadj.size() - 1, -1 ); - std::unordered_set< camp::idx_t > uncoloredNodes; + if( xadj.empty()) + { + return {}; + } + + stdVector< int > color( xadj.size() - 1, -1 ); + std::unordered_set< size_t > uncoloredNodes; for( size_t i = 0; i < (xadj.size() - 1); ++i ) { uncoloredNodes.insert( i ); @@ -58,78 +64,105 @@ std::vector< int > RLFGraphColoring::RecursiveLargestFirstColoring( const std::v while( !uncoloredNodes.empty()) { // Find the uncolored node with the largest number of connections - idx_t largestDegreeNode = *std::max_element( uncoloredNodes.begin(), uncoloredNodes.end(), - [xadj]( const idx_t a, const idx_t b ){ return getGraphNodeDegree( a, xadj ) < getGraphNodeDegree( b, xadj ); } ); + auto cmp = [&]( size_t a, size_t b ) { + const auto degreeA = getGraphNodeDegree( a, xadj ); + const auto degreeB = getGraphNodeDegree( b, xadj ); + if( degreeA != degreeB ) + { + return degreeA < degreeB; + } + return a > b; + }; + size_t startNode = *std::max_element( uncoloredNodes.begin(), uncoloredNodes.end(), cmp ); - // Save its neighbors - std::unordered_set< camp::idx_t > largestDegreeNodeNeighbors = getGraphNodeNeighbors( largestDegreeNode, xadj, adjncy ); + // Declare the set of forbidden nodes (nodes adjacent to nodes_to_color) + std::unordered_set< size_t > forbiddenNodes; - // Initialize the node to be colored with the current color - int selectedNode = static_cast< int >(largestDegreeNode); + // Create the candidate set once per color. + // At this stage, candidates are all uncolored nodes... that set will shrink as we go + std::unordered_set< size_t > candidatesForThisColor = uncoloredNodes; - // Declare the set of forbidden nodes (nodes adjacent to nodes_to_color) - std::unordered_set< camp::idx_t > forbiddenNodes; + size_t selectedNode = startNode; - while( selectedNode != -1 ) + while( selectedNode != std::numeric_limits< size_t >::max()) { - // Color the selected node + // Color the selected node and remove it from future consideration color[selectedNode] = currentColor; - std::unordered_set< camp::idx_t > selectedNodeNeighbors = getGraphNodeNeighbors( selectedNode, xadj, adjncy ); - forbiddenNodes.insert( selectedNodeNeighbors.begin(), selectedNodeNeighbors.end()); uncoloredNodes.erase( selectedNode ); + candidatesForThisColor.erase( selectedNode ); - // Find new nodes to color with the current color - std::unordered_set< camp::idx_t > candidateNodesToColor; - for( camp::idx_t node : uncoloredNodes ) + // Update the set of forbidden nodes for the current color + // Any node adjacent to the selectedNode cannot be colored with currentColor + const auto selectedNodeNeighbors = getGraphNodeNeighbors( selectedNode, xadj, adjncy ); + forbiddenNodes.insert( selectedNodeNeighbors.begin(), selectedNodeNeighbors.end()); + + for( const auto & neighbor : selectedNodeNeighbors ) { - if( forbiddenNodes.find( node ) == forbiddenNodes.end()) - { - candidateNodesToColor.insert( node ); - } + candidatesForThisColor.erase( neighbor ); } - // Among the candidates, select one node + // Find the next best node to color from the remaining candidates + size_t bestCandidate = std::numeric_limits< size_t >::max(); size_t maxCommonNeighbors = 0; - selectedNode = -1; - for( camp::idx_t node : candidateNodesToColor ) + size_t bestCandidateDegree = std::numeric_limits< size_t >::max(); + + // Iterate over the shrinking set of candidates + for( const auto & node : candidatesForThisColor ) { - std::unordered_set< camp::idx_t > nodeNeighbors = getGraphNodeNeighbors( node, xadj, adjncy ); + const auto nodeNeighbors = getGraphNodeNeighbors( node, xadj, adjncy ); - size_t commonNeighbors = 0; - for( camp::idx_t neighbor : nodeNeighbors ) + // Count common neighbors with the forbidden set + size_t commonNeighborsCount = 0; + for( const auto & neighbor : nodeNeighbors ) { - if( largestDegreeNodeNeighbors.find( neighbor ) != largestDegreeNodeNeighbors.end()) + if( forbiddenNodes.count( neighbor )) { - ++commonNeighbors; + ++commonNeighborsCount; } } - size_t nodeDegree = getGraphNodeDegree( node, xadj ); - if( commonNeighbors > maxCommonNeighbors || (commonNeighbors == maxCommonNeighbors && nodeDegree < getGraphNodeDegree( selectedNode, xadj ))) + // Apply RLF heuristic + bool shouldSelect = false; + if( bestCandidate == std::numeric_limits< size_t >::max() || commonNeighborsCount > maxCommonNeighbors ) + { + shouldSelect = true; + } + else if( commonNeighborsCount == maxCommonNeighbors ) { - selectedNode = static_cast< int >(node); - maxCommonNeighbors = commonNeighbors; + const size_t nodeDegree = getGraphNodeDegree( node, xadj ); + if( nodeDegree < bestCandidateDegree ) + { + shouldSelect = true; + } + } + + if( shouldSelect ) + { + bestCandidate = node; + maxCommonNeighbors = commonNeighborsCount; + bestCandidateDegree = getGraphNodeDegree( node, xadj ); } } + selectedNode = bestCandidate; } - // Increment the current color + // Move to the next color ++currentColor; } return color; } -size_t RLFGraphColoring::getNumberOfColors( const std::vector< int > & colors ) const + +size_t RLFGraphColoring::getNumberOfColors( const stdVector< int > & colors ) const { return GraphColoringBase::getNumberOfColors( colors ); } -bool RLFGraphColoring::isColoringValid( const std::vector< camp::idx_t > & xadj, const std::vector< camp::idx_t > & adjncy, const std::vector< int > & colors ) const +bool RLFGraphColoring::isColoringValid( const stdVector< size_t > & xadj, const stdVector< size_t > & adjncy, const stdVector< int > & colors ) const { return GraphColoringBase::isColoringValid( xadj, adjncy, colors ); } - } // namespace graph } // namespace geos diff --git a/src/coreComponents/mesh/graphs/RLFGraphColoring.hpp b/src/coreComponents/mesh/graphs/RLFGraphColoring.hpp index af4c5338071..fbdd71927d5 100644 --- a/src/coreComponents/mesh/graphs/RLFGraphColoring.hpp +++ b/src/coreComponents/mesh/graphs/RLFGraphColoring.hpp @@ -63,21 +63,21 @@ class RLFGraphColoring : public GraphColoringBase * @param adjncy Adjacency list. * @return A vector of assigned colors. */ - std::vector< int > colorGraph( const std::vector< camp::idx_t > & xadj, const std::vector< camp::idx_t > & adjncy ) override; + stdVector< int > colorGraph( const stdVector< size_t > & xadj, const stdVector< size_t > & adjncy ) override; /** * @brief Colors a graph assuming one node per rank. * @param localAdjncy Local adjacency list. * @return Color of the node. */ - int colorGraph( const std::vector< camp::idx_t > & localAdjncy ) override; + int colorGraph( const stdVector< size_t > & localAdjncy ) override; /** * @brief Returns the number of distinct colors used. * @param colors Vector of color assignments. * @return Number of unique colors. */ - size_t getNumberOfColors( const std::vector< int > & colors ) const; + size_t getNumberOfColors( const stdVector< int > & colors ) const; /** * @brief Validates the coloring of a graph. @@ -86,7 +86,7 @@ class RLFGraphColoring : public GraphColoringBase * @param colors Vector of assigned colors. * @return True if coloring is valid, false otherwise. */ - bool isColoringValid( const std::vector< camp::idx_t > & xadj, const std::vector< camp::idx_t > & adjncy, const std::vector< int > & colors ) const; + bool isColoringValid( const stdVector< size_t > & xadj, const stdVector< size_t > & adjncy, const stdVector< int > & colors ) const; private: @@ -96,7 +96,7 @@ class RLFGraphColoring : public GraphColoringBase * @param adjncy The adjacency list containing the neighbors of each node. * @return A vector where the index represents the node and the value represents the assigned color. */ - std::vector< int > RecursiveLargestFirstColoring( const std::vector< camp::idx_t > & xadj, const std::vector< camp::idx_t > & adjncy ); + stdVector< int > RecursiveLargestFirstColoring( const stdVector< size_t > & xadj, const stdVector< size_t > & adjncy ); }; } // namespace graph diff --git a/src/coreComponents/mesh/graphs/RLFGraphColoringMPI.cpp b/src/coreComponents/mesh/graphs/RLFGraphColoringMPI.cpp index 3ed9881511c..5be78b6a89a 100644 --- a/src/coreComponents/mesh/graphs/RLFGraphColoringMPI.cpp +++ b/src/coreComponents/mesh/graphs/RLFGraphColoringMPI.cpp @@ -36,23 +36,23 @@ RLFGraphColoringMPI::~RLFGraphColoringMPI() {} -int RLFGraphColoringMPI::colorGraph( const std::vector< camp::idx_t > & localAdjncy ) +int RLFGraphColoringMPI::colorGraph( const stdVector< size_t > & localAdjncy ) { - std::vector< camp::idx_t > localXadj = createXadjFromAdjncy( localAdjncy, m_comm ); - std::vector< int > localColors = RLFGraphColoringMPI::colorGraph( localXadj, localAdjncy ); + stdVector< size_t > localXadj = createXadjFromAdjncy( localAdjncy, m_comm ); + stdVector< int > localColors = RLFGraphColoringMPI::colorGraph( localXadj, localAdjncy ); return localColors[0]; } -std::vector< int > RLFGraphColoringMPI::colorGraph( const std::vector< camp::idx_t > & localXadj, - const std::vector< camp::idx_t > & localAdjncy ) +stdVector< int > RLFGraphColoringMPI::colorGraph( const stdVector< size_t > & localXadj, + const stdVector< size_t > & localAdjncy ) { int const rank = MpiWrapper::commRank( m_comm ); int const size = MpiWrapper::commSize( m_comm ); // Perform coloring on rank 0 auto [xadj, adjncy] = gatherGraphData( localXadj, localAdjncy, m_comm ); - std::vector< int > colors; + stdVector< int > colors; if( rank == 0 ) { // Symmetrize the gathered graph before coloring. @@ -62,25 +62,25 @@ std::vector< int > RLFGraphColoringMPI::colorGraph( const std::vector< camp::idx // 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; + size_t const numNodes = 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 ) + stdVector< std::set< size_t > > adjSets( numNodes ); + for( size_t i = 0; i < numNodes; ++i ) { - for( camp::idx_t j = xadj[i]; j < xadj[i + 1]; ++j ) + for( size_t j = xadj[i]; j < xadj[i + 1]; ++j ) { - camp::idx_t const neighbor = adjncy[j]; + size_t const neighbor = adjncy[j]; adjSets[i].insert( neighbor ); - adjSets[neighbor].insert( static_cast< camp::idx_t >( i ) ); // reverse edge + adjSets[neighbor].insert( 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 ) + stdVector< size_t > symXadj( numNodes + 1, 0 ); + stdVector< size_t > symAdjncy; + for( size_t 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] ) + symXadj[i + 1] = symXadj[i] + adjSets[i].size(); + for( size_t nb : adjSets[i] ) { symAdjncy.push_back( nb ); } @@ -93,8 +93,8 @@ std::vector< int > RLFGraphColoringMPI::colorGraph( const std::vector< camp::idx } // Scatter colors back to original ranks - std::vector< int > sendCounts; - std::vector< int > displacements; + stdVector< int > sendCounts; + stdVector< int > displacements; if( rank==0 ) { @@ -114,7 +114,7 @@ std::vector< int > RLFGraphColoringMPI::colorGraph( const std::vector< camp::idx } } - std::vector< int > localColors( localNodeCounts ); + stdVector< int > localColors( localNodeCounts ); MpiWrapper::scatterv( colors.data(), sendCounts.data(), displacements.data(), localColors.data(), localNodeCounts, 0, m_comm ); @@ -127,13 +127,13 @@ size_t RLFGraphColoringMPI::getNumberOfColors( const int color ) const return GraphColoringBase::getNumberOfColors( color, m_comm ); } -size_t RLFGraphColoringMPI::getNumberOfColors( const std::vector< int > & colors ) const +size_t RLFGraphColoringMPI::getNumberOfColors( const stdVector< int > & colors ) const { return GraphColoringBase::getNumberOfColors( colors, m_comm ); } -bool RLFGraphColoringMPI::isColoringValid( const std::vector< camp::idx_t > & adjncy, const int color ) const +bool RLFGraphColoringMPI::isColoringValid( const stdVector< size_t > & adjncy, const int color ) const { return GraphColoringBase::isColoringValid( adjncy, color, m_comm ); } diff --git a/src/coreComponents/mesh/graphs/RLFGraphColoringMPI.hpp b/src/coreComponents/mesh/graphs/RLFGraphColoringMPI.hpp index 93990c8e586..96517647352 100644 --- a/src/coreComponents/mesh/graphs/RLFGraphColoringMPI.hpp +++ b/src/coreComponents/mesh/graphs/RLFGraphColoringMPI.hpp @@ -60,7 +60,7 @@ class RLFGraphColoringMPI : public GraphColoringBase * @param colors Vector of color assignments. * @return Number of unique colors. */ - size_t getNumberOfColors( const std::vector< int > & colors ) const; + size_t getNumberOfColors( const stdVector< int > & colors ) const; /** * @brief Returns the number of distinct colors used, assuming one node per rank. @@ -75,7 +75,7 @@ class RLFGraphColoringMPI : public GraphColoringBase * @param localColor Color assigned to the local node. * @return True if the coloring is valid, false otherwise. */ - bool isColoringValid( const std::vector< camp::idx_t > & localAdjncy, const int localColor ) const; + bool isColoringValid( const stdVector< size_t > & localAdjncy, const int localColor ) const; /** * @brief Colors a distributed graph. @@ -83,14 +83,14 @@ class RLFGraphColoringMPI : public GraphColoringBase * @param localAdjncy Local adjacency list. * @return A vector of assigned colors. */ - std::vector< int > colorGraph( const std::vector< camp::idx_t > & localXadj, const std::vector< camp::idx_t > & localAdjncy ) override; + stdVector< int > colorGraph( const stdVector< size_t > & localXadj, const stdVector< size_t > & localAdjncy ) override; /** * @brief Simplified coloring assuming one node per rank. * @param localAdjncy Local adjacency list. * @return Color of the node. */ - int colorGraph( const std::vector< camp::idx_t > & localAdjncy ) override; + int colorGraph( const stdVector< size_t > & localAdjncy ) override; }; } // namespace graph diff --git a/src/coreComponents/mesh/graphs/ZoltanGraphColoring.cpp b/src/coreComponents/mesh/graphs/ZoltanGraphColoring.cpp index c343e8a7c01..741d994bb42 100644 --- a/src/coreComponents/mesh/graphs/ZoltanGraphColoring.cpp +++ b/src/coreComponents/mesh/graphs/ZoltanGraphColoring.cpp @@ -20,6 +20,7 @@ #include "ZoltanGraphColoring.hpp" #include "GraphToolsMPI.hpp" #include +#include #define GEOS_ZOLTAN_CHECK( call ) \ @@ -58,26 +59,37 @@ ZoltanGraphColoring::~ZoltanGraphColoring() } -int ZoltanGraphColoring::colorGraph( const std::vector< camp::idx_t > & localAdjncy ) +int ZoltanGraphColoring::colorGraph( const stdVector< size_t > & localAdjncy ) { - std::vector< camp::idx_t > localXadj = createXadjFromAdjncy( localAdjncy, m_comm ); - std::vector< int > colors = colorGraph( localXadj, localAdjncy ); + stdVector< size_t > localXadj = createXadjFromAdjncy( localAdjncy, m_comm ); + stdVector< int > colors = colorGraph( localXadj, localAdjncy ); return colors[0]; } -std::vector< int > ZoltanGraphColoring::colorGraph( const std::vector< camp::idx_t > & xadj, - const std::vector< camp::idx_t > & adjncy ) +stdVector< int > ZoltanGraphColoring::colorGraph( const stdVector< size_t > & xadj, + const stdVector< size_t > & adjncy ) { int const rank = MpiWrapper::commRank( m_comm ); + // Convert size_t to int with overflow checking for Zoltan + auto safeConvert = []( size_t value ) -> int { + GEOS_ERROR_IF( value > static_cast< size_t >( std::numeric_limits< int >::max()), + "Value " << value << " exceeds maximum int value for Zoltan interface" ); + return static_cast< int >( value ); + }; + ZoltanGraph graph; - graph.m_xadj.assign( xadj.begin(), xadj.end()); - graph.m_adjncy.assign( adjncy.begin(), adjncy.end()); - graph.m_numVertices = xadj.size() - 1; + graph.m_xadj.reserve( xadj.size()); + std::transform( xadj.begin(), xadj.end(), std::back_inserter( graph.m_xadj ), safeConvert ); + + graph.m_adjncy.reserve( adjncy.size()); + std::transform( adjncy.begin(), adjncy.end(), std::back_inserter( graph.m_adjncy ), safeConvert ); + + graph.m_numVertices = safeConvert( xadj.size() - 1 ); graph.m_rank = rank; - std::vector< int > vertexGID = createVertexGlobalID( xadj, m_comm ); + stdVector< int > vertexGID = createVertexGlobalID( xadj, m_comm ); graph.m_vertexGID.resize( graph.m_numVertices ); for( int i = 0; i < graph.m_numVertices; i++ ) { @@ -103,7 +115,7 @@ std::vector< int > ZoltanGraphColoring::colorGraph( const std::vector< camp::idx std::fill( color, color + graph.m_numVertices, -1 ); GEOS_ZOLTAN_CHECK( m_zz->Color( numGidEntries, numReqObjs, reqObjs, color )); - std::vector< int > coloringVector; + stdVector< int > coloringVector; coloringVector.assign( color, color + graph.m_numVertices ); // Make numbering starts at 0, and not 1. @@ -198,13 +210,13 @@ size_t ZoltanGraphColoring::getNumberOfColors( const int color ) const return GraphColoringBase::getNumberOfColors( color, m_comm ); } -size_t ZoltanGraphColoring::getNumberOfColors( const std::vector< int > & colors ) const +size_t ZoltanGraphColoring::getNumberOfColors( const stdVector< int > & colors ) const { return GraphColoringBase::getNumberOfColors( colors, m_comm ); } -bool ZoltanGraphColoring::isColoringValid( const std::vector< camp::idx_t > & adjncy, const int color ) const +bool ZoltanGraphColoring::isColoringValid( const stdVector< size_t > & adjncy, const int color ) const { return GraphColoringBase::isColoringValid( adjncy, color, m_comm ); } diff --git a/src/coreComponents/mesh/graphs/ZoltanGraphColoring.hpp b/src/coreComponents/mesh/graphs/ZoltanGraphColoring.hpp index 219934b6471..f965c48b7e9 100644 --- a/src/coreComponents/mesh/graphs/ZoltanGraphColoring.hpp +++ b/src/coreComponents/mesh/graphs/ZoltanGraphColoring.hpp @@ -61,7 +61,7 @@ class ZoltanGraphColoring : public GraphColoringBase * @param colors Vector of color assignments. * @return Number of unique colors. */ - size_t getNumberOfColors( const std::vector< int > & colors ) const; + size_t getNumberOfColors( const stdVector< int > & colors ) const; /** * @brief Returns the number of colors assuming one node per rank. @@ -76,7 +76,7 @@ class ZoltanGraphColoring : public GraphColoringBase * @param color Color of the node. * @return True if the coloring is valid, false otherwise. */ - bool isColoringValid( const std::vector< camp::idx_t > & adjncy, const int color ) const; + bool isColoringValid( const stdVector< size_t > & adjncy, const int color ) const; /** * @brief Colors a graph. @@ -84,14 +84,14 @@ class ZoltanGraphColoring : public GraphColoringBase * @param adjncy Adjacency list. * @return A vector of assigned colors. */ - std::vector< int > colorGraph( const std::vector< camp::idx_t > & xadj, const std::vector< camp::idx_t > & adjncy ) override; + stdVector< int > colorGraph( const stdVector< size_t > & xadj, const stdVector< size_t > & adjncy ) override; /** * @brief Simplified coloring assuming one node per rank. * @param adjncy Local adjacency list. * @return Number of colors used. */ - int colorGraph( const std::vector< camp::idx_t > & adjncy ) override; + int colorGraph( const stdVector< size_t > & adjncy ) override; private: @@ -100,9 +100,9 @@ class ZoltanGraphColoring : public GraphColoringBase struct ZoltanGraph { int m_numVertices; - std::vector< int > m_vertexGID; - std::vector< int > m_xadj; - std::vector< int > m_adjncy; + stdVector< int > m_vertexGID; + stdVector< int > m_xadj; + stdVector< int > m_adjncy; int m_rank; }; diff --git a/src/coreComponents/mesh/mpiCommunications/SpatialPartition.cpp b/src/coreComponents/mesh/mpiCommunications/SpatialPartition.cpp index 40eeb557a85..9d2f229f026 100644 --- a/src/coreComponents/mesh/mpiCommunications/SpatialPartition.cpp +++ b/src/coreComponents/mesh/mpiCommunications/SpatialPartition.cpp @@ -93,31 +93,15 @@ void SpatialPartition::setPartitions( unsigned int xPartitions, int SpatialPartition::getColor() { - if( m_metisNeighborList.empty() ) - { - // Internal cartesian partitioner (for internal mesh) - int color=0; - if( isOdd( m_coords[0] ) ) - { - color += 1; - } - - if( isOdd( m_coords[1] ) ) - { - color += 2; - } + return getColor( {} ); +} - if( isOdd( m_coords[2] ) ) - { - color += 4; - } +int SpatialPartition::getColor( std::set< int > const & fullNeighbors ) +{ + // Determine neighbor source + bool const useGraphColoring = !fullNeighbors.empty() || !m_metisNeighborList.empty(); - // With this algorithm, numbering may have gaps. - // In that case m_numColors is an upper bound, not the exact number of distinct colors used. - m_numColors = MpiWrapper::max( color )+1; - return color; - } - else + if( useGraphColoring ) { // External partitioner such as ParMetis or PTScotch (for VTK external mesh). // @@ -177,14 +161,14 @@ int SpatialPartition::getColor() } } - std::vector< camp::idx_t > adjncy( symmetricNeighbors.begin(), symmetricNeighbors.end() ); + stdVector< size_t > adjncy( symmetricNeighbors.begin(), symmetricNeighbors.end() ); #ifdef GEOS_USE_TRILINOS geos::graph::ZoltanGraphColoring coloring; #else geos::graph::RLFGraphColoringMPI coloring; #endif - int color = coloring.colorGraph( adjncy ); + int const color = coloring.colorGraph( adjncy ); if( !coloring.isColoringValid( adjncy, color )) { @@ -199,7 +183,18 @@ int SpatialPartition::getColor() GEOS_ERROR( "Invalid partition coloring: two neighboring partitions share the same color" ); } m_numColors = coloring.getNumberOfColors( color ); + return color; + } + else + { + // Cartesian partitioner coloring + int const color = (isOdd( m_coords[0] ) ? 1 : 0) | + (isOdd( m_coords[1] ) ? 2 : 0) | + (isOdd( m_coords[2] ) ? 4 : 0); + // With this algorithm, numbering may have gaps. + // In that case m_numColors is an upper bound, not the exact number of distinct colors used. + m_numColors = MpiWrapper::max( color ) + 1; return color; } } diff --git a/src/coreComponents/mesh/mpiCommunications/SpatialPartition.hpp b/src/coreComponents/mesh/mpiCommunications/SpatialPartition.hpp index 0ed1b526039..556b51df83d 100644 --- a/src/coreComponents/mesh/mpiCommunications/SpatialPartition.hpp +++ b/src/coreComponents/mesh/mpiCommunications/SpatialPartition.hpp @@ -71,8 +71,26 @@ class SpatialPartition : public PartitionBase unsigned int yPartitions, unsigned int zPartitions ) override; + /** + * @brief Get the color for graph coloring-based synchronization. + * @return The color assigned to this rank. + * + * @note Uses the default neighbor list (m_metisNeighborList for external meshes, + * or Cartesian coordinates for internal meshes). + */ int getColor() override; + /** + * @brief Get the color for graph coloring-based synchronization with custom neighbors. + * @param fullNeighbors Set of neighbor ranks to use for coloring. If provided, + * overrides the default neighbor list. May include second-order + * neighbors for more conservative coloring. + * @return The color assigned to this rank. + * + * @note When fullNeighbors is empty, falls back to the default getColor() behavior. + */ + int getColor( std::set< int > const & fullNeighbors ); + void repartitionMasterParticles( ParticleSubRegion & subRegion, MPI_iCommData & commData ); diff --git a/src/coreComponents/mesh/unitTests/CMakeLists.txt b/src/coreComponents/mesh/unitTests/CMakeLists.txt index a365e1f0b0a..01381a38081 100644 --- a/src/coreComponents/mesh/unitTests/CMakeLists.txt +++ b/src/coreComponents/mesh/unitTests/CMakeLists.txt @@ -38,7 +38,7 @@ if (ENABLE_TRILINOS) list( APPEND dependencyList trilinos ) endif() -set( nranks 8 ) +set( nranks 4 ) foreach( test ${mesh_tests_mpi} ) get_filename_component( file_we ${test} NAME_WE ) diff --git a/src/coreComponents/mesh/unitTests/testGraphColoring.cpp b/src/coreComponents/mesh/unitTests/testGraphColoring.cpp index db16eb574b0..aa152875024 100644 --- a/src/coreComponents/mesh/unitTests/testGraphColoring.cpp +++ b/src/coreComponents/mesh/unitTests/testGraphColoring.cpp @@ -14,7 +14,7 @@ */ /** - * @file testColoring.cpp + * @file testGraphColoring.cpp */ #include "../graphs/GraphTools.hpp" @@ -27,17 +27,17 @@ using namespace geos; using namespace graph; TEST( GraphColoringTest, CountPositiveDistinctColors ) { - std::vector< int > colors = {1, -1, 3, 2, 1, 4, 5, 3, -1, 0}; + stdVector< int > colors = {1, -1, 3, 2, 1, 4, 5, 3, -1, 0}; EXPECT_EQ( GraphColoringBase::getNumberOfColors( colors ), 6 ); } TEST( GraphColoringTest, CartesianDecomposition3D6 ) { - idx_t const nx = 3, ny = 4, nz = 3; - auto [xadj, adjncy] = generateGraphCartPartitionning3D6( nx, ny, nz ); + size_t const nx = 3, ny = 4, nz = 3; + auto [xadj, adjncy] = generateGraphCartPartitioning3D6( nx, ny, nz ); geos::graph::RLFGraphColoring graphColoring; - std::vector< int > colors = graphColoring.colorGraph( xadj, adjncy ); + stdVector< int > colors = graphColoring.colorGraph( xadj, adjncy ); EXPECT_TRUE( graphColoring.isColoringValid( xadj, adjncy, colors )); EXPECT_EQ( graphColoring.getNumberOfColors( colors ), 2 ); @@ -46,10 +46,10 @@ TEST( GraphColoringTest, CartesianDecomposition3D6 ) TEST( GraphColoringTest, CartesianDecomposition3D26 ) { - idx_t const nx = 3, ny = 4, nz = 3; - auto [xadj, adjncy] = generateGraphCartPartitionning3D26( nx, ny, nz ); + size_t const nx = 3, ny = 4, nz = 3; + auto [xadj, adjncy] = generateGraphCartPartitioning3D26( nx, ny, nz ); geos::graph::RLFGraphColoring graphColoring; - std::vector< int > colors = graphColoring.colorGraph( xadj, adjncy ); + stdVector< int > colors = graphColoring.colorGraph( xadj, adjncy ); EXPECT_TRUE( graphColoring.isColoringValid( xadj, adjncy, colors )); EXPECT_EQ( graphColoring.getNumberOfColors( colors ), 8 ); } @@ -57,14 +57,14 @@ TEST( GraphColoringTest, CartesianDecomposition3D26 ) TEST( GraphColoringTest, RandomGraphs ) { - size_t const iterations = 10; + size_t const iterations = 3; for( size_t i = 0; i < iterations; ++i ) { - size_t num_nodes = rand() % 100 + 5; // between 5 and 104 - size_t num_edges = rand() % (num_nodes * 6 + 1) + num_nodes; // between num_nodes and num_nodes * 6 + size_t num_nodes = rand() % 60 + 5; // between 5 and 64 + size_t num_edges = rand() % (num_nodes * 4 + 1) + num_nodes; // between num_nodes and num_nodes * 4 auto [xadj, adjncy] = generateGraphRandom( num_nodes, num_edges ); geos::graph::RLFGraphColoring graphColoring; - std::vector< int > colors = graphColoring.colorGraph( xadj, adjncy ); + stdVector< int > colors = graphColoring.colorGraph( xadj, adjncy ); EXPECT_TRUE( graphColoring.isColoringValid( xadj, adjncy, colors )); } } @@ -73,11 +73,11 @@ TEST( GraphColoringTest, RandomGraphs ) TEST( GraphColoringTest, InvalidColoring ) { // Create a simple graph with 4 nodes and 3 edges - std::vector< idx_t > xadj = {0, 1, 2, 3, 3}; - std::vector< idx_t > adjncy = {1, 0, 2, 1}; + stdVector< size_t > xadj = {0, 1, 2, 3, 3}; + stdVector< size_t > adjncy = {1, 0, 2, 1}; // Intentionally create an invalid coloring where two adjacent nodes have the same color - std::vector< int > colors = {0, 0, 1, 1}; + stdVector< int > colors = {0, 0, 1, 1}; // Check if the coloring is valid (should fail) EXPECT_FALSE( GraphColoringBase::isColoringValid( xadj, adjncy, colors )); diff --git a/src/coreComponents/mesh/unitTests/testGraphColoringMPI.cpp b/src/coreComponents/mesh/unitTests/testGraphColoringMPI.cpp index 6d8779db389..4512cc71dda 100644 --- a/src/coreComponents/mesh/unitTests/testGraphColoringMPI.cpp +++ b/src/coreComponents/mesh/unitTests/testGraphColoringMPI.cpp @@ -14,7 +14,7 @@ */ /** - * @file testColoring.cpp + * @file testGraphColoringMPI.cpp */ #include "../graphs/GraphTools.hpp" @@ -47,7 +47,7 @@ class GraphColoringTest : public ::testing::Test }; -void runColoringTest( GraphColoringBase & graphColoring, const std::vector< camp::idx_t > & xadj, const std::vector< camp::idx_t > & adjncy, int expectedNumberOfColors ) +void runColoringTest( GraphColoringBase & graphColoring, const stdVector< size_t > & xadj, const stdVector< size_t > & adjncy, int expectedNumberOfColors ) { auto [localXadj, localAdjncy] = scatterGraphData( xadj, adjncy, MPI_COMM_GEOS ); int color = graphColoring.colorGraph( localAdjncy ); @@ -67,13 +67,13 @@ TEST_F( GraphColoringTest, CartesianDecomposition3D6 ) #endif RLFGraphColoringMPI rlfColoringMPI; - std::vector< camp::idx_t > xadj; - std::vector< camp::idx_t > adjncy; + stdVector< size_t > xadj; + stdVector< size_t > adjncy; if( rank == 0 ) { - idx_t const nx = 4, ny = 2, nz = 1; - std::tie( xadj, adjncy ) = generateGraphCartPartitionning3D6( nx, ny, nz ); + size_t const nx = 2, ny = 2, nz = 1; + std::tie( xadj, adjncy ) = generateGraphCartPartitioning3D6( nx, ny, nz ); } #ifdef GEOS_USE_TRILINOS @@ -90,19 +90,19 @@ TEST_F( GraphColoringTest, CartesianDecomposition3D26 ) #endif RLFGraphColoringMPI rlfColoringMPI; - std::vector< camp::idx_t > xadj; - std::vector< camp::idx_t > adjncy; + stdVector< size_t > xadj; + stdVector< size_t > adjncy; if( rank == 0 ) { - idx_t const nx = 2, ny = 2, nz = 2; - std::tie( xadj, adjncy ) = generateGraphCartPartitionning3D26( nx, ny, nz ); + size_t const nx = 2, ny = 2, nz = 1; + std::tie( xadj, adjncy ) = generateGraphCartPartitioning3D26( nx, ny, nz ); } #ifdef GEOS_USE_TRILINOS - runColoringTest( zoltanColoring, xadj, adjncy, 8 ); + runColoringTest( zoltanColoring, xadj, adjncy, 4 ); #endif - runColoringTest( rlfColoringMPI, xadj, adjncy, 8 ); + runColoringTest( rlfColoringMPI, xadj, adjncy, 4 ); } @@ -116,12 +116,12 @@ TEST_F( GraphColoringTest, RandomGraphs ) size_t const iterations = 10; for( size_t i = 0; i < iterations; ++i ) { - std::vector< camp::idx_t > xadj; - std::vector< camp::idx_t > adjncy; + stdVector< size_t > xadj; + stdVector< size_t > adjncy; if( rank == 0 ) { - size_t num_nodes = 8; + size_t num_nodes = 4; size_t num_edges = rand() % (num_nodes * 3 + 1) + num_nodes; std::tie( xadj, adjncy ) = generateGraphRandom( num_nodes, num_edges ); } @@ -136,7 +136,7 @@ TEST_F( GraphColoringTest, RandomGraphs ) TEST_F( GraphColoringTest, CountPositiveDistinctColors ) { - std::vector< int > colors = {1, -1, 3, 2, 1, 4, 5, 3}; + stdVector< int > colors = {1, -1, 3, 2, 1, 4, 5, 3}; EXPECT_EQ( GraphColoringBase::getNumberOfColors( colors, MPI_COMM_GEOS ), 6 ); } From 1a669eef77e8d2b093515bc982cba606e01448ce Mon Sep 17 00:00:00 2001 From: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> Date: Thu, 21 May 2026 14:56:15 -0500 Subject: [PATCH 46/53] Surface generator fix for diffusion (#4061) * Fix surface generator diffusion * Access only defined values * Add line * Remove line --------- Co-authored-by: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> --- .../diffusion/ConstantDiffusion.cpp | 21 +++++++++++++++++ .../diffusion/ConstantDiffusion.hpp | 2 ++ .../constitutive/diffusion/DiffusionBase.cpp | 23 +++++++++++++++++++ .../constitutive/diffusion/DiffusionBase.hpp | 3 +-- .../surfaceGeneration/SurfaceGenerator.cpp | 15 ++++++++++-- 5 files changed, 60 insertions(+), 4 deletions(-) diff --git a/src/coreComponents/constitutive/diffusion/ConstantDiffusion.cpp b/src/coreComponents/constitutive/diffusion/ConstantDiffusion.cpp index 22d6db8d061..acc8d226c6f 100644 --- a/src/coreComponents/constitutive/diffusion/ConstantDiffusion.cpp +++ b/src/coreComponents/constitutive/diffusion/ConstantDiffusion.cpp @@ -52,6 +52,27 @@ void ConstantDiffusion::allocateConstitutiveData( Group & parent, localIndex con } } +void ConstantDiffusion::initializeTemperatureState( arrayView1d< real64 const > const & initialTemperature ) const +{ + DiffusionBase::initializeTemperatureState( initialTemperature ); + + localIndex const numE = m_diffusivity.size( 0 ); + integer constexpr numQuad = 1; // NOTE: enforcing 1 quadrature point + + auto diffusivityView = m_diffusivity.toView(); + auto const diffusivityComponentsView = m_diffusivityComponents.toViewConst(); + + forAll< parallelDevicePolicy<> >( numE, [=] GEOS_HOST_DEVICE ( localIndex const ei ) + { + for( localIndex q = 0; q < numQuad; ++q ) + { + diffusivityView[ei][q][0] = diffusivityComponentsView[0]; + diffusivityView[ei][q][1] = diffusivityComponentsView[1]; + diffusivityView[ei][q][2] = diffusivityComponentsView[2]; + } + } ); +} + void ConstantDiffusion::postInputInitialization() { GEOS_THROW_IF( m_diffusivityComponents.size() != 3, diff --git a/src/coreComponents/constitutive/diffusion/ConstantDiffusion.hpp b/src/coreComponents/constitutive/diffusion/ConstantDiffusion.hpp index 90258d2e0fb..8e7a90024ec 100644 --- a/src/coreComponents/constitutive/diffusion/ConstantDiffusion.hpp +++ b/src/coreComponents/constitutive/diffusion/ConstantDiffusion.hpp @@ -73,6 +73,8 @@ class ConstantDiffusion : public DiffusionBase virtual void allocateConstitutiveData( dataRepository::Group & parent, localIndex const numPts ) override final; + virtual void initializeTemperatureState( arrayView1d< real64 const > const & initialTemperature ) const override; + /// Type of kernel wrapper for in-kernel update using KernelWrapper = ConstantDiffusionUpdate; diff --git a/src/coreComponents/constitutive/diffusion/DiffusionBase.cpp b/src/coreComponents/constitutive/diffusion/DiffusionBase.cpp index 3b03b6e8990..69160b87122 100644 --- a/src/coreComponents/constitutive/diffusion/DiffusionBase.cpp +++ b/src/coreComponents/constitutive/diffusion/DiffusionBase.cpp @@ -88,6 +88,29 @@ void DiffusionBase::allocateConstitutiveData( Group & parent, localIndex const n } } +void DiffusionBase::initializeTemperatureState( arrayView1d< real64 const > const & initialTemperature ) const +{ + GEOS_UNUSED_VAR( initialTemperature ); + + localIndex const numE = m_phaseDiffusivityMultiplier.size( 0 ); + integer constexpr numQuad = 1; // NOTE: enforcing 1 quadrature point + integer const numPhases = numFluidPhases(); + + auto phaseDiffusivityMultiplierView = m_phaseDiffusivityMultiplier.toView(); + auto const defaultPhaseDiffusivityMultiplierView = m_defaultPhaseDiffusivityMultiplier.toViewConst(); + + forAll< parallelDevicePolicy<> >( numE, [=] GEOS_HOST_DEVICE ( localIndex const ei ) + { + for( localIndex q = 0; q < numQuad; ++q ) + { + for( integer ip = 0; ip < numPhases; ++ip ) + { + phaseDiffusivityMultiplierView[ei][q][ip] = defaultPhaseDiffusivityMultiplierView[ip]; + } + } + } ); +} + } // namespace constitutive } // namespace geos diff --git a/src/coreComponents/constitutive/diffusion/DiffusionBase.hpp b/src/coreComponents/constitutive/diffusion/DiffusionBase.hpp index bb998e842e2..0c55efc4ea5 100644 --- a/src/coreComponents/constitutive/diffusion/DiffusionBase.hpp +++ b/src/coreComponents/constitutive/diffusion/DiffusionBase.hpp @@ -140,8 +140,7 @@ class DiffusionBase : public ConstitutiveBase * * Note: this is needed because for now, the temperature is treated **explicitly** in the diffusion tensor */ - virtual void initializeTemperatureState( arrayView1d< real64 const > const & initialTemperature ) const - { GEOS_UNUSED_VAR( initialTemperature ); } + virtual void initializeTemperatureState( arrayView1d< real64 const > const & initialTemperature ) const; /** * @brief Save the temperature state (needed when diffusion depends on temperature) diff --git a/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp b/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp index a1629ba5180..0735262ad09 100644 --- a/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp +++ b/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp @@ -29,6 +29,7 @@ #include "mesh/SurfaceElementRegion.hpp" #include "mesh/utilities/ComputationalGeometry.hpp" #include "constitutive/thermalConductivity/SinglePhaseThermalConductivityBase.hpp" +#include "constitutive/diffusion/DiffusionBase.hpp" #include "physicsSolvers/solidMechanics/SolidMechanicsFields.hpp" #include "physicsSolvers/solidMechanics/SolidMechanicsLagrangianFEM.hpp" #include "physicsSolvers/solidMechanics/kernels/SolidMechanicsLagrangianFEMKernels.hpp" @@ -583,6 +584,14 @@ real64 SurfaceGenerator::solverStep( real64 const & time_n, SinglePhaseThermalConductivityBase & thermalCondModel = getConstitutiveModel< SinglePhaseThermalConductivityBase >( fractureSubRegion, thermalCondModelName ); thermalCondModel.initializeState(); } + + string const diffusionModelName = getConstitutiveName< DiffusionBase >( fractureSubRegion ); + if( !diffusionModelName.empty() ) + { + DiffusionBase & diffusionModel = getConstitutiveModel< DiffusionBase >( fractureSubRegion, diffusionModelName ); + arrayView1d< real64 const > const temperature = fractureSubRegion.template getField< flow::temperature >(); + diffusionModel.initializeTemperatureState( temperature ); + } } ); return rval; @@ -4775,6 +4784,8 @@ SurfaceGenerator::calculateRuptureRate( SurfaceElementRegion & faceElementRegion { GEOS_MARK_FUNCTION; + real64 constexpr timeTolerance = 1.0e-14; + real64 maxRuptureRate = 0; FaceElementSubRegion & subRegion = faceElementRegion.getSubRegion< FaceElementSubRegion >( 0 ); @@ -4796,8 +4807,8 @@ SurfaceGenerator::calculateRuptureRate( SurfaceElementRegion & faceElementRegion localIndex const faceElem1 = fractureConnectorEdgesToFaceElements( kfc, kfe1 ); if( !( m_faceElemsRupturedThisSolve.count( faceElem0 ) && m_faceElemsRupturedThisSolve.count( faceElem1 ) ) ) { - real64 const deltaRuptureTime = fabs( ruptureTime( faceElem0 ) - ruptureTime( faceElem1 )); - if( deltaRuptureTime > 1.0e-14 * (ruptureTime( faceElem0 ) + ruptureTime( faceElem1 )) ) + real64 const deltaRuptureTime = LvArray::math::abs( ruptureTime( faceElem0 ) - ruptureTime( faceElem1 ) ); + if( deltaRuptureTime > timeTolerance ) { real64 distance[3] = LVARRAY_TENSOROPS_INIT_LOCAL_3 ( elemCenter[ faceElem0 ] ); LvArray::tensorOps::subtract< 3 >( distance, elemCenter[ faceElem1 ] ); From c23e75b3ef35650227840554b1048da46299f101 Mon Sep 17 00:00:00 2001 From: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> Date: Thu, 21 May 2026 23:59:11 -0500 Subject: [PATCH 47/53] Remove dependency on PVT package (#4057) * Remove dependence of PVT package * Remove documentation about pvt package * Exclude PVTPackage from code checks * Skip PVTPackage from documentation generation * Rebaseline * Reintroduce doc index file * Update baselines --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 3 + .../4comp_2ph_1d.xml | 9 +- .../4comp_2ph_cap_1d.xml | 9 +- .../compositional_multiphase_wells_1d.xml | 9 +- .../compositional_multiphase_wells_2d.xml | 9 +- .../resvol_constraint.xml | 9 +- inputFiles/constitutiveDriver/testPVT.xml | 7 +- .../testPVT_PhaseComposition.xml | 7 +- src/cmake/GeosxConfig.cmake | 1 - src/cmake/GeosxOptions.cmake | 2 - src/coreComponents/common/GeosxConfig.hpp.in | 3 - .../constitutive/CMakeLists.txt | 15 - .../constitutive/docs/BlackOilFluid.rst | 2 - ...uid.rst => CompositionalTwoPhaseFluid.rst} | 48 +-- .../constitutive/docs/FluidModels.rst | 2 +- .../multifluid/CO2Brine/CO2BrineFluid.hpp | 3 - .../fluid/multifluid/MultiFluidBase.hpp | 4 +- .../fluid/multifluid/MultiFluidSelector.hpp | 11 - .../multifluid/blackOil/BlackOilFluidBase.hpp | 3 - .../CompositionalMultiphaseFluid.hpp | 2 - ...CompositionalMultiphaseFluidPVTPackage.cpp | 232 ------------ ...CompositionalMultiphaseFluidPVTPackage.hpp | 339 ------------------ .../constant/InvariantImmiscibleFluid.hpp | 2 - .../unitTests/testNegativeTwoPhaseFlash.cpp | 2 +- .../constitutiveDrivers/CMakeLists.txt | 7 - .../fluid/multiFluid/PVTDriverRunTest.hpp | 10 +- ...verRunTestCompositionalMultiphaseFluid.cpp | 26 -- .../fluidFlowTests/CMakeLists.txt | 12 +- .../fluidFlowTests/testCompMultiphaseFlow.cpp | 25 +- .../testCompMultiphaseFlowHybrid.cpp | 9 +- .../wellsTests/CMakeLists.txt | 18 +- .../wellsTests/testOpenClosePerf.cpp | 9 +- ...eservoirCompositionalMultiphaseMSWells.cpp | 9 +- .../fluidFlow/CompositionalMultiphaseBase.cpp | 24 +- .../wells/CompositionalMultiphaseWell.cpp | 12 +- src/coreComponents/schema/schema.xsd | 31 -- src/coreComponents/schema/schema.xsd.other | 47 --- src/docs/doxygen/GeosxConfig.hpp | 53 ++- src/docs/sphinx/QuickStart.rst | 6 +- src/docs/sphinx/buildGuide/BuildProcess.rst | 1 - .../Contributing/GitWorkflow.rst | 1 - 42 files changed, 133 insertions(+), 902 deletions(-) rename src/coreComponents/constitutive/docs/{CompositionalMultiphaseFluid.rst => CompositionalTwoPhaseFluid.rst} (85%) delete mode 100644 src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluidPVTPackage.cpp delete mode 100644 src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluidPVTPackage.hpp delete mode 100644 src/coreComponents/constitutiveDrivers/fluid/multiFluid/compositional/PVTDriverRunTestCompositionalMultiphaseFluid.cpp diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index 428d43f1d7c..de37c7e6147 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr3814-16717-d17ea59 + baseline: integratedTests/baseline_integratedTests-pr4057-16739-5dde641 allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index 4daa1929dda..5909bd5d0bd 100644 --- a/BASELINE_NOTES.md +++ b/BASELINE_NOTES.md @@ -5,6 +5,9 @@ This file is designed to track changes to the integrated test baselines. Any developer who updates the baseline ID in the .integrated_tests.yaml file is expected to create an entry in this file with the pull request number, date, and their justification for rebaselining. These notes should be in reverse-chronological order, and use the following time format: (YYYY-MM-DD). +PR #4057 (2026-05-21) +Remove dependency on PVT package + PR #3814 (2026-05-20) Fix RLF coloring diff --git a/inputFiles/compositionalMultiphaseFlow/4comp_2ph_1d.xml b/inputFiles/compositionalMultiphaseFlow/4comp_2ph_1d.xml index 0f3273c6c7f..67b25e78328 100644 --- a/inputFiles/compositionalMultiphaseFlow/4comp_2ph_1d.xml +++ b/inputFiles/compositionalMultiphaseFlow/4comp_2ph_1d.xml @@ -77,20 +77,17 @@ - + constantPhaseViscosity="{ 1.0e-3, 1.0e-3 }" /> - + constantPhaseViscosity="{ 1.0e-3, 1.0e-3 }" /> - + constantPhaseViscosity="{ 1.0e-3, 1.0e-3 }" /> - + constantPhaseViscosity="{ 1.0e-3, 1.0e-3 }" /> - + constantPhaseViscosity="{ 1.0e-3, 1.0e-3 }" /> - + componentMolarWeight="{ 2.0159e-3, 16.043e-3 }" + constantPhaseViscosity="{ 1.0e-3, 1.0e-3 }" /> diff --git a/inputFiles/constitutiveDriver/testPVT_PhaseComposition.xml b/inputFiles/constitutiveDriver/testPVT_PhaseComposition.xml index 6e9e5750168..0ff29790ea1 100644 --- a/inputFiles/constitutiveDriver/testPVT_PhaseComposition.xml +++ b/inputFiles/constitutiveDriver/testPVT_PhaseComposition.xml @@ -81,16 +81,17 @@ - + componentVolumeShift="{ 0, 0, 0, 0 }" + constantPhaseViscosity="{ 1.0e-3, 1.0e-3 }" /> `` node in the input. -Under the hood this is a wrapper around ``PVTPackage`` library, which is included as a submodule. -In order to use the model, GEOS must be built with ``-DENABLE_PVTPACKAGE=ON`` (default). The following attributes are supported: diff --git a/src/coreComponents/constitutive/docs/CompositionalMultiphaseFluid.rst b/src/coreComponents/constitutive/docs/CompositionalTwoPhaseFluid.rst similarity index 85% rename from src/coreComponents/constitutive/docs/CompositionalMultiphaseFluid.rst rename to src/coreComponents/constitutive/docs/CompositionalTwoPhaseFluid.rst index 66723ee555c..4bdde45e0c3 100644 --- a/src/coreComponents/constitutive/docs/CompositionalMultiphaseFluid.rst +++ b/src/coreComponents/constitutive/docs/CompositionalTwoPhaseFluid.rst @@ -193,32 +193,11 @@ The flash calculation process is as follows: Parameters ========================= -The model represented by ```` node in the input. -Under the hood this is a wrapper around ``PVTPackage`` library, which is included as a submodule. -In order to use the model, GEOS must be built with ``-DENABLE_PVTPACKAGE=ON`` (default). +The model represented by ```` node in the input. The following attributes are supported: -.. include:: /docs/sphinx/datastructure/CompositionalMultiphaseFluid.rst - -Supported phase names are: - -===== =========== -Value Comment -===== =========== -oil Oil phase -gas Gas phase -water Water phase -===== =========== - -Supported Equation of State types: - -===== ======================= -Value Comment -===== ======================= -PR Peng-Robinson EOS -SRK Soave-Redlich-Kwong EOS -===== ======================= +.. include:: /docs/sphinx/datastructure/CompositionalTwoPhaseFluid.rst Example ========================= @@ -226,19 +205,16 @@ Example .. code-block:: xml - + References diff --git a/src/coreComponents/constitutive/docs/FluidModels.rst b/src/coreComponents/constitutive/docs/FluidModels.rst index 1aed1ce387e..687fe9db4c5 100644 --- a/src/coreComponents/constitutive/docs/FluidModels.rst +++ b/src/coreComponents/constitutive/docs/FluidModels.rst @@ -15,6 +15,6 @@ single fluids and fluid mixtures. BlackOilFluid - CompositionalMultiphaseFluid + CompositionalTwoPhaseFluid CO2BrineFluid diff --git a/src/coreComponents/constitutive/fluid/multifluid/CO2Brine/CO2BrineFluid.hpp b/src/coreComponents/constitutive/fluid/multifluid/CO2Brine/CO2BrineFluid.hpp index 1b89321acd7..3d6dd51691d 100644 --- a/src/coreComponents/constitutive/fluid/multifluid/CO2Brine/CO2BrineFluid.hpp +++ b/src/coreComponents/constitutive/fluid/multifluid/CO2Brine/CO2BrineFluid.hpp @@ -49,9 +49,6 @@ template< typename PHASE1, typename PHASE2, typename FLASH > class CO2BrineFluid : public MultiFluidBase { public: - - using exec_policy = parallelDevicePolicy<>; - CO2BrineFluid( string const & name, Group * const parent ); diff --git a/src/coreComponents/constitutive/fluid/multifluid/MultiFluidBase.hpp b/src/coreComponents/constitutive/fluid/multifluid/MultiFluidBase.hpp index 9396fe6ad3e..58f3b16abea 100644 --- a/src/coreComponents/constitutive/fluid/multifluid/MultiFluidBase.hpp +++ b/src/coreComponents/constitutive/fluid/multifluid/MultiFluidBase.hpp @@ -370,7 +370,7 @@ class MultiFluidBase : public ConstitutiveBase * @tparam OUT_ARRAY the type of array storing the component mole fractions * @param[in] composition the component mass fractions * @param[out] compMoleFrac the newly converted component mole fractions - * @detail The template is needed because PVTPackage expects a stdVector + * @details The template is needed because the blackoil fluid model calls this with real64[] */ template< integer maxNumComp, typename OUT_ARRAY > GEOS_HOST_DEVICE @@ -385,7 +385,7 @@ class MultiFluidBase : public ConstitutiveBase * @param[in] componentMolarWeight the component molar weight * @param[out] compMoleFrac the newly converted component mole fractions * @param[out] dCompMoleFrac_dCompMassFrac the derivatives of the newly converted component mole fractions - * @detail The template is needed because PVTPackage expects a stdVector + * @details The template is needed because the blackoil fluid model calls this with real64[] */ template< integer maxNumComp, typename OUT_ARRAY > GEOS_HOST_DEVICE diff --git a/src/coreComponents/constitutive/fluid/multifluid/MultiFluidSelector.hpp b/src/coreComponents/constitutive/fluid/multifluid/MultiFluidSelector.hpp index c3ceef4b9f3..d85f6b0f6ab 100644 --- a/src/coreComponents/constitutive/fluid/multifluid/MultiFluidSelector.hpp +++ b/src/coreComponents/constitutive/fluid/multifluid/MultiFluidSelector.hpp @@ -24,11 +24,6 @@ #include "constitutive/fluid/multifluid/blackOil/DeadOilFluid.hpp" #include "constitutive/fluid/multifluid/blackOil/BlackOilFluid.hpp" #include "constitutive/fluid/multifluid/CO2Brine/CO2BrineFluid.hpp" - -#include "common/TypeDispatch.hpp" -#ifdef GEOS_USE_PVTPackage -#include "constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluidPVTPackage.hpp" -#endif #include "constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluid.hpp" namespace geos @@ -44,9 +39,6 @@ void constitutiveUpdatePassThru( constitutive::MultiFluidBase const & fluid, ConstitutivePassThruHandler< InvariantImmiscibleFluid, DeadOilFluid, BlackOilFluid, -#ifdef GEOS_USE_PVTPackage - CompositionalMultiphaseFluidPVTPackage, -#endif CO2BrinePhillipsFluid, CO2BrineEzrokhiFluid, CO2BrinePhillipsThermalFluid, @@ -71,9 +63,6 @@ void constitutiveUpdatePassThru( constitutive::MultiFluidBase & fluid, ConstitutivePassThruHandler< InvariantImmiscibleFluid, DeadOilFluid, BlackOilFluid, -#ifdef GEOS_USE_PVTPackage - CompositionalMultiphaseFluidPVTPackage, -#endif CO2BrinePhillipsFluid, CO2BrineEzrokhiFluid, CO2BrinePhillipsThermalFluid, diff --git a/src/coreComponents/constitutive/fluid/multifluid/blackOil/BlackOilFluidBase.hpp b/src/coreComponents/constitutive/fluid/multifluid/blackOil/BlackOilFluidBase.hpp index 8ec94f07f64..19dac26c2d8 100644 --- a/src/coreComponents/constitutive/fluid/multifluid/blackOil/BlackOilFluidBase.hpp +++ b/src/coreComponents/constitutive/fluid/multifluid/blackOil/BlackOilFluidBase.hpp @@ -33,9 +33,6 @@ namespace constitutive class BlackOilFluidBase : public MultiFluidBase { public: - - using exec_policy = parallelDevicePolicy<>; - static constexpr integer MAX_NUM_PHASES = 3; struct PhaseType diff --git a/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluid.hpp b/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluid.hpp index bd9faf0ce44..a0fe1e26357 100644 --- a/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluid.hpp +++ b/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluid.hpp @@ -61,8 +61,6 @@ class CompositionalMultiphaseFluid : public MultiFluidBase // Currently restrict to 2 or 3 phases static_assert( NUM_PHASES == 2 || NUM_PHASES == 3 ); - using exec_policy = parallelDevicePolicy<>; - public: CompositionalMultiphaseFluid( string const & name, dataRepository::Group * const parent ); diff --git a/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluidPVTPackage.cpp b/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluidPVTPackage.cpp deleted file mode 100644 index ae3303004b1..00000000000 --- a/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluidPVTPackage.cpp +++ /dev/null @@ -1,232 +0,0 @@ -/* - * ------------------------------------------------------------------------------------------------------------ - * 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 CompositionalMultiphaseFluidPVTPackage.cpp - */ - -#include "CompositionalMultiphaseFluidPVTPackage.hpp" - -#include "codingUtilities/Utilities.hpp" -#include "constitutive/fluid/multifluid/CO2Brine/functions/PVTFunctionHelpers.hpp" - -#include "pvt/pvt.hpp" - -#include -#include - -namespace geos -{ - -using namespace dataRepository; - -namespace constitutive -{ - -CompositionalMultiphaseFluidPVTPackage::CompositionalMultiphaseFluidPVTPackage( string const & name, Group * const parent ) - : MultiFluidBase( name, parent ) -{ - getWrapperBase( viewKeyStruct::componentNamesString() ).setInputFlag( InputFlags::REQUIRED ); - getWrapperBase( viewKeyStruct::componentMolarWeightString() ).setInputFlag( InputFlags::REQUIRED ); - getWrapperBase( viewKeyStruct::phaseNamesString() ).setInputFlag( InputFlags::REQUIRED ); - - registerWrapper( viewKeyStruct::equationsOfStateString(), &m_equationsOfState ). - setInputFlag( InputFlags::REQUIRED ). - setDescription( "List of equation of state types for each phase" ); - - registerWrapper( viewKeyStruct::constantPhaseViscosityString(), &m_constantPhaseViscosity ). - setInputFlag( InputFlags::OPTIONAL ). - setDescription( "Viscosity for each phase" ); - - registerWrapper( viewKeyStruct::componentCriticalPressureString(), &m_componentCriticalPressure ). - setInputFlag( InputFlags::REQUIRED ). - setDescription( "Component critical pressures" ); - - registerWrapper( viewKeyStruct::componentCriticalTemperatureString(), &m_componentCriticalTemperature ). - setInputFlag( InputFlags::REQUIRED ). - setDescription( "Component critical temperatures" ); - - registerWrapper( viewKeyStruct::componentAcentricFactorString(), &m_componentAcentricFactor ). - setInputFlag( InputFlags::REQUIRED ). - setDescription( "Component acentric factors" ); - - registerWrapper( viewKeyStruct::componentVolumeShiftString(), &m_componentVolumeShift ). - setInputFlag( InputFlags::OPTIONAL ). - setDescription( "Component volume shifts" ); - - registerWrapper( viewKeyStruct::componentBinaryCoeffString(), &m_componentBinaryCoeff ). - setInputFlag( InputFlags::OPTIONAL ). - setDescription( "Table of binary interaction coefficients" ); -} - -integer CompositionalMultiphaseFluidPVTPackage::getWaterPhaseIndex() const -{ - string const expectedWaterPhaseNames[] = { "water" }; - return PVTProps::PVTFunctionHelpers::findName( m_phaseNames, expectedWaterPhaseNames, viewKeyStruct::phaseNamesString() ); -} - -void CompositionalMultiphaseFluidPVTPackage::postInputInitialization() -{ - MultiFluidBase::postInputInitialization(); - - auto const getPVTPackagePhaseType = [&]( string const & phaseName ) - { - static geos::map< string, pvt::PHASE_TYPE > const phaseTypes - { - { "gas", pvt::PHASE_TYPE::GAS }, - { "oil", pvt::PHASE_TYPE::OIL }, - { "water", pvt::PHASE_TYPE::LIQUID_WATER_RICH } - }; - return findOption( phaseTypes, phaseName, viewKeyStruct::phaseNamesString(), getFullName() ); - }; - - m_phaseTypes.resize( numFluidPhases() ); - std::transform( m_phaseNames.begin(), m_phaseNames.end(), m_phaseTypes.begin(), getPVTPackagePhaseType ); - - integer const NC = numFluidComponents(); - integer const NP = numFluidPhases(); - - auto const checkInputSize = [&]( auto const & array, auto const expected, string const & attribute ) - { - GEOS_THROW_IF_NE_MSG( array.size(), expected, - GEOS_FMT( "invalid number of values in attribute '{}'", attribute ), - InputError, getDataContext() ); - - }; - checkInputSize( m_equationsOfState, LvArray::integerConversion< size_t >( NP ), viewKeyStruct::equationsOfStateString() ); - checkInputSize( m_componentCriticalPressure, NC, viewKeyStruct::componentCriticalPressureString() ); - checkInputSize( m_componentCriticalTemperature, NC, viewKeyStruct::componentCriticalTemperatureString() ); - checkInputSize( m_componentAcentricFactor, NC, viewKeyStruct::componentAcentricFactorString() ); - - if( m_constantPhaseViscosity.empty() ) - { - m_constantPhaseViscosity.resize( NP ); - for( integer ip = 0; ip < NP; ++ip ) - { - m_constantPhaseViscosity[ip] = 0.001; // Default value = 1 cP - } - } - checkInputSize( m_constantPhaseViscosity, NP, viewKeyStruct::constantPhaseViscosityString() ); - - if( m_componentVolumeShift.empty() ) - { - m_componentVolumeShift.resize( NC ); - m_componentVolumeShift.zero(); - } - checkInputSize( m_componentVolumeShift, NC, viewKeyStruct::componentVolumeShiftString() ); - - if( m_componentBinaryCoeff.empty() ) - { - m_componentBinaryCoeff.resize( NC, NC ); - m_componentBinaryCoeff.zero(); - } - checkInputSize( m_componentBinaryCoeff, NC * NC, viewKeyStruct::componentBinaryCoeffString() ); -} - -void CompositionalMultiphaseFluidPVTPackage::initializePostSubGroups() -{ - MultiFluidBase::initializePostSubGroups(); - createFluid(); -} - -void CompositionalMultiphaseFluidPVTPackage::createFluid() -{ - auto const getCompositionalEosType = [&]( string const & name ) - { - static map< string, pvt::EOS_TYPE > const eosTypes = - { - { "PR", pvt::EOS_TYPE::PENG_ROBINSON }, - { "SRK", pvt::EOS_TYPE::REDLICH_KWONG_SOAVE } - }; - return findOption( eosTypes, name, viewKeyStruct::equationsOfStateString(), getFullName() ); - }; - - stdVector< pvt::EOS_TYPE > eos( numFluidPhases() ); - std::transform( m_equationsOfState.begin(), m_equationsOfState.end(), eos.begin(), getCompositionalEosType ); - - stdVector< pvt::PHASE_TYPE > phases( m_phaseTypes.begin(), m_phaseTypes.end() ); - stdVector< string > const components( m_componentNames.begin(), m_componentNames.end() ); - stdVector< double > const Mw( m_componentMolarWeight.begin(), m_componentMolarWeight.end() ); - stdVector< double > const Tc( m_componentCriticalTemperature.begin(), m_componentCriticalTemperature.end() ); - stdVector< double > const Pc( m_componentCriticalPressure.begin(), m_componentCriticalPressure.end() ); - stdVector< double > const Omega( m_componentAcentricFactor.begin(), m_componentAcentricFactor.end() ); - - m_fluid = pvt::MultiphaseSystemBuilder::buildCompositional( pvt::COMPOSITIONAL_FLASH_TYPE::NEGATIVE_OIL_GAS, phases, eos, - components, Mw, Tc, Pc, Omega ); -} - -std::unique_ptr< ConstitutiveBase > -CompositionalMultiphaseFluidPVTPackage::deliverClone( string const & name, - Group * const parent ) const -{ - std::unique_ptr< ConstitutiveBase > clone = MultiFluidBase::deliverClone( name, parent ); - CompositionalMultiphaseFluidPVTPackage & fluid = dynamicCast< CompositionalMultiphaseFluidPVTPackage & >( *clone ); - fluid.m_phaseTypes = m_phaseTypes; - fluid.createFluid(); - return clone; -} - -CompositionalMultiphaseFluidPVTPackage::KernelWrapper:: - KernelWrapper( pvt::MultiphaseSystem & fluid, - arrayView1d< pvt::PHASE_TYPE > const & phaseTypes, - arrayView1d< geos::real64 const > const & constantPhaseViscosity, - arrayView1d< geos::real64 const > const & componentMolarWeight, - bool useMass, - PhaseProp::ViewType phaseFraction, - PhaseProp::ViewType phaseDensity, - PhaseProp::ViewType phaseMassDensity, - PhaseProp::ViewType phaseViscosity, - PhaseProp::ViewType phaseEnthalpy, - PhaseProp::ViewType phaseInternalEnergy, - PhaseComp::ViewType phaseCompFraction, - FluidProp::ViewType totalDensity ) - : MultiFluidBase::KernelWrapper( componentMolarWeight, - useMass, - std::move( phaseFraction ), - std::move( phaseDensity ), - std::move( phaseMassDensity ), - std::move( phaseViscosity ), - std::move( phaseEnthalpy ), - std::move( phaseInternalEnergy ), - std::move( phaseCompFraction ), - std::move( totalDensity ) ), - m_fluid( fluid ), - m_phaseTypes( phaseTypes ), - m_constantPhaseViscosity( constantPhaseViscosity ) -{} - -CompositionalMultiphaseFluidPVTPackage::KernelWrapper -CompositionalMultiphaseFluidPVTPackage::createKernelWrapper() -{ - return KernelWrapper( *m_fluid, - m_phaseTypes, - m_constantPhaseViscosity, - m_componentMolarWeight, - m_useMass, - m_phaseFraction.toView(), - m_phaseDensity.toView(), - m_phaseMassDensity.toView(), - m_phaseViscosity.toView(), - m_phaseEnthalpy.toView(), - m_phaseInternalEnergy.toView(), - m_phaseCompFraction.toView(), - m_totalDensity.toView() ); -} - -REGISTER_CATALOG_ENTRY( ConstitutiveBase, CompositionalMultiphaseFluidPVTPackage, string const &, Group * const ) - -} // namespace constitutive - -} // namespace geos diff --git a/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluidPVTPackage.hpp b/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluidPVTPackage.hpp deleted file mode 100644 index 6cab7a26e33..00000000000 --- a/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluidPVTPackage.hpp +++ /dev/null @@ -1,339 +0,0 @@ -/* - * ------------------------------------------------------------------------------------------------------------ - * 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 CompositionalMultiphaseFluidPVTPackage.hpp - */ - -#ifndef GEOS_CONSTITUTIVE_FLUID_MULTIFLUID_COMPOSITIONAL_COMPOSITIONALMULTIPHASEFLUIDPVTPACKAGE_HPP_ -#define GEOS_CONSTITUTIVE_FLUID_MULTIFLUID_COMPOSITIONAL_COMPOSITIONALMULTIPHASEFLUIDPVTPACKAGE_HPP_ - -#include "constitutive/fluid/multifluid/MultiFluidBase.hpp" -#include "constitutive/fluid/multifluid/MultiFluidUtils.hpp" - -#include "constitutive/PVTPackage/PVTPackage/source/pvt/pvt.hpp" - -namespace geos -{ -namespace constitutive -{ - -class CompositionalMultiphaseFluidPVTPackage : public MultiFluidBase -{ -public: - - using exec_policy = serialPolicy; - - CompositionalMultiphaseFluidPVTPackage( string const & name, Group * const parent ); - - virtual std::unique_ptr< ConstitutiveBase > - deliverClone( string const & name, - Group * const parent ) const override; - - static string catalogName() { return "CompositionalMultiphaseFluid"; } - - virtual string getCatalogName() const override { return catalogName(); } - - static constexpr bool isThermalType(){ return false; } - - // TODO: This method should be implemented if an incorrect extrapolation of the pressure and temperature is encountered in the kernel - /** - * @copydoc MultiFluidBase::checkTablesParameters( real64 pressure, real64 temperature ) - */ - virtual void checkTablesParameters( real64 pressure, real64 temperature ) const override final - { - GEOS_UNUSED_VAR( pressure, temperature ); - } - - virtual integer getWaterPhaseIndex() const override final; - - struct viewKeyStruct : MultiFluidBase::viewKeyStruct - { - static constexpr char const * equationsOfStateString() { return "equationsOfState"; } - static constexpr char const * componentCriticalPressureString() { return "componentCriticalPressure"; } - static constexpr char const * componentCriticalTemperatureString() { return "componentCriticalTemperature"; } - static constexpr char const * componentAcentricFactorString() { return "componentAcentricFactor"; } - static constexpr char const * componentVolumeShiftString() { return "componentVolumeShift"; } - static constexpr char const * componentBinaryCoeffString() { return "componentBinaryCoeff"; } - static constexpr char const * constantPhaseViscosityString() { return "constantPhaseViscosity"; } - }; - - /** - * @brief Kernel wrapper class for CompositionalMultiphaseFluidPVTPackage. - */ - class KernelWrapper final : public MultiFluidBase::KernelWrapper - { -public: - GEOS_HOST_DEVICE - virtual void compute( real64 const pressure, - real64 const temperature, - arraySlice1d< real64 const, compflow::USD_COMP - 1 > const & composition, - PhaseProp::SliceType const phaseFraction, - PhaseProp::SliceType const phaseDensity, - PhaseProp::SliceType const phaseMassDensity, - PhaseProp::SliceType const phaseViscosity, - PhaseProp::SliceType const phaseEnthalpy, - PhaseProp::SliceType const phaseInternalEnergy, - PhaseComp::SliceType const phaseCompFraction, - FluidProp::SliceType const totalDensity ) const override; - - GEOS_HOST_DEVICE - virtual void update( localIndex const k, - localIndex const q, - real64 const pressure, - real64 const temperature, - arraySlice1d< real64 const, compflow::USD_COMP - 1 > const & composition ) const override; - -private: - - friend class CompositionalMultiphaseFluidPVTPackage; - - KernelWrapper( pvt::MultiphaseSystem & fluid, - arrayView1d< pvt::PHASE_TYPE > const & phaseTypes, - arrayView1d< real64 const > const & constantPhaseViscosity, - arrayView1d< real64 const > const & componentMolarWeight, - bool const useMass, - PhaseProp::ViewType phaseFraction, - PhaseProp::ViewType phaseDensity, - PhaseProp::ViewType phaseMassDensity, - PhaseProp::ViewType phaseViscosity, - PhaseProp::ViewType phaseEnthalpy, - PhaseProp::ViewType phaseInternalEnergy, - PhaseComp::ViewType phaseCompFraction, - FluidProp::ViewType totalDensity ); - - pvt::MultiphaseSystem & m_fluid; - - arrayView1d< pvt::PHASE_TYPE > m_phaseTypes; - arrayView1d< real64 const > m_constantPhaseViscosity; - }; - - /** - * @brief Create an update kernel wrapper. - * @return the wrapper - */ - KernelWrapper createKernelWrapper(); - -protected: - - virtual void postInputInitialization() override; - - virtual void initializePostSubGroups() override; - -private: - - void createFluid(); - - /// PVTPackage fluid object - std::unique_ptr< pvt::MultiphaseSystem > m_fluid{}; - - /// PVTPackage phase labels - array1d< pvt::PHASE_TYPE > m_phaseTypes; - - // names of equations of state to use for each phase - string_array m_equationsOfState; - - // Phase viscosity - array1d< real64 > m_constantPhaseViscosity; - - // standard EOS component input - array1d< real64 > m_componentCriticalPressure; - array1d< real64 > m_componentCriticalTemperature; - array1d< real64 > m_componentAcentricFactor; - array1d< real64 > m_componentVolumeShift; - array2d< real64 > m_componentBinaryCoeff; - -}; - -GEOS_HOST_DEVICE -GEOS_FORCE_INLINE -void -CompositionalMultiphaseFluidPVTPackage::KernelWrapper:: - compute( real64 const pressure, - real64 const temperature, - arraySlice1d< real64 const, compflow::USD_COMP - 1 > const & composition, - PhaseProp::SliceType const phaseFraction, - PhaseProp::SliceType const phaseDensity, - PhaseProp::SliceType const phaseMassDensity, - PhaseProp::SliceType const phaseViscosity, - PhaseProp::SliceType const phaseEnthalpy, - PhaseProp::SliceType const phaseInternalEnergy, - PhaseComp::SliceType const phaseCompFraction, - FluidProp::SliceType const totalDensity ) const -{ - GEOS_UNUSED_VAR( phaseEnthalpy, phaseInternalEnergy ); -#if defined(GEOS_DEVICE_COMPILE) - GEOS_ERROR( "This function cannot be used on GPU" ); - GEOS_UNUSED_VAR( m_fluid ); - GEOS_UNUSED_VAR( pressure ); - GEOS_UNUSED_VAR( temperature ); - GEOS_UNUSED_VAR( composition ); - GEOS_UNUSED_VAR( phaseFraction ); - GEOS_UNUSED_VAR( phaseDensity ); - GEOS_UNUSED_VAR( phaseMassDensity ); - GEOS_UNUSED_VAR( phaseViscosity ); - GEOS_UNUSED_VAR( phaseCompFraction ); - GEOS_UNUSED_VAR( totalDensity ); -#else - - using Deriv = constitutive::multifluid::DerivativeOffset; - - integer constexpr maxNumComp = MultiFluidBase::MAX_NUM_COMPONENTS; - integer constexpr maxNumPhase = MultiFluidBase::MAX_NUM_PHASES; - integer const numComp = numComponents(); - integer const numPhase = numPhases(); - - // 1. Convert input mass fractions to mole fractions and keep derivatives - - stdVector< double > compMoleFrac( numComp ); - real64 dCompMoleFrac_dCompMassFrac[maxNumComp][maxNumComp]{}; - - if( m_useMass ) - { - // convert mass fractions to mole fractions - convertToMoleFractions( composition, - compMoleFrac, - dCompMoleFrac_dCompMassFrac ); - } - else - { - for( integer ic = 0; ic < numComp; ++ic ) - { - compMoleFrac[ic] = composition[ic]; - } - } - - // 2. Trigger PVTPackage compute and get back phase split - - m_fluid.Update( pressure, temperature, compMoleFrac ); - - GEOS_WARNING_IF( !m_fluid.hasSucceeded(), - "Phase equilibrium calculations not converged" ); - - pvt::MultiphaseSystemProperties const & props = m_fluid.getMultiphaseSystemProperties(); - - // 3. Extract phase split, phase properties and derivatives from PVTPackage - - for( integer ip = 0; ip < numPhase; ++ip ) - { - pvt::PHASE_TYPE const & phaseType = m_phaseTypes[ip]; - - auto const & frac = props.getPhaseMoleFraction( phaseType ); - auto const & comp = props.getMoleComposition( phaseType ); - auto const & dens = m_useMass ? props.getMassDensity( phaseType ) : props.getMoleDensity( phaseType ); - auto const & massDens = props.getMassDensity( phaseType ); - - phaseFraction.value[ip] = frac.value; - phaseFraction.derivs[ip][Deriv::dP] = frac.dP; - phaseFraction.derivs[ip][Deriv::dT] = frac.dT; - - phaseDensity.value[ip] = dens.value; - phaseDensity.derivs[ip][Deriv::dP] = dens.dP; - phaseDensity.derivs[ip][Deriv::dT] = dens.dT; - - phaseMassDensity.value[ip] = massDens.value; - phaseMassDensity.derivs[ip][Deriv::dP] = massDens.dP; - phaseMassDensity.derivs[ip][Deriv::dT] = massDens.dT; - - // TODO - phaseViscosity.value[ip] = m_constantPhaseViscosity[ip]; - phaseViscosity.derivs[ip][Deriv::dP] = 0.0; - phaseViscosity.derivs[ip][Deriv::dT] = 0.0; - - for( integer jc = 0; jc < numComp; ++jc ) - { - phaseFraction.derivs[ip][Deriv::dC+jc] = frac.dz[jc]; - phaseDensity.derivs[ip][Deriv::dC+jc] = dens.dz[jc]; - phaseMassDensity.derivs[ip][Deriv::dC+jc] = massDens.dz[jc]; - phaseViscosity.derivs[ip][Deriv::dC+jc] = 0.0; // TODO - - phaseCompFraction.value[ip][jc] = comp.value[jc]; - phaseCompFraction.derivs[ip][jc][Deriv::dP] = comp.dP[jc]; - phaseCompFraction.derivs[ip][jc][Deriv::dT] = comp.dT[jc]; - - for( integer ic = 0; ic < numComp; ++ic ) - { - phaseCompFraction.derivs[ip][ic][Deriv::dC+jc] = comp.dz[ic][jc]; - } - } - } - - // 4. if mass variables used instead of molar, perform the conversion - if( m_useMass ) - { - - // unfortunately here, we have to copy the molecular weight coming from PVT package... - real64 phaseMolecularWeight[maxNumPhase]{}; - real64 dPhaseMolecularWeight[maxNumPhase][maxNumComp+2]{}; - - for( integer ip = 0; ip < numPhase; ++ip ) - { - phaseMolecularWeight[ip] = props.getMolecularWeight( m_phaseTypes[ip] ).value; - dPhaseMolecularWeight[ip][Deriv::dP] = props.getMolecularWeight( m_phaseTypes[ip] ).dP; - dPhaseMolecularWeight[ip][Deriv::dT] = props.getMolecularWeight( m_phaseTypes[ip] ).dT; - for( integer ic = 0; ic < numComp; ++ic ) - { - dPhaseMolecularWeight[ip][Deriv::dC+ic] = props.getMolecularWeight( m_phaseTypes[ip] ).dz[ic]; - } - } - - convertToMassFractions( dCompMoleFrac_dCompMassFrac, - phaseMolecularWeight, - dPhaseMolecularWeight, - phaseFraction, - phaseCompFraction, - phaseDensity.derivs, - phaseViscosity.derivs, - phaseEnthalpy.derivs, - phaseInternalEnergy.derivs ); - } - - // 5. Compute total fluid mass/molar density and derivatives - - computeTotalDensity( phaseFraction, - phaseDensity, - totalDensity ); - -#endif -} - -GEOS_HOST_DEVICE -GEOS_FORCE_INLINE -void -CompositionalMultiphaseFluidPVTPackage::KernelWrapper:: - update( localIndex const k, - localIndex const q, - real64 const pressure, - real64 const temperature, - arraySlice1d< geos::real64 const, compflow::USD_COMP - 1 > const & composition ) const -{ - compute( pressure, - temperature, - composition, - m_phaseFraction( k, q ), - m_phaseDensity( k, q ), - m_phaseMassDensity( k, q ), - m_phaseViscosity( k, q ), - m_phaseEnthalpy( k, q ), - m_phaseInternalEnergy( k, q ), - m_phaseCompFraction( k, q ), - m_totalDensity( k, q ) ); -} - -} /* namespace constitutive */ - -} /* namespace geos */ - -#endif //GEOS_CONSTITUTIVE_FLUID_COMPOSITIONALMULTIPHASEFLUIDPVTPACKAGE_HPP_ diff --git a/src/coreComponents/constitutive/fluid/multifluid/constant/InvariantImmiscibleFluid.hpp b/src/coreComponents/constitutive/fluid/multifluid/constant/InvariantImmiscibleFluid.hpp index 243198fa9b4..25a86bd2df6 100644 --- a/src/coreComponents/constitutive/fluid/multifluid/constant/InvariantImmiscibleFluid.hpp +++ b/src/coreComponents/constitutive/fluid/multifluid/constant/InvariantImmiscibleFluid.hpp @@ -22,8 +22,6 @@ class InvariantImmiscibleFluid : public MultiFluidBase static constexpr bool isThermalType() { return false; } - using exec_policy = parallelDevicePolicy<>; - virtual integer getWaterPhaseIndex() const override; void checkTablesParameters( real64 pressure, real64 temperature ) const override; diff --git a/src/coreComponents/constitutive/unitTests/testNegativeTwoPhaseFlash.cpp b/src/coreComponents/constitutive/unitTests/testNegativeTwoPhaseFlash.cpp index e3823bdd9f2..b7decd38199 100644 --- a/src/coreComponents/constitutive/unitTests/testNegativeTwoPhaseFlash.cpp +++ b/src/coreComponents/constitutive/unitTests/testNegativeTwoPhaseFlash.cpp @@ -344,7 +344,7 @@ TEST_P( SoaveRedlichKwong4, testNegativeFlashDerivatives ) } //------------------------------------------------------------------------------- -// Data generated by PVTPackage +// Test data //------------------------------------------------------------------------------- /* UNCRUSTIFY-OFF */ diff --git a/src/coreComponents/constitutiveDrivers/CMakeLists.txt b/src/coreComponents/constitutiveDrivers/CMakeLists.txt index cbc198074d6..e3b7a38416c 100644 --- a/src/coreComponents/constitutiveDrivers/CMakeLists.txt +++ b/src/coreComponents/constitutiveDrivers/CMakeLists.txt @@ -61,13 +61,6 @@ set( constitutiveDrivers_sources set( dependencyList ${parallelDeps} constitutive events ) -if( ENABLE_PVTPackage ) - set( constitutiveDrivers_sources - ${constitutiveDrivers_sources} - fluid/multiFluid/compositional/PVTDriverRunTestCompositionalMultiphaseFluid.cpp - ) -endif() - geos_decorate_link_dependencies( LIST decoratedDependencies DEPENDENCIES ${dependencyList} ) diff --git a/src/coreComponents/constitutiveDrivers/fluid/multiFluid/PVTDriverRunTest.hpp b/src/coreComponents/constitutiveDrivers/fluid/multiFluid/PVTDriverRunTest.hpp index 950088c0f95..e25fdf8d68f 100644 --- a/src/coreComponents/constitutiveDrivers/fluid/multiFluid/PVTDriverRunTest.hpp +++ b/src/coreComponents/constitutiveDrivers/fluid/multiFluid/PVTDriverRunTest.hpp @@ -67,11 +67,11 @@ void PVTDriver::runTest( FLUID_TYPE & fluid, arrayView2d< real64 > const & table bool const outputEnthalpy = fluid.isThermal(); integer const numRows = m_table.size( 0 ); - using ExecPolicy = typename FLUID_TYPE::exec_policy; - forAll< ExecPolicy >( numRows, - [outputMassDensity, outputCompressibility, outputPhaseComposition, outputEnthalpy, - numPhases, numComponents, kernelWrapper, table, composition] - GEOS_HOST_DEVICE ( localIndex const step ) + + forAll< parallelDevicePolicy<> >( numRows, + [outputMassDensity, outputCompressibility, outputPhaseComposition, outputEnthalpy, + numPhases, numComponents, kernelWrapper, table, composition] + GEOS_HOST_DEVICE ( localIndex const step ) { // Index for start of phase properties integer const PHASE_FRACTION = TEMP + 2 + (outputCompressibility ? 1 : 0); diff --git a/src/coreComponents/constitutiveDrivers/fluid/multiFluid/compositional/PVTDriverRunTestCompositionalMultiphaseFluid.cpp b/src/coreComponents/constitutiveDrivers/fluid/multiFluid/compositional/PVTDriverRunTestCompositionalMultiphaseFluid.cpp deleted file mode 100644 index 6506255acce..00000000000 --- a/src/coreComponents/constitutiveDrivers/fluid/multiFluid/compositional/PVTDriverRunTestCompositionalMultiphaseFluid.cpp +++ /dev/null @@ -1,26 +0,0 @@ -/* - * ------------------------------------------------------------------------------------------------------------ - * 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. - * ------------------------------------------------------------------------------------------------------------ - */ - -/* - * PVTDriverRunTestCompositionalMultiphaseFluid.cpp - */ - -#include "constitutiveDrivers/fluid/multiFluid/PVTDriverRunTest.hpp" -#include "constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluidPVTPackage.hpp" - -namespace geos -{ -template void PVTDriver::runTest< constitutive::CompositionalMultiphaseFluidPVTPackage >( constitutive::CompositionalMultiphaseFluidPVTPackage &, arrayView2d< real64 > const & ); -} diff --git a/src/coreComponents/integrationTests/fluidFlowTests/CMakeLists.txt b/src/coreComponents/integrationTests/fluidFlowTests/CMakeLists.txt index 55fc140e56c..35166c392e6 100644 --- a/src/coreComponents/integrationTests/fluidFlowTests/CMakeLists.txt +++ b/src/coreComponents/integrationTests/fluidFlowTests/CMakeLists.txt @@ -1,20 +1,16 @@ # Specify list of tests set( gtest_geosx_tests + testCompMultiphaseFlow.cpp + testCompMultiphaseFlowHybrid.cpp + testCompositionalMultiPhaseMFDPolyhedral.cpp testThermalCompMultiphaseFlow.cpp testThermalSinglePhaseFlow.cpp testTransmissibility.cpp testImmiscibleMultiphaseFlow.cpp + testReactiveCompositionalMultiphaseOBL.cpp testSinglePhaseMFDPolyhedral.cpp testSinglePhaseReactiveTransport.cpp ) -if( ENABLE_PVTPackage ) - list( APPEND gtest_geosx_tests - testCompMultiphaseFlow.cpp - testCompMultiphaseFlowHybrid.cpp - testReactiveCompositionalMultiphaseOBL.cpp - testCompositionalMultiPhaseMFDPolyhedral.cpp ) -endif() - set( tplDependencyList ${parallelDeps} gtest ) set( dependencyList mainInterface testingUtilities ) diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testCompMultiphaseFlow.cpp b/src/coreComponents/integrationTests/fluidFlowTests/testCompMultiphaseFlow.cpp index beab9c48b97..0fae7796dce 100644 --- a/src/coreComponents/integrationTests/fluidFlowTests/testCompMultiphaseFlow.cpp +++ b/src/coreComponents/integrationTests/fluidFlowTests/testCompMultiphaseFlow.cpp @@ -41,7 +41,7 @@ char const * xmlInput = discretization="fluidTPFA" targetRegions="{region}" temperature="297.15" - useMass="1"> + useMass="0"> @@ -69,19 +69,16 @@ char const * xmlInput = - + constantPhaseViscosity="{ 1.0e-3, 1.0e-3 }" /> + scale="0.1"/> + scale="0.2"/> + scale="0.1"/> - + constantPhaseViscosity="{ 1.0e-3, 1.0e-3 }" /> - + constantPhaseViscosity="{ 1.0e-3, 1.0e-3 }" /> - + constantPhaseViscosity="{ 1.0e-3, 1.0e-3 }" /> ( dataGroup.size(), - fluidWrapper, - pres, - temp, - compFrac ); + launch< parallelDevicePolicy<> >( dataGroup.size(), + fluidWrapper, + pres, + temp, + compFrac ); } ); } @@ -2177,16 +2177,16 @@ void CompositionalMultiphaseBase::applyDirichletBC( real64 const time_n, constitutiveUpdatePassThru( fluid, [&] ( auto & castedFluid ) { using FluidType = TYPEOFREF( castedFluid ); - using ExecPolicy = typename FluidType::exec_policy; + typename FluidType::KernelWrapper fluidWrapper = castedFluid.createKernelWrapper(); thermalCompositionalMultiphaseBaseKernels:: FluidUpdateKernel:: - launch< ExecPolicy >( targetSet, - fluidWrapper, - bcPres, - bcTemp, - compFrac ); + launch< parallelDevicePolicy<> >( targetSet, + fluidWrapper, + bcPres, + bcTemp, + compFrac ); } ); arrayView1d< integer const > const ghostRank = diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp index ce6bfa970ae..31dfce3163d 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp @@ -932,15 +932,15 @@ void CompositionalMultiphaseWell::updateFluidModel( WellElementSubRegion & subRe constitutive::constitutiveUpdatePassThru( fluid, [&] ( auto & castedFluid ) { using FluidType = TYPEOFREF( castedFluid ); - using ExecPolicy = typename FluidType::exec_policy; + typename FluidType::KernelWrapper fluidWrapper = castedFluid.createKernelWrapper(); thermalCompositionalMultiphaseBaseKernels:: FluidUpdateKernel:: - launch< ExecPolicy >( subRegion.size(), - fluidWrapper, - pres, - temp, - compFrac ); + launch< parallelDevicePolicy<> >( subRegion.size(), + fluidWrapper, + pres, + temp, + compFrac ); } ); } diff --git a/src/coreComponents/schema/schema.xsd b/src/coreComponents/schema/schema.xsd index 00589e978ab..bd776c2bac0 100644 --- a/src/coreComponents/schema/schema.xsd +++ b/src/coreComponents/schema/schema.xsd @@ -715,10 +715,6 @@ - - - - @@ -6774,7 +6770,6 @@ Information output from lower logLevels is added with the desired log level - @@ -7139,32 +7134,6 @@ if the table is requested to be output in the log, and it is too large, a CSV fi - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/src/coreComponents/schema/schema.xsd.other b/src/coreComponents/schema/schema.xsd.other index 469438cab1a..355f061e7f5 100644 --- a/src/coreComponents/schema/schema.xsd.other +++ b/src/coreComponents/schema/schema.xsd.other @@ -1622,7 +1622,6 @@ A field can represent a physical variable. (pressure, temperature, global compos - @@ -2082,52 +2081,6 @@ A field can represent a physical variable. (pressure, temperature, global compos - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/src/docs/doxygen/GeosxConfig.hpp b/src/docs/doxygen/GeosxConfig.hpp index 21b976a0d4c..424b6923190 100644 --- a/src/docs/doxygen/GeosxConfig.hpp +++ b/src/docs/doxygen/GeosxConfig.hpp @@ -1,3 +1,18 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 GeosxConfig.hpp * @@ -30,7 +45,7 @@ #define GEOS_USE_MPI /// Enables use of OpenMP (CMake option ENABLE_OPENMP) -/* #undef GEOS_USE_OPENMP */ +#define GEOS_USE_OPENMP /// Enables use of CUDA (CMake option ENABLE_CUDA) /* #undef GEOS_USE_CUDA */ @@ -38,15 +53,15 @@ /// Enables use of CUDA NVToolsExt (CMake option ENABLE_CUDA_NVTOOLSEXT) /* #undef GEOS_USE_CUDA_NVTOOLSEXT */ +/// Sets the CUDA stack size in KB (CMake option CUDA_STACK_SIZE) +/* #undef GEOS_CUDA_STACK_SIZE */ + /// Enables use of HIP (CMake option ENABLE_HIP) /* #undef GEOS_USE_HIP */ /// Workaround for FMT compilation issue on some NVCC/PowerPC machines (CMake option ENABLE_FMT_CONST_FORMATTER_WORKAROUND) /* #undef GEOS_USE_FMT_CONST_FORMATTER_WORKAROUND */ -/// Enables use of PVTPackage (CMake option ENABLE_PVTPackage) -#define GEOS_USE_PVTPackage - /// Enables use of Python (CMake option ENABLE_PYTHON) /* #undef GEOS_USE_PYGEOSX */ @@ -68,6 +83,9 @@ /// Enables use of Hypre library (CMake option ENABLE_HYPRE) #define GEOS_USE_HYPRE +/// Enables use of HYPREDRV library (CMake option ENABLE_HYPREDRV) +/* #undef GEOS_USE_HYPREDRV */ + /// Denotes HYPRE using CPU #define GEOS_USE_HYPRE_CPU 0 /// Denotes HYPRE using CUDA @@ -81,7 +99,7 @@ #define GEOS_USE_SUPERLU_DIST /// Enables use of PETSc library (CMake option ENABLE_PETSC) -#define GEOS_USE_PETSC +/* #undef GEOS_USE_PETSC */ /// Enables use of METIS library (CMake option ENABLE_METIS) #define GEOS_USE_METIS @@ -129,22 +147,22 @@ #define HDF5_VERSION 1.12.1 /// Version information for Conduit -#define Conduit_VERSION 0.8.2 +#define Conduit_VERSION 0.9.5 /// Version information for RAJA -#define RAJA_VERSION 2022.10.5 +#define RAJA_VERSION 2025.12.0 /// Version information for umpire -#define umpire_VERSION 2022.10.0 +#define umpire_VERSION 2025.12.0 /// Version information for chai -/* #undef chai_VERSION */ +#define chai_VERSION 2025.12.0 /// Version information for adiak #define adiak_VERSION .. /// Version information for caliper -#define caliper_VERSION 2.8.0 +#define caliper_VERSION .. /// Version information for Metis #define metis_VERSION 5.1.0 @@ -153,7 +171,7 @@ #define parmetis_VERSION 4.0.0 /// Version information for scotch -#define scotch_VERSION 6.0.9 +/* #undef scotch_VERSION */ /// Version information for superlu_dist #define superlu_dist_VERSION 6.3.0 @@ -162,22 +180,22 @@ #define suitesparse_VERSION 5.7.9 /// Version information for hypre -#define hypre_VERSION 2.29.0 +#define hypre_VERSION 3.1.0 /// Version information for trilinos -#define trilinos_VERSION 13.4.1 +#define trilinos_VERSION 16.1.0 /// Version information for petsc -#define petsc_VERSION 3.13.0 +/* #undef petsc_VERSION */ /// Version information for VTK -#define VTK_VERSION 9.2.6 +#define VTK_VERSION 9.4.2 /// Version information for fmt -#define fmt_VERSION 10.0.0 +/* #undef fmt_VERSION */ /// Version information for python -#define Python3_VERSION 3.10.6 +#define Python3_VERSION 3.9.13 /// Version information for CUDAToolkit /* #undef CUDAToolkit_VERSION */ @@ -191,4 +209,3 @@ #endif #endif /* GEOS_CONFIG_HPP */ - diff --git a/src/docs/sphinx/QuickStart.rst b/src/docs/sphinx/QuickStart.rst index c87bb11962a..7305fea884c 100644 --- a/src/docs/sphinx/QuickStart.rst +++ b/src/docs/sphinx/QuickStart.rst @@ -89,7 +89,7 @@ The main repository of interest is obviously GEOS itself: `GEOS `_ or the streamlined CMake-based foundation `BLT `_ . +For example, there is a chemical reactions package called `HPCReact `_ or the streamlined CMake-based foundation `BLT `_ . These packages are handled as `Git Submodules `_, which provides a transparent way of coordinating multiple code development projects. Most users will never have to worry that these modules are in fact separate projects from GEOS. @@ -179,8 +179,9 @@ The most common errors people encounter here have to do with Github not recogniz See the previous section for tips on ensuring your SSH is working properly. *Note*: Previous versions of GEOS also imported the integratedTests submodule, which is not publicly available (access is limited to the core development team). +Previous versions also included the PVTPackage which is no longer required. This may cause the ``git submodule update`` command to fail. -In that case, run ``git submodule deinit integratedTests`` before ``git submodule update``. +In that case, run ``git submodule deinit integratedTests`` and/or ``git submodule deinit src/coreComponents/constitutive/PVTPackage`` before ``git submodule update``. This submodule is not required for building GEOS. .. code-block:: sh @@ -189,7 +190,6 @@ This submodule is not required for building GEOS. git submodule update --init src/cmake/blt git submodule update --init src/coreComponents/LvArray git submodule update --init src/coreComponents/fileIO/coupling/hdf5_interface - git submodule update --init src/coreComponents/constitutive/PVTPackage cd .. Once we have grabbed GEOS, we do the same for the thirdPartyLibs repository. From the ``codes`` directory, type diff --git a/src/docs/sphinx/buildGuide/BuildProcess.rst b/src/docs/sphinx/buildGuide/BuildProcess.rst index cd3910c451c..3fcff6c15b3 100644 --- a/src/docs/sphinx/buildGuide/BuildProcess.rst +++ b/src/docs/sphinx/buildGuide/BuildProcess.rst @@ -71,7 +71,6 @@ Option Default Explanation ``ENABLE_HIP`` ``OFF`` Build with HIP/ROCM (also applies to TPLs) ``ENABLE_DOCS`` ``ON`` Build documentation (Sphinx and Doxygen) ``ENABLE_WARNINGS_AS_ERRORS`` ``ON`` Treat all warnings as errors -``ENABLE_PVTPackage`` ``ON`` Enable PVTPackage library (required for compositional flow runs) ``ENABLE_TOTALVIEW_OUTPUT`` ``OFF`` Enables TotalView debugger custom view of GEOS data structures ``ENABLE_COV`` ``OFF`` Enables code coverage ``GEOS_ENABLE_TESTS`` ``ON`` Enables unit testing targets diff --git a/src/docs/sphinx/developerGuide/Contributing/GitWorkflow.rst b/src/docs/sphinx/developerGuide/Contributing/GitWorkflow.rst index c3cd039dc12..690cd3049f8 100644 --- a/src/docs/sphinx/developerGuide/Contributing/GitWorkflow.rst +++ b/src/docs/sphinx/developerGuide/Contributing/GitWorkflow.rst @@ -439,5 +439,4 @@ blt develop LvArray develop integratedTests develop hdf5_interface master -PVTPackage master ================ ================ From 426a9bba5b7a0132a55f8851d0afc777c56b0bc8 Mon Sep 17 00:00:00 2001 From: Nicolas Pillardou <71120126+npillardou@users.noreply.github.com> Date: Wed, 27 May 2026 16:29:15 +0200 Subject: [PATCH 48/53] fix: Change hard-coded PorousSolid model for ALM (#4062) This PR corrects the use of hard-coded Porous Solid model for ALM solver from : PorousSolid< ElasticIsotropic, ConstantPermeability > to a type dispatch list. This allows to setup other kind of mechanical model for matrix surrounding faults such as Drucker-Prager. Also, switch to iterative solver to fix timeout issue in inputFiles/singlePhaseFlow/FieldCaseTutorial3_Thermal_smoke.xml --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 3 + .../ALM_inclinedFault_ESG_smoke.xml | 245 +++++++++++++++++ ..._inclinedFault_ISG_DruckerPrager_smoke.xml | 256 ++++++++++++++++++ .../ALM_inclinedFault_ISG_smoke.xml | 252 +++++++++++++++++ .../ALM_inclinedFault_base.xml | 163 +++++++++++ ...ltiphasePoromechanics_curvedFrac_smoke.xml | 4 +- ...glephasePoromechanics_curvedFrac_smoke.xml | 0 .../AugmentedLagrangianMultipliers.ats | 59 ++++ ...peningFrac_horizontal_sequential_smoke.xml | 2 +- ...ture_2d_openingFrac_sequential_solvers.xml | 0 ..._openingFrac_vertical_sequential_smoke.xml | 2 +- .../curvedFrac_base.xml | 0 .../curvedFrac_smoke.xml | 2 +- ...ayPermeability_conformingFracture_base.xml | 0 ...yPermeability_conformingFracture_smoke.xml | 0 .../LagrangianMultipliers.ats} | 78 +----- ...racture_2d_faultSlip_BartonBandis_base.xml | 0 ...re_2d_faultSlip_BartonBandis_benchmark.xml | 0 ...acture_2d_faultSlip_BartonBandis_smoke.xml | 0 ...c_conformingFracture_2d_faultSlip_base.xml | 0 ...formingFracture_2d_faultSlip_benchmark.xml | 0 ...ture_2d_faultSlip_sequential_benchmark.xml | 0 ...Fracture_2d_faultSlip_sequential_smoke.xml | 0 ...acture_2d_faultSlip_sequential_solvers.xml | 0 ..._conformingFracture_2d_faultSlip_smoke.xml | 0 ...onformingFracture_2d_faultSlip_solvers.xml | 0 ...conformingFracture_2d_openingFrac_base.xml | 0 ...peningFrac_horizontal_sequential_smoke.xml | 0 ...acture_2d_openingFrac_horizontal_smoke.xml | 0 ...ture_2d_openingFrac_sequential_solvers.xml | 0 ...formingFracture_2d_openingFrac_solvers.xml | 0 ...ture_2d_openingFrac_vertical_benchmark.xml | 0 ...ningFrac_vertical_sequential_benchmark.xml | 0 ..._openingFrac_vertical_sequential_smoke.xml | 0 ...Fracture_2d_openingFrac_vertical_smoke.xml | 0 .../PoroElastic_dfm_PEBICrack_base.xml | 0 .../PoroElastic_dfm_PEBICrack_smoke.xml | 196 +++++++------- ...ultiphasePoromechanics_FaultModel_base.xml | 24 +- ...ltiphasePoromechanics_FaultModel_smoke.xml | 2 +- ...hasePoromechanics_FaultModel_well_base.xml | 24 +- ...oromechanics_FaultModel_well_fim_smoke.xml | 2 +- ...oromechanics_FaultModel_well_seq_smoke.xml | 2 +- ...nglePhasePoromechanics_FaultModel_base.xml | 16 +- ...glePhasePoromechanics_FaultModel_smoke.xml | 2 +- ...hasePoromechanics_FaultModel_well_base.xml | 2 +- ...echanics_FaultModel_well_fim_new_smoke.xml | 0 ...oromechanics_FaultModel_well_seq_smoke.xml | 0 ...glePhasePoromechanics_WellInFault_base.xml | 2 +- ...asePoromechanics_WellInFault_fim_smoke.xml | 0 ...asePoromechanics_WellInFault_seq_smoke.xml | 0 .../yieldAcceleration/final_split_domain.vtu | 0 .../yieldAcceleration/final_split_fault.vtu | 0 .../yieldAcceleration/mesh_faultModel.vtm | 0 .../validation_case_base.xml | 0 .../validation_case_smoke_fim.xml | 0 .../validation_case_smoke_seq.xml | 0 .../validation_case_solvers_fim.xml | 0 .../validation_case_solvers_seq.xml | 0 .../poromechanicsFractures/EDFM/EDFM.ats | 52 ++++ ...ExponentialDecayPermeability_edfm_base.xml | 0 ...xponentialDecayPermeability_edfm_smoke.xml | 0 .../{ => EDFM}/PoroElastic_efem-edfm_base.xml | 0 .../PoroElastic_efem-edfm_eggModel_large.xml | 0 .../PoroElastic_efem-edfm_eggModel_small.xml | 0 ...oroElastic_efem-edfm_inclinedFrac_base.xml | 0 ...astic_efem-edfm_inclinedFrac_benchmark.xml | 0 ...roElastic_efem-edfm_inclinedFrac_smoke.xml | 0 .../PoroElastic_efem-edfm_pennyCrack_base.xml | 0 ...Elastic_efem-edfm_pennyCrack_benchmark.xml | 0 ...PoroElastic_efem-edfm_pennyCrack_smoke.xml | 0 ...lastic_efem-edfm_pressurizedFrac_smoke.xml | 0 ...oroElastic_efem-edfm_verticalFrac_base.xml | 0 ...astic_efem-edfm_verticalFrac_benchmark.xml | 0 ...roElastic_efem-edfm_verticalFrac_smoke.xml | 0 .../SlipPermeability_embeddedFrac.xml | 0 .../SlipPermeability_pEDFM_base.xml | 0 .../SlipPermeability_pEDFM_smoke.xml | 0 ...lisRichardsPermeability_efem-edfm_base.xml | 0 ...isRichardsPermeability_efem-edfm_smoke.xml | 0 .../{ => MESH}/Domain_Mesh_FaultModel.vtu | 0 .../{ => MESH}/Fault_Mesh_FaultModel.vtu | 0 .../{ => MESH}/curvedFrac_coarse.vtm | 0 .../{ => MESH}/curvedFrac_domain.vtu | 0 .../{ => MESH}/curvedFrac_fracture.vtu | 0 .../{ => MESH}/displacedFault.vtm | 0 .../{ => MESH}/domain_res5_id.vtu | 0 .../MESH/fault_contact_hex.vtm | 7 + .../MESH/fault_contact_hex_fault_ids.vtu | 52 ++++ .../MESH/fault_contact_hex_mesh_ids.vtu | 44 +++ .../fault_contact_hex_mesh_with_node_sets.vtu | 26 ++ .../{ => MESH}/fracture_res5_id.vtu | 0 .../{ => MESH}/verticalFault_ExternalMesh.vtm | 0 .../{ => MULTIPHASE_TABLES}/co2flash.txt | 0 .../{ => MULTIPHASE_TABLES}/elevation.txt | 0 .../initCO2CompFrac.txt | 0 .../{ => MULTIPHASE_TABLES}/initTemp.txt | 0 .../initWaterCompFrac.txt | 0 .../phaseVolFraction_gas.txt | 0 .../phaseVolFraction_water.txt | 0 .../{ => MULTIPHASE_TABLES}/pvtgas.txt | 0 .../pvtgas_curvedFrac.txt} | 0 .../{ => MULTIPHASE_TABLES}/pvtliquid.txt | 0 .../pvtwat.txt | 0 .../{ => MULTIPHASE_TABLES}/relPerm_gas.txt | 0 .../{ => MULTIPHASE_TABLES}/relPerm_water.txt | 0 .../multiphase_fluid/co2flash.txt | 1 - .../FieldCaseTutorial3_Thermal_base.xml | 3 +- .../solidMechanics/CMakeLists.txt | 5 +- ...lidMechanicsAugmentedLagrangianContact.cpp | 12 +- ...hanicsALMContactPorousKernels.cpp.template | 40 +++ .../solidMechanics/kernelSpecs.json | 36 +++ 112 files changed, 1393 insertions(+), 225 deletions(-) create mode 100755 inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ESG_smoke.xml create mode 100755 inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_DruckerPrager_smoke.xml create mode 100755 inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_smoke.xml create mode 100755 inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_base.xml rename inputFiles/poromechanicsFractures/{ => Contact/AugmentedLagrangianMultipliers}/ALM_multiphasePoromechanics_curvedFrac_smoke.xml (97%) rename inputFiles/poromechanicsFractures/{ => Contact/AugmentedLagrangianMultipliers}/ALM_singlephasePoromechanics_curvedFrac_smoke.xml (100%) create mode 100644 inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/AugmentedLagrangianMultipliers.ats rename inputFiles/poromechanicsFractures/{ => Contact/AugmentedLagrangianMultipliers}/PoroElastic_ALM_conformingFracture_2d_openingFrac_horizontal_sequential_smoke.xml (97%) rename inputFiles/poromechanicsFractures/{ => Contact/AugmentedLagrangianMultipliers}/PoroElastic_ALM_conformingFracture_2d_openingFrac_sequential_solvers.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/AugmentedLagrangianMultipliers}/PoroElastic_ALM_conformingFracture_2d_openingFrac_vertical_sequential_smoke.xml (97%) rename inputFiles/poromechanicsFractures/{ => Contact/AugmentedLagrangianMultipliers}/curvedFrac_base.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/AugmentedLagrangianMultipliers}/curvedFrac_smoke.xml (96%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/ExponentialDecayPermeability_conformingFracture_base.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/ExponentialDecayPermeability_conformingFracture_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{poromechanicsFractures.ats => Contact/LagrangianMultipliers/LagrangianMultipliers.ats} (52%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_base.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_benchmark.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_faultSlip_base.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_faultSlip_benchmark.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_faultSlip_sequential_benchmark.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_faultSlip_sequential_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_faultSlip_sequential_solvers.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_faultSlip_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_faultSlip_solvers.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_openingFrac_base.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_openingFrac_horizontal_sequential_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_openingFrac_horizontal_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_openingFrac_sequential_solvers.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_openingFrac_solvers.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_openingFrac_vertical_benchmark.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_openingFrac_vertical_sequential_benchmark.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_openingFrac_vertical_sequential_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_conformingFracture_2d_openingFrac_vertical_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_dfm_PEBICrack_base.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/PoroElastic_dfm_PEBICrack_smoke.xml (94%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/multiphasePoromechanics_FaultModel_base.xml (84%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/multiphasePoromechanics_FaultModel_smoke.xml (98%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/multiphasePoromechanics_FaultModel_well_base.xml (86%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/multiphasePoromechanics_FaultModel_well_fim_smoke.xml (98%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/multiphasePoromechanics_FaultModel_well_seq_smoke.xml (98%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/singlePhasePoromechanics_FaultModel_base.xml (89%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/singlePhasePoromechanics_FaultModel_smoke.xml (98%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/singlePhasePoromechanics_FaultModel_well_base.xml (99%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/singlePhasePoromechanics_FaultModel_well_fim_new_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/singlePhasePoromechanics_FaultModel_well_seq_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/singlePhasePoromechanics_WellInFault_base.xml (99%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/singlePhasePoromechanics_WellInFault_fim_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/singlePhasePoromechanics_WellInFault_seq_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/yieldAcceleration/final_split_domain.vtu (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/yieldAcceleration/final_split_fault.vtu (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/yieldAcceleration/mesh_faultModel.vtm (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/yieldAcceleration/validation_case_base.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/yieldAcceleration/validation_case_smoke_fim.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/yieldAcceleration/validation_case_smoke_seq.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/yieldAcceleration/validation_case_solvers_fim.xml (100%) rename inputFiles/poromechanicsFractures/{ => Contact/LagrangianMultipliers}/yieldAcceleration/validation_case_solvers_seq.xml (100%) create mode 100644 inputFiles/poromechanicsFractures/EDFM/EDFM.ats rename inputFiles/poromechanicsFractures/{ => EDFM}/ExponentialDecayPermeability_edfm_base.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/ExponentialDecayPermeability_edfm_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/PoroElastic_efem-edfm_base.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/PoroElastic_efem-edfm_eggModel_large.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/PoroElastic_efem-edfm_eggModel_small.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/PoroElastic_efem-edfm_inclinedFrac_base.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/PoroElastic_efem-edfm_inclinedFrac_benchmark.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/PoroElastic_efem-edfm_inclinedFrac_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/PoroElastic_efem-edfm_pennyCrack_base.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/PoroElastic_efem-edfm_pennyCrack_benchmark.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/PoroElastic_efem-edfm_pennyCrack_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/PoroElastic_efem-edfm_pressurizedFrac_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/PoroElastic_efem-edfm_verticalFrac_base.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/PoroElastic_efem-edfm_verticalFrac_benchmark.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/PoroElastic_efem-edfm_verticalFrac_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/SlipPermeability_embeddedFrac.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/SlipPermeability_pEDFM_base.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/SlipPermeability_pEDFM_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/WillisRichardsPermeability_efem-edfm_base.xml (100%) rename inputFiles/poromechanicsFractures/{ => EDFM}/WillisRichardsPermeability_efem-edfm_smoke.xml (100%) rename inputFiles/poromechanicsFractures/{ => MESH}/Domain_Mesh_FaultModel.vtu (100%) rename inputFiles/poromechanicsFractures/{ => MESH}/Fault_Mesh_FaultModel.vtu (100%) rename inputFiles/poromechanicsFractures/{ => MESH}/curvedFrac_coarse.vtm (100%) rename inputFiles/poromechanicsFractures/{ => MESH}/curvedFrac_domain.vtu (100%) rename inputFiles/poromechanicsFractures/{ => MESH}/curvedFrac_fracture.vtu (100%) rename inputFiles/poromechanicsFractures/{ => MESH}/displacedFault.vtm (100%) rename inputFiles/poromechanicsFractures/{ => MESH}/domain_res5_id.vtu (100%) create mode 100755 inputFiles/poromechanicsFractures/MESH/fault_contact_hex.vtm create mode 100755 inputFiles/poromechanicsFractures/MESH/fault_contact_hex_fault_ids.vtu create mode 100755 inputFiles/poromechanicsFractures/MESH/fault_contact_hex_mesh_ids.vtu create mode 100755 inputFiles/poromechanicsFractures/MESH/fault_contact_hex_mesh_with_node_sets.vtu rename inputFiles/poromechanicsFractures/{ => MESH}/fracture_res5_id.vtu (100%) rename inputFiles/poromechanicsFractures/{ => MESH}/verticalFault_ExternalMesh.vtm (100%) rename inputFiles/poromechanicsFractures/{ => MULTIPHASE_TABLES}/co2flash.txt (100%) rename inputFiles/poromechanicsFractures/{ => MULTIPHASE_TABLES}/elevation.txt (100%) rename inputFiles/poromechanicsFractures/{ => MULTIPHASE_TABLES}/initCO2CompFrac.txt (100%) rename inputFiles/poromechanicsFractures/{ => MULTIPHASE_TABLES}/initTemp.txt (100%) rename inputFiles/poromechanicsFractures/{ => MULTIPHASE_TABLES}/initWaterCompFrac.txt (100%) rename inputFiles/poromechanicsFractures/{ => MULTIPHASE_TABLES}/phaseVolFraction_gas.txt (100%) rename inputFiles/poromechanicsFractures/{ => MULTIPHASE_TABLES}/phaseVolFraction_water.txt (100%) rename inputFiles/poromechanicsFractures/{ => MULTIPHASE_TABLES}/pvtgas.txt (100%) rename inputFiles/poromechanicsFractures/{multiphase_fluid/pvtgas.txt => MULTIPHASE_TABLES/pvtgas_curvedFrac.txt} (100%) rename inputFiles/poromechanicsFractures/{ => MULTIPHASE_TABLES}/pvtliquid.txt (100%) rename inputFiles/poromechanicsFractures/{multiphase_fluid => MULTIPHASE_TABLES}/pvtwat.txt (100%) rename inputFiles/poromechanicsFractures/{ => MULTIPHASE_TABLES}/relPerm_gas.txt (100%) rename inputFiles/poromechanicsFractures/{ => MULTIPHASE_TABLES}/relPerm_water.txt (100%) delete mode 100644 inputFiles/poromechanicsFractures/multiphase_fluid/co2flash.txt create mode 100644 src/coreComponents/physicsSolvers/solidMechanics/contact/kernels/SolidMechanicsALMContactPorousKernels.cpp.template diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index de37c7e6147..e1ea844bc05 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr4057-16739-5dde641 + baseline: integratedTests/baseline_integratedTests-pr4062-16784-6d8782e allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index 5909bd5d0bd..2e69f9d42db 100644 --- a/BASELINE_NOTES.md +++ b/BASELINE_NOTES.md @@ -5,6 +5,9 @@ This file is designed to track changes to the integrated test baselines. Any developer who updates the baseline ID in the .integrated_tests.yaml file is expected to create an entry in this file with the pull request number, date, and their justification for rebaselining. These notes should be in reverse-chronological order, and use the following time format: (YYYY-MM-DD). +PR #4062 (2026-05-26) +Add Porous Solid other than PorousElasticity for ALM solver + PR #4057 (2026-05-21) Remove dependency on PVT package diff --git a/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ESG_smoke.xml b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ESG_smoke.xml new file mode 100755 index 00000000000..feaf2b63d3f --- /dev/null +++ b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ESG_smoke.xml @@ -0,0 +1,245 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_DruckerPrager_smoke.xml b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_DruckerPrager_smoke.xml new file mode 100755 index 00000000000..b3ca9b80281 --- /dev/null +++ b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_DruckerPrager_smoke.xml @@ -0,0 +1,256 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_smoke.xml b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_smoke.xml new file mode 100755 index 00000000000..85382db0112 --- /dev/null +++ b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_smoke.xml @@ -0,0 +1,252 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_base.xml b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_base.xml new file mode 100755 index 00000000000..0df32c00838 --- /dev/null +++ b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_base.xml @@ -0,0 +1,163 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/inputFiles/poromechanicsFractures/ALM_multiphasePoromechanics_curvedFrac_smoke.xml b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_multiphasePoromechanics_curvedFrac_smoke.xml similarity index 97% rename from inputFiles/poromechanicsFractures/ALM_multiphasePoromechanics_curvedFrac_smoke.xml rename to inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_multiphasePoromechanics_curvedFrac_smoke.xml index 7e40ab72e7d..af481771ac6 100644 --- a/inputFiles/poromechanicsFractures/ALM_multiphasePoromechanics_curvedFrac_smoke.xml +++ b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_multiphasePoromechanics_curvedFrac_smoke.xml @@ -121,8 +121,8 @@ phaseNames="{ gas, water }" componentNames="{ co2, water }" componentMolarWeight="{ 44e-3, 18e-3 }" - phasePVTParaFiles="{ multiphase_fluid/pvtgas.txt, multiphase_fluid/pvtwat.txt }" - flashModelParaFile="multiphase_fluid/co2flash.txt" /> + phasePVTParaFiles="{ ../../MULTIPHASE_TABLES/pvtgas_curvedFrac.txt, ../../MULTIPHASE_TABLES/pvtwat.txt }" + flashModelParaFile="../../MULTIPHASE_TABLES/co2flash.txt" /> + name="../LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_base.xml"/> diff --git a/inputFiles/poromechanicsFractures/PoroElastic_ALM_conformingFracture_2d_openingFrac_sequential_solvers.xml b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/PoroElastic_ALM_conformingFracture_2d_openingFrac_sequential_solvers.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_ALM_conformingFracture_2d_openingFrac_sequential_solvers.xml rename to inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/PoroElastic_ALM_conformingFracture_2d_openingFrac_sequential_solvers.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_ALM_conformingFracture_2d_openingFrac_vertical_sequential_smoke.xml b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/PoroElastic_ALM_conformingFracture_2d_openingFrac_vertical_sequential_smoke.xml similarity index 97% rename from inputFiles/poromechanicsFractures/PoroElastic_ALM_conformingFracture_2d_openingFrac_vertical_sequential_smoke.xml rename to inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/PoroElastic_ALM_conformingFracture_2d_openingFrac_vertical_sequential_smoke.xml index caff7079cac..8c91e75b1cc 100755 --- a/inputFiles/poromechanicsFractures/PoroElastic_ALM_conformingFracture_2d_openingFrac_vertical_sequential_smoke.xml +++ b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/PoroElastic_ALM_conformingFracture_2d_openingFrac_vertical_sequential_smoke.xml @@ -7,7 +7,7 @@ + name="../LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_base.xml"/> diff --git a/inputFiles/poromechanicsFractures/curvedFrac_base.xml b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/curvedFrac_base.xml similarity index 100% rename from inputFiles/poromechanicsFractures/curvedFrac_base.xml rename to inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/curvedFrac_base.xml diff --git a/inputFiles/poromechanicsFractures/curvedFrac_smoke.xml b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/curvedFrac_smoke.xml similarity index 96% rename from inputFiles/poromechanicsFractures/curvedFrac_smoke.xml rename to inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/curvedFrac_smoke.xml index 93b066af107..25244776d54 100644 --- a/inputFiles/poromechanicsFractures/curvedFrac_smoke.xml +++ b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/curvedFrac_smoke.xml @@ -11,7 +11,7 @@ name="mesh1" useGlobalIds="1" faceBlocks="{ fracture }" - file="curvedFrac_coarse.vtm"/> + file="../../MESH/curvedFrac_coarse.vtm"/> diff --git a/inputFiles/poromechanicsFractures/ExponentialDecayPermeability_conformingFracture_base.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/ExponentialDecayPermeability_conformingFracture_base.xml similarity index 100% rename from inputFiles/poromechanicsFractures/ExponentialDecayPermeability_conformingFracture_base.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/ExponentialDecayPermeability_conformingFracture_base.xml diff --git a/inputFiles/poromechanicsFractures/ExponentialDecayPermeability_conformingFracture_smoke.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/ExponentialDecayPermeability_conformingFracture_smoke.xml similarity index 100% rename from inputFiles/poromechanicsFractures/ExponentialDecayPermeability_conformingFracture_smoke.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/ExponentialDecayPermeability_conformingFracture_smoke.xml diff --git a/inputFiles/poromechanicsFractures/poromechanicsFractures.ats b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/LagrangianMultipliers.ats similarity index 52% rename from inputFiles/poromechanicsFractures/poromechanicsFractures.ats rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/LagrangianMultipliers.ats index 6dc19c8b255..dd215521351 100644 --- a/inputFiles/poromechanicsFractures/poromechanicsFractures.ats +++ b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/LagrangianMultipliers.ats @@ -1,22 +1,10 @@ from geos.ats.test_builder import TestDeck, RestartcheckParameters, generate_geos_tests +glue(collection='poromechanicsFractures') + restartcheck_params = {'atol': 1e-07, 'rtol': 4e-06} decks = [ - TestDeck( - name="SlipPermeability_pEDFM_smoke", - description='pEDFM slip dependent permeability case', - partitions=((1, 1, 1), (2, 2, 1)), - restart_step=0, - check_step=1, - restartcheck_params=RestartcheckParameters(**restartcheck_params)), - TestDeck( - name="WillisRichardsPermeability_efem-edfm_smoke", - description='WillisRichards Permeability model with EDFM', - partitions=((1, 1, 1), (2, 2, 1)), - restart_step=0, - check_step=5, - restartcheck_params=RestartcheckParameters(**restartcheck_params)), TestDeck( name="PoroElastic_conformingFracture_2d_openingFrac_horizontal_smoke", description='PoroElastic conformingFracture 2d case', @@ -31,13 +19,6 @@ decks = [ restart_step=0, check_step=10, restartcheck_params=RestartcheckParameters(**restartcheck_params)), - TestDeck( - name="PoroElastic_ALM_conformingFracture_2d_openingFrac_horizontal_sequential_smoke", - description='PoroElastic ALM conformingFracture 2d case (sequential)', - partitions=((1, 1, 1), (2, 2, 1)), - restart_step=0, - check_step=10, - restartcheck_params=RestartcheckParameters(**restartcheck_params)), TestDeck( name="PoroElastic_conformingFracture_2d_openingFrac_vertical_smoke", description='PoroElastic conformingFracture 2d case', @@ -53,48 +34,13 @@ decks = [ check_step=10, restartcheck_params=RestartcheckParameters(**restartcheck_params)), TestDeck( - name="PoroElastic_ALM_conformingFracture_2d_openingFrac_vertical_sequential_smoke", - description='PoroElastic ALM conformingFracture 2d case (sequential)', - partitions=((1, 1, 1), (2, 2, 1)), - restart_step=0, - check_step=10, - restartcheck_params=RestartcheckParameters(**restartcheck_params)), - TestDeck( - name="PoroElastic_efem-edfm_pressurizedFrac_smoke", - description='poromechanics efem-edfm pressurized vertical frac', - partitions=((1, 1, 1), (2, 2, 1)), - restart_step=0, - check_step=1, - restartcheck_params=RestartcheckParameters(**restartcheck_params)), - TestDeck( - name="PoroElastic_efem-edfm_verticalFrac_smoke", - description='poromechanics efem-edfm vertical frac', - partitions=((1, 1, 1), (2, 2, 1)), - restart_step=0, - check_step=1, - restartcheck_params=RestartcheckParameters(**restartcheck_params)), - TestDeck( - name="PoroElastic_efem-edfm_inclinedFrac_smoke", - description='poromechanics efem-edfm inclined frac', - partitions=((1, 1, 1), (2, 2, 1)), - restart_step=0, - check_step=1, - restartcheck_params=RestartcheckParameters(**restartcheck_params)), - TestDeck( - name="ExponentialDecayPermeability_edfm_smoke", - description='Exponential Decay Permeability model with EDFM', - partitions=((1, 1, 1), (2, 2, 1)), - restart_step=0, - check_step=5, - restartcheck_params=RestartcheckParameters(**restartcheck_params)), - TestDeck(name="ExponentialDecayPermeability_conformingFracture_smoke", - description= - 'Exponential Decay Permeability model with conforming fracture', + name="ExponentialDecayPermeability_conformingFracture_smoke", + description='Exponential Decay Permeability model with conforming fracture', partitions=((1, 1, 1), (2, 2, 1)), restart_step=0, check_step=12, restartcheck_params=RestartcheckParameters(atol=1e-05, rtol=4e-04)), - TestDeck( + TestDeck( name="PoroElastic_dfm_PEBICrack_smoke", description='Plane strain poro-elastic problems with conforming vertical fracture (unstructured PEBI grid)', partitions=((1, 1, 1), (3, 1, 1)), @@ -136,20 +82,6 @@ decks = [ restart_step=0, check_step=1, restartcheck_params=RestartcheckParameters(atol=1e-05, rtol=1e-04)), - TestDeck( - name="ALM_singlephasePoromechanics_curvedFrac_smoke", - description='PoroElastic ALM conformingFracture with two curved fractures and singlePhase', - partitions=((1, 1, 1), (4, 1, 1)), - restart_step=1, - check_step=2, - restartcheck_params=RestartcheckParameters(atol=1e-05, rtol=1e-04)), - TestDeck( - name="ALM_multiphasePoromechanics_curvedFrac_smoke", - description='PoroElastic ALM conformingFracture with two curved fractures and multiPhase', - partitions=((1, 1, 1), (4, 1, 1)), - restart_step=1, - check_step=2, - restartcheck_params=RestartcheckParameters(atol=1e-05, rtol=1e-04)) ] generate_geos_tests(decks) diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_base.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_base.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_base.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_base.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_benchmark.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_benchmark.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_benchmark.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_benchmark.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_smoke.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_smoke.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_smoke.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_BartonBandis_smoke.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_base.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_base.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_base.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_base.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_benchmark.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_benchmark.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_benchmark.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_benchmark.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_sequential_benchmark.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_sequential_benchmark.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_sequential_benchmark.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_sequential_benchmark.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_sequential_smoke.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_sequential_smoke.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_sequential_smoke.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_sequential_smoke.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_sequential_solvers.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_sequential_solvers.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_sequential_solvers.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_sequential_solvers.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_smoke.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_smoke.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_smoke.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_smoke.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_solvers.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_solvers.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_faultSlip_solvers.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_faultSlip_solvers.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_base.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_base.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_base.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_base.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_horizontal_sequential_smoke.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_horizontal_sequential_smoke.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_horizontal_sequential_smoke.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_horizontal_sequential_smoke.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_horizontal_smoke.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_horizontal_smoke.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_horizontal_smoke.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_horizontal_smoke.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_sequential_solvers.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_sequential_solvers.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_sequential_solvers.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_sequential_solvers.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_solvers.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_solvers.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_solvers.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_solvers.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_vertical_benchmark.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_vertical_benchmark.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_vertical_benchmark.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_vertical_benchmark.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_vertical_sequential_benchmark.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_vertical_sequential_benchmark.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_vertical_sequential_benchmark.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_vertical_sequential_benchmark.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_vertical_sequential_smoke.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_vertical_sequential_smoke.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_vertical_sequential_smoke.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_vertical_sequential_smoke.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_vertical_smoke.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_vertical_smoke.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_conformingFracture_2d_openingFrac_vertical_smoke.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_conformingFracture_2d_openingFrac_vertical_smoke.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_dfm_PEBICrack_base.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_dfm_PEBICrack_base.xml similarity index 100% rename from inputFiles/poromechanicsFractures/PoroElastic_dfm_PEBICrack_base.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_dfm_PEBICrack_base.xml diff --git a/inputFiles/poromechanicsFractures/PoroElastic_dfm_PEBICrack_smoke.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_dfm_PEBICrack_smoke.xml similarity index 94% rename from inputFiles/poromechanicsFractures/PoroElastic_dfm_PEBICrack_smoke.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_dfm_PEBICrack_smoke.xml index 7de947a55d6..52dd8e9b7a4 100644 --- a/inputFiles/poromechanicsFractures/PoroElastic_dfm_PEBICrack_smoke.xml +++ b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/PoroElastic_dfm_PEBICrack_smoke.xml @@ -1,98 +1,98 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/inputFiles/poromechanicsFractures/multiphasePoromechanics_FaultModel_base.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_base.xml similarity index 84% rename from inputFiles/poromechanicsFractures/multiphasePoromechanics_FaultModel_base.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_base.xml index fc1798c6851..a2c60aeab07 100644 --- a/inputFiles/poromechanicsFractures/multiphasePoromechanics_FaultModel_base.xml +++ b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_base.xml @@ -18,8 +18,8 @@ phaseNames="{ gas, water }" componentNames="{ co2, water }" componentMolarWeight="{ 44e-3, 18e-3 }" - phasePVTParaFiles="{ pvtgas.txt, pvtliquid.txt }" - flashModelParaFile="co2flash.txt"/> + phasePVTParaFiles="{ ../../MULTIPHASE_TABLES/pvtgas.txt, ../../MULTIPHASE_TABLES/pvtliquid.txt }" + flashModelParaFile="../../MULTIPHASE_TABLES/co2flash.txt"/> + coordinateFiles="{ ../../MULTIPHASE_TABLES/elevation.txt }" + voxelFile="../../MULTIPHASE_TABLES/initCO2CompFrac.txt"/> + coordinateFiles="{ ../../MULTIPHASE_TABLES/elevation.txt }" + voxelFile="../../MULTIPHASE_TABLES/initWaterCompFrac.txt"/> + coordinateFiles="{ ../../MULTIPHASE_TABLES/elevation.txt }" + voxelFile="../../MULTIPHASE_TABLES/initTemp.txt"/> + coordinateFiles="{ ../../MULTIPHASE_TABLES/phaseVolFraction_water.txt }" + voxelFile="../../MULTIPHASE_TABLES/relPerm_water.txt"/> + coordinateFiles="{ ../../MULTIPHASE_TABLES/phaseVolFraction_gas.txt }" + voxelFile="../../MULTIPHASE_TABLES/relPerm_gas.txt"/> diff --git a/inputFiles/poromechanicsFractures/multiphasePoromechanics_FaultModel_smoke.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_smoke.xml similarity index 98% rename from inputFiles/poromechanicsFractures/multiphasePoromechanics_FaultModel_smoke.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_smoke.xml index 9195fb39163..ecd6cfd30d3 100644 --- a/inputFiles/poromechanicsFractures/multiphasePoromechanics_FaultModel_smoke.xml +++ b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_smoke.xml @@ -45,7 +45,7 @@ name="mesh1" useGlobalIds="1" faceBlocks="{ fracture }" - file="verticalFault_ExternalMesh.vtm"/> + file="../../MESH/verticalFault_ExternalMesh.vtm"/> diff --git a/inputFiles/poromechanicsFractures/multiphasePoromechanics_FaultModel_well_base.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_well_base.xml similarity index 86% rename from inputFiles/poromechanicsFractures/multiphasePoromechanics_FaultModel_well_base.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_well_base.xml index 254244756ef..d723d5f636d 100644 --- a/inputFiles/poromechanicsFractures/multiphasePoromechanics_FaultModel_well_base.xml +++ b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_well_base.xml @@ -18,8 +18,8 @@ phaseNames="{ gas, water }" componentNames="{ co2, water }" componentMolarWeight="{ 44e-3, 18e-3 }" - phasePVTParaFiles="{ pvtgas.txt, pvtliquid.txt }" - flashModelParaFile="co2flash.txt" /> + phasePVTParaFiles="{ ../../MULTIPHASE_TABLES/pvtgas.txt, ../../MULTIPHASE_TABLES/pvtliquid.txt }" + flashModelParaFile="../../MULTIPHASE_TABLES/co2flash.txt" /> + coordinateFiles="{ ../../MULTIPHASE_TABLES/elevation.txt }" + voxelFile="../../MULTIPHASE_TABLES/initCO2CompFrac.txt" /> + coordinateFiles="{ ../../MULTIPHASE_TABLES/elevation.txt }" + voxelFile="../../MULTIPHASE_TABLES/initWaterCompFrac.txt" /> + coordinateFiles="{ ../../MULTIPHASE_TABLES/elevation.txt }" + voxelFile="../../MULTIPHASE_TABLES/initTemp.txt" /> + coordinateFiles="{ ../../MULTIPHASE_TABLES/phaseVolFraction_water.txt }" + voxelFile="../../MULTIPHASE_TABLES/relPerm_water.txt" /> + coordinateFiles="{ ../../MULTIPHASE_TABLES/phaseVolFraction_gas.txt }" + voxelFile="../../MULTIPHASE_TABLES/relPerm_gas.txt" /> diff --git a/inputFiles/poromechanicsFractures/multiphasePoromechanics_FaultModel_well_fim_smoke.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_well_fim_smoke.xml similarity index 98% rename from inputFiles/poromechanicsFractures/multiphasePoromechanics_FaultModel_well_fim_smoke.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_well_fim_smoke.xml index 0ce10628d75..f072a262c59 100644 --- a/inputFiles/poromechanicsFractures/multiphasePoromechanics_FaultModel_well_fim_smoke.xml +++ b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_well_fim_smoke.xml @@ -75,7 +75,7 @@ name="mesh1" useGlobalIds="1" faceBlocks="{ fracture }" - file="verticalFault_ExternalMesh.vtm"> + file="../../MESH/verticalFault_ExternalMesh.vtm"> + file="../../MESH/verticalFault_ExternalMesh.vtm"> + file="../../MESH/verticalFault_ExternalMesh.vtm"/> diff --git a/inputFiles/poromechanicsFractures/singlePhasePoromechanics_FaultModel_well_base.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/singlePhasePoromechanics_FaultModel_well_base.xml similarity index 99% rename from inputFiles/poromechanicsFractures/singlePhasePoromechanics_FaultModel_well_base.xml rename to inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/singlePhasePoromechanics_FaultModel_well_base.xml index b86106ea73d..8f794b6d433 100644 --- a/inputFiles/poromechanicsFractures/singlePhasePoromechanics_FaultModel_well_base.xml +++ b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/singlePhasePoromechanics_FaultModel_well_base.xml @@ -167,7 +167,7 @@ name="mesh1" useGlobalIds="1" faceBlocks="{ fracture }" - file="verticalFault_ExternalMesh.vtm"> + file="../../MESH/verticalFault_ExternalMesh.vtm"> + file="../../MESH/verticalFault_ExternalMesh.vtm"> + + + + + + diff --git a/inputFiles/poromechanicsFractures/MESH/fault_contact_hex_fault_ids.vtu b/inputFiles/poromechanicsFractures/MESH/fault_contact_hex_fault_ids.vtu new file mode 100755 index 00000000000..1e79b5ae346 --- /dev/null +++ b/inputFiles/poromechanicsFractures/MESH/fault_contact_hex_fault_ids.vtu @@ -0,0 +1,52 @@ + + + + + + + AQAAAACAAABAHQAAzQYAAA==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 + + + 27612.000018 + + + 31335.132392 + + + + + AQAAAACAAACgDgAA+AIAAA==eJw11WNjEAgAgOFs17KXW8u2bde2bBtbtrFs224t27yrQzjUoc4Ih+7DPb1fnp/wxojxfzEZi7EZh3EZj/GZgAmZiImZhEmZjMmZgimZiqmZhgFMy3RMzwzMyEzMzCzMymzMzhzMyUDmYm7mYV7mY34WYEEGsRCDWZhFWJTFWJwlWJKlWJplWJblWJ4VWJGVWJlVWJXVWJ01WJO1WJt1WJf1WJ8N2JCN2JhN2JTN2Jwt2JKt2Jpt2Jbt2J4hDGUYO7AjO7Ezu7Aru7E7e7Ane7E3+7Av+7E/B3AgB3Ewh3Aoh3E4R3AkR3E0wxnBMRzLcRzPCZzISZzMKZzKaZzOGZzJWZzNOZzLeZzPBVzISC7iYi7hUi7jcq7gSq7iaq7hWq7jem7gRm7iZm7hVm7jdu7gTu7ibu7hXu7jfh7gQR7iYR7hUR7jcUbxBKN5kqd4mmd4lud4nhd4kZd4mVd4ldd4nTd4k7d4m3d4l/d4nw/4ET/mQz7iJ/yUn/FzPuYTPuUzfsEv+RW/5nO+4Df8lt/xe77kK/7AH/kTf+Yv/JW/8Xf+wT/5mm/4lu/4F//mP/yX7/lh/DEZi7EZh3EZj/GZgAmZiImZhEmZjMmZgimZiqmZhgFMy3RMzwzMyEzMzCzMymzMzhzMyUDmYm7mYV7mY34WYEEGsRCDWZhFWJTFWJwlWJKlWJplWJblWJ4VWJGVWJlVWJXVWJ01WJO1WJt1WJf1WJ8N2JCN2JhN2JTN2Jwt2JKt2Jpt2Jbt2J4hDGUYO7AjO7Ezu7Aru7E7e7Ane7E3+7Av+7E/B3AgB3Ewh3Aoh3E4R3AkR3E0wxnBMRzLcRzPCZzISZzMKZzKaZzOGZzJWZzNOZzLeZzPBVzISC7iYi7hUi7jcq7gSq7iaq7hWq7jem7gRm7iZm7hVm7jdu7gTu7ibu7hXu7jfh7gQR7iYR7hUR7jcUbxBKN5kqd4mmd4lud4nhd4kZd4mVd4ldd4nTd4k7d4m3d4l/d4n/8B/ObXsw== + + + + + AQAAAACAAACwCQAAEwIAAA==eJw11dViEAQAQFEGA8aIkRu9URu5kRIiJdLd3Y1KCSIgHSrSqXR3d6N0dyodiqQoqaAPHO7L+YQbK9a7AhibcRjIuIzH+AxiAgYzIRMxMZMwhEmZjMmZgimZiqEMY2qmYVqmY3pmYEaGM4KZmJlZmJXZGMkoZmcO5mQu5mYeRjOGeZmP+VmABVmIH7Awi7Aoi/FDFudHLMGSLMXSLMOPWZafsBzLswIrshIrswqrshqrswZrshZrsw7rsh7rswEbshEbswmbshmbswVbshVbsw3bsh3bswM7shM781N+xs/ZhV3Zjd3Zg1+wJ3vxS/bmV+zDvuzHr9mfAziQgziYQziUwzicI/gNv+V3HMnvOYqjOYZjOY7jOYETOYmTOYVT+QN/5DRO5wzO5CzO5hzO5TzO5wIu5CIu5hIu5TIu5wqu5Cqu5hqu5Tqu5wZu5CZu5hZu5TZu5w7u5C7u5k/8mXu4l/u4nwd4kId4mEd4lMd4nCd4kqd4mmd4lud4nhd4kZd4mb/wV17hVV7jdd7gTd7ibd7hXf7G33mPf/A+H/AhH/Exn/BPPuVf/JvP+Jwv+JKv+Jr/8F++4Vv+x/fjD2BsxmEg4zIe4zOICRjMhEzExEzCECZlMiZnCqZkKoYyjKmZhmmZjumZgRkZzghmYmZmYVZmYySjmJ05mJO5mJt5GM0Y5mU+5mcBFmQh/g8IioVO + + + + + AQAAAACAAADwFQAAcAsAAA==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 + + + 2516.6143322 + + + 4041.4536614 + + + + + + + AQAAAACAAADAJgAAxAYAAA==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 + + + AQAAAACAAACwCQAA0gEAAA==eJwtxRGAGgAAAMC2BUEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEHw8BAEQfDwMOhOLhj4CDnsiKOOOe6Ek0457YyzzjnvgosuueyKq6657oabbrntjrvuue+Bhx557ImnnnnuhZdeee2Nt95574OPPvnsi6+++e4vf/vhp19++8e/Dvz5FHTIYUccdcxxJ5x0ymlnnHXOeRdcdMllV1x1zXU33HTLbXfcdc99Dzz0yGNPPPXMcy+89Mprb7z1znsffPTJZ1989c13f/nbDz/98ts//nXg76egQw474qhjjjvhpFNOO+Osc8674KJLLrviqmuuu+GmW26746577nvgoUcee+KpZ5574aVXXnvjrXfe++CjTz774qtvvvvL33746Zff/vGvA/8+BR1y2BFHHXPcCSedctoZZ51z3gUXXXLZFVddc90NN91y2x133XPfAw898tgTTz3z3AsvvfLaG2+9894HH33y2RdfffPdX/72w0+//PaPfx0IyiGHHXHUMcedcNIpp51x1jnnXXDRJZddcdU1191w0y233XHXPfc98NAjjz3x1DPPvfDSK6+98dY7733w0SefffHVN/8Hc9iXkQ== + + + AQAAAACAAAA2AQAADQAAAA==eJxjZx8FpAMAJ5wIew== + + + + + diff --git a/inputFiles/poromechanicsFractures/MESH/fault_contact_hex_mesh_ids.vtu b/inputFiles/poromechanicsFractures/MESH/fault_contact_hex_mesh_ids.vtu new file mode 100755 index 00000000000..34fc15c71ab --- /dev/null +++ b/inputFiles/poromechanicsFractures/MESH/fault_contact_hex_mesh_ids.vtu @@ -0,0 +1,44 @@ + + + + + + + BwAAAACAAACAbQAATBgAAFEYAABRGAAAURgAAFAYAABRGAAA0xQAAA==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 + + + + + AwAAAACAAADwGAAAQAAAAEAAAAAhAAAAeJztw7ENACAMA7BcSvr/Fd2ZmJEtuUmqqqqqqqqq11FVVVVVVVVVVVVVVVVVVfXpUVVVVVVVVVVVVb+5gPzmCHic7cMxDQAACAOwKYXg3wQWuLjapJWkVFVVVVVVVVVV9fmoqqqqqqqqqqqqqqqqqqp62qqqqqqqqurbBW8f9cZ4nO3DAQkAAAwEoWv6/Vssx0DBVVNVVVVVVX38ADppUGM= + + + BQAAAACAAADgMQAATBgAAFEYAABRGAAAURgAAJUJAAA=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 + + + + + CwAAAACAAABAJAAAp0gAAN5VAAB+VgAAj0gAABUuAAAPLQAAEy4AADEzAABeMgAAxzQAAOARAAA=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 + + + 2500.0022458 + + + 4500 + + + + + + + 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 + + + BQAAAACAAADgMQAApRMAAJQTAAAOEwAAChMAAJIHAAA=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 + + + AQAAAACAAAA8RgAAKQAAAA==eJztwQENAAAAwqAC75/XHG5AAQAAAAAAAAAAAAAAAAAAAADwZuavSv4= + + + + + diff --git a/inputFiles/poromechanicsFractures/MESH/fault_contact_hex_mesh_with_node_sets.vtu b/inputFiles/poromechanicsFractures/MESH/fault_contact_hex_mesh_with_node_sets.vtu new file mode 100755 index 00000000000..7cfe2a4a313 --- /dev/null +++ b/inputFiles/poromechanicsFractures/MESH/fault_contact_hex_mesh_with_node_sets.vtu @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + + + + _BwAAAACAAADgXgAATBgAAFEYAABRGAAAURgAAFAYAABRGAAADxIAAA==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eF7t2jsOwyAMAFBz/0u3yVA6VHZEajWp3oMN+SMhMxEjXkaMp9j2vuLtjPsZiSp2RVavV9XZ16UVe1r9QdapSnNAd/4Plm8piwMAAAAAAAAA4P/4SwK9zBj0ymZsqrIAnOcVgmsymwAAAAAAAAAAAAAAAACrHmhoAdU=AwAAAACAAADwGAAAQAAAAEAAAAAhAAAAeF7tw7ENACAMA7BcSvr/Fd2ZmJEtuUmqqqqqqqqq11FVVVVVVVVVVVVVVVVVVfXpUVVVVVVVVVVVVb+5gPzmCHhe7cMxDQAACAOwKYXg3wQWuLjapJWkVFVVVVVVVVVV9fmoqqqqqqqqqqqqqqqqqqp62qqqqqqqqurbBW8f9cZ4Xu3DAQkAAAwEoWv6/Vssx0DBVVNVVVVVVX38ADppUGM=BQAAAACAAADgMQAATBgAAFEYAABRGAAAURgAAJUJAAA=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BQAAAACAAADgMQAAlhMAAJQTAAANEwAAChMAAJEHAAA=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eF7twQENAAAAwqAC75/XHG5AAQAAAAAAAAAAAAAAAAAAAADwZuavSv4= + + diff --git a/inputFiles/poromechanicsFractures/fracture_res5_id.vtu b/inputFiles/poromechanicsFractures/MESH/fracture_res5_id.vtu similarity index 100% rename from inputFiles/poromechanicsFractures/fracture_res5_id.vtu rename to inputFiles/poromechanicsFractures/MESH/fracture_res5_id.vtu diff --git a/inputFiles/poromechanicsFractures/verticalFault_ExternalMesh.vtm b/inputFiles/poromechanicsFractures/MESH/verticalFault_ExternalMesh.vtm similarity index 100% rename from inputFiles/poromechanicsFractures/verticalFault_ExternalMesh.vtm rename to inputFiles/poromechanicsFractures/MESH/verticalFault_ExternalMesh.vtm diff --git a/inputFiles/poromechanicsFractures/co2flash.txt b/inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/co2flash.txt similarity index 100% rename from inputFiles/poromechanicsFractures/co2flash.txt rename to inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/co2flash.txt diff --git a/inputFiles/poromechanicsFractures/elevation.txt b/inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/elevation.txt similarity index 100% rename from inputFiles/poromechanicsFractures/elevation.txt rename to inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/elevation.txt diff --git a/inputFiles/poromechanicsFractures/initCO2CompFrac.txt b/inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/initCO2CompFrac.txt similarity index 100% rename from inputFiles/poromechanicsFractures/initCO2CompFrac.txt rename to inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/initCO2CompFrac.txt diff --git a/inputFiles/poromechanicsFractures/initTemp.txt b/inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/initTemp.txt similarity index 100% rename from inputFiles/poromechanicsFractures/initTemp.txt rename to inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/initTemp.txt diff --git a/inputFiles/poromechanicsFractures/initWaterCompFrac.txt b/inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/initWaterCompFrac.txt similarity index 100% rename from inputFiles/poromechanicsFractures/initWaterCompFrac.txt rename to inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/initWaterCompFrac.txt diff --git a/inputFiles/poromechanicsFractures/phaseVolFraction_gas.txt b/inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/phaseVolFraction_gas.txt similarity index 100% rename from inputFiles/poromechanicsFractures/phaseVolFraction_gas.txt rename to inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/phaseVolFraction_gas.txt diff --git a/inputFiles/poromechanicsFractures/phaseVolFraction_water.txt b/inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/phaseVolFraction_water.txt similarity index 100% rename from inputFiles/poromechanicsFractures/phaseVolFraction_water.txt rename to inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/phaseVolFraction_water.txt diff --git a/inputFiles/poromechanicsFractures/pvtgas.txt b/inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/pvtgas.txt similarity index 100% rename from inputFiles/poromechanicsFractures/pvtgas.txt rename to inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/pvtgas.txt diff --git a/inputFiles/poromechanicsFractures/multiphase_fluid/pvtgas.txt b/inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/pvtgas_curvedFrac.txt similarity index 100% rename from inputFiles/poromechanicsFractures/multiphase_fluid/pvtgas.txt rename to inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/pvtgas_curvedFrac.txt diff --git a/inputFiles/poromechanicsFractures/pvtliquid.txt b/inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/pvtliquid.txt similarity index 100% rename from inputFiles/poromechanicsFractures/pvtliquid.txt rename to inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/pvtliquid.txt diff --git a/inputFiles/poromechanicsFractures/multiphase_fluid/pvtwat.txt b/inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/pvtwat.txt similarity index 100% rename from inputFiles/poromechanicsFractures/multiphase_fluid/pvtwat.txt rename to inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/pvtwat.txt diff --git a/inputFiles/poromechanicsFractures/relPerm_gas.txt b/inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/relPerm_gas.txt similarity index 100% rename from inputFiles/poromechanicsFractures/relPerm_gas.txt rename to inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/relPerm_gas.txt diff --git a/inputFiles/poromechanicsFractures/relPerm_water.txt b/inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/relPerm_water.txt similarity index 100% rename from inputFiles/poromechanicsFractures/relPerm_water.txt rename to inputFiles/poromechanicsFractures/MULTIPHASE_TABLES/relPerm_water.txt diff --git a/inputFiles/poromechanicsFractures/multiphase_fluid/co2flash.txt b/inputFiles/poromechanicsFractures/multiphase_fluid/co2flash.txt deleted file mode 100644 index 900fa60672a..00000000000 --- a/inputFiles/poromechanicsFractures/multiphase_fluid/co2flash.txt +++ /dev/null @@ -1 +0,0 @@ -FlashModel CO2Solubility 1.0e5 1.0e8 1.0e5 288.15 369.15 2.0 0 diff --git a/inputFiles/singlePhaseFlow/FieldCaseTutorial3_Thermal_base.xml b/inputFiles/singlePhaseFlow/FieldCaseTutorial3_Thermal_base.xml index bbd526c564a..d33b7fe628a 100755 --- a/inputFiles/singlePhaseFlow/FieldCaseTutorial3_Thermal_base.xml +++ b/inputFiles/singlePhaseFlow/FieldCaseTutorial3_Thermal_base.xml @@ -19,7 +19,8 @@ lineSearchAction="None" logLevel="1"/> + solverType="gmres" + preconditionerType="amg"/> diff --git a/src/coreComponents/physicsSolvers/solidMechanics/CMakeLists.txt b/src/coreComponents/physicsSolvers/solidMechanics/CMakeLists.txt index 483615ce5e8..c6f9a5b0035 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/CMakeLists.txt +++ b/src/coreComponents/physicsSolvers/solidMechanics/CMakeLists.txt @@ -82,9 +82,10 @@ geos_decorate_link_dependencies( LIST decoratedDependencies DEPENDENCIES ${depen file( READ "${CMAKE_CURRENT_LIST_DIR}/kernelSpecs.json" kernelSpecs ) set( kernelTemplateFileList "" ) - list( APPEND kernelTemplateFileList + list( APPEND kernelTemplateFileList kernels/SolidMechanicsKernels.cpp.template - kernels/SolidMechanicsFixedStressThermoPoromechanicsKernels.cpp.template ) + kernels/SolidMechanicsFixedStressThermoPoromechanicsKernels.cpp.template + contact/kernels/SolidMechanicsALMContactPorousKernels.cpp.template ) foreach( kernelTemplateFile ${kernelTemplateFileList} ) diff --git a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp index 8dd1d59330e..8f82904b03a 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp +++ b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp @@ -37,6 +37,7 @@ #include "constitutive/contact/FrictionSelector.hpp" #include "constitutive/solid/PorousSolid.hpp" #include "constitutive/solid/SolidFields.hpp" +#include "physicsSolvers/solidMechanics/contact/kernels/SolidMechanicsALMContactPorousKernelsDispatchTypeList.hpp" #include "finiteElement/FiniteElementDiscretization.hpp" #include "mesh/DomainPartition.hpp" @@ -783,12 +784,11 @@ void SolidMechanicsAugmentedLagrangianContact::assembleForceResidualPressureCont real64 maxTraction = finiteElement::regionBasedKernelApplication < parallelDevicePolicy< >, - PorousSolid< ElasticIsotropic, ConstantPermeability >, - CellElementSubRegion >( mesh, - poromechanicsRegionNames, - getDiscretizationName(), - FlowSolverBase::viewKeyStruct::solidNamesString(), - kernelFactory ); + SolidMechanicsALMContactPorousKernelsDispatchTypeList >( mesh, + poromechanicsRegionNames, + getDiscretizationName(), + FlowSolverBase::viewKeyStruct::solidNamesString(), + kernelFactory ); GEOS_UNUSED_VAR( maxTraction ); } ); diff --git a/src/coreComponents/physicsSolvers/solidMechanics/contact/kernels/SolidMechanicsALMContactPorousKernels.cpp.template b/src/coreComponents/physicsSolvers/solidMechanics/contact/kernels/SolidMechanicsALMContactPorousKernels.cpp.template new file mode 100644 index 00000000000..491a1be4646 --- /dev/null +++ b/src/coreComponents/physicsSolvers/solidMechanics/contact/kernels/SolidMechanicsALMContactPorousKernels.cpp.template @@ -0,0 +1,40 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 "physicsSolvers/solidMechanics/SolidMechanicsFields.hpp" +#include "physicsSolvers/solidMechanics/contact/ContactFields.hpp" +#include "physicsSolvers/fluidFlow/FlowSolverBaseFields.hpp" +#include "physicsSolvers/solidMechanics/contact/kernels/SolidMechanicsPressureFaceBubbleKernels.hpp" + +using ALMContactPorousPolicy = @ALMContactPorousPolicy@; + +#define INSTANTIATION( NAME )\ +template class NAME < @SUBREGION_TYPE@, @CONSTITUTIVE_TYPE@, @FE_TYPE@_impl >; \ +template real64 NAME < @SUBREGION_TYPE@, @CONSTITUTIVE_TYPE@, @FE_TYPE@_impl >::kernelLaunch< ALMContactPorousPolicy, \ + NAME < @SUBREGION_TYPE@, @CONSTITUTIVE_TYPE@, @FE_TYPE@_impl > > \ + ( localIndex const, \ + NAME < @SUBREGION_TYPE@, @CONSTITUTIVE_TYPE@, @FE_TYPE@_impl > const & ); \ + +namespace geos +{ +using namespace constitutive; +using namespace finiteElement; +namespace solidMechanicsConformingContactKernels +{ + INSTANTIATION( PressureFaceBubbleKernels ) +} +} + +#undef INSTANTIATION diff --git a/src/coreComponents/physicsSolvers/solidMechanics/kernelSpecs.json b/src/coreComponents/physicsSolvers/solidMechanics/kernelSpecs.json index 9eb41224111..3caafa8247e 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/kernelSpecs.json +++ b/src/coreComponents/physicsSolvers/solidMechanics/kernelSpecs.json @@ -149,5 +149,41 @@ ] }, "explicit": [] + }, + + "SolidMechanicsALMContactPorousKernels": { + "vars": [ + "SUBREGION_TYPE", + "CONSTITUTIVE_TYPE", + "FE_TYPE" + ], + "constants": [ + [ "ALMContactPorousPolicy", "geos::parallelDevicePolicy< GEOS_BLOCK_SIZE >" ] + ], + "combinations": { + "SUBREGION_TYPE": [ + "CellElementSubRegion" + ], + "CONSTITUTIVE_TYPE": [ + "PorousSolid", + "PorousSolid", + "PorousSolid", + "PorousSolid", + "PorousSolid", + "PorousSolid", + "PorousSolid, ConstantPermeability>", + "PorousSolid, CarmanKozenyPermeability>", + "PorousSolid, ConstantPermeability>", + "PorousSolid, CarmanKozenyPermeability>" + ], + "FE_TYPE": [ + "H1_Hexahedron_Lagrange1_GaussLegendre2", + "H1_Wedge_Lagrange1_Gauss6", + "H1_Tetrahedron_Lagrange1_Gauss1", + "H1_Tetrahedron_Lagrange1_Gauss14", + "H1_Pyramid_Lagrange1_Gauss5" + ] + }, + "explicit": [] } } From b92bb95c298cb94c99d107a1778afcfdab6d011f Mon Sep 17 00:00:00 2001 From: Arnaud DUDES <155963334+arng40@users.noreply.github.com> Date: Thu, 28 May 2026 20:00:28 +0200 Subject: [PATCH 49/53] feat: CI - Add code rules checking action (#3914) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * add-code-rules * comment jobs not needed * try this * remove ctest testcoderule * try to add some target * relaunch ci * forget 1 target * test code for detecting std::map * force to true * log * more log * print pwd * test with regex * fix * update find * update prefix file pattern * move to script * fix rule ^^ * test perm * add write * give perm * give perm * attempt perm * remove if statement * test ls * test another pwd * fix cd * add src * go to src * remove prefix * sabotage code * missing : * display info at the end * check str * wrong varaible * echo * simplify * remove done * remove bracket * add more std * update logic * fix std * style * remove lr * set stdUnorderedMap * vector rule * add common * replace std::vector * revert on stdContainerWrapper * echo file * another echo * add id cond * stdVector * missing file * test for constituve * try refacto with func * clean the code + test with file * fix declaration * log * update echo * refacto find cmd * remove exclude find * remove log + revert * update find command * remove type f * remove var from find * reset find * revert loop * update loop * update code * enforce code * echo file * fix loop * revert some ci change + remove echo * print all path + some refacto * remove debug log * uncrustify * factorize duplicated code * simplify functions * centralize declaration of forbedden expression * syntax correction * add code rules in check_all_tests_succedeed * renaming * ♻️ name clarity refactor * opti code rules * fix confition in test & update container * correction script * address last comments * fix if command * disable graph coloring test * add get inserted method * uncrustidy + rmove comment + add TODO * 🎨 TODO uppercase * :art: use of stdContainerWrapper * fix * fix * fix: revert uncrustify formatting on SpatialPartition.cpp * ⚡️ fixing std::move usage, removing needs for useless copies * 🐛 fix some get_inserted() usage * 🎨 uncrustify --------- Co-authored-by: MelReyCG Co-authored-by: MelReyCG <122801580+MelReyCG@users.noreply.github.com> Co-authored-by: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> Co-authored-by: Bertrand Denel <120652669+bd713@users.noreply.github.com> Co-authored-by: DENEL Bertrand --- .github/workflows/ci_tests.yml | 17 ++ scripts/check_code_rules.sh | 157 ++++++++++++++++++ .../codingUtilities/RTTypes.cpp | 2 +- .../codingUtilities/tests/testGeosxTraits.cpp | 2 +- src/coreComponents/common/MemoryInfos.cpp | 2 +- .../common/StdContainerWrappers.hpp | 4 +- src/coreComponents/common/TypeDispatch.hpp | 2 +- .../common/format/table/TableFormatter.cpp | 10 +- .../common/format/table/TableLayout.hpp | 2 +- .../common/format/table/TableTypes.hpp | 10 +- .../common/logger/ErrorHandling.cpp | 4 +- .../common/logger/ErrorHandling.hpp | 4 +- .../common/unitTests/testDataTypes.cpp | 2 +- .../constitutive/ConstitutiveBase.hpp | 4 +- .../parameters/KValueFlashParameters.cpp | 2 +- .../compositional/parameters/PhaseType.cpp | 2 +- .../constitutive/unitTests/TestFluid.hpp | 4 +- .../unitTests/testSoreideWhitsonFlash.cpp | 2 +- .../dataRepository/ObjectCatalog.hpp | 10 +- .../unitTests/testErrorHandling.cpp | 2 +- .../Outputs/unitTests/testMemoryStats.cpp | 8 +- .../fileIO/vtk/VTKPolyDataWriterInterface.cpp | 4 +- .../unitTests/testMimeticInnerProducts.cpp | 8 +- .../testFieldSpecification.cpp | 6 +- ...stCompositionalMultiPhaseMFDPolyhedral.cpp | 14 +- .../testSinglePhaseMFDPolyhedral.cpp | 10 +- .../solverStatisticsTests/testSolverStats.cpp | 10 +- .../wellsTests/testOpenClosePerf.cpp | 16 +- ...testReservoirThermalSinglePhaseMSWells.cpp | 4 +- ...rvoirThermalSinglePhaseMSWells_RateInj.cpp | 4 +- .../interfaces/hypre/HypreUtils.cpp | 2 +- .../interfaces/hypre/hypredrive.cpp | 10 +- .../multiscale/MultiscalePreconditioner.hpp | 2 +- .../multiscale/mesh/DofManager.hpp | 2 +- .../multiscale/mesh/MeshLevel.cpp | 20 +-- .../multiscale/mesh/MeshLevel.hpp | 12 +- .../multiscale/mesh/MeshUtils.hpp | 2 +- .../multiscale/mesh/coarsening/Coarsening.cpp | 4 +- .../coarsening/SemistructuredPartitioner.cpp | 4 +- .../multiscale/msrsb/MsrsbLevelBuilder.cpp | 2 +- .../msrsb/MsrsbLevelBuilderCoupled.cpp | 8 +- .../msrsb/MsrsbLevelBuilderCoupled.hpp | 8 +- .../multiscale/msrsb/MsrsbUtils.cpp | 10 +- .../multiscale/msrsb/MsrsbUtils.hpp | 2 +- .../solvers/BlockPreconditioner.cpp | 2 +- .../solvers/BlockPreconditioner.hpp | 2 +- .../unitTests/testComponentMask.cpp | 16 +- src/coreComponents/mesh/DomainPartition.hpp | 4 +- .../mesh/ElementSubRegionBase.hpp | 2 +- .../mesh/WellElementSubRegion.cpp | 4 +- .../mesh/generators/CellBlockManager.cpp | 30 ++-- .../mesh/generators/MeshGeneratorBase.cpp | 4 +- .../mesh/generators/VTKFaceBlockUtilities.cpp | 4 +- .../mesh/generators/VTKUtilities.cpp | 22 +-- .../mpiCommunications/CommunicationTools.cpp | 4 +- .../mpiCommunications/SpatialPartition.cpp | 8 +- .../SinglePhaseReactiveTransport.cpp | 4 +- .../solidMechanics/SolidMechanicsMPM.cpp | 6 +- ...lidMechanicsAugmentedLagrangianContact.cpp | 4 +- .../surfaceGeneration/SurfaceGenerator.cpp | 30 ++-- 60 files changed, 368 insertions(+), 194 deletions(-) create mode 100755 scripts/check_code_rules.sh diff --git a/.github/workflows/ci_tests.yml b/.github/workflows/ci_tests.yml index 6b553f07160..b5e5b2112cf 100644 --- a/.github/workflows/ci_tests.yml +++ b/.github/workflows/ci_tests.yml @@ -321,6 +321,22 @@ jobs: RUNS_ON: ubuntu-22.04 USE_SCCACHE: false + check_code_rules: + needs: [is_not_draft_pull_request] + runs-on: ubuntu-22.04 + steps: + - name: Checkout Repository + uses: actions/checkout@v4.2.2 + with: + submodules: false + lfs: false + fetch-depth: 0 + sparse-checkout: | + scripts + src + - name: Check the code rules + run: "scripts/check_code_rules.sh" + # Matrix containing all the CPU build. # Those are quite fast and can efficiently benefit from the `sccache' tool to make them even faster. cpu_builds: @@ -642,6 +658,7 @@ jobs: - if_not_unassigned_pull_request - are_submodules_in_sync - check_code_style_and_documentation + - check_code_rules - cpu_builds - cuda_builds - run_integrated_tests diff --git a/scripts/check_code_rules.sh b/scripts/check_code_rules.sh new file mode 100755 index 00000000000..8a9ed6dd931 --- /dev/null +++ b/scripts/check_code_rules.sh @@ -0,0 +1,157 @@ +#!/bin/bash + + +################################ +## I. Function initializations +################################ + +# while +# ... done < <(grep -n "std::map\s*<" "$file") +# Process the result of grep command as a file. +# This allows everything to be handled in the same shell environment. +check_container_usage() { + local file="$1" + + if grep -qE "$FULL_REGEX" "$file"; then + while IFS= read -r line; do + for container in "${FORBIDDEN_EXPRESSIONS[@]}"; do + local pattern="${container}[[:space:]]*[<\(]" + if [[ "$line" =~ $pattern ]]; then + local msg=" $file:$line"$'\n' + ERRORS_CONTAINER[$container]+="$msg" + ((FORBIDDEN_CONTAINER_MAP["$container"]++)) + fi + done + done < <(grep -nE "$FULL_REGEX" "$file") + fi + +} + +print_violation() +{ + local container_name="$1" + + if [ "${FORBIDDEN_CONTAINER_MAP[$container_name]}" -ge 1 ];then + echo $'\n' + echo "ERROR: Forbidden $container_name usage detected" + echo "==========================================" + + printf '%s' "${ERRORS_CONTAINER[$container_name]}" + + fi +} + +################################ +## II. GLOBAL INITIALIZATION +################################ + +FORBIDDEN_EXPRESSIONS=( + "std::map" + "std::unordered_map" + "std::vector" +) + +declare -A FORBIDDEN_CONTAINER_MAP=() +for exp in "${FORBIDDEN_EXPRESSIONS[@]}"; do + FORBIDDEN_CONTAINER_MAP["$exp"]=0 +done + +declare -A ERRORS_CONTAINER=() +for exp in "${FORBIDDEN_EXPRESSIONS[@]}"; do + ERRORS_CONTAINER["$exp"]="" +done + +FILEPATH_PREFIX="src/coreComponents/" +FILEPATH_SUBFOLDERS=( + "codingUtilities" + "common" + "dataRepository" + "constitutive" + "denseLinearAlgebra" + "discretizationMethods" + "events" + "fieldSpecification" + "fileIO" + "finiteElement" + "finiteVolume" + "functions" + "linearAlgebra" + "mainInterface" + "mesh" + "physicsSolvers" +) + +FILEPATH_EXCLUDE_PATTERNS=( + "Datatype.hpp" + "StdContainerWrappers.hpp" + "MpiWrapper.cpp" + "BufferOps_inline.hpp" + "BufferOps.hpp" + "PVTPackage" + "hdf5_interface" +) + +FILE_PATH_ARGS=() +for pattern in "${FILEPATH_SUBFOLDERS[@]}"; do + if [ -d "${FILEPATH_PREFIX}${pattern}" ]; then + FILE_PATH_ARGS+=("${FILEPATH_PREFIX}${pattern}") + fi +done + +EXCLUDED_NAME_PATTERNS=() +for pattern in "${FILEPATH_EXCLUDE_PATTERNS[@]}"; do + if [[ ! "$pattern" == *".hpp"* || "$pattern" == *".cpp"* ]]; then + EXCLUDED_NAME_PATTERNS+=( -path "*/$pattern" -prune -o ) + else + EXCLUDED_NAME_PATTERNS+=( -name "*${pattern}" -prune -o ) + fi +done + +echo "======================================================" +echo -e " TREE LIST OF FILES FOUND " +echo "======================================================" + +if [ ${#FILE_PATH_ARGS[@]} -gt 0 ]; then + find "${FILE_PATH_ARGS[@]}" "${EXCLUDED_NAME_PATTERNS[@]}" -type d -print | sort | while IFS= read -r dir; do + echo -e "->" $(echo "$dir" | sed 's/[]^$*.[]/\\&/g' | sed 's/\// |---/g') + done +fi + +ARRAY_FILES=() +# mapfile used for reading inMAPput lines into an array; -d $'\0': Specifies that the delimiter is (\0). +# -print0 : ask find to separate file paths by '\0' +mapfile -d $'\0' ARRAY_FILES < <(find "${FILE_PATH_ARGS[@]}" "${EXCLUDED_NAME_PATTERNS[@]}" \ + -type f \( -name "*.hpp" -o -name "*.cpp" -o -name "*.hpp.template" -o -name "*.cpp.template" \) \ + -print0 2>/dev/null) + +################################ +## III. MAIN LOOP +################################ + +REGEX_PATTERN=$(IFS='|'; echo "${FORBIDDEN_EXPRESSIONS[*]}") +FULL_REGEX="(${REGEX_PATTERN})" + +for file in "${ARRAY_FILES[@]}"; do + check_container_usage "$file" +done + +# Print section +for key in "${!FORBIDDEN_CONTAINER_MAP[@]}"; do + if [[ "${FORBIDDEN_CONTAINER_MAP[$key]}" -ge "1" ]]; then + echo $'\n' + echo "----------------------------------------" + echo "SUMMARY: Code rule violations found" + echo "----------------------------------------" + + for container_name in "${!FORBIDDEN_CONTAINER_MAP[@]}"; do + print_violation "$container_name" + done + + echo "" + exit 1; + fi +done + +echo $'\n' +echo "No code rule violations found" +exit 0 diff --git a/src/coreComponents/codingUtilities/RTTypes.cpp b/src/coreComponents/codingUtilities/RTTypes.cpp index d95ee701695..724b2b77312 100644 --- a/src/coreComponents/codingUtilities/RTTypes.cpp +++ b/src/coreComponents/codingUtilities/RTTypes.cpp @@ -39,7 +39,7 @@ void printTypeSummary() string rtTypes::getTypeName( std::type_index const key ) { - static const std::unordered_map< std::type_index, string > type_names = + static const stdUnorderedMap< std::type_index, string > type_names = { {std::type_index( typeid(integer)), "integer"}, {std::type_index( typeid(real32)), "real32"}, diff --git a/src/coreComponents/codingUtilities/tests/testGeosxTraits.cpp b/src/coreComponents/codingUtilities/tests/testGeosxTraits.cpp index 7a20ee4238c..121cb4f71de 100644 --- a/src/coreComponents/codingUtilities/tests/testGeosxTraits.cpp +++ b/src/coreComponents/codingUtilities/tests/testGeosxTraits.cpp @@ -53,7 +53,7 @@ TEST( testGeosxTraits, HasMemberFunction_at ) static_assert( HasMemberFunction_at< stdVector< int > >, "Should be true." ); static_assert( HasMemberFunction_at< stdVector< double > >, "Should be true." ); static_assert( HasMemberFunction_at< stdMap< int, string > >, "Should be true." ); - static_assert( HasMemberFunction_at< std::unordered_map< int, string > >, "Should be true." ); + static_assert( HasMemberFunction_at< stdUnorderedMap< int, string > >, "Should be true." ); static_assert( !HasMemberFunction_at< int >, "Should be false." ); static_assert( !HasMemberFunction_at< stdMap< string, string > >, "Should be false." ); diff --git a/src/coreComponents/common/MemoryInfos.cpp b/src/coreComponents/common/MemoryInfos.cpp index 13031f71c5e..2a2c74f5fd6 100644 --- a/src/coreComponents/common/MemoryInfos.cpp +++ b/src/coreComponents/common/MemoryInfos.cpp @@ -144,7 +144,7 @@ void MemoryLogging::memoryStatsReport() const MPI_Comm_size( MPI_COMM_WORLD, &size ); size_t nbRank = (std::size_t)size; // Get a list of all the allocators and sort it so that it's in the same order on each rank. - std::vector< string > allocatorNames = rm.getAllocatorNames(); + stdVector< string > allocatorNames = rm.getAllocatorNames(); std::sort( allocatorNames.begin(), allocatorNames.end() ); // If each rank doesn't have the same number of allocators you can't aggregate them. diff --git a/src/coreComponents/common/StdContainerWrappers.hpp b/src/coreComponents/common/StdContainerWrappers.hpp index afb7506daab..a7d2e519bdc 100644 --- a/src/coreComponents/common/StdContainerWrappers.hpp +++ b/src/coreComponents/common/StdContainerWrappers.hpp @@ -91,13 +91,13 @@ class StdVectorWrapper : public std::vector< T, Allocator > StdVectorWrapper( const Base & other ): Base( other ) {} - StdVectorWrapper( Base && other ): Base( other ) {} + StdVectorWrapper( Base && other ): Base( std::move( other ) ) {} StdVectorWrapper( const Base & other, const Allocator & alloc ) : Base( other, alloc ) {} StdVectorWrapper( Base && other, const Allocator & alloc ) - : Base( other, alloc ) {} + : Base( std::move( other ), alloc ) {} StdVectorWrapper( std::initializer_list< T > init, const Allocator & alloc = Allocator()) diff --git a/src/coreComponents/common/TypeDispatch.hpp b/src/coreComponents/common/TypeDispatch.hpp index 416aa3d08f5..67b247b4870 100644 --- a/src/coreComponents/common/TypeDispatch.hpp +++ b/src/coreComponents/common/TypeDispatch.hpp @@ -269,7 +269,7 @@ template< typename LIST, std::size_t ... Is > auto const & getTypeMap( LIST, std::integer_sequence< std::size_t, Is... > ) { using KeyType = decltype( createTypeIndexTuple( camp::first< LIST > {} ) ); - static std::unordered_map< KeyType, std::size_t, tuple_hash > const result = { { createTypeIndexTuple( camp::at_t< LIST, camp::num< Is > >{} ), Is } ... }; + static stdUnorderedMap< KeyType, std::size_t, tuple_hash > const result = { { createTypeIndexTuple( camp::at_t< LIST, camp::num< Is > >{} ), Is } ... }; return result; } diff --git a/src/coreComponents/common/format/table/TableFormatter.cpp b/src/coreComponents/common/format/table/TableFormatter.cpp index 3d454887da7..e200dc5f363 100644 --- a/src/coreComponents/common/format/table/TableFormatter.cpp +++ b/src/coreComponents/common/format/table/TableFormatter.cpp @@ -202,7 +202,7 @@ string TableCSVFormatter::toString< TableData >( TableData const & tableData ) c { if( tableData.getErrorsList().hasErrors() ) { - std::vector< string > cpyErrors = tableData.getErrorsList().getErrors(); + stdVector< string > cpyErrors = tableData.getErrorsList().getErrors(); getErrorsList().appendErrors( cpyErrors ); } @@ -525,8 +525,8 @@ void TableTextFormatter::populateErrorCellsLayout( PreparedTableLayout const & t { errorCellsLayout.push_back( { - std::vector< TableLayout::CellLayout >( nbCells, - TableLayout::CellLayout( CellType::MergeNext ) ), + stdVector< TableLayout::CellLayout >( nbCells, + TableLayout::CellLayout( CellType::MergeNext ) ), 1 // subLines count } ); errorCellsLayout.back().cells.back().m_cellType = CellType::Value; @@ -538,8 +538,8 @@ void TableTextFormatter::populateErrorCellsLayout( PreparedTableLayout const & t errorCellsLayout.push_back( { - std::vector< TableLayout::CellLayout >( nbCells, - TableLayout::CellLayout( CellType::Separator ) ), + stdVector< TableLayout::CellLayout >( nbCells, + TableLayout::CellLayout( CellType::Separator ) ), 1 // subLines count } ); diff --git a/src/coreComponents/common/format/table/TableLayout.hpp b/src/coreComponents/common/format/table/TableLayout.hpp index e08474aa064..049575ae931 100644 --- a/src/coreComponents/common/format/table/TableLayout.hpp +++ b/src/coreComponents/common/format/table/TableLayout.hpp @@ -119,7 +119,7 @@ class TableLayout /** * @return The view on each cell line. */ - std::vector< string_view > & getLines() + stdVector< string_view > & getLines() { return m_lines; } /** diff --git a/src/coreComponents/common/format/table/TableTypes.hpp b/src/coreComponents/common/format/table/TableTypes.hpp index 59826ddde6a..cfea392d21b 100644 --- a/src/coreComponents/common/format/table/TableTypes.hpp +++ b/src/coreComponents/common/format/table/TableTypes.hpp @@ -64,7 +64,7 @@ class TableErrorListing void clear(); /// The iterator alias for the errors vector of string - using Iterator = std::vector< string >::const_iterator; + using Iterator = stdVector< string >::const_iterator; /** * @return An Iterator pointing to the first element of the errors vector @@ -82,24 +82,24 @@ class TableErrorListing * @brief Append a vector of string to the errors vector. * @param errors A vector of string to append */ - void appendErrors( std::vector< string > & errors ) + void appendErrors( stdVector< string > & errors ) { m_errorList.insert( m_errorList.end(), errors.begin(), errors.end() );} /** * @return A const reference to the errors vector. */ - std::vector< string > const & getErrors() const + stdVector< string > const & getErrors() const { return m_errorList; } /** * @return A reference to the errors vector. */ - std::vector< string > & getErrors() + stdVector< string > & getErrors() { return m_errorList; } private: /// Contain all the errors to display at the end of the table - std::vector< string > m_errorList; + stdVector< string > m_errorList; }; inline void TableErrorListing::addError( string_view text ) diff --git a/src/coreComponents/common/logger/ErrorHandling.cpp b/src/coreComponents/common/logger/ErrorHandling.cpp index 6881e11259a..cd9a2748302 100644 --- a/src/coreComponents/common/logger/ErrorHandling.cpp +++ b/src/coreComponents/common/logger/ErrorHandling.cpp @@ -309,7 +309,7 @@ void ErrorLogger::formatMsgForLog( DiagnosticMsg const & errMsg, std::ostream & } os << PREFIX << "Rank " << stringutilities::join( errMsg.m_ranksInfo, ", " ) << "\n"; // --- ERROR CONTEXT & MESSAGE --- - std::vector< ErrorContext > const & contexts = errMsg.m_contextsInfo; + stdVector< ErrorContext > const & contexts = errMsg.m_contextsInfo; if( contexts.empty() || contexts.front().m_formattedContext.empty()) { os << PREFIX << "Message :\n"; @@ -374,7 +374,7 @@ void ErrorLogger::writeToYamlStream( DiagnosticMsg & errMsg ) // context information if( !errMsg.m_contextsInfo.empty() ) { - std::vector< ErrorContext > contextInfo = errMsg.m_contextsInfo; + stdVector< ErrorContext > contextInfo = errMsg.m_contextsInfo; // Sort contextual information by decreasing priority std::sort( contextInfo.begin(), contextInfo.end(), []( const ErrorContext & a, const ErrorContext & b ) { diff --git a/src/coreComponents/common/logger/ErrorHandling.hpp b/src/coreComponents/common/logger/ErrorHandling.hpp index 38df2a2566c..095cdfc1789 100644 --- a/src/coreComponents/common/logger/ErrorHandling.hpp +++ b/src/coreComponents/common/logger/ErrorHandling.hpp @@ -138,9 +138,9 @@ struct DiagnosticMsg /// the source location line (default is 0) integer m_line = 0; /// Additional information about the diagnostic in the input file - std::vector< ErrorContext > m_contextsInfo; + stdVector< ErrorContext > m_contextsInfo; /// the stack trace - std::vector< std::string > m_sourceCallStack; + stdVector< std::string > m_sourceCallStack; /// Indicates whether the stored call stack trace is valid and usable. bool m_isValidStackTrace = false; }; diff --git a/src/coreComponents/common/unitTests/testDataTypes.cpp b/src/coreComponents/common/unitTests/testDataTypes.cpp index 58ebc681cae..dcece3fd6e7 100644 --- a/src/coreComponents/common/unitTests/testDataTypes.cpp +++ b/src/coreComponents/common/unitTests/testDataTypes.cpp @@ -59,7 +59,7 @@ TEST( testDataTypes, testBoundChecking ) }, std::out_of_range ); - internal::StdMapWrapper< std::unordered_map< integer, integer >, true > unorderedMapBoundsChecking{{0, 1}}; + internal::StdMapWrapper< stdUnorderedMap< integer, integer >, true > unorderedMapBoundsChecking{{0, 1}}; EXPECT_THROW( { try { diff --git a/src/coreComponents/constitutive/ConstitutiveBase.hpp b/src/coreComponents/constitutive/ConstitutiveBase.hpp index 7921ee28a78..b8bd67c2de0 100644 --- a/src/coreComponents/constitutive/ConstitutiveBase.hpp +++ b/src/coreComponents/constitutive/ConstitutiveBase.hpp @@ -170,7 +170,7 @@ class ConstitutiveBase : public dataRepository::Group /** * @return A const vector containing all fields */ - std::vector< std::string > const & getUserFields() const + stdVector< std::string > const & getUserFields() const { return m_userFields; } @@ -189,7 +189,7 @@ class ConstitutiveBase : public dataRepository::Group bool m_isClone; // Vector containing all fields registered with `registerField()` - std::vector< std::string > m_userFields; + stdVector< std::string > m_userFields; }; } diff --git a/src/coreComponents/constitutive/fluid/multifluid/compositional/parameters/KValueFlashParameters.cpp b/src/coreComponents/constitutive/fluid/multifluid/compositional/parameters/KValueFlashParameters.cpp index 192eea5de79..c97809402b7 100644 --- a/src/coreComponents/constitutive/fluid/multifluid/compositional/parameters/KValueFlashParameters.cpp +++ b/src/coreComponents/constitutive/fluid/multifluid/compositional/parameters/KValueFlashParameters.cpp @@ -400,7 +400,7 @@ bool KValueFlashParameters< NUM_PHASE >::validateKValues( MultiFluidBase const * if( !tableData.getCellsData().empty()) { - std::vector< TableLayout::Column > columns; + stdVector< TableLayout::Column > columns; columns.emplace_back( TableLayout::Column().setName( "Phase" ).setValuesAlignment( TableLayout::Alignment::left ) ); columns.emplace_back( TableLayout::Column().setName( "Pressure" ).setValuesAlignment( TableLayout::Alignment::right ) ); columns.emplace_back( TableLayout::Column().setName( "Temperature" ).setValuesAlignment( TableLayout::Alignment::right ) ); diff --git a/src/coreComponents/constitutive/fluid/multifluid/compositional/parameters/PhaseType.cpp b/src/coreComponents/constitutive/fluid/multifluid/compositional/parameters/PhaseType.cpp index a86de714834..435b50a6202 100644 --- a/src/coreComponents/constitutive/fluid/multifluid/compositional/parameters/PhaseType.cpp +++ b/src/coreComponents/constitutive/fluid/multifluid/compositional/parameters/PhaseType.cpp @@ -29,7 +29,7 @@ namespace constitutive namespace compositional { -static std::unordered_map< PhaseType, std::string > const phase_aliases{ +static stdUnorderedMap< PhaseType, std::string > const phase_aliases{ {PhaseType::LIQUID, "liquid,liq,oil"}, {PhaseType::VAPOUR, "gas,vap,vapor,vapour"}, {PhaseType::AQUEOUS, "wat,water,aqueous"} diff --git a/src/coreComponents/constitutive/unitTests/TestFluid.hpp b/src/coreComponents/constitutive/unitTests/TestFluid.hpp index ea6d23fe70b..9be655cfca7 100644 --- a/src/coreComponents/constitutive/unitTests/TestFluid.hpp +++ b/src/coreComponents/constitutive/unitTests/TestFluid.hpp @@ -78,7 +78,7 @@ struct Fluid 7.45513e-02, 1.80000e+07, 3.47000e+03, 6.25000e-04, -1.21200e-01, 3.05992e-05, // KCL (potassium chloride) }; - static std::unordered_map const componentNames; + static stdUnorderedMap const componentNames; /* UNCRUSTIFY-ON */ }; @@ -199,7 +199,7 @@ class TestFluid }; /* UNCRUSTIFY-OFF */ -std::unordered_map const Fluid::componentNames = { +stdUnorderedMap const Fluid::componentNames = { { H2O, "H2O" }, // water { CO2, "CO2" }, // carbon dioxide { N2, "N2" }, // nitrogen diff --git a/src/coreComponents/constitutive/unitTests/testSoreideWhitsonFlash.cpp b/src/coreComponents/constitutive/unitTests/testSoreideWhitsonFlash.cpp index 54645b4207e..87d948828a1 100644 --- a/src/coreComponents/constitutive/unitTests/testSoreideWhitsonFlash.cpp +++ b/src/coreComponents/constitutive/unitTests/testSoreideWhitsonFlash.cpp @@ -64,7 +64,7 @@ TEST_P( SoreideWhitsonSolubilityTestFixture, testSolubility ) /* UNCRUSTIFY-OFF */ // Soreide-Whitson correlations work only with "true" values of component parameters // kij_NA is the binary interation coefficient in the gas phase (see Table 5 Soreide-Whitson (1992)) - std::unordered_map const> const componentDatabase = { + stdUnorderedMap const> const componentDatabase = { // Mw Pc Tc Vc Ac kij_NA {Fluid::H2O, { 1.80153e-02, 2.20640e+07, 6.47096e+02, 5.59480e-05, 3.44300e-01, 0.0000 }}, {Fluid::CO2, { 4.40095e-02, 7.37730e+06, 3.04128e+02, 9.41185e-05, 2.23940e-01, 0.1896 }}, diff --git a/src/coreComponents/dataRepository/ObjectCatalog.hpp b/src/coreComponents/dataRepository/ObjectCatalog.hpp index 862cd91b704..810ea678d79 100644 --- a/src/coreComponents/dataRepository/ObjectCatalog.hpp +++ b/src/coreComponents/dataRepository/ObjectCatalog.hpp @@ -22,8 +22,8 @@ * a similar manner to classic virtual factory method, except that it is no * maintained list of derived objects that is required to create new objects. * Instead, the ``ObjectCatalog`` creates a "catalog" of derived objects using - * a ``std::unordered_map``. - * This ``std::unordered_map`` is then statically initialized through the declaration + * a ``stdUnorderedMap``. + * This ``stdUnorderedMap`` is then statically initialized through the declaration * of a */ @@ -71,8 +71,8 @@ class CatalogInterface /// This is the type that will be used for the catalog. The catalog is actually instantiated in the @p BASETYPE. //START_SPHINX_1 - typedef std::unordered_map< std::string, - std::unique_ptr< CatalogInterface< BASETYPE, ARGS... > > > CatalogType; + typedef stdUnorderedMap< std::string, + std::unique_ptr< CatalogInterface< BASETYPE, ARGS... > > > CatalogType; //STOP_SPHINX /** @@ -426,7 +426,7 @@ class CatalogInterface< BASETYPE > public: /// This is the type that will be used for the catalog. The catalog is actually instantiated in the @p BASETYPE. - typedef std::unordered_map< std::string, std::unique_ptr< CatalogInterface< BASETYPE > > > CatalogType; + typedef stdUnorderedMap< std::string, std::unique_ptr< CatalogInterface< BASETYPE > > > CatalogType; /** * @brief Default constructor. diff --git a/src/coreComponents/dataRepository/unitTests/testErrorHandling.cpp b/src/coreComponents/dataRepository/unitTests/testErrorHandling.cpp index 84098904ac6..d2a2d16257a 100644 --- a/src/coreComponents/dataRepository/unitTests/testErrorHandling.cpp +++ b/src/coreComponents/dataRepository/unitTests/testErrorHandling.cpp @@ -66,7 +66,7 @@ void beginLocalLoggerTest( ErrorLogger & errorLogger, string_view filename ) * @param expectedFileBits reference file parts that must be in the logger file output */ void endLocalLoggerTest( ErrorLogger & errorLogger, - std::vector< string > expectedFileBits ) + stdVector< string > expectedFileBits ) { auto const readFile = [] ( string_view filename ) { if( !fs::exists( filename )) diff --git a/src/coreComponents/fileIO/Outputs/unitTests/testMemoryStats.cpp b/src/coreComponents/fileIO/Outputs/unitTests/testMemoryStats.cpp index b07a30431a2..84cd000bc60 100644 --- a/src/coreComponents/fileIO/Outputs/unitTests/testMemoryStats.cpp +++ b/src/coreComponents/fileIO/Outputs/unitTests/testMemoryStats.cpp @@ -170,7 +170,7 @@ TEST( testXML, testMemoryCSVOutput ) memOutput.execute( 0.0, 0.0, dummyCycle, 0, 0.0, problem.getDomainPartition() ); // read the CSV output (parseFile() will throw if no CSV is generated) - std::vector< string > csvLines; + stdVector< string > csvLines; { std::ifstream is( memOutputFileName ); EXPECT_TRUE( is.good() ); @@ -184,9 +184,9 @@ TEST( testXML, testMemoryCSVOutput ) auto const findCSVMemoryEntry = [=]( string_view cycleStr, string_view memSpaceName ) -> bool { for( string const & csvLine : csvLines ) { - std::vector< string > const lineEntries = stringutilities::tokenize( csvLine, - TableCSVFormatter::m_separator, - false ); + stdVector< string > const lineEntries = stringutilities::tokenize( csvLine, + TableCSVFormatter::m_separator, + false ); EXPECT_GT( lineEntries.size(), 3 ); if( lineEntries[0] == cycleStr && lineEntries[2] == memSpaceName ) { // we found the line coresponding to the given cycle & memory-space diff --git a/src/coreComponents/fileIO/vtk/VTKPolyDataWriterInterface.cpp b/src/coreComponents/fileIO/vtk/VTKPolyDataWriterInterface.cpp index 6c66bb2f368..bb3c0182b12 100644 --- a/src/coreComponents/fileIO/vtk/VTKPolyDataWriterInterface.cpp +++ b/src/coreComponents/fileIO/vtk/VTKPolyDataWriterInterface.cpp @@ -362,7 +362,7 @@ getSurface( FaceElementSubRegion const & subRegion, stdVector< int > cellTypes; cellTypes.reserve( subRegion.size() ); - std::unordered_map< localIndex, localIndex > geos2VTKIndexing; + stdUnorderedMap< localIndex, localIndex > geos2VTKIndexing; geos2VTKIndexing.reserve( subRegion.size() * subRegion.numNodesPerElement() ); localIndex nodeIndexInVTK = 0; // FaceElementSubRegion being heterogeneous, the size of the connectivity vector may vary for each element. @@ -398,7 +398,7 @@ getSurface( FaceElementSubRegion const & subRegion, /// nodeIndexInVTK++). /// 2. we increment nodeIndexInVTK to ensure the next new node gets a unique index. /// 3. we add this new VTK node index to the connectivity vector (connectivity.push_back). - connectivity.push_back( geos2VTKIndexing[nodes[ordering]] = nodeIndexInVTK++ ); + connectivity.push_back( geos2VTKIndexing.get_inserted( nodes[ordering] ) = nodeIndexInVTK++ ); } else { diff --git a/src/coreComponents/finiteVolume/mimeticInnerProducts/unitTests/testMimeticInnerProducts.cpp b/src/coreComponents/finiteVolume/mimeticInnerProducts/unitTests/testMimeticInnerProducts.cpp index 49c1df7a4c5..20da0e14b04 100644 --- a/src/coreComponents/finiteVolume/mimeticInnerProducts/unitTests/testMimeticInnerProducts.cpp +++ b/src/coreComponents/finiteVolume/mimeticInnerProducts/unitTests/testMimeticInnerProducts.cpp @@ -1381,7 +1381,7 @@ TEST( MimeticIP_Linear, UnitCube_LinearPressure_BdVLM ) TEST( MimeticIP_Linear, Distortion_Planar_LinearPressure ) { int neps = 3; - std::vector< double > eps_values( 3 ); + stdVector< double > eps_values( 3 ); eps_values[0] = 0.0; // no distortion eps_values[1] = 0.2; // moderate distortion eps_values[2] = 0.9; // severe distortion @@ -1422,7 +1422,7 @@ TEST( MimeticIP_Linear, Distortion_Planar_LinearPressure ) TEST( MimeticIP_Linear, Distortion_NonPlanar_LinearPressure ) { int neps = 2; - std::vector< double > eps_values( 2 ); + stdVector< double > eps_values( 2 ); eps_values[0] = 0.2; // moderate distortion eps_values[1] = 0.9; // severe distortion @@ -1727,7 +1727,7 @@ TEST( Hydrostatic, GravityConsistency_NoDistortion_BdVLM ) TEST( Hydrostatic, GravityConsistency_Distortion_Planar ) { int neps = 2; - std::vector< double > eps_values( 2 ); + stdVector< double > eps_values( 2 ); eps_values[0] = 0.2; // moderate distortion eps_values[1] = 0.9; // severe distortion @@ -1754,7 +1754,7 @@ TEST( Hydrostatic, GravityConsistency_Distortion_Planar ) TEST( Hydrostatic, GravityConsistency_Distortion_NonPlanar ) { int neps = 2; - std::vector< double > eps_values( 2 ); + stdVector< double > eps_values( 2 ); eps_values[0] = 0.2; // moderate distortion eps_values[1] = 0.9; // severe distortion diff --git a/src/coreComponents/integrationTests/fieldSpecificationTests/testFieldSpecification.cpp b/src/coreComponents/integrationTests/fieldSpecificationTests/testFieldSpecification.cpp index d474ee9c564..a7065dbe97c 100644 --- a/src/coreComponents/integrationTests/fieldSpecificationTests/testFieldSpecification.cpp +++ b/src/coreComponents/integrationTests/fieldSpecificationTests/testFieldSpecification.cpp @@ -199,10 +199,10 @@ void setupAndPlayWrongBC( string const & xml ) problem.applyInitialConditions(); } -std::vector< string > splitStringByDelimiter( string const & s, string const & delimiter ) +stdVector< string > splitStringByDelimiter( string const & s, string const & delimiter ) { string cpyTokens = s; - std::vector< string > tokens; + stdVector< string > tokens; size_t pos = 0; string token; while((pos = cpyTokens.find( delimiter )) != string::npos ) @@ -283,7 +283,7 @@ TEST( testIncorrectFieldSpecification, testRightFieldNames ) "ghostRank, localToGlobalMap, mass, pressure, rockPorosity_initialPorosity, rockPorosity_porosity, " "rockPorosity_referencePorosity, temperature, water_dDensity, water_dEnthalpy, water_dInternalEnergy, " "water_dViscosity, water_density, water_enthalpy, water_internalEnergy, water_viscosity"; - std::vector< string > const splitToken = splitStringByDelimiter( tokens, "," ); + stdVector< string > const splitToken = splitStringByDelimiter( tokens, "," ); for( auto const & token : splitToken ) { string const xmlTemplate = R"xml( diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testCompositionalMultiPhaseMFDPolyhedral.cpp b/src/coreComponents/integrationTests/fluidFlowTests/testCompositionalMultiPhaseMFDPolyhedral.cpp index 8dfd432d91a..acf299b9871 100644 --- a/src/coreComponents/integrationTests/fluidFlowTests/testCompositionalMultiPhaseMFDPolyhedral.cpp +++ b/src/coreComponents/integrationTests/fluidFlowTests/testCompositionalMultiPhaseMFDPolyhedral.cpp @@ -327,21 +327,21 @@ static std::string generateXmlInputCompMFD( std::string const & innerProductType return oss.str(); } -// Helper: copy arrayView1d to std::vector -static inline std::vector< real64 > arrayViewToVector( arrayView1d< real64 const > & arr ) +// Helper: copy arrayView1d to stdVector +static inline stdVector< real64 > arrayViewToVector( arrayView1d< real64 const > & arr ) { arr.move( hostMemorySpace, false ); - return std::vector< real64 >( arr.data(), arr.data() + arr.size() ); + return stdVector< real64 >( arr.data(), arr.data() + arr.size() ); } // Helper: copy a 2D view to flat vector (row-major by phase index), accepts any 2D view type template< typename View2D > -static inline std::vector< real64 > arrayView2dToVector( View2D & arr ) +static inline stdVector< real64 > arrayView2dToVector( View2D & arr ) { arr.move( hostMemorySpace, false ); localIndex nCells = arr.size( 0 ); localIndex nCols = arr.size( 1 ); - std::vector< real64 > out; + stdVector< real64 > out; out.reserve( static_cast< size_t >( nCells ) * static_cast< size_t >( nCols ) ); for( localIndex i = 0; i < nCells; ++i ) { @@ -535,8 +535,8 @@ TEST_P( CompositionalTPFAvsMFDTPFA, PressureAndSaturationComparison ) std::string const testBinaryDir = TEST_BINARY_DIR; std::string const meshFile = testBinaryDir + std::string( "/" ) + GetParam(); - std::vector< real64 > p_tpfa, p_mfd; - std::vector< real64 > sat_tpfa, sat_mfd; // phase volume fractions flattened [cell,phase] + stdVector< real64 > p_tpfa, p_mfd; + stdVector< real64 > sat_tpfa, sat_mfd; // phase volume fractions flattened [cell,phase] localIndex n_cells_tpfa = 0, n_cells_mfd = 0; localIndex n_phases_tpfa = 2, n_phases_mfd = 2; // From XML phaseNames diff --git a/src/coreComponents/integrationTests/fluidFlowTests/testSinglePhaseMFDPolyhedral.cpp b/src/coreComponents/integrationTests/fluidFlowTests/testSinglePhaseMFDPolyhedral.cpp index 58c8c167f66..77915637bb8 100644 --- a/src/coreComponents/integrationTests/fluidFlowTests/testSinglePhaseMFDPolyhedral.cpp +++ b/src/coreComponents/integrationTests/fluidFlowTests/testSinglePhaseMFDPolyhedral.cpp @@ -433,11 +433,11 @@ class TPFAvsMFDTPFATest : public ::testing::TestWithParam< const char * > TPFAvsMFDTPFATest() = default; }; -// Helper function to copy arrayView1d to std::vector -static inline std::vector< real64 > arrayViewToVector( arrayView1d< real64 const > & arr, localIndex n ) +// Helper function to copy arrayView1d to stdVector +static inline stdVector< real64 > arrayViewToVector( arrayView1d< real64 const > & arr, localIndex n ) { arr.move( hostMemorySpace, false ); - return std::vector< real64 >( arr.data(), arr.data() + n ); + return stdVector< real64 >( arr.data(), arr.data() + n ); } @@ -458,8 +458,8 @@ TEST_P( TPFAvsMFDTPFATest, PressureFieldComparison ) // Use the CMAKE-defined TEST_BINARY_DIR variable std::string testBinaryDir = TEST_BINARY_DIR; - std::vector< real64 > p_tpfa; - std::vector< real64 > p_mfd; + stdVector< real64 > p_tpfa; + stdVector< real64 > p_mfd; localIndex n_data_tpfa = 0; localIndex n_data_mfd = 0; diff --git a/src/coreComponents/integrationTests/solverStatisticsTests/testSolverStats.cpp b/src/coreComponents/integrationTests/solverStatisticsTests/testSolverStats.cpp index 7247a45a722..2b254d517f8 100644 --- a/src/coreComponents/integrationTests/solverStatisticsTests/testSolverStats.cpp +++ b/src/coreComponents/integrationTests/solverStatisticsTests/testSolverStats.cpp @@ -54,8 +54,8 @@ class ConvergenceTest : public ConvergenceStatistics public: - void AssertConvergenceValuesEquals( std::vector< std::string > const & actualValues, - std::vector< std::string > const & expectedValues ) + void AssertConvergenceValuesEquals( stdVector< std::string > const & actualValues, + stdVector< std::string > const & expectedValues ) { EXPECT_EQ( actualValues[0], expectedValues[0] ); EXPECT_EQ( actualValues[1], expectedValues[1] ); @@ -238,7 +238,7 @@ TEST( testSolverStats, testOutputFiles ) ConvergenceTest & convergenceStat = static_cast< ConvergenceTest & >(solver.getConvergenceStats()); IterationTest & iterationStat = static_cast< IterationTest & >(solver.getIterationStats()); - auto loadCsvLines = []( string const & filename, std::vector< string > & lines ) { + auto loadCsvLines = []( string const & filename, stdVector< string > & lines ) { if( !std::filesystem::exists( filename )) { @@ -293,7 +293,7 @@ TEST( testSolverStats, testOutputFiles ) return true; }; - std::vector< string > csvLines; + stdVector< string > csvLines; loadCsvLines( iterationStat.getFilename(), csvLines ); EXPECT_EQ( csvLines[0], @@ -304,7 +304,7 @@ TEST( testSolverStats, testOutputFiles ) iterationStat.AssertIterationValuesEquals(); - std::vector< string > csvLines2; + stdVector< string > csvLines2; loadCsvLines( convergenceStat.getFilename(), csvLines2 ); EXPECT_EQ( csvLines2[0], "Cycle number,time_n (s),dt (s),iteration,R,Rflow" ); diff --git a/src/coreComponents/integrationTests/wellsTests/testOpenClosePerf.cpp b/src/coreComponents/integrationTests/wellsTests/testOpenClosePerf.cpp index 652fbf9b46e..36a32117b62 100644 --- a/src/coreComponents/integrationTests/wellsTests/testOpenClosePerf.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testOpenClosePerf.cpp @@ -174,7 +174,7 @@ void testPlugTopDownPerfCheck( CompositionalMultiphaseReservoirAndWells<> & solv { CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); - typedef stdMap< real64, std::vector< int > > map_type; + typedef stdMap< real64, stdVector< int > > map_type; map_type refVal; refVal.insert( {29800.0, { 1, 1, 1, 1, 1}} ); refVal.insert( {32400.0, { 1, 1, 1, 1, 0}} ); @@ -186,7 +186,7 @@ void testPlugTopDownPerfCheck( CompositionalMultiphaseReservoirAndWells<> & solv { perfFunction( it->first ); - const std::vector< int > & refStatus = it->second; + const stdVector< int > & refStatus = it->second; wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, MeshLevel & mesh, string_array const & regionNames ) @@ -216,7 +216,7 @@ void testPlugBottomUpPerfCheck( CompositionalMultiphaseReservoirAndWells<> & sol { CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); - typedef stdMap< real64, std::vector< int > > map_type; + typedef stdMap< real64, stdVector< int > > map_type; map_type refVal; refVal.insert( {4800.0, { 1, 1, 1, 1, 1}} ); refVal.insert( {14800.0, { 1, 1, 1, 1, 0}} ); @@ -229,7 +229,7 @@ void testPlugBottomUpPerfCheck( CompositionalMultiphaseReservoirAndWells<> & sol { perfFunction( it->first ); - const std::vector< int > & refStatus = it->second; + const stdVector< int > & refStatus = it->second; wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, MeshLevel & mesh, string_array const & regionNames ) @@ -259,7 +259,7 @@ void testOpenTopDownPerfCheck( CompositionalMultiphaseReservoirAndWells<> & solv { CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); - typedef stdMap< real64, std::vector< int > > map_type; + typedef stdMap< real64, stdVector< int > > map_type; map_type refPerfTable; refPerfTable.insert( {4800.0, { 0, 0, 0, 0, 0}} ); refPerfTable.insert( {14800.0, { 1, 0, 0, 0, 0}} ); @@ -271,7 +271,7 @@ void testOpenTopDownPerfCheck( CompositionalMultiphaseReservoirAndWells<> & solv { perfFunction( it->first ); - const std::vector< int > & refStatus = it->second; + const stdVector< int > & refStatus = it->second; wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, MeshLevel & mesh, string_array const & regionNames ) @@ -301,7 +301,7 @@ void testOpenBottomUpPerfCheck( CompositionalMultiphaseReservoirAndWells<> & sol { CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); - typedef stdMap< real64, std::vector< int > > map_type; + typedef stdMap< real64, stdVector< int > > map_type; map_type refVal; refVal.insert( {4800.0, { 0, 0, 0, 0, 0}} ); refVal.insert( {33000.0, { 1, 1, 1, 1, 1}} ); @@ -311,7 +311,7 @@ void testOpenBottomUpPerfCheck( CompositionalMultiphaseReservoirAndWells<> & sol { perfFunction( it->first ); - const std::vector< int > & refStatus = it->second; + const stdVector< int > & refStatus = it->second; wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, MeshLevel & mesh, string_array const & regionNames ) diff --git a/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells.cpp b/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells.cpp index 8b1e19af0a7..16cd7e0855c 100644 --- a/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells.cpp @@ -175,8 +175,8 @@ void printCompareLocalMatrices( CRSMatrixView< T const, COL_INDEX const > const std::ofstream omat1( testName+".csv" ); - std::vector< std::vector< double > > fmat1( matrix1.numRows(), std::vector< double >( matrix1.numRows(), 0.0 )); - std::vector< std::vector< double > > fmat2( matrix2.numRows(), std::vector< double >( matrix2.numRows(), 0.0 )); + stdVector< stdVector< double > > fmat1( matrix1.numRows(), stdVector< double >( matrix1.numRows(), 0.0 )); + stdVector< stdVector< double > > fmat2( matrix2.numRows(), stdVector< double >( matrix2.numRows(), 0.0 )); for( localIndex i = 0; i < matrix1.numRows(); ++i ) { diff --git a/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells_RateInj.cpp b/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells_RateInj.cpp index b1fa0d9cb84..9169eeb0206 100644 --- a/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells_RateInj.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells_RateInj.cpp @@ -257,8 +257,8 @@ void printCompareLocalMatrices( CRSMatrixView< T const, COL_INDEX const > const std::ofstream omat1( testName+".csv" ); - std::vector< std::vector< double > > fmat1( matrix1.numRows(), std::vector< double >( matrix1.numRows(), 0.0 )); - std::vector< std::vector< double > > fmat2( matrix2.numRows(), std::vector< double >( matrix2.numRows(), 0.0 )); + stdVector< stdVector< double > > fmat1( matrix1.numRows(), stdVector< double >( matrix1.numRows(), 0.0 )); + stdVector< stdVector< double > > fmat2( matrix2.numRows(), stdVector< double >( matrix2.numRows(), 0.0 )); for( localIndex i = 0; i < matrix1.numRows(); ++i ) { diff --git a/src/coreComponents/linearAlgebra/interfaces/hypre/HypreUtils.cpp b/src/coreComponents/linearAlgebra/interfaces/hypre/HypreUtils.cpp index 9fee0322379..bb8de0a6ad7 100644 --- a/src/coreComponents/linearAlgebra/interfaces/hypre/HypreUtils.cpp +++ b/src/coreComponents/linearAlgebra/interfaces/hypre/HypreUtils.cpp @@ -82,7 +82,7 @@ HYPRE_Vector parVectorToVector( HYPRE_ParVector const vec, int const targetRank newVec = hypre_SeqVectorCreate( globalSize ); hypre_SeqVectorInitialize_v2( newVec, HYPRE_MEMORY_HOST ); - std::vector< MPI_Request > requests( numProcs, MPI_REQUEST_NULL ); + stdVector< MPI_Request > requests( numProcs, MPI_REQUEST_NULL ); for( int i = 0; i < numProcs; ++i ) { HYPRE_Real * const data = hypre_VectorData( newVec ) + offsets[i]; diff --git a/src/coreComponents/linearAlgebra/interfaces/hypre/hypredrive.cpp b/src/coreComponents/linearAlgebra/interfaces/hypre/hypredrive.cpp index 1d6d9f5c37c..1db7a6e581c 100644 --- a/src/coreComponents/linearAlgebra/interfaces/hypre/hypredrive.cpp +++ b/src/coreComponents/linearAlgebra/interfaces/hypre/hypredrive.cpp @@ -654,7 +654,7 @@ stdVector< string > buildDofLabelNames( LinearSolverParameters::MGR::StrategyTyp return labels; } -std::string joinLabelNames( std::vector< HYPRE_Int > const & values, +std::string joinLabelNames( stdVector< HYPRE_Int > const & values, stdVector< string > const & labelNames ) { std::ostringstream stream; @@ -903,7 +903,7 @@ struct LevelAMGBlock struct MGRSpecialization { AMGFlavor coarseFlavor = AMGFlavor::pressure; - std::vector< LevelAMGBlock > fRelaxAMGLevels; + stdVector< LevelAMGBlock > fRelaxAMGLevels; HYPRE_Int pmax = 0; HYPRE_Int coarseMinCoarseSize = -1; }; @@ -1171,13 +1171,13 @@ bool buildStrategyYaml( LinearSolverParameters const & params, appendLine( stream, 2, GEOS_FMT( "num_levels: {}", MGRStrategyProbe< STRATEGY >::numReductionLevels + 1 ) ); appendLine( stream, 2, "level:" ); - std::vector< HYPRE_Int > activeLabels( static_cast< size_t >( strategy.m_numBlocks ) ); + stdVector< HYPRE_Int > activeLabels( static_cast< size_t >( strategy.m_numBlocks ) ); std::iota( activeLabels.begin(), activeLabels.end(), 0 ); for( HYPRE_Int level = 0; level < MGRStrategyProbe< STRATEGY >::numReductionLevels; ++level ) { - std::vector< HYPRE_Int > cLabels( strategy.m_labels[level].begin(), strategy.m_labels[level].end() ); - std::vector< HYPRE_Int > fLabels; + stdVector< HYPRE_Int > cLabels( strategy.m_labels[level].begin(), strategy.m_labels[level].end() ); + stdVector< HYPRE_Int > fLabels; for( HYPRE_Int const activeLabel : activeLabels ) { diff --git a/src/coreComponents/linearAlgebra/multiscale/MultiscalePreconditioner.hpp b/src/coreComponents/linearAlgebra/multiscale/MultiscalePreconditioner.hpp index c4758aeb7e2..f462331b6c3 100644 --- a/src/coreComponents/linearAlgebra/multiscale/MultiscalePreconditioner.hpp +++ b/src/coreComponents/linearAlgebra/multiscale/MultiscalePreconditioner.hpp @@ -100,7 +100,7 @@ class MultiscalePreconditioner : public PreconditionerBase< LAI > DomainPartition & m_domain; - std::vector< LevelData > m_levels; + stdVector< LevelData > m_levels; std::unique_ptr< PreconditionerBase< LAI > > m_coarse_solver; diff --git a/src/coreComponents/linearAlgebra/multiscale/mesh/DofManager.hpp b/src/coreComponents/linearAlgebra/multiscale/mesh/DofManager.hpp index c27b6be3857..10f97b23fd1 100644 --- a/src/coreComponents/linearAlgebra/multiscale/mesh/DofManager.hpp +++ b/src/coreComponents/linearAlgebra/multiscale/mesh/DofManager.hpp @@ -235,7 +235,7 @@ class DofManager DomainPartition * m_domain = nullptr; /// Array of field descriptions - std::vector< FieldDescription > m_fields; + stdVector< FieldDescription > m_fields; /// Flag indicating that DOFs have been reordered rank-wise. bool m_reordered = false; diff --git a/src/coreComponents/linearAlgebra/multiscale/mesh/MeshLevel.cpp b/src/coreComponents/linearAlgebra/multiscale/mesh/MeshLevel.cpp index 0d8bf0cdf29..b45e08c7e52 100644 --- a/src/coreComponents/linearAlgebra/multiscale/mesh/MeshLevel.cpp +++ b/src/coreComponents/linearAlgebra/multiscale/mesh/MeshLevel.cpp @@ -123,7 +123,7 @@ void populateNodeManager( string const & localIndexKey, numLocalNodes ); // Setup neighbor data - std::vector< int > const neighborRanks = domain.getNeighborRanks(); + stdVector< int > const neighborRanks = domain.getNeighborRanks(); for( int const rank : neighborRanks ) { msNodeManager.addNeighbor( rank ); @@ -255,7 +255,7 @@ void populateCellManager( string const & localIndexKey, numLocalCells ); // Setup neighbor data - std::vector< int > const neighborRanks = domain.getNeighborRanks(); + stdVector< int > const neighborRanks = domain.getNeighborRanks(); for( int const rank : neighborRanks ) { msCellManager.addNeighbor( rank ); @@ -424,7 +424,7 @@ void MeshLevel::buildCoarseMesh( multiscale::MeshLevel & fineMesh, coarsening::buildCoarseMesh( fineMesh, *this, coarse_params, boundaryNodeSets ); } -void MeshLevel::writeCellData( std::vector< string > const & fieldNames, int depth ) const +void MeshLevel::writeCellData( stdVector< string > const & fieldNames, int depth ) const { if( m_fineMesh ) { @@ -436,7 +436,7 @@ void MeshLevel::writeCellData( std::vector< string > const & fieldNames, int dep } } -void MeshLevel::writeNodeData( std::vector< string > const & fieldNames, int depth ) const +void MeshLevel::writeNodeData( stdVector< string > const & fieldNames, int depth ) const { if( m_fineMesh ) { @@ -448,7 +448,7 @@ void MeshLevel::writeNodeData( std::vector< string > const & fieldNames, int dep } } -void MeshLevel::writeCellDataFine( std::vector< string > const & fieldNames, int depth ) const +void MeshLevel::writeCellDataFine( stdVector< string > const & fieldNames, int depth ) const { geos::MeshLevel & sourceMesh = m_domain->getMeshBody( m_support.meshBodyName ).getMeshLevel( m_support.meshLevelName ); arrayView1d< localIndex const > const origRegion = m_cellManager.getField< fields::multiscale::OrigElementRegion >(); @@ -492,13 +492,13 @@ void MeshLevel::writeCellDataFine( std::vector< string > const & fieldNames, int } } -void MeshLevel::writeCellDataCoarse( std::vector< string > const & fieldNames, int depth ) const +void MeshLevel::writeCellDataCoarse( stdVector< string > const & fieldNames, int depth ) const { GEOS_ASSERT( m_fineMesh != nullptr ); arrayView1d< localIndex const > const coarseCellIndex = m_fineMesh->cellManager().getField< fields::multiscale::CoarseCellLocalIndex >(); - std::vector< string > fineFieldNames; + stdVector< string > fineFieldNames; for( string const & fieldName : fieldNames ) { WrapperBase const & wrapper = m_cellManager.getWrapperBase( fieldName ); @@ -534,7 +534,7 @@ void MeshLevel::writeCellDataCoarse( std::vector< string > const & fieldNames, i m_fineMesh->writeCellData( fineFieldNames, depth + 1 ); } -void MeshLevel::writeNodeDataFine( std::vector< string > const & fieldNames, int depth ) const +void MeshLevel::writeNodeDataFine( stdVector< string > const & fieldNames, int depth ) const { geos::MeshLevel & sourceMesh = m_domain->getMeshBody( m_support.meshBodyName ).getMeshLevel( m_support.meshLevelName ); arrayView1d< localIndex const > const origNodeIndex = m_nodeManager.getField< fields::multiscale::OrigNodeIndex >(); @@ -570,12 +570,12 @@ void MeshLevel::writeNodeDataFine( std::vector< string > const & fieldNames, int } } -void MeshLevel::writeNodeDataCoarse( std::vector< string > const & fieldNames, int depth ) const +void MeshLevel::writeNodeDataCoarse( stdVector< string > const & fieldNames, int depth ) const { GEOS_ASSERT( m_fineMesh != nullptr ); arrayView1d< localIndex const > const fineNodeIndex = m_nodeManager.getField< fields::multiscale::FineNodeLocalIndex >(); - std::vector< string > fineFieldNames; + stdVector< string > fineFieldNames; for( string const & fieldName : fieldNames ) { WrapperBase const & wrapper = m_nodeManager.getWrapperBase( fieldName ); diff --git a/src/coreComponents/linearAlgebra/multiscale/mesh/MeshLevel.hpp b/src/coreComponents/linearAlgebra/multiscale/mesh/MeshLevel.hpp index 69843f3170e..db96de9ecd3 100644 --- a/src/coreComponents/linearAlgebra/multiscale/mesh/MeshLevel.hpp +++ b/src/coreComponents/linearAlgebra/multiscale/mesh/MeshLevel.hpp @@ -96,14 +96,14 @@ class MeshLevel * @param fieldNames the list of field names to write * @param depth counter used to track recursion depth (leave default value of 0) */ - void writeCellData( std::vector< string > const & fieldNames, int depth = 0 ) const; + void writeCellData( stdVector< string > const & fieldNames, int depth = 0 ) const; /** * @brief Push node data to finer levels * @param fieldNames the list of field names to write * @param depth counter used to track recursion depth (leave default value of 0) */ - void writeNodeData( std::vector< string > const & fieldNames, int depth = 0 ) const; + void writeNodeData( stdVector< string > const & fieldNames, int depth = 0 ) const; /** * @brief @return the level name @@ -122,10 +122,10 @@ class MeshLevel private: - void writeCellDataFine( std::vector< string > const & fieldNames, int depth ) const; - void writeCellDataCoarse( std::vector< string > const & fieldNames, int depth ) const; - void writeNodeDataFine( std::vector< string > const & fieldNames, int depth ) const; - void writeNodeDataCoarse( std::vector< string > const & fieldNames, int depth ) const; + void writeCellDataFine( stdVector< string > const & fieldNames, int depth ) const; + void writeCellDataCoarse( stdVector< string > const & fieldNames, int depth ) const; + void writeNodeDataFine( stdVector< string > const & fieldNames, int depth ) const; + void writeNodeDataCoarse( stdVector< string > const & fieldNames, int depth ) const; string m_name; ///< Unique name prefix diff --git a/src/coreComponents/linearAlgebra/multiscale/mesh/MeshUtils.hpp b/src/coreComponents/linearAlgebra/multiscale/mesh/MeshUtils.hpp index 24a02ccffd7..38f820f756b 100644 --- a/src/coreComponents/linearAlgebra/multiscale/mesh/MeshUtils.hpp +++ b/src/coreComponents/linearAlgebra/multiscale/mesh/MeshUtils.hpp @@ -247,7 +247,7 @@ void fillArrayBySrcIndex( arrayView1d< INDEX const > const & map, template< typename FUNC > void copyNeighborData( ObjectManagerBase const & srcManager, string const & mapKey, - std::vector< integer > const & ranks, + stdVector< integer > const & ranks, ObjectManagerBase & dstManager, FUNC && copyFunc ) { diff --git a/src/coreComponents/linearAlgebra/multiscale/mesh/coarsening/Coarsening.cpp b/src/coreComponents/linearAlgebra/multiscale/mesh/coarsening/Coarsening.cpp index 5571fd2b719..4a325636475 100644 --- a/src/coreComponents/linearAlgebra/multiscale/mesh/coarsening/Coarsening.cpp +++ b/src/coreComponents/linearAlgebra/multiscale/mesh/coarsening/Coarsening.cpp @@ -234,7 +234,7 @@ void buildCoarseCells( multiscale::MeshLevel & fineMesh, fillBasicCellData( fineCellManager, coarseCellManager ); // Populate neighbor data and sets - std::vector< int > neighborRanks = fineMesh.domain()->getNeighborRanks(); + stdVector< int > neighborRanks = fineMesh.domain()->getNeighborRanks(); for( int const rank : neighborRanks ) { coarseCellManager.addNeighbor( rank ); @@ -375,7 +375,7 @@ void buildCoarseNodes( multiscale::MeshLevel & fineMesh, fillBasicNodeData( fineNodeManager, coarseNodeManager ); // Populate neighbor data and sets - std::vector< int > neighborRanks = fineMesh.domain()->getNeighborRanks(); + stdVector< int > neighborRanks = fineMesh.domain()->getNeighborRanks(); for( int const rank : neighborRanks ) { coarseNodeManager.addNeighbor( rank ); diff --git a/src/coreComponents/linearAlgebra/multiscale/mesh/coarsening/SemistructuredPartitioner.cpp b/src/coreComponents/linearAlgebra/multiscale/mesh/coarsening/SemistructuredPartitioner.cpp index 82c8ab67a29..e7b58e1c508 100644 --- a/src/coreComponents/linearAlgebra/multiscale/mesh/coarsening/SemistructuredPartitioner.cpp +++ b/src/coreComponents/linearAlgebra/multiscale/mesh/coarsening/SemistructuredPartitioner.cpp @@ -40,7 +40,7 @@ template< typename FUNC > CRSMatrix< int64_t, int64_t, int64_t > buildLayerGraph( multiscale::MeshLevel const & mesh, arrayView1d< localIndex const > const & layerCells, - std::unordered_map< integer, localIndex > const & structIndexToLayerCell, + stdUnorderedMap< integer, localIndex > const & structIndexToLayerCell, integer const layerIndex, integer const minCommonNodes, FUNC && weightFunc ) @@ -151,7 +151,7 @@ localIndex SemistructuredPartitioner::generate( MeshLevel const & mesh, array1d< localIndex > layerCells; layerCells.reserve( numCellsA ); - std::unordered_map< integer, localIndex > indexToLayer; + stdUnorderedMap< integer, localIndex > indexToLayer; indexToLayer.reserve( numCellsA ); forAll< serialPolicy >( numCells, [&]( localIndex const i ) diff --git a/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbLevelBuilder.cpp b/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbLevelBuilder.cpp index a8b4ddd1d4e..97740161d51 100644 --- a/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbLevelBuilder.cpp +++ b/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbLevelBuilder.cpp @@ -578,7 +578,7 @@ void MsrsbLevelBuilder< LAI >::writeProlongationForDebug() const MeshObjectManager & manager = m_location == FieldLocation::Node ? m_mesh.fineMesh()->nodeManager() : m_mesh.fineMesh()->cellManager(); - auto const writeFunc = [location = m_location]( multiscale::MeshLevel & mesh, std::vector< string > const & names ) + auto const writeFunc = [location = m_location]( multiscale::MeshLevel & mesh, stdVector< string > const & names ) { return location == FieldLocation::Node ? mesh.writeNodeData( names ) diff --git a/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbLevelBuilderCoupled.cpp b/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbLevelBuilderCoupled.cpp index dc268a33e17..9211a9c729e 100644 --- a/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbLevelBuilderCoupled.cpp +++ b/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbLevelBuilderCoupled.cpp @@ -126,17 +126,17 @@ void MsrsbLevelBuilderCoupled< LAI >::initializeFineLevel( DomainPartition & dom createSmoothers(); } -std::unordered_map< globalIndex, globalIndex > +stdUnorderedMap< globalIndex, globalIndex > makeGhostDofMap( MeshObjectManager const & manager, string const & oldDofKey, string const & newDofKey ) { - std::unordered_map< globalIndex, globalIndex > ghostDofMap; + stdUnorderedMap< globalIndex, globalIndex > ghostDofMap; arrayView1d< globalIndex const > const oldDofNumber = manager.getReference< array1d< globalIndex > >( oldDofKey ); arrayView1d< globalIndex const > const newDofNumber = manager.getReference< array1d< globalIndex > >( newDofKey ); for( localIndex i = manager.numOwnedObjects(); i < manager.size(); ++i ) { - ghostDofMap[oldDofNumber[i]] = newDofNumber[i]; + ghostDofMap.get_inserted( oldDofNumber[i] ) = newDofNumber[i]; } return ghostDofMap; } @@ -176,7 +176,7 @@ void MsrsbLevelBuilderCoupled< LAI >::buildProlongationStructure( DofManager con integer const numComp = m_dofManager.numComponents( fieldName ); - std::unordered_map< globalIndex, globalIndex > const ghostDofMap = + stdUnorderedMap< globalIndex, globalIndex > const ghostDofMap = makeGhostDofMap( m_builders[blockId]->manager(), dofManager.key( fieldName ), m_dofManager.key( fieldName ) ); auto const mapGhostCol = [numComp, &ghostDofMap]( globalIndex const col ) diff --git a/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbLevelBuilderCoupled.hpp b/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbLevelBuilderCoupled.hpp index 7f58df98b1c..e9d33362cd1 100644 --- a/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbLevelBuilderCoupled.hpp +++ b/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbLevelBuilderCoupled.hpp @@ -98,16 +98,16 @@ class MsrsbLevelBuilderCoupled : public MsrsbLevelBuilderBase< LAI > void buildProlongationStructure( DofManager const & fineDofManager ); /// A field description for each sub-block - std::vector< string > m_fields; + stdVector< string > m_fields; /// Subproblem selector matrices at the current level - std::vector< Matrix > m_selectors; + stdVector< Matrix > m_selectors; /// Levels for each sub-problem - std::vector< std::unique_ptr< MsrsbLevelBuilder< LAI > > > m_builders; + stdVector< std::unique_ptr< MsrsbLevelBuilder< LAI > > > m_builders; /// Sub-problem prolongators in extracted (local) form - std::vector< CRSMatrix< real64, globalIndex > > m_prolongationBlocks; + stdVector< CRSMatrix< real64, globalIndex > > m_prolongationBlocks; /// Temporary storage for combined prolongation operator (stored to avoid recreating the structure) CRSMatrix< real64, globalIndex > m_localProlongation; diff --git a/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbUtils.cpp b/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbUtils.cpp index 1b225e3f09b..3b7d906ab12 100644 --- a/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbUtils.cpp +++ b/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbUtils.cpp @@ -610,17 +610,17 @@ void writeProlongation( CRSMatrixView< real64 const, globalIndex const > const & string const & prefix, multiscale::MeshLevel & mesh, multiscale::MeshObjectManager & fineManager, - std::function< void ( multiscale::MeshLevel &, std::vector< string > const & ) > const & writeFunc ) + std::function< void ( multiscale::MeshLevel &, stdVector< string > const & ) > const & writeFunc ) { - std::vector< string > bNames{ "X ", "Y ", "Z " }; - std::vector< string > cNames{ " x", " y", " z" }; + stdVector< string > bNames{ "X ", "Y ", "Z " }; + stdVector< string > cNames{ " x", " y", " z" }; integer const numComp = dofManager.numComponents( fieldName ); globalIndex const numBfuncs = prolongation.numColumns() / numComp; int const labelWidth = static_cast< int >( std::log10( numBfuncs ) ) + 1; - std::vector< arrayView3d< real64 > > views; - std::vector< string > names; + stdVector< arrayView3d< real64 > > views; + stdVector< string > names; for( globalIndex bfIndex = 0; bfIndex < numBfuncs; ++bfIndex ) { diff --git a/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbUtils.hpp b/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbUtils.hpp index e4bcb7f8526..7dd1b7340fd 100644 --- a/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbUtils.hpp +++ b/src/coreComponents/linearAlgebra/multiscale/msrsb/MsrsbUtils.hpp @@ -254,7 +254,7 @@ void writeProlongation( CRSMatrixView< real64 const, globalIndex const > const & string const & prefix, multiscale::MeshLevel & mesh, multiscale::MeshObjectManager & fineManager, - std::function< void ( multiscale::MeshLevel &, std::vector< string > const & ) > const & writeFunc ); + std::function< void ( multiscale::MeshLevel &, stdVector< string > const & ) > const & writeFunc ); } // namespace msrsb } // namespace multiscale diff --git a/src/coreComponents/linearAlgebra/solvers/BlockPreconditioner.cpp b/src/coreComponents/linearAlgebra/solvers/BlockPreconditioner.cpp index 4d500926c0b..e0fd2af73ac 100644 --- a/src/coreComponents/linearAlgebra/solvers/BlockPreconditioner.cpp +++ b/src/coreComponents/linearAlgebra/solvers/BlockPreconditioner.cpp @@ -81,7 +81,7 @@ void BlockPreconditioner< LAI >::setupBlock( localIndex const blockIndex, template< typename LAI > void BlockPreconditioner< LAI >::setupBlock( localIndex const blockIndex, - std::vector< DofManager::SubComponent > blockDofs, + stdVector< DofManager::SubComponent > blockDofs, PreconditionerBase< LAI > * const solver, real64 const scaling ) { diff --git a/src/coreComponents/linearAlgebra/solvers/BlockPreconditioner.hpp b/src/coreComponents/linearAlgebra/solvers/BlockPreconditioner.hpp index 58622d2f933..951c1992fd1 100644 --- a/src/coreComponents/linearAlgebra/solvers/BlockPreconditioner.hpp +++ b/src/coreComponents/linearAlgebra/solvers/BlockPreconditioner.hpp @@ -115,7 +115,7 @@ class BlockPreconditioner : public PreconditionerBase< LAI > * DoF components in the monolithic system. */ void setupBlock( localIndex const blockIndex, - std::vector< DofManager::SubComponent > blockDofs, + stdVector< DofManager::SubComponent > blockDofs, PreconditionerBase< LAI > * const solver, real64 const scaling = 1.0 ); diff --git a/src/coreComponents/linearAlgebra/unitTests/testComponentMask.cpp b/src/coreComponents/linearAlgebra/unitTests/testComponentMask.cpp index 23aef693db0..ad7e46fbcaa 100644 --- a/src/coreComponents/linearAlgebra/unitTests/testComponentMask.cpp +++ b/src/coreComponents/linearAlgebra/unitTests/testComponentMask.cpp @@ -27,21 +27,21 @@ using namespace geos; template< int N > -void compare( ComponentMask< N > const & mask, std::vector< int > const & expected ) +void compare( ComponentMask< N > const & mask, stdVector< int > const & expected ) { EXPECT_EQ( mask.empty(), expected.empty() ); EXPECT_EQ( mask.size(), expected.size() ); - EXPECT_EQ( std::vector< int >( mask.begin(), mask.end() ), expected ); + EXPECT_EQ( stdVector< int >( mask.begin(), mask.end() ), expected ); } -std::vector< int > make_range( int lo, int const hi, int const step = 1 ) +stdVector< int > make_range( int lo, int const hi, int const step = 1 ) { - std::vector< int > r( hi - lo ); + stdVector< int > r( hi - lo ); std::generate( r.begin(), r.end(), [&lo, step] { int const ret = lo; lo += step; return ret; } ); return r; } -std::vector< int > join_range( std::vector< int > lhs, std::vector< int > const & rhs ) +stdVector< int > join_range( stdVector< int > lhs, stdVector< int > const & rhs ) { lhs.insert( lhs.end(), rhs.begin(), rhs.end() ); return lhs; @@ -173,7 +173,7 @@ TYPED_TEST( ComponentMaskTest, Set_EveryOtherComp ) using Mask = typename TestFixture::CompMask; constexpr int N = TestFixture::MAX_COMP; Mask mask( N ); - std::vector< int > expected; + stdVector< int > expected; for( int i = 0; i < N; i += 2 ) { mask.set( i ); @@ -187,7 +187,7 @@ TYPED_TEST( ComponentMaskTest, Set_EveryComp ) using Mask = typename TestFixture::CompMask; constexpr int N = TestFixture::MAX_COMP; Mask mask( N ); - std::vector< int > expected; + stdVector< int > expected; for( int i = 0; i < N; i += 1 ) { mask.set( i ); @@ -213,7 +213,7 @@ TYPED_TEST( ComponentMaskTest, Unset_EveryOtherComp ) using Mask = typename TestFixture::CompMask; constexpr int N = TestFixture::MAX_COMP; Mask mask( N, true ); - std::vector< int > expected; + stdVector< int > expected; for( int i = 0; i < N; i += 2 ) { mask.unset( i ); diff --git a/src/coreComponents/mesh/DomainPartition.hpp b/src/coreComponents/mesh/DomainPartition.hpp index 6644915738c..870ad00bec2 100644 --- a/src/coreComponents/mesh/DomainPartition.hpp +++ b/src/coreComponents/mesh/DomainPartition.hpp @@ -278,9 +278,9 @@ class DomainPartition : public dataRepository::Group * @brief Get a list of neighbor ranks. * @return Container of neighbor ranks. */ - std::vector< int > getNeighborRanks() const + stdVector< int > getNeighborRanks() const { - std::vector< int > ranks; + stdVector< int > ranks; ranks.reserve( m_neighbors.size() ); for( NeighborCommunicator const & neighbor : m_neighbors ) { diff --git a/src/coreComponents/mesh/ElementSubRegionBase.hpp b/src/coreComponents/mesh/ElementSubRegionBase.hpp index 21810289001..3af0767c53b 100644 --- a/src/coreComponents/mesh/ElementSubRegionBase.hpp +++ b/src/coreComponents/mesh/ElementSubRegionBase.hpp @@ -281,7 +281,7 @@ class ElementSubRegionBase : public ObjectManagerBase { // collect node coordinates for element k localIndex const numNodes = this->numNodesPerElement( k ); - std::vector< std::array< real64, 3 > > nodes; + stdVector< std::array< real64, 3 > > nodes; nodes.reserve( numNodes ); for( localIndex a = 0; a < numNodes; ++a ) { diff --git a/src/coreComponents/mesh/WellElementSubRegion.cpp b/src/coreComponents/mesh/WellElementSubRegion.cpp index 1cacfc95d80..401eb4b239c 100644 --- a/src/coreComponents/mesh/WellElementSubRegion.cpp +++ b/src/coreComponents/mesh/WellElementSubRegion.cpp @@ -215,7 +215,7 @@ bool isPointInsideElement( SurfaceElementSubRegion const & subRegion, // collect element nodes integer const nV = subRegion.numNodesPerElement( eiLocal ); SurfaceElementSubRegion::NodeMapType const & nodeList = subRegion.nodeList(); - std::vector< Point3d > polygon( nV ); + stdVector< Point3d > polygon( nV ); for( integer i = 0; i < nV; ++i ) { for( integer j = 0; j < 3; ++j ) @@ -1085,7 +1085,7 @@ void WellElementSubRegion::setElementStatus( arrayView1d< integer > const & loca // Sort indices based on the global index - std::vector< size_t > indices( numElements ); + stdVector< size_t > indices( numElements ); for( size_t i = 0; i < indices.size(); ++i ) { indices[i] = i; // Initialize indices diff --git a/src/coreComponents/mesh/generators/CellBlockManager.cpp b/src/coreComponents/mesh/generators/CellBlockManager.cpp index 7506e96b77e..0150b2f35bd 100644 --- a/src/coreComponents/mesh/generators/CellBlockManager.cpp +++ b/src/coreComponents/mesh/generators/CellBlockManager.cpp @@ -1022,7 +1022,7 @@ void CellBlockManager::generateHighOrderMaps( localIndex const order, nodeLocalToGlobalNew=nodeLocalToGlobalNew.toView(), numInternalNodesPerEdge, numNodesPerEdge, globalNodeOffset, glCoords, localNodeOffset, order]( localIndex const iter_edge ) { - std::unordered_map< std::array< localIndex, 6 >, localIndex, NodeKeyHasher< localIndex > > nodeIDs; + stdUnorderedMap< std::array< localIndex, 6 >, localIndex, NodeKeyHasher< localIndex > > nodeIDs; localIndex edgeHeadNode = edgeToNodesMapSource[ iter_edge ][ 0 ]; localIndex edgeEndNode = edgeToNodesMapSource[ iter_edge ][ 1 ]; globalIndex edgeHeadNodeG = nodeLocalToGlobalNew[ edgeHeadNode ]; @@ -1030,15 +1030,15 @@ void CellBlockManager::generateHighOrderMaps( localIndex const order, array1d< localIndex > const edgeToNodeMapWork( numNodesPerEdge ); edgeToNodeMapWork[ 0 ] = edgeHeadNode; edgeToNodeMapWork[ 1 ] = edgeEndNode; - nodeIDs[ createNodeKey( edgeHeadNode ) ] = 0; - nodeIDs[ createNodeKey( edgeEndNode ) ] = 1; + nodeIDs.get_inserted( createNodeKey( edgeHeadNode )) = 0; + nodeIDs.get_inserted( createNodeKey( edgeEndNode ) )= 1; for( localIndex iter_node = 0; iter_node < numInternalNodesPerEdge; iter_node++ ) { real64 alpha = ( glCoords[ iter_node ] + 1.0 ) / 2.0; localIndex nodeLocalID = localNodeOffset + iter_edge * ( numInternalNodesPerEdge ) + iter_node; edgeToNodeMapWork[ iter_node + 2 ] = nodeLocalID; - nodeIDs[ createNodeKey( edgeHeadNode, edgeEndNode, iter_node + 1, order ) ] = iter_node + 2; + nodeIDs.get_inserted( createNodeKey( edgeHeadNode, edgeEndNode, iter_node + 1, order ) ) = iter_node + 2; std::array< globalIndex, 6 > referenceOrientation = createNodeKey( edgeHeadNodeG, edgeEndNodeG, iter_node + 1, order ); int gq = referenceOrientation[4] - 1; nodeLocalToGlobalNew[ nodeLocalID ] = globalNodeOffset + edgeLocalToGlobal[ iter_edge ] * numInternalNodesPerEdge + gq; @@ -1048,7 +1048,7 @@ void CellBlockManager::generateHighOrderMaps( localIndex const order, // reorder map for( localIndex q = 0; q < numNodesPerEdge; q++ ) { - edgeToNodeMapNew[ iter_edge ][ q ] = edgeToNodeMapWork[ nodeIDs[ createNodeKey( edgeHeadNode, edgeEndNode, q, order ) ] ]; + edgeToNodeMapNew[ iter_edge ][ q ] = edgeToNodeMapWork[ nodeIDs.get_inserted( createNodeKey( edgeHeadNode, edgeEndNode, q, order ) ) ]; } } ); localNodeOffset += numInternalNodesPerEdge * numLocalEdges; @@ -1086,7 +1086,7 @@ void CellBlockManager::generateHighOrderMaps( localIndex const order, faceLocalToGlobal=faceLocalToGlobal.toView(), nodeLocalToGlobalNew=nodeLocalToGlobalNew.toView() ]( localIndex const iter_face ) { - std::unordered_map< std::array< localIndex, 6 >, localIndex, NodeKeyHasher< localIndex > > nodeIDs; + stdUnorderedMap< std::array< localIndex, 6 >, localIndex, NodeKeyHasher< localIndex > > nodeIDs; localIndex faceVertID[ numVerticesPerFace ]; globalIndex faceVertGID[ numVerticesPerFace ]; array1d< localIndex > const faceToNodeMapWork( numNodesPerFace ); @@ -1100,7 +1100,7 @@ void CellBlockManager::generateHighOrderMaps( localIndex const order, faceVertGID[ iter_node ] = nodeLocalToGlobalNew[ faceVertID[ iter_node ] ]; faceToNodeMapWork[ iter_node ] = faceVertID[ iter_node ]; // store location of nodes for later reordering - nodeIDs[ createNodeKey( faceVertID[ iter_node ] ) ] = iter_node; + nodeIDs.get_inserted( createNodeKey( faceVertID[ iter_node ] ) ) = iter_node; } for( localIndex iter_edge=0; iter_edge, localIndex, NodeKeyHasher< localIndex > > nodeIDs; + stdUnorderedMap< std::array< localIndex, 6 >, localIndex, NodeKeyHasher< localIndex > > nodeIDs; localIndex elemVertID[ numVerticesPerCell]; array1d< localIndex > const elemToNodeMapWork( numNodesPerCell ); for( localIndex iter_node=0; iter_node < numVerticesPerCell; iter_node++ ) { elemVertID[ iter_node ] = elemsToNodesSource[ iter_elem ][ iter_node ]; elemToNodeMapWork[ iter_node ] = elemVertID[ iter_node ]; - nodeIDs[ createNodeKey( elemVertID[ iter_node ] ) ] = iter_node; + nodeIDs.get_inserted( createNodeKey( elemVertID[ iter_node ] ) ) = iter_node; } for( localIndex iter_edge=0; iter_edge < numEdgesPerCell; iter_edge++ ) @@ -1206,7 +1206,7 @@ void CellBlockManager::generateHighOrderMaps( localIndex const order, localIndex nodeIdxInMap = numVerticesPerCell + iter_edge * numInternalNodesPerEdge + iter_node; localIndex edge = elemsToEdges[iter_elem][iter_edge]; elemToNodeMapWork[ nodeIdxInMap ] = edgeToNodeMapNew[ edge ][iter_node+1]; - nodeIDs[ createNodeKey( edgeToNodeMapNew[ edge ][ 0 ], edgeToNodeMapNew[ edge ][ numNodesPerEdge - 1 ], iter_node + 1, order ) ] = nodeIdxInMap; + nodeIDs.get_inserted( createNodeKey( edgeToNodeMapNew[ edge ][ 0 ], edgeToNodeMapNew[ edge ][ numNodesPerEdge - 1 ], iter_node + 1, order ) ) = nodeIdxInMap; } } for( localIndex iter_face=0; iter_face < numFacesPerCell; iter_face++ ) @@ -1218,8 +1218,8 @@ void CellBlockManager::generateHighOrderMaps( localIndex const order, localIndex nodeIdxInMap = numVerticesPerCell + numEdgesPerCell * numInternalNodesPerEdge + iter_face * numInternalNodesPerFace + iter_node; localIndex face = elemsToFaces[iter_elem][iter_face]; elemToNodeMapWork[ nodeIdxInMap ] = faceToNodeMapNew[face][(q2 + 1) * numNodesPerEdge + (q1 + 1 )]; - nodeIDs[ createNodeKey( faceToNodeMapNew[ face ][ 0 ], faceToNodeMapNew[ face ][ numNodesPerEdge - 1 ], - faceToNodeMapNew[ face ][ numNodesPerFace - numNodesPerEdge ], faceToNodeMapNew[ face ][ numNodesPerFace- 1 ], q1 + 1, q2 + 1, order ) ] = nodeIdxInMap; + nodeIDs.get_inserted( createNodeKey( faceToNodeMapNew[ face ][ 0 ], faceToNodeMapNew[ face ][ numNodesPerEdge - 1 ], + faceToNodeMapNew[ face ][ numNodesPerFace - numNodesPerEdge ], faceToNodeMapNew[ face ][ numNodesPerFace- 1 ], q1 + 1, q2 + 1, order ) ) = nodeIdxInMap; } } for( localIndex iter_node=0; iter_node < numInternalNodesPerCell; iter_node++ ) @@ -1246,7 +1246,7 @@ void CellBlockManager::generateHighOrderMaps( localIndex const order, if( q1 == 0 || q1 == numNodesPerEdge - 1 || q2 == 0 || q2 == numNodesPerEdge - 1 || q3 == 0 || q3 == numNodesPerEdge - 1 ) { elemsToNodesNew[ iter_elem ][ q ] = elemToNodeMapWork[ - nodeIDs[ createNodeKey( elemVertID, q1, q2, q3, order ) ] ]; + nodeIDs.get_inserted( createNodeKey( elemVertID, q1, q2, q3, order ) ) ]; } } } ); diff --git a/src/coreComponents/mesh/generators/MeshGeneratorBase.cpp b/src/coreComponents/mesh/generators/MeshGeneratorBase.cpp index 5cb6a6516dc..6f6516d7de0 100644 --- a/src/coreComponents/mesh/generators/MeshGeneratorBase.cpp +++ b/src/coreComponents/mesh/generators/MeshGeneratorBase.cpp @@ -147,7 +147,7 @@ integer computeEulerCharacteristic( NodeManager const & nodeManager, // counted exactly once. using EdgeKey = std::pair< globalIndex, globalIndex >; - using FaceKey = std::vector< globalIndex >; + using FaceKey = stdVector< globalIndex >; arrayView1d< globalIndex const > const localToGlobal = nodeManager.localToGlobalMap(); arrayView1d< integer const > const nodeGhostRank = nodeManager.ghostRank(); @@ -185,7 +185,7 @@ integer computeEulerCharacteristic( NodeManager const & nodeManager, ++numOwnedCells; localIndex const npe = elemToNodeMap.size( 1 ); - std::vector< globalIndex > gn( npe ); + stdVector< globalIndex > gn( npe ); for( localIndex ni = 0; ni < npe; ++ni ) { gn[ni] = localToGlobal[ elemToNodeMap[ei][ni] ]; diff --git a/src/coreComponents/mesh/generators/VTKFaceBlockUtilities.cpp b/src/coreComponents/mesh/generators/VTKFaceBlockUtilities.cpp index 21f0d17fafe..2dd962a156f 100644 --- a/src/coreComponents/mesh/generators/VTKFaceBlockUtilities.cpp +++ b/src/coreComponents/mesh/generators/VTKFaceBlockUtilities.cpp @@ -239,14 +239,14 @@ ArrayOfArrays< localIndex > buildFace2dToElems2d( vtkPolyData * edges, { // Each edge is first associated to an hash and to an id. // Then we loop over all the edges of each cell and compute its hash to recover the associated id. - std::unordered_map< std::pair< vtkIdType, vtkIdType >, int, pairHashComputer > face2dIds; + stdUnorderedMap< std::pair< vtkIdType, vtkIdType >, int, pairHashComputer > face2dIds; for( int i = 0; i < edges->GetNumberOfCells(); ++i ) { vtkCell * c = edges->GetCell( i ); vtkIdList * edgePointIds = c->GetPointIds(); GEOS_ASSERT( edgePointIds->GetNumberOfIds() == 2 ); std::pair< vtkIdType, vtkIdType > const minMax = std::minmax( edgePointIds->GetId( 0 ), edgePointIds->GetId( 1 ) ); - face2dIds[minMax] = i; + face2dIds.get_inserted( minMax ) = i; } ArrayOfArrays< localIndex > face2dToElems2d( LvArray::integerConversion< localIndex >( edges->GetNumberOfCells() ) ); diff --git a/src/coreComponents/mesh/generators/VTKUtilities.cpp b/src/coreComponents/mesh/generators/VTKUtilities.cpp index 78f6b905404..2bf0d4f02e5 100644 --- a/src/coreComponents/mesh/generators/VTKUtilities.cpp +++ b/src/coreComponents/mesh/generators/VTKUtilities.cpp @@ -1459,7 +1459,7 @@ stdVector< vtkIdType > findMatchingCellsForFractureElement( } // Build map: candidate cellId -> set of its nodes that match fracture's collocated nodes - std::unordered_map< vtkIdType, std::unordered_set< vtkIdType > > cellToMatchedNodes; + stdUnorderedMap< vtkIdType, std::unordered_set< vtkIdType > > cellToMatchedNodes; cellToMatchedNodes.reserve( fractureCollocatedNodes.size() ); for( vtkIdType const & collocatedNode : fractureCollocatedNodes ) @@ -1469,7 +1469,7 @@ stdVector< vtkIdType > findMatchingCellsForFractureElement( { for( vtkIdType const & cellId : it->second ) { - cellToMatchedNodes[cellId].insert( collocatedNode ); + cellToMatchedNodes.get_inserted( cellId ).insert( collocatedNode ); } } } @@ -2560,11 +2560,11 @@ splitCellsByTypeAndAttribute( stdMap< ElementType, stdVector< vtkIdType > > & ty { using ArrayType = TYPEOFPTR( attributeArray ); vtkDataArrayAccessor< ArrayType > attribute( attributeArray ); - std::unordered_map< int, size_t > cellCounts; + stdUnorderedMap< int, size_t > cellCounts; for( vtkIdType c: cells ) { int const region = static_cast< int >( attribute.Get( c, 0 ) ); - ++cellCounts[region]; + ++cellCounts.get_inserted( region ); } for( auto const & count : cellCounts ) { @@ -2757,10 +2757,10 @@ stdVector< localIndex > getWedgeNodeOrderingFromPolyhedron( vtkCell * const cell stdVector< localIndex > nodeOrder( 6 ); // Generate global to local map - std::unordered_map< localIndex, localIndex > G2L; + stdUnorderedMap< localIndex, localIndex > G2L; for( localIndex iPoint = 0; iPoint < 6; ++iPoint ) { - G2L[cell->GetPointId( iPoint )] = iPoint; + G2L.get_inserted( cell->GetPointId( iPoint )) = iPoint; } // Assuming the input parameters are correct, identify one of the triangles @@ -2852,10 +2852,10 @@ stdVector< localIndex > getPyramidNodeOrderingFromPolyhedron( vtkCell * const ce stdVector< localIndex > nodeOrder( 5 ); // Generate global to local map - std::unordered_map< localIndex, localIndex > G2L; + stdUnorderedMap< localIndex, localIndex > G2L; for( iPoint = 0; iPoint < 5; ++iPoint ) { - G2L[cell->GetPointId( iPoint )] = iPoint; + G2L.get_inserted( cell->GetPointId( iPoint )) = iPoint; } // Assuming the input parameters are correct, identify the base @@ -2926,10 +2926,10 @@ stdVector< localIndex > getPrismNodeOrderingFromPolyhedron( vtkCell * const cell stdVector< localIndex > nodeOrder( 2*NUM_SIDES ); // Generate global to local map - std::unordered_map< localIndex, localIndex > G2L; + stdUnorderedMap< localIndex, localIndex > G2L; for( localIndex iPoint = 0; iPoint < cell->GetNumberOfPoints(); ++iPoint ) { - G2L[cell->GetPointId( iPoint )] = iPoint; + G2L.get_inserted( cell->GetPointId( iPoint )) = iPoint; } // Assuming the input parameters are correct, identify one of the bases @@ -3575,7 +3575,7 @@ void writeCells( integer const logLevel, { continue; } - std::unordered_map< int, stdVector< vtkIdType > > const & regionIdToCellIds = typeRegions.second; + stdUnorderedMap< int, stdVector< vtkIdType > > const & regionIdToCellIds = typeRegions.second; for( auto const & regionCells : regionIdToCellIds ) { int const regionId = regionCells.first; diff --git a/src/coreComponents/mesh/mpiCommunications/CommunicationTools.cpp b/src/coreComponents/mesh/mpiCommunications/CommunicationTools.cpp index b09718c2381..8614dbd0af4 100644 --- a/src/coreComponents/mesh/mpiCommunications/CommunicationTools.cpp +++ b/src/coreComponents/mesh/mpiCommunications/CommunicationTools.cpp @@ -708,7 +708,7 @@ void fixReceiveLists( ObjectManagerBase & objectManager, stdVector< localIndex > ghostsToFix; /// Map from owning MPI rank to an array of local objects we need to fix. - std::unordered_map< int, stdVector< localIndex > > ghostsBySecondNeighbor; + stdUnorderedMap< int, stdVector< localIndex > > ghostsBySecondNeighbor; arrayView1d< integer > const & ghostRank = objectManager.ghostRank(); @@ -716,7 +716,7 @@ void fixReceiveLists( ObjectManagerBase & objectManager, for( std::pair< globalIndex, int > const & pair : ghostsFromSecondNeighbor ) { localIndex const lid = objectManager.globalToLocalMap( pair.first ); - ghostsBySecondNeighbor[ pair.second ].emplace_back( lid ); + ghostsBySecondNeighbor.get_inserted( pair.second ).emplace_back( lid ); ghostsToFix.emplace_back( lid ); ghostRank[ lid ] = pair.second; } diff --git a/src/coreComponents/mesh/mpiCommunications/SpatialPartition.cpp b/src/coreComponents/mesh/mpiCommunications/SpatialPartition.cpp index 9d2f229f026..b4144750e23 100644 --- a/src/coreComponents/mesh/mpiCommunications/SpatialPartition.cpp +++ b/src/coreComponents/mesh/mpiCommunications/SpatialPartition.cpp @@ -123,19 +123,19 @@ int SpatialPartition::getColor( std::set< int > const & fullNeighbors ) // 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 ); + stdVector< 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 ); + stdVector< 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 ); + stdVector< int > localNeighborVec( m_metisNeighborList.begin(), m_metisNeighborList.end() ); + stdVector< int > allNeighbors( totalNeighbors ); MpiWrapper::allgatherv( localNeighborVec.data(), localNeighborCount, allNeighbors.data(), allNeighborCounts.data(), displacements.data(), MPI_COMM_GEOS ); diff --git a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseReactiveTransport.cpp b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseReactiveTransport.cpp index 7c2643a52b2..b5c850662d3 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseReactiveTransport.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseReactiveTransport.cpp @@ -894,7 +894,7 @@ void SinglePhaseReactiveTransport::applySourceFluxBC( real64 const time_n, fsManager.forSubGroups< SourceFluxBoundaryCondition >( [&] ( SourceFluxBoundaryCondition const & bc ) { // collect all the bc names to idx - bcNameToBcId[bc.getName()] = bcCounter; + bcNameToBcId.get_inserted( bc.getName()) = bcCounter; bcCounter++; } ); @@ -1384,7 +1384,7 @@ void SinglePhaseReactiveTransport::applySystemSolution( DofManager const & dofMa MeshLevel & mesh, string_array const & regionNames ) { - std::vector< string > fields{ fields::flow::pressure::key() }; + stdVector< string > fields{ fields::flow::pressure::key() }; if( m_isThermal ) { diff --git a/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsMPM.cpp b/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsMPM.cpp index 03b29dca757..bf1814610e5 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsMPM.cpp +++ b/src/coreComponents/physicsSolvers/solidMechanics/SolidMechanicsMPM.cpp @@ -2009,7 +2009,7 @@ real64 SolidMechanicsMPM::computeNeighborList( ParticleManager & particleManager // Declare bin key and bins data structure BinKey binKey; - std::unordered_map< BinKey, stdVector< localIndex >, BinKeyHash > bins; + stdUnorderedMap< BinKey, stdVector< localIndex >, BinKeyHash > bins; // Reverse entries in bins based on even distribution of particles in partition - OPTIONAL particleManager.forParticleRegions< ParticleRegion >( [&]( ParticleRegion & region ) // idk why this requires a template argument and the @@ -2029,7 +2029,7 @@ real64 SolidMechanicsMPM::computeNeighborList( ParticleManager & particleManager for( int k=0; k) as a parameter. When the +// string_array const & (= stdVector) as a parameter. When the // lambda body also contains device kernel launches, nvcc erroneously tries to -// generate a device-compatible destructor for std::vector even +// generate a device-compatible destructor for stdVector even // though it is a reference parameter whose lifetime is not managed by the lambda. GEOS_NV_HOST_DEVICE_DIAG_SUPPRESS diff --git a/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp b/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp index 0735262ad09..229d409edea 100644 --- a/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp +++ b/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp @@ -4420,25 +4420,25 @@ stdVector< std::set< localIndex > > SurfaceGenerator::groupRupturedFacesIntoSets } // 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 + // stdMap 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; + stdMap< localIndex, localIndex > parent; + stdMap< localIndex, localIndex > rank; for( localIndex const fi : allFaces ) { - parent[fi] = fi; - rank[fi] = 0; + parent.get_inserted( fi ) = fi; + rank.get_inserted( fi ) = 0; } // Find with path compression. std::function< localIndex( localIndex ) > findRoot = [&]( localIndex x ) -> localIndex { - if( parent[x] != x ) + if( parent.at( x ) != x ) { - parent[x] = findRoot( parent[x] ); + parent.get_inserted( x ) = findRoot( parent.at( x ) ); } - return parent[x]; + return parent.at( x ); }; // Union by rank. @@ -4448,11 +4448,11 @@ stdVector< std::set< localIndex > > SurfaceGenerator::groupRupturedFacesIntoSets localIndex rb = findRoot( b ); if( ra == rb ) return; - if( rank[ra] < rank[rb] ) + if( rank.at( ra ) < rank.at( rb ) ) std::swap( ra, rb ); - parent[rb] = ra; - if( rank[ra] == rank[rb] ) - ++rank[ra]; + parent.get_inserted( rb ) = ra; + if( rank.at( ra ) == rank.at( rb ) ) + ++rank.get_inserted( ra ); }; // Two ruptured faces sharing a node belong to the same fracture set. @@ -4474,12 +4474,12 @@ stdVector< std::set< localIndex > > SurfaceGenerator::groupRupturedFacesIntoSets } // Gather connected components. - // std::map guarantees deterministic iteration order (by sorted key), + // stdMap 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; + stdMap< localIndex, std::set< localIndex > > components; for( localIndex const fi : allFaces ) { - components[findRoot( fi )].insert( fi ); + components.get_inserted( findRoot( fi )).insert( fi ); } // Convert to a vector. From 85d0453fc8053c23b7fab42a25d5c810c44ee837 Mon Sep 17 00:00:00 2001 From: kdrienCG Date: Tue, 2 Jun 2026 12:01:21 +0200 Subject: [PATCH 50/53] move StackTrace dependencies - remove dependency to cpptrace in StackTrace header - move stacktrace dispatch logic from main to StackTraceParams - move stacktrace decoding from ErrorHandling to StackTrace --- src/coreComponents/common/CMakeLists.txt | 1 + .../common/initializeEnvironment.cpp | 6 +- .../common/logger/ErrorHandling.cpp | 30 +----- .../common/logger/ErrorHandling.hpp | 3 +- .../common/logger/StackTrace.cpp | 93 ++++++++++++++++--- .../common/logger/StackTrace.hpp | 42 +++++---- .../common/logger/StackTraceParams.hpp | 60 ++++++++++++ .../unitTests/testErrorHandling.cpp | 2 +- src/main/main.cpp | 37 +++----- 9 files changed, 185 insertions(+), 89 deletions(-) create mode 100644 src/coreComponents/common/logger/StackTraceParams.hpp diff --git a/src/coreComponents/common/CMakeLists.txt b/src/coreComponents/common/CMakeLists.txt index 9dbfd6081f1..8bd23cd2421 100644 --- a/src/coreComponents/common/CMakeLists.txt +++ b/src/coreComponents/common/CMakeLists.txt @@ -44,6 +44,7 @@ set( common_headers logger/ErrorHandling.hpp logger/ExternalErrorHandler.hpp logger/StackTrace.hpp + logger/StackTraceParams.hpp MpiWrapper.hpp Path.hpp Span.hpp diff --git a/src/coreComponents/common/initializeEnvironment.cpp b/src/coreComponents/common/initializeEnvironment.cpp index 89d071ef26c..83e9747e468 100644 --- a/src/coreComponents/common/initializeEnvironment.cpp +++ b/src/coreComponents/common/initializeEnvironment.cpp @@ -87,12 +87,11 @@ void setupLogger() } else { - std::string const stackHistory = StackTrace::stackTrace(); DiagnosticMsg diagnosticMsg; ErrorLogger::global().flushErrorMsg( DiagnosticMsgBuilder::init( diagnosticMsg, MsgType::Error, errorMsg, ::geos::logger::internal::g_rank ) - .addCallStackInfo( stackHistory ) + .addCallStackInfo( StackTrace::stackTrace() ) .addDetectionLocation( detectionLocation ) .getDiagnosticMsg() ); @@ -110,13 +109,12 @@ void setupLogger() ExternalErrorHandler::instance().flush( "before signal error output" ); // error message output - std::string const stackHistory = StackTrace::signalSafeStackTrace(); DiagnosticMsg diagnosticMsg; ErrorLogger::global().flushErrorMsg( DiagnosticMsgBuilder::init( diagnosticMsg, MsgType::ExternalError, "", ::geos::logger::internal::g_rank ) .addSignal( signal ) - .addCallStackInfo( stackHistory ) + .addCallStackInfo( StackTrace::stackTrace() ) .getDiagnosticMsg() ); // call program termination diff --git a/src/coreComponents/common/logger/ErrorHandling.cpp b/src/coreComponents/common/logger/ErrorHandling.cpp index a21a7348bb4..b115aa09edb 100644 --- a/src/coreComponents/common/logger/ErrorHandling.cpp +++ b/src/coreComponents/common/logger/ErrorHandling.cpp @@ -204,34 +204,10 @@ DiagnosticMsgBuilder & DiagnosticMsgBuilder::addRank( integer const rank ) return *this; } -DiagnosticMsgBuilder & DiagnosticMsgBuilder::addCallStackInfo( std::string_view ossStackTrace ) +DiagnosticMsgBuilder & DiagnosticMsgBuilder::addCallStackInfo( StackTrace && stacktrace ) { - m_errorMsg.m_sourceCallStack.clear(); - m_errorMsg.m_isValidStackTrace = false; - - std::string str = std::string( ossStackTrace ); - std::istringstream iss( str ); - std::string stackLine; - - std::regex lvArrayPattern( R"(Frame \d+:\s*)" ); - std::regex cpptracePattern( R"(^\s*#\d+\s+)" ); - - while( std::getline( iss, stackLine ) ) - { - std::smatch m; - if( std::regex_search( stackLine, m, lvArrayPattern ) || - std::regex_search( stackLine, m, cpptracePattern ) ) - { - m_errorMsg.m_isValidStackTrace = true; - m_errorMsg.m_sourceCallStack.push_back( m.suffix().str() ); - } - } - - if( !m_errorMsg.m_isValidStackTrace ) - { - m_errorMsg.m_sourceCallStack.push_back( str ); - } - + m_errorMsg.m_isValidStackTrace = stacktrace.isValidStackTrace(); + m_errorMsg.m_sourceCallStack = std::move( stacktrace ).frames(); return *this; } diff --git a/src/coreComponents/common/logger/ErrorHandling.hpp b/src/coreComponents/common/logger/ErrorHandling.hpp index 38df2a2566c..6f2fc6533c8 100644 --- a/src/coreComponents/common/logger/ErrorHandling.hpp +++ b/src/coreComponents/common/logger/ErrorHandling.hpp @@ -23,6 +23,7 @@ #include "common/DataTypes.hpp" #include "common/format/Format.hpp" #include "common/format/StringUtilities.hpp" +#include "common/logger/StackTrace.hpp" #include namespace geos @@ -252,7 +253,7 @@ class DiagnosticMsgBuilder * @param stacktrace stack trace information to add * @return Reference to the current instance for method chaining. */ - DiagnosticMsgBuilder & addCallStackInfo( std::string_view stacktrace ); + DiagnosticMsgBuilder & addCallStackInfo( StackTrace && stacktrace ); /** * @return Get the DiagnosticMsg diff --git a/src/coreComponents/common/logger/StackTrace.cpp b/src/coreComponents/common/logger/StackTrace.cpp index 5c9e5d80b69..f834fcc0e6d 100644 --- a/src/coreComponents/common/logger/StackTrace.cpp +++ b/src/coreComponents/common/logger/StackTrace.cpp @@ -18,31 +18,50 @@ */ #include "StackTrace.hpp" +#include "StackTraceParams.hpp" #include "LvArray/src/system.hpp" -#include "common/GeosxConfig.hpp" #ifdef GEOS_USE_CPPTRACE #include -#include #include #endif +#include +#include + namespace geos { -std::string StackTrace::stackTrace() +/** + * @brief Collect the given stack trace into frames. + * @param[in] trace The unified trace + * @param[inout] frames Container for the collected frames + * @param[inout] isValidStackTrace Result of whether the given trace is a valid trace + */ +void collectLvArrayTrace( std::string const & trace, + std::vector< std::string > & frames, + bool & isValidStackTrace ) { -#ifdef GEOS_USE_CPPTRACE - return formatStackTrace( cpptrace::generate_trace( /* skip = */ 1 ) ); -#else - return LvArray::system::stackTrace( true ); -#endif -} + std::regex lvArrayPattern( R"(Frame \d+:\s*)" ); -std::string StackTrace::signalSafeStackTrace() -{ - return LvArray::system::stackTrace( true ); + std::istringstream iss( trace ); + std::string stackLine; + + while( std::getline( iss, stackLine ) ) + { + std::smatch m; + if( std::regex_search( stackLine, m, lvArrayPattern ) ) + { + isValidStackTrace = true; + frames.push_back( m.suffix().str() ); + } + } + + if( !isValidStackTrace ) + { + frames.push_back( trace ); + } } #ifdef GEOS_USE_CPPTRACE @@ -85,11 +104,57 @@ static cpptrace::formatter const & formatter() return fmt; } -std::string StackTrace::formatStackTrace( cpptrace::stacktrace const & stacktrace ) +/** + * @brief Collect the given stack trace into frames. + * @param[in] trace The unified trace + * @param[inout] frames Container for the collected frames + * @param[inout] isValidStackTrace Result of whether the given trace is a valid trace + */ +void collectCpptraceTrace( cpptrace::stacktrace const & trace, + std::vector< std::string > & frames, + bool & isValidStackTrace ) +{ + std::string const formatted = formatter().format( trace ); + std::regex cpptracePattern( R"(^\s*#\d+\s+)" ); + + std::istringstream iss( formatted ); + std::string stackLine; + + while( std::getline( iss, stackLine ) ) + { + std::smatch m; + if( std::regex_search( stackLine, m, cpptracePattern ) ) + { + isValidStackTrace = true; + frames.push_back( m.suffix().str() ); + } + } + + if( !isValidStackTrace ) + { + frames.push_back( formatted ); + } +} +#endif + + +StackTrace::StackTrace( StackTraceParams const & params ) { - return formatter().format( stacktrace ); +#ifdef GEOS_USE_CPPTRACE + collectCpptraceTrace( params.trace, m_frames, m_isValidStackTrace ); +#else + collectLvArrayTrace( params.trace, m_frames, m_isValidStackTrace ); +#endif } + +StackTrace StackTrace::stackTrace() +{ +#ifdef GEOS_USE_CPPTRACE + return StackTrace( StackTraceParams{ cpptrace::generate_trace( /* skip = */ 1 ) } ); +#else + return StackTrace( LvArray::system::stackTrace( true ) ); #endif +} } /* namespace geos */ diff --git a/src/coreComponents/common/logger/StackTrace.hpp b/src/coreComponents/common/logger/StackTrace.hpp index 5162d9584fe..d32afdd7ac1 100644 --- a/src/coreComponents/common/logger/StackTrace.hpp +++ b/src/coreComponents/common/logger/StackTrace.hpp @@ -20,16 +20,14 @@ #ifndef GEOS_COMMON_LOGGER_STACKTRACE_HPP #define GEOS_COMMON_LOGGER_STACKTRACE_HPP -#include "common/GeosxConfig.hpp" // For the following guards -#ifdef GEOS_USE_CPPTRACE -#include -#endif - #include +#include namespace geos { +struct StackTraceParams; + /** * @brief Utility class to interact with stack traces. */ @@ -38,27 +36,33 @@ class StackTrace public: /** - * @brief Get a stack trace for the current thread. - * @return The stack trace as a string. - * @note Not signal-safe. Use signalSafeStackTrace() from inside a signal handler. + * @brief StackTrace constructor + * @param params StackTraceParams class containing the type of stacktrace used, + * based on the build. */ - static std::string stackTrace(); + StackTrace( StackTraceParams const & params ); /** - * @brief Get a stack trace from a context where signal-safety is required. - * @return The stack trace as a string. - * @note Implementation reverts back to LvArray::system stack trace for signal-safety + * @brief Get a stack trace for the current thread. + * @return The stack trace object containing the stack trace frames. */ - static std::string signalSafeStackTrace(); + static StackTrace stackTrace(); -#ifdef GEOS_USE_CPPTRACE /** - * @brief Format a cpptrace stacktrace using the configured formatter. - * @param stacktrace The cpptrace stack trace to format. - * @return Formatted stack trace string. + * @brief Stack trace frames accessor. + * @return Container of frames from this stack trace. */ - static std::string formatStackTrace( cpptrace::stacktrace const & stacktrace ); -#endif + std::vector< std::string > const & frames() const + { return m_frames; } + + bool isValidStackTrace() const + { return m_isValidStackTrace; } + +private: + + std::vector< std::string > m_frames; + + bool m_isValidStackTrace = false; }; diff --git a/src/coreComponents/common/logger/StackTraceParams.hpp b/src/coreComponents/common/logger/StackTraceParams.hpp new file mode 100644 index 00000000000..5df437c8a08 --- /dev/null +++ b/src/coreComponents/common/logger/StackTraceParams.hpp @@ -0,0 +1,60 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 StackTraceData.hpp + */ + +#ifndef GEOS_COMMON_LOGGER_STACKTRACEPARAMS_HPP +#define GEOS_COMMON_LOGGER_STACKTRACEPARAMS_HPP + +#include "common/GeosxConfig.hpp" +#ifdef GEOS_USE_CPPTRACE +#include +#include +#endif + +#include + +namespace geos +{ + +#ifdef GEOS_USE_CPPTRACE +using StackTraceType = cpptrace::stacktrace; +#else // fallback to LvArray stacktrace +using StackTraceType = std::string +#endif + + +/** + * @struct StackTraceParams + * @brief Dispatch struct to store the stacktrace type used by the current build. + */ +struct StackTraceParams +{ + StackTraceType trace; +}; + + +#ifdef GEOS_USE_CPPTRACE +#define GEOS_STACKTRACE_PARAMETERS StackTraceParams{ cpptrace::from_current_exception() } +#else +#define GEOS_STACKTRACE_PARAMETERS StackTraceParams{ LvArray::system::stackTrace( true ) } +#endif + + +} /* namespace geos */ + +#endif /* GEOS_COMMON_LOGGER_STACKTRACEPARAMS_HPP */ diff --git a/src/coreComponents/dataRepository/unitTests/testErrorHandling.cpp b/src/coreComponents/dataRepository/unitTests/testErrorHandling.cpp index 84098904ac6..06309f48a8d 100644 --- a/src/coreComponents/dataRepository/unitTests/testErrorHandling.cpp +++ b/src/coreComponents/dataRepository/unitTests/testErrorHandling.cpp @@ -349,7 +349,7 @@ TEST( ErrorHandling, testStdException ) testErrorLogger.initCurrentExceptionMessage( MsgType::Exception, e.what(), ::geos::logger::internal::g_rank ) - .addCallStackInfo( LvArray::system::stackTrace( true ) ); + .addCallStackInfo( StackTrace::stackTrace() ); std::ostringstream oss; ErrorLogger::formatMsgForLog( testErrorLogger.getCurrentExceptionMsg(), oss ); diff --git a/src/main/main.cpp b/src/main/main.cpp index 1d9ad3657ba..c6c1eb09252 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -17,6 +17,7 @@ #include "common/logger/ErrorHandling.hpp" #include "common/logger/Logger.hpp" #include "common/logger/StackTrace.hpp" +#include "common/logger/StackTraceParams.hpp" #include "common/GeosxConfig.hpp" #include "common/MemoryInfos.hpp" #include "common/TimingMacros.hpp" @@ -25,9 +26,6 @@ #include "mainInterface/ProblemManager.hpp" #include "mainInterface/GeosxState.hpp" #include "mainInterface/version.hpp" -#ifdef GEOS_USE_CPPTRACE -#include -#endif using namespace geos; @@ -81,56 +79,49 @@ int main( int argc, char *argv[] ) basicCleanup( false ); }; - auto onGeosException = [&]( geos::Exception & ) + auto onGeosException = [&]( geos::Exception &, StackTrace stacktrace ) { // GEOS generated exceptions management -#ifdef GEOS_USE_CPPTRACE - std::string const stacktrace = StackTrace::formatStackTrace( cpptrace::from_current_exception() ); -#else - std::string const stacktrace = LvArray::system::stackTrace( true ); -#endif - if( !stacktrace.empty() ) + if( !stacktrace.frames().empty() ) { - ErrorLogger::global().modifyCurrentExceptionMessage().addCallStackInfo( stacktrace ); + ErrorLogger::global().modifyCurrentExceptionMessage().addCallStackInfo( std::move( stacktrace ) ); } ErrorLogger::global().flushCurrentExceptionMessage(); basicCleanup( true ); LvArray::system::callErrorHandler(); }; - auto onStdException = [&]( std::exception const & e ) + auto onStdException = [&]( std::exception const & e, StackTrace stacktrace ) { // native exceptions management -#ifdef GEOS_USE_CPPTRACE - std::string const stacktrace = StackTrace::formatStackTrace( cpptrace::from_current_exception() ); -#else - std::string const stacktrace = LvArray::system::stackTrace( true ); -#endif ErrorLogger::global().flushErrorMsg( ErrorLogger::global().initCurrentExceptionMessage( MsgType::Exception, e.what(), ::geos::logger::internal::g_rank ) - .addCallStackInfo( stacktrace ) + .addCallStackInfo( std::move( stacktrace ) ) .getDiagnosticMsg()); basicCleanup( true ); LvArray::system::callErrorHandler(); }; #ifdef GEOS_USE_CPPTRACE - cpptrace::try_catch( runMain, onNotAnError, onGeosException, onStdException ); + cpptrace::try_catch( runMain, + onNotAnError, + [&]( geos::Exception & e ) { onGeosException( e, StackTrace( GEOS_STACKTRACE_PARAMETERS ) ); }, + [&]( std::exception const & e ) { onStdException( e, StackTrace( GEOS_STACKTRACE_PARAMETERS ) ); } ); #else try { runMain(); } - catch( NotAnError const & ) + catch( NotAnError const & e ) { onNotAnError(); } - catch( geos::Exception & ) + catch( geos::Exception & e ) { - onGeosException(); + onGeosException( e, StackTrace( GEOS_STACKTRACE_PARAMETERS ) ); } catch( std::exception const & e ) { - onStdException( e ); + onStdException( e, StackTrace( GEOS_STACKTRACE_PARAMETERS ) ); } #endif From f779513de87a803dc4d602a9801c82faac47ca6b Mon Sep 17 00:00:00 2001 From: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> Date: Tue, 2 Jun 2026 08:44:16 -0500 Subject: [PATCH 51/53] Refactor compositional multiphase fluid in preparation for thermal models (#4058) This PR refactors the compositional multiphase fluid framework, replacing hardcoded 2/3-phase templates with variadic templates (typename... PHASES) to support an arbitrary number of fluid phases. This provides the foundational architecture needed for thermal compositional models. --- .../fluid/multifluid/MultiFluidBase.hpp | 25 +- .../CompositionalMultiphaseFluid.cpp | 125 +++++----- .../CompositionalMultiphaseFluid.hpp | 75 +++--- .../CompositionalMultiphaseFluidUpdates.hpp | 227 ++++++++++-------- .../compositional/models/PhaseModel.hpp | 8 +- 5 files changed, 246 insertions(+), 214 deletions(-) diff --git a/src/coreComponents/constitutive/fluid/multifluid/MultiFluidBase.hpp b/src/coreComponents/constitutive/fluid/multifluid/MultiFluidBase.hpp index 58f3b16abea..ad85efc114b 100644 --- a/src/coreComponents/constitutive/fluid/multifluid/MultiFluidBase.hpp +++ b/src/coreComponents/constitutive/fluid/multifluid/MultiFluidBase.hpp @@ -1020,27 +1020,16 @@ MultiFluidBase::KernelWrapper:: integer const numPhase = numPhases(); integer const numComp = numComponents(); - StackArray< real64, 4, maxNumDof *maxNumPhase, LAYOUT_PHASE_DC > dPhaseFrac( 1, 1, numPhase, numComp+2 ); - MultiFluidVarSlice< real64, 1, USD_PHASE - 2, USD_PHASE_DC - 2 > - phaseFracAndDeriv { phaseFrac, dPhaseFrac[0][0] }; - - StackArray< real64, 4, maxNumDof *maxNumPhase, LAYOUT_PHASE_DC > dPhaseMassDens( 1, 1, numPhase, numComp+2 ); - MultiFluidVarSlice< real64, 1, USD_PHASE - 2, USD_PHASE_DC - 2 > - phaseMassDensAndDeriv { phaseMassDens, dPhaseMassDens[0][0] }; + // Space for dummy derivatives + StackArray< real64, 4, 2*maxNumDof *maxNumPhase, LAYOUT_PHASE_DC > derivatives( 2, 1, numPhase, numComp+2 ); - StackArray< real64, 4, maxNumDof *maxNumPhase, LAYOUT_PHASE_DC > dPhaseEnthalpy( 1, 1, numPhase, numComp+2 ); - MultiFluidVarSlice< real64, 1, USD_PHASE - 2, USD_PHASE_DC - 2 > - phaseEnthalpyAndDeriv { phaseEnthalpy, dPhaseEnthalpy[0][0] }; - - StackArray< real64, 4, maxNumDof *maxNumPhase, LAYOUT_PHASE_DC > dPhaseInternalEnergy( 1, 1, numPhase, numComp+2 ); - MultiFluidVarSlice< real64, 1, USD_PHASE - 2, USD_PHASE_DC - 2 > - phaseInternalEnergyAndDeriv { phaseInternalEnergy, dPhaseInternalEnergy[0][0] }; + using SliceType = MultiFluidVarSlice< real64, 1, USD_PHASE - 2, USD_PHASE_DC - 2 >; computeInternalEnergy( pressure, - phaseFracAndDeriv, - phaseMassDensAndDeriv, - phaseEnthalpyAndDeriv, - phaseInternalEnergyAndDeriv ); + SliceType { phaseFrac, derivatives[0][0] }, + SliceType { phaseMassDens, derivatives[0][0] }, + SliceType { phaseEnthalpy, derivatives[0][0] }, + SliceType { phaseInternalEnergy, derivatives[1][0] } ); } GEOS_HOST_DEVICE diff --git a/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluid.cpp b/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluid.cpp index 56c24735d27..d8ab70a4a8f 100644 --- a/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluid.cpp +++ b/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluid.cpp @@ -31,8 +31,8 @@ namespace geos namespace constitutive { -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > -CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >:: +template< typename FLASH, typename ... PHASES > +CompositionalMultiphaseFluid< FLASH, PHASES... >:: CompositionalMultiphaseFluid( string const & name, Group * const parent ) : MultiFluidBase( name, parent ), m_componentProperties( std::make_unique< compositional::ComponentProperties >( m_componentNames, m_componentMolarWeight ) ), @@ -76,8 +76,8 @@ CompositionalMultiphaseFluid( string const & name, Group * const parent ) .setRestartFlags( RestartFlags::NO_WRITE ); } -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > -integer CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::getWaterPhaseIndex() const +template< typename FLASH, typename ... PHASES > +integer CompositionalMultiphaseFluid< FLASH, PHASES... >::getWaterPhaseIndex() const { auto const phaseTypes = getPhaseTypes(); integer const aqueous = static_cast< integer >(compositional::PhaseType::AQUEOUS); @@ -91,16 +91,17 @@ integer CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::getWaterP return -1; } -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > -string CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::catalogName() +template< typename FLASH, typename ... PHASES > +string CompositionalMultiphaseFluid< FLASH, PHASES... >::catalogName() { - return GEOS_FMT( "Compositional{}Fluid{}", - FLASH::catalogName(), - PHASE1::Viscosity::catalogName() ); + // Use the first phase viscosity + using FirstPhase = typename camp::at< camp::list< PHASES... >, camp::num< 0 > >::type; + using ViscosityType = typename FirstPhase::Viscosity; + return GEOS_FMT( "Compositional{}Fluid{}", FLASH::catalogName(), ViscosityType::catalogName() ); } -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > -void CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::initializeState() const +template< typename FLASH, typename ... PHASES > +void CompositionalMultiphaseFluid< FLASH, PHASES... >::initializeState() const { // Zero k-Values to force re-initialisation m_kValues.zero(); @@ -108,8 +109,8 @@ void CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::initializeSt MultiFluidBase::initializeState(); } -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > -void CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::allocateConstitutiveData( Group & parent, localIndex const numPts ) +template< typename FLASH, typename ... PHASES > +void CompositionalMultiphaseFluid< FLASH, PHASES... >::allocateConstitutiveData( Group & parent, localIndex const numPts ) { m_kValues.resize( 0, numPts, numFluidPhases()-1, numFluidComponents() ); @@ -119,8 +120,8 @@ void CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::allocateCons m_kValues.zero(); } -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > -void CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::postInputInitialization() +template< typename FLASH, typename ... PHASES > +void CompositionalMultiphaseFluid< FLASH, PHASES... >::postInputInitialization() { MultiFluidBase::postInputInitialization(); @@ -200,8 +201,8 @@ void CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::postInputIni m_parameters->postInputInitialization( this, *m_componentProperties ); } -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > -void CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::initializePostSubGroups() +template< typename FLASH, typename ... PHASES > +void CompositionalMultiphaseFluid< FLASH, PHASES... >::initializePostSubGroups() { MultiFluidBase::initializePostSubGroups(); @@ -209,10 +210,10 @@ void CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::initializePo createModels(); } -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > +template< typename FLASH, typename ... PHASES > std::unique_ptr< ConstitutiveBase > -CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::deliverClone( string const & name, - Group * const parent ) const +CompositionalMultiphaseFluid< FLASH, PHASES... >::deliverClone( string const & name, + Group * const parent ) const { std::unique_ptr< ConstitutiveBase > clone = MultiFluidBase::deliverClone( name, parent ); CompositionalMultiphaseFluid & newFluid = dynamicCast< CompositionalMultiphaseFluid & >( *clone ); @@ -220,15 +221,21 @@ CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::deliverClone( str return clone; } -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > -typename CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::KernelWrapper -CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::createKernelWrapper() +template< typename FLASH, typename ... PHASES > +typename CompositionalMultiphaseFluid< FLASH, PHASES... >::KernelWrapper +CompositionalMultiphaseFluid< FLASH, PHASES... >::createKernelWrapper() +{ + return createKernelWrapper( std::index_sequence_for< PHASES... >{} ); +} + +template< typename FLASH, typename ... PHASES > +template< std::size_t... Is > +typename CompositionalMultiphaseFluid< FLASH, PHASES... >::KernelWrapper +CompositionalMultiphaseFluid< FLASH, PHASES... >::createKernelWrapper( std::index_sequence< Is... > ) { return KernelWrapper( *m_componentProperties, *m_flash, - *m_phase1, - *m_phase2, - *m_phase3, + *camp::get< Is >( m_phases )..., m_phaseOrder.toViewConst(), m_componentMolarWeight, m_useMass, @@ -244,8 +251,8 @@ CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::createKernelWrapp } // Create the fluid models -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > -void CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::createModels() +template< typename FLASH, typename ... PHASES > +void CompositionalMultiphaseFluid< FLASH, PHASES... >::createModels() { m_phaseType = getPhaseTypes(); @@ -258,24 +265,22 @@ void CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::createModels *m_parameters, m_phaseType.toViewConst() ); - m_phase1 = std::make_unique< PHASE1 >( GEOS_FMT( "{}_PhaseModel1", getName() ), - *m_componentProperties, - 0, - *m_parameters ); - - m_phase2 = std::make_unique< PHASE2 >( GEOS_FMT( "{}_PhaseModel2", getName() ), - *m_componentProperties, - 1, - *m_parameters ); + createPhaseModels( std::index_sequence_for< PHASES... >{} ); +} - m_phase3 = std::make_unique< PHASE3 >( GEOS_FMT( "{}_PhaseModel3", getName() ), - *m_componentProperties, - 2, - *m_parameters ); +template< typename FLASH, typename ... PHASES > +template< std::size_t... Is > +void CompositionalMultiphaseFluid< FLASH, PHASES... >::createPhaseModels( std::index_sequence< Is... > ) +{ + ((camp::get< Is >( m_phases ) = + std::make_unique< PHASES >( GEOS_FMT( "{}_PhaseModel{}", getName(), Is + 1 ), + *m_componentProperties, + Is, + *m_parameters )), ...); } -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > -array1d< integer > CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::getPhaseTypes() const +template< typename FLASH, typename ... PHASES > +array1d< integer > CompositionalMultiphaseFluid< FLASH, PHASES... >::getPhaseTypes() const { integer const numPhases = numFluidPhases(); array1d< integer > phaseTypes( numPhases ); @@ -287,44 +292,42 @@ array1d< integer > CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 > } // Create the fluid models -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > +template< typename FLASH, typename ... PHASES > std::unique_ptr< compositional::ModelParameters > -CompositionalMultiphaseFluid< FLASH, PHASE1, PHASE2, PHASE3 >::createModelParameters() +CompositionalMultiphaseFluid< FLASH, PHASES... >::createModelParameters() { std::unique_ptr< compositional::ModelParameters > parameters; parameters = FLASH::createParameters( std::move( parameters )); - parameters = PHASE1::createParameters( std::move( parameters )); - parameters = PHASE2::createParameters( std::move( parameters )); - parameters = PHASE3::createParameters( std::move( parameters )); + ((parameters = PHASES::createParameters( std::move( parameters ) )), ...); return parameters; } // Explicit instantiation of the model template. template class CompositionalMultiphaseFluid< compositional::NegativeTwoPhaseFlashModel, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::ConstantViscosity, compositional::NullModel >, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::ConstantViscosity, compositional::NullModel > >; + compositional::PhaseModel< compositional::CompositionalDensity, compositional::ConstantViscosity >, + compositional::PhaseModel< compositional::CompositionalDensity, compositional::ConstantViscosity > >; template class CompositionalMultiphaseFluid< compositional::NegativeTwoPhaseFlashModel, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel >, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel > >; + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity >, + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity > >; template class CompositionalMultiphaseFluid< compositional::NegativeTwoPhaseFlashModel, - compositional::PhaseModel< compositional::PhillipsBrineDensity, compositional::PhillipsBrineViscosity, compositional::NullModel >, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel > >; + compositional::PhaseModel< compositional::PhillipsBrineDensity, compositional::PhillipsBrineViscosity >, + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity > >; template class CompositionalMultiphaseFluid< compositional::ImmiscibleWaterFlashModel, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel >, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel >, - compositional::PhaseModel< compositional::ImmiscibleWaterDensity, compositional::ImmiscibleWaterViscosity, compositional::NullModel > >; + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity >, + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity >, + compositional::PhaseModel< compositional::ImmiscibleWaterDensity, compositional::ImmiscibleWaterViscosity > >; template class CompositionalMultiphaseFluid< compositional::KValueFlashModel< 2 >, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel >, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel > >; + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity >, + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity > >; template class CompositionalMultiphaseFluid< compositional::KValueFlashModel< 2 >, - compositional::PhaseModel< compositional::PhillipsBrineDensity, compositional::PhillipsBrineViscosity, compositional::NullModel >, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel > >; + compositional::PhaseModel< compositional::PhillipsBrineDensity, compositional::PhillipsBrineViscosity >, + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity > >; REGISTER_CATALOG_ENTRY( ConstitutiveBase, CompositionalTwoPhaseConstantViscosity, diff --git a/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluid.hpp b/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluid.hpp index a0fe1e26357..d116ad4ed73 100644 --- a/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluid.hpp +++ b/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluid.hpp @@ -43,23 +43,36 @@ namespace constitutive /** * @brief A general compositional fluid model. * @tparam FLASH Class describing the phase equilibrium model - * @tparam PHASE1 Class describing the phase property models for the first phase. - * @tparam PHASE2 Class describing the phase property models for the second phase. - * @tparam PHASE3 Class describing the phase property models for the possible third phase. + * @tparam PHASES Classes describing the phase property models for each phase. */ -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 = compositional::NullPhaseModel > +template< typename FLASH, typename ... PHASES > class CompositionalMultiphaseFluid : public MultiFluidBase { public: using FlashModel = FLASH; - using Phase1Model = PHASE1; - using Phase2Model = PHASE2; - using Phase3Model = PHASE3; // Get the number of phases - static constexpr integer NUM_PHASES = FlashModel::KernelWrapper::getNumberOfPhases(); - // Currently restrict to 2 or 3 phases - static_assert( NUM_PHASES == 2 || NUM_PHASES == 3 ); + static constexpr integer NUM_PHASES = static_cast< integer >(sizeof...(PHASES)); + + // Ensure that the number of phases matches the flash object + static_assert( NUM_PHASES == FlashModel::KernelWrapper::getNumberOfPhases(), + "Number of phases should match the flash" ); + + // Check if all phase models have a valid enthalpy model + static constexpr bool isThermalType() + { + return (!std::is_same_v< typename PHASES::Enthalpy, compositional::NullModel > && ...); + } + + // Check if all phase models do not provide an enthalpy model + static constexpr bool isIsoThermalType() + { + return (std::is_same_v< typename PHASES::Enthalpy, compositional::NullModel > && ...); + } + + // Either all phases are thermal or all are not + static_assert( ( isThermalType() || isIsoThermalType() ), + "All phase models must either use NullModel for Enthalpy, or none should." ); public: CompositionalMultiphaseFluid( string const & name, dataRepository::Group * const parent ); @@ -75,8 +88,6 @@ class CompositionalMultiphaseFluid : public MultiFluidBase virtual void allocateConstitutiveData( dataRepository::Group & parent, localIndex const numPts ) override; - static constexpr bool isThermalType(){ return false; } - // TODO: This method should be implemented if an incorrect extrapolation of the pressure and temperature is encountered in the kernel /** * @copydoc MultiFluidBase::checkTablesParameters( real64 pressure, real64 temperature ) @@ -100,7 +111,7 @@ class CompositionalMultiphaseFluid : public MultiFluidBase }; public: - using KernelWrapper = CompositionalMultiphaseFluidUpdates< FLASH, PHASE1, PHASE2, PHASE3 >; + using KernelWrapper = CompositionalMultiphaseFluidUpdates< FLASH, PHASES... >; /** * @brief Create an update kernel wrapper. @@ -118,6 +129,14 @@ class CompositionalMultiphaseFluid : public MultiFluidBase // Create the fluid models void createModels(); + // Create each of the phase models + template< std::size_t... Is > + void createPhaseModels( std::index_sequence< Is... > ); + + // Helper to create the kernel wrappers + template< std::size_t... Is > + KernelWrapper createKernelWrapper( std::index_sequence< Is... > ); + array1d< integer > getPhaseTypes() const; static std::unique_ptr< compositional::ModelParameters > createModelParameters(); @@ -130,9 +149,7 @@ class CompositionalMultiphaseFluid : public MultiFluidBase array1d< integer > m_phaseType{}; // Phase models - std::unique_ptr< PHASE1 > m_phase1{}; - std::unique_ptr< PHASE2 > m_phase2{}; - std::unique_ptr< PHASE3 > m_phase3{}; + camp::tuple< std::unique_ptr< PHASES >... > m_phases{}; // Standard EOS component input std::unique_ptr< compositional::ComponentProperties > m_componentProperties{}; @@ -146,29 +163,29 @@ class CompositionalMultiphaseFluid : public MultiFluidBase using CompositionalTwoPhaseConstantViscosity = CompositionalMultiphaseFluid< compositional::NegativeTwoPhaseFlashModel, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::ConstantViscosity, compositional::NullModel >, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::ConstantViscosity, compositional::NullModel > >; + compositional::PhaseModel< compositional::CompositionalDensity, compositional::ConstantViscosity >, + compositional::PhaseModel< compositional::CompositionalDensity, compositional::ConstantViscosity > >; using CompositionalTwoPhaseLohrenzBrayClarkViscosity = CompositionalMultiphaseFluid< compositional::NegativeTwoPhaseFlashModel, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel >, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel > >; + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity >, + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity > >; using CompositionalTwoPhasePhillipsBrine = CompositionalMultiphaseFluid< compositional::NegativeTwoPhaseFlashModel, - compositional::PhaseModel< compositional::PhillipsBrineDensity, compositional::PhillipsBrineViscosity, compositional::NullModel >, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel > >; + compositional::PhaseModel< compositional::PhillipsBrineDensity, compositional::PhillipsBrineViscosity >, + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity > >; using CompositionalThreePhaseLohrenzBrayClarkViscosity = CompositionalMultiphaseFluid< compositional::ImmiscibleWaterFlashModel, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel >, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel >, - compositional::PhaseModel< compositional::ImmiscibleWaterDensity, compositional::ImmiscibleWaterViscosity, compositional::NullModel > >; + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity >, + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity >, + compositional::PhaseModel< compositional::ImmiscibleWaterDensity, compositional::ImmiscibleWaterViscosity > >; using CompositionalKValueLohrenzBrayClarkViscosity = CompositionalMultiphaseFluid< compositional::KValueFlashModel< 2 >, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel >, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel > >; + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity >, + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity > >; using CompositionalKValuePhillipsBrine = CompositionalMultiphaseFluid< compositional::KValueFlashModel< 2 >, - compositional::PhaseModel< compositional::PhillipsBrineDensity, compositional::PhillipsBrineViscosity, compositional::NullModel >, - compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity, compositional::NullModel > >; + compositional::PhaseModel< compositional::PhillipsBrineDensity, compositional::PhillipsBrineViscosity >, + compositional::PhaseModel< compositional::CompositionalDensity, compositional::LohrenzBrayClarkViscosity > >; } /* namespace constitutive */ diff --git a/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluidUpdates.hpp b/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluidUpdates.hpp index 6af1f3366dc..fb15d1a7c1c 100644 --- a/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluidUpdates.hpp +++ b/src/coreComponents/constitutive/fluid/multifluid/compositional/CompositionalMultiphaseFluidUpdates.hpp @@ -21,6 +21,7 @@ #define GEOS_CONSTITUTIVE_FLUID_MULTIFLUID_COMPOSITIONAL_COMPOSITIONALMULTIPHASEFLUIDUPDATES_HPP_ #include "constitutive/fluid/multifluid/compositional/parameters/ComponentProperties.hpp" +#include "constitutive/fluid/multifluid/compositional/models/NullModel.hpp" #include "constitutive/fluid/multifluid/MultiFluidBase.hpp" #include "constitutive/fluid/multifluid/MultiFluidUtils.hpp" @@ -33,19 +34,21 @@ namespace constitutive /** * @brief Kernel wrapper class for CompositionalMultiphaseFluid. * @tparam FLASH Class describing the phase equilibrium model - * @tparam PHASE1 Class describing the phase property models for the first phase. - * @tparam PHASE2 Class describing the phase property models for the second phase. - * @tparam PHASE3 Class describing the phase property models for the possible third phase. + * @tparam PHASES Classes describing the phase property models for each phase. */ -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > +template< typename FLASH, typename ... PHASES > class CompositionalMultiphaseFluidUpdates final : public MultiFluidBase::KernelWrapper { +public: + using FlashModel = FLASH; + + // Get the number of phases + static constexpr integer NUM_PHASES = static_cast< integer >(sizeof...(PHASES)); + public: CompositionalMultiphaseFluidUpdates( compositional::ComponentProperties const & componentProperties, FLASH const & flash, - PHASE1 const & phase1, - PHASE2 const & phase2, - PHASE3 const & phase3, + PHASES const & ... phases, arrayView1d< integer const > const & phaseOrder, arrayView1d< real64 const > const & componentMolarWeight, bool const useMass, @@ -94,6 +97,20 @@ class CompositionalMultiphaseFluidUpdates final : public MultiFluidBase::KernelW MultiFluidBase::FluidProp::SliceType const totalDensity, MultiFluidBase::PhaseComp::SliceType::ValueType const & kValues ) const; + /** + * @brief Helper to unpack phase property models and compute phase densities and viscosities. + */ + template< std::size_t... Is > + GEOS_HOST_DEVICE + void computePhaseProperties( real64 const pressure, + real64 const temperature, + MultiFluidBase::PhaseComp::SliceType const phaseComponentFraction, + MultiFluidBase::PhaseProp::SliceType const phaseDensity, + MultiFluidBase::PhaseProp::SliceType const phaseMassDensity, + MultiFluidBase::PhaseProp::SliceType const phaseViscosity, + MultiFluidBase::PhaseProp::SliceType const phaseEnthalpy, + std::index_sequence< Is... > ) const; + /** * @brief Convert derivatives from phase mole fraction to total mole fraction * @details Given property derivatives @c dProperty where composition derivatives are with @@ -116,6 +133,12 @@ class CompositionalMultiphaseFluidUpdates final : public MultiFluidBase::KernelW GEOS_FORCE_INLINE static void setZero( real64 & val ){ val = 0.0; } + GEOS_HOST_DEVICE + static constexpr bool isThermalType() + { + return (!std::is_same_v< typename PHASES::Enthalpy, compositional::NullModel > && ...); + } + private: // The component properties compositional::ComponentProperties::KernelWrapper m_componentProperties; @@ -126,22 +149,18 @@ class CompositionalMultiphaseFluidUpdates final : public MultiFluidBase::KernelW // The ordering of phases arrayView1d< integer const > const m_phaseOrder; - // Phase model kernel wrappers - typename PHASE1::KernelWrapper m_phase1; - typename PHASE2::KernelWrapper m_phase2; - typename PHASE3::KernelWrapper m_phase3; + // Phase model kernel wrappers stored in a tuple + camp::tuple< typename PHASES::KernelWrapper... > m_phases; // Backup variables MultiFluidBase::PhaseComp::ViewValueType m_kValues; }; -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > -CompositionalMultiphaseFluidUpdates< FLASH, PHASE1, PHASE2, PHASE3 >:: +template< typename FLASH, typename ... PHASES > +CompositionalMultiphaseFluidUpdates< FLASH, PHASES... >:: CompositionalMultiphaseFluidUpdates( compositional::ComponentProperties const & componentProperties, FLASH const & flash, - PHASE1 const & phase1, - PHASE2 const & phase2, - PHASE3 const & phase3, + PHASES const &... phases, arrayView1d< integer const > const & phaseOrder, arrayView1d< real64 const > const & componentMolarWeight, bool const useMass, @@ -167,17 +186,15 @@ CompositionalMultiphaseFluidUpdates( compositional::ComponentProperties const & m_componentProperties( componentProperties.createKernelWrapper() ), m_flash( flash.createKernelWrapper() ), m_phaseOrder( phaseOrder ), - m_phase1( phase1.createKernelWrapper() ), - m_phase2( phase2.createKernelWrapper() ), - m_phase3( phase3.createKernelWrapper() ), + m_phases( phases.createKernelWrapper()... ), m_kValues( kValues ) {} -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > +template< typename FLASH, typename ... PHASES > GEOS_HOST_DEVICE GEOS_FORCE_INLINE void -CompositionalMultiphaseFluidUpdates< FLASH, PHASE1, PHASE2, PHASE3 >::compute( +CompositionalMultiphaseFluidUpdates< FLASH, PHASES... >::compute( real64 const pressure, real64 const temperature, arraySlice1d< real64 const, compflow::USD_COMP - 1 > const & composition, @@ -210,11 +227,62 @@ CompositionalMultiphaseFluidUpdates< FLASH, PHASE1, PHASE2, PHASE3 >::compute( kValues[0][0] ); } -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > +template< typename FLASH, typename ... PHASES > +template< std::size_t... Is > +GEOS_HOST_DEVICE +void CompositionalMultiphaseFluidUpdates< FLASH, PHASES... >::computePhaseProperties( + real64 const pressure, + real64 const temperature, + MultiFluidBase::PhaseComp::SliceType const phaseComponentFraction, + MultiFluidBase::PhaseProp::SliceType const phaseDensity, + MultiFluidBase::PhaseProp::SliceType const phaseMassDensity, + MultiFluidBase::PhaseProp::SliceType const phaseViscosity, + MultiFluidBase::PhaseProp::SliceType const phaseEnthalpy, + std::index_sequence< Is... > ) const +{ + // Density computations + ( camp::get< Is >( m_phases ).density.compute( + m_componentProperties, + pressure, + temperature, + phaseComponentFraction.value[m_phaseOrder[Is]].toSliceConst(), + phaseDensity.value[m_phaseOrder[Is]], + phaseDensity.derivs[m_phaseOrder[Is]], + phaseMassDensity.value[m_phaseOrder[Is]], + phaseMassDensity.derivs[m_phaseOrder[Is]], + m_useMass ), ... ); + + // Viscosity computations + ( camp::get< Is >( m_phases ).viscosity.compute( + m_componentProperties, + pressure, + temperature, + phaseComponentFraction.value[m_phaseOrder[Is]].toSliceConst(), + phaseMassDensity.value[m_phaseOrder[Is]], + phaseMassDensity.derivs[m_phaseOrder[Is]].toSliceConst(), + phaseViscosity.value[m_phaseOrder[Is]], + phaseViscosity.derivs[m_phaseOrder[Is]], + m_useMass ), ... ); + + if constexpr (isThermalType()) + { + // Enthalpy computations + ( camp::get< Is >( m_phases ).enthalpy.compute( + m_componentProperties, + pressure, + temperature, + phaseComponentFraction.value[m_phaseOrder[Is]].toSliceConst(), + phaseEnthalpy.value[m_phaseOrder[Is]], + phaseEnthalpy.derivs[m_phaseOrder[Is]], + m_useMass ), ... ); + } +} + +template< typename FLASH, typename ... PHASES > GEOS_HOST_DEVICE GEOS_FORCE_INLINE void -CompositionalMultiphaseFluidUpdates< FLASH, PHASE1, PHASE2, PHASE3 >::compute( +CompositionalMultiphaseFluidUpdates< FLASH, PHASES... >::compute( real64 const pressure, real64 const temperature, arraySlice1d< real64 const, compflow::USD_COMP - 1 > const & composition, @@ -230,9 +298,7 @@ CompositionalMultiphaseFluidUpdates< FLASH, PHASE1, PHASE2, PHASE3 >::compute( { integer constexpr maxNumComp = MultiFluidBase::MAX_NUM_COMPONENTS; integer constexpr maxNumDof = MultiFluidBase::MAX_NUM_COMPONENTS + 2; - integer constexpr maxNumPhase = MultiFluidBase::MAX_NUM_PHASES; integer const numComp = numComponents(); - integer const numPhase = numPhases(); integer const numDof = numComp + 2; // 1. Convert input mass fractions to mole fractions and keep derivatives @@ -264,73 +330,19 @@ CompositionalMultiphaseFluidUpdates< FLASH, PHASE1, PHASE2, PHASE3 >::compute( phaseFraction, phaseComponentFraction ); - // 3. Calculate the phase densities - m_phase1.density.compute( m_componentProperties, - pressure, - temperature, - phaseComponentFraction.value[m_phaseOrder[0]].toSliceConst(), - phaseDensity.value[m_phaseOrder[0]], - phaseDensity.derivs[m_phaseOrder[0]], - phaseMassDensity.value[m_phaseOrder[0]], - phaseMassDensity.derivs[m_phaseOrder[0]], - m_useMass ); - m_phase2.density.compute( m_componentProperties, - pressure, - temperature, - phaseComponentFraction.value[m_phaseOrder[1]].toSliceConst(), - phaseDensity.value[m_phaseOrder[1]], - phaseDensity.derivs[m_phaseOrder[1]], - phaseMassDensity.value[m_phaseOrder[1]], - phaseMassDensity.derivs[m_phaseOrder[1]], - m_useMass ); - if constexpr (2 < FLASH::KernelWrapper::getNumberOfPhases()) - { - m_phase3.density.compute( m_componentProperties, - pressure, - temperature, - phaseComponentFraction.value[m_phaseOrder[2]].toSliceConst(), - phaseDensity.value[m_phaseOrder[2]], - phaseDensity.derivs[m_phaseOrder[2]], - phaseMassDensity.value[m_phaseOrder[2]], - phaseMassDensity.derivs[m_phaseOrder[2]], - m_useMass ); - } - - // 4. Calculate the phase viscosities - m_phase1.viscosity.compute( m_componentProperties, - pressure, - temperature, - phaseComponentFraction.value[m_phaseOrder[0]].toSliceConst(), - phaseMassDensity.value[m_phaseOrder[0]], - phaseMassDensity.derivs[m_phaseOrder[0]].toSliceConst(), - phaseViscosity.value[m_phaseOrder[0]], - phaseViscosity.derivs[m_phaseOrder[0]], - m_useMass ); - m_phase2.viscosity.compute( m_componentProperties, - pressure, - temperature, - phaseComponentFraction.value[m_phaseOrder[1]].toSliceConst(), - phaseMassDensity.value[m_phaseOrder[1]], - phaseMassDensity.derivs[m_phaseOrder[1]].toSliceConst(), - phaseViscosity.value[m_phaseOrder[1]], - phaseViscosity.derivs[m_phaseOrder[1]], - m_useMass ); - if constexpr (2 < FLASH::KernelWrapper::getNumberOfPhases()) - { - m_phase3.viscosity.compute( m_componentProperties, - pressure, - temperature, - phaseComponentFraction.value[m_phaseOrder[2]].toSliceConst(), - phaseMassDensity.value[m_phaseOrder[2]], - phaseMassDensity.derivs[m_phaseOrder[2]].toSliceConst(), - phaseViscosity.value[m_phaseOrder[2]], - phaseViscosity.derivs[m_phaseOrder[2]], - m_useMass ); - } - - // 5. Convert derivatives from phase composition to total composition + // 3. Calculate phase properties: density, viscosity and enthalpy + computePhaseProperties( pressure, + temperature, + phaseComponentFraction, + phaseDensity, + phaseMassDensity, + phaseViscosity, + phaseEnthalpy, + std::make_index_sequence< NUM_PHASES >{} ); + + // 4. Convert derivatives from phase composition to total composition stackArray1d< real64, maxNumDof > workSpace( numDof ); - for( integer ip = 0; ip < FLASH::KernelWrapper::getNumberOfPhases(); ++ip ) + for( integer ip = 0; ip < NUM_PHASES; ++ip ) { convertDerivativesToTotalMoleFraction( numComp, phaseComponentFraction.derivs[ip].toSliceConst(), @@ -344,17 +356,34 @@ CompositionalMultiphaseFluidUpdates< FLASH, PHASE1, PHASE2, PHASE3 >::compute( phaseComponentFraction.derivs[ip].toSliceConst(), phaseViscosity.derivs[ip], workSpace ); + if constexpr (isThermalType()) + { + convertDerivativesToTotalMoleFraction( numComp, + phaseComponentFraction.derivs[ip].toSliceConst(), + phaseEnthalpy.derivs[ip], + workSpace ); + } + } + + // 5. Calculate the internal energy + if constexpr (isThermalType()) + { + computeInternalEnergy( pressure, + phaseFraction, + phaseMassDensity, + phaseEnthalpy, + phaseInternalEnergy ); } // 6. if mass variables used instead of molar, perform the conversion if( m_useMass ) { - real64 phaseMolecularWeight[maxNumPhase]{}; - real64 dPhaseMolecularWeight[maxNumPhase][maxNumDof]{}; + real64 phaseMolecularWeight[NUM_PHASES]{}; + real64 dPhaseMolecularWeight[NUM_PHASES][maxNumDof]{}; arrayView1d< real64 const > const & componentMolarWeight = m_componentProperties.m_componentMolarWeight; - for( integer ip = 0; ip < numPhase; ++ip ) + for( integer ip = 0; ip < NUM_PHASES; ++ip ) { auto const & phaseComposition = phaseComponentFraction.value[ip].toSliceConst(); auto const & dPhaseComposition = phaseComponentFraction.derivs[ip].toSliceConst(); @@ -380,7 +409,7 @@ CompositionalMultiphaseFluidUpdates< FLASH, PHASE1, PHASE2, PHASE3 >::compute( phaseInternalEnergy.derivs ); // Molar density equals mass density - for( integer ip = 0; ip < numPhase; ++ip ) + for( integer ip = 0; ip < NUM_PHASES; ++ip ) { phaseDensity.value[ip] = phaseMassDensity.value[ip]; for( integer idof = 0; idof < numDof; ++idof ) @@ -397,11 +426,11 @@ CompositionalMultiphaseFluidUpdates< FLASH, PHASE1, PHASE2, PHASE3 >::compute( totalDensity ); } -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > +template< typename FLASH, typename ... PHASES > GEOS_HOST_DEVICE GEOS_FORCE_INLINE void -CompositionalMultiphaseFluidUpdates< FLASH, PHASE1, PHASE2, PHASE3 >:: +CompositionalMultiphaseFluidUpdates< FLASH, PHASES... >:: update( localIndex const k, localIndex const q, real64 const pressure, @@ -422,11 +451,11 @@ update( localIndex const k, m_kValues[k][q] ); } -template< typename FLASH, typename PHASE1, typename PHASE2, typename PHASE3 > +template< typename FLASH, typename ... PHASES > template< int USD1, int USD2 > GEOS_HOST_DEVICE void -CompositionalMultiphaseFluidUpdates< FLASH, PHASE1, PHASE2, PHASE3 >:: +CompositionalMultiphaseFluidUpdates< FLASH, PHASES... >:: convertDerivativesToTotalMoleFraction( integer const numComps, arraySlice2d< real64 const, USD1 > const & dPhaseComposition, arraySlice1d< real64, USD2 > const & dProperty, diff --git a/src/coreComponents/constitutive/fluid/multifluid/compositional/models/PhaseModel.hpp b/src/coreComponents/constitutive/fluid/multifluid/compositional/models/PhaseModel.hpp index c99b723c0b0..06cc7779df0 100644 --- a/src/coreComponents/constitutive/fluid/multifluid/compositional/models/PhaseModel.hpp +++ b/src/coreComponents/constitutive/fluid/multifluid/compositional/models/PhaseModel.hpp @@ -39,7 +39,7 @@ class ModelParameters; * @tparam VISCOSITY Class describing the viscosity model * @tparam ENTHALPY Class describing the enthalpy model */ -template< typename DENSITY, typename VISCOSITY, typename ENTHALPY > +template< typename DENSITY, typename VISCOSITY, typename ENTHALPY = NullModel > struct PhaseModel { using Density = DENSITY; @@ -85,7 +85,6 @@ struct PhaseModel */ struct KernelWrapper { - /** * @brief Constructor for the kernel wrapper * @param[in] dens the density model @@ -120,7 +119,6 @@ struct PhaseModel /// Kernel wrapper for enthalpy updates typename Enthalpy::KernelWrapper enthalpy; - }; /** @@ -143,12 +141,8 @@ struct PhaseModel phaseParameters = Enthalpy::createParameters( std::move( phaseParameters ) ); return phaseParameters; } - }; -// A no-op phase model -using NullPhaseModel = PhaseModel< NullModel, NullModel, NullModel >; - } // namespace compositional } // namespace constitutive From 1fb5e3d6d1828020f8d903403ca8fa48f4d38012 Mon Sep 17 00:00:00 2001 From: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> Date: Mon, 8 Jun 2026 13:01:17 -0500 Subject: [PATCH 52/53] Fix multifluid mole-fraction derivative initialization for GCC15 (#4070) (#4072) * Fix multifluid mole-fraction derivative initialization for GCC15 (#4070) * Fix molality calculation in MultiFluidBase.hpp * Fix calculation of component mole fraction * Change * Change --------- Co-authored-by: LiYang --- .../constitutive/fluid/multifluid/MultiFluidBase.hpp | 9 ++++----- src/coreComponents/schema/schema.xsd.other | 4 ++-- 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/src/coreComponents/constitutive/fluid/multifluid/MultiFluidBase.hpp b/src/coreComponents/constitutive/fluid/multifluid/MultiFluidBase.hpp index ad85efc114b..22ab079eeaa 100644 --- a/src/coreComponents/constitutive/fluid/multifluid/MultiFluidBase.hpp +++ b/src/coreComponents/constitutive/fluid/multifluid/MultiFluidBase.hpp @@ -775,9 +775,7 @@ MultiFluidBase::KernelWrapper:: for( integer ic = 0; ic < numComps; ++ic ) { // component weight can not be zero, checked in MultiFluidBase::postInputInitialization - real64 const mwInv = 1.0 / m_componentMolarWeight[ic]; - compMoleFrac[ic] = composition[ic] * mwInv; // this is molality (units of mole/mass) - dCompMoleFrac_dCompMassFrac[ic][ic] = mwInv; + compMoleFrac[ic] = composition[ic] / m_componentMolarWeight[ic]; // this is molality (units of mole/mass) totalMolality += compMoleFrac[ic]; } @@ -788,8 +786,9 @@ MultiFluidBase::KernelWrapper:: for( integer jc = 0; jc < numComps; ++jc ) { - dCompMoleFrac_dCompMassFrac[ic][jc] -= compMoleFrac[ic] / m_componentMolarWeight[jc]; - dCompMoleFrac_dCompMassFrac[ic][jc] *= totalMolalityInv; + real64 const delta = ic == jc ? 1.0 : 0.0; + dCompMoleFrac_dCompMassFrac[ic][jc] = + ( delta - compMoleFrac[ic] ) * totalMolalityInv / m_componentMolarWeight[jc]; } } } diff --git a/src/coreComponents/schema/schema.xsd.other b/src/coreComponents/schema/schema.xsd.other index 355f061e7f5..11e08ccc206 100644 --- a/src/coreComponents/schema/schema.xsd.other +++ b/src/coreComponents/schema/schema.xsd.other @@ -526,7 +526,7 @@ A field can represent a physical variable. (pressure, temperature, global compos - + @@ -1603,7 +1603,7 @@ A field can represent a physical variable. (pressure, temperature, global compos - + From b21bec7ae1deb4d6657e70b621714e744d3d2062 Mon Sep 17 00:00:00 2001 From: Jian Huang <53012159+jhuang2601@users.noreply.github.com> Date: Tue, 9 Jun 2026 01:24:32 -0500 Subject: [PATCH 53/53] fix: MPI runs for smoke tests with surfaceGenerator (#4068) * enable smoke tests with MPI runs * update rebaseline tag * test ordering * test ordering * map * rebaseline test * Update src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.hpp Co-authored-by: Jacques Franc <49998870+jafranc@users.noreply.github.com> --------- Co-authored-by: DENEL Bertrand Co-authored-by: Jacques Franc <49998870+jafranc@users.noreply.github.com> Co-authored-by: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 12 +++++++ ..._inclinedFault_ISG_DruckerPrager_smoke.xml | 7 +++- .../ALM_inclinedFault_ISG_smoke.xml | 7 +++- .../AugmentedLagrangianMultipliers.ats | 4 +-- .../surfaceGeneration/SurfaceGenerator.cpp | 16 ++++----- .../surfaceGeneration/SurfaceGenerator.hpp | 33 ++++++++++++++++--- 7 files changed, 64 insertions(+), 17 deletions(-) diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index e1ea844bc05..33f78393820 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr4062-16784-6d8782e + baseline: integratedTests/baseline_integratedTests-pr4068-16828-c74157c allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index 2e69f9d42db..c52ced0e372 100644 --- a/BASELINE_NOTES.md +++ b/BASELINE_NOTES.md @@ -5,28 +5,40 @@ This file is designed to track changes to the integrated test baselines. Any developer who updates the baseline ID in the .integrated_tests.yaml file is expected to create an entry in this file with the pull request number, date, and their justification for rebaselining. These notes should be in reverse-chronological order, and use the following time format: (YYYY-MM-DD). +PR #4068 (2026-05-28) +===================== +Add MPI runs for smoke tests with surfaceGenerator + PR #4062 (2026-05-26) +===================== Add Porous Solid other than PorousElasticity for ALM solver PR #4057 (2026-05-21) +===================== Remove dependency on PVT package PR #3814 (2026-05-20) +===================== Fix RLF coloring PR #4008 (2026-05-18) +===================== Fix Fracture/3D cell co-location in parallel mesh redistribution PR #4055 (2026-05-18) +===================== Trim some fluid model tests PR #4041 (2026-05-16) +===================== Fix wellbore nonlinear thermal diffusion PR #3977 (2026-05-15) +===================== Change face normal, centers and area for local Newell's formula PR #3999 (2026-05-14) +===================== Fault Perm Update for Contact solvers PR #4029 (2026-05-06) diff --git a/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_DruckerPrager_smoke.xml b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_DruckerPrager_smoke.xml index b3ca9b80281..38a27f41b27 100755 --- a/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_DruckerPrager_smoke.xml +++ b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_DruckerPrager_smoke.xml @@ -159,7 +159,12 @@ krylovTol="1.0e-8" logLevel="1"/> - + diff --git a/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_smoke.xml b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_smoke.xml index 85382db0112..c0d606e5849 100755 --- a/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_smoke.xml +++ b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/ALM_inclinedFault_ISG_smoke.xml @@ -155,7 +155,12 @@ krylovTol="1.0e-8" logLevel="1"/> - + diff --git a/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/AugmentedLagrangianMultipliers.ats b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/AugmentedLagrangianMultipliers.ats index 754e1c0f60a..ae88ea54ea8 100644 --- a/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/AugmentedLagrangianMultipliers.ats +++ b/inputFiles/poromechanicsFractures/Contact/AugmentedLagrangianMultipliers/AugmentedLagrangianMultipliers.ats @@ -36,7 +36,7 @@ decks = [ TestDeck( name="ALM_inclinedFault_ISG_smoke", description='PoroElastic ALM inclined fault with internal surface generator (elastic)', - partitions=((1, 1, 1),), + partitions=((1, 1, 1), (2, 2, 1)), restart_step=0, check_step=1, restartcheck_params=RestartcheckParameters(**restartcheck_params)), @@ -50,7 +50,7 @@ decks = [ TestDeck( name="ALM_inclinedFault_ISG_DruckerPrager_smoke", description='PoroElastic ALM inclined fault with internal surface generator (DruckerPrager plastic)', - partitions=((1, 1, 1),), + partitions=((1, 1, 1), (2, 2, 1)), restart_step=0, check_step=1, restartcheck_params=RestartcheckParameters(**restartcheck_params)), diff --git a/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp b/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp index 229d409edea..ef2b09b7e6a 100644 --- a/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp +++ b/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.cpp @@ -993,7 +993,7 @@ bool SurfaceGenerator::processNode( const localIndex nodeID, std::set< localIndex > facialRupturePath; map< localIndex, int > edgeLocations; map< localIndex, int > faceLocations; - map< std::pair< CellElementSubRegion const *, localIndex >, int > elemLocations; + ElemLocMapType elemLocations; fracturePlaneFlag = findFracturePlanes( nodeID, nodeManager, @@ -1045,7 +1045,7 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, std::set< localIndex > & separationPathFaces, map< localIndex, int > & edgeLocations, map< localIndex, int > & faceLocations, - map< std::pair< CellElementSubRegion const *, localIndex >, int > & elemLocations ) + ElemLocMapType & elemLocations ) { GEOS_MARK_FUNCTION; @@ -1492,7 +1492,7 @@ bool SurfaceGenerator::findFracturePlanes( localIndex const nodeID, for( auto k = nodeToElementMaps.cbegin(); k != nodeToElementMaps.cend(); ++k ) { - elemLocations[*k] = INT_MIN; + elemLocations.get_inserted( *k ) = INT_MIN; } @@ -1585,7 +1585,7 @@ bool SurfaceGenerator::assignLocationsBFS( std::set< localIndex > const & separa map< localIndex, std::pair< localIndex, localIndex > > const & localFacesToEdges, map< localIndex, int > & edgeLocations, map< localIndex, int > & faceLocations, - map< std::pair< CellElementSubRegion const *, localIndex >, int > & elemLocations ) + ElemLocMapType & elemLocations ) { GEOS_MARK_FUNCTION; @@ -1835,7 +1835,7 @@ void SurfaceGenerator::performFracture( const localIndex nodeID, const std::set< localIndex > & separationPathFaces, const map< localIndex, int > & edgeLocations, const map< localIndex, int > & faceLocations, - const map< std::pair< CellElementSubRegion const *, localIndex >, int > & elemLocations ) + const ElemLocMapType & elemLocations ) { GEOS_MARK_FUNCTION; @@ -2151,7 +2151,7 @@ void SurfaceGenerator::performFracture( const localIndex nodeID, array1d< localIndex > const & childFaceIndex = faceManager.getField< fields::childIndex >(); // 1) loop over all elements attached to the nodeID - for( map< std::pair< CellElementSubRegion const *, localIndex >, int >::const_iterator iter_elem = elemLocations.begin(); iter_elem != elemLocations.end(); ++iter_elem ) + for( ElemLocMapType::const_iterator iter_elem = elemLocations.begin(); iter_elem != elemLocations.end(); ++iter_elem ) { const int & location = iter_elem->second; @@ -2515,7 +2515,7 @@ void SurfaceGenerator::mapConsistencyCheck( localIndex const GEOS_UNUSED_PARAM( EdgeManager const & edgeManager, FaceManager const & faceManager, ElementRegionManager const & elementManager, - map< std::pair< CellElementSubRegion const *, localIndex >, int > const & elemLocations ) + ElemLocMapType const & elemLocations ) { GEOS_MARK_FUNCTION; @@ -2544,7 +2544,7 @@ void SurfaceGenerator::mapConsistencyCheck( localIndex const GEOS_UNUSED_PARAM( { std::cout << "CONSISTENCY CHECKING OF THE MAPS" << std::endl; - for( map< std::pair< CellElementSubRegion const *, localIndex >, int >::const_iterator iter_elem = elemLocations.cbegin(); iter_elem != elemLocations.cend(); ++iter_elem ) + for( ElemLocMapType::const_iterator iter_elem = elemLocations.cbegin(); iter_elem != elemLocations.cend(); ++iter_elem ) { const std::pair< CellElementSubRegion const *, localIndex > & elem = iter_elem->first; diff --git a/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.hpp b/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.hpp index e0b655b4be4..5ddb0cd2773 100644 --- a/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.hpp +++ b/src/coreComponents/physicsSolvers/surfaceGeneration/SurfaceGenerator.hpp @@ -22,6 +22,7 @@ #include "mesh/mpiCommunications/NeighborCommunicator.hpp" #include "physicsSolvers/PhysicsSolverBase.hpp" #include "mesh/DomainPartition.hpp" +#include "mesh/CellElementSubRegion.hpp" #include "ParallelTopologyChange.hpp" namespace geos @@ -34,6 +35,30 @@ class FaceManager; class ElementRegionManager; class ElementRegionBase; +/** + * @brief Comparator for (CellElementSubRegion const *, localIndex) pairs that + * provides deterministic ordering based on localIndex/region/subregion indices in that precedence + */ +struct ElemLocComparator +{ + bool operator()( std::pair< CellElementSubRegion const *, localIndex > const & a, + std::pair< CellElementSubRegion const *, localIndex > const & b ) const + { + if( a.first != b.first ) + { + localIndex const regionA = a.first->getParent().getParent().getIndexInParent(); + localIndex const regionB = b.first->getParent().getParent().getIndexInParent(); + if( regionA != regionB ) + return regionA < regionB; + return a.first->getIndexInParent() < b.first->getIndexInParent(); + } + return a.second < b.second; + } +}; + +/// Type alias for the element location map with deterministic ordering. +using ElemLocMapType = stdMap< std::pair< CellElementSubRegion const *, localIndex >, int, ElemLocComparator >; + /** * @class SurfaceGenerator * @@ -367,7 +392,7 @@ class SurfaceGenerator : public PhysicsSolverBase std::set< localIndex > & separationPathFaces, map< localIndex, int > & edgeLocations, map< localIndex, int > & faceLocations, - map< std::pair< CellElementSubRegion const *, localIndex >, int > & elemLocations ); + ElemLocMapType & elemLocations ); /** @@ -397,14 +422,14 @@ class SurfaceGenerator : public PhysicsSolverBase std::set< localIndex > const & separationPathFaces, map< localIndex, int > const & edgeLocations, map< localIndex, int > const & faceLocations, - map< std::pair< CellElementSubRegion const *, localIndex >, int > const & elemLocations ); + ElemLocMapType const & elemLocations ); void mapConsistencyCheck( localIndex const nodeID, NodeManager const & nodeManager, EdgeManager const & edgeManager, FaceManager const & faceManager, ElementRegionManager const & elementManager, - map< std::pair< CellElementSubRegion const *, localIndex >, int > const & elemLocations ); + ElemLocMapType const & elemLocations ); /** * @brief Assign fracture-plane sides to all elements, faces, and edges @@ -444,7 +469,7 @@ class SurfaceGenerator : public PhysicsSolverBase map< localIndex, std::pair< localIndex, localIndex > > const & localFacesToEdges, map< localIndex, int > & edgeLocations, map< localIndex, int > & faceLocations, - map< std::pair< CellElementSubRegion const *, localIndex >, int > & elemLocations ); + ElemLocMapType & elemLocations ); /** *