OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2024-12-25 00:40:02 -06:00
Code Issues Packages Projects Releases Wiki Activity
f5b44ad26d
opm-simulators/opm/simulators/wells/StandardWell.hpp

467 lines
23 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 04:41:03 -05:00
/*
adding the copyright information.
2017-08-03 09:45:59 -05: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 04:41:03 -05:00
Copyright 2017 Statoil ASA.
adding the copyright information.
2017-08-03 09:45:59 -05: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 04:41:03 -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/>.
*/
#ifndef OPM_STANDARDWELL_HEADER_INCLUDED
#define OPM_STANDARDWELL_HEADER_INCLUDED
changed: (re)move unnecessary includes
2021-05-12 01:47:22 -05:00
#include <opm/simulators/timestepping/ConvergenceReport.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>
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 06:59:26 -06:00
#include <opm/simulators/wells/VFPInjProperties.hpp>
#include <opm/simulators/wells/VFPProdProperties.hpp>
Moved files to opm/simulators/ subdirs.
2019-05-07 06:06:02 -05: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 06:38:33 -05: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 08:09:28 -05: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 04:41:03 -05:00
changed: ewoms/models/blackoil -> opm/models/blackoil
2019-09-16 04:22:14 -05:00
#include <opm/models/blackoil/blackoilpolymermodules.hh>
#include <opm/models/blackoil/blackoilsolventmodules.hh>
Alternative solvent extension for the black oil model.
2020-10-10 09:20:25 -05:00
#include <opm/models/blackoil/blackoilextbomodules.hh>
changed: ewoms/models/blackoil -> opm/models/blackoil
2019-09-16 04:22:14 -05:00
#include <opm/models/blackoil/blackoilfoammodules.hh>
renamed saltwater-->brine and removed keywords from missingFeatures
2019-12-03 10:48:17 -06:00
#include <opm/models/blackoil/blackoilbrinemodules.hh>
first version of micp implementation in flow
2021-10-06 12:32:35 -05:00
#include <opm/models/blackoil/blackoilmicpmodules.hh>
Finalize integration of foam module.
2019-07-04 02:50:08 -05:00
always include Evaluation.hpp even if we are using the dynamic specialization
2022-12-23 06:31:41 -06:00
#include <opm/material/densead/Evaluation.hpp>
Downstream filesystem reorganisation in opm-common
2021-12-14 01:30:15 -06:00
#include <opm/input/eclipse/Schedule/ScheduleTypes.hpp>
removing StandardWellV
2019-03-25 06:52:34 -05:00
add StandardWellEval
2021-06-01 08:49:24 -05:00
#include <opm/simulators/wells/StandardWellEval.hpp>
removing StandardWellV
2019-03-25 06:52:34 -05: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 06:59:26 -06:00
#include <memory>
replace boost::optional with std::optional
2020-02-19 04:02:13 -06:00
#include <optional>
Add robustSolveBhpAtThpLimitProd() method.
2019-10-02 04:16:52 -05:00
adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 04:41:03 -05:00
namespace Opm
{
makding the StandardWell and WellInterface templated with the template parameter TypeTag.
2017-06-19 07:49:49 -05: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 08:34:14 -05:00
class StandardWell : public WellInterface<TypeTag>
add StandardWellEval
2021-06-01 08:49:24 -05:00
, public StandardWellEval<GetPropType<TypeTag, Properties::FluidSystem>,
GetPropType<TypeTag, Properties::Indices>,
GetPropType<TypeTag, Properties::Scalar>>
adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 04:41:03 -05:00
{
public:
remove unnecessary <Runspec.hpp> includes
2023-01-05 05:36:46 -06:00
using Base = WellInterface<TypeTag>;
add StandardWellEval
2021-06-01 08:49:24 -05:00
using StdWellEval = StandardWellEval<GetPropType<TypeTag, Properties::FluidSystem>,
GetPropType<TypeTag, Properties::Indices>,
GetPropType<TypeTag, Properties::Scalar>>;
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
adding function computeAccumWell and computeWellConnectionPressures to StandardWell and removing a few not needed function from StandardWellsDense
2017-06-29 06:52:31 -05: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 09:19:27 -05: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 02:14:08 -06:00
using typename Base::Indices;
Move Rateconverter and pvtIdx to the wellInterface
2017-11-23 01:37:30 -06:00
using typename Base::RateConverterType;
[cleanup][Wells] Consequently use SparseMatrixAdapter in addWellContributions.
2019-10-02 05:48:29 -05:00
using typename Base::SparseMatrixAdapter;
Enable single-phase runs.
2019-10-09 08:24:23 -05:00
using typename Base::FluidState;
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 04:11:00 -06:00
using typename Base::RateVector;
handing the numComponents in WellInterface
2017-06-19 09:46:06 -05: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 03:50:33 -05:00
using Base::has_solvent;
Alternative solvent extension for the black oil model.
2020-10-10 09:20:25 -05: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 03:50:33 -05:00
using Base::has_polymer;
add StandardWellEval
2021-06-01 08:49:24 -05:00
using Base::has_polymermw;
Use foam module.
2019-04-26 03:38:37 -05:00
using Base::has_foam;
renamed saltwater-->brine and removed keywords from missingFeatures
2019-12-03 10:48:17 -06: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 03:50:33 -05:00
using Base::has_energy;
first version of micp implementation in flow
2021-10-06 12:32:35 -05: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 03:50:33 -05:00
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
using PolymerModule = BlackOilPolymerModule<TypeTag>;
using FoamModule = BlackOilFoamModule<TypeTag>;
using BrineModule = BlackOilBrineModule<TypeTag>;
Use MatrixBlock consistently, also whitespace cleanup.
2022-06-10 04:08:24 -05:00
using typename Base::PressureMatrix;
Finalize integration of foam module.
2019-07-04 02:50:08 -05: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 03:57:08 -05: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 05:47:21 -05: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 03:57:08 -05: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 05:47:21 -05: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 08:58:15 -06: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 05:47:21 -05:00
static constexpr int numStaticWellEq = numWellConservationEq + numWellControlEq;
small bug fixes.
2018-05-09 08:07:43 -05: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 07:21:53 -05: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 05:47:21 -05: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 08:58:15 -06:00
StandardWellPrimaryVariables: make data members private and add generic read-only accessors
2022-11-09 05:26:46 -06:00
using StdWellEval::WQTotal;
using Base to represent WellInterface<TypeTag> for better readability.
2017-08-02 09:19:27 -05: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 07:49:30 -05:00
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 06:07:16 -05:00
using well name and allow_cf form well_ecl.
2017-08-21 04:26:21 -05: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 06:57:36 -06:00
using Base::Water;
using Base::Oil;
using Base::Gas;
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 06:07:16 -05:00
using Base to represent WellInterface<TypeTag> for better readability.
2017-08-02 09:19:27 -05:00
using typename Base::BVector;
more or less getting the old implementation in and compile now.
2017-06-15 10:19:49 -05:00
add StandardWellEval
2021-06-01 08:49:24 -05: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 08:14:36 -05: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 08:09:28 -05:00
StandardWell(const Well& well,
const ParallelWellInfo& pw_info,
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 07:39:42 -06:00
const ModelParameters& param,
const RateConverterType& rate_converter,
removing numComponents() from WellInterface which is dumplicated from BlackoilWellModel.
2017-11-30 09:31:48 -06:00
const int pvtRegionIdx,
Avoid using the Wells struct.
2019-10-23 02:09:45 -05:00
const int num_components,
const int num_phases,
const int index_of_well,
const std::vector<PerforationData>& perf_data);
adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 04:41:03 -05:00
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 06:07:16 -05:00
virtual void init(const PhaseUsage* phase_usage_arg,
const std::vector<double>& depth_arg,
const double gravity_arg,
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
const int num_cells,
dont use explicit vfp lookup for newly opened wells
2022-04-12 01:44:52 -05:00
const std::vector< Scalar >& B_avg,
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 04:41:03 -05:00
WellInterface: make initPrimaryVariablesEvaluation non-const this will obviously modify well state
2022-11-09 06:01:30 -06: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 08:24:49 -05:00
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 06:07:16 -05:00
/// check whether the well equations get converged for this well
stricter tolerance for wells with zero rate target for StandardWell only at this moment.
2023-03-30 08:49:27 -05:00
virtual ConvergenceReport getWellConvergence(const SummaryState& summary_state,
const WellState& well_state,
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
const std::vector<double>& B_avg,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
DeferredLogger& deferred_logger,
stricter tolerance for wells with zero rate target for StandardWell only at this moment.
2023-03-30 08:49:27 -05:00
const bool relax_tolerance) const override;
adding getWellConvergence for StandardWell
2017-06-26 07:35:43 -05:00
adding a test for well model. It is just test for StandardWell.
2017-08-22 10:14:52 -05:00
/// Ax = Ax - C D^-1 B x
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05: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 10:14:52 -05:00
/// r = r - C D^-1 Rw
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05: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 07:21:17 -05:00
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 06:07:16 -05:00
/// using the solution x to recover the solution xw for wells and applying
/// xw to update 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 09:10:00 -05:00
void recoverWellSolutionAndUpdateWellState(const SummaryState& summary_state,
const BVector& x,
WellInterface: make recoverWellSolutionAndUpdateWellState non-const this will obviously modify well state
2022-11-09 06:01:30 -06:00
WellState& well_state,
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 08:30:34 -05:00
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 06:07:16 -05:00
/// computing the well potentials for group control
adding function computeWellPotentials to StandardWell for some similar reasons, this function stays in StandardWell for now. Eventually, it should go to WellInterface with some refactoring work.
2017-07-24 08:09:44 -05:00
virtual void computeWellPotentials(const Simulator& ebosSimulator,
const WellState& well_state,
Correct Logging for Black Oil Well Model for parallel runs using DeferredLogger
2019-02-03 01:13:11 -06:00
std::vector<double>& well_potentials,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05: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 10:49:35 -05:00
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 09:10:00 -05:00
void updatePrimaryVariables(const SummaryState& summary_state,
const WellState& well_state,
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 10:49:35 -05:00
fixing the comilation from the reverted commit the interface has changed.
2023-04-21 03:17:03 -05:00
virtual void solveEqAndUpdateWellState(const SummaryState& summary_state,
WellState& well_state,
DeferredLogger& deferred_logger) override;
adding a function calculateExplictQuantities to WellInterface to hide some implementation details.
2017-09-05 04:09:58 -05:00
removing two functions from WellInterface computeWellConnectionPressures() and computeAccumWell(). They belongs to the implementation details of well models now.
2017-09-05 04:20:43 -05:00
virtual void calculateExplicitQuantities(const Simulator& ebosSimulator,
correct exception handling in wells for parallel runs
2019-02-07 07:43:17 -06:00
const WellState& well_state,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
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 05:23:20 -06: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
virtual void updateProductivityIndex(const Simulator& ebosSimulator,
const WellProdIndexCalculator& wellPICalc,
WellState& well_state,
DeferredLogger& deferred_logger) 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 08:18:23 -06:00
virtual void addWellContributions(SparseMatrixAdapter& mat) const override;
Changes to make ms wells work with cprw
2022-04-28 02:32:07 -05:00
virtual void addWellPressureEquations(PressureMatrix& mat,
const BVector& x,
const int pressureVarIndex,
const bool use_well_weights,
const WellState& 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 05:23:20 -06:00
renaming solveWellEqUntilConverged to be iterateWellEquations
2020-06-02 07:54:45 -05:00
// iterate well equations with the specified control until converged
bool iterateWellEqWithControl(const Simulator& ebosSimulator,
const double dt,
const Well::InjectionControls& inj_controls,
const Well::ProductionControls& prod_controls,
WellState& well_state,
Extract group state and create WGState to manage well & group state
2021-04-22 10:31:21 -05:00
const GroupState& group_state,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
DeferredLogger& deferred_logger) override;
renaming solveWellEqUntilConverged to be iterateWellEquations
2020-06-02 07:54:45 -05: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 05:23:20 -06:00
/// \brief Wether the Jacobian will also have well contributions in it.
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -05:00
virtual 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 05:23:20 -06:00
{
drop using statement for param_ rather qualify member variable with this->
2021-09-06 05:58:16 -05: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 05:23:20 -06:00
}
flow: let the wells be managed by EclProblem
2018-08-16 04:51:36 -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
/* returns BHP */
double computeWellRatesAndBhpWithThpAlqProd(const Simulator &ebos_simulator,
const SummaryState &summary_state,
DeferredLogger &deferred_logger,
std::vector<double> &potentials,
double alq) const;
void computeWellRatesWithThpAlqProd(
const Simulator &ebos_simulator,
const SummaryState &summary_state,
DeferredLogger &deferred_logger,
std::vector<double> &potentials,
double alq) const;
changed: tidy up computeBhpAtThpLimitProdWithAlq interface put deferred_logger at the end of the parameter list. similar to the rest of this family of methods
2022-10-19 05:23:02 -05:00
std::optional<double> computeBhpAtThpLimitProdWithAlq(
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
const Simulator& ebos_simulator,
const SummaryState& summary_state,
changed: tidy up computeBhpAtThpLimitProdWithAlq interface put deferred_logger at the end of the parameter list. similar to the rest of this family of methods
2022-10-19 05:23:02 -05:00
const double alq_value,
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 03:04:39 -05:00
Add gaslift optimization support for MSW. Implements gas lift optimization support for multisegmented wells (MSW).
2022-02-07 04:28:35 -06:00
virtual void computeWellRatesWithBhp(
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
const Simulator& ebosSimulator,
const double& bhp,
std::vector<double>& well_flux,
Add gaslift optimization support for MSW. Implements gas lift optimization support for multisegmented wells (MSW).
2022-02-07 04:28:35 -06: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 03:04:39 -05:00
// NOTE: These cannot be protected since they are used by GasLiftRuntime
using Base::phaseUsage;
using Base::vfp_properties_;
Refactor to put updateWellStateRates() in base class.
2020-10-15 07:15:05 -05:00
virtual std::vector<double> computeCurrentWellRates(const Simulator& ebosSimulator,
DeferredLogger& deferred_logger) const override;
Implement extended network model.
2020-05-15 04:21:32 -05: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 11:33:07 -05:00
void computeConnLevelProdInd(const FluidState& fs,
PI/II: Switch to Using Values Only We don't need to do the calculations in terms of EvalWell when we're going to reduce this to the .value() before calling the PI/II calculation routine. We can also get by with a simpler approach to computing the II by assuming we always inject pure phases and no cross flow in injectors. Suggested by: [at]atgeirr
2020-11-06 14:13:10 -06:00
const std::function<double(const double)>& connPICalc,
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 11:33:07 -05:00
const std::vector<EvalWell>& mobility,
double* connPI) const;
PI/II: Switch to Using Values Only We don't need to do the calculations in terms of EvalWell when we're going to reduce this to the .value() before calling the PI/II calculation routine. We can also get by with a simpler approach to computing the II by assuming we always inject pure phases and no cross flow in injectors. Suggested by: [at]atgeirr
2020-11-06 14:13:10 -06:00
void computeConnLevelInjInd(const typename StandardWell<TypeTag>::FluidState& fs,
const Phase preferred_phase,
const std::function<double(const double)>& connIICalc,
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 11:33:07 -05:00
const std::vector<EvalWell>& mobility,
double* connII,
DeferredLogger& deferred_logger) const;
WIP in cleaning up the interfaces of WellInterface and StandardWell commiting now to save some changes.
2017-08-04 04:20:55 -05:00
add useInnerIteration method and move assembleWellEq to the well interface to avoid code duplication
2021-05-10 02:41:18 -05: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 11:33:07 -05:00
protected:
regularize equation for std wells
2022-06-23 08:14:36 -05:00
bool regularize_;
renaming a few functions to reflect the functions better. No functional change.
2017-08-21 07:16:24 -05:00
// updating the well_state based on well solution dwells
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 09:10:00 -05:00
void updateWellState(const SummaryState& summary_state,
const BVectorWell& dwells,
correct exception handling in wells for parallel runs
2019-02-07 07:43:17 -06:00
WellState& well_state,
StandardWell: make updateWellState non-const this will obviously modify well state
2022-11-09 06:05:40 -06:00
DeferredLogger& deferred_logger);
renaming a few functions to reflect the functions better. No functional change.
2017-08-21 07:16:24 -05:00
adding computePropertiesForWellConnectionPressures to StandardWell
2017-06-23 07:55:56 -05:00
// calculate the properties for the well connections
// to calulate the pressure difference between well connections.
changed: simplify WellConnectionPressure calculation by passing a struct
2023-05-04 07:27:49 -05:00
using WellConnectionProps = typename StdWellEval::StdWellConnections::Properties;
adding computePropertiesForWellConnectionPressures to StandardWell
2017-06-23 07:55:56 -05:00
void computePropertiesForWellConnectionPressures(const Simulator& ebosSimulator,
removing the current argument in updateWellStateWithTarget and some other cleaning up.
2017-11-30 10:14:29 -06:00
const WellState& well_state,
changed: simplify WellConnectionPressure calculation by passing a struct
2023-05-04 07:27:49 -05:00
WellConnectionProps& props) 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 08:54:05 -05:00
Initialize empty producers using the mobility ratio and the transmissbility ratio
2021-04-20 08:42:27 -05:00
void computeWellConnectionDensitesPressures(const Simulator& ebosSimulator,
const WellState& well_state,
changed: simplify WellConnectionPressure calculation by passing a struct
2023-05-04 07:27:49 -05:00
const WellConnectionProps& props,
Address comments from review 1) Add debug messages 2) Fix bug of missing else in the code
2022-04-01 01:35:31 -05: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 09:01:45 -05:00
removing two functions from WellInterface computeWellConnectionPressures() and computeAccumWell(). They belongs to the implementation details of well models now.
2017-09-05 04:20:43 -05:00
void computeWellConnectionPressures(const Simulator& ebosSimulator,
Address comments from review 1) Add debug messages 2) Fix bug of missing else in the code
2022-04-01 01:35:31 -05:00
const WellState& well_state,
DeferredLogger& deferred_logger);
removing two functions from WellInterface computeWellConnectionPressures() and computeAccumWell(). They belongs to the implementation details of well models now.
2017-09-05 04:20:43 -05:00
Add a derivative free version of the well rate calculations
2021-06-30 08:06:59 -05:00
void computePerfRateEval(const IntensiveQuantities& intQuants,
const std::vector<EvalWell>& mob,
const EvalWell& bhp,
const double Tw,
const int perf,
const bool allow_cf,
std::vector<EvalWell>& cq_s,
changed: simplify computePerfRate signatures pass a PerforationRates ref instead of multiple references to doubles
2023-05-04 06:02:17 -05:00
PerforationRates& perf_rates,
Add a derivative free version of the well rate calculations
2021-06-30 08:06:59 -05:00
DeferredLogger& deferred_logger) const;
void computePerfRateScalar(const IntensiveQuantities& intQuants,
const std::vector<Scalar>& mob,
const Scalar& bhp,
const double Tw,
const int perf,
const bool allow_cf,
std::vector<Scalar>& cq_s,
DeferredLogger& deferred_logger) const;
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 15:31:21 -05: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 07:32:41 -06:00
const Value& rsw,
Add a derivative free version of the well rate calculations
2021-06-30 08:06:59 -05:00
std::vector<Value>& b_perfcells_dense,
Add support for water induced compaction using ROCKCOMP, ROCK2D, ROCK2DTR, ROCKWNOD and OVERBURD
2019-03-12 09:51:41 -05:00
const double Tw,
cleaning StandardWell and StandardWellV to make them more comparable, so that we can do refactoring easier later.
2018-12-12 08:58:15 -06:00
const int perf,
addressing the first part of comments form PR#1680 there should be no functional change.
2018-12-13 06:29:59 -06:00
const bool allow_cf,
Add a derivative free version of the well rate calculations
2021-06-30 08:06:59 -05:00
const Value& skin_pressure,
const std::vector<Value>& cmix_s,
std::vector<Value>& cq_s,
changed: simplify computePerfRate signatures pass a PerforationRates ref instead of multiple references to doubles
2023-05-04 06:02:17 -05:00
PerforationRates& perf_rates,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
DeferredLogger& deferred_logger) const;
computePerfRate and crossFlowAllowed protected in StandardWell
2017-08-21 09:40:10 -05:00
rename computeBhpFromThpPotential to computeBhpFromThpIterations in std wells
2021-09-13 07:07:21 -05:00
void computeWellRatesWithBhpIterations(const Simulator& ebosSimulator,
Address PR comments
2019-05-24 09:45:27 -05:00
const double& bhp,
std::vector<double>& well_flux,
iterate to get more accurate potentials for stw wells
2021-06-30 06:46:47 -05:00
DeferredLogger& deferred_logger) const;
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 07:48:57 -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
std::vector<double> computeWellPotentialWithTHP(
const Simulator& ebosSimulator,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
DeferredLogger& deferred_logger,
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
const WellState &well_state) const;
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 06:07:16 -05:00
update well state when switching to THP control for producers hopefully, it begins at a reasonably good initial point. When the Newton iteration begins with certian solution region, the nonlinear solution might fail.
2023-01-30 05:41:45 -06:00
bool updateWellStateWithTHPTargetProd(const Simulator& ebos_simulator,
WellState& well_state,
Fix a few warnings in recently added code.
2023-02-14 08:46:08 -06:00
DeferredLogger& deferred_logger) const override;
adding functions to calcuate between thp and bhp to reduce some code duplication in StandardWell
2017-08-11 04:10:59 -05:00
Remove code duplication between STW and MSW
2021-04-26 02:31:29 -05:00
virtual double getRefDensity() const override;
more cleaning up of the interface of WellInterface and StandardWell
2017-08-04 06:07:16 -05:00
// get the mobility for specific perforation
changed: unify StandardWell::getMobility(Eval|Scalar)
2023-05-07 14:56:09 -05:00
template<class Value>
void getMobility(const Simulator& ebosSimulator,
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 00:50:28 -05:00
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 09:10:37 -06:00
void updateWaterMobilityWithPolymer(const Simulator& ebos_simulator,
const int perf,
correct exception handling in wells for parallel runs
2019-02-07 07:43:17 -06:00
std::vector<EvalWell>& mob_water,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
DeferredLogger& deferred_logger) const;
refactoring updateWellState in StandardWell to be two functions for other use.
2018-05-04 09:25:33 -05:00
void updatePrimaryVariablesNewton(const BVectorWell& dwells,
combining wellIsStopped and wellUnderZeroRateTaget for better readability.
2023-03-29 07:33:05 -05:00
const bool stop_or_zero_rate_target,
StandardWell: make updatePrimaryVariablesNewton non-const this will obviously modify well state
2022-11-09 06:06:11 -06:00
DeferredLogger& deferred_logger);
refactoring updateWellState in StandardWell to be two functions for other use.
2018-05-04 09:25:33 -05:00
combining wellIsStopped and wellUnderZeroRateTaget for better readability.
2023-03-29 07:33:05 -05:00
void updateWellStateFromPrimaryVariables(const bool stop_or_zero_rate_target,
not updating the THP for zero rate controlled wells
2023-03-28 08:22:50 -05:00
WellState& well_state,
DeferredLogger& deferred_logger) const;
adding assembleControlEq to StandardWell solvent model needs to be handled for the injector control.
2018-05-09 05:16:33 -05:00
make assembleWellEqIteration private
2020-01-29 02:13:25 -06:00
virtual void assembleWellEqWithoutIteration(const Simulator& ebosSimulator,
const double dt,
const Well::InjectionControls& inj_controls,
const Well::ProductionControls& prod_controls,
WellState& well_state,
Extract group state and create WGState to manage well & group state
2021-04-22 10:31:21 -05:00
const GroupState& group_state,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
DeferredLogger& deferred_logger) override;
make assembleWellEqIteration private
2020-01-29 02:13:25 -06:00
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 04:11:00 -06:00
void assembleWellEqWithoutIterationImpl(const Simulator& ebosSimulator,
const double dt,
make sure computeWellRatesWithBhpIterations honor bhp limit for StandardWell
2023-03-01 09:47:11 -06:00
const Well::InjectionControls& inj_controls,
const Well::ProductionControls& prod_controls,
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 04:11:00 -06:00
WellState& well_state,
Extract group state and create WGState to manage well & group state
2021-04-22 10:31:21 -05:00
const GroupState& group_state,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
DeferredLogger& deferred_logger);
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 04:11:00 -06:00
void calculateSinglePerf(const Simulator& ebosSimulator,
const int perf,
WellState& well_state,
std::vector<RateVector>& connectionRates,
std::vector<EvalWell>& cq_s,
EvalWell& water_flux_s,
Rebase issue.
2020-11-17 07:50:57 -06:00
EvalWell& cq_s_zfrac_effective,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
DeferredLogger& deferred_logger) const;
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 04:11:00 -06: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 07:31:41 -06:00
// check whether the well is operable under BHP limit with current reservoir condition
check operability injectors
2021-10-01 06:47:53 -05:00
virtual void checkOperabilityUnderBHPLimit(const WellState& well_state, const Simulator& ebos_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 07:31:41 -06:00
// check whether the well is operable under THP limit with current reservoir condition
check operability injectors
2021-10-01 06:47:53 -05:00
virtual void checkOperabilityUnderTHPLimit(const Simulator& ebos_simulator, const WellState& well_state, DeferredLogger& deferred_logger) override;
Add check for operability of MSW
2020-11-27 00:57:55 -06:00
// updating the inflow based on the current reservoir condition
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
virtual void updateIPR(const Simulator& ebos_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 07:31:41 -06:00
// for a well, when all drawdown are in the wrong direction, then this well will not
// be able to produce/inject .
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 16:39:09 -06:00
bool allDrawDownWrongDirection(const Simulator& ebos_simulator) const;
adding canProduceInjectWithCurrentBhp to StandardWell and use it the operability_status determination.
2018-11-22 00:02:29 -06:00
// whether the well can produce / inject based on the current well state (bhp)
bool canProduceInjectWithCurrentBhp(const Simulator& ebos_simulator,
Correct Logging for Black Oil Well Model for parallel runs using DeferredLogger
2019-02-03 01:13:11 -06:00
const WellState& well_state,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
DeferredLogger& deferred_logger);
adding canProduceInjectWithCurrentBhp to StandardWell and use it the operability_status determination.
2018-11-22 00:02:29 -06: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 16:39:09 -06: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 06:49:11 -06: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 16:39:09 -06:00
// well rates, it can cause problem for THP calculation
// TODO: looking for better alternative to avoid wrong-signed well rates
bool openCrossFlowAvoidSingularity(const Simulator& ebos_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 07:31:41 -06:00
removing StandardWellV
2019-03-25 06:52:34 -05: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.
EvalWell pskin(const double throuhgput,
const EvalWell& water_velocity,
const EvalWell& poly_inj_conc,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
DeferredLogger& deferred_logger) const;
removing StandardWellV
2019-03-25 06:52:34 -05:00
// calculate the skin pressure based on water velocity, throughput during water injection.
EvalWell pskinwater(const double throughput,
const EvalWell& water_velocity,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
DeferredLogger& deferred_logger) const;
removing StandardWellV
2019-03-25 06:52:34 -05:00
// calculate the injecting polymer molecular weight based on the througput and water velocity
EvalWell wpolymermw(const double throughput,
const EvalWell& water_velocity,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
DeferredLogger& deferred_logger) const;
removing StandardWellV
2019-03-25 06:52:34 -05:00
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 04:11:00 -06:00
// modify the water rate for polymer injectivity study
void handleInjectivityRate(const Simulator& ebosSimulator,
const int perf,
std::vector<EvalWell>& cq_s) const;
removing StandardWellV
2019-03-25 06:52:34 -05:00
// handle the extra equations for polymer injectivity study
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 04:11:00 -06:00
void handleInjectivityEquations(const Simulator& ebosSimulator,
const WellState& well_state,
const int perf,
const EvalWell& water_flux_s,
fixed: do not use Opm:: prefix when inside namespace Opm
2021-05-25 05:00:04 -05:00
DeferredLogger& deferred_logger);
finish the injecivity functionality the result looks okay
2018-11-30 05:15:51 -06:00
virtual void updateWaterThroughput(const double dt, WellState& 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 06:12:32 -05:00
adding checkConvergenceExtraEqs to StandardWell
2019-06-06 04:12:22 -05:00
// checking convergence of extra equations, if there are any
void checkConvergenceExtraEqs(const std::vector<double>& res,
fixing warnings under simulator/wells
2019-06-25 14:53:37 -05:00
ConvergenceReport& report) const;
adding checkConvergenceExtraEqs to StandardWell
2019-06-06 04:12:22 -05:00
adding updateConnectionRatePolyMW to StandardWell
2019-06-06 04:47:59 -05:00
// updating the connectionRates_ related polymer molecular weight
void updateConnectionRatePolyMW(const EvalWell& cq_s_poly,
const IntensiveQuantities& int_quants,
const WellState& well_state,
const int perf,
Refactor per-perforation code into separate function. Also make some methods const.
2020-11-03 04:11:00 -06:00
std::vector<RateVector>& connectionRates,
DeferredLogger& deferred_logger) const;
adding updateConnectionRatePolyMW to StandardWell
2019-06-06 04:47:59 -05:00
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
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
std::optional<double> computeBhpAtThpLimitProd(const WellState& well_state,
const Simulator& ebos_simulator,
replace boost::optional with std::optional
2020-02-19 04:02:13 -06:00
const SummaryState& summary_state,
DeferredLogger& deferred_logger) const;
add computeBhpAtThpLimitInj
2019-11-05 06:31:59 -06:00
replace boost::optional with std::optional
2020-02-19 04:02:13 -06:00
std::optional<double> computeBhpAtThpLimitInj(const Simulator& ebos_simulator,
const SummaryState& summary_state,
DeferredLogger& deferred_logger) const;
add computeBhpAtThpLimitInj
2019-11-05 06:31:59 -06:00
adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 04:41:03 -05:00
};
}
makding the StandardWell and WellInterface templated with the template parameter TypeTag.
2017-06-19 07:49:49 -05:00
#include "StandardWell_impl.hpp"
adding StandardWell class copied from the old implementation, which is the starting point for the new refactoring
2017-06-15 04:41:03 -05:00
#endif // OPM_STANDARDWELL_HEADER_INCLUDED
Reference in New Issue Copy Permalink