OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2024-12-25 16:51:00 -06:00
Code Issues Packages Projects Releases Wiki Activity
3eb684ae7d
opm-simulators/opm/simulators/wells/GasLiftSingleWellGeneric.hpp

370 lines
15 KiB
C++
Raw Normal View History

GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
/*
Copyright 2020 Equinor ASA.
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_GASLIFT_SINGLE_WELL_GENERIC_HEADER_INCLUDED
#define OPM_GASLIFT_SINGLE_WELL_GENERIC_HEADER_INCLUDED
Check group limits in gas lift stage 1. Check group limits in gas lift stage 1 to avoid adding too much ALQ which must anyway later be removed in stage 2. This should make the optimization more efficient for small ALQ increment values. Also adds MPI support.
2021-05-27 01:31:49 -05:00
#include <dune/common/version.hh>
#include <dune/common/parallel/mpihelper.hh>
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
#include <opm/core/props/BlackoilPhases.hpp>
GasLiftSingleWellGeneric.hpp: include WellProductionControls.hpp instead of Well.hpp
2023-01-18 04:56:21 -06:00
#include <opm/input/eclipse/Schedule/Well/WellProductionControls.hpp>
Check group limits in gas lift stage 1. Check group limits in gas lift stage 1 to avoid adding too much ALQ which must anyway later be removed in stage 2. This should make the optimization more efficient for small ALQ increment values. Also adds MPI support.
2021-05-27 01:31:49 -05:00
#include <opm/simulators/wells/GasLiftGroupInfo.hpp>
Improve debugging tools in gaslift code. Introduces a gaslift debugging variable in ALQState in WellState. This variable will persist between timesteps in contrast to when debugging variables are defined in GasLiftSingleWell, GasLiftGroupState, or GasLiftStage2. Currently only an integer variable debug_counter is added to ALQState, which can be used as follows: First debugging is switched on globally for BlackOilWellModel, GasLiftSingleWell, GasLiftGroupState, and GasLiftStage2 by setting glift_debug to a true value in BlackOilWellModelGeneric. Then, the following debugging code can be added to e.g. one of GasLiftSingleWell, GasLiftGroupState, or GasLiftStage2 : auto count = debugUpdateGlobalCounter_(); if (count == some_integer) { displayDebugMessage_("stop here"); } Here, the integer "some_integer" is determined typically by looking at the debugging output of a previous run. This can be done since the call to debugUpdateGlobalCounter_() will print out the current value of the counter and then increment the counter by one. And it will be easy to recognize these values in the debug ouput. If you find a place in the output that looks suspect, just take a note of the counter value in the output around that point and insert the value for "some_integer", then after recompiling the code with the desired value for "some_integer", it is now easy to set a breakpoint in GDB at the line displayDebugMessage_("stop here"). shown in the above snippet. This should improve the ability to quickly to set a breakpoint in GDB around at a given time and point in the simulation.
2022-01-23 13:37:26 -06:00
#include <opm/simulators/wells/GasLiftCommon.hpp>
Change condition under which stage 2 is done. It only makes sense to try to optimize the distribution of lift gas if the amount of lift gas is constrained either by the maximum allowed gaslift or total gas or the group is under individual control.
2022-10-20 05:58:42 -05:00
#include <opm/simulators/wells/GroupState.hpp>
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
#include <functional>
#include <optional>
#include <string>
#include <tuple>
#include <vector>
#include <utility>
namespace Opm
{
class DeferredLogger;
avoid GasLiftOpt.hpp where possible and add where necessary
2023-01-09 06:54:30 -06:00
class GasLiftWell;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
class GasLiftWellState;
class Schedule;
class SummaryState;
GasLiftStage2: use GasLiftSingleWellGeneric
2021-05-24 16:56:14 -05:00
class WellInterfaceGeneric;
Rename WellStateFullyImplicitBlackoil -> WellState
2021-05-20 06:32:18 -05:00
class WellState;
Potentially reduce gaslift when under well is under group control Current implemention only support ORAT and GRAT controlled groups
2021-06-23 08:46:33 -05:00
class GroupState;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
Improve debugging tools in gaslift code. Introduces a gaslift debugging variable in ALQState in WellState. This variable will persist between timesteps in contrast to when debugging variables are defined in GasLiftSingleWell, GasLiftGroupState, or GasLiftStage2. Currently only an integer variable debug_counter is added to ALQState, which can be used as follows: First debugging is switched on globally for BlackOilWellModel, GasLiftSingleWell, GasLiftGroupState, and GasLiftStage2 by setting glift_debug to a true value in BlackOilWellModelGeneric. Then, the following debugging code can be added to e.g. one of GasLiftSingleWell, GasLiftGroupState, or GasLiftStage2 : auto count = debugUpdateGlobalCounter_(); if (count == some_integer) { displayDebugMessage_("stop here"); } Here, the integer "some_integer" is determined typically by looking at the debugging output of a previous run. This can be done since the call to debugUpdateGlobalCounter_() will print out the current value of the counter and then increment the counter by one. And it will be easy to recognize these values in the debug ouput. If you find a place in the output that looks suspect, just take a note of the counter value in the output around that point and insert the value for "some_integer", then after recompiling the code with the desired value for "some_integer", it is now easy to set a breakpoint in GDB at the line displayDebugMessage_("stop here"). shown in the above snippet. This should improve the ability to quickly to set a breakpoint in GDB around at a given time and point in the simulation.
2022-01-23 13:37:26 -06:00
class GasLiftSingleWellGeneric : public GasLiftCommon
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
{
Make constants used in subclasses protected.
2021-05-24 04:24:14 -05:00
protected:
Gas lift optimization for two-phase oil-water. Add gas lift optimization support for two-phase oil-water flow.
2022-02-17 02:15:56 -06:00
static constexpr int Water = BlackoilPhases::Aqua;
static constexpr int Oil = BlackoilPhases::Liquid;
static constexpr int Gas = BlackoilPhases::Vapour;
static constexpr int NUM_PHASES = 3;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
static constexpr double ALQ_EPSILON = 1e-8;
public:
Check group limits in gas lift stage 1. Check group limits in gas lift stage 1 to avoid adding too much ALQ which must anyway later be removed in stage 2. This should make the optimization more efficient for small ALQ increment values. Also adds MPI support.
2021-05-27 01:31:49 -05:00
using GLiftSyncGroups = std::set<int>;
Refactor some methods in GasLiftSingleWellGeneric. Refactor getOilRateWithGroupLimit_(), getGasRateWithGroupLimit_(), getWaterRateWithGroupLimit_(), and getLiquidRateWithGroupLimit_() into a single generic method called getRateWithGroupLimit_().
2021-12-16 18:52:34 -06:00
using Rate = GasLiftGroupInfo::Rate;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
struct GradInfo
{
GradInfo() { }
GradInfo(double grad_, double new_oil_rate_, bool oil_is_limited_,
double new_gas_rate_, bool gas_is_limited_,
update well potensials in well state along with alq and update guide rates accordingly
2022-02-08 08:46:08 -06:00
double new_water_rate_, bool water_is_limited_,
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
double alq_, bool alq_is_limited_) :
grad{grad_},
new_oil_rate{new_oil_rate_},
oil_is_limited{oil_is_limited_},
new_gas_rate{new_gas_rate_},
gas_is_limited{gas_is_limited_},
update well potensials in well state along with alq and update guide rates accordingly
2022-02-08 08:46:08 -06:00
new_water_rate{new_water_rate_},
water_is_limited{water_is_limited_},
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
alq{alq_},
alq_is_limited{alq_is_limited_} {}
double grad;
double new_oil_rate;
bool oil_is_limited;
double new_gas_rate;
bool gas_is_limited;
update well potensials in well state along with alq and update guide rates accordingly
2022-02-08 08:46:08 -06:00
double new_water_rate;
bool water_is_limited;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
double alq;
bool alq_is_limited;
};
virtual ~GasLiftSingleWellGeneric() = default;
const std::string& name() const { return well_name_; }
std::optional<GradInfo> calcIncOrDecGradient(double oil_rate, double gas_rate,
Calculate gradients with group limits. Take into account group limits when calculating gradients for individual wells in stage 2 of gas lift optimization.
2022-10-17 15:05:35 -05:00
double water_rate,
pass group name to getRateWithGroupLimit to avoid checking for that
2022-10-26 01:51:38 -05:00
double alq,
renaming and adding more comments based on review
2022-11-16 02:18:35 -06:00
const std::string& gr_name_dont_limit,
bool increase) const;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
std::unique_ptr<GasLiftWellState> runOptimize(const int iteration_idx);
Rename some methods and variables. Renames some methods and variables to reflect that the well is no longer necessarily a StandardWell. It can be either a MultisegmentWell or a StandardWell. This should avoid confusion about the nature of the variable.
2022-02-15 03:21:09 -06:00
virtual const WellInterfaceGeneric& getWell() const = 0;
GasLiftStage2: use GasLiftSingleWellGeneric
2021-05-24 16:56:14 -05:00
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
protected:
Check group limits in gas lift stage 1. Check group limits in gas lift stage 1 to avoid adding too much ALQ which must anyway later be removed in stage 2. This should make the optimization more efficient for small ALQ increment values. Also adds MPI support.
2021-05-27 01:31:49 -05:00
GasLiftSingleWellGeneric(
Limit well rates to honor group rates If a well is under a group that is limited by a target, it should use as little gaslift as possible. The reduction algorithm will reduce the gaslift of the well as long as the groups potential is above the groups target.
2022-02-01 05:55:04 -06:00
DeferredLogger& deferred_logger,
WellState& well_state,
Potentially reduce gaslift when under well is under group control Current implemention only support ORAT and GRAT controlled groups
2021-06-23 08:46:33 -05:00
const GroupState& group_state,
Check group limits in gas lift stage 1. Check group limits in gas lift stage 1 to avoid adding too much ALQ which must anyway later be removed in stage 2. This should make the optimization more efficient for small ALQ increment values. Also adds MPI support.
2021-05-27 01:31:49 -05:00
const Well& ecl_well,
const SummaryState& summary_state,
Limit well rates to honor group rates If a well is under a group that is limited by a target, it should use as little gaslift as possible. The reduction algorithm will reduce the gaslift of the well as long as the groups potential is above the groups target.
2022-02-01 05:55:04 -06:00
GasLiftGroupInfo& group_info,
const PhaseUsage& phase_usage,
Check group limits in gas lift stage 1. Check group limits in gas lift stage 1 to avoid adding too much ALQ which must anyway later be removed in stage 2. This should make the optimization more efficient for small ALQ increment values. Also adds MPI support.
2021-05-27 01:31:49 -05:00
const Schedule& schedule,
const int report_step_idx,
Limit well rates to honor group rates If a well is under a group that is limited by a target, it should use as little gaslift as possible. The reduction algorithm will reduce the gaslift of the well as long as the groups potential is above the groups target.
2022-02-01 05:55:04 -06:00
GLiftSyncGroups& sync_groups,
Cleanup glift debugging output code
2022-03-24 06:42:46 -05:00
const Parallel::Communication& comm,
Improve debugging tools in gaslift code. Introduces a gaslift debugging variable in ALQState in WellState. This variable will persist between timesteps in contrast to when debugging variables are defined in GasLiftSingleWell, GasLiftGroupState, or GasLiftStage2. Currently only an integer variable debug_counter is added to ALQState, which can be used as follows: First debugging is switched on globally for BlackOilWellModel, GasLiftSingleWell, GasLiftGroupState, and GasLiftStage2 by setting glift_debug to a true value in BlackOilWellModelGeneric. Then, the following debugging code can be added to e.g. one of GasLiftSingleWell, GasLiftGroupState, or GasLiftStage2 : auto count = debugUpdateGlobalCounter_(); if (count == some_integer) { displayDebugMessage_("stop here"); } Here, the integer "some_integer" is determined typically by looking at the debugging output of a previous run. This can be done since the call to debugUpdateGlobalCounter_() will print out the current value of the counter and then increment the counter by one. And it will be easy to recognize these values in the debug ouput. If you find a place in the output that looks suspect, just take a note of the counter value in the output around that point and insert the value for "some_integer", then after recompiling the code with the desired value for "some_integer", it is now easy to set a breakpoint in GDB at the line displayDebugMessage_("stop here"). shown in the above snippet. This should improve the ability to quickly to set a breakpoint in GDB around at a given time and point in the simulation.
2022-01-23 13:37:26 -06:00
bool glift_debug
Check group limits in gas lift stage 1. Check group limits in gas lift stage 1 to avoid adding too much ALQ which must anyway later be removed in stage 2. This should make the optimization more efficient for small ALQ increment values. Also adds MPI support.
2021-05-27 01:31:49 -05:00
);
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
struct LimitedRates;
struct BasicRates
{
BasicRates(const BasicRates& rates) :
oil{rates.oil},
gas{rates.gas},
water{rates.water},
bhp_is_limited{rates.bhp_is_limited}
{}
BasicRates(double oil_, double gas_, double water_, bool bhp_is_limited_) :
oil{oil_},
gas{gas_},
water{water_},
bhp_is_limited{bhp_is_limited_}
{}
BasicRates& operator=(const BasicRates& rates) {
oil = rates.oil;
gas = rates.gas;
water = rates.water;
bhp_is_limited = rates.bhp_is_limited;
return *this;
}
// This copy constructor cannot be defined inline here since LimitedRates
// has not been defined yet (it is defined below). Instead it is defined in
// in the .cpp file
BasicRates(const LimitedRates& rates);
double operator[](Rate rate_type) const {
switch (rate_type) {
case Rate::oil:
return this->oil;
case Rate::gas:
return this->gas;
case Rate::water:
return this->water;
case Rate::liquid:
return this->oil + this->water;
default:
throw std::runtime_error("This should not happen");
}
}
double oil, gas, water;
bool bhp_is_limited;
};
struct LimitedRates : public BasicRates
{
enum class LimitType {well, group, none};
LimitedRates(
double oil_, double gas_, double water_,
bool oil_is_limited_, bool gas_is_limited_,
bool water_is_limited_, bool bhp_is_limited_,
std::optional<Rate> oil_limiting_target_,
std::optional<Rate> water_limiting_target_
) :
BasicRates(oil_, gas_, water_, bhp_is_limited_),
oil_is_limited{oil_is_limited_},
gas_is_limited{gas_is_limited_},
water_is_limited{water_is_limited_},
oil_limiting_target{oil_limiting_target_},
water_limiting_target{water_limiting_target_}
{
set_initial_limit_type_();
}
LimitedRates(
const BasicRates& rates,
bool oil_is_limited_, bool gas_is_limited_,
bool water_is_limited_
) :
BasicRates(rates),
oil_is_limited{oil_is_limited_},
gas_is_limited{gas_is_limited_},
water_is_limited{water_is_limited_}
{
set_initial_limit_type_();
}
bool limited() const {
return oil_is_limited || gas_is_limited || water_is_limited;
}
// For a given ALQ value, were the rates limited due to group targets
// or due to well targets?
LimitType limit_type;
bool oil_is_limited;
bool gas_is_limited;
bool water_is_limited;
std::optional<Rate> oil_limiting_target;
std::optional<Rate> water_limiting_target;
private:
void set_initial_limit_type_() {
limit_type = limited() ? LimitType::well : LimitType::none;
}
};
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
struct OptimizeState
{
OptimizeState( GasLiftSingleWellGeneric& parent_, bool increase_ ) :
parent{parent_},
increase{increase_},
it{0},
stop_iteration{false},
bhp{-1}
{}
GasLiftSingleWellGeneric& parent;
bool increase;
int it;
bool stop_iteration;
double bhp;
std::pair<std::optional<double>,bool> addOrSubtractAlqIncrement(double alq);
double calcEcoGradient(double oil_rate, double new_oil_rate,
double gas_rate, double new_gas_rate);
bool checkAlqOutsideLimits(double alq, double oil_rate);
bool checkEcoGradient(double gradient);
bool checkOilRateExceedsTarget(double oil_rate);
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
bool checkRatesViolated(const LimitedRates& rates) const;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
void debugShowIterationInfo(double alq);
double getBhpWithLimit();
void warn_(std::string msg) {parent.displayWarning_(msg);}
};
renaming and adding more comments based on review
2022-11-16 02:18:35 -06:00
bool checkGroupALQrateExceeded(double delta_alq, const std::string& gr_name_dont_limit = "") const;
reduce alq when alq + gas production target is violated
2022-02-02 07:17:06 -06:00
bool checkGroupTotalRateExceeded(double delta_alq, double delta_gas_rate) const;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
std::pair<std::optional<double>, bool> addOrSubtractAlqIncrement_(
double alq, bool increase) const;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
double calcEcoGradient_(double oil_rate, double new_oil_rate,
double gas_rate, double new_gas_rate, bool increase) const;
bool checkALQequal_(double alq1, double alq2) const;
Small clean up in GasLiftSingleWellGeneric.cpp As discussed in PR #3728, it is better to move the two methods reduceALQtoGroupTarget() and checkGroupTargetsViolated() from OptimizeState to the parent class, then we do not have to abuse OptimizeState in maybeAdjustALQbeforeOptimizeLoop_() just to call reduceALQtoGroupTarget(). Also fixes a typo (as discussed in PR #3729) in reduceALQtoGrouptTarget() where the water rate is updated with the gas flow rate instead of the water flow rate. Should be like this: water_rate = -potentials[this->parent.water_pos_]; instead of water_rate = -potentials[this->parent.gas_pos_];
2021-12-09 04:58:43 -06:00
bool checkGroupTargetsViolated(
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
const BasicRates& rates, const BasicRates& new_rates) const;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
bool checkInitialALQmodified_(double alq, double initial_alq) const;
Allow for gaslift for wells that violate thp limit but are not allowed to switch
2022-09-02 05:11:39 -05:00
virtual bool checkThpControl_() const = 0;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
virtual std::optional<double> computeBhpAtThpLimit_(double alq) const = 0;
Well testing of gas lift wells Assign a maximum ALQ value to each GLIFT producer when doing well testing in beginTimeStep(). This allows the well to be considered open. Then, later in the timestep, when assemble() is called, the full gas lift optimization procedure can adjust the ALQ to its correct value. It is also observed that in some cases when gas lift is switched off by setting ALQ to zero, and later in the schedule is switched back on again, it might not be possible to determine bhp from thp for low small ALQ values. Instead of aborting the gas lift optimization, we should try increasing ALQ until we get convergence or until the maximum ALQ for the well is reached.
2022-03-27 00:57:31 -05:00
std::pair<std::optional<double>,double> computeConvergedBhpAtThpLimitByMaybeIncreasingALQ_() const;
std::pair<std::optional<BasicRates>,double> computeInitialWellRates_() const;
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
std::optional<LimitedRates> computeLimitedWellRatesWithALQ_(double alq) const;
virtual BasicRates computeWellRates_(double bhp, bool bhp_is_limited, bool debug_output = true) const = 0;
std::optional<BasicRates> computeWellRatesWithALQ_(double alq) const;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
void debugCheckNegativeGradient_(double grad, double alq, double new_alq,
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
double oil_rate, double new_oil_rate,
double gas_rate, double new_gas_rate,
bool increase) const;
Limit well rates to honor group rates If a well is under a group that is limited by a target, it should use as little gaslift as possible. The reduction algorithm will reduce the gaslift of the well as long as the groups potential is above the groups target.
2022-02-01 05:55:04 -06:00
void debugPrintWellStateRates() const;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
void debugShowAlqIncreaseDecreaseCounts_();
void debugShowBhpAlqTable_();
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
void debugShowLimitingTargets_(const LimitedRates& rates) const;
Add gaslift optimization support for MSW. Implements gas lift optimization support for multisegmented wells (MSW).
2022-02-07 04:28:35 -06:00
void debugShowProducerControlMode() const;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
void debugShowStartIteration_(double alq, bool increase, double oil_rate);
void debugShowTargets_();
Improve debugging tools in gaslift code. Introduces a gaslift debugging variable in ALQState in WellState. This variable will persist between timesteps in contrast to when debugging variables are defined in GasLiftSingleWell, GasLiftGroupState, or GasLiftStage2. Currently only an integer variable debug_counter is added to ALQState, which can be used as follows: First debugging is switched on globally for BlackOilWellModel, GasLiftSingleWell, GasLiftGroupState, and GasLiftStage2 by setting glift_debug to a true value in BlackOilWellModelGeneric. Then, the following debugging code can be added to e.g. one of GasLiftSingleWell, GasLiftGroupState, or GasLiftStage2 : auto count = debugUpdateGlobalCounter_(); if (count == some_integer) { displayDebugMessage_("stop here"); } Here, the integer "some_integer" is determined typically by looking at the debugging output of a previous run. This can be done since the call to debugUpdateGlobalCounter_() will print out the current value of the counter and then increment the counter by one. And it will be easy to recognize these values in the debug ouput. If you find a place in the output that looks suspect, just take a note of the counter value in the output around that point and insert the value for "some_integer", then after recompiling the code with the desired value for "some_integer", it is now easy to set a breakpoint in GDB at the line displayDebugMessage_("stop here"). shown in the above snippet. This should improve the ability to quickly to set a breakpoint in GDB around at a given time and point in the simulation.
2022-01-23 13:37:26 -06:00
void displayDebugMessage_(const std::string& msg) const override;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
void displayWarning_(const std::string& warning);
std::pair<double, bool> getBhpWithLimit_(double bhp) const;
Refactor methods getXyzRateWithLimit_() Refactors getOilRateWithLimit_(), getGasRateWithLimit_(), and getWaterRateWithLimit_() in GasLiftSingleWellGeneric.cpp. The common part of the methods is split out into a new method called getRateWithLimit_(). The purpose of the refactorization is to reduce reptetive code and make the code easier to maintain.
2021-12-19 17:29:06 -06:00
std::pair<double, bool> getGasRateWithLimit_(
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
const BasicRates& rates) const;
Refactor some methods in GasLiftSingleWellGeneric. Refactor getOilRateWithGroupLimit_(), getGasRateWithGroupLimit_(), getWaterRateWithGroupLimit_(), and getLiquidRateWithGroupLimit_() into a single generic method called getRateWithGroupLimit_().
2021-12-16 18:52:34 -06:00
std::pair<double, bool> getGasRateWithGroupLimit_(
renaming and adding more comments based on review
2022-11-16 02:18:35 -06:00
double new_gas_rate, double gas_rate, const std::string& gr_name_dont_limit) const;
Well testing of gas lift wells Assign a maximum ALQ value to each GLIFT producer when doing well testing in beginTimeStep(). This allows the well to be considered open. Then, later in the timestep, when assemble() is called, the full gas lift optimization procedure can adjust the ALQ to its correct value. It is also observed that in some cases when gas lift is switched off by setting ALQ to zero, and later in the schedule is switched back on again, it might not be possible to determine bhp from thp for low small ALQ values. Instead of aborting the gas lift optimization, we should try increasing ALQ until we get convergence or until the maximum ALQ for the well is reached.
2022-03-27 00:57:31 -05:00
std::pair<std::optional<LimitedRates>,double> getInitialRatesWithLimit_() const;
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
LimitedRates getLimitedRatesFromRates_(const BasicRates& rates) const;
Refactor some methods in GasLiftSingleWellGeneric. Refactor getOilRateWithGroupLimit_(), getGasRateWithGroupLimit_(), getWaterRateWithGroupLimit_(), and getLiquidRateWithGroupLimit_() into a single generic method called getRateWithGroupLimit_().
2021-12-16 18:52:34 -06:00
std::tuple<double,double,bool,bool> getLiquidRateWithGroupLimit_(
Make parameters to getLiquidRateWithGroupLimit_() const To improve readability, we make the parameters of getLiquidRateWithGroupLimit_() const as discussed in https://github.com/OPM/opm-simulators/pull/3748
2021-12-20 16:19:40 -06:00
const double new_oil_rate, const double oil_rate,
renaming and adding more comments based on review
2022-11-16 02:18:35 -06:00
const double new_water_rate, const double water_rate, const std::string& gr_name_dont_limit) const;
Refactor methods getXyzRateWithLimit_() Refactors getOilRateWithLimit_(), getGasRateWithLimit_(), and getWaterRateWithLimit_() in GasLiftSingleWellGeneric.cpp. The common part of the methods is split out into a new method called getRateWithLimit_(). The purpose of the refactorization is to reduce reptetive code and make the code easier to maintain.
2021-12-19 17:29:06 -06:00
std::pair<double, bool> getOilRateWithGroupLimit_(
renaming and adding more comments based on review
2022-11-16 02:18:35 -06:00
double new_oil_rate, double oil_rate, const std::string& gr_name_dont_limit) const;
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
std::pair<double, bool> getOilRateWithLimit_(const BasicRates& rates) const;
std::pair<double, std::optional<Rate>> getOilRateWithLimit2_(
const BasicRates& rates) const;
Refactor methods getXyzRateWithLimit_() Refactors getOilRateWithLimit_(), getGasRateWithLimit_(), and getWaterRateWithLimit_() in GasLiftSingleWellGeneric.cpp. The common part of the methods is split out into a new method called getRateWithLimit_(). The purpose of the refactorization is to reduce reptetive code and make the code easier to maintain.
2021-12-19 17:29:06 -06:00
double getProductionTarget_(Rate rate) const;
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
double getRate_(Rate rate_type, const BasicRates& rates) const;
std::pair<double, std::optional<Rate>> getRateWithLimit_(
Rate rate_type, const BasicRates& rates) const;
Refactor methods getXyzRateWithLimit_() Refactors getOilRateWithLimit_(), getGasRateWithLimit_(), and getWaterRateWithLimit_() in GasLiftSingleWellGeneric.cpp. The common part of the methods is split out into a new method called getRateWithLimit_(). The purpose of the refactorization is to reduce reptetive code and make the code easier to maintain.
2021-12-19 17:29:06 -06:00
std::tuple<double, const std::string*, double> getRateWithGroupLimit_(
renaming and adding more comments based on review
2022-11-16 02:18:35 -06:00
Rate rate_type, const double new_rate, const double old_rate, const std::string& gr_name_dont_limit) const;
Refactor methods getXyzRateWithLimit_() Refactors getOilRateWithLimit_(), getGasRateWithLimit_(), and getWaterRateWithLimit_() in GasLiftSingleWellGeneric.cpp. The common part of the methods is split out into a new method called getRateWithLimit_(). The purpose of the refactorization is to reduce reptetive code and make the code easier to maintain.
2021-12-19 17:29:06 -06:00
std::pair<double, bool> getWaterRateWithGroupLimit_(
renaming and adding more comments based on review
2022-11-16 02:18:35 -06:00
double new_water_rate, double water_rate, const std::string& gr_name_dont_limit) const;
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
std::pair<double, bool> getWaterRateWithLimit_(const BasicRates& rates) const;
std::pair<double, std::optional<Rate>> getWaterRateWithLimit2_(
const BasicRates& rates) const;
Limit well rates to honor group rates If a well is under a group that is limited by a target, it should use as little gaslift as possible. The reduction algorithm will reduce the gaslift of the well as long as the groups potential is above the groups target.
2022-02-01 05:55:04 -06:00
BasicRates getWellStateRates_() const;
Refactor methods getXyzRateWithLimit_() Refactors getOilRateWithLimit_(), getGasRateWithLimit_(), and getWaterRateWithLimit_() in GasLiftSingleWellGeneric.cpp. The common part of the methods is split out into a new method called getRateWithLimit_(). The purpose of the refactorization is to reduce reptetive code and make the code easier to maintain.
2021-12-19 17:29:06 -06:00
bool hasProductionControl_(Rate rate) const;
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
std::pair<LimitedRates, double> increaseALQtoPositiveOilRate_(
double alq, const LimitedRates& orig_rates) const;
std::pair<LimitedRates, double> increaseALQtoMinALQ_(
double alq, const LimitedRates& orig_rates) const;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
void logSuccess_(double alq,
const int iteration_idx);
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
std::pair<LimitedRates, double> maybeAdjustALQbeforeOptimizeLoop_(
const LimitedRates& rates, double alq, bool increase) const;
reduce alq when alq + gas production target is violated
2022-02-02 07:17:06 -06:00
std::pair<LimitedRates, double> reduceALQtoGroupAlqLimits_(
double alq, const LimitedRates& rates) const;
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
std::pair<LimitedRates, double> reduceALQtoGroupTarget(
double alq, const LimitedRates& rates) const;
std::pair<LimitedRates, double> reduceALQtoWellTarget_(
double alq, const LimitedRates& rates) const;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
std::unique_ptr<GasLiftWellState> runOptimize1_();
std::unique_ptr<GasLiftWellState> runOptimize2_();
std::unique_ptr<GasLiftWellState> runOptimizeLoop_(bool increase);
adapt to renamed GasLift(Group|Well)
2023-01-09 06:50:05 -06:00
void setAlqMinRate_(const GasLiftWell& well);
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
std::unique_ptr<GasLiftWellState> tryIncreaseLiftGas_();
std::unique_ptr<GasLiftWellState> tryDecreaseLiftGas_();
Cleanup code in GasLiftSingleWellGeneric Introduces two new data types BasicRates and LimitedRates to capture oil, gas, and water rates, and whether they have been limited by well or group targets. This reduces the number of variables that are passed to and returned from various methods and thus makes the code easier to read.
2022-01-25 15:05:46 -06:00
void updateGroupRates_(
const LimitedRates& rates,
const LimitedRates& new_rates,
double delta_alq) const;
LimitedRates updateRatesToGroupLimits_(
pass group name to getRateWithGroupLimit to avoid checking for that
2022-10-26 01:51:38 -05:00
const BasicRates& rates, const LimitedRates& new_rates, const std::string& gr_name = "") const;
adapt to renamed GasLift(Group|Well)
2023-01-09 06:50:05 -06:00
void updateWellStateAlqFixedValue_(const GasLiftWell& well);
bool useFixedAlq_(const GasLiftWell& well);
Limit well rates to honor group rates If a well is under a group that is limited by a target, it should use as little gaslift as possible. The reduction algorithm will reduce the gaslift of the well as long as the groups potential is above the groups target.
2022-02-01 05:55:04 -06:00
void debugInfoGroupRatesExceedTarget(
Replace assert with warning. Replace assert with warning when group rates exceeds target.
2022-01-30 18:39:11 -06:00
Rate rate_type, const std::string& gr_name, double rate, double target) const;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
void warnMaxIterationsExceeded_();
const Well& ecl_well_;
const SummaryState& summary_state_;
Check group limits in gas lift stage 1. Check group limits in gas lift stage 1 to avoid adding too much ALQ which must anyway later be removed in stage 2. This should make the optimization more efficient for small ALQ increment values. Also adds MPI support.
2021-05-27 01:31:49 -05:00
GasLiftGroupInfo& group_info_;
Limit well rates to honor group rates If a well is under a group that is limited by a target, it should use as little gaslift as possible. The reduction algorithm will reduce the gaslift of the well as long as the groups potential is above the groups target.
2022-02-01 05:55:04 -06:00
const PhaseUsage& phase_usage_;
Check group limits in gas lift stage 1. Check group limits in gas lift stage 1 to avoid adding too much ALQ which must anyway later be removed in stage 2. This should make the optimization more efficient for small ALQ increment values. Also adds MPI support.
2021-05-27 01:31:49 -05:00
GLiftSyncGroups& sync_groups_;
GasLiftSingleWellGeneric.hpp: include WellProductionControls.hpp instead of Well.hpp
2023-01-18 04:56:21 -06:00
const WellProductionControls controls_;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
double increment_;
double max_alq_;
double min_alq_;
double orig_alq_;
double alpha_w_;
double alpha_g_;
double eco_grad_;
int gas_pos_;
int oil_pos_;
int water_pos_;
int max_iterations_;
std::string well_name_;
adapt to renamed GasLift(Group|Well)
2023-01-09 06:50:05 -06:00
const GasLiftWell* gl_well_;
GasLiftSingleWell: split typetag independent code to separate class
2021-05-20 07:20:27 -05:00
bool optimize_;
bool debug_limit_increase_decrease_;
bool debug_abort_if_decrease_and_oil_is_limited_ = false;
bool debug_abort_if_increase_and_gas_is_limited_ = false;
};
} // namespace Opm
#endif // OPM_GASLIFT_SINGLE_WELL_GENERIC_HEADER_INCLUDED
Reference in New Issue Copy Permalink