BlackoilWellModelGasLift_impl.hpp
Go to the documentation of this file.
1/*
2 Copyright 2016 - 2019 SINTEF Digital, Mathematics & Cybernetics.
3 Copyright 2016 - 2018 Equinor ASA.
4 Copyright 2017 Dr. Blatt - HPC-Simulation-Software & Services
5 Copyright 2016 - 2018 Norce AS
6
7 This file is part of the Open Porous Media project (OPM).
8
9 OPM is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
13
14 OPM is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with OPM. If not, see <http://www.gnu.org/licenses/>.
21*/
22#define OPM_BLACKOILWELLMODEL_GASLIFT_IMPL_HEADER_INCLUDED
23#define OPM_BLACKOILWELLMODEL_GASLIFT_IMPL_HEADER_INCLUDED
24
25// Improve IDE experience
26#ifndef OPM_BLACKOILWELLMODEL_GASLIFT_HEADER_INCLUDED
27#include <config.h>
29#endif
30#include <opm/common/TimingMacros.hpp>
33
34#if HAVE_MPI
36#endif
37
38namespace Opm {
39
40template<typename TypeTag>
41bool
43maybeDoGasLiftOptimize(const Simulator& simulator,
44 const std::vector<WellInterfacePtr>& well_container,
45 const std::map<std::string, Scalar>& node_pressures,
46 const bool updatePotentials,
47 WellStateType& wellState,
48 GroupState<Scalar>& groupState,
49 DeferredLogger& deferred_logger)
50{
51 OPM_TIMEFUNCTION();
52 const auto& glo = simulator.vanguard().schedule().glo(simulator.episodeIndex());
53 if(!glo.active()) {
54 return false;
55 }
56 bool do_glift_optimization = false;
57 int num_wells_changed = 0;
58 const double simulation_time = simulator.time();
59 const Scalar min_wait = glo.min_wait();
60 // We only optimize if a min_wait time has past.
61 // If all_newton is true we still want to optimize several times pr timestep
62 // i.e. we also optimize if check simulation_time == last_glift_opt_time_
63 // that is when the last_glift_opt_time is already updated with the current time step
64 if (simulation_time == this->last_glift_opt_time_ ||
65 simulation_time >= (this->last_glift_opt_time_ + min_wait))
66 {
67 do_glift_optimization = true;
68 this->last_glift_opt_time_ = simulation_time;
69 }
70
71 // update potentials if changed by network (needed by the gaslift algorithm)
72 if (updatePotentials) {
73 updateWellPotentials(simulator, well_container, node_pressures, wellState, deferred_logger);
74 }
75
76 if (do_glift_optimization) {
77 GLiftOptWells glift_wells;
78 GLiftProdWells prod_wells;
79 GLiftWellStateMap state_map;
80 // NOTE: To make GasLiftGroupInfo (see below) independent of the TypeTag
81 // associated with *this (i.e. BlackoilWellModel<TypeTag>) we observe
82 // that GasLiftGroupInfo's only dependence on *this is that it needs to
83 // access the eclipse Wells in the well container (the eclipse Wells
84 // themselves are independent of the TypeTag).
85 // Hence, we extract them from the well container such that we can pass
86 // them to the GasLiftGroupInfo constructor.
87 GLiftEclWells ecl_well_map;
88 initGliftEclWellMap(well_container, ecl_well_map);
89 const auto& iterCtx = simulator.problem().iterationContext();
90 GasLiftGroupInfo group_info {
91 ecl_well_map,
92 simulator.vanguard().schedule(),
93 simulator.vanguard().summaryState(),
94 simulator.episodeIndex(),
95 iterCtx,
96 deferred_logger,
97 wellState,
98 groupState,
99 simulator.vanguard().grid().comm(),
100 this->glift_debug,
101 simulator.problem().wellModel().groupStateHelper()
102 };
103 group_info.initialize();
104
105 gasLiftOptimizationStage1(simulator,
106 well_container,
107 wellState,
108 groupState,
109 prod_wells,
110 glift_wells,
111 group_info,
112 state_map,
113 deferred_logger);
114
115 this->gasLiftOptimizationStage2(simulator.vanguard().gridView().comm(),
116 simulator.vanguard().schedule(),
117 simulator.vanguard().summaryState(),
118 wellState,
119 groupState,
120 prod_wells,
121 glift_wells,
122 group_info,
123 state_map,
124 simulator.episodeIndex(),
125 deferred_logger);
126
127 if constexpr (glift_debug) {
128 std::vector<WellInterfaceGeneric<Scalar, IndexTraits>*> wc;
129 wc.reserve(well_container.size());
130 std::ranges::transform(well_container, std::back_inserter(wc),
131 [](const auto& w)
132 { return static_cast<WellInterfaceGeneric<Scalar, IndexTraits>*>(w.get()); });
133 this->gliftDebugShowALQ(wc,
134 wellState,
135 deferred_logger);
136 }
137 num_wells_changed = glift_wells.size();
138 }
139 num_wells_changed = simulator.vanguard().gridView().comm().sum(num_wells_changed);
140 return num_wells_changed > 0;
141}
142
143template<typename TypeTag>
144void
146gasLiftOptimizationStage1(const Simulator& simulator,
147 const std::vector<WellInterfacePtr>& well_container,
148 WellStateType& wellState,
149 GroupState<Scalar>& groupState,
150 GLiftProdWells& prod_wells,
151 GLiftOptWells &glift_wells,
153 GLiftWellStateMap& state_map,
154 DeferredLogger& deferred_logger)
155{
156 OPM_TIMEFUNCTION();
157 auto comm = simulator.vanguard().grid().comm();
158 int num_procs = comm.size();
159 // NOTE: Gas lift optimization stage 1 seems to be difficult
160 // to do in parallel since the wells are optimized on different
161 // processes and each process needs to know the current ALQ allocated
162 // to each group it is a memeber of in order to check group limits and avoid
163 // allocating more ALQ than necessary. (Surplus ALQ is removed in
164 // stage 2). In stage1, as each well is adding ALQ, the current group ALQ needs
165 // to be communicated to the other processes. But there is no common
166 // synchronization point that all process will reach in the
167 // runOptimizeLoop_() in GasLiftSingleWell.cpp.
168 //
169 // TODO: Maybe a better solution could be invented by distributing
170 // wells according to certain parent groups. Then updated group rates
171 // might not have to be communicated to the other processors.
172
173 // Currently, the best option seems to be to run this part sequentially
174 // (not in parallel).
175 //
176 // TODO: The simplest approach seems to be if a) one process could take
177 // ownership of all the wells (the union of all the wells in the
178 // well_container_ of each process) then this process could do the
179 // optimization, while the other processes could wait for it to
180 // finish (e.g. comm.barrier()), or alternatively, b) if all
181 // processes could take ownership of all the wells. Then there
182 // would be no need for synchronization here..
183 //
184 for (int i = 0; i< num_procs; i++) {
185 int num_rates_to_sync = 0; // communication variable
186 GLiftSyncGroups groups_to_sync;
187 if (comm.rank() == i) {
188 // Run stage1: Optimize single wells while also checking group limits
189 for (const auto& well : well_container) {
190 // NOTE: Only the wells in "group_info" needs to be optimized
191 if (group_info.hasWell(well->name())) {
192 gasLiftOptimizationStage1SingleWell(well.get(),
193 simulator,
194 wellState,
195 groupState,
196 prod_wells,
197 glift_wells,
198 group_info,
199 state_map,
200 groups_to_sync,
201 deferred_logger);
202 }
203 }
204 num_rates_to_sync = groups_to_sync.size();
205 }
206 {
207 OPM_TIMEBLOCK(WaitForGasLiftSyncGroups);
208 num_rates_to_sync = comm.sum(num_rates_to_sync);
209 }
210 if (num_rates_to_sync > 0) {
211 OPM_TIMEBLOCK(GasLiftSyncGroups);
212 std::vector<int> group_indexes;
213 group_indexes.reserve(num_rates_to_sync);
214 std::vector<Scalar> group_alq_rates;
215 group_alq_rates.reserve(num_rates_to_sync);
216 std::vector<Scalar> group_oil_rates;
217 group_oil_rates.reserve(num_rates_to_sync);
218 std::vector<Scalar> group_gas_rates;
219 group_gas_rates.reserve(num_rates_to_sync);
220 std::vector<Scalar> group_water_rates;
221 group_water_rates.reserve(num_rates_to_sync);
222 if (comm.rank() == i) {
223 for (auto idx : groups_to_sync) {
224 auto [oil_rate, gas_rate, water_rate, alq] = group_info.getRates(idx);
225 group_indexes.push_back(idx);
226 group_oil_rates.push_back(oil_rate);
227 group_gas_rates.push_back(gas_rate);
228 group_water_rates.push_back(water_rate);
229 group_alq_rates.push_back(alq);
230 }
231 } else {
232 group_indexes.resize(num_rates_to_sync);
233 group_oil_rates.resize(num_rates_to_sync);
234 group_gas_rates.resize(num_rates_to_sync);
235 group_water_rates.resize(num_rates_to_sync);
236 group_alq_rates.resize(num_rates_to_sync);
237 }
238#if HAVE_MPI
239 Parallel::MpiSerializer ser(comm);
240 ser.broadcast(Parallel::RootRank{i}, group_indexes, group_oil_rates,
241 group_gas_rates, group_water_rates, group_alq_rates);
242#endif
243 if (comm.rank() != i) {
244 for (int j = 0; j < num_rates_to_sync; ++j) {
245 group_info.updateRate(group_indexes[j],
246 group_oil_rates[j],
247 group_gas_rates[j],
248 group_water_rates[j],
249 group_alq_rates[j]);
250 }
251 }
252 }
253 }
254}
255
256// NOTE: this method cannot be const since it passes this->wellState()
257// (see below) to the GasLiftSingleWell constructor which accepts WellState
258// as a non-const reference..
259template<typename TypeTag>
260void
261BlackoilWellModelGasLift<TypeTag>::
262gasLiftOptimizationStage1SingleWell(WellInterface<TypeTag>* well,
263 const Simulator& simulator,
264 WellStateType& wellState,
265 GroupState<Scalar>& groupState,
266 GLiftProdWells& prod_wells,
267 GLiftOptWells& glift_wells,
268 GasLiftGroupInfo<Scalar, IndexTraits>& group_info,
269 GLiftWellStateMap& state_map,
270 GLiftSyncGroups& sync_groups,
271 DeferredLogger& deferred_logger)
272{
273 OPM_TIMEFUNCTION();
274 const auto& summary_state = simulator.vanguard().summaryState();
275 auto glift = std::make_unique<GasLiftSingleWell<TypeTag>>(*well,
276 simulator,
277 summary_state,
278 deferred_logger,
279 wellState,
280 groupState,
281 group_info,
282 sync_groups,
283 simulator.vanguard().gridView().comm(),
284 this->glift_debug);
285 const auto& iterCtx = simulator.problem().iterationContext();
286 auto state = glift->runOptimize(iterCtx.iteration());
287 if (state) {
288 state_map.emplace(well->name(), std::move(state));
289 glift_wells.emplace(well->name(), std::move(glift));
290 return;
291 }
292 prod_wells.insert({well->name(), well});
293}
294
295template<typename TypeTag>
296void
298initGliftEclWellMap(const std::vector<WellInterfacePtr>& well_container,
299 GLiftEclWells& ecl_well_map)
300{
301 for (const auto& well : well_container) {
302 ecl_well_map.try_emplace(well->name(), &well->wellEcl(), well->indexOfWell());
303 }
304}
305
306template<typename TypeTag>
307void
309updateWellPotentials(const Simulator& simulator,
310 const std::vector<WellInterfacePtr>& well_container,
311 const std::map<std::string, Scalar>& node_pressures,
312 WellStateType& wellState,
313 DeferredLogger& deferred_logger)
314{
315 auto well_state_copy = wellState;
316 const int np = wellState.numPhases();
317 std::string exc_msg;
318 auto exc_type = ExceptionType::NONE;
319 for (const auto& well : well_container) {
320 if (well->isInjector() || !well->wellEcl().predictionMode())
321 continue;
322
323 const auto it = node_pressures.find(well->wellEcl().groupName());
324 if (it != node_pressures.end()) {
325 std::string cur_exc_msg;
326 auto cur_exc_type = ExceptionType::NONE;
327 try {
328 std::vector<Scalar> potentials;
329 const auto& groupStateHelper = simulator.problem().wellModel().groupStateHelper();
330 well->computeWellPotentials(simulator, well_state_copy, groupStateHelper, potentials);
331 auto& ws = wellState.well(well->indexOfWell());
332 for (int p = 0; p < np; ++p) {
333 // make sure the potentials are positive
334 ws.well_potentials[p] = std::max(Scalar{0.0}, potentials[p]);
335 }
336 }
337 // catch all possible exception and store type and message.
338 OPM_PARALLEL_CATCH_CLAUSE(cur_exc_type, cur_exc_msg);
339 if (cur_exc_type != ExceptionType::NONE) {
340 exc_msg += fmt::format("\nFor well {}: {}", well->name(), cur_exc_msg);
341 }
342 exc_type = std::max(exc_type, cur_exc_type);
343 }
344 }
345 if (exc_type != ExceptionType::NONE) {
346 const std::string msg = "Updating well potentials after network balancing failed. Continue with current potentials";
347 deferred_logger.warning("WELL_POT_SOLVE_AFTER_NETWORK_FAILED", msg + exc_msg);
348 }
349}
350
351} // namespace Opm
#define OPM_PARALLEL_CATCH_CLAUSE(obptc_exc_type, obptc_exc_msg)
Inserts catch classes for the parallel try-catch.
Definition: DeferredLoggingErrorHelpers.hpp:168
Class for handling the gaslift in the blackoil well model.
Definition: BlackoilWellModelGasLift.hpp:96
GetPropType< TypeTag, Properties::Simulator > Simulator
Definition: BlackoilWellModelGasLift.hpp:108
bool maybeDoGasLiftOptimize(const Simulator &simulator, const std::vector< WellInterfacePtr > &well_container, const std::map< std::string, Scalar > &node_pressures, const bool updatePotentials, WellStateType &wellState, GroupState< Scalar > &groupState, DeferredLogger &deferred_logger)
Definition: BlackoilWellModelGasLift_impl.hpp:43
static void initGliftEclWellMap(const std::vector< WellInterfacePtr > &well_container, GLiftEclWells &ecl_well_map)
Definition: BlackoilWellModelGasLift_impl.hpp:298
typename Base::GLiftWellStateMap GLiftWellStateMap
Definition: BlackoilWellModelGasLift.hpp:107
typename Base::GLiftOptWells GLiftOptWells
Definition: BlackoilWellModelGasLift.hpp:104
typename GasLiftGroupInfo< Scalar, IndexTraits >::GLiftEclWells GLiftEclWells
Definition: BlackoilWellModelGasLift.hpp:103
typename Base::GLiftProdWells GLiftProdWells
Definition: BlackoilWellModelGasLift.hpp:105
GetPropType< TypeTag, Properties::Scalar > Scalar
Definition: BlackoilWellModelGasLift.hpp:98
Definition: DeferredLogger.hpp:57
void warning(const std::string &tag, const std::string &message)
Definition: GasLiftGroupInfo.hpp:49
bool hasWell(const std::string &well_name)
std::tuple< Scalar, Scalar, Scalar, Scalar > getRates(const int group_idx) const
void updateRate(int idx, Scalar oil_rate, Scalar gas_rate, Scalar water_rate, Scalar alq)
Definition: GroupState.hpp:42
Manages the initializing and running of time dependent problems.
Definition: simulator.hh:87
Vanguard & vanguard()
Return a reference to the grid manager of simulation.
Definition: simulator.hh:242
Problem & problem()
Return the object which specifies the pysical setup of the simulation.
Definition: simulator.hh:273
Definition: WellInterfaceGeneric.hpp:60
Definition: WellState.hpp:68
@ NONE
Definition: DeferredLogger.hpp:46
Definition: blackoilbioeffectsmodules.hh:45