OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2025-01-01 03:56:55 -06:00
Code Issues Packages Projects Releases Wiki Activity
68b604c85f
opm-simulators/opm/simulators/wells/GasLiftGroupInfo.hpp

218 lines
8.7 KiB
C++
Raw Normal View History

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
/*
Copyright 2021 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_GROUP_INFO_HEADER_INCLUDED
#define OPM_GASLIFT_GROUP_INFO_HEADER_INCLUDED
#include <dune/common/version.hh>
#include <dune/common/parallel/mpihelper.hh>
#include <opm/core/props/BlackoilPhases.hpp>
#include <opm/models/utils/propertysystem.hh>
#include <opm/models/utils/parametersystem.hh>
Downstream filesystem reorganisation in opm-common
2021-12-14 01:30:15 -06:00
#include <opm/input/eclipse/Schedule/Schedule.hpp>
#include <opm/input/eclipse/Schedule/Well/Well.hpp>
#include <opm/input/eclipse/Schedule/Group/Group.hpp>
#include <opm/input/eclipse/Schedule/GasLiftOpt.hpp>
#include <opm/input/eclipse/Schedule/SummaryState.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>
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/WellState.hpp>
#include <opm/simulators/utils/DeferredLogger.hpp>
#include <algorithm>
#include <map>
#include <string>
#include <vector>
#include <fmt/format.h>
namespace Opm
{
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 GasLiftGroupInfo : public GasLiftCommon
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
{
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
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
class GroupRates;
// NOTE: In the Well2GroupMap below, in the std::vector value we store
// pairs of group names and efficiency factors. The efficiency factors
// are the product of the wells efficiency factor and all the efficiency
// factors of the child groups of the group all the way down
// to the well group.
using Well2GroupMap =
std::map<std::string, std::vector<std::pair<std::string,double>>>;
using GroupRateMap =
std::map<std::string, GroupRates>;
using GroupIdxMap = std::map<std::string, int>;
Add missing header file to GasLiftGroupInfo.cpp GasLiftGroupInfo.cpp did not include "config.h" which caused HAVE_MPI to be undefined causing the file to be compiled with Dune::Communication<No_Comm> instead of with Dune::Communication<MPI_Comm>. Which later caused linking problems with files that used MPI.
2021-06-22 02:52:22 -05:00
#if DUNE_VERSION_NEWER(DUNE_COMMON, 2, 7)
Replacing use of MPI_COMM_WORLD with a variable communicator.
2021-05-25 05:57:11 -05:00
using Communication = Dune::Communication<Dune::MPIHelper::MPICommunicator>;
Add missing header file to GasLiftGroupInfo.cpp GasLiftGroupInfo.cpp did not include "config.h" which caused HAVE_MPI to be undefined causing the file to be compiled with Dune::Communication<No_Comm> instead of with Dune::Communication<MPI_Comm>. Which later caused linking problems with files that used MPI.
2021-06-22 02:52:22 -05:00
#else
Replacing use of MPI_COMM_WORLD with a variable communicator.
2021-05-25 05:57:11 -05:00
using Communication = Dune::CollectiveCommunication<Dune::MPIHelper::MPICommunicator>;
Add missing header file to GasLiftGroupInfo.cpp GasLiftGroupInfo.cpp did not include "config.h" which caused HAVE_MPI to be undefined causing the file to be compiled with Dune::Communication<No_Comm> instead of with Dune::Communication<MPI_Comm>. Which later caused linking problems with files that used MPI.
2021-06-22 02:52:22 -05:00
#endif
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
// TODO: same definition with WellInterface, and
// WellState eventually they should go to a common header file.
static const int Water = BlackoilPhases::Aqua;
static const int Oil = BlackoilPhases::Liquid;
static const int Gas = BlackoilPhases::Vapour;
public:
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
enum class Rate {oil, gas, water, liquid};
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 GLiftEclWells = std::map<std::string,std::pair<const Well *,int>>;
GasLiftGroupInfo(
GLiftEclWells& ecl_wells,
const Schedule& schedule,
const SummaryState& summary_state,
const int report_step_idx,
const int iteration_idx,
const PhaseUsage& phase_usage,
DeferredLogger& deferred_logger,
Add missing header file to GasLiftGroupInfo.cpp GasLiftGroupInfo.cpp did not include "config.h" which caused HAVE_MPI to be undefined causing the file to be compiled with Dune::Communication<No_Comm> instead of with Dune::Communication<MPI_Comm>. Which later caused linking problems with files that used MPI.
2021-06-22 02:52:22 -05:00
WellState& well_state,
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
const Parallel::Communication& comm,
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
std::vector<std::pair<std::string,double>>& getWellGroups(
const std::string& well_name);
double alqRate(const std::string& group_name);
Made some methods in GasLiftGroupInfo const This is in agreement with C++ Core Guidelines. A member function should be marked const unless it changes the object’s observable state. This gives a more precise statement of design intent, better readability, more errors caught by the compiler, and sometimes more optimization opportunities.
2021-12-21 16:24:58 -06:00
double gasRate(const std::string& group_name) const;
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
int getGroupIdx(const std::string& group_name);
Made some methods in GasLiftGroupInfo const This is in agreement with C++ Core Guidelines. A member function should be marked const unless it changes the object’s observable state. This gives a more precise statement of design intent, better readability, more errors caught by the compiler, and sometimes more optimization opportunities.
2021-12-21 16:24:58 -06:00
double getRate(Rate rate_type, const std::string& group_name) const;
std::tuple<double,double,double,double> getRates(const int group_idx) const;
std::optional<double> gasTarget(const std::string& group_name) const;
std::optional<double> getTarget(
Rate rate_type, const std::string& group_name) const;
const std::string& groupIdxToName(int group_idx) 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
bool hasAnyTarget(const std::string& group_name) const;
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
bool hasWell(const std::string& well_name);
Add missing header file to GasLiftGroupInfo.cpp GasLiftGroupInfo.cpp did not include "config.h" which caused HAVE_MPI to be undefined causing the file to be compiled with Dune::Communication<No_Comm> instead of with Dune::Communication<MPI_Comm>. Which later caused linking problems with files that used MPI.
2021-06-22 02:52:22 -05:00
void initialize();
Made some methods in GasLiftGroupInfo const This is in agreement with C++ Core Guidelines. A member function should be marked const unless it changes the object’s observable state. This gives a more precise statement of design intent, better readability, more errors caught by the compiler, and sometimes more optimization opportunities.
2021-12-21 16:24:58 -06:00
std::optional<double> liquidTarget(const std::string& group_name) const;
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
std::optional<double> maxAlq(const std::string& group_name);
Add support for maximum total gas (alq + gas rate) in GLIFTOPT Dont increase gaslift if the groups alq + gas production rate is above the given target
2022-02-02 03:28:13 -06:00
std::optional<double> maxTotalGasRate(const std::string& group_name);
Made some methods in GasLiftGroupInfo const This is in agreement with C++ Core Guidelines. A member function should be marked const unless it changes the object’s observable state. This gives a more precise statement of design intent, better readability, more errors caught by the compiler, and sometimes more optimization opportunities.
2021-12-21 16:24:58 -06:00
double oilRate(const std::string& group_name) const;
std::optional<double> oilTarget(const std::string& group_name) 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
static const std::string rateToString(Rate rate);
Made some methods in GasLiftGroupInfo const This is in agreement with C++ Core Guidelines. A member function should be marked const unless it changes the object’s observable state. This gives a more precise statement of design intent, better readability, more errors caught by the compiler, and sometimes more optimization opportunities.
2021-12-21 16:24:58 -06:00
double waterRate(const std::string& group_name) const;
std::optional<double> waterTarget(const std::string& group_name) const;
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
void update(const std::string& well_name,
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
double delta_oil, double delta_gas, double delta_water, double delta_alq);
void updateRate(int idx, double oil_rate, double gas_rate, double water_rate, double alq);
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 Well2GroupMap& wellGroupMap() { return well_group_map_; }
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
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
bool checkDoGasLiftOptimization_(const std::string& well_name);
bool checkNewtonIterationIdxOk_(const std::string& well_name);
Add gaslift optimization support for MSW. Implements gas lift optimization support for multisegmented wells (MSW).
2022-02-07 04:28:35 -06:00
void debugDisplayWellContribution_(
const std::string& gr_name, const std::string& well_name,
double eff_factor,
double well_oil_rate, double well_gas_rate, double well_water_rate,
double well_alq,
double oil_rate, double gas_rate, double water_rate,
double alq
) const;
void debugDisplayUpdatedGroupRates(const std::string& name,
double oil_rate, double gas_rate, double water_rate, double alq) const;
void debugEndInitializeGroup(const std::string& name) const;
void debugStartInitializeGroup(const std::string& name) 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
void displayDebugMessage_(const std::string& msg) const override;
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
void displayDebugMessage_(const std::string& msg, const std::string& well_name);
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
std::tuple<double, double, double> getProducerWellRates_(const int index);
std::tuple<double, double, double, double>
Add missing header file to GasLiftGroupInfo.cpp GasLiftGroupInfo.cpp did not include "config.h" which caused HAVE_MPI to be undefined causing the file to be compiled with Dune::Communication<No_Comm> instead of with Dune::Communication<MPI_Comm>. Which later caused linking problems with files that used MPI.
2021-06-22 02:52:22 -05:00
initializeGroupRatesRecursive_(const Group &group);
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
void initializeWell2GroupMapRecursive_(
const Group& group, std::vector<std::string>& group_names,
std::vector<double>& group_efficiency, double cur_efficiency);
void updateGroupIdxMap_(const std::string& group_name);
class GroupRates {
public:
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
GroupRates( double oil_rate, double gas_rate, double water_rate, double alq,
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
std::optional<double> oil_target,
std::optional<double> gas_target,
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
std::optional<double> water_target,
std::optional<double> liquid_target,
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
std::optional<double> total_gas,
std::optional<double> max_alq
) :
oil_rate_{oil_rate},
gas_rate_{gas_rate},
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
water_rate_{water_rate},
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
alq_{alq},
oil_target_{oil_target},
gas_target_{gas_target},
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
water_target_{water_target},
liquid_target_{liquid_target},
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
total_gas_{total_gas},
max_alq_{max_alq}
{}
double alq() const { return alq_; }
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
void assign(double oil_rate, double gas_rate, double water_rate, double alq)
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
{
oil_rate_ = oil_rate;
gas_rate_ = gas_rate;
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
water_rate_ = water_rate;
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
alq_ = alq;
}
double gasRate() const { return gas_rate_; }
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
double waterRate() const { return water_rate_; }
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
std::optional<double> gasTarget() const { return gas_target_; }
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
std::optional<double> waterTarget() const { return water_target_; }
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
std::optional<double> maxAlq() const { return max_alq_; }
Add support for maximum total gas (alq + gas rate) in GLIFTOPT Dont increase gaslift if the groups alq + gas production rate is above the given target
2022-02-02 03:28:13 -06:00
std::optional<double> maxTotalGasRate() const { return total_gas_; }
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
double oilRate() const { return oil_rate_; }
std::optional<double> oilTarget() const { return oil_target_; }
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
std::optional<double> liquidTarget() const { return liquid_target_; }
void update(double delta_oil, double delta_gas, double delta_water, double delta_alq)
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
{
oil_rate_ += delta_oil;
gas_rate_ += delta_gas;
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
water_rate_ += delta_water;
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
alq_ += delta_alq;
}
private:
double oil_rate_;
double gas_rate_;
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
double water_rate_;
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
double alq_;
std::optional<double> oil_target_;
std::optional<double> gas_target_;
Check group production LRAT and WRAT targets
2021-11-04 07:12:05 -05:00
std::optional<double> water_target_;
std::optional<double> liquid_target_;
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
std::optional<double> total_gas_;
std::optional<double> max_alq_;
};
GLiftEclWells &ecl_wells_;
const Schedule &schedule_;
const SummaryState &summary_state_;
const int report_step_idx_;
const int iteration_idx_;
const PhaseUsage &phase_usage_;
const GasLiftOpt& glo_;
GroupRateMap group_rate_map_;
Well2GroupMap well_group_map_;
GroupIdxMap group_idx_;
int next_group_idx_ = 0;
// Optimize only wells under THP control
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
bool optimize_only_thp_wells_ = false;
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
};
} // namespace Opm
#endif // OPM_GASLIFT_GROUP_INFO_INCLUDED
Reference in New Issue Copy Permalink