GasLiftSingleWell_impl.hpp
Go to the documentation of this file.
1/*
2 Copyright 2020 Equinor ASA.
3
4 This file is part of the Open Porous Media project (OPM).
5
6 OPM is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
10
11 OPM is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with OPM. If not, see <http://www.gnu.org/licenses/>.
18*/
19
20#ifndef OPM_GASLIFT_SINGLE_WELL_IMPL_HEADER_INCLUDED
21#define OPM_GASLIFT_SINGLE_WELL_IMPL_HEADER_INCLUDED
22
23// Improve IDE experience
24#ifndef OPM_GASLIFT_SINGLE_WELL_HEADER_INCLUDED
25#include <config.h>
27#endif
28
29#include <opm/common/TimingMacros.hpp>
30
31#include <opm/input/eclipse/Schedule/GasLiftOpt.hpp>
32#include <opm/input/eclipse/Schedule/Well/Well.hpp>
33
34#include <string>
35#include <vector>
36
37#include <fmt/format.h>
38
39namespace Opm {
40
41template<typename TypeTag>
44 const Simulator& simulator,
45 const SummaryState& summary_state,
46 DeferredLogger& deferred_logger,
48 const GroupState<Scalar>& group_state,
50 GLiftSyncGroups &sync_groups,
51 const Parallel::Communication& comm,
52 bool glift_debug)
53 // The parent class GasLiftSingleWellGeneric contains all stuff
54 // that is not dependent on TypeTag
55 : GasLiftSingleWellGeneric<Scalar, IndexTraits>(deferred_logger,
56 well_state,
57 group_state,
58 well.wellEcl(),
59 summary_state,
60 group_info,
61 simulator.vanguard().schedule(),
62 simulator.episodeIndex(),
63 sync_groups,
64 comm,
65 glift_debug)
66 , simulator_{simulator}
67 , well_{well}
68{
69 const auto& gl_well = *this->gl_well_;
70 if (this->useFixedAlq_(gl_well)) {
71 this->updateWellStateAlqFixedValue_(gl_well);
72 this->optimize_ = false; // lift gas supply is fixed
73 }
74 else {
75 setAlqMaxRate_(gl_well);
76 this->optimize_ = true;
77 }
78
79 setupPhaseVariables_();
80 // get the alq value used for this well for the previous iteration (a
81 // nonlinear iteration in assemble() in BlackoilWellModel).
82 // If gas lift optimization has not been applied to this well yet, the
83 // default value is used.
84 this->orig_alq_ = this->well_state_.well(this->well_name_).alq_state.get();
85 if (this->optimize_) {
86 this->setAlqMinRate_(gl_well);
87 // NOTE: According to item 4 in WLIFTOPT, this value does not
88 // have to be positive.
89 // TODO: Does it make sense to have a negative value?
90 this->alpha_w_ = gl_well.weight_factor();
91 if (this->alpha_w_ <= 0 ) {
92 this->displayWarning_("Nonpositive value for alpha_w ignored");
93 this->alpha_w_ = 1.0;
94 }
95
96 // NOTE: According to item 6 in WLIFTOPT:
97 // "If this value is greater than zero, the incremental gas rate will influence
98 // the calculation of the incremental gradient and may be used
99 // to discourage the allocation of lift gas to wells which produce more gas."
100 // TODO: Does this mean that we should ignore this value if it
101 // is negative?
102 this->alpha_g_ = gl_well.inc_weight_factor();
103
104 // TODO: adhoc value.. Should we keep max_iterations_ as a safety measure
105 // or does it not make sense to have it?
106 this->max_iterations_ = 1000;
107 }
108}
109
110/****************************************
111 * Private methods in alphabetical order
112 ****************************************/
113
114template<typename TypeTag>
115typename GasLiftSingleWell<TypeTag>::BasicRates
117computeWellRates_(Scalar bhp, bool bhp_is_limited, bool debug_output ) const
118{
119 std::vector<Scalar> potentials(this->NUM_PHASES, 0.0);
120 this->well_.computeWellRatesWithBhp(this->simulator_,
121 bhp,
122 potentials,
123 this->deferred_logger_);
124 if (debug_output) {
125 const std::string msg = fmt::format("computed well potentials given bhp {}, "
126 "oil: {}, gas: {}, water: {}", bhp,
127 -potentials[this->oil_pos_], -potentials[this->gas_pos_],
128 -potentials[this->water_pos_]);
129 this->displayDebugMessage_(msg);
130 }
131
132 std::transform(potentials.begin(), potentials.end(),
133 potentials.begin(),
134 [](const auto& potential)
135 { return std::min(Scalar{0}, potential); });
136 return {-potentials[this->oil_pos_],
137 -potentials[this->gas_pos_],
138 -potentials[this->water_pos_],
139 bhp_is_limited
140 };
141}
142
143template<typename TypeTag>
144std::optional<typename GasLiftSingleWell<TypeTag>::Scalar>
145GasLiftSingleWell<TypeTag>::
146computeBhpAtThpLimit_(Scalar alq, bool debug_output) const
147{
148 OPM_TIMEFUNCTION();
149 auto bhp_at_thp_limit = this->well_.computeBhpAtThpLimitProdWithAlq(
150 this->simulator_,
151 this->summary_state_,
152 alq,
153 this->deferred_logger_,
154 /*iterate_if_no_solution */ false);
155 if (bhp_at_thp_limit) {
156 if (*bhp_at_thp_limit < this->controls_.bhp_limit) {
157 if (debug_output && this->debug) {
158 const std::string msg = fmt::format(
159 "Computed bhp ({}) from thp limit is below bhp limit ({}), (ALQ = {})."
160 " Using bhp limit instead",
161 *bhp_at_thp_limit, this->controls_.bhp_limit, alq
162 );
163 this->displayDebugMessage_(msg);
164 }
165 bhp_at_thp_limit = this->controls_.bhp_limit;
166 }
167 //bhp_at_thp_limit = std::max(*bhp_at_thp_limit, this->controls_.bhp_limit);
168 }
169 else {
170 const std::string msg = fmt::format(
171 "Failed in getting converged bhp potential from thp limit (ALQ = {})", alq);
172 this->displayDebugMessage_(msg);
173 }
174 return bhp_at_thp_limit;
175}
176
177template<typename TypeTag>
178void
179GasLiftSingleWell<TypeTag>::
180setupPhaseVariables_()
181{
182#ifndef NDEBUG
183 bool num_phases_ok = (FluidSystem::numActivePhases()== 3);
184#endif
185 if (FluidSystem::numActivePhases()== 2) {
186 // NOTE: We support two-phase oil-water flow, by setting the gas flow rate
187 // to zero. This is done by initializing the potential vector to zero:
188 //
189 // std::vector<double> potentials(NUM_PHASES, 0.0);
190 //
191 // see e.g. runOptimizeLoop_() in GasLiftSingleWellGeneric.cpp
192 // In addition the VFP calculations, e.g. to calculate BHP from THP
193 // has been adapted to the two-phase oil-water case, see the comment
194 // in WellInterfaceGeneric.cpp for the method adaptRatesForVFP() for
195 // more information.
196 if ( FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx)
197 && FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx)
198 && !FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx) )
199 {
200#ifndef NDEBUG
201 num_phases_ok = true; // two-phase oil-water is also supported
202#endif
203 }
204 else {
205 throw std::logic_error("Two-phase gas lift optimization only supported"
206 " for oil and water");
207 }
208 }
209 assert(num_phases_ok);
210 this->oil_pos_ = FluidSystem::canonicalToActivePhaseIdx(FluidSystem::oilPhaseIdx);
211 this->gas_pos_ = FluidSystem::canonicalToActivePhaseIdx(FluidSystem::gasPhaseIdx);
212 this->water_pos_ = FluidSystem::canonicalToActivePhaseIdx(FluidSystem::waterPhaseIdx);
213}
214
215template<typename TypeTag>
216void
217GasLiftSingleWell<TypeTag>::
218setAlqMaxRate_(const GasLiftWell& well)
219{
220 const auto& max_alq_optional = well.max_rate();
221 if (max_alq_optional) {
222 // NOTE: To prevent extrapolation of the VFP tables, any value
223 // entered here must not exceed the largest ALQ value in the well's VFP table.
224 this->max_alq_ = *max_alq_optional;
225 }
226 else { // i.e. WLIFTOPT, item 3 has been defaulted
227 // According to the manual for WLIFTOPT, item 3:
228 // The default value should be set to the largest ALQ
229 // value in the well's VFP table
230 const auto& table = well_.vfpProperties()->getProd()->getTable(
231 this->controls_.vfp_table_number);
232 const auto& alq_values = table.getALQAxis();
233 // Assume the alq_values are sorted in ascending order, so
234 // the last item should be the largest value:
235 this->max_alq_ = alq_values.back();
236 }
237}
238
239template<typename TypeTag>
240bool
241GasLiftSingleWell<TypeTag>::
242checkThpControl_() const
243{
244 const int well_index = this->well_state_.index(this->well_name_).value();
245 const Well::ProducerCMode& control_mode =
246 this->well_state_.well(well_index).production_cmode;
247 bool thp_control = control_mode == Well::ProducerCMode::THP;
248 const auto& well = getWell();
249 thp_control = thp_control || well.thpLimitViolatedButNotSwitched();
250 if (this->debug) {
251 if (!thp_control) {
252 this->displayDebugMessage_("Well is not under THP control, skipping iteration..");
253 }
254 }
255 return thp_control;
256}
257
258}
259
260#endif
Scalar get() const
Definition: DeferredLogger.hpp:57
WellState< GetPropType< TypeTag, Properties::Scalar >, GetPropType< TypeTag, Properties::FluidSystem >::IndexTraitsType > & well_state_
Definition: GasLiftCommon.hpp:54
Definition: GasLiftGroupInfo.hpp:46
Definition: GasLiftSingleWellGeneric.hpp:48
Definition: GasLiftSingleWell.hpp:39
GasLiftSingleWell(const WellInterface< TypeTag > &well, const Simulator &simulator, const SummaryState &summary_state, DeferredLogger &deferred_logger, WellState< Scalar, IndexTraits > &well_state, const GroupState< Scalar > &group_state, GasLiftGroupInfo< Scalar, IndexTraits > &group_info, GLiftSyncGroups &sync_groups, const Parallel::Communication &comm, bool glift_debug)
Definition: GasLiftSingleWell_impl.hpp:43
Definition: GroupState.hpp:41
ALQState< Scalar > alq_state
Definition: SingleWellState.hpp:128
Definition: WellInterface.hpp:76
Definition: WellState.hpp:66
const SingleWellState< Scalar, IndexTraits > & well(std::size_t well_index) const
Definition: WellState.hpp:289
Dune::Communication< MPIComm > Communication
Definition: ParallelCommunication.hpp:30
Definition: blackoilboundaryratevector.hh:39