OilfieldToolsNet/opm-common
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
3ecf6db2e0
opm-common/tests/test_OutputStream.cpp

2429 lines
81 KiB
C++
Raw Normal View History

Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
/*
Copyright 2019 Equinor
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/>.
*/
#define BOOST_TEST_MODULE OutputStream
#include <boost/test/unit_test.hpp>
#include <opm/io/eclipse/OutputStream.hpp>
#include <opm/io/eclipse/EclFile.hpp>
#include <opm/io/eclipse/EclOutput.hpp>
#include <opm/io/eclipse/ERst.hpp>
Add RFT Output Stream This commit introduces a new output stream, 'RFT', that is intended as a new backend for writing RFT files. At present this supports integer, float, and PaddedOutputString<8> element types since those are the types needed for basic RFT data. We will extend the element support if needed for PLT and/or Segment data. We support formatted and unformatted output streams and distinguish between opening a new stream and opening an existing output stream (essentially between open modes ios_base::out and ios_base::app). Add unit tests to exercise the possible combinations.
2019-08-28 02:54:41 -05:00
#include <opm/io/eclipse/PaddedOutputString.hpp>
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
#include <opm/io/eclipse/EclIOdata.hpp>
#include <algorithm>
Add File Manager Stream for Summary Specification This commit introduces a new OutputStream class for representing the summary specification file (.SMSPEC). The stream is constructed with constant data (output directory, basename, start date &c), and provides a single write() member function that outputs a summary specification. Each call to write rewinds the underlying stream's output position. Class EclOutput grants friendship to the new output stream class in order to support easy stream rewinding. Add a unit test to exercise the new class.
2019-09-30 12:00:54 -05:00
#include <chrono>
#include <ctime>
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
#include <iterator>
#include <ostream>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>
changed: use std::filesystem instead of boost::filesystem since we still support g++-7, where filesystem is marked experimental, we introduce a wrapper header and expose the namespace to use as Opm::filesystem. for gcc we unconditionally link with libstdc++fs in the python bindings. the setup.py stuff links as c code, not c++ code, so it is not automatically added on any gcc version. this might prove unportable later.
2020-02-12 02:12:29 -06:00
#include <opm/common/utility/FileSystem.hpp>
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
namespace Opm { namespace EclIO {
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
// Needed by BOOST_CHECK_EQUAL_COLLECTIONS.
std::ostream&
operator<<(std::ostream& os, const EclFile::EclEntry& e)
{
os << "{ " << std::get<0>(e)
<< ", " << static_cast<int>(std::get<1>(e))
<< ", " << std::get<2>(e)
<< " }";
return os;
}
}} // Namespace Opm::ecl
namespace {
template <class Coll>
void check_is_close(const Coll& c1, const Coll& c2)
{
using ElmType = typename std::remove_cv<
typename std::remove_reference<
typename std::iterator_traits<
decltype(std::begin(c1))
>::value_type
>::type
>::type;
for (auto b1 = c1.begin(), e1 = c1.end(), b2 = c2.begin();
b1 != e1; ++b1, ++b2)
{
BOOST_CHECK_CLOSE(*b1, *b2, static_cast<ElmType>(1.0e-7));
}
}
} // Anonymous namespace
BOOST_AUTO_TEST_SUITE(FileName)
BOOST_AUTO_TEST_CASE(ResultSetDescriptor)
{
fixed: gcc8+ filesystem will collapse the multiple slashes
2020-02-14 09:14:15 -06:00
const auto odir = std::string{"/x/y/z/"};
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto ext = std::string{"F0123"};
{
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto rset = ::Opm::EclIO::OutputStream::ResultSet {
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
odir, "CASE"
};
const auto fname = outputFileName(rset, ext);
BOOST_CHECK_EQUAL(fname, odir + "CASE.F0123");
}
{
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto rset = ::Opm::EclIO::OutputStream::ResultSet {
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
odir, "CASE." // CASE DOT
};
const auto fname = outputFileName(rset, ext);
BOOST_CHECK_EQUAL(fname, odir + "CASE.F0123");
}
{
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto rset = ::Opm::EclIO::OutputStream::ResultSet {
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
odir, "CASE.01"
};
const auto fname = outputFileName(rset, ext);
BOOST_CHECK_EQUAL(fname, odir + "CASE.01.F0123");
}
{
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto rset = ::Opm::EclIO::OutputStream::ResultSet {
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
odir, "CASE.01." // CASE.01 DOT
};
const auto fname = outputFileName(rset, ext);
BOOST_CHECK_EQUAL(fname, odir + "CASE.01.F0123");
}
}
BOOST_AUTO_TEST_SUITE_END() // FileName
// ==========================================================================
class RSet
{
public:
explicit RSet(std::string base)
changed: use std::filesystem instead of boost::filesystem since we still support g++-7, where filesystem is marked experimental, we introduce a wrapper header and expose the namespace to use as Opm::filesystem. for gcc we unconditionally link with libstdc++fs in the python bindings. the setup.py stuff links as c code, not c++ code, so it is not automatically added on any gcc version. this might prove unportable later.
2020-02-12 02:12:29 -06:00
: odir_(Opm::filesystem::temp_directory_path() /
Opm::unique_path("rset-%%%%"))
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
, base_(std::move(base))
{
changed: use std::filesystem instead of boost::filesystem since we still support g++-7, where filesystem is marked experimental, we introduce a wrapper header and expose the namespace to use as Opm::filesystem. for gcc we unconditionally link with libstdc++fs in the python bindings. the setup.py stuff links as c code, not c++ code, so it is not automatically added on any gcc version. this might prove unportable later.
2020-02-12 02:12:29 -06:00
Opm::filesystem::create_directories(this->odir_);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
}
~RSet()
{
changed: use std::filesystem instead of boost::filesystem since we still support g++-7, where filesystem is marked experimental, we introduce a wrapper header and expose the namespace to use as Opm::filesystem. for gcc we unconditionally link with libstdc++fs in the python bindings. the setup.py stuff links as c code, not c++ code, so it is not automatically added on any gcc version. this might prove unportable later.
2020-02-12 02:12:29 -06:00
Opm::filesystem::remove_all(this->odir_);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
}
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
operator ::Opm::EclIO::OutputStream::ResultSet() const
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
{
return { this->odir_.string(), this->base_ };
}
private:
changed: use std::filesystem instead of boost::filesystem since we still support g++-7, where filesystem is marked experimental, we introduce a wrapper header and expose the namespace to use as Opm::filesystem. for gcc we unconditionally link with libstdc++fs in the python bindings. the setup.py stuff links as c code, not c++ code, so it is not automatically added on any gcc version. this might prove unportable later.
2020-02-12 02:12:29 -06:00
Opm::filesystem::path odir_;
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
std::string base_;
};
File Output: Add Manager for 'INIT' File Based on EclOutput This commit introduces a new file manager, Opm::EclIO::OutputStream::Init that's intended to replace the low-level operations of Flow's INIT file writer. The implementation uses the 'EclOutput' class and is very similar to that of the 'Restart' stream introduced in commit 992d3b0c. The commonality between the two file managers might possibly be extracted to a base class at a later time. As of right now, the Init class supports outputting vectors of 'int', 'bool', 'float', and 'double'. Additional types will be supported when needed.
2019-06-19 11:46:26 -05:00
// ==========================================================================
BOOST_AUTO_TEST_SUITE(Class_Init)
BOOST_AUTO_TEST_CASE(Unformatted)
{
const auto rset = RSet("CASE");
const auto fmt = ::Opm::EclIO::OutputStream::Formatted{ false };
{
auto init = ::Opm::EclIO::OutputStream::Init {
rset, fmt
};
init.write("I", std::vector<int> {1, 7, 2, 9});
init.write("L", std::vector<bool> {true, false, false, true});
init.write("S", std::vector<float> {3.1f, 4.1f, 59.265f});
init.write("D", std::vector<double>{2.71, 8.21});
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "INIT");
auto init = ::Opm::EclIO::EclFile{fname};
BOOST_CHECK(init.hasKey("I"));
BOOST_CHECK(init.hasKey("L"));
BOOST_CHECK(init.hasKey("S"));
BOOST_CHECK(init.hasKey("D"));
{
const auto vectors = init.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"I", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"L", Opm::EclIO::eclArrType::LOGI, 4},
Opm::EclIO::EclFile::EclEntry{"S", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"D", Opm::EclIO::eclArrType::DOUB, 2},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
init.loadData();
{
const auto& I = init.get<int>("I");
const auto expect_I = std::vector<int>{ 1, 7, 2, 9 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& L = init.get<bool>("L");
const auto expect_L = std::vector<bool> {
true, false, false, true,
};
BOOST_CHECK_EQUAL_COLLECTIONS(L.begin(), L.end(),
expect_L.begin(),
expect_L.end());
}
{
const auto& S = init.get<float>("S");
const auto expect_S = std::vector<float>{
3.1f, 4.1f, 59.265f,
};
check_is_close(S, expect_S);
}
{
const auto& D = init.get<double>("D");
const auto expect_D = std::vector<double>{
2.71, 8.21,
};
check_is_close(D, expect_D);
}
}
// Second write request replaces original contents
{
auto init = ::Opm::EclIO::OutputStream::Init {
rset, fmt
};
init.write("I2", std::vector<int> {1, 2, 3, 4, 5, 6});
init.write("L2", std::vector<bool> {false, false, true, true});
init.write("S2", std::vector<float> {-1.0f, 2.0f, -3.0e-4f});
init.write("D2", std::vector<double>{2.71, 8.21, 18.28459});
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "INIT");
auto init = ::Opm::EclIO::EclFile{fname};
BOOST_CHECK(!init.hasKey("I"));
BOOST_CHECK(!init.hasKey("L"));
BOOST_CHECK(!init.hasKey("S"));
BOOST_CHECK(!init.hasKey("D"));
BOOST_CHECK(init.hasKey("I2"));
BOOST_CHECK(init.hasKey("L2"));
BOOST_CHECK(init.hasKey("S2"));
BOOST_CHECK(init.hasKey("D2"));
{
const auto vectors = init.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"I2", Opm::EclIO::eclArrType::INTE, 6},
Opm::EclIO::EclFile::EclEntry{"L2", Opm::EclIO::eclArrType::LOGI, 4},
Opm::EclIO::EclFile::EclEntry{"S2", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"D2", Opm::EclIO::eclArrType::DOUB, 3},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
init.loadData();
{
const auto& I = init.get<int>("I2");
const auto expect_I = std::vector<int>{ 1, 2, 3, 4, 5, 6 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& L = init.get<bool>("L2");
const auto expect_L = std::vector<bool> {
false, false, true, true,
};
BOOST_CHECK_EQUAL_COLLECTIONS(L.begin(), L.end(),
expect_L.begin(),
expect_L.end());
}
{
const auto& S = init.get<float>("S2");
const auto expect_S = std::vector<float>{
-1.0f, 2.0f, -3.0e-4f,
};
check_is_close(S, expect_S);
}
{
const auto& D = init.get<double>("D2");
const auto expect_D = std::vector<double>{
2.71, 8.21, 18.28459,
};
check_is_close(D, expect_D);
}
}
}
BOOST_AUTO_TEST_CASE(Formatted)
{
const auto rset = RSet("CASE");
const auto fmt = ::Opm::EclIO::OutputStream::Formatted{ true };
{
auto init = ::Opm::EclIO::OutputStream::Init {
rset, fmt
};
init.write("I", std::vector<int> {1, 7, 2, 9});
init.write("L", std::vector<bool> {true, false, false, true});
init.write("S", std::vector<float> {3.1f, 4.1f, 59.265f});
init.write("D", std::vector<double>{2.71, 8.21});
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "FINIT");
auto init = ::Opm::EclIO::EclFile{fname};
BOOST_CHECK(init.hasKey("I"));
BOOST_CHECK(init.hasKey("L"));
BOOST_CHECK(init.hasKey("S"));
BOOST_CHECK(init.hasKey("D"));
{
const auto vectors = init.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"I", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"L", Opm::EclIO::eclArrType::LOGI, 4},
Opm::EclIO::EclFile::EclEntry{"S", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"D", Opm::EclIO::eclArrType::DOUB, 2},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
init.loadData();
{
const auto& I = init.get<int>("I");
const auto expect_I = std::vector<int>{ 1, 7, 2, 9 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& L = init.get<bool>("L");
const auto expect_L = std::vector<bool> {
true, false, false, true,
};
BOOST_CHECK_EQUAL_COLLECTIONS(L.begin(), L.end(),
expect_L.begin(),
expect_L.end());
}
{
const auto& S = init.get<float>("S");
const auto expect_S = std::vector<float>{
3.1f, 4.1f, 59.265f,
};
check_is_close(S, expect_S);
}
{
const auto& D = init.get<double>("D");
const auto expect_D = std::vector<double>{
2.71, 8.21,
};
check_is_close(D, expect_D);
}
}
// Second write request replaces original contents
{
auto init = ::Opm::EclIO::OutputStream::Init {
rset, fmt
};
init.write("I2", std::vector<int> {1, 2, 3, 4, 5, 6});
init.write("L2", std::vector<bool> {false, false, true, true});
init.write("S2", std::vector<float> {-1.0f, 2.0f, -3.0e-4f});
init.write("D2", std::vector<double>{2.71, 8.21, 18.28459});
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "FINIT");
auto init = ::Opm::EclIO::EclFile{fname};
BOOST_CHECK(!init.hasKey("I"));
BOOST_CHECK(!init.hasKey("L"));
BOOST_CHECK(!init.hasKey("S"));
BOOST_CHECK(!init.hasKey("D"));
BOOST_CHECK(init.hasKey("I2"));
BOOST_CHECK(init.hasKey("L2"));
BOOST_CHECK(init.hasKey("S2"));
BOOST_CHECK(init.hasKey("D2"));
{
const auto vectors = init.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"I2", Opm::EclIO::eclArrType::INTE, 6},
Opm::EclIO::EclFile::EclEntry{"L2", Opm::EclIO::eclArrType::LOGI, 4},
Opm::EclIO::EclFile::EclEntry{"S2", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"D2", Opm::EclIO::eclArrType::DOUB, 3},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
init.loadData();
{
const auto& I = init.get<int>("I2");
const auto expect_I = std::vector<int>{ 1, 2, 3, 4, 5, 6 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& L = init.get<bool>("L2");
const auto expect_L = std::vector<bool> {
false, false, true, true,
};
BOOST_CHECK_EQUAL_COLLECTIONS(L.begin(), L.end(),
expect_L.begin(),
expect_L.end());
}
{
const auto& S = init.get<float>("S2");
const auto expect_S = std::vector<float>{
-1.0f, 2.0f, -3.0e-4f,
};
check_is_close(S, expect_S);
}
{
const auto& D = init.get<double>("D2");
const auto expect_D = std::vector<double>{
2.71, 8.21, 18.28459,
};
check_is_close(D, expect_D);
}
}
}
BOOST_AUTO_TEST_SUITE_END()
// ==========================================================================
BOOST_AUTO_TEST_SUITE(Class_Restart)
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
BOOST_AUTO_TEST_CASE(Unformatted_Unified)
{
const auto rset = RSet("CASE");
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto fmt = ::Opm::EclIO::OutputStream::Formatted{ false };
const auto unif = ::Opm::EclIO::OutputStream::Unified { true };
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
{
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
const auto seqnum = 1;
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
auto rst = ::Opm::EclIO::OutputStream::Restart {
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
rset, seqnum, fmt, unif
};
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
Redo Public Interface of OutputStream::Restart In particular, make the stream() function into a private detail of the implementation and add an overload set for outputting keyword data and messages to the underlying output stream. Update unit test accordingly. Suggested by: Atgeirr F. Rasmussen
2019-05-27 04:44:24 -05:00
rst.write("I", std::vector<int> {1, 7, 2, 9});
rst.write("L", std::vector<bool> {true, false, false, true});
rst.write("S", std::vector<float> {3.1f, 4.1f, 59.265f});
rst.write("D", std::vector<double> {2.71, 8.21});
rst.write("Z", std::vector<std::string>{"W1", "W2"});
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
}
{
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
const auto seqnum = 13;
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
auto rst = ::Opm::EclIO::OutputStream::Restart {
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
rset, seqnum, fmt, unif
};
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
Redo Public Interface of OutputStream::Restart In particular, make the stream() function into a private detail of the implementation and add an overload set for outputting keyword data and messages to the underlying output stream. Update unit test accordingly. Suggested by: Atgeirr F. Rasmussen
2019-05-27 04:44:24 -05:00
rst.write("I", std::vector<int> {35, 51, 13});
rst.write("L", std::vector<bool> {true, true, true, false});
rst.write("S", std::vector<float> {17.29e-02f, 1.4142f});
rst.write("D", std::vector<double> {0.6931, 1.6180, 123.45e6});
rst.write("Z", std::vector<std::string>{"G1", "FIELD"});
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
}
{
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto fname = ::Opm::EclIO::OutputStream::
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
outputFileName(rset, "UNRST");
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
auto rst = ::Opm::EclIO::ERst{fname};
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
BOOST_CHECK(rst.hasReportStepNumber( 1));
BOOST_CHECK(rst.hasReportStepNumber(13));
{
const auto seqnum = rst.listOfReportStepNumbers();
const auto expect_seqnum = std::vector<int>{1, 13};
BOOST_CHECK_EQUAL_COLLECTIONS(seqnum.begin(), seqnum.end(),
expect_seqnum.begin(),
expect_seqnum.end());
}
{
const auto vectors = rst.listOfRstArrays(13);
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"SEQNUM", Opm::EclIO::eclArrType::INTE, 1},
Opm::EclIO::EclFile::EclEntry{"I", Opm::EclIO::eclArrType::INTE, 3},
Opm::EclIO::EclFile::EclEntry{"L", Opm::EclIO::eclArrType::LOGI, 4},
Opm::EclIO::EclFile::EclEntry{"S", Opm::EclIO::eclArrType::REAL, 2},
Opm::EclIO::EclFile::EclEntry{"D", Opm::EclIO::eclArrType::DOUB, 3},
Opm::EclIO::EclFile::EclEntry{"Z", Opm::EclIO::eclArrType::CHAR, 2},
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
rst.loadReportStepNumber(13);
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& I = rst.getRst<int>("I", 13, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_I = std::vector<int>{ 35, 51, 13};
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& L = rst.getRst<bool>("L", 13, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_L = std::vector<bool> {
true, true, true, false,
};
BOOST_CHECK_EQUAL_COLLECTIONS(L.begin(), L.end(),
expect_L.begin(),
expect_L.end());
}
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& S = rst.getRst<float>("S", 13, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_S = std::vector<float>{
17.29e-02f, 1.4142f,
};
check_is_close(S, expect_S);
}
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& D = rst.getRst<double>("D", 13, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_D = std::vector<double>{
0.6931, 1.6180, 123.45e6,
};
check_is_close(D, expect_D);
}
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& Z = rst.getRst<std::string>("Z", 13, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_Z = std::vector<std::string>{
"G1", "FIELD", // ERst trims trailing blanks
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(),
expect_Z.end());
}
}
{
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
const auto seqnum = 5; // Before 13. Should overwrite 13
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
auto rst = ::Opm::EclIO::OutputStream::Restart {
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
rset, seqnum, fmt, unif
};
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
Redo Public Interface of OutputStream::Restart In particular, make the stream() function into a private detail of the implementation and add an overload set for outputting keyword data and messages to the underlying output stream. Update unit test accordingly. Suggested by: Atgeirr F. Rasmussen
2019-05-27 04:44:24 -05:00
rst.write("I", std::vector<int> {1, 2, 3, 4});
rst.write("L", std::vector<bool> {false, false, false, true});
rst.write("S", std::vector<float> {1.23e-04f, 1.234e5f, -5.4321e-9f});
rst.write("D", std::vector<double> {0.6931, 1.6180});
rst.write("Z", std::vector<std::string>{"HELLO", ", ", "WORLD"});
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
}
{
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto fname = ::Opm::EclIO::OutputStream::
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
outputFileName(rset, "UNRST");
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
auto rst = ::Opm::EclIO::ERst{fname};
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
BOOST_CHECK( rst.hasReportStepNumber( 1));
BOOST_CHECK( rst.hasReportStepNumber( 5));
BOOST_CHECK(!rst.hasReportStepNumber(13));
{
const auto seqnum = rst.listOfReportStepNumbers();
const auto expect_seqnum = std::vector<int>{1, 5};
BOOST_CHECK_EQUAL_COLLECTIONS(seqnum.begin(), seqnum.end(),
expect_seqnum.begin(),
expect_seqnum.end());
}
{
const auto vectors = rst.listOfRstArrays(5);
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"SEQNUM", Opm::EclIO::eclArrType::INTE, 1},
Opm::EclIO::EclFile::EclEntry{"I", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"L", Opm::EclIO::eclArrType::LOGI, 4},
Opm::EclIO::EclFile::EclEntry{"S", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"D", Opm::EclIO::eclArrType::DOUB, 2},
Opm::EclIO::EclFile::EclEntry{"Z", Opm::EclIO::eclArrType::CHAR, 3},
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
rst.loadReportStepNumber(5);
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& I = rst.getRst<int>("I", 5, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_I = std::vector<int>{ 1, 2, 3, 4 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& L = rst.getRst<bool>("L", 5, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_L = std::vector<bool> {
false, false, false, true,
};
BOOST_CHECK_EQUAL_COLLECTIONS(L.begin(), L.end(),
expect_L.begin(),
expect_L.end());
}
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& S = rst.getRst<float>("S", 5, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_S = std::vector<float>{
1.23e-04f, 1.234e5f, -5.4321e-9f,
};
check_is_close(S, expect_S);
}
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& D = rst.getRst<double>("D", 5, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_D = std::vector<double>{
0.6931, 1.6180,
};
check_is_close(D, expect_D);
}
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& Z = rst.getRst<std::string>("Z", 5, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_Z = std::vector<std::string>{
"HELLO", ",", "WORLD", // ERst trims trailing blanks
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(),
expect_Z.end());
}
}
{
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
const auto seqnum = 13;
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
auto rst = ::Opm::EclIO::OutputStream::Restart {
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
rset, seqnum, fmt, unif
};
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
Redo Public Interface of OutputStream::Restart In particular, make the stream() function into a private detail of the implementation and add an overload set for outputting keyword data and messages to the underlying output stream. Update unit test accordingly. Suggested by: Atgeirr F. Rasmussen
2019-05-27 04:44:24 -05:00
rst.write("I", std::vector<int> {35, 51, 13});
rst.write("L", std::vector<bool> {true, true, true, false});
rst.write("S", std::vector<float> {17.29e-02f, 1.4142f});
rst.write("D", std::vector<double> {0.6931, 1.6180, 123.45e6});
rst.write("Z", std::vector<std::string>{"G1", "FIELD"});
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
}
{
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto fname = ::Opm::EclIO::OutputStream::
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
outputFileName(rset, "UNRST");
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
auto rst = ::Opm::EclIO::ERst{fname};
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
BOOST_CHECK(rst.hasReportStepNumber( 1));
BOOST_CHECK(rst.hasReportStepNumber( 5));
BOOST_CHECK(rst.hasReportStepNumber(13));
{
const auto seqnum = rst.listOfReportStepNumbers();
const auto expect_seqnum = std::vector<int>{1, 5, 13};
BOOST_CHECK_EQUAL_COLLECTIONS(seqnum.begin(), seqnum.end(),
expect_seqnum.begin(),
expect_seqnum.end());
}
{
const auto vectors = rst.listOfRstArrays(13);
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"SEQNUM", Opm::EclIO::eclArrType::INTE, 1},
Opm::EclIO::EclFile::EclEntry{"I", Opm::EclIO::eclArrType::INTE, 3},
Opm::EclIO::EclFile::EclEntry{"L", Opm::EclIO::eclArrType::LOGI, 4},
Opm::EclIO::EclFile::EclEntry{"S", Opm::EclIO::eclArrType::REAL, 2},
Opm::EclIO::EclFile::EclEntry{"D", Opm::EclIO::eclArrType::DOUB, 3},
Opm::EclIO::EclFile::EclEntry{"Z", Opm::EclIO::eclArrType::CHAR, 2},
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
rst.loadReportStepNumber(13);
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& I = rst.getRst<int>("I", 13, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_I = std::vector<int>{ 35, 51, 13};
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& L = rst.getRst<bool>("L", 13, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_L = std::vector<bool> {
true, true, true, false,
};
BOOST_CHECK_EQUAL_COLLECTIONS(L.begin(), L.end(),
expect_L.begin(),
expect_L.end());
}
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& S = rst.getRst<float>("S", 13, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_S = std::vector<float>{
17.29e-02f, 1.4142f,
};
check_is_close(S, expect_S);
}
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& D = rst.getRst<double>("D", 13, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_D = std::vector<double>{
0.6931, 1.6180, 123.45e6,
};
check_is_close(D, expect_D);
}
{
updates of ERst api, supports multiple occurrences of array names
2019-11-03 12:34:25 -06:00
const auto& Z = rst.getRst<std::string>("Z", 13, 0);
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
const auto expect_Z = std::vector<std::string>{
"G1", "FIELD", // ERst trims trailing blanks
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(),
expect_Z.end());
}
}
}
BOOST_AUTO_TEST_CASE(Formatted_Separate)
{
const auto rset = RSet("CASE.T01.");
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto fmt = ::Opm::EclIO::OutputStream::Formatted{ true };
const auto unif = ::Opm::EclIO::OutputStream::Unified { false };
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
{
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
const auto seqnum = 1;
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
auto rst = ::Opm::EclIO::OutputStream::Restart {
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
rset, seqnum, fmt, unif
};
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
Redo Public Interface of OutputStream::Restart In particular, make the stream() function into a private detail of the implementation and add an overload set for outputting keyword data and messages to the underlying output stream. Update unit test accordingly. Suggested by: Atgeirr F. Rasmussen
2019-05-27 04:44:24 -05:00
rst.write("I", std::vector<int> {1, 7, 2, 9});
rst.write("L", std::vector<bool> {true, false, false, true});
rst.write("S", std::vector<float> {3.1f, 4.1f, 59.265f});
rst.write("D", std::vector<double> {2.71, 8.21});
rst.write("Z", std::vector<std::string>{"W1", "W2"});
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
}
{
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
const auto seqnum = 13;
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
auto rst = ::Opm::EclIO::OutputStream::Restart {
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
rset, seqnum, fmt, unif
};
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
Redo Public Interface of OutputStream::Restart In particular, make the stream() function into a private detail of the implementation and add an overload set for outputting keyword data and messages to the underlying output stream. Update unit test accordingly. Suggested by: Atgeirr F. Rasmussen
2019-05-27 04:44:24 -05:00
rst.write("I", std::vector<int> {35, 51, 13});
rst.write("L", std::vector<bool> {true, true, true, false});
rst.write("S", std::vector<float> {17.29e-02f, 1.4142f});
rst.write("D", std::vector<double> {0.6931, 1.6180, 123.45e6});
rst.write("Z", std::vector<std::string>{"G1", "FIELD"});
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
}
{
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
using ::Opm::EclIO::OutputStream::Restart;
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto fname = ::Opm::EclIO::OutputStream::
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
outputFileName(rset, "F0013");
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
auto rst = ::Opm::EclIO::EclFile{fname};
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
{
const auto vectors = rst.getList();
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
// No SEQNUM in separate output files
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
Opm::EclIO::EclFile::EclEntry{"I", Opm::EclIO::eclArrType::INTE, 3},
Opm::EclIO::EclFile::EclEntry{"L", Opm::EclIO::eclArrType::LOGI, 4},
Opm::EclIO::EclFile::EclEntry{"S", Opm::EclIO::eclArrType::REAL, 2},
Opm::EclIO::EclFile::EclEntry{"D", Opm::EclIO::eclArrType::DOUB, 3},
Opm::EclIO::EclFile::EclEntry{"Z", Opm::EclIO::eclArrType::CHAR, 2},
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
rst.loadData();
{
const auto& I = rst.get<int>("I");
const auto expect_I = std::vector<int>{ 35, 51, 13 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& L = rst.get<bool>("L");
const auto expect_L = std::vector<bool> {
true, true, true, false,
};
BOOST_CHECK_EQUAL_COLLECTIONS(L.begin(), L.end(),
expect_L.begin(),
expect_L.end());
}
{
const auto& S = rst.get<float>("S");
const auto expect_S = std::vector<float>{
17.29e-02f, 1.4142f,
};
check_is_close(S, expect_S);
}
{
const auto& D = rst.get<double>("D");
const auto expect_D = std::vector<double>{
0.6931, 1.6180, 123.45e6,
};
check_is_close(D, expect_D);
}
{
const auto& Z = rst.get<std::string>("Z");
const auto expect_Z = std::vector<std::string>{
"G1", "FIELD", // ERst trims trailing blanks
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(),
expect_Z.end());
}
}
{
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
// Separate output. Step 13 should be unaffected.
const auto seqnum = 5;
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
auto rst = ::Opm::EclIO::OutputStream::Restart {
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
rset, seqnum, fmt, unif
};
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
Redo Public Interface of OutputStream::Restart In particular, make the stream() function into a private detail of the implementation and add an overload set for outputting keyword data and messages to the underlying output stream. Update unit test accordingly. Suggested by: Atgeirr F. Rasmussen
2019-05-27 04:44:24 -05:00
rst.write("I", std::vector<int> {1, 2, 3, 4});
rst.write("L", std::vector<bool> {false, false, false, true});
rst.write("S", std::vector<float> {1.23e-04f, 1.234e5f, -5.4321e-9f});
rst.write("D", std::vector<double> {0.6931, 1.6180});
rst.write("Z", std::vector<std::string>{"HELLO", ", ", "WORLD"});
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
}
{
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
using ::Opm::EclIO::OutputStream::Restart;
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto fname = ::Opm::EclIO::OutputStream::
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
outputFileName(rset, "F0005");
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
auto rst = ::Opm::EclIO::EclFile{fname};
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
{
const auto vectors = rst.getList();
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
// No SEQNUM in separate output files
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
Opm::EclIO::EclFile::EclEntry{"I", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"L", Opm::EclIO::eclArrType::LOGI, 4},
Opm::EclIO::EclFile::EclEntry{"S", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"D", Opm::EclIO::eclArrType::DOUB, 2},
Opm::EclIO::EclFile::EclEntry{"Z", Opm::EclIO::eclArrType::CHAR, 3},
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
rst.loadData();
{
const auto& I = rst.get<int>("I");
const auto expect_I = std::vector<int>{ 1, 2, 3, 4 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& L = rst.get<bool>("L");
const auto expect_L = std::vector<bool> {
false, false, false, true,
};
BOOST_CHECK_EQUAL_COLLECTIONS(L.begin(), L.end(),
expect_L.begin(),
expect_L.end());
}
{
const auto& S = rst.get<float>("S");
const auto expect_S = std::vector<float>{
1.23e-04f, 1.234e5f, -5.4321e-9f,
};
check_is_close(S, expect_S);
}
{
const auto& D = rst.get<double>("D");
const auto expect_D = std::vector<double>{
0.6931, 1.6180,
};
check_is_close(D, expect_D);
}
{
const auto& Z = rst.get<std::string>("Z");
const auto expect_Z = std::vector<std::string>{
"HELLO", ",", "WORLD", // ERst trims trailing blanks
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(),
expect_Z.end());
}
}
// -------------------------------------------------------
// Don't rewrite step 13. Output file should still exist.
// -------------------------------------------------------
{
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
using ::Opm::EclIO::OutputStream::Restart;
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto fname = ::Opm::EclIO::OutputStream::
OutputStream::Restart: Pull File Creation Into Constructor Then we don't have to store copies of the 'formatted' and 'unified' flags, and are also able to remove the 'prepareStep()' function. We will reintroduce these features if we decide to add support for keeping the output stream open between separate restart output requests (i.e., between calls to EclipseIO::writeTimeStep()).
2019-05-27 11:03:11 -05:00
outputFileName(rset, "F0013");
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
auto rst = ::Opm::EclIO::EclFile{fname};
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
{
const auto vectors = rst.getList();
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
// No SEQNUM in separate output files.
ECLIPSE I/O: Rename Namespace Opm::ecl -> Opm::EclIO This reduces the risk of conflicting with the 'ecl' namespace from LibECL, especially when the latter name is used from within the Opm namespace.
2019-05-24 08:26:01 -05:00
Opm::EclIO::EclFile::EclEntry{"I", Opm::EclIO::eclArrType::INTE, 3},
Opm::EclIO::EclFile::EclEntry{"L", Opm::EclIO::eclArrType::LOGI, 4},
Opm::EclIO::EclFile::EclEntry{"S", Opm::EclIO::eclArrType::REAL, 2},
Opm::EclIO::EclFile::EclEntry{"D", Opm::EclIO::eclArrType::DOUB, 3},
Opm::EclIO::EclFile::EclEntry{"Z", Opm::EclIO::eclArrType::CHAR, 2},
Restart Output: Add File Management Facility This commit introduces a new class, Opm::ecl::OutputStream::Restart that handles the details of opening restart output streams (all combinations of formatted/unformatted and unified/separate), as well as correctly positioning the stream 'put' indicator if we're opening an existing unified restart file. In most cases, this will be a simple append operation (std::ios_base::app), but there are some subtleties that require more precise control. The new class is befriended by EclOutput and ERst in order to access private member functions and data members of these classes. That is needed in order to handle file resize operations since some of the requisite information is only available in those two classes. We use Boost.Filesystem to implement file resize, as if by POSIX function ::truncate(), and also to simplify filename generation. These calls can be switched to std::filesystem once the project requires C++17. Intended use of the Restart class is Restart rst(resultSet, formatted, unified); rst.prepareStep(17); // Report step/SEQNUM 17. rst.write("INTEHEAD", ihead); // ... The 'prepareStep' operation opens the file stream (if needed) and also outputs a SEQNUM record in the case of a unified output stream. Moreover, the 'resultSet' is a pair of output directory and case's base name (e.g., "./mpi.np4/2019.05.14.01" and "NORNE_ATW2013") and the formatted/unified flags are bools wrapped in structures. The Restart class is intended to take over the role of the 'filename' string parameter of RestartIO::save(). Add a set of unit tests to demontrate usage and abilities of class Restart.
2019-05-27 06:03:57 -05:00
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
rst.loadData();
{
const auto& I = rst.get<int>("I");
const auto expect_I = std::vector<int>{ 35, 51, 13 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& L = rst.get<bool>("L");
const auto expect_L = std::vector<bool> {
true, true, true, false,
};
BOOST_CHECK_EQUAL_COLLECTIONS(L.begin(), L.end(),
expect_L.begin(),
expect_L.end());
}
{
const auto& S = rst.get<float>("S");
const auto expect_S = std::vector<float>{
17.29e-02f, 1.4142f,
};
check_is_close(S, expect_S);
}
{
const auto& D = rst.get<double>("D");
const auto expect_D = std::vector<double>{
0.6931, 1.6180, 123.45e6,
};
check_is_close(D, expect_D);
}
{
const auto& Z = rst.get<std::string>("Z");
const auto expect_Z = std::vector<std::string>{
"G1", "FIELD", // ERst trims trailing blanks
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(),
expect_Z.end());
}
}
}
BOOST_AUTO_TEST_SUITE_END() // Class_Restart
Add RFT Output Stream This commit introduces a new output stream, 'RFT', that is intended as a new backend for writing RFT files. At present this supports integer, float, and PaddedOutputString<8> element types since those are the types needed for basic RFT data. We will extend the element support if needed for PLT and/or Segment data. We support formatted and unformatted output streams and distinguish between opening a new stream and opening an existing output stream (essentially between open modes ios_base::out and ios_base::app). Add unit tests to exercise the possible combinations.
2019-08-28 02:54:41 -05:00
// ==========================================================================
BOOST_AUTO_TEST_SUITE(Class_RFT)
BOOST_AUTO_TEST_CASE(Unformatted_New)
{
using Char8 = ::Opm::EclIO::PaddedOutputString<8>;
const auto rset = RSet("CASE");
const auto fmt = ::Opm::EclIO::OutputStream::Formatted{ false };
const auto exist = ::Opm::EclIO::OutputStream::RFT::OpenExisting{ false };
{
auto rft = ::Opm::EclIO::OutputStream::RFT {
rset, fmt, exist
};
rft.write("I", std::vector<int> {1, 7, 2, 9});
rft.write("S", std::vector<float> {3.1f, 4.1f, 59.265f});
rft.write("Z", std::vector<Char8> {
Char8{" Hello "}, Char8{" World "}
});
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "RFT");
auto rft = ::Opm::EclIO::EclFile{fname};
BOOST_CHECK(rft.hasKey("I"));
BOOST_CHECK(rft.hasKey("S"));
BOOST_CHECK(rft.hasKey("Z"));
BOOST_CHECK(!rft.hasKey("C"));
{
const auto vectors = rft.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"I", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"S", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"Z", Opm::EclIO::eclArrType::CHAR, 2},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
rft.loadData();
{
const auto& I = rft.get<int>("I");
const auto expect_I = std::vector<int>{ 1, 7, 2, 9 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& S = rft.get<float>("S");
const auto expect_S = std::vector<float>{
3.1f, 4.1f, 59.265f,
};
check_is_close(S, expect_S);
}
{
const auto& Z = rft.get<std::string>("Z");
const auto expect_Z = std::vector<std::string>{
" Hello", " World" // Trailing blanks trimmed
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(), expect_Z.end());
}
}
{
auto rft = ::Opm::EclIO::OutputStream::RFT {
rset, fmt, exist
};
rft.write("I2", std::vector<int> {11, 22, 33});
rft.write("S2", std::vector<float> {2.71f, 828.1f, 8.218f});
rft.write("Z2", std::vector<Char8> {
Char8{"Good B"}, Char8{" ye"}, Char8{ "W0rlD" },
});
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "RFT");
auto rft = ::Opm::EclIO::EclFile{fname};
BOOST_CHECK(!rft.hasKey("I"));
BOOST_CHECK(!rft.hasKey("S"));
BOOST_CHECK(!rft.hasKey("Z"));
BOOST_CHECK(rft.hasKey("I2"));
BOOST_CHECK(rft.hasKey("S2"));
BOOST_CHECK(rft.hasKey("Z2"));
{
const auto vectors = rft.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"I2", Opm::EclIO::eclArrType::INTE, 3},
Opm::EclIO::EclFile::EclEntry{"S2", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"Z2", Opm::EclIO::eclArrType::CHAR, 3},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
rft.loadData();
{
const auto& I = rft.get<int>("I2");
const auto expect_I = std::vector<int>{ 11, 22, 33 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& S = rft.get<float>("S2");
const auto expect_S = std::vector<float>{
2.71f, 828.1f, 8.218f,
};
check_is_close(S, expect_S);
}
{
const auto& Z = rft.get<std::string>("Z2");
const auto expect_Z = std::vector<std::string>{
"Good B", " ye", "W0rlD"
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(), expect_Z.end());
}
}
}
BOOST_AUTO_TEST_CASE(Unformatted_Existing)
{
using Char8 = ::Opm::EclIO::PaddedOutputString<8>;
const auto rset = RSet("CASE");
const auto fmt = ::Opm::EclIO::OutputStream::Formatted{ false };
const auto exist = ::Opm::EclIO::OutputStream::RFT::OpenExisting{ true };
{
auto rft = ::Opm::EclIO::OutputStream::RFT {
rset, fmt, exist
};
rft.write("I", std::vector<int> {1, 7, 2, 9});
rft.write("S", std::vector<float> {3.1f, 4.1f, 59.265f});
rft.write("Z", std::vector<Char8> {
Char8{" Hello "}, Char8{" World "}
});
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "RFT");
auto rft = ::Opm::EclIO::EclFile{fname};
BOOST_CHECK(rft.hasKey("I"));
BOOST_CHECK(rft.hasKey("S"));
BOOST_CHECK(rft.hasKey("Z"));
BOOST_CHECK(!rft.hasKey("C"));
{
const auto vectors = rft.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"I", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"S", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"Z", Opm::EclIO::eclArrType::CHAR, 2},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
rft.loadData();
{
const auto& I = rft.get<int>("I");
const auto expect_I = std::vector<int>{ 1, 7, 2, 9 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& S = rft.get<float>("S");
const auto expect_S = std::vector<float>{
3.1f, 4.1f, 59.265f,
};
check_is_close(S, expect_S);
}
{
const auto& Z = rft.get<std::string>("Z");
const auto expect_Z = std::vector<std::string>{
" Hello", " World" // Trailing blanks trimmed
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(), expect_Z.end());
}
}
{
auto rft = ::Opm::EclIO::OutputStream::RFT {
rset, fmt, exist
};
rft.write("I2", std::vector<int> {11, 22, 33});
rft.write("S2", std::vector<float> {2.71f, 828.1f, 8.218f});
rft.write("Z2", std::vector<Char8> {
Char8{"Good B"}, Char8{" ye"}, Char8{ "W0rlD" },
});
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "RFT");
auto rft = ::Opm::EclIO::EclFile{fname};
BOOST_CHECK(rft.hasKey("I"));
BOOST_CHECK(rft.hasKey("S"));
BOOST_CHECK(rft.hasKey("Z"));
BOOST_CHECK(rft.hasKey("I2"));
BOOST_CHECK(rft.hasKey("S2"));
BOOST_CHECK(rft.hasKey("Z2"));
BOOST_CHECK(!rft.hasKey("C"));
{
const auto vectors = rft.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"I", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"S", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"Z", Opm::EclIO::eclArrType::CHAR, 2},
Opm::EclIO::EclFile::EclEntry{"I2", Opm::EclIO::eclArrType::INTE, 3},
Opm::EclIO::EclFile::EclEntry{"S2", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"Z2", Opm::EclIO::eclArrType::CHAR, 3},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
rft.loadData();
{
const auto& I = rft.get<int>("I");
const auto expect_I = std::vector<int>{ 1, 7, 2, 9 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& S = rft.get<float>("S");
const auto expect_S = std::vector<float>{
3.1f, 4.1f, 59.265f,
};
check_is_close(S, expect_S);
}
{
const auto& Z = rft.get<std::string>("Z");
const auto expect_Z = std::vector<std::string>{
" Hello", " World" // Trailing blanks trimmed
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(), expect_Z.end());
}
{
const auto& I = rft.get<int>("I2");
const auto expect_I = std::vector<int>{ 11, 22, 33 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& S = rft.get<float>("S2");
const auto expect_S = std::vector<float>{
2.71f, 828.1f, 8.218f,
};
check_is_close(S, expect_S);
}
{
const auto& Z = rft.get<std::string>("Z2");
const auto expect_Z = std::vector<std::string>{
"Good B", " ye", "W0rlD"
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(), expect_Z.end());
}
}
}
BOOST_AUTO_TEST_CASE(Formatted_New)
{
using Char8 = ::Opm::EclIO::PaddedOutputString<8>;
const auto rset = RSet("CASE");
const auto fmt = ::Opm::EclIO::OutputStream::Formatted{ true };
const auto exist = ::Opm::EclIO::OutputStream::RFT::OpenExisting{ false };
{
auto rft = ::Opm::EclIO::OutputStream::RFT {
rset, fmt, exist
};
rft.write("I", std::vector<int> {1, 7, 2, 9});
rft.write("S", std::vector<float> {3.1f, 4.1f, 59.265f});
rft.write("Z", std::vector<Char8> {
Char8{" Hello "}, Char8{" World "}
});
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "FRFT");
auto rft = ::Opm::EclIO::EclFile{fname};
BOOST_CHECK(rft.hasKey("I"));
BOOST_CHECK(rft.hasKey("S"));
BOOST_CHECK(rft.hasKey("Z"));
BOOST_CHECK(!rft.hasKey("C"));
{
const auto vectors = rft.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"I", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"S", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"Z", Opm::EclIO::eclArrType::CHAR, 2},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
rft.loadData();
{
const auto& I = rft.get<int>("I");
const auto expect_I = std::vector<int>{ 1, 7, 2, 9 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& S = rft.get<float>("S");
const auto expect_S = std::vector<float>{
3.1f, 4.1f, 59.265f,
};
check_is_close(S, expect_S);
}
{
const auto& Z = rft.get<std::string>("Z");
const auto expect_Z = std::vector<std::string>{
" Hello", " World" // Trailing blanks trimmed
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(), expect_Z.end());
}
}
{
auto rft = ::Opm::EclIO::OutputStream::RFT {
rset, fmt, exist
};
rft.write("I2", std::vector<int> {11, 22, 33});
rft.write("S2", std::vector<float> {2.71f, 828.1f, 8.218f});
rft.write("Z2", std::vector<Char8> {
Char8{"Good B"}, Char8{" ye"}, Char8{ "W0rlD" },
});
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "FRFT");
auto rft = ::Opm::EclIO::EclFile{fname};
BOOST_CHECK(!rft.hasKey("I"));
BOOST_CHECK(!rft.hasKey("S"));
BOOST_CHECK(!rft.hasKey("Z"));
BOOST_CHECK(rft.hasKey("I2"));
BOOST_CHECK(rft.hasKey("S2"));
BOOST_CHECK(rft.hasKey("Z2"));
{
const auto vectors = rft.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"I2", Opm::EclIO::eclArrType::INTE, 3},
Opm::EclIO::EclFile::EclEntry{"S2", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"Z2", Opm::EclIO::eclArrType::CHAR, 3},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
rft.loadData();
{
const auto& I = rft.get<int>("I2");
const auto expect_I = std::vector<int>{ 11, 22, 33 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& S = rft.get<float>("S2");
const auto expect_S = std::vector<float>{
2.71f, 828.1f, 8.218f,
};
check_is_close(S, expect_S);
}
{
const auto& Z = rft.get<std::string>("Z2");
const auto expect_Z = std::vector<std::string>{
"Good B", " ye", "W0rlD"
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(), expect_Z.end());
}
}
}
BOOST_AUTO_TEST_CASE(Formatted_Existing)
{
using Char8 = ::Opm::EclIO::PaddedOutputString<8>;
const auto rset = RSet("CASE");
const auto fmt = ::Opm::EclIO::OutputStream::Formatted{ true };
const auto exist = ::Opm::EclIO::OutputStream::RFT::OpenExisting{ true };
{
auto rft = ::Opm::EclIO::OutputStream::RFT {
rset, fmt, exist
};
rft.write("I", std::vector<int> {1, 7, 2, 9});
rft.write("S", std::vector<float> {3.1f, 4.1f, 59.265f});
rft.write("Z", std::vector<Char8> {
Char8{" Hello "}, Char8{" World "}
});
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "FRFT");
auto rft = ::Opm::EclIO::EclFile{fname};
BOOST_CHECK(rft.hasKey("I"));
BOOST_CHECK(rft.hasKey("S"));
BOOST_CHECK(rft.hasKey("Z"));
BOOST_CHECK(!rft.hasKey("C"));
{
const auto vectors = rft.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"I", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"S", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"Z", Opm::EclIO::eclArrType::CHAR, 2},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
rft.loadData();
{
const auto& I = rft.get<int>("I");
const auto expect_I = std::vector<int>{ 1, 7, 2, 9 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& S = rft.get<float>("S");
const auto expect_S = std::vector<float>{
3.1f, 4.1f, 59.265f,
};
check_is_close(S, expect_S);
}
{
const auto& Z = rft.get<std::string>("Z");
const auto expect_Z = std::vector<std::string>{
" Hello", " World" // Trailing blanks trimmed
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(), expect_Z.end());
}
}
{
auto rft = ::Opm::EclIO::OutputStream::RFT {
rset, fmt, exist
};
rft.write("I2", std::vector<int> {11, 22, 33});
rft.write("S2", std::vector<float> {2.71f, 828.1f, 8.218f});
rft.write("Z2", std::vector<Char8> {
Char8{"Good B"}, Char8{" ye"}, Char8{ "W0rlD" },
});
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "FRFT");
auto rft = ::Opm::EclIO::EclFile{fname};
BOOST_CHECK(rft.hasKey("I"));
BOOST_CHECK(rft.hasKey("S"));
BOOST_CHECK(rft.hasKey("Z"));
BOOST_CHECK(rft.hasKey("I2"));
BOOST_CHECK(rft.hasKey("S2"));
BOOST_CHECK(rft.hasKey("Z2"));
BOOST_CHECK(!rft.hasKey("C"));
{
const auto vectors = rft.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"I", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"S", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"Z", Opm::EclIO::eclArrType::CHAR, 2},
Opm::EclIO::EclFile::EclEntry{"I2", Opm::EclIO::eclArrType::INTE, 3},
Opm::EclIO::EclFile::EclEntry{"S2", Opm::EclIO::eclArrType::REAL, 3},
Opm::EclIO::EclFile::EclEntry{"Z2", Opm::EclIO::eclArrType::CHAR, 3},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
rft.loadData();
{
const auto& I = rft.get<int>("I");
const auto expect_I = std::vector<int>{ 1, 7, 2, 9 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& S = rft.get<float>("S");
const auto expect_S = std::vector<float>{
3.1f, 4.1f, 59.265f,
};
check_is_close(S, expect_S);
}
{
const auto& Z = rft.get<std::string>("Z");
const auto expect_Z = std::vector<std::string>{
" Hello", " World" // Trailing blanks trimmed
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(), expect_Z.end());
}
{
const auto& I = rft.get<int>("I2");
const auto expect_I = std::vector<int>{ 11, 22, 33 };
BOOST_CHECK_EQUAL_COLLECTIONS(I.begin(), I.end(),
expect_I.begin(),
expect_I.end());
}
{
const auto& S = rft.get<float>("S2");
const auto expect_S = std::vector<float>{
2.71f, 828.1f, 8.218f,
};
check_is_close(S, expect_S);
}
{
const auto& Z = rft.get<std::string>("Z2");
const auto expect_Z = std::vector<std::string>{
"Good B", " ye", "W0rlD"
};
BOOST_CHECK_EQUAL_COLLECTIONS(Z.begin(), Z.end(),
expect_Z.begin(), expect_Z.end());
}
}
}
BOOST_AUTO_TEST_SUITE_END() // Class_RFT
Add File Manager Stream for Summary Specification This commit introduces a new OutputStream class for representing the summary specification file (.SMSPEC). The stream is constructed with constant data (output directory, basename, start date &c), and provides a single write() member function that outputs a summary specification. Each call to write rewinds the underlying stream's output position. Class EclOutput grants friendship to the new output stream class in order to support easy stream rewinding. Add a unit test to exercise the new class.
2019-09-30 12:00:54 -05:00
// ==========================================================================
BOOST_AUTO_TEST_SUITE(Class_SummarySpecification)
namespace {
std::time_t advance(const std::time_t tp, const double sec)
{
using namespace std::chrono;
using TP = time_point<system_clock>;
using DoubSec = duration<double, seconds::period>;
const auto t = system_clock::from_time_t(tp) +
duration_cast<TP::duration>(DoubSec(sec));
return system_clock::to_time_t(t);
}
std::time_t makeUTCTime(const std::tm& timePoint)
{
auto tp = timePoint; // Mutable copy.
const auto ltime = std::mktime(&tp);
auto tmval = *std::gmtime(&ltime); // Mutable.
// offset = ltime - tmval
// == #seconds by which 'ltime' is AHEAD of tmval.
const auto offset =
std::difftime(ltime, std::mktime(&tmval));
// Advance 'ltime' by 'offset' so that std::gmtime(return value) will
// have the same broken-down elements as 'tp'.
return advance(ltime, offset);
}
std::string noWGName()
{
return ":+:+:+:+";
}
int noNum() { return 0; }
Opm::EclIO::OutputStream::SummarySpecification::StartTime
start(const int year, const int month, const int day,
const int hour, const int minute, const int second)
{
using std::chrono::system_clock;
auto timepoint = std::tm {};
timepoint.tm_sec = second;
timepoint.tm_min = minute;
timepoint.tm_hour = hour;
timepoint.tm_mday = day;
timepoint.tm_mon = month - 1;
timepoint.tm_year = year - 1900;
return system_clock::from_time_t(makeUTCTime(timepoint));
}
Opm::EclIO::OutputStream::SummarySpecification::RestartSpecification
noRestart()
{
return { "", -1 };
}
Opm::EclIO::OutputStream::SummarySpecification::RestartSpecification
restartedSimulation()
{
// 28 characters = 3x8 + 4
return { "BASE-RUN-WITH-LONG-CASE-NAME", 123 };
}
Opm::EclIO::OutputStream::SummarySpecification::RestartSpecification
restartedSimulationTooLongBasename()
{
return { std::string(73, 'X'), 123 };
}
Opm::EclIO::OutputStream::SummarySpecification::Parameters
summaryParameters()
{
auto prm = Opm::EclIO::OutputStream::
SummarySpecification::Parameters{};
prm.add("TIME", noWGName(), noNum(), "DAYS");
prm.add("WBHP", "PROD01", noNum(), "BARSA");
prm.add("GGOR", "N-PROD", noNum(), "SM3/SM3");
prm.add("BGSAT", noWGName(), 523, "");
return prm;
}
} // Anonymous
BOOST_AUTO_TEST_CASE(Unformatted_Base)
{
using SMSpec = ::Opm::EclIO::OutputStream::SummarySpecification;
const auto rset = RSet("CASE");
const auto fmt = ::Opm::EclIO::OutputStream::Formatted{ false };
const auto cartDims = std::array<int,3>{ 46, 112, 22 }; // Norne dimensions
{
using UConv = SMSpec::UnitConvention;
// Invalid unit convention
const auto uconv = static_cast<UConv>(1729);
BOOST_CHECK_THROW(SMSpec(rset, fmt, uconv, cartDims, noRestart(),
start(2019, 10, 1, 12, 34, 56)),
std::invalid_argument);
}
// ========================= METRIC =======================
{
const auto uconv = SMSpec::UnitConvention::Metric;
auto smspec = SMSpec {
rset, fmt, uconv, cartDims, noRestart(),
start(2019, 10, 1, 12, 34, 56)
};
smspec.write(summaryParameters());
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "SMSPEC");
auto smspec = ::Opm::EclIO::EclFile{fname};
SMSPEC: Temporarily Restore Unconditional RESTART Vector Needed to ensure we create the same summary/specification files as the existing system. We will revert this change once the new system is in place and we can afford to update the reference solutions.
2019-10-09 00:18:41 -05:00
//BOOST_CHECK_MESSAGE(! smspec.hasKey("RESTART"), "SMSPEC File must NOT have 'RESTART'");
Add File Manager Stream for Summary Specification This commit introduces a new OutputStream class for representing the summary specification file (.SMSPEC). The stream is constructed with constant data (output directory, basename, start date &c), and provides a single write() member function that outputs a summary specification. Each call to write rewinds the underlying stream's output position. Class EclOutput grants friendship to the new output stream class in order to support easy stream rewinding. Add a unit test to exercise the new class.
2019-09-30 12:00:54 -05:00
{
const auto vectors = smspec.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"INTEHEAD", Opm::EclIO::eclArrType::INTE, 2},
SMSPEC: Temporarily Restore Unconditional RESTART Vector Needed to ensure we create the same summary/specification files as the existing system. We will revert this change once the new system is in place and we can afford to update the reference solutions.
2019-10-09 00:18:41 -05:00
Opm::EclIO::EclFile::EclEntry{"RESTART", Opm::EclIO::eclArrType::CHAR, 9},
Add File Manager Stream for Summary Specification This commit introduces a new OutputStream class for representing the summary specification file (.SMSPEC). The stream is constructed with constant data (output directory, basename, start date &c), and provides a single write() member function that outputs a summary specification. Each call to write rewinds the underlying stream's output position. Class EclOutput grants friendship to the new output stream class in order to support easy stream rewinding. Add a unit test to exercise the new class.
2019-09-30 12:00:54 -05:00
Opm::EclIO::EclFile::EclEntry{"DIMENS", Opm::EclIO::eclArrType::INTE, 6},
Opm::EclIO::EclFile::EclEntry{"KEYWORDS", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"WGNAMES", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"NUMS", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"UNITS", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"STARTDAT", Opm::EclIO::eclArrType::INTE, 6},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
smspec.loadData();
{
const auto& Ih = smspec.get<int>("INTEHEAD");
const auto expect = std::vector<int>{ 1, 100 };
BOOST_CHECK_EQUAL_COLLECTIONS(Ih.begin(), Ih.end(),
expect.begin(),
expect.end());
}
{
const auto& D = smspec.get<int>("DIMENS");
const auto expect = std::vector<int> {
4, 46, 112, 22, 0, -1
};
BOOST_CHECK_EQUAL_COLLECTIONS(D.begin(), D.end(),
expect.begin(), expect.end());
}
{
const auto& K = smspec.get<std::string>("KEYWORDS");
const auto expect = std::vector<std::string> {
"TIME", "WBHP", "GGOR", "BGSAT"
};
BOOST_CHECK_EQUAL_COLLECTIONS(K.begin(), K.end(),
expect.begin(), expect.end());
}
{
const auto& W = smspec.get<std::string>("WGNAMES");
const auto expect = std::vector<std::string> {
":+:+:+:+", "PROD01", "N-PROD", ":+:+:+:+"
};
BOOST_CHECK_EQUAL_COLLECTIONS(W.begin(), W.end(),
expect.begin(), expect.end());
}
{
const auto& N = smspec.get<int>("NUMS");
const auto expect = std::vector<int> { 0, 0, 0, 523 };
BOOST_CHECK_EQUAL_COLLECTIONS(N.begin(), N.end(),
expect.begin(), expect.end());
}
{
const auto& U = smspec.get<std::string>("UNITS");
const auto expect = std::vector<std::string> {
"DAYS", "BARSA", "SM3/SM3", ""
};
BOOST_CHECK_EQUAL_COLLECTIONS(U.begin(), U.end(),
expect.begin(), expect.end());
}
{
const auto& S = smspec.get<int>("STARTDAT");
const auto expect = std::vector<int> {
1, 10, 2019, 12, 34,
56 * 1000 * 1000
};
BOOST_CHECK_EQUAL_COLLECTIONS(S.begin(), S.end(),
expect.begin(), expect.end());
}
}
// ========================= FIELD =======================
{
const auto uconv = SMSpec::UnitConvention::Field;
auto smspec = SMSpec {
rset, fmt, uconv, cartDims, noRestart(),
start(1970, 1, 1, 0, 0, 0)
};
smspec.write(summaryParameters());
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "SMSPEC");
auto smspec = ::Opm::EclIO::EclFile{fname};
{
const auto vectors = smspec.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"INTEHEAD", Opm::EclIO::eclArrType::INTE, 2},
SMSPEC: Temporarily Restore Unconditional RESTART Vector Needed to ensure we create the same summary/specification files as the existing system. We will revert this change once the new system is in place and we can afford to update the reference solutions.
2019-10-09 00:18:41 -05:00
Opm::EclIO::EclFile::EclEntry{"RESTART", Opm::EclIO::eclArrType::CHAR, 9},
Add File Manager Stream for Summary Specification This commit introduces a new OutputStream class for representing the summary specification file (.SMSPEC). The stream is constructed with constant data (output directory, basename, start date &c), and provides a single write() member function that outputs a summary specification. Each call to write rewinds the underlying stream's output position. Class EclOutput grants friendship to the new output stream class in order to support easy stream rewinding. Add a unit test to exercise the new class.
2019-09-30 12:00:54 -05:00
Opm::EclIO::EclFile::EclEntry{"DIMENS", Opm::EclIO::eclArrType::INTE, 6},
Opm::EclIO::EclFile::EclEntry{"KEYWORDS", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"WGNAMES", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"NUMS", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"UNITS", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"STARTDAT", Opm::EclIO::eclArrType::INTE, 6},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
smspec.loadData();
{
const auto& Ih = smspec.get<int>("INTEHEAD");
const auto expect = std::vector<int>{ 2, 100 };
BOOST_CHECK_EQUAL_COLLECTIONS(Ih.begin(), Ih.end(),
expect.begin(),
expect.end());
}
{
const auto& D = smspec.get<int>("DIMENS");
const auto expect = std::vector<int> {
4, 46, 112, 22, 0, -1
};
BOOST_CHECK_EQUAL_COLLECTIONS(D.begin(), D.end(),
expect.begin(), expect.end());
}
{
const auto& K = smspec.get<std::string>("KEYWORDS");
const auto expect = std::vector<std::string> {
"TIME", "WBHP", "GGOR", "BGSAT"
};
BOOST_CHECK_EQUAL_COLLECTIONS(K.begin(), K.end(),
expect.begin(), expect.end());
}
{
const auto& W = smspec.get<std::string>("WGNAMES");
const auto expect = std::vector<std::string> {
":+:+:+:+", "PROD01", "N-PROD", ":+:+:+:+"
};
BOOST_CHECK_EQUAL_COLLECTIONS(W.begin(), W.end(),
expect.begin(), expect.end());
}
{
const auto& N = smspec.get<int>("NUMS");
const auto expect = std::vector<int> { 0, 0, 0, 523 };
BOOST_CHECK_EQUAL_COLLECTIONS(N.begin(), N.end(),
expect.begin(), expect.end());
}
{
const auto& U = smspec.get<std::string>("UNITS");
const auto expect = std::vector<std::string> {
// (!) (!)
"DAYS", "BARSA", "SM3/SM3", ""
};
BOOST_CHECK_EQUAL_COLLECTIONS(U.begin(), U.end(),
expect.begin(), expect.end());
}
{
const auto& S = smspec.get<int>("STARTDAT");
const auto expect = std::vector<int> {
1, 1, 1970, 0, 0, 0
};
BOOST_CHECK_EQUAL_COLLECTIONS(S.begin(), S.end(),
expect.begin(), expect.end());
}
}
// ========================= LAB =======================
{
const auto uconv = SMSpec::UnitConvention::Lab;
auto smspec = SMSpec {
rset, fmt, uconv, cartDims, noRestart(),
start(2018, 12, 24, 17, 0, 0)
};
smspec.write(summaryParameters());
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "SMSPEC");
auto smspec = ::Opm::EclIO::EclFile{fname};
{
const auto vectors = smspec.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"INTEHEAD", Opm::EclIO::eclArrType::INTE, 2},
SMSPEC: Temporarily Restore Unconditional RESTART Vector Needed to ensure we create the same summary/specification files as the existing system. We will revert this change once the new system is in place and we can afford to update the reference solutions.
2019-10-09 00:18:41 -05:00
Opm::EclIO::EclFile::EclEntry{"RESTART", Opm::EclIO::eclArrType::CHAR, 9},
Add File Manager Stream for Summary Specification This commit introduces a new OutputStream class for representing the summary specification file (.SMSPEC). The stream is constructed with constant data (output directory, basename, start date &c), and provides a single write() member function that outputs a summary specification. Each call to write rewinds the underlying stream's output position. Class EclOutput grants friendship to the new output stream class in order to support easy stream rewinding. Add a unit test to exercise the new class.
2019-09-30 12:00:54 -05:00
Opm::EclIO::EclFile::EclEntry{"DIMENS", Opm::EclIO::eclArrType::INTE, 6},
Opm::EclIO::EclFile::EclEntry{"KEYWORDS", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"WGNAMES", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"NUMS", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"UNITS", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"STARTDAT", Opm::EclIO::eclArrType::INTE, 6},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
smspec.loadData();
{
const auto& Ih = smspec.get<int>("INTEHEAD");
const auto expect = std::vector<int>{ 3, 100 };
BOOST_CHECK_EQUAL_COLLECTIONS(Ih.begin(), Ih.end(),
expect.begin(),
expect.end());
}
{
const auto& D = smspec.get<int>("DIMENS");
const auto expect = std::vector<int> {
4, 46, 112, 22, 0, -1
};
BOOST_CHECK_EQUAL_COLLECTIONS(D.begin(), D.end(),
expect.begin(), expect.end());
}
{
const auto& K = smspec.get<std::string>("KEYWORDS");
const auto expect = std::vector<std::string> {
"TIME", "WBHP", "GGOR", "BGSAT"
};
BOOST_CHECK_EQUAL_COLLECTIONS(K.begin(), K.end(),
expect.begin(), expect.end());
}
{
const auto& W = smspec.get<std::string>("WGNAMES");
const auto expect = std::vector<std::string> {
":+:+:+:+", "PROD01", "N-PROD", ":+:+:+:+"
};
BOOST_CHECK_EQUAL_COLLECTIONS(W.begin(), W.end(),
expect.begin(), expect.end());
}
{
const auto& N = smspec.get<int>("NUMS");
const auto expect = std::vector<int> { 0, 0, 0, 523 };
BOOST_CHECK_EQUAL_COLLECTIONS(N.begin(), N.end(),
expect.begin(), expect.end());
}
{
const auto& U = smspec.get<std::string>("UNITS");
const auto expect = std::vector<std::string> {
// (!) (!)
"DAYS", "BARSA", "SM3/SM3", ""
};
BOOST_CHECK_EQUAL_COLLECTIONS(U.begin(), U.end(),
expect.begin(), expect.end());
}
{
const auto& S = smspec.get<int>("STARTDAT");
const auto expect = std::vector<int> {
24, 12, 2018, 17, 0, 0
};
BOOST_CHECK_EQUAL_COLLECTIONS(S.begin(), S.end(),
expect.begin(), expect.end());
}
}
// ========================= PVT-M =======================
{
const auto uconv = SMSpec::UnitConvention::Pvt_M;
auto smspec = SMSpec {
rset, fmt, uconv, cartDims, noRestart(),
start(1983, 1, 1, 1, 2, 3)
};
smspec.write(summaryParameters());
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "SMSPEC");
auto smspec = ::Opm::EclIO::EclFile{fname};
{
const auto vectors = smspec.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"INTEHEAD", Opm::EclIO::eclArrType::INTE, 2},
SMSPEC: Temporarily Restore Unconditional RESTART Vector Needed to ensure we create the same summary/specification files as the existing system. We will revert this change once the new system is in place and we can afford to update the reference solutions.
2019-10-09 00:18:41 -05:00
Opm::EclIO::EclFile::EclEntry{"RESTART", Opm::EclIO::eclArrType::CHAR, 9},
Add File Manager Stream for Summary Specification This commit introduces a new OutputStream class for representing the summary specification file (.SMSPEC). The stream is constructed with constant data (output directory, basename, start date &c), and provides a single write() member function that outputs a summary specification. Each call to write rewinds the underlying stream's output position. Class EclOutput grants friendship to the new output stream class in order to support easy stream rewinding. Add a unit test to exercise the new class.
2019-09-30 12:00:54 -05:00
Opm::EclIO::EclFile::EclEntry{"DIMENS", Opm::EclIO::eclArrType::INTE, 6},
Opm::EclIO::EclFile::EclEntry{"KEYWORDS", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"WGNAMES", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"NUMS", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"UNITS", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"STARTDAT", Opm::EclIO::eclArrType::INTE, 6},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
smspec.loadData();
{
const auto& Ih = smspec.get<int>("INTEHEAD");
const auto expect = std::vector<int>{ 4, 100 };
BOOST_CHECK_EQUAL_COLLECTIONS(Ih.begin(), Ih.end(),
expect.begin(),
expect.end());
}
{
const auto& D = smspec.get<int>("DIMENS");
const auto expect = std::vector<int> {
4, 46, 112, 22, 0, -1
};
BOOST_CHECK_EQUAL_COLLECTIONS(D.begin(), D.end(),
expect.begin(), expect.end());
}
{
const auto& K = smspec.get<std::string>("KEYWORDS");
const auto expect = std::vector<std::string> {
"TIME", "WBHP", "GGOR", "BGSAT"
};
BOOST_CHECK_EQUAL_COLLECTIONS(K.begin(), K.end(),
expect.begin(), expect.end());
}
{
const auto& W = smspec.get<std::string>("WGNAMES");
const auto expect = std::vector<std::string> {
":+:+:+:+", "PROD01", "N-PROD", ":+:+:+:+"
};
BOOST_CHECK_EQUAL_COLLECTIONS(W.begin(), W.end(),
expect.begin(), expect.end());
}
{
const auto& N = smspec.get<int>("NUMS");
const auto expect = std::vector<int> { 0, 0, 0, 523 };
BOOST_CHECK_EQUAL_COLLECTIONS(N.begin(), N.end(),
expect.begin(), expect.end());
}
{
const auto& U = smspec.get<std::string>("UNITS");
const auto expect = std::vector<std::string> {
// (!) (!)
"DAYS", "BARSA", "SM3/SM3", ""
};
BOOST_CHECK_EQUAL_COLLECTIONS(U.begin(), U.end(),
expect.begin(), expect.end());
}
{
const auto& S = smspec.get<int>("STARTDAT");
const auto expect = std::vector<int> {
1, 1, 1983, 1, 2, 3 * 1000 * 1000
};
BOOST_CHECK_EQUAL_COLLECTIONS(S.begin(), S.end(),
expect.begin(), expect.end());
}
}
}
BOOST_AUTO_TEST_CASE(Formatted_Restarted)
{
using SMSpec = ::Opm::EclIO::OutputStream::SummarySpecification;
const auto rset = RSet("CASE");
const auto fmt = ::Opm::EclIO::OutputStream::Formatted{ true };
const auto cartDims = std::array<int,3>{ 46, 112, 22 }; // Norne dimensions
// === Restart root name too long =========================
{
using UConv = SMSpec::UnitConvention;
auto smspec = SMSpec {
rset, fmt, UConv::Pvt_M, cartDims,
restartedSimulationTooLongBasename(),
start(2019, 10, 1, 12, 34, 56)
};
// Should *NOT* write RESTART vector (name too long).
smspec.write(summaryParameters());
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "FSMSPEC");
auto smspec = ::Opm::EclIO::EclFile{fname};
SMSPEC: Temporarily Restore Unconditional RESTART Vector Needed to ensure we create the same summary/specification files as the existing system. We will revert this change once the new system is in place and we can afford to update the reference solutions.
2019-10-09 00:18:41 -05:00
#if 0
Add File Manager Stream for Summary Specification This commit introduces a new OutputStream class for representing the summary specification file (.SMSPEC). The stream is constructed with constant data (output directory, basename, start date &c), and provides a single write() member function that outputs a summary specification. Each call to write rewinds the underlying stream's output position. Class EclOutput grants friendship to the new output stream class in order to support easy stream rewinding. Add a unit test to exercise the new class.
2019-09-30 12:00:54 -05:00
BOOST_CHECK_MESSAGE(! smspec.hasKey("RESTART"),
"SMSPEC file must NOT have RESTART "
"data if root name is too long");
SMSPEC: Temporarily Restore Unconditional RESTART Vector Needed to ensure we create the same summary/specification files as the existing system. We will revert this change once the new system is in place and we can afford to update the reference solutions.
2019-10-09 00:18:41 -05:00
#endif
Add File Manager Stream for Summary Specification This commit introduces a new OutputStream class for representing the summary specification file (.SMSPEC). The stream is constructed with constant data (output directory, basename, start date &c), and provides a single write() member function that outputs a summary specification. Each call to write rewinds the underlying stream's output position. Class EclOutput grants friendship to the new output stream class in order to support easy stream rewinding. Add a unit test to exercise the new class.
2019-09-30 12:00:54 -05:00
}
// ========================= METRIC =======================
{
const auto uconv = SMSpec::UnitConvention::Metric;
auto smspec = SMSpec {
rset, fmt, uconv, cartDims, restartedSimulation(),
start(2019, 10, 1, 12, 34, 56)
};
smspec.write(summaryParameters());
}
{
const auto fname = ::Opm::EclIO::OutputStream::
outputFileName(rset, "FSMSPEC");
auto smspec = ::Opm::EclIO::EclFile{fname};
{
const auto vectors = smspec.getList();
const auto expect_vectors = std::vector<Opm::EclIO::EclFile::EclEntry>{
Opm::EclIO::EclFile::EclEntry{"INTEHEAD", Opm::EclIO::eclArrType::INTE, 2},
Opm::EclIO::EclFile::EclEntry{"RESTART", Opm::EclIO::eclArrType::CHAR, 9},
Opm::EclIO::EclFile::EclEntry{"DIMENS", Opm::EclIO::eclArrType::INTE, 6},
Opm::EclIO::EclFile::EclEntry{"KEYWORDS", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"WGNAMES", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"NUMS", Opm::EclIO::eclArrType::INTE, 4},
Opm::EclIO::EclFile::EclEntry{"UNITS", Opm::EclIO::eclArrType::CHAR, 4},
Opm::EclIO::EclFile::EclEntry{"STARTDAT", Opm::EclIO::eclArrType::INTE, 6},
};
BOOST_CHECK_EQUAL_COLLECTIONS(vectors.begin(), vectors.end(),
expect_vectors.begin(),
expect_vectors.end());
}
smspec.loadData();
{
const auto& Ih = smspec.get<int>("INTEHEAD");
const auto expect = std::vector<int>{ 1, 100 };
BOOST_CHECK_EQUAL_COLLECTIONS(Ih.begin(), Ih.end(),
expect.begin(),
expect.end());
}
{
const auto& R = smspec.get<std::string>("RESTART");
const auto expect = std::vector<std::string> {
"BASE-RUN", "-WITH-LO", "NG-CASE-", // 0 .. 2
"NAME" , "" , "" , // 3 .. 5
"" , "" , "" , // 6 .. 8
};
BOOST_CHECK_EQUAL_COLLECTIONS(R.begin(), R.end(),
expect.begin(), expect.end());
}
{
const auto& D = smspec.get<int>("DIMENS");
const auto expect = std::vector<int> {
4, 46, 112, 22, 0, 123
};
BOOST_CHECK_EQUAL_COLLECTIONS(D.begin(), D.end(),
expect.begin(), expect.end());
}
{
const auto& K = smspec.get<std::string>("KEYWORDS");
const auto expect = std::vector<std::string> {
"TIME", "WBHP", "GGOR", "BGSAT"
};
BOOST_CHECK_EQUAL_COLLECTIONS(K.begin(), K.end(),
expect.begin(), expect.end());
}
{
const auto& W = smspec.get<std::string>("WGNAMES");
const auto expect = std::vector<std::string> {
":+:+:+:+", "PROD01", "N-PROD", ":+:+:+:+"
};
BOOST_CHECK_EQUAL_COLLECTIONS(W.begin(), W.end(),
expect.begin(), expect.end());
}
{
const auto& N = smspec.get<int>("NUMS");
const auto expect = std::vector<int> { 0, 0, 0, 523 };
BOOST_CHECK_EQUAL_COLLECTIONS(N.begin(), N.end(),
expect.begin(), expect.end());
}
{
const auto& U = smspec.get<std::string>("UNITS");
const auto expect = std::vector<std::string> {
"DAYS", "BARSA", "SM3/SM3", ""
};
BOOST_CHECK_EQUAL_COLLECTIONS(U.begin(), U.end(),
expect.begin(), expect.end());
}
{
const auto& S = smspec.get<int>("STARTDAT");
const auto expect = std::vector<int> {
1, 10, 2019, 12, 34,
56 * 1000 * 1000
};
BOOST_CHECK_EQUAL_COLLECTIONS(S.begin(), S.end(),
expect.begin(), expect.end());
}
}
}
BOOST_AUTO_TEST_SUITE_END() // Class_SummarySpecification
Reference in New Issue Copy Permalink