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

Report Pressure Dependent Pore Volume in PRT File

Browse Source 
This commit distinguishes the reference condition pore volume from
the dynamic, pressure (and/or temperature) dependent pore volume
value.  Previously we would report the latter as the 'PORV' value in
the "Field Totals" and "FIPNUM region" reports, but this commit
switches to reporting the former instead-mostly for compatibility.
We still report the dynamic pore volume value, but now we report
this on a line of its own, before the table, using one of the forms

Field total pressure dependent pore volume = 12345 RM3
FIPNUM report region 1 pressure dependent pore volume = 123 RM3
This commit is contained in:
Bård Skaflestad 2021-06-21 16:15:10 +02:00
parent 6f227f8177
commit 6d3da3d2e0
5 changed files with 192 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

292
ebos/eclgenericoutputblackoilmodule.cc
View File

@ -38,6 +38,7 @@
#include <opm/parser/eclipse/Units/Units.hpp> #include <opm/parser/eclipse/Units/Units.hpp>
#include <cassert> #include <cassert>
#include <initializer_list>
#include <iomanip> #include <iomanip>
#include <sstream> #include <sstream>
#include <stdexcept> #include <stdexcept>
@ -827,33 +828,41 @@ doAllocBuffers(unsigned bufferSize,
} }
} }
outputFipRestart_ = false; this->outputFipRestart_ = false;
computeFip_ = false; this->computeFip_ = false;
// Fluid in place // Fluid in place
for (const auto& phase : Inplace::phases()) { for (const auto& phase : Inplace::phases()) {
if (!substep || summaryConfig_.require3DField(EclString(phase))) { if (!substep || summaryConfig_.require3DField(EclString(phase))) {
if (rstKeywords["FIP"] > 0) { if (rstKeywords["FIP"] > 0) {
rstKeywords["FIP"] = 0; rstKeywords["FIP"] = 0;
outputFipRestart_ = true; this->outputFipRestart_ = true;
} }
fip_[phase].resize(bufferSize, 0.0);
computeFip_ = true; this->fip_[phase].resize(bufferSize, 0.0);
this->computeFip_ = true;
}
else {
this->fip_[phase].clear();
} }
else
fip_[phase].clear();
} }
if (!substep || summaryConfig_.hasKeyword("FPR") || summaryConfig_.hasKeyword("FPRP") || !this->RPRNodes_.empty()) { if (!substep ||
fip_[Inplace::Phase::PoreVolume].resize(bufferSize, 0.0); this->summaryConfig_.hasKeyword("FPR") ||
hydrocarbonPoreVolume_.resize(bufferSize, 0.0); this->summaryConfig_.hasKeyword("FPRP") ||
pressureTimesPoreVolume_.resize(bufferSize, 0.0); !this->RPRNodes_.empty())
pressureTimesHydrocarbonVolume_.resize(bufferSize, 0.0); {
this->fip_[Inplace::Phase::PoreVolume].resize(bufferSize, 0.0);
this->dynamicPoreVolume_.resize(bufferSize, 0.0);
this->hydrocarbonPoreVolume_.resize(bufferSize, 0.0);
this->pressureTimesPoreVolume_.resize(bufferSize, 0.0);
this->pressureTimesHydrocarbonVolume_.resize(bufferSize, 0.0);
} }
else { else {
hydrocarbonPoreVolume_.clear(); this->dynamicPoreVolume_.clear();
pressureTimesPoreVolume_.clear(); this->hydrocarbonPoreVolume_.clear();
pressureTimesHydrocarbonVolume_.clear(); this->pressureTimesPoreVolume_.clear();
this->pressureTimesHydrocarbonVolume_.clear();
} }
// Well RFT data // Well RFT data
@ -1074,32 +1083,25 @@ void EclGenericOutputBlackoilModule<FluidSystem,Scalar>::
fipUnitConvert_(std::unordered_map<Inplace::Phase, Scalar>& fip) const fipUnitConvert_(std::unordered_map<Inplace::Phase, Scalar>& fip) const
{ {
const UnitSystem& units = eclState_.getUnits(); const UnitSystem& units = eclState_.getUnits();
if (units.getType() == UnitSystem::UnitType::UNIT_TYPE_FIELD) { using M = UnitSystem::measure;
fip[Inplace::Phase::WATER] = unit::convert::to(fip[Inplace::Phase::WATER], unit::stb);
fip[Inplace::Phase::OIL] = unit::convert::to(fip[Inplace::Phase::OIL], unit::stb); const auto unit_map = std::unordered_map<Inplace::Phase, M> {
fip[Inplace::Phase::OilInLiquidPhase] = unit::convert::to(fip[Inplace::Phase::OilInLiquidPhase], unit::stb); {Inplace::Phase::WATER, M::liquid_surface_volume},
fip[Inplace::Phase::OilInGasPhase] = unit::convert::to(fip[Inplace::Phase::OilInGasPhase], unit::stb); {Inplace::Phase::OIL, M::liquid_surface_volume},
fip[Inplace::Phase::GAS] = unit::convert::to(fip[Inplace::Phase::GAS], 1000*unit::cubic(unit::feet)); {Inplace::Phase::OilInLiquidPhase, M::liquid_surface_volume},
fip[Inplace::Phase::GasInLiquidPhase] = unit::convert::to(fip[Inplace::Phase::GasInLiquidPhase], 1000*unit::cubic(unit::feet)); {Inplace::Phase::OilInGasPhase, M::liquid_surface_volume},
fip[Inplace::Phase::GasInGasPhase] = unit::convert::to(fip[Inplace::Phase::GasInGasPhase], 1000*unit::cubic(unit::feet)); {Inplace::Phase::GAS, M::gas_surface_volume},
fip[Inplace::Phase::PoreVolume] = unit::convert::to(fip[Inplace::Phase::PoreVolume], unit::stb); {Inplace::Phase::GasInLiquidPhase, M::gas_surface_volume},
} {Inplace::Phase::GasInGasPhase, M::gas_surface_volume},
else if (units.getType() == UnitSystem::UnitType::UNIT_TYPE_LAB) { {Inplace::Phase::PoreVolume, M::volume},
Scalar scc = unit::cubic(prefix::centi * unit::meter); //standard cubic cm. {Inplace::Phase::DynamicPoreVolume, M::volume},
fip[Inplace::Phase::WATER] = unit::convert::to(fip[Inplace::Phase::WATER], scc); };
fip[Inplace::Phase::OIL] = unit::convert::to(fip[Inplace::Phase::OIL], scc);
fip[Inplace::Phase::OilInLiquidPhase] = unit::convert::to(fip[Inplace::Phase::OilInLiquidPhase], scc); for (auto& [phase, value] : fip) {
fip[Inplace::Phase::OilInGasPhase] = unit::convert::to(fip[Inplace::Phase::OilInGasPhase], scc); auto unitPos = unit_map.find(phase);
fip[Inplace::Phase::GAS] = unit::convert::to(fip[Inplace::Phase::GAS], scc); if (unitPos != unit_map.end()) {
fip[Inplace::Phase::GasInLiquidPhase] = unit::convert::to(fip[Inplace::Phase::GasInLiquidPhase], scc); value = units.from_si(unitPos->second, value);
fip[Inplace::Phase::GasInGasPhase] = unit::convert::to(fip[Inplace::Phase::GasInGasPhase], scc); }
fip[Inplace::Phase::PoreVolume] = unit::convert::to(fip[Inplace::Phase::PoreVolume], scc);
}
else if (units.getType() == UnitSystem::UnitType::UNIT_TYPE_METRIC) {
// nothing to do
}
else {
throw std::runtime_error("Unsupported unit type for fluid in place output.");
} }
} }
@ -1107,20 +1109,8 @@ template<class FluidSystem, class Scalar>
void EclGenericOutputBlackoilModule<FluidSystem,Scalar>:: void EclGenericOutputBlackoilModule<FluidSystem,Scalar>::
pressureUnitConvert_(Scalar& pav) const pressureUnitConvert_(Scalar& pav) const
{ {
const UnitSystem& units = eclState_.getUnits(); pav = this->eclState_.getUnits()
if (units.getType() == UnitSystem::UnitType::UNIT_TYPE_FIELD) { .from_si(UnitSystem::measure::pressure, pav);
pav = unit::convert::to(pav, unit::psia);
}
else if (units.getType() == UnitSystem::UnitType::UNIT_TYPE_METRIC) {
pav = unit::convert::to(pav, unit::barsa);
}
else if (units.getType() == UnitSystem::UnitType::UNIT_TYPE_LAB) {
pav = unit::convert::to(pav, unit::atm);
}
else {
throw std::runtime_error("Unsupported unit type for fluid in place output.");
}
} }
template<class FluidSystem, class Scalar> template<class FluidSystem, class Scalar>
@ -1133,11 +1123,25 @@ outputRegionFluidInPlace_(std::unordered_map<Inplace::Phase, Scalar> oip,
return; return;
// don't output FIPNUM report if the region has no porv. // don't output FIPNUM report if the region has no porv.
if (cip[Inplace::Phase::PoreVolume] == 0) if (! (cip[Inplace::Phase::PoreVolume] > Scalar{0}))
return; return;
const UnitSystem& units = eclState_.getUnits(); const UnitSystem& units = eclState_.getUnits();
std::ostringstream ss; std::ostringstream ss;
ss << '\n';
if (reg == 0) {
ss << "Field total";
}
else {
ss << "FIPNUM report region " << reg;
}
ss << " pressure dependent pore volume = "
<< std::fixed << std::setprecision(0)
<< cip[Inplace::Phase::DynamicPoreVolume] << ' '
<< units.name(UnitSystem::measure::volume) << "\n\n";
if (reg == 0) { if (reg == 0) {
ss << " ===================================================\n" ss << " ===================================================\n"
<< " : Field Totals :\n"; << " : Field Totals :\n";
@ -1304,12 +1308,12 @@ isOutputCreationDirective_(const std::string& keyword)
template<class FluidSystem, class Scalar> template<class FluidSystem, class Scalar>
Scalar EclGenericOutputBlackoilModule<FluidSystem,Scalar>:: Scalar EclGenericOutputBlackoilModule<FluidSystem,Scalar>::
pressureAverage_(const Scalar& pressurePvHydrocarbon, pressureAverage_(const Scalar& pressurePvHydrocarbon,
const Scalar& pvHydrocarbon, const Scalar& pvHydrocarbon,
const Scalar& pressurePv, const Scalar& pressurePv,
const Scalar& pv, const Scalar& pv,
bool hydrocarbon) const bool hydrocarbon)
{ {
if (pvHydrocarbon > 1e-10 && hydrocarbon) if (hydrocarbon && (pvHydrocarbon > 1e-10))
return pressurePvHydrocarbon / pvHydrocarbon; return pressurePvHydrocarbon / pvHydrocarbon;
return pressurePv / pv; return pressurePv / pv;
@ -1319,20 +1323,25 @@ template<class FluidSystem,class Scalar>
typename EclGenericOutputBlackoilModule<FluidSystem,Scalar>::ScalarBuffer typename EclGenericOutputBlackoilModule<FluidSystem,Scalar>::ScalarBuffer
EclGenericOutputBlackoilModule<FluidSystem,Scalar>:: EclGenericOutputBlackoilModule<FluidSystem,Scalar>::
pressureAverage_(const ScalarBuffer& pressurePvHydrocarbon, pressureAverage_(const ScalarBuffer& pressurePvHydrocarbon,
const ScalarBuffer& pvHydrocarbon, const ScalarBuffer& pvHydrocarbon,
const ScalarBuffer& pressurePv, const ScalarBuffer& pressurePv,
const ScalarBuffer& pv, const ScalarBuffer& pv,
bool hydrocarbon) const bool hydrocarbon)
{ {
size_t size = pressurePvHydrocarbon.size(); const std::size_t size = pressurePvHydrocarbon.size();
assert(pvHydrocarbon.size() == size); assert(pvHydrocarbon.size() == size);
assert(pressurePv.size() == size); assert(pressurePv.size() == size);
assert(pv.size() == size); assert(pv.size() == size);
ScalarBuffer fraction(size, 0.0); ScalarBuffer fraction(size, 0.0);
for (size_t i = 0; i < size; ++i) { for (std::size_t i = 0; i < size; ++i) {
fraction[i] = pressureAverage_(pressurePvHydrocarbon[i], pvHydrocarbon[i], pressurePv[i], pv[i], hydrocarbon); fraction[i] = pressureAverage_(pressurePvHydrocarbon[i],
pvHydrocarbon[i],
pressurePv[i],
pv[i],
hydrocarbon);
} }
return fraction; return fraction;
} }
@ -1421,13 +1430,15 @@ outputFipLogImpl(const Inplace& inplace) const
current_values[phase] = inplace.get(phase); current_values[phase] = inplace.get(phase);
} }
current_values[Inplace::Phase::DynamicPoreVolume] =
inplace.get(Inplace::Phase::DynamicPoreVolume);
fipUnitConvert_(initial_values); fipUnitConvert_(initial_values);
fipUnitConvert_(current_values); fipUnitConvert_(current_values);
pressureUnitConvert_(fieldHydroCarbonPoreVolumeAveragedPressure); pressureUnitConvert_(fieldHydroCarbonPoreVolumeAveragedPressure);
outputRegionFluidInPlace_(initial_values, outputRegionFluidInPlace_(std::move(initial_values),
current_values, std::move(current_values),
fieldHydroCarbonPoreVolumeAveragedPressure); fieldHydroCarbonPoreVolumeAveragedPressure);
} }
@ -1439,6 +1450,10 @@ outputFipLogImpl(const Inplace& inplace) const
initial_values[phase] = this->initialInplace_->get("FIPNUM", phase, reg); initial_values[phase] = this->initialInplace_->get("FIPNUM", phase, reg);
current_values[phase] = inplace.get("FIPNUM", phase, reg); current_values[phase] = inplace.get("FIPNUM", phase, reg);
} }
current_values[Inplace::Phase::DynamicPoreVolume] =
inplace.get("FIPNUM", Inplace::Phase::DynamicPoreVolume, reg);
fipUnitConvert_(initial_values); fipUnitConvert_(initial_values);
fipUnitConvert_(current_values); fipUnitConvert_(current_values);
@ -1449,7 +1464,9 @@ outputFipLogImpl(const Inplace& inplace) const
inplace.get("FIPNUM", Inplace::Phase::PoreVolume, reg), inplace.get("FIPNUM", Inplace::Phase::PoreVolume, reg),
true); true);
pressureUnitConvert_(regHydroCarbonPoreVolumeAveragedPressure); pressureUnitConvert_(regHydroCarbonPoreVolumeAveragedPressure);
outputRegionFluidInPlace_(initial_values, current_values, regHydroCarbonPoreVolumeAveragedPressure, reg); outputRegionFluidInPlace_(std::move(initial_values),
std::move(current_values),
regHydroCarbonPoreVolumeAveragedPressure, reg);
} }
} }
@ -1466,33 +1483,55 @@ template<class FluidSystem,class Scalar>
void EclGenericOutputBlackoilModule<FluidSystem,Scalar>:: void EclGenericOutputBlackoilModule<FluidSystem,Scalar>::
update(Inplace& inplace, update(Inplace& inplace,
const std::string& region_name, const std::string& region_name,
Inplace::Phase phase, const Inplace::Phase phase,
std::size_t ntFip, const std::size_t ntFip,
const std::vector<double>& values) const ScalarBuffer& values)
{ {
double sum = 0; double sum = 0.0;
for (std::size_t region_number = 0; region_number < ntFip; region_number++) { for (std::size_t region_number = 0; region_number < ntFip; ++region_number) {
inplace.add( region_name, phase, region_number + 1, values[region_number] ); const auto rval = static_cast<double>(values[region_number]);
sum += values[region_number]; inplace.add(region_name, phase, region_number + 1, rval);
sum += rval;
} }
inplace.add( phase, sum ); inplace.add(phase, sum);
} }
template<class FluidSystem,class Scalar> template<class FluidSystem,class Scalar>
void EclGenericOutputBlackoilModule<FluidSystem,Scalar>:: void EclGenericOutputBlackoilModule<FluidSystem,Scalar>::
makeRegionSum(Inplace& inplace, makeRegionSum(Inplace& inplace,
const std::string& region_name, const std::string& region_name,
const Comm& comm) const Comm& comm) const
{ {
const auto& region = this->regions_.at(region_name); const auto& region = this->regions_.at(region_name);
std::size_t ntFip = this->regionMax(region, comm); const std::size_t ntFip = this->regionMax(region, comm);
update(inplace, region_name, Inplace::Phase::PressurePV, ntFip, this->regionSum(this->pressureTimesPoreVolume_, region, ntFip, comm)); auto update_inplace =
update(inplace, region_name, Inplace::Phase::HydroCarbonPV, ntFip, this->regionSum(this->hydrocarbonPoreVolume_, region, ntFip, comm)); [&inplace, &region, &region_name, &comm, ntFip, this]
update(inplace, region_name, Inplace::Phase::PressureHydroCarbonPV, ntFip, this->regionSum(this->pressureTimesHydrocarbonVolume_, region, ntFip, comm)); (const Inplace::Phase phase,
const std::vector<Scalar>& value)
{
update(inplace, region_name, phase, ntFip,
this->regionSum(value, region, ntFip, comm));
};
for (const auto& phase : Inplace::phases()) update_inplace(Inplace::Phase::PressurePV,
update(inplace, region_name, phase, ntFip, this->regionSum(this->fip_[phase], region, ntFip, comm)); this->pressureTimesPoreVolume_);
update_inplace(Inplace::Phase::HydroCarbonPV,
this->hydrocarbonPoreVolume_);
update_inplace(Inplace::Phase::PressureHydroCarbonPV,
this->pressureTimesHydrocarbonVolume_);
update_inplace(Inplace::Phase::DynamicPoreVolume,
this->dynamicPoreVolume_);
for (const auto& phase : Inplace::phases()) {
auto fipPos = this->fip_.find(phase);
if (fipPos != this->fip_.end()) {
update_inplace(phase, fipPos->second);
}
}
} }
template<class FluidSystem,class Scalar> template<class FluidSystem,class Scalar>
@ -1501,9 +1540,8 @@ accumulateRegionSums(const Comm& comm)
{ {
Inplace inplace; Inplace inplace;
for (const auto& [region_name, _] : this->regions_) { for (const auto& region : this->regions_) {
(void)_; makeRegionSum(inplace, region.first, comm);
makeRegionSum(inplace, region_name, comm);
} }
// The first time the outputFipLog function is run we store the inplace values in // The first time the outputFipLog function is run we store the inplace values in
@ -1537,54 +1575,68 @@ updateSummaryRegionValues(const Inplace& inplace,
// The field summary vectors should only use the FIPNUM based region sum. // The field summary vectors should only use the FIPNUM based region sum.
{ {
for (const auto& phase : Inplace::phases()) { for (const auto& phase : Inplace::phases()) {
std::string key = "F" + EclString(phase); const std::string key = "F" + EclString(phase);
if (summaryConfig_.hasKeyword(key)) if (this->summaryConfig_.hasKeyword(key)) {
miscSummaryData[key] = inplace.get(phase); miscSummaryData[key] = inplace.get(phase);
}
} }
if (summaryConfig_.hasKeyword("FOE") && this->initialInplace_) if (this->summaryConfig_.hasKeyword("FOE") && this->initialInplace_) {
miscSummaryData["FOE"] = inplace.get(Inplace::Phase::OIL) miscSummaryData["FOE"] = inplace.get(Inplace::Phase::OIL)
/ this->initialInplace_.value().get(Inplace::Phase::OIL); / this->initialInplace_.value().get(Inplace::Phase::OIL);
}
if (summaryConfig_.hasKeyword("FPR")) if (this->summaryConfig_.hasKeyword("FPR")) {
miscSummaryData["FPR"] = pressureAverage_(inplace.get(Inplace::Phase::PressureHydroCarbonPV), miscSummaryData["FPR"] =
inplace.get(Inplace::Phase::HydroCarbonPV), pressureAverage_(inplace.get(Inplace::Phase::PressureHydroCarbonPV),
inplace.get(Inplace::Phase::PressurePV), inplace.get(Inplace::Phase::HydroCarbonPV),
inplace.get(Inplace::Phase::PoreVolume), inplace.get(Inplace::Phase::PressurePV),
true); inplace.get(Inplace::Phase::PoreVolume),
true);
}
if (this->summaryConfig_.hasKeyword("FPRP")) {
if (summaryConfig_.hasKeyword("FPRP")) miscSummaryData["FPRP"] =
miscSummaryData["FPRP"] = pressureAverage_(inplace.get(Inplace::Phase::PressureHydroCarbonPV), pressureAverage_(inplace.get(Inplace::Phase::PressureHydroCarbonPV),
inplace.get(Inplace::Phase::HydroCarbonPV), inplace.get(Inplace::Phase::HydroCarbonPV),
inplace.get(Inplace::Phase::PressurePV), inplace.get(Inplace::Phase::PressurePV),
inplace.get(Inplace::Phase::PoreVolume), inplace.get(Inplace::Phase::PoreVolume),
false); false);
}
} }
// The region summary vectors should loop through the FIPxxx regions to // The region summary vectors should loop through the FIPxxx regions to
// support the RPR__xxx summary keywords. // support the RPR__xxx summary keywords.
{ {
auto get_vector = [&inplace]
(const auto& node,
const Inplace::Phase phase)
{
return inplace.get_vector(node.fip_region(), phase);
};
for (const auto& phase : Inplace::phases()) { for (const auto& phase : Inplace::phases()) {
for (const auto& node : this->regionNodes_.at(phase)) for (const auto& node : this->regionNodes_.at(phase))
regionData[node.keyword()] = inplace.get_vector(node.fip_region(), phase); regionData[node.keyword()] = get_vector(node, phase);
} }
// The exact same quantity is calculated for RPR and RPRP - is that correct? for (const auto& node : this->RPRNodes_) {
for (const auto& node : this->RPRNodes_) regionData[node.keyword()] =
regionData[node.keyword()] = pressureAverage_(inplace.get_vector(node.fip_region(), Inplace::Phase::PressureHydroCarbonPV), pressureAverage_(get_vector(node, Inplace::Phase::PressureHydroCarbonPV),
inplace.get_vector(node.fip_region(), Inplace::Phase::HydroCarbonPV), get_vector(node, Inplace::Phase::HydroCarbonPV),
inplace.get_vector(node.fip_region(), Inplace::Phase::PressurePV), get_vector(node, Inplace::Phase::PressurePV),
inplace.get_vector(node.fip_region(), Inplace::Phase::PoreVolume), get_vector(node, Inplace::Phase::PoreVolume),
true); true);
}
for (const auto& node : this->RPRPNodes_) {
for (const auto& node : this->RPRPNodes_) regionData[node.keyword()] =
regionData[node.keyword()] = pressureAverage_(inplace.get_vector(node.fip_region(), Inplace::Phase::PressureHydroCarbonPV), pressureAverage_(get_vector(node, Inplace::Phase::PressureHydroCarbonPV),
inplace.get_vector(node.fip_region(), Inplace::Phase::HydroCarbonPV), get_vector(node, Inplace::Phase::HydroCarbonPV),
inplace.get_vector(node.fip_region(), Inplace::Phase::PressurePV), get_vector(node, Inplace::Phase::PressurePV),
inplace.get_vector(node.fip_region(), Inplace::Phase::PoreVolume), get_vector(node, Inplace::Phase::PoreVolume),
false); false);
}
} }
} }

