From 8536462284068ec749d22a3e9827468257435dd2 Mon Sep 17 00:00:00 2001 From: MelReyCG <122801580+MelReyCG@users.noreply.github.com> Date: Tue, 7 Jul 2026 14:46:19 +0200 Subject: [PATCH 1/9] feat: Split statistics components computation & output (#3836) Allow to query statistics computation for solver (for reservoir reference pressure for wells), without needing an output statistics component. Statistics are no longer recomputed for each convergence step but only at iteration start. - `RegionStatistics` classes for resulting data storages at different levels: - sub-regions mpi-local kernel compute read-backs, - (cell element) regions, - solver discretisation `MeshLevel`, - `StatsAggregator` classes to compute & reduce the statistics to rank 0, - `StatsTask` `Group`, the user component to schedule flow statistics computation & output to log & CSV. --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 4 + .../common/format/table/TableFormatter.hpp | 6 + .../common/format/table/TableTypes.hpp | 2 +- .../dataRepository/DataContext.hpp | 6 +- src/coreComponents/mesh/MeshBody.hpp | 6 +- .../physicsSolvers/CMakeLists.txt | 4 +- .../physicsSolvers/FieldStatisticsBase.hpp | 32 +- .../StatisticsAggregatorBase.hpp | 283 +++++++++ .../StatisticsAggregatorBaseHelpers.hpp | 296 ++++++++++ .../physicsSolvers/fluidFlow/CMakeLists.txt | 12 +- .../CompositionalMultiphaseStatistics.cpp | 555 ------------------ ...sitionalMultiphaseStatisticsAggregator.cpp | 397 +++++++++++++ ...sitionalMultiphaseStatisticsAggregator.hpp | 314 ++++++++++ .../CompositionalMultiphaseStatisticsTask.cpp | 419 +++++++++++++ ...CompositionalMultiphaseStatisticsTask.hpp} | 133 ++--- .../fluidFlow/SinglePhaseStatistics.cpp | 303 ---------- .../SinglePhaseStatisticsAggregator.cpp | 194 ++++++ .../SinglePhaseStatisticsAggregator.hpp | 203 +++++++ .../fluidFlow/SinglePhaseStatisticsTask.cpp | 278 +++++++++ ...tics.hpp => SinglePhaseStatisticsTask.hpp} | 93 ++- .../unitTests/testFlowStatistics.cpp | 93 ++- .../wells/CompositionalMultiphaseWell.cpp | 259 ++++---- .../wells/CompositionalMultiphaseWell.hpp | 24 +- .../fluidFlow/wells/SinglePhaseWell.cpp | 227 ++++--- .../fluidFlow/wells/SinglePhaseWell.hpp | 26 +- .../fluidFlow/wells/WellControls.hpp | 4 +- .../fluidFlow/wells/WellSolverBase.cpp | 11 +- .../fluidFlow/wells/WellSolverBase.hpp | 2 +- src/coreComponents/schema/schema.xsd.other | 4 +- 30 files changed, 2951 insertions(+), 1241 deletions(-) create mode 100644 src/coreComponents/physicsSolvers/StatisticsAggregatorBase.hpp create mode 100644 src/coreComponents/physicsSolvers/StatisticsAggregatorBaseHelpers.hpp delete mode 100644 src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatistics.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsAggregator.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsAggregator.hpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsTask.cpp rename src/coreComponents/physicsSolvers/fluidFlow/{CompositionalMultiphaseStatistics.hpp => CompositionalMultiphaseStatisticsTask.hpp} (55%) delete mode 100644 src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatistics.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsAggregator.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsAggregator.hpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsTask.cpp rename src/coreComponents/physicsSolvers/fluidFlow/{SinglePhaseStatistics.hpp => SinglePhaseStatisticsTask.hpp} (53%) diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index 5076ede8bd3..3de3368090d 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr4040-16993-1393f80 + baseline: integratedTests/baseline_integratedTests-pr3836-17046-2e89f64 allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index 024e6787153..6f77c74b57b 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 #3836 (2026-05-20) +===================== +Added statistics `Group` objects for each statistics `Task` instance + PR #4040 (2026-06-16) Move relperm driver to use new constitutive driver framework diff --git a/src/coreComponents/common/format/table/TableFormatter.hpp b/src/coreComponents/common/format/table/TableFormatter.hpp index eed907975c2..5100336e302 100644 --- a/src/coreComponents/common/format/table/TableFormatter.hpp +++ b/src/coreComponents/common/format/table/TableFormatter.hpp @@ -57,6 +57,12 @@ class TableFormatter TableErrorListing & getErrorsList() const { return *m_errors; } + /** + * @return The prepared table layout + */ + PreparedTableLayout const & getLayout() const + { return m_tableLayout; } + protected: /// Layout for a table diff --git a/src/coreComponents/common/format/table/TableTypes.hpp b/src/coreComponents/common/format/table/TableTypes.hpp index cfea392d21b..d42d2fd2a33 100644 --- a/src/coreComponents/common/format/table/TableTypes.hpp +++ b/src/coreComponents/common/format/table/TableTypes.hpp @@ -82,7 +82,7 @@ class TableErrorListing * @brief Append a vector of string to the errors vector. * @param errors A vector of string to append */ - void appendErrors( stdVector< string > & errors ) + void appendErrors( stdVector< string > const & errors ) { m_errorList.insert( m_errorList.end(), errors.begin(), errors.end() );} /** diff --git a/src/coreComponents/dataRepository/DataContext.hpp b/src/coreComponents/dataRepository/DataContext.hpp index 8a43381b438..f34ca3c8687 100644 --- a/src/coreComponents/dataRepository/DataContext.hpp +++ b/src/coreComponents/dataRepository/DataContext.hpp @@ -78,7 +78,7 @@ class DataContext /** * @return Get the target object name */ - string getTargetName() const + string const & getTargetName() const { return m_targetName; } /** * @brief Insert contextual information in the provided stream. @@ -179,13 +179,13 @@ class DataFileContext final : public DataContext /** * @return the type name in the source file (XML node tag name / attribute name). */ - string getTypeName() const + string const & getTypeName() const { return m_typeName; } /** * @return the source file path where the target object has been declared. */ - string getFilePath() const + string const & getFilePath() const { return m_filePath; } /** diff --git a/src/coreComponents/mesh/MeshBody.hpp b/src/coreComponents/mesh/MeshBody.hpp index c0f30715c0c..a8f8cbe70af 100644 --- a/src/coreComponents/mesh/MeshBody.hpp +++ b/src/coreComponents/mesh/MeshBody.hpp @@ -96,8 +96,7 @@ class MeshBody : public dataRepository::Group * @param[in] level The lookup key of the MeshLevel * @return const reference to the MeshLevel */ - template< typename T, std::enable_if_t< std::is_same< T, string >::value || - std::is_same< T, const char * >::value, bool > = false > + template< typename T > MeshLevel & getMeshLevel( T const & level ) const { return m_meshLevels.getGroup< MeshLevel >( level ); } @@ -108,8 +107,7 @@ class MeshBody : public dataRepository::Group * @param[in] level The lookup key of the MeshLevel * @return Reference to the MeshLevel */ - template< typename T, std::enable_if_t< std::is_same< T, string >::value || - std::is_same< T, const char * >::value, bool > = false > + template< typename T > MeshLevel & getMeshLevel( T const & level ) { return m_meshLevels.getGroup< MeshLevel >( level ); } diff --git a/src/coreComponents/physicsSolvers/CMakeLists.txt b/src/coreComponents/physicsSolvers/CMakeLists.txt index ee5c8ff2a0b..62748ae8208 100644 --- a/src/coreComponents/physicsSolvers/CMakeLists.txt +++ b/src/coreComponents/physicsSolvers/CMakeLists.txt @@ -29,7 +29,9 @@ set( physicsSolversBase_headers NonlinearSolverParameters.hpp PhysicsSolverBase.hpp PhysicsSolverBaseKernels.hpp - SolverStatistics.hpp ) + SolverStatistics.hpp + StatisticsAggregatorBase.hpp + StatisticsAggregatorBaseHelpers.hpp ) # # Specify solver sources # diff --git a/src/coreComponents/physicsSolvers/FieldStatisticsBase.hpp b/src/coreComponents/physicsSolvers/FieldStatisticsBase.hpp index 13390fe314c..1548ed4b6e6 100644 --- a/src/coreComponents/physicsSolvers/FieldStatisticsBase.hpp +++ b/src/coreComponents/physicsSolvers/FieldStatisticsBase.hpp @@ -50,8 +50,7 @@ class FieldStatisticsBase : public TaskBase m_outputDir( joinPath( OutputBase::getOutputDirectory(), name ) ) { - string const key = SOLVER::coupledSolverAttributePrefix() + "SolverName"; - registerWrapper( key, &m_solverName ). + registerWrapper( getSolverWrapperKey(), &m_solverName ). setRTTypeName( rtTypes::CustomTypes::groupNameRef ). setInputFlag( dataRepository::InputFlags::REQUIRED ). setDescription( "Name of the " + SOLVER::coupledSolverAttributePrefix() + " solver" ); @@ -80,6 +79,20 @@ class FieldStatisticsBase : public TaskBase protected: + struct viewKeyStruct + { + static constexpr char const * writeCSVFlagString() { return "writeCSV"; } + }; + + /// Pointer to the physics solver + SOLVER * m_solver; + + // Output directory + string const m_outputDir; + + // Flag to enable writing CSV output + integer m_writeCSV; + void postInputInitialization() override { Group & problemManager = this->getGroupByPath( "/Problem" ); @@ -103,19 +116,8 @@ class FieldStatisticsBase : public TaskBase } } - struct viewKeyStruct - { - static constexpr char const * writeCSVFlagString() { return "writeCSV"; } - }; - - /// Pointer to the physics solver - SOLVER * m_solver; - - // Output directory - string const m_outputDir; - - // Flag to enable writing CSV output - integer m_writeCSV; + string getSolverWrapperKey() const + { return SOLVER::coupledSolverAttributePrefix() + "SolverName"; } private: diff --git a/src/coreComponents/physicsSolvers/StatisticsAggregatorBase.hpp b/src/coreComponents/physicsSolvers/StatisticsAggregatorBase.hpp new file mode 100644 index 00000000000..6f389885dc6 --- /dev/null +++ b/src/coreComponents/physicsSolvers/StatisticsAggregatorBase.hpp @@ -0,0 +1,283 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 StatisticsAggregatorBase.hpp + */ + +#ifndef SRC_CORECOMPONENTS_PHYSICSSOLVERS_STATISTICSAGGREGATOR_HPP_ +#define SRC_CORECOMPONENTS_PHYSICSSOLVERS_STATISTICSAGGREGATOR_HPP_ + +#include "common/DataTypes.hpp" +#include "dataRepository/DataContext.hpp" +#include "dataRepository/Group.hpp" +#include "mesh/CellElementRegion.hpp" +#include "mesh/MeshBody.hpp" +#include "mesh/MeshLevel.hpp" + +namespace geos +{ + +/** + * @brief Output data group to contain the result of a given stat aggregator on the dataRepository. + * Attributes are public since the class is a POD. + * @todo repair 1D HDF5 outputs to enable stats HDF5 outputs + */ +class RegionStatisticsBase : public dataRepository::Group +{ +public: + + /// Time of statistics computation (std::numeric_limits< double >::lowest() if not initialized) + real64 m_time; + + /** + * @brief Construct a new Region Statistics Base object + * @param targetName name of the data-repository object that is targeted by the statistics + * (mesh level / region / sub-region). + * @param parent the instance parent in data-repository + * @param statsOutputEnabled If true, the stats are saved in the output HDF5 + * (through dataRepository::RestartFlags, but not functional for this output for now). + */ + RegionStatisticsBase( string const & targetName, + dataRepository::Group * const parent, + bool statsOutputEnabled ); + + /** + * @return the name of the data-repository object that is targeted by the statistics + * (mesh level / region / sub-region). + */ + string_view getTargetName() const + { return getName(); } + +}; + +template< typename T > +struct StatsAggregatorTraits; + +/** + * @brief Reponsible of computing physical statistics over the grid, registering the result in the + * data repository, but not storing / outputing it by itself. It does not have mutable state + * except the encountered issues. + * @todo repair 1D HDF5 outputs to enable stats HDF5 outputs + * @tparam Impl the derived type of the statistics aggregator which contains all necessary implementations (CRTP) + */ +template< typename Impl > +class StatsAggregatorBase +{ +public: + + using SolverType = typename StatsAggregatorTraits< Impl >::SolverType; + + using StatsGroupType = typename StatsAggregatorTraits< Impl >::StatsGroupType; + + /** + * @brief Standard function signature for any functor that applies on statistics group instances (StatsGroupType) + * - param 0: OwnerType &, the group instance containing the data for which we want to aggregate the statistics (MeshLevel, + * CellElementRegion...) + * - param 1: StatsAggregateGroupType &, the statistics aggregate Group where to store the data + * @tparam OwnerType the concrete type of the OwnerType param + */ + template< typename OwnerType > + using RegionStatsFunc = std::function< void ( OwnerType &, + StatsGroupType & ) >; + + /** + * @brief A functor that can be used to register a statistics Group instance. Parameters: + * - dataRepository::Group &, the parent Group, + * - string const &, name of the statistics target (i.e. region name). + */ + using RegionStatsRegisterFunc = std::function< StatsGroupType & ( dataRepository::Group &, + string const & ) >; + + /** + * @brief the associated view keys + */ + struct ViewKeys + { + /// String for the discretization statistics group + constexpr static char const * statisticsString() { return "statistics"; } + /// String for the region statistics group + constexpr static char const * regionsStatisticsString() { return "regionsStatistics"; } + }; + + /** + * @brief Construct a new Stats Aggregator object + * @param ownerName the unique name of the entity requesting the statistics. + * An error is thrown if not unique in this context. + * @param meshBodies The Group containing the MeshBody objects + * @param statsOutputEnabled If true, the stats are saved in the output HDF5 + * (through dataRepository::RestartFlags, but not functional for this output for now). + */ + StatsAggregatorBase( dataRepository::DataContext const & ownerDataContext, + dataRepository::Group & meshBodies, + bool statsOutputEnabled ); + + /** + * @brief Enable the computation of any statistics, initialize data structure to collect them. + * Register the resulting data wrappers so they will be targeted by TimeHistory output + * @param solver flow solver object to retrieve: + - the simulated regions, + - fields for statistics computation. + */ + void initStatisticsAggregation( SolverType & solver ); + + void forRegionStatistics( RegionStatsFunc< MeshLevel > const & functor ) const; + + void forRegionStatistics( MeshLevel & mesh, + StatsGroupType & meshRegionsStatistics, + RegionStatsFunc< CellElementRegion > const & functor ) const; + + void forRegionStatistics( CellElementRegion & region, + StatsGroupType & regionStatistics, + RegionStatsFunc< CellElementSubRegion > const & functor ) const; + + /** + * @param[in] timeRequest The time for which we want to know if the statistics are computed. + * @param[in] stats the statistics data structure we want to know if it has been computed + * @return true if the statistics have been computed. + */ + bool isComputed( real64 const timeRequest, StatsGroupType const & stats ); + + /** + * @brief set the statistics as dirty, ensuring isComputed() will be false until the next computation. + */ + void setDirty(); + + /** + * @brief Compute statistics on the mesh discretizations (average field pressure, etc) + * Results are reduced on rank 0, and broadcasted over all ranks. + * @param[in] timeRequest The time for which we want to compute the statistics. + * @return false if there was a problem that prevented the statistics to be computed correctly. + */ + bool computeRegionsStatistics( real64 const timeRequest ); + + /** + * @return the name of the entity that needs the statistics. + */ + string const & getOwnerName() const + { return m_ownerDataContext.getTargetName(); } + + /** + * @return The encountered issues during the last computing method call. + */ + stdVector< string > const & getWarnings() const + { return m_warnings; } + + dataRepository::Group & getInstanceStatisticsGroup( MeshLevel & mesh ) const; + + StatsGroupType & getRegionsStatistics( MeshLevel & mesh ) const; + + /** + * @return a specific statistics Group instance. + * @param mesh The desired mesh-level + * @param regionName The name of the desired region + * @throw InputError if no statistics data is found for the given region name. + */ + StatsGroupType & getRegionStatistics( MeshLevel & mesh, string_view regionName ) const; + +protected: + + struct StatsState + { + bool m_isEnabled = false; + bool m_isDirty = false; + }; + + struct DiscretizationGroupPath + { + localIndex m_meshBody; + localIndex m_meshLevel; + string_array m_regionNames; + }; + + /// @see getOwnerName() + dataRepository::DataContext const & m_ownerDataContext; + + /// If true, the stats are to save in the output HDF5 + bool const m_statsOutputEnabled; + + dataRepository::Group & m_meshBodies; + + stdVector< DiscretizationGroupPath > m_discretizationsPaths; + + /// @see getWarnings() + stdVector< string > m_warnings; + + /// The current state of the region statistics + StatsState m_regionStatsState; + + /** + * @brief Enable the computation of region statistics, initialize data structure to collect them. + * Register the resulting data wrappers so they will be targeted by TimeHistory output + * @note Must be called in or after the "registerDataOnMesh" initialization phase + * @param registerStatsFunc The functor which register each statistics group whithin the regions hierarchy + */ + void enableRegionStatisticsAggregation( RegionStatsRegisterFunc && registerStatsFunc ); + + /** + * @param path the path of the discretization group in the data-repository. + * @return MeshLevel& the MeshLevel Group for the given discretisation + */ + MeshLevel & getMeshLevel( DiscretizationGroupPath const & path ) const; + + /** + * @brief Initialize all statistics values to aggregable default values, + * before any computation / reduction for the current timestep. + * @param stats the statistics instance + * @param time start time of the current timestep (s) + * @note Must be implemented for each type that implements this template (CRTP). + */ + void initStats( StatsGroupType & stats, real64 time ) const + { static_cast< Impl const * >(this)->initStats( stats, time ); } + + /** + * @brief Compute the rank-local stats for the given sub-region and store the results in the given stats group. + * @param subRegion + * @param subRegionStats the stats group instance for the subregion + * @note Must be implemented for each type that implements this template (CRTP). + */ + void computeSubRegionRankStats( CellElementSubRegion & subRegion, StatsGroupType & subRegionStats ) const + { static_cast< Impl const * >(this)->computeSubRegionRankStats( subRegion, subRegionStats ); } + + /** + * @brief Aggregate all instance statistics with those of another instance on the current rank. + * @param stats the statistics instance + * @param other the other instance to aggregate with. + * @note Must be implemented for each type that implements this template (CRTP). + */ + void aggregateStats( StatsGroupType & stats, StatsGroupType const & other ) const + { static_cast< Impl const * >(this)->aggregateStats( stats, other ); } + + /** + * @brief Aggregate all instance statistics with those of other ranks. + * @param stats the statistics instance + * @note Must be implemented for each type that implements this template (CRTP). + */ + void mpiAggregateStats( StatsGroupType & stats ) const + { static_cast< Impl const * >(this)->mpiAggregateStats( stats ); } + + /** + * @brief Do the final computations for the statistics. Must be called after computations & aggregations. + * @param stats the statistics instance + * @note Must be implemented for each type that implements this template (CRTP). + */ + void postAggregateStats( StatsGroupType & stats ) + { static_cast< Impl * >(this)->postAggregateStats( stats ); } + +}; + +} /* namespace geos */ + +#endif /* SRC_CORECOMPONENTS_PHYSICSSOLVERS_STATISTICSAGGREGATOR_HPP_ */ diff --git a/src/coreComponents/physicsSolvers/StatisticsAggregatorBaseHelpers.hpp b/src/coreComponents/physicsSolvers/StatisticsAggregatorBaseHelpers.hpp new file mode 100644 index 00000000000..a609b4033ed --- /dev/null +++ b/src/coreComponents/physicsSolvers/StatisticsAggregatorBaseHelpers.hpp @@ -0,0 +1,296 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 "mesh/MeshBody.hpp" +#include "physicsSolvers/StatisticsAggregatorBase.hpp" + +#include "LvArray/src/math.hpp" +#include "common/DataTypes.hpp" +#include "common/format/Format.hpp" +#include "common/format/StringUtilities.hpp" +#include "common/logger/Logger.hpp" +#include "dataRepository/DataContext.hpp" +#include "dataRepository/Group.hpp" +#include "mesh/CellElementRegion.hpp" +#include "mesh/CellElementSubRegion.hpp" +#include "mesh/ElementRegionManager.hpp" +#include "mesh/MeshLevel.hpp" + +namespace geos +{ + +inline RegionStatisticsBase::RegionStatisticsBase( string const & targetName, + dataRepository::Group * const parent, + bool const statsOutputEnabled ): + dataRepository::Group( targetName, parent ), + m_time( std::numeric_limits< double >::lowest() ) +{ + Group::setRestartFlags( statsOutputEnabled ? + dataRepository::RestartFlags::WRITE_AND_READ : + dataRepository::RestartFlags::NO_WRITE ); + + // TODO : registerWrappers to store results in HDF5 (but need repairing of 1D HDF5 outputs) +} + +template< typename Impl > +StatsAggregatorBase< Impl >::StatsAggregatorBase( dataRepository::DataContext const & ownerDataContext, + dataRepository::Group & meshBodies, + bool const statsOutputEnabled ): + m_ownerDataContext( ownerDataContext ), + m_statsOutputEnabled( statsOutputEnabled ), + m_meshBodies( meshBodies ) +{} + +template< typename Impl > +void +StatsAggregatorBase< Impl >::initStatisticsAggregation( SolverType & solver ) +{ + solver.forDiscretizationOnMeshTargets( m_meshBodies, [&] ( string const & meshBodyName, + MeshLevel & mesh, + string_array const & regionNames ) + { + // getting the container of all requesters statistics groups (can be already initialized) + dataRepository::Group * meshStatsGroup = mesh.getGroupPointer( ViewKeys::statisticsString() ); + if( meshStatsGroup == nullptr ) + meshStatsGroup = &mesh.registerGroup( ViewKeys::statisticsString() ); + + // registering the container of instance statistics groups (must be unique for this instance) + string const & ownerName = getOwnerName(); + GEOS_ERROR_IF_NE_MSG( meshStatsGroup->hasGroup( ownerName ), false, + GEOS_FMT( "A statistics aggregator have already been requested for '{}'.", + ownerName ), + m_ownerDataContext ); + meshStatsGroup->registerGroup( ownerName ); + + // remembering the path of this discretization + MeshBody const & body = m_meshBodies.getGroup< MeshBody >( meshBodyName ); + DiscretizationGroupPath const path { + /* .m_meshBody = */ body.getIndexInParent(), + /* .m_meshLevel = */ mesh.getIndexInParent(), + /* .m_regionNames = */ regionNames, + }; + m_discretizationsPaths.push_back( path ); + } ); +} + +template< typename Impl > +void +StatsAggregatorBase< Impl >::enableRegionStatisticsAggregation( RegionStatsRegisterFunc && registerStatsFunc ) +{ + integer regionCount = 0; + integer subRegionCount = 0; + + for( auto const & path : m_discretizationsPaths ) + { + MeshLevel & mesh = getMeshLevel( path ); + ElementRegionManager & elemManager = mesh.getElemManager(); + dataRepository::Group & statisticsGroup = getInstanceStatisticsGroup( mesh ); + StatsGroupType & meshRegionsStats = registerStatsFunc( statisticsGroup, + ViewKeys::regionsStatisticsString() ); + + for( size_t i = 0; i < path.m_regionNames.size(); ++i ) + { + CellElementRegion & region = elemManager.getRegion< CellElementRegion >( path.m_regionNames[i] ); + StatsGroupType & regionStats = registerStatsFunc( meshRegionsStats, + region.getName() ); + + region.forElementSubRegions< CellElementSubRegion >( [&] ( CellElementSubRegion & subRegion ) + { + registerStatsFunc( regionStats, + subRegion.getName() ); + ++subRegionCount; + } ); + ++regionCount; + } + } + + GEOS_ERROR_IF( regionCount == 0 || subRegionCount == 0, + GEOS_FMT( "Missing region for computing statistics:\n- {} regions,\n- {} sub-regions.", + getOwnerName(), regionCount, subRegionCount ), + m_ownerDataContext ); + + m_regionStatsState.m_isEnabled = true; + m_regionStatsState.m_isDirty = true; +} + +template< typename Impl > +void +StatsAggregatorBase< Impl >::forRegionStatistics( RegionStatsFunc< MeshLevel > const & func ) const +{ + for( auto const & path : m_discretizationsPaths ) + { + MeshLevel & mesh = getMeshLevel( path ); + StatsGroupType & meshRegionsStats = getRegionsStatistics( mesh ); + + func( mesh, meshRegionsStats ); + } +} + +template< typename Impl > +void +StatsAggregatorBase< Impl >::forRegionStatistics( MeshLevel & mesh, + StatsGroupType & meshRegionsStatistics, + RegionStatsFunc< CellElementRegion > const & func ) const +{ + ElementRegionManager & elemManager = mesh.getElemManager(); + meshRegionsStatistics.template forSubGroups< StatsGroupType >( [&] ( StatsGroupType & regionStatistics ) + { + string_view targetName = regionStatistics.getTargetName(); + CellElementRegion & region = elemManager.getRegion< CellElementRegion >( string( targetName ) ); + + func( region, regionStatistics ); + } ); +} + +template< typename Impl > +void +StatsAggregatorBase< Impl >::forRegionStatistics( CellElementRegion & region, + StatsGroupType & regionStatistics, + RegionStatsFunc< CellElementSubRegion > const & func ) const +{ + regionStatistics.template forSubGroups< StatsGroupType >( [&] ( StatsGroupType & subRegionStatistics ) + { + string_view targetName = subRegionStatistics.getTargetName(); + CellElementSubRegion & subRegion = region.getSubRegion< CellElementSubRegion >( string( targetName ) ); + func( subRegion, subRegionStatistics ); + } ); +} + +template< typename Impl > +bool +StatsAggregatorBase< Impl >::isComputed( real64 const timeRequest, StatsGroupType const & stats ) +{ + real64 const timePrecisionScale = LvArray::math::max( LvArray::math::abs( timeRequest ), + LvArray::math::abs( stats.m_time ) ); + static constexpr real64 timeRelTol = 1.0e-12; + + return + !m_regionStatsState.m_isDirty && + LvArray::math::abs( timeRequest - stats.m_time ) < timeRelTol * timePrecisionScale; +} + +template< typename Impl > +void +StatsAggregatorBase< Impl >::setDirty() +{ + m_regionStatsState.m_isDirty = true; +} + +template< typename Impl > +bool +StatsAggregatorBase< Impl >::computeRegionsStatistics( real64 const timeRequest ) +{ + GEOS_MARK_FUNCTION; + + m_warnings.clear(); + + // computation of sub region stats + forRegionStatistics( [&, timeRequest] ( MeshLevel & mesh, StatsGroupType & meshRegionsStats ) + { + forRegionStatistics( mesh, + meshRegionsStats, + [&, timeRequest] ( CellElementRegion & region, StatsGroupType & regionStats ) + { + forRegionStatistics( region, + regionStats, + [&, timeRequest] ( CellElementSubRegion & subRegion, StatsGroupType & subRegionStats ) + { + initStats( subRegionStats, timeRequest ); + computeSubRegionRankStats( subRegion, subRegionStats ); + } ); + } ); + } ); + + // aggregation of computations from the sub regions + forRegionStatistics( [&, timeRequest] ( MeshLevel & mesh, StatsGroupType & meshRegionsStats ) + { + initStats( meshRegionsStats, timeRequest ); + + forRegionStatistics( mesh, + meshRegionsStats, + [&, timeRequest] ( CellElementRegion & region, StatsGroupType & regionStats ) + { + initStats( regionStats, timeRequest ); + + forRegionStatistics( region, + regionStats, + [&] ( CellElementSubRegion &, StatsGroupType & subRegionStats ) + { + aggregateStats( regionStats, subRegionStats ); + + mpiAggregateStats( subRegionStats ); + postAggregateStats( subRegionStats ); + } ); + + aggregateStats( meshRegionsStats, regionStats ); + + mpiAggregateStats( regionStats ); + postAggregateStats( regionStats ); + } ); + + mpiAggregateStats( meshRegionsStats ); + postAggregateStats( meshRegionsStats ); + } ); + + m_regionStatsState.m_isDirty = false; + + return true; +} + +template< typename Impl > +MeshLevel & +StatsAggregatorBase< Impl >::getMeshLevel( DiscretizationGroupPath const & path ) const +{ + MeshBody & body = m_meshBodies.getGroup< MeshBody >( path.m_meshBody ); + MeshLevel & mesh = body.getMeshLevel( path.m_meshLevel ); + return mesh; +} + +template< typename Impl > +dataRepository::Group & +StatsAggregatorBase< Impl >::getInstanceStatisticsGroup( MeshLevel & mesh ) const +{ + // considering everything is initialized, or else, crash gracefully + dataRepository::Group & meshStatsGroup = mesh.getGroup( ViewKeys::statisticsString() ); + dataRepository::Group & instanceStatisticsGroup = meshStatsGroup.getGroup( getOwnerName() ); + return instanceStatisticsGroup; +} + +template< typename Impl > +typename StatsAggregatorBase< Impl >::StatsGroupType & +StatsAggregatorBase< Impl >:: +getRegionsStatistics( MeshLevel & mesh ) const +{ + // considering everything is initialized, or else, crash gracefully + dataRepository::Group & instanceStatisticsGroup = getInstanceStatisticsGroup( mesh ); + return instanceStatisticsGroup.getGroup< StatsGroupType >( ViewKeys::regionsStatisticsString() ); +} + +template< typename Impl > +typename StatsAggregatorBase< Impl >::StatsGroupType & +StatsAggregatorBase< Impl >::getRegionStatistics( MeshLevel & mesh, + string_view regionName ) const +{ + StatsGroupType & meshRegionsStats = getRegionsStatistics( mesh ); + StatsGroupType * const stats = meshRegionsStats.template getGroupPointer< StatsGroupType >( string( regionName ) ); + GEOS_THROW_IF( stats == nullptr, + GEOS_FMT( "Region '{}' not found to get region statistics, is it a target of the reservoir solver?\n" + "Available target regions:\n- {}", + regionName, stringutilities::join( meshRegionsStats.getSubGroupsNames(), "\n- " ) ), + InputError, m_ownerDataContext ); + return *stats; +} + +} /* namespace geos */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/CMakeLists.txt b/src/coreComponents/physicsSolvers/fluidFlow/CMakeLists.txt index f7f31869468..5df1a8ce699 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/CMakeLists.txt +++ b/src/coreComponents/physicsSolvers/fluidFlow/CMakeLists.txt @@ -22,7 +22,8 @@ set( fluidFlowSolvers_headers FlowSolverBaseFields.hpp CompositionalMultiphaseBase.hpp CompositionalMultiphaseBaseFields.hpp - CompositionalMultiphaseStatistics.hpp + CompositionalMultiphaseStatisticsAggregator.hpp + CompositionalMultiphaseStatisticsTask.hpp CompositionalMultiphaseFVM.hpp CompositionalMultiphaseHybridFVM.hpp CompositionalMultiphaseUtilities.hpp @@ -34,7 +35,8 @@ set( fluidFlowSolvers_headers SourceFluxStatistics.hpp SinglePhaseBase.hpp SinglePhaseBaseFields.hpp - SinglePhaseStatistics.hpp + SinglePhaseStatisticsAggregator.hpp + SinglePhaseStatisticsTask.hpp SinglePhaseFVM.hpp SinglePhaseHybridFVM.hpp SinglePhaseProppantBase.hpp @@ -147,13 +149,15 @@ set( fluidFlowSolvers_headers set( fluidFlowSolvers_sources CompositionalMultiphaseBase.cpp CompositionalMultiphaseFVM.cpp - CompositionalMultiphaseStatistics.cpp + CompositionalMultiphaseStatisticsAggregator.cpp + CompositionalMultiphaseStatisticsTask.cpp CompositionalMultiphaseHybridFVM.cpp ImmiscibleMultiphaseFlow.cpp ReactiveCompositionalMultiphaseOBL.cpp FlowSolverBase.cpp SinglePhaseBase.cpp - SinglePhaseStatistics.cpp + SinglePhaseStatisticsAggregator.cpp + SinglePhaseStatisticsTask.cpp SinglePhaseFVM.cpp SinglePhaseHybridFVM.cpp SinglePhaseProppantBase.cpp diff --git a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatistics.cpp b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatistics.cpp deleted file mode 100644 index c83695e5a98..00000000000 --- a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatistics.cpp +++ /dev/null @@ -1,555 +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 CompositionalMultiphaseStatistics.cpp - */ - -#include "CompositionalMultiphaseStatistics.hpp" - -#include "mesh/DomainPartition.hpp" -#include "constitutive/fluid/multifluid/MultiFluidBase.hpp" -#include "constitutive/relativePermeability/RelativePermeabilityBase.hpp" -#include "constitutive/solid/CoupledSolidBase.hpp" -#include "physicsSolvers/LogLevelsInfo.hpp" -#include "physicsSolvers/fluidFlow/LogLevelsInfo.hpp" -#include "physicsSolvers/fluidFlow/CompositionalMultiphaseBase.hpp" -#include "physicsSolvers/fluidFlow/CompositionalMultiphaseBaseFields.hpp" -#include "physicsSolvers/fluidFlow/CompositionalMultiphaseHybridFVM.hpp" -#include "physicsSolvers/fluidFlow/FlowSolverBaseFields.hpp" -#include "physicsSolvers/fluidFlow/kernels/compositional/StatisticsKernel.hpp" -#include "common/format/table/TableData.hpp" -#include "common/format/table/TableFormatter.hpp" -#include "common/format/table/TableLayout.hpp" - - -namespace geos -{ - -using namespace constitutive; -using namespace fields; -using namespace dataRepository; - -CompositionalMultiphaseStatistics::CompositionalMultiphaseStatistics( const string & name, - Group * const parent ): - Base( name, parent ), - m_computeCFLNumbers( 0 ), - m_computeRegionStatistics( 1 ) -{ - registerWrapper( viewKeyStruct::computeCFLNumbersString(), &m_computeCFLNumbers ). - setApplyDefaultValue( 0 ). - setInputFlag( InputFlags::OPTIONAL ). - setDescription( "Flag to decide whether CFL numbers are computed or not" ); - - registerWrapper( viewKeyStruct::computeRegionStatisticsString(), &m_computeRegionStatistics ). - setApplyDefaultValue( 1 ). - setInputFlag( InputFlags::OPTIONAL ). - setDescription( "Flag to decide whether region statistics are computed or not" ); - - registerWrapper( viewKeyStruct::relpermThresholdString(), &m_relpermThreshold ). - setApplyDefaultValue( 1e-6 ). - setInputFlag( InputFlags::OPTIONAL ). - setDescription( "Flag to decide whether a phase is considered mobile (when the relperm is above the threshold) or immobile (when the relperm is below the threshold) in metric 2" ); - - addLogLevel< logInfo::CFL >(); - addLogLevel< logInfo::Statistics >(); -} - -void CompositionalMultiphaseStatistics::postInputInitialization() -{ - Base::postInputInitialization(); - - if( dynamicCast< CompositionalMultiphaseHybridFVM * >( m_solver ) && m_computeCFLNumbers != 0 ) - { - GEOS_THROW( "The option to compute CFL numbers is incompatible with CompositionalMultiphaseHybridFVM", - InputError, getDataContext() ); - } -} - -void CompositionalMultiphaseStatistics::registerDataOnMesh( Group & meshBodies ) -{ - // the fields have to be registered in "registerDataOnMesh" (and not later) - // otherwise they cannot be targeted by TimeHistory - - // for now, this guard is needed to avoid breaking the xml schema generation - if( m_solver == nullptr ) - { - return; - } - - m_solver->forDiscretizationOnMeshTargets( meshBodies, [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { - ElementRegionManager & elemManager = mesh.getElemManager(); - - integer const numPhases = m_solver->numFluidPhases(); - integer const numComps = m_solver->numFluidComponents(); - - // if we have to report region statistics, we have to register them first here - if( m_computeRegionStatistics ) - { - for( size_t i = 0; i < regionNames.size(); ++i ) - { - ElementRegionBase & region = elemManager.getRegion( regionNames[i] ); - - region.registerWrapper< RegionStatistics >( viewKeyStruct::regionStatisticsString() ). - setRestartFlags( RestartFlags::NO_WRITE ); - region.excludeWrappersFromPacking( { viewKeyStruct::regionStatisticsString() } ); - RegionStatistics & stats = region.getReference< RegionStatistics >( viewKeyStruct::regionStatisticsString() ); - - stats.phasePoreVolume.resizeDimension< 0 >( numPhases ); - stats.phaseMass.resizeDimension< 0 >( numPhases ); - stats.trappedPhaseMass.resizeDimension< 0 >( numPhases ); - stats.immobilePhaseMass.resizeDimension< 0 >( numPhases ); - stats.componentMass.resizeDimension< 0, 1 >( numPhases, numComps ); - - if( m_writeCSV > 0 && MpiWrapper::commRank() == 0 ) - { - auto addStatsValue = []( std::ostringstream & pstatsLayout, TableLayout & ptableLayout, - string const & description, string_view punit, - integer pnumPhases, integer pnumComps = 0 ) - { - for( int ip = 0; ip < pnumPhases; ++ip ) - { - if( pnumComps == 0 ) - { - pstatsLayout << description << " (phase " << ip << ") [" << punit << "]"; - } - else - { - for( int ic = 0; ic < pnumComps; ++ic ) - { - pstatsLayout << description << " (component " << ic << " / phase " << ip << ") [" << punit << "]"; - if( ic == 0 ) - { - pstatsLayout << ","; - } - } - } - if( ip == 0 ) - { - pstatsLayout << ","; - } - } - - ptableLayout.addColumn( pstatsLayout.str()); - pstatsLayout.str( "" ); - }; - - string_view massUnit = units::getSymbol( m_solver->getMassUnit() ); - - TableLayout tableLayout( { - TableLayout::Column().setName( GEOS_FMT( "Time [{}]", units::getSymbol( units::Unit::Time ))), - TableLayout::Column().setName( GEOS_FMT( "Min pressure [{}]", units::getSymbol( units::Unit::Pressure ))), - TableLayout::Column().setName( GEOS_FMT( "Average pressure [{}]", units::getSymbol( units::Unit::Pressure )) ), - TableLayout::Column().setName( GEOS_FMT( "Max pressure [{}]", units::getSymbol( units::Unit::Pressure ) ) ), - TableLayout::Column().setName( GEOS_FMT( "Min delta pressure [{}]", units::getSymbol( units::Unit::Pressure ))), - TableLayout::Column().setName( GEOS_FMT( "Max delta pressure [{}]", units::getSymbol( units::Unit::Pressure ))), - TableLayout::Column().setName( GEOS_FMT( "Min temperature [{}]", units::getSymbol( units::Unit::Temperature ) )), - TableLayout::Column().setName( GEOS_FMT( "Average temperature [{}]", units::getSymbol( units::Unit::Temperature ) )), - TableLayout::Column().setName( GEOS_FMT( "Max temperature [{}]", units::getSymbol( units::Unit::Temperature ) )), - TableLayout::Column().setName( GEOS_FMT( "Total dynamic pore volume [{}]", units::getSymbol( units::Unit::ReservoirVolume ) )), - } ); - - std::ostringstream statsLayout; - addStatsValue( statsLayout, tableLayout, "Phase dynamic pore volume", "rm^3", numPhases ); - addStatsValue( statsLayout, tableLayout, "Phase mass", massUnit, numPhases ); - addStatsValue( statsLayout, tableLayout, "Trapped phase mass (metric 1)", massUnit, numPhases ); - addStatsValue( statsLayout, tableLayout, "Non-trapped phase mass (metric 1)", massUnit, numPhases ); - addStatsValue( statsLayout, tableLayout, "Immobile phase mass (metric 2)", massUnit, numPhases ); - addStatsValue( statsLayout, tableLayout, "Mobile phase mass (metric 2)", massUnit, numPhases ); - addStatsValue( statsLayout, tableLayout, "Component mass", massUnit, numPhases, numComps ); - - std::ofstream outputFile( m_outputDir + "/" + regionNames[i] + ".csv" ); - TableCSVFormatter csvFormatter( tableLayout ); - outputFile << csvFormatter.headerToString(); - } - } - } - } ); - - // if we have to compute CFL numbers later, we need to register additional variables - if( m_computeCFLNumbers ) - { - m_solver->registerDataForCFL( meshBodies ); - } -} - -bool CompositionalMultiphaseStatistics::execute( real64 const time_n, - real64 const dt, - integer const GEOS_UNUSED_PARAM( cycleNumber ), - integer const GEOS_UNUSED_PARAM( eventCounter ), - real64 const GEOS_UNUSED_PARAM( eventProgress ), - DomainPartition & domain ) -{ - m_solver->forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { - if( m_computeRegionStatistics ) - { - // current time is time_n + dt - computeRegionStatistics( time_n + dt, mesh, regionNames ); - } - } ); - - if( m_computeCFLNumbers ) - { - // current time is time_n + dt - computeCFLNumbers( time_n + dt, dt, domain ); - } - - return false; -} - -void CompositionalMultiphaseStatistics::computeRegionStatistics( real64 const time, - MeshLevel & mesh, - string_array const & regionNames ) const -{ - GEOS_MARK_FUNCTION; - - integer const numPhases = m_solver->numFluidPhases(); - integer const numComps = m_solver->numFluidComponents(); - - // Step 1: initialize the average/min/max quantities - ElementRegionManager & elemManager = mesh.getElemManager(); - for( size_t i = 0; i < regionNames.size(); ++i ) - { - ElementRegionBase & region = elemManager.getRegion( regionNames[i] ); - RegionStatistics & stats = region.getReference< RegionStatistics >( viewKeyStruct::regionStatisticsString() ); - - stats.averagePressure = 0.0; - stats.maxPressure = 0.0; - stats.minPressure = LvArray::NumericLimits< real64 >::max; - - stats.maxDeltaPressure = -LvArray::NumericLimits< real64 >::max; - stats.minDeltaPressure = LvArray::NumericLimits< real64 >::max; - - stats.averageTemperature = 0.0; - stats.maxTemperature = 0.0; - stats.minTemperature = LvArray::NumericLimits< real64 >::max; - - stats.totalPoreVolume = 0.0; - stats.totalUncompactedPoreVolume = 0.0; - stats.phasePoreVolume.setValues< serialPolicy >( 0.0 ); - - stats.phaseMass.setValues< serialPolicy >( 0.0 ); - stats.trappedPhaseMass.setValues< serialPolicy >( 0.0 ); - stats.immobilePhaseMass.setValues< serialPolicy >( 0.0 ); - stats.componentMass.setValues< serialPolicy >( 0.0 ); - } - - // Step 2: increment the average/min/max quantities for all the subRegions - elemManager.forElementSubRegions( regionNames, [&]( localIndex const, - ElementSubRegionBase & subRegion ) - { - - arrayView1d< integer const > const elemGhostRank = subRegion.ghostRank(); - arrayView1d< real64 const > const volume = subRegion.getElementVolume(); - arrayView1d< real64 const > const pres = subRegion.getField< flow::pressure >(); - arrayView1d< real64 const > const temp = subRegion.getField< flow::temperature >(); - arrayView2d< real64 const, compflow::USD_PHASE > const phaseVolFrac = - subRegion.getField< flow::phaseVolumeFraction >(); - arrayView1d< real64 const > const deltaPres = subRegion.getField< flow::deltaPressure >(); - - Group const & constitutiveModels = subRegion.getGroup( ElementSubRegionBase::groupKeyStruct::constitutiveModelsString() ); - - string const & solidName = subRegion.getReference< string >( CompositionalMultiphaseBase::viewKeyStruct::solidNamesString() ); - CoupledSolidBase const & solid = constitutiveModels.getGroup< CoupledSolidBase >( solidName ); - arrayView1d< real64 const > const refPorosity = solid.getReferencePorosity(); - arrayView2d< real64 const > const porosity = solid.getPorosity(); - - string const & fluidName = subRegion.getReference< string >( CompositionalMultiphaseBase::viewKeyStruct::fluidNamesString() ); - MultiFluidBase const & fluid = constitutiveModels.getGroup< MultiFluidBase >( fluidName ); - arrayView3d< real64 const, multifluid::USD_PHASE > const phaseDensity = fluid.phaseDensity(); - arrayView4d< real64 const, multifluid::USD_PHASE_COMP > const phaseCompFraction = fluid.phaseCompFraction(); - - - //get min vol fraction for each phase to dispactche immobile/mobile mass - string const & relpermName = subRegion.getReference< string >( CompositionalMultiphaseBase::viewKeyStruct::relPermNamesString() ); - RelativePermeabilityBase const & relperm = constitutiveModels.getGroup< RelativePermeabilityBase >( relpermName ); - arrayView3d< real64 const, relperm::USD_RELPERM > const phaseTrappedVolFrac = relperm.phaseTrappedVolFraction(); - arrayView3d< real64 const, relperm::USD_RELPERM > const phaseRelperm = relperm.phaseRelPerm(); - - real64 subRegionAvgPresNumerator = 0.0; - real64 subRegionMinPres = 0.0; - real64 subRegionMaxPres = 0.0; - real64 subRegionMinDeltaPres = 0.0; - real64 subRegionMaxDeltaPres = 0.0; - real64 subRegionAvgTempNumerator = 0.0; - real64 subRegionMinTemp = 0.0; - real64 subRegionMaxTemp = 0.0; - real64 subRegionTotalUncompactedPoreVol = 0.0; - array1d< real64 > subRegionPhaseDynamicPoreVol( numPhases ); - array1d< real64 > subRegionPhaseMass( numPhases ); - array1d< real64 > subRegionTrappedPhaseMass( numPhases ); - array1d< real64 > subRegionImmobilePhaseMass( numPhases ); - array1d< real64 > subRegionRelpermPhaseMass( numPhases ); - array2d< real64 > subRegionComponentMass( numPhases, numComps ); - - isothermalCompositionalMultiphaseBaseKernels:: - StatisticsKernel:: - launch< parallelDevicePolicy<> >( subRegion.size(), - numComps, - numPhases, - m_relpermThreshold, - elemGhostRank, - volume, - pres, - deltaPres, - temp, - refPorosity, - porosity, - phaseDensity, - phaseCompFraction, - phaseVolFrac, - phaseTrappedVolFrac, - phaseRelperm, - subRegionMinPres, - subRegionAvgPresNumerator, - subRegionMaxPres, - subRegionMinDeltaPres, - subRegionMaxDeltaPres, - subRegionMinTemp, - subRegionAvgTempNumerator, - subRegionMaxTemp, - subRegionTotalUncompactedPoreVol, - subRegionPhaseDynamicPoreVol.toView(), - subRegionPhaseMass.toView(), - subRegionTrappedPhaseMass.toView(), - subRegionImmobilePhaseMass.toView(), - subRegionComponentMass.toView() ); - - ElementRegionBase & region = elemManager.getRegion( ElementRegionBase::getParentRegion( subRegion ).getName() ); - RegionStatistics & stats = region.getReference< RegionStatistics >( viewKeyStruct::regionStatisticsString() ); - - stats.averagePressure += subRegionAvgPresNumerator; - if( subRegionMinPres < stats.minPressure ) - { - stats.minPressure = subRegionMinPres; - } - if( subRegionMaxPres > stats.maxPressure ) - { - stats.maxPressure = subRegionMaxPres; - } - - if( subRegionMinDeltaPres < stats.minDeltaPressure ) - { - stats.minDeltaPressure = subRegionMinDeltaPres; - } - if( subRegionMaxDeltaPres > stats.maxDeltaPressure ) - { - stats.maxDeltaPressure = subRegionMaxDeltaPres; - } - - stats.averageTemperature += subRegionAvgTempNumerator; - if( subRegionMinTemp < stats.minTemperature ) - { - stats.minTemperature = subRegionMinTemp; - } - if( subRegionMaxTemp > stats.maxTemperature ) - { - stats.maxTemperature = subRegionMaxTemp; - } - - stats.totalUncompactedPoreVolume += subRegionTotalUncompactedPoreVol; - for( integer ip = 0; ip < numPhases; ++ip ) - { - stats.phasePoreVolume[ip] += subRegionPhaseDynamicPoreVol[ip]; - stats.phaseMass[ip] += subRegionPhaseMass[ip]; - stats.trappedPhaseMass[ip] += subRegionTrappedPhaseMass[ip]; - stats.immobilePhaseMass[ip] += subRegionImmobilePhaseMass[ip]; - - for( integer ic = 0; ic < numComps; ++ic ) - { - stats.componentMass[ip][ic] += subRegionComponentMass[ip][ic]; - } - } - - } ); - - // Step 3: synchronize the results over the MPI ranks - for( size_t i = 0; i < regionNames.size(); ++i ) - { - ElementRegionBase & region = elemManager.getRegion( regionNames[i] ); - RegionStatistics & stats = region.getReference< RegionStatistics >( viewKeyStruct::regionStatisticsString() ); - - stats.minPressure = MpiWrapper::min( stats.minPressure ); - stats.maxPressure = MpiWrapper::max( stats.maxPressure ); - stats.minDeltaPressure = MpiWrapper::min( stats.minDeltaPressure ); - stats.maxDeltaPressure = MpiWrapper::max( stats.maxDeltaPressure ); - stats.minTemperature = MpiWrapper::min( stats.minTemperature ); - stats.maxTemperature = MpiWrapper::max( stats.maxTemperature ); - stats.totalUncompactedPoreVolume = MpiWrapper::sum( stats.totalUncompactedPoreVolume ); - stats.totalPoreVolume = 0.0; - for( integer ip = 0; ip < numPhases; ++ip ) - { - stats.phasePoreVolume[ip] = MpiWrapper::sum( stats.phasePoreVolume[ip] ); - stats.phaseMass[ip] = MpiWrapper::sum( stats.phaseMass[ip] ); - stats.trappedPhaseMass[ip] = MpiWrapper::sum( stats.trappedPhaseMass[ip] ); - stats.immobilePhaseMass[ip] = MpiWrapper::sum( stats.immobilePhaseMass[ip] ); - stats.totalPoreVolume += stats.phasePoreVolume[ip]; - for( integer ic = 0; ic < numComps; ++ic ) - { - stats.componentMass[ip][ic] = MpiWrapper::sum( stats.componentMass[ip][ic] ); - } - } - stats.averagePressure = MpiWrapper::sum( stats.averagePressure ); - stats.averageTemperature = MpiWrapper::sum( stats.averageTemperature ); - if( stats.totalUncompactedPoreVolume > 0 ) - { - float invTotalUncompactedPoreVolume = 1.0 / stats.totalUncompactedPoreVolume; - stats.averagePressure *= invTotalUncompactedPoreVolume; - stats.averageTemperature *= invTotalUncompactedPoreVolume; - } - else - { - stats.averagePressure = 0.0; - stats.averageTemperature = 0.0; - GEOS_LOG_LEVEL_RANK_0( logInfo::Statistics, - GEOS_FMT( "{}, {}: Cannot compute average pressure because region pore volume is zero.", - getName(), regionNames[i] ) ); - } - - - // helpers to report statistics - array1d< real64 > nonTrappedPhaseMass( numPhases ); - array1d< real64 > mobilePhaseMass( numPhases ); - for( integer ip = 0; ip < numPhases; ++ip ) - { - nonTrappedPhaseMass[ip] = stats.phaseMass[ip] - stats.trappedPhaseMass[ip]; - mobilePhaseMass[ip] = stats.phaseMass[ip] - stats.immobilePhaseMass[ip]; - } - - string_view massUnit = units::getSymbol( m_solver->getMassUnit() ); - - stdVector< string > phaseCompName; - phaseCompName.reserve( numPhases*numComps ); - stdVector< string > massValues; - phaseCompName.reserve( numPhases*numComps ); - - ConstitutiveManager const & constitutiveManager = this->getGroupByPath< ConstitutiveManager >( "/Problem/domain/Constitutive" ); - MultiFluidBase const & fluid = constitutiveManager.getGroup< MultiFluidBase >( m_solver->referenceFluidModelName() ); - auto const phaseNames = fluid.phaseNames(); - auto const componentNames = fluid.componentNames(); - for( integer ip = 0; ip < numPhases; ++ip ) - { - for( integer ic = 0; ic < numComps; ++ic ) - { - std::stringstream ss; - ss << phaseNames[ip] << "/" << componentNames[ic]; - phaseCompName.push_back( ss.str() ); - massValues.push_back( GEOS_FMT( "{}", stats.componentMass[ip][ic] ) ); - } - } - - if( isLogLevelActive< logInfo::Statistics >( this->getLogLevel() ) && MpiWrapper::commRank() == 0 ) - { - TableData compPhaseStatsData; - compPhaseStatsData.addRow( "Pressure [Pa]", stats.minPressure, stats.averagePressure, stats.maxPressure ); - compPhaseStatsData.addRow( "Delta pressure [Pa]", stats.minDeltaPressure, "/", stats.maxDeltaPressure ); - compPhaseStatsData.addRow( "Temperature [K]", stats.minTemperature, stats.averageTemperature, stats.maxTemperature ); - compPhaseStatsData.addSeparator(); - - compPhaseStatsData.addRow( "Total dynamic pore volume [rm^3]", CellType::MergeNext, CellType::MergeNext, stats.totalPoreVolume ); - compPhaseStatsData.addSeparator(); - compPhaseStatsData.addRow( "Phase dynamic pore volume [rm^3]", - stringutilities::joinLambda( phaseNames, "\n", []( auto data ) { return data[0]; } ), - CellType::MergeNext, - stringutilities::joinLambda( stats.phasePoreVolume, "\n", []( auto data ) { return data[0]; } ) ); - compPhaseStatsData.addSeparator(); - - compPhaseStatsData.addRow( GEOS_FMT( "Phase mass [{}]", massUnit ), - stringutilities::joinLambda( phaseNames, "\n", []( auto data ) { return data[0]; } ), - CellType::MergeNext, - stringutilities::joinLambda( stats.phaseMass, "\n", []( auto data ) { return data[0]; } ) ); - compPhaseStatsData.addSeparator(); - - compPhaseStatsData.addRow( GEOS_FMT( "Trapped phase mass (metric 1) [{}]", massUnit ), - stringutilities::joinLambda( phaseNames, "\n", []( auto value ) { return value[0]; } ), - CellType::MergeNext, - stringutilities::joinLambda( stats.trappedPhaseMass, "\n", []( auto value ) { return value[0]; } ) ); - compPhaseStatsData.addSeparator(); - compPhaseStatsData.addRow( GEOS_FMT( "Non-trapped phase mass (metric 1) [{}]", massUnit ), - stringutilities::joinLambda( phaseNames, "\n", []( auto value ) { return value[0]; } ), - CellType::MergeNext, - stringutilities::joinLambda( nonTrappedPhaseMass, "\n", []( auto value ) { return value[0]; } ) ); - compPhaseStatsData.addSeparator(); - - compPhaseStatsData.addRow( GEOS_FMT( "Immobile phase mass (metric 2) [{}]", massUnit ), - stringutilities::joinLambda( phaseNames, "\n", []( auto value ) { return value[0]; } ), - CellType::MergeNext, - stringutilities::joinLambda( stats.immobilePhaseMass, "\n", []( auto value ) { return value[0]; } ) ); - compPhaseStatsData.addSeparator(); - compPhaseStatsData.addRow( GEOS_FMT( "Mobile phase mass (metric 2) [{}]", massUnit ), - stringutilities::joinLambda( phaseNames, "\n", []( auto value ) { return value[0]; } ), - CellType::MergeNext, - stringutilities::joinLambda( mobilePhaseMass, "\n", []( auto value ) { return value[0]; } ) ); - compPhaseStatsData.addSeparator(); - - compPhaseStatsData.addRow( GEOS_FMT( "Component mass [{}]", massUnit ), - stringutilities::join( phaseCompName, '\n' ), - CellType::MergeNext, - stringutilities::join( massValues, '\n' ) ); - - string const title = GEOS_FMT( "{}, {} (time {} s):", getName(), regionNames[i], time ); - TableLayout const compPhaseStatsLayout( title, { "statistics", "min", "average", "max" } ); - TableTextFormatter tableFormatter( compPhaseStatsLayout ); - GEOS_LOG_RANK_0( tableFormatter.toString( compPhaseStatsData ) ); - } - - if( m_writeCSV > 0 && MpiWrapper::commRank() == 0 ) - { - TableData tableData; - tableData.addRow( time, stats.minPressure, stats.averagePressure, stats.maxPressure, stats.minDeltaPressure, stats.maxDeltaPressure, - stats.minTemperature, stats.averageTemperature, stats.maxTemperature, stats.totalPoreVolume, - stringutilities::joinLambda( stats.phasePoreVolume, "\n", []( auto data ) { return data[0]; } ), - stringutilities::joinLambda( stats.phaseMass, "\n", []( auto data ) { return data[0]; } ), - stringutilities::joinLambda( stats.trappedPhaseMass, "\n", []( auto value ) { return value[0]; } ), - stringutilities::joinLambda( nonTrappedPhaseMass, "\n", []( auto value ) { return value[0]; } ), - stringutilities::joinLambda( stats.immobilePhaseMass, "\n", []( auto value ) { return value[0]; } ), - stringutilities::joinLambda( mobilePhaseMass, "\n", []( auto value ) { return value[0]; } ), - stringutilities::join( massValues, '\n' ) ); - - std::ofstream outputFile( m_outputDir + "/" + regionNames[i] + ".csv", std::ios_base::app ); - TableCSVFormatter const csvOutput; - outputFile << csvOutput.dataToString( tableData ); - outputFile.close(); - } - } - -} - -void CompositionalMultiphaseStatistics::computeCFLNumbers( real64 const time, - real64 const dt, - DomainPartition & domain ) const -{ - GEOS_MARK_FUNCTION; - real64 maxPhaseCFL, maxCompCFL; - m_solver->computeCFLNumbers( domain, dt, maxPhaseCFL, maxCompCFL ); - - GEOS_LOG_LEVEL_RANK_0( logInfo::CFL, - GEOS_FMT( "{} (time {} s): Max phase CFL number: {}", getName(), time, maxPhaseCFL ) ); - GEOS_LOG_LEVEL_RANK_0( logInfo::CFL, - GEOS_FMT( "{} (time {} s): Max component CFL number: {}", getName(), time, maxCompCFL ) ); -} - - -REGISTER_CATALOG_ENTRY( TaskBase, - CompositionalMultiphaseStatistics, - string const &, dataRepository::Group * const ) - -} /* namespace geos */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsAggregator.cpp b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsAggregator.cpp new file mode 100644 index 00000000000..c9a0826da47 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsAggregator.cpp @@ -0,0 +1,397 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 CompositionalMultiphaseStatistics.cpp + * @details Region statistics data is stored as follow: + + * Problem : ProblemManager + * |-> domain : DomainPartition + * |-> MeshBodies : Group + * |-> cartesianMesh : MeshBody + * |-> meshLevels : Group + * |-> Level0 : MeshLevel + * | |-> nodeManager : NodeManager + * | | |-> sets : Group + * | | | * all : Wrapper< index array > + * | | | * xneg : Wrapper< index array > + * | | [...] (other element sets) + * | | + * | |-> ElementRegions : ElementRegionManager + * | | |-> Channel : CellElementRegion + * | | | |-> cb-0_0_0 : CellElementSubRegion + * | | | | | * pressure : Wrapper< real64 array > + * | | | | | * temperature : Wrapper< real64 array > + * | | | | [...] (other fields) + * | | | | + * | | | |-> cb-0_0_1 : CellElementSubRegion + * | | | | | * pressure : Wrapper< real64 array > + * | | | | | * temperature : Wrapper< real64 array > + * | | | | [...] (other fields) + * | | | | + * | | | [...] (other sub-regions) + * | | | + * | | |-> Barrier : CellElementRegion + * | | |-> cb-1_0_0 : CellElementSubRegion + * | | |-> cb-1_0_1 : CellElementSubRegion + * | | [...] (other sub-regions) + * | | + * | [...] (other element managers) + * ____ | | + * | | |-> statistics : Group (storage for all stats) + * | | |-> compFlowStats : Group (storage for this instance stats) + * | | | |-> cflStatistics : CFLStatistics + * | | | |-> regionsStatistics : RegionStatistics (aggregate) + * | | | |-> Channel : RegionStatistics (aggregate, mpi reduced) + * | | | | |-> cb-0_0_0 : RegionStatistics (compute read-back) + * stats | | | | |-> cb-0_0_1 : RegionStatistics (compute read-back) + * data -> | | | | [...] (other sub-regions stats) + * | | | | + * | | | |-> Barrier : RegionStatistics (aggregate, mpi reduced) + * | | | |-> cb-1_0_0 : RegionStatistics (compute read-back) + * | | | |-> cb-1_0_1 : RegionStatistics (compute read-back) + * | | | [...] (other sub-regions stats) + * | | | + * |___ | [...] (other stats storages) + * | + * [...] (other discretizations) + */ + +#include "CompositionalMultiphaseStatisticsAggregator.hpp" + +#include "physicsSolvers/StatisticsAggregatorBaseHelpers.hpp" +#include "mesh/DomainPartition.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseBase.hpp" +#include "physicsSolvers/fluidFlow/kernels/compositional/StatisticsKernel.hpp" +#include "constitutive/relativePermeability/RelativePermeabilityBase.hpp" + +namespace geos +{ + +using namespace constitutive; +using namespace dataRepository; + +namespace compositionalMultiphaseStatistics +{ + +RegionStatistics::RegionStatistics( string const & name, + dataRepository::Group * const parent, + bool statsOutputEnabled, + integer const numPhases, + integer const numComponents ): + RegionStatisticsBase( name, parent, statsOutputEnabled ), + m_phaseDynamicPoreVolume( numPhases ), + m_phaseMass( numPhases ), + m_trappedPhaseMass( numPhases ), + m_nonTrappedPhaseMass( numPhases ), + m_immobilePhaseMass( numPhases ), + m_mobilePhaseMass( numPhases ), + m_componentMass( numPhases, numComponents ) +{ + // TODO : registerWrappers to store results in HDF5 (but need repairing of 1D HDF5 outputs) +} + +CFLStatistics::CFLStatistics( string const & name, + dataRepository::Group * const parent, + bool const statsOutputEnabled ): + RegionStatisticsBase( name, parent, statsOutputEnabled ) +{ + // TODO : registerWrappers to store results in HDF5 (but need repairing of 1D HDF5 outputs) +} + +StatsAggregator::StatsAggregator( DataContext const & ownerDataContext, + dataRepository::Group & meshBodies, + bool const statsOutputEnabled ): + Base( ownerDataContext, meshBodies, statsOutputEnabled ), + m_params() +{} + +void StatsAggregator::initStatisticsAggregation( CompositionalMultiphaseBase & solver ) +{ + m_solver = &solver; + m_numPhases = solver.numFluidPhases(); + m_numComponents = solver.numFluidComponents(); + + Base::initStatisticsAggregation( solver ); +} + +void StatsAggregator::enableRegionStatisticsAggregation() +{ + auto const registerStats = [=] ( Group & parent, + string const & targetName ) -> RegionStatistics & + { + return parent.registerGroup( targetName, + std::make_unique< RegionStatistics >( targetName, + &parent, + m_statsOutputEnabled, + m_numPhases, + m_numComponents ) ); + }; + + Base::enableRegionStatisticsAggregation( registerStats ); +} + +void StatsAggregator::enableCFLStatistics() +{ + if( m_solver == nullptr ) + return; + + m_solver->registerDataForCFL( m_meshBodies ); + for( auto const & path : m_discretizationsPaths ) + { + MeshLevel & mesh = getMeshLevel( path ); + Group & statisticsGroup = getInstanceStatisticsGroup( mesh ); + auto const cflStatsName = ViewKeys::cflStatisticsString(); + statisticsGroup.registerGroup< CFLStatistics >( cflStatsName, + std::make_unique< CFLStatistics >( cflStatsName, + &statisticsGroup, + m_statsOutputEnabled ) ); + } + + m_cflStatsState.m_isEnabled = true; + m_cflStatsState.m_isDirty = true; +} + +void StatsAggregator::setDirty() +{ + Base::setDirty(); + m_cflStatsState.m_isDirty = true; +} + +bool StatsAggregator::computeCFLNumbers( real64 const time, + real64 const dt, + DomainPartition & domain ) +{ + GEOS_MARK_FUNCTION; + real64 maxPhaseCFL, maxCompCFL; + CFLStatistics * stats = getCFLStatistics( domain ); + + m_warnings.clear(); + + if( !m_cflStatsState.m_isEnabled ) + { + m_warnings.emplace_back( "CFL numbers computation is not enabled." ); + return false; + } + if( stats == nullptr ) + { + m_warnings.emplace_back( GEOS_FMT( "No statistics structure to compute CFL numbers for domain '{}'.", domain.getName() )); + return false; + } + + m_solver->computeCFLNumbers( domain, dt, maxPhaseCFL, maxCompCFL ); + + stats->m_time = time; + stats->m_maxPhaseCFL = maxPhaseCFL; + stats->m_maxCompCFL = maxCompCFL; + + m_cflStatsState.m_isDirty = false; + + return true; +} + +CFLStatistics * StatsAggregator::getCFLStatistics( DomainPartition & domain ) const +{ + return domain.getGroupPointer< CFLStatistics >( ViewKeys::cflStatisticsString() ); +} + +CFLStatistics & StatsAggregator::getCflStatistics( MeshLevel & mesh ) const +{ + // considering everything is initialized, or else, crash gracefully + Group & statisticsGroup = getInstanceStatisticsGroup( mesh ); + return statisticsGroup.getGroup< CFLStatistics >( ViewKeys::cflStatisticsString() ); +} + +void StatsAggregator::initStats( RegionStatistics & stats, real64 const time ) const +{ + stats.m_time = time; + + stats.m_averagePressure = 0.0; + stats.m_maxPressure = 0.0; + stats.m_minPressure = LvArray::NumericLimits< real64 >::max; + + stats.m_maxDeltaPressure = -LvArray::NumericLimits< real64 >::max; + stats.m_minDeltaPressure = LvArray::NumericLimits< real64 >::max; + + stats.m_averageTemperature = 0.0; + stats.m_maxTemperature = 0.0; + stats.m_minTemperature = LvArray::NumericLimits< real64 >::max; + + stats.m_totalMass = 0.0; + + stats.m_totalPoreVolume = 0.0; + stats.m_totalUncompactedPoreVolume = 0.0; + stats.m_phaseDynamicPoreVolume.setValues< serialPolicy >( 0.0 ); + + stats.m_phaseMass.setValues< serialPolicy >( 0.0 ); + stats.m_trappedPhaseMass.setValues< serialPolicy >( 0.0 ); + stats.m_nonTrappedPhaseMass.setValues< serialPolicy >( 0.0 ); + stats.m_immobilePhaseMass.setValues< serialPolicy >( 0.0 ); + stats.m_mobilePhaseMass.setValues< serialPolicy >( 0.0 ); + stats.m_componentMass.setValues< serialPolicy >( 0.0 ); +} + +void StatsAggregator::computeSubRegionRankStats( CellElementSubRegion & subRegion, + RegionStatistics & subRegionStats ) const +{ + arrayView1d< integer const > const elemGhostRank = subRegion.ghostRank(); + arrayView1d< real64 const > const volume = subRegion.getElementVolume(); + arrayView1d< real64 const > const pres = subRegion.getField< fields::flow::pressure >(); + arrayView1d< real64 const > const temp = subRegion.getField< fields::flow::temperature >(); + arrayView2d< real64 const, compflow::USD_PHASE > const phaseVolFrac = + subRegion.getField< fields::flow::phaseVolumeFraction >(); + arrayView1d< real64 const > const deltaPres = subRegion.getField< fields::flow::deltaPressure >(); + + Group const & constitutiveModels = subRegion.getGroup( ElementSubRegionBase::groupKeyStruct::constitutiveModelsString() ); + + string const & solidName = subRegion.getReference< string >( CompositionalMultiphaseBase::viewKeyStruct::solidNamesString() ); + CoupledSolidBase const & solid = constitutiveModels.getGroup< CoupledSolidBase >( solidName ); + arrayView1d< real64 const > const refPorosity = solid.getReferencePorosity(); + arrayView2d< real64 const > const porosity = solid.getPorosity(); + + string const & fluidName = subRegion.getReference< string >( CompositionalMultiphaseBase::viewKeyStruct::fluidNamesString() ); + MultiFluidBase const & fluid = constitutiveModels.getGroup< MultiFluidBase >( fluidName ); + arrayView3d< real64 const, multifluid::USD_PHASE > const phaseDensity = fluid.phaseDensity(); + arrayView4d< real64 const, multifluid::USD_PHASE_COMP > const phaseCompFraction = fluid.phaseCompFraction(); + + //get min vol fraction for each phase to dispactche immobile/mobile mass + string const & relpermName = subRegion.getReference< string >( CompositionalMultiphaseBase::viewKeyStruct::relPermNamesString() ); + RelativePermeabilityBase const & relperm = constitutiveModels.getGroup< RelativePermeabilityBase >( relpermName ); + arrayView3d< real64 const, relperm::USD_RELPERM > const phaseTrappedVolFrac = relperm.phaseTrappedVolFraction(); + arrayView3d< real64 const, relperm::USD_RELPERM > const phaseRelperm = relperm.phaseRelPerm(); + + isothermalCompositionalMultiphaseBaseKernels:: + StatisticsKernel:: + launch< parallelDevicePolicy<> >( subRegion.size(), + m_numComponents, + m_numPhases, + m_params.m_relpermThreshold, + elemGhostRank, + volume, + pres, + deltaPres, + temp, + refPorosity, + porosity, + phaseDensity, + phaseCompFraction, + phaseVolFrac, + phaseTrappedVolFrac, + phaseRelperm, + subRegionStats.m_minPressure, + subRegionStats.m_averagePressure, + subRegionStats.m_maxPressure, + subRegionStats.m_minDeltaPressure, + subRegionStats.m_maxDeltaPressure, + subRegionStats.m_minTemperature, + subRegionStats.m_averageTemperature, + subRegionStats.m_maxTemperature, + subRegionStats.m_totalUncompactedPoreVolume, + subRegionStats.m_phaseDynamicPoreVolume.toView(), + subRegionStats.m_phaseMass.toView(), + subRegionStats.m_trappedPhaseMass.toView(), + subRegionStats.m_immobilePhaseMass.toView(), + subRegionStats.m_componentMass.toView() ); +} + +void StatsAggregator::aggregateStats( RegionStatistics & stats, + RegionStatistics const & other ) const +{ + stats.m_averagePressure += other.m_averagePressure; + stats.m_minPressure = LvArray::math::min( stats.m_minPressure, other.m_minPressure ); + stats.m_maxPressure = LvArray::math::max( stats.m_maxPressure, other.m_maxPressure ); + + stats.m_minDeltaPressure = LvArray::math::min( stats.m_minDeltaPressure, other.m_minDeltaPressure ); + stats.m_maxDeltaPressure = LvArray::math::max( stats.m_maxDeltaPressure, other.m_maxDeltaPressure ); + + stats.m_averageTemperature += other.m_averageTemperature; + stats.m_minTemperature = LvArray::math::min( stats.m_minTemperature, other.m_minTemperature ); + stats.m_maxTemperature = LvArray::math::max( stats.m_maxTemperature, other.m_maxTemperature ); + + stats.m_totalUncompactedPoreVolume += other.m_totalUncompactedPoreVolume; + + for( integer ip = 0; ip < m_numPhases; ++ip ) + { + stats.m_phaseDynamicPoreVolume[ip] += other.m_phaseDynamicPoreVolume[ip]; + stats.m_phaseMass[ip] += other.m_phaseMass[ip]; + stats.m_trappedPhaseMass[ip] += other.m_trappedPhaseMass[ip]; + stats.m_immobilePhaseMass[ip] += other.m_immobilePhaseMass[ip]; + + for( integer ic = 0; ic < m_numComponents; ++ic ) + { + stats.m_componentMass[ip][ic] += other.m_componentMass[ip][ic]; + } + } +} + +void StatsAggregator::mpiAggregateStats( RegionStatistics & stats ) const +{ + stats.m_averagePressure = MpiWrapper::sum( stats.m_averagePressure ); + stats.m_minPressure = MpiWrapper::min( stats.m_minPressure ); + stats.m_maxPressure = MpiWrapper::max( stats.m_maxPressure ); + + stats.m_minDeltaPressure = MpiWrapper::min( stats.m_minDeltaPressure ); + stats.m_maxDeltaPressure = MpiWrapper::max( stats.m_maxDeltaPressure ); + + stats.m_averageTemperature = MpiWrapper::sum( stats.m_averageTemperature ); + stats.m_minTemperature = MpiWrapper::min( stats.m_minTemperature ); + stats.m_maxTemperature = MpiWrapper::max( stats.m_maxTemperature ); + + stats.m_totalUncompactedPoreVolume = MpiWrapper::sum( stats.m_totalUncompactedPoreVolume ); + + for( integer ip = 0; ip < m_numPhases; ++ip ) + { + stats.m_phaseDynamicPoreVolume[ip] = MpiWrapper::sum( stats.m_phaseDynamicPoreVolume[ip] ); + stats.m_phaseMass[ip] = MpiWrapper::sum( stats.m_phaseMass[ip] ); + stats.m_trappedPhaseMass[ip] = MpiWrapper::sum( stats.m_trappedPhaseMass[ip] ); + stats.m_immobilePhaseMass[ip] = MpiWrapper::sum( stats.m_immobilePhaseMass[ip] ); + + for( integer ic = 0; ic < m_numComponents; ++ic ) + { + stats.m_componentMass[ip][ic] = MpiWrapper::sum( stats.m_componentMass[ip][ic] ); + } + } +} + +void StatsAggregator::postAggregateStats( RegionStatistics & stats ) +{ + if( stats.m_totalUncompactedPoreVolume > 0 ) + { + float invTotalUncompactedPoreVolume = 1.0 / stats.m_totalUncompactedPoreVolume; + stats.m_averagePressure *= invTotalUncompactedPoreVolume; + stats.m_averageTemperature *= invTotalUncompactedPoreVolume; + } + else + { + stats.m_averagePressure = 0.0; + stats.m_averageTemperature = 0.0; + m_warnings.emplace_back( GEOS_FMT( "Cannot compute average pressure for '{}' because pore volume is zero in '{}'.", + getOwnerName(), stats.getTargetName() ) ); + } + + for( integer ip = 0; ip < m_numPhases; ++ip ) + { + stats.m_totalMass += stats.m_phaseMass[ip]; + stats.m_totalPoreVolume += stats.m_phaseDynamicPoreVolume[ip]; + stats.m_nonTrappedPhaseMass[ip] = stats.m_phaseMass[ip] - stats.m_trappedPhaseMass[ip]; + stats.m_mobilePhaseMass[ip] = stats.m_phaseMass[ip] - stats.m_immobilePhaseMass[ip]; + } +} + +} /* namespace compositionalMultiphaseStatistics */ + +template class StatsAggregatorBase< compositionalMultiphaseStatistics::StatsAggregator >; + +} /* namespace geos */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsAggregator.hpp b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsAggregator.hpp new file mode 100644 index 00000000000..e027122ebcb --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsAggregator.hpp @@ -0,0 +1,314 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 CompositionalMultiphaseStatisticsAggregator.hpp + * @details Region statistics data is stored as follow: + + * Problem : ProblemManager + * |-> domain : DomainPartition + * |-> MeshBodies : Group + * |-> cartesianMesh : MeshBody + * |-> meshLevels : Group + * |-> Level0 : MeshLevel + * | |-> nodeManager : NodeManager + * | | |-> sets : Group + * | | | * all : Wrapper< index array > + * | | | * xneg : Wrapper< index array > + * | | [...] (other element sets) + * | | + * | |-> ElementRegions : ElementRegionManager + * | | |-> Channel : CellElementRegion + * | | | |-> cb-0_0_0 : CellElementSubRegion + * | | | | | * pressure : Wrapper< real64 array > + * | | | | | * temperature : Wrapper< real64 array > + * | | | | [...] (other fields) + * | | | | + * | | | |-> cb-0_0_1 : CellElementSubRegion + * | | | | | * pressure : Wrapper< real64 array > + * | | | | | * temperature : Wrapper< real64 array > + * | | | | [...] (other fields) + * | | | | + * | | | [...] (other sub-regions) + * | | | + * | | |-> Barrier : CellElementRegion + * | | |-> cb-1_0_0 : CellElementSubRegion + * | | |-> cb-1_0_1 : CellElementSubRegion + * | | [...] (other sub-regions) + * | | + * | [...] (other element managers) + * ____ | | + * | | |-> statistics : Group (storage for all stats) + * | | |-> compFlowStats : Group (storage for this instance stats) + * | | | |-> cflStatistics : CFLStatistics + * | | | |-> regionsStatistics : RegionStatistics (aggregate) + * | | | |-> Channel : RegionStatistics (aggregate, mpi reduced) + * | | | | |-> cb-0_0_0 : RegionStatistics (compute read-back) + * stats | | | | |-> cb-0_0_1 : RegionStatistics (compute read-back) + * data -> | | | | [...] (other sub-regions stats) + * | | | | + * | | | |-> Barrier : RegionStatistics (aggregate, mpi reduced) + * | | | |-> cb-1_0_0 : RegionStatistics (compute read-back) + * | | | |-> cb-1_0_1 : RegionStatistics (compute read-back) + * | | | [...] (other sub-regions stats) + * | | | + * |___ | [...] (other stats storages) + * | + * [...] (other discretizations) + */ + +#ifndef SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_COMPOSITIONALMULTIPHASESTATISTICSAGGREGATOR_HPP_ +#define SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_COMPOSITIONALMULTIPHASESTATISTICSAGGREGATOR_HPP_ + +#include "common/DataTypes.hpp" +#include "physicsSolvers/StatisticsAggregatorBase.hpp" + +namespace geos +{ + +class CompositionalMultiphaseBase; + +namespace compositionalMultiphaseStatistics +{ +class StatsAggregator; +class RegionStatistics; +} + +template<> +struct StatsAggregatorTraits< compositionalMultiphaseStatistics::StatsAggregator > +{ + using SolverType = CompositionalMultiphaseBase; + using StatsGroupType = compositionalMultiphaseStatistics::RegionStatistics; +}; + +namespace compositionalMultiphaseStatistics +{ + +struct AggregatorParameters +{ + /// Threshold to decide whether a phase is considered "mobile" or not + real64 m_relpermThreshold; + + // TODO: add other params like views and stuff +}; + +/** + * @brief Output data group to contain the result of a given stat aggregator on the dataRepository. + * Attributes are public since the class is a POD. + * @todo repair 1D HDF5 outputs to enable stats HDF5 outputs + */ +class RegionStatistics : public RegionStatisticsBase +{ +public: + + /// average region pressure (numerator value before postAggregateCompute()) + real64 m_averagePressure; + /// minimum region pressure + real64 m_minPressure; + /// maximum region pressure + real64 m_maxPressure; + + /// minimum region delta pressure + real64 m_minDeltaPressure; + /// maximum region delta pressure + real64 m_maxDeltaPressure; + + /// average region temperature (numerator value before postAggregateCompute()) + real64 m_averageTemperature; + /// minimum region temperature + real64 m_minTemperature; + /// maximum region temperature + real64 m_maxTemperature; + + /// fluid mass + real64 m_totalMass; + + /// total region pore volume + real64 m_totalPoreVolume; + /// total region uncompacted pore volume (not necessarily output, useful for weighting cell pressure data) + real64 m_totalUncompactedPoreVolume; + /// phase region dynamic pore volume + array1d< real64 > const m_phaseDynamicPoreVolume; + + /// region phase mass (trapped and non-trapped, immobile and mobile) + array1d< real64 > const m_phaseMass; + /// trapped region phase mass + array1d< real64 > const m_trappedPhaseMass; + /// non-trapped region phase mass (available after postAggregateCompute()) + array1d< real64 > const m_nonTrappedPhaseMass; + /// immobile region phase mass + array1d< real64 > const m_immobilePhaseMass; + /// mobile region phase mass (available after postAggregateCompute()) + array1d< real64 > const m_mobilePhaseMass; + /// region component mass + array2d< real64 > const m_componentMass; + + // TODO? -> split to struct PressureStats...MassStats: + // - optional computation of each stats + // - VKS for struct name ("pressureStats"..."massStats") + // - current RegionStatistics struct bits + + /** + * @brief Construct a new Region Statistics object + * @param targetName name of the data-repository object that is targeted by the statistics + * (mesh level / region / sub-region). + * @param parent the instance parent in data-repository + * @param numPhases Fluid phase count + * @param numComponents Fluid component count + */ + RegionStatistics( string const & targetName, + dataRepository::Group * const parent, + bool statsOutputEnabled, + integer numPhases, + integer numComponents ); + + RegionStatistics( RegionStatistics && ) = default; + +}; + +/** + * @brief Output data group to contain the result of a given stat aggregator on the dataRepository. + * Attributes are public since the class is a POD. Can it be replaced by a wrapped-struct? + */ +class CFLStatistics : public RegionStatisticsBase +{ +public: + + /// Maximum Courant Friedrichs Lewy number in the grid for each phase + real64 m_maxPhaseCFL; + + /// Maximum Courant-Friedrichs-Lewy number in the grid for each component + real64 m_maxCompCFL; + + /** + * @brief Construct a new CFLStatistics object + * @param name instance name in data-repository + * @param parent the instance parent in data-repository + */ + CFLStatistics( const string & name, + dataRepository::Group * const parent, + bool statsOutputEnabled ); +}; + +/** + * @brief Reponsible of computing physical statistics over the grid, registering the result in the + * data repository, but not storing / outputing it by itself. It does not have mutable state + * except the encountered issues. + */ +class StatsAggregator : public StatsAggregatorBase< StatsAggregator > +{ +public: + + using Base = StatsAggregatorBase< StatsAggregator >; + + /** + * @brief the associated view keys + */ + struct ViewKeys + { + /// String for the cfl statistics group + constexpr static char const * cflStatisticsString() { return "cflStatistics"; } + }; + + /** + * @brief Construct a new Stats Aggregator object + * @param ownerName the unique name of the entity requesting the statistics. + * An error is thrown if not unique in this context. + * @param meshBodies The Group containing the MeshBody objects + * @param statsOutputEnabled If true, the stats are saved in the output HDF5 + * (through dataRepository::RestartFlags, but not functional for this output for now). + */ + StatsAggregator( dataRepository::DataContext const & ownerDataContext, + dataRepository::Group & meshBodies, + bool m_statsOutputEnabled ); + + /** + * @brief Enable the computation of any statistics, initialize data structure to collect them. + * Register the resulting data wrappers so they will be targeted by TimeHistory output + * @param solver flow solver object to retrieve: + - the simulated regions, + - fields for statistics computation. + */ + void initStatisticsAggregation( CompositionalMultiphaseBase & solver ); + + /** + * @brief Enable the computation of region statistics, initialize data structure to collect them. + * Register the resulting data wrappers so they will be targeted by TimeHistory output + * @note Must be called in or after the "registerDataOnMesh" initialization phase + */ + void enableRegionStatisticsAggregation(); + + /** + * @brief Register the results structs & wrappers so they will be targeted by TimeHistory output + * @note Must be called in or after the "registerDataOnMesh" initialization phase + */ + void enableCFLStatistics(); + + /** + * @brief set the statistics as dirty, ensuring isComputed() will be false until the next computation. + */ + void setDirty(); + + /** + * @brief Compute CFL numbers + * @param[in] time current time + * @param[in] dt the time step size + * @param[in] domain the domain partition + * @return false if there was a problem that prevented the statistics to be computed correctly. + */ + bool computeCFLNumbers( real64 const time, + real64 const dt, + DomainPartition & domain ); + + integer getNumPhases() const + { return m_numPhases; } + + integer getNumComponents() const + { return m_numComponents; } + + CFLStatistics * getCFLStatistics( DomainPartition & domain ) const; + + CFLStatistics & getCflStatistics( MeshLevel & mesh ) const; + + // template implementations + /// @cond DO_NOT_DOCUMENT + + void initStats( RegionStatistics & stats, real64 time ) const; + void computeSubRegionRankStats( CellElementSubRegion & subRegion, RegionStatistics & subRegionStats ) const; + void aggregateStats( RegionStatistics & stats, RegionStatistics const & other ) const; + void mpiAggregateStats( RegionStatistics & stats ) const; + void postAggregateStats( RegionStatistics & stats ); + + /// @endcond + +private: + + SolverType * m_solver = nullptr; + + AggregatorParameters m_params; + + StatsState m_cflStatsState; + + integer m_numPhases; + + integer m_numComponents; + +}; + +} /* namespace compositionalMultiphaseStatistics */ + +} /* namespace geos */ + +#endif /* SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_COMPOSITIONALMULTIPHASESTATISTICSAGGREGATOR_HPP_ */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsTask.cpp b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsTask.cpp new file mode 100644 index 00000000000..d80db9040c1 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsTask.cpp @@ -0,0 +1,419 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 CompositionalMultiphaseStatistics.cpp + */ + +#include "CompositionalMultiphaseStatisticsTask.hpp" + +#include "constitutive/fluid/multifluid/MultiFluidBase.hpp" +#include "physicsSolvers/LogLevelsInfo.hpp" +#include "physicsSolvers/fluidFlow/LogLevelsInfo.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseHybridFVM.hpp" + + +namespace geos +{ + +using namespace dataRepository; + +namespace compositionalMultiphaseStatistics +{ + +StatsTask::StatsTask( string const & name, Group * const parent ): + Base( name, parent ), + m_aggregator(), + m_computeCFLNumbers( 0 ), + m_computeRegionStatistics( 1 ) +{ + registerWrapper( viewKeyStruct::computeCFLNumbersString(), &m_computeCFLNumbers ). + setApplyDefaultValue( 0 ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Flag to decide whether CFL numbers are computed or not" ); + + registerWrapper( viewKeyStruct::computeRegionStatisticsString(), &m_computeRegionStatistics ). + setApplyDefaultValue( 1 ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Flag to decide whether region statistics are computed or not" ); + + registerWrapper( viewKeyStruct::relpermThresholdString(), &m_relpermThreshold ). + setApplyDefaultValue( 1e-6 ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Flag to decide whether a phase is considered mobile (when the relperm is above the threshold) or immobile (when the relperm is below the threshold) in metric 2" ); + + addLogLevel< logInfo::CFL >(); + addLogLevel< logInfo::Statistics >(); +} + +void StatsTask::postInputInitialization() +{ + Base::postInputInitialization(); + + GEOS_THROW_IF_EQ_MSG( m_solver, nullptr, + "To identify simulated regions, a solver must be provided.", + InputError, getWrapperDataContext( getSolverWrapperKey() ) ); + + if( !dynamicCast< CompositionalMultiphaseBase * >( m_solver ) ) + { + GEOS_THROW( "Incompatible solver selected, a compositional multiphase solver is expected", + InputError, getDataContext() ); + } + else if( dynamicCast< CompositionalMultiphaseHybridFVM * >( m_solver ) && m_computeCFLNumbers != 0 ) + { + GEOS_THROW( "The option to compute CFL numbers is incompatible with CompositionalMultiphaseHybridFVM", + InputError, getDataContext() ); + } +} + +void StatsTask::registerDataOnMesh( Group & meshBodies ) +{ + // for now, this guard is needed to avoid breaking the xml schema generation + if( m_solver == nullptr ) + return; + + prepareFluidMetaData(); + + if( m_computeRegionStatistics || m_computeCFLNumbers ) + { + // expected to work as check is done in postInputInitialization() + CompositionalMultiphaseBase * castedSolver = dynamicCast< CompositionalMultiphaseBase * >( m_solver ); + GEOS_ERROR_IF_EQ_MSG( castedSolver, nullptr, + GEOS_FMT( "{} {}: Unexpected error (solver pointer changed?)", catalogName(), getDataContext() ) ); + m_aggregator = std::make_unique< StatsAggregator >( getDataContext(), meshBodies, true ); + m_aggregator->initStatisticsAggregation( *castedSolver ); + } + else + { + GEOS_WARNING( GEOS_FMT( "{} {}: No computing option enabled, no output is scheduled.", + catalogName(), getDataContext() ) ); + } + + if( m_computeRegionStatistics ) + m_aggregator->enableRegionStatisticsAggregation(); + + // if we have to compute CFL numbers later, we need to register additional variables + if( m_computeCFLNumbers ) + m_aggregator->enableCFLStatistics(); + + m_aggregator->forRegionStatistics( [&] ( MeshLevel & mesh, RegionStatistics & ) + { + prepareLogTableLayouts( mesh.getName() ); + prepareCsvTableLayouts( mesh.getName() ); + } ); +} + +void StatsTask::prepareFluidMetaData() +{ + using namespace constitutive; + + ConstitutiveManager const & constitutiveManager = this->getGroupByPath< ConstitutiveManager >( "/Problem/domain/Constitutive" ); + MultiFluidBase const & fluid = constitutiveManager.getGroup< MultiFluidBase >( m_solver->referenceFluidModelName() ); + + m_fluid.m_numPhases = fluid.numFluidPhases(); + m_fluid.m_numComps = fluid.numFluidComponents(); + + m_fluid.m_phaseNames = fluid.phaseNames(); + m_fluid.m_compNames = fluid.componentNames(); + + m_fluid.m_phaseCompNames.resize( m_fluid.m_numPhases * m_fluid.m_numComps, string() ); + + for( int ip = 0; ip < m_fluid.m_numPhases; ++ip ) + for( int ic = 0; ic < m_fluid.m_numComps; ++ic ) + m_fluid.phaseCompName( ip, ic ) = GEOS_FMT( "{} / {}", m_fluid.m_phaseNames[ip], m_fluid.m_compNames[ic] ); +} + +void StatsTask::prepareLogTableLayouts( string_view meshName ) +{ + // only output from rank 0 + if( MpiWrapper::commRank() != 0 ) + return; + + TableLayout const tableLayout = TableLayout() + .setTitle( GEOS_FMT( "{}: mesh {}", getName(), meshName ) ); + + m_logFormatters.emplace( meshName, std::make_unique< TableTextFormatter >( tableLayout ) ); +} + +void StatsTask::prepareCsvTableLayouts( string_view meshName ) +{ + // only output from rank 0 + if( MpiWrapper::commRank() != 0 || !m_writeCSV ) + return; + + integer const numPhases = m_solver->numFluidPhases(); + integer const numComps = m_solver->numFluidComponents(); + + auto addPhaseColumns = []( TableLayout & ptableLayout, string const & description, string_view punit, + integer pnumPhases ) + { + for( int ip = 0; ip < pnumPhases; ++ip ) + ptableLayout.addColumn( GEOS_FMT( "{} (phase {}) [{}]", + description, ip, punit ) ); + }; + auto addPhaseCompColumns = []( TableLayout & ptableLayout, string const & description, string_view punit, + integer pnumPhases, integer pnumComps ) + { + for( int ip = 0; ip < pnumPhases; ++ip ) + for( int ic = 0; ic < pnumComps; ++ic ) + ptableLayout.addColumn( GEOS_FMT( "{} (component {} / phase {}) [{}]", + description, ic, ip, punit ) ); + }; + + string_view massUnit = units::getSymbol( m_solver->getMassUnit() ); + + TableLayout tableLayout( { + TableLayout::Column( GEOS_FMT( "Time [{}]", units::getSymbol( units::Unit::Time ))), + TableLayout::Column( "Region" ), // TODO : mention this change in PR description + TableLayout::Column( GEOS_FMT( "Min pressure [{}]", units::getSymbol( units::Unit::Pressure ))), + TableLayout::Column( GEOS_FMT( "Average pressure [{}]", units::getSymbol( units::Unit::Pressure )) ), + TableLayout::Column( GEOS_FMT( "Max pressure [{}]", units::getSymbol( units::Unit::Pressure ) ) ), + TableLayout::Column( GEOS_FMT( "Min delta pressure [{}]", units::getSymbol( units::Unit::Pressure ))), + TableLayout::Column( GEOS_FMT( "Max delta pressure [{}]", units::getSymbol( units::Unit::Pressure ))), + TableLayout::Column( GEOS_FMT( "Min temperature [{}]", units::getSymbol( units::Unit::Temperature ) )), + TableLayout::Column( GEOS_FMT( "Average temperature [{}]", units::getSymbol( units::Unit::Temperature ) )), + TableLayout::Column( GEOS_FMT( "Max temperature [{}]", units::getSymbol( units::Unit::Temperature ) )), + TableLayout::Column( GEOS_FMT( "Total dynamic pore volume [{}]", units::getSymbol( units::Unit::ReservoirVolume ) )), + } ); + addPhaseColumns( tableLayout, "Phase dynamic pore volume", units::getSymbol( units::Unit::ReservoirVolume ), numPhases ); + addPhaseColumns( tableLayout, "Phase mass", massUnit, numPhases ); + addPhaseColumns( tableLayout, "Trapped phase mass (metric 1)", massUnit, numPhases ); + addPhaseColumns( tableLayout, "Non-trapped phase mass (metric 1)", massUnit, numPhases ); + addPhaseColumns( tableLayout, "Immobile phase mass (metric 2)", massUnit, numPhases ); + addPhaseColumns( tableLayout, "Mobile phase mass (metric 2)", massUnit, numPhases ); + addPhaseCompColumns( tableLayout, "Component mass", massUnit, numPhases, numComps ); + + auto & csvFormatter = m_csvFormatters.get_inserted( string( meshName ) ); + csvFormatter = std::make_unique< TableCSVFormatter >( tableLayout ); + + // output CSV header + std::ofstream outputFile( getCsvFileName( meshName ) ); + outputFile << csvFormatter->headerToString(); +} + +string StatsTask::getCsvFileName( string_view meshName ) const +{ return GEOS_FMT( "{}/{}.csv", m_outputDir, meshName ); } + +bool StatsTask::execute( real64 const time_n, + real64 const dt, + integer const GEOS_UNUSED_PARAM( cycleNumber ), + integer const GEOS_UNUSED_PARAM( eventCounter ), + real64 const GEOS_UNUSED_PARAM( eventProgress ), + DomainPartition & domain ) +{ + // current statistics time is after solver resolution: time_n (timestep start) + dt + real64 statsTime = time_n + dt; + + GEOS_ERROR_IF( !m_aggregator, + "No statistics aggregator initialized!", getDataContext() ); + + m_aggregator->computeRegionsStatistics( statsTime ); + + m_aggregator->forRegionStatistics( [&] ( MeshLevel & mesh, RegionStatistics & meshRegionsStatistics ) + { + if( m_computeRegionStatistics ) + { + outputLogStats( statsTime, mesh, meshRegionsStatistics ); + outputCsvStats( statsTime, mesh, meshRegionsStatistics ); + } + } ); + + if( m_computeCFLNumbers ) + m_aggregator->computeCFLNumbers( statsTime, dt, domain ); + + return false; +} + +void StatsTask::outputLogStats( real64 const statsTime, + MeshLevel & mesh, + RegionStatistics & meshRegionsStatistics ) +{ + if( MpiWrapper::commRank() > 0 || !isLogLevelActive< logInfo::Statistics >( this->getLogLevel() ) ) + return; + + auto const formatterIter = m_logFormatters.find( mesh.getName() ); + if( formatterIter==m_logFormatters.end()) + return; + + TableTextFormatter const & formatter = *formatterIter->second; + TableData tableData; + static constexpr auto merge = CellType::MergeNext; + + string_view massUnit = units::getSymbol( m_solver->getMassUnit() ); + string_view pressureUnit = units::getSymbol( units::Pressure ); + string_view tempUnit = units::getSymbol( units::Temperature ); + string_view resVolUnit = units::getSymbol( units::ReservoirVolume ); + + tableData.getErrorsList().appendErrors( m_aggregator->getWarnings() ); + + tableData.addRow( "Statistics time", merge, merge, statsTime ); + + // lamda to apply for each region statistics + auto const outputRegionStats = [&] ( string_view targetName, RegionStatistics & stats ) + { + tableData.addSeparator(); + tableData.addRow( merge, merge, merge, "" ); + tableData.addRow( merge, merge, merge, targetName ); + tableData.addSeparator(); + + tableData.addRow( "statistics", "min", "average", "max" ); + tableData.addSeparator(); + + tableData.addRow( GEOS_FMT( "Pressure [{}]", pressureUnit ), + stats.m_minPressure, stats.m_averagePressure, stats.m_maxPressure ); + tableData.addRow( GEOS_FMT( "Delta pressure [{}]", pressureUnit ), + stats.m_minDeltaPressure, "/", stats.m_maxDeltaPressure ); + tableData.addRow( GEOS_FMT( "Temperature [{}]", tempUnit ), + stats.m_minTemperature, stats.m_averageTemperature, stats.m_maxTemperature ); + + tableData.addSeparator(); + + tableData.addRow( GEOS_FMT( "Total dynamic pore volume [{}]", resVolUnit ), + "all", + CellType::MergeNext, + stats.m_totalPoreVolume ); + tableData.addRow( GEOS_FMT( "Phase dynamic pore volume [{}]", resVolUnit ), + stringutilities::joinLambda( m_fluid.m_phaseNames, "\n", []( auto data ) { return data[0]; } ), + CellType::MergeNext, + stringutilities::joinLambda( stats.m_phaseDynamicPoreVolume, "\n", []( auto data ) { return data[0]; } ) ); + + tableData.addSeparator(); + + tableData.addRow( GEOS_FMT( "Total fluid mass [{}]", massUnit ), + "all", + CellType::MergeNext, + stats.m_totalMass ); + + tableData.addRow( GEOS_FMT( "Phase mass [{}]", massUnit ), + stringutilities::joinLambda( m_fluid.m_phaseNames, "\n", []( auto data ) { return data[0]; } ), + CellType::MergeNext, + stringutilities::joinLambda( stats.m_phaseMass, "\n", []( auto data ) { return data[0]; } ) ); + + tableData.addSeparator(); + + tableData.addRow( GEOS_FMT( "Trapped phase mass (metric 1) [{}]", massUnit ), + stringutilities::joinLambda( m_fluid.m_phaseNames, "\n", []( auto value ) { return value[0]; } ), + CellType::MergeNext, + stringutilities::joinLambda( stats.m_trappedPhaseMass, "\n", []( auto value ) { return value[0]; } ) ); + tableData.addRow( GEOS_FMT( "Non-trapped phase mass (metric 1) [{}]", massUnit ), + stringutilities::joinLambda( m_fluid.m_phaseNames, "\n", []( auto value ) { return value[0]; } ), + CellType::MergeNext, + stringutilities::joinLambda( stats.m_nonTrappedPhaseMass, "\n", []( auto value ) { return value[0]; } ) ); + + tableData.addSeparator(); + + tableData.addRow( GEOS_FMT( "Immobile phase mass (metric 2) [{}]", massUnit ), + stringutilities::joinLambda( m_fluid.m_phaseNames, "\n", []( auto value ) { return value[0]; } ), + CellType::MergeNext, + stringutilities::joinLambda( stats.m_immobilePhaseMass, "\n", []( auto value ) { return value[0]; } ) ); + tableData.addRow( GEOS_FMT( "Mobile phase mass (metric 2) [{}]", massUnit ), + stringutilities::joinLambda( m_fluid.m_phaseNames, "\n", []( auto value ) { return value[0]; } ), + CellType::MergeNext, + stringutilities::joinLambda( stats.m_mobilePhaseMass, "\n", []( auto value ) { return value[0]; } ) ); + + tableData.addSeparator(); + + tableData.addRow( GEOS_FMT( "Component mass [{}]", massUnit ), + stringutilities::join( m_fluid.m_phaseCompNames, '\n' ), + CellType::MergeNext, + stringutilities::join( stats.m_componentMass, '\n' ) ); + }; + + // apply the lambda for each region and, finally, the mesh summary + outputRegionStats( GEOS_FMT( "Discretization '{}'", mesh.getName() ), meshRegionsStatistics ); + + m_aggregator->forRegionStatistics( mesh, meshRegionsStatistics, + [&] ( CellElementRegion & region, RegionStatistics & stats ) + { + outputRegionStats( GEOS_FMT( "Region '{}'", region.getName() ), stats ); + } ); + + // output to log + GEOS_LOG_RANK_0( formatter.toString( tableData ) ); +} + +void StatsTask::outputCsvStats( real64 statsTime, + MeshLevel & mesh, + RegionStatistics & meshRegionsStatistics ) +{ + if( MpiWrapper::commRank() > 0 || m_writeCSV == 0 ) + return; + + auto const formatterIter = m_csvFormatters.find( mesh.getName() ); + if( formatterIter==m_csvFormatters.end()) + return; + + TableCSVFormatter const & formatter = *formatterIter->second; + TableData tableData; + + stdVector< string > row; + row.reserve( formatter.getLayout().getTotalLowermostColumnCount() ); + + // lamda to apply for each region statistics + auto const outputRegionStats = [&] ( string_view targetName, RegionStatistics & stats ) + { + + auto addPhaseValues = []( auto & list, auto const & values ) + { + for( auto value : values ) + list.emplace_back( std::to_string( value ) ); + }; + + row.clear(); + row.insert( row.begin(), + { std::to_string( statsTime ), + string( targetName ), + std::to_string( stats.m_minPressure ), + std::to_string( stats.m_averagePressure ), + std::to_string( stats.m_maxPressure ), + std::to_string( stats.m_minDeltaPressure ), + std::to_string( stats.m_maxDeltaPressure ), + std::to_string( stats.m_minTemperature ), + std::to_string( stats.m_averageTemperature ), + std::to_string( stats.m_maxTemperature ), + std::to_string( stats.m_totalPoreVolume ), + } ); + addPhaseValues( row, stats.m_phaseDynamicPoreVolume ); + addPhaseValues( row, stats.m_phaseMass ); + addPhaseValues( row, stats.m_trappedPhaseMass ); + addPhaseValues( row, stats.m_nonTrappedPhaseMass ); + addPhaseValues( row, stats.m_immobilePhaseMass ); + addPhaseValues( row, stats.m_mobilePhaseMass ); + addPhaseValues( row, stats.m_componentMass ); // TODO verify phase / comp ordering + + tableData.addRow( row ); + }; + + // apply the lambda for each region and, finally, the mesh summary + m_aggregator->forRegionStatistics( mesh, meshRegionsStatistics, + [&] ( CellElementRegion & region, RegionStatistics & stats ) + { + outputRegionStats( region.getName(), stats ); + } ); + outputRegionStats( mesh.getName(), meshRegionsStatistics ); + + // append to csv file + std::ofstream outputFile( getCsvFileName( mesh.getName() ), std::ios_base::app ); + outputFile << formatter.dataToString( tableData ); + outputFile.close(); +} + +REGISTER_CATALOG_ENTRY( TaskBase, + StatsTask, + string const &, dataRepository::Group * const ) + +} /* namespace compositionalMultiphaseStatistics */ + +} /* namespace geos */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatistics.hpp b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsTask.hpp similarity index 55% rename from src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatistics.hpp rename to src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsTask.hpp index dbe275b7b6f..c74dd261ba3 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatistics.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsTask.hpp @@ -14,25 +14,30 @@ */ /** - * @file CompositionalMultiphaseStatistics.hpp + * @file CompositionalMultiphaseStatisticsTask.hpp */ -#ifndef SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_COMPOSITIONALMULTIPHASESTATISTICS_HPP_ -#define SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_COMPOSITIONALMULTIPHASESTATISTICS_HPP_ +#ifndef SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_COMPOSITIONALMULTIPHASESTATISTICSTASK_HPP_ +#define SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_COMPOSITIONALMULTIPHASESTATISTICSTASK_HPP_ +#include "common/DataTypes.hpp" +#include "common/format/table/TableFormatter.hpp" #include "physicsSolvers/FieldStatisticsBase.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsAggregator.hpp" +#include namespace geos { class CompositionalMultiphaseBase; +namespace compositionalMultiphaseStatistics +{ + /** - * @class CompositionalMultiphaseStatistics - * * Task class allowing for the computation of aggregate statistics in compositional multiphase simulations */ -class CompositionalMultiphaseStatistics : public FieldStatisticsBase< CompositionalMultiphaseBase > +class StatsTask : public FieldStatisticsBase< CompositionalMultiphaseBase > { public: @@ -41,16 +46,11 @@ class CompositionalMultiphaseStatistics : public FieldStatisticsBase< Compositio * @param[in] name the name of the task coming from the xml * @param[in] parent the parent group of the task */ - CompositionalMultiphaseStatistics( const string & name, - Group * const parent ); + StatsTask( const string & name, dataRepository::Group * const parent ); /// Accessor for the catalog name static string catalogName() { return "CompositionalMultiphaseStatistics"; } - /// Accessor for the region statistics catalog name - static string regionStatisticsName() { return "regionStatistics"; } - - /** * @defgroup Tasks Interface Functions * @@ -67,43 +67,12 @@ class CompositionalMultiphaseStatistics : public FieldStatisticsBase< Compositio /**@}*/ - struct RegionStatistics - { - /// average region pressure - real64 averagePressure; - /// minimum region pressure - real64 minPressure; - /// maximum region pressure - real64 maxPressure; - - /// minimum region delta pressure - real64 minDeltaPressure; - /// maximum region delta pressure - real64 maxDeltaPressure; - - /// average region temperature - real64 averageTemperature; - /// minimum region temperature - real64 minTemperature; - /// maximum region temperature - real64 maxTemperature; - - /// total region pore volume - real64 totalPoreVolume; - /// total region uncompacted pore volume - real64 totalUncompactedPoreVolume; - /// phase region phase pore volume - array1d< real64 > phasePoreVolume; - - /// region phase mass (trapped and non-trapped, immobile and mobile) - array1d< real64 > phaseMass; - /// trapped region phase mass - array1d< real64 > trappedPhaseMass; - /// immobile region phase mass - array1d< real64 > immobilePhaseMass; - /// region component mass - array2d< real64 > componentMass; - }; + StatsAggregator & getStatisticsAggregator() + { return *m_aggregator; } + + StatsAggregator const & getStatisticsAggregator() const + { return *m_aggregator; } + private: using Base = FieldStatisticsBase< CompositionalMultiphaseBase >; @@ -117,37 +86,38 @@ class CompositionalMultiphaseStatistics : public FieldStatisticsBase< Compositio constexpr static char const * computeCFLNumbersString() { return "computeCFLNumbers"; } /// String for the flag deciding the computation of the region statistics constexpr static char const * computeRegionStatisticsString() { return "computeRegionStatistics"; } - /// String for the region statistics - constexpr static char const * regionStatisticsString() { return "regionStatistics"; } /// String for the relperm threshold constexpr static char const * relpermThresholdString() { return "relpermThreshold"; } }; + void postInputInitialization() override; + void registerDataOnMesh( Group & meshBodies ) override; - /** - * @brief Compute some statistics on the reservoir (average field pressure, etc) - * @param[in] time current time - * @param[in] mesh the mesh level object - * @param[in] regionNames the array of target region names - */ - void computeRegionStatistics( real64 const time, - MeshLevel & mesh, - string_array const & regionNames ) const; + void prepareFluidMetaData(); - /** - * @brief Compute CFL numbers - * @param[in] time current time - * @param[in] dt the time step size - * @param[in] domain the domain partition - */ - void computeCFLNumbers( real64 const time, - real64 const dt, - DomainPartition & domain ) const; + void prepareLogTableLayouts( string_view tableName ); - void postInputInitialization() override; + void prepareCsvTableLayouts( string_view tableName ); - void registerDataOnMesh( Group & meshBodies ) override; + string getCsvFileName( string_view meshName ) const; + + void outputLogStats( real64 statsTime, + MeshLevel & mesh, + RegionStatistics & meshRegionsStatistics ); + + void outputCsvStats( real64 statsTime, + MeshLevel & mesh, + RegionStatistics & meshRegionsStatistics ); + + /// For each discretization (MeshLevel name), table formatter for log output. + stdMap< string, std::unique_ptr< TableTextFormatter > > m_logFormatters; + + /// For each discretization (MeshLevel name), table formatter for csv output. + stdMap< string, std::unique_ptr< TableCSVFormatter > > m_csvFormatters; + + // mesh statistics aggregator + std::unique_ptr< StatsAggregator > m_aggregator; /// Flag to decide whether CFL numbers are computed or not integer m_computeCFLNumbers; @@ -158,9 +128,28 @@ class CompositionalMultiphaseStatistics : public FieldStatisticsBase< Compositio /// Threshold to decide whether a phase is considered "mobile" or not real64 m_relpermThreshold; + struct FluidMetaData + { + integer m_numPhases; + integer m_numComps; + stdVector< string > m_phaseNames; + stdVector< string > m_compNames; + stdVector< string > m_phaseCompNames; + + /** + * @param phaseId index of the phase for which we want the name + * @param compId index of the component for which we want the name + * @return string& reference of the name string + */ + string & phaseCompName( integer phaseId, integer compId ) + { return m_phaseCompNames[phaseId * m_numComps + compId]; } + + } m_fluid; + }; +} /* namespace compositionalMultiphaseStatistics */ } /* namespace geos */ -#endif /* SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_COMPOSITIONALMULTIPHASESTATISTICS_HPP_ */ +#endif /* SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_COMPOSITIONALMULTIPHASESTATISTICSTASK_HPP_ */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatistics.cpp b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatistics.cpp deleted file mode 100644 index 31cfee04b70..00000000000 --- a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatistics.cpp +++ /dev/null @@ -1,303 +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 SinglePhaseStatistics.cpp - */ - -#include "SinglePhaseStatistics.hpp" - -#include "mesh/DomainPartition.hpp" -#include "physicsSolvers/LogLevelsInfo.hpp" -#include "physicsSolvers/fluidFlow/SinglePhaseBase.hpp" -#include "physicsSolvers/fluidFlow/FlowSolverBaseFields.hpp" -#include "physicsSolvers/fluidFlow/SinglePhaseBaseFields.hpp" -#include "physicsSolvers/fluidFlow/kernels/singlePhase/StatisticsKernel.hpp" -#include "common/format/table/TableData.hpp" -#include "common/format/table/TableFormatter.hpp" -#include "common/format/table/TableLayout.hpp" - -namespace geos -{ - -using namespace constitutive; -using namespace fields; -using namespace dataRepository; - -SinglePhaseStatistics::SinglePhaseStatistics( const string & name, - Group * const parent ): - Base( name, parent ) -{ - addLogLevel< logInfo::Statistics >(); -} - -void SinglePhaseStatistics::registerDataOnMesh( Group & meshBodies ) -{ - // the fields have to be registered in "registerDataOnMesh" (and not later) - // otherwise they cannot be targeted by TimeHistory - - // for now, this guard is needed to avoid breaking the xml schema generation - if( m_solver == nullptr ) - { - return; - } - - m_solver->forDiscretizationOnMeshTargets( meshBodies, [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { - ElementRegionManager & elemManager = mesh.getElemManager(); - - for( size_t i = 0; i < regionNames.size(); ++i ) - { - ElementRegionBase & region = elemManager.getRegion( regionNames[i] ); - region.registerWrapper< RegionStatistics >( viewKeyStruct::regionStatisticsString() ). - setRestartFlags( RestartFlags::NO_WRITE ); - region.excludeWrappersFromPacking( { viewKeyStruct::regionStatisticsString() } ); - - if( m_writeCSV > 0 && MpiWrapper::commRank() == 0 ) - { - TableLayout tableLayout( { - TableLayout::Column().setName( GEOS_FMT( "Time [{}]", units::getSymbol( units::Unit::Time ))), - TableLayout::Column().setName( GEOS_FMT( "Min pressure [{}]", units::getSymbol( units::Unit::Pressure ))), - TableLayout::Column().setName( GEOS_FMT( "Average pressure [{}]", units::getSymbol( units::Unit::Pressure ))), - TableLayout::Column().setName( GEOS_FMT( "Max pressure [{}]", units::getSymbol( units::Unit::Pressure ))), - TableLayout::Column().setName( GEOS_FMT( "Min delta pressure [{}]", units::getSymbol( units::Unit::Pressure ))), - TableLayout::Column().setName( GEOS_FMT( "Max delta pressure [{}]", units::getSymbol( units::Unit::Pressure )) ), - TableLayout::Column().setName( GEOS_FMT( "Min temperature [{}]", units::getSymbol( units::Unit::Temperature ))), - TableLayout::Column().setName( GEOS_FMT( "Average temperature [{}]", units::getSymbol( units::Unit::Temperature ))), - TableLayout::Column().setName( GEOS_FMT( "Max temperature [{}]", units::getSymbol( units::Unit::Temperature ))), - TableLayout::Column().setName( GEOS_FMT( "Total dynamic pore volume [{}]", units::getSymbol( units::Unit::ReservoirVolume ) )), - TableLayout::Column().setName( GEOS_FMT( "Total fluid mass [{}]", units::getSymbol( units::Unit::Mass ))) - } ); - - TableCSVFormatter csvFormatter( tableLayout ); - std::ofstream outputFile( m_outputDir + "/" + regionNames[i] + ".csv" ); - outputFile << csvFormatter.headerToString(); - outputFile.close(); - } - } - } ); -} - -bool SinglePhaseStatistics::execute( real64 const time_n, - real64 const dt, - integer const GEOS_UNUSED_PARAM( cycleNumber ), - integer const GEOS_UNUSED_PARAM( eventCounter ), - real64 const GEOS_UNUSED_PARAM( eventProgress ), - DomainPartition & domain ) -{ - m_solver->forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { - // current time is time_n + dt - computeRegionStatistics( time_n + dt, mesh, regionNames ); - } ); - return false; -} - -void SinglePhaseStatistics::computeRegionStatistics( real64 const time, - MeshLevel & mesh, - string_array const & regionNames ) const -{ - GEOS_MARK_FUNCTION; - // Step 1: initialize the average/min/max quantities - ElementRegionManager & elemManager = mesh.getElemManager(); - for( size_t i = 0; i < regionNames.size(); ++i ) - { - ElementRegionBase & region = elemManager.getRegion( regionNames[i] ); - RegionStatistics & stats = region.getReference< RegionStatistics >( viewKeyStruct::regionStatisticsString() ); - - stats.averagePressure = 0.0; - stats.maxPressure = -LvArray::NumericLimits< real64 >::max; - stats.minPressure = LvArray::NumericLimits< real64 >::max; - - stats.maxDeltaPressure = -LvArray::NumericLimits< real64 >::max; - stats.minDeltaPressure = LvArray::NumericLimits< real64 >::max; - - stats.averageTemperature = 0.0; - stats.maxTemperature = -LvArray::NumericLimits< real64 >::max; - stats.minTemperature = LvArray::NumericLimits< real64 >::max; - - stats.totalPoreVolume = 0.0; - stats.totalUncompactedPoreVolume = 0.0; - stats.totalMass = 0.0; - } - - // Step 2: increment the average/min/max quantities for all the subRegions - elemManager.forElementSubRegions( regionNames, [&]( localIndex const, - ElementSubRegionBase & subRegion ) - { - - arrayView1d< integer const > const elemGhostRank = subRegion.ghostRank(); - arrayView1d< real64 const > const volume = subRegion.getElementVolume(); - arrayView1d< real64 const > const pres = subRegion.getField< flow::pressure >(); - arrayView1d< real64 const > const deltaPres = subRegion.getField< flow::deltaPressure >(); - arrayView1d< real64 const > const temp = subRegion.getField< flow::temperature >(); - - string const & solidName = subRegion.getReference< string >( SinglePhaseBase::viewKeyStruct::solidNamesString() ); - Group const & constitutiveModels = subRegion.getGroup( ElementSubRegionBase::groupKeyStruct::constitutiveModelsString() ); - CoupledSolidBase const & solid = constitutiveModels.getGroup< CoupledSolidBase >( solidName ); - arrayView1d< real64 const > const refPorosity = solid.getReferencePorosity(); - arrayView2d< real64 const > const porosity = solid.getPorosity(); - - string const & fluidName = subRegion.template getReference< string >( FlowSolverBase::viewKeyStruct::fluidNamesString() ); - SingleFluidBase const & fluid = constitutiveModels.getGroup< SingleFluidBase >( fluidName ); - arrayView2d< real64 const, constitutive::singlefluid::USD_FLUID > const densities = fluid.density(); - - real64 subRegionAvgPresNumerator = 0.0; - real64 subRegionMinPres = 0.0; - real64 subRegionMaxPres = 0.0; - real64 subRegionMinDeltaPres = 0.0; - real64 subRegionMaxDeltaPres = 0.0; - real64 subRegionAvgTempNumerator = 0.0; - real64 subRegionMinTemp = 0.0; - real64 subRegionMaxTemp = 0.0; - real64 subRegionTotalUncompactedPoreVol = 0.0; - real64 subRegionTotalPoreVol = 0.0; - real64 subRegionTotalMass = 0.0; - - singlePhaseBaseKernels::StatisticsKernel:: - launch( subRegion.size(), - elemGhostRank, - volume, - pres, - deltaPres, - temp, - refPorosity, - porosity, - densities, - subRegionMinPres, - subRegionAvgPresNumerator, - subRegionMaxPres, - subRegionMinDeltaPres, - subRegionMaxDeltaPres, - subRegionMinTemp, - subRegionAvgTempNumerator, - subRegionMaxTemp, - subRegionTotalUncompactedPoreVol, - subRegionTotalPoreVol, - subRegionTotalMass ); - - ElementRegionBase & region = elemManager.getRegion( ElementRegionBase::getParentRegion( subRegion ).getName() ); - RegionStatistics & stats = region.getReference< RegionStatistics >( viewKeyStruct::regionStatisticsString() ); - - stats.averagePressure += subRegionAvgPresNumerator; - if( subRegionMinPres < stats.minPressure ) - { - stats.minPressure = subRegionMinPres; - } - if( subRegionMaxPres > stats.maxPressure ) - { - stats.maxPressure = subRegionMaxPres; - } - - if( subRegionMinDeltaPres < stats.minDeltaPressure ) - { - stats.minDeltaPressure = subRegionMinDeltaPres; - } - if( subRegionMaxDeltaPres > stats.maxDeltaPressure ) - { - stats.maxDeltaPressure = subRegionMaxDeltaPres; - } - - stats.averageTemperature += subRegionAvgTempNumerator; - if( subRegionMinTemp < stats.minTemperature ) - { - stats.minTemperature = subRegionMinTemp; - } - if( subRegionMaxTemp > stats.maxTemperature ) - { - stats.maxTemperature = subRegionMaxTemp; - } - - stats.totalUncompactedPoreVolume += subRegionTotalUncompactedPoreVol; - stats.totalPoreVolume += subRegionTotalPoreVol; - stats.totalMass += subRegionTotalMass; - } ); - - // Step 3: synchronize the results over the MPI ranks - for( size_t i = 0; i < regionNames.size(); ++i ) - { - ElementRegionBase & region = elemManager.getRegion( regionNames[i] ); - RegionStatistics & stats = region.getReference< RegionStatistics >( viewKeyStruct::regionStatisticsString() ); - - stats.minPressure = MpiWrapper::min( stats.minPressure ); - stats.averagePressure = MpiWrapper::sum( stats.averagePressure ); - stats.maxPressure = MpiWrapper::max( stats.maxPressure ); - - stats.minDeltaPressure = MpiWrapper::min( stats.minDeltaPressure ); - stats.maxDeltaPressure = MpiWrapper::max( stats.maxDeltaPressure ); - - stats.minTemperature = MpiWrapper::min( stats.minTemperature ); - stats.averageTemperature = MpiWrapper::sum( stats.averageTemperature ); - stats.maxTemperature = MpiWrapper::max( stats.maxTemperature ); - - stats.totalUncompactedPoreVolume = MpiWrapper::sum( stats.totalUncompactedPoreVolume ); - stats.totalPoreVolume = MpiWrapper::sum( stats.totalPoreVolume ); - stats.totalMass = MpiWrapper::sum( stats.totalMass ); - - if( stats.totalUncompactedPoreVolume > 0 ) - { - float invTotalUncompactedPoreVolume = 1.0 / stats.totalUncompactedPoreVolume; - stats.averagePressure *= invTotalUncompactedPoreVolume; - stats.averageTemperature *= invTotalUncompactedPoreVolume; - } - else - { - stats.averagePressure = 0.0; - stats.averageTemperature = 0.0; - GEOS_WARNING( GEOS_FMT( "{}: Cannot compute average pressure & temperature because region pore volume is zero.", regionNames[i] ), - getDataContext() ); - } - - string_view massUnit = units::getSymbol( m_solver->getMassUnit() ); - - if( isLogLevelActive< logInfo::Statistics >( this->getLogLevel())&& MpiWrapper::commRank() == 0 ) - { - TableData singPhaseStatsData; - singPhaseStatsData.addRow( "Pressure[Pa]", stats.minPressure, stats.averagePressure, stats.maxPressure ); - singPhaseStatsData.addRow( "Delta pressure [Pa]", stats.minDeltaPressure, "/", stats.maxDeltaPressure ); - singPhaseStatsData.addRow( "Temperature [K]", stats.minTemperature, stats.averageTemperature, stats.maxTemperature ); - singPhaseStatsData.addSeparator(); - - singPhaseStatsData.addRow( "Total dynamic pore volume [rm^3]", CellType::MergeNext, CellType::MergeNext, stats.totalPoreVolume ); - singPhaseStatsData.addSeparator(); - singPhaseStatsData.addRow( GEOS_FMT( "Total fluid mass [{}]", massUnit ), CellType::MergeNext, CellType::MergeNext, stats.totalMass ); - - string const title = GEOS_FMT( "{}, {} (time {} s):", getName(), regionNames[i], time ); - TableLayout const singPhaseStatsLayout( title, { "statistics", "min", "average", "max" } ); - TableTextFormatter tableFormatter( singPhaseStatsLayout ); - GEOS_LOG_RANK_0( tableFormatter.toString( singPhaseStatsData ) ); - - if( m_writeCSV > 0 && MpiWrapper::commRank() == 0 ) - { - std::ofstream outputFile( m_outputDir + "/" + regionNames[i] + ".csv", std::ios_base::app ); - outputFile << time << "," << stats.minPressure << "," << stats.averagePressure << "," << stats.maxPressure << "," << - stats.minDeltaPressure << "," << stats.maxDeltaPressure << "," << - stats.minTemperature << "," << stats.averageTemperature << "," << stats.maxTemperature << "," << - stats.totalPoreVolume << "," << stats.totalMass << std::endl; - outputFile.close(); - } - } - } -} - -REGISTER_CATALOG_ENTRY( TaskBase, - SinglePhaseStatistics, - string const &, dataRepository::Group * const ) - -} /* namespace geos */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsAggregator.cpp b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsAggregator.cpp new file mode 100644 index 00000000000..d5c0aad8412 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsAggregator.cpp @@ -0,0 +1,194 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 SinglePhaseStatistics.cpp + */ + +#include "SinglePhaseStatisticsAggregator.hpp" + +#include "mesh/DomainPartition.hpp" +#include "physicsSolvers/LogLevelsInfo.hpp" +#include "physicsSolvers/StatisticsAggregatorBaseHelpers.hpp" +#include "physicsSolvers/fluidFlow/SinglePhaseBase.hpp" +#include "physicsSolvers/fluidFlow/FlowSolverBaseFields.hpp" +#include "physicsSolvers/fluidFlow/SinglePhaseBaseFields.hpp" +#include "physicsSolvers/fluidFlow/kernels/singlePhase/StatisticsKernel.hpp" +#include "common/format/table/TableData.hpp" +#include "common/format/table/TableFormatter.hpp" +#include "common/format/table/TableLayout.hpp" + +namespace geos +{ + +namespace singlePhaseStatistics +{ + +using namespace constitutive; +using namespace dataRepository; + +RegionStatistics::RegionStatistics( string const & name, + dataRepository::Group * const parent, + bool const statsOutputEnabled ): + RegionStatisticsBase( name, parent, statsOutputEnabled ) +{} + +StatsAggregator::StatsAggregator( DataContext const & ownerDataContext, + dataRepository::Group & meshBodies, + bool const statsOutputEnabled ): + Base( ownerDataContext, meshBodies, statsOutputEnabled ) +{} + +void StatsAggregator::enableRegionStatisticsAggregation() +{ + auto const registerStats = [=] ( Group & parent, + string const & targetName ) -> RegionStatistics & + { + return parent.registerGroup( targetName, + std::make_unique< RegionStatistics >( targetName, + &parent, + m_statsOutputEnabled ) ); + }; + + Base::enableRegionStatisticsAggregation( registerStats ); +} + +void StatsAggregator::initStats( RegionStatistics & stats, real64 const time ) const +{ + stats.m_time = time; + + stats.m_averagePressure = 0.0; + stats.m_maxPressure = 0.0; + stats.m_minPressure = LvArray::NumericLimits< real64 >::max; + + stats.m_maxDeltaPressure = -LvArray::NumericLimits< real64 >::max; + stats.m_minDeltaPressure = LvArray::NumericLimits< real64 >::max; + + stats.m_averageTemperature = 0.0; + stats.m_maxTemperature = 0.0; + stats.m_minTemperature = LvArray::NumericLimits< real64 >::max; + + stats.m_totalDynamicPoreVolume = 0.0; + stats.m_totalUncompactedPoreVolume = 0.0; + + stats.m_totalMass = 0.0; +} + +void StatsAggregator::computeSubRegionRankStats( CellElementSubRegion & subRegion, + RegionStatistics & subRegionStats ) const +{ + static constexpr string_view solidNamesVK = SinglePhaseBase::viewKeyStruct::solidNamesString(); + static constexpr string_view fluidNamesVK = FlowSolverBase::viewKeyStruct::fluidNamesString(); + static constexpr string_view modelsVK = ElementSubRegionBase::groupKeyStruct::constitutiveModelsString(); + + arrayView1d< integer const > const elemGhostRank = subRegion.ghostRank(); + arrayView1d< real64 const > const volume = subRegion.getElementVolume(); + arrayView1d< real64 const > const pres = subRegion.getField< fields::flow::pressure >(); + arrayView1d< real64 const > const deltaPres = subRegion.getField< fields::flow::deltaPressure >(); + arrayView1d< real64 const > const temp = subRegion.getField< fields::flow::temperature >(); + + string const & solidName = subRegion.getReference< string >( string( solidNamesVK ) ); + Group const & constitutiveModels = subRegion.getGroup( string( modelsVK ) ); + CoupledSolidBase const & solid = constitutiveModels.getGroup< CoupledSolidBase >( solidName ); + arrayView1d< real64 const > const refPorosity = solid.getReferencePorosity(); + arrayView2d< real64 const > const porosity = solid.getPorosity(); + + string const & fluidName = subRegion.template getReference< string >( string( fluidNamesVK ) ); + SingleFluidBase const & fluid = constitutiveModels.getGroup< SingleFluidBase >( fluidName ); + arrayView2d< real64 const, constitutive::singlefluid::USD_FLUID > const densities = fluid.density(); + + singlePhaseBaseKernels::StatisticsKernel::launch( subRegion.size(), + elemGhostRank, + volume, + pres, + deltaPres, + temp, + refPorosity, + porosity, + densities, + subRegionStats.m_minPressure, + subRegionStats.m_averagePressure, + subRegionStats.m_maxPressure, + subRegionStats.m_minDeltaPressure, + subRegionStats.m_maxDeltaPressure, + subRegionStats.m_minTemperature, + subRegionStats.m_averageTemperature, + subRegionStats.m_maxTemperature, + subRegionStats.m_totalUncompactedPoreVolume, + subRegionStats.m_totalDynamicPoreVolume, + subRegionStats.m_totalMass ); +} + +void StatsAggregator::aggregateStats( RegionStatistics & stats, + RegionStatistics const & other ) const +{ + stats.m_averagePressure += other.m_averagePressure; + stats.m_minPressure = LvArray::math::min( stats.m_minPressure, other.m_minPressure ); + stats.m_maxPressure = LvArray::math::max( stats.m_maxPressure, other.m_maxPressure ); + + stats.m_minDeltaPressure = LvArray::math::min( stats.m_minDeltaPressure, other.m_minDeltaPressure ); + stats.m_maxDeltaPressure = LvArray::math::max( stats.m_maxDeltaPressure, other.m_maxDeltaPressure ); + + stats.m_averageTemperature += other.m_averageTemperature; + stats.m_minTemperature = LvArray::math::min( stats.m_minTemperature, other.m_minTemperature ); + stats.m_maxTemperature = LvArray::math::max( stats.m_maxTemperature, other.m_maxTemperature ); + + stats.m_totalUncompactedPoreVolume += other.m_totalUncompactedPoreVolume; + stats.m_totalDynamicPoreVolume += other.m_totalDynamicPoreVolume; + + stats.m_totalMass += other.m_totalMass; +} + +void StatsAggregator::mpiAggregateStats( RegionStatistics & stats ) const +{ + stats.m_averagePressure = MpiWrapper::sum( stats.m_averagePressure ); + stats.m_minPressure = MpiWrapper::min( stats.m_minPressure ); + stats.m_maxPressure = MpiWrapper::max( stats.m_maxPressure ); + + stats.m_minDeltaPressure = MpiWrapper::min( stats.m_minDeltaPressure ); + stats.m_maxDeltaPressure = MpiWrapper::max( stats.m_maxDeltaPressure ); + + stats.m_averageTemperature = MpiWrapper::sum( stats.m_averageTemperature ); + stats.m_minTemperature = MpiWrapper::min( stats.m_minTemperature ); + stats.m_maxTemperature = MpiWrapper::max( stats.m_maxTemperature ); + + stats.m_totalUncompactedPoreVolume = MpiWrapper::sum( stats.m_totalUncompactedPoreVolume ); + stats.m_totalDynamicPoreVolume = MpiWrapper::sum( stats.m_totalDynamicPoreVolume ); + + stats.m_totalMass = MpiWrapper::sum( stats.m_totalMass ); +} + +void StatsAggregator::postAggregateStats( RegionStatistics & stats ) +{ + if( stats.m_totalUncompactedPoreVolume > 0 ) + { + float invTotalUncompactedPoreVolume = 1.0 / stats.m_totalUncompactedPoreVolume; + stats.m_averagePressure *= invTotalUncompactedPoreVolume; + stats.m_averageTemperature *= invTotalUncompactedPoreVolume; + } + else + { + stats.m_averagePressure = 0.0; + stats.m_averageTemperature = 0.0; + m_warnings.emplace_back( GEOS_FMT( "Cannot compute average pressure for '{}' because pore volume is zero in '{}'.", + getOwnerName(), stats.getTargetName() ) ); + } +} + +} /* namespace singlePhaseStatistics */ + +template class StatsAggregatorBase< singlePhaseStatistics::StatsAggregator >; + +} /* namespace geos */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsAggregator.hpp b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsAggregator.hpp new file mode 100644 index 00000000000..630423d993a --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsAggregator.hpp @@ -0,0 +1,203 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 SinglePhaseStatisticsAggregator.hpp + * @details Region statistics data is stored as follow: + + * Problem : ProblemManager + * |-> domain : DomainPartition + * |-> MeshBodies : Group + * |-> cartesianMesh : MeshBody + * |-> meshLevels : Group + * |-> Level0 : MeshLevel + * | |-> nodeManager : NodeManager + * | | |-> sets : Group + * | | | * all : Wrapper< index array > + * | | | * xneg : Wrapper< index array > + * | | [...] (other element sets) + * | | + * | |-> ElementRegions : ElementRegionManager + * | | |-> Channel : CellElementRegion + * | | | |-> cb-0_0_0 : CellElementSubRegion + * | | | | | * pressure : Wrapper< real64 array > + * | | | | | * temperature : Wrapper< real64 array > + * | | | | [...] (other fields) + * | | | | + * | | | |-> cb-0_0_1 : CellElementSubRegion + * | | | | | * pressure : Wrapper< real64 array > + * | | | | | * temperature : Wrapper< real64 array > + * | | | | [...] (other fields) + * | | | | + * | | | [...] (other sub-regions) + * | | | + * | | |-> Barrier : CellElementRegion + * | | |-> cb-1_0_0 : CellElementSubRegion + * | | |-> cb-1_0_1 : CellElementSubRegion + * | | [...] (other sub-regions) + * | | + * | [...] (other element managers) + * ____ | | + * | | |-> statistics : Group (storage for all stats) + * | | |-> flowStats : Group (storage for this instance stats) + * | | | |-> regionsStatistics : RegionStatistics (aggregate) + * | | | |-> Channel : RegionStatistics (aggregate, mpi reduced) + * | | | | |-> cb-0_0_0 : RegionStatistics (compute read-back) + * stats | | | | |-> cb-0_0_1 : RegionStatistics (compute read-back) + * data -> | | | | [...] (other sub-regions stats) + * | | | | + * | | | |-> Barrier : RegionStatistics (aggregate, mpi reduced) + * | | | |-> cb-1_0_0 : RegionStatistics (compute read-back) + * | | | |-> cb-1_0_1 : RegionStatistics (compute read-back) + * | | | [...] (other sub-regions stats) + * | | | + * |___ | [...] (other stats storages) + * | + * [...] (other discretizations) + */ + +#ifndef SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_SINGLEPHASESTATISTICSAGGREGATOR_HPP_ +#define SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_SINGLEPHASESTATISTICSAGGREGATOR_HPP_ + +#include "physicsSolvers/StatisticsAggregatorBase.hpp" + +namespace geos +{ + +class SinglePhaseBase; + +namespace singlePhaseStatistics +{ +class StatsAggregator; +class RegionStatistics; +} + +template<> +struct StatsAggregatorTraits< singlePhaseStatistics::StatsAggregator > +{ + using SolverType = SinglePhaseBase; + using StatsGroupType = singlePhaseStatistics::RegionStatistics; +}; + +namespace singlePhaseStatistics +{ + +/** + * @brief Output data group to contain the result of a given stat aggregator on the dataRepository. + * Attributes are public since the class is a POD. + * @todo repair 1D HDF5 outputs to enable stats HDF5 outputs + */ +class RegionStatistics : public RegionStatisticsBase +{ +public: + + /// Time of statistics computation + real64 m_time; + + /// average region pressure (numerator value before postAggregateCompute()) + real64 m_averagePressure; + /// minimum region pressure + real64 m_minPressure; + /// maximum region pressure + real64 m_maxPressure; + + /// minimum region delta pressure + real64 m_minDeltaPressure; + /// maximum region delta pressure + real64 m_maxDeltaPressure; + + /// average region temperature (numerator value before postAggregateCompute()) + real64 m_averageTemperature; + /// minimum region temperature + real64 m_minTemperature; + /// maximum region temperature + real64 m_maxTemperature; + + /// fluid mass + real64 m_totalMass; + + /// total region pore volume + real64 m_totalDynamicPoreVolume; + /// total region uncompacted pore volume (not necessarily output, useful for weighting cell pressure data) + real64 m_totalUncompactedPoreVolume; + + // TODO? -> split to struct PressureStats...MassStats: + // - optional computation of each stats + // - VKS for struct name ("pressureStats"..."massStats") + // - current RegionStatistics struct bits + + /** + * @brief Construct a new Region Statistics object + * @param targetName name of the data-repository object that is targeted by the statistics + * (mesh level / region / sub-region). + * @param parent the instance parent in data-repository + */ + RegionStatistics( string const & targetName, + dataRepository::Group * const parent, + bool statsOutputEnabled ); + + RegionStatistics( RegionStatistics && ) = default; + +}; + +/** + * @brief Reponsible of computing physical statistics over the grid, registering the result in the + * data repository, but not storing / outputing it by itself. It does not have mutable state + * except the encountered issues. + * @todo repair 1D HDF5 outputs to enable stats HDF5 outputs + */ +class StatsAggregator : public StatsAggregatorBase< StatsAggregator > +{ +public: + + using Base = StatsAggregatorBase< StatsAggregator >; + + /** + * @brief Construct a new Stats Aggregator object + * @param ownerName the unique name of the entity requesting the statistics. + * An error is thrown if not unique in this context. + * @param meshBodies The Group containing the MeshBody objects + * @param statsOutputEnabled If true, the stats are saved in the output HDF5 + * (through dataRepository::RestartFlags, but not functional for this output for now). + */ + StatsAggregator( dataRepository::DataContext const & ownerDataContext, + dataRepository::Group & meshBodies, + bool statsOutputEnabled ); + + /** + * @brief Enable the computation of region statistics, initialize data structure to collect them. + * Register the resulting data wrappers so they will be targeted by TimeHistory output + * @note Must be called in or after the "registerDataOnMesh" initialization phase + */ + void enableRegionStatisticsAggregation(); + + // template implementations + /// @cond DO_NOT_DOCUMENT + + void initStats( RegionStatistics & stats, real64 time ) const; + void computeSubRegionRankStats( CellElementSubRegion & subRegion, RegionStatistics & subRegionStats ) const; + void aggregateStats( RegionStatistics & stats, RegionStatistics const & other ) const; + void mpiAggregateStats( RegionStatistics & stats ) const; + void postAggregateStats( RegionStatistics & stats ); + + /// @endcond + +}; + +} /* namespace singlePhaseStatistics */ + +} /* namespace geos */ + +#endif /* SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_SINGLEPHASESTATISTICSAGGREGATOR_HPP_ */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsTask.cpp b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsTask.cpp new file mode 100644 index 00000000000..22882918abf --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsTask.cpp @@ -0,0 +1,278 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 SinglePhaseStatisticsTask.cpp + */ + +#include "SinglePhaseStatisticsTask.hpp" + +#include "physicsSolvers/LogLevelsInfo.hpp" +#include "physicsSolvers/fluidFlow/SinglePhaseBase.hpp" + +namespace geos +{ + +using namespace dataRepository; + +namespace singlePhaseStatistics +{ + +StatsTask::StatsTask( const string & name, Group * const parent ): + Base( name, parent ) +{ + addLogLevel< logInfo::Statistics >(); +} + +void StatsTask::postInputInitialization() +{ + Base::postInputInitialization(); + + GEOS_THROW_IF_EQ_MSG( m_solver, nullptr, + "To identify simulated regions, a solver must be provided.", + InputError, getWrapperDataContext( getSolverWrapperKey() ) ); + + if( !dynamicCast< SinglePhaseBase * >( m_solver ) ) + { + GEOS_THROW( "Incompatible solver selected, a single-phase solver is expected", + InputError, getDataContext() ); + } +} + +void StatsTask::registerDataOnMesh( Group & meshBodies ) +{ + // for now, this guard is needed to avoid breaking the xml schema generation + if( m_solver == nullptr ) + return; + + if( m_writeCSV || isLogLevelActive< logInfo::Statistics >( this->getLogLevel()) ) + { + // expected to work as check is done in postInputInitialization() + SinglePhaseBase * castedSolver = dynamicCast< SinglePhaseBase * >( m_solver ); + GEOS_ERROR_IF_EQ_MSG( castedSolver, nullptr, + GEOS_FMT( "{} {}: Unexpected error (solver pointer changed?)", catalogName(), getDataContext() ) ); + m_aggregator = std::make_unique< StatsAggregator >( getDataContext(), meshBodies, true ); + m_aggregator->initStatisticsAggregation( *castedSolver ); + } + else + { + GEOS_WARNING( GEOS_FMT( "{} {}: No computing option enabled, no output is scheduled.", + catalogName(), getDataContext() ) ); + } + + m_aggregator->enableRegionStatisticsAggregation(); + + m_aggregator->forRegionStatistics( [&] ( MeshLevel & mesh, RegionStatistics & ) + { + prepareLogTableLayouts( mesh.getName() ); + prepareCsvTableLayouts( mesh.getName() ); + } ); +} + +void StatsTask::prepareLogTableLayouts( string_view meshName ) +{ + // only output from rank 0 + if( MpiWrapper::commRank() != 0 ) + return; + + TableLayout const tableLayout = TableLayout() + .setTitle( GEOS_FMT( "{}: mesh {}", getName(), meshName ) ); + + m_logFormatters.emplace( meshName, std::make_unique< TableTextFormatter >( tableLayout ) ); +} + +void StatsTask::prepareCsvTableLayouts( string_view meshName ) +{ + // only output from rank 0 + if( MpiWrapper::commRank() != 0 || !m_writeCSV ) + return; + + string_view massUnit = units::getSymbol( m_solver->getMassUnit() ); + + TableLayout tableLayout( { + TableLayout::Column( GEOS_FMT( "Time [{}]", units::getSymbol( units::Unit::Time ))), + TableLayout::Column( "Region" ), // TODO : mention this change in PR description + TableLayout::Column( GEOS_FMT( "Min pressure [{}]", units::getSymbol( units::Unit::Pressure ))), + TableLayout::Column( GEOS_FMT( "Average pressure [{}]", units::getSymbol( units::Unit::Pressure )) ), + TableLayout::Column( GEOS_FMT( "Max pressure [{}]", units::getSymbol( units::Unit::Pressure ) ) ), + TableLayout::Column( GEOS_FMT( "Min delta pressure [{}]", units::getSymbol( units::Unit::Pressure ))), + TableLayout::Column( GEOS_FMT( "Max delta pressure [{}]", units::getSymbol( units::Unit::Pressure ))), + TableLayout::Column( GEOS_FMT( "Min temperature [{}]", units::getSymbol( units::Unit::Temperature ) )), + TableLayout::Column( GEOS_FMT( "Average temperature [{}]", units::getSymbol( units::Unit::Temperature ) )), + TableLayout::Column( GEOS_FMT( "Max temperature [{}]", units::getSymbol( units::Unit::Temperature ) )), + TableLayout::Column( GEOS_FMT( "Total dynamic pore volume [{}]", units::getSymbol( units::Unit::ReservoirVolume ) )), + TableLayout::Column( GEOS_FMT( "Total fluid mass [{}]", massUnit )), + } ); + + auto & csvFormatter = m_csvFormatters.get_inserted( string( meshName ) ); + csvFormatter = std::make_unique< TableCSVFormatter >( tableLayout ); + + // output CSV header + std::ofstream outputFile( getCsvFileName( meshName ) ); + outputFile << csvFormatter->headerToString(); +} + +string StatsTask::getCsvFileName( string_view meshName ) const +{ return GEOS_FMT( "{}/{}.csv", m_outputDir, meshName ); } + +bool StatsTask::execute( real64 const time_n, + real64 const dt, + integer const GEOS_UNUSED_PARAM( cycleNumber ), + integer const GEOS_UNUSED_PARAM( eventCounter ), + real64 const GEOS_UNUSED_PARAM( eventProgress ), + DomainPartition & ) +{ + // current statistics time is after solver resolution: time_n (timestep start) + dt + real64 statsTime = time_n + dt; + + GEOS_ERROR_IF( !m_aggregator, + "No statistics aggregator initialized!", getDataContext() ); + + m_aggregator->computeRegionsStatistics( statsTime ); + + m_aggregator->forRegionStatistics( [&] ( MeshLevel & mesh, RegionStatistics & meshRegionsStatistics ) + { + outputLogStats( statsTime, mesh, meshRegionsStatistics ); + outputCsvStats( statsTime, mesh, meshRegionsStatistics ); + } ); + + return false; +} + +void StatsTask::outputLogStats( real64 const statsTime, + MeshLevel & mesh, + RegionStatistics & meshRegionsStatistics ) +{ + if( MpiWrapper::commRank() > 0 || !isLogLevelActive< logInfo::Statistics >( this->getLogLevel() ) ) + return; + + auto const formatterIter = m_logFormatters.find( mesh.getName() ); + if( formatterIter==m_logFormatters.end()) + return; + + TableTextFormatter const & formatter = *formatterIter->second; + TableData tableData; + static constexpr auto merge = CellType::MergeNext; + + string_view massUnit = units::getSymbol( m_solver->getMassUnit() ); + string_view pressureUnit = units::getSymbol( units::Pressure ); + string_view tempUnit = units::getSymbol( units::Temperature ); + string_view resVolUnit = units::getSymbol( units::ReservoirVolume ); + + tableData.getErrorsList().appendErrors( m_aggregator->getWarnings() ); + + tableData.addRow( "Statistics time", merge, merge, statsTime ); + + // lamda to apply for each region statistics + auto const outputRegionStats = [&] ( string_view targetName, RegionStatistics & stats ) + { + tableData.addSeparator(); + tableData.addRow( merge, merge, merge, "" ); + tableData.addRow( merge, merge, merge, targetName ); + tableData.addSeparator(); + + tableData.addRow( "statistics", "min", "average", "max" ); + tableData.addSeparator(); + + tableData.addRow( GEOS_FMT( "Pressure [{}]", pressureUnit ), + stats.m_minPressure, stats.m_averagePressure, stats.m_maxPressure ); + tableData.addRow( GEOS_FMT( "Delta pressure [{}]", pressureUnit ), + stats.m_minDeltaPressure, "/", stats.m_maxDeltaPressure ); + tableData.addRow( GEOS_FMT( "Temperature [{}]", tempUnit ), + stats.m_minTemperature, stats.m_averageTemperature, stats.m_maxTemperature ); + + tableData.addSeparator(); + + tableData.addRow( GEOS_FMT( "Total dynamic pore volume [{}]", resVolUnit ), + "all", CellType::MergeNext, stats.m_totalDynamicPoreVolume ); + + tableData.addRow( GEOS_FMT( "Total fluid mass [{}]", massUnit ), + "all", CellType::MergeNext, stats.m_totalMass ); + }; + + // apply the output lambda for the mesh then each regions + outputRegionStats( GEOS_FMT( "Discretization '{}'", mesh.getName() ), meshRegionsStatistics ); + + m_aggregator->forRegionStatistics( mesh, meshRegionsStatistics, + [&] ( CellElementRegion & region, RegionStatistics & stats ) + { + outputRegionStats( GEOS_FMT( "Region '{}'", region.getName() ), stats ); + } ); + + // output to log + GEOS_LOG_RANK_0( formatter.toString( tableData ) ); +} + +void StatsTask::outputCsvStats( real64 statsTime, + MeshLevel & mesh, + RegionStatistics & meshRegionsStatistics ) +{ + if( MpiWrapper::commRank() > 0 || m_writeCSV == 0 ) + return; + + auto const formatterIter = m_csvFormatters.find( mesh.getName() ); + if( formatterIter==m_csvFormatters.end()) + return; + + TableCSVFormatter const & formatter = *formatterIter->second; + TableData tableData; + + stdVector< string > row; + row.reserve( formatter.getLayout().getTotalLowermostColumnCount() ); + + // lamda to apply for each region statistics + auto const outputRegionStats = [&] ( string_view targetName, RegionStatistics & stats ) + { + row.clear(); + row.insert( row.begin(), + { std::to_string( statsTime ), + string( targetName ), + std::to_string( stats.m_minPressure ), + std::to_string( stats.m_averagePressure ), + std::to_string( stats.m_maxPressure ), + std::to_string( stats.m_minDeltaPressure ), + std::to_string( stats.m_maxDeltaPressure ), + std::to_string( stats.m_minTemperature ), + std::to_string( stats.m_averageTemperature ), + std::to_string( stats.m_maxTemperature ), + std::to_string( stats.m_totalDynamicPoreVolume ), + std::to_string( stats.m_totalMass ), + } ); + + tableData.addRow( row ); + }; + + // apply the output lambda for the mesh then each regions + outputRegionStats( mesh.getName(), meshRegionsStatistics ); + + m_aggregator->forRegionStatistics( mesh, meshRegionsStatistics, + [&] ( CellElementRegion & region, RegionStatistics & stats ) + { + outputRegionStats( region.getName(), stats ); + } ); + + // append to csv file + std::ofstream outputFile( getCsvFileName( mesh.getName() ), std::ios_base::app ); + outputFile << formatter.dataToString( tableData ); + outputFile.close(); +} + +REGISTER_CATALOG_ENTRY( TaskBase, + StatsTask, + string const &, dataRepository::Group * const ) + +} /* namespace singlePhaseStatistics */ + +} /* namespace geos */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatistics.hpp b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsTask.hpp similarity index 53% rename from src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatistics.hpp rename to src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsTask.hpp index 4906790b026..c10a71a989c 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatistics.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseStatisticsTask.hpp @@ -14,25 +14,27 @@ */ /** - * @file SinglePhaseStatistics.hpp + * @file SinglePhaseStatisticsTask.hpp */ #ifndef SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_SINGLEPHASESTATISTICS_HPP_ #define SRC_CORECOMPONENTS_PHYSICSSOLVERS_FLUIDFLOW_SINGLEPHASESTATISTICS_HPP_ #include "physicsSolvers/FieldStatisticsBase.hpp" +#include "physicsSolvers/fluidFlow/SinglePhaseStatisticsAggregator.hpp" namespace geos { class SinglePhaseBase; +namespace singlePhaseStatistics +{ + /** - * @class SinglePhaseStatistics - * - * Task class allowing for the computation of aggregate statistics in single-phase simulations + * Task class allowing for the computation of aggregate statistics in single phase simulations */ -class SinglePhaseStatistics : public FieldStatisticsBase< SinglePhaseBase > +class StatsTask : public FieldStatisticsBase< SinglePhaseBase > { public: @@ -41,14 +43,11 @@ class SinglePhaseStatistics : public FieldStatisticsBase< SinglePhaseBase > * @param[in] name the name of the task coming from the xml * @param[in] parent the parent group of the task */ - SinglePhaseStatistics( const string & name, - Group * const parent ); + StatsTask( const string & name, dataRepository::Group * const parent ); /// Accessor for the catalog name static string catalogName() { return "SinglePhaseStatistics"; } - /// Accessor for the region statistics catalog name - static string regionStatisticsName() { return "regionStatistics"; } /** * @defgroup Tasks Interface Functions * @@ -65,64 +64,46 @@ class SinglePhaseStatistics : public FieldStatisticsBase< SinglePhaseBase > /**@}*/ + StatsAggregator & getStatisticsAggregator() + { return *m_aggregator; } - /** - * @struct viewKeyStruct holds char strings and viewKeys for fast lookup - */ - struct viewKeyStruct - { - /// String for the region statistics - constexpr static char const * regionStatisticsString() { return "regionStatistics"; } - }; - - struct RegionStatistics - { - /// average region pressure - real64 averagePressure; - /// minimum region pressure - real64 minPressure; - /// maximum region pressure - real64 maxPressure; - - /// minimum region delta pressure - real64 minDeltaPressure; - /// maximum region delta pressure - real64 maxDeltaPressure; - - // fluid mass - real64 totalMass; - - /// average region temperature - real64 averageTemperature; - /// minimum region temperature - real64 minTemperature; - /// maximum region temperature - real64 maxTemperature; - - /// total region pore volume - real64 totalPoreVolume; - /// total region uncompacted pore volume - real64 totalUncompactedPoreVolume; - }; + StatsAggregator const & getStatisticsAggregator() const + { return *m_aggregator; } private: using Base = FieldStatisticsBase< SinglePhaseBase >; - /** - * @brief Compute some statistics on the reservoir (average field pressure, etc) - * @param[in] mesh the mesh level object - * @param[in] regionNames the array of target region names - */ - void computeRegionStatistics( real64 const time, - MeshLevel & mesh, - string_array const & regionNames ) const; - + void postInputInitialization() override; void registerDataOnMesh( Group & meshBodies ) override; + void prepareLogTableLayouts( string_view tableName ); + + void prepareCsvTableLayouts( string_view tableName ); + + string getCsvFileName( string_view meshName ) const; + + void outputLogStats( real64 statsTime, + MeshLevel & mesh, + RegionStatistics & meshRegionsStatistics ); + + void outputCsvStats( real64 statsTime, + MeshLevel & mesh, + RegionStatistics & meshRegionsStatistics ); + + /// For each discretization (MeshLevel name), table formatter for log output. + stdMap< string, std::unique_ptr< TableTextFormatter > > m_logFormatters; + + /// For each discretization (MeshLevel name), table formatter for csv output. + stdMap< string, std::unique_ptr< TableCSVFormatter > > m_csvFormatters; + + // mesh statistics aggregator + std::unique_ptr< StatsAggregator > m_aggregator; + }; +} /* namespace singlePhaseStatistics */ } /* namespace geos */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/unitTests/testFlowStatistics.cpp b/src/coreComponents/physicsSolvers/fluidFlow/unitTests/testFlowStatistics.cpp index 356661e434e..e61551c70c3 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/unitTests/testFlowStatistics.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/unitTests/testFlowStatistics.cpp @@ -17,8 +17,13 @@ #include "integrationTests/testingUtilities/TestingTasks.hpp" #include "mainInterface/initialization.hpp" #include "mainInterface/GeosxState.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsAggregator.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsTask.hpp" +#include "physicsSolvers/fluidFlow/SinglePhaseBase.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseBase.hpp" +#include "physicsSolvers/fluidFlow/SinglePhaseStatisticsAggregator.hpp" #include "physicsSolvers/fluidFlow/SourceFluxStatistics.hpp" -#include "physicsSolvers/fluidFlow/SinglePhaseStatistics.hpp" +#include "physicsSolvers/fluidFlow/SinglePhaseStatisticsTask.hpp" #include @@ -46,6 +51,7 @@ struct TestInputs string timeStepFluxStatsPath; string wholeSimFluxStatsPath; string flowSolverPath; + string statsTaskPath; // rates for each timesteps, for each phases array2d< real64 > sourceRates; @@ -206,27 +212,19 @@ void setRateTable( array2d< real64 > & rateTable, std::initializer_list< std::in } } -real64 getTotalFluidMass( ProblemManager & problem, string_view flowSolverPath ) +template< typename SolverType, typename StatTaskType > +real64 getTotalFluidMass( ProblemManager & problem, + SolverType & solver, + StatTaskType const & statsTask ) { - real64 totalMass = 0.0; - PhysicsSolverBase const & solver = problem.getGroupByPath< PhysicsSolverBase >( string( flowSolverPath ) ); - solver.forDiscretizationOnMeshTargets( problem.getDomainPartition().getMeshBodies(), - [&] ( string const &, - MeshLevel & mesh, - string_array const & ) - { - mesh.getElemManager().forElementRegions( [&]( ElementRegionBase & region ) - { - SinglePhaseStatistics::RegionStatistics & regionStats = region.getReference< SinglePhaseStatistics::RegionStatistics >( - SinglePhaseStatistics::viewKeyStruct::regionStatisticsString() ); - - totalMass += regionStats.totalMass; - } ); - } ); - return totalMass; + MeshLevel & mesh = problem.getDomainPartition() + .getMeshBody( 0 ) + .getMeshLevel( solver.getDiscretizationName() ); + auto const & statsAggregator = statsTask.getStatisticsAggregator(); + auto const & stats = statsAggregator.getRegionsStatistics( mesh ); + return stats.m_totalMass; } - /** * @brief Verification that the source flux statistics are correct for the current timestep * @param expectedMasses the expected mass values per phase @@ -529,6 +527,7 @@ TestSet getTestSet() testInputs.timeStepFluxStatsPath = "/Tasks/timeStepFluxStats"; testInputs.wholeSimFluxStatsPath = "/Tasks/wholeSimFluxStats"; testInputs.flowSolverPath = "/Solvers/testSolver"; + testInputs.statsTaskPath = "/Tasks/timeStepReservoirStats"; testInputs.dt = 500.0; testInputs.sourceElementsCount = 2; @@ -565,8 +564,12 @@ TEST_F( FlowStatisticsTest, checkSinglePhaseFluxStatistics ) setupProblemFromXML( problem, testSet.inputs.xmlInput.data() ); - real64 firstMass; + SinglePhaseBase & flowSolver = + problem.getGroupByPath< SinglePhaseBase >( testSet.inputs.flowSolverPath ); + singlePhaseStatistics::StatsTask & statsTask = + problem.getGroupByPath< singlePhaseStatistics::StatsTask >( string( testSet.inputs.statsTaskPath ) ); + real64 firstMass; TimeStepChecker & timeStepChecker = problem.getGroupByPath< TimeStepChecker >( testSet.inputs.timeStepCheckerPath ); timeStepChecker.setTimeStepCheckingFunction( [&]( real64 const time_n ) { @@ -578,7 +581,7 @@ TEST_F( FlowStatisticsTest, checkSinglePhaseFluxStatistics ) if( !passedFirstTimeStep ) { passedFirstTimeStep = true; - firstMass = getTotalFluidMass( problem, testSet.inputs.flowSolverPath ); + firstMass = getTotalFluidMass( problem, flowSolver, statsTask ); } } ); @@ -589,12 +592,12 @@ TEST_F( FlowStatisticsTest, checkSinglePhaseFluxStatistics ) checkWholeSimTimeStepStats( problem, testSet, timeStepChecker ); // check singlephasestatistics results - real64 const lastMass = getTotalFluidMass( problem, testSet.inputs.flowSolverPath ); + real64 const lastMass = getTotalFluidMass( problem, flowSolver, statsTask ); real64 const massDiffTol = 1e-7; EXPECT_NEAR( lastMass - firstMass, -testSet.totalMassProd[0], massDiffTol * std::abs( testSet.totalMassProd[0] ) ) << GEOS_FMT( "{} total mass difference from start to end is not consistent with fluxes production.", - SinglePhaseStatistics::catalogName() ); + singlePhaseStatistics::StatsTask::catalogName() ); } @@ -806,6 +809,7 @@ TestSet getTestSet() testInputs.timeStepFluxStatsPath = "/Tasks/timeStepFluxStats"; testInputs.wholeSimFluxStatsPath = "/Tasks/wholeSimFluxStats"; testInputs.flowSolverPath = "/Solvers/testSolver"; + testInputs.statsTaskPath = "/Tasks/timeStepReservoirStats"; testInputs.dt = 500.0; testInputs.sourceElementsCount = 1; @@ -854,12 +858,25 @@ TEST_F( FlowStatisticsTest, checkMultiPhaseFluxStatisticsMass ) setupProblemFromXML( problem, testSet.inputs.xmlInput.data() ); + CompositionalMultiphaseBase & flowSolver = + problem.getGroupByPath< CompositionalMultiphaseBase >( testSet.inputs.flowSolverPath ); + compositionalMultiphaseStatistics::StatsTask & statsTask = + problem.getGroupByPath< compositionalMultiphaseStatistics::StatsTask >( string( testSet.inputs.statsTaskPath ) ); + + real64 firstMass; TimeStepChecker & timeStepChecker = problem.getGroupByPath< TimeStepChecker >( testSet.inputs.timeStepCheckerPath ); timeStepChecker.setTimeStepCheckingFunction( [&]( real64 const time_n ) { integer const timestepId = timeStepChecker.getTestedTimeStepCount(); checkTimeStepStats( testSet, time_n, timestepId ); checkTimeStepFluxStats( problem, testSet, time_n, timestepId ); + + static bool passedFirstTimeStep = false; + if( !passedFirstTimeStep ) + { + passedFirstTimeStep = true; + firstMass = getTotalFluidMass( problem, flowSolver, statsTask ); + } } ); // run simulation @@ -867,6 +884,14 @@ TEST_F( FlowStatisticsTest, checkMultiPhaseFluxStatisticsMass ) checkWholeSimFluxStats( problem, testSet ); checkWholeSimTimeStepStats( problem, testSet, timeStepChecker ); + + // check compositionalmultiphasestatistics results + real64 const lastMass = getTotalFluidMass( problem, flowSolver, statsTask ); + real64 const massDiffTol = 1e-5; + EXPECT_NEAR( lastMass - firstMass, + -( testSet.totalMassProd[0] + testSet.totalMassProd[1] ), + massDiffTol * std::abs( testSet.totalMassProd[0] + testSet.totalMassProd[1] ) ) << GEOS_FMT( "{} total mass difference from start to end is not consistent with fluxes production.", + singlePhaseStatistics::StatsTask::catalogName() ); } @@ -1078,6 +1103,7 @@ TestSet getTestSet() testInputs.timeStepFluxStatsPath = "/Tasks/timeStepFluxStats"; testInputs.wholeSimFluxStatsPath = "/Tasks/wholeSimFluxStats"; testInputs.flowSolverPath = "/Solvers/testSolver"; + testInputs.statsTaskPath = "/Tasks/timeStepReservoirStats"; testInputs.dt = 500.0; testInputs.sourceElementsCount = 1; @@ -1130,12 +1156,25 @@ TEST_F( FlowStatisticsTest, checkMultiPhaseFluxStatisticsMol ) setupProblemFromXML( problem, testSet.inputs.xmlInput.data() ); + CompositionalMultiphaseBase & flowSolver = + problem.getGroupByPath< CompositionalMultiphaseBase >( testSet.inputs.flowSolverPath ); + auto const & statsTask = + problem.getGroupByPath< compositionalMultiphaseStatistics::StatsTask >( string( testSet.inputs.statsTaskPath ) ); + + real64 firstMass; TimeStepChecker & timeStepChecker = problem.getGroupByPath< TimeStepChecker >( testSet.inputs.timeStepCheckerPath ); timeStepChecker.setTimeStepCheckingFunction( [&]( real64 const time_n ) { integer const timestepId = timeStepChecker.getTestedTimeStepCount(); checkTimeStepStats( testSet, time_n, timestepId ); checkTimeStepFluxStats( problem, testSet, time_n, timestepId ); + + static bool passedFirstTimeStep = false; + if( !passedFirstTimeStep ) + { + passedFirstTimeStep = true; + firstMass = getTotalFluidMass( problem, flowSolver, statsTask ); + } } ); // run simulation @@ -1143,6 +1182,14 @@ TEST_F( FlowStatisticsTest, checkMultiPhaseFluxStatisticsMol ) checkWholeSimFluxStats( problem, testSet ); checkWholeSimTimeStepStats( problem, testSet, timeStepChecker ); + + // check compositionalmultiphasestatistics results + real64 const lastMass = getTotalFluidMass( problem, flowSolver, statsTask ); + real64 const massDiffTol = 1e-5; + EXPECT_NEAR( lastMass - firstMass, + -( testSet.totalMassProd[0] + testSet.totalMassProd[1] ), + massDiffTol * std::abs( testSet.totalMassProd[0] + testSet.totalMassProd[1] ) ) << GEOS_FMT( "{} total mass difference from start to end is not consistent with fluxes production.", + singlePhaseStatistics::StatsTask::catalogName() ); } diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp index 98953ad39cb..6a72af7a90c 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp @@ -19,19 +19,23 @@ #include "CompositionalMultiphaseWell.hpp" +#include "LvArray/src/system.hpp" #include "codingUtilities/Utilities.hpp" #include "common/DataTypes.hpp" #include "common/TimingMacros.hpp" +#include "common/logger/Logger.hpp" #include "constitutive/ConstitutiveManager.hpp" #include "constitutive/fluid/multifluid/MultiFluidBase.hpp" #include "constitutive/fluid/multifluid/MultiFluidFields.hpp" #include "constitutive/fluid/multifluid/MultiFluidSelector.hpp" #include "dataRepository/Group.hpp" #include "mesh/DomainPartition.hpp" +#include "mesh/MeshBody.hpp" #include "mesh/PerforationFields.hpp" #include "mesh/WellElementSubRegion.hpp" #include "mesh/mpiCommunications/CommunicationTools.hpp" #include "physicsSolvers/LogLevelsInfo.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseBase.hpp" #include "physicsSolvers/fluidFlow/SolutionCheckHelpers.hpp" #include "physicsSolvers/fluidFlow/wells/LogLevelsInfo.hpp" #include "physicsSolvers/fluidFlow/wells/WellSolverBaseFields.hpp" @@ -49,7 +53,7 @@ #include "physicsSolvers/fluidFlow/kernels/compositional/PhaseVolumeFractionKernel.hpp" #include "physicsSolvers/fluidFlow/kernels/compositional/ThermalPhaseVolumeFractionKernel.hpp" #include "physicsSolvers/fluidFlow/kernels/compositional/FluidUpdateKernel.hpp" -#include "physicsSolvers/fluidFlow/CompositionalMultiphaseStatistics.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsAggregator.hpp" #if defined( __INTEL_COMPILER ) #pragma GCC optimize "O0" @@ -61,6 +65,19 @@ namespace geos using namespace dataRepository; using namespace constitutive; using namespace fields; +using namespace compositionalMultiphaseStatistics; + +CompositionalMultiphaseBase & getFlowSolver( CompositionalMultiphaseWell & wellSolver ) +{ + // TODO: change the way we access the flowSolver here + return wellSolver.getParent().getGroup< CompositionalMultiphaseBase >( wellSolver.getFlowSolverName() ); +} + +CompositionalMultiphaseBase const & getFlowSolver( CompositionalMultiphaseWell const & wellSolver ) +{ + // TODO: change the way we access the flowSolver here + return wellSolver.getParent().getGroup< CompositionalMultiphaseBase >( wellSolver.getFlowSolverName() ); +} CompositionalMultiphaseWell::CompositionalMultiphaseWell( const string & name, Group * const parent ) @@ -367,7 +384,7 @@ void CompositionalMultiphaseWell::validateConstitutiveModels( DomainPartition co GEOS_MARK_FUNCTION; ConstitutiveManager const & cm = domain.getConstitutiveManager(); - CompositionalMultiphaseBase const & flowSolver = getParent().getGroup< CompositionalMultiphaseBase >( getFlowSolverName() ); + CompositionalMultiphaseBase const & flowSolver = getFlowSolver( *this ); string const referenceFluidName = flowSolver.referenceFluidModelName(); MultiFluidBase const & referenceFluid = cm.getConstitutiveRelation< MultiFluidBase >( m_referenceFluidModelName ); @@ -430,33 +447,21 @@ void CompositionalMultiphaseWell::validateWellConstraints( real64 const & time_n WellElementSubRegion const & subRegion ) { WellControls & wellControls = getWellControls( subRegion ); + if( !wellControls.useSurfaceConditions() ) { - bool const useSeg =wellControls.referenceReservoirRegion().empty(); - GEOS_WARNING_IF( useSeg, - GEOS_FMT( "WellControls {} not set and well constraint fluid property calculations will use " - "top segement pressure and temp ", - WellControls::viewKeyStruct::referenceReservoirRegionString() ) ); - if( useSeg ) - { - wellControls.setRegionAveragePressure( -1 ); - wellControls.setRegionAverageTemperature( -1 ); - } - else - { - // Check if region name exists in list of Reservoir's target regions - string const regionName = wellControls.referenceReservoirRegion(); - CompositionalMultiphaseBase const & flowSolver = getParent().getGroup< CompositionalMultiphaseBase >( getFlowSolverName() ); - string_array const & targetRegionsNames = flowSolver.getTargetRegionNames(); - auto const pos = std::find( targetRegionsNames.begin(), targetRegionsNames.end(), regionName ); - GEOS_ERROR_IF( pos == targetRegionsNames.end(), - GEOS_FMT( "Region {} is not a target of the reservoir solver and cannot be used for referenceReservoirRegion in WellControl {}.", - regionName, wellControls.getName() ), - getDataContext() ); - + bool const useSegmentValues = wellControls.referenceReservoirRegion().empty(); + static bool firstNoRefRegionMsg = true; + if( useSegmentValues && firstNoRefRegionMsg ) + { + GEOS_WARNING( WellControls::viewKeyStruct::referenceReservoirRegionString() << + " not set: well constraint fluid property calculations will use top segement pressure and temp ", + wellControls.getDataContext() ); + firstNoRefRegionMsg = false; } } + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString()); MultiFluidBase const & fluid = subRegion.getConstitutiveModel< MultiFluidBase >( fluidName ); @@ -663,7 +668,7 @@ void CompositionalMultiphaseWell::updateBHPForConstraint( WellElementSubRegion & } -void CompositionalMultiphaseWell::updateVolRatesForConstraint( ElementRegionManager const & elemManager, WellElementSubRegion const & subRegion ) +void CompositionalMultiphaseWell::updateVolRatesForConstraint( WellElementSubRegion const & subRegion ) { GEOS_MARK_FUNCTION; @@ -681,9 +686,6 @@ void CompositionalMultiphaseWell::updateVolRatesForConstraint( ElementRegionMana WellControls & wellControls = getWellControls( subRegion ); // subRegion data - - arrayView1d< real64 const > const & pres = subRegion.getField< well::pressure >(); - arrayView1d< real64 const > const & temp = subRegion.getField< well::temperature >(); arrayView1d< real64 const > const & connRate = subRegion.getField< well::mixtureConnectionRate >(); arrayView2d< real64 const, compflow::USD_COMP > const & compFrac = subRegion.getField< well::globalCompFraction >(); @@ -708,47 +710,8 @@ void CompositionalMultiphaseWell::updateVolRatesForConstraint( ElementRegionMana string const massUnit = m_useMass ? "kg" : "mol"; integer const useSurfaceConditions = wellControls.useSurfaceConditions(); - real64 flashPressure; - real64 flashTemperature; - if( useSurfaceConditions ) - { - // use surface conditions - flashPressure = wellControls.getSurfacePressure(); - flashTemperature = wellControls.getSurfaceTemperature(); - } - else - { - if( !wellControls.referenceReservoirRegion().empty() ) - { - ElementRegionBase const & region = elemManager.getRegion( wellControls.referenceReservoirRegion()); - GEOS_ERROR_IF ( !region.hasWrapper( CompositionalMultiphaseStatistics::regionStatisticsName() ), - GEOS_FMT( "WellControl {} referenceReservoirRegion field requires CompositionalMultiphaseStatistics to be configured for region {} ", - wellControls.getName(), wellControls.referenceReservoirRegion() ), - getDataContext() ); - - CompositionalMultiphaseStatistics::RegionStatistics const & stats = region.getReference< CompositionalMultiphaseStatistics::RegionStatistics >( - CompositionalMultiphaseStatistics::regionStatisticsName() ); - wellControls.setRegionAveragePressure( stats.averagePressure ); - wellControls.setRegionAverageTemperature( stats.averageTemperature ); - GEOS_ERROR_IF( stats.averagePressure <= 0.0, - GEOS_FMT( "No region average quantities computed. WellControl {} referenceReservoirRegion field requires CompositionalMultiphaseStatistics to be configured for region {} ", - wellControls.getName(), wellControls.referenceReservoirRegion() ), - getDataContext()); - } - // If flashPressure is not set by region the value is defaulted to -1 and indicates to use top segment conditions - flashPressure = wellControls.getRegionAveragePressure(); - if( flashPressure < 0.0 ) - { - // region name not set, use segment conditions - flashPressure = pres[iwelemRef]; - flashTemperature = temp[iwelemRef]; - } - else - { - // use reservoir region averages - flashTemperature = wellControls.getRegionAverageTemperature(); - } - } + ReferenceConditions const refConditions = getReferenceConditions( subRegion ); + arrayView1d< real64 > const & currentPhaseVolRate = wellControls.getReference< array1d< real64 > >( CompositionalMultiphaseWell::viewKeyStruct::currentPhaseVolRateString() ); arrayView2d< real64 > const & dCurrentPhaseVolRate = @@ -778,8 +741,6 @@ void CompositionalMultiphaseWell::updateVolRatesForConstraint( ElementRegionMana forAll< serialPolicy >( 1, [&numComp, &numPhase, fluidSeparatorWrapper, - pres, - temp, compFrac, dCompFrac_dCompDens, connRate, @@ -791,8 +752,7 @@ void CompositionalMultiphaseWell::updateVolRatesForConstraint( ElementRegionMana dPhaseFrac, logSurfaceCondition, &useSurfaceConditions, - &flashPressure, - &flashTemperature, + &refConditions, ¤tTotalVolRate, dCurrentTotalVolRate, currentPhaseVolRate, @@ -812,24 +772,18 @@ void CompositionalMultiphaseWell::updateVolRatesForConstraint( ElementRegionMana // - Surface conditions: using the surface pressure provided by the user // - Segment conditions: using the pressure in the top element // - Reservoir conditions: using the average region pressure - if( useSurfaceConditions ) + fluidSeparatorWrapper.update( iwelemRef, 0, + refConditions.pressure, refConditions.temperature, + compFrac[iwelemRef] ); + if( useSurfaceConditions && logSurfaceCondition ) { - // we need to compute the surface density - fluidSeparatorWrapper.update( iwelemRef, 0, flashPressure, flashTemperature, compFrac[iwelemRef] ); - if( logSurfaceCondition ) - { - GEOS_LOG_RANK( GEOS_FMT( "{}: surface density computed with P_surface = {} Pa and T_surface = {} K", - wellControlsName, flashPressure, flashTemperature ) ); - } + GEOS_LOG_RANK( GEOS_FMT( "{}: surface density computed with P_surface = {} Pa and T_surface = {} K", + wellControlsName, refConditions.pressure, refConditions.temperature ) ); + } #ifdef GEOS_USE_HIP - GEOS_UNUSED_VAR( wellControlsName ); + GEOS_UNUSED_VAR( wellControlsName ); #endif - } - else - { - fluidSeparatorWrapper.update( iwelemRef, 0, flashPressure, flashTemperature, compFrac[iwelemRef] ); - } // Step 2: update the total volume rate real64 const currentTotalRate = connRate[iwelemRef]; @@ -917,7 +871,97 @@ void CompositionalMultiphaseWell::updateVolRatesForConstraint( ElementRegionMana } ); } +void CompositionalMultiphaseWell::precomputeReferenceConditions( real64 const time_n, + Group & meshBodies, + MeshBody & meshBody, + WellElementSubRegion const & subRegion ) +{ + WellControls & wellControls = getWellControls( subRegion ); + integer const useSurfaceConditions = wellControls.useSurfaceConditions(); + if( !useSurfaceConditions ) + { + string_view refRegionName = wellControls.referenceReservoirRegion(); + bool const useSegmentValues = refRegionName.empty(); + if( useSegmentValues ) + { + wellControls.setRegionAveragePressure( -1 ); + wellControls.setRegionAverageTemperature( -1 ); + } + else + { + auto & flowSolver = getParent().getGroup< CompositionalMultiphaseBase >( getFlowSolverName() ); + MeshLevel & flowMeshLevel = meshBody.getMeshLevel( flowSolver.getDiscretizationName() ); + + if( !m_reservoirStatsAggregator ) + { // lazily initialize the region statistics aggregator + m_reservoirStatsAggregator = std::make_unique< StatsAggregator >( wellControls.getDataContext(), + meshBodies, + false ); + m_reservoirStatsAggregator->initStatisticsAggregation( flowSolver ); + m_reservoirStatsAggregator->enableRegionStatisticsAggregation(); + } + + RegionStatistics & stats = m_reservoirStatsAggregator->getRegionStatistics( flowMeshLevel, refRegionName ); + // compute region stats only if needed (could have already been done for another subRegion) + if( !m_reservoirStatsAggregator->isComputed( time_n, stats ) ) + m_reservoirStatsAggregator->computeRegionsStatistics( time_n ); + + GEOS_WARNING_IF( stats.m_averagePressure <= 0.0, + GEOS_FMT( "No region average quantities computed in reference region '{}'.", + wellControls.referenceReservoirRegion() ), + wellControls.getWrapperDataContext( WellControls::viewKeyStruct::referenceReservoirRegionString() ), + getDataContext() ); + + wellControls.setRegionAveragePressure( stats.m_averagePressure ); + wellControls.setRegionAverageTemperature( stats.m_averageTemperature ); + } + } +} + +CompositionalMultiphaseWell::ReferenceConditions +CompositionalMultiphaseWell::getReferenceConditions( WellElementSubRegion const & subRegion ) +{ + WellControls & wellControls = getWellControls( subRegion ); + integer const useSurfaceConditions = wellControls.useSurfaceConditions(); + if( useSurfaceConditions ) + { + // use surface conditions + return { + /* .pressure = */ wellControls.getSurfacePressure(), + /* .temperature = */ wellControls.getSurfaceTemperature(), + }; + } + else + { + if( wellControls.getRegionAveragePressure() > 0.0 && wellControls.getRegionAverageTemperature() > 0.0 ) + { // reference region condition properly computed, we can return them + return { + /* .pressure = */ wellControls.getRegionAveragePressure(), + /* .temperature = */ wellControls.getRegionAverageTemperature(), + }; + } + else + { // region average stats not initialized or initialized, fallback to top segment values + static bool firstNoRefRegionMsg = true; + if( firstNoRefRegionMsg ) + { + GEOS_WARNING( "CompositionalMultiphaseWell: region average statsistics of reference region not initialized," + " fallback to top segment values.", + wellControls.getDataContext() ); + firstNoRefRegionMsg=false; + } + + arrayView1d< real64 const > const & pres = subRegion.getField< well::pressure >(); + arrayView1d< real64 const > const & temp = subRegion.getField< well::temperature >(); + localIndex const iwelemRef = subRegion.getTopWellElementIndex(); + return { + /* .pressure = */ pres[iwelemRef], + /* .temperature = */ temp[iwelemRef], + }; + } + } +} void CompositionalMultiphaseWell::updateFluidModel( WellElementSubRegion & subRegion ) { @@ -1008,7 +1052,7 @@ void CompositionalMultiphaseWell::updateState( DomainPartition & domain ) WellControls & wellControls = getWellControls( subRegion ); if( wellControls.getWellStatus() == WellControls::Status::OPEN ) { - real64 const maxRegionPhaseVolFrac = updateSubRegionState( elemManager, subRegion ); + real64 const maxRegionPhaseVolFrac = updateSubRegionState( subRegion ); maxPhaseVolFrac = LvArray::math::max( maxRegionPhaseVolFrac, maxPhaseVolFrac ); } } ); @@ -1021,14 +1065,14 @@ void CompositionalMultiphaseWell::updateState( DomainPartition & domain ) } -real64 CompositionalMultiphaseWell::updateSubRegionState( ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ) +real64 CompositionalMultiphaseWell::updateSubRegionState( WellElementSubRegion & subRegion ) { // update properties updateGlobalComponentFraction( subRegion ); // update volumetric rates for the well constraints // note: this must be called before updateFluidModel - updateVolRatesForConstraint( elemManager, subRegion ); + updateVolRatesForConstraint( subRegion ); // update densities, phase fractions, phase volume fractions @@ -1047,16 +1091,17 @@ void CompositionalMultiphaseWell::initializeWells( DomainPartition & domain, rea integer const numComp = m_numComponents; integer const numPhase = m_numPhases; - // TODO: change the way we access the flowSolver here - CompositionalMultiphaseBase const & flowSolver = getParent().getGroup< CompositionalMultiphaseBase >( getFlowSolverName() ); + Group & meshBodies = domain.getMeshBodies(); + CompositionalMultiphaseBase const & flowSolver = getFlowSolver( *this ); // loop over the wells - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) + forDiscretizationOnMeshTargets( meshBodies, [&] ( string const & meshBodyName, + MeshLevel & mesh, + string_array const & regionNames ) { - + MeshBody & meshBody = domain.getMeshBody( meshBodyName ); ElementRegionManager & elemManager = mesh.getElemManager(); + compositionalMultiphaseWellKernels::PresTempCompFracInitializationKernel::CompFlowAccessors resCompFlowAccessors( mesh.getElemManager(), flowSolver.getName() ); compositionalMultiphaseWellKernels::PresTempCompFracInitializationKernel::MultiFluidAccessors @@ -1145,7 +1190,8 @@ void CompositionalMultiphaseWell::initializeWells( DomainPartition & domain, rea wellElemCompDens ); // 5) Recompute the pressure-dependent properties - updateSubRegionState( elemManager, subRegion ); + precomputeReferenceConditions( time_n, meshBodies, meshBody, subRegion ); + updateSubRegionState( subRegion ); // 6) Estimate the well rates // TODO: initialize rates using perforation rates @@ -1728,7 +1774,7 @@ void CompositionalMultiphaseWell::computePerforationRates( real64 const & time_n { // TODO: change the way we access the flowSolver here - CompositionalMultiphaseBase const & flowSolver = getParent().getGroup< CompositionalMultiphaseBase >( getFlowSolverName() ); + CompositionalMultiphaseBase const & flowSolver = getFlowSolver( *this ); ElementRegionManager & elemManager = mesh.getElemManager(); elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, @@ -1954,7 +2000,7 @@ void CompositionalMultiphaseWell::resetStateToBeginningOfStep( DomainPartition & if( wellControls.isWellOpen( ) ) { - updateSubRegionState( elemManager, subRegion ); + updateSubRegionState( subRegion ); } } ); } ); @@ -2092,12 +2138,16 @@ void CompositionalMultiphaseWell::implicitStepSetup( real64 const & time_n, { WellSolverBase::implicitStepSetup( time_n, dt, domain ); - forDiscretizationOnMeshTargets ( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { + if( m_reservoirStatsAggregator ) + m_reservoirStatsAggregator->setDirty(); // TODO: is it useful? are timestep cut properly managed for this call? + Group & meshBodies = domain.getMeshBodies(); + forDiscretizationOnMeshTargets ( meshBodies, [&] ( string const & meshBodyName, + MeshLevel & mesh, + string_array const & regionNames ) + { ElementRegionManager & elemManager = mesh.getElemManager(); + MeshBody & meshBody = domain.getMeshBody( meshBodyName ); elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, @@ -2148,7 +2198,8 @@ void CompositionalMultiphaseWell::implicitStepSetup( real64 const & time_n, validateWellConstraints( time_n, dt, subRegion ); - updateSubRegionState( elemManager, subRegion ); + precomputeReferenceConditions( time_n, meshBodies, meshBody, subRegion ); + updateSubRegionState( subRegion ); } } ) ; diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.hpp index cb8ed9f1a6f..677ea19d64c 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.hpp @@ -20,8 +20,10 @@ #ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_COMPOSITIONALMULTIPHASEWELL_HPP_ #define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_COMPOSITIONALMULTIPHASEWELL_HPP_ +#include "common/DataTypes.hpp" #include "constitutive/fluid/multifluid/Layouts.hpp" #include "constitutive/relativePermeability/Layouts.hpp" +#include "mesh/MeshLevel.hpp" #include "physicsSolvers/fluidFlow/wells/WellSolverBase.hpp" #include "physicsSolvers/fluidFlow/CompositionalMultiphaseBase.hpp" @@ -34,6 +36,11 @@ class ConstitutiveManager; class MultiFluidBase; } +namespace compositionalMultiphaseStatistics +{ +class StatsAggregator; +} + /** * @class CompositionalMultiphaseWell * @@ -143,7 +150,7 @@ class CompositionalMultiphaseWell : public WellSolverBase * @param elemManager the well region manager containing the well * @param subRegion the well subregion containing all the primary and dependent fields */ - void updateVolRatesForConstraint( ElementRegionManager const & elemManager, WellElementSubRegion const & subRegion ); + void updateVolRatesForConstraint( WellElementSubRegion const & subRegion ); /** * @brief Recompute the current BHP pressure @@ -185,7 +192,7 @@ class CompositionalMultiphaseWell : public WellSolverBase */ virtual void updateState( DomainPartition & domain ) override; - virtual real64 updateSubRegionState( ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ) override; + virtual real64 updateSubRegionState( WellElementSubRegion & subRegion ) override; virtual string wellElementDofName() const override { return viewKeyStruct::dofFieldString(); } @@ -358,6 +365,12 @@ class CompositionalMultiphaseWell : public WellSolverBase private: + struct ReferenceConditions + { + real64 pressure; + real64 temperature; + }; + /** * @brief Initialize all the primary and secondary variables in all the wells * @param domain the domain containing the well manager to access individual wells @@ -366,7 +379,12 @@ class CompositionalMultiphaseWell : public WellSolverBase virtual void setConstitutiveNames( ElementSubRegionBase & subRegion ) const override; + void precomputeReferenceConditions( real64 time_n, + Group & meshBodies, + MeshBody & meshBody, + WellElementSubRegion const & subRegion ); + ReferenceConditions getReferenceConditions( WellElementSubRegion const & subRegion ); /// flag indicating whether mass or molar formulation should be used integer m_useMass; @@ -398,6 +416,8 @@ class CompositionalMultiphaseWell : public WellSolverBase /// index of the target phase, used to impose the phase rate constraint localIndex m_targetPhaseIndex; + /// optional statistics aggregator to get the average pressure of simulated region + std::unique_ptr< compositionalMultiphaseStatistics::StatsAggregator > m_reservoirStatsAggregator; }; diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.cpp index 875ddfba049..b2bbfabfe9b 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.cpp @@ -27,6 +27,7 @@ #include "constitutive/fluid/singlefluid/SingleFluidSelector.hpp" #include "dataRepository/Group.hpp" #include "mesh/DomainPartition.hpp" +#include "mesh/ElementRegionManager.hpp" #include "mesh/WellElementSubRegion.hpp" #include "mesh/PerforationFields.hpp" #include "mesh/mpiCommunications/CommunicationTools.hpp" @@ -44,7 +45,7 @@ #include "physicsSolvers/fluidFlow/wells/kernels/SinglePhasePerforationFluxKernels.hpp" #include "physicsSolvers/fluidFlow/kernels/singlePhase/FluidUpdateKernel.hpp" #include "physicsSolvers/fluidFlow/kernels/singlePhase/SolutionCheckKernel.hpp" -#include "physicsSolvers/fluidFlow/SinglePhaseStatistics.hpp" +#include "physicsSolvers/fluidFlow/SinglePhaseStatisticsAggregator.hpp" namespace geos { @@ -53,6 +54,19 @@ using namespace dataRepository; using namespace constitutive; using namespace fields; using namespace singlePhaseWellKernels; +using namespace singlePhaseStatistics; + +SinglePhaseBase & getFlowSolver( SinglePhaseWell & wellSolver ) +{ + // TODO: change the way we access the flowSolver here + return wellSolver.getParent().getGroup< SinglePhaseBase >( wellSolver.getFlowSolverName() ); +} + +SinglePhaseBase const & getFlowSolver( SinglePhaseWell const & wellSolver ) +{ + // TODO: change the way we access the flowSolver here + return wellSolver.getParent().getGroup< SinglePhaseBase >( wellSolver.getFlowSolverName() ); +} SinglePhaseWell::SinglePhaseWell( const string & name, Group * const parent ): @@ -144,29 +158,21 @@ void SinglePhaseWell::validateWellConstraints( real64 const & time_n, WellElementSubRegion const & subRegion ) { WellControls & wellControls = getWellControls( subRegion ); + if( !wellControls.useSurfaceConditions() ) { - bool useSeg = wellControls.referenceReservoirRegion().empty(); - GEOS_WARNING_IF( useSeg, - "WellControls referenceReservoirRegion not set and well constraint fluid property calculations will use top segement pressure and temp " ); - if( useSeg ) - { - wellControls.setRegionAveragePressure( -1 ); - } - else - { - // Check if region name exists in list of Reservoir's target regions - string const regionName = wellControls.referenceReservoirRegion(); - SinglePhaseBase const & flowSolver = getParent().getGroup< SinglePhaseBase >( getFlowSolverName() ); - string_array const & targetRegionsNames = flowSolver.getTargetRegionNames(); - auto const pos = std::find( targetRegionsNames.begin(), targetRegionsNames.end(), regionName ); - GEOS_ERROR_IF( pos == targetRegionsNames.end(), - GEOS_FMT( "Region {} is not a target of the reservoir solver and cannot be used for referenceReservoirRegion in WellControl {}.", - regionName, wellControls.getName() ), - getDataContext() ); + bool useSegmentValues = wellControls.referenceReservoirRegion().empty(); + static bool firstNoRefRegionMsg = true; + if( useSegmentValues && firstNoRefRegionMsg ) + { + GEOS_WARNING( WellControls::viewKeyStruct::referenceReservoirRegionString() << + " not set: well constraint fluid property calculations will use top segement pressure and temp ", + wellControls.getDataContext() ); + firstNoRefRegionMsg = false; } } + WellControls::Control currentControl = wellControls.getControl(); real64 const targetTotalRate = wellControls.getTargetTotalRate( time_n ); real64 const targetPhaseRate = wellControls.getTargetPhaseRate( time_n ); @@ -250,7 +256,7 @@ void SinglePhaseWell::updateBHPForConstraint( WellElementSubRegion & subRegion ) } -void SinglePhaseWell::updateVolRateForConstraint( ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ) +void SinglePhaseWell::updateVolRateForConstraint( WellElementSubRegion & subRegion ) { GEOS_MARK_FUNCTION; @@ -264,9 +270,6 @@ void SinglePhaseWell::updateVolRateForConstraint( ElementRegionManager const & e // subRegion data - arrayView1d< real64 const > const pres = - subRegion.getField< well::pressure >(); - arrayView1d< real64 const > const & connRate = subRegion.getField< well::connectionRate >(); @@ -283,39 +286,8 @@ void SinglePhaseWell::updateVolRateForConstraint( ElementRegionManager const & e string const wellControlsName = wellControls.getName(); bool const logSurfaceCondition = isLogLevelActive< logInfo::WellControl >( wellControls.getLogLevel()); integer const useSurfaceConditions = wellControls.useSurfaceConditions(); - real64 flashPressure; - if( useSurfaceConditions ) - { - // use surface conditions - flashPressure = wellControls.getSurfacePressure(); - } - else - { - if( !wellControls.referenceReservoirRegion().empty() ) - { - ElementRegionBase const & region = elemManager.getRegion( wellControls.referenceReservoirRegion() ); - GEOS_ERROR_IF ( !region.hasWrapper( SinglePhaseStatistics::regionStatisticsName()), - GEOS_FMT( "WellControl {} referenceReservoirRegion field requires SinglePhaseStatistics to be configured for region {} ", - wellControls.getName(), wellControls.referenceReservoirRegion() ), - getDataContext() ); - - SinglePhaseStatistics::RegionStatistics const & stats = region.getReference< SinglePhaseStatistics::RegionStatistics >( SinglePhaseStatistics::regionStatisticsName() ); - GEOS_ERROR_IF( stats.averagePressure <= 0.0, - GEOS_FMT( - "No region average quantities computed. WellControl {} referenceReservoirRegion field requires SinglePhaseStatistics to be configured for region {} ", - wellControls.getName(), wellControls.referenceReservoirRegion() ), - getDataContext()); - wellControls.setRegionAveragePressure( stats.averagePressure ); - wellControls.setRegionAverageTemperature( stats.averageTemperature ); - } - // use region conditions - flashPressure = wellControls.getRegionAveragePressure(); - if( flashPressure < 0.0 ) - { - // use segment conditions - flashPressure = pres[iwelemRef]; - } - } + ReferenceConditions const refConditions = getReferenceConditions( subRegion ); + real64 & currentVolRate = wellControls.getReference< real64 >( SinglePhaseWell::viewKeyStruct::currentVolRateString() ); @@ -332,13 +304,12 @@ void SinglePhaseWell::updateVolRateForConstraint( ElementRegionManager const & e using COFFSET_WJ = singlePhaseWellKernels::ColOffset_WellJac< IS_THERMAL >; // bring everything back to host, capture the scalars by reference forAll< serialPolicy >( 1, [fluidWrapper, - pres, connRate, dens, dDens, logSurfaceCondition, &useSurfaceConditions, - &flashPressure, + refConditions, ¤tVolRate, dCurrentVolRate, &iwelemRef, @@ -348,28 +319,17 @@ void SinglePhaseWell::updateVolRateForConstraint( ElementRegionManager const & e // - Surface conditions: using the surface pressure provided by the user // - Reservoir conditions: using the pressure in the top element - if( useSurfaceConditions ) + fluidWrapper.update( iwelemRef, 0, refConditions.pressure ); + if( useSurfaceConditions && logSurfaceCondition ) { - // we need to compute the surface density - fluidWrapper.update( iwelemRef, 0, flashPressure ); - if( logSurfaceCondition ) - { - - GEOS_LOG_RANK( GEOS_FMT( "{}: surface density computed with P_surface = {} Pa", - wellControlsName, flashPressure ) ); - } + GEOS_LOG_RANK( GEOS_FMT( "{}: surface density computed with P_surface = {} Pa", + wellControlsName, refConditions.pressure ) ); + } #ifdef GEOS_USE_HIP - GEOS_UNUSED_VAR( wellControlsName ); + GEOS_UNUSED_VAR( wellControlsName ); #endif - } - else - { - real64 const refPres = pres[iwelemRef]; - fluidWrapper.update( iwelemRef, 0, refPres ); - } - real64 const densInv = 1.0 / dens[iwelemRef][0]; currentVolRate = connRate[iwelemRef] * densInv; @@ -389,6 +349,92 @@ void SinglePhaseWell::updateVolRateForConstraint( ElementRegionManager const & e } ); } +void SinglePhaseWell::precomputeReferenceConditions( real64 const time_n, + Group & meshBodies, + MeshBody & meshBody, + WellElementSubRegion const & subRegion ) +{ + WellControls & wellControls = getWellControls( subRegion ); + integer const useSurfaceConditions = wellControls.useSurfaceConditions(); + if( !useSurfaceConditions ) + { + string_view refRegionName = wellControls.referenceReservoirRegion(); + bool const useSegmentValues = refRegionName.empty(); + if( useSegmentValues ) + { + wellControls.setRegionAveragePressure( -1 ); + wellControls.setRegionAverageTemperature( -1 ); + } + else + { + auto & flowSolver = getParent().getGroup< SinglePhaseBase >( getFlowSolverName() ); + MeshLevel & flowMeshLevel = meshBody.getMeshLevel( flowSolver.getDiscretizationName() ); + + if( !m_reservoirStatsAggregator ) + { // lazily initialize the region statistics aggregator + m_reservoirStatsAggregator = std::make_unique< StatsAggregator >( wellControls.getDataContext(), + meshBodies, + false ); + m_reservoirStatsAggregator->initStatisticsAggregation( flowSolver ); + m_reservoirStatsAggregator->enableRegionStatisticsAggregation(); + } + + RegionStatistics & stats = m_reservoirStatsAggregator->getRegionStatistics( flowMeshLevel, refRegionName ); + + // compute region stats only if needed (could have already been done for another subRegion) + if( !m_reservoirStatsAggregator->isComputed( time_n, stats ) ) + m_reservoirStatsAggregator->computeRegionsStatistics( time_n ); + + GEOS_WARNING_IF( stats.m_averagePressure <= 0.0, + GEOS_FMT( "No region average quantities computed in reference region '{}'.", + wellControls.referenceReservoirRegion() ), + wellControls.getWrapperDataContext( WellControls::viewKeyStruct::referenceReservoirRegionString() ), + getDataContext() ); + + wellControls.setRegionAveragePressure( stats.m_averagePressure ); + wellControls.setRegionAverageTemperature( stats.m_averageTemperature ); + } + } +} + +SinglePhaseWell::ReferenceConditions +SinglePhaseWell::getReferenceConditions( WellElementSubRegion const & subRegion ) +{ + WellControls & wellControls = getWellControls( subRegion ); + integer const useSurfaceConditions = wellControls.useSurfaceConditions(); + if( useSurfaceConditions ) + { + // use surface conditions + return { + /* .pressure = */ wellControls.getSurfacePressure(), + /* .temperature = */ wellControls.getSurfaceTemperature(), + }; + } + else + { + if( wellControls.getRegionAveragePressure() > 0.0 && wellControls.getRegionAverageTemperature() > 0.0 ) + { // reference region condition properly computed, we can return them + return { + /* .pressure = */ wellControls.getRegionAveragePressure(), + /* .temperature = */ wellControls.getRegionAverageTemperature(), + }; + } + else + { // region average stats not initialized or initialized, fallback to top segment values + GEOS_WARNING( "Region average statistics of reference region not initialized, fallback to top segment values.", + wellControls.getDataContext() ); + + arrayView1d< real64 const > const & pres = subRegion.getField< well::pressure >(); + arrayView1d< real64 const > const & temp = subRegion.getField< well::temperature >(); + localIndex const iwelemRef = subRegion.getTopWellElementIndex(); + return { + /* .pressure = */ pres[iwelemRef], + /* .temperature = */ temp[iwelemRef], + }; + } + } +} + void SinglePhaseWell::updateFluidModel( WellElementSubRegion & subRegion ) const { GEOS_MARK_FUNCTION; @@ -406,11 +452,11 @@ void SinglePhaseWell::updateFluidModel( WellElementSubRegion & subRegion ) const } ); } -real64 SinglePhaseWell::updateSubRegionState( ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ) +real64 SinglePhaseWell::updateSubRegionState( WellElementSubRegion & subRegion ) { // update volumetric rates for the well constraints // Warning! This must be called before updating the fluid model - updateVolRateForConstraint( elemManager, subRegion ); + updateVolRateForConstraint( subRegion ); // update density in the well elements updateFluidModel( subRegion ); @@ -427,12 +473,15 @@ void SinglePhaseWell::initializeWells( DomainPartition & domain, real64 const & GEOS_MARK_FUNCTION; GEOS_UNUSED_VAR( time_n ); + Group & meshBodies = domain.getMeshBodies(); + // loop over the wells - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const & meshBodyName, MeshLevel & meshLevel, string_array const & regionNames ) { ElementRegionManager & elemManager = meshLevel.getElemManager(); + MeshBody & meshBody = domain.getMeshBody( meshBodyName ); elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, @@ -468,7 +517,7 @@ void SinglePhaseWell::initializeWells( DomainPartition & domain, real64 const & if( wellControls.isWellOpen() && !hasNonZeroRate ) { // TODO: change the way we access the flowSolver here - SinglePhaseBase const & flowSolver = getParent().getGroup< SinglePhaseBase >( getFlowSolverName() ); + SinglePhaseBase const & flowSolver = getFlowSolver( *this ); PresTempInitializationKernel::SinglePhaseFlowAccessors resSinglePhaseFlowAccessors( meshLevel.getElemManager(), flowSolver.getName() ); PresTempInitializationKernel::SingleFluidAccessors resSingleFluidAccessors( meshLevel.getElemManager(), flowSolver.getName() ); @@ -496,7 +545,8 @@ void SinglePhaseWell::initializeWells( DomainPartition & domain, real64 const & // 4) Recompute the pressure-dependent properties // Note: I am leaving that here because I would like to use the perforationRates (computed in UpdateState) // to better initialize the rates - updateSubRegionState( elemManager, subRegion ); + precomputeReferenceConditions( time_n, meshBodies, meshBody, subRegion ); + updateSubRegionState( subRegion ); string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); SingleFluidBase & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); @@ -840,7 +890,7 @@ void SinglePhaseWell::computePerforationRates( real64 const & time_n, { // TODO: change the way we access the flowSolver here - SinglePhaseBase const & flowSolver = getParent().getGroup< SinglePhaseBase >( getFlowSolverName() ); + SinglePhaseBase const & flowSolver = getFlowSolver( *this ); PerforationKernel::SinglePhaseFlowAccessors resSinglePhaseFlowAccessors( mesh.getElemManager(), flowSolver.getName() ); PerforationKernel::SingleFluidAccessors resSingleFluidAccessors( mesh.getElemManager(), flowSolver.getName() ); ElementRegionManager & elemManager = mesh.getElemManager(); @@ -1159,7 +1209,7 @@ void SinglePhaseWell::resetStateToBeginningOfStep( DomainPartition & domain ) subRegion.getField< well::connectionRate_n >(); connRate.setValues< parallelDevicePolicy<> >( connRate_n ); - updateSubRegionState( elemManager, subRegion ); + updateSubRegionState( subRegion ); } ); } ); } @@ -1171,11 +1221,14 @@ void SinglePhaseWell::implicitStepSetup( real64 const & time, { WellSolverBase::implicitStepSetup( time, dt, domain ); - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { + if( m_reservoirStatsAggregator ) + m_reservoirStatsAggregator->setDirty(); // TODO: is it useful? are timestep cut properly managed for this call? + Group & meshBodies = domain.getMeshBodies(); + forDiscretizationOnMeshTargets( meshBodies, [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { ElementRegionManager & elemManager = mesh.getElemManager(); elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, @@ -1201,7 +1254,7 @@ void SinglePhaseWell::implicitStepSetup( real64 const & time, validateWellConstraints( time, dt, subRegion ); - updateSubRegionState( elemManager, subRegion ); + updateSubRegionState( subRegion ); } ); } ); } diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.hpp index 8c07e223fb7..b82ebe96342 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.hpp @@ -36,6 +36,12 @@ namespace constitutive { class SingleFluidBase; } + +namespace singlePhaseStatistics +{ +class StatsAggregator; +} + class WellElementSubRegion; /** @@ -143,7 +149,7 @@ class SinglePhaseWell : public WellSolverBase * @param elemManager the well region manager * @param subRegion the well subregion containing all the primary and dependent fields */ - virtual void updateVolRateForConstraint( ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ); + virtual void updateVolRateForConstraint( WellElementSubRegion & subRegion ); /** * @brief Recompute the BHP pressure that is used in the well constraints @@ -169,7 +175,7 @@ class SinglePhaseWell : public WellSolverBase * @param elemManager the elemManager containing the well * @param subRegion the well subRegion containing the well elements and their associated fields */ - virtual real64 updateSubRegionState( ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ) override; + virtual real64 updateSubRegionState( WellElementSubRegion & subRegion ) override; /** * @brief function to assemble the linear system matrix and rhs @@ -279,6 +285,15 @@ class SinglePhaseWell : public WellSolverBase private: + struct ReferenceConditions + { + real64 pressure; + real64 temperature; + }; + + /// optional statistics aggregator to get the average pressure of simulated region + std::unique_ptr< singlePhaseStatistics::StatsAggregator > m_reservoirStatsAggregator; + virtual void setConstitutiveNames( ElementSubRegionBase & subRegion ) const override; /** @@ -287,6 +302,13 @@ class SinglePhaseWell : public WellSolverBase */ void initializeWells( DomainPartition & domain, real64 const & time_n ) override; + void precomputeReferenceConditions( real64 time_n, + Group & meshBodies, + MeshBody & meshBody, + WellElementSubRegion const & subRegion ); + + ReferenceConditions getReferenceConditions( WellElementSubRegion const & subRegion ); + /** * @brief Make sure that the well constraints are compatible * @param time_n the time at the beginning of the time step diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellControls.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellControls.hpp index 301c3c42f7c..a85e2868941 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellControls.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellControls.hpp @@ -252,7 +252,7 @@ class WellControls : public dataRepository::Group * @brief Getter for the reservoir region associated with reservoir volume constraint * @return name of reservoir region */ - string referenceReservoirRegion() const { return m_referenceReservoirRegion; } + string const & referenceReservoirRegion() const { return m_referenceReservoirRegion; } /** * @brief Getter for the surface pressure when m_useSurfaceConditions == 1 @@ -316,12 +316,14 @@ class WellControls : public dataRepository::Group /** * @brief Getter for the reservoir average pressure when m_useSurfaceConditions == 0 + * @note When not available, value is less or equal to 0.0. * @return the pressure */ real64 getRegionAveragePressure() const { return m_regionAveragePressure; } /** * @brief Set the reservoir average pressure when m_useSurfaceConditions == 0 + * @note When not available, value is less or equal to 0.0. * @param[in] regionAveragePressure value for pressure */ void setRegionAveragePressure( real64 regionAveragePressure ) { m_regionAveragePressure = regionAveragePressure; } diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.cpp index 060ff895e73..61b9398d0e6 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.cpp @@ -19,7 +19,9 @@ #include "WellSolverBase.hpp" +#include "dataRepository/Group.hpp" #include "mesh/DomainPartition.hpp" +#include "mesh/MeshBody.hpp" #include "mesh/PerforationFields.hpp" #include "mesh/WellElementRegion.hpp" #include "mesh/WellElementSubRegion.hpp" @@ -151,9 +153,10 @@ void WellSolverBase::initializePostSubGroups() { DomainPartition & domain = this->getGroupByPath< DomainPartition >( "/Problem/domain" ); FunctionManager & functionManager = FunctionManager::getInstance(); - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) + Group & meshBodies = domain.getMeshBodies(); + forDiscretizationOnMeshTargets( meshBodies, [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) { ElementRegionManager & elemManager = mesh.getElemManager(); elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, @@ -310,7 +313,7 @@ void WellSolverBase::updateState( DomainPartition & domain ) ElementRegionManager & elemManager = mesh.getElemManager(); elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, WellElementSubRegion & subRegion ) - { updateSubRegionState( elemManager, subRegion ); } ); + { updateSubRegionState( subRegion ); } ); } ); } diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.hpp index 04fe58112b4..0f9bd2615b6 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.hpp @@ -253,7 +253,7 @@ class WellSolverBase : public PhysicsSolverBase * @param elemManager the elemManager containing the well * @param subRegion the well subRegion containing the well elements and their associated fields */ - virtual real64 updateSubRegionState( ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ) = 0; + virtual real64 updateSubRegionState( WellElementSubRegion & subRegion ) = 0; /** * @brief Recompute the perforation rates for all the wells diff --git a/src/coreComponents/schema/schema.xsd.other b/src/coreComponents/schema/schema.xsd.other index 12b9eae3e1d..8972cbe655c 100644 --- a/src/coreComponents/schema/schema.xsd.other +++ b/src/coreComponents/schema/schema.xsd.other @@ -2443,11 +2443,11 @@ A field can represent a physical variable. (pressure, temperature, global compos - + - + From 3949b4fa3834c3532821d7dddd7c916730dd9fca Mon Sep 17 00:00:00 2001 From: Jian Huang <53012159+jhuang2601@users.noreply.github.com> Date: Thu, 9 Jul 2026 20:46:27 -0500 Subject: [PATCH 2/9] docs: updated publications and fixed broken links with button-ref (#4095) * update publications * fix error for doc build * fix the failure for the button-ref directive * switch to button-link * add path * fix links for reference * Fixed hyperlinks * address review comment --------- Co-authored-by: DENEL Bertrand --- .../fileIO/doc/InputXMLFiles.rst | 2 +- src/coreComponents/fileIO/doc/OutputTasks.rst | 2 +- .../linearAlgebra/docs/LinearSolvers.rst | 4 +- .../docs/SpatialPartition.rst | 4 +- .../docs/SolidMechanicsEmbeddedFractures.rst | 4 +- src/docs/sphinx/Publications.rst | 51 ++++++++++--------- .../carbonStorage/buckleyLeverett/Example.rst | 2 +- .../kgdValidation/Example.rst | 2 +- .../thermalConsolidation/Example.rst | 2 +- .../buildGuide/ContinuousIntegration.rst | 4 +- src/docs/sphinx/buildGuide/Dependencies.rst | 4 +- src/docs/sphinx/tutorials/step01/Tutorial.rst | 2 +- src/index.rst | 10 ++-- 13 files changed, 46 insertions(+), 47 deletions(-) diff --git a/src/coreComponents/fileIO/doc/InputXMLFiles.rst b/src/coreComponents/fileIO/doc/InputXMLFiles.rst index 15fb463ca82..fb1b66ab32c 100644 --- a/src/coreComponents/fileIO/doc/InputXMLFiles.rst +++ b/src/coreComponents/fileIO/doc/InputXMLFiles.rst @@ -266,7 +266,7 @@ Advanced XML Features ================================= The `geosx_xml_tools` python package adds a set of advanced features to the GEOS xml format: units, parameters, and symbolic expressions. -See`Python Tools Setup `_ for details on setup instructions, and `XML Parser Documentation `_ for package API details. +See `Python Tools Setup `_ for details on setup instructions, and `XML Parser Documentation `_ for package API details. Usage diff --git a/src/coreComponents/fileIO/doc/OutputTasks.rst b/src/coreComponents/fileIO/doc/OutputTasks.rst index b8d91d92fed..9d79f9440bc 100644 --- a/src/coreComponents/fileIO/doc/OutputTasks.rst +++ b/src/coreComponents/fileIO/doc/OutputTasks.rst @@ -195,7 +195,7 @@ time history datat. .. _SILO: https://wci.llnl.gov/simulation/computer-codes/silo .. _VTK: https://vtk.org/wp-content/uploads/2015/04/file-formats.pdf -.. _HDF5: https://portal.hdfgroup.org/display/HDF5/HDF5 +.. _HDF5: https://www.hdfgroup.org/solutions/hdf5 .. _VisIT: https://wci.llnl.gov/simulation/computer-codes/visit/downloads .. _Paraview: https://www.paraview.org/ .. _MatPlotLib: https://matplotlib.org/ diff --git a/src/coreComponents/linearAlgebra/docs/LinearSolvers.rst b/src/coreComponents/linearAlgebra/docs/LinearSolvers.rst index e7390348681..9e690b8abf3 100644 --- a/src/coreComponents/linearAlgebra/docs/LinearSolvers.rst +++ b/src/coreComponents/linearAlgebra/docs/LinearSolvers.rst @@ -305,14 +305,14 @@ This section provides a brief description of the available preconditioners. * **ILUK**: incomplete LU factorization with fill level k of the original matrix: :math:`\mathsf{M}^{-1} = \mathsf{U}^{-1} \mathsf{L}^{-1}`. Further details can be found in: - - `HYPRE documentation `__, + - `HYPRE documentation `__, - `PETSc documentation `__, - `Trilinos documentation `__. * **ILUT**: a dual threshold incomplete LU factorization: :math:`\mathsf{M}^{-1} = \mathsf{U}^{-1} \mathsf{L}^{-1}`. Further details can be found in: - - `HYPRE documentation `__, + - `HYPRE documentation `__, - not yet available through PETSc interface, - `Trilinos documentation `__. diff --git a/src/coreComponents/mesh/mpiCommunications/docs/SpatialPartition.rst b/src/coreComponents/mesh/mpiCommunications/docs/SpatialPartition.rst index ca141be0514..0c8a7567f81 100644 --- a/src/coreComponents/mesh/mpiCommunications/docs/SpatialPartition.rst +++ b/src/coreComponents/mesh/mpiCommunications/docs/SpatialPartition.rst @@ -81,6 +81,6 @@ Therefore, it is a good practice or habit to hide ghost objects using ghostRank If the visualization method involves interpolation, such as interpolating a zonal field into a nodal field or generating contours, the interpretation near partition boundaries is not accurate. -.. _METIS: http://glaros.dtc.umn.edu/gkhome/metis/metis/overview -.. _PARMETIS: http://glaros.dtc.umn.edu/gkhome/metis/parmetis/overview +.. _METIS: https://github.com/KarypisLab/METIS +.. _PARMETIS: https://github.com/KarypisLab/ParMETIS .. _PTSCOTCH: https://www.labri.fr/perso/pelegrin/scotch/ \ No newline at end of file diff --git a/src/coreComponents/physicsSolvers/solidMechanics/contact/docs/SolidMechanicsEmbeddedFractures.rst b/src/coreComponents/physicsSolvers/solidMechanics/contact/docs/SolidMechanicsEmbeddedFractures.rst index 5cf3a8ce3f9..5d39212805a 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/contact/docs/SolidMechanicsEmbeddedFractures.rst +++ b/src/coreComponents/physicsSolvers/solidMechanics/contact/docs/SolidMechanicsEmbeddedFractures.rst @@ -43,9 +43,9 @@ The following data are allocated and used by the solver: References ========== -1. Simo JC, Rifai MS. A class of mixed assumed strain methods and the method of incompatible modes. *Int J Numer Methods Eng.* 1990;29(8):1595-1638. Available at: http://arxiv.org/abs/https://onlinelibrary.wiley.com/doi/pdf/10.1002/nme.1620290802. +1. Simo JC, Rifai MS. A class of mixed assumed strain methods and the method of incompatible modes. *Int J Numer Methods Eng.* 1990;29(8):1595-1638. Available at: https://onlinelibrary.wiley.com/doi/pdf/10.1002/nme.1620290802. -2. Foster CD, Borja RI, Regueiro RA. Embedded strong discontinuity finite elements for fractured geomaterials with variable friction. *Int J Numer Methods Eng.* 2007;72(5):549-581. Available at: http://arxiv.org/abs/https://onlinelibrary.wiley.com/doi/pdf/10.1002/nme.2020. +2. Foster CD, Borja RI, Regueiro RA. Embedded strong discontinuity finite elements for fractured geomaterials with variable friction. *Int J Numer Methods Eng.* 2007;72(5):549-581. Available at: https://onlinelibrary.wiley.com/doi/pdf/10.1002/nme.2020. 3. Wells G, Sluys L. Three-dimensional embedded discontinuity model for brittle fracture. *Int J Solids Struct.* 2001;38(5):897-913. Available at: https://doi.org/10.1016/S0020-7683(00)00029-9. diff --git a/src/docs/sphinx/Publications.rst b/src/docs/sphinx/Publications.rst index 9a81c0f20ff..baad1ae944f 100644 --- a/src/docs/sphinx/Publications.rst +++ b/src/docs/sphinx/Publications.rst @@ -2,7 +2,7 @@ Publications ############################################################################### -Last updated 10-October-2025 +Last updated 07-July-2026 Referencing GEOS ========================= @@ -20,25 +20,6 @@ Referencing GEOS Preprints and Early-Views ========================= -.. list-table:: - :widths: 100 - :header-rows: 0 - - * - | **A robust framework for frictional fault contact in geological formations using a stabilized augmented Lagrangian approach** - | M Frigo, N Castelletto, M Cusini, RR Settgast, HA Tchelepi - | arXiv preprint - | `arXiv:2509.20528 `_ - - * - | **Recurrent Transformer U-Net surrogate for flow modeling and data assimilation in subsurface formations with faults** - | Y Han, LJ Durlofsky - | arXiv preprint - | `arXiv:2508.16631 `_ - - * - | **Semi-Analytical Approaches for Addressing Thermal Debonding Issues in Cased Wellbores** - | T Nguyen-Sy, J Huang, H Gross, FP Hamon - | SSRN preprint - | `doi:10.2139/ssrn.5208966 `_ - 2026 ==== @@ -52,6 +33,31 @@ Preprints and Early-Views | Computer Methods in Applied Mechanics and Engineering | `doi:10.1016/j.cma.2025.118399 `_ + * - | **A robust framework for frictional fault contact in geological formations using a stabilized augmented Lagrangian approach** + | M Frigo, N Castelletto, M Cusini, RR Settgast, HA Tchelepi + | Journal of Computational Physics + | `doi:10.1016/j.jcp.2026.114988 `_ + + * - | **Recurrent Transformer U-Net surrogate for flow modeling and data assimilation in subsurface formations with faults** + | Y Han, LJ Durlofsky + | Journal of Computational Physics + | `doi:10.1016/j.jcp.2026.114801 `_ + + * - | **Simulation of Multiphase Flow and Poromechanical Effects Around Injection Wells in CO2 Storage Sites** + | J Huang, F Hamon, M Cusini, T Gazzola, RR Settgast, JA White, H Gross + | Rock Mechanics and Rock Engineering + | `doi:10.1007/s00603-024-04051-w `_ + + * - | **High-Resolution Simulations of Geological CO2 Injection: Application to the SPE11 Benchmark** + | D Kachuma, R Hasanzade, P Tomin, ME Thomadakis, J Franc, VAP Magri, TJ Byer, M Cusini, RR Settgast, H Gross, N Castelletto + | SPE Journal + | `doi:10.2118/231182-PA `_ + + * - | **Basin-scale analysis of Mokelumne River Formation for multi-well CO2 injection** + | A Zibitsker, B Schmidt, T Byer, N Castelletto, J Iyer + | International Journal of Greenhouse Gas Control + | `doi:10.1016/j.ijggc.2026.104703 `_ + 2025 ==== @@ -113,11 +119,6 @@ Preprints and Early-Views | Advances in Water Resources | `doi:10.1016/j.advwatres.2024.104678 `_ - * - | **Simulation of Multiphase Flow and Poromechanical Effects Around Injection Wells in CO2 Storage Sites** - | J Huang, F Hamon, M Cusini, T Gazzola, RR Settgast, JA White, H Gross - | Rock Mechanics and Rock Engineering - | `doi:10.1007/s00603-024-04051-w `_ - * - | **Learning CO2 plume migration in faulted reservoirs with Graph Neural Networks** | X Ju, FP Hamon, G Wen, R Kanfar, M Araya-Polo, HA Tchelepi | Computers & Geosciences diff --git a/src/docs/sphinx/advancedExamples/validationStudies/carbonStorage/buckleyLeverett/Example.rst b/src/docs/sphinx/advancedExamples/validationStudies/carbonStorage/buckleyLeverett/Example.rst index 9aedba305d5..12705ec12c8 100644 --- a/src/docs/sphinx/advancedExamples/validationStudies/carbonStorage/buckleyLeverett/Example.rst +++ b/src/docs/sphinx/advancedExamples/validationStudies/carbonStorage/buckleyLeverett/Example.rst @@ -9,7 +9,7 @@ **Context** In this example, we simulate a CO2 core flood experiment representing immiscible transport of two-phase -flow (CO2 and water) through porous media `(Ekechukwu et al., 2022) `__. This problem is solved using the multiphase flow solver in GEOS to obtain the temporal evolution of saturation along the flow direction, and verified against the Buckley-Leverett analytical solutions `(Buckley and Leverett, 1942; `__ `Arabzai and Honma, 2013) `__. +flow (CO2 and water) through porous media `(Ekechukwu et al., 2022) `__. This problem is solved using the multiphase flow solver in GEOS to obtain the temporal evolution of saturation along the flow direction, and verified against the Buckley-Leverett analytical solutions `(Buckley and Leverett, 1942; `__ `Arabzai and Honma, 2013) `__. **Input file** diff --git a/src/docs/sphinx/advancedExamples/validationStudies/hydraulicFracture/kgdValidation/Example.rst b/src/docs/sphinx/advancedExamples/validationStudies/hydraulicFracture/kgdValidation/Example.rst index 95d84bb7b4c..29c8ba27eb5 100644 --- a/src/docs/sphinx/advancedExamples/validationStudies/hydraulicFracture/kgdValidation/Example.rst +++ b/src/docs/sphinx/advancedExamples/validationStudies/hydraulicFracture/kgdValidation/Example.rst @@ -8,7 +8,7 @@ Validating KGD Hydraulic Fracture with Experiment **Context** -In this example, we use GEOS to model a planar hydraulic fracture propagating in a finite domain subject to traction-free external boundaries. Contrary to the classic KGD problems, we do not assume an infinite rock domain. Existing analytical solutions cannot model fracture behavior in this scenario, so this problem is solved using the hydrofracture solver in GEOS. We validate the simulation results against a benchmark experiment `(Rubin, 1983) `__. +In this example, we use GEOS to model a planar hydraulic fracture propagating in a finite domain subject to traction-free external boundaries. Contrary to the classic KGD problems, we do not assume an infinite rock domain. Existing analytical solutions cannot model fracture behavior in this scenario, so this problem is solved using the hydrofracture solver in GEOS. We validate the simulation results against a benchmark experiment `(Rubin, 1983) `__. **Input file** diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/Example.rst b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/Example.rst index 07922a086b9..32461b48560 100644 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/Example.rst +++ b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/Example.rst @@ -8,7 +8,7 @@ Thermoporoelastic Consolidation **Context** Thermoporoelastic consolidation is a typical fully coupled problem which involves solid deformation, fluid flow and heat transfer in saturated porous media. -In this example, we use the GEOS coupled solvers to solve a one-dimensional thermoporoelastic consolidation problem with a non-isothermal boundary condition, and we verify the accuracy of the results using the analytical solution provided in `(Bai, 2005) `__ +In this example, we use the GEOS coupled solvers to solve a one-dimensional thermoporoelastic consolidation problem with a non-isothermal boundary condition, and we verify the accuracy of the results using the analytical solution provided in `(Bai, 2005) `__ **InputFile** diff --git a/src/docs/sphinx/buildGuide/ContinuousIntegration.rst b/src/docs/sphinx/buildGuide/ContinuousIntegration.rst index 3740fe464a3..402c3c7ea11 100644 --- a/src/docs/sphinx/buildGuide/ContinuousIntegration.rst +++ b/src/docs/sphinx/buildGuide/ContinuousIntegration.rst @@ -6,9 +6,7 @@ Continuous Integration process To save building time, the third party libraries (that do not change so often) and GEOS are build separately. Everytime a pull is requested in the TPL repository, docker images are generated and deployed on `dockerhub `_. -The repository names (`ubuntu18.04-gcc8 `_, -`centos7.7.1908-clang9.0.0 `_, `centos7.6.1810-gcc8.3.1-cuda10.1.243 `_ etc.) -obviously reflect the OS and the compiler flavour used. +The repository names (e.g. `ubuntu24.04-gcc13-cuda12.9.1 `_) obviously reflect the OS and the compiler flavour used. For each image, the unique tag ``${PULL_REQUEST_NUMBER}-${BUILD_NUMBER}`` (defined as ``${{ github.event.number }}-${{ github.run_number }}`` in github actions) is used so we can connect the related code source in a rather convenient way. Each docker contains the ``org.opencontainers.image.created`` and ``org.opencontainers.image.revision`` labels to provide additional information. diff --git a/src/docs/sphinx/buildGuide/Dependencies.rst b/src/docs/sphinx/buildGuide/Dependencies.rst index 03824bb29a4..1ac14328374 100644 --- a/src/docs/sphinx/buildGuide/Dependencies.rst +++ b/src/docs/sphinx/buildGuide/Dependencies.rst @@ -57,10 +57,10 @@ uncrustify_ 401a409 :code:`ENABLE_UNCRUSTIFY` :code:`UNCRUSTIFY_EXECUTABL .. _conduit: https://github.com/LLNL/conduit .. _CHAI : https://github.com/LLNL/CHAI .. _RAJA : https://github.com/LLNL/RAJA -.. _hdf5 : https://portal.hdfgroup.org/display/HDF5/HDF5 +.. _hdf5 : https://www.hdfgroup.org/solutions/hdf5 .. _mathpresso : https://github.com/kobalicek/mathpresso .. _pugixml : https://pugixml.org -.. _parmetis : http://glaros.dtc.umn.edu/gkhome/metis/parmetis/overview +.. _parmetis : https://github.com/KarypisLab/ParMETIS .. _silo : https://wci.llnl.gov/simulation/computer-codes/silo .. _VTK : https://vtk.org/ .. _suitesparse : https://people.engr.tamu.edu/davis/suitesparse.html diff --git a/src/docs/sphinx/tutorials/step01/Tutorial.rst b/src/docs/sphinx/tutorials/step01/Tutorial.rst index 8c9b5697689..e67d33b3788 100644 --- a/src/docs/sphinx/tutorials/step01/Tutorial.rst +++ b/src/docs/sphinx/tutorials/step01/Tutorial.rst @@ -137,7 +137,7 @@ In production runs, you may want to suppress most console output. For solvers of the ``SinglePhaseFVM`` family, one required attribute is a discretization scheme. Here, we use a Two-Point Flux Approximation (TPFA) finite volume discretization scheme called ``singlePhaseTPFA``. -To know the list of admissible values of an attribute, please see `GEOS's XML schema `_. +To know the list of admissible values of an attribute, please see `GEOS's XML schema `_. This discretization type must know how to find permeability values that it uses internally to compute transmissibilities. The ``permeabilityNames`` attribute tells the solver the user-defined name (the *handle*) of the permeability values that will be defined elsewhere in the input file. diff --git a/src/index.rst b/src/index.rst index a912239cb52..1e52aa22f49 100644 --- a/src/index.rst +++ b/src/index.rst @@ -39,7 +39,7 @@ you have suggestions for improving the guides below, please post an issue on our +++ - .. button-ref:: QuickStart + .. button-link:: docs/sphinx/QuickStart.html :expand: :color: info :click-parent: @@ -55,7 +55,7 @@ you have suggestions for improving the guides below, please post an issue on our +++ - .. button-ref:: Tutorials + .. button-link:: docs/sphinx/tutorials/Index.html :expand: :color: info :click-parent: @@ -71,7 +71,7 @@ you have suggestions for improving the guides below, please post an issue on our +++ - .. button-ref:: BasicExamples + .. button-link:: docs/sphinx/basicExamples/Index.html :expand: :color: info :click-parent: @@ -87,7 +87,7 @@ you have suggestions for improving the guides below, please post an issue on our +++ - .. button-ref:: AdvancedExamples + .. button-link:: docs/sphinx/advancedExamples/Index.html :expand: :color: info :click-parent: @@ -103,7 +103,7 @@ you have suggestions for improving the guides below, please post an issue on our +++ - .. button-ref:: UserGuide + .. button-link:: docs/sphinx/userGuide/Index.html :expand: :color: info :click-parent: From d7c0c185dfd7f1860a83d02bd93c5483f805f4bf Mon Sep 17 00:00:00 2001 From: Nicola Castelletto <38361926+castelletto1@users.noreply.github.com> Date: Tue, 21 Jul 2026 16:21:15 -0700 Subject: [PATCH 3/9] ci: CODEOWNERS - sync to reality (#4099) --- .github/CODEOWNERS | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 539befdf706..60f40f7beb8 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -15,25 +15,25 @@ /inputFiles/hydraulicFracturing @rrsettgast @frankfeifan @cssherman @jhuang2601 @kimtaeho07 @OmarDuran /inputFiles/inducedSeismicity @jhuang2601 @frankfeifan @kimtaeho07 /inputFiles/initialization @rrsettgast @jhuang2601 @OmarDuran -/inputFiles/lagrangianContactMechanics @jhuang2601 @jafranc @joshua-white @castelletto1 +/inputFiles/lagrangianContactMechanics @jhuang2601 @jafranc @joshua-white /inputFiles/materialPointMethod @cmcrook5 @homel1 /inputFiles/meshGeneration @rrsettgast @cssherman @jhuang2601 @OmarDuran /inputFiles/multiphaseFlowFractures @jhuang2601 @tjb-ltk @joshua-white /inputFiles/multipleMeshBodies @rrsettgast @OmarDuran @bd713 /inputFiles/phaseField @rrsettgast @frankfeifan @jhuang2601 -/inputFiles/poromechanics @castelletto1 @jhuang2601 @joshua-white -/inputFiles/poromechanicsFractures @castelletto1 @jhuang2601 @joshua-white +/inputFiles/poromechanics @jhuang2601 @joshua-white +/inputFiles/poromechanicsFractures @jhuang2601 @joshua-white /inputFiles/proppant @rrsettgast @jhuang2601 @OmarDuran /inputFiles/relpermDriver @dkachuma @jafranc @joshua-white -/inputFiles/simplePDE @rrsettgast @castelletto1 @OmarDuran @bd713 -/inputFiles/singlePhaseFlow @castelletto1 @jhuang2601 @dkachuma +/inputFiles/simplePDE @rrsettgast @OmarDuran @bd713 +/inputFiles/singlePhaseFlow @jhuang2601 @dkachuma /inputFiles/singlePhaseFlowFractures @jhuang2601 @dkachuma @joshua-white /inputFiles/singlePhaseWell @tjb-ltk @dkachuma @joshua-white -/inputFiles/solidMechanics @castelletto1 @jhuang2601 @OmarDuran +/inputFiles/solidMechanics @jhuang2601 @OmarDuran /inputFiles/surfaceGeneration @rrsettgast @OmarDuran @bd713 /inputFiles/thermalMultiphaseFlow @dkachuma @tjb-ltk @joshua-white /inputFiles/thermalSinglePhaseFlowFractures @jhuang2601 @frankfeifan @dkachuma -/inputFiles/thermoPoromechanics @jhuang2601 @castelletto1 @frankfeifan +/inputFiles/thermoPoromechanics @jhuang2601 @frankfeifan /inputFiles/thermoPoromechanicsFractures @jhuang2601 @jafranc @joshua-white /inputFiles/triaxialDriver @rrsettgast @jhuang2601 @joshua-white @OmarDuran /inputFiles/wavePropagation @acitrain @sframba @bd713 @jhuang2601 @@ -57,15 +57,15 @@ /src/coreComponents/constitutive/unitTests @rrsettgast @dkachuma @jhuang2601 @joshua-white /src/coreComponents/constitutiveDrivers @rrsettgast @dkachuma @jhuang2601 @jafranc @joshua-white /src/coreComponents/dataRepository @rrsettgast @wrtobin @corbett5 @MelReyCG @OmarDuran @bd713 -/src/coreComponents/denseLinearAlgebra @rrsettgast @castelletto1 @OmarDuran @bd713 -/src/coreComponents/discretizationMethods @rrsettgast @castelletto1 @OmarDuran @bd713 +/src/coreComponents/denseLinearAlgebra @rrsettgast @OmarDuran @bd713 +/src/coreComponents/discretizationMethods @rrsettgast @OmarDuran @bd713 /src/coreComponents/events @rrsettgast @corbett5 @cssherman @MelReyCG @OmarDuran @bd713 /src/coreComponents/fieldSpecification @rrsettgast @corbett5 @cssherman @MelReyCG @OmarDuran @OmarDuran @bd713 /src/coreComponents/fileIO @rrsettgast @wrtobin @MelReyCG @OmarDuran @bd713 -/src/coreComponents/finiteElement @rrsettgast @castelletto1 @andrea-borio @OmarDuran @jafranc @bd713 -/src/coreComponents/finiteVolume @rrsettgast @castelletto1 @OmarDuran @jafranc @bd713 +/src/coreComponents/finiteElement @rrsettgast @andrea-borio @OmarDuran @jafranc @bd713 +/src/coreComponents/finiteVolume @rrsettgast @OmarDuran @jafranc @bd713 /src/coreComponents/functions @rrsettgast @cssherman @wrtobin @MelReyCG @OmarDuran @bd713 -/src/coreComponents/linearAlgebra @rrsettgast @castelletto1 @victorapm @OmarDuran @bd713 +/src/coreComponents/linearAlgebra @rrsettgast @victorapm @OmarDuran @bd713 /src/coreComponents/mainInterface @rrsettgast @corbett5 @wrtobin @MelReyCG @OmarDuran @bd713 /src/coreComponents/math @rrsettgast @corbett5 @wrtobin @OmarDuran @bd713 /src/coreComponents/mesh @rrsettgast @wrtobin @OmarDuran @jafranc @bd713 @@ -73,10 +73,10 @@ /src/coreComponents/physicsSolvers/contact @rrsettgast @jhuang2601 @jafranc @OmarDuran /src/coreComponents/physicsSolvers/fluidFlow @rrsettgast @tjb-ltk @dkachuma @OmarDuran @jhuang2601 /src/coreComponents/physicsSolvers/inducedSeismicity @rrsettgast @jhuang2601 @kimtaeho07 @frankfeifan -/src/coreComponents/physicsSolvers/multiphysics @rrsettgast @castelletto1 @frankfeifan @jhuang2601 @OmarDuran +/src/coreComponents/physicsSolvers/multiphysics @rrsettgast @frankfeifan @jhuang2601 @OmarDuran /src/coreComponents/physicsSolvers/python @cssherman @corbett5 @bd713 @jafranc -/src/coreComponents/physicsSolvers/simplePDE @rrsettgast @castelletto1 @frankfeifan @bd713 -/src/coreComponents/physicsSolvers/solidMechanics @rrsettgast @castelletto1 @jhuang2601 @OmarDuran +/src/coreComponents/physicsSolvers/simplePDE @rrsettgast @frankfeifan @bd713 +/src/coreComponents/physicsSolvers/solidMechanics @rrsettgast @jhuang2601 @OmarDuran /src/coreComponents/physicsSolvers/surfaceGeneration @rrsettgast @jhuang2601 @OmarDuran @bd713 /src/coreComponents/physicsSolvers/wavePropagation @sframba @acitrain @bd713 @MelReyCG /src/coreComponents/schema @rrsettgast @herve-gross @jhuang2601 @dkachuma @OmarDuran From 0f9c572191511bd470f0ee108539efbd605bd55d Mon Sep 17 00:00:00 2001 From: Tom Byer <149726499+tjb-ltk@users.noreply.github.com> Date: Fri, 31 Jul 2026 04:57:42 -0700 Subject: [PATCH 4/9] feat: well_manager + well estimator (#3972) This wommit introduces: - An improved well schema layout and code refactor better suited for well modeling. The previous implementation primarily targeted Jacobian generation requirements for the coupled reservoir and well system. - The well estimator is used to select the active well constraint by solving the well system assuming fixed reservoir conditions and selecting the constraint with the highest or lowest well flowing pressure. the estimator is applied at beginning of Jacobian assembly of the coupled system frequency determined via input setting estimator is a data member of WellControl and a tailed version of PhysicsSolver for wells logic underpins future capability to replace the segmented well model with other formulations. This is a breaking change, detailed migration instructions and migration script are posted at #4081 --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 3 + .../1D_100cells/1D_benchmark.xml | 685 ++-- .../soreideWhitson/1D_100cells/1D_smoke.xml | 685 ++-- .../class09_pb3_drainageOnly_direct_base.xml | 84 +- ...lass09_pb3_drainageOnly_iterative_base.xml | 130 +- .../class09_pb3_hystRelperm_direct_base.xml | 86 +- ...class09_pb3_hystRelperm_iterative_base.xml | 85 +- .../benchmarks/Egg/deadOilEgg_base_direct.xml | 243 +- .../Egg/deadOilEgg_base_iterative.xml | 225 +- .../black_oil_wells_saturated_3d.xml | 131 +- .../black_oil_wells_saturated_3d_stone2.xml | 182 +- .../black_oil_wells_unsaturated_3d.xml | 95 +- .../black_oil_wells_unsaturated_3d_stone2.xml | 521 +-- .../compositionalMultiphaseWell/bos.xml | 305 ++ .../compositional_multiphase_wells_1d.xml | 45 +- .../compositional_multiphase_wells_2d.xml | 68 +- .../dead_oil_wells_2d.xml | 78 +- .../dead_oil_wells_hybrid_2d.xml | 70 +- .../dome_kvalue_base.xml | 729 ++-- .../dome_soreide_whitson_base.xml | 688 ++-- .../isothm_mass_inj_table.xml | 65 +- .../isothm_vol_inj_table.xml | 75 +- .../resvol_constraint.xml | 51 +- .../simpleCo2InjTutorial_base.xml | 87 +- .../staged_perf_base.xml | 69 +- .../staircase_co2_wells_3d.xml | 78 +- .../staircase_co2_wells_hybrid_3d.xml | 53 +- .../PoroElastic_staircase_co2_3d_fim.xml | 73 +- ...oroElastic_staircase_co2_3d_sequential.xml | 71 +- ...roElastic_staircase_singlephase_3d_fim.xml | 69 +- ...ic_staircase_singlephase_3d_sequential.xml | 70 +- ...oirThermoPoroElastic_Circulation_debug.xml | 71 +- ...oromechanics_FaultModel_well_fim_smoke.xml | 78 +- ...oromechanics_FaultModel_well_seq_smoke.xml | 80 +- ...echanics_FaultModel_well_fim_new_smoke.xml | 78 +- ...oromechanics_FaultModel_well_seq_smoke.xml | 73 +- ...asePoromechanics_WellInFault_fim_smoke.xml | 78 +- ...asePoromechanics_WellInFault_seq_smoke.xml | 73 +- .../thermalCompressibleWell_base.xml | 37 +- .../compressible_single_phase_wells_1d.xml | 36 +- ...sible_single_phase_wells_1d_skinFactor.xml | 40 +- ...pressible_single_phase_wells_hybrid_1d.xml | 38 +- .../incompressible_single_phase_wells_2d.xml | 59 +- ...pressible_single_phase_wells_hybrid_2d.xml | 52 +- .../singlePhaseWell/perf_status_test.xml | 75 +- .../staircase_single_phase_wells_3d.xml | 51 +- ...staircase_single_phase_wells_hybrid_3d.xml | 41 +- scripts/convertWellSchema.py | 441 +++ scripts/xml_formatter.py | 205 + .../testTableFunctionsOutput.cpp | 35 +- .../wellsTests/CMakeLists.txt | 2 + ...eservoirCompositionalMultiphaseMSWells.cpp | 60 +- ...eservoirCompositionalMultiphaseSSWells.cpp | 63 +- .../wellsTests/testOpenClosePerf.cpp | 109 +- ...eservoirCompositionalMultiphaseMSWells.cpp | 101 +- .../testReservoirSinglePhaseMSWells.cpp | 133 +- ...testReservoirThermalSinglePhaseMSWells.cpp | 141 +- ...rvoirThermalSinglePhaseMSWells_RateInj.cpp | 124 +- .../testThermalEstimatorInjWell.cpp | 955 +++++ .../testThermalEstimatorProdWell.cpp | 969 +++++ .../wellsTests/testThermalInjWell.cpp | 124 +- .../wellsTests/testThermalProdWell.cpp | 116 +- ...eservoirCompositionalMultiphaseMSWells.cpp | 83 +- ...eservoirCompositionalMultiphaseSSWells.cpp | 80 +- .../linearAlgebra/utilities/ComponentMask.hpp | 4 +- .../physicsSolvers/SolverStatistics.hpp | 5 + .../physicsSolvers/fluidFlow/CMakeLists.txt | 23 +- .../wells/CompositionalMultiphaseWell.cpp | 3342 +++++++++-------- .../wells/CompositionalMultiphaseWell.hpp | 366 +- .../CompositionalMultiphaseWellFields.hpp | 14 - .../fluidFlow/wells/SinglePhaseWell.cpp | 1840 ++++----- .../fluidFlow/wells/SinglePhaseWell.hpp | 310 +- .../fluidFlow/wells/SinglePhaseWellFields.hpp | 15 - .../fluidFlow/wells/WellBHPConstraints.cpp | 97 + .../fluidFlow/wells/WellBHPConstraints.hpp | 177 + .../fluidFlow/wells/WellConstants.hpp | 5 + .../fluidFlow/wells/WellConstraintsBase.cpp | 116 + .../fluidFlow/wells/WellConstraintsBase.hpp | 292 ++ .../fluidFlow/wells/WellControls.cpp | 1246 ++++-- .../fluidFlow/wells/WellControls.hpp | 860 ++++- .../fluidFlow/wells/WellFields.hpp | 70 + .../wells/WellInjectionConstraint.cpp | 107 + .../wells/WellInjectionConstraint.hpp | 151 + .../wells/WellLiquidRateConstraint.cpp | 76 + .../wells/WellLiquidRateConstraint.hpp | 175 + .../fluidFlow/wells/WellManager.cpp | 921 +++++ .../fluidFlow/wells/WellManager.hpp | 474 +++ .../wells/WellMassRateConstraint.cpp | 75 + .../wells/WellMassRateConstraint.hpp | 120 + .../fluidFlow/wells/WellNewtonSolver.cpp | 514 +++ .../fluidFlow/wells/WellNewtonSolver.hpp | 870 +++++ .../wells/WellPhaseVolumeRateConstraint.cpp | 81 + .../wells/WellPhaseVolumeRateConstraint.hpp | 190 + .../wells/WellProductionConstraint.cpp | 69 + .../wells/WellProductionConstraint.hpp | 106 + .../fluidFlow/wells/WellSolverBase.cpp | 181 +- .../fluidFlow/wells/WellSolverBase.hpp | 157 +- .../fluidFlow/wells/WellSolverBaseFields.hpp | 60 +- .../wells/WellVolumeRateConstraint.cpp | 73 + .../wells/WellVolumeRateConstraint.hpp | 124 + ...itionalMultiphaseWellConstraintKernels.hpp | 459 +++ .../CompositionalMultiphaseWellKernels.cpp | 403 +- .../CompositionalMultiphaseWellKernels.hpp | 133 +- .../SinglePhaseWellConstraintKernels.hpp | 196 + .../wells/kernels/SinglePhaseWellKernels.cpp | 104 +- .../wells/kernels/SinglePhaseWellKernels.hpp | 49 +- ...rmalCompositionalMultiphaseWellKernels.hpp | 104 +- .../kernels/ThermalSinglePhaseWellKernels.hpp | 36 +- .../wells/unitTests/testWellEnums.cpp | 4 +- ...mpositionalMultiphaseReservoirAndWells.cpp | 44 +- ...mpositionalMultiphaseReservoirAndWells.hpp | 11 +- .../CoupledReservoirAndWellKernels.hpp | 495 ++- .../CoupledReservoirAndWellsBase.cpp | 2 +- .../CoupledReservoirAndWellsBase.hpp | 4 +- .../SinglePhaseReservoirAndWells.cpp | 23 + .../SinglePhaseReservoirAndWells.hpp | 6 +- src/coreComponents/schema/schema.xsd | 657 +++- src/coreComponents/schema/schema.xsd.other | 99 +- .../multiphaseFlowWithWells/Example.rst | 4 +- 120 files changed, 19370 insertions(+), 7371 deletions(-) create mode 100644 inputFiles/compositionalMultiphaseWell/bos.xml create mode 100644 scripts/convertWellSchema.py create mode 100644 scripts/xml_formatter.py create mode 100644 src/coreComponents/integrationTests/wellsTests/testThermalEstimatorInjWell.cpp create mode 100644 src/coreComponents/integrationTests/wellsTests/testThermalEstimatorProdWell.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellBHPConstraints.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellBHPConstraints.hpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellConstraintsBase.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellConstraintsBase.hpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellInjectionConstraint.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellInjectionConstraint.hpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellLiquidRateConstraint.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellLiquidRateConstraint.hpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellManager.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellManager.hpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellMassRateConstraint.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellMassRateConstraint.hpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellNewtonSolver.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellNewtonSolver.hpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.hpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellProductionConstraint.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellProductionConstraint.hpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.cpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.hpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellConstraintKernels.hpp create mode 100644 src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/SinglePhaseWellConstraintKernels.hpp diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index 3de3368090d..7cf1a5ce23b 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr3836-17046-2e89f64 + baseline: integratedTests/baseline_integratedTests-pr3972-17154-316e6d8 allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index 6f77c74b57b..a317d171a60 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 #3972 (2026-07-28) +Well model refactor . Integrated test update due to schema changes + PR #3836 (2026-05-20) ===================== Added statistics `Group` objects for each statistics `Task` instance diff --git a/inputFiles/compositionalMultiphaseFlow/soreideWhitson/1D_100cells/1D_benchmark.xml b/inputFiles/compositionalMultiphaseFlow/soreideWhitson/1D_100cells/1D_benchmark.xml index 89b9cc7dc86..1ec3648a5fb 100644 --- a/inputFiles/compositionalMultiphaseFlow/soreideWhitson/1D_100cells/1D_benchmark.xml +++ b/inputFiles/compositionalMultiphaseFlow/soreideWhitson/1D_100cells/1D_benchmark.xml @@ -1,294 +1,391 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/inputFiles/compositionalMultiphaseFlow/soreideWhitson/1D_100cells/1D_smoke.xml b/inputFiles/compositionalMultiphaseFlow/soreideWhitson/1D_100cells/1D_smoke.xml index 19a577bde98..c415cbc8fb6 100644 --- a/inputFiles/compositionalMultiphaseFlow/soreideWhitson/1D_100cells/1D_smoke.xml +++ b/inputFiles/compositionalMultiphaseFlow/soreideWhitson/1D_100cells/1D_smoke.xml @@ -1,294 +1,391 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_drainageOnly_direct_base.xml b/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_drainageOnly_direct_base.xml index f2c31503e8a..d6c553dc399 100644 --- a/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_drainageOnly_direct_base.xml +++ b/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_drainageOnly_direct_base.xml @@ -27,27 +27,32 @@ logLevel="1" useMass="1"/> - - - + useSurfaceConditions="1" + surfacePressure="101325" + surfaceTemperature="288.71" + control="totalVolRate"> + + + + - + - + + name="fluidTPFA"/> @@ -80,13 +85,16 @@ solidModelName="nullSolid" porosityModelName="rockPorosity" permeabilityModelName="rockPerm"/> + + + @@ -94,9 +102,8 @@ - + wettingNonWettingRelPermTableNames="{ waterRelativePermeabilityTable, gasRelativePermeabilityTable }"/> + - - + + + + + - @@ -165,37 +176,36 @@ name="waterRelativePermeabilityTable" coordinateFiles="{ tables/phaseVolumeFraction_water.txt }" voxelFile="tables/relPerm_water.txt"/> + + voxelFile="tables/relPerm_gas.txt"/> - + voxelFile="tables/capPres_water.txt"/> - + interpolation="linear"/> - + interpolation="linear"/> - - diff --git a/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_drainageOnly_iterative_base.xml b/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_drainageOnly_iterative_base.xml index 8e76b08905b..254a2c798a5 100644 --- a/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_drainageOnly_iterative_base.xml +++ b/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_drainageOnly_iterative_base.xml @@ -33,57 +33,71 @@ logLevel="1" useMass="1"/> - - - + - - + + + + - + + + + - - + control="massRate"> + + + + + @@ -98,11 +112,11 @@ materialList="{ fluid }"/> - + + name="fluidTPFA"/> @@ -123,13 +137,16 @@ solidModelName="nullSolid" porosityModelName="rockPorosity" permeabilityModelName="rockPerm"/> + + + @@ -139,9 +156,8 @@ - + wettingNonWettingRelPermTableNames="{ waterRelativePermeabilityTable, gasRelativePermeabilityTable }"/> + - @@ -171,28 +186,31 @@ + + + @@ -204,11 +222,13 @@ name="initCO2CompFracTable" coordinates="{ -3238.2, -2506.13 }" values="{ 0.000001, 0.000001 }"/> + - @@ -217,43 +237,43 @@ name="waterRelativePermeabilityTable" coordinateFiles="{ tables/phaseVolumeFraction_water.txt }" voxelFile="tables/relPerm_water.txt"/> + + voxelFile="tables/relPerm_gas.txt"/> - + voxelFile="tables/capPres_water.txt"/> - + interpolation="linear"/> - + interpolation="linear"/> - diff --git a/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_hystRelperm_direct_base.xml b/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_hystRelperm_direct_base.xml index c731abcf696..f1963b5631c 100644 --- a/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_hystRelperm_direct_base.xml +++ b/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_hystRelperm_direct_base.xml @@ -27,27 +27,32 @@ logLevel="1" useMass="1"/> - - - + useSurfaceConditions="1" + surfacePressure="101325" + surfaceTemperature="288.71" + control="totalVolRate"> + + + + - + - + + name="fluidTPFA"/> @@ -80,13 +85,16 @@ solidModelName="nullSolid" porosityModelName="rockPorosity" permeabilityModelName="rockPerm"/> + + + @@ -95,11 +103,10 @@ - + - - + @@ -128,6 +134,7 @@ fieldName="pressure" functionName="pressureFunction" scale="1"/> + + + + + - + voxelFile="tables/capPres_water.txt"/> - + interpolation="linear"/> - + interpolation="linear"/> - + + + - - diff --git a/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_hystRelperm_iterative_base.xml b/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_hystRelperm_iterative_base.xml index ee1af0ef88d..7e24e404aed 100644 --- a/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_hystRelperm_iterative_base.xml +++ b/inputFiles/compositionalMultiphaseWell/benchmarks/Class09Pb3/class09_pb3_hystRelperm_iterative_base.xml @@ -30,28 +30,33 @@ logLevel="1" useMass="1"/> - - - + control="totalVolRate"> + + + + - + - + + name="fluidTPFA"/> @@ -84,13 +89,16 @@ solidModelName="nullSolid" porosityModelName="rockPorosity" permeabilityModelName="rockPerm"/> + + + @@ -100,12 +108,11 @@ - + - + + + + @@ -161,10 +170,12 @@ name="initCO2CompFracTable" coordinates="{ -3238.2, -2506.13 }" values="{ 0.000001, 0.000001 }"/> + + + + voxelFile="tables/relPerm_gas.txt"/> + voxelFile="tables/capPres_water.txt"/> - + interpolation="linear"/> - + interpolation="linear"/> @@ -210,19 +222,20 @@ name="drainageWaterRelativePermeabilityTable" coordinateFiles="{ tables/drainagePhaseVolFraction_water.txt }" voxelFile="tables/drainageRelPerm_water.txt"/> + + + - - diff --git a/inputFiles/compositionalMultiphaseWell/benchmarks/Egg/deadOilEgg_base_direct.xml b/inputFiles/compositionalMultiphaseWell/benchmarks/Egg/deadOilEgg_base_direct.xml index 048e88999d7..bddccec015d 100644 --- a/inputFiles/compositionalMultiphaseWell/benchmarks/Egg/deadOilEgg_base_direct.xml +++ b/inputFiles/compositionalMultiphaseWell/benchmarks/Egg/deadOilEgg_base_direct.xml @@ -1,7 +1,6 @@ - - - - + + + + - - - - + + + + - + + + + - + + + + - + + + + - + + + + - + + + + - + + + + - + + + + - + + + + - + + + + - + maxCompFractionChange="0.5"> + + + + - - - - - - - - @@ -279,7 +338,6 @@ materialList="{ fluid }"/> - - - - - @@ -373,32 +427,27 @@ - - - + fieldName="wellElementConnectionRate"/> + fieldName="wellElementConnectionRate"/> + fieldName="wellElementConnectionRate"/> + fieldName="wellElementConnectionRate"/> - - diff --git a/inputFiles/compositionalMultiphaseWell/benchmarks/Egg/deadOilEgg_base_iterative.xml b/inputFiles/compositionalMultiphaseWell/benchmarks/Egg/deadOilEgg_base_iterative.xml index 615688bef78..682607e2575 100644 --- a/inputFiles/compositionalMultiphaseWell/benchmarks/Egg/deadOilEgg_base_iterative.xml +++ b/inputFiles/compositionalMultiphaseWell/benchmarks/Egg/deadOilEgg_base_iterative.xml @@ -36,120 +36,189 @@ logLevel="1" useMass="1"/> - - - + + + + - + maxCompFractionChange="0.5"> + + + - - - + + + + - + + + + - + + + + - + + + + - + + + + - + + + + - + + + + - + + + + - + + + + - + maxCompFractionChange="0.5"> + + + + @@ -210,7 +279,6 @@ timeFrequency="7.5e6" targetExactTimestep="0" target="/Outputs/restartOutput"/> - @@ -375,7 +443,6 @@ - @@ -384,22 +451,22 @@ + fieldName="wellElementConnectionRate"/> + fieldName="wellElementonnectionRate"/> + fieldName="wellElementConnectionRate"/> + fieldName="wellElementConnectionRate"/> diff --git a/inputFiles/compositionalMultiphaseWell/black_oil_wells_saturated_3d.xml b/inputFiles/compositionalMultiphaseWell/black_oil_wells_saturated_3d.xml index 7ebac080cbc..b18a6368e5e 100644 --- a/inputFiles/compositionalMultiphaseWell/black_oil_wells_saturated_3d.xml +++ b/inputFiles/compositionalMultiphaseWell/black_oil_wells_saturated_3d.xml @@ -2,7 +2,6 @@ - - + - - - + + + + - + maxRelativePressureChange="0.1" + maxCompFractionChange="0.1"> + + + + - - - - + - + - + - @@ -148,12 +155,14 @@ name="region" cellBlocks="{ * }" materialList="{ fluid, rock, relperm, cappres }"/> + + + materialList="{ fluid }"/> @@ -163,7 +172,7 @@ surfaceDensities="{ 800.907131537, 0.856234902739, 1020.3440 }" componentMolarWeight="{ 120e-3, 25e-3, 18e-3 }" tableFiles="{ pvto_bo.txt, pvtg_norv_bo.txt, pvtw_bo.txt }"/> - + - + - - + + + scale="0.2"/> + - + coordinates="{ 0.0, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1.00 }" + values="{ 0, 0.0025, 0.0100, 0.0225, 0.0400, 0.0625, 0.0900, 0.1225, 0.1600, 0.2025, 0.2500, 0.3025, 0.3600, 0.4225, 0.4900, 0.5625, 0.6400, 0.7225, 0.8100, 0.9025, 1.0000 }"/> + + coordinates="{ 0.0, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1.00 }" + values="{ 0, 0.0025, 0.0100, 0.0225, 0.0400, 0.0625, 0.0900, 0.1225, 0.1600, 0.2025, 0.2500, 0.3025, 0.3600, 0.4225, 0.4900, 0.5625, 0.6400, 0.7225, 0.8100, 0.9025, 1.0000 }"/> + + coordinates="{ 0.0, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1.00 }" + values="{ 0, 0.0025, 0.0100, 0.0225, 0.0400, 0.0625, 0.0900, 0.1225, 0.1600, 0.2025, 0.2500, 0.3025, 0.3600, 0.4225, 0.4900, 0.5625, 0.6400, 0.7225, 0.8100, 0.9025, 1.0000 }"/> + + coordinates="{ 0.0, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1.00 }" + values="{ 0, 0.0025, 0.0100, 0.0225, 0.0400, 0.0625, 0.0900, 0.1225, 0.1600, 0.2025, 0.2500, 0.3025, 0.3600, 0.4225, 0.4900, 0.5625, 0.6400, 0.7225, 0.8100, 0.9025, 1.0000 }"/> + coordinates="{ 0.0, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1.00 }" + values="{ 10000, 9025, 8100, 7225, 6400, 5625, 4900, 4225, 3600, 3025, 2500, 2025, 1600, 1225, 900, 625, 400, 225, 100, 25, 0 }"/> + - + coordinates="{ 0.0, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1.00 }" + values="{ 0, 50, 200, 450, 800, 1250, 1800, 2450, 3200, 4050, 5000, 6050, 7200, 8450, 9800, 11250, 12800, 14450, 16200, 18050, 20000 }"/> - + - + + fieldName="wellElementConnectionRate"/> - + - + - diff --git a/inputFiles/compositionalMultiphaseWell/black_oil_wells_saturated_3d_stone2.xml b/inputFiles/compositionalMultiphaseWell/black_oil_wells_saturated_3d_stone2.xml index ce669961545..a6bc0ce2660 100644 --- a/inputFiles/compositionalMultiphaseWell/black_oil_wells_saturated_3d_stone2.xml +++ b/inputFiles/compositionalMultiphaseWell/black_oil_wells_saturated_3d_stone2.xml @@ -2,7 +2,6 @@ - - + - - - + + + + - + maxRelativePressureChange="0.1" + maxCompFractionChange="0.1"> + + + + - - - - - - - + + + + + + - - + - + - + - @@ -147,12 +155,14 @@ name="region" cellBlocks="{ * }" materialList="{ fluid, rock, relperm, cappres }"/> + + + materialList="{ fluid }"/> @@ -162,7 +172,7 @@ surfaceDensities="{ 800.907131537, 0.856234902739, 1020.3440 }" componentMolarWeight="{ 120e-3, 25e-3, 18e-3 }" tableFiles="{ pvto_bo.txt, pvtg_norv_bo.txt, pvtw_bo.txt }"/> - + - + - - + + + scale="0.2"/> + - + coordinates="{ 0.0, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1.00 }" + values="{ 0, 0.0025, 0.0100, 0.0225, 0.0400, 0.0625, 0.0900, 0.1225, 0.1600, 0.2025, 0.2500, 0.3025, 0.3600, 0.4225, 0.4900, 0.5625, 0.6400, 0.7225, 0.8100, 0.9025, 1.0000 }"/> + + coordinates="{ 0.0, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1.00 }" + values="{ 0, 0.0025, 0.0100, 0.0225, 0.0400, 0.0625, 0.0900, 0.1225, 0.1600, 0.2025, 0.2500, 0.3025, 0.3600, 0.4225, 0.4900, 0.5625, 0.6400, 0.7225, 0.8100, 0.9025, 1.0000 }"/> + + coordinates="{ 0.0, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1.00 }" + values="{ 0, 0.0025, 0.0100, 0.0225, 0.0400, 0.0625, 0.0900, 0.1225, 0.1600, 0.2025, 0.2500, 0.3025, 0.3600, 0.4225, 0.4900, 0.5625, 0.6400, 0.7225, 0.8100, 0.9025, 1.0000 }"/> + + coordinates="{ 0.0, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1.00 }" + values="{ 0, 0.0025, 0.0100, 0.0225, 0.0400, 0.0625, 0.0900, 0.1225, 0.1600, 0.2025, 0.2500, 0.3025, 0.3600, 0.4225, 0.4900, 0.5625, 0.6400, 0.7225, 0.8100, 0.9025, 1.0000 }"/> + coordinates="{ 0.0, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1.00 }" + values="{ 10000, 9025, 8100, 7225, 6400, 5625, 4900, 4225, 3600, 3025, 2500, 2025, 1600, 1225, 900, 625, 400, 225, 100, 25, 0 }"/> + - + coordinates="{ 0.0, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.5, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1.00 }" + values="{ 0, 50, 200, 450, 800, 1250, 1800, 2450, 3200, 4050, 5000, 6050, 7200, 8450, 9800, 11250, 12800, 14450, 16200, 18050, 20000 }"/> - + - + + fieldName="wellElementConnectionRate"/> - + - + - diff --git a/inputFiles/compositionalMultiphaseWell/black_oil_wells_unsaturated_3d.xml b/inputFiles/compositionalMultiphaseWell/black_oil_wells_unsaturated_3d.xml index 323b9a144c6..01e678391cd 100644 --- a/inputFiles/compositionalMultiphaseWell/black_oil_wells_unsaturated_3d.xml +++ b/inputFiles/compositionalMultiphaseWell/black_oil_wells_unsaturated_3d.xml @@ -2,7 +2,6 @@ - - + - - - + + + + - + maxRelativePressureChange="0.1" + maxCompFractionChange="0.1"> + + + + - - - - - + - - + - + - @@ -148,12 +156,14 @@ name="region" cellBlocks="{ * }" materialList="{ fluid, rock, relperm }"/> + + + materialList="{ fluid }"/> @@ -163,7 +173,7 @@ surfaceDensities="{ 800.907131537, 0.856234902739, 1020.3440 }" componentMolarWeight="{ 120e-3, 25e-3, 18e-3 }" tableFiles="{ pvto_bo.txt, pvtg_norv_bo.txt, pvtw_bo.txt }"/> - + - - + + + scale="0.1"/> + - + - + + fieldName="wellElementConnectionRate"/> - + name="vtkOutput"/> + - - diff --git a/inputFiles/compositionalMultiphaseWell/black_oil_wells_unsaturated_3d_stone2.xml b/inputFiles/compositionalMultiphaseWell/black_oil_wells_unsaturated_3d_stone2.xml index ea41c8adf9c..9a59b7a21da 100644 --- a/inputFiles/compositionalMultiphaseWell/black_oil_wells_unsaturated_3d_stone2.xml +++ b/inputFiles/compositionalMultiphaseWell/black_oil_wells_unsaturated_3d_stone2.xml @@ -1,260 +1,269 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/inputFiles/compositionalMultiphaseWell/bos.xml b/inputFiles/compositionalMultiphaseWell/bos.xml new file mode 100644 index 00000000000..07524638dec --- /dev/null +++ b/inputFiles/compositionalMultiphaseWell/bos.xml @@ -0,0 +1,305 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/inputFiles/compositionalMultiphaseWell/compositional_multiphase_wells_1d.xml b/inputFiles/compositionalMultiphaseWell/compositional_multiphase_wells_1d.xml index 50dd2dac0e7..1cd60fe2ceb 100644 --- a/inputFiles/compositionalMultiphaseWell/compositional_multiphase_wells_1d.xml +++ b/inputFiles/compositionalMultiphaseWell/compositional_multiphase_wells_1d.xml @@ -23,28 +23,38 @@ targetRegions="{ Region1 }" temperature="297.15"/> - - - + + + + - + control="totalVolRate"> + + + + @@ -58,7 +68,6 @@ ny="{ 1 }" nz="{ 1 }" cellBlockNames="{ cb1 }"> - - + name="fluidTPFA"/> diff --git a/inputFiles/compositionalMultiphaseWell/compositional_multiphase_wells_2d.xml b/inputFiles/compositionalMultiphaseWell/compositional_multiphase_wells_2d.xml index 9c385c41364..32ba08239e6 100644 --- a/inputFiles/compositionalMultiphaseWell/compositional_multiphase_wells_2d.xml +++ b/inputFiles/compositionalMultiphaseWell/compositional_multiphase_wells_2d.xml @@ -22,39 +22,52 @@ discretization="fluidTPFA" targetRegions="{ Region1 }" temperature="297.15"/> - - - + - - + + + + - + + + + - - + control="totalVolRate"> + + + + @@ -69,7 +82,6 @@ ny="{ 20 }" nz="{ 1 }" cellBlockNames="{ cb1 }"> - - - + name="fluidTPFA"/> @@ -220,7 +229,6 @@ - - - + - + + + + - + + + + - + control="totalVolRate" + maxRelativePressureChange="0.1" + maxCompFractionChange="0.1"> + + + + @@ -78,7 +97,6 @@ ny="{ 20 }" nz="{ 1 }" cellBlockNames="{ cb1 }"> - - - + name="fluidTPFA"/> @@ -262,14 +277,13 @@ - - + - - + - + + + + - + + + + - + control="totalVolRate" + maxRelativePressureChange="0.1" + maxCompFractionChange="0.1"> + + + + @@ -77,7 +96,6 @@ ny="{ 20 }" nz="{ 1 }" cellBlockNames="{ cb1 }"> - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_base.xml b/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_base.xml index 718e7894417..eb98b185e18 100644 --- a/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_base.xml +++ b/inputFiles/compositionalMultiphaseWell/dome_soreide_whitson_base.xml @@ -1,317 +1,377 @@ + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/inputFiles/compositionalMultiphaseWell/isothm_mass_inj_table.xml b/inputFiles/compositionalMultiphaseWell/isothm_mass_inj_table.xml index 14076fab917..da6c1c11af3 100644 --- a/inputFiles/compositionalMultiphaseWell/isothm_mass_inj_table.xml +++ b/inputFiles/compositionalMultiphaseWell/isothm_mass_inj_table.xml @@ -10,7 +10,7 @@ initialDt="1e2" targetRegions="{ region, injwell }"> - + targetRegions="{ region }"/> - - - + writeCSV="1"> + + + + @@ -83,10 +86,8 @@ - - @@ -94,8 +95,6 @@ name="sink" xMin="{ 89.99, 89.99, -0.01 }" xMax="{ 101.01, 101.01, 1.01 }"/> - - - - @@ -143,25 +143,28 @@ name="region" cellBlocks="{ cb }" materialList="{ fluid, rock, relperm }"/> + - + + + @@ -181,11 +184,9 @@ phaseMinVolumeFraction="{ 0.0, 0.0 }" phaseRelPermExponent="{ 1.5, 1.5 }" phaseRelPermMaxValue="{ 0.9, 0.9 }"/> - - + + + - diff --git a/inputFiles/compositionalMultiphaseWell/isothm_vol_inj_table.xml b/inputFiles/compositionalMultiphaseWell/isothm_vol_inj_table.xml index d39421e36fc..15c9dcc7b89 100644 --- a/inputFiles/compositionalMultiphaseWell/isothm_vol_inj_table.xml +++ b/inputFiles/compositionalMultiphaseWell/isothm_vol_inj_table.xml @@ -10,7 +10,7 @@ initialDt="1e2" targetRegions="{ region, injwell }"> - + targetRegions="{ region }"/> - - - + writeCSV="1"> + + + + @@ -82,10 +86,8 @@ - - @@ -93,8 +95,6 @@ name="sink" xMin="{ 89.99, 89.99, -0.01 }" xMax="{ 101.01, 101.01, 1.01 }"/> - - - - - @@ -148,25 +150,28 @@ name="region" cellBlocks="{ cb }" materialList="{ fluid, rock, relperm }"/> + - + + + @@ -186,11 +191,9 @@ phaseMinVolumeFraction="{ 0.0, 0.0 }" phaseRelPermExponent="{ 1.5, 1.5 }" phaseRelPermMaxValue="{ 0.9, 0.9 }"/> - - + + + - diff --git a/inputFiles/compositionalMultiphaseWell/resvol_constraint.xml b/inputFiles/compositionalMultiphaseWell/resvol_constraint.xml index 620b7b74df0..549456ba08d 100644 --- a/inputFiles/compositionalMultiphaseWell/resvol_constraint.xml +++ b/inputFiles/compositionalMultiphaseWell/resvol_constraint.xml @@ -23,31 +23,42 @@ targetRegions="{ Region1 }" temperature="297.15"/> - - - + + + + - + writeCSV="1"> + + + + @@ -61,7 +72,6 @@ ny="{ 1 }" nz="{ 1 }" cellBlockNames="{ cb1 }"> - - + - - + + name="fluidTPFA"/> @@ -189,7 +198,6 @@ - - - - - + useSurfaceConditions="1" + surfacePressure="101325" + surfaceTemperature="288.71" + control="totalVolRate" + maxCompFractionChange="0.2"> + + + + - + - + @@ -111,13 +116,12 @@ - - - + sources="{ /Tasks/wellPressureCollection }" + filename="wellPressureHistory"/> @@ -196,31 +199,29 @@ - + fieldName="pressure"/> - - - - - + + + + + - diff --git a/inputFiles/compositionalMultiphaseWell/staged_perf_base.xml b/inputFiles/compositionalMultiphaseWell/staged_perf_base.xml index 302d728e9b4..cc2aee8bbbe 100644 --- a/inputFiles/compositionalMultiphaseWell/staged_perf_base.xml +++ b/inputFiles/compositionalMultiphaseWell/staged_perf_base.xml @@ -10,11 +10,11 @@ targetRegions="{ reservoir, wellRegion1 }"> + directParallel="0"/> - - - + writeCSV="1"> + + + + - - + + name="fluidTPFA"/> @@ -91,7 +94,6 @@ - @@ -158,34 +160,31 @@ scale="1.0"/> - + name="equil" + objectPath="ElementRegions" + datumElevation="0" + datumPressure="2.214e7" + initialPhaseName="water" + componentNames="{ co2, water }" + componentFractionVsElevationTableNames="{ initCO2CompFracTable, initWaterCompFracTable }" + temperatureVsElevationTableName="initTempTable"/> + name="initCO2CompFracTable" + coordinates="{ -3000.0, 0.0 }" + values="{ 0.0, 0.0 }"/> + name="initWaterCompFracTable" + coordinates="{ -3000.0, 0.0 }" + values="{ 1.0, 1.0 }"/> - + name="initTempTable" + coordinates="{ -3000.0, 0.0 }" + values="{ 368, 288 }"/> diff --git a/inputFiles/compositionalMultiphaseWell/staircase_co2_wells_3d.xml b/inputFiles/compositionalMultiphaseWell/staircase_co2_wells_3d.xml index 388b15ca605..6b436f5d9b8 100644 --- a/inputFiles/compositionalMultiphaseWell/staircase_co2_wells_3d.xml +++ b/inputFiles/compositionalMultiphaseWell/staircase_co2_wells_3d.xml @@ -25,36 +25,45 @@ maxCompFractionChange="0.2" useMass="1"/> - - - + + + + - + maxCompFractionChange="0.2"> + + + + - - - + cellBlockNames="{ cb-0_0_0, cb-1_0_0, cb-0_1_0, cb-1_1_0, cb-0_0_1, cb-1_0_1, cb-0_1_1, cb-1_1_1, cb-0_0_2, cb-1_0_2, cb-0_1_2, cb-1_1_2, cb-0_0_3, cb-1_0_3, cb-0_1_3, cb-1_1_3 }"> - + wettingNonWettingRelPermTableNames="{ waterRelativePermeabilityTable, gasRelativePermeabilityTable }"/> - @@ -222,35 +224,37 @@ scale="0.96"/> - + + voxelFile="relPerm_gas.txt"/> + + voxelFile="capPres_water.txt"/> + + - diff --git a/inputFiles/compositionalMultiphaseWell/staircase_co2_wells_hybrid_3d.xml b/inputFiles/compositionalMultiphaseWell/staircase_co2_wells_hybrid_3d.xml index b7e30e91dcb..e194d703d6c 100644 --- a/inputFiles/compositionalMultiphaseWell/staircase_co2_wells_hybrid_3d.xml +++ b/inputFiles/compositionalMultiphaseWell/staircase_co2_wells_hybrid_3d.xml @@ -28,35 +28,46 @@ maxRelativePressureChange="0.2" useMass="1"/> - - - + + + + - + maxRelativePressureChange="0.2" + maxCompFractionChange="0.2"> + + + + - - - - + diff --git a/inputFiles/poromechanics/PoroElastic_staircase_co2_3d_fim.xml b/inputFiles/poromechanics/PoroElastic_staircase_co2_3d_fim.xml index 0ca07929f8e..d71aa6ef337 100644 --- a/inputFiles/poromechanics/PoroElastic_staircase_co2_3d_fim.xml +++ b/inputFiles/poromechanics/PoroElastic_staircase_co2_3d_fim.xml @@ -1,13 +1,12 @@ - - - + + - - + + targetRegions="{ channel, barrier }"/> - - - + + + + - - + maxCompFractionChange="0.2"> + + + + - + + - + + - + - - - diff --git a/inputFiles/poromechanics/PoroElastic_staircase_co2_3d_sequential.xml b/inputFiles/poromechanics/PoroElastic_staircase_co2_3d_sequential.xml index e978595a49f..f61b41a4c67 100755 --- a/inputFiles/poromechanics/PoroElastic_staircase_co2_3d_sequential.xml +++ b/inputFiles/poromechanics/PoroElastic_staircase_co2_3d_sequential.xml @@ -1,13 +1,12 @@ - - - + + - - + + targetRegions="{ channel, barrier }"/> - - - + + + + - - + maxCompFractionChange="0.2"> + + + + - + + - + + - + - - diff --git a/inputFiles/poromechanics/PoroElastic_staircase_singlephase_3d_fim.xml b/inputFiles/poromechanics/PoroElastic_staircase_singlephase_3d_fim.xml index 95f2090ada1..2e78157ef6e 100644 --- a/inputFiles/poromechanics/PoroElastic_staircase_singlephase_3d_fim.xml +++ b/inputFiles/poromechanics/PoroElastic_staircase_singlephase_3d_fim.xml @@ -1,13 +1,12 @@ - - - + + - - + + targetRegions="{ channel, barrier }"/> - - - + + + + - - + surfacePressure="101325"> + + + + - + minTime="-1e11" + maxTime="1e7"> - + + - + + - - + + - diff --git a/inputFiles/poromechanics/PoroElastic_staircase_singlephase_3d_sequential.xml b/inputFiles/poromechanics/PoroElastic_staircase_singlephase_3d_sequential.xml index 0c952c6934f..331844d8b48 100755 --- a/inputFiles/poromechanics/PoroElastic_staircase_singlephase_3d_sequential.xml +++ b/inputFiles/poromechanics/PoroElastic_staircase_singlephase_3d_sequential.xml @@ -1,13 +1,12 @@ - - - + + - - + + targetRegions="{ channel, barrier }"/> - - - + + + + - - + surfacePressure="101325"> + + + + - + minTime="-1e11" + maxTime="1e7"> - + + - + - @@ -118,24 +125,25 @@ name="linearElasticityStatistics" solidSolverName="linearElasticity" logLevel="1"/> + - - + + - diff --git a/inputFiles/poromechanics/ReservoirThermoPoroElastic_Circulation_debug.xml b/inputFiles/poromechanics/ReservoirThermoPoroElastic_Circulation_debug.xml index b2a0d65d59d..feb3d2e9307 100644 --- a/inputFiles/poromechanics/ReservoirThermoPoroElastic_Circulation_debug.xml +++ b/inputFiles/poromechanics/ReservoirThermoPoroElastic_Circulation_debug.xml @@ -2,12 +2,12 @@ - + - - - - + + + + - - + writeCSV="1"> + + + + + - - + + @@ -162,7 +173,6 @@ - - + targetTime="-1e10"/> - + - - - + poromechanicsSolverName="reservoirPoromechanics"/> - diff --git a/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_well_fim_smoke.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_well_fim_smoke.xml index f072a262c59..66b6e0e5d9e 100644 --- a/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_well_fim_smoke.xml +++ b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_well_fim_smoke.xml @@ -1,14 +1,16 @@ + + - + - + maxAllowedResidualNorm="1e+15"/> + directParallel="0"/> + targetRegions="{ Region, Fault }" + discretization="FE1"/> + logLevel="3"/> - + targetRegions="{ Region, Fault }" + temperature="368.15"/> - - + - + logLevel="2" + writeCSV="1"> + + + + @@ -88,47 +95,44 @@ numElementsPerSegment="1"> + distanceFromHead="250"/> - + + - - - + target="/Outputs/vtkOutput"/> + target="/Solvers/reservoirSolver"/> + target="/Outputs/vtkOutput"/> + target="/Outputs/restartOutput"/> diff --git a/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_well_seq_smoke.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_well_seq_smoke.xml index 6ca0216ac4e..d91d7f890ff 100644 --- a/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_well_seq_smoke.xml +++ b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/multiphasePoromechanics_FaultModel_well_seq_smoke.xml @@ -1,14 +1,16 @@ + + - + - + maxAllowedResidualNorm="1e+15"/> + directParallel="0"/> + targetRegions="{ Region, Fault }" + discretization="FE1"/> + newtonMaxIter="20"/> + preconditionerType="mgr"/> - + targetRegions="{ Region, Fault }" + temperature="368.15"/> - - + - + logLevel="2" + writeCSV="1"> + + + + @@ -97,47 +104,44 @@ numElementsPerSegment="1"> + distanceFromHead="250"/> - + + - - - + target="/Outputs/vtkOutput"/> + target="/Solvers/reservoirSolver"/> + target="/Outputs/vtkOutput"/> + target="/Outputs/restartOutput"/> diff --git a/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/singlePhasePoromechanics_FaultModel_well_fim_new_smoke.xml b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/singlePhasePoromechanics_FaultModel_well_fim_new_smoke.xml index 07a6e1521ff..72aad6f89b6 100644 --- a/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/singlePhasePoromechanics_FaultModel_well_fim_new_smoke.xml +++ b/inputFiles/poromechanicsFractures/Contact/LagrangianMultipliers/singlePhasePoromechanics_FaultModel_well_fim_new_smoke.xml @@ -1,14 +1,16 @@ + + - + - + solverType="direct"/> - + logLevel="1"/> + targetRegions="{ Region, Fault }" + discretization="FE1"/> - + targetRegions="{ Region, Fault }"/> - - - + + + + - + control="BHP"> + + + + - + + - - - + - + - + solverType="direct"/> + targetRegions="{ Region, Fault }" + discretization="FE1"/> - + targetRegions="{ Region, Fault }"/> - - - + + + + - + control="BHP"> + + + + - + + - - - + - + - + directParallel="1"/> - + logLevel="1"/> + targetRegions="{ Region, Fault }" + discretization="FE1"/> - + targetRegions="{ Region, Fault }"/> - - - + + + + - + control="BHP"> + + + + - + + - - - + - + - + directParallel="1"/> + targetRegions="{ Region, Fault }" + discretization="FE1"/> - + targetRegions="{ Region, Fault }"/> - - - + + + + - + control="BHP"> + + + + - + + - - - + targetRegions="{ region , wellRegion2 }"> - + targetRegions="{ region }"/> - - - + surfaceTemperature="300.15"> + + + + @@ -78,13 +82,13 @@ name="region" cellBlocks="{ * }" materialList="{ fluid, rock, thermalCond }"/> + - - - - diff --git a/inputFiles/singlePhaseWell/compressible_single_phase_wells_1d.xml b/inputFiles/singlePhaseWell/compressible_single_phase_wells_1d.xml index 4b5f64d0287..0fe903b3199 100644 --- a/inputFiles/singlePhaseWell/compressible_single_phase_wells_1d.xml +++ b/inputFiles/singlePhaseWell/compressible_single_phase_wells_1d.xml @@ -20,25 +20,35 @@ discretization="singlePhaseTPFA" targetRegions="{ Region1 }"/> - - - + + + + - + control="totalVolRate"> + + + + @@ -52,7 +62,6 @@ ny="{ 1 }" nz="{ 1 }" cellBlockNames="{ cb1 }"> - - - - - + + + + - + control="totalVolRate"> + + + + @@ -52,7 +62,6 @@ ny="{ 1 }" nz="{ 1 }" cellBlockNames="{ cb1 }"> - + distanceFromHead="1.45" + skinFactor="1"/> - - - + - + + + + - + control="totalVolRate"> + + + + @@ -53,7 +63,6 @@ ny="{ 1 }" nz="{ 1 }" cellBlockNames="{ cb1 }"> - - - - + - + + + + - + + + + - + initialPressureCoefficient="0.01" + control="totalVolRate"> + + + + @@ -60,7 +75,6 @@ ny="{ 20 }" nz="{ 1 }" cellBlockNames="{ cb1 }"> - - - + name="singlePhaseTPFA"/> diff --git a/inputFiles/singlePhaseWell/incompressible_single_phase_wells_hybrid_2d.xml b/inputFiles/singlePhaseWell/incompressible_single_phase_wells_hybrid_2d.xml index 743a1f7be70..28a95e82f30 100644 --- a/inputFiles/singlePhaseWell/incompressible_single_phase_wells_hybrid_2d.xml +++ b/inputFiles/singlePhaseWell/incompressible_single_phase_wells_hybrid_2d.xml @@ -21,32 +21,47 @@ discretization="singlePhaseHybridMimetic" targetRegions="{ Region1 }"/> - - - + + + + - + + + + - + control="totalVolRate"> + + + + @@ -60,7 +75,6 @@ ny="{ 20 }" nz="{ 1 }" cellBlockNames="{ cb1 }"> - - - - - + - + + + + - + + + + - + writeCSV="1"> + + + + @@ -62,7 +79,6 @@ ny="{ 20 }" nz="{ 1 }" cellBlockNames="{ cb1 }"> - - - + name="singlePhaseTPFA"/> diff --git a/inputFiles/singlePhaseWell/staircase_single_phase_wells_3d.xml b/inputFiles/singlePhaseWell/staircase_single_phase_wells_3d.xml index 6789ab90542..55da1048afe 100644 --- a/inputFiles/singlePhaseWell/staircase_single_phase_wells_3d.xml +++ b/inputFiles/singlePhaseWell/staircase_single_phase_wells_3d.xml @@ -16,29 +16,39 @@ - - - + + + + - + control="totalVolRate"> + + + + @@ -51,11 +61,7 @@ nx="{ 5, 5 }" ny="{ 5, 5 }" nz="{ 3, 3, 3, 3 }" - cellBlockNames="{ cb-0_0_0, cb-1_0_0, cb-0_1_0, cb-1_1_0, - cb-0_0_1, cb-1_0_1, cb-0_1_1, cb-1_1_1, - cb-0_0_2, cb-1_0_2, cb-0_1_2, cb-1_1_2, - cb-0_0_3, cb-1_0_3, cb-0_1_3, cb-1_1_3 }"> - + cellBlockNames="{ cb-0_0_0, cb-1_0_0, cb-0_1_0, cb-1_1_0, cb-0_0_1, cb-1_0_1, cb-0_1_1, cb-1_1_1, cb-0_0_2, cb-1_0_2, cb-0_1_2, cb-1_1_2, cb-0_0_3, cb-1_0_3, cb-0_1_3, cb-1_1_3 }"> - @@ -172,9 +177,9 @@ diff --git a/inputFiles/singlePhaseWell/staircase_single_phase_wells_hybrid_3d.xml b/inputFiles/singlePhaseWell/staircase_single_phase_wells_hybrid_3d.xml index 2298a32e483..40fd508d61b 100644 --- a/inputFiles/singlePhaseWell/staircase_single_phase_wells_hybrid_3d.xml +++ b/inputFiles/singlePhaseWell/staircase_single_phase_wells_hybrid_3d.xml @@ -21,27 +21,37 @@ discretization="singlePhaseHybridMimetic" targetRegions="{ Channel }"/> - - - + + + + - + surfacePressure="101325"> + + + + @@ -54,11 +64,7 @@ nx="{ 5, 5 }" ny="{ 5, 5 }" nz="{ 3, 3, 3, 3 }" - cellBlockNames="{ cb-0_0_0, cb-1_0_0, cb-0_1_0, cb-1_1_0, - cb-0_0_1, cb-1_0_1, cb-0_1_1, cb-1_1_1, - cb-0_0_2, cb-1_0_2, cb-0_1_2, cb-1_1_2, - cb-0_0_3, cb-1_0_3, cb-0_1_3, cb-1_1_3 }"> - + cellBlockNames="{ cb-0_0_0, cb-1_0_0, cb-0_1_0, cb-1_1_0, cb-0_0_1, cb-1_0_1, cb-0_1_1, cb-1_1_1, cb-0_0_2, cb-1_0_2, cb-0_1_2, cb-1_1_2, cb-0_0_3, cb-1_0_3, cb-0_1_3, cb-1_1_3 }"> - short form) + try: + if hasattr(tree, "write"): + tree.write(outpath, encoding='utf-8', xml_declaration=True, short_empty_elements=False) + else: + # last resort: convert to string and write + s = ET_local.tostring(tree, encoding='utf-8') + with open(outpath, "wb") as f: + f.write(s) + except Exception as e: + raise + xml_formatter.format_file(outpath) + # + +def validate_with_xsd(tree: ET.ElementTree, xsd_path: str) -> Tuple[bool, str]: + if not lxml_etree: + return False, "lxml not installed" + try: + xml_bytes = ET.tostring(tree.getroot(), encoding="utf-8") + xml_doc = lxml_etree.fromstring(xml_bytes) + xsd_doc = lxml_etree.parse(xsd_path) + schema = lxml_etree.XMLSchema(xsd_doc) + ok = schema.validate(xml_doc) + if ok: + return True, "" + else: + return False, str(schema.error_log) + except Exception as e: + return False, str(e) + +def update_constraint_element(xml_file,add_we,estimatorSolves): + delete_old_schema=True + with open(xml_file, 'rb') as xml_file: + tree = ET.parse(xml_file) + root = tree.getroot() + compoFluidModel = True + isThermal=False + for elem in root.iter(): + #print(f"Tag: {elem.tag}, Attributes: {elem.attrib}, Text: {elem.text}") + + if elem.tag == "CompositionalMultiphaseWell" or elem.tag == "SinglePhaseWell": + if elem.tag == "SinglePhaseWell": + compoFluidModel = False + #if "writeCSV" not in elem.attrib: + # esolves = '"'+str(estimatorSolves)+'"' + # elem.set("writeCSV","1") + if add_we: + + nlsTag="NonlinearSolverParameters" + nlsAttributes={} + nlsAttributes["newtonTol"]="1.0e-8" + nlsAttributes["lineSearchAction"]="None" + nlsAttributes["newtonMaxIter"]="20" + elem.insert(0,ET.Element(nlsTag,nlsAttributes)) + lsTag="LinearSolverParameters" + lsAttributes={} + lsAttributes["directParallel"]="0" + elem.insert(0,ET.Element(lsTag,lsAttributes)) + + if "isThermal" in elem.attrib: + if elem.attrib["isThermal"] == "1": + isThermal = True + if elem.tag == "WellControls": + #print(f"Tag: {elem.tag}, Attributes: {elem.attrib}, Text: {elem.text}") + #if "control" in elem.attrib: + # if delete_old_schema: + # elem.attrib.pop("control") + if add_we: + elem.set("estimateWellSolution",str(estimatorSolves)) + isProducer = elem.attrib['type'] == 'producer' + if isProducer: + constraintType="Production" + pressureType="Minimum" + else: + constraintType="Injection" + pressureType="Maximum" + # setup phase constraint + if 'targetPhaseName' in elem.attrib: + writePhaseConstraint=True + phaseConstraintTag= constraintType+"PhaseVolumeRateConstraint" + phaseConstraintAttributes={} + phaseConstraintAttributes["name"]="max"+elem.attrib['targetPhaseName'].lower() +"prod" if isProducer else "inj" + if 'targetPhaseName' in elem.attrib: + phaseConstraintAttributes["phaseName"] = elem.attrib['targetPhaseName'] + if delete_old_schema: + elem.attrib.pop("targetPhaseName") + if "targetPhaseRateTableName" in elem.attrib: + phaseConstraintAttributes["constraintScheduleTableName"]=elem.attrib["targetPhaseRateTableName"] + if delete_old_schema: + elem.attrib.pop("targetPhaseRateTableName") + elif "targetPhaseRate" in elem.attrib: + phaseConstraintAttributes["phaseRate"]=elem.attrib["targetPhaseRate"] + if delete_old_schema: + elem.attrib.pop("targetPhaseRate") + else: + writePhaseConstraint=False + print("error missing phase rate info") + if not isProducer: + if compoFluidModel: + if "injectionStream" in elem: + phaseConstraintAttributes["injectionStream"]=elem.attrib["injectionStream"] + phaseConstraintAttributes["injectionTemperature"]=elem.attrib["injectionTemperature"] + if delete_old_schema: + elem.attrib.pop("injectionStream") + elem.attrib.pop("injectionTemperature") + else: + print("error missinging injectionStream ",elem.attrib) + + if writePhaseConstraint: + elem.append(ET.Element(phaseConstraintTag,phaseConstraintAttributes)) + + # setup pressure constraint + pressureConstraintTag= pressureType+"BHPConstraint" + pressureConstraintAttributes={} + pressureConstraintAttributes["name"]="minbhp" if isProducer else "maxbhp" + if 'targetBHPTableName' in elem.attrib: + pressureConstraintAttributes["constraintScheduleTableName"]=elem.attrib["targetBHPTableName"] + if delete_old_schema: + elem.attrib.pop("targetBHPTableName") + elif 'targetBHP' in elem.attrib: + pressureConstraintAttributes["targetBHP"]=elem.attrib["targetBHP"] + if delete_old_schema: + elem.attrib.pop("targetBHP") + else: + print('error missing bhp info') + + if 'referenceElevation' in elem.attrib: + pressureConstraintAttributes["referenceElevation"]=elem.attrib["referenceElevation"] + if delete_old_schema: + elem.attrib.pop("referenceElevation") + else: + print('error missing bhp referenceElevation') + + elem.append(ET.Element(pressureConstraintTag,pressureConstraintAttributes)) + + totalVolRateTag= constraintType+"VolumeRateConstraint" + totalVolRateAttributes={} + totalVolRateAttributes["name"]="maxvolrateprod" if isProducer else "maxvolrateinj" + if 'targetTotalRate' in elem.attrib or 'targetTotalRateTableName' in elem.attrib: + if 'targetTotalRate' in elem.attrib: + totalVolRateAttributes["volumeRate"]=elem.attrib["targetTotalRate"] + if delete_old_schema: + elem.attrib.pop("targetTotalRate") + if 'targetTotalRateTableName' in elem.attrib: + totalVolRateAttributes["constraintScheduleTableName"]=elem.attrib["targetTotalRateTableName"] + if delete_old_schema: + elem.attrib.pop("targetTotalRateTableName") + if not isProducer: + if compoFluidModel: + totalVolRateAttributes["injectionStream"]=elem.attrib["injectionStream"] + totalVolRateAttributes["injectionTemperature"]=elem.attrib["injectionTemperature"] + if delete_old_schema: + elem.attrib.pop("injectionStream") + elem.attrib.pop("injectionTemperature") + else: + if isThermal: + if "injectionStream" in elem.attrib: + totalVolRateAttributes["injectionStream"]=elem.attrib["injectionStream"] + totalVolRateAttributes["injectionTemperature"]=elem.attrib["injectionTemperature"] + if delete_old_schema: + elem.attrib.pop("injectionStream") + elem.attrib.pop("injectionTemperature") + else: + totalVolRateAttributes["injectionStream"]="{1.0}" + totalVolRateAttributes["injectionTemperature"]="123" + + elem.append(ET.Element(totalVolRateTag,totalVolRateAttributes)) + + totalMassRateTag= constraintType+"MassRateConstraint" + totalMassRateAttributes={} + totalMassRateAttributes["name"]="maxmassrateprod" if isProducer else "maxmassrateinj" + if 'targetMassRate' in elem.attrib or 'targetMassRateTableName' in elem.attrib: + if 'targetMassRate' in elem.attrib: + totalMassRateAttributes["massRate"]=elem.attrib["targetMassRate"] + if delete_old_schema: + elem.attrib.pop("targetMassRate") + if 'targetMassRateTableName' in elem.attrib: + totalMassRateAttributes["constraintScheduleTableName"]=elem.attrib["targetMassRateTableName"] + if delete_old_schema: + elem.attrib.pop("targetMassRateTableName") + if not isProducer: + if True: #compoFluidModel: + totalMassRateAttributes["injectionStream"]=elem.attrib["injectionStream"] + totalMassRateAttributes["injectionTemperature"]=elem.attrib["injectionTemperature"] + if delete_old_schema: + elem.attrib.pop("injectionStream") + elem.attrib.pop("injectionTemperature") + elem.append(ET.Element(totalMassRateTag,totalMassRateAttributes)) + + wc={} + isCompositional=False + nlsparms={} + useMass=False + useMasVal="0" + for elem in root.iter(): + if elem.tag == "CompositionalMultiphaseWell": + isCompositional=True + if "maxRelativePressureChange" in elem.attrib: + nlsparms["maxRelativePressureChange"]=elem.attrib["maxRelativePressureChange"] + elem.attrib.pop("maxRelativePressureChange") + if "maxCompFractionChange" in elem.attrib: + nlsparms["maxCompFractionChange"]=elem.attrib["maxCompFractionChange"] + elem.attrib.pop("maxCompFractionChange") + if "useMass" in elem.attrib: + useMass=True + useMassVal=elem.attrib["useMass"] + elem.attrib.pop("useMass") + if "writeCSV" in elem.attrib: + nlsparms["writeCSV"]=elem.attrib["writeCSV"] + elem.attrib.pop("writeCSV") + + break + elif elem.tag == "SinglePhaseWell": + if "writeCSV" in elem.attrib: + nlsparms["writeCSV"]=elem.attrib["writeCSV"] + elem.attrib.pop("writeCSV") + for elem in root.iter(): + if elem.tag == "CompositionalMultiphaseWell" or elem.tag == "SinglePhaseWell": + elem.tag="WellManager" + if useMass: + elem.set("useMass",useMassVal) + + if elem.tag == "WellControls": + for k in nlsparms: + elem.attrib[k] = nlsparms[k] + if isCompositional: + elem.tag="CompositionalMultiphaseWell" + else: + elem.tag="SinglePhaseWell" + + return True ,tree + +def removeUseMass(xml_file,delete_old_schema,add_we,estimatorSolves): + with open(xml_file, 'rb') as xml_file: + tree = ET.parse(xml_file) + root = tree.getroot() + compoFluidModel = True + isThermal=False + + wc={} + isCompositional=False + nlsparms={} + useMass=False + useMasVal="0" + mod=False + for elem in root.iter(): + if elem.tag == "CompositionalMultiphaseWell": + isCompositional=True + if "useMass" in elem.attrib: + elem.attrib.pop("useMass") + mod=True + + return mod,tree + +def add_we(xml_file,estimatorSolves): + with open(xml_file, 'rb') as xml_file: + tree = ET.parse(xml_file) + root = tree.getroot() + compoFluidModel = True + isThermal=False + + wc={} + isCompositional=False + nlsparms={} + useMass=False + useMasVal="0" + mod=True + for elem in root.iter(): + if elem.tag == "CompositionalMultiphaseWell" or elem.tag == "SinglePhaseWell": + elem.attrib["estimateWellSolution"] = str(estimatorSolves) + + return mod,tree + +def main1(ifs,ofs,add_we,estimatorSolves,args): + try: + mod,tree= update_constraint_element(ifs, add_we,estimatorSolves) + #mod,tree= removeUseMass(ifs, delete_old_schema,add_we,estimatorSolves) + if mod: + wrap_width=80 + indent=" " + attr_per_line=True + pretty_print_file(tree, ofs, indent, wrap_width, attr_per_line,False) + # Optionally validate against XSD + if args.xsd: + ok, msg = validate_with_xsd(tree, args.xsd) + if not ok: + print("XSD validation failed:", msg, file=sys.stderr) + # still write a diagnostic copy + tree.write(ofs + ".failed.xml", encoding="utf-8", xml_declaration=True) + print("XSD failed for ",ofs ) + xml_formatter.format_file(ofs + ".failed.xml") + else: + print("XSD validation passed. Wrote to ",ofs) + except Exception as e: + print("Error occurred:", e,ifs) + +def add_estimator(ifs,ofs,estimatorSolves,args): + try: + #tree= updateconstraint_element(ifs, delete_old_schema,add_we,estimatorSolves) + mod,tree= add_we(ifs, estimatorSolves) + if mod: + wrap_width=80 + indent=" " + attr_per_line=True + pretty_print_file(tree, ofs, indent, wrap_width, attr_per_line,args.pretty) + # Optionally validate against XSD + if args.xsd: + ok, msg = validate_with_xsd(tree, args.xsd) + if not ok: + print("XSD validation failed:", msg, file=sys.stderr) + # still write a diagnostic copy + tree.write(ofs + ".failed.xml", encoding="utf-8", xml_declaration=True) + print("XSD failed for ",ofs ) + xml_formatter.format_file(ofs + ".failed.xml") + else: + print("XSD validation passed. Wrote to ",ofs) + except Exception as e: + print("Error occurred:", e,ifs) + +def main(): + # Two modes: single file or batch from list + # To create a list of files to process + # egrep -l -m1 -R "WellControl|SinglePhaseWell|CompositionalMultiphaseWell" ./ --include=\*.xml > convert_lst.txt + ## convert from file list + # cws_v3 -d --xsd=/Users/byer3/GEOS-DEV-1105/wc1014/src/coreComponents/schema/schema.xsd -r -f convert_lst.txt | tee convert.log + ## convert single file inplace + # cws_v3.py -scompositionalMultiphaseWell/compositional_multiphase_wells_1d.xml --xsd=/Users/byer3/GEOS-DEV/wmwe0603/src/coreComponents/schema/schema.xsd + + p = argparse.ArgumentParser(description="Add attributes and/or child elements to XML") + p.add_argument("-s", "--sourcefile", required=False, help="source XML file") + p.add_argument("-t", "--targetfile", required=False, help="output XML file") + p.add_argument("-a", "--add", action="store_true",default=False, help="add we strings") + p.add_argument("-e", "--estimatorSolves", type=int ,default=0, help="when to use estimator") + p.add_argument("-r", "--replace", action="store_true",default=True, help="in place substitution") + p.add_argument("-f", "--file", type=str ,default="", help="file with list of files to process") + p.add_argument("--xsd", required=True, help=" XSD file to validate output (requires lxml)") + args = p.parse_args() + + ofn_tag="" + if args.estimatorSolves >0 and not args.add: + ofn_tag+="we"+str(args.estimatorSolves) + if args.file: + if os.path.exists(args.file): + ifs = open(args.file,"r") + for f in ifs: + args.sourcefile=f.rstrip().lstrip() + if args.replace: + fn1=f.rstrip().lstrip() + fn2=fn1 + else: + fns = f.split() + fn1=fns[0].rstrip().lstrip() + if len(ofn_tag)>0: + fn2=fns[0].rstrip().lstrip() + fn2=fn2.replace(".xml",ofn_tag+".xml") + else: + fn2=fns[1].rstrip().lstrip() + print("Processing ",fn1,fn2,args.add,args.estimatorSolves) + if args.estimatorSolves >0 : + add_estimator(fn1,fn2,args.estimatorSolves,args) + else: + main1(fn1,fn2,args.add,args.estimatorSolves,args) + else: + print("File with list of files to process not found ",args.file) + + else: + if os.path.exists(args.sourcefile): + if not args.targetfile: + args.targetfile=args.sourcefile + main1(args.sourcefile,args.targetfile,args.add,args.estimatorSolves,args) + else: + print("Source file not found ",args.sourcefile) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/xml_formatter.py b/scripts/xml_formatter.py new file mode 100644 index 00000000000..1656aedf78f --- /dev/null +++ b/scripts/xml_formatter.py @@ -0,0 +1,205 @@ +import os +from lxml import etree as ElementTree # type: ignore[import] +import re +from typing import List, Any, TextIO + + + +def format_attribute( attribute_indent: str, ka: str, attribute_value: str ) -> str: + """Format xml attribute strings. + + Args: + attribute_indent (str): Attribute indent string + ka (str): Attribute name + attribute_value (str): Attribute value + + Returns: + str: Formatted attribute value + """ + # Make sure that a space follows commas + attribute_value = re.sub( r",\s*", ", ", attribute_value ) + + # Handle external brackets + attribute_value = re.sub( r"{\s*", "{ ", attribute_value ) + attribute_value = re.sub( r"\s*}", " }", attribute_value ) + + # Consolidate whitespace + attribute_value = re.sub( r"\s+", " ", attribute_value ) + + # Identify and split multi-line attributes + if re.match( r"\s*{\s*({[-+.,0-9a-zA-Z\s]*},?\s*)*\s*}", attribute_value ): + split_positions: List[ Any ] = [ match.end() for match in re.finditer( r"}\s*,", attribute_value ) ] + newline_indent = '\n%s' % ( ' ' * ( len( attribute_indent ) + len( ka ) + 4 ) ) + new_values = [] + for a, b in zip( [ None ] + split_positions, split_positions + [ None ], strict=False ): + new_values.append( attribute_value[ a:b ].strip() ) + if new_values: + attribute_value = newline_indent.join( new_values ) + + return attribute_value + + +def format_xml_level( output: TextIO, + node: ElementTree.Element, + level: int, + indent: str = ' ' * 2, + block_separation_max_depth: int = 2, + modify_attribute_indent: bool = False, + sort_attributes: bool = False, + close_tag_newline: bool = False, + include_namespace: bool = False ) -> None: + """Iteratively format the xml file. + + Args: + output (file): the output text file handle + node (lxml.etree.Element): the current xml element + level (int): the xml depth + indent (str): the xml indent style + block_separation_max_depth (int): the maximum depth to separate adjacent elements + modify_attribute_indent (bool): option to have flexible attribute indentation + sort_attributes (bool): option to sort attributes alphabetically + close_tag_newline (bool): option to place close tag on a separate line + include_namespace (bool): option to include the xml namespace in the output + """ + # Handle comments + if node.tag is ElementTree.Comment: + output.write( '\n%s' % ( indent * level, node.text ) ) + + else: + # Write opening line + opening_line = '\n%s<%s' % ( indent * level, node.tag ) + output.write( opening_line ) + + # Write attributes + if ( len( node.attrib ) > 0 ): + # Choose indentation + attribute_indent = '%s' % ( indent * ( level + 1 ) ) + if modify_attribute_indent: + attribute_indent = ' ' * ( len( opening_line ) ) + + # Get a copy of the attributes + attribute_dict = {} + if ( ( level == 0 ) & include_namespace ): + # Handle the optional namespace information at the root level + # Note: preferably, this would point to a schema we host online + attribute_dict[ 'xmlns:xsi' ] = 'http://www.w3.org/2001/XMLSchema-instance' + attribute_dict[ 'xsi:noNamespaceSchemaLocation' ] = '/usr/gapps/GEOS/schema/schema.xsd' + elif ( level > 0 ): + attribute_dict = node.attrib + + # Sort attribute names + akeys = list( attribute_dict.keys() ) + if sort_attributes: + akeys = sorted( akeys ) + + # Format attributes + for ka in akeys: + # Avoid formatting mathpresso expressions + if not ( node.tag in [ "SymbolicFunction", "CompositeFunction" ] and ka == "expression" ): + attribute_dict[ ka ] = format_attribute( attribute_indent, ka, attribute_dict[ ka ] ) + + for ii in range( 0, len( akeys ) ): + k = akeys[ ii ] + if ( ( ii == 0 ) & modify_attribute_indent ): + output.write( ' %s=\"%s\"' % ( k, attribute_dict[ k ] ) ) + else: + output.write( '\n%s%s=\"%s\"' % ( attribute_indent, k, attribute_dict[ k ] ) ) + + # Write children + if len( node ): + output.write( '>' ) + Nc = len( node ) + for ii, child in zip( range( Nc ), node, strict=False ): + format_xml_level( output, child, level + 1, indent, block_separation_max_depth, modify_attribute_indent, + sort_attributes, close_tag_newline, include_namespace ) + + # Add space between blocks + if ( ( level < block_separation_max_depth ) & ( ii < Nc - 1 ) & + ( child.tag is not ElementTree.Comment ) ): + output.write( '\n' ) + + # Write the end tag + output.write( '\n%s' % ( indent * level, node.tag ) ) + else: + if close_tag_newline: + output.write( '\n%s/>' % ( indent * level ) ) + else: + output.write( '/>' ) + + +def format_file( input_fname: str, + indent_size: int = 2, + indent_style: bool = False, + block_separation_max_depth: int = 2, + alphebitize_attributes: bool = False, + close_style: bool = False, + namespace: bool = False ) -> None: + """Script to format xml files. + + Args: + input_fname (str): Input file name + indent_size (int): Indent size + indent_style (bool): Style of indentation (0=fixed, 1=hanging) + block_separation_max_depth (int): Max depth to separate xml blocks + alphebitize_attributes (bool): Alphebitize attributes + close_style (bool): Style of close tag (0=same line, 1=new line) + namespace (bool): Insert this namespace in the xml description + """ + fname = os.path.expanduser( input_fname ) + try: + tree = ElementTree.parse( fname ) + root = tree.getroot() + prologue_comments = [ tmp.text for tmp in root.itersiblings( preceding=True ) ] + epilog_comments = [ tmp.text for tmp in root.itersiblings() ] + + with open( fname, 'w' ) as f: + f.write( '\n' ) + + for comment in reversed( prologue_comments ): + f.write( '\n' % ( comment ) ) + + format_xml_level( f, + root, + 0, + indent=' ' * indent_size, + block_separation_max_depth=block_separation_max_depth, + modify_attribute_indent=indent_style, + sort_attributes=alphebitize_attributes, + close_tag_newline=close_style, + include_namespace=namespace ) + + for comment in epilog_comments: + f.write( '\n' % ( comment ) ) + f.write( '\n' ) + + except ElementTree.ParseError as err: + print( '\nCould not load file: %s' % ( fname ) ) + print( err.msg ) + raise Exception( '\nCheck input file!' ) from err + + +def main() -> None: + """Script to format xml files. + + Args: + input (str): Input file name + -i/--indent (int): Indent size + -s/--style (int): Indent style + -d/--depth (int): Block separation depth + -a/--alphebitize (int): Alphebitize attributes + -c/--close (int): Close tag style + -n/--namespace (int): Include namespace + """ + parser = command_line_parsers.build_xml_formatter_input_parser() + args = parser.parse_args() + format_file( args.input, + indent_size=args.indent, + indent_style=args.style, + block_separation_max_depth=args.depth, + alphebitize_attributes=args.alphebitize, + close_style=args.close, + namespace=args.namespace ) + + +if __name__ == "__main__": + main() diff --git a/src/coreComponents/integrationTests/tableFunctionsFileTests/testTableFunctionsOutput.cpp b/src/coreComponents/integrationTests/tableFunctionsFileTests/testTableFunctionsOutput.cpp index bbb29ff0972..ae5394e2d26 100644 --- a/src/coreComponents/integrationTests/tableFunctionsFileTests/testTableFunctionsOutput.cpp +++ b/src/coreComponents/integrationTests/tableFunctionsFileTests/testTableFunctionsOutput.cpp @@ -84,26 +84,31 @@ char const * xmlInput = targetRegions="{ region }"> - - + - + referenceElevation="-0.01"/> + + + diff --git a/src/coreComponents/integrationTests/wellsTests/CMakeLists.txt b/src/coreComponents/integrationTests/wellsTests/CMakeLists.txt index badcac28453..0206cc917b9 100644 --- a/src/coreComponents/integrationTests/wellsTests/CMakeLists.txt +++ b/src/coreComponents/integrationTests/wellsTests/CMakeLists.txt @@ -3,6 +3,8 @@ set( gtest_geosx_tests testIsothermalReservoirCompositionalMultiphaseMSWells.cpp testIsothermalReservoirCompositionalMultiphaseSSWells.cpp testOpenClosePerf.cpp + testThermalEstimatorProdWell.cpp + testThermalEstimatorInjWell.cpp testReservoirCompositionalMultiphaseMSWells.cpp testReservoirSinglePhaseMSWells.cpp testReservoirThermalSinglePhaseMSWells.cpp diff --git a/src/coreComponents/integrationTests/wellsTests/testIsothermalReservoirCompositionalMultiphaseMSWells.cpp b/src/coreComponents/integrationTests/wellsTests/testIsothermalReservoirCompositionalMultiphaseMSWells.cpp index da7d3606fb2..0736e182dca 100644 --- a/src/coreComponents/integrationTests/wellsTests/testIsothermalReservoirCompositionalMultiphaseMSWells.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testIsothermalReservoirCompositionalMultiphaseMSWells.cpp @@ -94,26 +94,31 @@ char const * xmlInput = targetRegions="{ region }"> - - + surfaceTemperature="300.15"> + + + @@ -300,7 +305,7 @@ void testNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compositio real64 const relTol, LAMBDA && assembleFunction ) { - CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); + WellManager & wellSolver = *solver.wellSolver(); CompositionalMultiphaseFVM & flowSolver = dynamicCast< CompositionalMultiphaseFVM & >( *solver.reservoirSolver() ); localIndex const NC = flowSolver.numFluidComponents(); @@ -463,7 +468,7 @@ void testNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compositio wellElemCompDens.move( hostMemorySpace, false ); arrayView1d< real64 > const & connRate = - subRegion.getField< fields::well::mixtureConnectionRate >(); + subRegion.getField< fields::well::connectionRate >(); connRate.move( hostMemorySpace, false ); // a) compute all the derivatives wrt to the pressure in WELL elem iwelem @@ -580,6 +585,23 @@ class CompositionalMultiphaseReservoirSolverTest : public ::testing::Test solver->getSystemSolution() ); solver->implicitStepSetup( time, dt, domain ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.initializeWell( domain, domain.getMeshBodies(), meshBodyName, meshLevel, subRegion, time ); + } ); + } ); } static real64 constexpr time = 0.0; @@ -641,7 +663,23 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Accum [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleAccumulationTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellAccumulationTerms( time, dt, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } diff --git a/src/coreComponents/integrationTests/wellsTests/testIsothermalReservoirCompositionalMultiphaseSSWells.cpp b/src/coreComponents/integrationTests/wellsTests/testIsothermalReservoirCompositionalMultiphaseSSWells.cpp index 277c7a2a38c..9bf476f7cb4 100644 --- a/src/coreComponents/integrationTests/wellsTests/testIsothermalReservoirCompositionalMultiphaseSSWells.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testIsothermalReservoirCompositionalMultiphaseSSWells.cpp @@ -94,26 +94,31 @@ char const * xmlInput = targetRegions="{ region }"> - - - + surfaceTemperature="300.15"> + + + + @@ -301,7 +306,7 @@ void testNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compositio real64 const relTol, LAMBDA && assembleFunction ) { - CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); + WellManager & wellSolver = *solver.wellSolver(); CompositionalMultiphaseFVM & flowSolver = dynamicCast< CompositionalMultiphaseFVM & >( *solver.reservoirSolver() ); localIndex const NC = flowSolver.numFluidComponents(); @@ -510,7 +515,7 @@ void testNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compositio wellElemCompDens.move( hostMemorySpace, false ); arrayView1d< real64 > const & connRate = - subRegion.getField< fields::well::mixtureConnectionRate >(); + subRegion.getField< fields::well::connectionRate >(); connRate.move( hostMemorySpace, false ); // a) compute all the derivatives wrt to the pressure in WELL elem iwelem @@ -531,7 +536,6 @@ void testNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compositio 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 ); @@ -652,6 +656,23 @@ class CompositionalMultiphaseReservoirSolverTest : public ::testing::Test solver->getSystemSolution() ); solver->implicitStepSetup( time, dt, domain ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.initializeWell( domain, domain.getMeshBodies(), meshBodyName, meshLevel, subRegion, time ); + } ); + } ); } static real64 constexpr time = 0.0; @@ -699,7 +720,23 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Accum [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleAccumulationTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellAccumulationTerms( time, dt, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } #endif diff --git a/src/coreComponents/integrationTests/wellsTests/testOpenClosePerf.cpp b/src/coreComponents/integrationTests/wellsTests/testOpenClosePerf.cpp index 36a32117b62..136aaf417cb 100644 --- a/src/coreComponents/integrationTests/wellsTests/testOpenClosePerf.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testOpenClosePerf.cpp @@ -57,18 +57,24 @@ char const * PreXmlInput = temperature="297.15" useMass="0"> - - - + + + + + & solv LAMBDA && perfFunction ) { - CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); + WellManager & wellSolver = *solver.wellSolver(); typedef stdMap< real64, stdVector< int > > map_type; map_type refVal; @@ -214,7 +220,7 @@ void testPlugBottomUpPerfCheck( CompositionalMultiphaseReservoirAndWells<> & sol LAMBDA && perfFunction ) { - CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); + WellManager & wellSolver = *solver.wellSolver(); typedef stdMap< real64, stdVector< int > > map_type; map_type refVal; @@ -257,7 +263,7 @@ void testOpenTopDownPerfCheck( CompositionalMultiphaseReservoirAndWells<> & solv LAMBDA && perfFunction ) { - CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); + WellManager & wellSolver = *solver.wellSolver(); typedef stdMap< real64, stdVector< int > > map_type; map_type refPerfTable; @@ -299,7 +305,7 @@ void testOpenBottomUpPerfCheck( CompositionalMultiphaseReservoirAndWells<> & sol LAMBDA && perfFunction ) { - CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); + WellManager & wellSolver = *solver.wellSolver(); typedef stdMap< real64, stdVector< int > > map_type; map_type refVal; @@ -513,8 +519,23 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, plugTopDownPerfCheck ) testPlugTopDownPerfCheck( *solver, domain, [&] ( real64 time ) { - WellSolverBase * wellSolverBase = solver->wellSolver(); - wellSolverBase->setPerforationStatus( time, domain ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.setPerforationStatus( time, subRegion ); + } ); + } ); } ); } @@ -527,8 +548,23 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, plugBottomUpPerfCheck ) testPlugBottomUpPerfCheck( *solver, domain, [&] ( real64 time ) { - WellSolverBase * wellSolverBase = solver->wellSolver(); - wellSolverBase->setPerforationStatus( time, domain ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.setPerforationStatus( time, subRegion ); + } ); + } ); } ); } TEST_F( CompositionalMultiphaseReservoirSolverTest, openTopDownPerfCheck ) @@ -540,8 +576,23 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, openTopDownPerfCheck ) testOpenTopDownPerfCheck( *solver, domain, [&] ( real64 time ) { - WellSolverBase * wellSolverBase = solver->wellSolver(); - wellSolverBase->setPerforationStatus( time, domain ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.setPerforationStatus( time, subRegion ); + } ); + } ); } ); } @@ -554,8 +605,24 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, openBottomUpPerfCheck ) testOpenBottomUpPerfCheck( *solver, domain, [&] ( real64 time ) { - WellSolverBase * wellSolverBase = solver->wellSolver(); - wellSolverBase->setPerforationStatus( time, domain ); + + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.setPerforationStatus( time, subRegion ); + } ); + } ); } ); } diff --git a/src/coreComponents/integrationTests/wellsTests/testReservoirCompositionalMultiphaseMSWells.cpp b/src/coreComponents/integrationTests/wellsTests/testReservoirCompositionalMultiphaseMSWells.cpp index 74f624e5d2e..b336ce89d3c 100644 --- a/src/coreComponents/integrationTests/wellsTests/testReservoirCompositionalMultiphaseMSWells.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testReservoirCompositionalMultiphaseMSWells.cpp @@ -57,26 +57,38 @@ char const * xmlInput = temperature="297.15" useMass="0"> - - - + + + + + + + + & solver, real64 const relTol, LAMBDA && assembleFunction ) { - CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); + WellManager & wellSolver = *solver.wellSolver(); CompositionalMultiphaseFVM & flowSolver = dynamicCast< CompositionalMultiphaseFVM & >( *solver.reservoirSolver() ); localIndex const NC = flowSolver.numFluidComponents(); @@ -363,7 +375,7 @@ void testNumericalJacobian( CompositionalMultiphaseReservoirAndWells<> & solver, wellElemCompDens.move( hostMemorySpace, false ); arrayView1d< real64 > const & connRate = - subRegion.getField< fields::well::mixtureConnectionRate >(); + subRegion.getField< fields::well::connectionRate >(); connRate.move( hostMemorySpace, false ); // a) compute all the derivatives wrt to the pressure in WELL elem iwelem @@ -480,6 +492,23 @@ class CompositionalMultiphaseReservoirSolverTest : public ::testing::Test solver->getSystemSolution() ); solver->implicitStepSetup( time, dt, domain ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.initializeWell( domain, domain.getMeshBodies(), meshBodyName, meshLevel, subRegion, time ); + } ); + } ); } static real64 constexpr time = 0.0; @@ -525,7 +554,23 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Flux [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleFluxTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellFluxTerms( time, dt, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } @@ -542,7 +587,23 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Press [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assemblePressureRelations( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellPressureRelations( time, dt, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } diff --git a/src/coreComponents/integrationTests/wellsTests/testReservoirSinglePhaseMSWells.cpp b/src/coreComponents/integrationTests/wellsTests/testReservoirSinglePhaseMSWells.cpp index d75ad50a957..031bded773d 100644 --- a/src/coreComponents/integrationTests/wellsTests/testReservoirSinglePhaseMSWells.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testReservoirSinglePhaseMSWells.cpp @@ -58,22 +58,35 @@ char const * PreXmlInput = discretization="singlePhaseTPFA" targetRegions="{Region1}"> - - - - + + + + + + + + + + & solver, real64 const relTol, LAMBDA && assembleFunction ) { - SinglePhaseWell & wellSolver = *solver.wellSolver(); + WellManager & wellSolver = *solver.wellSolver(); SinglePhaseFVM< SinglePhaseBase > & flowSolver = dynamicCast< SinglePhaseFVM< SinglePhaseBase > & >( *solver.reservoirSolver() ); CRSMatrix< real64, globalIndex > const & jacobian = solver.getLocalMatrix(); @@ -357,6 +370,23 @@ class SinglePhaseReservoirSolverTest : public ::testing::Test solver->getSystemSolution() ); solver->implicitStepSetup( TIME, DT, domain ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.initializeWell( domain, domain.getMeshBodies(), meshBodyName, meshLevel, subRegion, TIME ); + } ); + } ); } void TestAssembleCouplingTerms() @@ -385,7 +415,23 @@ class SinglePhaseReservoirSolverTest : public ::testing::Test [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleFluxTerms( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellFluxTerms( TIME, DT, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } @@ -400,7 +446,23 @@ class SinglePhaseReservoirSolverTest : public ::testing::Test [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assemblePressureRelations( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellPressureRelations( TIME, DT, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } @@ -415,7 +477,23 @@ class SinglePhaseReservoirSolverTest : public ::testing::Test [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleAccumulationTerms( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellAccumulationTerms( TIME, DT, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } @@ -497,7 +575,24 @@ TEST_F( SinglePhaseReservoirSolverInternalWellTest, jacobianNumericalCheck_Flux [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleFluxTerms( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); + + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellFluxTerms( TIME, DT, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } diff --git a/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells.cpp b/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells.cpp index 16cd7e0855c..d473b995dee 100644 --- a/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells.cpp @@ -60,27 +60,40 @@ char const * PreXmlInput = discretization="singlePhaseTPFA" targetRegions="{Region1}"> - - - - + + + + + + + + + + & solver, LAMBDA && assembleFunction ) { GEOS_UNUSED_VAR( testName ); - SinglePhaseWell & wellSolver = *solver.wellSolver(); + WellManager & wellSolver = *solver.wellSolver(); SinglePhaseFVM< SinglePhaseBase > & flowSolver = dynamicCast< SinglePhaseFVM< SinglePhaseBase > & >( *solver.reservoirSolver() ); CRSMatrix< real64, globalIndex > const & jacobian = solver.getLocalMatrix(); @@ -513,6 +526,23 @@ class SinglePhaseReservoirSolverTest : public ::testing::Test solver->getSystemSolution() ); solver->implicitStepSetup( TIME, DT, domain ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.initializeWell( domain, domain.getMeshBodies(), meshBodyName, meshLevel, subRegion, TIME ); + } ); + } ); } void TestAssembleCouplingTerms() @@ -545,7 +575,23 @@ class SinglePhaseReservoirSolverTest : public ::testing::Test [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleFluxTerms( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellFluxTerms( TIME, DT, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } @@ -559,7 +605,23 @@ class SinglePhaseReservoirSolverTest : public ::testing::Test [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assemblePressureRelations( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellPressureRelations( TIME, DT, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } @@ -574,7 +636,23 @@ class SinglePhaseReservoirSolverTest : public ::testing::Test [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleAccumulationTerms( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellAccumulationTerms( TIME, DT, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } @@ -656,7 +734,24 @@ TEST_F( SinglePhaseReservoirSolverInternalWellTest, jacobianNumericalCheck_Flux [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleFluxTerms( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); + + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellFluxTerms( TIME, DT, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } diff --git a/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells_RateInj.cpp b/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells_RateInj.cpp index 9169eeb0206..8e4776c9730 100644 --- a/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells_RateInj.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testReservoirThermalSinglePhaseMSWells_RateInj.cpp @@ -73,26 +73,30 @@ char const * XmlInput = targetRegions="{ region }"> - - + + referenceElevation="-0.01"/> + + @@ -305,7 +309,7 @@ void testNumericalJacobian( SinglePhaseReservoirAndWells<> & solver, { GEOS_UNUSED_VAR( testName ); - SinglePhaseWell & wellSolver = *solver.wellSolver(); + WellManager & wellSolver = *solver.wellSolver(); SinglePhaseFVM< SinglePhaseBase > & flowSolver = dynamicCast< SinglePhaseFVM< SinglePhaseBase > & >( *solver.reservoirSolver() ); CRSMatrix< real64, globalIndex > const & jacobian = solver.getLocalMatrix(); @@ -596,6 +600,23 @@ class SinglePhaseReservoirSolverTest : public ::testing::Test solver->getSystemSolution() ); solver->implicitStepSetup( TIME, DT, domain ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.initializeWell( domain, domain.getMeshBodies(), meshBodyName, meshLevel, subRegion, TIME ); + } ); + } ); } void TestAssembleCouplingTerms() @@ -624,7 +645,23 @@ class SinglePhaseReservoirSolverTest : public ::testing::Test [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleFluxTerms( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellFluxTerms( TIME, DT, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } @@ -638,7 +675,23 @@ class SinglePhaseReservoirSolverTest : public ::testing::Test [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assemblePressureRelations( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellPressureRelations( TIME, DT, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } @@ -653,7 +706,23 @@ class SinglePhaseReservoirSolverTest : public ::testing::Test [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleAccumulationTerms( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellAccumulationTerms( TIME, DT, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } @@ -710,7 +779,24 @@ TEST_F( SinglePhaseReservoirSolverInternalWellTest, jacobianNumericalCheck_Flux [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleFluxTerms( TIME, DT, domain, solver->getDofManager(), localMatrix, localRhs ); + + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellFluxTerms( TIME, DT, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } diff --git a/src/coreComponents/integrationTests/wellsTests/testThermalEstimatorInjWell.cpp b/src/coreComponents/integrationTests/wellsTests/testThermalEstimatorInjWell.cpp new file mode 100644 index 00000000000..7bd3df651c5 --- /dev/null +++ b/src/coreComponents/integrationTests/wellsTests/testThermalEstimatorInjWell.cpp @@ -0,0 +1,955 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 testWellEstimatorNumericalJacobian( 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( testName ); + WellManager & wellSolver = *solver.wellSolver(); + + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const & meshBodyName, + MeshLevel & mesh, + string_array const & regionNames ) + { + mesh.getElemManager().forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + CompositionalMultiphaseWell * compWell = dynamic_cast< CompositionalMultiphaseWell * >(&wellControls); + compWell->setWellState( 1 ); + compWell->initializeWell( domain, domain.getMeshBodies(), meshBodyName, mesh, subRegion, time_n ); + } ); + } ); + + 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 ) + { + bool processMesh = true; + meshBody.forMeshLevels( [&] ( MeshLevel & mesh ) + { + if( !processMesh ) + return; + processMesh = false; + 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; + } ); + } + 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::connectionRate >(); + 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() ); + std::cout << "tjb dq iwelem " << iwelem << " " << (residual[25] - residualOrig[25])/dRate << std::endl; + 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< CompositionalMultiphaseBase > >( "reservoirSystem" ); + + DomainPartition & domain = state.getProblemManager().getDomainPartition(); + + solver->setupSystem( domain, + solver->getDofManager(), + solver->getLocalMatrix(), + solver->getSystemRhs(), + solver->getSystemSolution() ); + + solver->implicitStepSetup( time, dt, domain ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.initializeWell( domain, domain.getMeshBodies(), meshBodyName, meshLevel, subRegion, time ); + } ); + } ); + } + + 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(); + + testWellEstimatorNumericalJacobian( *solver, domain, perturb, time, tol, false, "Check_System", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + + DofManager const & dofManager = solver->getDofManager(); + WellManager * wellSolver = solver->wellSolver(); + wellSolver->forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + ElementRegionManager & elemManager = mesh.getElemManager(); + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + // call assemble to fill the matrix and the rhs + WellControls & wellControls = wellSolver->getWellControls( subRegion ); + CompositionalMultiphaseWell * compWell = dynamic_cast< CompositionalMultiphaseWell * >(&wellControls); + compWell->assembleSystem( time, + dt, + 0, + elemManager, + subRegion, + dofManager, + 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(); + + testWellEstimatorNumericalJacobian( *solver, domain, perturb, time, tol, false, "Check_Accum", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + + //DofManager const & dofManager = solver->wellSolver()->getDofManager(); + WellManager * wellSolver = solver->wellSolver(); + wellSolver->forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + ElementRegionManager & elemManager = mesh.getElemManager(); + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + // call assemble to fill the matrix and the rhs + WellControls & wellControls = wellSolver->getWellControls( subRegion ); + wellControls.assembleWellAccumulationTerms( time, dt, subRegion, 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(); + + testWellEstimatorNumericalJacobian( *solver, domain, perturb, time, tol, true, "Check_PressureRelation", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + + //DofManager const & dofManager = solver->wellSolver()->getDofManager(); + DofManager const & dofManager = solver->getDofManager(); + WellManager * wellSolver = solver->wellSolver(); + wellSolver->forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + ElementRegionManager & elemManager = mesh.getElemManager(); + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + // call assemble to fill the matrix and the rhs + WellControls & wellControls = wellSolver->getWellControls( subRegion ); + //wellControls.assembleWellConstraintTerms( time, dt, subRegion, dofManager, localMatrix.toViewConstSizes(), localRhs ); + wellControls.assembleWellPressureRelations( time, dt, subRegion, dofManager, localMatrix.toViewConstSizes(), 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(); + + testWellEstimatorNumericalJacobian( *solver, domain, perturb, time, tol, true, "Check_Flux", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + + //DofManager const & dofManager = solver->wellSolver()->getDofManager(); + WellManager * wellSolver = solver->wellSolver(); + wellSolver->forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + ElementRegionManager & elemManager = mesh.getElemManager(); + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + // call assemble to fill the matrix and the rhs + WellControls & wellControls = wellSolver->getWellControls( subRegion ); + wellControls.assembleWellFluxTerms( time, dt, subRegion, 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/testThermalEstimatorProdWell.cpp b/src/coreComponents/integrationTests/wellsTests/testThermalEstimatorProdWell.cpp new file mode 100644 index 00000000000..ed45f48f4ed --- /dev/null +++ b/src/coreComponents/integrationTests/wellsTests/testThermalEstimatorProdWell.cpp @@ -0,0 +1,969 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 testWellEstimatorNumericalJacobian( CompositionalMultiphaseReservoirAndWells< CompositionalMultiphaseBase > & solver, + DomainPartition & domain, + real64 const perturbParameter, + real64 const time_n, + real64 const relTol, std::string const & testName, + LAMBDA && assembleFunction ) +{ + WellManager & wellSolver = *solver.wellSolver(); + + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const & meshBodyName, + MeshLevel & mesh, + string_array const & regionNames ) + { + mesh.getElemManager().forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + CompositionalMultiphaseWell * compWell = dynamic_cast< CompositionalMultiphaseWell * >(&wellControls); + compWell->setWellState( 1 ); + compWell->initializeWell( domain, domain.getMeshBodies(), meshBodyName, mesh, subRegion, time_n ); + } ); + } ); + + CompositionalMultiphaseFVM & flowSolver = dynamicCast< CompositionalMultiphaseFVM & >( *solver.reservoirSolver() ); + + localIndex const NC = flowSolver.numFluidComponents(); + + //ßCRSMatrix< real64, globalIndex > const & jacobian = wellSolver.getLocalMatrix(); + CRSMatrix< real64, globalIndex > const & jacobian = solver.getLocalMatrix(); + array1d< real64 > residual( jacobian.numRows() ); + //DofManager const & dofManager = wellSolver.getDofManager(); + 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 ) + { + bool processMesh = true; + meshBody.forMeshLevels( [&] ( MeshLevel & mesh ) + { + if( !processMesh ) + return; + processMesh = false; + ElementRegionManager & elemManager = mesh.getElemManager(); + for( localIndex er = 0; er < elemManager.numRegions(); ++er ) + { + //if ( er == 1) + // continue; + 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 ( ei > 0 ) + // continue; + + { + 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; + } ); + } + 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::connectionRate >(); + 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< CompositionalMultiphaseBase > >( "reservoirSystem" ); + + DomainPartition & domain = state.getProblemManager().getDomainPartition(); + + solver->setupSystem( domain, + solver->getDofManager(), + solver->getLocalMatrix(), + solver->getSystemRhs(), + solver->getSystemSolution() ); + +#if 0 + solver->wellSolver()->setupSystem( domain, + solver->wellSolver()->getDofManager(), + solver->wellSolver()->getLocalMatrix(), + solver->wellSolver()->getSystemRhs(), + solver->wellSolver()->getSystemSolution() ); +#endif + solver->implicitStepSetup( time, dt, domain ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.initializeWell( domain, domain.getMeshBodies(), meshBodyName, meshLevel, subRegion, time ); + } ); + } ); + } + + 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(); + + testWellEstimatorNumericalJacobian( *solver, domain, perturb, time, tol, "Check_System", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + + DofManager const & dofManager = solver->getDofManager(); + WellManager * wellSolver = solver->wellSolver(); + wellSolver->forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + ElementRegionManager & elemManager = mesh.getElemManager(); + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + // call assemble to fill the matrix and the rhs + WellControls & wellControls = wellSolver->getWellControls( subRegion ); + CompositionalMultiphaseWell * compWell = dynamic_cast< CompositionalMultiphaseWell * >(&wellControls); + compWell->assembleSystem( time, + dt, + 0, + elemManager, + subRegion, + dofManager, + localMatrix, + localRhs ); + +// apply boundary conditions to system +#if 0 + compWell->applyWellBoundaryConditions( time, + dt, + elemManager, + subRegion, + dofManager, + localRhs, + localMatrix ); +#endif + } ); + } ); + + 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(); + + testWellEstimatorNumericalJacobian( *solver, domain, perturb, time, tol, "Check_Accum", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + + //DofManager const & dofManager = solver->wellSolver()->getDofManager(); + WellManager * wellSolver = solver->wellSolver(); + wellSolver->forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + ElementRegionManager & elemManager = mesh.getElemManager(); + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + // call assemble to fill the matrix and the rhs + WellControls & wellControls = wellSolver->getWellControls( subRegion ); + wellControls.assembleWellAccumulationTerms( time, dt, subRegion, 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(); + + testWellEstimatorNumericalJacobian( *solver, domain, perturb, time, tol, "Check_PressureRelation", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + + //DofManager const & dofManager = solver->wellSolver()->getDofManager(); + DofManager const & dofManager = solver->getDofManager(); + WellManager * wellSolver = solver->wellSolver(); + wellSolver->forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + ElementRegionManager & elemManager = mesh.getElemManager(); + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + // call assemble to fill the matrix and the rhs + WellControls & wellControls = wellSolver->getWellControls( subRegion ); + //wellControls.assembleWellConstraintTerms( time, dt, subRegion, dofManager, localMatrix.toViewConstSizes(), localRhs ); + wellControls.assembleWellPressureRelations( time, dt, subRegion, dofManager, localMatrix.toViewConstSizes(), 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(); + + testWellEstimatorNumericalJacobian( *solver, domain, perturb, time, tol, "Check_Flux", + [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + + //DofManager const & dofManager = solver->wellSolver()->getDofManager(); + WellManager * wellSolver = solver->wellSolver(); + wellSolver->forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + ElementRegionManager & elemManager = mesh.getElemManager(); + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + // call assemble to fill the matrix and the rhs + WellControls & wellControls = wellSolver->getWellControls( subRegion ); + wellControls.assembleWellFluxTerms( time, dt, subRegion, 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/testThermalInjWell.cpp b/src/coreComponents/integrationTests/wellsTests/testThermalInjWell.cpp index b7bfa1a4ce6..77b7b1d60ae 100644 --- a/src/coreComponents/integrationTests/wellsTests/testThermalInjWell.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testThermalInjWell.cpp @@ -93,28 +93,32 @@ char const * xmlInput = maxCompFractionChange="0.5" targetRegions="{ region }"> - - - - + control="totalVolRate"> + + + + )xml"; +// CSV output file are generated for the jacobian, which can be used to compare the analytical and numerical results. +// Both matrices are reported to same file 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 ) @@ -328,7 +334,9 @@ void printCompareLocalMatrices( CRSMatrixView< T const, COL_INDEX const > const omat1.close(); } - +// CSV output file are generated for the residuals, which can be used to compare the analytical and numerical results. +// Both residuals are reported to same file. This is used to determine how the perturbation affects the residuals. +// This is useful to determine if the perturbation is too small or too large. void printResiduals( array1d< real64 > const & rsd1, array1d< real64 > const & rsd2, std::string const & testName ) { @@ -351,7 +359,7 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos { GEOS_UNUSED_VAR( time_n ); GEOS_UNUSED_VAR ( testName ); - CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); + WellManager & wellSolver = *solver.wellSolver(); CompositionalMultiphaseFVM & flowSolver = dynamicCast< CompositionalMultiphaseFVM & >( *solver.reservoirSolver() ); @@ -381,6 +389,8 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos //////////////////////////////////////////////// // Step 1) Compute the terms in J_RR and J_WR // //////////////////////////////////////////////// +// Toggels to turn on/off the numerical jacobian computation of terms with respect to reservoir element dofs. +// This is useful to isolate the terms that are causing the test to fail. #if 1 domain.forMeshBodies( [&] ( MeshBody & meshBody ) { @@ -412,6 +422,7 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos // a) compute all the derivatives wrt to the pressure in RESERVOIR elem ei for( localIndex ei = 0; ei < subRegion.size(); ++ei ) { +// Turn on/off the numerical jacobian computation of terms with respect to reservoir pressure. #if 1 { solver.resetStateToBeginningOfStep( domain ); @@ -447,6 +458,7 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos jacobianFD.toViewConstSizes() ); } #endif +// Turn on/off the numerical jacobian computation of terms with respect to reservoir temperature. #if 1 { solver.resetStateToBeginningOfStep( domain ); @@ -482,6 +494,7 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos jacobianFD.toViewConstSizes() ); } #endif +// Turn on/off the numerical jacobian computation of terms with respect to reservoir component density. #if 1 real64 totalDensity = 0.0; for( localIndex ic = 0; ic < NC; ++ic ) @@ -493,7 +506,7 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos { solver.resetStateToBeginningOfStep( domain ); - real64 const dRho = perturbParameter * totalDensity; + real64 const dRho = perturbParameter * (totalDensity+ perturbParameter); compDens.move( hostMemorySpace, true ); compDens[ei][jc] += dRho; @@ -529,14 +542,13 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos } ); #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 +// Toggels to turn on/off the numerical jacobian computation of terms with respect to well element dofs. +// This is useful to isolate the terms that are causing the test to fail. if( 1 ) wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, MeshLevel & mesh, @@ -564,13 +576,13 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos wellElemCompDens.move( hostMemorySpace, false ); arrayView1d< real64 > const & connRate = - subRegion.getField< fields::well::mixtureConnectionRate >(); + subRegion.getField< fields::well::connectionRate >(); 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 ) { - +// Turn on/off the numerical jacobian computation of terms with respect to well pressure. #if 1 { solver.resetStateToBeginningOfStep( domain ); @@ -594,6 +606,7 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos jacobianFD.toViewConstSizes() ); } #endif +// Turn on/off the numerical jacobian computation of terms with respect to well component density. #if 1 real64 wellElemTotalDensity = 0.0; for( localIndex ic = 0; ic < NC; ++ic ) @@ -604,7 +617,7 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos { solver.resetStateToBeginningOfStep( domain ); - real64 const dRho = perturbParameter * wellElemTotalDensity; + real64 const dRho = perturbParameter * (wellElemTotalDensity+ perturbParameter); wellElemCompDens.move( hostMemorySpace, true ); wellElemCompDens[iwelem][jc] += dRho; @@ -663,10 +676,9 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos } #endif } - +// Turn on/off the numerical jacobian computation of terms with respect to well connection rate. #if 1 - // b) compute all the derivatives wrt to the connection in WELL elem - // iwelem + for( localIndex iwelem = 0; iwelem < subRegion.size(); ++iwelem ) { { @@ -741,12 +753,13 @@ 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. +// Enable test for full well system jacobian, which includes the coupling terms. +// There are is a terms that cause this test to fail, these are dt terms of cell connected to cell with boundary condtion. +// The the well cell with boundary condition cannot have 2 constraints. The temperature equation is set so that +// in the energy balance dEnergyBalance/dT = 1 and the residual is set to zero. +// This causes the numerical jacobian to have a non-zero value, but the analytical jacobian has zero. // Otherwise the test is good, uncomment out printCompareLocalMatrices and look at FD and computed derivatives +#if 0 TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_System ) { real64 const perturb = std::sqrt( eps ); @@ -776,9 +789,26 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Accum [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleAccumulationTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellAccumulationTerms( time, dt, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } +// Enable test for well pressure relation derivatives #if 1 TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_PressureRelation ) { @@ -791,10 +821,27 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Press [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assemblePressureRelations( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellPressureRelations( time, dt, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } #endif +// Enable test for well flux derivatives #if 1 TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Flux ) { @@ -807,7 +854,24 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Flux [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleFluxTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellFluxTerms( time, dt, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } #endif diff --git a/src/coreComponents/integrationTests/wellsTests/testThermalProdWell.cpp b/src/coreComponents/integrationTests/wellsTests/testThermalProdWell.cpp index a0bbc409c9e..fda57774f2b 100644 --- a/src/coreComponents/integrationTests/wellsTests/testThermalProdWell.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testThermalProdWell.cpp @@ -37,8 +37,6 @@ using namespace geos::testing; CommandLineOptions g_commandLineOptions; - - void writeTableToFile( string const & filename, char const * str ) { std::ofstream os( filename ); @@ -95,14 +93,14 @@ char const * xmlInput = maxCompFractionChange="0.5" targetRegions="{ region }"> - - + surfaceTemperature="300.15"> + + + )xml"; +// CSV output file are generated for the jacobian, which can be used to compare the analytical and numerical results. +// Both matrices are reported to same file 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 ) @@ -329,7 +334,9 @@ void printCompareLocalMatrices( CRSMatrixView< T const, COL_INDEX const > const omat1.close(); } - +// CSV output file are generated for the residuals, which can be used to compare the analytical and numerical results. +// Both residuals are reported to same file. This is used to determine how the perturbation affects the residuals. +// This is useful to determine if the perturbation is too small or too large. void printResiduals( array1d< real64 > const & rsd1, array1d< real64 > const & rsd2, std::string const & testName ) { @@ -352,7 +359,7 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos { GEOS_UNUSED_VAR( time_n ); GEOS_UNUSED_VAR ( testName ); - CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); + WellManager & wellSolver = *solver.wellSolver(); CompositionalMultiphaseFVM & flowSolver = dynamicCast< CompositionalMultiphaseFVM & >( *solver.reservoirSolver() ); @@ -381,6 +388,8 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos //////////////////////////////////////////////// // Step 1) Compute the terms in J_RR and J_WR // //////////////////////////////////////////////// +// Toggels to turn on/off the numerical jacobian computation of terms with respect to reservoir element dofs. +// This is useful to isolate the terms that are causing the test to fail. #if 1 domain.forMeshBodies( [&] ( MeshBody & meshBody ) { @@ -412,8 +421,8 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos // a) compute all the derivatives wrt to the pressure in RESERVOIR elem ei for( localIndex ei = 0; ei < subRegion.size(); ++ei ) { - - +// Turn on/off the numerical jacobian computation of terms with respect to reservoir pressure. +#if 1 { solver.resetStateToBeginningOfStep( domain ); @@ -446,6 +455,8 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos dP, jacobianFD.toViewConstSizes() ); } +#endif +// Turn on/off the numerical jacobian computation of terms with respect to reservoir temperature. #if 1 { solver.resetStateToBeginningOfStep( domain ); @@ -481,6 +492,7 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos jacobianFD.toViewConstSizes() ); } #endif +// Turn on/off the numerical jacobian computation of terms with respect to reservoir component density. #if 1 real64 totalDensity = 0.0; for( localIndex ic = 0; ic < NC; ++ic ) @@ -492,7 +504,7 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos { solver.resetStateToBeginningOfStep( domain ); - real64 const dRho = perturbParameter * totalDensity; + real64 const dRho = perturbParameter * (totalDensity+perturbParameter); compDens.move( hostMemorySpace, true ); compDens[ei][jc] += dRho; @@ -528,14 +540,13 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos } ); #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 +// Toggels to turn on/off the numerical jacobian computation of terms with respect to well element dofs. +// This is useful to isolate the terms that are causing the test to fail. if( 1 ) wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, MeshLevel & mesh, @@ -563,13 +574,13 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos wellElemCompDens.move( hostMemorySpace, false ); arrayView1d< real64 > const & connRate = - subRegion.getField< fields::well::mixtureConnectionRate >(); + subRegion.getField< fields::well::connectionRate >(); 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 ) { - +// Turn on/off the numerical jacobian computation of terms with respect to well pressure. #if 1 { solver.resetStateToBeginningOfStep( domain ); @@ -593,6 +604,7 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos jacobianFD.toViewConstSizes() ); } #endif +// Turn on/off the numerical jacobian computation of terms with respect to well component density. #if 1 real64 wellElemTotalDensity = 0.0; for( localIndex ic = 0; ic < NC; ++ic ) @@ -603,7 +615,7 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos { solver.resetStateToBeginningOfStep( domain ); - real64 const dRho = perturbParameter * wellElemTotalDensity; + real64 const dRho = perturbParameter * (wellElemTotalDensity+perturbParameter);; wellElemCompDens.move( hostMemorySpace, true ); wellElemCompDens[iwelem][jc] += dRho; @@ -642,10 +654,9 @@ void testWellNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compos } #endif } - +// Turn on/off the numerical jacobian computation of terms with respect to well connection rate. #if 1 - // b) compute all the derivatives wrt to the connection in WELL elem - // iwelem + for( localIndex iwelem = 0; iwelem < subRegion.size(); ++iwelem ) { { @@ -737,7 +748,7 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_FullS } ); } #endif - +// Enable test for full well system jacobian, which includes the coupling terms. #if 1 TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_System ) { @@ -768,9 +779,27 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Accum [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleAccumulationTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellAccumulationTerms( time, dt, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } +// Enable test for well pressure relation derivatives #if 1 TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_PressureRelation ) { @@ -783,10 +812,27 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Press [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assemblePressureRelations( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellPressureRelations( time, dt, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } #endif +// Enable test for well flux derivatives #if 1 TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Flux ) { @@ -799,7 +845,23 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Flux [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleFluxTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellFluxTerms( time, dt, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } #endif diff --git a/src/coreComponents/integrationTests/wellsTests/testThermalReservoirCompositionalMultiphaseMSWells.cpp b/src/coreComponents/integrationTests/wellsTests/testThermalReservoirCompositionalMultiphaseMSWells.cpp index 269b4e6fdeb..1ee3ad577c3 100644 --- a/src/coreComponents/integrationTests/wellsTests/testThermalReservoirCompositionalMultiphaseMSWells.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testThermalReservoirCompositionalMultiphaseMSWells.cpp @@ -96,28 +96,33 @@ char const * xmlInput = targetRegions="{ region }"> - - - + surfaceTemperature="300.15"> + + + + @@ -375,7 +380,7 @@ void testNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compositio LAMBDA && assembleFunction ) { GEOS_UNUSED_VAR( testName ); - CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); + WellManager & wellSolver = *solver.wellSolver(); CompositionalMultiphaseFVM & flowSolver = dynamicCast< CompositionalMultiphaseFVM & >( *solver.reservoirSolver() ); localIndex const NC = flowSolver.numFluidComponents(); @@ -587,7 +592,7 @@ void testNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compositio wellElemCompDens.move( hostMemorySpace, false ); arrayView1d< real64 > const & connRate = - subRegion.getField< fields::well::mixtureConnectionRate >(); + subRegion.getField< fields::well::connectionRate >(); connRate.move( hostMemorySpace, false ); // a) compute all the derivatives wrt to the pressure in WELL elem iwelem @@ -748,6 +753,24 @@ class CompositionalMultiphaseReservoirSolverTest : public ::testing::Test solver->getSystemSolution() ); solver->implicitStepSetup( time, dt, domain ); + + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.initializeWell( domain, domain.getMeshBodies(), meshBodyName, meshLevel, subRegion, time ); + } ); + } ); } static real64 constexpr time = 0.0; @@ -779,13 +802,11 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Perfo { solver->wellSolver()->assembleSystem( 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 ) @@ -799,7 +820,23 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Accum [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleAccumulationTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellAccumulationTerms( time, dt, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_PressureRel ) @@ -814,7 +851,23 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Press [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assemblePressureRelations( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellPressureRelations( time, dt, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } #endif diff --git a/src/coreComponents/integrationTests/wellsTests/testThermalReservoirCompositionalMultiphaseSSWells.cpp b/src/coreComponents/integrationTests/wellsTests/testThermalReservoirCompositionalMultiphaseSSWells.cpp index 76fa20d4cea..5caf701f77e 100644 --- a/src/coreComponents/integrationTests/wellsTests/testThermalReservoirCompositionalMultiphaseSSWells.cpp +++ b/src/coreComponents/integrationTests/wellsTests/testThermalReservoirCompositionalMultiphaseSSWells.cpp @@ -97,28 +97,33 @@ char const * xmlInput = targetRegions="{ region }"> - - - + surfaceTemperature="300.15"> + + + + @@ -329,7 +334,7 @@ void testNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compositio real64 const relTol, bool diag_check, LAMBDA && assembleFunction ) { - CompositionalMultiphaseWell & wellSolver = *solver.wellSolver(); + WellManager & wellSolver = *solver.wellSolver(); CompositionalMultiphaseFVM & flowSolver = dynamicCast< CompositionalMultiphaseFVM & >( *solver.reservoirSolver() ); localIndex const NC = flowSolver.numFluidComponents(); @@ -539,7 +544,7 @@ void testNumericalJacobian( CompositionalMultiphaseReservoirAndWells< Compositio wellElemCompDens.move( hostMemorySpace, false ); arrayView1d< real64 > const & connRate = - subRegion.getField< fields::well::mixtureConnectionRate >(); + subRegion.getField< fields::well::connectionRate >(); connRate.move( hostMemorySpace, false ); // a) compute all the derivatives wrt to the pressure in WELL elem iwelem @@ -688,6 +693,23 @@ class CompositionalMultiphaseReservoirSolverTest : public ::testing::Test solver->getSystemSolution() ); solver->implicitStepSetup( time, dt, domain ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.initializeWell( domain, domain.getMeshBodies(), meshBodyName, meshLevel, subRegion, time ); + } ); + } ); } static real64 constexpr time = 0.0; @@ -773,7 +795,23 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Accum [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assembleAccumulationTerms( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellAccumulationTerms( time, dt, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_PressureRel ) @@ -787,7 +825,23 @@ TEST_F( CompositionalMultiphaseReservoirSolverTest, jacobianNumericalCheck_Press [&] ( CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - solver->wellSolver()->assemblePressureRelations( time, dt, domain, solver->getDofManager(), localMatrix, localRhs ); + WellManager & wellSolver = *solver->wellSolver(); + wellSolver.forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = wellSolver.getWellControls( subRegion ); + wellControls.assembleWellPressureRelations( time, dt, subRegion, solver->getDofManager(), localMatrix, localRhs ); + } ); + } ); } ); } #endif diff --git a/src/coreComponents/linearAlgebra/utilities/ComponentMask.hpp b/src/coreComponents/linearAlgebra/utilities/ComponentMask.hpp index a27d1a37a64..42eab7c568e 100644 --- a/src/coreComponents/linearAlgebra/utilities/ComponentMask.hpp +++ b/src/coreComponents/linearAlgebra/utilities/ComponentMask.hpp @@ -92,10 +92,10 @@ class ComponentMask private: /// Number of bits in mask storage - static constexpr int NUM_BITS = internal::roundToNextPowerOfTwo( MAX_COMP ); + static constexpr int NUM_BITS = geos::internal::roundToNextPowerOfTwo( MAX_COMP ); /// Type used to represent the bit mask - using mask_t = typename internal::ComponentMaskType< NUM_BITS >::type; + using mask_t = typename geos::internal::ComponentMaskType< NUM_BITS >::type; public: diff --git a/src/coreComponents/physicsSolvers/SolverStatistics.hpp b/src/coreComponents/physicsSolvers/SolverStatistics.hpp index 334f1672c98..0cef5c39d20 100644 --- a/src/coreComponents/physicsSolvers/SolverStatistics.hpp +++ b/src/coreComponents/physicsSolvers/SolverStatistics.hpp @@ -184,6 +184,11 @@ class IterationsStatistics : public dataRepository::Group void closeFile() { if( m_CSVOutputOpened ) { m_logStream.close(); m_CSVOutputOpened = false; } } + /** + * @brief Get the number of time steps + */ + integer const & getNumTimeSteps() const { return m_numTimeSteps; } + protected: /// Number of time steps diff --git a/src/coreComponents/physicsSolvers/fluidFlow/CMakeLists.txt b/src/coreComponents/physicsSolvers/fluidFlow/CMakeLists.txt index 5df1a8ce699..6a134ee798e 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/CMakeLists.txt +++ b/src/coreComponents/physicsSolvers/fluidFlow/CMakeLists.txt @@ -136,11 +136,20 @@ set( fluidFlowSolvers_headers wells/SinglePhaseWellFields.hpp wells/WellConstants.hpp wells/WellControls.hpp - wells/WellSolverBase.hpp - wells/WellSolverBaseFields.hpp + wells/WellConstraintsBase.hpp + wells/WellInjectionConstraint.hpp + wells/WellProductionConstraint.hpp + wells/WellBHPConstraints.hpp + wells/WellVolumeRateConstraint.hpp + wells/WellMassRateConstraint.hpp + wells/WellPhaseVolumeRateConstraint.hpp + wells/WellManager.hpp + wells/WellNewtonSolver.hpp wells/LogLevelsInfo.hpp wells/kernels/SinglePhaseWellKernels.hpp wells/kernels/CompositionalMultiphaseWellKernels.hpp + wells/kernels/CompositionalMultiphaseWellConstraintKernels.hpp + wells/kernels/SinglePhaseWellConstraintKernels.hpp proppantTransport/ProppantTransport.hpp proppantTransport/ProppantTransportFields.hpp proppantTransport/ProppantTransportKernels.hpp ) @@ -176,7 +185,15 @@ set( fluidFlowSolvers_sources wells/SinglePhaseWell.cpp wells/kernels/SinglePhaseWellKernels.cpp wells/WellControls.cpp - wells/WellSolverBase.cpp + wells/WellConstraintsBase.cpp + wells/WellInjectionConstraint.cpp + wells/WellProductionConstraint.cpp + wells/WellBHPConstraints.cpp + wells/WellVolumeRateConstraint.cpp + wells/WellMassRateConstraint.cpp + wells/WellPhaseVolumeRateConstraint.cpp + wells/WellManager.cpp + wells/WellNewtonSolver.cpp proppantTransport/ProppantTransport.cpp proppantTransport/ProppantTransportKernels.cpp ) diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp index 6a72af7a90c..fa9f19b140a 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp @@ -18,7 +18,7 @@ */ #include "CompositionalMultiphaseWell.hpp" - +#include "physicsSolvers/PhysicsSolverManager.hpp" #include "LvArray/src/system.hpp" #include "codingUtilities/Utilities.hpp" #include "common/DataTypes.hpp" @@ -42,6 +42,14 @@ #include "physicsSolvers/fluidFlow/wells/WellFields.hpp" #include "physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWellFields.hpp" #include "physicsSolvers/fluidFlow/wells/WellControls.hpp" + +#include "physicsSolvers/fluidFlow/wells/WellInjectionConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellProductionConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellBHPConstraints.hpp" +#include "physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellMassRateConstraint.hpp" + #include "physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellKernels.hpp" #include "physicsSolvers/fluidFlow/wells/kernels/ThermalCompositionalMultiphaseWellKernels.hpp" #include "physicsSolvers/fluidFlow/wells/kernels/PerforationFluxKernels.hpp" @@ -55,6 +63,15 @@ #include "physicsSolvers/fluidFlow/kernels/compositional/FluidUpdateKernel.hpp" #include "physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsAggregator.hpp" +#include "physicsSolvers/fluidFlow/wells/WellBHPConstraints.hpp" + +#include "physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellMassRateConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellConstraintKernels.hpp" +#include "physicsSolvers/multiphysics/CoupledReservoirAndWellKernels.hpp" + + #if defined( __INTEL_COMPILER ) #pragma GCC optimize "O0" #endif @@ -69,34 +86,61 @@ using namespace compositionalMultiphaseStatistics; CompositionalMultiphaseBase & getFlowSolver( CompositionalMultiphaseWell & wellSolver ) { - // TODO: change the way we access the flowSolver here - return wellSolver.getParent().getGroup< CompositionalMultiphaseBase >( wellSolver.getFlowSolverName() ); + return wellSolver.getParent().getParent().getGroup< CompositionalMultiphaseBase >( wellSolver.getFlowSolverName() ); } CompositionalMultiphaseBase const & getFlowSolver( CompositionalMultiphaseWell const & wellSolver ) { - // TODO: change the way we access the flowSolver here - return wellSolver.getParent().getGroup< CompositionalMultiphaseBase >( wellSolver.getFlowSolverName() ); + return wellSolver.getParent().getParent().getGroup< CompositionalMultiphaseBase >( wellSolver.getFlowSolverName() ); +} + +real64 getBHPReferenceGravityCoef( CompositionalMultiphaseWell const & wellSolver, + ConstraintSourceId const source ) +{ + real64 refGravCoef = 0.0; + bool foundConstraint = false; + + if( wellSolver.isProducer() ) + { + wellSolver.forSubGroups< MinimumBHPConstraint >( [&]( WellConstraintBase const & constraint ) + { + if( constraint.isConstraintActive() && constraint.getConstraintSource() == source ) + { + refGravCoef = static_cast< MinimumBHPConstraint const & >( constraint ).getReferenceGravityCoef(); + foundConstraint = true; + } + } ); + } + else + { + wellSolver.forSubGroups< MaximumBHPConstraint >( [&]( WellConstraintBase const & constraint ) + { + if( constraint.isConstraintActive() && constraint.getConstraintSource() == source ) + { + refGravCoef = static_cast< MaximumBHPConstraint const & >( constraint ).getReferenceGravityCoef(); + foundConstraint = true; + } + } ); + } + + GEOS_THROW_IF( !foundConstraint, + GEOS_FMT( "Could not find active BHP constraint for well {}", wellSolver.getName() ), + InputError ); + + return refGravCoef; } CompositionalMultiphaseWell::CompositionalMultiphaseWell( const string & name, Group * const parent ) : - WellSolverBase( name, parent ), - m_useMass( false ), + WellControls( name, parent ), m_useTotalMassEquation( 1 ), m_maxCompFracChange( 1.0 ), m_maxRelativePresChange( 0.2 ), m_maxAbsolutePresChange( -1 ), // disabled by default m_minScalingFactor( 0.01 ), - m_allowCompDensChopping( 1 ), - m_targetPhaseIndex( -1 ) + m_allowCompDensChopping( 1 ) { - this->registerWrapper( viewKeyStruct::useMassFlagString(), &m_useMass ). - setApplyDefaultValue( 0 ). - setInputFlag( InputFlags::OPTIONAL ). - setDescription( "Use mass formulation instead of molar" ); - this->registerWrapper( viewKeyStruct::useTotalMassEquationString(), &m_useTotalMassEquation ). setApplyDefaultValue( 1 ). setInputFlag( InputFlags::OPTIONAL ). @@ -139,9 +183,17 @@ CompositionalMultiphaseWell::CompositionalMultiphaseWell( const string & name, setDescription( "Flag indicating whether local (cell-wise) chopping of negative compositions is allowed" ); } +CompositionalMultiphaseWell::~CompositionalMultiphaseWell() = default; + +void CompositionalMultiphaseWell::setReservoirStatsAggregator( + std::unique_ptr< compositionalMultiphaseStatistics::StatsAggregator > aggregator ) +{ + m_reservoirStatsAggregator = std::move( aggregator ); +} + void CompositionalMultiphaseWell::postInputInitialization() { - WellSolverBase::postInputInitialization(); + WellControls::postInputInitialization(); GEOS_ERROR_IF_GT_MSG( m_maxCompFracChange, 1.0, "The maximum absolute change in component fraction must smaller or equal to 1.0", @@ -153,29 +205,24 @@ void CompositionalMultiphaseWell::postInputInitialization() GEOS_ERROR_IF_LE_MSG( m_maxRelativeCompDensChange, 0.0, "The maximum relative change in component density must be larger than 0.0", getWrapperDataContext( viewKeyStruct::maxRelativeCompDensChangeString() ) ); + +} +void CompositionalMultiphaseWell::setConstitutiveNames( ElementSubRegionBase & subRegion ) const +{ + setConstitutiveName< MultiFluidBase >( subRegion, viewKeyStruct::fluidNamesString(), "multiphase fluid" ); } -void CompositionalMultiphaseWell::registerDataOnMesh( Group & meshBodies ) +void CompositionalMultiphaseWell::registerWellDataOnMesh( WellElementSubRegion & subRegion ) { - WellSolverBase::registerDataOnMesh( meshBodies ); + DomainPartition const & domain = this->getGroupByPath< DomainPartition >( "/Problem/domain" ); ConstitutiveManager const & cm = domain.getConstitutiveManager(); - - forDiscretizationOnMeshTargets( meshBodies, [&]( string const &, - MeshLevel & mesh, - string_array const & regionNames ) + setConstitutiveNames ( subRegion ); + if( m_referenceFluidModelName.empty() ) { - mesh.getElemManager().forElementSubRegions( regionNames, - [&]( localIndex const, - ElementSubRegionBase & subRegion ) - { - if( m_referenceFluidModelName.empty() ) - { - m_referenceFluidModelName = getConstitutiveName< MultiFluidBase >( subRegion ); - } - } ); - } ); + m_referenceFluidModelName = getConstitutiveName< MultiFluidBase >( subRegion ); + } // 1. Set key dimensions of the problem // Empty check needed to avoid errors when running in schema generation mode. @@ -190,131 +237,119 @@ void CompositionalMultiphaseWell::registerDataOnMesh( Group & meshBodies ) // 1 pressure + NC compositions + temp if thermal m_numDofPerResElement = isThermal() ? m_numComponents + 2 : m_numComponents + 1; - // loop over the wells - forDiscretizationOnMeshTargets( meshBodies, [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) + + WellControls::registerWellDataOnMesh( subRegion ); + + + + string const & fluidName = getConstitutiveName< MultiFluidBase >( subRegion ); + MultiFluidBase const & fluid = subRegion.getConstitutiveModel< MultiFluidBase >( fluidName ); + + // The resizing of the arrays needs to happen here, before the call to initializePreSubGroups, + // to make sure that the dimensions are properly set before the timeHistoryOutput starts its initialization. + subRegion.registerField< well::pressure >( getName() ); + subRegion.registerField< well::pressure_n >( getName() ); + + subRegion.registerField< well::temperature >( getName() ); + if( isThermal() ) { + subRegion.registerField< well::temperature_n >( getName() ); + } - ElementRegionManager & elemManager = mesh.getElemManager(); + subRegion.registerField< well::gravityCoefficient >( getName() ); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion & subRegion ) - { - string const & fluidName = getConstitutiveName< MultiFluidBase >( subRegion ); - MultiFluidBase const & fluid = subRegion.getConstitutiveModel< MultiFluidBase >( fluidName ); - - // The resizing of the arrays needs to happen here, before the call to initializePreSubGroups, - // to make sure that the dimensions are properly set before the timeHistoryOutput starts its initialization. - - subRegion.registerField< well::globalCompDensity >( getName() ). - reference().resizeDimension< 1 >( m_numComponents ); - subRegion.registerField< well::globalCompDensity_n >( getName() ). - reference().resizeDimension< 1 >( m_numComponents ); - - subRegion.registerField< well::mixtureConnectionRate >( getName() ); - subRegion.registerField< well::mixtureConnectionRate_n >( getName() ); - - subRegion.registerField< well::globalCompFraction >( getName() ). - setDimLabels( 1, fluid.componentNames() ). - reference().resizeDimension< 1 >( m_numComponents ); - subRegion.registerField< well::dGlobalCompFraction_dGlobalCompDensity >( getName() ). - reference().resizeDimension< 1, 2 >( m_numComponents, m_numComponents ); - - subRegion.registerField< well::phaseVolumeFraction >( getName() ). - setDimLabels( 1, fluid.phaseNames() ). - reference().resizeDimension< 1 >( m_numPhases ); - subRegion.registerField< well::dPhaseVolumeFraction >( getName() ). - reference().resizeDimension< 1, 2 >( m_numPhases, m_numComponents + 2 ); // dP, dT, dC - - subRegion.registerField< well::totalMassDensity >( getName() ); - subRegion.registerField< well::dTotalMassDensity >( getName() ). - reference().resizeDimension< 1 >( m_numComponents +2 ); // dP, dT, dC - - subRegion.registerField< well::phaseVolumeFraction_n >( getName() ). - reference().resizeDimension< 1 >( m_numPhases ); - - subRegion.registerField< well::pressureScalingFactor >( getName() ); - subRegion.registerField< well::temperatureScalingFactor >( getName() ); - subRegion.registerField< well::globalCompDensityScalingFactor >( getName() ); - - PerforationData & perforationData = *subRegion.getPerforationData(); - perforationData.registerField< well::compPerforationRate >( getName() ). - reference().resizeDimension< 1 >( m_numComponents ); - - perforationData.registerField< well::dCompPerforationRate >( getName() ). - reference().resizeDimension< 1, 2, 3 >( 2, m_numComponents, m_numComponents+ 2 ); - if( fluid.isThermal() ) - { - perforationData.registerField< well::energyPerforationFlux >( getName() ); - perforationData.registerField< well::dEnergyPerforationFlux >( getName() ). - reference().resizeDimension< 1, 2 >( 2, m_numComponents+2 ); - } + subRegion.registerField< well::globalCompDensity >( getName() ). + reference().resizeDimension< 1 >( m_numComponents ); + subRegion.registerField< well::globalCompDensity_n >( getName() ). + reference().resizeDimension< 1 >( m_numComponents ); - WellControls & wellControls = getWellControls( subRegion ); - wellControls.registerWrapper< real64 >( viewKeyStruct::currentBHPString() ); + subRegion.registerField< well::connectionRate >( getName() ); + subRegion.registerField< well::connectionRate_n >( getName() ); - wellControls.registerWrapper< array1d< real64 > >( viewKeyStruct::dCurrentBHPString() ). - setSizedFromParent( 0 ). - reference().resizeDimension< 0 >( m_numComponents + 2 ); // dP, dT, dC + subRegion.registerField< well::globalCompFraction >( getName() ). + setDimLabels( 1, fluid.componentNames() ). + reference().resizeDimension< 1 >( m_numComponents ); + subRegion.registerField< well::dGlobalCompFraction_dGlobalCompDensity >( getName() ). + reference().resizeDimension< 1, 2 >( m_numComponents, m_numComponents ); - wellControls.registerWrapper< array1d< real64 > >( viewKeyStruct::currentPhaseVolRateString() ). - setSizedFromParent( 0 ). - reference().resizeDimension< 0 >( m_numPhases ); + subRegion.registerField< well::phaseVolumeFraction >( getName() ). + setDimLabels( 1, fluid.phaseNames() ). + reference().resizeDimension< 1 >( m_numPhases ); + subRegion.registerField< well::dPhaseVolumeFraction >( getName() ). + reference().resizeDimension< 1, 2 >( m_numPhases, m_numComponents + 2 ); // dP, dT, dC - wellControls.registerWrapper< array2d< real64 > >( viewKeyStruct::dCurrentPhaseVolRateString() ). - setSizedFromParent( 0 ). - reference().resizeDimension< 0, 1 >( m_numPhases, m_numComponents + 3 ); // dP, dT, dC, dQ + subRegion.registerField< well::totalMassDensity >( getName() ); + subRegion.registerField< well::dTotalMassDensity >( getName() ). + reference().resizeDimension< 1 >( m_numComponents +2 ); // dP, dT, dC - wellControls.registerWrapper< real64 >( viewKeyStruct::massDensityString() ); + subRegion.registerField< well::phaseVolumeFraction_n >( getName() ). + reference().resizeDimension< 1 >( m_numPhases ); - wellControls.registerWrapper< real64 >( viewKeyStruct::currentTotalVolRateString() ); - wellControls.registerWrapper< array1d< real64 > >( viewKeyStruct::dCurrentTotalVolRateString() ). - setSizedFromParent( 0 ). - reference().resizeDimension< 0 >( m_numComponents + 3 ); // dP, dT, dC dQ + subRegion.registerField< well::pressureScalingFactor >( getName() ); + subRegion.registerField< well::temperatureScalingFactor >( getName() ); + subRegion.registerField< well::globalCompDensityScalingFactor >( getName() ); - wellControls.registerWrapper< real64 >( viewKeyStruct::massDensityString() ); + PerforationData & perforationData = *subRegion.getPerforationData(); - wellControls.registerWrapper< real64 >( viewKeyStruct::currentMassRateString() ); + perforationData.registerField< well::gravityCoefficient >( getName() ); + perforationData.registerField< well::compPerforationRate >( getName() ). + reference().resizeDimension< 1 >( m_numComponents ); - // write rates output header - // the rank that owns the reference well element is responsible - if( m_writeCSV > 0 && subRegion.isLocallyOwned() ) - { - string const fileName = GEOS_FMT( "{}/{}.csv", m_ratesOutputDir, wellControls.getName() ); - string const massUnit = m_useMass ? "kg" : "mol"; - integer const useSurfaceConditions = wellControls.useSurfaceConditions(); - string const conditionKey = useSurfaceConditions ? "surface" : "reservoir"; - string const unitKey = useSurfaceConditions ? "s" : "r"; - integer const numPhase = m_numPhases; - integer const numComp = m_numComponents; - // format: time,bhp,total_rate,total_vol_rate,phase0_vol_rate,phase1_vol_rate,... - makeDirsForPath( m_ratesOutputDir ); - GEOS_LOG( GEOS_FMT( "{}: Rates CSV generated at {}", getName(), fileName ) ); - std::ofstream outputFile( fileName ); - outputFile << "Time [s],dt[s],BHP [Pa],Total rate [" << massUnit << "/s],Total " << conditionKey << " volumetric rate [" << unitKey << "m3/s]"; - for( integer ip = 0; ip < numPhase; ++ip ) - { - outputFile << ",Phase" << ip << " " << conditionKey << " volumetric rate [" << unitKey << "m3/s]"; - } - for( integer ic = 0; ic < numComp; ++ic ) - { - outputFile << ",Component" << ic << " rate [" << massUnit << "/s]"; - } - outputFile << std::endl; - outputFile.close(); - } - } ); - } ); + perforationData.registerField< well::dCompPerforationRate >( getName() ). + reference().resizeDimension< 1, 2, 3 >( 2, m_numComponents, m_numComponents+ 2 ); + if( fluid.isThermal() ) + { + perforationData.registerField< well::energyPerforationFlux >( getName() ); + perforationData.registerField< well::dEnergyPerforationFlux >( getName() ). + reference().resizeDimension< 1, 2 >( 2, m_numComponents+2 ); + } + + registerWrapper< real64 >( viewKeyStruct::currentBHPString() ); + + registerWrapper< array1d< real64 > >( viewKeyStruct::currentPhaseVolRateString() ). + setSizedFromParent( 0 ). + reference().resizeDimension< 0 >( m_numPhases ); + + registerWrapper< real64 >( viewKeyStruct::massDensityString() ); + + registerWrapper< real64 >( viewKeyStruct::currentTotalVolRateString() ); + + registerWrapper< real64 >( viewKeyStruct::massDensityString() ); + + registerWrapper< real64 >( viewKeyStruct::currentMassRateString() ); + + // write rates output header + // the rank that owns the reference well element is responsible + if( m_writeCSV > 0 && subRegion.isLocallyOwned() ) + { + string const fileName = GEOS_FMT( "{}/{}.csv", m_ratesOutputDir, getName() ); + string const massUnit = m_useMass ? "kg" : "mol"; + integer const useSurfaceConditions = this->useSurfaceConditions(); + string const conditionKey = useSurfaceConditions ? "surface" : "reservoir"; + string const unitKey = useSurfaceConditions ? "s" : "r"; + integer const numPhase = m_numPhases; + integer const numComp = m_numComponents; + // format: time,bhp,total_rate,total_vol_rate,phase0_vol_rate,phase1_vol_rate,... + makeDirsForPath( m_ratesOutputDir ); + GEOS_LOG( GEOS_FMT( "{}: Rates CSV generated at {}", getName(), fileName ) ); + std::ofstream outputFile( fileName ); + outputFile << "Time [s],dt[s],BHP [Pa],Total rate [" << massUnit << "/s],Total " << conditionKey << " volumetric rate [" << unitKey << "m3/s]"; + for( integer ip = 0; ip < numPhase; ++ip ) + { + outputFile << ",Phase" << ip << " " << conditionKey << " volumetric rate [" << unitKey << "m3/s]"; + } + for( integer ic = 0; ic < numComp; ++ic ) + { + outputFile << ",Component" << ic << " rate [" << massUnit << "/s]"; + } + outputFile << std::endl; + outputFile.close(); + } -} -void CompositionalMultiphaseWell::setConstitutiveNames( ElementSubRegionBase & subRegion ) const -{ - setConstitutiveName< MultiFluidBase >( subRegion, viewKeyStruct::fluidNamesString(), "multiphase fluid" ); } + namespace { @@ -358,15 +393,17 @@ void compareMulticomponentModels( MODEL1_TYPE const & lhs, MODEL2_TYPE const & r * @brief Checks if the WellControls parameters are within the fluid tables ranges * @param fluid the fluid to check */ -void CompositionalMultiphaseWell::validateWellControlsForFluid( WellControls const & wellControls, - MultiFluidBase const & fluid ) const +void CompositionalMultiphaseWell::validateFluidModel( + constitutive::MultiFluidBase const & fluid, constitutive::MultiFluidBase const & referenceFluid ) const { - if( wellControls.useSurfaceConditions() ) + compareMultiphaseModels( fluid, referenceFluid ); + compareMulticomponentModels( fluid, referenceFluid ); + if( useSurfaceConditions() ) { try { - real64 const & surfaceTemp = wellControls.getSurfaceTemperature(); - real64 const & surfacePres = wellControls.getSurfacePressure(); + real64 const & surfaceTemp = getSurfaceTemperature(); + real64 const & surfacePres = getSurfacePressure(); fluid.checkTablesParameters( surfacePres, surfaceTemp ); } catch( SimulationError const & ex ) { @@ -379,85 +416,23 @@ void CompositionalMultiphaseWell::validateWellControlsForFluid( WellControls con } } -void CompositionalMultiphaseWell::validateConstitutiveModels( DomainPartition const & domain ) const -{ - GEOS_MARK_FUNCTION; - - ConstitutiveManager const & cm = domain.getConstitutiveManager(); - CompositionalMultiphaseBase const & flowSolver = getFlowSolver( *this ); - string const referenceFluidName = flowSolver.referenceFluidModelName(); - MultiFluidBase const & referenceFluid = cm.getConstitutiveRelation< MultiFluidBase >( m_referenceFluidModelName ); - - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const &, - MeshLevel const & mesh, - string_array const & regionNames ) - { - - mesh.getElemManager().forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, - WellElementSubRegion const & subRegion ) - { - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - MultiFluidBase const & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); - compareMultiphaseModels( fluid, referenceFluid ); - compareMulticomponentModels( fluid, referenceFluid ); - - WellControls const & wellControls = getWellControls( subRegion ); - validateWellControlsForFluid( wellControls, fluid ); - } ); - - } ); -} - -void CompositionalMultiphaseWell::validateInjectionStreams( WellElementSubRegion const & subRegion ) const -{ - WellControls const & wellControls = getWellControls( subRegion ); - - // check well injection stream for injectors - if( wellControls.isInjector()) - { - arrayView1d< real64 const > const & injectionStream = wellControls.getInjectionStream(); - - integer const streamSize = injectionStream.size(); - GEOS_THROW_IF( ( streamSize == 0 ), - "Injection stream not specified for well ", - InputError, wellControls.getDataContext() ); - GEOS_THROW_IF( ( streamSize != m_numComponents ), - GEOS_FMT( "Injection stream for well should have {} components.", - m_numComponents ), - InputError, wellControls.getDataContext() ); - - real64 compFracSum = 0; - for( integer ic = 0; ic < m_numComponents; ++ic ) - { - real64 const compFrac = injectionStream[ic]; - GEOS_THROW_IF( ( compFrac < 0.0 ) || ( compFrac > 1.0 ), - "Invalid injection stream for well ", - InputError, wellControls.getDataContext() ); - compFracSum += compFrac; - } - GEOS_THROW_IF( ( compFracSum < 1.0 - std::numeric_limits< real64 >::epsilon() ) || - ( compFracSum > 1.0 + std::numeric_limits< real64 >::epsilon() ), - "Invalid injection stream for well ", - InputError, wellControls.getDataContext() ); - } -} void CompositionalMultiphaseWell::validateWellConstraints( real64 const & time_n, real64 const & GEOS_UNUSED_PARAM( dt ), WellElementSubRegion const & subRegion ) { - WellControls & wellControls = getWellControls( subRegion ); + GEOS_UNUSED_VAR( time_n ); - if( !wellControls.useSurfaceConditions() ) + if( !useSurfaceConditions() ) { - bool const useSegmentValues = wellControls.referenceReservoirRegion().empty(); + bool const useSegmentValues = referenceReservoirRegion().empty(); static bool firstNoRefRegionMsg = true; if( useSegmentValues && firstNoRefRegionMsg ) { GEOS_WARNING( WellControls::viewKeyStruct::referenceReservoirRegionString() << " not set: well constraint fluid property calculations will use top segement pressure and temp ", - wellControls.getDataContext() ); + getDataContext() ); firstNoRefRegionMsg = false; } } @@ -465,125 +440,56 @@ void CompositionalMultiphaseWell::validateWellConstraints( real64 const & time_n string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString()); MultiFluidBase const & fluid = subRegion.getConstitutiveModel< MultiFluidBase >( fluidName ); - WellControls::Control const currentControl = wellControls.getControl(); - real64 const & targetTotalRate = wellControls.getTargetTotalRate( time_n ); - real64 const & targetPhaseRate = wellControls.getTargetPhaseRate( time_n ); - real64 const & targetMassRate = wellControls.getTargetMassRate( time_n ); - - GEOS_THROW_IF( wellControls.isInjector() && currentControl == WellControls::Control::PHASEVOLRATE, - "Phase rate control is not available for injectors", - InputError, wellControls.getDataContext() ); - GEOS_THROW_IF( wellControls.isProducer() && currentControl == WellControls::Control::TOTALVOLRATE, - "Total rate control is not available for producers", - InputError, wellControls.getDataContext() ); - - GEOS_THROW_IF( wellControls.isInjector() && targetTotalRate < 0.0, - "Target total rate cannot be negative for injectors", - InputError, wellControls.getDataContext() ); - GEOS_THROW_IF( wellControls.isInjector() && !isZero( targetPhaseRate ), - "Target phase rate cannot be used for injectors", - InputError, wellControls.getDataContext() ); - GEOS_THROW_IF( wellControls.isProducer() && !isZero( targetTotalRate ), - "Target total rate cannot be used for producers", - InputError, wellControls.getDataContext() ); - GEOS_THROW_IF( wellControls.isProducer() && !isZero( targetMassRate ), - "Target mass rate cannot be used for producers", - InputError, wellControls.getDataContext() ); - GEOS_THROW_IF( !m_useMass && !isZero( targetMassRate ), - "Target mass rate cannot with useMass=0", - InputError, wellControls.getDataContext() ); - - // The user always provides positive rates, but these rates are later multiplied by -1 internally for producers - GEOS_THROW_IF( wellControls.isProducer() && targetPhaseRate > 0.0, - "Target phase rate cannot be negative for producers", - InputError, wellControls.getDataContext() ); - GEOS_THROW_IF( wellControls.isProducer() && !isZero( targetTotalRate ), - "Target total rate cannot be used for producers", - InputError, wellControls.getDataContext() ); - - // Find target phase index for phase rate constraint - for( integer ip = 0; ip < fluid.numFluidPhases(); ++ip ) - { - if( fluid.phaseNames()[ip] == wellControls.getTargetPhaseName() ) - { - m_targetPhaseIndex = ip; - } - } - GEOS_THROW_IF( wellControls.isProducer() && m_targetPhaseIndex == -1, - GEOS_FMT( "Phase {} not found", wellControls.getTargetPhaseName() ), - InputError, wellControls.getDataContext() ); + forSubGroups< InjectionConstraint< PhaseVolumeRateConstraint >, ProductionConstraint< PhaseVolumeRateConstraint > >( [&]( auto & constraint ) + { + constraint.validatePhaseType( fluid ); + } ); } void CompositionalMultiphaseWell::initializePostSubGroups() { - WellSolverBase::initializePostSubGroups(); - - DomainPartition & domain = this->getGroupByPath< DomainPartition >( "/Problem/domain" ); - - validateConstitutiveModels( domain ); - - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { - mesh.getElemManager().forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, - WellElementSubRegion & subRegion ) - { - validateInjectionStreams( subRegion ); - } ); - } ); + WellControls::initializePostSubGroups(); } void CompositionalMultiphaseWell::initializePostInitialConditionsPreSubGroups() { - WellSolverBase::initializePostInitialConditionsPreSubGroups(); - createSeparator(); + WellControls::initializePostInitialConditionsPreSubGroups(); } -void CompositionalMultiphaseWell::postRestartInitialization() +void CompositionalMultiphaseWell::initializeWellPostInitialConditionsPreSubGroups( WellElementSubRegion & subRegion ) { - DomainPartition & domain = this->getGroupByPath< DomainPartition >( "/Problem/domain" ); - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { - // loop over the wells - mesh.getElemManager().forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, - WellElementSubRegion & subRegion ) - { - // setup fluid separator - WellControls & wellControls = getWellControls( subRegion ); - constitutive::MultiFluidBase & fluidSeparator = wellControls.getMultiFluidSeparator(); - fluidSeparator.allocateConstitutiveData( wellControls, 1 ); - fluidSeparator.resize( 1 ); - } ); - } ); + // set gravity coefficient + setGravCoef( subRegion, getParent().getParent().getReference< R1Tensor >( PhysicsSolverManager::viewKeyStruct::gravityVectorString() )); + + // setup fluid model + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + constitutive::MultiFluidBase & fluid = subRegion.getConstitutiveModel< constitutive::MultiFluidBase >( fluidName ); + fluid.setMassFlag( m_useMass ); + createSeparator( subRegion ); +} +void CompositionalMultiphaseWell::postRestartInitialization( ) +{ + + // setup fluid separator + constitutive::MultiFluidBase & fluidSeparator = getMultiFluidSeparator(); + fluidSeparator.allocateConstitutiveData( *this, 1 ); + fluidSeparator.resize( 1 ); + } -void CompositionalMultiphaseWell::createSeparator() +void CompositionalMultiphaseWell::createSeparator( WellElementSubRegion & subRegion ) { - DomainPartition & domain = this->getGroupByPath< DomainPartition >( "/Problem/domain" ); - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { - // loop over the wells - mesh.getElemManager().forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, - WellElementSubRegion & subRegion ) - { - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - MultiFluidBase & fluid = subRegion.getConstitutiveModel< MultiFluidBase >( fluidName ); - fluid.setMassFlag( m_useMass ); - // setup fluid separator - WellControls & wellControls = getWellControls( subRegion ); - string const fluidSeparatorName = wellControls.getName() + "Separator"; - std::unique_ptr< constitutive::ConstitutiveBase > fluidSeparatorPtr = fluid.deliverClone( fluidSeparatorName, &wellControls ); - fluidSeparatorPtr->allocateConstitutiveData( wellControls, 1 ); - fluidSeparatorPtr->resize( 1 ); - wellControls.setFluidSeparator( std::move( fluidSeparatorPtr )); - } ); - } ); + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + MultiFluidBase & fluid = subRegion.getConstitutiveModel< MultiFluidBase >( fluidName ); + fluid.setMassFlag( m_useMass ); + // setup fluid separator + string const fluidSeparatorName = getName() + "Separator"; + std::unique_ptr< constitutive::ConstitutiveBase > fluidSeparatorPtr = fluid.deliverClone( fluidSeparatorName, this ); + fluidSeparatorPtr->allocateConstitutiveData( *this, 1 ); + fluidSeparatorPtr->resize( 1 ); + setFluidSeparator( std::move( fluidSeparatorPtr )); + } void CompositionalMultiphaseWell::updateGlobalComponentFraction( WellElementSubRegion & subRegion ) const { @@ -605,63 +511,34 @@ void CompositionalMultiphaseWell::updateBHPForConstraint( WellElementSubRegion & { return; } - using Deriv = constitutive::multifluid::DerivativeOffset; - integer const numComp = m_numComponents; localIndex const iwelemRef = subRegion.getTopWellElementIndex(); - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - MultiFluidBase const & fluid = subRegion.getConstitutiveModel< MultiFluidBase >( fluidName ); - integer const isThermal = fluid.isThermal(); // subRegion data - arrayView1d< real64 const > const & pres = subRegion.getField< well::pressure >(); - arrayView1d< real64 > const & totalMassDens = subRegion.getField< well::totalMassDensity >(); - arrayView2d< real64, compflow::USD_FLUID_DC > const & dTotalMassDens = subRegion.getField< well::dTotalMassDensity >(); - arrayView1d< real64 const > const wellElemGravCoef = subRegion.getField< well::gravityCoefficient >(); // control data - WellControls & wellControls = getWellControls( subRegion ); - string const wellControlsName = wellControls.getName(); - real64 const & refGravCoef = wellControls.getReferenceGravityCoef(); + string const wellControlsName = getName(); + real64 const refGravCoef = getBHPReferenceGravityCoef( *this, ConstraintSourceId::USER ); real64 & currentBHP = - wellControls.getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentBHPString() ); - arrayView1d< real64 > const & dCurrentBHP = - wellControls.getReference< array1d< real64 > >( CompositionalMultiphaseWell::viewKeyStruct::dCurrentBHPString() ); - - geos::internal::kernelLaunchSelectorCompThermSwitch( numComp, isThermal, [&] ( auto NC, auto ISTHERMAL ) + getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentBHPString() ); + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [ pres, + totalMassDens, + wellElemGravCoef, + ¤tBHP, + &iwelemRef, + &refGravCoef] ( localIndex const ) { - integer constexpr IS_THERMAL = ISTHERMAL(); - GEOS_UNUSED_VAR( NC ); - // bring everything back to host, capture the scalars by reference - forAll< serialPolicy >( 1, [&numComp, - pres, - totalMassDens, - dTotalMassDens, - wellElemGravCoef, - ¤tBHP, - &dCurrentBHP, - &iwelemRef, - &refGravCoef] ( localIndex const ) - { - real64 const diffGravCoef = refGravCoef - wellElemGravCoef[iwelemRef]; - currentBHP = pres[iwelemRef] + totalMassDens[iwelemRef] * diffGravCoef; - dCurrentBHP[Deriv::dP] = 1 + dTotalMassDens[iwelemRef][Deriv::dP] * diffGravCoef; - for( integer ic = 0; ic < numComp; ++ic ) - { - dCurrentBHP[Deriv::dC+ic] = dTotalMassDens[iwelemRef][Deriv::dC+ic] * diffGravCoef; - } - if constexpr ( IS_THERMAL ) - { - dCurrentBHP[Deriv::dT] = dTotalMassDens[iwelemRef][Deriv::dT] * diffGravCoef; - } - } ); + real64 const diffGravCoef = refGravCoef - wellElemGravCoef[iwelemRef]; + currentBHP = pres[iwelemRef] + totalMassDens[iwelemRef] * diffGravCoef; } ); + GEOS_LOG_LEVEL_BY_RANK( logInfo::BoundaryConditions, GEOS_FMT( "{}: BHP (at the specified reference elevation) = {} Pa", wellControlsName, currentBHP ) ); @@ -678,195 +555,197 @@ void CompositionalMultiphaseWell::updateVolRatesForConstraint( WellElementSubReg return; } - integer constexpr maxNumComp = constitutive::MultiFluidBase::MAX_NUM_COMPONENTS; - integer const numComp = m_numComponents; integer const numPhase = m_numPhases; localIndex const iwelemRef = subRegion.getTopWellElementIndex(); - WellControls & wellControls = getWellControls( subRegion ); - // subRegion data - arrayView1d< real64 const > const & connRate = subRegion.getField< well::mixtureConnectionRate >(); - arrayView2d< real64 const, compflow::USD_COMP > const & compFrac = subRegion.getField< well::globalCompFraction >(); - arrayView3d< real64 const, compflow::USD_COMP_DC > const & dCompFrac_dCompDens = subRegion.getField< well::dGlobalCompFraction_dGlobalCompDensity >(); + arrayView1d< real64 const > const & connRate = subRegion.getField< well::connectionRate >(); // fluid data - constitutive::MultiFluidBase & fluidSeparator = wellControls.getMultiFluidSeparator(); - integer isThermal = fluidSeparator.isThermal(); - arrayView3d< real64 const, constitutive::multifluid::USD_PHASE > const & phaseFrac = fluidSeparator.phaseFraction(); - arrayView4d< real64 const, constitutive::multifluid::USD_PHASE_DC > const & dPhaseFrac = fluidSeparator.dPhaseFraction(); + constitutive::MultiFluidBase & fluidSeparator = getMultiFluidSeparator(); + arrayView3d< real64 const, constitutive::multifluid::USD_PHASE > const & phaseFrac = fluidSeparator.phaseFraction(); arrayView2d< real64 const, constitutive::multifluid::USD_FLUID > const & totalDens = fluidSeparator.totalDensity(); - arrayView3d< real64 const, constitutive::multifluid::USD_FLUID_DC > const & dTotalDens = fluidSeparator.dTotalDensity(); - arrayView3d< real64 const, constitutive::multifluid::USD_PHASE > const & phaseDens = fluidSeparator.phaseDensity(); - arrayView4d< real64 const, constitutive::multifluid::USD_PHASE_DC > const & dPhaseDens = fluidSeparator.dPhaseDensity(); // control data - string const wellControlsName = wellControls.getName(); - bool const logSurfaceCondition = isLogLevelActive< logInfo::BoundaryConditions >( wellControls.getLogLevel()); - string const massUnit = m_useMass ? "kg" : "mol"; + string const wellControlsName = getName(); + integer const useMassCond = useMass(); + arrayView1d< real64 > const & currentPhaseVolRate = + getReference< array1d< real64 > >( viewKeyStruct::currentPhaseVolRateString() ); + + real64 & currentTotalVolRate = + getReference< real64 >( viewKeyStruct::currentTotalVolRateString() ); + + real64 & currentMassRate = + getReference< real64 >( viewKeyStruct::currentMassRateString() ); + + real64 & massDensity = + getReference< real64 >( viewKeyStruct::massDensityString() ); + + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [&numPhase, + connRate, + totalDens, + phaseDens, + phaseFrac, + &useMassCond, + ¤tTotalVolRate, + currentPhaseVolRate, + ¤tMassRate, + &iwelemRef, + &massDensity] ( localIndex const ) + { + // Step 1: update the total volume rate + + real64 const currentTotalRate = connRate[iwelemRef]; + if( useMassCond ) + currentMassRate = currentTotalRate; + // Step 1.1: compute the inverse of the total density and derivatives + massDensity = totalDens[iwelemRef][0]; + real64 const totalDensInv = 1.0 / totalDens[iwelemRef][0]; + + // Step 1.2: divide the total mass/molar rate by the total density to get the total volumetric rate + currentTotalVolRate = currentTotalRate * totalDensInv; + + // Step 2: update the phase volume rate + for( integer ip = 0; ip < numPhase; ++ip ) + { + // Step 2.1: compute the inverse of the (phase density * phase fraction) and derivatives + + // skip the rest of this function if phase ip is absent + bool const phaseExists = (phaseFrac[iwelemRef][0][ip] > 0); + if( !phaseExists ) + { + continue; + } + + real64 const phaseDensInv = 1.0 / phaseDens[iwelemRef][0][ip]; + real64 const phaseFracTimesPhaseDensInv = phaseFrac[iwelemRef][0][ip] * phaseDensInv; + + // Step 2.2: divide the total mass/molar rate by the (phase density * phase fraction) to get the phase volumetric rate + currentPhaseVolRate[ip] = currentTotalRate * phaseFracTimesPhaseDensInv; + } + } ); + +} + +void CompositionalMultiphaseWell::calculateReferenceElementRates( WellElementSubRegion & subRegion ) +{ + GEOS_MARK_FUNCTION; + + // the rank that owns the reference well element is responsible for the calculations below. + if( !subRegion.isLocallyOwned() ) + { + return; + } + + integer const numPhase = m_numPhases; + localIndex const iwelemRef = subRegion.getTopWellElementIndex(); + + + + // subRegion data + arrayView1d< real64 const > const & connRate = subRegion.getField< fields::well::connectionRate >(); + + // fluid data + constitutive::MultiFluidBase & fluidSeparator = getMultiFluidSeparator(); + arrayView3d< real64 const, constitutive::multifluid::USD_PHASE > const & phaseFrac = fluidSeparator.phaseFraction(); + arrayView2d< real64 const, constitutive::multifluid::USD_FLUID > const & totalDens = fluidSeparator.totalDensity(); + arrayView3d< real64 const, constitutive::multifluid::USD_PHASE > const & phaseDens = fluidSeparator.phaseDensity(); - integer const useSurfaceConditions = wellControls.useSurfaceConditions(); - ReferenceConditions const refConditions = getReferenceConditions( subRegion ); + // control data + string const wellControlsName = getName(); + bool const logSurfaceCondition = isLogLevelActive< logInfo::BoundaryConditions >( getLogLevel()); + string const massUnit = m_useMass ? "kg" : "mol"; + integer const useSurfCond = useSurfaceConditions(); + integer const useMassCond = useMass(); arrayView1d< real64 > const & currentPhaseVolRate = - wellControls.getReference< array1d< real64 > >( CompositionalMultiphaseWell::viewKeyStruct::currentPhaseVolRateString() ); - arrayView2d< real64 > const & dCurrentPhaseVolRate = - wellControls.getReference< array2d< real64 > >( CompositionalMultiphaseWell::viewKeyStruct::dCurrentPhaseVolRateString() ); + getReference< array1d< real64 > >( CompositionalMultiphaseWell::viewKeyStruct::currentPhaseVolRateString() ); real64 & currentTotalVolRate = - wellControls.getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentTotalVolRateString() ); + getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentTotalVolRateString() ); real64 & currentMassRate = - wellControls.getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentMassRateString() ); - - arrayView1d< real64 > const & dCurrentTotalVolRate = - wellControls.getReference< array1d< real64 > >( CompositionalMultiphaseWell::viewKeyStruct::dCurrentTotalVolRateString() ); + getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentMassRateString() ); real64 & massDensity = - wellControls.getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::massDensityString() ); + getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::massDensityString() ); + constitutive::constitutiveUpdatePassThru( fluidSeparator, [&] ( auto & castedFluidSeparator ) { // typename TYPEOFREF( castedFluid ) ::KernelWrapper fluidWrapper = castedFluid.createKernelWrapper(); typename TYPEOFREF( castedFluidSeparator ) ::KernelWrapper fluidSeparatorWrapper = castedFluidSeparator.createKernelWrapper(); - geos::internal::kernelLaunchSelectorCompThermSwitch( numComp, isThermal, [&] ( auto NC, auto ISTHERMAL ) + + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [fluidSeparatorWrapper, + &numPhase, + connRate, + totalDens, + phaseDens, + phaseFrac, + logSurfaceCondition, + &useSurfCond, + &useMassCond, + ¤tTotalVolRate, + currentPhaseVolRate, + ¤tMassRate, + &iwelemRef, + &wellControlsName, + &massUnit, + &massDensity] ( localIndex const ) { - integer constexpr NUM_COMP = NC(); - integer constexpr IS_THERMAL = ISTHERMAL(); - using COFFSET_WJ = compositionalMultiphaseWellKernels::ColOffset_WellJac< NUM_COMP, IS_THERMAL >; - // bring everything back to host, capture the scalars by reference - forAll< serialPolicy >( 1, [&numComp, - &numPhase, - fluidSeparatorWrapper, - compFrac, - dCompFrac_dCompDens, - connRate, - totalDens, - dTotalDens, - phaseDens, - dPhaseDens, - phaseFrac, - dPhaseFrac, - logSurfaceCondition, - &useSurfaceConditions, - &refConditions, - ¤tTotalVolRate, - dCurrentTotalVolRate, - currentPhaseVolRate, - dCurrentPhaseVolRate, - ¤tMassRate, - &iwelemRef, - &wellControlsName, - &massUnit, - &massDensity] ( localIndex const ) - { - GEOS_UNUSED_VAR( massUnit ); - using Deriv = constitutive::multifluid::DerivativeOffset; - stackArray1d< real64, maxNumComp > work( numComp ); - // Step 1: evaluate the phase and total density in the reference element - - // We need to evaluate the density as follows: - // - Surface conditions: using the surface pressure provided by the user - // - Segment conditions: using the pressure in the top element - // - Reservoir conditions: using the average region pressure - fluidSeparatorWrapper.update( iwelemRef, 0, - refConditions.pressure, refConditions.temperature, - compFrac[iwelemRef] ); - if( useSurfaceConditions && logSurfaceCondition ) - { - GEOS_LOG_RANK( GEOS_FMT( "{}: surface density computed with P_surface = {} Pa and T_surface = {} K", - wellControlsName, refConditions.pressure, refConditions.temperature ) ); - } -#ifdef GEOS_USE_HIP - GEOS_UNUSED_VAR( wellControlsName ); -#endif + GEOS_UNUSED_VAR( massUnit ); - // Step 2: update the total volume rate - real64 const currentTotalRate = connRate[iwelemRef]; - // Assumes useMass is true - currentMassRate = currentTotalRate; - // Step 2.1: compute the inverse of the total density and derivatives - massDensity = totalDens[iwelemRef][0]; - real64 const totalDensInv = 1.0 / totalDens[iwelemRef][0]; + // Step 2: update the total volume rate - stackArray1d< real64, maxNumComp > dTotalDensInv_dCompDens( numComp ); - for( integer ic = 0; ic < numComp; ++ic ) - { - dTotalDensInv_dCompDens[ic] = -dTotalDens[iwelemRef][0][Deriv::dC+ic] * totalDensInv * totalDensInv; - } - applyChainRuleInPlace( numComp, dCompFrac_dCompDens[iwelemRef], dTotalDensInv_dCompDens, work.data() ); - - // Step 2.2: divide the total mass/molar rate by the total density to get the total volumetric rate - currentTotalVolRate = currentTotalRate * totalDensInv; - // Compute derivatives dP dT - real64 const dTotalDensInv_dPres = -dTotalDens[iwelemRef][0][Deriv::dP] * totalDensInv * totalDensInv; - dCurrentTotalVolRate[COFFSET_WJ::dP] = ( useSurfaceConditions == 0 ) * currentTotalRate * dTotalDensInv_dPres; - if constexpr ( IS_THERMAL ) - { - dCurrentTotalVolRate[COFFSET_WJ::dT] = ( useSurfaceConditions == 0 ) * currentTotalRate * -dTotalDens[iwelemRef][0][Deriv::dT] * totalDensInv * totalDensInv; - } + real64 const currentTotalRate = connRate[iwelemRef]; + if( useMassCond ) + currentMassRate = currentTotalRate; + // Step 2.1: compute the inverse of the total density + massDensity = totalDens[iwelemRef][0]; + real64 const totalDensInv = 1.0 / totalDens[iwelemRef][0]; - if( logSurfaceCondition && useSurfaceConditions ) - { - GEOS_LOG_RANK( GEOS_FMT( "{}: total fluid density at surface conditions = {} {}/sm3, total rate = {} {}/s, total surface volumetric rate = {} sm3/s", - wellControlsName, totalDens[iwelemRef][0], massUnit, connRate[iwelemRef], massUnit, currentTotalVolRate ) ); - } - dCurrentTotalVolRate[COFFSET_WJ::dQ] = totalDensInv; - for( integer ic = 0; ic < numComp; ++ic ) - { - dCurrentTotalVolRate[COFFSET_WJ::dC+ic] = currentTotalRate * dTotalDensInv_dCompDens[ic]; - } + // Step 2.2: divide the total mass/molar rate by the total density to get the total volumetric rate + currentTotalVolRate = currentTotalRate * totalDensInv; - // Step 3: update the phase volume rate - for( integer ip = 0; ip < numPhase; ++ip ) - { - // Step 3.1: compute the inverse of the (phase density * phase fraction) and derivatives + if( logSurfaceCondition && useSurfCond ) + { + GEOS_LOG_RANK( GEOS_FMT( "{}: total fluid density at surface conditions = {} {}/sm3, total rate = {} {}/s, total surface volumetric rate = {} sm3/s", + wellControlsName, totalDens[iwelemRef][0], massUnit, connRate[iwelemRef], massUnit, currentTotalVolRate ) ); + } - // skip the rest of this function if phase ip is absent - bool const phaseExists = (phaseFrac[iwelemRef][0][ip] > 0); - if( !phaseExists ) - { - continue; - } + // Step 3: update the phase volume rate + for( integer ip = 0; ip < numPhase; ++ip ) + { - real64 const phaseDensInv = 1.0 / phaseDens[iwelemRef][0][ip]; - real64 const phaseFracTimesPhaseDensInv = phaseFrac[iwelemRef][0][ip] * phaseDensInv; - real64 const dPhaseFracTimesPhaseDensInv_dPres = dPhaseFrac[iwelemRef][0][ip][Deriv::dP] * phaseDensInv - - dPhaseDens[iwelemRef][0][ip][Deriv::dP] * phaseFracTimesPhaseDensInv * phaseDensInv; + // Step 3.1: compute the inverse of the (phase density * phase fraction) + // skip the rest of this function if phase ip is absent + bool const phaseExists = (phaseFrac[iwelemRef][0][ip] > 0); + if( !phaseExists ) + { + continue; + } - // Step 3.2: divide the total mass/molar rate by the (phase density * phase fraction) to get the phase volumetric rate - currentPhaseVolRate[ip] = currentTotalRate * phaseFracTimesPhaseDensInv; - dCurrentPhaseVolRate[ip][COFFSET_WJ::dP] = ( useSurfaceConditions == 0 ) * currentTotalRate * dPhaseFracTimesPhaseDensInv_dPres; - dCurrentPhaseVolRate[ip][COFFSET_WJ::dQ] = phaseFracTimesPhaseDensInv; - if constexpr (IS_THERMAL ) - { - real64 const dPhaseFracTimesPhaseDensInv_dTemp = dPhaseFrac[iwelemRef][0][ip][Deriv::dT] * phaseDensInv - - dPhaseDens[iwelemRef][0][ip][Deriv::dT] * phaseFracTimesPhaseDensInv * phaseDensInv; - dCurrentPhaseVolRate[ip][COFFSET_WJ::dT] = ( useSurfaceConditions == 0 ) * currentTotalRate * dPhaseFracTimesPhaseDensInv_dTemp; - } + real64 const phaseDensInv = 1.0 / phaseDens[iwelemRef][0][ip]; + real64 const phaseFracTimesPhaseDensInv = phaseFrac[iwelemRef][0][ip] * phaseDensInv; - for( integer ic = 0; ic < numComp; ++ic ) - { - dCurrentPhaseVolRate[ip][COFFSET_WJ::dC+ic] = -phaseFracTimesPhaseDensInv * dPhaseDens[iwelemRef][0][ip][Deriv::dC+ic] * phaseDensInv; - dCurrentPhaseVolRate[ip][COFFSET_WJ::dC+ic] += dPhaseFrac[iwelemRef][0][ip][Deriv::dC+ic] * phaseDensInv; - dCurrentPhaseVolRate[ip][COFFSET_WJ::dC+ic] *= currentTotalRate; - } - applyChainRuleInPlace( numComp, dCompFrac_dCompDens[iwelemRef], &dCurrentPhaseVolRate[ip][COFFSET_WJ::dC], work.data() ); + // Step 3.2: divide the total mass/molar rate by the (phase density * phase fraction) to get the phase volumetric rate + currentPhaseVolRate[ip] = currentTotalRate * phaseFracTimesPhaseDensInv; - if( logSurfaceCondition && useSurfaceConditions ) - { - GEOS_LOG_RANK( GEOS_FMT( "{}: density of phase {} at surface conditions = {} {}/sm3, phase surface volumetric rate = {} sm3/s", - wellControlsName, ip, phaseDens[iwelemRef][0][ip], massUnit, currentPhaseVolRate[ip] ) ); - } + if( logSurfaceCondition && useSurfCond ) + { + GEOS_LOG_RANK( GEOS_FMT( "{}: density of phase {} at surface conditions = {} {}/sm3, phase surface volumetric rate = {} sm3/s", + wellControlsName, ip, phaseDens[iwelemRef][0][ip], massUnit, currentPhaseVolRate[ip] ) ); } - } ); + } } ); } ); } @@ -876,31 +755,27 @@ void CompositionalMultiphaseWell::precomputeReferenceConditions( real64 const ti MeshBody & meshBody, WellElementSubRegion const & subRegion ) { - WellControls & wellControls = getWellControls( subRegion ); - integer const useSurfaceConditions = wellControls.useSurfaceConditions(); - if( !useSurfaceConditions ) + GEOS_UNUSED_VAR( meshBodies ); + GEOS_UNUSED_VAR( subRegion ); + if( !useSurfaceConditions() ) { - string_view refRegionName = wellControls.referenceReservoirRegion(); + string_view refRegionName = referenceReservoirRegion(); bool const useSegmentValues = refRegionName.empty(); if( useSegmentValues ) { - wellControls.setRegionAveragePressure( -1 ); - wellControls.setRegionAverageTemperature( -1 ); + setRegionAveragePressure( -1 ); + setRegionAverageTemperature( -1 ); } else { - auto & flowSolver = getParent().getGroup< CompositionalMultiphaseBase >( getFlowSolverName() ); - MeshLevel & flowMeshLevel = meshBody.getMeshLevel( flowSolver.getDiscretizationName() ); - if( !m_reservoirStatsAggregator ) - { // lazily initialize the region statistics aggregator - m_reservoirStatsAggregator = std::make_unique< StatsAggregator >( wellControls.getDataContext(), - meshBodies, - false ); - m_reservoirStatsAggregator->initStatisticsAggregation( flowSolver ); - m_reservoirStatsAggregator->enableRegionStatisticsAggregation(); + { + GEOS_THROW_IF( !m_reservoirStatsAggregator, + GEOS_FMT( "Region {} stats aggregator not initialized in WellControl {}.", + refRegionName, getName() ), + InputError, getDataContext() ); } - + MeshLevel & flowMeshLevel = meshBody.getMeshLevel( getDiscretizationName() ); RegionStatistics & stats = m_reservoirStatsAggregator->getRegionStatistics( flowMeshLevel, refRegionName ); // compute region stats only if needed (could have already been done for another subRegion) @@ -909,12 +784,12 @@ void CompositionalMultiphaseWell::precomputeReferenceConditions( real64 const ti GEOS_WARNING_IF( stats.m_averagePressure <= 0.0, GEOS_FMT( "No region average quantities computed in reference region '{}'.", - wellControls.referenceReservoirRegion() ), - wellControls.getWrapperDataContext( WellControls::viewKeyStruct::referenceReservoirRegionString() ), + referenceReservoirRegion() ), + getWrapperDataContext( WellControls::viewKeyStruct::referenceReservoirRegionString() ), getDataContext() ); - wellControls.setRegionAveragePressure( stats.m_averagePressure ); - wellControls.setRegionAverageTemperature( stats.m_averageTemperature ); + setRegionAveragePressure( stats.m_averagePressure ); + setRegionAverageTemperature( stats.m_averageTemperature ); } } } @@ -922,23 +797,21 @@ void CompositionalMultiphaseWell::precomputeReferenceConditions( real64 const ti CompositionalMultiphaseWell::ReferenceConditions CompositionalMultiphaseWell::getReferenceConditions( WellElementSubRegion const & subRegion ) { - WellControls & wellControls = getWellControls( subRegion ); - integer const useSurfaceConditions = wellControls.useSurfaceConditions(); - if( useSurfaceConditions ) + if( useSurfaceConditions() ) { // use surface conditions return { - /* .pressure = */ wellControls.getSurfacePressure(), - /* .temperature = */ wellControls.getSurfaceTemperature(), + /* .pressure = */ getSurfacePressure(), + /* .temperature = */ getSurfaceTemperature(), }; } else { - if( wellControls.getRegionAveragePressure() > 0.0 && wellControls.getRegionAverageTemperature() > 0.0 ) + if( getRegionAveragePressure() > 0.0 && getRegionAverageTemperature() > 0.0 ) { // reference region condition properly computed, we can return them return { - /* .pressure = */ wellControls.getRegionAveragePressure(), - /* .temperature = */ wellControls.getRegionAverageTemperature(), + /* .pressure = */ getRegionAveragePressure(), + /* .temperature = */ getRegionAverageTemperature(), }; } else @@ -948,7 +821,7 @@ CompositionalMultiphaseWell::getReferenceConditions( WellElementSubRegion const { GEOS_WARNING( "CompositionalMultiphaseWell: region average statsistics of reference region not initialized," " fallback to top segment values.", - wellControls.getDataContext() ); + getDataContext() ); firstNoRefRegionMsg=false; } @@ -988,19 +861,123 @@ void CompositionalMultiphaseWell::updateFluidModel( WellElementSubRegion & subRe } -real64 CompositionalMultiphaseWell::updatePhaseVolumeFraction( WellElementSubRegion & subRegion ) const +void CompositionalMultiphaseWell::updateSeparator( real64 const time_n, + MeshBody const & meshBody, + ElementRegionManager const & elemManager, + WellElementSubRegion & subRegion ) { GEOS_MARK_FUNCTION; + GEOS_UNUSED_VAR( elemManager ); - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - MultiFluidBase & fluid = subRegion.getConstitutiveModel< MultiFluidBase >( fluidName ); - real64 maxDeltaPhaseVolFrac = - m_isThermal ? - thermalCompositionalMultiphaseBaseKernels:: - PhaseVolumeFractionKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( m_numComponents, - m_numPhases, + // control data + // needs to be done because the aggregator requires all cores for mpi + string const wellControlsName = getName(); + bool const logSurfaceCondition = isLogLevelActive< logInfo::BoundaryConditions >( getLogLevel()); + integer const useSurfaceCond = useSurfaceConditions(); + + if( !useSurfaceCond ) + { + string_view refRegionName = referenceReservoirRegion(); + if( !refRegionName.empty() ) + { + MeshLevel & flowMeshLevel = meshBody.getMeshLevel( getDiscretizationName()); + RegionStatistics & stats = m_reservoirStatsAggregator->getRegionStatistics( flowMeshLevel, refRegionName ); + + // compute region stats only if needed (could have already been done for another subRegion) + if( time_n >= 0.0 && !m_reservoirStatsAggregator->isComputed( time_n, stats ) ) + { + m_reservoirStatsAggregator->computeRegionsStatistics( time_n ); + } + } + } + // the rank that owns the reference well element is responsible for the calculations below. + if( !subRegion.isLocallyOwned() ) + { + return; + } + + localIndex const iwelemRef = subRegion.getTopWellElementIndex(); + + // subRegion data + arrayView1d< real64 const > const & pres = subRegion.getField< fields::well::pressure >(); + arrayView1d< real64 const > const & temp = subRegion.getField< fields::well::temperature >(); + arrayView2d< real64 const, compflow::USD_COMP > const & compFrac = subRegion.getField< fields::well::globalCompFraction >(); + + + // fluid data + constitutive::MultiFluidBase & fluidSeparator = getMultiFluidSeparator(); + + real64 flashPressure; + real64 flashTemperature; + if( useSurfaceCond ) + { + // use surface conditions + flashPressure = getSurfacePressure(); + flashTemperature = getSurfaceTemperature(); + } + else + { + string_view refRegionName = referenceReservoirRegion(); + if( !refRegionName.empty() ) + { + MeshLevel & flowMeshLevel = meshBody.getMeshLevel( getDiscretizationName()); + RegionStatistics & stats = m_reservoirStatsAggregator->getRegionStatistics( flowMeshLevel, refRegionName ); + + setRegionAveragePressure( stats.m_averagePressure ); + setRegionAverageTemperature( stats.m_averageTemperature ); + flashPressure = stats.m_averagePressure; + flashTemperature = stats.m_averageTemperature; + } + else + { + // region name not set, use segment conditions + flashPressure = pres[iwelemRef]; + flashTemperature = temp[iwelemRef]; + } + } + + constitutive::constitutiveUpdatePassThru( fluidSeparator, [&] ( auto & castedFluidSeparator ) + { + // typename TYPEOFREF( castedFluid ) ::KernelWrapper fluidWrapper = castedFluid.createKernelWrapper(); + typename TYPEOFREF( castedFluidSeparator ) ::KernelWrapper fluidSeparatorWrapper = castedFluidSeparator.createKernelWrapper(); + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [fluidSeparatorWrapper, + wellControlsName, + flashPressure, + flashTemperature, + logSurfaceCondition, + iwelemRef, + compFrac] ( localIndex const ) + { + fluidSeparatorWrapper.update( iwelemRef, 0, flashPressure, flashTemperature, compFrac[iwelemRef] ); + if( logSurfaceCondition ) + { + GEOS_LOG_RANK( GEOS_FMT( "{}: separator density computed with P = {} Pa and T = {} K", + wellControlsName, flashPressure, flashTemperature ) ); + } +#ifdef GEOS_USE_HIP + GEOS_UNUSED_VAR( wellControlsName ); +#endif + + } ); + } ); +} + + +real64 CompositionalMultiphaseWell::updatePhaseVolumeFraction( WellElementSubRegion & subRegion ) const +{ + GEOS_MARK_FUNCTION; + + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + MultiFluidBase & fluid = subRegion.getConstitutiveModel< MultiFluidBase >( fluidName ); + + real64 maxDeltaPhaseVolFrac = + m_isThermal ? + thermalCompositionalMultiphaseBaseKernels:: + PhaseVolumeFractionKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( m_numComponents, + m_numPhases, subRegion, fluid ) : isothermalCompositionalMultiphaseBaseKernels:: @@ -1036,186 +1013,285 @@ void CompositionalMultiphaseWell::updateTotalMassDensity( WellElementSubRegion & } -void CompositionalMultiphaseWell::updateState( DomainPartition & domain ) +real64 CompositionalMultiphaseWell::updateWellState( MeshBody const & meshBody, ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ) { GEOS_MARK_FUNCTION; - real64 maxPhaseVolFrac = 0.0; - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { - ElementRegionManager & elemManager = mesh.getElemManager(); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, - WellElementSubRegion & subRegion ) - { - WellControls & wellControls = getWellControls( subRegion ); - if( wellControls.getWellStatus() == WellControls::Status::OPEN ) - { - real64 const maxRegionPhaseVolFrac = updateSubRegionState( subRegion ); - maxPhaseVolFrac = LvArray::math::max( maxRegionPhaseVolFrac, maxPhaseVolFrac ); - } - } ); - } ); - maxPhaseVolFrac = MpiWrapper::max( maxPhaseVolFrac ); - GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, - GEOS_FMT( " {}: Max well phase volume fraction change = {}", - getName(), fmt::format( "{:.{}f}", maxPhaseVolFrac, 4 ) ) ); + real64 maxPhaseVolFrac = updateSubRegionState( -1.0, meshBody, elemManager, subRegion ); + return maxPhaseVolFrac; } -real64 CompositionalMultiphaseWell::updateSubRegionState( WellElementSubRegion & subRegion ) +real64 CompositionalMultiphaseWell::updateSubRegionState( real64 const time_n, + MeshBody const & meshBody, + ElementRegionManager const & elemManager, + WellElementSubRegion & subRegion ) { - // update properties - updateGlobalComponentFraction( subRegion ); + real64 maxPhaseVolChange=0.0; + + if( getWellState()) + { + + // update properties + updateGlobalComponentFraction( subRegion ); + + // update densities, phase fractions, phase volume fractions - // update volumetric rates for the well constraints - // note: this must be called before updateFluidModel - updateVolRatesForConstraint( subRegion ); + updateFluidModel( subRegion ); // Calculate fluid properties - // update densities, phase fractions, phase volume fractions + updateSeparator( time_n, meshBody, elemManager, subRegion ); // Calculate fluid properties at control conditions - updateFluidModel( subRegion ); // Calculate fluid properties; - real64 maxPhaseVolChange = updatePhaseVolumeFraction( subRegion ); - updateTotalMassDensity( subRegion ); - // update the current BHP pressure - updateBHPForConstraint( subRegion ); + updateVolRatesForConstraint( subRegion ); // remove tjb ?? + + maxPhaseVolChange = updatePhaseVolumeFraction( subRegion ); + updateTotalMassDensity( subRegion ); + + // Calculate the reference element rates + calculateReferenceElementRates( subRegion ); + + // update the current BHP + updateBHPForConstraint( subRegion ); + + // Broad case the updated well state to other ranks + real64 & currentBHP = + getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentBHPString() ); + array1d< real64 > currentPhaseVolRate = + getReference< array1d< real64 > >( CompositionalMultiphaseWell::viewKeyStruct::currentPhaseVolRateString() ); + real64 & currentTotalVolRate = + getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentTotalVolRateString() ); + real64 & currentMassRate = + getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentMassRateString() ); + integer topRank = + subRegion.getReference< integer >( WellElementSubRegion::viewKeyStruct::topRankString() ); + MpiWrapper::broadcast( currentBHP, topRank ); + MpiWrapper::bcast( currentPhaseVolRate.data(), LvArray::integerConversion< int >( currentPhaseVolRate.size() ), topRank ); + MpiWrapper::broadcast( currentTotalVolRate, topRank ); + MpiWrapper::broadcast( currentMassRate, topRank ); + if( !subRegion.isLocallyOwned() ) + { + getReference< array1d< real64 > >( + CompositionalMultiphaseWell::viewKeyStruct::currentPhaseVolRateString() ) =currentPhaseVolRate; + + } + + WellConstraintBase * constraint = getCurrentConstraint(); + if( constraint != nullptr ) + { + constraint->setBHP ( getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentBHPString() )); + constraint->setPhaseVolumeRates ( getReference< array1d< real64 > >( + CompositionalMultiphaseWell::viewKeyStruct::currentPhaseVolRateString() ) ); + constraint->setTotalVolumeRate ( getReference< real64 >( + CompositionalMultiphaseWell::viewKeyStruct::currentTotalVolRateString() )); + constraint->setMassRate( getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentMassRateString() )); + } + + } return maxPhaseVolChange; } -void CompositionalMultiphaseWell::initializeWells( DomainPartition & domain, real64 const & time_n ) + +void CompositionalMultiphaseWell::initializeWell( DomainPartition & domain, Group & meshBodies, string const & meshBodyName, MeshLevel & mesh, WellElementSubRegion & subRegion, real64 const & time_n ) { GEOS_MARK_FUNCTION; - + GEOS_UNUSED_VAR( domain ); integer const numComp = m_numComponents; integer const numPhase = m_numPhases; - Group & meshBodies = domain.getMeshBodies(); - CompositionalMultiphaseBase const & flowSolver = getFlowSolver( *this ); - // loop over the wells - forDiscretizationOnMeshTargets( meshBodies, [&] ( string const & meshBodyName, - MeshLevel & mesh, - string_array const & regionNames ) - { - MeshBody & meshBody = domain.getMeshBody( meshBodyName ); - ElementRegionManager & elemManager = mesh.getElemManager(); + // TODO: change the way we access the flowSolver here + ElementRegionManager const & elemManager = mesh.getElemManager(); - compositionalMultiphaseWellKernels::PresTempCompFracInitializationKernel::CompFlowAccessors - resCompFlowAccessors( mesh.getElemManager(), flowSolver.getName() ); - compositionalMultiphaseWellKernels::PresTempCompFracInitializationKernel::MultiFluidAccessors - resMultiFluidAccessors( mesh.getElemManager(), flowSolver.getName() ); + compositionalMultiphaseWellKernels::PresTempCompFracInitializationKernel::CompFlowAccessors + resCompFlowAccessors( elemManager, getFlowSolverName() ); + compositionalMultiphaseWellKernels::PresTempCompFracInitializationKernel::MultiFluidAccessors + resMultiFluidAccessors( elemManager, getFlowSolverName() ); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion & subRegion ) - { - WellControls & wellControls = getWellControls( subRegion ); - PerforationData const & perforationData = *subRegion.getPerforationData(); - arrayView2d< real64 const > const compPerfRate = perforationData.getField< fields::well::compPerforationRate >(); + PerforationData const & perforationData = *subRegion.getPerforationData(); + arrayView2d< real64 const > const compPerfRate = perforationData.getField< fields::well::compPerforationRate >(); - bool const hasNonZeroRate = MpiWrapper::max< integer >( hasNonZero( compPerfRate )); + bool const hasNonZeroRate = MpiWrapper::max< integer >( hasNonZero( compPerfRate )); - if( wellControls.isWellOpen() && !hasNonZeroRate ) + if( time_n <= 0.0 || ( isWellOpen( ) && !hasNonZeroRate ) ) + { + setWellState( true ); + if( getCurrentConstraint() == nullptr ) + { + // tjb needed for backward compatibility. and these 2 lists must be consistent + ConstraintTypeId inputControl = ConstraintTypeId( getInputControl()); + if( isProducer() ) { - // get well primary variables on well elements - arrayView1d< real64 > const & wellElemPressure = subRegion.getField< well::pressure >(); - arrayView1d< real64 > const & wellElemTemp = subRegion.getField< well::temperature >(); - arrayView2d< real64, compflow::USD_COMP > const & wellElemCompDens = subRegion.getField< well::globalCompDensity >(); - arrayView1d< real64 > const & connRate = subRegion.getField< well::mixtureConnectionRate >(); - - // get the info stored on well elements - arrayView2d< real64, compflow::USD_COMP > const & wellElemCompFrac = subRegion.getField< well::globalCompFraction >(); - arrayView1d< real64 const > const & wellElemGravCoef = subRegion.getField< well::gravityCoefficient >(); - - // get the element region, subregion, index - arrayView1d< localIndex const > const resElementRegion = perforationData.getField< perforation::reservoirElementRegion >(); - arrayView1d< localIndex const > const resElementSubRegion = perforationData.getField< perforation::reservoirElementSubRegion >(); - arrayView1d< localIndex const > const resElementIndex = perforationData.getField< perforation::reservoirElementIndex >(); - - arrayView1d< real64 const > const & perfGravCoef = perforationData.getField< fields::well::gravityCoefficient >(); - arrayView1d< integer const > const & perfStatus = perforationData.getField< fields::perforation::perforationStatus >(); - - // 1) Loop over all perforations to compute an average mixture density and component fraction - // 2) Initialize the reference pressure - // 3) Estimate the pressures in the well elements using the average density - compositionalMultiphaseWellKernels:: - PresTempCompFracInitializationKernel:: - launch( perforationData.size(), - subRegion.size(), - numComp, - numPhase, - wellControls, - 0.0, // initialization done at t = 0 - resCompFlowAccessors.get( flow::pressure{} ), - resCompFlowAccessors.get( flow::temperature{} ), - resCompFlowAccessors.get( flow::globalCompDensity{} ), - resCompFlowAccessors.get( flow::phaseVolumeFraction{} ), - resMultiFluidAccessors.get( fields::multifluid::phaseMassDensity{} ), - resElementRegion, - resElementSubRegion, - resElementIndex, - perfGravCoef, - perfStatus, - wellElemGravCoef, - wellElemPressure, - wellElemTemp, - wellElemCompFrac ); - - // get well secondary variables on well elements - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - MultiFluidBase & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); - arrayView3d< real64 const, constitutive::multifluid::USD_PHASE > const & wellElemPhaseDens = fluid.phaseDensity(); - arrayView2d< real64 const, constitutive::multifluid::USD_FLUID > const & wellElemTotalDens = fluid.totalDensity(); - - // 4) Back calculate component densities - constitutive::constitutiveUpdatePassThru( fluid, [&] ( auto & castedFluid ) + forSubGroups< MinimumBHPConstraint, ProductionConstraint< VolumeRateConstraint >, ProductionConstraint< MassRateConstraint >, + ProductionConstraint< PhaseVolumeRateConstraint > >( [&]( auto & constraint ) { - using FluidType = TYPEOFREF( castedFluid ); - typename FluidType::KernelWrapper fluidWrapper = castedFluid.createKernelWrapper(); - using KernelType = thermalCompositionalMultiphaseBaseKernels::FluidUpdateKernel< serialPolicy, FluidType >; - KernelType::launch( subRegion.size(), - fluidWrapper, - wellElemPressure, - wellElemTemp, - wellElemCompFrac ); + if( constraint.getControl() == inputControl ) + { + setCurrentConstraint( &constraint ); + } } ); + } + else + { - compositionalMultiphaseWellKernels:: - CompDensInitializationKernel::launch( subRegion.size(), - numComp, - wellElemCompFrac, - wellElemTotalDens, - wellElemCompDens ); - - // 5) Recompute the pressure-dependent properties - precomputeReferenceConditions( time_n, meshBodies, meshBody, subRegion ); - updateSubRegionState( subRegion ); - - // 6) Estimate the well rates - // TODO: initialize rates using perforation rates - compositionalMultiphaseWellKernels:: - RateInitializationKernel:: - launch( subRegion.size(), - m_targetPhaseIndex, - wellControls, - time_n, // initialization done at time_n - wellElemPhaseDens, - wellElemTotalDens, - connRate ); + forSubGroups< MaximumBHPConstraint, InjectionConstraint< VolumeRateConstraint >, InjectionConstraint< MassRateConstraint >, + InjectionConstraint< PhaseVolumeRateConstraint > >( [&]( auto & constraint ) + { + if( constraint.getControl() == inputControl ) + { + setCurrentConstraint( &constraint ); + } + } ); } + } + // get well primary variables on well elements + arrayView1d< real64 > const & wellElemPressure = subRegion.getField< well::pressure >(); + arrayView1d< real64 > const & wellElemTemp = subRegion.getField< well::temperature >(); + arrayView2d< real64, compflow::USD_COMP > const & wellElemCompDens = subRegion.getField< well::globalCompDensity >(); + arrayView1d< real64 > const & connRate = subRegion.getField< well::connectionRate >(); + + // get the info stored on well elements + arrayView2d< real64, compflow::USD_COMP > const & wellElemCompFrac = subRegion.getField< well::globalCompFraction >(); + arrayView1d< real64 const > const & wellElemGravCoef = subRegion.getField< well::gravityCoefficient >(); + + // get the element region, subregion, index + arrayView1d< localIndex const > const resElementRegion = perforationData.getField< perforation::reservoirElementRegion >(); + arrayView1d< localIndex const > const resElementSubRegion = perforationData.getField< perforation::reservoirElementSubRegion >(); + arrayView1d< localIndex const > const resElementIndex = perforationData.getField< perforation::reservoirElementIndex >(); + + arrayView1d< real64 const > const & perfGravCoef = perforationData.getField< fields::well::gravityCoefficient >(); + arrayView1d< integer const > const & perfStatus = perforationData.getField< fields::perforation::perforationStatus >(); + real64 const refWellElemGravCoef = getBHPReferenceGravityCoef( *this, ConstraintSourceId::USER ); + // 1) Loop over all perforations to compute an average mixture density and component fraction + // 2) Initialize the reference pressure + // 3) Estimate the pressures in the well elements using the average density + compositionalMultiphaseWellKernels:: + PresTempCompFracInitializationKernel:: + launch( perforationData.size(), + subRegion.size(), + numComp, + numPhase, + *this, + refWellElemGravCoef, + 0.0, // initialization done at t = 0 + resCompFlowAccessors.get( flow::pressure{} ), + resCompFlowAccessors.get( flow::temperature{} ), + resCompFlowAccessors.get( flow::globalCompDensity{} ), + resCompFlowAccessors.get( flow::phaseVolumeFraction{} ), + resMultiFluidAccessors.get( fields::multifluid::phaseMassDensity{} ), + resElementRegion, + resElementSubRegion, + resElementIndex, + perfGravCoef, + perfStatus, + wellElemGravCoef, + wellElemPressure, + wellElemTemp, + wellElemCompFrac ); + + // get well secondary variables on well elements + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + MultiFluidBase & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); + arrayView3d< real64 const, constitutive::multifluid::USD_PHASE > const & wellElemPhaseDens = fluid.phaseDensity(); + arrayView2d< real64 const, constitutive::multifluid::USD_FLUID > const & wellElemTotalDens = fluid.totalDensity(); + + // 4) Back calculate component densities + constitutive::constitutiveUpdatePassThru( fluid, [&] ( auto & castedFluid ) + { + using FluidType = TYPEOFREF( castedFluid ); + typename FluidType::KernelWrapper fluidWrapper = castedFluid.createKernelWrapper(); + using KernelType = thermalCompositionalMultiphaseBaseKernels::FluidUpdateKernel< serialPolicy, FluidType >; + KernelType::launch( subRegion.size(), + fluidWrapper, + wellElemPressure, + wellElemTemp, + wellElemCompFrac ); } ); - } ); + compositionalMultiphaseWellKernels:: + CompDensInitializationKernel::launch( subRegion.size(), + numComp, + wellElemCompFrac, + wellElemTotalDens, + wellElemCompDens ); + + // 5) Recompute the pressure-dependent properties + MeshBody & meshBody = domain.getMeshBody( meshBodyName ); + precomputeReferenceConditions( time_n, meshBodies, meshBody, subRegion ); + updateSubRegionState( time_n, meshBody, elemManager, subRegion ); + + // 6) Estimate the well rates + // TODO: initialize rates using perforation rates + compositionalMultiphaseWellKernels:: + RateInitializationKernel:: + launch( subRegion.size(), + *this, + time_n, // initialization done at time_n + wellElemPhaseDens, + wellElemTotalDens, + connRate ); + + updateVolRatesForConstraint( subRegion ); + // Since this is a well manager class the rates need to be pushed into the WellControls class, which represnets the well + WellConstraintBase * constraint = getCurrentConstraint(); + constraint->setBHP ( getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentBHPString() )); + constraint->setPhaseVolumeRates ( getReference< array1d< real64 > >( + CompositionalMultiphaseWell::viewKeyStruct::currentPhaseVolRateString() ) ); + constraint->setTotalVolumeRate ( getReference< real64 >( + CompositionalMultiphaseWell::viewKeyStruct::currentTotalVolRateString() )); + constraint->setMassRate( getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentMassRateString() )); + // 7) Copy well / fluid dofs to "prop"_n variables + saveState( subRegion ); + } + else if( !hasNonZeroRate ) + { + setWellState( false ); + } + else + { + setWellState( true ); + // setup if restart + if( getCurrentConstraint() == nullptr ) + { + if( isProducer() ) + { + forSubGroups< MinimumBHPConstraint, + ProductionConstraint< VolumeRateConstraint >, + ProductionConstraint< MassRateConstraint >, + ProductionConstraint< PhaseVolumeRateConstraint > >( [&]( auto & constraint ) + { + if( ConstraintTypeId( getControl()) == constraint.getControl() ) + { + setCurrentConstraint( &constraint ); + } + } ); + } + else + { + forSubGroups< MaximumBHPConstraint, + InjectionConstraint< VolumeRateConstraint >, + InjectionConstraint< MassRateConstraint >, + InjectionConstraint< PhaseVolumeRateConstraint > >( [&]( auto & constraint ) + { + if( ConstraintTypeId( getControl()) == constraint.getControl() ) + { + setCurrentConstraint( &constraint ); + } + } ); + } + updateSubRegionState( time_n, domain.getMeshBody( meshBodyName ), elemManager, subRegion ); + } + + } } -void CompositionalMultiphaseWell::assembleFluxTerms( real64 const & time, - real64 const & dt, - DomainPartition & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) + + +void CompositionalMultiphaseWell::assembleWellFluxTerms( real64 const & time, + real64 const & dt, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) { GEOS_MARK_FUNCTION; GEOS_UNUSED_VAR( time ); @@ -1225,62 +1301,55 @@ void CompositionalMultiphaseWell::assembleFluxTerms( real64 const & time, kernelFlags.set( isothermalCompositionalMultiphaseBaseKernels::KernelFlags::TotalMassEquation ); string const wellDofKey = dofManager.getKey( wellElementDofName()); - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const &, - MeshLevel & mesh, - string_array const & regionNames ) + + + if( isWellOpen( ) && !m_keepVariablesConstantDuringInitStep ) { - mesh.getElemManager().forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion & subRegion ) + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString()); + MultiFluidBase const & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); + int numComponents = fluid.numFluidComponents(); + + if( isThermal() ) { - WellControls const & well_controls = getWellControls( subRegion ); - if( well_controls.getWellStatus() == WellControls::Status::OPEN && !m_keepVariablesConstantDuringInitStep ) - { - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString()); - MultiFluidBase const & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); - int const numComponents = fluid.numFluidComponents(); + thermalCompositionalMultiphaseWellKernels:: + FaceBasedAssemblyKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( numComponents, + dt, + dofManager.rankOffset(), + kernelFlags, + wellDofKey, + *this, + subRegion, + fluid, + localMatrix, + localRhs ); + } + else + { + compositionalMultiphaseWellKernels:: + FaceBasedAssemblyKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( numComponents, + dt, + dofManager.rankOffset(), + kernelFlags, + wellDofKey, + *this, + subRegion, + localMatrix, + localRhs ); + } + } - if( isThermal() ) - { - thermalCompositionalMultiphaseWellKernels:: - FaceBasedAssemblyKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( numComponents, - dt, - dofManager.rankOffset(), - kernelFlags, - wellDofKey, - well_controls, - subRegion, - fluid, - localMatrix, - localRhs ); - } - else - { - compositionalMultiphaseWellKernels:: - FaceBasedAssemblyKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( numComponents, - dt, - dofManager.rankOffset(), - kernelFlags, - wellDofKey, - well_controls, - subRegion, - localMatrix, - localRhs ); - } - } - } ); - } ); } -void CompositionalMultiphaseWell::assembleAccumulationTerms( real64 const & time, - real64 const & dt, - DomainPartition & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) + +void CompositionalMultiphaseWell::assembleWellAccumulationTerms( real64 const & time, + real64 const & dt, + WellElementSubRegion & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) { GEOS_MARK_FUNCTION; GEOS_UNUSED_VAR( time ); @@ -1291,123 +1360,126 @@ void CompositionalMultiphaseWell::assembleAccumulationTerms( real64 const & time kernelFlags.set( isothermalCompositionalMultiphaseBaseKernels::KernelFlags::TotalMassEquation ); string const wellDofKey = dofManager.getKey( wellElementDofName() ); - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const &, - MeshLevel & mesh, - string_array const & regionNames ) + + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString()); + MultiFluidBase const & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); + integer const numPhases = fluid.numFluidPhases(); + integer const numComponents = fluid.numFluidComponents(); + + if( getWellStatus() == WellControls::Status::OPEN && !m_keepVariablesConstantDuringInitStep ) { - mesh.getElemManager().forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion & subRegion ) + if( isThermal() ) + { + + thermalCompositionalMultiphaseWellKernels:: + ElementBasedAssemblyKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( numComponents, + numPhases, + thermalEffectsEnabled(), + isProducer(), + dofManager.rankOffset(), + kernelFlags, + wellDofKey, + subRegion, + fluid, + localMatrix, + localRhs ); + } + else { - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString()); - MultiFluidBase const & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); - integer const numPhases = fluid.numFluidPhases(); - integer const numComponents = fluid.numFluidComponents(); - WellControls const & wellControls = getWellControls( subRegion ); - if( wellControls.getWellStatus() == WellControls::Status::OPEN && !m_keepVariablesConstantDuringInitStep ) + compositionalMultiphaseWellKernels:: + ElementBasedAssemblyKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( numComponents, + numPhases, + thermalEffectsEnabled(), + isProducer(), + dofManager.rankOffset(), + kernelFlags, + wellDofKey, + subRegion, + fluid, + localMatrix, + localRhs ); + } + // get the degrees of freedom and ghosting info + arrayView1d< globalIndex const > const & wellElemDofNumber = + subRegion.getReference< array1d< globalIndex > >( wellDofKey ); + arrayView1d< integer const > const wellElemGhostRank = subRegion.ghostRank(); + arrayView1d< integer const > const elemStatus = subRegion.getLocalWellElementStatus(); + arrayView1d< real64 > const mixConnRate = subRegion.getField< fields::well::connectionRate >(); + localIndex rank_offset = dofManager.rankOffset(); + forAll< parallelDevicePolicy<> >( subRegion.size(), [=] GEOS_HOST_DEVICE ( localIndex const ei ) + { + if( wellElemGhostRank[ei] < 0 ) { - if( isThermal() ) + if( elemStatus[ei]==WellElementSubRegion::WellElemStatus::CLOSED ) { + mixConnRate[ei] = 0.0; + globalIndex const dofIndex = wellElemDofNumber[ei]; + localIndex const localRow = dofIndex - rank_offset; - thermalCompositionalMultiphaseWellKernels:: - ElementBasedAssemblyKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( numComponents, - numPhases, - wellControls.isProducer(), - dofManager.rankOffset(), - kernelFlags, - wellDofKey, - subRegion, - fluid, - localMatrix, - localRhs ); - } - else - { - compositionalMultiphaseWellKernels:: - ElementBasedAssemblyKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( numComponents, - numPhases, - wellControls.isProducer(), - dofManager.rankOffset(), - kernelFlags, - wellDofKey, - subRegion, - fluid, - localMatrix, - localRhs ); - } - // get the degrees of freedom and ghosting info - arrayView1d< globalIndex const > const & wellElemDofNumber = - subRegion.getReference< array1d< globalIndex > >( wellDofKey ); - arrayView1d< integer const > const wellElemGhostRank = subRegion.ghostRank(); - arrayView1d< integer const > const elemStatus = subRegion.getLocalWellElementStatus(); - arrayView1d< real64 > const mixConnRate = subRegion.getField< fields::well::mixtureConnectionRate >(); - localIndex rank_offset = dofManager.rankOffset(); - forAll< parallelDevicePolicy<> >( subRegion.size(), [=] GEOS_HOST_DEVICE ( localIndex const ei ) - { - if( wellElemGhostRank[ei] < 0 ) + real64 const unity = 1.0; + for( integer i=0; i < m_numDofPerWellElement; i++ ) { - if( elemStatus[ei]==WellElementSubRegion::WellElemStatus::CLOSED ) - { - mixConnRate[ei] = 0.0; - globalIndex const dofIndex = wellElemDofNumber[ei]; - localIndex const localRow = dofIndex - rank_offset; - - real64 const unity = 1.0; - for( integer i=0; i < m_numDofPerWellElement; i++ ) - { - globalIndex const rindex = localRow+i; - globalIndex const cindex =dofIndex + i; - localMatrix.template addToRow< serialAtomic >( rindex, - &cindex, - &unity, - 1 ); - localRhs[rindex] = 0.0; - } - } + globalIndex const rindex = localRow+i; + globalIndex const cindex =dofIndex + i; + localMatrix.template addToRow< serialAtomic >( rindex, + &cindex, + &unity, + 1 ); + localRhs[rindex] = 0.0; } - } ); + } } - else + } ); + + } + else + { + arrayView1d< globalIndex const > const & wellElemDofNumber = + subRegion.getReference< array1d< globalIndex > >( wellDofKey ); + arrayView1d< integer const > const wellElemGhostRank = subRegion.ghostRank(); + + arrayView1d< real64 > mixConnRate = subRegion.getField< fields::well::connectionRate >(); + localIndex rank_offset = dofManager.rankOffset(); + forAll< parallelDevicePolicy<> >( subRegion.size(), [=] GEOS_HOST_DEVICE ( localIndex const ei ) + { + if( wellElemGhostRank[ei] < 0 ) { - // get the degrees of freedom and ghosting info - arrayView1d< globalIndex const > const & wellElemDofNumber = - subRegion.getReference< array1d< globalIndex > >( wellDofKey ); - arrayView1d< integer const > const & wellElemGhostRank = subRegion.ghostRank(); - localIndex rank_offset = dofManager.rankOffset(); - forAll< parallelDevicePolicy<> >( subRegion.size(), [=] GEOS_HOST_DEVICE ( localIndex const ei ) + mixConnRate[ei] = 0.0; + globalIndex const dofIndex = wellElemDofNumber[ei]; + localIndex const localRow = dofIndex - rank_offset; + + real64 const unity = 1.0; + for( integer i=0; i < m_numDofPerWellElement; i++ ) { - if( wellElemGhostRank[ei] < 0 ) - { - globalIndex const dofIndex = wellElemDofNumber[ei]; - localIndex const localRow = dofIndex - rank_offset; - - real64 unity = 1.0; - for( integer i=0; i < m_numDofPerWellElement; i++ ) - { - globalIndex const rindex = localRow+i; - globalIndex const cindex =dofIndex + i; - localMatrix.template addToRow< serialAtomic >( rindex, - &cindex, - &unity, - 1 ); - localRhs[rindex] = 0.0; - } - } - } ); + globalIndex const rindex = localRow+i; + globalIndex const cindex =dofIndex + i; + localMatrix.template addToRow< serialAtomic >( rindex, + &cindex, + &unity, + 1 ); + localRhs[rindex] = 0.0; + } } - } ); // forElementSubRegions - } ); // forDiscretizationOnMeshTargets + } ); + // zero out current state constraint quantities + getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentBHPString() )=0.0; + getReference< array1d< real64 > >( + CompositionalMultiphaseWell::viewKeyStruct::currentPhaseVolRateString() ).zero(); + getReference< real64 >( + CompositionalMultiphaseWell::viewKeyStruct::currentTotalVolRateString() )=0.0; + getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentMassRateString() )=0.0; + } } - -real64 -CompositionalMultiphaseWell::calculateResidualNorm( real64 const & time_n, - real64 const & dt, - DomainPartition const & domain, - DofManager const & dofManager, - arrayView1d< real64 const > const & localRhs ) +array1d< real64 > +CompositionalMultiphaseWell::calculateLocalWellResidualNorm( real64 const & time_n, + real64 const & dt, + NonlinearSolverParameters const & nonlinearSolverParameters, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localRhs ) { GEOS_MARK_FUNCTION; @@ -1418,93 +1490,127 @@ CompositionalMultiphaseWell::calculateResidualNorm( real64 const & time_n, globalIndex const rankOffset = dofManager.rankOffset(); string const wellDofKey = dofManager.getKey( wellElementDofName() ); - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel const & mesh, - string_array const & regionNames ) + + + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + MultiFluidBase const & fluid = subRegion.getConstitutiveModel< MultiFluidBase >( fluidName ); + + + // step 1: compute the norm in the subRegion + + if( !isWellOpen() ) { + for( integer i = 0; i < numNorm; ++i ) + { + localResidualNorm[i] = 0.0; + localResidualNormalizer[i] = nonlinearSolverParameters.m_minNormalizer; + } + } + else if( isThermal() ) + { + real64 subRegionResidualNorm[2]{}; + thermalCompositionalMultiphaseWellKernels::ResidualNormKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( m_numComponents, + rankOffset, + wellDofKey, + localRhs, + subRegion, + fluid, + *this, + time_n, + dt, + nonlinearSolverParameters.m_minNormalizer, + subRegionResidualNorm ); + // step 2: reduction across meshBodies/regions/subRegions + + for( integer i=0; i localResidualNorm[i] ) + { + localResidualNorm[i] = subRegionResidualNorm[i]; + } + } - ElementRegionManager const & elemManager = mesh.getElemManager(); + } + else + { + real64 subRegionResidualNorm[1]{}; + compositionalMultiphaseWellKernels::ResidualNormKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( m_numComponents, + m_numDofPerWellElement, + rankOffset, + wellDofKey, + localRhs, + subRegion, + fluid, + *this, + time_n, + dt, + nonlinearSolverParameters.m_minNormalizer, + subRegionResidualNorm ); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion const & subRegion ) + + + // step 2: reduction across meshBodies/regions/subRegions + + if( subRegionResidualNorm[0] > localResidualNorm[0] ) { + localResidualNorm[0] = subRegionResidualNorm[0]; + } + } + return localResidualNorm; - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - MultiFluidBase const & fluid = subRegion.getConstitutiveModel< MultiFluidBase >( fluidName ); +} - WellControls const & wellControls = getWellControls( subRegion ); +real64 +CompositionalMultiphaseWell::calculateWellResidualNorm( real64 const & time_n, + real64 const & dt, + NonlinearSolverParameters const & nonlinearSolverParameters, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localRhs ) +{ + GEOS_MARK_FUNCTION; + integer numNorm = 1; // mass balance + array1d< real64 > localResidualNorm; + array1d< real64 > localResidualNormalizer; - // step 1: compute the norm in the subRegion + if( isThermal() ) + { + numNorm = 2; // mass balance and energy balance + } + localResidualNorm.resize( numNorm ); + localResidualNormalizer.resize( numNorm ); - if( !wellControls.isWellOpen() ) - { - for( integer i = 0; i < numNorm; ++i ) - { - localResidualNorm[i] = 0.0; - localResidualNormalizer[i] = m_nonlinearSolverParameters.m_minNormalizer; - } - } - else if( isThermal() ) - { - real64 subRegionResidualNorm[2]{}; - - thermalCompositionalMultiphaseWellKernels::ResidualNormKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( m_numComponents, - m_targetPhaseIndex, - rankOffset, - wellDofKey, - localRhs, - subRegion, - fluid, - wellControls, - time_n, - dt, - m_nonlinearSolverParameters.m_minNormalizer, - subRegionResidualNorm ); - // step 2: reduction across meshBodies/regions/subRegions - - for( integer i=0; i localResidualNorm[i] ) - { - localResidualNorm[i] = subRegionResidualNorm[i]; - } - } - } - else - { - real64 subRegionResidualNorm[1]{}; - compositionalMultiphaseWellKernels::ResidualNormKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( m_numComponents, - numDofPerWellElement(), - m_targetPhaseIndex, - rankOffset, - wellDofKey, - localRhs, - subRegion, - fluid, - wellControls, - time_n, - dt, - m_nonlinearSolverParameters.m_minNormalizer, - subRegionResidualNorm ); - - - - // step 2: reduction across meshBodies/regions/subRegions - - if( subRegionResidualNorm[0] > localResidualNorm[0] ) - { - localResidualNorm[0] = subRegionResidualNorm[0]; - } - } - } ); - } ); + //globalIndex const rankOffset = dofManager.rankOffset(); + string const wellDofKey = dofManager.getKey( wellElementDofName() ); + + + + //string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + //MultiFluidBase const & fluid = subRegion.getConstitutiveModel< MultiFluidBase >( fluidName ); + if( isWellOpen( ) ) + { + localResidualNorm = calculateLocalWellResidualNorm( time_n, + dt, + nonlinearSolverParameters, + subRegion, + dofManager, + localRhs ); + + } + else + { + for( integer i=0; i const & localSolution ) +CompositionalMultiphaseWell::scalingForLocalSystemSolution( WellElementSubRegion & subRegion, + DofManager const & dofManager, + real64 & maxDeltaPres, + real64 & maxDeltaCompDens, + real64 & maxDeltaTemp, + real64 & minPresScalingFactor, + real64 & minCompDensScalingFactor, + real64 & minTempScalingFactor, + arrayView1d< real64 const > const & localSolution ) { GEOS_MARK_FUNCTION; string const wellDofKey = dofManager.getKey( wellElementDofName() ); real64 scalingFactor = 1.0; - real64 maxDeltaPres = 0.0, maxDeltaCompDens = 0.0, maxDeltaTemp = 0.0; - real64 minPresScalingFactor = 1.0, minCompDensScalingFactor = 1.0, minTempScalingFactor = 1.0; - - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { - mesh.getElemManager().forElementSubRegions( regionNames, - [&]( localIndex const, - ElementSubRegionBase & subRegion ) - { - arrayView1d< real64 const > const pressure = subRegion.getField< well::pressure >(); - arrayView1d< real64 const > const temperature = subRegion.getField< well::temperature >(); - arrayView2d< real64 const, compflow::USD_COMP > const compDens = subRegion.getField< well::globalCompDensity >(); - arrayView1d< real64 > pressureScalingFactor = subRegion.getField< well::pressureScalingFactor >(); - arrayView1d< real64 > temperatureScalingFactor = subRegion.getField< well::temperatureScalingFactor >(); - arrayView1d< real64 > compDensScalingFactor = subRegion.getField< well::globalCompDensityScalingFactor >(); - const integer temperatureOffset = m_numComponents+2; - auto const subRegionData = - m_isThermal + maxDeltaPres = 0.0; + maxDeltaCompDens = 0.0; + maxDeltaTemp = 0.0; + minPresScalingFactor = 1.0; + minCompDensScalingFactor = 1.0; + minTempScalingFactor = 1.0; + + arrayView1d< real64 const > const pressure = subRegion.getField< fields::well::pressure >(); + arrayView1d< real64 const > const temperature = subRegion.getField< fields::well::temperature >(); + arrayView2d< real64 const, compflow::USD_COMP > const compDens = subRegion.getField< fields::well::globalCompDensity >(); + arrayView1d< real64 > pressureScalingFactor = subRegion.getField< fields::well::pressureScalingFactor >(); + arrayView1d< real64 > temperatureScalingFactor = subRegion.getField< fields::well::temperatureScalingFactor >(); + arrayView1d< real64 > compDensScalingFactor = subRegion.getField< fields::well::globalCompDensityScalingFactor >(); + const integer temperatureOffset = m_numComponents+2; + auto const subRegionData = + m_isThermal ? thermalCompositionalMultiphaseBaseKernels:: - SolutionScalingKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( m_maxRelativePresChange, - m_maxAbsolutePresChange, - m_maxRelativeTempChange, - m_maxCompFracChange, - m_maxRelativeCompDensChange, - pressure, - temperature, - compDens, - pressureScalingFactor, - compDensScalingFactor, - temperatureScalingFactor, - dofManager.rankOffset(), - m_numComponents, - wellDofKey, - subRegion, - localSolution, - temperatureOffset ) + SolutionScalingKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( m_maxRelativePresChange, + m_maxAbsolutePresChange, + m_maxRelativeTempChange, + m_maxCompFracChange, + m_maxRelativeCompDensChange, + pressure, + temperature, + compDens, + pressureScalingFactor, + compDensScalingFactor, + temperatureScalingFactor, + dofManager.rankOffset(), + m_numComponents, + wellDofKey, + subRegion, + localSolution, + temperatureOffset ) : isothermalCompositionalMultiphaseBaseKernels:: - SolutionScalingKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( m_maxRelativePresChange, - m_maxAbsolutePresChange, - m_maxCompFracChange, - m_maxRelativeCompDensChange, - pressure, - compDens, - pressureScalingFactor, - compDensScalingFactor, - dofManager.rankOffset(), - m_numComponents, - wellDofKey, - subRegion, - localSolution ); - - - scalingFactor = std::min( subRegionData.localMinVal, scalingFactor ); - - maxDeltaPres = std::max( maxDeltaPres, subRegionData.localMaxDeltaPres ); - maxDeltaCompDens = std::max( maxDeltaCompDens, subRegionData.localMaxDeltaCompDens ); - maxDeltaTemp = std::max( maxDeltaTemp, subRegionData.localMaxDeltaTemp ); - minPresScalingFactor = std::min( minPresScalingFactor, subRegionData.localMinPresScalingFactor ); - minCompDensScalingFactor = std::min( minCompDensScalingFactor, subRegionData.localMinCompDensScalingFactor ); - minTempScalingFactor = std::min( minTempScalingFactor, subRegionData.localMinTempScalingFactor ); - } ); - } ); + SolutionScalingKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( m_maxRelativePresChange, + m_maxAbsolutePresChange, + m_maxCompFracChange, + m_maxRelativeCompDensChange, + pressure, + compDens, + pressureScalingFactor, + compDensScalingFactor, + dofManager.rankOffset(), + m_numComponents, + wellDofKey, + subRegion, + localSolution ); + + + scalingFactor = std::min( subRegionData.localMinVal, scalingFactor ); + + maxDeltaPres = std::max( maxDeltaPres, subRegionData.localMaxDeltaPres ); + maxDeltaCompDens = std::max( maxDeltaCompDens, subRegionData.localMaxDeltaCompDens ); + maxDeltaTemp = std::max( maxDeltaTemp, subRegionData.localMaxDeltaTemp ); + minPresScalingFactor = std::min( minPresScalingFactor, subRegionData.localMinPresScalingFactor ); + minCompDensScalingFactor = std::min( minCompDensScalingFactor, subRegionData.localMinCompDensScalingFactor ); + minTempScalingFactor = std::min( minTempScalingFactor, subRegionData.localMinTempScalingFactor ); scalingFactor = MpiWrapper::min( scalingFactor ); maxDeltaPres = MpiWrapper::max( maxDeltaPres ); @@ -1631,7 +1735,6 @@ CompositionalMultiphaseWell::scalingForSystemSolution( DomainPartition & domain, getName(), GEOS_FMT( "{:.{}f}", maxDeltaTemp, 3 ) ) ); } - GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, GEOS_FMT( " {}: Min well pressure scaling factor: {}", getName(), minPresScalingFactor ) ); @@ -1645,205 +1748,311 @@ CompositionalMultiphaseWell::scalingForSystemSolution( DomainPartition & domain, getName(), minTempScalingFactor ) ); } - return LvArray::math::max( scalingFactor, m_minScalingFactor ); } +real64 +CompositionalMultiphaseWell::scalingForWellSystemSolution( WellElementSubRegion & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution ) +{ + GEOS_MARK_FUNCTION; + + string const wellDofKey = dofManager.getKey( wellElementDofName() ); + + real64 maxDeltaPres = 0.0, maxDeltaCompDens = 0.0, maxDeltaTemp = 0.0; + real64 minPresScalingFactor = 1.0, minCompDensScalingFactor = 1.0, minTempScalingFactor = 1.0; + + real64 scalingFactor =scalingForLocalSystemSolution( subRegion, + dofManager, + maxDeltaPres, + maxDeltaCompDens, + maxDeltaTemp, + minPresScalingFactor, + minCompDensScalingFactor, + minTempScalingFactor, + localSolution ); + string const massUnit = m_useMass ? "kg/m3" : "mol/m3"; + GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, + GEOS_FMT( " {}: Max well pressure change: {} Pa (before scaling)", + getName(), GEOS_FMT( "{:.{}f}", maxDeltaPres, 3 ) ) ); + GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, + GEOS_FMT( " {}: Max well component density change: {} {} (before scaling)", + getName(), GEOS_FMT( "{:.{}f}", maxDeltaCompDens, 3 ), massUnit ) ); + + if( m_isThermal ) + { + maxDeltaTemp = MpiWrapper::max( maxDeltaTemp ); + minTempScalingFactor = MpiWrapper::min( minTempScalingFactor ); + GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, + GEOS_FMT( " {}: Max well temperature change: {} K (before scaling)", + getName(), GEOS_FMT( "{:.{}f}", maxDeltaTemp, 3 ) ) ); + } + + GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, + GEOS_FMT( " {}: Min well pressure scaling factor: {}", + getName(), minPresScalingFactor ) ); + GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, + GEOS_FMT( " {}: Min well component density scaling factor: {}", + getName(), minCompDensScalingFactor ) ); + if( m_isThermal ) + { + GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, + GEOS_FMT( " {}: Min well temperature scaling factor: {}", + getName(), minTempScalingFactor ) ); + } + + return LvArray::math::max( scalingFactor, m_minScalingFactor ); + +} + + bool -CompositionalMultiphaseWell::checkSystemSolution( DomainPartition & domain, - DofManager const & dofManager, - arrayView1d< real64 const > const & localSolution, - real64 const scalingFactor ) +CompositionalMultiphaseWell::checkWellSystemSolution( WellElementSubRegion & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution, + real64 const scalingFactor, + real64 & minPressure, + real64 & minDensity, + real64 & minTotalDensity, + ElementsReporterBuffer & negPressureIds, + ElementsReporterBuffer & negDensityIds, + ElementsReporterBuffer & negTotalDensityIds ) { GEOS_MARK_FUNCTION; string const wellDofKey = dofManager.getKey( wellElementDofName() ); integer localCheck = 1; - real64 minPres = 0.0, minDens = 0.0, minTotalDens = 0.0; - ElementsReporterBuffer rankNegPressureIds{ isLogLevelActive< logInfo::Solution >( getLogLevel() ), - isLogLevelActive< logInfo::SolutionDetails >( getLogLevel() ) ? 16 : 0 }; - ElementsReporterBuffer rankNegDensityIds{ isLogLevelActive< logInfo::Solution >( getLogLevel() ), - isLogLevelActive< logInfo::SolutionDetails >( this->getLogLevel() ) ? 16 : 0 }; - // output only total density sum, not cell details - ElementsReporterBuffer rankTotalNegDensityIds{ isLogLevelActive< logInfo::Solution >( getLogLevel() ), 0 }; - - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { - mesh.getElemManager().forElementSubRegions( regionNames, - [&]( localIndex const, - ElementSubRegionBase & subRegion ) - { - //integer const m_allowCompDensChopping(true); - integer const m_allowNegativePressure( false ); - compositionalMultiphaseUtilities::ScalingType const m_scalingType( compositionalMultiphaseUtilities::ScalingType::Global ); - arrayView1d< real64 const > const pressure = - subRegion.getField< well::pressure >(); - arrayView1d< real64 const > const temperature = - subRegion.getField< well::temperature >(); - arrayView2d< real64 const, compflow::USD_COMP > const compDens = - subRegion.getField< well::globalCompDensity >(); - arrayView1d< real64 > pressureScalingFactor = subRegion.getField< well::pressureScalingFactor >(); - arrayView1d< real64 > temperatureScalingFactor = subRegion.getField< well::temperatureScalingFactor >(); - arrayView1d< real64 > compDensScalingFactor = subRegion.getField< well::globalCompDensityScalingFactor >(); - auto const & cellLocalToGlobalIds = subRegion.localToGlobalMap(); - auto const negPresCollector = rankNegPressureIds.createCollector( cellLocalToGlobalIds ); - auto const negDensCollector = rankNegDensityIds.createCollector( cellLocalToGlobalIds ); - auto const negTotalDensCollector = rankNegDensityIds.createCollector( cellLocalToGlobalIds ); - - // check that pressure and component densities are non-negative - // for thermal, check that temperature is above 273.15 K - const integer temperatureOffset = m_numComponents+2; - auto const subRegionData = m_isThermal ? - thermalCompositionalMultiphaseBaseKernels:: - SolutionCheckKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( m_allowCompDensChopping, - m_allowNegativePressure, - m_scalingType, - scalingFactor, - pressure, - temperature, - compDens, - pressureScalingFactor, - temperatureScalingFactor, - compDensScalingFactor, - dofManager.rankOffset(), - m_numComponents, - wellDofKey, - subRegion, - localSolution, - negPresCollector, - negDensCollector, - negTotalDensCollector, - temperatureOffset ) : - isothermalCompositionalMultiphaseBaseKernels:: - SolutionCheckKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( m_allowCompDensChopping, - m_allowNegativePressure, - m_scalingType, - scalingFactor, - pressure, - compDens, - pressureScalingFactor, - compDensScalingFactor, - dofManager.rankOffset(), - m_numComponents, - wellDofKey, - subRegion, - localSolution, - negPresCollector, - negDensCollector, - negTotalDensCollector ); - - localCheck = std::min( localCheck, subRegionData.localMinVal ); - - minPres = std::min( minPres, subRegionData.localMinNegPres ); - minDens = std::min( minDens, subRegionData.localMinNegDens ); - minTotalDens = std::min( minTotalDens, subRegionData.localMinNegTotalDens ); - } ); - } ); - minPres = MpiWrapper::min( minPres ); - minDens = MpiWrapper::min( minDens ); - minTotalDens = MpiWrapper::min( minTotalDens ); + integer constexpr allowNegativePressure = 0; + compositionalMultiphaseUtilities::ScalingType constexpr scalingType = compositionalMultiphaseUtilities::ScalingType::Global; - rankNegPressureIds.createOutput().outputTooLowValues( GEOS_FMT( " {}: ", getName() ), - "negative pressure", minPres, units::Unit::Pressure ); + arrayView1d< real64 const > const pressure = subRegion.getField< well::pressure >(); + arrayView1d< real64 const > const temperature = subRegion.getField< well::temperature >(); + arrayView2d< real64 const, compflow::USD_COMP > const compDens = subRegion.getField< well::globalCompDensity >(); + arrayView1d< real64 > pressureScalingFactor = subRegion.getField< well::pressureScalingFactor >(); + arrayView1d< real64 > temperatureScalingFactor = subRegion.getField< well::temperatureScalingFactor >(); + arrayView1d< real64 > compDensScalingFactor = subRegion.getField< well::globalCompDensityScalingFactor >(); + + auto const & cellLocalToGlobalIds = subRegion.localToGlobalMap(); + auto const negPresCollector = negPressureIds.createCollector( cellLocalToGlobalIds ); + auto const negDensCollector = negDensityIds.createCollector( cellLocalToGlobalIds ); + auto const negTotalDensCollector = negTotalDensityIds.createCollector( cellLocalToGlobalIds ); + + // check that pressure and component densities are non-negative + // for thermal, check that temperature is above 273.15 K + const integer temperatureOffset = m_numComponents+2; + + auto const subRegionData = [&](){ + if( m_isThermal ) + { + using Kernel = thermalCompositionalMultiphaseBaseKernels::SolutionCheckKernelFactory; + return Kernel::createAndLaunch< parallelDevicePolicy<> >( m_allowCompDensChopping, + allowNegativePressure, + scalingType, + scalingFactor, + pressure, + temperature, + compDens, + pressureScalingFactor, + temperatureScalingFactor, + compDensScalingFactor, + dofManager.rankOffset(), + m_numComponents, + wellDofKey, + subRegion, + localSolution, + negPresCollector, + negDensCollector, + negTotalDensCollector, + temperatureOffset ); + } + else + { + using Kernel = isothermalCompositionalMultiphaseBaseKernels::SolutionCheckKernelFactory; + return Kernel::createAndLaunch< parallelDevicePolicy<> >( m_allowCompDensChopping, + allowNegativePressure, + scalingType, + scalingFactor, + pressure, + compDens, + pressureScalingFactor, + compDensScalingFactor, + dofManager.rankOffset(), + m_numComponents, + wellDofKey, + subRegion, + localSolution, + negPresCollector, + negDensCollector, + negTotalDensCollector ); + } + }(); - units::Unit const massUnit = m_useMass ? units::Unit::Density : units::Unit::MolarDensity; - rankNegDensityIds.createOutput().outputTooLowValues( GEOS_FMT( " {}: ", getName() ), - "negative component density", minDens, massUnit ); - rankTotalNegDensityIds.createOutput().outputTooLowValues( GEOS_FMT( " {}: ", getName() ), - "negative components total density", minTotalDens, massUnit ); + minPressure = std::min( minPressure, subRegionData.localMinNegPres ); + minDensity = std::min( minDensity, subRegionData.localMinNegDens ); + minTotalDensity = std::min( minTotalDensity, subRegionData.localMinNegTotalDens ); + localCheck = std::min( localCheck, subRegionData.localMinVal ); return MpiWrapper::min( localCheck ); } -void CompositionalMultiphaseWell::computePerforationRates( real64 const & time_n, - real64 const & GEOS_UNUSED_PARAM( dt ), - DomainPartition & domain ) +void CompositionalMultiphaseWell::computeWellPerforationRates( real64 const & time_n, + real64 const & GEOS_UNUSED_PARAM( dt ), + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion ) { GEOS_MARK_FUNCTION; GEOS_UNUSED_VAR( time_n ); - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) + //CompositionalMultiphaseBase const & flowSolver = getParent().getParent().getGroup< CompositionalMultiphaseBase >( getFlowSolverName() + // ); + + PerforationData * const perforationData = subRegion.getPerforationData(); + + if( isWellOpen() && !m_keepVariablesConstantDuringInitStep ) { - // TODO: change the way we access the flowSolver here - CompositionalMultiphaseBase const & flowSolver = getFlowSolver( *this ); - ElementRegionManager & elemManager = mesh.getElemManager(); + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + MultiFluidBase const & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); + bool isThermal = fluid.isThermal(); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, - WellElementSubRegion & subRegion ) + if( isThermal ) { - PerforationData * const perforationData = subRegion.getPerforationData(); - WellControls const & wellControls = getWellControls( subRegion ); - if( wellControls.getWellStatus() == WellControls::Status::OPEN && !m_keepVariablesConstantDuringInitStep ) - { - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - MultiFluidBase const & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); - bool const isThermal = fluid.isThermal(); - - if( isThermal ) - { - thermalPerforationFluxKernels:: - PerforationFluxKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( m_numComponents, - m_numPhases, - flowSolver.getName(), - perforationData, - subRegion, - fluid, - elemManager, - wellControls.isInjector(), - wellControls.isCrossflowEnabled() ); - } - else - { - isothermalPerforationFluxKernels:: - PerforationFluxKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( m_numComponents, - m_numPhases, - flowSolver.getName(), - perforationData, - subRegion, - elemManager, - wellControls.isInjector(), - wellControls.isCrossflowEnabled() ); - } - } - else + thermalPerforationFluxKernels:: + PerforationFluxKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( m_numComponents, + m_numPhases, + getFlowSolverName(), + perforationData, + subRegion, + fluid, + elemManager, + isInjector(), + isCrossflowEnabled()); + } + else + { + isothermalPerforationFluxKernels:: + PerforationFluxKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( m_numComponents, + m_numPhases, + getFlowSolverName(), + perforationData, + subRegion, + elemManager, + isInjector(), + isCrossflowEnabled() ); + } + } + else + { + // Zero completion flow rate + arrayView2d< real64 > const compPerfRate = perforationData->getField< fields::well::compPerforationRate >(); + for( integer iperf=0; iperfsize(); iperf++ ) + { + for( integer ic = 0; ic < m_numComponents; ++ic ) { - // Zero completion flow rate - arrayView2d< real64 > const compPerfRate = perforationData->getField< well::compPerforationRate >(); - for( integer iperf=0; iperfsize(); iperf++ ) - { - for( integer ic = 0; ic < m_numComponents; ++ic ) - { - compPerfRate[iperf][ic] = 0.0; - } - } + compPerfRate[iperf][ic] = 0.0; } - } ); + } + } - } ); } - void -CompositionalMultiphaseWell::applySystemSolution( DofManager const & dofManager, - arrayView1d< real64 const > const & localSolution, - real64 const scalingFactor, - real64 const dt, - DomainPartition & domain ) +CompositionalMultiphaseWell::applyWellBoundaryConditions( real64 const time_n, + real64 const dt, + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion, + DofManager const & dofManager, + arrayView1d< real64 > const & localRhs, + CRSMatrixView< real64, globalIndex const > const & localMatrix ) { + GEOS_UNUSED_VAR( elemManager ); + GEOS_UNUSED_VAR( time_n ); + + using namespace compositionalMultiphaseUtilities; + + BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags; + if( useTotalMassEquation() ) + kernelFlags.set( isothermalCompositionalMultiphaseBaseKernels::KernelFlags::TotalMassEquation ); + + integer const numComps = numFluidComponents(); + + globalIndex const rankOffset = dofManager.rankOffset(); + + + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + MultiFluidBase const & fluid = subRegion.getConstitutiveModel< MultiFluidBase >( fluidName ); + + // if the well is shut, we neglect reservoir-well flow that may occur despite the zero rate + // therefore, we do not want to compute perforation rates and we simply assume they are zero + + //bool const detectCrossflow = + // ( wellControls.isInjector() ) && wellControls.isCrossflowEnabled() && + // getLogLevel() >= 1; // since detect crossflow requires communication, we detect it only if the logLevel is sufficiently high + + if( !isWellOpen( ) ) + { + return; + } + + PerforationData const * const perforationData = subRegion.getPerforationData(); + + // get the degrees of freedom + string const wellDofKey = dofManager.getKey( wellElementDofName() ); + + if( isThermal ( ) ) + { + coupledReservoirAndWellKernels:: + ThermalCompositionalMultiPhaseWellFluxKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( numComps, + *this, + isProducer(), + dt, + rankOffset, + wellDofKey, + subRegion, + perforationData, + fluid, + kernelFlags, + localRhs, + localMatrix ); + + } + else + { + coupledReservoirAndWellKernels:: + IsothermalCompositionalMultiPhaseWellFluxKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( numComps, + dt, + rankOffset, + wellDofKey, + subRegion, + perforationData, + fluid, + localRhs, + localMatrix, + kernelFlags ); + } + + +} +void +CompositionalMultiphaseWell::applyWellSystemSolution( DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution, + real64 const scalingFactor, + real64 const dt, + DomainPartition & domain, + MeshLevel & mesh, + WellElementSubRegion & subRegion ) +{ + GEOS_UNUSED_VAR( domain ); DofManager::CompMask pressureMask( m_numDofPerWellElement, 0, 1 ); DofManager::CompMask componentMask( m_numDofPerWellElement, 1, numFluidComponents()+1 ); DofManager::CompMask connRateMask( m_numDofPerWellElement, numFluidComponents()+1, numFluidComponents()+2 ); @@ -1851,518 +2060,521 @@ CompositionalMultiphaseWell::applySystemSolution( DofManager const & dofManager, // update all the fields using the global damping coefficients dofManager.addVectorToField( localSolution, wellElementDofName(), - well::pressure::key(), + fields::well::pressure::key(), scalingFactor, pressureMask ); dofManager.addVectorToField( localSolution, wellElementDofName(), - well::globalCompDensity::key(), + fields::well::globalCompDensity::key(), scalingFactor, componentMask ); dofManager.addVectorToField( localSolution, wellElementDofName(), - well::mixtureConnectionRate::key(), + fields::well::connectionRate::key(), scalingFactor, connRateMask ); if( isThermal() ) { DofManager::CompMask temperatureMask( m_numDofPerWellElement, numFluidComponents()+2, numFluidComponents()+3 ); - dofManager.addVectorToField( localSolution, wellElementDofName(), - well::temperature::key(), + fields::well::temperature::key(), scalingFactor, temperatureMask ); } + // if component density chopping is allowed, some component densities may be negative after the update // these negative component densities are set to zero in this function if( m_allowCompDensChopping ) { - chopNegativeDensities( domain ); + chopNegativeDensities( subRegion ); } - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const &, - MeshLevel & mesh, - string_array const & regionNames ) + // synchronize + FieldIdentifiers fieldsToBeSync; + if( isThermal() ) { - // synchronize - FieldIdentifiers fieldsToBeSync; - if( isThermal() ) - { - fieldsToBeSync.addElementFields( { well::pressure::key(), - well::globalCompDensity::key(), - well::mixtureConnectionRate::key(), - well::temperature::key() }, - regionNames ); - } - else - { - fieldsToBeSync.addElementFields( { well::pressure::key(), - well::globalCompDensity::key(), - well::mixtureConnectionRate::key() }, - regionNames ); - } - CommunicationTools::getInstance().synchronizeFields( fieldsToBeSync, - mesh, - domain.getNeighbors(), - true ); - } ); - + fieldsToBeSync.addElementFields( { fields::well::pressure::key(), + fields::well::globalCompDensity::key(), + fields::well::connectionRate::key(), + fields::well::temperature::key() }, + getTargetRegionNames() ); + } + else + { + fieldsToBeSync.addElementFields( { fields::well::pressure::key(), + fields::well::globalCompDensity::key(), + fields::well::connectionRate::key() }, + getTargetRegionNames() ); + } + CommunicationTools::getInstance().synchronizeFields( fieldsToBeSync, + mesh, + domain.getNeighbors(), + true ); } -void CompositionalMultiphaseWell::chopNegativeDensities( DomainPartition & domain ) + + +void CompositionalMultiphaseWell::chopNegativeDensities( WellElementSubRegion & subRegion ) { integer const numComp = m_numComponents; - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { - - ElementRegionManager & elemManager = mesh.getElemManager(); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion & subRegion ) - { - arrayView1d< integer const > const & wellElemGhostRank = subRegion.ghostRank(); + arrayView1d< integer const > const & wellElemGhostRank = subRegion.ghostRank(); - arrayView2d< real64, compflow::USD_COMP > const & wellElemCompDens = - subRegion.getField< well::globalCompDensity >(); + arrayView2d< real64, compflow::USD_COMP > const & wellElemCompDens = + subRegion.getField< fields::well::globalCompDensity >(); - forAll< parallelDevicePolicy<> >( subRegion.size(), [=] GEOS_HOST_DEVICE ( localIndex const iwelem ) + forAll< parallelDevicePolicy<> >( subRegion.size(), [=] GEOS_HOST_DEVICE ( localIndex const iwelem ) + { + if( wellElemGhostRank[iwelem] < 0 ) + { + for( integer ic = 0; ic < numComp; ++ic ) { - if( wellElemGhostRank[iwelem] < 0 ) + // we allowed for some densities to be slightly negative in CheckSystemSolution + // if the new density is negative, chop back to zero + if( wellElemCompDens[iwelem][ic] < 0 ) { - for( integer ic = 0; ic < numComp; ++ic ) - { - // we allowed for some densities to be slightly negative in CheckSystemSolution - // if the new density is negative, chop back to zero - if( wellElemCompDens[iwelem][ic] < 0 ) - { - wellElemCompDens[iwelem][ic] = 0; - } - } + wellElemCompDens[iwelem][ic] = 0.0; } - } ); - } ); - + } + } } ); + } -void CompositionalMultiphaseWell::resetStateToBeginningOfStep( DomainPartition & domain ) +void CompositionalMultiphaseWell::resetStateToBeginningOfStep( DomainPartition & domain, + string const & meshBodyName, ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ) { - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) + + // get a reference to the primary variables on well elements + arrayView1d< real64 > const & wellElemPressure = + subRegion.getField< well::pressure >(); + arrayView1d< real64 const > const & wellElemPressure_n = + subRegion.getField< well::pressure_n >(); + wellElemPressure.setValues< parallelDevicePolicy<> >( wellElemPressure_n ); + + if( isThermal() ) { + // get a reference to the primary variables on well elements + arrayView1d< real64 > const & wellElemTemperature = + subRegion.getField< well::temperature >(); + arrayView1d< real64 const > const & wellElemTemperature_n = + subRegion.getField< well::temperature_n >(); + wellElemTemperature.setValues< parallelDevicePolicy<> >( wellElemTemperature_n ); + } + arrayView2d< real64, compflow::USD_COMP > const & wellElemGlobalCompDensity = + subRegion.getField< well::globalCompDensity >(); + arrayView2d< real64 const, compflow::USD_COMP > const & wellElemGlobalCompDensity_n = + subRegion.getField< well::globalCompDensity_n >(); + wellElemGlobalCompDensity.setValues< parallelDevicePolicy<> >( wellElemGlobalCompDensity_n ); + + arrayView1d< real64 > const & connRate = + subRegion.getField< well::connectionRate >(); + arrayView1d< real64 const > const & connRate_n = + subRegion.getField< well::connectionRate_n >(); + connRate.setValues< parallelDevicePolicy<> >( connRate_n ); + + + if( isWellOpen( ) ) + { + updateSubRegionState( -1.0, domain.getMeshBody( meshBodyName ), elemManager, subRegion ); + } + +} - ElementRegionManager & elemManager = mesh.getElemManager(); +void CompositionalMultiphaseWell::assembleWellConstraintTerms( real64 const & time_n, + real64 const & GEOS_UNUSED_PARAM( dt ), + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) +{ + GEOS_MARK_FUNCTION; + + + // the rank that owns the reference well element is responsible for the calculations below. + + if( !subRegion.isLocallyOwned() || !( getWellStatus() == WellControls::Status::OPEN )) + { + return; + } - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion & subRegion ) + if( isProducer() ) + { + forSubGroups< MinimumBHPConstraint, ProductionConstraint< PhaseVolumeRateConstraint >, ProductionConstraint< MassRateConstraint >, ProductionConstraint< VolumeRateConstraint > + >( [&]( auto & constraint ) { - // get a reference to the primary variables on well elements - arrayView1d< real64 > const & wellElemPressure = - subRegion.getField< well::pressure >(); - arrayView1d< real64 const > const & wellElemPressure_n = - subRegion.getField< well::pressure_n >(); - wellElemPressure.setValues< parallelDevicePolicy<> >( wellElemPressure_n ); - - if( isThermal() ) + // Need to use name since there could be multiple constraints of the same type + if( constraint.getName() == getCurrentConstraint()->getName()) { - // get a reference to the primary variables on well elements - arrayView1d< real64 > const & wellElemTemperature = - subRegion.getField< well::temperature >(); - arrayView1d< real64 const > const & wellElemTemperature_n = - subRegion.getField< well::temperature_n >(); - wellElemTemperature.setValues< parallelDevicePolicy<> >( wellElemTemperature_n ); + // found limiting constraint + constitutive::MultiFluidBase & fluidSeparator = getMultiFluidSeparator(); + integer isThermal = fluidSeparator.isThermal(); + integer const numComp = fluidSeparator.numFluidComponents(); + geos::internal::kernelLaunchSelectorCompThermSwitch( numComp, isThermal, [&] ( auto NC, auto ISTHERMAL ) + { + integer constexpr NUM_COMP = NC(); + integer constexpr IS_THERMAL = ISTHERMAL(); + + wellConstraintKernels::ConstraintHelper< NUM_COMP, IS_THERMAL >::assembleConstraintEquation( time_n, + *this, + constraint, + subRegion, + dofManager.getKey( wellElementDofName() ), + dofManager.rankOffset(), + localMatrix, + localRhs ); + } ); } - arrayView2d< real64, compflow::USD_COMP > const & wellElemGlobalCompDensity = - subRegion.getField< well::globalCompDensity >(); - arrayView2d< real64 const, compflow::USD_COMP > const & wellElemGlobalCompDensity_n = - subRegion.getField< well::globalCompDensity_n >(); - wellElemGlobalCompDensity.setValues< parallelDevicePolicy<> >( wellElemGlobalCompDensity_n ); - - arrayView1d< real64 > const & connRate = - subRegion.getField< well::mixtureConnectionRate >(); - arrayView1d< real64 const > const & connRate_n = - subRegion.getField< well::mixtureConnectionRate_n >(); - connRate.setValues< parallelDevicePolicy<> >( connRate_n ); - WellControls & wellControls = getWellControls( subRegion ); - - if( wellControls.isWellOpen( ) ) + } ); + } + else + { + forSubGroups< MaximumBHPConstraint, InjectionConstraint< PhaseVolumeRateConstraint >, InjectionConstraint< MassRateConstraint >, + InjectionConstraint< VolumeRateConstraint > + >( [&]( auto & constraint ) + { + if( constraint.getName() == getCurrentConstraint()->getName()) { - updateSubRegionState( subRegion ); + // found limiting constraint + constitutive::MultiFluidBase & fluidSeparator = getMultiFluidSeparator(); + integer isThermal = fluidSeparator.isThermal(); + integer const numComp = fluidSeparator.numFluidComponents(); + geos::internal::kernelLaunchSelectorCompThermSwitch( numComp, isThermal, [&] ( auto NC, auto ISTHERMAL ) + { + integer constexpr NUM_COMP = NC(); + integer constexpr IS_THERMAL = ISTHERMAL(); + + wellConstraintKernels::ConstraintHelper< NUM_COMP, IS_THERMAL >::assembleConstraintEquation( time_n, + *this, + constraint, + subRegion, + dofManager.getKey( wellElementDofName() ), + dofManager.rankOffset(), + localMatrix, + localRhs ); + } ); } } ); - } ); + } } -void CompositionalMultiphaseWell::assemblePressureRelations( real64 const & time_n, - real64 const & GEOS_UNUSED_PARAM( dt ), - DomainPartition const & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) +void CompositionalMultiphaseWell::assembleWellPressureRelations( real64 const & GEOS_UNUSED_PARAM( time_n ), + real64 const & GEOS_UNUSED_PARAM( dt ), + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) { GEOS_MARK_FUNCTION; - forDiscretizationOnMeshTargets ( domain.getMeshBodies(), [&] ( string const &, - MeshLevel const & mesh, - string_array const & regionNames ) + if( isWellOpen( ) && !m_keepVariablesConstantDuringInitStep ) { + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + MultiFluidBase const & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); + bool const isThermal = fluid.isThermal(); + // get the degrees of freedom, depth info, next welem index + string const wellDofKey = dofManager.getKey( wellElementDofName() ); + arrayView1d< globalIndex const > const & wellElemDofNumber = + subRegion.getReference< array1d< globalIndex > >( wellDofKey ); + arrayView1d< real64 const > const & wellElemGravCoef = + subRegion.getField< well::gravityCoefficient >(); + arrayView1d< localIndex const > const & nextWellElemIndex = + subRegion.getReference< array1d< localIndex > >( WellElementSubRegion::viewKeyStruct::nextWellElementIndexString() ); + + // get primary variables on well elements + arrayView1d< real64 const > const & wellElemPres = + subRegion.getField< well::pressure >(); + + // get total mass density on well elements (for potential calculations) + arrayView1d< real64 const > const & wellElemTotalMassDens = + subRegion.getField< well::totalMassDensity >(); + arrayView2d< real64 const, compflow::USD_FLUID_DC > const & dWellElemTotalMassDens = + subRegion.getField< well::dTotalMassDensity >(); + + // segment status + arrayView1d< integer const > const elemStatus =subRegion.getLocalWellElementStatus(); + + bool controlHasSwitched = false; + isothermalCompositionalMultiphaseBaseKernels:: + KernelLaunchSelectorCompTherm< compositionalMultiphaseWellKernels::PressureRelationKernel > + ( numFluidComponents(), + isThermal, + subRegion.size(), + dofManager.rankOffset(), + elemStatus, + wellElemDofNumber, + wellElemGravCoef, + nextWellElemIndex, + wellElemPres, + wellElemTotalMassDens, + dWellElemTotalMassDens, + controlHasSwitched, + localMatrix, + localRhs ); - ElementRegionManager const & elemManager = mesh.getElemManager(); + } - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion const & subRegion ) - { +} - WellControls & wellControls = getWellControls( subRegion ); - if( wellControls.isWellOpen( ) && !m_keepVariablesConstantDuringInitStep ) - { - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - MultiFluidBase const & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); - bool const isThermal = fluid.isThermal(); - // get the degrees of freedom, depth info, next welem index - string const wellDofKey = dofManager.getKey( wellElementDofName() ); - arrayView1d< globalIndex const > const & wellElemDofNumber = - subRegion.getReference< array1d< globalIndex > >( wellDofKey ); - arrayView1d< real64 const > const & wellElemGravCoef = - subRegion.getField< well::gravityCoefficient >(); - arrayView1d< localIndex const > const & nextWellElemIndex = - subRegion.getReference< array1d< localIndex > >( WellElementSubRegion::viewKeyStruct::nextWellElementIndexString() ); - - // get primary variables on well elements - arrayView1d< real64 const > const & wellElemPres = - subRegion.getField< well::pressure >(); - - // get total mass density on well elements (for potential calculations) - arrayView1d< real64 const > const & wellElemTotalMassDens = - subRegion.getField< well::totalMassDensity >(); - arrayView2d< real64 const, compflow::USD_FLUID_DC > const & dWellElemTotalMassDens = - subRegion.getField< well::dTotalMassDensity >(); - - // segment status - arrayView1d< integer const > const elemStatus =subRegion.getLocalWellElementStatus(); - - bool controlHasSwitched = false; - isothermalCompositionalMultiphaseBaseKernels:: - KernelLaunchSelectorCompTherm< compositionalMultiphaseWellKernels::PressureRelationKernel > - ( numFluidComponents(), - isThermal, - subRegion.size(), - dofManager.rankOffset(), - subRegion.isLocallyOwned(), - subRegion.getTopWellElementIndex(), - m_targetPhaseIndex, - wellControls, - time_n, // controls evaluated with BHP/rate of the beginning of step - elemStatus, - wellElemDofNumber, - wellElemGravCoef, - nextWellElemIndex, - wellElemPres, - wellElemTotalMassDens, - dWellElemTotalMassDens, - controlHasSwitched, - localMatrix, - localRhs ); - - if( controlHasSwitched ) - { - // TODO: move the switch logic into wellControls - // TODO: implement a more general switch when more then two constraints per well type are allowed - if( wellControls.getControl() == WellControls::Control::BHP ) - { - if( wellControls.isProducer() ) - { - wellControls.switchToPhaseRateControl( wellControls.getTargetPhaseRate( time_n ) ); - GEOS_LOG_LEVEL_RANK_0( logInfo::WellControl, - GEOS_FMT( "Control switch for well {} from BHP constraint to phase volumetric rate constraint", subRegion.getName() ) ); - } - else if( wellControls.getInputControl() == WellControls::Control::MASSRATE ) - { - wellControls.switchToMassRateControl( wellControls.getTargetMassRate( time_n ) ); - GEOS_LOG_LEVEL_RANK_0( logInfo::WellControl, - GEOS_FMT( "Control switch for well {} from BHP constraint to mass rate constraint", subRegion.getName()) ); - } - else - { - wellControls.switchToTotalRateControl( wellControls.getTargetTotalRate( time_n ) ); - GEOS_LOG_LEVEL_RANK_0( logInfo::WellControl, - GEOS_FMT( "Control switch for well {} from BHP constraint to total volumetric rate constraint", subRegion.getName()) ); - } - } - else - { - wellControls.switchToBHPControl( wellControls.getTargetBHP( time_n ) ); - GEOS_LOG_LEVEL_RANK_0( logInfo::WellControl, - GEOS_FMT( "Control switch for well {} from rate constraint to BHP constraint", subRegion.getName() ) ); - } - } +void CompositionalMultiphaseWell::saveState( WellElementSubRegion & subRegion ) +{ - // If a well is opened and then timestep is cut resulting in the well being shut, if the well is opened - // the well initialization code requires control type to by synced - integer owner = -1; - // Only subregion owner evaluates well control and control changes need to be broadcast to all ranks - if( subRegion.isLocallyOwned() ) - { - owner = MpiWrapper::commRank( MPI_COMM_GEOS ); - } - owner = MpiWrapper::max( owner ); - WellControls::Control wellControl = wellControls.getControl(); - MpiWrapper::broadcast( wellControl, owner ); - wellControls.setControl( wellControl ); - } + // get a reference to the primary variables on well elements + arrayView1d< real64 const > const & wellElemPressure = + subRegion.getField< fields::well::pressure >(); + arrayView2d< real64 const, compflow::USD_COMP > const & wellElemGlobalCompDensity = + subRegion.getField< fields::well::globalCompDensity >(); + arrayView1d< real64 const > const & wellElemTemperature = + subRegion.getField< fields::well::temperature >(); - } ); - } ); -} + arrayView1d< real64 > const & wellElemPressure_n = + subRegion.getField< fields::well::pressure_n >(); + wellElemPressure_n.setValues< parallelDevicePolicy<> >( wellElemPressure ); -void CompositionalMultiphaseWell::implicitStepSetup( real64 const & time_n, - real64 const & dt, - DomainPartition & domain ) -{ - WellSolverBase::implicitStepSetup( time_n, dt, domain ); + if( isThermal() ) + { - if( m_reservoirStatsAggregator ) - m_reservoirStatsAggregator->setDirty(); // TODO: is it useful? are timestep cut properly managed for this call? + arrayView1d< real64 > const & wellElemTemperature_n = + subRegion.getField< fields::well::temperature_n >(); + wellElemTemperature_n.setValues< parallelDevicePolicy<> >( wellElemTemperature ); + } - Group & meshBodies = domain.getMeshBodies(); - forDiscretizationOnMeshTargets ( meshBodies, [&] ( string const & meshBodyName, - MeshLevel & mesh, - string_array const & regionNames ) - { - ElementRegionManager & elemManager = mesh.getElemManager(); - MeshBody & meshBody = domain.getMeshBody( meshBodyName ); + arrayView2d< real64, compflow::USD_COMP > const & wellElemGlobalCompDensity_n = + subRegion.getField< fields::well::globalCompDensity_n >(); + wellElemGlobalCompDensity_n.setValues< parallelDevicePolicy<> >( wellElemGlobalCompDensity ); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion & subRegion ) - { + arrayView1d< real64 const > const & connRate = + subRegion.getField< fields::well::connectionRate >(); + arrayView1d< real64 > const & connRate_n = + subRegion.getField< fields::well::connectionRate_n >(); + connRate_n.setValues< parallelDevicePolicy<> >( connRate ); + + arrayView2d< real64 const, compflow::USD_PHASE > const wellElemPhaseVolFrac = + subRegion.getField< fields::well::phaseVolumeFraction >(); + arrayView2d< real64, compflow::USD_PHASE > const wellElemPhaseVolFrac_n = + subRegion.getField< fields::well::phaseVolumeFraction_n >(); + wellElemPhaseVolFrac_n.setValues< parallelDevicePolicy<> >( wellElemPhaseVolFrac ); + + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + MultiFluidBase const & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); + fluid.saveConvergedState(); - WellControls & wellControls = getWellControls( subRegion ); - if( wellControls.isWellOpen() ) - { - // get a reference to the primary variables on well elements - arrayView1d< real64 const > const & wellElemPressure = - subRegion.getField< fields::well::pressure >(); - arrayView2d< real64 const, compflow::USD_COMP > const & wellElemGlobalCompDensity = - subRegion.getField< fields::well::globalCompDensity >(); - arrayView1d< real64 const > const & wellElemTemperature = - subRegion.getField< fields::well::temperature >(); - - arrayView1d< real64 > const & wellElemPressure_n = - subRegion.getField< fields::well::pressure_n >(); - wellElemPressure_n.setValues< parallelDevicePolicy<> >( wellElemPressure ); - - if( isThermal() ) - { - arrayView1d< real64 > const & wellElemTemperature_n = - subRegion.getField< fields::well::temperature_n >(); - wellElemTemperature_n.setValues< parallelDevicePolicy<> >( wellElemTemperature ); - } - arrayView2d< real64, compflow::USD_COMP > const & wellElemGlobalCompDensity_n = - subRegion.getField< fields::well::globalCompDensity_n >(); - wellElemGlobalCompDensity_n.setValues< parallelDevicePolicy<> >( wellElemGlobalCompDensity ); +} - arrayView1d< real64 const > const & connRate = - subRegion.getField< fields::well::mixtureConnectionRate >(); - arrayView1d< real64 > const & connRate_n = - subRegion.getField< fields::well::mixtureConnectionRate_n >(); - connRate_n.setValues< parallelDevicePolicy<> >( connRate ); +void CompositionalMultiphaseWell::implicitStepSetup( real64 const & time_n, + real64 const & dt, + DomainPartition & domain, + string const & meshBodyName, + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion ) +{ + WellControls::implicitStepSetup( time_n, dt, domain, meshBodyName, elemManager, subRegion ); + if( m_reservoirStatsAggregator && !useSurfaceConditions() && !referenceReservoirRegion().empty() ) + { + m_reservoirStatsAggregator->setDirty(); + } - arrayView2d< real64 const, compflow::USD_PHASE > const wellElemPhaseVolFrac = - subRegion.getField< fields::well::phaseVolumeFraction >(); - arrayView2d< real64, compflow::USD_PHASE > const wellElemPhaseVolFrac_n = - subRegion.getField< fields::well::phaseVolumeFraction_n >(); - wellElemPhaseVolFrac_n.setValues< parallelDevicePolicy<> >( wellElemPhaseVolFrac ); - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - MultiFluidBase const & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); - fluid.saveConvergedState(); + if( isWellOpen() ) + { + // get a reference to the primary variables on well elements + arrayView1d< real64 const > const & wellElemPressure = + subRegion.getField< fields::well::pressure >(); + arrayView2d< real64 const, compflow::USD_COMP > const & wellElemGlobalCompDensity = + subRegion.getField< fields::well::globalCompDensity >(); + arrayView1d< real64 const > const & wellElemTemperature = + subRegion.getField< fields::well::temperature >(); + + arrayView1d< real64 > const & wellElemPressure_n = + subRegion.getField< fields::well::pressure_n >(); + wellElemPressure_n.setValues< parallelDevicePolicy<> >( wellElemPressure ); - validateWellConstraints( time_n, dt, subRegion ); + if( isThermal() ) + { + arrayView1d< real64 > const & wellElemTemperature_n = + subRegion.getField< fields::well::temperature_n >(); + wellElemTemperature_n.setValues< parallelDevicePolicy<> >( wellElemTemperature ); + } - precomputeReferenceConditions( time_n, meshBodies, meshBody, subRegion ); - updateSubRegionState( subRegion ); - } - } ) - ; - } ); + arrayView2d< real64, compflow::USD_COMP > const & wellElemGlobalCompDensity_n = + subRegion.getField< fields::well::globalCompDensity_n >(); + wellElemGlobalCompDensity_n.setValues< parallelDevicePolicy<> >( wellElemGlobalCompDensity ); + + arrayView1d< real64 const > const & connRate = + subRegion.getField< fields::well::connectionRate >(); + arrayView1d< real64 > const & connRate_n = + subRegion.getField< fields::well::connectionRate_n >(); + connRate_n.setValues< parallelDevicePolicy<> >( connRate ); + + arrayView2d< real64 const, compflow::USD_PHASE > const wellElemPhaseVolFrac = + subRegion.getField< fields::well::phaseVolumeFraction >(); + arrayView2d< real64, compflow::USD_PHASE > const wellElemPhaseVolFrac_n = + subRegion.getField< fields::well::phaseVolumeFraction_n >(); + wellElemPhaseVolFrac_n.setValues< parallelDevicePolicy<> >( wellElemPhaseVolFrac ); + + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + MultiFluidBase const & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); + fluid.saveConvergedState(); + + validateWellConstraints( time_n, dt, subRegion ); + precomputeReferenceConditions( time_n, domain.getMeshBodies(), domain.getMeshBody( meshBodyName ), subRegion ); + updateSubRegionState( time_n, domain.getMeshBody( meshBodyName ), elemManager, subRegion ); + } } void CompositionalMultiphaseWell::implicitStepComplete( real64 const & time_n, real64 const & dt, - DomainPartition & domain ) + WellElementSubRegion const & subRegion ) { - WellSolverBase::implicitStepComplete( time_n, dt, domain ); - - if( getLogLevel() > 0 ) - { - printRates( time_n, dt, domain ); - } + printRates( time_n, dt, subRegion ); } void CompositionalMultiphaseWell::printRates( real64 const & time_n, real64 const & dt, - DomainPartition & domain ) + WellElementSubRegion const & subRegion ) { - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { - ElementRegionManager & elemManager = mesh.getElemManager(); + integer const numPhase = m_numPhases; + integer const numComp = m_numComponents; + integer const numPerf = subRegion.getPerforationData()->size(); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion & subRegion ) - { - integer const numPhase = m_numPhases; - integer const numComp = m_numComponents; - integer const numPerf = subRegion.getPerforationData()->size(); - // control data - WellControls const & wellControls = getWellControls( subRegion ); - stdVector< double > compRate( numComp, 0.0 ); - if( m_writeCSV > 0 && wellControls.isWellOpen( ) ) - { - arrayView2d< real64 > const compPerfRate = subRegion.getPerforationData()->getField< fields::well::compPerforationRate >(); + stdVector< double > compRate( numComp, 0.0 ); + if( m_writeCSV > 0 && isWellOpen( ) ) + { + arrayView2d< real64 const > const & compPerfRate = subRegion.getPerforationData()->getField< fields::well::compPerforationRate >(); - // bring everything back to host, capture the scalars by reference - forAll< serialPolicy >( 1, [&numComp, - &numPerf, - compPerfRate, - &compRate] ( localIndex const ) - { - for( integer ic = 0; ic < numComp; ++ic ) - { - for( integer iperf = 0; iperf < numPerf; iperf++ ) - { - compRate[ic] += compPerfRate[iperf][ic]; - } - } - } ); - for( integer ic = 0; ic < numComp; ++ic ) + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [&numComp, + &numPerf, + compPerfRate, + &compRate] ( localIndex const ) + { + for( integer ic = 0; ic < numComp; ++ic ) + { + for( integer iperf = 0; iperf < numPerf; iperf++ ) { - compRate[ic] = MpiWrapper::sum( compRate[ic] ); + compRate[ic] += compPerfRate[iperf][ic]; } } + } ); + for( integer ic = 0; ic < numComp; ++ic ) + { + compRate[ic] = MpiWrapper::sum( compRate[ic] ); + } + } - // the rank that owns the reference well element is responsible for the calculations below. - if( !subRegion.isLocallyOwned() ) - { - return; - } + // the rank that owns the reference well element is responsible for the calculations below. + if( !subRegion.isLocallyOwned() ) + { + return; + } + + string const wellControlsName = getName(); - string const wellControlsName = wellControls.getName(); + // format: time,total_rate,total_vol_rate,phase0_vol_rate,phase1_vol_rate,... + std::ofstream outputFile; + if( m_writeCSV > 0 ) + { + outputFile.open( m_ratesOutputDir + "/" + wellControlsName + ".csv", std::ios_base::app ); + outputFile << time_n << "," << dt; + } - // format: time,total_rate,total_vol_rate,phase0_vol_rate,phase1_vol_rate,... - std::ofstream outputFile; - if( m_writeCSV > 0 ) + if( getWellStatus() == WellControls::Status::CLOSED ) + { + GEOS_LOG( GEOS_FMT( "{}: well is shut", wellControlsName ) ); + if( outputFile.is_open()) + { + // print all zeros in the rates file + outputFile << ",0.0,0.0,0.0"; + for( integer ip = 0; ip < numPhase; ++ip ) { - outputFile.open( m_ratesOutputDir + "/" + wellControlsName + ".csv", std::ios_base::app ); - outputFile << time_n << "," << dt; + outputFile << ",0.0"; } - - if( wellControls.getWellStatus() == WellControls::Status::CLOSED ) + for( integer ic = 0; ic < numComp; ++ic ) { - GEOS_LOG( GEOS_FMT( "{}: well is shut", wellControlsName ) ); - if( outputFile.is_open()) - { - // print all zeros in the rates file - outputFile << ",0.0,0.0,0.0"; - for( integer ip = 0; ip < numPhase; ++ip ) - { - outputFile << ",0.0"; - } - for( integer ic = 0; ic < numComp; ++ic ) - { - outputFile << ",0.0"; - } - outputFile << std::endl; - outputFile.close(); - } - return; + outputFile << ",0.0"; } + outputFile << std::endl; + outputFile.close(); + } + return; + } - localIndex const iwelemRef = subRegion.getTopWellElementIndex(); - string const massUnit = m_useMass ? "kg" : "mol"; - - // subRegion data - - arrayView1d< real64 const > const & connRate = - subRegion.getField< well::mixtureConnectionRate >(); - - integer const useSurfaceConditions = wellControls.useSurfaceConditions(); - - real64 const & currentBHP = - wellControls.getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentBHPString() ); - arrayView1d< real64 const > const & currentPhaseVolRate = - wellControls.getReference< array1d< real64 > >( CompositionalMultiphaseWell::viewKeyStruct::currentPhaseVolRateString() ); - real64 const & currentTotalVolRate = - wellControls.getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentTotalVolRateString() ); - - // bring everything back to host, capture the scalars by reference - forAll< serialPolicy >( 1, [&numPhase, - &numComp, - &useSurfaceConditions, - ¤tBHP, - connRate, - ¤tTotalVolRate, - currentPhaseVolRate, - &compRate, - &iwelemRef, - &wellControlsName, - &massUnit, - &outputFile] ( localIndex const ) + localIndex const iwelemRef = subRegion.getTopWellElementIndex(); + string const massUnit = m_useMass ? "kg" : "mol"; + + // subRegion data + + arrayView1d< real64 const > const & connRate = + subRegion.getField< well::connectionRate >(); + + integer const useSurfaceCond = useSurfaceConditions(); + + real64 const & currentBHP = + getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentBHPString() ); + arrayView1d< real64 const > const & currentPhaseVolRate = + getReference< array1d< real64 > >( CompositionalMultiphaseWell::viewKeyStruct::currentPhaseVolRateString() ); + real64 const & currentTotalVolRate = + getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentTotalVolRateString() ); + + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [&numPhase, + &numComp, + &useSurfaceCond, + ¤tBHP, + connRate, + ¤tTotalVolRate, + currentPhaseVolRate, + &compRate, + &iwelemRef, + &wellControlsName, + &massUnit, + &outputFile] ( localIndex const ) + { + string const conditionKey = useSurfaceCond ? "surface" : "reservoir"; + string const unitKey = useSurfaceCond ? "s" : "r"; + + real64 const currentTotalRate = connRate[iwelemRef]; + GEOS_LOG( GEOS_FMT( "{}: BHP (at the specified reference elevation): {} Pa", + wellControlsName, currentBHP ) ); + GEOS_LOG( GEOS_FMT( "{}: Total rate: {} {}/s; total {} volumetric rate: {} {}m3/s", + wellControlsName, currentTotalRate, massUnit, conditionKey, currentTotalVolRate, unitKey ) ); + for( integer ip = 0; ip < numPhase; ++ip ) + GEOS_LOG( GEOS_FMT( "{}: Phase {} {} volumetric rate: {} {}m3/s", + wellControlsName, ip, conditionKey, currentPhaseVolRate[ip], unitKey ) ); + if( outputFile.is_open()) + { + outputFile << "," << currentBHP; + outputFile << "," << currentTotalRate << "," << currentTotalVolRate; + for( integer ip = 0; ip < numPhase; ++ip ) { - string const conditionKey = useSurfaceConditions ? "surface" : "reservoir"; - string const unitKey = useSurfaceConditions ? "s" : "r"; - - real64 const currentTotalRate = connRate[iwelemRef]; - GEOS_LOG( GEOS_FMT( "{}: BHP (at the specified reference elevation): {} Pa", - wellControlsName, currentBHP ) ); - GEOS_LOG( GEOS_FMT( "{}: Total rate: {} {}/s; total {} volumetric rate: {} {}m3/s", - wellControlsName, currentTotalRate, massUnit, conditionKey, currentTotalVolRate, unitKey ) ); - for( integer ip = 0; ip < numPhase; ++ip ) - GEOS_LOG( GEOS_FMT( "{}: Phase {} {} volumetric rate: {} {}m3/s", - wellControlsName, ip, conditionKey, currentPhaseVolRate[ip], unitKey ) ); - if( outputFile.is_open()) - { - outputFile << "," << currentBHP; - outputFile << "," << currentTotalRate << "," << currentTotalVolRate; - for( integer ip = 0; ip < numPhase; ++ip ) - { - outputFile << "," << currentPhaseVolRate[ip]; - } - for( integer ic = 0; ic < numComp; ++ic ) - { - outputFile << "," << compRate[ic]; - } - outputFile << std::endl; - outputFile.close(); - } - } ); - } ); + outputFile << "," << currentPhaseVolRate[ip]; + } + for( integer ic = 0; ic < numComp; ++ic ) + { + outputFile << "," << compRate[ic]; + } + outputFile << std::endl; + outputFile.close(); + } } ); + } -REGISTER_CATALOG_ENTRY( PhysicsSolverBase, CompositionalMultiphaseWell, string const &, Group * const ) -} // namespace geos + + +} // namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.hpp index 677ea19d64c..b40a11f0ee5 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.hpp @@ -24,9 +24,11 @@ #include "constitutive/fluid/multifluid/Layouts.hpp" #include "constitutive/relativePermeability/Layouts.hpp" #include "mesh/MeshLevel.hpp" -#include "physicsSolvers/fluidFlow/wells/WellSolverBase.hpp" + #include "physicsSolvers/fluidFlow/CompositionalMultiphaseBase.hpp" +#include "physicsSolvers/fluidFlow/wells/WellConstraintsBase.hpp" +#include "physicsSolvers/fluidFlow/wells/WellControls.hpp" namespace geos { @@ -46,7 +48,7 @@ class StatsAggregator; * * A compositional multiphase well solver */ -class CompositionalMultiphaseWell : public WellSolverBase +class CompositionalMultiphaseWell : public WellControls { public: @@ -64,8 +66,8 @@ class CompositionalMultiphaseWell : public WellSolverBase /// deleted copy constructor CompositionalMultiphaseWell( CompositionalMultiphaseWell const & ) = delete; - /// default move constructor - CompositionalMultiphaseWell( CompositionalMultiphaseWell && ) = default; + /// deleted move constructor + CompositionalMultiphaseWell( CompositionalMultiphaseWell && ) = delete; /// deleted assignment operator CompositionalMultiphaseWell & operator=( CompositionalMultiphaseWell const & ) = delete; @@ -76,66 +78,180 @@ class CompositionalMultiphaseWell : public WellSolverBase /** * @brief default destructor */ - virtual ~CompositionalMultiphaseWell() override = default; + virtual ~CompositionalMultiphaseWell() override; + + compositionalMultiphaseStatistics::StatsAggregator * getStatsAggregator() { return m_reservoirStatsAggregator.get(); } + void setReservoirStatsAggregator( std::unique_ptr< compositionalMultiphaseStatistics::StatsAggregator > aggregator ); + + virtual void registerWellDataOnMesh( WellElementSubRegion & subRegion ) override; /** - * @brief name of the node manager in the object catalog - * @return string that contains the catalog name to generate a new NodeManager object through the object catalog. + * @defgroup WellManager Interface Functions + * + * These functions provide the primary interface that is required for derived classes + * The "Well" versions apply to individual well subRegions, whereas the others apply to all wells */ - static string catalogName() { return "CompositionalMultiphaseWell"; } + /**@{*/ /** - * @copydoc PhysicsSolverBase::getCatalogName() + * * @brief Initialize well for the beginning of a simulation or restart + * @param domain the domain + * @param mesh the mesh level + * @param subRegion the well subRegion */ - string getCatalogName() const override { return catalogName(); } + virtual void initializeWell( DomainPartition & domain, Group & meshBodies, string const & meshBodyName, MeshLevel & mesh, WellElementSubRegion & subRegion, real64 const & time_n ) override; + + virtual void initializeWellPostInitialConditionsPreSubGroups( WellElementSubRegion & subRegion ) override; - virtual void registerDataOnMesh( Group & meshBodies ) override; + virtual bool isCompositional() const override { return true; } + + + /** + * @copydoc WellControls::assembleWellAccumulationTerms() + */ + virtual void assembleWellAccumulationTerms( real64 const & time, + real64 const & dt, + WellElementSubRegion & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) override; + /** + * @copydoc WellControls::assembleWellPressureRelations() + */ + virtual void assembleWellPressureRelations( real64 const & time_n, + real64 const & dt, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) override; + /** + * @copydoc WellControls::assembleWellConstraintTerms() + */ + virtual void assembleWellConstraintTerms( real64 const & time_n, + real64 const & dt, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) override; + /** + * @copydoc WellControls::computeWellPerforationRates() + */ + virtual void computeWellPerforationRates( real64 const & time_n, + real64 const & GEOS_UNUSED_PARAM( dt ), + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion ) override; /** - * @defgroup Solver Interface Functions + * @copydoc WellControls::assembleFluxTerms() + */ + virtual void assembleWellFluxTerms( real64 const & time, + real64 const & dt, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) override; + /**@}*/ + /** + * @defgroup Well Interface Functions - required by WellManager and WellNewtonSolver * * These functions provide the primary interface that is required for derived classes + * The "Well" versions apply to individual well subRegions */ /**@{*/ + /** + * @copydoc WellControls::calculateResidualNorm() + */ + + virtual array1d< real64 > + calculateLocalWellResidualNorm( real64 const & time_n, + real64 const & dt, + NonlinearSolverParameters const & nonlinearSolverParameters, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localRhs ) override; - virtual real64 - calculateResidualNorm( real64 const & time_n, - real64 const & dt, - DomainPartition const & domain, - DofManager const & dofManager, - arrayView1d< real64 const > const & localRhs ) override; virtual real64 - scalingForSystemSolution( DomainPartition & domain, - DofManager const & dofManager, - arrayView1d< real64 const > const & localSolution ) override; + calculateWellResidualNorm( real64 const & time_n, + real64 const & dt, + NonlinearSolverParameters const & nonlinearSolverParameters, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localRhs ) override; - virtual bool - checkSystemSolution( DomainPartition & domain, - DofManager const & dofManager, - arrayView1d< real64 const > const & localSolution, - real64 const scalingFactor ) override; + /** + * @copydoc WellControls::scalingForSystemSolution() + */ + real64 scalingForLocalSystemSolution ( WellElementSubRegion & subRegion, + DofManager const & dofManager, + real64 & maxDeltaPres, + real64 & maxDeltaCompDens, + real64 & maxDeltaTemp, + real64 & minPresScalingFactor, + real64 & minCompDensScalingFactor, + real64 & minTempScalingFactor, + arrayView1d< real64 const > const & localSolution ); + + virtual real64 scalingForWellSystemSolution( WellElementSubRegion & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution ) override; - virtual void - applySystemSolution( DofManager const & dofManager, - arrayView1d< real64 const > const & localSolution, - real64 const scalingFactor, - real64 const dt, - DomainPartition & domain ) override; + /** + * @copydoc WellControls::checkSystemSolution() + */ + virtual bool + checkWellSystemSolution( WellElementSubRegion & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution, + real64 const scalingFactor, + real64 & minPressure, + real64 & minDensity, + real64 & minTotalDensity, + ElementsReporterBuffer & negPressureIds, + ElementsReporterBuffer & negDensityIds, + ElementsReporterBuffer & negTotalDensityIds ) override; - virtual void - resetStateToBeginningOfStep( DomainPartition & domain ) override; + /** + * @copydoc WellControls::applyWellSystemSolution() + */ virtual void - implicitStepSetup( real64 const & time, - real64 const & dt, - DomainPartition & domain ) override; + applyWellSystemSolution( DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution, + real64 const scalingFactor, + real64 const dt, + DomainPartition & domain, + MeshLevel & mesh, + WellElementSubRegion & subRegion ) override; + + virtual void applyWellBoundaryConditions( real64 const time_n, + real64 const dt, + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion, + DofManager const & dofManager, + arrayView1d< real64 > const & localRhs, + CRSMatrixView< real64, globalIndex const > const & localMatrix ) override; + + + virtual void resetStateToBeginningOfStep( DomainPartition & domain, + string const & meshBodyName, ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ) override; + + virtual void implicitStepSetup( real64 const & time_n, + real64 const & GEOS_UNUSED_PARAM( dt ), + DomainPartition & domain, + string const & meshBodyName, + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion ) override; virtual void implicitStepComplete( real64 const & time, real64 const & dt, - DomainPartition & domain ) override; + WellElementSubRegion const & subRegion ) override; + + virtual void printRates( real64 const & time_n, + real64 const & dt, + WellElementSubRegion const & subRegion ) override; /**@}*/ @@ -147,7 +263,6 @@ class CompositionalMultiphaseWell : public WellSolverBase /** * @brief Recompute the volumetric rates that are used in the well constraints - * @param elemManager the well region manager containing the well * @param subRegion the well subregion containing all the primary and dependent fields */ void updateVolRatesForConstraint( WellElementSubRegion const & subRegion ); @@ -166,6 +281,25 @@ class CompositionalMultiphaseWell : public WellSolverBase */ void updateFluidModel( WellElementSubRegion & subRegion ); + /** + * @brief Update well separator using current values of pressure and composition at the reference + * element + * @param elemManager the element region manager + + */ + void updateSeparator( real64 time_n, + MeshBody const & meshBody, + ElementRegionManager const & elemManager, + WellElementSubRegion & subRegion ); + + /** + * @brief Calculate well rates at reference element + * @param subRegion the well subregion containing all the primary and dependent fields + * @param targetIndex the targetIndex of the subRegion + */ + + void calculateReferenceElementRates( WellElementSubRegion & subRegion ); + /** * @brief Recompute phase volume fractions (saturations) from constitutive and primary variables * @param subRegion the well subregion containing all the primary and dependent fields @@ -179,20 +313,18 @@ class CompositionalMultiphaseWell : public WellSolverBase */ void updateTotalMassDensity( WellElementSubRegion & subRegion ) const; - /** - * @brief Recompute the perforation rates for all the wells - * @param domain the domain containing the mesh and fields - */ - virtual void computePerforationRates( real64 const & time_n, - real64 const & dt, DomainPartition & domain ) override; - /** * @brief Recompute all dependent quantities from primary variables (including constitutive models) * @param subRegion the well subregion containing all the primary and dependent fields */ - virtual void updateState( DomainPartition & domain ) override; + virtual real64 updateWellState( MeshBody const & meshBody, + ElementRegionManager const & elemManager, + WellElementSubRegion & subRegion ) override; - virtual real64 updateSubRegionState( WellElementSubRegion & subRegion ) override; + virtual real64 updateSubRegionState( real64 time_n, + MeshBody const & meshBody, + ElementRegionManager const & elemManager, + WellElementSubRegion & subRegion ) override; virtual string wellElementDofName() const override { return viewKeyStruct::dofFieldString(); } @@ -204,61 +336,16 @@ class CompositionalMultiphaseWell : public WellSolverBase integer useTotalMassEquation() const { return m_useTotalMassEquation; } - /** - * @brief assembles the flux terms for all connections between well elements - * @param time_n previous time value - * @param dt time step - * @param domain the physical domain object - * @param dofManager degree-of-freedom manager associated with the linear system - * @param matrix the system matrix - * @param rhs the system right-hand side vector - */ - - virtual void assembleFluxTerms( real64 const & time_n, - real64 const & dt, - DomainPartition & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs )override; - /** - * @brief assembles the accumulation term for all the well elements - * @param domain the physical domain object - * @param dofManager degree-of-freedom manager associated with the linear system - * @param matrix the system matrix - * @param rhs the system right-hand side vector - */ - virtual void assembleAccumulationTerms( real64 const & time_n, - real64 const & dt, - DomainPartition & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) override; - - /** - * @brief assembles the pressure relations at all connections between well elements except at the well head - * @param time_n time at the beginning of the time step - * @param dt the time step size - * @param domain the physical domain object - * @param dofManager degree-of-freedom manager associated with the linear system - * @param matrix the system matrix - * @param rhs the system right-hand side vector - */ - virtual void assemblePressureRelations( real64 const & time_n, - real64 const & dt, - DomainPartition const & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) override; - /** * @brief Sets all the negative component densities (if any) to zero. - * @param domain the physical domain object + * @param subRegion the well subregion containing all the primary and dependent fields */ - void chopNegativeDensities( DomainPartition & domain ); + void chopNegativeDensities( WellElementSubRegion & subRegion ); - struct viewKeyStruct : WellSolverBase::viewKeyStruct + + struct viewKeyStruct : WellControls::viewKeyStruct { - static constexpr char const * dofFieldString() { return "compositionalWellVars"; } + static constexpr char const * dofFieldString() { return "wellVars"; } // inputs @@ -278,39 +365,21 @@ class CompositionalMultiphaseWell : public WellSolverBase static constexpr char const * allowLocalCompDensChoppingString() { return CompositionalMultiphaseBase::viewKeyStruct::allowLocalCompDensChoppingString(); } - // control data (not registered on the mesh) - - static constexpr char const * massDensityString() { return "massDensity";} - - static constexpr char const * currentBHPString() { return "currentBHP"; } - static constexpr char const * dCurrentBHPString() { return "dCurrentBHP"; } - - static constexpr char const * dCurrentBHP_dPresString() { return "dCurrentBHP_dPres"; } - static constexpr char const * dCurrentBHP_dCompDensString() { return "dCurrentBHP_dCompDens"; } - - static constexpr char const * currentPhaseVolRateString() { return "currentPhaseVolumetricRate"; } - static constexpr char const * dCurrentPhaseVolRateString() { return "dCurrentPhaseVolumetricRate"; } - - - static constexpr char const * dCurrentPhaseVolRate_dPresString() { return "dCurrentPhaseVolumetricRate_dPres"; } - - static constexpr char const * dCurrentPhaseVolRate_dCompDensString() { return "dCurrentPhaseVolumetricRate_dCompDens"; } - - static constexpr char const * dCurrentPhaseVolRate_dRateString() { return "dCurrentPhaseVolumetricRate_dRate"; } - - static constexpr char const * currentTotalVolRateString() { return "currentTotalVolumetricRate"; } - static constexpr char const * dCurrentTotalVolRateString() { return "dCurrentTotalVolumetricRate"; } - - static constexpr char const * currentMassRateString() { return "currentMassRate"; } - - static constexpr char const * dCurrentTotalVolRate_dPresString() { return "dCurrentTotalVolumetricRate_dPres"; } - - static constexpr char const * dCurrentTotalVolRate_dCompDensString() { return "dCurrentTotalVolumetricRate_dCompDens"; } - static constexpr char const * dCurrentTotalVolRate_dRateString() { return "dCurrentTotalVolumetricRate_dRate"; } } viewKeysCompMultiphaseWell; + /** + * @brief Checks fluild model compatibility and validity + * @param[in] fluid the fluid to check + * @param[in] referenceFluid the reference fluid model + * @detail + * This function will produce an error if one of the well constitutive models + * is incompatible with the corresponding models in reservoir + * regions connected to that particular well. + */ + void validateFluidModel( constitutive::MultiFluidBase const & fluid, constitutive::MultiFluidBase const & referenceFluid )const; + protected: virtual void postInputInitialization() override; @@ -319,29 +388,9 @@ class CompositionalMultiphaseWell : public WellSolverBase virtual void initializePostInitialConditionsPreSubGroups() override; - virtual void postRestartInitialization() override final; - /* - * @brief Utility function that checks the consistency of the constitutive models - * @param[in] domain the domain partition - * @detail - * This function will produce an error if one of the well constitutive models - * is incompatible with the corresponding models in reservoir - * regions connected to that particular well. - */ - void validateConstitutiveModels( DomainPartition const & domain ) const; + void saveState( WellElementSubRegion & subRegion ); + virtual void postRestartInitialization( ) override; - /** - * @brief Checks if the WellControls parameters are within the fluid tables ranges - * @param fluid the fluid to check - */ - void validateWellControlsForFluid( WellControls const & wellControls, - constitutive::MultiFluidBase const & fluid ) const; - - /** - * @brief Checks injection streams for validity (compositions sum to one) - * @param subRegion the well subRegion - */ - void validateInjectionStreams( WellElementSubRegion const & subRegion ) const; /** * @brief Make sure that the well constraints are compatible @@ -357,11 +406,10 @@ class CompositionalMultiphaseWell : public WellSolverBase /** * @brief Create well separator */ - void createSeparator(); + virtual void createSeparator( WellElementSubRegion & subRegion ) override; + /// optional statistics aggregator to get the average pressure of simulated region + std::unique_ptr< compositionalMultiphaseStatistics::StatsAggregator > m_reservoirStatsAggregator; - void printRates( real64 const & time_n, - real64 const & dt, - DomainPartition & domain ) override; private: @@ -371,11 +419,6 @@ class CompositionalMultiphaseWell : public WellSolverBase real64 temperature; }; - /** - * @brief Initialize all the primary and secondary variables in all the wells - * @param domain the domain containing the well manager to access individual wells - */ - void initializeWells( DomainPartition & domain, real64 const & time_n ) override; virtual void setConstitutiveNames( ElementSubRegionBase & subRegion ) const override; @@ -386,8 +429,6 @@ class CompositionalMultiphaseWell : public WellSolverBase ReferenceConditions getReferenceConditions( WellElementSubRegion const & subRegion ); - /// flag indicating whether mass or molar formulation should be used - integer m_useMass; /// flag indicating whether total mass equation should be used integer m_useTotalMassEquation; @@ -413,11 +454,6 @@ class CompositionalMultiphaseWell : public WellSolverBase /// flag indicating whether local (cell-wise) chopping of negative compositions is allowed integer m_allowCompDensChopping; - /// index of the target phase, used to impose the phase rate constraint - localIndex m_targetPhaseIndex; - - /// optional statistics aggregator to get the average pressure of simulated region - std::unique_ptr< compositionalMultiphaseStatistics::StatsAggregator > m_reservoirStatsAggregator; }; diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWellFields.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWellFields.hpp index 3ca423cd7ac..4abd716ffc4 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWellFields.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWellFields.hpp @@ -58,21 +58,7 @@ DECLARE_FIELD( globalCompDensity_n, WRITE_AND_READ, "Global component density at the previous converged time step" ); -DECLARE_FIELD( mixtureConnectionRate, - "wellElementMixtureConnectionRate", - array1d< real64 >, - 0, - LEVEL_0, - WRITE_AND_READ, - "Mixture connection rate" ); -DECLARE_FIELD( mixtureConnectionRate_n, - "wellElementMixtureConnectionRate_n", - array1d< real64 >, - 0, - NOPLOT, - WRITE_AND_READ, - "Mixture connection rate at the previous converged time step" ); DECLARE_FIELD( globalCompFraction, "globalCompFraction", diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.cpp index b2bbfabfe9b..7da4cd4d891 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.cpp @@ -32,6 +32,7 @@ #include "mesh/PerforationFields.hpp" #include "mesh/mpiCommunications/CommunicationTools.hpp" #include "physicsSolvers/LogLevelsInfo.hpp" +#include "physicsSolvers/PhysicsSolverManager.hpp" #include "physicsSolvers/fluidFlow/wells/LogLevelsInfo.hpp" #include "physicsSolvers/fluidFlow/SinglePhaseBase.hpp" #include "physicsSolvers/fluidFlow/SolutionCheckHelpers.hpp" @@ -39,14 +40,21 @@ #include "physicsSolvers/fluidFlow/wells/WellFields.hpp" #include "physicsSolvers/fluidFlow/wells/WellSolverBaseFields.hpp" #include "physicsSolvers/fluidFlow/wells/SinglePhaseWellFields.hpp" -#include "physicsSolvers/fluidFlow/wells/WellControls.hpp" + +#include "physicsSolvers/fluidFlow/wells/WellInjectionConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellProductionConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellBHPConstraints.hpp" +#include "physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellMassRateConstraint.hpp" + #include "physicsSolvers/fluidFlow/wells/kernels/SinglePhaseWellKernels.hpp" #include "physicsSolvers/fluidFlow/wells/kernels/ThermalSinglePhaseWellKernels.hpp" #include "physicsSolvers/fluidFlow/wells/kernels/SinglePhasePerforationFluxKernels.hpp" #include "physicsSolvers/fluidFlow/kernels/singlePhase/FluidUpdateKernel.hpp" #include "physicsSolvers/fluidFlow/kernels/singlePhase/SolutionCheckKernel.hpp" #include "physicsSolvers/fluidFlow/SinglePhaseStatisticsAggregator.hpp" - +#include "physicsSolvers/fluidFlow/wells/kernels/SinglePhaseWellConstraintKernels.hpp" namespace geos { @@ -68,9 +76,45 @@ SinglePhaseBase const & getFlowSolver( SinglePhaseWell const & wellSolver ) return wellSolver.getParent().getGroup< SinglePhaseBase >( wellSolver.getFlowSolverName() ); } +real64 getBHPReferenceGravityCoef( SinglePhaseWell const & wellSolver, + ConstraintSourceId const source ) +{ + real64 refGravCoef = 0.0; + bool foundConstraint = false; + + if( wellSolver.isProducer() ) + { + wellSolver.forSubGroups< MinimumBHPConstraint >( [&]( WellConstraintBase const & constraint ) + { + if( constraint.isConstraintActive() && constraint.getConstraintSource() == source ) + { + refGravCoef = static_cast< MinimumBHPConstraint const & >( constraint ).getReferenceGravityCoef(); + foundConstraint = true; + } + } ); + } + else + { + wellSolver.forSubGroups< MaximumBHPConstraint >( [&]( WellConstraintBase const & constraint ) + { + if( constraint.isConstraintActive() && constraint.getConstraintSource() == source ) + { + refGravCoef = static_cast< MaximumBHPConstraint const & >( constraint ).getReferenceGravityCoef(); + foundConstraint = true; + } + } ); + } + + GEOS_THROW_IF( !foundConstraint, + GEOS_FMT( "Could not find active BHP constraint for well {}", wellSolver.getName() ), + InputError ); + + return refGravCoef; +} + SinglePhaseWell::SinglePhaseWell( const string & name, Group * const parent ): - WellSolverBase( name, parent ) + WellControls( name, parent ) { m_numDofPerWellElement = 2; m_numDofPerResElement = 1; @@ -83,64 +127,59 @@ SinglePhaseWell::SinglePhaseWell( const string & name, setDescription( "Flag indicating if negative pressure is allowed" ); } -void SinglePhaseWell::registerDataOnMesh( Group & meshBodies ) +SinglePhaseWell::~SinglePhaseWell() = default; + +void SinglePhaseWell::registerWellDataOnMesh( WellElementSubRegion & subRegion ) { - WellSolverBase::registerDataOnMesh( meshBodies ); + WellControls::registerDataOnMesh( subRegion ); + setConstitutiveNames ( subRegion ); - // loop over the wells - forDiscretizationOnMeshTargets( meshBodies, [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) + if( m_referenceFluidModelName.empty() ) { + m_referenceFluidModelName = getConstitutiveName< SingleFluidBase >( subRegion ); + } + subRegion.registerField< well::pressure >( getName() ); + subRegion.registerField< well::pressure_n >( getName() ); - ElementRegionManager & elemManager = mesh.getElemManager(); - - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion & subRegion ) - { - subRegion.registerField< well::connectionRate_n >( getName() ); - subRegion.registerField< well::connectionRate >( getName() ); - - PerforationData & perforationData = *subRegion.getPerforationData(); - perforationData.registerField< well::perforationRate >( getName() ); - perforationData.registerField< well::dPerforationRate >( getName() ). - reference().resizeDimension< 1, 2 >( 2, 2 ); - if( isThermal() ) - { - perforationData.registerField< well::energyPerforationFlux >( getName() ); - perforationData.registerField< well::dEnergyPerforationFlux >( getName() ). - reference().resizeDimension< 1, 2 >( 2, 2 ); - } - - WellControls & wellControls = getWellControls( subRegion ); - wellControls.registerWrapper< real64 >( viewKeyStruct::currentBHPString() ); + subRegion.registerField< well::temperature >( getName() ); + if( isThermal() ) + { + subRegion.registerField< well::temperature_n >( getName() ); + } + subRegion.registerField< well::connectionRate_n >( getName() ); + subRegion.registerField< well::connectionRate >( getName() ); + subRegion.registerField< well::gravityCoefficient >( getName() ); + PerforationData & perforationData = *subRegion.getPerforationData(); + perforationData.registerField< well::gravityCoefficient >( getName() ); + + perforationData.registerField< well::perforationRate >( getName() ); + perforationData.registerField< well::dPerforationRate >( getName() ). + reference().resizeDimension< 1, 2 >( 2, 2 ); + if( isThermal() ) + { + perforationData.registerField< well::energyPerforationFlux >( getName() ); + perforationData.registerField< well::dEnergyPerforationFlux >( getName() ). + reference().resizeDimension< 1, 2 >( 2, 2 ); + perforationData.registerField< well::gravityCoefficient >( getName() ); + } - wellControls.registerWrapper< array1d< real64 > >( viewKeyStruct::dCurrentBHPString() ). - setSizedFromParent( 0 ). - reference().resizeDimension< 0 >( 2 + isThermal() ); // dP, dT , dQ + registerWrapper< real64 >( viewKeyStruct::currentBHPString() ); + registerWrapper< real64 >( viewKeyStruct::currentVolRateString() ); - wellControls.registerWrapper< real64 >( viewKeyStruct::currentVolRateString() ); - wellControls.registerWrapper< array1d< real64 > >( viewKeyStruct::dCurrentVolRateString() ). - setSizedFromParent( 0 ). - reference().resizeDimension< 0 >( 2 + isThermal() ); // dP, dT, dQ + // write rates output header + if( m_writeCSV > 0 && subRegion.isLocallyOwned()) + { + string const fileName = GEOS_FMT( "{}/{}.csv", m_ratesOutputDir, getName() ); + string const conditionKey = useSurfaceConditions() ? "surface" : "reservoir"; + string const unitKey = useSurfaceConditions() ? "s" : "r"; + // format: time,bhp,total_rate,total_vol_rate + makeDirsForPath( m_ratesOutputDir ); + GEOS_LOG( GEOS_FMT( "{}: Rates CSV generated at {}", getName(), fileName ) ); + std::ofstream outputFile( fileName ); + outputFile << "Time [s],BHP [Pa],Total rate [kg/s],Total " << conditionKey << " volumetric rate ["< 0 && subRegion.isLocallyOwned()) - { - string const fileName = GEOS_FMT( "{}/{}.csv", m_ratesOutputDir, wellControls.getName() ); - integer const useSurfaceConditions = wellControls.useSurfaceConditions(); - string const conditionKey = useSurfaceConditions ? "surface" : "reservoir"; - string const unitKey = useSurfaceConditions ? "s" : "r"; - // format: time,bhp,total_rate,total_vol_rate - makeDirsForPath( m_ratesOutputDir ); - GEOS_LOG( GEOS_FMT( "{}: Rates CSV generated at {}", getName(), fileName ) ); - std::ofstream outputFile( fileName ); - outputFile << "Time [s],BHP [Pa],Total rate [kg/s],Total " << conditionKey << " volumetric rate ["<( PhysicsSolverManager::viewKeyStruct::gravityVectorString() )); + + // setup fluid model + createSeparator( subRegion ); +} +void SinglePhaseWell::initializePostInitialConditionsPreSubGroups() +{ + WellControls::initializePostInitialConditionsPreSubGroups(); +} +void SinglePhaseWell::postRestartInitialization( ) +{ + // setup fluid separator + constitutive::SingleFluidBase & fluidSeparator = getSingleFluidSeparator(); + fluidSeparator.allocateConstitutiveData( *this, 1 ); + fluidSeparator.resize( 1 ); + +} +void SinglePhaseWell::createSeparator( WellElementSubRegion & subRegion ) +{ + + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + SingleFluidBase & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); + // setup fluid separator + + string const fluidSeparatorName = getName() + "Separator"; + std::unique_ptr< constitutive::ConstitutiveBase > fluidSeparatorPtr = fluid.deliverClone( fluidSeparatorName, this ); + fluidSeparatorPtr->allocateConstitutiveData( *this, 1 ); + fluidSeparatorPtr->resize( 1 ); + setFluidSeparator( std::move( fluidSeparatorPtr )); - WellControls::Control currentControl = wellControls.getControl(); - real64 const targetTotalRate = wellControls.getTargetTotalRate( time_n ); - real64 const targetPhaseRate = wellControls.getTargetPhaseRate( time_n ); - GEOS_THROW_IF( currentControl == WellControls::Control::PHASEVOLRATE, - "Phase rate control is not available for SinglePhaseWell", - InputError, wellControls.getDataContext() ); - // The user always provides positive rates, but these rates are later multiplied by -1 internally for producers - GEOS_THROW_IF( ( ( wellControls.isInjector() && targetTotalRate < 0.0 ) || - ( wellControls.isProducer() && targetTotalRate > 0.0) ), - "Target total rate cannot be negative", - InputError, wellControls.getDataContext() ); - GEOS_THROW_IF( !isZero( targetPhaseRate ), - "Target phase rate cannot be used for SinglePhaseWell", - InputError, wellControls.getDataContext() ); } void SinglePhaseWell::updateBHPForConstraint( WellElementSubRegion & subRegion ) @@ -199,7 +260,6 @@ void SinglePhaseWell::updateBHPForConstraint( WellElementSubRegion & subRegion ) return; } - localIndex const iwelemRef = subRegion.getTopWellElementIndex(); // subRegion data @@ -216,47 +276,29 @@ void SinglePhaseWell::updateBHPForConstraint( WellElementSubRegion & subRegion ) arrayView2d< real64 const, constitutive::singlefluid::USD_FLUID > const & dens = fluid.density(); arrayView3d< real64 const, constitutive::singlefluid::USD_FLUID_DER > const & dDens = fluid.dDensity(); - // control data - - WellControls & wellControls = getWellControls( subRegion ); - string const wellControlsName = wellControls.getName(); - real64 const & refGravCoef = wellControls.getReferenceGravityCoef(); - - real64 & currentBHP = - wellControls.getReference< real64 >( SinglePhaseWell::viewKeyStruct::currentBHPString() ); - arrayView1d< real64 > const & dCurrentBHP = - wellControls.getReference< array1d< real64 > >( SinglePhaseWell::viewKeyStruct::dCurrentBHPString() ); - - geos::internal::kernelLaunchSelectorThermalSwitch( isThermal(), [&] ( auto ISTHERMAL ) + real64 const refGravCoef = getBHPReferenceGravityCoef( *this, ConstraintSourceId::USER ); + real64 & currentBHP = getReference< real64 >( SinglePhaseWell::viewKeyStruct::currentBHPString() ); + + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [pres, + dens, + dDens, + wellElemGravCoef, + ¤tBHP, + &iwelemRef, + &refGravCoef] ( localIndex const ) { - integer constexpr IS_THERMAL = ISTHERMAL(); - // bring everything back to host, capture the scalars by reference - forAll< serialPolicy >( 1, [pres, - dens, - dDens, - wellElemGravCoef, - ¤tBHP, - &dCurrentBHP, - &iwelemRef, - &refGravCoef] ( localIndex const ) - { - real64 const diffGravCoef = refGravCoef - wellElemGravCoef[iwelemRef]; - currentBHP = pres[iwelemRef] + dens[iwelemRef][0] * diffGravCoef; - dCurrentBHP[DerivOffset::dP] = 1.0 + dDens[iwelemRef][0][DerivOffset::dP] *diffGravCoef; - if constexpr ( IS_THERMAL ) - { - dCurrentBHP[DerivOffset::dT] = dDens[iwelemRef][0][DerivOffset::dT] * diffGravCoef; - } - } ); + real64 const diffGravCoef = refGravCoef - wellElemGravCoef[iwelemRef]; + currentBHP = pres[iwelemRef] + dens[iwelemRef][0] * diffGravCoef; } ); GEOS_LOG_LEVEL_BY_RANK( logInfo::WellControl, GEOS_FMT( "{}: The BHP (at the specified reference elevation) = {} Pa", - wellControlsName, currentBHP ) ); + getName(), currentBHP ) ); } -void SinglePhaseWell::updateVolRateForConstraint( WellElementSubRegion & subRegion ) +void SinglePhaseWell::calculateReferenceElementRates( WellElementSubRegion & subRegion ) { GEOS_MARK_FUNCTION; @@ -274,76 +316,96 @@ void SinglePhaseWell::updateVolRateForConstraint( WellElementSubRegion & subRegi subRegion.getField< well::connectionRate >(); // fluid data + constitutive::SingleFluidBase & fluidSeparator = getSingleFluidSeparator(); + arrayView2d< real64 const, constitutive::singlefluid::USD_FLUID > const & dens = fluidSeparator.density(); - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - SingleFluidBase & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); - arrayView2d< real64 const, constitutive::singlefluid::USD_FLUID > const & dens = fluid.density(); - arrayView3d< real64 const, constitutive::singlefluid::USD_FLUID_DER > const & dDens = fluid.dDensity(); + real64 & currentVolRate = + getReference< real64 >( WellControls::viewKeyStruct::currentVolRateString() ); - // control data + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [connRate, + dens, + ¤tVolRate, + &iwelemRef] ( localIndex const ) + { + real64 const densInv = 1.0 / dens[iwelemRef][0]; + currentVolRate = connRate[iwelemRef] * densInv; + // compute mass rate + } ); - WellControls & wellControls = getWellControls( subRegion ); - string const wellControlsName = wellControls.getName(); - bool const logSurfaceCondition = isLogLevelActive< logInfo::WellControl >( wellControls.getLogLevel()); - integer const useSurfaceConditions = wellControls.useSurfaceConditions(); - ReferenceConditions const refConditions = getReferenceConditions( subRegion ); - real64 & currentVolRate = - wellControls.getReference< real64 >( SinglePhaseWell::viewKeyStruct::currentVolRateString() ); +} + +void SinglePhaseWell::updateFluidModel( WellElementSubRegion & subRegion ) const +{ + GEOS_MARK_FUNCTION; - arrayView1d< real64 > const & dCurrentVolRate = - wellControls.getReference< array1d< real64 > >( SinglePhaseWell::viewKeyStruct::dCurrentVolRateString() ); + arrayView1d< real64 const > const pres = subRegion.getField< well::pressure >(); + arrayView1d< real64 const > const temp = subRegion.getField< well::temperature >(); + + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + SingleFluidBase & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); constitutiveUpdatePassThru( fluid, [&]( auto & castedFluid ) { typename TYPEOFREF( castedFluid ) ::KernelWrapper fluidWrapper = castedFluid.createKernelWrapper(); + singlePhaseBaseKernels::FluidUpdateKernel::launch( fluidWrapper, pres, temp ); + } ); +} +void SinglePhaseWell::updateSeparator( ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ) +{ + GEOS_MARK_FUNCTION; + GEOS_UNUSED_VAR( elemManager ); + + // the rank that owns the reference well element is responsible for the calculations below. + if( !subRegion.isLocallyOwned() ) + { + return; + } + + localIndex const iwelemRef = subRegion.getTopWellElementIndex(); + + constitutive::SingleFluidBase & fluidSeparator = getSingleFluidSeparator(); + string const wellControlsName = getName(); + bool const logSurfaceCondition = isLogLevelActive< logInfo::WellControl >( getLogLevel()); + integer const useSurfCond = useSurfaceConditions(); + ReferenceConditions const refConditions = getReferenceConditions( subRegion ); + + constitutiveUpdatePassThru( fluidSeparator, [&]( auto & castedFluid ) + { + typename TYPEOFREF( castedFluid ) ::KernelWrapper fluidSeparatorWrapper = castedFluid.createKernelWrapper(); geos::internal::kernelLaunchSelectorThermalSwitch( isThermal(), [&] ( auto ISTHERMAL ) { integer constexpr IS_THERMAL = ISTHERMAL(); - using COFFSET_WJ = singlePhaseWellKernels::ColOffset_WellJac< IS_THERMAL >; + GEOS_UNUSED_VAR( IS_THERMAL ); // bring everything back to host, capture the scalars by reference - forAll< serialPolicy >( 1, [fluidWrapper, - connRate, - dens, - dDens, + forAll< serialPolicy >( 1, [fluidSeparatorWrapper, logSurfaceCondition, - &useSurfaceConditions, + &useSurfCond, refConditions, - ¤tVolRate, - dCurrentVolRate, &iwelemRef, &wellControlsName] ( localIndex const ) { - // We need to evaluate the density as follows: - // - Surface conditions: using the surface pressure provided by the user - // - Reservoir conditions: using the pressure in the top element + // Refresh separator properties at the selected control/reference conditions. + if constexpr ( IS_THERMAL ) + { + fluidSeparatorWrapper.update( iwelemRef, 0, refConditions.pressure, refConditions.temperature ); + } + else + { + fluidSeparatorWrapper.update( iwelemRef, 0, refConditions.pressure ); + } - fluidWrapper.update( iwelemRef, 0, refConditions.pressure ); - if( useSurfaceConditions && logSurfaceCondition ) + if( useSurfCond && logSurfaceCondition ) { - GEOS_LOG_RANK( GEOS_FMT( "{}: surface density computed with P_surface = {} Pa", - wellControlsName, refConditions.pressure ) ); + GEOS_LOG_RANK( GEOS_FMT( "{}: surface density computed with P_surface = {} Pa and T_surface = {} K", + wellControlsName, refConditions.pressure, refConditions.temperature ) ); } #ifdef GEOS_USE_HIP GEOS_UNUSED_VAR( wellControlsName ); #endif - - real64 const densInv = 1.0 / dens[iwelemRef][0]; - currentVolRate = connRate[iwelemRef] * densInv; - - dCurrentVolRate[COFFSET_WJ::dP] = -( useSurfaceConditions == 0 ) * dDens[iwelemRef][0][DerivOffset::dP] * currentVolRate * densInv; - dCurrentVolRate[COFFSET_WJ::dQ] = densInv; - if constexpr ( IS_THERMAL ) - { - dCurrentVolRate[COFFSET_WJ::dT] = -( useSurfaceConditions == 0 ) * dDens[iwelemRef][0][DerivOffset::dT] * currentVolRate * densInv; - } - if( logSurfaceCondition && useSurfaceConditions ) - { - GEOS_LOG_RANK( GEOS_FMT( "{}: total fluid density at surface conditions = {} kg/sm3, total rate = {} kg/s, total surface volumetric rate = {} sm3/s", - wellControlsName, dens[iwelemRef][0], connRate[iwelemRef], currentVolRate ) ); - } } ); } ); } ); @@ -354,16 +416,15 @@ void SinglePhaseWell::precomputeReferenceConditions( real64 const time_n, MeshBody & meshBody, WellElementSubRegion const & subRegion ) { - WellControls & wellControls = getWellControls( subRegion ); - integer const useSurfaceConditions = wellControls.useSurfaceConditions(); - if( !useSurfaceConditions ) + GEOS_UNUSED_VAR( subRegion ); + if( !useSurfaceConditions() ) { - string_view refRegionName = wellControls.referenceReservoirRegion(); + string_view refRegionName = referenceReservoirRegion(); bool const useSegmentValues = refRegionName.empty(); if( useSegmentValues ) { - wellControls.setRegionAveragePressure( -1 ); - wellControls.setRegionAverageTemperature( -1 ); + setRegionAveragePressure( -1 ); + setRegionAverageTemperature( -1 ); } else { @@ -372,7 +433,7 @@ void SinglePhaseWell::precomputeReferenceConditions( real64 const time_n, if( !m_reservoirStatsAggregator ) { // lazily initialize the region statistics aggregator - m_reservoirStatsAggregator = std::make_unique< StatsAggregator >( wellControls.getDataContext(), + m_reservoirStatsAggregator = std::make_unique< StatsAggregator >( getDataContext(), meshBodies, false ); m_reservoirStatsAggregator->initStatisticsAggregation( flowSolver ); @@ -387,12 +448,12 @@ void SinglePhaseWell::precomputeReferenceConditions( real64 const time_n, GEOS_WARNING_IF( stats.m_averagePressure <= 0.0, GEOS_FMT( "No region average quantities computed in reference region '{}'.", - wellControls.referenceReservoirRegion() ), - wellControls.getWrapperDataContext( WellControls::viewKeyStruct::referenceReservoirRegionString() ), + referenceReservoirRegion() ), + getWrapperDataContext( WellControls::viewKeyStruct::referenceReservoirRegionString() ), getDataContext() ); - wellControls.setRegionAveragePressure( stats.m_averagePressure ); - wellControls.setRegionAverageTemperature( stats.m_averageTemperature ); + setRegionAveragePressure( stats.m_averagePressure ); + setRegionAverageTemperature( stats.m_averageTemperature ); } } } @@ -400,29 +461,34 @@ void SinglePhaseWell::precomputeReferenceConditions( real64 const time_n, SinglePhaseWell::ReferenceConditions SinglePhaseWell::getReferenceConditions( WellElementSubRegion const & subRegion ) { - WellControls & wellControls = getWellControls( subRegion ); - integer const useSurfaceConditions = wellControls.useSurfaceConditions(); - if( useSurfaceConditions ) + if( useSurfaceConditions() ) { // use surface conditions return { - /* .pressure = */ wellControls.getSurfacePressure(), - /* .temperature = */ wellControls.getSurfaceTemperature(), + /* .pressure = */ getSurfacePressure(), + /* .temperature = */ getSurfaceTemperature(), }; } else { - if( wellControls.getRegionAveragePressure() > 0.0 && wellControls.getRegionAverageTemperature() > 0.0 ) + if( getRegionAveragePressure() > 0.0 && getRegionAverageTemperature() > 0.0 ) { // reference region condition properly computed, we can return them return { - /* .pressure = */ wellControls.getRegionAveragePressure(), - /* .temperature = */ wellControls.getRegionAverageTemperature(), + /* .pressure = */ getRegionAveragePressure(), + /* .temperature = */ getRegionAverageTemperature(), }; } else { // region average stats not initialized or initialized, fallback to top segment values - GEOS_WARNING( "Region average statistics of reference region not initialized, fallback to top segment values.", - wellControls.getDataContext() ); + static bool firstNoRefRegionMsg = true; + if( firstNoRefRegionMsg ) + { + GEOS_WARNING( "SinglePhaseWell: region average statsistics of reference region not initialized," + " fallback to top segment values.", + getDataContext() ); + firstNoRefRegionMsg=false; + } + arrayView1d< real64 const > const & pres = subRegion.getField< well::pressure >(); arrayView1d< real64 const > const & temp = subRegion.getField< well::temperature >(); @@ -435,528 +501,530 @@ SinglePhaseWell::getReferenceConditions( WellElementSubRegion const & subRegion } } -void SinglePhaseWell::updateFluidModel( WellElementSubRegion & subRegion ) const +real64 SinglePhaseWell::updateSubRegionState( real64 const time_n, + MeshBody const & meshBody, + ElementRegionManager const & elemManager, + WellElementSubRegion & subRegion ) { - GEOS_MARK_FUNCTION; - - arrayView1d< real64 const > const pres = subRegion.getField< well::pressure >(); - arrayView1d< real64 const > const temp = subRegion.getField< well::temperature >(); - - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - SingleFluidBase & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); + GEOS_UNUSED_VAR( time_n ); + GEOS_UNUSED_VAR( meshBody ); - constitutiveUpdatePassThru( fluid, [&]( auto & castedFluid ) + if( getWellState()) { - typename TYPEOFREF( castedFluid ) ::KernelWrapper fluidWrapper = castedFluid.createKernelWrapper(); - singlePhaseBaseKernels::FluidUpdateKernel::launch( fluidWrapper, pres, temp ); - } ); -} - -real64 SinglePhaseWell::updateSubRegionState( WellElementSubRegion & subRegion ) -{ - // update volumetric rates for the well constraints - // Warning! This must be called before updating the fluid model - updateVolRateForConstraint( subRegion ); - // update density in the well elements - updateFluidModel( subRegion ); - - // update the current BHP - updateBHPForConstraint( subRegion ); - - // note: the perforation rates are updated separately - return 0.0; // change in phasevolume fraction doesnt apply + // update volumetric rates for the well constraints + // Warning! This must be called before updating the fluid model + //calculateReferenceElementRates( subRegion ); + + // update density in the well elements + updateFluidModel( subRegion ); + updateSeparator( elemManager, subRegion ); // Calculate fluid properties at control conditions + + // Calculate the reference element rates + calculateReferenceElementRates( subRegion ); + // update the current BHP + updateBHPForConstraint( subRegion ); + + // Broad case the updated well state to other ranks + // TODO: add the missing getters on SinglePhaseWell & WellElementSubRegion because look-up is not useful here. + real64 & currentBHP = + getReference< real64 >( SinglePhaseWell::viewKeyStruct::currentBHPString() ); + real64 & currentTotalVolRate = + getReference< real64 >( SinglePhaseWell::viewKeyStruct::currentVolRateString() ); + integer topRank = + subRegion.getReference< integer >( WellElementSubRegion::viewKeyStruct::topRankString() ); + MpiWrapper::broadcast( currentBHP, topRank ); + MpiWrapper::broadcast( currentTotalVolRate, topRank ); + WellConstraintBase * constraint = getCurrentConstraint(); + if( constraint != nullptr ) + { + constraint->setBHP ( getReference< real64 >( SinglePhaseWell::viewKeyStruct::currentBHPString() )); + constraint->setTotalVolumeRate ( getReference< real64 >( + SinglePhaseWell::viewKeyStruct::currentVolRateString() )); + } + } + return 0.0; // change in phasevolume fraction doesnt apply } - -void SinglePhaseWell::initializeWells( DomainPartition & domain, real64 const & time_n ) +void SinglePhaseWell::initializeWell( DomainPartition & domain, Group & meshBodies, string const & meshBodyName, MeshLevel & mesh, WellElementSubRegion & subRegion, real64 const & time_n ) { - GEOS_MARK_FUNCTION; - GEOS_UNUSED_VAR( time_n ); + GEOS_UNUSED_VAR( domain ); - Group & meshBodies = domain.getMeshBodies(); + PerforationData const & perforationData = *subRegion.getPerforationData(); + ElementRegionManager const & elemManager = mesh.getElemManager(); + // get the info stored on well elements + arrayView1d< real64 const > const wellElemGravCoef = + subRegion.getField< well::gravityCoefficient >(); - // loop over the wells - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const & meshBodyName, - MeshLevel & meshLevel, - string_array const & regionNames ) + // get well primary variables on well elements + arrayView1d< real64 > const wellElemPressure = + subRegion.getField< well::pressure >(); + arrayView1d< real64 > const connRate = + subRegion.getField< well::connectionRate >(); + arrayView1d< real64 > const wellElemTemperature = + subRegion.getField< well::temperature >(); + // get the element region, subregion, index + arrayView1d< localIndex const > const resElementRegion = + perforationData.getField< perforation::reservoirElementRegion >(); + arrayView1d< localIndex const > const resElementSubRegion = + perforationData.getField< perforation::reservoirElementSubRegion >(); + arrayView1d< localIndex const > const resElementIndex = + perforationData.getField< perforation::reservoirElementIndex >(); + + arrayView1d< real64 const > const & perfGravCoef = + perforationData.getField< well::gravityCoefficient >(); + + bool const hasNonZeroRate = MpiWrapper::max< integer >( hasNonZero( connRate )); + + if( time_n <= 0.0 || ( isWellOpen() && !hasNonZeroRate ) ) { - ElementRegionManager & elemManager = meshLevel.getElemManager(); - MeshBody & meshBody = domain.getMeshBody( meshBodyName ); - - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion & subRegion ) + setWellState( true ); + if( getCurrentConstraint() == nullptr ) { - WellControls const & wellControls = getWellControls( subRegion ); - PerforationData const & perforationData = *subRegion.getPerforationData(); - - // get the info stored on well elements - arrayView1d< real64 const > const wellElemGravCoef = - subRegion.getField< well::gravityCoefficient >(); - - // get well primary variables on well elements - arrayView1d< real64 > const wellElemPressure = - subRegion.getField< well::pressure >(); - arrayView1d< real64 > const connRate = - subRegion.getField< well::connectionRate >(); - arrayView1d< real64 > const wellElemTemperature = - subRegion.getField< well::temperature >(); - // get the element region, subregion, index - arrayView1d< localIndex const > const resElementRegion = - perforationData.getField< perforation::reservoirElementRegion >(); - arrayView1d< localIndex const > const resElementSubRegion = - perforationData.getField< perforation::reservoirElementSubRegion >(); - arrayView1d< localIndex const > const resElementIndex = - perforationData.getField< perforation::reservoirElementIndex >(); - - arrayView1d< real64 const > const & perfGravCoef = - perforationData.getField< well::gravityCoefficient >(); - - bool const hasNonZeroRate = MpiWrapper::max< integer >( hasNonZero( connRate )); - - if( wellControls.isWellOpen() && !hasNonZeroRate ) + if( isProducer() ) { - // TODO: change the way we access the flowSolver here - SinglePhaseBase const & flowSolver = getFlowSolver( *this ); - PresTempInitializationKernel::SinglePhaseFlowAccessors resSinglePhaseFlowAccessors( meshLevel.getElemManager(), flowSolver.getName() ); - PresTempInitializationKernel::SingleFluidAccessors resSingleFluidAccessors( meshLevel.getElemManager(), flowSolver.getName() ); - - // 1) Loop over all perforations to compute an average density - // 2) Initialize the reference pressure - // 3) Estimate the pressures in the well elements using the average density - PresTempInitializationKernel:: - launch( isThermal(), - perforationData.size(), - subRegion.size(), - perforationData.getNumPerforationsGlobal(), - wellControls, - 0.0, // initialization done at t = 0 - resSinglePhaseFlowAccessors.get( flow::pressure{} ), - resSinglePhaseFlowAccessors.get( flow::temperature{} ), - resSingleFluidAccessors.get( fields::singlefluid::density{} ), - resElementRegion, - resElementSubRegion, - resElementIndex, - perfGravCoef, - wellElemGravCoef, - wellElemPressure, - wellElemTemperature ); - - // 4) Recompute the pressure-dependent properties - // Note: I am leaving that here because I would like to use the perforationRates (computed in UpdateState) - // to better initialize the rates - precomputeReferenceConditions( time_n, meshBodies, meshBody, subRegion ); - updateSubRegionState( subRegion ); - - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - SingleFluidBase & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); - arrayView2d< real64 const, constitutive::singlefluid::USD_FLUID > const & wellElemDens = fluid.density(); - - // 5) Estimate the well rates - RateInitializationKernel::launch( subRegion.size(), - wellControls, - 0.0, // initialization done at t = 0 - wellElemDens, - connRate ); + forSubGroups< MinimumBHPConstraint, ProductionConstraint< VolumeRateConstraint >, ProductionConstraint< MassRateConstraint >, + ProductionConstraint< PhaseVolumeRateConstraint > >( [&]( auto & constraint ) + { + if( ConstraintTypeId( getControl()) == constraint.getControl() ) + { + setCurrentConstraint( &constraint ); + } + } ); } + else + { + forSubGroups< MaximumBHPConstraint, InjectionConstraint< VolumeRateConstraint >, InjectionConstraint< MassRateConstraint >, + InjectionConstraint< PhaseVolumeRateConstraint > >( [&]( auto & constraint ) + { + if( ConstraintTypeId( getControl()) == constraint.getControl() ) + { + setCurrentConstraint( &constraint ); + } + } ); + } + } - } ); - - } ); -} -void SinglePhaseWell::shutDownWell( real64 const time_n, - DomainPartition const & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) -{ - GEOS_MARK_FUNCTION; - GEOS_UNUSED_VAR( time_n ); - - string const wellDofKey = dofManager.getKey( wellElementDofName() ); - - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel const & mesh, - string_array const & regionNames ) + PresTempInitializationKernel::SinglePhaseFlowAccessors resSinglePhaseFlowAccessors( elemManager, getFlowSolverName()); + PresTempInitializationKernel::SingleFluidAccessors resSingleFluidAccessors( elemManager, getFlowSolverName() ); + real64 const refWellElemGravCoef = getBHPReferenceGravityCoef( *this, ConstraintSourceId::USER ); + // 1) Loop over all perforations to compute an average density + // 2) Initialize the reference pressure + // 3) Estimate the pressures in the well elements using the average density + PresTempInitializationKernel:: + launch( isThermal(), + perforationData.size(), + subRegion.size(), + perforationData.getNumPerforationsGlobal(), + *this, + refWellElemGravCoef, + 0.0, // initialization done at t = 0 + resSinglePhaseFlowAccessors.get( flow::pressure{} ), + resSinglePhaseFlowAccessors.get( flow::temperature{} ), + resSingleFluidAccessors.get( fields::singlefluid::density{} ), + resElementRegion, + resElementSubRegion, + resElementIndex, + perfGravCoef, + wellElemGravCoef, + wellElemPressure, + wellElemTemperature ); + + // 4) Recompute the pressure-dependent properties + // Note: I am leaving that here because I would like to use the perforationRates (computed in UpdateState) + // to better initialize the rates + MeshBody & meshBody = domain.getMeshBody( meshBodyName ); + precomputeReferenceConditions( time_n, meshBodies, meshBody, subRegion ); + updateSubRegionState( time_n, meshBody, elemManager, subRegion ); + + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + SingleFluidBase & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); + arrayView2d< real64 const, constitutive::singlefluid::USD_FLUID > const & wellElemDens = fluid.density(); + + // 5) Estimate the well rates + RateInitializationKernel::launch( subRegion.size(), + *this, + 0.0, // initialization done at t = 0 + wellElemDens, + connRate ); + + calculateReferenceElementRates( subRegion ); + WellConstraintBase * constraint = getCurrentConstraint(); + constraint->setBHP ( getReference< real64 >( WellControls::viewKeyStruct::currentBHPString() )); + constraint->setTotalVolumeRate ( getReference< real64 >( + SinglePhaseWell::viewKeyStruct::currentVolRateString() )); + // 7) Copy well / fluid dofs to "prop"_n variables + saveState( subRegion ); + } + else if( !hasNonZeroRate ) { - - ElementRegionManager const & elemManager = mesh.getElemManager(); - - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion const & subRegion ) + setWellState( false ); + } + else + { + setWellState( true ); + // setup for restart + if( getCurrentConstraint() == nullptr ) { - - // if the well is open, we don't have to do anything, so we just return - WellControls const & wellControls = getWellControls( subRegion ); - if( wellControls.isWellOpen( ) ) + if( isProducer() ) { - return; + forSubGroups< MinimumBHPConstraint, ProductionConstraint< VolumeRateConstraint >, ProductionConstraint< MassRateConstraint >, + ProductionConstraint< PhaseVolumeRateConstraint > >( [&]( + auto + & constraint ) + { + if( ConstraintTypeId( getControl()) == constraint.getControl() ) + { + setCurrentConstraint( &constraint ); + } + } ); } - - globalIndex const rankOffset = dofManager.rankOffset(); - - arrayView1d< integer const > const ghostRank = - subRegion.getReference< array1d< integer > >( ObjectManagerBase::viewKeyStruct::ghostRankString() ); - arrayView1d< globalIndex const > const dofNumber = - subRegion.getReference< array1d< globalIndex > >( wellDofKey ); - - arrayView1d< real64 const > const pres = - subRegion.getField< fields::well::pressure >(); - arrayView1d< real64 const > const connRate = - subRegion.getField< fields::well::connectionRate >(); - - forAll< parallelDevicePolicy<> >( subRegion.size(), [=] GEOS_HOST_DEVICE ( localIndex const ei ) + else { - if( ghostRank[ei] >= 0 ) + forSubGroups< MaximumBHPConstraint, InjectionConstraint< VolumeRateConstraint >, InjectionConstraint< MassRateConstraint >, InjectionConstraint< PhaseVolumeRateConstraint > >( [&]( + auto + & + constraint ) { - return; - } + if( ConstraintTypeId( getControl()) == constraint.getControl() ) + { + setCurrentConstraint( &constraint ); + } + } ); + } + updateSubRegionState( time_n, domain.getMeshBody( meshBodyName ), elemManager, subRegion ); + } - globalIndex const dofIndex = dofNumber[ei]; - localIndex const localRow = dofIndex - rankOffset; - real64 rhsValue; - - // 4.1. Apply pressure value to the matrix/rhs - FieldSpecificationEqual::SpecifyFieldValue( dofIndex, - rankOffset, - localMatrix, - rhsValue, - pres[ei], // freeze the current pressure value - pres[ei] ); - localRhs[localRow] = rhsValue; - - // 4.2. Apply rate value to the matrix/rhs - FieldSpecificationEqual::SpecifyFieldValue( dofIndex + 1, - rankOffset, - localMatrix, - rhsValue, - connRate[ei], // freeze the current pressure value - connRate[ei] ); - localRhs[localRow + 1] = rhsValue; + } - } ); - } ); - } ); } -void SinglePhaseWell::assembleSystem( real64 const time, - real64 const dt, - DomainPartition & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) +real64 SinglePhaseWell::updateWellState( MeshBody const & meshBody, + ElementRegionManager const & elemManager, + WellElementSubRegion & subRegion ) { - string const wellDofKey = dofManager.getKey( wellElementDofName()); + GEOS_MARK_FUNCTION; - // assemble the accumulation term in the mass balance equations - assembleAccumulationTerms( time, dt, domain, dofManager, localMatrix, localRhs ); + updateSubRegionState( -1.0, meshBody, elemManager, subRegion ); + return 0.0; +} - // then assemble the pressure relations between well elements - assemblePressureRelations( time, dt, domain, dofManager, localMatrix, localRhs ); - // then compute the perforation rates (later assembled by the coupled solver) - computePerforationRates( time, dt, domain ); +void SinglePhaseWell::assembleWellFluxTerms( real64 const & time, + real64 const & dt, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) +{ + GEOS_MARK_FUNCTION; + GEOS_UNUSED_VAR( time ); - // then assemble the flux terms in the mass balance equations // get a reference to the degree-of-freedom numbers - // then assemble the flux terms in the mass balance equations - assembleFluxTerms( time, dt, domain, dofManager, localMatrix, localRhs ); + string const wellDofKey = dofManager.getKey( wellElementDofName() ); + + if( isThermal() ) + { + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + SingleFluidBase const & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); + thermalSinglePhaseWellKernels:: + FaceBasedAssemblyKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( dt, + dofManager.rankOffset(), + wellDofKey, + *this, + subRegion, + fluid, + localMatrix, + localRhs ); + } + else + { + singlePhaseWellKernels:: + FaceBasedAssemblyKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( dt, + dofManager.rankOffset(), + wellDofKey, + *this, + subRegion, + localMatrix, + localRhs ); + } - // then apply a special treatment to the wells that are shut - shutDownWell( time, domain, dofManager, localMatrix, localRhs ); } -void SinglePhaseWell::assembleFluxTerms( real64 const & time_n, - real64 const & dt, - DomainPartition & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) + +void SinglePhaseWell::assembleWellConstraintTerms( real64 const & time_n, + real64 const & GEOS_UNUSED_PARAM( dt ), + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) { GEOS_MARK_FUNCTION; - GEOS_UNUSED_VAR( time_n ); - GEOS_UNUSED_VAR( dt ); - // loop over the wells - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel const & mesh, - string_array const & regionNames ) - { - ElementRegionManager const & elemManager = mesh.getElemManager(); + // the rank that owns the reference well element is responsible for the calculations below. - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion const & subRegion ) + if( !subRegion.isLocallyOwned() || !( getWellStatus() == WellControls::Status::OPEN )) + { + return; + } + { + forSubGroups< MinimumBHPConstraint, MaximumBHPConstraint, InjectionConstraint< VolumeRateConstraint >, ProductionConstraint< VolumeRateConstraint > >( [&]( auto & constraint ) { + if( constraint.getName() == getCurrentConstraint()->getName()) + { + // found limiting constraint - WellControls const & wellControls = getWellControls( subRegion ); - // get a reference to the degree-of-freedom numbers - string const wellDofKey = dofManager.getKey( wellElementDofName() ); + // fluid data + constitutive::SingleFluidBase & fluidSeparator = getSingleFluidSeparator(); + integer isThermal = fluidSeparator.isThermal(); - if( isThermal() ) - { - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - SingleFluidBase const & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); - thermalSinglePhaseWellKernels:: - FaceBasedAssemblyKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( dt, - dofManager.rankOffset(), - wellDofKey, - wellControls, - subRegion, - fluid, - localMatrix, - localRhs ); - } - else - { - singlePhaseWellKernels:: - FaceBasedAssemblyKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( dt, - dofManager.rankOffset(), - wellDofKey, - wellControls, - subRegion, - localMatrix, - localRhs ); + geos::internal::kernelLaunchSelectorThermalSwitch( isThermal, [&] ( auto ISTHERMAL ) + { + integer constexpr IS_THERMAL = ISTHERMAL(); + + singlePhaseWellConstraintKernels::ConstraintHelper< IS_THERMAL >::assembleConstraintEquation( time_n, + *this, + constraint, + subRegion, + dofManager.getKey( wellElementDofName() ), + dofManager.rankOffset(), + localMatrix, + localRhs ); + } ); } } ); + } - } ); } -void SinglePhaseWell::assemblePressureRelations( real64 const & time_n, - real64 const & GEOS_UNUSED_PARAM( dt ), - DomainPartition const & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) +void SinglePhaseWell::assembleWellPressureRelations( real64 const & GEOS_UNUSED_PARAM( time_n ), + real64 const & GEOS_UNUSED_PARAM( dt ), + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) { - GEOS_MARK_FUNCTION; - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel const & mesh, - string_array const & regionNames ) - { - - ElementRegionManager const & elemManager = mesh.getElemManager(); + // get the degrees of freedom numbers, depth, next well elem index + string const wellDofKey = dofManager.getKey( wellElementDofName() ); + arrayView1d< globalIndex const > const & wellElemDofNumber = + subRegion.getReference< array1d< globalIndex > >( wellDofKey ); + arrayView1d< real64 const > const & wellElemGravCoef = + subRegion.getField< well::gravityCoefficient >(); + arrayView1d< localIndex const > const & nextWellElemIndex = + subRegion.getReference< array1d< localIndex > >( WellElementSubRegion::viewKeyStruct::nextWellElementIndexString() ); + // get primary variables on well elements + arrayView1d< real64 const > const & wellElemPressure = + subRegion.getField< well::pressure >(); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion const & subRegion ) - { + // get well constitutive data + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + SingleFluidBase const & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); + arrayView2d< real64 const, constitutive::singlefluid::USD_FLUID > const & wellElemDensity = fluid.density(); + arrayView3d< real64 const, constitutive::singlefluid::USD_FLUID_DER > const & dWellElemDensity = fluid.dDensity(); - WellControls & wellControls = getWellControls( subRegion ); + geos::internal::kernelLaunchSelectorThermalSwitch( isThermal(), [&] ( auto ISTHERMAL ) + { + PressureRelationKernel::launch< ISTHERMAL >( subRegion.size(), + dofManager.rankOffset(), + wellElemDofNumber, + wellElemGravCoef, + nextWellElemIndex, + wellElemPressure, + wellElemDensity, + dWellElemDensity, + localMatrix, + localRhs ); + } ); - // get the degrees of freedom numbers, depth, next well elem index - string const wellDofKey = dofManager.getKey( wellElementDofName() ); - arrayView1d< globalIndex const > const & wellElemDofNumber = - subRegion.getReference< array1d< globalIndex > >( wellDofKey ); - arrayView1d< real64 const > const & wellElemGravCoef = - subRegion.getField< well::gravityCoefficient >(); - arrayView1d< localIndex const > const & nextWellElemIndex = - subRegion.getReference< array1d< localIndex > >( WellElementSubRegion::viewKeyStruct::nextWellElementIndexString() ); +} - // get primary variables on well elements - arrayView1d< real64 const > const & wellElemPressure = - subRegion.getField< well::pressure >(); +void SinglePhaseWell::assembleWellAccumulationTerms( real64 const & time, + real64 const & dt, + WellElementSubRegion & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) - // get well constitutive data - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - SingleFluidBase const & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); - arrayView2d< real64 const, constitutive::singlefluid::USD_FLUID > const & wellElemDensity = fluid.density(); - arrayView3d< real64 const, constitutive::singlefluid::USD_FLUID_DER > const & dWellElemDensity = fluid.dDensity(); +{ + GEOS_UNUSED_VAR( time ); + GEOS_UNUSED_VAR( dt ); + // get a reference to the degree-of-freedom numbers + string const wellElemDofKey = dofManager.getKey( wellElementDofName() ); - geos::internal::kernelLaunchSelectorThermalSwitch( isThermal(), [&] ( auto ISTHERMAL ) + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + SingleFluidBase const & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); + if( getWellStatus() == WellControls::Status::OPEN && !m_keepVariablesConstantDuringInitStep ) + { + if( isThermal() ) + { + thermalSinglePhaseWellKernels:: + ElementBasedAssemblyKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( isProducer(), + dofManager.rankOffset(), + wellElemDofKey, + subRegion, + fluid, + localMatrix, + localRhs ); + } + else + { + singlePhaseWellKernels:: + ElementBasedAssemblyKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( dofManager.rankOffset(), + wellElemDofKey, + subRegion, + fluid, + localMatrix, + localRhs ); + } + // get the degrees of freedom and ghosting info + arrayView1d< globalIndex const > const & wellElemDofNumber = + subRegion.getReference< array1d< globalIndex > >( wellElemDofKey ); + arrayView1d< integer const > const wellElemGhostRank = subRegion.ghostRank(); + arrayView1d< integer const > const elemStatus = subRegion.getLocalWellElementStatus(); + + arrayView1d< real64 > connRate = subRegion.getField< fields::well::connectionRate >(); + localIndex rank_offset = dofManager.rankOffset(); + forAll< parallelDevicePolicy<> >( subRegion.size(), [=] GEOS_HOST_DEVICE ( localIndex const ei ) + { + if( wellElemGhostRank[ei] < 0 ) { - localIndex controlHasSwitched=0; - controlHasSwitched = PressureRelationKernel::launch< ISTHERMAL >( subRegion.size(), - dofManager.rankOffset(), - subRegion.isLocallyOwned(), - subRegion.getTopWellElementIndex(), - wellControls, - time_n, - wellElemDofNumber, - wellElemGravCoef, - nextWellElemIndex, - wellElemPressure, - wellElemDensity, - dWellElemDensity, - localMatrix, - localRhs ); - - if( controlHasSwitched == 1 ) + if( elemStatus[ei]==WellElementSubRegion::WellElemStatus::CLOSED ) { - // Note: if BHP control is not viable, we switch to TOTALVOLRATE - // if TOTALVOLRATE is not viable, we switch to BHP + connRate[ei] = 0.0; + globalIndex const dofIndex = wellElemDofNumber[ei]; + localIndex const localRow = dofIndex - rank_offset; - if( wellControls.getControl() == WellControls::Control::BHP ) - { - wellControls.switchToTotalRateControl( wellControls.getTargetTotalRate( time_n ) ); - GEOS_LOG_LEVEL_RANK_0( logInfo::WellControl, - GEOS_FMT( "Control switch for well {} from BHP constraint to rate constraint", subRegion.getName()) ); - } - else + real64 const unity = 1.0; + for( integer i=0; i < m_numDofPerWellElement; i++ ) { - wellControls.switchToBHPControl( wellControls.getTargetBHP( time_n ) ); - GEOS_LOG_LEVEL_RANK_0( logInfo::WellControl, - GEOS_FMT( "Control switch for well {} from rate constraint to BHP constraint", subRegion.getName()) ); + globalIndex const rindex = localRow+i; + globalIndex const cindex =dofIndex + i; + localMatrix.template addToRow< serialAtomic >( rindex, + &cindex, + &unity, + 1 ); + localRhs[rindex] = 0.0; } } - } ); - + } } ); - } ); -} - -void SinglePhaseWell::assembleAccumulationTerms( real64 const & time_n, - real64 const & dt, - DomainPartition & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) -{ - GEOS_MARK_FUNCTION; - GEOS_UNUSED_VAR( time_n ); - GEOS_UNUSED_VAR( dt ); - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel const & mesh, - string_array const & regionNames ) + } + else { - - ElementRegionManager const & elemManager = mesh.getElemManager(); - - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion const & subRegion ) + // Zero accumulation contribution + arrayView1d< globalIndex const > const & wellElemDofNumber = + subRegion.getReference< array1d< globalIndex > >( wellElemDofKey ); + arrayView1d< integer const > const wellElemGhostRank = subRegion.ghostRank(); + + arrayView1d< real64 > connRate = subRegion.getField< fields::well::connectionRate >(); + localIndex rank_offset = dofManager.rankOffset(); + forAll< parallelDevicePolicy<> >( subRegion.size(), [=] GEOS_HOST_DEVICE ( localIndex const ei ) { - - // get a reference to the degree-of-freedom numbers - string const wellElemDofKey = dofManager.getKey( wellElementDofName() ); - - WellControls const & wellControls = getWellControls( subRegion ); - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - SingleFluidBase const & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); - - if( isThermal() ) - { - thermalSinglePhaseWellKernels:: - ElementBasedAssemblyKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( wellControls.isProducer(), - dofManager.rankOffset(), - wellElemDofKey, - subRegion, - fluid, - localMatrix, - localRhs ); - } - else + if( wellElemGhostRank[ei] < 0 ) { - singlePhaseWellKernels:: - ElementBasedAssemblyKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( dofManager.rankOffset(), - wellElemDofKey, - subRegion, - fluid, - localMatrix, - localRhs ); + connRate[ei] = 0.0; + globalIndex const dofIndex = wellElemDofNumber[ei]; + localIndex const localRow = dofIndex - rank_offset; + + real64 const unity = 1.0; + for( integer i=0; i < m_numDofPerWellElement; i++ ) + { + globalIndex const rindex = localRow+i; + globalIndex const cindex =dofIndex + i; + localMatrix.template addToRow< serialAtomic >( rindex, + &cindex, + &unity, + 1 ); + localRhs[rindex] = 0.0; + } } } ); - } ); - // then assemble the volume balance equations - assembleVolumeBalanceTerms( domain, dofManager, localMatrix, localRhs ); -} - -void SinglePhaseWell::assembleVolumeBalanceTerms( DomainPartition const & GEOS_UNUSED_PARAM( domain ), - DofManager const & GEOS_UNUSED_PARAM( dofManager ), - CRSMatrixView< real64, globalIndex const > const & GEOS_UNUSED_PARAM( localMatrix ), - arrayView1d< real64 > const & GEOS_UNUSED_PARAM( localRhs ) ) -{ - // not implemented for single phase flow + // zero out current state constraint quantities + getReference< real64 >( WellControls::viewKeyStruct::currentBHPString() ) = 0.0; + getReference< real64 >( WellControls::viewKeyStruct::currentVolRateString() )=0.0; + getReference< real64 >( WellControls::viewKeyStruct::currentVolRateString() )=0.0; + } } -void SinglePhaseWell::computePerforationRates( real64 const & time_n, - real64 const & dt, DomainPartition & domain ) +void SinglePhaseWell::computeWellPerforationRates( real64 const & time_n, + real64 const & GEOS_UNUSED_PARAM( dt ), + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion ) { GEOS_MARK_FUNCTION; GEOS_UNUSED_VAR( time_n ); - GEOS_UNUSED_VAR( dt ); - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) + PerforationData * const perforationData = subRegion.getPerforationData(); + if( isWellOpen() && !m_keepVariablesConstantDuringInitStep ) { + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + SingleFluidBase const & fluid = getConstitutiveModel< SingleFluidBase >( subRegion, fluidName ); - // TODO: change the way we access the flowSolver here - SinglePhaseBase const & flowSolver = getFlowSolver( *this ); - PerforationKernel::SinglePhaseFlowAccessors resSinglePhaseFlowAccessors( mesh.getElemManager(), flowSolver.getName() ); - PerforationKernel::SingleFluidAccessors resSingleFluidAccessors( mesh.getElemManager(), flowSolver.getName() ); - ElementRegionManager & elemManager = mesh.getElemManager(); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, - WellElementSubRegion & subRegion ) + if( isThermal() ) { - - // get the well data - PerforationData * const perforationData = subRegion.getPerforationData(); - WellControls const & wellControls = getWellControls( subRegion ); - if( wellControls.isWellOpen() && !m_keepVariablesConstantDuringInitStep ) - { - - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - SingleFluidBase const & fluid = getConstitutiveModel< SingleFluidBase >( subRegion, fluidName ); - - if( isThermal() ) - { - thermalSinglePhasePerforationFluxKernels:: - PerforationFluxKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( flowSolver.getName(), - perforationData, - subRegion, - fluid, - elemManager ); - } - else - { - isothermalSinglePhasePerforationFluxKernels:: - PerforationFluxKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( flowSolver.getName(), - perforationData, - subRegion, - fluid, - elemManager ); - } - } - else - { - // Zero completion flow rate - arrayView1d< real64 > const perfRate = perforationData->getField< fields::well::perforationRate >(); - for( integer iperf=0; iperfsize(); iperf++ ) - { - perfRate[iperf] = 0.0; - } - } - } ); - } ); + thermalSinglePhasePerforationFluxKernels:: + PerforationFluxKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( getFlowSolverName(), + perforationData, + subRegion, + fluid, + elemManager ); + } + else + { + isothermalSinglePhasePerforationFluxKernels:: + PerforationFluxKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( getFlowSolverName(), + perforationData, + subRegion, + fluid, + elemManager ); + } + } + else + { + // Zero completion flow rate. + arrayView1d< real64 > const perfRate = perforationData->getField< fields::well::perforationRate >(); + for( integer iperf=0; iperfsize(); iperf++ ) + { + perfRate[iperf] = 0.0; + } + } } +real64 +SinglePhaseWell::scalingForWellSystemSolution( WellElementSubRegion & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution ) +{ + GEOS_MARK_FUNCTION; + GEOS_UNUSED_VAR( subRegion ); + GEOS_UNUSED_VAR( dofManager ); + GEOS_UNUSED_VAR( localSolution ); + return 1.0; +} -real64 -SinglePhaseWell::calculateResidualNorm( real64 const & time_n, - real64 const & dt, - DomainPartition const & domain, - DofManager const & dofManager, - arrayView1d< real64 const > const & localRhs ) +array1d< real64 > +SinglePhaseWell::calculateLocalWellResidualNorm( real64 const & time_n, + real64 const & dt, + NonlinearSolverParameters const & nonlinearSolverParameters, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localRhs ) { GEOS_MARK_FUNCTION; - integer numNorm = 1; // mass balance + integer numNorm = 1; // mass balance array1d< real64 > localResidualNorm; array1d< real64 > localResidualNormalizer; if( isThermal() ) { - numNorm = 2; // mass balance and energy balance + numNorm = 2; // mass balance and energy balance } localResidualNorm.resize( numNorm ); localResidualNormalizer.resize( numNorm ); @@ -965,74 +1033,99 @@ SinglePhaseWell::calculateResidualNorm( real64 const & time_n, globalIndex const rankOffset = dofManager.rankOffset(); string const wellDofKey = dofManager.getKey( wellElementDofName() ); - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel const & mesh, - string_array const & regionNames ) - { - - ElementRegionManager const & elemManager = mesh.getElemManager(); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion const & subRegion ) - { + string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); + SingleFluidBase const & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); - string const & fluidName = subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ); - SingleFluidBase const & fluid = subRegion.getConstitutiveModel< SingleFluidBase >( fluidName ); - WellControls const & wellControls = getWellControls( subRegion ); - // step 1: compute the norm in the subRegion - if( isThermal() ) + if( isWellOpen() ) + { + // step 1: compute the norm in the subRegion + if( isThermal() ) + { + real64 subRegionResidualNorm[2]{}; + thermalSinglePhaseWellKernels::ResidualNormKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( rankOffset, + wellDofKey, + localRhs, + subRegion, + fluid, + *this, + time_n, + dt, + nonlinearSolverParameters.m_minNormalizer, + subRegionResidualNorm ); + // step 2: reduction across meshBodies/regions/subRegions + + for( integer i=0; i >( rankOffset, - wellDofKey, - localRhs, - subRegion, - fluid, - wellControls, - time_n, - dt, - m_nonlinearSolverParameters.m_minNormalizer, - subRegionResidualNorm ); - // step 2: reduction across meshBodies/regions/subRegions - - for( integer i=0; i localResidualNorm[i] ) { - if( subRegionResidualNorm[i] > localResidualNorm[i] ) - { - localResidualNorm[i] = subRegionResidualNorm[i]; - } + localResidualNorm[i] = subRegionResidualNorm[i]; } } - else + } + else + { + real64 subRegionResidualNorm[1]{}; + ResidualNormKernelFactory:: + createAndLaunch< parallelDevicePolicy<> >( rankOffset, + wellDofKey, + localRhs, + subRegion, + fluid, + *this, + time_n, + dt, + nonlinearSolverParameters.m_minNormalizer, + subRegionResidualNorm ); + + // step 2: reduction across meshBodies/regions/subRegions + if( subRegionResidualNorm[0] > localResidualNorm[0] ) { - real64 subRegionResidualNorm[1]{}; - ResidualNormKernelFactory:: - createAndLaunch< parallelDevicePolicy<> >( rankOffset, - wellDofKey, - localRhs, - subRegion, - fluid, - wellControls, - time_n, - dt, - m_nonlinearSolverParameters.m_minNormalizer, - subRegionResidualNorm ); - - // step 2: reduction across meshBodies/regions/subRegions - - if( subRegionResidualNorm[0] > localResidualNorm[0] ) - { - localResidualNorm[0] = subRegionResidualNorm[0]; - } + localResidualNorm[0] = subRegionResidualNorm[0]; } - } ); - } ); + } + } + + return localResidualNorm; +} + +real64 +SinglePhaseWell::calculateWellResidualNorm( real64 const & time_n, + real64 const & dt, + NonlinearSolverParameters const & nonlinearSolverParameters, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localRhs ) +{ + GEOS_MARK_FUNCTION; + integer numNorm = 1; // mass balance + array1d< real64 > localResidualNorm; + array1d< real64 > localResidualNormalizer; + if( isThermal() ) + { + numNorm = 2; // mass balance and energy balance + } + localResidualNorm.resize( numNorm ); + localResidualNormalizer.resize( numNorm ); + + + //globalIndex const rankOffset = dofManager.rankOffset(); + string const wellDofKey = dofManager.getKey( wellElementDofName() ); + + if( isWellOpen() ) + { + localResidualNorm = calculateLocalWellResidualNorm( time_n, + dt, + nonlinearSolverParameters, + subRegion, + dofManager, + localRhs ); + } real64 resNorm=localResidualNorm[0]; if( isThermal() ) { @@ -1044,8 +1137,8 @@ SinglePhaseWell::calculateResidualNorm( real64 const & time_n, GEOS_LOG_LEVEL_RANK_0_NLR( logInfo::ResidualNorm, GEOS_FMT( " ( R{} ) = ( {:4.2e} ) ( Renergy ) = ( {:4.2e} )", coupledSolverAttributePrefix(), globalResidualNorm[0], globalResidualNorm[1] )); - getConvergenceStats().setResidualValue( GEOS_FMT( "R{}", coupledSolverAttributePrefix()), globalResidualNorm[0] ); - getConvergenceStats().setResidualValue( "Renergy", globalResidualNorm[1] ); + //getConvergenceStats().setResidualValue( GEOS_FMT( "R{}", coupledSolverAttributePrefix()), globalResidualNorm[0] ); + //getConvergenceStats().setResidualValue( "Renergy", globalResidualNorm[1] ); } else { @@ -1053,76 +1146,64 @@ SinglePhaseWell::calculateResidualNorm( real64 const & time_n, GEOS_LOG_LEVEL_RANK_0_NLR( logInfo::ResidualNorm, GEOS_FMT( " ( R{} ) = ( {:4.2e} )", coupledSolverAttributePrefix(), resNorm )); - getConvergenceStats().setResidualValue( GEOS_FMT( "R{}", coupledSolverAttributePrefix()), resNorm ); + //getConvergenceStats().setResidualValue( GEOS_FMT( "R{}", coupledSolverAttributePrefix()), resNorm ); } return resNorm; } - -bool SinglePhaseWell::checkSystemSolution( DomainPartition & domain, - DofManager const & dofManager, - arrayView1d< real64 const > const & localSolution, - real64 const scalingFactor ) +bool SinglePhaseWell::checkWellSystemSolution( WellElementSubRegion & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution, + real64 const scalingFactor, + real64 & minPressure, + real64 & minDensity, + real64 & minTotalDensity, + ElementsReporterBuffer & negPressureIds, + ElementsReporterBuffer & negDensityIds, + ElementsReporterBuffer & negTotalDensityIds ) { GEOS_MARK_FUNCTION; + GEOS_UNUSED_VAR( minDensity, minTotalDensity ); + GEOS_UNUSED_VAR( negDensityIds, negTotalDensityIds ); + string const wellDofKey = dofManager.getKey( wellElementDofName() ); - ElementsReporterBuffer rankNegPressureIds{ isLogLevelActive< logInfo::Solution >( getLogLevel() ), - isLogLevelActive< logInfo::SolutionDetails >( getLogLevel() ) ? 16 : 0 }; - real64 minNegPres = 0.0; - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel const & mesh, - string_array const & regionNames ) - { + globalIndex const rankOffset = dofManager.rankOffset(); + // get the degree of freedom numbers on well elements + arrayView1d< globalIndex const > const & dofNumber = subRegion.getReference< array1d< globalIndex > >( wellDofKey ); + arrayView1d< integer const > const & ghostRank = subRegion.ghostRank(); - ElementRegionManager const & elemManager = mesh.getElemManager(); + // get a reference to the primary variables on well elements + arrayView1d< real64 const > const & pressure = subRegion.getField< well::pressure >(); + auto const negPresCollector = negPressureIds.createCollector( subRegion.localToGlobalMap().toViewConst() ); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion const & subRegion ) + using Kernel = singlePhaseBaseKernels::SolutionCheckKernel; - { - globalIndex const rankOffset = dofManager.rankOffset(); - // get the degree of freedom numbers on well elements - arrayView1d< globalIndex const > const & dofNumber = - subRegion.getReference< array1d< globalIndex > >( wellDofKey ); - arrayView1d< integer const > const & ghostRank = subRegion.ghostRank(); - - // get a reference to the primary variables on well elements - arrayView1d< real64 const > const & pres = - subRegion.getField< well::pressure >(); - - auto const negPresCollector = rankNegPressureIds.createCollector( subRegion.localToGlobalMap().toViewConst() ); - - auto const results = singlePhaseBaseKernels::SolutionCheckKernel:: - launch< parallelDevicePolicy<> >( localSolution, - rankOffset, - dofNumber, - ghostRank, - pres, - scalingFactor, - negPresCollector ); - - minNegPres = std::min( minNegPres, results.minNegPres ); - } ); - } ); + auto const results = Kernel::launch< parallelDevicePolicy<> >( localSolution, + rankOffset, + dofNumber, + ghostRank, + pressure, + scalingFactor, + negPresCollector ); - ElementsReporterOutput const rankNegPressureIdsOutput = rankNegPressureIds.createOutput(); - rankNegPressureIdsOutput.outputTooLowValues( GEOS_FMT( " {}: ", getName() ), - "negative pressure", minNegPres, units::Unit::Pressure ); + minPressure = std::min( minPressure, results.minNegPres ); - return (m_allowNegativePressure || rankNegPressureIdsOutput.getRanksSignaledIdsCount() == 0) ? 1 : 0; + return (m_allowNegativePressure || 0.0 < results.minNegPres) ? 1 : 0; } void -SinglePhaseWell::applySystemSolution( DofManager const & dofManager, - arrayView1d< real64 const > const & localSolution, - real64 const scalingFactor, - real64 const dt, - DomainPartition & domain ) +SinglePhaseWell::applyWellSystemSolution( DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution, + real64 const scalingFactor, + real64 const dt, + DomainPartition & domain, + MeshLevel & mesh, + WellElementSubRegion & subRegion ) { GEOS_UNUSED_VAR( dt ); + GEOS_UNUSED_VAR( subRegion ); DofManager::CompMask pressureMask( m_numDofPerWellElement, 0, 1 ); DofManager::CompMask connRateMask( m_numDofPerWellElement, 1, 2 ); dofManager.addVectorToField( localSolution, @@ -1149,216 +1230,197 @@ SinglePhaseWell::applySystemSolution( DofManager const & dofManager, } - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) + + FieldIdentifiers fieldsToBeSync; + if( isThermal() ) { - FieldIdentifiers fieldsToBeSync; - if( isThermal() ) - { - fieldsToBeSync.addElementFields( { well::pressure::key(), - well::connectionRate::key(), - well::temperature::key() }, - regionNames ); - } - else - { - fieldsToBeSync.addElementFields( { well::pressure::key(), - well::connectionRate::key() }, - regionNames ); - } - CommunicationTools::getInstance().synchronizeFields( fieldsToBeSync, - mesh, - domain.getNeighbors(), - true ); - } ); + fieldsToBeSync.addElementFields( { well::pressure::key(), + well::connectionRate::key(), + well::temperature::key() }, + getTargetRegionNames() ); + } + else + { + fieldsToBeSync.addElementFields( { well::pressure::key(), + well::connectionRate::key() }, + getTargetRegionNames() ); + } + CommunicationTools::getInstance().synchronizeFields( fieldsToBeSync, + mesh, + domain.getNeighbors(), + true ); + } -void SinglePhaseWell::resetStateToBeginningOfStep( DomainPartition & domain ) + +void SinglePhaseWell::resetStateToBeginningOfStep( DomainPartition & domain, + string const & meshBodyName, ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ) { - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { - ElementRegionManager & elemManager = mesh.getElemManager(); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion & subRegion ) - { - // get a reference to the primary variables on well elements - arrayView1d< real64 > const & wellElemPressure = - subRegion.getField< well::pressure >(); - arrayView1d< real64 const > const & wellElemPressure_n = - subRegion.getField< well::pressure_n >(); - wellElemPressure.setValues< parallelDevicePolicy<> >( wellElemPressure_n ); - - if( isThermal() ) - { - arrayView1d< real64 > const & wellElemTemperature = - subRegion.getField< fields::well::temperature >(); - arrayView1d< real64 const > const & wellElemTemperature_n = - subRegion.getField< fields::well::temperature_n >(); - wellElemTemperature.setValues< parallelDevicePolicy<> >( wellElemTemperature_n ); - } - arrayView1d< real64 > const & connRate = - subRegion.getField< well::connectionRate >(); - arrayView1d< real64 const > const & connRate_n = - subRegion.getField< well::connectionRate_n >(); - connRate.setValues< parallelDevicePolicy<> >( connRate_n ); + // get a reference to the primary variables on well elements + arrayView1d< real64 > const & wellElemPressure = + subRegion.getField< well::pressure >(); + arrayView1d< real64 const > const & wellElemPressure_n = + subRegion.getField< well::pressure_n >(); + wellElemPressure.setValues< parallelDevicePolicy<> >( wellElemPressure_n ); + + if( isThermal() ) + { + arrayView1d< real64 > const & wellElemTemperature = + subRegion.getField< fields::well::temperature >(); + arrayView1d< real64 const > const & wellElemTemperature_n = + subRegion.getField< fields::well::temperature_n >(); + wellElemTemperature.setValues< parallelDevicePolicy<> >( wellElemTemperature_n ); + } + arrayView1d< real64 > const & connRate = + subRegion.getField< well::connectionRate >(); + arrayView1d< real64 const > const & connRate_n = + subRegion.getField< well::connectionRate_n >(); + connRate.setValues< parallelDevicePolicy<> >( connRate_n ); + updateSubRegionState( -1.0, domain.getMeshBody( meshBodyName ), elemManager, subRegion ); - updateSubRegionState( subRegion ); - } ); - } ); } +void SinglePhaseWell::saveState( WellElementSubRegion & subRegion ) +{ + arrayView1d< real64 const > const wellElemPressure = subRegion.getField< well::pressure >(); + arrayView1d< real64 > const wellElemPressure_n = subRegion.getField< well::pressure_n >(); + wellElemPressure_n.setValues< parallelDevicePolicy<> >( wellElemPressure ); + + if( isThermal() ) + { + arrayView1d< real64 const > const wellElemTemperature = subRegion.getField< well::temperature >(); + arrayView1d< real64 > const wellElemTemperature_n = subRegion.getField< well::temperature_n >(); + wellElemTemperature_n.setValues< parallelDevicePolicy<> >( wellElemTemperature ); + } + arrayView1d< real64 const > const connRate = subRegion.getField< well::connectionRate >(); + arrayView1d< real64 > const connRate_n = subRegion.getField< well::connectionRate_n >(); + connRate_n.setValues< parallelDevicePolicy<> >( connRate ); + + SingleFluidBase const & fluid = + getConstitutiveModel< SingleFluidBase >( subRegion, subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ) ); + fluid.saveConvergedState(); +} -void SinglePhaseWell::implicitStepSetup( real64 const & time, +void SinglePhaseWell::implicitStepSetup( real64 const & time_n, real64 const & dt, - DomainPartition & domain ) + DomainPartition & domain, + string const & meshBodyName, + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion ) { - WellSolverBase::implicitStepSetup( time, dt, domain ); - - if( m_reservoirStatsAggregator ) - m_reservoirStatsAggregator->setDirty(); // TODO: is it useful? are timestep cut properly managed for this call? + GEOS_MARK_FUNCTION; + WellControls::implicitStepSetup( time_n, dt, domain, meshBodyName, elemManager, subRegion ); + arrayView1d< real64 const > const wellElemPressure = subRegion.getField< well::pressure >(); + arrayView1d< real64 > const wellElemPressure_n = subRegion.getField< well::pressure_n >(); + wellElemPressure_n.setValues< parallelDevicePolicy<> >( wellElemPressure ); - Group & meshBodies = domain.getMeshBodies(); - forDiscretizationOnMeshTargets( meshBodies, [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) + if( isThermal() ) { - ElementRegionManager & elemManager = mesh.getElemManager(); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion & subRegion ) - { - arrayView1d< real64 const > const wellElemPressure = subRegion.getField< well::pressure >(); - arrayView1d< real64 > const wellElemPressure_n = subRegion.getField< well::pressure_n >(); - wellElemPressure_n.setValues< parallelDevicePolicy<> >( wellElemPressure ); + arrayView1d< real64 const > const wellElemTemperature = subRegion.getField< well::temperature >(); + arrayView1d< real64 > const wellElemTemperature_n = subRegion.getField< well::temperature_n >(); + wellElemTemperature_n.setValues< parallelDevicePolicy<> >( wellElemTemperature ); + } + arrayView1d< real64 const > const connRate = subRegion.getField< well::connectionRate >(); + arrayView1d< real64 > const connRate_n = subRegion.getField< well::connectionRate_n >(); + connRate_n.setValues< parallelDevicePolicy<> >( connRate ); - if( isThermal() ) - { - arrayView1d< real64 const > const wellElemTemperature = subRegion.getField< well::temperature >(); - arrayView1d< real64 > const wellElemTemperature_n = subRegion.getField< well::temperature_n >(); - wellElemTemperature_n.setValues< parallelDevicePolicy<> >( wellElemTemperature ); - } - arrayView1d< real64 const > const connRate = subRegion.getField< well::connectionRate >(); - arrayView1d< real64 > const connRate_n = subRegion.getField< well::connectionRate_n >(); - connRate_n.setValues< parallelDevicePolicy<> >( connRate ); + SingleFluidBase const & fluid = + getConstitutiveModel< SingleFluidBase >( subRegion, subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ) ); + fluid.saveConvergedState(); - SingleFluidBase const & fluid = - getConstitutiveModel< SingleFluidBase >( subRegion, subRegion.getReference< string >( viewKeyStruct::fluidNamesString() ) ); - fluid.saveConvergedState(); + validateWellConstraints( time_n, dt, subRegion ); - validateWellConstraints( time, dt, subRegion ); + updateSubRegionState( time_n, domain.getMeshBody( meshBodyName ), elemManager, subRegion ); - updateSubRegionState( subRegion ); - } ); - } ); } void SinglePhaseWell::implicitStepComplete( real64 const & time_n, real64 const & dt, - DomainPartition & domain ) + WellElementSubRegion const & subRegion ) { - WellSolverBase::implicitStepComplete( time_n, dt, domain ); - - if( getLogLevel() > 0 ) - { - printRates( time_n, dt, domain ); - } + printRates( time_n, dt, subRegion ); } void SinglePhaseWell::printRates( real64 const & time_n, - real64 const & GEOS_UNUSED_PARAM( dt ), - DomainPartition & domain ) + real64 const & dt, + WellElementSubRegion const & subRegion ) { - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) - { - - ElementRegionManager & elemManager = mesh.getElemManager(); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion & subRegion ) - { - - // the rank that owns the reference well element is responsible for the calculations below. - if( !subRegion.isLocallyOwned() ) - { - return; - } - - localIndex const iwelemRef = subRegion.getTopWellElementIndex(); + GEOS_UNUSED_VAR( dt ); + // the rank that owns the reference well element is responsible for the calculations below. + if( !subRegion.isLocallyOwned() ) + { + return; + } - // subRegion data + localIndex const iwelemRef = subRegion.getTopWellElementIndex(); - arrayView1d< real64 const > const & connRate = - subRegion.getField< well::connectionRate >(); + // subRegion data - // control data + arrayView1d< real64 const > const & connRate = + subRegion.getField< well::connectionRate >(); - WellControls const & wellControls = getWellControls( subRegion ); - string const wellControlsName = wellControls.getName(); + // control data - // format: time,total_rate,total_vol_rate - std::ofstream outputFile; - if( m_writeCSV > 0 ) - { - outputFile.open( m_ratesOutputDir + "/" + wellControlsName + ".csv", std::ios_base::app ); - outputFile << time_n; - } - if( !wellControls.isWellOpen() ) - { - GEOS_LOG( GEOS_FMT( "{}: well is shut", wellControlsName ) ); - if( outputFile.is_open()) - { - // print all zeros in the rates file - outputFile << ",0.0,0.0,0.0" << std::endl; - outputFile.close(); - } - return; - } + string const wellControlsName = getName(); - integer const useSurfaceConditions = wellControls.useSurfaceConditions(); + // format: time,total_rate,total_vol_rate + std::ofstream outputFile; + if( m_writeCSV > 0 ) + { + outputFile.open( m_ratesOutputDir + "/" + wellControlsName + ".csv", std::ios_base::app ); + outputFile << time_n; + } - real64 const & currentBHP = - wellControls.getReference< real64 >( SinglePhaseWell::viewKeyStruct::currentBHPString() ); - real64 const & currentTotalVolRate = - wellControls.getReference< real64 >( SinglePhaseWell::viewKeyStruct::currentVolRateString() ); + if( !isWellOpen() ) + { + GEOS_LOG( GEOS_FMT( "{}: well is shut", wellControlsName ) ); + if( outputFile.is_open()) + { + // print all zeros in the rates file + outputFile << ",0.0,0.0,0.0" << std::endl; + outputFile.close(); + } + return; + } - // bring everything back to host, capture the scalars by reference - forAll< serialPolicy >( 1, [&useSurfaceConditions, - ¤tBHP, - connRate, - ¤tTotalVolRate, - &iwelemRef, - &wellControlsName, - &outputFile] ( localIndex const ) - { - string const conditionKey = useSurfaceConditions ? "surface" : "reservoir"; - string const unitKey = useSurfaceConditions ? "s" : "r"; - - real64 const currentTotalRate = connRate[iwelemRef]; - GEOS_LOG( GEOS_FMT( "{}: BHP (at the specified reference elevation): {} Pa", - wellControlsName, currentBHP ) ); - GEOS_LOG( GEOS_FMT( "{}: Total rate: {} kg/s; total {} volumetric rate: {} {}m3/s", - wellControlsName, currentTotalRate, conditionKey, currentTotalVolRate, unitKey ) ); - if( outputFile.is_open()) - { - outputFile << "," << currentBHP; - outputFile << "," << currentTotalRate << "," << currentTotalVolRate << std::endl; - outputFile.close(); - } - } ); - } ); + integer const useSurfaceCond = useSurfaceConditions(); + + real64 const & currentBHP = + getReference< real64 >( WellControls::viewKeyStruct::currentBHPString() ); + real64 const & currentTotalVolRate = + getReference< real64 >( WellControls::viewKeyStruct::currentVolRateString() ); + + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [&useSurfaceCond, + ¤tBHP, + connRate, + ¤tTotalVolRate, + &iwelemRef, + &wellControlsName, + &outputFile] ( localIndex const ) + { + string const conditionKey = useSurfaceCond ? "surface" : "reservoir"; + string const unitKey = useSurfaceCond ? "s" : "r"; + + real64 const currentTotalRate = connRate[iwelemRef]; + GEOS_LOG( GEOS_FMT( "{}: BHP (at the specified reference elevation): {} Pa", + wellControlsName, currentBHP ) ); + GEOS_LOG( GEOS_FMT( "{}: Total rate: {} kg/s; total {} volumetric rate: {} {}m3/s", + wellControlsName, currentTotalRate, conditionKey, currentTotalVolRate, unitKey ) ); + if( outputFile.is_open()) + { + outputFile << "," << currentBHP; + outputFile << "," << currentTotalRate << "," << currentTotalVolRate << std::endl; + outputFile.close(); + } } ); } -REGISTER_CATALOG_ENTRY( PhysicsSolverBase, SinglePhaseWell, string const &, Group * const ) + + }// namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.hpp index b82ebe96342..84b2888594d 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.hpp @@ -20,7 +20,7 @@ #ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_SINGLEPHASEWELL_HPP_ #define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_SINGLEPHASEWELL_HPP_ -#include "WellSolverBase.hpp" +#include "physicsSolvers/fluidFlow/wells/WellControls.hpp" #include "constitutive/fluid/singlefluid/SingleFluidLayouts.hpp" @@ -49,7 +49,7 @@ class WellElementSubRegion; * * A single-phase well solver */ -class SinglePhaseWell : public WellSolverBase +class SinglePhaseWell : public WellControls { public: @@ -69,7 +69,7 @@ class SinglePhaseWell : public WellSolverBase SinglePhaseWell( SinglePhaseWell const & ) = delete; /// default move constructor - SinglePhaseWell( SinglePhaseWell && ) = default; + SinglePhaseWell( SinglePhaseWell && ) = delete; /// deleted assignment operator SinglePhaseWell & operator=( SinglePhaseWell const & ) = delete; @@ -80,59 +80,164 @@ class SinglePhaseWell : public WellSolverBase /** * @brief default destructor */ - virtual ~SinglePhaseWell() override = default; + virtual ~SinglePhaseWell() override; + void registerWellDataOnMesh( WellElementSubRegion & subRegion ) override; + + /** + * @defgroup WellManager Interface Functions + * + * These functions provide the primary interface that is required for derived classes + * The "Well" versions apply to individual well subRegions, whereas the others apply to all wells + */ + /**@{*/ + /** + * * @brief Initialize well for the beginning of a simulation or restart + * @param domain the domain + * @param mesh the mesh level + * @param subRegion the well subRegion + * @param time_n the current time + */ + virtual void initializeWell( DomainPartition & domain, Group & meshBodies, string const & meshBodyName, MeshLevel & mesh, WellElementSubRegion & subRegion, real64 const & time_n )override; + + virtual void initializeWellPostInitialConditionsPreSubGroups( WellElementSubRegion & subRegion )override; + + virtual bool isCompositional() const override { return false; } + /** + * @copydoc WellControls::assembleWellAccumulationTerms() + */ + virtual void assembleWellAccumulationTerms( real64 const & time, + real64 const & dt, + WellElementSubRegion & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) override; /** - * @brief name of the node manager in the object catalog - * @return string that contains the catalog name to generate a new NodeManager object through the object catalog. + * @copydoc WellControls::assembleWellConstraintTerms() */ - static string catalogName() { return "SinglePhaseWell"; } + virtual void assembleWellPressureRelations( real64 const & time_n, + real64 const & dt, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) override; + /** - * @copydoc PhysicsSolverBase::getCatalogName() + * @copydoc WellControls::assembleWellConstraintTerms() */ - string getCatalogName() const override { return catalogName(); } + virtual void assembleWellConstraintTerms( real64 const & time_n, + real64 const & dt, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) override; - virtual void registerDataOnMesh( Group & meshBodies ) override; + /** + * @copydoc WellControls::computeWellPerforationRates() + */ + virtual void computeWellPerforationRates( real64 const & time_n, + real64 const & GEOS_UNUSED_PARAM( dt ), + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion ) override; + + /** + * @copydoc WellControls::assembleFluxTerms() + */ + virtual void assembleWellFluxTerms( real64 const & time, + real64 const & dt, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) override; + /**@}*/ /** * @defgroup Solver Interface Functions * * These functions provide the primary interface that is required for derived classes + * The "Well" versions apply to individual well subRegions, whereas the others apply to all wells */ /**@{*/ - virtual real64 - calculateResidualNorm( real64 const & time_n, - real64 const & dt, - DomainPartition const & domain, - DofManager const & dofManager, - arrayView1d< real64 const > const & localRhs ) override; + virtual array1d< real64 > + calculateLocalWellResidualNorm( real64 const & time_n, + real64 const & dt, + NonlinearSolverParameters const & nonlinearSolverParameters, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localRhs )override; - virtual bool - checkSystemSolution( DomainPartition & domain, - DofManager const & dofManager, - arrayView1d< real64 const > const & localSolution, - real64 const scalingFactor ) override; - virtual void - applySystemSolution( DofManager const & dofManager, - arrayView1d< real64 const > const & localSolution, - real64 const scalingFactor, - real64 const dt, - DomainPartition & domain ) override; + virtual real64 + calculateWellResidualNorm( real64 const & time_n, + real64 const & dt, + NonlinearSolverParameters const & nonlinearSolverParameters, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localRhs ) override; + + virtual real64 scalingForWellSystemSolution( WellElementSubRegion & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution ) override; + /** + * @copydoc WellControls::checkSystemSolution() + */ - virtual void - resetStateToBeginningOfStep( DomainPartition & domain ) override; + virtual bool + checkWellSystemSolution( WellElementSubRegion & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution, + real64 const scalingFactor, + real64 & minPressure, + real64 & minDensity, + real64 & minTotalDensity, + ElementsReporterBuffer & negPressureIds, + ElementsReporterBuffer & negDensityIds, + ElementsReporterBuffer & negTotalDensityIds ) override; + /** + * @copydoc WellControls::applyWellSystemSolution() + */ virtual void - implicitStepSetup( real64 const & time, - real64 const & dt, - DomainPartition & domain ) override; + applyWellSystemSolution( DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution, + real64 const scalingFactor, + real64 const dt, + DomainPartition & domain, + MeshLevel & mesh, + WellElementSubRegion & subRegion ) override; + + virtual void applyWellBoundaryConditions ( real64 const GEOS_UNUSED_PARAM( time_n ), + real64 const GEOS_UNUSED_PARAM( dt ), + ElementRegionManager & GEOS_UNUSED_PARAM( elemManager ), + WellElementSubRegion & GEOS_UNUSED_PARAM( subRegion ), + DofManager const & GEOS_UNUSED_PARAM( dofManager ), + arrayView1d< real64 > const & GEOS_UNUSED_PARAM( localRhs ), + CRSMatrixView< real64, globalIndex const > const & GEOS_UNUSED_PARAM( localMatrix ) )override {}; + + virtual void resetStateToBeginningOfStep( DomainPartition & domain, + string const & meshBodyName, ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ) override; + + virtual void implicitStepSetup( real64 const & time_n, + real64 const & GEOS_UNUSED_PARAM( dt ), + DomainPartition & domain, + string const & meshBodyName, + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion )override; virtual void implicitStepComplete( real64 const & time, real64 const & dt, - DomainPartition & domain ) override; + WellElementSubRegion const & subRegion ) override; + + virtual void printRates( real64 const & time_n, + real64 const & dt, + WellElementSubRegion const & subRegion ) override; + + virtual real64 updateSubRegionState( real64 const time_n, + MeshBody const & meshBody, + ElementRegionManager const & elemManager, + WellElementSubRegion & subRegion ) override; /**@}*/ @@ -140,17 +245,10 @@ class SinglePhaseWell : public WellSolverBase virtual string resElementDofName() const override; - virtual localIndex numFluidComponents() const override { return 1; } + virtual localIndex numFluidComponents() const override { return 0; } virtual localIndex numFluidPhases() const override { return 1; } - /** - * @brief Recompute the volumetric rate that are used in the well constraints - * @param elemManager the well region manager - * @param subRegion the well subregion containing all the primary and dependent fields - */ - virtual void updateVolRateForConstraint( WellElementSubRegion & subRegion ); - /** * @brief Recompute the BHP pressure that is used in the well constraints * @param subRegion the well subregion containing all the primary and dependent fields @@ -162,124 +260,62 @@ class SinglePhaseWell : public WellSolverBase * @param subRegion the well subRegion containing the well elements and their associated fields */ virtual void updateFluidModel( WellElementSubRegion & subRegion ) const; - /** - * @brief Recompute the perforation rates for all the wells - * @param domain the domain containing the mesh and fields + * @brief Update separator model state + * @param elemManager the element region manager + * @param subRegion the well subRegion containing the separator */ - virtual void computePerforationRates( real64 const & time_n, - real64 const & dt, DomainPartition & domain ) override; + void updateSeparator( ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ); /** - * @brief Recompute all dependent quantities from primary variables (including constitutive models) - * @param elemManager the elemManager containing the well + * @brief Calculate well rates at the reference element * @param subRegion the well subRegion containing the well elements and their associated fields */ - virtual real64 updateSubRegionState( WellElementSubRegion & subRegion ) override; + void calculateReferenceElementRates( WellElementSubRegion & subRegion ); /** - * @brief function to assemble the linear system matrix and rhs - * @param time the time at the beginning of the step - * @param dt the desired timestep - * @param domain the domain partition - * @param dofManager degree-of-freedom manager associated with the linear system - * @param matrix the system matrix - * @param rhs the system right-hand side vector - */ - virtual void assembleSystem( real64 const time, - real64 const dt, - DomainPartition & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) override; + * @brief Recompute all dependent quantities from primary variables (including constitutive + * models) - /** - * @brief assembles the flux terms for all connections between well elements - * @param time_n previous time value - * @param dt time step - * @param domain the physical domain object - * @param dofManager degree-of-freedom manager associated with the linear system - * @param matrix the system matrix - * @param rhs the system right-hand side vector + * @param + * @param subRegion the well subRegion containing the well elements and their associated */ - virtual void assembleFluxTerms( real64 const & time_n, - real64 const & dt, - DomainPartition & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) override; - - /** - * @brief assembles the accumulation term for all the well elements - * @param domain the physical domain object - * @param dofManager degree-of-freedom manager associated with the linear system - * @param matrix the system matrix - * @param rhs the system right-hand side vector - */ - virtual void assembleAccumulationTerms( real64 const & time_n, - real64 const & dt, DomainPartition & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) override; - - /** - * @brief assembles the volume balance terms for all well elements - * @param domain the physical domain object - * @param dofManager degree-of-freedom manager associated with the linear system - * @param matrix the system matrix - * @param rhs the system right-hand side vector - */ - void assembleVolumeBalanceTerms( DomainPartition const & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ); + virtual real64 updateWellState( MeshBody const & meshBody, + ElementRegionManager const & elemManager, + WellElementSubRegion & subRegion ) override; - /** - * @brief assembles the pressure relations at all connections between well elements except at the well head - * @param time_n time at the beginning of the time step - * @param dt the time step size - * @param domain the physical domain object - * @param dofManager degree-of-freedom manager associated with the linear system - * @param matrix the system matrix - * @param rhs the system right-hand side vector - */ - virtual void assemblePressureRelations( real64 const & time_n, - real64 const & dt, - DomainPartition const & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) override; /* * @brief apply a special treatment to the wells that are shut - * @param time_n the time at the previous converged time step - * @param domain the physical domain object + * @param dofManager degree-of-freedom manager associated with the linear system * @param matrix the system matrix * @param rhs the system right-hand side vector */ - void shutDownWell( real64 const time_n, - DomainPartition const & domain, + void shutDownWell( WellElementSubRegion & subRegion, DofManager const & dofManager, CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ); - struct viewKeyStruct : WellSolverBase::viewKeyStruct + + void assembleVolumeBalanceTerms( DomainPartition const & domain, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ); + + struct viewKeyStruct : WellControls::viewKeyStruct { - static constexpr char const * dofFieldString() { return "singlePhaseWellVars"; } + static constexpr char const * dofFieldString() { return "wellVars"; } + - // control data (not registered on the mesh) - static constexpr char const * currentBHPString() { return "currentBHP"; } - static constexpr char const * dCurrentBHPString() { return "dCurrentBHP"; } - static constexpr char const * currentVolRateString() { return "currentVolumetricRate"; } - static constexpr char const * dCurrentVolRateString() { return "dCurrentVolRate"; } }; protected: - void printRates( real64 const & time_n, - real64 const & dt, - DomainPartition & domain ) override; + virtual void initializePostInitialConditionsPreSubGroups() override; + + void saveState( WellElementSubRegion & subRegion ); + virtual void postRestartInitialization( )override; /// flag if negative pressure is allowed integer m_allowNegativePressure; @@ -300,7 +336,7 @@ class SinglePhaseWell : public WellSolverBase * @brief Initialize all the primary and secondary variables in all the wells * @param domain the domain containing the well manager to access individual wells */ - void initializeWells( DomainPartition & domain, real64 const & time_n ) override; + void initializeWells( DomainPartition & domain, real64 const & time_n ); void precomputeReferenceConditions( real64 time_n, Group & meshBodies, @@ -317,7 +353,15 @@ class SinglePhaseWell : public WellSolverBase */ virtual void validateWellConstraints( real64 const & time_n, real64 const & dt, - WellElementSubRegion const & subRegion ) override; + WellElementSubRegion const & subRegion + ) override; + + + + /** + * @brief Create well separator + */ + virtual void createSeparator( WellElementSubRegion & subRegion ) override; }; diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWellFields.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWellFields.hpp index 2cd21f32866..9e0d5472826 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWellFields.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWellFields.hpp @@ -33,21 +33,6 @@ namespace fields namespace well { -DECLARE_FIELD( connectionRate, - "connectionRate", - array1d< real64 >, - 0, - LEVEL_0, - WRITE_AND_READ, - "Connection rate" ); - -DECLARE_FIELD( connectionRate_n, - "connectionRate_n", - array1d< real64 >, - 0, - NOPLOT, - WRITE_AND_READ, - "Connection rate at the previous converged time step" ); DECLARE_FIELD( density_n, "density_n", diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellBHPConstraints.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellBHPConstraints.cpp new file mode 100644 index 00000000000..c6fbca6e40c --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellBHPConstraints.cpp @@ -0,0 +1,97 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellBHPConstraints.cpp + */ + +#include "LogLevelsInfo.hpp" +#include "WellBHPConstraints.hpp" +#include "WellConstants.hpp" +#include "dataRepository/InputFlags.hpp" +#include "functions/FunctionManager.hpp" + + +namespace geos +{ + +using namespace dataRepository; + +template< BHPConstraintTypeId T > +BHPConstraint< T >::BHPConstraint( string const & name, Group * const parent ) + : WellConstraintBase( name, parent ), + m_refElevation( 0.0 ), + m_refGravCoef( 0.0 ) +{ + setInputFlags( InputFlags::OPTIONAL_NONUNIQUE ); + + registerWrapper( viewKeyStruct::refElevString(), &m_refElevation ). + setDefaultValue( -1 ). + setInputFlag( InputFlags::REQUIRED ). + setDescription( "Reference elevation where BHP control is enforced [m]" ); + if constexpr (T == BHPConstraintTypeId::MAX) + { + // override the description for minimum BHP constraint + registerWrapper( viewKeyStruct::targetBHPString(), &m_constraintValue ). + setDefaultValue( 0.0 ). + setInputFlag( InputFlags::OPTIONAL ). + setRestartFlags( RestartFlags::WRITE_AND_READ ). + setDescription( "Maximum bottom-hole production pressure [Pa]" ); + } + else + { + registerWrapper( viewKeyStruct::targetBHPString(), &m_constraintValue ). + setDefaultValue( 0.0 ). + setInputFlag( InputFlags::OPTIONAL ). + setRestartFlags( RestartFlags::WRITE_AND_READ ). + setDescription( "Minimum bottom-hole production pressure [Pa]" ); + } +} + +template< BHPConstraintTypeId T > +BHPConstraint< T >::~BHPConstraint() +{} + +template< BHPConstraintTypeId T > +void BHPConstraint< T >::postInputInitialization() +{ + WellConstraintBase::postInputInitialization(); +} + + +template< BHPConstraintTypeId T > +bool BHPConstraint< T >::checkViolation( WellConstraintBase const & currentConstraint, real64 const & currentTime ) const +{ + if constexpr (T == BHPConstraintTypeId::MAX) + { + return currentConstraint.bottomHolePressure() > getConstraintValue( currentTime ); + } + else + { + return currentConstraint.bottomHolePressure() < getConstraintValue( currentTime ); + } +} + + +template class BHPConstraint< BHPConstraintTypeId::MIN >; +template class BHPConstraint< BHPConstraintTypeId::MAX >; +namespace +{ +typedef BHPConstraint< BHPConstraintTypeId::MIN > MinimumBHPConstraint; +typedef BHPConstraint< BHPConstraintTypeId::MAX > MaximumBHPConstraint; +REGISTER_CATALOG_ENTRY( WellConstraintBase, MinimumBHPConstraint, string const &, Group * const ) +REGISTER_CATALOG_ENTRY( WellConstraintBase, MaximumBHPConstraint, string const &, Group * const ) +} +} //namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellBHPConstraints.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellBHPConstraints.hpp new file mode 100644 index 00000000000..63a637e18c5 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellBHPConstraints.hpp @@ -0,0 +1,177 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellBHPConstraints.hpp + */ + +#ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLBHPCONSTRAINTS_HPP +#define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLBHPCONSTRAINTS_HPP + +#include "common/format/EnumStrings.hpp" +#include "dataRepository/Group.hpp" +#include "functions/TableFunction.hpp" +#include "WellConstraintsBase.hpp" +namespace geos +{ + +enum class BHPConstraintTypeId : integer +{ + MIN, /**< The well operates at a specified minimum bottom hole pressure (BHP) */ + MAX, /**< The well operates at a specified maximum bottom hole pressure (BHP) */ + UNINITIALIZED, /**< This is the current well control before postInputInitialization (needed to restart from file properly) */ +}; + + +/** + * @class BHPConstraint + * @brief This class describes a minimum pressure constraint used to control a injection well. + */ +template< BHPConstraintTypeId T > +class BHPConstraint : public WellConstraintBase +{ +public: + /** + * @name Constructor / Destructor + */ + ///@{ + + /** + * @brief Constructor for WellControls Objects. + * @param[in] name the name of this instantiation of WellControls in the repository + * @param[in] parent the parent group of this instantiation of WellControls + */ + explicit BHPConstraint( string const & name, dataRepository::Group * const parent ); + + + /** + * @brief Default destructor. + */ + ~BHPConstraint() override; + + /** + * @brief Deleted default constructor. + */ + BHPConstraint() = delete; + + /** + * @brief Deleted copy constructor. + */ + BHPConstraint( BHPConstraint const & ) = delete; + + /** + * @brief Deleted move constructor. + */ + BHPConstraint( BHPConstraint && ) = delete; + + /** + * @brief Deleted assignment operator. + * @return a reference to a constraint object + */ + BHPConstraint & operator=( BHPConstraint const & ) = delete; + + /** + * @brief Deleted move operator. + * @return a reference to a constraint object + */ + BHPConstraint & operator=( BHPConstraint && ) = delete; + + ///@} + + /** + * @name Getters / Setters + */ + ///@{ + + // Temp interface - tjb + virtual ConstraintTypeId getControl() const override { return ConstraintTypeId::BHP; }; + + ///@} + /** + * @brief Struct to serve as a container for variable strings and keys. + * @struct viewKeyStruct + */ + struct viewKeyStruct + { + /// String key for the well target BHP + static constexpr char const * targetBHPString() { return "targetBHP"; } + /// String key for the well reference elevation (for BHP control) + static constexpr char const * refElevString() { return "referenceElevation"; } + } + viewKeysWellBHPConstraint; + + virtual bool checkViolation( WellConstraintBase const & currentConstraint, real64 const & currentTime ) const override; + + /** + * @brief Getter for the reference elevation where the BHP control is enforced + * @return the reference elevation + */ + real64 getReferenceElevation() const { return m_refElevation; } + + /** + * @brief Set the reference elevation where the BHP control is enforced + * @return the reference elevation + */ + void setReferenceElevation( real64 const & refElevation ) { m_refElevation=refElevation; } + + /** + * @brief Getter for the reference gravity coefficient + * @return the reference gravity coefficient + */ + real64 getReferenceGravityCoef() const { return m_refGravCoef; } + + /** + * @brief Setter for the reference gravity + */ + void setReferenceGravityCoef( real64 const & refGravCoef ) { m_refGravCoef = refGravCoef; } + + + /** + * @brief name of the node manager in the object catalog + * @return string that contains the catalog name to generate a new Constraint object through the object catalog. + */ + static string catalogName() + { + if constexpr (T == BHPConstraintTypeId::MAX) + { + return "MaximumBHPConstraint"; + } + else + { + return "MinimumBHPConstraint"; + } + + } + + + virtual string getCatalogName() const override { return catalogName(); } +protected: + + virtual void postInputInitialization() override; + + /// Reference elevation + real64 m_refElevation; + + /// Gravity coefficient of the reference elevation + real64 m_refGravCoef; + +}; + +using MinimumBHPConstraint = BHPConstraint< BHPConstraintTypeId::MIN >; +using MaximumBHPConstraint = BHPConstraint< BHPConstraintTypeId::MAX >; + +} //namespace geos + +#endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLBHPCONSTRAINTS_HPP diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellConstants.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellConstants.hpp index 58b8b421c3a..83eadb7c2ff 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellConstants.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellConstants.hpp @@ -36,6 +36,11 @@ struct WellConstants static constexpr real64 defaultInjectorBHP = 1.01325e8; }; +enum class WellTypes : integer +{ + PRODUCER, /**< A production well */ + INJECTOR /**< An injection well */ +}; } //namespace geos #endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONSTANTS_HPP diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellConstraintsBase.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellConstraintsBase.cpp new file mode 100644 index 00000000000..d4a54860f68 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellConstraintsBase.cpp @@ -0,0 +1,116 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellConstraintBase.cpp + */ + +#include "LogLevelsInfo.hpp" +#include "WellConstraintsBase.hpp" +#include "WellConstants.hpp" +#include "dataRepository/InputFlags.hpp" +#include "functions/FunctionManager.hpp" + + +namespace geos +{ + +using namespace dataRepository; + +// Provide a properly-typed static catalog for WellConstraintBase so that +// CatalogInterface< WellConstraintBase, ... >::getCatalog() can return +// a catalog of CatalogInterface objects instead of +// inheriting Group::getCatalog() which returns a catalog of Group entries. +WellConstraintBase::CatalogInterface::CatalogType & WellConstraintBase::getCatalog() +{ + static WellConstraintBase::CatalogInterface::CatalogType catalog; + return catalog; +} + + +WellConstraintBase::WellConstraintBase( string const & name, Group * const parent ) + : Group( name, parent ), + m_constraintSource( ConstraintSourceId::USER ), + m_isConstraintActive( 1 ), + m_useScheduleTable( false ), + m_constraintValue( 0 ), + m_constraintScheduleTable( nullptr ), + m_rateSign( 1.0 ) // Default to positive rate sign for injection, set to -1.0 for production wells + +{ + setInputFlags( InputFlags::OPTIONAL_NONUNIQUE ); + + registerWrapper( viewKeyStruct::constraintScheduleTableNameString(), &m_constraintScheduleTableName ). + setRTTypeName( rtTypes::CustomTypes::groupNameRef ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Name of the well constraint schedule table when the constraint value is a time dependent function. \n" ); + + registerWrapper( viewKeyStruct::constraintActiveString(), &m_isConstraintActive ). + setDefaultValue( 1 ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Flag to enable constraint. Currently only supported for injectors: \n" + " - If the flag is set to 1, constraint included in boundary condition selection. \n" + " - If the flag is set to 0, constraint excluded from boundary condition selection." ); + +} + + +WellConstraintBase::~WellConstraintBase() +{} + + +void WellConstraintBase::postInputInitialization() +{ + + GEOS_THROW_IF( ((m_constraintValue > 0.0 && !m_constraintScheduleTableName.empty())|| (!(m_constraintValue > 0.0) && m_constraintScheduleTableName.empty())), + this->getDataContext() << ": You have provided redundant information for well constraint value ." << + " A constraint value and table of constraint values cannot be specified together", + InputError ); + + // Create time-dependent constraint table + if( !m_constraintScheduleTableName.empty() ) + { + FunctionManager & functionManager = FunctionManager::getInstance(); + m_constraintScheduleTable = &(functionManager.getGroup< TableFunction const >( m_constraintScheduleTableName )); + + GEOS_THROW_IF( m_constraintScheduleTable->getInterpolationMethod() != TableFunction::InterpolationType::Lower, + this->getName() << " " << this->getDataContext() << ": The interpolation method for the schedule table " + << m_constraintScheduleTable->getName() << " should be TableFunction::InterpolationType::Lower", + InputError ); + } + +} + +void WellConstraintBase::setNextDtFromTables( real64 const currentTime, real64 & nextDt ) const +{ + setNextDtFromTable( m_constraintScheduleTable, currentTime, nextDt ); +} + +void WellConstraintBase::setNextDtFromTable( TableFunction const * table, real64 const currentTime, real64 & nextDt ) +{ + if( table ) + { + // small epsilon to make sure we land on the other side of table interval and pick up the right rate + real64 const eps = 1e-6; + real64 const dtLimit = (table->getCoord( ¤tTime, 0, TableFunction::InterpolationType::Upper ) - currentTime) * ( 1.0 + eps ); + if( dtLimit > eps && dtLimit < nextDt ) + { + nextDt = dtLimit; + } + } +} + + +} //namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellConstraintsBase.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellConstraintsBase.hpp new file mode 100644 index 00000000000..445ed62a61d --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellConstraintsBase.hpp @@ -0,0 +1,292 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellConstraintBase.hpp + */ + + +#ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONSTRAINTBASE_HPP +#define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONSTRAINTBASE_HPP + +#include "common/format/EnumStrings.hpp" + +#include "functions/TableFunction.hpp" +#include "dataRepository/Group.hpp" +namespace geos +{ + +enum class ConstraintSourceId : integer +{ + USER, /**< The well operates at a specified minimum bottom hole pressure (BHP) */ + WHP, /**< The well operates at a specified maximum bottom hole pressure (BHP) */ + UNINITIALIZED, /**< This is the current well control before postInputInitialization (needed to restart from file properly) */ +}; + + +enum class ConstraintTypeId : integer +{ + BHP, /**< The well operates at a specified bottom hole pressure (BHP) */ + PHASEVOLRATE, /**< The well operates at a specified phase volumetric flow rate */ + TOTALVOLRATE, /**< The well operates at a specified total volumetric flow rate */ + MASSRATE, /**; + + /// Get the singleton catalog for WellConstraintBase + static CatalogInterface::CatalogType & getCatalog(); + + /** + * @brief function to return the catalog name of the derived class + * @return a string that contains the catalog name of the derived class + */ + virtual string getCatalogName() const = 0; + + /** + * @name Getters / Setters + */ + ///@{ + + /** + * @brief Constructor for WellControls Objects. + * @param[in] name the name of this instantiation of WellControls in the repository + * @param[in] parent the parent group of this instantiation of WellControls + */ + explicit WellConstraintBase( string const & name, dataRepository::Group * const parent ); + + + /** + * @brief Default destructor. + */ + ~WellConstraintBase() override; + + /** + * @brief Deleted default constructor. + */ + WellConstraintBase() = delete; + + /** + * @brief Deleted copy constructor. + */ + WellConstraintBase( WellConstraintBase const & ) = delete; + + /** + * @brief Deleted move constructor. + */ + WellConstraintBase( WellConstraintBase && ) = delete; + + /** + * @brief Deleted assignment operator. + * @return a reference to a constraint object + */ + WellConstraintBase & operator=( WellConstraintBase const & ) = delete; + + /** + * @brief Deleted move operator. + * @return a reference to a constraint object + */ + WellConstraintBase & operator=( WellConstraintBase && ) = delete; + + ///@} + + + /** + * @name Getters / Setters + */ + ///@{ + + // Temp interface - tjb + virtual ConstraintTypeId getControl() const = 0; + + /** + * @brief Provide source of constraint (user defined, or computed from WHP constraint) + * @return true if the constraint is active, false otherwise + */ + ConstraintSourceId getConstraintSource( ) const { return m_constraintSource; } + + /** + * @brief Defines whether the constraint should be evaluated or not + * @brief Some workflows require the well model to define a constraint + * @brief of similar type to user defined constraints. For example, + * @brief rate constraints to evaluated WHP constraints. + * @return true if the constraint is active, false otherwise + */ + bool isConstraintActive( ) const { return m_isConstraintActive; } + + /** + * @brief Sets constraint active status + * @param[in] constraintActive true if the constraint is active, false otherwise + */ + void setConstraintActive( bool const & constraintActive ) { m_isConstraintActive=constraintActive; } + + /** + * @brief Sets constraint value + * @param[in] constraint value + */ + void setConstraintValue( real64 const & constraintValue ) + { + m_constraintValue = constraintValue; + } + + /** + * @brief Get the target bottom hole pressure value. + * @return a value for the target bottom hole pressure + */ + real64 getConstraintValue( real64 const & currentTime ) const + { + if( m_constraintScheduleTableName.empty() ) + { + return m_rateSign*m_constraintValue; + } + + return m_rateSign*m_constraintScheduleTable->evaluate( ¤tTime ); + } + + ///@} + + /** + * @brief Struct to serve as a container for variable strings and keys. + * @struct viewKeyStruct + */ + struct viewKeyStruct + { + /// string key for schedule table name + static constexpr char const * constraintScheduleTableNameString() { return "constraintScheduleTableName"; } + + /// String key for the well constraint active flag + static constexpr char const * constraintActiveString() { return "constraintActive"; } + + } + /// ViewKey struct for the WellControls class + viewKeysWellConstraint; + + // Quantities computed from well constraint solve with this boundary condition + // Until we have a more general interface for constraints to return these quantities, + // we will store them in the constraint object itself. + // This is not ideal but it is a temporary solution to avoid having to solve the constraint multiple times in the well solver and in the + // test. + void setBHP( real64 bhp ){ m_BHP=bhp;}; + void setPhaseVolumeRates( array1d< real64 > const & phaseVolumeRates ) { m_phaseVolumeRates = phaseVolumeRates; }; + void setTotalVolumeRate( real64 totalVolumeRate ){ m_totalVolumeRate = totalVolumeRate; }; + void setMassRate( real64 massRate ){ m_massRate = massRate; }; + + /** + * @brief Getter for the bottom hole pressure + * @return bottom hole pressure + */ + real64 bottomHolePressure() const { return m_BHP; } + + /** + * @brief Getter for the phase volume rates + * @return an arrayView1d storing the phase volume rates + */ + arrayView1d< real64 const > phaseVolumeRates() const { return m_phaseVolumeRates; } + + /** + * @brief Getter for the total volume rate + * @return mass rate + */ + real64 totalVolumeRate() const { return m_totalVolumeRate; } + + /** + * @brief Getter for the liquid rate + * @return liquid rate + */ + real64 liquidRate() const { return m_liquidRate; } + + /** + * @brief Getter for the mass rate + * @return mass rate + */ + real64 massRate() const { return m_massRate; } + + // endof This needs to be somewhere else tjb + /** + * @brief Check if this constraint is violated + * @return true if limiting constraint, false otherwise + */ + virtual bool checkViolation( WellConstraintBase const & currentConstraint, real64 const & currentTime ) const = 0; + +protected: + + virtual void postInputInitialization() override; + + /** + * @brief set next time step based on tables intervals + * @param[in] currentTime the current time + * @param[inout] nextDt the time step + */ + void setNextDtFromTables( real64 const currentTime, real64 & nextDt ) const; + + +protected: + + /// Source of the constraint (user defined, or computed from WHP constraint) + ConstraintSourceId m_constraintSource; + + /// Constraint status + integer m_isConstraintActive; + + /// Flag to indicate whether a schedule table should be generated for constraint value; + bool m_useScheduleTable; + + /// Constraint value + real64 m_constraintValue; + + static void setNextDtFromTable( TableFunction const * table, real64 const currentTime, real64 & nextDt ); + + /// Constraint schedule table name + string m_constraintScheduleTableName; + + /// Constraint values versus time + TableFunction const * m_constraintScheduleTable; + + // Quantities computed from well constraint solve with this boundary condition + + // botton hole pressure + real64 m_BHP; + + // phase rates + array1d< real64 > m_phaseVolumeRates; + + // liquid rate + real64 m_liquidRate; + + // total volume rate + real64 m_totalVolumeRate; + + // mass rate + real64 m_massRate; + + /// Rate sign. +1 for injector, -1 for producer + real64 m_rateSign; +}; + + +} //namespace geos + +#endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONSTRAINTBASE_HPP diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellControls.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellControls.cpp index e04bd780afa..8213516d2f8 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellControls.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellControls.cpp @@ -17,12 +17,30 @@ * @file WellControls.cpp */ -#include "LogLevelsInfo.hpp" #include "WellControls.hpp" + +#include "physicsSolvers/fluidFlow/wells/WellInjectionConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellProductionConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellBHPConstraints.hpp" +#include "physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellMassRateConstraint.hpp" + + +#include "physicsSolvers/fluidFlow/FlowSolverBase.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsTask.hpp" +#include "physicsSolvers/fluidFlow/SinglePhaseStatisticsTask.hpp" + +#include "LogLevelsInfo.hpp" #include "WellConstants.hpp" #include "dataRepository/InputFlags.hpp" #include "functions/FunctionManager.hpp" +#include "mesh/DomainPartition.hpp" +#include "mesh/PerforationFields.hpp" +#include "fileIO/Outputs/OutputBase.hpp" +#include "physicsSolvers/fluidFlow/wells/WellFields.hpp" +#include "functions/FunctionManager.hpp" namespace geos { @@ -32,26 +50,31 @@ using namespace dataRepository; WellControls::WellControls( string const & name, Group * const parent ) : Group( name, parent ), m_type( Type::PRODUCER ), - m_refElevation( 0.0 ), - m_refGravCoef( 0.0 ), - m_inputControl( Control::UNINITIALIZED ), - m_currentControl( Control::UNINITIALIZED ), - m_targetBHP( 0.0 ), - m_targetTotalRate( 0.0 ), - m_targetPhaseRate( 0.0 ), - m_targetMassRate( 0.0 ), + m_numPhases( 0 ), + m_numComponents( 0 ), + m_numDofPerWellElement( 0 ), + m_numDofPerResElement( 0 ), + m_isThermal( 0 ), + m_keepVariablesConstantDuringInitStep( false ), + m_ratesOutputDir( joinPath( OutputBase::getOutputDirectory(), parent->getName() + "_rates" ) ), + m_inputControl( ConstraintTypeId::UNINITIALIZED ), + m_currentControl( ConstraintTypeId::UNINITIALIZED ), m_useSurfaceConditions( 0 ), - m_surfacePres( 0.0 ), - m_surfaceTemp( 0.0 ), + m_surfacePres( -1.0 ), + m_surfaceTemp( -1.0 ), m_isCrossflowEnabled( 1 ), - m_initialPressureCoefficient( 0.1 ), - m_rateSign( -1.0 ), - m_targetTotalRateTable( nullptr ), - m_targetPhaseRateTable( nullptr ), - m_targetBHPTable( nullptr ), - m_statusTable( nullptr ), + m_initialPressureCoefficient( 0.5 ), + m_currentConstraint( nullptr ), m_wellStatus( WellControls::Status::OPEN ), - m_regionAveragePressure( -1 ) + m_wellOpen( false ), + m_statusTable( nullptr ), + m_regionAveragePressure( -1 ), + m_estimateSolution( 0 ), + m_enableIsoThermalEstimator( 0 ), + /// Nonlinear solver parameters + m_wellNewtonSolver( groupKeyStruct::wellNewtonSolverString(), this ), + m_estimatorDoFManager( name ), + m_dofManagerInitialized( false ) { setInputFlags( InputFlags::OPTIONAL_NONUNIQUE ); @@ -59,61 +82,24 @@ WellControls::WellControls( string const & name, Group * const parent ) setInputFlag( InputFlags::REQUIRED ). setDescription( "Well type. Valid options:\n* " + EnumStrings< Type >::concat( "\n* " ) ); - registerWrapper( viewKeyStruct::inputControlString(), &m_inputControl ). - setInputFlag( InputFlags::REQUIRED ). - setDescription( "Well control. Valid options:\n* " + EnumStrings< Control >::concat( "\n* " ) ); + this->registerWrapper( viewKeyStruct::writeCSVFlagString(), &m_writeCSV ). + setApplyDefaultValue( 1 ). + setInputFlag( dataRepository::InputFlags::OPTIONAL ). + setDescription( "When set to 1, write the rates into a CSV file." ); + + this->registerWrapper( viewKeyStruct::timeStepFromTablesFlagString(), &m_timeStepFromTables ). + setApplyDefaultValue( 0 ). + setInputFlag( dataRepository::InputFlags::OPTIONAL ). + setDescription( "Choose time step to honor rates/bhp tables time intervals" ); registerWrapper( viewKeyStruct::currentControlString(), &m_currentControl ). - setDefaultValue( Control::UNINITIALIZED ). + setDefaultValue( ConstraintTypeId::UNINITIALIZED ). setInputFlag( InputFlags::FALSE ). setDescription( "Current well control" ); - registerWrapper( viewKeyStruct::targetBHPString(), &m_targetBHP ). - setDefaultValue( 0.0 ). - setInputFlag( InputFlags::OPTIONAL ). - setRestartFlags( RestartFlags::WRITE_AND_READ ). - setDescription( "The target bottom-hole pressure [Pa] for the well." ); - - registerWrapper( viewKeyStruct::targetTotalRateString(), &m_targetTotalRate ). - setDefaultValue( 0.0 ). - setInputFlag( InputFlags::OPTIONAL ). - setRestartFlags( RestartFlags::WRITE_AND_READ ). - setDescription( "Target total volumetric rate (if useSurfaceConditions: [surface m^3/s]; else [reservoir m^3/s])" ); - - registerWrapper( viewKeyStruct::targetPhaseRateString(), &m_targetPhaseRate ). - setDefaultValue( 0.0 ). - setInputFlag( InputFlags::OPTIONAL ). - setRestartFlags( RestartFlags::WRITE_AND_READ ). - setDescription( "Target phase volumetric rate (if useSurfaceConditions: [surface m^3/s]; else [reservoir m^3/s])" ); - - registerWrapper( viewKeyStruct::targetMassRateString(), &m_targetMassRate ). - setDefaultValue( 0.0 ). - setInputFlag( InputFlags::OPTIONAL ). - setRestartFlags( RestartFlags::WRITE_AND_READ ). - setDescription( "Target Mass Rate rate ( [kg^3/s])" ); - - registerWrapper( viewKeyStruct::targetPhaseNameString(), &m_targetPhaseName ). - setRTTypeName( rtTypes::CustomTypes::groupNameRef ). - setDefaultValue( "" ). - setInputFlag( InputFlags::OPTIONAL ). - setRestartFlags( RestartFlags::WRITE_AND_READ ). - setDescription( "Name of the target phase" ); - - registerWrapper( viewKeyStruct::refElevString(), &m_refElevation ). - setDefaultValue( -1 ). + registerWrapper( viewKeyStruct::inputControlString(), &m_inputControl ). setInputFlag( InputFlags::REQUIRED ). - setDescription( "Reference elevation where BHP control is enforced [m]" ); - - registerWrapper( viewKeyStruct::injectionStreamString(), &m_injectionStream ). - setDefaultValue( -1 ). - setSizedFromParent( 0 ). - setInputFlag( InputFlags::OPTIONAL ). - setDescription( "Defines the global component fractions of the injected fluid." ); - - registerWrapper( viewKeyStruct::injectionTemperatureString(), &m_injectionTemperature ). - setDefaultValue( -1 ). - setInputFlag( InputFlags::OPTIONAL ). - setDescription( "Temperature of the injection stream [K]" ); + setDescription( "Well control. Valid options:\n* " + EnumStrings< ConstraintTypeId >::concat( "\n* " ) ); registerWrapper( viewKeyStruct::useSurfaceConditionsString(), &m_useSurfaceConditions ). setDefaultValue( 0 ). @@ -155,25 +141,15 @@ WellControls::WellControls( string const & name, Group * const parent ) " - Injector pressure at reference depth initialized as: (1+initialPressureCoefficient)*reservoirPressureAtClosestPerforation + density*g*( zRef - zPerf ) \n" " - Producer pressure at reference depth initialized as: (1-initialPressureCoefficient)*reservoirPressureAtClosestPerforation + density*g*( zRef - zPerf ) " ); - registerWrapper( viewKeyStruct::targetBHPTableNameString(), &m_targetBHPTableName ). - setRTTypeName( rtTypes::CustomTypes::groupNameRef ). + this->registerWrapper( viewKeyStruct::estimateWellSolutionString(), &m_estimateSolution ). + setApplyDefaultValue( 0 ). setInputFlag( InputFlags::OPTIONAL ). - setDescription( "Name of the BHP table when the rate is a time dependent function" ); + setDescription( "Flag to esitmate well solution prior to coupled reservoir and well solve." ); - registerWrapper( viewKeyStruct::targetTotalRateTableNameString(), &m_targetTotalRateTableName ). - setRTTypeName( rtTypes::CustomTypes::groupNameRef ). - setInputFlag( InputFlags::OPTIONAL ). - setDescription( "Name of the total rate table when the rate is a time dependent function" ); - - registerWrapper( viewKeyStruct::targetPhaseRateTableNameString(), &m_targetPhaseRateTableName ). - setRTTypeName( rtTypes::CustomTypes::groupNameRef ). - setInputFlag( InputFlags::OPTIONAL ). - setDescription( "Name of the phase rate table when the rate is a time dependent function" ); - - registerWrapper( viewKeyStruct::targetMassRateTableNameString(), &m_targetMassRateTableName ). - setRTTypeName( rtTypes::CustomTypes::groupNameRef ). + this->registerWrapper( viewKeyStruct::enableIsoThermalEstimatorString(), &m_enableIsoThermalEstimator ). + setApplyDefaultValue( 0 ). setInputFlag( InputFlags::OPTIONAL ). - setDescription( "Name of the mass rate table when the rate is a time dependent function" ); + setDescription( "Flag to enable isothermal estimator prior to coupled reservoir and well solve." ); registerWrapper( viewKeyStruct::statusTableNameString(), &m_statusTableName ). setRTTypeName( rtTypes::CustomTypes::groupNameRef ). @@ -181,6 +157,8 @@ WellControls::WellControls( string const & name, Group * const parent ) setDescription( "Name of the well status table when the status of the well is a time dependent function. \n" "If the status function evaluates to a positive value at the current time, the well will be open otherwise the well will be shut." ); + registerGroup( groupKeyStruct::wellNewtonSolverString(), &m_wellNewtonSolver ); + addLogLevel< logInfo::WellControl >(); } @@ -188,28 +166,26 @@ WellControls::WellControls( string const & name, Group * const parent ) WellControls::~WellControls() {} -void WellControls::switchToBHPControl( real64 const & val ) -{ - m_currentControl = Control::BHP; - m_targetBHP = val; -} - -void WellControls::switchToTotalRateControl( real64 const & val ) +Group * WellControls::createChild( string const & childKey, string const & childName ) { - m_currentControl = Control::TOTALVOLRATE; - m_targetTotalRate = val; -} + GEOS_LOG_RANK_0( GEOS_FMT( "{}: adding {} {}", getName(), childKey, childName ) ); + if( childKey == groupKeyStruct::wellNewtonSolverString() ) + { + return &m_wellNewtonSolver; + } -void WellControls::switchToPhaseRateControl( real64 const & val ) -{ - m_currentControl = Control::PHASEVOLRATE; - m_targetPhaseRate = val; + std::unique_ptr< WellConstraintBase > constraint = + WellConstraintBase::CatalogInterface::factory( childKey, getDataContext(), childName, this ); + return ®isterGroup< WellConstraintBase >( childName, std::move( constraint ) ); } -void WellControls::switchToMassRateControl( real64 const & val ) +void WellControls::expandObjectCatalogs() { - m_currentControl = Control::MASSRATE; - m_targetMassRate = val; + // During schema generation, register one of each type derived from WellConstraintBase here + for( auto & catalogIter : WellConstraintBase::getCatalog()) + { + createChild( catalogIter.first, catalogIter.first ); + } } namespace @@ -235,305 +211,983 @@ TableFunction * createWellTable( string const & tableName, } +void WellControls::registerWellDataOnMesh( WellElementSubRegion & subRegion ) +{ + std::string const & regionName = subRegion.getName(); + std::string addrWithMask( regionName ); + std::size_t pos = addrWithMask.find( "UniqueSubRegion" ); + std::string addr = addrWithMask.substr( 0, pos ); + m_targetRegionNames.push_back( addr ); + + registerWrapper< real64 >( viewKeyStruct::currentBHPString() ); + registerWrapper< real64 >( viewKeyStruct::currentVolRateString() ); + + registerWrapper< array1d< real64 > >( viewKeyStruct::currentPhaseVolRateString() ). + setSizedFromParent( 0 ). + reference().resizeDimension< 0 >( m_numPhases ); + registerWrapper< real64 >( viewKeyStruct::massDensityString() ); + + registerWrapper< real64 >( viewKeyStruct::currentTotalVolRateString() ); + registerWrapper< real64 >( viewKeyStruct::currentMassRateString() ); + + // If estimator is used including thermal effects set during constraint evaluation + // otherwise they are always included + if( isThermal() ) + { + if( m_estimateSolution == 0 ) + { + enableThermalEffects( true ); + } + } +} + void WellControls::postInputInitialization() { + Group::postInputInitialization(); // 0) Assign the value of the current well control // When the simulation starts from a restart file, we don't want to use the inputControl, // because the control may have switched in the simulation that generated the restart - GEOS_THROW_IF( m_inputControl == Control::UNINITIALIZED, + GEOS_THROW_IF( m_inputControl == ConstraintTypeId::UNINITIALIZED, "Input well control cannot be uninitialized", InputError, getWrapperDataContext( viewKeyStruct::inputControlString() ) ); - if( m_currentControl == Control::UNINITIALIZED ) + if( m_currentControl == ConstraintTypeId::UNINITIALIZED ) { m_currentControl = m_inputControl; } - // 1.a) check target BHP - GEOS_THROW_IF( m_targetBHP < 0, - "Target bottom-hole pressure is negative", - InputError, getWrapperDataContext( viewKeyStruct::targetBHPString() ) ); - // 1.b) check target rates - GEOS_THROW_IF( m_targetTotalRate < 0, - "Target rate is negative", - InputError, getWrapperDataContext( viewKeyStruct::targetTotalRateString() ) ); + // 3) check the flag for surface / reservoir conditions + GEOS_THROW_IF( m_useSurfaceConditions != 0 && m_useSurfaceConditions != 1, + "The flag to select surface/reservoir conditions must be equal to 0 or 1", + InputError, getWrapperDataContext( viewKeyStruct::useSurfaceConditionsString() ) ); + - GEOS_THROW_IF( m_targetPhaseRate < 0, - "Target oil rate is negative", - InputError, getWrapperDataContext( viewKeyStruct::targetPhaseRateString() ) ); - GEOS_THROW_IF( m_targetMassRate < 0, - "Target mass rate is negative", - InputError, getWrapperDataContext( viewKeyStruct::targetMassRateString() ) ); + // 6.2) Check incoherent information - GEOS_THROW_IF( (m_injectionStream.empty() && m_injectionTemperature >= 0) || - (!m_injectionStream.empty() && m_injectionTemperature < 0), - GEOS_FMT( "Both {} and {} must be specified for multiphase simulations", - viewKeyStruct::injectionStreamString(), - viewKeyStruct::injectionTemperatureString() ), + // An injector must be controlled by TotalVolRate + GEOS_THROW_IF( (isInjector() && (m_inputControl == ConstraintTypeId::PHASEVOLRATE)), + GEOS_FMT( "You have to control an injector with {}", + EnumStrings< ConstraintTypeId >::toString( ConstraintTypeId::TOTALVOLRATE ) ), InputError, getDataContext() ); - // 1.c) Set the multiplier for the rates - if( isProducer() ) + // An injector must be controlled by TotalVolRate + GEOS_THROW_IF( (isProducer() && (m_inputControl == ConstraintTypeId::MASSRATE)), + GEOS_FMT( "You have to control an injector with {}", + EnumStrings< ConstraintTypeId >::toString( ConstraintTypeId::MASSRATE ) ), + InputError, getDataContext() ); + + // 8) Make sure that the initial pressure coefficient is positive + GEOS_THROW_IF( m_initialPressureCoefficient < 0, + GEOS_FMT( "{}This tuning coefficient is negative", + viewKeyStruct::initialPressureCoefficientString() ), + InputError, getWrapperDataContext( viewKeyStruct::initialPressureCoefficientString() ) ); + + + + // 12) Create the time-dependent well status table + if( m_statusTableName.empty()) { - m_rateSign = -1.0; + // All well controls without a specified status function will use the same "Open" status function. + m_statusTableName = GEOS_FMT( "{0}_OpenStatus_table", dataRepository::keys::wellControls ); + FunctionManager & functionManager = FunctionManager::getInstance(); + m_statusTable = functionManager.getGroupPointer< TableFunction const >( m_statusTableName ); + if( m_statusTable==nullptr ) + { + m_statusTable = createWellTable( m_statusTableName, 1.0 ); + } } else { - m_rateSign = 1.0; + FunctionManager & functionManager = FunctionManager::getInstance(); + m_statusTable = &(functionManager.getGroup< TableFunction const >( m_statusTableName )); + + GEOS_THROW_IF( m_statusTable->getInterpolationMethod() != TableFunction::InterpolationType::Lower, + GEOS_FMT( "The interpolation method for the time-dependent status table {} " + "should be TableFunction::InterpolationType::Lower", + m_statusTable->getName() ), + InputError, getDataContext() ); } - // 2) check injection stream - if( !m_injectionStream.empty()) + // 13) Validate constraints + bool const isProducerWell = isProducer(); + + forSubGroups< InjectionConstraint< MassRateConstraint >, + ProductionConstraint< MassRateConstraint > >( [&]( auto const & constraint ) { - real64 sum = 0.0; - for( localIndex ic = 0; ic < m_injectionStream.size(); ++ic ) + GEOS_THROW_IF( useMass(), + GEOS_FMT( "Constraint {} of type {} only allowed for {} if useMass is set to 1", + constraint.getName(), getName() ), + InputError, constraint.getDataContext() ); + } ); + + stdVector< std::tuple< string, string, WellConstraintBase const * > > constraints; + forSubGroups< MaximumBHPConstraint, + InjectionConstraint< MassRateConstraint >, + InjectionConstraint< VolumeRateConstraint >, + InjectionConstraint< PhaseVolumeRateConstraint >, + MinimumBHPConstraint, + ProductionConstraint< MassRateConstraint >, + ProductionConstraint< VolumeRateConstraint >, + ProductionConstraint< PhaseVolumeRateConstraint > >( [&]( auto const & constraint ) + { + using ConstraintType = std::decay_t< decltype(constraint) >; + constraints.emplace_back( constraint.getName(), ConstraintType::catalogName(), &constraint ); + } ); + + // 13.1) Make sure a producer does not have injector constraints and vice versa + const std::set< string > types = [isProducerWell]() -> std::set< string > + { + if( isProducerWell ) { - GEOS_ERROR_IF( m_injectionStream[ic] < 0.0 || m_injectionStream[ic] > 1.0, - "Invalid injection stream", - getWrapperDataContext( viewKeyStruct::injectionStreamString() ) ); - sum += m_injectionStream[ic]; + return { MaximumBHPConstraint::catalogName(), + InjectionConstraint< MassRateConstraint >::catalogName(), + InjectionConstraint< VolumeRateConstraint >::catalogName(), + InjectionConstraint< PhaseVolumeRateConstraint >::catalogName()}; } - GEOS_THROW_IF( LvArray::math::abs( 1.0 - sum ) > std::numeric_limits< real64 >::epsilon(), - "Invalid injection stream", - InputError, getWrapperDataContext( viewKeyStruct::injectionStreamString() ) ); + else + { + return { MinimumBHPConstraint::catalogName(), + ProductionConstraint< MassRateConstraint >::catalogName(), + ProductionConstraint< VolumeRateConstraint >::catalogName(), + ProductionConstraint< PhaseVolumeRateConstraint >::catalogName() }; + } + }(); + for( const auto & [name, type, constraint] : constraints ) + { + GEOS_THROW_IF( types.find( type ) != types.end(), + GEOS_FMT( "Constraint {} of type {} is not allowed for {} wells", + name, type, (isProducerWell ? "producer" : "injector")), + InputError, constraint->getDataContext() ); } - // 3) check the flag for surface / reservoir conditions - GEOS_THROW_IF( m_useSurfaceConditions != 0 && m_useSurfaceConditions != 1, - "The flag to select surface/reservoir conditions must be equal to 0 or 1", - InputError, getWrapperDataContext( viewKeyStruct::useSurfaceConditionsString() ) ); - - // 4) check that at least one rate constraint has been defined - GEOS_THROW_IF( ((m_targetPhaseRate <= 0.0 && m_targetPhaseRateTableName.empty()) && - (m_targetMassRate <= 0.0 && m_targetMassRateTableName.empty()) && - (m_targetTotalRate <= 0.0 && m_targetTotalRateTableName.empty())), - GEOS_FMT( "You need to specify a phase, mass, or total rate constraint. \n" - "The phase rate constraint can be specified using either {} or {}.\n" - "The total rate constraint can be specified using .\n" - "either {} or {}.\n" - "The mass rate constraint can be specified using either {} or {}", - viewKeyStruct::targetPhaseRateString(), - viewKeyStruct::targetPhaseRateTableNameString(), - viewKeyStruct::targetTotalRateString(), - viewKeyStruct::targetTotalRateTableNameString(), - viewKeyStruct::targetMassRateString(), - viewKeyStruct::targetMassRateTableNameString() ), - InputError, getDataContext() ); - - // 5) check whether redundant information has been provided - GEOS_THROW_IF( ((m_targetPhaseRate > 0.0 && !m_targetPhaseRateTableName.empty())), - GEOS_FMT( "You have provided redundant information for well phase rate." - " The keywords {} and {} cannot be specified together", - viewKeyStruct::targetPhaseRateString(), - viewKeyStruct::targetPhaseRateTableNameString() ), - InputError, getDataContext() ); + // 13.2) Make sure we don't have multiple constraints of the same type + // Track the types we have already seen + mapBase< string, WellConstraintBase const *, std::false_type > seen_types; + for( const auto & [name, type, constraint] : constraints ) + { + auto [it, inserted] = seen_types.insert( {type, constraint} ); + GEOS_THROW_IF( !inserted, + GEOS_FMT( "Constraint of type {} is duplicated by {} and {}", + type, name, it->second->getName() ), + InputError, constraint->getDataContext() ); + } - GEOS_THROW_IF( ((m_targetTotalRate > 0.0 && !m_targetTotalRateTableName.empty())), - GEOS_FMT( "You have provided redundant information for well total rate." - " The keywords {} and {} cannot be specified together", - viewKeyStruct::targetTotalRateString(), - viewKeyStruct::targetTotalRateTableNameString() ), + // 13.3) Make sure there is a BHP constraint + string const bhp_type = isProducerWell ? MinimumBHPConstraint::catalogName() : MaximumBHPConstraint::catalogName(); + bool const no_match_found = std::none_of( constraints.begin(), constraints.end(), [&bhp_type]( const auto & constraint_tuple ) + { + return std::get< 1 >( constraint_tuple ) == bhp_type; + } ); + GEOS_THROW_IF( no_match_found, + GEOS_FMT( "Constraint of type {} is missing and is required for a {} well", + bhp_type, (isProducerWell ? "producer" : "injector") ), InputError, getDataContext() ); - GEOS_THROW_IF( ((m_targetBHP > 0.0 && !m_targetBHPTableName.empty())), - GEOS_FMT( "You have provided redundant information for well BHP." - " The keywords {} and {} cannot be specified together", - viewKeyStruct::targetBHPString(), - viewKeyStruct::targetBHPTableNameString() ), + // 13.4) Make sure there is at least one non-BHP constraint + bool const rate_match_found = std::any_of( constraints.begin(), constraints.end(), [&bhp_type]( const auto & constraint_tuple ) + { + return std::get< 1 >( constraint_tuple ) != bhp_type; + } ); + GEOS_THROW_IF( !rate_match_found, + GEOS_FMT( "Missing rate constraint for {} well {}", + (isProducerWell ? "producer" : "injector"), getName() ), InputError, getDataContext() ); +} - GEOS_THROW_IF( ((m_targetMassRate > 0.0 && !m_targetMassRateTableName.empty())), - GEOS_FMT( "You have provided redundant information for well mass rate." - " The keywords {} and {} cannot be specified together", - viewKeyStruct::targetMassRateString(), - viewKeyStruct::targetMassRateTableNameString() ), - InputError, getDataContext() ); +void WellControls::initializePreSubGroups() +{ + // Validate the reference region + validateReferenceRegion(); +} - GEOS_THROW_IF( ((m_targetMassRate > 0.0 && m_useSurfaceConditions==0)), - "Option only valid if useSurfaceConditions set to 1", - InputError, getDataContext() ); +void WellControls::postRestartInitialization( ) +{} - // 6.1) If the well is under BHP control then the BHP must be specified. - // Otherwise the BHP will be set to a default value. - if( m_currentControl == Control::BHP ) +void WellControls::logConstraint( WellConstraintBase const * constraint, WellElementSubRegion const & region, real64 time, bool isLimiting ) const +{ + bool const needsLog = (constraint != nullptr) && (getLogLevel() > 4) && region.isLocallyOwned(); + if( isLimiting ) { - GEOS_THROW_IF( ((m_targetBHP <= 0.0 && m_targetBHPTableName.empty())), - GEOS_FMT( "You have to provide well BHP by specifying either {} or {}", - viewKeyStruct::targetBHPString(), - viewKeyStruct::targetBHPTableNameString() ), - InputError, getDataContext() ); + GEOS_LOG_RANK_IF ( needsLog, + GEOS_FMT( " Well {}: Limiting Constraint {} - BHP {}, Volume rates {}, Total rate {}, Mass rate {}", + region.getName(), constraint->getName(), constraint->bottomHolePressure(), + constraint->phaseVolumeRates(), constraint->totalVolumeRate(), constraint->massRate()) ); } - else if( m_targetBHP <= 0.0 && m_targetBHPTableName.empty() ) + else { - m_targetBHP = isProducer() ? WellConstants::defaultProducerBHP : WellConstants::defaultInjectorBHP; - GEOS_LOG_LEVEL_RANK_0( logInfo::WellControl, - GEOS_FMT( "WellControls {}: Setting {} to default value {}", getDataContext(), viewKeyStruct::targetBHPString(), m_targetBHP )); + GEOS_LOG_RANK_IF ( needsLog, + GEOS_FMT( " Well {}: Constraint {} - active {}, value {}", + region.getName(), constraint->getName(), constraint->isConstraintActive(), + constraint->getConstraintValue( time ) ) ); } +} - // 6.2) Check incoherent information +void WellControls::setWellStatus( real64 const & currentTime, WellControls::Status status ) +{ + m_wellStatus = status; + if( m_wellStatus == WellControls::Status::OPEN ) + { + bool hasZeroRate = false; - // An injector must be controlled by TotalVolRate - GEOS_THROW_IF( (isInjector() && (m_inputControl == Control::PHASEVOLRATE)), - GEOS_FMT( "You have to control an injector with {}", - EnumStrings< Control >::toString( Control::TOTALVOLRATE ) ), - InputError, getDataContext() ); + if( m_statusTable->evaluate( ¤tTime ) < LvArray::NumericLimits< real64 >::epsilon ) + { + hasZeroRate = true; + } - // An injector must be controlled by TotalVolRate - GEOS_THROW_IF( (isProducer() && (m_inputControl == Control::MASSRATE)), - GEOS_FMT( "You have to control an injector with {}", - EnumStrings< Control >::toString( Control::MASSRATE ) ), - InputError, getDataContext() ); + if( !hasZeroRate ) + { + for( auto const * constraint : getRateConstraints() ) + { + if( isZero( constraint->getConstraintValue( currentTime ) ) ) + { + hasZeroRate = true; + } + } + } - // 8) Make sure that the initial pressure coefficient is positive - GEOS_THROW_IF( m_initialPressureCoefficient < 0, - GEOS_FMT( "{}This tuning coefficient is negative", - viewKeyStruct::initialPressureCoefficientString() ), - InputError, getWrapperDataContext( viewKeyStruct::initialPressureCoefficientString() ) ); + if( hasZeroRate ) + { + m_wellStatus = WellControls::Status::CLOSED; + m_currentConstraint = nullptr; + } + } +} +real64 WellControls::setNextDt( real64 const & currentTime, + real64 const & currentDt, + WellElementSubRegion & subRegion ) +{ + real64 nextDt = currentDt; + real64 nextDt_perf=nextDt; - // 9) Create time-dependent BHP table - if( m_targetBHPTableName.empty() ) + // Find min dt from perf status tables + PerforationData & perforationData = *subRegion.getPerforationData(); + string_array const & perfStatusTableName = perforationData.getPerfStatusTableName(); + FunctionManager & functionManager = FunctionManager::getInstance(); + // Get dt for local perforations + for( integer i=0; i( perfStatusTableName[i] ); + setNextDtFromTable( tableFunction, currentTime, nextDt_perf ); + } + nextDt = MpiWrapper::min< real64 >( nextDt_perf ); + // Find min dt including rate and status tables + real64 const nextDt_orig = nextDt; + setNextDtFromTables( currentTime, nextDt ); + //if( m_nonlinearSolverParameters.getLogLevel() > 0 && nextDt < nextDt_orig ) + if( getLogLevel() > 0 && nextDt < nextDt_orig ) + GEOS_LOG_RANK_0( GEOS_FMT( "{}: next time step based on tables coordinates = {}", getName(), nextDt )); + return nextDt; +} + +bool WellControls::isWellOpen() const +{ + return getWellStatus() == WellControls::Status::OPEN; +} + +void WellControls::setWellState( bool open ) +{ + m_wellOpen = open; +} + +bool WellControls::getWellState() const +{ + return m_wellOpen; +} + +void WellControls::setNextDtFromTables( real64 const & currentTime, real64 & nextDt ) +{ + if( isProducer() ) + { + if( getBHPConstraint() != nullptr ) + { + getBHPConstraint()->setNextDtFromTables( currentTime, nextDt ); + } + for( auto const & constraint : getRateConstraints() ) + { + constraint->setNextDtFromTables( currentTime, nextDt ); + } } else { - FunctionManager & functionManager = FunctionManager::getInstance(); - m_targetBHPTable = &(functionManager.getGroup< TableFunction const >( m_targetBHPTableName )); + getBHPConstraint()->setNextDtFromTables( currentTime, nextDt ); + for( auto const & constraint : getRateConstraints() ) + { + constraint->setNextDtFromTables( currentTime, nextDt ); + } + } - GEOS_THROW_IF( m_targetBHPTable->getInterpolationMethod() != TableFunction::InterpolationType::Lower, - GEOS_FMT( "The interpolation method for the time-dependent BHP table {} " - "should be TableFunction::InterpolationType::Lower", - m_targetBHPTable->getName() ), - InputError, getDataContext() ); + WellControls::setNextDtFromTable( m_statusTable, currentTime, nextDt ); +} + +void WellControls::setNextDtFromTable( TableFunction const * table, real64 const currentTime, real64 & nextDt ) +{ + if( table ) + { + // small epsilon to make sure we land on the other side of table interval and pick up the right rate + real64 const eps = 1e-6; + real64 const dtLimit = (table->getCoord( ¤tTime, 0, TableFunction::InterpolationType::Upper ) - currentTime) * ( 1.0 + eps ); + if( dtLimit > eps && dtLimit < nextDt ) + { + nextDt = dtLimit; + } } +} - // 10) Create time-dependent total rate table - if( m_targetTotalRateTableName.empty() ) +namespace +{ +template< typename GROUP, + typename CONSTRAINT = std::conditional_t< + std::is_const_v< std::remove_reference_t< GROUP > >, + WellConstraintBase const, + WellConstraintBase > > +void populateConstraints( GROUP & group, bool isProducer, stdVector< CONSTRAINT * > & constraints, ConstraintSourceId source = ConstraintSourceId::USER ) +{ + if( isProducer ) { - m_targetTotalRateTableName = getName()+"_ConstantTotalRate_table"; - m_targetTotalRateTable = createWellTable( m_targetTotalRateTableName, m_targetTotalRate ); + group.template forSubGroups< ProductionConstraint< MassRateConstraint >, + ProductionConstraint< VolumeRateConstraint >, + ProductionConstraint< PhaseVolumeRateConstraint > >( [&]( CONSTRAINT & constraint ) + { + if( constraint.isConstraintActive() && constraint.getConstraintSource() == source ) + { + constraints.push_back( &constraint ); + } + } ); } else { - FunctionManager & functionManager = FunctionManager::getInstance(); - m_targetTotalRateTable = &(functionManager.getGroup< TableFunction const >( m_targetTotalRateTableName )); + group.template forSubGroups< InjectionConstraint< MassRateConstraint >, + InjectionConstraint< VolumeRateConstraint >, + InjectionConstraint< PhaseVolumeRateConstraint > >( [&]( CONSTRAINT & constraint ) + { + if( constraint.isConstraintActive() && constraint.getConstraintSource() == source ) + { + constraints.push_back( &constraint ); + } + } ); + } +} +} stdVector< WellConstraintBase const * > WellControls::getRateConstraints() const +{ + stdVector< WellConstraintBase const * > constraints; + populateConstraints( *this, isProducer(), constraints ); + return constraints; +} - GEOS_THROW_IF( m_targetTotalRateTable->getInterpolationMethod() != TableFunction::InterpolationType::Lower, - GEOS_FMT( "The interpolation method for the time-dependent total rate table {} " - "should be TableFunction::InterpolationType::Lower", - m_targetTotalRateTable->getName() ), - InputError, getDataContext() ); +stdVector< WellConstraintBase * > WellControls::getRateConstraints() +{ + stdVector< WellConstraintBase * > constraints; + populateConstraints( *this, isProducer(), constraints ); + return constraints; +} + +stdVector< WellConstraintBase const * > WellControls::getAllConstraints() const +{ + stdVector< WellConstraintBase const * > constraints = getRateConstraints(); + constraints.insert( constraints.begin(), getBHPConstraint() ); + return constraints; +} +stdVector< WellConstraintBase * > WellControls::getAllConstraints() +{ + stdVector< WellConstraintBase * > constraints = getRateConstraints(); + constraints.insert( constraints.begin(), getBHPConstraint() ); + return constraints; +} + +WellConstraintBase const * WellControls::getBHPConstraint( const ConstraintSourceId source ) const +{ + WellConstraintBase const * bhpConstraint = nullptr; + // Rely on validation here. We assume that there aren't both constraints listed + if( isProducer() ) + { + forSubGroups< MinimumBHPConstraint >( [&]( WellConstraintBase const & constraint ) + { + if( constraint.isConstraintActive() && constraint.getConstraintSource() == source ) + bhpConstraint = &constraint; + } ); + } + else + { + forSubGroups< MaximumBHPConstraint >( [&]( WellConstraintBase const & constraint ) + { + if( constraint.isConstraintActive() && constraint.getConstraintSource() == source ) + bhpConstraint = &constraint; + } ); } + return bhpConstraint; +} - // 11) Create time-dependent phase rate table - if( m_targetPhaseRateTableName.empty() ) +WellConstraintBase * WellControls::getBHPConstraint( const ConstraintSourceId source ) +{ + WellConstraintBase * bhpConstraint = nullptr; + // Rely on validation here. We assume that there aren't both constraints listed + if( isProducer() ) { - m_targetPhaseRateTableName = getName()+"_ConstantPhaseRate_table"; - m_targetPhaseRateTable = createWellTable( m_targetPhaseRateTableName, m_targetPhaseRate ); + forSubGroups< MinimumBHPConstraint >( [&]( WellConstraintBase & constraint ) + { + if( constraint.isConstraintActive() && constraint.getConstraintSource() == source ) + bhpConstraint = &constraint; + } ); } else { - FunctionManager & functionManager = FunctionManager::getInstance(); - m_targetPhaseRateTable = &(functionManager.getGroup< TableFunction const >( m_targetPhaseRateTableName )); + forSubGroups< MaximumBHPConstraint >( [&]( WellConstraintBase & constraint ) + { + if( constraint.isConstraintActive() && constraint.getConstraintSource() == source ) + bhpConstraint = &constraint; + } ); + } + return bhpConstraint; +} +real64 WellControls::getTargetBHP( real64 const & targetTime, const ConstraintSourceId source ) const +{ + return getBHPConstraint( source )->getConstraintValue( targetTime ); +} - GEOS_THROW_IF( m_targetPhaseRateTable->getInterpolationMethod() != TableFunction::InterpolationType::Lower, - GEOS_FMT( "The interpolation method for the time-dependent phase rate table {} " - "should be TableFunction::InterpolationType::Lower", - m_targetPhaseRateTable->getName() ), - InputError, getDataContext() ); +real64 WellControls::getInjectionTemperature() const +{ + real64 injectionTemperature = 0.0; + localIndex firstIndex = -1; // Used to "capture" the first one + forSubGroupsIndex< InjectionConstraint< MassRateConstraint >, + InjectionConstraint< VolumeRateConstraint >, + InjectionConstraint< PhaseVolumeRateConstraint > >( [&] ( localIndex index, auto const & constraint ) + { + if( firstIndex < 0 && constraint.isConstraintActive() ) + { + injectionTemperature = constraint.getInjectionTemperature(); + firstIndex = index; + } + } ); + return injectionTemperature; +} + +arrayView1d< real64 const > WellControls::getInjectionStream() const +{ + arrayView1d< real64 const > injectionStream; + localIndex firstIndex = -1; // Used to "capture" the first one + forSubGroupsIndex< InjectionConstraint< MassRateConstraint >, + InjectionConstraint< VolumeRateConstraint >, + InjectionConstraint< PhaseVolumeRateConstraint > >( [&] ( localIndex index, auto const & constraint ) + { + if( firstIndex < 0 && constraint.isConstraintActive() ) + { + injectionStream = constraint.getInjectionStream(); + firstIndex = index; + } + } ); + return injectionStream; +} + +integer WellControls::getConstraintPhaseIndex() const +{ + integer phaseIndex = -1; + // Validation should make sure we are not mixing constraints. + // Here we assume that we have zero or one or the other but not both + forSubGroups< ProductionConstraint< PhaseVolumeRateConstraint >, + InjectionConstraint< PhaseVolumeRateConstraint > >( [&] ( auto & constraint ) + { + if( constraint.isConstraintActive() ) + { + phaseIndex = constraint.getPhaseIndex(); + } + } ); + return phaseIndex; +} + +real64 WellControls::getReferenceElevation() const +{ + real64 referenceElevation = 0.0; + // Validation should make sure we are not mixing constraints. + // Here we assume that we have zero or one or the other but not both + forSubGroups< MinimumBHPConstraint, + MaximumBHPConstraint >( [&] ( auto & constraint ) + { + referenceElevation = constraint.getReferenceElevation(); + } ); + return referenceElevation; +} + +void WellControls::implicitStepSetup( real64 const & time_n, + real64 const & GEOS_UNUSED_PARAM( dt ), + DomainPartition & GEOS_UNUSED_PARAM( domain ), + string const & GEOS_UNUSED_PARAM( meshBodyName ), + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion ) +{ + + GEOS_UNUSED_VAR( elemManager ); + // Set perforation status + setPerforationStatus( time_n, subRegion ); +} + +void WellControls::setPerforationStatus( real64 const & time_n, WellElementSubRegion & subRegion ) +{ + FunctionManager & functionManager = FunctionManager::getInstance(); + + // Set perforation status + + PerforationData & perforationData = *subRegion.getPerforationData(); + string_array const & perfStatusTableName = perforationData.getPerfStatusTableName(); + arrayView1d< integer > perfStatus = perforationData.getLocalPerfStatus(); + // for now set to open + for( integer i=0; i( perfStatusTableName[i] ); + perfStatus[i]=PerforationData::PerforationStatus::OPEN; + if( tableFunction->evaluate( &time_n ) < LvArray::NumericLimits< real64 >::epsilon ) + { + perfStatus[i]=PerforationData::PerforationStatus::CLOSED; + } } - // Create time-dependent mass rate table - if( m_targetMassRateTableName.empty() ) + + array1d< localIndex > const perfWellElemIndex = perforationData.getField< fields::perforation::wellElementIndex >(); + // global index local elements (size == subregion.size) + arrayView1d< globalIndex const > globalWellElementIndex = subRegion.getGlobalWellElementIndex(); + + arrayView1d< integer const > const elemGhostRank = subRegion.ghostRank(); + array1d< integer > & currentStatus = subRegion.getWellElementStatus(); + // Local elements + array1d< integer > & localElemStatus = subRegion.getWellLocalElementStatus(); + + integer numLocalElements = subRegion.getNumLocalElements(); + array1d< integer > segStatus( numLocalElements ); + + // Local perforations + for( integer j = 0; j < perforationData.size(); j++ ) { - m_targetMassRateTableName = getName()+"_ConstantMassRate_table"; - m_targetMassRateTable = createWellTable( m_targetMassRateTableName, m_targetMassRate ); + localIndex const iwelem = perfWellElemIndex[j]; + if( elemGhostRank[iwelem] < 0 ) + { + if( perfStatus[j] ) + { + segStatus[iwelem] +=1; + } + } } - else + // Broadcast segment status so all cores have same well status + subRegion.setElementStatus( segStatus ); + integer numOpenElements = 0; + array1d< integer > const & updatedStatus = subRegion.getWellElementStatus(); + for( integer i=0; i( m_targetMassRateTableName )); + numOpenElements += updatedStatus[i]; + } + numOpenElements>0 ? setWellStatus( time_n, WellControls::Status::OPEN ) : setWellStatus( time_n, WellControls::Status::CLOSED ); - GEOS_THROW_IF( m_targetMassRateTable->getInterpolationMethod() != TableFunction::InterpolationType::Lower, - GEOS_FMT( "The interpolation method for the time-dependent mass rate table {} " - "should be TableFunction::InterpolationType::Lower", - m_targetMassRateTable->getName() ), - InputError, getDataContext() ); + + // Set local well element status array + for( integer i=0; i const wellElemLocation = subRegion.getElementCenter(); + arrayView1d< real64 > const wellElemGravCoef = subRegion.getField< fields::well::gravityCoefficient >(); + + arrayView2d< real64 const > const perfLocation = perforationData.getField< fields::perforation::location >(); + arrayView1d< real64 > const perfGravCoef = perforationData.getField< fields::well::gravityCoefficient >(); + + forAll< serialPolicy >( perforationData.size(), [=]( localIndex const iperf ) { - // All well controls without a specified status function will use the same "Open" status function. - m_statusTableName = GEOS_FMT( "{0}_OpenStatus_table", dataRepository::keys::wellControls ); - FunctionManager & functionManager = FunctionManager::getInstance(); - m_statusTable = functionManager.getGroupPointer< TableFunction const >( m_statusTableName ); - if( m_statusTable==nullptr ) + // precompute the depth of the perforations + perfGravCoef[iperf] = LvArray::tensorOps::AiBi< 3 >( perfLocation[iperf], gravVector ); + } ); + + forAll< serialPolicy >( subRegion.size(), [=]( localIndex const iwelem ) + { + // precompute the depth of the well elements + wellElemGravCoef[iwelem] = LvArray::tensorOps::AiBi< 3 >( wellElemLocation[iwelem], gravVector ); + } ); + + forSubGroups< MinimumBHPConstraint, MaximumBHPConstraint >( [&]( auto & constraint ) + { + // set the reference well element where the BHP control is applied + real64 const refElev = constraint.getReferenceElevation(); + constraint.setReferenceGravityCoef( refElev * gravVector[2] ); + } ); +} + +void WellControls::selectWellConstraint( real64 const & time_n, + real64 const & dt, + integer const cycleNumber, + integer const coupledIterationNumber, + DomainPartition & domain, + string const & meshBodyName, + MeshLevel & meshLevel, + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion, + DofManager const & dofManager ) + +{ + + // Well state estimated from reservoir conditions + if( isWellOpen() ) + { + if( !getWellState() ) { - m_statusTable = createWellTable( m_statusTableName, 1.0 ); + setWellState( 1 ); + + initializeWell( domain, domain.getMeshBodies(), meshBodyName, meshLevel, subRegion, time_n ); } } else { - FunctionManager & functionManager = FunctionManager::getInstance(); - m_statusTable = &(functionManager.getGroup< TableFunction const >( m_statusTableName )); - - GEOS_THROW_IF( m_statusTable->getInterpolationMethod() != TableFunction::InterpolationType::Lower, - GEOS_FMT( "The interpolation method for the time-dependent status table {} " - "should be TableFunction::InterpolationType::Lower", - m_statusTable->getName() ), - InputError, getDataContext() ); + setWellState( 0 ); } + bool useEstimator = coupledIterationNumber < estimateSolution(); + + if( getWellState()) + { + if( useEstimator ) + { + // Estimate well solution prior to coupled solve + evaluateConstraints( time_n, + dt, + cycleNumber, + coupledIterationNumber, + domain, + meshLevel, + elemManager, + subRegion, + dofManager ); + } + else + { + // Evaluate well constraints based on current solution + evaluateConstraints( time_n, + subRegion ); + } + + // If a well is opened and then timestep is cut resulting in the well being shut, if the well is opened + // the well initialization code requires control type to by synced + integer owner = -1; + // Only subregion owner evaluates well control and control changes need to be broadcast to all ranks + if( subRegion.isLocallyOwned() ) + { + owner = MpiWrapper::commRank( MPI_COMM_GEOS ); + } + owner = MpiWrapper::max( owner ); + ConstraintTypeId wellControl = getControl(); + MpiWrapper::broadcast( wellControl, owner ); + setControl( wellControl ); + } } -void WellControls::setWellStatus( real64 const & currentTime, WellControls::Status status ) +bool WellControls::evaluateConstraints( real64 const & time_n, + WellElementSubRegion & subRegion ) { - m_wellStatus = status; - if( m_wellStatus == WellControls::Status::OPEN ) + + // create list of all constraints to process + stdVector< WellConstraintBase * > constraintList = getAllConstraints(); + + // Get current constraint + WellConstraintBase * limitingConstraint = nullptr; + for( auto & constraint : constraintList ) { + if( constraint->getName() == getCurrentConstraint()->getName()) + { + limitingConstraint = constraint; + logConstraint( limitingConstraint, subRegion, time_n, true ); + } + } + constraintList.erase( std::find( constraintList.begin(), constraintList.end(), limitingConstraint ) ); - if( isZero( getTargetTotalRate( currentTime ) ) && isZero( getTargetPhaseRate( currentTime ) ) - && isZero( getTargetMassRate( currentTime ) ) ) + // Check current against other constraints + for( auto & constraint : constraintList ) + { + + if( limitingConstraint->getName() != constraint->getName()) { - m_wellStatus = WellControls::Status::CLOSED; + if( constraint->checkViolation( *limitingConstraint, time_n ) ) + { + limitingConstraint = constraint; + setCurrentConstraint( constraint ); + GEOS_LOG_RANK_IF ( subRegion.isLocallyOwned(), + " Well " << subRegion.getName() << " Control switch " << constraint->getName() << " " << constraint->getConstraintValue( time_n ) ); + } } - if( m_statusTable->evaluate( ¤tTime ) < LvArray::NumericLimits< real64 >::epsilon ) + } + logConstraint( limitingConstraint, subRegion, time_n, true ); + + return true; +} + +bool WellControls::evaluateConstraints( real64 const & time_n, + real64 const & dt, + integer const cycleNumber, + integer const coupledIterationNumber, + DomainPartition & domain, + MeshLevel & mesh, + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion, + DofManager const & dofManager ) +{ + // create list of all constraints to solve + // note that initializeWells sets the initial constraint + stdVector< WellConstraintBase * > constraintList = getRateConstraints(); + WellConstraintBase * limitingConstraint = getCurrentConstraint(); + if( isProducer() ) + { + if( limitingConstraint->getControl() != ConstraintTypeId::BHP ) { - m_wellStatus = WellControls::Status::CLOSED; + { // remove from list and add BHP constraint + auto it = std::find( constraintList.begin(), constraintList.end(), limitingConstraint ); + if( it != constraintList.end() ) + { + constraintList.erase( it ); + } + forSubGroups< MinimumBHPConstraint >( [&] ( auto & constraint ) + { + if( constraint.isConstraintActive() ) + { + constraintList.emplace_back( &constraint ); + } + } ); + constraintList.insert( constraintList.begin(), limitingConstraint ); + } } } + else + { + if( limitingConstraint->getControl() != ConstraintTypeId::BHP ) + { + constraintList.emplace_back( getBHPConstraint() ); + } + } + if( isoThermalEstimatorEnabled() ) + { + enableThermalEffects( false ); + solveConstraint ( limitingConstraint, time_n, + dt, + cycleNumber, + coupledIterationNumber, + domain, + mesh, + elemManager, + subRegion, + dofManager ); + enableThermalEffects( true ); + } + solveConstraint ( limitingConstraint, time_n, + dt, + cycleNumber, + coupledIterationNumber, + domain, + mesh, + elemManager, + subRegion, + dofManager ); + + for( auto const & constraint : constraintList ) + { + GEOS_LOG_RANK_IF ( getLogLevel() > 4 && subRegion.isLocallyOwned(), + " Well " << subRegion.getName() << " Constraint " << constraint->getName() << " active " << constraint->isConstraintActive() << + " value " << constraint->getConstraintValue( time_n ) ); + if( constraint->isConstraintActive() && constraint->checkViolation( *limitingConstraint, time_n )) + { + limitingConstraint=constraint; + setCurrentConstraint( limitingConstraint ); + GEOS_LOG_RANK_IF ( getLogLevel() > 4 && subRegion.isLocallyOwned(), + " Well " << subRegion.getName() << " New Limiting Constraint " << constraint->getName() << " active " << constraint->isConstraintActive() << + " value " << constraint->getConstraintValue( time_n ) ); + solveConstraint ( constraint, time_n, + dt, + cycleNumber, + coupledIterationNumber, + domain, + mesh, + elemManager, + subRegion, + dofManager ); + } + } + solveConstraint ( limitingConstraint, time_n, + dt, + cycleNumber, + coupledIterationNumber, + domain, + mesh, + elemManager, + subRegion, + dofManager ); + + logConstraint( limitingConstraint, subRegion, time_n, true ); + + return true; } -bool WellControls::isWellOpen() const +void WellControls::setupWellDofs( DomainPartition & domain, WellElementRegion & wellElementRegion, + string const & meshBodyName, MeshLevel const & meshLevel ) { - return getWellStatus() == WellControls::Status::OPEN; + if( !m_dofManagerInitialized ) + { + m_dofManagerInitialized=true; + m_wellNewtonSolver.setupSystem( *this, domain, meshBodyName, meshLevel, wellElementRegion ); + } } -void WellControls::setNextDtFromTables( real64 const & currentTime, real64 & nextDt ) +void WellControls::solveConstraint( WellConstraintBase *constraint, + real64 const & time_n, + real64 const & dt, + integer const cycleNumber, + integer const coupledIterationNumber, + DomainPartition & domain, + MeshLevel & mesh, + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion, + DofManager const & dofManager ) { - WellControls::setNextDtFromTable( m_targetBHPTable, currentTime, nextDt ); - WellControls::setNextDtFromTable( m_targetMassRateTable, currentTime, nextDt ); - WellControls::setNextDtFromTable( m_targetPhaseRateTable, currentTime, nextDt ); - WellControls::setNextDtFromTable( m_targetTotalRateTable, currentTime, nextDt ); - WellControls::setNextDtFromTable( m_statusTable, currentTime, nextDt ); + GEOS_UNUSED_VAR( dt ); + GEOS_UNUSED_VAR( cycleNumber ); + GEOS_UNUSED_VAR( domain ); + GEOS_UNUSED_VAR( mesh ); + GEOS_UNUSED_VAR( elemManager ); + GEOS_UNUSED_VAR( dofManager ); + + bool useEstimator = coupledIterationNumber < estimateSolution(); + if( useEstimator ) + { + if( getLogLevel() > 4 ) + { + GEOS_LOG_RANK_0( "Well " <getName() << " value " << constraint->getConstraintValue( time_n ) << " active " << + constraint->isConstraintActive() ); + } + if( constraint->isConstraintActive() ) + { + setCurrentConstraint( constraint ); + // If a well is opened and then timestep is cut resulting in the well being shut, if the well is opened +// the well initialization code requires control type to by synced + integer owner = -1; +// Only subregion owner evaluates well control and control changes need to be broadcast to all ranks + if( subRegion.isLocallyOwned() ) + { + owner = MpiWrapper::commRank( MPI_COMM_GEOS ); + } + owner = MpiWrapper::max( owner ); + ConstraintTypeId wellControl = getControl(); + MpiWrapper::broadcast( wellControl, owner ); + setControl( wellControl ); + + m_wellNewtonSolver.solveNonlinearSystem( *this, time_n, + dt, + cycleNumber, + domain, + mesh, + elemManager, + subRegion ); + + if( getLogLevel() > 4 ) + { + GEOS_LOG_RANK_0( "Well " <getName() << " bhp " << constraint->bottomHolePressure() << " phaseVolRate " << + constraint->phaseVolumeRates() << " totalVolRate " << constraint->totalVolumeRate() << " massRate " << constraint->massRate()); + } + } + + + } + } -void WellControls::setNextDtFromTable( TableFunction const * table, real64 const currentTime, real64 & nextDt ) +void +WellControls::assembleSystem( real64 const & time_n, + real64 const & dt, + integer const cycleNumber, + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) { - if( table ) + GEOS_UNUSED_VAR( cycleNumber ); + assembleWellAccumulationTerms( time_n, dt, subRegion, dofManager, localMatrix.toViewConstSizes(), localRhs ); + + assembleWellConstraintTerms( time_n, dt, subRegion, dofManager, localMatrix.toViewConstSizes(), localRhs ); + + assembleWellPressureRelations( time_n, dt, subRegion, dofManager, localMatrix.toViewConstSizes(), localRhs ); + + computeWellPerforationRates( time_n, dt, elemManager, subRegion ); + + assembleWellFluxTerms( time_n, dt, subRegion, dofManager, localMatrix.toViewConstSizes(), localRhs ); +} + +bool WellControls::validateReferenceRegion() const +{ + // If using surface conditions then there is nothing to validate + if( useSurfaceConditions()) { - // small epsilon to make sure we land on the other side of table interval and pick up the right rate - real64 const eps = 1e-6; - real64 const dtLimit = (table->getCoord( ¤tTime, 0, TableFunction::InterpolationType::Upper ) - currentTime) * ( 1.0 + eps ); - if( dtLimit > eps && dtLimit < nextDt ) + return true; + } + bool const isRoot = MpiWrapper::commRank() == 0; + string const regionName = referenceReservoirRegion(); + if( regionName.empty() ) + { + GEOS_WARNING_IF( isRoot, + GEOS_FMT( "WellControls {} referenceReservoirRegion not set and well constraint " + "fluid property calculations will use top segment pressure and temperature.", + getName()) ); + } + else + { + FlowSolverBase const * flowSolver = getParent().getParent().getGroupPointer< FlowSolverBase >( getFlowSolverName() ); + if( flowSolver == nullptr ) { - nextDt = dtLimit; + return true; } + string_array const & targetRegionsNames = flowSolver->getTargetRegionNames(); + auto const pos = std::find( targetRegionsNames.begin(), targetRegionsNames.end(), regionName ); + GEOS_THROW_IF( pos == targetRegionsNames.end(), + GEOS_FMT( "Region {} is not a target of the reservoir solver {} and cannot " + "be used for referenceReservoirRegion in WellControl {}.", + regionName, flowSolver->getName(), getName() ), + InputError, getDataContext() ); + + return pos != targetRegionsNames.end(); + } + return true; +} + +#if 0 +template< typename STATISTICS > +bool WellControls::validateReferenceRegionStatistics( ElementRegionManager const & elemManager, + real64 & averagePressure, + real64 & averageTemperature ) const +{ + averagePressure = 0.0; + averageTemperature = 0.0; + string const regionName = referenceReservoirRegion(); + if( !regionName.empty()) + { + ElementRegionBase const & region = elemManager.getRegion( regionName ); + GEOS_THROW_IF( !region.hasWrapper( STATISTICS::regionStatisticsName() ), + GEOS_FMT( "WellControl {} referenceReservoirRegion field requires {} to be configured for region {}", + getName(), STATISTICS::catalogName(), regionName ), + RuntimeError, getDataContext() ); + + auto const & stats = region.getReference< typename STATISTICS::RegionStatistics >( STATISTICS::regionStatisticsName() ); + GEOS_THROW_IF( stats.averagePressure <= 0.0, + GEOS_FMT( "No region average quantities computed. WellControl {} referenceReservoirRegion field requires " + "{} to be configured for region {} ", + getName(), STATISTICS::catalogName(), regionName ), + RuntimeError, getDataContext()); + averagePressure = stats.averagePressure; + averageTemperature = stats.averageTemperature; } + return true; } +template bool WellControls::validateReferenceRegionStatistics< singlePhaseStatistics::StatsTask >( ElementRegionManager const &, real64 &, real64 & ) const; +template bool WellControls::validateReferenceRegionStatistics< compositionalMultiphaseStatistics::StatsTask >( ElementRegionManager const &, real64 &, real64 & ) const; +#endif } //namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellControls.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellControls.hpp index a85e2868941..870e0b45fe0 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellControls.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellControls.hpp @@ -17,15 +17,20 @@ * @file WellControls.hpp */ - #ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONTROLS_HPP #define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONTROLS_HPP +#include "physicsSolvers/PhysicsSolverBase.hpp" #include "common/format/EnumStrings.hpp" #include "dataRepository/Group.hpp" #include "functions/TableFunction.hpp" #include "constitutive/fluid/multifluid/MultiFluidBase.hpp" +#include "constitutive/fluid/multifluid/MultiFluidBase.hpp" +#include "constitutive/fluid/singlefluid/SingleFluidBase.hpp" +#include "physicsSolvers/fluidFlow/wells/WellConstraintsBase.hpp" +#include "physicsSolvers/fluidFlow/wells/WellNewtonSolver.hpp" + namespace geos { namespace dataRepository @@ -36,17 +41,19 @@ static constexpr auto wellControls = "WellControls"; } } +class ElementsReporterBuffer; + /** * @class WellControls * @brief This class describes the controls used to operate a well. */ -class WellControls : public dataRepository::Group +class WellControls : public dataRepository::Group { public: /** Type of wells - * Either producer or injector. + * Either producer or injector */ enum class Type : integer { @@ -63,18 +70,6 @@ class WellControls : public dataRepository::Group CLOSED /**< shutin well */ }; - /** Types of well controls - * Used to specifiy a well's operating conditions - */ - enum class Control : integer - { - BHP, /**< The well operates at a specified bottom hole pressure (BHP) */ - PHASEVOLRATE, /**< The well operates at a specified phase volumetric flow rate */ - TOTALVOLRATE, /**< The well operates at a specified total volumetric flow rate */ - MASSRATE, /** const & localMatrix, + arrayView1d< real64 > const & localRhs ); + /** + * @brief assembles the accumulation term for an individual well + * @param time_n time at the beginning of the time step + * @param dt the time step size + * @param subRegion the well subregion containing all the primary and dependent fields + * @param dofManager degree-of-freedom manager associated with the linear system + * @param matrix the system matrix + * @param rhs the system right-hand side vector + */ + virtual void assembleWellAccumulationTerms( real64 const & time, + real64 const & dt, + WellElementSubRegion & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) = 0; + /** + * @brief assembles the well momentum terms for an individual well + * @param time_n time at the beginning of the time step + * @param dt the time step size + * @param subRegion the well subregion containing all the primary and dependent fields + * @param dofManager degree-of-freedom manager associated with the linear system + * @param matrix the system matrix + * @param rhs the system right-hand side vector + */ + virtual void assembleWellPressureRelations( real64 const & time_n, + real64 const & dt, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) = 0; + /** + * @brief assembles the well constraint terms for an individual well + * @param time_n time at the beginning of the time step + * @param dt the time step size + * @param subRegion the well subregion containing all the primary and dependent fields + * @param dofManager degree-of-freedom manager associated with the linear system + * @param matrix the system matrix + * @param rhs the system right-hand side vector */ - Control getControl() const { return m_currentControl; } + virtual void assembleWellConstraintTerms( real64 const & time_n, + real64 const & dt, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) = 0; /** - * @brief Set the control type for the well. - * @param[in] newControl type + * @brief Recompute the perforation rates for all the wells + * @param time_n the time at the beginning of the time step + * @param dt the time step size + * @param elemManager the element region manager + * @param subRegion the well subregion containing all the primary and dependent fields */ - void setControl( Control const & newControl ) { m_currentControl = newControl; } + virtual void computeWellPerforationRates( real64 const & time_n, + real64 const & GEOS_UNUSED_PARAM( dt ), + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion ) = 0; /** - * @brief Get the input control type for the well. - * @return the Control enum enforced at the well + * @brief assembles the flux terms for individual well for all connections between well elements + * @param time_n previous time value + * @param dt time step + * @param subRegion the well subregion containing all the primary and dependent fields + * @param dofManager degree-of-freedom manager associated with the linear system + * @param matrix the system matrix + * @param rhs the system right-hand side vector */ - Control getInputControl() const { return m_inputControl; } + virtual void assembleWellFluxTerms( real64 const & time, + real64 const & dt, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) = 0; + virtual real64 + calculateWellResidualNorm( real64 const & time_n, + real64 const & dt, + NonlinearSolverParameters const & nonlinearSolverParameters, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localRhs ) = 0; + + virtual array1d< real64 > + calculateLocalWellResidualNorm( real64 const & time_n, + real64 const & dt, + NonlinearSolverParameters const & nonlinearSolverParameters, + WellElementSubRegion const & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localRhs ) = 0; + + virtual real64 + scalingForWellSystemSolution( WellElementSubRegion & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution ) = 0; + + virtual bool + checkWellSystemSolution( WellElementSubRegion & subRegion, + DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution, + real64 const scalingFactor, + real64 & minPressure, + real64 & minDensity, + real64 & minTotalDensity, + ElementsReporterBuffer & negPressureIds, + ElementsReporterBuffer & negDensityIds, + ElementsReporterBuffer & negTotalDensityIds ) = 0; + + virtual void + applyWellSystemSolution( DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution, + real64 const scalingFactor, + real64 const dt, + DomainPartition & domain, + MeshLevel & mesh, + WellElementSubRegion & subRegion ) = 0; + + virtual void applyWellBoundaryConditions( real64 const time_n, + real64 const dt, + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion, + DofManager const & dofManager, + arrayView1d< real64 > const & localRhs, + CRSMatrixView< real64, globalIndex const > const & localMatrix ) = 0; + /** + * @brief Recompute all dependent quantities from primary variables (including constitutive models) + * @param subRegion the well subregion containing all the primary and dependent fields + */ + virtual real64 updateWellState( MeshBody const & meshBody, + ElementRegionManager const & elemManager, + WellElementSubRegion & subRegion ) = 0; /** - * @brief Getter for the reference elevation where the BHP control is enforced - * @return the reference elevation + * @brief Reset the well state to the beginning of the time step + * @param subRegion the well subregion containing all the primary and dependent fields */ - real64 getReferenceElevation() const { return m_refElevation; } + virtual void resetStateToBeginningOfStep( DomainPartition & domain, + string const & meshBodyName, ElementRegionManager const & elemManager, WellElementSubRegion & subRegion ) = 0; + + virtual void postInputInitialization() override; + + virtual void initializePreSubGroups() override; + + virtual void initializeWellPostInitialConditionsPreSubGroups( WellElementSubRegion & subRegion ) = 0; + virtual void printRates( real64 const & time_n, + real64 const & dt, + WellElementSubRegion const & subRegion ) = 0; /** - * @brief Getter for the reference gravity coefficient - * @return the reference gravity coefficient + * @name Getters / Setters */ - real64 getReferenceGravityCoef() const { return m_refGravCoef; } + ///@{ /** - * @brief Setter for the reference gravity + * @brief Get the Constitutive Name object + * + * @tparam CONSTITUTIVE_BASE_TYPE the base type of the constitutive model. + * @param subRegion the element subregion on which the constitutive model is registered + * @return the name name of the constitutive model of type CONSTITUTIVE_BASE_TYPE registered on the subregion. */ - void setReferenceGravityCoef( real64 const & refGravCoef ) { m_refGravCoef = refGravCoef; } + template< typename CONSTITUTIVE_BASE_TYPE > + static string getConstitutiveName( ElementSubRegionBase const & subRegion ); + /** + * @brief Register wrapper with given name and store constitutive model name on the subregion + * + * @tparam CONSTITUTIVE the base type of the constitutive model. + * @param subRegion the subregion on which the constitutive model is registered. + * @param wrapperName the wrapper name to register. + * @param constitutiveType the type description of the constitutive model. + */ + template< typename CONSTITUTIVE > + void setConstitutiveName( ElementSubRegionBase & subRegion, string const & wrapperName, string const & constitutiveType ) const; /** - * @brief Get the target bottom hole pressure value. - * @return a value for the target bottom hole pressure + * @brief return the list of target regions + * @return the array of region names */ - real64 getTargetBHP( real64 const & currentTime ) const - { - return m_targetBHPTable->evaluate( ¤tTime ); - } + string_array const & getTargetRegionNames() const {return m_targetRegionNames;} + /** + * @brief Get the control type for the well. + * @return the Control enum enforced at the well + */ + std::string getFlowSolverName() const { return m_flowSolverName; } /** - * @brief Get the target total rate - * @return the target total rate + * @brief Set the control type for the well. + * @param[in] flowSolverName the name of the flow solver */ - real64 getTargetTotalRate( real64 const & currentTime ) const - { - return m_rateSign * m_targetTotalRateTable->evaluate( ¤tTime ); - } + void setFlowSolverName( const std::string & flowSolverName ) { m_flowSolverName = flowSolverName; } /** - * @brief Get the target phase rate - * @return the target phase rate + * @brief return the name of the discretization object + * @return the name of the discretization object */ - real64 getTargetPhaseRate( real64 const & currentTime ) const - { - return m_rateSign * m_targetPhaseRateTable->evaluate( ¤tTime ); - } + std::string getDiscretizationName() const { return m_discretizationName; } /** - * @brief Get the target mass rate - * @return the target mass rate + * @brief set the name of the discretization object + * @param[in] discretizationName name */ - real64 getTargetMassRate( real64 const & currentTime ) const - { - return m_rateSign * m_targetMassRateTable->evaluate( ¤tTime ); - } + void setDiscretizationName( const std::string & discretizationName ) { m_discretizationName = discretizationName; } + /** + * @brief Get the control type for the well. + * @return the Control enum enforced at the well + */ + ConstraintTypeId getControl() const { return m_currentControl; } + + /** + * @brief Set the control type for the well. + * @param[in] newControl type + */ + void setControl( ConstraintTypeId const & newControl ) { m_currentControl = newControl; } /** - * @brief Get the target phase name - * @return the target phase name + * @brief Get the input control type for the well. + * @return the Control enum enforced at the well */ - const string & getTargetPhaseName() const { return m_targetPhaseName; } + ConstraintTypeId getInputControl() const { return m_inputControl; } /** - * @brief Const accessor for the composition of the injection stream - * @return a global component fraction vector + * @brief getter for esitmator switch + * @return True if estimate well solution */ - arrayView1d< real64 const > getInjectionStream() const { return m_injectionStream; } + integer estimateSolution() const { return m_estimateSolution; } + + + /** + * @brief Returns the target bottom hole pressure value. + * @param[in] targetTime time at which to evaluate the constraint + * @return the injector maximum bottom hole pressure or producer minimum bottom hole pressure + */ + real64 getTargetBHP( real64 const & targetTime, const ConstraintSourceId source = ConstraintSourceId::USER ) const; /** * @brief Const accessor for the temperature of the injection stream * @return the temperature of the injection stream */ - real64 getInjectionTemperature() const { return m_injectionTemperature; } + real64 getInjectionTemperature() const; + + /** + * @brief Const accessor for the injection stream + * @return the injection stream + */ + arrayView1d< real64 const > getInjectionStream() const; + + /** + * @brief Const accessor for the phase constraint index + * @return phase index associated with phase constraint + */ + integer getConstraintPhaseIndex() const; + + /** + * @brief Return the reference elvation where pressure constraint is measured + * @return vertical location of constraint + */ + real64 getReferenceElevation() const; /** * @brief Getter for the flag specifying whether we check rates at surface or reservoir conditions @@ -278,12 +527,66 @@ class WellControls : public dataRepository::Group */ bool isProducer() const { return ( m_type == Type::PRODUCER ); } + /** + * @brief getter for iso/thermal switch + * @return True if thermal + */ + integer isThermal() const { return m_isThermal; } + + /** + * @brief setter for iso/thermal switch + * @param[in] isThermal + */ + + void setThermal( bool isThermal ) { m_isThermal=isThermal; } + + /** + * @brief setter to activate mass formulation + * @param[in] useMass + */ + + void setUseMass( integer useMass ) { m_useMass=useMass; } + + /** + * @brief is useMass option active + * @return a boolean + */ + + integer useMass( ) { return m_useMass;} + /** * @brief Is the well open (or shut) at currentTime, status initalized in WellSolverBase::implicitStepSetup * @return a boolean */ bool isWellOpen() const; + /** + * @brief Set the well state + * @param[in] open boolean + */ + void setWellState( bool open ); + /** + * @brief Get the well state + * @return a boolean + */ + bool getWellState() const; + + /** + * @brief Set the current consrtaint + * @param[in] currentConstraint pointer to constraint + */ + void setCurrentConstraint( WellConstraintBase * currentConstraint ) + { + setControl( currentConstraint->getControl() ); + m_currentConstraint = currentConstraint; + } + /** + * @brief Get the current consrtaint + * @return pointer to constraint + */ + WellConstraintBase * getCurrentConstraint() { return m_currentConstraint; } + WellConstraintBase const * getCurrentConstraint() const { return m_currentConstraint; } + /** * @brief Getter for the flag to enable crossflow * @return the flag deciding whether crossflow is allowed or not @@ -302,6 +605,16 @@ class WellControls : public dataRepository::Group * @param[inout] nextDt the time step */ void setNextDtFromTables( real64 const & currentTime, real64 & nextDt ); + /** + * @brief Utility function to keep the well variables during a time step (used in + * poromechanics simulations) + * @param[in] keepVariablesConstantDuringInitStep flag to tell the solver to freeze its + * primary variables during a time step + * @detail This function is meant to be called by a specific task before/after the + * initialization step + */ + void setKeepVariablesConstantDuringInitStep( bool const keepVariablesConstantDuringInitStep ) + { m_keepVariablesConstantDuringInitStep = keepVariablesConstantDuringInitStep; } /** * @brief setter for multi fluid separator @@ -314,6 +627,12 @@ class WellControls : public dataRepository::Group */ constitutive::MultiFluidBase & getMultiFluidSeparator() { return dynamicCast< constitutive::MultiFluidBase & >( *m_fluidSeparatorPtr ); } + /** + * @brief Getter for single fluid separator + * @return reference to separator + */ + constitutive::SingleFluidBase & getSingleFluidSeparator() { return dynamicCast< constitutive::SingleFluidBase & >( *m_fluidSeparatorPtr ); } + /** * @brief Getter for the reservoir average pressure when m_useSurfaceConditions == 0 * @note When not available, value is less or equal to 0.0. @@ -354,34 +673,49 @@ class WellControls : public dataRepository::Group WellControls::Status getWellStatus () const { return m_wellStatus; } ///@} + virtual string wellElementDofName() const = 0; + + virtual string resElementDofName() const = 0; + + /** + * @brief getter for the number of degrees of freedom per well element + * @return the number of dofs + */ + localIndex numDofPerWellElement() const { return m_numDofPerWellElement; } + + /** + * @brief getter for the number of degrees of freedom per mesh element + * @return the number of dofs + */ + localIndex numDofPerResElement() const { return m_numDofPerResElement; } + + + virtual localIndex numFluidComponents() const = 0; + + virtual localIndex numFluidPhases() const = 0; + /** * @brief Struct to serve as a container for variable strings and keys. * @struct viewKeyStruct */ struct viewKeyStruct { + /// String key for the fluid model names + static constexpr char const * fluidNamesString() { return "fluidNames"; } + /// String key for the write CSV flag + static constexpr char const * writeCSVFlagString() { return "writeCSV"; } + static constexpr char const * timeStepFromTablesFlagString() { return "timeStepFromTables"; } + /// String for the targetRegions wrapper + static constexpr char const * targetRegionsString() { return "targetRegions"; } + /// String key for the well reference elevation (for BHP control) static constexpr char const * refElevString() { return "referenceElevation"; } /// String key for the well type static constexpr char const * typeString() { return "type"; } - /// String key for the well input control - static constexpr char const * inputControlString() { return "control"; } /// String key for the well current control static constexpr char const * currentControlString() { return "currentControl"; } - /// String key for the well target BHP - static constexpr char const * targetBHPString() { return "targetBHP"; } - /// String key for the well target rate - static constexpr char const * targetTotalRateString() { return "targetTotalRate"; } - /// String key for the well target phase rate - static constexpr char const * targetPhaseRateString() { return "targetPhaseRate"; } - /// String key for the well target phase name - static constexpr char const * targetPhaseNameString() { return "targetPhaseName"; } - /// String key for the well target phase name - static constexpr char const * targetMassRateString() { return "targetMassRate"; } - /// String key for the well injection stream - static constexpr char const * injectionStreamString() { return "injectionStream"; } - /// String key for the well injection temperature - static constexpr char const * injectionTemperatureString() { return "injectionTemperature"; } + /// String key for the well input control + static constexpr char const * inputControlString() { return "control"; } /// String key for checking the rates at surface conditions static constexpr char const * useSurfaceConditionsString() { return "useSurfaceConditions"; } /// String key for reference reservoir region @@ -390,14 +724,7 @@ class WellControls : public dataRepository::Group static constexpr char const * surfacePressureString() { return "surfacePressure"; } /// String key for the surface temperature static constexpr char const * surfaceTemperatureString() { return "surfaceTemperature"; } - /// string key for total rate table name - static constexpr char const * targetTotalRateTableNameString() { return "targetTotalRateTableName"; } - /// string key for phase rate table name - static constexpr char const * targetPhaseRateTableNameString() { return "targetPhaseRateTableName"; } - /// string key for mass rate table name - static constexpr char const * targetMassRateTableNameString() { return "targetMassRateTableName"; } - /// string key for BHP table name - static constexpr char const * targetBHPTableNameString() { return "targetBHPTableName"; } + /// string key for status table name static constexpr char const * statusTableNameString() { return "statusTableName"; } /// string key for perforation status table name @@ -407,55 +734,217 @@ class WellControls : public dataRepository::Group /// string key for the initial pressure coefficient static constexpr char const * initialPressureCoefficientString() { return "initialPressureCoefficient"; } - } - /// ViewKey struct for the WellControls class - viewKeysWellControls; + /// string key for the estimate well solution flag + static constexpr char const * estimateWellSolutionString() { return "estimateWellSolution"; } + /// string key for the enable iso thermal estimator flag + static constexpr char const * enableIsoThermalEstimatorString() { return "enableIsoThermalEstimator"; } + + // control data (not registered on the mesh) + static constexpr char const * massDensityString() { return "massDensity";} + + static constexpr char const * currentBHPString() { return "currentBHP"; } + + static constexpr char const * currentPhaseVolRateString() { return "currentPhaseVolumetricRate"; } + static constexpr char const * currentVolRateString() { return "currentVolRate"; } + + static constexpr char const * currentTotalVolRateString() { return "currentTotalVolumetricRate"; } + + static constexpr char const * currentMassRateString() { return "currentMassRate"; } + }; + + /** + * @brief Structure to hold scoped key names + */ + struct groupKeyStruct + { + /// string key for the well Newton solver + static constexpr char const * wellNewtonSolverString() { return "WellNewtonSolver"; } + }; + + void setPerforationStatus( real64 const & time_n, WellElementSubRegion & subRegion ); + void setGravCoef( WellElementSubRegion & subRegion, R1Tensor const & gravVector ); + /** + * @brief Set next time step based on a table function + * @param[in] table the table function + * @param[in] currentTime the current time + * @param[inout] nextDt the time step + */ static void setNextDtFromTable( TableFunction const * table, real64 const currentTime, real64 & nextDt ); + /** + * @brief Create a constraint + * @tparam ConstraintType the type of constraint to create + * @param[in] constraintName name to assign to the constraint + */ + template< typename ConstraintType > void createConstraint ( string const & constraintName ); + + + /** + * @brief Gets the defined BHP constraint + * @details Returns the BHP constraint if one is defined for the WellControl. For a producer + * well this will be a minimum BHP constraint and for an injector well this will be a maximum + * BHP constraint. This will possibly return null if no BHP constraint is set. Validation is + * in place to enforce the setting of at least one BHp constraint. + * @return A BHP constraint object of one is defined + */ + WellConstraintBase const * getBHPConstraint( const ConstraintSourceId source = ConstraintSourceId::USER ) const; + WellConstraintBase * getBHPConstraint( const ConstraintSourceId source = ConstraintSourceId::USER ); + + /** + * @brief Gets a list of rate constraints + * @details Returns a list of rate constraints for the WellControl. For a producer + * well these will be a production rate constraints `ProductionConstraint` and for an + * injector well these will be injection rate constraints `InjectionConstraint`. + */ + stdVector< WellConstraintBase const * > getRateConstraints() const; + stdVector< WellConstraintBase * > getRateConstraints(); + + /** + * @brief Gets a list of all constraints constraints + * @details Returns a list of all constraints for the WellControl including rate and BHP + * constraints. + */ + stdVector< WellConstraintBase const * > getAllConstraints() const; + stdVector< WellConstraintBase * > getAllConstraints(); + + /** + * @brief Set thermal effects enable + * @param[in] true/false + */ + void enableThermalEffects ( bool enable ) { m_thermalEffectsEnabled = enable; }; + + /** + * @brief Are thermal effects enabled + * @return true if thermal effects are enabled, false otherwise + */ + bool thermalEffectsEnabled() const { return m_thermalEffectsEnabled; } + + /** + * @brief Is isoThermalEstimator enabled + * @return true if isoThermalEstimator is enabled, false otherwise + */ + bool isoThermalEstimatorEnabled() const { return m_enableIsoThermalEstimator; } + + void setupWellDofs( DomainPartition & domain, WellElementRegion & wellElementRegion, string const & meshBodyName, MeshLevel const & meshLevel ); + WellNewtonSolver & getWellNewtonSolver() { return m_wellNewtonSolver; } + + void selectWellConstraint( real64 const & time_n, + real64 const & dt, + integer const cycleNumber, + integer const coupledIterationNumber, + DomainPartition & domain, + string const & meshBodyName, + MeshLevel & mesh, + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion, + DofManager const & dofManager ); + protected: + virtual void postRestartInitialization( )override; - virtual void postInputInitialization() override; + /** + * @brief Logs the state and values of a specific well constraint. + * + * @details This method evaluates whether the provided constraint requires + * logging based on its validity, the current log level being strictly greater + * than 4, and the region being locally owned. When the constraint is flagged + * as the limiting constraint, it logs extensive operational data such as the + * bottom hole pressure, individual phase volume rates, the total volume rate, + * and the mass rate. Otherwise, it logs general information, specifically + * whether the constraint is active and its target value at the current time. + * + * @param constraint Pointer to the base constraint object to evaluate and log. + * @param region Reference to the well element sub-region associated with it. + * @param time The current simulation time used to get the constraint value. + * @param isLimiting Boolean indicating if this is the active limiting constraint. + */ + void logConstraint( WellConstraintBase const * constraint, + WellElementSubRegion const & region, + real64 time, + bool isLimiting = false ) const; + /** + * @brief Validates the reference region + * @details Validates the reference region by ensuring that it is defined for cases that do not + * use surface conditions. If the reference region is provided, it is checked against the flow + * solves regions. + * @return @c true if the region is valid + */ + bool validateReferenceRegion() const; + /** + * @brief Validates and retrieves the reference region statistics for average pressure and temperature. + * + * @details This template method checks if a reference reservoir region is configured for the well control. + * If a region is specified, it retrieves the region from the provided element manager and verifies + * that the required statistics wrapper exists. It then extracts the average pressure and temperature, + * throwing an exception if the average pressure has not been properly computed. + * + * @tparam STATISTICS Type providing static methods and types for region statistics (SinglePhaseStatistics or + * CompositionalMultiphaseStatistics). + * @param elementManager Reference to the ElementRegionManager used to look up the reservoir region. + * @param[out] averagePressure Reference to a real64 variable where the retrieved average pressure is stored. + * @param[out] averageTemperature Reference to a real64 variable where the retrieved average temperature is stored. + * @return Boolean value, always returning true upon successful validation. + */ + //template< typename STATISTICS > + //bool validateReferenceRegionStatistics( ElementRegionManager const & elementManager, + // real64 & averagePressure, + // real64 & averageTemperature ) const; private: + /// List of names of regions the solver will be applied to + string_array m_targetRegionNames; + +protected: /// Well type (as Type enum) Type m_type; - /// Reference elevation - real64 m_refElevation; + /// Name of the flow solver managing this well + std::string m_flowSolverName; - /// Gravity coefficient of the reference elevation - real64 m_refGravCoef; + /// Name of the discretization for the region + std::string m_discretizationName; - /// Input well controls as a Control enum - Control m_inputControl; + /// flag indicating whether mass or molar formulation should be used + integer m_useMass; - /// Well controls as a Control enum - Control m_currentControl; + /// the max number of fluid phases + integer m_numPhases; - /// Target bottom hole pressure value - real64 m_targetBHP; + /// the number of fluid components + integer m_numComponents; - /// Target rate value - real64 m_targetTotalRate; + /// the number of Degrees of Freedom per well element + integer m_numDofPerWellElement; - /// Target phase rate value - real64 m_targetPhaseRate; + /// the number of Degrees of Freedom per reservoir element + integer m_numDofPerResElement; - /// Name of the targeted phase - string m_targetPhaseName; + /// flag indicating whether thermal formulation is used + integer m_isThermal; + /// flag to freeze the initial state during initialization in coupled problems + bool m_keepVariablesConstantDuringInitStep; + /// rates output + integer m_writeCSV; + string const m_ratesOutputDir; + + // flag to enable time step selection base on rates/bhp tables coordinates + integer m_timeStepFromTables; + + /// Reference elevation + real64 m_refElevation; - /// Target MassRate - real64 m_targetMassRate; + /// Gravity coefficient of the reference elevation + real64 m_refGravCoef; - /// Vector with global component fractions at the injector - array1d< real64 > m_injectionStream; + /// Input well controls as a Control enum + ConstraintTypeId m_inputControl; - /// Temperature at the injector - real64 m_injectionTemperature; + /// Well controls as a Control enum + ConstraintTypeId m_currentControl; /// Flag to decide whether rates are controlled at rates or surface conditions integer m_useSurfaceConditions; @@ -463,6 +952,9 @@ class WellControls : public dataRepository::Group // Fuild model to compute properties for constraint equation user specified conditions std::unique_ptr< constitutive::ConstitutiveBase > m_fluidSeparatorPtr; + /// name of the fluid constitutive model used as a reference for component/phase description on subregion + string m_referenceFluidModelName; + /// Reservoir region associated with reservoir volume constraint string m_referenceReservoirRegion; @@ -472,21 +964,6 @@ class WellControls : public dataRepository::Group /// Surface temperature real64 m_surfaceTemp; - /// Total rate table name - string m_targetTotalRateTableName; - - /// Phase rate table name - string m_targetPhaseRateTableName; - - /// Mass rate table name - string m_targetMassRateTableName; - - /// BHP table name - string m_targetBHPTableName; - - /// Well status table name - string m_statusTableName; - /// Perforation status table name string m_perfStatusTableName; @@ -496,41 +973,50 @@ class WellControls : public dataRepository::Group /// Tuning coefficient for the initial well pressure real64 m_initialPressureCoefficient; - /// Rate sign. +1 for injector, -1 for producer - real64 m_rateSign; - - /// Total rate table - TableFunction const * m_targetTotalRateTable; + // Current constrint + WellConstraintBase * m_currentConstraint{}; - /// Phase rate table - TableFunction const * m_targetPhaseRateTable; + /// Well status + WellControls::Status m_wellStatus; - /// Mass rate table - TableFunction const * m_targetMassRateTable; + /// Well open flag + bool m_wellOpen; - /// BHP table - TableFunction const * m_targetBHPTable; + /// Well status table name + string m_statusTableName; /// Status table TableFunction const * m_statusTable; - /// Well status - WellControls::Status m_wellStatus; - - /// Region average pressure used in volume rate constraint calculations real64 m_regionAveragePressure; /// Region average temperature used in volume rate constraint calculations real64 m_regionAverageTemperature; + integer m_estimateSolution; + integer m_enableIsoThermalEstimator; + bool m_thermalEffectsEnabled; + + WellNewtonSolver m_wellNewtonSolver; + + + /// @brief Well DofManager + /// @details This DofManager is used to store the DOF numbers for the estimator + /// @note This DofManager is used in the assembly of the estimators linear system + DofManager m_estimatorDoFManager; + bool m_dofManagerInitialized; }; -ENUM_STRINGS( WellControls::Type, + +// Use local aliases to avoid accidental macro expansion of the tokens 'Type' or 'Control' +using WellControls_Type = WellControls::Type; +ENUM_STRINGS( WellControls_Type, "producer", "injector" ); -ENUM_STRINGS( WellControls::Control, +using WellControls_Control = ConstraintTypeId; +ENUM_STRINGS( WellControls_Control, "BHP", "phaseVolRate", "totalVolRate", @@ -538,6 +1024,62 @@ ENUM_STRINGS( WellControls::Control, "uninitialized" ); +template< typename CONSTITUTIVE > +void WellControls::setConstitutiveName( ElementSubRegionBase & subRegion, string const & wrapperName, string const & constitutiveType ) const +{ + subRegion.registerWrapper< string >( wrapperName ). + setPlotLevel( dataRepository::PlotLevel::NOPLOT ). + setRestartFlags( dataRepository::RestartFlags::NO_WRITE ). + setSizedFromParent( 0 ); + + string & constitutiveName = subRegion.getReference< string >( wrapperName ); + constitutiveName = getConstitutiveName< CONSTITUTIVE >( subRegion ); + GEOS_ERROR_IF( constitutiveName.empty(), GEOS_FMT( "{}: {} constitutive model not found on subregion {}", + getDataContext(), constitutiveType, subRegion.getName() ) ); +} +template< typename CONSTITUTIVE_BASE_TYPE > +string WellControls::getConstitutiveName( ElementSubRegionBase const & subRegion ) +{ + string validName; + dataRepository::Group const & constitutiveModels = subRegion.getConstitutiveModels(); + + constitutiveModels.forSubGroups< CONSTITUTIVE_BASE_TYPE >( [&]( dataRepository::Group const & model ) + { + GEOS_ERROR_IF( !validName.empty(), "A valid constitutive model was already found." ); + validName = model.getName(); + } ); + + return validName; +} + +/** + * @brief Get the Constitutive Model object + * @tparam BASETYPE the base type of the constitutive model. + * @tparam LOOKUP_TYPE the type of the key used to look up the constitutive model. + * @param dataGroup the data group containing the constitutive models. + * @param key the key used to look up the constitutive model. + * @return the constitutive model of type @p BASETYPE registered on the @p dataGroup with the key @p key. + */ +template< typename BASETYPE = constitutive::ConstitutiveBase, typename LOOKUP_TYPE > +static BASETYPE const & getConstitutiveModel( dataRepository::Group const & dataGroup, LOOKUP_TYPE const & key ) +{ + dataRepository::Group const & constitutiveModels = dataGroup.getGroup( ElementSubRegionBase::groupKeyStruct::constitutiveModelsString() ); + return constitutiveModels.getGroup< BASETYPE >( key ); +} +/** + * @brief Get the Constitutive Model object + * @tparam BASETYPE the base type of the constitutive model. + * @tparam LOOKUP_TYPE the type of the key used to look up the constitutive model. + * @param dataGroup the data group containing the constitutive models. + * @param key the key used to look up the constitutive model. + * @return the constitutive model of type @p BASETYPE registered on the @p dataGroup with the key @p key. + */ +template< typename BASETYPE = constitutive::ConstitutiveBase, typename LOOKUP_TYPE > +static BASETYPE & getConstitutiveModel( dataRepository::Group & dataGroup, LOOKUP_TYPE const & key ) +{ + dataRepository::Group & constitutiveModels = dataGroup.getGroup( ElementSubRegionBase::groupKeyStruct::constitutiveModelsString() ); + return constitutiveModels.getGroup< BASETYPE >( key ); +} } //namespace geos #endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONTROLS_HPP diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellFields.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellFields.hpp index 5f77922f4ee..3bb07399534 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellFields.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellFields.hpp @@ -34,6 +34,21 @@ namespace fields namespace well { +DECLARE_FIELD( connectionRate, + "wellElementConnectionRate", + array1d< real64 >, + 0, + LEVEL_0, + WRITE_AND_READ, + "Connection rate" ); + +DECLARE_FIELD( connectionRate_n, + "wellElementConnectionRate_n", + array1d< real64 >, + 0, + NOPLOT, + WRITE_AND_READ, + "Connection rate at the previous converged time step" ); DECLARE_FIELD( energyPerforationFlux, "energyPerforationFlux", array1d< real64 >, @@ -50,6 +65,61 @@ DECLARE_FIELD( dEnergyPerforationFlux, NO_WRITE, "Derivative of energy perforation flux with respect to pressure temperature and global component density (compositional only)" ); +DECLARE_FIELD( pressure, + "pressure", + array1d< real64 >, + 0, + LEVEL_0, + WRITE_AND_READ, + "Pressure" ); + +DECLARE_FIELD( pressure_n, + "pressure_n", + array1d< real64 >, + 0, + NOPLOT, + WRITE_AND_READ, + "Pressure at the previous converged time step" ); + +DECLARE_FIELD( temperature, + "temperature", + array1d< real64 >, + 0, + LEVEL_0, + WRITE_AND_READ, + "Temperature" ); + +DECLARE_FIELD( temperature_n, + "temperature_n", + array1d< real64 >, + 0, + NOPLOT, + WRITE_AND_READ, + "Temperature at the previous converged time step" ); + +DECLARE_FIELD( gravityCoefficient, + "gravityCoefficient", + array1d< real64 >, + 0, + NOPLOT, + WRITE_AND_READ, + "Gravity coefficient (dot product of gravity acceleration by gravity vector)" ); + +DECLARE_FIELD( pressureScalingFactor, + "pressureScalingFactor", + array1d< real64 >, + 1, + NOPLOT, + NO_WRITE, + "Scaling factors for pressure" ); + +DECLARE_FIELD( temperatureScalingFactor, + "temperatureScalingFactor", + array1d< real64 >, + 1, + NOPLOT, + NO_WRITE, + "Scaling factors for temperature" ); } diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellInjectionConstraint.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellInjectionConstraint.cpp new file mode 100644 index 00000000000..425a10147c8 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellInjectionConstraint.cpp @@ -0,0 +1,107 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellInjectionConstraint.cpp + */ + +#include "LogLevelsInfo.hpp" +#include "WellInjectionConstraint.hpp" +#include "WellConstants.hpp" +#include "dataRepository/InputFlags.hpp" +#include "functions/FunctionManager.hpp" + +#include "WellMassRateConstraint.hpp" +#include "WellPhaseVolumeRateConstraint.hpp" +#include "WellVolumeRateConstraint.hpp" + +namespace geos +{ +using namespace dataRepository; + +template< typename ConstraintRateType > +InjectionConstraint< ConstraintRateType >::InjectionConstraint( string const & name, Group * const parent ) + : ConstraintRateType( name, parent ) +{ + // set rate sign for injectors (base class member) + this->m_rateSign = 1.0; + classtype::registerWrapper( injectionStreamKey::injectionStreamString(), &m_injectionStream ). + setDefaultValue( -1 ). + setSizedFromParent( 0 ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Global component densities of the injection stream [moles/m^3 or kg/m^3]" ); + + InjectionConstraint< ConstraintRateType >::registerWrapper( injectionStreamKey::injectionTemperatureString(), &m_injectionTemperature ). + setDefaultValue( -1 ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Temperature of the injection stream [K]" ); +} +template< typename ConstraintRateType > +InjectionConstraint< ConstraintRateType >::~InjectionConstraint() +{} +template< typename ConstraintRateType > +void InjectionConstraint< ConstraintRateType >::postInputInitialization() +{ + // Validate value and table options + ConstraintRateType::postInputInitialization(); + +// Validate the injection stream and temperature + validateInjectionStream( ); + +} +template< typename ConstraintRateType > +void InjectionConstraint< ConstraintRateType >::validateInjectionStream( ) +{ + GEOS_THROW_IF( (m_injectionStream.empty() && m_injectionTemperature >= 0) || + (!m_injectionStream.empty() && m_injectionTemperature < 0), + this->getName() << " " << this->getDataContext() << ": Both " + << injectionStreamKey::injectionStreamString() << " and " << injectionStreamKey::injectionTemperatureString() + << " must be specified for multiphase simulations", + InputError ); + + if( !m_injectionStream.empty()) + { + real64 sum = 0.0; + for( localIndex ic = 0; ic < m_injectionStream.size(); ++ic ) + { + GEOS_ERROR_IF( m_injectionStream[ic] < 0.0 || m_injectionStream[ic] > 1.0, + classtype::getWrapperDataContext( injectionStreamKey::injectionStreamString() ) << ": Invalid injection stream" ); + sum += m_injectionStream[ic]; + } + GEOS_THROW_IF( LvArray::math::abs( 1.0 - sum ) > std::numeric_limits< real64 >::epsilon(), + classtype::getWrapperDataContext( injectionStreamKey::injectionStreamString() ) << ": Invalid injection stream", + InputError ); + } +} + +// Register concrete wrapper constraint types and instantiate templates. +//template class InjectionConstraint< LiquidRateConstraint >; +//using InjectionLiquidRateConstraint = InjectionConstraint< LiquidRateConstraint >; +//REGISTER_CATALOG_ENTRY( WellConstraintBase, InjectionLiquidRateConstraint, string const &, Group * const ) + +template class InjectionConstraint< MassRateConstraint >; +using InjectionMassRateConstraint = InjectionConstraint< MassRateConstraint >; +REGISTER_CATALOG_ENTRY( WellConstraintBase, InjectionMassRateConstraint, string const &, Group * const ) + +template class InjectionConstraint< PhaseVolumeRateConstraint >; +using InjectionPhaseVolumeRateConstraint = InjectionConstraint< PhaseVolumeRateConstraint >; +REGISTER_CATALOG_ENTRY( WellConstraintBase, InjectionPhaseVolumeRateConstraint, string const &, Group * const ) + +template class InjectionConstraint< VolumeRateConstraint >; +using InjectionVolumeRateConstraint = InjectionConstraint< VolumeRateConstraint >; +REGISTER_CATALOG_ENTRY( WellConstraintBase, InjectionVolumeRateConstraint, string const &, Group * const ) + + +} diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellInjectionConstraint.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellInjectionConstraint.hpp new file mode 100644 index 00000000000..7dfd4d21e53 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellInjectionConstraint.hpp @@ -0,0 +1,151 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellInjectionConstraint.hpp + */ + + +#ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLINJECTIONCONSTRAINT_HPP +#define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLINJECTIONCONSTRAINT_HPP + +#include "common/format/EnumStrings.hpp" +#include "dataRepository/Group.hpp" +#include "functions/TableFunction.hpp" + +namespace geos +{ + +using namespace dataRepository; +/** + * @class InjectionConstraint + * @brief This class describes constraint used to control a injection well. + */ + +template< typename ConstraintType > +class InjectionConstraint : public ConstraintType +{ +public: + typedef InjectionConstraint< ConstraintType > classtype; + /** + * @name Constructor / Destructor + */ + ///@{ + + /** + * @brief Constructor for WellControls Objects. + * @param[in] name the name of this instantiation of WellControls in the repository + * @param[in] parent the parent group of this instantiation of WellControls + */ + explicit InjectionConstraint( string const & name, dataRepository::Group * const parent ); + + /** + * @brief Default destructor. + */ + ~InjectionConstraint() override; + + /** + * @brief Deleted default constructor. + */ + InjectionConstraint() = delete; + + /** + * @brief Deleted copy constructor. + */ + InjectionConstraint( InjectionConstraint const & ) = delete; + + /** + * @brief Deleted move constructor. + */ + InjectionConstraint( InjectionConstraint && ) = delete; + + /** + * @brief Deleted assignment operator. + * @return a reference to a constraint object + */ + InjectionConstraint & operator=( InjectionConstraint const & ) = delete; + + /** + * @brief Deleted move operator. + * @return a reference to a constraint object + */ + InjectionConstraint & operator=( InjectionConstraint && ) = delete; + + ///@} + + /** + * @brief name of the node manager in the object catalog + * @return string that contains the catalog name to generate a new Constraint object through the object catalog. + */ + static string catalogName() + { + return "Injection"+ConstraintType::catalogName(); + } + + virtual string getCatalogName() const override { return catalogName(); } + + struct injectionStreamKey + { + /// String key for the well injection stream + static constexpr char const * injectionStreamString() { return "injectionStream"; } + /// String key for the well injection temperature + static constexpr char const * injectionTemperatureString() { return "injectionTemperature"; } + }; + + /** + * @brief Const accessor for the composition of the injection stream + * @return a global component fraction vector + */ + arrayView1d< real64 const > getInjectionStream() const { return m_injectionStream; } + + /** + * @brief Const accessor for the temperature of the injection stream + * @return the temperature of the injection stream + */ + real64 getInjectionTemperature() const { return m_injectionTemperature; } + + /** + * @brief Set composition of the injection stream + * @param[in] injectionStream a global component fraction vector + */ + void setInjectionStream( arrayView1d< real64 const > const & injectionStream ) { m_injectionStream = injectionStream; } + + /** + * @brief Set temperature of the injection stream + * @param[in] temperature the temperature of the injection stream + */ + void setInjectionTemperature( real64 temperature ) { m_injectionTemperature = temperature; } + +protected: + + virtual void postInputInitialization() override; + static bool isViolated( const real64 & currentValue, const real64 & constraintValue ) + { return currentValue > constraintValue; } + + void validateInjectionStream(); +private: + + /// Vector with global component fractions at the injector + array1d< real64 > m_injectionStream; + + /// Temperature at the injector + real64 m_injectionTemperature; + +}; + + +} //namespace geos + +#endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLINJECTIONCONSTRAINT_HPP diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellLiquidRateConstraint.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellLiquidRateConstraint.cpp new file mode 100644 index 00000000000..3c84f70f1a7 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellLiquidRateConstraint.cpp @@ -0,0 +1,76 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellLiquidRateConstraint.cpp + */ + +#include "LogLevelsInfo.hpp" +#include "WellLiquidRateConstraint.hpp" +#include "WellConstants.hpp" +#include "dataRepository/InputFlags.hpp" +#include "functions/FunctionManager.hpp" + +namespace geos +{ + +using namespace dataRepository; + + +LiquidRateConstraint::LiquidRateConstraint( string const & name, Group * const parent ) + : WellConstraintBase( name, parent ) +{ + this->registerWrapper( viewKeyStruct::liquidRateString(), &this->m_constraintValue ). + setDefaultValue( 0.0 ). + setInputFlag( InputFlags::OPTIONAL ). + setRestartFlags( RestartFlags::WRITE_AND_READ ). + setDescription( "Phase rate, (if useSurfaceCondSitions: [surface m^3/s]; else [reservoir m^3/s]) " ); + + this->registerWrapper( viewKeyStruct::phaseNamesString(), &m_phaseNames ). + setRTTypeName( rtTypes::CustomTypes::groupNameRefArray ). + setInputFlag( InputFlags::REQUIRED ). + setDescription( "List of fluid phase names defining the liquid" ); +} + +LiquidRateConstraint::~LiquidRateConstraint() +{} + +void LiquidRateConstraint::postInputInitialization() +{ + // Validate table options + WellConstraintBase::postInputInitialization(); + + // check constraint value + GEOS_THROW_IF( m_constraintValue < 0, + getWrapperDataContext( viewKeyStruct::liquidRateString() ) << ": Target value is negative", + InputError ); + + GEOS_THROW_IF ((m_constraintValue <= 0.0 && m_constraintScheduleTableName.empty()), + getName() << " " << getDataContext() << ": You need to specify a liquid rate constraint. \n" << + "The rate constraint can be specified using " << + "either " << viewKeyStruct::liquidRateString() << + " or " << WellConstraintBase::viewKeyStruct::constraintScheduleTableNameString(), + InputError ); +} + + +bool LiquidRateConstraint::checkViolation( WellConstraintBase const & currentConstraint, real64 const & currentTime ) const +{ + real64 const currentValue = currentConstraint.liquidRate(); + real64 const constraintValue = this->getConstraintValue( currentTime ); + return ( LvArray::math::abs( currentValue ) <= LvArray::math::abs( constraintValue ) ); +} + +} //namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellLiquidRateConstraint.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellLiquidRateConstraint.hpp new file mode 100644 index 00000000000..10ba7bffdf2 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellLiquidRateConstraint.hpp @@ -0,0 +1,175 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellLiquidRateConstraint.hpp + */ + + +#ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLLIQUIDRATECONSTRAINT_HPP +#define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLLIQUIDRATECONSTRAINT_HPP + +#include "common/format/EnumStrings.hpp" + +#include "functions/TableFunction.hpp" +#include "WellConstraintsBase.hpp" + +namespace geos +{ + + +/** + * @class LiquidRateConstraint + * @brief This class describes a Liquid rate constraint used to control of type WellConstraintType + */ + + +class LiquidRateConstraint : public WellConstraintBase +{ +public: + + + /** + * @name Constructor / Destructor + */ + ///@{ + + /** + * @brief Constructor for WellControls Objects. + * @param[in] name the name of this instantiation of WellControls in the repository + * @param[in] parent the parent group of this instantiation of WellControls + */ + explicit LiquidRateConstraint( string const & name, dataRepository::Group * const parent ); + + + /** + * @brief Default destructor. + */ + ~LiquidRateConstraint() override; + + /** + * @brief Deleted default constructor. + */ + LiquidRateConstraint() = delete; + + /** + * @brief Deleted copy constructor. + */ + LiquidRateConstraint( LiquidRateConstraint const & ) = delete; + + /** + * @brief Deleted move constructor. + */ + LiquidRateConstraint( LiquidRateConstraint && ) = delete; + + /** + * @brief Deleted assignment operator. + * @return a reference to a constraint object + */ + LiquidRateConstraint & operator=( LiquidRateConstraint const & ) = delete; + + /** + * @brief Deleted move operator. + * @return a reference to a constraint object + */ + LiquidRateConstraint & operator=( LiquidRateConstraint && ) = delete; + + /** + * @brief name of the node manager in the object catalog + * @return string that contains the catalog name to generate a new Constraint object through the object catalog. + */ + static string catalogName() + { + return "LiquidRateConstraint"; + } + ///@} + + /** + * @name Getters / Setters + */ + ///@{ + /** + * @brief Get the target phase name + * @return the target phase name + */ + const string_array & getPhaseNames() const { return m_phaseNames; } + + /** + * @brief Set phases associated with liquid constraint + * @param array of phase names + */ + void setPhaseNames( const string_array & phaseNames ) { m_phaseNames=phaseNames; } + + /** + * @brief Get the phase indices + * @return array of phase indices + */ + const array1d< integer > & getPhaseIndices() const { return m_phaseIndices; } + + ///@} + /** + * @brief Struct to serve as a container for variable strings and keys. + * @struct viewKeyStruct + */ + struct viewKeyStruct + { + /// String key for the liquid rate + static constexpr char const * liquidRateString() { return "liquidRate"; } + /// String key for the phases names + static constexpr char const * phaseNamesString() { return "phaseNames"; } + }; + + // Temp interface - tjb + virtual ConstraintTypeId getControl() const override { return ConstraintTypeId::LIQUIDRATE; }; + + virtual bool checkViolation( WellConstraintBase const & currentConstraint, real64 const & currentTime ) const override; + + /** + * @brief Validate Liquid type is consistent with fluidmodel + */ + template< typename T > + void validateLiquidType( T const & fluidModel ); + +protected: + + virtual void postInputInitialization() override; + +protected: + + /// Name of the targeted phase + string_array m_phaseNames; + ///Indices of the phases defining the fluid + array1d< integer > m_phaseIndices; + +}; + +template< typename T > +void LiquidRateConstraint::validateLiquidType( T const & fluidModel ) +{ + m_phaseIndices.resize( m_phaseNames.size()); + for( size_t ip =0; ipgetWrapper< string >( viewKeyStruct::discretizationString() ). + setInputFlag( InputFlags::FALSE ); + + registerWrapper( viewKeyStruct::isThermalString(), &m_isThermal ). + setApplyDefaultValue( 0 ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Flag indicating whether the problem is thermal or not." ); + + + this->registerWrapper( viewKeyStruct::useMassFlagString(), &m_useMass ). + setApplyDefaultValue( 0 ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Use mass formulation instead of molar" ); + + this->registerWrapper( viewKeyStruct::useTotalMassEquationString(), &m_useTotalMassEquation ). + setApplyDefaultValue( 1 ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Use total mass equation" ); + + this->registerWrapper( viewKeyStruct::allowLocalCompDensChoppingString(), &m_allowCompDensChopping ). + setSizedFromParent( 0 ). + setInputFlag( InputFlags::OPTIONAL ). + setApplyDefaultValue( 1 ). + setDescription( "Flag indicating whether local (cell-wise) chopping of negative compositions is allowed" ); + + this->registerWrapper( viewKeyStruct::timeStepFromTablesFlagString(), &m_timeStepFromTables ). + setApplyDefaultValue( 0 ). + setInputFlag( dataRepository::InputFlags::OPTIONAL ). + setDescription ( "Choose time step to honor rates/bhp tables time intervals" ); + +} +Group * WellManager::createChild( string const & childKey, string const & childName ) +{ + static std::set< string > const childTypes = { + keys::compositionalMultiphaseWell, + keys::singlePhaseWell, + PhysicsSolverBase::groupKeyStruct::linearSolverParametersString(), + PhysicsSolverBase::groupKeyStruct::nonlinearSolverParametersString(), + }; + GEOS_ERROR_IF( childTypes.count( childKey ) == 0, + CatalogInterface::unknownTypeError( childKey, getDataContext(), childTypes ), + getDataContext() ); + if( childKey == keys::compositionalMultiphaseWell ) + { + setCompositional( true ); + return ®isterGroup< CompositionalMultiphaseWell >( childName ); + } + else if( childKey == keys::singlePhaseWell ) + { + setCompositional( false ); + return ®isterGroup< SinglePhaseWell >( childName ); + } + else + { + PhysicsSolverBase::createChild( childKey, childName ); + return nullptr; + } +} + +void WellManager::expandObjectCatalogs() +{ + createChild( keys::compositionalMultiphaseWell, keys::compositionalMultiphaseWell ); + createChild( keys::singlePhaseWell, keys::singlePhaseWell ); +} + +void WellManager::registerDataOnMesh( Group & meshBodies ) +{ + + //std::string const & flowSolverName = getParent().getName();//getGroup< CompositionalMultiphaseBase >().getName(); + // CompositionalMultiphaseBase const & flowSolver = getParent().getGroup< CompositionalMultiphaseBase >( getFlowSolverName() ); + + forDiscretizationOnMeshTargets( meshBodies, [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + + ElementRegionManager & elemManager = mesh.getElemManager(); + + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + + WellControls & well = getWellControls( subRegion ); + //well.setFlowSolverName( flowSolver.getName() ); + well.setThermal( isThermal() ); + well.setUseMass( m_useMass ); + well.registerWellDataOnMesh( subRegion ); + m_numFluidPhases = well.numFluidPhases(); + m_numFluidComponents = well.numFluidComponents(); + + } ); + } ); + // 1. Set key dimensions of the problem + // Empty check needed to avoid errors when running in schema generation mode. + + // 1 pressure + NC compositions + 1 connectionRate + temp if thermal + m_numDofPerWellElement = isThermal() ? m_numFluidComponents + 3 : m_numFluidComponents + 2; + // 1 pressure + NC compositions + temp if thermal + m_numDofPerResElement = isThermal() ? m_numFluidComponents + 2 : m_numFluidComponents + 1; + +} + +WellControls & WellManager::getWell( WellElementSubRegion const & subRegion ) +{ + return this->getGroup< WellControls >( subRegion.getWellControlsName()); +} +WellControls & WellManager::getWell( std::string const & wellControlsName ) +{ + return this->getGroup< WellControls >( wellControlsName ); +} + +WellControls const & WellManager::getWell( std::string const & wellControlsName ) const +{ + return this->getGroup< WellControls >( wellControlsName ); +} +void WellManager::implicitStepSetup( real64 const & time_n, + real64 const & dt, + DomainPartition & domain ) +{ + + forDiscretizationOnMeshTargets ( domain.getMeshBodies(), [&] ( string const & meshBodyName, + MeshLevel & mesh, + string_array const & regionNames ) + { + + ElementRegionManager & elemManager = mesh.getElemManager(); + + elemManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + // TODO expose a getWellControlsName() on WellElementRegion because Wrapper look-up is not useful here. + WellControls & well = getWell( + region.getReference< string >( WellElementRegion::viewKeyStruct::wellControlsString() ) ); + if( well.estimateSolution() ) + { + well.setupWellDofs( domain, region, meshBodyName, mesh ); + } + + } ) + ; + } ); + + forDiscretizationOnMeshTargets ( domain.getMeshBodies(), [&] ( string const & meshBodyName, + MeshLevel & mesh, + string_array const & regionNames ) + { + + ElementRegionManager & elemManager = mesh.getElemManager(); + + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + WellControls & well = getWell( subRegion ); + well.implicitStepSetup( time_n, dt, domain, meshBodyName, elemManager, subRegion ); + } ); + } ); +} +real64 +WellManager::setNextDt( real64 const & currentTime, const real64 & currentDt, geos::DomainPartition & domain ) +{ + + real64 nextDt = PhysicsSolverBase::setNextDt( currentTime, currentDt, domain ); + + if( m_timeStepFromTables ) + { + real64 nextDt_orig = nextDt; + real64 nextDtLocal = nextDt; + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + mesh.getElemManager().forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + + WellControls & wellControls = getWellControls( subRegion ); + real64 nextDtWell = wellControls.setNextDt( currentTime, nextDt, subRegion ); + if( nextDtWell < nextDtLocal ) + { + nextDtLocal = nextDtWell; + } + } ); + } ); + // get the minimum across all ranks + nextDt = MpiWrapper::min< real64 >( nextDtLocal ); + if( getLogLevel() > 0 && nextDt < nextDt_orig ) + GEOS_LOG_RANK_0( GEOS_FMT( "{}: next time step based on tables coordinates = {}", getName(), nextDt )); + } + + return nextDt; +} +localIndex WellManager::numDofPerWellElement() const +{ + return m_numDofPerWellElement; +} + +localIndex WellManager::numDofPerResElement() const +{ + return m_numDofPerResElement; +} +integer WellManager::isThermal() const +{ + return m_isThermal; +} + +string WellManager::wellElementDofName() const +{ + return viewKeyStruct::dofFieldString(); +} + +string WellManager::resElementDofName() const +{ + if( isCompositional() ) + return CompositionalMultiphaseBase::viewKeyStruct::elemDofFieldString(); + else + return SinglePhaseBase::viewKeyStruct::elemDofFieldString(); +} + +localIndex WellManager::numFluidComponents() const +{ + return m_numFluidComponents; +} + +localIndex WellManager::numFluidPhases() const +{ + return m_numFluidPhases; +} +WellControls & WellManager::getWellControls( WellElementSubRegion const & subRegion ) +{ + return this->getGroup< WellControls >( subRegion.getWellControlsName()); +} + +WellControls const & WellManager::getWellControls( WellElementSubRegion const & subRegion ) const +{ + return this->getGroup< WellControls >( subRegion.getWellControlsName()); +} + +CompositionalMultiphaseWell & WellManager::getCompositionalMultiphaseWell( WellElementSubRegion const & subRegion ) +{ + return this->getGroup< CompositionalMultiphaseWell >( subRegion.getWellControlsName()); +} + +CompositionalMultiphaseWell const & WellManager::getCompositionalMultiphaseWell( WellElementSubRegion const & subRegion ) const +{ + return this->getGroup< CompositionalMultiphaseWell >( subRegion.getWellControlsName()); +} +void WellManager::initializePostSubGroups() +{ + GEOS_MARK_FUNCTION; + // Validate constitutive models + if( isCompositional() ) + { + DomainPartition & domain = this->getGroupByPath< DomainPartition >( "/Problem/domain" ); + constitutive::ConstitutiveManager const & cm = domain.getConstitutiveManager(); + CompositionalMultiphaseBase const & flowSolver = getParent().getGroup< CompositionalMultiphaseBase >( getFlowSolverName() ); + string const referenceFluidName = flowSolver.referenceFluidModelName(); + constitutive::MultiFluidBase const & referenceFluid = cm.getConstitutiveRelation< constitutive::MultiFluidBase >( referenceFluidName ); + + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const &, + MeshLevel const & mesh, + string_array const & regionNames ) + { + + mesh.getElemManager().forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, + WellElementSubRegion const & subRegion ) + { + string const & fluidName = subRegion.getReference< string >( CompositionalMultiphaseWell::viewKeyStruct::fluidNamesString() ); + constitutive::MultiFluidBase const & fluid = getConstitutiveModel< constitutive::MultiFluidBase >( subRegion, fluidName ); + CompositionalMultiphaseWell * wellControls = dynamic_cast< CompositionalMultiphaseWell * >(&getWellControls ( subRegion )); + wellControls->validateFluidModel( fluid, referenceFluid ); + } ); + + } ); + } + else + { + // Single phase validation can be added here in the future + } + +} + +void WellManager::setupDofs( DomainPartition const & domain, + DofManager & dofManager ) const +{ + map< std::pair< string, string >, string_array > meshTargets; + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel const & meshLevel, + string_array const & regionNames ) + { + string_array regions; + ElementRegionManager const & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion const & region ) + { + regions.emplace_back( region.getName() ); + } ); + auto const key = std::make_pair( meshBodyName, meshLevel.getName()); + meshTargets[key] = std::move( regions ); + } ); + + dofManager.addField( wellElementDofName(), + FieldLocation::Elem, + numDofPerWellElement(), + meshTargets ); + + dofManager.addCoupling( wellElementDofName(), + wellElementDofName(), + DofManager::Connector::Node ); +} + +void WellManager::assembleSystem( real64 const time, + real64 const dt, + DomainPartition & domain, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) +{ + + + // selects constraints one of 2 ways + // wellEstimator flag set to 0 => orginal logic rates are computed during update state and constraints are selected every newton + // iteration + // wellEstimator flag > 0 => well esitmator solved for each constraint and then selects the constraint + // => estimator solve only performed first "wellEstimator" iterations + NonlinearSolverParameters const & nonlinearParams = getNonlinearSolverParameters(); + IterationsStatistics const & iterationsStatistics = getIterationStats(); + //selectWellConstraint( time, dt, solverStatistics.m_numNewtonIterations, domain ); + + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) + { + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + WellControls & wellControls = getWellControls( subRegion ); + wellControls.selectWellConstraint( time, + dt, + iterationsStatistics.getNumTimeSteps(), + nonlinearParams.m_numNewtonIterations, + domain, + meshBodyName, + meshLevel, + elementRegionManager, + subRegion, + dofManager ); + + // assemble the accumulation term in the mass balance equations + wellControls.assembleWellAccumulationTerms( time, dt, subRegion, dofManager, localMatrix, localRhs ); + if( wellControls.isWellOpen() ) + { + // assemble the pressure relations between well elements + wellControls.assembleWellPressureRelations( time, dt, subRegion, dofManager, localMatrix, localRhs ); + // assemble well constraint terms + wellControls.assembleWellConstraintTerms( time, dt, subRegion, dofManager, localMatrix.toViewConstSizes(), localRhs ); + // compute the perforation rates (later assembled by the coupled solver) + wellControls.computeWellPerforationRates( time, dt, elementRegionManager, subRegion ); + // assemble the flux terms in the mass balance equations + wellControls.assembleWellFluxTerms( time, dt, subRegion, dofManager, localMatrix, localRhs ); + } + } ); + } ); + +} + + +void WellManager::resetStateToBeginningOfStep( DomainPartition & domain ) +{ + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const & meshBodyName, + MeshLevel & mesh, + string_array const & regionNames ) + { + + ElementRegionManager & elemManager = mesh.getElemManager(); + + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + WellControls & wellControls = getWellControls( subRegion ); + wellControls.resetStateToBeginningOfStep( domain, meshBodyName, elemManager, subRegion ); + + + } ); + } ); +} + +void WellManager::implicitStepComplete( real64 const & time, + real64 const & dt, + DomainPartition & domain ) +{ + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + + ElementRegionManager & elemManager = mesh.getElemManager(); + + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + WellControls & wellControls = getWellControls( subRegion ); + wellControls.implicitStepComplete( time, dt, subRegion ); + } ); + } ); +} + +void WellManager::postRestartInitialization() +{} +void WellManager::initializePostInitialConditionsPreSubGroups() +{ + PhysicsSolverBase::initializePostInitialConditionsPreSubGroups(); + DomainPartition & domain = this->getGroupByPath< DomainPartition >( "/Problem/domain" ); + forDiscretizationOnMeshTargets ( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + + // loop over the wells + mesh.getElemManager().forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + // reconstruct local connectivity needed for flux calculations + subRegion.reconstructLocalConnectivity(); + WellControls & wellControls = getWellControls( subRegion ); + wellControls.initializeWellPostInitialConditionsPreSubGroups( subRegion ); + + + } ); + } ); +} +void WellManager::setKeepVariablesConstantDuringInitStep( bool const keepVariablesConstantDuringInitStep ) +{ + DomainPartition & domain = this->getGroupByPath< DomainPartition >( "/Problem/domain" ); + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + // loop over the wells + mesh.getElemManager().forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, + WellElementSubRegion & subRegion ) + + { + WellControls & wellControls = getWellControls( subRegion ); + wellControls.setKeepVariablesConstantDuringInitStep( keepVariablesConstantDuringInitStep ); + + } ); + } ); +} +void WellManager::updateState( DomainPartition & domain ) +{ + GEOS_MARK_FUNCTION; + + real64 maxPhaseVolFrac = 0.0; + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & mesh, + string_array const & regionNames ) + { + ElementRegionManager & elemManager = mesh.getElemManager(); + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + WellControls & wellControls = getWellControls( subRegion ); + if( wellControls.getWellState()) + { + + real64 const maxRegionPhaseVolFrac = wellControls.updateWellState( domain.getMeshBody( meshBodyName ), elemManager, subRegion ); + + maxPhaseVolFrac = LvArray::math::max( maxRegionPhaseVolFrac, maxPhaseVolFrac ); + } + } ); + } ); + maxPhaseVolFrac = MpiWrapper::max( maxPhaseVolFrac ); + + GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, + GEOS_FMT( " {}: Max well phase volume fraction change = {}", + getName(), fmt::format( "{:.{}f}", maxPhaseVolFrac, 4 ) ) ); + +} + +real64 +WellManager::calculateResidualNorm( real64 const & time_n, + real64 const & dt, + DomainPartition const & domain, + DofManager const & dofManager, + arrayView1d< real64 const > const & localRhs ) +{ + GEOS_MARK_FUNCTION; + + integer numNorm = 1; // mass balance + array1d< real64 > localResidualNorm, wellResidualNorm; + array1d< real64 > localResidualNormalizer; + + if( isThermal() ) + { + numNorm = 2; // mass balance and energy balance + } + localResidualNorm.resize( numNorm ); + + localResidualNormalizer.resize( numNorm ); + + string const wellDofKey = dofManager.getKey( wellElementDofName() ); + + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel const & mesh, + string_array const & regionNames ) + { + + + ElementRegionManager const & elemManager = mesh.getElemManager(); + + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion const & subRegion ) + { + + WellControls & wellControls = getWellControls( subRegion ); + + // step 1: compute the norm in the subRegion + if( wellControls.isWellOpen( ) ) + { + wellResidualNorm = wellControls.calculateLocalWellResidualNorm( time_n, + dt, + m_nonlinearSolverParameters, + subRegion, + dofManager, + localRhs ); + for( integer i=0; i localResidualNorm[i] ) + { + localResidualNorm[i] = wellResidualNorm[i]; + } + } + } + else + { + for( integer i=0; i const & localSolution ) +{ + GEOS_MARK_FUNCTION; + + string const wellDofKey = dofManager.getKey( wellElementDofName() ); + + real64 scalingFactor = 1.0; + real64 localScalingFactor = 1.0; + if( isCompositional() ) + { + + + real64 maxDeltaPres = 0.0, maxDeltaCompDens = 0.0, maxDeltaTemp = 0.0; + real64 minPresScalingFactor = 1.0, minCompDensScalingFactor = 1.0, minTempScalingFactor = 1.0; + real64 localMaxDeltaPres = 0.0, localMaxDeltaCompDens = 0.0, localMaxDeltaTemp = 0.0; + real64 localMinPresScalingFactor = 1.0, localMinCompDensScalingFactor = 1.0, localMinTempScalingFactor = 1.0; + + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + + ElementRegionManager & elemManager = mesh.getElemManager(); + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + + { + CompositionalMultiphaseWell * wellControls = dynamic_cast< CompositionalMultiphaseWell * >(&getWellControls ( subRegion )); + localScalingFactor = wellControls->scalingForLocalSystemSolution( subRegion, + dofManager, + localMaxDeltaPres, + localMaxDeltaCompDens, + localMaxDeltaTemp, + localMinPresScalingFactor, + localMinCompDensScalingFactor, + localMinTempScalingFactor, + localSolution ); + maxDeltaPres = LvArray::math::max( localMaxDeltaPres, maxDeltaPres ); + maxDeltaCompDens = LvArray::math::max( localMaxDeltaCompDens, maxDeltaCompDens ); + maxDeltaTemp = LvArray::math::max( localMaxDeltaTemp, maxDeltaTemp ); + minPresScalingFactor = LvArray::math::min( localMinPresScalingFactor, minPresScalingFactor ); + minCompDensScalingFactor = LvArray::math::min( localMinCompDensScalingFactor, minCompDensScalingFactor ); + minTempScalingFactor = LvArray::math::min( localMinTempScalingFactor, minTempScalingFactor ); + scalingFactor = LvArray::math::min( localScalingFactor, scalingFactor ); + + } ); + } ); + + scalingFactor = MpiWrapper::min( scalingFactor ); + maxDeltaPres = MpiWrapper::max( maxDeltaPres ); + maxDeltaCompDens = MpiWrapper::max( maxDeltaCompDens ); + minPresScalingFactor = MpiWrapper::min( minPresScalingFactor ); + minCompDensScalingFactor = MpiWrapper::min( minCompDensScalingFactor ); + + string const massUnit = m_useMass ? "kg/m3" : "mol/m3"; + GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, + GEOS_FMT( " {}: Max well pressure change: {} Pa (before scaling)", + getName(), GEOS_FMT( "{:.{}f}", maxDeltaPres, 3 ) ) ); + GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, + GEOS_FMT( " {}: Max well component density change: {} {} (before scaling)", + getName(), GEOS_FMT( "{:.{}f}", maxDeltaCompDens, 3 ), massUnit ) ); + + if( m_isThermal ) + { + maxDeltaTemp = MpiWrapper::max( maxDeltaTemp ); + minTempScalingFactor = MpiWrapper::min( minTempScalingFactor ); + GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, + GEOS_FMT( " {}: Max well temperature change: {} K (before scaling)", + getName(), GEOS_FMT( "{:.{}f}", maxDeltaTemp, 3 ) ) ); + } + + + GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, + GEOS_FMT( " {}: Min well pressure scaling factor: {}", + getName(), minPresScalingFactor ) ); + GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, + GEOS_FMT( " {}: Min well component density scaling factor: {}", + getName(), minCompDensScalingFactor ) ); + if( m_isThermal ) + { + GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, + GEOS_FMT( " {}: Min well temperature scaling factor: {}", + getName(), minTempScalingFactor ) ); + } + + } + else + { + // Single phase well scaling- not implemented yet + scalingFactor=1.0; + } + return LvArray::math::max( scalingFactor, m_minScalingFactor ); + +} + +bool +WellManager::checkSystemSolution( DomainPartition & domain, + DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution, + real64 const scalingFactor ) +{ + GEOS_MARK_FUNCTION; + + integer globalCheck = 1; + + real64 minPressure = 0.0, minDensity = 0.0, minTotalDensity = 0.0; + + bool const solutionLogActive = isLogLevelActive< logInfo::Solution >( getLogLevel() ); + bool const solutionDetailsLogActive = isLogLevelActive< logInfo::SolutionDetails >( getLogLevel() ); + ElementsReporterBuffer rankNegPressureIds{ solutionLogActive, solutionDetailsLogActive ? 16 : 0 }; + ElementsReporterBuffer rankNegDensityIds{ solutionLogActive, solutionDetailsLogActive ? 16 : 0 }; + // output only total density sum, not cell details + ElementsReporterBuffer rankTotalNegDensityIds{ solutionLogActive, 0 }; + + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + + ElementRegionManager & elemManager = mesh.getElemManager(); + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + + { + WellControls & wellControls = getWellControls( subRegion ); + integer localCheck = wellControls.checkWellSystemSolution( subRegion, + dofManager, + localSolution, + scalingFactor, + minPressure, + minDensity, + minTotalDensity, + rankNegPressureIds, + rankNegDensityIds, + rankTotalNegDensityIds ); + globalCheck = std::min( localCheck, globalCheck ); + } ); + } ); + globalCheck = MpiWrapper::min( globalCheck ); + minPressure = MpiWrapper::min( minPressure ); + minDensity = MpiWrapper::min( minDensity ); + minTotalDensity = MpiWrapper::min( minTotalDensity ); + + units::Unit const massUnit = m_useMass ? units::Unit::Density : units::Unit::MolarDensity; + rankNegPressureIds.createOutput() + .outputTooLowValues( GEOS_FMT( " {}: ", getName() ), + "negative pressure", minPressure, units::Unit::Pressure ); + rankNegDensityIds.createOutput() + .outputTooLowValues( GEOS_FMT( " {}: ", getName() ), + "negative component density", minDensity, massUnit ); + rankTotalNegDensityIds.createOutput() + .outputTooLowValues( GEOS_FMT( " {}: ", getName() ), + "negative components total density", minTotalDensity, massUnit ); + + return globalCheck; +} + +void +WellManager::applySystemSolution( DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution, + real64 const scalingFactor, + real64 const dt, + DomainPartition & domain ) +{ + + + DofManager::CompMask pressureMask( m_numDofPerWellElement, 0, 1 ); + + DofManager::CompMask connRateMask( m_numDofPerWellElement, numFluidComponents()+1, numFluidComponents()+2 ); + GEOS_UNUSED_VAR( dt ); + // update all the fields using the global damping coefficients + dofManager.addVectorToField( localSolution, + wellElementDofName(), + well::pressure::key(), + scalingFactor, + pressureMask ); + + dofManager.addVectorToField( localSolution, + wellElementDofName(), + well::connectionRate::key(), + scalingFactor, + connRateMask ); + if( isCompositional()) + { + DofManager::CompMask componentMask( m_numDofPerWellElement, 1, numFluidComponents()+1 ); + dofManager.addVectorToField( localSolution, + wellElementDofName(), + well::globalCompDensity::key(), + scalingFactor, + componentMask ); + + } + if( isThermal() ) + { + DofManager::CompMask temperatureMask( m_numDofPerWellElement, numFluidComponents()+2, numFluidComponents()+3 ); + + dofManager.addVectorToField( localSolution, + wellElementDofName(), + well::temperature::key(), + scalingFactor, + temperatureMask ); + + } + // if component density chopping is allowed, some component densities may be negative after the update + // these negative component densities are set to zero in this function + if( isCompositional() && m_allowCompDensChopping ) + { + chopNegativeDensities( domain ); + } + + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + stdVector< string > propNames; + propNames.emplace_back( well::pressure::key() ); + + propNames.emplace_back( well::connectionRate::key() ); + if( isCompositional()) + { + propNames.emplace_back( well::globalCompDensity::key() ); + } + if( isThermal() ) + { + propNames.emplace_back( well::temperature::key() ); + } + // synchronize + FieldIdentifiers fieldsToBeSync; + + fieldsToBeSync.addElementFields( propNames, + regionNames ); + + + CommunicationTools::getInstance().synchronizeFields( fieldsToBeSync, + mesh, + domain.getNeighbors(), + true ); + } ); + +} + +void WellManager::chopNegativeDensities( DomainPartition & domain ) +{ + integer const numComp = m_numFluidComponents; + + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + + ElementRegionManager & elemManager = mesh.getElemManager(); + + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, + [&]( localIndex const, + WellElementSubRegion & subRegion ) + { + arrayView1d< integer const > const & wellElemGhostRank = subRegion.ghostRank(); + + arrayView2d< real64, compflow::USD_COMP > const & wellElemCompDens = + subRegion.getField< well::globalCompDensity >(); + + forAll< parallelDevicePolicy<> >( subRegion.size(), [=] GEOS_HOST_DEVICE ( localIndex const iwelem ) + { + if( wellElemGhostRank[iwelem] < 0 ) + { + for( integer ic = 0; ic < numComp; ++ic ) + { + // we allowed for some densities to be slightly negative in CheckSystemSolution + // if the new density is negative, chop back to zero + if( wellElemCompDens[iwelem][ic] < 0 ) + { + wellElemCompDens[iwelem][ic] = 0; + } + } + } + } ); + } ); + + } ); +} + +REGISTER_CATALOG_ENTRY( PhysicsSolverBase, WellManager, string const &, Group * const ) +} // namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellManager.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellManager.hpp new file mode 100644 index 00000000000..27acb8eb5c9 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellManager.hpp @@ -0,0 +1,474 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellManager.hpp + */ + +#ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELL_MANAGER_HPP_ +#define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELL_MANAGER_HPP_ + +#include "physicsSolvers/PhysicsSolverBase.hpp" +#include "physicsSolvers/fluidFlow/SinglePhaseBase.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseBase.hpp" +#include "physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.hpp" +#include "physicsSolvers/fluidFlow/wells/SinglePhaseWell.hpp" +namespace geos +{ + +class DomainPartition; +class WellControls; +class WellElementSubRegion; + +namespace dataRepository +{ +namespace keys +{ +static constexpr auto compositionalMultiphaseWell = "CompositionalMultiphaseWell"; +static constexpr auto singlePhaseWell = "SinglePhaseWell"; +} +} +/** + * @class WellManager + * + * Base class for well solvers. + * Provides some common features + */ +class WellManager : public PhysicsSolverBase +{ +public: + + /// String used to form the solverName used to register single-physics solvers in CoupledSolver + static string coupledSolverAttributePrefix() { return "well"; } + + /** + * @brief main constructor for Group Objects + * @param name the name of this instantiation of Group in the repository + * @param parent the parent group of this instantiation of Group + */ + WellManager( const string & name, + Group * const parent ); + + /// default destructor + virtual ~WellManager() override = default; + + /// deleted default constructor + WellManager() = delete; + + /// deleted copy constructor + WellManager( WellManager const & ) = delete; + + /// default move constructor + WellManager( WellManager && ) = default; + + /// deleted assignment operator + WellManager & operator=( WellManager const & ) = delete; + + /// deleted move operator + WellManager & operator=( WellManager && ) = delete; + + virtual Group * createChild( string const & childKey, string const & childName ) override; + + /// Expand catalog for schema generation + virtual void expandObjectCatalogs() override; + + /** + * @brief setter for the name of the flow solver (needed to use the flow kernels like UpdateFluid) + * @param name the name of the flow solver + */ + void setFlowSolverName( string const & name ) { m_flowSolverName = name; } + + /** + * @brief setter for compositional flag + * @param compositional the compositional flag + */ + void setCompositional( bool const & isCompositional ) { m_isCompositional = isCompositional; } + + /** + * @brief getter for compositional flag + * @return the compositional flag + */ + bool isCompositional() const { return m_isCompositional; } + + + /** + * @brief getter for the name of the flow solver (used in UpdateState) + * @return a string containing the name of the flow solver + */ + string const & getFlowSolverName() const { return m_flowSolverName; } + + + /** + * @brief name of the node manager in the object catalog + * @return string that contains the catalog name to generate a new NodeManager object through the object catalog. + */ + static string catalogName() { return "WellManager"; } + /** + * @copydoc PhysicsSolverBase::getCatalogName() + */ + string getCatalogName() const override { return catalogName(); } + + virtual void registerDataOnMesh( Group & meshBodies ) override; + /** + * @brief Get a well solver for a given well element sub-region + * @param subRegion the well subRegion whose well solver is requested + * @return a reference to the well solver + */ + WellControls & getWell( WellElementSubRegion const & subRegion ); + + /** + * @brief Get a well solver for a given well element sub-region + * @param wellControlsName name of well + * @return a reference to the well solver + */ + WellControls & getWell( std::string const & wellControlsName ); + + /** + * @brief Get a well solver for a given well element sub-region + * @param wellControlsName name of well + * @return a reference to the well solver + */ + WellControls const & getWell( std::string const & wellControlsName ) const; +/** + * @brief get the name of DOF defined on well elements + * @return name of the DOF field used by derived solver type + */ + string wellElementDofName() const; + + struct viewKeyStruct : PhysicsSolverBase::viewKeyStruct + { + static constexpr char const * dofFieldString() { return "wellVars"; } + static constexpr char const * isThermalString() { return "isThermal"; } + static constexpr char const * useMassFlagString() {return "useMass"; } + /// @return string for the nextDt targetRegions wrapper + static constexpr char const * targetRegionsString() { return "targetRegions"; } + static constexpr char const * timeStepFromTablesFlagString() { return "timeStepFromTables"; } + static constexpr char const * useTotalMassEquationString() { return "useTotalMassEquation"; } + static constexpr char const * allowLocalCompDensChoppingString() { return CompositionalMultiphaseBase::viewKeyStruct::allowLocalCompDensChoppingString(); } + + + }; + + /** + * @brief getter for the number of degrees of freedom per well element + * @return the number of dofs + */ + localIndex numDofPerWellElement() const; + + /** + * @brief getter for the number of degrees of freedom per mesh element + * @return the number of dofs + */ + localIndex numDofPerResElement() const; + + /** + * @brief getter for iso/thermal switch + * @return True if thermal + */ + integer isThermal() const; + + + /** + * @brief get the name of DOF defined on well elements + * @return name of the DOF field used by derived solver type + */ + virtual string resElementDofName() const; + + /** + * @brief const getter for the number of fluid components + * @return the number of fluid components + */ + virtual localIndex numFluidComponents() const; + + /** + * @brief const getter for the number of fluid phases + * @return the number of fluid phases + */ + virtual localIndex numFluidPhases() const; + + /** + * @brief const getter for well total mass equation usage + * @return true if total mass equation is used + */ + integer useTotalMassEquation() const { return m_useTotalMassEquation; } + + /** + * @brief getter for the well controls associated to this well subRegion + * @param subRegion the well subRegion whose controls are requested + * @return a reference to the controls + */ + WellControls & getWellControls( WellElementSubRegion const & subRegion ); + + /** + * @brief const getter for the well controls associated to this well subRegion + * @param subRegion the well subRegion whose controls are requested + * @return a reference to the const controls + */ + WellControls const & getWellControls( WellElementSubRegion const & subRegion ) const; + + /** + * @brief getter for the compositional multiphase well associated to this well subRegion + * @param subRegion the well subRegion whose controls are requested + * @return a reference to the well + */ + CompositionalMultiphaseWell & getCompositionalMultiphaseWell( WellElementSubRegion const & subRegion ); + + /** + * @brief const getter for the compositional multiphase well associated to this well subRegion + * @param subRegion the well subRegion whose controls are requested + * @return a reference to the const well + */ + CompositionalMultiphaseWell const & getCompositionalMultiphaseWell( WellElementSubRegion const & subRegion ) const; + + /** + * @brief Selects the active well constraint based on current conditions + * @param[in] currentTime the current time + * @param[in] currentDt the current time step size + * @param[in] coupledIterationNumber the current coupled iteration number + * @param[in] domain the domain object + * @return the prescribed time step size + */ + void selectWellConstraint( real64 const & time_n, + real64 const & dt, + integer const coupledIterationNumber, + DomainPartition & domain ); + /* PhysicsSolverBase interfaces */ + + /** + * @brief function to set the next time step size + * @param[in] currentTime the current time + * @param[in] currentDt the current time step size + * @param[in] domain the domain object + * @return the prescribed time step size + */ + virtual real64 setNextDt( real64 const & currentTime, + real64 const & currentDt, + DomainPartition & domain ) override; + + virtual void setupDofs( DomainPartition const & domain, + DofManager & dofManager ) const override; + + /** + * @brief function to perform setup for implicit timestep + * @param time_n the time at the beginning of the step + * @param dt the desired timestep + * @param domain the domain partition + * + * This function should contain any step level initialization required to perform an implicit + * step. + * + * @note This function must be overridden in the derived physics solver in order to use an implict + * solution method such as LinearImplicitStep() or NonlinearImplicitStep(). + */ + virtual void + implicitStepSetup( real64 const & time_n, + real64 const & dt, + DomainPartition & domain ) override; + + + /** + * @brief function to assemble the linear system matrix and rhs + * @param time the time at the beginning of the step + * @param dt the desired timestep + * @param domain the domain partition + * @param dofManager degree-of-freedom manager associated with the linear system + * @param localMatrix the system matrix + * @param localRhs the system right-hand side vector + * + * This function assembles the residual and the jacobian of the residual wrt the primary + * variables. In a stand alone physics solver, this function will fill a single block in the + * block system. However the capability to query the block system structure for any coupled blocks + * may be implemented to fill in off diagonal blocks of the system to enable coupling between + * solvers. + * + * @note This function must be overridden in the derived physics solver in order to use an implict + * solution method such as LinearImplicitStep() or NonlinearImplicitStep(). + */ + virtual void + assembleSystem( real64 const time, + real64 const dt, + DomainPartition & domain, + DofManager const & dofManager, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) override; + + + virtual void + resetStateToBeginningOfStep( DomainPartition & domain ) override; + + virtual void + implicitStepComplete( real64 const & time, + real64 const & dt, + DomainPartition & domain ) override; + + virtual void applyBoundaryConditions( real64 const GEOS_UNUSED_PARAM( time_n ), + real64 const GEOS_UNUSED_PARAM( dt ), + DomainPartition & GEOS_UNUSED_PARAM( domain ), + DofManager const & GEOS_UNUSED_PARAM( dofManager ), + CRSMatrixView< real64, globalIndex const > const & GEOS_UNUSED_PARAM( localMatrix ), + arrayView1d< real64 > const & GEOS_UNUSED_PARAM( localRhs ) ) override {} + + /** + * @brief calculate the norm of the global system residual + * @param time the time at the beginning of the step + * @param dt the desired timestep + * @param domain the domain partition + * @param dofManager degree-of-freedom manager associated with the linear system + * @param localRhs the system right-hand side vector + * @return norm of the residual + * + * This function returns the norm of global residual vector, which is suitable for comparison with + * a tolerance. + */ + virtual real64 + calculateResidualNorm( real64 const & time, + real64 const & dt, + DomainPartition const & domain, + DofManager const & dofManager, + arrayView1d< real64 const > const & localRhs ) override; + /** + * @brief Recompute all dependent quantities from primary variables (including constitutive models) + * @param domain the domain containing the mesh and fields + */ + virtual void updateState( DomainPartition & domain ) override; + + /** + * @brief Function to determine if the solution vector should be scaled back in order to maintain a known constraint. + * @param[in] domain The domain partition. + * @param[in] dofManager degree-of-freedom manager associated with the linear system + * @param[in] localSolution the solution vector + * @return The factor that should be used to scale the solution vector values when they are being applied. + */ + virtual real64 + scalingForSystemSolution( DomainPartition & domain, + DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution )override; + + /** + * @brief Function to check system solution for physical consistency and constraint violation + * @param domain the domain partition + * @param dofManager degree-of-freedom manager associated with the linear system + * @param localSolution the solution vector + * @param scalingFactor factor to scale the solution prior to application + * @return true if solution can be safely applied without violating physical constraints, false otherwise + * + * @note This function must be overridden in the derived physics solver in order to use an implict + * solution method such as LinearImplicitStep() or NonlinearImplicitStep(). + * + */ + virtual bool + checkSystemSolution( DomainPartition & domain, + DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution, + real64 const scalingFactor ) override; + + /** + * @brief Function to apply the solution vector to the state + * @param dofManager degree-of-freedom manager associated with the linear system + * @param localSolution the solution vector + * @param scalingFactor factor to scale the solution prior to application + * @param dt the timestep + * @param domain the domain partition + * + * This function performs 2 operations: + * 1) extract the solution vector for the "blockSystem" parameter, and applies the + * contents of the solution vector to the primary variable field data, + * 2) perform a synchronization of the primary field variable such that all ghosts are updated, + * + * The "scalingFactor" parameter allows for the scaled application of the solution vector. For + * instance, a line search may apply a negative scaling factor to remove part of the previously + * applied solution. + * + * @note This function must be overridden in the derived physics solver in order to use an implict + * solution method such as LinearImplicitStep() or NonlinearImplicitStep(). + * + */ + virtual void + applySystemSolution( DofManager const & dofManager, + arrayView1d< real64 const > const & localSolution, + real64 const scalingFactor, + real64 const dt, + DomainPartition & domain ) override; + + /** + * @brief Sets all the negative component densities (if any) to zero. + * @param domain the physical domain object + */ + void chopNegativeDensities( DomainPartition & domain ); + + /** + * @brief Utility function to keep the well variables during a time step (used in + * poromechanics simulations) + * @param[in] keepVariablesConstantDuringInitStep flag to tell the solver to freeze its + * primary variables during a time step + * @detail This function is meant to be called by a specific task before/after the + * initialization step + */ + void setKeepVariablesConstantDuringInitStep( bool const keepVariablesConstantDuringInitStep ); + + +protected: + //virtual void postInputInitialization() override; + + virtual void initializePostSubGroups() override; + + virtual void initializePostInitialConditionsPreSubGroups() override; + + virtual void postRestartInitialization() override final; + + +private: + + /// name of the flow solver + string m_flowSolverName; + + /// flag indicating whether mass or molar formulation should be used + integer m_useMass; + + /// flag indicating whether total mass equation should be used + integer m_useTotalMassEquation; + + /// flag indicating whether thermal formulation is used + integer m_isThermal; + + /// flag indicating whether compositional formulation is used + bool m_isCompositional; + + + /// number of phases + integer m_numFluidPhases; + + /// number of components + integer m_numFluidComponents; + + /// number of degrees of freedom per well element + integer m_numDofPerWellElement; + + /// number of degrees of freedom per reservoir element + integer m_numDofPerResElement; + + /// minimum value of the scaling factor obtained by enforcing maxCompFracChange + real64 m_minScalingFactor; + + /// flag indicating whether local (cell-wise) chopping of negative compositions is allowed + integer m_allowCompDensChopping; + + // flag to enable time step selection base on rates/bhp tables coordinates + integer m_timeStepFromTables; +}; + +} + +#endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELL_MANAGER_HPP_ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellMassRateConstraint.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellMassRateConstraint.cpp new file mode 100644 index 00000000000..0540818bb2d --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellMassRateConstraint.cpp @@ -0,0 +1,75 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellMassRateConstraints.cpp + */ + +#include "LogLevelsInfo.hpp" +#include "WellMassRateConstraint.hpp" +#include "WellConstants.hpp" +#include "dataRepository/InputFlags.hpp" +#include "functions/FunctionManager.hpp" + +namespace geos +{ + +using namespace dataRepository; + +MassRateConstraint::MassRateConstraint( string const & name, Group * const parent ) + : WellConstraintBase( name, parent ) +{ + setInputFlags( InputFlags::OPTIONAL_NONUNIQUE ); + + registerWrapper( viewKeyStruct::massRateString(), &m_constraintValue ). + setDefaultValue( 0.0 ). + setInputFlag( InputFlags::OPTIONAL ). + setRestartFlags( RestartFlags::WRITE_AND_READ ). + setDescription( "Maximum mass rate (kg/s)" ); +} + +MassRateConstraint::~MassRateConstraint() +{} + + +void MassRateConstraint::postInputInitialization() +{ + // Validate table options + WellConstraintBase::postInputInitialization(); + + // check constraint value + GEOS_THROW_IF( m_constraintValue < 0, + getWrapperDataContext( viewKeyStruct::massRateString() ) << ": Target value is negative", + InputError ); + + GEOS_THROW_IF ((m_constraintValue <= 0.0 && m_constraintScheduleTableName.empty()), + getName() << " " << getDataContext() << ": You need to specify a mass rate constraint. \n" << + "The rate constraint can be specified using " << + "either " << viewKeyStruct::massRateString() << + " or " << WellConstraintBase::viewKeyStruct::constraintScheduleTableNameString(), + InputError ); +} + + +bool MassRateConstraint::checkViolation( WellConstraintBase const & currentConstraint, real64 const & currentTime )const +{ + // isViolated is defined as a static method on the specific WellConstraintType (Injection/Production) + // Evaluate violation according to the sign set for injectors/producers + real64 const currentValue = currentConstraint.massRate(); + real64 const constraintValue = this->getConstraintValue( currentTime ); + return ( LvArray::math::abs( currentValue ) > LvArray::math::abs( constraintValue ) ); + +} +} //namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellMassRateConstraint.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellMassRateConstraint.hpp new file mode 100644 index 00000000000..6cd6703ba36 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellMassRateConstraint.hpp @@ -0,0 +1,120 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellMassRateConstraint.hpp + */ + + +#ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLMASSRATECONSTRAINT_HPP +#define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLMASSRATECONSTRAINT_HPP + +#include "common/format/EnumStrings.hpp" +#include "dataRepository/Group.hpp" +#include "functions/TableFunction.hpp" +#include "WellConstraintsBase.hpp" +namespace geos +{ + +/** + * @class MassRateConstraint + * @brief This class describes a mass rate constraint used to control a well. + */ + +class MassRateConstraint : public WellConstraintBase +{ +public: + + /** + * @name Constructor / Destructor + */ + ///@{ + + /** + * @brief Constructor for WellControls Objects. + * @param[in] name the name of this instantiation of WellControls in the repository + * @param[in] parent the parent group of this instantiation of WellControls + */ + explicit MassRateConstraint( string const & name, dataRepository::Group * const parent ); + + + /** + * @brief Default destructor. + */ + ~MassRateConstraint() override; + + /** + * @brief Deleted default constructor. + */ + MassRateConstraint() = delete; + + /** + * @brief Deleted copy constructor. + */ + MassRateConstraint( MassRateConstraint const & ) = delete; + + /** + * @brief Deleted move constructor. + */ + MassRateConstraint( MassRateConstraint && ) = delete; + + /** + * @brief Deleted assignment operator. + * @return a reference to a constraint object + */ + MassRateConstraint & operator=( MassRateConstraint const & ) = delete; + + /** + * @brief Deleted move operator. + * @return a reference to a constraint object + */ + MassRateConstraint & operator=( MassRateConstraint && ) = delete; + + /** + * @brief name of the node manager in the object catalog + * @return string that contains the catalog name to generate a new Constraint object through the object catalog. + */ + static string catalogName() + { + return "MassRateConstraint"; + } + ///@} + + struct viewKeyStruct + { + /// String key for the well target rate + static constexpr char const * massRateString() { return "massRate"; } + }; + + /** + * @name Getters / Setters + */ + + // Temp interface - tjb + virtual ConstraintTypeId getControl() const override { return ConstraintTypeId::MASSRATE; }; + ///@} + + virtual bool checkViolation( WellConstraintBase const & currentConstraint, real64 const & currentTime ) const override; + +protected: + + virtual void postInputInitialization() override; + +}; + + +} //namespace geos + +#endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLMASSRATECONSTRAINT_HPP diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellNewtonSolver.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellNewtonSolver.cpp new file mode 100644 index 00000000000..06538248762 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellNewtonSolver.cpp @@ -0,0 +1,514 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 "WellNewtonSolver.hpp" + +#include "common/MpiWrapper.hpp" +#include "codingUtilities/RTTypes.hpp" +#include "common/format/EnumStrings.hpp" +#include "dataRepository/Group.hpp" +#include "physicsSolvers/LogLevelsInfo.hpp" +#include "common/format/LogPart.hpp" +#include "common/TimingMacros.hpp" +#include "linearAlgebra/solvers/KrylovSolver.hpp" +#include "mesh/DomainPartition.hpp" +#include "math/interpolation/Interpolation.hpp" +#include "common/Timer.hpp" +#include "common/Units.hpp" + + +namespace geos +{ + +using namespace dataRepository; + +WellNewtonSolver::WellNewtonSolver( string const & name, + Group * const parent ) + : + dataRepository::Group( name, parent ), + + m_dofManager( name ), + m_usePhysicsScaling( 1 ), + m_linearSolverParameters( groupKeyStruct::linearSolverParametersString(), this ), + m_nonlinearSolverParameters( groupKeyStruct::nonlinearSolverParametersString(), this ), + m_solverStatistics( groupKeyStruct::solverStatisticsString(), this ), + m_systemSetupTimestamp( 0 ), + m_activeCoupledIterations( 1 ), + m_enableIsoThermalEstimator( 0 ) +{ + setInputFlags( InputFlags::OPTIONAL_NONUNIQUE ); + + this->registerWrapper( viewKeyStruct::activeCoupledIterationsString(), &m_activeCoupledIterations ). + setApplyDefaultValue( 1 ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Number of coupled iterations to activate estimator solve." ); + + registerWrapper( viewKeyStruct::enableIsoThermalEstimatorString(), &m_enableIsoThermalEstimator ). + setDefaultValue( 0 ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Estimator configuration option to disable thermal effects on initial well constraint solve and then converge solution with thermal effects enabled: \n" + " - If the flag is set to 1, thermal effects are enabled during the initial constraint solve. \n" + " - If the flag is set to 0, thermal effects are disabled during the initial constraint solve." ); + + + + registerWrapper( viewKeyStruct::writeLinearSystemString(), &m_writeLinearSystem ). + setApplyDefaultValue( 0 ). + setInputFlag( InputFlags::OPTIONAL ). + setRestartFlags( RestartFlags::WRITE_AND_READ ). + setDescription( "Write matrix, rhs, solution to screen ( = 1) or file ( = 2)." ); + + registerWrapper( viewKeyStruct::allowNonConvergedLinearSolverSolutionString(), &m_allowNonConvergedLinearSolverSolution ). + setApplyDefaultValue( 1 ). + setInputFlag( InputFlags::OPTIONAL ). + setRestartFlags( RestartFlags::WRITE_AND_READ ). + setDescription( "Cut time step if linear solution fail without going until max nonlinear iterations." ); + + registerWrapper( viewKeyStruct::usePhysicsScalingString(), &m_usePhysicsScaling ). + setApplyDefaultValue( 1 ). + setInputFlag( InputFlags::OPTIONAL ). + setDescription( "Enable physics-based scaling of the linear system. Default: true." ); + + + registerWrapper( viewKeyStruct::writeStatisticsCSVString(), &m_writeStatisticsCSV ). + setApplyDefaultValue( StatsOutputType::none ). + setInputFlag( InputFlags::OPTIONAL ). + setRestartFlags( RestartFlags::NO_WRITE ). + setDescription( GEOS_FMT( "When set to `{}`, output iterations information to a csv\n" + "When set to `{}`, output convergence information to a csv\n" + "When set to `{}` output both convergence & iteration information to a csv.", + EnumStrings< StatsOutputType >::toString( StatsOutputType::iteration ), + EnumStrings< StatsOutputType >::toString( StatsOutputType::convergence ), + EnumStrings< StatsOutputType >::toString( StatsOutputType::all ) )); + + addLogLevel< logInfo::Convergence >(); + addLogLevel< logInfo::Fields >(); + addLogLevel< logInfo::LinearSolver >(); + addLogLevel< logInfo::ResidualNorm >(); + addLogLevel< logInfo::Solution >(); + addLogLevel< logInfo::TimeStep >(); + addLogLevel< logInfo::Timers >(); + + registerGroup( groupKeyStruct::linearSolverParametersString(), &m_linearSolverParameters ); + registerGroup( groupKeyStruct::nonlinearSolverParametersString(), &m_nonlinearSolverParameters ); + registerGroup( groupKeyStruct::solverStatisticsString(), &m_solverStatistics ); + + m_localMatrix.setName( this->getName() + "/localMatrix" ); + m_matrix.setDofManager( &m_dofManager ); +} + +void WellNewtonSolver::postInputInitialization() +{ + m_solverStatistics.setOutputFilesName( getName() ); + + m_solverStatistics.makeDir( m_writeStatisticsCSV != StatsOutputType::none ); + + getIterationStats().setTableName( getName() ); + getIterationStats().setLogOutputRequest( true ); + getIterationStats().setCSVOutputRequest( m_writeStatisticsCSV == StatsOutputType::iteration || + m_writeStatisticsCSV == StatsOutputType::all ); + getConvergenceStats().setCSVOutputRequest( m_writeStatisticsCSV == StatsOutputType::convergence || + m_writeStatisticsCSV == StatsOutputType::all ); +} + +WellNewtonSolver::~WellNewtonSolver() = default; + +void WellNewtonSolver::generateMeshTargetsFromTargetRegions( Group const & meshBodies ) +{ + for( auto const & target : m_targetRegionNames ) + { + + stdVector< string > targetTokens = stringutilities::tokenize( target, "/" ); + + if( targetTokens.size()==1 ) // no MeshBody or MeshLevel specified + { + GEOS_ERROR_IF( meshBodies.numSubGroups() != 1, + getDataContext() << ": No MeshBody information is specified in" << + " WellNewtonSolver::meshTargets, but there are multiple MeshBody objects", + getDataContext() ); + MeshBody const & meshBody = meshBodies.getGroup< MeshBody >( 0 ); + string const meshBodyName = meshBody.getName(); + + string const meshLevelName = ""; //tjbm_discretizationName; + + string const regionName = target; + auto const key = std::make_pair( meshBodyName, meshLevelName ); + m_meshTargets[key].emplace_back( regionName ); + } + else if( targetTokens.size()==2 ) + { + string const meshBodyName = targetTokens[0]; + GEOS_ERROR_IF( !meshBodies.hasGroup( meshBodyName ), + getWrapperDataContext( viewKeyStruct::targetRegionsString() ) << ": MeshBody (" << + meshBodyName << ") is specified in targetRegions, but does not exist.", + getWrapperDataContext( viewKeyStruct::targetRegionsString() ) ); + + string const meshLevelName = "";//tjbm_discretizationName; + + string const regionName = targetTokens[1]; + + + auto const key = std::make_pair( meshBodyName, meshLevelName ); + m_meshTargets[key].emplace_back( regionName ); + } + else + { + GEOS_ERROR( getDataContext() << ": Invalid specification of targetRegions" ); + } + } +} + + + +Group * WellNewtonSolver::createChild( string const & GEOS_UNUSED_PARAM( childKey ), string const & GEOS_UNUSED_PARAM( childName ) ) +{ + // Unused as all children are created within the constructor + return nullptr; +} + +WellNewtonSolver::CatalogInterface::CatalogType & WellNewtonSolver::getCatalog() +{ + static WellNewtonSolver::CatalogInterface::CatalogType catalog; + return catalog; +} + + +bool WellNewtonSolver::registerCallback( void * func, const std::type_info & funcType ) +{ + if( std::type_index( funcType ) == std::type_index( typeid( std::function< void( CRSMatrix< real64, globalIndex >, array1d< real64 > ) > ) ) ) + { + m_assemblyCallback = *reinterpret_cast< std::function< void( CRSMatrix< real64, globalIndex >, array1d< real64 > ) > * >( func ); + return true; + } + + return false; +} + + + +void WellNewtonSolver::logEndOfCycleInformation( integer const cycleNumber, + integer const numOfSubSteps, + stdVector< real64 > const & subStepDts ) const +{ + LogPart logpart( "TIMESTEP", MpiWrapper::commRank() == 0 ); + logpart.addEndDescription( "- Cycle ", cycleNumber ); + logpart.addEndDescription( "- N substeps ", numOfSubSteps ); + + std::stringstream logMessage; + for( integer i = 0; i < numOfSubSteps; ++i ) + { + if( i > 0 ) + { + logMessage << ", "; + } + logMessage << subStepDts[i] << " " << units::getSymbol( units::Unit::Time ); + } + + if( logMessage.rdbuf()->in_avail() == 0 ) + logMessage << "/"; + + logpart.addEndDescription( "- substep dts ", logMessage.str() ); + logpart.end(); + + if( isLogLevelActive< logInfo::SolverExecutionDetails >( getLogLevel())) + getIterationStats().outputStatistics(); +} + +void WellNewtonSolver::setupDofs( DomainPartition const & GEOS_UNUSED_PARAM( domain ), + DofManager & GEOS_UNUSED_PARAM( dofManager ) ) const +{ + GEOS_ERROR( "WellNewtonSolver::setupDofs called!. Should be overridden." ); +} + +void WellNewtonSolver::setSparsityPattern( DomainPartition & GEOS_UNUSED_PARAM( domain ), + DofManager & dofManager, + CRSMatrix< real64, globalIndex > & GEOS_UNUSED_PARAM( localMatrix ), + SparsityPattern< globalIndex > & pattern ) +{ + dofManager.setSparsityPattern( pattern ); +} + +void WellNewtonSolver::setSystemSetupTimestamp( Timestamp timestamp ) +{ + m_systemSetupTimestamp = timestamp; + + std::ostringstream oss; + m_dofManager.printFieldInfo( oss ); + GEOS_LOG_LEVEL( logInfo::Fields, oss.str()); +} + +std::unique_ptr< PreconditionerBase< LAInterface > > +WellNewtonSolver::createPreconditioner( DomainPartition & GEOS_UNUSED_PARAM( domain ) ) const +{ + // By default, do not create a preconditioner, one will be created internally inside LA backend + return {}; + + // TODO: refactor interfaces to always create preconditioner externally and pass to backends + // return LAInterface::createPreconditioner( m_linearSolverParameters.get() ); +} + + +namespace +{ + +/** + * @brief Helper for debug output of linear algebra objects (matrices and vectors) + * @tparam T type of LA object (must have stream insertion and .write() implemented) + * @param obj the object to output + * @param cycleNumber event cycle number + * @param nonlinearIteration nonlinear iteration number + * @param filePrefix short filename prefix (e.g. "mat") + * @param screenName long name for screen output (e.g. "System matrix") + * @param toScreen whether to print on screen + * @param toFile whether to write to file + */ +template< typename T > +void debugOutputLAObject( T const & obj, + real64 const & GEOS_UNUSED_PARAM( time ), + integer const cycleNumber, + integer const nonlinearIteration, + string const & filePrefix, + string const & screenName, + bool const toScreen, + bool const toFile ) +{ + if( toScreen ) + { + GEOS_LOG_RANK_0( GEOS_FMT( "{2:=>{1}}\n{0}:\n{2:=>{1}}", screenName, screenName.size() + 1, "" ) ); + GEOS_LOG( obj ); + } + + if( toFile ) + { + string const filename = GEOS_FMT( "{}_{:06}_{:02}.mtx", filePrefix.c_str(), cycleNumber, nonlinearIteration ); + obj.write( filename, LAIOutputFormat::MATRIX_MARKET ); + GEOS_LOG_RANK_0( GEOS_FMT( "{} written to {}", screenName, filename ) ); + } +} + +} + +void WellNewtonSolver::debugOutputSystem( real64 const & time, + integer const cycleNumber, + integer const nonlinearIteration, + ParallelMatrix const & matrix, + ParallelVector const & rhs ) const +{ + // special case when flag value > 2 + if( m_writeLinearSystem > 2 && cycleNumber < m_writeLinearSystem ) + return; + + debugOutputLAObject( matrix, + time, + cycleNumber, + nonlinearIteration, + getName() + "_mat", + "System matrix", + m_writeLinearSystem == 1, + m_writeLinearSystem >= 2 ); + + debugOutputLAObject( rhs, + time, + cycleNumber, + nonlinearIteration, + getName() + "_rhs", + "System right-hand side", + m_writeLinearSystem == 1, + m_writeLinearSystem >= 2 ); +} + +void WellNewtonSolver::debugOutputSolution( real64 const & time, + integer const cycleNumber, + integer const nonlinearIteration, + ParallelVector const & solution ) const +{ + // special case when flag value > 2 + if( m_writeLinearSystem > 2 && cycleNumber < m_writeLinearSystem ) + return; + + debugOutputLAObject( solution, + time, + cycleNumber, + nonlinearIteration, + getName() + "_sol", + "System solution", + m_writeLinearSystem == 1, + m_writeLinearSystem >= 2 ); +} + +void WellNewtonSolver::updateAndWriteConvergenceStep( real64 const & time_n, real64 const & dt, + integer const cycleNumber, integer const iteration ) +{ + getConvergenceStats().updateSolverStep( time_n, dt, cycleNumber, iteration ); + getConvergenceStats().writeConvergenceStatsToTable(); +} + + +void WellNewtonSolver::solveLinearSystem( DofManager const & dofManager, + ParallelMatrix & matrix, + ParallelVector & rhs, + ParallelVector & solution ) +{ + GEOS_MARK_FUNCTION; + + rhs.scale( -1.0 ); + solution.zero(); + + LinearSolverParameters const & params = m_linearSolverParameters.get(); + const bool isDirectSolver = (params.solverType == LinearSolverParameters::SolverType::direct); + const bool isSetupNeeded = !(isDirectSolver && params.direct.reuseFactorization); + + matrix.setDofManager( &dofManager ); + + GEOS_WARNING_IF( isDirectSolver && dofManager.numGlobalDofs() > 100000, + "Direct solver used for large system ( > 100,000 DOFs ). " + "This may lead to high memory consumption and long computation times. " + "Consider using an iterative solver for better performance." ); + + // Apply physics-based scaling to the linear system if enabled + if( m_usePhysicsScaling ) + { + Timer timer_setup( m_timers.get_inserted( "linear solver scaling" ) ); + + matrix.computeScalingVector( m_scaling ); + matrix.leftRightScale( m_scaling, m_scaling ); + rhs.pointwiseProduct( m_scaling ); + // Assume the solution is zeroed out, thus no need to scale it + } + + if( isDirectSolver || !m_precond ) + { + if( !m_linearSolver ) + { + m_linearSolver = LAInterface::createSolver( params ); + } + + if( isSetupNeeded ) + { + Timer timer_setup( m_timers.get_inserted( "linear solver setup" ) ); + m_linearSolver->setup( matrix ); + } + + { + Timer timer_setup( m_timers.get_inserted( "linear solver solve" ) ); + m_linearSolver->solve( rhs, solution ); + } + + m_linearSolverResult = m_linearSolver->result(); + } + else + { + { + Timer timer_setup( m_timers.get_inserted( "linear solver setup" ) ); + m_precond->setup( matrix ); + } + std::unique_ptr< KrylovSolver< ParallelVector > > solver = KrylovSolver< ParallelVector >::create( params, matrix, *m_precond ); + { + Timer timer_setup( m_timers.get_inserted( "linear solver solve" ) ); + solver->solve( rhs, solution ); + } + m_linearSolverResult = solver->result(); + } + + getIterationStats().accumulateSolverLinearTime( m_linearSolverResult.setupTime, m_linearSolverResult.solveTime ); + + GEOS_LOG_LEVEL_RANK_0( logInfo::LinearSolver, + GEOS_FMT( " Linear solve: ( iter, res ) = ( {:3}, {:4.2e} )", + m_linearSolverResult.numIterations, + m_linearSolverResult.residualReduction )); + + if( params.stopIfError ) + { + GEOS_ERROR_IF( m_linearSolverResult.breakdown(), + getDataContext() << ": Linear solution breakdown -> simulation STOP", + getDataContext() ); + } + else + { + GEOS_WARNING_IF( !m_linearSolverResult.success(), + getDataContext() << ": Linear solution failed", + getDataContext() ); + } + + // Unscale the solution vector if physics-based scaling was applied + if( m_usePhysicsScaling ) + { + Timer timer_setup( m_timers.get_inserted( "linear solver scaling" ) ); + + solution.pointwiseProduct( m_scaling ); + } +} + + + +// Detect oscillations for all dofs in the solution history +bool WellNewtonSolver::detectOscillations() const +{ + // grab the parameters + integer const oscillationCheckDepth = m_nonlinearSolverParameters.m_oscillationCheckDepth; + real64 const oscillationTolerance = m_nonlinearSolverParameters.m_oscillationTolerance; + real64 const oscillationFraction = m_nonlinearSolverParameters.m_oscillationFraction; + + if( m_solutionHistory.size() < oscillationCheckDepth ) + return false; // not enough history to check oscillations + + RAJA::ReduceSum< parallelDeviceReduce, localIndex > oscillationCount( 0 ); + + auto const solutionHistory = m_solutionHistory.toViewConst(); + localIndex const numDofs = m_solutionHistory[0].size(); + localIndex const historySize = m_solutionHistory.size(); + + RAJA::forall< parallelDevicePolicy<> >( RAJA::TypedRangeSegment< localIndex >( 0, numDofs ), + [=] GEOS_HOST_DEVICE ( localIndex const dof ) + { + bool oscillationDetected = true; + for( localIndex i = historySize - 1; i > historySize - oscillationCheckDepth; --i ) + { + real64 dxCur = solutionHistory[i][dof]; + real64 dxPrev = solutionHistory[i-1][dof]; + + if( LvArray::math::abs( dxCur ) < oscillationTolerance || LvArray::math::abs( dxPrev ) < oscillationTolerance ) + { + oscillationDetected = false; + break; // solution changes are too small + } + + real64 maxAbs = LvArray::math::max( LvArray::math::abs( dxCur ), LvArray::math::abs( dxPrev ) ); + if( LvArray::math::abs( dxCur + dxPrev ) / maxAbs > oscillationTolerance ) + { + oscillationDetected = false; + break; // solution changes are not oscillating + } + + if( dxCur * dxPrev > 0 ) + { + oscillationDetected = false; + break; // sign is not oscillating + } + } + + if( oscillationDetected ) + { + oscillationCount += 1; + } + } ); + + real64 const f = static_cast< real64 >( MpiWrapper::sum( oscillationCount.get() ) ) / MpiWrapper::sum( numDofs ); + + return f > oscillationFraction; +} + + +} // namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellNewtonSolver.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellNewtonSolver.hpp new file mode 100644 index 00000000000..47a83e0f2f7 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellNewtonSolver.hpp @@ -0,0 +1,870 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellNewtonSolver.hpp + */ + +#ifndef GEOS_PHYSICSSOLVERS_WELLNEWTONSOLVER_HPP_ +#define GEOS_PHYSICSSOLVERS_WELLNEWTONSOLVER_HPP_ + +#include "codingUtilities/traits.hpp" +#include "common/DataTypes.hpp" +#include "common/format/LogPart.hpp" + +#include "dataRepository/RestartFlags.hpp" +#include "linearAlgebra/interfaces/InterfaceTypes.hpp" +#include "linearAlgebra/utilities/LinearSolverResult.hpp" +#include "linearAlgebra/DofManager.hpp" +#include "mesh/DomainPartition.hpp" +#include "mesh/MeshBody.hpp" +#include "physicsSolvers/NonlinearSolverParameters.hpp" +#include "physicsSolvers/LinearSolverParameters.hpp" +#include "physicsSolvers/SolverStatistics.hpp" +#include "physicsSolvers/LogLevelsInfo.hpp" + +#include "physicsSolvers/fluidFlow/SolutionCheckHelpers.hpp" +#include "common/Timer.hpp" +#include + +namespace geos +{ + +class DomainPartition; + +/** + * @class WellNewtonSolver + * @brief Base class for all physics solvers + * + * This class provides the base interface for all physics solvers. It provides the basic + * functionality for setting up and solving a linear system, as well as the interface for + * performing a timestep. + */ +class WellNewtonSolver : public dataRepository::Group +{ +public: + + /** + * @brief Type of the stat output + */ + enum class StatsOutputType : integer + { + none, iteration, convergence, all + }; + + /** + * @brief Constructor for WellNewtonSolver + * @param name the name of this instantiation of WellNewtonSolver + * @param parent the parent group of this instantiation of WellNewtonSolver + */ + explicit WellNewtonSolver( string const & name, + Group * const parent ); + + /** + * @brief Move constructor for WellNewtonSolver + */ + WellNewtonSolver( WellNewtonSolver && ) = default; + + /** + * @brief Destructor for WellNewtonSolver + */ + virtual ~WellNewtonSolver() override; + + /** + * @brief Deleted constructor + */ + WellNewtonSolver() = delete; + + /** + * @brief Deleted copy constructor + */ + WellNewtonSolver( WellNewtonSolver const & ) = delete; + + /** + * @brief Deleted copy assignment operator + */ + WellNewtonSolver & operator=( WellNewtonSolver const & ) = delete; + + /** + * @brief Deleted move assignment operator + */ + WellNewtonSolver & operator=( WellNewtonSolver && ) = delete; + + /** + * @brief name of the node manager in the object catalog + * @return string that contains the catalog name to generate a new NodeManager object through the object catalog. + */ + static string catalogName() { return "WellNewtonSolver"; } + + + + /** + * @brief Generate mesh targets from target regions + * @param meshBodies the group of mesh bodies + */ + void generateMeshTargetsFromTargetRegions( Group const & meshBodies ); + + + /** + * + * @brief Getter for system matrix + * @return a reference to linear system matrix of this solver + */ + ParallelMatrix & getSystemMatrix() { return m_matrix; } + + /** + * @brief Getter for system rhs vector + * @return a reference to linear system right-hand side of this solver + */ + ParallelMatrix const & getSystemMatrix() const { return m_matrix; } + + /** + * @brief Getter for system rhs vector + * @return a reference to linear system right-hand side of this solver + */ + ParallelVector & getSystemRhs() { return m_rhs; } + + /** + * @brief Getter for system rhs vector + * @return a reference to linear system right-hand side of this solver + */ + ParallelVector const & getSystemRhs() const { return m_rhs; } + + /** + * @brief Getter for system solution vector + * @return a reference to solution vector of this solver + */ + ParallelVector & getSystemSolution() { return m_solution; } + + /** + * @brief Getter for system solution vector + * @return a reference to solution vector of this solver + */ + ParallelVector const & getSystemSolution() const { return m_solution; } + + /** + * @brief Getter for degree-of-freedom manager + * @return a reference to degree-of-freedom manager of this solver + */ + DofManager & getDofManager() { return m_dofManager; } + + /** + * @brief Getter for degree-of-freedom manager + * @return a reference to degree-of-freedom manager of this solver + */ + DofManager const & getDofManager() const { return m_dofManager; } + + /** + * @brief Getter for local matrix + * @return a reference to linear system matrix of this solver + */ + CRSMatrix< real64, globalIndex > & getLocalMatrix() { return m_localMatrix; } + + /** + * @brief Getter for local matrix + * @return a reference to linear system matrix of this solver + */ + CRSMatrixView< real64 const, globalIndex const > getLocalMatrix() const { return m_localMatrix.toViewConst(); } + + + template< typename T > + void setupSystem( T & well, DomainPartition & domain, + std::string const & meshBodyName, + MeshLevel const & meshLevel, + WellElementRegion & wellElementRegion, + bool const setSparsity =true ); + + template< typename T > + bool + solveNonlinearSystem( T & well, real64 const & time_n, + real64 const & stepDt, + integer const cycleNumber, + DomainPartition & domain, + MeshLevel & mesh, + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion ); + + + /** + * @brief Populate degree-of-freedom manager with fields relevant to this solver + * @param domain the domain containing the mesh and fields + * @param dofManager degree-of-freedom manager associated with the linear system + */ + virtual void + setupDofs( DomainPartition const & domain, + DofManager & dofManager ) const; + + /** + * @brief Set up the linear system (DOF indices and sparsity patterns) + * @param domain the domain containing the mesh and fields + * @param dofManager degree-of-freedom manager associated with the linear system + * @param localMatrix the system matrix + * @param rhs the system right-hand side vector + * @param solution the solution vector + * @param setSparsity flag to indicate if the sparsity pattern should be set + * + * @note While the function is virtual, the base class implementation should be + * sufficient for most single-physics solvers. + */ + + + /** + * @brief Set the sparsity pattern of the linear system matrix + * @param domain the domain containing the mesh and fields + * @param dofManager degree-of-freedom manager associated with the linear system + * @param localMatrix the system matrix + * @param pattern the sparsity pattern to be filled + */ + virtual void + setSparsityPattern( DomainPartition & domain, + DofManager & dofManager, + CRSMatrix< real64, globalIndex > & localMatrix, + SparsityPattern< globalIndex > & pattern ); + + /** + * @brief Create a preconditioner for this solver's linear system. + * @param domain the domain containing the mesh and fields + * @return the newly created preconditioner object + */ + virtual std::unique_ptr< PreconditionerBase< LAInterface > > + createPreconditioner( DomainPartition & domain ) const; + + + /** + * @brief Output the assembled linear system for debug purposes. + * @param time beginning-of-step time + * @param cycleNumber event cycle number + * @param nonlinearIteration current nonlinear iteration number + * @param matrix system matrix + * @param rhs system right-hand side vector + */ + void + debugOutputSystem( real64 const & time, + integer const cycleNumber, + integer const nonlinearIteration, + ParallelMatrix const & matrix, + ParallelVector const & rhs ) const; + + /** + * @brief Output the linear system solution for debug purposes. + * @param time beginning-of-step time + * @param cycleNumber event cycle number + * @param nonlinearIteration current nonlinear iteration number + * @param solution system solution vector + */ + void + debugOutputSolution( real64 const & time, + integer const cycleNumber, + integer const nonlinearIteration, + ParallelVector const & solution ) const; + + /** + * @brief Update the convergence information and write then into a CSV file + * @param time_n the time at the beginning of the step + * @param dt the desired timestep + * @param cycleNumber event cycle number + * @param iteration current iteration + */ + virtual void + updateAndWriteConvergenceStep( real64 const & time_n, + real64 const & dt, + integer const cycleNumber, + integer const iteration ); + + + + /** + * @brief function to apply a linear system solver to the assembled system. + * @param dofManager degree-of-freedom manager associated with the linear system + * @param matrix the system matrix + * @param rhs the system right-hand side vector + * @param solution the solution vector + * + * This function calls the linear solver package to perform a single linear solve on the block + * system. The derived physics solver is required to specify the call, as no default is provided. + * + * @note This function must be overridden in the derived physics solver in order to use an implict + * solution method such as LinearImplicitStep() or NonlinearImplicitStep(). + */ + virtual void + solveLinearSystem( DofManager const & dofManager, + ParallelMatrix & matrix, + ParallelVector & rhs, + ParallelVector & solution ); + + + + /** + * @brief creates a child group of of this WellNewtonSolver instantiation + * @param childKey the key of the child type + * @param childName the name of the child + * @return a pointer to the child group + */ + virtual Group * createChild( string const & childKey, string const & childName ) override; + + /** + * @brief Type alias for catalog interface used by this class. See CatalogInterface. + */ + using CatalogInterface = dataRepository::CatalogInterface< WellNewtonSolver, string const &, Group * const >; + + /** + * @brief Get the singleton catalog for WellNewtonSolver. + * @return reference to the catalog object + */ + static CatalogInterface::CatalogType & getCatalog(); + + /** + * @brief Structure to hold scoped key names + */ + struct viewKeyStruct + { + /// @return string for the cflFactor wrapper + static constexpr char const * cflFactorString() { return "cflFactor"; } + + /// @return string for the initialDt wrapper + static constexpr char const * initialDtString() { return "initialDt"; } + + /// @return string for the minDtIncreaseInterval wrapper + static constexpr char const * minDtIncreaseIntervalString() { return "minDtIncreaseInterval"; } + + /// @return string for the discretization wrapper + static constexpr char const * discretizationString() { return "discretization"; } + + /// @return string for the nextDt targetRegions wrapper + static constexpr char const * targetRegionsString() { return "targetRegions"; } + + /// @return string for the writeLinearSystem wrapper + static constexpr char const * writeLinearSystemString() { return "writeLinearSystem"; } + + /// @return string for the usePhysicsScaling wrapper + static constexpr char const * usePhysicsScalingString() { return "usePhysicsScaling"; } + + /// @return string for the allowNonConvergedLinearSolverSolution wrapper + static constexpr char const * allowNonConvergedLinearSolverSolutionString() { return "allowNonConvergedLinearSolverSolution"; } + + /// @return string for the writeStatistics wrapper + static constexpr char const * writeStatisticsCSVString() { return "writeStatistics"; } + + /// @return string for the numTimestepsSinceLastDtCut wrapper + static constexpr char const * numTimestepsSinceLastDtCutString() { return "numTimestepsSinceLastDtCut"; } + + /// string key for the esitmate well solution flag + static constexpr char const * activeCoupledIterationsString() { return "activeCoupledIterations"; } + static constexpr char const * estimateWellSolutionString() { return "estimateWellSolution"; } + /// string key for the enable iso thermal estimator flag + static constexpr char const * enableIsoThermalEstimatorString() { return "enableIsoThermalEstimator"; } + }; + + /** + * @brief Structure to hold scoped key names + */ + struct groupKeyStruct + { + /// @return string for the linearSolverParameters wrapper + static constexpr char const * linearSolverParametersString() { return "LinearSolverParameters"; } + + /// @return string for the nonlinearSolverParameters wrapper + static constexpr char const * nonlinearSolverParametersString() { return "NonlinearSolverParameters"; } + + /// @return string for the solverStatistics wrapper + static constexpr char const * solverStatisticsString() { return "SolverStatistics"; } + }; + + /** + * @brief getter for the timestamp of the system setup + * @return the timestamp of the last time systemSetup was called + */ + Timestamp getSystemSetupTimestamp() const { return m_systemSetupTimestamp; } + + + /** + * @brief set the timestamp of the system setup + * @param[in] timestamp the new timestamp of system setup + */ + void setSystemSetupTimestamp( Timestamp timestamp ); + + + /** + * @brief accessor for the linear solver parameters. + * @return the linear solver parameter list + */ + LinearSolverParameters & getLinearSolverParameters() + { + return m_linearSolverParameters.get(); + } + + /** + * @brief const accessor for the linear solver parameters. + * @return the linear solver parameter list + */ + LinearSolverParameters const & getLinearSolverParameters() const + { + return m_linearSolverParameters.get(); + } + + /** + * @brief accessor for the nonlinear solver parameters. + * @return the nonlinear solver parameter list + */ + NonlinearSolverParameters & getNonlinearSolverParameters() + { + return m_nonlinearSolverParameters; + } + + /** + * @brief const accessor for the nonlinear solver parameters. + * @return the nonlinear solver parameter list + */ + NonlinearSolverParameters const & getNonlinearSolverParameters() const + { + return m_nonlinearSolverParameters; + } + + /** + * @brief synchronize the nonlinear solver parameters. + */ + virtual void + synchronizeNonlinearSolverParameters() + { /* empty here, overriden in CoupledSolver */ } + + /** + * @brief Get position of a given region within solver's target region list + * @param regionName the region name to find + * @return index within target regions list + */ + localIndex targetRegionIndex( string const & regionName ) const; + + /** + * @brief return the list of target regions + * @return the array of region names + */ + string_array const & getTargetRegionNames() const {return m_targetRegionNames;} + + + + /** + * @brief function to set the value of m_assemblyCallback + * @param func the function to set m_assemblyCallback to + * @param funcType the type of the function + * @return true if the function was successfully set, false otherwise + * + * This is used to provide a callback function for to be called in the assembly step. + */ + virtual bool registerCallback( void * func, const std::type_info & funcType ) final override; + + /** + * @return An IterationsStatistics for the "root" solver. + * Otherwise return an empty IterationsStatistics + */ + IterationsStatistics & getIterationStats() + { + return m_solverStatistics.m_iterationsStats; + } + /** + * @return An IterationsStatistics for the "root" solver. + * Otherwise return an empty IterationsStatistics + * (const version) + */ + IterationsStatistics const & getIterationStats() const + { + return m_solverStatistics.m_iterationsStats; + } + /** + * @return A ConvergenceStatistics for all sub-solvers + */ + ConvergenceStatistics & getConvergenceStats() + { + return m_solverStatistics.m_convergenceStats; + } + /** + * @return A ConvergenceStatistics for all sub-solvers (const version) + */ + ConvergenceStatistics const & getConvergenceStats() const + { + return m_solverStatistics.m_convergenceStats; + } + + /** + * @brief accessor for the solver statistics. + * @return reference to m_solverStatistics + */ + SolverStatistics & getSolverStatistics() { return m_solverStatistics; } + + /** + * @brief const accessor for the solver statistics. + * @return reference to m_solverStatistics + */ + SolverStatistics const & getSolverStatistics() const { return m_solverStatistics; } + + + + /** + * @brief Detect oscillations in the solution + * @return true if oscillations are detected, false otherwise + */ + bool detectOscillations() const; + + + /** + * @brief Set thermal effects enable + * @param[in] true/false + */ + void enableThermalEffects ( bool enable ) { m_thermalEffectsEnabled = enable; }; + + /** + * @brief Are thermal effects enabled + * @return true if thermal effects are enabled, false otherwise + */ + bool thermalEffectsEnabled() const { return m_thermalEffectsEnabled; } + + /** + * @brief Is isoThermalEstimator enabled + * @return true if isoThermalEstimator is enabled, false otherwise + */ + bool isoThermalEstimatorEnabled() const { return m_enableIsoThermalEstimator; } + + bool getNumActiveCoupledIterations() const { return m_activeCoupledIterations; } + +protected: + + virtual void postInputInitialization() override; + + /// behavior in case of linear solver failure + integer m_allowNonConvergedLinearSolverSolution; + + + + /// Data structure to handle degrees of freedom + DofManager m_dofManager; + + /// System matrix + ParallelMatrix m_matrix; + + /// System right-hand side vector + ParallelVector m_rhs; + + /// System solution vector + ParallelVector m_solution; + + /// Diagonal scaling vector D (Ahat = D * A * D, bhat = D * b, x = D * xhat) + ParallelVector m_scaling; + + /// Flag to decide whether to apply physics-based scaling to the linear system + integer m_usePhysicsScaling; + + /// Local system matrix and rhs + CRSMatrix< real64, globalIndex > m_localMatrix; + + /// Custom linear solver for the "native" solver type + std::unique_ptr< LinearSolverBase< LAInterface > > m_linearSolver; + + /// Custom preconditioner for the "native" iterative solver + std::unique_ptr< PreconditionerBase< LAInterface > > m_precond; + + /// flag for debug output of matrix, rhs, and solution + integer m_writeLinearSystem; + + /// Parameter for outputing statistics information + StatsOutputType m_writeStatisticsCSV; + + /// Linear solver parameters + LinearSolverParametersInput m_linearSolverParameters; + + /// Result of the last linear solver + LinearSolverResult m_linearSolverResult; + + /// Nonlinear solver parameters + NonlinearSolverParameters m_nonlinearSolverParameters; + + /// Solver statistics + SolverStatistics m_solverStatistics; + + /// Timestamp of the last call to setup system + Timestamp m_systemSetupTimestamp; + + /// Callback function for assembly step + std::function< void( CRSMatrix< real64, globalIndex >, array1d< real64 > ) > m_assemblyCallback; + + /// Timers for the aggregate profiling of the solver + stdMap< std::string, std::chrono::system_clock::duration > m_timers; + + /// History of the solution vector, used for oscillation detection + ArrayOfArrays< real64 > m_solutionHistory; + +private: + /// List of names of regions the solver will be applied to + string_array m_targetRegionNames; + + /// Map containing the array of target regions (value) for each MeshBody (key). + map< std::pair< string, string >, string_array > m_meshTargets; + + /// Number of coupled iterations to activate estimator solve + integer m_activeCoupledIterations; + + /// Flag to enable thermal effects in wellbore calculations + bool m_thermalEffectsEnabled; + integer m_enableIsoThermalEstimator; + + + /** + * @brief output information about the cycle to the log + * @param cycleNumber the current cycle number + * @param numOfSubSteps the number of substeps taken + * @param subStepDts the time step size for each substep + */ + void logEndOfCycleInformation( integer const cycleNumber, + integer const numOfSubSteps, + stdVector< real64 > const & subStepDts ) const; +}; + +template< typename T > +void WellNewtonSolver::setupSystem( T & well, DomainPartition & domain, + std::string const & meshBodyName, + MeshLevel const & meshLevel, + WellElementRegion & wellElementRegion, + bool const setSparsity ) +{ + GEOS_MARK_FUNCTION; + + map< std::pair< string, string >, string_array > meshTargets; + string_array regions; + + meshTargets.clear(); + regions.clear(); + regions.emplace_back( wellElementRegion.getName() ); + auto const key = std::make_pair( meshBodyName, meshLevel.getName() ); + meshTargets[key] = std::move( regions ); + + m_dofManager.setDomain( domain ); + m_dofManager.addField( well.wellElementDofName(), + FieldLocation::Elem, + well.numDofPerWellElement(), + meshTargets ); + + m_dofManager.addCoupling( well.wellElementDofName(), + well.wellElementDofName(), + DofManager::Connector::Node ); + + m_dofManager.reorderByRank(); + if( setSparsity ) + { + SparsityPattern< globalIndex > pattern; + setSparsityPattern( domain, m_dofManager, m_localMatrix, pattern ); + m_localMatrix.assimilate< parallelDevicePolicy<> >( std::move( pattern ) ); + } + m_localMatrix.setName( this->getName() + "/matrix" ); + + m_rhs.setName( this->getName() + "/rhs" ); + m_rhs.create( m_dofManager.numLocalDofs(), MPI_COMM_GEOS ); + + m_solution.setName( this->getName() + "/solution" ); + m_solution.create( m_dofManager.numLocalDofs(), MPI_COMM_GEOS ); +} + + +template< typename T > +bool WellNewtonSolver::solveNonlinearSystem( T & well, real64 const & time_n, + real64 const & stepDt, + integer const cycleNumber, + DomainPartition & domain, + MeshLevel & mesh, + ElementRegionManager & elemManager, + WellElementSubRegion & subRegion ) +{ + integer const maxNewtonIter = m_nonlinearSolverParameters.m_maxIterNewton; + integer const minNewtonIter = m_nonlinearSolverParameters.m_minIterNewton; + real64 const newtonTol = m_nonlinearSolverParameters.m_newtonTol; + +// keep residual from previous iteration in case we need to do a line search + + integer newtonIter = 0; + real64 scaleFactor = 1.0; + + bool isNewtonConverged = false; + + for( newtonIter = 0; newtonIter < maxNewtonIter; ++newtonIter ) + { + if( m_nonlinearSolverParameters.getLogLevel() > 4 ) + GEOS_LOG_LEVEL_RANK_0( logInfo::NonlinearSolver, + GEOS_FMT( " Well: {} Est Attempt: NewtonIter: {:2}", subRegion.getName(), stepDt, newtonIter )); + + { + Timer timer( m_timers.get_inserted( "assemble" ) ); + +// We sync the nonlinear convergence history. The coupled solver parameters are the one being +// used. We want to propagate the info to subsolvers. It can be important for solvers that +// have special treatment for specific iterations. + synchronizeNonlinearSolverParameters(); + +// zero out matrix/rhs before assembly + m_localMatrix.zero(); + m_rhs.zero(); + + arrayView1d< real64 > const localRhs = m_rhs.open(); + +// call assemble to fill the matrix and the rhs + well.assembleSystem( time_n, + stepDt, + cycleNumber, + elemManager, + subRegion, + m_dofManager, + m_localMatrix.toViewConstSizes(), + localRhs ); + +// apply boundary conditions to system + well.applyWellBoundaryConditions( time_n, + stepDt, + elemManager, + subRegion, + m_dofManager, + localRhs, + m_localMatrix.toViewConstSizes() ); + + m_rhs.close(); + + if( m_assemblyCallback ) + { +// Make a copy of LA objects and ship off to the callback + array1d< real64 > localRhsCopy( m_rhs.localSize() ); + localRhsCopy.setValues< parallelDevicePolicy<> >( m_rhs.values() ); + m_assemblyCallback( m_localMatrix, std::move( localRhsCopy ) ); + } + } + + // well.outputSingleWellDebug( time_n, stepDt, 0, newtonIter, 0, + // mesh, subRegion, dofManager, m_localMatrix.toViewConstSizes(), m_rhs.values() ); + real64 residualNorm = 0; + { + Timer timer( m_timers.get_inserted( "convergence check" ) ); + +// get residual norm + residualNorm = well.calculateWellResidualNorm( time_n, stepDt, m_nonlinearSolverParameters, subRegion, m_dofManager, m_rhs.values() ); + if( m_nonlinearSolverParameters.getLogLevel() > 4 ) + GEOS_LOG_LEVEL_RANK_0( logInfo::Convergence, + GEOS_FMT( " ( R ) = ( {:4.2e} )", residualNorm ) ); + } + //auto iterInfo = currentIter( time_n, dt ); + //outputSingleWellDebug( time_n, stepDt, 0, newtonIter, 0, + // mesh, subRegion, dofManager, m_localMatrix.toViewConstSizes(), m_rhs.values() ); + // if the residual norm is less than the Newton tolerance we denote that we have + // converged and break from the Newton loop immediately. + if( residualNorm < newtonTol && newtonIter >= minNewtonIter ) + { + isNewtonConverged = true; + break; + } + +// if the residual norm is above the max allowed residual norm, we break from +// the Newton loop to avoid crashes due to Newton divergence + if( residualNorm > m_nonlinearSolverParameters.m_maxAllowedResidualNorm ) + { + string const maxAllowedResidualNormString = NonlinearSolverParameters::viewKeysStruct::maxAllowedResidualNormString(); + if( m_nonlinearSolverParameters.getLogLevel() > 4 ) + GEOS_LOG_LEVEL_RANK_0( logInfo::Convergence, + GEOS_FMT( " The residual norm is above the {} of {}. Newton loop terminated.", + maxAllowedResidualNormString, + m_nonlinearSolverParameters.m_maxAllowedResidualNorm ) ); + isNewtonConverged = false; + break; + } + + { + Timer timer( m_timers.get_inserted( "linear solver total" ) ); + +// TODO: Trilinos currently requires this, re-evaluate after moving to Tpetra-based solvers + if( m_precond ) + { + m_precond->clear(); + } + + { + Timer timer_setup( m_timers.get_inserted( "linear solver create" ) ); + +// Compose parallel LA matrix/rhs out of local LA matrix/rhs +// + m_matrix.create( m_localMatrix.toViewConst(), m_dofManager.numLocalDofs(), MPI_COMM_GEOS ); + } + +// Output the linear system matrix/rhs for debugging purposes + //string tag = "_"+std::to_string( my_ctime ); tjb + //debugOutputSystem( time_n, cycleNumber, newtonIter, m_matrix, m_rhs, tag ); + + debugOutputSystem( time_n, cycleNumber, newtonIter, m_matrix, m_rhs ); +// Solve the linear system + solveLinearSystem( m_dofManager, m_matrix, m_rhs, m_solution ); + +// Increment the solver statistics for reporting purposes + getIterationStats().updateNonlinearIteration( m_linearSolverResult.numIterations ); + +// Output the linear system solution for debugging purposes + debugOutputSolution( time_n, cycleNumber, newtonIter, m_solution ); + //debugOutputSolution( time_n, cycleNumber, newtonIter, m_solution, tag ); + } + + { + Timer timer( m_timers.get_inserted( "apply solution" ) ); + +// Compute the scaling factor for the Newton update + scaleFactor = well.scalingForWellSystemSolution( subRegion, m_dofManager, m_solution.values() ); + if( m_nonlinearSolverParameters.getLogLevel() > 4 ) + GEOS_LOG_LEVEL_RANK_0( logInfo::Solution, + GEOS_FMT( " {}: Global solution scaling factor = {}", getName(), scaleFactor ) ); + + real64 minPressure = 0.0, minDensity = 0.0, minTotalDensity = 0.0; + bool const solutionLogActive = isLogLevelActive< logInfo::Solution >( getLogLevel() ); + bool const solutionDetailsLogActive = isLogLevelActive< logInfo::SolutionDetails >( getLogLevel() ); + ElementsReporterBuffer rankNegPressureIds{ solutionLogActive, solutionDetailsLogActive ? 16 : 0 }; + ElementsReporterBuffer rankNegDensityIds{ solutionLogActive, solutionDetailsLogActive ? 16 : 0 }; + // output only total density sum, not cell details + ElementsReporterBuffer rankTotalNegDensityIds{ solutionLogActive, 0 }; + if( !well.checkWellSystemSolution( subRegion, m_dofManager, m_solution.values(), scaleFactor, minPressure, minDensity, minTotalDensity, rankNegPressureIds, rankNegDensityIds, + rankTotalNegDensityIds ) ) + { +// TODO try chopping (similar to line search) + if( m_nonlinearSolverParameters.getLogLevel() > 4 ) + GEOS_LOG_RANK_0( GEOS_FMT( " {}: Solution check failed. Newton loop terminated.", getName()) ); + break; + } + +// apply the system solution to the fields/variables + well.applyWellSystemSolution( m_dofManager, m_solution.values(), scaleFactor, stepDt, domain, mesh, subRegion ); + } + + { + Timer timer( m_timers.get_inserted( "update state" ) ); + + // update derived variables (constitutive models) + well.updateWellState( domain.getMeshBody( mesh.getParent().getParent().getName() ), elemManager, subRegion ); + } + + } + return isNewtonConverged; +} + + +/** + * @brief String for the stats output type + */ +ENUM_STRINGS( WellNewtonSolver::StatsOutputType, + "none", + "iteration", + "convergence", + "all" ); + +} // namespace geos + + +#endif /* GEOS_PHYSICSSOLVERS_WELLNEWTONSOLVER_HPP_ */ diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.cpp new file mode 100644 index 00000000000..63f7baa7053 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.cpp @@ -0,0 +1,81 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * SPDX-License-Identifier: LGPL-2.1-only + * + * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC + * Copyright (c) 2018-2024 TotalEnergies + * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University + * Copyright (c) 2023-2024 Chevron + * Copyright (c) 2019- GEOS/GEOSX Contributors + * All rights reserved + * + * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details. + * ------------------------------------------------------------------------------------------------------------ + */ + +/* + * @file WellPhaseVolumeRateConstraint.cpp + */ + +#include "LogLevelsInfo.hpp" +#include "WellPhaseVolumeRateConstraint.hpp" +#include "WellConstants.hpp" +#include "dataRepository/InputFlags.hpp" +#include "functions/FunctionManager.hpp" + + +namespace geos +{ + +using namespace dataRepository; + + +PhaseVolumeRateConstraint::PhaseVolumeRateConstraint( string const & name, Group * const parent ) + : WellConstraintBase( name, parent ) +{ + this->setInputFlags( InputFlags::OPTIONAL_NONUNIQUE ); + + this->registerWrapper( viewKeyStruct::phaseRateString(), &this->m_constraintValue ). + setDefaultValue( 0.0 ). + setInputFlag( InputFlags::OPTIONAL ). + setRestartFlags( RestartFlags::WRITE_AND_READ ). + setDescription( "Phase rate, (if useSurfaceConditions: [surface m^3/s]; else [reservoir m^3/s]) " ); + + this->registerWrapper( viewKeyStruct::phaseNameString(), &this->m_phaseName ). + setRTTypeName( rtTypes::CustomTypes::groupNameRef ). + setDefaultValue( "" ). + setInputFlag( InputFlags::OPTIONAL ). + setRestartFlags( RestartFlags::WRITE_AND_READ ). + setDescription( "Name of the target phase" ); +} + +PhaseVolumeRateConstraint::~PhaseVolumeRateConstraint() +{} + +void PhaseVolumeRateConstraint::postInputInitialization() +{ + // Validate table options + WellConstraintBase::postInputInitialization(); + + // check constraint value + GEOS_THROW_IF( m_constraintValue < 0, + getWrapperDataContext( viewKeyStruct::phaseRateString() ) << ": Target value is negative", + InputError ); + + + GEOS_THROW_IF ((m_constraintValue <= 0.0 && m_constraintScheduleTableName.empty()), + getName() << " " << getDataContext() << ": You need to specify a phase rate constraint. \n" << + "The rate constraint can be specified using " << + "either " << viewKeyStruct::phaseRateString() << + " or " << WellConstraintBase::viewKeyStruct::constraintScheduleTableNameString(), + InputError ); +} + +bool PhaseVolumeRateConstraint::checkViolation( WellConstraintBase const & currentConstraint, real64 const & currentTime ) const +{ + real64 const currentValue = currentConstraint.phaseVolumeRates()[m_phaseIndex]; + real64 const constraintValue = getConstraintValue( currentTime ); + return ( LvArray::math::abs( currentValue ) > LvArray::math::abs( constraintValue ) ); +} + +} //namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.hpp new file mode 100644 index 00000000000..3b1fd5b8028 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.hpp @@ -0,0 +1,190 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellPhaseVolumeRateConstraint.hpp + */ + + +#ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLPHASEVOLUMERATECONSTRAINT_HPP +#define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLPHASEVOLUMERATECONSTRAINT_HPP + +#include "common/format/EnumStrings.hpp" +#include "dataRepository/Group.hpp" +#include "functions/TableFunction.hpp" +#include "WellConstraintsBase.hpp" +#include "WellConstants.hpp" + +namespace geos +{ + + +template< typename T > +localIndex getPhaseIndexFromFluidModel( T const & fluidModel, std::string const & inputPhase ) +{ + localIndex phaseIndex=-1; + // Find target phase index for phase rate constraint + for( integer ip = 0; ip < fluidModel.numFluidPhases(); ++ip ) + { + if( fluidModel.phaseNames()[ip] == inputPhase ) + { + phaseIndex = ip; + } + } + return phaseIndex; +} + +/** + * @class PhaseVolumeRateConstraint + * @brief This class describes a phase rate constraint used to control a well of WellConstraintType type (Injection or Production). + */ + +class PhaseVolumeRateConstraint : public WellConstraintBase +{ +public: + + + /** + * @name Constructor / Destructor + */ + ///@{ + + /** + * @brief Constructor for WellControls Objects. + * @param[in] name the name of this instantiation of WellControls in the repository + * @param[in] parent the parent group of this instantiation of WellControls + */ + explicit PhaseVolumeRateConstraint( string const & name, dataRepository::Group * const parent ); + + /** + * @brief Default destructor. + */ + ~PhaseVolumeRateConstraint() override; + + /** + * @brief Deleted default constructor. + */ + PhaseVolumeRateConstraint() = delete; + + /** + * @brief Deleted copy constructor. + */ + PhaseVolumeRateConstraint( PhaseVolumeRateConstraint const & ) = delete; + + /** + * @brief Deleted move constructor. + */ + PhaseVolumeRateConstraint( PhaseVolumeRateConstraint && ) = delete; + + /** + * @brief Deleted assignment operator. + * @return a reference to a constraint object + */ + PhaseVolumeRateConstraint & operator=( PhaseVolumeRateConstraint const & ) = delete; + + /** + * @brief Deleted move operator. + * @return a reference to a constraint object + */ + PhaseVolumeRateConstraint & operator=( PhaseVolumeRateConstraint && ) = delete; + + ///@} + + /** + * @brief name of the node manager in the object catalog + * @return string that contains the catalog name to generate a new Constraint object through the object catalog. + */ + static string catalogName() + { + return "PhaseVolumeRateConstraint"; + } + + /** + * @name Getters / Setters + */ + ///@{ + + // Temp interface - tjb + virtual ConstraintTypeId getControl() const override { return ConstraintTypeId::PHASEVOLRATE; }; + + /** + * @brief Get the target phase name + * @return the target phase name + */ + const string & getPhaseName() const { return m_phaseName; } + + /** + * @brief Set the target phase name + * @param[in] phaseName the target phase name + */ + void setPhaseName( const string & phaseName ) { m_phaseName = phaseName; } + + /** + * @brief Get the target phase index + * @return the target phase index + */ + const localIndex & getPhaseIndex() const { return m_phaseIndex; } + + /** + * @brief Set the target phase index + * @param[in] phaseIndex the target phase index + */ + void setPhaseIndex( const localIndex & phaseIndex ) { m_phaseIndex = phaseIndex; } + ///@} + + struct viewKeyStruct + { + /// String key for the well target phase rate + static constexpr char const * phaseRateString() { return "phaseRate"; } + /// String key for the well target phase name + static constexpr char const * phaseNameString() { return "phaseName"; } + }; + + /** + * @brief Validate phase type is consistent with fluidmodel + */ + template< typename T > void validatePhaseType( T const & fluidModel ); + ///@} + + virtual bool checkViolation( WellConstraintBase const & currentConstraint, real64 const & currentTime ) const override; +protected: + + virtual void postInputInitialization() override; + +private: + + /// Name of the targeted phase + string m_phaseName; + + /// Index of the target phase, used to impose the phase rate constraint + localIndex m_phaseIndex; + +}; + +template< typename T > +void PhaseVolumeRateConstraint::validatePhaseType( T const & fluidModel ) +{ + // Find target phase index for phase rate constraint + m_phaseIndex = getPhaseIndexFromFluidModel( fluidModel, this->template getReference< string >( viewKeyStruct::phaseNameString())); + + GEOS_THROW_IF( m_phaseIndex == -1, + "PhaseVolumeRateConstraint " << this->template getReference< string >( viewKeyStruct::phaseNameString()) << + ": Invalid phase type for simulation fluid model", + InputError ); +} + +} //namespace geos + +#endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLPHASEVOLUMERATECONSTRAINT_HPP diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellProductionConstraint.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellProductionConstraint.cpp new file mode 100644 index 00000000000..0ede58882b5 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellProductionConstraint.cpp @@ -0,0 +1,69 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellProductionConstraint.cpp + */ + +#include "LogLevelsInfo.hpp" +#include "WellProductionConstraint.hpp" +#include "WellConstants.hpp" +#include "dataRepository/InputFlags.hpp" +#include "functions/FunctionManager.hpp" + +#include "WellMassRateConstraint.hpp" +#include "WellPhaseVolumeRateConstraint.hpp" +#include "WellVolumeRateConstraint.hpp" + +namespace geos +{ + +template< typename ConstraintRateType > +ProductionConstraint< ConstraintRateType >::ProductionConstraint( string const & name, Group * const parent ) + : ConstraintRateType( name, parent ) +{ + // set rate sign for producers (base class member) + this->m_rateSign = -1.0; +} +template< typename ConstraintRateType > +ProductionConstraint< ConstraintRateType >::~ProductionConstraint() +{} + +template< typename ConstraintRateType > +void ProductionConstraint< ConstraintRateType >::postInputInitialization() +{ + // Validate value and table options + ConstraintRateType::postInputInitialization(); + +} +// Register concrete wrapper constraint types and instantiate templates. + +//template class ProductionConstraint< LiquidRateConstraint >; +//using ProductionLiquidRateConstraint = ProductionConstraint< LiquidRateConstraint >; +//REGISTER_CATALOG_ENTRY( WellConstraintBase, ProductionLiquidRateConstraint, string const &, Group * const ) + +template class ProductionConstraint< MassRateConstraint >; +using ProductionMassRateConstraint = ProductionConstraint< MassRateConstraint >; +REGISTER_CATALOG_ENTRY( WellConstraintBase, ProductionMassRateConstraint, string const &, Group * const ) + +template class ProductionConstraint< PhaseVolumeRateConstraint >; +using ProductionPhaseVolumeRateConstraint = ProductionConstraint< PhaseVolumeRateConstraint >; +REGISTER_CATALOG_ENTRY( WellConstraintBase, ProductionPhaseVolumeRateConstraint, string const &, Group * const ) + +template class ProductionConstraint< VolumeRateConstraint >; +using ProductionVolumeRateConstraint = ProductionConstraint< VolumeRateConstraint >; +REGISTER_CATALOG_ENTRY( WellConstraintBase, ProductionVolumeRateConstraint, string const &, Group * const ) + +} //namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellProductionConstraint.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellProductionConstraint.hpp new file mode 100644 index 00000000000..ce1ca16de14 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellProductionConstraint.hpp @@ -0,0 +1,106 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellProductionConstraints.hpp + */ + + +#ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLPRODUCTIONCONSTRAINT_HPP +#define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLPRODUCTIONCONSTRAINT_HPP + +#include "common/format/EnumStrings.hpp" +#include "dataRepository/Group.hpp" +#include "functions/TableFunction.hpp" + +namespace geos +{ +using namespace dataRepository; +/** + * @class ProductionConstraint + * @brief This class describes constraint used to control a production well. + */ + +template< typename ConstraintType > +class ProductionConstraint : public ConstraintType +{ +public: + /** + * @name Constructor / Destructor + */ + ///@{ + + /** + * @brief Constructor for WellControls Objects. + * @param[in] name the name of this instantiation of WellControls in the repository + * @param[in] parent the parent group of this instantiation of WellControls + */ + explicit ProductionConstraint( string const & name, dataRepository::Group * const parent ); + + /** + * @brief Default destructor. + */ + ~ProductionConstraint() override; + + /** + * @brief Deleted default constructor. + */ + ProductionConstraint() = delete; + + /** + * @brief Deleted copy constructor. + */ + ProductionConstraint( ProductionConstraint const & ) = delete; + + /** + * @brief Deleted move constructor. + */ + ProductionConstraint( ProductionConstraint && ) = delete; + + /** + * @brief Deleted assignment operator. + * @return a reference to a constraint object + */ + ProductionConstraint & operator=( ProductionConstraint const & ) = delete; + + /** + * @brief Deleted move operator. + * @return a reference to a constraint object + */ + ProductionConstraint & operator=( ProductionConstraint && ) = delete; + + ///@} + + /** + * @brief name of the node manager in the object catalog + * @return string that contains the catalog name to generate a new Constraint object through the object catalog. + */ + static string catalogName() + { + return "Production"+ConstraintType::catalogName(); + } + virtual string getCatalogName() const override { return catalogName(); } +protected: + + virtual void postInputInitialization() override; + + static bool isViolated( const real64 & currentValue, const real64 & constraintValue ) + { return currentValue < constraintValue; } +}; + + +} //namespace geos + +#endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLPRODUCTIONCONSTRAINT_HPP diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.cpp index 61b9398d0e6..830833212b2 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.cpp @@ -38,7 +38,7 @@ using namespace fields; WellSolverBase::WellSolverBase( string const & name, Group * const parent ) - : PhysicsSolverBase( name, parent ), + : WellControls( name, parent ), m_numPhases( 0 ), m_numComponents( 0 ), m_numDofPerWellElement( 0 ), @@ -46,6 +46,7 @@ WellSolverBase::WellSolverBase( string const & name, m_isThermal( 0 ), m_ratesOutputDir( joinPath( OutputBase::getOutputDirectory(), name + "_rates" ) ), m_keepVariablesConstantDuringInitStep( false ) + { registerWrapper( viewKeyStruct::isThermalString(), &m_isThermal ). setApplyDefaultValue( 0 ). @@ -65,40 +66,41 @@ WellSolverBase::WellSolverBase( string const & name, setInputFlag( dataRepository::InputFlags::OPTIONAL ). setDescription( "Choose time step to honor rates/bhp tables time intervals" ); + addLogLevel< logInfo::WellControl >(); } Group * WellSolverBase::createChild( string const & childKey, string const & childName ) { + Group * baseChild = WellControls::createChild( childKey, childName ); + if( baseChild != nullptr ) + { + return baseChild; + } static std::set< string > const childTypes = { - keys::wellControls, + //keys::wellControls, PhysicsSolverBase::groupKeyStruct::linearSolverParametersString(), PhysicsSolverBase::groupKeyStruct::nonlinearSolverParametersString(), }; GEOS_ERROR_IF( childTypes.count( childKey ) == 0, CatalogInterface::unknownTypeError( childKey, getDataContext(), childTypes ), getDataContext() ); - if( childKey == keys::wellControls ) - { - return ®isterGroup< WellControls >( childName ); - } - else - { - PhysicsSolverBase::createChild( childKey, childName ); - return nullptr; - } + + PhysicsSolverBase::createChild( childKey, childName ); + return nullptr; + } void WellSolverBase::expandObjectCatalogs() { - createChild( keys::wellControls, keys::wellControls ); + //createChild( keys::wellControls, keys::wellControls ); } WellSolverBase::~WellSolverBase() = default; void WellSolverBase::postInputInitialization() { - PhysicsSolverBase::postInputInitialization(); + WellControls::postInputInitialization(); // 1. Set key dimensions of the problem m_numDofPerWellElement = m_isThermal ? m_numComponents + 2 : m_numComponents + 1; // 1 pressure connectionRate + temp if thermal @@ -211,95 +213,67 @@ void WellSolverBase::setupDofs( DomainPartition const & domain, DofManager::Connector::Node ); } -void WellSolverBase::setPerforationStatus( real64 const & time_n, DomainPartition & domain ) + + +void WellSolverBase::selectWellConstraint( real64 const & time_n, + real64 const & dt, + const integer coupledIterationNumber, + DomainPartition & domain ) { - FunctionManager & functionManager = FunctionManager::getInstance(); + GEOS_MARK_FUNCTION; + GEOS_UNUSED_VAR( dt ); + GEOS_UNUSED_VAR( coupledIterationNumber ); - // Set well element/perf status - forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&] ( string const &, - MeshLevel & mesh, - string_array const & regionNames ) + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const & meshBodyName, + MeshLevel & meshLevel, + string_array const & regionNames ) { - - ElementRegionManager & elemManager = mesh.getElemManager(); - elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, - [&]( localIndex const, - WellElementSubRegion & subRegion ) + GEOS_UNUSED_VAR( meshBodyName ); + ElementRegionManager & elementRegionManager = meshLevel.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); WellControls & wellControls = getWellControls( subRegion ); - - // Set perforation status - - PerforationData & perforationData = *subRegion.getPerforationData(); - string_array const & perfStatusTableName = perforationData.getPerfStatusTableName(); - arrayView1d< integer > perfStatus = perforationData.getLocalPerfStatus(); - // for now set to open - for( integer i=0; i( perfStatusTableName[i] ); - perfStatus[i]=PerforationData::PerforationStatus::OPEN; - if( tableFunction->evaluate( &time_n ) < LvArray::NumericLimits< real64 >::epsilon ) + if( !wellControls.getWellState() ) { - perfStatus[i]=PerforationData::PerforationStatus::CLOSED; - } - } + wellControls.setWellState( 1 ); - array1d< localIndex > const perfWellElemIndex = perforationData.getField< fields::perforation::wellElementIndex >(); - // global index local elements (size == subregion.size) - arrayView1d< globalIndex const > globalWellElementIndex = subRegion.getGlobalWellElementIndex(); - - arrayView1d< integer const > const elemGhostRank = subRegion.ghostRank(); - array1d< integer > & currentStatus = subRegion.getWellElementStatus(); - // Local elements - array1d< integer > & localElemStatus = subRegion.getWellLocalElementStatus(); - - integer numLocalElements = subRegion.getNumLocalElements(); - array1d< integer > segStatus( numLocalElements ); - - // Local perforations - for( integer j = 0; j < perforationData.size(); j++ ) - { - localIndex const iwelem = perfWellElemIndex[j]; - if( elemGhostRank[iwelem] < 0 ) - { - if( perfStatus[j] ) - { - segStatus[iwelem] +=1; - } + initializeWell( domain, meshLevel, subRegion, time_n ); } } - // Broadcast segment status so all cores have same well status - subRegion.setElementStatus( segStatus ); - integer numOpenElements = 0; - array1d< integer > const & updatedStatus = subRegion.getWellElementStatus(); - for( integer i=0; i0 ? wellControls.setWellStatus( time_n, WellControls::Status::OPEN ) : wellControls.setWellStatus( time_n, WellControls::Status::CLOSED ); - - // Set local well element status array - for( integer i=0; i const & localMatrix, arrayView1d< real64 > const & localRhs ) { - string const wellDofKey = dofManager.getKey( wellElementDofName()); + + + // selects constraints one of 2 ways + // wellEstimator flag set to 0 => orginal logic rates are computed during update state and constraints are selected every newton + // iteration + // wellEstimator flag > 0 => well esitmator solved for each constraint and then selects the constraint + // => estimator solve only performed first "wellEstimator" iterations + NonlinearSolverParameters const & nonlinearParams = getNonlinearSolverParameters(); + selectWellConstraint( time, dt, nonlinearParams.m_numNewtonIterations, domain ); + + // assemble the accumulation term in the mass balance equations assembleAccumulationTerms( time, dt, domain, dofManager, localMatrix, localRhs ); // then assemble the pressure relations between well elements - assemblePressureRelations( time, dt, domain, dofManager, localMatrix, localRhs ); + //assemblePressureRelations( time, dt, domain, dofManager, localMatrix, localRhs ); + + forDiscretizationOnMeshTargets( domain.getMeshBodies(), [&]( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + ElementRegionManager & elementRegionManager = mesh.getElemManager(); + elementRegionManager.forElementRegions< WellElementRegion >( regionNames, + [&]( localIndex const, + WellElementRegion & region ) + { + WellElementSubRegion & subRegion = region.getGroup( ElementRegionBase::viewKeyStruct::elementSubRegions() ) + .getGroup< WellElementSubRegion >( region.getSubRegionName() ); + assembleWellConstraintTerms( time, dt, subRegion, dofManager, localMatrix.toViewConstSizes(), localRhs ); + } ); + } ); + // then compute the perforation rates (later assembled by the coupled solver) computePerforationRates( time, dt, domain ); @@ -392,8 +392,15 @@ void WellSolverBase::precomputeData( DomainPartition & domain ) wellElemGravCoef[iwelem] = LvArray::tensorOps::AiBi< 3 >( wellElemLocation[iwelem], gravVector ); } ); + wellControls.forSubGroups< MinimumBHPConstraint, MaximumBHPConstraint >( [&]( auto & constraint ) + { + // set the reference well element where the BHP control is applied + real64 const refElev1 = constraint.getReferenceElevation(); + constraint.setReferenceGravityCoef( refElev1 * gravVector[2] ); + } ); + // set the reference well element where the BHP control is applied - wellControls.setReferenceGravityCoef( refElev * gravVector[2] ); + wellControls.setReferenceGravityCoef( refElev * gravVector[2] ); // tjb remove } ); } ); } diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.hpp index 0f9bd2615b6..6df24834262 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBase.hpp @@ -20,13 +20,13 @@ #ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLSOLVERBASE_HPP_ #define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLSOLVERBASE_HPP_ -#include "physicsSolvers/PhysicsSolverBase.hpp" - +#include "physicsSolvers/fluidFlow/wells/WellControls.hpp" +#include "dataRepository/Group.hpp" namespace geos { class DomainPartition; -class WellControls; + class WellElementSubRegion; /** @@ -35,7 +35,7 @@ class WellElementSubRegion; * Base class for well solvers. * Provides some common features */ -class WellSolverBase : public PhysicsSolverBase +class WellSolverBase : public WellControls { public: @@ -60,7 +60,7 @@ class WellSolverBase : public PhysicsSolverBase WellSolverBase( WellSolverBase const & ) = delete; /// default move constructor - WellSolverBase( WellSolverBase && ) = default; + WellSolverBase( WellSolverBase && ) = delete; /// deleted assignment operator WellSolverBase & operator=( WellSolverBase const & ) = delete; @@ -128,6 +128,12 @@ class WellSolverBase : public PhysicsSolverBase */ virtual localIndex numFluidPhases() const = 0; + /** + * @brief getter for the well associated to this subRegion + * @param subRegion the well subRegion whose controls are requested + * @return a reference to the well + */ + WellSolverBase & getWell( WellElementSubRegion const & subRegion ); /** * @brief getter for the well controls associated to this well subRegion * @param subRegion the well subRegion whose controls are requested @@ -149,27 +155,63 @@ class WellSolverBase : public PhysicsSolverBase * @param domain the domain */ void setPerforationStatus( real64 const & time_n, DomainPartition & domain ); - + void setPerforationStatus( real64 const & time_n, WellElementSubRegion & subRegion ); /** * @defgroup Solver Interface Functions * * These functions provide the primary interface that is required for derived classes + * The "Well" versions apply to individual well subRegions, whereas the others apply to all wells + */ /**@{*/ virtual void registerDataOnMesh( Group & meshBodies ) override; + virtual real64 + calculateWellResidualNorm( real64 const & GEOS_UNUSED_PARAM( time_n ), + real64 const & GEOS_UNUSED_PARAM( dt ), + WellElementSubRegion const & GEOS_UNUSED_PARAM( subRegion ), + DofManager const & GEOS_UNUSED_PARAM( dofManager ), + arrayView1d< real64 const > const & GEOS_UNUSED_PARAM( localRhs ) ) = 0; + + virtual real64 + scalingForWellSystemSolution( ElementSubRegionBase & GEOS_UNUSED_PARAM( subRegion ), + DofManager const & GEOS_UNUSED_PARAM( dofManager ), + arrayView1d< real64 const > const & GEOS_UNUSED_PARAM( localSolution ) ) = 0; + + virtual bool + checkWellSystemSolution( ElementSubRegionBase & GEOS_UNUSED_PARAM( subRegion ), + DofManager const & GEOS_UNUSED_PARAM( dofManager ), + arrayView1d< real64 const > const & GEOS_UNUSED_PARAM( localSolution ), + real64 const GEOS_UNUSED_PARAM( scalingFactor ) ) = 0; + virtual void + applyWellSystemSolution( DofManager const & GEOS_UNUSED_PARAM( dofManager ), + arrayView1d< real64 const > const & GEOS_UNUSED_PARAM( localSolution ), + real64 const GEOS_UNUSED_PARAM( scalingFactor ), + real64 const GEOS_UNUSED_PARAM( dt ), + DomainPartition & GEOS_UNUSED_PARAM( domain ), + MeshLevel & GEOS_UNUSED_PARAM( mesh ), + WellElementSubRegion & GEOS_UNUSED_PARAM( subRegion ) ) = 0; + + /** + * @brief function to set the next time step size + * @param[in] currentTime the current time + * @param[in] currentDt the current time step size + * @param[in] domain the domain object + * @return the prescribed time step size + */ + virtual real64 setNextDt( real64 const & currentTime, + real64 const & currentDt, + DomainPartition & domain ) override; virtual void setupDofs( DomainPartition const & domain, DofManager & dofManager ) const override; - virtual void implicitStepSetup( real64 const & time_n, - real64 const & dt, - DomainPartition & domain ) override; virtual void implicitStepComplete( real64 const & GEOS_UNUSED_PARAM( time_n ), real64 const & GEOS_UNUSED_PARAM( dt ), DomainPartition & GEOS_UNUSED_PARAM( domain ) ) override {} + virtual void applyBoundaryConditions( real64 const GEOS_UNUSED_PARAM( time_n ), real64 const GEOS_UNUSED_PARAM( dt ), DomainPartition & GEOS_UNUSED_PARAM( domain ), @@ -177,17 +219,23 @@ class WellSolverBase : public PhysicsSolverBase CRSMatrixView< real64, globalIndex const > const & GEOS_UNUSED_PARAM( localMatrix ), arrayView1d< real64 > const & GEOS_UNUSED_PARAM( localRhs ) ) override {} + /** + * @brief Selects the active well constraint based on current conditions + * @param[in] currentTime the current time + * @param[in] currentDt the current time step size + * @param[in] coupledIterationNumber the current coupled iteration number + * @param[in] domain the domain object + * @return the prescribed time step size + */ + void selectWellConstraint( real64 const & time_n, + real64 const & dt, + integer const coupledIterationNumber, + DomainPartition & domain ); /**@}*/ /** - * @brief function to assemble the linear system matrix and rhs - * @param time the time at the beginning of the step - * @param dt the desired timestep - * @param domain the domain partition - * @param dofManager degree-of-freedom manager associated with the linear system - * @param matrix the system matrix - * @param rhs the system right-hand side vector + * @copydoc PhysicsSolverBase::assembleSystem() */ virtual void assembleSystem( real64 const time, real64 const dt, @@ -197,14 +245,15 @@ class WellSolverBase : public PhysicsSolverBase arrayView1d< real64 > const & localRhs ) override; /** - * @brief assembles the flux terms for all connections between well elements + * @brief assembles the flux terms for individual well for all connections between well elements * @param time_n previous time value * @param dt time step - * @param domain the physical domain object + * @param subRegion the well subregion containing all the primary and dependent fields * @param dofManager degree-of-freedom manager associated with the linear system * @param matrix the system matrix * @param rhs the system right-hand side vector */ + virtual void assembleFluxTerms( real64 const & time_n, real64 const & dt, DomainPartition & domain, @@ -226,35 +275,39 @@ class WellSolverBase : public PhysicsSolverBase CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) = 0; + + /** - * @brief assembles the pressure relations at all connections between well elements except at the well head - * @param time_n time at the beginning of the time step - * @param dt the time step size - * @param domain the physical domain object - * @param dofManager degree-of-freedom manager associated with the linear system - * @param matrix the system matrix - * @param rhs the system right-hand side vector + * @brief Recompute all dependent quantities from primary variables (including constitutive + * models) + * @param elemManager the element region manager + * @param subRegion the well subRegion containing the well elements and their associated fields */ - virtual void assemblePressureRelations( real64 const & time_n, - real64 const & dt, - DomainPartition const & domain, - DofManager const & dofManager, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) = 0; - + virtual real64 updateWellState( MeshBody const & meshBody, + ElementRegionManager const & elemManager, + WellElementSubRegion & subRegion ) = 0; /** - * @brief Recompute all dependent quantities from primary variables (including constitutive models) + * @brief Recompute all dependent quantities from primary variables (including constitutive + * models) * @param domain the domain containing the mesh and fields */ virtual void updateState( DomainPartition & domain ) override; /** - * @brief Recompute all dependent quantities from primary variables (including constitutive models) - * @param elemManager the elemManager containing the well - * @param subRegion the well subRegion containing the well elements and their associated fields + * @brief Initialize all the primary and secondary variables in all the wells + * @param domain the domain containing the well manager to access individual wells + */ + virtual void initializeWells( DomainPartition & domain, real64 const & time_n ) = 0; + + /** + * @brief Recompute all dependent quantities from primary variables (including constitutive + * models) + * @param elemManager the element region manager + * fields */ virtual real64 updateSubRegionState( WellElementSubRegion & subRegion ) = 0; + /** * @brief Recompute the perforation rates for all the wells * @param domain the domain containing the mesh and fields @@ -263,21 +316,14 @@ class WellSolverBase : public PhysicsSolverBase real64 const & dt, DomainPartition & domain ) = 0; - /** - * @brief function to set the next time step size - * @param[in] currentTime the current time - * @param[in] currentDt the current time step size - * @param[in] domain the domain object - * @return the prescribed time step size - */ - virtual real64 setNextDt( real64 const & currentTime, - real64 const & currentDt, - DomainPartition & domain ) override; /** - * @brief Utility function to keep the well variables during a time step (used in poromechanics simulations) - * @param[in] keepVariablesConstantDuringInitStep flag to tell the solver to freeze its primary variables during a time step - * @detail This function is meant to be called by a specific task before/after the initialization step + * @brief Utility function to keep the well variables during a time step (used in + * poromechanics simulations) + * @param[in] keepVariablesConstantDuringInitStep flag to tell the solver to freeze its + * primary variables during a time step + * @detail This function is meant to be called by a specific task before/after the + * initialization step */ void setKeepVariablesConstantDuringInitStep( bool const keepVariablesConstantDuringInitStep ) { m_keepVariablesConstantDuringInitStep = keepVariablesConstantDuringInitStep; } @@ -287,6 +333,8 @@ class WellSolverBase : public PhysicsSolverBase static constexpr char const * isThermalString() { return "isThermal"; } static constexpr char const * writeCSVFlagString() { return "writeCSV"; } static constexpr char const * timeStepFromTablesFlagString() { return "timeStepFromTables"; } + /// @return string for the targetRegions wrapper + static constexpr char const * targetRegionsString() { return "targetRegions"; } static constexpr char const * fluidNamesString() { return "fluidNames"; } }; @@ -307,11 +355,6 @@ class WellSolverBase : public PhysicsSolverBase virtual void initializePostSubGroups() override; - /** - * @brief Initialize all the primary and secondary variables in all the wells - * @param domain the domain containing the well manager to access individual wells - */ - virtual void initializeWells( DomainPartition & domain, real64 const & time_n ) = 0; /** * @brief Make sure that the well constraints are compatible @@ -327,6 +370,8 @@ class WellSolverBase : public PhysicsSolverBase real64 const & dt, DomainPartition & domain ) = 0; + + /// name of the flow solver string m_flowSolverName; @@ -357,6 +402,10 @@ class WellSolverBase : public PhysicsSolverBase /// name of the fluid constitutive model used as a reference for component/phase description string m_referenceFluidModelName; + + /// flag to use the estimator + integer m_estimateSolution; + }; } diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBaseFields.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBaseFields.hpp index b9dfebc799b..1c4b639f4f7 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBaseFields.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellSolverBaseFields.hpp @@ -31,65 +31,7 @@ namespace fields { namespace well -{ - -DECLARE_FIELD( pressure, - "pressure", - array1d< real64 >, - 0, - LEVEL_0, - WRITE_AND_READ, - "Pressure" ); - -DECLARE_FIELD( pressure_n, - "pressure_n", - array1d< real64 >, - 0, - NOPLOT, - WRITE_AND_READ, - "Pressure at the previous converged time step" ); - -DECLARE_FIELD( temperature, - "temperature", - array1d< real64 >, - 0, - LEVEL_0, - WRITE_AND_READ, - "Temperature" ); - -DECLARE_FIELD( temperature_n, - "temperature_n", - array1d< real64 >, - 0, - NOPLOT, - WRITE_AND_READ, - "Temperature at the previous converged time step" ); - -DECLARE_FIELD( gravityCoefficient, - "gravityCoefficient", - array1d< real64 >, - 0, - NOPLOT, - WRITE_AND_READ, - "Gravity coefficient (dot product of gravity acceleration by gravity vector)" ); - -DECLARE_FIELD( pressureScalingFactor, - "pressureScalingFactor", - array1d< real64 >, - 1, - NOPLOT, - NO_WRITE, - "Scaling factors for pressure" ); - -DECLARE_FIELD( temperatureScalingFactor, - "temperatureScalingFactor", - array1d< real64 >, - 1, - NOPLOT, - NO_WRITE, - "Scaling factors for temperature" ); - -} +{} } diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.cpp new file mode 100644 index 00000000000..e675af7459e --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.cpp @@ -0,0 +1,73 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellVolumeRateConstraint.cpp + */ + +#include "LogLevelsInfo.hpp" +#include "WellVolumeRateConstraint.hpp" +#include "WellConstants.hpp" +#include "dataRepository/InputFlags.hpp" +#include "functions/FunctionManager.hpp" + +namespace geos +{ + +using namespace dataRepository; + +VolumeRateConstraint::VolumeRateConstraint( string const & name, Group * const parent ) + : WellConstraintBase( name, parent ) +{ + this->setInputFlags( InputFlags::OPTIONAL_NONUNIQUE ); + + this->registerWrapper( viewKeyStruct::volumeRateString(), &this->m_constraintValue ). + setDefaultValue( 0.0 ). + setInputFlag( InputFlags::OPTIONAL ). + setRestartFlags( RestartFlags::WRITE_AND_READ ). + setDescription( "Volumetric rate (if useSurfaceConditions: [surface m^3/s]; else [reservoir m^3/s])" ); + +} + +VolumeRateConstraint::~VolumeRateConstraint() +{} + + +void VolumeRateConstraint::postInputInitialization() +{ + // Validate table options + WellConstraintBase::postInputInitialization(); + + // check constraint value + GEOS_THROW_IF( m_constraintValue < 0, + getWrapperDataContext( viewKeyStruct::volumeRateString() ) << ": Target value is negative", + InputError ); + + GEOS_THROW_IF ((m_constraintValue <= 0.0 && m_constraintScheduleTableName.empty()), + getName() << " " << getDataContext() << ": You need to specify a volume rate constraint. \n" << + "The rate constraint can be specified using " << + "either " << viewKeyStruct::volumeRateString() << + " or " << WellConstraintBase::viewKeyStruct::constraintScheduleTableNameString(), + InputError ); +} + +bool VolumeRateConstraint::checkViolation( WellConstraintBase const & currentConstraint, real64 const & currentTime ) const +{ + real64 const currentValue = currentConstraint.totalVolumeRate(); + real64 const constraintValue = this->getConstraintValue( currentTime ); + return ( LvArray::math::abs( currentValue ) > LvArray::math::abs( constraintValue ) ); +} + +} //namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.hpp new file mode 100644 index 00000000000..1ed14597ca3 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.hpp @@ -0,0 +1,124 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 WellVolumeRateConstraints.hpp + */ + + +#ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLTOTALVOLRATECONSTRAINTS_HPP +#define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLTOTALVOLRATECONSTRAINTS_HPP + +#include "common/format/EnumStrings.hpp" +#include "dataRepository/Group.hpp" +#include "functions/TableFunction.hpp" +#include "WellConstraintsBase.hpp" +namespace geos +{ + + + +/** + * @class VolumeRateConstraint + * @brief This class describes a volume rate constraint used to control a well. + */ + +class VolumeRateConstraint : public WellConstraintBase +{ +public: + + /** + * @name Constructor / Destructor + */ + ///@{ + + /** + * @brief Constructor for WellControls Objects. + * @param[in] name the name of this instantiation of WellControls in the repository + * @param[in] parent the parent group of this instantiation of WellControls + */ + explicit VolumeRateConstraint( string const & name, dataRepository::Group * const parent ); + + + /** + * @brief Default destructor. + */ + ~VolumeRateConstraint() override; + + /** + * @brief Deleted default constructor. + */ + VolumeRateConstraint() = delete; + + /** + * @brief Deleted copy constructor. + */ + VolumeRateConstraint( VolumeRateConstraint const & ) = delete; + + /** + * @brief Deleted move constructor. + */ + VolumeRateConstraint( VolumeRateConstraint && ) = delete; + + /** + * @brief Deleted assignment operator. + * @return a reference to a constraint object + */ + VolumeRateConstraint & operator=( VolumeRateConstraint const & ) = delete; + + /** + * @brief Deleted move operator. + * @return a reference to a constraint object + */ + VolumeRateConstraint & operator=( VolumeRateConstraint && ) = delete; + + /** + * @brief name of the node manager in the object catalog + * @return string that contains the catalog name to generate a new Constraint object through the object catalog. + */ + static string catalogName() + { + return "VolumeRateConstraint"; + } + ///@} + /** + * @brief Struct to serve as a container for variable strings and keys. + * @struct viewKeyStruct + */ + struct viewKeyStruct + { + /// String key for the volume rate + static constexpr char const * volumeRateString() { return "volumeRate"; } + }; + /** + * @name Getters / Setters + */ + ///@{ + + // Temp interface - tjb + virtual ConstraintTypeId getControl() const override { return ConstraintTypeId::TOTALVOLRATE; }; + ///@} + + virtual bool checkViolation( WellConstraintBase const & currentConstraint, real64 const & currentTime ) const override; +protected: + + virtual void postInputInitialization() override; + +}; + + +} //namespace geos + +#endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONSTRAINT_HPP diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellConstraintKernels.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellConstraintKernels.hpp new file mode 100644 index 00000000000..f972500e9a3 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellConstraintKernels.hpp @@ -0,0 +1,459 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 CompositionalMultiphaseWellConstraintKernels.hpp + */ + +#ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONSTRAINTKERNELS_HPP +#define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONSTRAINTKERNELS_HPP + +#include "codingUtilities/Utilities.hpp" +#include "common/DataLayouts.hpp" +#include "constitutive/fluid/multifluid/MultiFluidBase.hpp" +#include "constitutive/fluid/multifluid/MultiFluidFields.hpp" + + +#include "physicsSolvers/fluidFlow/wells/WellControls.hpp" +#include "physicsSolvers/fluidFlow/wells/WellBHPConstraints.hpp" +#include "physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.hpp" +#include "physicsSolvers/fluidFlow/wells/WellMassRateConstraint.hpp" +namespace geos +{ + +namespace wellConstraintKernels +{ + +/******************************** ControlEquationHelper ********************************/ +//template< integer NC, integer IS_THERMAL, typname S, typename T > +//struct ConstraintHelper< NC, IS_THERMAL > {}; + +template< integer NC, integer IS_THERMAL, typename CONSTRAINT = BHPConstraint< BHPConstraintTypeId::MIN > > +struct ConstraintHelper +{ + template< BHPConstraintTypeId I > + static void assembleConstraintEquation( real64 const & time_n, + WellControls & wellControls, + BHPConstraint< I > & constraint, + WellElementSubRegion const & subRegion, + string const & wellDofKey, + localIndex const & rankOffset, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + // subRegion data + localIndex const iwelemRef = subRegion.getTopWellElementIndex(); + arrayView1d< globalIndex const > const & wellElemDofNumber = subRegion.getReference< array1d< globalIndex > >( wellDofKey ); + arrayView1d< real64 const > const & pres = subRegion.getField< fields::well::pressure >(); + arrayView1d< real64 const > const & totalMassDens = subRegion.getField< fields::well::totalMassDensity >(); + arrayView2d< real64 const, constitutive::multifluid::USD_FLUID > const & dTotalMassDens = subRegion.getField< fields::well::dTotalMassDensity >(); + arrayView1d< real64 const > const wellElemGravCoef = subRegion.getField< fields::well::gravityCoefficient >(); + + // setup row/column indices for constraint equation + using COFFSET_WJ = compositionalMultiphaseWellKernels::ColOffset_WellJac< NC, IS_THERMAL >; + using WJ_ROFFSET = compositionalMultiphaseWellKernels::RowOffset_WellJac< NC, IS_THERMAL >; + using Deriv = constitutive::multifluid::DerivativeOffset; + + localIndex const eqnRowIndex = wellElemDofNumber[iwelemRef] + WJ_ROFFSET::CONTROL - rankOffset; + globalIndex dofColIndices[COFFSET_WJ::nDer]{}; + for( integer ic = 0; ic < COFFSET_WJ::nDer; ++ic ) + { + dofColIndices[ ic ] = wellElemDofNumber[iwelemRef] + ic; + } + + // constraint data + real64 const & targetBHP = constraint.getConstraintValue( time_n ); + real64 const & refGravCoef = constraint.getReferenceGravityCoef(); + + // current constraint value + real64 const & currentBHP = + wellControls.getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentBHPString() ); + + // residual + real64 controlEqn = currentBHP - targetBHP; + + // setup Jacobian terms + real64 dControlEqn[NC+2+IS_THERMAL]{}; + + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [pres, + totalMassDens, + dTotalMassDens, + wellElemGravCoef, + &dControlEqn, + &iwelemRef, + localRhs, + controlEqn, + eqnRowIndex, + dofColIndices, + localMatrix, + &refGravCoef] ( localIndex const ) + { + real64 const diffGravCoef = refGravCoef - wellElemGravCoef[iwelemRef]; + dControlEqn[COFFSET_WJ::dP] = 1 + dTotalMassDens[iwelemRef][Deriv::dP] * diffGravCoef; + for( integer ic = 0; ic < NC; ++ic ) + { + dControlEqn[COFFSET_WJ::dC+ic] = dTotalMassDens[iwelemRef][Deriv::dC+ic] * diffGravCoef; + } + if constexpr ( IS_THERMAL ) + { + dControlEqn[COFFSET_WJ::dT] = dTotalMassDens[iwelemRef][Deriv::dT] * diffGravCoef; + } + // add solver matrices + localRhs[eqnRowIndex] += controlEqn; + localMatrix.addToRowBinarySearchUnsorted< serialAtomic >( eqnRowIndex, + dofColIndices, + dControlEqn, + COFFSET_WJ::nDer ); + } ); + + + } + + + template< template< typename U > class T, typename U=PhaseVolumeRateConstraint > + static void assembleConstraintEquation( real64 const & time_n, + WellControls & wellControls, + T< PhaseVolumeRateConstraint > & constraint, + WellElementSubRegion const & subRegion, + string const & wellDofKey, + localIndex const & rankOffset, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + // subRegion data + + localIndex const iwelemRef = subRegion.getTopWellElementIndex(); + arrayView1d< globalIndex const > const & wellElemDofNumber = subRegion.getReference< array1d< globalIndex > >( wellDofKey ); + arrayView1d< real64 const > const & connRate = subRegion.getField< fields::well::connectionRate >(); + arrayView2d< real64 const, compflow::USD_COMP > const & compFrac = subRegion.getField< fields::well::globalCompFraction >(); + arrayView3d< real64 const, compflow::USD_COMP_DC > const & dCompFrac_dCompDens = subRegion.getField< fields::well::dGlobalCompFraction_dGlobalCompDensity >(); + + // setup row/column indices for constraint equation + using COFFSET_WJ = compositionalMultiphaseWellKernels::ColOffset_WellJac< NC, IS_THERMAL >; + using WJ_ROFFSET = compositionalMultiphaseWellKernels::RowOffset_WellJac< NC, IS_THERMAL >; + using Deriv = constitutive::multifluid::DerivativeOffset; + + localIndex const eqnRowIndex = wellElemDofNumber[iwelemRef] + WJ_ROFFSET::CONTROL - rankOffset; + globalIndex dofColIndices[COFFSET_WJ::nDer]{}; + for( integer ic = 0; ic < COFFSET_WJ::nDer; ++ic ) + { + dofColIndices[ ic ] = wellElemDofNumber[iwelemRef] + ic; + } + + // fluid data + constitutive::MultiFluidBase & fluidSeparator = wellControls.getMultiFluidSeparator(); + + arrayView3d< real64 const, constitutive::multifluid::USD_PHASE > const & phaseFrac = fluidSeparator.phaseFraction(); + arrayView4d< real64 const, constitutive::multifluid::USD_PHASE_DC > const & dPhaseFrac = fluidSeparator.dPhaseFraction(); + arrayView3d< real64 const, constitutive::multifluid::USD_PHASE > const & phaseDens = fluidSeparator.phaseDensity(); + arrayView4d< real64 const, constitutive::multifluid::USD_PHASE_DC > const & dPhaseDens = fluidSeparator.dPhaseDensity(); + + // constraint data + integer ip = getPhaseIndexFromFluidModel( fluidSeparator, constraint.getPhaseName()); + real64 const & targetPhaseRate = constraint.getConstraintValue( time_n ); + + // current constraint value + arrayView1d< real64 > const & currentPhaseVolRate = + wellControls.getReference< array1d< real64 > >( CompositionalMultiphaseWell::viewKeyStruct::currentPhaseVolRateString() ); + integer const useSurfaceConditions = wellControls.useSurfaceConditions(); + + // residual + real64 controlEqn = currentPhaseVolRate[ip] - targetPhaseRate; + + // setup Jacobian terms + real64 dControlEqn[NC+2+IS_THERMAL]{}; + + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [&ip, + connRate, + phaseDens, + dPhaseDens, + phaseFrac, + dPhaseFrac, + compFrac, + dCompFrac_dCompDens, + &dControlEqn, + &useSurfaceConditions, + localRhs, + controlEqn, + eqnRowIndex, + dofColIndices, + localMatrix, + &iwelemRef] ( localIndex const ) + { + // skip the rest of this function if phase ip is absent + bool const phaseExists = (phaseFrac[iwelemRef][0][ip] > 0); + if( phaseExists ) + { + stackArray1d< real64, NC > work( NC ); + real64 const currentTotalRate = connRate[iwelemRef]; + + real64 const phaseDensInv = 1.0 / phaseDens[iwelemRef][0][ip]; + real64 const phaseFracTimesPhaseDensInv = phaseFrac[iwelemRef][0][ip] * phaseDensInv; + real64 const dPhaseFracTimesPhaseDensInv_dPres = dPhaseFrac[iwelemRef][0][ip][Deriv::dP] * phaseDensInv + - dPhaseDens[iwelemRef][0][ip][Deriv::dP] * phaseFracTimesPhaseDensInv * phaseDensInv; + + // divide the total mass/molar rate by the (phase density * phase fraction) to get the phase volumetric rate + dControlEqn[COFFSET_WJ::dP] = ( useSurfaceConditions == 0 ) * currentTotalRate * dPhaseFracTimesPhaseDensInv_dPres; + dControlEqn[COFFSET_WJ::dQ] = phaseFracTimesPhaseDensInv; + if constexpr (IS_THERMAL ) + { + real64 const dPhaseFracTimesPhaseDensInv_dTemp = dPhaseFrac[iwelemRef][0][ip][Deriv::dT] * phaseDensInv + - dPhaseDens[iwelemRef][0][ip][Deriv::dT] * phaseFracTimesPhaseDensInv * phaseDensInv; + dControlEqn[COFFSET_WJ::dT] = ( useSurfaceConditions == 0 ) * currentTotalRate * dPhaseFracTimesPhaseDensInv_dTemp; + } + + for( integer ic = 0; ic < NC; ++ic ) + { + dControlEqn[COFFSET_WJ::dC+ic] = -phaseFracTimesPhaseDensInv * dPhaseDens[iwelemRef][0][ip][Deriv::dC+ic] * phaseDensInv; + dControlEqn[COFFSET_WJ::dC+ic] += dPhaseFrac[iwelemRef][0][ip][Deriv::dC+ic] * phaseDensInv; + dControlEqn[COFFSET_WJ::dC+ic] *= currentTotalRate; + } + applyChainRuleInPlace( NC, dCompFrac_dCompDens[iwelemRef], &dControlEqn[COFFSET_WJ::dC], work.data() ); + // add solver matrices + localRhs[eqnRowIndex] += controlEqn; + localMatrix.addToRowBinarySearchUnsorted< serialAtomic >( eqnRowIndex, + dofColIndices, + dControlEqn, + COFFSET_WJ::nDer ); + } + } ); + + + } + + template< template< typename U > class T, typename U=VolumeRateConstraint > + static void assembleConstraintEquation( real64 const & time_n, + WellControls & wellControls, + T< VolumeRateConstraint > & constraint, + WellElementSubRegion const & subRegion, + string const & wellDofKey, + localIndex const & rankOffset, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + // subRegion data + + localIndex const iwelemRef = subRegion.getTopWellElementIndex(); + arrayView1d< globalIndex const > const & wellElemDofNumber = subRegion.getReference< array1d< globalIndex > >( wellDofKey ); + arrayView1d< real64 const > const & connRate = subRegion.getField< fields::well::connectionRate >(); + arrayView2d< real64 const, compflow::USD_COMP > const & compFrac = subRegion.getField< fields::well::globalCompFraction >(); + arrayView3d< real64 const, compflow::USD_COMP_DC > const & dCompFrac_dCompDens = subRegion.getField< fields::well::dGlobalCompFraction_dGlobalCompDensity >(); + + // setup row/column indices for constraint equation + using COFFSET_WJ = compositionalMultiphaseWellKernels::ColOffset_WellJac< NC, IS_THERMAL >; + using WJ_ROFFSET = compositionalMultiphaseWellKernels::RowOffset_WellJac< NC, IS_THERMAL >; + using Deriv = constitutive::multifluid::DerivativeOffset; + + localIndex const eqnRowIndex = wellElemDofNumber[iwelemRef] + WJ_ROFFSET::CONTROL - rankOffset; + globalIndex dofColIndices[COFFSET_WJ::nDer]{}; + for( integer ic = 0; ic < COFFSET_WJ::nDer; ++ic ) + { + dofColIndices[ ic ] = wellElemDofNumber[iwelemRef] + ic; + } + + // fluid data + constitutive::MultiFluidBase & fluidSeparator = wellControls.getMultiFluidSeparator(); + + arrayView2d< real64 const, constitutive::multifluid::USD_FLUID > const & totalDens = fluidSeparator.totalDensity(); + arrayView3d< real64 const, constitutive::multifluid::USD_FLUID_DC > const & dTotalDens = fluidSeparator.dTotalDensity(); + + // constraint data + real64 const & targetTotalVolRate = constraint.getConstraintValue( time_n ); + + // current constraint value + real64 const & currentTotalVolRate = + wellControls.getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentTotalVolRateString() ); + integer const useSurfaceConditions = wellControls.useSurfaceConditions(); + + // residual + real64 controlEqn = currentTotalVolRate - targetTotalVolRate; + + // setup Jacobian terms + real64 dControlEqn[NC+2+IS_THERMAL]{}; + + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [connRate, + totalDens, + dTotalDens, + compFrac, + dCompFrac_dCompDens, + &dControlEqn, + &useSurfaceConditions, + localRhs, + controlEqn, + eqnRowIndex, + dofColIndices, + localMatrix, + &iwelemRef] ( localIndex const ) + { + stackArray1d< real64, NC > work( NC ); + + real64 const currentTotalRate = connRate[iwelemRef]; + + // compute the inverse of the total density and derivatives + + real64 const totalDensInv = 1.0 / totalDens[iwelemRef][0]; + + stackArray1d< real64, NC > dTotalDensInv_dCompDens( NC ); + for( integer ic = 0; ic < NC; ++ic ) + { + dTotalDensInv_dCompDens[ic] = -dTotalDens[iwelemRef][0][Deriv::dC+ic] * totalDensInv * totalDensInv; + } + applyChainRuleInPlace( NC, dCompFrac_dCompDens[iwelemRef], dTotalDensInv_dCompDens, work.data() ); + + // Step 2.2: divide the total mass/molar rate by the total density to get the total volumetric rate + + // Compute derivatives dP dT + real64 const dTotalDensInv_dPres = -dTotalDens[iwelemRef][0][Deriv::dP] * totalDensInv * totalDensInv; + dControlEqn[COFFSET_WJ::dP] = ( useSurfaceConditions == 0 ) * currentTotalRate * dTotalDensInv_dPres; + if constexpr ( IS_THERMAL ) + { + dControlEqn[COFFSET_WJ::dT] = ( useSurfaceConditions == 0 ) * currentTotalRate * -dTotalDens[iwelemRef][0][Deriv::dT] * totalDensInv * totalDensInv; + } + + dControlEqn[COFFSET_WJ::dQ] = totalDensInv; + for( integer ic = 0; ic < NC; ++ic ) + { + dControlEqn[COFFSET_WJ::dC+ic] = currentTotalRate * dTotalDensInv_dCompDens[ic]; + } + localRhs[eqnRowIndex] += controlEqn; + localMatrix.addToRowBinarySearchUnsorted< serialAtomic >( eqnRowIndex, + dofColIndices, + dControlEqn, + COFFSET_WJ::nDer ); + } ); + + } + template< template< typename U > class T, typename U=MassRateConstraint > + static void assembleConstraintEquation( real64 const & time_n, + WellControls & wellControls, + T< MassRateConstraint > & constraint, + WellElementSubRegion const & subRegion, + string const & wellDofKey, + localIndex const & rankOffset, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + // subRegion data + + localIndex const iwelemRef = subRegion.getTopWellElementIndex(); + arrayView1d< globalIndex const > const & wellElemDofNumber = subRegion.getReference< array1d< globalIndex > >( wellDofKey ); + arrayView1d< real64 const > const & connRate = subRegion.getField< fields::well::connectionRate >(); + arrayView2d< real64 const, compflow::USD_COMP > const & compFrac = subRegion.getField< fields::well::globalCompFraction >(); + arrayView3d< real64 const, compflow::USD_COMP_DC > const & dCompFrac_dCompDens = subRegion.getField< fields::well::dGlobalCompFraction_dGlobalCompDensity >(); + + // setup row/column indices for constraint equation + using COFFSET_WJ = compositionalMultiphaseWellKernels::ColOffset_WellJac< NC, IS_THERMAL >; + using WJ_ROFFSET = compositionalMultiphaseWellKernels::RowOffset_WellJac< NC, IS_THERMAL >; + using Deriv = constitutive::multifluid::DerivativeOffset; + + localIndex const eqnRowIndex = wellElemDofNumber[iwelemRef] + WJ_ROFFSET::CONTROL - rankOffset; + globalIndex dofColIndices[COFFSET_WJ::nDer]{}; + for( integer ic = 0; ic < COFFSET_WJ::nDer; ++ic ) + { + dofColIndices[ ic ] = wellElemDofNumber[iwelemRef] + ic; + } + + // fluid data + constitutive::MultiFluidBase & fluidSeparator = wellControls.getMultiFluidSeparator(); + arrayView2d< real64 const, constitutive::multifluid::USD_FLUID > const & totalDens = fluidSeparator.totalDensity(); + arrayView3d< real64 const, constitutive::multifluid::USD_FLUID_DC > const & dTotalDens = fluidSeparator.dTotalDensity(); + + // constraint data + real64 const & targetMassRate = constraint.getConstraintValue( time_n ); + + // current constraint value + real64 const & massDensity = + wellControls.getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::massDensityString() ); + + // fix to use stored massrate + real64 const & currentTotalVolRate = + wellControls.getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentTotalVolRateString() ); + integer const useSurfaceConditions = wellControls.useSurfaceConditions(); + + // residual + real64 controlEqn = massDensity*currentTotalVolRate - targetMassRate; + + // setup Jacobian terms + real64 dControlEqn[NC+2+IS_THERMAL]{}; + + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [connRate, + massDensity, + totalDens, + dTotalDens, + compFrac, + dCompFrac_dCompDens, + &dControlEqn, + &useSurfaceConditions, + localRhs, + controlEqn, + eqnRowIndex, + dofColIndices, + localMatrix, + &iwelemRef] ( localIndex const ) + { + stackArray1d< real64, NC > work( NC ); + + real64 const currentTotalRate = connRate[iwelemRef]; + + // compute the inverse of the total density and derivatives + + real64 const totalDensInv = 1.0 / totalDens[iwelemRef][0]; + + stackArray1d< real64, NC > dTotalDensInv_dCompDens( NC ); + for( integer ic = 0; ic < NC; ++ic ) + { + dTotalDensInv_dCompDens[ic] = -dTotalDens[iwelemRef][0][Deriv::dC+ic] * totalDensInv * totalDensInv; + } + applyChainRuleInPlace( NC, dCompFrac_dCompDens[iwelemRef], dTotalDensInv_dCompDens, work.data() ); + + // Step 2.2: divide the total mass/molar rate by the total density to get the total volumetric rate + + // Compute derivatives dP dT + real64 const dTotalDensInv_dPres = -dTotalDens[iwelemRef][0][Deriv::dP] * totalDensInv * totalDensInv; + dControlEqn[COFFSET_WJ::dP] = ( useSurfaceConditions == 0 )*massDensity * currentTotalRate * dTotalDensInv_dPres; + if constexpr ( IS_THERMAL ) + { + dControlEqn[COFFSET_WJ::dT] = ( useSurfaceConditions == 0 ) * massDensity* currentTotalRate * -dTotalDens[iwelemRef][0][Deriv::dT] * totalDensInv * totalDensInv; + } + + dControlEqn[COFFSET_WJ::dQ] = massDensity*totalDensInv; + for( integer ic = 0; ic < NC; ++ic ) + { + dControlEqn[COFFSET_WJ::dC+ic] = massDensity* currentTotalRate * dTotalDensInv_dCompDens[ic]; + } + + // add solver matrices + localRhs[eqnRowIndex] += controlEqn; + localMatrix.addToRowBinarySearchUnsorted< serialAtomic >( eqnRowIndex, + dofColIndices, + dControlEqn, + COFFSET_WJ::nDer ); + + } ); + + } +}; + + +} // end namespace wellConstraintKernels + +} // end namespace geos + +#endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONSTRAINTKERNELS_HPP diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellKernels.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellKernels.cpp index ab153369374..2347657946d 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellKernels.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellKernels.cpp @@ -31,214 +31,6 @@ namespace compositionalMultiphaseWellKernels using namespace constitutive; -/******************************** ControlEquationHelper ********************************/ - -GEOS_HOST_DEVICE -inline -void -ControlEquationHelper:: - switchControl( bool const isProducer, - WellControls::Control const & inputControl, - WellControls::Control const & currentControl, - integer const phasePhaseIndex, - real64 const & targetBHP, - real64 const & targetPhaseRate, - real64 const & targetTotalRate, - real64 const & targetMassRate, - real64 const & currentBHP, - arrayView1d< real64 const > const & currentPhaseVolRate, - real64 const & currentTotalVolRate, - real64 const & currentMassRate, - WellControls::Control & newControl ) -{ - // if isViable is true at the end of the following checks, no need to switch - bool controlIsViable = false; - - // The limiting flow rates are treated as upper limits, while the pressure limits - // are treated as lower limits in production wells and upper limits in injectors. - // The well changes its mode of control whenever the existing control mode would - // violate one of these limits. - - // Currently, the available constraints are: - // - Producer: BHP, PHASEVOLRATE - // - Injector: BHP, TOTALVOLRATE, MASSRATE - - // TODO: support GRAT, WRAT, LIQUID for producers and check if any of the active constraint is violated - - // BHP control - if( currentControl == WellControls::Control::BHP ) - { - // the control is viable if the reference oil rate is below the max rate for producers - if( isProducer ) - { - controlIsViable = ( LvArray::math::abs( currentPhaseVolRate[phasePhaseIndex] ) <= LvArray::math::abs( targetPhaseRate ) ); - } - // the control is viable if the reference total rate is below the max rate for injectors - else if( inputControl == WellControls::Control::MASSRATE ) - { - controlIsViable = ( LvArray::math::abs( currentMassRate ) <= LvArray::math::abs( targetMassRate ) ); - } - else - { - controlIsViable = ( LvArray::math::abs( currentTotalVolRate ) <= LvArray::math::abs( targetTotalRate ) ); - } - } - else // rate control - { - // the control is viable if the reference pressure is below/above the max/min pressure - if( isProducer ) - { - // targetBHP specifies a min pressure here - controlIsViable = ( currentBHP >= targetBHP ); - } - else - { - // targetBHP specifies a max pressure here - controlIsViable = ( currentBHP <= targetBHP ); - } - } - - if( controlIsViable ) - { - newControl = currentControl; - } - else - { - if( isProducer ) - { - newControl = ( currentControl == WellControls::Control::BHP ) - ? WellControls::Control::PHASEVOLRATE - : WellControls::Control::BHP; - } - else - { - if( isZero( targetMassRate ) ) - { - newControl = ( currentControl == WellControls::Control::BHP ) - ? WellControls::Control::TOTALVOLRATE - : WellControls::Control::BHP; - } - else - { - newControl = ( currentControl == WellControls::Control::BHP ) - ? WellControls::Control::MASSRATE - : WellControls::Control::BHP; - } - } - } -} - -template< integer NC, integer IS_THERMAL > -GEOS_HOST_DEVICE -inline -void -ControlEquationHelper:: - compute( globalIndex const rankOffset, - WellControls::Control const currentControl, - integer const targetPhaseIndex, - real64 const & targetBHP, - real64 const & targetPhaseRate, - real64 const & targetTotalRate, - real64 const & targetMassRate, - real64 const & currentBHP, - arrayView1d< real64 const > const & dCurrentBHP, - arrayView1d< real64 const > const & currentPhaseVolRate, - arrayView2d< real64 const > const & dCurrentPhaseVolRate, - - real64 const & currentTotalVolRate, - arrayView1d< real64 const > const & dCurrentTotalVolRate, - real64 const & massDensity, - globalIndex const dofNumber, - CRSMatrixView< real64, globalIndex const > const & localMatrix, - arrayView1d< real64 > const & localRhs ) -{ - - using COFFSET_WJ = compositionalMultiphaseWellKernels::ColOffset_WellJac< NC, IS_THERMAL >; - using Deriv = multifluid::DerivativeOffset; - - localIndex const eqnRowIndex = dofNumber + ROFFSET::CONTROL - rankOffset; - globalIndex dofColIndices[COFFSET_WJ::nDer]{}; - for( integer ic = 0; ic < COFFSET_WJ::nDer; ++ic ) - { - dofColIndices[ ic ] = dofNumber + ic; - } - - real64 controlEqn = 0; - real64 dControlEqn[NC+2+IS_THERMAL]{}; - - // Note: We assume in the computation of currentBHP that the reference elevation - // is in the top well element. This is enforced by a check in the solver. - // If we wanted to allow the reference elevation to be outside the top - // well element, it would make more sense to check the BHP constraint in - // the well element that contains the reference elevation. - - // BHP control - if( currentControl == WellControls::Control::BHP ) - { - // control equation is a difference between current BHP and target BHP - controlEqn = currentBHP - targetBHP; - dControlEqn[COFFSET_WJ::dP] = dCurrentBHP[Deriv::dP]; - for( integer ic = 0; ic < NC; ++ic ) - { - dControlEqn[COFFSET_WJ::dC+ic] = dCurrentBHP[Deriv::dC+ic]; - } - if constexpr ( IS_THERMAL ) - - dControlEqn[COFFSET_WJ::dT] = dCurrentBHP[Deriv::dT]; - - } - // Oil volumetric rate control - else if( currentControl == WellControls::Control::PHASEVOLRATE ) - { - controlEqn = currentPhaseVolRate[targetPhaseIndex] - targetPhaseRate; - dControlEqn[COFFSET_WJ::dP] = dCurrentPhaseVolRate[targetPhaseIndex][COFFSET_WJ::dP]; - dControlEqn[COFFSET_WJ::dQ] = dCurrentPhaseVolRate[targetPhaseIndex][COFFSET_WJ::dQ]; - for( integer ic = 0; ic < NC; ++ic ) - { - dControlEqn[COFFSET_WJ::dC+ic] = dCurrentPhaseVolRate[targetPhaseIndex][COFFSET_WJ::dC+ic]; - } - if constexpr ( IS_THERMAL ) - dControlEqn[COFFSET_WJ::dT] = dCurrentPhaseVolRate[targetPhaseIndex][COFFSET_WJ::dT]; - } - // Total volumetric rate control - else if( currentControl == WellControls::Control::TOTALVOLRATE ) - { - controlEqn = currentTotalVolRate - targetTotalRate; - dControlEqn[COFFSET_WJ::dP] = dCurrentTotalVolRate[COFFSET_WJ::dP]; - dControlEqn[COFFSET_WJ::dQ] = dCurrentTotalVolRate[COFFSET_WJ::dQ]; - for( integer ic = 0; ic < NC; ++ic ) - { - dControlEqn[COFFSET_WJ::dC+ic] = dCurrentTotalVolRate[COFFSET_WJ::dC+ic]; - } - if constexpr ( IS_THERMAL ) - dControlEqn[COFFSET_WJ::dT] = dCurrentTotalVolRate[COFFSET_WJ::dT]; - } - // Total mass rate control - else if( currentControl == WellControls::Control::MASSRATE ) - { - controlEqn = massDensity*currentTotalVolRate - targetMassRate; - dControlEqn[COFFSET_WJ::dP] = massDensity*dCurrentTotalVolRate[COFFSET_WJ::dP]; - dControlEqn[COFFSET_WJ::dQ] = massDensity*dCurrentTotalVolRate[COFFSET_WJ::dQ]; - for( integer ic = 0; ic < NC; ++ic ) - { - dControlEqn[COFFSET_WJ::dC+ic] = massDensity*dCurrentTotalVolRate[COFFSET_WJ::dC+ic]; - } - if constexpr ( IS_THERMAL ) - dControlEqn[COFFSET_WJ::dT] = massDensity*dCurrentTotalVolRate[COFFSET_WJ::dT]; - } - else - { - GEOS_ERROR( "This constraint is not supported in CompositionalMultiphaseWell" ); - } - localRhs[eqnRowIndex] += controlEqn; - - localMatrix.addToRowBinarySearchUnsorted< serialAtomic >( eqnRowIndex, - dofColIndices, - dControlEqn, - COFFSET_WJ::nDer ); - - -} /******************************** PressureRelationKernel ********************************/ @@ -300,11 +92,6 @@ void PressureRelationKernel:: launch( localIndex const size, globalIndex const rankOffset, - bool const isLocallyOwned, - localIndex const iwelemControl, - integer const targetPhaseIndex, - WellControls const & wellControls, - real64 const & time, arrayView1d< integer const > const elemStatus, arrayView1d< globalIndex const > const & wellElemDofNumber, arrayView1d< real64 const > const & wellElemGravCoef, @@ -317,36 +104,6 @@ PressureRelationKernel:: arrayView1d< real64 > const & localRhs ) { using COFFSET_WJ = compositionalMultiphaseWellKernels::ColOffset_WellJac< NC, IS_THERMAL >; - // static well control data - bool const isProducer = wellControls.isProducer(); - WellControls::Control const currentControl = wellControls.getControl(); - WellControls::Control const inputControl = wellControls.getInputControl(); - real64 const targetBHP = wellControls.getTargetBHP( time ); - real64 const targetTotalRate = wellControls.getTargetTotalRate( time ); - real64 const targetPhaseRate = wellControls.getTargetPhaseRate( time ); - real64 const targetMassRate = wellControls.getTargetMassRate( time ); - - // dynamic well control data - real64 const & currentBHP = - wellControls.getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentBHPString() ); - arrayView1d< real64 const > const & dCurrentBHP = - wellControls.getReference< array1d< real64 > >( CompositionalMultiphaseWell::viewKeyStruct::dCurrentBHPString() ); - - arrayView1d< real64 const > const & currentPhaseVolRate = - wellControls.getReference< array1d< real64 > >( CompositionalMultiphaseWell::viewKeyStruct::currentPhaseVolRateString() ); - arrayView2d< real64 const > const & dCurrentPhaseVolRate = - wellControls.getReference< array2d< real64 > >( CompositionalMultiphaseWell::viewKeyStruct::dCurrentPhaseVolRateString() ); - - real64 const & currentTotalVolRate = - wellControls.getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentTotalVolRateString() ); - arrayView1d< real64 const > const & dCurrentTotalVolRate = - wellControls.getReference< array1d< real64 > >( CompositionalMultiphaseWell::viewKeyStruct::dCurrentTotalVolRateString() ); - - real64 const & currentMassRate = - wellControls.getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::currentMassRateString() ); - - real64 const & massDensity = - wellControls.getReference< real64 >( CompositionalMultiphaseWell::viewKeyStruct::massDensityString() ); RAJA::ReduceMax< parallelDeviceReduce, localIndex > switchControl( 0 ); @@ -360,48 +117,7 @@ PressureRelationKernel:: localIndex const iwelemNext = nextWellElemIndex[iwelem]; - if( iwelemNext < 0 && isLocallyOwned ) // if iwelemNext < 0, form control equation - { - - WellControls::Control newControl = currentControl; - ControlEquationHelper::switchControl( isProducer, - inputControl, - currentControl, - targetPhaseIndex, - targetBHP, - targetPhaseRate, - targetTotalRate, - targetMassRate, - currentBHP, - currentPhaseVolRate, - currentTotalVolRate, - currentMassRate, - newControl ); - if( currentControl != newControl ) - { - switchControl.max( 1 ); - } - ControlEquationHelper::compute< NC, IS_THERMAL >( rankOffset, - newControl, - targetPhaseIndex, - targetBHP, - targetPhaseRate, - targetTotalRate, - targetMassRate, - currentBHP, - dCurrentBHP, - currentPhaseVolRate, - dCurrentPhaseVolRate, - currentTotalVolRate, - dCurrentTotalVolRate, - massDensity, - wellElemDofNumber[iwelemControl], - localMatrix, - localRhs ); - // TODO: for consistency, we should assemble here, not in compute... - - } - else if( iwelemNext >= 0 ) // if iwelemNext >= 0, form momentum equation + if( iwelemNext >= 0 ) // if iwelemNext >= 0, form momentum equation { real64 localPresRel = 0; @@ -455,11 +171,6 @@ PressureRelationKernel:: void PressureRelationKernel:: \ launch< NC, IS_THERMAL >( localIndex const size, \ globalIndex const rankOffset, \ - bool const isLocallyOwned, \ - localIndex const iwelemControl, \ - integer const targetPhaseIndex, \ - WellControls const & wellControls, \ - real64 const & time, \ arrayView1d< integer const > const elemStatus, \ arrayView1d< globalIndex const > const & wellElemDofNumber, \ arrayView1d< real64 const > const & wellElemGravCoef, \ @@ -489,6 +200,7 @@ PresTempCompFracInitializationKernel:: integer const numComps, integer const numPhases, WellControls const & wellControls, + real64 const & refWellElemGravCoef, real64 const & currentTime, ElementViewConst< arrayView1d< real64 const > > const & resPres, ElementViewConst< arrayView1d< real64 const > > const & resTemp, @@ -508,9 +220,8 @@ PresTempCompFracInitializationKernel:: integer constexpr MAX_NUM_COMP = constitutive::MultiFluidBase::MAX_NUM_COMPONENTS; real64 const targetBHP = wellControls.getTargetBHP( currentTime ); - real64 const refWellElemGravCoef = wellControls.getReferenceGravityCoef(); real64 const initialPresCoef = wellControls.getInitialPressureCoefficient(); - WellControls::Control const currentControl = wellControls.getControl(); + ConstraintTypeId const currentControl = wellControls.getControl(); bool const isProducer = wellControls.isProducer(); @@ -608,7 +319,7 @@ PresTempCompFracInitializationKernel:: real64 refPres = 0.0; // if the well is controlled by pressure, initialize the reference pressure at the target pressure - if( currentControl == WellControls::Control::BHP ) + if( currentControl == ConstraintTypeId::BHP ) { refPres = targetBHP; } @@ -716,62 +427,96 @@ CompDensInitializationKernel:: void RateInitializationKernel:: launch( localIndex const subRegionSize, - integer const targetPhaseIndex, WellControls const & wellControls, real64 const & time, arrayView3d< real64 const, multifluid::USD_PHASE > const & phaseDens, arrayView2d< real64 const, multifluid::USD_FLUID > const & totalDens, arrayView1d< real64 > const & connRate ) { - WellControls::Control const control = wellControls.getControl(); - bool const isProducer = wellControls.isProducer(); - real64 const targetTotalRate = wellControls.getTargetTotalRate( time ); - real64 const targetPhaseRate = wellControls.getTargetPhaseRate( time ); - real64 const targetMassRate = wellControls.getTargetMassRate( time ); - - // Estimate the connection rates - forAll< parallelDevicePolicy<> >( subRegionSize, [=] GEOS_HOST_DEVICE ( localIndex const iwelem ) + if( wellControls.isProducer() ) { - if( control == WellControls::Control::BHP ) + // Use use defined control type to set initial connection rates + WellConstraintBase const * constraint = wellControls.getCurrentConstraint(); + real64 const constraintVal = constraint->getConstraintValue( time ); + ConstraintTypeId const controlType = constraint->getControl(); + if( controlType == ConstraintTypeId::PHASEVOLRATE ) { - // if BHP constraint set rate below the absolute max rate - // with the appropriate sign (negative for prod, positive for inj) - if( isProducer ) + integer const targetPhaseIndex = wellControls.getConstraintPhaseIndex(); + + forAll< parallelDevicePolicy<> >( subRegionSize, [=] GEOS_HOST_DEVICE ( localIndex const iwelem ) { - connRate[iwelem] = LvArray::math::max( 0.1 * targetPhaseRate * phaseDens[iwelem][0][targetPhaseIndex], -1e3 ); - } - else + connRate[iwelem] = constraintVal * phaseDens[iwelem][0][targetPhaseIndex]; + } ); + } + else if( controlType == ConstraintTypeId::TOTALVOLRATE ) + { + forAll< parallelDevicePolicy<> >( subRegionSize, [=] GEOS_HOST_DEVICE ( localIndex const iwelem ) { - if( isZero( targetMassRate ) ) - { - connRate[iwelem] = LvArray::math::min( 0.1 * targetTotalRate * totalDens[iwelem][0], 1e3 ); - } - else - { - connRate[iwelem] = targetMassRate; - } + connRate[iwelem] = LvArray::math::max( 0.1 * constraintVal * totalDens[iwelem][0], -1e3 ); + } ); + } + else if( controlType == ConstraintTypeId::MASSRATE ) + { + forAll< parallelDevicePolicy<> >( subRegionSize, [=] GEOS_HOST_DEVICE ( localIndex const iwelem ) + { + connRate[iwelem] = constraintVal; + } ); + } + else if( controlType == ConstraintTypeId::BHP ) + { + // this assumes phase control present + integer const targetPhaseIndex = wellControls.getConstraintPhaseIndex(); + auto const * rateConstraint = wellControls.getRateConstraints().front(); + // Use first rate constraint to set initial connection rates + real64 const rateVal = rateConstraint->getConstraintValue( time ); + forAll< parallelDevicePolicy<> >( subRegionSize, [=] GEOS_HOST_DEVICE ( localIndex const iwelem ) + { + connRate[iwelem] = LvArray::math::max( 0.1 * rateVal * phaseDens[iwelem][0][targetPhaseIndex], -1e3 ); + } ); + } + } + else + { + // Use use defined control type to set initial connection rates + WellConstraintBase const * constraint = wellControls.getCurrentConstraint(); + real64 const constraintVal = constraint->getConstraintValue( time ); + ConstraintTypeId const controlType = constraint->getControl(); + if( controlType == ConstraintTypeId::PHASEVOLRATE ) + { + integer const targetPhaseIndex = wellControls.getConstraintPhaseIndex(); - } + forAll< parallelDevicePolicy<> >( subRegionSize, [=] GEOS_HOST_DEVICE ( localIndex const iwelem ) + { + connRate[iwelem] = LvArray::math::max( 0.1 * constraintVal * phaseDens[iwelem][0][targetPhaseIndex], 1e3 ); + } ); } - else if( control == WellControls::Control::MASSRATE ) + else if( controlType == ConstraintTypeId::TOTALVOLRATE ) { - connRate[iwelem] = targetMassRate; + forAll< parallelDevicePolicy<> >( subRegionSize, [=] GEOS_HOST_DEVICE ( localIndex const iwelem ) + { + connRate[iwelem] = constraintVal * totalDens[iwelem][0]; + } ); } - else + else if( controlType == ConstraintTypeId::MASSRATE ) { - if( isProducer ) + forAll< parallelDevicePolicy<> >( subRegionSize, [=] GEOS_HOST_DEVICE ( localIndex const iwelem ) { - connRate[iwelem] = targetPhaseRate * phaseDens[iwelem][0][targetPhaseIndex]; - } - else + connRate[iwelem] = constraintVal; + } ); + } + else if( controlType == ConstraintTypeId::BHP ) + { + auto const * rateConstraint = wellControls.getRateConstraints().front(); + // Use first rate constraint to set initial connection rates + real64 const rateVal = rateConstraint->getConstraintValue( time ); + forAll< parallelDevicePolicy<> >( subRegionSize, [=] GEOS_HOST_DEVICE ( localIndex const iwelem ) { - connRate[iwelem] = targetTotalRate * totalDens[iwelem][0]; - } + connRate[iwelem] = LvArray::math::min( 0.1 * rateVal * totalDens[iwelem][0], 1e3 ); + } ); } - } ); + } } - } // end namespace compositionalMultiphaseWellKernels } // end namespace geos diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellKernels.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellKernels.hpp index a8123abbb12..bc6dab29af6 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellKernels.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellKernels.hpp @@ -39,7 +39,8 @@ #include "physicsSolvers/fluidFlow/kernels/compositional/SolutionCheckKernel.hpp" #include "physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWellFields.hpp" #include "physicsSolvers/fluidFlow/wells/WellControls.hpp" -#include "physicsSolvers/fluidFlow/wells/WellSolverBaseFields.hpp" +#include "physicsSolvers/fluidFlow/wells/WellFields.hpp" +#include "physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.hpp" namespace geos { @@ -134,32 +135,33 @@ struct ControlEquationHelper inline static void - switchControl( bool const isProducer, - WellControls::Control const & inputControl, - WellControls::Control const & currentControl, - integer const phasePhaseIndex, - real64 const & targetBHP, - real64 const & targetPhaseRate, - real64 const & targetTotalRate, - real64 const & targetMassRate, - real64 const & currentBHP, - arrayView1d< real64 const > const & currentPhaseVolRate, - real64 const & currentTotalVolRate, - real64 const & currentMassRate, - WellControls::Control & newControl ); + selectLimitingConstraint( bool const isProducer, + ConstraintTypeId const & inputControl, + ConstraintTypeId const & currentControl, + integer const phasePhaseIndex, + real64 const & targetBHP, + real64 const & targetPhaseRate, + real64 const & targetTotalRate, + real64 const & targetMassRate, + real64 const & currentBHP, + arrayView1d< real64 const > const & currentPhaseVolRate, + real64 const & currentTotalVolRate, + real64 const & currentMassRate, + ConstraintTypeId & newControl ); template< integer NC, integer IS_THERMAL > GEOS_HOST_DEVICE inline static void compute( globalIndex const rankOffset, - WellControls::Control const currentControl, + ConstraintTypeId const currentControl, integer const targetPhaseIndex, real64 const & targetBHP, real64 const & targetPhaseRate, real64 const & targetTotalRate, real64 const & targetMassRate, real64 const & currentBHP, + real64 const & targetValue, arrayView1d< real64 const > const & dCurrentBHP, arrayView1d< real64 const > const & currentPhaseVolRate, arrayView2d< real64 const > const & dCurrentPhaseVolRate, @@ -200,11 +202,6 @@ struct PressureRelationKernel static void launch( localIndex const size, globalIndex const rankOffset, - bool const isLocallyOwned, - localIndex const iwelemControl, - integer const targetPhaseIndex, - WellControls const & wellControls, - real64 const & time, arrayView1d< integer const > const elemStatus, arrayView1d< globalIndex const > const & wellElemDofNumber, arrayView1d< real64 const > const & wellElemGravCoef, @@ -284,6 +281,7 @@ struct PresTempCompFracInitializationKernel integer const numComponents, integer const numPhases, WellControls const & wellControls, + real64 const & refWellElemGravCoef, real64 const & currentTime, ElementViewConst< arrayView1d< real64 const > > const & resPres, ElementViewConst< arrayView1d< real64 const > > const & resTemp, @@ -323,7 +321,6 @@ struct RateInitializationKernel static void launch( localIndex const subRegionSize, - integer const targetPhaseIndex, WellControls const & wellControls, real64 const & currentTime, arrayView3d< real64 const, constitutive::multifluid::USD_PHASE > const & phaseDens, @@ -505,7 +502,6 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa arrayView1d< localIndex const > const & ghostRank, integer const numComp, integer const numDof, - integer const targetPhaseIndex, WellElementSubRegion const & subRegion, constitutive::MultiFluidBase const & fluid, WellControls const & wellControls, @@ -519,20 +515,34 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa minNormalizer ), m_numComp( numComp ), m_numDof( numDof ), - m_targetPhaseIndex( targetPhaseIndex ), m_dt( dt ), m_isLocallyOwned( subRegion.isLocallyOwned() ), m_iwelemControl( subRegion.getTopWellElementIndex() ), m_isProducer( wellControls.isProducer() ), m_currentControl( wellControls.getControl() ), m_targetBHP( wellControls.getTargetBHP( time ) ), - m_targetTotalRate( wellControls.getTargetTotalRate( time ) ), - m_targetPhaseRate( wellControls.getTargetPhaseRate( time ) ), - m_targetMassRate( wellControls.getTargetMassRate( time ) ), m_volume( subRegion.getElementVolume() ), m_phaseDens_n( fluid.phaseDensity_n() ), m_totalDens_n( fluid.totalDensity_n() ) - {} + { + // Note this assumes that there is only one rate constraint + // This is a normalizer for the balance equations. The normalizaer should be the current rate not the constraint value!! + // This is one of the reasons for restricting constraint type for a production well + // Another pr will remove fix this (so the cause for difference results is isolated to one change) + auto const * rateConstraint = wellControls.getRateConstraints().front(); + if( rateConstraint != nullptr ) + { + m_constraintValue = rateConstraint->getConstraintValue( time ); + } + if( m_isProducer ) + { + m_targetPhaseIndex = wellControls.getConstraintPhaseIndex(); + } + else + { + m_targetPhaseIndex = -1; + } + } GEOS_HOST_DEVICE virtual void computeLinf( localIndex const iwelem, @@ -553,25 +563,25 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa // for the top well element, normalize using the current control if( m_isLocallyOwned && iwelem == m_iwelemControl ) { - if( m_currentControl == WellControls::Control::BHP ) + if( m_currentControl == ConstraintTypeId::BHP ) { // the residual entry is in pressure units normalizer = m_targetBHP; } - else if( m_currentControl == WellControls::Control::TOTALVOLRATE ) + else if( m_currentControl == ConstraintTypeId::TOTALVOLRATE ) { // the residual entry is in volume / time units - normalizer = LvArray::math::max( LvArray::math::abs( m_targetTotalRate ), m_minNormalizer ); + normalizer = LvArray::math::max( LvArray::math::abs( m_constraintValue ), m_minNormalizer ); } - else if( m_currentControl == WellControls::Control::PHASEVOLRATE ) + else if( m_currentControl == ConstraintTypeId::PHASEVOLRATE ) { // the residual entry is in volume / time units - normalizer = LvArray::math::max( LvArray::math::abs( m_targetPhaseRate ), m_minNormalizer ); + normalizer = LvArray::math::max( LvArray::math::abs( m_constraintValue ), m_minNormalizer ); } - else if( m_currentControl == WellControls::Control::MASSRATE ) + else if( m_currentControl == ConstraintTypeId::MASSRATE ) { // the residual entry is in volume / time units - normalizer = LvArray::math::max( LvArray::math::abs( m_targetMassRate ), m_minNormalizer ); + normalizer = LvArray::math::max( LvArray::math::abs( m_constraintValue ), m_minNormalizer ); } } // for the pressure difference equation, always normalize by the BHP @@ -586,18 +596,18 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa if( m_isProducer ) // only PHASEVOLRATE is supported for now { // the residual is in mass units - normalizer = m_dt * LvArray::math::abs( m_targetPhaseRate ) * m_phaseDens_n[iwelem][0][m_targetPhaseIndex]; + normalizer = m_dt * LvArray::math::abs( m_constraintValue ) * m_phaseDens_n[iwelem][0][m_targetPhaseIndex]; } else // Type::INJECTOR, only TOTALVOLRATE is supported for now { - if( m_currentControl == WellControls::Control::MASSRATE ) + if( m_currentControl == ConstraintTypeId::MASSRATE ) { - normalizer = m_dt * LvArray::math::abs( m_targetMassRate ); + normalizer = m_dt * LvArray::math::abs( m_constraintValue ); } else { // the residual is in mass units - normalizer = m_dt * LvArray::math::abs( m_targetTotalRate ) * m_totalDens_n[iwelem][0]; + normalizer = m_dt * LvArray::math::abs( m_constraintValue ) * m_totalDens_n[iwelem][0]; } } @@ -611,17 +621,17 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa if( m_isProducer ) // only PHASEVOLRATE is supported for now { // the residual is in volume units - normalizer = m_dt * LvArray::math::abs( m_targetPhaseRate ); + normalizer = m_dt * LvArray::math::abs( m_constraintValue ); } else // Type::INJECTOR, only TOTALVOLRATE is supported for now { - if( m_currentControl == WellControls::Control::MASSRATE ) + if( m_currentControl == ConstraintTypeId::MASSRATE ) { - normalizer = m_dt * LvArray::math::abs( m_targetMassRate/ m_totalDens_n[iwelem][0] ); + normalizer = m_dt * LvArray::math::abs( m_constraintValue/ m_totalDens_n[iwelem][0] ); } else { - normalizer = m_dt * LvArray::math::abs( m_targetTotalRate ); + normalizer = m_dt * LvArray::math::abs( m_constraintValue ); } } @@ -658,7 +668,7 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa integer const m_numDof; /// Index of the target phase - integer const m_targetPhaseIndex; + integer m_targetPhaseIndex; /// Time step size real64 const m_dt; @@ -673,11 +683,10 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa bool const m_isProducer; /// Controls - WellControls::Control const m_currentControl; - real64 const m_targetBHP; - real64 const m_targetTotalRate; - real64 const m_targetPhaseRate; - real64 const m_targetMassRate; + ConstraintTypeId const m_currentControl; + real64 m_constraintValue; + real64 m_targetBHP; + /// View on the volume arrayView1d< real64 const > const m_volume; @@ -700,7 +709,6 @@ class ResidualNormKernelFactory * @tparam POLICY the policy used in the RAJA kernel * @param[in] numComp number of fluid components * @param[in] numDof number of dofs per well element - * @param[in] targetPhaseIndex the index of the target phase (for phase volume control) * @param[in] rankOffset the offset of my MPI rank * @param[in] dofKey the string key to retrieve the degress of freedom numbers * @param[in] localResidual the residual vector on my MPI rank @@ -715,7 +723,6 @@ class ResidualNormKernelFactory static void createAndLaunch( integer const numComp, integer const numDof, - integer const targetPhaseIndex, globalIndex const rankOffset, string const & dofKey, arrayView1d< real64 const > const & localResidual, @@ -731,7 +738,7 @@ class ResidualNormKernelFactory arrayView1d< integer const > const ghostRank = subRegion.ghostRank(); ResidualNormKernel kernel( rankOffset, localResidual, dofNumber, ghostRank, - numComp, numDof, targetPhaseIndex, subRegion, fluid, wellControls, time, dt, minNormalizer ); + numComp, numDof, subRegion, fluid, wellControls, time, dt, minNormalizer ); ResidualNormKernel::launchLinf< POLICY >( subRegion.size(), kernel, residualNorm ); } @@ -830,6 +837,7 @@ class ElementBasedAssemblyKernel * @param[inout] localRhs the local right-hand side vector */ ElementBasedAssemblyKernel( localIndex const numPhases, + integer const thermalEffectsEnabled, integer const isProducer, globalIndex const rankOffset, string const dofKey, @@ -839,6 +847,7 @@ class ElementBasedAssemblyKernel arrayView1d< real64 > const & localRhs, BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > const kernelFlags ) : m_numPhases( numPhases ), + m_thermalEffectsEnabled( thermalEffectsEnabled ), m_isProducer( isProducer ), m_rankOffset( rankOffset ), m_iwelemControl( subRegion.getTopWellElementIndex() ), @@ -1120,7 +1129,20 @@ class ElementBasedAssemblyKernel if constexpr ( IS_THERMAL) { - if( ei == m_iwelemControl && !m_isProducer ) + if( !m_thermalEffectsEnabled ) + { + for( integer i=0; i < numComp+1+IS_THERMAL; i++ ) + { + stack.localJacobian[numRows-1][i] = 0.0; + } + // constant Temperature + for( integer i=0; i < numComp+1+IS_THERMAL; i++ ) + stack.localJacobian[i][numRows-1] = 0.0; + stack.localJacobian[numRows-1][numRows-1] = 1.0; + + stack.localResidual[numRows-1]=0.0; + } + else if( ei == m_iwelemControl && !m_isProducer ) { // For top segment energy balance eqn replaced with T(n+1) - T = 0 // No other energy balance derivatives @@ -1197,6 +1219,8 @@ class ElementBasedAssemblyKernel /// Number of fluid phases integer const m_numPhases; + /// Flag indicating whether thermal effects are enabled + bool const m_thermalEffectsEnabled; /// Well type integer const m_isProducer; @@ -1276,6 +1300,7 @@ class ElementBasedAssemblyKernelFactory static void createAndLaunch( localIndex const numComps, localIndex const numPhases, + integer const & thermalEffectsEnabled, integer const isProducer, globalIndex const rankOffset, BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags, @@ -1292,7 +1317,7 @@ class ElementBasedAssemblyKernelFactory integer constexpr istherm = IS_THERMAL(); ElementBasedAssemblyKernel< NUM_COMP, istherm > - kernel( numPhases, isProducer, rankOffset, dofKey, subRegion, fluid, localMatrix, localRhs, kernelFlags ); + kernel( numPhases, thermalEffectsEnabled, isProducer, rankOffset, dofKey, subRegion, fluid, localMatrix, localRhs, kernelFlags ); ElementBasedAssemblyKernel< NUM_COMP, istherm >::template launch< POLICY, ElementBasedAssemblyKernel< NUM_COMP, istherm > >( subRegion.size(), kernel ); } ); @@ -1359,7 +1384,7 @@ class FaceBasedAssemblyKernel m_wellElemDofNumber ( subRegion.getReference< array1d< globalIndex > >( wellDofKey ) ), m_nextWellElemIndex ( subRegion.getReference< array1d< localIndex > >( WellElementSubRegion::viewKeyStruct::nextWellElementIndexString()) ), m_elemStatus( subRegion.getLocalWellElementStatus() ), - m_connRate ( subRegion.getField< fields::well::mixtureConnectionRate >() ), + m_connRate ( subRegion.getField< fields::well::connectionRate >() ), m_wellElemCompFrac ( subRegion.getField< fields::well::globalCompFraction >() ), m_dWellElemCompFrac_dCompDens ( subRegion.getField< fields::well::dGlobalCompFraction_dGlobalCompDensity >() ), m_localMatrix( localMatrix ), diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/SinglePhaseWellConstraintKernels.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/SinglePhaseWellConstraintKernels.hpp new file mode 100644 index 00000000000..72d0e7878c5 --- /dev/null +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/SinglePhaseWellConstraintKernels.hpp @@ -0,0 +1,196 @@ +/* + * ------------------------------------------------------------------------------------------------------------ + * 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 SinglePhaseWellConstraintKernels.hpp + */ + +#ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_SINGLEPHASEWELLCONSTRAINTKERNELS_HPP +#define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_SINGLEPHASEWELLCONSTRAINTKERNELS_HPP + +#include "codingUtilities/Utilities.hpp" +#include "constitutive/fluid/singlefluid/SingleFluidBase.hpp" +#include "constitutive/fluid/singlefluid/SingleFluidFields.hpp" + + +#include "physicsSolvers/fluidFlow/wells/WellControls.hpp" +#include "physicsSolvers/fluidFlow/wells/WellBHPConstraints.hpp" +#include "physicsSolvers/fluidFlow/wells/WellVolumeRateConstraint.hpp" + + +namespace geos +{ + +namespace singlePhaseWellConstraintKernels +{ + +/******************************** ControlEquationHelper ********************************/ + + +template< integer IS_THERMAL > +struct ConstraintHelper +{ + template< BHPConstraintTypeId I > + static void assembleConstraintEquation( real64 const & time_n, + WellControls & wellControls, + BHPConstraint< I > & constraint, + WellElementSubRegion const & subRegion, + string const & wellDofKey, + localIndex const & rankOffset, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + // subRegion data + localIndex const iwelemRef = subRegion.getTopWellElementIndex(); + arrayView1d< globalIndex const > const & wellElemDofNumber = subRegion.getReference< array1d< globalIndex > >( wellDofKey ); + arrayView1d< real64 const > const & pres = subRegion.getField< fields::well::pressure >(); + + constitutive::SingleFluidBase & fluidSeparator = wellControls.getSingleFluidSeparator(); + arrayView2d< real64 const, constitutive::singlefluid::USD_FLUID > const & density = fluidSeparator.density(); + arrayView3d< real64 const, constitutive::singlefluid::USD_FLUID_DER > const & dDensity = fluidSeparator.dDensity(); + + arrayView1d< real64 const > const wellElemGravCoef = subRegion.getField< fields::well::gravityCoefficient >(); + + // setup row/column indices for constraint equation + using ROFFSET_WJ = singlePhaseWellKernels::RowOffset_WellJac< IS_THERMAL >; + using COFFSET_WJ = singlePhaseWellKernels::ColOffset_WellJac< IS_THERMAL >; + using Deriv = constitutive::singlefluid::DerivativeOffsetC< IS_THERMAL >; + + localIndex const eqnRowIndex = wellElemDofNumber[iwelemRef] + ROFFSET_WJ::CONTROL - rankOffset; + globalIndex dofColIndices[COFFSET_WJ::nDer]{}; + for( integer i = 0; i < COFFSET_WJ::nDer; ++i ) + { + dofColIndices[ i ] = wellElemDofNumber[iwelemRef] + i; + } + // constraint data + real64 const & targetBHP = constraint.getConstraintValue( time_n ); + real64 const & refGravCoef = constraint.getReferenceGravityCoef(); + + // current constraint value + real64 const & currentBHP = + wellControls.getReference< real64 >( SinglePhaseWell::viewKeyStruct::currentBHPString() ); + + // residual + real64 controlEqn = currentBHP - targetBHP; + + // setup Jacobian terms + real64 dControlEqn[2+IS_THERMAL]{}; + + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [pres, + density, + dDensity, + wellElemGravCoef, + &dControlEqn, + &iwelemRef, + &refGravCoef] ( localIndex const ) + { + real64 const diffGravCoef = refGravCoef - wellElemGravCoef[iwelemRef]; + dControlEqn[COFFSET_WJ::dP] = 1.0 + dDensity[iwelemRef][0][Deriv::dP] *diffGravCoef; + if constexpr ( IS_THERMAL ) + { + dControlEqn[COFFSET_WJ::dT] = dDensity[iwelemRef][0][Deriv::dT] * diffGravCoef; + } + } ); + + // add solver matrices + localRhs[eqnRowIndex] += controlEqn; + localMatrix.addToRowBinarySearchUnsorted< serialAtomic >( eqnRowIndex, + dofColIndices, + dControlEqn, + COFFSET_WJ::nDer ); + } + template< template< typename U > class T, typename U=VolumeRateConstraint > + static void assembleConstraintEquation( real64 const & time_n, + WellControls & wellControls, + T< VolumeRateConstraint > & constraint, + WellElementSubRegion const & subRegion, + string const & wellDofKey, + localIndex const & rankOffset, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + arrayView1d< real64 > const & localRhs ) + { + // subRegion data + + localIndex const iwelemRef = subRegion.getTopWellElementIndex(); + arrayView1d< globalIndex const > const & wellElemDofNumber = subRegion.getReference< array1d< globalIndex > >( wellDofKey ); + + + // setup row/column indices for constraint equation + using ROFFSET_WJ = singlePhaseWellKernels::RowOffset_WellJac< IS_THERMAL >; + using COFFSET_WJ = singlePhaseWellKernels::ColOffset_WellJac< IS_THERMAL >; + using Deriv = constitutive::singlefluid::DerivativeOffsetC< IS_THERMAL >; + + localIndex const eqnRowIndex = wellElemDofNumber[iwelemRef] + ROFFSET_WJ::CONTROL - rankOffset; + globalIndex dofColIndices[COFFSET_WJ::nDer]{}; + for( integer i = 0; i < COFFSET_WJ::nDer; ++i ) + { + dofColIndices[ i ] = wellElemDofNumber[iwelemRef] + i; + } + + // fluid data + constitutive::SingleFluidBase & fluidSeparator = wellControls.getSingleFluidSeparator(); + arrayView2d< real64 const, constitutive::singlefluid::USD_FLUID > const & density = fluidSeparator.density(); + arrayView3d< real64 const, constitutive::singlefluid::USD_FLUID_DER > const & dDensity = fluidSeparator.dDensity(); + + // constraint data + real64 const & targetVolRate = constraint.getConstraintValue( time_n ); + + // current constraint value + real64 & currentVolRate = + wellControls.getReference< real64 >( WellControls::viewKeyStruct::currentVolRateString() ); + + integer const useSurfaceConditions = wellControls.useSurfaceConditions(); + + // residual + real64 controlEqn = currentVolRate - targetVolRate; + + // setup Jacobian terms + real64 dControlEqn[2+IS_THERMAL]{}; + + // bring everything back to host, capture the scalars by reference + forAll< serialPolicy >( 1, [currentVolRate, + density, + dDensity, + &dControlEqn, + &useSurfaceConditions, + &iwelemRef] ( localIndex const ) + { + // compute the inverse of the total density and derivatives + real64 const densInv = 1.0 / density[iwelemRef][0]; + + dControlEqn[COFFSET_WJ::dP] = -( useSurfaceConditions == 0 ) * dDensity[iwelemRef][0][Deriv::dP] * currentVolRate * densInv; + dControlEqn[COFFSET_WJ::dQ] = densInv; + if constexpr ( IS_THERMAL ) + { + dControlEqn[COFFSET_WJ::dT] = -( useSurfaceConditions == 0 ) * dDensity[iwelemRef][0][Deriv::dT] * currentVolRate * densInv; + } + + } ); + + // add solver matrices + localRhs[eqnRowIndex] += controlEqn; + localMatrix.addToRowBinarySearchUnsorted< serialAtomic >( eqnRowIndex, + dofColIndices, + dControlEqn, + COFFSET_WJ::nDer ); + } +}; + +} // end namespace wellConstraintKernels + +} // end namespace geos + +#endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_WELLCONSTRAINTKERNELS_HPP diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/SinglePhaseWellKernels.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/SinglePhaseWellKernels.cpp index 5870c7c919c..d2846c9af53 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/SinglePhaseWellKernels.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/SinglePhaseWellKernels.cpp @@ -23,6 +23,7 @@ #include "physicsSolvers/fluidFlow/wells/SinglePhaseWell.hpp" #include "physicsSolvers/fluidFlow/wells/SinglePhaseWellFields.hpp" #include "constitutive/fluid/singlefluid/SingleFluidLayouts.hpp" + namespace geos { @@ -36,12 +37,12 @@ inline void ControlEquationHelper:: switchControl( bool const isProducer, - WellControls::Control const & currentControl, + ConstraintTypeId const & currentControl, real64 const & targetBHP, real64 const & targetRate, real64 const & currentBHP, real64 const & currentVolRate, - WellControls::Control & newControl ) + ConstraintTypeId & newControl ) { // if isViable is true at the end of the following checks, no need to switch bool controlIsViable = false; @@ -51,7 +52,7 @@ ControlEquationHelper:: // The well changes its mode of control whenever the existing control mode would // violate one of these limits. // BHP control - if( currentControl == WellControls::Control::BHP ) + if( currentControl == ConstraintTypeId::BHP ) { // the control is viable if the reference rate is below the max rate controlIsViable = ( LvArray::math::abs( currentVolRate ) <= LvArray::math::abs( targetRate ) + EPS ); @@ -79,9 +80,9 @@ ControlEquationHelper:: { // Note: if BHP control is not viable, we switch to TOTALVOLRATE // if TOTALVOLRATE are not viable, we switch to BHP - newControl = ( currentControl == WellControls::Control::BHP ) - ? WellControls::Control::TOTALVOLRATE - : WellControls::Control::BHP; + newControl = ( currentControl == ConstraintTypeId::BHP ) + ? ConstraintTypeId::TOTALVOLRATE + : ConstraintTypeId::BHP; } } @@ -91,7 +92,7 @@ inline void ControlEquationHelper:: compute( globalIndex const rankOffset, - WellControls::Control const currentControl, + ConstraintTypeId const currentControl, real64 const & targetBHP, real64 const & targetRate, real64 const & currentBHP, @@ -123,7 +124,7 @@ ControlEquationHelper:: // the well element that contains the reference elevation. // BHP control - if( currentControl == WellControls::Control::BHP ) + if( currentControl == ConstraintTypeId::BHP ) { // control equation is a difference between current BHP and target BHP controlEqn = currentBHP - targetBHP; @@ -133,7 +134,7 @@ ControlEquationHelper:: } // Total volumetric rate control - else if( currentControl == WellControls::Control::TOTALVOLRATE ) + else if( currentControl == ConstraintTypeId::TOTALVOLRATE ) { // control equation is the difference between volumetric current rate and target rate controlEqn = currentVolRate - targetRate; @@ -262,14 +263,10 @@ FluxKernel:: #define INST_PressureRelationKernel( IS_THERMAL ) \ template \ - localIndex \ + void \ PressureRelationKernel:: \ launch< IS_THERMAL >( localIndex const size, \ globalIndex const rankOffset, \ - bool const isLocallyOwned, \ - localIndex const iwelemControl, \ - WellControls const & wellControls, \ - real64 const & timeAtEndOfStep, \ arrayView1d< globalIndex const > const & wellElemDofNumber, \ arrayView1d< real64 const > const & wellElemGravCoef, \ arrayView1d< localIndex const > const & nextWellElemIndex, \ @@ -283,14 +280,10 @@ INST_PressureRelationKernel( 0 ); INST_PressureRelationKernel( 1 ); template< integer IS_THERMAL > -localIndex +void PressureRelationKernel:: launch( localIndex const size, globalIndex const rankOffset, - bool const isLocallyOwned, - localIndex const iwelemControl, - WellControls const & wellControls, - real64 const & time, arrayView1d< globalIndex const > const & wellElemDofNumber, arrayView1d< real64 const > const & wellElemGravCoef, arrayView1d< localIndex const > const & nextWellElemIndex, @@ -303,23 +296,6 @@ PressureRelationKernel:: using Deriv = constitutive::singlefluid::DerivativeOffset; using COFFSET_WJ = singlePhaseWellKernels::ColOffset_WellJac< IS_THERMAL >; // static well control data - bool const isProducer = wellControls.isProducer(); - WellControls::Control const currentControl = wellControls.getControl(); - real64 const targetBHP = wellControls.getTargetBHP( time ); - real64 const targetRate = wellControls.getTargetTotalRate( time ); - - // dynamic well control data - real64 const & currentBHP = - wellControls.getReference< real64 >( SinglePhaseWell::viewKeyStruct::currentBHPString() ); - arrayView1d< real64 const > const & dCurrentBHP = - wellControls.getReference< array1d< real64 > >( SinglePhaseWell::viewKeyStruct::dCurrentBHPString() ); - - real64 const & currentVolRate = - wellControls.getReference< real64 >( SinglePhaseWell::viewKeyStruct::currentVolRateString() ); - arrayView1d< real64 const > const & dCurrentVolRate = - wellControls.getReference< array1d< real64 > >( SinglePhaseWell::viewKeyStruct::dCurrentVolRateString() ); - - RAJA::ReduceMax< parallelDeviceReduce, localIndex > switchControl( 0 ); // loop over the well elements to compute the pressure relations between well elements forAll< parallelDevicePolicy<> >( size, [=] GEOS_HOST_DEVICE ( localIndex const iwelem ) @@ -327,34 +303,7 @@ PressureRelationKernel:: localIndex const iwelemNext = nextWellElemIndex[iwelem]; - if( iwelemNext < 0 && isLocallyOwned ) // if iwelemNext < 0, form control equation - { - WellControls::Control newControl = currentControl; - ControlEquationHelper::switchControl( isProducer, - currentControl, - targetBHP, - targetRate, - currentBHP, - currentVolRate, - newControl ); - if( currentControl != newControl ) - { - switchControl.max( 1 ); - } - - ControlEquationHelper::compute< IS_THERMAL >( rankOffset, - newControl, - targetBHP, - targetRate, - currentBHP, - dCurrentBHP, - currentVolRate, - dCurrentVolRate, - wellElemDofNumber[iwelemControl], - localMatrix, - localRhs ); - } - else if( iwelemNext >= 0 ) // if iwelemNext >= 0, form momentum equation + if( iwelemNext >= 0 ) // if iwelemNext >= 0, form momentum equation { // local working variables and arrays @@ -406,7 +355,6 @@ PressureRelationKernel:: } } } ); - return switchControl.get(); } /******************************** AccumulationKernel ********************************/ @@ -455,6 +403,7 @@ PresTempInitializationKernel:: localIndex const subRegionSize, localIndex const numPerforations, WellControls const & wellControls, + real64 const & refWellElemGravCoef, real64 const & currentTime, ElementViewConst< arrayView1d< real64 const > > const & resPressure, ElementViewConst< arrayView1d< real64 const > > const & resTemp, @@ -468,9 +417,8 @@ PresTempInitializationKernel:: arrayView1d< real64 > const & wellElemTemperature ) { real64 const targetBHP = wellControls.getTargetBHP( currentTime ); - real64 const refWellElemGravCoef = wellControls.getReferenceGravityCoef(); real64 const initialPressureCoef = wellControls.getInitialPressureCoefficient(); - WellControls::Control const currentControl = wellControls.getControl(); + ConstraintTypeId const currentControl = wellControls.getControl(); bool const isProducer = wellControls.isProducer(); @@ -529,7 +477,7 @@ PresTempInitializationKernel:: avgTemp = wellControls.getInjectionTemperature(); } // if the well is controlled by pressure, initialize the reference pressure at the target pressure - if( currentControl == WellControls::Control::BHP ) + if( currentControl == ConstraintTypeId::BHP ) { refPres = targetBHP; } @@ -581,7 +529,7 @@ PresTempInitializationKernel:: GEOS_THROW_IF( foundNegativePressure.get() == 1, "Invalid well initialization, negative pressure was found.", InputError, wellControls.getDataContext() ); - if( isThermal ) // tjb change temp in isothermal cases shouldnt be an issue (also what if temp in fluid prop calcs like compo) + if( isThermal ) { GEOS_THROW_IF( foundNegativeTemp.get() == 1, "Invalid well initialization, negative temperature was found.", @@ -599,29 +547,35 @@ RateInitializationKernel:: arrayView2d< real64 const, constitutive::singlefluid::USD_FLUID > const & wellElemDens, arrayView1d< real64 > const & connRate ) { - real64 const targetRate = wellControls.getTargetTotalRate( currentTime ); - WellControls::Control const control = wellControls.getControl(); + + ConstraintTypeId const control = wellControls.getControl(); bool const isProducer = wellControls.isProducer(); + auto const * rateConstraint = wellControls.getRateConstraints().front(); + real64 const constraintVal = rateConstraint->getConstraintValue( currentTime ); // Estimate the connection rates forAll< parallelDevicePolicy<> >( subRegionSize, [=] GEOS_HOST_DEVICE ( localIndex const iwelem ) { - if( control == WellControls::Control::BHP ) + if( control == ConstraintTypeId::BHP ) { // if BHP constraint set rate below the absolute max rate // with the appropriate sign (negative for prod, positive for inj) if( isProducer ) { - connRate[iwelem] = LvArray::math::max( 0.1 * targetRate * wellElemDens[iwelem][0], -1e3 ); + connRate[iwelem] = LvArray::math::max( 0.1 * constraintVal * wellElemDens[iwelem][0], -1e3 ); } else { - connRate[iwelem] = LvArray::math::min( 0.1 * targetRate * wellElemDens[iwelem][0], 1e3 ); + connRate[iwelem] = LvArray::math::min( 0.1 * constraintVal * wellElemDens[iwelem][0], 1e3 ); } } + else if( control == ConstraintTypeId::MASSRATE ) + { + connRate[iwelem] = constraintVal; + } else { - connRate[iwelem] = targetRate * wellElemDens[iwelem][0]; + connRate[iwelem] = constraintVal * wellElemDens[iwelem][0]; } } ); } diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/SinglePhaseWellKernels.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/SinglePhaseWellKernels.hpp index 5221162c73c..19d64b2d32b 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/SinglePhaseWellKernels.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/SinglePhaseWellKernels.hpp @@ -20,18 +20,23 @@ #ifndef GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_SINGLEPHASEWELLKERNELS_HPP #define GEOS_PHYSICSSOLVERS_FLUIDFLOW_WELLS_SINGLEPHASEWELLKERNELS_HPP +#include "common/DataTypes.hpp" +#include "common/GEOS_RAJA_Interface.hpp" +#include "physicsSolvers/PhysicsSolverBaseKernels.hpp" + #include "constitutive/fluid/singlefluid/SingleFluidFields.hpp" #include "constitutive/fluid/singlefluid/SingleFluidBase.hpp" #include "constitutive/fluid/singlefluid/SingleFluidLayouts.hpp" #include "constitutive/fluid/singlefluid/SingleFluidLayouts.hpp" -#include "common/DataTypes.hpp" -#include "common/GEOS_RAJA_Interface.hpp" + #include "mesh/ElementRegionManager.hpp" #include "physicsSolvers/fluidFlow/FlowSolverBaseFields.hpp" #include "physicsSolvers/fluidFlow/StencilAccessors.hpp" #include "physicsSolvers/fluidFlow/wells/WellControls.hpp" +#include "physicsSolvers/fluidFlow/wells/WellFields.hpp" #include "physicsSolvers/fluidFlow/wells/SinglePhaseWellFields.hpp" -#include "physicsSolvers/PhysicsSolverBaseKernels.hpp" +#include "physicsSolvers/fluidFlow/wells/WellConstraintsBase.hpp" + #include "physicsSolvers/KernelLaunchSelectors.hpp" namespace geos @@ -125,12 +130,12 @@ struct ControlEquationHelper static void switchControl( bool const isProducer, - WellControls::Control const & currentControl, + ConstraintTypeId const & currentControl, real64 const & targetBHP, real64 const & targetRate, real64 const & currentBHP, real64 const & currentVolRate, - WellControls::Control & newControl ); + ConstraintTypeId & newControl ); template< integer IS_THERMAL > GEOS_HOST_DEVICE @@ -138,7 +143,7 @@ struct ControlEquationHelper static void compute( globalIndex const rankOffset, - WellControls::Control const currentControl, + ConstraintTypeId const currentControl, real64 const & targetBHP, real64 const & targetRate, real64 const & currentBHP, @@ -185,13 +190,9 @@ struct PressureRelationKernel using TAG = singlePhaseWellKernels::ElemTag; template< integer IS_THERMAL > - static localIndex + static void launch( localIndex const size, globalIndex const rankOffset, - bool const isLocallyOwned, - localIndex const iwelemControl, - WellControls const & wellControls, - real64 const & time, arrayView1d< globalIndex const > const & wellElemDofNumber, arrayView1d< real64 const > const & wellElemGravCoef, arrayView1d< localIndex const > const & nextWellElemIndex, @@ -516,6 +517,7 @@ struct PresTempInitializationKernel localIndex const subRegionSize, localIndex const numPerforations, WellControls const & wellControls, + real64 const & refWellElemGravCoef, real64 const & currentTime, ElementViewConst< arrayView1d< real64 const > > const & resPressure, ElementViewConst< arrayView1d< real64 const > > const & resTemperature, @@ -811,9 +813,8 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa m_isLocallyOwned( subRegion.isLocallyOwned() ), m_iwelemControl( subRegion.getTopWellElementIndex() ), m_currentControl( wellControls.getControl() ), - m_targetBHP( wellControls.getTargetBHP( time ) ), - m_targetRate( wellControls.getTargetTotalRate( time ) ), - m_targetMassRate( wellControls.getTargetMassRate( time ) ), + m_constraintValue ( wellControls.getCurrentConstraint()->getConstraintValue( time )), + m_targetBHP( wellControls.getTargetBHP( time ) ), // tjb fix for whp imposed bhp constraint m_volume( subRegion.getElementVolume() ), m_density_n( fluid.density_n() ) {} @@ -830,20 +831,20 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa // for the top well element, normalize using the current control if( m_isLocallyOwned && iwelem == m_iwelemControl ) { - if( m_currentControl == WellControls::Control::BHP ) + if( m_currentControl == ConstraintTypeId::BHP ) { // this residual entry is in pressure units normalizer = m_targetBHP; } - else if( m_currentControl == WellControls::Control::TOTALVOLRATE ) + else if( m_currentControl == ConstraintTypeId::TOTALVOLRATE ) { // this residual entry is in volume / time units - normalizer = LvArray::math::max( LvArray::math::abs( m_targetRate ), m_minNormalizer ); + normalizer = LvArray::math::max( LvArray::math::abs( m_constraintValue ), m_minNormalizer ); } - else if( m_currentControl == WellControls::Control::MASSRATE ) + else if( m_currentControl == ConstraintTypeId::MASSRATE ) { // the residual entry is in volume / time units - normalizer = LvArray::math::max( LvArray::math::abs( m_targetMassRate ), m_minNormalizer ); + normalizer = LvArray::math::max( LvArray::math::abs( m_constraintValue ), m_minNormalizer ); } } // for the pressure difference equation, always normalize by the BHP @@ -856,7 +857,7 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa else // SinglePhaseWell::RowOffset::MASSBAL { // this residual entry is in mass units - normalizer = m_dt * LvArray::math::abs( m_targetRate ) * m_density_n[iwelem][0]; + normalizer = m_dt * LvArray::math::abs( m_constraintValue ) * m_density_n[iwelem][0]; // to make sure that everything still works well if the rate is zero, we add this check normalizer = LvArray::math::max( normalizer, m_volume[iwelem] * m_density_n[iwelem][0] ); @@ -893,10 +894,10 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa localIndex const m_iwelemControl; /// Controls - WellControls::Control const m_currentControl; - real64 const m_targetBHP; - real64 const m_targetRate; - real64 const m_targetMassRate; + ConstraintTypeId const m_currentControl; + real64 const m_constraintValue; + real64 m_targetBHP; + /// View on the volume arrayView1d< real64 const > const m_volume; diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/ThermalCompositionalMultiphaseWellKernels.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/ThermalCompositionalMultiphaseWellKernels.hpp index 54b7819e8bf..f3ec5b517a3 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/ThermalCompositionalMultiphaseWellKernels.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/ThermalCompositionalMultiphaseWellKernels.hpp @@ -22,6 +22,8 @@ #include "physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellKernels.hpp" #include "physicsSolvers/PhysicsSolverBaseKernels.hpp" +#include "physicsSolvers/fluidFlow/wells/WellConstraintsBase.hpp" +#include "physicsSolvers/fluidFlow/wells/WellPhaseVolumeRateConstraint.hpp" namespace geos { @@ -80,7 +82,7 @@ class TotalMassDensityKernel : public compositionalMultiphaseWellKernels::TotalM arraySlice2d< real64 const, multifluid::USD_PHASE_DC - 2 > dPhaseMassDens = m_dPhaseMassDens[ei][0]; real64 & dTotalMassDens_dT = m_dTotalMassDens[ei][Deriv::dT]; - dTotalMassDens_dT=0.0; + // Call the base compute the compute the total mass density and derivatives return Base::compute( ei, [&]( localIndex const ip ) { @@ -161,7 +163,7 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa arrayView1d< real64 const > const & localResidual, arrayView1d< globalIndex const > const & dofNumber, arrayView1d< localIndex const > const & ghostRank, - integer const targetPhaseIndex, + WellElementSubRegion const & subRegion, MultiFluidBase const & fluid, WellControls const & wellControls, @@ -174,23 +176,33 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa ghostRank, minNormalizer ), m_numPhases( fluid.numFluidPhases()), - m_targetPhaseIndex( targetPhaseIndex ), m_dt( dt ), m_isLocallyOwned( subRegion.isLocallyOwned() ), m_iwelemControl( subRegion.getTopWellElementIndex() ), m_isProducer( wellControls.isProducer() ), m_currentControl( wellControls.getControl() ), - m_targetBHP( wellControls.getTargetBHP( time ) ), - m_targetTotalRate( wellControls.getTargetTotalRate( time ) ), - m_targetPhaseRate( wellControls.getTargetPhaseRate( time ) ), - m_targetMassRate( wellControls.getTargetMassRate( time ) ), + m_targetBHP( std::numeric_limits< real64 >::max() ), m_volume( subRegion.getElementVolume() ), m_phaseDens_n( fluid.phaseDensity_n() ), m_totalDens_n( fluid.totalDensity_n() ), m_phaseVolFraction_n( subRegion.getField< fields::well::phaseVolumeFraction_n >()), m_phaseInternalEnergy_n( fluid.phaseInternalEnergy_n() ) - {} - + { + const WellConstraintBase * currentConstraint = wellControls.getCurrentConstraint(); + ConstraintTypeId currentControl = wellControls.getControl(); + if( currentControl == ConstraintTypeId::BHP ) + { + m_targetBHP = currentConstraint->getConstraintValue( time ); + } + else + { + m_constraintValue = currentConstraint->getConstraintValue( time ); + if( currentControl == ConstraintTypeId::PHASEVOLRATE ) + { + m_targetPhaseIndex = wellControls.getConstraintPhaseIndex(); + } + } + } GEOS_HOST_DEVICE void computeMassEnergyNormalizers( localIndex const iwelem, @@ -224,25 +236,25 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa // for the top well element, normalize using the current control if( m_isLocallyOwned && iwelem == m_iwelemControl ) { - if( m_currentControl == WellControls::Control::BHP ) + if( m_currentControl == ConstraintTypeId::BHP ) { // the residual entry is in pressure units normalizer = m_targetBHP; } - else if( m_currentControl == WellControls::Control::TOTALVOLRATE ) + else if( m_currentControl == ConstraintTypeId::TOTALVOLRATE ) { // the residual entry is in volume / time units - normalizer = LvArray::math::max( LvArray::math::abs( m_targetTotalRate ), m_minNormalizer ); + normalizer = LvArray::math::max( LvArray::math::abs( m_constraintValue ), m_minNormalizer ); } - else if( m_currentControl == WellControls::Control::PHASEVOLRATE ) + else if( m_currentControl == ConstraintTypeId::PHASEVOLRATE ) { // the residual entry is in volume / time units - normalizer = LvArray::math::max( LvArray::math::abs( m_targetPhaseRate ), m_minNormalizer ); + normalizer = LvArray::math::max( LvArray::math::abs( m_constraintValue ), m_minNormalizer ); } - else if( m_currentControl == WellControls::Control::MASSRATE ) + else if( m_currentControl == ConstraintTypeId::MASSRATE ) { // the residual entry is in volume / time units - normalizer = LvArray::math::max( LvArray::math::abs( m_targetMassRate ), m_minNormalizer ); + normalizer = LvArray::math::max( LvArray::math::abs( m_constraintValue ), m_minNormalizer ); } } // for the pressure difference equation, always normalize by the BHP @@ -254,21 +266,21 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa // Step 2: compute a normalizer for the mass balance equations else if( idof >= WJ_ROFFSET::MASSBAL && idof < WJ_ROFFSET::MASSBAL + numComp ) { - if( m_isProducer ) // only PHASEVOLRATE is supported for now + if( m_isProducer ) // only PHASEVOLRATE is supported for now { // the residual is in mass units - normalizer = m_dt * LvArray::math::abs( m_targetPhaseRate ) * m_phaseDens_n[iwelem][0][m_targetPhaseIndex]; + normalizer = m_dt * LvArray::math::abs( m_constraintValue ) * m_phaseDens_n[iwelem][0][m_targetPhaseIndex]; } - else // Type::INJECTOR, only TOTALVOLRATE is supported for now + else // Type::INJECTOR, only TOTALVOLRATE is supported for now { - if( m_currentControl == WellControls::Control::MASSRATE ) + if( m_currentControl == ConstraintTypeId::MASSRATE ) { - normalizer = m_dt * LvArray::math::abs( m_targetMassRate ); + normalizer = m_dt * LvArray::math::abs( m_constraintValue ); } else { // the residual is in mass units - normalizer = m_dt * LvArray::math::abs( m_targetTotalRate ) * m_totalDens_n[iwelem][0]; + normalizer = m_dt * LvArray::math::abs( m_constraintValue ) * m_totalDens_n[iwelem][0]; } } @@ -279,20 +291,20 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa // Step 3: compute a normalizer for the volume balance equations else if( idof == WJ_ROFFSET::VOLBAL ) { - if( m_isProducer ) // only PHASEVOLRATE is supported for now + if( m_isProducer ) // only PHASEVOLRATE is supported for now { // the residual is in volume units - normalizer = m_dt * LvArray::math::abs( m_targetPhaseRate ); + normalizer = m_dt * LvArray::math::abs( m_constraintValue ); } - else // Type::INJECTOR, only TOTALVOLRATE is supported for now + else // Type::INJECTOR, only TOTALVOLRATE is supported for now { - if( m_currentControl == WellControls::Control::MASSRATE ) + if( m_currentControl == ConstraintTypeId::MASSRATE ) { - normalizer = m_dt * LvArray::math::abs( m_targetMassRate/ m_totalDens_n[iwelem][0] ); + normalizer = m_dt * LvArray::math::abs( m_constraintValue/ m_totalDens_n[iwelem][0] ); } else { - normalizer = m_dt * LvArray::math::abs( m_targetTotalRate ); + normalizer = m_dt * LvArray::math::abs( m_constraintValue ); } } @@ -339,7 +351,7 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa integer const m_numPhases; /// Index of the target phase - integer const m_targetPhaseIndex; + integer m_targetPhaseIndex; /// Time step size real64 const m_dt; @@ -354,11 +366,10 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa bool const m_isProducer; /// Controls - WellControls::Control const m_currentControl; - real64 const m_targetBHP; - real64 const m_targetTotalRate; - real64 const m_targetPhaseRate; - real64 const m_targetMassRate; + ConstraintTypeId const m_currentControl; + real64 m_constraintValue; + real64 m_targetBHP; + /// View on the volume arrayView1d< real64 const > const m_volume; @@ -383,7 +394,6 @@ class ResidualNormKernelFactory * @tparam POLICY the policy used in the RAJA kernel * @param[in] numComp number of fluid components * @param[in] numDof number of dofs per well element - * @param[in] targetPhaseIndex the index of the target phase (for phase volume control) * @param[in] rankOffset the offset of my MPI rank * @param[in] dofKey the string key to retrieve the degress of freedom numbers * @param[in] localResidual the residual vector on my MPI rank @@ -397,7 +407,6 @@ class ResidualNormKernelFactory template< typename POLICY > static void createAndLaunch( integer const numComp, - integer const targetPhaseIndex, globalIndex const rankOffset, string const & dofKey, arrayView1d< real64 const > const & localResidual, @@ -418,7 +427,7 @@ class ResidualNormKernelFactory arrayView1d< integer const > const ghostRank = subRegion.ghostRank(); kernelType kernel( rankOffset, localResidual, dofNumber, ghostRank, - targetPhaseIndex, subRegion, fluid, wellControls, time, dt, minNormalizer ); + subRegion, fluid, wellControls, time, dt, minNormalizer ); kernelType::template launchLinf< POLICY >( subRegion.size(), kernel, residualNorm ); } ); } @@ -476,6 +485,7 @@ class ElementBasedAssemblyKernel : public compositionalMultiphaseWellKernels::El * @param[inout] localRhs the local right-hand side vector */ ElementBasedAssemblyKernel( localIndex const numPhases, + bool const thermalEffectsEnabled, integer const isProducer, globalIndex const rankOffset, string const dofKey, @@ -484,7 +494,7 @@ class ElementBasedAssemblyKernel : public compositionalMultiphaseWellKernels::El CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs, BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > const kernelFlags ) - : Base( numPhases, isProducer, rankOffset, dofKey, subRegion, fluid, localMatrix, localRhs, kernelFlags ), + : Base( numPhases, thermalEffectsEnabled, isProducer, rankOffset, dofKey, subRegion, fluid, localMatrix, localRhs, kernelFlags ), m_phaseInternalEnergy_n( fluid.phaseInternalEnergy_n()), m_phaseInternalEnergy( fluid.phaseInternalEnergy()), m_dPhaseInternalEnergy( fluid.dPhaseInternalEnergy()) @@ -636,6 +646,7 @@ class ElementBasedAssemblyKernelFactory static void createAndLaunch( localIndex const numComps, localIndex const numPhases, + integer const thermalEffectsEnabled, integer const isProducer, globalIndex const rankOffset, BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags, @@ -645,13 +656,12 @@ class ElementBasedAssemblyKernelFactory CRSMatrixView< real64, globalIndex const > const & localMatrix, arrayView1d< real64 > const & localRhs ) { - isothermalCompositionalMultiphaseBaseKernels:: - internal::kernelLaunchSelectorCompSwitch( numComps, [&]( auto NC ) + isothermalCompositionalMultiphaseBaseKernels::internal::kernelLaunchSelectorCompSwitch( numComps, [&]( auto NC ) { localIndex constexpr NUM_COMP = NC(); ElementBasedAssemblyKernel< NUM_COMP > - kernel( numPhases, isProducer, rankOffset, dofKey, subRegion, fluid, localMatrix, localRhs, kernelFlags ); + kernel( numPhases, thermalEffectsEnabled, isProducer, rankOffset, dofKey, subRegion, fluid, localMatrix, localRhs, kernelFlags ); ElementBasedAssemblyKernel< NUM_COMP >::template launch< POLICY, ElementBasedAssemblyKernel< NUM_COMP > >( subRegion.size(), kernel ); } ); @@ -731,6 +741,7 @@ class FaceBasedAssemblyKernel : public compositionalMultiphaseWellKernels::FaceB , localRhs , kernelFlags ), m_numPhases ( fluid.numFluidPhases()), + m_thermalEffectsEnabled( wellControls.thermalEffectsEnabled() ), m_globalWellElementIndex( subRegion.getGlobalWellElementIndex() ), m_phaseFraction( fluid.phaseFraction()), m_dPhaseFraction( fluid.dPhaseFraction()), @@ -777,7 +788,8 @@ class FaceBasedAssemblyKernel : public compositionalMultiphaseWellKernels::FaceB void complete( localIndex const iwelem, StackVariables & stack ) const { Base::complete ( iwelem, stack ); - + // tjb iso return; + if( !m_thermalEffectsEnabled ) return; using namespace compositionalMultiphaseUtilities; if( stack.numConnectedElems ==1 ) { @@ -939,7 +951,7 @@ class FaceBasedAssemblyKernel : public compositionalMultiphaseWellKernels::FaceB stack.localEnergyFlux[0] = -m_dt * eflux * currentConnRate; stack.localEnergyFluxJacobian_dQ[0][0] = -m_dt * eflux_dq; } - else if( ( iwelemNext < 0 && m_isProducer ) || currentConnRate < 0 ) // exit connection, producer + else if( ( iwelemNext < 0 && m_isProducer ) ) // exit connection, producer { real64 eflux=0; real64 eflux_dq=0; @@ -966,9 +978,9 @@ class FaceBasedAssemblyKernel : public compositionalMultiphaseWellKernels::FaceB for( integer dof=0; dof < CP_Deriv::nDer; dof++ ) { - stack.localEnergyFluxJacobian[0][dof] *= -m_dt*currentConnRate; + stack.localEnergyFluxJacobian[0][dof] *= -m_dt*currentConnRate; } - stack.localEnergyFlux[0] = -m_dt * eflux * currentConnRate; + stack.localEnergyFlux[0] = -m_dt * eflux * currentConnRate; stack.localEnergyFluxJacobian_dQ[0][0] = -m_dt*eflux_dq; } else @@ -1047,6 +1059,8 @@ class FaceBasedAssemblyKernel : public compositionalMultiphaseWellKernels::FaceB protected: /// Number of phases integer const m_numPhases; + /// Flag specifying whether thermal effects are enabled + bool const m_thermalEffectsEnabled; /// Global index of local element arrayView1d< globalIndex const > m_globalWellElementIndex; diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/ThermalSinglePhaseWellKernels.hpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/ThermalSinglePhaseWellKernels.hpp index f736826561c..317a0082b81 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/ThermalSinglePhaseWellKernels.hpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/kernels/ThermalSinglePhaseWellKernels.hpp @@ -522,14 +522,23 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa m_iwelemControl( subRegion.getTopWellElementIndex() ), m_isProducer( wellControls.isProducer() ), m_currentControl( wellControls.getControl() ), - m_targetBHP( wellControls.getTargetBHP( time ) ), - m_targetRate( wellControls.getTargetTotalRate( time ) ), - m_targetMassRate( wellControls.getTargetMassRate( time ) ), + m_constraintValue ( wellControls.getCurrentConstraint()->getConstraintValue( time )), m_volume( subRegion.getElementVolume() ), m_density_n( fluid.density_n() ), m_internalEnergy_n( fluid.internalEnergy_n() ) - {} + { + const WellConstraintBase * currentConstraint = wellControls.getCurrentConstraint(); + if( currentConstraint->getControl() == ConstraintTypeId::BHP ) + { + m_targetBHP = currentConstraint->getConstraintValue( time ); + } + else + { + m_targetBHP = std::numeric_limits< real64 >::max(); + } + + } GEOS_HOST_DEVICE @@ -560,20 +569,20 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa // for the top well element, normalize using the current control if( m_isLocallyOwned && iwelem == m_iwelemControl ) { - if( m_currentControl == WellControls::Control::BHP ) + if( m_currentControl == ConstraintTypeId::BHP ) { // the residual entry is in pressure units normalizer = m_targetBHP; } - else if( m_currentControl == WellControls::Control::TOTALVOLRATE ) + else if( m_currentControl == ConstraintTypeId::TOTALVOLRATE ) { // the residual entry is in volume / time units - normalizer = LvArray::math::max( LvArray::math::abs( m_targetRate ), m_minNormalizer ); + normalizer = LvArray::math::max( LvArray::math::abs( m_constraintValue ), m_minNormalizer ); } - else if( m_currentControl == WellControls::Control::MASSRATE ) + else if( m_currentControl == ConstraintTypeId::MASSRATE ) { // the residual entry is in volume / time units - normalizer = LvArray::math::max( LvArray::math::abs( m_targetMassRate ), m_minNormalizer ); + normalizer = LvArray::math::max( LvArray::math::abs( m_constraintValue ), m_minNormalizer ); } } // for the pressure difference equation, always normalize by the BHP @@ -587,7 +596,7 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa { // this residual entry is in mass units - normalizer = m_dt * LvArray::math::abs( m_targetRate ) * m_density_n[iwelem][0]; + normalizer = m_dt * LvArray::math::abs( m_constraintValue ) * m_density_n[iwelem][0]; // to make sure that everything still works well if the rate is zero, we add this check normalizer = LvArray::math::max( normalizer, m_volume[iwelem] * m_density_n[iwelem][0] ); @@ -639,10 +648,9 @@ class ResidualNormKernel : public physicsSolverBaseKernels::ResidualNormKernelBa bool const m_isProducer; /// Controls - WellControls::Control const m_currentControl; - real64 const m_targetBHP; - real64 const m_targetRate; - real64 const m_targetMassRate; + ConstraintTypeId const m_currentControl; + real64 const m_constraintValue; + real64 m_targetBHP; /// View on the volume arrayView1d< real64 const > const m_volume; diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/unitTests/testWellEnums.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/unitTests/testWellEnums.cpp index 27b318e4511..e8fb82d1c93 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/unitTests/testWellEnums.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/unitTests/testWellEnums.cpp @@ -14,7 +14,7 @@ */ #include "physicsSolvers/fluidFlow/wells/WellControls.hpp" - +#include "physicsSolvers/fluidFlow/wells/WellConstraintsBase.hpp" #include using namespace geos; @@ -34,7 +34,7 @@ TEST( WellControlsEnums, Type ) TEST( WellControlsEnums, Control ) { - using EnumType = WellControls::Control; + using EnumType = ConstraintTypeId; ASSERT_EQ( "BHP", toString( EnumType::BHP ) ); ASSERT_EQ( "phaseVolRate", toString( EnumType::PHASEVOLRATE ) ); diff --git a/src/coreComponents/physicsSolvers/multiphysics/CompositionalMultiphaseReservoirAndWells.cpp b/src/coreComponents/physicsSolvers/multiphysics/CompositionalMultiphaseReservoirAndWells.cpp index c0c49411f53..11a8ed584e4 100644 --- a/src/coreComponents/physicsSolvers/multiphysics/CompositionalMultiphaseReservoirAndWells.cpp +++ b/src/coreComponents/physicsSolvers/multiphysics/CompositionalMultiphaseReservoirAndWells.cpp @@ -27,6 +27,7 @@ #include "physicsSolvers/fluidFlow/CompositionalMultiphaseHybridFVM.hpp" #include "physicsSolvers/fluidFlow/CompositionalMultiphaseUtilities.hpp" #include "physicsSolvers/fluidFlow/LogLevelsInfo.hpp" +#include "physicsSolvers/fluidFlow/CompositionalMultiphaseStatisticsAggregator.hpp" #include "physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.hpp" #include "physicsSolvers/fluidFlow/wells/WellControls.hpp" #include "physicsSolvers/fluidFlow/wells/kernels/CompositionalMultiphaseWellKernels.hpp" @@ -147,11 +148,10 @@ initializePreSubGroups() { Base::initializePreSubGroups(); - CompositionalMultiphaseBase const * const flowSolver = this->flowSolver(); + CompositionalMultiphaseBase * const flowSolver = this->flowSolver(); Base::wellSolver()->setFlowSolverName( flowSolver->getName() ); - bool const useMassFlow = flowSolver->getReference< integer >( CompositionalMultiphaseBase::viewKeyStruct::useMassFlagString() ); - bool const useMassWell = Base::wellSolver()->template getReference< integer >( CompositionalMultiphaseWell::viewKeyStruct::useMassFlagString() ); + bool const useMassWell = Base::wellSolver()->template getReference< integer >( WellManager::viewKeyStruct::useMassFlagString() ); GEOS_THROW_IF( useMassFlow != useMassWell, GEOS_FMT( "The input flag {} must be the same in the flow and well solvers, respectively '{}' and '{}'", CompositionalMultiphaseBase::viewKeyStruct::useMassFlagString(), @@ -159,12 +159,47 @@ initializePreSubGroups() InputError, this->getDataContext(), Base::reservoirSolver()->getDataContext(), Base::wellSolver()->getDataContext() ); bool const isThermalFlow = flowSolver->getReference< integer >( CompositionalMultiphaseBase::viewKeyStruct::isThermalString() ); - bool const isThermalWell = Base::wellSolver()->template getReference< integer >( CompositionalMultiphaseWell::viewKeyStruct::isThermalString() ); + bool const isThermalWell = Base::wellSolver()->template getReference< integer >( WellManager::viewKeyStruct::isThermalString() ); GEOS_THROW_IF( isThermalFlow != isThermalWell, GEOS_FMT( "The input flag {} must be the same in the flow and well solvers, respectively '{}' and '{}'", CompositionalMultiphaseBase::viewKeyStruct::isThermalString(), Base::reservoirSolver()->getName(), Base::wellSolver()->getName() ), InputError, this->getDataContext(), Base::reservoirSolver()->getDataContext(), Base::wellSolver()->getDataContext() ); + DomainPartition & domain = this->template getGroupByPath< DomainPartition >( "/Problem/domain" ); + + Group & meshBodies = domain.getMeshBodies(); + this->template forDiscretizationOnMeshTargets<>( meshBodies, [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + ElementRegionManager & elemManager = mesh.getElemManager(); + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, + WellElementSubRegion const & subRegion ) + { + WellControls & wellControls = Base::wellSolver()->getWellControls( subRegion ); + CompositionalMultiphaseWell & compositionalMultiphaseWell = dynamic_cast< CompositionalMultiphaseWell & >( wellControls ); + wellControls.setFlowSolverName( flowSolver->getName() ); + wellControls.setDiscretizationName( flowSolver->getDiscretizationName() ); + + if( !wellControls.useSurfaceConditions() ) + { + string_view refRegionName = wellControls.referenceReservoirRegion(); + bool const useSegmentValues = refRegionName.empty(); + if( !useSegmentValues ) + { + if( !compositionalMultiphaseWell.getStatsAggregator() ) + { // lazily initialize the region statistics aggregator + auto aggregator = std::make_unique< compositionalMultiphaseStatistics::StatsAggregator >( compositionalMultiphaseWell.getDataContext(), + meshBodies, + false ); + aggregator->initStatisticsAggregation( *flowSolver ); + aggregator->enableRegionStatisticsAggregation(); + compositionalMultiphaseWell.setReservoirStatsAggregator( std::move( aggregator ) ); + } + } + } + } ); + } ); } template< typename RESERVOIR_SOLVER > @@ -345,6 +380,7 @@ assembleCouplingTerms( real64 const time_n, coupledReservoirAndWellKernels:: ThermalCompositionalMultiPhaseFluxKernelFactory:: createAndLaunch< parallelDevicePolicy<> >( numComps, + wellControls.thermalEffectsEnabled( ), wellControls.isProducer(), dt, rankOffset, diff --git a/src/coreComponents/physicsSolvers/multiphysics/CompositionalMultiphaseReservoirAndWells.hpp b/src/coreComponents/physicsSolvers/multiphysics/CompositionalMultiphaseReservoirAndWells.hpp index b2b1f7a4800..4a460846dba 100644 --- a/src/coreComponents/physicsSolvers/multiphysics/CompositionalMultiphaseReservoirAndWells.hpp +++ b/src/coreComponents/physicsSolvers/multiphysics/CompositionalMultiphaseReservoirAndWells.hpp @@ -23,20 +23,25 @@ #include "physicsSolvers/multiphysics/CoupledReservoirAndWellsBase.hpp" #include "physicsSolvers/fluidFlow/CompositionalMultiphaseBase.hpp" -#include "physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.hpp" +#include "physicsSolvers/fluidFlow/wells/WellManager.hpp" namespace geos { +namespace compositionalMultiphaseStatistics +{ +class StatsAggregator; +} + /// @tparam RESERVOIR_SOLVER compositional flow or compositional poromechanics solver template< typename RESERVOIR_SOLVER = CompositionalMultiphaseBase > class CompositionalMultiphaseReservoirAndWells : public CoupledReservoirAndWellsBase< RESERVOIR_SOLVER, - CompositionalMultiphaseWell > + WellManager > { public: using Base = CoupledReservoirAndWellsBase< RESERVOIR_SOLVER, - CompositionalMultiphaseWell >; + WellManager >; using Base::getLogLevel; using Base::m_solvers; using Base::m_linearSolverParameters; diff --git a/src/coreComponents/physicsSolvers/multiphysics/CoupledReservoirAndWellKernels.hpp b/src/coreComponents/physicsSolvers/multiphysics/CoupledReservoirAndWellKernels.hpp index 5d106df3156..05592b5725a 100644 --- a/src/coreComponents/physicsSolvers/multiphysics/CoupledReservoirAndWellKernels.hpp +++ b/src/coreComponents/physicsSolvers/multiphysics/CoupledReservoirAndWellKernels.hpp @@ -329,7 +329,263 @@ class IsothermalCompositionalMultiPhaseFluxKernelFactory } }; +/** + * @class FaceBasedAssemblyKernel + * @tparam NUM_COMP number of fluid components + * @brief Define the interface for the assembly kernel in charge of flux terms + */ +template< integer NC, integer IS_THERMAL > +class IsothermalCompositionalMultiPhaseWellFluxKernel +{ +public: + + /// Compile time value for the number of components + static constexpr integer numComp = NC; + static constexpr integer resNumDOF = NC+1+IS_THERMAL; + + // Well jacobian column and row indicies + using WJ_COFFSET = compositionalMultiphaseWellKernels::ColOffset_WellJac< NC, IS_THERMAL >; + using WJ_ROFFSET = compositionalMultiphaseWellKernels::RowOffset_WellJac< NC, IS_THERMAL >; + + using ROFFSET = compositionalMultiphaseWellKernels::RowOffset; + using COFFSET = compositionalMultiphaseWellKernels::ColOffset; + + using CP_Deriv = multifluid::DerivativeOffsetC< NC, IS_THERMAL >; + + using TAG = compositionalMultiphaseWellKernels::SubRegionTag; + + + + /// Compute time value for the number of degrees of freedom + static constexpr integer numDof = WJ_COFFSET::nDer; + + /// Compile time value for the number of equations except volume and momentum + static constexpr integer numEqn = WJ_ROFFSET::nEqn - 2; + + /** + * @brief Constructor for the kernel interface + * @param[in] rankOffset the offset of my MPI rank + * @param[in] stencilWrapper reference to the stencil wrapper + * @param[in] dofNumberAccessor + * @param[in] compFlowAccessors + * @param[in] multiFluidAccessors + * @param[in] capPressureAccessors + * @param[in] permeabilityAccessors + * @param[in] dt time step size + * @param[inout] localMatrix the local CRS matrix + * @param[inout] localRhs the local right-hand side vector + * @param[in] kernelFlags flags packed together + */ + IsothermalCompositionalMultiPhaseWellFluxKernel( real64 const dt, + globalIndex const rankOffset, + string const wellDofKey, + WellElementSubRegion const & subRegion, + PerforationData const * const perforationData, + MultiFluidBase const & fluid, + arrayView1d< real64 > const & localRhs, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags ) + : + m_dt( dt ), + m_numPhases ( fluid.numFluidPhases()), + m_rankOffset( rankOffset ), + m_compPerfRate( perforationData->getField< fields::well::compPerforationRate >() ), + m_dCompPerfRate( perforationData->getField< fields::well::dCompPerforationRate >() ), + m_perfWellElemIndex( perforationData->getField< fields::perforation::wellElementIndex >() ), + m_wellElemDofNumber( subRegion.getReference< array1d< globalIndex > >( wellDofKey ) ), + m_localRhs( localRhs ), + m_localMatrix( localMatrix ), + m_useTotalMassEquation ( kernelFlags.isSet( isothermalCompositionalMultiphaseBaseKernels::KernelFlags::TotalMassEquation ) ) + { } + + + /** + * @brief Compute the local flux contributions to the residual and Jacobian + * @tparam FUNC the type of the function that can be used to customize the computation of the phase fluxes + * @param[in] ie the element index + * @param[inout] stack the stack variables + * @param[in] compFluxKernelOp the function used to customize the computation of the component fluxes + */ + + template< typename FUNC = NoOpFunc > + GEOS_HOST_DEVICE + inline + void computeFlux( localIndex const iperf, + FUNC && compFluxKernelOp = NoOpFunc{} ) const + { + + using namespace compositionalMultiphaseUtilities; + // local working variables and arrays + stackArray1d< localIndex, numComp > eqnRowIndices( numComp ); + stackArray1d< globalIndex, resNumDOF > dofColIndices( resNumDOF ); + + stackArray1d< real64, numComp > localPerf( numComp ); + stackArray2d< real64, numComp *resNumDOF > localPerfJacobian( numComp, resNumDOF ); + + // get the reservoir (sub)region and element indices + //localIndex const er = m_resElementRegion[iperf]; + //localIndex const esr = m_resElementSubRegion[iperf]; + //localIndex const ei = m_resElementIndex[iperf]; + + // get the well element index for this perforation + localIndex const iwelem = m_perfWellElemIndex[iperf]; + //globalIndex const resOffset = m_resElemDofNumber[er][esr][ei]; + globalIndex const wellElemOffset = m_wellElemDofNumber[iwelem]; + + for( integer ic = 0; ic < numComp; ++ic ) + { + eqnRowIndices[ ic] = LvArray::integerConversion< localIndex >( wellElemOffset - m_rankOffset ) + WJ_ROFFSET::MASSBAL + ic; + } + for( integer jdof = 0; jdof < NC+1; ++jdof ) + { + dofColIndices[ jdof] = wellElemOffset + WJ_COFFSET::dP + jdof; + } + // For temp its different + if constexpr ( IS_THERMAL ) + { + dofColIndices[ NC+1 ] = wellElemOffset + WJ_COFFSET::dT; + } + // populate local flux vector and derivatives + + for( integer ic = 0; ic < numComp; ++ic ) + { + localPerf[ic] = -m_dt * m_compPerfRate[iperf][ic]; + } + for( integer ic = 0; ic < numComp; ++ic ) + { + localIndex localDofIndexPres = 0; + + localPerfJacobian[ic][localDofIndexPres] = -m_dt * m_dCompPerfRate[iperf][TAG::WELL ][ic][CP_Deriv::dP]; + for( integer jc = 0; jc < numComp; ++jc ) + { + localIndex const localDofIndexComp = localDofIndexPres + jc + 1; + localPerfJacobian[ic][localDofIndexComp] = -m_dt * m_dCompPerfRate[iperf][TAG::WELL ][ic][CP_Deriv::dC+jc]; + } + if constexpr ( IS_THERMAL ) + { + localIndex localDofIndexTemp = localDofIndexPres + NC + 1; + localPerfJacobian[ic][localDofIndexTemp] = -m_dt * m_dCompPerfRate[iperf][TAG::WELL ][ic][CP_Deriv::dT]; + } + } + + if( m_useTotalMassEquation ) + { + stackArray1d< real64, resNumDOF > work( resNumDOF ); + shiftBlockRowsAheadByOneAndReplaceFirstRowWithColumnSum( numComp, numComp, resNumDOF, 1, localPerfJacobian, work ); + + // Apply equation/variable change transformation(s) + shiftBlockElementsAheadByOneAndReplaceFirstElementWithSum( numComp, numComp, 1, localPerf ); + } + + for( localIndex i = 0; i < localPerf.size(); ++i ) + { + if( eqnRowIndices[i] >= 0 && eqnRowIndices[i] < m_localMatrix.numRows() ) + { + m_localMatrix.addToRowBinarySearchUnsorted< parallelDeviceAtomic >( eqnRowIndices[i], + dofColIndices.data(), + localPerfJacobian[i].dataIfContiguous(), + resNumDOF ); + RAJA::atomicAdd( parallelDeviceAtomic{}, &m_localRhs[eqnRowIndices[i]], localPerf[i] ); + } + } + + compFluxKernelOp( wellElemOffset, iwelem, dofColIndices ); + + } + + +/** + * @brief Performs the kernel launch + * @tparam POLICY the policy used in the RAJA kernels + * @tparam KERNEL_TYPE the kernel type + * @param[in] numElements the number of elements + * @param[inout] kernelComponent the kernel component providing access to setup/compute/complete functions and stack + * variables + */ + template< typename POLICY, typename KERNEL_TYPE > + static void + launch( localIndex const numElements, + KERNEL_TYPE const & kernelComponent ) + { + GEOS_MARK_FUNCTION; + forAll< POLICY >( numElements, [=] GEOS_HOST_DEVICE ( localIndex const ie ) + { + kernelComponent.computeFlux( ie ); + + } ); + } + +protected: + +/// Time step size + real64 const m_dt; + +/// Number of phases + integer const m_numPhases; + + globalIndex const m_rankOffset; +// Perfoation variables + arrayView2d< real64 const > const m_compPerfRate; + arrayView4d< real64 const > const m_dCompPerfRate; + arrayView1d< localIndex const > const m_perfWellElemIndex; + +// Element region, subregion, index + arrayView1d< globalIndex const > const m_wellElemDofNumber; + +// RHS and Jacobian + arrayView1d< real64 > const m_localRhs; + CRSMatrixView< real64, globalIndex const > m_localMatrix; + + integer const m_useTotalMassEquation; +}; + +/** + * @class FaceBasedAssemblyKernelFactory + */ +class IsothermalCompositionalMultiPhaseWellFluxKernelFactory +{ +public: + + /** + * @brief Create a new kernel and launch + * @tparam POLICY the policy used in the RAJA kernel + * @param[in] numComps the number of fluid components + * @param[in] dt time step size + * @param[in] rankOffset the offset of my MPI rank + * @param[in] useTotalMassEquation flag specifying whether to replace one component bal eqn with total mass eqn + * @param[in] dofKey string to get the element degrees of freedom numbers + * @param[in] wellControls object holding well control/constraint information + * @param[in] subregion well subregion + * @param[inout] localMatrix the local CRS matrix + * @param[inout] localRhs the local right-hand side vector + */ + template< typename POLICY > + static void + createAndLaunch( integer const numComps, + real64 const dt, + globalIndex const rankOffset, + string const wellDofKey, + WellElementSubRegion const & subRegion, + PerforationData const * const perforationData, + MultiFluidBase const & fluid, + arrayView1d< real64 > const & localRhs, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags ) + { + isothermalCompositionalMultiphaseBaseKernels::internal::kernelLaunchSelectorCompSwitch( numComps, [&]( auto NC ) + { + integer constexpr NUM_COMP = NC(); + + using kernelType = IsothermalCompositionalMultiPhaseWellFluxKernel< NUM_COMP, 0 >; + kernelType kernel( dt, rankOffset, wellDofKey, subRegion, perforationData, + fluid, localRhs, localMatrix, kernelFlags ); + kernelType::template launch< POLICY >( perforationData->size(), kernel ); + } ); + + } +}; +/********************************************************/ /** * @class FaceBasedAssemblyKernel * @tparam NUM_COMP number of fluid components @@ -383,6 +639,7 @@ class ThermalCompositionalMultiPhaseFluxKernel : public IsothermalCompositionalM * @param[in] kernelFlags flags packed together */ ThermalCompositionalMultiPhaseFluxKernel( real64 const dt, + bool const thermalEffectsEnabled, integer const isProducer, globalIndex const rankOffset, string const wellDofKey, @@ -407,6 +664,7 @@ class ThermalCompositionalMultiPhaseFluxKernel : public IsothermalCompositionalM detectCrossflow, numCrossFlowPerforations, kernelFlags ), + m_thermalEffectsEnabled( thermalEffectsEnabled ), m_isProducer( isProducer ), m_globalWellElementIndex( subRegion.getGlobalWellElementIndex() ), m_energyPerfFlux( perforationData->getField< fields::well::energyPerforationFlux >()), @@ -432,6 +690,8 @@ class ThermalCompositionalMultiPhaseFluxKernel : public IsothermalCompositionalM stackArray1d< globalIndex, 2*resNumDOF > & dofColIndices, localIndex const iwelem ) { + if( !m_thermalEffectsEnabled ) + return; // No energy equation if top element and Injector // Top element defined by global index == 0 // Assumption is global index == 0 is top segment with fixed temp BC @@ -441,7 +701,7 @@ class ThermalCompositionalMultiPhaseFluxKernel : public IsothermalCompositionalM return; } // local working variables and arrays - stackArray1d< localIndex, 2* numComp > eqnRowIndices( 2 ); + stackArray1d< localIndex, 2* numComp > eqnRowIndices( 2* numComp ); stackArray1d< real64, 2 * numComp > localPerf( 2 ); stackArray2d< real64, 2 * resNumDOF * 2 * numComp > localPerfJacobian( 2, 2 * resNumDOF ); @@ -510,6 +770,8 @@ class ThermalCompositionalMultiPhaseFluxKernel : public IsothermalCompositionalM } protected: + /// Flag specifying whether thermal effects are enabled + bool const m_thermalEffectsEnabled; /// Well type integer const m_isProducer; @@ -545,6 +807,7 @@ class ThermalCompositionalMultiPhaseFluxKernelFactory template< typename POLICY > static void createAndLaunch( integer const numComps, + integer const thermalEffectsEnabled, integer const isProducer, real64 const dt, globalIndex const rankOffset, @@ -565,7 +828,7 @@ class ThermalCompositionalMultiPhaseFluxKernelFactory integer constexpr NUM_COMP = NC(); using kernelType = ThermalCompositionalMultiPhaseFluxKernel< NUM_COMP, 1 >; - kernelType kernel( dt, isProducer, rankOffset, wellDofKey, subRegion, resDofNumber, perforationData, + kernelType kernel( dt, thermalEffectsEnabled, isProducer, rankOffset, wellDofKey, subRegion, resDofNumber, perforationData, fluid, localRhs, localMatrix, detectCrossflow, numCrossFlowPerforations, kernelFlags ); kernelType::template launch< POLICY >( perforationData->size(), kernel ); } ); @@ -573,6 +836,234 @@ class ThermalCompositionalMultiPhaseFluxKernelFactory } }; +/********************************************************/ +/** + * @class FaceBasedAssemblyKernel + * @tparam NUM_COMP number of fluid components + * @brief Define the interface for the assembly kernel in charge of flux terms + */ +template< integer NC, integer IS_THERMAL > +class ThermalCompositionalMultiPhaseWellFluxKernel : public IsothermalCompositionalMultiPhaseWellFluxKernel< NC, IS_THERMAL > +{ +public: + using Base = IsothermalCompositionalMultiPhaseWellFluxKernel< NC, IS_THERMAL >; + /// Compile time value for the number of components + static constexpr integer numComp = NC; + static constexpr integer resNumDOF = NC+1+IS_THERMAL; + + // Well jacobian column and row indicies + using WJ_COFFSET = compositionalMultiphaseWellKernels::ColOffset_WellJac< NC, IS_THERMAL >; + using WJ_ROFFSET = compositionalMultiphaseWellKernels::RowOffset_WellJac< NC, IS_THERMAL >; + + using ROFFSET = compositionalMultiphaseWellKernels::RowOffset; + using COFFSET = compositionalMultiphaseWellKernels::ColOffset; + + using CP_Deriv = multifluid::DerivativeOffsetC< NC, IS_THERMAL >; + + using TAG = compositionalMultiphaseWellKernels::SubRegionTag; + + using Base::m_dt; + using Base::m_localRhs; + using Base::m_localMatrix; + using Base::m_rankOffset; + + + + /// Compute time value for the number of degrees of freedom + static constexpr integer numDof = WJ_COFFSET::nDer; + + /// Compile time value for the number of equations except volume and momentum + static constexpr integer numEqn = WJ_ROFFSET::nEqn - 2; + + /** + * @brief Constructor for the kernel interface + * @param[in] rankOffset the offset of my MPI rank + * @param[in] stencilWrapper reference to the stencil wrapper + * @param[in] dofNumberAccessor + * @param[in] compFlowAccessors + * @param[in] multiFluidAccessors + * @param[in] capPressureAccessors + * @param[in] permeabilityAccessors + * @param[in] dt time step size + * @param[inout] localMatrix the local CRS matrix + * @param[inout] localRhs the local right-hand side vector + * @param[in] kernelFlags flags packed together + */ + ThermalCompositionalMultiPhaseWellFluxKernel( real64 const dt, + bool const thermalEffectsEnabled, + integer const isProducer, + globalIndex const rankOffset, + string const wellDofKey, + WellElementSubRegion const & subRegion, + PerforationData const * const perforationData, + MultiFluidBase const & fluid, + arrayView1d< real64 > const & localRhs, + CRSMatrixView< real64, globalIndex const > const & localMatrix, + BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags ) + : Base( dt, + rankOffset, + wellDofKey, + subRegion, + perforationData, + fluid, + localRhs, + localMatrix, + kernelFlags ), + m_thermalEffectsEnabled( thermalEffectsEnabled ), + m_isProducer( isProducer ), + m_globalWellElementIndex( subRegion.getGlobalWellElementIndex() ), + m_energyPerfFlux( perforationData->getField< fields::well::energyPerforationFlux >()), + m_dEnergyPerfFlux( perforationData->getField< fields::well::dEnergyPerforationFlux >()) + + { } + + + /** + * @brief Compute the local flux contributions to the residual and Jacobian + * @tparam FUNC the type of the function that can be used to customize the computation of the phase fluxes + * @param[in] ie the element index + * @param[inout] stack the stack variables + * @param[in] compFluxKernelOp the function used to customize the computation of the component fluxes + */ + + GEOS_HOST_DEVICE + inline + void computeFlux( localIndex const iperf ) const + { + Base::computeFlux( iperf, [&] ( globalIndex const & wellElemOffset, + localIndex const iwelem, + stackArray1d< globalIndex, resNumDOF > & dofColIndices ) + { + GEOS_UNUSED_VAR( dofColIndices ); + if( !m_thermalEffectsEnabled ) // tjb iso + return; + // No energy equation if top element and Injector + // Top element defined by global index == 0 + // Assumption is global index == 0 is top segment with fixed temp BC + if( !m_isProducer ) + { + if( m_globalWellElementIndex[iwelem] == 0 ) + return; + } + // local working variables and arrays + localIndex eqnRowIndices = LvArray::integerConversion< localIndex >( wellElemOffset - m_rankOffset ) + WJ_ROFFSET::ENERGYBAL; + + stackArray2d< real64, resNumDOF > localPerfJacobian( 1, resNumDOF ); + // populate local flux vector and derivatives + + real64 localPerf = -m_dt * m_energyPerfFlux[iperf]; + + // std::cout << "Local perf: " << iperf << " " << localPerf << std::endl; + localIndex localDofIndexPres = 0; + localPerfJacobian [0][localDofIndexPres] = -m_dt * m_dEnergyPerfFlux[iperf][TAG::WELL][CP_Deriv::dP]; + + // populate local flux vector and derivatives + for( integer ic = 0; ic < numComp; ++ic ) + { + localIndex const localDofIndexComp = localDofIndexPres + ic + 1; + localPerfJacobian [0][localDofIndexComp] = -m_dt * m_dEnergyPerfFlux[iperf][TAG::WELL ][CP_Deriv::dC+ic]; + } + localPerfJacobian [0][localDofIndexPres+NC+1] = -m_dt * m_dEnergyPerfFlux[iperf][TAG::WELL ][CP_Deriv::dT]; + + if( eqnRowIndices >= 0 && eqnRowIndices < m_localMatrix.numRows() ) + { + // tjb iso + m_localMatrix.template addToRowBinarySearchUnsorted< parallelDeviceAtomic >( eqnRowIndices, + dofColIndices.data(), + localPerfJacobian[0].dataIfContiguous(), + resNumDOF ); + RAJA::atomicAdd( parallelDeviceAtomic{}, &m_localRhs[eqnRowIndices], localPerf ); + } + } ); + + + } + + + /** + * @brief Performs the kernel launch + * @tparam POLICY the policy used in the RAJA kernels + * @tparam KERNEL_TYPE the kernel type + * @param[in] numElements the number of elements + * @param[inout] kernelComponent the kernel component providing access to setup/compute/complete functions and stack + * variables + */ + template< typename POLICY, typename KERNEL_TYPE > + static void + launch( localIndex const numElements, + KERNEL_TYPE const & kernelComponent ) + { + GEOS_MARK_FUNCTION; + forAll< POLICY >( numElements, [=] GEOS_HOST_DEVICE ( localIndex const ie ) + { + kernelComponent.computeFlux( ie ); + + } ); + } + +protected: + /// Thermal effects enabled + bool const m_thermalEffectsEnabled; + /// Well type + integer const m_isProducer; + + /// Global index of local element + arrayView1d< globalIndex const > m_globalWellElementIndex; + + /// Views on energy flux + arrayView1d< real64 const > const m_energyPerfFlux; + arrayView3d< real64 const > const m_dEnergyPerfFlux; +}; + +/** + * @class ThermalCompositionalMultiPhaseFluxWellKernelFactory + */ +class ThermalCompositionalMultiPhaseWellFluxKernelFactory +{ +public: + + /** + * @brief Create a new kernel and launch + * @tparam POLICY the policy used in the RAJA kernel + * @param[in] numComps the number of fluid components + * @param[in] dt time step size + * @param[in] rankOffset the offset of my MPI rank + * @param[in] useTotalMassEquation flag specifying whether to replace one component bal eqn with total mass eqn + * @param[in] dofKey string to get the element degrees of freedom numbers + * @param[in] wellControls object holding well control/constraint information + * @param[in] subregion well subregion + * @param[inout] localMatrix the local CRS matrix + * @param[inout] localRhs the local right-hand side vector + */ + template< typename POLICY > + static void + createAndLaunch( integer const numComps, + WellControls const & wellControls, + integer const isProducer, + real64 const dt, + globalIndex const rankOffset, + string const wellDofKey, + WellElementSubRegion const & subRegion, + PerforationData const * const perforationData, + MultiFluidBase const & fluid, + BitFlags< isothermalCompositionalMultiphaseBaseKernels::KernelFlags > kernelFlags, + arrayView1d< real64 > const & localRhs, + CRSMatrixView< real64, globalIndex const > const & localMatrix + ) + { + isothermalCompositionalMultiphaseBaseKernels::internal::kernelLaunchSelectorCompSwitch( numComps, [&]( auto NC ) + { + integer constexpr NUM_COMP = NC(); + + using kernelType = ThermalCompositionalMultiPhaseWellFluxKernel< NUM_COMP, 1 >; + kernelType kernel( dt, wellControls.thermalEffectsEnabled(), isProducer, rankOffset, wellDofKey, subRegion, perforationData, + fluid, localRhs, localMatrix, kernelFlags ); + kernelType::template launch< POLICY >( perforationData->size(), kernel ); + } ); + + } +}; + } // end namespace coupledReservoirAndWellKernels } // end namespace geos diff --git a/src/coreComponents/physicsSolvers/multiphysics/CoupledReservoirAndWellsBase.cpp b/src/coreComponents/physicsSolvers/multiphysics/CoupledReservoirAndWellsBase.cpp index 1982739401f..3f544f2160d 100644 --- a/src/coreComponents/physicsSolvers/multiphysics/CoupledReservoirAndWellsBase.cpp +++ b/src/coreComponents/physicsSolvers/multiphysics/CoupledReservoirAndWellsBase.cpp @@ -116,7 +116,7 @@ addCouplingNumNonzeros( PhysicsSolverBase const * const solver, } bool validateWellPerforations( PhysicsSolverBase const * const reservoirSolver, - WellSolverBase const * const wellSolver, + WellManager const * const wellSolver, DomainPartition const & domain ) { std::pair< string, string > badPerforation; diff --git a/src/coreComponents/physicsSolvers/multiphysics/CoupledReservoirAndWellsBase.hpp b/src/coreComponents/physicsSolvers/multiphysics/CoupledReservoirAndWellsBase.hpp index 32a67843aec..c7a1f3ea030 100644 --- a/src/coreComponents/physicsSolvers/multiphysics/CoupledReservoirAndWellsBase.hpp +++ b/src/coreComponents/physicsSolvers/multiphysics/CoupledReservoirAndWellsBase.hpp @@ -29,7 +29,7 @@ #include "mesh/PerforationFields.hpp" #include "mesh/DomainPartition.hpp" #include "physicsSolvers/fluidFlow/wells/WellControls.hpp" -#include "physicsSolvers/fluidFlow/wells/WellSolverBase.hpp" +#include "physicsSolvers/fluidFlow/wells/WellManager.hpp" namespace geos { @@ -65,7 +65,7 @@ addCouplingNumNonzeros( PhysicsSolverBase const * const solver, * @param domain the physical domain object */ bool validateWellPerforations( PhysicsSolverBase const * const reservoirSolver, - WellSolverBase const * const wellSolver, + WellManager const * const wellSolver, DomainPartition const & domain ); } diff --git a/src/coreComponents/physicsSolvers/multiphysics/SinglePhaseReservoirAndWells.cpp b/src/coreComponents/physicsSolvers/multiphysics/SinglePhaseReservoirAndWells.cpp index ca582820992..898be9c3055 100644 --- a/src/coreComponents/physicsSolvers/multiphysics/SinglePhaseReservoirAndWells.cpp +++ b/src/coreComponents/physicsSolvers/multiphysics/SinglePhaseReservoirAndWells.cpp @@ -137,6 +137,29 @@ initializePreSubGroups() Base::initializePreSubGroups(); SinglePhaseBase const * const flowSolver = this->flowSolver(); Base::wellSolver()->setFlowSolverName( flowSolver->getName() ); + + bool const isThermalFlow = flowSolver->getReference< integer >( SinglePhaseBase::viewKeyStruct::isThermalString() ); + bool const isThermalWell = Base::wellSolver()->template getReference< integer >( WellManager::viewKeyStruct::isThermalString() ); + GEOS_THROW_IF( isThermalFlow != isThermalWell, + GEOS_FMT( "{}: the input flag {} must be the same in the flow and well solvers, respectively '{}' and '{}'", + this->getDataContext(), SinglePhaseBase::viewKeyStruct::isThermalString(), + Base::reservoirSolver()->getDataContext(), Base::wellSolver()->getDataContext() ), + InputError, this->getDataContext(), Base::reservoirSolver()->getDataContext(), Base::wellSolver()->getDataContext() ); + DomainPartition & domain = this->template getGroupByPath< DomainPartition >( "/Problem/domain" ); + + this->template forDiscretizationOnMeshTargets<>( domain.getMeshBodies(), [&] ( string const &, + MeshLevel & mesh, + string_array const & regionNames ) + { + ElementRegionManager & elemManager = mesh.getElemManager(); + elemManager.forElementSubRegions< WellElementSubRegion >( regionNames, [&]( localIndex const, + WellElementSubRegion const & subRegion ) + { + WellControls & wellControls = Base::wellSolver()->getWellControls( subRegion ); + wellControls.setFlowSolverName( flowSolver->getName() ); + + } ); + } ); } template< typename RESERVOIR_SOLVER > diff --git a/src/coreComponents/physicsSolvers/multiphysics/SinglePhaseReservoirAndWells.hpp b/src/coreComponents/physicsSolvers/multiphysics/SinglePhaseReservoirAndWells.hpp index 0adeee58026..98da0ab2737 100644 --- a/src/coreComponents/physicsSolvers/multiphysics/SinglePhaseReservoirAndWells.hpp +++ b/src/coreComponents/physicsSolvers/multiphysics/SinglePhaseReservoirAndWells.hpp @@ -23,7 +23,7 @@ #include "physicsSolvers/multiphysics/CoupledReservoirAndWellsBase.hpp" #include "physicsSolvers/fluidFlow/SinglePhaseBase.hpp" -#include "physicsSolvers/fluidFlow/wells/SinglePhaseWell.hpp" +#include "physicsSolvers/fluidFlow/wells/WellManager.hpp" namespace geos { @@ -31,12 +31,12 @@ namespace geos /// @tparam RESERVOIR_SOLVER single-phase flow or single-phase poromechanics solver template< typename RESERVOIR_SOLVER = SinglePhaseBase > class SinglePhaseReservoirAndWells : public CoupledReservoirAndWellsBase< RESERVOIR_SOLVER, - SinglePhaseWell > + WellManager > { public: using Base = CoupledReservoirAndWellsBase< RESERVOIR_SOLVER, - SinglePhaseWell >; + WellManager >; using Base::m_solvers; using Base::m_linearSolverParameters; diff --git a/src/coreComponents/schema/schema.xsd b/src/coreComponents/schema/schema.xsd index e78160e9ce0..ebfc86d5b58 100644 --- a/src/coreComponents/schema/schema.xsd +++ b/src/coreComponents/schema/schema.xsd @@ -363,10 +363,6 @@ - - - - @@ -511,10 +507,6 @@ - - - - @@ -543,6 +535,10 @@ + + + + @@ -2788,12 +2784,6 @@ Information output from lower logLevels is added with the desired log level - - - - - - @@ -2830,12 +2820,6 @@ Information output from lower logLevels is added with the desired log level - - - - - - @@ -2843,6 +2827,16 @@ Information output from lower logLevels is added with the desired log level + + + + + + + + + + @@ -3682,144 +3676,6 @@ When set to `all` output both convergence & iteration information to a csv.--> - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -5725,52 +5581,6 @@ Local- Add jump stabilization on interior of macro elements--> - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -6256,6 +6066,445 @@ When set to `all` output both convergence & iteration information to a csv.--> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/coreComponents/schema/schema.xsd.other b/src/coreComponents/schema/schema.xsd.other index 8972cbe655c..acd3c24b757 100644 --- a/src/coreComponents/schema/schema.xsd.other +++ b/src/coreComponents/schema/schema.xsd.other @@ -570,7 +570,6 @@ A field can represent a physical variable. (pressure, temperature, global compos - @@ -607,7 +606,6 @@ A field can represent a physical variable. (pressure, temperature, global compos - @@ -615,6 +613,7 @@ A field can represent a physical variable. (pressure, temperature, global compos + @@ -867,27 +866,6 @@ A field can represent a physical variable. (pressure, temperature, global compos - - - - - - - - - - - - - - - - - - - - - @@ -1342,18 +1320,6 @@ A field can represent a physical variable. (pressure, temperature, global compos - - - - - - - - - - - - @@ -1497,6 +1463,69 @@ A field can represent a physical variable. (pressure, temperature, global compos + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/docs/sphinx/basicExamples/multiphaseFlowWithWells/Example.rst b/src/docs/sphinx/basicExamples/multiphaseFlowWithWells/Example.rst index 7fb95a4a927..640caa64300 100644 --- a/src/docs/sphinx/basicExamples/multiphaseFlowWithWells/Example.rst +++ b/src/docs/sphinx/basicExamples/multiphaseFlowWithWells/Example.rst @@ -67,7 +67,7 @@ It is illustrated in :ref:`TutorialPoroelasticity` for a poroelastic test case. The three solvers employed in this example are: - the single-physics reservoir flow solver, a solver of type **CompositionalMultiphaseFVM** named ``compositionalMultiphaseFlow`` (more information on this solver at :ref:`CompositionalMultiphaseFlow`), - - the single-physics well solver, a solver of type **CompositionalMultiphaseWell** named ``compositionalMultiphaseWell`` (more information on this solver at :ref:`CompositionalMultiphaseWell`), + - the single-physics well solver manager, a solver of type **WellManager** named ``compositionalMultiphaseWell`` (more information on this solver at :ref:`CompositionalMultiphaseWell`), - the coupling solver that binds the two single-physics solvers above, an object of type **CompositionalMultiphaseReservoir** named ``coupledFlowAndWells``. The **Solvers** XML block is shown below. @@ -146,7 +146,7 @@ needed in the XML file to define them. Each well is defined internally (i.e., not imported from a file) in a separate **InternalWell** XML sub-block. An **InternalWell** sub-block must point to the region corresponding to this well using the attribute -``wellRegionName``, and to the control of this well using the attribute ``wellControl``. +``wellRegionName``, and to the control of this well using the attribute ``control``. Each well is defined using a vertical polyline going through the seven layers of the mesh with a perforation in each layer. From 3698d7d7dcc0cc7a5519b6d2f856b68ac8b0fd1c Mon Sep 17 00:00:00 2001 From: Sushma Yellapragada Date: Mon, 3 Aug 2026 03:10:54 -0500 Subject: [PATCH 5/9] Fix AOCC shadow warning and VTK global ID SIGFPE (#4098) some changes that were needed to succesfully compile and pass unit tests in our environment (AOCC Compiler, AOCL). 1. Variable shadowing solved, 2. testSinglePhaseMFDPolyhedral failed intermittently during mesh initialization, crash solved by disabled FPE trapping. --- src/coreComponents/mesh/generators/VTKUtilities.cpp | 4 ++++ .../contact/SolidMechanicsAugmentedLagrangianContact.cpp | 4 ++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/coreComponents/mesh/generators/VTKUtilities.cpp b/src/coreComponents/mesh/generators/VTKUtilities.cpp index 2bf0d4f02e5..1dca5f69d5f 100644 --- a/src/coreComponents/mesh/generators/VTKUtilities.cpp +++ b/src/coreComponents/mesh/generators/VTKUtilities.cpp @@ -199,6 +199,10 @@ generateGlobalIDs( vtkSmartPointer< vtkDataSet > mesh ) { GEOS_MARK_FUNCTION; + // vtkGenerateGlobalIds may trigger floating-point exceptions internally + // Temporarily disable FPE trapping while invoking VTK. + LvArray::system::FloatingPointExceptionGuard guard; + vtkNew< vtkGenerateGlobalIds > generator; generator->SetInputDataObject( mesh ); generator->Update(); diff --git a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp index c4145ee9318..a928891a726 100644 --- a/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp +++ b/src/coreComponents/physicsSolvers/solidMechanics/contact/SolidMechanicsAugmentedLagrangianContact.cpp @@ -1257,7 +1257,7 @@ bool SolidMechanicsAugmentedLagrangianContact::updateConfiguration( DomainPartit { ElementRegionManager & elemManager = mesh.getElemManager(); - elemManager.forElementSubRegions< FaceElementSubRegion >( regionNames, [m_symmetric=m_symmetric]( localIndex const, + elemManager.forElementSubRegions< FaceElementSubRegion >( regionNames, [symmetric = m_symmetric]( localIndex const, FaceElementSubRegion & subRegion ) { @@ -1293,7 +1293,7 @@ bool SolidMechanicsAugmentedLagrangianContact::updateConfiguration( DomainPartit oldDispJump, dispJump, iterativePenalty, - m_symmetric, + symmetric, normalTractionTolerance, traction, fractureState ); From aeefcba527245fb60b522fc127b9cb09c8278577 Mon Sep 17 00:00:00 2001 From: Tom Byer <149726499+tjb-ltk@users.noreply.github.com> Date: Mon, 3 Aug 2026 04:13:48 -0700 Subject: [PATCH 6/9] fix: Global well residual norm calc (#4100) Solved a bug where a shut well following a non-converged open well reset the max well residual to zero, letting the simulation falsely converge. Affected compositional models only (well segment flow residuals). --- BASELINE_NOTES.md | 1 - .../fluidFlow/wells/CompositionalMultiphaseWell.cpp | 1 - 2 files changed, 2 deletions(-) diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index a317d171a60..cf9dbd6c1a2 100644 --- a/BASELINE_NOTES.md +++ b/BASELINE_NOTES.md @@ -9,7 +9,6 @@ PR #3972 (2026-07-28) -===================== Added statistics `Group` objects for each statistics `Task` instance PR #4040 (2026-06-16) diff --git a/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp b/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp index fa9f19b140a..66ad4b387dd 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp @@ -1502,7 +1502,6 @@ CompositionalMultiphaseWell::calculateLocalWellResidualNorm( real64 const & time { for( integer i = 0; i < numNorm; ++i ) { - localResidualNorm[i] = 0.0; localResidualNormalizer[i] = nonlinearSolverParameters.m_minNormalizer; } } From aa5d9c1a865fb6fba152ab21196d39ef876ebb97 Mon Sep 17 00:00:00 2001 From: Dickson Kachuma <81433670+dkachuma@users.noreply.github.com> Date: Wed, 5 Aug 2026 08:06:07 -0500 Subject: [PATCH 7/9] Reset fluid state after convergence failure (#4088) Fix a bug breaking determinism in numerical Jacobian tests, where iterate-dependent constitutive state persisted across Newton attempts. Update CompositionalMultiphaseBase::resetStateToBeginningOfStep to explicitly discard warm-started state held by the fluid model by calling fluid.initializeState(). This guarantees that rolled-back steps start clean and do not inherit iterate-dependent state from failed Newton attempts. --- .integrated_tests.yaml | 2 +- BASELINE_NOTES.md | 3 +++ .../fluidFlow/CompositionalMultiphaseBase.cpp | 8 ++++++++ 3 files changed, 12 insertions(+), 1 deletion(-) diff --git a/.integrated_tests.yaml b/.integrated_tests.yaml index 7cf1a5ce23b..94ec9a64586 100644 --- a/.integrated_tests.yaml +++ b/.integrated_tests.yaml @@ -1,6 +1,6 @@ baselines: bucket: geosx - baseline: integratedTests/baseline_integratedTests-pr3972-17154-316e6d8 + baseline: integratedTests/baseline_integratedTests-pr4088-17188-4247846 allow_fail: all: '' diff --git a/BASELINE_NOTES.md b/BASELINE_NOTES.md index cf9dbd6c1a2..b833684e8de 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 #4088 (2026-07-27) +Fluid reset after convergence failure + PR #3972 (2026-07-28) Well model refactor . Integrated test update due to schema changes diff --git a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.cpp b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.cpp index 93c17c765ec..03ec8ffe48a 100644 --- a/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.cpp +++ b/src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseBase.cpp @@ -2790,6 +2790,14 @@ void CompositionalMultiphaseBase::resetStateToBeginningOfStep( DomainPartition & // update porosity, permeability updatePorosityAndPermeability( subRegion ); + // discard any warm-started state held by the fluid model (e.g. K-values + // used to seed the flash) so the rolled-back step does not inherit + // iterate-dependent state from the failed Newton attempt. + { + string const & fluidName = subRegion.template getReference< string >( viewKeyStruct::fluidNamesString() ); + MultiFluidBase const & fluid = getConstitutiveModel< MultiFluidBase >( subRegion, fluidName ); + fluid.initializeState(); + } // update all fluid properties updateFluidState( subRegion ); // for thermal simulations, update solid internal energy From 4cc6f8307236fa08a2701cca13324877b61bd6e8 Mon Sep 17 00:00:00 2001 From: npillardou Date: Fri, 7 Aug 2026 10:49:16 +0200 Subject: [PATCH 8/9] Update thermo poromechanics doc --- .../thermalConsolidation/Example.rst | 35 +- .../displacementHistory.hdf5 | Bin 14142952 -> 0 bytes .../plotTests_tutorial_updated.py | 540 ++++++++++++++++++ .../thermalConsolidation/pressureHistory.hdf5 | Bin 2467672 -> 0 bytes .../temperatureHistory.hdf5 | Bin 2469888 -> 0 bytes .../thermalConsolidationDisplacementFigure.py | 86 --- .../thermalConsolidationPressureFigure.py | 82 --- .../thermalConsolidationTemperatureFigure.py | 85 --- .../thermoConsolidationDisp_1p4m.csv | 64 --- .../thermoConsolidationDisp_4p2m.csv | 73 --- .../thermoConsolidationDisp_7m.csv | 70 --- .../thermoConsolidationPressure_0m.csv | 83 --- .../thermoConsolidationPressure_4p2m.csv | 78 --- .../thermoConsolidationPressure_5p6m.csv | 76 --- .../thermoConsolidationTemp_0m.csv | 79 --- .../thermoConsolidationTemp_4p2m.csv | 79 --- .../thermoConsolidationTemp_5p6m.csv | 81 --- 17 files changed, 562 insertions(+), 949 deletions(-) delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/displacementHistory.hdf5 create mode 100755 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/plotTests_tutorial_updated.py delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/pressureHistory.hdf5 delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/temperatureHistory.hdf5 delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationDisplacementFigure.py delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationPressureFigure.py delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationTemperatureFigure.py delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationDisp_1p4m.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationDisp_4p2m.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationDisp_7m.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationPressure_0m.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationPressure_4p2m.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationPressure_5p6m.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationTemp_0m.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationTemp_4p2m.csv delete mode 100644 src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationTemp_5p6m.csv diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/Example.rst b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/Example.rst index 32461b48560..0d6f6359dca 100644 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/Example.rst +++ b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/Example.rst @@ -187,19 +187,28 @@ On the top surface, we impose the traction boundary condition and the non-isothe Inspecting results --------------------------------- -We request an output of the displacements, pressure, and temperature using the **TimeHistory** feature of GEOS. -The figures below compare the results from GEOS (dashed line) and the corresponding analytical solution (solid line) as a function of time at different locations of the slab. -We obtain a very good match, confirming that GEOS can accurately capture the thermo-poromechanical coupling on this example. The first figure illustrates this good agreement for the pressure evolution. - -.. plot:: docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationPressureFigure.py - -The second figure confirms the good match with the analytical solution for the temperature. - -.. plot:: docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationTemperatureFigure.py - -The third figure shows that GEOS is also able to match the vertical displacement (settlement) analytical solution. - -.. plot:: docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationDisplacementFigure.py + We request an output of the displacements, pressure, temperature, and stress using the + **TimeHistory** feature of GEOS. + The figure below compares the results from GEOS (open circles) with the corresponding + analytical solution (solid lines) as a function of time at different locations along the slab. + We obtain a very good match for all four quantities, confirming that GEOS accurately captures + the thermo-poromechanical coupling on this example. + + - The top-left panel shows the excellent agreement for the **pore pressure** evolution: + the initial thermally- and mechanically-induced overpressure gradually dissipates as the + fluid drains through the top surface. + - The top-right panel confirms the good match for the **temperature**, which diffuses from + the heated top boundary into the column. + - The bottom-left panel shows that GEOS also reproduces the **vertical displacement** + (settlement), including the characteristic non-monotonic response (thermal expansion + followed by consolidation). + - The bottom-right panel compares the **total stress**. By equilibrium, the total vertical + stress remains equal to the applied surface load at all times and depths + (:math:`\sigma_{yy} = -F`), which GEOS recovers exactly. The total horizontal stress + :math:`\sigma_{xx} = \sigma_{zz}` follows the analytical thermo-poroelastic solution, + exhibiting the transient overshoot driven by the coupled pressure and thermal fields. + + .. plot:: docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/plotTests_tutorial_updated.py ------------------------------------------------------------------ To go further diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/displacementHistory.hdf5 b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/displacementHistory.hdf5 deleted file mode 100644 index 7c6f53df87236aea991c38936fba32172ba002e5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 14142952 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 z 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

J!16 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

XI$*OTcwo_IC{4F88Uf;HFmZ@(X9ky=fr$ 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 z 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%0DlABln0&*-9$a*3*F=oz7)D?4R{UcCQb0U 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

L&8d&`ti}ouQj7z*|8#wF3`< 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
p?eB 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

wT9LfJ0j^zitjm&#azB~^ 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%0ABsB(DG%4+^6cjuh~~QtM64hCHJY-;LW~; zF58kJ_o>F<$=7D89*&dy)IRXc8*L)`&zJjDKDe><%17PpAS|?{tW-+^4RB z?gS+z3Pk!YOqG$&jJ7PxMb4ckMjOAcmu}?^^c8_ zdy^V?b@CD`x8pV3r_}5!lhT?EXfF37P4JDgm8J|{An!MT52!4%n)N{58-QEnDSk^g zl=~6+5XYVS+i#Hfqrvw*Xji!9i@ZMot`^W%RmWEDO-;bZC{0$#*eCDJ!CQXbA7`g1 z_aja4DK8h6zH^uNGr>0ncYni zd7lD4EYCb^Xd}5F*@EY8(au;pN#0)rS5^oK-*H^tYk-eE8Zjb4QSL#Lz(2)wcUbBu z@4tZ$oYBDDXqUV<1=oKN?S133yzd7dP#k>4c#zzW7K5j$jn)eZllR%+GjH05ZMh@w z1HfYkMfF|VTJB9z;E%(t9@8DCnt~&`rMJAEBFmfNMZEser3NH#G)Vhi;;tiid96 z2~Itw4?Q&;dddvk8oG)65OmXCa3$!by5N@3O-|sgp_|mfshg%jPenjCMS~B3ZZZXL z1KrddJQ2ESKe!!qlMVP8=%x$c&7qs>gHMERatHqi-SiXO5W2|#+!(s47x*IRre)yy z&`s&!ZqQAW!FND6Z3TY~-Siy%ANeF+>s(%ayuZ8Lr+mO`?HS$ip_|;Ne(tW>x3+j{ z{9%~fr;dXA=QaE0?ke}Gwc!6X4XdY|F83)z@JU6to=qPr_o-#zjeE|uGQKAFssF$~ z+0WCM;w1N}DsYdqf|!d>a0dk*m z0RKE>Ou(4ma-Sl9yX;2!jV!rOeFmR>`{lK`#d4nt0(b9}kg(N6?o(sI_YWzKx>70k zsbk>dmHJs}WXgTY6@1J2-HQ#fz0RBEJ~b6Q=ViL-*9CH)x(a?cZ=l9c z2f0tBf_Hzq=d^2Yxli>4->UIuji##Hn|6@jc^1*(jl53*e{jKd)2uwXPZff1jPM=s zWsBUWHiNevF#6Iif4NU-f%|;-^9Zz&`_w}47AHp+PwOQ2rrzKe_1vpHD&+kW@SD}q zJ>9O$ed-Q){;c7-Ba`Gl^%Q*UfF*@p=E;4^8T?0+^?^?<-w3ea^<}(xR%e8&69NGe$)(n>N(SKPHW}; zEbwvNdYp|YllNo6OP4Aht!*#&rcdBA59%u(Iw9{Dfo~{&zc0Ln+>dsGuSinfxgkK_ zF9(nEdR_ZmfxKS}J~?evMU(z=KO)cg6u=U!_%XrRs#d z-vB;*qu=^J_2eF851wm0bH`&Rd7lrSo~yezZnwP80bje_=V*^|c^?hlc2(ylTTJDC z)ERuhx-_4sYvlb9@O6WGT&lP$@3(?)>QLAJZ5z2aZ2*5ZJ6rSMRC)g#Tm;iUU?p_Z z?@KjzRwwAGPta32&`n9;QP54n-~*wX`hYKjZkh$&8M>)C_%GB)n*zWuLN{Fj zZw=j~3hoKr=#_+#j%0`NHKrfBeP&`mAD7eF`70`CRg)D`?b zbkkMvhtN&bSby6F=5Sm-7f@G;O$R^Zf4n$T0; z&`qgP1V~5Fo$`Slq%C$Q=H{?FmY;VoJ>vwGF;PG;wIs{&@e&wO6=W?HV3qE6C z&eIRas@55Tp}FON8|Q0`Ou;JMzu!MRRypUMVLY-9V=ppV?A_JO}Swn9On zk=&c!fnOTGE4jrxd4CIh!R+{~x##3Q6#!n~qj9s&cDYYI0ypY5&hYGfxlb8@pFZZT zynB?~r!ImI&dct;y|dh#oWafC4Y%I;yM}x4`HS8ar`(kLR3LcUF&>sXcgcOKA9zpa zWm{J+ko%NAxI?oKFD*vMeQE;usKd&&3$*0kWCtFr6p-8Ft-Rk19f?{cU9kU{`Eq6uL~ZPkhQ7BLwUazJh`*dUC#k>KO&zI zn{w&KCV3wSZaS^)Tbpn4-V8iawZp}NF>-H;0dF=Xw6jmDysr$kyjKbis_vps&4QMkO12cMbLe2>F@dA|UB zzzsWF^LBD?G5`;4qx!Y}G`8{7lBX*zf! zbW<$2Gjx*&xEXYlDR>xk({k{C89193yF zS zYvC&Qsea(La~=NEE0O!u1aRl6Gwctal>5{KaQDaR8Y2VcKIH{oH)!2LcN4i!se&7y zzG8a6TJBTi(>oXB?LH&-skz{nsw&D)hsu5GKDgJ<36711%6-ZMeBKN1Z(+6D=KTF1 zMi6+X#v_56$bD)C_|6l-9=o^6eJUBeTe&w%n&;!4JL2*TQ-{DUjqJ)&tmQss2mX57RplYA<=*rb zyl>7m!yWJCy%G2k*VGmdUFF`C2L8r%x~?l#$$z^1%Xmji#Y<^4eL%JJ9gIH=40sGf7p-h4^Vp;4alUK>0!%gyBQ zDS4j{Zq;*^+7V^B2ib!gJ4CdN8ZYn7z<)${(Y8*J_rJlbb22+W`zG(}=GN@x7E2b5 z93uClAK<2$$8WBWkoOkglWX75KJY-^`+)!1GVtn__Hu9f1#bE7+nkAB^4(*STQ=%yCnzR*qf;CawZhrx$JHw^^WhHh#J{sy|~3AjFVlPVpCLeG==%%^gy3kG3Szgdh)4=yYHzj}@ zLO1DyZ-#E#1l||AsSkKJ=%)7ILC{S;;BTOtsI#c2l%S{fK{ss%cYEVaFNJO@1NVY% zngt#J-4qNy3A$-4cnoyY25@!grWW8~&`mMmN1&VbgHunPfu1@A-INAi8@j0yI;%Bw zQw#89=%(Y~3!$6lfO|kUxqwGPH^qW0K{run^@eWh3f>pGX%KjQ=%za0n$S(H!7oBL zQD=>TZn6b8f^ISg{|w#q30wubsS-NtJ9N_@a9ijmGjMz8rt#p)TWjvAdf;QAo2Ld8duZGR5rpSFN5q#0Z zz0bX}e&b%i73J{1Y>x1e%%+FiL%#ek3KzpmnqyWFQ7!PQUdv~zeP_o)ux zudgobH2aj?r{009pSjrDFi7rGt-wFUrzy`hmHX5W@OfHmw=}8ULhL*K-~$dAwpTtU z_bC(b6-mp3ELX^VDiXZ;v+Fv!!{k1t3O=pvn2r+_fw|H=xO4xlio@zwW7{VBswHsY~F~8wREn8p?gj7yMzL zhZ%WI<=*rNe9Z2_W8F0Bc5nIQ40mRH^qTp@A#r??|bt8CiumOHBSfamHX5a z@XT;?7lRr zf-mt8x-fcwmWx+?#%ammV&hsBu`{KLsBW`eoQ*6}cao zfuEWGYO&Q6d4CDK|CDwUo@U8=1MnYh(ico`CikOH;LE3!M7^Fa??b`Ei@G1R%a!+0 z;QL>NXs0xj`_T#T5*NdH#na^dSMXC)Qv>Q|$omW6yPm$WQEVXhpo8Fx%L-kJo#p*9 zaLaQ6ZaenM`;p+6PwW_P@I&6;0FSax-kUg7?nfKJl@-ral&q8YO~6x|G_q1Cl=m6n zjYAfcm35GNlPb9Ljoz`xz2*IQ@V|TMU(cPOn>Imb1wc3T0k4K`Dg@sT-4p}92D)h} z_-g2;h2UY(O^d+CKsOBq*Mn}-1*dNM2tB0>-9$a5yt(F{ss%nDx@k5zb(1ml)LQ7K zRp9E-O|8JEKsQYSe+Jz|J(URElmJfM)B<{nx+w{I>IQVvRq#d7O$))FKsVh5cZF^m z1-|wFsi!tWPql|`Y7D*-x+w^JCUlc0_JeBo&()Poz()mNe`U5 zX&ZEw6?Bs&_-g2;aPSc5sX*|9&`n3d>p?d)0M~(T>ILo#-Q)#+9J(nD{48|SMQ{cG zntQ4NcnoyYI&kW#8PHQlpqt32LN`qW{{Y?e7W@TtQyKVB=%#_-7onTZg7<)K(g*(x z-9(+W0=j82_!{V@81OXcrla6*pqom;shiTFrw%|j?FA2lZdwUG1iHx#{2p{uK6os2 z(^l}7&`k}%w?jAW0&fM~qzOJ5y2%avU;Xs=`^6uRC=I?S_o;mFw}CIsujI>p>J9jo zOt;Av8{|Hf34XM)NyLxya-X^bUTN7<`ROmYPt_Yyv){GlYP$iX(sokbnsP+D}OkCllSDKGD6gz-jn;36L_3Xw`J!~$bD)r zxKf94JF8>mK2;xl#*14K%lza%6#%ZPF{ID%F>-He2Hw1->e#_O<=)f@yhHV(s3|IP zZ|VYGoM&RQw?y8Tg6noOy5{w@GsB8eT=ureX7>;n!U7d z$Eu?<<=#{dzUu6zLo?gT{U`!FrEiZPw^qpeBj8G1yh4|i%KHZ3k={-ri|pinv<|!^ z`f}IfY4ZLvxV@iQMwixdKO#RFUKDh5sl3kyH`?HHIpu}Cw*ikV-Ke_XT<%8+;4W9+ zoWHeO-n)V?c-C@li+XYong?F?Xkg<7Q|0|Gr;|)g|?`_Uf!<)4?erH zsO3v}9}TX2u}<4Y267K-0bbSnLimei@?J^5W}m5itX<4)c|RY#da#8?yY_MqQZ}pE zYma*Jb@@zruL_>h{7&TAGXeSL_OsO-82iFy2<~4?5U5?Q;yJ0 zI1$Ldg=i97U-tk;M7eIp{JfhH+=y2hHml# z4}fl33LXjFv;w>-bQ3xClnV6JH0UO8@CMLL3gGpjo7BNGp_>kYcZ6>04(EOq9Wh`h{r%L?% zC*ZAaRYd=4Ut8=Qy5PnOO-r(K4fyr1 zb@dE}%YCW{{Ns?N?mHT{62EV)p*8!kk8N8k70P{TIQZWEA=}3#$bBjuytu>7*@OGY zz3C13A8S{elNxewQn0Dn+wCZ9zx;>1?*cw@^78r#1#+Kq2fwDN@u&Kf+^4RCAHLkL zC_YZ^Q`z8;4-9voyg=?##o&iZZ9CXG%6;lI_&Zy>-7flaZ~6@W?aiH0^VH~oQOlM(pf$|o7QS@M1exXl2)hhJLD z{m2SDIWg$rz#w_Q7ku{u_3s-W%KMYxS|h%!uI?xIqqg9;offIjjg|Kg!4LjcF?n4k z?{|T>?7QN=o0Z&;T7l16aJT5@PI?B#yc7<~DNBidzq z<^2lqJ@*Wj^{STl2f+RP13J6d%l#+>e6G)w!L#?&a1TD`^RuDeKjnQec<;->MHVCE zeq;jv#6{_wV!XV6MXq=;ZP#mg{}H^s)8ohvedT`C6?{juVYfvg@_sM)v~hv+4_}q{ z{^0WmoleeeF88BV;9nCO^xZ!}-hTrhRCc~_cCx%T1OK~={`LF;x@i))FLcvD@N>{j ziQvznn{I;ZK{x4ukArR+13nbG$r$`U=%()Ay{MbO`$IPk1~-9j>I-fS-82HcC3F+{ z1L&qF;6I_Ks=zIwo5q9hgKjzo{ua9F9r!QkDe5e3=%!BKF3?SG;5VV0?t-6%Zn_Bm z0=nrbcouZi3Gh$QO<%#kLpN1`Pl9f82DgK58V%kKx~V<*Jm{vm;8xI0!@=F4n_R#P zp_?9qPl0X<0dEN1)E2xLy6H9e1L&q_;M7egp{M+yn}Wa#pqpNR_l9mV1y6)-+6LYL zx~VC6Z|ElKDe5MB=qc(Za_TAaROqIo;BBCr$ge;*T?40XIte{R-J}UU)P^!p4_Kgz?-_CeG>j%?o;aE zizkj*Wt1cLsc`V#-MZ>J4wd_q0l0>#d*>-Sa&Kx5zBE_6XKsDDH?0I8Sp2))gm?1Z z3fyqRqO*oqFV8A?oB7b9d(}^Ij$`CCRgz8Zwwk7Dw6jD!M*yM zEE{=H?o)HXZDLNP4>6T{lO6a2|FIqS?2-4+z=w?tOSe{)`_TySy6HbHd-}=y+Tg## zDv~V=d^Mt9|P}ZP65Y-xmDL zKKBxj^YWftQ*qe+NuA|>qyc_cb6x7fc=XFIe-dBF`y}wJ;srquOyz!*3vReH zLZSIqd2a$fsL*=#_#g7#0NnV~>H*uw$o>pgdENfjy?m?yC zGeV1o*gDJmY2ZHfqXOq0miKeO(_-8V!xiNobQ=8N_u}JG}- zyY7%Jf5!ch_x-_#mN+|V+RFWC6u4Q_4Xd-Z%X>@k`o0<;hJKLujlkWrE;daylKYV- z`0D)l^WRs>`}N=xM|W3ie_P(q0B^WwmcDLlxgWIx_m60FQf;cd_XE#-j2llO6bV=%!@wEa;{L@afP^6Tv@2H&IUoLpKG1zk+Uh2CfU;)Cv3ybkjNT z>CjDn;7QO;TfkpJH$4Ym0Nq4x0o`N`ZV%n$1g-(yqz%3Vx@iTtA#@XYW9X)4;LD(! zLcuMeo2aJ-Ku;NicY9J=W+xC?aC|JqYSp{Hg+H!TErf^H(GZh8ehWewd#ouvTXR1aJM zx`}$q33|!{JPx`k3j7;%(@*dg&`oW?&p}V!25$k~)C`=u={EG#R_LZ};CawZ+2FmQ zn|gs8LN}R%n?g7B2d@L&R1KX~4Bhk=9J>j6$``t6I`~QGrd)99rc=;UKcJ^7!TUis z>495AH(7z3LO0ofD?m5Z2KR<;as!WmZrTLy3*F=iUbVaCo~j2uwFJ6}`~q~-S@3`L z)8Fr_V{~`u>&ty=cx=tC5>T=%zPH?`8iQZ{wCJQ?vD~NLfnS-NUtrKn?o*}U-D{sY z=wU4PsXpKjOK0eMKa=~^Z}8pQmszY?Cikg)@I9kWjN9H>?o%hgpB5~$Fr6&-skh*t ztABs1)kp4AKf(LOE!$7LoI=N3JgFg@M^=#)%xlg?ZFRrEEH-CiOr(T0sjGEB>b!WLZ{Q=Kyl4)L{Aor$B z@YM?~YL!2f_nW|HJ2!fM>6qN7)_{9Vp6=^!4u5KYL^4b5qlVV~Lxp8xvVVdon5 zsq5f9T72@(X(;!jUf{o4O&v4ASKfaI&-QZ->H9$5Uj%=9qP~vFK)E-)23PTzw{-4y zdEW?pz3$|f*A(P_lnCCtQP-T2ljOZA__WBl_|iOiKNUPz`DL>`9p!$M1wK1v$)|ZC z^4 zZSY3WO^v~)LO1z>Q%|WtPyK>!`U&m`JvA156m%1HmI`ze`CaIyd*Gj;o65ndn-Za? zK0r6U0DlYJ^bVYQ>L>Kn73iiM@M!3!aPU>oP0PXOKsR}T?}Khi0`Caj)DoP!Nf&y` z2D)hy_z>tO8}LNvrUdXC&`tNi^`V>ez`sE^{RYp2ZlazlhHm-@t`6PQ06YP@X(#vq z=%zv7-q20+!E>OSGQp{*W42+4H#GrY3f;68{0el_RqzYY zP3hoQp_}f3+d?-D0r!S(nhS0U-82Y%6?D@w@PGBw-|t&T-CI9MPwrC=;F)>4PCL5G zed-{1s}5&oe|jqSDFg5mVQ_MUtKw@k;!DaPu&4G&uDi2Y7ecwuO^r=^+P zryhdeT2y<|gVu7Nx&!_~t1Qp{hrE9XKH+`FfMYl1J~b0uNn2~l`xLoPwFlomd-#|y zOXWUw4E)3mQ@{&c z{*+(YA-|t01aJP?Noz(w`8|{-_?jMi5eD1keI$6N3A0w4)Rp@Yx%${Gqe5!<_x)7C zecz7m`}>;w`GMfs`)}>u(_8LMncyDtwzpjxEAOX(Kebfr8~k0~e*kYW_}#|cW98n| z3EWbxLBscH^4=WWZ|C;~HZA0SG!r~$e$b=y^W=RdcxlBbC;L0{{s*}A$vEB5z2tsm z18y6=_V|{y^4<=7W8Rykwy)&`6Taq zg1?U`xMVb3?oGwuuZq^a|FE@&dvLA$Df{9+%llT~wy!i(`wx?Q)_CyHgQXX)Y?Akp z;LFV&e%rp4_v^v$Ds5PNc7WWEiolz-czr}WOx|mPKMpqT>H9$5KLgjA^f_anw%m`} zfKNA?Vt;Lpyq^u;yI`J9VWzw{1YhU$Y2!6TxgW)YuRL>i;J#7vJ_P(`qsV7I8|D2q z@V|TMU(f!~P2VDG?yQHy2%Fo0d&(X@R`s}Q^6lV zHx+{Khi*Csz7D!+1$ZauruN{}O$(s2sGIIVPgz4ZkyB5_Ku;ZjZaN75270Old^>a# zId#(w=&3c(P1IBOp_|CNLN|2-SAuS;zEN{$ZGdiC4gLhW=`r|C=%#DnrO-`Jz`dcH zJiyyQH?;&m0Ns=Xo(nf2HYFEX#)61=%zC8cF;{7!L6X19Kh#7H_ZUghHg3q{uR3E z3-}o5rV-@OO+&#Wpqn;dGon|h)CHJYD;4Pz?F1(>3_bEg0 zXFZLl&DN9q)GP39nQQKLyC(OkTyXd8s;xiIl>1Z&c&C}`N5(gh`;wXQJINla-S*yFHdf;tu#~aQA+J~a&d<|x-gM_$N%>Js?s^=+Ic?Umn8MUfBm)p6-3zn_W%pIB+W z&_+w{Q|{oW>W;b-_)Ferf-epaEP3=$?o+G49g5CRnwlZ^snOuEi6*sFuu9w`W&VfHuDoAahBKIcpIT_F04!@N5p5T_N zoBZyZCHE*g=`p}#`zQ+2={@+McMc9naRBe+(+YkQ?AdEXkm z<=V^<3E$+s7WnC#8K3-}<=%7xeBy{E3BlR&-V)9}0!dH)N%-c_r`OD*Ky)C4?ueOR#j9(lhA+~(Qfqb`baKQafOpIq0*Z?e3f z3;uECo85`I^8N?-Chx+2FI&s~Xe0RM$j_S%0_6P`@F#c9uZg}b@2`XZ_jBK?itchh z(gPoN`Sa0f%jLZb_@AGeEejvX`|se<3(99%>&yKp3|xDBo^IAEdEXv9M&0bAZjrnv zZ`pNccw{fRA9VzOVisEUAw=H41+R5I({sojdEXFRb*xFNwVmXCqz>+SDtpTXUwQ8i zK5eD3HMt-C0RQrBaY`F!dH)T(qT3K79SgomBZU^ItVPgGUf|SC7SL0Zp_|5oZ-#DK3qBco${ySby2%K<_Q0BZ>L>J6 zd+4T~;7ZUHw^`!2i-Ia{2O%B7w~P+O|jrH&`sgs_n@1ovwA}}>43XKH#vcq zLpPDHgKi?%fo{?QkAj}s2(AO&)E4|Xbkj5N#?VdG*J|!84d|vu;LgxZ9^mfKP0rxe z&`lq~ze6|u0$1r?b5H$%o|+Hcv=Dq8bdx=J0(4Ux_`mw;@Ap5_m%m!`yD0l_H_NEm zPX_euQSz%)+#dx`IsY@=HB;_W=fG#|A80Y^XQlZ0%fQn+#P|HACHJWe@HaiH8vQvb z_o;flYW81ho5w2K%YCXvqndp~?~Dy!J~R~HDh>>$KHE}TXt1v)};bW&L9cP zM2lpaoTIK0$p}O;AViaMcEkn@A~uEwlWcMhO|S`VKv+N%n=C*`AP_l7fD9OcESo|I z+UULG8_%5U&ZnO5|KW#E?XkyRXU(dkey5IE1fq(Be zcRu$+ez5u{4gB!G`NThb;^XW7)cpp2(`&u;zuoo?>;BY@2fpu-Pk7Z&pSSHAzMb${w71OLUnj(P3%AHD8Ro#);=^84>`> zvhGh^d*G-1x5Gbrqf4&)Q$HE_u`fUP>nHqd^}jptdmMh<+h6{p>;BZ?1ONVWe*K{X zUa;;@{b=B~zS%E-^49yT`%||V_Fe(=K(- z@2>tY2L75u4t?LdZ?Wz-y?Ee99lh^L$|!lF{^)*f&crr&-LzyUv1rQI%DAH`o)h={MvI?|EvSQ#3Md`*@yqz z>R)8w$6fi~zk9LUtouzz5B$8BfBhT2^QP6m$iQ!OyTkVV&{^00qZfFU;>H{`4z z4!P+q13!MqO>ZCg^M~B@*8~69kejBQwa<{7P91XA1%}-8n;~aSx#`(Mo;v%Gn|2TU zABWuZPXmAGked!4_&bN(^yY!zc*srH9Qfsj+;r)IPq}HzS@$1u(}M^8vLQG9{lM=t zDL37I$W!MV^3>@=o|LSYa?_;;{+~l``r*L8Kjfw_5Bxqu zZo2Ehzc=KjQwDy>kehBh@P`h0>iz@2c0Yh%O@W8(?hYq>v4+nnxAvfK5 z;7=cN(-Q`Mz>u3RHt=T+x#_V3zrv84EV z_&*J~=|uy7?~t3`Kky34(mssk_gzS|wY?oa(};P=1u{wKZZ zOY8pBg9rY+XIZb#L(dGZ> zs^@swx<7T~z@PM-XFc_S*I4(bUNP{;zWe0;U-QXzf9lBt|LAFtz2YaXvhGiPdf@ka z^(F7{EH*{`|(z#n(EzubDnhu8h7Cl36yFTDQ-fBuYhf9e+lzwTA;|I8z9zwS?6 zec-#VbFn8se&35N{XfgVul2uAfBa!zTlc4~H}Gq`34d^NvEv-kpsW;mw))-?|gpUpZep0|LY6Bd)oQl zw(d{;bl^97!hTo3-~U|qr>-^dKfJ_6@BhUIt@~3q8~9Hid)sFncJR7Cb@IRu{rFwp zebU9({i)jz{K-GQ(J%k>KUe>813%^X6aUAlpI`TQ`hXIB5613&-GUhun*y6U>$bhd$C z`$@-s^0Cif{p$_&{Oq}ZeYJJJ>FNW2 z#;ZPj@x!0J`p+5okteSG)D=*Zrxt4*VYHzRQsZ{&MwiKk(Px z`l{DI`|Z~Krk4%;Y%hP*YkvCL)!#kvuRiOoXMF9n)&J(e4|&*QpYrKjuKP`Q9QghA zIm>g8dhzN%eBdv7_UqpC#viW!%Le}bzkKB5UU1!Y|7hZ0xZxYV^|+_4{xJhT`V=V&KOPxoOH%4;pgQ0|x%wAvZmK;O9Gb=RCE0 z;8UKu(vYXlHRPsU1Ha*ro31kOs}H$p;!~db@Q|m@^1Yq&)GvlS_3j}zy=~xk9dgrc z27cO*n|?g-8xOhZ+55Lkel8!@LvzP>E{Fg^C34qe&C-Ra?>XU zzTc3WE->)-4SDMQ1Ap(3o8C6?a}K%b>;u2fkeeoc{vkJAaNs8lx#^Pwf5woTo;L79 zhTL?kfuAwtrro#LIcI%v$W8Aa_;rWebftkmcgRgs&U*ilo8CU~D-5~m5(7VE$W3<` z_-lvU^!Ee*gWITn-{&wjsJ1opL*56fAd%8yz>j+vhGiPci^x7-Y+kCsUz0? zsec^!+uw2O$A0<7b${xe1HaLWpa0E|{$QVFzvG$%|H9|)@YSOpyY5e&H1JQn>#Ik; z`#kIZ)CmKB{_}qDt!KYt-Jg2iz;FAGt3K#i`>y*_cNqBo4>j?wD zz|9Xj@$`TG-Nm2yOJ8#Or%(Cwb${w_2Y$~#_}Zgidd+oz>h1&I_l^&I$%#L^Kg;U#!udK)LGxX?oVB1;5Ym6)qeAh=dJrww;cG7FZ7i=f9nzJ z{?vB{{=Jv{=8M0+)w(}*;=sT1e@}YdHGY5HpE`En7k|+Ae)%WATK!85{1#j9Iq)4{ zT=%CA8u$bE`PLEN|HpNI>OKR%$otMX;#^N&_ovP_@JHR_c5lDXUDy4ozZm#4zjcLo zoc0In{?y9{e)MyndXu-DvHB+r{L1^h^y-)Y{JKANg@Hfu>rZ_A{a&^1PyOA%-?;0W z*SgCi*Zrwi5B&7Ay!4s>al>_g>emB*{heNY+zrpM?oYjP;9orb4S##_<5vIJfq(3| zr@!ux4qf+~K0ffjxZoQecI$s${XZM{ZD0SH3qAXy>;BQf1AoNNAM?M?``4@gCj&qC z3D>>#Cr?=Yvkv@MFWYmyqi(S7H~n(p=la$8KK}KWuKtAwez#{`@Sa!wD51C;2(bM`~K~q1K0hd4-EVbk3QRnp7{9Hf9}9<@~cb!>dRkR{p$?;D{sE% z0S8}s-9I{h;CH>_sqgvVQ&#`h13%vpZ~D7KPFVe4KVfHnsfWMdh!d~8?jP+t@X!6^ z{eSnjPg?y?4g5*(`p}8j{^IICW#ETA?7pA>*UPT^N4FpNgRi~+N8a%0)qm8$pRn&U z@A80;ul^AOKmDs`yX_S&y6zwC8Tg@>_`$P&a^Kaz^}rvt->C<_>+P%m;DI0TjW-_h zxYJjE|ABw)n@_mcO>eR8A5HxJce~6F&hgyUf9Sx!`r?0h-siru`kx>8fj_w2bzX3( zb${xBf%m+$x8wgi47urg1ON7ro4!2o z;Ex`1(?bUSv>`V=X5bed z^3>S}{trWLdf~ti8*0<-G z#*mvXGw|mRx#>v*fAf%=UNP`r47q8av+kU;rabl9Ay0jO$W31!_-BUPH1WS4a?`^H ze#;>@-F)DW9CFjde`m-|=N$N1UcPgl`uUKj_8W53MFxJaAvgW^fq!SnO+Og;K|^l3 z&cII`a?=R|pK{Zbvz|WWrpFKbJwtAK`@mm3e>CK& za}0UvYy-c9YfW=8&6?82D|5+;ppf|K*UI?mO_O4!P-Z1OLw9V{JTSLnsU~ahTL??f$uFp<@_lJ z;l1R{{~h)J9q-J$|Ea-;>tFNC{~fpZmFuTJCoF#D`swet7r%1-eDC)bzjFNtJ@B{x z`~KoruAhFMy!e&tAARQke!TdV>!+@M%&fur+_meaXMXX|mi8;x&p4dA_?7E__RNm{ z`{GxwpK<$-#jjjHmHlGzE7#9B?^*oH^;6gBi(k2Z=H*w5U%CF7%jbc=Ui`}Sw`X!| z`?G&+bN!6-uEnohKl8rN;#aPpe(qlU%JnmDXIcEp^>>~5zq2lW<@%{>^()s;U1wX` zuUtRt@OKu!a{X(aS=iYZzjFQ5b&kcaTtDk-^()uUIzQ*qe&za^$8#-y<@%Y&b1#17 z`l;(Yi(k2Z>RSEE^)rv>UD~f)KXsjN@hjKQJf45?E7wn57g+qt^|P*4zjFPo^VP3h zKmEMm(x1xpGj6M2xqj-p(9(Y8`WffduUtR#zWSBxXB}R6=}+bQxi40~a{bhGk){30 z^;6gCSFWFVT>Z-RQ`be8{#34?d0hR<^;6frOZ%1UXWg!T<@%{>^()uUy4`Q-Pv!cl zYxOJFPhI;j?N_d!d0hR<^|NkQzjFP|@^!+OJ$cb*+Bo`kBYo zuUtQM9kBGLa{bKX>Q}Cxx_)nIzjAy&bJqXcImf3QlyUBPs`KuXoA?HNxPHc==c!W; zs$4()>3NFw;ri)8&r_U-bIkYlJk_~=o&!BkopMm+`sshqQ}iFMpZloisZ$QBTtD@4 z?D$vC`BM(cy6SnVbN$Rq&r^&KTtD|k&r_!yRJne}t>-Dm6Rw}SdYlv<}y5Rbi>t{Xp ze8hT&>!&Wb?N_cJqvsvY!#QSt;kKXoh3jYC!u2cH&;0g$#Qehbvu@$GU%7sao_9D8 z=a_oowx4?8`k6<#e&zb9x9213h3jV?;kIA7evF={I1lHT_V)IvpK(lPcbqXe{z=Nll4Gu!e%|d^)oNzCjH9w^PK5t~$dcsvi``k8mQe&zaEhdm$hJcsM&zJS|) z<@zyt-r+j9e(HteQ7>FS^9a|kTtD^pd_=u){mdiW_AA$q(en=1!S%DA;drcPxPIz_ z>sPLyb=&h1>lv<}y5P27xqghEceoC&pZSI3F~4yAtXsH#<@%Z5o{yMcxPI0x-1aNi zkJ0lE*TMBuFC340;rf|JxPImOski4N>V@lP9^tlMxqb|ClYZs+e0HyMj(Km{^Hk^E zCpYmu_;CGUoOyv~d0Om}C22Ip=v#yV;-0y!1T9dLTDBo>>oY$20TQ^Az(1*U$5(=PBOv z!1cF#utiVu$$4@U$L!0%xvF#hJZE~IVx7SC)BoLDw46`+57*DQ^*qHm!}Zf1If!rJ zJe*_dg6rq`4A)P+Jx@_DT)*Zf+pkfEaE`f;;EsRpJGg%4 zx92J57p|Z6-18Lc8LprC?Rkp#;c)%*xaS?t!#U>X2;6$J-r)LK=WzYX^=od@uUtRl z+4B_R3D-}HJ@0TH&N1T*w?CN|xPImxu3x!+)?v>_Jb&Q&`MChM{mS)Y^t{7)ILFir zxBb)$*Uvn{^()s;y*(dMFI+$K3%C8s^<(tB!+AKztY^6GXFbF9Qx{yna{a8^o{zX6 z;rgiyZu^z%$LM*7^Kg!tU%2gOe&PCAw{ZQ+^)tUcA2Gjh{j6KK?N_cJqvsvY!#Sp2 zxb3H2xPImlu3x!+>h1Z6dg1z+N4V`*t{SvsLp4#kBF@kvxkei^q zZ-MvmBsb}2oZmFvgo$6N>JbF)9i$YlI`p5na+xe2>-$20RnZqlz@KhGI* zlYZs;+s2k=`O`Mn&vU8gDfVmN`gzWfn{2ys{q%G9_V?;nuAk>2xk*wct&r`fFh3luqb-$@{{j96iuUtRte6v55`R#d%_o(D1 z=Qrya?s#T?$xZr|>&NJMhwI?_Syym8e!jrr7M^|Nl_`jzWvetSM*e&PCAw{Y99Tt7z7J6s3XPrYzF>V@lP9^v|x>!;qH zkEj=}pLvAae&zZx$W8i{7@9Xj5`WYYgq39QR6Rw|mKVfJe zuAdg!hqC?3_0u2rq4X=)&+~!Yq+hvy`cH1suUtR(QO{Gnr-kdMMUHL1a?bN!akD>_ z@$Y$xb=dP%=ZC>-mWDaE_@9POm!GPrW@)Q7>FS_jUh$Ki<2-_4D(c z++=?$*N@Tj5$E9?v##K_pLGb=&pPjUisv(2Kl9sv-;eo)>t}x1hq6DF>&IYUNxyRa z)V2DR>t}w+O}1aTe(EJR=~u3wdF*+L_u+8;wAk|w=iwZ)uHg13>kzJ=zlXr}E7wo| zdp@H7aQ%!M-1aNikJ0lE=iwZ)uHd$x@rUbY-r@R{>t`MIe8lqyuAln_Zu^z%$LM*7 z^Kg!-7jFBh7p|XqgzHzXpL%;fqF%Uu<`HiDmFvgod580Gj#!&Wbe&zaE z&pjWpp5gkb3vT&NJMhx2fbnP0f=XMW-OS+{Wg%Jnn9Js&Z@aQ&=Xxb0W2AEW0T z&civTUbyY2Ubued5w2gke(LS{hr+4B_R3D?hkL~gSE%JpOPW3Geqx!Ip$WU|hCp5nbn&r_W{o|zYN6Rq>_ z-QfCp&XAk*E7#vPwlvG1wz+a*&{#34?^|tzz>t~&ln{2;w{j5WBlYZs;`FYp#6!!~UKP~or#P`7UQx_bM`wOn0 z`R#d%`GxDJuAZlOzY5piIZrXaJx|f!o_9L8{hFKbSZ}nWpZguIU%CFyd5Zp%oAfiD zaNDn3KSs|xTnE?B_`~rSf4F|u16;py{jATPk652@{oEID+pkt`O}`jzXa-ky)B7p|Xqgxh}Q`Z0Rm;X1f}%}sc$=haVLaQ(_{f9E{KdL}pNr!Khd zSFRtU=N+zt>t}x9c+4+cKkF8*U%7tfx920~7p|Xm3%C8s^<(tB!*y`|)CUbued z5w2gke(LS{hj_t}Tyd+_1<86Wnc^eflT zyq~bypE~mfBWF2289|O6&&oN^d-%=%RMu6`Q@r=+d8%{AGtWJ8ljC2xex5%)Pw}1y zuD{*l7A@zK^W-Lu*_VNHRpkJ0lE z=iwal+<@DD#viVq=PF#ka{WAidOqU$1J}>b1-R{3t{z<`J%6 zxqj;H`G|Vq`k6<#?N_cJqvsvY!#QR>!)?FjEdA8A`jzYNoTpgN&NJM zhx2fbnP0f=XMW-OS+{Wg%Jnn9Js&Z@aQ&=Xxb0W2AEW0T&civTUbyY2Ubued5w2gk ze(LS{hSvfli!ne;QAS#o~Ov0aQ(E? z^A!Do>!%0(_x

TtEHkzwbwX;QDzEun$GMyl;W)r~fCnJV^iH`niwDO}1aTevE$1 zb#Oj;PuufU=lU6+Q+KLe)_q4 z`+Mz6<@y;V@M`FI+$M_B=(saQ&=La+B>>uAiUpJx}qz6t15Z z$xXIjxqjB$>Q}Cxb-vl3%DneH#e3AAr#g2$cg|DHZ_iWAXU{vG+kV#7>Q}Cx^}qU+ z>+hVW=s&qhKjQ|c-`p>7{TMy(a2;Gf&kZ;p;}6%*I*035uAk>j&qqAZ;rh8>;I?16 zevF=XxDKwLdf|A~3)jy)!u2cHPrW@KQ7>FS^9#5A%JpOPyu)>H{j6I!9zWmV`l$=9 zU%CFyd5ZN+ZqiR(aNDn3KSs|xTnE?B{KD~=U$}nOEnL5H{mgIAN6ar=KkF85`<3g* z=y`|h;QFZ-jz_(4{mdg=zjFQ5+w&3i!u2zcaNDn3KL)u;zjAy&yVp6#>?@I*xUTc= zlbgB^*U$KnoAfK!&%BeH^efkoL2lBoTtDASZqlz@KhFnplYZs;=_k2KzjFQDM?FvR zJ{GQ@7CE;4$~n*b+n%R7*UvcgJjMF~xPI;na+Ce3TtDMRZqlz@KSs|}oQHGFy6t(Y zbN$pyZn8g>>u0{mP5PDV=lRp~6z_T9`r9pT(Q-aH-}6!5hvKTvxt@6^H|gj31J_Ug zcW+_llm5f?Gj2Ukv3}tCX^$Mlw{RZLF?GT9v)%cZKWkoTqqS z+Vd3G^?cMh$2=fue&)CTz8~`o*U$X&dwq^)<@zz$SJJOsKXt8s z<@%XNa+B>>uAh2)o}ym3{?2)d`R#d%>w4bloMYD2>SrCo^|Q|5)?2y$&UuRd_k6_j z0dD&lPq^*J=y`|paE=*gxb0_N;QE<&xPImOS%*Cz@%(}7=YE0Pe&zZxdfwqYoMY;R z+kWbW>t`O}`jzXa-ky)B7p|Xqgxh}Q`Z0Rm;XIsU)-&Apv!3DlsSB=Ox&F?1iuFux z(obD*+pkN8~2@ z&3*@5KSn?1Iyj%aSL}JJbN!4DxrufeAGm(*i=L<0FM#W3JbRvEJmLE30lCTkRIZ=# z-?Q1DI&)$5{KdSJn;g$Pf8dU1o|C(`H1ns*^|OA+OwLqe(LIZ zigAGJXMK{J>`&$TJLf6hm-akGd*mRF`Gnhko)2(5o)2*StbcNoe&za^M{<*X<@%Y& zo~L*|!1dE&&qsU@TtD@~@u(NBpZV>1iur}>r!I1n?N_e9bDm;;d!C}bo_9L8{j96i zuUtRteDy2W-#Jgw|DKN+H#q(7-1cMiyu)>H{fsjlkN4Yf{j3MLe&zaEpFJP3KH>Vg zFW|OcxqghEceoC&pL*eV)C5InVpXo~Jt3&p42qY`=2-+!y2~{mS(-ZsaEY%JpOPJjHo9$E@3) zr#jb9U7P)>Jb!wg;(gTaEoLg8o%iwVd5ZT-aQ(E`^AYFa9B=lg82>yUdY)pP_dM0P zX-1aNikJ0lE=iwYP&T!k$yukG{ z?{NLf^|L;EK4N{s_49KXZu^z%$LM*7^Kg!-7jFBh7p|XqgzHzXpL%;fqF%Uu<`HiD zmFvgod580Gj#!&Wbe&zZ*=PA}Rxk*2D!EL{C{TMy(a30Pv^9#5A%r9I& z>lUtGxqjxi=OgA9uAg-axBbfXWAwbkc{s<^3%C8$3)jy)!u2cHPrW@KQ7>FS^9Z;7 z%JpOPJjHo9$F#S%PyLK@&r|HDz`IXw@_W(_TtDN}^Avd#uAg>#o}xc+{q&&cDf$K1 zPk(xzqCar`JO_H7;(ZHTKmG4{ivGj(b076Q#rs&eek$w7)C=d6_liAFb*`WB>3NFr zf$QhK=y__hKgEpXIm7SuL3y78cRaU^EzR<$ZLXj3XCF$pa{WAK$W8i{>!<&_x4&1v za{a6ya+7}L`Z35&`jzXauGOzxKXtJWW&4%u=YHSpPi204p5i$`ZgM;`zi`JhM$boF z2iMQ@5RS+55U!tj?0Jgk8(cqik(+G4a{Zn26z{`(o}#^;cRIKInw#+W`9eGTS?6&5 z%Jp~7Q}mzQq@VGG+kWNxF?!zNI=Ftu8IH&E5U!u~0N1ZvKkKmPBi1ckKR>VGwqLn^ zjGlM64z8bi;ds;w*Uvn{^()s;y*(dMFI+$K2)F&p^<(tB!*y`|nw#)g&#Rxh;QE!@ z{?2)d^-ONkPhD`^uUtPy&pTWP*U$XI@t9w@e%38qzjFP|Z_h`}FI+$C7H<2M>&NJM zhwI?_sTYn%y>R`^BV507{nXp@5%t3LGmmiFuUtO{xk1Q0sP5PDV=f3E9ihTsQe#UdNKb7ZF&r^(3&qtke%s8)p z<^`^wdGC3ObpqE$ekZhM~U-0{pjlAD~b z%JpOPyu*1o$E+*3?Pndr^>bgt^()s;KYKpneLh@2;|90=%JpOPyu*1o$BZ-F_Vb*9 z>t~(A^()uU^QY${os&wM z)AJPL1J}=eL2k1B%JnmzJx?*7aQ(E%@AcV!<@y=tJ)3_&b>_nAd5U=_H#wep{=gm2 zJSTT=Y35Ir>u3Fto4l%W{TMwTaUEPg>k5v?ekfc&b&;F&E7#BZBsb|-uAiUpJx}qz z6t15Zdp_cO;QDz!!0~uK!1c5Kd!FL?3D?g&vJYkZmFs67*@x1vTt5c;O8S-Sr{2}C zTtD+jZnFK#^;1{RQ@me=>(|_5`<3g*=y`|h;QCota6F!eaQ&=*xPImO>1WSJtWUUp z#tm-!mFvgod57!Z`Wb&X9^((!&%DF+E7#9D?D>eFUvT~0FL2whTt7z7J6s3XPrYzF z>V@lP9^v|x>!;qHkEj=}pLvAae&zZxdfwqWxPI0%9FO%3*H2w={mS*To_juGJ;U`= z7u@zM*N@Tj4%fl;Grw>=<`=G?bqm+8TtD;M^AYn4*U!3z+kWNxF?!zNI=Fu7h2v2# zTtD*&*RNbZ_4a&3y>R`^Bi!~Y*N;JN(ytt!&+c{3G5aaxCa&we`{btX!}T*ht`Lp^;1{RQ>=fue%4{nQ@nSD>*wb? zxyk-it{;OOq+hvyo&&32xqhBMdY)o_;ri)8&qthxbIgCw z5N`idFI+$K+w&Cj3)fG*V@lP9^tlMxqghE zcQ_B{nCB$i_VZkY>!&Wbe&zZ*=c R7Q@!=kz?)x#OAZdfwqYoMYBA-1*9ShU;e@ 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

Oc$_?+d6w(B-sJi8U7mk=KI?Gvkw3rW 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

WSC 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 VP*EP}Ibum)j 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

`Ia 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 z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+0D)hZ z!0TW4{PVAR?zPW7ee}&Q_aDFU9WOt=`8D(QKY3>!U+MopdFuCR?*Gz7|Iw@7zV_>Xzv$n4-`)S^i~f@j+x`FJqW|#Y zcmG!|`gcET_y5m}{^Kv&{Xc!tfACei|9@TdpT2$fU%Kc&`ib5Dzc2dterflA^`ige zJ-&VI@BeerfB1pB|7R}xcRy69?*BO#{fEE0`|ozqzxzJlvG(`Rz34x_xBI{0qW|DycmL13 z=s*38-GBFs{-ZD4{XhSrfA1@H|2;1HPu{xwf5Aon;gj8e&x`)uU)cS>@S^|t-M(|} z*Lz*`AH4tW-@WKR{fOQFjTik#pSb&f(MA8>!`=UjFZxg3wEORU(SP_gyZ@J5^zXi7 z_uuED|M;hN|1Z7hKlqj1|4kSDr|5H^zS{t`+xaG|H-HA{`+3^ zAAZ5^{}mVgyI;Ed?|0FE#V>9z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5Fl_v z;PtP2{`pru_uA*4yyT$|F6F2Kl#wz|A34B!;jnjzviNU_cM3@126hdAMO5M zd(nUNb-VvT7yWzh+Wo)oqW|P)cK?Gf`VW6~_y78f{@wTa?&tph|I7LOEf@XA_jdnp zxadFl*xmn-i~iHk*!{opqW|a%cmLi+|K3;Z{@--bfAZGd|E(AOhfj9@Z@%c?{e|8C z(2M@#cl(~TUw_L*|H1q3{)b)kpMJ#d|E(AON1wR+AAZrl_i*=Ld(nULrrrODi~hr} z+5NxmqJQ@tyZ_rR`j3BV_y6{b{)1oH{lDX)|Mb1SckS;-Ui2S*@b2Hg=-+#O_dn{Q z|K!tl|L?r$Km3B-|LBYU-7nq!zw4s^_#1cs`HTL8AKLxD`=bB!XLtX%U-TdS+V1~7 z7yWy$dFR^SkGbeS`Ow|}doTJAKW_Iw_M(6HGk5>*yXZfD{Ci~fVJ-2K1*qW|=T z-T%0Y{-Yn?{RbEQd%w8*AAiw*^6uZa_Um;Q{f8g0`=4;pzx$E9|N4vm<4@lGPrT?q z_}tz92QK7xHKj{ir1009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+z^_Z- z^{;#W`By#n+UFj>@f|PsAAbIiy!`m)*UZ~L>DBZ2O8@`S*M8sX|AQC(d+*%+Prm3s z`RU#Nhc5aLU)udox#-`0?{}^H|A#O7k3VGhKlP&j;A3|GAGzp1{q)`cw2S_eH|_pE zdeMLQHM{>iFZy@ivHSnnMgQ?n?f$1<^dJ1n?*HQ#{ipBs{cFEI$i~f^O+x_2l(SP^_yZ=vJ^zVM@?tkV*|M55O{y%-ufAB-Q|5+FPr$4*<|I9`I z(XZ|PXJ7R1z2*nj{{FKU{U;x~`wuVr4?k}A|GA6)-Ot?p&$;M7e&g={^B4UGU%C6A zd(nUT!tVbI7yU;+zWbkd(ZBbLyZ57_;G>7sx4BX|D`F8Yr@ zdH4V2i~fVp-TmKv(SQ0SyZ^6T^dEig?!V!pfA5{U|9dX_Pkws$zwn~}@TJ}VS12zI^xpjf?)1x9t8G zU-TdT=wQ29{~ac2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly 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 z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY** z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0 z009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{ z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~ z0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL`0omA zb9Q#@4>+t6cH?uxz8CGC=Z5pi=Y^ece%RG62s@&`9RpEE)IKNw5MGX z&U;-NcJ0f;z8vk}WR|4A-YeJMPACJ}BB5(QbHC zxPEH1Z%4c5&Efj3(XMq%IG-5p{AhQ)HC(?c+Ldn$=VPONI@&F757#dU+qcZn*tu_$ zXbaI!i*{zTA4QwFBlHJEJ2l#SqHRXI-kqV_C)z2|4n_NBwCmiJP5t|=Z}(_R(N4NM zTrb`mcH)e%`TN7}@Ict?Lt~qrRtr1z;jmL?g)Kc2cJiZPC(RCf%wu7TbHW~04?FSk zu=_m`HveSU2~UOH;pwp3J`*Za!AYHrZs?x1$xo8qIy0uK#lx}U)r4Ecg|9#bTZPKk{y0mobnyy{CubHkxy04qAQ@T#m zWu*It>AIv_&vaSo);C?ZbQ_p1C*6jo%S-o7)AdOAEz=dG%b2bx-A1PCm2P9x^-1?_ z)0L$Aj_JzMeb;pT(rse8igcTrZa}&&(^aM0%yfg&ZEm_H-~Dj4b>G-HG(5lcoDhGW zbDl%u{ypP9EZz4_SCeiF)77Q>f$2u1`=RMZrOTSGA>EdyYf873=~5Hp&Rd(VO}cGN zmzHk4>Dr~+)^r`xZD+bp>AFpqk#2j_bxHRl(`BXmvFW;{+re}>>2@?-Ub>%{u1C6^ zOjnRDXS$+vJDaXox(TN1lWrH&m89F%bYvhKdQvCbbd6vZeXyaa%?pLPkm+lzT zRiyj1=?0|hHC1xs)Z@Rj4Czx(Ty5E{^RJuOXHKhBU z>6+3_HeKrA_}Aa>P1h#fA552)?nKkIOZP|9bx8Lo({)N$GF?WxlT6no-N~lQO7~~e zbxU`O>2lKj#dLY;rkJiry1$yPAYIvXMd?m8U9WVfnXXT|(@j^BZmQ|Z(w$+te(C;Z zx{7pvH{F1A{idr*cc$qErJH8DA?f~Mx?$=5X}X$p(@j^G?kv-dNO!jBMy0Emt|8qy zrfW)fuIW;T#Gn7pGhLf>=bJ7q-36v=m+nH-bx3!S={ltwFkMEvi%r)h-6f{WN_VO0 zx~03!bW6T#;%e)@vGqD*?X>vUt@F%@`{l+xFWnWU>yhqC(-owvnyx6_Ri^8e?rPKZ zNq3FuO440xy0UcFnXX^D>rGdY?grBhNH=J@s&qG+Zcw_LOgALm&88cc?iSP4q`TF0 zb?I(1-H3Fzn{HIPA=5RayTf!%>FzXLsu2IayvuZL(*4VHY3c4ZUAuJmn65**drj9V z-LUC0(#4v3y%5*j9o;F=w zx@Sx`BHgp58o`?=>#*CyTbrb|org6X(JT(UsxzVZKG zXS^W(_mlH%7xx#9dxvx{nXXg1QPX9ln{T=<>0UNnR=QVA*Dc+vrprmUz;t=(UNc>f zbg!GPAYH?BMd{u!U9WU+nyyc}g{CV>_m=6((!FiEe(ByZT}8TgO*bH2({xqo7MX5P zy7x>sB;EU_8yU04({)O>tm!h+eaduQ(k*AYtaNRr>z3}*rprn98PnyZTi$d%(tXx+1?g5WT~WHv znXXs5&zr7Ky0qy^(yeH^vUDq%u3x$@n64t-7fm-H-O8q`O7|tx4NA9)>4v0hH{Gyw ztD3GR-D;+*OZR2djYzk;=|-hn!*mVl)->IcpT)R}00IagfB*sreDVZZuN$>~&X~P2 z{_l0}eyS<=U0-qcU1!CAzYf#2Nw=2i($cMMx_0TlYPt^T)-heDbnBWfBi+|b*CpN8 zO_!Cf({$a^eZzD)>DDt{Ub^*7*CX8qrYlIdq3Md!ebaQk(tXQxebQx2SCVcc)0L&$ z*mV8UecN;u>AqvS0qMSLx~g=Wm~K$IO-(l>U6<*GrQ6JOHR(1tU0u5GnQlb7@0)H^ zx-CrCknRVjYfAS+)1}UiKmTP-*CySTrb|n=mFe20+uC#;(rsh9PU*&*E+gHxrt6Y! zJJV&Q>o#4tblaOQC*6-smzVCxrt6Vz2h$a#+tGAI>3(9mUg>r+U7vJ0)0L##*>q*; zCYY{Yx?N0Hk#1Mh4M?|}>8jH0Zn{C~_AuQi?~d@}eZ;N%#=F-nyx0@UZ$%{x3}p=q}#`Iqtfkbx`uT7nXW0_PfeGq#GQLg*CyTmrb|nAfa%($ zJJ56;(oHm7r*sFIE+gH+rt6aK5YuI)E10fZxN13i)x?h^EBHhuZ8<6f-rmISKjOhlY`?cwYr0X@^ zuyn_ot|r}armIW$8`F(QH_3FP(j9NQhIA*Gt|{GbO_w?+{`}Wxx;E*4XS%d>lTFty z-S17;A>AKL*D2kJrprk8N7Hpl_b1b3r7M}PTe_1>my_;f)8(c6v*~)IJH>Pb>HcE6 zqI6SC*DKv$P1h$~*>oT8F6xt4weA~RuQOKfihn;l&yu*GYTV1xoo2dz=}tFYMY^e` z8<6e{(^aMWo9PCn`@89er0X}`uykjdt|r|y)77Q>hv`P7`={wfrJHWLhID6{t|{Hw zrc0e0|N5(#u1&ggOqZ7KT+_8ncb@4wq&weqozh)kx{P!enyyQ_i%gf5ZoqWi(p_x2 zoOG9%E-&4srt6XJGSd~LyWDg|>8>zcuXI8jFQZ@NM0ZZO@Dbc3cFmhMK=)ug-0bam-&Hr=&woRvYm@E{)1{@m({%09-DSEC>HcN9PU-G8T}HZlOxGpdy{5}bH*C6Y>1LSj zlXpk>@jl{k-?(Y2^*ZC?=&kktpE%E)xZh{o^U~dKx*q9fnyw(-1EwoV_n_%|rF+P9 zebUuTSCZ~w)0L&0Wx9Up9x+`-x<^enAl+=!Ri%5(bc52(G2M`Kb<+(?_qge5(mi3i zx^z#PZbZ7LOgAds)23@k_l)V9(miXs)cNthPex4FCf!`qrKOu^x_0TFGhK&t&zr7O zx))5Bk?uv)bxHS<>9W#|nyy>A`KHTB_p<5o(!FB39_d~+T|v49rYlPKn(2C_d);(> z(ltz1lI{)Dm8E;rbp6sTG+jlyw@f!6-P@+CO81WG2Bmw~bVJfLO*bsvBGc8Rd(U)r w>E1Wph;$#AZdAGtP1lg_BhxjdTWq>i^z+cxT}`VS7hP!Gue2U#|GNVJ2hFJYlmGw# diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/plotTests_tutorial_updated.py b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/plotTests_tutorial_updated.py new file mode 100755 index 00000000000..d7fb3cf8c41 --- /dev/null +++ b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/plotTests_tutorial_updated.py @@ -0,0 +1,540 @@ +import matplotlib +import matplotlib.pyplot as plt +import numpy as np +import h5py +import xml.etree.ElementTree as ElementTree +from mpmath import * +import math +import os +import glob +import vtk +from vtk.util.numpy_support import vtk_to_numpy + + +def readGeosTotalStress(depths=(0.0, 4.2, 5.6)): + """Contrainte TOTALE GEOS aux profondeurs demandees. + averageStress = contrainte effective thermo-poro (terme -3aKdT inclus) -> + contrainte totale = averageStress - biot * pression. + Lit stressHistory.hdf5 s'il existe, sinon retombe sur les VTU du .pvd.""" + if os.path.exists("stressHistory.hdf5"): + return _readStressFromHDF5(depths) + return _readStressFromVTU(depths) + + +def _readStressFromHDF5(depths, biot=1.0): + hs = h5py.File("stressHistory.hdf5", 'r') + ts = np.array(hs.get('averageStress Time')).ravel() + center = np.array(hs.get('averageStress elementCenter')) # (nt, ncell, 3) + S = np.array(hs.get('averageStress')) # (nt, ncell, 6) + hp = h5py.File("pressureHistory.hdf5", 'r') + P = np.array(hp.get('pressure')) # (nt, ncell) + # coupe au premier reset de temps (redemarrage/restart) + last = len(ts) + for j in range(1, len(ts)): + if ts[j] < 1e-12: + last = j; break + n = min(last, len(P)) + ts, S, P = ts[:n], S[:n], P[:n] + yc = center[0, :, 1] + cid = {d: int(np.argmin(np.abs(yc - d))) for d in depths} + out = {} + for d, i in cid.items(): + out[d] = dict(syy=S[:, i, 1] - biot * P[:, i], + sxx=0.5 * (S[:, i, 0] + S[:, i, 2]) - biot * P[:, i]) + return ts, out + + +def _readStressFromVTU(depths, + pvd="thermoPoro_consolidation_fim.pvd", + root="thermoPoro_consolidation_fim"): + seen = {} + for d in ElementTree.parse(pvd).getroot().iter('DataSet'): + t = float(d.get('timestep')) + stem = d.get('file').split('/')[-1].replace('.vtm', '') + vtus = glob.glob(f"{root}/{stem}/**/Domain/*.vtu", recursive=True) + if vtus: + seen[t] = vtus[0] + ts = np.array(sorted(seen)) + files = [seen[t] for t in ts] + + r = vtk.vtkXMLUnstructuredGridReader(); r.SetFileName(files[0]); r.Update() + cc = vtk.vtkCellCenters(); cc.SetInputData(r.GetOutput()); cc.Update() + yc = vtk_to_numpy(cc.GetOutput().GetPoints().GetData())[:, 1] + cid = {d: int(np.argmin(np.abs(yc - d))) for d in depths} + + out = {d: {'sxx': [], 'syy': []} for d in depths} + for f in files: + rr = vtk.vtkXMLUnstructuredGridReader(); rr.SetFileName(f); rr.Update() + cd = rr.GetOutput().GetCellData() + A = lambda n: vtk_to_numpy(cd.GetArray(n)) + S = A('averageStress'); p = A('pressure'); b = A('rockPorosity_biotCoefficient') + if b is None: + b = np.ones_like(p) + for d, i in cid.items(): + out[d]['syy'].append(S[i, 1] - b[i] * p[i]) + out[d]['sxx'].append(0.5 * (S[i, 0] + S[i, 2]) - b[i] * p[i]) + for d in out: + for k in out[d]: + out[d][k] = np.asarray(out[d][k]) + return ts, out + + +class thermalAnalytical: + + def __init__(self, hydromechanicalParameters, xMin, xMax, appliedLoad): + E = hydromechanicalParameters["YoungModulus"] + nu = hydromechanicalParameters["PoissonRatio"] + b = hydromechanicalParameters["biotCoefficient"] + mu = hydromechanicalParameters["fluidViscosity"] + cf = hydromechanicalParameters["fluidCompressibility"] + phi = hydromechanicalParameters["porosity"] + k = hydromechanicalParameters["permeability"] + cc = hydromechanicalParameters["consolidationCoefficient"] + + G = E / 2.0/ (1.0 + nu) + eta = b*(1.-2.*nu)/2./(1.-nu) + + + K = E / 3.0 / (1.0 - 2.0 * nu) # bulk modulus + Kv = E * (1.0 - nu) / ((1.0 + nu) * (1.0 - 2.0 * nu)) # uniaxial bulk modulus + Se = (b - phi) * (1.0 - b) / K + phi * cf # constrained specific storage + + print( abs((k / mu) * Kv / (Se * Kv + b**2)/cc-1.0) ) + + self.characteristicLength = xMax - xMin + self.appliedLoad = abs(appliedLoad) + self.loadingEfficiency = b / (Kv * Se + b**2) + self.consolidationCoefficient = (k / mu) * Kv / (Se * Kv + b**2) + #self.consolidationCoefficient = cc + self.initialPressure = 0.0 + self.initialDisplacement = 0.0 + self.term = self.appliedLoad * self.characteristicLength * eta/G + + print( self.term, eta, G ) + + def computePressure(self, x, t): + if t == 0.0: + return self.initialPressure + else: + cc = self.consolidationCoefficient + L = self.characteristicLength + load = self.appliedLoad + p = nsum( + lambda m: 1 / (2 * m + 1) * exp(-((2 * m + 1)**2) * (math.pi**2) * cc * t / 4 / L / L) * sin( + (2 * m + 1) * math.pi * x / 2 / L), [0, inf]) + return load - load* 4 / math.pi * p + + def computeDisplacement(self, x, t): + if t == 0.0: + return self.initialDisplacement + else: + cc = self.consolidationCoefficient + L = self.characteristicLength + term = self.term + p = nsum( + lambda m: 8 / ((2 * m + 1)**2) / (math.pi**2) * (exp(-((2 * m + 1)**2) * (math.pi**2) * cc * t / 4 / L / L) -1.0) * cos((2 * m + 1) * math.pi * x / 2 / L), [0, inf]) + return term * p + + +def getHydromechanicalParametersFromXML(xmlFilePath): + tree = ElementTree.parse(xmlFilePath) + + param1 = tree.find('Constitutive/ElasticIsotropic') + param2 = tree.find('Constitutive/BiotPorosity') + param3 = tree.find('Constitutive/CompressibleSinglePhaseFluid') + param4 = tree.find('Constitutive/ConstantPermeability') + + hydromechanicalParameters = dict.fromkeys(["YoungModulus", + "PoissonRatio", + "biotCoefficient", + "fluidViscosity", + "fluidCompressibility", + "porosity", + "permeability", + "skemptonCoefficient", + "poissonRatio", + "undrainedPoissonRatio", + "consolidationCoefficient"]) + + hydromechanicalParameters["YoungModulus"] = float(param1.get("defaultYoungModulus")) + hydromechanicalParameters["PoissonRatio"] = float(param1.get("defaultPoissonRatio")) + + E = hydromechanicalParameters["YoungModulus"] + nu = hydromechanicalParameters["PoissonRatio"] + K = E / 3.0/ (1.0 - 2.0 * nu) + G = E / 2.0/ (1.0 + nu) + Ks = float(param2.get("grainBulkModulus")) + + hydromechanicalParameters["biotCoefficient"] = 1.0 - K / Ks + hydromechanicalParameters["porosity"] = float(param2.get("defaultReferencePorosity")) + hydromechanicalParameters["fluidViscosity"] = float(param3.get("defaultViscosity")) + hydromechanicalParameters["fluidCompressibility"] = float(param3.get("compressibility")) + + perm = param4.get("permeabilityComponents") + perm = np.array(perm[1:-1].split(','),float) + hydromechanicalParameters["permeability"] = perm[0] + + phi = hydromechanicalParameters["porosity"] + cf = hydromechanicalParameters["fluidCompressibility"] + bBiot = hydromechanicalParameters["biotCoefficient"] + kp = hydromechanicalParameters["permeability"] + mu = hydromechanicalParameters["fluidViscosity"] + M = 1./(phi*cf + (bBiot - phi)/Ks) + Ku = K + bBiot**2*M + B = bBiot*M/Ku + nuu = (3.*nu + bBiot* B* (1-2.*nu))/(3.-bBiot*B*(1-2.*nu)) + cc = 2.*kp/mu*B**2*G*(1.-nu)*(1.+nuu)**2/9./(1.-nuu)/(nuu-nu) + hydromechanicalParameters["skemptonCoefficient"] = B + hydromechanicalParameters["poissonRatio"] = nu + hydromechanicalParameters["undrainedPoissonRatio"] = nuu + hydromechanicalParameters["consolidationCoefficient"] = cc + + return hydromechanicalParameters + + +def getAppliedTractionFromXML(xmlFilePath): + tree = ElementTree.parse(xmlFilePath) + param = tree.findall('FieldSpecifications/FieldSpecification') + load = np.empty(1) + for elem in param: + if elem.get("name") == "boundaryPressure" and elem.get("fieldName") == "pressure": + load = float(elem.get("scale")) + print(load) + + return load + + +def getDomainMaxMinXCoordFromXML(xmlFilePath): + tree = ElementTree.parse(xmlFilePath) + meshElement = tree.find('Mesh/InternalMesh') + nodeXCoords = meshElement.get("xCoords") + nodeXCoords = [float(i) for i in nodeXCoords[1:-1].split(",")] + xMin = nodeXCoords[0] + xMax = nodeXCoords[-1] + return xMin, xMax + + +def computePP(x, t, h, phi12, phi11, r11, r22): + p = nsum(lambda m: 1 / ((2 * m + 1) * math.pi / 2 / h) * ( phi12 * exp(-r11 * ((2 * m + 1) * math.pi / 2 / h)**2 * t) + phi11 * exp(-r22 * ((2 * m + 1) * math.pi / 2 / h)**2 * t) )* sin(((2 * m + 1) * math.pi / 2 / h) * ( h - x) ), [0, inf]) + return 2/h * p + +def computeTemp(x, t, h, phi22, phi21, r11, r22): + p = nsum(lambda m: 1 / ((2 * m + 1) * math.pi / 2 / h) * ( phi22 * exp(-r11 * ((2 * m + 1) * math.pi / 2 / h)**2 * t) + phi21 * exp(-r22 * ((2 * m + 1) * math.pi / 2 / h)**2 * t) )* sin(((2 * m + 1) * math.pi / 2 / h) * ( h - x) ), [0, inf]) + return 2/h * p + +def computeDisp(x, t, h, t1, t2, r11, r22, A, M): + p = nsum(lambda m: 1 / ((2 * m + 1) * math.pi / 2 / h)**2 * ( t1 * exp(-r11 * ((2 * m + 1) * math.pi / 2 / h)**2 * t) + t2 * exp(-r22 * ((2 * m + 1) * math.pi / 2 / h)**2 * t) )* cos(((2 * m + 1) * math.pi / 2 / h) * ( h - x) ), [0, inf]) + return -A*x+2/h/M * p + +def main(): + E = 6.0e3 + nu = 0.4 + Ks = 1.0e27 + Kw = 1.0e50 + a_s = 3.0e-7 + a_w = 0.0 + phi = 0.2 + cs = 1.672e5 + cw = 1.672e2 + rhow = 1.0e3 + rhos = 2.4e3 + Kt = 836 + + lamda = E*nu/(1.0+nu)/(1.0-2.0*nu) + G = E/2.0/(1.0+nu) + K = E/3.0/(1.0-2.0*nu) + alpha = 1.0 - K / Ks + M = lamda + 2.0*G + m = (1.0-phi)*cs+phi*cw + a_m = (1.0-phi)*a_s+phi*a_w + + a_m = 9.0e-7 + m = 1.672e5 + + beta = a_m*(3.0*lamda+2.0*G)/3. + #a_p = phi/Kw + (alpha- phi)/Ks + a_p = 0 + perm = 4.0e-9 + mu = 1.0e-3 + km = perm/mu + h = 7.0 + theta_0 =0. + theta_a = 50. + dT0 = theta_a - theta_0 + F = 1.0 + + nuu = 0.499 + M_biot = 2.0*G*(nuu-nu)/(alpha**2*(1.0-2.0*nuu)*(1.0-2.0*nu)) + a_p = 1.0/M_biot + p0 = alpha*M_biot/(lamda+2.0*G+alpha**2*M_biot)*F + A = (F-alpha*0-beta*theta_a)/M + print(p0, A) + + keppa = Kt/m + c = km*M + time = np.logspace(-2, 5, 100, endpoint=True) + T = keppa*time/h**2 + print(a_m, M) + print(K, alpha, a_p, keppa, M, c/keppa) + print(K,G,M,A) + + g11=1.0/km*(a_p + alpha**2/M) + g12=1.0/km*(alpha*beta/M-a_m) + g21=alpha*beta*(theta_0)/(Kt*M) + g22=(m+beta**2*(theta_0)/M)/Kt + gs = g11*g22 - g12*g21 + r11=g11/gs + r12=g12/gs + r21=g21/gs + r22=g22/gs + r1s = r12*(theta_0 - theta_a) - r22*p0 + r2s = r21*p0 - r11*(theta_0 - theta_a) + rs = r11*r22-r12*r21 + + phi12= -(r12*r2s)/rs + phi11= -(r11*r1s)/rs + phi22= -(r22*r2s)/rs + phi21= -(r21*r1s)/rs + t1 = alpha*phi12 + beta*phi22 + t2 = alpha*phi11 + beta*phi21 + + + # File paths + hdf5FilePathPressure = "pressureHistory.hdf5" + + + # Read simulation output from HDF5 file + hf = h5py.File(hdf5FilePathPressure, 'r') + timePressure = hf.get('pressure Time') + timePressure = np.array(timePressure) + centerPressure = hf.get('pressure elementCenter') + centerPressure = np.array(centerPressure) + pressure = hf.get('pressure') + pressure = np.array(pressure) + + posElement1 = -1 + posElement2 = -1 + posElement3 = -1 + last = -1 + for j in range(0, centerPressure.shape[1]): + if centerPressure[0,j,1] >= 0 and posElement1 == -1: + posElement1 = j + if centerPressure[0,j,1] >= 4.2 and posElement2 == -1: + posElement2 = j + if centerPressure[0,j,1] >= 5.6 and posElement3 == -1: + posElement3 = j + + + # File paths + hdf5FilePathTemperature = "temperatureHistory.hdf5" + + + # Read simulation output from HDF5 file + hf = h5py.File(hdf5FilePathTemperature, 'r') + timeTemperature = hf.get('temperature Time') + timeTemperature = np.array(timeTemperature) + centerTemperature = hf.get('temperature elementCenter') + centerTemperature = np.array(centerTemperature) + temperature = hf.get('temperature') + temperature = np.array(temperature) + + posElement1 = -1 + posElement2 = -1 + posElement3 = -1 + last = -1 + + for j in range(0, centerTemperature.shape[1]): + if centerTemperature[0,j,1] >= 0 and posElement1 == -1: + posElement1 = j + if centerTemperature[0,j,1] >= 4.2 and posElement2 == -1: + posElement2 = j + if centerTemperature[0,j,1] >= 5.6 and posElement3 == -1: + posElement3 = j + + for j in range(0, timeTemperature.shape[0]): + if j > 0 and timeTemperature[j] < 1e-12 and last == -1: + last = j + + + + + #Visulization + N1 = 4 + fsize = 32 + msize = 8 + lw = 4 + mew = 2 + malpha = 0.6 + lalpha = 0.8 + + fig, ax = plt.subplots(2, 2, figsize=(32, 18)) + cmap = plt.get_cmap("tab10") + + pressure_analytical = np.empty(len(time)) + temperature_analytical = np.empty(len(time)) + displacement_analytical = np.empty(len(time)) + x_analytical = [0.0, 0.6, 0.8] + x_analytical2 = [0.2, 0.6, 1.0] + iplt = -1 + for xCell in x_analytical: + iplt += 1 + i = 0 + for k in range(0, len(time)): + pressure_analytical[i] = computePP(xCell*h, time[i], h, phi12, phi11, r11, r22) + temperature_analytical[i] = theta_a + computeTemp(xCell*h, time[i], h, phi22, phi21, r11, r22) + displacement_analytical[i] = computeDisp(x_analytical2[iplt]*h, time[i], h, t1, t2, r11, r22, A, M) + i += 1 + #ax[0,0].plot(pressure[k, :]/1.0e6, x[k, :, 0], 'o', color=cmap(iplt), markersize=msize, alpha=malpha, mec=cmap(iplt), fillstyle='none', mew=mew, label='GEOS: t ='+ str(t) + ' s') + test= np.linspace(0, h, 10, endpoint=True) + for tt in range(0, len(test)): + print(computeDisp(test[tt], 0, h, t1, t2, r11, r22, A, M)) + ax[0,0].semilogx(time, pressure_analytical, color=cmap(iplt), lw=lw, alpha=lalpha, label='Analytical: z/h =' + str(xCell)) + #ax[0,1].plot(displacement[k, :, 0], xl_node[k, :, 0], 'o', color=cmap(iplt), markersize=msize, alpha=malpha, mec=cmap(iplt), fillstyle='none', mew=mew, label='GEOS: t ='+ str(t) + ' s') + ax[0,1].semilogx(time, temperature_analytical+273.15, color=cmap(iplt), lw=lw, alpha=lalpha, label='Analytical: z/h =' + str(xCell)) + ax[1,0].semilogx(time, -displacement_analytical, color=cmap(iplt), lw=lw, alpha=lalpha, label='Analytical: z =' + str(round(x_analytical2[iplt]*h,2))) + + + ax[0,0].plot( timePressure[0:last:N1], + pressure[0:last:N1,posElement1], + 'o', color=cmap(0), markersize=msize, alpha=malpha, mec=cmap(0), fillstyle='none', mew=mew, + label='GEOS: z = 0.0 m') + ax[0,0].plot( timePressure[0:last:N1], + pressure[0:last:N1,posElement2], + 'o', color=cmap(1), markersize=msize, alpha=malpha, mec=cmap(1), fillstyle='none', mew=mew, + label='GEOS: z = 4.2 m') + ax[0,0].plot( timePressure[0:last:N1], + pressure[0:last:N1,posElement3], + 'o', color=cmap(2), markersize=msize, alpha=malpha, mec=cmap(2), fillstyle='none', mew=mew, + label='GEOS: z = 5.6 m') + + ax[0,0].set_xlabel('Time [s]', size=fsize, weight="bold") + ax[0,0].set_ylabel('Pore Pressure [pa]', size=fsize, weight="bold") + ax[0,0].legend(loc='lower left', fontsize=fsize * 0.6) + ax[0,0].grid(True) + ax[0,0].xaxis.set_tick_params(labelsize=fsize) + ax[0,0].yaxis.set_tick_params(labelsize=fsize) + #ax[0,0].invert_yaxis() + + + ax[0,1].plot( timeTemperature[0:last:N1], + temperature[0:last:N1,posElement1], + 'o', color=cmap(0), markersize=msize, alpha=malpha, mec=cmap(0), fillstyle='none', mew=mew, + label='GEOS: z = 0.0 m') + ax[0,1].plot( timeTemperature[0:last:N1], + temperature[0:last:N1,posElement2], + 'o', color=cmap(1), markersize=msize, alpha=malpha, mec=cmap(1), fillstyle='none', mew=mew, + label='GEOS: z = 4.2 m') + ax[0,1].plot( timeTemperature[0:last:N1], + temperature[0:last:N1,posElement3], + 'o', color=cmap(2), markersize=msize, alpha=malpha, mec=cmap(2), fillstyle='none', mew=mew, + label='GEOS: z = 5.6 m') + + ax[0,1].set_xlabel('Time [s]', size=fsize, weight="bold") + ax[0,1].set_ylabel('Temperature [K]', size=fsize, weight="bold") + ax[0,1].legend(loc='upper left', fontsize=fsize * 0.6) + ax[0,1].grid(True) + ax[0,1].xaxis.set_tick_params(labelsize=fsize) + ax[0,1].yaxis.set_tick_params(labelsize=fsize) + + + # File paths + hdf5FilePathDisplacement = "displacementHistory.hdf5" + + + # Read simulation output from HDF5 file + hf = h5py.File(hdf5FilePathDisplacement, 'r') + timeDisplacement = hf.get('totalDisplacement Time') + timeDisplacement = np.array(timeDisplacement) + centerDisplacement = hf.get('totalDisplacement ReferencePosition') + centerDisplacement = np.array(centerDisplacement) + displacement = hf.get('totalDisplacement') + displacement = np.array(displacement) + + posVertex1 = -1 + posVertex2 = -1 + posVertex3 = -1 + last = -1 + + for j in range(0, 284): + if centerDisplacement[0,j,1] >= 1.4 and posVertex1 == -1: + posVertex1 = j + if centerDisplacement[0,j,1] >= 4.2 and posVertex2 == -1: + posVertex2 = j + if centerDisplacement[0,j,1] >= 7 and posVertex3 == -1: + posVertex3 = j + + for j in range(0, timeDisplacement.shape[0]): + if j > 0 and timeDisplacement[j] < 1e-12 and last == -1: + last = j + + ax[1,0].plot( timeDisplacement[0:last:N1], + -displacement[0:last:N1,posVertex1,1], + 'o', color=cmap(0), markersize=msize, alpha=malpha, mec=cmap(0), fillstyle='none', mew=mew, + label='GEOS: z = 1.4 m') + ax[1,0].plot( timeDisplacement[0:last:N1], + -displacement[0:last:N1,posVertex2,1], + 'o', color=cmap(1), markersize=msize, alpha=malpha, mec=cmap(1), fillstyle='none', mew=mew, + label='GEOS: z = 4.2 m') + ax[1,0].plot( timeDisplacement[0:last:N1], + -displacement[0:last:N1,posVertex3,1], + 'o', color=cmap(2), markersize=msize, alpha=malpha, mec=cmap(2), fillstyle='none', mew=mew, + label='GEOS: z = 7.0 m') + + ax[1,0].set_xlabel('Time [s]', size=fsize, weight="bold") + ax[1,0].set_ylabel('Displacement [m]', size=fsize, weight="bold") + ax[1,0].legend(loc='upper left', fontsize=fsize * 0.6) + ax[1,0].grid(True) + ax[1,0].xaxis.set_tick_params(labelsize=fsize) + ax[1,0].yaxis.set_tick_params(labelsize=fsize) + + + # ------------------------------------------------------------------ + # Contrainte TOTALE (bas-droite, ax[1,1]) + # deformation uniaxiale, equilibre : sigma_yy^tot = -F (constant) + # sigma_xx^tot = sigma_zz^tot = -(lamda/M) F - (2G/M)(beta*theta + alpha*p) + # avec beta = a_m (3 lamda + 2G)/3 = 3 K a_s (contrainte thermique), + # alpha = coefficient de Biot, M = lamda + 2G (module oedometrique). + # GEOS : sigma^tot = averageStress - biot * pression (lu depuis le .pvd). + # ------------------------------------------------------------------ + zdepths = [0.0, 4.2, 5.6] + ts_geos, geosStress = readGeosTotalStress(depths=tuple(zdepths)) + + sigyy_analytical = np.empty(len(time)) + sigxx_analytical = np.empty(len(time)) + iplt = -1 + for xCell in x_analytical: + iplt += 1 + z = xCell * h + for i in range(0, len(time)): + p_an = float(computePP(z, time[i], h, phi12, phi11, r11, r22)) + th_an = float(theta_a + computeTemp(z, time[i], h, phi22, phi21, r11, r22)) + sigxx_analytical[i] = -(lamda / M) * F - (2.0 * G / M) * (beta * th_an + alpha * p_an) + sigyy_analytical[i] = -F + ax[1, 1].semilogx(time, sigxx_analytical, color=cmap(iplt), lw=lw, alpha=lalpha, + label='Analytical $\\sigma_{xx}$: z =' + str(round(z, 2))) + g = geosStress[zdepths[iplt]] + ax[1, 1].plot(ts_geos, g['sxx'], 'o', color=cmap(iplt), markersize=msize, alpha=malpha, + mec=cmap(iplt), fillstyle='none', mew=mew, + label='GEOS $\\sigma_{xx}$: z =' + str(round(z, 2))) + + # contrainte verticale totale (= -F pour toutes les profondeurs) + ax[1, 1].semilogx(time, -F * np.ones(len(time)), 'k--', lw=lw * 0.6, alpha=0.7, + label='$\\sigma_{yy}$ total = -F (all z)') + ax[1, 1].plot(ts_geos, geosStress[0.0]['syy'], 'k+', markersize=msize, mew=mew, alpha=malpha, + label='GEOS $\\sigma_{yy}$ total') + + ax[1, 1].set_xlabel('Time [s]', size=fsize, weight="bold") + ax[1, 1].set_ylabel('Total stress [Pa]', size=fsize, weight="bold") + ax[1, 1].legend(loc='upper left', fontsize=fsize * 0.5) + ax[1, 1].grid(True) + ax[1, 1].xaxis.set_tick_params(labelsize=fsize) + ax[1, 1].yaxis.set_tick_params(labelsize=fsize) + + plt.subplots_adjust(left=0.1, bottom=0.1, right=0.9, top=0.9, wspace=0.4, hspace=0.4) + + fig.savefig('Verification_tutorial.png') + print('figure -> Verification_tutorial.png') + + +if __name__ == "__main__": + main() diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/pressureHistory.hdf5 b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/pressureHistory.hdf5 deleted file mode 100644 index 11f1523fcc63bc70ae9ec4c53fe28ab0d8045ecc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2467672 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

u@m-c38t@uQEANnwrDUyO?#vX;&0`xNLm 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�ST-2eccc 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%0ATGQex^c!wY7)1iCz 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

*h@B<)RbZjs?mpE^EAhVmG_NoM5A_F0KCE%}gv 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

*9LX>tB4?kd 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 l-2DQ=&X3nQO@DD;*T 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 D7+IwO diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/temperatureHistory.hdf5 b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/temperatureHistory.hdf5 deleted file mode 100644 index 207a02377081d12c9c2dbb1628a27b874a8cfd62..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2469888 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 diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationDisplacementFigure.py b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationDisplacementFigure.py deleted file mode 100644 index 285a7b15706..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationDisplacementFigure.py +++ /dev/null @@ -1,86 +0,0 @@ -import matplotlib -matplotlib.use('Agg') -import matplotlib.pyplot as plt -import xml.etree.ElementTree as ElementTree -import numpy as np -import h5py -from numpy import genfromtxt - -def main(): - - # File paths - hdf5FilePathDisplacement = "displacementHistory.hdf5" - - - # Read simulation output from HDF5 file - hf = h5py.File(hdf5FilePathDisplacement, 'r') - timeDisplacement = hf.get('totalDisplacement Time') - timeDisplacement = np.asarray(timeDisplacement) - centerDisplacement = hf.get('totalDisplacement ReferencePosition') - centerDisplacement = np.asarray(centerDisplacement) - displacement = hf.get('totalDisplacement') - displacement = np.asarray(displacement) - - time = 1 - posVertex1 = -1 - posVertex2 = -1 - posVertex3 = -1 - last = -1 - - for j in range(0, 284): - if centerDisplacement[0,j,1] >= 1.4 and posVertex1 == -1: - posVertex1 = j - if centerDisplacement[0,j,1] >= 4.2 and posVertex2 == -1: - posVertex2 = j - if centerDisplacement[0,j,1] >= 7 and posVertex3 == -1: - posVertex3 = j - - for j in range(0, timeDisplacement.shape[0]): - if j > 0 and timeDisplacement[j] < 1e-12 and last == -1: - last = j - - displacement_1p4 = genfromtxt('thermoConsolidationDisp_1p4m.csv', delimiter=',') - displacement_4p2 = genfromtxt('thermoConsolidationDisp_4p2m.csv', delimiter=',') - displacement_7 = genfromtxt('thermoConsolidationDisp_7m.csv', delimiter=',') - - plt.plot( timeDisplacement[0:last], - -displacement[0:last,posVertex1,1], - 'r--', - label='GEOSX: z = 1.4 m') - plt.plot( timeDisplacement[0:last], - -displacement[0:last,posVertex2,1], - 'b--', - label='GEOSX: z = 4.2 m') - plt.plot( timeDisplacement[0:last], - -displacement[0:last,posVertex3,1], - 'k--', - label='GEOSX: z = 5.6 m') - - plt.plot( displacement_1p4[:,0], - displacement_1p4[:,1], - 'r-', - label='Analytical: z = 1.4 m') - plt.plot( displacement_4p2[:,0], - displacement_4p2[:,1], - 'b-', - label='Analytical: z = 4.2 m') - plt.plot( displacement_7[:,0], - displacement_7[:,1], - 'k-', - label='Analytical: z = 7 m') - - plt.xscale("log") - - plt.grid() - plt.ylabel('Displacement [m]') - plt.xlabel('Time [s]') - plt.xlim(0.01,100000) - - plt.legend(loc='upper left') - plt.show() - # plt.savefig('displacement.png') - - - -if __name__ == "__main__": - main() diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationPressureFigure.py b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationPressureFigure.py deleted file mode 100644 index d72455e6020..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationPressureFigure.py +++ /dev/null @@ -1,82 +0,0 @@ -import matplotlib -matplotlib.use('Agg') -import matplotlib.pyplot as plt -import xml.etree.ElementTree as ElementTree -import numpy as np -import h5py -from numpy import genfromtxt - -def main(): - - # File paths - hdf5FilePathPressure = "pressureHistory.hdf5" - - - # Read simulation output from HDF5 file - hf = h5py.File(hdf5FilePathPressure, 'r') - timePressure = hf.get('pressure Time') - timePressure = np.asarray(timePressure) - centerPressure = hf.get('pressure elementCenter') - centerPressure = np.asarray(centerPressure) - pressure = hf.get('pressure') - pressure = np.asarray(pressure) - - time = 1 - posElement1 = -1 - posElement2 = -1 - posElement3 = -1 - last = -1 - for j in range(0, centerPressure.shape[1]): - if centerPressure[0,j,1] >= 0 and posElement1 == -1: - posElement1 = j - if centerPressure[0,j,1] >= 4.2 and posElement2 == -1: - posElement2 = j - if centerPressure[0,j,1] >= 5.6 and posElement3 == -1: - posElement3 = j - - for j in range(0, timePressure.shape[0]): - if j > 0 and timePressure[j] < 1e-12 and last == -1: - last = j - - pressure_0 = genfromtxt('thermoConsolidationPressure_0m.csv', delimiter=',') - pressure_4p2 = genfromtxt('thermoConsolidationPressure_4p2m.csv', delimiter=',') - pressure_5p6 = genfromtxt('thermoConsolidationPressure_5p6m.csv', delimiter=',') - - plt.plot( timePressure[0:last], - pressure[0:last,posElement1], - 'r--', - label='GEOSX: z = 0.0 m') - plt.plot( timePressure[0:last], - pressure[0:last,posElement2], - 'b--', - label='GEOSX: z = 4.2 m') - plt.plot( timePressure[0:last], - pressure[0:last,posElement3], - 'k--', - label='GEOSX: z = 5.6 m') - - plt.plot( pressure_0[:,0], - pressure_0[:,1], - 'r-', - label='Analytical: z = 0.0 m') - plt.plot( pressure_4p2[:,0], - pressure_4p2[:,1], - 'b-', - label='Analytical: z = 4.2 m') - plt.plot( pressure_5p6[:,0], - pressure_5p6[:,1], - 'k-', - label='Analytical: z = 5.6 m') - - plt.xscale("log") - - plt.grid() - plt.ylabel('Pressure [Pa]') - plt.xlabel('Time [s]') - plt.xlim(0.01,100000) - - plt.legend(loc='lower left') - plt.show() - -if __name__ == "__main__": - main() diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationTemperatureFigure.py b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationTemperatureFigure.py deleted file mode 100644 index ee60cf94ab5..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermalConsolidationTemperatureFigure.py +++ /dev/null @@ -1,85 +0,0 @@ -import matplotlib -matplotlib.use('Agg') -import matplotlib.pyplot as plt -import xml.etree.ElementTree as ElementTree -import numpy as np -import h5py -from numpy import genfromtxt - -def main(): - - # File paths - hdf5FilePathTemperature = "temperatureHistory.hdf5" - - - # Read simulation output from HDF5 file - hf = h5py.File(hdf5FilePathTemperature, 'r') - timeTemperature = hf.get('temperature Time') - timeTemperature = np.asarray(timeTemperature) - centerTemperature = hf.get('temperature elementCenter') - centerTemperature = np.asarray(centerTemperature) - temperature = hf.get('temperature') - temperature = np.asarray(temperature) - - time = 1 - posElement1 = -1 - posElement2 = -1 - posElement3 = -1 - last = -1 - - for j in range(0, centerTemperature.shape[1]): - if centerTemperature[0,j,1] >= 0 and posElement1 == -1: - posElement1 = j - if centerTemperature[0,j,1] >= 4.2 and posElement2 == -1: - posElement2 = j - if centerTemperature[0,j,1] >= 5.6 and posElement3 == -1: - posElement3 = j - - for j in range(0, timeTemperature.shape[0]): - if j > 0 and timeTemperature[j] < 1e-12 and last == -1: - last = j - - temperature_0 = genfromtxt('thermoConsolidationTemp_0m.csv', delimiter=',') - temperature_4p2 = genfromtxt('thermoConsolidationTemp_4p2m.csv', delimiter=',') - temperature_5p6 = genfromtxt('thermoConsolidationTemp_5p6m.csv', delimiter=',') - - plt.plot( timeTemperature[0:last], - temperature[0:last,posElement1], - 'r--', - label='GEOSX: z = 0.0 m') - plt.plot( timeTemperature[0:last], - temperature[0:last,posElement2], - 'b--', - label='GEOSX: z = 4.2 m') - plt.plot( timeTemperature[0:last], - temperature[0:last,posElement3], - 'k--', - label='GEOSX: z = 5.6 m') - - plt.plot( temperature_0[:,0], - 273+temperature_0[:,1], - 'r-', - label='Analytical: z = 0.0 m') - plt.plot( temperature_4p2[:,0], - 273+temperature_4p2[:,1], - 'b-', - label='Analytical: z = 4.2 m') - plt.plot( temperature_5p6[:,0], - 273+temperature_5p6[:,1], - 'k-', - label='Analytical: z = 5.6 m') - - plt.xscale("log") - - plt.grid() - plt.ylabel('Temperature [K]') - plt.xlabel('Time [s]') - plt.ylim(273,323) - plt.xlim(0.01,100000) - - plt.legend(loc='upper left') - plt.show() - #plt.savefig(' temperature.png') - -if __name__ == "__main__": - main() diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationDisp_1p4m.csv b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationDisp_1p4m.csv deleted file mode 100644 index fe4937dfb4d..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationDisp_1p4m.csv +++ /dev/null @@ -1,64 +0,0 @@ -0.010153382770450296, 0.0000013599017727036408 -0.013363773135962386, 0.000001348306210454211 -0.017588889122929694, 0.0000020169836335079535 -0.022454281034521375, 0.00000200667646706404 -0.028665524766994802, 0.000001996369300620018 -0.03715929564047002, 6.24871965666839e-7 -0.049658839683139715, 0.00000197317817612105 -0.06947524531581625, 0.0000019590058222605875 -0.08869330361688064, 0.0000019486986558165656 -0.12990047589490736, 0.0000019325937082477745 -0.1608473432635658, 0.0000019235749376093772 -0.1961499697321569, 0.0000019152003648735755 -0.2786445563969257, 0.0000019003838131104091 -0.37811725071057417, 0.0000018874998550553546 -0.454121484123263, 0.0000018797694802223652 -0.5290052872535868, 0.0000018733275011948922 -0.6651076743801212, 0.0000018636645326536826 -0.8621294473729189, 0.000002532986153610129 -1.0197394947658354, 0.0000025258999766798436 -1.2435509780552996, 0.000002517525403944042 -1.7398272689135508, 0.000001823080064780407 -2.1874042970353043, 0.00000249369008154237 -2.9233188898260445, 0.0000024814503213901277 -3.7320371169840842, 0.0000017908701696429333 -4.912067090735175, 0.0000017792746073935035 -6.270830076016752, 0.0000017689674409494816 -8.128577892877692, 0.0000017580160766027557 -10.377083574864871, 0.0000017477089101587337 -13.868275049482747, 0.0000017354691500064915 -18.819079409319883, 0.0000017225851919515454 -25.930034799879476, 0.0000017090570359937869 -35.186739680618125, 0.0000016961730779388407 -47.747974844883, 0.0000016832891198837862 -65.7858703632878, 0.00000371057991983587 -92.0282264054625, 0.000007097772492491703 -113.93839291593221, 0.00001117039163367299 -147.662236140643, 0.000017962170122358856 -185.6103461800117, 0.00002543550999215352 -233.2963070659185, 0.00003494966881785808 -280.1206955348425, 0.00004310521426666435 -341.5020276966939, 0.000052620661488174316 -403.8330155958889, 0.0000607768511348834 -499.8741418664249, 0.00007165220012909717 -609.4341686323978, 0.00007980710138000058 -720.7280260248605, 0.00008524219908549654 -892.2269839498045, 0.00009271618315319401 -1121.6392214813618, 0.00009678815809647243 -1367.758754488643, 0.00009814032949434319 -1693.6422214882884, 0.0000974510377384014 -2263.6740781353897, 0.00009403743305173287 -3072.3521667520486, 0.00008790209222594845 -3983.205237157777, 0.00008244895697917553 -5406.171038138221, 0.00007631361615339117 -7008.7803886988195, 0.00007154075389192153 -8418.818380186558, 0.00006677111261996563 -11779.82325702495, 0.00006267530235428553 -15038.951357933107, 0.00006130444921723506 -18622.53255082284, 0.00005993488447599005 -25271.073403302787, 0.000059241727532631766 -33262.205588573604, 0.000058549858985079 -45831.57553825898, 0.00005785605784381796 -60324.27921334647, 0.0000571641892962652 -80617.6723282089, 0.000057832222521416235 -98313.606263342, 0.00005714357496337721 diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationDisp_4p2m.csv b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationDisp_4p2m.csv deleted file mode 100644 index 1692f9097fc..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationDisp_4p2m.csv +++ /dev/null @@ -1,73 +0,0 @@ -0.009998754088411478, 0.000004081637911819468 -0.013362663107590534, 0.000004069398151667226 -0.017058653323225467, 0.000004739363970526485 -0.022797744140105793, 0.000004727124210374242 -0.029551628218007345, 0.0000047161728460275165 -0.038306365970614646, 0.000004705221481680791 -0.04890155591770684, 0.0000053751873005400495 -0.06339007058199968, 0.000004683962950890043 -0.08343332872231671, 0.000004672367388640613 -0.10489686247826191, 0.000005342977405402576 -0.14453607003290095, 0.000004649176264141645 -0.19023681993992214, 0.000004637580701892107 -0.2542387294495813, 0.000004625340941739864 -0.355700314756735, 0.000003930895602576121 -0.4976325182104469, 0.0000045969962340189395 -0.645043899575232, 0.000005266317854975386 -0.8234913350291972, 0.000004575737703228192 -1.1346312476178406, 0.000005242482532573714 -1.6618188048768607, 0.0000045461045997017505 -2.4713393026023933, 0.0000045293554542302555 -3.3535771692660803, 0.000004516471496175201 -4.413850519257689, 0.000005185148919229052 -5.721582692071965, 0.000004493924569579045 -8.127902712897296, 0.0000044791080178157704 -11.029235405122794, 0.000005146497045064105 -14.296968627598796, 0.000004455272695414098 -18.53170873696416, 0.000005804867301673826 -25.532487870755826, 0.000007832158101626018 -35.17431988860397, 0.000013260813828094398 -45.58721884623693, 0.00001869204634617381 -60.905280583255255, 0.00002888390136557067 -72.02171913747563, 0.00003704009101227954 -85.16536268344663, 0.0000458765536442919 -102.25446821781289, 0.00005539264506370463 -117.27276420768364, 0.00006627121504743219 -132.46228782962527, 0.00007647015624375928 -149.6160975249088, 0.00008734937042538955 -174.21514692485636, 0.00010094838815242742 -199.7816911518674, 0.00011522832306267133 -225.64396296383725, 0.0001274680832149082 -251.00420271602334, 0.00013834794159444123 -283.4855907790619, 0.00015194824771728462 -315.30739108928015, 0.00016690974400863728 -350.7522329441862, 0.00017710932940286707 -378.43483589839576, 0.0001886707491635089 -414.5735096208301, 0.0002009117977115513 -461.1772141359031, 0.00021111138310578103 -505.25934791346043, 0.0002206313397126103 -562.0457029828076, 0.00023151119809214338 -625.2143053779638, 0.0002423910564716764 -695.4824591216696, 0.00025327091485120954 -797.6292074144066, 0.0002641494848349371 -887.4041481726439, 0.00027026743231734726 -1049.351459962489, 0.0002791038949493595 -1339.5090086031735, 0.00028181467972412857 -1633.6049792431556, 0.00027976548619548303 -2023.2073126887071, 0.00027295373757181183 -2623.404183329673, 0.0002627386914279161 -3103.9680973001127, 0.0002525275104714368 -3616.858145407688, 0.00024299724669816353 -4279.40626425186, 0.0002327860657416843 -4986.418512926343, 0.0002239360749537143 -5990.713958814154, 0.00021304397681402902 -7307.371084458944, 0.00020487232641765401 -8778.391478736308, 0.00019670132021918182 -11557.383994177571, 0.00018716590286268657 -14532.676355490463, 0.00018307460198232567 -19721.89247021044, 0.00018102089906836088 -26764.03389796784, 0.00017896719615439615 -40413.7429276549, 0.0001789498028110219 -58292.29712146067, 0.0001796146150466592 -82808.22727093354, 0.00017959979849489598 -100982.90057642768, 0.00017959142392216023 diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationDisp_7m.csv b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationDisp_7m.csv deleted file mode 100644 index cf467af410f..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationDisp_7m.csv +++ /dev/null @@ -1,70 +0,0 @@ -0.009997508332052525, 0.000008163275823639153 -0.014642076327913747, 0.000008827443861373642 -0.021444828476583546, 0.00000881133891380496 -0.03189056877732696, 0.000009474862753636746 -0.04599952839405873, 0.000009459402003970767 -0.06737104590376612, 0.000009443297056401976 -0.09717115108065555, 0.00001146865526264584 -0.13388534850727565, 0.000012135400091991362 -0.20842514486611707, 0.0000134772643234181 -0.3195496706161579, 0.000014819772752747758 -0.5050870011596059, 0.000017521538756878246 -0.7510360538100744, 0.000021586427523226435 -1.2427248786483838, 0.00002428626093364881 -1.738454866681777, 0.000027673453506304698 -2.469236035679274, 0.000032420547851664226 -3.5611526400792037, 0.00003716699799912116 -4.981302790847094, 0.00004327528251299017 -6.967649163227823, 0.0000500638400121623 -8.893359505790702, 0.000056175989713447803 -12.250740714758136, 0.0000643257373811292 -16.619272688510673, 0.00007383667521732007 -20.88943607464521, 0.0000826705610577213 -26.660064510881778, 0.0000921840756855231 -36.16085673700339, 0.00010713719740414 -43.41772108499518, 0.00011597301583824956 -52.12766613806268, 0.0001268496532282689 -63.54484090256706, 0.00013908619239099193 -75.13525041748713, 0.00015064374696421726 -86.1704985558791, 0.00016152231694794482 -100.34025795932699, 0.00017444106168967947 -118.63712596192376, 0.00018735916223351135 -138.13991587024188, 0.0002016384529458525 -153.65914921413193, 0.00021387885729599204 -170.92188009864876, 0.00022611926164613173 -187.25574825276573, 0.00023631949123826423 -214.7360360117358, 0.00025059942614850814 -238.85544727734836, 0.000263520103483951 -265.678462720635, 0.00027712105380469715 -291.04341093396084, 0.0002900423753380428 -328.6992769184907, 0.0003043229544461894 -360.08844830161087, 0.0003165640029942318 -388.50789829073506, 0.0003281254227548736 -419.17901626332485, 0.00033900656953021215 -473.44285592736765, 0.00035124632968244903 -526.631466256596, 0.0003634867340325886 -576.9102119716844, 0.0003764080555659342 -651.5792437063674, 0.00038932808870347434 -735.9126290692158, 0.00040224812184101445 -856.9784869877932, 0.00041312604762683926 -1013.3732508788464, 0.0004219625102588515 -1254.585997722622, 0.0004273956753706392 -1553.6016044563441, 0.0004246655646587876 -2014.4452252560188, 0.00041513079150019513 -2420.1166613447454, 0.0004049189663458131 -2863.501154352861, 0.00039402751240403053 -3601.867410039547, 0.00037905184375881736 -4197.377438863477, 0.00036680048804433105 -4743.890522157134, 0.00035727151266686327 -6059.026227402935, 0.0003416149268384441 -7505.148700187856, 0.00033004126731765005 -8879.782426667729, 0.000320510359346474 -11167.617583977653, 0.0003109768745836871 -14478.755753288755, 0.0003048434663516108 -18770.45904248312, 0.0003007508770754445 -23243.20866482086, 0.00029938131233419945 -30129.06263159623, 0.0002993703609698527 -42152.968135838084, 0.000298675915630689 -60803.45995643873, 0.0002979801818957197 -85067.13655571481, 0.00029796600954185926 -96115.22470876326, 0.00029796085595863725 diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationPressure_0m.csv b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationPressure_0m.csv deleted file mode 100644 index bcd2945855e..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationPressure_0m.csv +++ /dev/null @@ -1,83 +0,0 @@ -0.010150923999646412, 0.987603305785124 -0.012900151049529792, 0.9876237877251735 -0.018206356747197474, 0.9876532305139943 -0.023840942487676983, 0.9890536831648694 -0.03169052018799551, 0.9877005950003585 -0.0408812497263315, 0.9877223570616609 -0.05434131097931401, 0.9877466793654696 -0.0690588482277122, 0.9877671613055189 -0.09043149333627863, 0.9864127930197549 -0.11665799236725406, 0.9878119655493769 -0.15740771780960836, 0.986460157506119 -0.19706507612585966, 0.9864793593249154 -0.2619483175442174, 0.9865036816287239 -0.3328931300843456, 0.9865241635687734 -0.46283640251960934, 0.9865523262363411 -0.5708284053867687, 0.9879476584022039 -0.7254288036348263, 0.9865907298739337 -0.9642746363079265, 0.9879924626460619 -1.2817599322880595, 0.9866393744815509 -1.6784448010661022, 0.9880398271324261 -2.2989216146542857, 0.9880667096787409 -3.3432093195047434, 0.988098712710068 -4.511023535244492, 0.9895017256034493 -5.819288499263777, 0.9895234876647517 -8.590429339305476, 0.9881793603490123 -11.41880924135124, 0.988203682652821 -15.64004211629874, 0.9882305651991358 -20.480393182283496, 0.9882536073816913 -28.051454854794255, 0.9882804899280061 -35.648774909408836, 0.9869235613997359 -45.98745810620617, 0.9855679129927187 -55.04353529985595, 0.9828284535111167 -65.88297990528858, 0.9745793521562364 -80.0471225377729, 0.9621992995176504 -92.9825574226782, 0.9470605855786661 -100.21422402961326, 0.9305380605650968 -112.97282209439288, 0.909887144510328 -131.22897594022814, 0.8795969154198287 -141.43523644191845, 0.8589421590013007 -154.73589743096068, 0.8314016303624281 -166.77039565689014, 0.8052372320706218 -179.7408702784364, 0.7832050651837743 -188.00247591190245, 0.7584155171177815 -202.6242637477963, 0.7405155816358926 -211.93768120406273, 0.7143486231015803 -238.92015515371875, 0.6813010128319356 -246.18633359727394, 0.6551327741763702 -269.33785542229856, 0.6220826036642191 -299.11378691303156, 0.5890337132733214 -317.58408897347647, 0.5546035720503447 -337.19493377427756, 0.5229282517640073 -352.6937547165059, 0.4940064722930557 -397.59634115030553, 0.4582040410867718 -428.5191750993205, 0.41964294858008966 -448.21562157565273, 0.3948534005140967 -468.8173951093013, 0.37144126291642354 -512.9052857579319, 0.3535426075557877 -544.577231254386, 0.32186728726945024 -569.6081678166662, 0.29707773920345737 -604.7815211557064, 0.27366688172703724 -632.5796864503114, 0.24749992319272496 -681.7782191808445, 0.2213355249009188 -702.512854131631, 0.1965446967136728 -791.9520453043104, 0.16762931784898671 -853.5456744651754, 0.13595527768390236 -933.8136610032172, 0.10979215951334931 -1037.048950938775, 0.07674326912245133 -1186.7232263265391, 0.050583991315657495 -2328.6293754671296, 0.012074103659098778 -3649.7881600453043, 0.007980275891732669 -4501.380496556548, 0.006620787120956262 -5806.848833698688, 0.005265138713939299 -7490.922707649899, 0.003909490306921892 -9809.247392683612, 0.0025551220211579295 -13435.467666382601, 0.0025820045674727066 -18679.939472771566, 0.0026101672350404836 -25585.42085334695, 0.0026370497813554827 -33005.57936739651, 0.001281401374338298 -45889.15251453425, 0.0026869745102255926 -58317.54813581721, 0.0013300459819556298 -77518.47216056062, 0.0013543682857641848 -98513.19939296534, 0.0013748502258135176 -1399.2998277410964, 0.028559505156328324 diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationPressure_4p2m.csv b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationPressure_4p2m.csv deleted file mode 100644 index 751dcd6ea76..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationPressure_4p2m.csv +++ /dev/null @@ -1,78 +0,0 @@ -0.010150923999646412, 0.987603305785124 -0.013493093324807878, 0.9890050385572522 -0.01740629420154237, 0.9890268006185546 -0.02313727815405322, 0.9876737124540437 -0.030297907783064737, 0.9890741651049189 -0.03967464149927611, 0.9877197968191548 -0.052737429656322464, 0.9863667086546438 -0.0690588482277122, 0.9877671613055189 -0.09179632160310944, 0.9877914836093276 -0.11665799236725406, 0.9891893760176964 -0.1550673789056952, 0.9892136983215051 -0.2061229711975749, 0.9892380206253137 -0.2823212020209928, 0.9892649031716285 -0.3809386326441193, 0.9906679160650097 -0.5457438465435344, 0.9893212285067642 -0.7363772652851527, 0.989346830931826 -0.9358141142568936, 0.9893673128718753 -1.2254341045244705, 0.9893903550544308 -1.6046870010334717, 0.9880359867686668 -2.133026654795654, 0.9880603090724754 -2.8781127717460526, 0.9894633219658566 -3.7128089493104866, 0.9894850840271592 -4.7183681274551645, 0.9881281554988889 -6.0867661551458605, 0.9881499175601913 -7.852020280454728, 0.9867942691531743 -10.917019579814932, 0.9813127899474638 -13.873732243014787, 0.9716913986092763 -17.63122663137432, 0.9524281339928519 -19.875915308625075, 0.938664270279681 -24.149026509533922, 0.9180197548311777 -28.474818631052823, 0.8959952686718486 -30.68943178797696, 0.8794727436582794 -35.648774909408836, 0.8491825145677799 -40.18733612639283, 0.8257767775763721 -45.3037162999231, 0.7996162196483252 -51.07147943642877, 0.7762104826569174 -60.21986491247263, 0.7349022499411145 -69.95125957922657, 0.7004797894456564 -80.0471225377729, 0.6701882802339039 -90.23818146768905, 0.6426503118375373 -100.21422402961326, 0.6164884737882372 -114.67785311057571, 0.5875743750448044 -123.5968592541141, 0.5655422081579569 -137.26078186851976, 0.5393803701086568 -154.73589743096068, 0.5104649912439708 -169.28736117040538, 0.48430187307341754 -199.61164496439375, 0.45401292410417127 -221.679180387119, 0.41683180230831474 -246.18633359727394, 0.3906699642590147 -294.66656131348304, 0.3521178326011042 -337.19493377427756, 0.3121844501111146 -403.597024155423, 0.273632318453204 -448.21562157565273, 0.23507378618902797 -505.27940685576704, 0.21304545966593957 -604.7815211557064, 0.1689836861347508 -692.0678887519011, 0.13180512458140048 -803.9045023248603, 0.10151489549090109 -919.9297138228432, 0.07811043862074629 -1006.4404983000102, 0.0629666041967496 -1204.6337279055886, 0.031301524880436804 -1337.8088112866583, 0.013404149641053964 -1974.8723687289714, 0.009305201388675632 -2959.30406758484, 0.0065849437258698185 -3993.0165960405707, 0.005233135682612078 -4999.018665795859, 0.003874927033088671 -5983.45009110729, 0.0038902884881255595 -7379.547623360033, 0.0025307997173493746 -8701.438961584417, 0.002544881051133263 -11394.399699165459, 0.0011905127653693004 -16323.950862412092, 0.0025986461437628172 -20745.050584316636, 0.00261912808381215 -29719.9672924797, 0.002649850993886149 -36654.42356166941, 0.002667772691429482 -47284.76005789792, 0.0013121242844122971 -54925.87088594401, 0.0013249254969431856 -69801.72750582406, 0.0013454074369925184 -90045.28283432488, 0.0013671694982950733 -100000.0000000002, 0.0013761303470665176 diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationPressure_5p6m.csv b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationPressure_5p6m.csv deleted file mode 100644 index ec3f4cd6998..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationPressure_5p6m.csv +++ /dev/null @@ -1,76 +0,0 @@ -0.010150923999646412, 0.987603305785124 -0.013292477931346833, 0.9890037584359991 -0.01793566452456119, 0.9890293608610609 -0.02313727815405322, 0.9890511229223633 -0.03169052018799551, 0.9890780054686781 -0.04340567041200643, 0.9877274775466733 -0.058567676169505485, 0.987753079971735 -0.07223306769529865, 0.9877710016692782 -0.08776241192181838, 0.9877876432455683 -0.11665799236725406, 0.9864345550810574 -0.18284445081830478, 0.9878503691869694 -0.2504372260790477, 0.9878772517332842 -0.3042785762390852, 0.9878938933095743 -0.37527483474153583, 0.9879118150071176 -0.46283640251960934, 0.9893071471729803 -0.633934824145139, 0.9893340297192951 -0.8056266589439807, 0.9879771011910249 -1.1034456053673303, 0.9880039837373397 -1.5341704235076514, 0.986654735936588 -1.8640008096307419, 0.9852939670445585 -2.4408802220263235, 0.9811847778221554 -3.1019563892948305, 0.9743182074206069 -4.1232686848701805, 0.96056842504122 -5.162086513789205, 0.9385490593669032 -6.0867661551458605, 0.9165245732075743 -7.070373869743989, 0.8931213964586726 -8.090820479054509, 0.8697169395885179 -9.120889089634584, 0.8490660235337492 -10.129224766183718, 0.8270364168894079 -11.766084696229441, 0.7953687773305889 -13.464249666614887, 0.7650772681188363 -14.952754039751238, 0.7402928405378558 -16.358920687741605, 0.7141297223673027 -17.897324155562217, 0.6934762460700279 -19.875915308625075, 0.6686918184890474 -21.745059222245825, 0.6439061107868138 -23.789978636797112, 0.6246300449578586 -26.027203593921122, 0.599844337255625 -29.783634604013276, 0.5764398803854702 -34.596602938686715, 0.5365077780167338 -40.18733612639283, 0.5103497803311932 -48.10122467677227, 0.46628800680000426 -58.44247833740541, 0.4291145657316662 -68.91122382717396, 0.4002030272307393 -78.8569814339672, 0.3767985703605846 -87.57480564424162, 0.3575237846528825 -97.25640576349953, 0.33962640941349975 -111.29314148970882, 0.31622195254334495 -125.46223248835038, 0.2955710364885763 -143.56983359939346, 0.2762988110233803 -174.43582666387255, 0.2528994746382379 -199.61164496439375, 0.23224983870472227 -238.92015515371875, 0.21298145360328535 -281.7176950225821, 0.1909569674439563 -312.8622468107721, 0.1730595922045738 -374.47262439575746, 0.14690415476153917 -422.1479494026821, 0.1317628805800487 -497.76690956741334, 0.11111580488903916 -586.931422054467, 0.08909131872971021 -671.6415364794294, 0.0711965037328337 -768.5776166923116, 0.05743392014091586 -906.2521932534311, 0.03816425491822595 -1068.5882856063554, 0.025781642037133734 -1298.323445043419, 0.007891947525269671 -1945.5099543625452, 0.0010394584575053045 -2959.30406758484, 0.0010753018525915259 -4434.4539440087965, -0.001644955810214288 -5983.45009110729, -0.001619353385152733 -8966.072174173372, -0.0029622005796388073 -13435.467666382601, 0.001204594099153189 -19538.54382325673, -0.00014081333783910743 -26761.428606782032, -0.00011393079152433039 -41321.01717198699, 0.0013006031931346307 -56596.3083539263, 0.0013274857394494077 -78688.41194705585, 0.0027330588753367024 -100000.0000000002, 0.0013761303470665176 diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationTemp_0m.csv b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationTemp_0m.csv deleted file mode 100644 index 0de5c5011e3..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationTemp_0m.csv +++ /dev/null @@ -1,79 +0,0 @@ -0.009847522613947512, -0.00006538323730609363 -0.012984704504125002, 0.06969853096941847 -0.01738715297707653, 0.002353796543054898 -0.022926761479327634, 0.0035306948145858996 -0.03069940537329468, 0.004772976323422995 -0.041107135481112604, 0.006015257832252985 -0.05420287194642072, 0.07577917203898465 -0.07600262436389589, 0.07721760325974003 -0.10334485319892368, 0.07852526800588322 -0.13627088934753467, 0.07970216627741422 -0.18246952481410988, 0.08094444778625132 -0.2519553695461515, 0.0823174957697006 -0.3271634977522269, 0.08342901080392551 -0.4313989465438657, 0.0846059090754494 -0.6049024877789514, 0.08604434029621189 -0.888199860485518, 0.08767892122888554 -1.1893178892332754, 0.08892120273772264 -1.693504709248258, 0.02183800126058344 -2.2676376520806625, 0.023080282769420535 -3.1796546285384446, 0.024518713990183016 -4.458474019210867, 0.025957145210938393 -6.0624267499036755, 0.02726480995708158 -8.500662906977, 0.028703241177836958 -12.10383360127639, 0.0987940715711062 -17.234641266451327, 0.10029788602916767 -24.166718992123197, 0.03314930131472238 -36.034295475456396, 0.034849265484709235 -47.51595108902488, -0.03256085217896043 -67.65793371178145, -0.03105703772089896 -91.99618979378293, 0.038837642960444896 -119.4568517711176, 0.039949157994669804 -155.1177308394172, -0.02752634290631306 -210.9219156090737, -0.026218678160169873 -300.33158671082236, -0.024714863702101297 -414.6827600431619, 0.11383221615174932 -581.4264838157069, 0.3210316951781138 -743.3282497011799, 0.9393609703918457 -880.0194011992243, 1.625950345354255 -979.7215232722228, 2.3808652033026334 -1074.0431528439112, 3.272888709884114 -1214.0881612533528, 4.43939104668101 -1372.364780608189, 5.674480399413113 -1504.424295895417, 6.703677937864995 -1623.9766943305667, 7.869984124949973 -1726.3726233559503, 8.89905089692725 -1835.1475197500574, 10.065291700774921 -2011.2731934570777, 11.848946414514025 -2171.1949815654075, 12.878078569728608 -2343.5855923579347, 14.250145804619194 -2491.092184401604, 15.622147656272467 -2607.61861700225, 16.85691009281804 -2688.202299554259, 17.81725908238549 -2901.8873934524395, 18.914978253535267 -3037.245573084486, 20.561262785692044 -3328.811058957642, 22.276330483495958 -3704.388051751737, 24.40298566014839 -4059.3980338875435, 26.598162469498714 -4314.171321748316, 28.518860448633614 -4727.719521263503, 30.64545024204874 -5102.4501979037805, 32.429039572550536 -5591.797012988701, 34.418455334095256 -6318.6496999461115, 36.7509369417906 -6716.207497680589, 38.19152580937909 -7249.31455296477, 39.632180060204874 -8067.737044641319, 41.5530741890517 -8978.178124241254, 43.611142349768926 -10147.9915353643, 45.05199275030664 -11295.807152428426, 46.355603735736636 -12768.403810586182, 47.59069308846874 -15115.120130475732, 48.55163052717196 -17621.425778644534, 49.306741534832256 -19924.130714683673, 49.65019968040673 -23956.254936660134, 49.92533234299522 -30632.831165884967, 49.92637847479214 -39776.66444790172, 49.927489989826356 -51648.82340157383, 49.99718852079578 -65036.27075400391, 49.99816926935539 -83163.54530608773, 49.930628385217105 -98477.30173013602, 49.93134760082748 diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationTemp_4p2m.csv b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationTemp_4p2m.csv deleted file mode 100644 index 6587dbad78e..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationTemp_4p2m.csv +++ /dev/null @@ -1,79 +0,0 @@ -0.010154838320286299, 0.00006538323730609363 -0.013808079447942344, 0.0013730479834492826 -0.018489302502721943, 0.002615329492286378 -0.024008824998343215, -0.06486017140869649 -0.029770349769560688, 0.004642209848803702 -0.03806730645718513, 0.005688341645722517 -0.05019568508168139, 0.006865239917246413 -0.06418515541884809, 0.007911371714165227 -0.07958968428283685, 0.008826737036464749 -0.10334703142811452, 0.009938252070682552 -0.13013472669692205, 0.010919000630295272 -0.16898322037911714, -0.05655650027068759 -0.2160786180238699, -0.05551036847376878 -0.27629361652116846, 0.014122779258343598 -0.3532888317617504, 0.08375592699045598 -0.45874477739519076, 0.08486744202468088 -0.5956790927636327, 0.08597895705889869 -0.7386429247941366, 0.08689432238119821 -0.9591262266046674, 0.08800583741542312 -1.2647072384377274, 0.08918273568695412 -1.6171794552933025, 0.09022886748386583 -2.1990121708282984, 0.022949516294808348 -3.0834287924135517, 0.024387947515563724 -4.257622973771922, 0.025760995499013006 -5.614116728441364, 0.026937893770544008 -7.069303646215659, 0.027918642330149623 -9.61251211588196, 0.029226307076292812 -11.558564609652718, 0.09859792185918081 -15.716801528530866, 0.099905586605324 -22.72565899768972, 0.10147478430069867 -30.430125012396537, 0.10271706580952866 -40.12527058714834, 0.10389396408105966 -54.56163698475552, 0.036614612892002185 -74.18882658893563, 0.10650929357334604 -99.33408413730689, 0.31351262288779225 -141.4178942814683, 0.8637125648274733 -183.5766496504274, 1.825042302954536 -231.06742154147815, 3.12917635428299 -273.51244862121325, 4.364461856727019 -313.956479536012, 5.599616592696428 -360.3885274683878, 6.766184312730637 -420.03105544083894, 8.41292652754857 -482.10000949068575, 9.92242932725879 -520.4440584795021, 10.882974466538158 -579.3224804765924, 12.117998436032963 -654.7640094544381, 13.764609884376277 -763.1724859787392, 15.205591051388609 -889.417536437656, 17.058094314012145 -989.9966098796707, 18.430292315377343 -1085.215965767925, 19.596663885699634 -1189.5936618416808, 20.763035456021917 -1344.6203326069424, 22.13529884062443 -1473.9479289919866, 23.301670410946716 -1717.8790585492452, 24.94841262576465 -2001.715442798373, 27.349612015869813 -2369.063183064449, 29.065006629860253 -2636.744496793452, 30.711552694966265 -2980.2996180407863, 32.152403095503985 -3266.880439608481, 33.38736168176147 -3580.7165156964043, 34.89666833175977 -4047.181345484366, 36.40610574823268 -4504.6637290568715, 37.91547778146829 -5014.070037651899, 39.28767578283349 -5496.214954253563, 40.52263436909098 -6024.595169045325, 41.82617997128367 -6809.570932258092, 43.267030371821384 -7579.945354707946, 44.50205434131618 -8970.990124537786, 46.21744895530662 -10949.807320316113, 47.59003925609567 -12764.636679653275, 48.55091131156158 -14881.82547508411, 49.16884828735147 -18450.373518659027, 49.71845978015539 -22528.21972490492, 49.925070810045995 -29705.1641920149, 49.994834724252726 -38571.27792798286, 50.06453325522215 -50860.22364751764, 50.065710153493676 -62105.12456086096, 50.06656013557867 -81892.03714535893, 50.0677370338502 -99997.89231566602, 50.068587015935194 diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationTemp_5p6m.csv b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationTemp_5p6m.csv deleted file mode 100644 index b0a5c8a2df0..00000000000 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/thermoConsolidationTemp_5p6m.csv +++ /dev/null @@ -1,81 +0,0 @@ -0.010312074131115496, 0.00013076647461218727 -0.016101391474977494, 0.0020268803565173243 -0.021560094495253666, 0.0032691618653544197 -0.0284292169405849, 0.004446060136885421 -0.03635240170142669, 0.00549219193379713 -0.046483767464426694, 0.006538323730715945 -0.06129236848963046, 0.07630223793744051 -0.08463298936573758, 0.07767528592088979 -0.10822009037553766, 0.0787214177178086 -0.14052355128648145, 0.07983293275202641 -0.20633573372439612, 0.08146751368470717 -0.28491002042159363, 0.08284056166815645 -0.40569175463007623, 0.01575736019102436 -0.5516408831558136, 0.01706502493716755 -0.761710114134855, 0.018438072920616833 -1.004372484084059, 0.0882019871273414 -1.4747558792731383, 0.08983656806002216 -2.0999039950600644, 0.09134038251809073 -3.0833638034679507, 0.09297496345076439 -4.390399835067726, 0.09447877790883297 -5.969862622996343, 0.09578644265497616 -7.517259374810218, 0.09676719121458177 -9.912075908769697, 0.16653110542132055 -14.114096308388454, 0.09944790394417424 -20.40823250091457, 0.10101710163954891 -27.748415975181043, 0.3080858141913012 -37.723855920645136, 0.9266766223542646 -47.487917451255115, 1.887875594006708 -55.36093450283487, 2.7115736176022125 -64.53513749551234, 3.741032689003326 -75.22331221585263, 5.044839824145235 -83.7404698922964, 6.00551572989923 -90.40080720133093, 6.966060869178605 -100.63643637440106, 7.926736774932586 -110.3227750905378, 8.887347297449267 -120.9337847435934, 10.053718867771558 -132.56817130753677, 11.151503422158633 -145.32490238426186, 12.180700960610523 -161.76567212667092, 13.41572493010532 -174.63178026735855, 14.376270069384681 -188.52120031663478, 15.336815208664056 -209.84881585339235, 16.571839178158854 -230.0226924789056, 17.875384780351546 -260.0154630833952, 19.04188711714845 -289.4191045522492, 20.414085118513647 -327.135916329084, 21.786348503116162 -353.154823930799, 22.74689364239553 -393.1241980306451, 23.844743580019923 -430.94455482528394, 24.942528134407006 -479.7079079876418, 26.1089650879666 -542.2343972238937, 27.412641456633907 -612.9753616051692, 28.3733827456252 -692.8723087084063, 29.67705911429251 -783.2162655995311, 30.84356145108941 -899.0297249815874, 32.078716187058816 -1048.013503299308, 33.10817525845994 -1166.6748064473145, 34.06885116421392 -1298.8262824664105, 34.8923530380975 -1514.0309103321279, 35.99039912543381 -1711.5543563700394, 36.9511404144251 -2026.0797531807355, 37.98066486906352 -2325.8703601749457, 38.941471541292124 -2670.0760150629, 39.83369119758552 -2972.457956261255, 40.7257800874043 -3464.896292992599, 41.89241319067582 -4164.959538113848, 43.059177060421945 -4708.526818887187, 43.88274431754284 -5488.574560273634, 45.04937742081435 -6398.2550652825785, 46.01024947628026 -7809.908666132243, 47.2456657451989 -9245.493608546547, 48.13801616796691 -11287.001535141568, 48.89332332533913 -13780.168450737357, 49.442869434905745 -17618.454765575774, 49.855437662313875 -22528.21972490492, 49.925070810045995 -30165.749763528773, 49.92631309155483 -40391.70829122072, 49.99614238899887 -49322.08108319346, 49.99699237108386 -62107.74260359248, 49.92938610370827 -78206.15645939638, 49.93036685226787 -98477.30173013602, 49.93134760082748 From bd99d16f794bc2e6a50070bbce216b00ce98b117 Mon Sep 17 00:00:00 2001 From: npillardou Date: Fri, 7 Aug 2026 11:08:45 +0200 Subject: [PATCH 9/9] fix --- .../thermoPoromechanics/thermalConsolidation/Example.rst | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/Example.rst b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/Example.rst index 0d6f6359dca..3b887ca1ef5 100644 --- a/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/Example.rst +++ b/src/docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/Example.rst @@ -205,8 +205,10 @@ Inspecting results - The bottom-right panel compares the **total stress**. By equilibrium, the total vertical stress remains equal to the applied surface load at all times and depths (:math:`\sigma_{yy} = -F`), which GEOS recovers exactly. The total horizontal stress - :math:`\sigma_{xx} = \sigma_{zz}` follows the analytical thermo-poroelastic solution, - exhibiting the transient overshoot driven by the coupled pressure and thermal fields. + :math:`\sigma_{xx} = \sigma_{zz}` follows the uniaxial-strain thermo-poroelastic relation + :math:`\sigma_{xx} = -(\lambda/M)\,F - (2G/M)\,(3K\alpha_s\,\Delta T + b\,p)` + (with :math:`M = K + 4G/3` the oedometric modulus), exhibiting the transient overshoot + driven by the coupled pressure and thermal fields. .. plot:: docs/sphinx/advancedExamples/validationStudies/thermoPoromechanics/thermalConsolidation/plotTests_tutorial_updated.py

vR&l! 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%0DNDw` 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 z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF 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 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1pZe7TWmIK z);!bJoHly%fph!AS06U_>#<9wZ{KRZe}9;fXTDqYw{G+&7agnm+cf%P!*%}yjsEa^ z>;4BD{fUp){SP(zqkGr=4>$TlN7nt1H2ULb*Zpl9{juBY{&tQ2@ZanH_Kp6;!r!Z| z*GC)u(G~0d4vqfMhIRjAjsE!db^qgy{>WZ+f5%3D^02zUQ=>n2M&18Jqd)xHy8p>W zf8zeS|EWfQbe==1>-FhIe`u+?|CvUAeD%7&bE7}9Y2E*9qd)oSy1z@KKem6}A8qu9 zkE{EiYxF11tNXh)`lC13{m(c0Lyy({-5UMzg}z^1-!C-!Bg@wP-5dSMnRWk*jsDmN z>;4{%{_yT~|4WVj#8}@S>69~qd#;--QTOxAHS>af2GkMd8Y1vwb7qk^w8@1 zey!0T8?O6%H~Pcxt@~eZ^d~-E_xEY^NB6G#-)QuQj;#CpHu~dd*Zut({gH{fzkj1Y z`C#2YpwSH~J$d z*8T4^`jZ#c{qHvVV}GdoV~zgYi{&2#2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF 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

$!A+o>+JJw7ZYl!Lhi;;t3WIK%2mTzoiQE;s zX(+fkbQAT|X6U8_@cYnBS>R)!o5q3LK{q*omqIs{fp>#$>J4rK-P9HQ7If2N@b}P7 zB06QP@Sf%k@P>IEJT-LxB=y6H6ZQ~-1n^^^v5lRmf|bkiVk z8|bE9EWjh6n^uE6LN^Trr=E(0p1K9y^bq_!bQATI9dwgDcw6YE_TXyJ zO*-Hsp_@Fx`$9MM0B;N3)DGModdd}C8M>(!cnoyYM(`5osdDgf&`s1+2cVm%r`({M z$TOjvGQgKWH${SnKNA6QYz<1;vobW0| z?o+$L<6XwLPgiLuem>j5`%mtl|8=O`rv`%8af#gRx=-#?8sKvxybFJp%6%#Xyi>`T zeL2o@pXvj?H@;M<$u7B1T>$Un9`3%qRPIyW;DrHY%AMQDz3CUY>T%c1w1@Iu2mHgM z;BLRdy(t=e)knoE9cs$`Xgzqx(qWTLM#=jw;QIT<^}cdK-jiSV$<_O! zD)*xs;Gb8irtTOk@AJVA#%QTzrpWuF;N#1uD+j8{{m2J=S=(l%GsemLDDd|O8_l?P zO5T3}w>3HGIa^ikL3ZFHY@eu&_mcNx!RJp(@n3pW-p>VJaiQ+#XVv5$v=)4F&Z=!5 zuJV2w_?G%h+&*uY_dCGr&i0PkQY7zn!7b;1Ng3Wl?nm9h3sM)B8?BJ{U%<0{1~2;Z zNZ!8zFJ8CS;k=RDgZ_YzJaEu^g^#=+3$E^e^_=?&d9MXN^lZpjy)t<}68v9#>Iihx z0PsD~O$)(KK{thfe}Ha!488=qDFpmEbWLuYqnN z4~K3F0ndVNx(nVAx=9DT2Xs>(a3|=dq2P(oO$WdepqqAqJ3u!%fvZ6`X@iGCH${N= zgl_5&eg?YfBDfQDlNb1R=%ydwTF^}m!1JJ+sHdJlH<8zXZmJ1x0NvCSd^2>@c5vz@ zQ|Kw`Ch`x^O~v5%pqrk6r$IN}178Q-6bpVCx`}#fDRk3XaC_*c{@@*;oBD%)hi;;t z`U%}cJv9uvX(adu=%z2=U!j}+fUkybqMq6S-Lww8Gjvl=@aE7{&A_RrZb46dgl;MV z-w)kHJv9Zo$rpS%bW=2V9(2=3@V?MZeZak;o4mjmK{thfQ%^-fPx(SOO$FZ!-4qY5 z3Ek8XyaRMoC-7qErf=X+{vX!vJ1PeU{{KEIT2?Bv2rVm#Qk2RpBzt9x?50pwq>SuM z8Kr4Q2+7DMBPBu$>vC=jnBv4|G#D_;=_g z^3l*uBfyoRo7BMvKsS;9YfmjWVl-K!huo)P!0XMq`Qua%xlieWze&C6dTN^7r*!XB z?EN%1#0+te`_yRgj4^%78;zFx)O+xh;ag)DdCPq&2YhSL#Zb4)a-WI^&y3BtKR8hC zQ%}J!wQS$Y;)UF&?t?p6Zr3*Ql>5{maP88X(<2nr#h%g(JS;-F!R^g*pNa)<+huHzLk=s97~bGc6q0w1%*d+7Dna-W(2e(vO#`2K#H;{B2@**ny|?3&!C0>J0k zxOTZ%U+z;r;Cr^@_@19C_o*=OnhBS`e?BAksT$y|-4^P**J>!IzH8{sDa$&@y(toW*ScyRo-gEmEO^<0fQ{vA z=QHC~hZ|V*{Bw1a3cv6GYeH-+Vd(&-j^H8n5 z{@>+&XYgF>+C7IKko!~-_^0A(5B80g`&2o2?IlN#45=meruyKoH?FQd=7PNc0KQ~i zyKjfRiExmm6j`J2pw)D;ZVnp0V$%3{R5xUf`)^76N2;AS_S#MIJy!Qi7sOo+AteV_|&Ve83w*9%4 zi@ZMuKImKC$_H`sek6FA&(5C9zRG)r*%fY9e&gH1HG9Qy0J&K{qW2_kwQn2d8d|gr2Gn-BcI6 zEp(GP_)_Sm5bzVwO=rPhLpOZ_4~K3dkA`lF1pfrxL_K8(-DC^y0^KwU{3Uc#F8BrL zrfcBV&`mbr#n4UEQ{SMQluIh^EKTSp9q>ZvrjOw3pqti%e}r!O44wwvL_K8--DCqE z2i3?640u)OCKd3`&`n*y!=Rh?f!~5|N&}~Ex(_`S0o}A4ToJlS1$-`alP~zc z_S7-xrbO_z&`lk{gQ1(Kr=~$SQBP?@H`N6{0^M{Fyg77JGw?;wO$)%Or%pjn9f58- z1U?YDX(;$N=&4H3Qw7jXh2Slqn+(CJr#3=QQ8$r?LpSXLuLRws2<`~oMEFkz0ARLqPg6g z=7E3xwq(J;e0i_*y<$HQnAK<4PPtDV0-s*A+<$C8xi|TOYpm#gbXXO+H`N8tZ1*O* z)p2>B1Ab}Dm~K}l%YEt&_&DXOks1x;-ZUTFx9h8(pKr+fAnc<{Z@O*_CpLpNoBYeF}vkV7|>LudVfZmL{Zac8ZBZdw7Z2;Ec-d@^*?1n`5< zP0`?0p_`P!eW9D?gExR~Y7S04brX83J@iy(a4qO29q{VVO?AO@p_|@-SA%Y<4L%sU z$p!ofbkjxf)6h+4z@wm>$W@`6YJo3;ZdwdJ3%ZGVY8Q0VZt$tlOa^fS!5)-9)|?x@i^o&ps9RlmhfrFX$!*@PF;8y9sfTom}NURRr#H zWJs56SGiC5g4Zi|>@#h<+^712AM)N%a-X^k z-m0HRLcnvmPdR}1tyVO9tEb$j27`C{IbmjjVl}a+^Z{>B!)wE?t#Y3-0MA=LH8`WS z+^5RG`*phNaqN=Zr(D2K=;ptSJt+67GvI?O@7eYCo7|^Hf;W8?Xw}+L?o$TfSHH%3 z&)p{XscYc5E1o>f%GVN~|10n}G4oT#b&~tkTkyt%^y}ANE%zxs@NefVhn75-`&6am zirsx#kf)l3+^0OjA9b#IW^9Pur*gsjDz(1(F<0(WW5LgjcbtCJTJBTn;ENhY*%tPe zds8s@s5OhfZTKSZCxe$73`>6yCHJY%;1})Jn;se>_oi#$XYN`JX;@Y6O&7rrUdo!O znIP{^gGcpVxOl@PxlbJjU*`03>e{+;Z(0uSG0W_6u5hf5VXZN8pHc^pwR*YDLPPFN2f(9m6lGha$os?K9`*;`e)E<4lppx@ zyLRtpw2*sK4!Guow3)tH^1dnf#!>IxDzBFNR4Dl2q$1OKjpcrH0(|ztxxIG!%6otC z!sE?KN2JR8ci>H0Z!?ZHko%Dy_`B5ntoifheIfYMf{aGj@5}oa;5EaSHeO;Z_akla zsv1KFhc1x!YT!MLKhLXvU*7iwck$~Kchx}dM`OW*^>4agnk(mrsmt=XX}#E4fzep1n14+N#SvXg>J1thTL7hs*nY z;BQy8nRp>m-oFEXJgmmq4JGnE2fS_h@S(2OazAPhzF>xFxAsBuehK(%+vt_$sq(%6 z++@x8wioNleaZ~{Uwf+NiHdtF0(xpabkhv*anMbs;Mbs=lECwzn_h$8f^IqiZU^0D z2|f(E$%!1gX%Kh|=%zN{)J@-^r^Y}xjRH@CZaM|-0^KwQ+z7hK1pESY(=Bl7skhKm z`Or=8!J9xg>4TR;PborA`9e3%1AhVC^ak7ox@kQ4W$301@TJgAf#4INo5(*xH+=<9 zfo{4Co($b|3H%gvQzCc_bW=R|O6aE5;Qr7}^TC6lo3?;wKsV)pH-~O&1MUdj)E9g+ zbkh#-?$Axn;IE*kUVldNo2aMiLpL=64})&n34R*7 zDFNIMx@j@^N9d*!@PF;8x6n-`;7_2NsHdo#>OoH_LpP~|J3=>+kB4p=4ITpBv=V#~ zbkhQG>ZxStDIe%2FL3IqD$rB2p_}}`cR)9Vf`5c=Dgn=eZlazthi)QY2;Jld{tUV) z7u*QCsRj7I_LSR~C2bCQ%YAAkcs1Qg4g-ATK1IG~{({}>kH~#04Sc;*$0|>Jw!l4#afQNtFB48E}sut)7*i>!hqW51 zXox*15&XMHrjqS2xldK{tk}OTD~q2VE%&J(;5~;G%|Gx(OS~RO@Dp_h%vbLt_opl*6X)N?o)li)#`8h9P>r) zQ;osbR8cMNGEnYQ(clYXOR}pCm3vb#c=xHjwA7U3-qa7=#^?F_$ar~g5B_oZ>oXbS zlTwea-aGN?l|Jy z_8EiZ-ZTJQbHI!vH>=6LNe4W<_;1}mBXMA5M@2`T}pLFkYHACKa1>acs$e@{t+>glT^`A1W@-lfp7d&*A zxB1X4dA|qzZIR}!dhO(X^a0#ue$GLwAbCFye0yMO)RD*Xeg}A3{b$cTP2_&`5Zq;K ze3@5(yq^F*e@axPxHNh12d=wvY+MZkxgQyT7sf|*-8@^~e*iacI`OjQWqEH6ZtS`4 zU9qOzgW7{nsZ!nk+x0_dib;IYt6 zyTN-vH+2P1fo?hgz7)F2AAAdR6Lr=c=q7*g`_N6~W1*WSf=5F)MS!n?Zdwjb-E;Vs2HMMF=Gf^HfM?f~7?AG`r{6ZO;<=%y&} zCD2Vv!TUfrky}GIbpG=&`oW?7ehBK0>1{`ln(9< z-83J3Cv;Od_z&o&a`1l8P5;_cy3kWm&{O-ssi!_dPklRFaZgo)p4tfAL_IYDx`}!! z1-j`LcrH0rJQTWV7kDOgQwI20=%z8?i=mqqf$Kmw>46tRHx+?XPj!NxY7O0F20jhCX(sqY z=%xwayP=z?r$#|HjRvQldILQb2Hg}6{u;U|AN*f?DsGC|b@iokpGpPqG`6AJ!KHGa z>IOcs_ED{ESLHqx3T}QNrKMSr+^2ej_nDU5c0`=qr(D4e{kN^Ic~|aJJ-|zjzRKCVtn@Mt?$_B4}IDLrY3As+uF(uqD9M ze3aa$7K3MWH|pKwxZJ05z}FeqK4M!#SG=AG@I7(MZ*Osv`_w7$u?7pYHO9+*Y6|%N zi*HOkYRSDR0o-uhojH@v$@^B|-6lC1zndxdsXpLp%a=}6Xe{?8P4K-FPnhmbmG?)% zyA0km`|KjQPdS4ZH%TfP&`$16pTH|8AL=|bSKe0#pZ3x+`P^o?PkDg%KfE<*k%Qcu zhJ!zCJ=i(qyS&c>*Ql&KCF79Xry7BWh1Y%3Z-U&XqQKYK1W$RTE%&Bv;7#hiKfC<8 zyeA(}ZA-A>0=Z9(1V1$3>C*kCa&L+Uua$LYrQ%C@-vC^B{kO;lTjf5b39kKkmVTzA z+?!0n)r?;sHU1&*8-i!IC~_}7DEFy1;K@xDmus|@`_UC}_suqb&cX72Hn?hz&pxAU zd9MzhvrtQOjfLEga=}k+=f?-toKBUj#^1W%nm*lv%N+>bKA+Z`{sbbXDy z?+9)&Y+i7$TzPK^-b6_&rDjLDAL)ZvJKVaN_DXqQ6TG?I${YQk$oppCA6g#uJ=I3; zN8iC?OE)j>wou+52A>t`Rr2Pxy!Qn^Giv+VeL8Xvx&m(Bt?Ant)8xGqc*BT3Q*BPl zdtLBx69W5bD9Sx(3V6dcIagjf$$MS!YP0IRJHA!ktAmGoZMn1Pxx9}AFF4=dr@OJ- zr{018YflwGH~E2&hi+;QejK`K0r&vurtaXgpqr+FJ3}{FfLDcXDu>RR4Ba#m{1kN4 zX>f1oCNJ<*=%%~im1kAlQ(vK{e4v|VfFFWxB7Y9u^cuVdbW=U>me5UR;1{8ru7gj3 zZgK~o3EeaYdH~B+P z)rM}W3I4A=bpm=S3H)DsDjmA%A$WV}ChDn9&`q7e4WOHvfvZC|se&6rHyMIcPnAJW z9fEE;0PYUmGLK+5z3P8$1`f=@t0D z_SC?7Gd2#|Aor=c;2+MmNcgxx?o-9!76za0FL);RsY&1)qCWy>|bl>z}<46QXEjRrx<+sY1>imQxCu$ z`x(Uq-j(~*aPZtI_ixxwm-|#H__3_*x!3PW;HAmyJ+@}VCkMSQ{*qtZN1s+ zg50Na!Kb`DUVm3Txlc_6w^;6fT+dzZQ|90rPLoEbU6uP(L+~aS^BbLND)%W9@I|BU zw7xT6?o%7Vf4Ik$sm+l4l%hw)o)8%|?s7vt@$*Uozc#l^u;vYUe*^sSsMD)U=E;33 z8$7VehQN_6<=(UcJbd`^@eWz?{t)=P+Qr|Fg~)yC8~D3zyQ*yNBKM{u@WuhhD&-W* zdn549BL@s!7a{klF5sPt6uWF1D)%Nk@HS;h*Pg4&y~!M0_jAH4wN4pI!~mQr(_g*2?>I@U|E1HT?7BeLL_MMmv7~9Psg)b2>fWEbqxfZtncx zP$=)$gNNRqv$|1NxgSMz2f#p1;okh~uU-d^GQ)zumDz7zN{C9TK3 z4di~51RmVd$y(c6-fsl2Q!R858|rXk?U&`s1?522f~z(+whk$;44`UHLnx`}#s^gnwpZ>`kHF6awQ|xAm;2Od@crf;6uOnked-nX z)G^~t!}iI2YBBiU1J?Hj-K}7s0`FfmcKG^oxleh6d#x_cy`wGnskPuY7F26L>5$x~ z(#U5WINr)Z?o)Z-h87+fJ#ytfWd(kWbsYTq)@qf0E|&Y$UGSb$7n-G{$$iQRJnV(R;LS$bV(*9qZ><^r z+Hbzxr_8{&_(y9jxG(pqo!~DFbykJ9ko(kY@WzLSEiMj_`&3i#6W&pare(=}Dg}I> zLZ=CJEaX0Q3Ov;?!6JXX+^6!uePb?eF7=iB)MD^H)gqEr4dvc66x=+sb%!JA^1c)J z!jVc!FPF)EDhRxLx7Ka;SjfGpFZi9?9-E%!$@^#E^TvLxv~9cGr{D4+^Roh;2KRO6r zY+$>`dY8N>f1xw;^r2FD{|fwi=$6YXddvOjF8G|-Mzb#NmiG(59j4?Ra4MDeG{{iqK3dW$Y6+wGM1+rTGQ;%oUj=^W{E9y7t>iwH2L7)-RSMm-7(4^I=@|G| z=%y6#rO-`tz|TQ9C4tX_ZW;}~9J*;Ccsg_wbyhxfQvrBq=%!BKkD;5gz@4C*9KflY zqM)aaK{t_8H)TLib%k!Cp4tuF6b1gTJ+&3ODGZ!?ssMUQAG)apcrtX;Rq$ibO^M(S zpqpNU`$IR)2OkLCL{2@`8G0%Jx{2HYx`}!!3%cnExF2*=Ab4fyCPnax&`qx3W1yR6 zf@ecFy#)`1ZdwgK5V~my_!;P?Wbnt(O|QUJpqt2Zp_@K~fBeUunho9L58eQ}Nf-PP zbW;xaeCVcS;FF=7$nQZn-3F&_a)+MsgKnA&9tYh-Jyi%jRR;bXx`}!!6}ss@_`mj4 zZ|Er}a82l@+Tfd^n>K+@gKnA%UK_ee3p@$B=`8p;=%y5K4d|wN;MJjv{x4L^~+2xQ5_9^fiAHG^|&z1YsUGUB(mG*^nmits!aJ8bfC--fV`&4c4 z33r-gynHYBDKBuBT_0on^_KgT2e`j!u4Yb@+^05yPcr?amKq@UDR=Nz*WQe`X(#t4 zbMUjR7jEwSLf)STA0GQEJY~Jyr^bRW4Sqg5t*hLdR)Tvb^v)SyD(@G8|7?0=*OVx^ zPgQSLu|NKK&Mten+?$?)-?+KO>a4olo6^CL^axKcJtyyvgCA61ZN0!t?o$ci%`0#6 zb}*ECQ!DWMnw!TvJeK#5!J9bNPM^6(?o$Tf>j#*G#B`N=(++T#j!(PfeUkSh!5wPX z+Fx(K+^3wuYu|1fVK`RqQ+2?*J@sr{SyS#!eZlKSYxZ4xMcy|7zj`?~`rJIZPdx{> zI^C=G+}3h$>IpuzNADN=p2>R;@O^6)gSPaN`%xVDS-nP~<-6tm1@JSM-p%~}S>B%o zZ`!tZ+dyZzACW6ITcQ&ZCGQo$qwTd5;k@R|xPhOJ`cy(W0> zu+!Q}KjeK5_#Lx$CR_T;{pdb;Rk!Qi4n)X%b#Tq@$79RN4cL2Yr zt=9Ifj@*N;gNN>K=y}0S-tPkMdc|(~#-sAS2lzMZ3Fc$J$@`z+U03NmZr)YyQ$4}| z?w0?0{2aQ;1N;eeQ#`o(?TUNq9`w|G=%y>+eW06qfLlN}X@j?gZfXv00Nqp<{48`6 zxk6^eJyi+3C3F+@R0wp_Qt%znP3ypGKsTv_uYhg}0ly2~lnEXW-E;!HEp$@{@Korg zG;mw!rk>zh&`tHg-JzRigU^6&@&sQB-9$Y#9lD9!47!P&dg=o7lnZndc`$U-D)0r+ zO$)&*K{u&_Q#ZYUo}zBbfS!tnZaNQs7`o{UxFK{?TkxmQP0zubLpK?LQ%{9KPmO_Y z8VlY7y2%B+Ds+=3xC3;PGq?_PQ#0^%=qBo^&d^QNQ|{1B)Kdqcn_|JKo327nU4U*% z25$mA)eO86bdxf86m%2y)B)(GBjD6iTF_Ikpqui+A3!(V16P4=BCiMCL~a4y)CqhK zbklC|HPB6)z{f#1QBS2qH$4J(f^H)J*Phx9-LwbX7P`p>ycoLa6Sx(0lQsB%_0!+a z@BepORzo+|gLuiz`}gA?Yc zsER#h2l$vNXH>#t zbHME^KL?I-lKYe+c=U4L1vb%gpE?YlI{(SCt_nKh{bqw3yv}SebBx@ltiey5Pb)lo zM($Jh!E=s|nzl7W?o;o5hR)T9i zZ9J#6pWK@ogO8mO;CjEZ+?(9NpO`EvF*qjg3&Ah+ONo3vN$yiuz*8n)c&*kz?oD^W z4|Uu7DfpJWKL*}@#%GZ(^v2)jT{}T)AIfxc+D2&zO!e^eX2Hi#HX`C z^P0)M=>YiSbw`3tGvs|Pc$1EHO3PNreaaI2j-_AWIBU5#Jps3=b?4B*_wv3w_|bNE zVq%@;esmK2cH9}q#xe5#K6u*VsR7278vQsVes%eekx*_H%y@m-lAiUEbe0 z*WiG>?+!k+P3OaIKjr;k@Sa)Ctg@Zue&hrmv@HG2oIUb>1^Ao+o4>UvmiP0)z53>i ze&0pzM}FV|ePeE(3z7FB;1AlgyS4d|yeALTNWL)3K<+^+!JQW;6!-9u_XEJ+zV94V z|Fpb+2Og{H5cX0*?o9{4ONJ?QjqNS(OTqu{rT=>T0lH}scsX>_J@C=cO~&9$p_}}` zFF`k51pf@(^c372x~VmI9CQuYd=`r|6=%&x$UeHa{Q{AAOdV?QeEWdYq}1%3{?={EQq z=%zgIhtN&w;NPLAeu6K9ZdwZ75V}bRd?s|$4Df8|raW-!rfbks)J^0^p_|Tun?pC* zgKvgz3Ijg{-E;=L3UpI7@XydwO3+h3pqqYzheJ0df-6EdX@EyVHys9l4&C$`ybW{{ z_0&D+rY!Jo&`s1+r=gopfKxYRLQg${Zh8ow0zGvVya9AmQ*dwSCh93Y=q7#ec<81? za6{;(mf#(ro7#cfK{wfhkA!Y=0q+Lg^#A-nE-LJ-VCW`tALu53aBt|Qf9gY;Z;=UJno`>i6_#twiDh8j{cYVC(LAg(Pfp>p<`C?Gj`r`HU0k<`p>s)87+^2eh zKi9P=JDn)^sn_6d_9Y!#sx9}aui%+?7H7`%lKWHmw7jlanIO6x23t&vwx^^cYNR58VU*+~g<8HFN-wB?Zb8^&UFS$>>0dMg_WmXSExi?vWzthrNSnaXA{|NrN zzQ;a|HFBRS0nZxN@bQSQa&LMGK5<>!pLajW`x)S&36Hbf_RD=L0({8w6=pTZ$$e@Z z`0laI&c|!Xy=f15`+-i~uFLxv@G337o;k2U?o&$Ob#|Vpm(@=0O*-I9RM*8MzLNJL z;H@XeD7W7(_o-gshxI<2x9cnSrX=vaRr8OB{gn4{;CnK2oR18Xds8%c>azSvW=G`x z1Mv98uZtX1z4>hy~Unkes6 zz_;b>J&}G&-iLv|RZ)EBQ$y}S1>o*24__NGUfz3yEAOq@$?v$luL1r#=*{6<)#M)Z z3fxLn!^mN{ytfBGHE)>J%NTio7TjiCe5>tW{YHp}}y z;C;XQsi^13dna(?O6GR2+Q|K=E%?dX!7fR2<^37(+hq+x)?JkM_rMn|&o3IKF88KD z@T(c&o0<-i_qV|R?xp{FYysVLZdk=VH37P*1GqwqihJrZ^i()>(>CyT&`mGFwV<1d zp|gUZo92S|fNrABdJf%`4Za+@DG;2x$s2mAK6F!caOx)NEb6A-&{Nb+U7)9IpqqMv zzlCn1o|*yO>Jcs_K~Tkulortjcypqt)-zlEOq4juvBv=@9jbkkJu zZ_rca;9<~BJHb<-o9=)whHhF2z81P^3pjOC0rXTy=qBo^5715J;04f4rQq4nO|QY- zp_@Fw_d+-A10M?AG#)$xx`})jbki~L&&Cz^lp^$0J?JJ~@DM;2CgPW&+yDRr8l|vP~QG$Jlm9N~V z+Ji6u(6&Uqrrf7igQs1%Sw4J%+^4d@9UVI#S$k6MQ%>L)clEM3Q$y}kSHLeDuUq%Z zRqj(a!8cy$G{0Vw+^4pI2YlKxYIt3_PX&P|2i?^_+4FO2){c6O)Sr-H%zw_drRYk#>n z4F?}Ew9UR!CAl|^0Kc!kA@Wk9ynhJZsQjJ%?pbo5Y7X9ifPE+5=5lXx26s%}KguFg z-uDAndG~n3tq{3Sse&&)z2Sqtz1*9YgYVeT`)TA?aSCjiuGw}FEdqU#I%KJp{EhUWJ|@|%lB0rK7$yjiHpn(sH{y%BiK_RU?cY0ACn5O{H(b8d)>y#ECLcQ5_d zV~w^I_tZ}4slL!n2H-cKn?k@(LpL1&w}ftL3;qJSDGB^JbW<9*5_Hoi=&X*=O_ty% zp_@*Ct3x-DcYI68t1|6L~}E zrsm+(O~KGpv!R>F+d(&3g9ku2tpXne-Q)s33c6_wcsg{`Bk+dMO@`nDp_>MQ_keD4 z0sm20aZjm1PX$6ZtpeWz-4qF~0^Otm{uH|DHF#6#Ci1h;O((&ro5G=|ETNk$!1qHp zQBQ4wZrTNY0J@2KYC3e2JGcpSlR0=z=%za0A<#`Lz%N5LT>)(|cp-Gt zTkwa_O;5n5LN~dCPl0Zl0qz0aGz*-1${l)&y2%K7N)Nh82Ye57Qv~=M=qB?2>ZiY- zZ(DQuTbn|;PdR|A)Zb>FUMTk|1@J+~Og~volKa$B@CkaV;ig4$pPCJRp#0rjk2Z3j zN&!C~uq{b{rrf7;!EfB(nRR`r+@}h_-L4JsUGhclQ$FB@S+%B&-YNH~%1M;0* z&)yFdF3WvtJ9yCH%m5`FE%EP_LcqTt?y9KZBloE)M=JJ2BfVFOx8**S4E{ND#7GSz zxljE7Pgvi=&~%C1rxL-n?&t@(K9l=YUGU?+dvuO=miyFs@{BE6b$7^p>OQ!$g-!9M zuX3N741Q{j^}~$^T9ywHN)WBG|PaOtdquM-QdyL$twt{Qw1|Lw+lzWp7_zR~HPt|MkJ`dc` z-{DJx1#+J<1ur_EuhiU3?oH&ymNll=$&>e=z>U)_b<%greX0fc!@WZ+hxM0x({pg` zt`2&EN^);%4DOr|yt3yhdG7|kX@1Q1<8r;#{E3fZ$dG7@7u9s*3RafpuGr^U5SYLYMDeslRziJ)DQCB5L~(Tg&zC6$o;4m_=2kqEtjp3_W|IJIVZzLq{(|H@bObt z?J(4ld(&j_*b_Z$-%gbGhrs{trT=<79=b^pyfJjs&w3SiRycIiOz?%!O`hO)pqs9P zzlUy01%D0Q^bmXwbkk&T1?VR7S!9PJam4UlLH@SdQH?@PFqHa0}Jw@FV20gU| zx@i@7IrNmm|4%*j1-j`cIQ7&y=&1(KO}gM`p_@{`Z$mewfe(Uias@vJ-IN6W8M=x5 zIds!Y@GH8wH&IW$hHfeWkA-eJ2EGxxX$QC- zbW>CC*U(LGz>T1r%)mcFPm#ZeZc?K3P*MV+o3O*XTiF#@)bQATI z9dr}*R1N4R>M81`wa`<}&`tfoA44}i178c>v<-YGbkkn&PS8zVz-9-Lh{q* zsobaX!Ofn%QhW47?o(Fap(`h39qlOhsc>-fPQgCgHp+dfGx)kexi8lh%YAAy_`~uI zd&2t3ed-nXHoqY=k`Ky#YCrhhyq5ZY)#Tpv1U$9htRuQ7<^5yu7wuI1drgu1R3Z5M zv|yvs26As&3f{8p>fk1~dA)Rd-ME-jS%lsEWUkG(S=x08F*E$}ysTzZXqCGWq0 zC%vuWYqwqQQy0N6?0IOqz)9{+x54dd>TOh3kb6^4aHIN0VQDAiy(##M?C%y2rptZm z4Y>J&PaVGN$-T)2eDN#YF;*G!ei^vlt3^HwSIK?K82n-96}E|Xa&JlpPuuIZ?O~a` z&jf#Z#c%GFIJr-en{|Jn>NQsGQ=P%@)x3~+SyS#!kHFh>AK-N0s=V(3?%M12=UV=9 zpYj0DtWh~}MqRldWr5EqYEs?LUEX_uzt*f$S^t{6e+zyy(!2UtJ-Hv<25&pMQe>04 z^4F1X6`BPn}Rp|(sgy# z1$o~X{M7Lvt?e3e4@v@$SE`}wHcsB32Jd|GL!j*;dEXs;%|-1`I^X5}YVc%r=b~>t z<$iP-d_$qbt@QQsek1s{X3uWMWy$*;;33P3wdU%}y=g7@gS5Cr>lyO?A^6|D^k0v2 zp_}G_uYhhE2fhQkX$<%Z=q7*g=g>`=;CrE)7K49;Zps5!g>L!|on;8!)B?OUbQ5_K z=q7S&=q7V;>LzvQDe9()&{Nb+CD2pbp_{_NUqUxgPql|`>IfbN-4p@d5xU71d>eGr z4)7PyP5I!_&`s1+Y0yns;2F?OY2a_5oASXILN^6~n?N_U0{4J!@&vyD-EJ)oQB zflq;MqMoV_-BcU=Fm%&NaO$Z|&{M9^O%uR}LpO~CzYpC+ULU%tF}MzN6ZvuIrZeEj zpqr?tte~50!8bxTk)MNZqMq6U-L#n;x@iM=AaqkO_-*JW^8f0mzn?GtvE^=v>I3or zZ_+KV*aPp~GHI&zQrs^AuauDxroUe9Q|93H0-n9`s9q|*e{1lzz49NG4UqekBe-w7 zv$=WOc|f*u}npK1*rT0Q;oMs2xIMS=&M^6T>RjNGTTfLqpU{A}MuxlcKQ zdu@Mc996x#*lU)7H`^Ah*5stzr_90UJq>uS)lTkHOTdG6r#~(ZmiyEO@T}$Sq7G%t zeJU5c+rB!_hFfZh_uCizLZgNyU)IZg>IS&=fLiKX3*|o56MS^Zi=S2wa-W(EzR2vF zY2H4$PX&X!o!Y)QT%nP8zq7!V@2~1GYrNd2>VxlkGv{UR3v!=I0Jr`+-E3!Vxi|F& z_dfhEYwHDh9{@h+Y*)Yf-g2KB3vN{XSy%%Dxi^`DKV5B+w&kI`&jZg_S{}M`rQD}V z!N=XznDO35?oD3c0V6_opDvO2>%om~Je~hKQtnf2z>V6qHk~q3?o%DW&p1uH*`b!) zn=XP+dg#~7E=AsZfIqcT3SKZz?o+S9tB$Mg^2|i;O|`)DoIO_zdMWSUfuB+6pMGn* z+@~&scdF;6YUM2VCi3}-3zdSD48i+BH}wVI4c)X9 zTpzlr5jb_z4(O>(&`n#x`#?952SPV31@8#m)CN2Nx@ivhdg!J#;5pDuufgr0n|gs? zhHknFZVTOH4?YgM$rXGFbkhoO59lUOa82l@2H;1ao8rOkp_?4Q7eF`710Mz5ZvQxQ`XQ^HsJH1o7RF`K{xdT-wfTf6MPMH(+2Q3=%!=fuFy?0!OftX z$jhLcsHdo#RH3I1KsW6N9{}An1bjMllMnbp=qBnZPw1xE;9a4c9Korlwn0zjLpQw! z?+4xF4BiO3sUi4P=%!oX^PrpNg8yh$aZf2iPmPCeqMo`8-E;$dAav6J@B-*2>Zuyg zP1V7(pqnzmi=mrJ!L6X1I)VRJKmGl@mcG$bt@?7G>I$w~_vDr6`f{IY3Z8Bk^|T;L z?o%rE6}!_d`$HuSjze;vIs#r^b<)cG`EsACU#(&{ z?oimZyt&+`+JTQ$ueYexExAw40uO(@J7&XdxlbJhpT6{NYJWYsPx*uQGM%ts$t}50 z4FmUxetK<>wcMxXfbWTQS~+-=+^6Een?KkQm{%zGsg~feSs$CZ_LTe75%7+^Z%3r< z(H8qo7jQ#`N{U^6$bHHLyhp*S+}PoApK<~p^*PdC=Y-s+CV;oEbkKjhmfWX0fq#0p z<3}?exlbv-uh`vHPEAdGAor;t@Ie#nSR8C9_ongSBa?s3RJbMYr+~k1VKeyA0=Z9p z05|ybV3LWc+?!0mcZ@UBEzgnn5#Y-T!r$6%k^9s-aP{|B+ZQ{^y-5eW>zP(Ps{NGr z1HpA>Ymb;0FZZdY;K>sc*V($sed-o?!J?c}Cmp#rm4Mr9G@Y~Up1gMeA2?O1Oe0wC zQ!e1qrtPc`Sj)ZXD7fmNV2$A)C?Z+>bthC$*k@r2Zm#e*t{qy&kupJe2o=;PLxh@3u9S`%wb8;zGTi z)t1Y91@Jq4dS4x!E$>so=THBpQrklAM+?DqzsD7}4w3iG!Iw3gyKc`5dA|}o^QPZg@MC}oSn!F^P2<4dLpPBdLpQYo-v!+i3LXO8v=+PpbW=U> z?$Aw6;Cj$a&A@L$H{Ae#58d<~+!ng2H~0|frcvO>pqmoFYd|;E2CoU-R3AJTx@kGM z0(4V7a24n#>MV2UrcU64p__(*SAlL)0e=GB^b(x9sRVlJ3Um|o6m`=o=&3~Lrjy`R zpqrGyZ$USugZn`@Edp-}-DC((Jrx2y^$5D@DY!ax6ZKSc=q3a3OVCZ^9if|Sz&}7Y zk>7)EqMmYqZu-}r>H|IX6uOE0C3I6EcvI*mJ@6>#rU-CX=%y*)2ceq|f&W)O{r&v0 zZT7m$4dp)d96WEh^2P>6a-S*!pSXC~`}Jq#KD7tD&yj$*(JkaYH4)r>{g-ETeC0m1 z99*@kX-=CIxlb8@PfBm6G;f96rxt;0=yWU@U?%se`rwXdxBJ*Xk^9t0@GRX=+a?Fg zeJUS((3gfav)jvkYCQP-qaQ0>eIfU$72qX@-j+3Tko(kU@CRmwHc@-zKJ^4V*}17v zjc;!`+B>18UA^Km>$@?YX8!9)Nspup3sW9*d9UitE z)I#n}kHA~3?B?*~nY=dxpME?nZ2cy=PkDh`*N7~0?Jf7FZs6C=I%@T*Ecd3H;I|yo z&KaGM_xHgAchk-r zUdzkv_xV170Vi*wZ#o-fMv0So3nHVi&m|-2yN4 z*t5)dlf3@`p0ulAWW*bJe-XUOecw$}yU6{h68K2%0%gw)@_sbJK( zOPlIi%KgX)eEe*iyN6fE`)S}qzg&Mg_OZMl1@7cMDBqx^+>Zu<4;koM_xoIVKL$K3 z{?wF5SLA&Z_^8{n_ny&|d(dd`dKrxehmDo@y5NdSOyBv%$@{9{T~0Zl8c-_l?Z79` z`Tnwrjoh22fgie@u;OK)ypIR}yO;j!@h9k}VDRcAD(|M#(=+vZh8yu3f(jTd>wRCAov&PruX2~O-P2<5ULpLdb7eF_C1h;{1>I5DH z-9#P$-4qBu6}rg{`~!4T8Mq5{(+F@U=%%6I)J=iVQ`AkN&{Gegn_hyqf^M<^p9$SG z8@wlUlOs5F(;euk8_-SZ;LD(!g21alH`N1Ig>ItG@`G+#3?2a8vWJ-UqsAAoy_TChDnB=%&5k6QG;O>q0j*23Lh{ zQUSMyZn6R&1Kl(cJQ}(w7W}{Z>F?()4cy{hcaZzk3~;}dwg-L9NEJfj&m0$jhFk>a`3NnO`cAwEB7Ylc@_JN z8A@L#-IVw4;BB5<&px(T?o%DXw;%Uf-rYj(O<~}tC$7j)FO>I}z*U#_4*RiJ?o+kF z+kIKIPi45=r!2v{zBW0mS5xjy-NF4A7zcJpk@o@Mp5-gPnEA3dGcNr{9K)*yYJY_{pce2Y%lvmXST|F z@_<~MyShd4p8W2XI_U*HLE%ei^#yBDghllP&la=%(A?fzVAs;D?}_j)J#=ZZZX53*EFCJR7>{DR?L7 zCR^~%&`s1+YS2w}z}rAKwE*7$-9$bCy2%y1A9Pb6@K4Z9U%-Q)n*zbVK~E_{PkBH$ zd4gL)H&IW8LN~>LpM`F^0`x~U5|b(16X)I8{>W#H6PKG0MBp_|;mCqp+; zPfdkxatAknZfXJE4Z5i>czft38*u8T-q2G%&`s1+)J?UZr!GS`rGR_?V^1xFo(cj_ zg>Isra)55?3;wS?6$ah38@vW|lPdTS=%%6IZqQBS*P)wI!P`SOnStMcZn_8F1G=dX zxGi*35AYe#P2{Q2O&Q>Ap_@#=CqPe)1&@MmIsje--Sh$czxwI#=bwH05oX#=?o(gD zZGK!fN$w{1srKLp^a>g-&6E372KbIWn~!|%A@`{`@Om4nFTb{3?o;~US+QLUKfjmz z)JO2=wgFEkhRc2G6ZqF&2ZNIO$$jc4cv%zw5~Ck-pHkGT*zM!Yr(cMZ`;-&-&F_a_ zMU9mER2H~Ga`@zVRcnd8MipE?HpcV$7`aci08g7%U0Ewp?o*Gzw*?zDXrd+esh!|+ zJ;Ii%d&qri9(c>nX=N{NX^Z#U8oYSN*r%~A@TeaagA$j$OE`fubu zMQ#;)@@KZA+^0H$XBN)?xO2bUr*gr^c|1Bdyk=wZ`FN0fm8Pt)lzY=W@ar`~hQBJ1 z_i5m7Cj?}i36uL&8MyX%m!+x$JYs#dl{TDZq`liO>@8pj*Pc4 z`YP{Tzz2tnsXgeh+^1Z?6IA0TZJi|dsk7jXojz82)kyA5O~LmTkBn}0U*1Q9KiMDJ zVdQeTPdx??F_;)Ori+ayQ1E>N?{_eEko!>tc%tv| z1sAu=`%BZwTRDe9(<&{Nb+~vxv<2J_x~U5|_0&V?six3PO~7-Zo3g>T zLpSXL&w*}w3I1RG^y~SeF8_PC?SH;b{eO=u_P_71!TtaG?|ZZV`MNLe|McJYzg|zK zxc}3C-~W2O+2a0B|9$`K_stRafBNtH$&>!yuUF#!Pyc=Y>viUf`#=5n{muXRdMob# z^xyZt-q+uc|M#c%zy80!R;sl9e}3a)@%{hw-}k>hhY#ZZPyc;?>wjM8M{)nB|GxkA zxs{3gKmGUpuXpxY-2dsn?|*&HU&Q^N{`>yd`}!vC|McJYzkV*?#r>cD`~H9a_)IDn z_ka5D`~UlswEe%o{{74U_22iuKIcl}{!jmX|Lf;oS=|5Wzwdv&&MM;mPyc=Y>vK~O z_ka5D`%3@wr6}(I^xyZt-j}@p(|_OpdS6Q7`~T^`?|=O{tSavR^xyaG|L2WW6Ze1m z@B3fxOIh6i>A&xP{kf9&fBNtHUw_V3#P|Qxf8YQ5IjV~LKmGUpub-ouxc}3C-~W1F z>f-)S|9$`KeaZX(!`{2(SgvGSk`C)v)-UUqRdWfO_8USC;SC{s0YuAzYE;A(6A1R= z3HSuqiQ^Os_2^brs`(<#Z(N?wJpK=l_Ak$;uK)7zFVANl|Hp@ac|LXhPY?g{eAd;| zzdWCH{`4=;r=S1xqd%ADGj31+@_g$0UmopWp3gWx{mb*2_osh(KI`y*ee~z@eC~^< ze|bK2{ntnPm*-R0)4x2Qd3^ep=Tq1J_UO;$`OM?fzdWD1{`W`wm*=x?pZ?|f)b;c) z&u88KACLZAo=;s*|MGn5`ad7-U!KoAKK;w{S+`IB@_gp;|9bT2@_g3q)4x2Qy8hdv z{mb*I>*-&f&pbZ;%k!!0|90h2tUH{Lc{mb?J-;%~Q57&!-2Qr#vtB*zesuwLG7FVDr@9|8{vk{og!g|K<7I zN1Lbq{IbZU8_LSZ0u^VxqkPr3f(`ONR;Dd$(7&-`wla(?Cc^my}; z=j9$-uYBv3=QF>Xr<`ATKJ{*%vR-*U^SF7+`IYC> zpZ;$?vj6gY##3JVm*-<_-toNLW5-!u`^<|xpLH(JzdWDyx%tTTDbMGAk=Op^`52pb zJTLdydgZlGz4CnKQJ#N!KJ{)svR-*U^C++V%kwcd?|5GBvFll0`>bbqK6T0SFVAN^ zZ$5H8%k!yAUi+8lV{G2>yxe2wS6=(fuRNc1E6=|?pZVQ<S-0}qzdRpf^N#1` z9$T-x_NiB%&pgWWFVCmm%}3TN&u1RxwSRd&#^x!{%RRQeKYivi&YP!x{knX8b5q}g zFVAOuHc$Qfb$LGRn47kJc|L}@DgW|(zIXGK{gLOh4{VQ8DJRf88k=M!dsY|YBz4CnOGB@R4 zp3i-4Zpyzr|K_Ir%kweJLHU>Gv#y^0<@v00b5reKp3gj*oANKuXCBQ>`IqNon1k{! z&!?`Ze|bLhXl|F4I7 zU%xKTXWX9t<@xkr^N#(J=QGZ7J@-R-KJzZmzdWCHxcSKaT%ON;A+P<*^D#E>c%3|- zdgXf7E6-;h<@uNAQ}5;@>y_s-kMi2TJRf88j@QZaSp8#jeAcZz|MGn1ck_|+E6-=$%4`4fe2mRIUMJ6|Ub&w2 z%JZ2=dH&`3)Vuk}dgb}dqrCPn&&Mz~Icr=RkC_J_?=K8KO#)Bnv=j*mQ_`)Ko&&uQiP^w{J2 zf4S#@JF_t?7R`Rvc~eCpjiWxewJ zo11F?@_c^2zwf7*cXL+b!w7CZ^1R$*?<0BR&wVG)XMQ(NIluCJ*7N2m*RwpI`Q1F_ z^Kf}SJ>IrI}|I+y2Po_}*w{^j|M=jJKLQ=U(Yn|C}f_thOb3tDFm*-<_-toNLW9yaIKK07;nMZm4<@waR`N(?Z`OL4p z_Ak%J*u3L;xyP<&dF`{F<@wYl&%ZpMb-Ve<`%#`xUGmz$JRf88j_2hbJHPVUXMW}R ztXp~h<@wC-<|F4}0UU@$AD6jp? z^D#D0d0y_Z?fvO9pK;zi^}e5S1lb47O;Vq?$ag%=P5F$oJfHi>+?0QLKE@t|6|n44<* z@_hRF_4B>?m*=w|nw#=3&&Mza=e)@CS?BWn%k$Z1HXpg4%k#NkfL-~z4CnKQC|C(=VNT%@j7`v>shYndY0!?mpuRS zeAeyeBllZ*K6S}!|MGl{%{yKv&u4z+dd{yrpLHwGzdWD$-F)Qy%JW&b^4h;VA7k^5 z*U9s#SFUHh@_gn|o_~2h^=>}0UU@$AD6jp?^D)d#`Iqbax!!V*eQ&aPYWe#A@BI6E zeR)3P<9jIkW!{wMGw=WTZ`zmV)1vR8YX9-eb5s81`P@gF zr+iK;&!yeDjq1vpk>q-QV|fe&zYh zukWGi&*k|TzE{e>JfFIr{^j}1uequAFVCl5b5s81`OM?yDW8YS^J#JOj_2hbyRPK* zhjl2==kFo%{LAy{|K=n6FVAP(o@t5Z_@ACZ1^I3WAl#Zy_6&^~&>^M|u9``P94l$a>}Z%%i;aFVDx=Jmq=0$F}#U&wR#t z^VIu($`QP|N$T?!bJmXM<|)Thp3i+`ZmRvu^D*|=>*RjE@24CY*7@cspL=YcTHbgv zFXkp&_usq8^Vw(2P5GDS{}|ty=TAR8pM7cb)cbzQQDa{c%3|-dgXf7 zE6-;h<@uNAQ}5;@>y_s-kMi2TJRf88j@QZaZ*J0aJwJWwlILGu`=9fa>)G6tPhIlb zzdRpf^N!ca^O;|{p7SfuXWh#4FVAOwHy=5_@_g2pm z{^j|f^OW|?y>7xUi&v^@_c^2Z=UjbsXU(+%}up`c|Pmy>0h4DI)C3! zG4GqFe2%(#YI)=NIZrvio2Q)5%{$9$pLO;0FVAQFKmE(|Kj$g?Z*IzG+~oG#`$e9Q zv3bYqeH|0~8y!J28$Jo5% zb@F`XSFY#$%JW&b^8Cy5ncvMv&aXV5bt|v^%kwcd?|7X&pL*qb)+^6v9_9I$=TqeR)3PV{Xd7JfC?tH|1ZRk6~`g zzdWDsH8d)o*%$K<-|MGnHpUqP~=aJ|C zwD@hye0qNK(Y}ZBs^wnqyqlZy*?;8u^#AKylTZ6E&u82=Pq}{N`Lt&a@>@JF_t?7R z`K&j2K6RO!@-NS49d4fTxvME(qr+i-^&u2V0 zPdT3Qe0pGRsy~Og)vQvw>r}pU^4h;VA7k^5*U9slU%8(1E6-=$%JVPJXMQ&y zIluCJ)~&quFVDx=yyJE9eCn0!S+6{wd6eg0o=?4-kE~ao&pgU&|MGkcb5s81`hKpr z++&|xnwz|C`TFLj_2v1DkGU!T@_gpq+?0QLK8Cp||MGmk*W8qUc|QAtxhenheEMl_ z%D+6H`^emse|bKJ$N86g-sg>*r$&&Sxj<9WHq)+?`l>Xqj+kMjJ>^Qm|9k@d>+nMZl;U!IS# zdB^i|k6q95+Gjn>^QlXoe|i4rJmq>eH|0~8y!J28$Jo5%dAY~Vue|n|UwJ<3R-S)( zKJ&Zz$oZA$vu@?Je|bK}<{i(=J+@wX?NhHjpLvw$U!G6Bn~$tlp3gkWYya|mjLlP? zmwRk`fBMX4oHtMTK1II1xvB4=9eF;s#peBL6@r~jL$?7uvp`)Ko&&tv8JRJO;~EBDjqikqjF=QBQ=ryL)7KKI4usrUVq zGr~UO@AXN2o+EEOe~j~ljl>HxvBOq&;OjKd>+1e%Jw$zEU*2WoAmtoVmtY)b9w&d`JeNY{Wmw|GoJF= zzdRpf^N!ca^BHHkp8KIZpYH(&&Sxj<8|_U>XqwRuRNc5 zl;>ZbPraLutXH1TJj!eT@_dZVJ6}0UU@$AD6jp?^D)d#`Iqbax!!V*eQs%P^19{go14~`=QBR$ru@tEnRjzj{^j`? z=BE71^Z8zLQ~u@opYxQ@VKz@WZsw-ir~mTW=RPtw%JW&Do2R_r<@x-4_xJkh&*k|TzE{e> zJfD5w>0h4DKJ&hxV%|4Txo$U4EpI%TM{`s2b$LF<<{i(=J$7BmYoB!}&*#3D=U<*r zKQ|xwJYSyAxXEk(@_dZVJD!(&>^RG7pM6H2&pMaqU!KqYv-!yVN1o69BCq|+^D#E> zcwX+Y^~!6Xdgb}dqdfoeeCpkNWWDly=22ezm*-<_-toNLW7o61_F2#JeCm?tU!Ko; z-hAYGmgiHKy!J28$Jo5%dAY~Vue|n|UwJ<3R-S)(KJ&Zz$oZA$vu@?Je|bK}<{i(= zJ+@wX?NhHjpLvw$U!G6Bn~$tlp3gkWYya|mjLlP?mwRk`fBMX4oHtMTK1II1xvB4= z9eF;vW|+x2;iJfHrXoANKu=RVpz zx@zZTZ!Dd*kX)OfQ0$Qw`g$*=EB{&aah>&M*GRhQ>uY(DZjc|Pk(uIKwuc|LWS zoANKuXMLKR@-NTl=lkXX>s$B-y_dwe~|0BKgjc0|C^`WKjrz%qwk?=|MGn1 z(f3gKm*->nUMc_beCmDrm*+E&=BC=eJfFHYPx*XRo_}*w?O&dcv3bYqCxt{x> zJfHP1&%ZpMer`T;eaiD0H+k(}o{zD4$Lr+zjK5sZ@t5Z_@ACZ1^I3*V>YXSts1S)NZ_ z^8Cy5SXO&~<@p$!cf3xX&-}{uoL_l9>sFqBc|P;I`N;W|=d*6*wSRd& z#^xQbljl>fT+e#t`OKp{|MGn5-F#%d@_gn|Ui+8lW0;%rFW2{Tz2zSJKE>SRb<5W` zH?1$vXMD^}`IqN2@8+ib%kweJP5GDS^S$P#{LAy%AIwepm*>;Z%~Ou2JfHi>+*JFQ z=VN%Bf4S#<4!?P7c|PM{ZmRvu^SLiJPx-z;p3k_Mn`-~^e2mRgo|k*o=;ux zzn^0N**xX*sIPBliqGXco|~t9z9i45J#&!X;(58pt}A&y>rkFgU7M#||MGm+;pQoy zyUO$V`EG8iKbPlYn1k{!&u1Ta`j_Xk|CpO<|MGl(K5m|Je&zYxFPo>FUwJ+~*nH%9 zxySzZ4CVEodgb}d@8&7zSDsJ3=BC=eJfC@d-%l~l=B&nt5!}4vdAY}~EBTJUJfC@& z=U<-B`rLfv`jqE$U&w3!@_dZVJD!(&Y`yZ@XT8bu*~jGhm*-RO<|FHs=QEG;+P^#> zWAl#Z^8Cy5Kj*3U{S+hT-*YxkEpI%zZu5@k1DmIO-XhPZ|K=w9VgKd%{9M>P<@0BGJ}vIC z-y`?a_Ys??mgh4*o2MKfc|P}rxygR`zCfOTb5s81`55M={LAwh|KIQXslOK1`+kaj z)!fwjxxDqmIy5)sU!H$+Q~u@o7@Lp0PM**HAlGw$kms}hH&40$$n*I*Xl|-PD+>GFK)dis~=(}U;xqs#M|-=}|hKI``BU!KqWZa#8;<@u~zdEFEYD{i<@uNAQ}5;@>y_s-kMi2TJRif{lz+LtpX)96*xYJv^19{go14~` z=QBR$ru@tEnRjzj{^j`?=BE71^Z8zLQ~u@o><{Lq{LAy{r@1Nr@_g{%JVPJXB}=n^7*zrpP$R}+P^#>WAl#Z zp<@vO@dB^i|kDXt6{b7FP`K()c{^j}1@8%=tSDw$hmDm2|`52pbJTLdy zdgZlGz4CnKQJ#N!KJ{)svR-*U^DD3Y%kwcdPkCPMvF-ioGoNwZJmvFD`TFLjzK3?? z`HauzDf6a0pLRA+*&lg6J=i>DzvTJ!XY-W(k>}ssWV=3ZF=yq||IJhOU!Ko>w0X+s z&+>eFu*ddG?&rRT(p#R-_-vkXeB}Au7n`Tv_fw8E`;56s>hm0Vb%iNTIdH&}- z<^8^S%J&qTr~He? z%k!ys^O5z+^O;9^?O&dcv3bYqA8PCed?0uUtaq+H|1ZRPhIAw{LAw(Ht%?y zJfHcM>p8#jeAcZz|MGn1ck_|+E6-=$%4`4fe2mRIUMJ6|Ub&w2%JZ2=dH&`3)Vuk} zdgb}dqrCPn&&Mz~d>0e|bLhZf?rIJRif{lz(|X z-)nBlzdZkQp7J@&<|)U`+*JGYUtas%N9Lyd%kwcj&cEFAK8JbVPci<#e|`_J@nPQI ze?P_kW6o-P*gwC%U1_ef%kvq}%~L*KlIPQ&ImmDEyximW-%mOI><{Lw#)oyjdCGlB zp3gjPp7J@QJfHdXJyi2`c|L~kq4F=!r>>`ec|PlQf8Wo2Po7V`=BD~{c|Lzn^Y{Al zFVDw#zCXG=pPw&J|MGnP9`f`r&!?Z8kNo#0@_fcqUcHy+V{G2>yxe2gmAv*De|bLh zF3-O_pLMwT$o)s2&;25={mb()Ht%>|?y>dCYoB`M`OKp{|MGn5-F#%d@_gn|Ui+8l zV{G2>yxe2|UL>#mo3rw%>*-&fe{)mqU!G50o2T3#@i$o2Sg1@_gFaJmvcxc|JYZJY~P+`SfS= zl>L$Cf6h}rZ`nL$Kg~_{V|nd!A8np`-%mAi|N7JW@27sogFk*E1H{rR@py4`1vSry|I68o^t<`=hNcmBfm$U&weP^b3c^l^K;YOlz(|X zb#0!qUU~k_O|^e{KE~!9uaoEB+@$Bvm#5D-p(ZmpuRS+P}Fe|MGn5GB@R4o{zD4$Lr+z%&%O} z`IYChZsqxx=QF>XkDOn5KI>Lq`d>0e|bLhZf?rIJRif{lz(|X-)nBl zzdZkQp7J@&<|)T*^VIU%=RVpz<-a44=hI`4>;L7R_c_e_ev0+;`+Yz4*Fg9ls`bPE zBX9k%e|~*y^67Ibc|P}%@1eZP=S%W@40BNa<@xNxPyh0K>e@WzeId{1e)sqK>d)o* z{2brk_w)I`Jf9YQuT=Y&=d(XN{mb)N=jNu`zdWD$H8|?y>dCYoGNd&u1T#=U<*ry_=7$SDw#2%4`4fe2mRIo|k*< z-;3n6e{)tobv^yd^KWjd{mb*IYx9)*gFK%WH}7~}?y>VLuRqMMJfC$d&%ZpM`Q3cv z{L1rLxANM*JRf88j_2hbTd%zKsaKxQJj(Mg&!^taN7gIPXMW|ie|bK}<|)t1J+{3+ zedaUHo2PuAB46L!)c4SiJfHE|JZ0XL=hM#SDf=VOrw5y-?3X;B{%oGIKl1#~dCKQ4 zo2TsO=Beei&wXTWvfnt*Q~u@opYxQ@|2I$B-sYp_ zwa>bG`j_Xke{P;~|B>hOb8z#N>rS+6|*bDna3%~|>M;Q9XO@_g3S)4x2Qb^i1(&!_+9pvLF&e8%nRU!G5kn|J&k zc|PMW*K_>k`K$+d{^j|s&&@}!PkBD~i@f$P&&Sxj<8|_U>XqwRuRNc5l;>ZbPraLu ztXH1TJj!eT@_dZVJ6=Tq0yzdWB7H}Cj8@_go3 zuIK#9^I5m@{LAy1-_1wPuRNc1E3f^_^D#E>c%3|-dgXf7E6-;h<@uNAQ}5;@>y_s- zkMi2TJRif{lz+LtpX)96*!L#pCa+t*zPV|Ac|PM~ZpyzrpLsVoVQ_J%ihs{$yACTvBUu>T8 z-?_;18MpVp@5jDm&T4#qX7t;cz4K~r%4huLUgh}9^Vw&750!s;KK=aq*5uRYRPub* zkME(p%Jn19$1n%wU!G6BPyh0K>e@Wz`j_XkKHv9K%=_jk=h58Md@=9x#uLLFlz(|X z``**PJfHd9Jmvh#^Qp_+RDUkd=kICeru@tEF*fgbUhc8a^X0YAI+W+L&gJ=+=hM&4 zN4`Im=QE!2+P^#>WAl#ZHAJfC@#*Z$@C7@K!IFZbB>EU$gmvpk==c7EmchxwJ~vu@@2m*+FTn~$7dc|Pk_Ui+8lV{G2>yxe2! zmDfJ?%JZ2=dH&`3)Vuk}dgb}due|mz&&Sw2<$1Zsw)dyce8ze6l+QEe>zkYU9@>%T zGd`QA%$xFj+Sxp1f8_b}VDpsylIPQ(%~SSAp3gq8dCKQ4@_hPlZn7WtU!Ko>w0X+s zvGROc++)8-?&rRT(p#R-_?VmWFVE+`FgN92p3iu0o^m|p`Ly`{`>CIi{pPdrVVuoP zKh{4#F3)G5**xWXkms{cetp+6f4V%Mbz*Mns>|~+HXnJNJfFJcde$q?r(SbY{^j|s z&&^Y=PkBB+$9)e~`XPfZAIkHYM{`sD<@waLdCKRj@_goT^VIu(s*(QJpEmD!R^E6r{&GFXU!Ko; zkmp~X&pOshZnpZ!gqe|bLjZa%VJc|P}ry!J28 z$Jo5%b@Ke1oAlg2pFVZT^DnRco15}4&!;YPQ~u@o7@K#zPM**F%JrOIc|Pk_o_~2h z^Sk-T`IYChZsoOqc|OMG9j}w;Q?Fdldgb}dqdfoeeCpkNWWDly=22ezm*-=coANK$ z_jA4F9{b+J+~jr3*EctKwNL-$wa$G&%y=d(Y{^Qmj|l=p=^|8t)5e&0OhbN0h2t zU7L42FZbAWCExLv=QHo}{LAxMpPP?dpYnX}7kTYpo{zD4$MbTJtyfUi++Pc|LW?^Doc8xhenheCpaf<^CYgr^U@X zo|k*<{L1SO^DED1-OBSX&u4x&A34ABeAcbJ_Ak%J*u3L;xyRNkuYKy3=QEG;{LAyH zck_|;%JZ3DdF@}GkFj~m^Ky@E?@yokjPvFx->1meH#hY?v?I@Fd^S&+H|6=Xvw6z? z$n)vJ<|+Fn&!<0|r|geBpMAjGWV=3Zk>}HYb5s81`P@gFr+gkO&!@#b_Iu=h`rcvl z)bf1B=Y2oLIGD2G>4)dDFTL-l7>CVMu5)u! zW66FiZ#=o*%}x22=ks%X^OWx|*V>YE4iLO zU*!3$b9w&d`Sf%1k?T{Q&$!8J|MGl{%{yKv&u9GQdXB$5pY*V>=E7!ALc|P+f&%ZpMdN&_guRNc5l-K^{`55M={LA(ITyMF@KDRVCdEN5$ z%}wje^BEs=Q~u@o%)7ZM|MGkcb5s81`FyXrDgW|(_6KuQ{^j}fbMutrDbMFVGB?%! z<@p#M=U?u5pTlgPTAt51Y@YJ@fIOf3Vt?Py_XzTQ#?9aBtN)khW9;wyd0y_ZZS1r$HpYc6Z{^j}f z|La?mPx~*=XWV=b+*c&ar4yse#&{_bMublC->NWL%!oL z&u3qi=U<-B{Z#4KKqzF|MGn5-F#%d@_hC^ zdF@}GkFj~j^Ky^fC*`%zzADeBE_wdt`8PM^U!G50o2T3#DzvTJ! zXY-W(k>|4yY@YIYi#(tHo15&1{g>x+A8nrUd8|C27Wdfik^AZM`OQs|=&pI?W)&AxAH#g;9o{wQ}%D+6H_4f2H&u9I=@28k|b5`TSy4^hG^Hq61 z^SF7+_dD`@=JEOd=<$%?K`OKp{|MGn5-F#%d@_gn| zUi+8lV{G2>I(a_pR<7sYm*n}>CC|S+pLJ^v%D+6Hx}N^!`Lwus$M2EnGrw{@=U1N3 zx|Qc&p3nSlK5~BL`K)Jo?O&dcv3bYqHAJfC@#*Z$@C z80Mz@%k}+SZ@I@lxBrj%`{(lY%}sufzC54tF*oI3p3l6SoANKu$1peLU!KqRnw#=3 z&u4!yH|1ZRPe08~`IqN&ADNr-FVDyDIRA3b`y6KT)bf1B!Q52)m*;a|Y@YJ{h&-Qh zd*4s7FPXC%pPv!`cI5f={N^LaS?*QKz212@H|4Yc$n)vv*S990KBtoBvraZo`Fu&9 zPkZJdzs2)%kF86d&pMRnQpm{^j}1uemAz@_dZVJD!(&?7EWIKI>4P&pMaqU!G4tHy`dC z>kswH^O;9^{^j}9wfV^XR-Vs1%4`4fe2mRIo|k*sg*pUGn_P^I6ZEk6h34 zeCm?d{^j`?n|C}f_t^QB*FN(r&u87r^Dob5em5UEzw&(6t-SUx&&Sxj<9WHq)+?`l z>Xqj+kMjJ>^Qm|9k@d>+nMZl;U!IS#dCK#0k8STypZSdQ<|&`g$k#VF^*yvB&u4r# zPnkF6`Lwfn%Kpgn>A~hH`z6n(KbxoQk364!VDpsETjcrlfAf_6m*;aIZJzRdhdiIk z_Skyme)=4K^VITu#%J@C<0H@KzA!i058oHa^BK?0Q;w%RpBCTuQ$Hj7&1d7o_-~$a z{N?%VGv=nBR{!~Nc|QB(*LNm=x;&rtV{YoI%kweJLHU>GQ}5HiJfFHYPg$=#pY>^O zsy~*V>2zg*Apm*=z2<@uNA zv(Ick^5>U4pZi5#`^1R$*|J{(h_E~T8eD;~mQ{ETyeCBumdlb&EJfHdXJyiXU#Q@=QEGyruuVvKJ}WL@-NS49^dyZbPraLutXH1TJj!eT@_dZVJD!(& z>^>>4efCv(K6T0SFVFv+r{4EdjGX)Y=Bee4C)aJ>@x0t)*R#C&Vm-_AnMZm4<@v1V z%}1_hc|Pk_Ui+8lV{D%Cyxe2k`_pGW`^M%e->1meH#hY?v?I@Fd^S&+H|6=X^Pltg zVf!P`rw5y-?3X;B{%oGIKk|I`fz4AsZ;|KI|IJhOU!Kp;h0Rm%`zdFTPjl0yzkbOZ zPsacEzga)>eAdI}Dc6HMpZVH6<$THW*=IIS`8-FS|5M@jR(g3p`_ksA_x+UP$G*CG z>U}@u_^>|BO;XpVy!FQYvU$q;MV?QKn~(e+c|P}-T+jPUp3nSlo^pQW`P934%6jGb zpYxQ@!_8Uw^!WMy=<s$8-y_dw{N;L% zzdZluru@tES)ZGaT%YoMeqP9H|MGl{%{yKv&!=9wp7qM}nMZm4<@waR`N(?Z`OKrd z_Ak%J*u3L)^8A~d^!)qM)2A+Z{^hm*IZt^%`W`Buy5zNgc|OMT{n6$5%XPfZp5^(>qdfoeeCpkNWWDly=22ezm*-=c zoANK$_jA4F9-CYLWB&fRe0_71-=i{_8c)`Pyzykd z%uV^1=d=HqoANKu|1rKb`SiTG$z$Kk$h~TLKKso3eu{B0XEi?D@4km>JTK4Z=llD9 ziu+~rl;dO$YCQRqT+e+^p3nUy&u1RZP5GDSbKjYp@-NS4e$7q!m*-<_-toNLV}Fjw zYoGNd&*$$U^8Cy5>F4GnpXbZ-88>sg*pUGn_P^I6ZEk6h34eCm?d{^j`?n|C}f_t^QB*FN(r&u87r^Dob5em5UEzw&(6 zt-SUx&&Sxj<9WHq)+?`l>Xqj+kMjJ>^Qm|9k@d>+nMZl;U!IS#dCK#0k8STypZSdQ z<|*H&$k#VF^*yvB&u4r#PnkF6`Lwfn%Kpgn>A~hH`z6n(KbxoQk364!z}#fJK5vod z(|>bQ{^j}HN9Lyd%kwez*z4qe`kZ$2)bf1B=O2@=9Upl<_r?CcpYKQH`HbiOzMtbM z&!;lqLs_Sv@_fem_oM%p=Ton_$#$(*p3l5&p7Qy*JfD4L^OVnX&xZ&jHkcXmw$Oa#{T}E*U9s#SFUHh@_gzwH|1ZR z&-&av<@%K8^YeZ4l+R1$`Sifw)2lz1=d<3P{^j|sbAPX|_Ak$89(@m$e|bLhXl}~C zJRidxlz(|Xbv^yd^O?uZQ?6%uK6P!L@_v-(-`rIHFVDx=yyJE9eAb&>&-EtHXZ_3b zFVCl+n~z+d@_fcqUi+8lV{G2>I(a_hFV}PY<@wCJJpb~1*5T$O_j7qZ_l3OnFVDx= zyyJE9eCn0!S+6{wd6eg0o=?4-kE~ao&pgU&|MGl{%{yKv&u2Z$^<2;LeCm?tU!Ko; z-hAYGmgiHKy!J28$Jo5%b@F`XSFY#$%JW&b^8Cy5ncvMv&aXV5bt|v^%kwcd?|7X& zpL*qb)+^6v9_9I$=TqeR)3P zV{Xd7JfC?tH|1ZRk6~`gzdWDsH8IRrw1O_ zpUXY}zMpbjm=|+a_6tF{LAxyjBiaoJ-_*A-$QxTa<6wi zn49w1f8_b}^XpraPoGoC^BK3zQ$Amk=hL1!$Zzqy++*vK=d(Y{^Qmj|l;a@J=e{;K z)&AxA{Cqbzyxe2!mDfJ&O`gv_CeOb-pL#bRS+6{wd6d`w<@p$! zcRVlm_}Hc%~SSEo=<-^PuU-N{>@Fc>+=?KRzCeVH|1ZR&wXTW%D+4xV~@Q~?x)Xb z-}h6D|L>poR*etqVe^#hL7vaNY@T}GPq_jaPji#h@su~780Mh-%k$ZXpZ?|f?5pOc z+P^&i=BE71^KWj-zdRqq9F%`~KI`r2U!Ko8H#gP(<@x*^G&kj6p3nT6oANKu$1n%w zU!G50Pyh0K=5h0s`<^_Xx;9Vwd{v(RIZydK+?0h4Dx_!QHx;&q{ zp8nsDU-m*-=cgYqxWr{1T3c|P;_ z^e@k+-pxnWE6-;h<@Nvad<=6_{^k09uD9G{pIe%nyl(mW=BD-K`HYXbDgW|(=H1+s ze|bKJxhenhe7@J*lz(|X`+&JA|MGnLxp~U*l;?9FZJzQutvsI|cwB!j_q@;HH%~3k zXB_@9zc1(W0eL?6g}>KVe=g5w-2A=1{LAw({Jp;X%kvq3b5s81`P6G}%D+6H`Pw|? ze980KXWsWyjOXSl$7%D?a*yBlQ>;+en>nlTVV!TDa{rO%vpzRZ`5aQ7&pd9Pa(|HL z)8EZUo|k)UUGnZn?mKxtKR3-y`IqNYuemAz@_hcDW^T&AJRf88j_2hb`#fJ>`|OAE zeD+m&{^j}fbMuk^-b9|yxXEk(@_dZVJD!(&?7EWIKI1RXXWr%cm*=xSHy^n^<@ww% z^4h;VA7k^5=j9$-ue|oDSDw#2%JVPJr{2v+)+^6v9_6)vc|OMG9nZ@>c0J2$pY<%y zr!IN^<@q-^S-0}q zzdRpf^N#1`9$T-x_NiB%&pgWWFVCmm%}3TN&u4z+wSRd&#^x!{%RRQeKYivi&YP!v zA0%Jj+|>8bjy#|7**s<5l;_jV<|+Fl&!-2Qr|g$JpZ;u~vOn^C_JPe)@B1l7nEPV$ zl>eSZzT>%h%JG!v^F5oV{C0Uh>*x36LD!EwpY^bL%Jm@6XWuh7*^l@Alq11-nwzAK zr@ZmR*gWNR@_g2tT+j6;&u3qK-%oL0Y@YHts=2B0p8#jeAcZz|MGn1ck_|+E6-=$ z%4`4fe2mRIUMJ6|Ub&w2%JZ2=dH&`3)Vuk}dgb}dqrCPn&&Mz~iB^I7Ne{LAy%XEqvOF*fgbUhc7fFOt{(%~|=>_4F^#zqzUQFVCm0%~S3V@_bs{yyJPf z$Ih?3{xHAteAcZz|MGn1ck_|+E6-=$%4`4fe2mRIo|k)Uz4F?pUU@$AD9^to==N=?Dxq1^ts~Zspa{M z&p##)IzIAz?hD^T*$>|r$nzOb-$UhJo{!;ssQke|bLhWp2v9 zJfD4L^OVnXe%JE((+|&Q{Qd7#vr>$_oKY^!{5{P_x*goBhP2u?(gHduI2gcdvZO0 zzR2@g=kol^^KWj-zdWD&W%HCjFXZ{OxOvC#k>@l1ay`dip3lB2&%ZpMeP;8KKfmPp z+!ylNzdRpf^N!ca^Ql*^XT9=#=24!1c|P@SKC)hUKJzQD{mb()Ht%?yJfHO}*K<9~ z^QlXoe|i4RP5GDSQ}0UU@$AD6jp?^D)d#`Iqbax!!V*eXnG0^19{g zo14~`=QBR$ru@tEnRjzj{^j`?=BE71^Z8zLQ~u@o><{Lq{LAy{=jJKLQ=ZR#WNxbc z%kwcj&cEFAK8M*nwLG73FgMly<@wwf=BE71^BK3zQ$E*{=hNcmDbLG2cAPg)EzhT} z%~L)Pk>@ino2TCQQ?5V8bMutrDQ`TvZu61ny_6&^~&>^M|u9` z`P94l$a>}Z%%i;aFVDx=Jmq=0$F}#U&wR#t^OWyX^YeZGd+ENvkms|4%|W}K<@xLn z^8Cy5S^vI=%D+6HpM(B8sr<|H*+1WZKgGP8vl<^paPyAiD$l>UNze86^!a;;Jpc0A zzqu*@@_g=#%~S9DsYdQ!f7-m`S$X5heI(cOdA>ZKd6eg0p3nWb`N+S|$n%+BdF@}G zkFj~j>*V=2H|e>apFVZT^DnP`*6rpa_gi^Bb;)c0@_dZVJ6z1!?ZdzZS&-j>|@-NS4-px(JTK2@zTWp!?5khj zyY3h_-$U(q${SA%-$UhJp3gq~^e@k6Uo|(?{^j|f^OX1d<|&_xnwx5$pZoIK$Jl)2 zdAY~#1M=Eu9m?}r=bNY8f8_bh@OM-jDKp?hASCU!IS#dB^i|kKHHbwSRL~K6O3) z%kw|yDfeM>Q$BUc>(Ax+7@K!IFZbB_mDfJ=E6-=$%JVPJXMQ&yIluCJ)~&quFVDx= zyyJPf$JQ&aed?9xGmrB8%k!ys^O5z+^O;9^?O&dcv3bh#a*u8APoMdW^X4hv2g%nr zH}yTVBhP1iHcy#1<@vO;dCLCC^Xb9nDf=bQr$3vg?2kPEbDr{f%jPNjxp``N?Q+R`Zp3i;#^e@k+pPP?dxAJ_( zQ(nE7=VNT%@j7`v<1g29{N?$~yFCB$eAeOSBY(cj^SLkNwSRd&#^xQbljl>fT+e#t z`OKp{|MGn5-F#%d@_gn|Ui+8lV{G2>I(a_pR<7s%DbJ@adH&`3tmn-~u4j2Zb;)c0 z@_dZVJ6WAl#J$@8gKu4ldSeCAP} ze|bLjZa%VJc|P+ful>vOG0aW*m+Skv-g1w9ZfS1vy5;Meo7R`-Gd|{~{LAy1cXLzz z<@p%qru@tE`CfBV{^j}X59X%)%k$~y<|)Thp3i->dCKRs@_c&Was9d6^FCL6-%l|w zzkhxYu<>Eu-}h7OKjy5)hyC;G+m+@zyF8!q^gWbU`Fu&9kMVrpba_7e@YBCMpSsLV z_2=?@?rU>X{^j}neBV6f^HO;}Et-RB|MGnHho^seKI?q*l>3i7pLyIo<#R}RKJ&YI z%K4S&Q`hDr&&xe_-;*~!)GNvOF*fgbUhc8=%4?r`<@wB`Jpb~1>fL-~z4CnKQC|C(=VNT%@x0t)*R#C#SXPSQp3i#TeB^qT=Tn!w_Ak%J*u3L;xyR10y!M%2c|Pk_o_~2h^Sk-T`IYChZsoOq zc|OMG9nZ@>wqAMdQ?ERqd6eg0o=?4-kE~ao&pgU&|MGl{%~PJ2du)4u`pjpXH&6LK zMZUhdsqdj3c|PN_dCI&g&!?TuQ}#!mPY*Uv*)MrM{n1DmIO-XhPZ|K=w9 zVgKd%+(+i7{LAw(_Soy>e)^nt^VITu#^)c8e}8m&KKI4`_b7ZnBF|?${qIiLZ^u)f zkMX{r`WdNjJ{up#|9wBjIGD2eR)3PV{Xd7JfC?tH|1ZRk6~`gzdWDsH8M}Rg{^j|f^OX1d<|&_xZk}3R z`}AP*k>}+eyAR0gKl_F}pLOngsQkvOF*fgbUhc8`q`dZ7&+>fglILHZ|2a>2Kbo8JsY_n_m*-<_ z-toNLW9L_1`^>LApLHwGzdWD$-F)Qy%JW&b^4h;VA7k^5=j9$-ue|oDSDw#2%JVPJ zr{2v+)+^6v9_6)vc|OMGDbLG2w!J@n<}=Qlr+l9xU*Fu+_t1_!pYho|W!{wM)6V88 z`yAV&Xdn``df!hm4(6=J zhkbSPl=p=^pZne1)YxC1&(HVGQ$8=1=hLD&sP-?$#rg`P3!PzdWDyy!puWEYGJddF@}GkFj~j>*V>&uUyahmFKf=<@uNAGryaUoL_l9 z>sDU-m*-<_-tjtlKK07=tXH1TJj(Mg&!^taN7gIPXCCFXe|bKJxhem0eLvS*?y>Jv z%uQame0_7%`tp3n$J~^Ec|P-QZpyzrAH&>~e|bLNYi`QFJfHo++?0QLKKj|e|bK2 znVV|=@_g>=%~L*imFM&G-P~0Bm*-<_KJvWWWA_1h?X%wG`K)tuQ~u@o%&)mA|MGn1 z*W8qUc|L|YDF5<&>U#Q@=QEGyrrN(epSsLV`IqN2kDI4_9xl(P#mzgOmwW8GlGh*B zp*){;F3-O_pZ;$?vj6gY#!X)Pm*-<_-toNLWA_bt?KA%JeCA!Ae|bLZaPyJ-k366I zLSFlq=VNT%@x0t)>y_6&^~&>^M|u9``P94l$a>}Z%%i;aFVDx=yyJPf$F662?X#Zc z`P3!PzdWDyy!puWEYGJddF@}GkFj~j^Ky@!UwQ2_zw&(6tvvtoeCBuak@G9hXWhzc z|MGl{%{!i#du+Y(+NWN5KJzHgzdWCMHy>HAJfC@#*Z$@C7@Ma&FZbB?{`8s8IB%Zv zd8T}Qb5q|#JMw(SXY-VKQ=U&do2TrLJf9wHp0Z!^eEPF_%KpgnZ*H<(pSPH^^69_1 zDgW|(?jv(k{^j`?d+c>`KYdR7zMo?Jf4}di{u+qQQ?3(v>xX^v>)RFP=jHj_U*;xl z?=N{i#^xihljpM!%k}*Cdh&es)y-4ZE6@L&r@Y@cPx)MQ^VIU%r^n`?`hR&o`@qw` zJfC&GdCL7$p3gjPp7MF4JfHd9Jmvh#^Qmj|k#)=SsY|Z+zMpa=SpS=+T>tXM^K+hZ zeVUu{xnJadtM`jMA7k^5*U9r)Z*o1?n>?TOAkV)%pY^%<$n`1D=YEmb{^j`?n|HiU zo=?4UJ?oX{Gr#iu%k!ys^O5z+^O;|H?O&dcv3bYqA8PCed?0uUtas4^OWn^ z+>}pU^4h;VA7k^5*U9slU%8(1E6-=$%JVPJXMQ&yIluCJ)~&quFVDx=yyJE9eCn0! zS+6{wd6eg0o=?4-kE~ao&pgU&|MGkcb5s81`hKpr++*LHn47$A`TFLj_2v1DkGU!T z@_gpq+?0QLK8Cp||MGmk*W8qUdH&}-<#U+LQ;yr_spYlLeYAPX=hE_gdhBuizufch z`zgnT^|N`(=N|9-DfXYuQ$COS`eq#c-{q}0?jv(k{^j`?=Ait`^Vx@={^j}9Wp1kd z%kw|yDew2qQ$82nJhi;`>A~hB&&xe_ACT97_6>PH>)hOwe|bJXAI(kqm*+E&=BE71 z^D#Cbd0y_Z^~!6Xdgb}dvpk;`H}7~}?y>uZy#BD> zXkDOn5KI>Lq`i^O;9^{^j}9yZOj^<@wB`y!J28 z$JjjOdAY~7_ovT%#(DFU&okxgo16L`+L7loKAWe^oAP|x**s-`4iIXCId9`FviU&%U~O%6jGbpYxRW`{pU1 zi*BA;Uid)o*80MP%%kx=pPyh0K*8kJLJpbmV`g3_c z<7sZnzdRpf^N!ca^BI4+p5rgiXWr%cm*=xSHy^n^<@ww%^4h;VA7k^5*U9s#SFUHh z@_gn|o_~2h^=>}0UU@$AD6jp?^D#E>c%3|-bt~6%|CHxbmpuRSeAeyeBllZ*K6S}! z|MGl{%{yKv&u4z+dd{yrpLHwGzdWD$-F)Qy%JW&b^4h;VA7k^5*U9s#SFUHh@_gn| zo_~2h^=>}0UU@$AD6jp?^D)d#`Iqbax!!V*eQ#oJ^19{go14~`=QBR$ru@tEnRjzj z{^j`?=BE71^Z8zLQ~u@o><{Lq{LAy{=jJKLQ=ZR#WNxbc%kwcj&cEFA@B1mog?ZUL z<#Uhs{S^Dp<|&^?eSI^I{_pbE8~2g9DgW|(40BNa<@xNxPyh0K>M}Rg{^j}H*XE}D z%k%m9zIn>$rSg1Q+@GKm*+EXo2UFaBG0GA%{!i#d+fd;uRn~xJfC@&=U<-BI^2BZJ}=MbzL3}c<@p$! zcRVlm*m~u)PrdSd=24!1c|P@SKC)hUKJzQD{mb()Ht%>|?y>7xUi++Pc|LW?^Dob5 z-EKbeew61^m%R2b&&Sxj<9WHq&ab@onO}K6>sFqBc|P;I`N;W|=d*6*wSRd&#^xQ* z%RRPUdF@lLJfC@#=U<*ry_=7$SDw#2%4`4fe2mRgo|k)Udw=@OXPh@r`8-p;zPYLI zp&fZX4iIr(U_9^~&?9Yx9)#%JXk-s{PCJ`T1^c%D+4x!yJ@^@_dZVJ6le|bJFZr<^G6_m?#vxQfa1AXtqi*z6OJr!8RCQgYh+N2HQs>6AhV&ywRB1 z$93fJ|E>GUU23lCdd_1V>%7j7|62F`TkC%J&Zo!CJ06$Y_P!x+JgmPw|K_Ir%k!zj z%}3U)JfEKn^7_9#A7k^5$K|%2ue|=5uRNc9l;>Zb&wMu@IbV4``zx>i%kwcd?|58p z+j^GQKlLonXI}FB%k!z*%~S99Q>>i7|CpOvPwH9TdSYze@wnW!^(?P{>RF!8KFaei z&!?U@A6d`xeCk$S|Ci@uY@YJC+_wFF^_kB)Z=N#G%GWnH^*!_>&u4u$PnkF6`SkPa z`F+^&$nzP&<|)S|&u2WFryP$wpZmb(DWA8<^BMo5Fo%)gIQxBV`tOt2M`?ddj>F$?2pZm=I@1^@ZN1p$h;m6MO@_g<~zK80p%k#O< zn49u1&u9GKJ~H{&<@v0qxv8@*&&Sw&NxlEbTTk}U+?0QL zKKp2H%D+4xWAl;c$@96sJbC`jO?uYz(`R1t z{LAZ~y4^hWem~{PQMcwMsrP?*>xr>>$MfX*)U#aAdY0$2kMjJ>^Qq^}N7l1EpSqRT z|K<4@=BE71_5ECLxoz|8kMsNI^7YM4eviI9pY<^}} z@-NT-JWu%?X7iNmU~Z~^#xJjbelGYPD*y6)4BPpad)()W@Ap%z|K=&5dzhPAPwGM5 zda^I(ru@tEx&N4(@-NSS86TQ_dfeP(d;fo?JZpJA_nFO8)`>iyaen)-XFh#SCC_Kw zHcz?E@_hQ+eB^PtZRaI-RLk?3@B94}^}l(_ecU{?y!B*%H&400@_cs49MpbYp3imk z^e@k6e>YEA&+>fg+1%84F3-QYDgW|(jLkb9m)rK|h`j!9&dTTakf(on{>@GGe|bLZ zxp~U4u{^VxTK{^j}9=jJ2pQ=ZRtA+P_-^D#E>cwBDV`O52` z`O5RzM|u9``OJ6ok@J=3v%m8CzdRpf^Nz>mwykG*{okCG&%B=g<@wa@=BfAlDOTFw zKg~_8KlLncJux=#cwBDVdY0Ee^(@b4ALaR%=Tpy{kE~~TK6NXv|I70+Hcxq6ZrlF8 z`pjpYH&2;oz|(so2PspE6=CLZTmfPKmG3rHcu_jXMO(cP1 zPd@u=ZpyzrpSs;VtJs3 zTU^e@l|IAmO&pyiYFVAPbn~$8YJfD4(*Z<}D7@K!IF1PJ{QeOYmvpk=9$@4GI z|2$85J^J1%pLxma|MGl{=l}lR<@xO6)4x2QdVczs=d-`&pvHfBK6U%_FVCmP%{v~K z+qRzNjfeTl^Vvsv{^j}1Yx9xyEYD{j<@JAgKE~!LkIQY_-&ddctn=n6^Q?S*b5q|# zKk|ImXY-VKQ=U&h=BDjmo{wQ}%D+6H@tB+PFVE*bU~bC4JfHDzo^n0q`CLclrux4; zA7k5|C->9m@a87H<@v0Gxhenhe6EYlQ@$^d=d*6+rux4;A7k^B=gIR~|DPsLx&HEe z=Cygs`jqFhFPo=)UMkP$KC^%C=kpwS{%d9*&Tu|oJfHP{zn@|qHcwgSo2Qnyp46ea zsnx$cpP%oWr+i*2&!}H+xu*Uv&!^s={^j}X`_sQX zpE}%pv?_2^Vvsv{^j}1ck_|+mFKg+^7_9#A7k^5 z=gITAPs;V)@26Y|>UQ&#zdy)ZPxg27k^3vpr*7qbtM`9-KE~!9&y(j<&vHHMS)Nbb z%JVPJXTF<{oUc5ex|P@e<@p%qru@tG{akOkZJ*o!IKO``U*Fv1_vp*>Ss!y#{^j}9 zgSjdH@_dZVQy!PwHs@}hTAt7SVe^#FVdVLY)7-S?Q$ZP)+h9^dy+ z`P7>^E1!MYJmvbx^SLg}P4$0yKI^%8%Jr1z)1$em{x8pG{mo7Jm*+EIb5s81`Rtdu zDgW|(?myiyaen)-XFh#SCC_Kwd=KSW z){i_N!yJ@Gelz(|X`@4C{{gvm_FPoFEA zoAj3Fvp(jg{LAyXE;diS-%q)6+-EjV`8-G7dcMy4@cj9F@qE^Q^OWl^&*wg4ZmRdo z^BMoQ*Z1aMo==^aoANKu$Jl)2dGdVbE7xi_b5>UQ&#*P}fD^E~DLnzQm5f$xbL&*k~l)ziN`pZb6L zm*+Enb5P^CJfC%Y`j_X^^_;IfpM8|)U!Ko=Hy=4)c|Q9num8*QF*fgbo;;trmFvCVPq`A*?dGZX z`zhCldft3wJ%>Q-(q{(dXZ$1peLU#{=xddqG5Udi0#dCS)~H?1$vXMM~~`IqN& zA2T=QU!IS#dCKE*+vZ$zQ~fg@c|P}t%~L*yk>@kc%~P(YJfG`p^OVnN<@t=*cH_U? z<36X|JheQZb=W-Ry2wNf8^wmz)Cx#?y7x&Qv? z@_g<;o2RS?dH&5!^?!Lj^|N`(`jO|;qdBPlFVAOQPyh0K=DT^y`O5RD!~J_duXlO= z=XvV=ev18boi-mWx9xrJ>2sfy=d-_?r`%t8K6Ptus@^Wo|2$8*zniB#Z}ZM_+t$_7 zrw--$)VaLzU!H$+Q~u@otmoz_*HfNPkDGTqF1PLTZF%Ei{pI;LH|1ZR&;4ifk@p{Y z{>@GGe|bK}<{gjAZ989i{WD*AKKm%ozdWD$Za#9p@_hDJUjLWpV{AV1xZJk&EU$m+ zS)R|lvMTN`}p)P&!@-DQy!Pw_WQs3%x9f9Px(Gb zzP`Ds@1Y-gKI^b~%DgGhr=QJJjz^x)2+U25=kk2UV{Xd7JfHi3xhenhe8z8X%D+6H z>&V=ce|bK}wmnbor#XG|)bf1R!Q5oO?w35D>%!cWe|bLZwt33uSMq#%+&ty?$n#m} zpXTpZtsi+l^WDGqbH4I?_GSOx&*w|>eC{*8hjQFLpOojnjE~IouNTi}oi|VUzDAzU zea75W-Q8DJfENA z{#{@G<@p%?onHRs`PAFfzdWD%-@o^>{^j}XPoKX{ZO7y{mb(&&u5(Gp#018 zS+}Quc|JXwgX;hCeAfTzU!KptKmE(|sY7#9*eWRo==aPcl;iCKJ$|6S#R=u z_EDaHc|P;neB{qBc|Q9num8*QF*fgbo;;s=mg`y1@_gnc&%ZpMy4`%_`(k-M^OD#9 z<@p$!cRWv?&;H8w++TSDsv3bYyCYVG zw|HD`+j+_JsY7`__tni)&R3pK9d4fTdY9+(^L_J_?=R%}jCk{r$K|%Y56GJ@^(N1! z&dp8vm*=y;=BE71^V#3cQ|_-kpB^_Kd0cMW`N|s)^OfhbzniDrUwJ$!Q#^_1t+B|IAmO&pyiYFVAPbn~$8YJfHoQ z*Z<}D7@K!IF1Kwx%j=(dmgh4sdH&`3)a~XYuSa=4^OD#9<@p$!cRVh)?f%N^pZ%5R zQ@8T`%k$aa%}4I9JfFIi*Z<}D7@K!IF1PJ`<@L{e<@xNRJpb~1=DYdG`O5RzM|u5U zo{zD4%Hwj|_V?9iKI^=B%IBH#_03Iv5BT+j8F=dW`O5RzM|u9``OJ6ok@J=3vybxnzdRpf^N#1q z^QmXKp7kuxXI}FB%k!z*%}4L|Q?49!yLrm{zr6M2yv;lICeNpy<$Bh$JfD4(=U<*r zJ#Rj;p5^(}t-Ss(&&Mz~$!Q#b=rKi-1htZl-D_RXwGVVsB?2u z^?Z3g^=WR(zdWCP+&txVB+sYE%|{-W+x9w=Hy-9I&*$gn<|*%c@_goHZmR#w^KWj- zzdRpf^Nz>mw*5IGum78~^7%dF>0h3Ib5s3ap3i!2o^n0q`SiGX$K!I_KHru%9@bx; z&%Vp^FVCkwHy>G_@_eofdHr9WkFj~j<8s^1S6=_jSDw#4%JVPJXTF<{oUc5e{gv1M z<@p$!cRVh)Z9U8D|K_ZG=JoV1&!=uTPrctyvC{sYX>Mx$sb_iXiLrUd<8s^9v%LPP zXL&yRD9^tXFlt^dCEL1U*Fu+_t1|#pY_>1 zW!{wM)6eE9$0N^Y1m>p3b9p}FF*oI3p8t8C@_EbVDaUDUs( zDeF_7&pw))TK~)QG0Z{vm*;aGJ^jn`*EXd^b-yUwQt`P4$0yKE~!9&y(lh z+@$Bvm#0tt%kwX<|C^igFVAP)%uV^1=VNT%@jQ7x>o3=H{pI=WyFCB$eClxXk-u-q z^SLhM^?!Lj#^xQ*ljk#Ext{Zt=d+LU{LAy1@8%=tE6-;i<@JAgKE~!9&y(lh+@xnc zKYivU&%eC>soTv{@Ap%#9Cd4MlKOk8y!FJ`yyJQDeCk=QXFbdF*++T)<@wa}<|FG_ zo=@G%>;Lk640BWd<@$cEx7@aQ*4*TI%hxwItuN1Keaubym*-Ot=BE71^D#D0d0cMW zoV$5ydH&~l%I7efr(8F4(~e(W|NLCoJmqs*c|JYbuK&wD?sLWW`zh+@r`LPf)`vRu zJyh#?c|QAPZpyzrpZm||DWCJm^ItuF*fXCV-+biz8o6gJ_k8QY+?3D#N1o64zkO)( z>G__6-uLhQyx!&c{CwZP_w#wF zJf9K!Ua9e4o=;sp{mb*Ib8}PuU!KqYnw#=3&u4!(Pr1MHe0tn`t;|ar2JH<+iOWdE>b`E1x=l`j_Y5+*JRU=d+%h zr(92YK0R*U@wnW!_YHaDVg2R#?7KYw@_g!Z^O5x_&*!?3*Z<}D7@K!IF1PJ`<@L{e z<@xNRJpb~1=DYdG`O5RzUwQpso{zD4$K!I_*0a3+Z_dhRUQhq>eCl@dl-Hv?pLxj} z&*k|T&;P#Z@_hF3>0h2t-9G)x^Vwf>P~*QmpSpeem*>;t<{gjAZClUs#>0H&`Rt=S z|MGn1wfV?;mglpN^7_9#A7k^B$K|%|@2k&z)_L=kc~-u@xvB4=A9+6Ovw6zADbJ^$ z%~Os?p3ex(O^xUBe8#hR%JInaKhIM>Z`nNMIL%Fshk42CpXt=3}dVR@TPYiQV{^j}HhoAoC`P^5{P4$0y z{^xnh>wWW-&qd8m_0P|JdHrK-KJq+yKJ_Nov)<(S+-EjVd0&#}^K)?Xl+PRG`RuQ` zsqtK%k6{kVzdWD$KK;w{*++9z{a>EXd^b-yUwJ+R`N z=kol^>z{F&gYqxWXWgFu<@xludB^XO=d=EDJ=b5J&%Vp^FVCkAHy?Tbk>_*0$m{>| ze2mRIo+r;|zH&Y1E6-;i<@uNAGvCce&R3q#KFaI=@_dZVJDw-czqv`zdVc!MOP+su z{ZqG_kGv1d^O={t{x8qR*u3L;@_hDJuIK*B^Ql{T{^j}X@8%=-SDsJZ%Ip8~e2mRI zo+r;|zH&Y1E6-;i<@uNAGvCce&R3q#KFaI=@_Y<)Q~u@pey+FNw(nESO`f-WeRI?L z@_g3E+?0QLKKpKN%D+4xWAl{9<+jba=BD~*Jo5a{^OVnFHcz>3=BD~*{POzeI@&zt zb6R;mJ=(7S%RTOM#m!U8^I3<@Q?8plpX*}(-p}_4@_g3Q|J{kke|bKJ|GN|Um*=z2 zKYi!F2bAYCUvpFaU!Ko?ZJu(!BX4^2Kj?t3WPuCv^;mgjSy@jX=j z<@t>B+lMBfKBtoBvu@@l&$52x`52pzJTABGyyW#y9m?~W*XAkfU!G4Lnw#qX@_c^2 zo15}4&&MzaTQ^QnJxQ~h6_&;FX5@-NS4e>YFLzw&%~+!!FVAP+<@uNAQ=glUtWSA9*M+?PFVDx=yyJ1XZRabm zf95OCXCLMHm*+Fz%}35xp3gqY>;Lk6jLkb9m)o|U<@HZJ%k!C+Jpb~1>Ur~#^(@b4 zUh?|CJRf88j>qM;-CueAv%m6u>Q$7>v zyeZG8pI^`K!;VLu&j`#-jpy=w#$#^EzdWD&fVnCE@_fc`ZpyzrpX&5d~=gm|8_eAo1?lYUGtOt2M_2%D+4x!yJ@Jb6CrFV}PZ z<@xNpJpb~1>TvUs_j7qZ*NeRVFVDx=yyJQDeC8|HbH4I?_EDaHc|P;qeB^xP`Rt>- z{x8qR*u3L;@_g!9u4g^V^O=`C|MGn5dGnF=EYD|N^7_9#A7k^5=gITgU%8(9E6=BH z<@uNAv%i~<++TS-)Lha@)R7`Eh>#T)w`!$?wsZ=d(WMru@tE*>`hO{^j`?o2NW3w{6bdJheQZ z`@`lbpTo%W8RzCH*GHbub+mcP=d|*C=4-q4x!mJEr+vSlVqZ2-x$owt)|2{_x1Q{m zxhenheC|Kyru@tEU&e%rWV&;3W9&p5w*X!7ZEDtSKZwt32R zmgm#o<|B{GZ96ZyqgtNNyf#m{4)XlZ^OV>7<|&_xzTZ!=@8+!5lO5W8`Zrl5Yy#85#c|Q9t&%ZpMI^2BZ{YRe9&joq?U!IS#dB@{&+s;>B z|IAmO&pyiYFVAPbn~$8YJfD4(*Z<}D7@K!IF1Kwx%j^H+_v+T*FW=> z=d+LU{LAy1@8%=tE6-;i<@JAgKE~!LkIQY_-&ddctn=n6pJ&R~H#hY?^drw_eKt>- zH|6>Cvw6z#$nzP2xvBA7p3itTPdOfW{^xnh=PjG39H+Ud@h~rW{c|0eoANKu$Jn;# z$^G=b!{({w`K-_T{S@o4dCKMG~YW>Sw&(HIe*ZbxvpNnpuT3-K*!1qdx=kk2+15f|*eC{*8hpPX}^QlkYL*-wd z&vjvL%D+4x!yJ@JbC`jO?uYb z)8~4Z=U-m`pXVv-)7+HLy2Jb6CzmFqcQc|Q9n&%ZpM`EEXPzVdwbQC|O-=VNT%@jQ9{%}sjN^V4Tu z^8Cx||MNU$J)4{InU}o&FVDx=yyJQDeD+ta=l;s`satve<@xOI<|Fr4o=@G%>;Lk6 zjLkcqC(mcTay{oO&u1Uy`IqN2-_1wPSDw#4%Ip8~d<=6_{^k09uD9H_?@i22p0|8` zbJP0reAdU@lz(|X`)+Q^zdRpf^OVQsw#~Wbrut_*^8C;9l+R%{Pq}X9rut|6^7`jG z+C1fRT6sP_+OGf0J??Yb%~Q+sS%=M2uA4lc>tg@j&-VrLeAd&y>uda%=VSPHefgK? zv(7(#=Y6X@pZS`b>i_b5_G|N$`z6ok{$p;c|I71V#)l@K9yd4HcAe#(wLG8ujPIfH zFVAP3-##??^f{G0pLO#+lxJB#@_dZv`=-nDskf(pc|P+pH#MHi^Ql8~Q~u@o{CwX$ z!0 z^OfhbkMjJ>^O^7FBj+p6XCLMDe|bK}<{gjAZClUs`lp`d`OHh6e|bLjy!ps_mgh4s zdHr9WkFj~j<8s^Xue|=*UwJ-tE6=|?pZ(o@B|IAmO z&pyiYFVAPbn~$8YJfD4(*Z<}D7@Ma&F1KxeUw!7Y&YP!v&mv#n+|>8bk366C**s<5 zl;_jWujlt+$0N^Y1m>p3b9p}FF*oI3p3i;2+?0QLKI1nxl1{LAxMx6M;Nzmn(Euk>@kt%~Q@- zp3lCRn;ggc{gf-gdYYT0uBW{9#Mpe~dGdVfO0MVoIC(zz)y-4ZzdWD%+&pD{%Jcd8 zZfGelz(|XhB+wz@_gp?^e@k6 zf6Yzxe|bLh+C1g+Re3)9`2O#wSWk0S>%)p~-fd&%e2;@m!wII5$tZKJt8iE^MCiIjuaO5!h}#mwVjjw40}v=d&;7rux4; zpX*}tl0h2toj?7{^BKQ6sQF%=&w4)n%k$}R^Nz>mwyi69<6-^f z`8PM^U!G5WZa%U;<@sDM^7_9#A7k^5$K|%2ue|=5uRNc9l;>Zb&wMu@IbV4``zWvf z%kwcd?|58p`~7~3^>W{R57qimxANBi@_hE!9F%`~K6U%_FVCmP%{v~K+jd^^#zQ^J z^Ql{T{^j}1Yx9xyEYGKI<@JAgKE~!LkIQY_-&ddctn=n6^Q?S*b5q|#Kk|ImXY-VK zQ=U&ho2ML)Jf9Jmn;OsM`HW}tl;e@-^K^uCKh5(2>qnl?yf#l+5AuBOd*&v`@qRz$O0b^hCaLQwZ#^;0LHU>GQ&&&_ z@_g>Ao2TCIr(9`%4w{>!K5vw_p6su=DgW|(40BNa<@sD+Pyh0K_Sf80|Ci@8-_29b zSDycQp7MG4<|)5_^Um`6zqv`z`=R~hQ|I#h%kyt;%D+6Hb=y4U^&-!wM{`j9U!KqU zKmE(|+4rY^c|LWx`N;c^JfEKz^2UF8KE~!9&y(jfFS(xeCeLRd<@uNAGvCce&R3q# z{>tnB@_Y<)Q~u@o)brE7JfC?z{mb*I+x`1JuSa=4^O86I%kwcd?|7a(pZ%5Vxxey! z>Q~f4RP&>n*qKbITv+_s`|)o16R|eR)3XV{Xd7JfD3xH|1ZRkFj~m<8s^PTysAxp~L+liT+BwtUxLo==_2^DocmKC}7A`@B4#p9}K(zdRpf^Nz>mww%4i&=lSyW%}sp|{mAoK zpUqR|O?f{3Y@TvF@_a^MZfZQ2=QAF2Q~u@opXVu`A8wv_CZPyIjr%kvqh@0Hr$%k#Nj zp8nDsv3bYyUr~#^(@b)ZsqlVc|L}@DgSbPKi6As+xJT5 zCeK^GzPV|Ac|Pl7ZpyzrpL#Gi^UVc|O<0<|&^$$@5t^|E{n8FVDyD@A~pD z&u5)~`p)}7c|P;?JyiW)o_}*w{^j}He>P9~oJXGj>hZ&#`SkeaBiC8(S<5}&eK$Ad zQz!C##{ca@lTXJl&u85>Pgy_meEKs7`7Iuo+jd^^eCkl1&%8EIxeoGt>hS&FPqFWt zr`*TQQ_EXVc4+^8&*O62-uL9~FV~kmpZ)bcRQ~1p%hnD1b+LJBdF#oFZ{G2^ z+_v`(dHcn_$n)8EdH&`3+f=To=x`oBCMWAl{9<+knbtIvGadGnNcR=&Qu zsqdj5c|Pm2dCI&g&!?YX&+o&IN1o3J%uS8w@_fd#dCKv~^KWjd|I70k|K=&jFVE*X zGB?%#<@p%f_B^?tzIQM;=`GJ^eaubym*;a`n49u1&%e1T|MGl{%~PHy&u9IA`cD1G z^O@J?DeFO=&%XE`%5nHUQJ&9z#@v*DdH&1z$UOgg@qE^K^OWyvi_b5>TvUv@1y1U{9gM0-}hsG%~`Dv zD{c;I{V&hw`g;18=d+KSr@X((^Qqg-Q$Amn=d-{5cT$c2@_dZv`=iVAskf(pc|LXi z^e@l9xoO95Zpvpp<@uNAV{G2>Jb6CrFV}PZ<@xNpJpb~1>TvUs_j7qZKQH90h4Dyq^B$`PB3N z{oecilsiM+Zl3b@PkHOfd7F3aO`cCZ%k`{hc|Q9n&%ZpMdft3wJ-l~^#eK<~)%v_D^25sH)8m_uTxYpwE%$t%GjE<+p3gYH zeb_UfKBtoBQzx6Jyzb=r^tbuQ<8s^1OYW$a=W}1(Jmq}l`P8Smss1m|=jZ$8DgT~d zo==bdcTe?yc|N~4KK;w{xlj6cef58NKKtu?sQk0h2t-9G)x^Vwf>P~*QmpSpee zm*>;t<{gjAZClUs#>0H&`Rt=S|MGn1wfV?;mglpN^7_9#A7k^B$K|%|@2k&z*7?Wp zJkOV}Z*J;)=trK<`fQ#uZ_4xOXY-W#TAt4c%uS8w@_fc)ZpyzrpZmb(DW6x%^BMo2 z`ObRE^SO@R@26O2b5`ra4*4Fc{klA#_5bNR>o3n|-+d2N|Ci^pU%rRRzdWD&jJYZQ z^8A*j zq4F=!XMf-Cr&v#OR_ntGnuA);%kx?1r+;}q_3-pB&!;{&A6cLBe6AOHW`O5RzM|u9``OJ6ok@J=3vybxnzdRqq+?0R0zMtzYx4rM7Ja75>=BD-K`K*t* zDgW|(_TAi+e|bK}<|&WMZJTp9Pc6^q{$OruJeTJ)PIFWK<@sDko2PtEE6=A#+x36B z$9)dJfA6;TtmXOKXWs9pSclD1K3{#mpQ3Iz zPkCLKo2oaiBYE|PVGhc_JfG|9>0h4DK5m}!{wB|7UYn=99_9I;=P93uo3rwn*Yo|+ z<@wzAp8np3izd{mb*|ar2JH<+fdCdE;SUTvUs zbt}*3=YqWcFVDx=yyJ1XZRabmf95OCXCLMHm*+Fz%}35xp3gqY>;Lk6jLkb9m)rLK zDX)L(S)R|lxZJk$mDfM>mFKgM^8Cy5neXN!=PS==ALaFbc|OMGDUZu-+uv88 z`K1W!{wM)6cKJGah+9BQQ5Lp3CzY&*mw|BhTkPuzAYo zE%JQEzj?~%!}5HtBXd*ZzdRpf+ny)))93J;rqBgKI8oM`rgKJc|Pmu-}U8Ro{zDAzvp@KeC8|HbH4I?=4)=szdWD% z+&pD{%Jcd8?t7^EzdRq~`M&A$eCq1yU!G6>`yQ(CT%ON9nw#=3&u1UaP5GDSV{AV1 zJb6CzlIy+SPq`A*|K=&{U*3A&++;64&o?*ab6v>uFVDx=yyJQDeCkTB=kslOKJ_5a zzdWBh+c%D3;`O5X2uRNdqmFHic&wMu@IbV4``zWvf%kwcd z?|7a(|K=t=@1IYfdCBuHum8{Ul=Wc%D3;`O5X2uRNc9l;>Zb&wMu@IbV4``zWvf%kweJP5GDW z`?=n7+dj|#aen_?zP`E1@6ng%vp(jg{LAy%cXLzz<@p$!r#vpVZO%0})j#8r=YO83 zd=9gD%5^X|)j#8x*FV?M<|*HI$n)vZcKu)Oai7y}o?4#II+&a4|MGmU3v*Nc<@ulI zDc5uJl;@e7>Ysnf^;~~*Q$Fi2&u3odru@tE*{{u0?w35D`_JYnpYzD`UnBT%Bz$^& z^U=PC@~q{a@4lOx^11)W^BMoQ4^2KDzdWCH+dSoUC(oxpbCBQSak*{hCC{hc|}Mm)o|k0Do2R@kov(c7E6-wyzyV2kFj~j<8s^9mAw90e|bK2F3-O_pZeTxnAV; ze|bK}<{gjAZ989i{WD*AKKm%ozdWD$Za#9p@_hDDUjLWpV{G2>xZJk)NqPNK&+>fc zCC|S+|MNU$J)4{InU}o&FVDx=yyJ1XZTDAR|Lm_kpSqRjU!KqYZa#8<<@waDy#6oG z$Jo5%ak*{hE3bd%E6-;i<@uNAGvCce&R3q#KFaI=@_dZVQy!Pww!g1F^I7N3Q@&4; zuWxSZd+0}=&-!ehGH=TB>F3vz?;MXjpAndw8qekVjK|!Re|bLl0drIS<@t=?+?0QL zKG%`CDgW|(jBR_K+)v*-Y@S-4&pK?La=+yHTo;?Cd|oQgXWh(Aj@#!~@_Y<)Q~u@o ztn*LbsULYh^W8ko15zY@_hEu+?0QLKKp2H%D+4x!yJ@KKm}uzdWBh+c%D3;`O5X2uRNc9l;>Zb&wMu@ zIbV4``zWvf%kwcd?|7a(pL&+-S_(AZJzQutvsLk+HQR=_qfmDH%~3kXJ5=s^?!Lj z*M+$$|MGm+)7+GQc|OMGDUZu-yUymO`e$F{`OM4Qlz(|X`?Yz>{gUT%|Jgj{a~^sA zYXl#Tginu~n{4~OM($b5^SRG#p0Xa~`HcVDhduM@_~rSm+vX{+FL^%wZ9ek2+_v+Q zJF4aR%y;vY^OfgQhnuIo-sSoHd^a~Wp3CzwHXnIhZri$&*FSYA&!^5ePkCL)^V#3c zQ|_-kpZ(oD<^Ia^8S&;LkIQX4U-`~gp3nZ8oANKuXTIj9{LAy%$M^dw*3+ET`mlnV zcRVh)ZC%NC{pI=8xjg^!eCl)ak@YFh=X#OX|K<4@n|C}ex9xo8^-sOY^ZB_c&%ZpM z`EEXPzVdwbQC|O-=VNT%@wnW!_epvEb6=I`GcS4m<@ulIsrUOSR?hqU=BeeaC+BV6 z@wnW!^(=3{sAqXT`zX)9JfC{rd}KY#^Ql{T{a>Dsv3bhla@+Rz)n`8Ujm=ZO50bBM zZt8pJN1o66Y@RZ2%Jb>x*OTuYk363dn422U<@tm$$Sy4XDRem~`oaGxh0-Yo=^Qh{mb(i zzd5M&zdWDyeEOH?)8pnHzek?W`pflPe|bLpF3-O_pE}%p-{x8qRFgN92uJ7l1%Wa!m%}t)Se0_7%`tp3%$J~^E zc|QAYZpyzrA7k^B$K|%ox#p(&XFT$J?hl)%d=4YeXPld-Tu*sE*U{!FpVP|o8L{og zf4Rqf4!?P7c|Pl4ZmR#w^SLfIPx-z;p3i!|-%oL0+C1etnS)yY*S|ja)N`GmKKmli z=RUJ}%6gFJGtO_X@8#Qn_`&B?@_g!K^OV<}Jf9xTLG^!mKJ$9|m*+Fz%~Q@-o=<(6 zn;OsM`TTs}JmvFJc|JXEKJvKSw)X*f<@xNdxhenheCBIz%D+6H{WUk`U!IS#dB@{&+x{Gp*FW_p&!^7i z`IqN2&do>Gr#zo^lh^;{`52pbJTA9wUCHa8^_S;U=kol^^Qq6xN7ko2pX)_l|Ci@u zY~Jy>+_v+T*FW=>=d+LU{LAy1@8%=tE6-;i<@JAgKE~!9kIQXa&+_`Gp5^(>OP+su zKJ~o$$a1W!{wM)6eE9$0N^Y1m>p3b9p}FF*oI3p3i;2+?0QLKI1nx%8tJpX#}eAeIGlzVwT_Zf3j{^j|M z^V{ot^Dob5Jgo%kweJ zLHU>GQ&&&_@_g#w+*JRU=d+LIru@tE*++9z{^j`?=Ait`^O@JvzdWCP+&ty|O`gxZ zHc$C{Ri4j2Zl3aaxICYEZQgO-@_gz|u4lc;^QnJ%{^j|MfAf*!m*=yd^7_9#A7k^5 z=gIR~f4QFPFVAP+<@uNAQ-_<6yr0YSxh~}Oe|bK}<{i(I=QCfqp7WLGvybxp%k!D< z<|F4T&u1Uy^?!Lj#^xQ*ljl>t^-UwJ-tE6=|?pZ(o@DsVQ$L5T;I?2mfQBZ<&X3G=koQrmg5pO>7xZJk$mG6Az`TX28H|1ZR&wR~I z`IqOjkLITQ%kwcd?|58p+q#n1KXoY2r_Sa1m*+Fi%||}Zm*=x?^7_9#A7k^5$K|%I zD|!91{_=e4T%Lb}sr*7r>m*=y;n~&UIc|LV3um8*QF*fgbTyER>%Ilx`%JbPrdH&`3%y;vV^Ofhb zkMjDzJRf88l*i?^?eDA4eAapMl<$M&>zkYU9{Q2zvp$=r%$xFj`uX+bJI5o>X9VV^ z#&dZ-9mw40}v=d(VWr(7R- zKG((ODc={!^I5meQ$D|v=QA^Nlk@abp3ge}^qu;V=QH2UQ_feO&%T(O9Ebn^IP!e% zGv=oJ%ky8xN9Ot0i|4cc=B(Vy^SRHw-%qg)=B(C-`ZPDSo|otI^ZosPitA|el zvhAn5_2l}J>v?_2^V!GEQ{La?`CNCKr+mID&%e2;@m!vdv3bYynX4Q%kwcd?|7a(pY@mPx&HEe>Or1=c|LWx`N;dZJfEKz^7_9# zA7k^5=gIS#uUyah%JbPrdH&`3%y;vV^OfhbkMjDzJRf88j_1kqsb{&K^(@b4Uh@3Q z^Qq^}N7l1EpLxma|MGl{%{!ha&u4$-dhV}0pSqRjU!KqYZa#8<<@waDy#6oG$Jo5% zdGdVbE7x_%HXk&*3*uEzf5i%uV%wc|O;LxhenheAd(4lz(|XhPf&K@_g3c+?0QL zKJzj+Ed<+E<``oBCMWAl#3<+i==$?Ko>m*=zZ^8Cy5 zsl&}j{@j=6bG^vx|MGl{%{v~K+jhS4`e(lKeD+bEe|bLh-F)PH<@xNRy#6oG$Jo5% zak*{lSziCtvpk=9$@4GI|2$7w&*r9l<|VKH%kwcd?|58p+x?Z-Kl>}sr*7r>m*=y; zn~&UIc|LV3um8*QF*fgbTyER>%Ilx`%JbPrdH&`3%y;vV^OfhbkMjDzJRf88l*i?^ z?eDA4eAapMl<$M&>zkYU9{Q2zvp$=r%$xFj`q@0?c;xwvz}(b$F3)E?=BE71^SKY0 zoANKuXZ+@-{LAyXj?7K@m*-<_+wxANBW^E~DAd~;Ji*M;0~_2-2=A7k^5=gIS_H@TkmCeNoH zsin8 zeCk%7e|bLh-F)PH<@waDy#6oG$1peLU#{=xddqG5+|u0SdCS)~H?1$vXMM~~`IqNY z59X%)%kwcdPkCH!+nl?3YI*+6O^xUBe8#zX%Jr1zbA4@|dcU7yrCq1@`>9vuecW|< zzn^kFxIe$&PjUb8J=Cje{@ni_o@&wbn6lz(|X#^xiB%WZq#lh;4@ zNqIg$H{b84sQ=AVKDRdqwVpR;?Rq|a)>)oUkDGTqF1KyH$s5njS@}0Nq1`tm*-<_-toBHw)2(O|IJzX?BmnFJfHb)K61YDeD+b^crMS!FgN92p8t8C z+V@uZ%EXFlt^dCEL1U*Fu+_t1|#pY_>1W!{wM)6eE9$0N^Y z1m>p3b9p}F**xWVp`B+e(m4;xnJ^p?lZoJa-V#jBhP;sADQQ0FP_hR>HU6+b=W**{reuO zwd8&)Z#}uL-~as-b!*OQeYjpWPkFt_^I36oQ0sqrKG)aNzdWCP+&tyJ%k!Dn{=J{q zqdcGA-}Zlx!uLD!eCB1Y+4;)zsW*B4<@wb4)4x3b=BE0;JfHP6H|1ZRkFoj4^W^!g zzg*Atm*=zZ^8Cy5sn5+v)~7t5p9}K(zdRpf^N#1q^O>()&-u#p*++T)<@wBa^O5tF z=d+LU`oBCMWAl#Z$@8gOx!(Kzlq*5q`W{N^?+^0Ull?UZeR)3X zV{Xd7JfD3xH|1ZRkFj~m<8s^PTys-=B#|y;mxi0qa{d{jC&u2Z~|NRvArOi{W)8?b)wq56^ z&%Vg>+4uc>KkG!E&p5w*SUG(9oJyWgo$UW!y4RgNpZ?52ev8NDwwz{g-=QA&P{^j}9?eo8fx;&qGJ^jn`8G*T`@m!wIK0f`+ z^QqgXe|bLpyZOldmFH8p^2UF8KE~!9kIQXa&+__bzVdwbQJ#N!KJ(pt)8s+xN1o4oeGg^7&R3q#e)%3M|MGn9Gv=oJ z%ky8xN9Ot0i|4b>=BC`s^SRHMoANKuXPn<&-_2%D+4x!yJ@|cr+;}qJ#OCdd*u17vs};T+wy$&U7mk=K6SYH$osiGpX)_l z|Ci@uY~Jxac|P-%>p5R}KKm%ozdWD$Za#9p@_hDDUjLWpV{G2>Jb6C#EZ4K1<@wA@ zo_~2hb-Ve<_r>yj<|VKH%kwcd?|7a(pZ%5Vxxey!>Q~f4RP&>n*qKdy^mM_s`|) zo16R|eR)3XV{Xd7JfD3xH|1ZRkFj~m<8s^P+|5(V^SM84p7J@2JfCrHo^pNU`CLcl zrsjKjK8Ef5%RTOM#m!U8^Vt`3Q~h6_&vmhR%J&HJeAd(4RR5RfW0;%rFVAQF%}x22 z=QA&JQ~u@o?91jU|GN))KKGx^Q$FXB=f6hq;Yj%OxVg!;>n!)I<@wxaHcwd(@_fes z?Zck=bo}ys)@}2Y*Oxq>{x%TQ^Qm)lQ~h6_&;D+na)0Id?C<6&_g9|J2sR&iTyERzNZ$CFuRNc9 z+&pDH%k!D<<|*eZ&u4!(Pr1MHd`7%^$K!I_)|I^ZQit+T~mv^(oKix{%lZ<@p$!cRVh)?R@3+&wSDsv3bYia@*Fky#A?Yc|P-!=U<*r-EKbedX(ogFM0i6 zo{zD4$K!I_?ytQ5*Dsv3bYia@)>VUjNKjp3gqY z^Dob5zMGGnuRNc9l-K{|`52q0JTCt~{*J%*@AN}sm_+5Yf@&Bpsc;cV^p6mb99{A4ZuYTY4|C#T2;-CM4>;JPJ_}=Fq zy#7D;J@3VT`G>CmhrjSY{`mF(`7iw6{O0=q!WaIp{=&cEw}$)mFMi?w{I9+KANj)n z;cvhGzx0Lw%fIjX|MD09$M3)Xzw(9un}78BKYro=;-9?!zxsv$vp;tIf9(tZSAY8Y zfAkCg=l}Qh|Mf5YAAaZG_*=vM{WrewfBDy4|KI$=|M)wv|En+j-~9d8|F^#IfAJ4r z|Brp)|Lh;T{=fZ&|EoWI{eR~R|L1?=`v2}1{ty4#_5b)6{x5&W@BXdfe*Jr2_#c1G z_5b}Z{NMbo*Z&W`@PF}lU;jV+!vEPnc>VwA3;$RD$o2ok7yi%xiR=HzU-&=#(d+*w zU--ZLQ`i4bzwkf)&+GrmFZ|#9MSs(84fppy`@;Xl@4Ehf{)PXu-*f%{;tT&*zwi40 zo5F|KYsoH<_rHfzq$Uezwm$Y|6KpS{lfp* zU->ux)^LCSyD$7-{qF1k=`Z}B|6SMr@4xVW_y?~4KYZc;@)y_tAHVQF{_*So<_rHf zf8_fA(-;0P{^a%l=P&%9{qNWRU%v2v^%vaVSO3>9{P*GiKUcu~;om*%`eX9T`?X*`$bGoF1P<9OuxJV)@oOZ{J-&-i`sl7D$V zIeg#8`1dRFe0tor-y`?azvJ2WG0XE=pM4+W`pEOi)xLLe9RBas%JW&beIMidZ+SjF z?)wmFKfxzISmP?w35D=M=to$-g}RWqf3wf4z7<>%Z?~ zTz`2!&nbNGQs0;7GtO_X@6EqFpY`;;OaA5g82f(3^W^!=SFY!L<@wBO-^W=0@_g#k z_b&B+c|OkveeaTgc|OLzU-3M7KJ_Nov)<(S)c?MZvHs=x?4$2p>i_b5_R;q)`IqNo z{KX%c|KESf^O>(a_ws!9_b++$e|bLh^1Vy_U!KoC{-uxpFVCmPzwF^(o=;sp{mb*I z|EGU>KI8n$ALF?^pLKism*+FD-}&hO@_g3$>0h4DzCZoT^QptX;xV4f^SNH0{^j}1 zYu}eZfA~S3&%ES%{ymU9pM8|)U!Kpr_Wg=KzvTJsqrCnv&&SyJC7vhGr*7qX{(P6` zGcS4m<@wa@zF&F&eVZ#s-R}Ds@Bi}Flk@g{iM`45sb{&K^(@b4ALaR%=Tp!7e#Ls0 z=To=x`oBCM!}l)vm+Skv-g4Xi-PMopzi<2PMsA++eeLF{<-4Anr(9=wK0g=CP41h2 z=ONF>u$_Oo$Njs6%~Q+ssb_Oj{a>EXbzyGGzdWD&t+^@x@_Y<)Q~u@o+)vC+`IqN2 zFLP7=<@xNFxhenheC|J+r+iN=&wus!Vb6SeeDjfi*CqF?<(}`pZ=PD7&-lN6*fXDw zU!KppZJzS|v^<~w%t3yO$K|%2mpq?(ljn0^H8|lAm)o|k0D^8Cy5Z*I!JJfHR4Jmq@I z^XYN(j>qM;U1xdYVPE9=?7KYw@_g!Z^O5x_&*!?3*Z<}D7@K!IF1PJ`<@L{e<@xNR zJpb~1=DYdG`O5RzUwQpso{zD4$K!I_*0a3+sb_gU^OEOZo=@Fwp7MH>=QA&P{a>Ds z@mGCl^67E8ZTDC1SPMc>d^b-yUwJr4$V!C=kk1hzMGr! zFVDx=eB^oZeCkcEXT8bussGJW-aqB}?4!A<{x8pGAI(kqm*-=cgYqxWXTDGW@_hE! z+*JRU=QA&JQ~u@o?4!9U|MGl{%{!ha&!?{BdOpvW=TqnM{LAwhr#UG9@_g3q>0h2t zkDGV=9(g|NEZ6gXD9>l#<@uNAQ-_<6yr0YSxnAV;e|bK}<{i(I=QCfqp7WLGvybxp z%k!D<<|F4T&u1Uy^?!Lj#^xQ*ljl>UQ&#_kVfo z$$6W1>`k6eJ1W!{wMQxE2*?O&dcv3bhla@&5d@1g3Samw?#KfK>hu|Aupd|zO0 zYCXAL;^<4j_&-%;rxzCuJ>i_b5#`*2_z4@2tQzx6J zyzb=r^tk!R<8s^1SKfG-uRNc5nVa%2&%e1T|MGl(zHgrLd8s^~9?e1Ze|bK?H$MH# z^SOVTo9h4aeD-nkl+PjM`RwoJDfd^N&j>ajd0cM${eFt|@;Se`sr8}G?&SIGqdfoee6GjMM_!NeeD+sf|Ci@uY~Jy> z+_rTqum78~@|oAuzdZl*Jmvk?oR!bKmwykG*<6*w?eD+bEe|bLh+I(a^%k$YsdHr9WkFj~m<8s^f z_tj@U>%V!*JS$({+|>8bk366CF*oI3o=-pKru@tEG0aW*m*?}n=BE71^FPm1K5sE+ zFPoKlT-%qhGKfU&)^_fyorIji-#xvBNPJfHR4JmvKw&!@-d z`=iVAskf(pc|QC8^e@k+4xjIvF3;zBdHR>zU2ArqdfoeeCDQ2yol)a}#1Jf9vn@Ay6PeC8|HbH4I?_EDaHc|P;nd}KY# z^Vvsv{a>DsVQ$L5T;I?2mfJSBnwvat`TFLj_2v1j&*mxfraYg0-#q1b2Y(DZQs|(J!^SB_Zf3j{^j|M^V^3epFXFO z=Tj$}r@X%8`SiE>$m4R`&P(p7mgh4sb5s81`8PM^U!MPYp7MF=<|)tHe6-xQ_kpL+ zeM6ql{nOmk_%F|Af6Yz#m*=y;o2T4gc|JXEKJvKSw)2%Y9_B00XCF6Dd4H4VGq3%7 zKkHeZ&;IV;`?APyh1#o0}TX<@v0qxhenhe2mRI9+%s8 zo#pk`Zrl0F>!10`^Vvsv{^j}1ck_|+ zmFKgM^7_9#A7k^5$K|&Dy+~gF)U!OFdCBuH&!=uTA9+2>^O={t{x8qR*u3L$xo!7X zUjOW`JfFIi=U<-B{%$^Uf93hqt-Ss(&&Sxj<8ird=PR#&<}1%2KJ!`U%~L+ll&^1Y>U-!%p3nN2oANKuryp}u{^j`?=BE71 z^ZDM*Q|4cJKKB80Q~h6_&p6FZ`IqN&9hsZ*FVDx=w&%(H^ts~Zspa{s&*mxDN1o4h zv3bh>en+0qx^15F`IS7Mnfc#IIZr?3`KTvUs_j7qZKQH9Wn9`H%> z{LAyHck_|;%JbPrdE;N6kFj~j>*V?Ltz6H)@A7==lILHZ|L;6yKbxEKsY~AYm*-<_ z-tjtlKKm=zbARRe^sPMq@_hDp^O5^2&!=zYjemJQ#^xQbljl>fT+e#t`Rt=S|MGn5 z-F#%d@_hDD-uRd2W0;%rFW2{Tz2zSJdy2Wq>z1!?ZdzZS&-!ehGH=TB+4s#;&PSfl z3^q@BUhc8qYi?@(%u}Av^I`Lp?_uQm%zyKg^OxsyA8nrUJ*_;S8GGFPFZaCfX*W+T z&u1OXO^ttfKKF&WDgW|(*3;aSe|bKJxhenheAeIGlz(|Xb(x#;FVAPcHcz=<@_e2@ z{tngnm*+pmSCdcA`#Y4!{w^c;s^$4SXMVp=u@0N3ystM;EpI*f`|j^ht^eiu82+x5 ze|bLr_VzE&r_X=CPqDw|tk#G7Zu6AyUFG@gqq(X5x;!6a^N#1`9@|&)#^-q`&*!-+ z&%ZpMd2T-PeZD-Ob(1&#<@p$!cRVlm*magSKKmlir_bg2m*?}`-hAZWeR)3ji@fnK z&&Sxj<9WHq)+=v(>XqlSkMjJ>^Qm|9k@d>+*++TfU!IS#dB^i|kL_o9-@h{KE*gWNVxyO$8*JnQKym{*P`;;rl zbHLmr^?i$c*VEjT&pONVxsS|E`IqNo?6KF${q#Nj=BefR^z-H^-w(+1xi22K>Kg;u}ck`6>%JbP5bCdJ%|KFNCpXbcxDc|SF^PdsF zjeP#s!}D4H%~P(wJfG*x<|+F@p3nS0&-XT$%kx=Je}~GyJRif~mGUpor{1@Jc|P@; zn;QS}eEM_ql>I5s=kNRGDc_gM^O?csBj+X0r{Cmy_M1GP{@*-h|I72)M}LQE{LAy% z$KUT$|ISmc-{zg=ttb8V_Ak$;&)@##`Tx#S_NTcipZh}YynQ~%^D#E>c%3|-zLM+t zJe23t|ML9H^XbpcM?TNx`P?t^#=krtWAl#J$@8gKu4ldSeD+bEe|bLjZa%VJc|Q9q zZ~V*iF*fgbojjkumFxNZl;=~IJpc0if9EOt+1!**UGm1iJRf88j@QZa*tJrmzdWD& z!rYX9c|PlAZpyzrAH&>~e|bLZY;MZGJfFJEP5GDSvtQ<>{LAxs{+OHcFVBCBuO^?K z-+Z*cLwVJ5ueTq}P5JbLJfC@fzM6dco=Tq2x^15FewXJn-sU6E%RRO(xwBfHPhFd* zTnBkReQ0iK{LAzIou_k&sBN;<@wCh9F%`~KI``OFVAPh%{!i#du(6Hn-A+R&u8D|`IqO@pPP^DPkBD~ zg}m`E&&Sxj<9WHq)+=v(>XqlSkMjJ>^Qm|9k@d>+*++TfU!IS#dB^i|kL_o9=gm{T z&y=rkZt8m&N1o66n49u1&u1KSQ~u@o7@McOPM**AZk{s#%JX>+Y@YIci#(rsZk}>I z<@wx4<|gOu`)7GR#vXf}+)v*tnw#{N=d(VWr(7R-KKI4uDSsc4=d+%hr(92YJ~Q4t zWgYT-)_?Pq>o3oz-py0iE6-=YHcz=<@_e2%o2PuABhP;-`&!|AK0KfGH)myEp3if} z+?0QLKJ))P-_2%D+4xWAl;M$@8g8u4li=^Qp_+lz(|X{keI{{*>qQ_ubso z_?PEnn1k{!&!^ws{^j}f|K=(CU!KoCnwy%><@xNRxhenhd<=6?{^j}9_4Y5%XCF6D z`FxY-Q`hDx??-t)`?&wTpYOxv`P8*}$GYYD^qXAIev{|Z|ML9H^O^tVBj+#AXFcVO ze|bK}<{ht-=d=EDJ=b5J&%Vp^FVCkBHy`;tm*;c8$Q%Fie2mRIUMJ6|Ub&w2%JbPr zdH&`3)Vuk}dgb}-qrCAi&&Sxj<8|_U`dO}LKg;u}OP+suKK;D;$bOdRQ05dJ<@xOI<|Fr4o=@M(8~^frjLkb1W!{wMv+tXyoR2)8 z8JL@z&*k~d$J~^Ec|Okvb5s81`OM$klz(|X_mR0N|MGkckMl40yzk*RPc6@99n4LQ ze|bLlg}EvJ@_g3K+?0QLK8Cp||MGm++1!+Wc|LWSoANKuXJ5=s`IqPO{4qD>U!MOM zUrjzeZ*KC~-(}=pwLG8a%;qWkL7vY%KVL`Y)Av;JeAaFAl=r(lpYhB=ev9Yj9$S|@ zpMI0)Q}5;}>y_uzhvufnzdZluru@tEF*YB0Uhc8K*T@^6ev{|Z=jNvT%k$aa%~S5L zJfHpDJmvn%^O?csBhSk{wqAMjr(StJ`)h8>zdWCM%}x22=d+LIru@tEF*fgbUhc8) z^W}|Czsd9Ib9w&d`OI_kk?-^6`K+6~@h{KE*u3L;xySaEyzyCoc|Q9t&%ZpM{@i?I zf6DW@FXWAXc|OMG9nZ@>wqAMTQ?ERqeU#^4o=?4-kE~ao&pyf<|MGl{%{!i#du%_; z8=rob=TnzF|MGnLdGnF|EYGJddE;N6kFj~j^Ky^fUwPxRzw&(gR-S)(KKr}*$o-Y) z)3@@*zdRpf^N#1`9$T-x@u^py&pyiYFVCmm%}3TN&u1UyjemJQ#^x!{%RP3yzdrL> z=gm{T&y=rkZt8m&N1o66n49u1&u1KSQ~u@o7@McOPM**AZk{s#%JX>+Y@YIci#(rs zZk}>I<@wx4o2UG}L!M7%du+XOKYdTTd1`q+>$7>v^^xauUu>T8_X2r7>$!Q#^_1sR z+2$$hmFKhmo2OiVc|P@Sp0ZwfKKr$K%Keh(^PJf{<@+3Y{!`i43g`3T`KHV1j^r@Zy#{*vo?f64RN$IVkd-{kr9?dB=(M|u9uP0i=>e2mRIUMJ6| z-{gAsn>?RBm*-!e&pbCD`95Es&w9!m|MGl{%{yKv&u9JRdal1bpMH?%U!G4NZa(sP zF3;!hg}m`E&&Sxj<8|_U>XqwRuRNc9l;>ZbPraLutXH1TKFS;a@_dZVJ6ny5#wn=hM%dkL+i8K6S|(|MGl{%{yKv&u4$-dhV}0pT3pnU!KqYZa#8<<@xlj zyzwv3$Jo5%b@F`bmFrorJfD4(=U<*ry_=7$SDw#4${YXkd<=6_{^k09uD9G{fA=vr zdEN5$%}wje^I4zGQ|3*1KKs6T%K6CinSr^f`COjQe9TSxm*?|*FgN92p3nTvP5GDS zb03+T@-NTF@Hqc+&-)&J^VITu*1_D=_?PE%UznTnFVAP)%uV^1=VO?g@-NS4oy|@8 zm*-QLxhenheD=lMlz(|X&mVJB{^j|P@zvzh^P7+Sy+-a;%e~%x-#oQEpLu@1j?Aa; zspR>r+vX|ncX>YJZ9ek6++*vKJFDgSJXbeQS+6{wJ~THq{^j}necwFg`%-y6Bl^2i z<6oXnU%may^Xc>7?^Epi<|+Hu+|>Hh=knI`=BE71^D#E>cwX+Y@AKu2Pru3Yd9KRy zFVAP5n~&^Ic|PkVZ~V*iF*fgbUhc8$FK>L-U!G5&%kwYK=lQew$mfqdpZi7L_?PEn zY~Jy_++*vNH$L^s^Vvsv{^j}9yZOj^<@xNRyzwv3$Jo5%dAY~-v%K-?XL&w#$@4GI zr=K?;+0XKP>XJA9<@p$!cRVlm*!`6^KKm=rr*Gx?m*=y;n~&UIc|LtBZ~V*iF*fgb zUhc8=${U}0<@xNRJpb~1>fL-~z4CnaQQr8M=VNT1^1R$*$NTFupLO0m<@%JbQ;%~S4|JfG*x<|*Ij$n&4dzE(J&56@@)H&40#@_e2%o2Tptc|P<1 zJm1@FF3)E@%}x22=VNR>@;Z4w^~&|ESDsJ3=BE71^XbpcQ}(AkpTF^FHn{V&hIJfHb*K63u@eAZ3g_?PEn zY~JxYc|Pkb*YkNO&u8D|`IqO@hntUlp3C#OU*wH{c|OMG9j}w;Q?Fdldgb}-qdfoe zeCpkNWWDly_EFyWm*-<_-tjtlKK(4$v!CVp)FscqJfD8vd}Ke%^QlYT_?PEnY~JxY zc|Q9q*K>d6`Sh(k|MGnHck_|^E6=BI<&A%NKE~!9uaoCfuUyZ1<@xNRJpb~1>fL-~ zz4CnaQQr8M=VO?g@-Nr-bG_vr`@4_1$?KM{Z*E#&p3nMho-%LB^V#>!Q_e@8&kW2> z&FAub=3{QkzdWDkgSjdH@_goRZpyzrpZmz%lz(|XhR6Ard*1i(o2QoNvkvB_#=ktD z`@-Cme|bLZW^T&AJRif{lz(|X>uheyzdWD1%uV^1=d&;7ru@tEdH$H2@-NSSjISo2 zp5J`r?=o_)TJH7kySXW!=Z`#}d49f{eEObBp3k~%p7MT|=QEx;$Zzqy++*vK=hJWU zeCpaft;2!R8~+%RT=6-%qh#zUMbLwLbK@y#2jA|KEAa_xa|geC`){<6oYSv3bYya*ypR zdE?WE@_hPSo_~2h{ki$b{*>o)U&tH(@_dZVJD!(&Y`yZvr(StJ`zX)9JfC_uA6c(F zpM8`!{^j`?n|C}f_t?IbH$Kl#c|LW?^Doc;cb>AJ%}x2#C2#!8^D#E>cwX+Y`zvpJ z_E(-y-^%kZ&u4!(AGyEseEL@2_?PEnY~Jy_++*vNH$L^s^Vvsv{^j}9yZOj^<@xNR zyzwv3$JjjOdAY}q_t$4W>%4i&_nGqb%}sp|fw#U{h_tW1UHcu_jXMHwLxjyoI z?u*S+{$3!@XFWGhxt{WTD%(6|z4Cn4fAf^dCK?s=B9ksQ{H}Eo{zD4$Lr+z^p#xC=b=2G zeV6B7o=+ccKJs}k&*y%TH~!`M7@K#zPM%M_ay{#n=d+LU{LAyHck_|;%JbPrdE;N6 zkFj~j>*V=7C*^wneV6A`mpuRS{D0>u``O%-PhIlHzdRpf^N!ca^Vwgyp8G4$r*Gx? zm*=y;n~&UIc|LtBZ~V*iF*fgbojjj<<$BgD&u1Uy`IqNY@8%=xmFKgM^2WbBAH&>~ zf4RP&>n-=#-+jzYUblRGbJP0reAZ|4lzCI0&%SS-az65WW?*h=K9}b+A9GXw<@r1x z%uV^1=QDqEQ~u@o+(+i7{LAw(JkGz|^S+1QJheQZbuc$I{^j}H7v`q?%kx<`b5s81 z`55M={LAxMXLD2j<@wZQZpyzrpM5bm{N^KnuaSGza<6ya zH%~3kXP%$0BlGEdDtSKZwt33?U7pW)n~yv%_t?7R&T4r+&(+OS)+^7a4}ZT;vG3-r z)`$JwJmvn%^Vy-zN1m5^{QG^1_3}Oc<|F%DzWpz6J^!7je4lS_%IAKOH~!`M7@K!I zFZbBzhP?6VH+eqKReAp9`Sj=JBl}aH&))@k<6oYSv3bYya*wT7-uToj&*$%^Jpb~1 z>fL-~z4CnaQQr8M=VNT%@x0t)`&QogJXhuU)FscqJpbQ$%6>LCt;|TY2MOo{zD4$MbTJtykXo)GNa5&-_2n_coi$^I1=GQ~u@o7@Lp0PM%M_ zay{#n=Ton_DgW|(`f&4<_q#lwzwf{Q`ziK!^OWmtZt~bqdF#pjCD-%*lIOFJzu%|0 zFE&s4-hT7Z@?Foj&pONV*`dul?wdTH=Z0L*=b=2Gevs#1o=+ccKJs}k&*$%jyzwv3 z$Jo5%b@F`bmFrorJfD4(=U<*ry_=7$SDw#4${YXke2mRIUMJ7z`6<`)`6 zI(a_z%Jr;Qp3gqY^Dob*-pxnWE6-;i<&A%NK8Cp||8jjl*IVwfzx$Y*yl(mW=BD-K z`K-_8Df6a0pMBpv<$UD%%)s2#d@j#tKIW$U%kz0Yn49u1&u9MTru@tExsS|E`IqNo zc$|N^=Y0?V`+bV_-#ld>nwwfr`a#}$vM=VQ{LAxs{+OHcFVBCBuO^?K-+bizYPnY} z_j>!m+?3DrN1o3-KVMBgeNQFNXWceWxz6%@#xn=`EuNQqY+dqvp3m}p>e@WzI>__? zou_>7x_Qd?qMN6dH$F4=ztd~}m*>-0Z~yXq`rQAnukkO>XMg=2D*y6)_Sf8$e|bKJ zIVk_~eCm4pm*=y;o2T4gc|LXR|33=*S)R|o-~9hO(flvZ$1vCAU!G6Dz5UDc>GQXL zc|P+r2Q{C|^I6Zge|bJ5Zr<^{++){S-h9{>c|Q9t&%ZpMKHPld^GBY~eIalB%kwcd z?|5GBvGvLupL*r_?4vyY@_g#ud}O`yeD+b^_?PEnY~Jy_++&}U^2Vp1<@wYl&%ZpM zzTJG}^H!cuUGm1iJRf88j_2hbyT9_rXMg4S^sPMq@_hDp^O5^2&!=zYjemJQ#^xQ* z%RRPUdE-;BJfD4(=U<*ry_=7$SDw#4${YXke2mRgo|k*_(?_&Zeo<@v1V{`Y>ar#zn#{T-_DFVAQF z%}x22=Ton_DgW|(_G|N$`z6okIkS1n_c`+XX9nM9a{kxD^I7N3Q~q8f&*wQ~Zffky z^O^tW`QH4?^I11@Q~u@o80Mh-%k!!C?O&cxUFN37zdWD*G&kj6p3mR+%~QTFmFF|! z<|DsHo=?BY_3Sr!K7GD<%IA+fpMBgsWq-=^*~iUOJ|E=y%y{#Wb;$FnSFUHh@_hEu z+?0QLKJ}WL@-NS4e>YFLzw&%W+`QxW$n)tdxt`BMc|LtE&%ZqX=BE71^I5meQ~te> z=QHBw9luAO&pONX>^FHn{UFc3JfHsDd}M#h^SNK-jemJQ#^xQbljl>fT+e#t`Rt=S z|MGn5-F#%d@_hDJ-uRd2V{G2>I(a_*EZ4K2<@wYl&%ZpMzTJG}{V30;E_vf$o{zD4 z$Lr+z?5|wU{gvm_xAOeU^V#3cNA9mYpT3nh{^j`?n|HiUo=?4UJ?oX{vybxp%k!ys z^O5z+^Vvsv<6oYSVQ$L5T;I?2mV4~)KISH`TfV-zX?=M<>$7>vyeZFT-#1S=A9+4A zFgG=y%k!C!xhenhe4Y>Hru@tEnZLOy|MGn9BXd*!<@p#M=U?u5-_vfMTAt53n422^ z@_g=#%~Sr4AkSyr%uS7dc|OMGDbLG2wof)sEzhT}%~STLJfD3rH#Psu^LhT5oANKu ze~hmtpPt`*JjemJQ`)h8>zdWD) zH8}PpC`)F=z{+H)tY~Jy_+++Jn-uU#P zJfG*SJpb~1=4lSfzdWDyeEXN@GvekQ&&xe_o#oAkeUaz0@ACZ1^XbFQM?Qb#`P>)s z#=krtWAl#Z1<@(6; zxi8F3&cokFsn^`p_?PFiUz?}gFL^%Cnaxwa z&ynXpGx#=>^S>UR&-!nka{cA`JZCmf*$?u3=Kp!Vx4B%N&$^kL@-NTF*nH%5@_g!* z>shZnpL)$r`IqO@pXR3g%k%mBzIn>`rSg16+I5sXCF6D`FxP)Gvm!i)*;WQUb&w2%JbPrb5s81`P6G}%D+6H{oOp}{>t+iar2Jf zBhRO=Px*Y1=QHBw9luAO&pONX>^FHn{UFc3JfHsD zd}M#h^SNK-jemJQ#^xQbljl>fT+e#t`Rt=S|MGn5-F#%d@_hDJ-uRd2V{G2>I(a_* zEZ4K2<@wYl&%ZpMzTG_K{V30;E_vf$o{#bV{pj+1_V?{yo=@Mt{mb*&-_1wvuRNc= zl~?cO`52pbyiT4^U2;A9S)R{6%JVPJr{2v+)+^6vALWgIc|L}@DgSbPKi6CCvANaU z&u4u$PnkF6`Rx1VDd!{4X9nh`=5u*I^D#H&U!KqN!Q7O8c|P+uH|1ZR z&wXTW%D+4x!{hwRJ@0$k%~Q+sSqF1d<6oZ7ePM3OzdWCHGdJa5o{zD4%JXuM?GtlT z{N^Knmyvtba<6ya%}x0{f8_bh z^Yhi@)Av;JeAaXGl$JQm!r{CoH)U|oab&%)NhnuH-?<&vd@4LCF z`COilVGhc_JfFUL`%kwcd?|5GBv3(_PeELwHPoK;4FVAP5=Ait`^I6Zge|bJ5 zZr<^{++){S-h9{>c|Q9t&%ZpMKHPld^GBY~eIalB%kwcd?|5GBvGvLupL*r_?4vyY z@_g#ud}O`yeD+b^_?PEnY~Jy_+++J$-uU#hJfFJc`IqO@x0{cCzfZAp{`+V1)biGo z>o)IrUhc8|EN{Q)XL&yRD9^t05c@U!IS#dCK#0j~(x?&wQR6|MQ={ z;_~&)O~gSW^S@h zKjrzXzqv`z^_S;UuemAz@_hDd^OXA~&*wR_dCK=W^89B8-)3_D*TeH!|IJgbzdWDk zjJc_?FVAQGpXYn?FVAP)%uV^1=VO?I@-NS)-nV~wK6RO!8vpWq`qSK$e|bKC-#1VB zzEqyih?|f69(g|fCfBpy}0UU@$ID{uVE^D#E>c%3|-ewORm&+>fglILHZPv35y@_v-(Q$@_hcjo12=?<@p%qp#018>8rPYc|Lt^Zfg9?^Vwf>Q~u@o z?60{g|MGkcb5Q=}`PB9HFVAOxH&400@_g#rJY_%2^VvspQ}e$(A7k^5=j9&TSMtWE z59RqhSLOMa=QB@pQ2yoltmoUmJf9Ia?|5GBvFj{vKJ1G;pM96-U!G4NZa(t)BhTl) zkT?G2`52pbJTLdydgYBzz4CnaQJ#N!KJ{)svR-*U`zUYx%kwcd?|5GBvHdJ>eEM0Q zPhIl-%k$~m%}2lAr&u}voxFK!dF#n_n|C}f_t<`xw_o(LJfD4(=U<*rKW{#=pXK@V zt-SFs&&Sw2<$1Zsj`!DRKF^KKQ@+oXuWxSZdl*Na&-$2~@-NS49CK6t<@p$!r@T&{ z&-ZSgGXKi+c@Auz@_maupLuScay{kw{9V{Q<@;E9K9%jU^~(M9z2fGn<@v17<|)@l zp3i-;dCK2Ms|=&-!nka{cA`)N5{XTkGp3nMko^t)=`8;PfPuUOheCGdozPGttp3i!koANKu$Jl)2b@F`b zmFrorJfC{aP5GDS)1T(1{LAzC`@VU~_oecDM%;Yl_sH|@GKm*=x?o2Ps}$nzO-^N!ym&u5+GdiI+}0UU@$ID{uVE^D#E>c%3|- zewORm&+>fglILHZPv35y@_v-(QzkX_m*=xSo2Sg1@_hDv^OWwx8wg7yT^HXCLMHm*>;Zn~&^gc|LtBZ~V*iF*Z+mUhc8u{q>p8b7S+A?=$7= zo16L`#*yc+?0QLKE~!LuaoEVy_=`Zzw&&Z1DmIO-y+Xvo|~s!PkBCn z7dB7%K31MjWqWMBazA~qxOr-MKI^l2%Jq@wb6;$p^7jIHKI^%8%Jr1zQ`zPz>y_uT z{+p*Q8DJfFYso2PtVD$i%c z%}0KZJfD7(>)CJeeENU$l>INyXCF6D*`M-!_Hpx+_lrEA8E-za4tYNH%Jr;Qp3gp- zoANKur(SbY{^j}X@8&7@SDw#^n|J&kc|Lt5*YkNO&!^Aj`IqP4+?0QLKI^u5%D)%# zd`8^7shZnpM8|) zU!G6Bn~$tlp3nZu8~^frjLkb%k$YsdH&`3)Vuk} zdgb}-qrCAi&&Mz~tJqb{LAyX zFU(E(m*=x?=BE71^D)d#`IqOj&gQ24%k!zr+?0QLKKo*B%D+6H=a0E5|ML9D_-gX$ z`OQcEUL*Iafs(cIMhFVDx=yyJPf$M%)H@##Z(KF?Ko z{^j}1(;Sq4c|Pm;_Ak$8#LYXNmwW6w%bO4TBF|^v<@uNA(}$aneE!Juxi936e|bK} z<{i(=J+@wX<5RCZpM8|)U!G6Bn~$tlp3gqY8~^frjLkcqmwRkK%Nw75mgiHKJpb~1 z`gZft@AoNI&VMIwo?6~|a^2<~&&xfwpXKcr{VdOCALaR%=hM%dkL+i8K7A{1{LAw( zHcxq8?y=+j^_kCeWAl{nGv(`>oBAHck>|5M=BE71^BKq7lz(|X#^x!nljrljo2Sgb z@_e2Ho2Pu=BF|@@o2Oh)c|Ly^Hc$CJR-R8~du+XOKYg#bd1`q+>$7>v^^xauUu>T8 z_YrwM>$!Q#^_1sR+2$$hmFKhmo2OiVc|P@Sp0ZwfKKr$K%Keh(^PJf{<@+3Y{!`i4 z3g`3T`KH#jXa1k(dz;PW`K+h8DgW|(jLk=0C(ox|xt{gP^QqU| zlz(|X{b_E>zdWD6@0+K5UnXPf(&+>fsQJ#N!KJ{)svR-*U`zUYx%kweJP5GDW`?=n7kIk*-Ca+t*zPV|A zc|Pm2dCI&g&u8B^PdOiXJ~J>kHJ{7#nUA?C|MGmE59X%)%k!DPxhenheC{K2Q~u@o z7#`zdWD)H8}PpC z`)F=z{+H)tY~Jy_+++Jn-uU#PJfA+7=U<-BJk3G*m*=ydZ~yXqM%=vPdAY}~v%LAR zFY@x0t)`&r(8 z(a-XH_EDaHc|QHT`N)2j=hL_H#=krtWAl{fNZe=m^dv!0u$Tu*sEm2IA~UU@$2zj?~_m*-RO z<|*ry=d)j%r`#`jKF^uWQ@+oU=RcKwt#Cdcp3nMko^t)=`8;RLO^tqeKJ))P-_2%D+4x!yJ@-;=BE71^ZEO}dCK>t@_a_zeB}4Y^XWIa zp8Y1zr~fxk+5hr<_Hpx+{VC69A2&~VzsU2M@#Z7zkmpmcT+e#t`Rt>)DgW|(>NPjz zU!KqYZk}>~<@t=bdB^XO=hIhmJ)ej2eEM9Te|i4RP5GDSvu>NG{CgqKXT;4revdq# zb(ZVdZ}NQlL7snkKK;4*$o`b)bHB(N|MGl{%{yKv&!=9wp7qM}*++T)<@waR`N(?Z z`RuQ}@h{KE*u3L)@_hPPu4g~X^QlXoe|bKAyLrm{QJzm-^2WbBALIS|(dGH<@7upT zpT2$jm*=y;n~&UIc|LtBuine^F*fgbojjkqz1!?ZdzZS&-!ehGH=TB+4s#;&PSfl49rc<=kk2!V{Xd7 zJfG)-xhenheCBU%%D+6H`^emse|bKJ$N86g-uJYdr~e|bLZY;MZGJfFJEP5GDSvoGeR{LAxs{+OHcFVBCBuO^?K-+binHFB?7 z?)C2b=BefR%=7bgWIlaQCC_KwHcxrK%kvp;^O5J}9$S~(SuM}!xw?7Edgb}_;pQpd zyUO$V`)+P(K9}cXn1k{!&!?~6{^j}fxw)zFFVAOx%}x22=d-`&ru@tEG0Z{vm*-R0 z+rK=Y{oOp}{>t;IYx9)-EYD{j%}ve!@_dZVJD!(&Y+uP6pFWi5^IVnZU!KoA%|ZE> z=d+$~|MGlB+`Qv?xyP=vy!o&%@_hDPo_~2heYp9^=Z`#}`$FFMm*-<_-toNLW9yYS zKK07;*++T)<@waR`N(?Z`Rt>-@h{KE*u3L;xySaiyz%L0c|LW?^Dob*Z#N(PexG9H z{CD!^spYLF*KOYMyxe2^S>Arp&+>fsQJ#N!KK;D;$bOdR)3@@*zdRpf^OWc19y{J& zpZPpDHc$CJQ@*~rsqbMNc|Pl7ZpyzrpK;7h`IqNoY@YHuc|PB}dCL4N&*wR?dCK=K z@_gpGdCK*a=ks@A^OWyn<@r>$$JQ(N)Ax#-rshZnpL)$r`IqO@pXR3g z%k%mBzIn>`rSg16+I5sXCF6DdB4c>nepZ$ z>yYPDuUyZ1<@xNRxhenheCjnf}G_ay_4i@_hPVo_~4% z%}x22=d*5`r+hxh^BHmTj^88CXPxDG_M1GPevs#1o=<;nKC(aM`P?t^#=krtWAl#J z$@8gKu4ldSeD+bEe|bLjZa%VJc|Q9qZ~V*iF*fgbojjj@mh0Ki@_g!&=U<*r-)^4r zew61^m%Q;W&&PQGesp<0`}_7U&!=zS{^j}X@8%=-SDsJb%B%PCe2mRIUMJ6|F1eol zEYD{j<@uNAQ}5;@>y_uTkMhR9JRif{lz+LtpX)96*xYJv^19{go14~`=d(VWr_7u3 zeD;0wl=G42GXrx|^SL~q`IwvXFVE-sU~bC4JfHcSoANKu=RPtw@JF_t?7R`ShDSpSm_rxeoGt`f&4-0Z~yXq`rO>q z_?PFizvia=%k$Y^b5s81`55M){LAyH>+N5j&;D+na)0Id)U|oaewOF6kLIT4e|bK} z<{i(=J+`mpjZYuS^XYSW{^j}1(;Sq4c|Pm;_Ak$8#LYXNmwW6w%bO4TBF|^v<@uNA z(}$aneE!Juxi936e|bK}<{i(=J+@wX<5RCZpM8|)U!G6Bn~$tlp3gqY8~^frjLkcq zmwRkK%Nw75mgiHKJpb~1`gZft@AoNI&VMIwo?6~|a^2<~&&xfwpXKcr{VdOCALaR% z=hM%dkL+i8K7A{1{LAw(Hcxq8?y=+j^_kCeWAl{nGv(`>oBAHck>|5M=BE71^BKq7 zlz(|X#^x!nljrljo2Sgb@_e2Ho2Pu=BF|@@o2Oh)c|Ly^Hc$CJR-R8~du+XOKYg#b zd1`q+>$7>v^^xauUu>T8_X2r7>$!Q#^_1sR+2$$hmFKhmo2OiVc|P@Sp0ZwfKKr$K z%Keh(^PJf{<@+3Y{!`i43g`3T`KCcE`hWA3 z{V&gFA2(0gpYnY6ar2b-i#(qhZ$7dPc|P^Z^{iK(&pw))@-NS)UUO6a<@xOI<|+4A zp3jJzcl;iCK7A$E^LZ%Gr_bg2m*?Nylz(|X>$Z8yzZdd+M%=vP_sH{EXStsJCeNoI z`!?<_lvyoFVDx=yyJE9eCn0!S+6{weU#^4o=?4-kE~ao&;H6A|MGl{ z%{yKv&!?Z|diJwCpStAvm*>;Bo2R@V<@wYlZ~V*iG2Xu)U7pYWzWvMd>D#w|c|QBQ z`N;j1=hL_H>b*Q4WAl#J$@8g8u4g~X^Vvsv{^j}9yZOj^<@xNRyzwv3$1peLU#{=x zddodFx0;*0Zu$D=ruF6dtk32t^QJtXecwFgeB}Aez}(b)F3)E^=BE71^Laj)oANKu zXa44<{LAyXkIYT^m*-=6oPW9JeNVf2YI#2EU~X#s%k#M}%uV^1=d*6+ru@tEG0aW* zm*=z2=BE71^Qp_+lz(|X`(kd&zdWDkkGU!T^8Cm6YVzs%%}4%TBloK1Uhlqdo?4#I zJU?GY=F|67@_g29^OX0yJfHD4A9-Hxv31Fv)$)9vtDC2+SDsHFZl3bJt302-@8+iF zb9p|7IVk_~eERC`U!G5&o0}T{@_hE!+?0QLKKpBK%D+4x!yJ@Lp&&Sxj<9WHq_LaQx=|g!w&sBN;<@wCh9F%`~KI{4RFVAPh z%{!i#d+a*Pn-BXU&u8D|`IqO@hntUl{>byWFXWAXc|OMG9nZ@>wqAMTQ?ERqeU#^4 zo=?4-kE~ao&pyf<|MGl{%{!i#du%_;8=rob=TnzF|MGnLcJtBi_bFD+e!EYD{j<@uNA)6bia>}PpCeJgML%kwcdPkCPMvE%*qna^`$^OWy1 z_(?Y@YJ>5qUoAxp~U{gUVNoY_3(`y6@xQ`y%F=kwwDtpDaI*I%B`b7u3D z{UFb0{-5W2o6Y6Q8DJfFYso2PtV zD$i%c%}0KZJfD7(>)CJeeENU$l>INyXCF6D*`M-!_Hpx+_lrEA8E-za4tYNH%Jr;Q zp3gp-oANKur(SbY{^j}X@8&7@SDw#^n|J&kc|Lt5*YkNO&!_+8`IqP4+?0QLKI^u5 z%IAYTpAk3j_&xG`)>*D+zsd9I2YLSG`Sj=JBl}aH&;25A{LAw(Ht%?yJfC{yde$q? zXCLMHm*-RO<|FHs=d-`^#=krtWAl#J$@A%Fxt{$j&!;YV{^j}f?dB=(M|nPV$s7Oj ze2n++N0;Zbzi}0UU@$IC~y4B^D)d#`Iqbax!!V*&8_ApuUo#pxoLfQKI^l2%DgGhXWutZIUjjG zGcY$bpUd-^kGU!T@_e2T=BE71^O?W7DgW|(?jv(k{^j`?9_L@~dEe7+o?4#II+&Xp z|MGn93v*Nc<@v0exhenhd<=6_{^j|sv$-k%@_gztH|1ZR&%T(O@-NTl`D1R%zdZjj zzM6b`e)EyP%gDWIx!1ez=B9j}Kk|I$`T1({>3b@9KI^u5%KKfO&v@n_zs2)%kF86d zPru3YscZ9;>mbjk4>wQw-c_E@-*=d+$~|MGlB+`Qv?xyP=vy!o&%@_hDPo_~2heYp9^=Z`#} z`$FFMm*-<_-toNLW9yYSKK07;*++T)<@waR`N(?Z`Rt>-@h{KE*u3L;xySaiyz%L0 zc|LW?^Dob*Z#N(PexG9H{CD!^spYLF*KOYMyxe2^S>Arp&+>fsQJ#N!KK;D;$bOdR z)3@@*zdRpf^OWc19y{J&pZPpDHc$CJQ@*~rsqbMNc|Pl7ZpyzrpK;7h`IqNoY@YHu zc|PB}dCL4N&*wR?dCK=K@_gpGdCK*a=ks@A^OWyn<@r>$$JQ(N)Ax#-rJjedDP^Zz{Gn}2ye>uGMvzdRqq9F%`~KJ~u+ z%k!zr+|>A&=hL6&ru@tE`TM?k%J-%6d`8@So)zsMW^@_dZVJ6}Z?617>FVDx=yyJE9eEM0g zXFtpHsY{-Jc|Lu+dCL1yo=;u!#=krt5<@xOI+rK=YzJ2?b=d-_?kKA8*K7A{% z-plhbHt%?yJfFJcdiJwCpM8|)U!G6Bn~$tlp3gqY8~^fr40BWd<@$cEx7=fMtGUVR zmalJaT3?>e`fQ#uZ_4x8_svtzN1o3N%uUVb@_goFZpyzrpXY*~%D+4x!`zgAc|PlGZpyzr zpSsLV`IqOjFXpEF%kz2un49u1&wq@sCZC?)eB|#na<5wM_3r!Tspa|1^Ye9NK7CIm z&u85>PkFz~^BHgRk>}+eTbJBfEzjqGvz~AN@_a_zyyJPf$F8%y z`LHkYeD+y}Z z?4!K#FVDx=yyJPf$M&y{%D+6Ham-Emm*-<_p7J_*KHs}}%KR(O=Q*%>%J(hueCD}%%Jr1z^LJtMl<#BZ z`Bb*Y)+_hZ_lldRmgloRo2OhKc|P~W<|%(4k>|6Xo2Oh)c|MhGp0ZwfKI^}E%JrA$ zQ}5;}>y_uTUz?}gFL^%Cnaxwa&ynXpm3^&nJ|CXX`fr|c{pI;QXEsmS5AuBG|9QT* z*<7B_dYYT^FVDx=eB^cVeCn0!S+6{wdd*Gwm*>-;=BE71^ZEO}dCK>t@_a_zeB}4Y z^XWIap8Y1zr~fxk+5hr<_Hpx+{VC69A2&~VzsU2M@#Z7zkmpmcT+e#t`Rt>)DgW|( z>NPjzU!KqYZk}>~<@t=bdB^XO=hIhmJ)ej2eEMIWe|i4RP5GDSvu>NGd_KtY8FBND z-y_dwo#lG=n>?R>kmp~XPk(McvOned+%NLRzdRpf^N!ca^Ql*^XT9=#_EDaHc|P@S zKC)hUKKm)FrpeCm?tU!G6jZl3afl;=~Iyzwv3$9VsKba_7e z`}Qx-r*Gf><@xOI<|Fr4o=@M(tM~GJjLkb~f4RP&>n-=#+-h#}y5;Meo7R`-vp$=r%$xFj_I>k|^O5H>19MaJxjdiw zn49u1&*%AIZpyzrpZS}c@-NTlJ~B7uU!ITQasK6=_dV_Aspa{sgSn~kFVE+`FgN92 zp3l0OoANKu$1peLU!Ko8o15}4&!;YPQ~u@o?2EZ6|MGmEKjxNGyx-;djAst=TRboK*t+ET^qV}Nx;9U_ z4)T2ZaPyS!UFG@weK$8XpUd+x%t85==hIhj|MGnL+}zaom*=y;=BE71^Vwf>Q~u@o z80Mh-%k!!0?O&eH{%)Rff93hqwRy^ZmglpN=BDOwy)%kPan$j>2rDh z<@wCh9F%`~KI{4RFVAPh%{!i#d+a*Pn-BXU&u8D|`IqO@hntUl{>byWFXWAXc|OMG z9nZ@>wqAMTQ?ERqeU#^4o=?4-kE~ao&pyf<|MGl{%{!i#du%_;8=rob=TnzF|MGnL zcJtBi_bFD+e!EYD{j<@uNA)6bia>}PpCeJgML%kwcd zPkCPMvE%*qna^`$^OWy1_(?Y@YJ> z0(m~`xp~U{gUVNoY_3(`y6@xQ`y%F z=kwwDtpDaI*I%B`bH?1%=$Gd+|IhQi`IqOjp5~_f%kweJLHU>GQ}5fqJfFJEO^ttf zKK*HK%D+6Hzweu;d|xWhXT;4%evdq#ev|9jZ}NQlfAf_6FVANmH&5B0@_hDj^OX0C zJf9hFKC%vZKK07=tXH1TKAM~IFVCl5b5s81`RwoJDfd^N&xo6M{2qBeeI?iPc_`1P z&*k}-=il6ve|bLZwt33G7xH{Y+`QxW$n#lext{$d&!->c`IqO@pPP^DPkBD~i@fnK z&&Sxj<8|_U>XqwRuRNc9l;>ZbPraLutXH1T{>mHw@_dZVJ6ny5#wn z=hL^Fr@SBK`P3zE{LAw(-oGDRp3nZi{mb*|+qZvtKKr}*$o-Y))3@^Ky*wXd^N!ca z^QlX&XFtpH*++T)<@waR`N(?Z`Rt>-@h{KEFgN92uJ7l1%RM%?nwz|C`TFLj_2v1j z&*mxfraYg0-#q1fGelz(|X`)h8>zdRqq9F%`~K6SnQ%k$aa%~S5LJfFHYPub7%eD=}Y)ch~c z$Jo5%dAY~-mAvukLwP>WReAp9`OMQClz(|X>-qLC&u7HVJD!(&>^jSv5Bnm|XW!-d zm*>-mn~!|{$n&``ZbPraLutXH1TKFS;a@_dZV zJD!(&Y(L8zpMI9-QzkYU9>$U9vp(jg{LAwh z$J~^Ec|OMGDX){~^Szs=%)jz{o&%eweBUC^XP%p-y>dT& zuefTz`2!^=_WBUU@$I zwRy_@lIQcB**xX@9C`jz+1Co^^Wpid|K=&zU!Ko%X7iN&AkSz1pXYm<&E@&5r@1Nr z@_dZVM_wn-r(U_9^~&?9*W8qUc|QGVZpyzrpTF;$r+i;3&u7HVM}ChypMI0;*>CcE z`hWA3{V&gFA2(0gpYnY6ar2b-i#(qhZ$7dPc|P^Z^{iK(&pw))@-NS)UUO6a<@xOI z<|+4Ap3jJzcl;iCK7A$E^LZ%Gr~l>om*?Nylz(|X>$Z8y=Yu?-5jXGnJ@S0kS*~Zl z$@A$4dH&`3^ylUy`%|9J{UUGt%kwcd?|7X&pL*qb)+^6vALaR%=Tq)FrpeD+bEe|bLjZa%VJc|Q9nZ~V*iG0aW* zm+Skv-g1x4t>z}LTfV-zX?=M<>$7>vyeZFT-#1S=A9+4AFgG=y%k!C!xhenhe4Y>H zru@tEnZLOy|MGn9BXd*!<@p#M=U?u5-_vfMTAt53n422^@_g$Z8y`(2*Tc;+C##q)BHtxKLyzsd8dYx9)rAkU`{H&6NA zRi4k^cXLzoxjY}k9F%`~K7IA}FVCmX%}tGec|QAVZpyzrpZzsAG zvz~AN@_a_zyyJPf$F8%y`LHkYeD+y}Z?4!K#FVDx=yyJPf$M&y{%D+6Ham-Emm*-<_p7J_*KHs}}%KR(O=Q*%>%J(hu zeCD}%%Jr1z^LJtMl<#BZ`Bb*Y)+_hZ_lldRmgloRo2OhKc|P~W<|%(Kkms|Wo2Oh) zc|MhGp0ZwfKI^}E%JrA$Q}5;}>y_uTUz?}gFL^%Cnaxwa&ynXpm3^&nJ|CXX`fr|c z{pI;QXUt8FetACg|2*HDe|bLZX>Q8DJRidxlz(|X^}hYf^Qp_+)cBX@)1T(1{LAzC z`@VU~_oecDM%;Yl_sH|@GK zm*=x?o2UGHA)CJeeELD2e|bLrx%tTcl;?B5$Q%Fie2mRIUMJ6| zUb&w2%JbPrdH&`3)Vuk}dgb}-ue|Xu&&Sxj<8|_U`dO}LKg;u}OP+suK7G4+%KK5C zPhIlHzdRq~{rl17`Rwo8zdWD5efyW^v%i~<++TSn zeU#^4o=?4-kE~ao&pyf<|MGkcb5s81`hKpr++%aAxykF6uWxQzU!KqUY@RZ2%JbRx z%~Q@tp3e--P0i=>eCA_r%D+6H=YzQ^|MGn1Z*I!JJfHi>+?0QLK8DBnmwVp#w40}v z=d%vxrpCWKpZmhxlz(|X>t=4szdRqq+?0QLKI?35%D+6Hy39@am*=xD=BE71^LhT5 zoANKue~hmtpPt`*^L1oCeNQFNXWceWdB4l^8E^BE=j9$- zm)uz`&*!GQ`g(SJfHpDJmvn%^Qmj|l>IEvXCKW?&HwUzjLkcqmwRkq z$s3yxe2!l{Y^1%JbPrdH&`3)Vuk}dgb}-qrCAi&&Sxj<9WHq_Orb4 z>1TO9b;tk-pzdWCD%uV^1=VNT1 z@;Z4w-@AFr{43ArIk0)k_bu{#=DB&w^_1uHcVY9C?_=fpRJO;~EBDj)ikqjF=d(VW zr(7R-KKI4uDSsc4=d+%hr(92YK9y~rvR-*U>%V!*^_S;U@8&7%mFKfxo2T3_c|OmX z%~QV5k>@{^eXVdlAD++pZ=Q1f<@r2kHc#0P@_gq1dA_&VT%ON*nw#=3&&Sw&XqwRuRNc6%}x22=hL6&ru@tE`TM?k%J-%6d`8@S+0XKP>XPSQo=@Lyp7MT_=Tn!w@h{KEc>jKMc|QC5_Ak$;Z{Pmq`RwoJBllOH zPv6R`_wsy<%{yKv&!;ZAp8YJ(XCLMHm*-RO<|FHs=d+LU#=krt!`zgAxxSz4E%(^m zYHsqn@i5b5rxVJfHcPoANKu=lNi6%D+6H`J0>a zFVE*bGB@R4o{!;i{^g$cJ?-YH<@v0GxvB9l&*#1{H|1ZR&$^kL@-NTFFgN92p3gd) zoANKur!I3-{^j}Xi@7QP@_e2@=BE71^B?1@$*1QxANjkC+^d#*z58x%%IEnb&u5;W zuO^?qr;_KhZkwmP-{tv?XAbgPJTLdyy5#xvn>?SoHcz<@@_hPm^OWyh<@x-5H#aq( z%kweJLHU>G(^qf*@_hQ-+|>A&=d-`&ru@tE*~ z<@waLdCGp4=d+LIrsjWnKE~!9&&xfwujGwSAIkITb9w&d`OMQClz(|X>-qLC&u7HV zJD!(&>^jSv5Bnm|XW!-dm*>-mn~!|{$n&``Zb zPraLutXH1TKFS;a@_dZVJD!(&Y(L8zpMI9-QzkYU9>$U9vp(jg{LAwh$J~^Ec|OMGDX){~^Szs=%)jz{o&%eweBUC^XP%p-y>dT&uefTz`2!^=_WBUU@$IwRy_@lIQcB**xX@9C`jz+1Co^^Wpid|K=&zU!Ko%#@y8C zm*+G8&-1zdWD6@0+K5UnR z@_a_zyyN%C^I2!Pp8Y1zryu0`m*>-;n~&^Ic|P}xyzwv3$Jo5%b@F`bmFrorJfD4( z=U<*ry_=7$SDw%Q${YXke2mRIUMJ6|pXGY?vpk==}Z?4!K#FVDv?H|1Zh@8^2UJvO(Ro4juM`sSwf<@v17<|*^0JfD5vJmq}k`OLuF z)O;?_XFlep{LAxsKA4;GFVAQG=BE71^SO`AP5GDSV|bi@x#xXPyLoDPKI>p^YW&Od zxi8F3`IqOjZsw-^%kweJP5GDSv(DzG{LAyH%iNTIc|QAMZpyzrpXZOcDgW~P$M|aU z>G{n^{$3;Zs^wnqzHgpdp3gi#Uq|NC_f+zH)@}2Y_q#lw@irfMUhc7V$(_~me4eYD zr>s|=Pakfc^1Z7(pTFg`{iPoJBc8vpWq_Sf8$e|bLpYi`QF zJRidxlz(|Xb-n$|^V#3cQ|_-kpSm_r+0XKP_R-wb{4dYP*u3L;xySaEyz%Knc|Olo zdH&`3%+nl{e|bLZ`Svf*XT;4ro|k*wx8wg7yT^HXCLMHm*>;Zn~&^gc|LtBZ~V*i zF*Z+mUhc8u{q>p8b7S+A?=$7=o16L`#*yc+?0QLKE~!LuaoEVy_=`Z zzw&&Z1DmIO-y+Xvo|~s!PkBCn7dB7%K31MjWqWMBazA~qxOr-MKI^l2%Jq@wb6;$p z^7j#WKI^%8%Jr1zQ`zPz>y_uT{+p*o)zsMW^@_dZVJ6}Z?617>FVDx=yyJE9eEM0gXFtpHsY{-Jc|Lu+dCL1yo=;u!#=krt ze`fQ#uZ_4x8_svtzN1o3N z%uUVb@_goFZpyzrpXY*~%D+4x!`zgAc|PlGZpyzrpSsLV`IqOjFXpEF%kz2un49u1&wq_a zlTXiYKJs@NxmPXsdiUMjl+W`=p3gjgk0zhKr;_KhZkwmP-{tv?XAbgPJTLdyy5#xv zn>?SoHcz<@@_hPm^OWyh<@x-5H#aq(%kweJLHU>G(^p^r@_hQ-+|>A&=d-`&ru@tE z*~<@waLdCGp4=d+LIrsjWnKE~!9&&xfwujGwS zAIkITb9w&d`OMQClz(|X>-qIB&u7HVJD!(&>^jSv5Bnm|XW!-dm*>-mn~!|{$n&`` zZbPraLutXH1TKFS;a@_dZVJD!(&Y(L8zpMI9- zQfw zR^IrR=VNT1^1R$*$NTFupXbKrDc@(x*EcuyJ&YsIXMM~~`IqN2j=3rS@_dZVQ(h;} z=X*C#nSbT^JO?&U`MyP-&pbCzxt{WT{w{2u@_np4pUU>wdgXrlUUBo(@_g23^OWl& z&*#3_Jmv2N@_g2F^OWl;&!@7@Q`RfbXZ<%%x&HEe>fJnLz4CnaYx9)*CC}$Mvw6z* zIr99svd0SN^X2)h|K=&zU!Ko%#@y8Cm*+G8-}}A!m*=yd=BE71^D)dp`IqNY@7KRP zpSsLVjemJQ{b_E>zdWD6@0+K5UnR@_a_zyyN%C^I2!Pp8Y1zryu0`m*>-;n~&^I zc|P}xyzwv3$Jo5%b@F`bmFrorJfD4(=U<*ry_=7$SDw%Q${YXke2mRIUMJ6|pXGY? zvpk==%k$~muYY+y`@8wb{gvm_xAN+} zJRf88j@QZasY|YBKg;vkM|u9``P94l$a>}Z?4!K#FVDv?H|1Zh@8^2UJvO(Ro4juM z`sSwf<@v17<|*^0JfD5vJmq}k`OLuF)O;?_XFlep{LAxsKA4;GFVAQG=BE71^SO`A zP5GDSV|bi@x#xXPyLoDPKI>p^YW&Odxi8F3`IqOjZsw-^%kweJP5GDSv(DzG{LAyH z%iNTIc|QAMZpyzrpXZOcDgW~P*LXDf^!(-{f3J~y)pD@OY_Om>n zeKa>U|I70+Ht%>|?y-F(Z+!Ytp3ieto_~2h^E3zLU!Ko;e*Mey8FBND=j9%|&hqBN zzR2_0cX|Hh`SjuDBcDI=eC`W*<6oYSv3bYya*wT7-uToj&u1Uy`IqNY@8%=xmFKgM z^2WbBA7k^5=j9&T&+^8npXK?~CC|S+pT6CE^#AuMR?h#EH%~2ZJ-Kf4j_2hb+t2d$ zi++~pvybxp%k$~y%}4gLJfFUmH~!`M7@Ma&FZbB-{`$=4xv_c5_nGqb%}sp|1<@(6;xi2E|IJgbzdWCM zH&0owJfHpAJmr4L^Lfr}p7MQ;JpZlivBLR$c|PmEdCK*d=kuJ|JY_$~^O^te{oZDC zc|PlDZpyzrA7k^8*U9s#SFUHh@_gzwH|1ZRPk)-5@-NTl@B8K{-?TX-#lgi%k$aC%~STLJfD5sJmvi&&u7M)kE}zUPrY(I>y_uTkLITQ%k!z% z+?0QLKKr|Q%Keq+GvekQzek==U&-}+9?J9Se|i4p`8PM^U!KppZJzS^AkSyS%{zXN zJfC%z>)CJeeELD2e|bLrx%tTcl;?B5$Q%Fie2mRIUMJ6|Ub&w2%JbPrdH&`3)Vuk} zdgb}-ue|Xu&&Sxj<8|_U`dO}LKg;u}OP+suK7G4+%KK5CPhIlHzdRq~`}@)5`Rwo4 zzdWD5{rZ>Zv%i~<++TSneU#^4o=?4-kE~ao&pyf< z|MGkcb5s81`hKpr++%aAxykF6uWxQzU!KqUY@RZ2%JbRx%~Q@tp3e--P0i=>eCA_r z%D+6H=YzQ^|MGn1Z*I!JJfHi>+?0QLK8DBnmwVp#w40}v=d%vxrpCWKpZmhxlz(|X z>t=4szdRqq+?0QLKI?35%D+6Hy39@am*=xD=BE71^LhT5oANKue~m|zPtR{Y@^=}z zS1tE?_ubr-&+|u~&pdyRCZE2ilIOE-o2R_r<@ttK-)G9#H#hY?j3duyeaubym*+E%xhenhe2mRgUMJ7zdpA#+f93f+ z2R2XnzD1tTJU36dp7MPDE^MCieXKm6%J$fL<$n5Jar4yjeAZ|4l=d+&Xru@tEG0Z{vm*-RO*S|cUy39?De|bLr zX>Q8DJfFYso2PtVD$i%c%}0KZJfD7(>)CJeeENU$l>INyXCF6D*`M-!_Hpx+_lrEA z8E-za4tYNH%Jr;Qp3gp-oANKur(SbY{^j}X@8&7@SDw#^n|J&kc|Lt5*YkNO&!^Aj z`IqP4+?0QLKI^u5%D)%#d`8^7shZnpM8|)U!G6Bn~$tlp3nZu8~^frjLkb%k$YsdH&`3)Vuk}dgb}-qrCAi&&Mz~tJqb{LAyXFU(E(m*=x?=BE71^D)d#`IqOj&gQ24%k!zr+?0QLKKo*B z%D+6H=a0E5|ML9Tcr^L+{N^KnuaSGza<6yaH%~3kXP&>uk@@sJl{}wy+dSp{F3)GY z%}1V>du&~DXSF<^=j!Gu>y_uzhnuH-?<&vd@4LCF`COilVGhc_JfFV$`j_X^=jNuy zzdWD)H8%kwcd z?|5GBv3(_PeELwH&vR9te|bLhGzaBhp3i!I{mb(iar2Jn z^Xcc!NA|NkpT3nh{^j`?o2NW4_t^3N`poCKv3bh(nez3`O??mJ$n#krb5s81`HW+3 z%D+4xWAl{P$@BT%%~R%Ic|Om9%~QT_k>@kd%~P(YJfFV{o2PsqE6=C0J+@xCpT1Yz zJheQZ_1Qe-`pEOSFE&s4`-nWB_1rw=ddl;uZ1a@$%JW(O%~P(wJfC_uPg$=#pZ(fA z<$lTYdCqK}@_mjx|E=t?!ufo8KI^}E%JrA$^PJf{Wk1OCng8$o-ez-oKI>_2%D+4x zWAl;M$@8gKu4ldSeCjnfdP4mFKgM=BE71^QqU|lz(|X`@4C{ z{gvl4;^rN{N1jh#$@P35%Jb=edH&`3H#g;9p3k~%p7Qx1&u7HVJARKmpLLe&*>CcE z`azz5c|QHQ`N;m1=X1Zv8~^frjLkbc%3|-y5xHHvpk=Dl;>ZbPraLutXH1TKFS;a@_Y<)Q~u@p zey+FNV{@yy$?KM{Z*E#&p3nMho-%LB^V#>!Q_e@8&kW2>&FAub=3{QkzdWDkgSjdH z@_goRZpyzrpZmz%lz(|XhR6Ard*1i7o2QoNvkvB_#=ktD`@-Cme|bLZW^T&AJRif{ zlz(|X>uheyzdWD1%uV^1=d&;7ru@tEdH$H2@-NSSjYpGD&u>2RcNw`?E%$o&-Q1MV z^GBY~Jb#ZSpT4J(=d*5`r@Y_g`HW`{@>@JF_t?7R`ShDSpSm_rxeoGt`f&4-0U;pxa`rO>q_?PFizvia=%k$Y^b5s81`55M){LAyH>+4^h z&;D+na)0Id)U|oaewOF6kLIT4e|bK}<{i(=J+`mpjZYuS^XYSW{^j}1(;Sq4c|Pm; z^)Jt7#LYXNmwW6w%bO4TBF|^v<@uNA(}$aneE!Juxi936e|bK}<{i(=J+@wX<5RCZ zpM8|)U!G6Bn~$tlp3gqY8~^frjLkcqmwRkK%Nw75mgiHKJpb~1`gZft|KF!rIsZ@I zJhi;_ocF{ z#^x#CXUf+%H}yS?BhP1j%uV^1=QEDEDgW|(jLlPCC(q}5H&2;=<@r1ZHc$D!MV`+* zH&3~q@_ha-Y@YIctURB}_Skyme)?W<^VITu)@SpS>m$$SzSunF?*;OF)^qce>nYEt zvdvT0E6->BH&40#@_g#uJY~J|eD-Vel=~&m=Q*=^%J(_){I{~l3g`3X`KCcE`hWA3{V&gFA2(0gpYnY6ar2b-i#(qhZ$7dPc|P^Z z^{iK(&pw))@-NS)UUO6a<@xOI<|+4Ap3jJzcl;iCK7A$E^LZ%Gr_bg2m*?Nylz(|X z>$Z8yzZdd+M%=vP_sH{EXStsJCeNoI`!?<_lvyoFVDx=yyJE9eCn0! zS+6{weU#^4o=?4-kE~ao&;H6A|MGl{%{yKv&!?Z|diJwCpStAvm*>;Bo2R@V<@wYl zZ~V*iF}}YaU7pYWe*Mey>D#Y=c|QBQ`N;j1=hL_H>b*Q4WAl#J$@8g8u4g~X^Vvsv z{^j}9yZOj^<@xNRyzwv3$1peLU#{=xddodFx0;*0Zu$D=ruF6dtk32t^QJtXecwFg zeB}Aez}(b)F3)E^=BE71^Laj)oANKuXa44<{LAyXkIYT^m*-=6oPW9JeNVf2YI#2E zU~X#s%k#M}%uV^1=d*6+ru@tEG0aW*m*=z2=BE71^Qp_+lz(|X`(kd&zdWDkkGU!T z^8D9$H2L)W<|BWvk$cs0uXo=!Pc6@9p1;SD`Sd-NJfC&jJmvi^&u6^NN1m5^Y+Z6^ zwLG8a>gFlymFLrko2Pv5D$nQdySb_PT%M0%4$8kgpT7F~m*>;x=BCEKJfHnFH|1ZR z&;FX5@-NTFFbCydo=;t0|MGnHck`6{E6=B{%~STXJfD3uH#Psu^D#E>cwX+YeI;*v z`cR(Fb5)*yc|P+r2jyR$&w76S%kvp=^N#1`9=p!+=EJ_o^VxTK{^j}f;pQWsKk|I; z3wh&To{zD4$MbTJtykXo)GNF3Qy_Om>n zzLhur<@p$!r#vtB*zx}Q%;&kWdCK>h^7YM4eGlWv^I0ErQ~u@ojAL%fzdRpf^OV=g z^ZDM*Q|4cJKF@*8Q@(GJ=QGdEQ?92xpT7&6r+gnP&!@6IwqCiPzE|8lwLG8o**xX? z$n&``Hc$Ech&-S5+&txa%JZpg^OW_<^I8ARQ?9=}pL#b>S+6{w{n|X`e#!HB&TO9Y zeU3c;t?aSF`Fwdk>%V!*^_S=KoY_2OKgjc$|L^_YW^;Ky>uGMvzdRpf^O4ud^Ql*^ zXT9=#>NPjzU!G5Ynw#=3&*$&^<|*Ho%JUg<^O4^p&!^wydiI+z1!?ZdzZS&-!ehGH=TB+4s#;&PSfl49rc<=kk2!V{Xd7JfG)-xhenheCBU%%D+6H z`^emse|bKJ$N86g-uJYdr~e|bLZY;MZG zJfFJEP5GDSvoGeR{LAxs{+OHcFVBCCN0U#_Z$9#O8M#+2_j>o;+?3DrN1o3-e~%`g zzNeDsvu>NGyx-;djAst=TRboK*t+ET^qV}Nx;9U_4)T2ZaPyS!UFG@weK$8XpUd+x z%t85==hIhT|MGnL+}zaom*=y;=BE71^Vwf>Q~u@o80Mh-%k!!0>tCMF{%)Rff93hq zwRy^ZmglpN=BDOwy)%kPan$j>2rDh<@wCh9F%`~KI{4QFVAPh%{!i# zd+a*Pn-BXU&u8D|`IqO@hntUl{>byWFXWAXc|OMG9nZ@>wqAMTQ?ERqeU#^4o=?4- zkE~ao&pyf<|MGl{%{!i#du%_;8=rob=TnzF|MGnLcJtBy-=|nP|4-gLwY>G@y3ISD zmwRkK%iAydS)R{6%JVPJr=K?;+0XKP`c~ffm*-<_p7OlhW5@gJGoRbMutzDbJ^}%~RGZ&u9HN zPr3f`eCpjiWxeuz_G|N$`z6okIkS1n_c`+Xx3b3y=kw+HtpDaI*I%B`bH?1%=$Gd+ z|KIz)`IqOjp5~_f%kweJLHU>GQ}5TmJfFJEO^ttfKK*HK%D+6Hzweu;d|xWhXT;4% zevdq#ev|9jZ}NQlfAf_6FVANmH&5B0@_hDj^OX0CJf9hFKC%vZKK07=tXH1TKAM~I zFVCl5b5s81`RwoJDfd^N&xo6M{2qBeeI?iPc_`1P&*k}-=il6ve|bLZwt33G7xH{Y z+`QxW$n#lext{$d&!->c`IqO@pPP^DPkBD~i@fnK&&Sxj<8|_U>XqwRuRNc9l;>Zb zPraLutXH1T{>mHw@_dZVJ6ny5#wn=hL^Fr@SBK`P3zE{LAw(zP}$` zp3nY%{mb*|+pm9lKKr}*$o-Y))3@^Ky*wXd^N!ca^QlX&XFtpH*++T)<@waR`N(?Z z`Rt>-@h{KEFgN92uJ7l1%RM%?nwz|C`TFLj_2v1j&*mxfraYg0-#q1f`#V<@xmC<|Cg!@_gy_uTkMhR9JRf88j_2hb+t2dGr=R8d)FscqJfFVZ zeDweKDOS$^lQ&N-Z#}tg^N#1`9^23I_KSX&=d+LU{LAy{=gmj<>%r?Ne^Ub&yXSKK_cJfHR1Jmvbx^SLiJPxQ8DJRf88k=M!dsaLLNz4CnOH84ZFr{Cmy_M1GP{@*-h|I72)$IVmrr#zp1+&ty| zBF|^Wn~$tRo=?4UJ?oX{vybMc{LAyH*W8qUc|QBQdCL8j=QHBw9luAOPhZLPd>+d4 z>3@0t<@q-^o)zsMW^ z@_dZVJ6}Z?617>FVDx=yyJE9eEM0gXFtpHsY{-J zc|Lu+dCL1yo=;u!#=krte z`fQ#uZ_4x8_svtzN1o3N%uUVb@_goFZpyzrpXY*~%D+4x!`zgAc|PlGZpyzrpSsLV`IqOj zFXpEF%kz2un49u1&wq_alTXiYKJs@NxmPXsdiUMjl+W`=p3gjgk0zhKr;_KhZkwmP z-{tv?XAbgPJTLdyy5#xvn>?SoHcz<@@_hPm^OWyh<@x-5H#aq(%kweJLHU>G(^p^r z@_hQ-+|>A&=d-`&ru@tE*~<@waLdCGp4=d+LI zrsjWnKE~!9&&xfwujGwSAIkITb9w&d`OMQClz(|X>-qIB&u7HVJD!(&>^jSv5Bnm| zXW!-dm*>-mn~!|{$n&``ZbPraLutXH1TKFS;a z@_dZVJD!(&Y(L8zpMI9-QfwR^IrR=VNT1^1R$*$NTFupXbKrDc@(x*EcuyJ&YsIXMM~~ z`IqN2j=3rS@_dZVQ(h;}=X*C#nSbT^JO?&U`MyP-&pbCzxt{WT{w{2u@_np4pUU>w zdgXrlUUBo(@_g23^OWl&&*#3_Jmv2N@_g2F^OWl;&!@7@Q`RfbXZ<%%x&HEe>fJnL zz4CnaYx9)*CC}$Mvw6z*Ir99svd0SN^X2)h|K=&zU!Ko%#@y8Cm*+G8-}}A!m*=yd z=BE71^D)dp`IqNY@7KRPpSsLVjemJQ{b_E>zdWD6@0+K5UnR@_a_zyyN%C^I2!P zp8Y1zryu0`m*>-;n~&^Ic|P}xyzwv3$Jo5%b@F`bmFrorJfD4(=U<*ry_=7$SDw%Q z${YXke2mRIUMJ6|pXGY?vpk==%k$~m zuYY+y`@8wb{gvm_xAN+}JRf88j@QZasY|YBKg;vkM|u9``P94l$a>}Z?4!K#FVDv? zH|1Zh@8^2UJvO(Ro4juM`sSwf<@v17<|*^0JfD5vJmq}k`OLuF)O;?_XFlep{LAxs zKA4;GFVAQG=BE71^SO`AP5GDSV|bi@x#xXPyLoDPKI>p^YW&Odxi8F3`IqOjZsw-^ z%kweJP5GDSv(DzG{LAyH%iNTIc|QAMZpyzrpXZOcDgW~P*LXDf^!(-{f3J~y)pD@OY_Om>neKa>U|I70+Ht%>|?y-F(Z+!Ytp3ieto_~2h^E3zLU!Ko; ze*Mey8FBND=j9%|&hqBNzR2_0cX|Hh`SjuDBcDI=eC`W*<6oYSv3bYya*wT7-uToj z&u1Uy`IqNY@8%=xmFKgM^2WbBA7k^5=j9&T&+^8npXK?~CC|S+pT6CE^#AuMR?h#E zH%~2ZJ-Kf4j_2hb+t2d$i++~pvybxp%k$~y%}4gLJfFUmH~!`M7@Ma&FZbB-{`$=4 zxv_c5_nGqb%}sp|1<@(6;xi2E|IJgbzdWCMH&0owJfHpAJmr4L^Lfr}p7MQ;JpZlivBLR$c|PmEdCK*d z=kuJ|JY_$~^O^te{oZDCc|PlDZpyzrA7k^8*U9s#SFUHh@_gzwH|1ZRPk)-5@-NTl z@B8K{-?TX-#lgi%k$aC%~STLJfD5sJmvi&&u7M)kE}zU zPrY(I>y_uTkLITQ%k!z%+?0QLKKr|Q%Keq+GvekQzek==U&-}+9?J9Se|i4p`8PM^ zU!KppZJzS^AkSyS%{zXNJfC%z>)CJeeELD2e|bLrx%tTcl;?B5$Q%Fie2mRIUMJ6| zUb&w2%JbPrdH&`3)Vuk}dgb}-ue|Xu&&Sxj<8|_U`dO}LKg;u}OP+suK7G4+%KK5C zPhIlHzdRq~`}@)5`Rwo4zdWD5{rZ>Zv%i~<++TSn zeU#^4o=?4-kE~ao&pyf<|MGkcb5s81`hKpr++%aAxykF6uWxQzU!KqUY@RZ2%JbRx z%~Q@tp3e--P0i=>eCA_r%D+6H=YzQ^|MGn1Z*I!JJfHi>+?0QLK8DBnmwVp#w40}v z=d%vxrpCWKpZmhxlz(|X>t=4szdRqq+?0QLKI?35%D+6Hy39@am*=xD=BE71^LhT5 zoANKue~m|zPtR{Y@^=}zS1tE?_ubr-&+|u~&pdyRCZE2ilIOE-o2R_r<@ttK-)G9#H#hY?j3duyeaubym*+E%xhenh ze2mRgUMJ7zdpA#+f93f+2R2XnzD1tTJU36dp7MPDE^MCieXKm6%J$fL<$n5Jar4yj zeAZ|4l=d+&Xru@tEG0Z{v zm*-RO*S|cUy39?De|bLrX>Q8DJfFYso2PtVD$i%c%}0KZJfD7(>)CJeeENU$l>INy zXCF6D*`M-!_Hpx+_lrEA8E-za4tYNH%Jr;Qp3gp-oANKur(SbY{^j}X@8&7@SDw#^ zn|J&kc|Lt5*YkNO&!^Aj`IqP4+?0QLKI^u5%D)%#d`8^7shZnpM8|)U!G6Bn~$tlp3nZu8~^frjLkb< zC(oy!<$CtBJfFJc`IqO@x0|QDALaSfC2#!8^D(}^A6=f${(k+-^Xc2Ke|bLpyZOld zmFLs9^6I@jA7k^5*U9s#ORi@>%k$YsdH&`3)Vuk}dgb}-qrCAi&&Mz~tJqb{LAyXFU(E(m*=x?=BE71^D)d#`IqOj z&gQ24%k!zr+?0QLKKo*B%D+6H=a0E5|ML9Tcr^L+{N^KnuaSGza<6yaH%~3kXP&>u zk@@sJl{}wy+dSp{F3)GY%}1V>du&~DXSF<^=j!Gu>y_uzhnuH-?<&vd@4LCF`COil zVGhc_JfFV$`j_X^=jNuyzdWD)H8%kwcd?|5GBv3(_PeELwH&vR9te|bLhGzaBhp3i!I{mb(iar2Jn z^Xcc!NA|NkpT3nh{^j`?o2NW4_t^3N`poCKv3bh(nez3` zO??mJ$n#krb5s81`HW+3%D+4xWAl{P$@BT%%~R%Ic|Om9%~QT_k>@kd%~P(YJfFV{ zo2PsqE6=C0J+@xCpT1YzJheQZ_1Qe-`pEOSFE&s4`-nWB_1rw=ddl;uZ1a@$%JW(O z%~P(wJfC_uPg$=#pZ(fA<$lTYdCqK}@_mjx|E=t?!ufo8KI^}E%JrA$^PJf{Wk1OC zng8$o-ez-oKI>_2%D+4xWAl;M$@8gKu4ldSeCjnfdP4mFKgM z=BE71^QqU|lz(|X`@4C{{gvl4;^rN{N1jh#$@P35%Jb=edH&`3H#g;9p3k~%p7Qx1 z&u7HVJARKmpLLe&*>CcE`azz5c|QHQ`N;m1=X1Zv8~^frjLkbc%3|-y5xHHvpk=Dl;>ZbPraLu ztXH1TKFS;a@_Y<)Q~u@pey+FNV{@yy$?KM{Z*E#&p3nMho-%LB^V#>!Q_e@8&kW2> z&FAub=3{QkzdWDkgSjdH@_goRZpyzrpZmz%lz(|XhR6Ard*1i7o2QoNvkvB_#=ktD z`@-Cme|bLZW^T&AJRif{lz(|X>uheyzdWD1%uV^1=d&;7ru@tEdH$H2@-NSSjYpGD z&u>2RcNw`?E%$o&-Q1MV^GBY~Jb#ZSpT4J(=d*5`r@Y_g`HW`{@>@JF_t?7R`ShDS zpSm_rxeoGt`f&4-0U;pxa`rO>q_?PFizvia=%k$Y^ zb5s81`55M){LAyH>+4^h&;D+na)0Id)U|oaewOF6kLIT4e|bK}<{i(=J+`mpjZYuS z^XYSW{^j}1(;Sq4c|Pm;^)Jt7#LYXNmwW6w%bO4TBF|^v<@uNA(}$aneE!Juxi936 ze|bK}<{i(=J+@wX<5RCZpM8|)U!G6Bn~$tlp3gqY8~^frjLkcqmwRkK%Nw75mgiHK zJpb~1`gZft|KF!rIsZ@IJhi;_ocF{#^x#CXUf+%H}yS?BhP1j%uV^1=QEDEDgW|(jLlPCC(q}5 zH&2;=<@r1ZHc$D!MV`+*H&3~q@_ha-Y@YIctURB}_Skyme)?W<^VITu)@SpS>m$$S zzSunF?*;OF)^qce>nYEtvdvT0E6->BH&40#@_g#uJY~J|eD-Vel=~&m=Q*=^%J(_) z{I{~l3g`3X`KCcE`hWA3{V&gFA2(0gpYnY6 zar2b-i#(qhZ$7dPc|P^Z^{iK(&pw))@-NS)UUO6a<@xOI<|+4Ap3jJzcl;iCK7A$E z^LZ%Gr_bg2m*?Nylz(|X>$Z8yzZdd+M%=vP_sH{EXStsJCeNoI`!?< z_lvyoFVDx=yyJE9eCn0!S+6{weU#^4o=?4-kE~ao&;H6A|MGl{%{yKv&!?Z|diJwC zpStAvm*>;Bo2R@V<@wYlZ~V*iF}}YaU7pYWe*Mey>D#Y=c|QBQ`N;j1=hL_H>b*Q4 zWAl#J$@8g8u4g~X^Vvsv{^j}9yZOj^<@xNRyzwv3$1peLU#{=xddodFx0;*0Zu$D= zruF6dtk32t^QJtXecwFgeB}Aez}(b)F3)E^=BE71^Laj)oANKuXa44<{LAyXkIYT^ zm*-=6oPW9JeNVf2YI#2EU~X#s%k#M}%uV^1=d*6+ru@tEG0aW*m*=z2=BE71^Qp_+ zlz(|X`(kd&zdWDkkGU!T^8D9$H2L)W<|BWvk$cs0uXo=!Pc6@9p1;SD`Sd-NJfC&j zJmvi^&u6^NN1m5^Y+Z6^wLG8a>gFlymFLrko2Pv5D$nQdySb_PT%M0%4$8kgpT7F~ zm*>;x=BCEKJfHnFH|1ZR&;FX5@-NTFFbCydo=;t0|MGnHck`6{E6=B{%~STXJfD3u zH#Psu^D#E>cwX+YeI;*v`cR(Fb5)*yc|P+r2jyR$&w76S%kvp=^N#1`9=p!+=EJ_o z^VxTK{^j}f;pQWsKk|I;3wh&To{zD4$MbTJtykXo)GNF3Qy_Om>nzLhur<@p$!r#vtB*zx}Q%;&kWdCK>h^7YM4eGlWv^I0Er zQ~u@ojAL%fzdRpf^OV=g^ZDM*Q|4cJKF@*8Q@(GJ=QGdEQ?92xpT7&6r+gnP&!@6I zwqCiPzE|8lwLG8o**xX?$n&``Hc$Ech&-S5+&txa%JZpg^OW_<^I8ARQ?9=}pL#b> zS+6{w{n|X`e#!HB&TO9YeU3c;t?aSF`Fwdk>%V!*^_S=KoY_2OKgjc$|L^_YW^;Ky z>uGMvzdRpf^O4ud^Ql*^XT9=#>NPjzU!G5Ynw#=3&*$&^<|*Ho%JUg<^O4^p&!^wy zdiI+z1!?ZdzZS&-!ehGH=TB+4s#;&PSfl49rc<=kk2!V{Xd7 zJfG)-xhenheCBU%%D+6H`^emse|bKJ$N86g-uJYdr~e|bLZY;MZGJfFJEP5GDSvoGeR{LAxs{+OHcFVBCCN0U#_Z$9#O8M#+2 z_j>o;+?3DrN1o3-e~%`gzNeDsvu>NGyx-;djAst=TRboK*t+ET^qV}Nx;9U_4)T2Z zaPyS!UFG@weK$8XpUd+x%t85==hIhT|MGnL+}zaom*=y;=BE71^Vwf>Q~u@o80Mh- z%k!!0>tCMF{%)Rff93hqwRy^ZmglpN=BDOwy)%kPan$j>2rDh<@wCh z9F%`~KI{4QFVAPh%{!i#d+a*Pn-BXU&u8D|`IqO@hntUl{>byWFXWAXc|OMG9nZ@> zwqAMTQ?ERqeU#^4o=?4-kE~ao&pyf<|MGl{%{!i#du%_;8=rob=TnzF|MGnLcJtBy z-=|nP|4-gLwY>G@y3ISDmwRkK%iAydS)R{6%JVPJr=K?;+0XKP`c~ffm*-<_p7Olh zW5@gJGoR zbMutzDbJ^}%~RGZ&u9HNPr3f`eCpjiWxeuz_G|N$`z6okIkS1n_c`+Xx3b3y=kw+H ztpDaI*I%B`bH?1%=$Gd+|KIz)`IqOjp5~_f%kweJLHU>GQ}5TmJfFJEO^ttfKK*HK z%D+6Hzweu;d|xWhXT;4%evdq#ev|9jZ}NQlfAf_6FVANmH&5B0@_hDj^OX0CJf9hF zKC%vZKK07=tXH1TKAM~IFVCl5b5s81`RwoJDfd^N&xo6M{2qBeeI?iPc_`1P&*k}- z=il6ve|bLZwt33G7xH{Y+`QxW$n#lext{$d&!->c`IqO@pPP^DPkBD~i@fnK&&Sxj z<8|_U>XqwRuRNc9l;>ZbPraLutXH1T{>mHw@_dZVJ6ny5#wn=hL^F zr@SBK`P3zE{LAw(zP}$`p3nY%{mb*|+pm9lKKr}*$o-Y))3@^Ky*wXd^N!ca^QlX& zXFtpH*++T)<@waR`N(?Z`Rt>-@h{KEFgN92uJ7l1%RM%?nwz|C`TFLj_2v1j&*mxf zraYg0-#q1f`#V<@xmC z<|Cg!@_gy_uTkMhR9JRf88j_2hb z+t2dGr=R8d)FscqJfFVZeDweKDOS$^lQ&N-Z#}tg^N#1`9^23I_KSX&=d+LU{LAy{ z=gmj<>%r?Ne^Ub&yXSKK_c zJfHR1Jmvbx^SLiJPxQ8DJRf88 zk=M!dsaLLNz4CnOH84ZFr{Cmy_M1GP{@*-h z|I72)$IVmrr#zp1+&ty|BF|^Wn~$tRo=?4UJ?oX{vybMc{LAyH*W8qUc|QBQdCL8j z=QHBw9luAOPhZLPd>+d4>3@0t<@q-^o)zsMW^@_dZVJ6}Z?617>FVDx= zyyJE9eEM0gXFtpHsY{-Jc|Lu+dCL1yo=;u!#=krte`fQ#uZ_4x8_svtzN1o3N%uUVb@_goFZpyzrpXY*~%D+4x!`zgA zc|PlGZpyzrpSsLV`IqOjFXpEF%kz2un49u1&wq_alTXiYKJs@NxmPXsdiUMjl+W`= zp3gjgk0zhKr;_KhZkwmP-{tv?XAbgPJTLdyy5#xvn>?SoHcz<@@_hPm^OWyh<@x-5 zH#aq(%kweJLHU>G(^p^r@_hQ-+|>A&=d-`&ru@tE*~<@waLdCGp4=d+LIrsjWnKE~!9&&xfwujGwSAIkITb9w&d`OMQClz(|X>-qIB z&u7HVJD!(&>^jSv5Bnm|XW!-dm*>-mn~!|{$n&``ZbPraLutXH1TKFS;a@_dZVJD!(&Y(L8zpMI9-QfwR^IrR=VNT1^1R$*$NTFupXbKr zDc@(x*EcuyJ&YsIXMM~~`IqN2j=3rS@_dZVQ(h;}=X*C#nSbT^JO?&U`MyP-&pbCz zxt{WT{w{2u@_np4pUU>wdgXrlUUBo(@_g23^OWl&&*#3_Jmv2N@_g2F^OWl;&!@7@ zQ`RfbXZ<%%x&HEe>fJnLz4CnaYx9)*CC}$Mvw6z*Ir99svd0SN^X2)h|K=&zU!Ko% z#@y8Cm*+G8-}}A!m*=yd=BE71^D)dp`IqNY@7KRPpSsLVjemJQ{b_E>zdWD6@0+K5 zUnR@_a_zyyN%C^I2!Pp8Y1zryu0`m*>-;n~&^Ic|P}xyzwv3$Jo5%b@F`bmFror zJfD4(=U<*ry_=7$SDw%Q${YXke2mRIUMJ6|pXGY?vpk==%k$~muYY+y`@8wb{gvm_xAN+}JRf88j@QZasY|YBKg;vkM|u9` z`P94l$a>}Z?4!K#FVDv?H|1Zh@8^2UJvO(Ro4juM`sSwf<@v17<|*^0JfD5vJmq}k z`OLuF)O;?_XFlep{LAxsKA4;GFVAQG=BE71^SO`AP5GDSV|bi@x#xXPyLoDPKI>p^ zYW&Odxi8F3`IqOjZsw-^%kweJP5GDSv(DzG{LAyH%iNTIc|QAMZpyzrpXZOcDgW~P z*LXDf^!(-{f3J~y)pD@OY_Om>neKa>U|I70+Ht%>|?y-F(Z+!Yt zp3ieto_~2h^E3zLU!Ko;e*Mey8FBND=j9%|&hqBNzR2_0cX|Hh`SjuDBcDI=eC`W* z<6oYSv3bYya*wT7-uToj&u1Uy`IqNY@8%=xmFKgM^2WbBA7k^5=j9&T&+^8npXK?~ zCC|S+pT6CE^#AuMR?h#EH%~2ZJ-Kf4j_2hb+t2d$i++~pvybxp%k$~y%}4gLJfFUm zH~!`M7@Ma&FZbB-{`$=4xv_c5_nGqb%}sp|1<@(6; zxi2E|IJgbzdWCMH&0owJfHpAJmr4L^Lfr}p7MQ; zJpZlivBLR$c|PmEdCK*d=kuJ|JY_$~^O^te{oZDCc|PlDZpyzrA7k^8*U9s#SFUHh z@_gzwH|1ZRPk)-5@-NTl@B8K{-?TX-#lgi%k$aC%~STL zJfD5sJmvi&&u7M)kE}zUPrY(I>y_uTkLITQ%k!z%+?0QLKKr|Q%Keq+GvekQzek== zU&-}+9?J9Se|i4p`8PM^U!KppZJzS^AkSyS%{zXNJfC%z>)CJeeELD2e|bLrx%tTc zl;?B5$Q%Fie2mRIUMJ6|Ub&w2%JbPrdH&`3)Vuk}dgb}-ue|Xu&&Sxj<8|_U`dO}L zKg;u}OP+suK7G4+%KK5CPhIlHzdRq~`}@)5`Rwo4zdWD5{rZ>Zv%i~<++TSneU#^4o=?4-kE~ao&pyf<|MGkcb5s81`hKpr++%aAxykF6 zuWxQzU!KqUY@RZ2%JbRx%~Q@tp3e--P0i=>eCA_r%D+6H=YzQ^|MGn1Z*I!JJfHi> z+?0QLK8DBnmwVp#w40}v=d%vxrpCWKpZmhxlz(|X>t=4szdRqq+?0QLKI?35%D+6H zy39@am*=xD=BE71^LhT5oANKue~m|zPtR{Y@^=}zS1tE?_ubr-&+|u~&pdyRCZE2i zlIOE-o2R_r<@ttK-)G9#H#hY? zj3duyeaubym*+E%xhenhe2mRgUMJ7zdpA#+f93f+2R2XnzD1tTJU36dp7MPDE^MCi zeXKm6%J$fL<$n5Jar4yjeAZ|4l=d+&Xru@tEG0Z{vm*-RO*S|cUy39?De|bLrX>Q8DJfFYso2PtVD$i%c%}0KZ zJfD7(>)CJeeENU$l>INyXCF6D*`M-!_Hpx+_lrEA8E-za4tYNH%Jr;Qp3gp-oANKu zr(SbY{^j}X@8&7@SDw#^n|J&kc|Lt5*YkNO&!^Aj`IqP4+?0QLKI^u5%D)%#d`8^7 zshZnpM8|)U!G6B zn~$tlp3nZu8~^frjLkb%k$YsdH&`3)Vuk}dgb}- zqrCAi&&Mz~tJqb{LAyXFU(E( zm*=x?=BE71^D)d#`IqOj&gQ24%k!zr+?0QLKKo*B%D+6H=a0E5|ML9Tcr^L+{N^Kn zuaSGza<6yaH%~3kXP&>uk@@sJl{}wy+dSp{F3)GY%}1V>du&~DXSF<^=j!Gu>y_uz zhnuH-?<&vd@4LCF`COilVGhc_JfFV$`j_X^=jNuyzdWD)H8%kwcd?|5GBv3(_PeELwH&vR9te|bLh zGzaBhp3i!I{mb(iar2Jn^Xcc!NA|NkpT3nh{^j`?o2NW4 z_t^3N`poCKv3bh(nez3`O??mJ$n#krb5s81`HW+3%D+4xWAl{P$@BT%%~R%Ic|Om9 z%~QT_k>@kd%~P(YJfFV{o2PsqE6=C0J+@xCpT1YzJheQZ_1Qe-`pEOSFE&s4`-nWB z_1rw=ddl;uZ1a@$%JW(O%~P(wJfC_uPg$=#pZ(fA<$lTYdCqK}@_mjx|E=t?!ufo8 zKI^}E%JrA$^PJf{Wk1OCng8$o-ez-oKI>_2%D+4xWAl;M$@8gKu4ldSeCjnfdP4mFKgM=BE71^QqU|lz(|X`@4C{{gvl4;^rN{N1jh#$@P35%Jb=e zdH&`3H#g;9p3k~%p7Qx1&u7HVJARKmpLLe&*>CcE`azz5c|QHQ`N;m1=X1Zv8~^fr zjLkbc%3|- zy5xHHvpk=Dl;>ZbPraLutXH1TKFS;a@_Y<)Q~u@pey+FNV{@yy$?KM{Z*E#&p3nMh zo-%LB^V#>!Q_e@8&kW2>&FAub=3{QkzdWDkgSjdH@_goRZpyzrpZmz%lz(|XhR6Ar zd*1i7o2QoNvkvB_#=ktD`@-Cme|bLZW^T&AJRif{lz(|X>uheyzdWD1%uV^1=d&;7 zru@tEdH$H2@-NSSjYpGD&u>2RcNw`?E%$o&-Q1MV^GBY~Jb#ZSpT4J(=d*5`r@Y_g z`HW`{@>@JF_t?7R`ShDSpSm_rxeoGt`f&4-0U;pxa z`rO>q_?PFizvia=%k$Y^b5s81`55M){LAyH>+4^h&;D+na)0Id)U|oaewOF6kLIT4 ze|bK}<{i(=J+`mpjZYuS^XYSW{^j}1(;Sq4c|Pm;^)Jt7#LYXNmwW6w%bO4TBF|^v z<@uNA(}$aneE!Juxi936e|bK}<{i(=J+@wX<5RCZpM8|)U!G6Bn~$tlp3gqY8~^fr zjLkcqmwRkK%Nw75mgiHKJpb~1`gZft|KF!rIsZ@IJhi;_ocF{#^x#CXUf+%H}yS?BhP1j%uV^1 z=QEDEDgW|(jLlPCC(q}5H&2;=<@r1ZHc$D!MV`+*H&3~q@_ha-Y@YIctURB}_Skym ze)?W<^VITu)@SpS>m$$SzSunF?*;OF)^qce>nYEtvdvT0E6->BH&40#@_g#uJY~J| zeD-Vel=~&m=Q*=^%J(_){I{~l3g`3X`KCcE z`hWA3{V&gFA2(0gpYnY6ar2b-i#(qhZ$7dPc|P^Z^{iK(&pw))@-NS)UUO6a<@xOI z<|+4Ap3jJzcl;iCK7A$E^LZ%Gr_bg2m*?Nylz(|X>$Z8yzZdd+M%=vP_sH{EXStsJ zCeNoI`!?<_lvyoFVDx=yyJE9eCn0!S+6{weU#^4o=?4-kE~ao&;H6A z|MGl{%{yKv&!?Z|diJwCpStAvm*>;Bo2R@V<@wYlZ~V*iF}}YaU7pYWe*Mey>D#Y= zc|QBQ`N;j1=hL_H>b*Q4WAl#J$@8g8u4g~X^Vvsv{^j}9yZOj^<@xNRyzwv3$1peL zU#{=xddodFx0;*0Zu$D=ruF6dtk32t^QJtXecwFgeB}Aez}(b)F3)E^=BE71^Laj) zoANKuXa44<{LAyXkIYT^m*-=6oPW9JeNVf2YI#2EU~X#s%k#M}%uV^1=d*6+ru@tE zG0aW*m*=z2=BE71^Qp_+lz(|X`(kd&zdWDkkGU!T^8D9$H2L)W<|BWvk$cs0uXo=! zPc6@9p1;SD`Sd-NJfC&jJmvi^&u6^NN1m5^Y+Z6^wLG8a>gFlymFLrko2Pv5D$nQd zySb_PT%M0%4$8kgpT7F~m*>;x=BCEKJfHnFH|1ZR&;FX5@-NTFFbCydo=;t0|MGnH zck`6{E6=B{%~STXJfD3uH#Psu^D#E>cwX+YeI;*v`cR(Fb5)*yc|P+r2jyR$&w76S z%kvp=^N#1`9=p!+=EJ_o^VxTK{^j}f;pQWsKk|I;3wh&To{zD4$MbTJtykXo)GNF3Qy_Om>nzLhur<@p$!r#vtB*zx}Q%;&kW zdCK>h^7YM4eGlWv^I0ErQ~u@ojAL%fzdRpf^OV=g^ZDM*Q|4cJKF@*8Q@(GJ=QGdE zQ?92xpT7&6r+gnP&!@6IwqCiPzE|8lwLG8o**xX?$n&``Hc$Ech&-S5+&txa%JZpg z^OW_<^I8ARQ?9=}pL#b>S+6{w{n|X`e#!HB&TO9YeU3c;t?aSF`Fwdk>%V!*^_S=K zoY_2OKgjc$|L^_YW^;Ky>uGMvzdRpf^O4ud^Ql*^XT9=#>NPjzU!G5Ynw#=3&*$&^ z<|*Ho%JUg<^O4^p&!^wydiI+z1!?ZdzZS&-!ehGH=TB+4s#; z&PSfl49rc<=kk2!V{Xd7JfG)-xhenheCBU%%D+6H`^emse|bKJ$N86g-uJYdr~e|bLZY;MZGJfFJEP5GDSvoGeR{LAxs{+OHc zFVBCCN0U#_Z$9#O8M#+2_j>o;+?3DrN1o3-e~%`gzNeDsvu>NGyx-;djAst=TRboK z*t+ET^qV}Nx;9U_4)T2ZaPyS!UFG@weK$8XpUd+x%t85==hIhT|MGnL+}zaom*=y; z=BE71^Vwf>Q~u@o80Mh-%k!!0>tCMF{%)Rff93hqwRy^ZmglpN=BDO zwy)%kPan$j>2rDh<@wCh9F%`~KI{4QFVAPh%{!i#d+a*Pn-BXU&u8D|`IqO@hntUl z{>byWFXWAXc|OMG9nZ@>wqAMTQ?ERqeU#^4o=?4-kE~ao&pyf<|MGl{%{!i#du%_; z8=rob=TnzF|MGnLcJtBy-=|nP|4-gLwY>G@y3ISDmwRkK%iAydS)R{6%JVPJr=K?; z+0XKP`c~ffm*-<_p7OlhW5@gJGoRbMutzDbJ^}%~RGZ&u9HNPr3f`eCpjiWxeuz_G|N$`z6ok zIkS1n_c`+Xx3b3y=kw+HtpDaI*I%B`bH?1%=$Gd+|KIz)`IqOjp5~_f%kweJLHU>G zQ}5TmJfFJEO^ttfKK*HK%D+6Hzweu;d|xWhXT;4%evdq#ev|9jZ}NQlfAf_6FVANm zH&5B0@_hDj^OX0CJf9hFKC%vZKK07=tXH1TKAM~IFVCl5b5s81`RwoJDfd^N&xo6M z{2qBeeI?iPc_`1P&*k}-=il6ve|bLZwt33G7xH{Y+`QxW$n#lext{$d&!->c`IqO@ zpPP^DPkBD~i@fnK&&Sxj<8|_U>XqwRuRNc9l;>ZbPraLutXH1T{>mHw@_dZVJ6ny5#wn=hL^Fr@SBK`P3zE{LAw(zP}$`p3nY%{mb*|+pm9lKKr}*$o-Y) z)3@^Ky*wXd^N!ca^QlX&XFtpH*++T)<@waR`N(?Z`Rt>-@h{KEFgN92uJ7l1%RM%? znwz|C`TFLj_2v1j&*mxfraYg0-#q1f`#V<@xmC<|Cg!@_gy_uTkMhR9JRf88j_2hb+t2dGr=R8d)FscqJfFVZeDweKDOS$^lQ&N-Z#}tg^N#1` z9^23I_KSX&=d+LU{LAy{=gmj<>%r?Ne^Ub&yXSKK_cJfHR1Jmvbx^SLiJPxFc7Kh`VHXZ|-& zIsfu}>fJnLz4Cn4Yx9)rCC}$Rvw6zrIr98hWuI0!pD&)z{BNFe{^j}HXEsmS5AuA@ z|Ks(&oz3O>%%{02|MGl{%|{+5&!=9wp7qM}sn^_;e|bLrX>Q8DJfGk9%~L)vmFF|! z<|DsHo=?BY_3Sr!KK;LW%Kn$`!?<>$rK!>qVZ=8E-za4tYNH%Jr;Qp3gd( zoANKur(SbY{^j|s@8&7jSDw#^n|J&kc|Lt5*YkcT&!_+8`IqP4+?0QLKJ&JD%KL*n zpAk3j_&xG`=2@<1zsd9I2YLSG`Sj=JBl}aH&-Eg2{LAw(Ht%?xJfC{yde$q?XC3AF zm*-RO<|FHs=d-@@#=krtWAl#3$@A%Fxt{$j&!;YV{^j}f?dB=3M|nPV$s7Oje2nM& zqs#MI-=}|hK7IT2FVAOvHy^pa@_hPMUcHy+V{G2>IC(yG$@T1Kc|PkX&%ZpMdN&_g zuRNc1lsEq6`55M={LA(ITyMGC=2ml)$1Pvq+_b(tpZVE5W!{wMv+kRxJRf;JXJBsX zd@j%De9TSxm*;bTFgN92p3nK4oANKu=Q=VsuYYxzdWDy zH8}PpC>u7H3{4dYP*u3L@x!d-Yyz%Kn zc|LtE&%ZpM^E3zLU!Ko=KK;w{8FBND`{iys&+^WPb&=<@?(+Q0^XbFQN8W$r`CJ$B z#=krtWAl#tEM|tC4o{wQ}%D-IS&-IqOZEiI;dED~# z%}wje^O>K`Q|3*1KI^`D%JY%ua|Y(7&gb%c&d1!8e|bLl2Xj;Y<@ubyxhenhe6AyN zQ~u@o7;fiZ?tY)sZk}46&peo$8vpWqt_yQh{^j}1o4G0f@_Y<)Q~u@o%(J;E|MGn5 zGB@R4p3l0NoANKu=l)}E%D+7SWqfM#>Hf_}zORvc)N+q^-8WAy&*wZpJ{_4)pHs>6 znYYbTUhndJ#@l@4e!1J$CHJhB=W}1(JY~J|eEM+nl+Rt|`TV|{n>wG%^D)dp`IqO@ zS5N=)eEQtn)cBX@v%co0{LAxMUvpFb<@p%qp#018sq5)qp3nMjo^pNV`P8*}%6^vT zvySGb&j0d!jLkdlm%D9W$s3y_uT zj`GI8JRf88j{D_q+t2dGr=R8d)FscqJfFVZeDwW(ikb88$(yH^H=i80dB^>7x9w+n z>qS4y^I1oE{^j}f^X4P_S)Nbd${YXke2mRg?w7mmc<(;*xo>Qq@_D9weREUa!#MJM z=EvNWe|bLRn49u1&&Sw2<#F|fE`?SLOeDQqdfAf^{FVE*bvw6yXkmqy$AFuE2 zY%b4dKFv+}m*-<_KJqwuKK07=tXG~-z2>I;%k$|^b5s81`TV|bp7MFAJf9IaANf7< zeELnUXTQnw>Hp1B_P;!zb=*8nP8^JfC_u zA6c(FpY@eD{^j`?n|C};o=-o^_3USPK6T0SFVClMH&1yz%JZp9-uRd2V?5sD#A&c|PmA`N;K^=hL_H>b*Q4WAl#3$@8g8u4g~X^I1oE{^j}9yZOj^<@v0m zyzwv3$1peLU#{=xdduB5x0;(gZu$D=ruF6d%+Ka2^QJtXb>BSY`N;D*19Ma7b9p}J zV{Xd7JfHi6xhenhe9qt8lz(|X*O9p?|MGkcxAQM|zt3qmPc6@99?VURe|bLFg}EvJ z@_gpa+?0QLK8Cp||MGn1+1!+Wc|LWSoANKuXI;!q`IqN&|1me^U!MOmJ~jDt|K=m# z%g8-yxyQTi=B9k^Kk|Ie^W#&KPoGoC^O?8JQ(o`#e8w{e`7Q33yKPe@VIKg;u3M{`r>e|bK}<{kIT-L|jfjZYuS^XYSW z{^j|cr#UG9@_gp=>0h4Dh?{rZFL&E{mUlj^i#(rom*-!ePakeR^8O>w=em$L{^j`? zn|ItVciVd9jZeMueAZE(e|bLjZa%VJc|PkXZ~V*iF*fhGU+%X3EN^`JS)NZ_^8Cy5 z>D$dm-|wfGIscx#d1`s{$#I)^+%I?AewMdh^s_vlb(H5{o=-n-KC++X`Sh*4@h{KE z*gWNax!aES?lYhJ#^x!XXUf+%H}yS?BhP1k%uV^1=QEDEDgW|(jLlOXC(q}5H&2;= z<@wwPHc$DyMV`-jZk}>J<@x+BY@YIYtURB}cH4U8e)?Q-^VITu=4bPi^CQpay4XDB z`vQ4B^SOD-`IP5V+2$$hmFF}6o2Q(Ac|P@Sp0ZwfKI^r4%Jq`xbD!Bf`%|9JI&Plw zdXeXI#+#3mFF|!<{iIBo=;!N^}HX- z^XYSW{^j{MH|1ZR&%AA(^7lfX&xo6M{2qBe^DNi1-{kr9gFOH8eEM_qk^L#p=X#Mh z{^j`?n|C};o=?4UJ?oX{vySro%k!ys^O5z+^I2bc<6oYSv3bYi)ZdzZS z&-`qjGH=TBS@+FTo{v1AGcY%GK9}cnKIW$U%k#NEn49u1&*%KjP5GDSa~+wR@-NTF za6A8U_xqf7^VITu=E2<5_?PE%U6`BlFVAP*%uV^1=VO?g@-NS4p3P19m*-QLxhenh zeAdO>lz(|X_aAdp{^j{E<5QDQ_isM(eU03smV3PGzIkeSKIi%I>BxNgoJyY0yltNH zdY9)j-sU6s%iXpvxo5RJpZn_ODeINz(}$a@OY_Om>nbu>41 z{+H)tY~FFd+->_x-uU#PJfHijJpb~1&eI%}e|bLh`SdT(XT;4r?w7mmJj**D)K&okxgo16L`#*ybUKjx+?0QLKE~!LkCW%~y_=`Zzw&(U1DmIO-XhQEJU34{pYnWu7dB7%JXW4hWxH*? zazA~pxOr-MKJ&AA%K4G!b6sqn^8JWBpZVN8<$TKXsciF<^~&>^|IJg*zdWCMH&0ow zJfHR2Jmq@H^SRG#p7ME)JpWbMrxniUi{~@{o2Q(Ac|P}<%~SS+JfHLbczthYb9p}V zX>Q8DJRf88k;lpNsaLLNz4CnOH8_*9n~$tRo=?4UJ?oX{vySGb{LAyH*W8qU zc|PmAdCK*b=QHBw9luAOPhZLPydTQ*>3@0t<@q-^o)y~rE?@_dZVJ02&`r(U_9^~&>EM|u9``P94l$a>}Z ztgpQBFVDx=yyJ25eEM0gXFtpHsY{-Jc|Lu+dCKcio=;u!#=krt0h2t z-#-1z^I6}`N3O3tpT3n>@8$Uzn|C};o=;tJJ^NXn&pOKUFVCmm%}3TN&u1OwjemJQ zhPf&Ka(zG7Tkf{G)!gK9%hxwItuN1Kel|~;H|6=P`{pUnN1o3an43DE%kw!Ob5s81 z`P?7OP5GDSbN=S0{LAyXj?7K@m*-=+oqxIeeNMZ1YI#2MU~X#s%k#M|%uV^1=QD5S zru@tEG0aW*m*+Fj=BE71^Qp_+lz(|X>tb%ozdWD&kGU!T^8AGRUH|2Bxk>_)sAD^0h`kYFh&%AA(@_Lu&GoCrfZ*jleZR?Wf({J*8>e@WzJjnCu z!_8AZca`V!`)+RPd@j$&FbCydo=;yr{mb*|b8}PUU!KqUnw#=3&u4wjP5GDSW0-^T zFVCm0r+;}q>$`c%^_AyS*XAkvS)R{2nwvWR%kwcd@3>#?wtXdUeELwHPoK;4FVE*Z z%|ZE>=QE#A|MGlB+`Qv{x!caOyz^mQ@eCn0wvySro%k!ys^O5z+^I1oE<6oYSv3bY+a<}bgdE?X1@_g!&=U<*r-)=to zem}*``S;|_Q_GuAj@!KBe!1KBv%K}9pXK?iqdfoeeENCwk^L;sr*Gwre|bK}<|+5f z-FCcppZVN3Hc$CHQ@*~rsqbMNc|P-FZpyzrpK;7h`IqNoY@YHsc|PB}dCL4N&*wg{ zdCKQ4@_f#7^OW-`&*yhx^OVnH<@r>$+tw@h)8~qtrCcE`hWA3{V&gF9XC(epYnXxar2bdi#(q* z-h5;o@_g!*>shZnpLH}hI;%kx>^%~P(gJf9Ia@Ay6PeELeR=lxKgPoK;4 zFVDZZDgW|(=56zozZdd+M%=vP_sH{^XStsJCeNoI`!?<*NeRIFVDx= zyyJ25eCn0!S+6{wb(H5{o=?4-kE~ao&-%(6|MGl{%{v|^&!?Z|diJwCpStAvm*>;B zo2R@U<@wYlZ~V*iF`n;_F3)FupZ?|f^zGBXJfHR5eB}Dd^XXf8^&V=ce|bKJ+xeHf z-{-WOr~e|bLhY;MZGJfFJEP5GDSvo7YQ z{LAyX|CpQdFVBA&pPGESfAf*=Yvdla+~ZyM%~Q+sInR$zN9NP#RPuc0ZS$1ZyF8!q zHXpfP?zVNwJ*(yU+*dbGS+6{wKHNOzb60sjzwhRz&gb%c40BNa<@xm0)4x2QJ~uZt z{^j|suemAz@_g3U+?0QLK886c|MGn5dis~=v%Z_BTwi%Ub#0!qpXK?iqq(W`zdRpf z^N#!FZrfM##-|VE`P^6K`IqN&p5~zZ%k!Dfr+;}qBW~Vtzuax-S>E}uF7kZVU7mk= zK7F|P$or2xpX);2_?PEnY~FFd+->WXH$L^s^I1oE{^j}9yZOj^<@v0myzwv3$Jo5% ze!1KBv%K-?XL&w#$@4GIr*AhOeZQY#=KOo|=Bee)C&z8xalhPc`&r(4(a-XH)={2+ zc|QHT`N)2j=hL_H#=krtWAl{z;Hu} z{*V5x>;HFe{9pX7>;Ly}{NMV|uKz#0@qhj2|H0okT(7_Q#{c{i*Z&{i_&@%Kum3;2 z@qhHEum6)b{xAM>*Z)gz{NMVQum3;4@qhK-xc=|H@qg~$yZ-<3#{c#I%{6oKQxW51U8~;at@AdzWH~ugFFfWWZ~R~V7q0(%Z~UM8 zSFitnz43qj-@g7|e&c`s2iO0<-}pcN@%8_oH~x=)@A^OY^MCaNe(e|j^zRF<@6W&S zf9dbJ{>K~txBrpr|H2#phky3^f6W{J2mk!_|JpbHZ~Xb||8;NtU->t$|JT3qfAa5N z|8IEX|Jr|g{lD>z|4YAn{lDpr|J#4?&z$xB18@8v{>khA&2Ri4{1eyzgKzxb_-C&F zx4iLx9(p7s4Z-uS=q_h0{yyzzhKpS=DbedGV+pS}Jcd*lDwzjXb-^Ns&Y|N8a+_#6MX z|K02VU2ps!{>Rt<6L0(<{Kf14-EaKA`rY_@@BhCuVE*vmJ?#6K%kvq>_b&OD=VR>q7>|?Z^S%2%#`kCPe4Zoh`xxKX%JVtTeIMg|%JX@ywC`j5 z_Z;$kD%)-AmHX+xOW5}@%k!C^eIMie$n(k7`##2hUnS3HKKFf$^C{1#vV9+8z4CnK zf8WPA|MGn5-S;upE6-=W_I-@&CC}$M#lDa6eXu3f&_%kz0Y zxbI{9_ZISeM%?!+evdq#ev|9jZ}NQlf8WR0|MGm+ao@+-pYnXxao@*yy~y)9<9)wk z9rAqYmFrorJfC&+y-WV(`PA!sm;B4~S>Jsh>sNuEz%$#XByr~jY+ z<@xu$OXFXj&%FJi&rJSwc|LpheThfQ^O-;fA}+#KV6>B_44#D z&u6rKU*fmP^Ql*^XT9=#)={2+c|LXR`xUQ8c|PkXZ~V*iG5*MB=3n_Ic|LtB&%HdK zx}N^!`Sk4{eVotb`PB9FFVE+Upa1^s@_g3!>0h2t-#-1z^I6}0zvBAJ^XXf8^M83h z#=bA{IC(yG$@T1Kc|PkX&%ZpMdiVW`^~&>EM|tC4o{!;sm;B51{akOk+rIbOJhgm% zbCchrFVAOwHc$D!N}kWUZ=P~|c|K=gZt8q4&*yy1P5GDSb007_aFVE*X zGB@R4o{!;n{^joX-+64FTAt55n422^@_eofb5s81`OKTSDgW|(40BWd<@wCBxhenh zeCjec3eQ@KJ&JD%IjU8&v@n_zs3D>x2;Q_Pru3YscZ9;^B~Ws4>wQw?>6N5{EnNOI-kq) zG0Z{vm*>-0Pyh0K`rO>q_?PFizUHR<%kx=Zb5s81`55M){LAyH>*-&f&-!kja((6b z)U|oaewOF6j^?J$|MGl{%{%UwyKP^|8=pRu=hNr%{LAw>&&@~vdmwo}^C@rq%kwcd z@3>#?w(~4+eAY#t&$`R=FVCkBHy?Tbk>_(=$Q%Fie2mRI?w7l5z4FGVUU@$2D9^t< zpL#bRS+6{wb(A;$<@p$!cib;`+kTceKK(4ur!IN^<@xmU<|F%Ao=;u!#=krtWAl#t znqQvZ{>}Dc|OMG9rw%KwqAMTQ?ERqb(H5{o=?4- zkE~ao&pOH*|MGl{%~S4|yX|=IKJ%I9%~L+ll&^1Y>U$VRp3nT4oANKuXB=}={^j`? zo2NWZp3nDgo-+T+^SKXfp7MQ)JfHL2Jmq}K^SO>TPx(Ano=;`FZM||oeebY&YI#2M zvw6z-k>_(=Y@YIcfjpo2+&txc%JZpg^OW_<^O^t6Q_jCUpL#b>S+6{w_1Zk;ddc&- z&upIZd5%2)RoSN%&gYBgGyj{XoPT*f_Zf3jqhFrS`G35=H~;c{=F{Aie|bKJIVk_~ zeCmDrm*-QLxvB9l&!<1lP5GDS^ZUMe%J&!Yd`8@Sv=zv=hNr%{LAw>&&@~nr#zo|lQ;h5`52pbJWig^Jj?a$H+eq&AkV)%pZ?r@ zWPi%@xnAUre|bK}<{gid=Tom-&wAzgtfM^t@_g#ud}O`yeAZFk_?PEnY~JxWc|QFt z*R!AH`P3!PzdWCQ-h5;~%k!yA-uRd2V{G2>IC(znE7x;<<@xljJpb~1)_3!f>nqQv zZ{>}Dc|OMG9gmaeQ?Fdldgb}7qdfoeeCpkNWWDly)=}R0m*-=coANK$_jA4FZu{QH z+~je~*EctwG%^En@LQ~u@o+#k$M`IqN&{^q9q z%k#O8%uV^1=VQ2?f4Td8PP=((c|P-CZfg9?^SLg}P5GDSGjHam{LAw(%uV^1=QGdd zru@tEsmt7ye|bLZVs6U6JfHiIxhenh{Fm{m$*21_ANjsU?orD<-gVzRwLG8m{P=Wa zK7CFl&u88?PkFt|^BHgRk^ALtTbJCkTAt5+b@P<<%Jb>N%~L*imFM&OZf@#)F3-m> z2jyR$PhUO#%k$}Tb5rAAp3nN4oANKuXMN30`IqNon1k{!&!?`Ze|bLZyLrm>mFH8} z<|+GGp3gddzn@~B%~{P4>$rKx{c^XRXL}0UU@$2C~y4B^D#E>xL@wJ_epu;Zn~&^gc|LtBZ~V*i zF*Z-RU+%W!z5C4PzOi}A=b7^L%}sp|fJnLz4Cn4Yx9)rCC}$Rvw6zrIr98hWuI0! zpD&)z{BNFe{^j}HXEsmS5AuA@|Ks(&oz3O>%%{02|MGl{%|{+5&!=9wp7qM}sn^_; ze|bKAXl}~CJpbmV{LAw(HXnJMJfD7(>)CJeeENU$l>INyXB{_B*`M-!)^YQc*NZ%# zGv0h;9rAqYmFrorJfC$mH|1ZRPrc@*{LAyd&Qm@QH)rKD;`9B{<@xm0)4x2Q{(t(H z=X3t%pz6ImpLu)wm*+F$<{iIBp3gkX_3Sr!KK&rizdWD*+fL-~z4Cn4QQr8M=VNT%@i=)teJj`V?@RK0>XPSQo=@LC z-#1;JPhC&{@_f$V`TpqgeAf5rU!G6jKK;w{S>Me^uCF|wzLhthm*-<_-tjnjK6T0U z>}PpC>nP8^JfC_uA6c(FpLLWs{^j`?=BE71_5ECLx!dMebCbs{U*FuczC54#**s<5 zl;^YVo2NV5aFVE*XGB@R4o{!;n{^joX zIqmoRDdvCklznJ!YCh=)dGpD-n49u1&*%PQZpyzr|7Cn?^6CD~N4}Sld(?7|w;#++ z`P_fx`JCs+rzW31r;_J0Z=0u_XL&y3nS=Zm_siY3E_pupXL&w#ZJu%-%Mu)c`^sJUi?X}_mf}dI+EvKp3nMjo^pNV`SkPVDf?NT&-$91I-kq) zF*fhGU+%VjC2xHCP@Yep%kwYK=R7wb`8;2q&wR=o|MGl{%{%UwyX`#78=rNN=dnP8^JfC_uA6c(FpLLWs{^j`? zn|ItVciVoJH$MF=&!;YV{^j}f^X4P_S)NZ_^2WbBA7k^5`{i!CzVgOredYP|tvvto zeAajKk?SkZr*Gwre|bK}<{kIT-L_tN<5RCZpLLYyU!G6Bn~$tlp3geU8~^frjLlQ- zm%HtF?>_UH=gm_-&y=rkZt8m&N1o68n49u1&u1KSQ~u@o7@Ma&PM**AZk{s#%JXk- za$KLcn6vUZ&&^ZLr#zqQX!DfMW99jr!ESqAazB0Vuz6~EKJ(*yD93ev0h2tUFN37 zzdWD*G&kj6p3m?5<|*G_$nzP|_eza_c|QI2^e@k+&wUTo_?PFij=qP=zdWCHG&kj6 zo{zEl$m8Vs)Fs#R`jY3fj^?KP%k!zr+?0QL{>@GKm*-<_-tjnjK7A$E^L{ALr_bg2 zm*;byn~&^Ic|P+dZ~V*iF*fgboIIa-mg{*xl;_hA^8Cy5>BG%O{(i~xxh~|5e|bK} z<{gid=Tom-&wAzgtfM^t@_g#ud}O`yeAZFk_?PEnY~JxWc|QFt*R!AH`P3!PzdWCQ z-h5;~%k!yA-uRd2V{G2>IC(znE7x;<<@xljJpb~1)_3!f>nqQvZ{>}Dc|OMG9gmae zQ?Fdldgb}7qdfoeeCpkNWWDly)=}R0m*-=coANK$_jA4FZu{QH+~je~*EctwG%^En@LQ~u@o+#k$M`IqN&{^q9q%k#O8%uV^1=VQ2? zf4Td8PP=((c|P-CZfg9?^SLfIPx&4}p3l6Qn;QS}e2mRg?w7l5pKP95o=;tyr|eI8 zKI>v`>ijRy=l)}E%D+7SWqfM#>Hf_}&a>R3mV3PGzIkeSKIi%I>BxNgoJyY0d~Tj{ zKIQq0xB1BZa<{EZ?pZC*=f1jm%6jGb^x@_ypS#NQ`F%Gxbv~EpV{AThzuax#*T@^6 zev{{OpV>TR|I71P-_295uRNdi-8|*`%JVs6b5Q4hc|LVL{mb)N-_295uRNc6H&0ow zJfC&^em})Lo3ol9)^YQW`{iys&+__#b&=<@?(+Q0^XbpcNA{;YpX){5_?PEnY~FFd z+->WXH$L^s^Z7lM=U<*ry_=7$SDw#0${YXke2mRI?w7mmeNx`|+*jrK)FscqJpb!F z_5FT|ne#rsd1`s{$#I)^+%I?AewMdh^s_vlb(H5{o=-n-KC++X`Sh*4@h{KE*gWNa zx!aES?lYhJ#^x#Cr^wegH}yS?BhP1k%uV^1=QEDEDgW|(jLlOXC(q}5H&2;=<@wwP zHc$DyMV`-jZk}>J<@x+BY@YIYtURB}cH4U8e(rlHz2*7L&*mxTN1o4hVQy;t%kyt; z%D+4x!`zgAc|P;MdCK{h=Ton_sqrt*XT3I0xnA;o?lYUGe4ZoEf1SZ+XLA1Z;`z+; z=Be-ZQ_dRqRdbWn{+BnO^r5*a|ML8soANKu$1n%wU!G6DJ^jn`>3?%m<6oXnf0~=} zFVE+?FgN92o{zEl$m8Vs)Fs#R`jY3fzUHR<%k!zr+?0QL{?~cR=i%n8d`5h}Ke{}h zzIytX=X1S3{mb(?e{)dvUY^gqJ^jn`8FBND-y_dwp5=Pp59RsvgFOH8eEM+nk-uN^ ze69<5<6oYSv3bYiHAJfC%xH~!`M7@K!IPM%NS%JuyF zl02Wf&u4x%PnkF6`KpX=!9U!Ko8Zl3bK zC(q})+dSoSS9w0`Yi{cNFVDx=yyJek+xC^b@xRVfUe`~bzn{n(pYz;& zd@j$&*u3L@x!caOyzyBVc|Pkd&%ZpMKHPld{al{U?}EJXFVDx=yyJek+tw>@eCn0w zvySro%k!ys^O5z+^I1oE<6oYSv3bY+a<}bgdE?)ll}}wy|MGnLdGnF|EYGJddFOL^ zKE~!9_siXOedUeM`pWa^TY3KF`K<5eBiC1+Pv6QL|MGl{%{%UwyKTMl#;0C+KIHAJfC%xH~!`M7@McuFL&GV-hJjX&zq-wo-beD+|>6ljy#|FF*oI3p3gYu zru@tEF*Z+moIIcJ-8^OfmFM5wF=yp-o|~tfPkBDq(dH?i$IA0LgWdML$>T$n&`_zTZ!=j^?c9hx^RtDWB)a^ItRm+036my?8$Jzj^BW{gkuD zebw9~wg2VKC)fMtDX({VKELmqr+j}Q&*u!D@0%{qr>~y=<@wxyzTZ!=?whB)?#xZ~ z1J|j%`MkL)|MGkcb4~u``8PM^U!KqP{v7}Ee9m+8k^L#pXWrzU&*k|Tn|C};p3gkX z^;{QuK7B6FzdWDcugypPe#!H>UgV8`c|OMG9gmaeQ?Fdldgb}7qdfoeeCpkNWWDly z)=}R0m*-<_-tjnjK7A|K^ZqH%r!IN^<@xmU<|F%Ao=;u!#=krtWAl#3$@5uXxt{AQ z&!=zY`IqOjzMGF+UwJ-#D{uVE^D#E>c$_?+dgXf7E6-;g<@uNAQ}5;@>y_uTj`GI8 zJRif{lz+LtpX)7m+xI@^CXZXbzPV|Ac|P;AdCI&g&u85?PkBD_e9pk!)cIVV&-s{} z@-NTl{$Os(zdWDwH#g;9p3ik;ZpyzrAH(hZ%iZsD+RanT^O*;8Q{!Kr&vmhR%IB!^ zeCF-@zn|j1w0X*T+I+O!ZRh#vvo7*{?la%-r7w|%}X z-}#s4^E)WdzdWDcsm(|JeM6ql@3Oq{FVDx=yyJek+tw>@eELnE&wX2-e|bLjZa%VJ zc|PkXZ~V*iF*fhGU+%W|PkG~W|CHxbmpuRS{IB!W_xmYk&c7#bo?6~~a@^(}_siY3 zpXIF={VdOC9p(9#=hM%dkL+i8K7A{1{LAw(Hcz={N}0U`OMGeDd$I?&vjvL@;rP$BG3OiPdT6Ftb9iN{_m$=GyBPB^TYg` zn_kxc_i=eX_nFO8_Jcg1`{c)GBlD-r^XVV|e$2{`=iVA>8q!Ic|QIB^e@ln{LMl2+vWMp+ta^1pAk3j_&xG`=3lPo{LAy{b9w&d z`P^qVANl(w&*yrPH~!`M7@K!IPM%M_ay{#n=d+IT{LAyHck_|;%JW%AdE;N6kFj~j zW_$@4GIr*EI{n=a3%uBU%_K4-+RC&!=yn{^j|s@8%=d zSDsJb%A3#2^D#E>c$_?+y5xHHvpk=5l;>ZbPraLutXH1TI?5aW@_Y<)Q~u@pey+FN zZF8%+$>Wxzn@}0H%~cFo2Qn$ZJ+$~mz{Y&m*=zY-~as-_n*yEK9BnN-1+3bD&P6s zJmvK+&u3h7kl*5dx!b;vljn1PmgiH~<|*IL%Jb<%-$OP2<@x-Mf4`sNI{Nl{Y^1%JW%AdH&`3)Vuk}dgb}7ue|Xu&&Sw2<$k%_ zj`!{}pLyOq<@*%*`sSv-hjHZj%#XP#|MGmsF*oI3o{zD4%H!nueDCHd^RGOg`@rTY zpSQ^KInT{g&Zj(|>uB@T_kTa-3i7#m%DwXDllk8~<^0R@>4(iz_Jcg1_42=y@;qEG zc|P|U|6O1H<@qn;GxPlE#q+r@eZQY#9yU+;-p$<9TynpaH=j2*GFK~?de~hPyc_vpJIK#-%s7#R6k!{|1fXnru@tEG0Z{vm*;ced-|8>)8|kB z@_g>+n~%Jo%k#NjgivePhIAw#=ktD zKKy<^#k%|dqu%_mzP^WQJ}=M5@V|S?zdWDo=;>dc&pMi$8vpWq>hj<9GP+5c|Pa4`N;p?M4r#Q$*cGBe2mRI?w7mmeM8>(%)dOJ zb(iN~o=+ccKJxw}&*yhR-uRd2V{G1Wzuax>l{Y^1%JW%AdH&`3)Vuk}dgb}7qrCAi z&&Sxj<9@l@{=G=v`1G?ppStAvm*?Nylz(|Xb#0#V??3W_UH=gm_-&zG-nZt8m&N1o68n49u1&u1KSQ~u@o7@Ma&PM**AZk{s# z%JaDon428e=PmMl&ePnKe|bLFk+~`V@_dZl_BgqpKA+z_wLG8s**xX^$n&`_Hc$EA zv&i$A&&^ZLr#zp^HcwfvJfC^qJY_%2^Qm|9l=aHjdH}BXN@_hPDu4li=^XY$i{^j|c|K=mlU!Kpr z$s7Oje2mRI9w*Od{^fekzdWBlm*-!e&;4ifk@p{YKG%!9@h{KE*u3L$@_g!*>shZn zpLLYyU!G6Bn~$tlp3geU8~^frjLkb9C(oy!<$CtBJfFJc`IqO@&*q@~%k!!0>0h4D zh?{r(9(g|NE7x;<<@xljJpb~1)_3!f>nqQvZ{>}Dc|OMG9gmaeQ?Fdldgb}7qdfoe zeCpkNWWDly)=}R0m*-=coANK$_jA4FZu>sP+~je~*EctwG%^En@LQ~u@o+#k$M`IqN&{+p*fe|bLF(dMb|_fyQY^JH#n{`r$!&v`aC z<+CpGeAeCElz(|X>$Q2x^^)gv|M5Lk<6oZtGCno=biePR+}`(49<@B5`^@+IDdu7G zl+RbqP0c6QyS(}2cYO1d&;RB5jJWy8{c^YMD|zQbAIkIT^UYIU7xH}i(DzV{e|bLF z#rOLu)_wDo^R#(qx!d;J)2H9$`TRXZ-g;f0&v|Y>vOnedTo>}jzdRpf^N#!FZu@*& z-uU#JJfA+7=U<*re{MeV?;G-bt`~XZU!IS#dB^>7x2;#+_|z-UXC3AFm*-RO<|FHs z=d+IT#=krtWAl#tfMQQmr8o=-n-KC++X`K+(J@h{KE*gWNax!aES?lYhJ#&6EQ@A7%Re0_6M-@`ca zeCEg8lz(|X*xt~6V|9(Hk{QvaTSIrOouzAXUkms{r<|gOe^^)gvpV>U+^Bj5pYsAk+ zK7V@geC|u;tlZ1XJA9<@p%T_eYoKv%XLN@_g=Z zPyh0K*7y0o>GFK~`RQMtPhFdLoF{ocb;$|MGlB+_32-p z&;7?7)cIeY&+o$1zdWB2H}AM#?zVj;?|i6Np3geU^Dob*uFXf@Z{_){qrCAi&&Sxj z<9@l@_Orb4>1TO9b;xL@wJ^~xKcdgb}7qdfoeeCpkNWWDly)=}R0m*-<_o^rq3 zZO41}na@0Lp7QyOe0_6M-@`caeCEg8lz(|Xa@8 zJfHd8Jmq}K^ErdfQ=XSRpZVWB<^0R@sdw{~^~&>Eugz1gmpq^Q%;qVd=g9M4m3>;_ ze7<--^KZ_|zC54%%;qWkL7va~f4si8@h{J3KFv+}m*-<_KJqwuK6T0U>^FHn^_rXV zFVCkxH&5B0@_c^Z%}tGec|L}@DgW|(`t9joo=^XOzn@}#%~{P4eQR!N{x8pG9lzgC zF`wqF=7$;FyyLve^O}ZtfRc~FVDx=yyJ25{F|HfynjA@>XPSQ-uPeVsqgnw&K!Na zdCI^4$eT}&+q~mw@_hPPu4g~X^I1oE{^j}f^X4P_S)Nbd${YXkd<=6_{^k09uD9H6 z-XAbgP+%I?Ay5#xvn>?SoHc#3A^8By!l>NDR z%IBh+rx{&9yzW%$u#=ktD_4VKN0h4D`kI>>|MGn5+B{`H%k#g^Q?9Q$E1xrXzCXG=pMHD#m*>;xPyh0K&fgr= z{9K;TygmKP^BHmTj{D_qJJ0gYhjo$Xv+nZz%k$~O%}3sU6mwJKnp`eCGK#=ihgkXXWdgoBAHck>@i% z=BE71^BL!Ne#ZI8^BHmTl;0!I=X*C#nSbT^+y~4}j_dOlc|PZFZpyzrpX+GzlTRKgjbr|BuJ{ zT%ON-nwzTP@_Y<)Q2yol)cf==&!=8xL@wJ z^DJ+C)nqQvZ{>}Dc|OMG9rw%KwqAMTQ?ERqb(H5{o=?4-kE~ao z&pOH*|MGl{%~S4|yX|=IKJ%I9-<&-4{eH?BPe03>Pu9`glz(|X#^xQ5ljqY{ay{>d@_hPVo_~2h z=ehaF=lSw{=1t!Cm*-<_-tjnjKJzTsb6w>5^tn9$@_gfL-~z4Cn4QQr8M=VNT%@i=)t{VdnBpXK?~CC|S+pMKta zWIxOEsY~AYm*-<_-tjnjKI<#jbA9Fc^sPMq@_g2J^O5T-&!=zYjemJQ#^xQ5ljl>f zT+e#t`K+Tn|MGn5-F#%d@_g1&-uRd2W0;%rFW2{Tz2$EEJb&}l^7a3t$zS^NeCEgZ zP@b20Q=ZSd|IW`CU!Kp1-|wfGhn*Ln-)^2--f^s#xoOu+p3ik*ZpyzrpZl%3DgW|( z40BWd<@xlFxhenheCjnflIPQJ@_g>Ao2RT-o=+ccp7Ob? zJfGk9@Ap%z`~G`B=gId+O4}e6Fvj&-$91@-J_E`q|u+e|i4RP5GDSV{G1W zzuay6O5XVNp*){Hm*-!e&v|Y>@_D{IpLvrv{^j`?n|ItVcia1hyz!ZTc|Pkd&%ZpM zKHPld{YRe9?}EJXFVDx=yyJek+tw>@eCn0wvySro%k!ys^O5z+^I1oE<6oYSv3bY+ za<}bgdE?X1@_g!&=U<*rKW{#=pXK?~C2#!8^D#E>xL@wJ>nm@3)>ocS-^%kZ&u4u% zAGyBreEL@2_?PEnY~FFd+->WXH$L^s^I1oE{^j}9yZOj^<@v0myzwv3$JjjOe!1I@ z_wF;FdEPwb^L+XG=BB=fapd{TkGU!T@_fcIH|1ZRkFj~m zo2Q&lc|K>bdCK#W=QIDCr<{LzK6P!LvLEF6tjp%9@Ap%#2=i%fk~*LA<`csllz(|X z{r2=P&*#2sZfg9?^XX4>Q~u@o{Jw9V@_DH|pAnz$n=a3%-=6;E`Skzy`zhAfoYnmB zyT5tL=d1Gko15x~%kwcd?|7U%pT3goc|Vlr)93R1%kw$U%}4g9JfC@!H~!`M7@K!I zPM**F%k`Xpc|LtE&%ZpM`_JYh??3WnP8^JfC_u zA6c(FpLLWs{^j`?n|C};o=-o^_3USPK6T0SFVCl+Hy_#0@_g!&H~!`M7@K!IPM**D z%Jp1dc|LtB&%ZpM_1%2r`pWa^TY2MOo{zD4$K&Mr)GODsUU@$2D9^tnwy$W z`a#}&vR<2~TrYV(_n+_gQ_Sb)Dd%bP(Q>!H-%oj+(}(7)=7&DtJmvjUo=<=J|2t9t zU!Ko8`W`C(@_Y>6E9GCFPhC&{@_c?b%}tGec|LWSoANKuzqu*@@_dZVJMNde?elzj z&)-9y{^j{!=P94(o15~PH+koCc|OMG9rw%K_W8EF@tJ>lKI<;ezdWBl+xL@wJ^~xKcdgb}7qdfoeeCpkNWWDly)=}R0m*-<_-f_R&ZTnf? z_%~Lb@_hPMo_~2h>$~~L^_Az- zxAMlnJRf88j{D_qTd%zFsaKxQI?D4e&!^taN7gIPXC38@e|bK}<|+5f-FCcppZU!5 z<|&`&%hxwI^*xLu&u4zjP5GDSGmg0_|MGl{%~KvH&*ytLPnmz^`8PK?uFqS{S^1pj z<|*e>p3ik;Zfg9?^D%bYS?+4}i+-LUR``HijeD0GUukY<#F3)G)%uV^1=VNT1@;G@u^~&|E zSDsJ3-|wfmFKwQ(4>wOOZ$4Sa%~Re#<@v18<|Eflp3ik8*YmoQ=d-?>r|f5WK7G4+ z%6jGbH#c=Ym*-<_-tjnj{>@E#{=PhY`d^-ZdEnP8^JfC_uA6c(F zpLLWs{^j`?n|C};o_}+bp8fpvsY{-JdEXqwRuRNc1l;>ZbPraLutXH1TI?5aW z@_Y<)Q~u@pey+FNZJ%43n>=p$`sSwf<@wCd<|*^0JfC&nJmvYw^Em@^Q|EJeKIda@ z%D+7S>pbOin9Wn3r@5)|sY~AYTt}OyeBU9@XGFIf|8n<#zn^kmnE#)?{vBrX!@8TB zn$OGgSub-_{^j}He>P9~oJXGj8u8PS`E>v0Bj4A^J!-kf+YjcZeC|K;e9r&lQlIL@OmgiH~<|*evp3n8Z|K88*U7pYHyZ^4Q^SL}9 z!}m)0m*>-0Pyh0K`rO>q_?PFizMH39UwJ<3Yi?@%%kweJLHU>GQ`ghKJfHP7H#Pp{ z`P6G}%D+6Hb=?0y3ZI9|^BHmTj{D_q+gI|==jN<@`uyo%p3nJjKJxtK`OKTV^SL}9 zWAl#t@eCn0wvySro z%k!ys^O5z+^I1oE<6oYSv3bY+a<}bgdE?)ll}}wy|MGnLdGnF|EYGJddFOL^KE~!9 z_siXOedUeM`pWa^TY3KF`K<5eBiC1+Pv6QL|MGl{%{%UwyKTMl#;0C+KIHAJfC%xH~!`M7@McuFL&GV-hJjX&zq-wpCVu1+|>6ljy#|FF*oI3p3gYuru@tE zF*Z+moIIcJ-8^OfmFIt*r+nVBdCGY+H+de*8=vdQ+?0QLKE`f)oZL^J)9%0bTb|GS ze7~P!9?V(I59_jd%ID|ueC{*mCfCX5Ir99M@tJx4^y2y4mo`uNzDAzUea76>*q7&X z{vWUJ&A&XKc{4ZVU!IR)4$8kgpL(DE<@wZQZfg9?^S{nhUhkWyd@j0qYI);x2AhvO zFL^%wCfBpy|6H=BCEKJfC&kJmvjUp3jJzkNh5aKK07=tXH1TI&Plw z{wB|-uFX?kkMjJl^OWnmdCK$MytBOVZ*J1F-yA2OK9}cTp8s{8^8C$B`OK%h@h{KE z*u3L$@_goBuIK#A^XUh9{^j}f=jJ2(Q=ZTDB5(Z5^D#E>c$_?+dgXf7E6-;g<@uNA zQ}5;@>y_uTj`GI8JRf88j>pOKZ*J1FpPxQ;$@4F7{IBzr{cLW^r!INpU!IS#dB@}A z`K+&8&-In()3@^c%kx>^%}1`UJfFUmH~!`M7@K!IPM%M_ay{#n=d+IT{LAyHck_|; z%JW%AdE;N6k6~`gzg*wX^_IKs`xJAN$1Pvq+_b(tpZVE5W!{wMv+kRxJRf;JXJBsX zd@j%De9TSxm*;<-r+f~xdCK$LJhi;>xsEnZeZQY#Wt=Dfe z<|*^9Jpb!F<@1)!Q_kDwspXB&b+mcP=dtp9D%)-AmHX*)+VA&M^p82K`Jo>+PuUOh zeAa98l;`!W{Hcx%OpK{)~ubP{rUKjG_^Xok2^}cz^ z=c1dZmN!0Uu=&XIlIPQJay|P^o==}|p7Q=9&!<1lO^ttfKG)0UDX$lKJ|k{E@_Xd@ z)GODsUU@$2yLrm>mFH8}<|(g7dH&aV%Jtnm<@s*jS>E_JH|g1Lj+4*zF3-O_|LZ*E z`J0>anNNA+U!IS#dB@}A`OLpu&-s_<(+~3e%k$~a%}4g9JfG`D-uRd2V{G2>IC(zx z%Jr;Qp3geU^Dob*-pxnWE6-;g<&A%NKE~!9kCW%$+@xneKYi+w=U?9VU*{?N+1!** zUGm1iJRf88j>pOKSzo!H>nqQvZ{_)y=d-?>k6d4QK7A{1{LAw(Ht%?xJfC{yde$q? zXC3AFm*-RO<|FHs=d+IT#=krt!`zgAxxSz4EqB}J_U0y!TfV-zX?=M<^Rs!%yeZFT z-8WBpKJt9dz}(dNT%OPQn49u1&;L44`5b2Rl;^p5YI);x9hsXtpUd+x+|Iw;{XU1^ zJheQZdHCJO`<=`4xi0+wMelqr&u2dU|3%NgJRigNQ2CeV(?8~>{LAyH%iNTIc|Pl6 zZpyzrpZkxwDgW~Pm+`5|r~A!KZu?$F?orG0xzBvRpJE<1PkCLNo0?DhQ{H^?`@VU~ z=cV#|Ml=UC{^j}f)ziN`pFTG?HU8!K^x@_ypF_&?xh~92jemJQhB+wz@_g!g`j_Xk zj^?JuzdWCM%}x22=YO52T;I)89=CaCx!d;J)2H9$`P^6Ko&V+eU*{>$-`teXyvZB? z@_dZVJMNdeZC}Y7pZS;Pv+nZz%k$~O%}4%yL!QrdA#eQ4^D#E>xL@wJ^~xKcdgb}7 zqdfoeeCpkNWWDly)=}R0m*-<_-f_R&ZTnf?`1G?ppStAvm*;<-r|f5QQ$BUc8~^fr zjLkdlm%Huy${U~cmFLs9^8Cy5S>Me^uCF|wzLhur<@p$!cib;`+j`}VPrdSd)={2+ zc|P@SKC)hUKI^|IJg*zdWCMH&0owJfHR2 zJmq@H^SRG#p7ME)JpWbMrxniUi{~@{o2Q(Ac|P}<%~SS+JfHLbczthYb9p}V>A&mC zzdRpf|NWlF$@8gKu4ldSeCjnffJnLz4H98 z^OWnmdCK$MytBOV>8q!Ic|QIB^e@l}0UU@$2D{uVE z^D#E>c$_?+zLo3w`!3I?E_wdt`CsQL``O%-PhIlHzdRpf^Nz>K^I2cHp6e^mr*Gx? zm*=y-n~z*yc|LtBZ~V*iF*fgboIIa;<$BgD&u1Ow`IqNY@8%=xmFKgL^2WbBAH&>~ zf4RP&>n(TN_a^2hk6XUJxoLfQKJ&AA%DgGhXWchXc|P)d&cNK%`COjQ`IwvXFVE-x zU~bC4JfHJ7H|1ZR&vj&O%D+4x!|nXb-M{al^658oRzCA!ZpyzrpXee7b-0(Y}ZBsO27S zKbV{H=?8f}=lSue$*0e$pbQ8 zZ$9$6kT*W_DQ|p?%{%UwyX}2L-uTSFJfC%!=U<*rA8tPK{v*%lx{x>i<@p$!cib;` z+j`}VPrdSd)={2+c|P@SKC)hUKIHAJfC%xH~!`M7@McuFL&GV-hJjX&zq-wo+)47+|>6ljy#|F zF*oI3p3gYuru@tEF*Z+moIIcJ-8^OfmFIIG*gWO)7I{ABxp~U@l;?9DZJzRZtURB} zcH4U8e)?R|+@!ZWpZVE5<^0I=xh^(O`MyA&&wOs4az5qxobl!<>yYO&|C^_re|bLj zZl1DUc|Pm4dCK*Y=X0OgJmvEodH$=iPb-|y7td$@%~{!(=X0MiH|1ZR&-s76zBm8! zeCE^Klz(|XhB+wz@_g!g`j_WZm$|9&FVCkx%}x22=YO52d|tYF%JIxWZu=>3eELnU zXTQnw>Hp1B_P;!zb=*8&-}~v zoPT*f{UFc3JfHsDd}M#h^SNH+jemJQ#^xQ5ljl>fT+e#t`K+Tn|MGn5-F#%d@_eor zdE;N6kFj~jW_$@4GI|2j|E&*r9l>XJA9<@p$!cRWs>&-%*sTwi%U zeJjtuJfHR5eB}Dd^XXf8<6oYSv3bYiHAJfC%xH~!`M z80Mz@%k}+SZ@JsP_c1ql-17C!P3z0^nV-#5=1qA%>%Mu)^O5Is2Ii*D=kk2c$J~^E zc|P|Cb5s81`JBJGDgW|(t|N0({^j`?Zs%X_exEmPo?4#IJeZpr|MGmU3v*Nc<@wB; zxhenhd<=6_{^j}1v$-k%@_gztH|1ZR&$^hK@-NTl{$p;+zdZkCd}{LPesh!CzORvc z)bf1pGn=RE2YEi{`SIz}5%4go>jemJQ#^xRO%iZ?AA#Z% zRi1x&KKGx^N8W$r`TQ=(8~^frjLkdlm%DAf^2VoLc|PkX&%ZpMdN&_guRNc1lsEq6 z`52pb+%I?AewH^r{VdO?E_wdt`CsQL``O%-PhIlHzdRpf^N#!FZo9tn#%F!y`Sh(k z|MGm+ck_|!E6=BI<&A%NKE~!9_siY3UU}nFuRNc1l;>ZbPraLutXH1TI?5aW@_dZV zQ|_0$?Rf7#^O@((Q$Ej>uWxSZdl*Na&-|F1@-NS49CK6t<@p$!r#w!c&-ZSgGXKi+ zxesif@_CCqpYz;2_5ZSW-(fjF{NKlu6_GL$l9@6hk|I0FR@s|MA|-oe@14D6?-7xN zWJe;BnN&o|NLFU|eO%}HInJZ=-SfDP?tky=_s{3&;njI{R$t%i>3#f;pYruoT(ejG zbEMr<%HPK-uGy>Jnf9-h_p7+_RQ_I3yQj2WvsZn6w0lbV`Y5j1tNyvr?y3LXrdzVNo>KlkM{&*9Q~hzRm5poKd<-^Xj=>vsZooy6XR2 z%|5ql_Nt#BrJFSS+^*TH7TSHJe4OH%z3TlcuI!ZetGH&bdS6O6Y4*8Yv(LMylz-l} zdrJ9xQKg$Sub;cKG_S8(DBYyl=XT9r_2+}!=XT9r_2-Xrhtj-$ZrAKp-$&&RrP=3p z&0h6=RPIokeQww6RSTtqH2d7H*{j}{+~;=9UiE!cx=Hi;xm~kYy)W&aQvP{VT(i%+ zr~p(julhOE?jz;jUy5t?s(&sN*Svmi z*X&gb?cPy7PI1j%^?nsscFOxzT(ehw9~IZ^bGv4*dcWFzq`Y6nHG9?fQE|=d=XT9r zwb1Sz<>M6B>~nXMvQvJZ`*(u*&#Wj1?&#mH`eQww6Ro`FjK2pBFifi_&pIgN>ub{Z`K#WnlfuGy>JuXZ0P?^kinUiE!cT=V+5U9(p$ly1`ObGx!v zp4vNYSAMPBeUxreK2F=U_ewWu?-keVRbLF>Kam`-!eb??O72}uG#0^Q_A1NX!n%zc`Dtcd41LUQe5-;s(+4@Zqn>?yJoLiD8JV1 zbG!2U%HQ8=_msA4_NuRg(oLGz&+VGM>Yoeko>J}wifi_&ujl{nQ>s6gw0lbVIw>8b z`TDE>x7MnsvQxg!aUdXgQAGCe7!Q+co>#-K5#) zcFkV3(C#DU_Z3%ut=wf4*Sx;!&j-add)1#a+C8QGxum#euloLK_muMeRa~=IeSfuk zO8NdOuGydteqV9r*UI}JehuGy=;zuG;ee18?!>{ahq=_bwV=XT9r^?g*j zNwd%Gn!ReF-8;(fE3W)n`S*z8n%7tTyeY2PtA5TE*X(n)feqV9r*UI}_p7*OulhbJuG!~y&0h6>wfjhUzlv-2s_&!X zn%B?mn!ReF-8;(fE3W)n`FU1c^ZKfvXT>#p)%#Lhv(N3Cz3S&#yN{HgXT>#p)%#Lh z^ZL16vsW#&dq??w#g$(x-(STwudn+4Dz4e9er^@l>~p(juloLK_mT4bRa~=I{oE?9 zdHvk3*{c@Xy`%iT;>xd;_p7+(^;Pdzam`-!eNiuf>k@9{O*X&i_N5wU- zpW8Ki)k3?cl;2le{p+1$TK{LCq<$LutA1^*e!8fi{_1C-`WdW##;Tv0>ZjpY^~bB9 zF6yVh`WdKx2CJX3>Sw0(@#?3G`suHJ2CARI>SwI_nW=snj#q!Y`st#6`m3LT z>SwU}8LNI~s-K1v)E}>Yx~QN2>Sv((8LWQBs-Kzar{P5P$E%+%>ZiZ@8K`~+tDmvz zXQujTI7$8S>ZgnP>92kUs-MB?XRP{}seT$xR)4(u>7su6tDk}DXR!JitA1vxpN3P^ zAFqD8sGt7oXQ28StbWF-pPA~X;Z*gu#42%oq=7H)-Duwv0A&cuzRAl3xi#f*6tka(zJHru*=liorhhv*6srAbWC#p zoL+>Tp4Kh`c7|HJORzK1+C{>ys@Co@>@2l*S72wYwYv&Cd#&9y*tOQ$U58xfV zSlI2<+TDlUL9N{b*ad6t;$Ro1wR;G=NUdEw?4q=Gk6;(8wR;S^CtABFuuIa~J%wGG z*6tbXGPQQkVVAA7OMsnDh1`Gsy?~vb)-DlthFZIqurtxxCBd$$)-D-#mRh?M*ja1s zUct^@Yxf#<|Kq&B0?L1HtZJtE`3g+%`Oi@K?~U~JY_0WmPtE(~bvkJ6-oVa9Yxfp* zeYJLJup6qidj~sjtzA0o{Izx&u$!W_dk?$WTDuRhTdcMF2)jV7-6z;>(%NOhZl~7n zGwcp(?XqAOthM_ByD+WYSJ*{r?Y_Y-N^AEWcClK!AFz9(wabQGlGg4g?9#M$zhIZC zwfhabY^~iN*y&Wv{qK{%u+!7p{ezvM)-DHjCR#h40(lPuALjmZr~vFXY3+1jw^M6Z z5OxQ(c760pnE z+LeS|w${!7b~^F7e_l$#PETuR2s=Zqoe}Izw05OoS5<3Q26mQOyRxve*4mYWoxRr1 z7po1&oe% zEj_|5Ui`I86YyleHx0kKrHXw5_?R2d=iUALN$j_QFS}XuW367_#6Af8>ci>jGmice z`zPS{xBN}tsH-FXdg&$juZ)0Emrm%4eVO-pd-AT(UGakoi+vjS%gOc=m_{W3hh=Uc>d|lkd$;#J(1IXx3Q& zXi@@HzdQvR*}07W)<8ov(X->Q%jp*be|- z*S?GUFvqH5zXSZOUb1VM?{c37KK|AHPc05r6R$r5e3z+}-;06O#r^77yGl|As_qJ)Jv87Q1Cv%PFc^l z)Do}n4qhZ=t;Giy3$fP+uj18dOM{}8Vs8mPuCQL&4HxBpDtNQqh5D49P+Poy8}L`d zlWVT8Q%CIIfZuP~!`UEN?jM1BO+CG3^v1g4^*z8_AD>@wN7s5{?+70L^XaEm1+B#X z9Qe?^m*>Rsw-KV`aty-gj*pC1&u^{1bhsSbn0$!qWvrJDX zYw`L9;1iNF=ik^N_fx>D`|bFC@rT@7fd9F2LASL_L-G0KfX}JZ#;eUixhJ1EaOeBb z9J!wauDh)Mto6MciO;7H_?7MvjUOD9`zUaW^FxNY>)MFdw*vR{sIuRokK7Lf4|m+F z)ANYjM}Qw*x%Ante{z2Ud`72!CZ?{9#pgdAyzKEzi}2lYZw9{Xe0PHhU*vu@xWkgb z32hy1#plxoe5c-@5VJLMe-Jz^v3#;_lH7j=e_vv4{JVNh#OL!7eBa@0`+HO5{s_23 zeCfp}uF8E&@Fyl26&IJZ6Q9pB@OFCrYWL|a_Z`8P_bzj{(hj*_4W8ewa)EAoaU}1~ z`U~9@2Oa_4v>5ylbki2_SI|uf;Hl6}kH8I~n+kzvKsUVr&xCIJ3Z4Splmy-ix`})~ zbkl6`GSE%>;OC*6E`U=v4TYZi2Hm7{F7M8I1KpGXULCrrHaPXvMd+!&&`m{a<=t7e zpqpxgFN1Dc3*Ha9X)yRk=%$_EpP-vQfKP*N3IN{=-9$a52i;Tz{5W(|FnCMorWW9b zshhyhLN|qhdq6i)PZfi1G6t^>-BcHR0(4UVcsuAOXK?DKbm*zO&`nRlheJ1cgF8Ss zxqu&qZlcZ_4&5{gd_8p27VtsPOH?0J3 z3f%)Rktv%#@s(5_fUU$s9IFkr@ zpK=7(8x&umW=VOUG66ST_sCN3g1k>P0oVC=bi@-Md7ml{zH^HG)(}&9pE?b`^Ujf; zXYb1U)G_d1gd7pX<9z3kesL{*ieJTXJM@RQ-kJ9CRst@>!F;N5Rb&~g~6!70`%B7Dx zEbmi)!3XyncJa7=CGqz&L&5h)F5i>lEALZ>z&lkc_^8xgA0a>d1T35%90IN_069BKLp6AKt%eymN%SPdx+QwDQKLf0g9D zDG0pZcHhs}Vqc>KFeyY~y^eJT~)eZ;!SqaEbE$sgR>(&$+8&vI`AUg~DA>uv|+ zeX1h(&)~4_dj`q-)Iac!9%l;IC@b$xJ-|mqcfNAndRCpL z4eaH;sU7&<7BRD)eU$qn;2nHQIeYJu_bF%aKMh?1Zw!$4DV;`nyXnGX%TtWxy{R(z zk1Kd-h;fsm)$PBTeqLwF9Cm0`t|s|hvoh`c*Mcqn}+?C`)lBXI{d!YsI$Bu zd4LDaebwJ+i`?%A@A2&Cd^vk|Ie9;d0Izp9$JJ%9+*^ZBFb)4+cE8+D0ncwwMM5`q2X6x1qz7L7XWl*a z0eY$|bW1$Dx}}g7<)K z8VJ4;x@jG_19Ve6@Pp7z2f%+rH~j;D4Bhk`d^>d0Ht?a)P43_+&`snX&`rMJjiH;G zfLDTUBL4&3RQzP#oz(@psW(CL&`tU6sj1LYHqcECz`dZGMu4w^ZVCjao_Y*Dbp^WVGI)RJ zCU@{%&`s1+F3?TAz`H^>bq1%N3WuI@g>LE&ejd8%EO<@mrrO}X&`o2&^V?JRE}TtR z=O^z|MK0#;Lt|H)Rv9DjQzO8?=>L0Ku&lgKl`fID+v{}c+kULPPq~8oM22~8xhL;a z3&3xO=os%RFYi-{;Gd#aHfR+k?^7jikGLsXcf?%MUt65ptgj{&(`;wQl3&eX8J;yuI4oEAw({ z$$OI}xbEt!Nk$2BUmV=4h)c-a)$%?y8T?g=ML#<_%X?E6_|&%Z_YVFm_cOpJ?Q+-{ z8Y1sgbHSh7yuQEvD0!cH0q)+`cAIWBd2jLoud-3!{>5XtuLYj%=WZ9ZQr@R>z&*x4 z>wnrw-kZF@4>ub;X7wMr4+g*b`)c2AA@V+T8N6V4PqU{Z<$bCs_*;92pJr9%y(ta6 zOV1~sB_7FrFK|DPZ`Lc8$@|n)@Z`!->zB8d_omd4|-EX-j8CzUvwHiW7ZJ4PX@odcuLm#vvN<~E~nNmvr_VY zrS+-HG5IMi~G?s>V7 z2R93i((7*^??KhU)6-VGN*F5lY2X${EyvG2CHL0giQ&WJ+7^`epx5AAf~~F?_mKOY z;04Cm9{sUP?)AXyCi$Fw`AP0=z=u4DzH_U&ydMn(uUzi+&XbGfz6N+uX1Vig9W34AGZ(>(Ab=%!fk!q82>ptI7Tn_htHLN^ryp9|eIA6yr@sVKM?bdx8zJ#x1?~vl)E4{|bkiGf9q1Pd$NddI(+(x`}$~BXmcA)6L|4DgZp%=+{}hS@J&h0{nJd?F+ie@;>zxeCEcsSq9bReQGKA zNSzhyJRi#Y)J$-fo*xG6S|smNZs6}nesz20An#M(!5tU==z>D-cc79iXd7ml|uIqDe>58H9K2-wTJM*b)tFrRm zG!EP)xqJuZ3#PZ@!`m3s8}Q$u-g>IeQj<^1`sZ{_|Kcm>P)JBx0Y z_o+JI8^c{EmFpqzP5Z&erpDCpD<JL<(|BE z=7uIc!{vS`_zc@BcgyR`d(Z;#$Jb5w6q%C+|l&;GTtj2L}eqy$^WjGQ|gte=hef;G-?4hIBQT_oFf35f={bs_ZBC*TIYE zd$dnEBlji2^V?JJp_}}{jXvbvQz_6{%b=UQ!Be4|9)hPpHzk0tf^M1vJ{`JgEO>9| zrcU6$pqq3?<=t7`pqsjbXG1sr0dED}L_L)T-IN6W2)gMBICYab^ppd1Q#voyT7Z9pZpr~)1l<$}UIDtv6x<%V zsRejd=%%{h)KiYoQz6hzQQ$$)P1I8_pqrAxGoYJ3gRg;Z+5+wk-Q)+Z58XsPH3hn9 z95{88FZ5I@bQ5_)=qd7F&`r7x^X{w$&`s1++0aeYQ|Zu6AHidwo5+7dH&JKxhi>Wz z-WGa_ybp9!fAG1`O|!w{p_`tAKZS034(!-lr<`&D-lw z_>@z2g}hHWfxA!a|I;-~-lwL3-yYrZvTr?kpLzyfdhbr(DM|7^RS$fSh24b_>*amQ z6MV^p)c*ZC%lp(e@QQ==u8!2z7xxr%aQ*R3jZTNl`&1?H*v%b2S~ipSsYl=~%3NG{ zY@@tSwE_S7)9_i=H+i4>0q#|<+b7*#@;>DaK7XV4**B-liLcKB@Dj7EviFsf_o-6g zt^AtXIZu}NskY#mj^_LBJ(c$<@+NDp>p8ZN_bKuUafOfU*(L8&6~UKgRB+5HVkW*m zYr$_;8vV-3SKg=M!7Ge9{-yRPd7r8dUU;VN=LTl--edrNV|uxp`yR;sJ@AH0?+#hC zNZzNKfS=1MedJzqd2hM|Zr;>#^OP*Pw*s%_SHXDtL3y8Q0$$S8p~$_#@;+4wJT)QB z(WjieH@yR&`D?=tr#o`L3_QWz^|{+Td7nxKZ*%@q=)z|5-qacVn*X)5xX*Hb8@y|$ z+qLT*lJ}{e;9HvAZ#sLZyiaWhKlso2-KFyK-gF$i-|P!Dp52xE-rx`Zc>lSuK;Ea~ z!Po2#y3nh+yf>`|-+jsGYhae#9|He#F@0(OgYrIAI3jPKXL>4r`yhFr+6u1UaBO__ zV)A}u1a6gV(8A0^?(2i!{xY^v=moit0rw5;ar9+5c|RHt-n(qc^{f2kz90Dbao3-O z-;jH9@0=17dYj4n(Ma$}Y?vcL%Ti#s6-FD{|imywkcpo0Ce* zdyp&mh+n@8g}clBXmH!p27y5*<=z3jmFx4d%W~x23H(|{zui;1$omob^QfmO?wjQP zCHO}-)9dYD$^9pA%hMH4RCVf$ryfC1Swc4z1Md#q)Es;sbklV3m(WeI;I*NfDua7NHw^#}f^OOcUI)6VHaK;Y zDfHA+=%$C@)J^u#Q`AjAp{GVbH;n-gfNoj@PCZo`da5OKQ+x1_&{N;RZK0>yfLDQT zG6xTYZrTbS2i^1>yb^SiIk-M_6L}1D(|vFo=q5Yx2Vw-rH<6cuZmIyD z4&9UiPTjN=dMXjR={JPpRx@i~q0qCYv;QgVS27t#vH>H3t zfNrABIsn~t1iT=0lOA{=bkipA;?PZo;0>UgsHYx4H{AiJZkh@`H3+(id@S_TIPl@n zO@83Lpr`tRKZR~e0H>Z>13l#r-82?F5V~n8cxUJ)@)6KY-r#kho9csigKi@Cgl_Ty zw}WnK2JQge)EfLY^wdr8r_fEw;NPH|zJQxUH&p|l0NpeN{33Ky1bBXXD%-4k^R}Dh zeX35Cyxn?;wN2C}d7rWYuRF%GdkY(RpK=1<-!7{|;ud+I3Io5}zP-cZg1^Q8f2(Bh z`-UghUu+`pQ%T@@Rp!J_doS-()xdwn_|>bpN8YFYf&bW$@++*ryiXO`n70>AUDbDd z8F`;71>USz#MU{D1_U)GUsXE|8JqARdEl@_>N8G_< z+_o6587A*j_rOop&Fb0WN;&cRC&Bl1x3<1qL*Azjg0Bm4`&DD1yiaWaH@kf;bksX} zpQ-{L_xokermpfn^$>jgd%4Ov zXUEI?RDbXR|JoffvXu8GFYr=My$d`|ko$_@Kkc?YEw)D9r*gpcnvE$FL3CPZ}lfQ;osHo1UoLyPCW=MS$0w*0Si>CvtBM ze$2Y3!-ZAyJ{1gZr@!96uCu&1wFX~*`*Q!2|KxrP_;7FI;8vmXKIH?xw&QT?o4)cs zwE_InzTd~}%;ml5I{4;`eNAR3$o&Rzhou)6uUsqdQ?0;jblc$K(n;Q%$Rm@&i=EPu z_okcRrk7_N3<{O|THtGb2dpYITHdFQfVUj6`oVBRc|URjf9^iy%$QMf{{sBX$Q8xQ zU6cDT@B&`8ah)p5`;i{_!>4Bp6`3UWPr#eqxWB>SuG~9-M`xL>NivuBqZsgI$3L2- z2gv<$@Zr6>uj?8o_dei<2ih#ssV(nE!Qg@3tDk1ikoy(j&vl00s`o(d6TzpXcF9>| zF7HP(z#l}H+FpH%+{c2~m~7uU?v~uw121`~Z~N^PFC=OLi|R??HFLYi#kl)uN}|n}a7D8{4w>PPtD3cdrvz&>%zZy})O-*gpSV zV|hQC4X*bnsz~?@xiZbb8Q^%p3&Vx6F zZfXa<0lFy&d<=BcSn&1GOZy^?P5JGq6VOv@ zpqt23pqmoFr$aZ9$3r(g2CoU-WC?Br-9-Kpy6FvgVdy43@T<^GQQ&o;n=HVeLpQww z_knKm2A=`lGzDB2x~VXDXXqyK{Pxr}vqI%c4iczNJv zLwTR74BqW@PF(srd7p9t|FPgl*vD*npZX47{_Lx3j|R#6lreZ_$AEWxugd!rc?XX} zi~H4)_bFHKlIx;|eOWETdGa{ciB5E4L2wj+Xo9;MV4$o`-A7`%x3{l+N4k_|K60RPYPo z%eDo_%RPCkL1o_!wvzXw*5HkE?!WP$FZblOb_0GseYAQj9Ol{X+1wX&u)VDJAbgk>C~PWIg#lK<+DpCk`Gl z=hXqZPX+I?Y@Ow;EV*|B?^esI<-X?fe&h;nx%Ee}Nekq@0l5FWlgFFI$o*vS{PvVF zbkiE>tai{-2H@|Zn_|GbLN_%9Zv@>`7koc-(SreLrC|-J2-XIKDR^1vrgGp% zp_?v)pN4Lt&KeEfG!}dxbkkw*IOwJX@F&nsiQv>tK{t_~gPuAM z?f~871l|aG$`;%nx+%Xs6$m{w5xR-|1$5IR@DI>U@4=5iHys5Z2HoTd?hV~E0{jwm z({=E<&`tBf&pd;N*;6Bhz}8H112OPO=kS>C4>g11}}+}bu&-lw{OFFUlh!(nrIpV|tZn7DD1 zb!T~>`UKu+pTW}3g$j!Qdz_Bo4_ZzQa*UAosd(_?=BZg~|I=OYmMcKWi9NkoT#6;QC$W*iW4% z?^6cg+b*rhIFTUlQ`^CRT-r1BTq}8>`UgI+Y^$WLd*pq}9XxhM*INVhDvF<@?NUDRpPdS25(r>S0wO8J!mVg_)iRf@>p}bF3 z1pj=&`O-lLd2jjyzH|HQB}Sj+{s{QB2DJvi+%NA_x50OJeE6%xAbFoU1g_I>Z}oL$ ze0FKi{*W4KDeXz zn#XCa2AopS5 z79Oeo|LV&7QGIaRPA~r4n=kkF;NgeOe^q!P_vGVd*IjbIvAiEm0I%;Bk)E+k?i+v? zzMZmiaEjcQ05@^JP@{^yydRl?zv|$>x5f&&PXhmWDP@FvvfTd$|8=B6g9nY}{pcU~ zu;&prqZY~i5b#=OA2zQ3RPGyqTWy;?KdZL9AK8MR(u*$haH`ygg9nx?Ix{j#?l*xq z?q9FWDPwsLY7TyWK-J_u9&&#PyyNdD=U1PQdlztz?~d)J{F3{T;I3m+KJ;uS??*kr zrv()+SZjsc&jG*k;o5=phjM=lJik4)9J;9-cvI-6QsC>Mn`VLchHmNvz6ZK#7x-uB zrq|%@pqm`PA450Y1*dMh2|ZO6x~T^E7wD#+;4#omx51l3H`#&rfo|##UJ|;g9Qa!3 zrXcX2&`mkugP@y+gFk?7dJIlI-E zPTfR)0lMidxD|Ah4R~|tCi1h;Q(@p^pqr+ETR}HbPw7E7>4Q^GRfe8Qg>E9(iOjpF zsI&e;H~j%04&CGhZUNm?2fQJ4lQsBB=%%ya>!6!9fH#6}vIV~i-IU*+>JB~S3*9sd z+y%O+6Ziz^rpe$Jp_|C_+f$PpROsLQvb;~71g~sX&M@M#yiZjEA85A6BhyvhrzV3( zy82hWdR5-1;=pT;YU{e8iM&tQgRfYXmeHe^yiWyz&oBznuV^UmQyai9E%%QLkCykT zo8a}n=*)3jEbmioz=yy4Zu-Yb-lrykTMnD#cE6B;xR0~~Z!oN1jfw8^K4lNS;70MV z`d8(BYB_jP<&~j9HRXLO6}+?E9N+s3<$bC<_}726jqkjZ_bKxJ=dNAa&{f{2hJd>@ zec#OPl)O*%0iWR0xbUg+@;)^gJf&V4+u}3jeJT~)C9{cFn^bw9>Ir_Uw%`6fUFCf$ z9=yVBCy&md@;+4$+@oB(qa_06eQFGNL6_I920O`nlL7dPhU<08|CalA;8h;nTGQyH zyib{fPh8z<-;ojWJ{17o^!vSx>1OiY)E0dBHm6G4;^lra_?*Vw-V|IR?^CP5-u47N*8lKW5KqdQgIc4~vXPb~niRxq<-hPk{S zS%P~RRq6q_*Jt3YvrEYAhOc%_;+$&7QC;=&GXw@$@|eD@Vi5%wm+~= z?r(!ljOcN__;?tnk;K5 z??;!xPurH7G-i(6UjTo;?5O$RSh;@%{9+V8e%=O>rc0O{y3cQAO>|dL+ za$g&K>)O3um2~AjXeW63)5ty9o#p;Lct!U@y0_QKeN}Mx;E4Sz6Xf0-Jik448@j10 zcpK=ZGT;lKn?{2tKsVh3ZwuYj5_~sw(+2Q0&`nFgZ$mdxXE{PQIfGAyZki0<9J;9` zcr)lGTkxgOP4mHDK{vet?*`q}8$1JgDjR$Nbdx(c_0$09sfo}{)4`LWn?8c~g>D)M zejmE&8Mq~MQv+~s=q7(~edwm*;BTRusHdtyH`N562Hi9nyft)_BlvjeCi1z^P0PTk zo8CiD?T2pK3w{E+=>qtB=%#FN>M2*~saMcVso+7-P5Z!;pqt)KRVUk%+v?f^a29K0NKQx))V z=&6g~hR{vaQ+=SDsHg5hH^qYggKnbE%7kwE1nvgi)C1fOy2%0jB6Jh^Dd?ti;EB*p z$>5Kmo1THMfo`Inst(;mJ+&9QX*YNpbki&FGSE%s!3RP&4Fb<^PaP}L;>g9j@;;Rc zKD%w{>=yUreQG9niyV`c1_R}Nsy}#Gul61-?#ugBEcoO%?VpZxmiMV;;O2HVE4_!v z`;;ws{U&96A6Jt1DJSr8Pj*Z-dn)f!6UkG?ZRodA-lrCVPkDXDe@}0DpPC2$Zc%~0 z<;u(Z)Nk-rL$a58jF$JQjo@u69Cv>kBkxlkz+37c?pf7Z-lv?vOL%;rQ+}Ac+E0AJ>_%Awgfd7oMb9(w7qMUUF@-V_P$ z+2GLDb4hYP8QkXgkru-@$@^4W@DCA2r@FYvd(#*2uNJko4A+zQCSA+C{XuJ|^?M`b z{t5WRGF=`2PLcPinc(jy?C9X$P~MxqfY+T8(c}6%xwioy)%8Hl^1J1I$`^dR{loRn z{pEdX8n|nm;Q^=8^4`=Pe04#?r8&3cem(e;kGF%}=g9jMdFr!0F9z7lds7DZ%dYKg zAAgklH1HBRmTr-I<$bCqxY^#<^$J+Y`;j?#^5|W~+AWg%6!6Gvp*fY4<^C#og{qaB z&Tl5~M^(v>uXyCMR_<$ne{SOP_g047lYd;`l)BbY-j6cDOAQ?GHe!q18-k}bHDBKP zv)q3I-|%MH76WH_KiUqyc>IJ~Rkq3f0`R{FS_gS&%Dv9PyxqKc@x)|Dc|WQHex&L& zo4Fh0{xEn<>&g?`q{;mg@Q`yR#Z8*Z`_TpP44GgDk-BW}F=p*hB8`gPSq9J*;I_-*K^r{HPOO&`GDKsTj>SAcG+3Qj#$1A2y!K5uAEz8}!st=qB<)&`s1?wV|6V zz=NTi$nQZn#es)GH=PAfhi=LQ-v-?j1Rf0CbQ=5^bkia5{Pt8`=%(7>cc7c1z>T1r zjKTXuHw^^OZ%<7;YdXGeg1k>11+UxiOrOIE@;+q^zWs%N88a_=pNa&p-fV2Oy@~QZ z)e^i!<1hbe_LcXkI^YNI9a-%+Qr@Q`z*B~gxjN56-lzV8{~P9Z*zb+JPZe>`+Z{&# zjOnyr-lyEat8Ma|-DrfoPc;G$d|WQHWo>z%ItZQ|z0c2alDtp72On|hdH=vC@;)^V zy#4*)GJy{AKIH;F@ACcSorC0kYB~7Y@rC!@E@&+7O`E_UUpQh^c4T?6PXT|icVH*0 zd-6W@7Tnz6@`Q>_RR5S4RtD{zK?jxGVFB_!wE?_yv*h;`8q0fA5AeSZ*$r-F$h|@HynWltR(5Ch$oteG@D1k{ zZF@05-lw*L-+9?JyK&h(?oHsQ5~5R1+>!fG@a_d?d~dTr-luwlC$4Gu@I?!GZ+Z>> z?Aj&EiQnZu8N6HFVW+c?%lnio_>SW@d-NS4?^FB0=jvw_pI1fRn`VK>q+c}}@mTKf zgBRI8Eame`d7ml_zN&ubj)v{!y=fh|L5|hr@H_UpN9kKCUH z-}`&9>9Zele*oO*e9w}7JInh~dGJ|tv*!NUF84FRN5o_dy7Woz$AQPpxLs;cz5Wg zn&5Y!n~sCGgKlaB-VnOU5$A zEx12)lNWeb=qB=|&`m4AS3);!08fB!N(4`aZh8Z53Efl|ydZQ_3Gl|yO*Y_dpqr?t z^q`xHgWEtiH3k0$-SioJ8FbT9@K(@GEy348H&JJ~K{t`>LpSMxZ-;K$3r^ic{uH_? z9y|oP=@K~gRR4VT)LZDOSI|wV;N78{dVz0)ZaN4)2fAqCC3(!sH!4E?>?Ex%{y1Y-Bfd|~WTDXe8yictG?|7~3_#YYaKGhR^^7Y9{H@)S3YBu@Lu zHh3%7%okBl13#4!-V# zd9!1N@;*-15#eF9ee0hT=O%}h9_o>z3ZzgR_spll`Q}4h_C2r2xdraP^ z%79;6lH>c?Sl*|iz^`@L|J!Jeyidh~UynGnq|keLpLznGni6^<<%qmbWr5qf51wb? zF7H!q!T(HJYZhZ7?@fA>^Y#YiMt-?_PwpFm7d$<2j>RH*pDG6Kz2TcnY)g4>@&gaJ z_37i~?{dE!yuyP?>0ge^`&3Qvj>{{@4IClwQ(eH#vd-FPRgw25OK@AanMV&kk$XFE zo6iTXj$bYBQ}*Cfss~nT-$~w^rh}hYJ!yzhL3wWq0WW?%t^1Aha!;NV^D?^U1bLr& z4IXf2^YbJ1zUen`54|#7Y0zP*_P$mE3 z^4_!Gek}O!*Gp=aaFF*Soz%SDtcKIaQS0TNJi5=P;K85dJ_dYEsbz-~ zI>`IcX7J=n<&B>0lKa=-R`V-W?ea_R$uqlbtYzsY??+kS17hZt{L~7rd74HB+B` za$ghNHhuK+hCk%K6}ZLF?tKh8$oo+P@Kghz^}jaC{YUVhd*TXbzLEO^d-L|IzYd$c zYb@_a(cmv{m&s0=BloYt+m0<77#Ab=9l?{+f3Le}BJV+Oz)wEuxMZ8V+@A(7(a-6! z-x0Yl4c_xW&TyMAa^D|3zddyTx~VC6JLsm0;JcxlmVpn2Zt4TR0=g*>{2z4FH}LMz zO&!5kK{qW0PlImy3Vs>7DGK~JbkkYzD)OPCZo|dTJ4L({gYx=q7*gpU_h|;M7gz_o17pvo=9D zZ3j<-Zh8w|2YQP9J#^DI@V?Mf{lUjVH%$UB2i;@}{sX#+d>eEVb=Do|rfBdw&`spj zQ_Y~K>Owcw0e=nMln(v}dMXDz61wR+_#5b^SK!oB9iXQ&pqtXbPe3;v0WS>QR2;k; zbdw8setSy)#F(3RzRUZR6ZohVE{Pp}$orH(c=1cdlZ~dy`&3O$RT$oteU@PP6M_8e*{?^CP6|EB!XkJl+8?j8TY%eSpz`2MQA zPt^jCpODl=Z?U{jC4p~GvMkWHtGrJg10VG4Yu4i>@;>DbUdQw5+>j4O;{DbKxBIuQ zV+%KVpK<_iZ}%r@##wov>I80D()?~fWqF^f1pa#2Jm1#y%Ztzd9ry+7!-+8&@;-G1 zeC5cYnU+1}eQGs$i?3x%_Pi+XQ*FV=HHo%xv5@zv$>4im?K@<;M&74Rg3lV*c<9-` z@;l35WC?CCp~0u41?0V{8u->)L4MW3<^CY}s^nNp_g`DHUEZhGfM;~DXu7qxyia9(D1)j31a>W*Ns#JsFI zte@N$1os#@Fm!LQ+>@{JEU~b8QF#yA03H+LFw1O^+{c0E95;W~`jp)N22WjCsm_)n z@*b21KFoQ9PqqGX?*+bP;w{6wN9BGK_&}Y>hMWG$y%+exh$)$qyUY90O7K?oT_1P_ z$$ba#Sl^f#gFnjs6Y%QI(nj@bF7HQmz%6$ixb3z??ybQ0S|_b+A20Vuz};=5{To)5 z_n;Bro+pNUHyoA69=z(nVUu2+l6wpAk%uc)I`~WO$AIUzr}{uQy*!?GXRU#58V+s` z-BcNT9CVW>_!8)*#o<o4$arfNoj@uKOzQp85klWeMHX0Q@y{Q!4mT=%!%s;m}Rg zQ`Ais&{IvJo2aKcKsR**H-c`e3{E|jp3k1Tp3k0Im(QN+06jGgx+wts7<5wz_$ufo z>Zzm9O(Ecqp_}5st)ZL9??E@kf){~q(gnAGZX&M?-Bb~L8+6ldaO$SD&{IXBn+k$= zhHmNuz8tz~BX~M=(^v4T&`sCC>q0j*1W$%;dJldDx{2H#x~UWRV(2F7tP{{pA>cEi zo92QKg>Lc&9}3+x9DG4Od#XKj6Ll7KQvmdo4|LNgaBJu(^1pZT?x`ZsQ^TOA+`$8( zo7RKhfo^&Lu5%*qo}$jmfNrAB8V=p$0UiY1v;&-aY8dp?Qs|~7;M7y?pr;-}H$4Kc z0^L*-+#0&69{4`!ro-UA&`l%3J)oNggI9uXG6VO7ZW<1r@1ANBJ5Q(3qX_MfTL3<^ zmA&osLT|+01H4dZ|Eb^R$@^4Q@I~M6T6-4xE?$2-cv@18?$?*d`_w=1pvt#a7a^DHOzU}Mb zh7;v|swwztgBl}U>&bi5cJPGFBfF))lKUj^wibsc#c!4OsSe=dPd@5eqNlu1O#`32 zw5ju=67t@(1U&t8+Ornd<^Bh_-g%$-wPwouR0;5wI!CTFv6J_vPT+I!Na5b_cvN8 z?^9R7Gn)Ts9NAvpo6^BEqQkPP=E(hL@P-$A)~a?^-lxcSnr{d{<|pq{`@x4e7Aq8D zF7Hhv!M%gpJTy&^``O@2TK06#=pgS$tH58{4GtQ0JsUD8fHc|Rf#>hdaj`A~_{CwXT$i4c`*YxiJ&m5Fm6Z3OGT`60JvujGnB4yX4_FfAXMS4l zr-6T(8~rn@u)GKT1aE6oFeARV+;;*u&l===bHCg-0FTM(;(Ga;+{c6O*cE6T;VAD% z`@yZs7x)$yDEE!PBbKy!eJnxluY;dj+HHP-V(a0IXHFG2k5D#&`k@#?Vy|LgFl0AB2R;EdJk>@-DCn@ z61vF{+!4B|6L>r5rjFq8&`mGFeW9EDz*|B$wFCbF-9$ar7P_e;coXO*8}Mz=P5JGq zMChsZ&`pluQ=yxtgD-$?nh#Drl?6Se58XsPMcvdfpFI@_J@pHEN)LJ}0=nro_#Nn` zd*IYl5H=%xeUBcPi`flq{P3IJaW-LwKcDW5&{ z2D&K;oVuwx^ppp5lRNk(=qd88&`o>6zd|=rXT?A_Jpk_u-82|H0=kLZ7`ll%>o;`M zPw=_WO|!u>p_{&fw})1bdx^#f9ogh-+$Norg1eRd7m%?^92} zd(Sv6gMj zR+RUt4&beum8fc$Ebmjjz`K>GI)3Isd7l~tzCPzs^8|l+pE^X|Q@@SPc6pyV0Uon3 z;?5@B(xUetfY-5}Sm2Ere3!mubRmF)Hv`7M+WRN4U+e% z0Ps_-8a$|=S3$hr3*g&pg$_;}EALZ#!4G}Q9ymHd-ltB1huQb=z2+?MQ?rp(?C#|14W~RJPT?CJPIe7eETX}Cv1dskQ z(IWYS+{c3VJ`?)3?0$Kl8Vr7`O6}5X2Fv@@1Mm-Z$Cq?1FYiqS>gDbFKRw%bjFtNe z;A7W?)*rh>-lrykdloQg5z$uOo5q13`RM+!<{!B~37+^ZE^5;md7pX%-oh zKII6$=lI9|V=d*q=`i?<0(+*1CChyh_><9{4&L7)?^DU(&gW`2fT_t#-44tBbnpddvj&YWB=1Ly!7H3N<56<3+*bvkvSjw>I%nm6I(W+U zV;WO`ig7lYsEl)1{}uiW1SujtaEZu!pgepC(IHS6@kGMnVSH@MZ5 z(4bGT)&-|Nf!Q8@UPYmP4;O_BQ@;IG$C`FQBE+-HDWr8HXWS4`fgY{0d9 z>A(Hj9=ho~be02jlM#3-bkiMhf9NI;a69NGdvHDIrr*$6W1yQn!8=1YwFK`C-9$bN zx@jOdb<+XpsZ-ER$H3#Dn{IdqFo*XHAA~ngV_Xx+xrdCv?*;@T1U8 z)KizCo2aMeK{qV~e*oQdAG{uPQzP(m&`qbo6QG;Osi*EhPYr->qRxtiZX*8!J@pg3 z1awnr@QKh(6TqpP#z0RUgKjzp{t~(=1DtxQJ@nKu=%(Y~FQJ=K!KtTGpr<-QH+2B- z4c#;x+yuI*I(TR3ChDmP&`s1+L!g^H!8b!UZ3mwL-9$aL9J*;CICYab^wccqrkUU` zp{K}?LpPlTr=B9Whi+;CPCa!3dMXvV={5LG=%&lyQ=pqBfj@?BiU&Uq-En)pO)=o*p_@#>`$ISN0&f7_WD6b%-E5KAQ=PycM3VOfvE z@;+4!{GCw$hJUJsS`snOs`qqB;RC|J(u?>XYdh~rcIdUDDP9F!Q*??c|ZE7yiX;8KYq}sM^$5apLzxU=!|Ff z#@X^dl?dK!-}0OB8S*~m1b*JBjs3Ge@;-GP{PO*J4tuZ3`_x15=o_=vnN*PXrYGQ` zSIhTn87ucUz}vS>9}&4o-luwkr@u{owxyN4H~j>!Z(RFT)DO9D4BjAq=hb$>@;+q; zeyZ@AJ4Hvz`_y@Gd#{>(i&vNTrmo-#HbtWxpUZtZc*?@|^AE3+_o+1SF(D&<+jNun zrkUWYE+y}ISXADd)`P$BEu1s!vfQVFKlJt5ZaH1vr=Ecae1BLova!53%>ysw^R$61Or}lvFcM46|*;?M4j)T8TzIMLj54kUplDFGB9x({&E$>auz{l+ExUum`x%UGv zxNP00{`&HMR0KTL?rlKP;d1{TeBq`yI~qjD{Sxr_nV}b=jOG1^{Oj(;Zc%=6{|!9s zxNlC48*+aRd{No%Yww%N`_U@!+YNu1-W(_QvEZGWm&pEgQ|_I?TV73m=3y%DM{U82 zS1Pl?C47v9J?|rOxJLe|yel!^T zPY>g1mb2x)K+n9rwf>~o-%)bk0ene6>xq$u@;(&^uH8%j?bn;3o9co4K{vGm{|()g z3|Jq2lt0=qMj-a-Bbwt19a18@Dso+4iY-Lw+? z7If1+@XpXpde{*-GB0&VY}+X)|nPxV%qI12;|x4fNP6?^71w zEes<9>W!B7sh;3QmpYEQ&{*E5jKQP52R*F!Pu{1VgU7CToxDCu-lv{}dldgN#$cVi zPmKrvTx&#HuV8tf`T_3sc=*HC<>h_K2fVwMxJ$UenDp9+C$^9wt5)Pf88=sc< zsnXzEE3LG0_LcXkjo{7BE-Zt~n6UNviVgBURT_M4g%|a* zyUKghR`4SwpHv;HEAL04;DKG?;`y$krUo0do4 z*O2$4GvJ{gx*bTHD);BXe?@d^U;Uok{{Y{7^=+rX8uEU$9en(P^u*ee<$fyop$?UI zy}2d#2f$D3CZ3F_B=1L;z|UkFT{=8k?k|GhE#+Bi?*+Mk0{$cO^zyy>@*b1}zASZ5 z%>I6IzXrTduS#b7_sji2@C=JP3wLD6eHQqd1qv)B=@zz|GMt9 zZ5u211>OD+Yxfxya{vEvyo{n`7fL8env|3kg=mS)WQCNym6Zyqj3TQ+R%W*BNXTAE z${s0cpkXBS|KIlRd7SH<-_6hC`#z!T*7Lk>T-Ce%&QZ^mn#+C43H~*BV;OeX2!5 z^*-lLIQhRsXBp~jW1mp2_{vpU;)| z{lNDHJVk;0Jqhb zmf&9;Jib>3$on$zl9Zr9HW~8%D|p1AL9b57GhG>tVe3)p&Vt z41U6Vlilkh^8PG%Z70LW&wj~!HE_G#{lBO7mHUw+`1r;19S*LS_mjbuuJ<=t_DtT_ z2X}2;Bh9w8+^2?v|J_UfdYeEuorKPchHjb)z8Jb`6u266Q#o{2A#_tVxD|Ah0r)8B zCTH+W=%!Tgbcp!QwlhBlQZBHz`C{-&r@Hn;w8Sfo^IHo(SD^9-O*~JO#Sx7WhHvrg-ol&`s1+3!$5+ zvqnNU4F&%N-Siv01$2`Jcm{OS3-Ef-O)B7Zp_^)f*Mx3T1E-#v13mQ)y6H3cALu59 zk=1t=_0(GBP0hinr`khLwS;bJ4c-R2Ngw}r}?o)HXL(*L4M4p!W)K2hg z#hc>w`^$amDY#ie*NHox%YCW`cytZd)NN{BfhIE4fePKJ^SdJbql4 zv%Ta#wHdtWvXDKt338uO2lsyY-Z!L$+^432|EjogV$Eu~PgQ{TnDOPV!*{t)4FK2w zIXUBvx!jw~z&Bo);8glq-tPn-;eV&zxIJ>8nh4&0>&hA}N6USxGx^s@Q+;*0H(7zd z{jPAp_kq060iPS6u%&K@+@}_UTOZczm~JcgCP(mrGs6=f{Fe8lz%}Zp&i#@o_bDxK z{{ts38_kyc)LQTdIaL+DhH`Iu0zTQ!cGt~pc|QX@b7i1~TAbXcUV^tv_8H#IUG7sx z;OEDGebB3k+?y_ew^vDAr*>c7n}P?P{(OF8u-vEo!RP-hO-kw|_ohYQofCHrTl!Pp zTY%TIQP^?uxZI~2fro0`)%Wp{`_u;VKZk0ZZ6NofSnvk-7tVh1V*l)^b0J0bexXa>vt)fNL6hWM(*@_qt%>Zu7WD(}eq zN8o{JeqU;6$~`Cq{CnQ8`*nQeeFgYw=TcSGM0tM>Jh-gYmD-AO4_XWUIVIs@nUlQ# z3SKfOJT`N)y#EgFGx1<*!fSay1N_8^iPPrj%Y7;l{O?}+*SiwBDFA#MbkjueLE! zo(SD^27Een(=71e|FNgipqrk8M?g1i1E-#94n5@q-82VW;ZOBFMQ#t>L$zo*i)9!Q`yi>Z@~San-+ohhi>Wv?h4&B6r8%L1@zQ<=%!Hc$IwkL zz`dcH=7LjCy@8%Gg>LEyegV4aD!4v$Q%7*>De}3{O@ZJB&`s1+)J;vGry`)6BEh#p zH${W1K{qu9e-7P59tYh-okiWW3VLcPbkj6&1L&p>;4`47e8G1^PwfH!uRWCv-INNx z54wrGGjx*~_$}zBRB&VHCL{1a&{K-gQ{$kU#(>{|Zn_V?61r(M_&4Y#>Z}XUO^M*t zQ|q9oN}-#I!M{Q`6@Ys}H+g{{f^JFx|5rc#{r!#hf|UJ(FSIPlj&k)v8&mHSi?c&($wp1an` zeM$>lvFEss*`wq>RSVqAQq`c!K<-n$z>`u{7u5YJ_o-Xp{d8`8Y<^4bQ^UZc^S8X) zc~9LB>^zMUer7|4BUHu$!Q_eyQI%6%#Z z+|Bmp@x4l|#lLq9xcBzplri1q-ZTsR(z249$tCjsHn`~>`__I5a-Zr79+p{q=W;K( zPi+BTI__SNv{rI&@&|7-$E9*gro3+l9=^e*s@F!jPi+Bz9@}S%v$Ncr^1-`*{x&yQ zN$ySk!Ic9Q#$_kVdsT2-=L<_cmdJf-Ao$$!8y((S%DrhJ__W=_o_c+i_jAE}yFaM) z=8)W{`hvILRp#E)OYT#q;B6I;N6%?3_a=St-5uO7Ov{q@2f?R4y^yULDfcOFa954J zVKbcN-ZTWfW6jpH2iKN+lPP$&J2sb2CCU4q;8qQmsst{O`;-m%lbyFNyJ^V%=oNU~ zcJHSI&yn}_z$;z)*bKfW?|*}5bv^LxfWF+1o`c60+`SqUAn*5p>sGy4nVu!@$xpwX zelpTr?nfuV*SM}KP7IUxVc1 zC1Yr|yl)TQ@z90FY1VQ-G6y$G*J!h7t-S99?!Mn7$@Y!B9}aFA_s2l5liZJbgZEuD z#8~iGfmzngC7nXWTK-Z_oGwbp=rZ23}(su2ylzLGeV6o$$M*Xg%(-k z4C=@|NEzH=;Cu5HL*)G+@Bt++c2>m7duQ-jMMVuCf0XwNz|ZwKn7G+Q?o&zNfA`YA z-d&)Z5}~vDQ8$72fNp99ejd7MKllOYrg-pT=%yU-X3$M);L6ZVe|l8kS+>wk_TcxR zo9=)Qhi)1Hz8kt}2lz4Qrv2bcp_|CNKsQ-~w}GBA0uO_3S_hsC-E<3_dg?Ir)HLX( zh2Yzvn|6S^LpO~Fp9$SG8$21h=@xhw=%&u#o1vSwfiH$`S_a-0x~VmIBySBZt4t9J!K3%wG+B20elK{(=>2r z=%&%&y3kE#;5N`rw%|RXn{2_epqpNTD?v9=PgOuSk-vd%qRygj+7CU|4th!-{3vwO zG4NH;P2u3(pqsjbQ%{*gPj!QCqMkB_ZX)jt-DE}%-DCnj2D-@u+zPs>JGcXMlRfwu z=%ys_C}oVDSFXO?KeZpqplZpN4KC|5rc#{XNh@ z*J;F9xldgNAGm7Kpj%_*J~b5lo956idv1Qc{P&+*Ppf*jwhxX98!z`M7x0QXkCg|P z%YCZR-0HpCk}HZ^?#O-0k^I-4)cxD!J~aV+yYA2Yh2C5MqdSYMj0grELa?d79?o+40{Vl>5mpqmGR1kQ2Ez6ZJddYn%13bw;<-)i_a-X^i zo*#2z#AS zJp|XjcX8{PkMh1P_%)pxzTt6lpGpRQ84$6kuDjf)-hz)bI6AFyW4SjC2VWUJ(|_w7 zc^?A)b%=udsvx;f{RD4Na8W(GrQDBNfcyCdzH8?v@0WtB4nOhMATU{Qz#eTKC*9X7Zy8V{jZ{__h@JHc2+f3^!_oIj4H=i!b-Mm5Gr-IKh`j*l> zPu`RF`ZN1tUN5;H*@Nd;)NE0;S>AsJ@ABSrwrjq;?+D&#W3S_nd&&K%DS2ZD(`AwJ zUK4!f)*GiBa^!s=xP`-oP%~?}AK8FsWh`9TK2+Yn1z)v&PJN>+c^?5jRN2G4vw_@? z#(>8;4Bp#wp}gM*zTKJ$@{P14v*(}sqdBd zF5qcprdpp16n}&ezhHlyh?g!np6nr{#(-iPT=%zE^!O%_AQ(4eWkHN1%H&IU&K{pkH z+e0_Gfm2TvLQlCvH+h0jgKnA${usLH1^7tlCUT-6LppjbQAT|Bj~34;4`3`=7R@8H<5RNZlaztf^O;x-T}I)3pn*uU+Ae# z&`nX`_o16Iz*|B$8Guty-GH8Y4&9Uw?gZULofQV%v<{rQsRDXR1GZiZID<>NbES)O%slnj+8#k3roF@0FAKnB%QTQ`&Ylp(mTjm})B&vKvY2>xf&mLb+}rTf`W2G8U^H4wb8M~|Mf?Bzc775w~-tuMUK$bIS(xV@w1-G=Su zJ~as3e0gtM3un1Ebp_uvb4)>}+H!B&1s?1>^>@H!dA|XC?#Y;TE&b#^vUzgH!T2H`{{kuDMj8l0`Idk z!$)z$bUkTJ!a=+@~gj*E`gG-v%$aPc;DF zo!4p7l~!_Z+6lg-#yth^XY$@3yzbB((*@yjpK1smX8lclT3fjvMS`E7@;>i^zr4Q$ zUTQn&MO>D={|5dvGkR--&T>C`1|HeiEvagqypIN7>bUxoSFXG#@1(WzidAp9ADMxx z_j+74b(_3z0{*3Z;hM59^1cZCsp+_d_wD6=^a9+lUUHMXSb1*(es2AOn!SqU{R!}& z-OPHW+ROduH@K(Ei1rJk<-Iq!(vofA_J#7kCiv6%+&gBy$XO4tU?iO<%d(k@o}0fBr0U(vW+QE4ZI( z!+AEI^4=eOT90ABbPvn>S>Un7(@TGp$ot*kAA7fty3}3nQ=h^A?xladCqOs7zfyf? zwTP^~r}Chu9HE=cz;{76Z2&KXZu$(a2i?>h+y%O+5BMhNrZ8|{=%%IM9if{{!7ZSh zx_~P~H`N5sfo^&Yz74vGdWyPf8T8aF=%yv$)Khz*r_7<7x`I;M7e)&{H#@o92KYhHj$HvVm^01Mdah)Dt`%y6GkO zE$F7(;47e;$Ui_g6@ybxE&Go>)f{@t8MLr(&R+;=q?fPX&S-LpPa#H-v7| z1TTbcqMpitZh8gY9=gdC{48`6`5)*e>a5AoO_RV?pqrGzpFuZ02fqg0lnhQi^$B{a z19X!ycr)mxmf()iP5r=~pqmDR2SGP22ls()@&exq-4qS}7P{#j_`mw;@9#&W*1z}n zmHSi#)ZCepK1uMpHOS=lIL=t>IJ_2aILVti{w6a1pH6OLtXZ_ko%NMr|R7% zQTu_%E4fd(fCqfNWxDdH+^05!`*v;9-YY=vQ%k_VT0?o*?{U&Yt*w?@f*Dir*NYMt{-l$(ov>JIq3DqG!p3*|nQ3qGvguz^k=e!&u++l>NL1k@vh#wR&t+e2X0@>tt@P)+^1Z?GYndu%}|qj(+BX# zeiQO$-<0<|!0)X0wip&D_o)o!fz@TM;YwDGl&H{aSQ9HbU-G zHSDW*e{GM{^u}^;S_R(VXwkWx`|`dics-*T`!ho1KGg)=yZrsA&3)wFG!?v6gRT!7 zSIT=m@IAZCZEViTeQGE8b6W*trMYsSdIcUB=e1y@k=&aCz-MoqHcmHN-p>aQD2Y5U zC|2%MA>i}JC*RNQAortX;PZ=@ZRod3-ur>uc<-HM^;X_@2QTt-Yjvud+>gG2SLjaf zcXX4yui3VG&+*R+YgHugbHRVr?-2LPUhYRfz+1%zI9kTZ`G`7vF0tGssy&zQf-+bCDwzXR_$wbujdE^TbW4^8Oikc)Na&T^`H(Nbq%bqwBh8%ROilc#{^2qk8+u`xf9AmibO=cT(Obfvb;> zI$T~Z@3p|k9vU*}ik;l2CW8OnOaFS8LpQAew}fu01MUjl)EWE?bkiYl4d|w3;BL@O z{lO!lo7RFahi+O3UgJ{rJyjRn54y=0d<=BcIPg!IU7^1H1yd=_hy|bki5`80e;G@aE7>>flw-Q}v*ymP0qK0dEA| zqzT>(x=9n<2fArCxHfc?0r+m{rg-pY&`o*Z3!s~Vz!yR{`GHe6t%06e0^LMCH5a<+ zzxGrQ=&3U3rZ3>NpqrGz^PrpZ!Aqf=$Xh@+wFR#Y-Sl63Y6$eyV(2F7so~H~3B2Gtb^RAQotjd-&8-8BloF2;8R8#jv94d?o$EaYX_W6 zPhKncsYvkY)~=zY*i`OQ zF5n8rArEJ+ko#0^@JnMfLr0d#eJTmOv6lD#qKR^!QV0JU;ykJ2Q@Kx(SJYUwM618t zr)t%#-n*_DtClfZ?o++NYfK+LWu}JQo9ctle|x0wkVo>~AH1UYMVEjuxlbvVRPPak zhJF9iSME(4!A&209uiw6?=8TCZZ@*=zaaOiFz^|9MltIa$bHHmTx;)#byqvey{SF; zx6Bi!4GZLb8ThWrJCDuWFZZdV;0?cejCedj?o&;{`|gcjY1B&YO^)E6*%qf}WyyOl z@Pj_}gTgn-ed-waq2IGEE^(E6QvĎa=DDspc+1Rh}e;(*_EdA|%iepX|BZ-2Q@ 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