OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity
Files
c1f16bd9814a8455c7ddee54f625111fadaf2f8d
opm-simulators/opm/simulators/wells/StandardWell.hpp

526 lines
26 KiB
C++
Raw Normal View History

adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 11:41:03 +02:00
/*
adding the copyright information.
2017-08-03 16:45:59 +02:00
Copyright 2017 SINTEF Digital, Mathematics and Cybernetics.
adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 11:41:03 +02:00
Copyright 2017 Statoil ASA.
adding the copyright information.
2017-08-03 16:45:59 +02:00
Copyright 2016 - 2017 IRIS AS.
adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 11:41:03 +02: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/>.
*/
#ifndef OPM_STANDARDWELL_HEADER_INCLUDED
#define OPM_STANDARDWELL_HEADER_INCLUDED
changed: (re)move unnecessary includes
2021-05-12 08:47:22 +02:00
#include <opm/simulators/timestepping/ConvergenceReport.hpp>
Moved Flow-related classes and files to opm/simulators/flow.
2019-06-20 09:09:19 +02:00
#include <opm/simulators/wells/RateConverter.hpp>
Implements gas lift optimization for groups. Extends PR #2824 to include support for GLIFTOPT (item 2, maximum lift gas supply for a group) and group production constraints. The optimization is split into two phases. First the wells are optimized separately (as in PR #2824). In this phase LIFTOPT and WLIFTOPT constraints (e.g. maxmimum lift gas injection for a well, minimum economic gradient) are considered together with well production constraints. Then, in the next phase the wells are optimized in groups. Here, the ALQ distribution from the first phase is used as a starting point. If a group has any production rate constraints, and/or a limit on its total rate of lift gas supply, lift gas is redistributed to the wells that gain the most benefit from it by considering which wells that currently has the largest weighted incremental gradient (i.e. increase in oil rate compared to increase in ALQ).
2021-03-03 13:59:26 +01:00
#include <opm/simulators/wells/VFPInjProperties.hpp>
#include <opm/simulators/wells/VFPProdProperties.hpp>
Moved files to opm/simulators/ subdirs.
2019-05-07 13:06:02 +02:00
#include <opm/simulators/wells/WellInterface.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 13:38:33 +02:00
#include <opm/simulators/wells/WellProdIndexCalculator.hpp>
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 15:09:28 +02:00
#include <opm/simulators/wells/ParallelWellInfo.hpp>
adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 11:41:03 +02:00
changed: ewoms/models/blackoil -> opm/models/blackoil
2019-09-16 11:22:14 +02:00
#include <opm/models/blackoil/blackoilpolymermodules.hh>
#include <opm/models/blackoil/blackoilsolventmodules.hh>
Alternative solvent extension for the black oil model.
2020-10-10 16:20:25 +02:00
#include <opm/models/blackoil/blackoilextbomodules.hh>
changed: ewoms/models/blackoil -> opm/models/blackoil
2019-09-16 11:22:14 +02:00
#include <opm/models/blackoil/blackoilfoammodules.hh>
renamed saltwater-->brine and removed keywords from missingFeatures
2019-12-03 17:48:17 +01:00
#include <opm/models/blackoil/blackoilbrinemodules.hh>
first version of micp implementation in flow
2021-10-06 19:32:35 +02:00
#include <opm/models/blackoil/blackoilmicpmodules.hh>
Finalize integration of foam module.
2019-07-04 09:50:08 +02:00
always include Evaluation.hpp even if we are using the dynamic specialization
2022-12-23 13:31:41 +01:00
#include <opm/material/densead/Evaluation.hpp>
Downstream filesystem reorganisation in opm-common
2021-12-14 08:30:15 +01:00
#include <opm/input/eclipse/Schedule/ScheduleTypes.hpp>
removing StandardWellV
2019-03-25 12:52:34 +01:00
add StandardWellEval
2021-06-01 15:49:24 +02:00
#include <opm/simulators/wells/StandardWellEval.hpp>
removing StandardWellV
2019-03-25 12:52:34 +01:00
#include <dune/common/dynvector.hh>
#include <dune/common/dynmatrix.hh>
Implements gas lift optimization for groups. Extends PR #2824 to include support for GLIFTOPT (item 2, maximum lift gas supply for a group) and group production constraints. The optimization is split into two phases. First the wells are optimized separately (as in PR #2824). In this phase LIFTOPT and WLIFTOPT constraints (e.g. maxmimum lift gas injection for a well, minimum economic gradient) are considered together with well production constraints. Then, in the next phase the wells are optimized in groups. Here, the ALQ distribution from the first phase is used as a starting point. If a group has any production rate constraints, and/or a limit on its total rate of lift gas supply, lift gas is redistributed to the wells that gain the most benefit from it by considering which wells that currently has the largest weighted incremental gradient (i.e. increase in oil rate compared to increase in ALQ).
2021-03-03 13:59:26 +01:00
#include <memory>
replace boost::optional with std::optional
2020-02-19 11:02:13 +01:00
#include <optional>
Add robustSolveBhpAtThpLimitProd() method.
2019-10-02 11:16:52 +02:00
adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 11:41:03 +02:00
namespace Opm
{
makding the StandardWell and WellInterface templated with the template parameter TypeTag.
2017-06-19 14:49:49 +02:00
template<typename TypeTag>
add StandardWellGeneric avoid rebuilding this for all simulators when code is only dependent on Scalar. specialized for double
2021-06-03 15:34:14 +02:00
class StandardWell : public WellInterface<TypeTag>
add StandardWellEval
2021-06-01 15:49:24 +02:00
, public StandardWellEval<GetPropType<TypeTag, Properties::FluidSystem>,
StandardWellEval: remove unnecessary Scalar template parameter use the Scalar type from the FluidSystem
2024-02-22 15:17:09 +01:00
GetPropType<TypeTag, Properties::Indices>>
adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 11:41:03 +02:00
{
public:
remove unnecessary <Runspec.hpp> includes
2023-01-05 12:36:46 +01:00
using Base = WellInterface<TypeTag>;
add StandardWellEval
2021-06-01 15:49:24 +02:00
using StdWellEval = StandardWellEval<GetPropType<TypeTag, Properties::FluidSystem>,
StandardWellEval: remove unnecessary Scalar template parameter use the Scalar type from the FluidSystem
2024-02-22 15:17:09 +01:00
GetPropType<TypeTag, Properties::Indices>>;
flow: let the wells be managed by EclProblem
2018-08-16 11:51:36 +02:00
adding function computeAccumWell and computeWellConnectionPressures to StandardWell and removing a few not needed function from StandardWellsDense
2017-06-29 13:52:31 +02:00
// TODO: some functions working with AD variables handles only with values (double) without
// dealing with derivatives. It can be beneficial to make functions can work with either AD or scalar value.
// And also, it can also be beneficial to make these functions hanle different types of AD variables.
using Base to represent WellInterface<TypeTag> for better readability.
2017-08-02 16:19:27 +02:00
using typename Base::Simulator;
using typename Base::IntensiveQuantities;
using typename Base::FluidSystem;
using typename Base::MaterialLaw;
using typename Base::ModelParameters;
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 09:14:08 +01:00
using typename Base::Indices;
Move Rateconverter and pvtIdx to the wellInterface
2017-11-23 08:37:30 +01:00
using typename Base::RateConverterType;
[cleanup][Wells] Consequently use SparseMatrixAdapter in addWellContributions.
2019-10-02 12:48:29 +02:00
using typename Base::SparseMatrixAdapter;
Enable single-phase runs.
2019-10-09 15:24:23 +02:00
using typename Base::FluidState;
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 11:11:00 +01:00
using typename Base::RateVector;
handing the numComponents in WellInterface
2017-06-19 16:46:06 +02:00
Add a flow specialization for blackoil with energy conservation The energy conservation is enabled by specifying either TEMP or THERMAL in the deck. The deck also needs to contatin relevant fluid and rock heat properties. The blackoil + energy equations are solved fully implicit.
2018-03-26 10:50:33 +02:00
using Base::has_solvent;
Alternative solvent extension for the black oil model.
2020-10-10 16:20:25 +02:00
using Base::has_zFraction;
Add a flow specialization for blackoil with energy conservation The energy conservation is enabled by specifying either TEMP or THERMAL in the deck. The deck also needs to contatin relevant fluid and rock heat properties. The blackoil + energy equations are solved fully implicit.
2018-03-26 10:50:33 +02:00
using Base::has_polymer;
add StandardWellEval
2021-06-01 15:49:24 +02:00
using Base::has_polymermw;
Use foam module.
2019-04-26 10:38:37 +02:00
using Base::has_foam;
renamed saltwater-->brine and removed keywords from missingFeatures
2019-12-03 17:48:17 +01:00
using Base::has_brine;
Add a flow specialization for blackoil with energy conservation The energy conservation is enabled by specifying either TEMP or THERMAL in the deck. The deck also needs to contatin relevant fluid and rock heat properties. The blackoil + energy equations are solved fully implicit.
2018-03-26 10:50:33 +02:00
using Base::has_energy;
first version of micp implementation in flow
2021-10-06 19:32:35 +02:00
using Base::has_micp;
Add a flow specialization for blackoil with energy conservation The energy conservation is enabled by specifying either TEMP or THERMAL in the deck. The deck also needs to contatin relevant fluid and rock heat properties. The blackoil + energy equations are solved fully implicit.
2018-03-26 10:50:33 +02:00
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 12:00:04 +02:00
using PolymerModule = BlackOilPolymerModule<TypeTag>;
using FoamModule = BlackOilFoamModule<TypeTag>;
using BrineModule = BlackOilBrineModule<TypeTag>;
Use MatrixBlock consistently, also whitespace cleanup.
2022-06-10 11:08:24 +02:00
using typename Base::PressureMatrix;
Finalize integration of foam module.
2019-07-04 09:50:08 +02:00
addressing some comments and handle the situation that a non-zero target specified for a non-producing phases. We set the rates to zero for this case.
2018-05-18 10:57:08 +02:00
// number of the conservation equations
drop aliases for Indices entries using Indices directly more clearly shows where the data comes from without having to hop through hoops to do so.
2021-09-06 12:47:21 +02:00
static constexpr int numWellConservationEq = Indices::numPhases + Indices::numSolvents;
addressing some comments and handle the situation that a non-zero target specified for a non-producing phases. We set the rates to zero for this case.
2018-05-18 10:57:08 +02:00
// number of the well control equations
drop aliases for Indices entries using Indices directly more clearly shows where the data comes from without having to hop through hoops to do so.
2021-09-06 12:47:21 +02:00
static constexpr int numWellControlEq = 1;
cleaning StandardWell and StandardWellV to make them more comparable, so that we can do refactoring easier later.
2018-12-12 15:58:15 +01:00
// number of the well equations that will always be used
// based on the solution strategy, there might be other well equations be introduced
drop aliases for Indices entries using Indices directly more clearly shows where the data comes from without having to hop through hoops to do so.
2021-09-06 12:47:21 +02:00
static constexpr int numStaticWellEq = numWellConservationEq + numWellControlEq;
small bug fixes.
2018-05-09 15:07:43 +02:00
// the index for Bhp in primary variables and also the index of well control equation
more bug fixing mainly to recover the runnign related to group control example
2018-05-11 14:21:53 +02:00
// they both will be the last one in their respective system.
// TODO: we should have indices for the well equations and well primary variables separately
drop aliases for Indices entries using Indices directly more clearly shows where the data comes from without having to hop through hoops to do so.
2021-09-06 12:47:21 +02:00
static constexpr int Bhp = numStaticWellEq - numWellControlEq;
cleaning StandardWell and StandardWellV to make them more comparable, so that we can do refactoring easier later.
2018-12-12 15:58:15 +01:00
StandardWellPrimaryVariables: make data members private and add generic read-only accessors
2022-11-09 12:26:46 +01:00
using StdWellEval::WQTotal;
using Base to represent WellInterface<TypeTag> for better readability.
2017-08-02 16:19:27 +02:00
using typename Base::Scalar;
collecting the NaN and too large well residuals make sure all the processes will throw if there is any of the processes found abnormal residual values.
2017-08-22 14:49:30 +02:00
using well name and allow_cf form well_ecl.
2017-08-21 11:26:21 +02:00
using Base::name;
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 13:57:36 +01:00
using Base::Water;
using Base::Oil;
using Base::Gas;
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 13:07:16 +02:00
using Base to represent WellInterface<TypeTag> for better readability.
2017-08-02 16:19:27 +02:00
using typename Base::BVector;
more or less getting the old implementation in and compile now.
2017-06-15 17:19:49 +02:00
add StandardWellEval
2021-06-01 15:49:24 +02:00
using Eval = typename StdWellEval::Eval;
using EvalWell = typename StdWellEval::EvalWell;
using BVectorWell = typename StdWellEval::BVectorWell;
using different size of block size of well and reservoir
2017-08-03 15:14:36 +02:00
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 15:09:28 +02:00
StandardWell(const Well& well,
ParallelWellInfo: template Scalar type
2024-02-20 15:35:13 +01:00
const ParallelWellInfo<Scalar>& pw_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 15:09:28 +02:00
const int time_step,
Make it possible to combine solvent and RESV Compute the conversion factor for solvent using the RateConverter.hpp
2017-11-22 14:39:42 +01:00
const ModelParameters& param,
const RateConverterType& rate_converter,
removing numComponents() from WellInterface which is dumplicated from BlackoilWellModel.
2017-11-30 16:31:48 +01:00
const int pvtRegionIdx,
Avoid using the Wells struct.
2019-10-23 09:09:45 +02:00
const int num_components,
const int num_phases,
const int index_of_well,
PerforationData: template Scalar type
2024-02-20 14:37:48 +01:00
const std::vector<PerforationData<Scalar>>& perf_data);
adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 11:41:03 +02:00
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 13:07:16 +02:00
virtual void init(const PhaseUsage* phase_usage_arg,
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
const std::vector<Scalar>& depth_arg,
const Scalar gravity_arg,
const std::vector<Scalar>& B_avg,
dont use explicit vfp lookup for newly opened wells
2022-04-12 08:44:52 +02:00
const bool changed_to_open_this_step) override;
adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 11:41:03 +02:00
WellInterface: make initPrimaryVariablesEvaluation non-const this will obviously modify well state
2022-11-09 13:01:30 +01:00
void initPrimaryVariablesEvaluation() override;
adding extendEval() to StandardWell For this type of functions that related to Evaluation should be implemented within individual well model.
2017-06-19 15:24:49 +02:00
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 13:07:16 +02:00
/// check whether the well equations get converged for this well
Include checking for zero targets from groups where required
2024-03-19 12:50:34 +01:00
virtual ConvergenceReport getWellConvergence(const Simulator& simulator,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
const WellState<Scalar>& well_state,
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
const std::vector<Scalar>& B_avg,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 12:00:04 +02:00
DeferredLogger& deferred_logger,
stricter tolerance for wells with zero rate target for StandardWell only at this moment.
2023-03-30 15:49:27 +02:00
const bool relax_tolerance) const override;
adding getWellConvergence for StandardWell
2017-06-26 14:35:43 +02:00
adding a test for well model. It is just test for StandardWell.
2017-08-22 17:14:52 +02:00
/// Ax = Ax - C D^-1 B x
flow: let the wells be managed by EclProblem
2018-08-16 11:51:36 +02:00
virtual void apply(const BVector& x, BVector& Ax) const override;
adding a test for well model. It is just test for StandardWell.
2017-08-22 17:14:52 +02:00
/// r = r - C D^-1 Rw
flow: let the wells be managed by EclProblem
2018-08-16 11:51:36 +02:00
virtual void apply(BVector& r) const override;
implementing two apply() function in StandardWell_impl The two functions will be essentially the same even for different types of wells. Maybe later we should try to put them in WellInterface.
2017-07-21 14:21:17 +02:00
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 13:07:16 +02:00
/// using the solution x to recover the solution xw for wells and applying
/// xw to update Well State
Include checking for zero targets from groups where required
2024-03-19 12:50:34 +01:00
void recoverWellSolutionAndUpdateWellState(const Simulator& simulator,
make sure zero production rates are obtained for the following wells 1. stopped production wells 2. production wells under zero rate control We guarantee the objective through enforce zero values for the WQTotal primary variable during the initialization and update process during the Newton solution.
2023-03-22 15:10:00 +01:00
const BVector& x,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
WellState<Scalar>& well_state,
WellInterface: make recoverWellSolutionAndUpdateWellState non-const this will obviously modify well state
2022-11-09 13:01:30 +01:00
DeferredLogger& deferred_logger) override;
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 15:30:34 +02:00
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 13:07:16 +02:00
/// computing the well potentials for group control
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
void computeWellPotentials(const Simulator& simulator,
const WellState<Scalar>& well_state,
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
std::vector<Scalar>& well_potentials,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
DeferredLogger& deferred_logger) /* const */ override;
removing well_soltutions_ from WellStateFullyImplicitBlackoilDense adding function setWellSolutions() to StandardWell. The class WellStateFullyImplicitBlackoilDense is ready to be removed now, while the only thing can go wrong compred with the original version is the group control, which is not tested yet.
2017-08-07 17:49:35 +02:00
Include checking for zero targets from groups where required
2024-03-19 12:50:34 +01:00
void updatePrimaryVariables(const Simulator& simulator,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
const WellState<Scalar>& well_state,
make sure zero production rates are obtained for the following wells 1. stopped production wells 2. production wells under zero rate control We guarantee the objective through enforce zero values for the WQTotal primary variable during the initialization and update process during the Newton solution.
2023-03-22 15:10:00 +01:00
DeferredLogger& deferred_logger) override;
removing well_soltutions_ from WellStateFullyImplicitBlackoilDense adding function setWellSolutions() to StandardWell. The class WellStateFullyImplicitBlackoilDense is ready to be removed now, while the only thing can go wrong compred with the original version is the group control, which is not tested yet.
2017-08-07 17:49:35 +02:00
Include checking for zero targets from groups where required
2024-03-19 12:50:34 +01:00
void solveEqAndUpdateWellState(const Simulator& simulator,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
WellState<Scalar>& well_state,
DeferredLogger& deferred_logger) override;
adding a function calculateExplictQuantities to WellInterface to hide some implementation details.
2017-09-05 11:09:58 +02:00
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
void calculateExplicitQuantities(const Simulator& simulator,
const WellState<Scalar>& well_state,
DeferredLogger& deferred_logger) override; // should be const?
Let WellModel decide whether to apply well contributions. It queries the Well whether the jacobian also contains well contributions. If not then it applies them in the operator in addition. Thus the well knows whether that is needed or not.
2018-02-26 12:23:20 +01:00
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
void updateProductivityIndex(const Simulator& simulator,
WellProdIndexCalculator: template Scalar type
2024-02-20 23:39:23 +01:00
const WellProdIndexCalculator<Scalar>& wellPICalc,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
WellState<Scalar>& well_state,
DeferredLogger& deferred_logger) const override;
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 13:38:33 +02:00
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
Scalar connectionDensity(const int globalConnIdx,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
const int openConnIdx) const override;
Hook New WBPn Calculation Up to Well Model This commit activates the support for calculating WBPn summary result values per well in parallel. To affect the calculation we add two new data members in BlackoilWellModelGeneric: - conn_idx_map_: Maps well's connection index (0..getConnections().size() - 1) to connections on current rank. Its local() connections are negative 1 (-1) if the connection is not on current rank, and a non-negative value otherwise. The global() function maps well connections on current rank to global connection ID for each well. Effectively the reverse of local(). Finally, the open() function maps well connections on current rank to open/flowing connections on current rank. Negative 1 if connection is not flowing. - wbpCalculationService: Parallel collection of WBPn calculation objects that knows how to exchange source and result information between all ranks in a communicator. Also handles distributed wells. We furthermore need a way to compute connection-level fluid mixture density values. For the standard well class we add a way to access the StandardWellConnection's 'perf_densities_' values. However, since these are defined for open/flowing connections only, this means we're not able to fully meet the requirements of the WELL/ALL WPAVE depth correction procedure for standard wells. The multi-segmented well type, on the other hand, uses the fluid mixture density in the associated well segment and is therefore well defined for ALL connections. OPEN well connections are supported for both well types.
2023-06-06 21:31:17 +02:00
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
void addWellContributions(SparseMatrixAdapter& mat) const override;
Adding functions for pressure system manipulation to well models. Also add well-aware operator and transfer policy. This will be used for CPR with custom operators.
2021-01-04 15:18:23 +01:00
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
void addWellPressureEquations(PressureMatrix& mat,
const BVector& x,
const int pressureVarIndex,
const bool use_well_weights,
const WellState<Scalar>& well_state) const override;
Let WellModel decide whether to apply well contributions. It queries the Well whether the jacobian also contains well contributions. If not then it applies them in the operator in addition. Thus the well knows whether that is needed or not.
2018-02-26 12:23:20 +01:00
renaming solveWellEqUntilConverged to be iterateWellEquations
2020-06-02 14:54:45 +02:00
// iterate well equations with the specified control until converged
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
bool iterateWellEqWithControl(const Simulator& simulator,
renaming solveWellEqUntilConverged to be iterateWellEquations
2020-06-02 14:54:45 +02:00
const double dt,
const Well::InjectionControls& inj_controls,
const Well::ProductionControls& prod_controls,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
WellState<Scalar>& well_state,
GroupState: template Scalar type
2024-02-17 18:13:46 +01:00
const GroupState<Scalar>& group_state,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 12:00:04 +02:00
DeferredLogger& deferred_logger) override;
renaming solveWellEqUntilConverged to be iterateWellEquations
2020-06-02 14:54:45 +02:00
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 12:50:06 +02:00
// iterate well equations including control switching
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
bool iterateWellEqWithSwitching(const Simulator& simulator,
cleaning up to preapre for pull request
2023-09-25 13:07:39 +02:00
const double dt,
const Well::InjectionControls& inj_controls,
const Well::ProductionControls& prod_controls,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
WellState<Scalar>& well_state,
GroupState: template Scalar type
2024-02-17 18:13:46 +01:00
const GroupState<Scalar>& group_state,
revert changes
2023-10-26 17:28:05 +02:00
DeferredLogger& deferred_logger,
updates
2023-10-30 20:58:09 +01:00
const bool fixed_control = false,
const bool fixed_status = false) override;
adding function iterateWellEqWithSwitching when we do the local solve for well equations, control/status will be updated during the iteration process, such that the converged well gets correct control/status regarding to the current reservoir state. various change in the other parts of the code were made to make the function work as intended.
2023-08-16 12:50:06 +02:00
Let WellModel decide whether to apply well contributions. It queries the Well whether the jacobian also contains well contributions. If not then it applies them in the operator in addition. Thus the well knows whether that is needed or not.
2018-02-26 12:23:20 +01:00
/// \brief Wether the Jacobian will also have well contributions in it.
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
bool jacobianContainsWellContributions() const override
Let WellModel decide whether to apply well contributions. It queries the Well whether the jacobian also contains well contributions. If not then it applies them in the operator in addition. Thus the well knows whether that is needed or not.
2018-02-26 12:23:20 +01:00
{
drop using statement for param_ rather qualify member variable with this->
2021-09-06 12:58:16 +02:00
return this->param_.matrix_add_well_contributions_;
Let WellModel decide whether to apply well contributions. It queries the Well whether the jacobian also contains well contributions. If not then it applies them in the operator in addition. Thus the well knows whether that is needed or not.
2018-02-26 12:23:20 +01:00
}
flow: let the wells be managed by EclProblem
2018-08-16 11:51:36 +02: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 10:04:39 +02:00
/* returns BHP */
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
Scalar computeWellRatesAndBhpWithThpAlqProd(const Simulator& ebos_simulator,
const SummaryState &summary_state,
DeferredLogger& deferred_logger,
std::vector<Scalar>& potentials,
Scalar alq) const;
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 10:04:39 +02:00
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
void computeWellRatesWithThpAlqProd(const Simulator& ebos_simulator,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
const SummaryState& summary_state,
DeferredLogger& deferred_logger,
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
std::vector<Scalar>& potentials,
Scalar alq) const;
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 10:04:39 +02:00
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
std::optional<Scalar>
computeBhpAtThpLimitProdWithAlq(const Simulator& ebos_simulator,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
const SummaryState& summary_state,
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
const Scalar alq_value,
Dont iterate when computing bhp from thp for computing of the well potentials for gaslift optimization
2024-10-23 09:09:09 +02:00
DeferredLogger& deferred_logger,
bool iterate_if_no_solution) const override;
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 10:04:39 +02:00
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
void updateIPRImplicit(const Simulator& simulator,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
WellState<Scalar>& well_state,
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
DeferredLogger& deferred_logger) override;
revert changes
2023-10-26 17:28:05 +02:00
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
void computeWellRatesWithBhp(const Simulator& ebosSimulator,
const Scalar& bhp,
std::vector<Scalar>& well_flux,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
DeferredLogger& deferred_logger) const override;
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 10:04:39 +02:00
// NOTE: These cannot be protected since they are used by GasLiftRuntime
using Base::phaseUsage;
using Base::vfp_properties_;
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
std::vector<Scalar>
computeCurrentWellRates(const Simulator& ebosSimulator,
DeferredLogger& deferred_logger) const override;
Implement extended network model.
2020-05-15 11:21:32 +02:00
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
std::vector<Scalar> getPrimaryVars() const override;
Add methods for getting and setting primary variables. These can be used to manage state in the well models, and will be used in the NLDD solver option. Also added the setupDomains() method, as the getters and setters are working on a domain basis.
2023-06-13 12:58:07 +02:00
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
int setPrimaryVars(typename std::vector<Scalar>::const_iterator it) override;
add useInnerIteration method and move assembleWellEq to the well interface to avoid code duplication
2021-05-10 09:41:18 +02:00
PI: Treat Production Differently From Injection This commit makes the PI/II calculation more closely mirror the approach taken when computing connection flow rates. In particular, we switch to using total mobility, mixing and volume ratios for injecting connections while producing connections continue to use the phase mobilities and formation volume factors derived from conditions in the connecting cells. We also include dissolved gas/oil ratios and vaporised oil/gas ratios in order to fully capture the surface flow conditions. We split the handling of producing/injecting connections out to separate helper functions in order to make the overall logic in updateProductivityIndex() more manageable.ex() more manageable.
2020-10-26 17:33:07 +01:00
protected:
regularize equation for std wells
2022-06-23 15:14:36 +02:00
bool regularize_;
renaming a few functions to reflect the functions better. No functional change.
2017-08-21 14:16:24 +02:00
// updating the well_state based on well solution dwells
Include checking for zero targets from groups where required
2024-03-19 12:50:34 +01:00
void updateWellState(const Simulator& simulator,
make sure zero production rates are obtained for the following wells 1. stopped production wells 2. production wells under zero rate control We guarantee the objective through enforce zero values for the WQTotal primary variable during the initialization and update process during the Newton solution.
2023-03-22 15:10:00 +01:00
const BVectorWell& dwells,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
WellState<Scalar>& well_state,
StandardWell: make updateWellState non-const this will obviously modify well state
2022-11-09 13:05:40 +01:00
DeferredLogger& deferred_logger);
renaming a few functions to reflect the functions better. No functional change.
2017-08-21 14:16:24 +02:00
changed: simplify WellConnectionPressure calculation by passing a struct
2023-05-04 14:27:49 +02:00
using WellConnectionProps = typename StdWellEval::StdWellConnections::Properties;
Generate Property Object Directly This commit switches computePropertiesForPressures() to return a Properties object directly instead of populating an object constructed in the caller. There is just a single call site for this function so there's no benefit to using an out parameter here. While here, also collect the property callbacks into a structure to simplify the function signature. This also enables not filling in the solvent properties unless solvent is active in the run. Update caller accordingly.
2024-07-12 17:51:29 +02:00
// Compute connection level PVT properties needed to calulate the
// pressure difference between well connections.
WellConnectionProps
computePropertiesForWellConnectionPressures(const Simulator& simulator,
const WellState<Scalar>& well_state) const;
adding function computeConnectionDensities to StandardWell which is copied from WellDensitySegmented, while avoid using of the Wells struct. TODO: find a better place to put these long functions.
2017-06-23 15:54:05 +02:00
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
void computeWellConnectionDensitesPressures(const Simulator& simulator,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
const WellState<Scalar>& well_state,
changed: simplify WellConnectionPressure calculation by passing a struct
2023-05-04 14:27:49 +02:00
const WellConnectionProps& props,
Address comments from review 1) Add debug messages 2) Fix bug of missing else in the code
2022-04-01 08:35:31 +02:00
DeferredLogger& deferred_logger);
adding wellEqIteration() to StandardWell the involvement of the group control in updateWellControls() makes the solution of well equations for each well individually more troublesome. As a result, we will still makes the solveWellEq in all the wells level.
2017-06-26 16:01:45 +02:00
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
void computeWellConnectionPressures(const Simulator& simulator,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
const WellState<Scalar>& well_state,
Address comments from review 1) Add debug messages 2) Fix bug of missing else in the code
2022-04-01 08:35:31 +02:00
DeferredLogger& deferred_logger);
removing two functions from WellInterface computeWellConnectionPressures() and computeAccumWell(). They belongs to the implementation details of well models now.
2017-09-05 11:20:43 +02:00
changed: unify StandardWell::computePerfRate(Eval|Scalar)
2023-05-07 21:56:09 +02:00
template<class Value>
void computePerfRate(const IntensiveQuantities& intQuants,
const std::vector<Value>& mob,
const Value& bhp,
only use d factor for gas wells
2023-11-14 12:45:25 +01:00
const std::vector<Scalar>& Tw,
changed: unify StandardWell::computePerfRate(Eval|Scalar)
2023-05-07 21:56:09 +02:00
const int perf,
const bool allow_cf,
std::vector<Value>& cq_s,
PerforationRates: template Scalar type
2024-02-20 14:18:30 +01:00
PerforationRates<Scalar>& perf_rates,
changed: unify StandardWell::computePerfRate(Eval|Scalar)
2023-05-07 21:56:09 +02:00
DeferredLogger& deferred_logger) const;
Add a derivative free version of the well rate calculations
2021-06-30 15:06:59 +02:00
template<class Value>
void computePerfRate(const std::vector<Value>& mob,
const Value& pressure,
const Value& bhp,
const Value& rs,
const Value& rv,
adjustments to account for vaporized water
2022-04-08 22:31:21 +02:00
const Value& rvw,
Support gas dissolution in water (Rsw) - adapt to interface change in waterPvt() - add gas + water + disgasw simulator Note - MSW is not supported - EQUIL initialization is not supported
2022-11-24 14:32:41 +01:00
const Value& rsw,
Add a derivative free version of the well rate calculations
2021-06-30 15:06:59 +02:00
std::vector<Value>& b_perfcells_dense,
only use d factor for gas wells
2023-11-14 12:45:25 +01:00
const std::vector<Scalar>& Tw,
cleaning StandardWell and StandardWellV to make them more comparable, so that we can do refactoring easier later.
2018-12-12 15:58:15 +01:00
const int perf,
addressing the first part of comments form PR#1680 there should be no functional change.
2018-12-13 13:29:59 +01:00
const bool allow_cf,
Add a derivative free version of the well rate calculations
2021-06-30 15:06:59 +02:00
const Value& skin_pressure,
const std::vector<Value>& cmix_s,
std::vector<Value>& cq_s,
PerforationRates: template Scalar type
2024-02-20 14:18:30 +01:00
PerforationRates<Scalar>& perf_rates,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 12:00:04 +02:00
DeferredLogger& deferred_logger) const;
computePerfRate and crossFlowAllowed protected in StandardWell
2017-08-21 16:40:10 +02:00
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
void computeWellRatesWithBhpIterations(const Simulator& ebosSimulator,
const Scalar& bhp,
std::vector<Scalar>& well_flux,
DeferredLogger& deferred_logger) const override;
adding computeWellPotentialWithTHP() to StandardWell it is not clear at the moment how all the well potentials related will work with MS wells. For the moment, keep the well poentials related only in StandardWell. By theory, they should be very similar, while some dependence on certain member variables makes some small refactoring work necessary.
2017-07-24 14:48:57 +02:00
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
std::vector<Scalar>
computeWellPotentialWithTHP(const Simulator& ebosSimulator,
DeferredLogger& deferred_logger,
const WellState<Scalar>& well_state) const;
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 13:07:16 +02:00
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
bool computeWellPotentialsImplicit(const Simulator& ebos_simulator,
std::vector<Scalar>& well_potentials,
revert changes
2023-10-26 17:28:05 +02:00
DeferredLogger& deferred_logger) const;
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
Scalar getRefDensity() const override;
Remove code duplication between STW and MSW
2021-04-26 09:31:29 +02:00
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 13:07:16 +02:00
// get the mobility for specific perforation
changed: unify StandardWell::getMobility(Eval|Scalar)
2023-05-07 21:56:09 +02:00
template<class Value>
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
void getMobility(const Simulator& simulator,
changed: unify StandardWell::getMobility(Eval|Scalar)
2023-05-07 21:56:09 +02:00
const int perf,
std::vector<Value>& mob,
DeferredLogger& deferred_logger) const;
Make 2p gas oil compile and runs -- use mapping from canonicalToActiveCompIdx from Ebos -- add guards againts non-existing components
2017-08-31 07:50:28 +02:00
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
void updateWaterMobilityWithPolymer(const Simulator& simulator,
moving polymer related to updateWaterMobilityWithPolymer in StandardWell. And not calculating the shear effect for the injecting wells when the injection wells do not inject polymer.
2017-11-23 16:10:37 +01:00
const int perf,
correct exception handling in wells for parallel runs
2019-02-07 14:43:17 +01:00
std::vector<EvalWell>& mob_water,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 12:00:04 +02:00
DeferredLogger& deferred_logger) const;
refactoring updateWellState in StandardWell to be two functions for other use.
2018-05-04 16:25:33 +02:00
void updatePrimaryVariablesNewton(const BVectorWell& dwells,
combining wellIsStopped and wellUnderZeroRateTaget for better readability.
2023-03-29 14:33:05 +02:00
const bool stop_or_zero_rate_target,
StandardWell: make updatePrimaryVariablesNewton non-const this will obviously modify well state
2022-11-09 13:06:11 +01:00
DeferredLogger& deferred_logger);
refactoring updateWellState in StandardWell to be two functions for other use.
2018-05-04 16:25:33 +02:00
In updateThp always compute thp when vfp is active
2024-09-26 21:06:05 +02:00
void updateWellStateFromPrimaryVariables(WellState<Scalar>& well_state,
Account for pressure loss also in thp
2023-05-09 23:44:05 +02:00
const SummaryState& summary_state,
not updating the THP for zero rate controlled wells
2023-03-28 15:22:50 +02:00
DeferredLogger& deferred_logger) const;
adding assembleControlEq to StandardWell solvent model needs to be handled for the injector control.
2018-05-09 12:16:33 +02:00
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
void assembleWellEqWithoutIteration(const Simulator& simulator,
const double dt,
const Well::InjectionControls& inj_controls,
const Well::ProductionControls& prod_controls,
WellState<Scalar>& well_state,
GroupState: template Scalar type
2024-02-17 18:13:46 +01:00
const GroupState<Scalar>& group_state,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
DeferredLogger& deferred_logger) override;
make assembleWellEqIteration private
2020-01-29 09:13:25 +01:00
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
void assembleWellEqWithoutIterationImpl(const Simulator& simulator,
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 11:11:00 +01:00
const double dt,
make sure computeWellRatesWithBhpIterations honor bhp limit for StandardWell
2023-03-01 16:47:11 +01:00
const Well::InjectionControls& inj_controls,
const Well::ProductionControls& prod_controls,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
WellState<Scalar>& well_state,
GroupState: template Scalar type
2024-02-17 18:13:46 +01:00
const GroupState<Scalar>& group_state,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 12:00:04 +02:00
DeferredLogger& deferred_logger);
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 11:11:00 +01:00
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
void calculateSinglePerf(const Simulator& simulator,
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 11:11:00 +01:00
const int perf,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
WellState<Scalar>& well_state,
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 11:11:00 +01:00
std::vector<RateVector>& connectionRates,
std::vector<EvalWell>& cq_s,
EvalWell& water_flux_s,
Rebase issue.
2020-11-17 14:50:57 +01:00
EvalWell& cq_s_zfrac_effective,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 12:00:04 +02:00
DeferredLogger& deferred_logger) const;
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 11:11:00 +01:00
adding function checkWellOperatability() to StandardWell it includes BHPLimit check, THPlimit check, and also to see whether if the well can produce/inject in the correct direction.
2018-11-15 14:31:41 +01:00
// check whether the well is operable under BHP limit with current reservoir condition
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
void checkOperabilityUnderBHPLimit(const WellState<Scalar>& well_state,
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
const Simulator& simulator,
DeferredLogger& deferred_logger) override;
adding function checkWellOperatability() to StandardWell it includes BHPLimit check, THPlimit check, and also to see whether if the well can produce/inject in the correct direction.
2018-11-15 14:31:41 +01:00
// check whether the well is operable under THP limit with current reservoir condition
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
void checkOperabilityUnderTHPLimit(const Simulator& simulator,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
const WellState<Scalar>& well_state,
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
DeferredLogger& deferred_logger) override;
Add check for operability of MSW
2020-11-27 07:57:55 +01:00
// updating the inflow based on the current reservoir condition
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
void updateIPR(const Simulator& simulator,
DeferredLogger& deferred_logger) const override;
adding function checkWellOperatability() to StandardWell it includes BHPLimit check, THPlimit check, and also to see whether if the well can produce/inject in the correct direction.
2018-11-15 14:31:41 +01:00
// for a well, when all drawdown are in the wrong direction, then this well will not
// be able to produce/inject .
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
bool allDrawDownWrongDirection(const Simulator& simulator) const;
we need to open the cross-flow to solve the sigularity if a well is banned from cross-flow. When it is under RATE control, its BHP might be initialized in way causing all the drawdown in the wrong direction. It will cause singular well equations. here, we open the croff-flow to fix the singularity and rely on Newton iteraton to get desired result. possible alternative approach is to adust the BHP to avoid the situation that all the drawdown are in the wrong direction.
2018-11-17 23:39:09 +01:00
adding canProduceInjectWithCurrentBhp to StandardWell and use it the operability_status determination.
2018-11-22 07:02:29 +01:00
// whether the well can produce / inject based on the current well state (bhp)
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
bool canProduceInjectWithCurrentBhp(const Simulator& simulator,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
const WellState<Scalar>& well_state,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 12:00:04 +02:00
DeferredLogger& deferred_logger);
adding canProduceInjectWithCurrentBhp to StandardWell and use it the operability_status determination.
2018-11-22 07:02:29 +01:00
we need to open the cross-flow to solve the sigularity if a well is banned from cross-flow. When it is under RATE control, its BHP might be initialized in way causing all the drawdown in the wrong direction. It will cause singular well equations. here, we open the croff-flow to fix the singularity and rely on Newton iteraton to get desired result. possible alternative approach is to adust the BHP to avoid the situation that all the drawdown are in the wrong direction.
2018-11-17 23:39:09 +01:00
// turn on crossflow to avoid singular well equations
// when the well is banned from cross-flow and the BHP is not properly initialized,
fixing comments from review of PR#1648 there should be no functional change
2018-11-20 13:49:11 +01:00
// we turn on crossflow to avoid singular well equations. It can result in wrong-signed
we need to open the cross-flow to solve the sigularity if a well is banned from cross-flow. When it is under RATE control, its BHP might be initialized in way causing all the drawdown in the wrong direction. It will cause singular well equations. here, we open the croff-flow to fix the singularity and rely on Newton iteraton to get desired result. possible alternative approach is to adust the BHP to avoid the situation that all the drawdown are in the wrong direction.
2018-11-17 23:39:09 +01:00
// well rates, it can cause problem for THP calculation
// TODO: looking for better alternative to avoid wrong-signed well rates
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
bool openCrossFlowAvoidSingularity(const Simulator& simulator) const;
adding function checkWellOperatability() to StandardWell it includes BHPLimit check, THPlimit check, and also to see whether if the well can produce/inject in the correct direction.
2018-11-15 14:31:41 +01:00
removing StandardWellV
2019-03-25 12:52:34 +01:00
// calculate the skin pressure based on water velocity, throughput and polymer concentration.
// throughput is used to describe the formation damage during water/polymer injection.
// calculated skin pressure will be applied to the drawdown during perforation rate calculation
// to handle the effect from formation damage.
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
EvalWell pskin(const Scalar throughput,
removing StandardWellV
2019-03-25 12:52:34 +01:00
const EvalWell& water_velocity,
const EvalWell& poly_inj_conc,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 12:00:04 +02:00
DeferredLogger& deferred_logger) const;
removing StandardWellV
2019-03-25 12:52:34 +01:00
// calculate the skin pressure based on water velocity, throughput during water injection.
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
EvalWell pskinwater(const Scalar throughput,
removing StandardWellV
2019-03-25 12:52:34 +01:00
const EvalWell& water_velocity,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 12:00:04 +02:00
DeferredLogger& deferred_logger) const;
removing StandardWellV
2019-03-25 12:52:34 +01:00
// calculate the injecting polymer molecular weight based on the througput and water velocity
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
EvalWell wpolymermw(const Scalar throughput,
removing StandardWellV
2019-03-25 12:52:34 +01:00
const EvalWell& water_velocity,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 12:00:04 +02:00
DeferredLogger& deferred_logger) const;
removing StandardWellV
2019-03-25 12:52:34 +01:00
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 11:11:00 +01:00
// modify the water rate for polymer injectivity study
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
void handleInjectivityRate(const Simulator& simulator,
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 11:11:00 +01:00
const int perf,
std::vector<EvalWell>& cq_s) const;
removing StandardWellV
2019-03-25 12:52:34 +01:00
// handle the extra equations for polymer injectivity study
StandardWell: rename ebosSimulator to simulator
2024-03-07 10:11:26 +01:00
void handleInjectivityEquations(const Simulator& simulator,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
const WellState<Scalar>& well_state,
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 11:11:00 +01:00
const int perf,
const EvalWell& water_flux_s,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 12:00:04 +02:00
DeferredLogger& deferred_logger);
finish the injecivity functionality the result looks okay
2018-11-30 12:15:51 +01:00
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
void updateWaterThroughput(const double dt,
WellState<Scalar>& well_state) const override;
adding function checkConvergenceControlEq to refactor getWellConvergence only functional change is that rate control or BHP control has different tolerance for MSW now.
2019-05-09 13:12:32 +02:00
adding checkConvergenceExtraEqs to StandardWell
2019-06-06 11:12:22 +02:00
// checking convergence of extra equations, if there are any
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
void checkConvergenceExtraEqs(const std::vector<Scalar>& res,
fixing warnings under simulator/wells
2019-06-25 21:53:37 +02:00
ConvergenceReport& report) const;
adding checkConvergenceExtraEqs to StandardWell
2019-06-06 11:12:22 +02:00
adding updateConnectionRatePolyMW to StandardWell
2019-06-06 11:47:59 +02:00
// updating the connectionRates_ related polymer molecular weight
void updateConnectionRatePolyMW(const EvalWell& cq_s_poly,
const IntensiveQuantities& int_quants,
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
const WellState<Scalar>& well_state,
adding updateConnectionRatePolyMW to StandardWell
2019-06-06 11:47:59 +02:00
const int perf,
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 11:11:00 +01:00
std::vector<RateVector>& connectionRates,
DeferredLogger& deferred_logger) const;
adding updateConnectionRatePolyMW to StandardWell
2019-06-06 11:47:59 +02:00
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
std::optional<Scalar>
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
computeBhpAtThpLimitProd(const WellState<Scalar>& well_state,
const Simulator& simulator,
const SummaryState& summary_state,
DeferredLogger& deferred_logger) const;
add computeBhpAtThpLimitInj
2019-11-05 13:31:59 +01:00
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
std::optional<Scalar>
WellState: template Scalar type
2024-02-17 18:13:46 +01:00
computeBhpAtThpLimitInj(const Simulator& simulator,
const SummaryState& summary_state,
DeferredLogger& deferred_logger) const;
add computeBhpAtThpLimitInj
2019-11-05 13:31:59 +01:00
changed: put calculation of brine connection rate in separate method
2023-05-05 09:55:26 +02:00
private:
StandardWell: use Scalar type
2024-02-20 13:26:39 +01:00
Eval connectionRateEnergy(const Scalar maxOilSaturation,
changed: put calculation of energy connection rate in separate method
2023-05-05 09:55:26 +02:00
const std::vector<EvalWell>& cq_s,
const IntensiveQuantities& intQuants,
DeferredLogger& deferred_logger) const;
changed: put calculation of injection gas-oil perf rates in separate method
2023-05-05 09:55:26 +02:00
template<class Value>
void gasOilPerfRateInj(const std::vector<Value>& cq_s,
PerforationRates: template Scalar type
2024-02-20 14:18:30 +01:00
PerforationRates<Scalar>& perf_rates,
changed: put calculation of injection gas-oil perf rates in separate method
2023-05-05 09:55:26 +02:00
const Value& rv,
const Value& rs,
const Value& pressure,
const Value& rvw,
DeferredLogger& deferred_logger) const;
changed: put calculation of production gas-oil perf rates in separate method
2023-05-05 09:55:26 +02:00
template<class Value>
void gasOilPerfRateProd(std::vector<Value>& cq_s,
PerforationRates: template Scalar type
2024-02-20 14:18:30 +01:00
PerforationRates<Scalar>& perf_rates,
changed: put calculation of production gas-oil perf rates in separate method
2023-05-05 09:55:26 +02:00
const Value& rv,
const Value& rs,
const Value& rvw) const;
changed: put calculation of production gas-water perf rates in separate method
2023-05-05 09:55:26 +02:00
template<class Value>
void gasWaterPerfRateProd(std::vector<Value>& cq_s,
PerforationRates: template Scalar type
2024-02-20 14:18:30 +01:00
PerforationRates<Scalar>& perf_rates,
changed: put calculation of production gas-water perf rates in separate method
2023-05-05 09:55:26 +02:00
const Value& rvw,
const Value& rsw) const;
changed: put calculation of injection gas-water perf rates in separate method
2023-05-05 09:55:26 +02:00
template<class Value>
void gasWaterPerfRateInj(const std::vector<Value>& cq_s,
PerforationRates: template Scalar type
2024-02-20 14:18:30 +01:00
PerforationRates<Scalar>& perf_rates,
changed: put calculation of injection gas-water perf rates in separate method
2023-05-05 09:55:26 +02:00
const Value& rvw,
const Value& rsw,
const Value& pressure,
DeferredLogger& deferred_logger) const;
changed: put calculation of vaporized and dissolved water volume ratio in separate method
2023-05-05 14:22:56 +02:00
template<class Value>
void disOilVapWatVolumeRatio(Value& volumeRatio,
const Value& rvw,
const Value& rsw,
const Value& pressure,
const std::vector<Value>& cmix_s,
const std::vector<Value>& b_perfcells_dense,
DeferredLogger& deferred_logger) const;
changed: put calculation of gas-oil volume ratio in separate method
2023-05-05 14:22:56 +02:00
template<class Value>
void gasOilVolumeRatio(Value& volumeRatio,
const Value& rv,
const Value& rs,
const Value& pressure,
const std::vector<Value>& cmix_s,
const std::vector<Value>& b_perfcells_dense,
DeferredLogger& deferred_logger) const;
adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 11:41:03 +02:00
};
}
StandardWell: improve IDE experience
2024-02-23 08:45:25 +01:00
#ifndef OPM_STANDARDWELL_IMPL_HEADER_INCLUDED
makding the StandardWell and WellInterface templated with the template parameter TypeTag.
2017-06-19 14:49:49 +02:00
#include "StandardWell_impl.hpp"
StandardWell: improve IDE experience
2024-02-23 08:45:25 +01:00
#endif
makding the StandardWell and WellInterface templated with the template parameter TypeTag.
2017-06-19 14:49:49 +02:00
adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 11:41:03 +02:00
#endif // OPM_STANDARDWELL_HEADER_INCLUDED
Reference in New Issue Copy Permalink