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

Using data::Solution for transfer of 3D data.

Browse Source
This commit is contained in:
Joakim Hove 2016-10-04 15:55:29 +02:00
parent 7e0cb99bad
commit 39be053aef
5 changed files with 153 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
opm/autodiff/Compat.hpp
View File

@ -26,8 +26,9 @@
#include <opm/core/simulator/BlackoilState.hpp>
#include <opm/core/simulator/WellState.hpp>
#include <opm/autodiff/BlackoilSolventState.hpp>
#include <opm/output/Cells.hpp>
#include <opm/output/Wells.hpp>
#include <opm/output/data/Cells.hpp>
#include <opm/output/data/Solution.hpp>
#include <opm/output/data/Wells.hpp>
namespace Opm {
@ -69,13 +70,11 @@ inline std::vector< double >& stripe( const std::vector< double >& v,
inline data::Solution simToSolution( const SimulationDataContainer& reservoir,
PhaseUsage phases ) {
using ds = data::Solution::key;
inline data::Solution simToSolution( const SimulationDataContainer& reservoir,
PhaseUsage phases ) {
data::Solution sol;
sol.insert( ds::PRESSURE, reservoir.pressure() );
sol.insert( ds::TEMP, reservoir.temperature() );
sol.insert( "PRESSURE", UnitSystem::measure::pressure, reservoir.pressure() , data::TargetType::RESTART_SOLUTION);
sol.insert( "TEMP" , UnitSystem::measure::temperature, reservoir.temperature() , data::TargetType::RESTART_SOLUTION );
const auto ph = reservoir.numPhases();
const auto& sat = reservoir.saturation();
@ -84,23 +83,23 @@ inline data::Solution simToSolution( const SimulationDataContainer& reservoir,
const auto vapour = BlackoilPhases::Vapour;
if( phases.phase_used[ aqua ] ) {
sol.insert( ds::SWAT, destripe( sat, ph, phases.phase_pos[ aqua ] ) );
sol.insert( "SWAT", UnitSystem::measure::identity, destripe( sat, ph, phases.phase_pos[ aqua ] ) , data::TargetType::RESTART_SOLUTION );
}
if( phases.phase_used[ vapour ] ) {
sol.insert( ds::SGAS, destripe( sat, ph, phases.phase_pos[ vapour ] ) );
sol.insert( "SGAS", UnitSystem::measure::identity, destripe( sat, ph, phases.phase_pos[ vapour ] ) , data::TargetType::RESTART_SOLUTION );
}
if( reservoir.hasCellData( BlackoilState::GASOILRATIO ) ) {
sol.insert( ds::RS, reservoir.getCellData( BlackoilState::GASOILRATIO ) );
sol.insert( "RS", UnitSystem::measure::identity, reservoir.getCellData( BlackoilState::GASOILRATIO ) , data::TargetType::RESTART_SOLUTION );
}
if( reservoir.hasCellData( BlackoilState::RV ) ) {
sol.insert( ds::RV, reservoir.getCellData( BlackoilState::RV ) );
sol.insert( "RV", UnitSystem::measure::identity, reservoir.getCellData( BlackoilState::RV ) , data::TargetType::RESTART_SOLUTION );
}
if (reservoir.hasCellData( BlackoilSolventState::SSOL)) {
sol.insert( ds::SSOL, reservoir.getCellData( BlackoilSolventState::SSOL ) );
sol.insert( "SSOL", UnitSystem::measure::identity, reservoir.getCellData( BlackoilSolventState::SSOL ) , data::TargetType::RESTART_SOLUTION );
}
sol.sdc = &reservoir;
@ -118,41 +117,40 @@ inline data::Solution simToSolution( const SimulationDataContainer& reservoir,
inline void solutionToSim( const data::Solution& sol,
PhaseUsage phases,
SimulationDataContainer& state ) {
using ds = data::Solution::key;
const auto stride = phases.num_phases;
if( sol.has( ds::SWAT ) ) {
stripe( sol[ ds::SWAT ],
if( sol.has( "SWAT" ) ) {
stripe( sol.data( "SWAT" ),
stride,
phases.phase_pos[ BlackoilPhases::Aqua ],
state.saturation() );
}
if( sol.has( ds::SGAS ) ) {
stripe( sol[ ds::SGAS ],
if( sol.has( "SGAS" ) ) {
stripe( sol.data( "SGAS" ),
stride,
phases.phase_pos[ BlackoilPhases::Vapour ],
state.saturation() );
}
if( sol.has( ds::PRESSURE ) ) {
state.pressure() = sol[ ds::PRESSURE ];
if( sol.has( "PRESSURE" ) ) {
state.pressure() = sol.data( "PRESSURE" );
}
if( sol.has( ds::TEMP ) ) {
state.temperature() = sol[ ds::TEMP ];
if( sol.has( "TEMP" ) ) {
state.temperature() = sol.data( "TEMP" );
}
if( sol.has( ds::RS ) ) {
state.getCellData( "GASOILRATIO" ) = sol[ ds::RS ];
if( sol.has( "RS" ) ) {
state.getCellData( "GASOILRATIO" ) = sol.data( "RS" );
}
if( sol.has( ds::RV ) ) {
state.getCellData( "RV" ) = sol[ ds::RV ];
if( sol.has( "RV" ) ) {
state.getCellData( "RV" ) = sol.data( "RV" );
}
if (sol.has( ds::SSOL ) ) {
state.getCellData("SSOL") = sol [ ds::SSOL];
if (sol.has( "SSOL" ) ) {
state.getCellData("SSOL") = sol.data("SSOL");
}
}

20
opm/autodiff/GeoProps.hpp
View File

@ -33,7 +33,8 @@
#include <opm/parser/eclipse/EclipseState/Grid/TransMult.hpp>
#include <opm/core/grid/PinchProcessor.hpp>
#include <opm/common/utility/platform_dependent/disable_warnings.h>
#include <opm/output/Cells.hpp>
#include <opm/output/data/Cells.hpp>
#include <opm/output/data/Solution.hpp>
#include <Eigen/Eigen>
@ -228,15 +229,15 @@ namespace Opm
/// grid the whole TRAN keyword is quite meaningless.
template <class Grid>
const std::vector<data::CellData> simProps( const Grid& grid ) const {
data::Solution simProps( const Grid& grid ) const {
using namespace UgGridHelpers;
const int* dims = cartDims( grid );
const int globalSize = dims[0] * dims[1] * dims[2];
const auto& trans = this->transmissibility( );
data::CellData tranx = {"TRANX" , UnitSystem::measure::transmissibility, std::vector<double>( globalSize )};
data::CellData trany = {"TRANY" , UnitSystem::measure::transmissibility, std::vector<double>( globalSize )};
data::CellData tranz = {"TRANZ" , UnitSystem::measure::transmissibility, std::vector<double>( globalSize )};
data::CellData tranx = {UnitSystem::measure::transmissibility, std::vector<double>( globalSize ), data::TargetType::INIT};
data::CellData trany = {UnitSystem::measure::transmissibility, std::vector<double>( globalSize ), data::TargetType::INIT};
data::CellData tranz = {UnitSystem::measure::transmissibility, std::vector<double>( globalSize ), data::TargetType::INIT};
size_t num_faces = numFaces(grid);
auto fc = faceCells(grid);
@ -263,12 +264,9 @@ namespace Opm
}
}
std::vector<data::CellData> tran;
tran.push_back( std::move( tranx ));
tran.push_back( std::move( trany ));
tran.push_back( std::move( tranz ));
return tran;
return { {"TRANX" , tranx},
{"TRANY" , trany} ,
{"TRANZ" , tranz } };
}

16
opm/autodiff/SimulatorFullyImplicitBlackoilOutput.cpp
View File

@ -24,7 +24,7 @@
#include <opm/common/data/SimulationDataContainer.hpp>
#include <opm/parser/eclipse/EclipseState/InitConfig/InitConfig.hpp>
#include <opm/output/Cells.hpp>
#include <opm/output/data/Cells.hpp>
#include <opm/core/simulator/BlackoilState.hpp>
#include <opm/core/utility/DataMap.hpp>
#include <opm/autodiff/Compat.hpp>
@ -262,14 +262,14 @@ namespace Opm
std::unique_ptr< SimulatorTimerInterface > timer_;
const SimulationDataContainer state_;
const WellState wellState_;
std::vector<data::CellData> simProps_;
data::Solution simProps_;
const bool substep_;
explicit WriterCall( BlackoilOutputWriter& writer,
const SimulatorTimerInterface& timer,
const SimulationDataContainer& state,
const WellState& wellState,
const std::vector<data::CellData>& simProps,
const data::Solution& simProps,
bool substep )
: writer_( writer ),
timer_( timer.clone() ),
@ -300,8 +300,7 @@ namespace Opm
const WellState& localWellState,
bool substep)
{
std::vector<data::CellData> noCellProperties;
writeTimeStepWithCellProperties(timer, localState, localWellState, noCellProperties, substep);
writeTimeStepWithCellProperties(timer, localState, localWellState, {} , substep);
}
@ -314,7 +313,7 @@ namespace Opm
const SimulatorTimerInterface& timer,
const SimulationDataContainer& localState,
const WellState& localWellState,
const std::vector<data::CellData>& cellData,
const data::Solution& cellData,
bool substep)
{
// VTK output (is parallel if grid is parallel)
@ -360,7 +359,7 @@ namespace Opm
writeTimeStepSerial(const SimulatorTimerInterface& timer,
const SimulationDataContainer& state,
const WellState& wellState,
const std::vector<data::CellData>& simProps,
const data::Solution& simProps,
bool substep)
{
// Matlab output
@ -379,8 +378,7 @@ namespace Opm
substep,
timer.simulationTimeElapsed(),
simToSolution( state, phaseUsage_ ),
wellState.report(phaseUsage_),
simProps);
wellState.report(phaseUsage_));
}
}

243
opm/autodiff/SimulatorFullyImplicitBlackoilOutput.hpp
View File

@ -31,7 +31,8 @@
#include <opm/core/utility/parameters/ParameterGroup.hpp>
#include <opm/core/wells/DynamicListEconLimited.hpp>
#include <opm/output/Cells.hpp>
#include <opm/output/data/Cells.hpp>
#include <opm/output/data/Solution.hpp>
#include <opm/output/eclipse/EclipseWriter.hpp>
#include <opm/autodiff/GridHelpers.hpp>
@ -217,7 +218,7 @@ namespace Opm
const double* permeability );
/** \copydoc Opm::OutputWriter::writeInit */
void writeInit(const std::vector<data::CellData>& simProps, const NNC& nnc);
void writeInit(const data::Solution& simProps, const NNC& nnc);
/*!
* \brief Write a blackoil reservoir state to disk for later inspection with
@ -242,7 +243,7 @@ namespace Opm
const SimulatorTimerInterface& timer,
const SimulationDataContainer& reservoirState,
const Opm::WellState& wellState,
const std::vector<data::CellData>& simProps,
const data::Solution& solution,
bool substep = false);
/*!
@ -264,7 +265,7 @@ namespace Opm
void writeTimeStepSerial(const SimulatorTimerInterface& timer,
const SimulationDataContainer& reservoirState,
const Opm::WellState& wellState,
const std::vector<data::CellData>& simProps,
const data::Solution& cellData,
bool substep);
/** \brief return output directory */
@ -443,18 +444,16 @@ namespace Opm
* Returns the data requested in the restartConfig
*/
template<class Model>
void getRestartData(
std::vector<data::CellData>& output,
const Opm::PhaseUsage& phaseUsage,
const Model& physicalModel,
const RestartConfig& restartConfig,
const int reportStepNum,
const bool log) {
void getRestartData(data::Solution& output,
const Opm::PhaseUsage& phaseUsage,
const Model& physicalModel,
const RestartConfig& restartConfig,
const int reportStepNum,
const bool log) {
typedef Opm::AutoDiffBlock<double> ADB;
const typename Model::SimulatorData& sd = physicalModel.getSimulatorData();
//Get the value of each of the keys for the restart keywords
std::map<std::string, int> rstKeywords = restartConfig.getRestartKeywords(reportStepNum);
for (auto& keyValue : rstKeywords) {
@ -476,27 +475,24 @@ namespace Opm
*/
if (aqua_active && rstKeywords["BW"] > 0) {
rstKeywords["BW"] = 0;
output.emplace_back(data::CellData{
"1OVERBW",
Opm::UnitSystem::measure::water_inverse_formation_volume_factor,
adbToDoubleVector(sd.rq[aqua_idx].b),
true});
output.insert("1OVERBW",
Opm::UnitSystem::measure::water_inverse_formation_volume_factor,
adbToDoubleVector(sd.rq[aqua_idx].b),
data::TargetType::RESTART_AUXILLARY);
}
if (liquid_active && rstKeywords["BO"] > 0) {
rstKeywords["BO"] = 0;
output.emplace_back(data::CellData{
"1OVERBO",
Opm::UnitSystem::measure::oil_inverse_formation_volume_factor,
adbToDoubleVector(sd.rq[liquid_idx].b),
true});
output.insert("1OVERBO",
Opm::UnitSystem::measure::oil_inverse_formation_volume_factor,
adbToDoubleVector(sd.rq[liquid_idx].b),
data::TargetType::RESTART_AUXILLARY);
}
if (vapour_active && rstKeywords["BG"] > 0) {
rstKeywords["BG"] = 0;
output.emplace_back(data::CellData{
"1OVERBG",
Opm::UnitSystem::measure::gas_inverse_formation_volume_factor,
adbToDoubleVector(sd.rq[vapour_idx].b),
true});
output.insert("1OVERBG",
Opm::UnitSystem::measure::gas_inverse_formation_volume_factor,
adbToDoubleVector(sd.rq[vapour_idx].b),
data::TargetType::RESTART_AUXILLARY);
}
/**
@ -505,25 +501,22 @@ namespace Opm
if (rstKeywords["DEN"] > 0) {
rstKeywords["DEN"] = 0;
if (aqua_active) {
output.emplace_back(data::CellData{
"WAT_DEN",
Opm::UnitSystem::measure::density,
adbToDoubleVector(sd.rq[aqua_idx].rho),
true});
output.insert("WAT_DEN",
Opm::UnitSystem::measure::density,
adbToDoubleVector(sd.rq[aqua_idx].rho),
data::TargetType::RESTART_AUXILLARY);
}
if (liquid_active) {
output.emplace_back(data::CellData{
"OIL_DEN",
Opm::UnitSystem::measure::density,
adbToDoubleVector(sd.rq[liquid_idx].rho),
true});
output.insert("OIL_DEN",
Opm::UnitSystem::measure::density,
adbToDoubleVector(sd.rq[liquid_idx].rho),
data::TargetType::RESTART_AUXILLARY);
}
if (vapour_active) {
output.emplace_back(data::CellData{
"GAS_DEN",
Opm::UnitSystem::measure::density,
adbToDoubleVector(sd.rq[vapour_idx].rho),
true});
output.insert("GAS_DEN",
Opm::UnitSystem::measure::density,
adbToDoubleVector(sd.rq[vapour_idx].rho),
data::TargetType::RESTART_AUXILLARY);
}
}
@ -533,25 +526,22 @@ namespace Opm
if (rstKeywords["VISC"] > 0) {
rstKeywords["VISC"] = 0;
if (aqua_active) {
output.emplace_back(data::CellData{
"WAT_VISC",
Opm::UnitSystem::measure::viscosity,
adbToDoubleVector(sd.rq[aqua_idx].mu),
true});
output.insert("WAT_VISC",
Opm::UnitSystem::measure::viscosity,
adbToDoubleVector(sd.rq[aqua_idx].mu),
data::TargetType::RESTART_AUXILLARY);
}
if (liquid_active) {
output.emplace_back(data::CellData{
"OIL_VISC",
Opm::UnitSystem::measure::viscosity,
adbToDoubleVector(sd.rq[liquid_idx].mu),
true});
output.insert("OIL_VISC",
Opm::UnitSystem::measure::viscosity,
adbToDoubleVector(sd.rq[liquid_idx].mu),
data::TargetType::RESTART_AUXILLARY);
}
if (vapour_active) {
output.emplace_back(data::CellData{
"GAS_VISC",
Opm::UnitSystem::measure::viscosity,
adbToDoubleVector(sd.rq[vapour_idx].mu),
true});
output.insert("GAS_VISC",
Opm::UnitSystem::measure::viscosity,
adbToDoubleVector(sd.rq[vapour_idx].mu),
data::TargetType::RESTART_AUXILLARY);
}
}
@ -561,11 +551,10 @@ namespace Opm
if (aqua_active && rstKeywords["KRW"] > 0) {
if (sd.rq[aqua_idx].kr.size() > 0) {
rstKeywords["KRW"] = 0;
output.emplace_back(data::CellData{
"WATKR",
Opm::UnitSystem::measure::permeability,
adbToDoubleVector(sd.rq[aqua_idx].kr),
true});
output.insert("WATKR",
Opm::UnitSystem::measure::permeability,
adbToDoubleVector(sd.rq[aqua_idx].kr),
data::TargetType::RESTART_AUXILLARY);
}
else {
if ( log )
@ -578,11 +567,10 @@ namespace Opm
if (liquid_active && rstKeywords["KRO"] > 0) {
if (sd.rq[liquid_idx].kr.size() > 0) {
rstKeywords["KRO"] = 0;
output.emplace_back(data::CellData{
"OILKR",
Opm::UnitSystem::measure::permeability,
adbToDoubleVector(sd.rq[liquid_idx].kr),
true});
output.insert("OILKR",
Opm::UnitSystem::measure::permeability,
adbToDoubleVector(sd.rq[liquid_idx].kr),
data::TargetType::RESTART_AUXILLARY);
}
else {
if ( log )
@ -595,11 +583,10 @@ namespace Opm
if (vapour_active && rstKeywords["KRG"] > 0) {
if (sd.rq[vapour_idx].kr.size() > 0) {
rstKeywords["KRG"] = 0;
output.emplace_back(data::CellData{
"GASKR",
Opm::UnitSystem::measure::permeability,
adbToDoubleVector(sd.rq[vapour_idx].kr),
true});
output.insert("GASKR",
Opm::UnitSystem::measure::permeability,
adbToDoubleVector(sd.rq[vapour_idx].kr),
data::TargetType::RESTART_AUXILLARY);
}
else {
if ( log )
@ -615,19 +602,17 @@ namespace Opm
*/
if (vapour_active && liquid_active && rstKeywords["RSSAT"] > 0) {
rstKeywords["RSSAT"] = 0;
output.emplace_back(data::CellData{
"RSSAT",
Opm::UnitSystem::measure::gas_oil_ratio,
adbToDoubleVector(sd.rsSat),
true});
output.insert("RSSAT",
Opm::UnitSystem::measure::gas_oil_ratio,
adbToDoubleVector(sd.rsSat),
data::TargetType::RESTART_AUXILLARY);
}
if (vapour_active && liquid_active && rstKeywords["RVSAT"] > 0) {
rstKeywords["RVSAT"] = 0;
output.emplace_back(data::CellData{
"RVSAT",
Opm::UnitSystem::measure::oil_gas_ratio,
adbToDoubleVector(sd.rvSat),
true});
output.insert("RVSAT",
Opm::UnitSystem::measure::oil_gas_ratio,
adbToDoubleVector(sd.rvSat),
data::TargetType::RESTART_AUXILLARY);
}
@ -675,11 +660,10 @@ namespace Opm
* Returns the data as asked for in the summaryConfig
*/
template<class Model>
void getSummaryData(
std::vector<data::CellData>& output,
const Opm::PhaseUsage& phaseUsage,
const Model& physicalModel,
const SummaryConfig& summaryConfig) {
void getSummaryData(data::Solution& output,
const Opm::PhaseUsage& phaseUsage,
const Model& physicalModel,
const SummaryConfig& summaryConfig) {
typedef Opm::AutoDiffBlock<double> ADB;
@ -695,83 +679,74 @@ namespace Opm
*/
// Water in place
if (aqua_active && hasFRBKeyword(summaryConfig, "WIP")) {
output.emplace_back(data::CellData{
"WIP",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_AQUA]),
false});
output.insert("WIP",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_AQUA]),
data::TargetType::SUMMARY );
}
if (liquid_active) {
//Oil in place (liquid phase only)
if (hasFRBKeyword(summaryConfig, "OIPL")) {
output.emplace_back(data::CellData{
"OIPL",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_LIQUID]),
false});
output.insert("OIPL",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_LIQUID]),
data::TargetType::SUMMARY );
}
//Oil in place (gas phase only)
if (hasFRBKeyword(summaryConfig, "OIPG")) {
output.emplace_back(data::CellData{
"OIPG",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_VAPORIZED_OIL]),
false});
output.insert("OIPG",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_VAPORIZED_OIL]),
data::TargetType::SUMMARY );
}
// Oil in place (in liquid and gas phases)
if (hasFRBKeyword(summaryConfig, "OIP")) {
ADB::V oip = sd.fip[Model::SimulatorData::FIP_LIQUID] +
sd.fip[Model::SimulatorData::FIP_VAPORIZED_OIL];
output.emplace_back(data::CellData{
"OIP",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(oip),
false});
output.insert("OIP",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(oip),
data::TargetType::SUMMARY );
}
}
if (vapour_active) {
// Gas in place (gas phase only)
if (hasFRBKeyword(summaryConfig, "GIPG")) {
output.emplace_back(data::CellData{
"GIPG",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_VAPOUR]),
false});
output.insert("GIPG",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_VAPOUR]),
data::TargetType::SUMMARY );
}
// Gas in place (liquid phase only)
if (hasFRBKeyword(summaryConfig, "GIPL")) {
output.emplace_back(data::CellData{
"GIPL",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_DISSOLVED_GAS]),
false});
output.insert("GIPL",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_DISSOLVED_GAS]),
data::TargetType::SUMMARY );
}
// Gas in place (in both liquid and gas phases)
if (hasFRBKeyword(summaryConfig, "GIP")) {
ADB::V gip = sd.fip[Model::SimulatorData::FIP_VAPOUR] +
sd.fip[Model::SimulatorData::FIP_DISSOLVED_GAS];
output.emplace_back(data::CellData{
"GIP",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(gip),
false});
output.insert("GIP",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(gip),
data::TargetType::SUMMARY );
}
}
// Cell pore volume in reservoir conditions
if (hasFRBKeyword(summaryConfig, "RPV")) {
output.emplace_back(data::CellData{
"RPV",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_PV]),
false});
output.insert("RPV",
Opm::UnitSystem::measure::volume,
adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_PV]),
data::TargetType::SUMMARY );
}
// Pressure averaged value (hydrocarbon pore volume weighted)
if (summaryConfig.hasKeyword("FPRH") || summaryConfig.hasKeyword("RPRH")) {
output.emplace_back(data::CellData{
"PRH",
Opm::UnitSystem::measure::pressure,
adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_WEIGHTED_PRESSURE]),
false});
output.insert("PRH",
Opm::UnitSystem::measure::pressure,
adbVToDoubleVector(sd.fip[Model::SimulatorData::FIP_WEIGHTED_PRESSURE]),
data::TargetType::SUMMARY );
}
}
@ -794,8 +769,8 @@ namespace Opm
const int reportStepNum = timer.reportStepNum();
bool logMessages = output_ && parallelOutput_->isIORank();
std::vector<data::CellData> cellData;
detail::getRestartData( cellData, phaseUsage_, physicalModel,
data::Solution cellData;
detail::getRestartData( cellData, phaseUsage_, physicalModel,
restartConfig, reportStepNum, logMessages );
detail::getSummaryData( cellData, phaseUsage_, physicalModel, summaryConfig );

5
opm/polymer/SimulatorPolymer.cpp
View File

@ -610,10 +610,9 @@ namespace Opm
const std::string& output_dir)
{
#ifdef HAVE_ERT
using ds = data::Solution::key;
data::Solution sol;
sol.insert( ds::PRESSURE, state.pressure() );
sol.insert( ds::SWAT, destripe( state.saturation(), 0, 2 ) );
sol.insert( "PRESSURE", UnitSystem::measure::pressure , state.pressure() , data::TargetType::RESTART_SOLUTION );
sol.insert( "SWAT", UnitSystem::measure::identity, destripe( state.saturation(), 0, 2 ) , data::TargetType::RESTART_SOLUTION);
writeECLData( grid.cartdims[ 0 ],
grid.cartdims[ 1 ],