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

WellGroupHelpers: template Scalar type

Browse Source
This commit is contained in:
Arne Morten Kvarving 2024-02-19 13:47:25 +01:00
parent 522625aca8
commit aa03d06c4d
10 changed files with 683 additions and 462 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

202
opm/simulators/wells/BlackoilWellModelConstraints.cpp
View File

@ -74,7 +74,12 @@ checkGroupInjectionConstraints(const Group& group,
if (currentControl != Group::InjectionCMode::RATE) if (currentControl != Group::InjectionCMode::RATE)
{ {
double current_rate = 0.0; double current_rate = 0.0;
current_rate += WellGroupHelpers::sumWellSurfaceRates(group, wellModel_.schedule(), well_state, reportStepIdx, phasePos, /*isInjector*/true); current_rate += WellGroupHelpers<double>::sumWellSurfaceRates(group,
wellModel_.schedule(),
well_state,
reportStepIdx,
phasePos,
/*isInjector*/true);
// sum over all nodes // sum over all nodes
current_rate = wellModel_.comm().sum(current_rate); current_rate = wellModel_.comm().sum(current_rate);
@ -98,7 +103,12 @@ checkGroupInjectionConstraints(const Group& group,
if (currentControl != Group::InjectionCMode::RESV) if (currentControl != Group::InjectionCMode::RESV)
{ {
double current_rate = 0.0; double current_rate = 0.0;
current_rate += WellGroupHelpers::sumWellResRates(group, wellModel_.schedule(), well_state, reportStepIdx, phasePos, /*isInjector*/true); current_rate += WellGroupHelpers<double>::sumWellResRates(group,
wellModel_.schedule(),
well_state,
reportStepIdx,
phasePos,
/*isInjector*/true);
// sum over all nodes // sum over all nodes
current_rate = wellModel_.comm().sum(current_rate); current_rate = wellModel_.comm().sum(current_rate);
@ -123,17 +133,23 @@ checkGroupInjectionConstraints(const Group& group,
double production_Rate = 0.0; double production_Rate = 0.0;
const auto& controls = group.injectionControls(phase, wellModel_.summaryState()); const auto& controls = group.injectionControls(phase, wellModel_.summaryState());
const Group& groupRein = wellModel_.schedule().getGroup(controls.reinj_group, reportStepIdx); const Group& groupRein = wellModel_.schedule().getGroup(controls.reinj_group, reportStepIdx);
production_Rate += WellGroupHelpers::sumWellSurfaceRates(groupRein, wellModel_.schedule(), production_Rate += WellGroupHelpers<double>::sumWellSurfaceRates(groupRein,
well_state, reportStepIdx, wellModel_.schedule(),
phasePos, /*isInjector*/false); well_state,
reportStepIdx,
phasePos,
/*isInjector*/false);
// sum over all nodes // sum over all nodes
production_Rate = wellModel_.comm().sum(production_Rate); production_Rate = wellModel_.comm().sum(production_Rate);
double current_rate = 0.0; double current_rate = 0.0;
current_rate += WellGroupHelpers::sumWellSurfaceRates(group, wellModel_.schedule(), current_rate += WellGroupHelpers<double>::sumWellSurfaceRates(group,
well_state, reportStepIdx, wellModel_.schedule(),
phasePos, /*isInjector*/true); well_state,
reportStepIdx,
phasePos,
/*isInjector*/true);
// sum over all nodes // sum over all nodes
current_rate = wellModel_.comm().sum(current_rate); current_rate = wellModel_.comm().sum(current_rate);
@ -153,29 +169,46 @@ checkGroupInjectionConstraints(const Group& group,
double voidage_rate = 0.0; double voidage_rate = 0.0;
const auto& controls = group.injectionControls(phase, wellModel_.summaryState()); const auto& controls = group.injectionControls(phase, wellModel_.summaryState());
const Group& groupVoidage = wellModel_.schedule().getGroup(controls.voidage_group, reportStepIdx); const Group& groupVoidage = wellModel_.schedule().getGroup(controls.voidage_group, reportStepIdx);
voidage_rate += WellGroupHelpers::sumWellResRates(groupVoidage, wellModel_.schedule(), voidage_rate += WellGroupHelpers<double>::sumWellResRates(groupVoidage,
well_state, reportStepIdx, wellModel_.schedule(),
pu.phase_pos[BlackoilPhases::Aqua], false); well_state,
voidage_rate += WellGroupHelpers::sumWellResRates(groupVoidage, wellModel_.schedule(), reportStepIdx,
well_state, reportStepIdx, pu.phase_pos[BlackoilPhases::Aqua],
pu.phase_pos[BlackoilPhases::Liquid], false); false);
voidage_rate += WellGroupHelpers::sumWellResRates(groupVoidage, wellModel_.schedule(), voidage_rate += WellGroupHelpers<double>::sumWellResRates(groupVoidage,
well_state, reportStepIdx, wellModel_.schedule(),
pu.phase_pos[BlackoilPhases::Vapour], false); well_state,
reportStepIdx,
pu.phase_pos[BlackoilPhases::Liquid],
false);
voidage_rate += WellGroupHelpers<double>::sumWellResRates(groupVoidage,
wellModel_.schedule(),
well_state, reportStepIdx,
pu.phase_pos[BlackoilPhases::Vapour],
false);
// sum over all nodes // sum over all nodes
voidage_rate = wellModel_.comm().sum(voidage_rate); voidage_rate = wellModel_.comm().sum(voidage_rate);
double total_rate = 0.0; double total_rate = 0.0;
total_rate += WellGroupHelpers::sumWellResRates(group, wellModel_.schedule(), total_rate += WellGroupHelpers<double>::sumWellResRates(group,
well_state, reportStepIdx, wellModel_.schedule(),
pu.phase_pos[BlackoilPhases::Aqua], true); well_state,
total_rate += WellGroupHelpers::sumWellResRates(group, wellModel_.schedule(), reportStepIdx,
well_state, reportStepIdx, pu.phase_pos[BlackoilPhases::Aqua],
pu.phase_pos[BlackoilPhases::Liquid], true); true);
total_rate += WellGroupHelpers::sumWellResRates(group, wellModel_.schedule(), total_rate += WellGroupHelpers<double>::sumWellResRates(group,
well_state, reportStepIdx, wellModel_.schedule(),
pu.phase_pos[BlackoilPhases::Vapour], true); well_state,
reportStepIdx,
pu.phase_pos[BlackoilPhases::Liquid],
true);
total_rate += WellGroupHelpers<double>::sumWellResRates(group,
wellModel_.schedule(),
well_state,
reportStepIdx,
pu.phase_pos[BlackoilPhases::Vapour],
true);
// sum over all nodes // sum over all nodes
total_rate = wellModel_.comm().sum(total_rate); total_rate = wellModel_.comm().sum(total_rate);
@ -208,9 +241,12 @@ checkGroupProductionConstraints(const Group& group,
if (currentControl != Group::ProductionCMode::ORAT) if (currentControl != Group::ProductionCMode::ORAT)
{ {
double current_rate = 0.0; double current_rate = 0.0;
current_rate += WellGroupHelpers::sumWellSurfaceRates(group, wellModel_.schedule(), current_rate += WellGroupHelpers<double>::sumWellSurfaceRates(group,
well_state, reportStepIdx, wellModel_.schedule(),
pu.phase_pos[BlackoilPhases::Liquid], false); well_state,
reportStepIdx,
pu.phase_pos[BlackoilPhases::Liquid],
false);
// sum over all nodes // sum over all nodes
current_rate = wellModel_.comm().sum(current_rate); current_rate = wellModel_.comm().sum(current_rate);
@ -228,11 +264,13 @@ checkGroupProductionConstraints(const Group& group,
{ {
if (currentControl != Group::ProductionCMode::WRAT) if (currentControl != Group::ProductionCMode::WRAT)
{ {
double current_rate = 0.0; double current_rate = 0.0;
current_rate += WellGroupHelpers::sumWellSurfaceRates(group, wellModel_.schedule(), current_rate += WellGroupHelpers<double>::sumWellSurfaceRates(group,
well_state, reportStepIdx, wellModel_.schedule(),
pu.phase_pos[BlackoilPhases::Aqua], false); well_state,
reportStepIdx,
pu.phase_pos[BlackoilPhases::Aqua],
false);
// sum over all nodes // sum over all nodes
current_rate = wellModel_.comm().sum(current_rate); current_rate = wellModel_.comm().sum(current_rate);
@ -250,9 +288,12 @@ checkGroupProductionConstraints(const Group& group,
if (currentControl != Group::ProductionCMode::GRAT) if (currentControl != Group::ProductionCMode::GRAT)
{ {
double current_rate = 0.0; double current_rate = 0.0;
current_rate += WellGroupHelpers::sumWellSurfaceRates(group, wellModel_.schedule(), current_rate += WellGroupHelpers<double>::sumWellSurfaceRates(group,
well_state, reportStepIdx, wellModel_.schedule(),
pu.phase_pos[BlackoilPhases::Vapour], false); well_state,
reportStepIdx,
pu.phase_pos[BlackoilPhases::Vapour],
false);
// sum over all nodes // sum over all nodes
current_rate = wellModel_.comm().sum(current_rate); current_rate = wellModel_.comm().sum(current_rate);
@ -269,21 +310,30 @@ checkGroupProductionConstraints(const Group& group,
if (currentControl != Group::ProductionCMode::LRAT) if (currentControl != Group::ProductionCMode::LRAT)
{ {
double current_rate = 0.0; double current_rate = 0.0;
current_rate += WellGroupHelpers::sumWellSurfaceRates(group, wellModel_.schedule(), current_rate += WellGroupHelpers<double>::sumWellSurfaceRates(group,
well_state, reportStepIdx, wellModel_.schedule(),
pu.phase_pos[BlackoilPhases::Liquid], false); well_state,
current_rate += WellGroupHelpers::sumWellSurfaceRates(group, wellModel_.schedule(), reportStepIdx,
well_state, reportStepIdx, pu.phase_pos[BlackoilPhases::Liquid],
pu.phase_pos[BlackoilPhases::Aqua], false); false);
current_rate += WellGroupHelpers<double>::sumWellSurfaceRates(group,
wellModel_.schedule(),
well_state,
reportStepIdx,
pu.phase_pos[BlackoilPhases::Aqua],
false);
// sum over all nodes // sum over all nodes
current_rate = wellModel_.comm().sum(current_rate); current_rate = wellModel_.comm().sum(current_rate);
bool skip = false; bool skip = false;
if (controls.liquid_target == controls.oil_target) { if (controls.liquid_target == controls.oil_target) {
double current_water_rate = WellGroupHelpers::sumWellSurfaceRates(group, wellModel_.schedule(), double current_water_rate = WellGroupHelpers<double>::sumWellSurfaceRates(group,
well_state, reportStepIdx, wellModel_.schedule(),
pu.phase_pos[BlackoilPhases::Aqua], false); well_state,
reportStepIdx,
pu.phase_pos[BlackoilPhases::Aqua],
false);
current_water_rate = wellModel_.comm().sum(current_water_rate); current_water_rate = wellModel_.comm().sum(current_water_rate);
if (std::abs(current_water_rate) < 1e-12) { if (std::abs(current_water_rate) < 1e-12) {
skip = true; skip = true;
@ -309,15 +359,24 @@ checkGroupProductionConstraints(const Group& group,
if (currentControl != Group::ProductionCMode::RESV) if (currentControl != Group::ProductionCMode::RESV)
{ {
double current_rate = 0.0; double current_rate = 0.0;
current_rate += WellGroupHelpers::sumWellResRates(group, wellModel_.schedule(), current_rate += WellGroupHelpers<double>::sumWellResRates(group,
well_state, reportStepIdx, wellModel_.schedule(),
pu.phase_pos[BlackoilPhases::Aqua], false); well_state,
current_rate += WellGroupHelpers::sumWellResRates(group, wellModel_.schedule(), reportStepIdx,
well_state, reportStepIdx, pu.phase_pos[BlackoilPhases::Aqua],
pu.phase_pos[BlackoilPhases::Liquid], false); false);
current_rate += WellGroupHelpers::sumWellResRates(group, wellModel_.schedule(), current_rate += WellGroupHelpers<double>::sumWellResRates(group,
well_state, reportStepIdx, wellModel_.schedule(),
pu.phase_pos[BlackoilPhases::Vapour], false); well_state,
reportStepIdx,
pu.phase_pos[BlackoilPhases::Liquid],
false);
current_rate += WellGroupHelpers<double>::sumWellResRates(group,
wellModel_.schedule(),
well_state,
reportStepIdx,
pu.phase_pos[BlackoilPhases::Vapour],
false);
// sum over all nodes // sum over all nodes
current_rate = wellModel_.comm().sum(current_rate); current_rate = wellModel_.comm().sum(current_rate);
@ -457,11 +516,10 @@ actionOnBrokenConstraints(const Group& group,
break; break;
} }
case Group::ExceedAction::WELL: { case Group::ExceedAction::WELL: {
std::tie(worst_offending_well, std::ignore) = std::tie(worst_offending_well, std::ignore) =
WellGroupHelpers::worstOffendingWell(group, wellModel_.schedule(), reportStepIdx, WellGroupHelpers<double>::worstOffendingWell(group, wellModel_.schedule(), reportStepIdx,
newControl, wellModel_.phaseUsage(), newControl, wellModel_.phaseUsage(),
wellModel_.comm(), well_state, deferred_logger); wellModel_.comm(), well_state, deferred_logger);
break; break;
} }
case Group::ExceedAction::PLUG: { case Group::ExceedAction::PLUG: {
@ -520,13 +578,13 @@ updateGroupIndividualControl(const Group& group,
Group::InjectionCMode2String(changed_this.first)); Group::InjectionCMode2String(changed_this.first));
this->actionOnBrokenConstraints(group, changed_this.first, phase, this->actionOnBrokenConstraints(group, changed_this.first, phase,
group_state, deferred_logger); group_state, deferred_logger);
WellGroupHelpers::updateWellRatesFromGroupTargetScale(changed_this.second, WellGroupHelpers<double>::updateWellRatesFromGroupTargetScale(changed_this.second,
group, group,
wellModel_.schedule(), wellModel_.schedule(),
reportStepIdx, reportStepIdx,
/* isInjector */ false, /* isInjector */ false,
wellModel_.groupState(), wellModel_.groupState(),
well_state); well_state);
changed = true; changed = true;
} }
} }
@ -549,13 +607,13 @@ updateGroupIndividualControl(const Group& group,
if(changed) { if(changed) {
switched_prod.insert_or_assign(group.name(), switched_prod.insert_or_assign(group.name(),
Group::ProductionCMode2String(changed_this.first)); Group::ProductionCMode2String(changed_this.first));
WellGroupHelpers::updateWellRatesFromGroupTargetScale(changed_this.second, WellGroupHelpers<double>::updateWellRatesFromGroupTargetScale(changed_this.second,
group, group,
wellModel_.schedule(), wellModel_.schedule(),
reportStepIdx, reportStepIdx,
/* isInjector */ false, /* isInjector */ false,
wellModel_.groupState(), wellModel_.groupState(),
well_state); well_state);
} else if (worst_offending_well) { } else if (worst_offending_well) {
closed_offending_wells.insert_or_assign(group.name(), closed_offending_wells.insert_or_assign(group.name(),
std::make_pair(Group::ProductionCMode2String(changed_this.first), *worst_offending_well)); std::make_pair(Group::ProductionCMode2String(changed_this.first), *worst_offending_well));

211
opm/simulators/wells/BlackoilWellModelGeneric.cpp
View File

@ -450,8 +450,18 @@ checkGconsaleLimits(const Group& group,
const Group::ProductionCMode& oldProductionControl = this->groupState().production_control(group.name()); const Group::ProductionCMode& oldProductionControl = this->groupState().production_control(group.name());
int gasPos = phase_usage_.phase_pos[BlackoilPhases::Vapour]; int gasPos = phase_usage_.phase_pos[BlackoilPhases::Vapour];
double production_rate = WellGroupHelpers::sumWellSurfaceRates(group, schedule(), well_state, reportStepIdx, gasPos, /*isInjector*/false); double production_rate = WellGroupHelpers<double>::sumWellSurfaceRates(group,
double injection_rate = WellGroupHelpers::sumWellSurfaceRates(group, schedule(), well_state, reportStepIdx, gasPos, /*isInjector*/true); schedule(),
well_state,
reportStepIdx,
gasPos,
/*isInjector*/false);
double injection_rate = WellGroupHelpers<double>::sumWellSurfaceRates(group,
schedule(),
well_state,
reportStepIdx,
gasPos,
/*isInjector*/true);
// sum over all nodes // sum over all nodes
injection_rate = comm_.sum(injection_rate); injection_rate = comm_.sum(injection_rate);
@ -585,7 +595,12 @@ checkGroupHigherConstraints(const Group& group,
calcInjRates(fipnum, pvtreg, resv_coeff_inj); calcInjRates(fipnum, pvtreg, resv_coeff_inj);
for (int phasePos = 0; phasePos < phase_usage_.num_phases; ++phasePos) { for (int phasePos = 0; phasePos < phase_usage_.num_phases; ++phasePos) {
const double local_current_rate = WellGroupHelpers::sumWellSurfaceRates(group, schedule(), this->wellState(), reportStepIdx, phasePos, /* isInjector */ true); const double local_current_rate = WellGroupHelpers<double>::sumWellSurfaceRates(group,
schedule(),
this->wellState(),
reportStepIdx,
phasePos,
/* isInjector */ true);
// Sum over all processes // Sum over all processes
rates[phasePos] = comm_.sum(local_current_rate); rates[phasePos] = comm_.sum(local_current_rate);
} }
@ -595,29 +610,35 @@ checkGroupHigherConstraints(const Group& group,
auto currentControl = this->groupState().injection_control(group.name(), phase); auto currentControl = this->groupState().injection_control(group.name(), phase);
if (currentControl != Group::InjectionCMode::FLD && group.injectionGroupControlAvailable(phase)) { if (currentControl != Group::InjectionCMode::FLD && group.injectionGroupControlAvailable(phase)) {
const Group& parentGroup = schedule().getGroup(group.parent(), reportStepIdx); const Group& parentGroup = schedule().getGroup(group.parent(), reportStepIdx);
const auto [is_changed, scaling_factor] = WellGroupHelpers::checkGroupConstraintsInj( const auto [is_changed, scaling_factor] =
group.name(), WellGroupHelpers<double>::checkGroupConstraintsInj(group.name(),
group.parent(), group.parent(),
parentGroup, parentGroup,
this->wellState(), this->wellState(),
this->groupState(), this->groupState(),
reportStepIdx, reportStepIdx,
&guideRate_, &guideRate_,
rates.data(), rates.data(),
phase, phase,
phase_usage_, phase_usage_,
group.getGroupEfficiencyFactor(), group.getGroupEfficiencyFactor(),
schedule(), schedule(),
summaryState_, summaryState_,
resv_coeff_inj, resv_coeff_inj,
deferred_logger); deferred_logger);
if (is_changed) { if (is_changed) {
switched_inj_groups_.insert_or_assign({group.name(), phase}, Group::InjectionCMode2String(Group::InjectionCMode::FLD)); switched_inj_groups_.insert_or_assign({group.name(), phase}, Group::InjectionCMode2String(Group::InjectionCMode::FLD));
BlackoilWellModelConstraints(*this). BlackoilWellModelConstraints(*this).
actionOnBrokenConstraints(group, Group::InjectionCMode::FLD, actionOnBrokenConstraints(group, Group::InjectionCMode::FLD,
phase, this->groupState(), phase, this->groupState(),
deferred_logger); deferred_logger);
WellGroupHelpers::updateWellRatesFromGroupTargetScale(scaling_factor, group, schedule(), reportStepIdx, /* isInjector */ true, this->groupState(), this->wellState()); WellGroupHelpers<double>::updateWellRatesFromGroupTargetScale(scaling_factor,
group,
schedule(),
reportStepIdx,
/* isInjector */ true,
this->groupState(),
this->wellState());
changed = true; changed = true;
} }
} }
@ -627,7 +648,12 @@ checkGroupHigherConstraints(const Group& group,
if (!isField && group.isProductionGroup()) { if (!isField && group.isProductionGroup()) {
// Obtain rates for group. // Obtain rates for group.
for (int phasePos = 0; phasePos < phase_usage_.num_phases; ++phasePos) { for (int phasePos = 0; phasePos < phase_usage_.num_phases; ++phasePos) {
const double local_current_rate = WellGroupHelpers::sumWellSurfaceRates(group, schedule(), this->wellState(), reportStepIdx, phasePos, /* isInjector */ false); const double local_current_rate = WellGroupHelpers<double>::sumWellSurfaceRates(group,
schedule(),
this->wellState(),
reportStepIdx,
phasePos,
/* isInjector */ false);
// Sum over all processes // Sum over all processes
rates[phasePos] = -comm_.sum(local_current_rate); rates[phasePos] = -comm_.sum(local_current_rate);
} }
@ -637,21 +663,21 @@ checkGroupHigherConstraints(const Group& group,
const Group::ProductionCMode& currentControl = this->groupState().production_control(group.name()); const Group::ProductionCMode& currentControl = this->groupState().production_control(group.name());
if (currentControl != Group::ProductionCMode::FLD && group.productionGroupControlAvailable()) { if (currentControl != Group::ProductionCMode::FLD && group.productionGroupControlAvailable()) {
const Group& parentGroup = schedule().getGroup(group.parent(), reportStepIdx); const Group& parentGroup = schedule().getGroup(group.parent(), reportStepIdx);
const auto [is_changed, scaling_factor] = WellGroupHelpers::checkGroupConstraintsProd( const auto [is_changed, scaling_factor] =
group.name(), WellGroupHelpers<double>::checkGroupConstraintsProd(group.name(),
group.parent(), group.parent(),
parentGroup, parentGroup,
this->wellState(), this->wellState(),
this->groupState(), this->groupState(),
reportStepIdx, reportStepIdx,
&guideRate_, &guideRate_,
rates.data(), rates.data(),
phase_usage_, phase_usage_,
group.getGroupEfficiencyFactor(), group.getGroupEfficiencyFactor(),
schedule(), schedule(),
summaryState_, summaryState_,
resv_coeff, resv_coeff,
deferred_logger); deferred_logger);
if (is_changed) { if (is_changed) {
const auto group_limit_action = group.productionControls(summaryState_).group_limit_action; const auto group_limit_action = group.productionControls(summaryState_).group_limit_action;
std::optional<std::string> worst_offending_well = std::nullopt; std::optional<std::string> worst_offending_well = std::nullopt;
@ -664,8 +690,15 @@ checkGroupHigherConstraints(const Group& group,
deferred_logger); deferred_logger);
if (changed) { if (changed) {
switched_prod_groups_.insert_or_assign(group.name(), Group::ProductionCMode2String(Group::ProductionCMode::FLD)); switched_prod_groups_.insert_or_assign(group.name(),
WellGroupHelpers::updateWellRatesFromGroupTargetScale(scaling_factor, group, schedule(), reportStepIdx, /* isInjector */ false, this->groupState(), this->wellState()); Group::ProductionCMode2String(Group::ProductionCMode::FLD));
WellGroupHelpers<double>::updateWellRatesFromGroupTargetScale(scaling_factor,
group,
schedule(),
reportStepIdx,
/* isInjector */ false,
this->groupState(),
this->wellState());
} }
} }
} }
@ -808,8 +841,17 @@ updateWsolvent(const Group& group,
int gasPos = phase_usage_.phase_pos[BlackoilPhases::Vapour]; int gasPos = phase_usage_.phase_pos[BlackoilPhases::Vapour];
const auto& controls = group.injectionControls(Phase::GAS, summaryState_); const auto& controls = group.injectionControls(Phase::GAS, summaryState_);
const Group& groupRein = schedule_.getGroup(controls.reinj_group, reportStepIdx); const Group& groupRein = schedule_.getGroup(controls.reinj_group, reportStepIdx);
double gasProductionRate = WellGroupHelpers::sumWellSurfaceRates(groupRein, schedule_, wellState, reportStepIdx, gasPos, /*isInjector*/false); double gasProductionRate = WellGroupHelpers<double>::sumWellSurfaceRates(groupRein,
double solventProductionRate = WellGroupHelpers::sumSolventRates(groupRein, schedule_, wellState, reportStepIdx, /*isInjector*/false); schedule_,
wellState,
reportStepIdx,
gasPos,
/*isInjector*/false);
double solventProductionRate = WellGroupHelpers<double>::sumSolventRates(groupRein,
schedule_,
wellState,
reportStepIdx,
/*isInjector*/false);
solventProductionRate = comm_.sum(solventProductionRate); solventProductionRate = comm_.sum(solventProductionRate);
gasProductionRate = comm_.sum(gasProductionRate); gasProductionRate = comm_.sum(gasProductionRate);
@ -956,12 +998,12 @@ assignNodeValues(std::map<std::string, data::NodeData>& nodevalues, const int re
const auto& network = schedule()[reportStepIdx].network(); const auto& network = schedule()[reportStepIdx].network();
if (!network.active()) return; if (!network.active()) return;
auto converged_pressures = WellGroupHelpers::computeNetworkPressures(network, auto converged_pressures = WellGroupHelpers<double>::computeNetworkPressures(network,
this->wellState(), this->wellState(),
this->groupState(), this->groupState(),
*(vfp_properties_->getProd()), *(vfp_properties_->getProd()),
schedule(), schedule(),
reportStepIdx); reportStepIdx);
for (const auto& [node, converged_pressure] : converged_pressures) { for (const auto& [node, converged_pressure] : converged_pressures) {
auto it = nodevalues.find(node); auto it = nodevalues.find(node);
assert(it != nodevalues.end() ); assert(it != nodevalues.end() );
@ -1011,20 +1053,63 @@ updateAndCommunicateGroupData(const int reportStepIdx,
// the group target reduction rates needs to be update since wells may have switched to/from GRUP control // the group target reduction rates needs to be update since wells may have switched to/from GRUP control
// The group target reduction does not honor NUPCOL. // The group target reduction does not honor NUPCOL.
std::vector<double> groupTargetReduction(numPhases(), 0.0); std::vector<double> groupTargetReduction(numPhases(), 0.0);
WellGroupHelpers::updateGroupTargetReduction(fieldGroup, schedule(), reportStepIdx, /*isInjector*/ false, phase_usage_, guideRate_, well_state, this->groupState(), groupTargetReduction); WellGroupHelpers<double>::updateGroupTargetReduction(fieldGroup,
schedule(),
reportStepIdx,
/*isInjector*/ false,
phase_usage_,
guideRate_,
well_state,
this->groupState(),
groupTargetReduction);
std::vector<double> groupTargetReductionInj(numPhases(), 0.0); std::vector<double> groupTargetReductionInj(numPhases(), 0.0);
WellGroupHelpers::updateGroupTargetReduction(fieldGroup, schedule(), reportStepIdx, /*isInjector*/ true, phase_usage_, guideRate_, well_state, this->groupState(), groupTargetReductionInj); WellGroupHelpers<double>::updateGroupTargetReduction(fieldGroup,
schedule(),
reportStepIdx,
/*isInjector*/ true,
phase_usage_,
guideRate_,
well_state,
this->groupState(),
groupTargetReductionInj);
WellGroupHelpers::updateREINForGroups(fieldGroup, schedule(), reportStepIdx, phase_usage_, summaryState_, well_state_nupcol, this->groupState(), comm_.rank()==0); WellGroupHelpers<double>::updateREINForGroups(fieldGroup,
WellGroupHelpers::updateVREPForGroups(fieldGroup, schedule(), reportStepIdx, well_state_nupcol, this->groupState()); schedule(),
reportStepIdx,
phase_usage_,
summaryState_,
well_state_nupcol,
this->groupState(),
comm_.rank() == 0);
WellGroupHelpers<double>::updateVREPForGroups(fieldGroup,
schedule(),
reportStepIdx,
well_state_nupcol,
this->groupState());
WellGroupHelpers::updateReservoirRatesInjectionGroups(fieldGroup, schedule(), reportStepIdx, well_state_nupcol, this->groupState()); WellGroupHelpers<double>::updateReservoirRatesInjectionGroups(fieldGroup,
WellGroupHelpers::updateSurfaceRatesInjectionGroups(fieldGroup, schedule(), reportStepIdx, well_state_nupcol, this->groupState()); schedule(),
reportStepIdx,
well_state_nupcol,
this->groupState());
WellGroupHelpers<double>::updateSurfaceRatesInjectionGroups(fieldGroup,
schedule(),
reportStepIdx,
well_state_nupcol,
this->groupState());
WellGroupHelpers::updateGroupProductionRates(fieldGroup, schedule(), reportStepIdx, well_state_nupcol, this->groupState()); WellGroupHelpers<double>::updateGroupProductionRates(fieldGroup,
schedule(),
reportStepIdx,
well_state_nupcol,
this->groupState());
// We use the rates from the previous time-step to reduce oscillations // We use the rates from the previous time-step to reduce oscillations
WellGroupHelpers::updateWellRates(fieldGroup, schedule(), reportStepIdx, this->prevWellState(), well_state); WellGroupHelpers<double>::updateWellRates(fieldGroup,
schedule(),
reportStepIdx,
this->prevWellState(),
well_state);
// Set ALQ for off-process wells to zero // Set ALQ for off-process wells to zero
for (const auto& wname : schedule().wellNames(reportStepIdx)) { for (const auto& wname : schedule().wellNames(reportStepIdx)) {
@ -1151,12 +1236,12 @@ updateNetworkPressures(const int reportStepIdx)
const auto previous_node_pressures = node_pressures_; const auto previous_node_pressures = node_pressures_;
node_pressures_ = WellGroupHelpers::computeNetworkPressures(network, node_pressures_ = WellGroupHelpers<double>::computeNetworkPressures(network,
this->wellState(), this->wellState(),
this->groupState(), this->groupState(),
*(vfp_properties_->getProd()), *(vfp_properties_->getProd()),
schedule(), schedule(),
reportStepIdx); reportStepIdx);
// here, the network imbalance is the difference between the previous nodal pressure and the new nodal pressure // here, the network imbalance is the difference between the previous nodal pressure and the new nodal pressure
double network_imbalance = 0.; double network_imbalance = 0.;
@ -1225,7 +1310,11 @@ calculateEfficiencyFactors(const int reportStepIdx)
for (auto& well : well_container_generic_) { for (auto& well : well_container_generic_) {
const Well& wellEcl = well->wellEcl(); const Well& wellEcl = well->wellEcl();
double well_efficiency_factor = wellEcl.getEfficiencyFactor(); double well_efficiency_factor = wellEcl.getEfficiencyFactor();
WellGroupHelpers::accumulateGroupEfficiencyFactor(schedule().getGroup(wellEcl.groupName(), reportStepIdx), schedule(), reportStepIdx, well_efficiency_factor); WellGroupHelpers<double>::accumulateGroupEfficiencyFactor(schedule().getGroup(wellEcl.groupName(),
reportStepIdx),
schedule(),
reportStepIdx,
well_efficiency_factor);
well->setWellEfficiencyFactor(well_efficiency_factor); well->setWellEfficiencyFactor(well_efficiency_factor);
} }
} }

6
opm/simulators/wells/BlackoilWellModelGuideRates.cpp
View File

@ -328,7 +328,7 @@ getGuideRateValues(const Well& well) const
return grval; return grval;
} }
const auto qs = WellGroupHelpers:: const auto qs = WellGroupHelpers<double>::
getWellRateVector(wellModel_.wellState(), wellModel_.phaseUsage(), wname); getWellRateVector(wellModel_.wellState(), wellModel_.phaseUsage(), wname);
this->getGuideRateValues(qs, well.isInjector(), wname, grval); this->getGuideRateValues(qs, well.isInjector(), wname, grval);
@ -355,7 +355,7 @@ getGuideRateValues(const Group& group) const
return grval; return grval;
} }
const auto qs = WellGroupHelpers:: const auto qs = WellGroupHelpers<double>::
getProductionGroupRateVector(wellModel_.groupState(), wellModel_.phaseUsage(), gname); getProductionGroupRateVector(wellModel_.groupState(), wellModel_.phaseUsage(), gname);
const auto is_inj = false; // This procedure only applies to G*PGR. const auto is_inj = false; // This procedure only applies to G*PGR.
@ -433,7 +433,7 @@ assignWellGuideRates(data::Wells& wsrpt,
const auto get_gr = parent const auto get_gr = parent
|| RetrieveWellGuideRate{wellModel_.guideRate(), wname}; || RetrieveWellGuideRate{wellModel_.guideRate(), wname};
const auto qs = WellGroupHelpers:: const auto qs = WellGroupHelpers<double>::
getWellRateVector(wellModel_.wellState(), wellModel_.phaseUsage(), wname); getWellRateVector(wellModel_.wellState(), wellModel_.phaseUsage(), wname);
auto getGR = [this, &wname, &qs](const GuideRateModel::Target t) auto getGR = [this, &wname, &qs](const GuideRateModel::Target t)

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

@ -343,16 +343,16 @@ namespace Opm {
const auto& fieldGroup = const auto& fieldGroup =
this->schedule().getGroup("FIELD", reportStepIdx); this->schedule().getGroup("FIELD", reportStepIdx);
WellGroupHelpers::setCmodeGroup(fieldGroup, WellGroupHelpers<Scalar>::setCmodeGroup(fieldGroup,
this->schedule(), this->schedule(),
this->summaryState(), this->summaryState(),
reportStepIdx, reportStepIdx,
this->groupState()); this->groupState());
// Define per region average pressure calculators for use by // Define per region average pressure calculators for use by
// pressure maintenance groups (GPMAINT keyword). // pressure maintenance groups (GPMAINT keyword).
if (this->schedule()[reportStepIdx].has_gpmaint()) { if (this->schedule()[reportStepIdx].has_gpmaint()) {
WellGroupHelpers::setRegionAveragePressureCalculator WellGroupHelpers<Scalar>::setRegionAveragePressureCalculator
(fieldGroup, (fieldGroup,
this->schedule(), this->schedule(),
reportStepIdx, reportStepIdx,
@ -505,10 +505,20 @@ namespace Opm {
//update guide rates //update guide rates
const auto& comm = simulator_.vanguard().grid().comm(); const auto& comm = simulator_.vanguard().grid().comm();
std::vector<double> pot(numPhases(), 0.0); std::vector<double> pot(this->numPhases(), 0.0);
const Group& fieldGroup = schedule().getGroup("FIELD", reportStepIdx); const Group& fieldGroup = this->schedule().getGroup("FIELD", reportStepIdx);
WellGroupHelpers::updateGuideRates(fieldGroup, schedule(), summaryState, this->phase_usage_, reportStepIdx, simulationTime, WellGroupHelpers<double>::updateGuideRates(fieldGroup,
this->wellState(), this->groupState(), comm, &this->guideRate_, pot, local_deferredLogger); this->schedule(),
summaryState,
this->phase_usage_,
reportStepIdx,
simulationTime,
this->wellState(),
this->groupState(),
comm,
&this->guideRate_,
pot,
local_deferredLogger);
std::string exc_msg; std::string exc_msg;
auto exc_type = ExceptionType::NONE; auto exc_type = ExceptionType::NONE;
// update gpmaint targets // update gpmaint targets
@ -517,8 +527,13 @@ namespace Opm {
calculator.second->template defineState<ElementContext>(simulator_); calculator.second->template defineState<ElementContext>(simulator_);
} }
const double dt = simulator_.timeStepSize(); const double dt = simulator_.timeStepSize();
WellGroupHelpers::updateGpMaintTargetForGroups(fieldGroup, WellGroupHelpers<double>::updateGpMaintTargetForGroups(fieldGroup,
schedule_, regionalAveragePressureCalculator_, reportStepIdx, dt, this->wellState(), this->groupState()); this->schedule_,
regionalAveragePressureCalculator_,
reportStepIdx,
dt,
this->wellState(),
this->groupState());
} }
try { try {
// Compute initial well solution for new wells and injectors that change injection type i.e. WAG. // Compute initial well solution for new wells and injectors that change injection type i.e. WAG.
@ -574,8 +589,11 @@ namespace Opm {
well->init(&phase_usage_, depth_, gravity_, local_num_cells_, B_avg_, true); well->init(&phase_usage_, depth_, gravity_, local_num_cells_, B_avg_, true);
double well_efficiency_factor = wellEcl.getEfficiencyFactor(); double well_efficiency_factor = wellEcl.getEfficiencyFactor();
WellGroupHelpers::accumulateGroupEfficiencyFactor(schedule().getGroup(wellEcl.groupName(), timeStepIdx), WellGroupHelpers<double>::accumulateGroupEfficiencyFactor(this->schedule().getGroup(wellEcl.groupName(),
schedule(), timeStepIdx, well_efficiency_factor); timeStepIdx),
this->schedule(),
timeStepIdx,
well_efficiency_factor);
well->setWellEfficiencyFactor(well_efficiency_factor); well->setWellEfficiencyFactor(well_efficiency_factor);
well->setVFPProperties(vfp_properties_.get()); well->setVFPProperties(vfp_properties_.get());
@ -1191,13 +1209,22 @@ namespace Opm {
const double simulationTime = simulator_.time(); const double simulationTime = simulator_.time();
const auto& comm = simulator_.vanguard().grid().comm(); const auto& comm = simulator_.vanguard().grid().comm();
const auto& summaryState = simulator_.vanguard().summaryState(); const auto& summaryState = simulator_.vanguard().summaryState();
std::vector<double> pot(numPhases(), 0.0); std::vector<double> pot(this->numPhases(), 0.0);
const Group& fieldGroup = schedule().getGroup("FIELD", reportStepIdx); const Group& fieldGroup = this->schedule().getGroup("FIELD", reportStepIdx);
WellGroupHelpers::updateGuideRates(fieldGroup, schedule(), summaryState, this->phase_usage_, reportStepIdx, simulationTime, WellGroupHelpers<double>::updateGuideRates(fieldGroup,
this->wellState(), this->groupState(), comm, &this->guideRate_, pot, local_deferredLogger); this->schedule(),
summaryState,
this->phase_usage_,
reportStepIdx,
simulationTime,
this->wellState(),
this->groupState(),
comm,
&this->guideRate_,
pot,
local_deferredLogger);
} }
return {more_network_update, well_group_control_changed}; return {more_network_update, well_group_control_changed};
} }

26
opm/simulators/wells/FractionCalculator.cpp
View File

@ -144,8 +144,8 @@ guideRate(const std::string& name,
const std::string& always_included_child) const std::string& always_included_child)
{ {
if (schedule_.hasWell(name, report_step_)) { if (schedule_.hasWell(name, report_step_)) {
return WellGroupHelpers::getGuideRate(name, schedule_, well_state_, group_state_, return WellGroupHelpers<Scalar>::getGuideRate(name, schedule_, well_state_, group_state_,
report_step_, guide_rate_, target_, pu_); report_step_, guide_rate_, target_, pu_);
} else { } else {
if (groupControlledWells(name, always_included_child) > 0) { if (groupControlledWells(name, always_included_child) > 0) {
if (is_producer_ && guide_rate_->has(name)) { if (is_producer_ && guide_rate_->has(name)) {
@ -171,14 +171,14 @@ int FractionCalculator<Scalar>::
groupControlledWells(const std::string& group_name, groupControlledWells(const std::string& group_name,
const std::string& always_included_child) const std::string& always_included_child)
{ {
return WellGroupHelpers::groupControlledWells(schedule_, return WellGroupHelpers<Scalar>::groupControlledWells(schedule_,
well_state_, well_state_,
this->group_state_, this->group_state_,
report_step_, report_step_,
group_name, group_name,
always_included_child, always_included_child,
is_producer_, is_producer_,
injection_phase_); injection_phase_);
} }
template<class Scalar> template<class Scalar>
@ -186,9 +186,9 @@ GuideRate::RateVector FractionCalculator<Scalar>::
getGroupRateVector(const std::string& group_name) getGroupRateVector(const std::string& group_name)
{ {
assert(is_producer_); assert(is_producer_);
return WellGroupHelpers::getProductionGroupRateVector(this->group_state_, return WellGroupHelpers<Scalar>::getProductionGroupRateVector(this->group_state_,
this->pu_, this->pu_,
group_name); group_name);
} }
template class FractionCalculator<double>; template class FractionCalculator<double>;

9
opm/simulators/wells/GroupEconomicLimitsChecker.cpp
View File

@ -77,9 +77,12 @@ GroupEconomicLimitsChecker(const BlackoilWellModelGeneric& well_model,
auto phase_idx = this->phase_idx_map_[i]; auto phase_idx = this->phase_idx_map_[i];
this->phase_idx_reverse_map_[phase_idx] = static_cast<int>(i); this->phase_idx_reverse_map_[phase_idx] = static_cast<int>(i);
auto phase_pos = this->well_model_.phaseUsage().phase_pos[phase_idx]; auto phase_pos = this->well_model_.phaseUsage().phase_pos[phase_idx];
Scalar production_rate = WellGroupHelpers::sumWellSurfaceRates( Scalar production_rate = WellGroupHelpers<Scalar>::sumWellSurfaceRates(this->group_,
this->group_, this->schedule_, this->well_state_, this->schedule_,
this->report_step_idx_, phase_pos, /*isInjector*/false); this->well_state_,
this->report_step_idx_,
phase_pos,
/*isInjector*/false);
this->production_rates_[i] = this->well_model_.comm().sum(production_rate); this->production_rates_[i] = this->well_model_.comm().sum(production_rate);
} }
} }

58
opm/simulators/wells/WellGroupConstraints.cpp
View File

@ -74,21 +74,21 @@ checkGroupConstraintsInj(const Group& group,
const auto& ws = well_state.well(well_.indexOfWell()); const auto& ws = well_state.well(well_.indexOfWell());
// Call check for the well's injection phase. // Call check for the well's injection phase.
return WellGroupHelpers::checkGroupConstraintsInj(well_.name(), return WellGroupHelpers<double>::checkGroupConstraintsInj(well_.name(),
well_.wellEcl().groupName(), well_.wellEcl().groupName(),
group, group,
well_state, well_state,
group_state, group_state,
well_.currentStep(), well_.currentStep(),
well_.guideRate(), well_.guideRate(),
ws.surface_rates.data(), ws.surface_rates.data(),
injectionPhase, injectionPhase,
well_.phaseUsage(), well_.phaseUsage(),
efficiencyFactor, efficiencyFactor,
schedule, schedule,
summaryState, summaryState,
resv_coeff, resv_coeff,
deferred_logger); deferred_logger);
} }
std::pair<bool, double> std::pair<bool, double>
@ -107,20 +107,20 @@ checkGroupConstraintsProd(const Group& group,
rateConverter(0, well_.pvtRegionIdx(), group.name(), resv_coeff); // FIPNUM region 0 here, should use FIPNUM from WELSPECS. rateConverter(0, well_.pvtRegionIdx(), group.name(), resv_coeff); // FIPNUM region 0 here, should use FIPNUM from WELSPECS.
const auto& ws = well_state.well(well_.indexOfWell()); const auto& ws = well_state.well(well_.indexOfWell());
return WellGroupHelpers::checkGroupConstraintsProd(well_.name(), return WellGroupHelpers<double>::checkGroupConstraintsProd(well_.name(),
well_.wellEcl().groupName(), well_.wellEcl().groupName(),
group, group,
well_state, well_state,
group_state, group_state,
well_.currentStep(), well_.currentStep(),
well_.guideRate(), well_.guideRate(),
ws.surface_rates.data(), ws.surface_rates.data(),
well_.phaseUsage(), well_.phaseUsage(),
efficiencyFactor, efficiencyFactor,
schedule, schedule,
summaryState, summaryState,
resv_coeff, resv_coeff,
deferred_logger); deferred_logger);
} }
bool WellGroupConstraints:: bool WellGroupConstraints::

17
opm/simulators/wells/WellGroupControls.cpp
View File

@ -173,8 +173,8 @@ getGroupInjectionControl(const Group& group,
const double orig_target = tcalc.groupTarget(ctrl, const double orig_target = tcalc.groupTarget(ctrl,
deferred_logger); deferred_logger);
const auto chain = WellGroupHelpers::groupChainTopBot(well_.name(), group.name(), const auto chain = WellGroupHelpers<double>::groupChainTopBot(well_.name(), group.name(),
schedule, well_.currentStep()); schedule, well_.currentStep());
// Because 'name' is the last of the elements, and not an ancestor, we subtract one below. // Because 'name' is the last of the elements, and not an ancestor, we subtract one below.
const std::size_t num_ancestors = chain.size() - 1; const std::size_t num_ancestors = chain.size() - 1;
double target = orig_target; double target = orig_target;
@ -306,7 +306,10 @@ getGroupInjectionTargetRate(const Group& group,
const double orig_target = tcalc.groupTarget(ctrl, deferred_logger); const double orig_target = tcalc.groupTarget(ctrl, deferred_logger);
const auto chain = WellGroupHelpers::groupChainTopBot(well_.name(), group.name(), schedule, well_.currentStep()); const auto chain = WellGroupHelpers<double>::groupChainTopBot(well_.name(),
group.name(),
schedule,
well_.currentStep());
// Because 'name' is the last of the elements, and not an ancestor, we subtract one below. // Because 'name' is the last of the elements, and not an ancestor, we subtract one below.
const std::size_t num_ancestors = chain.size() - 1; const std::size_t num_ancestors = chain.size() - 1;
double target = orig_target; double target = orig_target;
@ -417,8 +420,8 @@ void WellGroupControls::getGroupProductionControl(const Group& group,
ctrl = group.productionControls(summaryState); ctrl = group.productionControls(summaryState);
const double orig_target = tcalc.groupTarget(ctrl, deferred_logger); const double orig_target = tcalc.groupTarget(ctrl, deferred_logger);
const auto chain = WellGroupHelpers::groupChainTopBot(well_.name(), group.name(), const auto chain = WellGroupHelpers<double>::groupChainTopBot(well_.name(), group.name(),
schedule, well_.currentStep()); schedule, well_.currentStep());
// Because 'name' is the last of the elements, and not an ancestor, we subtract one below. // Because 'name' is the last of the elements, and not an ancestor, we subtract one below.
const std::size_t num_ancestors = chain.size() - 1; const std::size_t num_ancestors = chain.size() - 1;
double target = orig_target; double target = orig_target;
@ -514,8 +517,8 @@ getGroupProductionTargetRate(const Group& group,
ctrl = group.productionControls(summaryState); ctrl = group.productionControls(summaryState);
const double orig_target = tcalc.groupTarget(ctrl, deferred_logger); const double orig_target = tcalc.groupTarget(ctrl, deferred_logger);
const auto chain = WellGroupHelpers::groupChainTopBot(well_.name(), group.name(), const auto chain = WellGroupHelpers<double>::groupChainTopBot(well_.name(), group.name(),
schedule, well_.currentStep()); schedule, well_.currentStep());
// Because 'name' is the last of the elements, and not an ancestor, we subtract one below. // Because 'name' is the last of the elements, and not an ancestor, we subtract one below.
const std::size_t num_ancestors = chain.size() - 1; const std::size_t num_ancestors = chain.size() - 1;
double target = orig_target; double target = orig_target;

419
opm/simulators/wells/WellGroupHelpers.cpp
View File

File diff suppressed because it is too large Load Diff

132
opm/simulators/wells/WellGroupHelpers.hpp
View File

@ -43,6 +43,7 @@ class FieldPropsManager;
namespace Network { class ExtNetwork; } namespace Network { class ExtNetwork; }
template<class Scalar>
class WellGroupHelpers class WellGroupHelpers
{ {
public: public:
@ -50,41 +51,41 @@ public:
const Schedule& schedule, const Schedule& schedule,
const SummaryState& summaryState, const SummaryState& summaryState,
const int reportStepIdx, const int reportStepIdx,
GroupState<double>& group_state); GroupState<Scalar>& group_state);
static void accumulateGroupEfficiencyFactor(const Group& group, static void accumulateGroupEfficiencyFactor(const Group& group,
const Schedule& schedule, const Schedule& schedule,
const int reportStepIdx, const int reportStepIdx,
double& factor); Scalar& factor);
static double sumWellSurfaceRates(const Group& group, static Scalar sumWellSurfaceRates(const Group& group,
const Schedule& schedule, const Schedule& schedule,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
const int reportStepIdx, const int reportStepIdx,
const int phasePos, const int phasePos,
const bool injector); const bool injector);
/// Returns the name of the worst offending well and its fraction (i.e. violated_phase / preferred_phase) /// Returns the name of the worst offending well and its fraction (i.e. violated_phase / preferred_phase)
static std::pair<std::optional<std::string>, double> static std::pair<std::optional<std::string>, Scalar>
worstOffendingWell(const Group& group, worstOffendingWell(const Group& group,
const Schedule& schedule, const Schedule& schedule,
const int reportStepIdx, const int reportStepIdx,
const Group::ProductionCMode& offendedControl, const Group::ProductionCMode& offendedControl,
const PhaseUsage& pu, const PhaseUsage& pu,
const Parallel::Communication& comm, const Parallel::Communication& comm,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
DeferredLogger& deferred_logger); DeferredLogger& deferred_logger);
static double sumWellResRates(const Group& group, static Scalar sumWellResRates(const Group& group,
const Schedule& schedule, const Schedule& schedule,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
const int reportStepIdx, const int reportStepIdx,
const int phasePos, const int phasePos,
const bool injector); const bool injector);
static double sumSolventRates(const Group& group, static Scalar sumSolventRates(const Group& group,
const Schedule& schedule, const Schedule& schedule,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
const int reportStepIdx, const int reportStepIdx,
const bool injector); const bool injector);
@ -94,9 +95,9 @@ public:
const bool isInjector, const bool isInjector,
const PhaseUsage& pu, const PhaseUsage& pu,
const GuideRate& guide_rate, const GuideRate& guide_rate,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
GroupState<double>& group_state, GroupState<Scalar>& group_state,
std::vector<double>& groupTargetReduction); std::vector<Scalar>& groupTargetReduction);
static void updateGuideRates(const Group& group, static void updateGuideRates(const Group& group,
const Schedule& schedule, const Schedule& schedule,
@ -104,29 +105,29 @@ public:
const PhaseUsage& pu, const PhaseUsage& pu,
int report_step, int report_step,
double sim_time, double sim_time,
WellState<double>& well_state, WellState<Scalar>& well_state,
const GroupState<double>& group_state, const GroupState<Scalar>& group_state,
const Parallel::Communication& comm, const Parallel::Communication& comm,
GuideRate* guide_rate, GuideRate* guide_rate,
std::vector<double>& pot, std::vector<Scalar>& pot,
DeferredLogger& deferred_logge); DeferredLogger& deferred_logger);
static void updateGuideRateForProductionGroups(const Group& group, static void updateGuideRateForProductionGroups(const Group& group,
const Schedule& schedule, const Schedule& schedule,
const PhaseUsage& pu, const PhaseUsage& pu,
const int reportStepIdx, const int reportStepIdx,
const double& simTime, const double& simTime,
WellState<double>& wellState, WellState<Scalar>& wellState,
const GroupState<double>& group_state, const GroupState<Scalar>& group_state,
const Parallel::Communication& comm, const Parallel::Communication& comm,
GuideRate* guideRate, GuideRate* guideRate,
std::vector<double>& pot); std::vector<Scalar>& pot);
static void updateGuideRatesForWells(const Schedule& schedule, static void updateGuideRatesForWells(const Schedule& schedule,
const PhaseUsage& pu, const PhaseUsage& pu,
const int reportStepIdx, const int reportStepIdx,
const double& simTime, const double& simTime,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
const Parallel::Communication& comm, const Parallel::Communication& comm,
GuideRate* guideRate); GuideRate* guideRate);
@ -135,16 +136,16 @@ public:
const SummaryState& summaryState, const SummaryState& summaryState,
const PhaseUsage& pu, const PhaseUsage& pu,
const int reportStepIdx, const int reportStepIdx,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
const GroupState<double>& group_state, const GroupState<Scalar>& group_state,
GuideRate* guideRate, GuideRate* guideRate,
DeferredLogger& deferred_logger); DeferredLogger& deferred_logger);
static void updateVREPForGroups(const Group& group, static void updateVREPForGroups(const Group& group,
const Schedule& schedule, const Schedule& schedule,
const int reportStepIdx, const int reportStepIdx,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
GroupState<double>& group_state); GroupState<Scalar>& group_state);
template <class RegionalValues> template <class RegionalValues>
static void updateGpMaintTargetForGroups(const Group& group, static void updateGpMaintTargetForGroups(const Group& group,
@ -152,81 +153,82 @@ public:
const RegionalValues& regional_values, const RegionalValues& regional_values,
const int reportStepIdx, const int reportStepIdx,
const double dt, const double dt,
const WellState<double>& well_state, const WellState<Scalar>& well_state,
GroupState<double>& group_state); GroupState<Scalar>& group_state);
static void updateReservoirRatesInjectionGroups(const Group& group, static void updateReservoirRatesInjectionGroups(const Group& group,
const Schedule& schedule, const Schedule& schedule,
const int reportStepIdx, const int reportStepIdx,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
GroupState<double>& group_state); GroupState<Scalar>& group_state);
static void updateSurfaceRatesInjectionGroups(const Group& group, static void updateSurfaceRatesInjectionGroups(const Group& group,
const Schedule& schedule, const Schedule& schedule,
const int reportStepIdx, const int reportStepIdx,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
GroupState<double>& group_state); GroupState<Scalar>& group_state);
static void updateWellRates(const Group& group, static void updateWellRates(const Group& group,
const Schedule& schedule, const Schedule& schedule,
const int reportStepIdx, const int reportStepIdx,
const WellState<double>& wellStateNupcol, const WellState<Scalar>& wellStateNupcol,
WellState<double>& wellState); WellState<Scalar>& wellState);
static void updateGroupProductionRates(const Group& group, static void updateGroupProductionRates(const Group& group,
const Schedule& schedule, const Schedule& schedule,
const int reportStepIdx, const int reportStepIdx,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
GroupState<double>& group_state); GroupState<Scalar>& group_state);
static void updateWellRatesFromGroupTargetScale(const double scale, static void updateWellRatesFromGroupTargetScale(const Scalar scale,
const Group& group, const Group& group,
const Schedule& schedule, const Schedule& schedule,
const int reportStepIdx, const int reportStepIdx,
bool isInjector, bool isInjector,
const GroupState<double>& group_state, const GroupState<Scalar>& group_state,
WellState<double>& wellState); WellState<Scalar>& wellState);
static void updateREINForGroups(const Group& group, static void updateREINForGroups(const Group& group,
const Schedule& schedule, const Schedule& schedule,
const int reportStepIdx, const int reportStepIdx,
const PhaseUsage& pu, const PhaseUsage& pu,
const SummaryState& st, const SummaryState& st,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
GroupState<double>& group_state, GroupState<Scalar>& group_state,
bool sum_rank); bool sum_rank);
static std::map<std::string, double>
static std::map<std::string, Scalar>
computeNetworkPressures(const Network::ExtNetwork& network, computeNetworkPressures(const Network::ExtNetwork& network,
const WellState<double>& well_state, const WellState<Scalar>& well_state,
const GroupState<double>& group_state, const GroupState<Scalar>& group_state,
const VFPProdProperties& vfp_prod_props, const VFPProdProperties& vfp_prod_props,
const Schedule& schedule, const Schedule& schedule,
const int report_time_step); const int report_time_step);
static GuideRate::RateVector static GuideRate::RateVector
getWellRateVector(const WellState<double>& well_state, getWellRateVector(const WellState<Scalar>& well_state,
const PhaseUsage& pu, const PhaseUsage& pu,
const std::string& name); const std::string& name);
static GuideRate::RateVector static GuideRate::RateVector
getProductionGroupRateVector(const GroupState<double>& group_state, getProductionGroupRateVector(const GroupState<Scalar>& group_state,
const PhaseUsage& pu, const PhaseUsage& pu,
const std::string& group_name); const std::string& group_name);
static double getGuideRate(const std::string& name, static Scalar getGuideRate(const std::string& name,
const Schedule& schedule, const Schedule& schedule,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
const GroupState<double>& group_state, const GroupState<Scalar>& group_state,
const int reportStepIdx, const int reportStepIdx,
const GuideRate* guideRate, const GuideRate* guideRate,
const GuideRateModel::Target target, const GuideRateModel::Target target,
const PhaseUsage& pu); const PhaseUsage& pu);
static double getGuideRateInj(const std::string& name, static Scalar getGuideRateInj(const std::string& name,
const Schedule& schedule, const Schedule& schedule,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
const GroupState<double>& group_state, const GroupState<Scalar>& group_state,
const int reportStepIdx, const int reportStepIdx,
const GuideRate* guideRate, const GuideRate* guideRate,
const GuideRateModel::Target target, const GuideRateModel::Target target,
@ -234,29 +236,29 @@ public:
const PhaseUsage& pu); const PhaseUsage& pu);
static int groupControlledWells(const Schedule& schedule, static int groupControlledWells(const Schedule& schedule,
const WellState<double>& well_state, const WellState<Scalar>& well_state,
const GroupState<double>& group_state, const GroupState<Scalar>& group_state,
const int report_step, const int report_step,
const std::string& group_name, const std::string& group_name,
const std::string& always_included_child, const std::string& always_included_child,
const bool is_production_group, const bool is_production_group,
const Phase injection_phase); const Phase injection_phase);
static std::pair<bool, double> static std::pair<bool, Scalar>
checkGroupConstraintsInj(const std::string& name, checkGroupConstraintsInj(const std::string& name,
const std::string& parent, const std::string& parent,
const Group& group, const Group& group,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
const GroupState<double>& group_state, const GroupState<Scalar>& group_state,
const int reportStepIdx, const int reportStepIdx,
const GuideRate* guideRate, const GuideRate* guideRate,
const double* rates, const Scalar* rates,
Phase injectionPhase, Phase injectionPhase,
const PhaseUsage& pu, const PhaseUsage& pu,
const double efficiencyFactor, const Scalar efficiencyFactor,
const Schedule& schedule, const Schedule& schedule,
const SummaryState& summaryState, const SummaryState& summaryState,
const std::vector<double>& resv_coeff, const std::vector<Scalar>& resv_coeff,
DeferredLogger& deferred_logger); DeferredLogger& deferred_logger);
static std::vector<std::string> static std::vector<std::string>
@ -265,20 +267,20 @@ public:
const Schedule& schedule, const Schedule& schedule,
const int report_step); const int report_step);
static std::pair<bool, double> static std::pair<bool, Scalar>
checkGroupConstraintsProd(const std::string& name, checkGroupConstraintsProd(const std::string& name,
const std::string& parent, const std::string& parent,
const Group& group, const Group& group,
const WellState<double>& wellState, const WellState<Scalar>& wellState,
const GroupState<double>& group_state, const GroupState<Scalar>& group_state,
const int reportStepIdx, const int reportStepIdx,
const GuideRate* guideRate, const GuideRate* guideRate,
const double* rates, const Scalar* rates,
const PhaseUsage& pu, const PhaseUsage& pu,
const double efficiencyFactor, const Scalar efficiencyFactor,
const Schedule& schedule, const Schedule& schedule,
const SummaryState& summaryState, const SummaryState& summaryState,
const std::vector<double>& resv_coeff, const std::vector<Scalar>& resv_coeff,
DeferredLogger& deferred_logger); DeferredLogger& deferred_logger);
template <class AverageRegionalPressureType> template <class AverageRegionalPressureType>