OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2024-12-30 11:06:55 -06:00
Code Issues Packages Projects Releases Wiki Activity
59b6e21cc3
opm-simulators/opm/simulators/wells/BlackoilWellModel.hpp

519 lines
21 KiB
C++
Raw Normal View History

Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
/*
Copyright 2016 SINTEF ICT, Applied Mathematics.
Updated Copyright stuff
2017-03-24 06:19:11 -05:00
Copyright 2016 - 2017 Statoil ASA.
Copyright 2017 Dr. Blatt - HPC-Simulation-Software & Services
implement WTEST support
2018-06-06 08:17:59 -05:00
Copyright 2016 - 2018 IRIS AS
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
changing StandardWellsDense to BlackoilModelEbos for a better naming.
2017-09-26 03:52:05 -05:00
#ifndef OPM_BLACKOILWELLMODEL_HEADER_INCLUDED
#define OPM_BLACKOILWELLMODEL_HEADER_INCLUDED
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
#include <ebos/eclproblem.hh>
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
#include <opm/common/OpmLog/OpmLog.hpp>
#include <opm/common/utility/platform_dependent/disable_warnings.h>
#include <opm/common/utility/platform_dependent/reenable_warnings.h>
#include <cassert>
Well Model: Add Helper for Well Pointer Creation This commit adds a new helper function, WellInterfacePtr createWellPointer(wellID, reportStep) const which is responsible for creating appropriately typed derived well pointers depending on well types (multi-segment vs. standard). This, in turn, allows us to centralise this logic and use the same factory function both when creating the 'well_container_' and when forming the well-test objects. Finally, this helper will become useful for calculating PI/II values of shut/stopped wells in the context of WELPI.
2020-12-01 11:04:46 -06:00
#include <functional>
#include <map>
#include <memory>
Run WELPI Scaling At Beginning of Report Step This commit implements the WELPI feature. We calculate new PI/II values for all wells in the event of a WELPI request and use those values for well-specific WELPI request, to calculate CTF scaling factors. We then apply those factors to all subsequent editions of the well provided the connection factors are eligible for WELPI-based rescaling. If we trigger a rescaling event we also reset the WellState's internal copies of the CTFs and reinitialize the Well PI calculators to ensure the rescaling takes effect immediately. Since we rely on PI values being available at the end of each time step we must also take care to forward those values from the WellState of one report step to the WellState of the next report step. Finally, take care not to redo a WELPI scaling if we've already performed the scaling operation and restart a report step. This, in turn, happens if WELPI is requested on the first report step.
2020-10-29 17:30:09 -05:00
#include <optional>
Well Model: Add Helper for Well Pointer Creation This commit adds a new helper function, WellInterfacePtr createWellPointer(wellID, reportStep) const which is responsible for creating appropriately typed derived well pointers depending on well types (multi-segment vs. standard). This, in turn, allows us to centralise this logic and use the same factory function both when creating the 'well_container_' and when forming the well-test objects. Finally, this helper will become useful for calculating PI/II values of shut/stopped wells in the context of WELPI.
2020-12-01 11:04:46 -06:00
#include <string>
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
#include <tuple>
Well Model: Add Helper for Well Pointer Creation This commit adds a new helper function, WellInterfacePtr createWellPointer(wellID, reportStep) const which is responsible for creating appropriately typed derived well pointers depending on well types (multi-segment vs. standard). This, in turn, allows us to centralise this logic and use the same factory function both when creating the 'well_container_' and when forming the well-test objects. Finally, this helper will become useful for calculating PI/II values of shut/stopped wells in the context of WELPI.
2020-12-01 11:04:46 -06:00
#include <unordered_map>
#include <vector>
#include <stddef.h>
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
further changes to report currentStatusGroupControls to Summary
2020-02-19 06:00:35 -06:00
#include <opm/parser/eclipse/EclipseState/Runspec.hpp>
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
Move well includes to subdirectory Well/
2019-03-07 08:13:46 -06:00
#include <opm/parser/eclipse/EclipseState/Schedule/Well/WellTestState.hpp>
implement proper guiderate support Tested on simple problems including GUIDERAT
2019-09-30 05:49:36 -05:00
#include <opm/parser/eclipse/EclipseState/Schedule/Group/GuideRate.hpp>
further changes to report currentStatusGroupControls to Summary
2020-02-19 06:00:35 -06:00
#include <opm/parser/eclipse/EclipseState/Schedule/Group/Group.hpp>
Implement min/max for GCONSALE Only default action RATE is implemented for violation of maximum sales target
2020-05-04 08:56:34 -05:00
#include <opm/parser/eclipse/EclipseState/Schedule/Group/GConSale.hpp>
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
Move files out of opm/core/simulator.
2019-06-20 03:30:16 -05:00
#include <opm/simulators/timestepping/SimulatorReport.hpp>
Avoid using the Wells struct.
2019-10-23 02:09:45 -05:00
#include <opm/simulators/wells/PerforationData.hpp>
Moved files to opm/simulators/ subdirs.
2019-05-07 06:06:02 -05:00
#include <opm/simulators/wells/VFPInjProperties.hpp>
#include <opm/simulators/wells/VFPProdProperties.hpp>
Moved all remaining files out of opm/autodiff.
2019-06-20 03:15:51 -05:00
#include <opm/simulators/flow/countGlobalCells.hpp>
Moved files to opm/simulators/ subdirs.
2019-05-07 06:06:02 -05:00
#include <opm/simulators/wells/WellStateFullyImplicitBlackoil.hpp>
Moved Flow-related classes and files to opm/simulators/flow.
2019-06-20 02:09:19 -05:00
#include <opm/simulators/wells/RateConverter.hpp>
Moved files to opm/simulators/ subdirs.
2019-05-07 06:06:02 -05:00
#include <opm/simulators/wells/WellInterface.hpp>
#include <opm/simulators/wells/StandardWell.hpp>
#include <opm/simulators/wells/MultisegmentWell.hpp>
Use well and group controls from opm-common. This PR remove the usage of well_control_ from opm-core and instead uses the control classes for wells and groups from opm-common. This PR also removes the usage of the group classes from opm-core.
2019-08-07 07:13:11 -05:00
#include <opm/simulators/wells/WellGroupHelpers.hpp>
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
#include <opm/simulators/wells/WellProdIndexCalculator.hpp>
Added a class with information and comunicator for parallel wells. BlackoilWellModel now stores an instance of this class for each well. Inside that class there is a custom communicator that only contains ranks that will have local cells perforated by the well. This will be used in the application of the distributed well operator. This is another small step in the direction of distributed wells, but it should be safe to merge this (note creation of the custom communicators is a collective operation in MPI but done only once).
2020-10-06 07:52:44 -05:00
#include <opm/simulators/wells/ParallelWellInfo.hpp>
Use gatherConvergenceReport(). This avoids multiple all-reduce blocks, simplifying the code and enabling us to return the report from getWellConvergence().
2018-11-13 07:02:55 -06:00
#include <opm/simulators/timestepping/gatherConvergenceReport.hpp>
Moved files to opm/simulators/ subdirs.
2019-05-07 06:06:02 -05:00
#include <dune/common/fmatrix.hh>
#include <dune/istl/bcrsmatrix.hh>
#include <dune/istl/matrixmatrix.hh>
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
#include <opm/material/densead/Math.hpp>
Moved files to opm/simulators/ subdirs.
2019-05-07 06:06:02 -05:00
#include <opm/simulators/utils/DeferredLogger.hpp>
moving the update the well_state at the end of the updatewellCotnrols in StandardWellsDense. The reason is that the update the well controls can change the well controls. It is better to update the well states after all the control checking is done.
2017-01-24 08:59:41 -06:00
changed: remove BEGIN_PROPERTIES/END_PROPERTIES macro usage
2020-08-21 06:42:08 -05:00
namespace Opm::Properties {
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
changed: remove NEW_PROP_TAG macro usage
2020-08-27 04:38:38 -05:00
template<class TypeTag, class MyTypeTag>
struct EnableTerminalOutput {
using type = UndefinedProperty;
};
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
changed: remove BEGIN_PROPERTIES/END_PROPERTIES macro usage
2020-08-21 06:42:08 -05:00
} // namespace Opm::Properties
more or less getting the old implementation in and compile now.
2017-06-15 10:19:49 -05:00
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
namespace Opm {
changing StandardWellsDense to BlackoilModelEbos for a better naming.
2017-09-26 03:52:05 -05:00
/// Class for handling the blackoil well model.
Prepare for extended models. Let the code loop over number of components instead of phase Pass TypeTag as template parameter instead of all the properties.
2017-05-03 06:34:15 -05:00
template<typename TypeTag>
changed: namespace Ewoms -> namespace Opm
2019-09-05 10:04:39 -05:00
class BlackoilWellModel : public Opm::BaseAuxiliaryModule<TypeTag>
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
{
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
public:
// --------- Types ---------
Remove WellStateFullyImplicitBlackoilDense After the restructuring of of the well model, keeping an extra class for the "Dense" model is not needed. The only thing still left in WellStateFullyImplicitBlackoilDense was some solvent related stuff, this PR moves this to WellStateFullyImplicitBlackoil and removes WellStateFullyImplicitBlackoilDense. In addition to a cleaning code this PR fixes missing solvent well output.
2017-10-06 03:59:42 -05:00
typedef WellStateFullyImplicitBlackoil WellState;
flow: switch it to use the eWoms parameter system this has several advanges: - a consistent and complete help message is now printed by passing the -h or --help command line parameters. most notably this allows to generically implement tab completion of parameters for bash - the full list of runtime parameters can now be printed before the simulator has been run. - all runtime parameters understood by ebos can be specified - no hacks to marry the two parameter systems anymore - command parameters now follow the standard unix convention, i.e., `--param-name=value` instead of `param_name=value` on the negative side, some parameters have been renamed and the syntax has changed so calls to `flow` that specify parameters must adapted.
2018-06-21 05:14:17 -05:00
typedef BlackoilModelParametersEbos<TypeTag> ModelParameters;
Reorganize the wellModel - All well-related stuff is moved to StandardWellsDense.hpp - Some unused functions are removed from BlackoilModelEbos.hpp
2016-08-23 02:45:37 -05:00
changed: remove GET_PROP_TYPE / GET_PROP macro usage
2020-08-26 03:49:52 -05:00
using Grid = GetPropType<TypeTag, Properties::Grid>;
using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
using ElementContext = GetPropType<TypeTag, Properties::ElementContext>;
using Indices = GetPropType<TypeTag, Properties::Indices>;
using Simulator = GetPropType<TypeTag, Properties::Simulator>;
using Scalar = GetPropType<TypeTag, Properties::Scalar>;
using RateVector = GetPropType<TypeTag, Properties::RateVector>;
using GlobalEqVector = GetPropType<TypeTag, Properties::GlobalEqVector>;
using SparseMatrixAdapter = GetPropType<TypeTag, Properties::SparseMatrixAdapter>;
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
changed: namespace Ewoms -> namespace Opm
2019-09-05 10:04:39 -05:00
typedef typename Opm::BaseAuxiliaryModule<TypeTag>::NeighborSet NeighborSet;
Prepare for extended models. Let the code loop over number of components instead of phase Pass TypeTag as template parameter instead of all the properties.
2017-05-03 06:34:15 -05:00
Use phase and comp info from FluidSystem TODO: The output, fip and restart still uses a mixture of old and new phase indices. This needs to be adressed in future PRs
2017-12-04 02:14:08 -06:00
static const int numEq = Indices::numEq;
static const int solventSaturationIdx = Indices::solventSaturationIdx;
changed: this is known on compile time use info to disable code
2021-01-28 07:33:21 -06:00
static constexpr bool has_solvent_ = getPropValue<TypeTag, Properties::EnableSolvent>();
static constexpr bool has_polymer_ = getPropValue<TypeTag, Properties::EnablePolymer>();
[feature] Added two-phase executable for numEq = 2.
2017-06-27 07:04:59 -05:00
adding applySolutionWellState to apply solution from reservoir to update well state. With this way, the BlackoilModelEbos does not need to know the data type assocated with different well type. It is not well tested yet.
2017-07-21 08:30:34 -05:00
// TODO: where we should put these types, WellInterface or Well Model?
// or there is some other strategy, like TypeTag
Prepare for extended models. Let the code loop over number of components instead of phase Pass TypeTag as template parameter instead of all the properties.
2017-05-03 06:34:15 -05:00
typedef Dune::FieldVector<Scalar, numEq > VectorBlockType;
Remove Eigen from StandardWellsDense
2016-11-01 07:41:00 -05:00
typedef Dune::BlockVector<VectorBlockType> BVector;
Prepare for extended models. Let the code loop over number of components instead of phase Pass TypeTag as template parameter instead of all the properties.
2017-05-03 06:34:15 -05:00
Add influences by well perforations to matrix. This is only done upon request and uses the auxiliary module approach provided by ewoms. In the case of adding the influences we do not execute applyWellModelScaleAdd or applyWellModel in the operator
2017-05-15 07:46:43 -05:00
typedef Dune::FieldMatrix<Scalar, numEq, numEq > MatrixBlockType;
changed: namespace Ewoms -> namespace Opm
2019-09-05 10:04:39 -05:00
typedef Opm::BlackOilPolymerModule<TypeTag> PolymerModule;
Fix the 2p simulator Only tested for oil+water case The blockmatrix and vectors are hardcoded to be 3 and a trivial equation is used for the Gas phase.
2016-11-18 05:43:53 -06:00
adding a pointer to rate_converter in BlackoilModelEbos in StandardWellsDense.
2017-01-17 06:14:32 -06:00
// For the conversion between the surface volume rate and resrevoir voidage rate
using RateConverterType = RateConverter::
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
SurfaceToReservoirVoidage<FluidSystem, std::vector<int> >;
Remove Eigen from StandardWellsDense
2016-11-01 07:41:00 -05:00
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
BlackoilWellModel(Simulator& ebosSimulator);
well models: remove superfluous arguments concretely this means the `eclState` and `schedule` arguments to the `init()` and `beginTimeStep()` methods.
2019-04-03 10:26:57 -05:00
void init();
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
/////////////
// <eWoms auxiliary module stuff>
/////////////
unsigned numDofs() const
// No extra dofs are inserted for wells. (we use a Schur complement.)
{ return 0; }
Prepare for extended models. Let the code loop over number of components instead of phase Pass TypeTag as template parameter instead of all the properties.
2017-05-03 06:34:15 -05:00
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
void addNeighbors(std::vector<NeighborSet>& neighbors) const;
void applyInitial()
{}
[cleanup][Wells] Consequently use SparseMatrixAdapter in addWellContributions.
2019-10-02 05:48:29 -05:00
void linearize(SparseMatrixAdapter& jacobian, GlobalEqVector& res);
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
void postSolve(GlobalEqVector& deltaX)
flow: avoid wrangling around with dummy state objects these objects are only used by flow_legacy, so not having to deal with them anymore lets non-legacy flow avoid to jump through a lot of hoops for the sake of having a common API. this required a fork of the NonlinearSolver and AdaptiveTimeStepping classes. this is not a problem because the original classes would get pruned to look like the new ones once flow_legacy gets moved out of the opm-simulators module.
2018-06-06 03:59:41 -05:00
{
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
recoverWellSolutionAndUpdateWellState(deltaX);
flow: avoid wrangling around with dummy state objects these objects are only used by flow_legacy, so not having to deal with them anymore lets non-legacy flow avoid to jump through a lot of hoops for the sake of having a common API. this required a fork of the NonlinearSolver and AdaptiveTimeStepping classes. this is not a problem because the original classes would get pruned to look like the new ones once flow_legacy gets moved out of the opm-simulators module.
2018-06-06 03:59:41 -05:00
}
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
/////////////
// </ eWoms auxiliary module stuff>
/////////////
template <class Restarter>
Removes unused function parameter warnings.
2019-04-24 10:18:44 -05:00
void deserialize(Restarter& /* res */)
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
{
// TODO (?)
}
/*!
* \brief This method writes the complete state of the well
* to the harddisk.
*/
template <class Restarter>
Removes unused function parameter warnings.
2019-04-24 10:18:44 -05:00
void serialize(Restarter& /* res*/)
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
{
// TODO (?)
}
EclProblem: clean up the time management code - when an episode/report step is over, the next is started by endEpisode() - the problem does not deal with updating the simulation time anymore - rename `episodeIdx` in to `reportStepIdx` the 'EclWriter' because this variable is -- and always has been -- the report step number used by some parts of `opm-output`'s ECL writing code (the report step number is equivalent to the episode index plus 1). IMO, the output and parser code should be made more consistent in regard of whether it expects 0-based or 1-based indices, but this is a story for another day.
2019-04-03 10:26:57 -05:00
void beginEpisode()
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
{
EclProblem: clean up the time management code - when an episode/report step is over, the next is started by endEpisode() - the problem does not deal with updating the simulation time anymore - rename `episodeIdx` in to `reportStepIdx` the 'EclWriter' because this variable is -- and always has been -- the report step number used by some parts of `opm-output`'s ECL writing code (the report step number is equivalent to the episode index plus 1). IMO, the output and parser code should be made more consistent in regard of whether it expects 0-based or 1-based indices, but this is a story for another day.
2019-04-03 10:26:57 -05:00
beginReportStep(ebosSimulator_.episodeIndex());
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
}
void beginTimeStep();
void beginIteration()
{
assemble(ebosSimulator_.model().newtonMethod().numIterations(),
ebosSimulator_.timeStepSize());
}
void endIteration()
{ }
void endTimeStep()
{
finish the injecivity functionality the result looks okay
2018-11-30 05:15:51 -06:00
timeStepSucceeded(ebosSimulator_.time(), ebosSimulator_.timeStepSize());
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
}
void endEpisode()
{
endReportStep();
}
template <class Context>
void computeTotalRatesForDof(RateVector& rate,
const Context& context,
unsigned spaceIdx,
unsigned timeIdx) const;
add method for getting the surfacevolume well connection rate changed wellpointer from unique to shared to make it accecible from outside the wellmodel add method for surfacevolume well connection rate
2018-11-14 06:18:48 -06:00
using WellInterfacePtr = std::shared_ptr<WellInterface<TypeTag> >;
WellInterfacePtr well(const std::string& wellName) const;
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
void initFromRestartFile(const RestartValue& restartValues);
Temperary commit -- works on SPE1 but not SPE9 -- if number of perforations are increased to 3 in SPE1 the same error as in SPE9 occur.
2016-08-25 08:25:01 -05:00
Chase Group/Node Summary API Update This is in preparation of adding support for outputting the network node pressure quantity, GPR, to the summary file. In particular, 'GroupValues' is renamed to 'GroupAndNetworkValues' and has new individual datamembers for the former group-level data and the new node-level data. Update BlackoilWellModel::groupData() and CollectToIORank accordingly and bring the parallel restart facility in line with the new layout.
2020-09-20 15:16:07 -05:00
Opm::data::GroupAndNetworkValues
groupAndNetworkData(const int reportStepIdx, const Opm::Schedule& sched) const
intial changes to add current group controls to summary
2020-02-11 05:55:31 -06:00
{
Chase Group/Node Summary API Update This is in preparation of adding support for outputting the network node pressure quantity, GPR, to the summary file. In particular, 'GroupValues' is renamed to 'GroupAndNetworkValues' and has new individual datamembers for the former group-level data and the new node-level data. Update BlackoilWellModel::groupData() and CollectToIORank accordingly and bring the parallel restart facility in line with the new layout.
2020-09-20 15:16:07 -05:00
auto grp_nwrk_values = ::Opm::data::GroupAndNetworkValues{};
Simulator Group Data: Chase Upstream API Update This commit makes the 'groupData()' function return a map<string, Opm::data::GroupData> object instead of a map<string, Opm::data::GroupConstraints> object. The 'GroupData' structure adds a level of indirection to the current per-group summary quantities that are directly assigned by the simulator. While here, also move the assignment of the current group constraints/control values out to a separate helper to reduce the body of the per-group loop in 'groupData()'. This is in preparation of adding support for reporting group-level production/injection guiderates (Gx[IP]GR) to the summary file.
2020-07-01 06:52:02 -05:00
Implement extended network model.
2020-05-15 04:21:32 -05:00
this->assignGroupValues(reportStepIdx, sched, grp_nwrk_values.groupData);
changed: remove unused parameters
2020-10-21 06:32:12 -05:00
this->assignNodeValues(grp_nwrk_values.nodeData);
Well Model: Report Guiderates at Well and Group Levels This commit adds support for reporting the simulator's guiderate values at the well and group levels to the output layer through the wellData() and groupData() member functions. We add several new member functions that collectively assemble the values and assign them to objects of type Opm::data::GuideRateValue for subsequent output to the summary and restart files. In particular getGuideRateValues(const Well&) const getGuideRateValues(const Group&) const retrieve the guiderate values for all phases for those individual wells and groups for which the guideRate_ data member defines a value. The most complicated function of this commit is calculateAllGroupGuideRates which aggregates those individual contributions from the well (leaf) level up to the root of the group tree (the FIELD group). This process uses an ancillary array ('up') to keep track of the parent groups of all wells and all groups, and to ensure that we only visit each parent group once (sort+unique on subsets of the 'up' array). We do not currently support outputting guiderates for reservoir voidage volume (GuideRateModel::Target::RES).
2020-07-20 14:38:30 -05:00
Chase Group/Node Summary API Update This is in preparation of adding support for outputting the network node pressure quantity, GPR, to the summary file. In particular, 'GroupValues' is renamed to 'GroupAndNetworkValues' and has new individual datamembers for the former group-level data and the new node-level data. Update BlackoilWellModel::groupData() and CollectToIORank accordingly and bring the parallel restart facility in line with the new layout.
2020-09-20 15:16:07 -05:00
return grp_nwrk_values;
further changes to report currentStatusGroupControls to Summary
2020-02-19 06:00:35 -06:00
}
intial changes to add current group controls to summary
2020-02-11 05:55:31 -06:00
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
Opm::data::Wells wellData() const
Save and Restore Well's Current Control Target Mode This commit uses the new restart file support for active well control target modes to save and restore the run's active targets.
2020-02-07 12:08:14 -06:00
{
auto wsrpt = well_state_.report(phase_usage_, Opm::UgGridHelpers::globalCell(grid()));
Refactor Well Guide Rate Summary Assignment In anticipation of adding more steps later.
2020-10-19 17:10:27 -05:00
this->assignWellGuideRates(wsrpt);
Well Data: Report CTFs for Shut Connections Needed to ensure that the CTFs reported to the summary files will be correct in the presence of WELPI even for shut connections.
2020-10-29 17:16:31 -05:00
this->assignShutConnections(wsrpt);
Save and Restore Well's Current Control Target Mode This commit uses the new restart file support for active well control target modes to save and restore the run's active targets.
2020-02-07 12:08:14 -06:00
return wsrpt;
}
Temperary commit -- works on SPE1 but not SPE9 -- if number of perforations are increased to 3 in SPE1 the same error as in SPE9 occur.
2016-08-25 08:25:01 -05:00
Do the schur complement after calling the getConvergence method
2018-11-05 08:54:48 -06:00
// substract Binv(D)rw from r;
void apply( BVector& r) const;
add and use class wellModelMatrixAdapter The well contribution is substracted in the MatrixAdapter i.e. Ax - BinvDCx
2016-09-07 06:23:52 -05:00
// subtract B*inv(D)*C * x from A*x
making wellMod_ in WellModelMatrixAdapter is actually a well model instead of the BlackoilModelEbos, which reduces some confusion and also removes a few unnecessary wrapping functions.
2017-06-07 07:23:43 -05:00
void apply(const BVector& x, BVector& Ax) const;
Temperary commit -- works on SPE1 but not SPE9 -- if number of perforations are increased to 3 in SPE1 the same error as in SPE9 occur.
2016-08-25 08:25:01 -05:00
Make sure OpenCL can be used without CUDA
2020-06-25 11:44:49 -05:00
#if HAVE_CUDA || HAVE_OPENCL
cusparseSolver can now apply wellcontributions separately, so --matrix-add-wellcontributions=true is not required anymore
2020-03-13 08:21:59 -05:00
// accumulate the contributions of all Wells in the WellContributions object
void getWellContributions(WellContributions& x) const;
BdaBridge and WellContributions are only included and compiled when CUDA is found
2020-03-18 11:48:28 -05:00
#endif
cusparseSolver can now apply wellcontributions separately, so --matrix-add-wellcontributions=true is not required anymore
2020-03-13 08:21:59 -05:00
[bugfix][WellModelMatrixAdapter] fix applyscaleadd method.
2016-11-17 06:43:39 -06:00
// apply well model with scaling of alpha
making wellMod_ in WellModelMatrixAdapter is actually a well model instead of the BlackoilModelEbos, which reduces some confusion and also removes a few unnecessary wrapping functions.
2017-06-07 07:23:43 -05:00
void applyScaleAdd(const Scalar alpha, const BVector& x, BVector& Ax) const;
[bugfix][WellModelMatrixAdapter] fix applyscaleadd method.
2016-11-17 06:43:39 -06:00
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
// Check if well equations is converged.
dont check if group has converged in solveWellEq
2020-04-01 02:55:29 -05:00
ConvergenceReport getWellConvergence(const std::vector<Scalar>& B_avg, const bool checkGroupConvergence = false) const;
Reset wellcontrols from well_state
2016-08-19 06:50:27 -05:00
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
// return the internal well state, ignore the passed one.
// Used by the legacy code to make it compatible with the legacy well models.
Address issues raised in the review of the PR
2017-11-08 08:48:30 -06:00
const WellState& wellState(const WellState& well_state OPM_UNUSED) const;
the second part in separating the StandardWellsDense.hpp implementations.
2017-02-13 10:07:34 -06:00
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
// return the internal well state
Address issues raised in the review of the PR
2017-11-08 08:48:30 -06:00
const WellState& wellState() const;
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
Refactor SimulatorReport system. Now SimulatorReport object contains a vector of SimulatorReportSingle objects, for both successful and failing steps.
2020-05-07 09:13:39 -05:00
const SimulatorReportSingle& lastReport() const;
adding setWellSolutions to StandardWellsDense. the function will calculate the well_solutions_ based on well_state. It will be used when we recover the well_state from a failed iteration, then we should also update well_solutions_ for consistence.
2017-08-08 03:44:10 -05:00
[cleanup][Wells] Consequently use SparseMatrixAdapter in addWellContributions.
2019-10-02 05:48:29 -05:00
void addWellContributions(SparseMatrixAdapter& jacobian) const
Do the schur complement after calling the getConvergence method
2018-11-05 08:54:48 -06:00
{
for ( const auto& well: well_container_ ) {
[cleanup][Wells] Consequently use SparseMatrixAdapter in addWellContributions.
2019-10-02 05:48:29 -05:00
well->addWellContributions(jacobian);
Do the schur complement after calling the getConvergence method
2018-11-05 08:54:48 -06:00
}
}
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
// called at the beginning of a report step
void beginReportStep(const int time_step);
Limit timestep when we have THP constraints present. Using 16 days as the current limit. Could be made a user parameter.
2018-11-22 04:01:58 -06:00
/// Return true if any well has a THP constraint.
bool hasTHPConstraints() const;
Only shut down wells if under prediction-type control.
2018-11-23 05:51:13 -06:00
/// Shut down any single well, but only if it is in prediction mode.
Add bool return value to forceShutWellByNameIfPredictionMode(). Returns true if the well requested was actually shut.
2018-12-03 06:24:34 -06:00
/// Returns true if the well was actually found and shut.
bool forceShutWellByNameIfPredictionMode(const std::string& wellname, const double simulation_time);
Add method BlackoilWellModel::forceShutWellByName().
2018-11-22 09:24:17 -06:00
Handle WELLPI keyword in ACTIONX When an ACTIONX has evaluated to True we inspect the keyword payload and if it contains WELPI we query the well model for current wellpi values and pass that along as context to the Schedule::applyAction()
2021-02-12 05:35:53 -06:00
void updateEclWell(int timeStepIdx, int well_index);
void updateEclWell(int timeStepIdx, const std::string& wname);
Implement BlackoilWellModel::hasWell() method
2021-02-12 04:26:14 -06:00
bool hasWell(const std::string& wname);
Handle WELLPI keyword in ACTIONX When an ACTIONX has evaluated to True we inspect the keyword payload and if it contains WELPI we query the well model for current wellpi values and pass that along as context to the Schedule::applyAction()
2021-02-12 05:35:53 -06:00
double wellPI(int well_index) const;
double wellPI(const std::string& well_name) const;
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
protected:
Simulator& ebosSimulator_;
Avoid using the Wells struct.
2019-10-23 02:09:45 -05:00
Rename Well2 -> Well and Group2 -> Group
2019-11-13 16:16:11 -06:00
std::vector< Well > wells_ecl_;
Avoid using the Wells struct.
2019-10-23 02:09:45 -05:00
std::vector< std::vector<PerforationData> > well_perf_data_;
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
std::vector< WellProdIndexCalculator > prod_index_calc_;
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
Added a class with information and comunicator for parallel wells. BlackoilWellModel now stores an instance of this class for each well. Inside that class there is a custom communicator that only contains ranks that will have local cells perforated by the well. This will be used in the application of the distributed well operator. This is another small step in the direction of distributed wells, but it should be safe to merge this (note creation of the custom communicators is a collective operation in MPI but done only once).
2020-10-06 07:52:44 -05:00
std::vector< ParallelWellInfo > parallel_well_info_;
Make the parallel reduction when applying the Wells. The B matrix is basically a component-wise multiplication with a vector followed by a parallel reduction. We do that reduction to all ranks computing for the well to save the broadcast when applying C^T.
2020-10-09 08:09:28 -05:00
std::vector< ParallelWellInfo* > local_parallel_well_info_;
Added a class with information and comunicator for parallel wells. BlackoilWellModel now stores an instance of this class for each well. Inside that class there is a custom communicator that only contains ranks that will have local cells perforated by the well. This will be used in the application of the distributed well operator. This is another small step in the direction of distributed wells, but it should be safe to merge this (note creation of the custom communicators is a collective operation in MPI but done only once).
2020-10-06 07:52:44 -05:00
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
bool wells_active_;
fixing reviewing comments from PR 1279.
2017-10-16 09:46:28 -05:00
more or less getting the old implementation in and compile now.
2017-06-15 10:19:49 -05:00
// a vector of all the wells.
makding createWellContainer a static function.
2017-08-21 03:23:42 -05:00
std::vector<WellInterfacePtr > well_container_;
more or less getting the old implementation in and compile now.
2017-06-15 10:19:49 -05:00
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
// map from logically cartesian cell indices to compressed ones
Only use connections in the interior for distributed wells.
2020-11-10 04:54:19 -06:00
// cells not in the interior are not mapped. This deactivates
// these for distributed wells and make the distribution non-overlapping.
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
std::vector<int> cartesian_to_compressed_;
Move addCellRates to interface and add is_cell_penetrated
2018-11-15 07:37:01 -06:00
std::vector<bool> is_cell_perforated_;
Refactored how well information is exported after load balancing. Previously, we exported an unordered map containing all names of wells that are not present in the local part of the grid. As we envision to have wells that are distributed across multiple processors, this information does not seem to be enough. We need to be able to set up communication for each well. To do this we need to find out who handles perforations of each well. We now export a full list of well name together with a boolean indicating whether it perforates local cells (vector of pair of string and bool).
2020-09-22 07:12:15 -05:00
std::function<bool(const Well&)> is_shut_or_defunct_;
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
void initializeWellProdIndCalculators();
Avoid using the Wells struct.
2019-10-23 02:09:45 -05:00
void initializeWellPerfData();
Split Well Stat Initialization Out to Helper Function Mostly to reduce the complexity of the implementation of beginReportStep() and to enable easier reordering of the stages.
2020-10-19 17:16:52 -05:00
void initializeWellState(const int timeStepIdx,
const int globalNumWells,
const SummaryState& summaryState);
Avoid using the Wells struct.
2019-10-23 02:09:45 -05:00
makding createWellContainer a static function.
2017-08-21 03:23:42 -05:00
// create the well container
Avoid using the Wells struct.
2019-10-23 02:09:45 -05:00
std::vector<WellInterfacePtr > createWellContainer(const int time_step);
more or less getting the old implementation in and compile now.
2017-06-15 10:19:49 -05:00
Well Model: Add Helper for Well Pointer Creation This commit adds a new helper function, WellInterfacePtr createWellPointer(wellID, reportStep) const which is responsible for creating appropriately typed derived well pointers depending on well types (multi-segment vs. standard). This, in turn, allows us to centralise this logic and use the same factory function both when creating the 'well_container_' and when forming the well-test objects. Finally, this helper will become useful for calculating PI/II values of shut/stopped wells in the context of WELPI.
2020-12-01 11:04:46 -06:00
WellInterfacePtr
createWellPointer(const int wellID,
const int time_step) const;
template <typename WellType>
std::unique_ptr<WellType>
createTypedWellPointer(const int wellID,
const int time_step) const;
correct exception handling in wells for parallel runs
2019-02-07 07:43:17 -06:00
WellInterfacePtr createWellForWellTest(const std::string& well_name, const int report_step, Opm::DeferredLogger& deferred_logger) const;
refactoring the wellTesting in BlackoilWellModel so that we can do well test for different closing reason.
2018-10-31 08:56:56 -05:00
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
WellState well_state_;
WellState previous_well_state_;
froze wellState at nupcol iterations
2019-12-17 01:49:47 -06:00
WellState well_state_nupcol_;
adding well collection to StandardWellsDense to make StandardWellsDense have access to the group information.
2017-01-09 03:36:17 -06:00
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
const ModelParameters param_;
Reorganize the wellModel - All well-related stuff is moved to StandardWellsDense.hpp - Some unused functions are removed from BlackoilModelEbos.hpp
2016-08-23 02:45:37 -05:00
bool terminal_output_;
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
std::vector<int> pvt_region_idx_;
small improvements to StandardWellsDense the most significant change is that only a "PhaseUsage" object must be passed to its constructor instead of a full "fluid object". also, the pointers to the vector of "active" phases has been converted into a full object. (this helps to avoid potential use-after-free errors.)
2017-01-11 10:02:20 -06:00
PhaseUsage phase_usage_;
Renamed variables/functions for number of cells.
2020-10-05 13:02:13 -05:00
size_t global_num_cells_;
more cleaning up of StandardWellsDense. not functional change.
2017-08-11 07:51:29 -05:00
// the number of the cells in the local grid
Renamed variables/functions for number of cells.
2020-10-05 13:02:13 -05:00
size_t local_num_cells_;
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
double gravity_;
std::vector<double> depth_;
Fix intial fluid distribution in the well Solve the well equation in order to determine the initial fluid content of the well used for the hydrostatic pressure calculation in the well.
2018-03-23 06:56:19 -05:00
bool initial_step_;
only double check the current group constraint at the start of a report step
2020-01-29 01:41:41 -06:00
bool report_step_starts_;
Simplified using fmt::format() Simplified debug output formatting by using fmt::format(). Also switched off glift debug output by default.
2020-10-01 11:27:57 -05:00
bool glift_debug = false;
Add parameter --alternative-well-rate-init. With this, a slightly more sophisticated procedure is used for well rate intialization. Since it changes existing results, it defaults to false, giving the existing behaviour.
2020-10-15 10:56:11 -05:00
bool alternative_well_rate_init_;
Run WELPI Scaling At Beginning of Report Step This commit implements the WELPI feature. We calculate new PI/II values for all wells in the event of a WELPI request and use those values for well-specific WELPI request, to calculate CTF scaling factors. We then apply those factors to all subsequent editions of the well provided the connection factors are eligible for WELPI-based rescaling. If we trigger a rescaling event we also reset the WellState's internal copies of the CTFs and reinitialize the Well PI calculators to ensure the rescaling takes effect immediately. Since we rely on PI values being available at the end of each time step we must also take care to forward those values from the WellState of one report step to the WellState of the next report step. Finally, take care not to redo a WELPI scaling if we've already performed the scaling operation and restart a report step. This, in turn, happens if WELPI is requested on the first report step.
2020-10-29 17:30:09 -05:00
std::optional<int> last_run_wellpi_{};
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
std::unique_ptr<RateConverterType> rateConverter_;
Use ScheduleState to handle VFP propertes + simplifications
2021-01-14 12:22:34 -06:00
std::unique_ptr<VFPProperties> vfp_properties_;
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
Refactor SimulatorReport system. Now SimulatorReport object contains a vector of SimulatorReportSingle objects, for both successful and failing steps.
2020-05-07 09:13:39 -05:00
SimulatorReportSingle last_report_;
Use the global number of cells for the average. This number is still wrong in master but well become correct once PR #1107 is merged.
2017-03-24 09:12:42 -05:00
implement WTEST support
2018-06-06 08:17:59 -05:00
WellTestState wellTestState_;
implement proper guiderate support Tested on simple problems including GUIDERAT
2019-09-30 05:49:36 -05:00
std::unique_ptr<GuideRate> guideRate_;
implement WTEST support
2018-06-06 08:17:59 -05:00
Implement extended network model.
2020-05-15 04:21:32 -05:00
std::map<std::string, double> node_pressures_; // Storing network pressures for output.
makding createWellContainer a static function.
2017-08-21 03:23:42 -05:00
// used to better efficiency of calcuation
[bugfix][WellModelMatrixAdapter] fix applyscaleadd method.
2016-11-17 06:43:39 -06:00
mutable BVector scaleAddRes_;
[cleanup] Use class variables instead of creating new vectors inside the apply method of StandardWellsDense.
2016-11-02 04:43:55 -05:00
flow: avoid wrangling around with dummy state objects these objects are only used by flow_legacy, so not having to deal with them anymore lets non-legacy flow avoid to jump through a lot of hoops for the sake of having a common API. this required a fork of the NonlinearSolver and AdaptiveTimeStepping classes. this is not a problem because the original classes would get pruned to look like the new ones once flow_legacy gets moved out of the opm-simulators module.
2018-06-06 03:59:41 -05:00
const Grid& grid() const
{ return ebosSimulator_.vanguard().grid(); }
const EclipseState& eclState() const
{ return ebosSimulator_.vanguard().eclState(); }
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
const Schedule& schedule() const
adapt to the gridManager() -> vanguard() change in ewoms
2018-02-01 09:27:42 -06:00
{ return ebosSimulator_.vanguard().schedule(); }
cleaning up for StandardWellsDense.
2017-08-10 08:27:05 -05:00
Implements support for gas lift optimization. Implements gas lift optimization for a single StandardWell. Support for gas lift optimization for multi-segment wells, groups of wells and networks is not implemented yet. The keywords LIFTOPT, WLIFTOPT, and VFPPROD are used to supply parameters for the optimization. Also adds support for summary output of liftgas injection rate via keyword WGLIR.
2020-09-30 03:04:39 -05:00
void gliftDebug(
const std::string &msg,
Opm::DeferredLogger& deferred_logger) const;
Added BlackoilWellModel::getLocalNonshutWells to reduce code duplication.
2020-10-09 08:09:28 -05:00
/// \brief Get the wells of our partition that are not shut.
/// \param timeStepIdx The index of the time step.
/// \param[out] globalNumWells the number of wells globally.
std::vector< Well > getLocalNonshutWells(const int timeStepIdx,
Factored out creation of parallel well infos from getLocalNonshutWells.
2020-12-04 03:06:14 -06:00
int& globalNumWells) const;
/// \brief Create the parallel well information
/// \param localWells The local wells from ECL schedule
std::vector< ParallelWellInfo* >
createLocalParallelWellInfo(const std::vector<Well>& localWells);
Added BlackoilWellModel::getLocalNonshutWells to reduce code duplication.
2020-10-09 08:09:28 -05:00
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
// compute the well fluxes and assemble them in to the reservoir equations as source terms
// and in the well equations.
void assemble(const int iterationIdx,
const double dt);
// called at the end of a time step
finish the injecivity functionality the result looks okay
2018-11-30 05:15:51 -06:00
void timeStepSucceeded(const double& simulationTime, const double dt);
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
// called at the end of a report step
void endReportStep();
// using the solution x to recover the solution xw for wells and applying
// xw to update Well State
void recoverWellSolutionAndUpdateWellState(const BVector& x);
Handle guide-rate based well constraints from groups.
2020-02-10 08:16:09 -06:00
void updateWellControls(Opm::DeferredLogger& deferred_logger, const bool checkGroupControls);
void updateAndCommunicateGroupData();
Implement extended network model.
2020-05-15 04:21:32 -05:00
void updateNetworkPressures();
cleaning up for StandardWellsDense.
2017-08-10 08:27:05 -05:00
// setting the well_solutions_ based on well_state.
correct exception handling in wells for parallel runs
2019-02-07 07:43:17 -06:00
void updatePrimaryVariables(Opm::DeferredLogger& deferred_logger);
cleaning up for StandardWellsDense.
2017-08-10 08:27:05 -05:00
Renamed variables/functions for number of cells.
2020-10-05 13:02:13 -05:00
void setupCartesianToCompressed_(const int* global_cell, int local_num__cells);
Add polymer option to flow_ebos No extra equation is added for polymer in the well equation. Seperate executables are added for polymer: flow_ebos_polymer and solvent: flow_ebos_solvent Tested and verified on the test cases in polymer_test_suite This PR should not effect the performance and results of the blackoil simulator
2017-06-07 02:29:31 -05:00
quell unused parameter warning
2021-01-28 05:52:19 -06:00
void setRepRadiusPerfLength();
Add polymer option to flow_ebos No extra equation is added for polymer in the well equation. Seperate executables are added for polymer: flow_ebos_polymer and solvent: flow_ebos_solvent Tested and verified on the test cases in polymer_test_suite This PR should not effect the performance and results of the blackoil simulator
2017-06-07 02:29:31 -05:00
using B_avg for the inner iteration for multisegment wells
2019-02-27 07:47:31 -06:00
void computeAverageFormationFactor(std::vector<Scalar>& B_avg) const;
cleaning up for StandardWellsDense.
2017-08-10 08:27:05 -05:00
// Calculating well potentials for each well
Use well and group controls from opm-common. This PR remove the usage of well_control_ from opm-core and instead uses the control classes for wells and groups from opm-common. This PR also removes the usage of the group classes from opm-core.
2019-08-07 07:13:11 -05:00
void computeWellPotentials(std::vector<double>& well_potentials, const int reportStepIdx, Opm::DeferredLogger& deferred_logger);
cleaning up for StandardWellsDense.
2017-08-10 08:27:05 -05:00
const std::vector<double>& wellPerfEfficiencyFactors() const;
Use well and group controls from opm-common. This PR remove the usage of well_control_ from opm-core and instead uses the control classes for wells and groups from opm-common. This PR also removes the usage of the group classes from opm-core.
2019-08-07 07:13:11 -05:00
void calculateEfficiencyFactors(const int reportStepIdx);
cleaning up for StandardWellsDense.
2017-08-10 08:27:05 -05:00
Unconditionally Calculate PI at End of Timestep This commit ensures that we calculate the well and connection level per-phase steady-state productivity index (PI) at the end of a completed time step (triggered from endTimeStep()). We add a new data member, BlackoilWellModel<>::prod_index_calc_ which holds one WellProdIndexCalculator for each of the process' local wells and a new interface member function WellInterface::updateProductivityIndex which uses a per-well PI calculator to actually compute the PI values and store those in the WellState. Implement this member function for both StandardWell and MultisegmentWell. Were it not for 'getMobility' existing only in the derived classes, the two equal implementations could be merged and moved to the interface. We also add a new data member to the WellStateFullyImplicitBlackoil to hold the connection-level PI values. Finally, remove the conditional PI calculation from StandardWell's well equation assembly routine.
2020-10-09 06:38:33 -05:00
void calculateProductivityIndexValues(DeferredLogger& deferred_logger);
adding a function calculateExplictQuantities to WellInterface to hide some implementation details.
2017-09-05 04:09:58 -05:00
// it should be able to go to prepareTimeStep(), however, the updateWellControls() and initPrimaryVariablesEvaluation()
// makes it a little more difficult. unless we introduce if (iterationIdx != 0) to avoid doing the above functions
// twice at the beginning of the time step
/// Calculating the explict quantities used in the well calculation. By explicit, we mean they are cacluated
/// at the beginning of the time step and no derivatives are included in these quantities
correct exception handling in wells for parallel runs
2019-02-07 07:43:17 -06:00
void calculateExplicitQuantities(Opm::DeferredLogger& deferred_logger) const;
cleaning up for StandardWellsDense.
2017-08-10 08:27:05 -05:00
renaming well_solutions_ and well_variables to give slightly easier understanding.
2017-08-21 08:41:25 -05:00
void initPrimaryVariablesEvaluation() const;
cleaning up for StandardWellsDense.
2017-08-10 08:27:05 -05:00
more cleaning up of StandardWellsDense. not functional change.
2017-08-11 07:51:29 -05:00
// The number of components in the model.
Address issues raised in the review of the PR
2017-11-08 08:48:30 -06:00
int numComponents() const;
renamed numWells to numLocalWells in BlackoilWellmodel as this better reflects that it is not the number of wells in the whole domain but just the one in the part of the domain stored in the local process.
2019-11-01 09:11:21 -05:00
int numLocalWells() const;
Address issues raised in the review of the PR
2017-11-08 08:48:30 -06:00
int numPhases() const;
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
fixing mistakes due to rebasing.
2019-03-04 04:24:52 -06:00
void assembleWellEq(const std::vector<Scalar>& B_avg, const double dt, Opm::DeferredLogger& deferred_logger);
adding comments about function calculateBhpFromThp.
2017-08-14 07:11:58 -05:00
// some preparation work, mostly related to group control and RESV,
// at the beginning of each time step (Not report step)
Address PR comments
2019-05-24 09:45:27 -05:00
void prepareTimeStep(Opm::DeferredLogger& deferred_logger);
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
Address issues raised in the review of the PR
2017-11-08 08:48:30 -06:00
void extractLegacyCellPvtRegionIndex_();
void extractLegacyDepth_();
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
/// return true if wells are available in the reservoir
bool wellsActive() const;
void setWellsActive(const bool wells_active);
re-organizting the function prepareTimeStep() for StandardWellsDense for better readibility and organization.
2017-09-04 06:54:41 -05:00
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
/// return true if wells are available on this process
bool localWellsActive() const;
Name completion and connection consistently
2018-06-28 06:47:10 -05:00
/// upate the wellTestState related to economic limits
void updateWellTestState(const double& simulationTime, WellTestState& wellTestState) const;
Make the wellModel self-contained The wellModel is now persistent over the time steps, with an update method called every reportStep/episode. This allows the following simplifications: 1. move the wellState to the WellModel 2. add a ref to the ebosSimulator to the wellModel 3. clean up the parameters passed to the wellModel methods 4. move RESV handling to the WellModel and the rateConverter 5. move the econLimit update to the WellModel
2017-11-08 06:57:36 -06:00
Address issues raised in the review of the PR
2017-11-08 08:48:30 -06:00
void updatePerforationIntensiveQuantities();
re-organizting the function prepareTimeStep() for StandardWellsDense for better readibility and organization.
2017-09-04 06:54:41 -05:00
correct exception handling in wells for parallel runs
2019-02-07 07:43:17 -06:00
void wellTesting(const int timeStepIdx, const double simulationTime, Opm::DeferredLogger& deferred_logger);
implement WTEST support
2018-06-06 08:17:59 -05:00
Remove usage of BlackoilState class This allows (re)moving of the following files opm/autodiff/RateConverter.hpp opm/autodiff/Compat.cpp opm/autodiff/Compat.hpp opm/core/props/BlackoilPropertiesInterface.hpp opm/core/simulator/BlackoilState.cpp opm/core/simulator/BlackoilState.hpp opm/core/simulator/BlackoilStateToFluidState.hpp opm/core/utility/initHydroCarbonState.hpp opm/polymer/PolymerBlackoilState.cpp opm/polymer/PolymerBlackoilState.hpp tests/test_blackoilstate.cpp
2018-11-26 05:09:04 -06:00
// convert well data from opm-common to well state from opm-core
void wellsToState( const data::Wells& wells,
Chase Group/Node Summary API Update This is in preparation of adding support for outputting the network node pressure quantity, GPR, to the summary file. In particular, 'GroupValues' is renamed to 'GroupAndNetworkValues' and has new individual datamembers for the former group-level data and the new node-level data. Update BlackoilWellModel::groupData() and CollectToIORank accordingly and bring the parallel restart facility in line with the new layout.
2020-09-20 15:16:07 -05:00
const data::GroupAndNetworkValues& grpNwrkValues,
recovering well restart data for multisegment well When multisegment wells are involved for RESTART, based on the recovered segment-related quantities as Opm::data::Segment objects, the segment phase rates and segment pressure are recovered as part of the WellStateFullyImplicitBlackoil.
2019-03-22 03:41:29 -05:00
const PhaseUsage& phases,
const bool handle_ms_well,
WellStateFullyImplicitBlackoil& state ) const;
Remove usage of BlackoilState class This allows (re)moving of the following files opm/autodiff/RateConverter.hpp opm/autodiff/Compat.cpp opm/autodiff/Compat.hpp opm/core/props/BlackoilPropertiesInterface.hpp opm/core/simulator/BlackoilState.cpp opm/core/simulator/BlackoilState.hpp opm/core/simulator/BlackoilStateToFluidState.hpp opm/core/utility/initHydroCarbonState.hpp opm/polymer/PolymerBlackoilState.cpp opm/polymer/PolymerBlackoilState.hpp tests/test_blackoilstate.cpp
2018-11-26 05:09:04 -06:00
addressing review comments
2019-04-04 08:36:35 -05:00
// whether there exists any multisegment well open on this process
Avoid using the Wells struct.
2019-10-23 02:09:45 -05:00
bool anyMSWellOpenLocal() const;
recovering well restart data for multisegment well When multisegment wells are involved for RESTART, based on the recovered segment-related quantities as Opm::data::Segment objects, the segment phase rates and segment pressure are recovered as part of the WellStateFullyImplicitBlackoil.
2019-03-22 03:41:29 -05:00
Rename Well2 -> Well and Group2 -> Group
2019-11-13 16:16:11 -06:00
const Well& getWellEcl(const std::string& well_name) const;
Use well and group controls from opm-common. This PR remove the usage of well_control_ from opm-core and instead uses the control classes for wells and groups from opm-common. This PR also removes the usage of the group classes from opm-core.
2019-08-07 07:13:11 -05:00
Handle guide-rate based well constraints from groups.
2020-02-10 08:16:09 -06:00
void updateGroupIndividualControls(Opm::DeferredLogger& deferred_logger, std::set<std::string>& switched_groups);
Various fixes and refactoring. - Communicate all well rates. - When changing controls, modify rates to satisfy failed constraint. - Ensure targets are positive. - Always solve for potentials for MSW (temporary fix).
2020-03-24 03:24:45 -05:00
void updateGroupIndividualControl(const Group& group, Opm::DeferredLogger& deferred_logger, std::set<std::string>& switched_groups);
bool checkGroupConstraints(const Group& group, Opm::DeferredLogger& deferred_logger) const;
Silence warnings and fix whitespace.
2020-04-08 03:41:20 -05:00
Group::ProductionCMode checkGroupProductionConstraints(const Group& group, Opm::DeferredLogger& deferred_logger) const;
Group::InjectionCMode checkGroupInjectionConstraints(const Group& group, const Phase& phase) const;
Implement min/max for GCONSALE Only default action RATE is implemented for violation of maximum sales target
2020-05-04 08:56:34 -05:00
void checkGconsaleLimits(const Group& group, WellState& well_state, Opm::DeferredLogger& deferred_logger ) const;
Various fixes and refactoring. - Communicate all well rates. - When changing controls, modify rates to satisfy failed constraint. - Ensure targets are positive. - Always solve for potentials for MSW (temporary fix).
2020-03-24 03:24:45 -05:00
Handle guide-rate based well constraints from groups.
2020-02-10 08:16:09 -06:00
void updateGroupHigherControls(Opm::DeferredLogger& deferred_logger, std::set<std::string>& switched_groups);
void checkGroupHigherConstraints(const Group& group, Opm::DeferredLogger& deferred_logger, std::set<std::string>& switched_groups);
Use well and group controls from opm-common. This PR remove the usage of well_control_ from opm-core and instead uses the control classes for wells and groups from opm-common. This PR also removes the usage of the group classes from opm-core.
2019-08-07 07:13:11 -05:00
Silence warnings and fix whitespace.
2020-04-08 03:41:20 -05:00
void actionOnBrokenConstraints(const Group& group, const Group::ExceedAction& exceed_action, const Group::ProductionCMode& newControl, Opm::DeferredLogger& deferred_logger);
Use well and group controls from opm-common. This PR remove the usage of well_control_ from opm-core and instead uses the control classes for wells and groups from opm-common. This PR also removes the usage of the group classes from opm-core.
2019-08-07 07:13:11 -05:00
Silence warnings and fix whitespace.
2020-04-08 03:41:20 -05:00
void actionOnBrokenConstraints(const Group& group, const Group::InjectionCMode& newControl, const Phase& topUpPhase, Opm::DeferredLogger& deferred_logger);
Use well and group controls from opm-common. This PR remove the usage of well_control_ from opm-core and instead uses the control classes for wells and groups from opm-common. This PR also removes the usage of the group classes from opm-core.
2019-08-07 07:13:11 -05:00
support REIN for solvent
2019-09-23 08:15:55 -05:00
WellInterfacePtr getWell(const std::string& well_name) const;
Rename Well2 -> Well and Group2 -> Group
2019-11-13 16:16:11 -06:00
void updateWsolvent(const Group& group, const Schedule& schedule, const int reportStepIdx, const WellStateFullyImplicitBlackoil& wellState);
support REIN for solvent
2019-09-23 08:15:55 -05:00
Rename Well2 -> Well and Group2 -> Group
2019-11-13 16:16:11 -06:00
void setWsolvent(const Group& group, const Schedule& schedule, const int reportStepIdx, double wsolvent);
support REIN for solvent
2019-09-23 08:15:55 -05:00
Run WELPI Scaling At Beginning of Report Step This commit implements the WELPI feature. We calculate new PI/II values for all wells in the event of a WELPI request and use those values for well-specific WELPI request, to calculate CTF scaling factors. We then apply those factors to all subsequent editions of the well provided the connection factors are eligible for WELPI-based rescaling. If we trigger a rescaling event we also reset the WellState's internal copies of the CTFs and reinitialize the Well PI calculators to ensure the rescaling takes effect immediately. Since we rely on PI values being available at the end of each time step we must also take care to forward those values from the WellState of one report step to the WellState of the next report step. Finally, take care not to redo a WELPI scaling if we've already performed the scaling operation and restart a report step. This, in turn, happens if WELPI is requested on the first report step.
2020-10-29 17:30:09 -05:00
void runWellPIScaling(const int timeStepIdx, DeferredLogger& local_deferredLogger);
Refactor Well Guide Rate Summary Assignment In anticipation of adding more steps later.
2020-10-19 17:10:27 -05:00
void assignWellGuideRates(data::Wells& wsrpt) const;
Well Data: Report CTFs for Shut Connections Needed to ensure that the CTFs reported to the summary files will be correct in the presence of WELPI even for shut connections.
2020-10-29 17:16:31 -05:00
void assignShutConnections(data::Wells& wsrpt) const;
Chase Group/Node Summary API Update This is in preparation of adding support for outputting the network node pressure quantity, GPR, to the summary file. In particular, 'GroupValues' is renamed to 'GroupAndNetworkValues' and has new individual datamembers for the former group-level data and the new node-level data. Update BlackoilWellModel::groupData() and CollectToIORank accordingly and bring the parallel restart facility in line with the new layout.
2020-09-20 15:16:07 -05:00
void assignGroupValues(const int reportStepIdx,
const Schedule& sched,
std::map<std::string, data::GroupData>& gvalues) const;
changed: remove unused parameters
2020-10-21 06:32:12 -05:00
void assignNodeValues(std::map<std::string, data::NodeData>& gvalues) const;
Implement extended network model.
2020-05-15 04:21:32 -05:00
Well Model: Report Guiderates at Well and Group Levels This commit adds support for reporting the simulator's guiderate values at the well and group levels to the output layer through the wellData() and groupData() member functions. We add several new member functions that collectively assemble the values and assign them to objects of type Opm::data::GuideRateValue for subsequent output to the summary and restart files. In particular getGuideRateValues(const Well&) const getGuideRateValues(const Group&) const retrieve the guiderate values for all phases for those individual wells and groups for which the guideRate_ data member defines a value. The most complicated function of this commit is calculateAllGroupGuideRates which aggregates those individual contributions from the well (leaf) level up to the root of the group tree (the FIELD group). This process uses an ancillary array ('up') to keep track of the parent groups of all wells and all groups, and to ensure that we only visit each parent group once (sort+unique on subsets of the 'up' array). We do not currently support outputting guiderates for reservoir voidage volume (GuideRateModel::Target::RES).
2020-07-20 14:38:30 -05:00
std::unordered_map<std::string, data::GroupGuideRates>
calculateAllGroupGuiderates(const int reportStepIdx, const Schedule& sched) const;
Simulator Group Data: Chase Upstream API Update This commit makes the 'groupData()' function return a map<string, Opm::data::GroupData> object instead of a map<string, Opm::data::GroupConstraints> object. The 'GroupData' structure adds a level of indirection to the current per-group summary quantities that are directly assigned by the simulator. While here, also move the assignment of the current group constraints/control values out to a separate helper to reduce the body of the per-group loop in 'groupData()'. This is in preparation of adding support for reporting group-level production/injection guiderates (Gx[IP]GR) to the summary file.
2020-07-01 06:52:02 -05:00
void assignGroupControl(const Group& group, data::GroupData& gdata) const;
Well Model: Report Guiderates at Well and Group Levels This commit adds support for reporting the simulator's guiderate values at the well and group levels to the output layer through the wellData() and groupData() member functions. We add several new member functions that collectively assemble the values and assign them to objects of type Opm::data::GuideRateValue for subsequent output to the summary and restart files. In particular getGuideRateValues(const Well&) const getGuideRateValues(const Group&) const retrieve the guiderate values for all phases for those individual wells and groups for which the guideRate_ data member defines a value. The most complicated function of this commit is calculateAllGroupGuideRates which aggregates those individual contributions from the well (leaf) level up to the root of the group tree (the FIELD group). This process uses an ancillary array ('up') to keep track of the parent groups of all wells and all groups, and to ensure that we only visit each parent group once (sort+unique on subsets of the 'up' array). We do not currently support outputting guiderates for reservoir voidage volume (GuideRateModel::Target::RES).
2020-07-20 14:38:30 -05:00
data::GuideRateValue getGuideRateValues(const Well& well) const;
data::GuideRateValue getGuideRateValues(const Group& group) const;
void getGuideRateValues(const GuideRate::RateVector& qs,
const bool is_inj,
const std::string& wgname,
data::GuideRateValue& grval) const;
void assignGroupGuideRates(const Group& group,
const std::unordered_map<std::string, data::GroupGuideRates>& groupGuideRates,
data::GroupData& gdata) const;
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
};
} // namespace Opm
the first part in separating the StandardWellsDense.hpp implementations. split into commits for easy debugging purpose.
2017-02-13 09:45:06 -06:00
changing StandardWellsDense to BlackoilModelEbos for a better naming.
2017-09-26 03:52:05 -05:00
#include "BlackoilWellModel_impl.hpp"
Implement new well model Start using the well model desribed in SPE 12259 "Enhancements to the Strongly Coupled, Fully Implicit Well Model: Wellbore CrossFlow Modeling and Collective Well Control" The new well model uses three well primary variables: (the old one had 4) 1) bhp for rate controlled wells or total_rate for bhp controlled wells 2) flowing fraction of water Fw = g_w * Q_w / (g_w * Q_w + q_o * Q_o + q_g + Q_g) 3) flowing fraction of gas Fg = g_g * Q_g / (g_w * Q_w + q_o * Q_o + q_g + Q_g) where g_g = 0.01 and q_w = q_o = 1; Note 1: This is the starting point of implementing a well model using denseAD The plan is to gradually remove Eigen from the well model and instead use the fluidState object provided by the Ebos simulator Note 2: This is still work in progress and substantial cleaning and testing is still needed. Note 3: Runs SPE1, SPE9 and norne until 950 days.
2016-08-11 06:31:52 -05:00
#endif
Reference in New Issue Copy Permalink