OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity

make group constrain check conditional

Browse Source
This commit is contained in:
Tor Harald Sandve
2020-01-16 09:52:03 +01:00
parent 91167ad405
commit f5c6bafd90
2 changed files with 110 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
opm/simulators/wells/BlackoilWellModel.hpp
View File

@@ -306,7 +306,7 @@ namespace Opm {
// xw to update Well State // xw to update Well State
void recoverWellSolutionAndUpdateWellState(const BVector& x); void recoverWellSolutionAndUpdateWellState(const BVector& x);
void updateWellControls(Opm::DeferredLogger& deferred_logger, const bool checkGroupControl); void updateWellControls(Opm::DeferredLogger& deferred_logger, const bool checkGroupControl, const bool checkCurrentGroupControl);
// setting the well_solutions_ based on well_state. // setting the well_solutions_ based on well_state.
void updatePrimaryVariables(Opm::DeferredLogger& deferred_logger); void updatePrimaryVariables(Opm::DeferredLogger& deferred_logger);
@@ -379,7 +379,7 @@ namespace Opm {
const Well& getWellEcl(const std::string& well_name) const; const Well& getWellEcl(const std::string& well_name) const;
void checkGroupConstraints(const Group& group, Opm::DeferredLogger& deferred_logger); void checkGroupConstraints(const Group& group, const bool checkCurrentControl, Opm::DeferredLogger& deferred_logger);
void actionOnBrokenConstraints(const Group& group, const Group::ExceedAction& exceed_action, const Group::ProductionCMode& newControl, const int reportStepIdx, Opm::DeferredLogger& deferred_logger); void actionOnBrokenConstraints(const Group& group, const Group::ExceedAction& exceed_action, const Group::ProductionCMode& newControl, const int reportStepIdx, Opm::DeferredLogger& deferred_logger);

201
opm/simulators/wells/BlackoilWellModel_impl.hpp
View File

@@ -834,7 +834,11 @@ namespace Opm {
calculateExplicitQuantities(local_deferredLogger); calculateExplicitQuantities(local_deferredLogger);
prepareTimeStep(local_deferredLogger); prepareTimeStep(local_deferredLogger);
} }
updateWellControls(local_deferredLogger, /*allow for switching to group controls*/true); // also check the current group control the first two iterations. The first itertion is needed for changes in group/well controls and closing of wells etc.
// a second check is needed for REIN and VREP controls since they depend on results from other wells.
// This check can probably be made more sofisticated, but this simple rule seems to work
bool checkCurrentGroupControls = (iterationIdx < 2);
updateWellControls(local_deferredLogger, /*allow for switching to group controls*/true, checkCurrentGroupControls);
// Set the well primary variables based on the value of well solutions // Set the well primary variables based on the value of well solutions
initPrimaryVariablesEvaluation(); initPrimaryVariablesEvaluation();
@@ -1052,7 +1056,7 @@ namespace Opm {
// are active wells anywhere in the global domain. // are active wells anywhere in the global domain.
if( wellsActive() ) if( wellsActive() )
{ {
updateWellControls(deferred_logger, /*don't switch group controls*/false); updateWellControls(deferred_logger, /*don't switch group controls*/false, /*don't check current group controls*/false);
initPrimaryVariablesEvaluation(); initPrimaryVariablesEvaluation();
} }
} catch (std::exception& e) { } catch (std::exception& e) {
@@ -1149,7 +1153,7 @@ namespace Opm {
template<typename TypeTag> template<typename TypeTag>
void void
BlackoilWellModel<TypeTag>:: BlackoilWellModel<TypeTag>::
updateWellControls(Opm::DeferredLogger& deferred_logger, const bool checkGroupControl) updateWellControls(Opm::DeferredLogger& deferred_logger, const bool checkGroupControl, const bool checkCurrentGroupControl)
{ {
// Even if there are no wells active locally, we cannot // Even if there are no wells active locally, we cannot
// return as the DeferredLogger uses global communication. // return as the DeferredLogger uses global communication.
@@ -1161,7 +1165,7 @@ namespace Opm {
// update group controls // update group controls
if (checkGroupControl) { if (checkGroupControl) {
checkGroupConstraints(fieldGroup, deferred_logger); checkGroupConstraints(fieldGroup, checkCurrentGroupControl, deferred_logger);
} }
for (const auto& well : well_container_) { for (const auto& well : well_container_) {
@@ -1676,15 +1680,16 @@ namespace Opm {
template<typename TypeTag> template<typename TypeTag>
void void
BlackoilWellModel<TypeTag>:: BlackoilWellModel<TypeTag>::
checkGroupConstraints(const Group& group, Opm::DeferredLogger& deferred_logger) { checkGroupConstraints(const Group& group, const bool checkCurrentControl, Opm::DeferredLogger& deferred_logger) {
const int reportStepIdx = ebosSimulator_.episodeIndex(); const int reportStepIdx = ebosSimulator_.episodeIndex();
const auto& summaryState = ebosSimulator_.vanguard().summaryState(); const auto& summaryState = ebosSimulator_.vanguard().summaryState();
const auto& comm = ebosSimulator_.vanguard().grid().comm(); const auto& comm = ebosSimulator_.vanguard().grid().comm();
auto& well_state = well_state_; auto& well_state = well_state_;
if (group.isInjectionGroup()) if (group.isInjectionGroup())
{ {
const Group::InjectionCMode& currentControl = well_state.currentInjectionGroupControl(group.name());
const auto controls = group.injectionControls(summaryState); const auto controls = group.injectionControls(summaryState);
int phasePos; int phasePos;
switch (controls.phase) { switch (controls.phase) {
@@ -1707,80 +1712,81 @@ namespace Opm {
throw("Expected WATER, OIL or GAS as type for group injector: " + group.name()); throw("Expected WATER, OIL or GAS as type for group injector: " + group.name());
} }
if (group.has_control(Group::InjectionCMode::NONE))
{
// do nothing??
}
if (group.has_control(Group::InjectionCMode::RATE)) if (group.has_control(Group::InjectionCMode::RATE))
{ {
double current_rate = 0.0; if (checkCurrentControl || currentControl != Group::InjectionCMode::RATE)
current_rate += wellGroupHelpers::sumWellRates(group, schedule(), well_state, reportStepIdx, phasePos, /*isInjector*/true); {
double current_rate = 0.0;
current_rate += wellGroupHelpers::sumWellRates(group, schedule(), well_state, reportStepIdx, phasePos, /*isInjector*/true);
// sum over all nodes // sum over all nodes
current_rate = comm.sum(current_rate); current_rate = comm.sum(current_rate);
if (controls.surface_max_rate < current_rate) { if (controls.surface_max_rate < current_rate) {
actionOnBrokenConstraints(group, Group::InjectionCMode::RATE, reportStepIdx, deferred_logger); actionOnBrokenConstraints(group, Group::InjectionCMode::RATE, reportStepIdx, deferred_logger);
}
} }
} }
if (group.has_control(Group::InjectionCMode::RESV)) if (group.has_control(Group::InjectionCMode::RESV))
{ {
double current_rate = 0.0; if (checkCurrentControl || currentControl != Group::InjectionCMode::RESV)
current_rate += wellGroupHelpers::sumWellResRates(group, schedule(), well_state, reportStepIdx, phasePos, /*isInjector*/true); {
// sum over all nodes double current_rate = 0.0;
current_rate = comm.sum(current_rate); current_rate += wellGroupHelpers::sumWellResRates(group, schedule(), well_state, reportStepIdx, phasePos, /*isInjector*/true);
// sum over all nodes
current_rate = comm.sum(current_rate);
if (controls.resv_max_rate < current_rate) { if (controls.resv_max_rate < current_rate) {
actionOnBrokenConstraints(group, Group::InjectionCMode::RESV, reportStepIdx, deferred_logger); actionOnBrokenConstraints(group, Group::InjectionCMode::RESV, reportStepIdx, deferred_logger);
} } }
}}
if (group.has_control(Group::InjectionCMode::REIN)) if (group.has_control(Group::InjectionCMode::REIN))
{ {
double production_Rate = 0.0; if (checkCurrentControl || currentControl != Group::InjectionCMode::REIN)
const Group& groupRein = schedule().getGroup(controls.reinj_group, reportStepIdx); {
production_Rate += wellGroupHelpers::sumWellRates(groupRein, schedule(), well_state, reportStepIdx, phasePos, /*isInjector*/false); double production_Rate = 0.0;
const Group& groupRein = schedule().getGroup(controls.reinj_group, reportStepIdx);
production_Rate += wellGroupHelpers::sumWellRates(groupRein, schedule(), well_state, reportStepIdx, phasePos, /*isInjector*/false);
// sum over all nodes // sum over all nodes
production_Rate = comm.sum(production_Rate); production_Rate = comm.sum(production_Rate);
double current_rate = 0.0; double current_rate = 0.0;
current_rate += wellGroupHelpers::sumWellRates(group, schedule(), well_state, reportStepIdx, phasePos, /*isInjector*/true); current_rate += wellGroupHelpers::sumWellRates(group, schedule(), well_state, reportStepIdx, phasePos, /*isInjector*/true);
// sum over all nodes // sum over all nodes
current_rate = comm.sum(current_rate); current_rate = comm.sum(current_rate);
if (controls.target_reinj_fraction*production_Rate < current_rate) { if (controls.target_reinj_fraction*production_Rate < current_rate) {
actionOnBrokenConstraints(group, Group::InjectionCMode::REIN, reportStepIdx, deferred_logger); actionOnBrokenConstraints(group, Group::InjectionCMode::REIN, reportStepIdx, deferred_logger);
} } }
}}
if (group.has_control(Group::InjectionCMode::VREP)) if (group.has_control(Group::InjectionCMode::VREP))
{ {
double voidage_rate = 0.0; if (checkCurrentControl || currentControl != Group::InjectionCMode::VREP)
const Group& groupVoidage = schedule().getGroup(controls.voidage_group, reportStepIdx); {
voidage_rate += wellGroupHelpers::sumWellResRates(groupVoidage, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Aqua], false); double voidage_rate = 0.0;
voidage_rate += wellGroupHelpers::sumWellResRates(groupVoidage, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Liquid], false); const Group& groupVoidage = schedule().getGroup(controls.voidage_group, reportStepIdx);
voidage_rate += wellGroupHelpers::sumWellResRates(groupVoidage, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Vapour], false); voidage_rate += wellGroupHelpers::sumWellResRates(groupVoidage, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Aqua], false);
voidage_rate += wellGroupHelpers::sumWellResRates(groupVoidage, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Liquid], false);
voidage_rate += wellGroupHelpers::sumWellResRates(groupVoidage, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Vapour], false);
// sum over all nodes // sum over all nodes
voidage_rate = comm.sum(voidage_rate); voidage_rate = comm.sum(voidage_rate);
double total_rate = 0.0; double total_rate = 0.0;
total_rate += wellGroupHelpers::sumWellResRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Aqua], true); total_rate += wellGroupHelpers::sumWellResRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Aqua], true);
total_rate += wellGroupHelpers::sumWellResRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Liquid], true); total_rate += wellGroupHelpers::sumWellResRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Liquid], true);
total_rate += wellGroupHelpers::sumWellResRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Vapour], true); total_rate += wellGroupHelpers::sumWellResRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Vapour], true);
// sum over all nodes // sum over all nodes
total_rate = comm.sum(total_rate); total_rate = comm.sum(total_rate);
if (controls.target_void_fraction*voidage_rate < total_rate) { if (controls.target_void_fraction*voidage_rate < total_rate) {
actionOnBrokenConstraints(group, Group::InjectionCMode::VREP, reportStepIdx, deferred_logger); actionOnBrokenConstraints(group, Group::InjectionCMode::VREP, reportStepIdx, deferred_logger);
}
} }
} }
if (group.has_control(Group::InjectionCMode::FLD))
{
// do nothing???
//OPM_THROW(std::runtime_error, "Group " + group.name() + "FLD control for injecting groups not implemented" );
}
// Handle GCONSALE // Handle GCONSALE
if (schedule().gConSale(reportStepIdx).has(group.name())) { if (schedule().gConSale(reportStepIdx).has(group.name())) {
@@ -1820,13 +1826,12 @@ namespace Opm {
if (group.isProductionGroup()) { if (group.isProductionGroup()) {
const auto controls = group.productionControls(summaryState); const auto controls = group.productionControls(summaryState);
const Group::ProductionCMode& currentControl = well_state.currentProductionGroupControl(group.name());
if (group.has_control(Group::ProductionCMode::NONE))
{
}
if (group.has_control(Group::ProductionCMode::ORAT)) if (group.has_control(Group::ProductionCMode::ORAT))
{ {
if (checkCurrentControl || currentControl != Group::ProductionCMode::ORAT)
{
double current_rate = 0.0; double current_rate = 0.0;
current_rate += wellGroupHelpers::sumWellRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Liquid], false); current_rate += wellGroupHelpers::sumWellRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Liquid], false);
@@ -1836,42 +1841,52 @@ namespace Opm {
if (controls.oil_target < current_rate ) { if (controls.oil_target < current_rate ) {
actionOnBrokenConstraints(group, controls.exceed_action, Group::ProductionCMode::ORAT, reportStepIdx, deferred_logger); actionOnBrokenConstraints(group, controls.exceed_action, Group::ProductionCMode::ORAT, reportStepIdx, deferred_logger);
} }
}
} }
if (group.has_control(Group::ProductionCMode::WRAT)) if (group.has_control(Group::ProductionCMode::WRAT))
{ {
double current_rate = 0.0; if (checkCurrentControl || currentControl != Group::ProductionCMode::WRAT)
current_rate += wellGroupHelpers::sumWellRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Aqua], false); {
double current_rate = 0.0;
current_rate += wellGroupHelpers::sumWellRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Aqua], false);
// sum over all nodes // sum over all nodes
current_rate = comm.sum(current_rate); current_rate = comm.sum(current_rate);
if (controls.water_target < current_rate ) { if (controls.water_target < current_rate ) {
actionOnBrokenConstraints(group, controls.exceed_action, Group::ProductionCMode::WRAT, reportStepIdx, deferred_logger); actionOnBrokenConstraints(group, controls.exceed_action, Group::ProductionCMode::WRAT, reportStepIdx, deferred_logger);
}
} }
} }
if (group.has_control(Group::ProductionCMode::GRAT)) if (group.has_control(Group::ProductionCMode::GRAT))
{ {
double current_rate = 0.0; if (checkCurrentControl || currentControl != Group::ProductionCMode::GRAT)
current_rate += wellGroupHelpers::sumWellRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Vapour], false); {
double current_rate = 0.0;
current_rate += wellGroupHelpers::sumWellRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Vapour], false);
// sum over all nodes // sum over all nodes
current_rate = comm.sum(current_rate); current_rate = comm.sum(current_rate);
if (controls.gas_target < current_rate ) { if (controls.gas_target < current_rate ) {
actionOnBrokenConstraints(group, controls.exceed_action, Group::ProductionCMode::GRAT, reportStepIdx, deferred_logger); actionOnBrokenConstraints(group, controls.exceed_action, Group::ProductionCMode::GRAT, reportStepIdx, deferred_logger);
}
} }
} }
if (group.has_control(Group::ProductionCMode::LRAT)) if (group.has_control(Group::ProductionCMode::LRAT))
{ {
double current_rate = 0.0; if (checkCurrentControl || currentControl != Group::ProductionCMode::LRAT)
current_rate += wellGroupHelpers::sumWellRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Liquid], false); {
current_rate += wellGroupHelpers::sumWellRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Aqua], false); double current_rate = 0.0;
current_rate += wellGroupHelpers::sumWellRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Liquid], false);
current_rate += wellGroupHelpers::sumWellRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Aqua], false);
// sum over all nodes // sum over all nodes
current_rate = comm.sum(current_rate); current_rate = comm.sum(current_rate);
if (controls.liquid_target < current_rate ) { if (controls.liquid_target < current_rate ) {
actionOnBrokenConstraints(group, controls.exceed_action, Group::ProductionCMode::LRAT, reportStepIdx, deferred_logger); actionOnBrokenConstraints(group, controls.exceed_action, Group::ProductionCMode::LRAT, reportStepIdx, deferred_logger);
}
} }
} }
@@ -1882,16 +1897,19 @@ namespace Opm {
} }
if (group.has_control(Group::ProductionCMode::RESV)) if (group.has_control(Group::ProductionCMode::RESV))
{ {
double current_rate = 0.0; if (checkCurrentControl || currentControl != Group::ProductionCMode::RESV)
current_rate += wellGroupHelpers::sumWellResRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Aqua], true); {
current_rate += wellGroupHelpers::sumWellResRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Liquid], true); double current_rate = 0.0;
current_rate += wellGroupHelpers::sumWellResRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Vapour], true); current_rate += wellGroupHelpers::sumWellResRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Aqua], true);
current_rate += wellGroupHelpers::sumWellResRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Liquid], true);
current_rate += wellGroupHelpers::sumWellResRates(group, schedule(), well_state, reportStepIdx, phase_usage_.phase_pos[BlackoilPhases::Vapour], true);
// sum over all nodes // sum over all nodes
current_rate = comm.sum(current_rate); current_rate = comm.sum(current_rate);
if (controls.resv_target < current_rate ) { if (controls.resv_target < current_rate ) {
actionOnBrokenConstraints(group, controls.exceed_action, Group::ProductionCMode::RESV, reportStepIdx, deferred_logger); actionOnBrokenConstraints(group, controls.exceed_action, Group::ProductionCMode::RESV, reportStepIdx, deferred_logger);
}
} }
} }
@@ -1899,10 +1917,7 @@ namespace Opm {
{ {
OPM_DEFLOG_THROW(std::runtime_error, "Group " + group.name() + "PRBL control for production groups not implemented", deferred_logger); OPM_DEFLOG_THROW(std::runtime_error, "Group " + group.name() + "PRBL control for production groups not implemented", deferred_logger);
} }
if (group.has_control(Group::ProductionCMode::FLD))
{
// do nothing???
}
} else { } else {
//neither production or injecting group FIELD? //neither production or injecting group FIELD?
@@ -1910,7 +1925,7 @@ namespace Opm {
// call recursively down the group hiearchy // call recursively down the group hiearchy
for (const std::string& groupName : group.groups()) { for (const std::string& groupName : group.groups()) {
checkGroupConstraints( schedule().getGroup(groupName, reportStepIdx), deferred_logger); checkGroupConstraints( schedule().getGroup(groupName, reportStepIdx), checkCurrentControl, deferred_logger);
} }