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

fixing the function checkMaxWaterCutLimit

Browse Source 
when looking for the worst offending completion
This commit is contained in:
Kai Bao 2019-06-20 11:52:23 +02:00
parent 8be28e8448
commit 01c9935b02
1 changed files with 49 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
opm/simulators/wells/WellInterface_impl.hpp
View File

@ -608,77 +608,71 @@ namespace Opm
checkMaxWaterCutLimit(const WellEconProductionLimits& econ_production_limits,
const WellState& well_state) const
{
bool water_cut_limit_violated = false;
int worst_offending_completion = INVALIDCOMPLETION;
double violation_extent = -1.0;
const int np = number_of_phases_;
const Opm::PhaseUsage& pu = phaseUsage();
const int well_number = index_of_well_;
assert(FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx));
assert(FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx));
const double oil_rate = well_state.wellRates()[well_number * np + pu.phase_pos[ Oil ] ];
const double water_rate = well_state.wellRates()[well_number * np + pu.phase_pos[ Water ] ];
auto waterCut = [](const double oil_rate, const double water_rate) {
// both rate should be in the same direction
assert(oil_rate * water_rate >= 0.);
const double liquid_rate = oil_rate + water_rate;
double water_cut;
if (std::abs(liquid_rate) != 0.) {
water_cut = water_rate / liquid_rate;
if (liquid_rate != 0.) {
return (water_rate / liquid_rate);
} else {
water_cut = 0.0;
return 0.;
}
};
const int np = number_of_phases_;
const Opm::PhaseUsage& pu = phaseUsage();
const double oil_rate = well_state.wellRates()[index_of_well_ * np + pu.phase_pos[ Oil ] ];
const double water_rate = well_state.wellRates()[index_of_well_ * np + pu.phase_pos[ Water ] ];
const double water_cut = waterCut(oil_rate, water_rate);
const double max_water_cut_limit = econ_production_limits.maxWaterCut();
if (water_cut > max_water_cut_limit) {
water_cut_limit_violated = true;
}
assert(max_water_cut_limit != 0.);
const bool water_cut_limit_violated = (water_cut > max_water_cut_limit);
int worst_offending_completion = INVALIDCOMPLETION;
double violation_extent = -1.0;
if (water_cut_limit_violated) {
// need to handle the worst_offending_connection
const int perf_start = first_perf_;
const int perf_number = number_of_perforations_;
// the maximum water cut value of the completions
double max_water_cut_completion = 0.;
std::vector<double> water_cut_perf(perf_number);
for (int perf = 0; perf < perf_number; ++perf) {
const int i_perf = perf_start + perf;
const double oil_perf_rate = well_state.perfPhaseRates()[i_perf * np + pu.phase_pos[ Oil ] ];
const double water_perf_rate = well_state.perfPhaseRates()[i_perf * np + pu.phase_pos[ Water ] ];
const double liquid_perf_rate = oil_perf_rate + water_perf_rate;
if (std::abs(liquid_perf_rate) != 0.) {
water_cut_perf[perf] = water_perf_rate / liquid_perf_rate;
} else {
water_cut_perf[perf] = 0.;
}
}
const auto& completions = well_ecl_.getCompletions();
const auto& connections = well_ecl_.getConnections();
// look for the worst_offending_completion
for (const auto& completion : completions_) {
int complnumIdx = 0;
std::vector<double> water_cut_in_completions(completions.size(), 0.0);
for (const auto& completion : completions) {
int complnum = completion.first;
for (int perf = 0; perf < perf_number; ++perf) {
if (complnum == connections.get ( perf ).complnum()) {
water_cut_in_completions[complnumIdx] += water_cut_perf[perf];
}
}
complnumIdx++;
double oil_completion_rate = 0.;
double water_completion_rate = 0.;
const std::vector<int>& conns = completion.second;
for(const int c : conns) {
const int index_con = c + first_perf_;
const double oil_connection_rate = well_state.perfPhaseRates()[index_con * np + pu.phase_pos[ Oil ] ];
oil_completion_rate += oil_connection_rate;
const double water_connection_rate = well_state.perfPhaseRates()[index_con * np + pu.phase_pos[ Water ] ];
water_completion_rate += water_connection_rate;
}
double max_water_cut_perf = 0.;
complnumIdx = 0;
for (const auto& completion : completions) {
if (water_cut_in_completions[complnumIdx] > max_water_cut_perf) {
const double water_cut_completion = waterCut(oil_completion_rate, water_completion_rate);
if (water_cut_completion > max_water_cut_completion) {
worst_offending_completion = completion.first;
max_water_cut_perf = water_cut_in_completions[complnumIdx];
}
complnumIdx++;
max_water_cut_completion = water_cut_completion;
}
} // end of for (const auto& completion : completions_)
assert(max_water_cut_limit != 0.);
assert(max_water_cut_completion >= max_water_cut_limit);
assert(worst_offending_completion != INVALIDCOMPLETION);
violation_extent = max_water_cut_perf / max_water_cut_limit;
violation_extent = max_water_cut_completion / max_water_cut_limit;
}
return std::make_tuple(water_cut_limit_violated, worst_offending_completion, violation_extent);