OilfieldToolsNet/opm-common
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

RestartIO: Reimplement save() in Terms of OutputStream::Restart

Browse Source 
This commit switches the file handling operations of the gateway
function RestartIO::save() to using the OutputStream::Restart
component.  Briefly, this means replacing write_kw() function calls
with calls to Restart::write(), especially since the latter natively
handles PaddedString<8> data.
This commit is contained in:
Bård Skaflestad
2019-05-02 23:30:20 +02:00
parent c98bf7d4c8
commit 16e49a0223
4 changed files with 260 additions and 235 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
opm/output/eclipse/RestartIO.hpp
View File

@@ -52,6 +52,11 @@ namespace Opm {
} // namespace Opm
namespace Opm { namespace EclIO { namespace OutputStream {
class Restart;
}}}
/*
The two free functions RestartIO::save() and RestartIO::load() can
@@ -76,15 +81,15 @@ namespace Opm {
*/
namespace Opm { namespace RestartIO {
void save(const std::string& filename,
int report_step,
double seconds_elapsed,
RestartValue value,
const EclipseState& es,
const EclipseGrid& grid,
const Schedule& schedule,
const SummaryState& sumState,
bool write_double = false);
void save(EclIO::OutputStream::Restart& rstFile,
int report_step,
double seconds_elapsed,
RestartValue value,
const EclipseState& es,
const EclipseGrid& grid,
const Schedule& schedule,
const SummaryState& sumState,
bool write_double = false);
std::pair<RestartValue, SummaryState>
load(const std::string& filename,

17
src/opm/output/eclipse/EclipseIO.cpp
View File

@@ -43,6 +43,8 @@
#include <opm/output/eclipse/Tables.hpp>
#include <opm/output/eclipse/WriteRestartHelpers.hpp>
#include <opm/io/eclipse/OutputStream.hpp>
#include <cstdlib>
#include <memory> // unique_ptr
#include <unordered_map>
@@ -532,12 +534,15 @@ void EclipseIO::writeTimeStep(int report_step,
*/
if(!isSubstep && restart.getWriteRestartFile(report_step))
{
std::string filename = ERT::EclFilename( this->impl->outputDir,
this->impl->baseName,
ioConfig.getUNIFOUT() ? ECL_UNIFIED_RESTART_FILE : ECL_RESTART_FILE,
report_step,
ioConfig.getFMTOUT() );
RestartIO::save(filename, report_step, secs_elapsed, value, es, grid, schedule,
EclIO::OutputStream::Restart rstFile {
EclIO::OutputStream::ResultSet { this->impl->outputDir,
this->impl->baseName },
report_step,
EclIO::OutputStream::Formatted { ioConfig.getFMTOUT() },
EclIO::OutputStream::Unified { ioConfig.getUNIFOUT() }
};
RestartIO::save(rstFile, report_step, secs_elapsed, value, es, grid, schedule,
this->impl->summary.get_restart_vectors(), write_double);
}

267
src/opm/output/eclipse/RestartIO.cpp
View File

@@ -30,8 +30,7 @@
#include <opm/output/eclipse/AggregateMSWData.hpp>
#include <opm/output/eclipse/WriteRestartHelpers.hpp>
#include <opm/output/eclipse/libECLRestart.hpp>
#include <opm/io/eclipse/OutputStream.hpp>
#include <opm/io/eclipse/PaddedOutputString.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/SummaryState.hpp>
@@ -39,20 +38,19 @@
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Tuning.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well/Well2.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/Eqldims.hpp>
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <fstream>
#include <initializer_list>
#include <iterator>
#include <string>
#include <unordered_set>
#include <vector>
#include <ert/ecl/FortIO.hpp>
#include <ert/ecl/EclFilename.hpp>
#include <ert/ecl/fortio.h>
namespace Opm { namespace RestartIO {
namespace {
@@ -169,20 +167,6 @@ namespace {
return xwel;
}
std::vector<const char*>
serialize_ZWEL(const std::vector<EclIO::PaddedOutputString<8>>& zwel)
{
std::vector<const char*> data(zwel.size(), nullptr);
std::size_t it = 0;
for (const auto& well : zwel) {
data[it] = well.c_str();
it += 1;
}
return data;
}
void checkSaveArguments(const EclipseState& es,
const RestartValue& restart_value,
const EclipseGrid& grid)
@@ -208,102 +192,37 @@ namespace {
}
}
ert_unique_ptr<ecl_rst_file_type, ecl_rst_file_close>
openRestartFile(const std::string& filename,
const int report_step)
{
auto rst_file = ::Opm::RestartIO::
ert_unique_ptr< ::Opm::RestartIO::ecl_rst_file_type,
::Opm::RestartIO::ecl_rst_file_close>{};
if (::Opm::RestartIO::EclFiletype(filename) == ECL_UNIFIED_RESTART_FILE)
rst_file.reset(::Opm::RestartIO::ecl_rst_file_open_write_seek(filename.c_str(),
report_step));
else
rst_file.reset(::Opm::RestartIO::ecl_rst_file_open_write(filename.c_str()));
return rst_file;
}
ert_unique_ptr<ecl_kw_type, ecl_kw_free>
make_ecl_kw_pointer(const std::string& kw,
const std::vector<double>& data,
const bool write_double)
{
auto kw_ptr = Opm::RestartIO::
ert_unique_ptr< ::Opm::RestartIO::ecl_kw_type, ecl_kw_free>{};
if (write_double) {
::Opm::RestartIO::ecl_kw_type* ecl_kw =
::Opm::RestartIO::ecl_kw_alloc(kw.c_str(), data.size(), ECL_DOUBLE);
::Opm::RestartIO::ecl_kw_set_memcpy_data(ecl_kw , data.data());
kw_ptr.reset(ecl_kw);
}
else {
::Opm::RestartIO::ecl_kw_type* ecl_kw = ::Opm::RestartIO::
ecl_kw_alloc(kw.c_str(), data.size(), ECL_FLOAT);
float* float_data = ecl_kw_get_type_ptr<float>(ecl_kw, ECL_FLOAT_TYPE);
for (auto n = data.size(), i = 0*n; i < n; ++i) {
float_data[i] = static_cast<float>(data[i]);
}
kw_ptr.reset(ecl_kw);
}
return kw_ptr;
}
template <typename T>
void write_kw(::Opm::RestartIO::ecl_rst_file_type* rst_file,
const std::string& keyword,
const std::vector<T>& data)
{
const auto kw = EclKW<T>(keyword, data);
::Opm::RestartIO::ecl_rst_file_add_kw(rst_file, kw.get());
}
std::vector<int>
writeHeader(::Opm::RestartIO::ecl_rst_file_type* rst_file,
const int sim_step,
const int report_step,
const double next_step_size,
const double simTime,
const Schedule& schedule,
const EclipseGrid& grid,
const EclipseState& es)
writeHeader(const int sim_step,
const double next_step_size,
const double simTime,
const Schedule& schedule,
const EclipseGrid& grid,
const EclipseState& es,
EclIO::OutputStream::Restart& rstFile)
{
if (rst_file->unified) {
::Opm::RestartIO::ecl_rst_file_fwrite_SEQNUM(rst_file, report_step);
}
// write INTEHEAD to restart file
const auto ih = Helpers::createInteHead(es, grid, schedule,
simTime, sim_step, sim_step);
write_kw(rst_file, "INTEHEAD", ih);
rstFile.write("INTEHEAD", ih);
// write LOGIHEAD to restart file
const auto lh = Helpers::createLogiHead(es);
write_kw(rst_file, "LOGIHEAD", lh);
rstFile.write("LOGIHEAD", Helpers::createLogiHead(es));
// write DOUBHEAD to restart file
const auto dh = Helpers::createDoubHead(es, schedule, sim_step,
simTime, next_step_size);
write_kw(rst_file, "DOUBHEAD", dh);
rstFile.write("DOUBHEAD", dh);
// return the inteHead vector
return ih;
}
void writeGroup(::Opm::RestartIO::ecl_rst_file_type* rst_file,
int sim_step,
const Schedule& schedule,
const Opm::SummaryState& sumState,
const std::vector<int>& ih)
void writeGroup(int sim_step,
const Schedule& schedule,
const Opm::SummaryState& sumState,
const std::vector<int>& ih,
EclIO::OutputStream::Restart& rstFile)
{
// write IGRP to restart file
const size_t simStep = static_cast<size_t> (sim_step);
@@ -320,20 +239,20 @@ namespace {
grpKeyToInd, fldKeyToInd,
simStep, sumState, ih);
write_kw(rst_file, "IGRP", groupData.getIGroup());
write_kw(rst_file, "SGRP", groupData.getSGroup());
write_kw(rst_file, "XGRP", groupData.getXGroup());
write_kw(rst_file, "ZGRP", serialize_ZWEL(groupData.getZGroup()));
rstFile.write("IGRP", groupData.getIGroup());
rstFile.write("SGRP", groupData.getSGroup());
rstFile.write("XGRP", groupData.getXGroup());
rstFile.write("ZGRP", groupData.getZGroup());
}
void writeMSWData(::Opm::RestartIO::ecl_rst_file_type* rst_file,
int sim_step,
const UnitSystem& units,
const Schedule& schedule,
const EclipseGrid& grid,
const Opm::SummaryState& sumState,
const Opm::data::Wells& wells,
const std::vector<int>& ih)
void writeMSWData(int sim_step,
const UnitSystem& units,
const Schedule& schedule,
const EclipseGrid& grid,
const Opm::SummaryState& sumState,
const Opm::data::Wells& wells,
const std::vector<int>& ih,
EclIO::OutputStream::Restart& rstFile)
{
// write ISEG, RSEG, ILBS and ILBR to restart file
const auto simStep = static_cast<std::size_t> (sim_step);
@@ -342,32 +261,32 @@ namespace {
MSWData.captureDeclaredMSWData(schedule, simStep, units,
ih, grid, sumState, wells);
write_kw(rst_file, "ISEG", MSWData.getISeg());
write_kw(rst_file, "ILBS", MSWData.getILBs());
write_kw(rst_file, "ILBR", MSWData.getILBr());
write_kw(rst_file, "RSEG", MSWData.getRSeg());
rstFile.write("ISEG", MSWData.getISeg());
rstFile.write("ILBS", MSWData.getILBs());
rstFile.write("ILBR", MSWData.getILBr());
rstFile.write("RSEG", MSWData.getRSeg());
}
void writeWell(::Opm::RestartIO::ecl_rst_file_type* rst_file,
int sim_step,
const bool ecl_compatible_rst,
const Phases& phases,
const UnitSystem& units,
const EclipseGrid& grid,
const Schedule& schedule,
const data::Wells& wells,
const Opm::SummaryState& sumState,
const std::vector<int>& ih)
void writeWell(int sim_step,
const bool ecl_compatible_rst,
const Phases& phases,
const UnitSystem& units,
const EclipseGrid& grid,
const Schedule& schedule,
const data::Wells& wells,
const Opm::SummaryState& sumState,
const std::vector<int>& ih,
EclIO::OutputStream::Restart& rstFile)
{
auto wellData = Helpers::AggregateWellData(ih);
wellData.captureDeclaredWellData(schedule, units, sim_step, sumState, ih);
wellData.captureDynamicWellData(schedule, sim_step,
wells, sumState);
write_kw(rst_file, "IWEL", wellData.getIWell());
write_kw(rst_file, "SWEL", wellData.getSWell());
write_kw(rst_file, "XWEL", wellData.getXWell());
write_kw(rst_file, "ZWEL", serialize_ZWEL(wellData.getZWell()));
rstFile.write("IWEL", wellData.getIWell());
rstFile.write("SWEL", wellData.getSWell());
rstFile.write("XWEL", wellData.getXWell());
rstFile.write("ZWEL", wellData.getZWell());
// Extended set of OPM well vectors
if (!ecl_compatible_rst)
@@ -380,17 +299,17 @@ namespace {
const auto opm_iwel = serialize_OPM_IWEL(wells, sched_well_names);
write_kw(rst_file, "OPM_IWEL", opm_iwel);
write_kw(rst_file, "OPM_XWEL", opm_xwel);
rstFile.write("OPM_IWEL", opm_iwel);
rstFile.write("OPM_XWEL", opm_xwel);
}
auto connectionData = Helpers::AggregateConnectionData(ih);
connectionData.captureDeclaredConnData(schedule, grid, units,
wells, sim_step);
write_kw(rst_file, "ICON", connectionData.getIConn());
write_kw(rst_file, "SCON", connectionData.getSConn());
write_kw(rst_file, "XCON", connectionData.getXConn());
rstFile.write("ICON", connectionData.getIConn());
rstFile.write("SCON", connectionData.getSConn());
rstFile.write("XCON", connectionData.getXConn());
}
bool haveHysteresis(const RestartValue& value)
@@ -456,20 +375,26 @@ namespace {
}
}
void writeSolution(ecl_rst_file_type* rst_file,
const RestartValue& value,
const bool ecl_compatible_rst,
const bool write_double_arg)
void writeSolution(const RestartValue& value,
const bool ecl_compatible_rst,
const bool write_double_arg,
EclIO::OutputStream::Restart& rstFile)
{
ecl_rst_file_start_solution(rst_file);
rstFile.message("STARTSOL");
auto write = [rst_file]
auto write = [&rstFile]
(const std::string& key,
const std::vector<double>& data,
const bool write_double) -> void
{
auto kw = make_ecl_kw_pointer(key, data, write_double);
::Opm::RestartIO::ecl_rst_file_add_kw(rst_file, kw.get());
if (write_double) {
rstFile.write(key, data);
}
else {
rstFile.write(key, std::vector<float> {
data.begin(), data.end()
});
}
};
for (const auto& elm : value.solution) {
@@ -492,7 +417,7 @@ namespace {
writeEclipseCompatHysteresis(value, write_double_arg, write);
}
ecl_rst_file_end_solution(rst_file);
rstFile.message("ENDSOL");
if (ecl_compatible_rst) {
return;
@@ -505,41 +430,38 @@ namespace {
}
}
void writeExtraData(::Opm::RestartIO::ecl_rst_file_type* rst_file,
const RestartValue::ExtraVector& extra_data)
void writeExtraData(const RestartValue::ExtraVector& extra_data,
EclIO::OutputStream::Restart& rstFile)
{
for (const auto& extra_value : extra_data) {
const std::string& key = extra_value.first.key;
const std::vector<double>& data = extra_value.second;
if (! extraInSolution(key)) {
ecl_kw_type * ecl_kw = ecl_kw_alloc_new_shared( key.c_str() , data.size() , ECL_DOUBLE , const_cast<double *>(data.data()));
ecl_rst_file_add_kw( rst_file , ecl_kw);
ecl_kw_free( ecl_kw );
}
if (! extraInSolution(key)) {
rstFile.write(key, extra_value.second);
}
}
}
} // Anonymous namespace
void save(const std::string& filename,
int report_step,
double seconds_elapsed,
RestartValue value,
const EclipseState& es,
const EclipseGrid& grid,
const Schedule& schedule,
const SummaryState& sumState,
bool write_double)
void save(EclIO::OutputStream::Restart& rstFile,
int report_step,
double seconds_elapsed,
RestartValue value,
const EclipseState& es,
const EclipseGrid& grid,
const Schedule& schedule,
const SummaryState& sumState,
bool write_double)
{
::Opm::RestartIO::checkSaveArguments(es, value, grid);
const auto ecl_compatible_rst = es.getIOConfig().getEclCompatibleRST();
const auto& ioCfg = es.getIOConfig();
const auto ecl_compatible_rst = ioCfg.getEclCompatibleRST();
const auto sim_step = std::max(report_step - 1, 0);
const auto& units = es.getUnits();
auto rst_file = openRestartFile(filename, report_step);
if (ecl_compatible_rst) {
write_double = false;
}
@@ -548,11 +470,10 @@ void save(const std::string& filename,
value.convertFromSI(units);
const auto inteHD =
writeHeader(rst_file.get(), sim_step, report_step,
nextStepSize(value), seconds_elapsed,
schedule, grid, es);
writeHeader(sim_step, nextStepSize(value), seconds_elapsed,
schedule, grid, es, rstFile);
writeGroup(rst_file.get(), sim_step, schedule, sumState, inteHD);
writeGroup(sim_step, schedule, sumState, inteHD, rstFile);
// Write well and MSW data only when applicable (i.e., when present)
{
@@ -567,20 +488,20 @@ void save(const std::string& filename,
});
if (haveMSW) {
writeMSWData(rst_file.get(), sim_step, units,
schedule, grid, sumState, value.wells, inteHD);
writeMSWData(sim_step, units, schedule, grid, sumState,
value.wells, inteHD, rstFile);
}
writeWell(rst_file.get(), sim_step, ecl_compatible_rst,
writeWell(sim_step, ecl_compatible_rst,
es.runspec().phases(), units, grid, schedule,
value.wells, sumState, inteHD);
value.wells, sumState, inteHD, rstFile);
}
}
writeSolution(rst_file.get(), value, ecl_compatible_rst, write_double);
writeSolution(value, ecl_compatible_rst, write_double, rstFile);
if (! ecl_compatible_rst) {
writeExtraData(rst_file.get(), value.extra);
writeExtraData(value.extra, rstFile);
}
}

188
tests/test_Restart.cpp
View File

@@ -38,6 +38,7 @@
#include <opm/parser/eclipse/Utility/Functional.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/SummaryState.hpp>
#include <opm/io/eclipse/OutputStream.hpp>
// ERT stuff
#include <ert/ecl/ecl_kw.h>
@@ -555,6 +556,8 @@ BOOST_AUTO_TEST_CASE(EclipseReadWriteWellStateData) {
BOOST_AUTO_TEST_CASE(ECL_FORMATTED) {
namespace OS = ::Opm::EclIO::OutputStream;
Setup setup("FIRST_SIM.DATA");
test_work_area_type * test_area = test_work_area_alloc("test_Restart");
auto& io_config = setup.es.getIOConfig();
@@ -568,17 +571,33 @@ BOOST_AUTO_TEST_CASE(ECL_FORMATTED) {
io_config.setEclCompatibleRST( false );
restart_value.addExtra("EXTRA", UnitSystem::measure::pressure, {10,1,2,3});
RestartIO::save("OPM_FILE.UNRST", 1 ,
100,
restart_value,
setup.es,
setup.grid,
setup.schedule,
sumState,
true);
const auto outputDir = std::string {
test_work_area_get_cwd(test_area)
};
{
ecl_file_type * rst_file = ecl_file_open( "OPM_FILE.UNRST" , 0 );
const auto seqnum = 1;
auto rstFile = OS::Restart {
OS::ResultSet{ outputDir, "OPM_FILE" }, seqnum,
OS::Formatted{ false }, OS::Unified{ true }
};
RestartIO::save(rstFile, seqnum,
100,
restart_value,
setup.es,
setup.grid,
setup.schedule,
sumState,
true);
}
{
const auto rstFile = ::Opm::EclIO::OutputStream::
outputFileName({outputDir, "OPM_FILE"}, "UNRST");
ecl_file_type * rst_file = ecl_file_open( rstFile.c_str() , 0 );
ecl_kw_type * swat = ecl_file_iget_named_kw(rst_file, "SWAT", 0);
BOOST_CHECK_EQUAL( ECL_DOUBLE_TYPE, ecl_kw_get_type(swat));
@@ -587,16 +606,28 @@ BOOST_AUTO_TEST_CASE(ECL_FORMATTED) {
}
io_config.setEclCompatibleRST( true );
RestartIO::save("ECL_FILE.UNRST", 1 ,
100,
restart_value,
setup.es,
setup.grid,
setup.schedule,
sumState,
true);
{
ecl_file_type * rst_file = ecl_file_open( "ECL_FILE.UNRST" , 0 );
const auto seqnum = 1;
auto rstFile = OS::Restart {
OS::ResultSet{ outputDir, "ECL_FILE" }, seqnum,
OS::Formatted{ false }, OS::Unified{ true }
};
RestartIO::save(rstFile, seqnum,
100,
restart_value,
setup.es,
setup.grid,
setup.schedule,
sumState,
true);
}
{
const auto rstFile = ::Opm::EclIO::OutputStream::
outputFileName({outputDir, "ECL_FILE"}, "UNRST");
ecl_file_type * rst_file = ecl_file_open( rstFile.c_str() , 0 );
ecl_kw_type * swat = ecl_file_iget_named_kw(rst_file, "SWAT", 0);
BOOST_CHECK_EQUAL( ECL_FLOAT_TYPE, ecl_kw_get_type(swat));
@@ -656,6 +687,8 @@ BOOST_AUTO_TEST_CASE(EclipseReadWriteWellStateData_double) {
BOOST_AUTO_TEST_CASE(WriteWrongSOlutionSize) {
namespace OS = ::Opm::EclIO::OutputStream;
Setup setup("FIRST_SIM.DATA");
test_work_area_type * test_area = test_work_area_alloc("test_Restart");
{
@@ -664,14 +697,20 @@ BOOST_AUTO_TEST_CASE(WriteWrongSOlutionSize) {
auto wells = mkWells();
Opm::SummaryState sumState;
BOOST_CHECK_THROW( RestartIO::save("FILE.UNRST", 1 ,
const auto seqnum = 1;
auto rstFile = OS::Restart {
OS::ResultSet { test_work_area_get_cwd(test_area), "FILE" }, seqnum,
OS::Formatted { false }, OS::Unified { true }
};
BOOST_CHECK_THROW( RestartIO::save(rstFile, seqnum,
100,
RestartValue(cells, wells),
setup.es,
setup.grid ,
setup.schedule,
sumState),
std::runtime_error);
std::runtime_error);
}
test_work_area_free(test_area);
}
@@ -698,6 +737,8 @@ BOOST_AUTO_TEST_CASE(ExtraData_KEYS) {
}
BOOST_AUTO_TEST_CASE(ExtraData_content) {
namespace OS = ::Opm::EclIO::OutputStream;
Setup setup("FIRST_SIM.DATA");
test_work_area_type * test_area = test_work_area_alloc("test_Restart");
{
@@ -711,16 +752,31 @@ BOOST_AUTO_TEST_CASE(ExtraData_content) {
restart_value.addExtra("EXTRA", UnitSystem::measure::pressure, {10,1,2,3});
RestartIO::save("FILE.UNRST", 1 ,
100,
restart_value,
setup.es,
setup.grid,
setup.schedule,
sumState);
const auto outputDir = std::string {
test_work_area_get_cwd(test_area)
};
{
ecl_file_type * f = ecl_file_open( "FILE.UNRST" , 0 );
const auto seqnum = 1;
auto rstFile = OS::Restart {
OS::ResultSet { outputDir, "FILE" }, seqnum,
OS::Formatted { false }, OS::Unified{ true }
};
RestartIO::save(rstFile, seqnum,
100,
restart_value,
setup.es,
setup.grid,
setup.schedule,
sumState);
}
const auto rstFile = ::Opm::EclIO::OutputStream::
outputFileName({outputDir, "FILE"}, "UNRST");
{
ecl_file_type * f = ecl_file_open( rstFile.c_str() , 0 );
BOOST_CHECK( ecl_file_has_kw( f , "EXTRA"));
{
ecl_kw_type * ex = ecl_file_iget_named_kw( f , "EXTRA" , 0 );
@@ -733,11 +789,11 @@ BOOST_AUTO_TEST_CASE(ExtraData_content) {
ecl_file_close( f );
}
BOOST_CHECK_THROW( RestartIO::load( "FILE.UNRST" , 1 , {}, setup.es, setup.grid , setup.schedule,
BOOST_CHECK_THROW( RestartIO::load( rstFile , 1 , {}, setup.es, setup.grid , setup.schedule,
{{"NOT-THIS", UnitSystem::measure::identity, true}}) , std::runtime_error );
{
const auto rst_value = RestartIO::load(
"FILE.UNRST" , 1 ,
rstFile , 1 ,
/* solution_keys = */ {
RestartKey("SWAT", UnitSystem::measure::identity),
RestartKey("NO" , UnitSystem::measure::identity, false)
@@ -765,12 +821,17 @@ BOOST_AUTO_TEST_CASE(ExtraData_content) {
BOOST_AUTO_TEST_CASE(STORE_THPRES) {
namespace OS = ::Opm::EclIO::OutputStream;
Setup setup("FIRST_SIM_THPRES.DATA");
test_work_area_type * test_area = test_work_area_alloc("test_Restart_THPRES");
{
auto num_cells = setup.grid.getNumActive( );
auto cells = mkSolution( num_cells );
auto wells = mkWells();
const auto outputDir = std::string {
test_work_area_get_cwd(test_area)
};
{
RestartValue restart_value(cells, wells);
RestartValue restart_value2(cells, wells);
@@ -792,28 +853,48 @@ BOOST_AUTO_TEST_CASE(STORE_THPRES) {
const auto sumState = sim_state();
/* THPRES data has wrong size in extra container. */
BOOST_CHECK_THROW( RestartIO::save("FILE.UNRST", 1 ,
100,
restart_value,
setup.es,
setup.grid,
setup.schedule,
sumState), std::runtime_error);
{
const auto seqnum = 1;
auto rstFile = OS::Restart {
OS::ResultSet { outputDir, "FILE" }, seqnum,
OS::Formatted { false }, OS::Unified { true }
};
BOOST_CHECK_THROW( RestartIO::save(rstFile, seqnum,
100,
restart_value,
setup.es,
setup.grid,
setup.schedule,
sumState),
std::runtime_error);
}
int num_regions = setup.es.getTableManager().getEqldims().getNumEquilRegions();
std::vector<double> thpres(num_regions * num_regions, 78);
restart_value2.addExtra("THRESHPR", UnitSystem::measure::pressure, thpres);
restart_value2.addExtra("EXTRA", UnitSystem::measure::pressure, thpres);
RestartIO::save("FILE2.UNRST", 1,
100,
restart_value2,
setup.es,
setup.grid,
setup.schedule, sumState);
{
const auto seqnum = 1;
auto rstFile = OS::Restart {
OS::ResultSet { outputDir, "FILE2" }, seqnum,
OS::Formatted { false }, OS::Unified { true }
};
RestartIO::save(rstFile, seqnum,
100,
restart_value2,
setup.es,
setup.grid,
setup.schedule, sumState);
}
{
ecl_file_type * rst_file = ecl_file_open("FILE2.UNRST", 0);
const auto rstFile = ::Opm::EclIO::OutputStream::
outputFileName({outputDir, "FILE2"}, "UNRST");
ecl_file_type * rst_file = ecl_file_open(rstFile.c_str(), 0);
std::map<std::string,int> kw_pos;
for (int i=0; i < ecl_file_get_size(rst_file); i++)
kw_pos[ ecl_file_iget_header(rst_file, i ) ] = i;
@@ -839,6 +920,8 @@ BOOST_AUTO_TEST_CASE(Restore_Cumulatives)
{
Setup setup("FIRST_SIM.DATA");
const auto wa = ::ecl::util::TestArea{"test_Restart"};
// Write fully ECLIPSE compatible output. This also saves cumulatives.
setup.es.getIOConfig().setEclCompatibleRST(true);
@@ -848,10 +931,21 @@ BOOST_AUTO_TEST_CASE(Restore_Cumulatives)
};
const auto sumState = sim_state();
RestartIO::save("FILE.UNRST", 1, 100, restart_value,
setup.es, setup.grid, setup.schedule, sumState);
namespace OS = ::Opm::EclIO::OutputStream;
const auto rst_value = RestartIO::load("FILE.UNRST", 1,
const auto rset = OS::ResultSet{ wa.test_cwd(), "FILE" };
const auto seqnum = 1;
{
auto rstFile = OS::Restart {
rset, seqnum, OS::Formatted{ false }, OS::Unified{ true }
};
RestartIO::save(rstFile, seqnum, 100, restart_value,
setup.es, setup.grid, setup.schedule, sumState);
}
const auto rst_value = RestartIO::
load(OS::outputFileName(rset, "UNRST"), seqnum,
/* solution_keys = */ {
RestartKey("SWAT", UnitSystem::measure::identity),
},