OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2025-02-10 02:25:33 -06:00
Code Issues Packages Projects Releases Wiki Activity
faf0ab8ee1
opm-simulators/opm/simulators/wells/GasLiftGroupInfo.hpp

258 lines
10 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
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
Move opm/core/props to opm/simulators/utils The opm/core directory is no longer meaningful, and it contains only components which might collectively be described as simulator utilities.
2024-06-25 03:20:41 -05:00
#include <opm/simulators/utils/BlackoilPhases.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 <map>
GasLiftXXX: clean up includes in particular avoid including GasLiftStage2.hpp in BlackoilWellModel
2023-12-11 08:54:28 -06:00
#include <optional>
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 <string>
GasLiftXXX: clean up includes in particular avoid including GasLiftStage2.hpp in BlackoilWellModel
2023-12-11 08:54:28 -06:00
#include <tuple>
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 <vector>
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
namespace Opm {
avoid GasLiftOpt.hpp where possible and add where necessary
2023-01-09 06:54:30 -06:00
GasLiftXXX: clean up includes in particular avoid including GasLiftStage2.hpp in BlackoilWellModel
2023-12-11 08:54:28 -06:00
class DeferredLogger;
avoid GasLiftOpt.hpp where possible and add where necessary
2023-01-09 06:54:30 -06:00
class GasLiftOpt;
GasLiftXXX: clean up includes in particular avoid including GasLiftStage2.hpp in BlackoilWellModel
2023-12-11 08:54:28 -06:00
class Group;
GroupState: template Scalar type
2024-02-17 11:13:46 -06:00
template<class Scalar> class GroupState;
GasLiftXXX: clean up includes in particular avoid including GasLiftStage2.hpp in BlackoilWellModel
2023-12-11 08:54:28 -06:00
class Schedule;
GasLiftGroupInfo.hpp: forward SummaryState
2023-01-11 07:40:05 -06:00
class SummaryState;
GasLiftGroupInfo.hpp: forward Well
2023-01-12 02:30:14 -06:00
class Well;
WellState: template Scalar type
2024-02-17 11:13:46 -06:00
template<class Scalar> class WellState;
avoid GasLiftOpt.hpp where possible and add where necessary
2023-01-09 06:54:30 -06:00
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
template<class Scalar>
class GasLiftGroupInfo : public GasLiftCommon<Scalar>
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 =
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
std::map<std::string, std::vector<std::pair<std::string,Scalar>>>;
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 GroupRateMap =
std::map<std::string, GroupRates>;
using GroupIdxMap = std::map<std::string, int>;
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>;
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;
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
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
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: template Scalar type
2024-02-19 08:46:29 -06:00
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,
WellState<Scalar>& well_state,
const GroupState<Scalar>& group_state,
const Parallel::Communication& comm,
bool glift_debug);
std::vector<std::pair<std::string,Scalar>>&
getWellGroups(const std::string& well_name);
Scalar alqRate(const std::string& group_name);
Scalar gasRate(const std::string& group_name) const;
Scalar gasPotential(const std::string& group_name) const;
Scalar waterPotential(const std::string& group_name) const;
Scalar oilPotential(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);
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
Scalar getRate(Rate rate_type, const std::string& group_name) const;
Scalar getPotential(Rate rate_type, const std::string& group_name) const;
std::tuple<Scalar,Scalar,Scalar,Scalar> getRates(const int group_idx) const;
std::optional<Scalar> gasTarget(const std::string& group_name) const;
std::optional<Scalar> getTarget(Rate rate_type, const std::string& group_name) const;
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
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();
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
std::optional<Scalar> liquidTarget(const std::string& group_name) const;
std::optional<Scalar> maxAlq(const std::string& group_name);
std::optional<Scalar> maxTotalGasRate(const std::string& group_name);
Scalar oilRate(const std::string& group_name) const;
std::optional<Scalar> 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);
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
Scalar waterRate(const std::string& group_name) const;
std::optional<Scalar> 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,
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
Scalar delta_oil,
Scalar delta_gas,
Scalar delta_water,
Scalar delta_alq);
void updateRate(int idx,
Scalar oil_rate,
Scalar gas_rate,
Scalar water_rate,
Scalar 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_; }
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06: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
bool checkDoGasLiftOptimization_(const std::string& well_name);
bool checkNewtonIterationIdxOk_(const std::string& well_name);
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
void debugDisplayWellContribution_(const std::string& gr_name,
const std::string& well_name,
Scalar eff_factor,
Scalar well_oil_rate,
Scalar well_gas_rate,
Scalar well_water_rate,
Scalar well_alq,
Scalar oil_rate,
Scalar gas_rate,
Scalar water_rate,
Scalar alq) 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 debugDisplayUpdatedGroupRates(const std::string& name,
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
Scalar oil_rate,
Scalar gas_rate,
Scalar water_rate,
Scalar alq) 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 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);
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
std::tuple<Scalar, Scalar, Scalar, Scalar, Scalar, Scalar>
getProducerWellRates_(const Well* well, const int index);
std::tuple<Scalar, Scalar, Scalar, Scalar, Scalar, Scalar, Scalar>
initializeGroupRatesRecursive_(const Group &group);
void initializeWell2GroupMapRecursive_(const Group& group,
std::vector<std::string>& group_names,
std::vector<Scalar>& group_efficiency,
Scalar cur_efficiency);
void updateGroupIdxMap_(const std::string& group_name);
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 {
public:
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
GroupRates(Scalar oil_rate,
Scalar gas_rate,
Scalar water_rate,
Scalar alq,
Scalar oil_potential,
Scalar gas_potential,
Scalar water_potential,
std::optional<Scalar> oil_target,
std::optional<Scalar> gas_target,
std::optional<Scalar> water_target,
std::optional<Scalar> liquid_target,
std::optional<Scalar> total_gas,
std::optional<Scalar> max_alq)
: oil_rate_{oil_rate}
, gas_rate_{gas_rate}
, water_rate_{water_rate}
, alq_{alq}
, oil_potential_{oil_potential}
, gas_potential_{gas_potential}
, water_potential_{water_potential}
, oil_target_{oil_target}
, gas_target_{gas_target}
, water_target_{water_target}
, liquid_target_{liquid_target}
, total_gas_{total_gas}
, max_alq_{max_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
{}
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
Scalar alq() const { return alq_; }
void assign(Scalar oil_rate,
Scalar gas_rate,
Scalar water_rate,
Scalar 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;
}
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
Scalar gasRate() const { return gas_rate_; }
Scalar waterRate() const { return water_rate_; }
std::optional<Scalar> gasTarget() const { return gas_target_; }
std::optional<Scalar> waterTarget() const { return water_target_; }
std::optional<Scalar> maxAlq() const { return max_alq_; }
std::optional<Scalar > maxTotalGasRate() const { return total_gas_; }
Scalar oilRate() const { return oil_rate_; }
std::optional<Scalar> oilTarget() const { return oil_target_; }
std::optional<Scalar> liquidTarget() const { return liquid_target_; }
Scalar oilPotential() const { return oil_potential_; }
Scalar gasPotential() const { return gas_potential_; }
Scalar waterPotential() const { return water_potential_; }
void update(Scalar delta_oil,
Scalar delta_gas,
Scalar delta_water,
Scalar 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;
renaming and adding more comments based on review
2022-11-16 02:18:35 -06:00
// Note. We don't updata the potentials at this point. They
// are only needed initially.
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: template Scalar type
2024-02-19 08:46:29 -06:00
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
private:
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
Scalar oil_rate_;
Scalar gas_rate_;
Scalar water_rate_;
Scalar alq_;
Scalar oil_potential_;
Scalar gas_potential_;
Scalar water_potential_;
std::optional<Scalar> oil_target_;
std::optional<Scalar> gas_target_;
std::optional<Scalar> water_target_;
std::optional<Scalar> liquid_target_;
std::optional<Scalar> total_gas_;
std::optional<Scalar> max_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
};
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -06:00
GLiftEclWells& ecl_wells_;
const Schedule& schedule_;
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
const int report_step_idx_;
const int iteration_idx_;
GasLiftGroupInfo: template Scalar type
2024-02-19 08:46:29 -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
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