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

Some clean-up

Browse Source 
Dont' output rs, rv, somax and hysteresis if they are not enabled.
We no longer output the same as legacy.
This commit is contained in:
Tor Harald Sandve 2018-01-22 13:38:50 +01:00
parent 85ed4bffbf
commit b021ee54ca
3 changed files with 88 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

172
ebos/ecloutputblackoilmodule.hh
View File

@ -121,9 +121,20 @@ public:
const Opm::SummaryConfig summaryConfig = simulator_.gridManager().summaryConfig(); const Opm::SummaryConfig summaryConfig = simulator_.gridManager().summaryConfig();
blockValues_.clear(); blockValues_.clear();
// Only output RESTART_AUXILIARY asked for by the user.
std::map<std::string, int> rstKeywords = restartConfig.getRestartKeywords(reportStepNum);
for (auto& keyValue : rstKeywords) {
keyValue.second = restartConfig.getKeyword(keyValue.first, reportStepNum);
}
outputFipRestart_ = false;
// Fluid in place // Fluid in place
for (int i = 0; i<FIPDataType::numFipValues; i++) { for (int i = 0; i<FIPDataType::numFipValues; i++) {
if (!substep || summaryConfig.require3DField(stringOfEnumIndex_(i))) { if (!substep || summaryConfig.require3DField(stringOfEnumIndex_(i))) {
if (rstKeywords["FIP"] > 0) {
rstKeywords["FIP"] = 0;
outputFipRestart_ = true;
}
fip_[i].resize(bufferSize, 0.0); fip_[i].resize(bufferSize, 0.0);
} }
} }
@ -141,24 +152,23 @@ public:
outputRestart_ = true; outputRestart_ = true;
// always output saturation of active phases
for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++ phaseIdx) { for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++ phaseIdx) {
if (!FluidSystem::phaseIsActive(phaseIdx)) if (!FluidSystem::phaseIsActive(phaseIdx))
continue; continue;
saturation_[phaseIdx].resize(bufferSize,0.0); saturation_[phaseIdx].resize(bufferSize,0.0);
} }
// and oil pressure
oilPressure_.resize(bufferSize,0.0); oilPressure_.resize(bufferSize,0.0);
if (true) if (true) // adding some logic here when the energy module is done
temperature_.resize(bufferSize,0.0); temperature_.resize(bufferSize,0.0);
// Output the same as legacy if (FluidSystem::enableDissolvedGas()) {
// TODO: Only needed if DISGAS or VAPOIL
if (true) {
rs_.resize(bufferSize,0.0); rs_.resize(bufferSize,0.0);
} }
if (true) { if (FluidSystem::enableVaporizedOil()) {
rv_.resize(bufferSize,0.0); rv_.resize(bufferSize,0.0);
} }
@ -169,33 +179,23 @@ public:
cPolymer_.resize(bufferSize,0.0); cPolymer_.resize(bufferSize,0.0);
} }
if (true) { if (simulator_.problem().vapparsActive())
// Output the same as legacy
// TODO: Only needed if Vappars or hysteresis.
soMax_.resize(bufferSize,0.0); soMax_.resize(bufferSize,0.0);
if (simulator_.problem().materialLawManager()->enableHysteresis()) {
pcSwMdcOw_.resize(bufferSize,0.0); pcSwMdcOw_.resize(bufferSize,0.0);
krnSwMdcOw_.resize(bufferSize,0.0); krnSwMdcOw_.resize(bufferSize,0.0);
pcSwMdcGo_.resize(bufferSize,0.0); pcSwMdcGo_.resize(bufferSize,0.0);
krnSwMdcGo_.resize(bufferSize,0.0); krnSwMdcGo_.resize(bufferSize,0.0);
} }
// Only output RESTART_AUXILIARY asked for by the user. if (FluidSystem::enableDissolvedGas() && rstKeywords["RSSAT"] > 0) {
std::map<std::string, int> rstKeywords = restartConfig.getRestartKeywords(reportStepNum); rstKeywords["RSSAT"] = 0;
for (auto& keyValue : rstKeywords) { gasDissolutionFactor_.resize(bufferSize,0.0);
keyValue.second = restartConfig.getKeyword(keyValue.first, reportStepNum);
} }
if (FluidSystem::enableVaporizedOil() && rstKeywords["RVSAT"] > 0) {
// Output the same as legacy rstKeywords["RVSAT"] = 0;
// TODO: Only needed if DISGAS or VAPOIL oilVaporizationFactor_.resize(bufferSize,0.0);
if (FluidSystem::phaseIsActive(oilPhaseIdx) && FluidSystem::phaseIsActive(gasPhaseIdx)) {
if (rstKeywords["RSSAT"] > 0) {
rstKeywords["RSSAT"] = 0;
gasDissolutionFactor_.resize(bufferSize,0.0);
}
if (rstKeywords["RVSAT"] > 0) {
rstKeywords["RVSAT"] = 0;
oilVaporizationFactor_.resize(bufferSize,0.0);
}
} }
if (FluidSystem::phaseIsActive(waterPhaseIdx) && rstKeywords["BW"] > 0) if (FluidSystem::phaseIsActive(waterPhaseIdx) && rstKeywords["BW"] > 0)
@ -569,11 +569,11 @@ public:
int global_index = node.num() - 1; int global_index = node.num() - 1;
std::pair<std::string, int> key = std::make_pair(node.keyword(), node.num()); std::pair<std::string, int> key = std::make_pair(node.keyword(), node.num());
if (global_index == globalIdx) { if (global_index == globalIdx) {
if (strcmp(node.keyword(),"BGSAT")) { if (key.first == "BWSAT") {
blockValues_[key] = Toolbox::value(fs.saturation(waterPhaseIdx)); blockValues_[key] = Toolbox::value(fs.saturation(waterPhaseIdx));
} else if (strcmp(node.keyword(),"BWSAT")) { } else if (key.first == "BGSAT") {
blockValues_[key] = Toolbox::value(fs.saturation(gasPhaseIdx)); blockValues_[key] = Toolbox::value(fs.saturation(gasPhaseIdx));
} else if (strcmp(node.keyword(),"BPR")) { } else if (key.first == "BPR") {
blockValues_[key] = Toolbox::value(fs.pressure(oilPhaseIdx)); blockValues_[key] = Toolbox::value(fs.pressure(oilPhaseIdx));
} }
} }
@ -754,10 +754,9 @@ public:
if (bubblePointPressure_.size() > 0) if (bubblePointPressure_.size() > 0)
sol.insert ("PBUB", Opm::UnitSystem::measure::pressure, std::move(bubblePointPressure_), Opm::data::TargetType::RESTART_AUXILIARY); sol.insert ("PBUB", Opm::UnitSystem::measure::pressure, std::move(bubblePointPressure_), Opm::data::TargetType::RESTART_AUXILIARY);
// Summary FIP output
// Fluid in place // Fluid in place
for (int i = 0; i<FIPDataType::numFipValues; i++) { for (int i = 0; i<FIPDataType::numFipValues; i++) {
if (fip_[i].size() > 0) { if (outputFipRestart_ && fip_[i].size() > 0) {
sol.insert(stringOfEnumIndex_(i), sol.insert(stringOfEnumIndex_(i),
Opm::UnitSystem::measure::volume, Opm::UnitSystem::measure::volume,
fip_[i] , fip_[i] ,
@ -774,33 +773,30 @@ public:
ntFip = comm.max(ntFip); ntFip = comm.max(ntFip);
// sum values over each region // sum values over each region
ScalarBuffer regionValues[FIPDataType::numFipValues]; ScalarBuffer regionFipValues[FIPDataType::numFipValues];
for (int i = 0; i<FIPDataType::numFipValues; i++) { for (int i = 0; i<FIPDataType::numFipValues; i++) {
regionValues[i] = FIPTotals_(fip_[i], fipnum_, ntFip); regionFipValues[i] = FIPTotals_(fip_[i], fipnum_, ntFip);
if (isIORank_() && origRegionValues_[i].empty()) if (isIORank_() && origRegionValues_[i].empty())
origRegionValues_[i] = regionValues[i]; origRegionValues_[i] = regionFipValues[i];
} }
// sum all region values to compute the field total // sum all region values to compute the field total
std::vector<int> fieldNum(ntFip, 1); std::vector<int> fieldNum(ntFip, 1);
ScalarBuffer totalValues(FIPDataType::numFipValues,0.0); ScalarBuffer fieldFipValues(FIPDataType::numFipValues,0.0);
for (int i = 0; i<FIPDataType::numFipValues; i++) { bool comunicateSum = false; // the regionValues are already summed over all ranks.
bool comunicateSum = false; // the regionValues are already summed over all ranks. for (int i = 0; i<FIPDataType::numFipValues; i++) {
const ScalarBuffer& tmp = FIPTotals_(regionValues[i], fieldNum, 1, comunicateSum); const ScalarBuffer& tmp = FIPTotals_(regionFipValues[i], fieldNum, 1, comunicateSum);
totalValues[i] = tmp[0]; // fieldFipValues[i] = tmp[0]; //
} }
// compute the hydrocarbon averaged pressure over the field.
Scalar totalPoreVolumeAveragedPressure;
Scalar totalHydroCarbonPoreVolumeAveragedPressure;
pressureAverage_(-1, totalPoreVolumeAveragedPressure, totalHydroCarbonPoreVolumeAveragedPressure);
// compute the hydrocarbon averaged pressure over the regions. // compute the hydrocarbon averaged pressure over the regions.
ScalarBuffer regPoreVolumeAveragedPressure(ntFip,0.0); ScalarBuffer regPressurePv = FIPTotals_(pPv_, fipnum_, ntFip);
ScalarBuffer regHydroCarbonPoreVolumeAveragedPressure(ntFip,0.0); ScalarBuffer regPvHydrocarbon = FIPTotals_(pvHydrocarbon_, fipnum_, ntFip);
for (size_t reg = 0; reg < ntFip; ++reg ) { ScalarBuffer regPressurePvHydrocarbon = FIPTotals_(pPvHydrocarbon_, fipnum_, ntFip);
pressureAverage_(reg + 1, regPoreVolumeAveragedPressure[reg], regHydroCarbonPoreVolumeAveragedPressure[reg]);
} ScalarBuffer fieldPressurePv = FIPTotals_(regPressurePv, fieldNum, 1, comunicateSum);
ScalarBuffer fieldPvHydrocarbon = FIPTotals_(regPvHydrocarbon, fieldNum, 1, comunicateSum);
ScalarBuffer fieldPressurePvHydrocarbon = FIPTotals_(regPressurePvHydrocarbon, fieldNum, 1, comunicateSum);
// output on io rank // output on io rank
// the original Fip values are stored on the first step // the original Fip values are stored on the first step
@ -812,38 +808,39 @@ public:
for (int i = 0; i<FIPDataType::numFipValues; i++) { for (int i = 0; i<FIPDataType::numFipValues; i++) {
std::string key = "F" + stringOfEnumIndex_(i); std::string key = "F" + stringOfEnumIndex_(i);
if (summaryConfig.hasKeyword(key)) if (summaryConfig.hasKeyword(key))
miscSummaryData[key] = totalValues[i]; miscSummaryData[key] = fieldFipValues[i];
} }
if (summaryConfig.hasKeyword("FOE") && !origTotalValues_.empty()) if (summaryConfig.hasKeyword("FOE") && !origTotalValues_.empty())
miscSummaryData["FOE"] = totalValues[FIPDataType::OilInPlace] / origTotalValues_[FIPDataType::OilInPlace]; miscSummaryData["FOE"] = fieldFipValues[FIPDataType::OilInPlace] / origTotalValues_[FIPDataType::OilInPlace];
if (summaryConfig.hasKeyword("FPR")) if (summaryConfig.hasKeyword("FPR"))
miscSummaryData["FPR"] = totalHydroCarbonPoreVolumeAveragedPressure; miscSummaryData["FPR"] = pressureAverage_(fieldPressurePvHydrocarbon[0], fieldPvHydrocarbon[0], fieldPressurePv[0], fieldFipValues[FIPDataType::PoreVolume], true);
if (summaryConfig.hasKeyword("FPRP")) if (summaryConfig.hasKeyword("FPRP"))
miscSummaryData["FPRP"] = totalPoreVolumeAveragedPressure; miscSummaryData["FPR"] = pressureAverage_(fieldPressurePvHydrocarbon[0], fieldPvHydrocarbon[0], fieldPressurePv[0], fieldFipValues[FIPDataType::PoreVolume], false);
// Region summary output // Region summary output
for (int i = 0; i<FIPDataType::numFipValues; i++) { for (int i = 0; i<FIPDataType::numFipValues; i++) {
std::string key = "R" + stringOfEnumIndex_(i); std::string key = "R" + stringOfEnumIndex_(i);
if (summaryConfig.hasKeyword(key)) if (summaryConfig.hasKeyword(key))
regionData[key] = regionValues[i]; regionData[key] = regionFipValues[i];
} }
if (summaryConfig.hasKeyword("RPR")) if (summaryConfig.hasKeyword("RPR"))
regionData["RPR"] = regHydroCarbonPoreVolumeAveragedPressure; regionData["RPR"] = pressureAverage_(regPressurePvHydrocarbon, regPvHydrocarbon, regPressurePv, regionFipValues[FIPDataType::PoreVolume], true);
if (summaryConfig.hasKeyword("FPRP")) if (summaryConfig.hasKeyword("RPRP"))
regionData["FPRP"] = regPoreVolumeAveragedPressure; regionData["RPRP"] = pressureAverage_(regPressurePvHydrocarbon, regPvHydrocarbon, regPressurePv, regionFipValues[FIPDataType::PoreVolume], false);
// Output to log // Output to log
if (!substep) { if (!substep) {
FIPUnitConvert_(totalValues); FIPUnitConvert_(fieldFipValues);
if (origTotalValues_.empty()) if (origTotalValues_.empty())
origTotalValues_ = totalValues; origTotalValues_ = fieldFipValues;
pressureUnitConvert_(totalHydroCarbonPoreVolumeAveragedPressure); Scalar fieldHydroCarbonPoreVolumeAveragedPressure = pressureAverage_(fieldPressurePvHydrocarbon[0], fieldPvHydrocarbon[0], fieldPressurePv[0], fieldFipValues[FIPDataType::PoreVolume], true);
outputRegionFluidInPlace_(origTotalValues_, totalValues, totalHydroCarbonPoreVolumeAveragedPressure, 0); pressureUnitConvert_(fieldHydroCarbonPoreVolumeAveragedPressure);
outputRegionFluidInPlace_(origTotalValues_, fieldFipValues, fieldHydroCarbonPoreVolumeAveragedPressure, 0);
for (size_t reg = 0; reg < ntFip; ++reg ) { for (size_t reg = 0; reg < ntFip; ++reg ) {
ScalarBuffer tmpO(FIPDataType::numFipValues,0.0); ScalarBuffer tmpO(FIPDataType::numFipValues,0.0);
for (int i = 0; i<FIPDataType::numFipValues; i++) { for (int i = 0; i<FIPDataType::numFipValues; i++) {
@ -852,11 +849,12 @@ public:
FIPUnitConvert_(tmpO); FIPUnitConvert_(tmpO);
ScalarBuffer tmp(FIPDataType::numFipValues,0.0); ScalarBuffer tmp(FIPDataType::numFipValues,0.0);
for (int i = 0; i<FIPDataType::numFipValues; i++) { for (int i = 0; i<FIPDataType::numFipValues; i++) {
tmp[i] = regionValues[i][reg]; tmp[i] = regionFipValues[i][reg];
} }
FIPUnitConvert_(tmp); FIPUnitConvert_(tmp);
pressureUnitConvert_(regHydroCarbonPoreVolumeAveragedPressure[reg]); Scalar regHydroCarbonPoreVolumeAveragedPressure = pressureAverage_(regPressurePvHydrocarbon[reg], regPvHydrocarbon[reg], regPressurePv[reg], regionFipValues[FIPDataType::PoreVolume][reg], true);
outputRegionFluidInPlace_(tmpO, tmp, regHydroCarbonPoreVolumeAveragedPressure[reg], reg + 1); pressureUnitConvert_(regHydroCarbonPoreVolumeAveragedPressure);
outputRegionFluidInPlace_(tmpO, tmp, regHydroCarbonPoreVolumeAveragedPressure, reg + 1);
} }
} }
} }
@ -865,7 +863,6 @@ public:
void setRestart(const Opm::data::Solution& sol, unsigned elemIdx, unsigned globalDofIndex) void setRestart(const Opm::data::Solution& sol, unsigned elemIdx, unsigned globalDofIndex)
{ {
Scalar so = 1.0; Scalar so = 1.0;
if( sol.has( "SWAT" ) ) { if( sol.has( "SWAT" ) ) {
saturation_[waterPhaseIdx][elemIdx] = sol.data("SWAT")[globalDofIndex]; saturation_[waterPhaseIdx][elemIdx] = sol.data("SWAT")[globalDofIndex];
@ -1068,39 +1065,24 @@ private:
return totals; return totals;
} }
// computes the pore volume weighted averaged pressure ScalarBuffer pressureAverage_(const ScalarBuffer& pressurePvHydrocarbon, const ScalarBuffer& pvHydrocarbon, const ScalarBuffer& pressurePv, const ScalarBuffer& pv, bool hydrocarbon) {
// of a region (reg) and the hydrocarbon volume weighted average size_t size = pressurePvHydrocarbon.size();
// if reg == -1, the field average is computed. assert(pvHydrocarbon.size() == size);
void pressureAverage_(int reg, Scalar& poreVolumeAveragedPressure, Scalar& hydroCarbonPoreVolumeAveragedPressure) assert(pressurePv.size() == size);
{ assert(pv.size() == size);
Scalar pPvSum = 0.0;
Scalar pvSum = 0.0; ScalarBuffer fraction(size,0.0);
Scalar pPvHydrocarbonSum = 0.0; for (size_t i = 0; i < size; ++i) {
Scalar pvHydrocarbonSum = 0.0; fraction[i] = pressureAverage_(pressurePvHydrocarbon[i], pvHydrocarbon[i], pressurePv[i], pv[i], hydrocarbon);
size_t numElem = pPv_.size();
for (size_t elem = 0; elem < numElem; ++elem) {
//ignore ghost cells (all ghost cells has fipnum == 0)
if(static_cast<int>(fipnum_[elem]) == reg || (-1 == reg && fipnum_[elem] > 0) )
{
pPvSum += pPv_[elem];;
pvSum += fip_[FIPDataType::PoreVolume][elem];
pPvHydrocarbonSum += pPvHydrocarbon_[elem];
pvHydrocarbonSum += pvHydrocarbon_[elem];
}
} }
const auto& comm = simulator_.gridView().comm(); return fraction;
pPvSum = comm.sum(pPvSum); }
pvSum = comm.sum(pvSum);
pPvHydrocarbonSum = comm.sum(pPvHydrocarbonSum);
pvHydrocarbonSum = comm.sum(pvHydrocarbonSum);
poreVolumeAveragedPressure = pPvSum / pvSum; Scalar pressureAverage_(const Scalar& pressurePvHydrocarbon, const Scalar& pvHydrocarbon, const Scalar& pressurePv, const Scalar& pv, bool hydrocarbon) {
// use porevolume weighted pressure if no hydrocarbon if (pvHydrocarbon > 1e-10 && hydrocarbon)
hydroCarbonPoreVolumeAveragedPressure = poreVolumeAveragedPressure; return pressurePvHydrocarbon / pvHydrocarbon;
if (pvHydrocarbonSum > 1e-10)
hydroCarbonPoreVolumeAveragedPressure = pPvHydrocarbonSum / pvHydrocarbonSum;
return pressurePv / pv;
} }
void FIPUnitConvert_(ScalarBuffer& fip) void FIPUnitConvert_(ScalarBuffer& fip)
@ -1199,6 +1181,7 @@ private:
const Simulator& simulator_; const Simulator& simulator_;
bool outputRestart_; bool outputRestart_;
bool outputFipRestart_;
ScalarBuffer saturation_[numPhases]; ScalarBuffer saturation_[numPhases];
ScalarBuffer oilPressure_; ScalarBuffer oilPressure_;
@ -1229,7 +1212,6 @@ private:
ScalarBuffer fip_[FIPDataType::numFipValues]; ScalarBuffer fip_[FIPDataType::numFipValues];
ScalarBuffer origTotalValues_; ScalarBuffer origTotalValues_;
ScalarBuffer origRegionValues_[FIPDataType::numFipValues]; ScalarBuffer origRegionValues_[FIPDataType::numFipValues];
ScalarBuffer pv_;
ScalarBuffer pvHydrocarbon_; ScalarBuffer pvHydrocarbon_;
ScalarBuffer pPv_; ScalarBuffer pPv_;
ScalarBuffer pPvHydrocarbon_; ScalarBuffer pPvHydrocarbon_;

5
ebos/eclproblem.hh
View File

@ -1176,6 +1176,11 @@ public:
const Opm::EclipseIO& eclIO() const const Opm::EclipseIO& eclIO() const
{ return eclWriter_->eclIO(); } { return eclWriter_->eclIO(); }
bool vapparsActive() const
{
return vapparsActive_;
}
private: private:
Scalar cellCenterDepth( const Element& element ) const Scalar cellCenterDepth( const Element& element ) const
{ {

11
ebos/eclwriter.hh
View File

@ -83,6 +83,7 @@ class EclWriter
typedef typename GET_PROP_TYPE(TypeTag, Grid) Grid; typedef typename GET_PROP_TYPE(TypeTag, Grid) Grid;
typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar; typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;
typedef typename GET_PROP_TYPE(TypeTag, ElementContext) ElementContext; typedef typename GET_PROP_TYPE(TypeTag, ElementContext) ElementContext;
typedef typename GET_PROP_TYPE(TypeTag, FluidSystem) FluidSystem;
typedef typename GridView::template Codim<0>::Entity Element; typedef typename GridView::template Codim<0>::Entity Element;
typedef typename GridView::template Codim<0>::Iterator ElementIterator; typedef typename GridView::template Codim<0>::Iterator ElementIterator;
@ -199,11 +200,11 @@ public:
void restartBegin() void restartBegin()
{ {
std::map<std::string, Opm::RestartKey> solution_keys {{"PRESSURE" , Opm::RestartKey(Opm::UnitSystem::measure::pressure)}, std::map<std::string, Opm::RestartKey> solution_keys {{"PRESSURE" , Opm::RestartKey(Opm::UnitSystem::measure::pressure)},
{"SWAT" , Opm::RestartKey(Opm::UnitSystem::measure::identity)}, {"SWAT" , Opm::RestartKey(Opm::UnitSystem::measure::identity, FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx))},
{"SGAS" , Opm::RestartKey(Opm::UnitSystem::measure::identity)}, {"SGAS" , Opm::RestartKey(Opm::UnitSystem::measure::identity, FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx))},
{"TEMP" , Opm::RestartKey(Opm::UnitSystem::measure::temperature)}, {"TEMP" , Opm::RestartKey(Opm::UnitSystem::measure::temperature)}, // always required for now
{"RS" , Opm::RestartKey(Opm::UnitSystem::measure::gas_oil_ratio)}, {"RS" , Opm::RestartKey(Opm::UnitSystem::measure::gas_oil_ratio, FluidSystem::enableDissolvedGas())},
{"RV" , Opm::RestartKey(Opm::UnitSystem::measure::oil_gas_ratio)}, {"RV" , Opm::RestartKey(Opm::UnitSystem::measure::oil_gas_ratio, FluidSystem::enableVaporizedOil())},
{"SOMAX", {Opm::UnitSystem::measure::identity, false}}, {"SOMAX", {Opm::UnitSystem::measure::identity, false}},
{"PCSWM_OW", {Opm::UnitSystem::measure::identity, false}}, {"PCSWM_OW", {Opm::UnitSystem::measure::identity, false}},
{"KRNSW_OW", {Opm::UnitSystem::measure::identity, false}}, {"KRNSW_OW", {Opm::UnitSystem::measure::identity, false}},