mirror of
https://github.com/OPM/opm-simulators.git
synced 2024-12-28 02:00:59 -06:00
7bdd91d78f
The surface density input in well_perforation_densities() in WellDensitySegmented.hpp is changed from one value pr. phase to one value pr phase and perforation. This allow for different densities in different perforation. The test is changed accordingly.
199 lines
8.5 KiB
C++
199 lines
8.5 KiB
C++
/*
|
|
Copyright 2014 SINTEF ICT, Applied Mathematics.
|
|
|
|
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/>.
|
|
*/
|
|
|
|
#include <opm/autodiff/WellDensitySegmented.hpp>
|
|
#include <opm/core/wells.h>
|
|
#include <opm/autodiff/WellStateFullyImplicitBlackoil.hpp>
|
|
#include <opm/core/utility/ErrorMacros.hpp>
|
|
#include <opm/core/props/BlackoilPhases.hpp>
|
|
#include <numeric>
|
|
#include <cmath>
|
|
|
|
|
|
|
|
|
|
|
|
std::vector<double>
|
|
Opm::WellDensitySegmented::computeConnectionDensities(const Wells& wells,
|
|
const WellStateFullyImplicitBlackoil& wstate,
|
|
const PhaseUsage& phase_usage,
|
|
const std::vector<double>& b_perf,
|
|
const std::vector<double>& rsmax_perf,
|
|
const std::vector<double>& rvmax_perf,
|
|
const std::vector<double>& surf_dens_perf)
|
|
{
|
|
// Verify that we have consistent input.
|
|
const int np = wells.number_of_phases;
|
|
const int nw = wells.number_of_wells;
|
|
const int nperf = wells.well_connpos[nw];
|
|
if (wells.number_of_phases != phase_usage.num_phases) {
|
|
OPM_THROW(std::logic_error, "Inconsistent input: wells vs. phase_usage.");
|
|
}
|
|
if (nperf*np != int(surf_dens_perf.size())) {
|
|
OPM_THROW(std::logic_error, "Inconsistent input: wells vs. surf_dens.");
|
|
}
|
|
if (nperf*np != int(wstate.perfPhaseRates().size())) {
|
|
OPM_THROW(std::logic_error, "Inconsistent input: wells vs. wstate.");
|
|
}
|
|
if (nperf*np != int(b_perf.size())) {
|
|
OPM_THROW(std::logic_error, "Inconsistent input: wells vs. b_perf.");
|
|
}
|
|
if ((!rsmax_perf.empty()) || (!rvmax_perf.empty())) {
|
|
// Need both oil and gas phases.
|
|
if (!phase_usage.phase_used[BlackoilPhases::Liquid]) {
|
|
OPM_THROW(std::logic_error, "Oil phase inactive, but non-empty rsmax_perf or rvmax_perf.");
|
|
}
|
|
if (!phase_usage.phase_used[BlackoilPhases::Vapour]) {
|
|
OPM_THROW(std::logic_error, "Gas phase inactive, but non-empty rsmax_perf or rvmax_perf.");
|
|
}
|
|
}
|
|
|
|
// 1. Compute the flow (in surface volume units for each
|
|
// component) exiting up the wellbore from each perforation,
|
|
// taking into account flow from lower in the well, and
|
|
// in/out-flow at each perforation.
|
|
std::vector<double> q_out_perf(nperf*np);
|
|
for (int w = 0; w < nw; ++w) {
|
|
// Iterate over well perforations from bottom to top.
|
|
for (int perf = wells.well_connpos[w+1] - 1; perf >= wells.well_connpos[w]; --perf) {
|
|
for (int phase = 0; phase < np; ++phase) {
|
|
if (perf == wells.well_connpos[w+1] - 1) {
|
|
// This is the bottom perforation. No flow from below.
|
|
q_out_perf[perf*np + phase] = 0.0;
|
|
} else {
|
|
// Set equal to flow from below.
|
|
q_out_perf[perf*np + phase] = q_out_perf[(perf+1)*np + phase];
|
|
}
|
|
// Subtract outflow through perforation.
|
|
q_out_perf[perf*np + phase] -= wstate.perfPhaseRates()[perf*np + phase];
|
|
}
|
|
}
|
|
}
|
|
|
|
// 2. Compute the component mix at each perforation as the
|
|
// absolute values of the surface rates divided by their sum.
|
|
// Then compute volume ratios (formation factors) for each perforation.
|
|
// Finally compute densities for the segments associated with each perforation.
|
|
const int gaspos = phase_usage.phase_pos[BlackoilPhases::Vapour];
|
|
const int oilpos = phase_usage.phase_pos[BlackoilPhases::Liquid];
|
|
std::vector<double> mix(np);
|
|
std::vector<double> x(np);
|
|
std::vector<double> surf_dens(np);
|
|
std::vector<double> dens(nperf);
|
|
for (int w = 0; w < nw; ++w) {
|
|
for (int perf = wells.well_connpos[w]; perf < wells.well_connpos[w+1]; ++perf) {
|
|
// Find component mix.
|
|
const double tot_surf_rate = std::accumulate(q_out_perf.begin() + np*perf,
|
|
q_out_perf.begin() + np*(perf+1), 0.0);
|
|
if (tot_surf_rate != 0.0) {
|
|
for (int phase = 0; phase < np; ++phase) {
|
|
mix[phase] = std::fabs(q_out_perf[perf*np + phase]/tot_surf_rate);
|
|
}
|
|
} else {
|
|
// No flow => use well specified fractions for mix.
|
|
std::copy(wells.comp_frac + w*np, wells.comp_frac + (w+1)*np, mix.begin());
|
|
}
|
|
// Compute volume ratio.
|
|
x = mix;
|
|
double rs = 0.0;
|
|
double rv = 0.0;
|
|
if (!rsmax_perf.empty() && mix[oilpos] > 0.0) {
|
|
rs = std::min(mix[gaspos]/mix[oilpos], rsmax_perf[perf]);
|
|
}
|
|
if (!rvmax_perf.empty() && mix[gaspos] > 0.0) {
|
|
rv = std::min(mix[oilpos]/mix[gaspos], rvmax_perf[perf]);
|
|
}
|
|
if (rs != 0.0) {
|
|
// Subtract gas in oil from gas mixture
|
|
x[gaspos] = (mix[gaspos] - mix[oilpos]*rs)/(1.0 - rs*rv);
|
|
}
|
|
if (rv != 0.0) {
|
|
// Subtract oil in gas from oil mixture
|
|
x[oilpos] = (mix[oilpos] - mix[gaspos]*rv)/(1.0 - rs*rv);;
|
|
}
|
|
double volrat = 0.0;
|
|
for (int phase = 0; phase < np; ++phase) {
|
|
volrat += x[phase] / b_perf[perf*np + phase];
|
|
}
|
|
for (int phase = 0; phase < np; ++phase) {
|
|
surf_dens[phase] = surf_dens_perf[perf*np + phase];
|
|
}
|
|
|
|
// Compute segment density.
|
|
dens[perf] = std::inner_product(surf_dens.begin(), surf_dens.end(), mix.begin(), 0.0) / volrat;
|
|
}
|
|
}
|
|
|
|
return dens;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
std::vector<double>
|
|
Opm::WellDensitySegmented::computeConnectionPressureDelta(const Wells& wells,
|
|
const std::vector<double>& z_perf,
|
|
const std::vector<double>& dens_perf,
|
|
const double gravity) {
|
|
const int nw = wells.number_of_wells;
|
|
const int nperf = wells.well_connpos[nw];
|
|
|
|
if (nperf != int(z_perf.size())) {
|
|
OPM_THROW(std::logic_error, "Inconsistent input: wells vs. z_perf.");
|
|
}
|
|
if (nperf != int(dens_perf.size())) {
|
|
OPM_THROW(std::logic_error, "Inconsistent input: wells vs. dens_perf.");
|
|
}
|
|
|
|
// Algorithm:
|
|
|
|
// We'll assume the perforations are given in order from top to
|
|
// bottom for each well. By top and bottom we do not necessarily
|
|
// mean in a geometric sense (depth), but in a topological sense:
|
|
// the 'top' perforation is nearest to the surface topologically.
|
|
// Our goal is to compute a pressure delta for each perforation.
|
|
|
|
// 1. Compute pressure differences between perforations.
|
|
// dp_perf will contain the pressure difference between a
|
|
// perforation and the one above it, except for the first
|
|
// perforation for each well, for which it will be the
|
|
// difference to the reference (bhp) depth.
|
|
std::vector<double> dp_perf(nperf);
|
|
for (int w = 0; w < nw; ++w) {
|
|
for (int perf = wells.well_connpos[w]; perf < wells.well_connpos[w+1]; ++perf) {
|
|
const double z_above = perf == wells.well_connpos[w] ? wells.depth_ref[w] : z_perf[perf - 1];
|
|
const double dz = z_perf[perf] - z_above;
|
|
dp_perf[perf] = dz * dens_perf[perf] * gravity;
|
|
}
|
|
}
|
|
|
|
// 2. Compute pressure differences to the reference point (bhp) by
|
|
// accumulating the already computed adjacent pressure
|
|
// differences, storing the result in dp_perf.
|
|
// This accumulation must be done per well.
|
|
for (int w = 0; w < nw; ++w) {
|
|
const auto beg = dp_perf.begin() + wells.well_connpos[w];
|
|
const auto end = dp_perf.begin() + wells.well_connpos[w + 1];
|
|
std::partial_sum(beg, end, beg);
|
|
}
|
|
|
|
return dp_perf;
|
|
}
|