11
ebos/eclgenericoutputblackoilmodule.hh
View File

@ -261,7 +261,7 @@ protected:
void makeRegionSum(Inplace& inplace, void makeRegionSum(Inplace& inplace,
const std::string& region_name, const std::string& region_name,
const Comm& comm); const Comm& comm) const;
Inplace accumulateRegionSums(const Comm& comm); Inplace accumulateRegionSums(const Comm& comm);
@ -285,7 +285,7 @@ protected:
// Sum Fip values over regions. // Sum Fip values over regions.
static ScalarBuffer regionSum(const ScalarBuffer& property, static ScalarBuffer regionSum(const ScalarBuffer& property,
const std::vector<int>& regionId, const std::vector<int>& regionId,
size_t maxNumberOfRegions, const std::size_t maxNumberOfRegions,
const Comm& comm); const Comm& comm);
static int regionMax(const std::vector<int>& region, static int regionMax(const std::vector<int>& region,
@ -293,9 +293,9 @@ protected:
static void update(Inplace& inplace, static void update(Inplace& inplace,
const std::string& region_name, const std::string& region_name,
Inplace::Phase phase, const Inplace::Phase phase,
std::size_t ntFip, const std::size_t ntFip,
const std::vector<double>& values); const ScalarBuffer& values);
static Scalar sum(const ScalarBuffer& v); static Scalar sum(const ScalarBuffer& v);
@ -332,6 +332,7 @@ protected:
ScalarBuffer hydrocarbonPoreVolume_; ScalarBuffer hydrocarbonPoreVolume_;
ScalarBuffer pressureTimesPoreVolume_; ScalarBuffer pressureTimesPoreVolume_;
ScalarBuffer pressureTimesHydrocarbonVolume_; ScalarBuffer pressureTimesHydrocarbonVolume_;
ScalarBuffer dynamicPoreVolume_;
ScalarBuffer oilPressure_; ScalarBuffer oilPressure_;
ScalarBuffer temperature_; ScalarBuffer temperature_;
ScalarBuffer rs_; ScalarBuffer rs_;

11
ebos/ecloutputblackoilmodule.hh
View File

@ -623,15 +623,18 @@ private:
// PORV, MINPV and friends). Also note that because of this, the porosity // PORV, MINPV and friends). Also note that because of this, the porosity
// returned by the intensive quantities can be outside of the physical // returned by the intensive quantities can be outside of the physical
// range [0, 1] in pathetic cases. // range [0, 1] in pathetic cases.
const double pv = const auto totVolume =
elemCtx.simulator().model().dofTotalVolume(globalDofIdx) elemCtx.simulator().model().dofTotalVolume(globalDofIdx);
* intQuants.porosity().value(); const double pv = totVolume * intQuants.porosity().value();
if (!this->pressureTimesHydrocarbonVolume_.empty() && !this->pressureTimesPoreVolume_.empty()) { if (!this->pressureTimesHydrocarbonVolume_.empty() && !this->pressureTimesPoreVolume_.empty()) {
assert(this->hydrocarbonPoreVolume_.size() == this->pressureTimesHydrocarbonVolume_.size()); assert(this->hydrocarbonPoreVolume_.size() == this->pressureTimesHydrocarbonVolume_.size());
assert(this->fip_[Inplace::Phase::PoreVolume].size() == this->pressureTimesPoreVolume_.size()); assert(this->fip_[Inplace::Phase::PoreVolume].size() == this->pressureTimesPoreVolume_.size());
this->fip_[Inplace::Phase::PoreVolume][globalDofIdx] = pv; this->fip_[Inplace::Phase::PoreVolume][globalDofIdx] =
totVolume * intQuants.referencePorosity();
this->dynamicPoreVolume_[globalDofIdx] = pv;
Scalar hydrocarbon = 0.0; Scalar hydrocarbon = 0.0;
if (FluidSystem::phaseIsActive(oilPhaseIdx)) if (FluidSystem::phaseIsActive(oilPhaseIdx))

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

@ -222,11 +222,12 @@ namespace Opm {
data::Wells wellData() const data::Wells wellData() const
{ {
auto wsrpt = this->wellState().report(UgGridHelpers::globalCell(grid()), auto wsrpt = this->wellState()
[this](const int well_ndex) -> bool .report(UgGridHelpers::globalCell(grid()),
{ [this](const int well_ndex) -> bool
return this->wasDynamicallyShutThisTimeStep(well_ndex); {
}); return this->wasDynamicallyShutThisTimeStep(well_ndex);
});
this->assignWellGuideRates(wsrpt); this->assignWellGuideRates(wsrpt);
this->assignShutConnections(wsrpt, this->reportStepIndex()); this->assignShutConnections(wsrpt, this->reportStepIndex());

2
opm/simulators/wells/WellState.cpp
View File

@ -492,7 +492,7 @@ void WellState::gatherVectorsOnRoot(const std::vector<data::Connection>& from_co
data::Wells data::Wells
WellState::report(const int* globalCellIdxMap, WellState::report(const int* globalCellIdxMap,
const std::function<bool(const int)>& wasDynamicallyClosed) const const std::function<bool(const int)>& wasDynamicallyClosed) const
{ {
if (this->numWells() == 0) if (this->numWells() == 0)
return {}; return {};